diff --git a/addons/ofxCv/example-contours-following/src/ofApp.h b/addons/ofxCv/example-contours-following/src/ofApp.h index 673d5c0..4c112b5 100644 --- a/addons/ofxCv/example-contours-following/src/ofApp.h +++ b/addons/ofxCv/example-contours-following/src/ofApp.h @@ -6,7 +6,7 @@ class Glow : public ofxCv::RectFollower { protected: ofColor color; - ofVec2f cur, smooth; + ofVec3f cur, smooth; float startedDying; ofPolyline all; public: diff --git a/addons/ofxCv/example-flow-distort-shader/src/MotionAmplifier.h b/addons/ofxCv/example-flow-distort-shader/src/MotionAmplifier.h index 407abd0..2dc2cc3 100644 --- a/addons/ofxCv/example-flow-distort-shader/src/MotionAmplifier.h +++ b/addons/ofxCv/example-flow-distort-shader/src/MotionAmplifier.h @@ -40,7 +40,7 @@ class MotionAmplifier { ySteps = 1+((rescale * h) / stepSize); for(int y = 0; y < ySteps; y++) { for(int x = 0; x < xSteps; x++) { - mesh.addVertex(ofVec2f(x, y) * stepSize / rescale); + mesh.addVertex(ofVec3f(ofVec2f(x, y) * stepSize / rescale)); } } for(int y = 0; y + 1 < ySteps; y++) { @@ -125,4 +125,4 @@ class MotionAmplifier { void setWindowSize(int windowSize) { flow.setWindowSize(windowSize); } -}; \ No newline at end of file +}; diff --git a/addons/ofxCv/libs/ofxCv/include/ofxCv/Calibration.h b/addons/ofxCv/libs/ofxCv/include/ofxCv/Calibration.h index d84bf23..9d4cfd7 100644 --- a/addons/ofxCv/libs/ofxCv/include/ofxCv/Calibration.h +++ b/addons/ofxCv/libs/ofxCv/include/ofxCv/Calibration.h @@ -74,8 +74,8 @@ namespace ofxCv { void undistort(cv::Mat img, int interpolationMode = cv::INTER_LINEAR); void undistort(cv::Mat src, cv::Mat dst, int interpolationMode = cv::INTER_LINEAR); - ofVec2f undistort(ofVec2f& src) const; - void undistort(std::vector& src, std::vector& dst) const; + glm::vec2 undistort(glm::vec2& src) const; + void undistort(std::vector& src, std::vector& dst) const; bool getTransformation(Calibration& dst, cv::Mat& rotation, cv::Mat& translation); diff --git a/addons/ofxCv/libs/ofxCv/include/ofxCv/ContourFinder.h b/addons/ofxCv/libs/ofxCv/include/ofxCv/ContourFinder.h index b269293..7057f56 100644 --- a/addons/ofxCv/libs/ofxCv/include/ofxCv/ContourFinder.h +++ b/addons/ofxCv/libs/ofxCv/include/ofxCv/ContourFinder.h @@ -22,7 +22,6 @@ // to implement in ContourFinder: // holes/no holes // CV_THRESH_OTSU? -// cv::pointPolygonTest - inside, edge, outside // cv::matchShapes - similarity between two contours // cv::estimateRigidTransform? subdivision-based estimation for outline-flow? @@ -53,10 +52,10 @@ namespace ofxCv { ofPolyline& getPolyline(unsigned int i); cv::Rect getBoundingRect(unsigned int i) const; - cv::Point2f getCenter(unsigned int i) const; // center of bounding box (most stable) - cv::Point2f getCentroid(unsigned int i) const; // center of mass (less stable) - cv::Point2f getAverage(unsigned int i) const; // average of contour vertices (least stable) - cv::Vec2f getBalance(unsigned int i) const; // difference between centroid and center + cv::Point2f getCenter(unsigned int i) const; // center of bounding box (most stable) + cv::Point2f getCentroid(unsigned int i) const; // center of mass (less stable) + cv::Point2f getAverage(unsigned int i) const; // average of contour vertices (least stable) + cv::Vec2f getBalance(unsigned int i) const; // difference between centroid and center double getContourArea(unsigned int i) const; double getArcLength(unsigned int i) const; std::vector getConvexHull(unsigned int i) const; @@ -70,6 +69,11 @@ namespace ofxCv { RectTracker& getTracker(); unsigned int getLabel(unsigned int i) const; + + // Performs a point-in-contour test. + // The function determines whether the point is inside a contour, outside, or lies on an edge (or coincides with a vertex) + // The return value is the signed distance (positive stands for inside). + double pointPolygonTest(unsigned int i, cv::Point2f point); void setThreshold(float thresholdValue); void setAutoThreshold(bool autoThreshold); diff --git a/addons/ofxCv/libs/ofxCv/include/ofxCv/Flow.h b/addons/ofxCv/libs/ofxCv/include/ofxCv/Flow.h index 94a752a..603e39e 100644 --- a/addons/ofxCv/libs/ofxCv/include/ofxCv/Flow.h +++ b/addons/ofxCv/libs/ofxCv/include/ofxCv/Flow.h @@ -73,13 +73,13 @@ namespace ofxCv { void setPyramidLevels(int levels); //returns tracking features for this image - std::vector getFeatures(); - std::vector getCurrent(); - std::vector getMotion(); + std::vector getFeatures(); + std::vector getCurrent(); + std::vector getMotion(); // recalculates features to track void resetFeaturesToTrack(); - void setFeaturesToTrack(const std::vector & features); + void setFeaturesToTrack(const std::vector & features); void setFeaturesToTrack(const std::vector & features); void resetFlow(); protected: @@ -129,12 +129,12 @@ namespace ofxCv { void setUseGaussian(bool gaussian); cv::Mat& getFlow(); - ofVec2f getTotalFlow(); - ofVec2f getAverageFlow(); - ofVec2f getFlowOffset(int x, int y); - ofVec2f getFlowPosition(int x, int y); - ofVec2f getTotalFlowInRegion(ofRectangle region); - ofVec2f getAverageFlowInRegion(ofRectangle region); + glm::vec2 getTotalFlow(); + glm::vec2 getAverageFlow(); + glm::vec2 getFlowOffset(int x, int y); + glm::vec2 getFlowPosition(int x, int y); + glm::vec2 getTotalFlowInRegion(ofRectangle region); + glm::vec2 getAverageFlowInRegion(ofRectangle region); //call this if you switch to a new video file to reset internal caches void resetFlow(); diff --git a/addons/ofxCv/libs/ofxCv/include/ofxCv/Helpers.h b/addons/ofxCv/libs/ofxCv/include/ofxCv/Helpers.h index 6919a8c..368d777 100644 --- a/addons/ofxCv/libs/ofxCv/include/ofxCv/Helpers.h +++ b/addons/ofxCv/libs/ofxCv/include/ofxCv/Helpers.h @@ -22,12 +22,12 @@ namespace ofxCv { void drawMat(const cv::Mat& mat, float x, float y, float width, float height); template - ofVec2f findMaxLocation(const T& img) { + glm::vec2 findMaxLocation(const T& img) { cv::Mat mat = toCv(img); double minVal, maxVal; cv::Point minLoc, maxLoc; minMaxLoc(mat, &minVal, &maxVal, &minLoc, &maxLoc); - return ofVec2f(maxLoc.x, maxLoc.y); + return glm::vec2(maxLoc.x, maxLoc.y); } template @@ -165,9 +165,10 @@ namespace ofxCv { cv::Point3_ intersectPointRay(cv::Point3_ point, cv::Point3_ ray) { return ray * (point.dot(ray) / ray.dot(ray)); } - + // morphological thinning, also called skeletonization, strangely missing from opencv // here is a description of the algorithm http://homepages.inf.ed.ac.uk/rbf/HIPR2/thin.htm + // Note: it may produce wrong skeletons for some complex shapes. template void thin(T& img) { cv::Mat mat = toCv(img); @@ -193,7 +194,59 @@ namespace ofxCv { for(int i=0;i + void thin2(T& img) { + + cv::Mat mat = toCv(img); + cv::Mat skel(mat.size(), CV_8UC1, cv::Scalar(0)); + cv::Mat temp; + cv::Mat eroded; + + cv::Mat element = cv::getStructuringElement(cv::MORPH_CROSS, cv::Size(3, 3)); + bool done; + do{ + cv::erode(mat, eroded, element); + cv::dilate(eroded, temp, element); + cv::subtract(mat, temp, temp); + cv::bitwise_or(skel, temp, skel); + eroded.copyTo(mat); + done = (cv::countNonZero(mat) == 0); + } while (!done); + skel.copyTo(mat); + return; + } + // Code for thinning a binary image using Zhang-Suen algorithm. + // Large areas to skeletonize may take considerable amount of time. + // Consider to rescale the input image and then upscale the skeleton for being computed every update() + // Otherwise use ofxCv::thin(), although it may lead to wrong skeletons for some shapes. + // Note: do not call thinningIteration() directly from your ofApp. + void thinningIteration( cv::Mat & img, int iter, cv::Mat & marker ); + template + void thinning(T& img) + { + cv::Mat dst = toCv(img); + dst /= 255; + cv::Mat prev = cv::Mat::zeros(dst.size(), CV_8UC1); + cv::Mat marker = cv::Mat::zeros(dst.size(), CV_8UC1); // Re-uses allocated memory + cv::Mat diff; + + do { + marker.setTo(cv::Scalar(0)); + thinningIteration(dst, 0, marker); + marker.setTo(cv::Scalar(0)); + thinningIteration(dst, 1, marker); + cv::absdiff(dst, prev, diff); + dst.copyTo(prev); + } + while (cv::countNonZero(diff) > 0); + + dst *= 255; + } + // given a vector of lines, this function will find the average angle float weightedAverageAngle(const std::vector& lines); @@ -203,6 +256,7 @@ namespace ofxCv { template float autorotate(const S& src, D& dst, float threshold1 = 50, float threshold2 = 200) { cv::Mat thresh; + cv::Mat srcMat = toCv(src); cv::Canny(src, thresh, threshold1, threshold2); return autorotate(src, thresh, dst); } @@ -223,9 +277,10 @@ namespace ofxCv { rotate(src, dst, rotationAmount); return rotationAmount; } - + + // approximates a polygonal curve(s) with the specified precision. std::vector getConvexPolygon(const std::vector& convexHull, int targetPoints); - + static const ofColor cyanPrint = ofColor::fromHex(0x00abec); static const ofColor magentaPrint = ofColor::fromHex(0xec008c); static const ofColor yellowPrint = ofColor::fromHex(0xffee00); diff --git a/addons/ofxCv/libs/ofxCv/include/ofxCv/Kalman.h b/addons/ofxCv/libs/ofxCv/include/ofxCv/Kalman.h index 774931e..af8d55b 100644 --- a/addons/ofxCv/libs/ofxCv/include/ofxCv/Kalman.h +++ b/addons/ofxCv/libs/ofxCv/include/ofxCv/Kalman.h @@ -14,10 +14,10 @@ namespace ofxCv { // smoothness, rapidness: smaller is more smooth/rapid // bUseAccel: set true to smooth out velocity void init(T smoothness = 0.1, T rapidness = 0.1, bool bUseAccel = false); - void update(const ofVec3f&); - ofVec3f getPrediction(); - ofVec3f getEstimation(); - ofVec3f getVelocity(); + void update(const glm::vec3&); + glm::vec3 getPrediction(); + glm::vec3 getEstimation(); + glm::vec3 getVelocity(); }; typedef KalmanPosition_ KalmanPosition; @@ -25,7 +25,7 @@ namespace ofxCv { // Kalman filter for orientation template class KalmanEuler_ : public KalmanPosition_ { - ofVec3f eulerPrev; // used for finding appropriate dimension + glm::vec3 eulerPrev; // used for finding appropriate dimension public: void init(T smoothness = 0.1, T rapidness = 0.1, bool bUseAccel = false); void update(const ofQuaternion&); diff --git a/addons/ofxCv/libs/ofxCv/include/ofxCv/Tracker.h b/addons/ofxCv/libs/ofxCv/include/ofxCv/Tracker.h index 379ecd9..c3fa4d3 100644 --- a/addons/ofxCv/libs/ofxCv/include/ofxCv/Tracker.h +++ b/addons/ofxCv/libs/ofxCv/include/ofxCv/Tracker.h @@ -79,7 +79,7 @@ namespace ofxCv { :lastSeen(old.lastSeen) ,label(old.label) ,age(old.age) - ,index(-1) + ,index(old.index) ,object(old.object){ } void timeStep(bool visible) { @@ -116,10 +116,12 @@ namespace ofxCv { std::vector currentLabels, previousLabels, newLabels, deadLabels; std::map*> previousLabelMap, currentLabelMap; - unsigned int persistence, curLabel; + unsigned int persistence; + unsigned long long curLabel; float maximumDistance; - unsigned int getNewLabel() { - return curLabel++; + unsigned long long getNewLabel() { + curLabel++; + return curLabel; } public: diff --git a/addons/ofxCv/libs/ofxCv/include/ofxCv/Utilities.h b/addons/ofxCv/libs/ofxCv/include/ofxCv/Utilities.h index e274d07..2a81ac7 100644 --- a/addons/ofxCv/libs/ofxCv/include/ofxCv/Utilities.h +++ b/addons/ofxCv/libs/ofxCv/include/ofxCv/Utilities.h @@ -13,12 +13,13 @@ #include "ofRectangle.h" #include "ofTexture.h" #include "ofPixels.h" - +#include "ofVideoBaseTypes.h" #include "ofVideoPlayer.h" #include "ofVideoGrabber.h" #include "ofPolyline.h" #include "ofVectorMath.h" - +#include "opencv2/imgproc/imgproc_c.h" +#include "opencv2/calib3d/calib3d_c.h" namespace ofxCv { // these functions are for accessing Mat, ofPixels and ofImage consistently. // they're very important for imitate(). @@ -257,12 +258,12 @@ namespace ofxCv { } cv::Mat toCv(ofMesh& mesh); - cv::Point2f toCv(ofVec2f vec); - cv::Point3f toCv(ofVec3f vec); + cv::Point2f toCv(glm::vec2 vec); + cv::Point3f toCv(glm::vec3 vec); cv::Rect toCv(ofRectangle rect); std::vector toCv(const ofPolyline& polyline); - std::vector toCv(const std::vector& points); - std::vector toCv(const std::vector& points); + std::vector toCv(const std::vector& points); + std::vector toCv(const std::vector& points); cv::Scalar toCv(ofColor color); // cross-toolkit, cross-bitdepth copying @@ -318,8 +319,8 @@ namespace ofxCv { } // toOf functions - ofVec2f toOf(cv::Point2f point); - ofVec3f toOf(cv::Point3f point); + glm::vec2 toOf(cv::Point2f point); + glm::vec3 toOf(cv::Point3f point); ofRectangle toOf(cv::Rect rect); ofPolyline toOf(cv::RotatedRect rect); template inline ofPolyline toOf(const std::vector>& contour) { diff --git a/addons/ofxCv/libs/ofxCv/include/ofxCv/Wrappers.h b/addons/ofxCv/libs/ofxCv/include/ofxCv/Wrappers.h index 4aa48b8..b21c217 100644 --- a/addons/ofxCv/libs/ofxCv/include/ofxCv/Wrappers.h +++ b/addons/ofxCv/libs/ofxCv/include/ofxCv/Wrappers.h @@ -74,12 +74,14 @@ cv::name(xMat, yMat, resultMat);\ wrapThree(bitwise_xor); // inverting non-floating point images is a just a bitwise not operation - template void invert(S& src, D& dst) { + template + void invert(S& src, D& dst) { cv::Mat srcMat = toCv(src), dstMat = toCv(dst); bitwise_not(srcMat, dstMat); } - template void invert(SD& srcDst) { + template + void invert(SD& srcDst) { ofxCv::invert(srcDst, srcDst); } @@ -301,23 +303,25 @@ cv::name(xMat, yMat, resultMat);\ if(black != 0) { add(dstMat, cv::Scalar(black), dstMat); } - // copy from dst (unsigned char) to img (int) - for(int y = 0; y < height; y++) { - for(int x = 0; x < width; x++) { - img[y][x] = dstMat.at(y, x); - } - } + // fast copy from dst (unsigned char) to img (int) + for(int y = 0; y < height; ++y) { + const unsigned char* dstPtr = dstMat.ptr(y); + for(int x = 0; x < width; ++x) { + img[y][x] = dstPtr[x]; + } + } ETF etf; etf.init(height, width); etf.set(img); etf.Smooth(halfw, smoothPasses); GetFDoG(img, etf, sigma1, sigma2, tau); - // copy result from img (int) to dst (unsigned char) - for(int y = 0; y < height; y++) { - for(int x = 0; x < width; x++) { - dstMat.at(y, x) = img[y][x]; - } - } + // fast copy result from img (int) to dst (unsigned char) + for(int y = 0; y < height; ++y) { + unsigned char* dstPtr = dstMat.ptr(y); + for(int x = 0; x < width; ++x) { + dstPtr[x] = img[y][x]; + } + } } // dst does not imitate src @@ -379,16 +383,27 @@ cv::name(xMat, yMat, resultMat);\ std::vector convexityDefects(const ofPolyline& polyline); cv::RotatedRect minAreaRect(const ofPolyline& polyline); cv::RotatedRect fitEllipse(const ofPolyline& polyline); - void fitLine(const ofPolyline& polyline, ofVec2f& point, ofVec2f& direction); - - // kind of obscure function, draws filled polygons on the CPU + void fitLine(const ofPolyline& polyline, glm::vec2& point, glm::vec2& direction); + + // Fills a convex polygon. It is much faster than the function fillPoly(). + // It can fill not only convex polygons but any monotonic polygon without self-intersections. + // Apolygon whose contour intersects every horizontal line (scan line) twice at the most + // (though, its top-most and/or the bottom edge could be horizontal). + template + void fillConvexPoly(const std::vector& points, D& dst) { + cv::Mat dstMat = toCv(dst); + dstMat.setTo(cv::Scalar(0)); + cv::fillConvexPoly(dstMat, points, cv::Scalar(255)); // default 8-connected, no shift + } + + // Fills the area bounded by one or more polygons into a texture (image) + // The function can fill complex areas, for example, areas with holes, + // contours with self-intersections (some of their parts), and so forth. template void fillPoly(const std::vector& points, D& dst) { cv::Mat dstMat = toCv(dst); - const cv::Point* ppt[1] = { &(points[0]) }; - int npt[] = { (int) points.size() }; dstMat.setTo(cv::Scalar(0)); - fillPoly(dstMat, ppt, npt, 1, cv::Scalar(255)); + cv::fillPoly(dstMat, points, cv::Scalar(255)); // default 8-connected, no shift } template @@ -439,8 +454,8 @@ cv::name(xMat, yMat, resultMat);\ cv::Mat dstMat = toCv(dst); cv::transpose(srcMat, dstMat); } - + // finds the 3x4 matrix that best describes the (premultiplied) affine transformation between two point clouds - ofMatrix4x4 estimateAffine3D(std::vector& from, std::vector& to, float accuracy = .99); - ofMatrix4x4 estimateAffine3D(std::vector& from, std::vector& to, std::vector& outliers, float accuracy = .99); + ofMatrix4x4 estimateAffine3D(std::vector& from, std::vector& to, float accuracy = .99); + ofMatrix4x4 estimateAffine3D(std::vector& from, std::vector& to, std::vector& outliers, float accuracy = .99); } diff --git a/addons/ofxCv/libs/ofxCv/src/Calibration.cpp b/addons/ofxCv/libs/ofxCv/src/Calibration.cpp index 5a8377b..19b1353 100644 --- a/addons/ofxCv/libs/ofxCv/src/Calibration.cpp +++ b/addons/ofxCv/libs/ofxCv/src/Calibration.cpp @@ -93,7 +93,7 @@ namespace ofxCv { ofLoadIdentityMatrix(); ofMatrix4x4 lookAt; - lookAt.makeLookAtViewMatrix(ofVec3f(0,0,0), ofVec3f(0,0,1), ofVec3f(0,-1,0)); + lookAt.makeLookAtViewMatrix(glm::vec3(0,0,0), glm::vec3(0,0,1), glm::vec3(0,-1,0)); ofMultMatrix(lookAt); } @@ -125,8 +125,8 @@ namespace ofxCv { fs << "distCoeffs" << distCoeffs; fs << "reprojectionError" << reprojectionError; fs << "features" << "["; - for(std::size_t i = 0; i < imagePoints.size(); i++) { - fs << "[:" << imagePoints[i] << "]"; + for(int i = 0; i < (int)imagePoints.size(); i++) { + fs << imagePoints[i]; } fs << "]"; } @@ -157,6 +157,96 @@ namespace ofxCv { } void Calibration::loadLcp(const std::string& filename, float focalLength, int imageWidth, int imageHeight, bool absolute){ + imagePoints.clear(); + + // Load the XML + ofXml xml; + bool loaded = xml.load(ofToDataPath(filename, absolute)); + if(!loaded){ + ofLogError()<<"No camera profile file found at "< bestMatchLtVal)){ + bestMatchLt = i; + bestMatchLtVal = curFocalLength; + bestMatchLtXml = child; + } + if(curFocalLength > focalLength && (bestMatchGt == -1 || curFocalLength < bestMatchGtVal)){ + bestMatchGt = i; + bestMatchGtVal = curFocalLength; + bestMatchGtXml = child; + } + i++; + } + } + + // Get the values out of the profile + float lcpImageWidth; // ImageWidth, pixels + float lcpImageHeight; // ImageLength, pixels + float cropFactor; // SensorFormatFactor, "focal length multiplier", "crop factor" + float principalPointX = 0.5; // ImageXCenter, ratio + float principalPointY = 0.5; // ImageYCenter, ratio + + float interpolation = 0; + if(bestMatchGt != -1) { + interpolation = ofMap(focalLength, bestMatchLtVal, bestMatchGtVal, 0, 1); + } + + lcpImageWidth = bestMatchLtXml.getChild("stCamera:ImageWidth").getFloatValue(); + lcpImageHeight = bestMatchLtXml.getChild("stCamera:ImageLength").getFloatValue(); + cropFactor = bestMatchLtXml.getChild("stCamera:SensorFormatFactor").getFloatValue(); + + float principalPointXLt = bestMatchLtXml.getChild("stCamera:PerspectiveModel").getChild("stCamera:ImageXCenter").getFloatValue(); + float principalPointYLt = bestMatchLtXml.getChild("stCamera:PerspectiveModel").getChild("stCamera:ImageYCenter").getFloatValue(); + float k1Lt = bestMatchLtXml.getChild("stCamera:PerspectiveModel").getChild("stCamera:RadialDistortParam1").getFloatValue(); + float k2Lt = bestMatchLtXml.getChild("stCamera:PerspectiveModel").getChild("stCamera:RadialDistortParam2").getFloatValue(); + float k3Lt = bestMatchLtXml.getChild("stCamera:PerspectiveModel").getChild("stCamera:RadialDistortParam3").getFloatValue(); + + float k1 = k1Lt; + float k2 = k2Lt; + float k3 = k3Lt; + + if(bestMatchGt != -1){ + float principalPointXGt = bestMatchGtXml.getChild("stCamera:PerspectiveModel").getChild("stCamera:ImageXCenter").getFloatValue() ; + float principalPointYGt = bestMatchGtXml.getChild("stCamera:PerspectiveModel").getChild("stCamera:ImageYCenter").getFloatValue(); + float k1Gt = bestMatchGtXml.getChild("stCamera:PerspectiveModel").getChild("stCamera:RadialDistortParam1").getFloatValue(); + float k2Gt = bestMatchGtXml.getChild("stCamera:PerspectiveModel").getChild("stCamera:RadialDistortParam2").getFloatValue(); + float k3Gt = bestMatchGtXml.getChild("stCamera:PerspectiveModel").getChild("stCamera:RadialDistortParam3").getFloatValue(); + + k1 = k1Gt * interpolation + k1Lt * (1-interpolation); + k2 = k2Gt * interpolation + k2Lt * (1-interpolation); + k3 = k3Gt * interpolation + k3Lt * (1-interpolation); + } + + setDistortionCoefficients(k1, k2, k3, 0); + + float sensorWidthMM = 35.0 / cropFactor; + + Intrinsics intrinsics; + cv::Size2f sensorSize(sensorWidthMM, sensorWidthMM * lcpImageHeight / lcpImageWidth); + + if(imageWidth == 0) imageWidth = lcpImageWidth; + if(imageHeight == 0) imageHeight = lcpImageHeight; + cv::Size imageSize(imageWidth,imageHeight); + + intrinsics.setup(focalLength, imageSize, sensorSize); + setIntrinsics(intrinsics); } @@ -322,15 +412,15 @@ namespace ofxCv { remap(src, dst, undistortMapX, undistortMapY, interpolationMode); } - ofVec2f Calibration::undistort(ofVec2f& src) const { - ofVec2f dst; + glm::vec2 Calibration::undistort(glm::vec2& src) const { + glm::vec2 dst; cv::Mat matSrc = cv::Mat(1, 1, CV_32FC2, &src.x); cv::Mat matDst = cv::Mat(1, 1, CV_32FC2, &dst.x);; undistortPoints(matSrc, matDst, distortedIntrinsics.getCameraMatrix(), distCoeffs); return dst; } - void Calibration::undistort(std::vector& src, std::vector& dst) const { + void Calibration::undistort(std::vector& src, std::vector& dst) const { int n = src.size(); dst.resize(n); cv::Mat matSrc = cv::Mat(n, 1, CV_32FC2, &src[0].x); @@ -407,11 +497,11 @@ namespace ofxCv { // this won't work until undistort() is in pixel coordinates /* void Calibration::drawUndistortion() const { - std::vector src, dst; + std::vector src, dst; cv::Point2i divisions(32, 24); for(int y = 0; y < divisions.y; y++) { for(int x = 0; x < divisions.x; x++) { - src.push_back(ofVec2f( + src.push_back(glm::vec2( ofMap(x, -1, divisions.x, 0, addedImageSize.width), ofMap(y, -1, divisions.y, 0, addedImageSize.height))); } @@ -452,7 +542,7 @@ namespace ofxCv { ofMesh mesh; mesh.setMode(OF_PRIMITIVE_LINE_STRIP); for(std::size_t j = 0; j < objectPoints[i].size(); j++) { - ofVec3f cur = toOf(objectPoints[i][j]); + glm::vec3 cur = toOf(objectPoints[i][j]); mesh.addVertex(cur); } mesh.draw(); diff --git a/addons/ofxCv/libs/ofxCv/src/ContourFinder.cpp b/addons/ofxCv/libs/ofxCv/src/ContourFinder.cpp index 2c3766c..425cf17 100644 --- a/addons/ofxCv/libs/ofxCv/src/ContourFinder.cpp +++ b/addons/ofxCv/libs/ofxCv/src/ContourFinder.cpp @@ -276,6 +276,10 @@ namespace ofxCv { return tracker; } + double ContourFinder::pointPolygonTest(unsigned int i, cv::Point2f point) { + return cv::pointPolygonTest(contours[i], point, true); + } + void ContourFinder::setAutoThreshold(bool autoThreshold) { this->autoThreshold = autoThreshold; } diff --git a/addons/ofxCv/libs/ofxCv/src/Distance.cpp b/addons/ofxCv/libs/ofxCv/src/Distance.cpp index 0cfef64..f126c4f 100644 --- a/addons/ofxCv/libs/ofxCv/src/Distance.cpp +++ b/addons/ofxCv/libs/ofxCv/src/Distance.cpp @@ -16,7 +16,7 @@ namespace ofxCv { }; const std::string& mostRepresentative(const std::vector& strs) { - int bestScore=0; + int bestScore; int besti; int n = strs.size(); for(int i = 0; i < n; i++) { diff --git a/addons/ofxCv/libs/ofxCv/src/Flow.cpp b/addons/ofxCv/libs/ofxCv/src/Flow.cpp index c91ad20..fa5d021 100644 --- a/addons/ofxCv/libs/ofxCv/src/Flow.cpp +++ b/addons/ofxCv/libs/ofxCv/src/Flow.cpp @@ -101,12 +101,16 @@ namespace ofxCv { if(!nextPts.empty() || calcFeaturesNextFrame){ if(calcFeaturesNextFrame){ calcFeaturesToTrack(prevPts, next); + if (prevPts.empty()) { + nextPts.clear(); + return; + } calcFeaturesNextFrame = false; }else{ swap(prevPts, nextPts); } nextPts.clear(); - + #if CV_MAJOR_VERSION>=2 && (CV_MINOR_VERSION>4 || (CV_MINOR_VERSION==4 && CV_SUBMINOR_VERSION>=1)) if (prevPyramid.empty()) { buildOpticalFlowPyramid(prev,prevPyramid,cv::Size(windowSize, windowSize),10); @@ -152,7 +156,7 @@ namespace ofxCv { calcFeaturesNextFrame=true; } - void FlowPyrLK::setFeaturesToTrack(const std::vector & features){ + void FlowPyrLK::setFeaturesToTrack(const std::vector & features){ nextPts.resize(features.size()); for(std::size_t i=0;i FlowPyrLK::getFeatures(){ + std::vector FlowPyrLK::getFeatures(){ ofPolyline poly = toOf(prevPts); return poly.getVertices(); } - std::vector FlowPyrLK::getCurrent(){ - std::vector ret; + std::vector FlowPyrLK::getCurrent(){ + std::vector ret; for(std::size_t i = 0; i < nextPts.size(); i++) { if(status[i]){ ret.push_back(toOf(nextPts[i])); @@ -180,8 +184,8 @@ namespace ofxCv { return ret; } - std::vector FlowPyrLK::getMotion(){ - std::vector ret(prevPts.size()); + std::vector FlowPyrLK::getMotion(){ + std::vector ret; for(std::size_t i = 0; i < prevPts.size(); i++) { if(status[i]){ ret.push_back(toOf(nextPts[i])-toOf(prevPts[i])); @@ -191,8 +195,8 @@ namespace ofxCv { } void FlowPyrLK::drawFlow(ofRectangle rect) { - ofVec2f offset(rect.x,rect.y); - ofVec2f scale(rect.width/getWidth(),rect.height/getHeight()); + glm::vec2 offset(rect.x,rect.y); + glm::vec2 scale(rect.width/getWidth(),rect.height/getHeight()); for(std::size_t i = 0; i < prevPts.size(); i++) { if(status[i]){ ofDrawLine(toOf(prevPts[i])*scale+offset, toOf(nextPts[i])*scale+offset); @@ -277,28 +281,28 @@ namespace ofxCv { } return flow; } - ofVec2f FlowFarneback::getFlowOffset(int x, int y){ + glm::vec2 FlowFarneback::getFlowOffset(int x, int y){ if(!hasFlow){ - return ofVec2f(0, 0); + return glm::vec2(0, 0); } const Vec2f& vec = flow.at(y, x); - return ofVec2f(vec[0], vec[1]); + return glm::vec2(vec[0], vec[1]); } - ofVec2f FlowFarneback::getFlowPosition(int x, int y){ + glm::vec2 FlowFarneback::getFlowPosition(int x, int y){ if(!hasFlow){ - return ofVec2f(0, 0); + return glm::vec2(0, 0); } const Vec2f& vec = flow.at(y, x); - return ofVec2f(x + vec[0], y + vec[1]); + return glm::vec2(x + vec[0], y + vec[1]); } - ofVec2f FlowFarneback::getTotalFlow(){ + glm::vec2 FlowFarneback::getTotalFlow(){ return getTotalFlowInRegion(ofRectangle(0,0,flow.cols, flow.rows)); } - ofVec2f FlowFarneback::getAverageFlow(){ + glm::vec2 FlowFarneback::getAverageFlow(){ return getAverageFlowInRegion(ofRectangle(0,0,flow.cols,flow.rows)); } - ofVec2f FlowFarneback::getAverageFlowInRegion(ofRectangle rect){ + glm::vec2 FlowFarneback::getAverageFlowInRegion(ofRectangle rect){ float area = rect.getArea(); if (area > 0) @@ -307,29 +311,29 @@ namespace ofxCv { } else { - return ofVec2f(0, 0); + return glm::vec2(0, 0); } } - ofVec2f FlowFarneback::getTotalFlowInRegion(ofRectangle region){ + glm::vec2 FlowFarneback::getTotalFlowInRegion(ofRectangle region){ if(!hasFlow){ - return ofVec2f(0, 0); + return glm::vec2(0, 0); } const Scalar& sc = sum(flow(toCv(region))); - return ofVec2f(sc[0], sc[1]); + return glm::vec2(sc[0], sc[1]); } void FlowFarneback::drawFlow(ofRectangle rect){ if(!hasFlow){ return; } - ofVec2f offset(rect.x,rect.y); - ofVec2f scale(rect.width/flow.cols, rect.height/flow.rows); + glm::vec2 offset(rect.x,rect.y); + glm::vec2 scale(rect.width/flow.cols, rect.height/flow.rows); int stepSize = 4; //TODO: make class-level parameteric for(int y = 0; y < flow.rows; y += stepSize) { for(int x = 0; x < flow.cols; x += stepSize) { - ofVec2f cur = ofVec2f(x, y) * scale + offset; + glm::vec2 cur = glm::vec2(x, y) * scale + offset; ofDrawLine(cur, getFlowPosition(x, y) * scale + offset); } } diff --git a/addons/ofxCv/libs/ofxCv/src/Helpers.cpp b/addons/ofxCv/libs/ofxCv/src/Helpers.cpp index 394c4ca..be6c7b4 100644 --- a/addons/ofxCv/libs/ofxCv/src/Helpers.cpp +++ b/addons/ofxCv/libs/ofxCv/src/Helpers.cpp @@ -73,13 +73,13 @@ namespace ofxCv { float weightedAverageAngle(const std::vector& lines) { float angleSum = 0; - ofVec2f start, end; + glm::vec2 start, end; float weights = 0; for(int i = 0; i < lines.size(); i++) { - start = ofVec2f(lines[i][0], lines[i][1]); - end = ofVec2f(lines[i][2], lines[i][3]); - ofVec2f diff = end - start; - float length = diff.length(); + start = glm::vec2(lines[i][0], lines[i][1]); + end = glm::vec2(lines[i][2], lines[i][3]); + glm::vec2 diff = end - start; + float length = glm::length(diff); float weight = length * length; float angle = atan2f(diff.y, diff.x); angleSum += angle * weight; @@ -87,7 +87,7 @@ namespace ofxCv { } return angleSum / weights; } - + std::vector getConvexPolygon(const std::vector& convexHull, int targetPoints) { std::vector result = convexHull; @@ -121,4 +121,98 @@ namespace ofxCv { return result; } + + // Code for thinning a binary image using Zhang-Suen algorithm. + // Normally you wouldn't call this function directly from your code. + // + // im Binary image with range = [0,1] + // iter 0=even, 1=odd + // + // Author: Nash (nash [at] opencv-code [dot] com) + // https://github.com/bsdnoobz/zhang-suen-thinning + void thinningIteration( cv::Mat & img, int iter, cv::Mat & marker ) + { + CV_Assert(img.channels() == 1); + CV_Assert(img.depth() != sizeof(uchar)); + CV_Assert(img.rows > 3 && img.cols > 3); + + int nRows = img.rows; + int nCols = img.cols; + + if (img.isContinuous()) { + nCols *= nRows; + nRows = 1; + } + + int x, y; + uchar *pAbove; + uchar *pCurr; + uchar *pBelow; + uchar *nw, *no, *ne; // north (pAbove) + uchar *we, *me, *ea; + uchar *sw, *so, *se; // south (pBelow) + + uchar *pDst; + + // initialize row pointers + pAbove = NULL; + pCurr = img.ptr(0); + pBelow = img.ptr(1); + + for (y = 1; y < img.rows-1; ++y) { + // shift the rows up by one + pAbove = pCurr; + pCurr = pBelow; + pBelow = img.ptr(y+1); + + pDst = marker.ptr(y); + + // initialize col pointers + no = &(pAbove[0]); + ne = &(pAbove[1]); + me = &(pCurr[0]); + ea = &(pCurr[1]); + so = &(pBelow[0]); + se = &(pBelow[1]); + + for (x = 1; x < img.cols-1; ++x) { + // shift col pointers left by one (scan left to right) + nw = no; + no = ne; + ne = &(pAbove[x+1]); + we = me; + me = ea; + ea = &(pCurr[x+1]); + sw = so; + so = se; + se = &(pBelow[x+1]); + + // @valillon + // Beyond this point the original Nash's code used an unified conditional at the end + // Intermediate conditionals speeds the process up (depending on the image to be thinned). + if (*me == 0) continue; // do not thin already zeroed pixels + + int A = (*no == 0 && *ne == 1) + (*ne == 0 && *ea == 1) + + (*ea == 0 && *se == 1) + (*se == 0 && *so == 1) + + (*so == 0 && *sw == 1) + (*sw == 0 && *we == 1) + + (*we == 0 && *nw == 1) + (*nw == 0 && *no == 1); + if (A != 1) continue; + + int B = *no + *ne + *ea + *se + *so + *sw + *we + *nw; + if (B < 2 || B > 6) continue; + + int m1 = iter == 0 ? (*no * *ea * *so) : (*no * *ea * *we); + if (m1) continue; + + int m2 = iter == 0 ? (*ea * *so * *we) : (*no * *so * *we); + if (m2) continue; + + // if (A == 1 && (B >= 2 && B <= 6) && m1 == 0 && m2 == 0) + pDst[x] = 1; + } + } + + img &= ~marker; + } + } diff --git a/addons/ofxCv/libs/ofxCv/src/Kalman.cpp b/addons/ofxCv/libs/ofxCv/src/Kalman.cpp index 7b9a8da..082a3f6 100644 --- a/addons/ofxCv/libs/ofxCv/src/Kalman.cpp +++ b/addons/ofxCv/libs/ofxCv/src/Kalman.cpp @@ -48,7 +48,7 @@ namespace ofxCv { } template - void KalmanPosition_::update(const ofVec3f& p) { + void KalmanPosition_::update(const glm::vec3& p) { // First predict, to update the internal statePre variable prediction = KF.predict(); @@ -60,21 +60,21 @@ namespace ofxCv { } template - ofVec3f KalmanPosition_::getPrediction() + glm::vec3 KalmanPosition_::getPrediction() { - return ofVec3f(prediction(0), prediction(1), prediction(2)); + return glm::vec3(prediction(0), prediction(1), prediction(2)); } template - ofVec3f KalmanPosition_::getEstimation() + glm::vec3 KalmanPosition_::getEstimation() { - return ofVec3f(estimated(0), estimated(1), estimated(2)); + return glm::vec3(estimated(0), estimated(1), estimated(2)); } template - ofVec3f KalmanPosition_::getVelocity() + glm::vec3 KalmanPosition_::getVelocity() { - return ofVec3f(estimated(3), estimated(4), estimated(5)); + return glm::vec3(estimated(3), estimated(4), estimated(5)); } template class KalmanPosition_; @@ -90,7 +90,7 @@ namespace ofxCv { template void KalmanEuler_::update(const ofQuaternion& q) { // warp to appropriate dimension - ofVec3f euler = q.getEuler(); + glm::vec3 euler = q.getEuler(); for( int i = 0; i < 3; i++ ) { float rev = floorf((eulerPrev[i] + 180) / 360.f) * 360; euler[i] += rev; @@ -107,9 +107,9 @@ namespace ofxCv { { ofQuaternion q; q.set(0, 0, 0, 1); - ofVec3f euler = KalmanPosition_::getPrediction(); + glm::vec3 euler = KalmanPosition_::getPrediction(); - q.makeRotate(euler.x, ofVec3f(1, 0, 0), euler.z, ofVec3f(0, 0, 1), euler.y, ofVec3f(0, 1, 0)); + q.makeRotate(euler.x, glm::vec3(1, 0, 0), euler.z, glm::vec3(0, 0, 1), euler.y, glm::vec3(0, 1, 0)); return q; } @@ -119,9 +119,9 @@ namespace ofxCv { { ofQuaternion q; q.set(0, 0, 0, 1); - ofVec3f euler = KalmanPosition_::getEstimation(); + glm::vec3 euler = KalmanPosition_::getEstimation(); - q.makeRotate(euler.x, ofVec3f(1, 0, 0), euler.z, ofVec3f(0, 0, 1), euler.y, ofVec3f(0, 1, 0)); + q.makeRotate(euler.x, glm::vec3(1, 0, 0), euler.z, glm::vec3(0, 0, 1), euler.y, glm::vec3(0, 1, 0)); return q; } diff --git a/addons/ofxCv/libs/ofxCv/src/Utilities.cpp b/addons/ofxCv/libs/ofxCv/src/Utilities.cpp index 69c667c..89b9f60 100644 --- a/addons/ofxCv/libs/ofxCv/src/Utilities.cpp +++ b/addons/ofxCv/libs/ofxCv/src/Utilities.cpp @@ -1,4 +1,7 @@ #include "ofxCv/Utilities.h" + +#include "ofGraphicsBaseTypes.h" +#include "ofMath.h" #include "ofMesh.h" @@ -20,11 +23,11 @@ namespace ofxCv { return mat.clone(); } - Point2f toCv(ofVec2f vec) { + Point2f toCv(glm::vec2 vec) { return Point2f(vec.x, vec.y); } - Point3f toCv(ofVec3f vec) { + Point3f toCv(glm::vec3 vec) { return Point3f(vec.x, vec.y, vec.z); } @@ -33,7 +36,7 @@ namespace ofxCv { } Mat toCv(ofMesh& mesh) { - std::vector& vertices = mesh.getVertices(); + std::vector& vertices = mesh.getVertices(); return Mat(1, vertices.size(), CV_32FC3, &vertices[0]); } @@ -47,7 +50,7 @@ namespace ofxCv { return contour; } - std::vector toCv(const std::vector& points) { + std::vector toCv(const std::vector& points) { std::vector out(points.size()); for(int i = 0; i < points.size(); i++) { out[i].x = points[i].x; @@ -56,7 +59,7 @@ namespace ofxCv { return out; } - std::vector toCv(const std::vector& points) { + std::vector toCv(const std::vector& points) { std::vector out(points.size()); for(int i = 0; i < points.size(); i++) { out[i].x = points[i].x; @@ -70,12 +73,12 @@ namespace ofxCv { return Scalar(color.r, color.g, color.b, color.a); } - ofVec2f toOf(Point2f point) { - return ofVec2f(point.x, point.y); + glm::vec2 toOf(Point2f point) { + return glm::vec2(point.x, point.y); } - ofVec3f toOf(Point3f point) { - return ofVec3f(point.x, point.y, point.z); + glm::vec3 toOf(Point3f point) { + return glm::vec3(point.x, point.y, point.z); } ofRectangle toOf(cv::Rect rect) { diff --git a/addons/ofxCv/libs/ofxCv/src/Wrappers.cpp b/addons/ofxCv/libs/ofxCv/src/Wrappers.cpp index 2596829..c3506c9 100644 --- a/addons/ofxCv/libs/ofxCv/src/Wrappers.cpp +++ b/addons/ofxCv/libs/ofxCv/src/Wrappers.cpp @@ -90,15 +90,15 @@ namespace ofxCv { return fitEllipse(Mat(toCv(polyline))); } - void fitLine(const ofPolyline& polyline, ofVec2f& point, ofVec2f& direction) { + void fitLine(const ofPolyline& polyline, glm::vec2& point, glm::vec2& direction) { Vec4f line; fitLine(Mat(toCv(polyline)), line, CV_DIST_L2, 0, .01, .01); - direction = ofVec2f(line[0], line[1]); - point = ofVec2f(line[2], line[3]); + direction = glm::vec2(line[0], line[1]); + point = glm::vec2(line[2], line[3]); } - ofMatrix4x4 estimateAffine3D(std::vector& from, std::vector& to, float accuracy) { + ofMatrix4x4 estimateAffine3D(std::vector& from, std::vector& to, float accuracy) { if(from.size() != to.size() || from.size() == 0 || to.size() == 0) { return ofMatrix4x4(); } @@ -106,7 +106,7 @@ namespace ofxCv { return estimateAffine3D(from, to, outliers, accuracy); } - ofMatrix4x4 estimateAffine3D(std::vector& from, std::vector& to, std::vector& outliers, float accuracy) { + ofMatrix4x4 estimateAffine3D(std::vector& from, std::vector& to, std::vector& outliers, float accuracy) { Mat fromMat(1, from.size(), CV_32FC3, &from[0]); Mat toMat(1, to.size(), CV_32FC3, &to[0]); Mat affine; diff --git a/addons/ofxGui/examples/.appveyor.yml b/addons/ofxGui/examples/.appveyor.yml new file mode 100644 index 0000000..a754a48 --- /dev/null +++ b/addons/ofxGui/examples/.appveyor.yml @@ -0,0 +1,39 @@ +version: 1.0.{build} +os: Visual Studio 2015 RC + +environment: + global: + APPVEYOR_OS_NAME: windows + matrix: + #MSYS2 Building + - platform: x86 + BUILDER: MSYS2 + + #VisualStudio Building + - platform: x86 + BUILDER : VS + BITS: 32 + - platform: x64 + BUILDER : VS + BITS: 64 + +configuration: Debug +shallow_clone: true +clone_depth: 10 +init: +- set MSYS2_PATH=c:\msys64 +- set CHERE_INVOKING=1 +- if "%BUILDER%_%PLATFORM%"=="MSYS2_x86" set MSYSTEM=MINGW32 +- if "%BUILDER%_%PLATFORM%"=="MSYS2_x64" set MSYSTEM=MINGW64 +- if "%BUILDER%"=="VS" set PATH=C:\Program Files (x86)\MSBuild\14.0\Bin;%PATH% + +install: +- cd .. +- git clone --depth=1 --branch=master https://github.com/openframeworks/openFrameworks +- call openFrameworks\scripts\ci\addons\install.cmd + +build_script: +- cd %OF_PATH% +- scripts\ci\addons\build.cmd + + diff --git a/addons/ofxGui/examples/.travis.yml b/addons/ofxGui/examples/.travis.yml new file mode 100644 index 0000000..e820405 --- /dev/null +++ b/addons/ofxGui/examples/.travis.yml @@ -0,0 +1,200 @@ +# This file allows testing your addon using travis CI servers to use it you'll need to +# create an account in travis.org and enable your addon there. +# +# By default it will test linux 64bit and osx against the master and stable OF branches. +# Other platforms can be enabled by uncommenting the corresponding sections. +# +# If any extra install is needed to use the addon it can be included in the corresponding +# install script in: +# +# scripts/ci/$TARGET/install.sh +# + + + +language: c++ +compiler: gcc +sudo: true +matrix: + include: + # fully specify builds, include can't dynamically expand matrix entries + # relative order of sudo and env is important so that addons: is recognized + +# Linux 64bit, OF master + - os: linux + dist: trusty + sudo: required + env: TARGET="linux64" OF_BRANCH="master" + addons: + apt: + sources: + - ubuntu-toolchain-r-test + packages: + - gcc-4.9 + - g++-4.9 + - gdb + +# Linux 64bit, OF stable: Not supported yet +# - os: linux +# dist: trusty +# sudo: required +# env: TARGET="linux64" OF_BRANCH="stable" +# addons: +# apt: +# sources: +# - ubuntu-toolchain-r-test +# packages: +# - gcc-4.9 +# - g++-4.9 +# - gdb + +# OSX, OF master + - os: osx + osx_image: xcode8 + compiler: clang + env: TARGET="osx" OF_BRANCH="master" + +# OSX, OF stable: Not supported yet +# - os: osx +# osx_image: xcode8 +# compiler: clang +# env: TARGET="osx" OF_BRANCH="stable" + +# Linux ARM6, OF master: Uncomment following lines to enable +# - os: linux +# sudo: required +# dist: trusty +# env: TARGET="linuxarmv6l" OF_BRANCH="master" + + +# Linux ARM6, OF stable: Not supported yet +# - os: linux +# sudo: required +# dist: trusty +# env: TARGET="linuxarmv6l" OF_BRANCH="stable" + +# Linux ARM7, OF master: Uncomment following lines to enable +# - os: linux +# sudo: false +# env: TARGET="linuxarmv7l" OF_BRANCH="master" +# cache: +# directories: +# - ~/rpi2_toolchain +# - ~/firmware-master +# - ~/archlinux + +# Linux ARM7, OF stable: Not supported yet +# - os: linux +# sudo: false +# env: TARGET="linuxarmv7l" OF_BRANCH="stable" +# cache: +# directories: +# - ~/rpi2_toolchain +# - ~/firmware-master +# - ~/archlinux + + +# Emscripten, OF master: Uncomment following lines to enable +# - os: linux +# sudo: false +# env: TARGET="emscripten" OF_BRANCH="master" +# addons: +# apt: +# sources: +# - ubuntu-toolchain-r-test +# packages: +# - libstdc++6 + + +# Emscripten, OF stable: Not supported yet +# - os: linux +# sudo: false +# env: TARGET="emscripten" OF_BRANCH="stable" +# addons: +# apt: +# sources: +# - ubuntu-toolchain-r-test +# packages: +# - libstdc++6 + + +# iOS, OF master: Not supported yet +# - os: osx +# osx_image: xcode8 +# compiler: clang +# env: TARGET="ios" OF_BRANCH="master" + + +# iOS, OF stable: Not supported yet +# - os: osx +# osx_image: xcode8 +# compiler: clang +# env: TARGET="ios" OF_BRANCH="stable" + + +# tvOS, OF master: Not supported yet +# - os: osx +# osx_image: xcode8 +# compiler: clang +# env: TARGET="tvos" OF_BRANCH="master" + + +# tvOS, OF stable: Not supported yet +# - os: osx +# osx_image: xcode8 +# compiler: clang +# env: TARGET="tvos" OF_BRANCH="stable" + + +# Android armv7, OF master: Uncomment following lines to enable +# - os: linux +# sudo: false +# env: TARGET="android" OPT="armv7" OF_BRANCH="master" +# cache: +# directories: +# - ~/android-ndk-r12b + + +# Android armv7, OF stable: Not supported yet +# - os: linux +# sudo: false +# env: TARGET="android" OPT="armv7" OF_BRANCH="stable" +# cache: +# directories: +# - ~/android-ndk-r12b + + +# Android x86, OF master: Uncomment following lines to enable +# - os: linux +# sudo: false +# env: TARGET="android" OPT="x86" OF_BRANCH="master" +# cache: +# directories: +# - ~/android-ndk-r12b + + +# Android x86, OF stable: Not supported yet +# - os: linux +# sudo: false +# env: TARGET="android" OPT="x86" OF_BRANCH="stable" +# cache: +# directories: +# - ~/android-ndk-r12b + + + # Exclude the default build that would otherwise be generated + # see https://github.com/travis-ci/travis-ci/issues/1228 + exclude: + - compiler: gcc + +install: + - cd ~ + - git clone --depth=1 --branch=$OF_BRANCH https://github.com/openframeworks/openFrameworks + - cd openFrameworks + - scripts/ci/addons/install.sh + +script: + - scripts/ci/addons/build.sh + +git: + depth: 10 diff --git a/addons/ofxGui/examples/LICENSE b/addons/ofxGui/examples/LICENSE new file mode 100644 index 0000000..2142096 --- /dev/null +++ b/addons/ofxGui/examples/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2017 Deborah Schmidt + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/addons/ofxGui/examples/README.md b/addons/ofxGui/examples/README.md new file mode 100644 index 0000000..2252008 --- /dev/null +++ b/addons/ofxGui/examples/README.md @@ -0,0 +1,512 @@ +# ofxGuiExtended + +[![Build status](https://travis-ci.org/frauzufall/ofxGuiExtended.svg?branch=master)](https://travis-ci.org/frauzufall/ofxGuiExtended) + +[![Build status](https://ci.appveyor.com/api/projects/status/ptbke4elwusby0rd?svg=true)](https://ci.appveyor.com/project/frauzufall/ofxguiextended) + +This is a gui addon displaying `ofParameter` based data with a focus on simplicity and extensibility. It can be configured using JSON. + +![exampleAdvancedGui](exampleAdvancedGui/advancedGuiExample.png) + +![exampleThemes](exampleThemes/exampleThemes.png) + +![exampleLayout](exampleLayout/layoutExample.png) + +## System requirements +Since ofJson just recently got added to openFrameworks, you have to use the current master branch in order for it to work. Please report an issue if ofxGuiExtended is not compatible with the latest openFrameworks version. + +This addon is tested on Ubuntu 16.04 64bit. Please tell me if it runs on other systems or if you have issues. + +## Versions and dependencies +This addon was first built as an extension for the OF core ofxGui addon. You can download this version [here](https://github.com/frauzufall/ofxGuiExtended/releases/tag/v0.1). + +This is the standalone ofxGuiExtended version build from ofxGui. It also contains a minimized version of [ofxDOM](https://github.com/bakercp/ofxDOM). It does not depend on other addons. + +## Extensions +This addon is built with the best intentions to be as extensible as possible. There are addons working with ofxGuiExtended: + - [ofxSortableList](https://github.com/frauzufall/ofxSortableList) + - [ofxMasterSlaveControl](https://github.com/frauzufall/ofxMasterSlaveControl) + - [ofx2DMapping](https://github.com/frauzufall/ofx2DMapping) *compatible version is not online yet* + + +Please tell me if you wrote something compatible, I will add it to the list. Check out the bottom of this page for contribution and implementation notes. + +## Usage + +### Basics +Just initialize some parameters and pass them on to the addon. It will create a panel showing the parameters. Have a look at [this example](example) to see it in action. +```c++ +//ofApp.h + +#include "ofxGuiExtended" + +//.. +ofxGui gui; + +ofParameter moving; +ofParameter speed; +ofParameter rotation; +//.. +``` +```c++ +//ofApp.cpp + +void setup(){ + + // initialize the parameters you want to work with + moving.set("moving", true); + speed.set("speed", 0.5, 0, 1); + rotation.set("rotation", 0, 0, 360); + + // add them to the gui + gui.add(moving, speed, rotation); +} +``` + +### Using containers +A container is just a collection of other elements, a group derives from it and has a header to minimize and maximize itself and a panel has a header to move it around and save and load element states. + +![example of different container types](exampleAdvancedGui/containers.png) + +In the last example, the panel got created automatically, but you can also create containers yourself. +```c++ +ofxGuiPanel* panel = gui.addPanel(); +panel->add(..); +``` + +In the same way you can add other containers to existing containers: +```c++ +ofxGuiGroup* group = panel->addGroup(); +group->add(..); +``` + +Some parameters automatically create groups if you add them to the gui: + +```c++ +ofParameter position; +ofParameter color; + +gui.add(position, color); +``` + +### Adding controls +Controls get automatically created whenever you add a parameter to the GUI. +```c++ +panel->add(moving); // creates a toggle +panel->add(speed); // creates a slider +panel->add(rotation); // creates a slider +``` +You can also add a specific control (this is very useful if you implement your own control classes): +```c++ +panel->add("labeltext"); +panel->add(/* contructor parameters of control element class */); +``` + +### Setting attributes +There are attributes that you can set for each element. You will find these attributes in the description of the classes beneath the examples on this page. +#### Styling individual items via ofJson +When adding parameters or creating containers, you can append attributes with `ofJson`. +```c++ +ofJson panelConfig = {{"background-color", "#ff0000"}, {"padding", 10}}; +ofJson itemConfig = {{"fill-color", "rgba(0,255,255,0.5)"}}; + +ofxGuiPanel* panel = gui.addPanel("panel title", panelConfig); +panel->add(moving, itemConfig); +panel->add(speed, itemConfig); +panel->add(rotation, itemConfig); +``` + +#### Styling individual items via JSON file +The goal is to set attributes in an external file to set style and layout without recompiling. This is not yet implemented but most of the work is done, stay tuned. + +#### Styling items by type via Theme +In a theme you can define attributes for the different element class types. Have a look at [this example](exampleThemes). Also read the class descriptions in the next chapters of this page for the class type names and the attributes that you can set for each class. + +This is how you load a theme: +```c++ +panel = gui.addPanel(); +panel->loadTheme("theme_light.json"); +``` + +A theme file could look like this: +```json +//theme_light.json +{ + "light": { + "base": { + "background-color": "rgba(255,255,255,0.4)", + "fill-color": "rgba(255,255,255,1)", + "border-width": 0, + "padding": 0, + "border-color": "rgb(0,0,0)", + "margin": 3, + "text-color": "#000000", + "text-padding": 3 + }, + + "group": { + "background-color": "rgba(155,155,155,0.6)", + "border-color": "#ffffff", + "padding": 1, + "margin-left": 20, + "border-width": 1 + }, + + "group-header": { + "background-color": "#2da1e3", + "text-color": "#ffffff" + } + } +} +``` + +### Using layouts +The default layout lets you align elements in containers horizontally and vertically. The layout can be changed. ofxDOMFlexBoxLayout was implemented for more complex layout scenarios. If you want to use it, you have to set it up before adding elements to the GUI: +```c++ +gui.setupFlexBoxLayout(); +``` +Have a look at the layout attribute descriptions later in this file for details and check out [this flexbox layout example](exampleLayout). + +If you want to implement your own layout class, you can use it by adding it to your GUI like this (assuming `ofxDOMLayoutCustom` is your layout class): +```c++ +gui.setup(); +``` + +## Controls + +### `ofxGuiElement` + - Derived from `DOM::Element`. + - Base class of all other gui elements. + - class type name for JSON theme: `base` + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
AttributeValueExampleDescription
show-namebooltrueDisplay or hide the name of the element.
background-color
border-color
fill-color
text-color
header-background-color		string"#ff0000"
"rgb(255,0,0)"
"rgba(255,0,0,0.5)"
"transparent"		Colors of the element.
border-widthfloat1Width of the border.
border-radiusfloat3Radius of the border (not implemented for all controls yet).
text-alignstringleft
right
center		Sets the text alignment. *Currently only affecting fullsize toggles.*
font-familystring"fonts/UbuntuMono-B.ttf"Sets the font family and changes the font rendering from bitmap font to TTF. Font path is relative to bin/data.
font-sizefloat10 (default)Sets the font size. Only works if you set a font family, the default bitmap font has a fixed size. The elements can't currently update their size according to the font size so if you set it high you have to adjust the element size yourself in order to prevent overlapping.
marginfloat
string		10
"10 20"
"10 20 30"
"10 20 30 40"		Set the margin of the element. Analog to CSS margin.
margin-top
margin-right
margin-bottom
margin-left		float10Set the margin for the specified side of the element.
paddingfloat`
`string		10
"10 20"
"10 20 30"
"10 20 30 40"		Set the padding of the element. Analog to CSS padding. Padding currently only has an effect on containers, not on controls.
padding-top
padding-right
padding-bottom
padding-left		float10Set the padding for the specified side of the element.
+ + +### `ofxGuiToggle` + - Derived from `ofxGuiElement`. + - Default control type for `ofParameter`. + - class type name for JSON theme: `toggle` + + + + + + + + + + + + + + + + + +
AttributeValueExampleDescription
typestring"checkbox" (default)
"radio"
"fullsize"		 Visual type of toggle.
+ +### `ofxGuiButton` + - Derived from `ofxGuiToggle`. + - Default control type for `ofParameter`. + - class type name for JSON theme: `button` + +### `ofxGuiSlider` + - Derived from `ofxGuiElement`. + - This is a template class, use `ofxGuiFloatSlider` or `ofxGuiIntSlider`. + - Default control types for `ofParameter` and `ofParameter`. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
AttributeValueExampleDescription
typestring"straight" (default)
"circular"		 Visual type of slider. The straight type will appear as a horizontal or vertical slider depending on the aspect ration of its size.
precisionint6 (default)Sets the displayed precision of a float value. The value of the parameter won't be changed.
update-on-release-onlyboolfalse (default)If true, the slider will trigger on release only.
+ +### `ofxGuiLabel` + - Derived from `ofxGuiElement`. + - Displays a text or a numerical value as a label. + - class type name for JSON theme: `label` + +### `ofxGuiGraphics` + - Derived from `ofxGuiElement`. + - Displays any `ofBaseDraws` reference. + - class type name for JSON theme: `graphics` + +### `ofxGuiZoomableGraphics` + - Derived from `ofxGuiGraphics`. + - `ofBaseDraws` reference can be zoomed with scroll wheel and dragged with mouse button. + +### `ofxGuiValuePlotter` + - Derived from `ofxGuiElement`. + - class type name for JSON theme: `value-plotter` + - //TODO + +### `ofxGuiFpsPlotter` + - Derived from `ofxGuiValuePlotter`. + - //TODO + +### `ofxGuiFunctionPlotter` + - Derived from `ofxGuiElement`. + - class type name for JSON theme: `function-plotter` + - //TODO + + +## Containers + +### `ofxGuiContainer` +- derived from `ofxGuiElement`. +- Contains other elements according to the current layout +- class type name for JSON theme: `container` + +### `ofxGuiGroup` +- derived from `ofxGuiContainer`. +- Groups other elements according to the current layout with a header to minimize or maximize the group +- class type name for JSON theme: `group` +- class type name of group header for JSON theme: `group-header` + + + + + + + + + + + + + + + + + +
AttributeValueExampleDescription
show-headerbooltrue (default)Show or hide the header of the group.
+ +### `ofxGuiPanel` + - derived from `ofxGuiGroup`. + - Header can be used to drag group (only if panel is in absolute position mode). + - class type name for JSON theme: `panel` +- class type name of group header for JSON theme: `panel-header` + +### `ofxGuiTabs` + - derived from `ofxGuiGroup`. + - Add groups to this container and they will be displayed as tabs. + - class type name for JSON theme: `tabs` + - //TODO + + +## Layouts + +### `ofxDOMBoxLayout` +- Derived from `DOM::Layout`. +- Simple layout that lets you align elements in a container horizontally or vertically. Vertically aligned items will always use the full width of the container, horizontally aligned items will always use the full height of the container. + + + + + + + + + + + + + + + + + + + + + + + +
AttributeValueExampleDescription
width
height		float
string		800
"70%"		Size of the element.
directionstring"vertical" (default)
"horizontal"		The direction child elements get aligned.
+ + +### `ofxDOMFlexBoxLayout` +- Derived from `ofxDOMBoxLayout`. +- Implements parts of the [CSS FlexBox Layout](https://www.w3.org/TR/css-flexbox). +- There are multiple guides online that describe the layout and its options [[1]](https://scotch.io/tutorials/a-visual-guide-to-css3-flexbox-properties), [[2]](https://css-tricks.com/snippets/css/a-guide-to-flexbox/). + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
AttributeValueExampleDescription
width
height		float
string		800
"70%"		Size of the element.
flexstring
float		"none" (default)
"auto"
3		Flex attribute of the element [[source](https://www.w3.org/TR/css-flexbox/#flex-property)].
flex-directionstring"column" (default)
"row"		The direction child elements get aligned.
flex-wrapstring"nowrap" (default)
"wrap"		Determines if the child elements are aligned on one or multiple lines if space is insufficient +
justify-contentstring"flex-start" (default)
"flex-end"
"center"
"space-between"
"space-around"		How to align the child items along the main axis.
align-items`string`"stretch" (default)
"flex-start"
"flex-end"
"center"		How to align child items along the cross axis.
align-contentstring"stretch" (default)
"flex-start"
"flex-end"
"center"
"space-between"
"space-around"		Alignment options for item lines when there is space in the container along the cross axis, only used if multiple rows / columns are present.
align-self`string`"auto" (default)
"flex-start"
"flex-end"
"center"
"stretch"		Individual alignment options for a flex item along the cross axis.
+ +## Writing custom gui classes +- //TODO + +### Add custom elements via template function +- //TODO + +### Use attributes +- //TODO + +### Create custom layout +- //TODO + +## Known issues and feature wish list +- ** *Please report issues!* ** +- Have a look at the [issues on github](https://github.com/frauzufall/ofxGuiExtended/issues), there are up to date posts on bugs and feature requests + +## Credits +- @arturoc for his work on [ofxGui](https://github.com/openframeworks/openFrameworks/tree/master/addons/ofxGui/src) +- @bakercp for his work on [ofxDOM](https://github.com/bakercp/ofxDOM) +- @fxlange for his work on [ofxInputField](https://github.com/fx-lange/ofxInputField/) diff --git a/addons/ofxGui/examples/example/README.md b/addons/ofxGui/examples/example/README.md new file mode 100644 index 0000000..b6184dc --- /dev/null +++ b/addons/ofxGui/examples/example/README.md @@ -0,0 +1,18 @@ +# About example + +![Screenshot of example](example.png) + +### Learning Objectives +This example demonstrates the most simple way to create a panel using the data you want to work with. + +Pay special attention to the usage of `ofParameter`. + +### Expected Behavior + +When you open the app, you should see a screen with a fly. You can control its movements with the button and the sliders. + +### Classes Used in This File + +This example also uses: + + ofParameter diff --git a/addons/ofxGui/examples/example/addons.make b/addons/ofxGui/examples/example/addons.make new file mode 100644 index 0000000..66aa4c8 --- /dev/null +++ b/addons/ofxGui/examples/example/addons.make @@ -0,0 +1 @@ +ofxGuiExtended diff --git a/addons/ofxGui/examples/example/example.png b/addons/ofxGui/examples/example/example.png new file mode 100644 index 0000000..647a551 Binary files /dev/null and b/addons/ofxGui/examples/example/example.png differ diff --git a/addons/ofxGui/examples/example/src/main.cpp b/addons/ofxGui/examples/example/src/main.cpp new file mode 100644 index 0000000..84ca57f --- /dev/null +++ b/addons/ofxGui/examples/example/src/main.cpp @@ -0,0 +1,13 @@ +#include "ofMain.h" +#include "ofApp.h" + +//======================================================================== +int main( ){ + ofSetupOpenGL(1024,768, OF_WINDOW); // <-------- setup the GL context + + // this kicks off the running of my app + // can be OF_WINDOW or OF_FULLSCREEN + // pass in width and height too: + ofRunApp( new ofApp()); + +} diff --git a/addons/ofxGui/examples/example/src/ofApp.cpp b/addons/ofxGui/examples/example/src/ofApp.cpp new file mode 100644 index 0000000..aeb324a --- /dev/null +++ b/addons/ofxGui/examples/example/src/ofApp.cpp @@ -0,0 +1,150 @@ +#include "ofApp.h" + + +//-------------------------------------------------------------- +void ofApp::setup(){ + + ofBackgroundGradient(ofColor::white, ofColor::gray); + + ofSetFrameRate(120); + + ofSetVerticalSync(true); + + position = ofPoint(ofRandomWidth(), ofRandomHeight()); + + // initialize the parameters you want to work with, set minimal and maximal values + moving.set("moving", true); + speed.set("speed", 0.5, 0, 1); + rotation.set("rotate", ofRandom(0,2*PI), 0, 2*PI); + + // add the parameters to the gui + gui.add(moving, speed, rotation); + + // that's all you have to do to setup, update and show the panel + // the rest of the example is just playing around with a fly + +} + +//-------------------------------------------------------------- +void ofApp::exit(){ +} + +//-------------------------------------------------------------- +void ofApp::update(){ + + // computing new position of the fly + if(moving){ + position += direction; + } + direction = ofPoint(cos(rotation),sin(rotation))*speed.get(); + + // making sure the fly stays inside of the window + if(position.x < 0) position.x = 0; + if(position.x > ofGetWindowWidth()) position.x = ofGetWindowWidth(); + if(position.y < 0) position.y = 0; + if(position.y > ofGetWindowHeight()) position.y = ofGetWindowHeight(); + +} + +//-------------------------------------------------------------- + +void ofApp::draw(){ + + ofVec2f wingsize(60,30); + + // computing the wing animation + float waving = 0; + if(moving && speed > 0){ + waving = sin(ofGetElapsedTimef()*speed*50)*40; + } + ofPoint wingpos(waving, -wingsize.x); + ofPoint wingpos_norm = wingpos.getNormalized(); + ofPoint p1 = wingpos_norm*wingsize.x+wingpos_norm.getRotated(90, ofVec3f(0,0,1))*wingsize.y/2; + ofPoint p2 = wingpos_norm*wingsize.x-wingpos_norm.getRotated(90, ofVec3f(0,0,1))*wingsize.y/2; + + if(speed > 0){ + // draw direction arrow + ofPoint arrowStart = position + direction.getNormalized()*15; + ofPoint arrowEnd = arrowStart + direction*100; + ofSetColor(0,100,255); + ofDrawArrow(arrowStart, arrowEnd, 3); + } + + ofPushMatrix(); + ofTranslate(position); + ofRotateZ(ofRadToDeg(rotation)); + + // draw body + ofSetColor(0); + ofFill(); + ofDrawCircle(ofPoint(0,0), 10); + + // draw wings + ofNoFill(); + ofSetLineWidth(1); + ofBeginShape(); + ofCurveVertex(0,0); + ofCurveVertex(0,0); + ofCurveVertex(p1.x, p1.y); + ofCurveVertex(p2.x, p2.y); + ofCurveVertex(0,0); + ofCurveVertex(p1.x, -p1.y); + ofCurveVertex(p2.x, -p2.y); + ofCurveVertex(0,0); + ofCurveVertex(0,0); + ofEndShape(); + ofPopMatrix(); + +} + +//-------------------------------------------------------------- +void ofApp::keyPressed(int key){ +} + +//-------------------------------------------------------------- +void ofApp::keyReleased(int key){ + +} + +//-------------------------------------------------------------- +void ofApp::mouseMoved(int x, int y ){ + +} + +//-------------------------------------------------------------- +void ofApp::mouseDragged(int x, int y, int button){ +} + +//-------------------------------------------------------------- +void ofApp::mousePressed(int x, int y, int button){ + +} + +//-------------------------------------------------------------- +void ofApp::mouseReleased(int x, int y, int button){ + +} + +//-------------------------------------------------------------- +void ofApp::mouseEntered(int x, int y){ + +} + +//-------------------------------------------------------------- +void ofApp::mouseExited(int x, int y){ + +} + +//-------------------------------------------------------------- +void ofApp::windowResized(int w, int h){ +} + +//-------------------------------------------------------------- +void ofApp::gotMessage(ofMessage msg){ + +} + +//-------------------------------------------------------------- +void ofApp::dragEvent(ofDragInfo dragInfo){ + +} diff --git a/addons/ofxGui/examples/example/src/ofApp.h b/addons/ofxGui/examples/example/src/ofApp.h new file mode 100644 index 0000000..4bd78bc --- /dev/null +++ b/addons/ofxGui/examples/example/src/ofApp.h @@ -0,0 +1,38 @@ +#pragma once + +#include "ofMain.h" +#include "ofxGuiExtended.h" + +class ofApp : public ofBaseApp{ + +public: + void setup(); + void update(); + void draw(); + + void exit(); + + void keyPressed(int key); + void keyReleased(int key); + void mouseMoved(int x, int y ); + void mouseDragged(int x, int y, int button); + void mousePressed(int x, int y, int button); + void mouseReleased(int x, int y, int button); + void mouseEntered(int x, int y); + void mouseExited(int x, int y); + void windowResized(int w, int h); + void dragEvent(ofDragInfo dragInfo); + void gotMessage(ofMessage msg); + + ofParameter moving; + ofParameter speed; + ofParameter rotation; + + ofxGui gui; + + + + ofPoint position, direction; + +}; + diff --git a/addons/ofxGui/examples/exampleAdvancedGui/README.md b/addons/ofxGui/examples/exampleAdvancedGui/README.md new file mode 100644 index 0000000..4332519 --- /dev/null +++ b/addons/ofxGui/examples/exampleAdvancedGui/README.md @@ -0,0 +1,25 @@ +# advancedGuiExample + +![Screenshot of advancedGuiExample](advancedGuiExample.png) + +### Learning Objectives + +This example demonstrates advanced techniques using ofxGuiExtended. + +In the code, you will learn how to.. +* create different button and toggle types +* set toggle groups exclusive +* create text input fields +* create vertical, horizontal and circular sliders +* set the precision of a slider +* add an FPS display +* change colors +* show and hide the header of groups and panels + +### Expected Behavior + +TODO + +### Other classes used in this file + +TODO diff --git a/addons/ofxGui/examples/exampleAdvancedGui/addons.make b/addons/ofxGui/examples/exampleAdvancedGui/addons.make new file mode 100644 index 0000000..66aa4c8 --- /dev/null +++ b/addons/ofxGui/examples/exampleAdvancedGui/addons.make @@ -0,0 +1 @@ +ofxGuiExtended diff --git a/addons/ofxGui/examples/exampleAdvancedGui/advancedGuiExample.png b/addons/ofxGui/examples/exampleAdvancedGui/advancedGuiExample.png new file mode 100644 index 0000000..9d14c15 Binary files /dev/null and b/addons/ofxGui/examples/exampleAdvancedGui/advancedGuiExample.png differ diff --git a/addons/ofxGui/examples/exampleAdvancedGui/containers.png b/addons/ofxGui/examples/exampleAdvancedGui/containers.png new file mode 100644 index 0000000..a2dd16f Binary files /dev/null and b/addons/ofxGui/examples/exampleAdvancedGui/containers.png differ diff --git a/addons/ofxGui/examples/exampleAdvancedGui/src/main.cpp b/addons/ofxGui/examples/exampleAdvancedGui/src/main.cpp new file mode 100644 index 0000000..43496c9 --- /dev/null +++ b/addons/ofxGui/examples/exampleAdvancedGui/src/main.cpp @@ -0,0 +1,14 @@ +#include "ofMain.h" +#include "ofApp.h" + +//======================================================================== +int main(){ + + ofSetupOpenGL(1024, 768, OF_WINDOW); // <-------- setup the GL context + + // this kicks off the running of my app + // can be OF_WINDOW or OF_FULLSCREEN + // pass in width and height too: + ofRunApp(new ofApp()); + +} diff --git a/addons/ofxGui/examples/exampleAdvancedGui/src/ofApp.cpp b/addons/ofxGui/examples/exampleAdvancedGui/src/ofApp.cpp new file mode 100644 index 0000000..8a34ddc --- /dev/null +++ b/addons/ofxGui/examples/exampleAdvancedGui/src/ofApp.cpp @@ -0,0 +1,230 @@ +#include "ofApp.h" + +//-------------------------------------------------------------- +void ofApp::setup(){ + + ofSetLogLevel(OF_LOG_VERBOSE); + + ofSetFrameRate(120); + + activeName.set("element name", ""); + activeIndex.set("element index", -1); + + + /* + * panel without header and a button that toggles the visibility of all the other headers + */ + panel1 = gui.addPanel(); + panel1->setPosition(20,20); + panel1->setShowHeader(false); + + /* + * toggle to show or hide header + */ + + showHeaders.set("show/hide header", true); + panel1->add(showHeaders, ofJson({{"type", "fullsize"}, {"text-align", "center"}})); + + panel1->addSpacer(0, 20); + + /* + * Plotter + */ + panel1->addFpsPlotter(); + auto sinusfunction = [&] (float x) { return sin(x); }; + + sinus.set("sinus", ofPoint(0,0), ofPoint(0, -1), ofPoint(4*PI, 1)); + panel1->add(sinus, sinusfunction, ofJson({})); + + panel1->add(randomVal.set("random value", 0, 0, 9), ofJson({{"precision", 2}})); + + panel1->addSpacer(0, 20); + + /* + * buttons + */ + buttons = panel1->addGroup("buttons"); + buttons->add("fullsize button", ofJson({{"type", "fullsize"}, {"text-align", "center"}})); + buttons->add("checkbox button", ofJson({{"type", "checkbox"}})); + buttons->add("radio button", ofJson({{"type", "radio"}})); + + panel1->addSpacer(0, 20); + + /* + * input fields + */ + panel1->add(floatfieldVal.set("float input",3.5,0,500)); + panel1->add(textfieldVal.set("text input","type in here")); + + panel1->addSpacer(0, 20); + + /* + * range slider + */ + rangesliderStart.set("range",2,0,5); //use the first parameter to set the initial lower value and the min and max value + rangesliderEnd.set(3); // use the second parameter to set the initial upper value + panel1->add(rangesliderStart, rangesliderEnd, ofJson({{"precision", 2}})); + + /* + * ofParameterGroup example with radio toggles, listener to show current index and name + */ + + colorParameters.setName("ofParameterGroup"); + colorParameters.add(color0.set("mediumSlateBlue",false)); + colorParameters.add(color1.set("tomato",false)); + colorParameters.add(color2.set("mediumAquaMarine",false)); + colorParameters.add(color3.set("steelBlue",false)); + + colorPanel = gui.addPanel("header color", ofJson({{"width", 270}})); + colorPanel->setPosition(panel1->getShape().getTopRight()+ofPoint(20,0)); + colorToggles = colorPanel->addGroup(colorParameters); + colorToggles->setExclusiveToggles(true); + colorToggles->setConfig(ofJson({{"type", "radio"}})); + + /* + * labels + */ + labels = colorPanel->addGroup("labels"); + labels->add(activeName); + labels->add(activeIndex); + labels->add("text without parameter"); + + + /* + * sliders + */ + sliders = gui.addContainer("vertical sliders", ofJson({{"direction", "horizontal"}})); + sliders->setPosition(colorPanel->getShape().getTopRight()+ofPoint(20,0)); + + sliders->add(slider1Val.set("slider1", 1. / 7., 0, 1), ofJson({{"width", 40}, {"height", 130}})); + sliders->add(slider2Val.set("slider2", 5. / 7., 0, 1), ofJson({{"width", 50}, {"height", 130}})); + sliders->add(slider3Val.set("slider3", 4. / 7., 0, 1), ofJson({{"width", 60}, {"height", 130}})); + sliders->add(slider4Val.set("slider4", 6. / 7., 0, 1), ofJson({{"width", 70}, {"height", 130}})); + + sliders->add(circularSliderVal.set("slider", 0.5, 0, 1), ofJson({{"type", "circular"}, {"width", 130}, {"height", 130}, {"precision", 2}})); + + + /* + * showing the differences between containers, groups and panels + */ + + ofJson containerSettings = {{"width", 400}}; + + containerExample = gui.addContainer("Container", containerSettings); + containerExample->add(containerLabel.set("Container", "A collection of elements.")); + containerExample->setPosition(sliders->getShape().getBottomLeft() + ofPoint(20, 170)); + + groupExample = gui.addGroup("Group", containerSettings); + groupExample->add(groupLabel.set("A container with header to minimize / maximize.")); + groupExample->setPosition(containerExample->getShape().getBottomLeft() + ofPoint(0, 20)); + + panelExample = gui.addPanel("Panel", containerSettings); + panelExample->add(panelLabel.set("A container with header to drag, save and load.")); + panelExample->setPosition(groupExample->getShape().getBottomLeft() + ofPoint(0, 20)); + + + /* + * adding listeners + */ + + showHeaders.addListener(this, &ofApp::toggleGroupHeader); + colorToggles->getActiveToggleIndex().addListener(this, &ofApp::setHeaderColors); + colorToggles->setActiveToggle(3); + +} + +//-------------------------------------------------------------- +void ofApp::exit(){ + showHeaders.removeListener(this, &ofApp::toggleGroupHeader); + colorToggles->getActiveToggleIndex().removeListener(this, &ofApp::setHeaderColors); +} + +//-------------------------------------------------------------- +void ofApp::update(){ + randomVal.set(ofRandom(randomVal.getMin(), randomVal.getMax())); +} + +//-------------------------------------------------------------- +void ofApp::draw(){ + + ofBackgroundGradient(ofColor::white, ofColor::gray); + +} + +void ofApp::setHeaderColors(int& index){ + + activeIndex = index; + activeName = colorParameters.get(index).getName(); + + ofColor c; + switch(index){ + case 0: c = ofColor::mediumSlateBlue; break; + case 1: c = ofColor::tomato; break; + case 2: c = ofColor::mediumAquaMarine; break; + default: case 3: c = ofColor::steelBlue; break; + + } + + labels->getHeader()->setBackgroundColor(c); + buttons->getHeader()->setBackgroundColor(c); + colorPanel->getHeader()->setBackgroundColor(c); + colorToggles->getHeader()->setBackgroundColor(c); + + color = c; +} + +void ofApp::toggleGroupHeader(bool & val){ + labels->setShowHeader(val); + buttons->setShowHeader(val); + colorPanel->setShowHeader(val); + colorToggles->setShowHeader(val); +} + +//-------------------------------------------------------------- +void ofApp::keyPressed(int key){ +} + +//-------------------------------------------------------------- +void ofApp::keyReleased(int key){ + switch(key){ + case 'f': { + ofToggleFullscreen(); + break; + } + + default: + break; + } + +} + +//-------------------------------------------------------------- +void ofApp::mouseMoved(ofMouseEventArgs & args){ + +} + +//-------------------------------------------------------------- +void ofApp::mouseDragged(ofMouseEventArgs & args){ +} + +//-------------------------------------------------------------- +void ofApp::mousePressed(ofMouseEventArgs & args){ +} + +//-------------------------------------------------------------- +void ofApp::mouseReleased(ofMouseEventArgs & args){ +} + +//-------------------------------------------------------------- +void ofApp::windowResized(int w, int h){ +} + +//-------------------------------------------------------------- +void ofApp::gotMessage(ofMessage msg){ + +} + +//-------------------------------------------------------------- +void ofApp::dragEvent(ofDragInfo dragInfo){ + +} diff --git a/addons/ofxGui/examples/exampleAdvancedGui/src/ofApp.h b/addons/ofxGui/examples/exampleAdvancedGui/src/ofApp.h new file mode 100644 index 0000000..24b30bd --- /dev/null +++ b/addons/ofxGui/examples/exampleAdvancedGui/src/ofApp.h @@ -0,0 +1,74 @@ +#pragma once + +#include "ofMain.h" +#include "ofxGuiExtended.h" + +class ofApp : public ofBaseApp { + + public: + void setup(); + void update(); + void draw(); + + void exit(); + + void keyPressed(int key); + void keyReleased(int key); + void mouseMoved(ofMouseEventArgs & args); + void mouseDragged(ofMouseEventArgs & args); + void mousePressed(ofMouseEventArgs & args); + void mouseReleased(ofMouseEventArgs & args); + void windowResized(int w, int h); + void dragEvent(ofDragInfo dragInfo); + void gotMessage(ofMessage msg); + + private: + + ofxGui gui; + + ofxGuiContainer *containerExample; + ofxGuiGroup *groupExample; + ofxGuiPanel *panelExample; + ofParameter containerLabel, groupLabel, panelLabel; + + ofxGuiPanel *panel1; + ofxGuiGroup *labels, *buttons; + + //plotter + ofParameter sinus; + ofParameter randomVal; + + //textfields + ofParameter floatfieldVal; + ofParameter textfieldVal; + + ofParameter showHeaders; + + //sliders + ofxGuiContainer* sliders; + ofParameter slider1Val, slider2Val, slider3Val, slider4Val; + ofParameter circularSliderVal; + + //rangeslider + ofParameter rangesliderStart, rangesliderEnd; + + //color panel + ofxGuiPanel* colorPanel; + ofxGuiGroup *colorToggles; + + ofParameterGroup colorParameters; + ofParameter color0; + ofParameter color1; + ofParameter color2; + ofParameter color3; + + ofParameter activeName; + ofParameter activeIndex; + + ofColor color; + + void toggleGroupHeader(bool & val); + void setHeaderColors(int& index); + +}; + diff --git a/addons/ofxGui/examples/exampleGraphics/README.md b/addons/ofxGui/examples/exampleGraphics/README.md new file mode 100644 index 0000000..5623716 --- /dev/null +++ b/addons/ofxGui/examples/exampleGraphics/README.md @@ -0,0 +1,24 @@ +# exampleGraphics + +![Screenshot of exampleGraphics](exampleGraphics.png) + +### Learning Objectives + +This example demonstrates how to show graphics within your graphical user interface. + +In the code, you will learn how to.. +* add an image to the panel +* add an fbo to the panel +* adjust the image size +* add the ability to zoom into the image + +### Expected Behavior + +When you run the application, you should see two panels. The left one shows the image of a duck with a fixed size. The right panel displays the same image, but its height is dependent on the image ratio. The second image on the right panel displays the texture of an fbo in which we draw the image in a specific color. + +Use your scrolling wheel to zoom into the images of the right panel and click and drag your mouse to move the focus of the zooming image. + +### Other classes used in this file + +* `ofImage` +* `ofFbo` diff --git a/addons/ofxGui/examples/exampleGraphics/addons.make b/addons/ofxGui/examples/exampleGraphics/addons.make new file mode 100644 index 0000000..66aa4c8 --- /dev/null +++ b/addons/ofxGui/examples/exampleGraphics/addons.make @@ -0,0 +1 @@ +ofxGuiExtended diff --git a/addons/ofxGui/examples/exampleGraphics/bin/data/images/ente.jpg b/addons/ofxGui/examples/exampleGraphics/bin/data/images/ente.jpg new file mode 100644 index 0000000..38e526b Binary files /dev/null and b/addons/ofxGui/examples/exampleGraphics/bin/data/images/ente.jpg differ diff --git a/addons/ofxGui/examples/exampleGraphics/exampleGraphics.png b/addons/ofxGui/examples/exampleGraphics/exampleGraphics.png new file mode 100644 index 0000000..966a63c Binary files /dev/null and b/addons/ofxGui/examples/exampleGraphics/exampleGraphics.png differ diff --git a/addons/ofxGui/examples/exampleGraphics/src/main.cpp b/addons/ofxGui/examples/exampleGraphics/src/main.cpp new file mode 100644 index 0000000..cf76611 --- /dev/null +++ b/addons/ofxGui/examples/exampleGraphics/src/main.cpp @@ -0,0 +1,14 @@ +#include "ofMain.h" +#include "ofApp.h" + +//======================================================================== +int main( ){ + + ofSetupOpenGL(1024,768, OF_WINDOW);// <-------- setup the GL context + + // this kicks off the running of my app + // can be OF_WINDOW or OF_FULLSCREEN + // pass in width and height too: + ofRunApp( new ofApp()); + +} diff --git a/addons/ofxGui/examples/exampleGraphics/src/ofApp.cpp b/addons/ofxGui/examples/exampleGraphics/src/ofApp.cpp new file mode 100644 index 0000000..82e9b43 --- /dev/null +++ b/addons/ofxGui/examples/exampleGraphics/src/ofApp.cpp @@ -0,0 +1,96 @@ +#include "ofApp.h" + +//-------------------------------------------------------------- +void ofApp::setup(){ + + ofSetLogLevel(OF_LOG_VERBOSE); + + ofSetFrameRate(120); + + // load image + img.load("images/ente.jpg"); + fbo.allocate(img.getWidth(), img.getHeight(), GL_RGB); + + // add panel 1 + ofxGuiGroup* panel1 = gui.addPanel("graphics"); + panel1->setPosition(260, 90); + + // add image texture with fixed height + panel1->add("some texture", &img.getTexture(), ofJson({{"height", 200}})); + + // add panel 2 + ofxGuiGroup* panel2 = gui.addPanel("zoomable graphics"); + panel2->setPosition(500, 90); + + // add image texture and get the pointer to this graphics gui element + ofxGuiGraphics* graphics = panel2->add("same texture", &img.getTexture()); + // set image heigth according to width and ratio if the image + graphics->setAutoHeight(); + // add fbo texture + graphics = panel2->add("fbo", &fbo.getTexture()); + graphics->setAutoHeight(); + +} + +//-------------------------------------------------------------- +void ofApp::exit() { +} + +//-------------------------------------------------------------- +void ofApp::update() { + fbo.begin(); + ofSetColor(ofColor::fromHsb(0, sin(ofGetElapsedTimef())*255, 255)); + img.draw(0,0); + fbo.end(); +} + +//-------------------------------------------------------------- +void ofApp::draw(){ +} + +//-------------------------------------------------------------- +void ofApp::keyPressed(int key){ +} + +//-------------------------------------------------------------- +void ofApp::keyReleased(int key){ + switch(key) { + case 'f': { + ofToggleFullscreen(); + break; + } + default: break; + } + +} + +//-------------------------------------------------------------- +void ofApp::mouseMoved(ofMouseEventArgs &args){ + +} + +//-------------------------------------------------------------- +void ofApp::mouseDragged(ofMouseEventArgs &args){ +} + +//-------------------------------------------------------------- +void ofApp::mousePressed(ofMouseEventArgs &args){ +} + +//-------------------------------------------------------------- +void ofApp::mouseReleased(ofMouseEventArgs &args){ +} + +//-------------------------------------------------------------- +void ofApp::windowResized(int w, int h) { +} + +//-------------------------------------------------------------- +void ofApp::gotMessage(ofMessage msg){ + +} + +//-------------------------------------------------------------- +void ofApp::dragEvent(ofDragInfo dragInfo){ + +} diff --git a/addons/ofxGui/examples/exampleGraphics/src/ofApp.h b/addons/ofxGui/examples/exampleGraphics/src/ofApp.h new file mode 100644 index 0000000..b09f3c9 --- /dev/null +++ b/addons/ofxGui/examples/exampleGraphics/src/ofApp.h @@ -0,0 +1,34 @@ +#pragma once + +#include "ofMain.h" +#include "ofxGuiExtended.h" + +class ofApp : public ofBaseApp{ + +public: + void setup(); + void update(); + void draw(); + + void exit(); + + void keyPressed(int key); + void keyReleased(int key); + void mouseMoved(ofMouseEventArgs &args); + void mouseDragged(ofMouseEventArgs &args); + void mousePressed(ofMouseEventArgs &args); + void mouseReleased(ofMouseEventArgs &args); + void windowResized(int w, int h); + void dragEvent(ofDragInfo dragInfo); + void gotMessage(ofMessage msg); + +private: + + ofxGui gui; + + ofImage img; + ofFbo fbo; + + +}; + diff --git a/addons/ofxGui/examples/exampleLayout/README.md b/addons/ofxGui/examples/exampleLayout/README.md new file mode 100644 index 0000000..a205213 --- /dev/null +++ b/addons/ofxGui/examples/exampleLayout/README.md @@ -0,0 +1,19 @@ +# layoutExample + +![Screenshot of layoutExample](layoutExample.png) + +### Learning Objectives + +This example demonstrates methods to use the flexbox layout in ofxGui. + +In the code, you will learn how to.. +* set layout options with `ofJson` +* create tabs and add pages +* set a percental with of an element +* create groups with fixed and with flexible size +* set different background colors for groups +* use different flexbox attributes + +### Expected Behavior + +You will see a layout with a header, a main part with tabs and a footer. The layout will always use the full window size, try resizing. diff --git a/addons/ofxGui/examples/exampleLayout/addons.make b/addons/ofxGui/examples/exampleLayout/addons.make new file mode 100644 index 0000000..66aa4c8 --- /dev/null +++ b/addons/ofxGui/examples/exampleLayout/addons.make @@ -0,0 +1 @@ +ofxGuiExtended diff --git a/addons/ofxGui/examples/exampleLayout/layoutExample.png b/addons/ofxGui/examples/exampleLayout/layoutExample.png new file mode 100644 index 0000000..41c43bf Binary files /dev/null and b/addons/ofxGui/examples/exampleLayout/layoutExample.png differ diff --git a/addons/ofxGui/examples/exampleLayout/src/main.cpp b/addons/ofxGui/examples/exampleLayout/src/main.cpp new file mode 100644 index 0000000..43496c9 --- /dev/null +++ b/addons/ofxGui/examples/exampleLayout/src/main.cpp @@ -0,0 +1,14 @@ +#include "ofMain.h" +#include "ofApp.h" + +//======================================================================== +int main(){ + + ofSetupOpenGL(1024, 768, OF_WINDOW); // <-------- setup the GL context + + // this kicks off the running of my app + // can be OF_WINDOW or OF_FULLSCREEN + // pass in width and height too: + ofRunApp(new ofApp()); + +} diff --git a/addons/ofxGui/examples/exampleLayout/src/ofApp.cpp b/addons/ofxGui/examples/exampleLayout/src/ofApp.cpp new file mode 100644 index 0000000..1840152 --- /dev/null +++ b/addons/ofxGui/examples/exampleLayout/src/ofApp.cpp @@ -0,0 +1,127 @@ +#include "ofApp.h" + +//-------------------------------------------------------------- +void ofApp::setup(){ + + ofSetFrameRate(120); + + ofSetLogLevel(OF_LOG_VERBOSE); + + gui.setupFlexBoxLayout(); + + ofxGuiGroup* all = gui.addGroup("all", ofJson({ + {"position", "static"}, + {"height", "100%"}, + {"width", "100%"}, + {"show-header", false}, + {"background-color", "#000000"} + })); + + // add header group + ofxGuiGroup* header = all->addGroup("header", ofJson({ + {"flex-direction", "row"}, + {"show-header", false}, + {"height", 50}, + {"background-color", "#F40056"} + })); + header->addLabel("this is the header"); + + // create tab container + ofxGuiTabs* tabbed_pages = all->addTabs("tabbedpages", ofJson({{"flex", 1}})); + + // add a page to the tab container + ofxGuiGroup* page1 = tabbed_pages->addGroup("page1", ofJson({ + {"background-color", "#2377BA"}, + {"flex-direction", "row"}, + {"padding", 10}, + {"flex-wrap", "wrap"} + })); + + // add labels with random width to the first page + for(int i = 0; i < 33; i++){ + page1->addLabel(ofToString(i), ofJson({ + {"border-width", 1}, + {"width", ofRandom(30, 130)} + })); + } + + // add two more pages without content + tabbed_pages->addGroup("page2", ofJson({{"background-color", "#00CA98"}})); + tabbed_pages->addGroup("page3", ofJson({{"background-color", "#ffaa00"}})); + +// add footer group + ofxGuiGroup* footer = all->addGroup("footer", ofJson({ + {"flex-direction", "row"}, + {"show-header", false}, + {"height", 50}, + {"background-color", "#F47E00"} + })); + footer->addLabel("this is the footer"); + + + +} + +//-------------------------------------------------------------- +void ofApp::exit(){ +} + +//-------------------------------------------------------------- +void ofApp::update(){ +} + +//-------------------------------------------------------------- +void ofApp::draw(){ + + ofBackgroundGradient(ofColor::white, ofColor::gray); + +} + +//-------------------------------------------------------------- +void ofApp::keyPressed(int key){ +} + +//-------------------------------------------------------------- +void ofApp::keyReleased(int key){ + switch(key){ + case 'f': { + ofToggleFullscreen(); + break; + } + + default: + break; + } + +} + +//-------------------------------------------------------------- +void ofApp::mouseMoved(ofMouseEventArgs & args){ + +} + +//-------------------------------------------------------------- +void ofApp::mouseDragged(ofMouseEventArgs & args){ +} + +//-------------------------------------------------------------- +void ofApp::mousePressed(ofMouseEventArgs & args){ +} + +//-------------------------------------------------------------- +void ofApp::mouseReleased(ofMouseEventArgs & args){ +} + +//-------------------------------------------------------------- +void ofApp::windowResized(int w, int h){ +} + +//-------------------------------------------------------------- +void ofApp::gotMessage(ofMessage msg){ + +} + +//-------------------------------------------------------------- +void ofApp::dragEvent(ofDragInfo dragInfo){ + +} diff --git a/addons/ofxGui/examples/exampleLayout/src/ofApp.h b/addons/ofxGui/examples/exampleLayout/src/ofApp.h new file mode 100644 index 0000000..490e9ec --- /dev/null +++ b/addons/ofxGui/examples/exampleLayout/src/ofApp.h @@ -0,0 +1,30 @@ +#pragma once + +#include "ofMain.h" +#include "ofxGuiExtended.h" + +class ofApp : public ofBaseApp { + + public: + void setup(); + void update(); + void draw(); + + void exit(); + + void keyPressed(int key); + void keyReleased(int key); + void mouseMoved(ofMouseEventArgs & args); + void mouseDragged(ofMouseEventArgs & args); + void mousePressed(ofMouseEventArgs & args); + void mouseReleased(ofMouseEventArgs & args); + void windowResized(int w, int h); + void dragEvent(ofDragInfo dragInfo); + void gotMessage(ofMessage msg); + + private: + + ofxGui gui; + +}; + diff --git a/addons/ofxGui/examples/exampleMenu/README.md b/addons/ofxGui/examples/exampleMenu/README.md new file mode 100644 index 0000000..0ce45a8 --- /dev/null +++ b/addons/ofxGui/examples/exampleMenu/README.md @@ -0,0 +1,17 @@ +# exampleMenu + +![Screenshot of exampleMenu](exampleMenu.png) + +### Learning Objectives + +This example demonstrates how to add a menu to your application. + +//TODO + +### Expected Behavior + +//TODO + +### Other classes used in this file + +//TODO diff --git a/addons/ofxGui/examples/exampleMenu/addons.make b/addons/ofxGui/examples/exampleMenu/addons.make new file mode 100644 index 0000000..66aa4c8 --- /dev/null +++ b/addons/ofxGui/examples/exampleMenu/addons.make @@ -0,0 +1 @@ +ofxGuiExtended diff --git a/addons/ofxGui/examples/exampleMenu/exampleMenu.png b/addons/ofxGui/examples/exampleMenu/exampleMenu.png new file mode 100644 index 0000000..9d9ad09 Binary files /dev/null and b/addons/ofxGui/examples/exampleMenu/exampleMenu.png differ diff --git a/addons/ofxGui/examples/exampleMenu/src/main.cpp b/addons/ofxGui/examples/exampleMenu/src/main.cpp new file mode 100644 index 0000000..cf76611 --- /dev/null +++ b/addons/ofxGui/examples/exampleMenu/src/main.cpp @@ -0,0 +1,14 @@ +#include "ofMain.h" +#include "ofApp.h" + +//======================================================================== +int main( ){ + + ofSetupOpenGL(1024,768, OF_WINDOW);// <-------- setup the GL context + + // this kicks off the running of my app + // can be OF_WINDOW or OF_FULLSCREEN + // pass in width and height too: + ofRunApp( new ofApp()); + +} diff --git a/addons/ofxGui/examples/exampleMenu/src/ofApp.cpp b/addons/ofxGui/examples/exampleMenu/src/ofApp.cpp new file mode 100644 index 0000000..d332485 --- /dev/null +++ b/addons/ofxGui/examples/exampleMenu/src/ofApp.cpp @@ -0,0 +1,138 @@ +#include "ofApp.h" + +//-------------------------------------------------------------- +void ofApp::setup(){ + + ofSetLogLevel(OF_LOG_VERBOSE); + + ofSetFrameRate(120); + + fbo.allocate(ofGetWidth(), ofGetHeight(), GL_RGB); + + data.add(addCircle.set("draw circle")); + data.add(addRectangle.set("draw rectangle")); + + circleSettings.setName("circle"); + circleSettings.add(circleRadius.set("radius", 20, 1, 100)); + circleSettings.add(circleColor.set("color", ofColor(0,255,255,100), ofColor(0,0,0,0), ofColor(255,255,255,255))); + + rectangleSettings.setName("rectangle"); + rectangleSettings.add(rectangleWidth.set("width", 20, 1, 100)); + rectangleSettings.add(rectangleHeight.set("height", 20, 1, 100)); + rectangleSettings.add(rectangleColor.set("color", ofColor(255,0,255,100), ofColor(0,0,0,0), ofColor(255,255,255,255))); + + settings.setName("settings"); + settings.add(circleSettings); + settings.add(rectangleSettings); + data.add(settings); + + unusedParameters.setName("unused"); + unusedParameters.add(labelParameter.set("std::string")); + unusedParameters.add(voidParameter.set("void")); + unusedParameters.add(boolParameter.set("bool", false)); + unusedParameters.add(floatParameter.set("float", 0.5,0,1)); + unusedParameters.add(pointParameter.set("ofPoint", ofPoint(0.5,0.5,0.5),ofPoint(0,0,0), ofPoint(1,1,1))); + unusedParameters.add(colorParameter.set("ofColor", ofColor(255,255,0,255),ofColor(0,0,0,0), ofColor(255,255,255,255))); + unusedParameters.add(rectParameter.set("ofRectangle", + ofRectangle(100,100,100,100), + ofRectangle(0,0,0,0), + ofRectangle(ofGetWidth(), ofGetHeight(), ofGetWidth(), ofGetHeight()))); + + data.add(unusedParameters); + + ofxGuiContainer* menu = gui.addMenu(data); + + menu->loadTheme("theme_light.json", true); + + addCircle.addListener(this, &ofApp::drawCircle); + addRectangle.addListener(this, &ofApp::drawRectangle); + + fbo.begin(); + ofSetColor(200); + ofFill(); + ofDrawRectangle(0,0,fbo.getWidth(), fbo.getHeight()); + fbo.end(); + +} + +void ofApp::drawCircle(){ + fbo.begin(); + + ofSetLineWidth(10); + ofNoFill(); + ofSetColor(circleColor); + ofDrawCircle(ofRandom(fbo.getWidth()), ofRandom(fbo.getHeight()), circleRadius); + + fbo.end(); +} + +void ofApp::drawRectangle(){ + fbo.begin(); + + ofSetLineWidth(10); + ofNoFill(); + ofSetColor(rectangleColor); + ofDrawRectangle(ofRandom(fbo.getWidth()), ofRandom(fbo.getHeight()), rectangleWidth, rectangleHeight); + + fbo.end(); +} + +//-------------------------------------------------------------- +void ofApp::exit() { +} + +//-------------------------------------------------------------- +void ofApp::update() { +} + +//-------------------------------------------------------------- +void ofApp::draw(){ + fbo.draw(0,0); +} + +//-------------------------------------------------------------- +void ofApp::keyPressed(int key){ +} + +//-------------------------------------------------------------- +void ofApp::keyReleased(int key){ + switch(key) { + case 'f': { + ofToggleFullscreen(); + break; + } + default: break; + } + +} + +//-------------------------------------------------------------- +void ofApp::mouseMoved(ofMouseEventArgs &args){ + +} + +//-------------------------------------------------------------- +void ofApp::mouseDragged(ofMouseEventArgs &args){ +} + +//-------------------------------------------------------------- +void ofApp::mousePressed(ofMouseEventArgs &args){ +} + +//-------------------------------------------------------------- +void ofApp::mouseReleased(ofMouseEventArgs &args){ +} + +//-------------------------------------------------------------- +void ofApp::windowResized(int w, int h) { +} + +//-------------------------------------------------------------- +void ofApp::gotMessage(ofMessage msg){ + +} + +//-------------------------------------------------------------- +void ofApp::dragEvent(ofDragInfo dragInfo){ + +} diff --git a/addons/ofxGui/examples/exampleMenu/src/ofApp.h b/addons/ofxGui/examples/exampleMenu/src/ofApp.h new file mode 100644 index 0000000..0858506 --- /dev/null +++ b/addons/ofxGui/examples/exampleMenu/src/ofApp.h @@ -0,0 +1,50 @@ +#pragma once + +#include "ofMain.h" +#include "ofxGuiExtended.h" + +class ofApp : public ofBaseApp{ + +public: + void setup(); + void update(); + void draw(); + + void exit(); + + void keyPressed(int key); + void keyReleased(int key); + void mouseMoved(ofMouseEventArgs &args); + void mouseDragged(ofMouseEventArgs &args); + void mousePressed(ofMouseEventArgs &args); + void mouseReleased(ofMouseEventArgs &args); + void windowResized(int w, int h); + void dragEvent(ofDragInfo dragInfo); + void gotMessage(ofMessage msg); + +private: + + void drawCircle(); + void drawRectangle(); + + ofxGui gui; + ofParameterGroup data; + ofParameter addCircle, addRectangle; + ofParameterGroup settings, circleSettings, rectangleSettings; + ofParameter circleRadius, rectangleWidth, rectangleHeight; + ofParameter circleColor, rectangleColor; + //all possible different types creating different interfaces + ofParameterGroup unusedParameters; + ofParameter rectParameter; + ofParameter colorParameter; + ofParameter pointParameter; + ofParameter floatParameter; + ofParameter labelParameter; + ofParameter boolParameter; + ofParameter voidParameter; + + ofFbo fbo; + + +}; + diff --git a/addons/ofxGui/examples/exampleOscParametersReceiver/addons.make b/addons/ofxGui/examples/exampleOscParametersReceiver/addons.make new file mode 100644 index 0000000..8726ddd --- /dev/null +++ b/addons/ofxGui/examples/exampleOscParametersReceiver/addons.make @@ -0,0 +1,2 @@ +ofxOsc +ofxGuiExtended diff --git a/addons/ofxGui/examples/exampleOscParametersReceiver/src/main.cpp b/addons/ofxGui/examples/exampleOscParametersReceiver/src/main.cpp new file mode 100644 index 0000000..8da2b16 --- /dev/null +++ b/addons/ofxGui/examples/exampleOscParametersReceiver/src/main.cpp @@ -0,0 +1,13 @@ +#include "ofMain.h" +#include "ofApp.h" + +//======================================================================== +int main( ){ + ofSetupOpenGL(1024,768, OF_WINDOW); // <-------- setup the GL context + + // this kicks off the running of my app + // can be OF_WINDOW or OF_FULLSCREEN + // pass in width and height too: + ofRunApp( new ofApp()); + +} diff --git a/addons/ofxGui/examples/exampleOscParametersReceiver/src/ofApp.cpp b/addons/ofxGui/examples/exampleOscParametersReceiver/src/ofApp.cpp new file mode 100644 index 0000000..d369c3a --- /dev/null +++ b/addons/ofxGui/examples/exampleOscParametersReceiver/src/ofApp.cpp @@ -0,0 +1,82 @@ +#include "ofApp.h" + +//-------------------------------------------------------------- +void ofApp::setup(){ + parameters.setName("parameters"); + parameters.add(size.set("size",10,0,100)); + parameters.add(number.set("number",10,0,100)); + parameters.add(check.set("check",false)); + parameters.add(color.set("color",ofColor(98, 38, 255, 223),ofColor(0,0),ofColor(255))); + panel = gui.addPanel(parameters); + // by now needs to pass the gui parameter groups since the panel internally creates it's own group + sync.setup((ofParameterGroup&)panel->getParameter(),6666,"localhost",6667); + ofSetVerticalSync(true); +} + +//-------------------------------------------------------------- +void ofApp::update(){ + sync.update(); +} + +//-------------------------------------------------------------- +void ofApp::draw(){ + ofSetColor(color); + for(int i=0;i size; + ofParameter number; + ofParameter check; + ofParameterGroup parameters; + ofParameter color; + ofxGuiPanel* panel; + ofxGui gui; + +}; diff --git a/addons/ofxGui/examples/exampleOscParametersSender/addons.make b/addons/ofxGui/examples/exampleOscParametersSender/addons.make new file mode 100644 index 0000000..8726ddd --- /dev/null +++ b/addons/ofxGui/examples/exampleOscParametersSender/addons.make @@ -0,0 +1,2 @@ +ofxOsc +ofxGuiExtended diff --git a/addons/ofxGui/examples/exampleOscParametersSender/src/main.cpp b/addons/ofxGui/examples/exampleOscParametersSender/src/main.cpp new file mode 100644 index 0000000..8da2b16 --- /dev/null +++ b/addons/ofxGui/examples/exampleOscParametersSender/src/main.cpp @@ -0,0 +1,13 @@ +#include "ofMain.h" +#include "ofApp.h" + +//======================================================================== +int main( ){ + ofSetupOpenGL(1024,768, OF_WINDOW); // <-------- setup the GL context + + // this kicks off the running of my app + // can be OF_WINDOW or OF_FULLSCREEN + // pass in width and height too: + ofRunApp( new ofApp()); + +} diff --git a/addons/ofxGui/examples/exampleOscParametersSender/src/ofApp.cpp b/addons/ofxGui/examples/exampleOscParametersSender/src/ofApp.cpp new file mode 100644 index 0000000..1fa5a24 --- /dev/null +++ b/addons/ofxGui/examples/exampleOscParametersSender/src/ofApp.cpp @@ -0,0 +1,83 @@ +#include "ofApp.h" + +//-------------------------------------------------------------- +void ofApp::setup(){ + parameters.setName("parameters"); + parameters.add(size.set("size",10,1,100)); + parameters.add(number.set("number",10,1,100)); + parameters.add(check.set("check",false)); + parameters.add(color.set("color",ofColor(98, 38, 255, 223),ofColor(0,0),ofColor(255))); + panel = gui.addPanel(parameters); + // by now needs to pass the gui parameter groups since the panel internally creates it's own group + sync.setup((ofParameterGroup&)panel->getParameter(),6667,"localhost",6666); + ofSetVerticalSync(true); +} + +//-------------------------------------------------------------- +void ofApp::update(){ + sync.update(); +} + +//-------------------------------------------------------------- +void ofApp::draw(){ + ofSetColor(color); + for(int i=0;i size; + ofParameter number; + ofParameter check; + ofParameterGroup parameters; + ofParameter color; + ofxGuiPanel* panel; + ofxGui gui; + +}; diff --git a/addons/ofxGui/examples/examplePanel/README.md b/addons/ofxGui/examples/examplePanel/README.md new file mode 100644 index 0000000..8a4b0b6 --- /dev/null +++ b/addons/ofxGui/examples/examplePanel/README.md @@ -0,0 +1,22 @@ +# About guiExample + +![Screenshot of guiExample](examplePanel.png) + +### Learning Objectives +This example shows you how to use a GUI to interact dynamically with sketch parameters. It also includes the use of listeners to check for changes. + +Pay special attention to the usage of `ofParameter`. + +### Expected Behavior + +When you open the app, you should see a screen with a hexagon and a number of sliders. Click and move the sliders to change the hexagon. + +Try changing the `circle res` slider to create a circle. Try clicking the `fill` toggle. + +Pressing the `h` key will hide and show the panel; spacebar sets color to white. + +### Classes Used in This File + +This example also uses: + + ofSoundPlayer diff --git a/addons/ofxGui/examples/examplePanel/addons.make b/addons/ofxGui/examples/examplePanel/addons.make new file mode 100644 index 0000000..66aa4c8 --- /dev/null +++ b/addons/ofxGui/examples/examplePanel/addons.make @@ -0,0 +1 @@ +ofxGuiExtended diff --git a/addons/ofxGui/examples/examplePanel/bin/data/ring.wav b/addons/ofxGui/examples/examplePanel/bin/data/ring.wav new file mode 100644 index 0000000..20da95c Binary files /dev/null and b/addons/ofxGui/examples/examplePanel/bin/data/ring.wav differ diff --git a/addons/ofxGui/examples/examplePanel/bin/data/settings.xml b/addons/ofxGui/examples/examplePanel/bin/data/settings.xml new file mode 100644 index 0000000..4cc874e --- /dev/null +++ b/addons/ofxGui/examples/examplePanel/bin/data/settings.xml @@ -0,0 +1,8 @@ + + 1 + 140 +
512, 384
+ 100, 100, 140, 255 + 5 + 1024x768 + diff --git a/addons/ofxGui/examples/examplePanel/examplePanel.png b/addons/ofxGui/examples/examplePanel/examplePanel.png new file mode 100644 index 0000000..75fd44c Binary files /dev/null and b/addons/ofxGui/examples/examplePanel/examplePanel.png differ diff --git a/addons/ofxGui/examples/examplePanel/src/main.cpp b/addons/ofxGui/examples/examplePanel/src/main.cpp new file mode 100644 index 0000000..84ca57f --- /dev/null +++ b/addons/ofxGui/examples/examplePanel/src/main.cpp @@ -0,0 +1,13 @@ +#include "ofMain.h" +#include "ofApp.h" + +//======================================================================== +int main( ){ + ofSetupOpenGL(1024,768, OF_WINDOW); // <-------- setup the GL context + + // this kicks off the running of my app + // can be OF_WINDOW or OF_FULLSCREEN + // pass in width and height too: + ofRunApp( new ofApp()); + +} diff --git a/addons/ofxGui/examples/examplePanel/src/ofApp.cpp b/addons/ofxGui/examples/examplePanel/src/ofApp.cpp new file mode 100644 index 0000000..c3435fe --- /dev/null +++ b/addons/ofxGui/examples/examplePanel/src/ofApp.cpp @@ -0,0 +1,135 @@ +#include "ofApp.h" + + +//-------------------------------------------------------------- +void ofApp::setup(){ + + ofSetFrameRate(120); + + ofSetVerticalSync(true); + + // we add this listener before setting up so the initial circle resolution is correct + circleResolution.addListener(this, &ofApp::circleResolutionChanged); + ringButton.addListener(this,&ofApp::ringButtonPressed); + + panel = gui.addPanel("panel"); + panel->setPosition(10,10); + + panel->add(filled.set("bFill", true)); + panel->add(radius.set( "radius", 140, 10, 300 )); + panel->add(center.set("center",ofVec2f(ofGetWidth()*.5,ofGetHeight()*.5),ofVec2f(0,0),ofVec2f(ofGetWidth(),ofGetHeight()))); + panel->add(color.set("color",ofColor(38,124,255,207),ofColor(0,0),ofColor(255,255))); + panel->add(circleResolution.set("circleRes", 5, 3, 90)); + panel->add(twoCircles.set("twoCircles", false)); + panel->add(ringButton.set("ring")); + panel->add(screenSize.set("screenSize", ofToString(ofGetWindowWidth()) + "x" + ofToString(ofGetWindowHeight()))); + + bHide = false; + + ring.load("ring.wav"); +} + +//-------------------------------------------------------------- +void ofApp::exit(){ + ringButton.removeListener(this,&ofApp::ringButtonPressed); +} + +//-------------------------------------------------------------- +void ofApp::circleResolutionChanged(int & circleResolution){ + ofSetCircleResolution(circleResolution); +} + +//-------------------------------------------------------------- +void ofApp::ringButtonPressed(){ + ring.play(); +} + +//-------------------------------------------------------------- +void ofApp::update(){ +} + +//-------------------------------------------------------------- +void ofApp::draw(){ + ofBackgroundGradient(ofColor::white, ofColor::gray); + + if( filled ){ + ofFill(); + }else{ + ofNoFill(); + } + + ofSetColor(color); + if(twoCircles){ + ofDrawCircle(center->x-radius*.5, center->y, radius ); + ofDrawCircle(center->x+radius*.5, center->y, radius ); + }else{ + ofDrawCircle((ofVec2f)center, radius ); + } + +} + +//-------------------------------------------------------------- +void ofApp::keyPressed(int key){ + if( key == 'h' ){ + bHide = !bHide; + panel->setHidden(bHide); + } + if(key == 's') { + panel->saveToFile("settings.xml"); + } + if(key == 'l') { + panel->loadFromFile("settings.xml"); + } + if(key == ' '){ + color = ofColor(255); + } +} + +//-------------------------------------------------------------- +void ofApp::keyReleased(int key){ + +} + +//-------------------------------------------------------------- +void ofApp::mouseMoved(int x, int y ){ + +} + +//-------------------------------------------------------------- +void ofApp::mouseDragged(int x, int y, int button){ +} + +//-------------------------------------------------------------- +void ofApp::mousePressed(int x, int y, int button){ + +} + +//-------------------------------------------------------------- +void ofApp::mouseReleased(int x, int y, int button){ + +} + +//-------------------------------------------------------------- +void ofApp::mouseEntered(int x, int y){ + +} + +//-------------------------------------------------------------- +void ofApp::mouseExited(int x, int y){ + +} + +//-------------------------------------------------------------- +void ofApp::windowResized(int w, int h){ + screenSize = ofToString(w) + "x" + ofToString(h); +} + +//-------------------------------------------------------------- +void ofApp::gotMessage(ofMessage msg){ + +} + +//-------------------------------------------------------------- +void ofApp::dragEvent(ofDragInfo dragInfo){ + +} diff --git a/addons/ofxGui/examples/examplePanel/src/ofApp.h b/addons/ofxGui/examples/examplePanel/src/ofApp.h new file mode 100644 index 0000000..6f7d37a --- /dev/null +++ b/addons/ofxGui/examples/examplePanel/src/ofApp.h @@ -0,0 +1,46 @@ +#pragma once + +#include "ofMain.h" +#include "ofxGuiExtended.h" + +class ofApp : public ofBaseApp{ + +public: + void setup(); + void update(); + void draw(); + + void exit(); + + void keyPressed(int key); + void keyReleased(int key); + void mouseMoved(int x, int y ); + void mouseDragged(int x, int y, int button); + void mousePressed(int x, int y, int button); + void mouseReleased(int x, int y, int button); + void mouseEntered(int x, int y); + void mouseExited(int x, int y); + void windowResized(int w, int h); + void dragEvent(ofDragInfo dragInfo); + void gotMessage(ofMessage msg); + + void circleResolutionChanged(int & circleResolution); + void ringButtonPressed(); + + bool bHide; + + ofParameter radius; + ofParameter color; + ofParameter center; + ofParameter circleResolution; + ofParameter filled; + ofParameter twoCircles; + ofParameter ringButton; + ofParameter screenSize; + + ofxGuiPanel* panel; + ofxGui gui; + + ofSoundPlayer ring; +}; + diff --git a/addons/ofxGui/examples/exampleParameterGroup/README.md b/addons/ofxGui/examples/exampleParameterGroup/README.md new file mode 100644 index 0000000..bc95a04 --- /dev/null +++ b/addons/ofxGui/examples/exampleParameterGroup/README.md @@ -0,0 +1,15 @@ +# parameterGroupExample + +![Screenshot of parameterGroupExample](parameterGroupExample.png) + +### Learning Objectives + +This example demonstrates how to use `ofParameterGroup` with `ofxGui`. + +### Expected Behavior + +TODO + +### Other classes used in this file + +TODO diff --git a/addons/ofxGui/examples/exampleParameterGroup/addons.make b/addons/ofxGui/examples/exampleParameterGroup/addons.make new file mode 100644 index 0000000..66aa4c8 --- /dev/null +++ b/addons/ofxGui/examples/exampleParameterGroup/addons.make @@ -0,0 +1 @@ +ofxGuiExtended diff --git a/addons/ofxGui/examples/exampleParameterGroup/parameterGroupExample.png b/addons/ofxGui/examples/exampleParameterGroup/parameterGroupExample.png new file mode 100644 index 0000000..1611e4c Binary files /dev/null and b/addons/ofxGui/examples/exampleParameterGroup/parameterGroupExample.png differ diff --git a/addons/ofxGui/examples/exampleParameterGroup/src/CirclesRenderer.cpp b/addons/ofxGui/examples/exampleParameterGroup/src/CirclesRenderer.cpp new file mode 100644 index 0000000..3c1a76c --- /dev/null +++ b/addons/ofxGui/examples/exampleParameterGroup/src/CirclesRenderer.cpp @@ -0,0 +1,36 @@ +/* + * CirclesRenderer.cpp + * + * Created on: 11/07/2012 + * Author: arturo + */ + +#include "CirclesRenderer.h" + +CirclesRenderer::CirclesRenderer() { + // TODO Auto-generated constructor stub + +} + + +void CirclesRenderer::setup(string name){ + parameters.setName(name); + parameters.add(size.set("size",10,0,100)); + parameters.add(number.set("number",2,1,20)); + parameters.add(position.set("position",ofVec2f(ofGetWidth()*.5,ofGetHeight()*.5),ofVec2f(0,0),ofVec2f(ofGetWidth(),ofGetHeight()))); + + color.set("color",ofColor(127),ofColor(0,0),ofColor(255)); + + parameters.add(color); + parameters.add(frameNum.set("frameNum",0)); +} + +void CirclesRenderer::draw(){ + // this will work only inside CirclesRenderer class + // since it's a readonly property + frameNum ++; + ofSetColor(color); + for(int i=0;i +class ofCirclesRendererParam: public ofReadOnlyParameter{ + friend class CirclesRenderer; +}; + +class CirclesRenderer { +public: + CirclesRenderer(); + + void setup(string name); + void draw(); + + ofParameterGroup parameters; + ofParameter size; + ofParameter number; + ofParameter position; + + ofParameter color; + + ofCirclesRendererParam frameNum; +}; + +#endif /* CIRCLESRENDERER_H_ */ diff --git a/addons/ofxGui/examples/exampleParameterGroup/src/main.cpp b/addons/ofxGui/examples/exampleParameterGroup/src/main.cpp new file mode 100644 index 0000000..84ca57f --- /dev/null +++ b/addons/ofxGui/examples/exampleParameterGroup/src/main.cpp @@ -0,0 +1,13 @@ +#include "ofMain.h" +#include "ofApp.h" + +//======================================================================== +int main( ){ + ofSetupOpenGL(1024,768, OF_WINDOW); // <-------- setup the GL context + + // this kicks off the running of my app + // can be OF_WINDOW or OF_FULLSCREEN + // pass in width and height too: + ofRunApp( new ofApp()); + +} diff --git a/addons/ofxGui/examples/exampleParameterGroup/src/ofApp.cpp b/addons/ofxGui/examples/exampleParameterGroup/src/ofApp.cpp new file mode 100644 index 0000000..39e71f8 --- /dev/null +++ b/addons/ofxGui/examples/exampleParameterGroup/src/ofApp.cpp @@ -0,0 +1,111 @@ +#include "ofApp.h" + +//-------------------------------------------------------------- +void ofApp::setup(){ + renderer1.setup("renderer1"); + renderer2.setup("renderer2"); + + parameters.setName("settings"); + parameters.add(vSync.set("vSync",true)); + parameters.add(renderer1.parameters); + parameters.add(renderer2.parameters); + + panel = gui.addPanel(parameters); + + panel->loadFromFile("settings.xml"); + + font.load( OF_TTF_SANS,9,true,true); + ofEnableAlphaBlending(); +} + +void ofApp::vSyncChanged(bool & vSync){ + ofSetVerticalSync(vSync); +} + + +//-------------------------------------------------------------- +void ofApp::update(){ + // frameNum is a readonly parameter so this will fail to compile + // unless we are inside the CirclesRenderer class + // renderer.frameNum = 5; +} + +//-------------------------------------------------------------- +void ofApp::draw(){ + ofBackgroundGradient(ofColor::white, ofColor::gray); + renderer1.draw(); + renderer2.draw(); + ofSetColor(255); + font.drawString("frame: " + ofToString(renderer1.frameNum),ofGetWidth()-150,20); + font.drawString("fps: " + ofToString((int)ofGetFrameRate()),ofGetWidth()-150,40); +} + +//-------------------------------------------------------------- +void ofApp::keyPressed(int key){ + if(key=='s'){ + ofSerialize(settings, parameters); + settings.save("settings.xml"); + } + if(key=='l'){ + settings.load("settings.xml"); + ofDeserialize(settings, parameters); + } + if(key=='o'){ + cout << renderer1.parameters; + cout << renderer2.parameters; + } + if(key=='r'){ + renderer1.color = ofColor(127); + renderer2.color = ofColor(127); + } +} + +//-------------------------------------------------------------- +void ofApp::keyReleased(int key){ + +} + +//-------------------------------------------------------------- +void ofApp::mouseMoved(int x, int y ){ + +} + +//-------------------------------------------------------------- +void ofApp::mouseDragged(int x, int y, int button){ + +} + +//-------------------------------------------------------------- +void ofApp::mousePressed(int x, int y, int button){ + +} + +//-------------------------------------------------------------- +void ofApp::mouseReleased(int x, int y, int button){ + +} + +//-------------------------------------------------------------- +void ofApp::mouseEntered(int x, int y){ + +} + +//-------------------------------------------------------------- +void ofApp::mouseExited(int x, int y){ + +} + +//-------------------------------------------------------------- +void ofApp::windowResized(int w, int h){ + +} + +//-------------------------------------------------------------- +void ofApp::gotMessage(ofMessage msg){ + +} + +//-------------------------------------------------------------- +void ofApp::dragEvent(ofDragInfo dragInfo){ + +} diff --git a/addons/ofxGui/examples/exampleParameterGroup/src/ofApp.h b/addons/ofxGui/examples/exampleParameterGroup/src/ofApp.h new file mode 100644 index 0000000..dcbfc7c --- /dev/null +++ b/addons/ofxGui/examples/exampleParameterGroup/src/ofApp.h @@ -0,0 +1,35 @@ +#pragma once + +#include "ofMain.h" +#include "ofxGuiExtended.h" +#include "CirclesRenderer.h" + +class ofApp : public ofBaseApp{ + + public: + void setup(); + void update(); + void draw(); + + void keyPressed (int key); + void keyReleased(int key); + void mouseMoved(int x, int y ); + void mouseDragged(int x, int y, int button); + void mousePressed(int x, int y, int button); + void mouseReleased(int x, int y, int button); + void mouseEntered(int x, int y); + void mouseExited(int x, int y); + void windowResized(int w, int h); + void dragEvent(ofDragInfo dragInfo); + void gotMessage(ofMessage msg); + + void vSyncChanged(bool & vSync); + + ofxGui gui; + ofxGuiPanel* panel; + ofParameter vSync; + ofParameterGroup parameters; + ofXml settings; + CirclesRenderer renderer1,renderer2; + ofTrueTypeFont font; +}; diff --git a/addons/ofxGui/examples/exampleThemes/README.md b/addons/ofxGui/examples/exampleThemes/README.md new file mode 100644 index 0000000..c32ab4b --- /dev/null +++ b/addons/ofxGui/examples/exampleThemes/README.md @@ -0,0 +1,19 @@ +# exampleThemes + +![Screenshot of exampleThemes](exampleThemes.png) + +### Learning Objectives + +This example demonstrates how to write your own theme for the GUI. It is written in JSON and placed in a separate file. It does not need to be recompiled after changing the theme. + +Pay attention to the structure of the JSON theme file. You'll find more information about how to write the theme on [this page](https://github.com/frauzufall/ofxGuiExtended/#styling-items-by-type-via-theme). + +### Expected Behavior + +When starting the program you see two panels showing settings for a circle renderer. The rendered circles are displayed in the middle. You can control each set of circles with one panel. +The panels have different styles. The theme JSON file for the left panel is `bin/data/theme_default.json`. The right panel is styled by `bin/data/theme_light.json`. + +### Other classes used in this file + +- `ofParameter` +- `ofParameterGroup` diff --git a/addons/ofxGui/examples/exampleThemes/addons.make b/addons/ofxGui/examples/exampleThemes/addons.make new file mode 100644 index 0000000..66aa4c8 --- /dev/null +++ b/addons/ofxGui/examples/exampleThemes/addons.make @@ -0,0 +1 @@ +ofxGuiExtended diff --git a/addons/ofxGui/examples/exampleThemes/bin/data/fonts/Ubuntu-L.ttf b/addons/ofxGui/examples/exampleThemes/bin/data/fonts/Ubuntu-L.ttf new file mode 100644 index 0000000..7b7ac7d Binary files /dev/null and b/addons/ofxGui/examples/exampleThemes/bin/data/fonts/Ubuntu-L.ttf differ diff --git a/addons/ofxGui/examples/exampleThemes/bin/data/fonts/UbuntuMono-B.ttf b/addons/ofxGui/examples/exampleThemes/bin/data/fonts/UbuntuMono-B.ttf new file mode 100644 index 0000000..7bd6665 Binary files /dev/null and b/addons/ofxGui/examples/exampleThemes/bin/data/fonts/UbuntuMono-B.ttf differ diff --git a/addons/ofxGui/examples/exampleThemes/bin/data/fonts/UbuntuMono-R.ttf b/addons/ofxGui/examples/exampleThemes/bin/data/fonts/UbuntuMono-R.ttf new file mode 100644 index 0000000..fdd309d Binary files /dev/null and b/addons/ofxGui/examples/exampleThemes/bin/data/fonts/UbuntuMono-R.ttf differ diff --git a/addons/ofxGui/examples/exampleThemes/bin/data/fonts/ubuntu-font-licence-1.0.txt b/addons/ofxGui/examples/exampleThemes/bin/data/fonts/ubuntu-font-licence-1.0.txt new file mode 100644 index 0000000..ae78a8f --- /dev/null +++ b/addons/ofxGui/examples/exampleThemes/bin/data/fonts/ubuntu-font-licence-1.0.txt @@ -0,0 +1,96 @@ +------------------------------- +UBUNTU FONT LICENCE Version 1.0 +------------------------------- + +PREAMBLE +This licence allows the licensed fonts to be used, studied, modified and +redistributed freely. The fonts, including any derivative works, can be +bundled, embedded, and redistributed provided the terms of this licence +are met. The fonts and derivatives, however, cannot be released under +any other licence. The requirement for fonts to remain under this +licence does not require any document created using the fonts or their +derivatives to be published under this licence, as long as the primary +purpose of the document is not to be a vehicle for the distribution of +the fonts. + +DEFINITIONS +"Font Software" refers to the set of files released by the Copyright +Holder(s) under this licence and clearly marked as such. This may +include source files, build scripts and documentation. + +"Original Version" refers to the collection of Font Software components +as received under this licence. + +"Modified Version" refers to any derivative made by adding to, deleting, +or substituting -- in part or in whole -- any of the components of the +Original Version, by changing formats or by porting the Font Software to +a new environment. + +"Copyright Holder(s)" refers to all individuals and companies who have a +copyright ownership of the Font Software. + +"Substantially Changed" refers to Modified Versions which can be easily +identified as dissimilar to the Font Software by users of the Font +Software comparing the Original Version with the Modified Version. + +To "Propagate" a work means to do anything with it that, without +permission, would make you directly or secondarily liable for +infringement under applicable copyright law, except executing it on a +computer or modifying a private copy. Propagation includes copying, +distribution (with or without modification and with or without charging +a redistribution fee), making available to the public, and in some +countries other activities as well. + +PERMISSION & CONDITIONS +This licence does not grant any rights under trademark law and all such +rights are reserved. + +Permission is hereby granted, free of charge, to any person obtaining a +copy of the Font Software, to propagate the Font Software, subject to +the below conditions: + +1) Each copy of the Font Software must contain the above copyright +notice and this licence. These can be included either as stand-alone +text files, human-readable headers or in the appropriate machine- +readable metadata fields within text or binary files as long as those +fields can be easily viewed by the user. + +2) The font name complies with the following: +(a) The Original Version must retain its name, unmodified. +(b) Modified Versions which are Substantially Changed must be renamed to +avoid use of the name of the Original Version or similar names entirely. +(c) Modified Versions which are not Substantially Changed must be +renamed to both (i) retain the name of the Original Version and (ii) add +additional naming elements to distinguish the Modified Version from the +Original Version. The name of such Modified Versions must be the name of +the Original Version, with "derivative X" where X represents the name of +the new work, appended to that name. + +3) The name(s) of the Copyright Holder(s) and any contributor to the +Font Software shall not be used to promote, endorse or advertise any +Modified Version, except (i) as required by this licence, (ii) to +acknowledge the contribution(s) of the Copyright Holder(s) or (iii) with +their explicit written permission. + +4) The Font Software, modified or unmodified, in part or in whole, must +be distributed entirely under this licence, and must not be distributed +under any other licence. The requirement for fonts to remain under this +licence does not affect any document created using the Font Software, +except any version of the Font Software extracted from a document +created using the Font Software may only be distributed under this +licence. + +TERMINATION +This licence becomes null and void if any of the above conditions are +not met. + +DISCLAIMER +THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF +COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE +COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL +DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM OTHER +DEALINGS IN THE FONT SOFTWARE. diff --git a/addons/ofxGui/examples/exampleThemes/bin/data/theme3.json b/addons/ofxGui/examples/exampleThemes/bin/data/theme3.json new file mode 100644 index 0000000..38b9cad --- /dev/null +++ b/addons/ofxGui/examples/exampleThemes/bin/data/theme3.json @@ -0,0 +1,48 @@ +{ + "theme3": { + "base": { + "background-color": "rgba(0,0,0,0.3)", + "fill-color": "rgb(220,180,50)", + "border-width": 1, + "padding": 2, + "border-color": "rgba(0,0,0,0.4)", + "margin": 5, + "text-color": "#000000", + "text-padding": 2, + "border-radius": 5 + }, + + "panel": { + "width": 300, + "direction": "vertical", + "show-header": true, + "background-color": "transparent", + "padding": 10, + "show-header": false + }, + + "group": { + "width": "100%", + "background-color": "transparent", + "padding": 5, + "margin": "0 0 5 0" + }, + + "group-header": { + "height": 39, + "border-width": 0, + "background-color": "transparent", + "text-color": "#000000" + }, + + "slider": { + "precision": 3 + }, + + "toggle": { + "type": "radio" + } + + + } +} diff --git a/addons/ofxGui/examples/exampleThemes/bin/data/theme_default.json b/addons/ofxGui/examples/exampleThemes/bin/data/theme_default.json new file mode 100644 index 0000000..4944380 --- /dev/null +++ b/addons/ofxGui/examples/exampleThemes/bin/data/theme_default.json @@ -0,0 +1,59 @@ +{ + "default": { + "base": { + "background-color": "rgba(0,0,0,0.2)", + "fill-color": "rgba(200,200,200,0.42)", + "border-width": 1, + "padding": 2, + "border-color": "rgb(255,255,255)", + "margin": 4, + "text-color": "#ffffff" + }, + "toggle": { + + }, + "button": { + + }, + "slider": { + + }, + "label": { + "border-width": 0, + "background-color": "rgba(0,0,0,0)" + }, + "group": { + "border-color": "rgba(255,255,255,0.7)", + "padding": 0, + "border-width": 0 + }, + "group-header": { + "align-self": "flex-start", + "flex": "none", + "width": "100%", + "margin": 0, + "border-width": 0, + "padding": 0, + "text-color": "#ffffff" + }, + "panel": { + + }, + "panel-header": { + + }, + "tabs": { + "show-header": false, + "margin-top": 10 + }, + "value-plotter": { + + }, + "function-plotter": { + + }, + "input-field": { + + } + } +} diff --git a/addons/ofxGui/examples/exampleThemes/bin/data/theme_light.json b/addons/ofxGui/examples/exampleThemes/bin/data/theme_light.json new file mode 100644 index 0000000..23fb36d --- /dev/null +++ b/addons/ofxGui/examples/exampleThemes/bin/data/theme_light.json @@ -0,0 +1,25 @@ +{ + "default": { + "base": { + "background-color": "rgba(255,255,255,0.2)", + "fill-color": "rgba(255,255,255,0.7)", + "border-width": 0, + "padding": 1, + "margin": 3, + "text-color": "#000000", + "font-family": "fonts/UbuntuMono-B.ttf", + "font-size": 10, + "text-padding": 2 + }, + "group": { + "border-color": "#2da1e3", + "padding": 1, + "border-width": 1, + "margin-left": 10 + }, + "group-header": { + "background-color": "#2da1e3", + "text-color": "#ffffff" + } + } +} diff --git a/addons/ofxGui/examples/exampleThemes/exampleThemes.png b/addons/ofxGui/examples/exampleThemes/exampleThemes.png new file mode 100644 index 0000000..e4c7df0 Binary files /dev/null and b/addons/ofxGui/examples/exampleThemes/exampleThemes.png differ diff --git a/addons/ofxGui/examples/exampleThemes/src/CirclesRenderer.cpp b/addons/ofxGui/examples/exampleThemes/src/CirclesRenderer.cpp new file mode 100644 index 0000000..d9f4ffc --- /dev/null +++ b/addons/ofxGui/examples/exampleThemes/src/CirclesRenderer.cpp @@ -0,0 +1,39 @@ +/* + * CirclesRenderer.cpp + * + * Created on: 11/07/2012 + * Author: arturo + */ + +#include "CirclesRenderer.h" + +CirclesRenderer::CirclesRenderer() { + // TODO Auto-generated constructor stub + +} + + +void CirclesRenderer::setup(string name){ + parameters.setName(name); + parameters.add(show.set("visible", true)); + parameters.add(size.set("size",10,0,100)); + parameters.add(number.set("number",2,1,20)); + parameters.add(position.set("position",ofVec2f(ofGetWidth()*.5,ofGetHeight()*.5),ofVec2f(0,0),ofVec2f(ofGetWidth(),ofGetHeight()))); + + color.set("color",ofColor(127),ofColor(0,0),ofColor(255)); + + parameters.add(color); + parameters.add(frameNum.set("frameNum",0)); +} + +void CirclesRenderer::draw(){ + // this will work only inside CirclesRenderer class + // since it's a readonly property + if(show){ + frameNum ++; + ofSetColor(color); + for(int i=0;i +class ofCirclesRendererParam: public ofReadOnlyParameter{ + friend class CirclesRenderer; +}; + +class CirclesRenderer { +public: + CirclesRenderer(); + + void setup(string name); + void draw(); + + ofParameterGroup parameters; + ofParameter size; + ofParameter number; + ofParameter show; + ofParameter position; + + ofParameter color; + + ofCirclesRendererParam frameNum; +}; + +#endif /* CIRCLESRENDERER_H_ */ diff --git a/addons/ofxGui/examples/exampleThemes/src/main.cpp b/addons/ofxGui/examples/exampleThemes/src/main.cpp new file mode 100644 index 0000000..84ca57f --- /dev/null +++ b/addons/ofxGui/examples/exampleThemes/src/main.cpp @@ -0,0 +1,13 @@ +#include "ofMain.h" +#include "ofApp.h" + +//======================================================================== +int main( ){ + ofSetupOpenGL(1024,768, OF_WINDOW); // <-------- setup the GL context + + // this kicks off the running of my app + // can be OF_WINDOW or OF_FULLSCREEN + // pass in width and height too: + ofRunApp( new ofApp()); + +} diff --git a/addons/ofxGui/examples/exampleThemes/src/ofApp.cpp b/addons/ofxGui/examples/exampleThemes/src/ofApp.cpp new file mode 100644 index 0000000..bf7d462 --- /dev/null +++ b/addons/ofxGui/examples/exampleThemes/src/ofApp.cpp @@ -0,0 +1,91 @@ +#include "ofApp.h" + +//-------------------------------------------------------------- +void ofApp::setup(){ + + ofSetFrameRate(120); + + renderer1.setup("renderer1"); + renderer2.setup("renderer2"); + renderer3.setup("renderer3"); + + gui.setupFlexBoxLayout(); + + ofxGuiPanel* panel1 = gui.addPanel(renderer1.parameters); + panel1->loadTheme("theme_default.json", true); + + ofxGuiPanel* panel2 = gui.addPanel(renderer2.parameters); + panel2->loadTheme("theme_light.json", true); + panel2->setPosition(panel1->getShape().getTopRight()+ofPoint(10, 0)); + + ofxGuiPanel* panel3 = gui.addPanel(renderer3.parameters); + panel3->loadTheme("theme3.json", true); + panel3->setPosition(panel2->getShape().getTopRight()+ofPoint(10, 0)); + +} + + +//-------------------------------------------------------------- +void ofApp::update(){ +} + +//-------------------------------------------------------------- +void ofApp::draw(){ + ofBackgroundGradient(ofColor::white, ofColor::gray); + renderer1.draw(); + renderer2.draw(); + renderer3.draw(); +} + +//-------------------------------------------------------------- +void ofApp::keyPressed(int key){ +} + +//-------------------------------------------------------------- +void ofApp::keyReleased(int key){ + +} + +//-------------------------------------------------------------- +void ofApp::mouseMoved(int x, int y ){ + +} + +//-------------------------------------------------------------- +void ofApp::mouseDragged(int x, int y, int button){ + +} + +//-------------------------------------------------------------- +void ofApp::mousePressed(int x, int y, int button){ + +} + +//-------------------------------------------------------------- +void ofApp::mouseReleased(int x, int y, int button){ + +} + +//-------------------------------------------------------------- +void ofApp::mouseEntered(int x, int y){ + +} + +//-------------------------------------------------------------- +void ofApp::mouseExited(int x, int y){ + +} + +//-------------------------------------------------------------- +void ofApp::windowResized(int w, int h){ +} + +//-------------------------------------------------------------- +void ofApp::gotMessage(ofMessage msg){ + +} + +//-------------------------------------------------------------- +void ofApp::dragEvent(ofDragInfo dragInfo){ + +} diff --git a/addons/ofxGui/examples/exampleThemes/src/ofApp.h b/addons/ofxGui/examples/exampleThemes/src/ofApp.h new file mode 100644 index 0000000..2a3ead7 --- /dev/null +++ b/addons/ofxGui/examples/exampleThemes/src/ofApp.h @@ -0,0 +1,29 @@ +#pragma once + +#include "ofMain.h" +#include "ofxGuiExtended.h" +#include "CirclesRenderer.h" + +class ofApp : public ofBaseApp{ + + public: + void setup(); + void update(); + void draw(); + + void keyPressed (int key); + void keyReleased(int key); + void mouseMoved(int x, int y ); + void mouseDragged(int x, int y, int button); + void mousePressed(int x, int y, int button); + void mouseReleased(int x, int y, int button); + void mouseEntered(int x, int y); + void mouseExited(int x, int y); + void windowResized(int w, int h); + void dragEvent(ofDragInfo dragInfo); + void gotMessage(ofMessage msg); + + ofxGui gui; + ofParameterGroup parameters; + CirclesRenderer renderer1, renderer2, renderer3; +}; diff --git a/addons/ofxGui/examples/exampleXBadPractice/README.md b/addons/ofxGui/examples/exampleXBadPractice/README.md new file mode 100644 index 0000000..fb3edac --- /dev/null +++ b/addons/ofxGui/examples/exampleXBadPractice/README.md @@ -0,0 +1,22 @@ +# About badPracticeGuiExample + +![Screenshot of xBadPracticeGuiExample](xBadPracticeGuiExample.png) + +### Learning Objectives +This example is similar to `guiExample`. It uses pointers to gui elements instead of `ofParameter`. This is not advised and this example could be deleted though we could keep it in case someone asks _"I want to store buttons and toggles and sliders and use them to do math"_. We can answer _"Sure, have a look at the badPracticeGuiExample."_. Which is probably why you are here. Go to `guiExample` and learn how to use `ofParameter`, you won't regret it. + +### Expected Behavior + +When you open the app, you should see a screen with a hexagon and a number of sliders. Click and move the sliders to change the hexagon. + +Try changing the `circle res` slider to create a circle. Try clicking the `fill` toggle. + +Pressing the `h` key will hide and show the panel; spacebar sets color to white. + +### Classes Used in This File + +TODO + +This example also uses: + + ofSoundPlayer diff --git a/addons/ofxGui/examples/exampleXBadPractice/addons.make b/addons/ofxGui/examples/exampleXBadPractice/addons.make new file mode 100644 index 0000000..66aa4c8 --- /dev/null +++ b/addons/ofxGui/examples/exampleXBadPractice/addons.make @@ -0,0 +1 @@ +ofxGuiExtended diff --git a/addons/ofxGui/examples/exampleXBadPractice/bin/data/ring.wav b/addons/ofxGui/examples/exampleXBadPractice/bin/data/ring.wav new file mode 100644 index 0000000..20da95c Binary files /dev/null and b/addons/ofxGui/examples/exampleXBadPractice/bin/data/ring.wav differ diff --git a/addons/ofxGui/examples/exampleXBadPractice/src/main.cpp b/addons/ofxGui/examples/exampleXBadPractice/src/main.cpp new file mode 100644 index 0000000..cf76611 --- /dev/null +++ b/addons/ofxGui/examples/exampleXBadPractice/src/main.cpp @@ -0,0 +1,14 @@ +#include "ofMain.h" +#include "ofApp.h" + +//======================================================================== +int main( ){ + + ofSetupOpenGL(1024,768, OF_WINDOW);// <-------- setup the GL context + + // this kicks off the running of my app + // can be OF_WINDOW or OF_FULLSCREEN + // pass in width and height too: + ofRunApp( new ofApp()); + +} diff --git a/addons/ofxGui/examples/exampleXBadPractice/src/ofApp.cpp b/addons/ofxGui/examples/exampleXBadPractice/src/ofApp.cpp new file mode 100644 index 0000000..2c7fce2 --- /dev/null +++ b/addons/ofxGui/examples/exampleXBadPractice/src/ofApp.cpp @@ -0,0 +1,129 @@ +#include "ofApp.h" + +//-------------------------------------------------------------- +void ofApp::setup(){ + + ofSetFrameRate(60); + + ofSetVerticalSync(true); + + panel = gui.addPanel("panel"); + + filled = panel->add("fill"); + radius = panel->add("radius", 140, 10, 300); + center = panel->add("center", ofVec2f(ofGetWidth()*.5, ofGetHeight()*.5), ofVec2f(0, 0), ofVec2f(ofGetWidth(), ofGetHeight())); + color = panel->add("color", ofColor(100, 100, 140), ofColor(0, 0), ofColor(255, 255)); + circleResolution = panel->add("circle res", 5, 3, 90); + twoCircles = panel->add("two circles"); + ringButton = panel->add("ring"); + screenSize = panel->add("screen size", ofToString(ofGetWidth())+"x"+ofToString(ofGetHeight())); + + ringButton->addListener(this, &ofApp::ringButtonPressed); + //ugly fix to trigger initial value + ringButton->getParameter().cast().set(*ringButton); + + bHide = false; + + ring.load("ring.wav"); +} + +//-------------------------------------------------------------- +void ofApp::exit(){ + ringButton->removeListener(this, &ofApp::ringButtonPressed); +} + +//-------------------------------------------------------------- +void ofApp::ringButtonPressed(){ + ring.play(); +} + +//-------------------------------------------------------------- +void ofApp::update(){ + ofSetCircleResolution(*circleResolution); +} + +//-------------------------------------------------------------- +void ofApp::draw(){ + ofBackgroundGradient(ofColor::white, ofColor::gray); + + if(*filled){ + ofFill(); + }else{ + ofNoFill(); + } + + ofSetColor(*color); + if(*twoCircles){ + ofDrawCircle((*center)->x-*radius*.5, (*center)->y, *radius ); + ofDrawCircle((*center)->x+*radius*.5, (*center)->y, *radius ); + }else{ + ofDrawCircle((ofVec2f)*center, *radius ); + } + +} + +//-------------------------------------------------------------- +void ofApp::keyPressed(int key){ + if(key == 'h'){ + bHide = !bHide; + } + else if(key == 's'){ + panel->saveToFile("settings.xml"); + } + else if(key == 'l'){ + panel->loadFromFile("settings.xml"); + } + else if(key == ' '){ + *color = ofColor(255); + } +} + +//-------------------------------------------------------------- +void ofApp::keyReleased(int key){ + +} + +//-------------------------------------------------------------- +void ofApp::mouseMoved(int x, int y ){ + +} + +//-------------------------------------------------------------- +void ofApp::mouseDragged(int x, int y, int button){ + +} + +//-------------------------------------------------------------- +void ofApp::mousePressed(int x, int y, int button){ + +} + +//-------------------------------------------------------------- +void ofApp::mouseReleased(int x, int y, int button){ + +} + +//-------------------------------------------------------------- +void ofApp::mouseEntered(int x, int y){ + +} + +//-------------------------------------------------------------- +void ofApp::mouseExited(int x, int y){ + +} + +//-------------------------------------------------------------- +void ofApp::windowResized(int w, int h){ + *screenSize = ofToString(w) + "x" + ofToString(h); +} + +//-------------------------------------------------------------- +void ofApp::gotMessage(ofMessage msg){ + +} + +//-------------------------------------------------------------- +void ofApp::dragEvent(ofDragInfo dragInfo){ + +} diff --git a/addons/ofxGui/examples/exampleXBadPractice/src/ofApp.h b/addons/ofxGui/examples/exampleXBadPractice/src/ofApp.h new file mode 100644 index 0000000..da6d58c --- /dev/null +++ b/addons/ofxGui/examples/exampleXBadPractice/src/ofApp.h @@ -0,0 +1,45 @@ +#pragma once + +#include "ofMain.h" +#include "ofxGuiExtended.h" + +class ofApp : public ofBaseApp{ + +public: + void setup(); + void update(); + void draw(); + + void exit(); + + void keyPressed(int key); + void keyReleased(int key); + void mouseMoved(int x, int y ); + void mouseDragged(int x, int y, int button); + void mousePressed(int x, int y, int button); + void mouseReleased(int x, int y, int button); + void mouseEntered(int x, int y); + void mouseExited(int x, int y); + void windowResized(int w, int h); + void dragEvent(ofDragInfo dragInfo); + void gotMessage(ofMessage msg); + + void ringButtonPressed(); + + bool bHide; + + ofxGuiFloatSlider* radius; + ofxGuiColorSlider* color; + ofxGuiVec2Slider* center; + ofxGuiIntSlider* circleResolution; + ofxGuiToggle* filled; + ofxGuiButton* twoCircles; + ofxGuiButton* ringButton; + ofxGuiLabel* screenSize; + + ofxGuiPanel* panel; + ofxGui gui; + + ofSoundPlayer ring; +}; + diff --git a/addons/ofxGui/examples/exampleXBadPractice/xBadPracticeGuiExample.png b/addons/ofxGui/examples/exampleXBadPractice/xBadPracticeGuiExample.png new file mode 100644 index 0000000..7527ba5 Binary files /dev/null and b/addons/ofxGui/examples/exampleXBadPractice/xBadPracticeGuiExample.png differ diff --git a/addons/ofxGui/examples/testFlexBox/README.md b/addons/ofxGui/examples/testFlexBox/README.md new file mode 100644 index 0000000..a52771c --- /dev/null +++ b/addons/ofxGui/examples/testFlexBox/README.md @@ -0,0 +1,5 @@ +# testLayout + +### Purpose + +This test application has the purpose to test the different attributes of the `ofxDOMFlexBoxLayout`. diff --git a/addons/ofxGui/examples/testFlexBox/addons.make b/addons/ofxGui/examples/testFlexBox/addons.make new file mode 100644 index 0000000..66aa4c8 --- /dev/null +++ b/addons/ofxGui/examples/testFlexBox/addons.make @@ -0,0 +1 @@ +ofxGuiExtended diff --git a/addons/ofxGui/examples/testFlexBox/src/main.cpp b/addons/ofxGui/examples/testFlexBox/src/main.cpp new file mode 100644 index 0000000..84ca57f --- /dev/null +++ b/addons/ofxGui/examples/testFlexBox/src/main.cpp @@ -0,0 +1,13 @@ +#include "ofMain.h" +#include "ofApp.h" + +//======================================================================== +int main( ){ + ofSetupOpenGL(1024,768, OF_WINDOW); // <-------- setup the GL context + + // this kicks off the running of my app + // can be OF_WINDOW or OF_FULLSCREEN + // pass in width and height too: + ofRunApp( new ofApp()); + +} diff --git a/addons/ofxGui/examples/testFlexBox/src/ofApp.cpp b/addons/ofxGui/examples/testFlexBox/src/ofApp.cpp new file mode 100644 index 0000000..71328ed --- /dev/null +++ b/addons/ofxGui/examples/testFlexBox/src/ofApp.cpp @@ -0,0 +1,206 @@ +#include "ofApp.h" + +//-------------------------------------------------------------- +void ofApp::setup(){ + + ofSetFrameRate(120); + + gui.setupFlexBoxLayout(); + + ofxGuiGroup* all = gui.addGroup("", ofJson({ + {"flex-direction", "column"}, + {"background-color", "#rgba(0,0,0,0)"}, + {"flex", 1}, + {"margin", 0}, + {"padding", 0}, + {"width", "100%"}, + {"show-header", false}, + {"position", "static"} + })); + + ofxGuiGroup* control = all->addGroup("control", ofJson({ + {"show-header", false}, + {"flex-direction", "row"}, + {"height", 50} + })); + + ofJson controlGroupConfig = {{"width", 200}}; + + justifyContent = control->addGroup("justify-content", controlGroupConfig); + justifyContent->add("flex-start"); + justifyContent->add("flex-end"); + justifyContent->add("center"); + justifyContent->add("space-between"); + justifyContent->add("space-around"); + justifyContent->setExclusiveToggles(true); + justifyContent->setActiveToggle(0); + + + alignItems = control->addGroup("align-items", controlGroupConfig); + alignItems->add("stretch"); + alignItems->add("flex-start"); + alignItems->add("flex-end"); + alignItems->add("center"); + alignItems->setExclusiveToggles(true); + alignItems->setActiveToggle(0); + + alignContent = control->addGroup("align-content", controlGroupConfig); + alignContent->add("stretch"); + alignContent->add("flex-start"); + alignContent->add("flex-end"); + alignContent->add("center"); + alignContent->add("space-between"); + alignContent->add("space-around"); + alignContent->setExclusiveToggles(true); + alignContent->setActiveToggle(0); + + ofxGuiGroup* groupsGroup = all->addGroup("", ofJson({ + {"flex-direction", "row"}, + {"flex", 1}, + {"show-header", false} + })); + + groups.push_back(groupsGroup->addGroup("flex-direction: column", ofJson({ + {"flex-direction", "column"}, + {"flex", 1}, + {"flex-wrap", "wrap"}, + {"show-header", false}, + {"background-color", "#F40056"}, + }))); + + groups.push_back(groupsGroup->addGroup("flex-direction: row", ofJson({ + {"flex-direction", "row"}, + {"flex", 1}, + {"flex-wrap", "wrap"}, + {"show-header", false}, + {"background-color", "#2377BA"} + }))); + + for(ofxGuiGroup* group : groups){ + for(int i = 0; i < 22; i++){ + group->addLabel(ofToString(i), ofJson({ + {"border-width", 1}, + {"width", ofRandom(20, 70)}, + {"height", ofRandom(20, 70)} + })); + } + } + + justifyContent->getActiveToggleIndex().addListener(this, &ofApp::setJustifyContent); + alignItems->getActiveToggleIndex().addListener(this, &ofApp::setAlignItems); + alignContent->getActiveToggleIndex().addListener(this, &ofApp::setAlignContent); + +} + +void ofApp::exit(){ + justifyContent->getActiveToggleIndex().removeListener(this, &ofApp::setJustifyContent); + alignItems->getActiveToggleIndex().removeListener(this, &ofApp::setAlignItems); + alignContent->getActiveToggleIndex().removeListener(this, &ofApp::setAlignContent); +} + +void ofApp::setAlignContent(int &index){ + std::string value; + switch(index){ + case 1: value = "flex-start"; break; + case 2: value = "flex-end"; break; + case 3: value = "center"; break; + case 4: value = "space-between"; break; + case 5: value = "space-around"; break; + default: case 0: value = "stretch"; break; + } + + for(ofxGuiGroup* group : groups){ + group->setConfig(ofJson({{"align-content", value}})); + } +} + +void ofApp::setAlignItems(int &index){ + std::string value; + switch(index){ + case 1: value = "flex-start"; break; + case 2: value = "flex-end"; break; + case 3: value = "center"; break; + default: case 0: value = "stretch"; break; + } + + for(ofxGuiGroup* group : groups){ + group->setConfig(ofJson({{"align-items", value}})); + } +} + +void ofApp::setJustifyContent(int &index){ + std::string value; + switch(index){ + case 1: value = "flex-end"; break; + case 2: value = "center"; break; + case 3: value = "space-between"; break; + case 4: value = "space-around"; break; + default: case 0: value = "flex-start"; break; + } + + for(ofxGuiGroup* group : groups){ + group->setConfig(ofJson({{"justify-content", value}})); + } +} + +//-------------------------------------------------------------- +void ofApp::update(){ +} + +//-------------------------------------------------------------- +void ofApp::draw(){ + ofBackgroundGradient(ofColor::white, ofColor::gray); +} + +//-------------------------------------------------------------- +void ofApp::keyPressed(int key){ +} + +//-------------------------------------------------------------- +void ofApp::keyReleased(int key){ + +} + +//-------------------------------------------------------------- +void ofApp::mouseMoved(int x, int y ){ + +} + +//-------------------------------------------------------------- +void ofApp::mouseDragged(int x, int y, int button){ + +} + +//-------------------------------------------------------------- +void ofApp::mousePressed(int x, int y, int button){ + +} + +//-------------------------------------------------------------- +void ofApp::mouseReleased(int x, int y, int button){ + +} + +//-------------------------------------------------------------- +void ofApp::mouseEntered(int x, int y){ + +} + +//-------------------------------------------------------------- +void ofApp::mouseExited(int x, int y){ + +} + +//-------------------------------------------------------------- +void ofApp::windowResized(int w, int h){ +} + +//-------------------------------------------------------------- +void ofApp::gotMessage(ofMessage msg){ + +} + +//-------------------------------------------------------------- +void ofApp::dragEvent(ofDragInfo dragInfo){ + +} diff --git a/addons/ofxGui/examples/testFlexBox/src/ofApp.h b/addons/ofxGui/examples/testFlexBox/src/ofApp.h new file mode 100644 index 0000000..510874b --- /dev/null +++ b/addons/ofxGui/examples/testFlexBox/src/ofApp.h @@ -0,0 +1,38 @@ +#pragma once + +#include "ofMain.h" +#include "ofxGuiExtended.h" + +class ofApp : public ofBaseApp{ + + public: + void setup(); + void update(); + void draw(); + void exit(); + + void keyPressed (int key); + void keyReleased(int key); + void mouseMoved(int x, int y ); + void mouseDragged(int x, int y, int button); + void mousePressed(int x, int y, int button); + void mouseReleased(int x, int y, int button); + void mouseEntered(int x, int y); + void mouseExited(int x, int y); + void windowResized(int w, int h); + void dragEvent(ofDragInfo dragInfo); + void gotMessage(ofMessage msg); + + void setJustifyContent(int& index); + void setAlignItems(int& index); + void setAlignContent(int& index); + + ofxGui gui; + + vector groups; + + ofxGuiGroup* justifyContent; + ofxGuiGroup* alignItems; + ofxGuiGroup* alignContent; + +}; diff --git a/addons/ofxGui/examples/testLayout/README.md b/addons/ofxGui/examples/testLayout/README.md new file mode 100644 index 0000000..7f6247b --- /dev/null +++ b/addons/ofxGui/examples/testLayout/README.md @@ -0,0 +1,5 @@ +# testLayout + +### Purpose + +This test application is meant as a tool to test the implementation of `ofxDOMBoxLayout` and `ofxDOMFlexBoxLayout`. If you use simple controls, panels and groups and align them without using special flexbox attributes, both layouts should create the same output. This app adds a set of panels created by each of the layouts and you can switch between the two versions via the toggles on the top. Both versions should look the same, I just added some color differences to be able to see that the switching between the layouts works. diff --git a/addons/ofxGui/examples/testLayout/addons.make b/addons/ofxGui/examples/testLayout/addons.make new file mode 100644 index 0000000..66aa4c8 --- /dev/null +++ b/addons/ofxGui/examples/testLayout/addons.make @@ -0,0 +1 @@ +ofxGuiExtended diff --git a/addons/ofxGui/examples/testLayout/bin/data/fonts/UbuntuMono-B.ttf b/addons/ofxGui/examples/testLayout/bin/data/fonts/UbuntuMono-B.ttf new file mode 100644 index 0000000..7bd6665 Binary files /dev/null and b/addons/ofxGui/examples/testLayout/bin/data/fonts/UbuntuMono-B.ttf differ diff --git a/addons/ofxGui/examples/testLayout/bin/data/fonts/ubuntu-font-licence-1.0.txt b/addons/ofxGui/examples/testLayout/bin/data/fonts/ubuntu-font-licence-1.0.txt new file mode 100644 index 0000000..ae78a8f --- /dev/null +++ b/addons/ofxGui/examples/testLayout/bin/data/fonts/ubuntu-font-licence-1.0.txt @@ -0,0 +1,96 @@ +------------------------------- +UBUNTU FONT LICENCE Version 1.0 +------------------------------- + +PREAMBLE +This licence allows the licensed fonts to be used, studied, modified and +redistributed freely. The fonts, including any derivative works, can be +bundled, embedded, and redistributed provided the terms of this licence +are met. The fonts and derivatives, however, cannot be released under +any other licence. The requirement for fonts to remain under this +licence does not require any document created using the fonts or their +derivatives to be published under this licence, as long as the primary +purpose of the document is not to be a vehicle for the distribution of +the fonts. + +DEFINITIONS +"Font Software" refers to the set of files released by the Copyright +Holder(s) under this licence and clearly marked as such. This may +include source files, build scripts and documentation. + +"Original Version" refers to the collection of Font Software components +as received under this licence. + +"Modified Version" refers to any derivative made by adding to, deleting, +or substituting -- in part or in whole -- any of the components of the +Original Version, by changing formats or by porting the Font Software to +a new environment. + +"Copyright Holder(s)" refers to all individuals and companies who have a +copyright ownership of the Font Software. + +"Substantially Changed" refers to Modified Versions which can be easily +identified as dissimilar to the Font Software by users of the Font +Software comparing the Original Version with the Modified Version. + +To "Propagate" a work means to do anything with it that, without +permission, would make you directly or secondarily liable for +infringement under applicable copyright law, except executing it on a +computer or modifying a private copy. Propagation includes copying, +distribution (with or without modification and with or without charging +a redistribution fee), making available to the public, and in some +countries other activities as well. + +PERMISSION & CONDITIONS +This licence does not grant any rights under trademark law and all such +rights are reserved. + +Permission is hereby granted, free of charge, to any person obtaining a +copy of the Font Software, to propagate the Font Software, subject to +the below conditions: + +1) Each copy of the Font Software must contain the above copyright +notice and this licence. These can be included either as stand-alone +text files, human-readable headers or in the appropriate machine- +readable metadata fields within text or binary files as long as those +fields can be easily viewed by the user. + +2) The font name complies with the following: +(a) The Original Version must retain its name, unmodified. +(b) Modified Versions which are Substantially Changed must be renamed to +avoid use of the name of the Original Version or similar names entirely. +(c) Modified Versions which are not Substantially Changed must be +renamed to both (i) retain the name of the Original Version and (ii) add +additional naming elements to distinguish the Modified Version from the +Original Version. The name of such Modified Versions must be the name of +the Original Version, with "derivative X" where X represents the name of +the new work, appended to that name. + +3) The name(s) of the Copyright Holder(s) and any contributor to the +Font Software shall not be used to promote, endorse or advertise any +Modified Version, except (i) as required by this licence, (ii) to +acknowledge the contribution(s) of the Copyright Holder(s) or (iii) with +their explicit written permission. + +4) The Font Software, modified or unmodified, in part or in whole, must +be distributed entirely under this licence, and must not be distributed +under any other licence. The requirement for fonts to remain under this +licence does not affect any document created using the Font Software, +except any version of the Font Software extracted from a document +created using the Font Software may only be distributed under this +licence. + +TERMINATION +This licence becomes null and void if any of the above conditions are +not met. + +DISCLAIMER +THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF +COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE +COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, +INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL +DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM OTHER +DEALINGS IN THE FONT SOFTWARE. diff --git a/addons/ofxGui/examples/testLayout/bin/data/theme_default.json b/addons/ofxGui/examples/testLayout/bin/data/theme_default.json new file mode 100644 index 0000000..399af61 --- /dev/null +++ b/addons/ofxGui/examples/testLayout/bin/data/theme_default.json @@ -0,0 +1,40 @@ +{ + "default": { + "base": { + "background-color": "rgba(0,0,0,0.2)", + "fill-color": "rgba(200,200,200,0.42)", + "border-width": 1, + "padding": 2, + "border-color": "rgb(255,255,255)", + "margin": 4, + "text-color": "#ffffff" + }, + "toggle": { + + }, + "button": { + + }, + "slider": { + + }, + "label": { + "border-width": 0, + "background-color": "rgba(0,0,0,0)" + }, + "group": { + "border-color": "rgba(255,255,255,0.7)", + "padding": 0, + "border-width": 0 + }, + "group-header": { + "align-self": "flex-start", + "flex": "none", + "width": "100%", + "margin": 0, + "border-width": 0, + "padding": 0, + "text-color": "#ffffff" + } + } +} diff --git a/addons/ofxGui/examples/testLayout/bin/data/theme_light.json b/addons/ofxGui/examples/testLayout/bin/data/theme_light.json new file mode 100644 index 0000000..f15cd55 --- /dev/null +++ b/addons/ofxGui/examples/testLayout/bin/data/theme_light.json @@ -0,0 +1,25 @@ +{ + "default": { + "base": { + "background-color": "rgba(255,255,255,0.2)", + "fill-color": "rgba(255,255,255,0.7)", + "border-width": 0, + "padding": 0, + "margin": 0, + "text-color": "#000000", + "font-family": "fonts/UbuntuMono-B.ttf", + "font-size": 10, + "text-padding": 2 + }, + "group": { + "border-color": "rgb(255,255,255)", + "padding": 1, + "border-width": 1, + "margin-left": 10 + }, + "group-header": { + "background-color": "#2da1e3", + "text-color": "#ffffff" + } + } +} diff --git a/addons/ofxGui/examples/testLayout/src/main.cpp b/addons/ofxGui/examples/testLayout/src/main.cpp new file mode 100644 index 0000000..84ca57f --- /dev/null +++ b/addons/ofxGui/examples/testLayout/src/main.cpp @@ -0,0 +1,13 @@ +#include "ofMain.h" +#include "ofApp.h" + +//======================================================================== +int main( ){ + ofSetupOpenGL(1024,768, OF_WINDOW); // <-------- setup the GL context + + // this kicks off the running of my app + // can be OF_WINDOW or OF_FULLSCREEN + // pass in width and height too: + ofRunApp( new ofApp()); + +} diff --git a/addons/ofxGui/examples/testLayout/src/ofApp.cpp b/addons/ofxGui/examples/testLayout/src/ofApp.cpp new file mode 100644 index 0000000..80ec53c --- /dev/null +++ b/addons/ofxGui/examples/testLayout/src/ofApp.cpp @@ -0,0 +1,192 @@ +#include "ofApp.h" + +//-------------------------------------------------------------- +void ofApp::setup(){ + + ofSetFrameRate(120); + + ofAddListener(ofEvents().draw, this, &ofApp::drawMousePosition, OF_EVENT_ORDER_AFTER_APP+1); + + testBool.set("bool", true); + testFloat.set("float", 0.5, 0, 1); + testColor.set("color", ofColor(120), ofColor(0,0), ofColor(255,255)); + testPoint.set("point", ofPoint(0.5,0.5), ofPoint(0,0), ofPoint(100,100)); + testString.set("string", "teststring"); + + + gui_flex.setupFlexBoxLayout(); + + + ofxGuiGroup* control = gui_control.addPanel("active layout", ofJson({ + {"show-header", false}, + {"direction", "horizontal"}, + {"left", 300}, + {"width", "auto"} + })); + control->setExclusiveToggles(true); + control->add(gui_box.getVisible().set("box layout", false)); + control->add(gui_flex.getVisible().set("flexbox layout", true)); + control->add("(note: both cases should look identical)"); + + + vector guis; + guis.push_back(&gui_box); + guis.push_back(&gui_flex); + + for(ofxGui* gui : guis){ + + gui->add(testBool, testFloat); + + vector panels; + + ofxGuiGroup* panel1 = gui->addPanel(); + panel1->setPosition(10, 130); + panel1->loadTheme("theme_default.json"); + + ofxGuiGroup* panel2 = gui->addPanel(); + panel2->loadTheme("theme_light.json"); + panel2->setPosition(panel1->getPosition().x + panel1->getWidth()+10, panel1->getPosition().y); + + panels.push_back(panel1); + panels.push_back(panel2); + + for(ofxGuiGroup* panel : panels){ + panel->add(testBool); + panel->add(testPoint); + panel->add(testFloat); + panel->add(testColor); + panel->add(testString); + } + + ofxGuiGroup* panel3 = gui->addPanel("horizontal", ofJson({ + {"direction", "horizontal"}, + {"flex-direction", "row"} + })); + panel3->setPosition(panel2->getPosition().x + panel2->getWidth()+10, panel2->getPosition().y); + panel3->add(testBool); + panel3->add(testBool); + panel3->add(testBool); + + ofxGuiGroup* panel4 = gui->addPanel(); + panel4->setPosition(panel3->getPosition().x, panel3->getPosition().y + panel3->getHeight()+10); + panel4->add(testFloat); + ofxGuiGroup* panel4_vertical = panel4->addGroup("", ofJson({ + {"direction", "horizontal"}, + {"show-header", false}, + {"flex-direction", "row"}, + {"width", 270} + })); + panel4_vertical->add(testBool, ofJson({ + {"type", "radio"}, + {"show-name", false}, + {"width", "10%"} + })); + panel4_vertical->add(testFloat, ofJson({{"width", "45%"}})); + panel4_vertical->add(testFloat, ofJson({{"width", "45%"}})); + + //give the flexbox layout a different color to be able to see that something happens when you change the layout + if(gui == &gui_flex){ + ofJson config = { + { + "group-header", { + {"background-color", "#123456"} + } + } + }; + panel1->setTheme(config); + panel2->setTheme(config); + + } + + } + +} + +void ofApp::exit(){ + ofRemoveListener(ofEvents().draw, this, &ofApp::drawMousePosition, OF_EVENT_ORDER_AFTER_APP+1); +} + +//-------------------------------------------------------------- +void ofApp::update(){ +} + +//-------------------------------------------------------------- +void ofApp::draw(){ + ofBackgroundGradient(ofColor::white, ofColor::gray); +} + +void ofApp::drawMousePosition(ofEventArgs&){ + + ofPoint mPos(ofGetMouseX(), ofGetMouseY()); + + std::string info; + if(!dragging){ + info = "x: " + ofToString(mPos.x) + " y: " + ofToString(mPos.y); + }else{ + ofSetColor(255,0,0); + ofSetLineWidth(1); + ofDrawLine(mPos, dragStart); + info = ofToString((mPos-dragStart).length()); + } + + ofSetColor(255); + ofFill(); + ofDrawRectangle(font.getBoundingBox(info, mPos.x +12, mPos.y + 30)); + + ofSetColor(0); + ofDrawBitmapString(info, mPos.x +12, mPos.y + 30); +} + +//-------------------------------------------------------------- +void ofApp::keyPressed(int key){ +} + +//-------------------------------------------------------------- +void ofApp::keyReleased(int key){ + +} + +//-------------------------------------------------------------- +void ofApp::mouseMoved(int x, int y ){ + +} + +//-------------------------------------------------------------- +void ofApp::mouseDragged(int x, int y, int button){ + +} + +//-------------------------------------------------------------- +void ofApp::mousePressed(int x, int y, int button){ + dragStart = ofPoint(x,y); + dragging = true; +} + +//-------------------------------------------------------------- +void ofApp::mouseReleased(int x, int y, int button){ + dragging = false; +} + +//-------------------------------------------------------------- +void ofApp::mouseEntered(int x, int y){ + +} + +//-------------------------------------------------------------- +void ofApp::mouseExited(int x, int y){ + +} + +//-------------------------------------------------------------- +void ofApp::windowResized(int w, int h){ +} + +//-------------------------------------------------------------- +void ofApp::gotMessage(ofMessage msg){ + +} + +//-------------------------------------------------------------- +void ofApp::dragEvent(ofDragInfo dragInfo){ + +} diff --git a/addons/ofxGui/examples/testLayout/src/ofApp.h b/addons/ofxGui/examples/testLayout/src/ofApp.h new file mode 100644 index 0000000..ae5cd42 --- /dev/null +++ b/addons/ofxGui/examples/testLayout/src/ofApp.h @@ -0,0 +1,40 @@ +#pragma once + +#include "ofMain.h" +#include "ofxGuiExtended.h" + +class ofApp : public ofBaseApp{ + + public: + void setup(); + void update(); + void draw(); + void exit(); + + void drawMousePosition(ofEventArgs&); + + void keyPressed (int key); + void keyReleased(int key); + void mouseMoved(int x, int y ); + void mouseDragged(int x, int y, int button); + void mousePressed(int x, int y, int button); + void mouseReleased(int x, int y, int button); + void mouseEntered(int x, int y); + void mouseExited(int x, int y); + void windowResized(int w, int h); + void dragEvent(ofDragInfo dragInfo); + void gotMessage(ofMessage msg); + + ofxGui gui_control, gui_box, gui_flex; + + ofParameter testBool; + ofParameter testFloat; + ofParameter testString; + ofParameter testColor; + ofParameter testPoint; + + ofPoint dragStart; + bool dragging; + ofBitmapFont font; + +}; diff --git a/addons/ofxGui/src/Document.cpp b/addons/ofxGui/src/Document.cpp new file mode 100644 index 0000000..0c9fd8f --- /dev/null +++ b/addons/ofxGui/src/Document.cpp @@ -0,0 +1,162 @@ +// ============================================================================= +// +// Copyright (c) 2009-2016 Christopher Baker +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. +// +// ============================================================================= + + +#include "Document.h" +#include "ofGraphics.h" +#include "ofAppRunner.h" + + +namespace DOM { + + +Document::Document(): + Element("document", 0, 0, 1024, 768) +{ + ofAddListener(ofEvents().setup, this, &Document::setup); + ofAddListener(ofEvents().update, this, &Document::update); + ofAddListener(ofEvents().draw, this, &Document::draw, OF_EVENT_ORDER_AFTER_APP); + ofAddListener(ofEvents().exit, this, &Document::exit); + ofAddListener(ofEvents().windowResized, this, &Document::windowResized, std::numeric_limits::lowest()); + + ofAddListener(ofEvents().fileDragEvent, this, &Document::fileDragEvent, std::numeric_limits::lowest()); + + ofAddListener(ofEvents().keyPressed, this, &Document::onKeyEvent, std::numeric_limits::lowest()); + ofAddListener(ofEvents().keyReleased, this, &Document::onKeyEvent, std::numeric_limits::lowest()); +} + + +Document::~Document() +{ + ofRemoveListener(ofEvents().setup, this, &Document::setup); + ofRemoveListener(ofEvents().update, this, &Document::update); + ofRemoveListener(ofEvents().draw, this, &Document::draw, OF_EVENT_ORDER_AFTER_APP); + ofRemoveListener(ofEvents().exit, this, &Document::exit); + ofRemoveListener(ofEvents().windowResized, this, &Document::windowResized, std::numeric_limits::lowest()); + + ofRemoveListener(ofEvents().fileDragEvent, this, &Document::fileDragEvent, std::numeric_limits::lowest()); + + ofRemoveListener(ofEvents().keyPressed, this, &Document::onKeyEvent, std::numeric_limits::lowest()); + ofRemoveListener(ofEvents().keyReleased, this, &Document::onKeyEvent, std::numeric_limits::lowest()); +} + + +void Document::setup(ofEventArgs& e) +{ + if (_autoFillScreen) + { + setSize(ofGetWidth(), ofGetHeight()); + } + + Element::_setup(e); +} + + +void Document::update(ofEventArgs& e) +{ + Element::_update(e); +} + + +void Document::draw(ofEventArgs& e) +{ + Element::_draw(e); +} + + +void Document::exit(ofEventArgs& e) +{ + Element::_exit(e); +} + + +void Document::windowResized(ofResizeEventArgs& e) +{ + if (_autoFillScreen) + { + setSize(e.width, e.height); + } +} + + +bool Document::fileDragEvent(ofDragInfo& e) +{ + return false; +} + + +bool Document::onKeyEvent(ofKeyEventArgs& e) +{ + return false; +} + + +void Document::setAutoFillScreen(bool autoFillScreen) +{ + _autoFillScreen = autoFillScreen; + + if (_autoFillScreen) + { + setSize(ofGetWidth(), ofGetHeight()); + } +} + + +bool Document::getAutoFillScreen() const +{ + return _autoFillScreen; +} + + +void Document::setBlockLayout(bool blocking) +{ + if(blocking){ + _blockLayoutCount++; + _blockLayout = true; + }else{ + _blockLayoutCount--; + if(_blockLayoutCount == 0){ + _blockLayout = false; + } + } +} + + +bool Document::isBlockingLayout() +{ + return _blockLayout; +} + + +float Document::getMinWidth(){ + return ofGetWidth(); +} + + +float Document::getMinHeight(){ + return ofGetHeight(); +} + + +} // namespace DOM diff --git a/addons/ofxGui/src/Document.h b/addons/ofxGui/src/Document.h new file mode 100644 index 0000000..ee36412 --- /dev/null +++ b/addons/ofxGui/src/Document.h @@ -0,0 +1,105 @@ +// ============================================================================= +// +// Copyright (c) 2009-2016 Christopher Baker +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. +// +// ============================================================================= + + +#pragma once + + +#include "Element.h" + + +namespace DOM { + + +/// \brief The Document represents the root DOM Element in an DOM tree. +class Document: public Element +{ +public: + /// \brief Create a default Document. + /// + /// The Document will have the default id of "document" and will fill + /// the entire screen. + Document(); + + /// \brief Destroy the Document. + virtual ~Document(); + + /// \brief Callback for the setup event. + /// \param e the event data. + void setup(ofEventArgs& e); + + /// \brief Callback for the update event. + /// \param e the event data. + void update(ofEventArgs& e); + + /// \brief Callback for the draw event. + /// \param e the event data. + void draw(ofEventArgs& e); + + /// \brief Callback for the exit event. + /// \param e the event data. + void exit(ofEventArgs& e); + + /// \brief Callback for the window resized event. + /// \param e the event data. + void windowResized(ofResizeEventArgs& e); + + /// \brief Callback for file drag events. + /// \param e the event data. + /// \returns true iff the event was handled. + bool fileDragEvent(ofDragInfo& e); + + /// \brief Callback for key events events. + /// \param e the event data. + /// \returns true iff the event was handled. + bool onKeyEvent(ofKeyEventArgs& e); + + /// \brief Determine if the Document size should always match the screen size. + /// \param true if if the Document size should always match the screen size. + void setAutoFillScreen(bool autoFillScreen); + + /// \returns true if the Document size will always match the screen size. + bool getAutoFillScreen() const; + + /// \brief Can be used to prevent the layout from being computed. + /// \param blocking True if layout computing should be prevented. + void setBlockLayout(bool blocking); + + /// \returns True if the layout computing is blocked. + bool isBlockingLayout(); + + virtual float getMinWidth() override; + virtual float getMinHeight() override; + +protected: + + /// \brief True if the Document size should always match the screen size. + bool _autoFillScreen = true; + bool _blockLayout = false; + int _blockLayoutCount = 0; + +}; + + +} // namespace DOM diff --git a/addons/ofxGui/src/Element.cpp b/addons/ofxGui/src/Element.cpp new file mode 100644 index 0000000..e18d997 --- /dev/null +++ b/addons/ofxGui/src/Element.cpp @@ -0,0 +1,1086 @@ +// ============================================================================= +// +// Copyright (c) 2009-2016 Christopher Baker +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. +// +// ============================================================================= + + +#include "Element.h" +#include "Document.h" +#include "ofGraphics.h" +#include "Layout.h" +#include + +#include "ofxGuiElement.h" + +namespace DOM { + + +Element::Element(float x, float y, float width, float height): + Element("", x, y, width, height) +{ +} + + +Element::Element(const std::string& id, + float x, + float y, + float width, + float height): + _id(id), + _shape(x, y, width, height), + _layoutSize(width, height), + _sizeSetByParent(0,0), + needsRedraw(true) +{ + _visible.set("visible", true); + _visible.addListener(this, &Element::setVisible); + ofAddListener(this->move, this, &Element::_onMoved); + ofAddListener(this->resize, this, &Element::_onResized); +} + + +Element::~Element() +{ + _visible.removeListener(this, &Element::setVisible); + ofRemoveListener(this->move, this, &Element::_onMoved); + ofRemoveListener(this->resize, this, &Element::_onResized); +} + + +std::unique_ptr Element::removeChild(Element* element) +{ + auto iter = findChild(element); + + if (iter != _children.end()) + { + // Move the child out of the children array. + std::unique_ptr detachedChild = std::move(*iter); + + // Disown the detached child + _children.erase(iter); + + // Set the parent to nullptr. + detachedChild->_parent = nullptr; + + // Invalidate all cached child shape. + invalidateChildShape(); + + // Alert the node that its parent was set. + ElementEventArgs removedFromEvent(this); + ofNotifyEvent(detachedChild->removedFrom, removedFromEvent, this); + + ElementEventArgs childRemovedEvent(detachedChild.get()); + ofNotifyEvent(childRemoved, childRemovedEvent, this); + + /// Alert the node's siblings that it no longer has a sibling. + for (auto& child : _children) + { + if (detachedChild.get() != child.get()) + { + ElementEventArgs e(detachedChild.get()); + ofNotifyEvent(child->siblingRemoved, e, this); + } + } + + // Detatch child listeners. + ofRemoveListener(detachedChild.get()->move, this, &Element::_onChildMoved); + ofRemoveListener(detachedChild.get()->resize, this, &Element::_onChildResized); + + // Return the detached child. + // If the return value is ignored, it will be deleted. + + return detachedChild; + } + else + { + // Return nullptr because we couldn't find anything. + return nullptr; + } +} + +void Element::clear() +{ + while(children().size() > 0) { + if(!removeChild(children().at(0))){ + ofLogError("Element::clear") << "Could not remove child"; + return; + } + } +} + +void Element::moveToFront() +{ + if (_parent) + { + _parent->moveChildToFront(this); + } +} + + +void Element::moveForward() +{ + if (_parent) + { + _parent->moveChildForward(this); + } +} + + +void Element::moveToBack() +{ + if (_parent) + { + _parent->moveChildToBack(this); + } +} + + +void Element::moveBackward() +{ + if (_parent) + { + _parent->moveChildBackward(this); + } +} + + +void Element::moveChildToIndex(Element* element, std::size_t index) +{ + auto iter = findChild(element); + + if (iter != _children.end()) + { + std::size_t oldIndex = iter - _children.begin(); + std::size_t newIndex = std::min(index, _children.size() - 1); + + auto detachedChild = std::move(*iter); + + _children.erase(iter); + + _children.insert(_children.begin() + newIndex, std::move(detachedChild)); + + ElementOrderEventArgs e(element, oldIndex, newIndex); + ofNotifyEvent(reordered, e, element); + ofNotifyEvent(childReordered, e, this); + } + else + { + throw DOMException(DOMException::INVALID_STATE_ERROR + ": " + "Element::moveChildToIndex: Element does not exist."); + } +} + + +void Element::moveChildToFront(Element* element) +{ + auto iter = findChild(element); + + if (iter != _children.end()) + { + std::size_t oldIndex = iter - _children.begin(); + std::size_t newIndex = 0; + + auto detachedChild = std::move(*iter); + _children.erase(iter); + _children.insert(_children.begin(), std::move(detachedChild)); + + ElementOrderEventArgs e(element, oldIndex, newIndex); + ofNotifyEvent(reordered, e, element); + ofNotifyEvent(childReordered, e, this); + } + else + { + throw DOMException(DOMException::INVALID_STATE_ERROR + ": " + "Element::moveChildToFront: Element does not exist."); + } +} + + +void Element::moveChildForward(Element* element) +{ + auto iter = findChild(element); + + if (iter != _children.end()) + { + // Make sure it's not already in the front. + if (iter != _children.begin()) + { + std::size_t oldIndex = iter - _children.begin(); + std::size_t newIndex = oldIndex - 1; + + std::iter_swap(iter, iter - 1); + + ElementOrderEventArgs e(element, oldIndex, newIndex); + ofNotifyEvent(reordered, e, element); + ofNotifyEvent(childReordered, e, this); + } + } + else + { + throw DOMException(DOMException::INVALID_STATE_ERROR + ": " + "Element::moveChildForward: Element does not exist."); + } +} + + +void Element::moveChildToBack(Element* element) +{ + auto iter = findChild(element); + + if (iter != _children.end()) + { + // Make sure it's not already in the back. + if (iter != _children.end() - 1) + { + std::size_t oldIndex = iter - _children.begin(); + std::size_t newIndex = _children.size() - 1; + + auto detachedChild = std::move(*iter); + _children.erase(iter); + _children.push_back(std::move(detachedChild)); + + ElementOrderEventArgs e(element, oldIndex, newIndex); + ofNotifyEvent(reordered, e, element); + ofNotifyEvent(childReordered, e, this); + } + } + else + { + throw DOMException(DOMException::INVALID_STATE_ERROR + ": " + "Element::moveChildToBack: Element does not exist."); + } +} + + +void Element::moveChildBackward(Element* element) +{ + auto iter = findChild(element); + + if (iter != _children.end()) + { + if (iter != _children.end() - 1) + { + std::size_t oldIndex = iter - _children.begin(); + std::size_t newIndex = _children.size() + 1; + + std::iter_swap(iter, iter + 1); + + ElementOrderEventArgs e(element, oldIndex, newIndex); + ofNotifyEvent(reordered, e, element); + ofNotifyEvent(childReordered, e, this); + } + } +} + + +bool Element::isChild(Element* element) const +{ + return element + && element->_parent == this; +} + + +bool Element::isSibling(Element* element) const +{ + return element + && element->_parent + && element->_parent == _parent; +} + + +std::size_t Element::numSiblings() const +{ + // Don't count self. + return _parent ? (_parent->numChildren() - 1) : 0; +} + + +std::vector Element::siblings() +{ + std::vector results; + + if (_parent) + { + results.reserve(_parent->_children.size()); + + for (auto& child : _parent->_children) + { + Element* sibling = child.get(); + + if (sibling) + { + if (this != sibling) + { + results.push_back(sibling); + } + } + else + { + throw DOMException(DOMException::INVALID_STATE_ERROR + ": " + "Element::siblings(): Child element is nullptr."); + } + } + } + + return results; +} + + +bool Element::isParent(Element* element) const +{ + return element + && element == this->_parent; +} + + +std::size_t Element::numChildren() const +{ + return _children.size(); +} + + +std::vector Element::children() +{ + std::vector results; + + results.reserve(_children.size()); + + for (auto& child : _children) + { + Element* pChild = child.get(); + + if (pChild) + { + results.push_back(pChild); + } + else + { + throw DOMException(DOMException::INVALID_STATE_ERROR + ": " + "Element::children(): Child element is nullptr."); + } + } + + return results; +} + + +bool Element::hasParent() const +{ + return _parent; +} + + +Element* Element::findFirstChildById(const std::string& id) +{ + auto iter = std::find_if(_children.begin(), + _children.end(), + [&](const std::unique_ptr& child) { + return child->getId() == id; + }); + + return (iter != _children.end()) ? iter->get() : nullptr; +} + + +std::vector Element::findChildrenById(const std::string& id) +{ + std::vector matches; + + matches.reserve(_children.size()); + + for (auto& child : _children) + { + Element* pChild = child.get(); + + if (pChild) + { + if (child->getId() == id) + { + matches.push_back(child.get()); + } + } + else + { + throw DOMException(DOMException::INVALID_STATE_ERROR + ": " + "Element::findChildrenById(): Child element is nullptr."); + } + } + + return matches; +} + + +std::vector>::iterator Element::findChild(Element* element) +{ + return std::find_if(_children.begin(), + _children.end(), + [&](const std::unique_ptr& child) { + return element == child.get(); + }); +} + + +Element* Element::parent() +{ + return _parent; +} + + +const Element* Element::parent() const +{ + return _parent; +} + + +Document* Element::document() +{ + if (_parent) + { + // If a parent exists, return it recursively. + return _parent->document(); + } + else + { + // Return self if a Document, otherwise, will return nullptr. + return dynamic_cast(this); + } +} + + +const Document* Element::document() const +{ + if (_parent) + { + // If a parent exists, return it recursively. + return _parent->document(); + } + else + { + // Return self if a Document, otherwise, will return nullptr. + return dynamic_cast(this); + } +} + +std::unique_ptr Element::removeLayout(){ + // TODO + return nullptr; +} + +Layout* Element::layout(){ + return _layout.get(); +} + +void Element::updateLayout(){ + invalidateChildShape(); +} + +bool Element::hitTest(const Position& parentPosition) const +{ + return getShape().inside(parentPosition); +} + + +bool Element::childHitTest(const Position& localPosition) const +{ + return getChildShape().inside(localPosition); +} + + +Position Element::localToScreen(const Position& localPosition) const +{ + return localPosition + getScreenPosition(); +} + + +Shape Element::localToScreen(const Shape& localShape) const +{ + return Shape(localShape.getPosition() + getScreenPosition(), + localShape.getWidth(), localShape.getHeight()); +} + + +Position Element::screenToLocal(const Position& screenPosition) const +{ + return screenPosition - getScreenPosition(); +} + + +Position Element::parentToScreen(const Position& parentPosition) const +{ + if (_parent) + { + return parentPosition + _parent->getScreenPosition(); + } + else + { + return parentPosition; + } +} + + +Position Element::screenToParent(const Position& screenPosition) const +{ + if (_parent) + { + return screenPosition - _parent->getScreenPosition(); + } + else + { + return screenPosition; + } +} + + +void Element::setPosition(float x, float y) +{ + if(ofPoint(_shape.getPosition()) != ofPoint(x,y)) + { + _shape.setPosition(x, y); + MoveEventArgs e(getPosition(), this); + ofNotifyEvent(move, e, this); + } +} + + +void Element::setPosition(const Position& position) +{ + setPosition(position.x, position.y); +} + + +Position Element::getPosition() const +{ + return _shape.getPosition(); +} + + +float Element::getX() const +{ + return _shape.getX(); +} + + +float Element::getY() const +{ + return _shape.getY(); +} + + +Position Element::getScreenPosition() const +{ + if (_parent) + { + return getPosition() + _parent->getScreenPosition(); + } + else + { + return getPosition(); + } +} + + +float Element::getScreenX() const +{ + return getScreenPosition().x; +} + + +float Element::getScreenY() const +{ + return getScreenPosition().y; +} + + +void Element::setSize(float width, float height) +{ + if(_shape.getWidth()!= width || _shape.getHeight() != height || _layoutSize.x != width || _layoutSize.y != height) + { + setAttribute("_width", ofToString(width)); + setAttribute("_height", ofToString(height)); + invalidateChildShape(); + } +} + + +void Element::setLayoutSize(float width, float height, bool tellParent) +{ + + if(_layoutSize.x!= width || _layoutSize.y != height) + { + _layoutSize.x = width; + _layoutSize.y = height; + if(tellParent){ + invalidateChildShape(); + } + ResizeEventArgs e(Shape(_shape.x, _shape.y, _layoutSize.x, _layoutSize.y)); + ofNotifyEvent(resize, e, this); + } + +} + + +void Element::setSizeByParent(float width, float height) +{ + _sizeSetByParent.x = width; + _sizeSetByParent.y = height; +} + + +Size Element::getSize() const +{ + return Size(_layoutSize.x, _layoutSize.y); +} + + +Size Element::getSizeByParent() const +{ + return Size(_sizeSetByParent.x, _sizeSetByParent.y); +} + + +///\todo use ofCompareFloat +void Element::setWidth(float width) +{ + if(_shape.getWidth()!= width || _layoutSize.x != width) + { + setAttribute("_width", ofToString(width)); + invalidateChildShape(); + } +} + + +void Element::setLayoutWidth(float width, bool tellParent) +{ + + if(width != _layoutSize.x){ + _layoutSize.x = width; + if(tellParent){ + invalidateChildShape(); + } + ResizeEventArgs e(Shape(_shape.x, _shape.y, _layoutSize.x, _layoutSize.y)); + ofNotifyEvent(resize, e, this); + } + +} + + +float Element::getWidth() const +{ + return _layoutSize.x; +} + + +float Element::getMinWidth() +{ + return 0; +} + + +///\todo use ofCompareFloat +void Element::setHeight(float height) +{ + if(_shape.getHeight() != height || _layoutSize.y != height) + { + setAttribute("_height", ofToString(height)); + invalidateChildShape(); + } +} + + + +void Element::setLayoutHeight(float height, bool tellParent) +{ + + if(height != _layoutSize.y){ + _layoutSize.y = height; + if(tellParent){ + invalidateChildShape(); + } + ResizeEventArgs e(Shape(_shape.x, _shape.y, _layoutSize.x, _layoutSize.y)); + ofNotifyEvent(resize, e, this); + } + +} + + +float Element::getMinHeight() +{ + return 0; +} + + +float Element::getHeight() const +{ + return _layoutSize.y; +} + +Shape Element::getShape() const +{ + return Shape(_shape.x, _shape.y, _layoutSize.x, _layoutSize.y); +} + + +void Element::setShape(const Shape& shape) +{ + setPosition(shape.x, shape.y); + setSize(shape.width, shape.height); +} + + +void Element::setShape(float x, float y, float width, float height) +{ + setShape(ofRectangle(x, y, width, height)); +} + + +Shape Element::getChildShape() const +{ + if (_childShapeInvalid) + { + _childShape = Shape(); // Clear. + + auto iter = _children.begin(); + + while (iter != _children.end()) + { + const Element* child = iter->get(); + + if (child) + { + if (iter == _children.begin()) + { + _childShape = child->getTotalShape(); + } + else + { + _childShape.growToInclude(child->getTotalShape()); + } + } + else + { + throw DOMException(DOMException::INVALID_STATE_ERROR + ": " + "Element::getChildGeometry(): Child element is nullptr."); + } + + ++iter; + } + + _childShapeInvalid = false; + } + + return _childShape; +} + + +Shape Element::getTotalShape() const +{ + Shape totalGeometry(getShape()); + + if (!_children.empty()) + { + totalGeometry.growToInclude(getChildShape() + getPosition()); + } + + return totalGeometry; +} + + +std::string Element::getId() const +{ + return _id; +} + + +void Element::setId(const std::string& id) +{ + _id = id; +} + + +bool Element::hasAttribute(const std::string& key) const +{ + return _attributes.find(key) != _attributes.end(); +} + + +void Element::setAttribute(const std::string& key, const Any& value) +{ + _attributes[key] = value; + + AttributeEventArgs e(key, value); + ofNotifyEvent(attributeSet, e, this); +} + + +void Element::clearAttribute(const std::string& key) +{ + _attributes.erase(key); + AttributeEventArgs e(key); + ofNotifyEvent(attributeCleared, e, this); +} + + + +void Element::_setup(ofEventArgs& e) +{ + for (auto& child : _children) + { + child->_setup(e); + } + + onSetup(); +} + + +void Element::_update(ofEventArgs& e) +{ + if (_enabled && !_hidden) + { + for (auto& child : _children) + { + child->_update(e); + } + + onUpdate(); + } +} + + +void Element::_draw(ofEventArgs& e) +{ + if (_enabled && !_hidden) + { + ofPushStyle(); + ofPushMatrix(); + ofTranslate(_shape.getPosition()); + + // Draw parent behind children. + if(needsRedraw){ + generateDraw(); + needsRedraw = false; + } + render(); + + // Now draw in reverse order. + auto iter = _children.rbegin(); + + while (iter != _children.rend()) + { + (*iter)->_draw(e); + ++iter; + } + + ofPopMatrix(); + ofPopStyle(); + } +} + +void Element::setNeedsRedraw() +{ + needsRedraw = true; +} + +void Element::_exit(ofEventArgs& e) +{ + for (auto& child : _children) + { + child->_exit(e); + } + + onExit(); +} + + +Element* Element::recursiveHitTest(const Position& parentPosition) +{ + if (_enabled && !_hidden) + { + Position childLocal = parentPosition - this->getPosition(); + + if (!_children.empty() && childHitTest(childLocal)) + { + for (auto& child : _children) + { + Element* target = child->recursiveHitTest(childLocal); + + if (target) + { + return target; + } + } + } + + // If there is no child target, is this a viable target? + if (hitTest(parentPosition)) + { + return this; + } + else + { + return nullptr; + } + } + else + { + return nullptr; + } +} + + +bool Element::isEnabled() const +{ + return _enabled; +} + + +void Element::setEnabled(bool enabled_) +{ + _enabled = enabled_; + EnablerEventArgs e(_enabled); + ofNotifyEvent(enabled, e, this); +} + + +bool Element::isHidden() const +{ + if(parent()){ + return parent()->isHidden() || _hidden; + } + return _hidden; +} + + +void Element::setHidden(bool hidden_) +{ + _visible.set(!hidden_); +} + + +void Element::setVisible(bool &visible) +{ + if(visible == _hidden){ + _hidden = !visible; +// if(!visible){ +// setLayoutSize(0,0); +// } + invalidateChildShape(); + EnablerEventArgs e(_hidden); + ofNotifyEvent(hidden, e, this); + } +} + + +ofParameter& Element::getVisible(){ + return _visible; +} + + +bool Element::isLocked() const +{ + return _locked; +} + + +void Element::setLocked(bool locked_) +{ + _locked = locked_; + EnablerEventArgs e(_locked); + ofNotifyEvent(locked, e, this); +} + + +void Element::blockLayout(bool block){ + if(DOM::Document* doc = document()){ + doc->setBlockLayout(block); + if(!doc->isBlockingLayout()){ + //redo layout for all elements + doc->invalidateChildShape(); + } + } +} + + +void Element::invalidateChildShape() +{ + if(DOM::Document* doc = document()){ + if(!doc->isBlockingLayout()){ + if(_parent){ + Size oldParent = _parent->getSize(); + if(_parent->layout()){ + if(_parent->layout()->isDoingLayout()){ + if (_layout){ + _layout->doLayout(); + } + }else{ + _parent->layout()->doLayout(); + Size newParent = _parent->getSize(); + if(oldParent != newParent){ + _parent->invalidateChildShape(); + } + } + } + }else{ + if (_layout){ + _layout->doLayout(); + } + } + setNeedsRedraw(); + } + } + +} + + +//void Element::redoLayout() +//{ + +// for(auto *child : children()) +// { +// child->redoLayout(); +// } + +// if(children().size() == 0){ +// invalidateChildShape(); +// } +//} + + +void Element::_onMoved(MoveEventArgs&) +{ +// invalidateChildShape(); +} + + +void Element::_onResized(ResizeEventArgs&) +{ +// if(parent()){ +// invalidateChildShape(); +// } +} + + +void Element::_onChildMoved(MoveEventArgs &args) +{ +// invalidateChildShape(); + ofNotifyEvent(childMoved, args, this); +} + + +void Element::_onChildResized(ResizeEventArgs&) +{ +// invalidateChildShape(false); +} + + +} // namespace DOM diff --git a/addons/ofxGui/src/Element.h b/addons/ofxGui/src/Element.h new file mode 100644 index 0000000..34cb49c --- /dev/null +++ b/addons/ofxGui/src/Element.h @@ -0,0 +1,825 @@ +// ============================================================================= +// +// Copyright (c) 2009-2016 Christopher Baker +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. +// +// ============================================================================= + + +#pragma once + + +#include +#include "Events.h" +#include "EventTarget.h" +#include "Exceptions.h" +#include "Types.h" +#include "ofParameter.h" + + +namespace DOM { + + +class Document; +class AbstractLayout; +class Layout; + + +/// \brief A class representing a DOM Element. +/// +/// There are several DOM coordiante systems with respect to an Element. +/// +/// 1. Local Coordinates: The origin of the local coordiantes are at 0, 0 of the +/// Element Geometry. The coordiantes of the local Geometry range from (0, 0) +/// - the upper left corner to (width, height) - the lower right corner of the +/// Element. +/// +/// 2. Parent Coordinates: The (x, y) position of the Element geometry are in +/// "Parent" Coordinates, meaning they are oriented with respect to the +/// parent's Local Coordinates. +/// +/// 3. Screen Coordinates: The screen coordinates are the coordinates (x, y) +/// in terms of the global screen coordiantes where (0, 0) is the upper left +/// corner of the screen / window, and (ofGetWidth(), ofGetHeight()) are the +/// coordiantes of the lower right corner. +class Element: public EventTarget +{ +public: + /// \brief Construct a new Element with the given parameters. + /// + /// The Element will take the default id, an empty string. + /// + /// \param x the X position of the Element in its parent coordinates. + /// \param y the Y position of the Element in its parent coordinates. + /// \param width the width of the Element. + /// \param height the height of the Element. + Element(float x, float y, float width, float height); + + /// \brief Construct a new Element with the given parameters. + /// \param id The id of the Element. + /// \param x the X position of the Element in its parent coordinates. + /// \param y the Y position of the Element in its parent coordinates. + /// \param width the width of the Element. + /// \param height the height of the Element. + Element(const std::string& id, float x, float y, float width, float height); + + /// \brief Destroy the Element. + virtual ~Element(); + + /// \brief Take ownership of the passed std::unique_ptr. + /// + /// This this is "sink" meaning that any child passed to this will be + /// owned by this Node. + /// + /// \param element the rvalue reference to the child node. + /// \returns A pointer to the added Element. The parent Element retains + /// ownership of the pointer via a std::unique_ptr. + /// \tparam ElementType The Element Type. + template + ElementType* add(std::unique_ptr element); + + /// \brief Create a child using a templated Element type. + /// + /// To create a child Element you can use this method like: + /// + /// ElementType* element = parentElement->add(arguments ...); + /// + /// \tparam ElementType The subclass of Element that will be added. + /// \tparam Args The variable constructor arguments for the ElementType. + /// \param args The variable constructor arguments for the ElementType. + /// \returns A pointer to the added Element. The parent Element retains + /// ownership of the pointer via a std::unique_ptr. + /// \tparam ElementType The Element Type. + /// \tparam Args the ElementType constructor arguments. + template + ElementType* add(Args&&... args); + + /// \brief Release ownership of a child Element. + /// \param element The Element to release. + /// \returns a std::unique_ptr to the child. + std::unique_ptr removeChild(Element* element); + + /// \brief Removes all child elements. + virtual void clear(); + + /// \brief Move this Element in front of all of its siblings. + void moveToFront(); + + /// \brief Move this Element in front of its next sibling. + void moveForward(); + + /// \brief Move this Element in back of all of its siblings. + void moveToBack(); + + /// \brief Move this Element in back of its next sibling. + void moveBackward(); + + /// \brief Move the given Element to the the given index. + /// + /// If the index value is greater than the number of children, the element + /// will be moved into the last position. + /// + /// \param element The child element to move. + /// \param index The child index to move to. + /// \throws DOMException(DOMException::INVALID_STATE_ERROR) if no matching + /// child element exists. + void moveChildToIndex(Element* element, std::size_t index); + + /// \brief Move the given Element in front of all of its siblings. + /// \throws DOMException(DOMException::INVALID_STATE_ERROR) if no matching + /// child element exists. + void moveChildToFront(Element* element); + + /// \brief Move the given Element in front of its next sibling. + /// \param element The child element to move. + /// \throws DOMException(DOMException::INVALID_STATE_ERROR) if no matching + /// child element exists. + void moveChildForward(Element* element); + + /// \brief Move the given Element in back of all of its siblings. + /// \param element The child element to move. + /// \throws DOMException(DOMException::INVALID_STATE_ERROR) if no matching + /// child element exists. + void moveChildToBack(Element* element); + + /// \brief Move the given Element in back of its next sibling. + /// \param element The child element to move. + /// \throws DOMException(DOMException::INVALID_STATE_ERROR) if no matching + /// child element exists. + void moveChildBackward(Element* element); + + /// \brief Determine if the given Element is a child of this Element. + /// \param element A pointer the the Element to test. + /// \returns true iff the given element is a child of this Element. + bool isChild(Element* element) const; + + /// \brief Determine if the given Element is a sibling of this Element. + /// \param element A pointer the the Element to test. + /// \returns true iff the given element is a sibling of this Element. + bool isSibling(Element* element) const; + + /// \returns the number of siblings. + std::size_t numSiblings() const; + + /// \returns a list of pointers to sibling elements. + std::vector siblings(); + + /// \brief Get a list of siblings of a given Element or Element subclass. + /// + /// If the there are no siblings of the given type, + /// + /// \returns a list of pointers to sibling elements of a given type. + template + std::vector siblings(); + + /// \brief Determine if the given Element is the parent of this Element. + /// \param element A pointer the the Element to test. + /// \returns true iff the given element is the parent of this Element. + bool isParent(Element* element) const; + + /// \returns the number of children. + std::size_t numChildren() const; + + /// \brief Get a list of pointers to the child elements. + /// + /// The parent Element retains ownership. + /// + /// \returns a list of pointers to child elements. + virtual std::vector children(); + + /// \brief Get a list of pointers to the child elements. + /// + /// The parent Element retains ownership. + /// + /// \returns a list of pointers to child elements. + template + std::vector children(); + + /// \brief Determine if this Element has a parent Element. + /// \returns true if this Element has a parent Element. + bool hasParent() const; + + /// \brief Find this Element's first child by its id. + /// \param id The id of the child Element to find. + /// \returns a pointer to the first child or nullptr if no such child exists. + Element* findFirstChildById(const std::string& id); + + /// \brief Find all of this Element's matching the given id. + /// \param id The id of the child Elements to find. + /// \returns a vector of pointers to child elements or an empty vector if none exist. + std::vector findChildrenById(const std::string& id); + + /// \brief Get a pointer to the parent. + /// \returns a pointer to the parent or a nullptr. + Element* parent(); + + /// \brief Get a pointer to the parent. + /// \returns a pointer to the parent or a nullptr. + const Element* parent() const; + + /// \brief Get a pointer to the parent Document. + /// \returns a pointer to the parent Document, self if a Document or a nullptr. + Document* document(); + + /// \brief Get a pointer to the parent Document. + /// \returns a pointer to the parent Document, self if a Document or a nullptr. + const Document* document() const; + + /// \brief Create a Layout using a templated Layout type. + /// + /// To create a Layout you can use this method like: + /// + /// LayoutType* layout = parentElement->createLayout(arguments ...); + /// + /// \tparam ElementType The subclass of Element that will be added. + /// \tparam Args The variable constructor arguments for the ElementType. + /// \param args The variable constructor arguments for the ElementType. + /// \returns A pointer to the added Element. The parent Element retains + /// ownership of the pointer via a std::unique_ptr. + /// \tparam ElementType The Element Type. + /// \tparam Args the ElementType constructor arguments. + template + LayoutType* createLayout(Args&&... args); + + /// \brief Take ownership of the passed std::unique_ptr. + /// + /// This this is "sink" meaning that any Layout passed to this will be + /// owned by this Element. + /// + /// \param layout the rvalue reference to the Layout. + /// \returns A pointer to the set Layout. The parent Element retains + /// ownership of the pointer via a std::unique_ptr. + /// \tparam LayoutType The Layout Type. + template + LayoutType* setLayout(std::unique_ptr layout); + + /// \brief Release ownership of the Layout. + /// \returns a std::unique_ptr to the Layout or nullptr if none. + std::unique_ptr removeLayout(); + + /// \brief Get a pointer to the associated Layout. + /// + /// The Element retains ownership of the pointer via a std::unique_ptr. + /// + /// \returns a pointer to the associated Layout or nullptr if there is none. + Layout* layout(); + + /// \brief Updates the current layout. + /// + virtual void updateLayout(); + + /// \brief Perform a hit test on the Element. + /// + /// For a normal Element, the hit test will test the rectangular geometry + /// of the Element. Subclasses can override this method for custom hit test + /// geometry. + /// + /// Parent coordinates are used because the geometry / position of the + /// Element are in parent coordinates. + /// + /// \param parentPosition The Position to test in parent coordinates. + /// \returns true iff the local position is within the hit test region. + virtual bool hitTest(const Position& parentPosition) const; + + /// \brief Perform a hit test on a child Element. + /// \param localPosition The Position to test in local coordinates. + /// \returns true iff the local position is within the hit test region. + virtual bool childHitTest(const Position& localPosition) const; + + /// \brief Convert the local coordinates to screen coordinates. + /// + /// Local coordinates are defined with reference to the position of the box. + /// The Position of this element will be in its parent's local coordinates. + /// + /// \param localPosition The local coordinates to convert. + /// \returns the position converted from local to screen coordinates. + Position localToScreen(const Position& localPosition) const; + + /// \brief Convert the local coordinates to screen coordinates. + /// + /// Local coordinates are defined with reference to the position of the box. + /// The Position of this element will be in its parent's local coordinates. + /// + /// \param localShape The local shape to convert. + /// \returns the shape converted from local to screen coordinates. + Shape localToScreen(const Shape& localShape) const; + + /// \brief Convert the screen coordinates to local coordinates. + /// + /// Local coordinates are defined with reference to the position of the box. + /// The Position of this element will be in its parent's local coordinates. + /// + /// \param screenPosition The screen coordinates to convert. + /// \returns the position converted from screen to local coordinates. + Position screenToLocal(const Position& screenPosition) const; + + /// \brief Convert the parent coordinates to screen coordinates. + /// \param parentPosition The parent coordinates to convert. + /// \returns the position converted from parent to screen coordinates. + Position parentToScreen(const Position& parentPosition) const; + + /// \brief Convert the screen coordinates to parent coordinates. + /// \param screenPosition The screen coordinates to convert. + /// \returns the position converted from screen to parent coordinates. + Position screenToParent(const Position& screenPosition) const; + + /// \brief Set the position of the Element in its parent coordinates. + /// \param x The new x position. + /// \param y The new y position. + void setPosition(float x, float y); + + /// \brief Set the position of the Element in its parent coordinates. + /// \param position The new position. + void setPosition(const Position& position); + + /// \brief Get the position of the Element in its parent coordinates. + /// + /// Local coordinates are defined with reference to the position of the box. + /// The Position of this element will be in its parent's local coordinates. + /// + /// \returns The position in parent coordinates. + Position getPosition() const; + + /// \brief Get the X position of the Element in its parent coordinates. + /// \returns the X position of the Element in its parent coordinates. + float getX() const; + + /// \brief Get the Y position of the Element in its parent coordinates. + /// \returns the Y position of the Element in its parent coordinates. + float getY() const; + + /// \brief Get the Position of the Element in screen coordinates. + /// \returns the Position of the Element in screen coordinates. + /// \todo Cache screen position w/ geometry. + Position getScreenPosition() const; + + /// \brief Get the X position of the Element in screen coordinates. + /// \returns the X position of the Element in screen coordinates. + float getScreenX() const; + + /// \brief Get the Y position of the Element in screen coordinates. + /// \returns the Y position of the Element in screen coordinates. + float getScreenY() const; + + /// \brief Set the size of the Element. + /// \param width The new width of the Element. + /// \param height The new height of the Element. + virtual void setSize(float width, float height); + + /// \brief Set the size of the Element in the current layout. + /// \param width The new width of the Element. + /// \param height The new height of the Element. + virtual void setLayoutSize(float width, float height, bool tellParent = true); + + /// \brief Set the size of the Element that the parent suggests by the current layout. + /// \param width The new width of the Element. + /// \param height The new height of the Element. + virtual void setSizeByParent(float width, float height); + + /// \brief Get the Size of the Element. + /// \returns the Size of the Element. + Size getSize() const; + + /// \brief Get the Size of the Element that the parent suggests by the current layout. + /// \returns the Size of the Element. + Size getSizeByParent() const; + + /// \brief Set the width of the Element. + /// param width The new width of the Element. + virtual void setWidth(float width); + + /// \brief Set the width of the Element in the current layout. + /// param width The new width of the Element. + virtual void setLayoutWidth(float width, bool tellParent = true); + + /// \brief Get the width of the Element produced by the layout. + /// \returns The width of the Element. + float getWidth() const; + + /// \brief Get the actual minimal width of the Element. + /// \returns The width of the Element. + virtual float getMinWidth(); + + /// \brief Set the height of the Element. + /// param height The new height of the Element. + virtual void setHeight(float height); + + /// \brief Set the height of the Element in the current layout. + /// param height The new height of the Element. + virtual void setLayoutHeight(float height, bool tellParent = true); + + /// \brief Get the height of the Element produced by the layout. + /// \returns The height of the Element. + float getHeight() const; + + /// \brief Get the actual minimal height of the Element. + /// \returns The height of the Element. + virtual float getMinHeight(); + + /// \brief Get the shape of the Element in its parent coordinates. + /// \returns the Shape of the Element in its parent coordinates. + Shape getShape() const; + + /// \brief Set the shape of the Element in its parent coordinates. + /// \param shape The new shape of the Element in its parent coordinates. + virtual void setShape(const Shape& shape); + + /// \brief Set the shape of the Element in its parent coordinates. + /// \param x The new horizontal position of the Element in its parent coordinates. + /// \param y The new vertical position of the Element in its parent coordinates. + /// \param width The new width of the Element in its parent coordinates. + /// \param height The new height of the Element in its parent coordinates. + virtual void setShape(float x, float y, float width, float height); + + /// \brief Get the bounding box representing all child elements. + /// \returns the bounding box representing all child elements, or + /// a rectangle of zero width and height at the origin if no children. + Shape getChildShape() const; + + /// \brief Get the bounding box representing the union of the child shape and the element shape. + /// \returns the bounding box representing the union of the child shape and the element shape. + Shape getTotalShape() const; + + /// \brief Get the id of this Element. + /// + /// The id is optional and an empty std::string by default. + /// + /// \returns the id of the Element. + std::string getId() const; + + /// \brief Set the id of the Element. + /// \param id The new id of the Element. + void setId(const std::string& id); + + /// \brief Determine of the Element has an attribute with the given name. + /// \param name The name of the Attribute to query. + /// \returns true iff the Element has an attribute with the given name. + bool hasAttribute(const std::string& name) const; + + /// \brief Get a named attribute via its key. + /// + /// Users should check to see if the attribute exists using hasAttribute or + /// catch the DOMException. + /// + /// \throws DOMException if no such key. + /// \throws Poco::BadCastException if the types do not match. + /// \param key The name of the attribute. + /// \param inherit True if the Element should query its ancestors for the attribute. + /// \returns The value corresponding to the key, or throws an exception. + template + AnyType getAttribute(const std::string& key, bool inherit = false); + + /// \brief Set a value for a named attribute. + /// + /// If the given attribute exists, it will be overwritten with the given + /// value. + /// + /// \param name The name of the attribute. + /// \param value The new value of the attribute called name. + void setAttribute(const std::string& name, const Any& value); + + /// \brief Clear a named attribute. + /// \param The name of the attribute to clear. + void clearAttribute(const std::string& name); + + /// \brief Request that the parent Document capture the given pointer id. + /// + /// Captured pointers send all of their revents to the capturing Element. + /// + /// \param id The pointer id to capture. + void setPointerCapture(std::size_t id); + + /// \brief Release a captured pointer with the given id. + /// + /// Usually this call is not required as the parent Document's pointer + /// dispatching system will automatically release a pointer on the next + /// POINTER_UP event. In some cases, the user may want to explicity release + /// the event to fire the associated lostPointerCapture events. + /// + /// \param id The pointer id to release. + void releasePointerCapture(std::size_t id); + + /// \returns true iff the Element is enabled. + bool isEnabled() const; + + /// \brief Enable or disable this Element. + /// \param enabled The enabled state to set. True to enable, false to disable. + void setEnabled(bool enabled); + + /// \returns true iff the Element is visible. + bool isHidden() const; + + /// \brief Hide or show this Element. + /// \param hidden The visible state to set. True to hide, false to show. + void setHidden(bool hidden); + + /// \brief Hide or show this Element. + /// \param visible The visible state to set. False to hide, true to show. + void setVisible(bool& visible); + + /// \returns A parameter that determines if the element is visible or not. + ofParameter& getVisible(); + + /// \returns true iff the Element is locked. + bool isLocked() const; + + /// \brief Lock or unlock a this Element. + /// \param locked The locked state to set. True to lock, false to unlock. + void setLocked(bool locked); + + /// \param If true prevent layout from being computed, if false release block + void blockLayout(bool block); + + /// \brief Called internally to invalidate the child shape tree. + virtual void invalidateChildShape(); + +// /// \brief Redo layout and children layouts. +// virtual void redoLayout(); + + /// \brief A method to call generateDraw() next time before the object is rendered + void setNeedsRedraw(); + + +protected: + /// \brief Setup method called by parent Element. + /// \param e The event data. + void _setup(ofEventArgs& e); + + /// \brief Update method called by parent Element. + /// \param e The event data. + void _update(ofEventArgs& e); + + /// \brief Draw method called by parent Element. + /// \param e The event data. + void _draw(ofEventArgs& e); + + /// \brief Render method to draw content on screen + virtual void render(){} + + /// \brief A method to generate the content drawn by render() + virtual void generateDraw(){} + + /// \brief Exit method called by parent Element. + /// \param e The event data. + void _exit(ofEventArgs& e); + + /// \brief A recursive hit test to find a target element. + /// \param parentPosition The parent coordinates to test. + /// \returns A pointer to the target Element or a nullptr if none found. + /// \todo Provide a seed position to speed up search? + Element* recursiveHitTest(const Position& parentPosition); + + /// \brief Find a child by a raw Element pointer. + /// \param The pointer to the child. + /// \returns An iterator pointing to the matching Element or the end. + std::vector>::iterator findChild(Element* element); + + + /// \brief A vector to Elements. + std::vector> _children; + +//private: + /// \brief Not construction-copyable. + Element(const Element& other) = delete; // non-construction-copyable + + /// \brief Non copyable. + Element& operator = (const Element&) = delete; + + /// \brief A callback for to notify of Element movement + void _onMoved(MoveEventArgs&); + + /// \brief A callback to notify of Elements size changes + void _onResized(ResizeEventArgs&); + + /// \brief A callback for child Elements to notify their parent of movement. + void _onChildMoved(MoveEventArgs &args); + + /// \brief A callback for child Elements to notify their parent size changes. + void _onChildResized(ResizeEventArgs&); + + /// \brief The id for this element. + std::string _id; + + /// \brief The basic shape of this element. + Shape _shape; + Size _layoutSize; + Size _sizeSetByParent; + + /// \brief The union of all child shapes. + mutable Shape _childShape; + + /// \brief True if the child geometry is invalid. + /// + /// This variable usually set by callbacks from the child elements. + mutable bool _childShapeInvalid = true; + + /// \brief The enabled state of this Element. + bool _enabled = true; + + /// \brief The hidden state of this Element. + bool _hidden = false; + + /// \brief The locked state of this Element. + bool _locked = false; + + ofParameter _visible; + + /// \brief A collection of named attributes. + /// \todo This may not be permanent. + std::unordered_map _attributes; + + /// \brief True if content drawn by render() needs to be regenerated + bool needsRedraw; + + /// \brief The Layout associated with this + std::unique_ptr _layout; + + /// \brief An optional pointer to a parent Node. + Element* _parent = nullptr; + + /// \brief The Layout class has access to all private variables. + friend class Layout; + + /// \brief The Document class has access to all private variables. + friend class Document; + +}; + + +template +ElementType* Element::add(Args&&... args) +{ + return add(std::make_unique(std::forward(args)...)); +} + + +template +ElementType* Element::add(std::unique_ptr element) +{ + + static_assert(std::is_base_of(), "ElementType must be an Element or derived from Element."); + + if (element) + { + // Get a raw pointer to the node for later. + ElementType* pNode = element.get(); + + // Assign the parent to the node via the raw pointer. + pNode->_parent = this; + + // Take ownership of the node. + _children.push_back(std::move(element)); + + // Invalidate all cached child shape. + pNode->invalidateChildShape(); + + // Alert the node that its parent was set. + ElementEventArgs addedEvent(this); + ofNotifyEvent(pNode->addedTo, addedEvent, this); + + ElementEventArgs childAddedEvent(pNode); + ofNotifyEvent(childAdded, childAddedEvent, this); + + // Attach child listeners. + ofAddListener(pNode->move, this, &Element::_onChildMoved); + ofAddListener(pNode->resize, this, &Element::_onChildResized); + + /// Alert the node's siblings that they have a new sibling. + for (auto& child : _children) + { + // Don't alert itself. + if (child.get() != pNode) + { + ElementEventArgs event(pNode); + ofNotifyEvent(child->siblingAdded, event, this); + } + } + + return pNode; + } + else + { + return nullptr; + } +} + + +template +std::vector Element::siblings() +{ + static_assert(std::is_base_of(), "ElementType must be an Element or derived from Element."); + + std::vector results; + + if (_parent) + { + for (auto& child : _parent->_children) + { + ElementType* pChild = dynamic_cast(child.get()); + + if (pChild != this) + { + results.push_back(pChild); + } + } + } + + return results; +} + + +template +std::vector Element::children() +{ + static_assert(std::is_base_of(), "ElementType must be an Element or derived from Element."); + + std::vector results; + + for (auto& child : _children) + { + ElementType* pChild = dynamic_cast(child.get()); + + if (pChild) + { + results.push_back(pChild); + } + } + + return results; +} + + +template +LayoutType* Element::createLayout(Args&&... args) +{ + return setLayout(std::make_unique(std::forward(args)...)); +} + + +template +LayoutType* Element::setLayout(std::unique_ptr layout) +{ + if (layout) + { + // Get a raw pointer to the node for later. + LayoutType* pLayout = layout.get(); + + // Assign the parent to the node via the raw pointer. + pLayout->_parent = this; + + // Take ownership of the layout. + _layout = std::move(layout); + + _layoutSize.x = 0; + _layoutSize.y = 0; + + // Invalidate all cached child shape. + invalidateChildShape(); + + return pLayout; + } + else + { + return nullptr; + } +} + + +template +AnyType Element::getAttribute(const std::string& key, bool inherit) +{ + auto iter = _attributes.find(key); + + if (iter != _attributes.end() && iter->second.is()) + { + return iter->second.as(); + } + else if (inherit && hasParent()) + { + return parent()->getAttribute(key); + } + else + { + throw DOMException(DOMException::INVALID_ATTRIBUTE_KEY); + } +} + + +} // namespace DOM diff --git a/addons/ofxGui/src/EventTarget.h b/addons/ofxGui/src/EventTarget.h new file mode 100644 index 0000000..7a424dc --- /dev/null +++ b/addons/ofxGui/src/EventTarget.h @@ -0,0 +1,404 @@ +// ============================================================================= +// +// Copyright (c) 2009-2016 Christopher Baker +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. +// +// ============================================================================= + + +#pragma once + +#include +#include +#include +#include "Events.h" + + +namespace DOM { + + +/// \brief A class representing an EventTarget. +/// +/// EventTargets know how to handle events. This class is usually inherited +/// using the curiously-recurring template pattern. +/// +/// \tparam EventTargetType The type of the Tvent target. +template +class EventTarget +{ +public: + /// \brief Create an EventTarget. + EventTarget(); + + /// \brief Destroy the EventTarget. + virtual ~EventTarget(); + + template + void addEventListener(EventType& event, + void (ListenerClass::*listenerMethod)(const void*, ArgumentsType&), + bool useCapture = false, + int priority = OF_EVENT_ORDER_AFTER_APP) + { + ofAddListener(event.event(useCapture), dynamic_cast(this), listenerMethod, priority); + } + + template + void addEventListener(EventType& event, + void (ListenerClass::*listenerMethod)(ArgumentsType&), + bool useCapture = false, + int priority = OF_EVENT_ORDER_AFTER_APP) + { + ofAddListener(event.event(useCapture), dynamic_cast(this), listenerMethod, priority); + } + + template + void addEventListener(EventType& event, + bool (ListenerClass::*listenerMethod)(const void*, ArgumentsType&), + bool useCapture = false, + int priority = OF_EVENT_ORDER_AFTER_APP) + { + ofAddListener(event.event(useCapture), dynamic_cast(this), listenerMethod, priority); + } + + template + void addEventListener(EventType& event, + bool (ListenerClass::*listenerMethod)(ArgumentsType&), + bool useCapture = false, + int priority = OF_EVENT_ORDER_AFTER_APP) + { + ofAddListener(event.event(useCapture), dynamic_cast(this), listenerMethod, priority); + } + + template + void removeEventListener(EventType& event, + void (ListenerClass::*listenerMethod)(const void*, ArgumentsType&), + bool useCapture = false, + int priority = OF_EVENT_ORDER_AFTER_APP) + { + ofRemoveListener(event.event(useCapture), dynamic_cast(this), listenerMethod, priority); + } + + template + void removeEventListener(EventType& event, + void (ListenerClass::*listenerMethod)(ArgumentsType&), + bool useCapture = false, + int priority = OF_EVENT_ORDER_AFTER_APP) + { + ofRemoveListener(event.event(useCapture), dynamic_cast(this), listenerMethod, priority); + } + + + template + void removeEventListener(EventType& event, + bool (ListenerClass::*listenerMethod)(const void*, ArgumentsType&), + bool useCapture = false, + int priority = OF_EVENT_ORDER_AFTER_APP) + { + ofRemoveListener(event.event(useCapture), dynamic_cast(this), listenerMethod, priority); + } + + + template + void removeEventListener(EventType& event, + bool (ListenerClass::*listenerMethod)(ArgumentsType&), + bool useCapture = false, + int priority = OF_EVENT_ORDER_AFTER_APP) + { + ofRemoveListener(event.event(useCapture), dynamic_cast(this), listenerMethod, priority); + } + + /// \brief Dispatch the given event. + /// + /// This will return true if the default action for this event should be + /// prevented. + /// + /// \param event The Event to dispatch. + /// \tparam EventType The Event type to dispatch. + /// \returns true iff one of the responders called Event::preventDefault(). + template + bool dispatchEvent(EventType& event); + + /// \brief Handle the given event. + /// + /// This will return true if the default action for this event should be + /// prevented. + /// + /// \tparam EventArgsType The EventArgs type to dispatch. + /// \param event The Event to dispatch. + /// \returns true if the EventTarget was registered to handle the event. + template + bool handleEvent(EventArgsType& e); + + /// \brief Determine if the EventTarget has listeners for an event. + /// \param event The event name. + /// \returns true if it has registered listeners for this event. + bool hasListenersForEventType(const std::string& type) const; + + /// \brief Determine if the EventTarget is registered to receive the type of events. + /// \param type The event type. + /// \returns true if it is registered to receive the type of events. + bool isEventTypeRegistered(const std::string& type) const; + + /// \brief Register a new event type by name. + /// \param type The event type. + /// \param event A pointer to the DOMEvent<> that will be called. + void registerEventType(const std::string& type, BaseDOMEvent* event); + + /// \brief Unregister a new event type by name. + /// \param type The event type. + void unregisterEventType(const std::string& type); + + virtual void onSetup() + { + } + + virtual void onUpdate() + { + } + + virtual void onExit() + { + } + + DOMEvent keyDown; + DOMEvent keyUp; + + DOMEvent blur; + DOMEvent focusIn; + DOMEvent focus; + DOMEvent focusOut; + + ofEvent addedTo; + ofEvent removedFrom; + ofEvent reordered; + + ofEvent siblingAdded; + ofEvent siblingRemoved; + ofEvent siblingReordered; + + ofEvent childAdded; + ofEvent childRemoved; + ofEvent childReordered; + ofEvent childMoved; + + ofEvent move; + ofEvent resize; + + ofEvent attributeSet; + ofEvent attributeCleared; + + ofEvent enabled; + ofEvent locked; + ofEvent hidden; + +protected: + std::unordered_map _eventRegistry; + +}; + + +template +EventTarget::EventTarget() +{ + // Register default events. + // TODO: do we want to automatically register all of these events? + // TODO: do we need the event target to have all of these events, or could + // it be on more of an ad hoc basis ... could be a speed optimization not + // to have each one. + + // theoretically not having any events registered woudl make isEventTypeRegistered much faster. + _eventRegistry = { + + { KeyboardUIEventArgs::KEY_DOWN, &keyDown }, + { KeyboardUIEventArgs::KEY_UP, &keyUp } + }; +} + + +template +EventTarget::~EventTarget() +{ +} + + +template +template +bool EventTarget::dispatchEvent(EventType& event) +{ + // Get the target (this Element). + EventTargetType* target = dynamic_cast(this); + + // Create the path from the target to the document. + std::vector targets; + + // The target will be at the beginning of the list. + // The root document will be at the end of the list. + do + { + targets.push_back(target); + target = target->parent(); + } + while (target); + + + // Capture and Target phase (document -> target). + + // Begin with the document (at the end of the list). + auto riter = targets.rbegin(); + + // Cycle through the targets from the document to the event.target(). + while (riter != targets.rend()) + { + event.setPhase(event.target() == *riter ? EventArgs::Phase::AT_TARGET : EventArgs::Phase::CAPTURING_PHASE); + event.setCurrentTarget(*riter); + + // Here we handle event and assume that if the currentTarget + // can't handle the event, it will return quickly with no errors. + // This is potentially faster that asking the target to search its + // registry and then asking it to search its registry _again_ to + // actually handle the event. + bool isRegisteredHandler = (*riter)->handleEvent(event); + + // If the event is cancelled, return appropriately. + if (event.isCancelled()) + { + return !event.isDefaultPrevented(); + } + + // TODO + if (!isRegisteredHandler) + { + // Here we might remove any listeners from the list of targets that cannot handle ... ? + // Does this prevent us from dynamically adding and removing listeners between the + // bubble and capture phases though? + } + + // Continue iterating. + ++riter; + } + + // Bubble phase if needed (target -> document). + if (targets.size() > 1 && event.bubbles()) + { + // Begin with the _parent_ of the target element (we already dealt + // with the target element during the capture / target phased). + auto bubbleIter = targets.begin() + 1; + + while (bubbleIter != targets.end()) + { + event.setPhase(EventArgs::Phase::BUBBLING_PHASE); + + event.setCurrentTarget(*bubbleIter); + + // Here we handle event and assume that if the currentTarget + // can't handle the event, it will return quickly with no errors. + // This is potentially faster that asking the target to search its + // registry and then asking it to search its registry _again_ to + // actually handle the event. + (*bubbleIter)->handleEvent(event); + + if (event.isCancelled()) + { + return !event.isDefaultPrevented(); + } + + ++bubbleIter; + } + } + + return event.isDefaultPrevented(); +} + + +template +bool EventTarget::hasListenersForEventType(const std::string& type) const +{ + auto iter = _eventRegistry.find(type); + + if (iter != _eventRegistry.end()) + { + return iter->second->hasListeners(); + } + else + { + return false; + } +} + + +template +template +bool EventTarget::handleEvent(EventArgsType& e) +{ + + + + auto iter = _eventRegistry.find(e.type()); + + if (iter != _eventRegistry.end()) + { + DOMEvent* _event = dynamic_cast*>(iter->second); + + if (_event) + { +// if (e.type() == "buttonpressed") +// { +// cout << "event: " << e.type() << " being handled by : " << (e.getCurrentTarget() ? e.getCurrentTarget()->getId() : "nullptr") << endl; +// cout << " hasListeners -> " << _event->hasListeners() << std::endl; +// cout << " e -> " << e.toString() << std::endl; +// } + _event->notify(e); + return true; + } + else + { + throw DOMException(DOMException::INVALID_STATE_ERROR + ": " + "EventTarget::handleEvent: " + e.type() + " invalid listener registered."); + } + } + else + { + return false; + } +} + + +template +bool EventTarget::isEventTypeRegistered(const std::string& type) const +{ + return _eventRegistry.find(type) != _eventRegistry.end(); +} + + +template +void EventTarget::registerEventType(const std::string& type, + BaseDOMEvent* event) +{ + _eventRegistry[type] = event; +} + + +template +void EventTarget::unregisterEventType(const std::string& type) +{ + _eventRegistry.erase(_eventRegistry.find(type)); +} + + +} // namespace DOM diff --git a/addons/ofxGui/src/Events.cpp b/addons/ofxGui/src/Events.cpp new file mode 100644 index 0000000..c9aea66 --- /dev/null +++ b/addons/ofxGui/src/Events.cpp @@ -0,0 +1,419 @@ +// ============================================================================= +// +// Copyright (c) 2009-2016 Christopher Baker +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. +// +// ============================================================================= + + +#include "Events.h" +#include "Element.h" + + +namespace DOM { + + +EventArgs::EventArgs(const std::string& type, + Element* source, + Element* target, + bool bubbles, + bool cancelable, + uint64_t timestamp): + EventArgs(type, source, target, nullptr, bubbles, cancelable, timestamp) +{ +} + + +EventArgs::EventArgs(const std::string& type, + Element* source, + Element* target, + Element* relatedTarget, + bool bubbles, + bool cancelable, + uint64_t timestamp): + _type(type), + _source(source), + _target(target), + _relatedTarget(relatedTarget), + _bubbles(bubbles), + _cancelable(cancelable), + _timestamp(timestamp) +{ +} + + +EventArgs::~EventArgs() +{ +} + + +const std::string& EventArgs::type() const +{ + return _type; +} + + +void EventArgs::stopPropagation() +{ + if (_cancelable) + { + _canceled = true; + } +} + + +void EventArgs::stopImmediatePropagation() +{ + if (_cancelable) + { + _canceled = true; + //throw ofEventAttendedException(); + } +} + + +void EventArgs::preventDefault() +{ + _defaultPrevented = true; +} + + +bool EventArgs::isCancelled() const +{ + return _canceled; +} + + +bool EventArgs::isDefaultPrevented() const +{ + return _defaultPrevented; +} + + +void EventArgs::setPhase(Phase phase) +{ + _phase = phase; +} + + +EventArgs::Phase EventArgs::getPhase() const +{ + return _phase; +} + + +bool EventArgs::bubbles() const +{ + return _bubbles; +} + + +bool EventArgs::isCancelable() const +{ + return _cancelable; +} + + +Element* EventArgs::source() +{ + return _source; +} + + +Element* EventArgs::target() +{ + return _target; +} + + +Element* EventArgs::relatedTarget() +{ + return _relatedTarget; +} + + +Element* EventArgs::getCurrentTarget() +{ + return _currentTaget; +} + + +const Element* EventArgs::getCurrentTarget() const +{ + return _currentTaget; +} + + +void EventArgs::setCurrentTarget(Element* target) +{ + _currentTaget = target; +} + + +uint64_t EventArgs::timestamp() const +{ + return _timestamp; +} + + +std::string EventArgs::toString() const +{ + std::stringstream ss; + + std::string phaseString = ""; + + switch (_phase) + { + case Phase::NONE: + phaseString = "NONE"; + break; + case Phase::CAPTURING_PHASE: + phaseString = "CAPTURING_PHASE"; + break; + case Phase::AT_TARGET: + phaseString = "AT_TARGET"; + break; + case Phase::BUBBLING_PHASE: + phaseString = "BUBBLING_PHASE"; + break; + } + + + ss << "Event Type: " << _type << std::endl; + ss << " Phase: " << phaseString << std::endl; + ss << " Source: " << (_source != nullptr ? _source->getId() : "nullptr") << std::endl; + ss << " Target: " << (_target != nullptr ? _target->getId() : "nullptr") << std::endl; + ss << "Rel-Target: " << (_relatedTarget != nullptr ? _relatedTarget->getId() : "nullptr") << std::endl; + ss << "Cur-Target: " << (_currentTaget != nullptr ? _currentTaget->getId() : "nullptr") << std::endl; + ss << " Bubs/Canc: " << _bubbles << "/" << _cancelable << std::endl; + ss << " DP/Canc'd: " << _defaultPrevented << "/" << _canceled << std::endl; + ss << " timestamp: " << _timestamp << std::endl; + + return ss.str(); +} + + +const std::string KeyboardUIEventArgs::KEY_DOWN = "keydown"; +const std::string KeyboardUIEventArgs::KEY_UP = "keyup"; + + +KeyboardUIEventArgs::KeyboardUIEventArgs(const ofKeyEventArgs& args, + Element* source, + Element* target): + UIEventArgs(args.type == ofKeyEventArgs::Pressed ? KEY_DOWN : KEY_UP, + source, + target, + true, + true, + ofGetElapsedTimeMillis()) +{ +} + + +KeyboardUIEventArgs::~KeyboardUIEventArgs() +{ +} + + +const ofKeyEventArgs& KeyboardUIEventArgs::key() const +{ + return _key; +} + + +const std::string FocusEventArgs::FOCUS_IN = "focusin"; +const std::string FocusEventArgs::FOCUS = "focus"; +const std::string FocusEventArgs::FOCUS_OUT = "focusout"; +const std::string FocusEventArgs::BLUR = "blur"; + + +FocusEventArgs::FocusEventArgs(const std::string& type, + Element* source, + Element* target, + Element* relatedTarget): + EventArgs(type, + source, + target, + (type != FOCUS), // In the spec. + false, + ofGetElapsedTimeMillis()) +{ + // TODO: better Event constructor. + _relatedTarget = relatedTarget; +} + + +FocusEventArgs::~FocusEventArgs() +{ +} + + +MoveEventArgs::MoveEventArgs(const Position& position, Element *element): + _element(element), + _position(position) +{ +} + + +MoveEventArgs::~MoveEventArgs() +{ +} + + +const Position& MoveEventArgs::position() const +{ + return _position; +} + + +Element* MoveEventArgs::element() +{ + return _element; +} + + +ResizeEventArgs::ResizeEventArgs(const Shape& shape): + _shape(shape) +{ +} + + +ResizeEventArgs::~ResizeEventArgs() +{ +} + + +const Shape& ResizeEventArgs::shape() const +{ + return _shape; +} + + +AttributeEventArgs::AttributeEventArgs(const std::string& key, + const Any& value): + _key(key), + _value(value) +{ +} + + +AttributeEventArgs::~AttributeEventArgs() +{ +} + + +const std::string& AttributeEventArgs::key() const +{ + return _key; +} + + +const Any& AttributeEventArgs::value() const +{ + return _value; +} + + +EnablerEventArgs::EnablerEventArgs(bool value): + _value(value) +{ +} + + +EnablerEventArgs::~EnablerEventArgs() +{ +} + + +bool EnablerEventArgs::value() const +{ + return _value; +} + + +ElementEventArgs::ElementEventArgs(Element* element): + _element(element) +{ +} + + +ElementEventArgs::~ElementEventArgs() +{ +} + + +Element* ElementEventArgs::element() +{ + return _element; +} + + +ElementOrderEventArgs::ElementOrderEventArgs(Element* element, + std::size_t newIndex, + std::size_t oldIndex): + ElementEventArgs(element), + _newIndex(newIndex), + _oldIndex(oldIndex) +{ +} + + +ElementOrderEventArgs::~ElementOrderEventArgs() +{ +} + + +std::size_t ElementOrderEventArgs::newIndex() const +{ + return _newIndex; +} + + +std::size_t ElementOrderEventArgs::oldIndex() const +{ + return _oldIndex; +} + + +bool ElementOrderEventArgs::wasMovedForward() const +{ + return _oldIndex > _newIndex; +} + + +bool ElementOrderEventArgs::wasMovedBackward() const +{ + return _newIndex > _oldIndex; +} + + +bool ElementOrderEventArgs::isAtFront() const +{ + return _newIndex == 0; +} + + +bool ElementOrderEventArgs::isAtBack() const +{ + return _element->numSiblings() == _newIndex; +} + + +} // namespace DOM diff --git a/addons/ofxGui/src/Events.h b/addons/ofxGui/src/Events.h new file mode 100644 index 0000000..8cd7157 --- /dev/null +++ b/addons/ofxGui/src/Events.h @@ -0,0 +1,470 @@ +// ============================================================================= +// +// Copyright (c) 2009-2016 Christopher Baker +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. +// +// ============================================================================= + + +#pragma once + + +#include +#include +#include +#include +#include "ofEvents.h" +#include "Exceptions.h" +#include "Types.h" + + +namespace DOM { + + +class Element; + + +/// \brief The base type describing a named Element Event. +/// +/// \sa http://www.w3.org/TR/DOM-Level-3-Events/ +class EventArgs +{ +public: + /// \brief Create EventArgs with a type. + /// \param type The event type string (case-insensitive). + /// \param source The source of the event. + /// \param target The target element. + /// \param bubbles True iff the argument bubbles after AT_TARGET phase. + /// \param cancelable True iff the event can be cancelled by a listener. + /// \param timestamp The timestamp of the event. + EventArgs(const std::string& type, + Element* source, + Element* target, + bool bubbles, + bool cancelable, + uint64_t timestamp); + + /// \brief Create EventArgs with a type. + /// \param type The event type string (case-insensitive). + /// \param source The source of the event. + /// \param target The target element. + /// \param bubbles True iff the argument bubbles after AT_TARGET phase. + /// \param cancelable True iff the event can be cancelled by a listener. + /// \param timestamp The timestamp of the event. + EventArgs(const std::string& type, + Element* source, + Element* target, + Element* relatedTarget, + bool bubbles, + bool cancelable, + uint64_t timestamp); + + /// \brief Destroy the EventArgs. + virtual ~EventArgs(); + + /// \brief Get the event type. + /// \returns the event type string. + const std::string& type() const; + + enum class Phase + { + /// \brief Events not currently dispatched are in this phase. + NONE = 0, + /// \brief When an event is dispatched to an object that participates in a tree it will be in this phase before it reaches its target attribute value. + CAPTURING_PHASE = 1, + /// \brief When an event is dispatched it will be in this phase on its target attribute value. + AT_TARGET = 2, + /// \brief When an event is dispatched to an object that participates in a tree it will be in this phase after it reaches its target attribute value. + BUBBLING_PHASE = 3 + }; + + + /// \brief Stop the propagation of the event. + /// + /// The stopPropagation method is used prevent further propagation of an + /// event during event flow. If this method is called by any EventListener + /// the event will cease propagating through the tree. The event will + /// complete dispatch to all listeners on the current EventTarget before + /// event flow stops. This method may be used during any stage of event + /// flow. + void stopPropagation(); + + // \brief Stop the propagation of the event, including all other events at the target. + // + // If successful this event throws ofEventAttendedException(). This exception + // should be handled gracefully by the ofEvent dispatching this event. + // + // The same effect can be achieved by returning "true" from any event + // callback with a boolean return type. + // + // \throws ofEventAttendedException if the event is cancelable. + void stopImmediatePropagation(); + + /// \brief Prevent any default actions associated with the event. + /// + /// For some events, there are default actions. Calling preventDefault will + /// tell the event dispatcher that it should not call the default action + /// after the event has been dispatched. This is different from + /// stopPropagation. Calling stopPropagation does not prevent the default + /// action from taking place. To stop propagation and prevent the default, + /// both methods must be called. + void preventDefault(); + + /// \returns true iff the event was cancelled. + bool isCancelled() const; + + /// \returns true iff the default activity was prevented. + bool isDefaultPrevented() const; + + /// \brief Set the Phase of the event. + /// \param phase The phase to set. + void setPhase(Phase phase); + + /// \returns the Phase of the event. + Phase getPhase() const; + + /// \brief Determine if the event has a bubbling phase. + /// \returns true iff the event should bubble. + bool bubbles() const; + + /// \returns true iff the Event can be cancelled. + bool isCancelable() const; + + /// \returns the source Element. + Element* source(); + + /// \returns the target Element. + Element* target(); + + /// \returns the related target Element. + Element* relatedTarget(); + + /// \returns a pointer to the current target Element. + Element* getCurrentTarget(); + + /// \returns a pointer to the current target Element. + const Element* getCurrentTarget() const; + + /// \brief Set the current target Element. + /// \param target The current target Element. + void setCurrentTarget(Element* target); + + /// \returns the timestamp (in milliseconds relative to the epoch). + uint64_t timestamp() const; + + /// \brief A utility method to print get the Event as a std::string. + /// \returns The Event as a std::string. + /// \note Not for serialization. + std::string toString() const; + +protected: + /// \brief The name of the event (case-insensitive). + std::string _type; + + /// \brief The source of the event. + Element* _source = nullptr; + + /// \brief The event's target. + Element* _target = nullptr; + + /// \brief The event's related target. + Element* _relatedTarget = nullptr; + + /// \brief Used to indicate whether or not an event is a bubbling event. + /// If the event can bubble the value is true, else the value is false. + bool _bubbles = true; + + /// \brief Used to indicate whether propgation was stopped. The currentTarget + /// will indicate which target stopped propagation. + bool _cancelable = true; + + /// \brief Used to indicated + bool _defaultPrevented = false; + + /// \brief Used to indicate the EventTarget whose EventListeners are currently being processed. + /// This is particularly useful during capturing and bubbling. + Element* _currentTaget = nullptr; + + /// \brief Used to indicate which phase of event flow is currently being evaluated. + Phase _phase = Phase::NONE; + + /// \brief Used to indicate if an event is canceled. + bool _canceled = false; + + /// \brief Used to specify the time (in milliseconds relative to the epoch) + /// at which the event was created. + /// + /// Due to the fact that some systems may not provide this information the + /// value of timeStamp may be not available for all events. When not + /// available, a value of 0 will be returned. Examples of epoch time are + /// the time of the system start or 0:0:0 UTC 1st January 1970. + uint64_t _timestamp = 0; + + /// \brief The Document class has access to Event data. + friend class Document; +}; + + +/// can we handle this named ui event at this coordinate? +class UIEventArgs: public EventArgs +{ +public: + using EventArgs::EventArgs; + + virtual ~UIEventArgs() + { + } + +}; + + +class KeyboardUIEventArgs: public UIEventArgs +{ +public: + KeyboardUIEventArgs(const ofKeyEventArgs& args, + Element* source, + Element* target); + + virtual ~KeyboardUIEventArgs(); + + const ofKeyEventArgs& key() const; + + static const std::string KEY_DOWN; + static const std::string KEY_UP; + +protected: + ofKeyEventArgs _key; + +}; + + +/// \sa http://www.w3.org/TR/DOM-Level-3-Events/#event-type-focus +class FocusEventArgs: public EventArgs +{ +public: + FocusEventArgs(const std::string& type, + Element* source, + Element* target, + Element* relatedTarget = nullptr); + + virtual ~FocusEventArgs(); + + static const std::string FOCUS_IN; + static const std::string FOCUS; + static const std::string FOCUS_OUT; + static const std::string BLUR; + +}; + + +class DragDropEventArgs: public EventArgs +{ +public: + +}; + + +class AbstractDOMEvent +{ +public: + virtual ~AbstractDOMEvent() + { + } +}; + + + +class BaseDOMEvent +{ +public: + virtual ~BaseDOMEvent() + { + } + + //virtual std::string type() const = 0; + + virtual bool hasBubblePhaseListeners() const = 0; + virtual bool hasCapturePhaseListeners() const = 0; + + bool hasListeners() const + { + return hasBubblePhaseListeners() || hasCapturePhaseListeners(); + } + +}; + + +/// \brief DOM Events follow the DOM capture, target, bubble propagation scheme. +/// +/// +template +class DOMEvent: public BaseDOMEvent +{ +public: + virtual ~DOMEvent() + { + } + + bool hasBubblePhaseListeners() const override + { + return _bubbleEvent.size() > 0; + } + + bool hasCapturePhaseListeners() const override + { + return _captureEvent.size() > 0; + } + + ofEvent& event(bool useCapture = false) + { + return useCapture ? _captureEvent : _bubbleEvent; + } + + void notify(EventArgsType& e) + { + switch (e.getPhase()) + { + case EventArgs::Phase::NONE: + throw DOMException(DOMException::INVALID_STATE_ERROR + ": " + "DOMEvent::notify"); + case EventArgs::Phase::CAPTURING_PHASE: + _captureEvent.notify(e.source(), e); + return; + case EventArgs::Phase::AT_TARGET: + _captureEvent.notify(e.source(), e); + _bubbleEvent.notify(e.source(), e); + return; + case EventArgs::Phase::BUBBLING_PHASE: + _bubbleEvent.notify(e.source(), e); + return; + } + } + +private: + ofEvent _bubbleEvent; + ofEvent _captureEvent; + +}; + + +class MoveEventArgs +{ +public: + MoveEventArgs(const Position& position, Element* element); + virtual ~MoveEventArgs(); + + const Position& position() const; + Element* element(); + +protected: + Position _position; + Element* _element; + +}; + +class ResizeEventArgs +{ +public: + ResizeEventArgs(const Shape& shape); + virtual ~ResizeEventArgs(); + + const Shape& shape() const; + +protected: + Shape _shape; + +}; + + +class AttributeEventArgs +{ +public: + AttributeEventArgs(const std::string& key, const Any& value = Any()); + + virtual ~AttributeEventArgs(); + + const std::string& key() const; + + const Any& value() const; + +protected: + std::string _key; + Any _value; + +}; + + +class EnablerEventArgs +{ +public: + EnablerEventArgs(bool value); + virtual ~EnablerEventArgs(); + + bool value() const; + +protected: + bool _value; + +}; + + +class ElementEventArgs +{ +public: + ElementEventArgs(Element* element); + + virtual ~ElementEventArgs(); + + Element* element(); + +protected: + Element* _element; + +}; + + +class ElementOrderEventArgs: public ElementEventArgs +{ +public: + ElementOrderEventArgs(Element* element, + std::size_t oldIndex, + std::size_t newIndex); + + virtual ~ElementOrderEventArgs(); + + std::size_t newIndex() const; + + std::size_t oldIndex() const; + + bool wasMovedForward() const; + + bool wasMovedBackward() const; + + bool isAtFront() const; + + bool isAtBack() const; + +protected: + std::size_t _oldIndex; + std::size_t _newIndex; + +}; + + +} // namespace DOM diff --git a/addons/ofxGui/src/Exceptions.cpp b/addons/ofxGui/src/Exceptions.cpp new file mode 100644 index 0000000..3127ab1 --- /dev/null +++ b/addons/ofxGui/src/Exceptions.cpp @@ -0,0 +1,38 @@ +// ============================================================================= +// +// Copyright (c) 2009-2016 Christopher Baker +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. +// +// ============================================================================= + + +#include "Exceptions.h" + + +namespace DOM { + + +const std::string DOMException::INVALID_POINTER_ID = "InvalidPointerId"; +const std::string DOMException::INVALID_STATE_ERROR = "InvalidStateError"; +const std::string DOMException::UNREGISTERED_EVENT = "UnregisteredEvent"; +const std::string DOMException::INVALID_ATTRIBUTE_KEY = "InvalidAttributeKey"; + + +} // namespace DOM diff --git a/addons/ofxGui/src/Exceptions.h b/addons/ofxGui/src/Exceptions.h new file mode 100644 index 0000000..d6e28ce --- /dev/null +++ b/addons/ofxGui/src/Exceptions.h @@ -0,0 +1,57 @@ +// ============================================================================= +// +// Copyright (c) 2009-2016 Christopher Baker +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. +// +// ============================================================================= + + +#pragma once + + +#include +#include + + +namespace DOM { + + +/// \brief A generic DOM exception. +class DOMException: public std::runtime_error +{ +public: + using std::runtime_error::runtime_error; + + /// \brief Invalid pointer id exception. + static const std::string INVALID_POINTER_ID; + + /// \brief Invalid state exception. + static const std::string INVALID_STATE_ERROR; + + /// \brief Unregistered event exception. + static const std::string UNREGISTERED_EVENT; + + /// \brief Invalid attribute key exception. + static const std::string INVALID_ATTRIBUTE_KEY; + +}; + + +} // namespace DOM diff --git a/addons/ofxGui/src/IDGenerator.h b/addons/ofxGui/src/IDGenerator.h new file mode 100644 index 0000000..f5d850a --- /dev/null +++ b/addons/ofxGui/src/IDGenerator.h @@ -0,0 +1,13 @@ +#pragma once + +class IDGenerator { + public: + static IDGenerator& getInstance() { + static IDGenerator instance; + return instance; + } + int next () { return _id++; } + private: + IDGenerator () : _id(0) {} + int _id; +}; diff --git a/addons/ofxGui/src/JsonConfigParser.cpp b/addons/ofxGui/src/JsonConfigParser.cpp new file mode 100644 index 0000000..e558ce6 --- /dev/null +++ b/addons/ofxGui/src/JsonConfigParser.cpp @@ -0,0 +1,216 @@ +#include "JsonConfigParser.h" +#include + +bool JsonConfigParser::_parse(const ofJson &config, const string &name, bool& val){ + + if (config.find(name) != config.end()) { + ofJson content = config[name]; + if(content.is_boolean()){ + val = content; + return true; + }else { + ofLogError("JsonConfigParser::parse") << "Could not parse " << config << " to boolean."; + } + } + return false; +} + +bool JsonConfigParser::_parse(const ofJson &config, const string &name, std::string& val){ + + if (config.find(name) != config.end()) { + ofJson content = config[name]; + if(content.is_string()){ + val = content; + return true; + }else { + ofLogError("JsonConfigParser::parse") << "Could not parse " << config << " to string."; + } + } + return false; +} + +//source: https://gist.github.com/olmokramer/82ccce673f86db7cda5e +//complete check: (#(?:[\\da-f]{3}){1,2}|rgb\\((?:\d{1,3},\\s*){2}\\d{1,3}\\)|rgba\\((?:\\d{1,3},\\s*){3}\\d*\\.?\\d+\\)|hsl\\(\\d{1,3}(?:,\\s*\\d{1,3}%){2}\\)|hsla\\(\\d{1,3}(?:,\\s*\\d{1,3}%){2},\\s*\\d*\\.?\\d+\\)) +bool JsonConfigParser::_parse(const ofJson &config, const string &name, ofColor& val){ + + if (config.find(name) != config.end()) { + + ofJson content = config[name]; + + if(content.is_string()){ + std::string s_value = content; + + if(s_value == "transparent"){ + val.set(ofColor(0,0)); + return true; + } + + //look for colors in hex format + + std::string hexval = s_value; + std::transform(hexval.begin(), hexval.end(), hexval.begin(), ::tolower); + vector matches = JsonConfigParser::getMatchedStrings(hexval, "#(?:[\\da-f]{3}){1,2}"); + if(matches.size() > 0){ + int x; + ofStringReplace(matches[0],"#",""); + std::stringstream ss; + ss << std::hex << matches[0]; + ss >> x; + val.set(ofColor::fromHex(x,255)); + return true; + + } + + //look for colors in rgba format + matches.clear(); + matches = JsonConfigParser::getMatchedStrings(s_value, "rgba\\((?:\\d{1,3},\\s*){3}\\d*\\.?\\d+\\)"); + if(matches.size() > 0){ + vector vals = ofSplitString(ofSplitString(ofSplitString(s_value, "rgba(")[1],")")[0],","); + ofColor res(ofToFloat(vals[0]), ofToFloat(vals[1]), ofToFloat(vals[2]), ofToFloat(vals[3])*255); + val.set(res); + return true; + } + + //loook for colors in rgb format + matches.clear(); + matches = JsonConfigParser::getMatchedStrings(s_value, "rgb\\((?:\\d{1,3},\\s*){2}\\d{1,3}\\)"); + if(matches.size() > 0){ + vector vals = ofSplitString(ofSplitString(ofSplitString(s_value, "rgb(")[1],")")[0],","); + ofColor res(ofToFloat(vals[0]), ofToFloat(vals[1]), ofToFloat(vals[2])); + val.set(res); + return true; + } + }/*else { + // look for ofColor format + if(ofColor* color = dynamic_cast(&content)){ + val.set(color); + return true; + } + }*/ + + + } + return false; + +} + +bool JsonConfigParser::_parse(const ofJson &config, const string &name, ofPoint& val){ + + if (config.find("left") != config.end()) { + ofJson left = config["left"]; + if(left.is_number()){ + val.x = left; + } + } + if (config.find("top") != config.end()) { + ofJson top = config["top"]; + if(top.is_number()){ + val.y = top; + } + } + + return true; +} + + +bool JsonConfigParser::_parse(const ofJson &config, const string &name, ofRectangle& val){ + + if (config.find("left") != config.end()) { + ofJson left = config["left"]; + if(left.is_number()){ + val.x = left; + } + } + if (config.find("top") != config.end()) { + ofJson top = config["top"]; + if(top.is_number()){ + val.y = top; + } + } + if (config.find("width") != config.end()) { + ofJson width = config["width"]; + if(width.is_number()){ + val.width = width; + } + } + if (config.find("height") != config.end()) { + ofJson height = config["height"]; + if(height.is_number()){ + val.height = height; + } + } + return true; + +} + +bool JsonConfigParser::_parse(const ofJson &config, const string &name, DOM::LayoutFloat& val){ + + if (config.find(name) != config.end()) { + ofJson content = config[name]; + if(content == "none"){ + val = DOM::LayoutFloat::NONE; + return true; + } + if(content == "left"){ + val = DOM::LayoutFloat::LEFT; + return true; + } + if(content == "right"){ + val = DOM::LayoutFloat::RIGHT; + return true; + } + } + return false; +} + +bool JsonConfigParser::_parse(const ofJson &config, const string &name, DOM::LayoutPosition& val){ + + if (config.find(name) != config.end()) { + ofJson content = config[name]; + if(content == "static"){ + val = DOM::LayoutPosition::POSITION_STATIC; + return true; + } + if(content == "absolute"){ + val = DOM::LayoutPosition::POSITION_ABSOLUTE; + return true; + } + } + return false; +} + +bool JsonConfigParser::parse(const ofJson &config, DOM::Element* val){ + + if(!config.is_null()){ + if (config.find("left") != config.end()) { + ofJson left = config["left"]; + if(left.is_number()){ + val->setPosition(left, val->getPosition().y); + } + } + if (config.find("top") != config.end()) { + ofJson top = config["top"]; + if(top.is_number()){ + val->setPosition(val->getPosition().x, top); + } + } + } + return true; + +} + + +vector JsonConfigParser::getMatchedStrings(string contents, string regex){ + + vector results; + std::regex regEx(regex); + std::smatch match; + + if(std::regex_search(contents, match, regEx)) { + for (size_t i = 0; i < match.size(); ++i){ + results.push_back(match[i]); + } + } + + return results; +} diff --git a/addons/ofxGui/src/JsonConfigParser.h b/addons/ofxGui/src/JsonConfigParser.h new file mode 100644 index 0000000..4b11e29 --- /dev/null +++ b/addons/ofxGui/src/JsonConfigParser.h @@ -0,0 +1,86 @@ +#pragma once + +#include "ofMain.h" +#include "Types.h" +#include "Element.h" + +class JsonConfigParser { + public: + + template + static bool parse(const ofJson &config, ofParameter& attribute){ + AttributeType res = attribute.get(); + parse(config, attribute.getName(), res); + if(attribute.get() == res){ + //no changes + return false; + }else{ + //changes + attribute.set(res); + return true; + + } + + } + + template + static bool parse(const ofJson &config, const string& name, AttributeType& attribute){ + if(!config.is_null()){ + return _parse(config, name, attribute); + } + return false; + } + + static bool parse(const ofJson &config, DOM::Element* val); + + ///\brief regex helper function copied from https://github.com/openframeworks/openFrameworks/issues/1110 + static vector getMatchedStrings(std::string contents, string regex); + + protected: + + + /// \todo this method is not called for arithmetic values (don't know why) + /// that's why I copied the content to the default _parse function at the bottom. + /// works but should be changed someday. + template + static bool _parse(const ofJson &config, const string& name, + typename std::enable_if::value, AttributeType>::type& val){ + + if (config.find(name) != config.end()) { + ofJson content = config[name]; + if(content.is_number()){ + val = content; + return true; + }else { + ofLogError("JsonConfigParser::parse") << "Could not parse " << config << " to arithmetic value."; + } + } + return false; + } + static bool _parse(const ofJson &config, const string& name, bool& val); + static bool _parse(const ofJson &config, const string& name, std::string& val); + static bool _parse(const ofJson &config, const string& name, ofColor& val); + static bool _parse(const ofJson &config, const string& name, ofPoint& val); + static bool _parse(const ofJson &config, const string& name, ofRectangle& val); + static bool _parse(const ofJson &config, const string& name, DOM::LayoutFloat& val); + static bool _parse(const ofJson &config, const string& name, DOM::LayoutPosition& val); + + ///\brief Default parse method for non implemented attribute types + template + static bool _parse(const ofJson &config, const string& name, AttributeType& attribute){ + + if (config.find(name) != config.end()) { + ofJson content = config[name]; + if(content.is_number()){ + attribute = content; + return true; + }else { + ofLogError("JsonConfigParser::parse") << "Could not parse " << config << " to arithmetic value."; + } + } + + // TODO throw error when no parsing method found? + return false; + } + +}; diff --git a/addons/ofxGui/src/Layout.cpp b/addons/ofxGui/src/Layout.cpp new file mode 100644 index 0000000..88920bc --- /dev/null +++ b/addons/ofxGui/src/Layout.cpp @@ -0,0 +1,69 @@ +// ============================================================================= +// +// Copyright (c) 2009-2016 Christopher Baker +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. +// +// ============================================================================= + + +#include "Layout.h" +#include "Element.h" +#include + + +namespace DOM { + + +Layout::Layout(Element* parent): _parent(parent) +{ +} + + +Layout::~Layout() +{ +} + + +Element* Layout::parent() +{ + return _parent; +} + + +bool Layout::isDoingLayout() const +{ + return _isDoingLayout; +} + + +std::vector Layout::children() +{ + if (_parent) + { + return _parent->children(); + } + else + { + std::vector _children; + return _children; + } +} + +} // namespace DOM diff --git a/addons/ofxGui/src/Layout.h b/addons/ofxGui/src/Layout.h new file mode 100644 index 0000000..297e90e --- /dev/null +++ b/addons/ofxGui/src/Layout.h @@ -0,0 +1,93 @@ +// ============================================================================= +// +// Copyright (c) 2009-2016 Christopher Baker +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. +// +// ============================================================================= + + +#pragma once + + +#include +#include "Types.h" +#include "Element.h" + + +namespace DOM { + + +/// \brief A base class for laying out Elements. +/// +/// Generally this class and its subclasses should not be instantiated directly +/// but instead should be created using Element::createLayout(...). +/// This pattern preserves the ownership of the Layout. +class Layout +{ +public: + /// \brief Create a Layout with a given Element parent. + /// \param parent The parent Element. + Layout(Element* parent); + + /// \brief Destroy the layout. + virtual ~Layout(); + + /// \returns a pointer to the parent Element or nullptr if none. + Element* parent(); + + /// \returns true iff this layout is currently being done. + bool isDoingLayout() const; + + /// \brief Get all of the children for this element. + std::vector children(); + + /// \brief Do layout. + virtual void doLayout() = 0; + + virtual void copyTo(Element* parent) const = 0 ; + +protected: + /// \brief The owning Widget class. + Element* _parent = nullptr; + + /// \brief True if in doLayout(). Used to prevent recusive calls. + bool _isDoingLayout = false; + + friend class Element; + +}; + + +template +class _Layout : public Layout { + + public: + + _Layout(Element* parent):Layout(parent){} + ~_Layout(){} + + virtual void copyTo(Element* parent) const { + parent->createLayout(parent); + } + +}; + + +} // namespace DOM diff --git a/addons/ofxGui/src/Types.h b/addons/ofxGui/src/Types.h new file mode 100644 index 0000000..bd10e65 --- /dev/null +++ b/addons/ofxGui/src/Types.h @@ -0,0 +1,215 @@ +// ============================================================================= +// +// Copyright (c) 2009-2016 Christopher Baker +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. +// +// ============================================================================= + + +#pragma once + + +#include +#include +#include +#include +#include +#include "ofPoint.h" +#include "ofRectangle.h" +#include "ofTypes.h" + + +namespace DOM { + + +class Element; + + +typedef ofPoint Position; +typedef ofPoint Size; +typedef ofRectangle Shape; + +/// \brief The orientation of a Widget. +/// \todo Replace this with ofOrientation. + +// OF_ORIENTATION_DEFAULT = 1, +// OF_ORIENTATION_180 = 2, +// OF_ORIENTATION_90_LEFT = 3, +// OF_ORIENTATION_90_RIGHT = 4, +// OF_ORIENTATION_UNKNOWN = 5 + +enum class Orientation +{ + /// \brief Locks the Orientation to landscape. + HORIZONTAL, + /// \brief Locks the Orientation to portrait. + VERTICAL, + /// \brief Sets the Orientation based on the aspect ratio. + DEFAULT +}; + +/// \brief The float of a gui element in a layout. +enum class LayoutFloat { + /// \brief Left float. + LEFT, + /// \brief Right float. + RIGHT, + /// \brief No float. + NONE +}; + +/// \brief The position type of a gui element in a layout. +enum class LayoutPosition { + /// \brief Element is positioned by the floating attribute depending of the positions of its siblings. + POSITION_STATIC, + /// \brief Element is positioned by its position independent of siblings. + POSITION_ABSOLUTE +}; + +template +using StorageType = typename std::decay::type; + +/// \brief C++11 Any class. +/// \sa https://codereview.stackexchange.com/questions/20058/c11-any-class +/// \note This class may change in the near future. +struct Any +{ + bool is_null() const { return !ptr; } + bool not_null() const { return ptr; } + + template Any(U&& value) + : ptr(new Derived>(std::forward(value))) + { + } + + template bool is() const + { + typedef StorageType T; + + auto derived = dynamic_cast*> (ptr); + + return derived; + } + + template + StorageType& as() + { + typedef StorageType T; + + auto derived = dynamic_cast*> (ptr); + + if (!derived) + throw std::bad_cast(); + + return derived->value; + } + + template + operator U() + { + return as>(); + } + + Any(): ptr(nullptr) + { + } + + Any(Any& that): ptr(that.clone()) + { + + } + + Any(Any&& that): ptr(that.ptr) + { + that.ptr = nullptr; + } + + Any(const Any& that): ptr(that.clone()) + { + } + + + Any(const Any&& that): ptr(that.clone()) + { + } + + + Any& operator=(const Any& a) + { + if (ptr == a.ptr) + return *this; + + auto old_ptr = ptr; + + ptr = a.clone(); + + if (old_ptr) + delete old_ptr; + + return *this; + } + + Any& operator=(Any&& a) + { + if (ptr == a.ptr) + return *this; + + std::swap(ptr, a.ptr); + + return *this; + } + + ~Any() + { + if (ptr) + delete ptr; + } + +private: + struct Base + { + virtual ~Base() {} + + virtual Base* clone() const = 0; + }; + + template + struct Derived: Base + { + template Derived(U&& value) : value(std::forward(value)) { } + + T value; + + Base* clone() const { return new Derived(value); } + }; + + Base* clone() const + { + if (ptr) + return ptr->clone(); + else + return nullptr; + } + + Base* ptr; +}; + + +} // namespace DOM diff --git a/addons/ofxGui/src/ofxBaseGui.cpp b/addons/ofxGui/src/ofxBaseGui.cpp deleted file mode 100644 index b8ddbd8..0000000 --- a/addons/ofxGui/src/ofxBaseGui.cpp +++ /dev/null @@ -1,396 +0,0 @@ -#include "ofxBaseGui.h" -#include "ofImage.h" -#include "ofBitmapFont.h" -#ifndef TARGET_EMSCRIPTEN -#include "ofXml.h" -#endif -using namespace std; - - -void ofxGuiSetFont(const string & fontPath, int fontsize, bool _bAntiAliased, bool _bFullCharacterSet, int dpi){ - ofxBaseGui::loadFont(fontPath, fontsize, _bAntiAliased, _bFullCharacterSet, dpi); -} - -void ofxGuiSetBitmapFont(){ - ofxBaseGui::setUseTTF(false); -} - -void ofxGuiSetHeaderColor(const ofColor & color){ - ofxBaseGui::setDefaultHeaderBackgroundColor(color); -} - -void ofxGuiSetBackgroundColor(const ofColor & color){ - ofxBaseGui::setDefaultBackgroundColor(color); -} - -void ofxGuiSetBorderColor(const ofColor & color){ - ofxBaseGui::setDefaultBorderColor(color); -} - -void ofxGuiSetTextColor(const ofColor & color){ - ofxBaseGui::setDefaultTextColor(color); -} - -void ofxGuiSetFillColor(const ofColor & color){ - ofxBaseGui::setDefaultFillColor(color); -} - -void ofxGuiSetTextPadding(int padding){ - ofxBaseGui::setDefaultTextPadding(padding); -} - -void ofxGuiSetDefaultWidth(int width){ - ofxBaseGui::setDefaultWidth(width); - -} - -void ofxGuiSetDefaultHeight(int height){ - ofxBaseGui::setDefaultHeight(height); -} - -ofColor -ofxBaseGui::headerBackgroundColor(64), -ofxBaseGui::backgroundColor(0), -ofxBaseGui::borderColor(120, 100), -ofxBaseGui::textColor(255), -ofxBaseGui::fillColor(128); - -int ofxBaseGui::textPadding = 4; -int ofxBaseGui::defaultWidth = 200; -int ofxBaseGui::defaultHeight = 18; - -ofTrueTypeFont ofxBaseGui::font; -bool ofxBaseGui::fontLoaded = false; -bool ofxBaseGui::useTTF = false; -ofBitmapFont ofxBaseGui::bitmapFont; - -ofxBaseGui::ofxBaseGui(){ - parent = nullptr; - currentFrame = ofGetFrameNum(); -#ifndef TARGET_EMSCRIPTEN - serializer = std::make_shared(); -#endif - - thisHeaderBackgroundColor = headerBackgroundColor; - thisBackgroundColor = backgroundColor; - thisBorderColor = borderColor; - thisTextColor = textColor; - thisFillColor = fillColor; - - bRegisteredForMouseEvents = false; - needsRedraw = true; - - /*if(!fontLoaded){ - loadFont(OF_TTF_MONO,10,true,true); - useTTF=false; - }*/ - -} - -void ofxBaseGui::loadFont(const std::string& filename, int fontsize, bool _bAntiAliased, bool _bFullCharacterSet, int dpi){ - font.load(filename, fontsize, _bAntiAliased, _bFullCharacterSet, false, 0, dpi); - fontLoaded = true; - useTTF = true; -} - -void ofxBaseGui::setUseTTF(bool bUseTTF){ - if(bUseTTF && !fontLoaded){ - loadFont(OF_TTF_MONO, 10, true, true); - } - useTTF = bUseTTF; -} - -ofxBaseGui::~ofxBaseGui(){ - unregisterMouseEvents(); -} - -void ofxBaseGui::registerMouseEvents(){ - if(bRegisteredForMouseEvents == true){ - return; // already registered. - } - bRegisteredForMouseEvents = true; - ofRegisterMouseEvents(this, OF_EVENT_ORDER_BEFORE_APP); -} - -void ofxBaseGui::unregisterMouseEvents(){ - if(bRegisteredForMouseEvents == false){ - return; // not registered. - } - ofUnregisterMouseEvents(this, OF_EVENT_ORDER_BEFORE_APP); - bRegisteredForMouseEvents = false; -} - -void ofxBaseGui::draw(){ - if(needsRedraw){ - generateDraw(); - needsRedraw = false; - } - currentFrame = ofGetFrameNum(); - render(); -} - -bool ofxBaseGui::isGuiDrawing(){ - if(ofGetFrameNum() - currentFrame > 1){ - return false; - }else{ - return true; - } -} - -void ofxBaseGui::bindFontTexture(){ - if(useTTF){ - font.getFontTexture().bind(); - }else{ - bitmapFont.getTexture().bind(); - } -} - -void ofxBaseGui::unbindFontTexture(){ - if(useTTF){ - font.getFontTexture().unbind(); - }else{ - bitmapFont.getTexture().unbind(); - } -} - - -ofMesh ofxBaseGui::getTextMesh(const string & text, float x, float y){ - if(useTTF){ - return font.getStringMesh(text, x, y); - }else{ - return bitmapFont.getMesh(text, x, y); - } -} - -ofRectangle ofxBaseGui::getTextBoundingBox(const string & text, float x, float y){ - if(useTTF){ - return font.getStringBoundingBox(text, x, y); - }else{ - return bitmapFont.getBoundingBox(text, x, y); - } -} - -void ofxBaseGui::saveToFile(const std::string& filename){ - if(serializer){ - serializer->load(filename); - saveTo(*serializer); - serializer->save(filename); - }else{ - ofLogError("ofxGui") << "element has no serializer to save to"; - } -} - -void ofxBaseGui::loadFromFile(const std::string& filename){ - if(serializer){ - serializer->load(filename); - loadFrom(*serializer); - }else{ - ofLogError("ofxGui") << "element has no serializer to load from"; - } -} - - -void ofxBaseGui::saveTo(ofBaseSerializer & serializer){ - serializer.serialize(getParameter()); -} - -void ofxBaseGui::loadFrom(ofBaseSerializer & serializer){ - serializer.deserialize(getParameter()); -} - - -void ofxBaseGui::setDefaultSerializer(std::shared_ptr _serializer){ - serializer = _serializer; -} - -string ofxBaseGui::getName(){ - return getParameter().getName(); -} - -void ofxBaseGui::setName(const std::string& _name){ - getParameter().setName(_name); -} - -void ofxBaseGui::setPosition(const ofPoint & p){ - setPosition(p.x, p.y); -} - -void ofxBaseGui::setPosition(float x, float y){ - b.x = x; - b.y = y; - setNeedsRedraw(); -} - -void ofxBaseGui::setSize(float w, float h){ - b.width = w; - b.height = h; - sizeChangedCB(); -} - -void ofxBaseGui::setShape(ofRectangle r){ - b = r; - sizeChangedCB(); -} - -void ofxBaseGui::setShape(float x, float y, float w, float h){ - b.set(x, y, w, h); - sizeChangedCB(); -} - -ofPoint ofxBaseGui::getPosition() const { - return ofPoint(b.x, b.y); -} - -ofRectangle ofxBaseGui::getShape() const { - return b; -} - -float ofxBaseGui::getWidth() const { - return b.width; -} - -float ofxBaseGui::getHeight() const { - return b.height; -} - -ofColor ofxBaseGui::getHeaderBackgroundColor() const { - return thisHeaderBackgroundColor; -} - -ofColor ofxBaseGui::getBackgroundColor() const { - return thisBackgroundColor; -} - -ofColor ofxBaseGui::getBorderColor() const { - return thisBorderColor; -} - -ofColor ofxBaseGui::getTextColor() const { - return thisTextColor; -} - -ofColor ofxBaseGui::getFillColor() const { - return thisFillColor; -} - -void ofxBaseGui::setHeaderBackgroundColor(const ofColor & color){ - setNeedsRedraw(); - thisHeaderBackgroundColor = color; -} - -void ofxBaseGui::setBackgroundColor(const ofColor & color){ - setNeedsRedraw(); - thisBackgroundColor = color; -} - -void ofxBaseGui::setBorderColor(const ofColor & color){ - setNeedsRedraw(); - thisBorderColor = color; -} - -void ofxBaseGui::setTextColor(const ofColor & color){ - setNeedsRedraw(); - thisTextColor = color; -} - -void ofxBaseGui::setFillColor(const ofColor & color){ - setNeedsRedraw(); - thisFillColor = color; -} - -void ofxBaseGui::setDefaultHeaderBackgroundColor(const ofColor & color){ - headerBackgroundColor = color; -} - -void ofxBaseGui::setDefaultBackgroundColor(const ofColor & color){ - backgroundColor = color; -} - -void ofxBaseGui::setDefaultBorderColor(const ofColor & color){ - borderColor = color; -} - -void ofxBaseGui::setDefaultTextColor(const ofColor & color){ - textColor = color; -} - -void ofxBaseGui::setDefaultFillColor(const ofColor & color){ - fillColor = color; -} - -void ofxBaseGui::setDefaultTextPadding(int padding){ - textPadding = padding; -} - -void ofxBaseGui::setDefaultWidth(int width){ - defaultWidth = width; -} - -void ofxBaseGui::setDefaultHeight(int height){ - defaultHeight = height; -} - -void ofxBaseGui::sizeChangedCB(){ - if(parent){ - parent->sizeChangedCB(); - } - setNeedsRedraw(); -} - -void ofxBaseGui::setNeedsRedraw(){ - needsRedraw = true; -} - -string ofxBaseGui::saveStencilToHex(const ofImage & img){ - stringstream strm; - int width = img.getWidth(); - int height = img.getHeight(); - int n = width * height; - unsigned char cur = 0; - int shift = 0; - strm << "{"; - for(int i = 0; i < n;){ - if(img.getPixels()[i * 4 + 3] > 0){ - cur |= 1 << shift; - } - i++; - if(i % 8 == 0){ - strm << "0x" << hex << (unsigned int)cur; - cur = 0; - shift = 0; - if(i < n){ - strm << ","; - } - }else{ - shift++; - } - } - strm << "}"; - return strm.str(); -} - -void ofxBaseGui::loadStencilFromHex(ofImage & img, unsigned char * data){ - int width = img.getWidth(); - int height = img.getHeight(); - int i = 0; - ofColor on(255, 255); - ofColor off(255, 0); - for(int y = 0; y < height; y++){ - for(int x = 0; x < width; x++){ - int shift = i % 8; - int offset = i / 8; - bool cur = (data[offset] >> shift) & 1; - img.setColor(x, y, cur ? on : off); - i++; - } - } - img.update(); -} - -void ofxBaseGui::setParent(ofxBaseGui * parent){ - this->parent = parent; -} - -ofxBaseGui * ofxBaseGui::getParent(){ - return parent; -} diff --git a/addons/ofxGui/src/ofxBaseGui.h b/addons/ofxGui/src/ofxBaseGui.h deleted file mode 100644 index e8282f0..0000000 --- a/addons/ofxGui/src/ofxBaseGui.h +++ /dev/null @@ -1,125 +0,0 @@ -#pragma once - -#include "ofConstants.h" -#include "ofBaseTypes.h" -#include "ofParameter.h" -#include "ofTrueTypeFont.h" -#include "ofBitmapFont.h" - -class ofxBaseGui { - public: - ofxBaseGui(); - - virtual ~ofxBaseGui(); - void draw(); - - void saveToFile(const std::string& filename); - void loadFromFile(const std::string& filename); - - void setDefaultSerializer(std::shared_ptr serializer); - - virtual void saveTo(ofBaseSerializer & serializer); - virtual void loadFrom(ofBaseSerializer & serializer); - - std::string getName(); - void setName(const std::string& name); - - virtual void setPosition(const ofPoint & p); - virtual void setPosition(float x, float y); - virtual void setSize(float w, float h); - virtual void setShape(ofRectangle r); - virtual void setShape(float x, float y, float w, float h); - - ofPoint getPosition() const; - ofRectangle getShape() const; - float getWidth() const; - float getHeight() const; - - ofColor getHeaderBackgroundColor() const; - ofColor getBackgroundColor() const; - ofColor getBorderColor() const; - ofColor getTextColor() const; - ofColor getFillColor() const; - - void setHeaderBackgroundColor(const ofColor & color); - void setBackgroundColor(const ofColor & color); - void setBorderColor(const ofColor & color); - void setTextColor(const ofColor & color); - void setFillColor(const ofColor & color); - - static void setDefaultHeaderBackgroundColor(const ofColor & color); - static void setDefaultBackgroundColor(const ofColor & color); - static void setDefaultBorderColor(const ofColor & color); - static void setDefaultTextColor(const ofColor & color); - static void setDefaultFillColor(const ofColor & color); - - static void setDefaultTextPadding(int padding); - static void setDefaultWidth(int width); - static void setDefaultHeight(int height); - - virtual ofAbstractParameter & getParameter() = 0; - static void loadFont(const std::string& filename, int fontsize, bool _bAntiAliased = true, bool _bFullCharacterSet = false, int dpi = 0); - static void setUseTTF(bool bUseTTF); - - void registerMouseEvents(); - void unregisterMouseEvents(); - - virtual void sizeChangedCB(); - void setParent(ofxBaseGui * parent); - ofxBaseGui * getParent(); - - virtual bool mouseMoved(ofMouseEventArgs & args) = 0; - virtual bool mousePressed(ofMouseEventArgs & args) = 0; - virtual bool mouseDragged(ofMouseEventArgs & args) = 0; - virtual bool mouseReleased(ofMouseEventArgs & args) = 0; - virtual bool mouseScrolled(ofMouseEventArgs & args) = 0; - virtual void mouseEntered(ofMouseEventArgs & args){ - } - virtual void mouseExited(ofMouseEventArgs & args){ - } - - protected: - virtual void render() = 0; - bool isGuiDrawing(); - virtual bool setValue(float mx, float my, bool bCheckBounds) = 0; - void bindFontTexture(); - void unbindFontTexture(); - ofMesh getTextMesh(const std::string & text, float x, float y); - ofRectangle getTextBoundingBox(const std::string & text, float x, float y); - - ofxBaseGui * parent; - - ofRectangle b; - static ofTrueTypeFont font; - static bool fontLoaded; - static bool useTTF; - static ofBitmapFont bitmapFont; - std::shared_ptr serializer; - - static ofColor headerBackgroundColor; - static ofColor backgroundColor; - static ofColor borderColor; - static ofColor textColor; - static ofColor fillColor; - - ofColor thisHeaderBackgroundColor; - ofColor thisBackgroundColor; - ofColor thisBorderColor; - ofColor thisTextColor; - ofColor thisFillColor; - - static int textPadding; - static int defaultWidth; - static int defaultHeight; - - static std::string saveStencilToHex(const ofImage & img); - static void loadStencilFromHex(ofImage & img, unsigned char * data); - - void setNeedsRedraw(); - virtual void generateDraw() = 0; - - private: - bool needsRedraw; - unsigned long currentFrame; - bool bRegisteredForMouseEvents; -}; diff --git a/addons/ofxGui/src/ofxButton.cpp b/addons/ofxGui/src/ofxButton.cpp deleted file mode 100644 index 1a7ce4d..0000000 --- a/addons/ofxGui/src/ofxButton.cpp +++ /dev/null @@ -1,55 +0,0 @@ -#include "ofxButton.h" -using namespace std; - -ofxButton::ofxButton(){ - value.setSerializable(false); -} - -ofxButton::~ofxButton(){ - // -} - -ofxButton* ofxButton::setup(const std::string& toggleName, float width, float height){ - setName(toggleName); - b.x = 0; - b.y = 0; - b.width = width; - b.height = height; - bGuiActive = false; - value = false; - checkboxRect.set(1, 1, b.height - 2, b.height - 2); - - registerMouseEvents(); - - value.addListener(this,&ofxButton::valueChanged); - - return this; -} - -bool ofxButton::mouseReleased(ofMouseEventArgs & args){ - bool attended = setValue(args.x, args.y, false); - bGuiActive = false; - if(attended){ - return true; - }else{ - return false; - } -} - -bool ofxButton::mouseMoved(ofMouseEventArgs & args){ - return ofxToggle::mouseMoved(args); -} - -bool ofxButton::mousePressed(ofMouseEventArgs & args){ - return ofxToggle::mousePressed(args); -} - -bool ofxButton::mouseDragged(ofMouseEventArgs & args){ - return ofxToggle::mouseDragged(args); -} - -void ofxButton::valueChanged(bool & v){ - if(!v){ - ofNotifyEvent(triggerEvent, this); - } -} diff --git a/addons/ofxGui/src/ofxButton.h b/addons/ofxGui/src/ofxButton.h deleted file mode 100644 index 7158e3c..0000000 --- a/addons/ofxGui/src/ofxButton.h +++ /dev/null @@ -1,33 +0,0 @@ -#pragma once - -#include "ofxToggle.h" -#include "ofParameter.h" - -class ofxButton : public ofxToggle{ - friend class ofPanel; - -public: - ofxButton(); - ~ofxButton(); - ofxButton* setup(const std::string& toggleName, float width = defaultWidth, float height = defaultHeight); - - virtual bool mouseReleased(ofMouseEventArgs & args); - virtual bool mouseMoved(ofMouseEventArgs & args); - virtual bool mousePressed(ofMouseEventArgs & args); - virtual bool mouseDragged(ofMouseEventArgs & args); - - template - void addListener(ListenerClass * listener, ListenerMethod method){ - ofAddListener(triggerEvent,listener,method); - } - - template - void removeListener(ListenerClass * listener, ListenerMethod method){ - ofRemoveListener(triggerEvent,listener,method); - } - -private: - ofEvent triggerEvent; - void valueChanged(bool & v); - -}; diff --git a/addons/ofxGui/src/ofxColorPicker.cpp b/addons/ofxGui/src/ofxColorPicker.cpp deleted file mode 100644 index 5bd2622..0000000 --- a/addons/ofxGui/src/ofxColorPicker.cpp +++ /dev/null @@ -1,492 +0,0 @@ -// -// ofxColorPicker.cpp -// ofxColorPicker -// -// Based on ofxColorPicker by Lukasz Karluk on 13/08/2015. -// -// - -#include "ofxColorPicker.h" -#include "ofGraphics.h" - - -namespace { -constexpr int COLOR_WHEEL_RES = 200; - -struct PolCord { - float angle; - float radius; -}; - -PolCord getPolarCoordinate(const glm::vec2 & p, float radius){ - - float px = p.x - radius; // point x from center. - float py = p.y - radius; // point x from center. - float pl = sqrt(px * px + py * py); // point length from center. - float pa = atan2(px, py); // point angle around center. - - pa *= RAD_TO_DEG; - pa -= 90; - pl /= radius; - - PolCord pc; - pc.angle = pa; - pc.radius = pl; - - return pc; -} - -glm::vec2 getPoint(float a, float r){ - glm::vec2 p; - p.x = r * cos(-a * DEG_TO_RAD); - p.y = r * sin(-a * DEG_TO_RAD); - - return p; -} - -float saturate(float v){ - return std::min(1.f, std::max(0.f, v)); -} - -template -ofColor_ getCircularColor(float angle, float radius, float scale){ - radius = saturate(radius); - - angle = ofWrap(angle, 0, 360); - - float da; - - ofColor_ c; - - if(angle < 60) { - - da = angle / 60; - c.r = c.limit() * scale; - c.g = c.limit() * (da + (1 - da) * (1 - radius)) * scale; - c.b = c.limit() * (1 - radius) * scale; - c.a = c.limit(); - - } else if(angle < 120) { - - da = (120 - angle) / 60; - c.r = c.limit() * (da + (1 - da) * (1 - radius)) * scale; - c.g = c.limit() * scale; - c.b = c.limit() * (1 - radius) * scale; - c.a = c.limit(); - - } else if(angle < 180) { - - da = 1 - (180 - angle) / 60; - c.r = c.limit() * (1 - radius) * scale; - c.g = c.limit() * scale; - c.b = c.limit() * (da + (1 - da) * (1 - radius)) * scale; - c.a = c.limit(); - - } else if(angle < 240) { - - da = (240 - angle) / 60; - c.r = c.limit() * (1 - radius) * scale; - c.g = c.limit() * (da + (1 - da) * (1 - radius)) * scale; - c.b = c.limit() * scale; - c.a = c.limit(); - - } else if(angle < 300) { - - da = 1 - (300 - angle) / 60; - c.r = c.limit() * (da + (1 - da) * (1 - radius)) * scale; - c.g = c.limit() * (1 - radius) * scale; - c.b = c.limit() * scale; - c.a = c.limit(); - - } else if(angle <= 360) { - - da = (360 - angle) / 60; - c.r = c.limit() * scale; - c.g = c.limit() * (1 - radius) * scale; - c.b = c.limit() * (da + (1 - da) * (1 - radius)) * scale; - c.a = c.limit(); - } - - return c; -} - -ofMesh rectangle(const ofRectangle & r, const ofFloatColor & c){ - ofMesh mesh; - mesh.addVertex(r.position); - mesh.addVertex(glm::vec3(r.x + r.width, r.y, 0)); - mesh.addVertex(glm::vec3(r.x + r.width, r.y + r.height, 0)); - - mesh.addVertex(glm::vec3(r.x + r.width, r.y + r.height, 0)); - mesh.addVertex(glm::vec3(r.x, r.y + r.height, 0)); - mesh.addVertex(glm::vec3(r.x, r.y, 0)); - - mesh.addColor(c); - mesh.addColor(c); - mesh.addColor(c); - - mesh.addColor(c); - mesh.addColor(c); - mesh.addColor(c); - - return mesh; -} -} - -template -ofxColorPicker_::ofxColorPicker_() { - colorScale = 1.0; - colorRadius = 0; - colorAngle = 0; - - setShape(b); -} - -template -ofxColorPicker_::ofxColorPicker_(ofParameter> parameter, float w, float h){ - colorScale = 1.0; - colorRadius = 0; - colorAngle = 0; - - setup(parameter, w, h); -} - -template -ofxColorPicker_ * ofxColorPicker_::setup(ofParameter> parameter, float w, float h){ - this->color.makeReferenceTo(parameter); - auto colorChanged = [this](const ofColor_ & c){ - if(bSettingColor){ - return; - } - ofFloatColor cf = c; - float hue, saturation, brightness; - cf.getHsb(hue,saturation,brightness); - colorScale = brightness; - colorRadius = saturation; - colorAngle = 360.f * hue; - setNeedsRedraw(); - }; - listener = color.newListener(colorChanged); - setShape(b.x, b.y, w, h); - colorChanged(color.get());//needs this so the color wheel shows the correct color once setup. - return this; -} -template -void ofxColorPicker_::setShape(float x, float y, float w, float h) { - b.x = x; - b.y = y; - b.width = w; - b.height = h; - - setNeedsRedraw(); -} - -template -void ofxColorPicker_::setShape(ofRectangle r){ - setShape(r.x, r.y, r.width, r.height); -} - -template -ofMesh ofxColorPicker_::getBackground(){ - return rectangle(rectBackground, thisFillColor); -} - -template -ofMesh ofxColorPicker_::getColorPoint(){ - int x = rectColorWheel.x; - int y = rectColorWheel.y; - int w = rectColorWheel.width; - int h = rectColorWheel.height; - - colorPoint = getPoint(colorAngle, colorRadius * colorWheelRadius) + glm::vec2(colorWheelRadius); - colorPoint.x += x; - colorPoint.y += y; - - colorPoint.x = ofClamp( colorPoint.x, x, x + w ); - colorPoint.y = ofClamp( colorPoint.y, y, y + h ); - - ofPolyline circle; - circle.arc(glm::vec3(0), 1, 1, 0, 360, true, 20); - ofMesh meshColorPoint; - - auto center = glm::vec3(colorPoint, 0); - for(size_t i=0;i -ofMesh ofxColorPicker_::getColorWheel() { - ofPolyline circle; - circle.arc(glm::vec3(0), 1, 1, 0, 360, false, COLOR_WHEEL_RES); - - ofMesh meshColorWheel; - auto center = glm::vec3(rectColorWheel.x + colorWheelRadius, rectColorWheel.y + colorWheelRadius, 0); - for(size_t i=0;i(a * RAD_TO_DEG, 1.0, colorScale); - meshColorWheel.addColor(ofFloatColor::white); - meshColorWheel.addColor(c0); - meshColorWheel.addColor(c0); - } - - return meshColorWheel; -} - -template -ofMesh ofxColorPicker_::getColorScaleBar() { - int padding = 2; - int x = rectColorScaleBar.x; - int y = rectColorScaleBar.y; - int w = rectColorScaleBar.width; - int h = rectColorScaleBar.height; - - - ofMesh meshColorScaleBar; - - auto borderColor = ofColor(149, 255); - meshColorScaleBar.append(rectangle(rectColorScaleBar, borderColor)); - - - int rx, ry; - rx = x + 2; - ry = y + 2; - - w = rectColorScaleBar.width - padding * 2; - h = rectColorScaleBar.height - padding * 2; - rx = rectColorScaleBar.x + 2; - ry = rectColorScaleBar.y + 2; - ofRectangle colorBar(rx, ry, w, h); - meshColorScaleBar.append(rectangle(colorBar, ofFloatColor::white)); - ofFloatColor c0 = ofFloatColor::black; - ofFloatColor c1 = getCircularColor(colorAngle, colorRadius, 1.0); - - meshColorScaleBar.setColor(6, c1); - meshColorScaleBar.setColor(7, c1); - meshColorScaleBar.setColor(8, c0); - - meshColorScaleBar.setColor(9, c0); - meshColorScaleBar.setColor(10, c0); - meshColorScaleBar.setColor(11, c1); - - //-- - - int rw = w; - int rh = h - 4; - int bx, by; - int ch = 3; - int cy = (1. - colorScale) * (rh + ch); - - //-- grey rect for handle. bx and by are border values. - bx = 4; - by = 2; - ofRectangle handle(rx - bx, ry + cy - by, rw + bx * 2, ch + by * 2); - meshColorScaleBar.append(rectangle(handle, borderColor)); - - //-- white rect for handle. bx and by are border values. - bx = 3; - by = 1; - ofRectangle handleBorder(rx - bx, ry + cy - by, rw + bx * 2, ch + by * 2); - meshColorScaleBar.append(rectangle(handleBorder, ofFloatColor::white)); - - return meshColorScaleBar; -} - - -template -void ofxColorPicker_::setColorScale(float value) { - if(colorScale == value) { - return; - } - colorScale = value; - bSettingColor = true; - color = getCircularColor(colorAngle, colorRadius, colorScale); - bSettingColor = false; -} - -template -float ofxColorPicker_::getColorScale() { - return colorScale; -} - -template -void ofxColorPicker_::setColorRadius (float value) { - colorRadius = value; - bSettingColor = true; - color = getCircularColor(colorAngle, colorRadius, colorScale); - bSettingColor = false; -} - -template -float ofxColorPicker_::getColorRadius() { - return colorRadius; -} - -template -void ofxColorPicker_::setColorAngle(float value) { - colorAngle = value * 360; - bSettingColor = true; - color = getCircularColor(colorAngle, colorRadius, colorScale); - bSettingColor = false; -} - -template -float ofxColorPicker_::getColorAngle() { - return colorAngle / 360.0; -} - - -template -ofAbstractParameter & ofxColorPicker_::getParameter(){ - return color; -} - -template -bool ofxColorPicker_::mouseMoved(ofMouseEventArgs &){ - return false; -} - -template -bool ofxColorPicker_::mousePressed(ofMouseEventArgs & mouse){ - if(!isGuiDrawing()){ - return false; - } - - if(rectColorScaleBar.inside(mouse)){ - state = ChangingScale; - }else if(rectColorWheel.inside(mouse)){ - state = ChangingWheel; - } - - return mouseUpdate(mouse); -} - -template -bool ofxColorPicker_::mouseDragged(ofMouseEventArgs & mouse){ - if(!isGuiDrawing()){ - return false; - } - return mouseUpdate(mouse); -} - -template -bool ofxColorPicker_::mouseReleased(ofMouseEventArgs & mouse){ - if(!isGuiDrawing()){ - return false; - } - bool bReturn = mouseUpdate(mouse); - state = Waiting; - return bReturn; -} -template -bool ofxColorPicker_::mouseUpdate(ofMouseEventArgs& mouse){ - if(rectBackground.inside(mouse)){ - switch (state) { - case ChangingScale:{ - int relY = mouse.y - rectColorScaleBar.y; - float scale = 1.f - saturate(relY / rectColorScaleBar.height); - setColorScale(scale); - - setNeedsRedraw(); - break; - } - case ChangingWheel:{ - auto p = mouse - rectColorWheel.position.xy(); - auto pc = getPolarCoordinate(p, colorWheelRadius); - - colorAngle = pc.angle; - colorRadius = saturate(pc.radius); - - bSettingColor = true; - color = getCircularColor(colorAngle, colorRadius, colorScale); - bSettingColor = false; - setNeedsRedraw(); - break; - } - default: return true; - } - return true; - } - return false; -} - -template -bool ofxColorPicker_::mouseScrolled(ofMouseEventArgs & mouse){ - if(rectColorScaleBar.inside(mouse)){ - setColorScale(saturate(colorScale + mouse.scrollY * 0.001)); - setNeedsRedraw(); - return true; - }else{ - return false; - } -} - - -template -void ofxColorPicker_::render(){ - geometry.draw(); -} - -template -bool ofxColorPicker_::setValue(float mx, float my, bool bCheckBounds){ - return false; -} - -template -void ofxColorPicker_::generateDraw(){ - int minWH = std::min(b.width, b.height); - - colorWheelRadius = (int)std::min(b.width * 0.5f * 0.75f, b.height * 0.9f); - colorWheelPad = (int)(minWH * 0.05); - - rectBackground.x = (int)(b.x); - rectBackground.y = (int)(b.y); - rectBackground.width = (int)(b.width); - rectBackground.height = (int)(b.height); - - rectColorWheel.x = (int)(b.x + colorWheelPad); - rectColorWheel.y = (int)(b.y + (rectBackground.height - colorWheelRadius * 2.f) / 2.f); - rectColorWheel.width = (int)(colorWheelRadius * 2); - rectColorWheel.height = (int)(colorWheelRadius * 2); - - rectColorScaleBar.width = (int)(colorWheelRadius * 0.2); - rectColorScaleBar.height = rectColorWheel.height; - rectColorScaleBar.x = (int)(rectBackground.getMaxX() - rectColorScaleBar.width - colorWheelPad); - rectColorScaleBar.y = (int)(rectColorWheel.y); - - geometry.clear(); - geometry.append(getBackground()); - geometry.append(getColorWheel()); - geometry.append(getColorPoint()); - geometry.append(getColorScaleBar()); -} - - -template class ofxColorPicker_; -template class ofxColorPicker_; -template class ofxColorPicker_; diff --git a/addons/ofxGui/src/ofxColorPicker.h b/addons/ofxGui/src/ofxColorPicker.h deleted file mode 100644 index c83bcde..0000000 --- a/addons/ofxGui/src/ofxColorPicker.h +++ /dev/null @@ -1,82 +0,0 @@ -// -// ofxColorPicker.h -// ofxColorPicker -// -// Based on ofxColorPicker by Lukasz Karluk on 13/08/2015. -// -// - -#pragma once - -#include "ofColor.h" -#include "ofEvents.h" -#include "ofxBaseGui.h" -#include "ofxSlider.h" - - - -template -class ofxColorPicker_: public ofxBaseGui { - -public : - - ofxColorPicker_(); - ofxColorPicker_(ofParameter> parameter, float w = defaultWidth, float h = defaultWidth / 9. * 16.); - ofxColorPicker_ * setup(ofParameter> parameter, float w = defaultWidth, float h = defaultWidth / 9. * 16.); - - void setShape(float x, float y, float w, float h); - void setShape(ofRectangle r); - - void setColorScale(float value); - float getColorScale(); - - void setColorRadius(float value); - float getColorRadius(); - - void setColorAngle(float value); - float getColorAngle(); - - ofAbstractParameter & getParameter(); - -private : - void render(); - bool setValue(float mx, float my, bool bCheckBounds); - void generateDraw(); - - ofMesh getBackground(); - ofMesh getColorPoint(); - ofMesh getColorWheel(); - ofMesh getColorScaleBar(); - - bool mouseMoved(ofMouseEventArgs & args); - bool mousePressed(ofMouseEventArgs & args); - bool mouseDragged(ofMouseEventArgs & args); - bool mouseReleased(ofMouseEventArgs & args); - bool mouseScrolled(ofMouseEventArgs & args); - - bool mouseUpdate(ofMouseEventArgs& args); - - glm::vec2 colorPoint; - float colorScale; - float colorRadius; - float colorAngle; - bool bSettingColor = false; - - int colorWheelRadius; - int colorWheelPad; - - ofRectangle rectBackground; - ofRectangle rectColorWheel; - ofRectangle rectColorScaleBar; - - ofVboMesh geometry; - ofParameter> color; - - enum State{ - Waiting, - ChangingWheel, - ChangingScale, - }state = Waiting; - - ofEventListener listener; -}; diff --git a/addons/ofxGui/src/ofxDOM.h b/addons/ofxGui/src/ofxDOM.h new file mode 100644 index 0000000..aff6cf2 --- /dev/null +++ b/addons/ofxGui/src/ofxDOM.h @@ -0,0 +1,32 @@ +// ============================================================================= +// +// Copyright (c) 2009-2016 Christopher Baker +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. +// +// ============================================================================= + + +#pragma once + + +#include "Document.h" +#include "Element.h" +#include "Types.h" + diff --git a/addons/ofxGui/src/ofxDOMBoxLayout.cpp b/addons/ofxGui/src/ofxDOMBoxLayout.cpp new file mode 100644 index 0000000..ce0aedd --- /dev/null +++ b/addons/ofxGui/src/ofxDOMBoxLayout.cpp @@ -0,0 +1,185 @@ +// ============================================================================= +// +// Copyright (c) 2009-2016 Christopher Baker +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. +// +// ============================================================================= + + +#include "ofMain.h" +#include "ofxDOMBoxLayout.h" +#include "Element.h" +#include "ofxGuiElement.h" +#include +#include "ofxDOMLayoutHelper.h" + +typedef ofxDOMLayoutHelper DOMLH; + + +ofxDOMBoxLayout::ofxDOMBoxLayout(DOM::Element* parent): + DOM::_Layout(parent) +{ +} + + +ofxDOMBoxLayout::~ofxDOMBoxLayout() +{ +} + + +void ofxDOMBoxLayout::doLayout() +{ + if (_parent && !_isDoingLayout) + { + + // Prevent recursive calls to doLayout. + _isDoingLayout = true; + + bool horizontal = getDirection(_parent) == Direction::HORIZONTAL; + + +// if(ofxGuiElement* el = dynamic_cast(_parent)){ +// cout << el->getName() << endl; +// } + + float paddingHorizontal = DOMLH::getPaddingHorizontal(_parent); + float paddingVertical = DOMLH::getPaddingVertical(_parent); + + float marginHorizontal = DOMLH::getMarginHorizontal(_parent); + float marginVertical = DOMLH::getMarginVertical(_parent); + + float wParent = ofGetWidth(); + float hParent = ofGetHeight(); + if(_parent->parent()){ + wParent = _parent->getSizeByParent().x; + hParent = _parent->getSizeByParent().y; + } + + float totalWidth = DOMLH::getDesiredWidth(_parent, wParent) - paddingHorizontal; + float totalHeight = DOMLH::getDesiredHeight(_parent, hParent) - paddingVertical; + + float maxWidth = DOMLH::getMaxWidth(_parent, wParent) - paddingHorizontal; + float maxHeight = DOMLH::getMaxHeight(_parent, hParent) - paddingVertical; + + float currentX = DOMLH::getPaddingLeft(_parent); + float currentY = DOMLH::getPaddingTop(_parent); + + for (DOM::Element* element : children()){ + if (element){ + if(element->getVisible().get()){ + + // set to minimal size on main axis + if(horizontal){ + element->setSizeByParent(0, DOMLH::getMaxHeight(element, maxHeight) + DOMLH::getMarginVertical(element)); + }else{ + element->setSizeByParent(DOMLH::getMaxWidth(element, maxWidth) + DOMLH::getMarginHorizontal(element),0); + } + + + float w = DOMLH::getDesiredWidth(element, maxWidth); + float h = DOMLH::getDesiredHeight(element, maxHeight); + + if(!DOMLH::elementAbsolutePositioned(element)){ + + element->setPosition(currentX+DOMLH::getMarginLeft(element), currentY+DOMLH::getMarginTop(element)); + + element->setLayoutSize(w, h, true); + w = element->getWidth(); + h = element->getHeight(); + + if(horizontal){ + totalHeight = std::max(totalHeight, h+DOMLH::getMarginVertical(element)); + currentX += w + DOMLH::getMarginHorizontal(element); +// totalWidth = currentX; + } + else{ + totalWidth = std::max(totalWidth, w + DOMLH::getMarginHorizontal(element)); + currentY += h + DOMLH::getMarginVertical(element); +// totalHeight = currentY; + } + }else{ + element->setLayoutSize(w, h); + } + + } + } + } + + if(horizontal){ + totalWidth = max(currentX+DOMLH::getPaddingRight(_parent), DOMLH::getDesiredWidth(_parent, wParent)); + }else{ + totalHeight = max(currentY+DOMLH::getPaddingBottom(_parent), DOMLH::getDesiredHeight(_parent, hParent)); + } + + if(!DOMLH::elementAbsolutePositioned(_parent)){ + if(horizontal){ + totalHeight = max(totalHeight, maxHeight); + }else{ + totalWidth = max(totalWidth, maxWidth); + } + } + + // set cross axis size of all children to maximum + for (DOM::Element* element : children()) + { + if (element) + { + if(element->getVisible().get()){ + + if(!DOMLH::elementAbsolutePositioned(element)){ + + if (horizontal){ + float h = totalHeight-DOMLH::getMarginVertical(element); + element->setLayoutHeight(h, true); + }else{ + float w = totalWidth-DOMLH::getMarginHorizontal(element); + element->setLayoutWidth(w, true); + } + + } + } + } + } + + if(horizontal){ + totalHeight += paddingVertical; + }else{ + totalWidth += paddingHorizontal; + } + + _parent->setLayoutSize(totalWidth, totalHeight, false); + + _isDoingLayout = false; + } +} + +ofxDOMBoxLayout::Direction ofxDOMBoxLayout::getDirection(DOM::Element *e, Direction defaultVal){ + if(e->hasAttribute("_direction")){ + std::string val = e->getAttribute("_direction"); + if(val == "horizontal"){ + return Direction::HORIZONTAL; + } + if(val == "vertical"){ + return Direction::VERTICAL; + } + } + return defaultVal; +} + diff --git a/addons/ofxGui/src/ofxDOMBoxLayout.h b/addons/ofxGui/src/ofxDOMBoxLayout.h new file mode 100644 index 0000000..93bd587 --- /dev/null +++ b/addons/ofxGui/src/ofxDOMBoxLayout.h @@ -0,0 +1,55 @@ +// ============================================================================= +// +// Copyright (c) 2009-2016 Christopher Baker +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in +// all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +// THE SOFTWARE. +// +// ============================================================================= + + +#pragma once + +#include +#include "Types.h" +#include "Layout.h" + +class ofxDOMBoxLayout: public DOM::_Layout +{ +public: + + /// \brief Direction options + enum class Direction { + /// \brief Align items horizontally from left to right (default) + HORIZONTAL, + /// \brief Align items vertically from top to bottom + VERTICAL + }; + + ofxDOMBoxLayout(DOM::Element* parent); + + virtual ~ofxDOMBoxLayout(); + + virtual void doLayout() override; + +protected: + + static Direction getDirection(DOM::Element* e, Direction defaultVal = Direction::VERTICAL); + +}; + diff --git a/addons/ofxGui/src/ofxDOMFlexBoxLayout.cpp b/addons/ofxGui/src/ofxDOMFlexBoxLayout.cpp new file mode 100644 index 0000000..82e591f --- /dev/null +++ b/addons/ofxGui/src/ofxDOMFlexBoxLayout.cpp @@ -0,0 +1,563 @@ +#include "ofxDOMFlexBoxLayout.h" +#include "ofxDOMLayoutHelper.h" +#include "ofMain.h" +//#include "ofxGuiElement.h" + +typedef ofxDOMLayoutHelper DOMLH; + +bool isInteger(const std::string & s){ + if(s.empty() || ((!isdigit(s[0])) && (s[0] != '-') && (s[0] != '+'))) return false ; + + char * p ; + strtol(s.c_str(), &p, 10) ; + + return (*p == 0) ; +} + +bool isFloat( std::string myString ) { + std::istringstream iss(myString); + float f; + iss >> noskipws >> f; // noskipws considers leading whitespace invalid + // Check the entire string was consumed and if either failbit or badbit is set + return iss.eof() && !iss.fail(); +} + +ofxDOMFlexBoxLayout::ofxDOMFlexBoxLayout(DOM::Element* parent): + DOM::_Layout(parent){ +} + +ofxDOMFlexBoxLayout::~ofxDOMFlexBoxLayout(){ +} + +void ofxDOMFlexBoxLayout::doLayout(){ + + if(!_isDoingLayout){ + + if(_parent){ + + // Prevent recursive calls to doLayout. + _isDoingLayout = true; + + align(getFlexDirection(_parent)); + + _isDoingLayout = false; + + } + + } + +} + +void ofxDOMFlexBoxLayout::align(FlexDirection direction){ + + bool horizontal = direction == FlexDirection::ROW; + + float paddingHorizontal = DOMLH::getPaddingHorizontal(_parent); + float paddingVertical = DOMLH::getPaddingVertical(_parent); + + float wParent = ofGetWidth(); + float hParent = ofGetHeight(); + if(_parent->parent()){ + wParent = _parent->getSizeByParent().x; + hParent = _parent->getSizeByParent().y; + } + + float totalWidth = DOMLH::getDesiredWidthStretched(_parent, wParent) - paddingHorizontal; + float totalHeight = DOMLH::getDesiredHeightStretched(_parent, hParent) - paddingVertical; + +// if(ofxGuiElement* el = dynamic_cast(_parent)){ +// cout << el->getName() << " total size: " << totalWidth << " " << totalHeight << endl; +// } + + + vector lines; + + float mainAxisSize = horizontal ? totalWidth : totalHeight; + float crossAxisSize = horizontal ? totalHeight : totalWidth; + + int linecount = 0; + + if(children().size() > 0){ + //newline + lines.push_back(FlexBoxLine(mainAxisSize)); + } + + //sort children according to flex attribute and main size of children + + bool firstChild = true; + for(unsigned int i = 0; i < children().size(); i++){ + + DOM::Element* element = children().at(i); + + FlexBoxObject obj; + obj.origin = element; + obj.shape.width = DOMLH::getDesiredWidth(element, totalWidth); + obj.shape.height = DOMLH::getDesiredHeight(element, totalHeight); + + float elementMainSize = horizontal ? obj.shape.width : obj.shape.height; + + if(elementFlexing(element)){ + + //if element is flexible, add it to the current line and save the items flex basis + // TODO check if it fits in with minimal size + if(element->hasAttribute("_flex")){ + std::string flexvalstr = element->getAttribute("_flex"); + if(flexvalstr == "auto"){ + obj.flex = true; + obj.flexBasis = 1; + } + if(isFloat(ofTrim(flexvalstr))){ + float _flexval = ofToFloat(flexvalstr); + if(_flexval > 0){ + obj.flex = true; + obj.flexBasis = _flexval; + } + } + } + + if(!obj.flex){ + // not flexible or no valid flex attribute, not flexing on main axis + + element->setSizeByParent(obj.shape.width + DOMLH::getMarginHorizontal(element), obj.shape.height + DOMLH::getMarginVertical(element)); + element->setLayoutSize(obj.shape.width, obj.shape.height, true); + if(horizontal){ + elementMainSize = element->getWidth()+DOMLH::getMarginHorizontal(element); + obj.shape.width = elementMainSize; + }else { + elementMainSize = element->getHeight()+DOMLH::getMarginVertical(element); + obj.shape.height = elementMainSize; + } + } + + // add to new line if it does not fit and flex-wrap is on + if((int)lines.at(linecount).totalSpaceMainAxis - (int)elementMainSize < 0){ + FlexWrap _wrap = getFlexWrap(_parent); + if(_wrap == FlexWrap::NOWRAP || firstChild){ + //no new line + }else{ + //new line + linecount++; + lines.push_back(FlexBoxLine(mainAxisSize)); + } + } + + // add item to line vectors and save + lines.at(linecount).items.push_back(obj); + if(!obj.flex){ + // subtract main element size from main axis free space + lines.at(linecount).totalSpaceMainAxis -= elementMainSize; + } + + firstChild = false; + + + }else { + //set an absolute positioned element to its desired independent size + if(DOMLH::elementAbsolutePositioned(element)){ + + element->setLayoutSize(obj.shape.width, obj.shape.height); + + } + } + } + + //compute main size of flex items if they are flexible + + for(FlexBoxLine& line : lines){ + int partscount = 0; + for(FlexBoxObject& obj : line.items){ + partscount += obj.flexBasis; + } + + if(partscount > 0){ + + float partsize = line.totalSpaceMainAxis/partscount; + + line.totalSpaceMainAxis = 0; + + for(FlexBoxObject& obj : line.items){ + if(obj.flex){ + if(horizontal){ + obj.origin->setSizeByParent(obj.flexBasis*partsize, obj.origin->getSizeByParent().y); + obj.shape.width = obj.flexBasis*partsize - DOMLH::getMarginHorizontal(obj.origin); + }else{ + obj.origin->setSizeByParent(obj.origin->getSizeByParent().x, obj.flexBasis*partsize); + obj.shape.height = obj.flexBasis*partsize - DOMLH::getMarginVertical(obj.origin); + } + } + } + } + } + + //set cross size of items if they stretch + + AlignItems alignItems = getAlignItems(_parent); + AlignContent alignContent = getAlignContent(_parent); + + float totalSpaceCrossAxis = crossAxisSize; + + for(FlexBoxLine& line : lines){ + + float lineSize = 0; + for(FlexBoxObject& obj : line.items){ + float elementCrossSize = horizontal ? + DOMLH::getDesiredHeight(obj.origin, totalHeight)+DOMLH::getMarginVertical(obj.origin) : + DOMLH::getDesiredWidth(obj.origin, totalWidth)+DOMLH::getMarginHorizontal(obj.origin); + if(elementCrossSize > lineSize){ + lineSize = elementCrossSize; + } + if(alignContent == AlignContent::STRETCH){ + lineSize = max(lineSize, crossAxisSize / lines.size()); + } + } + totalSpaceCrossAxis -= lineSize; + line.sizeCrossAxis = lineSize; + } + + + // check if lines are not big enough to fit in all elements minimal cross size + for(FlexBoxLine& line : lines){ + + float lineSize = line.sizeCrossAxis; + for(FlexBoxObject& obj : line.items){ + AlignSelf alignSelf = getAlignSelf(obj.origin); + float mainSize = horizontal? obj.origin->getWidth() : obj.origin->getHeight(); + if(obj.flex){ + mainSize = horizontal? obj.shape.width : obj.shape.height; + } + if(alignSelf == AlignSelf::STRETCH || + ((alignSelf == AlignSelf::AUTO) && (alignItems == AlignItems::STRETCH))){ + if(horizontal){ + obj.origin->setSizeByParent(obj.origin->getSizeByParent().x, lineSize); + obj.origin->setLayoutSize(mainSize, lineSize - DOMLH::getMarginVertical(obj.origin)); + }else{ + obj.origin->setSizeByParent(lineSize, obj.origin->getSizeByParent().y); + obj.origin->setLayoutSize(lineSize - DOMLH::getMarginHorizontal(obj.origin), mainSize); + } + }else{ + if(horizontal){ + obj.origin->setLayoutSize(mainSize, DOMLH::getDesiredHeight(obj.origin, lineSize)); + }else{ + obj.origin->setLayoutSize(DOMLH::getDesiredWidth(obj.origin, lineSize), mainSize); + } + } + float elementCrossSize = horizontal ? + obj.origin->getHeight()+DOMLH::getMarginVertical(obj.origin) : + obj.origin->getWidth()+DOMLH::getMarginHorizontal(obj.origin); + + if(elementCrossSize > lineSize){ + lineSize = elementCrossSize; + } + } + line.sizeCrossAxis = lineSize; + } + + float newCrossAxisSize = 0; + for(FlexBoxLine& line : lines){ + newCrossAxisSize += line.sizeCrossAxis; + } + if(newCrossAxisSize > crossAxisSize){ + totalSpaceCrossAxis = 0; + } + + //take care of empty space on cross axis + int spacingCrossAxisStart = 0; + int spacingCrossAxisBetween = 0; + if(lines.size() > 1){ + if(totalSpaceCrossAxis > 0){ + switch(alignContent){ + case AlignContent::CENTER: + spacingCrossAxisStart = totalSpaceCrossAxis/2; + break; + case AlignContent::FLEX_END: + spacingCrossAxisStart = totalSpaceCrossAxis; + break; + case AlignContent::SPACE_AROUND: + spacingCrossAxisStart = totalSpaceCrossAxis/(lines.size()+1); + spacingCrossAxisBetween = spacingCrossAxisStart; + break; + case AlignContent::SPACE_BETWEEN: + spacingCrossAxisBetween = totalSpaceCrossAxis/(lines.size()-1); + break; + default:break; + } + } + }else{ + if(lines.size()>0){ + lines.at(0).sizeCrossAxis = max(lines.at(0).sizeCrossAxis,crossAxisSize); + } + } + + totalWidth += paddingHorizontal; + totalHeight += paddingVertical; + + float parentPaddingLeft = DOMLH::getPaddingLeft(_parent); + float parentPaddingTop = DOMLH::getPaddingTop(_parent); + + float currentMainPos = 0; + float currentCrossPos = spacingCrossAxisStart; + currentCrossPos += horizontal ? parentPaddingTop : parentPaddingLeft; + + for(FlexBoxLine& line : lines){ + + //take care of empty space on main axis + int spacingMainAxisStart = horizontal ? parentPaddingLeft : parentPaddingTop; + int spacingMainAxisBetween = 0; + if(line.totalSpaceMainAxis > 0){ + switch(getJustifyContent(_parent)){ + case JustifyContent::CENTER: + spacingMainAxisStart += line.totalSpaceMainAxis/2; + break; + case JustifyContent::FLEX_END: + spacingMainAxisStart += line.totalSpaceMainAxis; + break; + case JustifyContent::SPACE_AROUND: + spacingMainAxisStart += line.totalSpaceMainAxis/(line.items.size()+1); + spacingMainAxisBetween = spacingMainAxisStart; + break; + case JustifyContent::SPACE_BETWEEN: + spacingMainAxisBetween = line.totalSpaceMainAxis/(line.items.size()-1); + break; + default:break; + } + } + + currentMainPos = spacingMainAxisStart; + + for(FlexBoxObject& obj : line.items){ + + // set cross size of item + + DOM::Element* element = obj.origin; + AlignSelf alignSelf = getAlignSelf(element); + if(alignSelf == AlignSelf::STRETCH || + ((alignSelf == AlignSelf::AUTO) && (alignItems == AlignItems::STRETCH))){ + if(horizontal){ + element->setSizeByParent(element->getSizeByParent().x, line.sizeCrossAxis); + setLayoutHeightMinusMargin(element, line.sizeCrossAxis); + }else{ + element->setSizeByParent(line.sizeCrossAxis, element->getSizeByParent().y); + setLayoutWidthMinusMargin(element, line.sizeCrossAxis); + } + }/*else{ + if(horizontal){ + element->setLayoutHeight(DOMLH::getDesiredHeight(element, lineSizes.at(i))); + }else{ + element->setLayoutWidth(DOMLH::getDesiredWidth(element, lineSizes.at(i))); + } + }*/ + + //align item + + float elementMainPos = currentMainPos; + float elementCrossPos = currentCrossPos; + float elementMainSize = horizontal ? getWidthPlusMargin(element) : getHeightPlusMargin(element); + float elementCrossSize = horizontal ? getHeightPlusMargin(element) : getWidthPlusMargin(element); + + //align item on cross axis + + AlignItems alignItem = alignItems; + if(alignSelf != AlignSelf::AUTO){ + switch(alignSelf){ + case AlignSelf::CENTER: + alignItem = AlignItems::CENTER; + break; + case AlignSelf::STRETCH: + case AlignSelf::FLEX_START: + alignItem = AlignItems::FLEX_START; + break; + case AlignSelf::FLEX_END: + alignItem = AlignItems::FLEX_END; + break; + default: + break; + } + } + + switch(alignItem){ + case AlignItems::FLEX_END: + elementCrossPos += line.sizeCrossAxis-elementCrossSize; + break; + case AlignItems::CENTER: + elementCrossPos += (line.sizeCrossAxis-elementCrossSize)/2.; + break; + default: + break; + } + + //set final element position + if(horizontal){ + DOMLH::setPosition(element, ofPoint(elementMainPos, elementCrossPos)); + }else{ + DOMLH::setPosition(element, ofPoint(elementCrossPos, elementMainPos)); + } + + totalWidth = max(totalWidth, element->getShape().getRight()+DOMLH::getMarginRight(element)+DOMLH::getPaddingRight(_parent)); + totalHeight = max(totalHeight, element->getShape().getBottom()+DOMLH::getMarginBottom(element)+DOMLH::getPaddingBottom(_parent)); + + currentMainPos += elementMainSize + spacingMainAxisBetween; + + } + + currentCrossPos += line.sizeCrossAxis + spacingCrossAxisBetween; + + } + + _parent->setLayoutSize(totalWidth, totalHeight, false); + _parent->setNeedsRedraw(); + +} + +bool ofxDOMFlexBoxLayout::elementFlexing(DOM::Element* e){ + if(!e->getVisible().get()){ + return false; + } + if(e->hasAttribute("position")){ + if(e->getAttribute("position") == DOM::LayoutPosition::POSITION_ABSOLUTE){ + return false; + } + } + return true; +} + +float ofxDOMFlexBoxLayout::getWidthPlusMargin(DOM::Element* e){ + return e->getWidth() + DOMLH::getMarginHorizontal(e); +} + +void ofxDOMFlexBoxLayout::setLayoutWidthMinusMargin(DOM::Element* e, float width){ + if(e->layout()){ + if(e->layout()->isDoingLayout()){ + return; + } + } + width -= DOMLH::getMarginHorizontal(e); + e->setLayoutWidth(width); +} + +float ofxDOMFlexBoxLayout::getHeightPlusMargin(DOM::Element* e){ + return e->getHeight() + DOMLH::getMarginVertical(e); +} + +void ofxDOMFlexBoxLayout::setLayoutHeightMinusMargin(DOM::Element* e, float height){ + if(e->layout()){ + if(e->layout()->isDoingLayout()){ + return; + } + } + height -= DOMLH::getMarginVertical(e); + e->setLayoutHeight(height); +} + +ofxDOMFlexBoxLayout::FlexDirection ofxDOMFlexBoxLayout::getFlexDirection(DOM::Element *e, FlexDirection defaultVal){ + if(e->hasAttribute("_flex-direction")){ + std::string val = e->getAttribute("_flex-direction"); + if(val == "row"){ + return FlexDirection::ROW; + } + if(val == "column"){ + return FlexDirection::COLUMN; + } + } + return defaultVal; +} + +ofxDOMFlexBoxLayout::FlexWrap ofxDOMFlexBoxLayout::getFlexWrap(DOM::Element *e, FlexWrap defaultVal){ + if(e->hasAttribute("_flex-wrap")){ + std::string val = e->getAttribute("_flex-wrap"); + if(val == "nowrap"){ + return FlexWrap::NOWRAP; + } + if(val == "wrap"){ + return FlexWrap::WRAP; + } + } + return defaultVal; +} + +ofxDOMFlexBoxLayout::JustifyContent ofxDOMFlexBoxLayout::getJustifyContent(DOM::Element *e, JustifyContent defaultVal){ + if(e->hasAttribute("_justify-content")){ + std::string val = e->getAttribute("_justify-content"); + if(val == "flex-start"){ + return JustifyContent::FLEX_START; + } + if(val == "flex-end"){ + return JustifyContent::FLEX_END; + } + if(val == "center"){ + return JustifyContent::CENTER; + } + if(val == "space-between"){ + return JustifyContent::SPACE_BETWEEN; + } + if(val == "space-around"){ + return JustifyContent::SPACE_AROUND; + } + } + return defaultVal; +} + +ofxDOMFlexBoxLayout::AlignItems ofxDOMFlexBoxLayout::getAlignItems(DOM::Element *e, AlignItems defaultVal){ + if(e->hasAttribute("_align-items")){ + std::string val = e->getAttribute("_align-items"); + if(val == "flex-start"){ + return AlignItems::FLEX_START; + } + if(val == "flex-end"){ + return AlignItems::FLEX_END; + } + if(val == "center"){ + return AlignItems::CENTER; + } + if(val == "stretch"){ + return AlignItems::STRETCH; + } + } + return defaultVal; +} + +ofxDOMFlexBoxLayout::AlignContent ofxDOMFlexBoxLayout::getAlignContent(DOM::Element *e, AlignContent defaultVal){ + if(e->hasAttribute("_align-content")){ + std::string val = e->getAttribute("_align-content"); + if(val == "stretch"){ + return AlignContent::STRETCH; + } + if(val == "flex-start"){ + return AlignContent::FLEX_START; + } + if(val == "flex-end"){ + return AlignContent::FLEX_END; + } + if(val == "center"){ + return AlignContent::CENTER; + } + if(val == "space-between"){ + return AlignContent::SPACE_BETWEEN; + } + if(val == "space-around"){ + return AlignContent::SPACE_AROUND; + } + } + return defaultVal; +} + +ofxDOMFlexBoxLayout::AlignSelf ofxDOMFlexBoxLayout::getAlignSelf(DOM::Element *e, AlignSelf defaultVal){ + if(e->hasAttribute("_align-self")){ + std::string val = e->getAttribute("_align-self"); + if(val == "auto"){ + return AlignSelf::AUTO; + } + if(val == "stretch"){ + return AlignSelf::STRETCH; + } + if(val == "flex-start"){ + return AlignSelf::FLEX_START; + } + if(val == "flex-end"){ + return AlignSelf::FLEX_END; + } + if(val == "center"){ + return AlignSelf::CENTER; + } + } + return defaultVal; +} diff --git a/addons/ofxGui/src/ofxDOMFlexBoxLayout.h b/addons/ofxGui/src/ofxDOMFlexBoxLayout.h new file mode 100644 index 0000000..f9fb2a5 --- /dev/null +++ b/addons/ofxGui/src/ofxDOMFlexBoxLayout.h @@ -0,0 +1,128 @@ +#pragma once + +#include "Layout.h" +#include "ofParameter.h" +#include "Element.h" + +class ofxDOMFlexBoxLayout: public DOM::_Layout +{ +public: + + /// \brief Flex direction options + enum class FlexDirection { + /// \brief Align items horizontally from left to right (default) + ROW, + /// \brief Align items vertically from top to bottom + COLUMN + }; + + /// \brief Flex wrap options + enum class FlexWrap { + /// \brief Set items in one single line (default) + NOWRAP, + /// \brief Use multiple lines to align items if needed + WRAP + }; + + /// \brief Align items along the main axis options + enum class JustifyContent { + /// \brief Align items at the beginning according to flex direction (default) + FLEX_START, + /// \brief Align items at the end according to flex direction + FLEX_END, + /// \brief Align items at the center + CENTER, + /// \brief Distribute items with equal spacing between them, first and last items without spacing to the edges + SPACE_BETWEEN, + /// \brief Distribute items with equal spacing around all items + SPACE_AROUND + }; + + /// \brief Align items along the cross axis options + enum class AlignItems { + /// \brief Items fill the whole height (or width) + STRETCH, + /// \brief Align items at the beginning (default) + FLEX_START, + /// \brief Align items at the end + FLEX_END, + /// \brief Align items at the center + CENTER + }; + + /// \brief Alignment options for item lines when there is space in the container along the cross axis, only used if multiple rows / columns are present + enum class AlignContent { + /// \brief Distributed space after every item row / column + STRETCH, + /// \brief Items are stacked towards the beginning + FLEX_START, + /// \brief Items are stacked towards the end + FLEX_END, + /// \brief Items are stacked in the center + CENTER, + /// \brief Distribute item rows / columns with equal spacing between them, first and last ones without spacing to the edges + SPACE_BETWEEN, + /// \brief Distribute item rows / columns with equal spacing around all of them + SPACE_AROUND + }; + + /// \brief Individual alignment options for flex items along the cross axis + enum class AlignSelf { + /// \brief Use AlignItems value of parent + AUTO, + /// \brief Item is aligned at the beginning + FLEX_START, + /// \brief Item is aligned at the end + FLEX_END, + /// \brief Item is aligned at the center + CENTER, + /// \brief Item is stretched + STRETCH + }; + + + /// If the Orientation::DEFAULT is chosen, the default will be set to + /// Orientation::HORIZONTAL. + ofxDOMFlexBoxLayout(DOM::Element* parent); + + virtual ~ofxDOMFlexBoxLayout(); + + virtual void doLayout() override; + +protected: + + struct FlexBoxObject { + DOM::Element* origin; + ofRectangle shape; + bool sizeSet = false; + bool flex = false; + float flexBasis = 0; + }; + + struct FlexBoxLine { + FlexBoxLine(float initialSpaceMainAxis){ + totalSpaceMainAxis = initialSpaceMainAxis; + } + std::vector items; + float totalSpaceMainAxis; + float sizeCrossAxis; + }; + + void align(FlexDirection direction); + + static bool elementFlexing(DOM::Element* e); + + static FlexDirection getFlexDirection(DOM::Element* e, FlexDirection defaultVal = FlexDirection::COLUMN); + static FlexWrap getFlexWrap(DOM::Element* e, FlexWrap defaultVal = FlexWrap::NOWRAP); + static JustifyContent getJustifyContent(DOM::Element* e, JustifyContent defaultVal = JustifyContent::FLEX_START); + static AlignItems getAlignItems(DOM::Element* e, AlignItems defaultVal = AlignItems::STRETCH); + static AlignContent getAlignContent(DOM::Element* e, AlignContent defaultVal = AlignContent::STRETCH); + static AlignSelf getAlignSelf(DOM::Element* e, AlignSelf defaultVal = AlignSelf::AUTO); + + static float getWidthPlusMargin(DOM::Element* e); + static float getHeightPlusMargin(DOM::Element* e); + + static void setLayoutWidthMinusMargin(DOM::Element* e, float width); + static void setLayoutHeightMinusMargin(DOM::Element* e, float height); + +}; diff --git a/addons/ofxGui/src/ofxDOMLayoutHelper.cpp b/addons/ofxGui/src/ofxDOMLayoutHelper.cpp new file mode 100644 index 0000000..5494d66 --- /dev/null +++ b/addons/ofxGui/src/ofxDOMLayoutHelper.cpp @@ -0,0 +1,252 @@ +#include "ofxDOMLayoutHelper.h" +#include "JsonConfigParser.h" +#include "Layout.h" +#include "ofxGuiElement.h" + +ofxDOMLayoutHelper::ofxDOMLayoutHelper() +{ + +} + +bool ofxDOMLayoutHelper::elementAbsolutePositioned(DOM::Element* e){ + if(!e->getVisible().get()){ + return false; + } + if(e->hasAttribute("position")){ + if(e->getAttribute("position") == DOM::LayoutPosition::POSITION_ABSOLUTE){ + return true; + } + } + return false; +} + +float ofxDOMLayoutHelper::getDesiredWidth(DOM::Element* e){ + if(e->parent()){ + return getDesiredWidth(e, e->parent()->getWidth()-getPaddingHorizontal(e->parent())); + }else{ + return getDesiredWidth(e, ofGetWindowWidth()); + } + +} + +float ofxDOMLayoutHelper::getDesiredWidth(DOM::Element* e, float parentWidth){ + float res = e->getMinWidth() + getPaddingHorizontal(e); + + if(e->hasAttribute("_width")){ + std::string widthstr = e->getAttribute("_width"); + if(ofIsStringInString(widthstr, "%")){ + vector _val = JsonConfigParser::getMatchedStrings(widthstr, "(?:\\b|-)([1-9]{1,2}[0]?|100)\\b"); + if(_val.size() > 0){ + float amount = ofToFloat(_val[0])/100.; + return parentWidth*amount-getMarginHorizontal(e); + } + }else { + float val = ofToFloat(widthstr); + if(val > 0){ + return val; + } + } + } + + return res; +} + +float ofxDOMLayoutHelper::getDesiredWidthStretched(DOM::Element* e, float parentWidth){ + float res = e->getMinWidth() + getPaddingHorizontal(e); + + if(e->hasAttribute("_width")){ + std::string widthstr = e->getAttribute("_width"); + if(ofIsStringInString(widthstr, "%")){ + vector _val = JsonConfigParser::getMatchedStrings(widthstr, "(?:\\b|-)([1-9]{1,2}[0]?|100)\\b"); + if(_val.size() > 0){ + float amount = ofToFloat(_val[0])/100.; + return parentWidth*amount-getMarginHorizontal(e); + } + }else { + float val = ofToFloat(widthstr); + if(val > 0){ + return val; + } + } + } + + return max(res, parentWidth-getMarginHorizontal(e)); +} + +float ofxDOMLayoutHelper::getMaxWidth(DOM::Element* e, float parentWidth){ + + if(e->hasAttribute("_width")){ + std::string widthstr = e->getAttribute("_width"); + if(ofIsStringInString(widthstr, "%")){ + vector _val = JsonConfigParser::getMatchedStrings(widthstr, "(?:\\b|-)([1-9]{1,2}[0]?|100)\\b"); + if(_val.size() > 0){ + float amount = ofToFloat(_val[0])/100.; + return parentWidth*amount-getMarginHorizontal(e); + } + }else { + float val = ofToFloat(widthstr); + if(val > 0){ + return val; + } + } + } + + return parentWidth-getMarginHorizontal(e); +} + + +float ofxDOMLayoutHelper::getDesiredHeight(DOM::Element* e){ + if(e->parent()){ + return getDesiredHeight(e, e->parent()->getHeight()-getPaddingVertical(e->parent())); + }else{ + return getDesiredHeight(e, ofGetWindowHeight()); + } +} + +float ofxDOMLayoutHelper::getDesiredHeight(DOM::Element* e, float parentHeight){ + float res = e->getMinHeight() + getPaddingVertical(e); + + if(e->hasAttribute("_height")){ + std::string heightstr = e->getAttribute("_height"); + if(ofIsStringInString(heightstr, "%")){ + vector _val = JsonConfigParser::getMatchedStrings(heightstr, "(?:\\b|-)([1-9]{1,2}[0]?|100)\\b"); + if(_val.size() > 0){ + float amount = ofToFloat(_val[0])/100.; + return parentHeight*amount-getMarginVertical(e); + } + }else { + float val = ofToFloat(heightstr); + if(val > 0){ + return val; + } + } + } + + return res; +} + +float ofxDOMLayoutHelper::getDesiredHeightStretched(DOM::Element* e, float parentHeight){ + float res = e->getMinHeight() + getPaddingVertical(e); + + if(e->hasAttribute("_height")){ + std::string heightstr = e->getAttribute("_height"); + if(ofIsStringInString(heightstr, "%")){ + vector _val = JsonConfigParser::getMatchedStrings(heightstr, "(?:\\b|-)([1-9]{1,2}[0]?|100)\\b"); + if(_val.size() > 0){ + float amount = ofToFloat(_val[0])/100.; + return parentHeight*amount-getMarginVertical(e); + } + }else { + float val = ofToFloat(heightstr); + if(val > 0){ + return val; + } + } + } + + return max(res, parentHeight -getMarginVertical(e)); +} + +float ofxDOMLayoutHelper::getMaxHeight(DOM::Element* e, float parentHeight){ + + if(e->hasAttribute("_height")){ + std::string heightstr = e->getAttribute("_height"); + if(ofIsStringInString(heightstr, "%")){ + vector _val = JsonConfigParser::getMatchedStrings(heightstr, "(?:\\b|-)([1-9]{1,2}[0]?|100)\\b"); + if(_val.size() > 0){ + float amount = ofToFloat(_val[0])/100.; + return parentHeight*amount-getMarginVertical(e); + } + }else { + float val = ofToFloat(heightstr); + if(val > 0){ + return val; + } + } + } + + return parentHeight -getMarginVertical(e); +} + +float ofxDOMLayoutHelper::getMarginHorizontal(DOM::Element *e){ + return getMarginLeft(e) + getMarginRight(e); +} + +float ofxDOMLayoutHelper::getMarginVertical(DOM::Element *e){ + return getMarginTop(e) + getMarginBottom(e); +} + +float ofxDOMLayoutHelper::getMarginLeft(DOM::Element *e){ + if(e->hasAttribute("_margin-left")){ + return ofToFloat(e->getAttribute("_margin-left")); + } + return 0; +} + +float ofxDOMLayoutHelper::getMarginRight(DOM::Element *e){ + if(e->hasAttribute("_margin-right")){ + return ofToFloat(e->getAttribute("_margin-right")); + } + return 0; +} + +float ofxDOMLayoutHelper::getMarginTop(DOM::Element *e){ + if(e->hasAttribute("_margin-top")){ + return ofToFloat(e->getAttribute("_margin-top")); + } + return 0; +} + +float ofxDOMLayoutHelper::getMarginBottom(DOM::Element *e){ + if(e->hasAttribute("_margin-bottom")){ + return ofToFloat(e->getAttribute("_margin-bottom")); + } + return 0; +} + +float ofxDOMLayoutHelper::getPaddingHorizontal(DOM::Element *e){ + return getPaddingLeft(e) + getPaddingRight(e); +} + +float ofxDOMLayoutHelper::getPaddingVertical(DOM::Element *e){ + return getPaddingTop(e) + getPaddingBottom(e); +} + +float ofxDOMLayoutHelper::getPaddingLeft(DOM::Element *e){ + if(e->hasAttribute("_padding-left")){ + return ofToFloat(e->getAttribute("_padding-left")); + } + return 0; +} + +float ofxDOMLayoutHelper::getPaddingRight(DOM::Element *e){ + if(e->hasAttribute("_padding-right")){ + return ofToFloat(e->getAttribute("_padding-right")); + } + return 0; +} + +float ofxDOMLayoutHelper::getPaddingTop(DOM::Element *e){ + if(e->hasAttribute("_padding-top")){ + return ofToFloat(e->getAttribute("_padding-top")); + } + return 0; +} + +float ofxDOMLayoutHelper::getPaddingBottom(DOM::Element *e){ + if(e->hasAttribute("_padding-bottom")){ + return ofToFloat(e->getAttribute("_padding-bottom")); + } + return 0; +} + +void ofxDOMLayoutHelper::setPosition(DOM::Element* e, ofPoint p){ + if(e->layout()){ + if(e->layout()->isDoingLayout()){ + return; + } + } + p.x += getMarginLeft(e); + p.y += getMarginTop(e); + e->setPosition(p); +} diff --git a/addons/ofxGui/src/ofxDOMLayoutHelper.h b/addons/ofxGui/src/ofxDOMLayoutHelper.h new file mode 100644 index 0000000..ccd4996 --- /dev/null +++ b/addons/ofxGui/src/ofxDOMLayoutHelper.h @@ -0,0 +1,36 @@ +#pragma once + +#include "Element.h" + +class ofxDOMLayoutHelper +{ + public: + ofxDOMLayoutHelper(); + + static bool elementAbsolutePositioned(DOM::Element* e); + + static float getDesiredWidth(DOM::Element* e); + static float getDesiredHeight(DOM::Element* e); + static float getDesiredWidth(DOM::Element* e, float parentWidth); + static float getDesiredHeight(DOM::Element* e, float parentHeight); + static float getDesiredWidthStretched(DOM::Element* e, float parentWidth); + static float getDesiredHeightStretched(DOM::Element* e, float parentHeight); + static float getMaxWidth(DOM::Element* e, float parentWidth); + static float getMaxHeight(DOM::Element* e, float parentHeight); + + static float getMarginHorizontal(DOM::Element* e); + static float getMarginVertical(DOM::Element* e); + static float getMarginLeft(DOM::Element* e); + static float getMarginRight(DOM::Element* e); + static float getMarginTop(DOM::Element* e); + static float getMarginBottom(DOM::Element* e); + + static float getPaddingHorizontal(DOM::Element* e); + static float getPaddingVertical(DOM::Element* e); + static float getPaddingLeft(DOM::Element* e); + static float getPaddingRight(DOM::Element* e); + static float getPaddingTop(DOM::Element* e); + static float getPaddingBottom(DOM::Element* e); + + static void setPosition(DOM::Element* e, ofPoint p); +}; diff --git a/addons/ofxGui/src/ofxGui.h b/addons/ofxGui/src/ofxGui.h deleted file mode 100644 index 5c55477..0000000 --- a/addons/ofxGui/src/ofxGui.h +++ /dev/null @@ -1,21 +0,0 @@ -#pragma once - -#include "ofxToggle.h" -#include "ofxSlider.h" -#include "ofxSliderGroup.h" -#include "ofxPanel.h" -#include "ofxButton.h" -#include "ofxLabel.h" - -void ofxGuiSetFont(const string & fontPath,int fontsize, bool _bAntiAliased=true, bool _bFullCharacterSet=false, int dpi=0); -void ofxGuiSetBitmapFont(); - -void ofxGuiSetHeaderColor(const ofColor & color); -void ofxGuiSetBackgroundColor(const ofColor & color); -void ofxGuiSetBorderColor(const ofColor & color); -void ofxGuiSetTextColor(const ofColor & color); -void ofxGuiSetFillColor(const ofColor & color); - -void ofxGuiSetTextPadding(int padding); -void ofxGuiSetDefaultWidth(int width); -void ofxGuiSetDefaultHeight(int height); diff --git a/addons/ofxGui/src/ofxGuiButton.cpp b/addons/ofxGui/src/ofxGuiButton.cpp new file mode 100644 index 0000000..53324b9 --- /dev/null +++ b/addons/ofxGui/src/ofxGuiButton.cpp @@ -0,0 +1,103 @@ +#include "ofxGuiButton.h" +using namespace std; + +ofxGuiButton::ofxGuiButton() + :ofxGuiToggle(){ + setup(); +} + +ofxGuiButton::ofxGuiButton(const string &buttonName) + :ofxGuiButton(){ + value.setName(buttonName); +} + +ofxGuiButton::ofxGuiButton(const string &buttonName, const ofJson & config) + :ofxGuiButton(buttonName){ + _setConfig(config); +} + +ofxGuiButton::ofxGuiButton(ofParameter &_val, const ofJson & config) + :ofxGuiToggle(){ + voidvalue.makeReferenceTo(_val); + useVoidValue = true; + setup(); + _setConfig(config); +} + +ofxGuiButton::ofxGuiButton(ofParameter &_val, const ofJson & config) + :ofxGuiToggle(_val){ + setup(); + _setConfig(config); +} + +ofxGuiButton::~ofxGuiButton(){ +} + +void ofxGuiButton::setup(){ + + value = false; + value.setSerializable(false); + voidvalue.setSerializable(false); + registerMouseEvents(); + setTheme(); + +} + +ofAbstractParameter& ofxGuiButton::getParameter(){ + if(useVoidValue){ + return voidvalue; + }else { + return value; + } +} + +bool ofxGuiButton::setValue(float mx, float my, bool bCheck){ + + if(isHidden()){ + hasFocus = false; + return false; + } + if(bCheck){ + + ofRectangle checkRect = checkboxRect; + checkRect.x += getScreenPosition().x; + checkRect.y += getScreenPosition().y; + + hasFocus = checkRect.inside(mx, my); + } + if(hasFocus){ + if(!value){ + voidvalue.trigger(); + } + value = !value; + return true; + } + return false; +} + +void ofxGuiButton::generateDraw(){ + if(useVoidValue){ + value.setName(voidvalue.getName()); + } + ofxGuiToggle::generateDraw(); +} + +bool ofxGuiButton::mouseReleased(ofMouseEventArgs & args){ + + ofxGuiElement::mouseReleased(args); + + bool attended = setValue(args.x, args.y, false); + hasFocus = false; + return attended; + +} + +std::string ofxGuiButton::getClassType(){ + return "button"; +} + +vector ofxGuiButton::getClassTypes(){ + vector types = ofxGuiToggle::getClassTypes(); + types.push_back(getClassType()); + return types; +} diff --git a/addons/ofxGui/src/ofxGuiButton.h b/addons/ofxGui/src/ofxGuiButton.h new file mode 100644 index 0000000..24cd77b --- /dev/null +++ b/addons/ofxGui/src/ofxGuiButton.h @@ -0,0 +1,44 @@ +#pragma once + +#include "ofxGuiToggle.h" +#include "ofParameter.h" + +class ofxGuiButton : public ofxGuiToggle{ +public: + + ofxGuiButton(); + ofxGuiButton(const std::string& buttonName); + ofxGuiButton(const std::string& buttonName, const ofJson & config); + ofxGuiButton(ofParameter& _val, const ofJson & config = ofJson()); + ofxGuiButton(ofParameter& _bVal, const ofJson & config = ofJson()); + + ~ofxGuiButton(); + + virtual ofAbstractParameter & getParameter() override; + + virtual bool mouseReleased(ofMouseEventArgs & args) override; + + template + void addListener(ListenerClass * listener, ListenerMethod method){ + voidvalue.addListener(listener,method); + } + + template + void removeListener(ListenerClass * listener, ListenerMethod method){ + voidvalue.removeListener(listener,method); + } + + static std::string getClassType(); + +protected: + + void setup(); + + virtual std::vector getClassTypes() override; + + virtual void generateDraw() override; + virtual bool setValue(float mx, float my, bool bCheck) override; + ofParameter voidvalue; + bool useVoidValue {false}; + +}; diff --git a/addons/ofxGui/src/ofxGuiContainer.cpp b/addons/ofxGui/src/ofxGuiContainer.cpp new file mode 100644 index 0000000..de0ca83 --- /dev/null +++ b/addons/ofxGui/src/ofxGuiContainer.cpp @@ -0,0 +1,499 @@ +#include "ofGraphics.h" + +#include "ofxGuiContainer.h" +#include "ofxGuiPanel.h" +#include "ofxGuiSliderGroup.h" +#include "ofxGuiTabs.h" +#include "ofxGuiMenu.h" +#include "Document.h" +#include "Layout.h" +#include "ofxGuiFpsPlotter.h" +#include "JsonConfigParser.h" + + +ofxGuiContainer::ofxGuiContainer() + :ofxGuiElement(){ + + setup(); + +} + +ofxGuiContainer::ofxGuiContainer(const std::string& collectionName) + :ofxGuiElement(){ + + setup(); + setName(collectionName); + +} + +ofxGuiContainer::ofxGuiContainer(const std::string& collectionName, const ofJson & config) + :ofxGuiContainer(collectionName){ + + _setConfig(config); + +} + +ofxGuiContainer::ofxGuiContainer(const ofParameterGroup & _parameters, const ofJson & config) + :ofxGuiContainer(_parameters.getName()){ + + addParametersFrom(_parameters); + _setConfig(config); + +} + +ofxGuiContainer::ofxGuiContainer(const std::string& collectionName, const std::string& _filename, float x, float y) + :ofxGuiContainer(collectionName){ + + filename = _filename; + setPosition(x,y); + +} + +ofxGuiContainer::ofxGuiContainer(const ofParameterGroup & _parameters, const std::string& _filename, float x, float y) + :ofxGuiContainer(_parameters.getName()){ + + filename = _filename; + setPosition(x,y); + addParametersFrom(_parameters); + +} + + +ofxGuiContainer::~ofxGuiContainer(){ + + ofRemoveListener(resize, this, &ofxGuiContainer::onResize); + ofRemoveListener(childAdded, this, &ofxGuiContainer::onChildAdded); + ofRemoveListener(addedTo, this, &ofxGuiContainer::onParentAdded); + unregisterMouseEvents(); + +} + +void ofxGuiContainer::setup(){ + + filename.set("filename","settings.xml"); + + exclusiveToggles.set("exclusive toggles", false); + + ofAddListener(resize, this, &ofxGuiContainer::onResize); + ofAddListener(childAdded, this, &ofxGuiContainer::onChildAdded); + ofAddListener(addedTo, this, &ofxGuiContainer::onParentAdded); + + setTheme(); + + registerMouseEvents(); + +} + +void ofxGuiContainer::_setConfig(const ofJson &config){ + + ofxGuiElement::_setConfig(config); + +} + +void ofxGuiContainer::add(const std::shared_ptr & p){ + if(p->isReadOnly()){ + ofLogWarning("ofxGui") << "Trying to add " << p->getName() << ": read only parameters not supported yet in ofxGui"; + } + string type = p->type(); + // TODO is this neccessary? + if(type == typeid(ofParameter ).name()){ + add(p->cast()); + }else if(type == typeid(ofParameter ).name()){ + add(p->cast()); + }else if(type == typeid(ofParameter ).name()){ + add(p->cast()); + }else if(type == typeid(ofParameter ).name()){ + add(p->cast()); + }else if(type == typeid(ofParameter ).name()){ + add(p->cast()); + }else if(type == typeid(ofParameter ).name()){ + add(p->cast()); + }else if(type == typeid(ofParameter ).name()){ + add(p->cast()); + }else if(type == typeid(ofParameter ).name()){ + add(p->cast()); + }else if(type == typeid(ofParameter).name()){ + add(p->cast()); + }else if(type == typeid(ofParameter ).name()){ + add(p->cast()); + }else if(type == typeid(ofParameter).name()){ + add(p->cast()); + }else if(type == typeid(ofParameter).name()){ + add(p->cast()); + }else if(type == typeid(ofParameter).name()){ + add(p->cast()); + }else if(type == typeid(ofParameter).name()){ + add(p->cast()); + }else if(type == typeid(ofParameter).name()){ + add(p->cast()); + }else if(type == typeid(ofParameter).name()){ + add(p->cast()); + }else if(type == typeid(ofParameter).name()){ + add(p->cast()); + }else if(type == typeid(ofParameter).name()){ + add(p->cast()); + }else if(type == typeid(ofParameter).name()){ + add(p->cast()); + }else if(type == typeid(ofParameter).name()){ + add(p->cast()); + }else if(type == typeid(ofParameterGroup).name()){ + //add(p->castGroup()); + add(static_cast(*p)); + }else{ + ofLogWarning("ofxGui") << "Trying to add " << p->getName() << ": ofxBaseGroup; no control for parameter of type " << type; + + } +} + +void ofxGuiContainer::addParametersFrom(const ofParameterGroup & parameters){ + for(auto & p: parameters){ + add(p); + } + this->parameters = parameters; +} + +ofxGuiButton* ofxGuiContainer::add(ofParameter & parameter, const ofJson & config){ + return add(parameter, config); +} + +ofxGuiToggle* ofxGuiContainer::add(ofParameter & parameter, const ofJson & config){ + return add(parameter, config); +} + +ofxGuiLabel *ofxGuiContainer::add(ofParameter & parameter, const ofJson & config){ + return add(parameter, config); +} + +ofxGuiVec2Slider* ofxGuiContainer::add(ofParameter & parameter, const ofJson & config){ + return add(parameter, config); +} + +ofxGuiVec3Slider* ofxGuiContainer::add(ofParameter & parameter, const ofJson & config){ + return add(parameter, config); +} + +ofxGuiVec4Slider* ofxGuiContainer::add(ofParameter & parameter, const ofJson & config){ + return add(parameter, config); +} + +ofxGuiColorSlider* ofxGuiContainer::add(ofParameter & parameter, const ofJson & config){ + return add(parameter, config); +} + +ofxGuiShortColorSlider* ofxGuiContainer::add(ofParameter & parameter, const ofJson & config){ + return add(parameter, config); +} + +ofxGuiFloatColorSlider* ofxGuiContainer::add(ofParameter & parameter, const ofJson & config){ + return add(parameter, config); +} + +ofxGuiRectangleSlider* ofxGuiContainer::add(ofParameter & parameter, const ofJson & config){ + return add(parameter, config); +} + +void ofxGuiContainer::add(const ofParameterGroup ¶meters){ + addParametersFrom(parameters); +} + +ofxGuiLabel* ofxGuiContainer::addLabel(const std::string& label, const ofJson& config){ + return add("", label, config); +} + +ofxGuiElement* ofxGuiContainer::addSpacer(float width, float height){ + ofxGuiElement* e = add(); + e->setSize(width, height); + e->setBorderWidth(0); + e->setBackgroundColor(ofColor(0,0,0,0)); + return e; +} + +ofxGuiElement *ofxGuiContainer::addSpacer(const ofJson& config){ + ofxGuiElement* e = add(); + e->setConfig(ofJson({ + {"border-width", 0}, + {"background-color", "rgba(0,0,0,0)"} + })); + e->setConfig(config); + return e; +} + +ofxGuiFpsPlotter* ofxGuiContainer::addFpsPlotter(const ofJson &config){ + return add(config); +} + +ofxGuiGroup* ofxGuiContainer::addGroup(const string &name, const ofJson &config){ + return add(name, config); +} + +ofxGuiGroup* ofxGuiContainer::addGroup(const ofParameterGroup & parameters, const ofJson &config){ + return add(parameters, config); +} + +ofxGuiContainer* ofxGuiContainer::addContainer(const string &name, const ofJson &config){ + return add(name, config); +} + +ofxGuiContainer* ofxGuiContainer::addContainer(const ofParameterGroup & parameters, const ofJson &config){ + return add(parameters, config); +} + +ofxGuiPanel* ofxGuiContainer::addPanel(const string &name, const ofJson &config){ + return add(name, config); +} + +ofxGuiPanel* ofxGuiContainer::addPanel(const ofParameterGroup & parameters, const ofJson &config){ + return add(parameters, config); +} + +ofxGuiTabs* ofxGuiContainer::addTabs(const string &name, const ofJson &config){ + return add(name, config); +} + +ofxGuiMenu* ofxGuiContainer::addMenu(ofParameterGroup &content, const ofJson &config){ + ofxGuiMenu* c = add(content.getName(), config); + c->addMenuItems(&content); + return c; +} + +void ofxGuiContainer::addMenuItems(ofParameterGroup *content){ + for(auto& _item : *content){ + addToMenu(_item); + } +} + +void ofxGuiContainer::addToMenu(const std::shared_ptr & p){ + string type = p->type(); + if(type == typeid(ofParameter).name()){ + add(p->cast()); + }else if(type == typeid(ofParameter).name()){ + add(p->cast()); + }else if(type == typeid(ofParameter).name()){ + add(p->cast()); + }else if(type == typeid(ofParameter).name()){ + add(p->cast()); + }else if(type == typeid(ofParameter).name()){ + add(p->cast()); + }else if(type == typeid(ofParameter).name()){ + add(p->cast()); + }else if(type == typeid(ofParameter).name()){ + add(p->cast()); + }else if(type == typeid(ofParameterGroup).name()){ + ofxGuiMenu* c = add(p->getName()); + c->addMenuItems(dynamic_cast(p.get())); + }else{ + add(p); + } +} + +void ofxGuiContainer::clear(){ + parameters.clear(); + while(getControls().size() > 0) { + if(!removeChild(getControls().at(0))){ + ofLogError("Element::clear") << "Could not remove child"; + return; + } + } + active_toggle_index = -1; +} + +//vector ofxGuiContainer::getControlNames() const{ +// vector names; +// // TODO +//// for(auto & e: collection){ +//// names.push_back(e->getName()); +//// } +// return names; +//} + +ofxGuiIntSlider* ofxGuiContainer::getIntSlider(const std::string& name){ + return getControlType (name); +} + +ofxGuiFloatSlider* ofxGuiContainer::getFloatSlider(const std::string& name){ + return getControlType (name); +} + +ofxGuiToggle* ofxGuiContainer::getToggle(const std::string& name){ + return getControlType (name); +} + +ofxGuiButton* ofxGuiContainer::getButton(const std::string& name){ + return getControlType (name); +} + +ofxGuiContainer* ofxGuiContainer::getGroup(const std::string& name){ + return getControlType (name); +} + +ofxGuiElement* ofxGuiContainer::getControl(const std::string& name){ + for(auto & e: getControls()){ + if(e){ + if(e->getName() == name){ + return e; + } + } + } + return nullptr; +} + +int ofxGuiContainer::getControlIndex(ofxGuiElement* element){ + + for(int i = 0; i < (int)getControls().size(); i++){ + ofxGuiElement *e = getControl(i); + if(e){ + if(e == element){ + return i; + } + } + } + return -1; + +} + +int ofxGuiContainer::getControlIndex(const std::string& name){ + + for(int i = 0; i < (int)getControls().size(); i++){ + ofxGuiElement *e = getControl(i); + if(e){ + if(e->getName() == name){ + return i; + } + } + } + return -1; +} + +std::vector ofxGuiContainer::getControls(){ + static_assert(std::is_base_of(), "ElementType must be an Element or derived from Element."); + + std::vector results; + + for (auto& child : _children){ + ofxGuiElement* pChild = dynamic_cast(child.get()); + results.push_back(pChild); + } + + return results; +} + + +std::size_t ofxGuiContainer::getNumControls() { + return getControls().size(); +} + +ofxGuiElement * ofxGuiContainer::getControl(std::size_t num){ + if(num < getControls().size()){ + return dynamic_cast (getControls().at(num)); + }else{ + return nullptr; + } +} + +bool ofxGuiContainer::getTogglesExclusive() const { + return exclusiveToggles; +} + +void ofxGuiContainer::setExclusiveToggles(bool exclusive) { + exclusiveToggles = exclusive; +// if(exclusiveToggles) { +// setOneToggleActive(); +// } +} + +bool ofxGuiContainer::setActiveToggle(ofxGuiToggle* toggle) { + if(!(*toggle)) { + *toggle = true; + deactivateAllOtherToggles(toggle); + return true; + } + return false; +} + +bool ofxGuiContainer::setActiveToggle(int index) { + if(index >= 0 && index < (int)getControls().size()){ + if(ofxGuiToggle* toggle = dynamic_cast(getControls().at(index))) { + return setActiveToggle(toggle); + } + else { + ofLogError("ofxGuiContainer", "cannot activate control " + ofToString(index) + " because it's no ofxToggle."); + return false; + } + } + return false; +} + +void ofxGuiContainer::deactivateAllOtherToggles(ofxGuiToggle *toggle) { + if(exclusiveToggles) { + int active_index = -1; + for(int i = 0; i < (int)getControls().size(); i++){ + if(ofxGuiToggle* t = dynamic_cast(getControls()[i])) { + active_index++; + if(t != toggle) { + *t = false; + } + else { + active_toggle_index.set(active_index); + } + } + } + } +} + +void ofxGuiContainer::setOneToggleActive() { + if(active_toggle_index == -1){ + for(auto &e : getControls()){ + if(ofxGuiToggle* t = dynamic_cast(e)) { + setActiveToggle(t); + return; + } + } + } +} + + +ofParameter& ofxGuiContainer::getActiveToggleIndex() { + return active_toggle_index; +} + +ofAbstractParameter & ofxGuiContainer::getParameter(){ + return parameters; +} + +string ofxGuiContainer::getName(){ + return getParameter().getName(); +} + +void ofxGuiContainer::setName(const std::string& _name){ + getParameter().setName(_name); +} + +void ofxGuiContainer::onChildAdded(DOM::ElementEventArgs& args){ + if(ofxGuiElement* e = dynamic_cast(args.element())){ + parameters.add(e->getParameter()); + e->setTheme(theme); + } + args.element()->invalidateChildShape(); +} + +void ofxGuiContainer::onParentAdded(DOM::ElementEventArgs& args){ +// parent()->setLayoutSize(0,0, false); +// this->setLayoutSize(0,0, false); + copyLayoutFromDocument(); + _parent->invalidateChildShape(); + invalidateChildShape(); +} + +void ofxGuiContainer::onResize(DOM::ResizeEventArgs & re){ + +} + +std::string ofxGuiContainer::getClassType(){ + return "container"; +} + +vector ofxGuiContainer::getClassTypes(){ + vector types = ofxGuiElement::getClassTypes(); + types.push_back(getClassType()); + return types; +} diff --git a/addons/ofxGui/src/ofxGuiContainer.h b/addons/ofxGui/src/ofxGuiContainer.h new file mode 100644 index 0000000..10f7128 --- /dev/null +++ b/addons/ofxGui/src/ofxGuiContainer.h @@ -0,0 +1,198 @@ +#pragma once +#include "ofxGuiElement.h" + +#include "ofxGuiSlider.h" +#include "ofxGuiRangeSlider.h" +#include "ofxGuiButton.h" +#include "ofxGuiLabel.h" +#include "ofParameterGroup.h" +#include "ofParameter.h" + +template +class ofxGuiVecSlider_; + +template +class ofxGuiColorSlider_; + +template +class ofxGuiMenuColor_; + +template +class ofxGuiMenuVec_; + +typedef ofxGuiVecSlider_ ofxGuiVec3Slider; +typedef ofxGuiVecSlider_ ofxGuiVec2Slider; +typedef ofxGuiVecSlider_ ofxGuiVec4Slider; +typedef ofxGuiVecSlider_ ofxGuiPointSlider; + +typedef ofxGuiMenuVec_ ofxGuiMenuVec3; +typedef ofxGuiMenuVec_ ofxGuiMenuVec2; +typedef ofxGuiMenuVec_ ofxGuiMenuVec4; +typedef ofxGuiMenuVec_ ofxGuiMenuPoint; + +typedef ofxGuiColorSlider_ ofxGuiColorSlider; +typedef ofxGuiColorSlider_ ofxGuiShortColorSlider; +typedef ofxGuiColorSlider_ ofxGuiFloatColorSlider; + +typedef ofxGuiMenuColor_ ofxGuiMenuColor; +typedef ofxGuiMenuColor_ ofxGuiMenuShortColor; +typedef ofxGuiMenuColor_ ofxGuiMenuFloatColor; + +class ofxGuiRectangleSlider; +class ofxGuiMenuRectangle; +class ofxGuiGroup; +class ofxGuiPanel; +class ofxGuiTabs; +class ofxGuiMenu; +class ofxGuiFpsPlotter; + + +class ofxGuiContainer : public ofxGuiElement { + public: + + ofxGuiContainer(); + ofxGuiContainer(const std::string& collectionName); + ofxGuiContainer(const std::string& collectionName, const ofJson & config); + ofxGuiContainer(const ofParameterGroup & parameters, const ofJson &config = ofJson()); + ofxGuiContainer(const ofParameterGroup & parameters, const std::string& _filename, float x = 10, float y = 10); + ofxGuiContainer(const std::string& collectionName, const std::string& _filename, float x = 10, float y = 10); + + virtual ~ofxGuiContainer(); + + void setup(); + + using Element::add; + + template + typename std::enable_if::value, ofxGuiSlider*>::type add(ofParameter & p, const ofJson & config = ofJson()); + + ofxGuiButton* add(ofParameter & parameter, const ofJson & config = ofJson()); + ofxGuiToggle* add(ofParameter & parameter, const ofJson & config = ofJson()); + ofxGuiLabel* add(ofParameter & parameter, const ofJson & config = ofJson()); + ofxGuiVec2Slider *add(ofParameter & parameter, const ofJson & config = ofJson()); + ofxGuiVecSlider_ *add(ofParameter & parameter, const ofJson & config = ofJson()); + ofxGuiVec4Slider* add(ofParameter & parameter, const ofJson & config = ofJson()); + ofxGuiColorSlider* add(ofParameter & parameter, const ofJson & config = ofJson()); + ofxGuiShortColorSlider* add(ofParameter & parameter, const ofJson & config = ofJson()); + ofxGuiFloatColorSlider* add(ofParameter & parameter, const ofJson & config = ofJson()); + ofxGuiRectangleSlider *add(ofParameter & parameter, const ofJson & config = ofJson()); + + void add(const std::shared_ptr &p); + void add(const ofParameterGroup& parameters); + + ofxGuiLabel* addLabel(const std::string& label, const ofJson& config = ofJson()); + ofxGuiElement* addSpacer(float width, float height); + ofxGuiElement* addSpacer(const ofJson & config = ofJson()); + ofxGuiFpsPlotter* addFpsPlotter(const ofJson & config = ofJson()); + + ofxGuiContainer* addContainer(const std::string& name="", const ofJson& config = ofJson()); + ofxGuiContainer* addContainer(const ofParameterGroup & parameters, const ofJson& config = ofJson()); + ofxGuiGroup* addGroup(const std::string& name="", const ofJson& config = ofJson()); + ofxGuiGroup* addGroup(const ofParameterGroup & parameters, const ofJson& config = ofJson()); + ofxGuiPanel* addPanel(const std::string& name="", const ofJson& config = ofJson()); + ofxGuiPanel* addPanel(const ofParameterGroup & parameters, const ofJson& config = ofJson()); + ofxGuiTabs* addTabs(const std::string& name="", const ofJson& config = ofJson()); + + ofxGuiMenu* addMenu(ofParameterGroup &content, const ofJson& config = ofJson()); + void addMenuItems(ofParameterGroup *content); + void addToMenu(const std::shared_ptr &p); + + virtual void clear() override; + + /// \brief Get a list of pointers to the child elements. + /// + /// The parent Element retains ownership. + /// + /// \returns a list of pointers to child elements. + virtual std::vector getControls(); + +// std::vector getControlNames() const; + std::size_t getNumControls(); + + ofxGuiIntSlider* getIntSlider(const std::string& name); + ofxGuiFloatSlider* getFloatSlider(const std::string& name); + ofxGuiToggle* getToggle(const std::string& name); + ofxGuiButton* getButton(const std::string& name); + ofxGuiContainer* getGroup(const std::string& name); + + ofxGuiElement* getControl(const std::string& name); + ofxGuiElement* getControl(std::size_t num); + int getControlIndex(const std::string& name); + int getControlIndex(ofxGuiElement* element); + + template + ControlType* getControlType(const std::string& name); + + template + ControlType* getControlType(const int& index); + + virtual ofAbstractParameter & getParameter() override; + virtual std::string getName() override; + virtual void setName(const std::string& name) override; + + bool getTogglesExclusive() const; + void setExclusiveToggles(bool exclusive); + bool setActiveToggle(int index); + bool setActiveToggle(ofxGuiToggle* toggle); + ofParameter& getActiveToggleIndex(); + void deactivateAllOtherToggles(ofxGuiToggle* toggle); + + static std::string getClassType(); + + protected: + + virtual std::vector getClassTypes() override; + + ofParameterGroup parameters; + + virtual void _setConfig(const ofJson & config) override; + + void addParametersFrom(const ofParameterGroup & parameters); + + ofParameter active_toggle_index; + bool processToggles(); + void setOneToggleActive(); + + ofParameter filename; + ofParameter exclusiveToggles; + + virtual void onChildAdded(DOM::ElementEventArgs&); + virtual void onParentAdded(DOM::ElementEventArgs&); + virtual void onResize(DOM::ResizeEventArgs&); + +}; + +template +ControlType* ofxGuiContainer::getControlType(const std::string& name){ + ControlType* control = dynamic_cast (getControl(name)); + if(control){ + return control; + }else{ + ofLogWarning() << "getControlType " << name << " not found, creating new"; + control = this->add(); + control->setName(name); + return control; + } +} + +template +ControlType* ofxGuiContainer::getControlType(const int& index){ + + int counter = -1; + for(auto &child : children()){ + if(ControlType* e = dynamic_cast(child)){ + counter++; + if(counter == index){ + return e; + } + } + } + + return nullptr; + +} + +template +typename std::enable_if::value, ofxGuiSlider*>::type ofxGuiContainer::add(ofParameter & p, const ofJson & config){ + return add>(p,config); +} diff --git a/addons/ofxGui/src/ofxGuiDefaultConfig.h b/addons/ofxGui/src/ofxGuiDefaultConfig.h new file mode 100644 index 0000000..90c29fe --- /dev/null +++ b/addons/ofxGui/src/ofxGuiDefaultConfig.h @@ -0,0 +1,125 @@ +#pragma once +#include "ofMain.h" +#include "ofxGuiExtended.h" + +struct ofxGuiDefaultConfig{ + + static ofJson get(){ + + ofJson config = { + + /// settings for all elements + { + ofxGuiElement::getClassType(), { + {"background-color", "rgba(0,0,0,0.2)"}, + {"fill-color", "rgba(200,200,200,0.42)"}, + {"border-width", 1}, + {"padding", 2}, + {"border-color", "rgb(255,255,255)"}, + {"margin", 4}, + {"text-color", "#ffffff"} + } + }, + + /// settings for all toggles + { + ofxGuiToggle::getClassType(), { + } + }, + + /// settings for all buttons + { + ofxGuiButton::getClassType(), { + } + }, + + /// settings for all sliders + { + ofxGuiFloatSlider::getClassType(), { + + } + }, + + /// settings for all rangesliders + { + ofxGuiFloatRangeSlider::getClassType(), { + + } + }, + + /// settings for all labels + { + ofxGuiLabel::getClassType(), { + {"border-width", 0}, + {"background-color", "transparent"} + } + }, + + /// settings for all containers + { + ofxGuiContainer::getClassType(), { + {"border-color", "rgba(255,255,255,0.7)"}, + {"padding", 0}, + {"border-width", 0} + } + }, + + /// settings for all groups + { + ofxGuiGroup::getClassType(), { + } + }, + + /// settings for all group headers + { + ofxGuiGroupHeader::getClassType(), { + {"width", "100%"}, + {"align-self", "stretch"}, + {"flex","none"}, + {"margin", 0}, + {"border-width", 0}, + {"padding", 0}, + {"text-color", "#ffffff"} + } + }, + + /// settings for all panels + { + ofxGuiPanel::getClassType(), { + } + }, + + /// settings for all panel headers + { + ofxGuiPanelHeader::getClassType(), { + } + + }, + + /// settings for all tabbed groups + { + ofxGuiTabs::getClassType(), { + {"show-header",false}, + {"margin-top", 10} + } + }, + + /// settings for all value plotters + { + ofxGuiValuePlotter::getClassType(), { + + } + }, + + /// settings for all input fields + { + ofxGuiIntInputField::getClassType(), { + + } + } + + }; + return config; + } + +}; diff --git a/addons/ofxGui/src/ofxGuiElement.cpp b/addons/ofxGui/src/ofxGuiElement.cpp new file mode 100644 index 0000000..27a9996 --- /dev/null +++ b/addons/ofxGui/src/ofxGuiElement.cpp @@ -0,0 +1,808 @@ +#include "ofxGuiElement.h" +#include "ofxGuiContainer.h" +#include "ofImage.h" +#include "ofBitmapFont.h" +#include "ofxGuiDefaultConfig.h" +#include "IDGenerator.h" +#ifndef TARGET_EMSCRIPTEN +#include "ofXml.h" +#endif + +#include "JsonConfigParser.h" + +using namespace std; + + +//copied from PR https://github.com/openframeworks/openFrameworks/pull/4988 +ofJson loadJson(const std::string & filename){ + ofJson json; + ofFile jsonFile(filename); + if(jsonFile.exists()){ + try{ + jsonFile >> json; + }catch(std::exception & e){ + ofLogError("ofLoadJson") << "error loading json from " + filename + ": " + e.what(); + }catch(...){ + ofLogError("ofLoadJson") << "error loading json from " + filename; + } + }else{ + ofLogError("ofLoadJson") << "error loading json from " + filename + ": file doesn't exist"; + } + return json; +} + +bool saveJson(const std::string & filename, ofJson & json){ + ofFile jsonFile(filename, ofFile::WriteOnly); + try{ + jsonFile << json; + }catch(std::exception & e){ + ofLogError("ofLoadJson") << "error saving json to " + filename + ": " + e.what(); + return false; + }catch(...){ + ofLogError("ofLoadJson") << "error saving json to " + filename; + return false; + } + return true; +} + + +ofxGuiElement::ofxGuiElement() + :DOM::Element("",0,0,0,0){ + + objCount = IDGenerator::getInstance().next(); + + setup(); + +} + +ofxGuiElement::ofxGuiElement(const ofJson &config) + :ofxGuiElement(){ + + _setConfig(config); + +} + +ofxGuiElement::~ofxGuiElement(){ + + unregisterMouseEvents(); + if(updateOnThemeChange){ + ofRemoveListener(ofEvents().update, this, &ofxGuiElement::watchTheme); + } + +} + +void ofxGuiElement::setup(){ + + bRegisteredForMouseEvents = false; + fontLoaded = false; + useTTF = false; + themeUpdated = 0; + themeFilename = ""; + updateOnThemeChange = false; + + textPadding.set("text-padding", 4); + headerBackgroundColor.set("header-background-color", ofColor(255)); + backgroundColor.set("background-color", ofColor(255)); + borderColor.set("border-color", ofColor(0)); + textColor.set("text-color", ofColor(0)); + fillColor.set("fill-color", ofColor(100)); + fontSize.set("font-size", 10); + showName.set("show-name", true); + borderWidth.set("border-width", 1); + borderRadius.set("border-radius", 0); + setLayoutPosition(DOM::LayoutPosition::POSITION_STATIC); + + textAlignment.setName("text-align"); + setTextAlignment("left"); + + theme = ofxGuiDefaultConfig::get(); + setTheme(); + + + // parameter won't be saved to file + parameter.setSerializable(false); + + registerMouseEvents(); + +} + +void ofxGuiElement::registerMouseEvents(int priority){ + if(bRegisteredForMouseEvents == true){ + return; // already registered. + } + bRegisteredForMouseEvents = true; + ofRegisterMouseEvents(this, priority); +} + +void ofxGuiElement::unregisterMouseEvents(int priority){ + if(bRegisteredForMouseEvents == false){ + return; // not registered. + } + ofUnregisterMouseEvents(this, priority); + bRegisteredForMouseEvents = false; +} + +void ofxGuiElement::setConfig(const ofJson &config, bool recursive){ + _setConfig(config); + if(recursive){ + for(auto& e: children()){ + ofxGuiElement* _e = dynamic_cast(e); + if(_e){ + _e->setConfig(config, recursive); + } + } + } +} + +void ofxGuiElement::setTheme(){ + setTheme(theme); +} + +void ofxGuiElement::setTheme(const ofJson &config){ + theme = config; +// blockLayout(true); + _setConfigUsingClassifiers(config, true); +// blockLayout(false); +} + +void ofxGuiElement::loadConfig(const string &filename, bool recursive){ + ofJson config = loadJson(filename); + if(config.size() > 0){ + setConfig(config.begin().value(), recursive); + }else{ + ofLogError("ofxGuiElement::loadConfig") << "Could not load config from " << filename << ". File is empty or does not exist." << endl; + } +} + +void ofxGuiElement::loadTheme(const string &filename, bool updateOnFileChange){ + ofJson config = loadJson(filename); + if(updateOnFileChange){ + if(!updateOnThemeChange){ + updateOnThemeChange = true; + themeFilename = filename; + themeUpdated = std::filesystem::last_write_time(ofToDataPath(themeFilename)); + ofAddListener(ofEvents().update, this, &ofxGuiElement::watchTheme); + } + }else{ + if(updateOnThemeChange){ + updateOnThemeChange = false; + ofRemoveListener(ofEvents().update, this, &ofxGuiElement::watchTheme); + } + } + if(config.size() > 0){ + setTheme(config.begin().value()); + }else{ + ofLogError("ofxGuiElement::loadTheme") << "Could not load config from " << filename << ". File is empty or does not exist." << endl; + } +} + +void ofxGuiElement::watchTheme(ofEventArgs &args){ + std::time_t newthemeUpdated = std::filesystem::last_write_time(ofToDataPath(themeFilename)); + if(newthemeUpdated != themeUpdated){ + themeUpdated = newthemeUpdated; + loadTheme(themeFilename, true); + } + +} + +void ofxGuiElement::_setConfigUsingClassifiers(const ofJson &config, bool recursive){ + + themeLoading = true; + + for(std::string classifier : this->getClassTypes()){ + ofJson::const_iterator it = config.find(classifier); + if(it != config.end()){ + //filter out all config entries that are already set individually for this item + ofJson configFiltered; + for (ofJson::const_iterator it2 = (*it).begin(); it2 != (*it).end(); ++it2) { + if(individualConfig.find(it2.key()) == individualConfig.end()){ + configFiltered[it2.key()] = it2.value(); + } + } + setConfig(configFiltered, false); + } + } + + if(recursive){ + for(auto& e: children()){ + ofxGuiElement* _e = dynamic_cast(e); + if(_e){ + _e->_setConfigUsingClassifiers(config, recursive); + } + } + } + + themeLoading = false; + +} + +void ofxGuiElement::_setConfig(const ofJson &config){ + + ofJson _config = config; + + if(!_config.is_null() && _config.size() > 0){ + + //parse colors + JsonConfigParser::parse(_config, backgroundColor); + JsonConfigParser::parse(_config, borderColor); + JsonConfigParser::parse(_config, textColor); + JsonConfigParser::parse(_config, fillColor); + JsonConfigParser::parse(_config, headerBackgroundColor); + + JsonConfigParser::parse(_config, showName); + JsonConfigParser::parse(_config, fontSize); + JsonConfigParser::parse(_config, borderWidth); + JsonConfigParser::parse(_config, textPadding); + JsonConfigParser::parse(_config, borderRadius); + + //parse size + JsonConfigParser::parse(_config, this); + + //parse position type + DOM::LayoutPosition _position = getLayoutPosition(); + JsonConfigParser::parse(_config, "position", _position); + if(_position != getLayoutPosition()){ + setLayoutPosition(_position); + invalidateChildShape(); + } + + //parse margin + if(_config.find("margin") != _config.end()){ + std::string val = ""; + if(_config["margin"].is_string()){ + val = _config["margin"]; + }else{ + val = ofToString(_config["margin"]); + } + vector margins = ofSplitString(val, " "); + std::string val_top, val_right, val_bottom, val_left; + if(margins.size() == 1){ + val_top = val; + val_right = val; + val_bottom = val; + val_left = val; + } + if(margins.size() == 2){ + val_top = margins[0]; + val_right = margins[1]; + val_bottom = margins[0]; + val_left = margins[1]; + } + if(margins.size() == 3){ + val_top = margins[0]; + val_right = margins[1]; + val_bottom = margins[2]; + val_left = margins[1]; + } + if(margins.size() == 4){ + val_top = margins[0]; + val_right = margins[1]; + val_bottom = margins[2]; + val_left = margins[3]; + } + if(_config.find("margin-top") == _config.end()){ + _config["margin-top"] = val_top; + } + if(_config.find("margin-bottom") == _config.end()){ + _config["margin-bottom"] = val_bottom; + } + if(_config.find("margin-left") == _config.end()){ + _config["margin-left"] = val_left; + } + if(_config.find("margin-right") == _config.end()){ + _config["margin-right"] = val_right; + } + } + + //parse padding + if(_config.find("padding") != _config.end()){ + std::string val = ""; + if(_config["padding"].is_string()){ + val = _config["padding"]; + }else{ + val = ofToString(_config["padding"]); + } + vector paddings = ofSplitString(val, " "); + std::string val_top, val_right, val_bottom, val_left; + if(paddings.size() == 1){ + val_top = val; + val_right = val; + val_bottom = val; + val_left = val; + } + if(paddings.size() == 2){ + val_top = paddings[0]; + val_right = paddings[1]; + val_bottom = paddings[0]; + val_left = paddings[1]; + } + if(paddings.size() == 3){ + val_top = paddings[0]; + val_right = paddings[1]; + val_bottom = paddings[2]; + val_left = paddings[1]; + } + if(paddings.size() == 4){ + val_top = paddings[0]; + val_right = paddings[1]; + val_bottom = paddings[2]; + val_left = paddings[3]; + } + if(_config.find("padding-top") == _config.end()){ + _config["padding-top"] = val_top; + } + if(_config.find("padding-bottom") == _config.end()){ + _config["padding-bottom"] = val_bottom; + } + if(_config.find("padding-left") == _config.end()){ + _config["padding-left"] = val_left; + } + if(_config.find("padding-right") == _config.end()){ + _config["padding-right"] = val_right; + } + } + + //parse text alignment + if (_config.find(textAlignment.getName()) != _config.end()) { + std::string val = _config[textAlignment.getName()]; + setTextAlignment(val); + } + + //parse font + if(_config.find("font-family") != _config.end()){ + + std::string family = _config["font-family"]; + loadFont(family, fontSize); + } + + //parse all config entries to attribute values of the element. + //WARNING this will crash if there are non string keys in the config + for (ofJson::const_iterator it = _config.begin(); it != _config.end(); ++it) { + std::string key = "_" + it.key(); + if(!themeLoading){ + individualConfig[it.key()] = it.value(); + } + if(it.value().is_string() || it.value().is_number() || it.value().is_boolean()){ + std::string value; + if(it.value().is_string()){ + value = it.value(); + }else { + value = ofToString(it.value()); + } + setAttribute(key, value); + } + } + + setLayoutSize(0,0); + invalidateChildShape(); + setNeedsRedraw(); + + } + +} + +void ofxGuiElement::copyLayoutFromDocument(){ + + if(ofxGuiContainer* _this = dynamic_cast(this)){ + if(!layout()){ + DOM::Document* doc = document(); + if(doc){ + if(doc->layout()){ + doc->layout()->copyTo(_this); + } + } + } + } + + for(auto child : children()){ + if(ofxGuiElement* _child = dynamic_cast(child)){ + _child->copyLayoutFromDocument(); + } + } + +} + +ofAbstractParameter& ofxGuiElement::getParameter(){ + return parameter; +} + +void ofxGuiElement::loadFont(const std::string& filename, int fontsize, bool _bAntiAliased, bool _bFullCharacterSet, int dpi){ + font.load(filename, fontsize, _bAntiAliased, _bFullCharacterSet, false, 0, dpi); + fontLoaded = true; + useTTF = true; +} + +void ofxGuiElement::setUseTTF(bool bUseTTF){ + if(bUseTTF && !fontLoaded){ + loadFont(OF_TTF_MONO, fontSize, true, true); + } + useTTF = bUseTTF; +} + +void ofxGuiElement::bindFontTexture(){ + if(useTTF){ + font.getFontTexture().bind(); + }else{ + bitmapFont.getTexture().bind(); + } +} + +void ofxGuiElement::unbindFontTexture(){ + if(useTTF){ + font.getFontTexture().unbind(); + }else{ + bitmapFont.getTexture().unbind(); + } +} + +ofMesh ofxGuiElement::getTextMesh(const string & text, ofPoint p){ + return getTextMesh(text, p.x, p.y); +} + +ofMesh ofxGuiElement::getTextMesh(const string & text, float x, float y){ + if(useTTF){ + return font.getStringMesh(text, x, y); + }else{ + return bitmapFont.getMesh(text, x, y); + } +} + +ofRectangle ofxGuiElement::getTextBoundingBox(const string & text, float x, float y){ + if(useTTF){ + return font.getStringBoundingBox(text, x, y); + }else{ + return bitmapFont.getBoundingBox(text, x, y); + } +} + +void ofxGuiElement::saveToFile(const std::string& filename){ + auto extension = ofToLower(ofFilePath::getFileExt(filename)); + if(extension == "xml"){ + ofXml xml; + if(ofFile(filename, ofFile::Reference).exists()){ + xml.load(filename); + } + saveTo(xml); + xml.save(filename); + }else if(extension == "json"){ + ofJson json; + { + ofFile jsonFile(filename); + if(jsonFile.exists()){ + jsonFile >> json; + } + } + + saveTo(json); + + { + ofFile jsonFile(filename, ofFile::WriteOnly); + jsonFile << json; + } + + }else{ + ofLogError("ofxGuiExtended") << extension << " not recognized, only .xml and .json supported by now"; + } +} + +void ofxGuiElement::loadFromFile(const std::string& filename){ + auto extension = ofToLower(ofFilePath::getFileExt(filename)); + if(extension == "xml"){ + ofXml xml; + xml.load(filename); + loadFrom(xml); + }else if(extension == "json"){ + ofJson json; + ofFile jsonFile(filename); + jsonFile >> json; + loadFrom(json); + }else{ + ofLogError("ofxGuiExtended") << extension << " not recognized, only .xml and .json supported by now"; + } +} + +string ofxGuiElement::getName(){ + return getParameter().getName(); +} + +void ofxGuiElement::setName(const std::string& _name){ + getParameter().setName(_name); +} + +void ofxGuiElement::setTextAlignment(const TextAlignment &textLayout){ + this->textAlignment = textLayout; +} + +void ofxGuiElement::setTextAlignment(const std::string &textLayout){ + if(textLayout == "left"){ + setTextAlignment(TextAlignment::LEFT); + } + else if(textLayout == "right"){ + setTextAlignment(TextAlignment::RIGHT); + } + else if(textLayout == "center"){ + setTextAlignment(TextAlignment::CENTERED); + } +} + +TextAlignment ofxGuiElement::getTextAlignment() const { + return textAlignment; +} + +ofColor ofxGuiElement::getHeaderBackgroundColor() const { + return headerBackgroundColor; +} + +ofColor ofxGuiElement::getBackgroundColor() const { + return backgroundColor; +} + +ofColor ofxGuiElement::getBorderColor() const { + return borderColor; +} + +ofColor ofxGuiElement::getTextColor() const { + return textColor; +} + +ofColor ofxGuiElement::getFillColor() const { + return fillColor; +} + +bool ofxGuiElement::getShowName() const { + return showName; +} + +float ofxGuiElement::getBorderWidth() const { + return borderWidth; +} + +void ofxGuiElement::setBackgroundColor(const ofColor & color){ + backgroundColor.set(color); + individualConfig[backgroundColor.getName()] = ofxGui::colorToString(color); + setNeedsRedraw(); +} + +void ofxGuiElement::setBorderColor(const ofColor & color){ + borderColor.set(color); + individualConfig[borderColor.getName()] = ofxGui::colorToString(color); + setNeedsRedraw(); +} + +void ofxGuiElement::setTextColor(const ofColor & color){ + textColor.set(color); + individualConfig[textColor.getName()] = ofxGui::colorToString(color); + setNeedsRedraw(); +} + +void ofxGuiElement::setFillColor(const ofColor & color){ + fillColor.set(color); + individualConfig[fillColor.getName()] = ofxGui::colorToString(color); + setNeedsRedraw(); +} + +void ofxGuiElement::setBorderWidth(float width){ + borderWidth.set(width); + individualConfig[borderWidth.getName()] = width; + setNeedsRedraw(); +} + +void ofxGuiElement::setFontSize(float size){ + fontSize.set(size); + individualConfig[fontSize.getName()] = size; + setNeedsRedraw(); +} + +void ofxGuiElement::setLayoutPosition(DOM::LayoutPosition type){ + setAttribute("position", type); +} + +DOM::LayoutPosition ofxGuiElement::getLayoutPosition() { + if(!hasAttribute("position")){ + setAttribute("position", DOM::LayoutPosition::POSITION_STATIC); + } + return getAttribute("position"); +} + +void ofxGuiElement::setShowName(bool show){ + showName.set(show); + individualConfig[showName.getName()] = show; + setNeedsRedraw(); +} + +void ofxGuiElement::generateDraw(){ + + bg.clear(); + + bg.setFillColor(backgroundColor); + bg.setFilled(true); + bg.setStrokeWidth(0); + + border.clear(); + border.setFilled(true); + border.setStrokeWidth(0); + border.setFillColor(borderColor); + + bg.rectRounded(borderWidth,borderWidth,getWidth()-borderWidth*2,getHeight()-borderWidth*2, borderRadius); + border.rectRounded(0,0,getWidth(),getHeight(), borderRadius); + border.rectRounded(borderWidth,borderWidth,getWidth()-borderWidth*2,getHeight()-borderWidth*2, borderRadius); + +} + +void ofxGuiElement::render(){ + + ofColor c = ofGetStyle().color; + ofBlendMode blendMode = ofGetStyle().blendingMode; + if(blendMode!=OF_BLENDMODE_ALPHA){ + ofEnableAlphaBlending(); + } + + bg.draw(); + border.draw(); + + ofSetColor(c); + if(blendMode!=OF_BLENDMODE_ALPHA){ + ofEnableBlendMode(blendMode); + } + +} + +string ofxGuiElement::saveStencilToHex(const ofImage & img){ + stringstream strm; + int width = img.getWidth(); + int height = img.getHeight(); + int n = width * height; + unsigned char cur = 0; + int shift = 0; + strm << "{"; + for(int i = 0; i < n;){ + if(img.getPixels()[i * 4 + 3] > 0){ + cur |= 1 << shift; + } + i++; + if(i % 8 == 0){ + strm << "0x" << hex << (unsigned int)cur; + cur = 0; + shift = 0; + if(i < n){ + strm << ","; + } + }else{ + shift++; + } + } + strm << "}"; + return strm.str(); +} + +void ofxGuiElement::loadStencilFromHex(ofImage & img, unsigned char * data){ + int width = img.getWidth(); + int height = img.getHeight(); + int i = 0; + ofColor on(255, 255); + ofColor off(255, 0); + for(int y = 0; y < height; y++){ + for(int x = 0; x < width; x++){ + int shift = i % 8; + int offset = i / 8; + bool cur = (data[offset] >> shift) & 1; + img.setColor(x, y, cur ? on : off); + i++; + } + } + img.update(); +} + +float ofxGuiElement::getTextWidth(const std::string & text){ + return getTextBoundingBox(text).width+2*textPadding; +} + +float ofxGuiElement::getTextHeight(const std::string & text){ + std::string _text = text; + if(text != ""){ + //get text height independent of the appearance of letters being low or high + _text += "|"; + } + return getTextBoundingBox(_text).height+2*textPadding; +} + +bool ofxGuiElement::isMouseOver() const{ + return _isMouseOver; +} + +void ofxGuiElement::setDraggable(bool draggable){ + _isDraggable = draggable; +} + +bool ofxGuiElement::isDraggable() const{ + return _isDraggable; +} + +bool ofxGuiElement::isDragging() const{ + return _isDragging; +} + +bool ofxGuiElement::mouseDragged(ofMouseEventArgs & args){ + if(!isHidden()){ + + if(localToScreen(ofRectangle(0,0,getWidth(),getHeight())).inside(args.x, args.y)){ + _isMouseOver = true; + }else { + _isMouseOver = false; + } + + if(_isDragging){ + setPosition(args - grabPoint - getScreenPosition()); + return true; + } + + }else { + _isDragging = false; + _isMouseOver= false; + } + return false; +} + +bool ofxGuiElement::mousePressed(ofMouseEventArgs & args){ + if(!isHidden()){ + if(localToScreen(ofRectangle(0,0,getWidth(),getHeight())).inside(args.x, args.y)){ + _isMouseOver = true; + if(_isDraggable){ + _isDragging = true; + grabPoint = ofPoint(args.x, args.y) - getScreenPosition(); + return true; + } + }else { + _isDragging = false; + _isMouseOver = false; + } + }else { + _isDragging = false; + _isMouseOver= false; + } + return false; +} + +bool ofxGuiElement::mouseMoved(ofMouseEventArgs & args){ + if(!isHidden()){ + if(localToScreen(ofRectangle(0,0,getWidth(),getHeight())).inside(args.x, args.y)){ + _isMouseOver = true; + }else { + _isMouseOver = false; + } + }else{ + _isDragging = false; + _isMouseOver= false; + } + return false; +} + +bool ofxGuiElement::mouseReleased(ofMouseEventArgs & args){ + if(!isHidden()){ + if(localToScreen(ofRectangle(0,0,getWidth(),getHeight())).inside(args.x, args.y)){ + _isMouseOver = true; + }else { + _isMouseOver = false; + } + } + _isDragging = false; + return false; +} + +ofJson ofxGuiElement::getTheme(){ + return theme; +} + +std::string ofxGuiElement::getClassType(){ + return "base"; +} + +vector ofxGuiElement::getClassTypes(){ + vector types; + types.push_back(getClassType()); + return types; +} + +int ofxGuiElement::getObjectCount(){ + return objCount; +} diff --git a/addons/ofxGui/src/ofxGuiElement.h b/addons/ofxGui/src/ofxGuiElement.h new file mode 100644 index 0000000..55e4659 --- /dev/null +++ b/addons/ofxGui/src/ofxGuiElement.h @@ -0,0 +1,190 @@ +#pragma once + +#include "ofConstants.h" +#include "ofParameter.h" +#include "ofTrueTypeFont.h" +#include "ofBitmapFont.h" +#include "ofJson.h" + +#include "Element.h" + +enum TextAlignment{ + LEFT, + RIGHT, + CENTERED +}; + +class ofxGuiElement : public DOM::Element { + public: + + ofxGuiElement(); + ofxGuiElement(const ofJson & config); + + void setup(); + + virtual ~ofxGuiElement(); + ofxGuiElement(const ofxGuiElement &) = delete; + ofxGuiElement & operator=(const ofxGuiElement &) = delete; + + void setConfig(const ofJson &config, bool recursive = false); + void setTheme(); + void setTheme(const ofJson &config); + void loadConfig(const std::string &filename, bool recursive = false); + void loadTheme(const std::string &filename, bool updateOnFileChange = false); + + void saveToFile(const std::string& filename); + void loadFromFile(const std::string& filename); + + template + void saveTo(T & serializer){ + ofSerialize(serializer, getParameter()); + } + + template + void loadFrom(T & serializer){ + ofDeserialize(serializer, getParameter()); + } + + virtual std::string getName(); + virtual void setName(const std::string& name); + + virtual void setTextAlignment(const TextAlignment& textLayout=TextAlignment::LEFT); + virtual void setTextAlignment(const std::string& textLayout); + TextAlignment getTextAlignment() const; + + virtual void setLayoutPosition(DOM::LayoutPosition type); + virtual DOM::LayoutPosition getLayoutPosition(); + + ofColor getHeaderBackgroundColor() const; + ofColor getBackgroundColor() const; + ofColor getBorderColor() const; + ofColor getTextColor() const; + ofColor getFillColor() const; + bool getShowName() const; + float getBorderWidth() const; + float getFontSize() const; + + virtual void setBackgroundColor(const ofColor & color); + virtual void setBorderColor(const ofColor & color); + virtual void setTextColor(const ofColor & color); + virtual void setFillColor(const ofColor & color); + virtual void setBorderWidth(float width); + virtual void setFontSize(float size); + + void setShowName(bool show); + + virtual ofAbstractParameter & getParameter(); + void loadFont(const std::string& filename, int fontsize, bool _bAntiAliased = true, bool _bFullCharacterSet = false, int dpi = 0); + void setUseTTF(bool bUseTTF); + + /// \returns true if the mouse is over this element. + bool isMouseOver() const; + + /// \returns true if the mouse is pressed on this element. + bool isMousePressed() const; + + /// \brief Set draggability for this element. + /// \param draggable True if draggability is enabled. + void setDraggable(bool draggable); + + /// \brief Determine if draggability is enabled for this element. + /// \returns true if the draggability is enabled. + bool isDraggable() const; + + /// \brief Determine if this element is being dragged. + /// \returns true if this element is being dragged. + bool isDragging() const; + + void registerMouseEvents(int priority = OF_EVENT_ORDER_BEFORE_APP); + void unregisterMouseEvents(int priority = OF_EVENT_ORDER_BEFORE_APP); + + virtual bool mouseMoved(ofMouseEventArgs & args); + virtual bool mousePressed(ofMouseEventArgs & args); + virtual bool mouseDragged(ofMouseEventArgs & args); + virtual bool mouseReleased(ofMouseEventArgs & args); + virtual bool mouseScrolled(ofMouseEventArgs & args){return false;} + virtual void mouseEntered(ofMouseEventArgs & args){} + virtual void mouseExited(ofMouseEventArgs & args){} + + ofJson getTheme(); + ofJson getGlobalConfigTheme(); + + static std::string getClassType(); + + int getObjectCount(); + + protected: + + int objCount; + + virtual std::vector getClassTypes(); + + virtual void generateDraw(); + virtual void render(); + + virtual void _setConfig(const ofJson & config); + void _setConfigUsingClassifiers(const ofJson &config, bool recursive = false); + + void copyLayoutFromDocument(); + + /// \brief Sets the value of the element based on a position + /// \param mx The horizontal position + /// \param my The vertical position + /// \param boundaryCheck If true, it checks whether the position is inside of the element. If not, the value won't be changed. + virtual bool setValue(float mx, float my, bool boundaryCheck){return false;} + void bindFontTexture(); + void unbindFontTexture(); + ofMesh getTextMesh(const std::string & text, ofPoint p); + ofMesh getTextMesh(const std::string & text, float x, float y); + ofRectangle getTextBoundingBox(const std::string & text, float x=0, float y=0); + float getTextWidth(const std::string & text); + float getTextHeight(const std::string & text); + + static std::string saveStencilToHex(const ofImage & img); + static void loadStencilFromHex(ofImage & img, unsigned char * data); + + ofTrueTypeFont font; + bool fontLoaded; + bool useTTF; + ofBitmapFont bitmapFont; + + /// \brief True if the Widget is configured to be dragged. + bool _isDraggable = false; + + /// \brief True if the widget is currently being dragged. + bool _isDragging = false; + + /// \brief True if the pointer is over the widget. + bool _isMouseOver = false; + + /// \brief Point where element is grabbed for dragging in screen coordinates + ofPoint grabPoint; + + ofPath bg, border; + + ofParameter headerBackgroundColor; + ofParameter backgroundColor; + ofParameter borderColor; + ofParameter textColor; + ofParameter fillColor; + ofParameter borderWidth; + ofParameter textAlignment; + ofParameter showName; + ofParameter fontSize; + ofParameter textPadding; + ofParameter borderRadius; + + bool bRegisteredForMouseEvents; + + ofJson theme, individualConfig; + std::string themeFilename; + bool updateOnThemeChange; + void watchTheme(ofEventArgs& args); + std::time_t themeUpdated; + + ofParameter parameter; + + bool themeLoading = false; + +}; + diff --git a/addons/ofxGui/src/ofxGuiExtended.cpp b/addons/ofxGui/src/ofxGuiExtended.cpp new file mode 100644 index 0000000..4984de4 --- /dev/null +++ b/addons/ofxGui/src/ofxGuiExtended.cpp @@ -0,0 +1,94 @@ +#include "ofxGuiExtended.h" + +ofxGui::ofxGui(){ + setup_done = false; +} + +ofxGui::~ofxGui(){ +} + +void ofxGui::setupFlexBoxLayout(){ + setup(); +} + +DOM::Document* ofxGui::getDocument(){ + if(!setup_done){ + setup(); + } + return document.get(); +} + +ofParameter& ofxGui::getVisible(){ + return getDocument()->getVisible(); +} + +ofxGuiContainer* ofxGui::addContainer(const std::string& name, const ofJson& config){ + return getDocument()->add(name, rootGroupConfig(config)); +} + +ofxGuiContainer* ofxGui::addContainer(const ofParameterGroup & parameters, const ofJson& config){ + return getDocument()->add(parameters, rootGroupConfig(config)); +} + +ofxGuiGroup* ofxGui::addGroup(const std::string& name, const ofJson& config){ + return getDocument()->add(name, rootGroupConfig(config)); +} + +ofxGuiGroup* ofxGui::addGroup(const ofParameterGroup & parameters, const ofJson& config){ + return getDocument()->add(parameters, rootGroupConfig(config)); +} + +ofxGuiPanel* ofxGui::addPanel(const std::string& name, const ofJson& config){ + return getDocument()->add(name, rootGroupConfig(config)); +} + +ofxGuiPanel* ofxGui::addPanel(const ofParameterGroup & parameters, const ofJson& config){ + return getDocument()->add(parameters, rootGroupConfig(config)); +} + +ofxGuiTabs* ofxGui::addTabs(const std::string& name, const ofJson& config){ + return getDocument()->add(name, rootGroupConfig(config)); +} + +ofJson ofxGui::rootGroupConfig(const ofJson& config){ + ofJson res = config; + if(config.find("width") == config.end()){ + res["width"] = 200; + } + if(config.find("position") == config.end()){ + res["position"] = "absolute"; + } + if(config.find("left") == config.end()){ + res["left"] = 10; + } + if(config.find("top") == config.end()){ + res["top"] = 10; + } + if(config.find("flex-direction") == config.end()){ + res["flex-direction"] = "column"; + } + return res; +} + +void ofxGui::setConfig(const ofJson &config){ + for(auto* child : getDocument()->children()){ + if(ofxGuiElement* el = dynamic_cast(child)){ + el->setConfig(config, true); + } + } +} + +ofxGuiContainer* ofxGui::addMenu(ofParameterGroup &content, const ofJson& config){ + ofJson res = config; + res["width"] = 50; + ofxGuiContainer* root = addContainer("",res); + ofxGuiMenu* c = root->add("", rootGroupConfig(config)); + c->addMenuItems(&content); + return root; +} + +std::string ofxGui::colorToString(const ofColor& color){ + std::stringstream strstr; + strstr << "rgba(" << (int)color.r << "," << (int)color.g << "," << (int)color.b << "," << ((float)color.a)/255. << ")"; + return strstr.str(); +} diff --git a/addons/ofxGui/src/ofxGuiExtended.h b/addons/ofxGui/src/ofxGuiExtended.h new file mode 100644 index 0000000..be4127d --- /dev/null +++ b/addons/ofxGui/src/ofxGuiExtended.h @@ -0,0 +1,151 @@ +#pragma once + +#include "ofxGuiElement.h" +#include "ofxGuiGroup.h" +#include "ofxGuiSliderGroup.h" +#include "ofxGuiPanel.h" +#include "ofxGuiMenu.h" +#include "ofxGuiTabs.h" +#include "ofxGuiToggle.h" +#include "ofxGuiSlider.h" +#include "ofxGuiRangeSlider.h" +#include "ofxGuiButton.h" +#include "ofxGuiLabel.h" +#include "ofxGuiValuePlotter.h" +#include "ofxGuiFpsPlotter.h" +#include "ofxGuiFunctionPlotter.h" +#include "ofxGuiInputField.h" +#include "ofxGuiGraphics.h" +#include "ofxGuiZoomableGraphics.h" + +#include "ofxDOM.h" + +#include "ofxGuiDefaultConfig.h" +#include "ofxDOMFlexBoxLayout.h" +#include "ofxDOMBoxLayout.h" +#include "JsonConfigParser.h" + +class ofxGui { + public: + ofxGui(); + ~ofxGui(); + + /// \brief Setup function initializing the GUI using the flexbox layout defined by ofxDOMFlexBoxLayout. + /// This function has to be called before adding elements to the GUI. + void setupFlexBoxLayout(); + + /// \brief Template setup function initializing the GUI using the layout given by the template class. + /// The setup function doesn't need to be called from the application if one wants to use + /// the default ofxDOMBoxLayout, it will be executed automatically. + /// This function has to be called before adding elements to the GUI. + template + void setup(){ + if(!setup_done){ + setup_done = true; + document = std::make_unique(); + document->createLayout(document.get()); + }else{ + ofLogError("ofxGui::setup()") << "Setup already done. This function needs to be called before getting the document or adding any elements to it."; + } + } + + /// \brief Get the root document of the GUI. + /// \returns The root DOM::Document. + DOM::Document* getDocument(); + + /// \returns A parameter that determines if the gui is visible or not. + ofParameter& getVisible(); + + /// \brief Add a container to the document. + /// A container is a collection of elements. + /// \param name The container name. + /// \param config The container configuration. + /// \returns The GUI container element. + ofxGuiContainer* addContainer(const std::string& name="", const ofJson& config = ofJson()); + + /// \brief Add a container to the document. + /// A container is a collection of elements. + /// \param parameters A parameter group containing parameters that will be added to the container. + /// \param config The container configuration. + /// \returns The GUI container element. + ofxGuiContainer* addContainer(const ofParameterGroup & parameters, const ofJson& config = ofJson()); + + /// \brief Add a group to the document. + /// A group is a container of elements with a header to minimize the group. + /// \param name The group name. + /// \param config The group configuration. + /// \returns The GUI group element. + ofxGuiGroup* addGroup(const std::string& name="", const ofJson& config = ofJson()); + + /// \brief Add a group to the document. + /// A group is a container of elements with a header to minimize the group. + /// \param parameters A parameter group containing parameters that will be added to the group. + /// \param config The group configuration. + /// \returns The GUI group element. + ofxGuiGroup* addGroup(const ofParameterGroup & parameters, const ofJson& config = ofJson()); + + /// \brief Add a panel to the document. + /// A panel is a container of elements with a header to save and load all child controls. + /// \param name The panel name. + /// \param config The panel configuration. + /// \returns The GUI panel element. + ofxGuiPanel* addPanel(const std::string& name="", const ofJson& config = ofJson()); + + /// \brief Add a panel to the document. + /// A panel is a container of elements with a header to save and load all child controls. + /// \param parameters A parameter group containing parameters that will be added to the panel. + /// \param config The panel configuration. + /// \returns The GUI panel element. + ofxGuiPanel* addPanel(const ofParameterGroup & parameters, const ofJson& config = ofJson()); + + /// \brief Add a tabbed interface to the document. + /// A tabbed interface is a container of other containers. For each added container a tab will be created. + /// \param name The name of the tabbed interface (won't be displayed by default). + /// \param config The tabbed interface configuration. + /// \returns The tabbed interface element. + ofxGuiTabs* addTabs(const std::string& name="", const ofJson& config = ofJson()); + + /// \brief Set a config recursively for all elements of the GUI. + /// \param config The configuration. + void setConfig(const ofJson &config); + + /// \brief Add a parameter to the GUI without initializing a panel or group first. + /// Creates a default panel if not already done. + /// \param parameter The parameter that is going to be modifiable with the standard control type for the specific parameter type. + template + void add(ofParameter& parameter){ + if(!defaultPanel){ + defaultPanel = addPanel(); + } + defaultPanel->add(parameter); + } + + /// \brief Add parameters to the GUI without initializing a panel or group first. + /// Creates a default panel if not already done. + /// \param parameters The parameters that are going to be modifiable with the standard control type for each parameter type. + template + void add(ofParameter& parameter, Args... args) { + getDocument()->blockLayout(true); + add(parameter); + add(args...) ; + getDocument()->blockLayout(false); + } + + ofxGuiContainer *addMenu(ofParameterGroup &content, const ofJson &config = ofJson()); + + /// \brief Converts ofColor data type to a CSS-like rgba string. + /// example: ofColor(255,0,0,127.5) -> "rgba(255,0,0,0.5)" + /// \param color The color to be converted + /// \returns The color in string rgba format. + static std::string colorToString(const ofColor& color); + + private: + std::unique_ptr document; + + bool setup_done; + + ofJson rootGroupConfig(const ofJson& config = ofJson()); + + ofxGuiContainer* defaultPanel = nullptr; +}; + diff --git a/addons/ofxGui/src/ofxGuiFpsPlotter.cpp b/addons/ofxGui/src/ofxGuiFpsPlotter.cpp new file mode 100644 index 0000000..5650a15 --- /dev/null +++ b/addons/ofxGui/src/ofxGuiFpsPlotter.cpp @@ -0,0 +1,45 @@ +#include "ofxGuiFpsPlotter.h" +#include "ofAppRunner.h" + +ofxGuiFpsPlotter::ofxGuiFpsPlotter() +:ofxGuiValuePlotter(){ + + setName("FPS"); + setup(); + +} + +ofxGuiFpsPlotter::ofxGuiFpsPlotter(const ofJson & config) +:ofxGuiFpsPlotter(){ + + _setConfig(config); + +} + +ofxGuiFpsPlotter::ofxGuiFpsPlotter(std::string label, float minValue, float maxValue, int plotSize, const ofJson &config) + :ofxGuiValuePlotter(label, minValue, maxValue, plotSize, config){ + + setup(); + +} + +ofxGuiFpsPlotter::~ofxGuiFpsPlotter(){ + ofRemoveListener(ofEvents().update,this,&ofxGuiFpsPlotter::update); +} + +void ofxGuiFpsPlotter::setup(){ + if(minVal.get() == maxVal.get()) { + if(ofGetTargetFrameRate() > 0) { + minVal = 0; + maxVal = ofGetTargetFrameRate(); + } + } + setDecimalPlace(0); + ofAddListener(ofEvents().update,this,&ofxGuiFpsPlotter::update); +} + +void ofxGuiFpsPlotter::update(ofEventArgs &){ + value = ofGetFrameRate(); + setNeedsRedraw(); +} + diff --git a/addons/ofxGui/src/ofxGuiFpsPlotter.h b/addons/ofxGui/src/ofxGuiFpsPlotter.h new file mode 100644 index 0000000..12fc601 --- /dev/null +++ b/addons/ofxGui/src/ofxGuiFpsPlotter.h @@ -0,0 +1,19 @@ +#pragma once + +#include "ofxGuiValuePlotter.h" + +class ofxGuiFpsPlotter : public ofxGuiValuePlotter { + public: + ofxGuiFpsPlotter(); + ofxGuiFpsPlotter(const ofJson & config); + ofxGuiFpsPlotter(std::string label, float minValue, float maxValue, int plotSize = 100, const ofJson & config = ofJson()); + + virtual ~ofxGuiFpsPlotter(); + + void update(ofEventArgs &); + + protected: + + void setup(); + +}; diff --git a/addons/ofxGui/src/ofxGuiFunctionPlotter.cpp b/addons/ofxGui/src/ofxGuiFunctionPlotter.cpp new file mode 100644 index 0000000..366879a --- /dev/null +++ b/addons/ofxGui/src/ofxGuiFunctionPlotter.cpp @@ -0,0 +1,169 @@ +#include "ofxGuiFunctionPlotter.h" +#include "ofGraphics.h" +using namespace std; + +ofxGuiFunctionPlotter::ofxGuiFunctionPlotter(ofParameter value, const ofJson & config) : + ofxGuiElement(){ + + this->function = [&](float x){return x;}; + this->value.makeReferenceTo(value); + setup(); + _setConfig(config); +} + +ofxGuiFunctionPlotter::ofxGuiFunctionPlotter(ofParameter value, std::function function, const ofJson & config) : + ofxGuiElement(){ + + this->function = function; + this->value.makeReferenceTo(value); + setup(); + _setConfig(config); +} + +ofxGuiFunctionPlotter::~ofxGuiFunctionPlotter(){ + value.removeListener(this,&ofxGuiFunctionPlotter::valueChanged); +} + +void ofxGuiFunctionPlotter::setup(){ + + plotterStrokeWidth.set("plotter-stroke-width", 1); + decimalPlace.set("precision", 3); + value.addListener(this,&ofxGuiFunctionPlotter::valueChanged); + setNeedsRedraw(); + +} + +void ofxGuiFunctionPlotter::_setConfig(const ofJson & config){ + ofxGuiElement::_setConfig(config); + // TODO +} + +float ofxGuiFunctionPlotter::getMinWidth(){ + float _width = 0; + if(showName){ + _width += ofxGuiElement::getTextWidth(getName()); + } + return _width; +} + +float ofxGuiFunctionPlotter::getMinHeight(){ + if(showName){ + return ofxGuiElement::getTextHeight(getName()); + } + return 0; +} + +void ofxGuiFunctionPlotter::setDecimalPlace(int place){ + individualConfig[decimalPlace.getName()] = place; + decimalPlace = place; +} + +void ofxGuiFunctionPlotter::setFunction(std::function function){ + this->function = function; + setNeedsRedraw(); +} + +void ofxGuiFunctionPlotter::generateDraw(){ + + ofxGuiElement::generateDraw(); + + textMesh = getTextMesh(this->getName(), textPadding, getShape().getHeight() / 2 + 4); + + plot.clear(); + plot.setFilled(false); + plot.setStrokeWidth(plotterStrokeWidth); + plot.setStrokeColor(ofColor::white); + for(unsigned i = plotterStrokeWidth; i < getWidth()-plotterStrokeWidth; i++){ + float y_norm = ofMap(function( + ofMap(i, + borderWidth, getWidth() - borderWidth*2, + value.getMin().x, value.getMax().x) + ), + value.getMin().y, value.getMax().y, 0, 1); + if(i == plotterStrokeWidth){ + plot.moveTo(i, ofMap( + y_norm, + 0, 1, + borderWidth + plotterStrokeWidth/2, getHeight() - borderWidth - plotterStrokeWidth/2)); + continue; + } + plot.lineTo(i, ofMap(y_norm, 0, 1, borderWidth + plotterStrokeWidth/2, getHeight() - borderWidth - plotterStrokeWidth/2)); + } +} + +void ofxGuiFunctionPlotter::render(){ + + ofxGuiElement::render(); + +// glEnable(GL_BLEND); + plot.draw(); +// if(background_gradient.isAllocated()){ +//// glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); +// glBlendEquation(GL_MIN); +// background_gradient.draw(borderWidth,borderWidth,getWidth()-2*borderWidth, getHeight()-2*borderWidth); +// ofEnableAlphaBlending(); +// } + + ofSetColor(textColor); + + bindFontTexture(); + textMesh.draw(); + unbindFontTexture(); + +} + +ofAbstractParameter & ofxGuiFunctionPlotter::getParameter(){ + return value; +} + +void ofxGuiFunctionPlotter::valueChanged(ofPoint & value){ + setNeedsRedraw(); +} + +void ofxGuiFunctionPlotter::setFillColor(const ofColor &color){ + setFillColor(color, color); +} + +void ofxGuiFunctionPlotter::setFillColor(const ofColor &minColor, const ofColor &maxColor){ + this->minColor = minColor; + this->maxColor = maxColor; + if(background_gradient.isAllocated()){ + background_gradient.clear(); + } + + float w = 1; + float h = getHeight(); + + background_gradient.allocate(w, h, OF_IMAGE_COLOR); + + float r,g,b,a; + ofColor c; + + for (float y=0; y ofxGuiFunctionPlotter::getClassTypes(){ + vector types = ofxGuiElement::getClassTypes(); + types.push_back(getClassType()); + return types; +} + +std::string ofxGuiFunctionPlotter::getClassType(){ + return "function-plotter"; +} diff --git a/addons/ofxGui/src/ofxGuiFunctionPlotter.h b/addons/ofxGui/src/ofxGuiFunctionPlotter.h new file mode 100644 index 0000000..4a703a2 --- /dev/null +++ b/addons/ofxGui/src/ofxGuiFunctionPlotter.h @@ -0,0 +1,53 @@ +#pragma once + +#include "ofxGuiElement.h" +#include "ofImage.h" + +class ofxGuiFunctionPlotter : public ofxGuiElement { + public: + + ofxGuiFunctionPlotter(ofParameter value, const ofJson & config = ofJson()); + ofxGuiFunctionPlotter(ofParameter value, std::function function, const ofJson & config = ofJson()); + + virtual ~ofxGuiFunctionPlotter(); + + virtual float getMinWidth() override; + virtual float getMinHeight() override; + + void setPlotterStrokeWidth(float width); + void setFunction(std::function function); + + virtual void setFillColor(const ofColor& color) override; + virtual void setFillColor(const ofColor& minColor, const ofColor& maxColor); + + void setDecimalPlace(int place); + + virtual ofAbstractParameter & getParameter() override; + + static std::string getClassType(); + + protected: + + void setup(); + + virtual std::vector getClassTypes() override; + + virtual void _setConfig(const ofJson & config) override; + virtual void render() override; + virtual void generateDraw() override; + + ofVboMesh textMesh; + std::vector buffer; + ofPath plot; + ofParameter plotterStrokeWidth; + ofParameter label; + ofParameter value; + std::function function; + + ofParameter decimalPlace; + ofColor minColor, maxColor; + ofImage background_gradient; + + void valueChanged(ofPoint & value); + +}; diff --git a/addons/ofxGui/src/ofxGuiGraphics.cpp b/addons/ofxGui/src/ofxGuiGraphics.cpp new file mode 100644 index 0000000..9e5e918 --- /dev/null +++ b/addons/ofxGui/src/ofxGuiGraphics.cpp @@ -0,0 +1,147 @@ +#include "ofxGuiGraphics.h" +#include "ofGraphics.h" +using namespace std; + +ofxGuiGraphics::~ofxGuiGraphics(){ + ofRemoveListener(resize, this, &ofxGuiGraphics::onResize); +} + +ofxGuiGraphics::ofxGuiGraphics(std::string canvasName, const ofJson& config) + :ofxGuiElement(){ + _bLoaded = false; + graphics = nullptr; + setup(canvasName); + _setConfig(config); +} + +ofxGuiGraphics::ofxGuiGraphics(std::string canvasName, ofBaseDraws * graphics, const ofJson& config) + :ofxGuiElement(){ + _bLoaded = false; + setGraphics(graphics); + setup(canvasName); + _setConfig(config); +} + +ofxGuiGraphics::ofxGuiGraphics(std::string canvasName, ofBaseDraws * graphics, float w, float h){ + _bLoaded = false; + setGraphics(graphics); + setup(canvasName,w,h); +} + +void ofxGuiGraphics::setup(std::string canvasName, float w, float h){ + autoWidth = false; + autoHeight = false; + setName(canvasName); + if(_bLoaded){ + if(w == 0){ + if(h == 0){ + w = getWidth(); + }else{ + w = h * graphics->getWidth() / graphics->getHeight(); + } + } + h = w * graphics->getHeight() / graphics->getWidth(); + ofxGuiElement::setSize(w,h); + } + setTheme(); + ofAddListener(resize, this, &ofxGuiGraphics::onResize); +} + +void ofxGuiGraphics::setGraphics(ofBaseDraws *graphics){ + if(graphics){ + if(graphics->getHeight() != 0 && graphics->getWidth() != 0){ + _bLoaded = true; + this->graphics = graphics; + }else{ + ofLogWarning("ofxGuiGraphics:setGraphics()", "graphics cannot be loaded, width = 0 or height = 0"); + } + }else{ + ofLogWarning("ofxGuiGraphics:setGraphics()", "graphics is nullptr"); + } +} + +float ofxGuiGraphics::getMinWidth(){ + float _width = 0; + if(showName){ + _width += ofxGuiElement::getTextWidth(getName()) + 2*textPadding; + } + return _width; +} + +float ofxGuiGraphics::getMinHeight(){ + if(showName){ + return ofxGuiElement::getTextHeight(getName()); + } + return 0; +} + +void ofxGuiGraphics::setAutoHeight(){ + autoHeight = true; + autoWidth = false; + setHeight(getWidth() * graphics->getHeight() / graphics->getWidth()); +} + +void ofxGuiGraphics::setAutoWidth(){ + autoHeight = false; + autoWidth = true; + setWidth(getHeight() * graphics->getWidth() / graphics->getHeight()); +} + +void ofxGuiGraphics::onResize(DOM::ResizeEventArgs &args){ + if(autoHeight){ + setHeight(args.shape().width * graphics->getHeight() / graphics->getWidth()); + } + if(autoWidth){ + setWidth(args.shape().height * graphics->getWidth() / graphics->getHeight()); + } +} + +void ofxGuiGraphics::generateDraw(){ + ofxGuiElement::generateDraw(); + + if(showName){ + textMesh = getTextMesh(getName(), textPadding, getHeight() - textPadding); + } +} + +void ofxGuiGraphics::render(){ + + ofxGuiElement::render(); + + ofColor c = ofGetStyle().color; + + if(_bLoaded && graphics){ + graphics->draw(0, 0, getWidth(), getHeight()); + } + + if(showName){ + ofBlendMode blendMode = ofGetStyle().blendingMode; + if(blendMode != OF_BLENDMODE_ALPHA){ + ofEnableAlphaBlending(); + } + ofSetColor(textColor); + + bindFontTexture(); + textMesh.draw(); + unbindFontTexture(); + + ofSetColor(c); + if(blendMode != OF_BLENDMODE_ALPHA){ + ofEnableBlendMode(blendMode); + } + } +} + +ofAbstractParameter & ofxGuiGraphics::getParameter(){ + return label; +} + +std::string ofxGuiGraphics::getClassType(){ + return "graphics"; +} + +vector ofxGuiGraphics::getClassTypes(){ + vector types = ofxGuiElement::getClassTypes(); + types.push_back(getClassType()); + return types; +} diff --git a/addons/ofxGui/src/ofxGuiGraphics.h b/addons/ofxGui/src/ofxGuiGraphics.h new file mode 100644 index 0000000..53378bb --- /dev/null +++ b/addons/ofxGui/src/ofxGuiGraphics.h @@ -0,0 +1,47 @@ +#pragma once + +#include "ofxGuiElement.h" + +class ofxGuiGraphics : public ofxGuiElement { + public: + + ofxGuiGraphics(std::string canvasName="", const ofJson& config = ofJson()); + ofxGuiGraphics(std::string canvasName, ofBaseDraws * graphics, const ofJson& config = ofJson()); + ofxGuiGraphics(std::string canvasName, ofBaseDraws * graphics, float w, float h = 0); + virtual ~ofxGuiGraphics(); + + virtual float getMinWidth() override; + virtual float getMinHeight() override; + + void setAutoHeight(); + void setAutoWidth(); + + virtual void setGraphics(ofBaseDraws* graphics); + + virtual ofAbstractParameter & getParameter() override; + + static std::string getClassType(); + + protected: + + void setup(std::string canvasName = "", float w = 0, float h = 0); + + virtual std::vector getClassTypes() override; + + bool setValue(float mx, float my, bool bCheckBounds) override { + return false; + } + virtual void render() override; + virtual void generateDraw() override; + + virtual void onResize(DOM::ResizeEventArgs& args); + + ofPath bg; + ofVboMesh textMesh; + ofBaseDraws * graphics; + ofParameter label; + bool _bLoaded; + bool resizing = false; + bool autoWidth, autoHeight; + +}; diff --git a/addons/ofxGui/src/ofxGuiGroup.cpp b/addons/ofxGui/src/ofxGuiGroup.cpp index 8529734..9104073 100644 --- a/addons/ofxGui/src/ofxGuiGroup.cpp +++ b/addons/ofxGui/src/ofxGuiGroup.cpp @@ -1,411 +1,226 @@ -#include "ofxGuiGroup.h" -#include "ofxPanel.h" -#include "ofxSliderGroup.h" #include "ofGraphics.h" -#include "ofxLabel.h" -using namespace std; - -ofxGuiGroup::ofxGuiGroup(){ - minimized = false; - spacing = 1; - spacingNextElement = 3; - header = defaultHeight; - bGuiActive = false; -} -ofxGuiGroup::ofxGuiGroup(const ofParameterGroup & parameters, const std::string& filename, float x, float y){ - minimized = false; - parent = nullptr; - setup(parameters, filename, x, y); +#include "ofxGuiGroup.h" +#include "ofxGuiPanel.h" +#include "ofxGuiSliderGroup.h" +#include "ofxGuiTabs.h" +#include "Document.h" +#include "Layout.h" +#include "ofxGuiFpsPlotter.h" +#include "JsonConfigParser.h" + +ofxGuiGroupHeader::ofxGuiGroupHeader(const ofJson &config):ofxGuiElement(){ + setTheme(); + _setConfig(config); + registerMouseEvents(); } -ofxGuiGroup * ofxGuiGroup::setup(const std::string& collectionName, const std::string& filename, float x, float y){ - parameters.setName(collectionName); - return setup(parameters, filename, x, y); -} +void ofxGuiGroupHeader::generateDraw(){ + ofxGuiElement::generateDraw(); -ofxGuiGroup * ofxGuiGroup::setup(const ofParameterGroup & _parameters, const std::string& _filename, float x, float y){ - b.x = x; - b.y = y; - header = defaultHeight; - spacing = 1; - spacingNextElement = 3; - if(parent != nullptr){ - b.width = parent->getWidth(); - }else{ - b.width = defaultWidth; - } - clear(); - filename = _filename; - bGuiActive = false; - - for(std::size_t i = 0; i < _parameters.size(); i++){ - string type = _parameters.getType(i); - if(type == typeid(ofParameter ).name()){ - auto p = _parameters.getInt(i); - add(p); - }else if(type == typeid(ofParameter ).name()){ - auto p = _parameters.get(i); - add(p); - }else if(type == typeid(ofParameter ).name()){ - auto p = _parameters.get(i); - add(p); - }else if(type == typeid(ofParameter ).name()){ - auto p = _parameters.get(i); - add(p); - }else if(type == typeid(ofParameter ).name()){ - auto p = _parameters.get(i); - add(p); - }else if(type == typeid(ofParameter ).name()){ - auto p = _parameters.get(i); - add(p); - }else if(type == typeid(ofParameter ).name()){ - auto p = _parameters.get(i); - add(p); - }else if(type == typeid(ofParameter ).name()){ - auto p = _parameters.get(i); - add(p); - }else if(type == typeid(ofParameter ).name()){ - auto p = _parameters.getFloat(i); - add(p); - }else if(type == typeid(ofParameter ).name()){ - auto p = _parameters.get(i); - add(p); - }else if(type == typeid(ofParameter ).name()){ - auto p = _parameters.getBool(i); - add(p); - }else if(type == typeid(ofParameter ).name()){ - auto p = _parameters.getVec2f(i); - add(p); - }else if(type == typeid(ofParameter ).name()){ - auto p = _parameters.getVec3f(i); - add(p); - }else if(type == typeid(ofParameter ).name()){ - auto p = _parameters.getVec4f(i); - add(p); - }else if(type == typeid(ofParameter ).name()){ - auto p = _parameters.getColor(i); - add(p); - }else if(type == typeid(ofParameter ).name()){ - auto p = _parameters.getShortColor(i); - add(p); - }else if(type == typeid(ofParameter ).name()){ - auto p = _parameters.getFloatColor(i); - add(p); - }else if(type == typeid(ofParameter ).name()){ - auto p = _parameters.getString(i); - add(p); - }else if(type == typeid(ofParameterGroup).name()){ - auto p = _parameters.getGroup(i); - ofxGuiGroup * panel = new ofxGuiGroup(p); - add(panel); + textMesh.clear(); + ofxGuiGroup* _parent = dynamic_cast(parent()); + if(_parent){ + if(_parent->getShowName()){ + textMesh.append(getTextMesh(_parent->getName(), textPadding, getHeight()/ 2 + 4)); + } + if(_parent->getMinimized()){ + textMesh.append(getTextMesh("+", getWidth() - textPadding - 10, getHeight() / 2 + 4)); }else{ - ofLogWarning() << "ofxBaseGroup; no control for parameter of type " << type; + textMesh.append(getTextMesh("-", getWidth()- textPadding - 10, getHeight() / 2 + 4)); } } +} - parameters = _parameters; - registerMouseEvents(); +ofxGuiGroupHeader::~ofxGuiGroupHeader(){ +} - setNeedsRedraw(); +void ofxGuiGroupHeader::render() { + ofColor c = ofGetStyle().color; - return this; -} + ofBlendMode blendMode = ofGetStyle().blendingMode; + if(blendMode!=OF_BLENDMODE_ALPHA){ + ofEnableAlphaBlending(); + } -void ofxGuiGroup::add(ofxBaseGui * element){ - collection.push_back(element); + ofxGuiElement::render(); - element->setPosition(b.x, b.y + b.height + spacing); + ofxGuiGroup* _parent = dynamic_cast(parent()); + if(_parent){ + if(_parent->getShowName()){ - b.height += element->getHeight() + spacing; + ofSetColor(textColor); + bindFontTexture(); + textMesh.draw(); + unbindFontTexture(); - //if(b.widthgetWidth()) b.width = element->getWidth(); + } + } - element->unregisterMouseEvents(); + ofSetColor(c); + if(blendMode!=OF_BLENDMODE_ALPHA){ + ofEnableBlendMode(blendMode); + } + +} - element->setParent(this); +bool ofxGuiGroupHeader::mousePressed(ofMouseEventArgs & args){ - ofxGuiGroup * subgroup = dynamic_cast (element); - if(subgroup != nullptr){ - subgroup->filename = filename; - subgroup->setWidthElements(b.width * .98); - }else{ - if(parent != nullptr){ - element->setSize(b.width * .98, element->getHeight()); - element->setPosition(b.x + b.width - element->getWidth(), element->getPosition().y); + if(!isHidden()){ + ofRectangle minButton(getWidth() - textPadding * 2 - 10, 0, textPadding * 2 + 10, getHeight()); + minButton.setPosition(localToScreen(minButton.getPosition())); + if(minButton.inside(args.x, args.y)){ + ofxGuiGroup* _parent = dynamic_cast(parent()); + if(_parent){ + _parent->toggleMinimize(); + this->setNeedsRedraw(); + return true; + } } } - parameters.add(element->getParameter()); - setNeedsRedraw(); + return ofxGuiElement::mousePressed(args); + } -void ofxGuiGroup::setWidthElements(float w){ - for(std::size_t i = 0; i < collection.size(); i++){ - collection[i]->setSize(w, collection[i]->getHeight()); - collection[i]->setPosition(b.x + b.width - w, collection[i]->getPosition().y); - ofxGuiGroup * subgroup = dynamic_cast (collection[i]); - if(subgroup != nullptr){ - subgroup->setWidthElements(w * .98); +float ofxGuiGroupHeader::getMinWidth(){ + std::string text = ""; + + ofxGuiGroup* _parent = dynamic_cast(parent()); + if(_parent){ + if(_parent->getShowName()){ + text += _parent->getName(); } + text += "+"; } - sizeChangedCB(); - setNeedsRedraw(); -} -void ofxGuiGroup::add(const ofParameterGroup & parameters){ - ofxGuiGroup * panel = new ofxGuiGroup(parameters); - panel->parent = this; - add(panel); + return getTextWidth(text)+4*textPadding; } -void ofxGuiGroup::add(ofParameter & parameter){ - add(new ofxToggle(parameter, b.width)); +float ofxGuiGroupHeader::getMinHeight(){ + return ofxGuiElement::getTextHeight("test")+5; } -void ofxGuiGroup::add(ofParameter & parameter){ - add(new ofxLabel(parameter, b.width)); +std::string ofxGuiGroupHeader::getClassType(){ + return "group-header"; } -void ofxGuiGroup::add(ofParameter & parameter){ - add(new ofxVecSlider_ (parameter, b.width)); +vector ofxGuiGroupHeader::getClassTypes(){ + vector types = ofxGuiElement::getClassTypes(); + types.push_back(getClassType()); + return types; } -void ofxGuiGroup::add(ofParameter & parameter){ - add(new ofxVecSlider_ (parameter, b.width)); -} -void ofxGuiGroup::add(ofParameter & parameter){ - add(new ofxVecSlider_ (parameter, b.width)); -} +/* + * + * ofxGuiGroup + * + */ -void ofxGuiGroup::add(ofParameter & parameter){ - add(new ofxColorSlider_ (parameter, b.width)); -} +ofxGuiGroup::ofxGuiGroup() + :ofxGuiContainer(){ -void ofxGuiGroup::add(ofParameter & parameter){ - add(new ofxColorSlider_ (parameter, b.width)); -} + setup(); -void ofxGuiGroup::add(ofParameter & parameter){ - add(new ofxColorSlider_ (parameter, b.width)); } -void ofxGuiGroup::clear(){ - collection.clear(); - parameters.clear(); - b.height = header + spacing + spacingNextElement; - sizeChangedCB(); -} +ofxGuiGroup::ofxGuiGroup(const std::string& collectionName) + :ofxGuiContainer(){ -bool ofxGuiGroup::mouseMoved(ofMouseEventArgs & args){ - ofMouseEventArgs a = args; - for(std::size_t i = 0; i < collection.size(); i++){ - if(collection[i]->mouseMoved(a)){ - return true; - } - } - if(isGuiDrawing() && b.inside(ofPoint(args.x, args.y))){ - return true; - }else{ - return false; - } -} + setup(); + setName(collectionName); -bool ofxGuiGroup::mousePressed(ofMouseEventArgs & args){ - if(setValue(args.x, args.y, true)){ - return true; - } - if(bGuiActive){ - ofMouseEventArgs a = args; - for(std::size_t i = 0; i < collection.size(); i++){ - if(collection[i]->mousePressed(a)){ - return true; - } - } - } - return false; } -bool ofxGuiGroup::mouseDragged(ofMouseEventArgs & args){ - if(setValue(args.x, args.y, false)){ - return true; - } - if(bGuiActive){ - ofMouseEventArgs a = args; - for(std::size_t i = 0; i < collection.size(); i++){ - if(collection[i]->mouseDragged(a)){ - return true; - } - } - } - return false; -} +ofxGuiGroup::ofxGuiGroup(const std::string& collectionName, const ofJson & config) + :ofxGuiGroup(collectionName){ -bool ofxGuiGroup::mouseReleased(ofMouseEventArgs & args){ - bGuiActive = false; - for(std::size_t k = 0; k < collection.size(); k++){ - ofMouseEventArgs a = args; - if(collection[k]->mouseReleased(a)){ - return true; - } - } - if(isGuiDrawing() && b.inside(ofPoint(args.x, args.y))){ - return true; - }else{ - return false; - } -} + _setConfig(config); -bool ofxGuiGroup::mouseScrolled(ofMouseEventArgs & args){ - ofMouseEventArgs a = args; - for(std::size_t i = 0; i < collection.size(); i++){ - if(collection[i]->mouseScrolled(a)){ - return true; - } - } - if(isGuiDrawing() && b.inside(ofPoint(args.x, args.y))){ - return true; - }else{ - return false; - } } -void ofxGuiGroup::generateDraw(){ - border.clear(); - border.setFillColor(ofColor(thisBorderColor, 180)); - border.setFilled(true); - border.rectangle(b.x, b.y + spacingNextElement, b.width + 1, b.height); - +ofxGuiGroup::ofxGuiGroup(const ofParameterGroup & _parameters, const ofJson & config) + :ofxGuiGroup(_parameters.getName()){ - headerBg.clear(); - headerBg.setFillColor(thisHeaderBackgroundColor); - headerBg.setFilled(true); - headerBg.rectangle(b.x, b.y + 1 + spacingNextElement, b.width, header); + addParametersFrom(_parameters); + _setConfig(config); - textMesh = getTextMesh(getName(), textPadding + b.x, header / 2 + 4 + b.y + spacingNextElement); - if(minimized){ - textMesh.append(getTextMesh("+", b.width - textPadding - 8 + b.x, header / 2 + 4 + b.y + spacingNextElement)); - }else{ - textMesh.append(getTextMesh("-", b.width - textPadding - 8 + b.x, header / 2 + 4 + b.y + spacingNextElement)); - } } -void ofxGuiGroup::render(){ - border.draw(); - headerBg.draw(); +ofxGuiGroup::ofxGuiGroup(const std::string& collectionName, const std::string& _filename, float x, float y) + :ofxGuiContainer(collectionName, _filename, x, y){ - ofBlendMode blendMode = ofGetStyle().blendingMode; - if(blendMode != OF_BLENDMODE_ALPHA){ - ofEnableAlphaBlending(); - } - ofColor c = ofGetStyle().color; - ofSetColor(thisTextColor); + setup(); - bindFontTexture(); - textMesh.draw(); - unbindFontTexture(); +} - if(!minimized){ - for(std::size_t i = 0; i < collection.size(); i++){ - collection[i]->draw(); - } - } +ofxGuiGroup::ofxGuiGroup(const ofParameterGroup & _parameters, const std::string& _filename, float x, float y) + :ofxGuiContainer(_parameters, _filename, x,y){ - ofSetColor(c); - if(blendMode != OF_BLENDMODE_ALPHA){ - ofEnableBlendMode(blendMode); - } -} + setup(); -vector ofxGuiGroup::getControlNames() const{ - vector names; - for(std::size_t i = 0; i < collection.size(); i++){ - names.push_back(collection[i]->getName()); - } - return names; } -ofxIntSlider & ofxGuiGroup::getIntSlider(const std::string& name){ - return getControlType (name); -} -ofxFloatSlider & ofxGuiGroup::getFloatSlider(const std::string& name){ - return getControlType (name); -} +ofxGuiGroup::~ofxGuiGroup(){ -ofxToggle & ofxGuiGroup::getToggle(const std::string& name){ - return getControlType (name); -} + showHeader.removeListener(this, &ofxGuiGroup::onHeaderVisibility); -ofxButton & ofxGuiGroup::getButton(const std::string& name){ - return getControlType (name); } -ofxGuiGroup & ofxGuiGroup::getGroup(const std::string& name){ - return getControlType (name); -} +void ofxGuiGroup::setup(){ -ofxBaseGui * ofxGuiGroup::getControl(const std::string& name){ - for(std::size_t i = 0; i < collection.size(); i++){ - if(collection[i]->getName() == name){ - return collection[i]; - } - } - return nullptr; -} + minimized.set("minimized", false); + showHeader.set("show-header", true); -bool ofxGuiGroup::setValue(float mx, float my, bool bCheck){ + header = add(ofJson({{"margin", 0}})); - if(!isGuiDrawing()){ - bGuiActive = false; - return false; - } + showHeader.addListener(this, &ofxGuiGroup::onHeaderVisibility); + setTheme(); - if(bCheck){ - if(b.inside(mx, my)){ - bGuiActive = true; +} - ofRectangle minButton(b.x + b.width - textPadding * 3, b.y, textPadding * 3, header); - if(minButton.inside(mx, my)){ - minimized = !minimized; - if(minimized){ - minimize(); - }else{ - maximize(); - } - return true; - } - } - } +void ofxGuiGroup::_setConfig(const ofJson &config){ + + ofxGuiContainer::_setConfig(config); + JsonConfigParser::parse(config, showHeader); - return false; } void ofxGuiGroup::minimize(){ minimized = true; - b.height = header + spacing + spacingNextElement + 1 /*border*/; - if(parent){ - parent->sizeChangedCB(); +// blockLayout(true); +// widthMaximized = getWidth(); +// heightMaximized = getHeight(); + + for(auto& child : getControls()){ + child->setHidden(true); } - setNeedsRedraw(); + + invalidateChildShape(); + +// blockLayout(false); + +// setLayoutSize(header->getWidth(), header->getHeight()); } void ofxGuiGroup::maximize(){ minimized = false; - for(std::size_t i = 0; i < collection.size(); i++){ - b.height += collection[i]->getHeight() + spacing; - } - if(parent){ - parent->sizeChangedCB(); +// blockLayout(true); + + for(auto& child : getControls()){ + child->setHidden(false); } - setNeedsRedraw(); +// setLayoutSize(widthMaximized, heightMaximized); + +// blockLayout(false); } void ofxGuiGroup::minimizeAll(){ - for(std::size_t i = 0; i < collection.size(); i++){ - ofxGuiGroup * group = dynamic_cast (collection[i]); + for(auto & e: getControls()){ + ofxGuiGroup * group = dynamic_cast (e); if(group){ group->minimize(); } @@ -413,60 +228,73 @@ void ofxGuiGroup::minimizeAll(){ } void ofxGuiGroup::maximizeAll(){ - for(std::size_t i = 0; i < collection.size(); i++){ - ofxGuiGroup * group = dynamic_cast (collection[i]); + for(auto & e: getControls()){ + ofxGuiGroup * group = dynamic_cast (e); if(group){ group->maximize(); } } } -void ofxGuiGroup::sizeChangedCB(){ - float y; - if(parent){ - y = b.y + header + spacing + spacingNextElement; - }else{ - y = b.y + header + spacing; - } - for(std::size_t i = 0; i < collection.size(); i++){ - collection[i]->setPosition(collection[i]->getPosition().x, y + spacing); - y += collection[i]->getHeight() + spacing; - } - b.height = y - b.y; - if(parent){ - parent->sizeChangedCB(); +bool ofxGuiGroup::getMinimized(){ + return minimized; +} + +void ofxGuiGroup::toggleMinimize(){ + if(minimized){ + maximize(); + }else { + minimize(); } - setNeedsRedraw(); } +void ofxGuiGroup::setShowHeader(bool show) { + if(show == false){ + if(minimized) + maximize(); + } + showHeader = show; + invalidateChildShape(); + } -std::size_t ofxGuiGroup::getNumControls() const { - return collection.size(); -} +std::vector ofxGuiGroup::getControls(){ + static_assert(std::is_base_of(), "ElementType must be an Element or derived from Element."); + + std::vector results; -ofxBaseGui * ofxGuiGroup::getControl(std::size_t num){ - if(num < collection.size()){ - return collection[num]; - }else{ - return nullptr; + for (auto& child : _children){ + ofxGuiElement* pChild = dynamic_cast(child.get()); + + if (pChild && pChild != header){ + results.push_back(pChild); + } } + + return results; } -ofAbstractParameter & ofxGuiGroup::getParameter(){ - return parameters; +ofxGuiElement* ofxGuiGroup::getHeader(){ + return this->header; } -void ofxGuiGroup::setPosition(const ofPoint& p){ - ofVec2f diff = p - b.getPosition(); +void ofxGuiGroup::onHeaderVisibility(bool &showing){ + if(getHeader()){ + getHeader()->setHidden(!showing); + } +} - for(std::size_t i = 0; i < collection.size(); i++){ - collection[i]->setPosition(collection[i]->getPosition() + diff); +void ofxGuiGroup::onHeaderHeight(float &height){ + if(getHeader()){ + getHeader()->setHeight(height); } +} - b.setPosition(p); - setNeedsRedraw(); +std::string ofxGuiGroup::getClassType(){ + return "group"; } -void ofxGuiGroup::setPosition(float x, float y){ - setPosition(ofVec2f(x, y)); +vector ofxGuiGroup::getClassTypes(){ + vector types = ofxGuiContainer::getClassTypes(); + types.push_back(getClassType()); + return types; } diff --git a/addons/ofxGui/src/ofxGuiGroup.h b/addons/ofxGui/src/ofxGuiGroup.h index bd5a86d..d3895b3 100644 --- a/addons/ofxGui/src/ofxGuiGroup.h +++ b/addons/ofxGui/src/ofxGuiGroup.h @@ -1,103 +1,73 @@ #pragma once -#include "ofxBaseGui.h" +#include "ofxGuiContainer.h" -#include "ofxSlider.h" -#include "ofxButton.h" -#include "ofParameterGroup.h" -#include "ofParameter.h" -class ofxGuiGroup : public ofxBaseGui { +class ofxGuiGroupHeader : public ofxGuiElement { public: - ofxGuiGroup(); - ofxGuiGroup(const ofParameterGroup & parameters, const std::string& _filename = "settings.xml", float x = 10, float y = 10); - virtual ~ofxGuiGroup(){ - } - ofxGuiGroup * setup(const std::string& collectionName = "", const std::string& filename = "settings.xml", float x = 10, float y = 10); - ofxGuiGroup * setup(const ofParameterGroup & parameters, const std::string& filename = "settings.xml", float x = 10, float y = 10); - - void add(ofxBaseGui * element); - void add(const ofParameterGroup & parameters); - - template - typename std::enable_if::value, void>::type add(ofParameter & p){ - add(new ofxSlider(p)); - } - void add(ofParameter & parameter); - void add(ofParameter & parameter); - void add(ofParameter & parameter); - void add(ofParameter & parameter); - void add(ofParameter & parameter); - void add(ofParameter & parameter); - void add(ofParameter & parameter); - void add(ofParameter & parameter); - - void minimize(); - void maximize(); - void minimizeAll(); - void maximizeAll(); - - void setWidthElements(float w); - - void clear(); - - virtual void sizeChangedCB(); - - virtual bool mouseMoved(ofMouseEventArgs & args); - virtual bool mousePressed(ofMouseEventArgs & args); - virtual bool mouseDragged(ofMouseEventArgs & args); - virtual bool mouseReleased(ofMouseEventArgs & args); - virtual bool mouseScrolled(ofMouseEventArgs & args); - - - std::vector getControlNames() const; - std::size_t getNumControls() const; - - ofxIntSlider & getIntSlider(const std::string& name); - ofxFloatSlider & getFloatSlider(const std::string& name); - ofxToggle & getToggle(const std::string& name); - ofxButton & getButton(const std::string& name); - ofxGuiGroup & getGroup(const std::string& name); - - ofxBaseGui * getControl(const std::string& name); - ofxBaseGui * getControl(std::size_t num); - - virtual ofAbstractParameter & getParameter(); - - virtual void setPosition(const ofPoint& p); - virtual void setPosition(float x, float y); - protected: - virtual void render(); - virtual bool setValue(float mx, float my, bool bCheck); + ofxGuiGroupHeader(const ofJson &config = ofJson()); + + ~ofxGuiGroupHeader(); - float spacing, spacingNextElement; - float header; + virtual bool mousePressed(ofMouseEventArgs & args) override; - template - ControlType & getControlType(const std::string& name); + virtual float getMinWidth() override; + virtual float getMinHeight() override; - virtual void generateDraw(); + static std::string getClassType(); - std::vector collection; - ofParameterGroup parameters; + protected: - std::string filename; - bool minimized; - bool bGuiActive; + virtual std::vector getClassTypes() override; - ofPath border, headerBg; + virtual void generateDraw() override; + virtual void render() override; ofVboMesh textMesh; + }; -template -ControlType & ofxGuiGroup::getControlType(const std::string& name){ - ControlType * control = dynamic_cast (getControl(name)); - if(control){ - return *control; - }else{ - ofLogWarning() << "getControlType " << name << " not found, creating new"; - control = new ControlType; - control->setName(name); - add(control); - return *control; - } -} + +class ofxGuiGroup : public ofxGuiContainer { + public: + + ofxGuiGroup(); + ofxGuiGroup(const std::string& collectionName); + ofxGuiGroup(const std::string& collectionName, const ofJson & config); + ofxGuiGroup(const ofParameterGroup & parameters, const ofJson &config = ofJson()); + ofxGuiGroup(const ofParameterGroup & parameters, const std::string& _filename, float x = 10, float y = 10); + ofxGuiGroup(const std::string& collectionName, const std::string& _filename, float x = 10, float y = 10); + + virtual ~ofxGuiGroup(); + + void setup(); + + virtual void minimize(); + virtual void maximize(); + virtual void minimizeAll(); + virtual void maximizeAll(); + bool getMinimized(); + void toggleMinimize(); + + void setShowHeader(bool show); + ofxGuiElement* getHeader(); + + virtual std::vector getControls() override; + + static std::string getClassType(); + + protected: + + virtual std::vector getClassTypes() override; + + virtual void _setConfig(const ofJson & config) override; + + ofParameter minimized; + ofParameter showHeader; + ofxGuiElement* header; + + virtual void onHeaderVisibility(bool& showing); + virtual void onHeaderHeight(float& height); + + private: + float widthMaximized, heightMaximized; + +}; diff --git a/addons/ofxGui/src/ofxGuiInputField.cpp b/addons/ofxGui/src/ofxGuiInputField.cpp new file mode 100644 index 0000000..a384a68 --- /dev/null +++ b/addons/ofxGui/src/ofxGuiInputField.cpp @@ -0,0 +1,518 @@ +#include "ofxGuiInputField.h" +#include "ofGraphics.h" + +template +ofxGuiInputField::ofxGuiInputField(){ + + setup(); + +} + +template +ofxGuiInputField::ofxGuiInputField(const ofJson &config) + :ofxGuiInputField(){ + + _setConfig(config); + +} + +template +ofxGuiInputField::ofxGuiInputField(ofParameter& _val, const ofJson &config) + :ofxGuiInputField(){ + + value.makeReferenceTo(_val); + input = ofToString(value); + inputWidth = getTextBoundingBox(input,0,0).width; + value.addListener(this,&ofxGuiInputField::valueChanged); + pressCounter = 0; + _setConfig(config); + +} + +template +ofxGuiInputField::ofxGuiInputField(const std::string& _name, Type _val, Type _min, Type _max, const ofJson &config) + :ofxGuiInputField(value.set(_name,_val,_min,_max), config){ +} + +template +ofxGuiInputField::~ofxGuiInputField(){ + value.removeListener(this,&ofxGuiInputField::valueChanged); + unregisterKeyEvents(); +} + +template +void ofxGuiInputField::setup(){ + + bChangedInternally = false; + bMousePressed = false; + mouseInside = false; + bRegisteredForKeyEvents = false; + hasFocus = false; + mousePressedPos = -1; + selectStartX = -1; + selectStartPos = -1; + selectEndPos = -1; + pressCounter = 0; + inputWidth = 0; + selectionWidth = 0; + setTheme(); + registerMouseEvents(); + registerKeyEvents(); + +} + +template +void ofxGuiInputField::setMin(Type min){ + value.setMin(min); +} + +template +Type ofxGuiInputField::getMin(){ + return value.getMin(); +} + +template +void ofxGuiInputField::setMax(Type max){ + value.setMax(max); +} + +template +Type ofxGuiInputField::getMax(){ + return value.getMax(); +} + +template +void ofxGuiInputField::calculateSelectionArea(int selectIdx1, int selectIdx2){ + std::string preSelectStr, selectStr; + + if(selectIdx1 <= selectIdx2){ + selectStartPos = selectIdx1; + selectEndPos = selectIdx2; + }else{ + selectStartPos = selectIdx2; + selectEndPos = selectIdx1; + } + + float preSelectWidth = 0; + if(selectStartPos > 0){ + preSelectStr.assign(input,0,selectStartPos); + preSelectWidth = getTextBoundingBox(preSelectStr,0,0).width; + } + selectStartX = getWidth() - textPadding - inputWidth + preSelectWidth; + + if(hasSelectedText()){ + selectStr.assign(input,selectStartPos,selectEndPos-selectStartPos); + selectionWidth = getTextBoundingBox(selectStr,0,0).width; + } +} + + +template +float ofxGuiInputField::getMinWidth(){ + std::string text = ofToString(value.get()); + if(showName){ + if(!getName().empty()){ + text = getName() + ": "; + } + } + + return ofxGuiElement::getTextWidth(text); +} + +template +float ofxGuiInputField::getMinHeight(){ + std::string text = ofToString(value.get()); + if(showName){ + if(!getName().empty()){ + text = getName() + ": "; + } + } + return ofxGuiElement::getTextHeight(text); +} + +template +bool ofxGuiInputField::mouseMoved(ofMouseEventArgs & args){ + + ofxGuiElement::mouseMoved(args); + + mouseInside = !isHidden() && isMouseOver(); + return mouseInside; +} + +template +bool ofxGuiInputField::mousePressed(ofMouseEventArgs & args){ + + ofxGuiElement::mousePressed(args); + + if(isMouseOver()){ + bMousePressed = true; + hasFocus = true; + + float cursorX = args.x - (localToScreen(getShape()).getRight() - textPadding - inputWidth); + int cursorPos = ofMap(cursorX,0,inputWidth,0,input.size(),true); + mousePressedPos = cursorPos; + + calculateSelectionArea(cursorPos, cursorPos); + + pressCounter++; + + }else{ + if(hasFocus){ + leaveFocus(); + } + } + return false; +} + +template +bool ofxGuiInputField::mouseDragged(ofMouseEventArgs & args){ + + ofxGuiElement::mouseDragged(args); + + if(!hasFocus || !bMousePressed) + return false; + + float cursorX = args.x - (localToScreen(getShape()).getRight() - textPadding - inputWidth); + int cursorPos = ofMap(cursorX,0,inputWidth,0,input.size(),true); + calculateSelectionArea(mousePressedPos,cursorPos); + return false; +} + +template +bool ofxGuiInputField::mouseReleased(ofMouseEventArgs & args){ + + ofxGuiElement::mouseReleased(args); + + // if(bUpdateOnEnterOnly){ //TODO not implemented yet + // value.enableEvents(); + // } + + if(hasFocus){ + if(pressCounter == 1 && !hasSelectedText()){ + //activated panel without selecting an area => select all + calculateSelectionArea(0, input.size()); + } + } + + bMousePressed = false; + return false; +} + + +template +typename std::enable_if::value, Type>::type +getRange(Type min, Type max, float width){ + double range = max - min; + range /= width*4; + return std::max(range,1.0); +} + +template +typename std::enable_if::value, Type>::type +getRange(Type min, Type max, float width){ + double range = max - min; + range /= width*4; + return range; +} + +template +bool ofxGuiInputField::mouseScrolled(ofMouseEventArgs & args){ + + ofxGuiElement::mouseScrolled(args); + + if(mouseInside || hasFocus){ + if(args.y>0 || args.y<0){ + double range = getRange(value.getMin(),value.getMax(),getWidth()); + Type newValue = value + ofMap(args.y,-1,1,-range, range); + newValue = ofClamp(newValue,value.getMin(),value.getMax()); + value = newValue; + } + return true; + }else{ + return false; + } +} + +template<> +bool ofxGuiInputField::mouseScrolled(ofMouseEventArgs & args){ + if(mouseInside || hasFocus){ + return true; + }else{ + return false; + } +} + +template +void ofxGuiInputField::registerKeyEvents(){ + if(bRegisteredForKeyEvents == true){ + return; // already registered. + } + bRegisteredForKeyEvents = true; + ofRegisterKeyEvents(this, OF_EVENT_ORDER_BEFORE_APP); +} + +template +void ofxGuiInputField::unregisterKeyEvents(){ + if(bRegisteredForKeyEvents == false){ + return; // not registered. + } + ofUnregisterKeyEvents(this, OF_EVENT_ORDER_BEFORE_APP); + bRegisteredForKeyEvents = false; +} + +template +bool ofxGuiInputField::keyPressed(ofKeyEventArgs & args){ + if(hasFocus && !bMousePressed){ + + int newCursorIdx = -1; + if(args.key >= '0' && args.key <= '9'){ + int digit = args.key - '0'; + newCursorIdx = insertKeystroke(ofToString(digit)); + }else if(args.key == '-' ){ + newCursorIdx = insertKeystroke("-"); + }else if(args.key == '.' ){ + newCursorIdx = insertKeystroke("."); + }else if(args.key == OF_KEY_BACKSPACE || args.key == OF_KEY_DEL){ + if(hasSelectedText()){ + input.erase(selectStartPos,selectEndPos-selectStartPos); + newCursorIdx = selectStartPos; + parseInput(); + }else{ + int deleteIdx = -1; + if(args.key == OF_KEY_BACKSPACE){ + deleteIdx = selectStartPos-1; + }else if(args.key == OF_KEY_DEL){ + deleteIdx = selectStartPos; + } + + //erase char if valid deleteIdx + if(deleteIdx >= 0 && deleteIdx < (int)input.size()){ + input.erase(deleteIdx,1); + newCursorIdx = deleteIdx; + parseInput(); + } + } + }else if(args.key == OF_KEY_LEFT){ + if(hasSelectedText()){ + newCursorIdx = selectStartPos; + }else{ + newCursorIdx = selectStartPos == 0 ? 0 : selectStartPos-1; + } + }else if(args.key == OF_KEY_RIGHT){ + if(hasSelectedText()){ + newCursorIdx = selectEndPos; + }else{ + newCursorIdx = selectStartPos == (int)input.size() ? (int)input.size() : selectStartPos+1; + } + }else if(args.key == OF_KEY_RETURN){ + leaveFocus(); + }else if((args.key >= '!' && args.key <= '~') + || (args.key <= 'a' && args.key >= 'Z') + || (args.key == ' ')){ + newCursorIdx = insertAlphabetic(ofToString((char)args.key)); + } + + if(newCursorIdx != -1){ + //set cursor + calculateSelectionArea(newCursorIdx,newCursorIdx); + } + return true; + } + return false; +} + +template +bool ofxGuiInputField::keyReleased(ofKeyEventArgs & args){ + return hasFocus && !bMousePressed; +} + + +template +int ofxGuiInputField::insertKeystroke(const std::string & character){ + if(hasSelectedText()){ + input.erase(selectStartPos,selectEndPos-selectStartPos); + } + input.insert(selectStartPos,character); + parseInput(); + return selectStartPos + 1; +} + +template +int ofxGuiInputField::insertAlphabetic(const std::string &){ + return -1; //do nothing for numeric types, cursor/selection area stays the same +} + +template<> +int ofxGuiInputField::insertAlphabetic(const std::string & character){ + return insertKeystroke(character); +} + +template +Type ofxGuiInputField::operator=(Type v){ + value = v; + return v; +} + +template +ofxGuiInputField::operator const Type & (){ + return value; +} + +template +void ofxGuiInputField::generateDraw(){ + + ofxGuiElement::generateDraw(); + + generateText(); +} + + +template +void ofxGuiInputField::generateText(){ + std::string valStr = input; + textMesh = getTextMesh(getName(), textPadding, getShape().height / 2 + 4); + textMesh.append(getTextMesh(valStr, getShape().width - textPadding - getTextBoundingBox(valStr,0,0).width, getShape().height / 2 + 4)); +} + +template +void ofxGuiInputField::render(){ + ofxGuiElement::render(); + + if(hasFocus){ + drawFocusedBB(); + + if(hasSelectedText()){ + drawSelectedArea(); + }else{ + drawCursor(); + } + } + + drawMesh(); +} + +template +bool ofxGuiInputField::hasSelectedText(){ + return selectStartPos != selectEndPos; +} + +template +void ofxGuiInputField::drawMesh(){ + ofBlendMode blendMode = ofGetStyle().blendingMode; + if(blendMode!=OF_BLENDMODE_ALPHA){ + ofEnableAlphaBlending(); + } + ofSetColor(textColor); + + bindFontTexture(); + textMesh.draw(); + unbindFontTexture(); + + ofColor c = ofGetStyle().color; + ofSetColor(c); + if(blendMode!=OF_BLENDMODE_ALPHA){ + ofEnableBlendMode(blendMode); + } +} + +template +void ofxGuiInputField::drawSelectedArea(){ + ofPushStyle(); + ofSetColor(fillColor); + ofFill(); + ofDrawRectangle( selectStartX, 1, selectionWidth, getShape().height-2 ); + ofPopStyle(); +} + +template +void ofxGuiInputField::drawCursor(){ + ofPushStyle(); + ofSetColor(textColor); + ofDrawLine( selectStartX, 0, selectStartX, getShape().getHeight() ); + ofPopStyle(); +} + +template +void ofxGuiInputField::drawFocusedBB(){ + ofPushStyle(); + ofSetColor(textColor); + ofDrawLine( selectStartX, 0, selectStartX, getShape().getHeight() ); + ofPopStyle(); +} + +template +bool ofxGuiInputField::setValue(float mx, float my, bool bCheck){ + return false; +} + +template +ofAbstractParameter & ofxGuiInputField::getParameter(){ + return value; +} + +template +void ofxGuiInputField::parseInput(){ + bChangedInternally = true; + Type tmpVal = ofToFloat(input); + if(tmpVal < getMin()){ + tmpVal = getMin(); + }else if(tmpVal > getMax()){ + tmpVal = getMax(); + } + value = tmpVal; +} + +template<> +void ofxGuiInputField::parseInput(){ + bChangedInternally = true; + value = input; +} + +template +void ofxGuiInputField::valueChanged(Type & value){ + if(bChangedInternally){ + bChangedInternally = false; + inputWidth = getTextBoundingBox(input,0,0).width; + }else{ + input = ofToString(value); + inputWidth = getTextBoundingBox(input,0,0).width; + if(hasFocus){ + int cursorPos = input.size(); + calculateSelectionArea(cursorPos,cursorPos); + } + } + setNeedsRedraw(); +} + +template +void ofxGuiInputField::leaveFocus(){ + pressCounter = 0; + input = ofToString(value); + inputWidth = getTextBoundingBox(input,0,0).width; + hasFocus = false; + setNeedsRedraw(); +} + +template +std::string ofxGuiInputField::getClassType(){ + return "input"; +} + +template +std::vector ofxGuiInputField::getClassTypes(){ + std::vector types = ofxGuiElement::getClassTypes(); + types.push_back(getClassType()); + return types; +} + +template class ofxGuiInputField; +template class ofxGuiInputField; +template class ofxGuiInputField; +template class ofxGuiInputField; +template class ofxGuiInputField; +template class ofxGuiInputField; +template class ofxGuiInputField; +template class ofxGuiInputField; +template class ofxGuiInputField; +template class ofxGuiInputField; +template class ofxGuiInputField; diff --git a/addons/ofxGui/src/ofxGuiInputField.h b/addons/ofxGui/src/ofxGuiInputField.h new file mode 100644 index 0000000..d75b39a --- /dev/null +++ b/addons/ofxGui/src/ofxGuiInputField.h @@ -0,0 +1,98 @@ +#pragma once + +#include "ofxGuiElement.h" + +template +class ofxGuiInputField : public ofxGuiElement{ +public: + ofxGuiInputField(); + ofxGuiInputField(const ofJson &config); + ofxGuiInputField(ofParameter& _val, const ofJson &config = ofJson()); + ofxGuiInputField(const std::string& _name, Type _val, Type _min, Type _max, const ofJson &config = ofJson()); + //TODO the setup non-ofParameter setup is a pain for the Type string (because of the forced min and max) + + ~ofxGuiInputField(); + + void setMin(Type min); + Type getMin(); + void setMax(Type max); + Type getMax(); + + virtual float getMinWidth() override; + virtual float getMinHeight() override; + + virtual bool mouseMoved(ofMouseEventArgs & args) override; + virtual bool mousePressed(ofMouseEventArgs & args) override; + virtual bool mouseDragged(ofMouseEventArgs & args) override; + virtual bool mouseReleased(ofMouseEventArgs & args) override; + virtual bool mouseScrolled(ofMouseEventArgs & args) override; + + void registerKeyEvents(); + void unregisterKeyEvents(); + + virtual bool keyPressed(ofKeyEventArgs & args); + virtual bool keyReleased(ofKeyEventArgs & args); + + template + void addListener(ListenerClass * listener, ListenerMethod method){ + value.addListener(listener,method); + } + + template + void removeListener(ListenerClass * listener, ListenerMethod method){ + value.removeListener(listener,method); + } + + Type operator=(Type v); + operator const Type & (); + + ofAbstractParameter & getParameter() override; + + static std::string getClassType(); + +protected: + + void setup(); + + virtual std::vector getClassTypes() override; + + virtual void render() override; + ofParameter value; + bool bMousePressed; + bool mouseInside; + bool hasFocus; + bool setValue(float mx, float my, bool bCheck) override; + virtual void generateDraw() override; + virtual void generateText(); + void valueChanged(Type & value); + ofVboMesh textMesh; + + bool bRegisteredForKeyEvents; + + std::string input; + float inputWidth; + bool bChangedInternally; + void parseInput(); + int insertKeystroke(const std::string & character); + int insertAlphabetic(const std::string & character); + + int mousePressedPos; //set by mouse interaction + bool hasSelectedText(); + + float selectStartX, selectionWidth; //calculated from select indices + int selectStartPos, selectEndPos; + void calculateSelectionArea(int selectIdx1, int selectIdx2); + + virtual void drawSelectedArea(); + virtual void drawCursor(); + virtual void drawFocusedBB(); + virtual void drawMesh(); + + int pressCounter; + + void leaveFocus(); +}; + +typedef ofxGuiInputField ofxGuiFloatInputField; +typedef ofxGuiInputField ofxGuiIntInputField; +typedef ofxGuiInputField ofxGuiTextField; diff --git a/addons/ofxGui/src/ofxGuiLabel.cpp b/addons/ofxGui/src/ofxGuiLabel.cpp new file mode 100644 index 0000000..1e25fe2 --- /dev/null +++ b/addons/ofxGui/src/ofxGuiLabel.cpp @@ -0,0 +1,174 @@ +#include "ofxGuiLabel.h" +#include "ofGraphics.h" +using namespace std; + +template +ofxGuiValueLabel::ofxGuiValueLabel() +:ofxGuiElement(){ + + setup(); + +} + +template +ofxGuiValueLabel::ofxGuiValueLabel(ofParameter& _label, const ofJson & config) +:ofxGuiElement(){ + + label.makeReferenceTo(_label); + setup(); + _setConfig(config); + +} + +template<> +ofxGuiValueLabel::ofxGuiValueLabel(const string& labelName, const ofJson & config) +:ofxGuiValueLabel(){ + + label.set(labelName); + _setConfig(config); + +} + + +template +ofxGuiValueLabel::ofxGuiValueLabel(ofParameter& _label, float width, float height) + :ofxGuiValueLabel(_label){ + + setSize(width, height); + +} + +template +ofxGuiValueLabel::ofxGuiValueLabel(const string& labelName, const Type& _label, const ofJson & config) + :ofxGuiValueLabel(){ + + label.set(labelName,_label); + _setConfig(config); + +} + +template +ofxGuiValueLabel::ofxGuiValueLabel(const string& labelName, const Type& _label, float width, float height) + :ofxGuiValueLabel(){ + + label.set(labelName,_label); + setSize(width, height); + +} + +template +ofxGuiValueLabel::~ofxGuiValueLabel(){ + + label.removeListener(this,&ofxGuiValueLabel::valueChanged); + +} + +template +void ofxGuiValueLabel::setup(){ + + label.setSerializable(false); + setTheme(); + + label.addListener(this,&ofxGuiValueLabel::valueChanged); + +} + +template +float ofxGuiValueLabel::getMinWidth(){ + string text = ""; + if(showName){ + if(!getName().empty()){ + text += getName(); + } + if(!getName().empty() && label.toString() != ""){ + text += ": "; + } + } + text += label.toString(); + + return ofxGuiElement::getTextWidth(text); +} + +template +float ofxGuiValueLabel::getMinHeight(){ + string text = ""; + if(showName){ + if(!getName().empty()){ + text += getName(); + } + if(!getName().empty() && label.toString() != ""){ + text += ": "; + } + } + text += label.toString(); + + return ofxGuiElement::getTextHeight(text); +} + +template +void ofxGuiValueLabel::generateDraw(){ + + ofxGuiElement::generateDraw(); + + if(showName){ + string name = ""; + if(!getName().empty()){ + name += getName(); + } + if(!getName().empty() && label.toString() != ""){ + name += ": "; + } + textMesh = getTextMesh(name + label.toString(), textPadding, getShape().height / 2 + 4); + }else { + textMesh = getTextMesh(label.toString(), textPadding, getShape().height / 2 + 4); + } +} + +template +void ofxGuiValueLabel::render() { + ofColor c = ofGetStyle().color; + + ofxGuiElement::render(); + + ofBlendMode blendMode = ofGetStyle().blendingMode; + if(blendMode!=OF_BLENDMODE_ALPHA){ + ofEnableAlphaBlending(); + } + ofSetColor(textColor); + + bindFontTexture(); + textMesh.draw(); + unbindFontTexture(); + + ofSetColor(c); + if(blendMode!=OF_BLENDMODE_ALPHA){ + ofEnableBlendMode(blendMode); + } +} + +template +ofAbstractParameter & ofxGuiValueLabel::getParameter(){ + return label; +} + +template +void ofxGuiValueLabel::valueChanged(Type & value){ + setNeedsRedraw(); +} + +template +std::string ofxGuiValueLabel::getClassType(){ + return "label"; +} + +template +vector ofxGuiValueLabel::getClassTypes(){ + vector types = ofxGuiElement::getClassTypes(); + types.push_back(getClassType()); + return types; +} + +template class ofxGuiValueLabel; +template class ofxGuiValueLabel; +template class ofxGuiValueLabel; +template class ofxGuiValueLabel; diff --git a/addons/ofxGui/src/ofxGuiLabel.h b/addons/ofxGui/src/ofxGuiLabel.h new file mode 100644 index 0000000..ad7afa2 --- /dev/null +++ b/addons/ofxGui/src/ofxGuiLabel.h @@ -0,0 +1,58 @@ +#pragma once + +#include "ofxGuiElement.h" +#include "ofParameter.h" + +template +class ofxGuiValueLabel: public ofxGuiElement { +public: + + ofxGuiValueLabel(); + ofxGuiValueLabel(ofParameter& _label, const ofJson & config = ofJson()); + ofxGuiValueLabel(const std::string& labelName, const ofJson & config = ofJson()); + ofxGuiValueLabel(ofParameter& _label, float width, float height); + ofxGuiValueLabel(const std::string& labelName, const Type & label, const ofJson & config = ofJson()); + ofxGuiValueLabel(const std::string& labelName, const Type & label, float width, float height); + + virtual ~ofxGuiValueLabel(); + + virtual float getMinWidth() override; + virtual float getMinHeight() override; + + + template + void addListener(ListenerClass * listener, ListenerMethod method){ + label.addListener(listener,method); + } + + template + void removeListener(ListenerClass * listener, ListenerMethod method){ + label.removeListener(listener,method); + } + + + Type operator=(Type v) { label = v; return v; } + operator const Type & () { return label; } + + ofAbstractParameter & getParameter() override; + + static std::string getClassType(); + +protected: + + void setup(); + + virtual std::vector getClassTypes() override; + + virtual void render() override; + ofParameter label; + virtual void generateDraw() override; + void valueChanged(Type & value); + bool setValue(float mx, float my){return false;} + ofVboMesh textMesh; +}; + +typedef ofxGuiValueLabel ofxGuiLabel; +typedef ofxGuiValueLabel ofxGuiIntLabel; +typedef ofxGuiValueLabel ofxGuiFloatLabel; +typedef ofxGuiValueLabel ofxGuiBoolLabel; diff --git a/addons/ofxGui/src/ofxGuiMenu.cpp b/addons/ofxGui/src/ofxGuiMenu.cpp new file mode 100644 index 0000000..943f163 --- /dev/null +++ b/addons/ofxGui/src/ofxGuiMenu.cpp @@ -0,0 +1,608 @@ +#include "ofxGuiExtended.h" +#include "ofxGuiMenu.h" +#include "ofGraphics.h" +#include "Document.h" +#include "ofxDOMLayoutHelper.h" +using namespace std; + +//MENU LABEL + +ofxGuiMenuLabel::ofxGuiMenuLabel(const std::string& labelName, const std::string & label, const ofJson & config) + :ofxGuiLabel(){ + this->label.set(labelName,label); + this->_setConfig(config); +} + +void ofxGuiMenuLabel::generateDraw(){ + ofxGuiLabel::generateDraw(); + float lineW = 4; + float height = this->getHeight(); + float width = height; + float x = this->getWidth()-width/6*5; + icon.clear(); + icon.setColor(this->getTextColor()); + icon.setFilled(true); + icon.rectangle(x,height/6,width-width/3, lineW); + icon.rectangle(x,height/2-lineW/2,width-width/3, lineW); + icon.rectangle(x,height/6*5-lineW,width-width/3, lineW); +} + +void ofxGuiMenuLabel::render(){ + ofxGuiLabel::render(); + icon.draw(); +} + +float ofxGuiMenuLabel::getMinWidth(){ + return ofxGuiLabel::getMinWidth()+this->getHeight()/2+10; +} + +//SUBMENU LABEL + +ofxGuiSubmenuLabel::ofxGuiSubmenuLabel(const std::string& labelName, const std::string & label, const ofJson & config) + :ofxGuiMenuLabel(labelName, label, config){ +} + +void ofxGuiSubmenuLabel::generateDraw(){ + ofxGuiLabel::generateDraw(); + float lineW = 2; + float height = this->getHeight(); + float width = height/2; + float x = this->getWidth()-width; + icon.clear(); + icon.setColor(this->getTextColor()); + icon.setFilled(true); + icon.lineTo(x+lineW, height/6); + icon.lineTo(x+width/6*5, height/2); + icon.lineTo(x+lineW, height/6*5); + icon.lineTo(x, height/6*5); + icon.lineTo(x+width/6*5-lineW, height/2); + icon.lineTo(x, height/6); + icon.close(); +} + +//MENU + +ofxGuiMenu::ofxGuiMenu() : + ofxGuiContainer(){ + + setup(); + +} + +ofxGuiMenu::ofxGuiMenu(const string &collectionName, const ofJson &config) : + ofxGuiMenu(){ + + setName(collectionName); + _setConfig(config); + +} + +ofxGuiMenu::ofxGuiMenu(string collectionName, string filename, float x, float y) + :ofxGuiMenu(collectionName){ + + this->filename = filename; + setPosition(x,y); + +} + +ofxGuiMenu::ofxGuiMenu(const ofParameterGroup & parameters, const ofJson & config) +:ofxGuiMenu(parameters.getName()){ + + addParametersFrom(parameters); + _setConfig(config); + +} + +ofxGuiMenu::ofxGuiMenu(const ofParameterGroup & parameters, const std::string& filename, float x, float y) + :ofxGuiMenu(parameters.getName()){ + + addParametersFrom(parameters); +// config.filename = filename; + // TODO set filename + setPosition(x,y); + +} + +ofxGuiMenu::~ofxGuiMenu(){ + ofRemoveListener(addedTo, this, &ofxGuiMenu::onAdded); +} + +void ofxGuiMenu::setup(){ + + label = nullptr; + onMenuLabel = false; + rootMenu = false; + changeLabelColor = true; + + setTheme(); + + setConfig(ofJson({ + {"flex-direction", "column"}, + {"direction", "vertical"}, + {"position", "absolute"}, + {"type","fullsize"} + })); + + clear(); + + ofAddListener(addedTo, this, &ofxGuiMenu::onAdded); + + setHidden(true); + +} + +void ofxGuiMenu::generateDraw(){ + + ofxGuiContainer::generateDraw(); + if(label){ + if(rootMenu){ + float paddingTop = ofxDOMLayoutHelper::getPaddingTop(label); + this->setPosition(label->getShape().getBottomLeft()+ofPoint(-5,7)); + }else{ + float paddingTop = ofxDOMLayoutHelper::getPaddingTop(label); + this->setPosition(label->getShape().getTopRight()+ofPoint(5, -4)); + } + } + +} + +void ofxGuiMenu::onAdded(DOM::ElementEventArgs &args){ + + if(ofxGuiContainer* parent = dynamic_cast(args.element())){ + + if(rootMenu){ + label = parent->add( + this->getName()+"-menu", + this->getName(), + ofJson({{"show-name", false}, + {"background-color", "transparent"}, + {"border-width", 0}, + {"width", 50}, + {"height", 50}})); + }else{ + label = parent->add( + this->getName()+"-menu", + this->getName(), + ofJson({{"show-name", false}, + {"border-width", 0}, + {"background-color", "transparent"}})); + } + if(label){ + this->setPosition(label->getShape().getTopRight()); + this->generateDraw(); + } + } +} + +bool ofxGuiMenu::mouseMoved(ofMouseEventArgs & args){ + ofxGuiContainer::mouseMoved(args); + if(label){ + if(label->isMouseOver()){ + if(!onMenuLabel){ + onMenuLabel = true; + if(isHidden()){ + if(changeLabelColor){ + label->setBackgroundColor(label->getTextColor()); + label->setTextColor(label->getTextColor().getInverted()); + } + this->setHidden(false); + } + hideOtherMenusDown(this, nullptr); + if(ofxGuiContainer* parent = dynamic_cast(this->parent())){ + hideOtherMenusUp(parent, this); + } + return true; + } + }else{ + onMenuLabel = false; + } + } + return false; +} + +bool ofxGuiMenu::mousePressed(ofMouseEventArgs & args){ + if(label){ + if(!label->isMouseOver()){ + if(!isMouseOver(this)){ + if(!isHidden()){ + this->setHidden(true); + if(changeLabelColor){ + label->setBackgroundColor(ofColor(0,0,0,0)); + label->setTextColor(label->getTextColor().getInverted()); + } + } + } + hideOtherMenusUpPress(this, this); + } + } + return ofxGuiContainer::mousePressed(args); +} + +bool ofxGuiMenu::isMouseOver(ofxGuiElement* el){ + if(el->isMouseOver()){ + return true; + }else{ + for(DOM::Element* child : el->children()){ + if(ofxGuiElement* _child = dynamic_cast(child)){ + if(isMouseOver(_child)){ + return true; + } + } + } + } + return false; +} + +void ofxGuiMenu::hideOtherMenusUp(DOM::Element* parent, ofxGuiMenu* exception){ + if(parent){ + hideOtherMenusDown(parent, exception); + DOM::Element* nextparent = parent->parent(); + if(nextparent){ + if(ofxGuiMenu* _parent = dynamic_cast(parent)){ + hideOtherMenusUp(nextparent, _parent); + }else{ + hideOtherMenusUp(nextparent, exception); + } + } + } +} + +void ofxGuiMenu::hideOtherMenusDown(DOM::Element* parent, ofxGuiMenu* exception){ + if(parent){ + for(DOM::Element* child : parent->children()){ + if(ofxGuiMenu* menu = dynamic_cast(child)){ + if(menu != exception){ + if(!menu->isHidden()){ + menu->setHidden(true); + if(menu->changeLabelColor){ + menu->label->setBackgroundColor(ofColor(0,0,0,0)); + menu->label->setTextColor(menu->label->getTextColor().getInverted()); + } + } + hideOtherMenusDown(menu, exception); + } + }else{ + hideOtherMenusDown(child, exception); + } + } + } +} + +void ofxGuiMenu::hideOtherMenusUpPress(ofxGuiContainer* parent, ofxGuiMenu* exception){ + if(parent){ + hideOtherMenusDownPress(parent, exception); + if(ofxGuiContainer* nextparent = dynamic_cast(parent->parent())){ + if(ofxGuiMenu* _parent = dynamic_cast(parent)){ + hideOtherMenusUpPress(nextparent, _parent); + } + } + } +} + +void ofxGuiMenu::hideOtherMenusDownPress(ofxGuiContainer* parent, ofxGuiMenu* exception){ + if(parent){ + for(ofxGuiElement* child : parent->getControls()){ + if(ofxGuiMenu* menu = dynamic_cast(child)){ + if(menu != exception){ + if(!isMouseOver(menu) && ! menu->getMenuLabel()->isMouseOver()){ + if(!menu->isHidden()){ + menu->setHidden(true); + if(menu->changeLabelColor){ + menu->label->setBackgroundColor(ofColor(0,0,0,0)); + menu->label->setTextColor(menu->label->getTextColor().getInverted()); + } + } + } + hideOtherMenusDownPress(menu, exception); + } + } + } + } +} + +ofxGuiLabel* ofxGuiMenu::getMenuLabel(){ + return label; +} + +std::string ofxGuiMenu::getClassType(){ + return "menu"; +} + +vector ofxGuiMenu::getClassTypes(){ + vector types = ofxGuiContainer::getClassTypes(); + types.push_back(getClassType()); + return types; +} + +// ROOT MENU + +ofxGuiRootMenu::ofxGuiRootMenu(const std::string &collectionName, const ofJson & config) + :ofxGuiMenu(collectionName, config){ + rootMenu = true; +} + +ofxGuiRootMenu::~ofxGuiRootMenu(){ + +} + +// COLOR MENU + +template +ofxGuiMenuColor_::ofxGuiMenuColor_(ofParameter> &value, const ofJson &config) + :ofxGuiMenu(){ + + changeLabelColor = false; + + setName(value.getName()); + + names.clear(); + names.push_back("r"); + names.push_back("g"); + names.push_back("b"); + names.push_back("a"); + + this->value.makeReferenceTo(value); + this->value.addListener(this, & ofxGuiMenuColor_::changeValue); + + ofColor_ val = value; + ofColor_ min = value.getMin(); + ofColor_ max = value.getMax(); + + for (int i=0; i<4; i++) { + ofParameter p(names[i], val[i], min[i], max[i]); + add>(p); + p.addListener(this, & ofxGuiMenuColor_::changeSlider); + getControl(names[i])->setConfig(ofJson({ + {"fill-color", ofxGui::colorToString(value.get())} + })); + } + + sliderChanging = false; + + _setConfig(config); + +} + + +template +ofxGuiMenuColor_::~ofxGuiMenuColor_(){ + this->value.removeListener(this, & ofxGuiMenuColor_::changeValue); + for (int i=0; i<4; i++){ + getControl(names[i])->getParameter().template cast().removeListener(this, &ofxGuiMenuColor_::changeSlider); + } +} + +template +void ofxGuiMenuColor_::changeSlider(const void * parameter, ColorType & _value){ + sliderChanging = true; + ofParameter & param = *(ofParameter*)parameter; + int i = getControlIndex(param.getName()) - getControlIndex(names[0]); + ofColor_ data = value; + data[i] = _value; + + value = data; + + for (int i=0; i<4; i++){ + getControl(names[i])->setFillColor(value.get()); + } + if(label){ + label->setBackgroundColor(value.get()); + } + sliderChanging = false; +} + +template +void ofxGuiMenuColor_::changeValue(ofColor_ & value){ + if (sliderChanging){ + return; + } + for (int i=0; i<4; i++){ + getControl(names[i])->getParameter().template cast() = value[i]; + getControl(names[i])->setFillColor(value); + } + if(label){ + label->setBackgroundColor(value); + } +} + +template +void ofxGuiMenuColor_::generateDraw(){ + if(label){ + label->setBackgroundColor(value.get()); + } + ofxGuiMenu::generateDraw(); +} + +template +ofAbstractParameter & ofxGuiMenuColor_::getParameter(){ + return value; +} + +template +ofColor_ ofxGuiMenuColor_::operator=(const ofColor_ & v){ + value = v; + return value; +} + +template +ofxGuiMenuColor_::operator const ofColor_ & (){ + return value; +} + +template class ofxGuiMenuColor_; +template class ofxGuiMenuColor_; +template class ofxGuiMenuColor_; + +//VECTOR MENU + +template +ofxGuiMenuVec_::ofxGuiMenuVec_(ofParameter &value, const ofJson & config) +:ofxGuiMenu(){ + + sliderChanging = false; + + setName(value.getName()); + + names.clear(); + names.push_back("x"); + names.push_back("y"); + names.push_back("z"); + names.push_back("w"); + + this->value.makeReferenceTo(value); + this->value.addListener(this, & ofxGuiMenuVec_::changeValue); + + VecType val = value; + VecType min = value.getMin(); + VecType max = value.getMax(); + for (int i=0; i p(names[i], val[i], min[i], max[i]); + add(p); + p.addListener(this, & ofxGuiMenuVec_::changeSlider); + } + + _setConfig(config); + +} + +template +ofxGuiMenuVec_::~ofxGuiMenuVec_(){ + this->value.removeListener(this, & ofxGuiMenuVec_::changeValue); + for (int i=0; igetParameter().template cast().removeListener(this, &ofxGuiMenuVec_::changeSlider); + } +} + +template +void ofxGuiMenuVec_::changeSlider(const void * parameter, float & _value){ + sliderChanging = true; + ofParameter & param = *(ofParameter*)parameter; + int i = getControlIndex(param.getName()) - getControlIndex(names[0]); + VecType data = value; + data[i] = _value; + value = data; + sliderChanging = false; +} + +template +void ofxGuiMenuVec_::changeValue(VecType & value){ + if (sliderChanging){ + return; + } + for (int i=0; igetParameter().template cast() = value[i]; + } +} + +template +ofAbstractParameter & ofxGuiMenuVec_::getParameter(){ + return value; +} + +template +VecType ofxGuiMenuVec_::operator=(const VecType & v){ + value = v; + return value; +} + +template +ofxGuiMenuVec_::operator const VecType & (){ + return value; +} + +template +const VecType * ofxGuiMenuVec_::operator->(){ + return &value.get(); +} + +template class ofxGuiMenuVec_; +template class ofxGuiMenuVec_; +template class ofxGuiMenuVec_; + + +// RECTANGLE MENU + +ofxGuiMenuRectangle::ofxGuiMenuRectangle(ofParameter &value, const ofJson & config) +:ofxGuiMenu(){ + + sliderChanging = false; + + setName(value.getName()); + + names.clear(); + names.push_back("x"); + names.push_back("y"); + names.push_back("width"); + names.push_back("height"); + + this->value.makeReferenceTo(value); + this->value.addListener(this, & ofxGuiMenuRectangle::changeValue); + + ofRectangle val = value; + ofRectangle min = value.getMin(); + ofRectangle max = value.getMax(); + ofParameter px(names[0], val.x, min.x, max.x); + ofParameter py(names[1], val.y, min.y, max.y); + ofParameter pw(names[2], val.width, min.width, max.width); + ofParameter ph(names[3], val.height, min.height, max.height); + add(px); + add(py); + add(pw); + add(ph); + px.addListener(this, & ofxGuiMenuRectangle::changeSlider); + py.addListener(this, & ofxGuiMenuRectangle::changeSlider); + pw.addListener(this, & ofxGuiMenuRectangle::changeSlider); + ph.addListener(this, & ofxGuiMenuRectangle::changeSlider); + + _setConfig(config); + +} + +ofxGuiMenuRectangle::~ofxGuiMenuRectangle(){ + this->value.removeListener(this, & ofxGuiMenuRectangle::changeValue); + for (int i=0; i<4; i++){ + getControl(names[i])->getParameter().template cast().removeListener(this, &ofxGuiMenuRectangle::changeSlider); + } +} + +void ofxGuiMenuRectangle::changeSlider(const void * parameter, float & _value){ + sliderChanging = true; + ofParameter & param = *(ofParameter*)parameter; + int i = getControlIndex(param.getName()) - getControlIndex(names[0]); + ofRectangle data = value; + switch(i){ + case 0: data.x = _value; break; + case 1: data.y = _value; break; + case 2: data.width = _value; break; + case 3: data.height = _value; break; + } + value = data; + sliderChanging = false; +} + +void ofxGuiMenuRectangle::changeValue(ofRectangle & value){ + if (sliderChanging){ + return; + } + getControl("x")->getParameter().template cast() = value.x; + getControl("y")->getParameter().template cast() = value.y; + getControl("width")->getParameter().template cast() = value.width; + getControl("height")->getParameter().template cast() = value.height; +} + +ofAbstractParameter & ofxGuiMenuRectangle::getParameter(){ + return value; +} + +ofRectangle ofxGuiMenuRectangle::operator=(const ofRectangle & v){ + value = v; + return value; +} + +ofxGuiMenuRectangle::operator const ofRectangle & (){ + return value; +} + +const ofRectangle * ofxGuiMenuRectangle::operator->(){ + return &value.get(); +} diff --git a/addons/ofxGui/src/ofxGuiMenu.h b/addons/ofxGui/src/ofxGuiMenu.h new file mode 100644 index 0000000..cb8f892 --- /dev/null +++ b/addons/ofxGui/src/ofxGuiMenu.h @@ -0,0 +1,137 @@ +#pragma once + +#include "ofxGuiContainer.h" + +class ofxGuiMenuLabel : public ofxGuiLabel { + public: + ofxGuiMenuLabel(const std::string& labelName, const std::string & label, const ofJson & config = ofJson()); + ~ofxGuiMenuLabel(){} + protected: + virtual void generateDraw() override; + virtual void render() override; + virtual float getMinWidth() override; + ofPath icon; +}; + +class ofxGuiSubmenuLabel : public ofxGuiMenuLabel { + public: + ofxGuiSubmenuLabel(const std::string& labelName, const std::string & label, const ofJson & config = ofJson()); + ~ofxGuiSubmenuLabel(){} + protected: + virtual void generateDraw() override; +}; + +class ofxGuiMenu : public ofxGuiContainer { + + public: + + ofxGuiMenu(); + ofxGuiMenu(const std::string &collectionName, const ofJson & config = ofJson()); + ofxGuiMenu(std::string collectionName, std::string filename, float x = 10, float y = 10); + ofxGuiMenu(const ofParameterGroup & parameters, const ofJson & config = ofJson()); + ofxGuiMenu(const ofParameterGroup & parameters, const std::string& filename, float x = 10, float y = 10); + ~ofxGuiMenu(); + + void setup(); + + static std::string getClassType(); + + ofxGuiLabel* getMenuLabel(); + ofParameter& isRootMenu(); + + virtual bool mouseMoved(ofMouseEventArgs & args) override; + virtual bool mousePressed(ofMouseEventArgs & args) override; + + protected: + + void hideOtherMenusUp(DOM::Element* parent, ofxGuiMenu* exception); + void hideOtherMenusDown(DOM::Element *parent, ofxGuiMenu* exception); + void hideOtherMenusUpPress(ofxGuiContainer* parent, ofxGuiMenu* exception); + void hideOtherMenusDownPress(ofxGuiContainer *parent, ofxGuiMenu* exception); + bool isMouseOver(ofxGuiElement *el); + + virtual std::vector getClassTypes() override; + + virtual void generateDraw() override; + + void onAdded(DOM::ElementEventArgs& args); + + ofParameter isOpen; + + ofxGuiLabel* label; + + bool onMenuLabel; + bool rootMenu; + bool changeLabelColor; + +}; + +class ofxGuiRootMenu : public ofxGuiMenu { + public: + ofxGuiRootMenu(const std::string &collectionName, const ofJson & config = ofJson()); + ~ofxGuiRootMenu(); +}; + + +template +class ofxGuiMenuColor_: public ofxGuiMenu{ + +public: + ofxGuiMenuColor_(ofParameter> &value, const ofJson & config = ofJson()); + ~ofxGuiMenuColor_(); + + ofAbstractParameter & getParameter(); + + ofColor_ operator=(const ofColor_ & v); + operator const ofColor_ & (); +protected: + virtual void generateDraw() override; + void changeSlider(const void * parameter, ColorType & value); + void changeValue(ofColor_ & value); + ofParameter > value; + bool sliderChanging; + std::vector names; +}; + +template +class ofxGuiMenuVec_ : public ofxGuiMenu { +public: + + ofxGuiMenuVec_(ofParameter &value, const ofJson & config = ofJson()); + ~ofxGuiMenuVec_(); + + void setup(); + + ofAbstractParameter & getParameter(); + + VecType operator=(const VecType & v); + operator const VecType & (); + const VecType * operator->(); +protected: + void changeSlider(const void * parameter, float & value); + void changeValue(VecType & value); + ofParameter value; + bool sliderChanging; + std::vector names; +}; + +class ofxGuiMenuRectangle : public ofxGuiMenu { +public: + + ofxGuiMenuRectangle(ofParameter &value, const ofJson & config = ofJson()); + ~ofxGuiMenuRectangle(); + + void setup(); + + ofAbstractParameter & getParameter(); + + ofRectangle operator=(const ofRectangle & v); + operator const ofRectangle & (); + const ofRectangle * operator->(); +protected: + void changeSlider(const void * parameter, float & value); + void changeValue(ofRectangle & value); + ofParameter value; + bool sliderChanging; + std::vector names; +}; diff --git a/addons/ofxGui/src/ofxGuiPanel.cpp b/addons/ofxGui/src/ofxGuiPanel.cpp new file mode 100644 index 0000000..8e2d563 --- /dev/null +++ b/addons/ofxGui/src/ofxGuiPanel.cpp @@ -0,0 +1,236 @@ +/* + * ofPanel.cpp + * + * Created on: 14/02/2012 + * Author: arturo + */ + +#include "ofxGuiPanel.h" +#include "ofGraphics.h" +using namespace std; + +ofxGuiPanelHeader::ofxGuiPanelHeader():ofxGuiGroupHeader(){ + if(!loadIcon.isAllocated() || !saveIcon.isAllocated()){ + loadIcons(); + } + registerMouseEvents(); + this->setDraggable(true); + setTheme(); +} + +ofxGuiPanelHeader::ofxGuiPanelHeader(const ofJson& config):ofxGuiPanelHeader(){ + _setConfig(config); +} + +void ofxGuiPanelHeader::loadIcons(){ + unsigned char loadIconData[] = {0x38,0x88,0xa,0x6,0x7e,0x60,0x50,0x11,0x1c}; + unsigned char saveIconData[] = {0xff,0x4a,0x95,0xea,0x15,0xa8,0x57,0xa9,0x7f}; + loadIcon.allocate(9, 8, OF_IMAGE_COLOR_ALPHA); + saveIcon.allocate(9, 8, OF_IMAGE_COLOR_ALPHA); + loadStencilFromHex(loadIcon, loadIconData); + loadStencilFromHex(saveIcon, saveIconData); + + loadIcon.getTexture().setTextureMinMagFilter(GL_NEAREST,GL_NEAREST); + saveIcon.getTexture().setTextureMinMagFilter(GL_NEAREST,GL_NEAREST); +} + +void ofxGuiPanelHeader::generateDraw(){ + ofxGuiElement::generateDraw(); + + float iconHeight = getHeight()*.5; + float iconWidth = loadIcon.getWidth()/loadIcon.getHeight()*iconHeight; + int iconSpacing = iconWidth*.5; + + loadBox.x = getWidth() - (iconWidth * 2 + iconSpacing + textPadding); + loadBox.y = getHeight() / 2. - iconHeight / 2.; + loadBox.width = iconWidth; + loadBox.height = iconHeight; + saveBox.set(loadBox); + saveBox.x += iconWidth + iconSpacing; + + ofxGuiGroup* _parent = dynamic_cast(parent()); + if(_parent){ + if(_parent->getShowName()){ + textMesh = getTextMesh(_parent->getName(), textPadding, getHeight() / 2 + 4); + } + } +} + +void ofxGuiPanelHeader::render() { + + ofColor c = ofGetStyle().color; + + ofBlendMode blendMode = ofGetStyle().blendingMode; + if(blendMode!=OF_BLENDMODE_ALPHA){ + ofEnableAlphaBlending(); + } + + ofxGuiElement::render(); + + ofSetColor(textColor); + + ofxGuiGroup* _parent = dynamic_cast(parent()); + if(_parent){ + if(_parent->getShowName()){ + + ofSetColor(textColor); + bindFontTexture(); + textMesh.draw(); + unbindFontTexture(); + + + } + } + + bool texHackEnabled = ofIsTextureEdgeHackEnabled(); + ofDisableTextureEdgeHack(); + loadIcon.draw(loadBox); + saveIcon.draw(saveBox); + if(texHackEnabled){ + ofEnableTextureEdgeHack(); + } + + ofSetColor(c); + if(blendMode!=OF_BLENDMODE_ALPHA){ + ofEnableBlendMode(blendMode); + } +} + +bool ofxGuiPanelHeader::mousePressed(ofMouseEventArgs & args){ + + if(!isHidden()){ + ofPoint pos = screenToLocal(ofPoint(args.x, args.y)); + if(loadBox.inside(pos)){ + ofNotifyEvent(loadPressedE,this); + return true; + } + if(saveBox.inside(pos)) { + ofNotifyEvent(savePressedE,this); + return true; + } + + } + + return ofxGuiElement::mousePressed(args); + +} + +float ofxGuiPanelHeader::getMinWidth(){ + generateDraw(); + std::string text = ""; + + ofxGuiGroup* _parent = dynamic_cast(parent()); + if(_parent){ + if(_parent->getShowName()){ + text += _parent->getName(); + } + } + + return getTextWidth(text)+loadBox.width+saveBox.width+4*textPadding; +} + +std::string ofxGuiPanelHeader::getClassType(){ + return "panel-header"; +} + +vector ofxGuiPanelHeader::getClassTypes(){ + vector types = ofxGuiGroupHeader::getClassTypes(); + types.push_back(getClassType()); + return types; +} + + +/* + * Panel + */ + +ofxGuiPanel::ofxGuiPanel(const string &collectionName) + :ofxGuiGroup(){ + + setup(); + setName(collectionName); + +} + +ofxGuiPanel::ofxGuiPanel(const string &collectionName, const ofJson & config) + :ofxGuiPanel(collectionName){ + + _setConfig(config); + +} + +ofxGuiPanel::ofxGuiPanel(const ofParameterGroup & parameters, const ofJson & config) +:ofxGuiPanel(parameters.getName()){ + + addParametersFrom(parameters); + _setConfig(config); + +} + +ofxGuiPanel::ofxGuiPanel(const std::string& collectionName, const std::string& filename, float x, float y) + :ofxGuiPanel(collectionName){ + + // TODO set filename + setPosition(x,y); + +} + +ofxGuiPanel::ofxGuiPanel(const ofParameterGroup & parameters, const std::string& filename, float x, float y) + :ofxGuiPanel(parameters.getName()){ + + addParametersFrom(parameters); +// config.filename = filename; + // TODO set filename + setPosition(x,y); + +} + +ofxGuiPanel::~ofxGuiPanel(){ + + ofRemoveListener(header->move, this, &ofxGuiPanel::onHeaderMove); + ofRemoveListener(((ofxGuiPanelHeader*)header)->loadPressedE, this, &ofxGuiPanel::onLoadPressed); + ofRemoveListener(((ofxGuiPanelHeader*)header)->savePressedE, this, &ofxGuiPanel::onSavePressed); + +} + +void ofxGuiPanel::setup(){ + + if(header){ + removeChild(header); + } + header = add(ofJson({{"margin", 0}})); + getHeader()->setHidden(!showHeader.get()); + + setTheme(); + + ofAddListener(header->move, this, &ofxGuiPanel::onHeaderMove); + ofAddListener(((ofxGuiPanelHeader*)header)->loadPressedE, this, &ofxGuiPanel::onLoadPressed); + ofAddListener(((ofxGuiPanelHeader*)header)->savePressedE, this, &ofxGuiPanel::onSavePressed); + +} + +void ofxGuiPanel::onHeaderMove(DOM::MoveEventArgs &args){ + ofPoint screenHeaderPos = localToScreen(args.position()); + ofPoint screenThisPos = getScreenPosition(); + ofPoint diff = screenHeaderPos-screenThisPos; + setPosition(getPosition()+diff); + invalidateChildShape(); +} + +void ofxGuiPanel::onLoadPressed(){ + loadFromFile(filename); +} + +void ofxGuiPanel::onSavePressed(){ + saveToFile(filename); +} + +std::string ofxGuiPanel::getClassType(){ + return "panel"; +} + +vector ofxGuiPanel::getClassTypes(){ + vector types = ofxGuiGroup::getClassTypes(); + types.push_back(getClassType()); + return types; +} diff --git a/addons/ofxGui/src/ofxGuiPanel.h b/addons/ofxGui/src/ofxGuiPanel.h new file mode 100644 index 0000000..04eb084 --- /dev/null +++ b/addons/ofxGui/src/ofxGuiPanel.h @@ -0,0 +1,68 @@ +#pragma once + +#include "ofxGuiGroup.h" +#include "ofImage.h" + +class ofxGuiGroup; + +class ofxGuiPanelHeader : public ofxGuiGroupHeader { + + public: + + ofxGuiPanelHeader(); + ofxGuiPanelHeader(const ofJson &config); + + ~ofxGuiPanelHeader(){ + } + + virtual float getMinWidth() override; + + virtual bool mousePressed(ofMouseEventArgs & args) override; + + ofEvent loadPressedE; + ofEvent savePressedE; + + static std::string getClassType(); + + protected: + + virtual std::vector getClassTypes() override; + + virtual void generateDraw() override; + virtual void render() override; + virtual void loadIcons(); + + ofRectangle loadBox, saveBox; + ofImage loadIcon; + ofImage saveIcon; + +}; + +class ofxGuiPanel : public ofxGuiGroup { + + public: + + ofxGuiPanel(const std::string& collectionName=""); + ofxGuiPanel(const std::string& collectionName, const ofJson & config); + ofxGuiPanel(const ofParameterGroup & parameters, const ofJson & config = ofJson()); + ofxGuiPanel(const std::string& collectionName, const std::string& filename, float x = 10, float y = 10); + ofxGuiPanel(const ofParameterGroup & parameters, const std::string& filename, float x = 10, float y = 10); + + ~ofxGuiPanel(); + + void setup(); + + void onHeaderMove(DOM::MoveEventArgs& args); + void onLoadPressed(); + void onSavePressed(); + + static std::string getClassType(); + + protected: + virtual std::vector getClassTypes() override; + + private: + + bool headerListenersLoaded; + +}; diff --git a/addons/ofxGui/src/ofxGuiRangeSlider.cpp b/addons/ofxGui/src/ofxGuiRangeSlider.cpp new file mode 100644 index 0000000..f38e237 --- /dev/null +++ b/addons/ofxGui/src/ofxGuiRangeSlider.cpp @@ -0,0 +1,338 @@ +#include "ofxGuiRangeSlider.h" +#include "JsonConfigParser.h" +#include "ofGraphics.h" +using namespace std; + + +template +ofxGuiRangeSlider::ofxGuiRangeSlider() + :ofxGuiSlider(){ + + setup(); + +} + +template +ofxGuiRangeSlider::ofxGuiRangeSlider(const ofJson &config) + :ofxGuiRangeSlider(){ + + this->_setConfig(config); + +} + +template +ofxGuiRangeSlider::ofxGuiRangeSlider(ofParameter& _valStart, ofParameter &_valEnd, const ofJson &config) +:ofxGuiSlider(){ + + valueStart.makeReferenceTo(_valStart); + valueEnd.makeReferenceTo(_valEnd); + setup(); + valueStart.addListener(this,&ofxGuiRangeSlider::valueStartChanged); + valueEnd.addListener(this,&ofxGuiRangeSlider::valueEndChanged); + this->_setConfig(config); + +} + +template +ofxGuiRangeSlider::ofxGuiRangeSlider(const std::string& sliderName, DataType _valStart, DataType _valEnd, DataType _min, DataType _max, const ofJson &config) + :ofxGuiRangeSlider(config){ + + valueStart.set(sliderName,_valStart,_min,_valEnd); + valueEnd.set(sliderName,_valEnd,_valStart,_max); + valueStart.addListener(this,&ofxGuiRangeSlider::valueStartChanged); + valueEnd.addListener(this,&ofxGuiRangeSlider::valueEndChanged); + +} + +template +ofxGuiRangeSlider::~ofxGuiRangeSlider(){ + + valueStart.removeListener(this,&ofxGuiRangeSlider::valueStartChanged); + valueEnd.removeListener(this,&ofxGuiRangeSlider::valueEndChanged); + +} + +template +void ofxGuiRangeSlider::setup(){ + + activeValue = nullptr; + + values.add(valueStart); + values.add(valueEnd); + values.setName(valueStart.getName()); + + valueEnd.setMin(valueStart.get()); + valueEnd.setMax(valueStart.getMax()); + valueStart.setMax(valueEnd.get()); + + this->hasFocus = false; + this->showValue.set("show-value", true); + this->updateOnReleaseOnly.set("update-on-release-only", false); + this->precision.set("precision", 6); + this->horizontal = this->getWidth() > this->getHeight(); + + this->setTheme(); + + this->registerMouseEvents(); + +} + +template +void ofxGuiRangeSlider::setMin(DataType min){ + valueStart.setMin(min); +} + +template +DataType ofxGuiRangeSlider::getMin(){ + return valueStart.getMin(); +} + +template +void ofxGuiRangeSlider::setMax(DataType max){ + valueEnd.setMax(max); +} + +template +DataType ofxGuiRangeSlider::getMax(){ + return valueEnd.getMax(); +} + +template +bool ofxGuiRangeSlider::mouseReleased(ofMouseEventArgs & args){ + + bool res = ofxGuiSlider::mouseReleased(args); + + activeValue = nullptr; + + return res; + +} + +template +void ofxGuiRangeSlider::generateDraw(){ + + ofxGuiSlider::generateDraw(); + + this->bar.clear(); + float valStartAsPct, valEndAsPct; + if(this->horizontal){ + valStartAsPct = ofMap(valueStart, getMin(), getMax(), 0, this->getWidth()-this->borderWidth*2, true); + valEndAsPct = ofMap(valueEnd, getMin(), getMax(), 0, this->getWidth()-this->borderWidth*2, true); + }else{ + valStartAsPct = ofMap(valueStart, getMin(), getMax(), 0, this->getHeight()-this->borderWidth*2, true); + valEndAsPct = ofMap(valueEnd, getMin(), getMax(), 0, this->getHeight()-this->borderWidth*2, true); + } + if(valStartAsPct-valEndAsPct<0.01){ + valEndAsPct++; + } + this->bar.setFillColor(this->fillColor); + this->bar.setFilled(true); + if(this->horizontal){ + this->bar.rectRounded(this->borderWidth+valStartAsPct,this->borderWidth, valEndAsPct-valStartAsPct, this->getHeight()-this->borderWidth*2, this->borderRadius); + }else{ + this->bar.rectRounded(this->borderWidth, this->getHeight() - valEndAsPct-this->borderWidth, this->getWidth()-this->borderWidth*2, valEndAsPct-valStartAsPct, this->borderRadius); + } + + generateText(); +} + + +template +void ofxGuiRangeSlider::generateText(){ + + string valStr = ofToString(valueStart.get(), this->precision) + " - " + + ofToString(valueEnd.get(), this->precision); + this->_generateText(valStr); +} + +template<> +void ofxGuiRangeSlider::generateText(){ + + string valStr = ofToString((int)valueStart, precision) + " - " + + ofToString((int)valueEnd, precision); + this->_generateText(valStr); +} + +template +void ofxGuiRangeSlider::_generateText(std::string valStr){ + + if(this->horizontal){ + this->textMesh.clear(); + if(this->showName){ + this->textMesh.append(this->getTextMesh(this->getName(), ofPoint(this->textPadding, this->getHeight() / 2 + 4))); + } + if(this->showValue){ + this->textMesh.append(this->getTextMesh(valStr, this->getShape().getWidth() - this->textPadding + - this->getTextBoundingBox(valStr,0,0).width, this->getHeight() / 2 + 4)); + } + }else{ + this->textMesh.clear(); + if(this->showName){ + string nameStr = this->getName(); + while(this->getTextBoundingBox(nameStr, 0, 0).getWidth() + this->textPadding * 2 > this->getWidth() && nameStr.length() > 1){ + nameStr = nameStr.substr(0, nameStr.size() - 1); + } + this->textMesh.append(this->getTextMesh(nameStr, this->textPadding, this->textPadding + this->getTextBoundingBox(nameStr, 0, 0).height)); + } + if(this->showValue){ + while(this->getTextBoundingBox(valStr, 0, 0).getWidth() + this->textPadding * 2 > this->getWidth() && valStr.length() > 1){ + valStr = valStr.substr(0, valStr.size() - 1); + } + this->textMesh.append(this->getTextMesh(valStr, this->textPadding, this->getHeight() - this->textPadding)); + } + } +} + +template +void ofxGuiRangeSlider::render(){ + ofColor c = ofGetStyle().color; + + ofxGuiElement::render(); + + this->bar.draw(); + +// if(showName){ + ofBlendMode blendMode = ofGetStyle().blendingMode; + if(blendMode!=OF_BLENDMODE_ALPHA){ + ofEnableAlphaBlending(); + } + ofSetColor(this->textColor); + + this->bindFontTexture(); + this->textMesh.draw(); + this->unbindFontTexture(); + + ofSetColor(c); + if(blendMode!=OF_BLENDMODE_ALPHA){ + ofEnableBlendMode(blendMode); + } +// } +} + + +template +bool ofxGuiRangeSlider::setValue(float mx, float my, bool bCheck){ + + if(this->isHidden()){ + this->hasFocus = false; + return false; + } + + if(bCheck){ + this->hasFocus = this->isMouseOver(); + } + + if(this->hasFocus){ + + ofPoint topleft = this->localToScreen(ofPoint(0, 0)); + ofPoint bottomright = this->localToScreen(ofPoint(this->getWidth(), this->getHeight())); + + if(!activeValue){ + DataType valStartX = ofMap(valueStart, getMin(), getMax(), topleft.x, bottomright.x, true); + DataType valEndX = ofMap(valueEnd, getMin(), getMax(), topleft.x, bottomright.x, true); + if(abs(valStartX-mx) > abs(valEndX-mx)){ + //closer to end marker + activeValue = &valueEnd; + }else{ + if(abs(valStartX-mx) < abs(valEndX-mx)){ + //closer to start marker + activeValue = &valueStart; + }else{ + if(mx > valStartX){ + activeValue = &valueEnd; + }else { + activeValue = &valueStart; + } + } + } + } + + DataType newval; + if(this->horizontal){ + newval = ofMap(mx, topleft.x, bottomright.x, getMin(), getMax(), true); + }else{ + newval = ofMap(my, bottomright.y, topleft.y, getMin(), getMax(), true); + } + if(newval > activeValue->getMax()){ + newval = activeValue->getMax(); + }else{ + if(newval < activeValue->getMin()){ + newval = activeValue->getMin(); + } + } + activeValue->set(newval); + return true; + + } + + return false; +} + +template +ofAbstractParameter & ofxGuiRangeSlider::getParameter(){ + return values; +} + +template +void ofxGuiRangeSlider::valueStartChanged(DataType & value){ + valueEnd.setMin(value); + this->setNeedsRedraw(); +} + +template +void ofxGuiRangeSlider::valueEndChanged(DataType & value){ + valueStart.setMax(value); + this->setNeedsRedraw(); +} + +template +std::string ofxGuiRangeSlider::getText(){ + + string res = ""; + if(this->showName){ + res += this->getName(); + } + res += ofToString(valueStart.get(), this->precision); + res += " - "; + res += ofToString(valueEnd.get(), this->precision); + + return res; + +} + +template<> +std::string ofxGuiRangeSlider::getText(){ + + string res = ""; + if(showName){ + res += getName(); + } + res += ofToString((int)valueStart, precision); + res += " - "; + res += ofToString((int)valueEnd, precision); + + return res; +} + +template +std::string ofxGuiRangeSlider::getClassType(){ + return "rangeslider"; +} + +template +vector ofxGuiRangeSlider::getClassTypes(){ + vector types = ofxGuiSlider::getClassTypes(); + types.push_back(getClassType()); + return types; +} + +template class ofxGuiRangeSlider; +template class ofxGuiRangeSlider; +template class ofxGuiRangeSlider; +template class ofxGuiRangeSlider; +template class ofxGuiRangeSlider; +template class ofxGuiRangeSlider; +template class ofxGuiRangeSlider; +template class ofxGuiRangeSlider; +template class ofxGuiRangeSlider; +template class ofxGuiRangeSlider; diff --git a/addons/ofxGui/src/ofxGuiRangeSlider.h b/addons/ofxGui/src/ofxGuiRangeSlider.h new file mode 100644 index 0000000..33afd33 --- /dev/null +++ b/addons/ofxGui/src/ofxGuiRangeSlider.h @@ -0,0 +1,71 @@ +#pragma once + +#include "ofxGuiSlider.h" +#include "ofParameter.h" + +template +class ofxGuiRangeSlider : public ofxGuiSlider { +public: + + ofxGuiRangeSlider(); + ofxGuiRangeSlider(const ofJson & config); + ofxGuiRangeSlider(ofParameter& _valStart, ofParameter& _valEnd, const ofJson & config = ofJson()); + ofxGuiRangeSlider(const std::string& sliderName, DataType _valStart, DataType _valEnd, DataType _min, DataType _max, const ofJson & config = ofJson()); + + ~ofxGuiRangeSlider(); + + void setMin(DataType min); + DataType getMin(); + void setMax(DataType max); + DataType getMax(); + + virtual bool mouseReleased(ofMouseEventArgs & args) override; + + template + void addListenerStart(ListenerClass * listener, ListenerMethod method){ + valueStart.addListener(listener,method); + } + + template + void addListenerEnd(ListenerClass * listener, ListenerMethod method){ + valueEnd.addListener(listener,method); + } + + template + void removeListenerStart(ListenerClass * listener, ListenerMethod method){ + valueStart.removeListener(listener,method); + } + + template + void removeListenerEnd(ListenerClass * listener, ListenerMethod method){ + valueEnd.removeListener(listener,method); + } + + ofAbstractParameter & getParameter() override; + + static std::string getClassType(); + +protected: + + void setup(); + + virtual std::vector getClassTypes() override; + + virtual void render() override; + + ofParameter valueStart,valueEnd; + ofParameterGroup values; + virtual bool setValue(float mx, float my, bool bCheck) override; + virtual void generateDraw() override; + virtual void generateText() override; + virtual void _generateText(std::string valStr) override; + void valueStartChanged(DataType & value); + void valueEndChanged(DataType & value); + virtual std::string getText(); + + ofParameter *activeValue; + +}; + +typedef ofxGuiRangeSlider ofxGuiFloatRangeSlider; +typedef ofxGuiRangeSlider ofxGuiIntRangeSlider; diff --git a/addons/ofxGui/src/ofxGuiSlider.cpp b/addons/ofxGui/src/ofxGuiSlider.cpp new file mode 100644 index 0000000..f592864 --- /dev/null +++ b/addons/ofxGui/src/ofxGuiSlider.cpp @@ -0,0 +1,526 @@ +#include "ofxGuiSlider.h" +#include "JsonConfigParser.h" +#include "ofGraphics.h" +using namespace std; + + +template +ofxGuiSlider::ofxGuiSlider() + :ofxGuiElement(){ +} + +template +ofxGuiSlider::ofxGuiSlider(const ofJson &config) + :ofxGuiSlider(){ + + setup(); + _setConfig(config); + +} + +template +ofxGuiSlider::ofxGuiSlider(ofParameter& _val, const ofJson &config) +:ofxGuiElement(){ + + value.makeReferenceTo(_val); + value.addListener(this,&ofxGuiSlider::valueChanged); + setup(); + _setConfig(config); + +} + +template +ofxGuiSlider::ofxGuiSlider(const std::string& sliderName, DataType _val, DataType _min, DataType _max, const ofJson &config) + :ofxGuiSlider(config){ + + value.set(sliderName,_val,_min,_max); + value.addListener(this,&ofxGuiSlider::valueChanged); + +} + +template +ofxGuiSlider::~ofxGuiSlider(){ + + value.removeListener(this,&ofxGuiSlider::valueChanged); + ofRemoveListener(resize, this, &ofxGuiSlider::resized); + +} + +template +void ofxGuiSlider::setup(){ + + hasFocus = false; + showValue.set("show-value", true); + updateOnReleaseOnly.set("update-on-release-only", false); + precision.set("precision", 6); + type.set("type", ofxGuiSliderType::STRAIGHT); + horizontal = getWidth() > getHeight(); + + setTheme(); + + ofAddListener(resize, this, &ofxGuiSlider::resized); + registerMouseEvents(); + +} + +template +void ofxGuiSlider::_setConfig(const ofJson &config){ + + ofxGuiElement::_setConfig(config); + + JsonConfigParser::parse(config, updateOnReleaseOnly); + JsonConfigParser::parse(config, precision); + JsonConfigParser::parse(config, showValue); + + if (config.find(type.getName()) != config.end()) { + std::string val = config[type.getName()]; + setType(val); + } + + +} + +template +void ofxGuiSlider::setMin(DataType min){ + value.setMin(min); +} + +template +DataType ofxGuiSlider::getMin(){ + return value.getMin(); +} + +template +void ofxGuiSlider::setMax(DataType max){ + value.setMax(max); +} + +template +DataType ofxGuiSlider::getMax(){ + return value.getMax(); +} + +template +void ofxGuiSlider::setType(const std::string& type){ + if(type == "circular"){ + setType(ofxGuiSliderType::CIRCULAR); + } + else{ + setType(ofxGuiSliderType::STRAIGHT); + } +} + +template +void ofxGuiSlider::setType(const ofxGuiSliderType::Type& type){ + this->type.set(type); + setNeedsRedraw(); +} + +template +ofxGuiSliderType::Type ofxGuiSlider::getType(){ + return type; +} + + +template +void ofxGuiSlider::resized(DOM::ResizeEventArgs &){ + horizontal = getWidth() > getHeight(); +} + +template +void ofxGuiSlider::setPrecision(int precision){ + individualConfig[this->precision.getName()] = precision; + this->precision = precision; +} + +template +bool ofxGuiSlider::mousePressed(ofMouseEventArgs & args){ + + ofxGuiElement::mousePressed(args); + + if((type == ofxGuiSliderType::CIRCULAR) && isMouseOver()){ + + ofPoint pos = screenToLocal(ofPoint(args.x, args.y)); + + DataType firstClickVal = ofMap(pos.y, getShape().getHeight(), 0, 0, 1, true); + DataType lastVal = ofMap(value, value.getMin(), value.getMax(), 0, 1, true); + _mouseOffset = (firstClickVal - lastVal) * getShape().height; + + } + + if(updateOnReleaseOnly){ + value.disableEvents(); + } + return setValue(args.x, args.y, true); + +} + +template +bool ofxGuiSlider::mouseDragged(ofMouseEventArgs & args){ + + ofxGuiElement::mouseDragged(args); + + return setValue(args.x, args.y, false); + +} + +template +bool ofxGuiSlider::mouseReleased(ofMouseEventArgs & args){ + + ofxGuiElement::mouseReleased(args); + + if(updateOnReleaseOnly){ + value.enableEvents(); + } + bool attended = setValue(args.x, args.y, false); + hasFocus = false; + return attended; + +} + +template +typename std::enable_if::value, DataType>::type +getRange(DataType min, DataType max, float width){ + double range = max - min; + range /= width*4; + return std::max(range,1.0); +} + +template +typename std::enable_if::value, DataType>::type +getRange(DataType min, DataType max, float width){ + double range = max - min; + range /= width*4; + return range; +} + +template +bool ofxGuiSlider::mouseScrolled(ofMouseEventArgs & args){ + + ofxGuiElement::mouseScrolled(args); + + if(isMouseOver()){ + if(args.scrollY>0 || args.scrollY<0){ + double range = getRange(value.getMin(),value.getMax(), getWidth()); + DataType newValue = value + ofMap(args.scrollY,-1,1,-range, range); + newValue = ofClamp(newValue,value.getMin(),value.getMax()); + value = newValue; + } + return true; + }else{ + return false; + } +} + +template +double ofxGuiSlider::operator=(DataType v){ + value = v; + return v; +} + +template +ofxGuiSlider::operator const DataType & (){ + return value; +} + +template +void ofxGuiSlider::generateDraw(){ + + if(type == ofxGuiSliderType::STRAIGHT){ + + horizontal = getWidth() > getHeight(); + + ofxGuiElement::generateDraw(); + + bar.clear(); + + float valAsPct; + if(horizontal){ + valAsPct = ofMap(value, value.getMin(), value.getMax(), 0, getWidth()-borderWidth*2, true); + }else{ + valAsPct = ofMap(value, value.getMin(), value.getMax(), 0, getHeight()-borderWidth*2, true); + } + bar.setFillColor(fillColor); + bar.setFilled(true); + if(horizontal){ + bar.rectRounded(borderWidth,borderWidth, valAsPct, getHeight()-borderWidth*2, borderRadius); + }else{ + bar.rectRounded(borderWidth, getHeight() - valAsPct-borderWidth, getWidth()-borderWidth*2, valAsPct, borderRadius); + } + + } + if(type == ofxGuiSliderType::CIRCULAR){ + + ofPoint center = ofPoint(getWidth()/2, getHeight()/2); + if(showName){ + center.y -= getTextHeight(getName()); + } + float radius = min(center.x, center.y)-borderWidth; + float inner_r = radius / 3; + float outer_r = radius-1; + + bg.clear(); + bar.clear(); + + bg.setStrokeColor(borderColor); + bg.setStrokeWidth(1); + bg.setFillColor(backgroundColor); + bg.setFilled(true); + arcStrip(bg, center, outer_r-1, inner_r+1, 1); + + float val = ofMap(value, value.getMin(), value.getMax(), 0, 1); + bar.setFillColor(fillColor); + bar.setFilled(true); + arcStrip(bar, center, outer_r - 1, inner_r + 1, val); + + } + + generateText(); +} + + +template +void ofxGuiSlider::generateText(){ + + string valStr = ofToString(value.get(), precision); + _generateText(valStr); +} + +template<> +void ofxGuiSlider::generateText(){ + + string valStr = ofToString((int)value, precision); + _generateText(valStr); +} + +template +void ofxGuiSlider::_generateText(std::string valStr){ + + if(type == ofxGuiSliderType::STRAIGHT){ + + if(horizontal){ + textMesh.clear(); + if(showName){ + textMesh.append(getTextMesh(getName(), ofPoint(textPadding, getHeight() / 2 + 4))); + } + if(showValue){ + textMesh.append(getTextMesh(valStr, getShape().getWidth() - textPadding - getTextBoundingBox(valStr,0,0).width, getHeight() / 2 + 4)); + } + }else{ + textMesh.clear(); + if(showName){ + string nameStr = getName(); + while(getTextBoundingBox(nameStr, 0, 0).getWidth() + textPadding * 2 > getWidth() && nameStr.length() > 1){ + nameStr = nameStr.substr(0, nameStr.size() - 1); + } + textMesh.append(getTextMesh(nameStr, textPadding, textPadding + getTextBoundingBox(nameStr, 0, 0).height)); + } + if(showValue){ + while(getTextBoundingBox(valStr, 0, 0).getWidth() + textPadding * 2 > getWidth() && valStr.length() > 1){ + valStr = valStr.substr(0, valStr.size() - 1); + } + textMesh.append(getTextMesh(valStr, textPadding, getHeight() - textPadding)); + } + } + } + if(type == ofxGuiSliderType::CIRCULAR){ + + textMesh.clear(); + if(showName){ + textMesh.append(getTextMesh(getName(), textPadding, getShape().height - textPadding)); + } + if(showValue){ + textMesh.append(getTextMesh(valStr, getShape().width - textPadding - getTextBoundingBox(valStr, 0, 0).width, getShape().height - textPadding)); + } + + } +} + +template +void ofxGuiSlider::render(){ + ofColor c = ofGetStyle().color; + + ofxGuiElement::render(); + + bar.draw(); + +// if(showName){ + ofBlendMode blendMode = ofGetStyle().blendingMode; + if(blendMode!=OF_BLENDMODE_ALPHA){ + ofEnableAlphaBlending(); + } + ofSetColor(textColor); + + bindFontTexture(); + textMesh.draw(); + unbindFontTexture(); + + ofSetColor(c); + if(blendMode!=OF_BLENDMODE_ALPHA){ + ofEnableBlendMode(blendMode); + } +// } +} + + +template +bool ofxGuiSlider::setValue(float mx, float my, bool bCheck){ + + if(isHidden()){ + hasFocus = false; + return false; + } + + if(bCheck){ + hasFocus = isMouseOver(); + } + + if(hasFocus){ + + if(type == ofxGuiSliderType::STRAIGHT){ + + ofPoint topleft = localToScreen(ofPoint(0, 0)); + ofPoint bottomright = localToScreen(ofPoint(getWidth(), getHeight())); + if(horizontal){ + value = ofMap(mx, topleft.x, bottomright.x, value.getMin(), value.getMax(), true); + }else{ + value = ofMap(my, bottomright.y, topleft.y, value.getMin(), value.getMax(), true); + } + return true; + + } + if(type == ofxGuiSliderType::CIRCULAR){ + + ofPoint pos = screenToLocal(ofPoint(mx,my)); + + DataType res = ofMap(pos.y, + getHeight() - _mouseOffset, + - _mouseOffset, + value.getMin(), + value.getMax(), + true); + value.set(res); + return true; + + } + + } + + return false; +} + +template +ofAbstractParameter & ofxGuiSlider::getParameter(){ + return value; +} + +template +void ofxGuiSlider::valueChanged(DataType & value){ + setNeedsRedraw(); +} + +template +std::string ofxGuiSlider::getText(){ + + string res = ""; + if(type == ofxGuiSliderType::STRAIGHT){ + if(showName){ + res += getName(); + } + res += ofToString(value.get(), precision); + } + + return res; + +} + +template<> +std::string ofxGuiSlider::getText(){ + + string res = ""; + if(type == ofxGuiSliderType::STRAIGHT){ + if(showName){ + res += getName(); + } + res += ofToString((int)value, precision); + } + + return res; +} + +template +float ofxGuiSlider::getMinWidth(){ + return ofxGuiElement::getTextWidth(getText()); +} + +template +float ofxGuiSlider::getMinHeight(){ + return ofxGuiElement::getTextHeight(getText()); +} + +/* + * adapted from ofxUI by Reza Ali (www.syedrezaali.com || syed.reza.ali@gmail.com || @rezaali) + * + */ +template +void ofxGuiSlider ::arcStrip(ofPath & path, ofPoint center, float outer_radius, float inner_radius, float percent){ + float theta = ofMap(percent, 0, 1, 0, 360.0, true); + + { + float x = sin(-ofDegToRad(0)); + float y = cos(-ofDegToRad(0)); + path.moveTo(center.x + outer_radius * x, center.y + outer_radius * y); + } + + for(int i = 0; i <= theta; i += 10){ + float x = sin(-ofDegToRad(i)); + float y = cos(-ofDegToRad(i)); + + path.lineTo(center.x + outer_radius * x, center.y + outer_radius * y); + } + + { + float x = sin(-ofDegToRad(theta)); + float y = cos(-ofDegToRad(theta)); + path.lineTo(center.x + outer_radius * x, center.y + outer_radius * y); + path.lineTo(center.x + inner_radius * x, center.y + inner_radius * y); + } + + for(int i = theta; i >= 0; i -= 10){ + float x = sin(-ofDegToRad(i)); + float y = cos(-ofDegToRad(i)); + + path.lineTo(center.x + inner_radius * x, center.y + inner_radius * y); + } + + { + float x = sin(-ofDegToRad(0)); + float y = cos(-ofDegToRad(0)); + path.lineTo(center.x + inner_radius * x, center.y + inner_radius * y); + } + + path.close(); +} + +template +std::string ofxGuiSlider::getClassType(){ + return "slider"; +} + +template +vector ofxGuiSlider::getClassTypes(){ + vector types = ofxGuiElement::getClassTypes(); + types.push_back(getClassType()); + return types; +} + +template class ofxGuiSlider; +template class ofxGuiSlider; +template class ofxGuiSlider; +template class ofxGuiSlider; +template class ofxGuiSlider; +template class ofxGuiSlider; +template class ofxGuiSlider; +template class ofxGuiSlider; +template class ofxGuiSlider; +template class ofxGuiSlider; diff --git a/addons/ofxGui/src/ofxGuiSlider.h b/addons/ofxGui/src/ofxGuiSlider.h new file mode 100644 index 0000000..ca9ee37 --- /dev/null +++ b/addons/ofxGui/src/ofxGuiSlider.h @@ -0,0 +1,103 @@ +#pragma once + +#include "ofxGuiElement.h" +#include "ofParameter.h" + +class ofxGuiSliderType{ + public: + enum Type{ + /// \brief Default. Shows slider as a vertical or horizontal bar. + STRAIGHT, + /// \brief Displays circular slider. + CIRCULAR + }; +}; + +template +class ofxGuiSlider : public ofxGuiElement, public ofxGuiSliderType{ +public: + + ofxGuiSlider(); + ofxGuiSlider(const ofJson & config); + ofxGuiSlider(ofParameter& _val, const ofJson & config = ofJson()); + ofxGuiSlider(const std::string& sliderName, DataType _val, DataType _min, DataType _max, const ofJson & config = ofJson()); + + ~ofxGuiSlider(); + + void setMin(DataType min); + DataType getMin(); + void setMax(DataType max); + DataType getMax(); + + void setType(const std::string &type); + void setType(const Type &type); + Type getType(); + + virtual float getMinWidth() override; + virtual float getMinHeight() override; + + void setPrecision(int precision); + + void setUpdateOnReleaseOnly(bool bUpdateOnReleaseOnly); + + virtual bool mousePressed(ofMouseEventArgs & args) override; + virtual bool mouseDragged(ofMouseEventArgs & args) override; + virtual bool mouseReleased(ofMouseEventArgs & args) override; + virtual bool mouseScrolled(ofMouseEventArgs & args) override; + + template + void addListener(ListenerClass * listener, ListenerMethod method){ + value.addListener(listener,method); + } + + template + void removeListener(ListenerClass * listener, ListenerMethod method){ + value.removeListener(listener,method); + } + + double operator=(DataType v); + operator const DataType & (); + + ofAbstractParameter & getParameter() override; + + static std::string getClassType(); + +protected: + + void setup(); + + virtual std::vector getClassTypes() override; + + virtual void _setConfig(const ofJson & config) override; + virtual void render() override; + + virtual void resized(DOM::ResizeEventArgs&); + + ofParameter value; + ofParameter type; + virtual bool setValue(float mx, float my, bool bCheck) override; + virtual void generateDraw() override; + virtual void generateText(); + virtual void _generateText(std::string valStr); + void valueChanged(DataType & value); + virtual std::string getText(); + ofPath bar; + ofVboMesh textMesh; + + ofParameter updateOnReleaseOnly; + ofParameter showValue; + ofParameter precision; + /// \brief The Slider orientation. + bool horizontal; + + bool hasFocus; + + //circular type + void arcStrip(ofPath & path, ofPoint center, float outer_radius, float inner_radius, float percent); + float _mouseOffset; + + +}; + +typedef ofxGuiSlider ofxGuiFloatSlider; +typedef ofxGuiSlider ofxGuiIntSlider; diff --git a/addons/ofxGui/src/ofxGuiSliderGroup.cpp b/addons/ofxGui/src/ofxGuiSliderGroup.cpp new file mode 100644 index 0000000..cf04106 --- /dev/null +++ b/addons/ofxGui/src/ofxGuiSliderGroup.cpp @@ -0,0 +1,416 @@ +#include "ofxGuiExtended.h" +#include "ofxGuiSliderGroup.h" +#include "JsonConfigParser.h" +using namespace std; + +template +ofxGuiVecSlider_::ofxGuiVecSlider_() + :ofxGuiGroup(){ + + setup(); + +} + +template +ofxGuiVecSlider_::ofxGuiVecSlider_(const ofJson &config) + :ofxGuiVecSlider_(){ + + _setConfig(config); + +} + +template +ofxGuiVecSlider_::ofxGuiVecSlider_(ofParameter &value, const ofJson & config) +:ofxGuiVecSlider_(){ + + setName(value.getName()); + + names.clear(); + names.push_back("x"); + names.push_back("y"); + names.push_back("z"); + names.push_back("w"); + + this->value.makeReferenceTo(value); + this->value.addListener(this, & ofxGuiVecSlider_::changeValue); + + VecType val = value; + VecType min = value.getMin(); + VecType max = value.getMax(); + for (int i=0; i p(names[i], val[i], min[i], max[i]); + add(p); + p.addListener(this, & ofxGuiVecSlider_::changeSlider); + } + + _setConfig(config); + +} + +template +ofxGuiVecSlider_::ofxGuiVecSlider_(const std::string& controlName, const VecType & v, const VecType & min, const VecType & max, const ofJson & config) + :ofxGuiVecSlider_(config){ + + names.clear(); + names.push_back("x"); + names.push_back("y"); + names.push_back("z"); + names.push_back("w"); + + value.set(controlName,v,min,max); + + this->value.addListener(this, & ofxGuiVecSlider_::changeValue); + + VecType val = value; + for (int i=0; i p(names[i], val[i], min[i], max[i]); + add(p); + p.addListener(this, & ofxGuiVecSlider_::changeSlider); + } + +} + +template +ofxGuiVecSlider_::~ofxGuiVecSlider_(){ + this->value.removeListener(this, & ofxGuiVecSlider_::changeValue); + for (int i=0; igetParameter().template cast().removeListener(this, &ofxGuiVecSlider_::changeSlider); + } +} + +template +void ofxGuiVecSlider_::setup(){ + + sliderChanging = false; + +} + +template +void ofxGuiVecSlider_::changeSlider(const void * parameter, float & _value){ + sliderChanging = true; + ofParameter & param = *(ofParameter*)parameter; + int i = getControlIndex(param.getName()) - getControlIndex(names[0]); + VecType data = value; + data[i] = _value; + value = data; + sliderChanging = false; +} + +template +void ofxGuiVecSlider_::changeValue(VecType & value){ + if (sliderChanging){ + return; + } + for (int i=0; igetParameter().template cast() = value[i]; + } +} + +template +ofAbstractParameter & ofxGuiVecSlider_::getParameter(){ + return value; +} + +template +VecType ofxGuiVecSlider_::operator=(const VecType & v){ + value = v; + return value; +} + +template +ofxGuiVecSlider_::operator const VecType & (){ + return value; +} + +template +const VecType * ofxGuiVecSlider_::operator->(){ + return &value.get(); +} + +template class ofxGuiVecSlider_; +template class ofxGuiVecSlider_; +template class ofxGuiVecSlider_; + + +// RECTANGLE SLIDER + +ofxGuiRectangleSlider::ofxGuiRectangleSlider() + :ofxGuiGroup(){ + + setup(); + +} + +ofxGuiRectangleSlider::ofxGuiRectangleSlider(const ofJson &config) + :ofxGuiRectangleSlider(){ + + _setConfig(config); + +} + +ofxGuiRectangleSlider::ofxGuiRectangleSlider(ofParameter &value, const ofJson & config) +:ofxGuiRectangleSlider(){ + + setName(value.getName()); + + names.clear(); + names.push_back("x"); + names.push_back("y"); + names.push_back("width"); + names.push_back("height"); + + this->value.makeReferenceTo(value); + this->value.addListener(this, & ofxGuiRectangleSlider::changeValue); + + ofRectangle val = value; + ofRectangle min = value.getMin(); + ofRectangle max = value.getMax(); + ofParameter px(names[0], val.x, min.x, max.x); + ofParameter py(names[1], val.y, min.y, max.y); + ofParameter pw(names[2], val.width, min.width, max.width); + ofParameter ph(names[3], val.height, min.height, max.height); + add(px); + add(py); + add(pw); + add(ph); + px.addListener(this, & ofxGuiRectangleSlider::changeSlider); + py.addListener(this, & ofxGuiRectangleSlider::changeSlider); + pw.addListener(this, & ofxGuiRectangleSlider::changeSlider); + ph.addListener(this, & ofxGuiRectangleSlider::changeSlider); + + _setConfig(config); + +} + +ofxGuiRectangleSlider::ofxGuiRectangleSlider(const std::string& controlName, const ofRectangle & v, const ofRectangle & min, const ofRectangle & max, const ofJson & config) + :ofxGuiRectangleSlider(config){ + + names.clear(); + names.push_back("x"); + names.push_back("y"); + names.push_back("width"); + names.push_back("height"); + + + value.set(controlName,v,min,max); + + this->value.addListener(this, & ofxGuiRectangleSlider::changeValue); + + ofRectangle val = value; + ofParameter px(names[0], val.x, min.x, max.x); + ofParameter py(names[1], val.y, min.y, max.y); + ofParameter pw(names[2], val.width, min.width, max.width); + ofParameter ph(names[3], val.height, min.height, max.height); + add(px); + add(py); + add(pw); + add(ph); + px.addListener(this, & ofxGuiRectangleSlider::changeSlider); + py.addListener(this, & ofxGuiRectangleSlider::changeSlider); + pw.addListener(this, & ofxGuiRectangleSlider::changeSlider); + ph.addListener(this, & ofxGuiRectangleSlider::changeSlider); + +} + +ofxGuiRectangleSlider::~ofxGuiRectangleSlider(){ + this->value.removeListener(this, & ofxGuiRectangleSlider::changeValue); + for (int i=0; i<4; i++){ + getControl(names[i])->getParameter().template cast().removeListener(this, &ofxGuiRectangleSlider::changeSlider); + } +} + +void ofxGuiRectangleSlider::setup(){ + + sliderChanging = false; + +} + +void ofxGuiRectangleSlider::changeSlider(const void * parameter, float & _value){ + sliderChanging = true; + ofParameter & param = *(ofParameter*)parameter; + int i = getControlIndex(param.getName()) - getControlIndex(names[0]); + ofRectangle data = value; + switch(i){ + case 0: data.x = _value; break; + case 1: data.y = _value; break; + case 2: data.width = _value; break; + case 3: data.height = _value; break; + } + value = data; + sliderChanging = false; +} + +void ofxGuiRectangleSlider::changeValue(ofRectangle & value){ + if (sliderChanging){ + return; + } + getControl("x")->getParameter().template cast() = value.x; + getControl("y")->getParameter().template cast() = value.y; + getControl("width")->getParameter().template cast() = value.width; + getControl("height")->getParameter().template cast() = value.height; +} + +ofAbstractParameter & ofxGuiRectangleSlider::getParameter(){ + return value; +} + +ofRectangle ofxGuiRectangleSlider::operator=(const ofRectangle & v){ + value = v; + return value; +} + +ofxGuiRectangleSlider::operator const ofRectangle & (){ + return value; +} + +const ofRectangle * ofxGuiRectangleSlider::operator->(){ + return &value.get(); +} + + + +// COLOR SLIDER + + +template +ofxGuiColorSlider_::ofxGuiColorSlider_() + :ofxGuiGroup(){ + + setup(); + +} + +template +ofxGuiColorSlider_::ofxGuiColorSlider_(const ofJson &config) + :ofxGuiGroup(){ + + _setConfig(config); + +} + +template +ofxGuiColorSlider_::ofxGuiColorSlider_(ofParameter > &value, const ofJson & config) + :ofxGuiColorSlider_(){ + + setName(value.getName()); + + names.clear(); + names.push_back("r"); + names.push_back("g"); + names.push_back("b"); + names.push_back("a"); + + this->value.makeReferenceTo(value); + this->value.addListener(this, & ofxGuiColorSlider_::changeValue); + + ofColor_ val = value; + ofColor_ min = value.getMin(); + ofColor_ max = value.getMax(); + + for (int i=0; i<4; i++) { + ofParameter p(names[i], val[i], min[i], max[i]); + add>(p); + p.addListener(this, & ofxGuiColorSlider_::changeSlider); + getControl(names[i])->setConfig(ofJson({ + {"fill-color", ofxGui::colorToString(value.get())} + })); + } + + sliderChanging = false; + + _setConfig(config); + +} + +template +ofxGuiColorSlider_::ofxGuiColorSlider_(const std::string& controlName, const ofColor_ & v, const ofColor_ & min, const ofColor_ & max, const ofJson &config) + :ofxGuiColorSlider_(config){ + + value.set(controlName,v,min,max); + + names.clear(); + names.push_back("r"); + names.push_back("g"); + names.push_back("b"); + names.push_back("a"); + + this->value.addListener(this, & ofxGuiColorSlider_::changeValue); + + ofColor_ val = value; + + for (int i=0; i<4; i++) { + ofParameter p(names[i], val[i], min[i], max[i]); + add>(p); + p.addListener(this, & ofxGuiColorSlider_::changeSlider); + getControl(names[i])->setConfig(ofJson({ + {"fill-color", ofxGui::colorToString(value.get())} + })); + } + + sliderChanging = false; + +} + + +template +ofxGuiColorSlider_::~ofxGuiColorSlider_(){ + this->value.removeListener(this, & ofxGuiColorSlider_::changeValue); + for (int i=0; i<4; i++){ + getControl(names[i])->getParameter().template cast().removeListener(this, &ofxGuiColorSlider_::changeSlider); + } +} + + +template +void ofxGuiColorSlider_::setup(){ + + sliderChanging = false; + +} + +template +void ofxGuiColorSlider_::changeSlider(const void * parameter, ColorType & _value){ + sliderChanging = true; + ofParameter & param = *(ofParameter*)parameter; + int i = getControlIndex(param.getName()) - getControlIndex(names[0]); + ofColor_ data = value; + data[i] = _value; + + value = data; + + for (int i=0; i<4; i++){ + getControl(names[i])->setFillColor(value.get()); + } + sliderChanging = false; +} + +template +void ofxGuiColorSlider_::changeValue(ofColor_ & value){ + if (sliderChanging){ + return; + } + for (int i=0; i<4; i++){ + getControl(names[i])->getParameter().template cast() = value[i]; + getControl(names[i])->setFillColor(value); + } +} + +template +ofAbstractParameter & ofxGuiColorSlider_::getParameter(){ + return value; +} + +template +ofColor_ ofxGuiColorSlider_::operator=(const ofColor_ & v){ + value = v; + return value; +} + +template +ofxGuiColorSlider_::operator const ofColor_ & (){ + return value; +} + +template class ofxGuiColorSlider_; +template class ofxGuiColorSlider_; +template class ofxGuiColorSlider_; diff --git a/addons/ofxGui/src/ofxGuiSliderGroup.h b/addons/ofxGui/src/ofxGuiSliderGroup.h new file mode 100644 index 0000000..fdc8cf4 --- /dev/null +++ b/addons/ofxGui/src/ofxGuiSliderGroup.h @@ -0,0 +1,82 @@ +#pragma once + +#include "ofxGuiGroup.h" + + +template +class ofxGuiVecSlider_ : public ofxGuiGroup { +public: + + ofxGuiVecSlider_(); + ofxGuiVecSlider_(const ofJson & config); + ofxGuiVecSlider_(ofParameter &value, const ofJson & config = ofJson()); + ofxGuiVecSlider_(const std::string& controlName, const VecType & value, const VecType & min, const VecType & max, const ofJson & config = ofJson()); + + ~ofxGuiVecSlider_(); + + void setup(); + + ofAbstractParameter & getParameter(); + + VecType operator=(const VecType & v); + operator const VecType & (); + const VecType * operator->(); +protected: + void changeSlider(const void * parameter, float & value); + void changeValue(VecType & value); + ofParameter value; + bool sliderChanging; + std::vector names; +}; + +class ofxGuiRectangleSlider : public ofxGuiGroup { +public: + + ofxGuiRectangleSlider(); + ofxGuiRectangleSlider(const ofJson & config); + ofxGuiRectangleSlider(ofParameter &value, const ofJson & config = ofJson()); + ofxGuiRectangleSlider(const std::string& controlName, const ofRectangle & value, const ofRectangle & min, const ofRectangle & max, const ofJson & config = ofJson()); + + ~ofxGuiRectangleSlider(); + + void setup(); + + ofAbstractParameter & getParameter(); + + ofRectangle operator=(const ofRectangle & v); + operator const ofRectangle & (); + const ofRectangle * operator->(); +protected: + void changeSlider(const void * parameter, float & value); + void changeValue(ofRectangle & value); + ofParameter value; + bool sliderChanging; + std::vector names; +}; + +template +class ofxGuiColorSlider_: public ofxGuiGroup{ + +public: + + ofxGuiColorSlider_(); + ofxGuiColorSlider_(const ofJson & config); + ofxGuiColorSlider_(ofParameter> &value, const ofJson & config = ofJson()); + ofxGuiColorSlider_(const std::string& controlName, const ofColor_ & value, const ofColor_ & min, const ofColor_ & max, const ofJson & config = ofJson()); + + ~ofxGuiColorSlider_(); + + void setup(); + + ofAbstractParameter & getParameter(); + + ofColor_ operator=(const ofColor_ & v); + operator const ofColor_ & (); +protected: + void changeSlider(const void * parameter, ColorType & value); + void changeValue(ofColor_ & value); + ofParameter > value; + bool sliderChanging; + std::vector names; +}; + diff --git a/addons/ofxGui/src/ofxGuiTabs.cpp b/addons/ofxGui/src/ofxGuiTabs.cpp new file mode 100644 index 0000000..58bd6ba --- /dev/null +++ b/addons/ofxGui/src/ofxGuiTabs.cpp @@ -0,0 +1,231 @@ +#include "ofxGuiTabs.h" +#include "ofGraphics.h" +using namespace std; + +ofxGuiTabs::ofxGuiTabs() : + ofxGuiContainer(){ + + setup(); + +} + +ofxGuiTabs::ofxGuiTabs(const string &collectionName, const ofJson &config) : + ofxGuiTabs(){ + + setName(collectionName); + _setConfig(config); + +} + +ofxGuiTabs::ofxGuiTabs(string collectionName, string filename, float x, float y) + :ofxGuiTabs(collectionName){ + + this->filename = filename; + setPosition(x,y); + +} + +ofxGuiTabs::~ofxGuiTabs(){ + if(tabs){ + tabs->getActiveToggleIndex().removeListener(this, &ofxGuiTabs::_setActiveTab); + } + ofRemoveListener(childAdded, this, &ofxGuiTabs::onChildAdd); +} + +void ofxGuiTabs::setup(){ + + tabs = nullptr; + pages.clear(); + activeToggle = nullptr; + activePage = nullptr; + + setTheme(); + + tabWidth.set("tab width", 100); + tabHeight.set("tab height", 50); + setConfig(ofJson({ + {"flex-direction", "column"}, + {"direction", "vertical"} + })); + + clear(); + + ofAddListener(childAdded, this, &ofxGuiTabs::onChildAdd); + +} + +void ofxGuiTabs::clear(){ + + if(tabs){ + tabs->getActiveToggleIndex().removeListener(this, &ofxGuiTabs::_setActiveTab); + } + + ofxGuiContainer::clear(); + + tabs = addContainer("tabs", ofJson({ + {"height", tabHeight.get()}, + {"align-items", "stretch"}, + {"justify-content", "flex-start"}, + {"margin", 0}, + {"border-width", 0}, + {"padding", "0 10"}, + {"flex-direction", "row"}, + {"direction", "horizontal"}, + {"background-color", "rgba(0,0,0,0)"} + })); + + tabs->setExclusiveToggles(true); + tabs->getActiveToggleIndex().addListener(this, &ofxGuiTabs::_setActiveTab); + +} + +void ofxGuiTabs::generateDraw(){ + + for(unsigned int i = 0; i < pages.size(); i++){ + if(ofxGuiElement* page = dynamic_cast(pages.at(i))){ + ofxGuiElement* tab = tabs->getControl(i); + if(tab->getName() != page->getName() + || tab->getFillColor() != page->getBackgroundColor()){ + tab->setName(page->getName()); + tab->setFillColor(page->getBackgroundColor()); + tab->setBackgroundColor(ofColor(page->getBackgroundColor(), 120)); + tabs->updateLayout(); + } + } + } + + ofxGuiContainer::generateDraw(); + + border.clear(); + bg.clear(); + if(activePage){ + int topy = activePage->getShape().getTop(); + border.moveTo(0, topy-borderWidth); + bg.moveTo(borderWidth, topy); + for(ofxGuiElement* tab : tabs->getControls()){ + border.lineTo(tab->getShape().getLeft()+tabs->getPosition().x-borderWidth, topy - borderWidth); + border.lineTo(tab->getShape().getTopLeft()+tabs->getPosition() - ofPoint(borderWidth,borderWidth)); + border.lineTo(tab->getShape().getTopRight()+tabs->getPosition() + ofPoint(borderWidth, -borderWidth)); + border.lineTo(tab->getShape().getRight()+tabs->getPosition().x+borderWidth, topy - borderWidth); + bg.lineTo(tab->getShape().getLeft()+tabs->getPosition().x, topy); + bg.lineTo(tab->getShape().getTopLeft()+tabs->getPosition()); + bg.lineTo(tab->getShape().getTopRight()+tabs->getPosition()); + if(tab != activeToggle){ + bg.lineTo(tab->getShape().getRight()+tabs->getPosition().x, topy - borderWidth); + bg.lineTo(tab->getShape().getLeft()+tabs->getPosition().x, topy - borderWidth); + bg.lineTo(tab->getShape().getLeft()+tabs->getPosition().x, topy); + bg.lineTo(tab->getShape().getRight()+tabs->getPosition().x, topy); + }else{ + bg.lineTo(tab->getShape().getRight()+tabs->getPosition().x, topy); + } + } + border.lineTo(getWidth(), topy - borderWidth); + border.lineTo(getWidth(), getHeight()); + border.lineTo(0, getHeight()); + border.lineTo(0, topy-borderWidth); + bg.lineTo(getWidth() - borderWidth, topy); + bg.lineTo(getWidth() - borderWidth, getHeight() - borderWidth); + bg.lineTo(borderWidth, getHeight() - borderWidth); + bg.lineTo(borderWidth, topy); + } + border.append(bg); + + +} + +void ofxGuiTabs::onChildAdd(DOM::ElementEventArgs &args){ + + unsigned int nopages = 2; + if(this->children().size() < nopages){ + return; + } + + if(tabs){ + + Element* _page = args.element(); + + pages.push_back(_page); + + std::string name = "Page " + ofToString(pages.size()); + ofxGuiElement* page = dynamic_cast(_page); + if(page){ + name = page->getName(); + page->setHidden(true); + page->setConfig(ofJson({ + {"position", "static"}, + {"flex", "auto"}, + {"align-self", "stretch"}, + {"margin", 0}, + {"show-header", false}, + {"border-width", 0} + })); + } + + ofJson toggleconfig = { + {"width", tabWidth.get()}, + {"type", "fullsize"}, + {"margin", "0 20 0 0"}, + {"border-width", 0} + }; + ofxGuiElement* tab = tabs->add(name, toggleconfig); + tab->getParameter().cast>().setSerializable(false); + tab->setTextAlignment(TextAlignment::CENTERED); + + if(pages.size() == 1){ + setActiveTab(0); + } + + invalidateChildShape(); + + } + +} + +void ofxGuiTabs::setActiveTab(int index){ + _setActiveTab(index); +} + +void ofxGuiTabs::_setActiveTab(int &index){ + tabs->setActiveToggle(index); + for(auto &e : tabs->getControls()){ + e->setConfig(ofJson({{"margin-bottom", "1"}})); + } + activeToggle = tabs->getControl(index); + activeToggle->setConfig(ofJson({{"margin-bottom", "-1"}})); + for(auto &e : pages){ + e->setHidden(true); + } + pages.at(index)->setHidden(false); + activePage = pages.at(index); + invalidateChildShape(); +} + +ofParameter& ofxGuiTabs::getActiveTabIndex(){ + return tabs->getActiveToggleIndex(); +} + +DOM::Element *ofxGuiTabs::getActiveTab(){ + return activePage; +} + +void ofxGuiTabs::setTabHeight(int h){ + tabHeight = h; + tabs->setHeight(h); +} + +void ofxGuiTabs::setTabWidth(int w){ + tabWidth = w; + for(auto & e: tabs->children()){ + e->setWidth(w); + } +} + +std::string ofxGuiTabs::getClassType(){ + return "tabs"; +} + +vector ofxGuiTabs::getClassTypes(){ + vector types = ofxGuiContainer::getClassTypes(); + types.push_back(getClassType()); + return types; +} diff --git a/addons/ofxGui/src/ofxGuiTabs.h b/addons/ofxGui/src/ofxGuiTabs.h new file mode 100644 index 0000000..9ad084b --- /dev/null +++ b/addons/ofxGui/src/ofxGuiTabs.h @@ -0,0 +1,52 @@ +#pragma once + +#include "ofxGuiContainer.h" + +class ofxGuiTabs : public ofxGuiContainer { + + public: + + ofxGuiTabs(); + ofxGuiTabs(const std::string &collectionName, const ofJson & config = ofJson()); + ofxGuiTabs(std::string collectionName, std::string filename, float x = 10, float y = 10); + ~ofxGuiTabs(); + + void setup(); + + using ofxGuiContainer::add; + + template + GuiType* add(std::unique_ptr element); + + virtual void clear() override; + + void setActiveTab(int index); + ofParameter &getActiveTabIndex(); + Element * getActiveTab(); + + void setTabHeight(int h); + void setTabWidth(int w); + + static std::string getClassType(); + + protected: + + void _setActiveTab(int &index); + + virtual std::vector getClassTypes() override; + + virtual void generateDraw() override; + + void onChildAdd(DOM::ElementEventArgs& args); + + ofParameter tabWidth; + ofParameter tabHeight; + + ofxGuiContainer * tabs; + std::vector pages; + Element * activePage; + ofxGuiElement * activeToggle; + + + private: +}; diff --git a/addons/ofxGui/src/ofxGuiToggle.cpp b/addons/ofxGui/src/ofxGuiToggle.cpp new file mode 100644 index 0000000..1c2426f --- /dev/null +++ b/addons/ofxGui/src/ofxGuiToggle.cpp @@ -0,0 +1,349 @@ +#include "ofxGuiToggle.h" +#include "ofxGuiContainer.h" +#include "ofGraphics.h" +using namespace std; + +ofxGuiToggle::ofxGuiToggle():ofxGuiElement(){ + + setup(); + +} + +ofxGuiToggle::ofxGuiToggle(const string &toggleName):ofxGuiToggle(){ + + setName(toggleName); + value.set(false); + +} + +ofxGuiToggle::ofxGuiToggle(const string &toggleName, const ofJson& config):ofxGuiToggle(toggleName){ + + _setConfig(config); + +} + +ofxGuiToggle::ofxGuiToggle(ofParameter &_bVal, const ofJson & config) + :ofxGuiElement(){ + + value.makeReferenceTo(_bVal); + setup(); + _setConfig(config); + +} + +ofxGuiToggle::ofxGuiToggle(const std::string& toggleName, bool _bVal, const ofJson &config) + :ofxGuiToggle(toggleName, config){ + + value.set(_bVal); + +} + +ofxGuiToggle::~ofxGuiToggle(){ + + value.removeListener(this,&ofxGuiToggle::valueChanged); + +} + +void ofxGuiToggle::setup(){ + + hasFocus = false; + + type.set("type", ofxGuiToggleType::CHECKBOX); + + setTheme(); + + value.addListener(this,&ofxGuiToggle::valueChanged); + + registerMouseEvents(); + +} + +void ofxGuiToggle::_setConfig(const ofJson &config){ + + ofxGuiElement::_setConfig(config); + + if (config.find(type.getName()) != config.end()) { + std::string val = config[type.getName()]; + setType(val); + } + +} + +float ofxGuiToggle::getMinWidth(){ + float _width = 0; + if(showName){ + _width += ofxGuiElement::getTextWidth(getName()); + } + if(type != ofxGuiToggleType::FULLSIZE){ + _width += 30; + } + return _width; +} + +float ofxGuiToggle::getMinHeight(){ + if(showName){ + return ofxGuiElement::getTextHeight(getName()); + } + return 10; +} + +bool ofxGuiToggle::mousePressed(ofMouseEventArgs & args){ + ofxGuiElement::mousePressed(args); + return setValue(args.x, args.y, true); +} + +bool ofxGuiToggle::mouseReleased(ofMouseEventArgs & args){ + ofxGuiElement::mouseReleased(args); + bool hadFocus = hasFocus; + hasFocus = false; + return (hadFocus && isMouseOver()); +} + +void ofxGuiToggle::generateDraw(){ + + float maxSize = min(getHeight(), getWidth()); + switch(type){ + default: + case ofxGuiToggleType::RADIO: + case ofxGuiToggleType::CHECKBOX: { + checkboxRect.set(0, (getHeight()-maxSize)/2, maxSize, maxSize); + break; + } + case ofxGuiToggleType::FULLSIZE: { + checkboxRect.set(0, 0, getWidth(), getHeight()); + break; + } + } + + bg.clear(); + bg.setFilled(true); + border.clear(); + border.setFillColor(borderColor); + border.setFilled(true); + if(value && (borderWidth <= 0 || type != ofxGuiToggleType::CHECKBOX)){ + bg.setFillColor(fillColor); + }else{ + bg.setFillColor(backgroundColor); + } + switch(type){ + default: + case ofxGuiToggleType::RADIO:{ + border.arc(checkboxRect.getCenter(), checkboxRect.getHeight()/3, checkboxRect.getHeight()/3, 0, 360); + border.arc(checkboxRect.getCenter(), checkboxRect.getHeight()/3-borderWidth, checkboxRect.getHeight()/3-borderWidth, 0, 360); + if(value){ + bg.arc(checkboxRect.getCenter(), checkboxRect.getHeight()/3-borderWidth-2, checkboxRect.getHeight()/3-borderWidth-2, 0, 360); + }else{ + bg.arc(checkboxRect.getCenter(), checkboxRect.getHeight()/3-borderWidth, checkboxRect.getHeight()/3-borderWidth, 0, 360); + } + + break; + } + case ofxGuiToggleType::CHECKBOX: { + border.rectRounded(checkboxRect.getTopLeft()+ofPoint(checkboxRect.width/6,checkboxRect.height/6), + checkboxRect.width/3*2,checkboxRect.height/3*2, borderRadius); + + if(value){ + if(borderWidth.get() > 0){ + border.rectRounded(checkboxRect.getTopLeft()+ofPoint(checkboxRect.width/6+borderWidth,checkboxRect.height/6+borderWidth), + checkboxRect.width/3*2-2*borderWidth,checkboxRect.height/3*2 - 2*borderWidth, borderRadius); + //create cross + float bla = sqrt(borderWidth*borderWidth*0.5); + ofRectangle checkbox = checkboxRect; + checkbox.setPosition(checkbox.getPosition() + ofPoint(checkbox.width/3, checkbox.width/3)); + checkbox.setSize(checkbox.width/3, checkbox.width/3); + border.moveTo(checkbox.getTopLeft()); + border.lineTo(checkbox.getTopLeft() + ofPoint(borderWidth,0)); + border.lineTo(checkbox.getCenter() + ofPoint(0, -bla)); + border.lineTo(checkbox.getTopRight() + ofPoint(-borderWidth, 0)); + border.lineTo(checkbox.getTopRight()); + border.lineTo(checkbox.getTopRight() + ofPoint(0, borderWidth)); + border.lineTo(checkbox.getCenter() + ofPoint(bla, 0)); + border.lineTo(checkbox.getBottomRight() + ofPoint(0, -borderWidth)); + border.lineTo(checkbox.getBottomRight()); + border.lineTo(checkbox.getBottomRight() + ofPoint(-borderWidth, 0)); + border.lineTo(checkbox.getCenter() + ofPoint(0, bla)); + border.lineTo(checkbox.getBottomLeft() + ofPoint(borderWidth, 0)); + border.lineTo(checkbox.getBottomLeft()); + border.lineTo(checkbox.getBottomLeft() + ofPoint(0, -borderWidth)); + border.lineTo(checkbox.getCenter() + ofPoint(-bla, 0)); + border.lineTo(checkbox.getTopLeft() + ofPoint(0, borderWidth)); + border.close(); + bg.rectRounded(checkboxRect.getTopLeft()+ofPoint(checkboxRect.width/6+borderWidth,checkboxRect.height/6+borderWidth), + checkboxRect.width/3*2-2*borderWidth,checkboxRect.height/3*2 - 2*borderWidth, borderRadius); + }else{ + bg.append(border); + } + }else{ + bg.rectRounded(checkboxRect.getTopLeft()+ofPoint(checkboxRect.width/6+borderWidth,checkboxRect.height/6+borderWidth), + checkboxRect.width/3*2-2*borderWidth,checkboxRect.height/3*2 - 2*borderWidth, borderRadius); + border.append(bg); + } + + break; + } + case ofxGuiToggleType::FULLSIZE: { + border.rectRounded(checkboxRect.getTopLeft(),checkboxRect.width,checkboxRect.height, borderRadius); + if(value){ + bg.append(border); + border.rectRounded(checkboxRect.getTopLeft()+ofPoint(borderWidth,borderWidth),checkboxRect.width-2*borderWidth,checkboxRect.height-2*borderWidth, borderRadius); + }else{ + bg.rectRounded(checkboxRect.getTopLeft()+ofPoint(borderWidth,borderWidth),checkboxRect.width-2*borderWidth,checkboxRect.height-2*borderWidth, borderRadius); + border.append(bg); + } + break; + } + } + + if(showName){ + switch(type){ + default: + case ofxGuiToggleType::RADIO: + case ofxGuiToggleType::CHECKBOX: { + + // create label + + textMesh = getTextMesh(getName(), textPadding + checkboxRect.width, getShape().getHeight() / 2 + 4); + break; + } + case ofxGuiToggleType::FULLSIZE: { + + // create label + float textWidth = ofxGuiElement::getTextWidth(getName()); + switch(textAlignment){ + default: + case TextAlignment::CENTERED: + if(getShape().getCenter().x - textWidth/2 > getShape().x+textPadding){ + textMesh = getTextMesh(getName(), getWidth()/2 - textWidth/2, getHeight()/ 2 + 4); + break; + } + case TextAlignment::LEFT: + textMesh = getTextMesh(getName(), textPadding, getShape().height / 2 + 4); + break; + case TextAlignment::RIGHT: + textMesh = getTextMesh(getName(), getShape().getWidth() - textWidth - textPadding, getShape().height / 2 + 4); + break; + + } + break; + } + } + } + + +} + +void ofxGuiToggle::render(){ + + bg.draw(); + border.draw(); + + if(showName){ + ofColor c = ofGetStyle().color; + ofBlendMode blendMode = ofGetStyle().blendingMode; + if(blendMode!=OF_BLENDMODE_ALPHA){ + ofEnableAlphaBlending(); + } + ofSetColor(textColor); + + bindFontTexture(); + textMesh.draw(); + unbindFontTexture(); + + ofSetColor(c); + if(blendMode!=OF_BLENDMODE_ALPHA){ + ofEnableBlendMode(blendMode); + } + } +} + +bool ofxGuiToggle::operator=(bool v){ + value = v; + return v; +} + +ofxGuiToggle::operator const bool & (){ + return value; +} + +bool ofxGuiToggle::setValue(float mx, float my, bool bCheck){ + + if(isHidden()){ + hasFocus = false; + return false; + } + if(bCheck){ + + ofRectangle checkRect = checkboxRect; + checkRect.x += getScreenPosition().x; + checkRect.y += getScreenPosition().y; + + hasFocus = checkRect.inside(mx, my); + } + + if(hasFocus){ + + //if group has exclusive toggles and toggle is on, don't to anything + ofxGuiContainer* parent = dynamic_cast(this->parent()); + if(parent){ + if(parent->getTogglesExclusive()){ + if(value.get()){ + return false; + } + } + } + + value = !value; + + if(value.get()){ + if(parent){ + parent->deactivateAllOtherToggles(this); + } + } + + setNeedsRedraw(); + + return true; + } + + return false; +} + +ofAbstractParameter & ofxGuiToggle::getParameter(){ + return value; +} + +void ofxGuiToggle::valueChanged(bool & value){ + setNeedsRedraw(); +} + +void ofxGuiToggle::setType(const std::string& type){ + if(type == "checkbox"){ + setType(ofxGuiToggleType::CHECKBOX); + } + else if(type == "radio"){ + setType(ofxGuiToggleType::RADIO); + } + else if(type == "fullsize"){ + setType(ofxGuiToggleType::FULLSIZE); + } +} + +void ofxGuiToggle::setType(const ofxGuiToggleType::Type &type){ + individualConfig[this->type.getName()] = type; + this->type.set(type); + setNeedsRedraw(); +} + +ofxGuiToggleType::Type ofxGuiToggle::getType(){ + return type; +} + +std::string ofxGuiToggle::getClassType(){ + return "toggle"; +} + +std::vector ofxGuiToggle::getClassTypes(){ + vector types = ofxGuiElement::getClassTypes(); + types.push_back(getClassType()); + return types; +} diff --git a/addons/ofxGui/src/ofxGuiToggle.h b/addons/ofxGui/src/ofxGuiToggle.h new file mode 100644 index 0000000..5887cb7 --- /dev/null +++ b/addons/ofxGui/src/ofxGuiToggle.h @@ -0,0 +1,74 @@ +#pragma once + +#include "ofParameter.h" +#include "ofxGuiElement.h" + +class ofxGuiToggleType{ + public: + enum Type { + /// \brief Shows toggle as checkbox (default). + CHECKBOX, + /// \brief Shows toggle as radio toggle. + RADIO, + /// \brief Uses the whole element as toggle. + FULLSIZE + }; +}; + +class ofxGuiToggle : public ofxGuiElement{ +public: + + ofxGuiToggle(); + ofxGuiToggle(const std::string& toggleName); + ofxGuiToggle(const std::string& toggleName, const ofJson & config); + ofxGuiToggle(ofParameter& _bVal, const ofJson & config = ofJson()); + ofxGuiToggle(const std::string& toggleName, bool _bVal, const ofJson & config = ofJson()); + + ~ofxGuiToggle(); + + void setType(const std::string &type); + void setType(const ofxGuiToggleType::Type &type); + ofxGuiToggleType::Type getType(); + + virtual float getMinWidth() override; + virtual float getMinHeight() override; + + virtual bool mousePressed(ofMouseEventArgs & args) override; + virtual bool mouseReleased(ofMouseEventArgs & args) override; + + template + void addListener(ListenerClass * listener, ListenerMethod method){ + value.addListener(listener,method); + } + + template + void removeListener(ListenerClass * listener, ListenerMethod method){ + value.removeListener(listener,method); + } + + bool operator=(bool v); + operator const bool & (); + + virtual ofAbstractParameter & getParameter() override; + + static std::string getClassType(); + +protected: + + void setup(); + + virtual std::vector getClassTypes() override; + + virtual void _setConfig(const ofJson & config) override; + virtual void render() override; + ofRectangle checkboxRect; + ofParameter value; + + ofParameter type; + bool hasFocus; + + virtual bool setValue(float mx, float my, bool bCheck) override; + virtual void generateDraw() override; + void valueChanged(bool & value); + ofVboMesh textMesh; +}; diff --git a/addons/ofxGui/src/ofxGuiValuePlotter.cpp b/addons/ofxGui/src/ofxGuiValuePlotter.cpp new file mode 100644 index 0000000..a4bbc6e --- /dev/null +++ b/addons/ofxGui/src/ofxGuiValuePlotter.cpp @@ -0,0 +1,169 @@ +#include "ofxGuiValuePlotter.h" +#include "ofGraphics.h" +#include "JsonConfigParser.h" +using namespace std; + +ofxGuiValuePlotter::ofxGuiValuePlotter() + :ofxGuiElement(){ + + setup(); + +} + +ofxGuiValuePlotter::ofxGuiValuePlotter(const ofJson & config) + :ofxGuiElement(){ + + setup(); + _setConfig(config); + +} + + +ofxGuiValuePlotter::ofxGuiValuePlotter(ofParameter &value, const ofJson & config) : + ofxGuiElement(){ + + this->value.makeReferenceTo(value); + setup(); + _setConfig(config); +} + +ofxGuiValuePlotter::ofxGuiValuePlotter(std::string label, float minValue, float maxValue, int plotSize, const ofJson & config) + :ofxGuiValuePlotter(config){ + + minVal = minValue; + maxVal = maxValue; + this->plotSize = plotSize; + setName(label); + +} + +ofxGuiValuePlotter::~ofxGuiValuePlotter(){ + value.removeListener(this,&ofxGuiValuePlotter::valueChanged); +} + +void ofxGuiValuePlotter::setup(){ + + setTheme(); + + decimalPlace.set("precision", 3); + minVal.set("min", 0); + maxVal.set("max", 0); + plotSize.set("plotsize", 100); + + autoscale = minVal == maxVal; + buffer.clear(); + value.addListener(this,&ofxGuiValuePlotter::valueChanged); + +} + +void ofxGuiValuePlotter::_setConfig(const ofJson & config){ + ofxGuiElement::_setConfig(config); + // TODO + JsonConfigParser::parse(config, decimalPlace); +} + +float ofxGuiValuePlotter::getMinWidth(){ + float _width = ofxGuiElement::getTextWidth(ofToString(value.get(), decimalPlace)); + if(showName){ + _width += ofxGuiElement::getTextWidth(getName()); + } + return _width; +} + +float ofxGuiValuePlotter::getMinHeight(){ + return ofxGuiElement::getTextHeight(ofToString(value.get(), decimalPlace)); +} + +void ofxGuiValuePlotter::setDecimalPlace(int place){ + individualConfig[decimalPlace.getName()] = place; + decimalPlace = place; +} + +void ofxGuiValuePlotter::generateDraw(){ + + ofxGuiElement::generateDraw(); + + label = ofToString(value.get(), decimalPlace); + if(showName){ + label += " " + this->getName(); + } + + textMesh = getTextMesh(label, textPadding, getShape().getHeight() / 2 + 4); + + if(plotSize > 0){ + + plot.clear(); + if(minVal != maxVal && buffer.size() > 1){ + plot.moveTo(0, getShape().getHeight()); + unsigned int i; + for(i = 0; i < buffer.size(); i++){ + float x = ofMap(i, 0, buffer.size() - 1, 0, getShape().getWidth()); + float y = ofMap(buffer[i], minVal, maxVal, getShape().getHeight(), 0); + plot.lineTo(x, y); + } + plot.lineTo(getShape().getWidth(), getShape().getHeight()); + plot.close(); + plot.setFilled(true); + plot.setFillColor(fillColor); + } + } +} + +void ofxGuiValuePlotter::render(){ + ofColor c = ofGetStyle().color; + + ofxGuiElement::render(); + + if(plotSize > 0){ + plot.draw(); + } + + ofBlendMode blendMode = ofGetStyle().blendingMode; + if(blendMode != OF_BLENDMODE_ALPHA){ + ofEnableAlphaBlending(); + } + ofSetColor(textColor); + + bindFontTexture(); + textMesh.draw(); + unbindFontTexture(); + + ofSetColor(c); + if(blendMode != OF_BLENDMODE_ALPHA){ + ofEnableBlendMode(blendMode); + } +} + +ofAbstractParameter & ofxGuiValuePlotter::getParameter(){ + return value; +} + +void ofxGuiValuePlotter::valueChanged(float & value){ + if(plotSize > 0){ + buffer.push_back(value); + + if((int)buffer.size() > plotSize){ + buffer.erase(buffer.begin(), buffer.begin() + 1); + } + if(autoscale){ + if(value < minVal){ + minVal = value; + } + if(value > maxVal){ + maxVal = value; + } + } + } + setNeedsRedraw(); +} + +vector ofxGuiValuePlotter::getClassTypes(){ + vector types = ofxGuiElement::getClassTypes(); + types.push_back(getClassType()); + return types; +} + +std::string ofxGuiValuePlotter::getClassType(){ + return "value-plotter"; +} + diff --git a/addons/ofxGui/src/ofxGuiValuePlotter.h b/addons/ofxGui/src/ofxGuiValuePlotter.h new file mode 100644 index 0000000..9f0a6dd --- /dev/null +++ b/addons/ofxGui/src/ofxGuiValuePlotter.h @@ -0,0 +1,48 @@ +#pragma once + +#include "ofxGuiElement.h" + +class ofxGuiValuePlotter : public ofxGuiElement { + public: + + ofxGuiValuePlotter(); + ofxGuiValuePlotter(const ofJson & config); + ofxGuiValuePlotter(ofParameter& value, const ofJson & config = ofJson()); + ofxGuiValuePlotter(std::string label, float minValue, float maxValue, int plotSize = 100, const ofJson & config = ofJson()); + + virtual ~ofxGuiValuePlotter(); + + virtual float getMinWidth() override; + virtual float getMinHeight() override; + + void setDecimalPlace(int place); + + virtual ofAbstractParameter & getParameter() override; + + static std::string getClassType(); + + protected: + + void setup(); + + virtual std::vector getClassTypes() override; + + virtual void _setConfig(const ofJson & config) override; + virtual void render() override; + virtual void generateDraw() override; + + ofVboMesh textMesh; + std::vector buffer; + ofPath plot; + bool autoscale; + ofParameter label; + ofParameter value; + + ofParameter decimalPlace; + ofParameter minVal; + ofParameter maxVal; + ofParameter plotSize; + + void valueChanged(float & value); + +}; diff --git a/addons/ofxGui/src/ofxGuiZoomableGraphics.cpp b/addons/ofxGui/src/ofxGuiZoomableGraphics.cpp new file mode 100644 index 0000000..e717b6b --- /dev/null +++ b/addons/ofxGui/src/ofxGuiZoomableGraphics.cpp @@ -0,0 +1,178 @@ +#include "ofxGuiZoomableGraphics.h" +#include "ofGraphics.h" +using namespace std; + +ofxGuiZoomableGraphics::ofxGuiZoomableGraphics(std::string canvasName, const ofJson& config) + :ofxGuiGraphics(canvasName){ + _setConfig(config); + setup(); +} + +ofxGuiZoomableGraphics::ofxGuiZoomableGraphics(std::string canvasName, ofBaseDraws * graphics, const ofJson& config) + :ofxGuiGraphics(canvasName, graphics){ + _setConfig(config); + setup(); +} + +ofxGuiZoomableGraphics::ofxGuiZoomableGraphics(std::string canvasName, ofBaseDraws * graphics, float w, float h) + :ofxGuiGraphics(canvasName, graphics, w, h){ + setup(); +} + +ofxGuiZoomableGraphics::~ofxGuiZoomableGraphics(){ + ofRemoveListener(resize, this, &ofxGuiZoomableGraphics::onResize); +} + +void ofxGuiZoomableGraphics::setup(){ + zoom_factor = 0; + zoom_speed = 0.1; + dragging_dst = false; + ofAddListener(resize, this, &ofxGuiZoomableGraphics::onResize); +} + +void ofxGuiZoomableGraphics::onResize(DOM::ResizeEventArgs& args){ + ofxGuiGraphics::onResize(args); + contentFbo.clear(); + if(_bLoaded && getWidth() > 0 && getHeight() > 0){ + contentFbo.allocate(getWidth(), getHeight(), GL_RGBA); + } +} + +void ofxGuiZoomableGraphics::generateDraw(){ + ofxGuiGraphics::generateDraw(); + +} + +void ofxGuiZoomableGraphics::render(){ + + if(_bLoaded){ + + contentFbo.begin(); + ofClear(0, 0, 0, 0); + + ofPushMatrix(); + + zoom_translation = zoom_point - zoom_point_scaled + zoom_point_offset; + if(zoom_translation.x > 0){ + zoom_translation.x = 0; + } + if(zoom_translation.y > 0){ + zoom_translation.y = 0; + } + if(zoom_translation.x < -addZoom(getWidth()) + getWidth()){ + zoom_translation.x = -addZoom(getWidth()) + getWidth(); + } + if(zoom_translation.y < -addZoom(getHeight()) + getHeight()){ + zoom_translation.y = -addZoom(getHeight()) + getHeight(); + } + ofTranslate(zoom_translation); + + graphics->draw(0, 0, addZoom(getWidth()), addZoom(getHeight())); + + ofPopMatrix(); + + contentFbo.end(); + + } + + ofColor c = ofGetStyle().color; + + bg.draw(); + if(_bLoaded){ + contentFbo.draw(0, 0, getWidth(), getHeight()); + } + + if(showName){ + ofBlendMode blendMode = ofGetStyle().blendingMode; + if(blendMode != OF_BLENDMODE_ALPHA){ + ofEnableAlphaBlending(); + } + ofSetColor(textColor); + + bindFontTexture(); + textMesh.draw(); + unbindFontTexture(); + + ofSetColor(c); + if(blendMode != OF_BLENDMODE_ALPHA){ + ofEnableBlendMode(blendMode); + } + } +} + +bool ofxGuiZoomableGraphics::mouseDragged(ofMouseEventArgs & args){ + ofPoint mouse(args.x, args.y); + if(dragging_dst){ + zoom_point_offset += mouse - last_mouse; + last_mouse = mouse; + setNeedsRedraw(); + } + return false; +} + +bool ofxGuiZoomableGraphics::mousePressed(ofMouseEventArgs & args){ + + if(isMouseOver()){ + dragging_dst = true; + last_mouse = ofPoint(args.x, args.y); + } + return false; +} + +bool ofxGuiZoomableGraphics::mouseReleased(ofMouseEventArgs & args){ + dragging_dst = false; + return false; +} + +bool ofxGuiZoomableGraphics::mouseScrolled(ofMouseEventArgs & args){ + + if(isMouseOver()){ + setZoomFactor(args.scrollY); + setNeedsRedraw(); + } + + return false; +} + +void ofxGuiZoomableGraphics::setZoomFactor(int factor){ + + int old_zoom_factor = zoom_factor; + + zoom_factor += factor; + if(zoom_factor < 0){ + zoom_factor = 0; + } + + ofPoint zoom_point_old = zoom_point; + + ofPoint tmp_zoom_point; + tmp_zoom_point.x = ofGetMouseX() - getScreenPosition().x - zoom_point_offset.x; + tmp_zoom_point.y = ofGetMouseY() - getScreenPosition().y - zoom_point_offset.y; + + ofVec2f diff = tmp_zoom_point - zoom_point_old; + + if(old_zoom_factor == 0){ + diff = ofPoint(0, 0); + zoom_point_offset = ofPoint(0, 0); + zoom_point_old = tmp_zoom_point; + } + + zoom_point = zoom_point_old + removeZoom(diff); + zoom_point_offset += tmp_zoom_point - zoom_point; + zoom_point_scaled = addZoom(zoom_point); + +} + +ofPoint ofxGuiZoomableGraphics::addZoom(ofPoint p){ + return p * (1 + zoom_factor * zoom_speed); +} + +float ofxGuiZoomableGraphics::addZoom(float p){ + return p * (1 + zoom_factor * zoom_speed); +} + + +ofPoint ofxGuiZoomableGraphics::removeZoom(ofPoint p){ + return p / (1 + zoom_factor * zoom_speed); +} + diff --git a/addons/ofxGui/src/ofxGuiZoomableGraphics.h b/addons/ofxGui/src/ofxGuiZoomableGraphics.h new file mode 100644 index 0000000..6f460ea --- /dev/null +++ b/addons/ofxGui/src/ofxGuiZoomableGraphics.h @@ -0,0 +1,44 @@ +#pragma once + +#include "ofxGuiGraphics.h" +#include "ofFbo.h" + +class ofxGuiZoomableGraphics : public ofxGuiGraphics { + public: + + ofxGuiZoomableGraphics(std::string canvasName="", const ofJson& config = ofJson()); + ofxGuiZoomableGraphics(std::string canvasName, ofBaseDraws * graphics, const ofJson& config = ofJson()); + ofxGuiZoomableGraphics(std::string canvasName, ofBaseDraws * graphics, float w, float h = 0); + + virtual ~ofxGuiZoomableGraphics(); + + virtual bool mousePressed(ofMouseEventArgs & args) override; + virtual bool mouseDragged(ofMouseEventArgs & args) override; + virtual bool mouseReleased(ofMouseEventArgs & args) override; + virtual bool mouseScrolled(ofMouseEventArgs & args) override; + + virtual void onResize(DOM::ResizeEventArgs&args) override; + + protected: + + void setup(); + + virtual void render() override; + virtual void generateDraw() override; + + void setZoomFactor(int factor); + ofPoint addZoom(ofPoint p); + float addZoom(float p); + ofPoint removeZoom(ofPoint p); + + int zoom_factor; + float zoom_speed; + ofPoint zoom_point, zoom_point_scaled, zoom_point_offset; + ofPoint zoom_translation; + + bool dragging_dst; + ofPoint last_mouse; + + ofFbo contentFbo; + +}; diff --git a/addons/ofxGui/src/ofxInputField.cpp b/addons/ofxGui/src/ofxInputField.cpp deleted file mode 100644 index 9fab253..0000000 --- a/addons/ofxGui/src/ofxInputField.cpp +++ /dev/null @@ -1,811 +0,0 @@ -// -// ofxInputField.cpp -// ofxInputField -// -// Based on ofxInputField by Felix Lange -// -// - -#include "ofxInputField.h" - -#include "ofGraphics.h" - -using namespace std; - -namespace{ - template - typename std::enable_if::value, Type>::type - getRange(Type min, Type max, float width){ - double range = max - min; - range /= width*4; - return std::max(range,1.0); - } - - template - typename std::enable_if::value, Type>::type - getRange(Type min, Type max, float width){ - double range = max - min; - range /= width*4; - return range; - } - - template - std::string toString(Type t){ - return ofToString(t); - } - - template<> - std::string toString(uint8_t t){ - return ofToString((int) t); - } - - template<> - std::string toString(int8_t t){ - return ofToString((int) t); - } - - template<> - std::string toString(std::string t){ - return t; - } - - bool isHexNotation(std::string const& s){ - return s.compare(0, 2, "0x") == 0 - && s.size() > 2 - && s.find_first_not_of("0123456789abcdefABCDEF", 2) == std::string::npos; - } - - bool isANumber(std::string const& s){ - return s.find_first_not_of("0123456789.-e", 0) == std::string::npos - && std::count(s.begin(), s.end(), '.') <= 1; - } - - template - Type fromString(const std::string & str){ - if(isHexNotation(str)){ - return ofHexToInt(str); - }else if(isANumber(str)){ - return ofFromString(str); - }else{ - throw std::exception(); - } - } - - template<> - uint8_t fromString(const std::string & str){ - auto ret = 0; - if(isHexNotation(str)){ - ret = ofHexToInt(str); - }else if(isANumber(str)){ - ret = ofFromString(str); - }else{ - throw std::exception(); - } - return std::max(std::min(ret, 255), 0); - } - - template<> - int8_t fromString(const std::string & str){ - auto ret = 0; - if(isHexNotation(str)){ - ret = ofHexToInt(str); - }else if(isANumber(str)){ - ret = ofFromString(str); - }else{ - throw std::exception(); - } - return std::max(std::min(ret, -127), 127); - } - - ofMesh rectangle(const ofRectangle & r, const ofFloatColor & c){ - ofMesh mesh; - mesh.addVertex(r.position); - mesh.addVertex(glm::vec3(r.x + r.width, r.y, 0)); - mesh.addVertex(glm::vec3(r.x + r.width, r.y + r.height, 0)); - - mesh.addVertex(glm::vec3(r.x + r.width, r.y + r.height, 0)); - mesh.addVertex(glm::vec3(r.x, r.y + r.height, 0)); - mesh.addVertex(glm::vec3(r.x, r.y, 0)); - - mesh.addColor(c); - mesh.addColor(c); - mesh.addColor(c); - - mesh.addColor(c); - mesh.addColor(c); - mesh.addColor(c); - - return mesh; - } -} - -//----------------------------------------------------------- -template -ofxInputField ofxInputField::createInsideSlider(){ - ofxInputField input; - input.insideSlider = true; - return input; -} - -//----------------------------------------------------------- -template -ofxInputField::ofxInputField(){ -} - -//----------------------------------------------------------- -template -ofxInputField::ofxInputField(ofParameter _val, float width, float height){ - setup(_val,width,height); -} - -//----------------------------------------------------------- -template -ofxInputField* ofxInputField::setup(ofParameter _val, float width, float height){ - value.makeReferenceTo(_val); - visibleInput = input = toString(value.get()); - b.x = 0; - b.y = 0; - b.width = width; - b.height = height; - bGuiActive = false; - setNeedsRedraw(); - - if(!insideSlider){ - registerMouseEvents(); - } - listeners.push_back(value.newListener(this,&ofxInputField::valueChanged)); - listeners.push_back(ofEvents().charEvent.newListener(this, &ofxInputField::charPressed, OF_EVENT_ORDER_BEFORE_APP)); - listeners.push_back(ofEvents().keyPressed.newListener(this, &ofxInputField::keyPressed, OF_EVENT_ORDER_BEFORE_APP)); - return this; -} - -//----------------------------------------------------------- -template -ofxInputField* ofxInputField::setup(const std::string& _name, Type _val, Type _min, Type _max, float width, float height){ - value.set(_name,_val,_min,_max); - return setup(value,width,height); -} - -//----------------------------------------------------------- -template -ofxInputField* ofxInputField::setup(const std::string& _name, Type _val){ - value.set(_name,_val); - return setup(value); -} - -//----------------------------------------------------------- -template -void ofxInputField::setMin(Type min){ - value.setMin(min); -} - -//----------------------------------------------------------- -template -Type ofxInputField::getMin(){ - return value.getMin(); -} - -//----------------------------------------------------------- -template -void ofxInputField::setMax(Type max){ - value.setMax(max); -} - -//----------------------------------------------------------- -template -Type ofxInputField::getMax(){ - return value.getMax(); -} - -//----------------------------------------------------------- -template -void ofxInputField::calculateSelectionArea(int selectIdx1, int selectIdx2){ - selectStartPos = selectIdx1; - selectEndPos = selectIdx2; - - if(selectEndPos>visibleInputEnd){ - visibleInputEnd = selectEndPos; - }else if(std::max(selectEndPos-1,0) totalTextWidth){ - substrWidth = 0; - visibleInput = ""; - auto substrLen = 0; - while(substrWidth < totalTextWidth){ - substrLen += 1; - visibleInput = ofUTF8Substring(input, visibleInputStart, substrLen); - substrWidth = getTextBoundingBox(ofUTF8Substring(input, visibleInputStart, substrLen),0,0).width; - } - substrLen -= 1; - visibleInput = ofUTF8Substring(input, visibleInputStart, substrLen); - substrWidth = getTextBoundingBox(ofUTF8Substring(input, visibleInputStart, substrLen),0,0).width; - visibleInputEnd = visibleInputStart + substrLen; - - if(selectEndPos > visibleInputEnd){ - substrWidth = 0; - visibleInput = ""; - visibleInputEnd = selectEndPos; - visibleInputStart = selectEndPos; - while(substrWidth < totalTextWidth){ - visibleInputStart -= 1; - visibleInput = ofUTF8Substring(input, visibleInputStart, visibleInputEnd - visibleInputStart); - substrWidth = getTextBoundingBox(ofUTF8Substring(input, visibleInputStart, visibleInputEnd - visibleInputStart),0,0).width; - } - visibleInputStart += 1; - visibleInput = ofUTF8Substring(input, visibleInputStart, visibleInputEnd - visibleInputStart); - substrWidth = getTextBoundingBox(ofUTF8Substring(input, visibleInputStart, visibleInputEnd - visibleInputStart),0,0).width; - } - } - - auto first = std::min(selectStartPos, selectEndPos); - auto last = std::max(selectStartPos, selectEndPos); - auto substrLength = ofUTF8Length(visibleInput); - float preSelectWidth = 0; - auto substrFirst = ofClamp(first-visibleInputStart, 0, substrLength); - auto substrLast = ofClamp(last-visibleInputStart, 0, substrLength); - if(first > visibleInputStart){ - std::string preSelectStr = ofUTF8Substring(visibleInput, 0, substrFirst); - preSelectWidth = getTextBoundingBox(preSelectStr,0,0).width; - } - - if(showLabelWhileEditing){ - selectStartX = b.getMaxX() - textPadding - substrWidth + preSelectWidth; - }else{ - selectStartX = b.x + textPadding + preSelectWidth; - } - - if(hasSelectedText()){ - std::string selectStr = ofUTF8Substring(visibleInput, substrFirst, substrLast - substrFirst); - selectionWidth = getTextBoundingBox(selectStr,0,0).width; - } - - setNeedsRedraw(); -} - -//----------------------------------------------------------- -template -void ofxInputField::moveCursor(int cursorPos){ - - if ( cursorPos < 0 ){ - return; - } - - lastCursorMoveTime = ofGetElapsedTimeMillis(); - - selectStartPos = selectEndPos = cursorPos; - selectionWidth = 0; - - if ( visibleInputEnd < ofUTF8Length( input ) ){ - // Attempt to extend visible input range. If a character was being entered - // somewhere inside the text, there might be enough space to the right to - // show the newly extended input. - visibleInputEnd += 1; - } - - if(cursorPos>visibleInputEnd){ - visibleInputEnd = cursorPos; - }else if(cursorPos totalTextWidth){ - substrWidth = 0; - visibleInput = ""; - auto substrLen = 0; - while(substrWidth < totalTextWidth){ - substrLen += 1; - visibleInput = ofUTF8Substring(input, visibleInputStart, substrLen); - substrWidth = getTextBoundingBox(ofUTF8Substring(input, visibleInputStart, substrLen),0,0).width; - } - substrLen -= 1; - visibleInput = ofUTF8Substring(input, visibleInputStart, substrLen); - substrWidth = getTextBoundingBox(ofUTF8Substring(input, visibleInputStart, substrLen),0,0).width; - visibleInputEnd = visibleInputStart + substrLen; - - if(cursorPos > visibleInputEnd){ - substrWidth = 0; - visibleInput = ""; - visibleInputEnd = cursorPos; - visibleInputStart = cursorPos; - while(substrWidth < totalTextWidth){ - visibleInputStart -= 1; - visibleInput = ofUTF8Substring(input, visibleInputStart, visibleInputEnd - visibleInputStart); - substrWidth = getTextBoundingBox(ofUTF8Substring(input, visibleInputStart, visibleInputEnd - visibleInputStart),0,0).width; - } - visibleInputStart += 1; - visibleInput = ofUTF8Substring(input, visibleInputStart, visibleInputEnd - visibleInputStart); - substrWidth = getTextBoundingBox(ofUTF8Substring(input, visibleInputStart, visibleInputEnd - visibleInputStart),0,0).width; - } - } - - - float beforeCursorWidth = 0; - if(selectStartPos > visibleInputStart){ - auto beforeCursorStr = ofUTF8Substring(visibleInput, 0, selectStartPos - visibleInputStart); - beforeCursorWidth = getTextBoundingBox(beforeCursorStr,0,0).width; - } - - if(showLabelWhileEditing){ - selectStartX = b.getMaxX() - textPadding - substrWidth + beforeCursorWidth; - }else{ - selectStartX = b.x + textPadding + beforeCursorWidth; - } - - setNeedsRedraw(); -} - -//----------------------------------------------------------- -template -bool ofxInputField::mouseMoved(ofMouseEventArgs & mouse){ - bool mouseOver = b.inside(mouse); - if(mouseOver != bMouseOver && !bGuiActive && overlappingLabel){ - setNeedsRedraw(); - } - bMouseOver = mouseOver; - return (isGuiDrawing() || insideSlider) && bMouseOver; -} - -//----------------------------------------------------------- -template -bool ofxInputField::mousePressed(ofMouseEventArgs & mouse){ - if(!isGuiDrawing() && !insideSlider){ - return false; - } - if(b.inside(mouse)){ - if(!insideSlider || mouse.button == OF_MOUSE_BUTTON_LEFT){ - bMousePressed = true; - if(bGuiActive){ - auto inputWidth = getTextBoundingBox(visibleInput,0,0).width; - float cursorX; - if(showLabelWhileEditing){ - cursorX = mouse.x - (b.x + b.width - textPadding - inputWidth); - }else{ - cursorX = mouse.x - (b.x + textPadding); - } - mousePressedPos = round(visibleInputStart + ofMap(cursorX, 0, inputWidth, 0, ofUTF8Length(visibleInput), true)); - moveCursor(mousePressedPos); - }else{ - calculateSelectionArea(0, ofUTF8Length(input)); - bGuiActive = true; - } - - setNeedsRedraw(); - } - return true; - - }else{ - if(bGuiActive){ - leaveFocus(); - } - } - return false; -} - -//----------------------------------------------------------- -template -bool ofxInputField::mouseDragged(ofMouseEventArgs & mouse){ - if(!isGuiDrawing() && !insideSlider){ - return false; - } - if(!bGuiActive){ - return false; - } - - if(!insideSlider || mouse.button == OF_MOUSE_BUTTON_LEFT){ - auto inputWidth = getTextBoundingBox(visibleInput,0,0).width; - float cursorX; - if(showLabelWhileEditing){ - cursorX = mouse.x - (b.x + b.width - textPadding - inputWidth); - }else{ - cursorX = mouse.x - (b.x + textPadding); - } - auto cursorPos = round(visibleInputStart + ofMap(cursorX, 0, inputWidth, 0, ofUTF8Length(visibleInput))); - cursorPos = ofClamp(cursorPos, 0, ofUTF8Length(input)); - calculateSelectionArea(mousePressedPos, cursorPos); - setNeedsRedraw(); - } - return true; -} - -//----------------------------------------------------------- -template -bool ofxInputField::mouseReleased(ofMouseEventArgs &){ - bMousePressed = false; - return bGuiActive; -} - -//----------------------------------------------------------- -template -bool ofxInputField::mouseScrolled(ofMouseEventArgs & mouse){ - if(b.inside(mouse)){ - if(!bGuiActive){ - if(mouse.y>0 || mouse.y<0){ - double range = getRange(value.getMin(), value.getMax(), b.width); - Type newValue = value + ofMap(mouse.y,-1,1,-range, range); - newValue = ofClamp(newValue,value.getMin(),value.getMax()); - value = newValue; - } - } - return true; - }else{ - return false; - } -} - -//----------------------------------------------------------- -template<> -bool ofxInputField::mouseScrolled(ofMouseEventArgs & mouse){ - if(b.inside(mouse)){ - return true; - }else{ - return false; - } -} - -//----------------------------------------------------------- -template -bool ofxInputField::charPressed(uint32_t & key){ - if(!isGuiDrawing() && !insideSlider){ - return false; - } - if(bGuiActive && !bMousePressed){ - if(key >= '0' && key <= '9'){ - moveCursor(insertKeystroke(key)); - }else if(key == '.' || key == '-' || key == '+'){ - moveCursor(insertKeystroke(key)); - }else{ - moveCursor(insertAlphabetic(key)); - } - return true; - } - return false; -} - -//----------------------------------------------------------- -template -bool ofxInputField::keyPressed(ofKeyEventArgs & args){ - if(!isGuiDrawing()){ - return false; - } - if(bGuiActive && !bMousePressed){ - auto key = args.key; - auto first = std::min(selectStartPos, selectEndPos); - auto last = std::max(selectStartPos, selectEndPos); - auto selectLen = last - first; - if(key == OF_KEY_BACKSPACE || key == OF_KEY_DEL){ - if(hasSelectedText()){ - ofUTF8Erase(input, first, selectLen); - moveCursor(selectStartPos); - }else{ - int deleteIdx = -1; - if(key == OF_KEY_BACKSPACE){ - deleteIdx = selectStartPos-1; - }else if(key == OF_KEY_DEL){ - deleteIdx = selectStartPos; - } - - //erase char if valid deleteIdx - if(deleteIdx >= 0 && deleteIdx < (int)ofUTF8Length(input)){ - ofUTF8Erase(input, deleteIdx, 1); - moveCursor(deleteIdx); - } - } - }else if(key == OF_KEY_LEFT){ - if(args.hasModifier(OF_KEY_SHIFT)){ - selectEndPos -= 1; - selectEndPos = std::max(0, selectEndPos); - calculateSelectionArea(selectStartPos, selectEndPos); - }else{ - if(hasSelectedText()){ - moveCursor(first); - }else{ - moveCursor(std::max(0, selectEndPos - 1)); - } - } - }else if(key == OF_KEY_RIGHT){ - if(args.hasModifier(OF_KEY_SHIFT)){ - auto inputSize = ofUTF8Length(input); - selectEndPos += 1; - selectEndPos = std::min(selectEndPos, int(inputSize)); - calculateSelectionArea(selectStartPos, selectEndPos); - }else{ - if(hasSelectedText()){ - moveCursor(last); - }else{ - auto inputSize = ofUTF8Length(input); - moveCursor(std::min(selectEndPos + 1, int(inputSize))); - } - } - }else if(key == OF_KEY_RETURN){ - leaveFocus(); - }else if(key == OF_KEY_ESC){ - input = toString(value.get()); - leaveFocus(); - }else if(key == 'a' && args.hasModifier(OF_KEY_CONTROL)){ - calculateSelectionArea(0, ofUTF8Length(input)); - }else if(key == 'c' && args.hasModifier(OF_KEY_CONTROL)){ - if(selectLen>0){ - auto selection = ofUTF8Substring(input, first, selectLen); - ofSetClipboardString(selection); - } - }else if(key == 'v' && args.hasModifier(OF_KEY_CONTROL)){ - auto cursorPos = first; - if(selectLen>0){ - ofUTF8Erase(input, cursorPos, selectLen); - } - auto clipboard = ofGetClipboardString(); - for(auto c: ofUTF8Iterator(clipboard)){ - ofUTF8Insert(input, cursorPos, c); - cursorPos+=1; - } - moveCursor(cursorPos); - }else if(key == 'x' && args.hasModifier(OF_KEY_CONTROL)){ - if(selectLen>0){ - auto selection = ofUTF8Substring(input, first, selectLen); - ofSetClipboardString(selection); - ofUTF8Erase(input, first, selectLen); - moveCursor(first); - } - }else if(key == OF_KEY_END){ - auto inputLength = ofUTF8Length(input); - if(args.hasModifier(OF_KEY_SHIFT)){ - calculateSelectionArea(selectStartPos, inputLength); - }else{ - moveCursor(inputLength); - } - }else if(key == OF_KEY_HOME){ - if(args.hasModifier(OF_KEY_SHIFT)){ - calculateSelectionArea(selectStartPos, 0); - }else{ - moveCursor(0); - } - } - return true; - } - return false; -} - - -//----------------------------------------------------------- -template -int ofxInputField::insertKeystroke(uint32_t character){ - auto first = std::min(selectStartPos, selectEndPos); - auto last = std::max(selectStartPos, selectEndPos); - auto selectLen = last - first; - if(hasSelectedText()){ - ofUTF8Erase(input, first, selectLen); - } - ofUTF8Insert(input, first, character); - auto cursorPos = first + 1; - - setNeedsRedraw(); - return cursorPos; -} - -//----------------------------------------------------------- -template -int ofxInputField::insertAlphabetic(uint32_t character){ - if(character == 'x' || character == 'a' || character == 'b' || character=='c' || character=='d' || character=='e' || character=='f'){ - return insertKeystroke(character); - }else{ - return -1; //cursor or selection area stay the same - } -} - -//----------------------------------------------------------- -template<> -int ofxInputField::insertAlphabetic(uint32_t character){ - return insertKeystroke(character); -} - -//----------------------------------------------------------- -template -Type ofxInputField::operator=(Type v){ - value = v; - return v; -} - -//----------------------------------------------------------- -template -ofxInputField::operator const Type & (){ - return value; -} - -//----------------------------------------------------------- -template -bool ofxInputField::hasSelectedText(){ - return selectStartPos != selectEndPos; -} - -//----------------------------------------------------------- -template -void ofxInputField::generateDraw(){ - bg.clear(); - - bg.append(rectangle(b, thisBackgroundColor)); - - if(bGuiActive){ - if(hasSelectedText()){ - ofRectangle selection(selectStartX, b.y+1, selectionWidth, b.height-2); - bg.append(rectangle(selection, thisFillColor)); - }else if(!blinkingCursor){ - ofRectangle cursor(selectStartX, b.y, 1, b.height); - bg.append(rectangle(cursor, thisTextColor)); - } - } - - auto input = visibleInput; - if(!bGuiActive && !containsValidValue()){ - input = toString(value); - } - - auto inputWidth = getTextBoundingBox(input,0,0).width; - auto label = getTextBoundingBox(getName(), b.x + textPadding, b.y + b.height / 2 + 4); - auto value = getTextBoundingBox(input, b.x + b.width - textPadding - inputWidth, b.y + b.height / 2 + 4); - overlappingLabel = label.getMaxX() > value.x; - - textMesh.clear(); - if(!bGuiActive || showLabelWhileEditing){ - if(!overlappingLabel || (!bMouseOver && !bGuiActive)){ - textMesh.append(getTextMesh(getName(), b.x + textPadding, b.y + b.height / 2 + 4) ); - } - if((!bGuiActive && (bMouseOver || !overlappingLabel)) || bGuiActive){ - textMesh.append(getTextMesh(input, b.x + b.width - textPadding - inputWidth, b.y + b.height / 2 + 4)); - } - }else{ - textMesh.append(getTextMesh(input, b.x + textPadding, b.y + b.height / 2 + 4)); - } - textMesh.getColors().assign(textMesh.getVertices().size(), thisTextColor); -} - -//----------------------------------------------------------- -template -void ofxInputField::render(){ - bg.draw(); - - if(!insideSlider && errorTime > 0 && !containsValidValue()){ - auto now = ofGetElapsedTimeMillis(); - auto pct = (now - errorTime) * 0.5f; - if(pct<1){ - for(size_t i=0;i -void ofxInputField::drawCursor(){ - auto now = ofGetElapsedTimeMillis(); - auto timeSinceLastCursorMove = now - lastCursorMoveTime; - - if(!blinkingCursor || ((now % 2000) >= 1000) || (timeSinceLastCursorMove < 500)){ - ofPushStyle(); - ofSetColor(thisTextColor); - ofDrawLine( selectStartX, b.y, selectStartX, b.y+b.height ); - ofPopStyle(); - } -} - -//----------------------------------------------------------- -template -void ofxInputField::setBlinkingCursor(bool blink){ - blinkingCursor = blink; - setNeedsRedraw(); -} - -//----------------------------------------------------------- -template -void ofxInputField::setShowLabelWhileEditing(bool show){ - showLabelWhileEditing = show; - setNeedsRedraw(); -} - -//----------------------------------------------------------- -template -bool ofxInputField::setValue(float mx, float my, bool bCheck){ - return false; -} - -//----------------------------------------------------------- -template -ofAbstractParameter & ofxInputField::getParameter(){ - return value; -} - -//----------------------------------------------------------- -template -void ofxInputField::parseInput(){ - try{ - Type tmpVal = fromString(input); - if(tmpVal < getMin()){ - tmpVal = getMin(); - }else if(tmpVal > getMax()){ - tmpVal = getMax(); - } - value = tmpVal; - validValue = true; - }catch(...){ - if(!insideSlider){ - originalColors = bg.getColors(); - errorTime = ofGetElapsedTimeMillis(); - } - validValue = false; - } -} - -//----------------------------------------------------------- -template<> -void ofxInputField::parseInput(){ - value = input; -} - -//----------------------------------------------------------- -template -void ofxInputField::valueChanged(Type & value){ - visibleInput = input = toString(value); - if(bGuiActive){ - moveCursor(ofUTF8Length(input)); - } - setNeedsRedraw(); -} - -//----------------------------------------------------------- -template -void ofxInputField::leaveFocus(){ - bGuiActive = false; - parseInput(); - setNeedsRedraw(); - leftFocus.notify(this); -} - -//----------------------------------------------------------- -template -bool ofxInputField::containsValidValue() const{ - return validValue; -} - -//----------------------------------------------------------- -template class ofxInputField; -template class ofxInputField; -template class ofxInputField; -template class ofxInputField; -template class ofxInputField; -template class ofxInputField; -template class ofxInputField; -template class ofxInputField; -template class ofxInputField; -template class ofxInputField; -template class ofxInputField; -template class ofxInputField::value || std::is_same::value, bool, size_t>::type>; diff --git a/addons/ofxGui/src/ofxInputField.h b/addons/ofxGui/src/ofxInputField.h deleted file mode 100644 index 72b3ad1..0000000 --- a/addons/ofxGui/src/ofxInputField.h +++ /dev/null @@ -1,106 +0,0 @@ -// -// ofxInputField.cpp -// ofxInputField -// -// Based on ofxInputField by Felix Lange -// -// - -#pragma once - -#include "ofxBaseGui.h" - -template -class ofxInputField : public ofxBaseGui{ - template - friend class ofxSlider; - - -public: - ofxInputField(); - ofxInputField(ofParameter _val, float width = defaultWidth, float height = defaultHeight); - ofxInputField* setup(ofParameter _val, float width = defaultWidth, float height = defaultHeight); - ofxInputField* setup(const std::string& _name, Type _val, Type _min, Type _max, float width = defaultWidth, float height = defaultHeight); - ofxInputField* setup(const std::string& _name, Type _val); - - void setMin(Type min); - Type getMin(); - void setMax(Type max); - Type getMax(); - - void setBlinkingCursor(bool blink); - void setShowLabelWhileEditing(bool show); - - virtual bool mouseMoved(ofMouseEventArgs & args); - virtual bool mousePressed(ofMouseEventArgs & args); - virtual bool mouseDragged(ofMouseEventArgs & args); - virtual bool mouseReleased(ofMouseEventArgs & args); - virtual bool mouseScrolled(ofMouseEventArgs & args); - virtual bool keyPressed(ofKeyEventArgs & args); - virtual bool charPressed(uint32_t & key); - - bool containsValidValue() const; - - template - void addListener(ListenerClass * listener, ListenerMethod method){ - value.addListener(listener,method); - } - - template - void removeListener(ListenerClass * listener, ListenerMethod method){ - value.removeListener(listener,method); - } - - Type operator=(Type v); - operator const Type & (); - - ofAbstractParameter & getParameter(); - -protected: - static ofxInputField createInsideSlider(); - virtual void render(); - ofParameter value; - bool bGuiActive=false, bMousePressed=false, bMouseOver=false; - bool setValue(float mx, float my, bool bCheck); - void generateDraw(); - void valueChanged(Type & value); - ofVboMesh bg; - ofVboMesh textMesh; - - std::string input; // input text - std::string visibleInput; // input text currently visible, i.e. not obscured by gui - int visibleInputStart = 0, visibleInputEnd = 0; // boundaries for visible input text - - void parseInput(); - int insertKeystroke(uint32_t character); - int insertAlphabetic(uint32_t character); - - bool hasSelectedText(); - - int mousePressedPos = -1; //set by mouse interaction - float selectStartX = -1, selectionWidth = 0; //calculated from select indices - int selectStartPos = -1, selectEndPos = -1; - void calculateSelectionArea(int selectIdx1, int selectIdx2); - void moveCursor(int cursorPos); - - virtual void drawCursor(); - - bool insideSlider = false; - bool blinkingCursor = true; - bool validValue = true; - bool showLabelWhileEditing = false; - bool overlappingLabel = false; - uint64_t errorTime = 0; // time last input error occured, used for animations - uint64_t lastCursorMoveTime = 0; // last time cursor was moved, used to calculate whether to blink - - void leaveFocus(); - - std::vector originalColors; - - ofEvent leftFocus; - std::vector listeners; -}; - -typedef ofxInputField ofxFloatField; -typedef ofxInputField ofxIntField; -typedef ofxInputField ofxTextField; diff --git a/addons/ofxGui/src/ofxLabel.cpp b/addons/ofxGui/src/ofxLabel.cpp deleted file mode 100644 index c7c82b3..0000000 --- a/addons/ofxGui/src/ofxLabel.cpp +++ /dev/null @@ -1,69 +0,0 @@ -#include "ofxLabel.h" -#include "ofGraphics.h" -using namespace std; - -ofxLabel::ofxLabel(ofParameter _label, float width, float height){ - setup(_label,width,height); -} - -ofxLabel::~ofxLabel(){ - label.removeListener(this,&ofxLabel::valueChanged); -} - -ofxLabel* ofxLabel::setup(ofParameter _label, float width, float height) { - label.makeReferenceTo(_label); - b.width = width; - b.height = height; - setNeedsRedraw(); - label.addListener(this,&ofxLabel::valueChanged); - return this; -} - -ofxLabel* ofxLabel::setup(const std::string& labelName, string _label, float width, float height) { - label.set(labelName,_label); - return setup(label,width,height); -} - -void ofxLabel::generateDraw(){ - bg.clear(); - - bg.setFillColor(thisBackgroundColor); - bg.setFilled(true); - bg.rectangle(b); - - string name; - if(!getName().empty()){ - name = getName() + ": "; - } - - textMesh = getTextMesh(name + (string)label, b.x + textPadding, b.y + b.height / 2 + 4); -} - -void ofxLabel::render() { - ofColor c = ofGetStyle().color; - - bg.draw(); - - ofBlendMode blendMode = ofGetStyle().blendingMode; - if(blendMode!=OF_BLENDMODE_ALPHA){ - ofEnableAlphaBlending(); - } - ofSetColor(textColor); - - bindFontTexture(); - textMesh.draw(); - unbindFontTexture(); - - ofSetColor(c); - if(blendMode!=OF_BLENDMODE_ALPHA){ - ofEnableBlendMode(blendMode); - } -} - -ofAbstractParameter & ofxLabel::getParameter(){ - return label; -} - -void ofxLabel::valueChanged(string & value){ - setNeedsRedraw(); -} diff --git a/addons/ofxGui/src/ofxLabel.h b/addons/ofxGui/src/ofxLabel.h deleted file mode 100644 index ca786be..0000000 --- a/addons/ofxGui/src/ofxLabel.h +++ /dev/null @@ -1,50 +0,0 @@ -#pragma once - -#include "ofxBaseGui.h" -#include "ofParameter.h" - -class ofxLabel: public ofxBaseGui { -public: - ofxLabel(){} - ofxLabel(ofParameter _label, float width = defaultWidth, float height = defaultHeight); - virtual ~ofxLabel(); - - ofxLabel * setup(ofParameter _label, float width = defaultWidth, float height = defaultHeight); - ofxLabel * setup(const std::string& labelName, std::string label, float width = defaultWidth, float height = defaultHeight); - - // Abstract methods we must implement, but have no need for! - virtual bool mouseMoved(ofMouseEventArgs & args){return false;} - virtual bool mousePressed(ofMouseEventArgs & args){return false;} - virtual bool mouseDragged(ofMouseEventArgs & args){return false;} - virtual bool mouseReleased(ofMouseEventArgs & args){return false;} - virtual bool mouseScrolled(ofMouseEventArgs & args){return false;} - - virtual void saveTo(ofBaseSerializer& serializer){}; - virtual void loadFrom(ofBaseSerializer& serializer){}; - - - template - void addListener(ListenerClass * listener, ListenerMethod method){ - label.addListener(listener,method); - } - - template - void removeListener(ListenerClass * listener, ListenerMethod method){ - label.removeListener(listener,method); - } - - - std::string operator=(std::string v) { label = v; return v; } - operator const std::string & () { return label; } - - ofAbstractParameter & getParameter(); - -protected: - void render(); - ofParameter label; - void generateDraw(); - void valueChanged(std::string & value); - bool setValue(float mx, float my, bool bCheckBounds){return false;} - ofPath bg; - ofVboMesh textMesh; -}; diff --git a/addons/ofxGui/src/ofxPanel.cpp b/addons/ofxGui/src/ofxPanel.cpp deleted file mode 100644 index 5cacfca..0000000 --- a/addons/ofxGui/src/ofxPanel.cpp +++ /dev/null @@ -1,165 +0,0 @@ -/* - * ofPanel.cpp - * - * Created on: 14/02/2012 - * Author: arturo - */ - -#include "ofxPanel.h" -#include "ofGraphics.h" -#include "ofImage.h" -using namespace std; - -ofImage ofxPanel::loadIcon; -ofImage ofxPanel::saveIcon; - -ofxPanel::ofxPanel() -:bGrabbed(false){} - -ofxPanel::ofxPanel(const ofParameterGroup & parameters, const std::string& filename, float x, float y) -: ofxGuiGroup(parameters, filename, x, y) -, bGrabbed(false){ - if(!loadIcon.isAllocated() || !saveIcon.isAllocated()){ - loadIcons(); - } - registerMouseEvents(); - setNeedsRedraw(); -} - -ofxPanel::~ofxPanel(){ - // -} - -ofxPanel * ofxPanel::setup(const std::string& collectionName, const std::string& filename, float x, float y){ - if(!loadIcon.isAllocated() || !saveIcon.isAllocated()){ - loadIcons(); - } - registerMouseEvents(); - return (ofxPanel*)ofxGuiGroup::setup(collectionName,filename,x,y); -} - -ofxPanel * ofxPanel::setup(const ofParameterGroup & parameters, const std::string& filename, float x, float y){ - if(!loadIcon.isAllocated() || !saveIcon.isAllocated()){ - loadIcons(); - } - registerMouseEvents(); - return (ofxPanel*)ofxGuiGroup::setup(parameters,filename,x,y); -} - -void ofxPanel::loadIcons(){ - unsigned char loadIconData[] = {0x38,0x88,0xa,0x6,0x7e,0x60,0x50,0x11,0x1c}; - unsigned char saveIconData[] = {0xff,0x4a,0x95,0xea,0x15,0xa8,0x57,0xa9,0x7f}; - loadIcon.allocate(9, 8, OF_IMAGE_COLOR_ALPHA); - saveIcon.allocate(9, 8, OF_IMAGE_COLOR_ALPHA); - loadStencilFromHex(loadIcon, loadIconData); - loadStencilFromHex(saveIcon, saveIconData); - - loadIcon.getTexture().setTextureMinMagFilter(GL_NEAREST,GL_NEAREST); - saveIcon.getTexture().setTextureMinMagFilter(GL_NEAREST,GL_NEAREST); -} - -void ofxPanel::generateDraw(){ - border.clear(); - border.setStrokeColor(thisBorderColor); - border.setStrokeWidth(1); - border.setFilled(false); - border.rectangle(b.x,b.y,b.width+1,b.height-spacingNextElement); - - - headerBg.clear(); - headerBg.setFillColor(ofColor(thisHeaderBackgroundColor,180)); - headerBg.setFilled(true); - headerBg.rectangle(b.x,b.y+1,b.width,header); - - float iconHeight = header*.5; - float iconWidth = loadIcon.getWidth()/loadIcon.getHeight()*iconHeight; - int iconSpacing = iconWidth*.5; - - loadBox.x = b.getMaxX() - (iconWidth * 2 + iconSpacing + textPadding); - loadBox.y = b.y + header / 2. - iconHeight / 2.; - loadBox.width = iconWidth; - loadBox.height = iconHeight; - saveBox.set(loadBox); - saveBox.x += iconWidth + iconSpacing; - - textMesh = getTextMesh(getName(), textPadding + b.x, header / 2 + 4 + b.y); -} - -void ofxPanel::render(){ - border.draw(); - headerBg.draw(); - - ofBlendMode blendMode = ofGetStyle().blendingMode; - if(blendMode!=OF_BLENDMODE_ALPHA){ - ofEnableAlphaBlending(); - } - ofColor c = ofGetStyle().color; - ofSetColor(thisTextColor); - - bindFontTexture(); - textMesh.draw(); - unbindFontTexture(); - - bool texHackEnabled = ofIsTextureEdgeHackEnabled(); - ofDisableTextureEdgeHack(); - loadIcon.draw(loadBox); - saveIcon.draw(saveBox); - if(texHackEnabled){ - ofEnableTextureEdgeHack(); - } - - for(std::size_t i = 0; i < collection.size(); i++){ - collection[i]->draw(); - } - - ofSetColor(c); - if(blendMode!=OF_BLENDMODE_ALPHA){ - ofEnableBlendMode(blendMode); - } -} - -bool ofxPanel::mouseReleased(ofMouseEventArgs & args){ - this->bGrabbed = false; - if(ofxGuiGroup::mouseReleased(args)) return true; - if(isGuiDrawing() && b.inside(ofPoint(args.x,args.y))){ - return true; - }else{ - return false; - } -} - -bool ofxPanel::setValue(float mx, float my, bool bCheck){ - - if( !isGuiDrawing() ){ - bGrabbed = false; - bGuiActive = false; - return false; - } - if( bCheck ){ - if( b.inside(mx, my) ){ - bGuiActive = true; - - if( my > b.y && my <= b.y + header ){ - bGrabbed = true; - grabPt.set(mx-b.x, my-b.y); - } else{ - bGrabbed = false; - } - - if(loadBox.inside(mx, my)) { - loadFromFile(filename); - ofNotifyEvent(loadPressedE,this); - return true; - } - if(saveBox.inside(mx, my)) { - saveToFile(filename); - ofNotifyEvent(savePressedE,this); - return true; - } - } - } else if( bGrabbed ){ - setPosition(mx - grabPt.x,my - grabPt.y); - return true; - } - return false; -} diff --git a/addons/ofxGui/src/ofxPanel.h b/addons/ofxGui/src/ofxPanel.h deleted file mode 100644 index 8c95121..0000000 --- a/addons/ofxGui/src/ofxPanel.h +++ /dev/null @@ -1,31 +0,0 @@ -#pragma once - -#include "ofxGuiGroup.h" - -class ofxGuiGroup; - -class ofxPanel : public ofxGuiGroup { -public: - ofxPanel(); - ofxPanel(const ofParameterGroup & parameters, const std::string& filename="settings.xml", float x = 10, float y = 10); - ~ofxPanel(); - - ofxPanel * setup(const std::string& collectionName="", const std::string& filename="settings.xml", float x = 10, float y = 10); - ofxPanel * setup(const ofParameterGroup & parameters, const std::string& filename="settings.xml", float x = 10, float y = 10); - - bool mouseReleased(ofMouseEventArgs & args); - - ofEvent loadPressedE; - ofEvent savePressedE; -protected: - void render(); - bool setValue(float mx, float my, bool bCheck); - void generateDraw(); - void loadIcons(); -private: - ofRectangle loadBox, saveBox; - static ofImage loadIcon, saveIcon; - - ofPoint grabPt; - bool bGrabbed; -}; diff --git a/addons/ofxGui/src/ofxSlider.cpp b/addons/ofxGui/src/ofxSlider.cpp deleted file mode 100644 index 1d7c0a7..0000000 --- a/addons/ofxGui/src/ofxSlider.cpp +++ /dev/null @@ -1,249 +0,0 @@ -#include "ofxSlider.h" -#include "ofGraphics.h" -using namespace std; - -template -ofxSlider::ofxSlider(){ - bUpdateOnReleaseOnly = false; - bGuiActive = false; - mouseInside = false; -} - -template -ofxSlider::~ofxSlider(){ - value.removeListener(this,&ofxSlider::valueChanged); -} - -template -ofxSlider::ofxSlider(ofParameter _val, float width, float height){ - setup(_val,width,height); -} - -template -ofxSlider* ofxSlider::setup(ofParameter _val, float width, float height){ - bUpdateOnReleaseOnly = false; - value.makeReferenceTo(_val); - b.x = 0; - b.y = 0; - b.width = width; - b.height = height; - bGuiActive = false; - setNeedsRedraw(); - - value.addListener(this,&ofxSlider::valueChanged); - registerMouseEvents(); - return this; -} - -template -ofxSlider* ofxSlider::setup(const std::string& sliderName, Type _val, Type _min, Type _max, float width, float height){ - value.set(sliderName,_val,_min,_max); - return setup(value,width,height); -} - -template -void ofxSlider::setMin(Type min){ - value.setMin(min); -} - -template -Type ofxSlider::getMin(){ - return value.getMin(); -} - -template -void ofxSlider::setMax(Type max){ - value.setMax(max); -} - -template -Type ofxSlider::getMax(){ - return value.getMax(); -} - -template -bool ofxSlider::mouseMoved(ofMouseEventArgs & args){ - mouseInside = isGuiDrawing() && b.inside(ofPoint(args.x,args.y)); - return mouseInside; -} - -template -bool ofxSlider::mousePressed(ofMouseEventArgs & args){ - if(bUpdateOnReleaseOnly){ - value.disableEvents(); - } - if(setValue(args.x, args.y, true)){ - return true; - }else{ - return false; - } -} - -template -bool ofxSlider::mouseDragged(ofMouseEventArgs & args){ - if(setValue(args.x, args.y, false)){ - return true; - }else{ - return false; - } -} - -template -bool ofxSlider::mouseReleased(ofMouseEventArgs & args){ - if(bUpdateOnReleaseOnly){ - value.enableEvents(); - } - bool attended = setValue(args.x, args.y, false); - - bGuiActive = false; - if(attended){ - return true; - }else{ - return false; - } -} - -template -typename std::enable_if::value, Type>::type -getRange(Type min, Type max, float width){ - double range = max - min; - range /= width*4; - return std::max(range,1.0); -} - -template -typename std::enable_if::value, Type>::type -getRange(Type min, Type max, float width){ - double range = max - min; - range /= width*4; - return range; -} - -template -bool ofxSlider::mouseScrolled(ofMouseEventArgs & args){ - if(mouseInside){ - if(args.scrollY>0 || args.scrollY<0){ - double range = getRange(value.getMin(),value.getMax(),b.width); - Type newValue = value + ofMap(args.scrollY,-1,1,-range, range); - newValue = ofClamp(newValue,value.getMin(),value.getMax()); - value = newValue; - } - return true; - }else{ - return false; - } -} - -template -double ofxSlider::operator=(Type v){ - value = v; - return v; -} - -template -ofxSlider::operator const Type & (){ - return value; -} - -template -void ofxSlider::generateDraw(){ - bg.clear(); - bar.clear(); - - bg.setFillColor(thisBackgroundColor); - bg.setFilled(true); - bg.rectangle(b); - - float valAsPct = ofMap( value, value.getMin(), value.getMax(), 0, b.width-2, true ); - bar.setFillColor(thisFillColor); - bar.setFilled(true); - bar.rectangle(b.x+1, b.y+1, valAsPct, b.height-2); - - generateText(); -} - - -template -void ofxSlider::generateText(){ - string valStr = ofToString(value); - textMesh = getTextMesh(getName(), b.x + textPadding, b.y + b.height / 2 + 4); - textMesh.append(getTextMesh(valStr, b.x + b.width - textPadding - getTextBoundingBox(valStr,0,0).width, b.y + b.height / 2 + 4)); -} - -template<> -void ofxSlider::generateText(){ - string valStr = ofToString((int)value); - textMesh = getTextMesh(getName(), b.x + textPadding, b.y + b.height / 2 + 4); - textMesh.append(getTextMesh(valStr, b.x + b.width - textPadding - getTextBoundingBox(valStr,0,0).width, b.y + b.height / 2 + 4)); -} - -template -void ofxSlider::render(){ - ofColor c = ofGetStyle().color; - - bg.draw(); - bar.draw(); - - ofBlendMode blendMode = ofGetStyle().blendingMode; - if(blendMode!=OF_BLENDMODE_ALPHA){ - ofEnableAlphaBlending(); - } - ofSetColor(thisTextColor); - - bindFontTexture(); - textMesh.draw(); - unbindFontTexture(); - - ofSetColor(c); - if(blendMode!=OF_BLENDMODE_ALPHA){ - ofEnableBlendMode(blendMode); - } -} - - -template -bool ofxSlider::setValue(float mx, float my, bool bCheck){ - if( !isGuiDrawing() ){ - bGuiActive = false; - return false; - } - if( bCheck ){ - if( b.inside(mx, my) ){ - bGuiActive = true; - }else{ - bGuiActive = false; - } - } - if( bGuiActive ){ - value = ofMap(mx, b.x, b.x + b.width, value.getMin(), value.getMax(), true); - return true; - } - return false; -} - -template -ofAbstractParameter & ofxSlider::getParameter(){ - return value; -} - - -template -void ofxSlider::setUpdateOnReleaseOnly(bool _bUpdateOnReleaseOnly){ - bUpdateOnReleaseOnly = _bUpdateOnReleaseOnly; -} - -template -void ofxSlider::valueChanged(Type & value){ - setNeedsRedraw(); -} - -template class ofxSlider; -template class ofxSlider; -template class ofxSlider; -template class ofxSlider; -template class ofxSlider; -template class ofxSlider; -template class ofxSlider; -template class ofxSlider; -template class ofxSlider; -template class ofxSlider; diff --git a/addons/ofxGui/src/ofxSlider.h b/addons/ofxGui/src/ofxSlider.h deleted file mode 100644 index 3c36832..0000000 --- a/addons/ofxGui/src/ofxSlider.h +++ /dev/null @@ -1,65 +0,0 @@ -#pragma once - -#include "ofxBaseGui.h" -#include "ofParameter.h" - -template -class ofxSlider : public ofxBaseGui{ - friend class ofPanel; - -public: - ofxSlider(); - ~ofxSlider(); - ofxSlider(ofParameter _val, float width = defaultWidth, float height = defaultHeight); - ofxSlider* setup(ofParameter _val, float width = defaultWidth, float height = defaultHeight); - ofxSlider* setup(const std::string& sliderName, Type _val, Type _min, Type _max, float width = defaultWidth, float height = defaultHeight); - - void setMin(Type min); - Type getMin(); - void setMax(Type max); - Type getMax(); - - virtual bool mouseMoved(ofMouseEventArgs & args); - virtual bool mousePressed(ofMouseEventArgs & args); - virtual bool mouseDragged(ofMouseEventArgs & args); - virtual bool mouseReleased(ofMouseEventArgs & args); - virtual bool mouseScrolled(ofMouseEventArgs & args); - - void setUpdateOnReleaseOnly(bool bUpdateOnReleaseOnly); - - - template - void addListener(ListenerClass * listener, ListenerMethod method){ - value.addListener(listener,method); - } - - template - void removeListener(ListenerClass * listener, ListenerMethod method){ - value.removeListener(listener,method); - } - - - - double operator=(Type v); - operator const Type & (); - - - - ofAbstractParameter & getParameter(); - -protected: - virtual void render(); - ofParameter value; - bool bUpdateOnReleaseOnly; - bool bGuiActive; - bool mouseInside; - bool setValue(float mx, float my, bool bCheck); - virtual void generateDraw(); - virtual void generateText(); - void valueChanged(Type & value); - ofPath bg, bar; - ofVboMesh textMesh; -}; - -typedef ofxSlider ofxFloatSlider; -typedef ofxSlider ofxIntSlider; diff --git a/addons/ofxGui/src/ofxSliderGroup.cpp b/addons/ofxGui/src/ofxSliderGroup.cpp deleted file mode 100644 index bf9f736..0000000 --- a/addons/ofxGui/src/ofxSliderGroup.cpp +++ /dev/null @@ -1,172 +0,0 @@ -#include "ofxSliderGroup.h" -using namespace std; - -template -ofxVecSlider_::ofxVecSlider_(ofParameter value, float width, float height){ - sliderChanging = false; - setup(value, width, height); -} - -template -ofxVecSlider_ * ofxVecSlider_::setup(ofParameter value, float width, float height){ - ofxGuiGroup::setup(value.getName(), "", 0, 0); - - parameters.clear(); - - const string names[4] = {"x", "y", "z", "w"}; - - this->value.makeReferenceTo(value); - this->value.addListener(this, & ofxVecSlider_::changeValue); - - VecType val = value; - VecType min = value.getMin(); - VecType max = value.getMax(); - - for (int i=0; i p(names[i], val[i], min[i], max[i]); - add(new ofxSlider(p, width, height)); - p.addListener(this, & ofxVecSlider_::changeSlider); - } - - sliderChanging = false; - return this; - -} - -template -ofxVecSlider_ * ofxVecSlider_::setup(const std::string& controlName, const VecType & v, const VecType & min, const VecType & max, float width, float height){ - value.set(controlName,v,min,max); - return setup(value,width,height); -} - -template -void ofxVecSlider_::changeSlider(const void * parameter, float & _value){ - sliderChanging = true; - ofParameter & param = *(ofParameter*)parameter; - int i = parameters.getPosition(param.getName()); - VecType data = value; - data[i] = _value; - value = data; - sliderChanging = false; -} - -template -void ofxVecSlider_::changeValue(VecType & value){ - if (sliderChanging){ - return; - } - for (int i=0; i() = value[i]; - } -} - -template -ofAbstractParameter & ofxVecSlider_::getParameter(){ - return value; -} - -template -VecType ofxVecSlider_::operator=(const VecType & v){ - value = v; - return value; -} - -template -ofxVecSlider_::operator const VecType & (){ - return value; -} - -template -const VecType * ofxVecSlider_::operator->(){ - return &value.get(); -} - -template class ofxVecSlider_; -template class ofxVecSlider_; -template class ofxVecSlider_; - - -template -ofxColorSlider_::ofxColorSlider_(ofParameter > value, float width, float height){ - sliderChanging = false; - setup(value, width, height); -} - -template -ofxColorSlider_ * ofxColorSlider_::setup(ofParameter > value, float width, float height){ - ofxGuiGroup::setup(value.getName(), "", 0, 0); - parameters.clear(); - - const string names[4] = {"r", "g", "b", "a"}; - - this->value.makeReferenceTo(value); - this->value.addListener(this, & ofxColorSlider_::changeValue); - - ofColor_ val = value; - ofColor_ min = value.getMin(); - ofColor_ max = value.getMax(); - - for (int i=0; i<4; i++) { - ofParameter p(names[i], val[i], min[i], max[i]); - add(new ofxSlider(p, width, height)); - p.addListener(this, & ofxColorSlider_::changeSlider); - collection[i]->setFillColor(value.get()); - } - - sliderChanging = false; - return this; -} - - -template -ofxColorSlider_ * ofxColorSlider_::setup(const std::string& controlName, const ofColor_ & v, const ofColor_ & min, const ofColor_ & max, float width, float height){ - value.set(controlName, v, min, max); - return setup(value,width,height); -} - -template -void ofxColorSlider_::changeSlider(const void * parameter, ColorType & _value){ - sliderChanging = true; - ofParameter & param = *(ofParameter*)parameter; - int i = parameters.getPosition(param.getName()); - ofColor_ data = value; - data[i] = _value; - value = data; - - - for (int i=0; i<4; i++){ - collection[i]->setFillColor(value.get()); - } - sliderChanging = false; -} - -template -void ofxColorSlider_::changeValue(ofColor_ & value){ - if (sliderChanging){ - return; - } - for (int i=0; i<4; i++){ - parameters[i].template cast() = value[i]; - collection[i]->setFillColor(value); - } -} - -template -ofAbstractParameter & ofxColorSlider_::getParameter(){ - return value; -} - -template -ofColor_ ofxColorSlider_::operator=(const ofColor_ & v){ - value = v; - return value; -} - -template -ofxColorSlider_::operator const ofColor_ & (){ - return value; -} - -template class ofxColorSlider_; -template class ofxColorSlider_; -template class ofxColorSlider_; diff --git a/addons/ofxGui/src/ofxSliderGroup.h b/addons/ofxGui/src/ofxSliderGroup.h deleted file mode 100644 index f85096a..0000000 --- a/addons/ofxGui/src/ofxSliderGroup.h +++ /dev/null @@ -1,59 +0,0 @@ -#pragma once - -#include "ofxGuiGroup.h" -#include "ofxSlider.h" - -template -class ofxVecSlider_ : public ofxGuiGroup { -public: - ofxVecSlider_(){ - sliderChanging = false; - }; - ofxVecSlider_(ofParameter value, float width = defaultWidth, float height = defaultHeight); - - ofxVecSlider_ * setup(ofParameter value, float width = defaultWidth, float height = defaultHeight); - ofxVecSlider_ * setup(const std::string& controlName, const VecType & value, const VecType & min, const VecType & max, float width = defaultWidth, float height = defaultHeight); - - ofAbstractParameter & getParameter(); - - VecType operator=(const VecType & v); - operator const VecType & (); - const VecType * operator->(); -protected: - void changeSlider(const void * parameter, float & value); - void changeValue(VecType & value); - ofParameter value; - bool sliderChanging; -}; - -typedef ofxVecSlider_ ofxVec3Slider; -typedef ofxVecSlider_ ofxVec2Slider; -typedef ofxVecSlider_ ofxVec4Slider; -typedef ofxVecSlider_ ofxPointSlider; - -template -class ofxColorSlider_: public ofxGuiGroup{ - -public: - ofxColorSlider_(){ - sliderChanging = false; - }; - ofxColorSlider_(ofParameter > value, float width = defaultWidth, float height = defaultHeight); - - ofxColorSlider_ * setup(ofParameter > value, float width = defaultWidth, float height = defaultHeight); - ofxColorSlider_ * setup(const std::string& controlName, const ofColor_ & value, const ofColor_ & min, const ofColor_ & max, float width = defaultWidth, float height = defaultHeight); - - ofAbstractParameter & getParameter(); - - ofColor_ operator=(const ofColor_ & v); - operator const ofColor_ & (); -protected: - void changeSlider(const void * parameter, ColorType & value); - void changeValue(ofColor_ & value); - ofParameter > value; - bool sliderChanging; -}; - -typedef ofxColorSlider_ ofxColorSlider; -typedef ofxColorSlider_ ofxShortColorSlider; -typedef ofxColorSlider_ ofxFloatColorSlider; diff --git a/addons/ofxGui/src/ofxToggle.cpp b/addons/ofxGui/src/ofxToggle.cpp deleted file mode 100644 index b6e7f2b..0000000 --- a/addons/ofxGui/src/ofxToggle.cpp +++ /dev/null @@ -1,163 +0,0 @@ -#include "ofxToggle.h" -#include "ofGraphics.h" -using namespace std; - -ofxToggle::ofxToggle(ofParameter _bVal, float width, float height){ - setup(_bVal,width,height); -} - -ofxToggle::~ofxToggle(){ - value.removeListener(this,&ofxToggle::valueChanged); -} - -ofxToggle * ofxToggle::setup(ofParameter _bVal, float width, float height){ - b.x = 0; - b.y = 0; - b.width = width; - b.height = height; - bGuiActive = false; - value.makeReferenceTo(_bVal); - checkboxRect.set(1, 1, b.height - 2, b.height - 2); - - value.addListener(this,&ofxToggle::valueChanged); - registerMouseEvents(); - setNeedsRedraw(); - - return this; - -} - -ofxToggle * ofxToggle::setup(const std::string& toggleName, bool _bVal, float width, float height){ - value.set(toggleName,_bVal); - return setup(value,width,height); -} - - -bool ofxToggle::mouseMoved(ofMouseEventArgs & args){ - if(isGuiDrawing() && b.inside(ofPoint(args.x,args.y))){ - return true; - }else{ - return false; - } -} - -bool ofxToggle::mousePressed(ofMouseEventArgs & args){ - if(setValue(args.x, args.y, true)){ - return true; - }else{ - return false; - } -} - -bool ofxToggle::mouseDragged(ofMouseEventArgs & args){ - if(bGuiActive && b.inside(ofPoint(args.x,args.y))){ - return true; - }else{ - return false; - } -} - -bool ofxToggle::mouseReleased(ofMouseEventArgs & args){ - bool wasGuiActive = bGuiActive; - bGuiActive = false; - if(wasGuiActive && b.inside(ofPoint(args.x,args.y))){ - return true; - }else{ - return false; - } -} - -void ofxToggle::generateDraw(){ - bg.clear(); - bg.setFillColor(thisBackgroundColor); - bg.rectangle(b); - - fg.clear(); - if(value){ - fg.setFilled(true); - fg.setFillColor(thisFillColor); - }else{ - fg.setFilled(false); - fg.setStrokeWidth(1); - fg.setStrokeColor(thisFillColor); - } - fg.rectangle(b.getPosition()+checkboxRect.getTopLeft(),checkboxRect.width,checkboxRect.height); - - cross.clear(); - cross.setStrokeColor(thisTextColor); - cross.setStrokeWidth(1); - cross.setFilled(false); - cross.moveTo(b.getPosition()+checkboxRect.getTopLeft()); - cross.lineTo(b.getPosition()+checkboxRect.getBottomRight()); - cross.moveTo(b.getPosition()+checkboxRect.getTopRight()); - cross.lineTo(b.getPosition()+checkboxRect.getBottomLeft()); - - textMesh = getTextMesh(getName(), b.x+textPadding + checkboxRect.width, b.y+b.height / 2 + 4); -} - -void ofxToggle::render(){ - bg.draw(); - fg.draw(); - - if( value ){ - cross.draw(); - } - - ofColor c = ofGetStyle().color; - ofBlendMode blendMode = ofGetStyle().blendingMode; - if(blendMode!=OF_BLENDMODE_ALPHA){ - ofEnableAlphaBlending(); - } - ofSetColor(thisTextColor); - - bindFontTexture(); - textMesh.draw(); - unbindFontTexture(); - - ofSetColor(c); - if(blendMode!=OF_BLENDMODE_ALPHA){ - ofEnableBlendMode(blendMode); - } -} - -bool ofxToggle::operator=(bool v){ - value = v; - return v; -} - -ofxToggle::operator const bool & (){ - return value; -} - -bool ofxToggle::setValue(float mx, float my, bool bCheck){ - - if( !isGuiDrawing() ){ - bGuiActive = false; - return false; - } - if( bCheck ){ - ofRectangle checkRect = checkboxRect; - checkRect.x += b.x; - checkRect.y += b.y; - - if( checkRect.inside(mx, my) ){ - bGuiActive = true; - }else{ - bGuiActive = false; - - } - } - if( bGuiActive ){ - value = !value; - return true; - } - return false; -} - -ofAbstractParameter & ofxToggle::getParameter(){ - return value; -} - -void ofxToggle::valueChanged(bool & value){ - setNeedsRedraw(); -} diff --git a/addons/ofxGui/src/ofxToggle.h b/addons/ofxGui/src/ofxToggle.h deleted file mode 100644 index 1d8eaa6..0000000 --- a/addons/ofxGui/src/ofxToggle.h +++ /dev/null @@ -1,50 +0,0 @@ -#pragma once - -#include "ofParameter.h" -#include "ofxBaseGui.h" - -class ofxToggle : public ofxBaseGui{ -public: - ofxToggle(){}; - ~ofxToggle(); - ofxToggle(ofParameter _bVal, float width = defaultWidth, float height = defaultHeight); - ofxToggle * setup(ofParameter _bVal, float width = defaultWidth, float height = defaultHeight); - ofxToggle * setup(const std::string& toggleName, bool _bVal, float width = defaultWidth, float height = defaultHeight); - - - virtual bool mouseMoved(ofMouseEventArgs & args); - virtual bool mousePressed(ofMouseEventArgs & args); - virtual bool mouseDragged(ofMouseEventArgs & args); - virtual bool mouseReleased(ofMouseEventArgs & args); - virtual bool mouseScrolled(ofMouseEventArgs & args){return false;} - - - template - void addListener(ListenerClass * listener, ListenerMethod method){ - value.addListener(listener,method); - } - - template - void removeListener(ListenerClass * listener, ListenerMethod method){ - value.removeListener(listener,method); - } - - - - bool operator=(bool v); - operator const bool & (); - - virtual ofAbstractParameter & getParameter(); - -protected: - virtual void render(); - ofRectangle checkboxRect; - ofParameter value; - bool bGuiActive; - - bool setValue(float mx, float my, bool bCheck); - void generateDraw(); - void valueChanged(bool & value); - ofPath bg,fg,cross; - ofVboMesh textMesh; -}; diff --git a/addons/ofxKinectForWindows2/ofxKinectForWindows2Lib/ofxKinectForWindows2Lib.vcxproj b/addons/ofxKinectForWindows2/ofxKinectForWindows2Lib/ofxKinectForWindows2Lib.vcxproj index 206b6f9..1c67b2d 100644 --- a/addons/ofxKinectForWindows2/ofxKinectForWindows2Lib/ofxKinectForWindows2Lib.vcxproj +++ b/addons/ofxKinectForWindows2/ofxKinectForWindows2Lib/ofxKinectForWindows2Lib.vcxproj @@ -21,32 +21,32 @@ {F6008D6A-6D39-4B68-840E-E7AC8ED855DA} ofxKinectForWindows2Lib - 8.1 + 10.0 StaticLibrary true - v140 + v142 MultiByte StaticLibrary true - v140 + v142 MultiByte StaticLibrary false - v140 + v142 true MultiByte StaticLibrary false - v140 + v142 true MultiByte diff --git a/addons/ofxKinectForWindows2/src/ofxKinectForWindows2/Device.cpp b/addons/ofxKinectForWindows2/src/ofxKinectForWindows2/Device.cpp index 4e8a98f..2244617 100644 --- a/addons/ofxKinectForWindows2/src/ofxKinectForWindows2/Device.cpp +++ b/addons/ofxKinectForWindows2/src/ofxKinectForWindows2/Device.cpp @@ -367,7 +367,7 @@ namespace ofxKinectForWindows2 { bodySource->drawWorld(); ofPushMatrix(); - ofRotate(90, 0, 0, 1); + ofRotateDeg(90, 0, 0, 1); ofMultMatrix(bodySource->getFloorTransform()); ofDrawGridPlane(5.0f); ofPopMatrix(); diff --git a/addons/ofxKinectForWindows2/src/ofxKinectForWindows2/Source/Body.cpp b/addons/ofxKinectForWindows2/src/ofxKinectForWindows2/Source/Body.cpp index 36de75d..26a3c86 100644 --- a/addons/ofxKinectForWindows2/src/ofxKinectForWindows2/Source/Body.cpp +++ b/addons/ofxKinectForWindows2/src/ofxKinectForWindows2/Source/Body.cpp @@ -18,7 +18,8 @@ namespace ofxKinectForWindows2 { ofNode helper; helper.lookAt(ofVec3f(floorClipPlane.x, floorClipPlane.z, -floorClipPlane.y)); helper.boom(-floorClipPlane.w); - ofMatrix4x4 transform = helper.getGlobalTransformMatrix().getInverse(); + ofMatrix4x4 transform = inverse(helper.getGlobalTransformMatrix()); + return transform; } diff --git a/addons/ofxLua/.gitignore b/addons/ofxLua/.gitignore index 8c4b6c8..5c8e850 100644 --- a/addons/ofxLua/.gitignore +++ b/addons/ofxLua/.gitignore @@ -45,3 +45,11 @@ luaExampleIOS/*.plist luaExampleIOS/*.pch luaExampleIOS/bin/data/Default*.png luaExampleIOS/bin/data/Icon*.png +luaTests/Makefile +luaTests/*.xcodeproj +luaTests/config.make +luaTests/*xcconfig +luaTests/*.plist +luaTests/bin/lib*.so +luaTests/bin/luaTests +luaTests/obj/* diff --git a/addons/ofxLua/gitmodules b/addons/ofxLua/.gitmodules similarity index 100% rename from addons/ofxLua/gitmodules rename to addons/ofxLua/.gitmodules diff --git a/addons/ofxLua/README.md b/addons/ofxLua/README.md index cbab87a..775d5ac 100644 --- a/addons/ofxLua/README.md +++ b/addons/ofxLua/README.md @@ -44,7 +44,7 @@ For these reasons, Lua has been used for game development for many years: * [LuaCraft](http://luacraft.com) = Minecraft + Lua * [love2d](https://love2d.org) game engine -Those coming from an embedded computing or game development background are probably familiar with Lua while those coming from a design and/or web development are used to Javascript. In many ways, both languages share a number of similarities and the rest is due to simple syntax or design differences. When it comes down to it, no one language or environment is *better* than another, they just have different focuses and design backgrounds. Do not dismiss Lua because you are unfamiliar with it as not every nail needs the same hammer. +Those coming from an embedded computing or game development background are probably familiar with Lua while those coming from design and/or web development are used to Javascript. In many ways, both languages share a number of similarities and the rest is due to simple syntax or design differences. When it comes down to it, no one language or environment is *better* than another, they just have different focuses and design backgrounds. Do not dismiss Lua because you are unfamiliar with it as not every nail needs the same hammer. Lua is not scary, trust me :) diff --git a/addons/ofxLua/luaExample/src/ofApp.cpp b/addons/ofxLua/luaExample/src/ofApp.cpp index 9299365..4d154ff 100644 --- a/addons/ofxLua/luaExample/src/ofApp.cpp +++ b/addons/ofxLua/luaExample/src/ofApp.cpp @@ -12,7 +12,6 @@ //-------------------------------------------------------------- void ofApp::setup() { - ofSetVerticalSync(true); ofSetFrameRate(30); ofSetLogLevel("ofxLua", OF_LOG_VERBOSE); @@ -22,21 +21,14 @@ void ofApp::setup() { scripts.push_back("scripts/imageLoaderExample.lua"); scripts.push_back("scripts/polygonExample.lua"); scripts.push_back("scripts/fontsExample.lua"); - scripts.push_back("scripts/boringTests.lua"); currentScript = 0; // init the lua state - lua.init(); + lua.init(true); // true because we want to stop on an error // listen to error events lua.addListener(this); - // run some read/write api tests - runTests(); - - // reinit the lua state, clears test data in state - lua.init(true); // true because we want to stop on an error - // run a script // true = change working directory to the script's parent dir // so lua will find scripts with relative paths via require @@ -118,7 +110,7 @@ void ofApp::mouseReleased(int x, int y, int button) { } //-------------------------------------------------------------- -void ofApp::errorReceived(string& msg) { +void ofApp::errorReceived(std::string& msg) { ofLogNotice() << "got a script error: " << msg; } @@ -148,271 +140,3 @@ void ofApp::prevScript() { } reloadScript(); } - -//-------------------------------------------------------------- - void ofApp::runTests() { - - // do tests - //------ - ofLog(); - ofLog() << "*** BEGIN READ TEST ***"; - - // load a script with some variables we want - lua.doScript("variableTest.lua"); - - // prints global table if no table is pushed - //lua.printTable(); - - // print the variables in the script manually - ofLog() << "variableTest variables:"; - ofLog() << " abool: " << lua.getBool("abool"); - ofLog() << " anumber: " << lua.getNumber("anumber"); - ofLog() << " astring: " << lua.getString("astring"); - - // load simple table arrays by type - stringstream line; - - vector boolTable; - lua.getBoolVector("boolTable", boolTable); - line << " boolTable: "; - for(size_t i = 0; i < boolTable.size(); ++i) { - line << boolTable[i] << " "; - } - ofLog() << line.str() << "#: " << lua.tableSize("boolTable"); - line.str(""); // clear - - vector numberTable; - lua.getNumberVector("numberTable", numberTable); - line << " numberTable: "; - for(size_t i = 0; i < numberTable.size(); ++i) { - line << numberTable[i] << " "; - } - ofLog() << line.str() << "#: " << lua.tableSize("numberTable"); - line.str(""); // clear - - vector stringTable; - lua.getStringVector("stringTable", stringTable); - line << " stringTable: "; - for(size_t i = 0; i < stringTable.size(); ++i) { - line << "\"" << stringTable[i] << "\" "; - } - ofLog() << line.str() << "#: " << lua.tableSize("stringTable"); - line.str(""); // clear - - // try to load a mixed var table, should fail and issue warnings - ofLog() << " ### should be warnings here vvv"; - vector testStringVector; - lua.getStringVector("mixedTable", testStringVector); - ofLog() << " ### should be warnings here ^^^"; - - // read manually by index, lua indices start at 1 not 0! - lua.pushTable("mixedTable"); - ofLog() << "mixedTable"; - for(size_t i = 1; i <= lua.tableSize(); ++i) { - if(lua.isBool(i)) { - ofLogNotice() << "\t" << i << " b: " << lua.getBool(i); - } - else if(lua.isNumber(i)) { - ofLogNotice() << "\t" << i << " n: " << lua.getNumber(i); - } - else if(lua.isString(i)) { - ofLogNotice() << "\t" << i << " s: " << lua.getString(i); - } - } - lua.popTable(); - - // load a table within a table by name - lua.pushTable("atable"); - lua.getStringVector("stringTable", stringTable); - line << "atable.stringTable: "; - for(size_t i = 0; i < stringTable.size(); ++i) { - line << "\"" << stringTable[i] << "\" "; - } - ofLog() << line.str() << "#: " << lua.tableSize("stringTable"); - line.str(""); // clear - lua.popTable(); - - // load a table within a table by index - lua.pushTable("atable"); - lua.pushTable("nestedTable"); - lua.getNumberVector(2, numberTable); - line << "atable.nestedTable[2]: "; - for(size_t i = 0; i < numberTable.size(); ++i) { - line << numberTable[i] << " "; - } - ofLog() << line.str() << "#: " << lua.tableSize(2); - line.str(""); // clear - lua.popAllTables(); - - // print the contents of the "atable" table - lua.pushTable("atable"); // move from the global lua namespace to the "atable" table - lua.printTable(); // print variables & tables in "atable" - lua.popTable(); // return to the global namespace - - // check if testing existence within a table works - lua.pushTable("atable"); - ofLog() << "atable.afunction a function?: " << lua.isFunction("afunction"); - lua.pushTable("nestedTable"); - lua.pushTable(1); - ofLog() << "atable.nestedTable[1][1] a number?: " << lua.isNumber(1); - lua.popAllTables(); - - ofLog() << "*** END READ TEST ***" << endl; - - //------ - - ofLog() << "*** BEGIN WRITE TEST ***"; - - // print - ofLog() << "values before:"; - ofLog() << " abool: " << lua.getBool("abool"); - ofLog() << " anumber: " << lua.getNumber("anumber"); - ofLog() << " astring: " << lua.getString("astring"); - - // this should throw a warning, it dosen't exist yet - ofLog() << "### should be a warning here vvv"; - ofLog() << " newstring: " << lua.getString("newstring"); - ofLog() << "### should be a warning here ^^^"; - - numberTable.clear(); - lua.getNumberVector("numberTable", numberTable); - line << " numberTable: "; - for(size_t i = 0; i < numberTable.size(); ++i) { - line << numberTable[i] << " "; - } - ofLog() << line.str() << "#: " << lua.tableSize("numberTable"); - line.str(""); // clear - - // set values - lua.setBool("abool", false); - lua.setNumber("anumber", 66.6); - lua.setString("astring", "kaaaaa"); - - // add new value - lua.setString("newstring", "a new string"); - - // set vector - numberTable.clear(); - for(size_t i = 0; i < 10; i+=2) { - numberTable.push_back(i); - } - lua.setNumberVector("numberTable", numberTable); - - // print again - ofLog() << "values after:"; - ofLog() << " abool: " << lua.getBool("abool"); - ofLog() << " anumber: " << lua.getNumber("anumber"); - ofLog() << " astring: " << lua.getString("astring"); - ofLog() << " newstring: " << lua.getString("newstring"); - - numberTable.clear(); - lua.getNumberVector("numberTable", numberTable); - line << " numberTable: "; - for(size_t i = 0; i < numberTable.size(); ++i) - line << numberTable[i] << " "; - ofLog() << line.str() << "#: " << lua.tableSize("numberTable"); - line.str(""); // clear - - // write manually by index, remember lua indices start at 1 not 0! - lua.pushTable("mixedTable"); - for(size_t i = 1; i <= lua.tableSize(); ++i) { - if(lua.isBool(i)) { - lua.setBool(i, true); - } - else if(lua.isNumber(i)) { - lua.setNumber(i, 9999.99); - } - else if(lua.isString(i)) { - lua.setString(i, "abcdefg"); - } - } - lua.printTable(); - lua.popTable(); - - ofLog() << "*** END WRITE TEST ***" << endl; - - //------ - - ofLog() << "*** BEGIN EXIST TEST ***"; - - // "avar" dosen't exist - ofLog() << "avar exists: " << lua.isNumber("avar") - << ", is nil: " << lua.isNil("avar"); - - // "avar" exists and is equal to 99 - lua.setNumber("avar", 99); - ofLog() << "avar exists: " << lua.isNumber("avar") - << ", is nil: " << lua.isNil("avar"); - ofLog() << " avar: " << lua.getNumber("avar"); - - // set "avar" to nil, it no longer exists - lua.setNil("avar"); - ofLog() << "avar exists: " << lua.isNumber("avar") - << ", is nil: " << lua.isNil("avar"); - - ofLog() << "*** END EXIST TEST ***" << endl; - - //------ - - ofLog() << "*** BEGIN CLEAR TEST ***"; - - lua.printTable("anotherTable"); - lua.clearTable("anotherTable"); - ofLog() << "### should only print the table name vvv"; - lua.printTable("anotherTable"); // should only print the name - - ofLog() << "*** END CLEAR TEST ***" << endl; - - //------ - - ofLog() << "*** BEGIN FILE WRITER TEST ***"; - - // write text & vars out into a text file - ofxLuaFileWriter luaWriter; - string filename = "writerTest.lua"; - luaWriter.writeComment("lua writer test"); - luaWriter.newLine(); - luaWriter.beginCommentBlock(); - luaWriter.writeLine("this is a comment block"); - luaWriter.endCommentBlock(); - luaWriter.newLine(); - luaWriter.writeBool("abool", lua.getBool("abool")); - luaWriter.writeNumber("anumber", lua.getNumber("anumber")); - luaWriter.writeString("astring", lua.getString("astring")); - luaWriter.beginTable("vectors"); - luaWriter.writeBoolVector("boolTable", boolTable); - luaWriter.writeNumberVector("numberTable", numberTable); - luaWriter.writeStringVector("stringTable", stringTable); - luaWriter.endTable(); - - // write a table's contents recursively into the file - lua.writeTable("atable", luaWriter, true); - - // save, load, and print file - if(luaWriter.saveToFile(filename)) { - - // print - ofLog() << "### Written File vvv"; - ofBuffer b = ofBufferFromFile(filename); - for(auto &line : b.getLines()) { - ofLog() << line; - } - b.clear(); - ofLog() << "### Written File ^^^"; - - // try loading into lua state - lua.doScript(filename); - - // delete when done - ofFile::removeFile(filename); - } - - ofLog() << "*** END FILE WRITER TEST ***" << endl; - - //------- - - ofLog() << "*** CHECK STACK ***"; - ofLog() << "Tests Done, stack length should be 0"; - lua.printStack(); - ofLog() << "*** TESTS DONE ***" << endl; - } diff --git a/addons/ofxLua/luaExample/src/ofApp.h b/addons/ofxLua/luaExample/src/ofApp.h index aaf6c7f..2032eda 100644 --- a/addons/ofxLua/luaExample/src/ofApp.h +++ b/addons/ofxLua/luaExample/src/ofApp.h @@ -11,7 +11,6 @@ #pragma once #include "ofMain.h" - #include "ofxLua.h" class ofApp : public ofBaseApp, ofxLuaListener { @@ -26,13 +25,13 @@ class ofApp : public ofBaseApp, ofxLuaListener { // input void keyPressed(int key); - void mouseMoved(int x, int y ); + void mouseMoved(int x, int y); void mouseDragged(int x, int y, int button); void mousePressed(int x, int y, int button); void mouseReleased(int x, int y, int button); // ofxLua error callback - void errorReceived(string& msg); + void errorReceived(std::string& msg); // a bunch of api tests void runTests(); diff --git a/addons/ofxLua/luaExampleIOS/bin/data/fonts/frabk.ttf b/addons/ofxLua/luaExampleIOS/bin/data/fonts/frabk.ttf new file mode 100644 index 0000000..21c4ecf Binary files /dev/null and b/addons/ofxLua/luaExampleIOS/bin/data/fonts/frabk.ttf differ diff --git a/addons/ofxLua/luaExampleIOS/bin/data/fonts/verdana.ttf b/addons/ofxLua/luaExampleIOS/bin/data/fonts/verdana.ttf new file mode 100644 index 0000000..8f25a64 Binary files /dev/null and b/addons/ofxLua/luaExampleIOS/bin/data/fonts/verdana.ttf differ diff --git a/addons/ofxLua/luaExampleIOS/bin/data/images/bike_icon.gif b/addons/ofxLua/luaExampleIOS/bin/data/images/bike_icon.gif new file mode 100644 index 0000000..836155e Binary files /dev/null and b/addons/ofxLua/luaExampleIOS/bin/data/images/bike_icon.gif differ diff --git a/addons/ofxLua/luaExampleIOS/bin/data/images/bike_icon.png b/addons/ofxLua/luaExampleIOS/bin/data/images/bike_icon.png new file mode 100644 index 0000000..761c465 Binary files /dev/null and b/addons/ofxLua/luaExampleIOS/bin/data/images/bike_icon.png differ diff --git a/addons/ofxLua/luaExampleIOS/bin/data/images/bikers.jpg b/addons/ofxLua/luaExampleIOS/bin/data/images/bikers.jpg new file mode 100644 index 0000000..eafbb44 Binary files /dev/null and b/addons/ofxLua/luaExampleIOS/bin/data/images/bikers.jpg differ diff --git a/addons/ofxLua/luaExampleIOS/bin/data/images/gears.gif b/addons/ofxLua/luaExampleIOS/bin/data/images/gears.gif new file mode 100644 index 0000000..31e0f17 Binary files /dev/null and b/addons/ofxLua/luaExampleIOS/bin/data/images/gears.gif differ diff --git a/addons/ofxLua/luaExampleIOS/bin/data/images/tdf_1972_poster.jpg b/addons/ofxLua/luaExampleIOS/bin/data/images/tdf_1972_poster.jpg new file mode 100644 index 0000000..2ce770e Binary files /dev/null and b/addons/ofxLua/luaExampleIOS/bin/data/images/tdf_1972_poster.jpg differ diff --git a/addons/ofxLua/luaExampleIOS/bin/data/images/transparency.png b/addons/ofxLua/luaExampleIOS/bin/data/images/transparency.png new file mode 100644 index 0000000..8e5e146 Binary files /dev/null and b/addons/ofxLua/luaExampleIOS/bin/data/images/transparency.png differ diff --git a/addons/ofxLua/luaExampleIOS/bin/data/scripts/fontsExample.lua b/addons/ofxLua/luaExampleIOS/bin/data/scripts/fontsExample.lua new file mode 100644 index 0000000..91a047e --- /dev/null +++ b/addons/ofxLua/luaExampleIOS/bin/data/scripts/fontsExample.lua @@ -0,0 +1,85 @@ +franklinBook = of.TrueTypeFont() +verdana = of.TrueTypeFont() +franklinBookLarge = of.TrueTypeFont() + +counter = 0 + +---------------------------------------------------- +function setup() + of.setWindowTitle("fonts example") + + -- this load font loads the non-full character set + -- (ie ASCII 33-128), at size "32" + franklinBook:load("fonts/frabk.ttf", 32) + + -- now load another font, but with extended parameters: + -- font name, size, anti-aliased, full character set + verdana:load("fonts/verdana.ttf", 8, false, true) + verdana:setLineHeight(20) +end + +---------------------------------------------------- +function update() + of.background(255, 255, 255) + counter = counter + 1 +end + +---------------------------------------------------- +function draw() + + of.setHexColor(0x00FF00) + franklinBook:drawString("hello, this is franklin book calling\nanyone home?", 100, 100) + + of.setHexColor(0x000000) + verdana:drawString("hello, I am aliased verdana -- full character set, see: � ! ", 100, 210) + + of.setHexColor(0x00FF00) + franklinBook:drawString("I can't make an (�) like you", 100, 310) + + of.setHexColor(0x000000) + verdana:drawString("yeah, but I'm not exactly pretty\nthe problem is with freeType library...\napple has a patent on TTF font hints\nso our aliased type via freeType isn't super looking", 100, 380) + + of.setHexColor(0x00FF00) + franklinBook:drawString("you look ok ! don't worry", 100, 520) + + --------------------- bounding rectangle : + tempString = tostring(counter) + -- ok first job to rotate around the center, is to get the bounding box: + rect = franklinBook:getStringBoundingBox(tempString, 0, 0); + -- this is the actual midpt (x + w/2, y + h/2); + local centerx = rect.x + rect.width / 2 + local centery = rect.y + rect.height / 2 + + of.pushMatrix() + of.translate(100, 650, 0) + of.rotate(counter, 0, 0, 1) + -- draw type & rect centered around 0,0 (subtract midpt from both): + of.setHexColor(0xcccccc) + of.drawRectangle(rect.x - centerx, rect.y - centery, rect.width, rect.height) + of.setHexColor(0xff3399) + franklinBook:drawString(tempString, -centerx,-centery); + of.popMatrix() + + --------------------------------------- + + of.pushMatrix() + of.translate(225, 675, 0) + of.scale(5, 5, 1) + of.setHexColor(0x333333) + verdana:drawString("scale 5x!", 0, 0) + of.popMatrix() + + local size = 2 + 2*math.sin(counter/300) + of.pushMatrix() + of.translate(520, 675, 0) + of.scale(size, size, 1) + of.setHexColor(0x00FF00) + franklinBook:drawString("$k@!%", 0, 0); + of.popMatrix() +end + +---------------------------------------------------- +function exit() + print("script finished") +end + diff --git a/addons/ofxLua/luaExampleIOS/bin/data/scripts/graphicsExample.lua b/addons/ofxLua/luaExampleIOS/bin/data/scripts/graphicsExample.lua new file mode 100644 index 0000000..1777f12 --- /dev/null +++ b/addons/ofxLua/luaExampleIOS/bin/data/scripts/graphicsExample.lua @@ -0,0 +1,104 @@ +print("Hello World!") + +counter = 0 +bSmooth = false + +---------------------------------------------------- +function setup() + of.setWindowTitle("graphics example") + print("script setup") + + of.setCircleResolution(50) + of.background(255, 255, 255, 255) + of.setWindowTitle("graphics example") + + of.setFrameRate(60) -- if vertical sync is off, we can go a bit fast... this caps the framerate at 60fps + of.disableSmoothing() +end + +---------------------------------------------------- +function update() + counter = counter + 0.033 +end + +---------------------------------------------------- +function draw() + + -- CIRCLES + -- let's draw a circle + of.setColor(255, 130, 0) + local radius = 50 + 10 * math.sin(counter) + of.fill() + of.drawCircle(100, 400, radius) + + -- now just an outline + of.noFill() + of.setHexColor(0xCCCCCC) + of.drawCircle(100, 400, 80) + + -- label + of.setHexColor(0x000000) + of.drawBitmapString("circle", 75, 500) + + -- RECTANGLES + of.fill() + for i=0,200 do + of.setColor(of.random(0, 255), of.random(0, 255), of.random(0, 255)) + of.drawRectangle(of.random(250, 350), of.random(350, 450), + of.random(10, 20), of.random(10, 20)) + end + of.setHexColor(0x000000) + of.drawBitmapString("rectangles", 275, 500) + + -- TRANSPARENCY + of.setHexColor(0x00FF33) + of.drawRectangle(400, 350, 100, 100) + -- alpha is usually turned off - for speed puposes. let's turn it on! + of.enableAlphaBlending() + of.setColor(255, 0, 0, 127) -- red, 50% transparent + of.drawRectangle(450, 430, 100, 33) + of.setColor(255, 0, 0, math.fmod(counter*10, 255)) -- red, variable transparent + of.drawRectangle(450, 370, 100, 33) + of.disableAlphaBlending() + + of.setHexColor(0x000000) + of.drawBitmapString("transparency", 410, 500) + + -- LINES + -- a bunch of red lines, make them smooth if the flag is set + + if bSmooth then + of.enableSmoothing() + end + + of.setHexColor(0xFF0000) + for i=0,20 do + of.drawLine(600, 300 + (i*5), 800, 250 + (i*10)) + end + + if bSmooth then + of.disableSmoothing() + end + + of.setHexColor(0x000000) + of.drawBitmapString("lines\npress 's' to toggle smoothness", 600, 500) + +end + +---------------------------------------------------- +function exit() + print("script finished") +end + +-- input callbacks + +---------------------------------------------------- +function keyPressed(key) + -- print out key as ascii val & char (keep within ascii 0-127 range) + print("script keyPressed: "..tostring(key) + .." \'"..string.char(math.max(math.min(key, 127), 0)).."\'") + if key == string.byte("s") then + bSmooth = not bSmooth + end +end + diff --git a/addons/ofxLua/luaExampleIOS/bin/data/scripts/imageLoaderExample.lua b/addons/ofxLua/luaExampleIOS/bin/data/scripts/imageLoaderExample.lua new file mode 100644 index 0000000..d954759 --- /dev/null +++ b/addons/ofxLua/luaExampleIOS/bin/data/scripts/imageLoaderExample.lua @@ -0,0 +1,87 @@ + +-- create new images +bikers = of.Image() +gears = of.Image() +tdf = of.Image() +tdfSmall = of.Image() +transparency = of.Image() +bikeIcon = of.Image() + +---------------------------------------------------- +function setup() + + of.setWindowTitle("image loader example") + of.setFrameRate(30) + + bikers:load("images/bikers.jpg") + gears:load("images/gears.gif") + tdf:load("images/tdf_1972_poster.jpg") + + tdfSmall:load("images/tdf_1972_poster.jpg") + tdfSmall:resize(tdfSmall:getWidth() / 4, tdfSmall:getHeight() / 4) + tdfSmall:setImageType(of.IMAGE_GRAYSCALE) + + transparency:load("images/transparency.png") + bikeIcon:load("images/bike_icon.png") + bikeIcon:setImageType(of.IMAGE_GRAYSCALE) +end + +---------------------------------------------------- +function update() + of.background(255) +end + +---------------------------------------------------- +function draw() + of.setColor(255) + + bikers:draw(0, 0) + gears:draw(600, 0) + tdf:draw(600, 300) + + of.setColor(220, 50, 50) + tdfSmall:draw(200, 300) + + of.setColor(255) + of.enableAlphaBlending() + local wave = math.sin(of.getElapsedTimef()) + transparency:draw(500 + (wave * 100), 20) + of.disableAlphaBlending() + + -- getting the ofColors from an image, + -- using the brightness to draw circles + local w = bikeIcon:getWidth() + local h = bikeIcon:getHeight() + local diameter = 10 + of.setColor(255, 0, 0) + for y=1,h-1 do + for x=1,w-1 do + local cur = bikeIcon:getColor(x, y) + local size = 1 - (cur:getBrightness() / 255) + of.drawCircle(x * diameter, 500 + y * diameter, + 1 + size * diameter / 2) + end + end +--[[ + -- same as above, but this time + -- use the raw data directly with getPixels() + local pixels = bikeIcon:getPixelsRef() + of.setColor(0, 0, 255) + for y=1,h-1 do + for x=1,w-1 do + local index = y * w + x + cur = pixels:getPixelsRef(index) + size = 1 - (cur / 255) + of.circle(200 + x * diameter, 500 + y * diameter, + 1 + size * diameter / 2) + end + end +]]-- + of.setColor(255) + bikeIcon:draw(190, 490, 20, 20) +end + +---------------------------------------------------- +function exit() + print("script finished") +end diff --git a/addons/ofxLua/luaExampleIOS/bin/data/scripts/polygonExample.lua b/addons/ofxLua/luaExampleIOS/bin/data/scripts/polygonExample.lua new file mode 100644 index 0000000..4f313c7 --- /dev/null +++ b/addons/ofxLua/luaExampleIOS/bin/data/scripts/polygonExample.lua @@ -0,0 +1,445 @@ + +-- simple class, like a C struct + +DraggableVertex = class() + +function DraggableVertex:__init(x, y) + self.x = x + self.y = y + self.bBeingDragged = false + self.bOver = false + self.radius = 4 +end + +-- array of DraggableVertex objects using a lua table +curveVertices = { + DraggableVertex(326, 209), + DraggableVertex(306, 279), + DraggableVertex(265, 331), + DraggableVertex(304, 383), + DraggableVertex(374, 383), + DraggableVertex(418, 209), + DraggableVertex(345, 279) +} + +-- number of vertexes in the array +nCurveVertexes = 7 + +---------------------------------------------------- +function setup() + of.setWindowTitle("polygon example") +end + +---------------------------------------------------- +function update() + of.background(255, 255, 255) + of.setFrameRate(60) +end + +---------------------------------------------------- +function draw() + of.fill() + of.setHexColor(0xe0be21) + + --------(a)-------------------------------------- + -- + -- draw a star + -- + -- use poly winding odd, the default rule + -- + -- info about the winding rules is here: + -- http:--glprogramming.com/red/images/Image128.gif + -- + of.setPolyMode(of.POLY_WINDING_ODD) -- this is the normal mode + of.beginShape() + of.vertex(200, 135) + of.vertex(15, 135) + of.vertex(165, 25) + of.vertex(105, 200) + of.vertex(50, 25) + of.endShape(false) + + --------(b)-------------------------------------- + -- + -- draw a star + -- + -- use poly winding nonzero + -- + -- info about the winding rules is here: + -- http:--glprogramming.com/red/images/Image128.gif + -- + of.setHexColor(0xb5de10) + of.setPolyMode(of.POLY_WINDING_NONZERO) + of.beginShape() + of.vertex(400, 135) + of.vertex(215, 135) + of.vertex(365, 25) + of.vertex(305, 200) + of.vertex(250, 25) + of.endShape(false) + --------------------------------------- + + --------(c)-------------------------------------- + -- + -- draw a star dynamically + -- + -- use the mouse position as a pct + -- to calc nPoints and internal point radius + -- + local xPct = of.getMouseX() / of.getWidth() + local yPct = of.getMouseY() / of.getHeight() + local nTips = 5 + xPct * 60 + local nStarPts = nTips * 2 + local angleChangePerPt = of.TWO_PI / nStarPts + local innerRadius = 0 + yPct*80 + local outerRadius = 80 + local origx = 525 + local origy = 100 + local angle = 0 + + of.setHexColor(0xa16bca) + of.beginShape() + for i=0,nStarPts do + if i % 2 == 0 then + -- inside point: + local x = origx + innerRadius * math.cos(angle) + local y = origy + innerRadius * math.sin(angle) + of.vertex(x, y) + else + -- outside point + local x = origx + outerRadius * math.cos(angle) + local y = origy + outerRadius * math.sin(angle) + of.vertex(x, y) + end + angle = angle + angleChangePerPt + end + of.endShape(false) + --------------------------------------- + + --------(d)-------------------------------------- + -- + -- poylgon of random points + -- + -- lots of self intersection, 500 pts is a good stress test + -- + -- + of.setHexColor(0x0cb0b6) + of.setPolyMode(of.POLY_WINDING_ODD) + of.beginShape() + for i=1,10 do + of.vertex(of.random(650, 850), of.random(20, 200)) + end + of.endShape(false) + --------------------------------------- + + --------(e)-------------------------------------- + -- + -- use sin cos and time to make some spirally shape + -- + of.pushMatrix() + of.translate(100, 300, 0) + of.setHexColor(0xff2220) + of.fill() + of.setPolyMode(of.POLY_WINDING_ODD) + of.beginShape() + local angleStep = of.TWO_PI/(100 + math.sin(of.getElapsedTimef()/5) * 60) + local radiusAdder = 0.5 + local radius = 0 + for i=1,200 do + local anglef = (i) * angleStep + local x = radius * math.cos(anglef) + local y = radius * math.sin(anglef) + of.vertex(x, y) + radius = radius + radiusAdder + end + of.endShape(of.CLOSE) + of.popMatrix() + --------------------------------------- + + --------(f)-------------------------------------- + -- + -- ofCurveVertex + -- + -- because it uses catmul rom splines, we need to repeat the first and last + -- items so the curve actually goes through those points + -- + + of.setHexColor(0x2bdbe6) + of.beginShape() + + for i=1,nCurveVertexes do + + -- sorry about all the if/states here, but to do catmull rom curves + -- we need to duplicate the start and end points so the curve acutally + -- goes through them. + + -- for i == 0, we just call the vertex twice + -- for i == nCurveVertexes-1 (last point) we call vertex 0 twice + -- otherwise just normal ofCurveVertex call + + if i == 1 then + -- we need to duplicate 0 for the curve to start at point 0 + of.curveVertex(curveVertices[1].x, curveVertices[1].y) + -- we need to duplicate 0 for the curve to start at point 0 + of.curveVertex(curveVertices[1].x, curveVertices[1].y) + elseif i == nCurveVertexes then + of.curveVertex(curveVertices[i].x, curveVertices[i].y) + -- to draw a curve from pt 6 to pt 0 + of.curveVertex(curveVertices[1].x, curveVertices[1].y) + -- we duplicate the first point twice + of.curveVertex(curveVertices[1].x, curveVertices[1].y) + else + of.curveVertex(curveVertices[i].x, curveVertices[i].y) + end + end + + of.endShape(false) + + + -- show a faint the non-curve version of the same polygon: + of.enableAlphaBlending() + of.noFill() + of.setColor(0, 0, 0, 40) + of.beginShape() + for i=1,nCurveVertexes do + of.vertex(curveVertices[i].x, curveVertices[i].y) + end + of.endShape(true) + + + of.setColor(0, 0, 0, 80) + for i=1,nCurveVertexes do + if curveVertices[i].bOver == true then + of.fill() + else + of.noFill() + end + of.drawCircle(curveVertices[i].x, curveVertices[i].y, 4) + end + of.disableAlphaBlending() + --------------------------------------- + + --------(g)-------------------------------------- + -- + -- ofBezierVertex + -- + -- with ofBezierVertex we can draw a curve from the current vertex + -- through the the next three vertexes we pass in. + -- (two control points and the final bezier point) + -- + + local x0 = 500 + local y0 = 300 + local x1 = 550+50*math.cos(of.getElapsedTimef()*1.0) + local y1 = 300+100*math.sin(of.getElapsedTimef()/3.5) + local x2 = 600+30*math.cos(of.getElapsedTimef()*2.0) + local y2 = 300+100*math.sin(of.getElapsedTimef()) + local x3 = 650 + local y3 = 300 + + of.fill() + of.setHexColor(0xFF9933) + of.beginShape() + of.vertex(x0, y0) + of.bezierVertex(x1, y1, x2, y2, x3, y3) + of.endShape(false) + + of.enableAlphaBlending() + of.fill() + of.setColor(0, 0 ,0, 40) + of.drawCircle(x0, y0, 4) + of.drawCircle(x1, y1, 4) + of.drawCircle(x2, y2, 4) + of.drawCircle(x3, y3, 4) + of.disableAlphaBlending() + --------------------------------------- + + --------(h)-------------------------------------- + -- + -- holes / ofNextContour + -- + -- with ofNextContour we can create multi-contour shapes + -- this allows us to draw holes, for example... + -- + of.fill() + of.setHexColor(0xd3ffd3) + of.drawRectangle(80,480, 140, 70) + of.setHexColor(0xff00ff) + + of.beginShape() + + of.vertex(100, 500) + of.vertex(180, 550) + of.vertex(100, 600) + + of.nextContour(true) + + of.vertex(120, 520) + of.vertex(160, 550) + of.vertex(120, 580) + + of.endShape(true) + --------------------------------------- + + --------(i)-------------------------------------- + -- + -- CSG / ofNextContour + -- + -- with different winding rules, you can even use ofNextContour to + -- perform constructive solid geometry + -- + -- be careful, the clockwiseness or counter clockwisenss of your multiple + -- contours matters with these winding rules. + -- + -- for csg ideas, see : http:--glprogramming.com/red/chapter11.html + -- + -- info about the winding rules is here: + -- http:--glprogramming.com/red/images/Image128.gif + -- + of.noFill() + + of.pushMatrix() + + of.setPolyMode(of.POLY_WINDING_ODD) + + of.beginShape() + + of.vertex(300, 500) + of.vertex(380, 550) + of.vertex(300, 600) + + of.nextContour(true) + + for i=1,20 do + local anglef = (i / 19.0) * of.TWO_PI + local x = 340 + 30 * math.cos(anglef) + local y = 550 + 30 * math.sin(anglef) + of.vertex(x,y) + radius = radius + radiusAdder + end + + of.endShape(true) + + of.translate(100, 0, 0) + + of.setPolyMode(of.POLY_WINDING_NONZERO) + of.beginShape() + + of.vertex(300, 500) + of.vertex(380, 550) + of.vertex(300, 600) + + of.nextContour(true) + + for i=1,20 do + local anglef = (i / 19.0) * of.TWO_PI + local x = 340 + 30 * math.cos(anglef) + local y = 550 + 30 * math.sin(anglef) + of.vertex(x,y) + radius = radius + radiusAdder + end + + of.endShape(true) + + of.translate(100, 0, 0) + of.setPolyMode(of.POLY_WINDING_ABS_GEQ_TWO) + of.beginShape() + of.vertex(300, 500) + of.vertex(380, 550) + of.vertex(300, 600) + of.nextContour(true) + + for i=1,20 do + local anglef = (i / 19.0) * of.TWO_PI + local x = 340 + 30 * math.cos(anglef) + local y = 550 + 30 * math.sin(anglef) + of.vertex(x,y) + radius = radius + radiusAdder + end + + of.endShape(true) + + of.popMatrix() + --------------------------------------- + + of.setHexColor(0x000000) + of.drawBitmapString("(a) star\nwinding rule odd", 20, 210) + + of.setHexColor(0x000000) + of.drawBitmapString("(b) star\nwinding rule nonzero", 220, 210) + + of.setHexColor(0x000000) + of.drawBitmapString("(c) dynamically\ncreated shape", 420, 210) + + of.setHexColor(0x000000) + of.drawBitmapString("(d) random points\npoly", 670, 210) + + of.setHexColor(0x000000) + of.drawBitmapString("(e) fun with sin/cos", 20, 410) + + of.setHexColor(0x000000) + of.drawBitmapString("(f) ofCurveVertex\nuses catmull rom\nto make curved shapes", 220, 410) + + of.setHexColor(0x000000) + of.drawBitmapString("(g) ofBezierVertex\nuses bezier to draw curves", 460, 410) + + + of.setHexColor(0x000000) + of.drawBitmapString("(h) ofNextContour\nallows for holes", 20, 610) + + of.setHexColor(0x000000) + of.drawBitmapString("(i) ofNextContour\ncan even be used for CSG operations\nsuch as union and intersection", 260, 620) +end + +function exit() + print("script finished") +end + +-- input callbacks + +---------------------------------------------------- +function mouseMoved(x, y) + for i=1,nCurveVertexes do + local diffx = x - curveVertices[i].x + local diffy = y - curveVertices[i].y + local dist = math.sqrt(diffx*diffx + diffy*diffy) + if dist < curveVertices[i].radius then + curveVertices[i].bOver = true + else + curveVertices[i].bOver = false + end + end +end + +---------------------------------------------------- +function mouseDragged(x, y, button) + for i=1,nCurveVertexes do + if curveVertices[i].bBeingDragged == true then + curveVertices[i].x = x + curveVertices[i].y = y + end + end +end + +---------------------------------------------------- +function mousePressed(x, y, button) + for i=1,nCurveVertexes do + local diffx = x - curveVertices[i].x + local diffy = y - curveVertices[i].y + local dist = math.sqrt(diffx*diffx + diffy*diffy) + if dist < curveVertices[i].radius then + curveVertices[i].bBeingDragged = true + else + curveVertices[i].bBeingDragged = false + end + end +end + +---------------------------------------------------- +function mouseReleased(x, y, button) + for i=1,nCurveVertexes do + curveVertices[i].bBeingDragged = false + end +end + + diff --git a/addons/ofxLua/luaExampleIOS/bin/data/scripts/touchExample.lua b/addons/ofxLua/luaExampleIOS/bin/data/scripts/touchExample.lua new file mode 100644 index 0000000..23f54e9 --- /dev/null +++ b/addons/ofxLua/luaExampleIOS/bin/data/scripts/touchExample.lua @@ -0,0 +1,69 @@ + +touches = {} -- table as array +for i=1,10 do -- populate table, 10 should be enough ... + touches[i] = nil +end + +---------------------------------------------------- +function setup() + of.background(255) + of.enableSmoothing() + of.enableAlphaBlending() +end + +---------------------------------------------------- +function update() +end + +---------------------------------------------------- +function draw() + -- draw all the current touch events + for i,touch in ipairs(touches) do + if touch ~= nil then + of.pushMatrix() + of.translate(touch.x, touch.y, 0) + + -- circle + of.setColor( + of.map(touch.x, 0, of.getWidth(), 50, 255), + of.map(touch.id, 0, 10, 127, 255), + of.map(touch.y, 0, of.getHeight(), 50, 255), + 200) + of.fill() + of.drawCircle(0, 0, 100) + + -- id text + of.setColor(100) + of.drawBitmapString(tostring(touch.id), 0, -80) + + of.popMatrix() + end + end +end + +---------------------------------------------------- +function touchDown(touch) + -- the = operator only sets table/object pointers in lua, it does not copy + touches[touch.id+1] = touch--of.TouchEventArgs(touch) -- create new Touch & copy data +end + +---------------------------------------------------- +function touchMoved(touch) + touches[touch.id+1] = touch--of.TouchEventArgs(touch) +end + +---------------------------------------------------- +function touchUp(touch) + touches[touch.id+1] = nil -- setting to nil deallocates +end + +---------------------------------------------------- +function touchDoubleTap(touch) + print("touchDoubleTap") +end + +---------------------------------------------------- +function touchCancelled(touch) + touches[touch.id+1] = nil +end + diff --git a/addons/ofxLua/luaTests/addons.make b/addons/ofxLua/luaTests/addons.make new file mode 100644 index 0000000..d7d1cf2 --- /dev/null +++ b/addons/ofxLua/luaTests/addons.make @@ -0,0 +1 @@ +ofxLua diff --git a/addons/ofxLua/luaTests/bin/data/fonts/verdana.ttf b/addons/ofxLua/luaTests/bin/data/fonts/verdana.ttf new file mode 100644 index 0000000..8f25a64 Binary files /dev/null and b/addons/ofxLua/luaTests/bin/data/fonts/verdana.ttf differ diff --git a/addons/ofxLua/luaTests/bin/data/lib/test.lua b/addons/ofxLua/luaTests/bin/data/lib/test.lua new file mode 100644 index 0000000..78717ab --- /dev/null +++ b/addons/ofxLua/luaTests/bin/data/lib/test.lua @@ -0,0 +1,7 @@ +-- +-- a test file to check that require works +-- + +function requireTest() + print("hello world, require must be working") +end diff --git a/addons/ofxLua/luaTests/bin/data/tests.lua b/addons/ofxLua/luaTests/bin/data/tests.lua new file mode 100644 index 0000000..cecedc2 --- /dev/null +++ b/addons/ofxLua/luaTests/bin/data/tests.lua @@ -0,0 +1,170 @@ +--[[ + nothing exciting here, just a bunch of stuff to see if the interpreter chokes + on any of the following lines (aka something isn't wrapped correctly, etc) +]] + +-- test that require is working +require "lib/test" + +---------------------------------------------------- +function setup() + print("script setup") + + of.setLogLevel(of.LOG_VERBOSE); + of.log(of.LOG_VERBOSE, "blah blah blah "..tostring(123.4)) + + of.setWindowTitle("function test") + + local testString = "/hello/this/is/a/fake/path" + print("test: "..testString) + + -- splitString returns a wrapped C++ std::vector + local testSplitStrings = of.splitString(testString, "/") + print("test split: "..tostring(testSplitStrings:size())) + for i = 0, testSplitStrings:size()-1 do + print("\t"..testSplitStrings[i]) + end + + local testJoinStrings = of.joinString(testSplitStrings, "/") + print("test join: "..testJoinStrings) + + --mutex = of.Mutex() + --lock = of.ScopedLock() + style = of.Style() + + rect = of.Rectangle() + m3x3 = of.Matrix3x3() + m4x4 = of.Matrix4x4() + quat = of.Quaternion() + + v2f = of.Vec2f() + v3f = of.Vec3f() + v4f = of.Vec4f() + + c = of.Color() + c:set(127.0, 127.0, 255.0) + print("c: "..c:getR().." "..tostring(c.g).." " ..tostring(c.b).." "..tostring(c.a)) + print(tostring(c)) + + pixels = of.Pixels() + pixels:clear() + + path = of.Path() + path:clear() + + polyline = of.Polyline() + polyline:clear() + + of.TrueTypeFont.setGlobalDpi(96) + font = of.TrueTypeFont() + font:load("fonts/verdana.ttf", 16) + print("font isLoaded: "..tostring(font:isLoaded())) + print("font lineHeight: "..font:getLineHeight()) + + player = of.SoundPlayer() + stream = of.SoundStream() + + node = of.Node() + mesh = of.Mesh() + + light = of.Light() + material = of.Material() + fbo = of.Fbo() + print("fbo allocated: "..tostring(fbo:isAllocated())) + vbo = of.Vbo() + vboMesh = of.VboMesh() + shader = of.Shader() + + txtData = of.TextureData() + txt = of.Texture() + txt:clear() + print("texture allocated: "..tostring(txt:isAllocated())) + + if not of.Image then + print "of.Image function doesn't exist" + end + img = of.Image() + + -- GL type defines added by the swig interface (don't exist in OF) + print("of.CLAMP_TO_EDGE: "..string.format("0x%X", of.CLAMP_TO_EDGE)) + print("of.CLAMP_TO_BORDER: "..string.format("0x%X", of.CLAMP_TO_BORDER)) + print("of.REPEAT: "..string.format("0x%X", of.REPEAT)) + print("of.MIRRORED_REPEAT: "..string.format("0x%X", of.MIRRORED_REPEAT)) + print("of.TEXTURE_LUMINANCE: "..string.format("0x%X", of.TEXTURE_LUMINANCE)) + print("of.TEXTURE_RGB: "..string.format("0x%X", of.TEXTURE_RGB)) + print("of.TEXTURE_RGBA: "..string.format("0x%X", of.TEXTURE_RGBA)) + print("of.NEAREST: "..string.format("0x%X", of.NEAREST)) + print("of.LINEAR: "..string.format("0x%X", of.LINEAR)) + + -- function loaded from separate script via require + requireTest() + + -- size_t + local haystack = "ka12ka34ka56ka" + print("'ka' is found "..of.stringTimesInString(haystack, "ka").." times in '"..haystack.."'") + + -- uint_64t + print("elapsed millis: "..of.getElapsedTimeMillis()) + + -- util stuff + of.restoreWorkingDirectoryToDefault() + + -- of.Buffer, test binary data in strings + buffer = of.Buffer("hello\0world") + print("buffer size (11): "..buffer:size()) + buffer:clear() + print("buffer size (0): "..buffer:size()) + buffer:set("abc\0de") + print("buffer size (6): "..buffer:size()) + buffer:append("fg\0hij") + print("buffer size (12): "..buffer:size()) + local data = buffer:getData() + if data then + io.write("buffer data (hex): ") + for i = 1,#data do + io.write(string.format("%.2X ", string.byte(data:sub(i,i)))) + end + io.write("\n") + end + buffer:set("foo bar") + print("buffer size (7): "..buffer:size()) + print("buffer text: "..buffer:getText()) + + -- of.FilePath + print("filepath current dir: "..of.FilePath.getCurrentWorkingDirectory()) + print("filepath joining /Users/foo with bar.txt: "..of.FilePath.join("/Users/foo", "bar.txt")) + + -- of.File + file = of.File("tests.lua") + + print("file path: "..file:path()) + print("file extension: "..file:getExtension()) + print("file name: "..file:getFileName()) + print("file basename: "..file:getBaseName()) + print("file enclosing directory: "..file:getEnclosingDirectory()) + print("file absolute path: "..file:getAbsolutePath()) + + print("file can read?: "..tostring(file:canRead())) + print("file can write?: "..tostring(file:canWrite())) + print("file can execute?: "..tostring(file:canExecute())) + + print("file is file?: "..tostring(file:isFile())) + print("file is link?: "..tostring(file:isLink())) + print("file is directory?: "..tostring(file:isDirectory())) + print("file is device?: "..tostring(file:isDevice())) + print("file is hidden?: "..tostring(file:isHidden())) + + print("file size: "..file:getSize()) + + -- of.Directory + dir = of.Directory("./") + print("dir absolute path: "..dir:getAbsolutePath()) + +end + +function update() +end + +function draw() + of.drawBitmapString("tests", 20, 20) +end diff --git a/addons/ofxLua/luaTests/bin/data/variableTest.lua b/addons/ofxLua/luaTests/bin/data/variableTest.lua new file mode 100644 index 0000000..3ba808f --- /dev/null +++ b/addons/ofxLua/luaTests/bin/data/variableTest.lua @@ -0,0 +1,38 @@ +-- some variables in a lua script + +-- variables +abool = true +anumber = 123.45 -- lua numbers are floating point +astring = "hello world" + +-- an array of simple variables using tables +boolTable = { true, true, false } +numberTable = { 1.23, 2.34, 4.56 } +stringTable = { "hello", "some text", "cha cha" } + +-- an array of mixed variable types +mixedTable = { true, 1, 2.34, "kaa" } + +-- variables within a table +atable = {} -- create an empty table + +atable.abool = true +atable.anumber = 1.234 +atable.astring = "hello again" + +atable.boolTable = { true, true, false } +atable.numberTable = { 1.23, 2.34, 4.56 } +atable.stringTable = { "hello", "some text", "cha cha" } +atable.mixedTable = { true, 1, 2.34, "kaa" } +atable.hashTable = { ["one"] = "foo", ["two"] = "bar" } +atable.nestedTable = { { 1, 2, 3}, { 4, 5, 6 } } + +atable.afunction = function() print("hey") end + +-- another table for clearing +anotherTable = {} + +anotherTable.b = false +anotherTable.n = 44.4 +anotherTable.s = "howdy ho" +anotherTable.t = { 1, 2, 3, 4, 5 } diff --git a/addons/ofxLua/luaTests/src/main.cpp b/addons/ofxLua/luaTests/src/main.cpp new file mode 100644 index 0000000..1a54367 --- /dev/null +++ b/addons/ofxLua/luaTests/src/main.cpp @@ -0,0 +1,17 @@ +/* + * Copyright (c) 2011 Dan Wilcox + * + * BSD Simplified License. + * For information on usage and redistribution, and for a DISCLAIMER OF ALL + * WARRANTIES, see the file, "LICENSE.txt," in this distribution. + * + * See https://github.com/danomatika/ofxLua for documentation + * + */ +#include "ofMain.h" +#include "ofApp.h" + +int main() { + ofSetupOpenGL(1024, 768, OF_WINDOW); + ofRunApp(new ofApp()); +} diff --git a/addons/ofxLua/luaTests/src/ofApp.cpp b/addons/ofxLua/luaTests/src/ofApp.cpp new file mode 100644 index 0000000..fa666c6 --- /dev/null +++ b/addons/ofxLua/luaTests/src/ofApp.cpp @@ -0,0 +1,340 @@ +/* + * Copyright (c) 2018 Dan Wilcox + * + * BSD Simplified License. + * For information on usage and redistribution, and for a DISCLAIMER OF ALL + * WARRANTIES, see the file, "LICENSE.txt," in this distribution. + * + * See https://github.com/danomatika/ofxLua for documentation + * + */ +#include "ofApp.h" + +//-------------------------------------------------------------- +void ofApp::setup() { + + ofSetVerticalSync(true); + ofSetFrameRate(30); + ofSetLogLevel("ofxLua", OF_LOG_VERBOSE); + + lua.init(); + lua.addListener(this); + runTests(); + lua.init(true); // stop on error + lua.doScript("tests.lua", true); + lua.scriptSetup(); +} + +//-------------------------------------------------------------- +void ofApp::update() { + lua.scriptUpdate(); +} + +//-------------------------------------------------------------- +void ofApp::draw() { + lua.scriptDraw(); +} + +//-------------------------------------------------------------- +void ofApp::exit() { + lua.scriptExit(); + lua.clear(); +} + +//-------------------------------------------------------------- +void ofApp::keyPressed(int key) { + lua.scriptKeyPressed(key); +} + +//-------------------------------------------------------------- +void ofApp::mouseMoved(int x, int y) { + lua.scriptMouseMoved(x, y); +} + +//-------------------------------------------------------------- +void ofApp::mouseDragged(int x, int y, int button) { + lua.scriptMouseDragged(x, y, button); +} + +//-------------------------------------------------------------- +void ofApp::mousePressed(int x, int y, int button) { + lua.scriptMousePressed(x, y, button); +} + +//-------------------------------------------------------------- +void ofApp::mouseReleased(int x, int y, int button) { + lua.scriptMouseReleased(x, y, button); +} + +//-------------------------------------------------------------- +void ofApp::errorReceived(std::string& msg) { + ofLogNotice() << "got a script error: " << msg; +} + +//-------------------------------------------------------------- + void ofApp::runTests() { + + // do tests + //------ + ofLog(); + ofLog() << "*** BEGIN READ TEST ***"; + + // load a script with some variables we want + lua.doScript("variableTest.lua"); + + // prints global table if no table is pushed + //lua.printTable(); + + // print the variables in the script manually + ofLog() << "variableTest variables:"; + ofLog() << " abool: " << lua.getBool("abool"); + ofLog() << " anumber: " << lua.getNumber("anumber"); + ofLog() << " astring: " << lua.getString("astring"); + + // load simple table arrays by type + stringstream line; + + vector boolTable; + lua.getBoolVector("boolTable", boolTable); + line << " boolTable: "; + for(size_t i = 0; i < boolTable.size(); ++i) { + line << boolTable[i] << " "; + } + ofLog() << line.str() << "#: " << lua.tableSize("boolTable"); + line.str(""); // clear + + vector numberTable; + lua.getNumberVector("numberTable", numberTable); + line << " numberTable: "; + for(size_t i = 0; i < numberTable.size(); ++i) { + line << numberTable[i] << " "; + } + ofLog() << line.str() << "#: " << lua.tableSize("numberTable"); + line.str(""); // clear + + vector stringTable; + lua.getStringVector("stringTable", stringTable); + line << " stringTable: "; + for(size_t i = 0; i < stringTable.size(); ++i) { + line << "\"" << stringTable[i] << "\" "; + } + ofLog() << line.str() << "#: " << lua.tableSize("stringTable"); + line.str(""); // clear + + // try to load a mixed var table, should fail and issue warnings + ofLog() << " ### should be warnings here vvv"; + vector testStringVector; + lua.getStringVector("mixedTable", testStringVector); + ofLog() << " ### should be warnings here ^^^"; + + // read manually by index, lua indices start at 1 not 0! + lua.pushTable("mixedTable"); + ofLog() << "mixedTable"; + for(size_t i = 1; i <= lua.tableSize(); ++i) { + if(lua.isBool(i)) { + ofLogNotice() << "\t" << i << " b: " << lua.getBool(i); + } + else if(lua.isNumber(i)) { + ofLogNotice() << "\t" << i << " n: " << lua.getNumber(i); + } + else if(lua.isString(i)) { + ofLogNotice() << "\t" << i << " s: " << lua.getString(i); + } + } + lua.popTable(); + + // load a table within a table by name + lua.pushTable("atable"); + lua.getStringVector("stringTable", stringTable); + line << "atable.stringTable: "; + for(size_t i = 0; i < stringTable.size(); ++i) { + line << "\"" << stringTable[i] << "\" "; + } + ofLog() << line.str() << "#: " << lua.tableSize("stringTable"); + line.str(""); // clear + lua.popTable(); + + // load a table within a table by index + lua.pushTable("atable"); + lua.pushTable("nestedTable"); + lua.getNumberVector(2, numberTable); + line << "atable.nestedTable[2]: "; + for(size_t i = 0; i < numberTable.size(); ++i) { + line << numberTable[i] << " "; + } + ofLog() << line.str() << "#: " << lua.tableSize(2); + line.str(""); // clear + lua.popAllTables(); + + // print the contents of the "atable" table + lua.pushTable("atable"); // move from the global lua namespace to the "atable" table + lua.printTable(); // print variables & tables in "atable" + lua.popTable(); // return to the global namespace + + // check if testing existence within a table works + lua.pushTable("atable"); + ofLog() << "atable.afunction a function?: " << lua.isFunction("afunction"); + lua.pushTable("nestedTable"); + lua.pushTable(1); + ofLog() << "atable.nestedTable[1][1] a number?: " << lua.isNumber(1); + lua.popAllTables(); + + ofLog() << "*** END READ TEST ***" << endl; + + //------ + + ofLog() << "*** BEGIN WRITE TEST ***"; + + // print + ofLog() << "values before:"; + ofLog() << " abool: " << lua.getBool("abool"); + ofLog() << " anumber: " << lua.getNumber("anumber"); + ofLog() << " astring: " << lua.getString("astring"); + + // this should throw a warning, it dosen't exist yet + ofLog() << "### should be a warning here vvv"; + ofLog() << " newstring: " << lua.getString("newstring"); + ofLog() << "### should be a warning here ^^^"; + + numberTable.clear(); + lua.getNumberVector("numberTable", numberTable); + line << " numberTable: "; + for(size_t i = 0; i < numberTable.size(); ++i) { + line << numberTable[i] << " "; + } + ofLog() << line.str() << "#: " << lua.tableSize("numberTable"); + line.str(""); // clear + + // set values + lua.setBool("abool", false); + lua.setNumber("anumber", 66.6); + lua.setString("astring", "kaaaaa"); + + // add new value + lua.setString("newstring", "a new string"); + + // set vector + numberTable.clear(); + for(size_t i = 0; i < 10; i+=2) { + numberTable.push_back(i); + } + lua.setNumberVector("numberTable", numberTable); + + // print again + ofLog() << "values after:"; + ofLog() << " abool: " << lua.getBool("abool"); + ofLog() << " anumber: " << lua.getNumber("anumber"); + ofLog() << " astring: " << lua.getString("astring"); + ofLog() << " newstring: " << lua.getString("newstring"); + + numberTable.clear(); + lua.getNumberVector("numberTable", numberTable); + line << " numberTable: "; + for(size_t i = 0; i < numberTable.size(); ++i) + line << numberTable[i] << " "; + ofLog() << line.str() << "#: " << lua.tableSize("numberTable"); + line.str(""); // clear + + // write manually by index, remember lua indices start at 1 not 0! + lua.pushTable("mixedTable"); + for(size_t i = 1; i <= lua.tableSize(); ++i) { + if(lua.isBool(i)) { + lua.setBool(i, true); + } + else if(lua.isNumber(i)) { + lua.setNumber(i, 9999.99); + } + else if(lua.isString(i)) { + lua.setString(i, "abcdefg"); + } + } + lua.printTable(); + lua.popTable(); + + ofLog() << "*** END WRITE TEST ***" << endl; + + //------ + + ofLog() << "*** BEGIN EXIST TEST ***"; + + // "avar" dosen't exist + ofLog() << "avar exists: " << lua.isNumber("avar") + << ", is nil: " << lua.isNil("avar"); + + // "avar" exists and is equal to 99 + lua.setNumber("avar", 99); + ofLog() << "avar exists: " << lua.isNumber("avar") + << ", is nil: " << lua.isNil("avar"); + ofLog() << " avar: " << lua.getNumber("avar"); + + // set "avar" to nil, it no longer exists + lua.setNil("avar"); + ofLog() << "avar exists: " << lua.isNumber("avar") + << ", is nil: " << lua.isNil("avar"); + + ofLog() << "*** END EXIST TEST ***" << endl; + + //------ + + ofLog() << "*** BEGIN CLEAR TEST ***"; + + lua.printTable("anotherTable"); + lua.clearTable("anotherTable"); + ofLog() << "### should only print the table name vvv"; + lua.printTable("anotherTable"); // should only print the name + + ofLog() << "*** END CLEAR TEST ***" << endl; + + //------ + + ofLog() << "*** BEGIN FILE WRITER TEST ***"; + + // write text & vars out into a text file + ofxLuaFileWriter luaWriter; + string filename = "writerTest.lua"; + luaWriter.writeComment("lua writer test"); + luaWriter.newLine(); + luaWriter.beginCommentBlock(); + luaWriter.writeLine("this is a comment block"); + luaWriter.endCommentBlock(); + luaWriter.newLine(); + luaWriter.writeBool("abool", lua.getBool("abool")); + luaWriter.writeNumber("anumber", lua.getNumber("anumber")); + luaWriter.writeString("astring", lua.getString("astring")); + luaWriter.beginTable("vectors"); + luaWriter.writeBoolVector("boolTable", boolTable); + luaWriter.writeNumberVector("numberTable", numberTable); + luaWriter.writeStringVector("stringTable", stringTable); + luaWriter.endTable(); + + // write a table's contents recursively into the file + lua.writeTable("atable", luaWriter, true); + + // save, load, and print file + if(luaWriter.saveToFile(filename)) { + + // print + ofLog() << "### Written File vvv"; + ofBuffer b = ofBufferFromFile(filename); + for(auto &line : b.getLines()) { + ofLog() << line; + } + b.clear(); + ofLog() << "### Written File ^^^"; + + // try loading into lua state + lua.doScript(filename); + + // delete when done + ofFile::removeFile(filename); + } + + ofLog() << "*** END FILE WRITER TEST ***" << endl; + + //------- + + ofLog() << "*** CHECK STACK ***"; + ofLog() << "Tests Done, stack length should be 0"; + lua.printStack(); + ofLog() << "*** TESTS DONE ***" << endl; + } diff --git a/addons/ofxLua/luaTests/src/ofApp.h b/addons/ofxLua/luaTests/src/ofApp.h new file mode 100644 index 0000000..dbff1a7 --- /dev/null +++ b/addons/ofxLua/luaTests/src/ofApp.h @@ -0,0 +1,36 @@ +/* + * Copyright (c) 2018 Dan Wilcox + * + * BSD Simplified License. + * For information on usage and redistribution, and for a DISCLAIMER OF ALL + * WARRANTIES, see the file, "LICENSE.txt," in this distribution. + * + * See https://github.com/danomatika/ofxLua for documentation + * + */ +#pragma once + +#include "ofMain.h" +#include "ofxLua.h" + +class ofApp : public ofBaseApp, ofxLuaListener { + + public: + + void setup(); + void update(); + void draw(); + void exit(); + + void keyPressed(int key); + void mouseMoved(int x, int y); + void mouseDragged(int x, int y, int button); + void mousePressed(int x, int y, int button); + void mouseReleased(int x, int y, int button); + + void errorReceived(std::string& msg); + + void runTests(); + + ofxLua lua; +}; diff --git a/addons/ofxLua/ofxLuaLib/bin/FreeImage.dll b/addons/ofxLua/ofxLuaLib/bin/FreeImage.dll index cb4cf6e..1959c17 100644 Binary files a/addons/ofxLua/ofxLuaLib/bin/FreeImage.dll and b/addons/ofxLua/ofxLuaLib/bin/FreeImage.dll differ diff --git a/addons/ofxLua/ofxLuaLib/bin/glu32.dll b/addons/ofxLua/ofxLuaLib/bin/glu32.dll new file mode 100644 index 0000000..a276058 Binary files /dev/null and b/addons/ofxLua/ofxLuaLib/bin/glu32.dll differ diff --git a/addons/ofxLua/ofxLuaLib/bin/qtmlClient.dll b/addons/ofxLua/ofxLuaLib/bin/qtmlClient.dll new file mode 100644 index 0000000..b27c607 Binary files /dev/null and b/addons/ofxLua/ofxLuaLib/bin/qtmlClient.dll differ diff --git a/addons/ofxLua/ofxLuaLib/ofxLuaLib.vcxproj b/addons/ofxLua/ofxLuaLib/ofxLuaLib.vcxproj index e76f748..711f0de 100644 --- a/addons/ofxLua/ofxLuaLib/ofxLuaLib.vcxproj +++ b/addons/ofxLua/ofxLuaLib/ofxLuaLib.vcxproj @@ -21,32 +21,32 @@ {E6CFB1D6-7BE9-4459-8A47-A769BA6309CA} ofxLuaLib - 8.1 + 10.0 StaticLibrary true - v140 + v142 MultiByte StaticLibrary true - v140 + v142 MultiByte StaticLibrary false - v140 + v142 true MultiByte StaticLibrary false - v140 + v142 true MultiByte @@ -159,12 +159,13 @@ - + + - + diff --git a/addons/ofxLua/ofxLuaLib/ofxLuaLib.vcxproj.filters b/addons/ofxLua/ofxLuaLib/ofxLuaLib.vcxproj.filters index f8294ab..98d88a4 100644 --- a/addons/ofxLua/ofxLuaLib/ofxLuaLib.vcxproj.filters +++ b/addons/ofxLua/ofxLuaLib/ofxLuaLib.vcxproj.filters @@ -15,7 +15,10 @@ src - + + src\bindings + + src\bindings @@ -26,7 +29,7 @@ src - + src\bindings diff --git a/addons/ofxLua/src/bindings/ofxLuaBindings.cpp b/addons/ofxLua/src/bindings/desktop/ofBindings.cpp similarity index 80% rename from addons/ofxLua/src/bindings/ofxLuaBindings.cpp rename to addons/ofxLua/src/bindings/desktop/ofBindings.cpp index f8ae63b..eb7eea3 100644 --- a/addons/ofxLua/src/bindings/ofxLuaBindings.cpp +++ b/addons/ofxLua/src/bindings/desktop/ofBindings.cpp @@ -1,6 +1,6 @@ /* ---------------------------------------------------------------------------- * This file was automatically generated by SWIG (http://www.swig.org). - * Version 3.0.12 + * Version 4.0.1 * * This file is not intended to be easily readable and contains a number of * coding conventions designed to improve portability and efficiency. Do not make @@ -214,6 +214,7 @@ template T SwigValueInit() { /* Flags for pointer conversions */ #define SWIG_POINTER_DISOWN 0x1 #define SWIG_CAST_NEW_MEMORY 0x2 +#define SWIG_POINTER_NO_NULL 0x4 /* Flags for new pointer objects */ #define SWIG_POINTER_OWN 0x1 @@ -742,6 +743,23 @@ SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) { } #endif +/* Errors in SWIG */ +#define SWIG_UnknownError -1 +#define SWIG_IOError -2 +#define SWIG_RuntimeError -3 +#define SWIG_IndexError -4 +#define SWIG_TypeError -5 +#define SWIG_DivisionByZero -6 +#define SWIG_OverflowError -7 +#define SWIG_SyntaxError -8 +#define SWIG_ValueError -9 +#define SWIG_SystemError -10 +#define SWIG_AttributeError -11 +#define SWIG_MemoryError -12 +#define SWIG_NullReferenceError -13 + + + /* ----------------------------------------------------------------------------- * luarun.swg * @@ -924,8 +942,8 @@ typedef struct swig_elua_entry { * -------------------------------------------------------------------------- */ /* Push the string STR on the Lua stack, like lua_pushstring, but - prefixed with the the location of the innermost Lua call-point - (as formated by luaL_where). */ + prefixed with the location of the innermost Lua call-point + (as formatted by luaL_where). */ SWIGRUNTIME void SWIG_Lua_pusherrstring (lua_State *L, const char *str) { @@ -935,8 +953,8 @@ SWIG_Lua_pusherrstring (lua_State *L, const char *str) } /* Push a formatted string generated from FMT and following args on - the Lua stack, like lua_pushfstring, but prefixed with the the - location of the innermost Lua call-point (as formated by luaL_where). */ + the Lua stack, like lua_pushfstring, but prefixed with the + location of the innermost Lua call-point (as formatted by luaL_where). */ SWIGRUNTIME void SWIG_Lua_pushferrstring (lua_State *L, const char *fmt, ...) { @@ -1033,7 +1051,7 @@ to tell the two structures apart within SWIG, other than by looking at the type typedef struct { swig_type_info *type; int own; /* 1 if owned & must be destroyed */ - char data[1]; /* arbitary amount of data */ + char data[1]; /* arbitrary amount of data */ } swig_lua_rawdata; /* Common SWIG API */ @@ -1085,7 +1103,7 @@ typedef struct { #define SWIG_isptrtype(L,I) (lua_isuserdata(L,I) || lua_isnil(L,I)) #ifdef __cplusplus -/* Special helper for member function pointers +/* Special helper for member function pointers it gets the address, casts it, then dereferences it */ /*#define SWIG_mem_fn_as_voidptr(a) (*((char**)&(a))) */ #endif @@ -1188,7 +1206,7 @@ SWIGINTERN void SWIG_Lua_elua_emulate_register(lua_State *L, const swig_elua_ent lua_pop(L,1); /*remove nil */ lua_newtable(L); SWIG_Lua_elua_emulate_register(L,entry->value.value.table); - } + } if(is_metatable) { assert(lua_istable(L,-1)); lua_pushvalue(L,-1); @@ -1197,11 +1215,11 @@ SWIGINTERN void SWIG_Lua_elua_emulate_register(lua_State *L, const swig_elua_ent break; case LUA_TUSERDATA: - if(entry->value.value.userdata.member) + if(entry->value.value.userdata.member) SWIG_NewMemberObj(L,entry->value.value.userdata.pvalue, entry->value.value.userdata.lvalue, *(entry->value.value.userdata.ptype)); - else + else SWIG_NewPointerObj(L,entry->value.value.userdata.pvalue, *(entry->value.value.userdata.ptype),0); break; @@ -1246,7 +1264,7 @@ SWIGINTERN int SWIG_Lua_emulate_elua_getmetatable(lua_State *L) } assert(lua_gettop(L) == 2); return 1; - + fail: lua_error(L); return 0; @@ -1264,7 +1282,7 @@ SWIGINTERN void SWIG_Lua_emulate_elua_swap_getmetatable(lua_State *L) lua_pushcfunction(L, SWIG_Lua_emulate_elua_getmetatable); lua_rawset(L,-3); lua_pop(L,2); - + } /* END OF REMOVE */ @@ -1783,17 +1801,11 @@ SWIGINTERN int SWIG_Lua_class_tostring(lua_State *L) { /* there should be 1 param passed in (1) userdata (not the metatable) */ - const char *className; - void* userData; + swig_lua_userdata* userData; assert(lua_isuserdata(L,1)); /* just in case */ - userData = lua_touserdata(L,1); /* get the userdata address for later */ - lua_getmetatable(L,1); /* get the meta table */ - assert(lua_istable(L,-1)); /* just in case */ - - lua_getfield(L, -1, ".type"); - className = lua_tostring(L, -1); + userData = (swig_lua_userdata*)lua_touserdata(L,1); /* get the userdata address */ - lua_pushfstring(L, "<%s userdata: %p>", className, userData); + lua_pushfstring(L, "", userData->type->str, userData->ptr); return 1; } @@ -1805,7 +1817,7 @@ SWIGINTERN int SWIG_Lua_class_disown(lua_State *L) swig_lua_userdata *usr; assert(lua_isuserdata(L,-1)); /* just in case */ usr=(swig_lua_userdata*)lua_touserdata(L,-1); /* get it */ - + usr->own = 0; /* clear our ownership */ return 0; } @@ -1914,7 +1926,7 @@ SWIGINTERN void SWIG_Lua_get_class_metatable(lua_State *L,const char *cname) Each class structure has a list of pointers to the base class structures. This function fills them. It cannot be done at compile time, as this will not work with hireachies -spread over more than one swig file. +spread over more than one swig file. Therefore it must be done at runtime, querying the SWIG type system. */ SWIGINTERN void SWIG_Lua_init_base_class(lua_State *L,swig_lua_class *clss) @@ -2148,11 +2160,11 @@ SWIGRUNTIME int SWIG_Lua_resolve_metamethod(lua_State *L) lua_checkstack(L,5); numargs = lua_gettop(L); /* number of arguments to pass to actual metamethod */ - + /* Get upvalues from closure */ lua_pushvalue(L, lua_upvalueindex(1)); /*Get function name*/ metamethod_name_idx = lua_gettop(L); - + lua_pushvalue(L, lua_upvalueindex(2)); clss = (const swig_lua_class*)(lua_touserdata(L,-1)); lua_pop(L,1); /* remove lightuserdata with clss from stack */ @@ -2184,7 +2196,7 @@ SWIGINTERN int SWIG_Lua_add_class_user_metamethod(lua_State *L, swig_lua_class * /* metamethod name - on the top of the stack */ assert(lua_isstring(L,-1)); - + key_index = lua_gettop(L); /* Check whether method is already defined in metatable */ @@ -2194,7 +2206,7 @@ SWIGINTERN int SWIG_Lua_add_class_user_metamethod(lua_State *L, swig_lua_class * lua_pop(L,1); return -1; } - lua_pop(L,1); + lua_pop(L,1); /* Iterating over immediate bases */ for(i=0;clss->bases[i];i++) @@ -2204,13 +2216,13 @@ SWIGINTERN int SWIG_Lua_add_class_user_metamethod(lua_State *L, swig_lua_class * lua_pushvalue(L, key_index); lua_rawget(L, -2); if( !lua_isnil(L,-1) ) { - lua_pushvalue(L, key_index); + lua_pushvalue(L, key_index); /* Add proxy function */ lua_pushvalue(L, key_index); /* first closure value is function name */ lua_pushlightuserdata(L, clss); /* second closure value is swig_lua_class structure */ lua_pushcclosure(L, SWIG_Lua_resolve_metamethod, 2); - + lua_rawset(L, metatable_index); success = 1; } @@ -2221,7 +2233,7 @@ SWIGINTERN int SWIG_Lua_add_class_user_metamethod(lua_State *L, swig_lua_class * break; } - return success; + return success; } SWIGINTERN void SWIG_Lua_add_class_user_metamethods(lua_State *L, swig_lua_class *clss) @@ -2509,7 +2521,12 @@ SWIGRUNTIME int SWIG_Lua_ConvertPtr(lua_State *L,int index,void **ptr,swig_type { swig_lua_userdata *usr; swig_cast_info *cast; - if (lua_isnil(L,index)){*ptr=0; return SWIG_OK;} /* special case: lua nil => NULL pointer */ + /* special case: lua nil => NULL pointer */ + if (lua_isnil(L,index)) + { + *ptr=0; + return (flags & SWIG_POINTER_NO_NULL) ? SWIG_NullReferenceError : SWIG_OK; + } usr=(swig_lua_userdata*)lua_touserdata(L,index); /* get data */ if (usr) { @@ -2555,7 +2572,7 @@ SWIGRUNTIME void SWIG_Lua_NewPackedObj(lua_State *L,void *ptr,size_t size,swig_t memcpy(raw->data,ptr,size); /* copy the data */ SWIG_Lua_AddMetatable(L,type); /* add metatable */ } - + /* converts a packed userdata. user for member fn pointers only */ SWIGRUNTIME int SWIG_Lua_ConvertPacked(lua_State *L,int index,void *ptr,size_t size,swig_type_info *type) { @@ -2604,7 +2621,7 @@ SWIG_Lua_InstallConstants(lua_State *L, swig_lua_const_info constants[]) { switch(constants[i].type) { case SWIG_LUA_INT: lua_pushstring(L,constants[i].name); - lua_pushinteger(L,(lua_Number)constants[i].lvalue); + lua_pushinteger(L,(lua_Integer)constants[i].lvalue); lua_rawset(L,-3); break; case SWIG_LUA_FLOAT: @@ -2615,7 +2632,7 @@ SWIG_Lua_InstallConstants(lua_State *L, swig_lua_const_info constants[]) { case SWIG_LUA_CHAR: lua_pushstring(L,constants[i].name); { - char c = constants[i].lvalue; + char c = (char)constants[i].lvalue; lua_pushlstring(L,&c,1); } lua_rawset(L,-3); @@ -2654,7 +2671,7 @@ Unfortunately lua keeps changing its APIs, so we need a conditional compile In lua 5.0.X it's lua_dostring() In lua 5.1.X it's luaL_dostring() */ -SWIGINTERN int +SWIGINTERN int SWIG_Lua_dostring(lua_State *L, const char *str) { int ok,top; if (str==0 || str[0]==0) return 0; /* nothing to do */ @@ -2669,7 +2686,7 @@ SWIG_Lua_dostring(lua_State *L, const char *str) { } lua_settop(L,top); /* restore the stack */ return ok; -} +} #ifdef __cplusplus } @@ -2697,40 +2714,40 @@ SWIG_Lua_dostring(lua_State *L, const char *str) { /* -------- TYPES TABLE (BEGIN) -------- */ -#define SWIGTYPE_p_Firmata_Encoder_Data swig_types[0] -#define SWIGTYPE_p_Firmata_I2C_Data swig_types[1] -#define SWIGTYPE_p_Firmata_Serial_Data swig_types[2] -#define SWIGTYPE_p_Firmata_Stepper_Data swig_types[3] -#define SWIGTYPE_p_GLintptr swig_types[4] -#define SWIGTYPE_p_GLsizei swig_types[5] -#define SWIGTYPE_p_GLsizeiptr swig_types[6] -#define SWIGTYPE_p__XDisplay swig_types[7] -#define SWIGTYPE_p_boost__filesystem__path swig_types[8] -#define SWIGTYPE_p_double swig_types[9] -#define SWIGTYPE_p_float swig_types[10] -#define SWIGTYPE_p_glm__mat3 swig_types[11] -#define SWIGTYPE_p_glm__mat4 swig_types[12] -#define SWIGTYPE_p_glm__quat swig_types[13] -#define SWIGTYPE_p_glm__tvec2T_int_glm__precision__defaultp_t swig_types[14] -#define SWIGTYPE_p_glm__tvec3T_int_glm__precision__defaultp_t swig_types[15] -#define SWIGTYPE_p_glm__tvec4T_int_glm__precision__defaultp_t swig_types[16] +#define SWIGTYPE_p_Base swig_types[0] +#define SWIGTYPE_p_Firmata_Encoder_Data swig_types[1] +#define SWIGTYPE_p_Firmata_I2C_Data swig_types[2] +#define SWIGTYPE_p_Firmata_Serial_Data swig_types[3] +#define SWIGTYPE_p_Firmata_Stepper_Data swig_types[4] +#define SWIGTYPE_p_GLintptr swig_types[5] +#define SWIGTYPE_p_GLsizei swig_types[6] +#define SWIGTYPE_p_GLsizeiptr swig_types[7] +#define SWIGTYPE_p_Node swig_types[8] +#define SWIGTYPE_p__XDisplay swig_types[9] +#define SWIGTYPE_p_boost__filesystem__path swig_types[10] +#define SWIGTYPE_p_difference_type swig_types[11] +#define SWIGTYPE_p_double swig_types[12] +#define SWIGTYPE_p_float swig_types[13] +#define SWIGTYPE_p_glm__mat3 swig_types[14] +#define SWIGTYPE_p_glm__mat4 swig_types[15] +#define SWIGTYPE_p_glm__quat swig_types[16] #define SWIGTYPE_p_glm__vec2 swig_types[17] #define SWIGTYPE_p_glm__vec3 swig_types[18] #define SWIGTYPE_p_glm__vec4 swig_types[19] -#define SWIGTYPE_p_int swig_types[20] -#define SWIGTYPE_p_int16_t swig_types[21] -#define SWIGTYPE_p_int32_t swig_types[22] -#define SWIGTYPE_p_int8_t swig_types[23] -#define SWIGTYPE_p_long_long swig_types[24] -#define SWIGTYPE_p_of3dPrimitive swig_types[25] -#define SWIGTYPE_p_ofAbstractParameter swig_types[26] -#define SWIGTYPE_p_ofAlphabet swig_types[27] -#define SWIGTYPE_p_ofAppBaseWindow swig_types[28] -#define SWIGTYPE_p_ofArduino swig_types[29] -#define SWIGTYPE_p_ofArrayViewT_unsigned_int_t swig_types[30] -#define SWIGTYPE_p_ofArrayViewT_void_t swig_types[31] -#define SWIGTYPE_p_ofBaseApp swig_types[32] -#define SWIGTYPE_p_ofBaseDraws swig_types[33] +#define SWIGTYPE_p_glm__vecT_2_int_glm__precision__defaultp_t swig_types[20] +#define SWIGTYPE_p_glm__vecT_3_int_glm__precision__defaultp_t swig_types[21] +#define SWIGTYPE_p_glm__vecT_4_int_glm__precision__defaultp_t swig_types[22] +#define SWIGTYPE_p_int swig_types[23] +#define SWIGTYPE_p_int16_t swig_types[24] +#define SWIGTYPE_p_int32_t swig_types[25] +#define SWIGTYPE_p_int8_t swig_types[26] +#define SWIGTYPE_p_long_long swig_types[27] +#define SWIGTYPE_p_of3dPrimitive swig_types[28] +#define SWIGTYPE_p_ofAbstractParameter swig_types[29] +#define SWIGTYPE_p_ofAppBaseWindow swig_types[30] +#define SWIGTYPE_p_ofArduino swig_types[31] +#define SWIGTYPE_p_ofBaseDraws swig_types[32] +#define SWIGTYPE_p_ofBaseHasPixels swig_types[33] #define SWIGTYPE_p_ofBaseHasTexture swig_types[34] #define SWIGTYPE_p_ofBaseImage_T_float_t swig_types[35] #define SWIGTYPE_p_ofBaseImage_T_unsigned_char_t swig_types[36] @@ -2741,170 +2758,163 @@ SWIG_Lua_dostring(lua_State *L, const char *str) { #define SWIGTYPE_p_ofBaseSoundInput swig_types[41] #define SWIGTYPE_p_ofBaseSoundOutput swig_types[42] #define SWIGTYPE_p_ofBaseSoundPlayer swig_types[43] -#define SWIGTYPE_p_ofBoxPrimitive swig_types[44] -#define SWIGTYPE_p_ofBuffer swig_types[45] -#define SWIGTYPE_p_ofBufferObject swig_types[46] -#define SWIGTYPE_p_ofCamera swig_types[47] -#define SWIGTYPE_p_ofColor_T_float_t swig_types[48] -#define SWIGTYPE_p_ofColor_T_unsigned_char_t swig_types[49] -#define SWIGTYPE_p_ofColor_T_unsigned_short_t swig_types[50] -#define SWIGTYPE_p_ofConePrimitive swig_types[51] -#define SWIGTYPE_p_ofConsoleLoggerChannel swig_types[52] -#define SWIGTYPE_p_ofCoreEvents swig_types[53] -#define SWIGTYPE_p_ofCylinderPrimitive swig_types[54] -#define SWIGTYPE_p_ofDebugViewLoggerChannel swig_types[55] -#define SWIGTYPE_p_ofDirectory swig_types[56] -#define SWIGTYPE_p_ofDragInfo swig_types[57] -#define SWIGTYPE_p_ofEasyCam swig_types[58] -#define SWIGTYPE_p_ofEventArgs swig_types[59] -#define SWIGTYPE_p_ofEventT_Firmata_I2C_Data_const_t swig_types[60] -#define SWIGTYPE_p_ofEventT_Firmata_Serial_Data_const_t swig_types[61] -#define SWIGTYPE_p_ofEventT_Firmata_Stepper_Data_const_t swig_types[62] -#define SWIGTYPE_p_ofEventT_int_const_t swig_types[63] -#define SWIGTYPE_p_ofEventT_ofHttpResponse_t swig_types[64] -#define SWIGTYPE_p_ofEventT_std__pairT_int_Firmata_Pin_Modes_t_const_t swig_types[65] -#define SWIGTYPE_p_ofEventT_std__string_const_t swig_types[66] -#define SWIGTYPE_p_ofEventT_std__vectorT_Firmata_Encoder_Data_t_const_t swig_types[67] -#define SWIGTYPE_p_ofEventT_std__vectorT_unsigned_char_t_const_t swig_types[68] -#define SWIGTYPE_p_ofFbo swig_types[69] -#define SWIGTYPE_p_ofFbo__Settings swig_types[70] -#define SWIGTYPE_p_ofFile swig_types[71] -#define SWIGTYPE_p_ofFileDialogResult swig_types[72] -#define SWIGTYPE_p_ofFileLoggerChannel swig_types[73] -#define SWIGTYPE_p_ofFilePath swig_types[74] -#define SWIGTYPE_p_ofFpsCounter swig_types[75] -#define SWIGTYPE_p_ofHttpRequest swig_types[76] -#define SWIGTYPE_p_ofHttpResponse swig_types[77] -#define SWIGTYPE_p_ofIcoSpherePrimitive swig_types[78] -#define SWIGTYPE_p_ofImageLoadSettings swig_types[79] -#define SWIGTYPE_p_ofImage_T_float_t swig_types[80] -#define SWIGTYPE_p_ofImage_T_unsigned_char_t swig_types[81] -#define SWIGTYPE_p_ofImage_T_unsigned_short_t swig_types[82] -#define SWIGTYPE_p_ofKeyEventArgs swig_types[83] -#define SWIGTYPE_p_ofLight swig_types[84] -#define SWIGTYPE_p_ofLog swig_types[85] -#define SWIGTYPE_p_ofLogError swig_types[86] -#define SWIGTYPE_p_ofLogFatalError swig_types[87] -#define SWIGTYPE_p_ofLogNotice swig_types[88] -#define SWIGTYPE_p_ofLogVerbose swig_types[89] -#define SWIGTYPE_p_ofLogWarning swig_types[90] -#define SWIGTYPE_p_ofLoopType swig_types[91] -#define SWIGTYPE_p_ofMaterial swig_types[92] -#define SWIGTYPE_p_ofMaterial__Settings swig_types[93] -#define SWIGTYPE_p_ofMatrix3x3 swig_types[94] -#define SWIGTYPE_p_ofMatrix4x4 swig_types[95] -#define SWIGTYPE_p_ofMatrixStack swig_types[96] -#define SWIGTYPE_p_ofMeshData swig_types[97] -#define SWIGTYPE_p_ofMeshFace_T_glm__vec3_glm__vec3_ofColor_T_float_t_glm__vec2_t swig_types[98] -#define SWIGTYPE_p_ofMesh_T_glm__vec3_glm__vec3_ofColor_T_float_t_glm__vec2_t swig_types[99] -#define SWIGTYPE_p_ofMessage swig_types[100] -#define SWIGTYPE_p_ofMouseEventArgs swig_types[101] -#define SWIGTYPE_p_ofNode swig_types[102] -#define SWIGTYPE_p_ofParameterGroup swig_types[103] -#define SWIGTYPE_p_ofPath swig_types[104] -#define SWIGTYPE_p_ofPixels_T_float_t swig_types[105] -#define SWIGTYPE_p_ofPixels_T_unsigned_char_t swig_types[106] -#define SWIGTYPE_p_ofPixels_T_unsigned_short_t swig_types[107] -#define SWIGTYPE_p_ofPlanePrimitive swig_types[108] -#define SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t swig_types[109] -#define SWIGTYPE_p_ofQuaternion swig_types[110] -#define SWIGTYPE_p_ofRectangle swig_types[111] -#define SWIGTYPE_p_ofResizeEventArgs swig_types[112] -#define SWIGTYPE_p_ofSerial swig_types[113] -#define SWIGTYPE_p_ofSerialDeviceInfo swig_types[114] -#define SWIGTYPE_p_ofShader swig_types[115] -#define SWIGTYPE_p_ofShader__Settings swig_types[116] -#define SWIGTYPE_p_ofShader__TransformFeedbackBaseBinding swig_types[117] -#define SWIGTYPE_p_ofShader__TransformFeedbackRangeBinding swig_types[118] -#define SWIGTYPE_p_ofShader__TransformFeedbackSettings swig_types[119] -#define SWIGTYPE_p_ofSoundDevice swig_types[120] -#define SWIGTYPE_p_ofSoundDevice__Api swig_types[121] -#define SWIGTYPE_p_ofSoundPlayer swig_types[122] -#define SWIGTYPE_p_ofSoundStream swig_types[123] -#define SWIGTYPE_p_ofSoundStreamSettings swig_types[124] -#define SWIGTYPE_p_ofSpherePrimitive swig_types[125] -#define SWIGTYPE_p_ofStyle swig_types[126] -#define SWIGTYPE_p_ofTexture swig_types[127] -#define SWIGTYPE_p_ofTextureData swig_types[128] -#define SWIGTYPE_p_ofTime swig_types[129] -#define SWIGTYPE_p_ofTouchEventArgs swig_types[130] -#define SWIGTYPE_p_ofTrueTypeFont swig_types[131] -#define SWIGTYPE_p_ofTrueTypeFont__Settings swig_types[132] -#define SWIGTYPE_p_ofTrueTypeFont__Settings__Direction swig_types[133] -#define SWIGTYPE_p_ofURLFileLoader swig_types[134] -#define SWIGTYPE_p_ofUnicode swig_types[135] -#define SWIGTYPE_p_ofUnicode__range swig_types[136] -#define SWIGTYPE_p_ofVbo swig_types[137] -#define SWIGTYPE_p_ofVboMesh swig_types[138] -#define SWIGTYPE_p_ofVec2f swig_types[139] -#define SWIGTYPE_p_ofVec3f swig_types[140] -#define SWIGTYPE_p_ofVec4f swig_types[141] -#define SWIGTYPE_p_ofVideoDevice swig_types[142] -#define SWIGTYPE_p_ofVideoGrabber swig_types[143] -#define SWIGTYPE_p_ofVideoPlayer swig_types[144] -#define SWIGTYPE_p_ofWindowPosEventArgs swig_types[145] -#define SWIGTYPE_p_ofXml swig_types[146] -#define SWIGTYPE_p_ofXmlSearchIterator swig_types[147] -#define SWIGTYPE_p_ofXml__Attribute swig_types[148] -#define SWIGTYPE_p_ofXml__RangeT_ofXmlIteratorT_pugi__xml_attribute_iterator_t_t swig_types[149] -#define SWIGTYPE_p_ofXml__RangeT_ofXmlIteratorT_pugi__xml_named_node_iterator_t_t swig_types[150] -#define SWIGTYPE_p_ofXml__RangeT_ofXmlIteratorT_pugi__xml_node_iterator_t_t swig_types[151] -#define SWIGTYPE_p_ofXml__Search swig_types[152] -#define SWIGTYPE_p_std__chrono__nanoseconds swig_types[153] -#define SWIGTYPE_p_std__chrono__time_pointT_std__chrono__nanoseconds_t swig_types[154] -#define SWIGTYPE_p_std__functionT_void_fofHttpResponse_const_RF_t swig_types[155] -#define SWIGTYPE_p_std__initializer_listT_ofUnicode__range_t swig_types[156] -#define SWIGTYPE_p_std__istream swig_types[157] -#define SWIGTYPE_p_std__mapT_int_supportedPinTypes_t swig_types[158] -#define SWIGTYPE_p_std__mapT_std__string_std__string_t swig_types[159] -#define SWIGTYPE_p_std__ostream swig_types[160] -#define SWIGTYPE_p_std__shared_ptrT_ofAppBaseWindow_t swig_types[161] -#define SWIGTYPE_p_std__shared_ptrT_ofBaseLoggerChannel_t swig_types[162] -#define SWIGTYPE_p_std__shared_ptrT_ofBaseRenderer_t swig_types[163] -#define SWIGTYPE_p_std__shared_ptrT_ofBaseSoundPlayer_t swig_types[164] -#define SWIGTYPE_p_std__shared_ptrT_ofBaseSoundStream_t swig_types[165] -#define SWIGTYPE_p_std__shared_ptrT_ofBaseVideoGrabber_t swig_types[166] -#define SWIGTYPE_p_std__shared_ptrT_ofBaseVideoPlayer_t swig_types[167] -#define SWIGTYPE_p_std__string swig_types[168] -#define SWIGTYPE_p_std__vectorT_char_t swig_types[169] -#define SWIGTYPE_p_std__vectorT_float_t swig_types[170] -#define SWIGTYPE_p_std__vectorT_glm__vec2_t swig_types[171] -#define SWIGTYPE_p_std__vectorT_glm__vec3_t swig_types[172] -#define SWIGTYPE_p_std__vectorT_glm__vec3_t__const_iterator swig_types[173] -#define SWIGTYPE_p_std__vectorT_glm__vec3_t__const_reverse_iterator swig_types[174] -#define SWIGTYPE_p_std__vectorT_glm__vec3_t__iterator swig_types[175] -#define SWIGTYPE_p_std__vectorT_glm__vec3_t__reverse_iterator swig_types[176] -#define SWIGTYPE_p_std__vectorT_int_t swig_types[177] -#define SWIGTYPE_p_std__vectorT_ofFile_t swig_types[178] -#define SWIGTYPE_p_std__vectorT_ofPath__Command_t swig_types[179] -#define SWIGTYPE_p_std__vectorT_ofPath_t swig_types[180] -#define SWIGTYPE_p_std__vectorT_ofPolyline_t swig_types[181] -#define SWIGTYPE_p_std__vectorT_ofSerialDeviceInfo_t swig_types[182] -#define SWIGTYPE_p_std__vectorT_ofShader__TransformFeedbackBaseBinding_t swig_types[183] -#define SWIGTYPE_p_std__vectorT_ofShader__TransformFeedbackRangeBinding_t swig_types[184] -#define SWIGTYPE_p_std__vectorT_ofSoundDevice_t swig_types[185] -#define SWIGTYPE_p_std__vectorT_ofTexture_t swig_types[186] -#define SWIGTYPE_p_std__vectorT_ofVec2f_t swig_types[187] -#define SWIGTYPE_p_std__vectorT_ofVec3f_t swig_types[188] -#define SWIGTYPE_p_std__vectorT_ofVideoDevice_t swig_types[189] -#define SWIGTYPE_p_std__vectorT_std__string_t swig_types[190] -#define SWIGTYPE_p_std__vectorT_std__weak_ptrT_ofLight__Data_t_t swig_types[191] -#define SWIGTYPE_p_std__vectorT_unsigned_char_t swig_types[192] -#define SWIGTYPE_p_std__vectorT_unsigned_int_t swig_types[193] -#define SWIGTYPE_p_string swig_types[194] -#define SWIGTYPE_p_supportedPinTypes swig_types[195] -#define SWIGTYPE_p_uint16_t swig_types[196] -#define SWIGTYPE_p_uint32_t swig_types[197] -#define SWIGTYPE_p_uint8_t swig_types[198] -#define SWIGTYPE_p_unsigned_char swig_types[199] -#define SWIGTYPE_p_unsigned_int swig_types[200] -#define SWIGTYPE_p_unsigned_long swig_types[201] -#define SWIGTYPE_p_unsigned_long_long swig_types[202] -#define SWIGTYPE_p_unsigned_short swig_types[203] -#define SWIGTYPE_p_va_list swig_types[204] -#define SWIGTYPE_p_void swig_types[205] -static swig_type_info *swig_types[207]; -static swig_module_info swig_module = {swig_types, 206, 0, 0, 0, 0}; +#define SWIGTYPE_p_ofBaseSoundStream swig_types[44] +#define SWIGTYPE_p_ofBaseUpdates swig_types[45] +#define SWIGTYPE_p_ofBaseVideo swig_types[46] +#define SWIGTYPE_p_ofBaseVideoDraws swig_types[47] +#define SWIGTYPE_p_ofBaseVideoGrabber swig_types[48] +#define SWIGTYPE_p_ofBaseVideoPlayer swig_types[49] +#define SWIGTYPE_p_ofBoxPrimitive swig_types[50] +#define SWIGTYPE_p_ofBuffer swig_types[51] +#define SWIGTYPE_p_ofBufferObject swig_types[52] +#define SWIGTYPE_p_ofCamera swig_types[53] +#define SWIGTYPE_p_ofColor_T_float_t swig_types[54] +#define SWIGTYPE_p_ofColor_T_unsigned_char_t swig_types[55] +#define SWIGTYPE_p_ofColor_T_unsigned_short_t swig_types[56] +#define SWIGTYPE_p_ofConePrimitive swig_types[57] +#define SWIGTYPE_p_ofConsoleLoggerChannel swig_types[58] +#define SWIGTYPE_p_ofCoreEvents swig_types[59] +#define SWIGTYPE_p_ofCylinderPrimitive swig_types[60] +#define SWIGTYPE_p_ofDirectory swig_types[61] +#define SWIGTYPE_p_ofDragInfo swig_types[62] +#define SWIGTYPE_p_ofEasyCam swig_types[63] +#define SWIGTYPE_p_ofEventArgs swig_types[64] +#define SWIGTYPE_p_ofEventT_Firmata_I2C_Data_const_t swig_types[65] +#define SWIGTYPE_p_ofEventT_Firmata_Serial_Data_const_t swig_types[66] +#define SWIGTYPE_p_ofEventT_Firmata_Stepper_Data_const_t swig_types[67] +#define SWIGTYPE_p_ofEventT_int_const_t swig_types[68] +#define SWIGTYPE_p_ofEventT_std__pairT_int_Firmata_Pin_Modes_t_const_t swig_types[69] +#define SWIGTYPE_p_ofEventT_std__string_const_t swig_types[70] +#define SWIGTYPE_p_ofEventT_std__vectorT_Firmata_Encoder_Data_t_const_t swig_types[71] +#define SWIGTYPE_p_ofEventT_std__vectorT_unsigned_char_t_const_t swig_types[72] +#define SWIGTYPE_p_ofFbo swig_types[73] +#define SWIGTYPE_p_ofFile swig_types[74] +#define SWIGTYPE_p_ofFileDialogResult swig_types[75] +#define SWIGTYPE_p_ofFileLoggerChannel swig_types[76] +#define SWIGTYPE_p_ofFilePath swig_types[77] +#define SWIGTYPE_p_ofFpsCounter swig_types[78] +#define SWIGTYPE_p_ofHttpRequest swig_types[79] +#define SWIGTYPE_p_ofHttpResponse swig_types[80] +#define SWIGTYPE_p_ofIcoSpherePrimitive swig_types[81] +#define SWIGTYPE_p_ofImageLoadSettings swig_types[82] +#define SWIGTYPE_p_ofImage_T_float_t swig_types[83] +#define SWIGTYPE_p_ofImage_T_unsigned_char_t swig_types[84] +#define SWIGTYPE_p_ofImage_T_unsigned_short_t swig_types[85] +#define SWIGTYPE_p_ofKeyEventArgs swig_types[86] +#define SWIGTYPE_p_ofLight swig_types[87] +#define SWIGTYPE_p_ofLog swig_types[88] +#define SWIGTYPE_p_ofLogError swig_types[89] +#define SWIGTYPE_p_ofLogFatalError swig_types[90] +#define SWIGTYPE_p_ofLogNotice swig_types[91] +#define SWIGTYPE_p_ofLogVerbose swig_types[92] +#define SWIGTYPE_p_ofLogWarning swig_types[93] +#define SWIGTYPE_p_ofMaterial swig_types[94] +#define SWIGTYPE_p_ofMaterialSettings swig_types[95] +#define SWIGTYPE_p_ofMatrix3x3 swig_types[96] +#define SWIGTYPE_p_ofMatrix4x4 swig_types[97] +#define SWIGTYPE_p_ofMatrixStack swig_types[98] +#define SWIGTYPE_p_ofMeshFace_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t swig_types[99] +#define SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t swig_types[100] +#define SWIGTYPE_p_ofMessage swig_types[101] +#define SWIGTYPE_p_ofMouseEventArgs swig_types[102] +#define SWIGTYPE_p_ofNode swig_types[103] +#define SWIGTYPE_p_ofParameterGroup swig_types[104] +#define SWIGTYPE_p_ofPath swig_types[105] +#define SWIGTYPE_p_ofPixels_T_float_t swig_types[106] +#define SWIGTYPE_p_ofPixels_T_unsigned_char_t swig_types[107] +#define SWIGTYPE_p_ofPixels_T_unsigned_short_t swig_types[108] +#define SWIGTYPE_p_ofPlanePrimitive swig_types[109] +#define SWIGTYPE_p_ofPolyline_T_glm__vec3_t swig_types[110] +#define SWIGTYPE_p_ofQuaternion swig_types[111] +#define SWIGTYPE_p_ofRectangle swig_types[112] +#define SWIGTYPE_p_ofResizeEventArgs swig_types[113] +#define SWIGTYPE_p_ofSerial swig_types[114] +#define SWIGTYPE_p_ofSerialDeviceInfo swig_types[115] +#define SWIGTYPE_p_ofShader swig_types[116] +#define SWIGTYPE_p_ofShaderSettings swig_types[117] +#define SWIGTYPE_p_ofShader__TransformFeedbackSettings swig_types[118] +#define SWIGTYPE_p_ofSoundDevice swig_types[119] +#define SWIGTYPE_p_ofSoundPlayer swig_types[120] +#define SWIGTYPE_p_ofSoundStream swig_types[121] +#define SWIGTYPE_p_ofSoundStreamSettings swig_types[122] +#define SWIGTYPE_p_ofSpherePrimitive swig_types[123] +#define SWIGTYPE_p_ofStyle swig_types[124] +#define SWIGTYPE_p_ofTexture swig_types[125] +#define SWIGTYPE_p_ofTextureData swig_types[126] +#define SWIGTYPE_p_ofTime swig_types[127] +#define SWIGTYPE_p_ofTouchEventArgs swig_types[128] +#define SWIGTYPE_p_ofTrueTypeFont swig_types[129] +#define SWIGTYPE_p_ofTrueTypeFontSettings swig_types[130] +#define SWIGTYPE_p_ofURLFileLoader swig_types[131] +#define SWIGTYPE_p_ofUnicode swig_types[132] +#define SWIGTYPE_p_ofUnicode__range swig_types[133] +#define SWIGTYPE_p_ofVbo swig_types[134] +#define SWIGTYPE_p_ofVboMesh swig_types[135] +#define SWIGTYPE_p_ofVec2f swig_types[136] +#define SWIGTYPE_p_ofVec3f swig_types[137] +#define SWIGTYPE_p_ofVec4f swig_types[138] +#define SWIGTYPE_p_ofVideoDevice swig_types[139] +#define SWIGTYPE_p_ofVideoFormat swig_types[140] +#define SWIGTYPE_p_ofVideoGrabber swig_types[141] +#define SWIGTYPE_p_ofVideoPlayer swig_types[142] +#define SWIGTYPE_p_ofWindowPosEventArgs swig_types[143] +#define SWIGTYPE_p_ofXml swig_types[144] +#define SWIGTYPE_p_ofXmlAttributeIterator swig_types[145] +#define SWIGTYPE_p_ofXml__Attribute swig_types[146] +#define SWIGTYPE_p_ofXml__RangeT_ofXmlAttributeIterator_t swig_types[147] +#define SWIGTYPE_p_ofXml__RangeT_ofXmlIteratorT_pugi__xml_named_node_iterator_t_t swig_types[148] +#define SWIGTYPE_p_ofXml__RangeT_ofXmlIteratorT_pugi__xml_node_iterator_t_t swig_types[149] +#define SWIGTYPE_p_size_type swig_types[150] +#define SWIGTYPE_p_std__chrono__nanoseconds swig_types[151] +#define SWIGTYPE_p_std__chrono__time_pointT_std__chrono__nanoseconds_t swig_types[152] +#define SWIGTYPE_p_std__fstream swig_types[153] +#define SWIGTYPE_p_std__functionT_void_fofHttpResponse_const_RF_t swig_types[154] +#define SWIGTYPE_p_std__functionT_void_fofSoundBuffer_RF_t swig_types[155] +#define SWIGTYPE_p_std__istream swig_types[156] +#define SWIGTYPE_p_std__mapT_int_supportedPinTypes_std__lessT_int_t_t swig_types[157] +#define SWIGTYPE_p_std__mapT_std__string_std__string_std__lessT_std__string_t_t swig_types[158] +#define SWIGTYPE_p_std__shared_ptrT_ofBaseLoggerChannel_t swig_types[159] +#define SWIGTYPE_p_std__shared_ptrT_ofBaseRenderer_t swig_types[160] +#define SWIGTYPE_p_std__shared_ptrT_ofBaseSoundPlayer_t swig_types[161] +#define SWIGTYPE_p_std__shared_ptrT_ofBaseSoundStream_t swig_types[162] +#define SWIGTYPE_p_std__shared_ptrT_ofBaseVideoGrabber_t swig_types[163] +#define SWIGTYPE_p_std__shared_ptrT_ofBaseVideoPlayer_t swig_types[164] +#define SWIGTYPE_p_std__string swig_types[165] +#define SWIGTYPE_p_std__vectorT_float_t swig_types[166] +#define SWIGTYPE_p_std__vectorT_glm__vec2_t swig_types[167] +#define SWIGTYPE_p_std__vectorT_glm__vec3_t swig_types[168] +#define SWIGTYPE_p_std__vectorT_int_t swig_types[169] +#define SWIGTYPE_p_std__vectorT_ofColor_T_float_t_t swig_types[170] +#define SWIGTYPE_p_std__vectorT_ofFile_t swig_types[171] +#define SWIGTYPE_p_std__vectorT_ofMeshFace_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t_t swig_types[172] +#define SWIGTYPE_p_std__vectorT_ofPath__Command_t swig_types[173] +#define SWIGTYPE_p_std__vectorT_ofPath_t swig_types[174] +#define SWIGTYPE_p_std__vectorT_ofPolyline_T_ofDefaultVertexType_t_t swig_types[175] +#define SWIGTYPE_p_std__vectorT_ofSerialDeviceInfo_t swig_types[176] +#define SWIGTYPE_p_std__vectorT_ofSoundDevice_t swig_types[177] +#define SWIGTYPE_p_std__vectorT_ofTexture_t swig_types[178] +#define SWIGTYPE_p_std__vectorT_ofUnicode__range_t swig_types[179] +#define SWIGTYPE_p_std__vectorT_ofVec2f_t swig_types[180] +#define SWIGTYPE_p_std__vectorT_ofVec3f_t swig_types[181] +#define SWIGTYPE_p_std__vectorT_ofVideoDevice_t swig_types[182] +#define SWIGTYPE_p_std__vectorT_ofVideoFormat_t swig_types[183] +#define SWIGTYPE_p_std__vectorT_std__string_t swig_types[184] +#define SWIGTYPE_p_std__vectorT_unsigned_char_t swig_types[185] +#define SWIGTYPE_p_std__vectorT_unsigned_int_t swig_types[186] +#define SWIGTYPE_p_supportedPinTypes swig_types[187] +#define SWIGTYPE_p_timespec swig_types[188] +#define SWIGTYPE_p_uint16_t swig_types[189] +#define SWIGTYPE_p_uint32_t swig_types[190] +#define SWIGTYPE_p_uint8_t swig_types[191] +#define SWIGTYPE_p_unsigned_char swig_types[192] +#define SWIGTYPE_p_unsigned_int swig_types[193] +#define SWIGTYPE_p_unsigned_long swig_types[194] +#define SWIGTYPE_p_unsigned_long_long swig_types[195] +#define SWIGTYPE_p_unsigned_short swig_types[196] +#define SWIGTYPE_p_value_type swig_types[197] +#define SWIGTYPE_p_void swig_types[198] +static swig_type_info *swig_types[200]; +static swig_module_info swig_module = {swig_types, 199, 0, 0, 0, 0}; #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) @@ -3181,51 +3191,144 @@ SWIGINTERN void std_vector_Sl_ofTexture_Sg____setitem__(std::vector< ofTexture > throw std::out_of_range("in vector::__setitem__()"); (*self)[idx]=val; } +SWIGINTERN ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > std_vector_Sl_ofMeshFace__Sl_ofDefaultVertexType_Sc_ofDefaultNormalType_Sc_ofDefaultColorType_Sc_ofDefaultTexCoordType_Sg__Sg____getitem__(std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > > *self,unsigned int idx){ + if (idx>=self->size()) + throw std::out_of_range("in vector::__getitem__()"); + return (*self)[idx]; + } +SWIGINTERN void std_vector_Sl_ofMeshFace__Sl_ofDefaultVertexType_Sc_ofDefaultNormalType_Sc_ofDefaultColorType_Sc_ofDefaultTexCoordType_Sg__Sg____setitem__(std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > > *self,unsigned int idx,ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > val){ + if (idx>=self->size()) + throw std::out_of_range("in vector::__setitem__()"); + (*self)[idx]=val; + } +SWIGINTERN glm::mat3 ofMatrix3x3_mat3(ofMatrix3x3 *self){ + return (*self); + } SWIGINTERN char const *ofMatrix3x3___str__(ofMatrix3x3 *self){ - stringstream str; + ostringstream str; str << (*self); return str.str().c_str(); } +SWIGINTERN glm::mat4 ofMatrix4x4_mat4(ofMatrix4x4 *self){ + return (*self); + } SWIGINTERN char const *ofMatrix4x4___str__(ofMatrix4x4 *self){ - stringstream str; + ostringstream str; str << (*self); return str.str().c_str(); } +SWIGINTERN glm::quat ofQuaternion_quat(ofQuaternion *self){ + return (*self); + } SWIGINTERN char const *ofQuaternion___str__(ofQuaternion *self){ - stringstream str; + ostringstream str; str << (*self); return str.str().c_str(); } +SWIGINTERN glm::vec2 ofVec2f_vec2(ofVec2f *self){ + return (*self); + } SWIGINTERN char const *ofVec2f___str__(ofVec2f *self){ - stringstream str; + ostringstream str; str << (*self); return str.str().c_str(); } +SWIGINTERN glm::vec3 ofVec3f_vec3(ofVec3f *self){ + return (*self); + } SWIGINTERN char const *ofVec3f___str__(ofVec3f *self){ - stringstream str; + ostringstream str; str << (*self); return str.str().c_str(); } +SWIGINTERN glm::vec4 ofVec4f_vec4(ofVec4f *self){ + return (*self); + } SWIGINTERN char const *ofVec4f___str__(ofVec4f *self){ - stringstream str; + ostringstream str; str << (*self); return str.str().c_str(); } -SWIGINTERN void delete_ofShader(ofShader *self){ - self->end(); - delete self; +SWIGINTERN char const *ofTouchEventArgs___str__(ofTouchEventArgs *self){ + stringstream str; + str << (*self); + return str.str().c_str(); } -SWIGINTERN ofPolyline std_vector_Sl_ofPolyline_Sg____getitem__(std::vector< ofPolyline > *self,unsigned int idx){ + +#define ofTouchEventArgs_x_get(self_) self_->x +#define ofTouchEventArgs_x_set(self_, val_) self_->x = val_ + + +#define ofTouchEventArgs_y_get(self_) self_->y +#define ofTouchEventArgs_y_set(self_, val_) self_->y = val_ + +SWIGINTERN ofPolyline_< glm::vec3 > std_vector_Sl_ofPolyline_Sg____getitem__(std::vector< ofPolyline > *self,unsigned int idx){ + if (idx>=self->size()) + throw std::out_of_range("in vector::__getitem__()"); + return (*self)[idx]; + } +SWIGINTERN void std_vector_Sl_ofPolyline_Sg____setitem__(std::vector< ofPolyline > *self,unsigned int idx,ofPolyline_< glm::vec3 > val){ + if (idx>=self->size()) + throw std::out_of_range("in vector::__setitem__()"); + (*self)[idx]=val; + } +SWIGINTERN glm::vec3 std_vector_Sl_ofDefaultVertexType_Sg____getitem__(std::vector< ofDefaultVertexType > *self,unsigned int idx){ if (idx>=self->size()) throw std::out_of_range("in vector::__getitem__()"); return (*self)[idx]; } -SWIGINTERN void std_vector_Sl_ofPolyline_Sg____setitem__(std::vector< ofPolyline > *self,unsigned int idx,ofPolyline val){ +SWIGINTERN void std_vector_Sl_ofDefaultVertexType_Sg____setitem__(std::vector< ofDefaultVertexType > *self,unsigned int idx,glm::vec3 val){ if (idx>=self->size()) throw std::out_of_range("in vector::__setitem__()"); (*self)[idx]=val; } + enum ofAlphabetEnum : int { + ofAlphabet_Emoji, + ofAlphabet_Japanese, + ofAlphabet_Chinese, + ofAlphabet_Korean, + ofAlphabet_Arabic, + ofAlphabet_Devanagari, + ofAlphabet_Latin, + ofAlphabet_Greek, + ofAlphabet_Cyrillic + }; + +SWIGINTERN void ofTrueTypeFontSettings_addRanges(ofTrueTypeFontSettings *self,ofAlphabetEnum alphabet){ + switch(alphabet) { + case ofAlphabet_Emoji: + self->addRanges(ofAlphabet::Emoji); + break; + case ofAlphabet_Japanese: + self->addRanges(ofAlphabet::Japanese); + break; + case ofAlphabet_Chinese: + self->addRanges(ofAlphabet::Chinese); + break; + case ofAlphabet_Korean: + self->addRanges(ofAlphabet::Korean); + break; + case ofAlphabet_Arabic: + self->addRanges(ofAlphabet::Arabic); + break; + case ofAlphabet_Devanagari: + self->addRanges(ofAlphabet::Devanagari); + break; + case ofAlphabet_Latin: + self->addRanges(ofAlphabet::Latin); + break; + case ofAlphabet_Greek: + self->addRanges(ofAlphabet::Greek); + break; + case ofAlphabet_Cyrillic: + self->addRanges(ofAlphabet::Cyrillic); + break; + default: + break; + } + } + #define ofColor__Sl_unsigned_SS_char_Sg__r_get(self_) self_->r #define ofColor__Sl_unsigned_SS_char_Sg__r_set(self_, val_) self_->r = val_ @@ -3326,319 +3429,10 @@ SWIGINTERN char const *ofRectangle___str__(ofRectangle *self){ #define ofRectangle_y_set(self_, val_) self_->setY(val_) - void log(ofLogLevel level, const string & message) { + void log(ofLogLevel level, const std::string & message) { ofLog(level, message); } - -#define ofFbo_allocated_get(self_) self_->isAllocated() - - -#define ofFbo_defaultTexture_get(self_) self_->getDefaultTextureIndex() -#define ofFbo_defaultTexture_set(self_, val_) self_->setDefaultTextureIndex(val_) - - -#define ofFbo_texture_get(self_) self_->getTexture() - - -#define ofFbo_depthTexture_get(self_) self_->getDepthTexture() - - -#define ofFbo_width_get(self_) self_->getWidth() - - -#define ofFbo_height_get(self_) self_->getHeight() - - -#define ofFbo_numTextures_get(self_) self_->getNumTextures() - - -#define ofFbo_id_get(self_) self_->getId() - - -#define ofFbo_idDrawBuffer_get(self_) self_->getIdDrawBuffer() - - -#define ofFbo_depthBuffer_get(self_) self_->getDepthBuffer() - - -#define ofFbo_stencilBuffer_get(self_) self_->getStencilBuffer() - - -#define ofTexture_allocated_get(self_) self_->isAllocated() - - -#define ofTexture_width_get(self_) self_->getWidth() - - -#define ofTexture_height_get(self_) self_->getHeight() - - -#define ofTexture_textureMatrix_get(self_) self_->getTextureMatrix() -#define ofTexture_textureMatrix_set(self_, val_) self_->setTextureMatrix(val_) - - -#define ofTexture_usingTextureMatrix_get(self_) self_->isUsingTextureMatrix() - - -#define ofTexture_textureData_get(self_) self_->getTextureData() - - -#define ofImage__Sl_unsigned_SS_char_Sg__allocated_get(self_) self_->isAllocated() - - -#define ofImage__Sl_unsigned_SS_char_Sg__usingTexture_get(self_) self_->isUsingTexture() -#define ofImage__Sl_unsigned_SS_char_Sg__usingTexture_set(self_, val_) self_->setUseTexture(val_) - - -#define ofImage__Sl_unsigned_SS_char_Sg__texture_get(self_) self_->getTexture() - - -#define ofImage__Sl_unsigned_SS_char_Sg__pixels_get(self_) self_->getPixels() - - -#define ofImage__Sl_unsigned_SS_char_Sg__width_get(self_) self_->getWidth() - - -#define ofImage__Sl_unsigned_SS_char_Sg__height_get(self_) self_->getHeight() - - -#define ofImage__Sl_unsigned_SS_char_Sg__imageType_get(self_) self_->getImageType() -#define ofImage__Sl_unsigned_SS_char_Sg__imageType_set(self_, val_) self_->setImageType(val_) - - -#define ofImage__Sl_float_Sg__allocated_get(self_) self_->isAllocated() - - -#define ofImage__Sl_float_Sg__usingTexture_get(self_) self_->isUsingTexture() -#define ofImage__Sl_float_Sg__usingTexture_set(self_, val_) self_->setUseTexture(val_) - - -#define ofImage__Sl_float_Sg__texture_get(self_) self_->getTexture() - - -#define ofImage__Sl_float_Sg__pixels_get(self_) self_->getPixels() - - -#define ofImage__Sl_float_Sg__width_get(self_) self_->getWidth() - - -#define ofImage__Sl_float_Sg__height_get(self_) self_->getHeight() - - -#define ofImage__Sl_float_Sg__imageType_get(self_) self_->getImageType() -#define ofImage__Sl_float_Sg__imageType_set(self_, val_) self_->setImageType(val_) - - -#define ofImage__Sl_unsigned_SS_short_Sg__allocated_get(self_) self_->isAllocated() - - -#define ofImage__Sl_unsigned_SS_short_Sg__usingTexture_get(self_) self_->isUsingTexture() -#define ofImage__Sl_unsigned_SS_short_Sg__usingTexture_set(self_, val_) self_->setUseTexture(val_) - - -#define ofImage__Sl_unsigned_SS_short_Sg__texture_get(self_) self_->getTexture() - - -#define ofImage__Sl_unsigned_SS_short_Sg__pixels_get(self_) self_->getPixels() - - -#define ofImage__Sl_unsigned_SS_short_Sg__width_get(self_) self_->getWidth() - - -#define ofImage__Sl_unsigned_SS_short_Sg__height_get(self_) self_->getHeight() - - -#define ofImage__Sl_unsigned_SS_short_Sg__imageType_get(self_) self_->getImageType() -#define ofImage__Sl_unsigned_SS_short_Sg__imageType_set(self_, val_) self_->setImageType(val_) - - -#define ofSoundStream_tickCount_get(self_) self_->getTickCount() - - -#define ofSoundStream_numInputChannels_get(self_) self_->getNumInputChannels() - - -#define ofSoundStream_numOutputChannels_get(self_) self_->getNumOutputChannels() - - -#define ofSoundStream_sampleRate_get(self_) self_->getSampleRate() - - -#define ofSoundStream_bufferSize_get(self_) self_->getBufferSize() - - -#define ofSoundPlayer_volume_get(self_) self_->getVolume() -#define ofSoundPlayer_volume_set(self_, val_) self_->setVolume(val_) - - -#define ofSoundPlayer_pan_get(self_) self_->getPan() -#define ofSoundPlayer_pan_set(self_, val_) self_->setPan(val_) - - -#define ofSoundPlayer_speed_get(self_) self_->getSpeed() -#define ofSoundPlayer_speed_set(self_, val_) self_->setSpeed(val_) - - -#define ofSoundPlayer_position_get(self_) self_->getPosition() -#define ofSoundPlayer_position_set(self_, val_) self_->setPosition(val_) - - -#define ofSoundPlayer_positionMS_get(self_) self_->getPositionMS() -#define ofSoundPlayer_positionMS_set(self_, val_) self_->setPositionMS(val_) - - -#define ofSoundPlayer_playing_get(self_) self_->isPlaying() - - -#define ofSoundPlayer_loaded_get(self_) self_->isLoaded() - - -#define ofFpsCounter_fps_get(self_) self_->getFps() - - -#define ofFpsCounter_numFrames_get(self_) self_->getNumFrames() - - -#define ofFpsCounter_lastFrameNanos_get(self_) self_->getLastFrameNanos() - - -#define ofFpsCounter_lastFrameSecs_get(self_) self_->getLastFrameSecs() - - -#define ofBufferObject_allocated_get(self_) self_->isAllocated() - - -#define ofBufferObject_id_get(self_) self_->getId() - - -#define ofPixels__Sl_unsigned_SS_char_Sg__width_get(self_) self_->getWidth() - - -#define ofPixels__Sl_unsigned_SS_char_Sg__height_get(self_) self_->getHeight() - - -#define ofPixels__Sl_float_Sg__width_get(self_) self_->getWidth() - - -#define ofPixels__Sl_float_Sg__height_get(self_) self_->getHeight() - - -#define ofPixels__Sl_unsigned_SS_short_Sg__width_get(self_) self_->getWidth() - - -#define ofPixels__Sl_unsigned_SS_short_Sg__height_get(self_) self_->getHeight() - - -#define ofTrueTypeFont_lineHeight_get(self_) self_->getLineHeight() -#define ofTrueTypeFont_lineHeight_set(self_, val_) self_->setLineHeight(val_) - - -#define ofTrueTypeFont_letterSpacing_get(self_) self_->getLetterSpacing() -#define ofTrueTypeFont_letterSpacing_set(self_, val_) self_->setLetterSpacing(val_) - - -#define ofTrueTypeFont_spaceSize_get(self_) self_->getSpaceSize() -#define ofTrueTypeFont_spaceSize_set(self_, val_) self_->setSpaceSize(val_) - - -#define ofBuffer_length_get(self_) self_->size() - - -#define ofBuffer_data_get(self_) self_->getData() - - -#define ofBuffer_text_get(self_) *new string(self_->getText()) - - -#define ofVideoGrabber_frameNew_get(self_) self_->isFrameNew() - - -#define ofVideoGrabber_pixelFormat_get(self_) self_->getPixelFormat() - - -#define ofVideoGrabber_pixels_get(self_) self_->getPixels() - - -#define ofVideoGrabber_texture_get(self_) self_->getTexture() - - -#define ofVideoGrabber_usingTexture_get(self_) self_->isUsingTexture() -#define ofVideoGrabber_usingTexture_set(self_, val_) self_->setUseTexture(val_) - - -#define ofVideoGrabber_width_get(self_) self_->getWidth() - - -#define ofVideoGrabber_height_get(self_) self_->getHeight() - - -#define ofVideoGrabber_initialized_get(self_) self_->isInitialized() - - -#define ofVideoPlayer_moviePath_get(self_) *new string(self_->getMoviePath()) - - -#define ofVideoPlayer_pixelFormat_get(self_) self_->getPixelFormat() -#define ofVideoPlayer_pixelFormat_set(self_, val_) self_->setPixelFormat(val_) - - -#define ofVideoPlayer_frameNew_get(self_) self_->isFrameNew() - - -#define ofVideoPlayer_pixels_get(self_) self_->getPixels() - - -#define ofVideoPlayer_position_get(self_) self_->getPosition() -#define ofVideoPlayer_position_set(self_, val_) self_->setPosition(val_) - - -#define ofVideoPlayer_speed_get(self_) self_->getSpeed() -#define ofVideoPlayer_speed_set(self_, val_) self_->setSpeed(val_) - - -#define ofVideoPlayer_duration_get(self_) self_->getDuration() - - -#define ofVideoPlayer_loopState_get(self_) self_->getLoopState() -#define ofVideoPlayer_loopState_set(self_, val_) self_->setLoopState(val_) - - -#define ofVideoPlayer_movieDone_get(self_) self_->getIsMovieDone() - - -#define ofVideoPlayer_usingTexture_get(self_) self_->isUsingTexture() -#define ofVideoPlayer_usingTexture_set(self_, val_) self_->setUseTexture(val_) - - -#define ofVideoPlayer_texture_get(self_) self_->getTexture() - - -#define ofVideoPlayer_frame_get(self_) self_->getCurrentFrame() -#define ofVideoPlayer_frame_set(self_, val_) self_->setFrame(val_) - - -#define ofVideoPlayer_numFrames_get(self_) self_->getTotalNumFrames() - - -#define ofVideoPlayer_width_get(self_) self_->getWidth() - - -#define ofVideoPlayer_height_get(self_) self_->getHeight() - - -#define ofVideoPlayer_paused_get(self_) self_->isPaused() -#define ofVideoPlayer_paused_set(self_, val_) self_->setPaused(val_) - - -#define ofVideoPlayer_loaded_get(self_) self_->isLoaded() - - -#define ofVideoPlayer_playing_get(self_) self_->isPlaying() - - -#define ofVideoPlayer_initialized_get(self_) self_->isInitialized() - #ifdef __cplusplus extern "C" { #endif @@ -3653,10 +3447,9 @@ static int _wrap_new_string__SWIG_1(lua_State* L) { int SWIG_arg = 0; char *arg1 SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__string,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_new_string(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_string__SWIG_0(L);} if (argc == 1) { int _v; { _v = SWIG_lua_isnilstring(L,argv[0]); } if (_v) { - return _wrap_new_string__SWIG_1(L);} } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_string'\n" - " Possible C/C++ prototypes are:\n" " std::string::string()\n" " std::string::string(char const *)\n"); - lua_error(L);return 0; } + return _wrap_new_string__SWIG_0(L);} if (argc == 1) { return _wrap_new_string__SWIG_1(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_string'\n" " Possible C/C++ prototypes are:\n" + " std::string::string()\n" " std::string::string(char const *)\n"); lua_error(L);return 0; } static int _wrap_string_size(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = (std::string *) 0 ; unsigned int result; SWIG_check_num_args("std::string::size",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::string::size",1,"std::string const *"); @@ -3758,10 +3551,9 @@ static int _wrap_new_path__SWIG_1(lua_State* L) { int SWIG_arg = 0; char *arg1 = SWIG_NewPointerObj(L,result,SWIGTYPE_p_boost__filesystem__path,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_new_path(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_path__SWIG_0(L);} if (argc == 1) { int _v; { _v = SWIG_lua_isnilstring(L,argv[0]); } if (_v) { - return _wrap_new_path__SWIG_1(L);} } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_path'\n" - " Possible C/C++ prototypes are:\n" " std::filesystem::path::path()\n" " std::filesystem::path::path(char const *)\n"); - lua_error(L);return 0; } + return _wrap_new_path__SWIG_0(L);} if (argc == 1) { return _wrap_new_path__SWIG_1(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_path'\n" " Possible C/C++ prototypes are:\n" + " std::filesystem::path::path()\n" " std::filesystem::path::path(char const *)\n"); lua_error(L);return 0; } static int _wrap_path_string(lua_State* L) { int SWIG_arg = 0; std::filesystem::path *arg1 = (std::filesystem::path *) 0 ; std::string result; SWIG_check_num_args("std::filesystem::path::string",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::filesystem::path::string",1,"std::filesystem::path const *"); @@ -3845,12 +3637,10 @@ static int _wrap_new_IntVector__SWIG_3(lua_State* L) { int SWIG_arg = 0; unsigne SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_int_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_new_IntVector(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_IntVector__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_std__vectorT_int_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_new_IntVector__SWIG_2(L);} } if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_new_IntVector__SWIG_1(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_new_IntVector__SWIG_3(L);} } } + return _wrap_new_IntVector__SWIG_0(L);} if (argc == 1) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_std__vectorT_int_t, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_new_IntVector__SWIG_2(L);} check_2: + if (argc == 1) { return _wrap_new_IntVector__SWIG_1(L);} if (argc == 2) { return _wrap_new_IntVector__SWIG_3(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_IntVector'\n" " Possible C/C++ prototypes are:\n" " std::vector< int >::vector()\n" " std::vector< int >::vector(unsigned int)\n" " std::vector< int >::vector(std::vector< int > const &)\n" " std::vector< int >::vector(unsigned int,int)\n"); @@ -4016,12 +3806,10 @@ static int _wrap_new_FloatVector__SWIG_3(lua_State* L) { int SWIG_arg = 0; unsig SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_float_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_new_FloatVector(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_FloatVector__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_std__vectorT_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_new_FloatVector__SWIG_2(L);} } if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_new_FloatVector__SWIG_1(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_new_FloatVector__SWIG_3(L);} } } + return _wrap_new_FloatVector__SWIG_0(L);} if (argc == 1) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_std__vectorT_float_t, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_new_FloatVector__SWIG_2(L);} check_2: + if (argc == 1) { return _wrap_new_FloatVector__SWIG_1(L);} if (argc == 2) { return _wrap_new_FloatVector__SWIG_3(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_FloatVector'\n" " Possible C/C++ prototypes are:\n" " std::vector< float >::vector()\n" " std::vector< float >::vector(unsigned int)\n" " std::vector< float >::vector(std::vector< float > const &)\n" " std::vector< float >::vector(unsigned int,float)\n"); @@ -4193,12 +3981,10 @@ static int _wrap_new_StringVector__SWIG_3(lua_State* L) { int SWIG_arg = 0; unsi SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_std__string_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_new_StringVector(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_StringVector__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_std__vectorT_std__string_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_new_StringVector__SWIG_2(L);} } if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_new_StringVector__SWIG_1(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { - return _wrap_new_StringVector__SWIG_3(L);} } } + return _wrap_new_StringVector__SWIG_0(L);} if (argc == 1) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_std__vectorT_std__string_t, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_new_StringVector__SWIG_2(L);} check_2: + if (argc == 1) { return _wrap_new_StringVector__SWIG_1(L);} if (argc == 2) { return _wrap_new_StringVector__SWIG_3(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_StringVector'\n" " Possible C/C++ prototypes are:\n" " std::vector< std::string >::vector()\n" " std::vector< std::string >::vector(unsigned int)\n" " std::vector< std::string >::vector(std::vector< std::string > const &)\n" @@ -4288,8 +4074,8 @@ static int _wrap_StringVector___setitem(lua_State* L) { int SWIG_arg = 0; if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_std__string_t,0))){ SWIG_fail_ptr("StringVector___setitem",1,SWIGTYPE_p_std__vectorT_std__string_t); } SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned int)lua_tonumber(L, 2); - (&arg3)->assign(lua_tostring(L,3),lua_rawlen(L,3)); try { std_vector_Sl_std_string_Sg____setitem__(arg1,arg2,arg3);} - catch(std::out_of_range &_e) { SWIG_exception(SWIG_IndexError, (&_e)->what()); } return SWIG_arg; if(0) SWIG_fail; fail: + (&arg3)->assign(lua_tostring(L,3),lua_rawlen(L,3)); try { std_vector_Sl_std_string_Sg____setitem__(arg1,arg2,arg3);} + catch(std::out_of_range &_e) { SWIG_exception(SWIG_IndexError, (&_e)->what()); } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static void swig_delete_StringVector(void *obj) { std::vector< std::string > *arg1 = (std::vector< std::string > *) obj; @@ -4380,12 +4166,10 @@ static int _wrap_new_UCharVector__SWIG_3(lua_State* L) { int SWIG_arg = 0; unsig SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_unsigned_char_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_new_UCharVector(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_UCharVector__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_std__vectorT_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_new_UCharVector__SWIG_2(L);} } if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_new_UCharVector__SWIG_1(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_new_UCharVector__SWIG_3(L);} } } + return _wrap_new_UCharVector__SWIG_0(L);} if (argc == 1) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_std__vectorT_unsigned_char_t, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_new_UCharVector__SWIG_2(L);} check_2: + if (argc == 1) { return _wrap_new_UCharVector__SWIG_1(L);} if (argc == 2) { return _wrap_new_UCharVector__SWIG_3(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_UCharVector'\n" " Possible C/C++ prototypes are:\n" " std::vector< unsigned char >::vector()\n" " std::vector< unsigned char >::vector(unsigned int)\n" " std::vector< unsigned char >::vector(std::vector< unsigned char > const &)\n" @@ -4567,13 +4351,11 @@ static int _wrap_new_VideoDeviceVector__SWIG_3(lua_State* L) { int SWIG_arg = 0; SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofVideoDevice_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_new_VideoDeviceVector(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_VideoDeviceVector__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_std__vectorT_ofVideoDevice_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_new_VideoDeviceVector__SWIG_2(L);} } if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_new_VideoDeviceVector__SWIG_1(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVideoDevice, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_new_VideoDeviceVector__SWIG_3(L);} } } + return _wrap_new_VideoDeviceVector__SWIG_0(L);} if (argc == 1) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_std__vectorT_ofVideoDevice_t, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_new_VideoDeviceVector__SWIG_2(L);} check_2: + if (argc == 1) { return _wrap_new_VideoDeviceVector__SWIG_1(L);} if (argc == 2) { + return _wrap_new_VideoDeviceVector__SWIG_3(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_VideoDeviceVector'\n" " Possible C/C++ prototypes are:\n" " std::vector< ofVideoDevice >::vector()\n" " std::vector< ofVideoDevice >::vector(unsigned int)\n" @@ -4763,13 +4545,10 @@ static int _wrap_new_TextureVector__SWIG_3(lua_State* L) { int SWIG_arg = 0; uns SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofTexture_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_new_TextureVector(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_TextureVector__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_std__vectorT_ofTexture_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_new_TextureVector__SWIG_2(L);} } if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_new_TextureVector__SWIG_1(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_new_TextureVector__SWIG_3(L);} } } + return _wrap_new_TextureVector__SWIG_0(L);} if (argc == 1) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_std__vectorT_ofTexture_t, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_new_TextureVector__SWIG_2(L);} check_2: + if (argc == 1) { return _wrap_new_TextureVector__SWIG_1(L);} if (argc == 2) { return _wrap_new_TextureVector__SWIG_3(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_TextureVector'\n" " Possible C/C++ prototypes are:\n" " std::vector< ofTexture >::vector()\n" " std::vector< ofTexture >::vector(unsigned int)\n" " std::vector< ofTexture >::vector(std::vector< ofTexture > const &)\n" @@ -4925,293 +4704,867 @@ static swig_lua_class *swig_TextureVector_bases[] = {0}; static const char *swig_TextureVector_base_names[] = {0}; static swig_lua_class _wrap_class_TextureVector = { "TextureVector", "TextureVector", &SWIGTYPE_p_std__vectorT_ofTexture_t,_proxy__wrap_new_TextureVector, swig_delete_TextureVector, swig_TextureVector_methods, swig_TextureVector_attributes, &swig_TextureVector_Sf_SwigStatic, swig_TextureVector_meta, swig_TextureVector_bases, swig_TextureVector_base_names }; -static int _wrap_new_Fbo__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofFbo *result = 0 ; SWIG_check_num_args("ofFbo::ofFbo",0,0) - result = (ofFbo *)new ofFbo(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofFbo,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; +static int _wrap_resetElapsedTimeCounter(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofResetElapsedTimeCounter",0,0) + ofResetElapsedTimeCounter(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_getElapsedTimef(lua_State* L) { int SWIG_arg = 0; float result; SWIG_check_num_args("ofGetElapsedTimef",0,0) + result = (float)ofGetElapsedTimef(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_new_Fbo__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = 0 ; ofFbo *result = 0 ; - SWIG_check_num_args("ofFbo::ofFbo",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofFbo::ofFbo",1,"ofFbo &&"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("new_Fbo",1,SWIGTYPE_p_ofFbo); } - result = (ofFbo *)new ofFbo((ofFbo &&)*arg1); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofFbo,1); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_new_Fbo(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_Fbo__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_new_Fbo__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_Fbo'\n" " Possible C/C++ prototypes are:\n" - " ofFbo::ofFbo()\n" " ofFbo::ofFbo(ofFbo &&)\n"); lua_error(L);return 0; } -static int _wrap_Fbo_allocate__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; int arg2 ; int arg3 ; - int arg4 ; int arg5 ; SWIG_check_num_args("ofFbo::allocate",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::allocate",1,"ofFbo *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofFbo::allocate",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofFbo::allocate",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofFbo::allocate",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofFbo::allocate",5,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_allocate",1,SWIGTYPE_p_ofFbo); } - arg2 = (int)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - arg5 = (int)lua_tonumber(L, 5); (arg1)->allocate(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Fbo_allocate__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; int arg2 ; int arg3 ; - int arg4 ; SWIG_check_num_args("ofFbo::allocate",4,4) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::allocate",1,"ofFbo *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofFbo::allocate",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofFbo::allocate",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofFbo::allocate",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_allocate",1,SWIGTYPE_p_ofFbo); } - arg2 = (int)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - (arg1)->allocate(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_allocate__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; int arg2 ; int arg3 ; - SWIG_check_num_args("ofFbo::allocate",3,3) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::allocate",1,"ofFbo *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofFbo::allocate",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofFbo::allocate",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_allocate",1,SWIGTYPE_p_ofFbo); } - arg2 = (int)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); (arg1)->allocate(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; +static int _wrap_getElapsedTimeMillis(lua_State* L) { int SWIG_arg = 0; uint64_t result; + SWIG_check_num_args("ofGetElapsedTimeMillis",0,0) result = (uint64_t)ofGetElapsedTimeMillis(); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_getElapsedTimeMicros(lua_State* L) { int SWIG_arg = 0; uint64_t result; + SWIG_check_num_args("ofGetElapsedTimeMicros",0,0) result = (uint64_t)ofGetElapsedTimeMicros(); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_getFrameNum(lua_State* L) { int SWIG_arg = 0; uint64_t result; SWIG_check_num_args("ofGetFrameNum",0,0) + result = (uint64_t)ofGetFrameNum(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_allocate__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; ofFbo::Settings arg2 ; - ofFbo::Settings *argp2 ; SWIG_check_num_args("ofFbo::allocate",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::allocate",1,"ofFbo *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofFbo::allocate",2,"ofFbo::Settings"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_allocate",1,SWIGTYPE_p_ofFbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofFbo__Settings,0))){ - SWIG_fail_ptr("Fbo_allocate",2,SWIGTYPE_p_ofFbo__Settings); } arg2 = *argp2; (arg1)->allocate(arg2); return SWIG_arg; +static int _wrap_getSeconds(lua_State* L) { int SWIG_arg = 0; int result; SWIG_check_num_args("ofGetSeconds",0,0) + result = (int)ofGetSeconds(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_getMinutes(lua_State* L) { int SWIG_arg = 0; int result; SWIG_check_num_args("ofGetMinutes",0,0) + result = (int)ofGetMinutes(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_getHours(lua_State* L) { int SWIG_arg = 0; int result; SWIG_check_num_args("ofGetHours",0,0) + result = (int)ofGetHours(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_getUnixTime(lua_State* L) { int SWIG_arg = 0; unsigned int result; SWIG_check_num_args("ofGetUnixTime",0,0) + result = (unsigned int)ofGetUnixTime(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; + fail: lua_error(L); return SWIG_arg; } +static int _wrap_getSystemTimeMillis(lua_State* L) { int SWIG_arg = 0; uint64_t result; + SWIG_check_num_args("ofGetSystemTimeMillis",0,0) result = (uint64_t)ofGetSystemTimeMillis(); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_getSystemTimeMicros(lua_State* L) { int SWIG_arg = 0; uint64_t result; + SWIG_check_num_args("ofGetSystemTimeMicros",0,0) result = (uint64_t)ofGetSystemTimeMicros(); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Time_seconds_set(lua_State* L) { int SWIG_arg = 0; ofTime *arg1 = (ofTime *) 0 ; uint64_t arg2 ; + SWIG_check_num_args("ofTime::seconds",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTime::seconds",1,"ofTime *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTime::seconds",2,"uint64_t"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTime,0))){ + SWIG_fail_ptr("Time_seconds_set",1,SWIGTYPE_p_ofTime); } arg2 = (uint64_t)lua_tonumber(L, 2); + if (arg1) (arg1)->seconds = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Time_seconds_get(lua_State* L) { int SWIG_arg = 0; ofTime *arg1 = (ofTime *) 0 ; uint64_t result; + SWIG_check_num_args("ofTime::seconds",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTime::seconds",1,"ofTime *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTime,0))){ + SWIG_fail_ptr("Time_seconds_get",1,SWIGTYPE_p_ofTime); } result = (uint64_t) ((arg1)->seconds); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Time_nanoseconds_set(lua_State* L) { int SWIG_arg = 0; ofTime *arg1 = (ofTime *) 0 ; uint64_t arg2 ; + SWIG_check_num_args("ofTime::nanoseconds",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTime::nanoseconds",1,"ofTime *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTime::nanoseconds",2,"uint64_t"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTime,0))){ + SWIG_fail_ptr("Time_nanoseconds_set",1,SWIGTYPE_p_ofTime); } arg2 = (uint64_t)lua_tonumber(L, 2); + if (arg1) (arg1)->nanoseconds = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Time_nanoseconds_get(lua_State* L) { int SWIG_arg = 0; ofTime *arg1 = (ofTime *) 0 ; uint64_t result; + SWIG_check_num_args("ofTime::nanoseconds",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTime::nanoseconds",1,"ofTime *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTime,0))){ + SWIG_fail_ptr("Time_nanoseconds_get",1,SWIGTYPE_p_ofTime); } result = (uint64_t) ((arg1)->nanoseconds); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Time_mode_set(lua_State* L) { int SWIG_arg = 0; ofTime *arg1 = (ofTime *) 0 ; enum ofTime::Mode arg2 ; + SWIG_check_num_args("ofTime::mode",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTime::mode",1,"ofTime *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTime::mode",2,"enum ofTime::Mode"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTime,0))){ SWIG_fail_ptr("Time_mode_set",1,SWIGTYPE_p_ofTime); } + arg2 = (enum ofTime::Mode)(int)lua_tonumber(L, 2); if (arg1) (arg1)->mode = arg2; return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_Time_mode_get(lua_State* L) { int SWIG_arg = 0; ofTime *arg1 = (ofTime *) 0 ; enum ofTime::Mode result; + SWIG_check_num_args("ofTime::mode",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTime::mode",1,"ofTime *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTime,0))){ SWIG_fail_ptr("Time_mode_get",1,SWIGTYPE_p_ofTime); } + result = (enum ofTime::Mode) ((arg1)->mode); lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_allocate__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; - SWIG_check_num_args("ofFbo::allocate",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::allocate",1,"ofFbo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_allocate",1,SWIGTYPE_p_ofFbo); } - (arg1)->allocate(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_allocate(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Fbo_allocate__SWIG_4(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofFbo__Settings, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Fbo_allocate__SWIG_3(L);} } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Fbo_allocate__SWIG_2(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Fbo_allocate__SWIG_1(L);} } } } } if (argc == 5) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Fbo_allocate__SWIG_0(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Fbo_allocate'\n" " Possible C/C++ prototypes are:\n" - " ofFbo::allocate(int,int,int,int)\n" " ofFbo::allocate(int,int,int)\n" " ofFbo::allocate(int,int)\n" - " ofFbo::allocate(ofFbo::Settings)\n" " ofFbo::allocate()\n"); lua_error(L);return 0; } -static int _wrap_Fbo_isAllocated(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; bool result; - SWIG_check_num_args("ofFbo::isAllocated",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::isAllocated",1,"ofFbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_isAllocated",1,SWIGTYPE_p_ofFbo); } - result = (bool)((ofFbo const *)arg1)->isAllocated(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; +static int _wrap_Time_getAsMilliseconds(lua_State* L) { int SWIG_arg = 0; ofTime *arg1 = (ofTime *) 0 ; uint64_t result; + SWIG_check_num_args("ofTime::getAsMilliseconds",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTime::getAsMilliseconds",1,"ofTime const *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTime,0))){ + SWIG_fail_ptr("Time_getAsMilliseconds",1,SWIGTYPE_p_ofTime); } + result = (uint64_t)((ofTime const *)arg1)->getAsMilliseconds(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Time_getAsMicroseconds(lua_State* L) { int SWIG_arg = 0; ofTime *arg1 = (ofTime *) 0 ; uint64_t result; + SWIG_check_num_args("ofTime::getAsMicroseconds",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTime::getAsMicroseconds",1,"ofTime const *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTime,0))){ + SWIG_fail_ptr("Time_getAsMicroseconds",1,SWIGTYPE_p_ofTime); } + result = (uint64_t)((ofTime const *)arg1)->getAsMicroseconds(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Time_getAsNanoseconds(lua_State* L) { int SWIG_arg = 0; ofTime *arg1 = (ofTime *) 0 ; uint64_t result; + SWIG_check_num_args("ofTime::getAsNanoseconds",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTime::getAsNanoseconds",1,"ofTime const *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTime,0))){ + SWIG_fail_ptr("Time_getAsNanoseconds",1,SWIGTYPE_p_ofTime); } + result = (uint64_t)((ofTime const *)arg1)->getAsNanoseconds(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Time_getAsSeconds(lua_State* L) { int SWIG_arg = 0; ofTime *arg1 = (ofTime *) 0 ; double result; + SWIG_check_num_args("ofTime::getAsSeconds",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTime::getAsSeconds",1,"ofTime const *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTime,0))){ + SWIG_fail_ptr("Time_getAsSeconds",1,SWIGTYPE_p_ofTime); } result = (double)((ofTime const *)arg1)->getAsSeconds(); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Time_getAsTimePoint(lua_State* L) { int SWIG_arg = 0; ofTime *arg1 = (ofTime *) 0 ; + std::chrono::time_point< std::chrono::nanoseconds > result; SWIG_check_num_args("ofTime::getAsTimePoint",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTime::getAsTimePoint",1,"ofTime const *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTime,0))){ + SWIG_fail_ptr("Time_getAsTimePoint",1,SWIGTYPE_p_ofTime); } result = ((ofTime const *)arg1)->getAsTimePoint(); { + std::chrono::time_point< std::chrono::nanoseconds > * resultptr = new std::chrono::time_point< std::chrono::nanoseconds >((const std::chrono::time_point< std::chrono::nanoseconds > &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__chrono__time_pointT_std__chrono__nanoseconds_t,1); SWIG_arg++; } + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Time___sub(lua_State* L) { int SWIG_arg = 0; ofTime *arg1 = (ofTime *) 0 ; ofTime *arg2 = 0 ; + std::chrono::nanoseconds result; SWIG_check_num_args("ofTime::operator -",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTime::operator -",1,"ofTime const *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofTime::operator -",2,"ofTime const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTime,0))){ SWIG_fail_ptr("Time___sub",1,SWIGTYPE_p_ofTime); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofTime,0))){ SWIG_fail_ptr("Time___sub",2,SWIGTYPE_p_ofTime); } + result = ((ofTime const *)arg1)->operator -((ofTime const &)*arg2); { + std::chrono::nanoseconds * resultptr = new std::chrono::nanoseconds((const std::chrono::nanoseconds &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__chrono__nanoseconds,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_clear(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; SWIG_check_num_args("ofFbo::clear",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::clear",1,"ofFbo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_clear",1,SWIGTYPE_p_ofFbo); } - (arg1)->clear(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_clearColorBuffer__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; - ofFloatColor *arg2 = 0 ; SWIG_check_num_args("ofFbo::clearColorBuffer",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::clearColorBuffer",1,"ofFbo *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofFbo::clearColorBuffer",2,"ofFloatColor const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ - SWIG_fail_ptr("Fbo_clearColorBuffer",1,SWIGTYPE_p_ofFbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("Fbo_clearColorBuffer",2,SWIGTYPE_p_ofColor_T_float_t); } - (arg1)->clearColorBuffer((ofFloatColor const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_clearColorBuffer__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; size_t arg2 ; - ofFloatColor *arg3 = 0 ; SWIG_check_num_args("ofFbo::clearColorBuffer",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::clearColorBuffer",1,"ofFbo *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofFbo::clearColorBuffer",2,"size_t"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofFbo::clearColorBuffer",3,"ofFloatColor const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ - SWIG_fail_ptr("Fbo_clearColorBuffer",1,SWIGTYPE_p_ofFbo); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("Fbo_clearColorBuffer",3,SWIGTYPE_p_ofColor_T_float_t); } - (arg1)->clearColorBuffer(arg2,(ofFloatColor const &)*arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Fbo_clearColorBuffer(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Fbo_clearColorBuffer__SWIG_0(L);} } } if (argc == 3) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Fbo_clearColorBuffer__SWIG_1(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Fbo_clearColorBuffer'\n" - " Possible C/C++ prototypes are:\n" " ofFbo::clearColorBuffer(ofFloatColor const &)\n" - " ofFbo::clearColorBuffer(size_t,ofFloatColor const &)\n"); lua_error(L);return 0; } -static int _wrap_Fbo_clearDepthBuffer(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; float arg2 ; - SWIG_check_num_args("ofFbo::clearDepthBuffer",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::clearDepthBuffer",1,"ofFbo *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofFbo::clearDepthBuffer",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ - SWIG_fail_ptr("Fbo_clearDepthBuffer",1,SWIGTYPE_p_ofFbo); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->clearDepthBuffer(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_clearStencilBuffer(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; int arg2 ; - SWIG_check_num_args("ofFbo::clearStencilBuffer",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::clearStencilBuffer",1,"ofFbo *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofFbo::clearStencilBuffer",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ - SWIG_fail_ptr("Fbo_clearStencilBuffer",1,SWIGTYPE_p_ofFbo); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->clearStencilBuffer(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_clearDepthStencilBuffer(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; float arg2 ; - int arg3 ; SWIG_check_num_args("ofFbo::clearDepthStencilBuffer",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::clearDepthStencilBuffer",1,"ofFbo *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofFbo::clearDepthStencilBuffer",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofFbo::clearDepthStencilBuffer",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ - SWIG_fail_ptr("Fbo_clearDepthStencilBuffer",1,SWIGTYPE_p_ofFbo); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); (arg1)->clearDepthStencilBuffer(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_draw__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofFbo::draw",3,3) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::draw",1,"ofFbo const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofFbo::draw",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofFbo::draw",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_draw",1,SWIGTYPE_p_ofFbo); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); ((ofFbo const *)arg1)->draw(arg2,arg3); return SWIG_arg; +static int _wrap_Time___lt(lua_State* L) { int SWIG_arg = 0; ofTime *arg1 = (ofTime *) 0 ; ofTime *arg2 = 0 ; bool result; + SWIG_check_num_args("ofTime::operator <",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTime::operator <",1,"ofTime const *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofTime::operator <",2,"ofTime const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTime,0))){ SWIG_fail_ptr("Time___lt",1,SWIGTYPE_p_ofTime); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofTime,0))){ SWIG_fail_ptr("Time___lt",2,SWIGTYPE_p_ofTime); } + result = (bool)((ofTime const *)arg1)->operator <((ofTime const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Time___le(lua_State* L) { int SWIG_arg = 0; ofTime *arg1 = (ofTime *) 0 ; ofTime *arg2 = 0 ; bool result; + SWIG_check_num_args("ofTime::operator <=",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTime::operator <=",1,"ofTime const *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofTime::operator <=",2,"ofTime const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTime,0))){ SWIG_fail_ptr("Time___le",1,SWIGTYPE_p_ofTime); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofTime,0))){ SWIG_fail_ptr("Time___le",2,SWIGTYPE_p_ofTime); } + result = (bool)((ofTime const *)arg1)->operator <=((ofTime const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_new_Time(lua_State* L) { int SWIG_arg = 0; ofTime *result = 0 ; SWIG_check_num_args("ofTime::ofTime",0,0) + result = (ofTime *)new ofTime(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTime,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_draw__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; float arg2 ; float arg3 ; - float arg4 ; float arg5 ; SWIG_check_num_args("ofFbo::draw",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::draw",1,"ofFbo const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofFbo::draw",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofFbo::draw",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofFbo::draw",4,"float"); if(!lua_isnumber(L,5)) SWIG_fail_arg("ofFbo::draw",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_draw",1,SWIGTYPE_p_ofFbo); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); ((ofFbo const *)arg1)->draw(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: +static void swig_delete_Time(void *obj) { +ofTime *arg1 = (ofTime *) obj; +delete arg1; +} +static int _proxy__wrap_new_Time(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_Time); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_Time_attributes[] = { + { "seconds", _wrap_Time_seconds_get, _wrap_Time_seconds_set }, + { "nanoseconds", _wrap_Time_nanoseconds_get, _wrap_Time_nanoseconds_set }, + { "mode", _wrap_Time_mode_get, _wrap_Time_mode_set }, + {0,0,0} +}; +static swig_lua_method swig_Time_methods[]= { + { "getAsMilliseconds", _wrap_Time_getAsMilliseconds}, + { "getAsMicroseconds", _wrap_Time_getAsMicroseconds}, + { "getAsNanoseconds", _wrap_Time_getAsNanoseconds}, + { "getAsSeconds", _wrap_Time_getAsSeconds}, + { "getAsTimePoint", _wrap_Time_getAsTimePoint}, + { "__sub", _wrap_Time___sub}, + { "__lt", _wrap_Time___lt}, + { "__le", _wrap_Time___le}, + {0,0} +}; +static swig_lua_method swig_Time_meta[] = { + { "__sub", _wrap_Time___sub}, + { "__lt", _wrap_Time___lt}, + { "__le", _wrap_Time___le}, + {0,0} +}; + +static swig_lua_attribute swig_Time_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_Time_Sf_SwigStatic_constants[]= { + {SWIG_LUA_CONSTTAB_INT("System", ofTime::System)}, + {SWIG_LUA_CONSTTAB_INT("FixedRate", ofTime::FixedRate)}, + {0,0,0,0,0,0} +}; +static swig_lua_method swig_Time_Sf_SwigStatic_methods[]= { + {0,0} +}; +static swig_lua_class* swig_Time_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_Time_Sf_SwigStatic = { + "Time", + swig_Time_Sf_SwigStatic_methods, + swig_Time_Sf_SwigStatic_attributes, + swig_Time_Sf_SwigStatic_constants, + swig_Time_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_Time_bases[] = {0}; +static const char *swig_Time_base_names[] = {0}; +static swig_lua_class _wrap_class_Time = { "Time", "Time", &SWIGTYPE_p_ofTime,_proxy__wrap_new_Time, swig_delete_Time, swig_Time_methods, swig_Time_attributes, &swig_Time_Sf_SwigStatic, swig_Time_meta, swig_Time_bases, swig_Time_base_names }; + +static int _wrap_getCurrentTime(lua_State* L) { int SWIG_arg = 0; ofTime result; SWIG_check_num_args("ofGetCurrentTime",0,0) + result = ofGetCurrentTime(); { ofTime * resultptr = new ofTime((const ofTime &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofTime,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_draw(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 3) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Fbo_draw__SWIG_1(L);} } } } if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Fbo_draw__SWIG_2(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Fbo_draw'\n" " Possible C/C++ prototypes are:\n" - " ofFbo::draw()\n" " ofFbo::draw(float,float) const\n" " ofFbo::draw(float,float,float,float) const\n"); - lua_error(L);return 0; } -static int _wrap_Fbo_setAnchorPercent(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofFbo::setAnchorPercent",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::setAnchorPercent",1,"ofFbo *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofFbo::setAnchorPercent",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofFbo::setAnchorPercent",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ - SWIG_fail_ptr("Fbo_setAnchorPercent",1,SWIGTYPE_p_ofFbo); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->setAnchorPercent(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Fbo_setAnchorPoint(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofFbo::setAnchorPoint",3,3) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::setAnchorPoint",1,"ofFbo *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofFbo::setAnchorPoint",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofFbo::setAnchorPoint",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ - SWIG_fail_ptr("Fbo_setAnchorPoint",1,SWIGTYPE_p_ofFbo); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->setAnchorPoint(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Fbo_resetAnchor(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; - SWIG_check_num_args("ofFbo::resetAnchor",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::resetAnchor",1,"ofFbo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_resetAnchor",1,SWIGTYPE_p_ofFbo); } - (arg1)->resetAnchor(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_setDefaultTextureIndex(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; int arg2 ; - SWIG_check_num_args("ofFbo::setDefaultTextureIndex",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::setDefaultTextureIndex",1,"ofFbo *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofFbo::setDefaultTextureIndex",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ - SWIG_fail_ptr("Fbo_setDefaultTextureIndex",1,SWIGTYPE_p_ofFbo); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->setDefaultTextureIndex(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_getDefaultTextureIndex(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; int result; - SWIG_check_num_args("ofFbo::getDefaultTextureIndex",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::getDefaultTextureIndex",1,"ofFbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ - SWIG_fail_ptr("Fbo_getDefaultTextureIndex",1,SWIGTYPE_p_ofFbo); } - result = (int)((ofFbo const *)arg1)->getDefaultTextureIndex(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_getTexture__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; ofTexture *result = 0 ; - SWIG_check_num_args("ofFbo::getTexture",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::getTexture",1,"ofFbo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_getTexture",1,SWIGTYPE_p_ofFbo); } - result = (ofTexture *) &(arg1)->getTexture(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTexture,0); SWIG_arg++; +static int _wrap_sleepMillis(lua_State* L) { int SWIG_arg = 0; int arg1 ; SWIG_check_num_args("ofSleepMillis",1,1) + if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSleepMillis",1,"int"); arg1 = (int)lua_tonumber(L, 1); ofSleepMillis(arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_getTexture__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; int arg2 ; - ofTexture *result = 0 ; SWIG_check_num_args("ofFbo::getTexture",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::getTexture",1,"ofFbo *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofFbo::getTexture",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_getTexture",1,SWIGTYPE_p_ofFbo); } - arg2 = (int)lua_tonumber(L, 2); result = (ofTexture *) &(arg1)->getTexture(arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTexture,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); +static int _wrap_getTimestampString__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string result; + SWIG_check_num_args("ofGetTimestampString",0,0) result = ofGetTimestampString(); + lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_getDepthTexture__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; - ofTexture *result = 0 ; SWIG_check_num_args("ofFbo::getDepthTexture",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::getDepthTexture",1,"ofFbo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ - SWIG_fail_ptr("Fbo_getDepthTexture",1,SWIGTYPE_p_ofFbo); } result = (ofTexture *) &(arg1)->getDepthTexture(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTexture,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); +static int _wrap_getTimestampString__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; + std::string result; SWIG_check_num_args("ofGetTimestampString",1,1) + if(!lua_isstring(L,1)) SWIG_fail_arg("ofGetTimestampString",1,"std::string const &"); + temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = ofGetTimestampString((std::string const &)*arg1); + lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_getTexture__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; ofTexture *result = 0 ; - SWIG_check_num_args("ofFbo::getTexture",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::getTexture",1,"ofFbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_getTexture",1,SWIGTYPE_p_ofFbo); } - result = (ofTexture *) &((ofFbo const *)arg1)->getTexture(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTexture,0); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_getTexture__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; int arg2 ; - ofTexture *result = 0 ; SWIG_check_num_args("ofFbo::getTexture",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::getTexture",1,"ofFbo const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofFbo::getTexture",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_getTexture",1,SWIGTYPE_p_ofFbo); } - arg2 = (int)lua_tonumber(L, 2); result = (ofTexture *) &((ofFbo const *)arg1)->getTexture(arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTexture,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); +static int _wrap_getTimestampString(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { + return _wrap_getTimestampString__SWIG_0(L);} if (argc == 1) { return _wrap_getTimestampString__SWIG_1(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'getTimestampString'\n" " Possible C/C++ prototypes are:\n" + " ofGetTimestampString()\n" " ofGetTimestampString(std::string const &)\n"); lua_error(L);return 0; } +static int _wrap_getYear(lua_State* L) { int SWIG_arg = 0; int result; SWIG_check_num_args("ofGetYear",0,0) + result = (int)ofGetYear(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_getMonth(lua_State* L) { int SWIG_arg = 0; int result; SWIG_check_num_args("ofGetMonth",0,0) + result = (int)ofGetMonth(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_getDay(lua_State* L) { int SWIG_arg = 0; int result; SWIG_check_num_args("ofGetDay",0,0) + result = (int)ofGetDay(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_getWeekday(lua_State* L) { int SWIG_arg = 0; int result; SWIG_check_num_args("ofGetWeekday",0,0) + result = (int)ofGetWeekday(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_enableDataPath(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofEnableDataPath",0,0) + ofEnableDataPath(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_disableDataPath(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofDisableDataPath",0,0) + ofDisableDataPath(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_toDataPath__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::filesystem::path *arg1 = 0 ; bool arg2 ; + std::filesystem::path temp1 ; std::string result; SWIG_check_num_args("ofToDataPath",2,2) + if(!lua_isstring(L,1)) SWIG_fail_arg("ofToDataPath",1,"std::filesystem::path const &"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("ofToDataPath",2,"bool"); { size_t len = lua_rawlen(L, 1); + temp1 = lua_tolstring(L, 1, &len); arg1 = &temp1; } arg2 = (lua_toboolean(L, 2)!=0); + result = ofToDataPath((boost::filesystem::path const &)*arg1,arg2); + lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_getTexture(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Fbo_getTexture__SWIG_0(L);} } if (argc == 1) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_Fbo_getTexture__SWIG_2(L);} } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Fbo_getTexture__SWIG_1(L);} } } - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Fbo_getTexture__SWIG_3(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Fbo_getTexture'\n" " Possible C/C++ prototypes are:\n" - " ofFbo::getTexture()\n" " ofFbo::getTexture(int)\n" " ofFbo::getTexture() const\n" - " ofFbo::getTexture(int) const\n"); lua_error(L);return 0; } -static int _wrap_Fbo_getDepthTexture__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; - ofTexture *result = 0 ; SWIG_check_num_args("ofFbo::getDepthTexture",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::getDepthTexture",1,"ofFbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ - SWIG_fail_ptr("Fbo_getDepthTexture",1,SWIGTYPE_p_ofFbo); } - result = (ofTexture *) &((ofFbo const *)arg1)->getDepthTexture(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTexture,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); +static int _wrap_toDataPath__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::filesystem::path *arg1 = 0 ; + std::filesystem::path temp1 ; std::string result; SWIG_check_num_args("ofToDataPath",1,1) + if(!lua_isstring(L,1)) SWIG_fail_arg("ofToDataPath",1,"std::filesystem::path const &"); { size_t len = lua_rawlen(L, 1); + temp1 = lua_tolstring(L, 1, &len); arg1 = &temp1; } result = ofToDataPath((boost::filesystem::path const &)*arg1); + lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_getDepthTexture(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Fbo_getDepthTexture__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Fbo_getDepthTexture__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Fbo_getDepthTexture'\n" - " Possible C/C++ prototypes are:\n" " ofFbo::getDepthTexture()\n" " ofFbo::getDepthTexture() const\n"); +static int _wrap_toDataPath(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { + return _wrap_toDataPath__SWIG_1(L);} if (argc == 2) { return _wrap_toDataPath__SWIG_0(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'toDataPath'\n" " Possible C/C++ prototypes are:\n" + " ofToDataPath(std::filesystem::path const &,bool)\n" " ofToDataPath(std::filesystem::path const &)\n"); lua_error(L);return 0; } -static int _wrap_Fbo_beginFbo__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; bool arg2 ; - SWIG_check_num_args("ofFbo::begin",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::begin",1,"ofFbo const *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofFbo::begin",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_beginFbo",1,SWIGTYPE_p_ofFbo); } - arg2 = (lua_toboolean(L, 2)!=0); ((ofFbo const *)arg1)->begin(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); +static int _wrap_restoreWorkingDirectoryToDefault(lua_State* L) { int SWIG_arg = 0; bool result; + SWIG_check_num_args("ofRestoreWorkingDirectoryToDefault",0,0) result = (bool)ofRestoreWorkingDirectoryToDefault(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_setDataPathRoot(lua_State* L) { int SWIG_arg = 0; std::filesystem::path *arg1 = 0 ; + std::filesystem::path temp1 ; SWIG_check_num_args("ofSetDataPathRoot",1,1) + if(!lua_isstring(L,1)) SWIG_fail_arg("ofSetDataPathRoot",1,"std::filesystem::path const &"); { size_t len = lua_rawlen(L, 1); + temp1 = lua_tolstring(L, 1, &len); arg1 = &temp1; } ofSetDataPathRoot((boost::filesystem::path const &)*arg1); + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_splitString__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; + bool arg3 ; bool arg4 ; std::string temp1 ; std::string temp2 ; std::vector< std::string > result; + SWIG_check_num_args("ofSplitString",4,4) if(!lua_isstring(L,1)) SWIG_fail_arg("ofSplitString",1,"std::string const &"); + if(!lua_isstring(L,2)) SWIG_fail_arg("ofSplitString",2,"std::string const &"); + if(!lua_isboolean(L,3)) SWIG_fail_arg("ofSplitString",3,"bool"); + if(!lua_isboolean(L,4)) SWIG_fail_arg("ofSplitString",4,"bool"); temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; + temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; arg3 = (lua_toboolean(L, 3)!=0); + arg4 = (lua_toboolean(L, 4)!=0); result = ofSplitString((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4); { + std::vector< std::string > * resultptr = new std::vector< std::string >((const std::vector< std::string > &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_std__string_t,1); SWIG_arg++; } return SWIG_arg; + if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_splitString__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; + bool arg3 ; std::string temp1 ; std::string temp2 ; std::vector< std::string > result; + SWIG_check_num_args("ofSplitString",3,3) if(!lua_isstring(L,1)) SWIG_fail_arg("ofSplitString",1,"std::string const &"); + if(!lua_isstring(L,2)) SWIG_fail_arg("ofSplitString",2,"std::string const &"); + if(!lua_isboolean(L,3)) SWIG_fail_arg("ofSplitString",3,"bool"); temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; + temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; arg3 = (lua_toboolean(L, 3)!=0); + result = ofSplitString((std::string const &)*arg1,(std::string const &)*arg2,arg3); { + std::vector< std::string > * resultptr = new std::vector< std::string >((const std::vector< std::string > &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_std__string_t,1); SWIG_arg++; } return SWIG_arg; + if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_splitString__SWIG_2(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; + std::string temp1 ; std::string temp2 ; std::vector< std::string > result; SWIG_check_num_args("ofSplitString",2,2) + if(!lua_isstring(L,1)) SWIG_fail_arg("ofSplitString",1,"std::string const &"); + if(!lua_isstring(L,2)) SWIG_fail_arg("ofSplitString",2,"std::string const &"); + temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; + result = ofSplitString((std::string const &)*arg1,(std::string const &)*arg2); { + std::vector< std::string > * resultptr = new std::vector< std::string >((const std::vector< std::string > &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_std__string_t,1); SWIG_arg++; } return SWIG_arg; + if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_splitString(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { + return _wrap_splitString__SWIG_2(L);} if (argc == 3) { return _wrap_splitString__SWIG_1(L);} if (argc == 4) { + return _wrap_splitString__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'splitString'\n" + " Possible C/C++ prototypes are:\n" " ofSplitString(std::string const &,std::string const &,bool,bool)\n" + " ofSplitString(std::string const &,std::string const &,bool)\n" + " ofSplitString(std::string const &,std::string const &)\n"); lua_error(L);return 0; } +static int _wrap_joinString(lua_State* L) { int SWIG_arg = 0; std::vector< std::string > *arg1 = 0 ; std::string *arg2 = 0 ; + std::string temp2 ; std::string result; SWIG_check_num_args("ofJoinString",2,2) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofJoinString",1,"std::vector< std::string > const &"); + if(!lua_isstring(L,2)) SWIG_fail_arg("ofJoinString",2,"std::string const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_std__string_t,0))){ + SWIG_fail_ptr("joinString",1,SWIGTYPE_p_std__vectorT_std__string_t); } + temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; + result = ofJoinString((std::vector< std::string > const &)*arg1,(std::string const &)*arg2); + lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_beginFbo__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; ofFboBeginMode arg2 ; - SWIG_check_num_args("ofFbo::begin",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::begin",1,"ofFbo *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofFbo::begin",2,"ofFboBeginMode"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_beginFbo",1,SWIGTYPE_p_ofFbo); } - arg2 = (ofFboBeginMode)(int)lua_tonumber(L, 2); (arg1)->begin(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); +static int _wrap_stringReplace(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; + std::string *arg3 = 0 ; std::string temp2 ; std::string temp3 ; SWIG_check_num_args("ofStringReplace",3,3) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofStringReplace",1,"std::string &"); + if(!lua_isstring(L,2)) SWIG_fail_arg("ofStringReplace",2,"std::string const &"); + if(!lua_isstring(L,3)) SWIG_fail_arg("ofStringReplace",3,"std::string const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__string,0))){ + SWIG_fail_ptr("stringReplace",1,SWIGTYPE_p_std__string); } temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; + temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3; + ofStringReplace(*arg1,(std::string const &)*arg2,(std::string const &)*arg3); return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_isStringInString(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; + std::string temp1 ; std::string temp2 ; bool result; SWIG_check_num_args("ofIsStringInString",2,2) + if(!lua_isstring(L,1)) SWIG_fail_arg("ofIsStringInString",1,"std::string const &"); + if(!lua_isstring(L,2)) SWIG_fail_arg("ofIsStringInString",2,"std::string const &"); + temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; + result = (bool)ofIsStringInString((std::string const &)*arg1,(std::string const &)*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_stringTimesInString(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; + std::string temp1 ; std::string temp2 ; std::size_t result; SWIG_check_num_args("ofStringTimesInString",2,2) + if(!lua_isstring(L,1)) SWIG_fail_arg("ofStringTimesInString",1,"std::string const &"); + if(!lua_isstring(L,2)) SWIG_fail_arg("ofStringTimesInString",2,"std::string const &"); + temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; + result = (std::size_t)ofStringTimesInString((std::string const &)*arg1,(std::string const &)*arg2); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_toLower__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; + std::string temp1 ; std::string temp2 ; std::string result; SWIG_check_num_args("ofToLower",2,2) + if(!lua_isstring(L,1)) SWIG_fail_arg("ofToLower",1,"std::string const &"); + if(!lua_isstring(L,2)) SWIG_fail_arg("ofToLower",2,"std::string const &"); + temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; + result = ofToLower((std::string const &)*arg1,(std::string const &)*arg2); + lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_beginFbo__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; - SWIG_check_num_args("ofFbo::begin",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::begin",1,"ofFbo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_beginFbo",1,SWIGTYPE_p_ofFbo); } - (arg1)->begin(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_beginFbo(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Fbo_beginFbo__SWIG_2(L);} } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { return _wrap_Fbo_beginFbo__SWIG_0(L);} } } - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Fbo_beginFbo__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Fbo_beginFbo'\n" " Possible C/C++ prototypes are:\n" - " ofFbo::begin(bool) const\n" " ofFbo::begin(ofFboBeginMode)\n" " ofFbo::begin()\n"); lua_error(L);return 0; } -static int _wrap_Fbo_endFbo(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; SWIG_check_num_args("ofFbo::end",1,1) +static int _wrap_toLower__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; + std::string result; SWIG_check_num_args("ofToLower",1,1) + if(!lua_isstring(L,1)) SWIG_fail_arg("ofToLower",1,"std::string const &"); + temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = ofToLower((std::string const &)*arg1); + lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_toLower(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { + return _wrap_toLower__SWIG_1(L);} if (argc == 2) { return _wrap_toLower__SWIG_0(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'toLower'\n" " Possible C/C++ prototypes are:\n" + " ofToLower(std::string const &,std::string const &)\n" " ofToLower(std::string const &)\n"); lua_error(L);return 0; } +static int _wrap_toUpper__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; + std::string temp1 ; std::string temp2 ; std::string result; SWIG_check_num_args("ofToUpper",2,2) + if(!lua_isstring(L,1)) SWIG_fail_arg("ofToUpper",1,"std::string const &"); + if(!lua_isstring(L,2)) SWIG_fail_arg("ofToUpper",2,"std::string const &"); + temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; + result = ofToUpper((std::string const &)*arg1,(std::string const &)*arg2); + lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_toUpper__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; + std::string result; SWIG_check_num_args("ofToUpper",1,1) + if(!lua_isstring(L,1)) SWIG_fail_arg("ofToUpper",1,"std::string const &"); + temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = ofToUpper((std::string const &)*arg1); + lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_toUpper(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { + return _wrap_toUpper__SWIG_1(L);} if (argc == 2) { return _wrap_toUpper__SWIG_0(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'toUpper'\n" " Possible C/C++ prototypes are:\n" + " ofToUpper(std::string const &,std::string const &)\n" " ofToUpper(std::string const &)\n"); lua_error(L);return 0; } +static int _wrap_trimFront__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; + std::string temp1 ; std::string temp2 ; std::string result; SWIG_check_num_args("ofTrimFront",2,2) + if(!lua_isstring(L,1)) SWIG_fail_arg("ofTrimFront",1,"std::string const &"); + if(!lua_isstring(L,2)) SWIG_fail_arg("ofTrimFront",2,"std::string const &"); + temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; + result = ofTrimFront((std::string const &)*arg1,(std::string const &)*arg2); + lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_trimFront__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; + std::string result; SWIG_check_num_args("ofTrimFront",1,1) + if(!lua_isstring(L,1)) SWIG_fail_arg("ofTrimFront",1,"std::string const &"); + temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = ofTrimFront((std::string const &)*arg1); + lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_trimFront(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { + return _wrap_trimFront__SWIG_1(L);} if (argc == 2) { return _wrap_trimFront__SWIG_0(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'trimFront'\n" " Possible C/C++ prototypes are:\n" + " ofTrimFront(std::string const &,std::string const &)\n" " ofTrimFront(std::string const &)\n"); + lua_error(L);return 0; } +static int _wrap_trimBack__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; + std::string temp1 ; std::string temp2 ; std::string result; SWIG_check_num_args("ofTrimBack",2,2) + if(!lua_isstring(L,1)) SWIG_fail_arg("ofTrimBack",1,"std::string const &"); + if(!lua_isstring(L,2)) SWIG_fail_arg("ofTrimBack",2,"std::string const &"); + temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; + result = ofTrimBack((std::string const &)*arg1,(std::string const &)*arg2); + lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_trimBack__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; + std::string result; SWIG_check_num_args("ofTrimBack",1,1) + if(!lua_isstring(L,1)) SWIG_fail_arg("ofTrimBack",1,"std::string const &"); + temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = ofTrimBack((std::string const &)*arg1); + lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_trimBack(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { + return _wrap_trimBack__SWIG_1(L);} if (argc == 2) { return _wrap_trimBack__SWIG_0(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'trimBack'\n" " Possible C/C++ prototypes are:\n" + " ofTrimBack(std::string const &,std::string const &)\n" " ofTrimBack(std::string const &)\n"); lua_error(L);return 0; } +static int _wrap_trim__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; + std::string temp1 ; std::string temp2 ; std::string result; SWIG_check_num_args("ofTrim",2,2) + if(!lua_isstring(L,1)) SWIG_fail_arg("ofTrim",1,"std::string const &"); + if(!lua_isstring(L,2)) SWIG_fail_arg("ofTrim",2,"std::string const &"); + temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; + result = ofTrim((std::string const &)*arg1,(std::string const &)*arg2); + lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_trim__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; std::string result; + SWIG_check_num_args("ofTrim",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofTrim",1,"std::string const &"); + temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = ofTrim((std::string const &)*arg1); + lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_trim(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { + return _wrap_trim__SWIG_1(L);} if (argc == 2) { return _wrap_trim__SWIG_0(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'trim'\n" " Possible C/C++ prototypes are:\n" + " ofTrim(std::string const &,std::string const &)\n" " ofTrim(std::string const &)\n"); lua_error(L);return 0; } +static int _wrap_uTF8Append(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; uint32_t arg2 ; uint32_t *argp2 ; + SWIG_check_num_args("ofUTF8Append",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofUTF8Append",1,"std::string &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofUTF8Append",2,"uint32_t"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__string,0))){ + SWIG_fail_ptr("uTF8Append",1,SWIGTYPE_p_std__string); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_uint32_t,0))){ + SWIG_fail_ptr("uTF8Append",2,SWIGTYPE_p_uint32_t); } arg2 = *argp2; ofUTF8Append(*arg1,arg2); return SWIG_arg; + if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_uTF8Insert(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; size_t arg2 ; uint32_t arg3 ; + uint32_t *argp3 ; SWIG_check_num_args("ofUTF8Insert",3,3) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofUTF8Insert",1,"std::string &"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofUTF8Insert",2,"size_t"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofUTF8Insert",3,"uint32_t"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__string,0))){ + SWIG_fail_ptr("uTF8Insert",1,SWIGTYPE_p_std__string); } + SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&argp3,SWIGTYPE_p_uint32_t,0))){ + SWIG_fail_ptr("uTF8Insert",3,SWIGTYPE_p_uint32_t); } arg3 = *argp3; ofUTF8Insert(*arg1,arg2,arg3); return SWIG_arg; + if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_uTF8Erase(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; size_t arg2 ; size_t arg3 ; + SWIG_check_num_args("ofUTF8Erase",3,3) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofUTF8Erase",1,"std::string &"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofUTF8Erase",2,"size_t"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("ofUTF8Erase",3,"size_t"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__string,0))){ + SWIG_fail_ptr("uTF8Erase",1,SWIGTYPE_p_std__string); } + SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); + SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); + ofUTF8Erase(*arg1,arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_uTF8Substring(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; size_t arg2 ; size_t arg3 ; + std::string temp1 ; std::string result; SWIG_check_num_args("ofUTF8Substring",3,3) + if(!lua_isstring(L,1)) SWIG_fail_arg("ofUTF8Substring",1,"std::string const &"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofUTF8Substring",2,"size_t"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("ofUTF8Substring",3,"size_t"); + temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; + SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); + SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); + result = ofUTF8Substring((std::string const &)*arg1,arg2,arg3); + lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_uTF8ToString(lua_State* L) { int SWIG_arg = 0; uint32_t arg1 ; uint32_t *argp1 ; std::string result; + SWIG_check_num_args("ofUTF8ToString",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofUTF8ToString",1,"uint32_t"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&argp1,SWIGTYPE_p_uint32_t,0))){ + SWIG_fail_ptr("uTF8ToString",1,SWIGTYPE_p_uint32_t); } arg1 = *argp1; result = ofUTF8ToString(arg1); + lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_uTF8Length(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; size_t result; + SWIG_check_num_args("ofUTF8Length",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofUTF8Length",1,"std::string const &"); + temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = (size_t)ofUTF8Length((std::string const &)*arg1); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_toInt(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; int result; + SWIG_check_num_args("ofToInt",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofToInt",1,"std::string const &"); + temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = (int)ofToInt((std::string const &)*arg1); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_toInt64(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; int64_t result; + SWIG_check_num_args("ofToInt64",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofToInt64",1,"std::string const &"); + temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = (int64_t)ofToInt64((std::string const &)*arg1); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_toFloat(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; float result; + SWIG_check_num_args("ofToFloat",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofToFloat",1,"std::string const &"); + temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = (float)ofToFloat((std::string const &)*arg1); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_toDouble(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; double result; + SWIG_check_num_args("ofToDouble",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofToDouble",1,"std::string const &"); + temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = (double)ofToDouble((std::string const &)*arg1); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_toBool(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; bool result; + SWIG_check_num_args("ofToBool",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofToBool",1,"std::string const &"); + temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = (bool)ofToBool((std::string const &)*arg1); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_toHex(lua_State* L) { int SWIG_arg = 0; char *arg1 = (char *) 0 ; std::string result; + SWIG_check_num_args("ofToHex",1,1) if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("ofToHex",1,"char const *"); + arg1 = (char *)lua_tostring(L, 1); result = ofToHex((char const *)arg1); + lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_hexToInt(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; int result; + SWIG_check_num_args("ofHexToInt",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofHexToInt",1,"std::string const &"); + temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = (int)ofHexToInt((std::string const &)*arg1); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_hexToChar(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; char result; + SWIG_check_num_args("ofHexToChar",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofHexToChar",1,"std::string const &"); + temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = (char)ofHexToChar((std::string const &)*arg1); + lua_pushlstring(L, &result, 1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_hexToFloat(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; float result; + SWIG_check_num_args("ofHexToFloat",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofHexToFloat",1,"std::string const &"); + temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = (float)ofHexToFloat((std::string const &)*arg1); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_hexToString(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; std::string result; + SWIG_check_num_args("ofHexToString",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofHexToString",1,"std::string const &"); + temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = ofHexToString((std::string const &)*arg1); + lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_toChar(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; char result; + SWIG_check_num_args("ofToChar",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofToChar",1,"std::string const &"); + temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = (char)ofToChar((std::string const &)*arg1); + lua_pushlstring(L, &result, 1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_toBinary(lua_State* L) { int SWIG_arg = 0; char *arg1 = (char *) 0 ; std::string result; + SWIG_check_num_args("ofToBinary",1,1) if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("ofToBinary",1,"char const *"); + arg1 = (char *)lua_tostring(L, 1); result = ofToBinary((char const *)arg1); + lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_binaryToInt(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; int result; + SWIG_check_num_args("ofBinaryToInt",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofBinaryToInt",1,"std::string const &"); + temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = (int)ofBinaryToInt((std::string const &)*arg1); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_binaryToChar(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; char result; + SWIG_check_num_args("ofBinaryToChar",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofBinaryToChar",1,"std::string const &"); + temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = (char)ofBinaryToChar((std::string const &)*arg1); + lua_pushlstring(L, &result, 1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_binaryToFloat(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; float result; + SWIG_check_num_args("ofBinaryToFloat",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofBinaryToFloat",1,"std::string const &"); + temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = (float)ofBinaryToFloat((std::string const &)*arg1); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_binaryToString(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; + std::string result; SWIG_check_num_args("ofBinaryToString",1,1) + if(!lua_isstring(L,1)) SWIG_fail_arg("ofBinaryToString",1,"std::string const &"); + temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = ofBinaryToString((std::string const &)*arg1); + lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_getVersionInfo(lua_State* L) { int SWIG_arg = 0; std::string result; + SWIG_check_num_args("ofGetVersionInfo",0,0) result = ofGetVersionInfo(); + lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_getVersionMajor(lua_State* L) { int SWIG_arg = 0; unsigned int result; + SWIG_check_num_args("ofGetVersionMajor",0,0) result = (unsigned int)ofGetVersionMajor(); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_getVersionMinor(lua_State* L) { int SWIG_arg = 0; unsigned int result; + SWIG_check_num_args("ofGetVersionMinor",0,0) result = (unsigned int)ofGetVersionMinor(); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_getVersionPatch(lua_State* L) { int SWIG_arg = 0; unsigned int result; + SWIG_check_num_args("ofGetVersionPatch",0,0) result = (unsigned int)ofGetVersionPatch(); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_getVersionPreRelease(lua_State* L) { int SWIG_arg = 0; std::string result; + SWIG_check_num_args("ofGetVersionPreRelease",0,0) result = ofGetVersionPreRelease(); + lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_saveScreen(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; + SWIG_check_num_args("ofSaveScreen",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofSaveScreen",1,"std::string const &"); + temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; ofSaveScreen((std::string const &)*arg1); return SWIG_arg; + if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_saveFrame__SWIG_0(lua_State* L) { int SWIG_arg = 0; bool arg1 ; SWIG_check_num_args("ofSaveFrame",1,1) + if(!lua_isboolean(L,1)) SWIG_fail_arg("ofSaveFrame",1,"bool"); arg1 = (lua_toboolean(L, 1)!=0); ofSaveFrame(arg1); + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_saveFrame__SWIG_1(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofSaveFrame",0,0) ofSaveFrame(); + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_saveFrame(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { + return _wrap_saveFrame__SWIG_1(L);} if (argc == 1) { return _wrap_saveFrame__SWIG_0(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'saveFrame'\n" " Possible C/C++ prototypes are:\n" + " ofSaveFrame(bool)\n" " ofSaveFrame()\n"); lua_error(L);return 0; } +static int _wrap_saveViewport(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; + SWIG_check_num_args("ofSaveViewport",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofSaveViewport",1,"std::string const &"); + temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; ofSaveViewport((std::string const &)*arg1); return SWIG_arg; + if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_launchBrowser__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; bool arg2 ; std::string temp1 ; + SWIG_check_num_args("ofLaunchBrowser",2,2) if(!lua_isstring(L,1)) SWIG_fail_arg("ofLaunchBrowser",1,"std::string const &"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("ofLaunchBrowser",2,"bool"); + temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; arg2 = (lua_toboolean(L, 2)!=0); + ofLaunchBrowser((std::string const &)*arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_launchBrowser__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; + SWIG_check_num_args("ofLaunchBrowser",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofLaunchBrowser",1,"std::string const &"); + temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; ofLaunchBrowser((std::string const &)*arg1); return SWIG_arg; + if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_launchBrowser(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { + return _wrap_launchBrowser__SWIG_1(L);} if (argc == 2) { return _wrap_launchBrowser__SWIG_0(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'launchBrowser'\n" " Possible C/C++ prototypes are:\n" + " ofLaunchBrowser(std::string const &,bool)\n" " ofLaunchBrowser(std::string const &)\n"); lua_error(L);return 0; } +static int _wrap_system(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; std::string result; + SWIG_check_num_args("ofSystem",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofSystem",1,"std::string const &"); + temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = ofSystem((std::string const &)*arg1); + lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_getTargetPlatform(lua_State* L) { int SWIG_arg = 0; ofTargetPlatform result; + SWIG_check_num_args("ofGetTargetPlatform",0,0) result = (ofTargetPlatform)ofGetTargetPlatform(); + lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_getEnv(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; std::string result; + SWIG_check_num_args("ofGetEnv",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofGetEnv",1,"std::string const &"); + temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = ofGetEnv((std::string const &)*arg1); + lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_FboModeOr(lua_State* L) { int SWIG_arg = 0; ofFboMode arg1 ; ofFboMode arg2 ; ofFboMode result; + SWIG_check_num_args("operator |",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("operator |",1,"ofFboMode"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("operator |",2,"ofFboMode"); arg1 = (ofFboMode)(int)lua_tonumber(L, 1); + arg2 = (ofFboMode)(int)lua_tonumber(L, 2); result = (ofFboMode)operator |(arg1,arg2); + lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_FboModeAnd(lua_State* L) { int SWIG_arg = 0; ofFboMode arg1 ; ofFboMode arg2 ; bool result; + SWIG_check_num_args("operator &",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("operator &",1,"ofFboMode"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("operator &",2,"ofFboMode"); arg1 = (ofFboMode)(int)lua_tonumber(L, 1); + arg2 = (ofFboMode)(int)lua_tonumber(L, 2); result = (bool)operator &(arg1,arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_new_Fbo__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofFbo *result = 0 ; SWIG_check_num_args("ofFbo::ofFbo",0,0) + result = (ofFbo *)new ofFbo(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofFbo,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; + fail: lua_error(L); return SWIG_arg; } +static int _wrap_new_Fbo__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = 0 ; ofFbo *result = 0 ; + SWIG_check_num_args("ofFbo::ofFbo",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofFbo::ofFbo",1,"ofFbo &&"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("new_Fbo",1,SWIGTYPE_p_ofFbo); } + result = (ofFbo *)new ofFbo((ofFbo &&)*arg1); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofFbo,1); SWIG_arg++; return SWIG_arg; + if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_new_Fbo(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { + return _wrap_new_Fbo__SWIG_0(L);} if (argc == 1) { return _wrap_new_Fbo__SWIG_1(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_Fbo'\n" " Possible C/C++ prototypes are:\n" + " ofFbo::ofFbo()\n" " ofFbo::ofFbo(ofFbo &&)\n"); lua_error(L);return 0; } +static int _wrap_Fbo_allocate__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; int arg2 ; int arg3 ; + int arg4 ; int arg5 ; SWIG_check_num_args("ofFbo::allocate",5,5) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::allocate",1,"ofFbo *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofFbo::allocate",2,"int"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("ofFbo::allocate",3,"int"); + if(!lua_isnumber(L,4)) SWIG_fail_arg("ofFbo::allocate",4,"int"); + if(!lua_isnumber(L,5)) SWIG_fail_arg("ofFbo::allocate",5,"int"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_allocate",1,SWIGTYPE_p_ofFbo); } + arg2 = (int)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); + arg5 = (int)lua_tonumber(L, 5); (arg1)->allocate(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_Fbo_allocate__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; int arg2 ; int arg3 ; + int arg4 ; SWIG_check_num_args("ofFbo::allocate",4,4) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::allocate",1,"ofFbo *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofFbo::allocate",2,"int"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("ofFbo::allocate",3,"int"); + if(!lua_isnumber(L,4)) SWIG_fail_arg("ofFbo::allocate",4,"int"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_allocate",1,SWIGTYPE_p_ofFbo); } + arg2 = (int)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); + (arg1)->allocate(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Fbo_allocate__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; int arg2 ; int arg3 ; + SWIG_check_num_args("ofFbo::allocate",3,3) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::allocate",1,"ofFbo *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofFbo::allocate",2,"int"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("ofFbo::allocate",3,"int"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_allocate",1,SWIGTYPE_p_ofFbo); } + arg2 = (int)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); (arg1)->allocate(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; + fail: lua_error(L); return SWIG_arg; } +static int _wrap_Fbo_allocate__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; + SWIG_check_num_args("ofFbo::allocate",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::allocate",1,"ofFbo *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_allocate",1,SWIGTYPE_p_ofFbo); } + (arg1)->allocate(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Fbo_allocate(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 1) { + return _wrap_Fbo_allocate__SWIG_3(L);} if (argc == 3) { return _wrap_Fbo_allocate__SWIG_2(L);} if (argc == 4) { + return _wrap_Fbo_allocate__SWIG_1(L);} if (argc == 5) { return _wrap_Fbo_allocate__SWIG_0(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Fbo_allocate'\n" " Possible C/C++ prototypes are:\n" + " ofFbo::allocate(int,int,int,int)\n" " ofFbo::allocate(int,int,int)\n" " ofFbo::allocate(int,int)\n" + " ofFbo::allocate()\n"); lua_error(L);return 0; } +static int _wrap_Fbo_isAllocated(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; bool result; + SWIG_check_num_args("ofFbo::isAllocated",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::isAllocated",1,"ofFbo const *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_isAllocated",1,SWIGTYPE_p_ofFbo); } + result = (bool)((ofFbo const *)arg1)->isAllocated(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; + if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Fbo_clear(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; SWIG_check_num_args("ofFbo::clear",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::clear",1,"ofFbo *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_clear",1,SWIGTYPE_p_ofFbo); } + (arg1)->clear(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Fbo_clearColorBuffer__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; + ofFloatColor *arg2 = 0 ; SWIG_check_num_args("ofFbo::clearColorBuffer",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::clearColorBuffer",1,"ofFbo *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofFbo::clearColorBuffer",2,"ofFloatColor const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ + SWIG_fail_ptr("Fbo_clearColorBuffer",1,SWIGTYPE_p_ofFbo); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_float_t,0))){ + SWIG_fail_ptr("Fbo_clearColorBuffer",2,SWIGTYPE_p_ofColor_T_float_t); } + (arg1)->clearColorBuffer((ofFloatColor const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Fbo_clearColorBuffer__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; size_t arg2 ; + ofFloatColor *arg3 = 0 ; SWIG_check_num_args("ofFbo::clearColorBuffer",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::clearColorBuffer",1,"ofFbo *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofFbo::clearColorBuffer",2,"size_t"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofFbo::clearColorBuffer",3,"ofFloatColor const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ + SWIG_fail_ptr("Fbo_clearColorBuffer",1,SWIGTYPE_p_ofFbo); } + SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofColor_T_float_t,0))){ + SWIG_fail_ptr("Fbo_clearColorBuffer",3,SWIGTYPE_p_ofColor_T_float_t); } + (arg1)->clearColorBuffer(arg2,(ofFloatColor const &)*arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_Fbo_clearColorBuffer(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { + return _wrap_Fbo_clearColorBuffer__SWIG_0(L);} if (argc == 3) { return _wrap_Fbo_clearColorBuffer__SWIG_1(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Fbo_clearColorBuffer'\n" + " Possible C/C++ prototypes are:\n" " ofFbo::clearColorBuffer(ofFloatColor const &)\n" + " ofFbo::clearColorBuffer(size_t,ofFloatColor const &)\n"); lua_error(L);return 0; } +static int _wrap_Fbo_clearDepthBuffer(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; float arg2 ; + SWIG_check_num_args("ofFbo::clearDepthBuffer",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::clearDepthBuffer",1,"ofFbo *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofFbo::clearDepthBuffer",2,"float"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ + SWIG_fail_ptr("Fbo_clearDepthBuffer",1,SWIGTYPE_p_ofFbo); } arg2 = (float)lua_tonumber(L, 2); + (arg1)->clearDepthBuffer(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Fbo_clearStencilBuffer(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; int arg2 ; + SWIG_check_num_args("ofFbo::clearStencilBuffer",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::clearStencilBuffer",1,"ofFbo *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofFbo::clearStencilBuffer",2,"int"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ + SWIG_fail_ptr("Fbo_clearStencilBuffer",1,SWIGTYPE_p_ofFbo); } arg2 = (int)lua_tonumber(L, 2); + (arg1)->clearStencilBuffer(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Fbo_clearDepthStencilBuffer(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; float arg2 ; + int arg3 ; SWIG_check_num_args("ofFbo::clearDepthStencilBuffer",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::clearDepthStencilBuffer",1,"ofFbo *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofFbo::clearDepthStencilBuffer",2,"float"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("ofFbo::clearDepthStencilBuffer",3,"int"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ + SWIG_fail_ptr("Fbo_clearDepthStencilBuffer",1,SWIGTYPE_p_ofFbo); } arg2 = (float)lua_tonumber(L, 2); + arg3 = (int)lua_tonumber(L, 3); (arg1)->clearDepthStencilBuffer(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_Fbo_draw__SWIG_0_0(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; glm::vec2 *arg2 = 0 ; + SWIG_check_num_args("draw",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("draw",1,"ofFbo const *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("draw",2,"glm::vec2 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_draw",1,SWIGTYPE_p_ofFbo); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("Fbo_draw",2,SWIGTYPE_p_glm__vec2); } + ((ofFbo const *)arg1)->draw((glm::vec2 const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_Fbo_draw__SWIG_0_1(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; ofRectangle *arg2 = 0 ; + SWIG_check_num_args("draw",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("draw",1,"ofFbo const *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("draw",2,"ofRectangle const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_draw",1,SWIGTYPE_p_ofFbo); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ + SWIG_fail_ptr("Fbo_draw",2,SWIGTYPE_p_ofRectangle); } ((ofFbo const *)arg1)->draw((ofRectangle const &)*arg2); + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Fbo_draw__SWIG_0_2(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; glm::vec2 *arg2 = 0 ; + float arg3 ; float arg4 ; SWIG_check_num_args("draw",4,4) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("draw",1,"ofFbo const *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("draw",2,"glm::vec2 const &"); if(!lua_isnumber(L,3)) SWIG_fail_arg("draw",3,"float"); + if(!lua_isnumber(L,4)) SWIG_fail_arg("draw",4,"float"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_draw",1,SWIGTYPE_p_ofFbo); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("Fbo_draw",2,SWIGTYPE_p_glm__vec2); } + arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); + ((ofFbo const *)arg1)->draw((glm::vec2 const &)*arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_Fbo_draw__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; float arg2 ; float arg3 ; + SWIG_check_num_args("ofFbo::draw",3,3) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::draw",1,"ofFbo const *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofFbo::draw",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofFbo::draw",3,"float"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_draw",1,SWIGTYPE_p_ofFbo); } + arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); ((ofFbo const *)arg1)->draw(arg2,arg3); return SWIG_arg; + if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Fbo_draw__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; float arg2 ; float arg3 ; + float arg4 ; float arg5 ; SWIG_check_num_args("ofFbo::draw",5,5) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::draw",1,"ofFbo const *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofFbo::draw",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofFbo::draw",3,"float"); + if(!lua_isnumber(L,4)) SWIG_fail_arg("ofFbo::draw",4,"float"); if(!lua_isnumber(L,5)) SWIG_fail_arg("ofFbo::draw",5,"float"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_draw",1,SWIGTYPE_p_ofFbo); } + arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); + arg5 = (float)lua_tonumber(L, 5); ((ofFbo const *)arg1)->draw(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_Fbo_draw(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_Fbo_draw__SWIG_0_0(L);} check_1: + if (argc == 2) { return _wrap_Fbo_draw__SWIG_0_1(L);} if (argc == 3) { return _wrap_Fbo_draw__SWIG_1(L);} if (argc == 4) { + return _wrap_Fbo_draw__SWIG_0_2(L);} if (argc == 5) { return _wrap_Fbo_draw__SWIG_2(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Fbo_draw'\n" " Possible C/C++ prototypes are:\n" + " draw(glm::vec2 const &) const\n" " draw(ofRectangle const &) const\n" + " draw(glm::vec2 const &,float,float) const\n" " ofFbo::draw(float,float) const\n" + " ofFbo::draw(float,float,float,float) const\n"); lua_error(L);return 0; } +static int _wrap_Fbo_setAnchorPercent(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; float arg2 ; float arg3 ; + SWIG_check_num_args("ofFbo::setAnchorPercent",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::setAnchorPercent",1,"ofFbo *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofFbo::setAnchorPercent",2,"float"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("ofFbo::setAnchorPercent",3,"float"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ + SWIG_fail_ptr("Fbo_setAnchorPercent",1,SWIGTYPE_p_ofFbo); } arg2 = (float)lua_tonumber(L, 2); + arg3 = (float)lua_tonumber(L, 3); (arg1)->setAnchorPercent(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_Fbo_setAnchorPoint(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; float arg2 ; float arg3 ; + SWIG_check_num_args("ofFbo::setAnchorPoint",3,3) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::setAnchorPoint",1,"ofFbo *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofFbo::setAnchorPoint",2,"float"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("ofFbo::setAnchorPoint",3,"float"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ + SWIG_fail_ptr("Fbo_setAnchorPoint",1,SWIGTYPE_p_ofFbo); } arg2 = (float)lua_tonumber(L, 2); + arg3 = (float)lua_tonumber(L, 3); (arg1)->setAnchorPoint(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_Fbo_resetAnchor(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; + SWIG_check_num_args("ofFbo::resetAnchor",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::resetAnchor",1,"ofFbo *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_resetAnchor",1,SWIGTYPE_p_ofFbo); } + (arg1)->resetAnchor(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Fbo_setDefaultTextureIndex(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; int arg2 ; + SWIG_check_num_args("ofFbo::setDefaultTextureIndex",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::setDefaultTextureIndex",1,"ofFbo *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofFbo::setDefaultTextureIndex",2,"int"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ + SWIG_fail_ptr("Fbo_setDefaultTextureIndex",1,SWIGTYPE_p_ofFbo); } arg2 = (int)lua_tonumber(L, 2); + (arg1)->setDefaultTextureIndex(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Fbo_getDefaultTextureIndex(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; int result; + SWIG_check_num_args("ofFbo::getDefaultTextureIndex",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::getDefaultTextureIndex",1,"ofFbo const *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ + SWIG_fail_ptr("Fbo_getDefaultTextureIndex",1,SWIGTYPE_p_ofFbo); } + result = (int)((ofFbo const *)arg1)->getDefaultTextureIndex(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Fbo_getTexture__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; ofTexture *result = 0 ; + SWIG_check_num_args("ofFbo::getTexture",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::getTexture",1,"ofFbo *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_getTexture",1,SWIGTYPE_p_ofFbo); } + result = (ofTexture *) &(arg1)->getTexture(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTexture,0); SWIG_arg++; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Fbo_getTexture__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; int arg2 ; + ofTexture *result = 0 ; SWIG_check_num_args("ofFbo::getTexture",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::getTexture",1,"ofFbo *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofFbo::getTexture",2,"int"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_getTexture",1,SWIGTYPE_p_ofFbo); } + arg2 = (int)lua_tonumber(L, 2); result = (ofTexture *) &(arg1)->getTexture(arg2); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTexture,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_Fbo_getDepthTexture__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; + ofTexture *result = 0 ; SWIG_check_num_args("ofFbo::getDepthTexture",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::getDepthTexture",1,"ofFbo *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ + SWIG_fail_ptr("Fbo_getDepthTexture",1,SWIGTYPE_p_ofFbo); } result = (ofTexture *) &(arg1)->getDepthTexture(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTexture,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_Fbo_getTexture__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; ofTexture *result = 0 ; + SWIG_check_num_args("ofFbo::getTexture",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::getTexture",1,"ofFbo const *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_getTexture",1,SWIGTYPE_p_ofFbo); } + result = (ofTexture *) &((ofFbo const *)arg1)->getTexture(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTexture,0); SWIG_arg++; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Fbo_getTexture__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; int arg2 ; + ofTexture *result = 0 ; SWIG_check_num_args("ofFbo::getTexture",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::getTexture",1,"ofFbo const *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofFbo::getTexture",2,"int"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_getTexture",1,SWIGTYPE_p_ofFbo); } + arg2 = (int)lua_tonumber(L, 2); result = (ofTexture *) &((ofFbo const *)arg1)->getTexture(arg2); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTexture,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_Fbo_getTexture(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { + return _wrap_Fbo_getTexture__SWIG_0(L);} if (argc == 1) { return _wrap_Fbo_getTexture__SWIG_2(L);} if (argc == 2) { + return _wrap_Fbo_getTexture__SWIG_1(L);} if (argc == 2) { return _wrap_Fbo_getTexture__SWIG_3(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Fbo_getTexture'\n" " Possible C/C++ prototypes are:\n" + " ofFbo::getTexture()\n" " ofFbo::getTexture(int)\n" " ofFbo::getTexture() const\n" + " ofFbo::getTexture(int) const\n"); lua_error(L);return 0; } +static int _wrap_Fbo_getDepthTexture__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; + ofTexture *result = 0 ; SWIG_check_num_args("ofFbo::getDepthTexture",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::getDepthTexture",1,"ofFbo const *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ + SWIG_fail_ptr("Fbo_getDepthTexture",1,SWIGTYPE_p_ofFbo); } + result = (ofTexture *) &((ofFbo const *)arg1)->getDepthTexture(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTexture,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_Fbo_getDepthTexture(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { + return _wrap_Fbo_getDepthTexture__SWIG_0(L);} if (argc == 1) { return _wrap_Fbo_getDepthTexture__SWIG_1(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Fbo_getDepthTexture'\n" + " Possible C/C++ prototypes are:\n" " ofFbo::getDepthTexture()\n" " ofFbo::getDepthTexture() const\n"); + lua_error(L);return 0; } +static int _wrap_Fbo_beginFbo__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; ofFboMode arg2 ; + SWIG_check_num_args("ofFbo::begin",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::begin",1,"ofFbo *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofFbo::begin",2,"ofFboMode"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_beginFbo",1,SWIGTYPE_p_ofFbo); } + arg2 = (ofFboMode)(int)lua_tonumber(L, 2); (arg1)->begin(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_Fbo_beginFbo__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; + SWIG_check_num_args("ofFbo::begin",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::begin",1,"ofFbo *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_beginFbo",1,SWIGTYPE_p_ofFbo); } + (arg1)->begin(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Fbo_beginFbo(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { + return _wrap_Fbo_beginFbo__SWIG_1(L);} if (argc == 2) { return _wrap_Fbo_beginFbo__SWIG_0(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Fbo_beginFbo'\n" " Possible C/C++ prototypes are:\n" + " ofFbo::begin(ofFboMode)\n" " ofFbo::begin()\n"); lua_error(L);return 0; } +static int _wrap_Fbo_endFbo(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; SWIG_check_num_args("ofFbo::end",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::end",1,"ofFbo const *"); if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_endFbo",1,SWIGTYPE_p_ofFbo); } ((ofFbo const *)arg1)->end(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } @@ -5267,33 +5620,19 @@ static int _wrap_Fbo_readToPixels__SWIG_5(lua_State* L) { int SWIG_arg = 0; ofFb SWIG_fail_ptr("Fbo_readToPixels",2,SWIGTYPE_p_ofPixels_T_float_t); } ((ofFbo const *)arg1)->readToPixels(*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Fbo_readToPixels(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Fbo_readToPixels__SWIG_1(L);} } } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Fbo_readToPixels__SWIG_3(L);} } } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Fbo_readToPixels__SWIG_5(L);} } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Fbo_readToPixels__SWIG_0(L);} } } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Fbo_readToPixels__SWIG_4(L);} } } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Fbo_readToPixels__SWIG_2(L);} } } } + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_Fbo_readToPixels__SWIG_1(L);} check_1: + if (argc == 2) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_Fbo_readToPixels__SWIG_3(L);} check_2: + if (argc == 2) { return _wrap_Fbo_readToPixels__SWIG_5(L);} if (argc == 3) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_4; return _wrap_Fbo_readToPixels__SWIG_0(L);} check_4: + if (argc == 3) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_5; return _wrap_Fbo_readToPixels__SWIG_4(L);} check_5: + if (argc == 3) { return _wrap_Fbo_readToPixels__SWIG_2(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Fbo_readToPixels'\n" " Possible C/C++ prototypes are:\n" " ofFbo::readToPixels(ofPixels &,int) const\n" " ofFbo::readToPixels(ofPixels &) const\n" " ofFbo::readToPixels(ofShortPixels &,int) const\n" " ofFbo::readToPixels(ofShortPixels &) const\n" @@ -5403,16 +5742,8 @@ static int _wrap_Fbo_createAndAttachDepthStencilTexture__SWIG_1(lua_State* L) { arg6 = (GLenum)lua_tonumber(L, 6); (arg1)->createAndAttachDepthStencilTexture(arg2,arg3,arg4,arg5,arg6); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Fbo_createAndAttachDepthStencilTexture(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; - argc = lua_gettop(L); if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Fbo_createAndAttachDepthStencilTexture__SWIG_0(L);} } } } - } if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { return _wrap_Fbo_createAndAttachDepthStencilTexture__SWIG_1(L);} } } - } } } } + argc = lua_gettop(L); if (argc == 4) { return _wrap_Fbo_createAndAttachDepthStencilTexture__SWIG_0(L);} if (argc == 6) { + return _wrap_Fbo_createAndAttachDepthStencilTexture__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Fbo_createAndAttachDepthStencilTexture'\n" " Possible C/C++ prototypes are:\n" " ofFbo::createAndAttachDepthStencilTexture(GLenum,GLint,GLenum)\n" " ofFbo::createAndAttachDepthStencilTexture(GLenum,GLint,GLenum,GLenum,GLenum)\n"); lua_error(L);return 0; } @@ -5480,68 +5811,6 @@ static int _wrap_Fbo_getStencilBuffer(lua_State* L) { int SWIG_arg = 0; ofFbo *a if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_getStencilBuffer",1,SWIGTYPE_p_ofFbo); } result = (GLuint)((ofFbo const *)arg1)->getStencilBuffer(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_allocated_get(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; bool result; - SWIG_check_num_args("ofFbo::allocated",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::allocated",1,"ofFbo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ - SWIG_fail_ptr("Fbo_allocated_get",1,SWIGTYPE_p_ofFbo); } result = (bool)ofFbo_allocated_get(arg1); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_defaultTexture_set(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; int arg2 ; - SWIG_check_num_args("ofFbo::defaultTexture",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::defaultTexture",1,"ofFbo *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofFbo::defaultTexture",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ - SWIG_fail_ptr("Fbo_defaultTexture_set",1,SWIGTYPE_p_ofFbo); } arg2 = (int)lua_tonumber(L, 2); - ofFbo_defaultTexture_set(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_defaultTexture_get(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; int result; - SWIG_check_num_args("ofFbo::defaultTexture",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::defaultTexture",1,"ofFbo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ - SWIG_fail_ptr("Fbo_defaultTexture_get",1,SWIGTYPE_p_ofFbo); } result = (int)ofFbo_defaultTexture_get(arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_texture_get(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; ofTexture *result = 0 ; - SWIG_check_num_args("ofFbo::texture",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::texture",1,"ofFbo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_texture_get",1,SWIGTYPE_p_ofFbo); } - result = (ofTexture *) &ofFbo_texture_get(arg1); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTexture,0); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_depthTexture_get(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; ofTexture *result = 0 ; - SWIG_check_num_args("ofFbo::depthTexture",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::depthTexture",1,"ofFbo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ - SWIG_fail_ptr("Fbo_depthTexture_get",1,SWIGTYPE_p_ofFbo); } result = (ofTexture *) &ofFbo_depthTexture_get(arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTexture,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Fbo_width_get(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; float result; - SWIG_check_num_args("ofFbo::width",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::width",1,"ofFbo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_width_get",1,SWIGTYPE_p_ofFbo); } - result = (float)ofFbo_width_get(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_height_get(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; float result; - SWIG_check_num_args("ofFbo::height",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::height",1,"ofFbo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_height_get",1,SWIGTYPE_p_ofFbo); } - result = (float)ofFbo_height_get(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_numTextures_get(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; int result; - SWIG_check_num_args("ofFbo::numTextures",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::numTextures",1,"ofFbo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ - SWIG_fail_ptr("Fbo_numTextures_get",1,SWIGTYPE_p_ofFbo); } result = (int)ofFbo_numTextures_get(arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_id_get(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; unsigned int result; - SWIG_check_num_args("ofFbo::id",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::id",1,"ofFbo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_id_get",1,SWIGTYPE_p_ofFbo); } - result = (unsigned int)ofFbo_id_get(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_idDrawBuffer_get(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; unsigned int result; - SWIG_check_num_args("ofFbo::idDrawBuffer",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::idDrawBuffer",1,"ofFbo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ - SWIG_fail_ptr("Fbo_idDrawBuffer_get",1,SWIGTYPE_p_ofFbo); } result = (unsigned int)ofFbo_idDrawBuffer_get(arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_depthBuffer_get(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; unsigned int result; - SWIG_check_num_args("ofFbo::depthBuffer",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::depthBuffer",1,"ofFbo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ - SWIG_fail_ptr("Fbo_depthBuffer_get",1,SWIGTYPE_p_ofFbo); } result = (unsigned int)ofFbo_depthBuffer_get(arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_stencilBuffer_get(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; unsigned int result; - SWIG_check_num_args("ofFbo::stencilBuffer",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::stencilBuffer",1,"ofFbo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ - SWIG_fail_ptr("Fbo_stencilBuffer_get",1,SWIGTYPE_p_ofFbo); } result = (unsigned int)ofFbo_stencilBuffer_get(arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static void swig_delete_Fbo(void *obj) { ofFbo *arg1 = (ofFbo *) obj; delete arg1; @@ -5555,17 +5824,6 @@ static int _proxy__wrap_new_Fbo(lua_State *L) { return 1; } static swig_lua_attribute swig_Fbo_attributes[] = { - { "allocated", _wrap_Fbo_allocated_get, SWIG_Lua_set_immutable }, - { "defaultTexture", _wrap_Fbo_defaultTexture_get, _wrap_Fbo_defaultTexture_set }, - { "texture", _wrap_Fbo_texture_get, SWIG_Lua_set_immutable }, - { "depthTexture", _wrap_Fbo_depthTexture_get, SWIG_Lua_set_immutable }, - { "width", _wrap_Fbo_width_get, SWIG_Lua_set_immutable }, - { "height", _wrap_Fbo_height_get, SWIG_Lua_set_immutable }, - { "numTextures", _wrap_Fbo_numTextures_get, SWIG_Lua_set_immutable }, - { "id", _wrap_Fbo_id_get, SWIG_Lua_set_immutable }, - { "idDrawBuffer", _wrap_Fbo_idDrawBuffer_get, SWIG_Lua_set_immutable }, - { "depthBuffer", _wrap_Fbo_depthBuffer_get, SWIG_Lua_set_immutable }, - { "stencilBuffer", _wrap_Fbo_stencilBuffer_get, SWIG_Lua_set_immutable }, {0,0,0} }; static swig_lua_method swig_Fbo_methods[]= { @@ -5972,9 +6230,7 @@ static int _wrap_new_Texture__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofTexture SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTexture,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_new_Texture(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_Texture__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_new_Texture__SWIG_1(L);} } + return _wrap_new_Texture__SWIG_0(L);} if (argc == 1) { return _wrap_new_Texture__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_Texture'\n" " Possible C/C++ prototypes are:\n" " ofTexture::ofTexture()\n" " ofTexture::ofTexture(ofTexture &&)\n"); lua_error(L);return 0; } static int _wrap_Texture_allocate__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; @@ -6103,61 +6359,26 @@ static int _wrap_Texture_allocate__SWIG_11(lua_State* L) { int SWIG_arg = 0; ofT SWIG_fail_ptr("Texture_allocate",2,SWIGTYPE_p_ofPixels_T_float_t); } arg3 = (lua_toboolean(L, 3)!=0); (arg1)->allocate((ofFloatPixels const &)*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Texture_allocate(lua_State* L) { int argc; int argv[8]={ 1,2,3,4,5,6,7,8} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofTextureData, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Texture_allocate__SWIG_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Texture_allocate__SWIG_6(L);} } } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Texture_allocate__SWIG_8(L);} } } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Texture_allocate__SWIG_10(L);} } } if (argc == 3) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - return _wrap_Texture_allocate__SWIG_9(L);} } } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - return _wrap_Texture_allocate__SWIG_7(L);} } } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - return _wrap_Texture_allocate__SWIG_11(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofTextureData, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Texture_allocate__SWIG_1(L);} } } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Texture_allocate__SWIG_2(L);} } } } } if (argc == 5) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isboolean(L,argv[4]); } if (_v) { - return _wrap_Texture_allocate__SWIG_4(L);} } } } } } if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { return _wrap_Texture_allocate__SWIG_3(L);} } } } } } } - if (argc == 7) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isboolean(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { - return _wrap_Texture_allocate__SWIG_5(L);} } } } } } } } + if (argc == 2) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofTextureData, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_Texture_allocate__SWIG_0(L);} check_1: + if (argc == 2) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_Texture_allocate__SWIG_6(L);} check_2: + if (argc == 2) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; return _wrap_Texture_allocate__SWIG_8(L);} check_3: + if (argc == 2) { return _wrap_Texture_allocate__SWIG_10(L);} if (argc == 3) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_5; return _wrap_Texture_allocate__SWIG_9(L);} check_5: + if (argc == 3) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_6; return _wrap_Texture_allocate__SWIG_7(L);} check_6: + if (argc == 3) { return _wrap_Texture_allocate__SWIG_11(L);} if (argc == 4) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofTextureData, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_8; return _wrap_Texture_allocate__SWIG_1(L);} check_8: + if (argc == 4) { return _wrap_Texture_allocate__SWIG_2(L);} if (argc == 5) { return _wrap_Texture_allocate__SWIG_4(L);} + if (argc == 6) { return _wrap_Texture_allocate__SWIG_3(L);} if (argc == 7) { return _wrap_Texture_allocate__SWIG_5(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Texture_allocate'\n" " Possible C/C++ prototypes are:\n" " ofTexture::allocate(ofTextureData const &)\n" " ofTexture::allocate(ofTextureData const &,int,int)\n" " ofTexture::allocate(int,int,int)\n" " ofTexture::allocate(int,int,int,int,int)\n" @@ -6369,87 +6590,38 @@ static int _wrap_Texture_loadData__SWIG_14(lua_State* L) { int SWIG_arg = 0; ofT arg4 = (int)lua_tonumber(L, 4); (arg1)->loadData((ofBufferObject const &)*arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Texture_loadData(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Texture_loadData__SWIG_7(L);} } } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Texture_loadData__SWIG_8(L);} } } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Texture_loadData__SWIG_9(L);} } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Texture_loadData__SWIG_10(L);} } } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Texture_loadData__SWIG_11(L);} } } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Texture_loadData__SWIG_12(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBufferObject, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Texture_loadData__SWIG_14(L);} } } } } if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; + if (argc == 2) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_Texture_loadData__SWIG_7(L);} check_1: + if (argc == 2) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_Texture_loadData__SWIG_8(L);} check_2: + if (argc == 2) { return _wrap_Texture_loadData__SWIG_9(L);} if (argc == 3) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_4; return _wrap_Texture_loadData__SWIG_10(L);} check_4: + if (argc == 3) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_5; return _wrap_Texture_loadData__SWIG_11(L);} check_5: + if (argc == 3) { return _wrap_Texture_loadData__SWIG_12(L);} if (argc == 4) { return _wrap_Texture_loadData__SWIG_14(L);} + if (argc == 5) { int _v = 0; { { void *ptr; if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_uint8_t, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_Texture_loadData__SWIG_0(L);} } } } } } - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; + else { _v = 1; } } } if (!_v) goto check_8; return _wrap_Texture_loadData__SWIG_0(L);} check_8: if (argc == 5) { + int _v = 0; { { void *ptr; if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_uint16_t, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_Texture_loadData__SWIG_1(L);} } } } } } - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; + else { _v = 1; } } } if (!_v) goto check_9; return _wrap_Texture_loadData__SWIG_1(L);} check_9: if (argc == 5) { + int _v = 0; { { void *ptr; if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_uint32_t, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_Texture_loadData__SWIG_2(L);} } } } } } - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; + else { _v = 1; } } } if (!_v) goto check_10; return _wrap_Texture_loadData__SWIG_2(L);} check_10: if (argc == 5) { + int _v = 0; { { void *ptr; if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_int8_t, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_Texture_loadData__SWIG_3(L);} } } } } } - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; + else { _v = 1; } } } if (!_v) goto check_11; return _wrap_Texture_loadData__SWIG_3(L);} check_11: if (argc == 5) { + int _v = 0; { { void *ptr; if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_int16_t, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_Texture_loadData__SWIG_4(L);} } } } } } - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; + else { _v = 1; } } } if (!_v) goto check_12; return _wrap_Texture_loadData__SWIG_4(L);} check_12: if (argc == 5) { + int _v = 0; { { void *ptr; if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_int32_t, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_Texture_loadData__SWIG_5(L);} } } } } } - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_Texture_loadData__SWIG_6(L);} } } } } } - if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, 0, 0)) { _v = 0; } else { _v = 1; } } - if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { - return _wrap_Texture_loadData__SWIG_13(L);} } } } } } } + else { _v = 1; } } } if (!_v) goto check_13; return _wrap_Texture_loadData__SWIG_5(L);} check_13: if (argc == 5) { + return _wrap_Texture_loadData__SWIG_6(L);} if (argc == 6) { return _wrap_Texture_loadData__SWIG_13(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Texture_loadData'\n" " Possible C/C++ prototypes are:\n" " ofTexture::loadData(uint8_t const *const,int,int,int)\n" " ofTexture::loadData(uint16_t const *,int,int,int)\n" " ofTexture::loadData(uint32_t const *,int,int,int)\n" " ofTexture::loadData(int8_t const *,int,int,int)\n" @@ -6470,6 +6642,33 @@ static int _wrap_Texture_loadScreenData(lua_State* L) { int SWIG_arg = 0; ofText SWIG_fail_ptr("Texture_loadScreenData",1,SWIGTYPE_p_ofTexture); } arg2 = (int)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); (arg1)->loadScreenData(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Texture_draw__SWIG_0_0(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; + glm::vec2 *arg2 = 0 ; SWIG_check_num_args("draw",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("draw",1,"ofTexture const *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("draw",2,"glm::vec2 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ + SWIG_fail_ptr("Texture_draw",1,SWIGTYPE_p_ofTexture); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec2,0))){ + SWIG_fail_ptr("Texture_draw",2,SWIGTYPE_p_glm__vec2); } ((ofTexture const *)arg1)->draw((glm::vec2 const &)*arg2); + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Texture_draw__SWIG_0_1(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; + ofRectangle *arg2 = 0 ; SWIG_check_num_args("draw",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("draw",1,"ofTexture const *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("draw",2,"ofRectangle const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ + SWIG_fail_ptr("Texture_draw",1,SWIGTYPE_p_ofTexture); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ + SWIG_fail_ptr("Texture_draw",2,SWIGTYPE_p_ofRectangle); } ((ofTexture const *)arg1)->draw((ofRectangle const &)*arg2); + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Texture_draw__SWIG_0_2(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; + glm::vec2 *arg2 = 0 ; float arg3 ; float arg4 ; SWIG_check_num_args("draw",4,4) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("draw",1,"ofTexture const *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("draw",2,"glm::vec2 const &"); if(!lua_isnumber(L,3)) SWIG_fail_arg("draw",3,"float"); + if(!lua_isnumber(L,4)) SWIG_fail_arg("draw",4,"float"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ + SWIG_fail_ptr("Texture_draw",1,SWIGTYPE_p_ofTexture); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec2,0))){ + SWIG_fail_ptr("Texture_draw",2,SWIGTYPE_p_glm__vec2); } arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); + ((ofTexture const *)arg1)->draw((glm::vec2 const &)*arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } static int _wrap_Texture_draw__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; float arg2 ; float arg3 ; SWIG_check_num_args("ofTexture::draw",3,3) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::draw",1,"ofTexture const *"); @@ -6553,46 +6752,35 @@ static int _wrap_Texture_draw__SWIG_7(lua_State* L) { int SWIG_arg = 0; ofTextur ((ofTexture const *)arg1)->draw((glm::vec3 const &)*arg2,(glm::vec3 const &)*arg3,(glm::vec3 const &)*arg4,(glm::vec3 const &)*arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Texture_draw(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Texture_draw__SWIG_3(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Texture_draw__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Texture_draw__SWIG_6(L);} } } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Texture_draw__SWIG_2(L);} } } } } if (argc == 5) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[4])==0 || SWIG_ConvertPtr(L,argv[4], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Texture_draw__SWIG_7(L);} } } } } } - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Texture_draw__SWIG_4(L);} } } } } } if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { return _wrap_Texture_draw__SWIG_5(L);} } } } } } } + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_Texture_draw__SWIG_0_0(L);} check_1: + if (argc == 2) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_Texture_draw__SWIG_0_1(L);} check_2: + if (argc == 2) { return _wrap_Texture_draw__SWIG_3(L);} if (argc == 3) { return _wrap_Texture_draw__SWIG_1(L);} + if (argc == 4) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_5; return _wrap_Texture_draw__SWIG_0_2(L);} check_5: + if (argc == 4) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_6; return _wrap_Texture_draw__SWIG_6(L);} check_6: + if (argc == 4) { return _wrap_Texture_draw__SWIG_2(L);} if (argc == 5) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_8; { { void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_8; { { void *ptr; + if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_8; { { void *ptr; + if (lua_isuserdata(L,argv[4])==0 || SWIG_ConvertPtr(L,argv[4], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_8; return _wrap_Texture_draw__SWIG_7(L);} check_8: + if (argc == 5) { return _wrap_Texture_draw__SWIG_4(L);} if (argc == 6) { return _wrap_Texture_draw__SWIG_5(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Texture_draw'\n" " Possible C/C++ prototypes are:\n" - " ofTexture::draw()\n" " ofTexture::draw(float,float) const\n" " ofTexture::draw(float,float,float) const\n" - " ofTexture::draw(glm::vec3 const &) const\n" " ofTexture::draw(float,float,float,float) const\n" - " ofTexture::draw(float,float,float,float,float) const\n" " ofTexture::draw(glm::vec3 const &,float,float) const\n" + " draw(glm::vec2 const &) const\n" " draw(ofRectangle const &) const\n" + " draw(glm::vec2 const &,float,float) const\n" " ofTexture::draw(float,float) const\n" + " ofTexture::draw(float,float,float) const\n" " ofTexture::draw(glm::vec3 const &) const\n" + " ofTexture::draw(float,float,float,float) const\n" " ofTexture::draw(float,float,float,float,float) const\n" + " ofTexture::draw(glm::vec3 const &,float,float) const\n" " ofTexture::draw(glm::vec3 const &,glm::vec3 const &,glm::vec3 const &,glm::vec3 const &) const\n"); lua_error(L);return 0; } static int _wrap_Texture_drawSubsection__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; @@ -6680,46 +6868,18 @@ static int _wrap_Texture_drawSubsection__SWIG_4(lua_State* L) { int SWIG_arg = 0 ((ofTexture const *)arg1)->drawSubsection(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Texture_drawSubsection(lua_State* L) { int argc; int argv[11]={ 1,2,3,4,5,6,7,8,9,10,11} ; - argc = lua_gettop(L); if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Texture_drawSubsection__SWIG_3(L);} } } } if (argc == 7) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { - return _wrap_Texture_drawSubsection__SWIG_0(L);} } } } } } } } if (argc == 8) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { return _wrap_Texture_drawSubsection__SWIG_1(L);} } } } } } } - } } if (argc == 9) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { { _v = lua_isnumber(L,argv[8]); } if (_v) { - return _wrap_Texture_drawSubsection__SWIG_2(L);} } } } } } } } } } if (argc == 10) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { { _v = lua_isnumber(L,argv[8]); } if (_v) { { - _v = lua_isnumber(L,argv[9]); } if (_v) { return _wrap_Texture_drawSubsection__SWIG_4(L);} } } } } - } } } } } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Texture_drawSubsection'\n" + argc = lua_gettop(L); if (argc == 3) { return _wrap_Texture_drawSubsection__SWIG_3(L);} if (argc == 7) { + return _wrap_Texture_drawSubsection__SWIG_0(L);} if (argc == 8) { return _wrap_Texture_drawSubsection__SWIG_1(L);} + if (argc == 9) { return _wrap_Texture_drawSubsection__SWIG_2(L);} if (argc == 10) { + return _wrap_Texture_drawSubsection__SWIG_4(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Texture_drawSubsection'\n" " Possible C/C++ prototypes are:\n" " ofTexture::drawSubsection(float,float,float,float,float,float) const\n" " ofTexture::drawSubsection(float,float,float,float,float,float,float) const\n" " ofTexture::drawSubsection(float,float,float,float,float,float,float,float) const\n" " ofTexture::drawSubsection(ofRectangle const &,ofRectangle const &) const\n" " ofTexture::drawSubsection(float,float,float,float,float,float,float,float,float) const\n"); lua_error(L);return 0; } static int _wrap_Texture_getQuad(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; glm::vec3 *arg2 = 0 ; - glm::vec3 *arg3 = 0 ; glm::vec3 *arg4 = 0 ; glm::vec3 *arg5 = 0 ; - SwigValueWrapper< ofMesh_< glm::vec3,glm::vec3,ofColor_< float >,glm::vec2 > > result; - SWIG_check_num_args("ofTexture::getQuad",5,5) + glm::vec3 *arg3 = 0 ; glm::vec3 *arg4 = 0 ; glm::vec3 *arg5 = 0 ; ofMesh result; SWIG_check_num_args("ofTexture::getQuad",5,5) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::getQuad",1,"ofTexture const *"); if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofTexture::getQuad",2,"glm::vec3 const &"); if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofTexture::getQuad",3,"glm::vec3 const &"); @@ -6737,12 +6897,11 @@ static int _wrap_Texture_getQuad(lua_State* L) { int SWIG_arg = 0; ofTexture *ar SWIG_fail_ptr("Texture_getQuad",5,SWIGTYPE_p_glm__vec3); } result = ((ofTexture const *)arg1)->getQuad((glm::vec3 const &)*arg2,(glm::vec3 const &)*arg3,(glm::vec3 const &)*arg4,(glm::vec3 const &)*arg5); { ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh_T_glm__vec3_glm__vec3_ofColor_T_float_t_glm__vec2_t,1); SWIG_arg++; } + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Texture_getMeshForSubsection(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; float arg2 ; float arg3 ; float arg4 ; float arg5 ; float arg6 ; float arg7 ; float arg8 ; float arg9 ; float arg10 ; bool arg11 ; - ofRectMode arg12 ; SwigValueWrapper< ofMesh_< glm::vec3,glm::vec3,ofColor_< float >,glm::vec2 > > result; - SWIG_check_num_args("ofTexture::getMeshForSubsection",12,12) + ofRectMode arg12 ; ofMesh result; SWIG_check_num_args("ofTexture::getMeshForSubsection",12,12) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::getMeshForSubsection",1,"ofTexture const *"); if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTexture::getMeshForSubsection",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTexture::getMeshForSubsection",3,"float"); @@ -6763,7 +6922,7 @@ static int _wrap_Texture_getMeshForSubsection(lua_State* L) { int SWIG_arg = 0; arg12 = (ofRectMode)(int)lua_tonumber(L, 12); result = ((ofTexture const *)arg1)->getMeshForSubsection(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12); { ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh_T_glm__vec3_glm__vec3_ofColor_T_float_t_glm__vec2_t,1); SWIG_arg++; } + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Texture_bind__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; int arg2 ; SWIG_check_num_args("ofTexture::bind",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::bind",1,"ofTexture const *"); @@ -6776,12 +6935,8 @@ static int _wrap_Texture_bind__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofTextur if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ SWIG_fail_ptr("Texture_bind",1,SWIGTYPE_p_ofTexture); } ((ofTexture const *)arg1)->bind(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_bind(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Texture_bind__SWIG_1(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Texture_bind__SWIG_0(L);} } } +static int _wrap_Texture_bind(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { + return _wrap_Texture_bind__SWIG_1(L);} if (argc == 2) { return _wrap_Texture_bind__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Texture_bind'\n" " Possible C/C++ prototypes are:\n" " ofTexture::bind(int) const\n" " ofTexture::bind() const\n"); lua_error(L);return 0; } static int _wrap_Texture_unbind__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; int arg2 ; @@ -6797,12 +6952,8 @@ static int _wrap_Texture_unbind__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofText if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ SWIG_fail_ptr("Texture_unbind",1,SWIGTYPE_p_ofTexture); } ((ofTexture const *)arg1)->unbind(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_unbind(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Texture_unbind__SWIG_1(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Texture_unbind__SWIG_0(L);} } } +static int _wrap_Texture_unbind(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { + return _wrap_Texture_unbind__SWIG_1(L);} if (argc == 2) { return _wrap_Texture_unbind__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Texture_unbind'\n" " Possible C/C++ prototypes are:\n" " ofTexture::unbind(int) const\n" " ofTexture::unbind() const\n"); lua_error(L);return 0; } static int _wrap_Texture_getAlphaMask(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; @@ -6986,21 +7137,13 @@ static int _wrap_Texture_readToPixels__SWIG_2(lua_State* L) { int SWIG_arg = 0; SWIG_fail_ptr("Texture_readToPixels",2,SWIGTYPE_p_ofPixels_T_float_t); } ((ofTexture const *)arg1)->readToPixels(*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Texture_readToPixels(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Texture_readToPixels__SWIG_0(L);} } } if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Texture_readToPixels__SWIG_1(L);} } } if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Texture_readToPixels__SWIG_2(L);} } } + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_Texture_readToPixels__SWIG_0(L);} check_1: + if (argc == 2) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_Texture_readToPixels__SWIG_1(L);} check_2: + if (argc == 2) { return _wrap_Texture_readToPixels__SWIG_2(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Texture_readToPixels'\n" " Possible C/C++ prototypes are:\n" " ofTexture::readToPixels(ofPixels &) const\n" " ofTexture::readToPixels(ofShortPixels &) const\n" " ofTexture::readToPixels(ofFloatPixels &) const\n"); @@ -7030,11 +7173,7 @@ static int _wrap_Texture_getTextureData__SWIG_1(lua_State* L) { int SWIG_arg = 0 SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTextureData,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Texture_getTextureData(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Texture_getTextureData__SWIG_0(L);} } if (argc == 1) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Texture_getTextureData__SWIG_1(L);} } + return _wrap_Texture_getTextureData__SWIG_0(L);} if (argc == 1) { return _wrap_Texture_getTextureData__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Texture_getTextureData'\n" " Possible C/C++ prototypes are:\n" " ofTexture::getTextureData()\n" " ofTexture::getTextureData() const\n"); lua_error(L);return 0; } @@ -7062,52 +7201,20 @@ static int _wrap_Texture_hasMipmap(lua_State* L) { int SWIG_arg = 0; ofTexture * if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ SWIG_fail_ptr("Texture_hasMipmap",1,SWIGTYPE_p_ofTexture); } result = (bool)((ofTexture const *)arg1)->hasMipmap(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_allocated_get(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; bool result; - SWIG_check_num_args("ofTexture::allocated",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::allocated",1,"ofTexture *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_allocated_get",1,SWIGTYPE_p_ofTexture); } result = (bool)ofTexture_allocated_get(arg1); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_width_get(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; float result; - SWIG_check_num_args("ofTexture::width",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::width",1,"ofTexture *"); +static int _wrap_Texture_texData_set(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; + ofTextureData *arg2 = (ofTextureData *) 0 ; SWIG_check_num_args("ofTexture::texData",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::texData",1,"ofTexture *"); + if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofTexture::texData",2,"ofTextureData *"); if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_width_get",1,SWIGTYPE_p_ofTexture); } result = (float)ofTexture_width_get(arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_height_get(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; float result; - SWIG_check_num_args("ofTexture::height",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::height",1,"ofTexture *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_height_get",1,SWIGTYPE_p_ofTexture); } result = (float)ofTexture_height_get(arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_textureMatrix_set(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - ofMatrix4x4 *arg2 = 0 ; SWIG_check_num_args("ofTexture::textureMatrix",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::textureMatrix",1,"ofTexture *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofTexture::textureMatrix",2,"ofMatrix4x4 &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_textureMatrix_set",1,SWIGTYPE_p_ofTexture); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Texture_textureMatrix_set",2,SWIGTYPE_p_ofMatrix4x4); } ofTexture_textureMatrix_set(arg1,*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_textureMatrix_get(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - ofMatrix4x4 *result = 0 ; SWIG_check_num_args("ofTexture::textureMatrix",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::textureMatrix",1,"ofTexture *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_textureMatrix_get",1,SWIGTYPE_p_ofTexture); } - result = (ofMatrix4x4 *) &ofTexture_textureMatrix_get(arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMatrix4x4,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Texture_usingTextureMatrix_get(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - bool result; SWIG_check_num_args("ofTexture::usingTextureMatrix",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::usingTextureMatrix",1,"ofTexture *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_usingTextureMatrix_get",1,SWIGTYPE_p_ofTexture); } - result = (bool)ofTexture_usingTextureMatrix_get(arg1); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; + SWIG_fail_ptr("Texture_texData_set",1,SWIGTYPE_p_ofTexture); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofTextureData,0))){ + SWIG_fail_ptr("Texture_texData_set",2,SWIGTYPE_p_ofTextureData); } if (arg1) (arg1)->texData = *arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_textureData_get(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - ofTextureData *result = 0 ; SWIG_check_num_args("ofTexture::textureData",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::textureData",1,"ofTexture *"); +static int _wrap_Texture_texData_get(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; + ofTextureData *result = 0 ; SWIG_check_num_args("ofTexture::texData",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::texData",1,"ofTexture *"); if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_textureData_get",1,SWIGTYPE_p_ofTexture); } - result = (ofTextureData *) &ofTexture_textureData_get(arg1); + SWIG_fail_ptr("Texture_texData_get",1,SWIGTYPE_p_ofTexture); } result = (ofTextureData *)& ((arg1)->texData); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTextureData,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static void swig_delete_Texture(void *obj) { @@ -7123,12 +7230,7 @@ static int _proxy__wrap_new_Texture(lua_State *L) { return 1; } static swig_lua_attribute swig_Texture_attributes[] = { - { "allocated", _wrap_Texture_allocated_get, SWIG_Lua_set_immutable }, - { "width", _wrap_Texture_width_get, SWIG_Lua_set_immutable }, - { "height", _wrap_Texture_height_get, SWIG_Lua_set_immutable }, - { "textureMatrix", _wrap_Texture_textureMatrix_get, _wrap_Texture_textureMatrix_set }, - { "usingTextureMatrix", _wrap_Texture_usingTextureMatrix_get, SWIG_Lua_set_immutable }, - { "textureData", _wrap_Texture_textureData_get, SWIG_Lua_set_immutable }, + { "texData", _wrap_Texture_texData_get, _wrap_Texture_texData_set }, {0,0,0} }; static swig_lua_method swig_Texture_methods[]= { @@ -7319,6 +7421,454 @@ static swig_lua_class *swig_ImageLoadSettings_bases[] = {0}; static const char *swig_ImageLoadSettings_base_names[] = {0}; static swig_lua_class _wrap_class_ImageLoadSettings = { "ImageLoadSettings", "ImageLoadSettings", &SWIGTYPE_p_ofImageLoadSettings,_proxy__wrap_new_ImageLoadSettings, swig_delete_ImageLoadSettings, swig_ImageLoadSettings_methods, swig_ImageLoadSettings_attributes, &swig_ImageLoadSettings_Sf_SwigStatic, swig_ImageLoadSettings_meta, swig_ImageLoadSettings_bases, swig_ImageLoadSettings_base_names }; +static int _wrap_loadImage__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPixels *arg1 = 0 ; std::filesystem::path *arg2 = 0 ; + ofImageLoadSettings *arg3 = 0 ; std::filesystem::path temp2 ; bool result; SWIG_check_num_args("ofLoadImage",3,3) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofLoadImage",1,"ofPixels &"); + if(!lua_isstring(L,2)) SWIG_fail_arg("ofLoadImage",2,"std::filesystem::path const &"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofLoadImage",3,"ofImageLoadSettings const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ + SWIG_fail_ptr("loadImage",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } { size_t len = lua_rawlen(L, 2); + temp2 = lua_tolstring(L, 2, &len); arg2 = &temp2; } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofImageLoadSettings,0))){ + SWIG_fail_ptr("loadImage",3,SWIGTYPE_p_ofImageLoadSettings); } + result = (bool)ofLoadImage(*arg1,(boost::filesystem::path const &)*arg2,(ofImageLoadSettings const &)*arg3); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_loadImage__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPixels *arg1 = 0 ; std::filesystem::path *arg2 = 0 ; + std::filesystem::path temp2 ; bool result; SWIG_check_num_args("ofLoadImage",2,2) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofLoadImage",1,"ofPixels &"); + if(!lua_isstring(L,2)) SWIG_fail_arg("ofLoadImage",2,"std::filesystem::path const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ + SWIG_fail_ptr("loadImage",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } { size_t len = lua_rawlen(L, 2); + temp2 = lua_tolstring(L, 2, &len); arg2 = &temp2; } + result = (bool)ofLoadImage(*arg1,(boost::filesystem::path const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_loadImage__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPixels *arg1 = 0 ; ofBuffer *arg2 = 0 ; + ofImageLoadSettings *arg3 = 0 ; bool result; SWIG_check_num_args("ofLoadImage",3,3) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofLoadImage",1,"ofPixels &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofLoadImage",2,"ofBuffer const &"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofLoadImage",3,"ofImageLoadSettings const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ + SWIG_fail_ptr("loadImage",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBuffer,0))){ SWIG_fail_ptr("loadImage",2,SWIGTYPE_p_ofBuffer); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofImageLoadSettings,0))){ + SWIG_fail_ptr("loadImage",3,SWIGTYPE_p_ofImageLoadSettings); } + result = (bool)ofLoadImage(*arg1,(ofBuffer const &)*arg2,(ofImageLoadSettings const &)*arg3); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_loadImage__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofPixels *arg1 = 0 ; ofBuffer *arg2 = 0 ; bool result; + SWIG_check_num_args("ofLoadImage",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofLoadImage",1,"ofPixels &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofLoadImage",2,"ofBuffer const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ + SWIG_fail_ptr("loadImage",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBuffer,0))){ SWIG_fail_ptr("loadImage",2,SWIGTYPE_p_ofBuffer); } + result = (bool)ofLoadImage(*arg1,(ofBuffer const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; + if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_loadImage__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofFloatPixels *arg1 = 0 ; std::filesystem::path *arg2 = 0 ; + ofImageLoadSettings *arg3 = 0 ; std::filesystem::path temp2 ; bool result; SWIG_check_num_args("ofLoadImage",3,3) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofLoadImage",1,"ofFloatPixels &"); + if(!lua_isstring(L,2)) SWIG_fail_arg("ofLoadImage",2,"std::filesystem::path const &"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofLoadImage",3,"ofImageLoadSettings const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ + SWIG_fail_ptr("loadImage",1,SWIGTYPE_p_ofPixels_T_float_t); } { size_t len = lua_rawlen(L, 2); + temp2 = lua_tolstring(L, 2, &len); arg2 = &temp2; } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofImageLoadSettings,0))){ + SWIG_fail_ptr("loadImage",3,SWIGTYPE_p_ofImageLoadSettings); } + result = (bool)ofLoadImage(*arg1,(boost::filesystem::path const &)*arg2,(ofImageLoadSettings const &)*arg3); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_loadImage__SWIG_5(lua_State* L) { int SWIG_arg = 0; ofFloatPixels *arg1 = 0 ; std::filesystem::path *arg2 = 0 ; + std::filesystem::path temp2 ; bool result; SWIG_check_num_args("ofLoadImage",2,2) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofLoadImage",1,"ofFloatPixels &"); + if(!lua_isstring(L,2)) SWIG_fail_arg("ofLoadImage",2,"std::filesystem::path const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ + SWIG_fail_ptr("loadImage",1,SWIGTYPE_p_ofPixels_T_float_t); } { size_t len = lua_rawlen(L, 2); + temp2 = lua_tolstring(L, 2, &len); arg2 = &temp2; } + result = (bool)ofLoadImage(*arg1,(boost::filesystem::path const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_loadImage__SWIG_6(lua_State* L) { int SWIG_arg = 0; ofFloatPixels *arg1 = 0 ; ofBuffer *arg2 = 0 ; + ofImageLoadSettings *arg3 = 0 ; bool result; SWIG_check_num_args("ofLoadImage",3,3) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofLoadImage",1,"ofFloatPixels &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofLoadImage",2,"ofBuffer const &"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofLoadImage",3,"ofImageLoadSettings const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ + SWIG_fail_ptr("loadImage",1,SWIGTYPE_p_ofPixels_T_float_t); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBuffer,0))){ SWIG_fail_ptr("loadImage",2,SWIGTYPE_p_ofBuffer); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofImageLoadSettings,0))){ + SWIG_fail_ptr("loadImage",3,SWIGTYPE_p_ofImageLoadSettings); } + result = (bool)ofLoadImage(*arg1,(ofBuffer const &)*arg2,(ofImageLoadSettings const &)*arg3); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_loadImage__SWIG_7(lua_State* L) { int SWIG_arg = 0; ofFloatPixels *arg1 = 0 ; ofBuffer *arg2 = 0 ; bool result; + SWIG_check_num_args("ofLoadImage",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofLoadImage",1,"ofFloatPixels &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofLoadImage",2,"ofBuffer const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ + SWIG_fail_ptr("loadImage",1,SWIGTYPE_p_ofPixels_T_float_t); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBuffer,0))){ SWIG_fail_ptr("loadImage",2,SWIGTYPE_p_ofBuffer); } + result = (bool)ofLoadImage(*arg1,(ofBuffer const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; + if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_loadImage__SWIG_8(lua_State* L) { int SWIG_arg = 0; ofShortPixels *arg1 = 0 ; std::filesystem::path *arg2 = 0 ; + ofImageLoadSettings *arg3 = 0 ; std::filesystem::path temp2 ; bool result; SWIG_check_num_args("ofLoadImage",3,3) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofLoadImage",1,"ofShortPixels &"); + if(!lua_isstring(L,2)) SWIG_fail_arg("ofLoadImage",2,"std::filesystem::path const &"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofLoadImage",3,"ofImageLoadSettings const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ + SWIG_fail_ptr("loadImage",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } { size_t len = lua_rawlen(L, 2); + temp2 = lua_tolstring(L, 2, &len); arg2 = &temp2; } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofImageLoadSettings,0))){ + SWIG_fail_ptr("loadImage",3,SWIGTYPE_p_ofImageLoadSettings); } + result = (bool)ofLoadImage(*arg1,(boost::filesystem::path const &)*arg2,(ofImageLoadSettings const &)*arg3); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_loadImage__SWIG_9(lua_State* L) { int SWIG_arg = 0; ofShortPixels *arg1 = 0 ; std::filesystem::path *arg2 = 0 ; + std::filesystem::path temp2 ; bool result; SWIG_check_num_args("ofLoadImage",2,2) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofLoadImage",1,"ofShortPixels &"); + if(!lua_isstring(L,2)) SWIG_fail_arg("ofLoadImage",2,"std::filesystem::path const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ + SWIG_fail_ptr("loadImage",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } { size_t len = lua_rawlen(L, 2); + temp2 = lua_tolstring(L, 2, &len); arg2 = &temp2; } + result = (bool)ofLoadImage(*arg1,(boost::filesystem::path const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_loadImage__SWIG_10(lua_State* L) { int SWIG_arg = 0; ofShortPixels *arg1 = 0 ; ofBuffer *arg2 = 0 ; + ofImageLoadSettings *arg3 = 0 ; bool result; SWIG_check_num_args("ofLoadImage",3,3) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofLoadImage",1,"ofShortPixels &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofLoadImage",2,"ofBuffer const &"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofLoadImage",3,"ofImageLoadSettings const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ + SWIG_fail_ptr("loadImage",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBuffer,0))){ SWIG_fail_ptr("loadImage",2,SWIGTYPE_p_ofBuffer); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofImageLoadSettings,0))){ + SWIG_fail_ptr("loadImage",3,SWIGTYPE_p_ofImageLoadSettings); } + result = (bool)ofLoadImage(*arg1,(ofBuffer const &)*arg2,(ofImageLoadSettings const &)*arg3); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_loadImage__SWIG_11(lua_State* L) { int SWIG_arg = 0; ofShortPixels *arg1 = 0 ; ofBuffer *arg2 = 0 ; + bool result; SWIG_check_num_args("ofLoadImage",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofLoadImage",1,"ofShortPixels &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofLoadImage",2,"ofBuffer const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ + SWIG_fail_ptr("loadImage",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBuffer,0))){ SWIG_fail_ptr("loadImage",2,SWIGTYPE_p_ofBuffer); } + result = (bool)ofLoadImage(*arg1,(ofBuffer const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; + if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_loadImage__SWIG_12(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = 0 ; std::filesystem::path *arg2 = 0 ; + ofImageLoadSettings *arg3 = 0 ; std::filesystem::path temp2 ; bool result; SWIG_check_num_args("ofLoadImage",3,3) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofLoadImage",1,"ofTexture &"); + if(!lua_isstring(L,2)) SWIG_fail_arg("ofLoadImage",2,"std::filesystem::path const &"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofLoadImage",3,"ofImageLoadSettings const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ + SWIG_fail_ptr("loadImage",1,SWIGTYPE_p_ofTexture); } { size_t len = lua_rawlen(L, 2); temp2 = lua_tolstring(L, 2, &len); + arg2 = &temp2; } if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofImageLoadSettings,0))){ + SWIG_fail_ptr("loadImage",3,SWIGTYPE_p_ofImageLoadSettings); } + result = (bool)ofLoadImage(*arg1,(boost::filesystem::path const &)*arg2,(ofImageLoadSettings const &)*arg3); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_loadImage__SWIG_13(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = 0 ; std::filesystem::path *arg2 = 0 ; + std::filesystem::path temp2 ; bool result; SWIG_check_num_args("ofLoadImage",2,2) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofLoadImage",1,"ofTexture &"); + if(!lua_isstring(L,2)) SWIG_fail_arg("ofLoadImage",2,"std::filesystem::path const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ + SWIG_fail_ptr("loadImage",1,SWIGTYPE_p_ofTexture); } { size_t len = lua_rawlen(L, 2); temp2 = lua_tolstring(L, 2, &len); + arg2 = &temp2; } result = (bool)ofLoadImage(*arg1,(boost::filesystem::path const &)*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_loadImage__SWIG_14(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = 0 ; ofBuffer *arg2 = 0 ; + ofImageLoadSettings *arg3 = 0 ; bool result; SWIG_check_num_args("ofLoadImage",3,3) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofLoadImage",1,"ofTexture &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofLoadImage",2,"ofBuffer const &"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofLoadImage",3,"ofImageLoadSettings const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ + SWIG_fail_ptr("loadImage",1,SWIGTYPE_p_ofTexture); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBuffer,0))){ SWIG_fail_ptr("loadImage",2,SWIGTYPE_p_ofBuffer); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofImageLoadSettings,0))){ + SWIG_fail_ptr("loadImage",3,SWIGTYPE_p_ofImageLoadSettings); } + result = (bool)ofLoadImage(*arg1,(ofBuffer const &)*arg2,(ofImageLoadSettings const &)*arg3); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_loadImage__SWIG_15(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = 0 ; ofBuffer *arg2 = 0 ; bool result; + SWIG_check_num_args("ofLoadImage",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofLoadImage",1,"ofTexture &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofLoadImage",2,"ofBuffer const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ + SWIG_fail_ptr("loadImage",1,SWIGTYPE_p_ofTexture); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBuffer,0))){ SWIG_fail_ptr("loadImage",2,SWIGTYPE_p_ofBuffer); } + result = (bool)ofLoadImage(*arg1,(ofBuffer const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; + if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_loadImage(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { int _v = 0; + { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBuffer, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_loadImage__SWIG_3(L);} check_1: + if (argc == 2) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; { { _v = lua_isstring(L, argv[1]); } } + if (!_v) goto check_2; return _wrap_loadImage__SWIG_1(L);} check_2: if (argc == 2) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBuffer, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; return _wrap_loadImage__SWIG_7(L);} check_3: + if (argc == 2) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_4; { { _v = lua_isstring(L, argv[1]); } } + if (!_v) goto check_4; return _wrap_loadImage__SWIG_5(L);} check_4: if (argc == 2) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_5; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBuffer, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_5; return _wrap_loadImage__SWIG_11(L);} check_5: + if (argc == 2) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_6; { { _v = lua_isstring(L, argv[1]); } } + if (!_v) goto check_6; return _wrap_loadImage__SWIG_9(L);} check_6: if (argc == 2) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBuffer, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_7; return _wrap_loadImage__SWIG_15(L);} check_7: + if (argc == 2) { return _wrap_loadImage__SWIG_13(L);} if (argc == 3) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_9; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBuffer, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_9; return _wrap_loadImage__SWIG_10(L);} check_9: + if (argc == 3) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_10; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBuffer, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_10; return _wrap_loadImage__SWIG_6(L);} check_10: + if (argc == 3) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_11; { { _v = lua_isstring(L, argv[1]); } } + if (!_v) goto check_11; return _wrap_loadImage__SWIG_8(L);} check_11: if (argc == 3) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_12; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBuffer, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_12; return _wrap_loadImage__SWIG_2(L);} check_12: + if (argc == 3) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_13; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBuffer, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_13; return _wrap_loadImage__SWIG_14(L);} check_13: + if (argc == 3) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_14; return _wrap_loadImage__SWIG_4(L);} check_14: + if (argc == 3) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_15; return _wrap_loadImage__SWIG_12(L);} check_15: + if (argc == 3) { return _wrap_loadImage__SWIG_0(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'loadImage'\n" " Possible C/C++ prototypes are:\n" + " ofLoadImage(ofPixels &,std::filesystem::path const &,ofImageLoadSettings const &)\n" + " ofLoadImage(ofPixels &,std::filesystem::path const &)\n" + " ofLoadImage(ofPixels &,ofBuffer const &,ofImageLoadSettings const &)\n" " ofLoadImage(ofPixels &,ofBuffer const &)\n" + " ofLoadImage(ofFloatPixels &,std::filesystem::path const &,ofImageLoadSettings const &)\n" + " ofLoadImage(ofFloatPixels &,std::filesystem::path const &)\n" + " ofLoadImage(ofFloatPixels &,ofBuffer const &,ofImageLoadSettings const &)\n" + " ofLoadImage(ofFloatPixels &,ofBuffer const &)\n" + " ofLoadImage(ofShortPixels &,std::filesystem::path const &,ofImageLoadSettings const &)\n" + " ofLoadImage(ofShortPixels &,std::filesystem::path const &)\n" + " ofLoadImage(ofShortPixels &,ofBuffer const &,ofImageLoadSettings const &)\n" + " ofLoadImage(ofShortPixels &,ofBuffer const &)\n" + " ofLoadImage(ofTexture &,std::filesystem::path const &,ofImageLoadSettings const &)\n" + " ofLoadImage(ofTexture &,std::filesystem::path const &)\n" + " ofLoadImage(ofTexture &,ofBuffer const &,ofImageLoadSettings const &)\n" + " ofLoadImage(ofTexture &,ofBuffer const &)\n"); lua_error(L);return 0; } +static int _wrap_saveImage__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPixels *arg1 = 0 ; std::filesystem::path *arg2 = 0 ; + ofImageQualityType arg3 ; std::filesystem::path temp2 ; bool result; SWIG_check_num_args("ofSaveImage",3,3) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofSaveImage",1,"ofPixels const &"); + if(!lua_isstring(L,2)) SWIG_fail_arg("ofSaveImage",2,"std::filesystem::path const &"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("ofSaveImage",3,"ofImageQualityType"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ + SWIG_fail_ptr("saveImage",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } { size_t len = lua_rawlen(L, 2); + temp2 = lua_tolstring(L, 2, &len); arg2 = &temp2; } arg3 = (ofImageQualityType)(int)lua_tonumber(L, 3); + result = (bool)ofSaveImage((ofPixels_< unsigned char > const &)*arg1,(boost::filesystem::path const &)*arg2,arg3); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_saveImage__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPixels *arg1 = 0 ; std::filesystem::path *arg2 = 0 ; + std::filesystem::path temp2 ; bool result; SWIG_check_num_args("ofSaveImage",2,2) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofSaveImage",1,"ofPixels const &"); + if(!lua_isstring(L,2)) SWIG_fail_arg("ofSaveImage",2,"std::filesystem::path const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ + SWIG_fail_ptr("saveImage",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } { size_t len = lua_rawlen(L, 2); + temp2 = lua_tolstring(L, 2, &len); arg2 = &temp2; } + result = (bool)ofSaveImage((ofPixels_< unsigned char > const &)*arg1,(boost::filesystem::path const &)*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_saveImage__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPixels *arg1 = 0 ; ofBuffer *arg2 = 0 ; + ofImageFormat arg3 ; ofImageQualityType arg4 ; bool result; SWIG_check_num_args("ofSaveImage",4,4) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofSaveImage",1,"ofPixels const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofSaveImage",2,"ofBuffer &"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("ofSaveImage",3,"ofImageFormat"); + if(!lua_isnumber(L,4)) SWIG_fail_arg("ofSaveImage",4,"ofImageQualityType"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ + SWIG_fail_ptr("saveImage",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBuffer,0))){ SWIG_fail_ptr("saveImage",2,SWIGTYPE_p_ofBuffer); } + arg3 = (ofImageFormat)(int)lua_tonumber(L, 3); arg4 = (ofImageQualityType)(int)lua_tonumber(L, 4); + result = (bool)ofSaveImage((ofPixels_< unsigned char > const &)*arg1,*arg2,arg3,arg4); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_saveImage__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofPixels *arg1 = 0 ; ofBuffer *arg2 = 0 ; + ofImageFormat arg3 ; bool result; SWIG_check_num_args("ofSaveImage",3,3) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofSaveImage",1,"ofPixels const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofSaveImage",2,"ofBuffer &"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("ofSaveImage",3,"ofImageFormat"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ + SWIG_fail_ptr("saveImage",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBuffer,0))){ SWIG_fail_ptr("saveImage",2,SWIGTYPE_p_ofBuffer); } + arg3 = (ofImageFormat)(int)lua_tonumber(L, 3); + result = (bool)ofSaveImage((ofPixels_< unsigned char > const &)*arg1,*arg2,arg3); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_saveImage__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofPixels *arg1 = 0 ; ofBuffer *arg2 = 0 ; bool result; + SWIG_check_num_args("ofSaveImage",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofSaveImage",1,"ofPixels const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofSaveImage",2,"ofBuffer &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ + SWIG_fail_ptr("saveImage",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBuffer,0))){ SWIG_fail_ptr("saveImage",2,SWIGTYPE_p_ofBuffer); } + result = (bool)ofSaveImage((ofPixels_< unsigned char > const &)*arg1,*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_saveImage__SWIG_5(lua_State* L) { int SWIG_arg = 0; ofFloatPixels *arg1 = 0 ; std::filesystem::path *arg2 = 0 ; + ofImageQualityType arg3 ; std::filesystem::path temp2 ; bool result; SWIG_check_num_args("ofSaveImage",3,3) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofSaveImage",1,"ofFloatPixels const &"); + if(!lua_isstring(L,2)) SWIG_fail_arg("ofSaveImage",2,"std::filesystem::path const &"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("ofSaveImage",3,"ofImageQualityType"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ + SWIG_fail_ptr("saveImage",1,SWIGTYPE_p_ofPixels_T_float_t); } { size_t len = lua_rawlen(L, 2); + temp2 = lua_tolstring(L, 2, &len); arg2 = &temp2; } arg3 = (ofImageQualityType)(int)lua_tonumber(L, 3); + result = (bool)ofSaveImage((ofPixels_< float > const &)*arg1,(boost::filesystem::path const &)*arg2,arg3); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_saveImage__SWIG_6(lua_State* L) { int SWIG_arg = 0; ofFloatPixels *arg1 = 0 ; std::filesystem::path *arg2 = 0 ; + std::filesystem::path temp2 ; bool result; SWIG_check_num_args("ofSaveImage",2,2) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofSaveImage",1,"ofFloatPixels const &"); + if(!lua_isstring(L,2)) SWIG_fail_arg("ofSaveImage",2,"std::filesystem::path const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ + SWIG_fail_ptr("saveImage",1,SWIGTYPE_p_ofPixels_T_float_t); } { size_t len = lua_rawlen(L, 2); + temp2 = lua_tolstring(L, 2, &len); arg2 = &temp2; } + result = (bool)ofSaveImage((ofPixels_< float > const &)*arg1,(boost::filesystem::path const &)*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_saveImage__SWIG_7(lua_State* L) { int SWIG_arg = 0; ofFloatPixels *arg1 = 0 ; ofBuffer *arg2 = 0 ; + ofImageFormat arg3 ; ofImageQualityType arg4 ; bool result; SWIG_check_num_args("ofSaveImage",4,4) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofSaveImage",1,"ofFloatPixels const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofSaveImage",2,"ofBuffer &"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("ofSaveImage",3,"ofImageFormat"); + if(!lua_isnumber(L,4)) SWIG_fail_arg("ofSaveImage",4,"ofImageQualityType"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ + SWIG_fail_ptr("saveImage",1,SWIGTYPE_p_ofPixels_T_float_t); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBuffer,0))){ SWIG_fail_ptr("saveImage",2,SWIGTYPE_p_ofBuffer); } + arg3 = (ofImageFormat)(int)lua_tonumber(L, 3); arg4 = (ofImageQualityType)(int)lua_tonumber(L, 4); + result = (bool)ofSaveImage((ofPixels_< float > const &)*arg1,*arg2,arg3,arg4); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_saveImage__SWIG_8(lua_State* L) { int SWIG_arg = 0; ofFloatPixels *arg1 = 0 ; ofBuffer *arg2 = 0 ; + ofImageFormat arg3 ; bool result; SWIG_check_num_args("ofSaveImage",3,3) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofSaveImage",1,"ofFloatPixels const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofSaveImage",2,"ofBuffer &"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("ofSaveImage",3,"ofImageFormat"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ + SWIG_fail_ptr("saveImage",1,SWIGTYPE_p_ofPixels_T_float_t); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBuffer,0))){ SWIG_fail_ptr("saveImage",2,SWIGTYPE_p_ofBuffer); } + arg3 = (ofImageFormat)(int)lua_tonumber(L, 3); result = (bool)ofSaveImage((ofPixels_< float > const &)*arg1,*arg2,arg3); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_saveImage__SWIG_9(lua_State* L) { int SWIG_arg = 0; ofFloatPixels *arg1 = 0 ; ofBuffer *arg2 = 0 ; bool result; + SWIG_check_num_args("ofSaveImage",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofSaveImage",1,"ofFloatPixels const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofSaveImage",2,"ofBuffer &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ + SWIG_fail_ptr("saveImage",1,SWIGTYPE_p_ofPixels_T_float_t); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBuffer,0))){ SWIG_fail_ptr("saveImage",2,SWIGTYPE_p_ofBuffer); } + result = (bool)ofSaveImage((ofPixels_< float > const &)*arg1,*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_saveImage__SWIG_10(lua_State* L) { int SWIG_arg = 0; ofShortPixels *arg1 = 0 ; + std::filesystem::path *arg2 = 0 ; ofImageQualityType arg3 ; std::filesystem::path temp2 ; bool result; + SWIG_check_num_args("ofSaveImage",3,3) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofSaveImage",1,"ofShortPixels const &"); + if(!lua_isstring(L,2)) SWIG_fail_arg("ofSaveImage",2,"std::filesystem::path const &"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("ofSaveImage",3,"ofImageQualityType"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ + SWIG_fail_ptr("saveImage",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } { size_t len = lua_rawlen(L, 2); + temp2 = lua_tolstring(L, 2, &len); arg2 = &temp2; } arg3 = (ofImageQualityType)(int)lua_tonumber(L, 3); + result = (bool)ofSaveImage((ofPixels_< unsigned short > const &)*arg1,(boost::filesystem::path const &)*arg2,arg3); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_saveImage__SWIG_11(lua_State* L) { int SWIG_arg = 0; ofShortPixels *arg1 = 0 ; + std::filesystem::path *arg2 = 0 ; std::filesystem::path temp2 ; bool result; SWIG_check_num_args("ofSaveImage",2,2) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofSaveImage",1,"ofShortPixels const &"); + if(!lua_isstring(L,2)) SWIG_fail_arg("ofSaveImage",2,"std::filesystem::path const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ + SWIG_fail_ptr("saveImage",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } { size_t len = lua_rawlen(L, 2); + temp2 = lua_tolstring(L, 2, &len); arg2 = &temp2; } + result = (bool)ofSaveImage((ofPixels_< unsigned short > const &)*arg1,(boost::filesystem::path const &)*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_saveImage__SWIG_12(lua_State* L) { int SWIG_arg = 0; ofShortPixels *arg1 = 0 ; ofBuffer *arg2 = 0 ; + ofImageFormat arg3 ; ofImageQualityType arg4 ; bool result; SWIG_check_num_args("ofSaveImage",4,4) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofSaveImage",1,"ofShortPixels const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofSaveImage",2,"ofBuffer &"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("ofSaveImage",3,"ofImageFormat"); + if(!lua_isnumber(L,4)) SWIG_fail_arg("ofSaveImage",4,"ofImageQualityType"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ + SWIG_fail_ptr("saveImage",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBuffer,0))){ SWIG_fail_ptr("saveImage",2,SWIGTYPE_p_ofBuffer); } + arg3 = (ofImageFormat)(int)lua_tonumber(L, 3); arg4 = (ofImageQualityType)(int)lua_tonumber(L, 4); + result = (bool)ofSaveImage((ofPixels_< unsigned short > const &)*arg1,*arg2,arg3,arg4); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_saveImage__SWIG_13(lua_State* L) { int SWIG_arg = 0; ofShortPixels *arg1 = 0 ; ofBuffer *arg2 = 0 ; + ofImageFormat arg3 ; bool result; SWIG_check_num_args("ofSaveImage",3,3) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofSaveImage",1,"ofShortPixels const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofSaveImage",2,"ofBuffer &"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("ofSaveImage",3,"ofImageFormat"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ + SWIG_fail_ptr("saveImage",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBuffer,0))){ SWIG_fail_ptr("saveImage",2,SWIGTYPE_p_ofBuffer); } + arg3 = (ofImageFormat)(int)lua_tonumber(L, 3); + result = (bool)ofSaveImage((ofPixels_< unsigned short > const &)*arg1,*arg2,arg3); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_saveImage__SWIG_14(lua_State* L) { int SWIG_arg = 0; ofShortPixels *arg1 = 0 ; ofBuffer *arg2 = 0 ; + bool result; SWIG_check_num_args("ofSaveImage",2,2) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofSaveImage",1,"ofShortPixels const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofSaveImage",2,"ofBuffer &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ + SWIG_fail_ptr("saveImage",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBuffer,0))){ SWIG_fail_ptr("saveImage",2,SWIGTYPE_p_ofBuffer); } + result = (bool)ofSaveImage((ofPixels_< unsigned short > const &)*arg1,*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_saveImage(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBuffer, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_saveImage__SWIG_4(L);} check_1: + if (argc == 2) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; { { _v = lua_isstring(L, argv[1]); } } + if (!_v) goto check_2; return _wrap_saveImage__SWIG_1(L);} check_2: if (argc == 2) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBuffer, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; return _wrap_saveImage__SWIG_9(L);} check_3: + if (argc == 2) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_4; { { _v = lua_isstring(L, argv[1]); } } + if (!_v) goto check_4; return _wrap_saveImage__SWIG_6(L);} check_4: if (argc == 2) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBuffer, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_5; return _wrap_saveImage__SWIG_14(L);} check_5: + if (argc == 2) { return _wrap_saveImage__SWIG_11(L);} if (argc == 3) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_7; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBuffer, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_7; return _wrap_saveImage__SWIG_8(L);} check_7: + if (argc == 3) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_8; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBuffer, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_8; return _wrap_saveImage__SWIG_3(L);} check_8: + if (argc == 3) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_9; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBuffer, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_9; return _wrap_saveImage__SWIG_13(L);} check_9: + if (argc == 3) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_10; return _wrap_saveImage__SWIG_5(L);} check_10: + if (argc == 3) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_11; return _wrap_saveImage__SWIG_10(L);} check_11: + if (argc == 3) { return _wrap_saveImage__SWIG_0(L);} if (argc == 4) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_13; return _wrap_saveImage__SWIG_12(L);} check_13: + if (argc == 4) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_14; return _wrap_saveImage__SWIG_2(L);} check_14: + if (argc == 4) { return _wrap_saveImage__SWIG_7(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'saveImage'\n" " Possible C/C++ prototypes are:\n" + " ofSaveImage(ofPixels const &,std::filesystem::path const &,ofImageQualityType)\n" + " ofSaveImage(ofPixels const &,std::filesystem::path const &)\n" + " ofSaveImage(ofPixels const &,ofBuffer &,ofImageFormat,ofImageQualityType)\n" + " ofSaveImage(ofPixels const &,ofBuffer &,ofImageFormat)\n" " ofSaveImage(ofPixels const &,ofBuffer &)\n" + " ofSaveImage(ofFloatPixels const &,std::filesystem::path const &,ofImageQualityType)\n" + " ofSaveImage(ofFloatPixels const &,std::filesystem::path const &)\n" + " ofSaveImage(ofFloatPixels const &,ofBuffer &,ofImageFormat,ofImageQualityType)\n" + " ofSaveImage(ofFloatPixels const &,ofBuffer &,ofImageFormat)\n" " ofSaveImage(ofFloatPixels const &,ofBuffer &)\n" + " ofSaveImage(ofShortPixels const &,std::filesystem::path const &,ofImageQualityType)\n" + " ofSaveImage(ofShortPixels const &,std::filesystem::path const &)\n" + " ofSaveImage(ofShortPixels const &,ofBuffer &,ofImageFormat,ofImageQualityType)\n" + " ofSaveImage(ofShortPixels const &,ofBuffer &,ofImageFormat)\n" " ofSaveImage(ofShortPixels const &,ofBuffer &)\n"); + lua_error(L);return 0; } static int _wrap_new_Image__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofImage_< unsigned char > *result = 0 ; SWIG_check_num_args("ofImage_< unsigned char >::ofImage_",0,0) result = (ofImage_< unsigned char > *)new ofImage_< unsigned char >(); @@ -7360,15 +7910,13 @@ static int _wrap_new_Image__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofImage_< u SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofImage_T_unsigned_char_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_new_Image(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_Image__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_new_Image__SWIG_1(L);} } if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_new_Image__SWIG_4(L);} } if (argc == 1) { int _v; { - _v = lua_isstring(L, argv[0]); } if (_v) { return _wrap_new_Image__SWIG_3(L);} } if (argc == 2) { int _v; { - _v = lua_isstring(L, argv[0]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofImageLoadSettings, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_new_Image__SWIG_2(L);} } } + return _wrap_new_Image__SWIG_0(L);} if (argc == 1) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_new_Image__SWIG_1(L);} check_2: + if (argc == 1) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; return _wrap_new_Image__SWIG_4(L);} check_3: + if (argc == 1) { return _wrap_new_Image__SWIG_3(L);} if (argc == 2) { return _wrap_new_Image__SWIG_2(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_Image'\n" " Possible C/C++ prototypes are:\n" " ofImage_< unsigned char >::ofImage_()\n" " ofImage_< unsigned char >::ofImage_(ofPixels_< unsigned char > const &)\n" " ofImage_< unsigned char >::ofImage_(std::filesystem::path const &,ofImageLoadSettings const &)\n" @@ -7446,31 +7994,50 @@ static int _wrap_Image_load__SWIG_3(lua_State* L) { int SWIG_arg = 0; if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBuffer,0))){ SWIG_fail_ptr("Image_load",2,SWIGTYPE_p_ofBuffer); } result = (bool)(arg1)->load((ofBuffer const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_load(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBuffer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Image_load__SWIG_3(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L, argv[1]); } if (_v) { - return _wrap_Image_load__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBuffer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofImageLoadSettings, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Image_load__SWIG_2(L);} } } } if (argc == 3) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L, argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofImageLoadSettings, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Image_load__SWIG_0(L);} } } } +static int _wrap_Image_load(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBuffer, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_Image_load__SWIG_3(L);} check_1: + if (argc == 2) { return _wrap_Image_load__SWIG_1(L);} if (argc == 3) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBuffer, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; return _wrap_Image_load__SWIG_2(L);} check_3: + if (argc == 3) { return _wrap_Image_load__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Image_load'\n" " Possible C/C++ prototypes are:\n" " ofImage_< unsigned char >::load(std::filesystem::path const &,ofImageLoadSettings const &)\n" " ofImage_< unsigned char >::load(std::filesystem::path const &)\n" " ofImage_< unsigned char >::load(ofBuffer const &,ofImageLoadSettings const &)\n" " ofImage_< unsigned char >::load(ofBuffer const &)\n"); lua_error(L);return 0; } +static int _wrap_Image_draw__SWIG_0_0(lua_State* L) { int SWIG_arg = 0; + ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; glm::vec2 *arg2 = 0 ; SWIG_check_num_args("draw",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("draw",1,"ofImage_< unsigned char > const *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("draw",2,"glm::vec2 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ + SWIG_fail_ptr("Image_draw",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec2,0))){ + SWIG_fail_ptr("Image_draw",2,SWIGTYPE_p_glm__vec2); } + ((ofImage_< unsigned char > const *)arg1)->draw((glm::vec2 const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_Image_draw__SWIG_0_1(lua_State* L) { int SWIG_arg = 0; + ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; ofRectangle *arg2 = 0 ; SWIG_check_num_args("draw",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("draw",1,"ofImage_< unsigned char > const *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("draw",2,"ofRectangle const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ + SWIG_fail_ptr("Image_draw",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ + SWIG_fail_ptr("Image_draw",2,SWIGTYPE_p_ofRectangle); } + ((ofImage_< unsigned char > const *)arg1)->draw((ofRectangle const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_Image_draw__SWIG_0_2(lua_State* L) { int SWIG_arg = 0; + ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; glm::vec2 *arg2 = 0 ; float arg3 ; float arg4 ; + SWIG_check_num_args("draw",4,4) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("draw",1,"ofImage_< unsigned char > const *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("draw",2,"glm::vec2 const &"); if(!lua_isnumber(L,3)) SWIG_fail_arg("draw",3,"float"); + if(!lua_isnumber(L,4)) SWIG_fail_arg("draw",4,"float"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ + SWIG_fail_ptr("Image_draw",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec2,0))){ + SWIG_fail_ptr("Image_draw",2,SWIGTYPE_p_glm__vec2); } arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); + ((ofImage_< unsigned char > const *)arg1)->draw((glm::vec2 const &)*arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } static int _wrap_Image_draw__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; float arg2 ; float arg3 ; SWIG_check_num_args("ofImage_< unsigned char >::draw",3,3) @@ -7545,33 +8112,23 @@ static int _wrap_Image_draw__SWIG_6(lua_State* L) { int SWIG_arg = 0; ((ofImage_< unsigned char > const *)arg1)->draw((glm::vec3 const &)*arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Image_draw(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Image_draw__SWIG_3(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_Image_draw__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Image_draw__SWIG_6(L);} } } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Image_draw__SWIG_2(L);} } } } } - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Image_draw__SWIG_4(L);} } } } } } if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { return _wrap_Image_draw__SWIG_5(L);} } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Image_draw'\n" " Possible C/C++ prototypes are:\n" - " ofImage_< unsigned char >::draw()\n" " ofImage_< unsigned char >::draw(float,float) const\n" + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_Image_draw__SWIG_0_0(L);} check_1: + if (argc == 2) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_Image_draw__SWIG_0_1(L);} check_2: + if (argc == 2) { return _wrap_Image_draw__SWIG_3(L);} if (argc == 3) { return _wrap_Image_draw__SWIG_1(L);} if (argc == 4) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_5; return _wrap_Image_draw__SWIG_0_2(L);} check_5: + if (argc == 4) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_6; return _wrap_Image_draw__SWIG_6(L);} check_6: + if (argc == 4) { return _wrap_Image_draw__SWIG_2(L);} if (argc == 5) { return _wrap_Image_draw__SWIG_4(L);} if (argc == 6) { + return _wrap_Image_draw__SWIG_5(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Image_draw'\n" + " Possible C/C++ prototypes are:\n" " draw(glm::vec2 const &) const\n" " draw(ofRectangle const &) const\n" + " draw(glm::vec2 const &,float,float) const\n" " ofImage_< unsigned char >::draw(float,float) const\n" " ofImage_< unsigned char >::draw(float,float,float) const\n" " ofImage_< unsigned char >::draw(glm::vec3 const &) const\n" " ofImage_< unsigned char >::draw(float,float,float,float) const\n" @@ -7651,32 +8208,10 @@ static int _wrap_Image_drawSubsection__SWIG_3(lua_State* L) { int SWIG_arg = 0; ((ofImage_< unsigned char > const *)arg1)->drawSubsection(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Image_drawSubsection(lua_State* L) { int argc; int argv[11]={ 1,2,3,4,5,6,7,8,9,10,11} ; argc = lua_gettop(L); - if (argc == 7) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { - return _wrap_Image_drawSubsection__SWIG_0(L);} } } } } } } } if (argc == 8) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { return _wrap_Image_drawSubsection__SWIG_1(L);} } } } } } } - } } if (argc == 9) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { { _v = lua_isnumber(L,argv[8]); } if (_v) { - return _wrap_Image_drawSubsection__SWIG_2(L);} } } } } } } } } } if (argc == 10) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { { _v = lua_isnumber(L,argv[8]); } if (_v) { { - _v = lua_isnumber(L,argv[9]); } if (_v) { return _wrap_Image_drawSubsection__SWIG_3(L);} } } } } } - } } } } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Image_drawSubsection'\n" + if (argc == 7) { return _wrap_Image_drawSubsection__SWIG_0(L);} if (argc == 8) { + return _wrap_Image_drawSubsection__SWIG_1(L);} if (argc == 9) { return _wrap_Image_drawSubsection__SWIG_2(L);} + if (argc == 10) { return _wrap_Image_drawSubsection__SWIG_3(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Image_drawSubsection'\n" " Possible C/C++ prototypes are:\n" " ofImage_< unsigned char >::drawSubsection(float,float,float,float,float,float) const\n" " ofImage_< unsigned char >::drawSubsection(float,float,float,float,float,float,float) const\n" @@ -7723,13 +8258,8 @@ static int _wrap_Image_getTexture__SWIG_1(lua_State* L) { int SWIG_arg = 0; result = (ofTexture *) &((ofImage_< unsigned char > const *)arg1)->getTexture(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTexture,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_getTexture(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v; - { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Image_getTexture__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Image_getTexture__SWIG_1(L);} } +static int _wrap_Image_getTexture(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { + return _wrap_Image_getTexture__SWIG_0(L);} if (argc == 1) { return _wrap_Image_getTexture__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Image_getTexture'\n" " Possible C/C++ prototypes are:\n" " ofImage_< unsigned char >::getTexture()\n" " ofImage_< unsigned char >::getTexture() const\n"); lua_error(L);return 0; } @@ -7747,13 +8277,8 @@ static int _wrap_Image_bind__SWIG_1(lua_State* L) { int SWIG_arg = 0; if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ SWIG_fail_ptr("Image_bind",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } ((ofImage_< unsigned char > const *)arg1)->bind(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_bind(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Image_bind__SWIG_1(L);} } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Image_bind__SWIG_0(L);} } } +static int _wrap_Image_bind(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { + return _wrap_Image_bind__SWIG_1(L);} if (argc == 2) { return _wrap_Image_bind__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Image_bind'\n" " Possible C/C++ prototypes are:\n" " ofImage_< unsigned char >::bind(int) const\n" " ofImage_< unsigned char >::bind() const\n"); lua_error(L);return 0; } static int _wrap_Image_unbind__SWIG_0(lua_State* L) { int SWIG_arg = 0; @@ -7772,14 +8297,8 @@ static int _wrap_Image_unbind__SWIG_1(lua_State* L) { int SWIG_arg = 0; if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ SWIG_fail_ptr("Image_unbind",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } ((ofImage_< unsigned char > const *)arg1)->unbind(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_unbind(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Image_unbind__SWIG_1(L);} } if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Image_unbind__SWIG_0(L);} } } +static int _wrap_Image_unbind(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { + return _wrap_Image_unbind__SWIG_1(L);} if (argc == 2) { return _wrap_Image_unbind__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Image_unbind'\n" " Possible C/C++ prototypes are:\n" " ofImage_< unsigned char >::unbind(int) const\n" " ofImage_< unsigned char >::unbind() const\n"); lua_error(L);return 0; } @@ -7792,6 +8311,28 @@ static int _wrap_Image_setCompression(lua_State* L) { int SWIG_arg = 0; SWIG_fail_ptr("Image_setCompression",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } arg2 = (ofTexCompression)(int)lua_tonumber(L, 2); (arg1)->setCompression(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Image_getPixels__SWIG_0(lua_State* L) { int SWIG_arg = 0; + ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; ofPixels_< unsigned char > *result = 0 ; + SWIG_check_num_args("ofImage_< unsigned char >::getPixels",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::getPixels",1,"ofImage_< unsigned char > *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ + SWIG_fail_ptr("Image_getPixels",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } + result = (ofPixels_< unsigned char > *) &(arg1)->getPixels(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_Image_getPixels__SWIG_1(lua_State* L) { int SWIG_arg = 0; + ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; ofPixels_< unsigned char > *result = 0 ; + SWIG_check_num_args("ofImage_< unsigned char >::getPixels",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::getPixels",1,"ofImage_< unsigned char > const *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ + SWIG_fail_ptr("Image_getPixels",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } + result = (ofPixels_< unsigned char > *) &((ofImage_< unsigned char > const *)arg1)->getPixels(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_Image_getPixels(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { + return _wrap_Image_getPixels__SWIG_0(L);} if (argc == 1) { return _wrap_Image_getPixels__SWIG_1(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Image_getPixels'\n" " Possible C/C++ prototypes are:\n" + " ofImage_< unsigned char >::getPixels()\n" " ofImage_< unsigned char >::getPixels() const\n"); lua_error(L);return 0; } static int _wrap_Image_getColor__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; int arg2 ; int arg3 ; ofColor_< unsigned char > result; SWIG_check_num_args("ofImage_< unsigned char >::getColor",3,3) @@ -7816,13 +8357,7 @@ static int _wrap_Image_getColor__SWIG_1(lua_State* L) { int SWIG_arg = 0; SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Image_getColor(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Image_getColor__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_Image_getColor__SWIG_0(L);} } } } + return _wrap_Image_getColor__SWIG_1(L);} if (argc == 3) { return _wrap_Image_getColor__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Image_getColor'\n" " Possible C/C++ prototypes are:\n" " ofImage_< unsigned char >::getColor(int,int) const\n" " ofImage_< unsigned char >::getColor(int) const\n"); lua_error(L);return 0; } @@ -7879,22 +8414,8 @@ static int _wrap_Image_setColor__SWIG_2(lua_State* L) { int SWIG_arg = 0; (arg1)->setColor((ofColor_< unsigned char > const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Image_setColor(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Image_setColor__SWIG_2(L);} } } if (argc == 3) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Image_setColor__SWIG_1(L);} } } } if (argc == 4) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Image_setColor__SWIG_0(L);} } } } } + return _wrap_Image_setColor__SWIG_2(L);} if (argc == 3) { return _wrap_Image_setColor__SWIG_1(L);} if (argc == 4) { + return _wrap_Image_setColor__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Image_setColor'\n" " Possible C/C++ prototypes are:\n" " ofImage_< unsigned char >::setColor(int,int,ofColor_< unsigned char > const &)\n" " ofImage_< unsigned char >::setColor(int,ofColor_< unsigned char > const &)\n" @@ -7942,24 +8463,8 @@ static int _wrap_Image_setFromPixels__SWIG_2(lua_State* L) { int SWIG_arg = 0; (arg1)->setFromPixels((ofPixels_< unsigned char > const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Image_setFromPixels(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Image_setFromPixels__SWIG_2(L);} } } if (argc == 5) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_unsigned_char, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_Image_setFromPixels__SWIG_1(L);} } } } } } - if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_unsigned_char, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isboolean(L,argv[5]); } if (_v) { - return _wrap_Image_setFromPixels__SWIG_0(L);} } } } } } } + if (argc == 2) { return _wrap_Image_setFromPixels__SWIG_2(L);} if (argc == 5) { return _wrap_Image_setFromPixels__SWIG_1(L);} + if (argc == 6) { return _wrap_Image_setFromPixels__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Image_setFromPixels'\n" " Possible C/C++ prototypes are:\n" " ofImage_< unsigned char >::setFromPixels(unsigned char const *,int,int,ofImageType,bool)\n" @@ -8133,111 +8638,20 @@ static int _wrap_Image_save__SWIG_4(lua_State* L) { int SWIG_arg = 0; if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBuffer,0))){ SWIG_fail_ptr("Image_save",2,SWIGTYPE_p_ofBuffer); } result = (bool)((ofImage_< unsigned char > const *)arg1)->save(*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_save(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { int _v; - { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBuffer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Image_save__SWIG_4(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L, argv[1]); } if (_v) { - return _wrap_Image_save__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBuffer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Image_save__SWIG_3(L);} } } - } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L, argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_Image_save__SWIG_0(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBuffer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Image_save__SWIG_2(L);} } } } } +static int _wrap_Image_save(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBuffer, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_Image_save__SWIG_4(L);} check_1: + if (argc == 2) { return _wrap_Image_save__SWIG_1(L);} if (argc == 3) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBuffer, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; return _wrap_Image_save__SWIG_3(L);} check_3: + if (argc == 3) { return _wrap_Image_save__SWIG_0(L);} if (argc == 4) { return _wrap_Image_save__SWIG_2(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Image_save'\n" " Possible C/C++ prototypes are:\n" " ofImage_< unsigned char >::save(std::filesystem::path const &,ofImageQualityType) const\n" " ofImage_< unsigned char >::save(std::filesystem::path const &) const\n" " ofImage_< unsigned char >::save(ofBuffer &,ofImageFormat,ofImageQualityType) const\n" " ofImage_< unsigned char >::save(ofBuffer &,ofImageFormat) const\n" " ofImage_< unsigned char >::save(ofBuffer &) const\n"); lua_error(L);return 0; } -static int _wrap_Image_allocated_get(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; bool result; - SWIG_check_num_args("ofImage_< unsigned char >::allocated",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::allocated",1,"ofImage_< unsigned char > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_allocated_get",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } - result = (bool)ofImage__Sl_unsigned_SS_char_Sg__allocated_get(arg1); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_usingTexture_set(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; bool arg2 ; - SWIG_check_num_args("ofImage_< unsigned char >::usingTexture",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::usingTexture",1,"ofImage_< unsigned char > *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::usingTexture",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_usingTexture_set",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } arg2 = (lua_toboolean(L, 2)!=0); - ofImage__Sl_unsigned_SS_char_Sg__usingTexture_set(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Image_usingTexture_get(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; bool result; - SWIG_check_num_args("ofImage_< unsigned char >::usingTexture",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::usingTexture",1,"ofImage_< unsigned char > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_usingTexture_get",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } - result = (bool)ofImage__Sl_unsigned_SS_char_Sg__usingTexture_get(arg1); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_texture_get(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; ofTexture *result = 0 ; - SWIG_check_num_args("ofImage_< unsigned char >::texture",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::texture",1,"ofImage_< unsigned char > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_texture_get",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } - result = (ofTexture *) &ofImage__Sl_unsigned_SS_char_Sg__texture_get(arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTexture,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Image_pixels_get(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; ofPixels *result = 0 ; - SWIG_check_num_args("ofImage_< unsigned char >::pixels",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::pixels",1,"ofImage_< unsigned char > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_pixels_get",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } - result = (ofPixels *) &ofImage__Sl_unsigned_SS_char_Sg__pixels_get(arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Image_width_get(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; float result; - SWIG_check_num_args("ofImage_< unsigned char >::width",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::width",1,"ofImage_< unsigned char > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_width_get",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } - result = (float)ofImage__Sl_unsigned_SS_char_Sg__width_get(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_height_get(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; float result; - SWIG_check_num_args("ofImage_< unsigned char >::height",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::height",1,"ofImage_< unsigned char > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_height_get",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } - result = (float)ofImage__Sl_unsigned_SS_char_Sg__height_get(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_imageType_set(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; ofImageType arg2 ; - SWIG_check_num_args("ofImage_< unsigned char >::imageType",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::imageType",1,"ofImage_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::imageType",2,"ofImageType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_imageType_set",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } arg2 = (ofImageType)(int)lua_tonumber(L, 2); - ofImage__Sl_unsigned_SS_char_Sg__imageType_set(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Image_imageType_get(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; ofImageType result; - SWIG_check_num_args("ofImage_< unsigned char >::imageType",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::imageType",1,"ofImage_< unsigned char > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_imageType_get",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } - result = (ofImageType)ofImage__Sl_unsigned_SS_char_Sg__imageType_get(arg1); - lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } static void swig_delete_Image(void *obj) { ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) obj; delete arg1; @@ -8251,13 +8665,6 @@ static int _proxy__wrap_new_Image(lua_State *L) { return 1; } static swig_lua_attribute swig_Image_attributes[] = { - { "allocated", _wrap_Image_allocated_get, SWIG_Lua_set_immutable }, - { "usingTexture", _wrap_Image_usingTexture_get, _wrap_Image_usingTexture_set }, - { "texture", _wrap_Image_texture_get, SWIG_Lua_set_immutable }, - { "pixels", _wrap_Image_pixels_get, SWIG_Lua_set_immutable }, - { "width", _wrap_Image_width_get, SWIG_Lua_set_immutable }, - { "height", _wrap_Image_height_get, SWIG_Lua_set_immutable }, - { "imageType", _wrap_Image_imageType_get, _wrap_Image_imageType_set }, {0,0,0} }; static swig_lua_method swig_Image_methods[]= { @@ -8274,6 +8681,7 @@ static swig_lua_method swig_Image_methods[]= { { "bind", _wrap_Image_bind}, { "unbind", _wrap_Image_unbind}, { "setCompression", _wrap_Image_setCompression}, + { "getPixels", _wrap_Image_getPixels}, { "getColor", _wrap_Image_getColor}, { "getHeight", _wrap_Image_getHeight}, { "getWidth", _wrap_Image_getWidth}, @@ -8361,16 +8769,13 @@ static int _wrap_new_FloatImage__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofImag SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofImage_T_float_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_new_FloatImage(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_FloatImage__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_new_FloatImage__SWIG_1(L);} } if (argc == 1) { int _v; { - void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_new_FloatImage__SWIG_4(L);} } if (argc == 1) { int _v; { - _v = lua_isstring(L, argv[0]); } if (_v) { return _wrap_new_FloatImage__SWIG_3(L);} } if (argc == 2) { int _v; { - _v = lua_isstring(L, argv[0]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofImageLoadSettings, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_new_FloatImage__SWIG_2(L);} } } + return _wrap_new_FloatImage__SWIG_0(L);} if (argc == 1) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_new_FloatImage__SWIG_1(L);} check_2: + if (argc == 1) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; return _wrap_new_FloatImage__SWIG_4(L);} check_3: + if (argc == 1) { return _wrap_new_FloatImage__SWIG_3(L);} if (argc == 2) { return _wrap_new_FloatImage__SWIG_2(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_FloatImage'\n" " Possible C/C++ prototypes are:\n" " ofImage_< float >::ofImage_()\n" " ofImage_< float >::ofImage_(ofPixels_< float > const &)\n" " ofImage_< float >::ofImage_(std::filesystem::path const &,ofImageLoadSettings const &)\n" @@ -8444,30 +8849,49 @@ static int _wrap_FloatImage_load__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofIma SWIG_fail_ptr("FloatImage_load",2,SWIGTYPE_p_ofBuffer); } result = (bool)(arg1)->load((ofBuffer const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_FloatImage_load(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBuffer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_FloatImage_load__SWIG_3(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L, argv[1]); } if (_v) { - return _wrap_FloatImage_load__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBuffer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofImageLoadSettings, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_FloatImage_load__SWIG_2(L);} } } } if (argc == 3) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L, argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofImageLoadSettings, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_FloatImage_load__SWIG_0(L);} } } } + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBuffer, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_FloatImage_load__SWIG_3(L);} check_1: + if (argc == 2) { return _wrap_FloatImage_load__SWIG_1(L);} if (argc == 3) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBuffer, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; return _wrap_FloatImage_load__SWIG_2(L);} check_3: + if (argc == 3) { return _wrap_FloatImage_load__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatImage_load'\n" " Possible C/C++ prototypes are:\n" " ofImage_< float >::load(std::filesystem::path const &,ofImageLoadSettings const &)\n" " ofImage_< float >::load(std::filesystem::path const &)\n" " ofImage_< float >::load(ofBuffer const &,ofImageLoadSettings const &)\n" " ofImage_< float >::load(ofBuffer const &)\n"); lua_error(L);return 0; } +static int _wrap_FloatImage_draw__SWIG_0_0(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; + glm::vec2 *arg2 = 0 ; SWIG_check_num_args("draw",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("draw",1,"ofImage_< float > const *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("draw",2,"glm::vec2 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ + SWIG_fail_ptr("FloatImage_draw",1,SWIGTYPE_p_ofImage_T_float_t); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec2,0))){ + SWIG_fail_ptr("FloatImage_draw",2,SWIGTYPE_p_glm__vec2); } + ((ofImage_< float > const *)arg1)->draw((glm::vec2 const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_FloatImage_draw__SWIG_0_1(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; + ofRectangle *arg2 = 0 ; SWIG_check_num_args("draw",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("draw",1,"ofImage_< float > const *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("draw",2,"ofRectangle const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ + SWIG_fail_ptr("FloatImage_draw",1,SWIGTYPE_p_ofImage_T_float_t); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ + SWIG_fail_ptr("FloatImage_draw",2,SWIGTYPE_p_ofRectangle); } + ((ofImage_< float > const *)arg1)->draw((ofRectangle const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_FloatImage_draw__SWIG_0_2(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; + glm::vec2 *arg2 = 0 ; float arg3 ; float arg4 ; SWIG_check_num_args("draw",4,4) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("draw",1,"ofImage_< float > const *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("draw",2,"glm::vec2 const &"); if(!lua_isnumber(L,3)) SWIG_fail_arg("draw",3,"float"); + if(!lua_isnumber(L,4)) SWIG_fail_arg("draw",4,"float"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ + SWIG_fail_ptr("FloatImage_draw",1,SWIGTYPE_p_ofImage_T_float_t); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec2,0))){ + SWIG_fail_ptr("FloatImage_draw",2,SWIGTYPE_p_glm__vec2); } arg3 = (float)lua_tonumber(L, 3); + arg4 = (float)lua_tonumber(L, 4); ((ofImage_< float > const *)arg1)->draw((glm::vec2 const &)*arg2,arg3,arg4); + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_FloatImage_draw__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; float arg2 ; float arg3 ; SWIG_check_num_args("ofImage_< float >::draw",3,3) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::draw",1,"ofImage_< float > const *"); @@ -8535,33 +8959,24 @@ static int _wrap_FloatImage_draw__SWIG_6(lua_State* L) { int SWIG_arg = 0; ofIma arg4 = (float)lua_tonumber(L, 4); ((ofImage_< float > const *)arg1)->draw((glm::vec3 const &)*arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_FloatImage_draw(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_FloatImage_draw__SWIG_3(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_FloatImage_draw__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_FloatImage_draw__SWIG_6(L);} } } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_FloatImage_draw__SWIG_2(L);} } } } } - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_FloatImage_draw__SWIG_4(L);} } } } } } if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { return _wrap_FloatImage_draw__SWIG_5(L);} } } } } } } + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_FloatImage_draw__SWIG_0_0(L);} check_1: + if (argc == 2) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_FloatImage_draw__SWIG_0_1(L);} check_2: + if (argc == 2) { return _wrap_FloatImage_draw__SWIG_3(L);} if (argc == 3) { return _wrap_FloatImage_draw__SWIG_1(L);} + if (argc == 4) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_5; return _wrap_FloatImage_draw__SWIG_0_2(L);} check_5: + if (argc == 4) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_6; return _wrap_FloatImage_draw__SWIG_6(L);} check_6: + if (argc == 4) { return _wrap_FloatImage_draw__SWIG_2(L);} if (argc == 5) { return _wrap_FloatImage_draw__SWIG_4(L);} + if (argc == 6) { return _wrap_FloatImage_draw__SWIG_5(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatImage_draw'\n" " Possible C/C++ prototypes are:\n" - " ofImage_< float >::draw()\n" " ofImage_< float >::draw(float,float) const\n" + " draw(glm::vec2 const &) const\n" " draw(ofRectangle const &) const\n" + " draw(glm::vec2 const &,float,float) const\n" " ofImage_< float >::draw(float,float) const\n" " ofImage_< float >::draw(float,float,float) const\n" " ofImage_< float >::draw(glm::vec3 const &) const\n" " ofImage_< float >::draw(float,float,float,float) const\n" " ofImage_< float >::draw(float,float,float,float,float) const\n" @@ -8638,33 +9053,9 @@ static int _wrap_FloatImage_drawSubsection__SWIG_3(lua_State* L) { int SWIG_arg ((ofImage_< float > const *)arg1)->drawSubsection(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_FloatImage_drawSubsection(lua_State* L) { int argc; int argv[11]={ 1,2,3,4,5,6,7,8,9,10,11} ; - argc = lua_gettop(L); if (argc == 7) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { - return _wrap_FloatImage_drawSubsection__SWIG_0(L);} } } } } } } } if (argc == 8) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { return _wrap_FloatImage_drawSubsection__SWIG_1(L);} } } } } } - } } } if (argc == 9) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { { _v = lua_isnumber(L,argv[8]); } if (_v) { - return _wrap_FloatImage_drawSubsection__SWIG_2(L);} } } } } } } } } } if (argc == 10) { int _v; - { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { { _v = lua_isnumber(L,argv[8]); } if (_v) { { - _v = lua_isnumber(L,argv[9]); } if (_v) { return _wrap_FloatImage_drawSubsection__SWIG_3(L);} } } } - } } } } } } } + argc = lua_gettop(L); if (argc == 7) { return _wrap_FloatImage_drawSubsection__SWIG_0(L);} if (argc == 8) { + return _wrap_FloatImage_drawSubsection__SWIG_1(L);} if (argc == 9) { return _wrap_FloatImage_drawSubsection__SWIG_2(L);} + if (argc == 10) { return _wrap_FloatImage_drawSubsection__SWIG_3(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatImage_drawSubsection'\n" " Possible C/C++ prototypes are:\n" " ofImage_< float >::drawSubsection(float,float,float,float,float,float) const\n" " ofImage_< float >::drawSubsection(float,float,float,float,float,float,float) const\n" @@ -8709,12 +9100,7 @@ static int _wrap_FloatImage_getTexture__SWIG_1(lua_State* L) { int SWIG_arg = 0; SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTexture,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_FloatImage_getTexture(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_FloatImage_getTexture__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_FloatImage_getTexture__SWIG_1(L);} } + return _wrap_FloatImage_getTexture__SWIG_0(L);} if (argc == 1) { return _wrap_FloatImage_getTexture__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatImage_getTexture'\n" " Possible C/C++ prototypes are:\n" " ofImage_< float >::getTexture()\n" " ofImage_< float >::getTexture() const\n"); lua_error(L);return 0; } @@ -8731,14 +9117,8 @@ static int _wrap_FloatImage_bind__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofIma if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ SWIG_fail_ptr("FloatImage_bind",1,SWIGTYPE_p_ofImage_T_float_t); } ((ofImage_< float > const *)arg1)->bind(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_bind(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; - { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_FloatImage_bind__SWIG_1(L);} } if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_FloatImage_bind__SWIG_0(L);} } } +static int _wrap_FloatImage_bind(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { + return _wrap_FloatImage_bind__SWIG_1(L);} if (argc == 2) { return _wrap_FloatImage_bind__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatImage_bind'\n" " Possible C/C++ prototypes are:\n" " ofImage_< float >::bind(int) const\n" " ofImage_< float >::bind() const\n"); lua_error(L);return 0; } static int _wrap_FloatImage_unbind__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; @@ -8755,13 +9135,7 @@ static int _wrap_FloatImage_unbind__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofI SWIG_fail_ptr("FloatImage_unbind",1,SWIGTYPE_p_ofImage_T_float_t); } ((ofImage_< float > const *)arg1)->unbind(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_FloatImage_unbind(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_FloatImage_unbind__SWIG_1(L);} } if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_FloatImage_unbind__SWIG_0(L);} } } + return _wrap_FloatImage_unbind__SWIG_1(L);} if (argc == 2) { return _wrap_FloatImage_unbind__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatImage_unbind'\n" " Possible C/C++ prototypes are:\n" " ofImage_< float >::unbind(int) const\n" " ofImage_< float >::unbind() const\n"); lua_error(L);return 0; } static int _wrap_FloatImage_setCompression(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; @@ -8772,6 +9146,29 @@ static int _wrap_FloatImage_setCompression(lua_State* L) { int SWIG_arg = 0; ofI SWIG_fail_ptr("FloatImage_setCompression",1,SWIGTYPE_p_ofImage_T_float_t); } arg2 = (ofTexCompression)(int)lua_tonumber(L, 2); (arg1)->setCompression(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_FloatImage_getPixels__SWIG_0(lua_State* L) { int SWIG_arg = 0; + ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; ofPixels_< float > *result = 0 ; + SWIG_check_num_args("ofImage_< float >::getPixels",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::getPixels",1,"ofImage_< float > *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ + SWIG_fail_ptr("FloatImage_getPixels",1,SWIGTYPE_p_ofImage_T_float_t); } + result = (ofPixels_< float > *) &(arg1)->getPixels(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofPixels_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_FloatImage_getPixels__SWIG_1(lua_State* L) { int SWIG_arg = 0; + ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; ofPixels_< float > *result = 0 ; + SWIG_check_num_args("ofImage_< float >::getPixels",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::getPixels",1,"ofImage_< float > const *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ + SWIG_fail_ptr("FloatImage_getPixels",1,SWIGTYPE_p_ofImage_T_float_t); } + result = (ofPixels_< float > *) &((ofImage_< float > const *)arg1)->getPixels(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofPixels_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_FloatImage_getPixels(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { + return _wrap_FloatImage_getPixels__SWIG_0(L);} if (argc == 1) { return _wrap_FloatImage_getPixels__SWIG_1(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatImage_getPixels'\n" + " Possible C/C++ prototypes are:\n" " ofImage_< float >::getPixels()\n" " ofImage_< float >::getPixels() const\n"); + lua_error(L);return 0; } static int _wrap_FloatImage_getColor__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; int arg2 ; int arg3 ; ofColor_< float > result; SWIG_check_num_args("ofImage_< float >::getColor",3,3) @@ -8796,13 +9193,7 @@ static int _wrap_FloatImage_getColor__SWIG_1(lua_State* L) { int SWIG_arg = 0; SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_FloatImage_getColor(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_FloatImage_getColor__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_FloatImage_getColor__SWIG_0(L);} } } } + return _wrap_FloatImage_getColor__SWIG_1(L);} if (argc == 3) { return _wrap_FloatImage_getColor__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatImage_getColor'\n" " Possible C/C++ prototypes are:\n" " ofImage_< float >::getColor(int,int) const\n" " ofImage_< float >::getColor(int) const\n"); lua_error(L);return 0; } @@ -8856,22 +9247,8 @@ static int _wrap_FloatImage_setColor__SWIG_2(lua_State* L) { int SWIG_arg = 0; SWIG_fail_ptr("FloatImage_setColor",2,SWIGTYPE_p_ofColor_T_float_t); } (arg1)->setColor((ofColor_< float > const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_FloatImage_setColor(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_FloatImage_setColor__SWIG_2(L);} } } if (argc == 3) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_FloatImage_setColor__SWIG_1(L);} } } } if (argc == 4) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_FloatImage_setColor__SWIG_0(L);} } } } } + return _wrap_FloatImage_setColor__SWIG_2(L);} if (argc == 3) { return _wrap_FloatImage_setColor__SWIG_1(L);} + if (argc == 4) { return _wrap_FloatImage_setColor__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatImage_setColor'\n" " Possible C/C++ prototypes are:\n" " ofImage_< float >::setColor(int,int,ofColor_< float > const &)\n" " ofImage_< float >::setColor(int,ofColor_< float > const &)\n" @@ -8919,24 +9296,8 @@ static int _wrap_FloatImage_setFromPixels__SWIG_2(lua_State* L) { int SWIG_arg = (arg1)->setFromPixels((ofPixels_< float > const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_FloatImage_setFromPixels(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_FloatImage_setFromPixels__SWIG_2(L);} } } if (argc == 5) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_FloatImage_setFromPixels__SWIG_1(L);} } } } } } - if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isboolean(L,argv[5]); } if (_v) { - return _wrap_FloatImage_setFromPixels__SWIG_0(L);} } } } } } } + if (argc == 2) { return _wrap_FloatImage_setFromPixels__SWIG_2(L);} if (argc == 5) { + return _wrap_FloatImage_setFromPixels__SWIG_1(L);} if (argc == 6) { return _wrap_FloatImage_setFromPixels__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatImage_setFromPixels'\n" " Possible C/C++ prototypes are:\n" " ofImage_< float >::setFromPixels(float const *,int,int,ofImageType,bool)\n" " ofImage_< float >::setFromPixels(float const *,int,int,ofImageType)\n" @@ -9099,98 +9460,19 @@ static int _wrap_FloatImage_save__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofIma SWIG_fail_ptr("FloatImage_save",2,SWIGTYPE_p_ofBuffer); } result = (bool)((ofImage_< float > const *)arg1)->save(*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_FloatImage_save(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBuffer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_FloatImage_save__SWIG_4(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L, argv[1]); } if (_v) { - return _wrap_FloatImage_save__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBuffer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_FloatImage_save__SWIG_3(L);} } - } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L, argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_FloatImage_save__SWIG_0(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBuffer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_FloatImage_save__SWIG_2(L);} } } } } + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBuffer, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_FloatImage_save__SWIG_4(L);} check_1: + if (argc == 2) { return _wrap_FloatImage_save__SWIG_1(L);} if (argc == 3) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBuffer, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; return _wrap_FloatImage_save__SWIG_3(L);} check_3: + if (argc == 3) { return _wrap_FloatImage_save__SWIG_0(L);} if (argc == 4) { return _wrap_FloatImage_save__SWIG_2(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatImage_save'\n" " Possible C/C++ prototypes are:\n" " ofImage_< float >::save(std::filesystem::path const &,ofImageQualityType) const\n" " ofImage_< float >::save(std::filesystem::path const &) const\n" " ofImage_< float >::save(ofBuffer &,ofImageFormat,ofImageQualityType) const\n" " ofImage_< float >::save(ofBuffer &,ofImageFormat) const\n" " ofImage_< float >::save(ofBuffer &) const\n"); lua_error(L);return 0; } -static int _wrap_FloatImage_allocated_get(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - bool result; SWIG_check_num_args("ofImage_< float >::allocated",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::allocated",1,"ofImage_< float > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_allocated_get",1,SWIGTYPE_p_ofImage_T_float_t); } - result = (bool)ofImage__Sl_float_Sg__allocated_get(arg1); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_usingTexture_set(lua_State* L) { int SWIG_arg = 0; - ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; bool arg2 ; SWIG_check_num_args("ofImage_< float >::usingTexture",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::usingTexture",1,"ofImage_< float > *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofImage_< float >::usingTexture",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_usingTexture_set",1,SWIGTYPE_p_ofImage_T_float_t); } arg2 = (lua_toboolean(L, 2)!=0); - ofImage__Sl_float_Sg__usingTexture_set(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_usingTexture_get(lua_State* L) { int SWIG_arg = 0; - ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; bool result; SWIG_check_num_args("ofImage_< float >::usingTexture",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::usingTexture",1,"ofImage_< float > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_usingTexture_get",1,SWIGTYPE_p_ofImage_T_float_t); } - result = (bool)ofImage__Sl_float_Sg__usingTexture_get(arg1); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_texture_get(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - ofTexture *result = 0 ; SWIG_check_num_args("ofImage_< float >::texture",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::texture",1,"ofImage_< float > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_texture_get",1,SWIGTYPE_p_ofImage_T_float_t); } - result = (ofTexture *) &ofImage__Sl_float_Sg__texture_get(arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTexture,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FloatImage_pixels_get(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - ofPixels *result = 0 ; SWIG_check_num_args("ofImage_< float >::pixels",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::pixels",1,"ofImage_< float > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_pixels_get",1,SWIGTYPE_p_ofImage_T_float_t); } - result = (ofPixels *) &ofImage__Sl_float_Sg__pixels_get(arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_width_get(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - float result; SWIG_check_num_args("ofImage_< float >::width",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::width",1,"ofImage_< float > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_width_get",1,SWIGTYPE_p_ofImage_T_float_t); } - result = (float)ofImage__Sl_float_Sg__width_get(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_height_get(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - float result; SWIG_check_num_args("ofImage_< float >::height",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::height",1,"ofImage_< float > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_height_get",1,SWIGTYPE_p_ofImage_T_float_t); } - result = (float)ofImage__Sl_float_Sg__height_get(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_imageType_set(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - ofImageType arg2 ; SWIG_check_num_args("ofImage_< float >::imageType",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::imageType",1,"ofImage_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< float >::imageType",2,"ofImageType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_imageType_set",1,SWIGTYPE_p_ofImage_T_float_t); } arg2 = (ofImageType)(int)lua_tonumber(L, 2); - ofImage__Sl_float_Sg__imageType_set(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_imageType_get(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - ofImageType result; SWIG_check_num_args("ofImage_< float >::imageType",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::imageType",1,"ofImage_< float > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_imageType_get",1,SWIGTYPE_p_ofImage_T_float_t); } - result = (ofImageType)ofImage__Sl_float_Sg__imageType_get(arg1); lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static void swig_delete_FloatImage(void *obj) { ofImage_< float > *arg1 = (ofImage_< float > *) obj; delete arg1; @@ -9204,13 +9486,6 @@ static int _proxy__wrap_new_FloatImage(lua_State *L) { return 1; } static swig_lua_attribute swig_FloatImage_attributes[] = { - { "allocated", _wrap_FloatImage_allocated_get, SWIG_Lua_set_immutable }, - { "usingTexture", _wrap_FloatImage_usingTexture_get, _wrap_FloatImage_usingTexture_set }, - { "texture", _wrap_FloatImage_texture_get, SWIG_Lua_set_immutable }, - { "pixels", _wrap_FloatImage_pixels_get, SWIG_Lua_set_immutable }, - { "width", _wrap_FloatImage_width_get, SWIG_Lua_set_immutable }, - { "height", _wrap_FloatImage_height_get, SWIG_Lua_set_immutable }, - { "imageType", _wrap_FloatImage_imageType_get, _wrap_FloatImage_imageType_set }, {0,0,0} }; static swig_lua_method swig_FloatImage_methods[]= { @@ -9227,6 +9502,7 @@ static swig_lua_method swig_FloatImage_methods[]= { { "bind", _wrap_FloatImage_bind}, { "unbind", _wrap_FloatImage_unbind}, { "setCompression", _wrap_FloatImage_setCompression}, + { "getPixels", _wrap_FloatImage_getPixels}, { "getColor", _wrap_FloatImage_getColor}, { "getHeight", _wrap_FloatImage_getHeight}, { "getWidth", _wrap_FloatImage_getWidth}, @@ -9316,16 +9592,13 @@ static int _wrap_new_ShortImage__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofImag SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofImage_T_unsigned_short_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_new_ShortImage(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_ShortImage__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_new_ShortImage__SWIG_1(L);} } if (argc == 1) { int _v; { - void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_new_ShortImage__SWIG_4(L);} } if (argc == 1) { int _v; { - _v = lua_isstring(L, argv[0]); } if (_v) { return _wrap_new_ShortImage__SWIG_3(L);} } if (argc == 2) { int _v; { - _v = lua_isstring(L, argv[0]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofImageLoadSettings, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_new_ShortImage__SWIG_2(L);} } } + return _wrap_new_ShortImage__SWIG_0(L);} if (argc == 1) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_new_ShortImage__SWIG_1(L);} check_2: + if (argc == 1) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; return _wrap_new_ShortImage__SWIG_4(L);} check_3: + if (argc == 1) { return _wrap_new_ShortImage__SWIG_3(L);} if (argc == 2) { return _wrap_new_ShortImage__SWIG_2(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_ShortImage'\n" " Possible C/C++ prototypes are:\n" " ofImage_< unsigned short >::ofImage_()\n" " ofImage_< unsigned short >::ofImage_(ofPixels_< unsigned short > const &)\n" @@ -9406,30 +9679,49 @@ static int _wrap_ShortImage_load__SWIG_3(lua_State* L) { int SWIG_arg = 0; SWIG_fail_ptr("ShortImage_load",2,SWIGTYPE_p_ofBuffer); } result = (bool)(arg1)->load((ofBuffer const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_ShortImage_load(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBuffer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_ShortImage_load__SWIG_3(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L, argv[1]); } if (_v) { - return _wrap_ShortImage_load__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBuffer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofImageLoadSettings, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_ShortImage_load__SWIG_2(L);} } } } if (argc == 3) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L, argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofImageLoadSettings, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_ShortImage_load__SWIG_0(L);} } } } + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBuffer, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_ShortImage_load__SWIG_3(L);} check_1: + if (argc == 2) { return _wrap_ShortImage_load__SWIG_1(L);} if (argc == 3) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBuffer, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; return _wrap_ShortImage_load__SWIG_2(L);} check_3: + if (argc == 3) { return _wrap_ShortImage_load__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortImage_load'\n" " Possible C/C++ prototypes are:\n" " ofImage_< unsigned short >::load(std::filesystem::path const &,ofImageLoadSettings const &)\n" " ofImage_< unsigned short >::load(std::filesystem::path const &)\n" " ofImage_< unsigned short >::load(ofBuffer const &,ofImageLoadSettings const &)\n" " ofImage_< unsigned short >::load(ofBuffer const &)\n"); lua_error(L);return 0; } +static int _wrap_ShortImage_draw__SWIG_0_0(lua_State* L) { int SWIG_arg = 0; + ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; glm::vec2 *arg2 = 0 ; SWIG_check_num_args("draw",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("draw",1,"ofImage_< unsigned short > const *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("draw",2,"glm::vec2 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ + SWIG_fail_ptr("ShortImage_draw",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec2,0))){ + SWIG_fail_ptr("ShortImage_draw",2,SWIGTYPE_p_glm__vec2); } + ((ofImage_< unsigned short > const *)arg1)->draw((glm::vec2 const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_ShortImage_draw__SWIG_0_1(lua_State* L) { int SWIG_arg = 0; + ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; ofRectangle *arg2 = 0 ; SWIG_check_num_args("draw",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("draw",1,"ofImage_< unsigned short > const *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("draw",2,"ofRectangle const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ + SWIG_fail_ptr("ShortImage_draw",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ + SWIG_fail_ptr("ShortImage_draw",2,SWIGTYPE_p_ofRectangle); } + ((ofImage_< unsigned short > const *)arg1)->draw((ofRectangle const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_ShortImage_draw__SWIG_0_2(lua_State* L) { int SWIG_arg = 0; + ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; glm::vec2 *arg2 = 0 ; float arg3 ; float arg4 ; + SWIG_check_num_args("draw",4,4) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("draw",1,"ofImage_< unsigned short > const *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("draw",2,"glm::vec2 const &"); if(!lua_isnumber(L,3)) SWIG_fail_arg("draw",3,"float"); + if(!lua_isnumber(L,4)) SWIG_fail_arg("draw",4,"float"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ + SWIG_fail_ptr("ShortImage_draw",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec2,0))){ + SWIG_fail_ptr("ShortImage_draw",2,SWIGTYPE_p_glm__vec2); } arg3 = (float)lua_tonumber(L, 3); + arg4 = (float)lua_tonumber(L, 4); ((ofImage_< unsigned short > const *)arg1)->draw((glm::vec2 const &)*arg2,arg3,arg4); + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_ShortImage_draw__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; float arg2 ; float arg3 ; SWIG_check_num_args("ofImage_< unsigned short >::draw",3,3) @@ -9504,33 +9796,24 @@ static int _wrap_ShortImage_draw__SWIG_6(lua_State* L) { int SWIG_arg = 0; arg4 = (float)lua_tonumber(L, 4); ((ofImage_< unsigned short > const *)arg1)->draw((glm::vec3 const &)*arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_ShortImage_draw(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_ShortImage_draw__SWIG_3(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_ShortImage_draw__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_ShortImage_draw__SWIG_6(L);} } } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_ShortImage_draw__SWIG_2(L);} } } } } - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_ShortImage_draw__SWIG_4(L);} } } } } } if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { return _wrap_ShortImage_draw__SWIG_5(L);} } } } } } } + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_ShortImage_draw__SWIG_0_0(L);} check_1: + if (argc == 2) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_ShortImage_draw__SWIG_0_1(L);} check_2: + if (argc == 2) { return _wrap_ShortImage_draw__SWIG_3(L);} if (argc == 3) { return _wrap_ShortImage_draw__SWIG_1(L);} + if (argc == 4) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_5; return _wrap_ShortImage_draw__SWIG_0_2(L);} check_5: + if (argc == 4) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_6; return _wrap_ShortImage_draw__SWIG_6(L);} check_6: + if (argc == 4) { return _wrap_ShortImage_draw__SWIG_2(L);} if (argc == 5) { return _wrap_ShortImage_draw__SWIG_4(L);} + if (argc == 6) { return _wrap_ShortImage_draw__SWIG_5(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortImage_draw'\n" " Possible C/C++ prototypes are:\n" - " ofImage_< unsigned short >::draw()\n" " ofImage_< unsigned short >::draw(float,float) const\n" + " draw(glm::vec2 const &) const\n" " draw(ofRectangle const &) const\n" + " draw(glm::vec2 const &,float,float) const\n" " ofImage_< unsigned short >::draw(float,float) const\n" " ofImage_< unsigned short >::draw(float,float,float) const\n" " ofImage_< unsigned short >::draw(glm::vec3 const &) const\n" " ofImage_< unsigned short >::draw(float,float,float,float) const\n" @@ -9610,33 +9893,9 @@ static int _wrap_ShortImage_drawSubsection__SWIG_3(lua_State* L) { int SWIG_arg ((ofImage_< unsigned short > const *)arg1)->drawSubsection(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_ShortImage_drawSubsection(lua_State* L) { int argc; int argv[11]={ 1,2,3,4,5,6,7,8,9,10,11} ; - argc = lua_gettop(L); if (argc == 7) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { - return _wrap_ShortImage_drawSubsection__SWIG_0(L);} } } } } } } } if (argc == 8) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { return _wrap_ShortImage_drawSubsection__SWIG_1(L);} } } } } } - } } } if (argc == 9) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { { _v = lua_isnumber(L,argv[8]); } if (_v) { - return _wrap_ShortImage_drawSubsection__SWIG_2(L);} } } } } } } } } } if (argc == 10) { int _v; - { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { { _v = lua_isnumber(L,argv[8]); } if (_v) { { - _v = lua_isnumber(L,argv[9]); } if (_v) { return _wrap_ShortImage_drawSubsection__SWIG_3(L);} } } } - } } } } } } } + argc = lua_gettop(L); if (argc == 7) { return _wrap_ShortImage_drawSubsection__SWIG_0(L);} if (argc == 8) { + return _wrap_ShortImage_drawSubsection__SWIG_1(L);} if (argc == 9) { return _wrap_ShortImage_drawSubsection__SWIG_2(L);} + if (argc == 10) { return _wrap_ShortImage_drawSubsection__SWIG_3(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortImage_drawSubsection'\n" " Possible C/C++ prototypes are:\n" " ofImage_< unsigned short >::drawSubsection(float,float,float,float,float,float) const\n" @@ -9685,12 +9944,7 @@ static int _wrap_ShortImage_getTexture__SWIG_1(lua_State* L) { int SWIG_arg = 0; SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTexture,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_ShortImage_getTexture(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_ShortImage_getTexture__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_ShortImage_getTexture__SWIG_1(L);} } + return _wrap_ShortImage_getTexture__SWIG_0(L);} if (argc == 1) { return _wrap_ShortImage_getTexture__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortImage_getTexture'\n" " Possible C/C++ prototypes are:\n" " ofImage_< unsigned short >::getTexture()\n" " ofImage_< unsigned short >::getTexture() const\n"); lua_error(L);return 0; } @@ -9710,14 +9964,8 @@ static int _wrap_ShortImage_bind__SWIG_1(lua_State* L) { int SWIG_arg = 0; if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ SWIG_fail_ptr("ShortImage_bind",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } ((ofImage_< unsigned short > const *)arg1)->bind(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_bind(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; - { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_ShortImage_bind__SWIG_1(L);} } if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_ShortImage_bind__SWIG_0(L);} } } +static int _wrap_ShortImage_bind(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { + return _wrap_ShortImage_bind__SWIG_1(L);} if (argc == 2) { return _wrap_ShortImage_bind__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortImage_bind'\n" " Possible C/C++ prototypes are:\n" " ofImage_< unsigned short >::bind(int) const\n" " ofImage_< unsigned short >::bind() const\n"); lua_error(L);return 0; } static int _wrap_ShortImage_unbind__SWIG_0(lua_State* L) { int SWIG_arg = 0; @@ -9737,13 +9985,7 @@ static int _wrap_ShortImage_unbind__SWIG_1(lua_State* L) { int SWIG_arg = 0; SWIG_fail_ptr("ShortImage_unbind",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } ((ofImage_< unsigned short > const *)arg1)->unbind(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_ShortImage_unbind(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_ShortImage_unbind__SWIG_1(L);} } if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_ShortImage_unbind__SWIG_0(L);} } } + return _wrap_ShortImage_unbind__SWIG_1(L);} if (argc == 2) { return _wrap_ShortImage_unbind__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortImage_unbind'\n" " Possible C/C++ prototypes are:\n" " ofImage_< unsigned short >::unbind(int) const\n" " ofImage_< unsigned short >::unbind() const\n"); lua_error(L);return 0; } @@ -9756,6 +9998,29 @@ static int _wrap_ShortImage_setCompression(lua_State* L) { int SWIG_arg = 0; SWIG_fail_ptr("ShortImage_setCompression",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } arg2 = (ofTexCompression)(int)lua_tonumber(L, 2); (arg1)->setCompression(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_ShortImage_getPixels__SWIG_0(lua_State* L) { int SWIG_arg = 0; + ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; ofPixels_< unsigned short > *result = 0 ; + SWIG_check_num_args("ofImage_< unsigned short >::getPixels",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::getPixels",1,"ofImage_< unsigned short > *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ + SWIG_fail_ptr("ShortImage_getPixels",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } + result = (ofPixels_< unsigned short > *) &(arg1)->getPixels(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_ShortImage_getPixels__SWIG_1(lua_State* L) { int SWIG_arg = 0; + ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; ofPixels_< unsigned short > *result = 0 ; + SWIG_check_num_args("ofImage_< unsigned short >::getPixels",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::getPixels",1,"ofImage_< unsigned short > const *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ + SWIG_fail_ptr("ShortImage_getPixels",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } + result = (ofPixels_< unsigned short > *) &((ofImage_< unsigned short > const *)arg1)->getPixels(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_ShortImage_getPixels(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { + return _wrap_ShortImage_getPixels__SWIG_0(L);} if (argc == 1) { return _wrap_ShortImage_getPixels__SWIG_1(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortImage_getPixels'\n" + " Possible C/C++ prototypes are:\n" " ofImage_< unsigned short >::getPixels()\n" + " ofImage_< unsigned short >::getPixels() const\n"); lua_error(L);return 0; } static int _wrap_ShortImage_getColor__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; int arg2 ; int arg3 ; ofColor_< unsigned short > result; SWIG_check_num_args("ofImage_< unsigned short >::getColor",3,3) @@ -9780,13 +10045,7 @@ static int _wrap_ShortImage_getColor__SWIG_1(lua_State* L) { int SWIG_arg = 0; SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_short_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_ShortImage_getColor(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_ShortImage_getColor__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_ShortImage_getColor__SWIG_0(L);} } } } + return _wrap_ShortImage_getColor__SWIG_1(L);} if (argc == 3) { return _wrap_ShortImage_getColor__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortImage_getColor'\n" " Possible C/C++ prototypes are:\n" " ofImage_< unsigned short >::getColor(int,int) const\n" " ofImage_< unsigned short >::getColor(int) const\n"); lua_error(L);return 0; } @@ -9843,22 +10102,8 @@ static int _wrap_ShortImage_setColor__SWIG_2(lua_State* L) { int SWIG_arg = 0; (arg1)->setColor((ofColor_< unsigned short > const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_ShortImage_setColor(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_ShortImage_setColor__SWIG_2(L);} } } if (argc == 3) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_ShortImage_setColor__SWIG_1(L);} } } } if (argc == 4) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_ShortImage_setColor__SWIG_0(L);} } } } } + return _wrap_ShortImage_setColor__SWIG_2(L);} if (argc == 3) { return _wrap_ShortImage_setColor__SWIG_1(L);} + if (argc == 4) { return _wrap_ShortImage_setColor__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortImage_setColor'\n" " Possible C/C++ prototypes are:\n" " ofImage_< unsigned short >::setColor(int,int,ofColor_< unsigned short > const &)\n" " ofImage_< unsigned short >::setColor(int,ofColor_< unsigned short > const &)\n" @@ -9906,24 +10151,8 @@ static int _wrap_ShortImage_setFromPixels__SWIG_2(lua_State* L) { int SWIG_arg = (arg1)->setFromPixels((ofPixels_< unsigned short > const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_ShortImage_setFromPixels(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_ShortImage_setFromPixels__SWIG_2(L);} } } if (argc == 5) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_unsigned_short, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_ShortImage_setFromPixels__SWIG_1(L);} } } } } - } if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_unsigned_short, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isboolean(L,argv[5]); } if (_v) { - return _wrap_ShortImage_setFromPixels__SWIG_0(L);} } } } } } } + if (argc == 2) { return _wrap_ShortImage_setFromPixels__SWIG_2(L);} if (argc == 5) { + return _wrap_ShortImage_setFromPixels__SWIG_1(L);} if (argc == 6) { return _wrap_ShortImage_setFromPixels__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortImage_setFromPixels'\n" " Possible C/C++ prototypes are:\n" " ofImage_< unsigned short >::setFromPixels(unsigned short const *,int,int,ofImageType,bool)\n" @@ -10102,110 +10331,19 @@ static int _wrap_ShortImage_save__SWIG_4(lua_State* L) { int SWIG_arg = 0; result = (bool)((ofImage_< unsigned short > const *)arg1)->save(*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_ShortImage_save(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBuffer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_ShortImage_save__SWIG_4(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L, argv[1]); } if (_v) { - return _wrap_ShortImage_save__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBuffer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_ShortImage_save__SWIG_3(L);} } - } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L, argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_ShortImage_save__SWIG_0(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBuffer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_ShortImage_save__SWIG_2(L);} } } } } + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBuffer, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_ShortImage_save__SWIG_4(L);} check_1: + if (argc == 2) { return _wrap_ShortImage_save__SWIG_1(L);} if (argc == 3) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBuffer, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; return _wrap_ShortImage_save__SWIG_3(L);} check_3: + if (argc == 3) { return _wrap_ShortImage_save__SWIG_0(L);} if (argc == 4) { return _wrap_ShortImage_save__SWIG_2(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortImage_save'\n" " Possible C/C++ prototypes are:\n" " ofImage_< unsigned short >::save(std::filesystem::path const &,ofImageQualityType) const\n" " ofImage_< unsigned short >::save(std::filesystem::path const &) const\n" " ofImage_< unsigned short >::save(ofBuffer &,ofImageFormat,ofImageQualityType) const\n" " ofImage_< unsigned short >::save(ofBuffer &,ofImageFormat) const\n" " ofImage_< unsigned short >::save(ofBuffer &) const\n"); lua_error(L);return 0; } -static int _wrap_ShortImage_allocated_get(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; bool result; - SWIG_check_num_args("ofImage_< unsigned short >::allocated",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::allocated",1,"ofImage_< unsigned short > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_allocated_get",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - result = (bool)ofImage__Sl_unsigned_SS_short_Sg__allocated_get(arg1); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_usingTexture_set(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; bool arg2 ; - SWIG_check_num_args("ofImage_< unsigned short >::usingTexture",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::usingTexture",1,"ofImage_< unsigned short > *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::usingTexture",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_usingTexture_set",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } arg2 = (lua_toboolean(L, 2)!=0); - ofImage__Sl_unsigned_SS_short_Sg__usingTexture_set(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortImage_usingTexture_get(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; bool result; - SWIG_check_num_args("ofImage_< unsigned short >::usingTexture",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::usingTexture",1,"ofImage_< unsigned short > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_usingTexture_get",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - result = (bool)ofImage__Sl_unsigned_SS_short_Sg__usingTexture_get(arg1); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_texture_get(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; ofTexture *result = 0 ; - SWIG_check_num_args("ofImage_< unsigned short >::texture",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::texture",1,"ofImage_< unsigned short > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_texture_get",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - result = (ofTexture *) &ofImage__Sl_unsigned_SS_short_Sg__texture_get(arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTexture,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortImage_pixels_get(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; ofPixels *result = 0 ; - SWIG_check_num_args("ofImage_< unsigned short >::pixels",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::pixels",1,"ofImage_< unsigned short > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_pixels_get",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - result = (ofPixels *) &ofImage__Sl_unsigned_SS_short_Sg__pixels_get(arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_width_get(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; float result; - SWIG_check_num_args("ofImage_< unsigned short >::width",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::width",1,"ofImage_< unsigned short > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_width_get",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - result = (float)ofImage__Sl_unsigned_SS_short_Sg__width_get(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_height_get(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; float result; - SWIG_check_num_args("ofImage_< unsigned short >::height",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::height",1,"ofImage_< unsigned short > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_height_get",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - result = (float)ofImage__Sl_unsigned_SS_short_Sg__height_get(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_imageType_set(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; ofImageType arg2 ; - SWIG_check_num_args("ofImage_< unsigned short >::imageType",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::imageType",1,"ofImage_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::imageType",2,"ofImageType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_imageType_set",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - arg2 = (ofImageType)(int)lua_tonumber(L, 2); ofImage__Sl_unsigned_SS_short_Sg__imageType_set(arg1,arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_imageType_get(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; ofImageType result; - SWIG_check_num_args("ofImage_< unsigned short >::imageType",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::imageType",1,"ofImage_< unsigned short > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_imageType_get",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - result = (ofImageType)ofImage__Sl_unsigned_SS_short_Sg__imageType_get(arg1); - lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } static void swig_delete_ShortImage(void *obj) { ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) obj; delete arg1; @@ -10219,13 +10357,6 @@ static int _proxy__wrap_new_ShortImage(lua_State *L) { return 1; } static swig_lua_attribute swig_ShortImage_attributes[] = { - { "allocated", _wrap_ShortImage_allocated_get, SWIG_Lua_set_immutable }, - { "usingTexture", _wrap_ShortImage_usingTexture_get, _wrap_ShortImage_usingTexture_set }, - { "texture", _wrap_ShortImage_texture_get, SWIG_Lua_set_immutable }, - { "pixels", _wrap_ShortImage_pixels_get, SWIG_Lua_set_immutable }, - { "width", _wrap_ShortImage_width_get, SWIG_Lua_set_immutable }, - { "height", _wrap_ShortImage_height_get, SWIG_Lua_set_immutable }, - { "imageType", _wrap_ShortImage_imageType_get, _wrap_ShortImage_imageType_set }, {0,0,0} }; static swig_lua_method swig_ShortImage_methods[]= { @@ -10242,6 +10373,7 @@ static swig_lua_method swig_ShortImage_methods[]= { { "bind", _wrap_ShortImage_bind}, { "unbind", _wrap_ShortImage_unbind}, { "setCompression", _wrap_ShortImage_setCompression}, + { "getPixels", _wrap_ShortImage_getPixels}, { "getColor", _wrap_ShortImage_getColor}, { "getHeight", _wrap_ShortImage_getHeight}, { "getWidth", _wrap_ShortImage_getWidth}, @@ -10290,6 +10422,1272 @@ static swig_lua_class *swig_ShortImage_bases[] = {0}; static const char *swig_ShortImage_base_names[] = {0}; static swig_lua_class _wrap_class_ShortImage = { "ShortImage", "ShortImage", &SWIGTYPE_p_ofImage_T_unsigned_short_t,_proxy__wrap_new_ShortImage, swig_delete_ShortImage, swig_ShortImage_methods, swig_ShortImage_attributes, &swig_ShortImage_Sf_SwigStatic, swig_ShortImage_meta, swig_ShortImage_bases, swig_ShortImage_base_names }; +static int _wrap_new_Style(lua_State* L) { int SWIG_arg = 0; ofStyle *result = 0 ; SWIG_check_num_args("ofStyle::ofStyle",0,0) + result = (ofStyle *)new ofStyle(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofStyle,1); SWIG_arg++; return SWIG_arg; + if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Style_color_set(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; + ofColor *arg2 = (ofColor *) 0 ; SWIG_check_num_args("ofStyle::color",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::color",1,"ofStyle *"); + if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofStyle::color",2,"ofColor *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ + SWIG_fail_ptr("Style_color_set",1,SWIGTYPE_p_ofStyle); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ + SWIG_fail_ptr("Style_color_set",2,SWIGTYPE_p_ofColor_T_unsigned_char_t); } if (arg1) (arg1)->color = *arg2; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Style_color_get(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; ofColor *result = 0 ; + SWIG_check_num_args("ofStyle::color",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::color",1,"ofStyle *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ + SWIG_fail_ptr("Style_color_get",1,SWIGTYPE_p_ofStyle); } result = (ofColor *)& ((arg1)->color); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_Style_bgColor_set(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; + ofColor *arg2 = (ofColor *) 0 ; SWIG_check_num_args("ofStyle::bgColor",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::bgColor",1,"ofStyle *"); + if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofStyle::bgColor",2,"ofColor *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ + SWIG_fail_ptr("Style_bgColor_set",1,SWIGTYPE_p_ofStyle); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ + SWIG_fail_ptr("Style_bgColor_set",2,SWIGTYPE_p_ofColor_T_unsigned_char_t); } if (arg1) (arg1)->bgColor = *arg2; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Style_bgColor_get(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; ofColor *result = 0 ; + SWIG_check_num_args("ofStyle::bgColor",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::bgColor",1,"ofStyle *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ + SWIG_fail_ptr("Style_bgColor_get",1,SWIGTYPE_p_ofStyle); } result = (ofColor *)& ((arg1)->bgColor); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_Style_polyMode_set(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; ofPolyWindingMode arg2 ; + SWIG_check_num_args("ofStyle::polyMode",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::polyMode",1,"ofStyle *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofStyle::polyMode",2,"ofPolyWindingMode"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ + SWIG_fail_ptr("Style_polyMode_set",1,SWIGTYPE_p_ofStyle); } arg2 = (ofPolyWindingMode)(int)lua_tonumber(L, 2); + if (arg1) (arg1)->polyMode = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Style_polyMode_get(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; ofPolyWindingMode result; + SWIG_check_num_args("ofStyle::polyMode",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::polyMode",1,"ofStyle *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ + SWIG_fail_ptr("Style_polyMode_get",1,SWIGTYPE_p_ofStyle); } result = (ofPolyWindingMode) ((arg1)->polyMode); + lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_Style_rectMode_set(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; ofRectMode arg2 ; + SWIG_check_num_args("ofStyle::rectMode",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::rectMode",1,"ofStyle *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofStyle::rectMode",2,"ofRectMode"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ + SWIG_fail_ptr("Style_rectMode_set",1,SWIGTYPE_p_ofStyle); } arg2 = (ofRectMode)(int)lua_tonumber(L, 2); + if (arg1) (arg1)->rectMode = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Style_rectMode_get(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; ofRectMode result; + SWIG_check_num_args("ofStyle::rectMode",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::rectMode",1,"ofStyle *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ + SWIG_fail_ptr("Style_rectMode_get",1,SWIGTYPE_p_ofStyle); } result = (ofRectMode) ((arg1)->rectMode); + lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_Style_bFill_set(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; bool arg2 ; + SWIG_check_num_args("ofStyle::bFill",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::bFill",1,"ofStyle *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("ofStyle::bFill",2,"bool"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ + SWIG_fail_ptr("Style_bFill_set",1,SWIGTYPE_p_ofStyle); } arg2 = (lua_toboolean(L, 2)!=0); if (arg1) (arg1)->bFill = arg2; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Style_bFill_get(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; bool result; + SWIG_check_num_args("ofStyle::bFill",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::bFill",1,"ofStyle *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ + SWIG_fail_ptr("Style_bFill_get",1,SWIGTYPE_p_ofStyle); } result = (bool) ((arg1)->bFill); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Style_drawBitmapMode_set(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; + ofDrawBitmapMode arg2 ; SWIG_check_num_args("ofStyle::drawBitmapMode",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::drawBitmapMode",1,"ofStyle *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofStyle::drawBitmapMode",2,"ofDrawBitmapMode"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ + SWIG_fail_ptr("Style_drawBitmapMode_set",1,SWIGTYPE_p_ofStyle); } arg2 = (ofDrawBitmapMode)(int)lua_tonumber(L, 2); + if (arg1) (arg1)->drawBitmapMode = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Style_drawBitmapMode_get(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; + ofDrawBitmapMode result; SWIG_check_num_args("ofStyle::drawBitmapMode",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::drawBitmapMode",1,"ofStyle *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ + SWIG_fail_ptr("Style_drawBitmapMode_get",1,SWIGTYPE_p_ofStyle); } result = (ofDrawBitmapMode) ((arg1)->drawBitmapMode); + lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_Style_blendingMode_set(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; ofBlendMode arg2 ; + SWIG_check_num_args("ofStyle::blendingMode",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::blendingMode",1,"ofStyle *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofStyle::blendingMode",2,"ofBlendMode"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ + SWIG_fail_ptr("Style_blendingMode_set",1,SWIGTYPE_p_ofStyle); } arg2 = (ofBlendMode)(int)lua_tonumber(L, 2); + if (arg1) (arg1)->blendingMode = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Style_blendingMode_get(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; ofBlendMode result; + SWIG_check_num_args("ofStyle::blendingMode",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::blendingMode",1,"ofStyle *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ + SWIG_fail_ptr("Style_blendingMode_get",1,SWIGTYPE_p_ofStyle); } result = (ofBlendMode) ((arg1)->blendingMode); + lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_Style_smoothing_set(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; bool arg2 ; + SWIG_check_num_args("ofStyle::smoothing",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::smoothing",1,"ofStyle *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("ofStyle::smoothing",2,"bool"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ + SWIG_fail_ptr("Style_smoothing_set",1,SWIGTYPE_p_ofStyle); } arg2 = (lua_toboolean(L, 2)!=0); + if (arg1) (arg1)->smoothing = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Style_smoothing_get(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; bool result; + SWIG_check_num_args("ofStyle::smoothing",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::smoothing",1,"ofStyle *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ + SWIG_fail_ptr("Style_smoothing_get",1,SWIGTYPE_p_ofStyle); } result = (bool) ((arg1)->smoothing); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Style_circleResolution_set(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; int arg2 ; + SWIG_check_num_args("ofStyle::circleResolution",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::circleResolution",1,"ofStyle *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofStyle::circleResolution",2,"int"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ + SWIG_fail_ptr("Style_circleResolution_set",1,SWIGTYPE_p_ofStyle); } arg2 = (int)lua_tonumber(L, 2); + if (arg1) (arg1)->circleResolution = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Style_circleResolution_get(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; int result; + SWIG_check_num_args("ofStyle::circleResolution",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::circleResolution",1,"ofStyle *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ + SWIG_fail_ptr("Style_circleResolution_get",1,SWIGTYPE_p_ofStyle); } result = (int) ((arg1)->circleResolution); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Style_sphereResolution_set(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; int arg2 ; + SWIG_check_num_args("ofStyle::sphereResolution",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::sphereResolution",1,"ofStyle *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofStyle::sphereResolution",2,"int"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ + SWIG_fail_ptr("Style_sphereResolution_set",1,SWIGTYPE_p_ofStyle); } arg2 = (int)lua_tonumber(L, 2); + if (arg1) (arg1)->sphereResolution = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Style_sphereResolution_get(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; int result; + SWIG_check_num_args("ofStyle::sphereResolution",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::sphereResolution",1,"ofStyle *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ + SWIG_fail_ptr("Style_sphereResolution_get",1,SWIGTYPE_p_ofStyle); } result = (int) ((arg1)->sphereResolution); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Style_curveResolution_set(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; int arg2 ; + SWIG_check_num_args("ofStyle::curveResolution",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::curveResolution",1,"ofStyle *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofStyle::curveResolution",2,"int"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ + SWIG_fail_ptr("Style_curveResolution_set",1,SWIGTYPE_p_ofStyle); } arg2 = (int)lua_tonumber(L, 2); + if (arg1) (arg1)->curveResolution = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Style_curveResolution_get(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; int result; + SWIG_check_num_args("ofStyle::curveResolution",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::curveResolution",1,"ofStyle *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ + SWIG_fail_ptr("Style_curveResolution_get",1,SWIGTYPE_p_ofStyle); } result = (int) ((arg1)->curveResolution); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Style_lineWidth_set(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; float arg2 ; + SWIG_check_num_args("ofStyle::lineWidth",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::lineWidth",1,"ofStyle *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofStyle::lineWidth",2,"float"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ + SWIG_fail_ptr("Style_lineWidth_set",1,SWIGTYPE_p_ofStyle); } arg2 = (float)lua_tonumber(L, 2); + if (arg1) (arg1)->lineWidth = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Style_lineWidth_get(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; float result; + SWIG_check_num_args("ofStyle::lineWidth",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::lineWidth",1,"ofStyle *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ + SWIG_fail_ptr("Style_lineWidth_get",1,SWIGTYPE_p_ofStyle); } result = (float) ((arg1)->lineWidth); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static void swig_delete_Style(void *obj) { +ofStyle *arg1 = (ofStyle *) obj; +delete arg1; +} +static int _proxy__wrap_new_Style(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_Style); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_Style_attributes[] = { + { "color", _wrap_Style_color_get, _wrap_Style_color_set }, + { "bgColor", _wrap_Style_bgColor_get, _wrap_Style_bgColor_set }, + { "polyMode", _wrap_Style_polyMode_get, _wrap_Style_polyMode_set }, + { "rectMode", _wrap_Style_rectMode_get, _wrap_Style_rectMode_set }, + { "bFill", _wrap_Style_bFill_get, _wrap_Style_bFill_set }, + { "drawBitmapMode", _wrap_Style_drawBitmapMode_get, _wrap_Style_drawBitmapMode_set }, + { "blendingMode", _wrap_Style_blendingMode_get, _wrap_Style_blendingMode_set }, + { "smoothing", _wrap_Style_smoothing_get, _wrap_Style_smoothing_set }, + { "circleResolution", _wrap_Style_circleResolution_get, _wrap_Style_circleResolution_set }, + { "sphereResolution", _wrap_Style_sphereResolution_get, _wrap_Style_sphereResolution_set }, + { "curveResolution", _wrap_Style_curveResolution_get, _wrap_Style_curveResolution_set }, + { "lineWidth", _wrap_Style_lineWidth_get, _wrap_Style_lineWidth_set }, + {0,0,0} +}; +static swig_lua_method swig_Style_methods[]= { + {0,0} +}; +static swig_lua_method swig_Style_meta[] = { + {0,0} +}; + +static swig_lua_attribute swig_Style_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_Style_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_Style_Sf_SwigStatic_methods[]= { + {0,0} +}; +static swig_lua_class* swig_Style_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_Style_Sf_SwigStatic = { + "Style", + swig_Style_Sf_SwigStatic_methods, + swig_Style_Sf_SwigStatic_attributes, + swig_Style_Sf_SwigStatic_constants, + swig_Style_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_Style_bases[] = {0}; +static const char *swig_Style_base_names[] = {0}; +static swig_lua_class _wrap_class_Style = { "Style", "Style", &SWIGTYPE_p_ofStyle,_proxy__wrap_new_Style, swig_delete_Style, swig_Style_methods, swig_Style_attributes, &swig_Style_Sf_SwigStatic, swig_Style_meta, swig_Style_bases, swig_Style_base_names }; + +static int _wrap_SoundDevice_api_set(lua_State* L) { int SWIG_arg = 0; ofSoundDevice *arg1 = (ofSoundDevice *) 0 ; + enum ofSoundDevice::Api arg2 ; SWIG_check_num_args("ofSoundDevice::api",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundDevice::api",1,"ofSoundDevice *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSoundDevice::api",2,"enum ofSoundDevice::Api"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundDevice,0))){ + SWIG_fail_ptr("SoundDevice_api_set",1,SWIGTYPE_p_ofSoundDevice); } arg2 = (enum ofSoundDevice::Api)(int)lua_tonumber(L, 2); + if (arg1) (arg1)->api = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_SoundDevice_api_get(lua_State* L) { int SWIG_arg = 0; ofSoundDevice *arg1 = (ofSoundDevice *) 0 ; + enum ofSoundDevice::Api result; SWIG_check_num_args("ofSoundDevice::api",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundDevice::api",1,"ofSoundDevice *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundDevice,0))){ + SWIG_fail_ptr("SoundDevice_api_get",1,SWIGTYPE_p_ofSoundDevice); } result = (enum ofSoundDevice::Api) ((arg1)->api); + lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_SoundDevice_name_set(lua_State* L) { int SWIG_arg = 0; ofSoundDevice *arg1 = (ofSoundDevice *) 0 ; + std::string *arg2 = 0 ; std::string temp2 ; SWIG_check_num_args("ofSoundDevice::name",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundDevice::name",1,"ofSoundDevice *"); + if(!lua_isstring(L,2)) SWIG_fail_arg("ofSoundDevice::name",2,"std::string const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundDevice,0))){ + SWIG_fail_ptr("SoundDevice_name_set",1,SWIGTYPE_p_ofSoundDevice); } + temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; if (arg1) (arg1)->name = *arg2; return SWIG_arg; + if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_SoundDevice_name_get(lua_State* L) { int SWIG_arg = 0; ofSoundDevice *arg1 = (ofSoundDevice *) 0 ; + std::string *result = 0 ; SWIG_check_num_args("ofSoundDevice::name",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundDevice::name",1,"ofSoundDevice *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundDevice,0))){ + SWIG_fail_ptr("SoundDevice_name_get",1,SWIGTYPE_p_ofSoundDevice); } result = (std::string *) & ((arg1)->name); + lua_pushlstring(L,result->data(),result->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_SoundDevice_deviceID_set(lua_State* L) { int SWIG_arg = 0; ofSoundDevice *arg1 = (ofSoundDevice *) 0 ; + int arg2 ; SWIG_check_num_args("ofSoundDevice::deviceID",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundDevice::deviceID",1,"ofSoundDevice *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSoundDevice::deviceID",2,"int"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundDevice,0))){ + SWIG_fail_ptr("SoundDevice_deviceID_set",1,SWIGTYPE_p_ofSoundDevice); } arg2 = (int)lua_tonumber(L, 2); + if (arg1) (arg1)->deviceID = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_SoundDevice_deviceID_get(lua_State* L) { int SWIG_arg = 0; ofSoundDevice *arg1 = (ofSoundDevice *) 0 ; + int result; SWIG_check_num_args("ofSoundDevice::deviceID",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundDevice::deviceID",1,"ofSoundDevice *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundDevice,0))){ + SWIG_fail_ptr("SoundDevice_deviceID_get",1,SWIGTYPE_p_ofSoundDevice); } result = (int) ((arg1)->deviceID); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_SoundDevice_inputChannels_set(lua_State* L) { int SWIG_arg = 0; ofSoundDevice *arg1 = (ofSoundDevice *) 0 ; + unsigned int arg2 ; SWIG_check_num_args("ofSoundDevice::inputChannels",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundDevice::inputChannels",1,"ofSoundDevice *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSoundDevice::inputChannels",2,"unsigned int"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundDevice,0))){ + SWIG_fail_ptr("SoundDevice_inputChannels_set",1,SWIGTYPE_p_ofSoundDevice); } + SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned int)lua_tonumber(L, 2); + if (arg1) (arg1)->inputChannels = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_SoundDevice_inputChannels_get(lua_State* L) { int SWIG_arg = 0; ofSoundDevice *arg1 = (ofSoundDevice *) 0 ; + unsigned int result; SWIG_check_num_args("ofSoundDevice::inputChannels",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundDevice::inputChannels",1,"ofSoundDevice *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundDevice,0))){ + SWIG_fail_ptr("SoundDevice_inputChannels_get",1,SWIGTYPE_p_ofSoundDevice); } + result = (unsigned int) ((arg1)->inputChannels); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; + if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_SoundDevice_outputChannels_set(lua_State* L) { int SWIG_arg = 0; ofSoundDevice *arg1 = (ofSoundDevice *) 0 ; + unsigned int arg2 ; SWIG_check_num_args("ofSoundDevice::outputChannels",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundDevice::outputChannels",1,"ofSoundDevice *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSoundDevice::outputChannels",2,"unsigned int"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundDevice,0))){ + SWIG_fail_ptr("SoundDevice_outputChannels_set",1,SWIGTYPE_p_ofSoundDevice); } + SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned int)lua_tonumber(L, 2); + if (arg1) (arg1)->outputChannels = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_SoundDevice_outputChannels_get(lua_State* L) { int SWIG_arg = 0; ofSoundDevice *arg1 = (ofSoundDevice *) 0 ; + unsigned int result; SWIG_check_num_args("ofSoundDevice::outputChannels",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundDevice::outputChannels",1,"ofSoundDevice *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundDevice,0))){ + SWIG_fail_ptr("SoundDevice_outputChannels_get",1,SWIGTYPE_p_ofSoundDevice); } + result = (unsigned int) ((arg1)->outputChannels); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; + if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_SoundDevice_isDefaultInput_set(lua_State* L) { int SWIG_arg = 0; ofSoundDevice *arg1 = (ofSoundDevice *) 0 ; + bool arg2 ; SWIG_check_num_args("ofSoundDevice::isDefaultInput",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundDevice::isDefaultInput",1,"ofSoundDevice *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("ofSoundDevice::isDefaultInput",2,"bool"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundDevice,0))){ + SWIG_fail_ptr("SoundDevice_isDefaultInput_set",1,SWIGTYPE_p_ofSoundDevice); } arg2 = (lua_toboolean(L, 2)!=0); + if (arg1) (arg1)->isDefaultInput = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_SoundDevice_isDefaultInput_get(lua_State* L) { int SWIG_arg = 0; ofSoundDevice *arg1 = (ofSoundDevice *) 0 ; + bool result; SWIG_check_num_args("ofSoundDevice::isDefaultInput",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundDevice::isDefaultInput",1,"ofSoundDevice *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundDevice,0))){ + SWIG_fail_ptr("SoundDevice_isDefaultInput_get",1,SWIGTYPE_p_ofSoundDevice); } result = (bool) ((arg1)->isDefaultInput); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_SoundDevice_isDefaultOutput_set(lua_State* L) { int SWIG_arg = 0; ofSoundDevice *arg1 = (ofSoundDevice *) 0 ; + bool arg2 ; SWIG_check_num_args("ofSoundDevice::isDefaultOutput",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundDevice::isDefaultOutput",1,"ofSoundDevice *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("ofSoundDevice::isDefaultOutput",2,"bool"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundDevice,0))){ + SWIG_fail_ptr("SoundDevice_isDefaultOutput_set",1,SWIGTYPE_p_ofSoundDevice); } arg2 = (lua_toboolean(L, 2)!=0); + if (arg1) (arg1)->isDefaultOutput = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_SoundDevice_isDefaultOutput_get(lua_State* L) { int SWIG_arg = 0; ofSoundDevice *arg1 = (ofSoundDevice *) 0 ; + bool result; SWIG_check_num_args("ofSoundDevice::isDefaultOutput",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundDevice::isDefaultOutput",1,"ofSoundDevice *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundDevice,0))){ + SWIG_fail_ptr("SoundDevice_isDefaultOutput_get",1,SWIGTYPE_p_ofSoundDevice); } result = (bool) ((arg1)->isDefaultOutput); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_SoundDevice_sampleRates_set(lua_State* L) { int SWIG_arg = 0; ofSoundDevice *arg1 = (ofSoundDevice *) 0 ; + std::vector< unsigned int > *arg2 = (std::vector< unsigned int > *) 0 ; SWIG_check_num_args("ofSoundDevice::sampleRates",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundDevice::sampleRates",1,"ofSoundDevice *"); + if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofSoundDevice::sampleRates",2,"std::vector< unsigned int > *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundDevice,0))){ + SWIG_fail_ptr("SoundDevice_sampleRates_set",1,SWIGTYPE_p_ofSoundDevice); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__vectorT_unsigned_int_t,0))){ + SWIG_fail_ptr("SoundDevice_sampleRates_set",2,SWIGTYPE_p_std__vectorT_unsigned_int_t); } + if (arg1) (arg1)->sampleRates = *arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_SoundDevice_sampleRates_get(lua_State* L) { int SWIG_arg = 0; ofSoundDevice *arg1 = (ofSoundDevice *) 0 ; + std::vector< unsigned int > *result = 0 ; SWIG_check_num_args("ofSoundDevice::sampleRates",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundDevice::sampleRates",1,"ofSoundDevice *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundDevice,0))){ + SWIG_fail_ptr("SoundDevice_sampleRates_get",1,SWIGTYPE_p_ofSoundDevice); } + result = (std::vector< unsigned int > *)& ((arg1)->sampleRates); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_unsigned_int_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_new_SoundDevice(lua_State* L) { int SWIG_arg = 0; ofSoundDevice *result = 0 ; + SWIG_check_num_args("ofSoundDevice::ofSoundDevice",0,0) result = (ofSoundDevice *)new ofSoundDevice(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofSoundDevice,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static void swig_delete_SoundDevice(void *obj) { +ofSoundDevice *arg1 = (ofSoundDevice *) obj; +delete arg1; +} +static int _proxy__wrap_new_SoundDevice(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_SoundDevice); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_SoundDevice_attributes[] = { + { "api", _wrap_SoundDevice_api_get, _wrap_SoundDevice_api_set }, + { "name", _wrap_SoundDevice_name_get, _wrap_SoundDevice_name_set }, + { "deviceID", _wrap_SoundDevice_deviceID_get, _wrap_SoundDevice_deviceID_set }, + { "inputChannels", _wrap_SoundDevice_inputChannels_get, _wrap_SoundDevice_inputChannels_set }, + { "outputChannels", _wrap_SoundDevice_outputChannels_get, _wrap_SoundDevice_outputChannels_set }, + { "isDefaultInput", _wrap_SoundDevice_isDefaultInput_get, _wrap_SoundDevice_isDefaultInput_set }, + { "isDefaultOutput", _wrap_SoundDevice_isDefaultOutput_get, _wrap_SoundDevice_isDefaultOutput_set }, + { "sampleRates", _wrap_SoundDevice_sampleRates_get, _wrap_SoundDevice_sampleRates_set }, + {0,0,0} +}; +static swig_lua_method swig_SoundDevice_methods[]= { + {0,0} +}; +static swig_lua_method swig_SoundDevice_meta[] = { + {0,0} +}; + +static swig_lua_attribute swig_SoundDevice_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_SoundDevice_Sf_SwigStatic_constants[]= { + {SWIG_LUA_CONSTTAB_INT("UNSPECIFIED", ofSoundDevice::UNSPECIFIED)}, + {SWIG_LUA_CONSTTAB_INT("DEFAULT", ofSoundDevice::DEFAULT)}, + {SWIG_LUA_CONSTTAB_INT("ALSA", ofSoundDevice::ALSA)}, + {SWIG_LUA_CONSTTAB_INT("PULSE", ofSoundDevice::PULSE)}, + {SWIG_LUA_CONSTTAB_INT("OSS", ofSoundDevice::OSS)}, + {SWIG_LUA_CONSTTAB_INT("JACK", ofSoundDevice::JACK)}, + {SWIG_LUA_CONSTTAB_INT("OSX_CORE", ofSoundDevice::OSX_CORE)}, + {SWIG_LUA_CONSTTAB_INT("MS_WASAPI", ofSoundDevice::MS_WASAPI)}, + {SWIG_LUA_CONSTTAB_INT("MS_ASIO", ofSoundDevice::MS_ASIO)}, + {SWIG_LUA_CONSTTAB_INT("MS_DS", ofSoundDevice::MS_DS)}, + {SWIG_LUA_CONSTTAB_INT("NUM_APIS", ofSoundDevice::NUM_APIS)}, + {0,0,0,0,0,0} +}; +static swig_lua_method swig_SoundDevice_Sf_SwigStatic_methods[]= { + {0,0} +}; +static swig_lua_class* swig_SoundDevice_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_SoundDevice_Sf_SwigStatic = { + "SoundDevice", + swig_SoundDevice_Sf_SwigStatic_methods, + swig_SoundDevice_Sf_SwigStatic_attributes, + swig_SoundDevice_Sf_SwigStatic_constants, + swig_SoundDevice_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_SoundDevice_bases[] = {0}; +static const char *swig_SoundDevice_base_names[] = {0}; +static swig_lua_class _wrap_class_SoundDevice = { "SoundDevice", "SoundDevice", &SWIGTYPE_p_ofSoundDevice,_proxy__wrap_new_SoundDevice, swig_delete_SoundDevice, swig_SoundDevice_methods, swig_SoundDevice_attributes, &swig_SoundDevice_Sf_SwigStatic, swig_SoundDevice_meta, swig_SoundDevice_bases, swig_SoundDevice_base_names }; + +static int _wrap_SoundStreamSettings_sampleRate_set(lua_State* L) { int SWIG_arg = 0; + ofSoundStreamSettings *arg1 = (ofSoundStreamSettings *) 0 ; size_t arg2 ; + SWIG_check_num_args("ofSoundStreamSettings::sampleRate",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStreamSettings::sampleRate",1,"ofSoundStreamSettings *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSoundStreamSettings::sampleRate",2,"size_t"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStreamSettings,0))){ + SWIG_fail_ptr("SoundStreamSettings_sampleRate_set",1,SWIGTYPE_p_ofSoundStreamSettings); } + SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); + if (arg1) (arg1)->sampleRate = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_SoundStreamSettings_sampleRate_get(lua_State* L) { int SWIG_arg = 0; + ofSoundStreamSettings *arg1 = (ofSoundStreamSettings *) 0 ; size_t result; + SWIG_check_num_args("ofSoundStreamSettings::sampleRate",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStreamSettings::sampleRate",1,"ofSoundStreamSettings *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStreamSettings,0))){ + SWIG_fail_ptr("SoundStreamSettings_sampleRate_get",1,SWIGTYPE_p_ofSoundStreamSettings); } + result = (size_t) ((arg1)->sampleRate); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; + fail: lua_error(L); return SWIG_arg; } +static int _wrap_SoundStreamSettings_bufferSize_set(lua_State* L) { int SWIG_arg = 0; + ofSoundStreamSettings *arg1 = (ofSoundStreamSettings *) 0 ; size_t arg2 ; + SWIG_check_num_args("ofSoundStreamSettings::bufferSize",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStreamSettings::bufferSize",1,"ofSoundStreamSettings *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSoundStreamSettings::bufferSize",2,"size_t"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStreamSettings,0))){ + SWIG_fail_ptr("SoundStreamSettings_bufferSize_set",1,SWIGTYPE_p_ofSoundStreamSettings); } + SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); + if (arg1) (arg1)->bufferSize = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_SoundStreamSettings_bufferSize_get(lua_State* L) { int SWIG_arg = 0; + ofSoundStreamSettings *arg1 = (ofSoundStreamSettings *) 0 ; size_t result; + SWIG_check_num_args("ofSoundStreamSettings::bufferSize",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStreamSettings::bufferSize",1,"ofSoundStreamSettings *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStreamSettings,0))){ + SWIG_fail_ptr("SoundStreamSettings_bufferSize_get",1,SWIGTYPE_p_ofSoundStreamSettings); } + result = (size_t) ((arg1)->bufferSize); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; + fail: lua_error(L); return SWIG_arg; } +static int _wrap_SoundStreamSettings_numBuffers_set(lua_State* L) { int SWIG_arg = 0; + ofSoundStreamSettings *arg1 = (ofSoundStreamSettings *) 0 ; size_t arg2 ; + SWIG_check_num_args("ofSoundStreamSettings::numBuffers",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStreamSettings::numBuffers",1,"ofSoundStreamSettings *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSoundStreamSettings::numBuffers",2,"size_t"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStreamSettings,0))){ + SWIG_fail_ptr("SoundStreamSettings_numBuffers_set",1,SWIGTYPE_p_ofSoundStreamSettings); } + SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); + if (arg1) (arg1)->numBuffers = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_SoundStreamSettings_numBuffers_get(lua_State* L) { int SWIG_arg = 0; + ofSoundStreamSettings *arg1 = (ofSoundStreamSettings *) 0 ; size_t result; + SWIG_check_num_args("ofSoundStreamSettings::numBuffers",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStreamSettings::numBuffers",1,"ofSoundStreamSettings *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStreamSettings,0))){ + SWIG_fail_ptr("SoundStreamSettings_numBuffers_get",1,SWIGTYPE_p_ofSoundStreamSettings); } + result = (size_t) ((arg1)->numBuffers); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; + fail: lua_error(L); return SWIG_arg; } +static int _wrap_SoundStreamSettings_numInputChannels_set(lua_State* L) { int SWIG_arg = 0; + ofSoundStreamSettings *arg1 = (ofSoundStreamSettings *) 0 ; size_t arg2 ; + SWIG_check_num_args("ofSoundStreamSettings::numInputChannels",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStreamSettings::numInputChannels",1,"ofSoundStreamSettings *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSoundStreamSettings::numInputChannels",2,"size_t"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStreamSettings,0))){ + SWIG_fail_ptr("SoundStreamSettings_numInputChannels_set",1,SWIGTYPE_p_ofSoundStreamSettings); } + SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); + if (arg1) (arg1)->numInputChannels = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_SoundStreamSettings_numInputChannels_get(lua_State* L) { int SWIG_arg = 0; + ofSoundStreamSettings *arg1 = (ofSoundStreamSettings *) 0 ; size_t result; + SWIG_check_num_args("ofSoundStreamSettings::numInputChannels",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStreamSettings::numInputChannels",1,"ofSoundStreamSettings *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStreamSettings,0))){ + SWIG_fail_ptr("SoundStreamSettings_numInputChannels_get",1,SWIGTYPE_p_ofSoundStreamSettings); } + result = (size_t) ((arg1)->numInputChannels); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; + if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_SoundStreamSettings_numOutputChannels_set(lua_State* L) { int SWIG_arg = 0; + ofSoundStreamSettings *arg1 = (ofSoundStreamSettings *) 0 ; size_t arg2 ; + SWIG_check_num_args("ofSoundStreamSettings::numOutputChannels",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStreamSettings::numOutputChannels",1,"ofSoundStreamSettings *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSoundStreamSettings::numOutputChannels",2,"size_t"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStreamSettings,0))){ + SWIG_fail_ptr("SoundStreamSettings_numOutputChannels_set",1,SWIGTYPE_p_ofSoundStreamSettings); } + SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); + if (arg1) (arg1)->numOutputChannels = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_SoundStreamSettings_numOutputChannels_get(lua_State* L) { int SWIG_arg = 0; + ofSoundStreamSettings *arg1 = (ofSoundStreamSettings *) 0 ; size_t result; + SWIG_check_num_args("ofSoundStreamSettings::numOutputChannels",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStreamSettings::numOutputChannels",1,"ofSoundStreamSettings *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStreamSettings,0))){ + SWIG_fail_ptr("SoundStreamSettings_numOutputChannels_get",1,SWIGTYPE_p_ofSoundStreamSettings); } + result = (size_t) ((arg1)->numOutputChannels); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; + if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_SoundStreamSettings_setInDevice(lua_State* L) { int SWIG_arg = 0; + ofSoundStreamSettings *arg1 = (ofSoundStreamSettings *) 0 ; ofSoundDevice *arg2 = 0 ; bool result; + SWIG_check_num_args("ofSoundStreamSettings::setInDevice",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStreamSettings::setInDevice",1,"ofSoundStreamSettings *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofSoundStreamSettings::setInDevice",2,"ofSoundDevice const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStreamSettings,0))){ + SWIG_fail_ptr("SoundStreamSettings_setInDevice",1,SWIGTYPE_p_ofSoundStreamSettings); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofSoundDevice,0))){ + SWIG_fail_ptr("SoundStreamSettings_setInDevice",2,SWIGTYPE_p_ofSoundDevice); } + result = (bool)(arg1)->setInDevice((ofSoundDevice const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_SoundStreamSettings_setOutDevice(lua_State* L) { int SWIG_arg = 0; + ofSoundStreamSettings *arg1 = (ofSoundStreamSettings *) 0 ; ofSoundDevice *arg2 = 0 ; bool result; + SWIG_check_num_args("ofSoundStreamSettings::setOutDevice",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStreamSettings::setOutDevice",1,"ofSoundStreamSettings *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofSoundStreamSettings::setOutDevice",2,"ofSoundDevice const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStreamSettings,0))){ + SWIG_fail_ptr("SoundStreamSettings_setOutDevice",1,SWIGTYPE_p_ofSoundStreamSettings); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofSoundDevice,0))){ + SWIG_fail_ptr("SoundStreamSettings_setOutDevice",2,SWIGTYPE_p_ofSoundDevice); } + result = (bool)(arg1)->setOutDevice((ofSoundDevice const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_SoundStreamSettings_setApi(lua_State* L) { int SWIG_arg = 0; + ofSoundStreamSettings *arg1 = (ofSoundStreamSettings *) 0 ; ofSoundDevice::Api arg2 ; bool result; + SWIG_check_num_args("ofSoundStreamSettings::setApi",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStreamSettings::setApi",1,"ofSoundStreamSettings *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSoundStreamSettings::setApi",2,"ofSoundDevice::Api"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStreamSettings,0))){ + SWIG_fail_ptr("SoundStreamSettings_setApi",1,SWIGTYPE_p_ofSoundStreamSettings); } + arg2 = (ofSoundDevice::Api)(int)lua_tonumber(L, 2); result = (bool)(arg1)->setApi(arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_SoundStreamSettings_getInDevice(lua_State* L) { int SWIG_arg = 0; + ofSoundStreamSettings *arg1 = (ofSoundStreamSettings *) 0 ; ofSoundDevice *result = 0 ; + SWIG_check_num_args("ofSoundStreamSettings::getInDevice",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStreamSettings::getInDevice",1,"ofSoundStreamSettings const *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStreamSettings,0))){ + SWIG_fail_ptr("SoundStreamSettings_getInDevice",1,SWIGTYPE_p_ofSoundStreamSettings); } + result = (ofSoundDevice *)((ofSoundStreamSettings const *)arg1)->getInDevice(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofSoundDevice,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_SoundStreamSettings_getOutDevice(lua_State* L) { int SWIG_arg = 0; + ofSoundStreamSettings *arg1 = (ofSoundStreamSettings *) 0 ; ofSoundDevice *result = 0 ; + SWIG_check_num_args("ofSoundStreamSettings::getOutDevice",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStreamSettings::getOutDevice",1,"ofSoundStreamSettings const *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStreamSettings,0))){ + SWIG_fail_ptr("SoundStreamSettings_getOutDevice",1,SWIGTYPE_p_ofSoundStreamSettings); } + result = (ofSoundDevice *)((ofSoundStreamSettings const *)arg1)->getOutDevice(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofSoundDevice,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_SoundStreamSettings_getApi(lua_State* L) { int SWIG_arg = 0; + ofSoundStreamSettings *arg1 = (ofSoundStreamSettings *) 0 ; ofSoundDevice::Api result; + SWIG_check_num_args("ofSoundStreamSettings::getApi",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStreamSettings::getApi",1,"ofSoundStreamSettings const *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStreamSettings,0))){ + SWIG_fail_ptr("SoundStreamSettings_getApi",1,SWIGTYPE_p_ofSoundStreamSettings); } + result = (ofSoundDevice::Api)((ofSoundStreamSettings const *)arg1)->getApi(); + lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_SoundStreamSettings_inCallback_set(lua_State* L) { int SWIG_arg = 0; + ofSoundStreamSettings *arg1 = (ofSoundStreamSettings *) 0 ; + std::function< void (ofSoundBuffer &) > *arg2 = (std::function< void (ofSoundBuffer &) > *) 0 ; + SWIG_check_num_args("ofSoundStreamSettings::inCallback",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStreamSettings::inCallback",1,"ofSoundStreamSettings *"); + if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofSoundStreamSettings::inCallback",2,"std::function< void (ofSoundBuffer &) > *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStreamSettings,0))){ + SWIG_fail_ptr("SoundStreamSettings_inCallback_set",1,SWIGTYPE_p_ofSoundStreamSettings); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__functionT_void_fofSoundBuffer_RF_t,0))){ + SWIG_fail_ptr("SoundStreamSettings_inCallback_set",2,SWIGTYPE_p_std__functionT_void_fofSoundBuffer_RF_t); } + if (arg1) (arg1)->inCallback = *arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_SoundStreamSettings_inCallback_get(lua_State* L) { int SWIG_arg = 0; + ofSoundStreamSettings *arg1 = (ofSoundStreamSettings *) 0 ; std::function< void (ofSoundBuffer &) > *result = 0 ; + SWIG_check_num_args("ofSoundStreamSettings::inCallback",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStreamSettings::inCallback",1,"ofSoundStreamSettings *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStreamSettings,0))){ + SWIG_fail_ptr("SoundStreamSettings_inCallback_get",1,SWIGTYPE_p_ofSoundStreamSettings); } + result = (std::function< void (ofSoundBuffer &) > *)& ((arg1)->inCallback); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__functionT_void_fofSoundBuffer_RF_t,0); SWIG_arg++; return SWIG_arg; + if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_SoundStreamSettings_outCallback_set(lua_State* L) { int SWIG_arg = 0; + ofSoundStreamSettings *arg1 = (ofSoundStreamSettings *) 0 ; + std::function< void (ofSoundBuffer &) > *arg2 = (std::function< void (ofSoundBuffer &) > *) 0 ; + SWIG_check_num_args("ofSoundStreamSettings::outCallback",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStreamSettings::outCallback",1,"ofSoundStreamSettings *"); + if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofSoundStreamSettings::outCallback",2,"std::function< void (ofSoundBuffer &) > *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStreamSettings,0))){ + SWIG_fail_ptr("SoundStreamSettings_outCallback_set",1,SWIGTYPE_p_ofSoundStreamSettings); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__functionT_void_fofSoundBuffer_RF_t,0))){ + SWIG_fail_ptr("SoundStreamSettings_outCallback_set",2,SWIGTYPE_p_std__functionT_void_fofSoundBuffer_RF_t); } + if (arg1) (arg1)->outCallback = *arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_SoundStreamSettings_outCallback_get(lua_State* L) { int SWIG_arg = 0; + ofSoundStreamSettings *arg1 = (ofSoundStreamSettings *) 0 ; std::function< void (ofSoundBuffer &) > *result = 0 ; + SWIG_check_num_args("ofSoundStreamSettings::outCallback",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStreamSettings::outCallback",1,"ofSoundStreamSettings *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStreamSettings,0))){ + SWIG_fail_ptr("SoundStreamSettings_outCallback_get",1,SWIGTYPE_p_ofSoundStreamSettings); } + result = (std::function< void (ofSoundBuffer &) > *)& ((arg1)->outCallback); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__functionT_void_fofSoundBuffer_RF_t,0); SWIG_arg++; return SWIG_arg; + if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_new_SoundStreamSettings(lua_State* L) { int SWIG_arg = 0; ofSoundStreamSettings *result = 0 ; + SWIG_check_num_args("ofSoundStreamSettings::ofSoundStreamSettings",0,0) + result = (ofSoundStreamSettings *)new ofSoundStreamSettings(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofSoundStreamSettings,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static void swig_delete_SoundStreamSettings(void *obj) { +ofSoundStreamSettings *arg1 = (ofSoundStreamSettings *) obj; +delete arg1; +} +static int _proxy__wrap_new_SoundStreamSettings(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_SoundStreamSettings); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_SoundStreamSettings_attributes[] = { + { "sampleRate", _wrap_SoundStreamSettings_sampleRate_get, _wrap_SoundStreamSettings_sampleRate_set }, + { "bufferSize", _wrap_SoundStreamSettings_bufferSize_get, _wrap_SoundStreamSettings_bufferSize_set }, + { "numBuffers", _wrap_SoundStreamSettings_numBuffers_get, _wrap_SoundStreamSettings_numBuffers_set }, + { "numInputChannels", _wrap_SoundStreamSettings_numInputChannels_get, _wrap_SoundStreamSettings_numInputChannels_set }, + { "numOutputChannels", _wrap_SoundStreamSettings_numOutputChannels_get, _wrap_SoundStreamSettings_numOutputChannels_set }, + { "inCallback", _wrap_SoundStreamSettings_inCallback_get, _wrap_SoundStreamSettings_inCallback_set }, + { "outCallback", _wrap_SoundStreamSettings_outCallback_get, _wrap_SoundStreamSettings_outCallback_set }, + {0,0,0} +}; +static swig_lua_method swig_SoundStreamSettings_methods[]= { + { "setInDevice", _wrap_SoundStreamSettings_setInDevice}, + { "setOutDevice", _wrap_SoundStreamSettings_setOutDevice}, + { "setApi", _wrap_SoundStreamSettings_setApi}, + { "getInDevice", _wrap_SoundStreamSettings_getInDevice}, + { "getOutDevice", _wrap_SoundStreamSettings_getOutDevice}, + { "getApi", _wrap_SoundStreamSettings_getApi}, + {0,0} +}; +static swig_lua_method swig_SoundStreamSettings_meta[] = { + {0,0} +}; + +static swig_lua_attribute swig_SoundStreamSettings_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_SoundStreamSettings_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_SoundStreamSettings_Sf_SwigStatic_methods[]= { + {0,0} +}; +static swig_lua_class* swig_SoundStreamSettings_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_SoundStreamSettings_Sf_SwigStatic = { + "SoundStreamSettings", + swig_SoundStreamSettings_Sf_SwigStatic_methods, + swig_SoundStreamSettings_Sf_SwigStatic_attributes, + swig_SoundStreamSettings_Sf_SwigStatic_constants, + swig_SoundStreamSettings_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_SoundStreamSettings_bases[] = {0}; +static const char *swig_SoundStreamSettings_base_names[] = {0}; +static swig_lua_class _wrap_class_SoundStreamSettings = { "SoundStreamSettings", "SoundStreamSettings", &SWIGTYPE_p_ofSoundStreamSettings,_proxy__wrap_new_SoundStreamSettings, swig_delete_SoundStreamSettings, swig_SoundStreamSettings_methods, swig_SoundStreamSettings_attributes, &swig_SoundStreamSettings_Sf_SwigStatic, swig_SoundStreamSettings_meta, swig_SoundStreamSettings_bases, swig_SoundStreamSettings_base_names }; + +static int _wrap_BaseSoundStream_setup(lua_State* L) { int SWIG_arg = 0; ofBaseSoundStream *arg1 = (ofBaseSoundStream *) 0 ; + ofSoundStreamSettings *arg2 = 0 ; bool result; SWIG_check_num_args("ofBaseSoundStream::setup",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBaseSoundStream::setup",1,"ofBaseSoundStream *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofBaseSoundStream::setup",2,"ofSoundStreamSettings const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBaseSoundStream,0))){ + SWIG_fail_ptr("BaseSoundStream_setup",1,SWIGTYPE_p_ofBaseSoundStream); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofSoundStreamSettings,0))){ + SWIG_fail_ptr("BaseSoundStream_setup",2,SWIGTYPE_p_ofSoundStreamSettings); } + result = (bool)(arg1)->setup((ofSoundStreamSettings const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_BaseSoundStream_setInput(lua_State* L) { int SWIG_arg = 0; ofBaseSoundStream *arg1 = (ofBaseSoundStream *) 0 ; + ofBaseSoundInput *arg2 = (ofBaseSoundInput *) 0 ; SWIG_check_num_args("ofBaseSoundStream::setInput",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBaseSoundStream::setInput",1,"ofBaseSoundStream *"); + if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofBaseSoundStream::setInput",2,"ofBaseSoundInput *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBaseSoundStream,0))){ + SWIG_fail_ptr("BaseSoundStream_setInput",1,SWIGTYPE_p_ofBaseSoundStream); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBaseSoundInput,0))){ + SWIG_fail_ptr("BaseSoundStream_setInput",2,SWIGTYPE_p_ofBaseSoundInput); } (arg1)->setInput(arg2); return SWIG_arg; + if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_BaseSoundStream_setOutput(lua_State* L) { int SWIG_arg = 0; ofBaseSoundStream *arg1 = (ofBaseSoundStream *) 0 ; + ofBaseSoundOutput *arg2 = (ofBaseSoundOutput *) 0 ; SWIG_check_num_args("ofBaseSoundStream::setOutput",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBaseSoundStream::setOutput",1,"ofBaseSoundStream *"); + if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofBaseSoundStream::setOutput",2,"ofBaseSoundOutput *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBaseSoundStream,0))){ + SWIG_fail_ptr("BaseSoundStream_setOutput",1,SWIGTYPE_p_ofBaseSoundStream); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBaseSoundOutput,0))){ + SWIG_fail_ptr("BaseSoundStream_setOutput",2,SWIGTYPE_p_ofBaseSoundOutput); } (arg1)->setOutput(arg2); return SWIG_arg; + if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_BaseSoundStream_getDeviceList(lua_State* L) { int SWIG_arg = 0; + ofBaseSoundStream *arg1 = (ofBaseSoundStream *) 0 ; ofSoundDevice::Api arg2 ; + SwigValueWrapper< std::vector< ofSoundDevice > > result; SWIG_check_num_args("ofBaseSoundStream::getDeviceList",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBaseSoundStream::getDeviceList",1,"ofBaseSoundStream const *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBaseSoundStream::getDeviceList",2,"ofSoundDevice::Api"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBaseSoundStream,0))){ + SWIG_fail_ptr("BaseSoundStream_getDeviceList",1,SWIGTYPE_p_ofBaseSoundStream); } + arg2 = (ofSoundDevice::Api)(int)lua_tonumber(L, 2); result = ((ofBaseSoundStream const *)arg1)->getDeviceList(arg2); { + std::vector< ofSoundDevice > * resultptr = new std::vector< ofSoundDevice >((const std::vector< ofSoundDevice > &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_ofSoundDevice_t,1); SWIG_arg++; } return SWIG_arg; + if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_BaseSoundStream_printDeviceList(lua_State* L) { int SWIG_arg = 0; + ofBaseSoundStream *arg1 = (ofBaseSoundStream *) 0 ; SWIG_check_num_args("ofBaseSoundStream::printDeviceList",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBaseSoundStream::printDeviceList",1,"ofBaseSoundStream const *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBaseSoundStream,0))){ + SWIG_fail_ptr("BaseSoundStream_printDeviceList",1,SWIGTYPE_p_ofBaseSoundStream); } + ((ofBaseSoundStream const *)arg1)->printDeviceList(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_BaseSoundStream_start(lua_State* L) { int SWIG_arg = 0; ofBaseSoundStream *arg1 = (ofBaseSoundStream *) 0 ; + SWIG_check_num_args("ofBaseSoundStream::start",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBaseSoundStream::start",1,"ofBaseSoundStream *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBaseSoundStream,0))){ + SWIG_fail_ptr("BaseSoundStream_start",1,SWIGTYPE_p_ofBaseSoundStream); } (arg1)->start(); return SWIG_arg; if(0) SWIG_fail; + fail: lua_error(L); return SWIG_arg; } +static int _wrap_BaseSoundStream_stop(lua_State* L) { int SWIG_arg = 0; ofBaseSoundStream *arg1 = (ofBaseSoundStream *) 0 ; + SWIG_check_num_args("ofBaseSoundStream::stop",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBaseSoundStream::stop",1,"ofBaseSoundStream *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBaseSoundStream,0))){ + SWIG_fail_ptr("BaseSoundStream_stop",1,SWIGTYPE_p_ofBaseSoundStream); } (arg1)->stop(); return SWIG_arg; if(0) SWIG_fail; + fail: lua_error(L); return SWIG_arg; } +static int _wrap_BaseSoundStream_close(lua_State* L) { int SWIG_arg = 0; ofBaseSoundStream *arg1 = (ofBaseSoundStream *) 0 ; + SWIG_check_num_args("ofBaseSoundStream::close",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBaseSoundStream::close",1,"ofBaseSoundStream *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBaseSoundStream,0))){ + SWIG_fail_ptr("BaseSoundStream_close",1,SWIGTYPE_p_ofBaseSoundStream); } (arg1)->close(); return SWIG_arg; if(0) SWIG_fail; + fail: lua_error(L); return SWIG_arg; } +static int _wrap_BaseSoundStream_getTickCount(lua_State* L) { int SWIG_arg = 0; + ofBaseSoundStream *arg1 = (ofBaseSoundStream *) 0 ; uint64_t result; + SWIG_check_num_args("ofBaseSoundStream::getTickCount",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBaseSoundStream::getTickCount",1,"ofBaseSoundStream const *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBaseSoundStream,0))){ + SWIG_fail_ptr("BaseSoundStream_getTickCount",1,SWIGTYPE_p_ofBaseSoundStream); } + result = (uint64_t)((ofBaseSoundStream const *)arg1)->getTickCount(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_BaseSoundStream_getNumInputChannels(lua_State* L) { int SWIG_arg = 0; + ofBaseSoundStream *arg1 = (ofBaseSoundStream *) 0 ; int result; + SWIG_check_num_args("ofBaseSoundStream::getNumInputChannels",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBaseSoundStream::getNumInputChannels",1,"ofBaseSoundStream const *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBaseSoundStream,0))){ + SWIG_fail_ptr("BaseSoundStream_getNumInputChannels",1,SWIGTYPE_p_ofBaseSoundStream); } + result = (int)((ofBaseSoundStream const *)arg1)->getNumInputChannels(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_BaseSoundStream_getNumOutputChannels(lua_State* L) { int SWIG_arg = 0; + ofBaseSoundStream *arg1 = (ofBaseSoundStream *) 0 ; int result; + SWIG_check_num_args("ofBaseSoundStream::getNumOutputChannels",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBaseSoundStream::getNumOutputChannels",1,"ofBaseSoundStream const *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBaseSoundStream,0))){ + SWIG_fail_ptr("BaseSoundStream_getNumOutputChannels",1,SWIGTYPE_p_ofBaseSoundStream); } + result = (int)((ofBaseSoundStream const *)arg1)->getNumOutputChannels(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_BaseSoundStream_getSampleRate(lua_State* L) { int SWIG_arg = 0; + ofBaseSoundStream *arg1 = (ofBaseSoundStream *) 0 ; int result; SWIG_check_num_args("ofBaseSoundStream::getSampleRate",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBaseSoundStream::getSampleRate",1,"ofBaseSoundStream const *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBaseSoundStream,0))){ + SWIG_fail_ptr("BaseSoundStream_getSampleRate",1,SWIGTYPE_p_ofBaseSoundStream); } + result = (int)((ofBaseSoundStream const *)arg1)->getSampleRate(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_BaseSoundStream_getBufferSize(lua_State* L) { int SWIG_arg = 0; + ofBaseSoundStream *arg1 = (ofBaseSoundStream *) 0 ; int result; SWIG_check_num_args("ofBaseSoundStream::getBufferSize",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBaseSoundStream::getBufferSize",1,"ofBaseSoundStream const *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBaseSoundStream,0))){ + SWIG_fail_ptr("BaseSoundStream_getBufferSize",1,SWIGTYPE_p_ofBaseSoundStream); } + result = (int)((ofBaseSoundStream const *)arg1)->getBufferSize(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_BaseSoundStream_getInDevice(lua_State* L) { int SWIG_arg = 0; + ofBaseSoundStream *arg1 = (ofBaseSoundStream *) 0 ; ofSoundDevice result; + SWIG_check_num_args("ofBaseSoundStream::getInDevice",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBaseSoundStream::getInDevice",1,"ofBaseSoundStream const *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBaseSoundStream,0))){ + SWIG_fail_ptr("BaseSoundStream_getInDevice",1,SWIGTYPE_p_ofBaseSoundStream); } + result = ((ofBaseSoundStream const *)arg1)->getInDevice(); { + ofSoundDevice * resultptr = new ofSoundDevice((const ofSoundDevice &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofSoundDevice,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_BaseSoundStream_getOutDevice(lua_State* L) { int SWIG_arg = 0; + ofBaseSoundStream *arg1 = (ofBaseSoundStream *) 0 ; ofSoundDevice result; + SWIG_check_num_args("ofBaseSoundStream::getOutDevice",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBaseSoundStream::getOutDevice",1,"ofBaseSoundStream const *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBaseSoundStream,0))){ + SWIG_fail_ptr("BaseSoundStream_getOutDevice",1,SWIGTYPE_p_ofBaseSoundStream); } + result = ((ofBaseSoundStream const *)arg1)->getOutDevice(); { + ofSoundDevice * resultptr = new ofSoundDevice((const ofSoundDevice &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofSoundDevice,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static void swig_delete_BaseSoundStream(void *obj) { +ofBaseSoundStream *arg1 = (ofBaseSoundStream *) obj; +delete arg1; +} +static swig_lua_attribute swig_BaseSoundStream_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_BaseSoundStream_methods[]= { + { "setup", _wrap_BaseSoundStream_setup}, + { "setInput", _wrap_BaseSoundStream_setInput}, + { "setOutput", _wrap_BaseSoundStream_setOutput}, + { "getDeviceList", _wrap_BaseSoundStream_getDeviceList}, + { "printDeviceList", _wrap_BaseSoundStream_printDeviceList}, + { "start", _wrap_BaseSoundStream_start}, + { "stop", _wrap_BaseSoundStream_stop}, + { "close", _wrap_BaseSoundStream_close}, + { "getTickCount", _wrap_BaseSoundStream_getTickCount}, + { "getNumInputChannels", _wrap_BaseSoundStream_getNumInputChannels}, + { "getNumOutputChannels", _wrap_BaseSoundStream_getNumOutputChannels}, + { "getSampleRate", _wrap_BaseSoundStream_getSampleRate}, + { "getBufferSize", _wrap_BaseSoundStream_getBufferSize}, + { "getInDevice", _wrap_BaseSoundStream_getInDevice}, + { "getOutDevice", _wrap_BaseSoundStream_getOutDevice}, + {0,0} +}; +static swig_lua_method swig_BaseSoundStream_meta[] = { + {0,0} +}; + +static swig_lua_attribute swig_BaseSoundStream_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_BaseSoundStream_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_BaseSoundStream_Sf_SwigStatic_methods[]= { + {0,0} +}; +static swig_lua_class* swig_BaseSoundStream_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_BaseSoundStream_Sf_SwigStatic = { + "BaseSoundStream", + swig_BaseSoundStream_Sf_SwigStatic_methods, + swig_BaseSoundStream_Sf_SwigStatic_attributes, + swig_BaseSoundStream_Sf_SwigStatic_constants, + swig_BaseSoundStream_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_BaseSoundStream_bases[] = {0}; +static const char *swig_BaseSoundStream_base_names[] = {0}; +static swig_lua_class _wrap_class_BaseSoundStream = { "BaseSoundStream", "BaseSoundStream", &SWIGTYPE_p_ofBaseSoundStream,0, swig_delete_BaseSoundStream, swig_BaseSoundStream_methods, swig_BaseSoundStream_attributes, &swig_BaseSoundStream_Sf_SwigStatic, swig_BaseSoundStream_meta, swig_BaseSoundStream_bases, swig_BaseSoundStream_base_names }; + +static int _wrap_toString(lua_State* L) { int SWIG_arg = 0; ofSoundDevice::Api arg1 ; std::string result; + SWIG_check_num_args("toString",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("toString",1,"ofSoundDevice::Api"); + arg1 = (ofSoundDevice::Api)(int)lua_tonumber(L, 1); result = toString(arg1); + lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_BaseSoundPlayer_load__SWIG_0(lua_State* L) { int SWIG_arg = 0; + ofBaseSoundPlayer *arg1 = (ofBaseSoundPlayer *) 0 ; std::filesystem::path *arg2 = 0 ; bool arg3 ; + std::filesystem::path temp2 ; bool result; SWIG_check_num_args("ofBaseSoundPlayer::load",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBaseSoundPlayer::load",1,"ofBaseSoundPlayer *"); + if(!lua_isstring(L,2)) SWIG_fail_arg("ofBaseSoundPlayer::load",2,"std::filesystem::path const &"); + if(!lua_isboolean(L,3)) SWIG_fail_arg("ofBaseSoundPlayer::load",3,"bool"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBaseSoundPlayer,0))){ + SWIG_fail_ptr("BaseSoundPlayer_load",1,SWIGTYPE_p_ofBaseSoundPlayer); } { size_t len = lua_rawlen(L, 2); + temp2 = lua_tolstring(L, 2, &len); arg2 = &temp2; } arg3 = (lua_toboolean(L, 3)!=0); + result = (bool)(arg1)->load((std::filesystem::path const &)*arg2,arg3); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_BaseSoundPlayer_load__SWIG_1(lua_State* L) { int SWIG_arg = 0; + ofBaseSoundPlayer *arg1 = (ofBaseSoundPlayer *) 0 ; std::filesystem::path *arg2 = 0 ; std::filesystem::path temp2 ; + bool result; SWIG_check_num_args("ofBaseSoundPlayer::load",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBaseSoundPlayer::load",1,"ofBaseSoundPlayer *"); + if(!lua_isstring(L,2)) SWIG_fail_arg("ofBaseSoundPlayer::load",2,"std::filesystem::path const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBaseSoundPlayer,0))){ + SWIG_fail_ptr("BaseSoundPlayer_load",1,SWIGTYPE_p_ofBaseSoundPlayer); } { size_t len = lua_rawlen(L, 2); + temp2 = lua_tolstring(L, 2, &len); arg2 = &temp2; } result = (bool)(arg1)->load((std::filesystem::path const &)*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_BaseSoundPlayer_load(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { + return _wrap_BaseSoundPlayer_load__SWIG_1(L);} if (argc == 3) { return _wrap_BaseSoundPlayer_load__SWIG_0(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'BaseSoundPlayer_load'\n" + " Possible C/C++ prototypes are:\n" " ofBaseSoundPlayer::load(std::filesystem::path const &,bool)\n" + " ofBaseSoundPlayer::load(std::filesystem::path const &)\n"); lua_error(L);return 0; } +static int _wrap_BaseSoundPlayer_unload(lua_State* L) { int SWIG_arg = 0; ofBaseSoundPlayer *arg1 = (ofBaseSoundPlayer *) 0 ; + SWIG_check_num_args("ofBaseSoundPlayer::unload",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBaseSoundPlayer::unload",1,"ofBaseSoundPlayer *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBaseSoundPlayer,0))){ + SWIG_fail_ptr("BaseSoundPlayer_unload",1,SWIGTYPE_p_ofBaseSoundPlayer); } (arg1)->unload(); return SWIG_arg; + if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_BaseSoundPlayer_play(lua_State* L) { int SWIG_arg = 0; ofBaseSoundPlayer *arg1 = (ofBaseSoundPlayer *) 0 ; + SWIG_check_num_args("ofBaseSoundPlayer::play",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBaseSoundPlayer::play",1,"ofBaseSoundPlayer *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBaseSoundPlayer,0))){ + SWIG_fail_ptr("BaseSoundPlayer_play",1,SWIGTYPE_p_ofBaseSoundPlayer); } (arg1)->play(); return SWIG_arg; if(0) SWIG_fail; + fail: lua_error(L); return SWIG_arg; } +static int _wrap_BaseSoundPlayer_stop(lua_State* L) { int SWIG_arg = 0; ofBaseSoundPlayer *arg1 = (ofBaseSoundPlayer *) 0 ; + SWIG_check_num_args("ofBaseSoundPlayer::stop",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBaseSoundPlayer::stop",1,"ofBaseSoundPlayer *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBaseSoundPlayer,0))){ + SWIG_fail_ptr("BaseSoundPlayer_stop",1,SWIGTYPE_p_ofBaseSoundPlayer); } (arg1)->stop(); return SWIG_arg; if(0) SWIG_fail; + fail: lua_error(L); return SWIG_arg; } +static int _wrap_BaseSoundPlayer_setVolume(lua_State* L) { int SWIG_arg = 0; ofBaseSoundPlayer *arg1 = (ofBaseSoundPlayer *) 0 ; + float arg2 ; SWIG_check_num_args("ofBaseSoundPlayer::setVolume",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBaseSoundPlayer::setVolume",1,"ofBaseSoundPlayer *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBaseSoundPlayer::setVolume",2,"float"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBaseSoundPlayer,0))){ + SWIG_fail_ptr("BaseSoundPlayer_setVolume",1,SWIGTYPE_p_ofBaseSoundPlayer); } arg2 = (float)lua_tonumber(L, 2); + (arg1)->setVolume(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_BaseSoundPlayer_setPan(lua_State* L) { int SWIG_arg = 0; ofBaseSoundPlayer *arg1 = (ofBaseSoundPlayer *) 0 ; + float arg2 ; SWIG_check_num_args("ofBaseSoundPlayer::setPan",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBaseSoundPlayer::setPan",1,"ofBaseSoundPlayer *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBaseSoundPlayer::setPan",2,"float"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBaseSoundPlayer,0))){ + SWIG_fail_ptr("BaseSoundPlayer_setPan",1,SWIGTYPE_p_ofBaseSoundPlayer); } arg2 = (float)lua_tonumber(L, 2); + (arg1)->setPan(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_BaseSoundPlayer_setSpeed(lua_State* L) { int SWIG_arg = 0; ofBaseSoundPlayer *arg1 = (ofBaseSoundPlayer *) 0 ; + float arg2 ; SWIG_check_num_args("ofBaseSoundPlayer::setSpeed",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBaseSoundPlayer::setSpeed",1,"ofBaseSoundPlayer *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBaseSoundPlayer::setSpeed",2,"float"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBaseSoundPlayer,0))){ + SWIG_fail_ptr("BaseSoundPlayer_setSpeed",1,SWIGTYPE_p_ofBaseSoundPlayer); } arg2 = (float)lua_tonumber(L, 2); + (arg1)->setSpeed(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_BaseSoundPlayer_setPaused(lua_State* L) { int SWIG_arg = 0; ofBaseSoundPlayer *arg1 = (ofBaseSoundPlayer *) 0 ; + bool arg2 ; SWIG_check_num_args("ofBaseSoundPlayer::setPaused",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBaseSoundPlayer::setPaused",1,"ofBaseSoundPlayer *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("ofBaseSoundPlayer::setPaused",2,"bool"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBaseSoundPlayer,0))){ + SWIG_fail_ptr("BaseSoundPlayer_setPaused",1,SWIGTYPE_p_ofBaseSoundPlayer); } arg2 = (lua_toboolean(L, 2)!=0); + (arg1)->setPaused(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_BaseSoundPlayer_setLoop(lua_State* L) { int SWIG_arg = 0; ofBaseSoundPlayer *arg1 = (ofBaseSoundPlayer *) 0 ; + bool arg2 ; SWIG_check_num_args("ofBaseSoundPlayer::setLoop",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBaseSoundPlayer::setLoop",1,"ofBaseSoundPlayer *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("ofBaseSoundPlayer::setLoop",2,"bool"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBaseSoundPlayer,0))){ + SWIG_fail_ptr("BaseSoundPlayer_setLoop",1,SWIGTYPE_p_ofBaseSoundPlayer); } arg2 = (lua_toboolean(L, 2)!=0); + (arg1)->setLoop(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_BaseSoundPlayer_setMultiPlay(lua_State* L) { int SWIG_arg = 0; + ofBaseSoundPlayer *arg1 = (ofBaseSoundPlayer *) 0 ; bool arg2 ; SWIG_check_num_args("ofBaseSoundPlayer::setMultiPlay",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBaseSoundPlayer::setMultiPlay",1,"ofBaseSoundPlayer *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("ofBaseSoundPlayer::setMultiPlay",2,"bool"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBaseSoundPlayer,0))){ + SWIG_fail_ptr("BaseSoundPlayer_setMultiPlay",1,SWIGTYPE_p_ofBaseSoundPlayer); } arg2 = (lua_toboolean(L, 2)!=0); + (arg1)->setMultiPlay(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_BaseSoundPlayer_setPosition(lua_State* L) { int SWIG_arg = 0; + ofBaseSoundPlayer *arg1 = (ofBaseSoundPlayer *) 0 ; float arg2 ; SWIG_check_num_args("ofBaseSoundPlayer::setPosition",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBaseSoundPlayer::setPosition",1,"ofBaseSoundPlayer *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBaseSoundPlayer::setPosition",2,"float"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBaseSoundPlayer,0))){ + SWIG_fail_ptr("BaseSoundPlayer_setPosition",1,SWIGTYPE_p_ofBaseSoundPlayer); } arg2 = (float)lua_tonumber(L, 2); + (arg1)->setPosition(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_BaseSoundPlayer_setPositionMS(lua_State* L) { int SWIG_arg = 0; + ofBaseSoundPlayer *arg1 = (ofBaseSoundPlayer *) 0 ; int arg2 ; SWIG_check_num_args("ofBaseSoundPlayer::setPositionMS",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBaseSoundPlayer::setPositionMS",1,"ofBaseSoundPlayer *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBaseSoundPlayer::setPositionMS",2,"int"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBaseSoundPlayer,0))){ + SWIG_fail_ptr("BaseSoundPlayer_setPositionMS",1,SWIGTYPE_p_ofBaseSoundPlayer); } arg2 = (int)lua_tonumber(L, 2); + (arg1)->setPositionMS(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_BaseSoundPlayer_getPosition(lua_State* L) { int SWIG_arg = 0; + ofBaseSoundPlayer *arg1 = (ofBaseSoundPlayer *) 0 ; float result; SWIG_check_num_args("ofBaseSoundPlayer::getPosition",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBaseSoundPlayer::getPosition",1,"ofBaseSoundPlayer const *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBaseSoundPlayer,0))){ + SWIG_fail_ptr("BaseSoundPlayer_getPosition",1,SWIGTYPE_p_ofBaseSoundPlayer); } + result = (float)((ofBaseSoundPlayer const *)arg1)->getPosition(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_BaseSoundPlayer_getPositionMS(lua_State* L) { int SWIG_arg = 0; + ofBaseSoundPlayer *arg1 = (ofBaseSoundPlayer *) 0 ; int result; SWIG_check_num_args("ofBaseSoundPlayer::getPositionMS",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBaseSoundPlayer::getPositionMS",1,"ofBaseSoundPlayer const *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBaseSoundPlayer,0))){ + SWIG_fail_ptr("BaseSoundPlayer_getPositionMS",1,SWIGTYPE_p_ofBaseSoundPlayer); } + result = (int)((ofBaseSoundPlayer const *)arg1)->getPositionMS(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_BaseSoundPlayer_isPlaying(lua_State* L) { int SWIG_arg = 0; ofBaseSoundPlayer *arg1 = (ofBaseSoundPlayer *) 0 ; + bool result; SWIG_check_num_args("ofBaseSoundPlayer::isPlaying",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBaseSoundPlayer::isPlaying",1,"ofBaseSoundPlayer const *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBaseSoundPlayer,0))){ + SWIG_fail_ptr("BaseSoundPlayer_isPlaying",1,SWIGTYPE_p_ofBaseSoundPlayer); } + result = (bool)((ofBaseSoundPlayer const *)arg1)->isPlaying(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_BaseSoundPlayer_getSpeed(lua_State* L) { int SWIG_arg = 0; ofBaseSoundPlayer *arg1 = (ofBaseSoundPlayer *) 0 ; + float result; SWIG_check_num_args("ofBaseSoundPlayer::getSpeed",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBaseSoundPlayer::getSpeed",1,"ofBaseSoundPlayer const *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBaseSoundPlayer,0))){ + SWIG_fail_ptr("BaseSoundPlayer_getSpeed",1,SWIGTYPE_p_ofBaseSoundPlayer); } + result = (float)((ofBaseSoundPlayer const *)arg1)->getSpeed(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_BaseSoundPlayer_getPan(lua_State* L) { int SWIG_arg = 0; ofBaseSoundPlayer *arg1 = (ofBaseSoundPlayer *) 0 ; + float result; SWIG_check_num_args("ofBaseSoundPlayer::getPan",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBaseSoundPlayer::getPan",1,"ofBaseSoundPlayer const *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBaseSoundPlayer,0))){ + SWIG_fail_ptr("BaseSoundPlayer_getPan",1,SWIGTYPE_p_ofBaseSoundPlayer); } + result = (float)((ofBaseSoundPlayer const *)arg1)->getPan(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_BaseSoundPlayer_isLoaded(lua_State* L) { int SWIG_arg = 0; ofBaseSoundPlayer *arg1 = (ofBaseSoundPlayer *) 0 ; + bool result; SWIG_check_num_args("ofBaseSoundPlayer::isLoaded",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBaseSoundPlayer::isLoaded",1,"ofBaseSoundPlayer const *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBaseSoundPlayer,0))){ + SWIG_fail_ptr("BaseSoundPlayer_isLoaded",1,SWIGTYPE_p_ofBaseSoundPlayer); } + result = (bool)((ofBaseSoundPlayer const *)arg1)->isLoaded(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_BaseSoundPlayer_getVolume(lua_State* L) { int SWIG_arg = 0; ofBaseSoundPlayer *arg1 = (ofBaseSoundPlayer *) 0 ; + float result; SWIG_check_num_args("ofBaseSoundPlayer::getVolume",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBaseSoundPlayer::getVolume",1,"ofBaseSoundPlayer const *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBaseSoundPlayer,0))){ + SWIG_fail_ptr("BaseSoundPlayer_getVolume",1,SWIGTYPE_p_ofBaseSoundPlayer); } + result = (float)((ofBaseSoundPlayer const *)arg1)->getVolume(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static void swig_delete_BaseSoundPlayer(void *obj) { +ofBaseSoundPlayer *arg1 = (ofBaseSoundPlayer *) obj; +delete arg1; +} +static swig_lua_attribute swig_BaseSoundPlayer_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_BaseSoundPlayer_methods[]= { + { "load", _wrap_BaseSoundPlayer_load}, + { "unload", _wrap_BaseSoundPlayer_unload}, + { "play", _wrap_BaseSoundPlayer_play}, + { "stop", _wrap_BaseSoundPlayer_stop}, + { "setVolume", _wrap_BaseSoundPlayer_setVolume}, + { "setPan", _wrap_BaseSoundPlayer_setPan}, + { "setSpeed", _wrap_BaseSoundPlayer_setSpeed}, + { "setPaused", _wrap_BaseSoundPlayer_setPaused}, + { "setLoop", _wrap_BaseSoundPlayer_setLoop}, + { "setMultiPlay", _wrap_BaseSoundPlayer_setMultiPlay}, + { "setPosition", _wrap_BaseSoundPlayer_setPosition}, + { "setPositionMS", _wrap_BaseSoundPlayer_setPositionMS}, + { "getPosition", _wrap_BaseSoundPlayer_getPosition}, + { "getPositionMS", _wrap_BaseSoundPlayer_getPositionMS}, + { "isPlaying", _wrap_BaseSoundPlayer_isPlaying}, + { "getSpeed", _wrap_BaseSoundPlayer_getSpeed}, + { "getPan", _wrap_BaseSoundPlayer_getPan}, + { "isLoaded", _wrap_BaseSoundPlayer_isLoaded}, + { "getVolume", _wrap_BaseSoundPlayer_getVolume}, + {0,0} +}; +static swig_lua_method swig_BaseSoundPlayer_meta[] = { + {0,0} +}; + +static swig_lua_attribute swig_BaseSoundPlayer_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_BaseSoundPlayer_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_BaseSoundPlayer_Sf_SwigStatic_methods[]= { + {0,0} +}; +static swig_lua_class* swig_BaseSoundPlayer_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_BaseSoundPlayer_Sf_SwigStatic = { + "BaseSoundPlayer", + swig_BaseSoundPlayer_Sf_SwigStatic_methods, + swig_BaseSoundPlayer_Sf_SwigStatic_attributes, + swig_BaseSoundPlayer_Sf_SwigStatic_constants, + swig_BaseSoundPlayer_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_BaseSoundPlayer_bases[] = {0}; +static const char *swig_BaseSoundPlayer_base_names[] = {0}; +static swig_lua_class _wrap_class_BaseSoundPlayer = { "BaseSoundPlayer", "BaseSoundPlayer", &SWIGTYPE_p_ofBaseSoundPlayer,0, swig_delete_BaseSoundPlayer, swig_BaseSoundPlayer_methods, swig_BaseSoundPlayer_attributes, &swig_BaseSoundPlayer_Sf_SwigStatic, swig_BaseSoundPlayer_meta, swig_BaseSoundPlayer_bases, swig_BaseSoundPlayer_base_names }; + +static int _wrap_VideoFormat_pixelFormat_set(lua_State* L) { int SWIG_arg = 0; ofVideoFormat *arg1 = (ofVideoFormat *) 0 ; + ofPixelFormat arg2 ; SWIG_check_num_args("ofVideoFormat::pixelFormat",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoFormat::pixelFormat",1,"ofVideoFormat *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVideoFormat::pixelFormat",2,"ofPixelFormat"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoFormat,0))){ + SWIG_fail_ptr("VideoFormat_pixelFormat_set",1,SWIGTYPE_p_ofVideoFormat); } arg2 = (ofPixelFormat)(int)lua_tonumber(L, 2); + if (arg1) (arg1)->pixelFormat = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_VideoFormat_pixelFormat_get(lua_State* L) { int SWIG_arg = 0; ofVideoFormat *arg1 = (ofVideoFormat *) 0 ; + ofPixelFormat result; SWIG_check_num_args("ofVideoFormat::pixelFormat",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoFormat::pixelFormat",1,"ofVideoFormat *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoFormat,0))){ + SWIG_fail_ptr("VideoFormat_pixelFormat_get",1,SWIGTYPE_p_ofVideoFormat); } result = (ofPixelFormat) ((arg1)->pixelFormat); + lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_VideoFormat_width_set(lua_State* L) { int SWIG_arg = 0; ofVideoFormat *arg1 = (ofVideoFormat *) 0 ; int arg2 ; + SWIG_check_num_args("ofVideoFormat::width",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoFormat::width",1,"ofVideoFormat *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVideoFormat::width",2,"int"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoFormat,0))){ + SWIG_fail_ptr("VideoFormat_width_set",1,SWIGTYPE_p_ofVideoFormat); } arg2 = (int)lua_tonumber(L, 2); + if (arg1) (arg1)->width = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_VideoFormat_width_get(lua_State* L) { int SWIG_arg = 0; ofVideoFormat *arg1 = (ofVideoFormat *) 0 ; int result; + SWIG_check_num_args("ofVideoFormat::width",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoFormat::width",1,"ofVideoFormat *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoFormat,0))){ + SWIG_fail_ptr("VideoFormat_width_get",1,SWIGTYPE_p_ofVideoFormat); } result = (int) ((arg1)->width); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_VideoFormat_height_set(lua_State* L) { int SWIG_arg = 0; ofVideoFormat *arg1 = (ofVideoFormat *) 0 ; int arg2 ; + SWIG_check_num_args("ofVideoFormat::height",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoFormat::height",1,"ofVideoFormat *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVideoFormat::height",2,"int"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoFormat,0))){ + SWIG_fail_ptr("VideoFormat_height_set",1,SWIGTYPE_p_ofVideoFormat); } arg2 = (int)lua_tonumber(L, 2); + if (arg1) (arg1)->height = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_VideoFormat_height_get(lua_State* L) { int SWIG_arg = 0; ofVideoFormat *arg1 = (ofVideoFormat *) 0 ; + int result; SWIG_check_num_args("ofVideoFormat::height",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoFormat::height",1,"ofVideoFormat *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoFormat,0))){ + SWIG_fail_ptr("VideoFormat_height_get",1,SWIGTYPE_p_ofVideoFormat); } result = (int) ((arg1)->height); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_VideoFormat_framerates_set(lua_State* L) { int SWIG_arg = 0; ofVideoFormat *arg1 = (ofVideoFormat *) 0 ; + std::vector< float > *arg2 = (std::vector< float > *) 0 ; SWIG_check_num_args("ofVideoFormat::framerates",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoFormat::framerates",1,"ofVideoFormat *"); + if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofVideoFormat::framerates",2,"std::vector< float > *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoFormat,0))){ + SWIG_fail_ptr("VideoFormat_framerates_set",1,SWIGTYPE_p_ofVideoFormat); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__vectorT_float_t,0))){ + SWIG_fail_ptr("VideoFormat_framerates_set",2,SWIGTYPE_p_std__vectorT_float_t); } if (arg1) (arg1)->framerates = *arg2; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_VideoFormat_framerates_get(lua_State* L) { int SWIG_arg = 0; ofVideoFormat *arg1 = (ofVideoFormat *) 0 ; + std::vector< float > *result = 0 ; SWIG_check_num_args("ofVideoFormat::framerates",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoFormat::framerates",1,"ofVideoFormat *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoFormat,0))){ + SWIG_fail_ptr("VideoFormat_framerates_get",1,SWIGTYPE_p_ofVideoFormat); } + result = (std::vector< float > *)& ((arg1)->framerates); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static void swig_delete_VideoFormat(void *obj) { +ofVideoFormat *arg1 = (ofVideoFormat *) obj; +delete arg1; +} +static swig_lua_attribute swig_VideoFormat_attributes[] = { + { "pixelFormat", _wrap_VideoFormat_pixelFormat_get, _wrap_VideoFormat_pixelFormat_set }, + { "width", _wrap_VideoFormat_width_get, _wrap_VideoFormat_width_set }, + { "height", _wrap_VideoFormat_height_get, _wrap_VideoFormat_height_set }, + { "framerates", _wrap_VideoFormat_framerates_get, _wrap_VideoFormat_framerates_set }, + {0,0,0} +}; +static swig_lua_method swig_VideoFormat_methods[]= { + {0,0} +}; +static swig_lua_method swig_VideoFormat_meta[] = { + {0,0} +}; + +static swig_lua_attribute swig_VideoFormat_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_VideoFormat_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_VideoFormat_Sf_SwigStatic_methods[]= { + {0,0} +}; +static swig_lua_class* swig_VideoFormat_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_VideoFormat_Sf_SwigStatic = { + "VideoFormat", + swig_VideoFormat_Sf_SwigStatic_methods, + swig_VideoFormat_Sf_SwigStatic_attributes, + swig_VideoFormat_Sf_SwigStatic_constants, + swig_VideoFormat_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_VideoFormat_bases[] = {0}; +static const char *swig_VideoFormat_base_names[] = {0}; +static swig_lua_class _wrap_class_VideoFormat = { "VideoFormat", "VideoFormat", &SWIGTYPE_p_ofVideoFormat,0, swig_delete_VideoFormat, swig_VideoFormat_methods, swig_VideoFormat_attributes, &swig_VideoFormat_Sf_SwigStatic, swig_VideoFormat_meta, swig_VideoFormat_bases, swig_VideoFormat_base_names }; + +static int _wrap_VideoDevice_id_set(lua_State* L) { int SWIG_arg = 0; ofVideoDevice *arg1 = (ofVideoDevice *) 0 ; int arg2 ; + SWIG_check_num_args("ofVideoDevice::id",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoDevice::id",1,"ofVideoDevice *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVideoDevice::id",2,"int"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoDevice,0))){ + SWIG_fail_ptr("VideoDevice_id_set",1,SWIGTYPE_p_ofVideoDevice); } arg2 = (int)lua_tonumber(L, 2); + if (arg1) (arg1)->id = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_VideoDevice_id_get(lua_State* L) { int SWIG_arg = 0; ofVideoDevice *arg1 = (ofVideoDevice *) 0 ; int result; + SWIG_check_num_args("ofVideoDevice::id",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoDevice::id",1,"ofVideoDevice *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoDevice,0))){ + SWIG_fail_ptr("VideoDevice_id_get",1,SWIGTYPE_p_ofVideoDevice); } result = (int) ((arg1)->id); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_VideoDevice_deviceName_set(lua_State* L) { int SWIG_arg = 0; ofVideoDevice *arg1 = (ofVideoDevice *) 0 ; + std::string *arg2 = 0 ; std::string temp2 ; SWIG_check_num_args("ofVideoDevice::deviceName",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoDevice::deviceName",1,"ofVideoDevice *"); + if(!lua_isstring(L,2)) SWIG_fail_arg("ofVideoDevice::deviceName",2,"std::string const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoDevice,0))){ + SWIG_fail_ptr("VideoDevice_deviceName_set",1,SWIGTYPE_p_ofVideoDevice); } + temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; if (arg1) (arg1)->deviceName = *arg2; return SWIG_arg; + if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_VideoDevice_deviceName_get(lua_State* L) { int SWIG_arg = 0; ofVideoDevice *arg1 = (ofVideoDevice *) 0 ; + std::string *result = 0 ; SWIG_check_num_args("ofVideoDevice::deviceName",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoDevice::deviceName",1,"ofVideoDevice *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoDevice,0))){ + SWIG_fail_ptr("VideoDevice_deviceName_get",1,SWIGTYPE_p_ofVideoDevice); } result = (std::string *) & ((arg1)->deviceName); + lua_pushlstring(L,result->data(),result->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_VideoDevice_hardwareName_set(lua_State* L) { int SWIG_arg = 0; ofVideoDevice *arg1 = (ofVideoDevice *) 0 ; + std::string *arg2 = 0 ; std::string temp2 ; SWIG_check_num_args("ofVideoDevice::hardwareName",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoDevice::hardwareName",1,"ofVideoDevice *"); + if(!lua_isstring(L,2)) SWIG_fail_arg("ofVideoDevice::hardwareName",2,"std::string const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoDevice,0))){ + SWIG_fail_ptr("VideoDevice_hardwareName_set",1,SWIGTYPE_p_ofVideoDevice); } + temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; if (arg1) (arg1)->hardwareName = *arg2; return SWIG_arg; + if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_VideoDevice_hardwareName_get(lua_State* L) { int SWIG_arg = 0; ofVideoDevice *arg1 = (ofVideoDevice *) 0 ; + std::string *result = 0 ; SWIG_check_num_args("ofVideoDevice::hardwareName",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoDevice::hardwareName",1,"ofVideoDevice *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoDevice,0))){ + SWIG_fail_ptr("VideoDevice_hardwareName_get",1,SWIGTYPE_p_ofVideoDevice); } + result = (std::string *) & ((arg1)->hardwareName); lua_pushlstring(L,result->data(),result->size()); SWIG_arg++; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_VideoDevice_serialID_set(lua_State* L) { int SWIG_arg = 0; ofVideoDevice *arg1 = (ofVideoDevice *) 0 ; + std::string *arg2 = 0 ; std::string temp2 ; SWIG_check_num_args("ofVideoDevice::serialID",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoDevice::serialID",1,"ofVideoDevice *"); + if(!lua_isstring(L,2)) SWIG_fail_arg("ofVideoDevice::serialID",2,"std::string const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoDevice,0))){ + SWIG_fail_ptr("VideoDevice_serialID_set",1,SWIGTYPE_p_ofVideoDevice); } + temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; if (arg1) (arg1)->serialID = *arg2; return SWIG_arg; + if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_VideoDevice_serialID_get(lua_State* L) { int SWIG_arg = 0; ofVideoDevice *arg1 = (ofVideoDevice *) 0 ; + std::string *result = 0 ; SWIG_check_num_args("ofVideoDevice::serialID",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoDevice::serialID",1,"ofVideoDevice *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoDevice,0))){ + SWIG_fail_ptr("VideoDevice_serialID_get",1,SWIGTYPE_p_ofVideoDevice); } result = (std::string *) & ((arg1)->serialID); + lua_pushlstring(L,result->data(),result->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_VideoDevice_formats_set(lua_State* L) { int SWIG_arg = 0; ofVideoDevice *arg1 = (ofVideoDevice *) 0 ; + std::vector< ofVideoFormat > *arg2 = (std::vector< ofVideoFormat > *) 0 ; SWIG_check_num_args("ofVideoDevice::formats",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoDevice::formats",1,"ofVideoDevice *"); + if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofVideoDevice::formats",2,"std::vector< ofVideoFormat > *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoDevice,0))){ + SWIG_fail_ptr("VideoDevice_formats_set",1,SWIGTYPE_p_ofVideoDevice); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__vectorT_ofVideoFormat_t,0))){ + SWIG_fail_ptr("VideoDevice_formats_set",2,SWIGTYPE_p_std__vectorT_ofVideoFormat_t); } if (arg1) (arg1)->formats = *arg2; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_VideoDevice_formats_get(lua_State* L) { int SWIG_arg = 0; ofVideoDevice *arg1 = (ofVideoDevice *) 0 ; + std::vector< ofVideoFormat > *result = 0 ; SWIG_check_num_args("ofVideoDevice::formats",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoDevice::formats",1,"ofVideoDevice *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoDevice,0))){ + SWIG_fail_ptr("VideoDevice_formats_get",1,SWIGTYPE_p_ofVideoDevice); } + result = (std::vector< ofVideoFormat > *)& ((arg1)->formats); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofVideoFormat_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_VideoDevice_bAvailable_set(lua_State* L) { int SWIG_arg = 0; ofVideoDevice *arg1 = (ofVideoDevice *) 0 ; + bool arg2 ; SWIG_check_num_args("ofVideoDevice::bAvailable",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoDevice::bAvailable",1,"ofVideoDevice *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("ofVideoDevice::bAvailable",2,"bool"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoDevice,0))){ + SWIG_fail_ptr("VideoDevice_bAvailable_set",1,SWIGTYPE_p_ofVideoDevice); } arg2 = (lua_toboolean(L, 2)!=0); + if (arg1) (arg1)->bAvailable = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_VideoDevice_bAvailable_get(lua_State* L) { int SWIG_arg = 0; ofVideoDevice *arg1 = (ofVideoDevice *) 0 ; + bool result; SWIG_check_num_args("ofVideoDevice::bAvailable",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoDevice::bAvailable",1,"ofVideoDevice *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoDevice,0))){ + SWIG_fail_ptr("VideoDevice_bAvailable_get",1,SWIGTYPE_p_ofVideoDevice); } result = (bool) ((arg1)->bAvailable); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static void swig_delete_VideoDevice(void *obj) { +ofVideoDevice *arg1 = (ofVideoDevice *) obj; +delete arg1; +} +static swig_lua_attribute swig_VideoDevice_attributes[] = { + { "id", _wrap_VideoDevice_id_get, _wrap_VideoDevice_id_set }, + { "deviceName", _wrap_VideoDevice_deviceName_get, _wrap_VideoDevice_deviceName_set }, + { "hardwareName", _wrap_VideoDevice_hardwareName_get, _wrap_VideoDevice_hardwareName_set }, + { "serialID", _wrap_VideoDevice_serialID_get, _wrap_VideoDevice_serialID_set }, + { "formats", _wrap_VideoDevice_formats_get, _wrap_VideoDevice_formats_set }, + { "bAvailable", _wrap_VideoDevice_bAvailable_get, _wrap_VideoDevice_bAvailable_set }, + {0,0,0} +}; +static swig_lua_method swig_VideoDevice_methods[]= { + {0,0} +}; +static swig_lua_method swig_VideoDevice_meta[] = { + {0,0} +}; + +static swig_lua_attribute swig_VideoDevice_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_VideoDevice_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_VideoDevice_Sf_SwigStatic_methods[]= { + {0,0} +}; +static swig_lua_class* swig_VideoDevice_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_VideoDevice_Sf_SwigStatic = { + "VideoDevice", + swig_VideoDevice_Sf_SwigStatic_methods, + swig_VideoDevice_Sf_SwigStatic_attributes, + swig_VideoDevice_Sf_SwigStatic_constants, + swig_VideoDevice_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_VideoDevice_bases[] = {0}; +static const char *swig_VideoDevice_base_names[] = {0}; +static swig_lua_class _wrap_class_VideoDevice = { "VideoDevice", "VideoDevice", &SWIGTYPE_p_ofVideoDevice,0, swig_delete_VideoDevice, swig_VideoDevice_methods, swig_VideoDevice_attributes, &swig_VideoDevice_Sf_SwigStatic, swig_VideoDevice_meta, swig_VideoDevice_bases, swig_VideoDevice_base_names }; + static int _wrap_new_Node__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofNode *result = 0 ; SWIG_check_num_args("ofNode::ofNode",0,0) result = (ofNode *)new ofNode(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofNode,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); @@ -10300,9 +11698,7 @@ static int _wrap_new_Node__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 result = (ofNode *)new ofNode((ofNode &&)*arg1); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofNode,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_new_Node(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_Node__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_new_Node__SWIG_1(L);} } + return _wrap_new_Node__SWIG_0(L);} if (argc == 1) { return _wrap_new_Node__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_Node'\n" " Possible C/C++ prototypes are:\n" " ofNode::ofNode()\n" " ofNode::ofNode(ofNode &&)\n"); lua_error(L);return 0; } static int _wrap_Node_setParent__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; ofNode *arg2 = 0 ; @@ -10322,17 +11718,9 @@ static int _wrap_Node_setParent__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofNode SWIG_fail_ptr("Node_setParent",2,SWIGTYPE_p_ofNode); } (arg1)->setParent(*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Node_setParent(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Node_setParent__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { return _wrap_Node_setParent__SWIG_0(L);} } - } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Node_setParent'\n" - " Possible C/C++ prototypes are:\n" " ofNode::setParent(ofNode &,bool)\n" " ofNode::setParent(ofNode &)\n"); - lua_error(L);return 0; } + return _wrap_Node_setParent__SWIG_1(L);} if (argc == 3) { return _wrap_Node_setParent__SWIG_0(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Node_setParent'\n" " Possible C/C++ prototypes are:\n" + " ofNode::setParent(ofNode &,bool)\n" " ofNode::setParent(ofNode &)\n"); lua_error(L);return 0; } static int _wrap_Node_clearParent__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; bool arg2 ; SWIG_check_num_args("ofNode::clearParent",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::clearParent",1,"ofNode *"); if(!lua_isboolean(L,2)) SWIG_fail_arg("ofNode::clearParent",2,"bool"); @@ -10345,11 +11733,7 @@ static int _wrap_Node_clearParent__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofNo SWIG_fail_ptr("Node_clearParent",1,SWIGTYPE_p_ofNode); } (arg1)->clearParent(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Node_clearParent(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Node_clearParent__SWIG_1(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_Node_clearParent__SWIG_0(L);} } } + return _wrap_Node_clearParent__SWIG_1(L);} if (argc == 2) { return _wrap_Node_clearParent__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Node_clearParent'\n" " Possible C/C++ prototypes are:\n" " ofNode::clearParent(bool)\n" " ofNode::clearParent()\n"); lua_error(L);return 0; } static int _wrap_Node_getParent(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; ofNode *result = 0 ; @@ -10419,21 +11803,6 @@ static int _wrap_Node_getUpDir(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = result = ((ofNode const *)arg1)->getUpDir(); { glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_getPitch(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; float result; - SWIG_check_num_args("ofNode::getPitch",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::getPitch",1,"ofNode const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_getPitch",1,SWIGTYPE_p_ofNode); } - result = (float)((ofNode const *)arg1)->getPitch(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_getHeading(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; float result; - SWIG_check_num_args("ofNode::getHeading",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::getHeading",1,"ofNode const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_getHeading",1,SWIGTYPE_p_ofNode); } result = (float)((ofNode const *)arg1)->getHeading(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_getRoll(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; float result; - SWIG_check_num_args("ofNode::getRoll",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::getRoll",1,"ofNode const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_getRoll",1,SWIGTYPE_p_ofNode); } - result = (float)((ofNode const *)arg1)->getRoll(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Node_getPitchDeg(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; float result; SWIG_check_num_args("ofNode::getPitchDeg",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::getPitchDeg",1,"ofNode const *"); @@ -10476,14 +11845,6 @@ static int _wrap_Node_getOrientationQuat(lua_State* L) { int SWIG_arg = 0; ofNod glm::quat * resultptr = new glm::quat((const glm::quat &) result); SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__quat,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_getOrientationEuler(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; glm::vec3 result; - SWIG_check_num_args("ofNode::getOrientationEuler",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::getOrientationEuler",1,"ofNode const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_getOrientationEuler",1,SWIGTYPE_p_ofNode); } result = ((ofNode const *)arg1)->getOrientationEuler(); { - glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } static int _wrap_Node_getOrientationEulerDeg(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; glm::vec3 result; SWIG_check_num_args("ofNode::getOrientationEulerDeg",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::getOrientationEulerDeg",1,"ofNode const *"); @@ -10568,13 +11929,7 @@ static int _wrap_Node_setPosition__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofNo SWIG_fail_ptr("Node_setPosition",2,SWIGTYPE_p_glm__vec3); } (arg1)->setPosition((glm::vec3 const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Node_setPosition(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Node_setPosition__SWIG_1(L);} } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Node_setPosition__SWIG_0(L);} } } } } + return _wrap_Node_setPosition__SWIG_1(L);} if (argc == 4) { return _wrap_Node_setPosition__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Node_setPosition'\n" " Possible C/C++ prototypes are:\n" " ofNode::setPosition(float,float,float)\n" " ofNode::setPosition(glm::vec3 const &)\n"); lua_error(L);return 0; } static int _wrap_Node_setGlobalPosition__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; float arg2 ; @@ -10597,14 +11952,8 @@ static int _wrap_Node_setGlobalPosition__SWIG_1(lua_State* L) { int SWIG_arg = 0 SWIG_fail_ptr("Node_setGlobalPosition",2,SWIGTYPE_p_glm__vec3); } (arg1)->setGlobalPosition((glm::vec3 const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Node_setGlobalPosition(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Node_setGlobalPosition__SWIG_1(L);} } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Node_setGlobalPosition__SWIG_0(L);} } } } } + if (argc == 2) { return _wrap_Node_setGlobalPosition__SWIG_1(L);} if (argc == 4) { + return _wrap_Node_setGlobalPosition__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Node_setGlobalPosition'\n" " Possible C/C++ prototypes are:\n" " ofNode::setGlobalPosition(float,float,float)\n" " ofNode::setGlobalPosition(glm::vec3 const &)\n"); lua_error(L);return 0; } @@ -10627,14 +11976,10 @@ static int _wrap_Node_setOrientation__SWIG_1(lua_State* L) { int SWIG_arg = 0; o SWIG_fail_ptr("Node_setOrientation",2,SWIGTYPE_p_glm__vec3); } (arg1)->setOrientation((glm::vec3 const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Node_setOrientation(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__quat, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Node_setOrientation__SWIG_0(L);} } } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Node_setOrientation__SWIG_1(L);} } } + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__quat, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_Node_setOrientation__SWIG_0(L);} check_1: + if (argc == 2) { return _wrap_Node_setOrientation__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Node_setOrientation'\n" " Possible C/C++ prototypes are:\n" " ofNode::setOrientation(glm::quat const &)\n" " ofNode::setOrientation(glm::vec3 const &)\n"); lua_error(L);return 0; } @@ -10671,16 +12016,10 @@ static int _wrap_Node_setScale__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofNode SWIG_fail_ptr("Node_setScale",2,SWIGTYPE_p_glm__vec3); } (arg1)->setScale((glm::vec3 const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Node_setScale(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Node_setScale__SWIG_2(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Node_setScale__SWIG_0(L);} } } - if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Node_setScale__SWIG_1(L);} } } } } + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_Node_setScale__SWIG_2(L);} check_1: + if (argc == 2) { return _wrap_Node_setScale__SWIG_0(L);} if (argc == 4) { return _wrap_Node_setScale__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Node_setScale'\n" " Possible C/C++ prototypes are:\n" " ofNode::setScale(float)\n" " ofNode::setScale(float,float,float)\n" " ofNode::setScale(glm::vec3 const &)\n"); lua_error(L);return 0; } @@ -10699,14 +12038,8 @@ static int _wrap_Node_move__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofNode *arg if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("Node_move",2,SWIGTYPE_p_glm__vec3); } (arg1)->move((glm::vec3 const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_move(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Node_move__SWIG_1(L);} } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Node_move__SWIG_0(L);} } } } } +static int _wrap_Node_move(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { + return _wrap_Node_move__SWIG_1(L);} if (argc == 4) { return _wrap_Node_move__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Node_move'\n" " Possible C/C++ prototypes are:\n" " ofNode::move(float,float,float)\n" " ofNode::move(glm::vec3 const &)\n"); lua_error(L);return 0; } static int _wrap_Node_truck(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; float arg2 ; @@ -10724,11 +12057,6 @@ static int _wrap_Node_dolly(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (of if(!lua_isnumber(L,2)) SWIG_fail_arg("ofNode::dolly",2,"float"); if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_dolly",1,SWIGTYPE_p_ofNode); } arg2 = (float)lua_tonumber(L, 2); (arg1)->dolly(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_tilt(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; float arg2 ; - SWIG_check_num_args("ofNode::tilt",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::tilt",1,"ofNode *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofNode::tilt",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_tilt",1,SWIGTYPE_p_ofNode); } - arg2 = (float)lua_tonumber(L, 2); (arg1)->tilt(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Node_tiltDeg(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; float arg2 ; SWIG_check_num_args("ofNode::tiltDeg",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::tiltDeg",1,"ofNode *"); if(!lua_isnumber(L,2)) SWIG_fail_arg("ofNode::tiltDeg",2,"float"); @@ -10741,11 +12069,6 @@ static int _wrap_Node_tiltRad(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = ( if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_tiltRad",1,SWIGTYPE_p_ofNode); } arg2 = (float)lua_tonumber(L, 2); (arg1)->tiltRad(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_pan(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; float arg2 ; - SWIG_check_num_args("ofNode::pan",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::pan",1,"ofNode *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofNode::pan",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_pan",1,SWIGTYPE_p_ofNode); } - arg2 = (float)lua_tonumber(L, 2); (arg1)->pan(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Node_panDeg(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; float arg2 ; SWIG_check_num_args("ofNode::panDeg",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::panDeg",1,"ofNode *"); if(!lua_isnumber(L,2)) SWIG_fail_arg("ofNode::panDeg",2,"float"); @@ -10758,11 +12081,6 @@ static int _wrap_Node_panRad(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (o if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_panRad",1,SWIGTYPE_p_ofNode); } arg2 = (float)lua_tonumber(L, 2); (arg1)->panRad(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_roll(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; float arg2 ; - SWIG_check_num_args("ofNode::roll",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::roll",1,"ofNode *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofNode::roll",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_roll",1,SWIGTYPE_p_ofNode); } - arg2 = (float)lua_tonumber(L, 2); (arg1)->roll(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Node_rollDeg(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; float arg2 ; SWIG_check_num_args("ofNode::rollDeg",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::rollDeg",1,"ofNode *"); if(!lua_isnumber(L,2)) SWIG_fail_arg("ofNode::rollDeg",2,"float"); @@ -10775,22 +12093,6 @@ static int _wrap_Node_rollRad(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = ( if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_rollRad",1,SWIGTYPE_p_ofNode); } arg2 = (float)lua_tonumber(L, 2); (arg1)->rollRad(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_rotate__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; glm::quat *arg2 = 0 ; - SWIG_check_num_args("ofNode::rotate",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::rotate",1,"ofNode *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofNode::rotate",2,"glm::quat const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_rotate",1,SWIGTYPE_p_ofNode); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__quat,0))){ - SWIG_fail_ptr("Node_rotate",2,SWIGTYPE_p_glm__quat); } (arg1)->rotate((glm::quat const &)*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_rotate__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; float arg2 ; - glm::vec3 *arg3 = 0 ; SWIG_check_num_args("ofNode::rotate",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::rotate",1,"ofNode *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofNode::rotate",2,"float"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofNode::rotate",3,"glm::vec3 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_rotate",1,SWIGTYPE_p_ofNode); } - arg2 = (float)lua_tonumber(L, 2); if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_glm__vec3,0))){ - SWIG_fail_ptr("Node_rotate",3,SWIGTYPE_p_glm__vec3); } (arg1)->rotate(arg2,(glm::vec3 const &)*arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Node_rotateDeg__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; float arg2 ; glm::vec3 *arg3 = 0 ; SWIG_check_num_args("ofNode::rotateDeg",3,3) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::rotateDeg",1,"ofNode *"); @@ -10809,33 +12111,6 @@ static int _wrap_Node_rotateRad__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofNode arg2 = (float)lua_tonumber(L, 2); if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("Node_rotateRad",3,SWIGTYPE_p_glm__vec3); } (arg1)->rotateRad(arg2,(glm::vec3 const &)*arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_rotate__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; float arg2 ; float arg3 ; - float arg4 ; float arg5 ; SWIG_check_num_args("ofNode::rotate",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::rotate",1,"ofNode *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofNode::rotate",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofNode::rotate",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofNode::rotate",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofNode::rotate",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_rotate",1,SWIGTYPE_p_ofNode); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); (arg1)->rotate(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Node_rotate(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__quat, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Node_rotate__SWIG_0(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Node_rotate__SWIG_1(L);} } } } if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Node_rotate__SWIG_2(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Node_rotate'\n" " Possible C/C++ prototypes are:\n" - " ofNode::rotate(glm::quat const &)\n" " ofNode::rotate(float,glm::vec3 const &)\n" - " ofNode::rotate(float,float,float,float)\n"); lua_error(L);return 0; } static int _wrap_Node_rotateDeg__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; float arg2 ; float arg3 ; float arg4 ; float arg5 ; SWIG_check_num_args("ofNode::rotateDeg",5,5) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::rotateDeg",1,"ofNode *"); @@ -10848,14 +12123,7 @@ static int _wrap_Node_rotateDeg__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofNode arg5 = (float)lua_tonumber(L, 5); (arg1)->rotateDeg(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Node_rotateDeg(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Node_rotateDeg__SWIG_0(L);} } } } if (argc == 5) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Node_rotateDeg__SWIG_1(L);} } } } } } + return _wrap_Node_rotateDeg__SWIG_0(L);} if (argc == 5) { return _wrap_Node_rotateDeg__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Node_rotateDeg'\n" " Possible C/C++ prototypes are:\n" " ofNode::rotateDeg(float,glm::vec3 const &)\n" " ofNode::rotateDeg(float,float,float,float)\n"); lua_error(L);return 0; } @@ -10871,18 +12139,11 @@ static int _wrap_Node_rotateRad__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofNode arg5 = (float)lua_tonumber(L, 5); (arg1)->rotateRad(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Node_rotateRad(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Node_rotateRad__SWIG_0(L);} } } } if (argc == 5) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Node_rotateRad__SWIG_1(L);} } } } } } + return _wrap_Node_rotateRad__SWIG_0(L);} if (argc == 5) { return _wrap_Node_rotateRad__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Node_rotateRad'\n" " Possible C/C++ prototypes are:\n" " ofNode::rotateRad(float,glm::vec3 const &)\n" " ofNode::rotateRad(float,float,float,float)\n"); lua_error(L);return 0; } -static int _wrap_Node_rotateAround__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; glm::quat *arg2 = 0 ; +static int _wrap_Node_rotateAround(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; glm::quat *arg2 = 0 ; glm::vec3 *arg3 = 0 ; SWIG_check_num_args("ofNode::rotateAround",3,3) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::rotateAround",1,"ofNode *"); if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofNode::rotateAround",2,"glm::quat const &"); @@ -10895,36 +12156,6 @@ static int _wrap_Node_rotateAround__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofN SWIG_fail_ptr("Node_rotateAround",3,SWIGTYPE_p_glm__vec3); } (arg1)->rotateAround((glm::quat const &)*arg2,(glm::vec3 const &)*arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_rotateAround__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; float arg2 ; - glm::vec3 *arg3 = 0 ; glm::vec3 *arg4 = 0 ; SWIG_check_num_args("ofNode::rotateAround",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::rotateAround",1,"ofNode *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofNode::rotateAround",2,"float"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofNode::rotateAround",3,"glm::vec3 const &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofNode::rotateAround",4,"glm::vec3 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_rotateAround",1,SWIGTYPE_p_ofNode); } arg2 = (float)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_glm__vec3,0))){ - SWIG_fail_ptr("Node_rotateAround",3,SWIGTYPE_p_glm__vec3); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_glm__vec3,0))){ - SWIG_fail_ptr("Node_rotateAround",4,SWIGTYPE_p_glm__vec3); } - (arg1)->rotateAround(arg2,(glm::vec3 const &)*arg3,(glm::vec3 const &)*arg4); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Node_rotateAround(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__quat, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Node_rotateAround__SWIG_0(L);} } } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Node_rotateAround__SWIG_1(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Node_rotateAround'\n" " Possible C/C++ prototypes are:\n" - " ofNode::rotateAround(glm::quat const &,glm::vec3 const &)\n" - " ofNode::rotateAround(float,glm::vec3 const &,glm::vec3 const &)\n"); lua_error(L);return 0; } static int _wrap_Node_rotateAroundDeg(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; float arg2 ; glm::vec3 *arg3 = 0 ; glm::vec3 *arg4 = 0 ; SWIG_check_num_args("ofNode::rotateAroundDeg",4,4) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::rotateAroundDeg",1,"ofNode *"); @@ -10987,79 +12218,17 @@ static int _wrap_Node_lookAt__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofNode *a if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("Node_lookAt",3,SWIGTYPE_p_glm__vec3); } (arg1)->lookAt((ofNode const &)*arg2,(glm::vec3 const &)*arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_lookAt(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Node_lookAt__SWIG_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Node_lookAt__SWIG_2(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Node_lookAt__SWIG_1(L);} } } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Node_lookAt__SWIG_3(L);} } } } +static int _wrap_Node_lookAt(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_Node_lookAt__SWIG_0(L);} check_1: + if (argc == 2) { return _wrap_Node_lookAt__SWIG_2(L);} if (argc == 3) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; return _wrap_Node_lookAt__SWIG_1(L);} check_3: + if (argc == 3) { return _wrap_Node_lookAt__SWIG_3(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Node_lookAt'\n" " Possible C/C++ prototypes are:\n" " ofNode::lookAt(glm::vec3 const &)\n" " ofNode::lookAt(glm::vec3 const &,glm::vec3)\n" " ofNode::lookAt(ofNode const &)\n" " ofNode::lookAt(ofNode const &,glm::vec3 const &)\n"); lua_error(L);return 0; } -static int _wrap_Node_orbit__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; float arg2 ; float arg3 ; - float arg4 ; glm::vec3 *arg5 = 0 ; SWIG_check_num_args("ofNode::orbit",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::orbit",1,"ofNode *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofNode::orbit",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofNode::orbit",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofNode::orbit",4,"float"); - if(!lua_isuserdata(L,5)) SWIG_fail_arg("ofNode::orbit",5,"glm::vec3 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_orbit",1,SWIGTYPE_p_ofNode); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_glm__vec3,0))){ - SWIG_fail_ptr("Node_orbit",5,SWIGTYPE_p_glm__vec3); } (arg1)->orbit(arg2,arg3,arg4,(glm::vec3 const &)*arg5); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_orbit__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; float arg2 ; float arg3 ; - float arg4 ; SWIG_check_num_args("ofNode::orbit",4,4) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::orbit",1,"ofNode *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofNode::orbit",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofNode::orbit",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofNode::orbit",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_orbit",1,SWIGTYPE_p_ofNode); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - (arg1)->orbit(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_orbit__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; float arg2 ; float arg3 ; - float arg4 ; ofNode *arg5 = 0 ; SWIG_check_num_args("ofNode::orbit",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::orbit",1,"ofNode *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofNode::orbit",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofNode::orbit",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofNode::orbit",4,"float"); - if(!lua_isuserdata(L,5)) SWIG_fail_arg("ofNode::orbit",5,"ofNode &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_orbit",1,SWIGTYPE_p_ofNode); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_orbit",5,SWIGTYPE_p_ofNode); } - (arg1)->orbit(arg2,arg3,arg4,*arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_orbit(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 4) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Node_orbit__SWIG_1(L);} } } } } - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[4])==0 || SWIG_ConvertPtr(L,argv[4], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Node_orbit__SWIG_0(L);} } } } } } if (argc == 5) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[4])==0 || SWIG_ConvertPtr(L,argv[4], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Node_orbit__SWIG_2(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Node_orbit'\n" " Possible C/C++ prototypes are:\n" - " ofNode::orbit(float,float,float,glm::vec3 const &)\n" " ofNode::orbit(float,float,float)\n" - " ofNode::orbit(float,float,float,ofNode &)\n"); lua_error(L);return 0; } static int _wrap_Node_orbitDeg__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; float arg2 ; float arg3 ; float arg4 ; glm::vec3 *arg5 = 0 ; SWIG_check_num_args("ofNode::orbitDeg",5,5) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::orbitDeg",1,"ofNode *"); @@ -11093,21 +12262,10 @@ static int _wrap_Node_orbitDeg__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofNode if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_orbitDeg",5,SWIGTYPE_p_ofNode); } (arg1)->orbitDeg(arg2,arg3,arg4,*arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Node_orbitDeg(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 4) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Node_orbitDeg__SWIG_1(L);} } } } } - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[4])==0 || SWIG_ConvertPtr(L,argv[4], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Node_orbitDeg__SWIG_0(L);} } } } } } - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[4])==0 || SWIG_ConvertPtr(L,argv[4], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Node_orbitDeg__SWIG_2(L);} } } } } } + return _wrap_Node_orbitDeg__SWIG_1(L);} if (argc == 5) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[4])==0 || SWIG_ConvertPtr(L,argv[4], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_Node_orbitDeg__SWIG_0(L);} check_2: + if (argc == 5) { return _wrap_Node_orbitDeg__SWIG_2(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Node_orbitDeg'\n" " Possible C/C++ prototypes are:\n" " ofNode::orbitDeg(float,float,float,glm::vec3 const &)\n" " ofNode::orbitDeg(float,float,float)\n" " ofNode::orbitDeg(float,float,float,ofNode &)\n"); lua_error(L);return 0; } @@ -11144,21 +12302,10 @@ static int _wrap_Node_orbitRad__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofNode if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_orbitRad",5,SWIGTYPE_p_ofNode); } (arg1)->orbitRad(arg2,arg3,arg4,*arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Node_orbitRad(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 4) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Node_orbitRad__SWIG_1(L);} } } } } - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[4])==0 || SWIG_ConvertPtr(L,argv[4], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Node_orbitRad__SWIG_0(L);} } } } } } - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[4])==0 || SWIG_ConvertPtr(L,argv[4], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Node_orbitRad__SWIG_2(L);} } } } } } + return _wrap_Node_orbitRad__SWIG_1(L);} if (argc == 5) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[4])==0 || SWIG_ConvertPtr(L,argv[4], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_Node_orbitRad__SWIG_0(L);} check_2: + if (argc == 5) { return _wrap_Node_orbitRad__SWIG_2(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Node_orbitRad'\n" " Possible C/C++ prototypes are:\n" " ofNode::orbitRad(float,float,float,glm::vec3 const &)\n" " ofNode::orbitRad(float,float,float)\n" " ofNode::orbitRad(float,float,float,ofNode &)\n"); lua_error(L);return 0; } @@ -11178,12 +12325,7 @@ static int _wrap_Node_transformGL__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofNo SWIG_fail_ptr("Node_transformGL",1,SWIGTYPE_p_ofNode); } ((ofNode const *)arg1)->transformGL(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Node_transformGL(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Node_transformGL__SWIG_1(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBaseRenderer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Node_transformGL__SWIG_0(L);} } } + return _wrap_Node_transformGL__SWIG_1(L);} if (argc == 2) { return _wrap_Node_transformGL__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Node_transformGL'\n" " Possible C/C++ prototypes are:\n" " ofNode::transformGL(ofBaseRenderer *) const\n" " ofNode::transformGL() const\n"); lua_error(L);return 0; } static int _wrap_Node_restoreTransformGL__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; @@ -11202,12 +12344,7 @@ static int _wrap_Node_restoreTransformGL__SWIG_1(lua_State* L) { int SWIG_arg = SWIG_fail_ptr("Node_restoreTransformGL",1,SWIGTYPE_p_ofNode); } ((ofNode const *)arg1)->restoreTransformGL(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Node_restoreTransformGL(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Node_restoreTransformGL__SWIG_1(L);} } if (argc == 2) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBaseRenderer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Node_restoreTransformGL__SWIG_0(L);} } } + return _wrap_Node_restoreTransformGL__SWIG_1(L);} if (argc == 2) { return _wrap_Node_restoreTransformGL__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Node_restoreTransformGL'\n" " Possible C/C++ prototypes are:\n" " ofNode::restoreTransformGL(ofBaseRenderer *) const\n" " ofNode::restoreTransformGL() const\n"); lua_error(L);return 0; } @@ -11232,13 +12369,8 @@ static int _wrap_Node_customDraw__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofNod if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_customDraw",1,SWIGTYPE_p_ofNode); } (arg1)->customDraw(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_customDraw(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Node_customDraw__SWIG_1(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBaseRenderer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Node_customDraw__SWIG_0(L);} } } +static int _wrap_Node_customDraw(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { + return _wrap_Node_customDraw__SWIG_1(L);} if (argc == 2) { return _wrap_Node_customDraw__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Node_customDraw'\n" " Possible C/C++ prototypes are:\n" " ofNode::customDraw(ofBaseRenderer const *) const\n" " ofNode::customDraw()\n"); lua_error(L);return 0; } static int _wrap_Node_draw(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; @@ -11274,9 +12406,6 @@ static swig_lua_method swig_Node_methods[]= { { "getSideDir", _wrap_Node_getSideDir}, { "getLookAtDir", _wrap_Node_getLookAtDir}, { "getUpDir", _wrap_Node_getUpDir}, - { "getPitch", _wrap_Node_getPitch}, - { "getHeading", _wrap_Node_getHeading}, - { "getRoll", _wrap_Node_getRoll}, { "getPitchDeg", _wrap_Node_getPitchDeg}, { "getHeadingDeg", _wrap_Node_getHeadingDeg}, { "getRollDeg", _wrap_Node_getRollDeg}, @@ -11284,7 +12413,6 @@ static swig_lua_method swig_Node_methods[]= { { "getHeadingRad", _wrap_Node_getHeadingRad}, { "getRollRad", _wrap_Node_getRollRad}, { "getOrientationQuat", _wrap_Node_getOrientationQuat}, - { "getOrientationEuler", _wrap_Node_getOrientationEuler}, { "getOrientationEulerDeg", _wrap_Node_getOrientationEulerDeg}, { "getOrientationEulerRad", _wrap_Node_getOrientationEulerRad}, { "getScale", _wrap_Node_getScale}, @@ -11302,23 +12430,18 @@ static swig_lua_method swig_Node_methods[]= { { "truck", _wrap_Node_truck}, { "boom", _wrap_Node_boom}, { "dolly", _wrap_Node_dolly}, - { "tilt", _wrap_Node_tilt}, { "tiltDeg", _wrap_Node_tiltDeg}, { "tiltRad", _wrap_Node_tiltRad}, - { "pan", _wrap_Node_pan}, { "panDeg", _wrap_Node_panDeg}, { "panRad", _wrap_Node_panRad}, - { "roll", _wrap_Node_roll}, { "rollDeg", _wrap_Node_rollDeg}, { "rollRad", _wrap_Node_rollRad}, - { "rotate", _wrap_Node_rotate}, { "rotateDeg", _wrap_Node_rotateDeg}, { "rotateRad", _wrap_Node_rotateRad}, { "rotateAround", _wrap_Node_rotateAround}, { "rotateAroundDeg", _wrap_Node_rotateAroundDeg}, { "rotateAroundRad", _wrap_Node_rotateAroundRad}, { "lookAt", _wrap_Node_lookAt}, - { "orbit", _wrap_Node_orbit}, { "orbitDeg", _wrap_Node_orbitDeg}, { "orbitRad", _wrap_Node_orbitRad}, { "transformGL", _wrap_Node_transformGL}, @@ -11401,23 +12524,14 @@ static int _wrap_drawGrid__SWIG_5(lua_State* L) { int SWIG_arg = 0; float arg1 ; static int _wrap_drawGrid__SWIG_6(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofDrawGrid",0,0) ofDrawGrid(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_drawGrid(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_drawGrid__SWIG_6(L);} if (argc == 1) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { - return _wrap_drawGrid__SWIG_5(L);} } if (argc == 2) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_drawGrid__SWIG_4(L);} } } if (argc == 3) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } - if (_v) { return _wrap_drawGrid__SWIG_3(L);} } } } if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { { - _v = lua_isboolean(L,argv[3]); } if (_v) { return _wrap_drawGrid__SWIG_2(L);} } } } } if (argc == 5) { int _v; - { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } - if (_v) { { _v = lua_isboolean(L,argv[3]); } if (_v) { { _v = lua_isboolean(L,argv[4]); } if (_v) { - return _wrap_drawGrid__SWIG_1(L);} } } } } } if (argc == 6) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { { - _v = lua_isboolean(L,argv[3]); } if (_v) { { _v = lua_isboolean(L,argv[4]); } if (_v) { { - _v = lua_isboolean(L,argv[5]); } if (_v) { return _wrap_drawGrid__SWIG_0(L);} } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'drawGrid'\n" " Possible C/C++ prototypes are:\n" - " ofDrawGrid(float,size_t,bool,bool,bool,bool)\n" " ofDrawGrid(float,size_t,bool,bool,bool)\n" - " ofDrawGrid(float,size_t,bool,bool)\n" " ofDrawGrid(float,size_t,bool)\n" " ofDrawGrid(float,size_t)\n" - " ofDrawGrid(float)\n" " ofDrawGrid()\n"); lua_error(L);return 0; } + return _wrap_drawGrid__SWIG_6(L);} if (argc == 1) { return _wrap_drawGrid__SWIG_5(L);} if (argc == 2) { + return _wrap_drawGrid__SWIG_4(L);} if (argc == 3) { return _wrap_drawGrid__SWIG_3(L);} if (argc == 4) { + return _wrap_drawGrid__SWIG_2(L);} if (argc == 5) { return _wrap_drawGrid__SWIG_1(L);} if (argc == 6) { + return _wrap_drawGrid__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'drawGrid'\n" + " Possible C/C++ prototypes are:\n" " ofDrawGrid(float,size_t,bool,bool,bool,bool)\n" + " ofDrawGrid(float,size_t,bool,bool,bool)\n" " ofDrawGrid(float,size_t,bool,bool)\n" + " ofDrawGrid(float,size_t,bool)\n" " ofDrawGrid(float,size_t)\n" " ofDrawGrid(float)\n" " ofDrawGrid()\n"); + lua_error(L);return 0; } static int _wrap_drawGridPlane__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; size_t arg2 ; bool arg3 ; SWIG_check_num_args("ofDrawGridPlane",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawGridPlane",1,"float"); if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawGridPlane",2,"size_t"); @@ -11436,11 +12550,8 @@ static int _wrap_drawGridPlane__SWIG_2(lua_State* L) { int SWIG_arg = 0; float a static int _wrap_drawGridPlane__SWIG_3(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofDrawGridPlane",0,0) ofDrawGridPlane(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_drawGridPlane(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_drawGridPlane__SWIG_3(L);} if (argc == 1) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { - return _wrap_drawGridPlane__SWIG_2(L);} } if (argc == 2) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_drawGridPlane__SWIG_1(L);} } } if (argc == 3) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } - if (_v) { return _wrap_drawGridPlane__SWIG_0(L);} } } } + return _wrap_drawGridPlane__SWIG_3(L);} if (argc == 1) { return _wrap_drawGridPlane__SWIG_2(L);} if (argc == 2) { + return _wrap_drawGridPlane__SWIG_1(L);} if (argc == 3) { return _wrap_drawGridPlane__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'drawGridPlane'\n" " Possible C/C++ prototypes are:\n" " ofDrawGridPlane(float,size_t,bool)\n" " ofDrawGridPlane(float,size_t)\n" " ofDrawGridPlane(float)\n" " ofDrawGridPlane()\n"); lua_error(L);return 0; } @@ -11462,16 +12573,9 @@ static int _wrap_drawArrow__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::vec3 * if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("drawArrow",2,SWIGTYPE_p_glm__vec3); } ofDrawArrow((glm::vec3 const &)*arg1,(glm::vec3 const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawArrow(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_drawArrow__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_drawArrow__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'drawArrow'\n" " Possible C/C++ prototypes are:\n" +static int _wrap_drawArrow(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { + return _wrap_drawArrow__SWIG_1(L);} if (argc == 3) { return _wrap_drawArrow__SWIG_0(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'drawArrow'\n" " Possible C/C++ prototypes are:\n" " ofDrawArrow(glm::vec3 const &,glm::vec3 const &,float)\n" " ofDrawArrow(glm::vec3 const &,glm::vec3 const &)\n"); lua_error(L);return 0; } static int _wrap_drawRotationAxes__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; int arg3 ; @@ -11490,11 +12594,8 @@ static int _wrap_drawRotationAxes__SWIG_2(lua_State* L) { int SWIG_arg = 0; floa arg1 = (float)lua_tonumber(L, 1); ofDrawRotationAxes(arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_drawRotationAxes(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_drawRotationAxes__SWIG_2(L);} } if (argc == 2) { int _v; - { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_drawRotationAxes__SWIG_1(L);} } } if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { - { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_drawRotationAxes__SWIG_0(L);} } } } + return _wrap_drawRotationAxes__SWIG_2(L);} if (argc == 2) { return _wrap_drawRotationAxes__SWIG_1(L);} if (argc == 3) { + return _wrap_drawRotationAxes__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'drawRotationAxes'\n" " Possible C/C++ prototypes are:\n" " ofDrawRotationAxes(float,float,int)\n" " ofDrawRotationAxes(float,float)\n" " ofDrawRotationAxes(float)\n"); lua_error(L);return 0; } @@ -11641,28 +12742,10 @@ static int _wrap_Camera_setupPerspective__SWIG_5(lua_State* L) { int SWIG_arg = SWIG_fail_ptr("Camera_setupPerspective",1,SWIGTYPE_p_ofCamera); } (arg1)->setupPerspective(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Camera_setupPerspective(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); - if (argc == 1) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCamera, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Camera_setupPerspective__SWIG_5(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCamera, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_Camera_setupPerspective__SWIG_4(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCamera, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Camera_setupPerspective__SWIG_3(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCamera, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Camera_setupPerspective__SWIG_2(L);} } } } } - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCamera, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Camera_setupPerspective__SWIG_1(L);} } } } } } if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCamera, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[5])==0 || SWIG_ConvertPtr(L,argv[5], (void **) &ptr, SWIGTYPE_p_glm__vec2, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Camera_setupPerspective__SWIG_0(L);} } } } } } } + if (argc == 1) { return _wrap_Camera_setupPerspective__SWIG_5(L);} if (argc == 2) { + return _wrap_Camera_setupPerspective__SWIG_4(L);} if (argc == 3) { return _wrap_Camera_setupPerspective__SWIG_3(L);} + if (argc == 4) { return _wrap_Camera_setupPerspective__SWIG_2(L);} if (argc == 5) { + return _wrap_Camera_setupPerspective__SWIG_1(L);} if (argc == 6) { return _wrap_Camera_setupPerspective__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Camera_setupPerspective'\n" " Possible C/C++ prototypes are:\n" " ofCamera::setupPerspective(bool,float,float,float,glm::vec2 const &)\n" " ofCamera::setupPerspective(bool,float,float,float)\n" " ofCamera::setupPerspective(bool,float,float)\n" @@ -11732,13 +12815,8 @@ static int _wrap_Camera_getImagePlaneDistance__SWIG_1(lua_State* L) { int SWIG_a result = (float)((ofCamera const *)arg1)->getImagePlaneDistance(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Camera_getImagePlaneDistance(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); - if (argc == 1) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCamera, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Camera_getImagePlaneDistance__SWIG_1(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCamera, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Camera_getImagePlaneDistance__SWIG_0(L);} } } + if (argc == 1) { return _wrap_Camera_getImagePlaneDistance__SWIG_1(L);} if (argc == 2) { + return _wrap_Camera_getImagePlaneDistance__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Camera_getImagePlaneDistance'\n" " Possible C/C++ prototypes are:\n" " ofCamera::getImagePlaneDistance(ofRectangle const &) const\n" " ofCamera::getImagePlaneDistance() const\n"); lua_error(L);return 0; } @@ -11757,13 +12835,7 @@ static int _wrap_Camera_beginCamera__SWIG_1(lua_State* L) { int SWIG_arg = 0; of SWIG_fail_ptr("Camera_beginCamera",2,SWIGTYPE_p_ofRectangle); } (arg1)->begin((ofRectangle const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Camera_beginCamera(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCamera, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Camera_beginCamera__SWIG_0(L);} } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCamera, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Camera_beginCamera__SWIG_1(L);} } } + return _wrap_Camera_beginCamera__SWIG_0(L);} if (argc == 2) { return _wrap_Camera_beginCamera__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Camera_beginCamera'\n" " Possible C/C++ prototypes are:\n" " ofCamera::begin()\n" " ofCamera::begin(ofRectangle const &)\n"); lua_error(L);return 0; } static int _wrap_Camera_endCamera(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; @@ -11792,13 +12864,8 @@ static int _wrap_Camera_getProjectionMatrix__SWIG_1(lua_State* L) { int SWIG_arg SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__mat4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Camera_getProjectionMatrix(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); - if (argc == 1) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCamera, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Camera_getProjectionMatrix__SWIG_0(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCamera, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Camera_getProjectionMatrix__SWIG_1(L);} } } + if (argc == 1) { return _wrap_Camera_getProjectionMatrix__SWIG_0(L);} if (argc == 2) { + return _wrap_Camera_getProjectionMatrix__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Camera_getProjectionMatrix'\n" " Possible C/C++ prototypes are:\n" " ofCamera::getProjectionMatrix() const\n" " ofCamera::getProjectionMatrix(ofRectangle const &) const\n"); lua_error(L);return 0; } @@ -11832,13 +12899,8 @@ static int _wrap_Camera_getModelViewProjectionMatrix__SWIG_1(lua_State* L) { int SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__mat4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Camera_getModelViewProjectionMatrix(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); - if (argc == 1) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCamera, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Camera_getModelViewProjectionMatrix__SWIG_1(L);} } if (argc == 2) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCamera, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Camera_getModelViewProjectionMatrix__SWIG_0(L);} } } + if (argc == 1) { return _wrap_Camera_getModelViewProjectionMatrix__SWIG_1(L);} if (argc == 2) { + return _wrap_Camera_getModelViewProjectionMatrix__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Camera_getModelViewProjectionMatrix'\n" " Possible C/C++ prototypes are:\n" " ofCamera::getModelViewProjectionMatrix(ofRectangle const &) const\n" " ofCamera::getModelViewProjectionMatrix() const\n"); lua_error(L);return 0; } @@ -11870,17 +12932,7 @@ static int _wrap_Camera_worldToScreen__SWIG_1(lua_State* L) { int SWIG_arg = 0; SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Camera_worldToScreen(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCamera, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Camera_worldToScreen__SWIG_1(L);} } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCamera, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Camera_worldToScreen__SWIG_0(L);} } } } + return _wrap_Camera_worldToScreen__SWIG_1(L);} if (argc == 3) { return _wrap_Camera_worldToScreen__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Camera_worldToScreen'\n" " Possible C/C++ prototypes are:\n" " ofCamera::worldToScreen(glm::vec3,ofRectangle const &) const\n" " ofCamera::worldToScreen(glm::vec3) const\n"); lua_error(L);return 0; } @@ -11912,17 +12964,7 @@ static int _wrap_Camera_screenToWorld__SWIG_1(lua_State* L) { int SWIG_arg = 0; SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Camera_screenToWorld(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCamera, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Camera_screenToWorld__SWIG_1(L);} } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCamera, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Camera_screenToWorld__SWIG_0(L);} } } } + return _wrap_Camera_screenToWorld__SWIG_1(L);} if (argc == 3) { return _wrap_Camera_screenToWorld__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Camera_screenToWorld'\n" " Possible C/C++ prototypes are:\n" " ofCamera::screenToWorld(glm::vec3,ofRectangle const &) const\n" " ofCamera::screenToWorld(glm::vec3) const\n"); lua_error(L);return 0; } @@ -11954,17 +12996,7 @@ static int _wrap_Camera_worldToCamera__SWIG_1(lua_State* L) { int SWIG_arg = 0; SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Camera_worldToCamera(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCamera, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Camera_worldToCamera__SWIG_1(L);} } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCamera, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Camera_worldToCamera__SWIG_0(L);} } } } + return _wrap_Camera_worldToCamera__SWIG_1(L);} if (argc == 3) { return _wrap_Camera_worldToCamera__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Camera_worldToCamera'\n" " Possible C/C++ prototypes are:\n" " ofCamera::worldToCamera(glm::vec3,ofRectangle const &) const\n" " ofCamera::worldToCamera(glm::vec3) const\n"); lua_error(L);return 0; } @@ -11996,17 +13028,7 @@ static int _wrap_Camera_cameraToWorld__SWIG_1(lua_State* L) { int SWIG_arg = 0; SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Camera_cameraToWorld(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCamera, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Camera_cameraToWorld__SWIG_1(L);} } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCamera, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Camera_cameraToWorld__SWIG_0(L);} } } } + return _wrap_Camera_cameraToWorld__SWIG_1(L);} if (argc == 3) { return _wrap_Camera_cameraToWorld__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Camera_cameraToWorld'\n" " Possible C/C++ prototypes are:\n" " ofCamera::cameraToWorld(glm::vec3,ofRectangle const &) const\n" " ofCamera::cameraToWorld(glm::vec3) const\n"); lua_error(L);return 0; } @@ -12037,13 +13059,7 @@ static int _wrap_Camera_drawFrustum__SWIG_1(lua_State* L) { int SWIG_arg = 0; of SWIG_fail_ptr("Camera_drawFrustum",1,SWIGTYPE_p_ofCamera); } ((ofCamera const *)arg1)->drawFrustum(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Camera_drawFrustum(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCamera, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Camera_drawFrustum__SWIG_1(L);} } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCamera, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Camera_drawFrustum__SWIG_0(L);} } } + return _wrap_Camera_drawFrustum__SWIG_1(L);} if (argc == 2) { return _wrap_Camera_drawFrustum__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Camera_drawFrustum'\n" " Possible C/C++ prototypes are:\n" " ofCamera::drawFrustum(ofRectangle const &) const\n" " ofCamera::drawFrustum() const\n"); lua_error(L);return 0; } static void swig_delete_Camera(void *obj) { @@ -12143,13 +13159,7 @@ static int _wrap_EasyCam_beginCamera__SWIG_1(lua_State* L) { int SWIG_arg = 0; o SWIG_fail_ptr("EasyCam_beginCamera",1,SWIGTYPE_p_ofEasyCam); } (arg1)->begin(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_EasyCam_beginCamera(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofEasyCam, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_EasyCam_beginCamera__SWIG_1(L);} } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofEasyCam, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_EasyCam_beginCamera__SWIG_0(L);} } } + return _wrap_EasyCam_beginCamera__SWIG_1(L);} if (argc == 2) { return _wrap_EasyCam_beginCamera__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'EasyCam_beginCamera'\n" " Possible C/C++ prototypes are:\n" " ofEasyCam::begin(ofRectangle const &)\n" " ofEasyCam::begin()\n"); lua_error(L);return 0; } @@ -12177,15 +13187,10 @@ static int _wrap_EasyCam_setTarget__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofE SWIG_fail_ptr("EasyCam_setTarget",2,SWIGTYPE_p_ofNode); } (arg1)->setTarget(*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_EasyCam_setTarget(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofEasyCam, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_EasyCam_setTarget__SWIG_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofEasyCam, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_EasyCam_setTarget__SWIG_1(L);} } } + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_EasyCam_setTarget__SWIG_0(L);} check_1: + if (argc == 2) { return _wrap_EasyCam_setTarget__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'EasyCam_setTarget'\n" " Possible C/C++ prototypes are:\n" " ofEasyCam::setTarget(glm::vec3 const &)\n" " ofEasyCam::setTarget(ofNode &)\n"); lua_error(L);return 0; } static int _wrap_EasyCam_getTarget(lua_State* L) { int SWIG_arg = 0; ofEasyCam *arg1 = (ofEasyCam *) 0 ; ofNode *result = 0 ; @@ -12257,15 +13262,9 @@ static int _wrap_EasyCam_setRotationSensitivity__SWIG_1(lua_State* L) { int SWIG (arg1)->setRotationSensitivity((glm::vec3 const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_EasyCam_setRotationSensitivity(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofEasyCam, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_EasyCam_setRotationSensitivity__SWIG_1(L);} } } if (argc == 4) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofEasyCam, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_EasyCam_setRotationSensitivity__SWIG_0(L);} } } } - } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'EasyCam_setRotationSensitivity'\n" + if (argc == 2) { return _wrap_EasyCam_setRotationSensitivity__SWIG_1(L);} if (argc == 4) { + return _wrap_EasyCam_setRotationSensitivity__SWIG_0(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'EasyCam_setRotationSensitivity'\n" " Possible C/C++ prototypes are:\n" " ofEasyCam::setRotationSensitivity(float,float,float)\n" " ofEasyCam::setRotationSensitivity(glm::vec3 const &)\n"); lua_error(L);return 0; } static int _wrap_EasyCam_setTranslationSensitivity__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofEasyCam *arg1 = (ofEasyCam *) 0 ; @@ -12289,15 +13288,8 @@ static int _wrap_EasyCam_setTranslationSensitivity__SWIG_1(lua_State* L) { int S (arg1)->setTranslationSensitivity((glm::vec3 const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_EasyCam_setTranslationSensitivity(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofEasyCam, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_EasyCam_setTranslationSensitivity__SWIG_1(L);} } } if (argc == 4) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofEasyCam, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_EasyCam_setTranslationSensitivity__SWIG_0(L);} } } } } + if (argc == 2) { return _wrap_EasyCam_setTranslationSensitivity__SWIG_1(L);} if (argc == 4) { + return _wrap_EasyCam_setTranslationSensitivity__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'EasyCam_setTranslationSensitivity'\n" " Possible C/C++ prototypes are:\n" " ofEasyCam::setTranslationSensitivity(float,float,float)\n" " ofEasyCam::setTranslationSensitivity(glm::vec3 const &)\n"); lua_error(L);return 0; } @@ -12367,12 +13359,8 @@ static int _wrap_EasyCam_setRelativeYAxis__SWIG_1(lua_State* L) { int SWIG_arg = SWIG_fail_ptr("EasyCam_setRelativeYAxis",1,SWIGTYPE_p_ofEasyCam); } (arg1)->setRelativeYAxis(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_EasyCam_setRelativeYAxis(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); - if (argc == 1) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofEasyCam, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_EasyCam_setRelativeYAxis__SWIG_1(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofEasyCam, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_EasyCam_setRelativeYAxis__SWIG_0(L);} } } + if (argc == 1) { return _wrap_EasyCam_setRelativeYAxis__SWIG_1(L);} if (argc == 2) { + return _wrap_EasyCam_setRelativeYAxis__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'EasyCam_setRelativeYAxis'\n" " Possible C/C++ prototypes are:\n" " ofEasyCam::setRelativeYAxis(bool)\n" " ofEasyCam::setRelativeYAxis()\n"); lua_error(L);return 0; } @@ -12462,13 +13450,8 @@ static int _wrap_EasyCam_addInteraction__SWIG_1(lua_State* L) { int SWIG_arg = 0 arg3 = (int)lua_tonumber(L, 3); (arg1)->addInteraction(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_EasyCam_addInteraction(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofEasyCam, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_EasyCam_addInteraction__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofEasyCam, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_EasyCam_addInteraction__SWIG_0(L);} } } } } + if (argc == 3) { return _wrap_EasyCam_addInteraction__SWIG_1(L);} if (argc == 4) { + return _wrap_EasyCam_addInteraction__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'EasyCam_addInteraction'\n" " Possible C/C++ prototypes are:\n" " ofEasyCam::addInteraction(ofEasyCam::TransformType,int,int)\n" " ofEasyCam::addInteraction(ofEasyCam::TransformType,int)\n"); lua_error(L);return 0; } @@ -12492,13 +13475,8 @@ static int _wrap_EasyCam_removeInteraction__SWIG_1(lua_State* L) { int SWIG_arg arg2 = (ofEasyCam::TransformType)(int)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); (arg1)->removeInteraction(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_EasyCam_removeInteraction(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofEasyCam, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_EasyCam_removeInteraction__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofEasyCam, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_EasyCam_removeInteraction__SWIG_0(L);} } } } } + if (argc == 3) { return _wrap_EasyCam_removeInteraction__SWIG_1(L);} if (argc == 4) { + return _wrap_EasyCam_removeInteraction__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'EasyCam_removeInteraction'\n" " Possible C/C++ prototypes are:\n" " ofEasyCam::removeInteraction(ofEasyCam::TransformType,int,int)\n" " ofEasyCam::removeInteraction(ofEasyCam::TransformType,int)\n"); lua_error(L);return 0; } @@ -12521,30 +13499,12 @@ static int _wrap_EasyCam_hasInteraction__SWIG_1(lua_State* L) { int SWIG_arg = 0 SWIG_fail_ptr("EasyCam_hasInteraction",1,SWIGTYPE_p_ofEasyCam); } arg2 = (ofEasyCam::TransformType)(int)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); result = (bool)(arg1)->hasInteraction(arg2,arg3); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_EasyCam_hasInteraction__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofEasyCam *arg1 = (ofEasyCam *) 0 ; int arg2 ; - int arg3 ; bool result; SWIG_check_num_args("ofEasyCam::hasInteraction",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofEasyCam::hasInteraction",1,"ofEasyCam *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofEasyCam::hasInteraction",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofEasyCam::hasInteraction",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofEasyCam,0))){ - SWIG_fail_ptr("EasyCam_hasInteraction",1,SWIGTYPE_p_ofEasyCam); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); result = (bool)(arg1)->hasInteraction(arg2,arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_EasyCam_hasInteraction(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofEasyCam, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_EasyCam_hasInteraction__SWIG_1(L);} } } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofEasyCam, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_EasyCam_hasInteraction__SWIG_2(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofEasyCam, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_EasyCam_hasInteraction__SWIG_0(L);} } } } } + if (argc == 3) { return _wrap_EasyCam_hasInteraction__SWIG_1(L);} if (argc == 4) { + return _wrap_EasyCam_hasInteraction__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'EasyCam_hasInteraction'\n" " Possible C/C++ prototypes are:\n" " ofEasyCam::hasInteraction(ofEasyCam::TransformType,int,int)\n" - " ofEasyCam::hasInteraction(ofEasyCam::TransformType,int)\n" " ofEasyCam::hasInteraction(int,int)\n"); - lua_error(L);return 0; } + " ofEasyCam::hasInteraction(ofEasyCam::TransformType,int)\n"); lua_error(L);return 0; } static int _wrap_EasyCam_removeAllInteractions(lua_State* L) { int SWIG_arg = 0; ofEasyCam *arg1 = (ofEasyCam *) 0 ; SWIG_check_num_args("ofEasyCam::removeAllInteractions",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofEasyCam::removeAllInteractions",1,"ofEasyCam *"); @@ -12637,223 +13597,2278 @@ static swig_lua_class *swig_EasyCam_bases[] = {0,0}; static const char *swig_EasyCam_base_names[] = {"ofCamera *",0}; static swig_lua_class _wrap_class_EasyCam = { "EasyCam", "EasyCam", &SWIGTYPE_p_ofEasyCam,_proxy__wrap_new_EasyCam, swig_delete_EasyCam, swig_EasyCam_methods, swig_EasyCam_attributes, &swig_EasyCam_Sf_SwigStatic, swig_EasyCam_meta, swig_EasyCam_bases, swig_EasyCam_base_names }; -static int _wrap_MeshData_getVerticesData(lua_State* L) { int SWIG_arg = 0; ofMeshData *arg1 = (ofMeshData *) 0 ; - SwigValueWrapper< ofArrayView< void > > result; SWIG_check_num_args("ofMeshData::getVerticesData",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMeshData::getVerticesData",1,"ofMeshData const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMeshData,0))){ - SWIG_fail_ptr("MeshData_getVerticesData",1,SWIGTYPE_p_ofMeshData); } - result = ((ofMeshData const *)arg1)->getVerticesData(); { - ofArrayView< void > * resultptr = new ofArrayView< void >((const ofArrayView< void > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofArrayViewT_void_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_MeshData_getNormalsData(lua_State* L) { int SWIG_arg = 0; ofMeshData *arg1 = (ofMeshData *) 0 ; - SwigValueWrapper< ofArrayView< void > > result; SWIG_check_num_args("ofMeshData::getNormalsData",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMeshData::getNormalsData",1,"ofMeshData const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMeshData,0))){ - SWIG_fail_ptr("MeshData_getNormalsData",1,SWIGTYPE_p_ofMeshData); } result = ((ofMeshData const *)arg1)->getNormalsData(); - { ofArrayView< void > * resultptr = new ofArrayView< void >((const ofArrayView< void > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofArrayViewT_void_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; +static int _wrap_new_MeshFaceVector__SWIG_0(lua_State* L) { int SWIG_arg = 0; + std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > > *result = 0 ; + SWIG_check_num_args("std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > >::vector",0,0) + result = (std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > > *)new std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > >(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofMeshFace_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t_t,1); SWIG_arg++; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_new_MeshFaceVector__SWIG_1(lua_State* L) { int SWIG_arg = 0; unsigned int arg1 ; + std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > > *result = 0 ; + SWIG_check_num_args("std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > >::vector",1,1) + if(!lua_isnumber(L,1)) SWIG_fail_arg("std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > >::vector",1,"unsigned int"); + SWIG_contract_assert((lua_tonumber(L,1)>=0),"number must not be negative") arg1 = (unsigned int)lua_tonumber(L, 1); + result = (std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > > *)new std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > >(arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofMeshFace_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t_t,1); SWIG_arg++; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_new_MeshFaceVector__SWIG_2(lua_State* L) { int SWIG_arg = 0; + std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > > *arg1 = 0 ; + std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > > *result = 0 ; + SWIG_check_num_args("std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > >::vector",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > >::vector",1,"std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > > const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofMeshFace_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t_t,0))){ + SWIG_fail_ptr("new_MeshFaceVector",1,SWIGTYPE_p_std__vectorT_ofMeshFace_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t_t); } + + result = (std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > > *)new std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > >((std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > > const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofMeshFace_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t_t,1); SWIG_arg++; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_new_MeshFaceVector__SWIG_3(lua_State* L) { int SWIG_arg = 0; unsigned int arg1 ; + ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > arg2 ; + ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *argp2 ; + std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > > *result = 0 ; + SWIG_check_num_args("std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > >::vector",2,2) + if(!lua_isnumber(L,1)) SWIG_fail_arg("std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > >::vector",1,"unsigned int"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > >::vector",2,"ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >"); + SWIG_contract_assert((lua_tonumber(L,1)>=0),"number must not be negative") arg1 = (unsigned int)lua_tonumber(L, 1); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofMeshFace_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("new_MeshFaceVector",2,SWIGTYPE_p_ofMeshFace_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + arg2 = *argp2; + result = (std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > > *)new std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > >(arg1,arg2); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofMeshFace_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t_t,1); SWIG_arg++; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_new_MeshFaceVector(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 0) { + return _wrap_new_MeshFaceVector__SWIG_0(L);} if (argc == 1) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_std__vectorT_ofMeshFace_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t_t, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_new_MeshFaceVector__SWIG_2(L);} check_2: + if (argc == 1) { return _wrap_new_MeshFaceVector__SWIG_1(L);} if (argc == 2) { return _wrap_new_MeshFaceVector__SWIG_3(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_MeshFaceVector'\n" " Possible C/C++ prototypes are:\n" + " std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > >::vector()\n" + " std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > >::vector(unsigned int)\n" + " std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > >::vector(std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > > const &)\n" + " std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > >::vector(unsigned int,ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >)\n"); + lua_error(L);return 0; } +static int _wrap_MeshFaceVector_size(lua_State* L) { int SWIG_arg = 0; + std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > > *arg1 = (std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > > *) 0 ; + unsigned int result; + SWIG_check_num_args("std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > >::size",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > >::size",1,"std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > > const *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofMeshFace_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t_t,0))){ + SWIG_fail_ptr("MeshFaceVector_size",1,SWIGTYPE_p_std__vectorT_ofMeshFace_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t_t); } + + result = (unsigned int)((std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > > const *)arg1)->size(); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_MeshFaceVector_max_size(lua_State* L) { int SWIG_arg = 0; + std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > > *arg1 = (std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > > *) 0 ; + unsigned int result; + SWIG_check_num_args("std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > >::max_size",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > >::max_size",1,"std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > > const *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofMeshFace_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t_t,0))){ + SWIG_fail_ptr("MeshFaceVector_max_size",1,SWIGTYPE_p_std__vectorT_ofMeshFace_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t_t); } + + result = (unsigned int)((std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > > const *)arg1)->max_size(); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_MeshFaceVector_empty(lua_State* L) { int SWIG_arg = 0; + std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > > *arg1 = (std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > > *) 0 ; + bool result; + SWIG_check_num_args("std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > >::empty",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > >::empty",1,"std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > > const *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofMeshFace_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t_t,0))){ + SWIG_fail_ptr("MeshFaceVector_empty",1,SWIGTYPE_p_std__vectorT_ofMeshFace_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t_t); } + + result = (bool)((std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > > const *)arg1)->empty(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_MeshFaceVector_clear(lua_State* L) { int SWIG_arg = 0; + std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > > *arg1 = (std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > > *) 0 ; + SWIG_check_num_args("std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > >::clear",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > >::clear",1,"std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > > *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofMeshFace_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t_t,0))){ + SWIG_fail_ptr("MeshFaceVector_clear",1,SWIGTYPE_p_std__vectorT_ofMeshFace_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t_t); } + (arg1)->clear(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_MeshFaceVector_push_back(lua_State* L) { int SWIG_arg = 0; + std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > > *arg1 = (std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > > *) 0 ; + ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > arg2 ; + ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *argp2 ; + SWIG_check_num_args("std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > >::push_back",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > >::push_back",1,"std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > > *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > >::push_back",2,"ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofMeshFace_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t_t,0))){ + SWIG_fail_ptr("MeshFaceVector_push_back",1,SWIGTYPE_p_std__vectorT_ofMeshFace_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t_t); } + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofMeshFace_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("MeshFaceVector_push_back",2,SWIGTYPE_p_ofMeshFace_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + arg2 = *argp2; (arg1)->push_back(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_MeshFaceVector_pop_back(lua_State* L) { int SWIG_arg = 0; + std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > > *arg1 = (std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > > *) 0 ; + SWIG_check_num_args("std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > >::pop_back",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > >::pop_back",1,"std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > > *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofMeshFace_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t_t,0))){ + SWIG_fail_ptr("MeshFaceVector_pop_back",1,SWIGTYPE_p_std__vectorT_ofMeshFace_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t_t); } + (arg1)->pop_back(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_MeshFaceVector_front(lua_State* L) { int SWIG_arg = 0; + std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > > *arg1 = (std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > > *) 0 ; + ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > result; + SWIG_check_num_args("std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > >::front",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > >::front",1,"std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > > const *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofMeshFace_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t_t,0))){ + SWIG_fail_ptr("MeshFaceVector_front",1,SWIGTYPE_p_std__vectorT_ofMeshFace_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t_t); } + + result = ((std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > > const *)arg1)->front(); + { + ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > * resultptr = new ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >((const ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMeshFace_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,1); SWIG_arg++; } + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_MeshFaceVector_back(lua_State* L) { int SWIG_arg = 0; + std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > > *arg1 = (std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > > *) 0 ; + ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > result; + SWIG_check_num_args("std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > >::back",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > >::back",1,"std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > > const *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofMeshFace_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t_t,0))){ + SWIG_fail_ptr("MeshFaceVector_back",1,SWIGTYPE_p_std__vectorT_ofMeshFace_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t_t); } + + result = ((std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > > const *)arg1)->back(); + { + ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > * resultptr = new ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >((const ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMeshFace_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,1); SWIG_arg++; } + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_MeshFaceVector___getitem(lua_State* L) { int SWIG_arg = 0; + std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > > *arg1 = (std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > > *) 0 ; + unsigned int arg2 ; ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > result; + SWIG_check_num_args("std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > >::__getitem__",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > >::__getitem__",1,"std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > > *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > >::__getitem__",2,"unsigned int"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofMeshFace_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t_t,0))){ + SWIG_fail_ptr("MeshFaceVector___getitem",1,SWIGTYPE_p_std__vectorT_ofMeshFace_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t_t); } + SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned int)lua_tonumber(L, 2); try { + result = std_vector_Sl_ofMeshFace__Sl_ofDefaultVertexType_Sc_ofDefaultNormalType_Sc_ofDefaultColorType_Sc_ofDefaultTexCoordType_Sg__Sg____getitem__(arg1,arg2);} + catch(std::out_of_range &_e) { SWIG_exception(SWIG_IndexError, (&_e)->what()); } { + ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > * resultptr = new ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >((const ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMeshFace_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,1); SWIG_arg++; } + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_MeshFaceVector___setitem(lua_State* L) { int SWIG_arg = 0; + std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > > *arg1 = (std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > > *) 0 ; + unsigned int arg2 ; ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > arg3 ; + ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *argp3 ; + SWIG_check_num_args("std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > >::__setitem__",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > >::__setitem__",1,"std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > > *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > >::__setitem__",2,"unsigned int"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > >::__setitem__",3,"ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofMeshFace_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t_t,0))){ + SWIG_fail_ptr("MeshFaceVector___setitem",1,SWIGTYPE_p_std__vectorT_ofMeshFace_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t_t); } + SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned int)lua_tonumber(L, 2); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&argp3,SWIGTYPE_p_ofMeshFace_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("MeshFaceVector___setitem",3,SWIGTYPE_p_ofMeshFace_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + arg3 = *argp3; try { + std_vector_Sl_ofMeshFace__Sl_ofDefaultVertexType_Sc_ofDefaultNormalType_Sc_ofDefaultColorType_Sc_ofDefaultTexCoordType_Sg__Sg____setitem__(arg1,arg2,arg3);} + catch(std::out_of_range &_e) { SWIG_exception(SWIG_IndexError, (&_e)->what()); } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static void swig_delete_MeshFaceVector(void *obj) { +std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > > *arg1 = (std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > > *) obj; +delete arg1; +} +static int _proxy__wrap_new_MeshFaceVector(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_MeshFaceVector); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_MeshFaceVector_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_MeshFaceVector_methods[]= { + { "size", _wrap_MeshFaceVector_size}, + { "max_size", _wrap_MeshFaceVector_max_size}, + { "empty", _wrap_MeshFaceVector_empty}, + { "clear", _wrap_MeshFaceVector_clear}, + { "push_back", _wrap_MeshFaceVector_push_back}, + { "pop_back", _wrap_MeshFaceVector_pop_back}, + { "front", _wrap_MeshFaceVector_front}, + { "back", _wrap_MeshFaceVector_back}, + { "__getitem", _wrap_MeshFaceVector___getitem}, + { "__setitem", _wrap_MeshFaceVector___setitem}, + {0,0} +}; +static swig_lua_method swig_MeshFaceVector_meta[] = { + { "__getitem", _wrap_MeshFaceVector___getitem}, + { "__setitem", _wrap_MeshFaceVector___setitem}, + {0,0} +}; + +static swig_lua_attribute swig_MeshFaceVector_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_MeshFaceVector_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_MeshFaceVector_Sf_SwigStatic_methods[]= { + {0,0} +}; +static swig_lua_class* swig_MeshFaceVector_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_MeshFaceVector_Sf_SwigStatic = { + "MeshFaceVector", + swig_MeshFaceVector_Sf_SwigStatic_methods, + swig_MeshFaceVector_Sf_SwigStatic_attributes, + swig_MeshFaceVector_Sf_SwigStatic_constants, + swig_MeshFaceVector_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_MeshFaceVector_bases[] = {0}; +static const char *swig_MeshFaceVector_base_names[] = {0}; +static swig_lua_class _wrap_class_MeshFaceVector = { "MeshFaceVector", "MeshFaceVector", &SWIGTYPE_p_std__vectorT_ofMeshFace_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t_t,_proxy__wrap_new_MeshFaceVector, swig_delete_MeshFaceVector, swig_MeshFaceVector_methods, swig_MeshFaceVector_attributes, &swig_MeshFaceVector_Sf_SwigStatic, swig_MeshFaceVector_meta, swig_MeshFaceVector_bases, swig_MeshFaceVector_base_names }; + +static int _wrap_new_Mesh__SWIG_0(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *result = 0 ; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::ofMesh_",0,0) + result = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *)new ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,1); SWIG_arg++; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_new_Mesh__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPrimitiveMode arg1 ; + std::vector< ofDefaultVertexType > *arg2 = 0 ; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *result = 0 ; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::ofMesh_",2,2) + if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::ofMesh_",1,"ofPrimitiveMode"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::ofMesh_",2,"std::vector< ofDefaultVertexType > const &"); + arg1 = (ofPrimitiveMode)(int)lua_tonumber(L, 1); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__vectorT_glm__vec3_t,0))){ + SWIG_fail_ptr("new_Mesh",2,SWIGTYPE_p_std__vectorT_glm__vec3_t); } + result = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *)new ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >(arg1,(std::vector< ofDefaultVertexType > const &)*arg2); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,1); SWIG_arg++; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_new_Mesh(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 0) { + return _wrap_new_Mesh__SWIG_0(L);} if (argc == 2) { return _wrap_new_Mesh__SWIG_1(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_Mesh'\n" " Possible C/C++ prototypes are:\n" + " ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::ofMesh_()\n" + " ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::ofMesh_(ofPrimitiveMode,std::vector< ofDefaultVertexType > const &)\n"); + lua_error(L);return 0; } +static int _wrap_Mesh_setFromTriangles__SWIG_0(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > > *arg2 = 0 ; + bool arg3 ; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::setFromTriangles",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::setFromTriangles",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::setFromTriangles",2,"std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > > const &"); + if(!lua_isboolean(L,3)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::setFromTriangles",3,"bool"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_setFromTriangles",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__vectorT_ofMeshFace_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t_t,0))){ + SWIG_fail_ptr("Mesh_setFromTriangles",2,SWIGTYPE_p_std__vectorT_ofMeshFace_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t_t); } + arg3 = (lua_toboolean(L, 3)!=0); + (arg1)->setFromTriangles((std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > > const &)*arg2,arg3); + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_setFromTriangles__SWIG_1(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > > *arg2 = 0 ; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::setFromTriangles",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::setFromTriangles",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::setFromTriangles",2,"std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > > const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_setFromTriangles",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__vectorT_ofMeshFace_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t_t,0))){ + SWIG_fail_ptr("Mesh_setFromTriangles",2,SWIGTYPE_p_std__vectorT_ofMeshFace_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t_t); } + + (arg1)->setFromTriangles((std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > > const &)*arg2); + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_setFromTriangles(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { + return _wrap_Mesh_setFromTriangles__SWIG_1(L);} if (argc == 3) { return _wrap_Mesh_setFromTriangles__SWIG_0(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_setFromTriangles'\n" + " Possible C/C++ prototypes are:\n" + " ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::setFromTriangles(std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > > const &,bool)\n" + " ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::setFromTriangles(std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > > const &)\n"); + lua_error(L);return 0; } +static int _wrap_Mesh_setMode(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + ofPrimitiveMode arg2 ; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::setMode",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::setMode",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::setMode",2,"ofPrimitiveMode"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_setMode",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + arg2 = (ofPrimitiveMode)(int)lua_tonumber(L, 2); (arg1)->setMode(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_Mesh_getMode(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + ofPrimitiveMode result; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getMode",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getMode",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_getMode",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + + result = (ofPrimitiveMode)((ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *)arg1)->getMode(); + lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_Mesh_plane__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; int arg3 ; int arg4 ; + ofPrimitiveMode arg5 ; ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > result; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::plane",5,5) + if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::plane",1,"float"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::plane",2,"float"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::plane",3,"int"); + if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::plane",4,"int"); + if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::plane",5,"ofPrimitiveMode"); + arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); + arg4 = (int)lua_tonumber(L, 4); arg5 = (ofPrimitiveMode)(int)lua_tonumber(L, 5); + result = ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::SWIGTEMPLATEDISAMBIGUATOR plane(arg1,arg2,arg3,arg4,arg5); + { + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > * resultptr = new ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >((const ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,1); SWIG_arg++; } + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_plane__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; int arg3 ; int arg4 ; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > result; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::plane",4,4) + if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::plane",1,"float"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::plane",2,"float"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::plane",3,"int"); + if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::plane",4,"int"); + arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); + arg4 = (int)lua_tonumber(L, 4); + result = ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::SWIGTEMPLATEDISAMBIGUATOR plane(arg1,arg2,arg3,arg4); + { + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > * resultptr = new ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >((const ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,1); SWIG_arg++; } + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_plane__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; int arg3 ; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > result; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::plane",3,3) + if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::plane",1,"float"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::plane",2,"float"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::plane",3,"int"); + arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); + result = ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::SWIGTEMPLATEDISAMBIGUATOR plane(arg1,arg2,arg3); + { + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > * resultptr = new ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >((const ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,1); SWIG_arg++; } + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_plane__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > result; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::plane",2,2) + if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::plane",1,"float"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::plane",2,"float"); + arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); + result = ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::SWIGTEMPLATEDISAMBIGUATOR plane(arg1,arg2); + { + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > * resultptr = new ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >((const ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,1); SWIG_arg++; } + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_plane(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 2) { + return _wrap_Mesh_plane__SWIG_3(L);} if (argc == 3) { return _wrap_Mesh_plane__SWIG_2(L);} if (argc == 4) { + return _wrap_Mesh_plane__SWIG_1(L);} if (argc == 5) { return _wrap_Mesh_plane__SWIG_0(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_plane'\n" " Possible C/C++ prototypes are:\n" + " ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::plane(float,float,int,int,ofPrimitiveMode)\n" + " ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::plane(float,float,int,int)\n" + " ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::plane(float,float,int)\n" + " ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::plane(float,float)\n"); + lua_error(L);return 0; } +static int _wrap_Mesh_sphere__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; int arg2 ; ofPrimitiveMode arg3 ; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > result; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::sphere",3,3) + if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::sphere",1,"float"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::sphere",2,"int"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::sphere",3,"ofPrimitiveMode"); + arg1 = (float)lua_tonumber(L, 1); arg2 = (int)lua_tonumber(L, 2); arg3 = (ofPrimitiveMode)(int)lua_tonumber(L, 3); + result = ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::SWIGTEMPLATEDISAMBIGUATOR sphere(arg1,arg2,arg3); + { + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > * resultptr = new ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >((const ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,1); SWIG_arg++; } + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_sphere__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; int arg2 ; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > result; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::sphere",2,2) + if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::sphere",1,"float"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::sphere",2,"int"); + arg1 = (float)lua_tonumber(L, 1); arg2 = (int)lua_tonumber(L, 2); + result = ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::SWIGTEMPLATEDISAMBIGUATOR sphere(arg1,arg2); + { + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > * resultptr = new ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >((const ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,1); SWIG_arg++; } + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_sphere__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > result; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::sphere",1,1) + if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::sphere",1,"float"); + arg1 = (float)lua_tonumber(L, 1); + result = ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::SWIGTEMPLATEDISAMBIGUATOR sphere(arg1); + { + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > * resultptr = new ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >((const ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,1); SWIG_arg++; } + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_sphere(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 1) { + return _wrap_Mesh_sphere__SWIG_2(L);} if (argc == 2) { return _wrap_Mesh_sphere__SWIG_1(L);} if (argc == 3) { + return _wrap_Mesh_sphere__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_sphere'\n" + " Possible C/C++ prototypes are:\n" + " ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::sphere(float,int,ofPrimitiveMode)\n" + " ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::sphere(float,int)\n" + " ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::sphere(float)\n"); + lua_error(L);return 0; } +static int _wrap_Mesh_icosahedron(lua_State* L) { int SWIG_arg = 0; float arg1 ; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > result; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::icosahedron",1,1) + if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::icosahedron",1,"float"); + arg1 = (float)lua_tonumber(L, 1); + result = ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::SWIGTEMPLATEDISAMBIGUATOR icosahedron(arg1); + { + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > * resultptr = new ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >((const ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,1); SWIG_arg++; } + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_icosphere__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; std::size_t arg2 ; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > result; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::icosphere",2,2) + if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::icosphere",1,"float"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::icosphere",2,"std::size_t"); + arg1 = (float)lua_tonumber(L, 1); SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") + arg2 = (std::size_t)lua_tonumber(L, 2); + result = ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::SWIGTEMPLATEDISAMBIGUATOR icosphere(arg1,arg2); + { + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > * resultptr = new ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >((const ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,1); SWIG_arg++; } + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_icosphere__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > result; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::icosphere",1,1) + if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::icosphere",1,"float"); + arg1 = (float)lua_tonumber(L, 1); + result = ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::SWIGTEMPLATEDISAMBIGUATOR icosphere(arg1); + { + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > * resultptr = new ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >((const ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,1); SWIG_arg++; } + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_icosphere(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { + return _wrap_Mesh_icosphere__SWIG_1(L);} if (argc == 2) { return _wrap_Mesh_icosphere__SWIG_0(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_icosphere'\n" " Possible C/C++ prototypes are:\n" + " ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::icosphere(float,std::size_t)\n" + " ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::icosphere(float)\n"); + lua_error(L);return 0; } +static int _wrap_Mesh_cylinder__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; int arg3 ; int arg4 ; + int arg5 ; bool arg6 ; ofPrimitiveMode arg7 ; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > result; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::cylinder",7,7) + if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::cylinder",1,"float"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::cylinder",2,"float"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::cylinder",3,"int"); + if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::cylinder",4,"int"); + if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::cylinder",5,"int"); + if(!lua_isboolean(L,6)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::cylinder",6,"bool"); + if(!lua_isnumber(L,7)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::cylinder",7,"ofPrimitiveMode"); + arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); + arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); arg6 = (lua_toboolean(L, 6)!=0); + arg7 = (ofPrimitiveMode)(int)lua_tonumber(L, 7); + result = ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::SWIGTEMPLATEDISAMBIGUATOR cylinder(arg1,arg2,arg3,arg4,arg5,arg6,arg7); + { + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > * resultptr = new ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >((const ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,1); SWIG_arg++; } + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_cylinder__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; int arg3 ; int arg4 ; + int arg5 ; bool arg6 ; ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > result; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::cylinder",6,6) + if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::cylinder",1,"float"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::cylinder",2,"float"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::cylinder",3,"int"); + if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::cylinder",4,"int"); + if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::cylinder",5,"int"); + if(!lua_isboolean(L,6)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::cylinder",6,"bool"); + arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); + arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); arg6 = (lua_toboolean(L, 6)!=0); + result = ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::SWIGTEMPLATEDISAMBIGUATOR cylinder(arg1,arg2,arg3,arg4,arg5,arg6); + { + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > * resultptr = new ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >((const ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,1); SWIG_arg++; } + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_cylinder__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; int arg3 ; int arg4 ; + int arg5 ; ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > result; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::cylinder",5,5) + if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::cylinder",1,"float"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::cylinder",2,"float"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::cylinder",3,"int"); + if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::cylinder",4,"int"); + if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::cylinder",5,"int"); + arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); + arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); + result = ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::SWIGTEMPLATEDISAMBIGUATOR cylinder(arg1,arg2,arg3,arg4,arg5); + { + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > * resultptr = new ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >((const ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,1); SWIG_arg++; } + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_cylinder__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; int arg3 ; int arg4 ; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > result; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::cylinder",4,4) + if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::cylinder",1,"float"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::cylinder",2,"float"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::cylinder",3,"int"); + if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::cylinder",4,"int"); + arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); + arg4 = (int)lua_tonumber(L, 4); + result = ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::SWIGTEMPLATEDISAMBIGUATOR cylinder(arg1,arg2,arg3,arg4); + { + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > * resultptr = new ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >((const ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,1); SWIG_arg++; } + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_cylinder__SWIG_4(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; int arg3 ; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > result; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::cylinder",3,3) + if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::cylinder",1,"float"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::cylinder",2,"float"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::cylinder",3,"int"); + arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); + result = ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::SWIGTEMPLATEDISAMBIGUATOR cylinder(arg1,arg2,arg3); + { + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > * resultptr = new ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >((const ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,1); SWIG_arg++; } + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_cylinder__SWIG_5(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > result; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::cylinder",2,2) + if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::cylinder",1,"float"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::cylinder",2,"float"); + arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); + result = ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::SWIGTEMPLATEDISAMBIGUATOR cylinder(arg1,arg2); + { + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > * resultptr = new ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >((const ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,1); SWIG_arg++; } + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_cylinder(lua_State* L) { int argc; int argv[8]={ 1,2,3,4,5,6,7,8} ; argc = lua_gettop(L); if (argc == 2) { + return _wrap_Mesh_cylinder__SWIG_5(L);} if (argc == 3) { return _wrap_Mesh_cylinder__SWIG_4(L);} if (argc == 4) { + return _wrap_Mesh_cylinder__SWIG_3(L);} if (argc == 5) { return _wrap_Mesh_cylinder__SWIG_2(L);} if (argc == 6) { + return _wrap_Mesh_cylinder__SWIG_1(L);} if (argc == 7) { return _wrap_Mesh_cylinder__SWIG_0(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_cylinder'\n" " Possible C/C++ prototypes are:\n" + " ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::cylinder(float,float,int,int,int,bool,ofPrimitiveMode)\n" + " ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::cylinder(float,float,int,int,int,bool)\n" + " ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::cylinder(float,float,int,int,int)\n" + " ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::cylinder(float,float,int,int)\n" + " ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::cylinder(float,float,int)\n" + " ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::cylinder(float,float)\n"); + lua_error(L);return 0; } +static int _wrap_Mesh_cone__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; int arg3 ; int arg4 ; int arg5 ; + ofPrimitiveMode arg6 ; ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > result; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::cone",6,6) + if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::cone",1,"float"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::cone",2,"float"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::cone",3,"int"); + if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::cone",4,"int"); + if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::cone",5,"int"); + if(!lua_isnumber(L,6)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::cone",6,"ofPrimitiveMode"); + arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); + arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); arg6 = (ofPrimitiveMode)(int)lua_tonumber(L, 6); + result = ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::SWIGTEMPLATEDISAMBIGUATOR cone(arg1,arg2,arg3,arg4,arg5,arg6); + { + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > * resultptr = new ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >((const ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,1); SWIG_arg++; } + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_cone__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; int arg3 ; int arg4 ; int arg5 ; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > result; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::cone",5,5) + if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::cone",1,"float"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::cone",2,"float"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::cone",3,"int"); + if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::cone",4,"int"); + if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::cone",5,"int"); + arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); + arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); + result = ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::SWIGTEMPLATEDISAMBIGUATOR cone(arg1,arg2,arg3,arg4,arg5); + { + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > * resultptr = new ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >((const ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,1); SWIG_arg++; } + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_cone__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; int arg3 ; int arg4 ; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > result; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::cone",4,4) + if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::cone",1,"float"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::cone",2,"float"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::cone",3,"int"); + if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::cone",4,"int"); + arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); + arg4 = (int)lua_tonumber(L, 4); + result = ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::SWIGTEMPLATEDISAMBIGUATOR cone(arg1,arg2,arg3,arg4); + { + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > * resultptr = new ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >((const ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,1); SWIG_arg++; } + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_cone__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; int arg3 ; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > result; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::cone",3,3) + if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::cone",1,"float"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::cone",2,"float"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::cone",3,"int"); + arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); + result = ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::SWIGTEMPLATEDISAMBIGUATOR cone(arg1,arg2,arg3); + { + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > * resultptr = new ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >((const ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,1); SWIG_arg++; } + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_cone__SWIG_4(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > result; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::cone",2,2) + if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::cone",1,"float"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::cone",2,"float"); + arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); + result = ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::SWIGTEMPLATEDISAMBIGUATOR cone(arg1,arg2); + { + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > * resultptr = new ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >((const ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,1); SWIG_arg++; } + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_cone(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); if (argc == 2) { + return _wrap_Mesh_cone__SWIG_4(L);} if (argc == 3) { return _wrap_Mesh_cone__SWIG_3(L);} if (argc == 4) { + return _wrap_Mesh_cone__SWIG_2(L);} if (argc == 5) { return _wrap_Mesh_cone__SWIG_1(L);} if (argc == 6) { + return _wrap_Mesh_cone__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_cone'\n" + " Possible C/C++ prototypes are:\n" + " ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::cone(float,float,int,int,int,ofPrimitiveMode)\n" + " ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::cone(float,float,int,int,int)\n" + " ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::cone(float,float,int,int)\n" + " ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::cone(float,float,int)\n" + " ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::cone(float,float)\n"); + lua_error(L);return 0; } +static int _wrap_Mesh_box__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; int arg4 ; int arg5 ; + int arg6 ; ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > result; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::box",6,6) + if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::box",1,"float"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::box",2,"float"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::box",3,"float"); + if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::box",4,"int"); + if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::box",5,"int"); + if(!lua_isnumber(L,6)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::box",6,"int"); + arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); + arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); arg6 = (int)lua_tonumber(L, 6); + result = ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::SWIGTEMPLATEDISAMBIGUATOR box(arg1,arg2,arg3,arg4,arg5,arg6); + { + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > * resultptr = new ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >((const ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,1); SWIG_arg++; } + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_box__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; int arg4 ; int arg5 ; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > result; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::box",5,5) + if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::box",1,"float"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::box",2,"float"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::box",3,"float"); + if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::box",4,"int"); + if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::box",5,"int"); + arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); + arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); + result = ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::SWIGTEMPLATEDISAMBIGUATOR box(arg1,arg2,arg3,arg4,arg5); + { + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > * resultptr = new ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >((const ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,1); SWIG_arg++; } + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_box__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; int arg4 ; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > result; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::box",4,4) + if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::box",1,"float"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::box",2,"float"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::box",3,"float"); + if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::box",4,"int"); + arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); + arg4 = (int)lua_tonumber(L, 4); + result = ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::SWIGTEMPLATEDISAMBIGUATOR box(arg1,arg2,arg3,arg4); + { + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > * resultptr = new ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >((const ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,1); SWIG_arg++; } + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_box__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > result; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::box",3,3) + if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::box",1,"float"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::box",2,"float"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::box",3,"float"); + arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); + result = ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::SWIGTEMPLATEDISAMBIGUATOR box(arg1,arg2,arg3); + { + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > * resultptr = new ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >((const ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,1); SWIG_arg++; } + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_box(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); if (argc == 3) { + return _wrap_Mesh_box__SWIG_3(L);} if (argc == 4) { return _wrap_Mesh_box__SWIG_2(L);} if (argc == 5) { + return _wrap_Mesh_box__SWIG_1(L);} if (argc == 6) { return _wrap_Mesh_box__SWIG_0(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_box'\n" " Possible C/C++ prototypes are:\n" + " ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::box(float,float,float,int,int,int)\n" + " ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::box(float,float,float,int,int)\n" + " ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::box(float,float,float,int)\n" + " ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::box(float,float,float)\n"); + lua_error(L);return 0; } +static int _wrap_Mesh_axis__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > result; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::axis",1,1) + if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::axis",1,"float"); + arg1 = (float)lua_tonumber(L, 1); + result = ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::SWIGTEMPLATEDISAMBIGUATOR axis(arg1); + { + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > * resultptr = new ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >((const ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,1); SWIG_arg++; } + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_axis__SWIG_1(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > result; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::axis",0,0) + result = ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::SWIGTEMPLATEDISAMBIGUATOR axis(); + { + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > * resultptr = new ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >((const ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,1); SWIG_arg++; } + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_axis(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { + return _wrap_Mesh_axis__SWIG_1(L);} if (argc == 1) { return _wrap_Mesh_axis__SWIG_0(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_axis'\n" " Possible C/C++ prototypes are:\n" + " ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::axis(float)\n" + " ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::axis()\n"); + lua_error(L);return 0; } +static int _wrap_Mesh_addVertex(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + ofDefaultVertexType *arg2 = 0 ; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::addVertex",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::addVertex",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::addVertex",2,"ofDefaultVertexType const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_addVertex",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ + SWIG_fail_ptr("Mesh_addVertex",2,SWIGTYPE_p_glm__vec3); } (arg1)->addVertex((ofDefaultVertexType const &)*arg2); + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_addVertices__SWIG_0(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + std::vector< ofDefaultVertexType > *arg2 = 0 ; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::addVertices",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::addVertices",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::addVertices",2,"std::vector< ofDefaultVertexType > const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_addVertices",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__vectorT_glm__vec3_t,0))){ + SWIG_fail_ptr("Mesh_addVertices",2,SWIGTYPE_p_std__vectorT_glm__vec3_t); } + (arg1)->addVertices((std::vector< ofDefaultVertexType > const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_Mesh_addVertices__SWIG_1(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + ofDefaultVertexType *arg2 = (ofDefaultVertexType *) 0 ; std::size_t arg3 ; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::addVertices",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::addVertices",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *"); + if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::addVertices",2,"ofDefaultVertexType const *"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::addVertices",3,"std::size_t"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_addVertices",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ + SWIG_fail_ptr("Mesh_addVertices",2,SWIGTYPE_p_glm__vec3); } + SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (std::size_t)lua_tonumber(L, 3); + (arg1)->addVertices((ofDefaultVertexType const *)arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_Mesh_addVertices(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { + return _wrap_Mesh_addVertices__SWIG_0(L);} if (argc == 3) { return _wrap_Mesh_addVertices__SWIG_1(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_addVertices'\n" " Possible C/C++ prototypes are:\n" + " ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::addVertices(std::vector< ofDefaultVertexType > const &)\n" + " ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::addVertices(ofDefaultVertexType const *,std::size_t)\n"); + lua_error(L);return 0; } +static int _wrap_Mesh_removeVertex(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + ofIndexType arg2 ; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::removeVertex",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::removeVertex",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::removeVertex",2,"ofIndexType"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_removeVertex",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); + (arg1)->removeVertex(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_setVertex(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + ofIndexType arg2 ; ofDefaultVertexType *arg3 = 0 ; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::setVertex",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::setVertex",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::setVertex",2,"ofIndexType"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::setVertex",3,"ofDefaultVertexType const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_setVertex",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_glm__vec3,0))){ + SWIG_fail_ptr("Mesh_setVertex",3,SWIGTYPE_p_glm__vec3); } (arg1)->setVertex(arg2,(ofDefaultVertexType const &)*arg3); + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_clearVertices(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::clearVertices",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::clearVertices",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_clearVertices",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + (arg1)->clearVertices(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_clear(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::clear",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::clear",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_clear",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + (arg1)->clear(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_getNumVertices(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + std::size_t result; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getNumVertices",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getNumVertices",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_getNumVertices",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + + result = (std::size_t)((ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *)arg1)->getNumVertices(); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_getVerticesPointer__SWIG_0(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + ofDefaultVertexType *result = 0 ; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getVerticesPointer",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getVerticesPointer",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_getVerticesPointer",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + result = (ofDefaultVertexType *)(arg1)->getVerticesPointer(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_glm__vec3,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_Mesh_getVerticesPointer__SWIG_1(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + ofDefaultVertexType *result = 0 ; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getVerticesPointer",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getVerticesPointer",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_getVerticesPointer",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + + result = (ofDefaultVertexType *)((ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *)arg1)->getVerticesPointer(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_glm__vec3,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_Mesh_getVerticesPointer(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { + return _wrap_Mesh_getVerticesPointer__SWIG_0(L);} if (argc == 1) { return _wrap_Mesh_getVerticesPointer__SWIG_1(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_getVerticesPointer'\n" + " Possible C/C++ prototypes are:\n" + " ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getVerticesPointer()\n" + " ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getVerticesPointer() const\n"); + lua_error(L);return 0; } +static int _wrap_Mesh_getVertex(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + ofIndexType arg2 ; ofDefaultVertexType result; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getVertex",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getVertex",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getVertex",2,"ofIndexType"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_getVertex",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); + result = ((ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *)arg1)->getVertex(arg2); + { ofDefaultVertexType * resultptr = new ofDefaultVertexType((const ofDefaultVertexType &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_getVertices__SWIG_0(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + std::vector< ofDefaultVertexType > *result = 0 ; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getVertices",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getVertices",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_getVertices",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + result = (std::vector< ofDefaultVertexType > *) &(arg1)->getVertices(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_glm__vec3_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_getVertices__SWIG_1(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + std::vector< ofDefaultVertexType > *result = 0 ; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getVertices",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getVertices",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_getVertices",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + + result = (std::vector< ofDefaultVertexType > *) &((ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *)arg1)->getVertices(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_glm__vec3_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_getVertices(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { + return _wrap_Mesh_getVertices__SWIG_0(L);} if (argc == 1) { return _wrap_Mesh_getVertices__SWIG_1(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_getVertices'\n" " Possible C/C++ prototypes are:\n" + " ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getVertices()\n" + " ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getVertices() const\n"); + lua_error(L);return 0; } +static int _wrap_Mesh_hasVertices(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + bool result; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::hasVertices",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::hasVertices",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_hasVertices",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + + result = (bool)((ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *)arg1)->hasVertices(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_append(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg2 = 0 ; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::append",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::append",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::append",2,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_append",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_append",2,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + (arg1)->append((ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const &)*arg2); + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_mergeDuplicateVertices(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::mergeDuplicateVertices",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::mergeDuplicateVertices",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_mergeDuplicateVertices",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + (arg1)->mergeDuplicateVertices(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_getCentroid(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + ofDefaultVertexType result; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getCentroid",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getCentroid",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_getCentroid",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + + result = ((ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *)arg1)->getCentroid(); + { ofDefaultVertexType * resultptr = new ofDefaultVertexType((const ofDefaultVertexType &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_getNormal(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + ofIndexType arg2 ; ofDefaultNormalType result; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getNormal",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getNormal",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getNormal",2,"ofIndexType"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_getNormal",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); + result = ((ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *)arg1)->getNormal(arg2); + { ofDefaultNormalType * resultptr = new ofDefaultNormalType((const ofDefaultNormalType &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_addNormal(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + ofDefaultNormalType *arg2 = 0 ; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::addNormal",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::addNormal",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::addNormal",2,"ofDefaultNormalType const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_addNormal",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ + SWIG_fail_ptr("Mesh_addNormal",2,SWIGTYPE_p_glm__vec3); } (arg1)->addNormal((ofDefaultNormalType const &)*arg2); + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_addNormals__SWIG_0(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + std::vector< ofDefaultNormalType > *arg2 = 0 ; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::addNormals",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::addNormals",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::addNormals",2,"std::vector< ofDefaultNormalType > const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_addNormals",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__vectorT_glm__vec3_t,0))){ + SWIG_fail_ptr("Mesh_addNormals",2,SWIGTYPE_p_std__vectorT_glm__vec3_t); } + (arg1)->addNormals((std::vector< ofDefaultNormalType > const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_Mesh_addNormals__SWIG_1(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + ofDefaultNormalType *arg2 = (ofDefaultNormalType *) 0 ; std::size_t arg3 ; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::addNormals",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::addNormals",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *"); + if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::addNormals",2,"ofDefaultNormalType const *"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::addNormals",3,"std::size_t"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_addNormals",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ + SWIG_fail_ptr("Mesh_addNormals",2,SWIGTYPE_p_glm__vec3); } + SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (std::size_t)lua_tonumber(L, 3); + (arg1)->addNormals((ofDefaultNormalType const *)arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_Mesh_addNormals(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { + return _wrap_Mesh_addNormals__SWIG_0(L);} if (argc == 3) { return _wrap_Mesh_addNormals__SWIG_1(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_addNormals'\n" " Possible C/C++ prototypes are:\n" + " ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::addNormals(std::vector< ofDefaultNormalType > const &)\n" + " ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::addNormals(ofDefaultNormalType const *,std::size_t)\n"); + lua_error(L);return 0; } +static int _wrap_Mesh_removeNormal(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + ofIndexType arg2 ; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::removeNormal",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::removeNormal",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::removeNormal",2,"ofIndexType"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_removeNormal",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); + (arg1)->removeNormal(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_setNormal(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + ofIndexType arg2 ; ofDefaultNormalType *arg3 = 0 ; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::setNormal",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::setNormal",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::setNormal",2,"ofIndexType"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::setNormal",3,"ofDefaultNormalType const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_setNormal",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_glm__vec3,0))){ + SWIG_fail_ptr("Mesh_setNormal",3,SWIGTYPE_p_glm__vec3); } (arg1)->setNormal(arg2,(ofDefaultNormalType const &)*arg3); + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_clearNormals(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::clearNormals",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::clearNormals",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_clearNormals",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + (arg1)->clearNormals(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_getNumNormals(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + std::size_t result; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getNumNormals",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getNumNormals",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_getNumNormals",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + + result = (std::size_t)((ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *)arg1)->getNumNormals(); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_getNormalsPointer__SWIG_0(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + ofDefaultNormalType *result = 0 ; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getNormalsPointer",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getNormalsPointer",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_getNormalsPointer",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + result = (ofDefaultNormalType *)(arg1)->getNormalsPointer(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_glm__vec3,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_Mesh_getNormalsPointer__SWIG_1(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + ofDefaultNormalType *result = 0 ; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getNormalsPointer",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getNormalsPointer",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_getNormalsPointer",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + + result = (ofDefaultNormalType *)((ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *)arg1)->getNormalsPointer(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_glm__vec3,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_Mesh_getNormalsPointer(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { + return _wrap_Mesh_getNormalsPointer__SWIG_0(L);} if (argc == 1) { return _wrap_Mesh_getNormalsPointer__SWIG_1(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_getNormalsPointer'\n" + " Possible C/C++ prototypes are:\n" + " ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getNormalsPointer()\n" + " ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getNormalsPointer() const\n"); + lua_error(L);return 0; } +static int _wrap_Mesh_getNormals__SWIG_0(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + std::vector< ofDefaultNormalType > *result = 0 ; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getNormals",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getNormals",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_getNormals",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + result = (std::vector< ofDefaultNormalType > *) &(arg1)->getNormals(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_glm__vec3_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_getNormals__SWIG_1(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + std::vector< ofDefaultNormalType > *result = 0 ; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getNormals",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getNormals",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_getNormals",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + + result = (std::vector< ofDefaultNormalType > *) &((ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *)arg1)->getNormals(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_glm__vec3_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_getNormals(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { + return _wrap_Mesh_getNormals__SWIG_0(L);} if (argc == 1) { return _wrap_Mesh_getNormals__SWIG_1(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_getNormals'\n" " Possible C/C++ prototypes are:\n" + " ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getNormals()\n" + " ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getNormals() const\n"); + lua_error(L);return 0; } +static int _wrap_Mesh_hasNormals(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + bool result; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::hasNormals",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::hasNormals",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_hasNormals",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + + result = (bool)((ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *)arg1)->hasNormals(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_enableNormals(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::enableNormals",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::enableNormals",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_enableNormals",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + (arg1)->enableNormals(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_disableNormals(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::disableNormals",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::disableNormals",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_disableNormals",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + (arg1)->disableNormals(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_usingNormals(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + bool result; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::usingNormals",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::usingNormals",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_usingNormals",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + + result = (bool)((ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *)arg1)->usingNormals(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_smoothNormals(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + float arg2 ; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::smoothNormals",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::smoothNormals",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::smoothNormals",2,"float"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_smoothNormals",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + arg2 = (float)lua_tonumber(L, 2); (arg1)->smoothNormals(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_Mesh_flatNormals(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::flatNormals",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::flatNormals",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_flatNormals",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + (arg1)->flatNormals(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_getFace(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + ofIndexType arg2 ; ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > result; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getFace",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getFace",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getFace",2,"ofIndexType"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_getFace",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); + result = ((ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *)arg1)->getFace(arg2); + { + ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > * resultptr = new ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >((const ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMeshFace_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,1); SWIG_arg++; } + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_getFaceNormals__SWIG_0(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + bool arg2 ; std::vector< ofDefaultNormalType > result; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getFaceNormals",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getFaceNormals",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getFaceNormals",2,"bool"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_getFaceNormals",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + arg2 = (lua_toboolean(L, 2)!=0); + result = ((ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *)arg1)->getFaceNormals(arg2); + { + std::vector< ofDefaultNormalType > * resultptr = new std::vector< ofDefaultNormalType >((const std::vector< ofDefaultNormalType > &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_glm__vec3_t,1); SWIG_arg++; } return SWIG_arg; + if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_getFaceNormals__SWIG_1(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + std::vector< ofDefaultNormalType > result; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getFaceNormals",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getFaceNormals",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_getFaceNormals",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + + result = ((ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *)arg1)->getFaceNormals(); + { + std::vector< ofDefaultNormalType > * resultptr = new std::vector< ofDefaultNormalType >((const std::vector< ofDefaultNormalType > &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_glm__vec3_t,1); SWIG_arg++; } return SWIG_arg; + if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_getFaceNormals(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { + return _wrap_Mesh_getFaceNormals__SWIG_1(L);} if (argc == 2) { return _wrap_Mesh_getFaceNormals__SWIG_0(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_getFaceNormals'\n" + " Possible C/C++ prototypes are:\n" + " ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getFaceNormals(bool) const\n" + " ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getFaceNormals() const\n"); + lua_error(L);return 0; } +static int _wrap_Mesh_getUniqueFaces(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > > *result = 0 ; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getUniqueFaces",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getUniqueFaces",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_getUniqueFaces",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + + result = (std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > > *) &((ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *)arg1)->getUniqueFaces(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofMeshFace_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t_t,0); SWIG_arg++; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_getColor(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + ofIndexType arg2 ; ofDefaultColorType result; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getColor",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getColor",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getColor",2,"ofIndexType"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_getColor",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); + result = ((ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *)arg1)->getColor(arg2); + { ofDefaultColorType * resultptr = new ofDefaultColorType((const ofDefaultColorType &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_MeshData_getTextureCoordsData(lua_State* L) { int SWIG_arg = 0; ofMeshData *arg1 = (ofMeshData *) 0 ; - SwigValueWrapper< ofArrayView< void > > result; SWIG_check_num_args("ofMeshData::getTextureCoordsData",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMeshData::getTextureCoordsData",1,"ofMeshData const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMeshData,0))){ - SWIG_fail_ptr("MeshData_getTextureCoordsData",1,SWIGTYPE_p_ofMeshData); } - result = ((ofMeshData const *)arg1)->getTextureCoordsData(); { - ofArrayView< void > * resultptr = new ofArrayView< void >((const ofArrayView< void > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofArrayViewT_void_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; +static int _wrap_Mesh_addColor(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + ofDefaultColorType *arg2 = 0 ; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::addColor",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::addColor",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::addColor",2,"ofDefaultColorType const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_addColor",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_float_t,0))){ + SWIG_fail_ptr("Mesh_addColor",2,SWIGTYPE_p_ofColor_T_float_t); } (arg1)->addColor((ofDefaultColorType const &)*arg2); + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_addColors__SWIG_0(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + std::vector< ofDefaultColorType > *arg2 = 0 ; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::addColors",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::addColors",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::addColors",2,"std::vector< ofDefaultColorType > const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_addColors",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__vectorT_ofColor_T_float_t_t,0))){ + SWIG_fail_ptr("Mesh_addColors",2,SWIGTYPE_p_std__vectorT_ofColor_T_float_t_t); } + (arg1)->addColors((std::vector< ofDefaultColorType > const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_Mesh_addColors__SWIG_1(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + ofDefaultColorType *arg2 = (ofDefaultColorType *) 0 ; std::size_t arg3 ; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::addColors",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::addColors",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *"); + if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::addColors",2,"ofDefaultColorType const *"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::addColors",3,"std::size_t"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_addColors",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_float_t,0))){ + SWIG_fail_ptr("Mesh_addColors",2,SWIGTYPE_p_ofColor_T_float_t); } + SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (std::size_t)lua_tonumber(L, 3); + (arg1)->addColors((ofDefaultColorType const *)arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_Mesh_addColors(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { + return _wrap_Mesh_addColors__SWIG_0(L);} if (argc == 3) { return _wrap_Mesh_addColors__SWIG_1(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_addColors'\n" " Possible C/C++ prototypes are:\n" + " ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::addColors(std::vector< ofDefaultColorType > const &)\n" + " ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::addColors(ofDefaultColorType const *,std::size_t)\n"); + lua_error(L);return 0; } +static int _wrap_Mesh_removeColor(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + ofIndexType arg2 ; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::removeColor",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::removeColor",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::removeColor",2,"ofIndexType"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_removeColor",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); + (arg1)->removeColor(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_setColor(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + ofIndexType arg2 ; ofDefaultColorType *arg3 = 0 ; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::setColor",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::setColor",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::setColor",2,"ofIndexType"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::setColor",3,"ofDefaultColorType const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_setColor",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofColor_T_float_t,0))){ + SWIG_fail_ptr("Mesh_setColor",3,SWIGTYPE_p_ofColor_T_float_t); } (arg1)->setColor(arg2,(ofDefaultColorType const &)*arg3); + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_clearColors(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::clearColors",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::clearColors",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_clearColors",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + (arg1)->clearColors(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_getNumColors(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + std::size_t result; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getNumColors",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getNumColors",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_getNumColors",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + + result = (std::size_t)((ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *)arg1)->getNumColors(); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_getColorsPointer__SWIG_0(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + ofDefaultColorType *result = 0 ; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getColorsPointer",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getColorsPointer",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_getColorsPointer",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + result = (ofDefaultColorType *)(arg1)->getColorsPointer(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_getColorsPointer__SWIG_1(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + ofDefaultColorType *result = 0 ; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getColorsPointer",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getColorsPointer",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_getColorsPointer",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + + result = (ofDefaultColorType *)((ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *)arg1)->getColorsPointer(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_getColorsPointer(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { + return _wrap_Mesh_getColorsPointer__SWIG_0(L);} if (argc == 1) { return _wrap_Mesh_getColorsPointer__SWIG_1(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_getColorsPointer'\n" + " Possible C/C++ prototypes are:\n" + " ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getColorsPointer()\n" + " ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getColorsPointer() const\n"); + lua_error(L);return 0; } +static int _wrap_Mesh_getColors__SWIG_0(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + std::vector< ofDefaultColorType > *result = 0 ; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getColors",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getColors",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_getColors",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + result = (std::vector< ofDefaultColorType > *) &(arg1)->getColors(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofColor_T_float_t_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_MeshData_getColorsData(lua_State* L) { int SWIG_arg = 0; ofMeshData *arg1 = (ofMeshData *) 0 ; - SwigValueWrapper< ofArrayView< void > > result; SWIG_check_num_args("ofMeshData::getColorsData",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMeshData::getColorsData",1,"ofMeshData const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMeshData,0))){ - SWIG_fail_ptr("MeshData_getColorsData",1,SWIGTYPE_p_ofMeshData); } result = ((ofMeshData const *)arg1)->getColorsData(); { - ofArrayView< void > * resultptr = new ofArrayView< void >((const ofArrayView< void > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofArrayViewT_void_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; +static int _wrap_Mesh_getColors__SWIG_1(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + std::vector< ofDefaultColorType > *result = 0 ; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getColors",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getColors",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_getColors",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + + result = (std::vector< ofDefaultColorType > *) &((ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *)arg1)->getColors(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofColor_T_float_t_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_MeshData_getIndicesData(lua_State* L) { int SWIG_arg = 0; ofMeshData *arg1 = (ofMeshData *) 0 ; - SwigValueWrapper< ofArrayView< unsigned int > > result; SWIG_check_num_args("ofMeshData::getIndicesData",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMeshData::getIndicesData",1,"ofMeshData const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMeshData,0))){ - SWIG_fail_ptr("MeshData_getIndicesData",1,SWIGTYPE_p_ofMeshData); } result = ((ofMeshData const *)arg1)->getIndicesData(); - { ofArrayView< ofIndexType > * resultptr = new ofArrayView< ofIndexType >((const ofArrayView< ofIndexType > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofArrayViewT_unsigned_int_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_MeshData_getVerticesDim(lua_State* L) { int SWIG_arg = 0; ofMeshData *arg1 = (ofMeshData *) 0 ; int result; - SWIG_check_num_args("ofMeshData::getVerticesDim",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMeshData::getVerticesDim",1,"ofMeshData const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMeshData,0))){ - SWIG_fail_ptr("MeshData_getVerticesDim",1,SWIGTYPE_p_ofMeshData); } - result = (int)((ofMeshData const *)arg1)->getVerticesDim(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_MeshData_getNormalsDim(lua_State* L) { int SWIG_arg = 0; ofMeshData *arg1 = (ofMeshData *) 0 ; int result; - SWIG_check_num_args("ofMeshData::getNormalsDim",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMeshData::getNormalsDim",1,"ofMeshData const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMeshData,0))){ - SWIG_fail_ptr("MeshData_getNormalsDim",1,SWIGTYPE_p_ofMeshData); } - result = (int)((ofMeshData const *)arg1)->getNormalsDim(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_MeshData_getTextureCoordsDim(lua_State* L) { int SWIG_arg = 0; ofMeshData *arg1 = (ofMeshData *) 0 ; - int result; SWIG_check_num_args("ofMeshData::getTextureCoordsDim",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMeshData::getTextureCoordsDim",1,"ofMeshData const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMeshData,0))){ - SWIG_fail_ptr("MeshData_getTextureCoordsDim",1,SWIGTYPE_p_ofMeshData); } - result = (int)((ofMeshData const *)arg1)->getTextureCoordsDim(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_MeshData_getColorsDim(lua_State* L) { int SWIG_arg = 0; ofMeshData *arg1 = (ofMeshData *) 0 ; int result; - SWIG_check_num_args("ofMeshData::getColorsDim",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMeshData::getColorsDim",1,"ofMeshData const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMeshData,0))){ - SWIG_fail_ptr("MeshData_getColorsDim",1,SWIGTYPE_p_ofMeshData); } result = (int)((ofMeshData const *)arg1)->getColorsDim(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_MeshData_getIndicesDim(lua_State* L) { int SWIG_arg = 0; ofMeshData *arg1 = (ofMeshData *) 0 ; int result; - SWIG_check_num_args("ofMeshData::getIndicesDim",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMeshData::getIndicesDim",1,"ofMeshData const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMeshData,0))){ - SWIG_fail_ptr("MeshData_getIndicesDim",1,SWIGTYPE_p_ofMeshData); } - result = (int)((ofMeshData const *)arg1)->getIndicesDim(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_MeshData_getNumVertices(lua_State* L) { int SWIG_arg = 0; ofMeshData *arg1 = (ofMeshData *) 0 ; - std::size_t result; SWIG_check_num_args("ofMeshData::getNumVertices",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMeshData::getNumVertices",1,"ofMeshData const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMeshData,0))){ - SWIG_fail_ptr("MeshData_getNumVertices",1,SWIGTYPE_p_ofMeshData); } - result = (std::size_t)((ofMeshData const *)arg1)->getNumVertices(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_MeshData_getNumNormals(lua_State* L) { int SWIG_arg = 0; ofMeshData *arg1 = (ofMeshData *) 0 ; - std::size_t result; SWIG_check_num_args("ofMeshData::getNumNormals",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMeshData::getNumNormals",1,"ofMeshData const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMeshData,0))){ - SWIG_fail_ptr("MeshData_getNumNormals",1,SWIGTYPE_p_ofMeshData); } - result = (std::size_t)((ofMeshData const *)arg1)->getNumNormals(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_MeshData_getNumTextureCoords(lua_State* L) { int SWIG_arg = 0; ofMeshData *arg1 = (ofMeshData *) 0 ; - std::size_t result; SWIG_check_num_args("ofMeshData::getNumTextureCoords",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMeshData::getNumTextureCoords",1,"ofMeshData const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMeshData,0))){ - SWIG_fail_ptr("MeshData_getNumTextureCoords",1,SWIGTYPE_p_ofMeshData); } - result = (std::size_t)((ofMeshData const *)arg1)->getNumTextureCoords(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_MeshData_getNumColors(lua_State* L) { int SWIG_arg = 0; ofMeshData *arg1 = (ofMeshData *) 0 ; - std::size_t result; SWIG_check_num_args("ofMeshData::getNumColors",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMeshData::getNumColors",1,"ofMeshData const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMeshData,0))){ - SWIG_fail_ptr("MeshData_getNumColors",1,SWIGTYPE_p_ofMeshData); } - result = (std::size_t)((ofMeshData const *)arg1)->getNumColors(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_MeshData_getNumIndices(lua_State* L) { int SWIG_arg = 0; ofMeshData *arg1 = (ofMeshData *) 0 ; - std::size_t result; SWIG_check_num_args("ofMeshData::getNumIndices",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMeshData::getNumIndices",1,"ofMeshData const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMeshData,0))){ - SWIG_fail_ptr("MeshData_getNumIndices",1,SWIGTYPE_p_ofMeshData); } - result = (std::size_t)((ofMeshData const *)arg1)->getNumIndices(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_MeshData_usingVertices(lua_State* L) { int SWIG_arg = 0; ofMeshData *arg1 = (ofMeshData *) 0 ; bool result; - SWIG_check_num_args("ofMeshData::usingVertices",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMeshData::usingVertices",1,"ofMeshData const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMeshData,0))){ - SWIG_fail_ptr("MeshData_usingVertices",1,SWIGTYPE_p_ofMeshData); } - result = (bool)((ofMeshData const *)arg1)->usingVertices(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_MeshData_usingNormals(lua_State* L) { int SWIG_arg = 0; ofMeshData *arg1 = (ofMeshData *) 0 ; bool result; - SWIG_check_num_args("ofMeshData::usingNormals",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMeshData::usingNormals",1,"ofMeshData const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMeshData,0))){ - SWIG_fail_ptr("MeshData_usingNormals",1,SWIGTYPE_p_ofMeshData); } - result = (bool)((ofMeshData const *)arg1)->usingNormals(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_MeshData_usingColors(lua_State* L) { int SWIG_arg = 0; ofMeshData *arg1 = (ofMeshData *) 0 ; bool result; - SWIG_check_num_args("ofMeshData::usingColors",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMeshData::usingColors",1,"ofMeshData const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMeshData,0))){ - SWIG_fail_ptr("MeshData_usingColors",1,SWIGTYPE_p_ofMeshData); } result = (bool)((ofMeshData const *)arg1)->usingColors(); +static int _wrap_Mesh_getColors(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { + return _wrap_Mesh_getColors__SWIG_0(L);} if (argc == 1) { return _wrap_Mesh_getColors__SWIG_1(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_getColors'\n" " Possible C/C++ prototypes are:\n" + " ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getColors()\n" + " ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getColors() const\n"); + lua_error(L);return 0; } +static int _wrap_Mesh_hasColors(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + bool result; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::hasColors",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::hasColors",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_hasColors",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + + result = (bool)((ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *)arg1)->hasColors(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_enableColors(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::enableColors",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::enableColors",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_enableColors",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + (arg1)->enableColors(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_disableColors(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::disableColors",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::disableColors",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_disableColors",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + (arg1)->disableColors(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_usingColors(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + bool result; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::usingColors",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::usingColors",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_usingColors",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + + result = (bool)((ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *)arg1)->usingColors(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_getTexCoord(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + ofIndexType arg2 ; ofDefaultTexCoordType result; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getTexCoord",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getTexCoord",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getTexCoord",2,"ofIndexType"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_getTexCoord",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); + result = ((ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *)arg1)->getTexCoord(arg2); + { ofDefaultTexCoordType * resultptr = new ofDefaultTexCoordType((const ofDefaultTexCoordType &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_addTexCoord(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + ofDefaultTexCoordType *arg2 = 0 ; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::addTexCoord",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::addTexCoord",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::addTexCoord",2,"ofDefaultTexCoordType const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_addTexCoord",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec2,0))){ + SWIG_fail_ptr("Mesh_addTexCoord",2,SWIGTYPE_p_glm__vec2); } (arg1)->addTexCoord((ofDefaultTexCoordType const &)*arg2); + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_addTexCoords__SWIG_0(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + std::vector< ofDefaultTexCoordType > *arg2 = 0 ; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::addTexCoords",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::addTexCoords",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::addTexCoords",2,"std::vector< ofDefaultTexCoordType > const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_addTexCoords",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__vectorT_glm__vec2_t,0))){ + SWIG_fail_ptr("Mesh_addTexCoords",2,SWIGTYPE_p_std__vectorT_glm__vec2_t); } + (arg1)->addTexCoords((std::vector< ofDefaultTexCoordType > const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_addTexCoords__SWIG_1(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + ofDefaultTexCoordType *arg2 = (ofDefaultTexCoordType *) 0 ; std::size_t arg3 ; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::addTexCoords",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::addTexCoords",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *"); + if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::addTexCoords",2,"ofDefaultTexCoordType const *"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::addTexCoords",3,"std::size_t"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_addTexCoords",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec2,0))){ + SWIG_fail_ptr("Mesh_addTexCoords",2,SWIGTYPE_p_glm__vec2); } + SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (std::size_t)lua_tonumber(L, 3); + (arg1)->addTexCoords((ofDefaultTexCoordType const *)arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_Mesh_addTexCoords(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { + return _wrap_Mesh_addTexCoords__SWIG_0(L);} if (argc == 3) { return _wrap_Mesh_addTexCoords__SWIG_1(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_addTexCoords'\n" " Possible C/C++ prototypes are:\n" + " ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::addTexCoords(std::vector< ofDefaultTexCoordType > const &)\n" + " ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::addTexCoords(ofDefaultTexCoordType const *,std::size_t)\n"); + lua_error(L);return 0; } +static int _wrap_Mesh_removeTexCoord(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + ofIndexType arg2 ; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::removeTexCoord",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::removeTexCoord",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::removeTexCoord",2,"ofIndexType"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_removeTexCoord",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); + (arg1)->removeTexCoord(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_setTexCoord(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + ofIndexType arg2 ; ofDefaultTexCoordType *arg3 = 0 ; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::setTexCoord",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::setTexCoord",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::setTexCoord",2,"ofIndexType"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::setTexCoord",3,"ofDefaultTexCoordType const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_setTexCoord",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_glm__vec2,0))){ + SWIG_fail_ptr("Mesh_setTexCoord",3,SWIGTYPE_p_glm__vec2); } (arg1)->setTexCoord(arg2,(ofDefaultTexCoordType const &)*arg3); + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_clearTexCoords(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::clearTexCoords",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::clearTexCoords",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_clearTexCoords",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + (arg1)->clearTexCoords(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_getNumTexCoords(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + std::size_t result; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getNumTexCoords",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getNumTexCoords",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_getNumTexCoords",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + + result = (std::size_t)((ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *)arg1)->getNumTexCoords(); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_getTexCoordsPointer__SWIG_0(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + ofDefaultTexCoordType *result = 0 ; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getTexCoordsPointer",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getTexCoordsPointer",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_getTexCoordsPointer",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + result = (ofDefaultTexCoordType *)(arg1)->getTexCoordsPointer(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_glm__vec2,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_Mesh_getTexCoordsPointer__SWIG_1(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + ofDefaultTexCoordType *result = 0 ; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getTexCoordsPointer",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getTexCoordsPointer",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_getTexCoordsPointer",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + + result = (ofDefaultTexCoordType *)((ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *)arg1)->getTexCoordsPointer(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_glm__vec2,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_Mesh_getTexCoordsPointer(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { + return _wrap_Mesh_getTexCoordsPointer__SWIG_0(L);} if (argc == 1) { return _wrap_Mesh_getTexCoordsPointer__SWIG_1(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_getTexCoordsPointer'\n" + " Possible C/C++ prototypes are:\n" + " ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getTexCoordsPointer()\n" + " ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getTexCoordsPointer() const\n"); + lua_error(L);return 0; } +static int _wrap_Mesh_getTexCoords__SWIG_0(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + std::vector< ofDefaultTexCoordType > *result = 0 ; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getTexCoords",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getTexCoords",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_getTexCoords",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + result = (std::vector< ofDefaultTexCoordType > *) &(arg1)->getTexCoords(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_glm__vec2_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_getTexCoords__SWIG_1(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + std::vector< ofDefaultTexCoordType > *result = 0 ; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getTexCoords",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getTexCoords",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_getTexCoords",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + + result = (std::vector< ofDefaultTexCoordType > *) &((ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *)arg1)->getTexCoords(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_glm__vec2_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_getTexCoords(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { + return _wrap_Mesh_getTexCoords__SWIG_0(L);} if (argc == 1) { return _wrap_Mesh_getTexCoords__SWIG_1(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_getTexCoords'\n" " Possible C/C++ prototypes are:\n" + " ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getTexCoords()\n" + " ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getTexCoords() const\n"); + lua_error(L);return 0; } +static int _wrap_Mesh_hasTexCoords(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + bool result; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::hasTexCoords",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::hasTexCoords",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_hasTexCoords",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + + result = (bool)((ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *)arg1)->hasTexCoords(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_MeshData_usingTextures(lua_State* L) { int SWIG_arg = 0; ofMeshData *arg1 = (ofMeshData *) 0 ; bool result; - SWIG_check_num_args("ofMeshData::usingTextures",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMeshData::usingTextures",1,"ofMeshData const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMeshData,0))){ - SWIG_fail_ptr("MeshData_usingTextures",1,SWIGTYPE_p_ofMeshData); } - result = (bool)((ofMeshData const *)arg1)->usingTextures(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_MeshData_hasNormals(lua_State* L) { int SWIG_arg = 0; ofMeshData *arg1 = (ofMeshData *) 0 ; bool result; - SWIG_check_num_args("ofMeshData::hasNormals",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMeshData::hasNormals",1,"ofMeshData const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMeshData,0))){ - SWIG_fail_ptr("MeshData_hasNormals",1,SWIGTYPE_p_ofMeshData); } result = (bool)((ofMeshData const *)arg1)->hasNormals(); +static int _wrap_Mesh_enableTextures(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::enableTextures",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::enableTextures",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_enableTextures",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + (arg1)->enableTextures(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_disableTextures(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::disableTextures",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::disableTextures",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_disableTextures",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + (arg1)->disableTextures(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_usingTextures(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + bool result; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::usingTextures",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::usingTextures",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_usingTextures",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + + result = (bool)((ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *)arg1)->usingTextures(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_MeshData_hasColors(lua_State* L) { int SWIG_arg = 0; ofMeshData *arg1 = (ofMeshData *) 0 ; bool result; - SWIG_check_num_args("ofMeshData::hasColors",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMeshData::hasColors",1,"ofMeshData const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMeshData,0))){ - SWIG_fail_ptr("MeshData_hasColors",1,SWIGTYPE_p_ofMeshData); } result = (bool)((ofMeshData const *)arg1)->hasColors(); +static int _wrap_Mesh_setupIndicesAuto(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::setupIndicesAuto",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::setupIndicesAuto",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_setupIndicesAuto",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + (arg1)->setupIndicesAuto(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_getIndices__SWIG_0(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + std::vector< ofIndexType > *result = 0 ; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getIndices",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getIndices",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_getIndices",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + result = (std::vector< ofIndexType > *) &(arg1)->getIndices(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_unsigned_int_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_getIndex(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + ofIndexType arg2 ; ofIndexType result; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getIndex",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getIndex",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getIndex",2,"ofIndexType"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_getIndex",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); + result = (ofIndexType)((ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *)arg1)->getIndex(arg2); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_addIndex(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + ofIndexType arg2 ; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::addIndex",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::addIndex",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::addIndex",2,"ofIndexType"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_addIndex",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); + (arg1)->addIndex(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_addIndices__SWIG_0(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + std::vector< ofIndexType > *arg2 = 0 ; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::addIndices",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::addIndices",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::addIndices",2,"std::vector< ofIndexType > const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_addIndices",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__vectorT_unsigned_int_t,0))){ + SWIG_fail_ptr("Mesh_addIndices",2,SWIGTYPE_p_std__vectorT_unsigned_int_t); } + (arg1)->addIndices((std::vector< ofIndexType > const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_Mesh_addIndices__SWIG_1(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + ofIndexType *arg2 = (ofIndexType *) 0 ; std::size_t arg3 ; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::addIndices",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::addIndices",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *"); + if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::addIndices",2,"ofIndexType const *"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::addIndices",3,"std::size_t"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_addIndices",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_unsigned_int,0))){ + SWIG_fail_ptr("Mesh_addIndices",2,SWIGTYPE_p_unsigned_int); } + SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (std::size_t)lua_tonumber(L, 3); + (arg1)->addIndices((ofIndexType const *)arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_addIndices(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { + return _wrap_Mesh_addIndices__SWIG_0(L);} if (argc == 3) { return _wrap_Mesh_addIndices__SWIG_1(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_addIndices'\n" " Possible C/C++ prototypes are:\n" + " ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::addIndices(std::vector< ofIndexType > const &)\n" + " ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::addIndices(ofIndexType const *,std::size_t)\n"); + lua_error(L);return 0; } +static int _wrap_Mesh_removeIndex(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + ofIndexType arg2 ; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::removeIndex",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::removeIndex",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::removeIndex",2,"ofIndexType"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_removeIndex",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); + (arg1)->removeIndex(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_setIndex(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + ofIndexType arg2 ; ofIndexType arg3 ; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::setIndex",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::setIndex",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::setIndex",2,"ofIndexType"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::setIndex",3,"ofIndexType"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_setIndex",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); + SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (ofIndexType)lua_tonumber(L, 3); + (arg1)->setIndex(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_clearIndices(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::clearIndices",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::clearIndices",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_clearIndices",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + (arg1)->clearIndices(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_getNumIndices(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + std::size_t result; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getNumIndices",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getNumIndices",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_getNumIndices",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + + result = (std::size_t)((ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *)arg1)->getNumIndices(); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_getIndexPointer__SWIG_0(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + ofIndexType *result = 0 ; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getIndexPointer",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getIndexPointer",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_getIndexPointer",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + result = (ofIndexType *)(arg1)->getIndexPointer(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_unsigned_int,0); SWIG_arg++; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_getIndexPointer__SWIG_1(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + ofIndexType *result = 0 ; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getIndexPointer",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getIndexPointer",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_getIndexPointer",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + + result = (ofIndexType *)((ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *)arg1)->getIndexPointer(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_unsigned_int,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_Mesh_getIndexPointer(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { + return _wrap_Mesh_getIndexPointer__SWIG_0(L);} if (argc == 1) { return _wrap_Mesh_getIndexPointer__SWIG_1(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_getIndexPointer'\n" + " Possible C/C++ prototypes are:\n" + " ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getIndexPointer()\n" + " ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getIndexPointer() const\n"); + lua_error(L);return 0; } +static int _wrap_Mesh_getIndices__SWIG_1(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + std::vector< ofIndexType > *result = 0 ; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getIndices",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getIndices",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_getIndices",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + + result = (std::vector< ofIndexType > *) &((ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *)arg1)->getIndices(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_unsigned_int_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_getIndices(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { + return _wrap_Mesh_getIndices__SWIG_0(L);} if (argc == 1) { return _wrap_Mesh_getIndices__SWIG_1(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_getIndices'\n" " Possible C/C++ prototypes are:\n" + " ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getIndices()\n" + " ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getIndices() const\n"); + lua_error(L);return 0; } +static int _wrap_Mesh_hasIndices(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + bool result; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::hasIndices",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::hasIndices",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_hasIndices",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + + result = (bool)((ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *)arg1)->hasIndices(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_MeshData_hasTexCoords(lua_State* L) { int SWIG_arg = 0; ofMeshData *arg1 = (ofMeshData *) 0 ; bool result; - SWIG_check_num_args("ofMeshData::hasTexCoords",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMeshData::hasTexCoords",1,"ofMeshData const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMeshData,0))){ - SWIG_fail_ptr("MeshData_hasTexCoords",1,SWIGTYPE_p_ofMeshData); } - result = (bool)((ofMeshData const *)arg1)->hasTexCoords(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_MeshData(void *obj) { -ofMeshData *arg1 = (ofMeshData *) obj; +static int _wrap_Mesh_addTriangle(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + ofIndexType arg2 ; ofIndexType arg3 ; ofIndexType arg4 ; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::addTriangle",4,4) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::addTriangle",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::addTriangle",2,"ofIndexType"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::addTriangle",3,"ofIndexType"); + if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::addTriangle",4,"ofIndexType"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_addTriangle",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); + SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (ofIndexType)lua_tonumber(L, 3); + SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (ofIndexType)lua_tonumber(L, 4); + (arg1)->addTriangle(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_enableIndices(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::enableIndices",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::enableIndices",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_enableIndices",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + (arg1)->enableIndices(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_disableIndices(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::disableIndices",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::disableIndices",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_disableIndices",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + (arg1)->disableIndices(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_usingIndices(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + bool result; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::usingIndices",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::usingIndices",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_usingIndices",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + + result = (bool)((ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *)arg1)->usingIndices(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_setColorForIndices(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + ofIndexType arg2 ; ofIndexType arg3 ; ofDefaultColorType arg4 ; ofDefaultColorType *argp4 ; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::setColorForIndices",4,4) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::setColorForIndices",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::setColorForIndices",2,"ofIndexType"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::setColorForIndices",3,"ofIndexType"); + if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::setColorForIndices",4,"ofDefaultColorType"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_setColorForIndices",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); + SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (ofIndexType)lua_tonumber(L, 3); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&argp4,SWIGTYPE_p_ofColor_T_float_t,0))){ + SWIG_fail_ptr("Mesh_setColorForIndices",4,SWIGTYPE_p_ofColor_T_float_t); } arg4 = *argp4; + (arg1)->setColorForIndices(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_getMeshForIndices__SWIG_0(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + ofIndexType arg2 ; ofIndexType arg3 ; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > result; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getMeshForIndices",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getMeshForIndices",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getMeshForIndices",2,"ofIndexType"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getMeshForIndices",3,"ofIndexType"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_getMeshForIndices",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); + SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (ofIndexType)lua_tonumber(L, 3); + result = ((ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *)arg1)->getMeshForIndices(arg2,arg3); + { + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > * resultptr = new ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >((const ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,1); SWIG_arg++; } + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_getMeshForIndices__SWIG_1(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + ofIndexType arg2 ; ofIndexType arg3 ; ofIndexType arg4 ; ofIndexType arg5 ; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > result; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getMeshForIndices",5,5) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getMeshForIndices",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getMeshForIndices",2,"ofIndexType"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getMeshForIndices",3,"ofIndexType"); + if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getMeshForIndices",4,"ofIndexType"); + if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getMeshForIndices",5,"ofIndexType"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_getMeshForIndices",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); + SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (ofIndexType)lua_tonumber(L, 3); + SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (ofIndexType)lua_tonumber(L, 4); + SWIG_contract_assert((lua_tonumber(L,5)>=0),"number must not be negative") arg5 = (ofIndexType)lua_tonumber(L, 5); + result = ((ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *)arg1)->getMeshForIndices(arg2,arg3,arg4,arg5); + { + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > * resultptr = new ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >((const ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,1); SWIG_arg++; } + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_getMeshForIndices(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); + if (argc == 3) { return _wrap_Mesh_getMeshForIndices__SWIG_0(L);} if (argc == 5) { + return _wrap_Mesh_getMeshForIndices__SWIG_1(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_getMeshForIndices'\n" + " Possible C/C++ prototypes are:\n" + " ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getMeshForIndices(ofIndexType,ofIndexType) const\n" + " ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getMeshForIndices(ofIndexType,ofIndexType,ofIndexType,ofIndexType) const\n"); + lua_error(L);return 0; } +static int _wrap_Mesh_drawVertices(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::drawVertices",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::drawVertices",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_drawVertices",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + ((ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *)arg1)->drawVertices(); + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_drawWireframe(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::drawWireframe",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::drawWireframe",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_drawWireframe",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + ((ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *)arg1)->drawWireframe(); + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_drawFaces(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::drawFaces",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::drawFaces",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_drawFaces",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + ((ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *)arg1)->drawFaces(); + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_draw__SWIG_0(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::draw",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::draw",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_draw",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + ((ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *)arg1)->draw(); + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_draw__SWIG_1(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + ofPolyRenderMode arg2 ; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::draw",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::draw",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::draw",2,"ofPolyRenderMode"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_draw",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + arg2 = (ofPolyRenderMode)(int)lua_tonumber(L, 2); + ((ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *)arg1)->draw(arg2); + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_draw(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { + return _wrap_Mesh_draw__SWIG_0(L);} if (argc == 2) { return _wrap_Mesh_draw__SWIG_1(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_draw'\n" " Possible C/C++ prototypes are:\n" + " ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::draw() const\n" + " ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::draw(ofPolyRenderMode) const\n"); + lua_error(L);return 0; } +static int _wrap_Mesh_load(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + std::filesystem::path *arg2 = 0 ; std::filesystem::path temp2 ; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::load",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::load",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *"); + if(!lua_isstring(L,2)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::load",2,"std::filesystem::path const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_load",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + { size_t len = lua_rawlen(L, 2); temp2 = lua_tolstring(L, 2, &len); arg2 = &temp2; } + (arg1)->load((std::filesystem::path const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_save__SWIG_0(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + std::filesystem::path *arg2 = 0 ; bool arg3 ; std::filesystem::path temp2 ; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::save",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::save",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *"); + if(!lua_isstring(L,2)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::save",2,"std::filesystem::path const &"); + if(!lua_isboolean(L,3)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::save",3,"bool"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_save",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + { size_t len = lua_rawlen(L, 2); temp2 = lua_tolstring(L, 2, &len); arg2 = &temp2; } arg3 = (lua_toboolean(L, 3)!=0); + ((ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *)arg1)->save((std::filesystem::path const &)*arg2,arg3); + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_save__SWIG_1(lua_State* L) { int SWIG_arg = 0; + ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + std::filesystem::path *arg2 = 0 ; std::filesystem::path temp2 ; + SWIG_check_num_args("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::save",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::save",1,"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *"); + if(!lua_isstring(L,2)) SWIG_fail_arg("ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::save",2,"std::filesystem::path const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Mesh_save",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + { size_t len = lua_rawlen(L, 2); temp2 = lua_tolstring(L, 2, &len); arg2 = &temp2; } + ((ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *)arg1)->save((std::filesystem::path const &)*arg2); + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Mesh_save(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { + return _wrap_Mesh_save__SWIG_1(L);} if (argc == 3) { return _wrap_Mesh_save__SWIG_0(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_save'\n" " Possible C/C++ prototypes are:\n" + " ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::save(std::filesystem::path const &,bool) const\n" + " ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::save(std::filesystem::path const &) const\n"); + lua_error(L);return 0; } +static void swig_delete_Mesh(void *obj) { +ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) obj; delete arg1; } -static swig_lua_attribute swig_MeshData_attributes[] = { +static int _proxy__wrap_new_Mesh(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_Mesh); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_Mesh_attributes[] = { {0,0,0} }; -static swig_lua_method swig_MeshData_methods[]= { - { "getVerticesData", _wrap_MeshData_getVerticesData}, - { "getNormalsData", _wrap_MeshData_getNormalsData}, - { "getTextureCoordsData", _wrap_MeshData_getTextureCoordsData}, - { "getColorsData", _wrap_MeshData_getColorsData}, - { "getIndicesData", _wrap_MeshData_getIndicesData}, - { "getVerticesDim", _wrap_MeshData_getVerticesDim}, - { "getNormalsDim", _wrap_MeshData_getNormalsDim}, - { "getTextureCoordsDim", _wrap_MeshData_getTextureCoordsDim}, - { "getColorsDim", _wrap_MeshData_getColorsDim}, - { "getIndicesDim", _wrap_MeshData_getIndicesDim}, - { "getNumVertices", _wrap_MeshData_getNumVertices}, - { "getNumNormals", _wrap_MeshData_getNumNormals}, - { "getNumTextureCoords", _wrap_MeshData_getNumTextureCoords}, - { "getNumColors", _wrap_MeshData_getNumColors}, - { "getNumIndices", _wrap_MeshData_getNumIndices}, - { "usingVertices", _wrap_MeshData_usingVertices}, - { "usingNormals", _wrap_MeshData_usingNormals}, - { "usingColors", _wrap_MeshData_usingColors}, - { "usingTextures", _wrap_MeshData_usingTextures}, - { "hasNormals", _wrap_MeshData_hasNormals}, - { "hasColors", _wrap_MeshData_hasColors}, - { "hasTexCoords", _wrap_MeshData_hasTexCoords}, - {0,0} -}; -static swig_lua_method swig_MeshData_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_MeshData_Sf_SwigStatic_attributes[] = { +static swig_lua_method swig_Mesh_methods[]= { + { "setFromTriangles", _wrap_Mesh_setFromTriangles}, + { "setMode", _wrap_Mesh_setMode}, + { "getMode", _wrap_Mesh_getMode}, + { "addVertex", _wrap_Mesh_addVertex}, + { "addVertices", _wrap_Mesh_addVertices}, + { "removeVertex", _wrap_Mesh_removeVertex}, + { "setVertex", _wrap_Mesh_setVertex}, + { "clearVertices", _wrap_Mesh_clearVertices}, + { "clear", _wrap_Mesh_clear}, + { "getNumVertices", _wrap_Mesh_getNumVertices}, + { "getVerticesPointer", _wrap_Mesh_getVerticesPointer}, + { "getVertex", _wrap_Mesh_getVertex}, + { "getVertices", _wrap_Mesh_getVertices}, + { "hasVertices", _wrap_Mesh_hasVertices}, + { "append", _wrap_Mesh_append}, + { "mergeDuplicateVertices", _wrap_Mesh_mergeDuplicateVertices}, + { "getCentroid", _wrap_Mesh_getCentroid}, + { "getNormal", _wrap_Mesh_getNormal}, + { "addNormal", _wrap_Mesh_addNormal}, + { "addNormals", _wrap_Mesh_addNormals}, + { "removeNormal", _wrap_Mesh_removeNormal}, + { "setNormal", _wrap_Mesh_setNormal}, + { "clearNormals", _wrap_Mesh_clearNormals}, + { "getNumNormals", _wrap_Mesh_getNumNormals}, + { "getNormalsPointer", _wrap_Mesh_getNormalsPointer}, + { "getNormals", _wrap_Mesh_getNormals}, + { "hasNormals", _wrap_Mesh_hasNormals}, + { "enableNormals", _wrap_Mesh_enableNormals}, + { "disableNormals", _wrap_Mesh_disableNormals}, + { "usingNormals", _wrap_Mesh_usingNormals}, + { "smoothNormals", _wrap_Mesh_smoothNormals}, + { "flatNormals", _wrap_Mesh_flatNormals}, + { "getFace", _wrap_Mesh_getFace}, + { "getFaceNormals", _wrap_Mesh_getFaceNormals}, + { "getUniqueFaces", _wrap_Mesh_getUniqueFaces}, + { "getColor", _wrap_Mesh_getColor}, + { "addColor", _wrap_Mesh_addColor}, + { "addColors", _wrap_Mesh_addColors}, + { "removeColor", _wrap_Mesh_removeColor}, + { "setColor", _wrap_Mesh_setColor}, + { "clearColors", _wrap_Mesh_clearColors}, + { "getNumColors", _wrap_Mesh_getNumColors}, + { "getColorsPointer", _wrap_Mesh_getColorsPointer}, + { "getColors", _wrap_Mesh_getColors}, + { "hasColors", _wrap_Mesh_hasColors}, + { "enableColors", _wrap_Mesh_enableColors}, + { "disableColors", _wrap_Mesh_disableColors}, + { "usingColors", _wrap_Mesh_usingColors}, + { "getTexCoord", _wrap_Mesh_getTexCoord}, + { "addTexCoord", _wrap_Mesh_addTexCoord}, + { "addTexCoords", _wrap_Mesh_addTexCoords}, + { "removeTexCoord", _wrap_Mesh_removeTexCoord}, + { "setTexCoord", _wrap_Mesh_setTexCoord}, + { "clearTexCoords", _wrap_Mesh_clearTexCoords}, + { "getNumTexCoords", _wrap_Mesh_getNumTexCoords}, + { "getTexCoordsPointer", _wrap_Mesh_getTexCoordsPointer}, + { "getTexCoords", _wrap_Mesh_getTexCoords}, + { "hasTexCoords", _wrap_Mesh_hasTexCoords}, + { "enableTextures", _wrap_Mesh_enableTextures}, + { "disableTextures", _wrap_Mesh_disableTextures}, + { "usingTextures", _wrap_Mesh_usingTextures}, + { "setupIndicesAuto", _wrap_Mesh_setupIndicesAuto}, + { "getIndex", _wrap_Mesh_getIndex}, + { "addIndex", _wrap_Mesh_addIndex}, + { "addIndices", _wrap_Mesh_addIndices}, + { "removeIndex", _wrap_Mesh_removeIndex}, + { "setIndex", _wrap_Mesh_setIndex}, + { "clearIndices", _wrap_Mesh_clearIndices}, + { "getNumIndices", _wrap_Mesh_getNumIndices}, + { "getIndexPointer", _wrap_Mesh_getIndexPointer}, + { "getIndices", _wrap_Mesh_getIndices}, + { "hasIndices", _wrap_Mesh_hasIndices}, + { "addTriangle", _wrap_Mesh_addTriangle}, + { "enableIndices", _wrap_Mesh_enableIndices}, + { "disableIndices", _wrap_Mesh_disableIndices}, + { "usingIndices", _wrap_Mesh_usingIndices}, + { "setColorForIndices", _wrap_Mesh_setColorForIndices}, + { "getMeshForIndices", _wrap_Mesh_getMeshForIndices}, + { "drawVertices", _wrap_Mesh_drawVertices}, + { "drawWireframe", _wrap_Mesh_drawWireframe}, + { "drawFaces", _wrap_Mesh_drawFaces}, + { "draw", _wrap_Mesh_draw}, + { "load", _wrap_Mesh_load}, + { "save", _wrap_Mesh_save}, + {0,0} +}; +static swig_lua_method swig_Mesh_meta[] = { + {0,0} +}; + +static swig_lua_attribute swig_Mesh_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_Mesh_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_Mesh_Sf_SwigStatic_methods[]= { + { "plane", _wrap_Mesh_plane}, + { "sphere", _wrap_Mesh_sphere}, + { "icosahedron", _wrap_Mesh_icosahedron}, + { "icosphere", _wrap_Mesh_icosphere}, + { "cylinder", _wrap_Mesh_cylinder}, + { "cone", _wrap_Mesh_cone}, + { "box", _wrap_Mesh_box}, + { "axis", _wrap_Mesh_axis}, + {0,0} +}; +static swig_lua_class* swig_Mesh_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_Mesh_Sf_SwigStatic = { + "Mesh", + swig_Mesh_Sf_SwigStatic_methods, + swig_Mesh_Sf_SwigStatic_attributes, + swig_Mesh_Sf_SwigStatic_constants, + swig_Mesh_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_Mesh_bases[] = {0}; +static const char *swig_Mesh_base_names[] = {0}; +static swig_lua_class _wrap_class_Mesh = { "Mesh", "Mesh", &SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,_proxy__wrap_new_Mesh, swig_delete_Mesh, swig_Mesh_methods, swig_Mesh_attributes, &swig_Mesh_Sf_SwigStatic, swig_Mesh_meta, swig_Mesh_bases, swig_Mesh_base_names }; + +static int _wrap_new_MeshFace(lua_State* L) { int SWIG_arg = 0; + ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *result = 0 ; + SWIG_check_num_args("ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::ofMeshFace_",0,0) + result = (ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *)new ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMeshFace_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,1); SWIG_arg++; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_MeshFace_getFaceNormal(lua_State* L) { int SWIG_arg = 0; + ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + ofDefaultNormalType *result = 0 ; + SWIG_check_num_args("ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getFaceNormal",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getFaceNormal",1,"ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMeshFace_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("MeshFace_getFaceNormal",1,SWIGTYPE_p_ofMeshFace_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + + result = (ofDefaultNormalType *) &((ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *)arg1)->getFaceNormal(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_glm__vec3,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_MeshFace_setVertex(lua_State* L) { int SWIG_arg = 0; + ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + ofIndexType arg2 ; ofDefaultVertexType *arg3 = 0 ; + SWIG_check_num_args("ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::setVertex",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::setVertex",1,"ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::setVertex",2,"ofIndexType"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::setVertex",3,"ofDefaultVertexType const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMeshFace_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("MeshFace_setVertex",1,SWIGTYPE_p_ofMeshFace_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_glm__vec3,0))){ + SWIG_fail_ptr("MeshFace_setVertex",3,SWIGTYPE_p_glm__vec3); } (arg1)->setVertex(arg2,(ofDefaultVertexType const &)*arg3); + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_MeshFace_getVertex(lua_State* L) { int SWIG_arg = 0; + ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + ofIndexType arg2 ; ofDefaultVertexType *result = 0 ; + SWIG_check_num_args("ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getVertex",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getVertex",1,"ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getVertex",2,"ofIndexType"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMeshFace_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("MeshFace_getVertex",1,SWIGTYPE_p_ofMeshFace_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); + result = (ofDefaultVertexType *) &((ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *)arg1)->getVertex(arg2); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_glm__vec3,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_MeshFace_setNormal(lua_State* L) { int SWIG_arg = 0; + ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + ofIndexType arg2 ; ofDefaultNormalType *arg3 = 0 ; + SWIG_check_num_args("ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::setNormal",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::setNormal",1,"ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::setNormal",2,"ofIndexType"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::setNormal",3,"ofDefaultNormalType const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMeshFace_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("MeshFace_setNormal",1,SWIGTYPE_p_ofMeshFace_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_glm__vec3,0))){ + SWIG_fail_ptr("MeshFace_setNormal",3,SWIGTYPE_p_glm__vec3); } (arg1)->setNormal(arg2,(ofDefaultNormalType const &)*arg3); + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_MeshFace_getNormal(lua_State* L) { int SWIG_arg = 0; + ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + ofIndexType arg2 ; ofDefaultNormalType *result = 0 ; + SWIG_check_num_args("ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getNormal",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getNormal",1,"ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getNormal",2,"ofIndexType"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMeshFace_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("MeshFace_getNormal",1,SWIGTYPE_p_ofMeshFace_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); + result = (ofDefaultNormalType *) &((ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *)arg1)->getNormal(arg2); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_glm__vec3,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_MeshFace_setColor(lua_State* L) { int SWIG_arg = 0; + ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + ofIndexType arg2 ; ofDefaultColorType *arg3 = 0 ; + SWIG_check_num_args("ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::setColor",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::setColor",1,"ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::setColor",2,"ofIndexType"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::setColor",3,"ofDefaultColorType const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMeshFace_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("MeshFace_setColor",1,SWIGTYPE_p_ofMeshFace_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofColor_T_float_t,0))){ + SWIG_fail_ptr("MeshFace_setColor",3,SWIGTYPE_p_ofColor_T_float_t); } + (arg1)->setColor(arg2,(ofDefaultColorType const &)*arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_MeshFace_getColor(lua_State* L) { int SWIG_arg = 0; + ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + ofIndexType arg2 ; ofDefaultColorType *result = 0 ; + SWIG_check_num_args("ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getColor",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getColor",1,"ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getColor",2,"ofIndexType"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMeshFace_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("MeshFace_getColor",1,SWIGTYPE_p_ofMeshFace_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); + result = (ofDefaultColorType *) &((ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *)arg1)->getColor(arg2); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_MeshFace_setTexCoord(lua_State* L) { int SWIG_arg = 0; + ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + ofIndexType arg2 ; ofDefaultTexCoordType *arg3 = 0 ; + SWIG_check_num_args("ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::setTexCoord",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::setTexCoord",1,"ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::setTexCoord",2,"ofIndexType"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::setTexCoord",3,"ofDefaultTexCoordType const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMeshFace_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("MeshFace_setTexCoord",1,SWIGTYPE_p_ofMeshFace_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_glm__vec2,0))){ + SWIG_fail_ptr("MeshFace_setTexCoord",3,SWIGTYPE_p_glm__vec2); } + (arg1)->setTexCoord(arg2,(ofDefaultTexCoordType const &)*arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_MeshFace_getTexCoord(lua_State* L) { int SWIG_arg = 0; + ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + ofIndexType arg2 ; ofDefaultTexCoordType *result = 0 ; + SWIG_check_num_args("ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getTexCoord",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getTexCoord",1,"ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::getTexCoord",2,"ofIndexType"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMeshFace_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("MeshFace_getTexCoord",1,SWIGTYPE_p_ofMeshFace_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); + result = (ofDefaultTexCoordType *) &((ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *)arg1)->getTexCoord(arg2); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_glm__vec2,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_MeshFace_setHasColors(lua_State* L) { int SWIG_arg = 0; + ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + bool arg2 ; + SWIG_check_num_args("ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::setHasColors",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::setHasColors",1,"ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::setHasColors",2,"bool"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMeshFace_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("MeshFace_setHasColors",1,SWIGTYPE_p_ofMeshFace_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + arg2 = (lua_toboolean(L, 2)!=0); (arg1)->setHasColors(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_MeshFace_setHasNormals(lua_State* L) { int SWIG_arg = 0; + ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + bool arg2 ; + SWIG_check_num_args("ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::setHasNormals",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::setHasNormals",1,"ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::setHasNormals",2,"bool"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMeshFace_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("MeshFace_setHasNormals",1,SWIGTYPE_p_ofMeshFace_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + arg2 = (lua_toboolean(L, 2)!=0); (arg1)->setHasNormals(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_MeshFace_setHasTexcoords(lua_State* L) { int SWIG_arg = 0; + ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + bool arg2 ; + SWIG_check_num_args("ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::setHasTexcoords",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::setHasTexcoords",1,"ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::setHasTexcoords",2,"bool"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMeshFace_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("MeshFace_setHasTexcoords",1,SWIGTYPE_p_ofMeshFace_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + arg2 = (lua_toboolean(L, 2)!=0); (arg1)->setHasTexcoords(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_MeshFace_hasColors(lua_State* L) { int SWIG_arg = 0; + ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + bool result; + SWIG_check_num_args("ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::hasColors",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::hasColors",1,"ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMeshFace_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("MeshFace_hasColors",1,SWIGTYPE_p_ofMeshFace_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + + result = (bool)((ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *)arg1)->hasColors(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_MeshFace_hasNormals(lua_State* L) { int SWIG_arg = 0; + ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + bool result; + SWIG_check_num_args("ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::hasNormals",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::hasNormals",1,"ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMeshFace_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("MeshFace_hasNormals",1,SWIGTYPE_p_ofMeshFace_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + + result = (bool)((ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *)arg1)->hasNormals(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_MeshFace_hasTexcoords(lua_State* L) { int SWIG_arg = 0; + ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) 0 ; + bool result; + SWIG_check_num_args("ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::hasTexcoords",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType >::hasTexcoords",1,"ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMeshFace_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("MeshFace_hasTexcoords",1,SWIGTYPE_p_ofMeshFace_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + + result = (bool)((ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > const *)arg1)->hasTexcoords(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static void swig_delete_MeshFace(void *obj) { +ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *arg1 = (ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) obj; +delete arg1; +} +static int _proxy__wrap_new_MeshFace(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_MeshFace); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_MeshFace_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_MeshFace_methods[]= { + { "getFaceNormal", _wrap_MeshFace_getFaceNormal}, + { "setVertex", _wrap_MeshFace_setVertex}, + { "getVertex", _wrap_MeshFace_getVertex}, + { "setNormal", _wrap_MeshFace_setNormal}, + { "getNormal", _wrap_MeshFace_getNormal}, + { "setColor", _wrap_MeshFace_setColor}, + { "getColor", _wrap_MeshFace_getColor}, + { "setTexCoord", _wrap_MeshFace_setTexCoord}, + { "getTexCoord", _wrap_MeshFace_getTexCoord}, + { "setHasColors", _wrap_MeshFace_setHasColors}, + { "setHasNormals", _wrap_MeshFace_setHasNormals}, + { "setHasTexcoords", _wrap_MeshFace_setHasTexcoords}, + { "hasColors", _wrap_MeshFace_hasColors}, + { "hasNormals", _wrap_MeshFace_hasNormals}, + { "hasTexcoords", _wrap_MeshFace_hasTexcoords}, + {0,0} +}; +static swig_lua_method swig_MeshFace_meta[] = { + {0,0} +}; + +static swig_lua_attribute swig_MeshFace_Sf_SwigStatic_attributes[] = { {0,0,0} }; -static swig_lua_const_info swig_MeshData_Sf_SwigStatic_constants[]= { +static swig_lua_const_info swig_MeshFace_Sf_SwigStatic_constants[]= { {0,0,0,0,0,0} }; -static swig_lua_method swig_MeshData_Sf_SwigStatic_methods[]= { +static swig_lua_method swig_MeshFace_Sf_SwigStatic_methods[]= { {0,0} }; -static swig_lua_class* swig_MeshData_Sf_SwigStatic_classes[]= { +static swig_lua_class* swig_MeshFace_Sf_SwigStatic_classes[]= { 0 }; -static swig_lua_namespace swig_MeshData_Sf_SwigStatic = { - "MeshData", - swig_MeshData_Sf_SwigStatic_methods, - swig_MeshData_Sf_SwigStatic_attributes, - swig_MeshData_Sf_SwigStatic_constants, - swig_MeshData_Sf_SwigStatic_classes, +static swig_lua_namespace swig_MeshFace_Sf_SwigStatic = { + "MeshFace", + swig_MeshFace_Sf_SwigStatic_methods, + swig_MeshFace_Sf_SwigStatic_attributes, + swig_MeshFace_Sf_SwigStatic_constants, + swig_MeshFace_Sf_SwigStatic_classes, 0 }; -static swig_lua_class *swig_MeshData_bases[] = {0}; -static const char *swig_MeshData_base_names[] = {0}; -static swig_lua_class _wrap_class_MeshData = { "MeshData", "MeshData", &SWIGTYPE_p_ofMeshData,0, swig_delete_MeshData, swig_MeshData_methods, swig_MeshData_attributes, &swig_MeshData_Sf_SwigStatic, swig_MeshData_meta, swig_MeshData_bases, swig_MeshData_base_names }; +static swig_lua_class *swig_MeshFace_bases[] = {0}; +static const char *swig_MeshFace_base_names[] = {0}; +static swig_lua_class _wrap_class_MeshFace = { "MeshFace", "MeshFace", &SWIGTYPE_p_ofMeshFace_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,_proxy__wrap_new_MeshFace, swig_delete_MeshFace, swig_MeshFace_methods, swig_MeshFace_attributes, &swig_MeshFace_Sf_SwigStatic, swig_MeshFace_meta, swig_MeshFace_bases, swig_MeshFace_base_names }; static int _wrap_new_3dPrimitive__SWIG_0(lua_State* L) { int SWIG_arg = 0; of3dPrimitive *result = 0 ; SWIG_check_num_args("of3dPrimitive::of3dPrimitive",0,0) result = (of3dPrimitive *)new of3dPrimitive(); @@ -12862,9 +15877,9 @@ static int _wrap_new_3dPrimitive__SWIG_0(lua_State* L) { int SWIG_arg = 0; of3dP static int _wrap_new_3dPrimitive__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = 0 ; of3dPrimitive *result = 0 ; SWIG_check_num_args("of3dPrimitive::of3dPrimitive",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("of3dPrimitive::of3dPrimitive",1,"ofMesh const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_glm__vec3_glm__vec3_ofColor_T_float_t_glm__vec2_t,0))){ - SWIG_fail_ptr("new_3dPrimitive",1,SWIGTYPE_p_ofMesh_T_glm__vec3_glm__vec3_ofColor_T_float_t_glm__vec2_t); } - result = (of3dPrimitive *)new of3dPrimitive((ofMesh const &)*arg1); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("new_3dPrimitive",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + result = (of3dPrimitive *)new of3dPrimitive((ofMesh const &)*arg1); SWIG_NewPointerObj(L,result,SWIGTYPE_p_of3dPrimitive,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_new_3dPrimitive__SWIG_2(lua_State* L) { int SWIG_arg = 0; of3dPrimitive *arg1 = 0 ; of3dPrimitive *result = 0 ; @@ -12876,11 +15891,10 @@ static int _wrap_new_3dPrimitive__SWIG_2(lua_State* L) { int SWIG_arg = 0; of3dP SWIG_NewPointerObj(L,result,SWIGTYPE_p_of3dPrimitive,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_new_3dPrimitive(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_3dPrimitive__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh_T_glm__vec3_glm__vec3_ofColor_T_float_t_glm__vec2_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_new_3dPrimitive__SWIG_1(L);} } if (argc == 1) { int _v; { - void *ptr; if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_of3dPrimitive, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_new_3dPrimitive__SWIG_2(L);} } + return _wrap_new_3dPrimitive__SWIG_0(L);} if (argc == 1) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_new_3dPrimitive__SWIG_1(L);} check_2: + if (argc == 1) { return _wrap_new_3dPrimitive__SWIG_2(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_3dPrimitive'\n" " Possible C/C++ prototypes are:\n" " of3dPrimitive::of3dPrimitive()\n" " of3dPrimitive::of3dPrimitive(ofMesh const &)\n" " of3dPrimitive::of3dPrimitive(of3dPrimitive const &)\n"); lua_error(L);return 0; } @@ -12911,14 +15925,14 @@ static int _wrap_3dPrimitive_getMeshPtr__SWIG_0(lua_State* L) { int SWIG_arg = 0 if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("of3dPrimitive::getMeshPtr",1,"of3dPrimitive *"); if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_of3dPrimitive,0))){ SWIG_fail_ptr("3dPrimitive_getMeshPtr",1,SWIGTYPE_p_of3dPrimitive); } result = (ofMesh *)(arg1)->getMeshPtr(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMesh_T_glm__vec3_glm__vec3_ofColor_T_float_t_glm__vec2_t,0); SWIG_arg++; + SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_3dPrimitive_getMesh__SWIG_0(lua_State* L) { int SWIG_arg = 0; of3dPrimitive *arg1 = (of3dPrimitive *) 0 ; ofMesh *result = 0 ; SWIG_check_num_args("of3dPrimitive::getMesh",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("of3dPrimitive::getMesh",1,"of3dPrimitive *"); if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_of3dPrimitive,0))){ SWIG_fail_ptr("3dPrimitive_getMesh",1,SWIGTYPE_p_of3dPrimitive); } result = (ofMesh *) &(arg1)->getMesh(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMesh_T_glm__vec3_glm__vec3_ofColor_T_float_t_glm__vec2_t,0); SWIG_arg++; + SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_3dPrimitive_getMeshPtr__SWIG_1(lua_State* L) { int SWIG_arg = 0; of3dPrimitive *arg1 = (of3dPrimitive *) 0 ; ofMesh *result = 0 ; SWIG_check_num_args("of3dPrimitive::getMeshPtr",1,1) @@ -12926,14 +15940,10 @@ static int _wrap_3dPrimitive_getMeshPtr__SWIG_1(lua_State* L) { int SWIG_arg = 0 if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_of3dPrimitive,0))){ SWIG_fail_ptr("3dPrimitive_getMeshPtr",1,SWIGTYPE_p_of3dPrimitive); } result = (ofMesh *)((of3dPrimitive const *)arg1)->getMeshPtr(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMesh_T_glm__vec3_glm__vec3_ofColor_T_float_t_glm__vec2_t,0); SWIG_arg++; + SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_3dPrimitive_getMeshPtr(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_of3dPrimitive, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_3dPrimitive_getMeshPtr__SWIG_0(L);} } if (argc == 1) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_of3dPrimitive, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_3dPrimitive_getMeshPtr__SWIG_1(L);} } + return _wrap_3dPrimitive_getMeshPtr__SWIG_0(L);} if (argc == 1) { return _wrap_3dPrimitive_getMeshPtr__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function '3dPrimitive_getMeshPtr'\n" " Possible C/C++ prototypes are:\n" " of3dPrimitive::getMeshPtr()\n" " of3dPrimitive::getMeshPtr() const\n"); lua_error(L);return 0; } @@ -12943,14 +15953,10 @@ static int _wrap_3dPrimitive_getMesh__SWIG_1(lua_State* L) { int SWIG_arg = 0; o if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_of3dPrimitive,0))){ SWIG_fail_ptr("3dPrimitive_getMesh",1,SWIGTYPE_p_of3dPrimitive); } result = (ofMesh *) &((of3dPrimitive const *)arg1)->getMesh(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMesh_T_glm__vec3_glm__vec3_ofColor_T_float_t_glm__vec2_t,0); SWIG_arg++; + SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_3dPrimitive_getMesh(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_of3dPrimitive, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_3dPrimitive_getMesh__SWIG_0(L);} } if (argc == 1) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_of3dPrimitive, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_3dPrimitive_getMesh__SWIG_1(L);} } + return _wrap_3dPrimitive_getMesh__SWIG_0(L);} if (argc == 1) { return _wrap_3dPrimitive_getMesh__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function '3dPrimitive_getMesh'\n" " Possible C/C++ prototypes are:\n" " of3dPrimitive::getMesh()\n" " of3dPrimitive::getMesh() const\n"); lua_error(L);return 0; } @@ -12977,11 +15983,8 @@ static int _wrap_3dPrimitive_getTexCoordsPtr__SWIG_1(lua_State* L) { int SWIG_ar SWIG_NewPointerObj(L,result,SWIGTYPE_p_glm__vec4,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_3dPrimitive_getTexCoordsPtr(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); - if (argc == 1) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_of3dPrimitive, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_3dPrimitive_getTexCoordsPtr__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_of3dPrimitive, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_3dPrimitive_getTexCoordsPtr__SWIG_1(L);} } + if (argc == 1) { return _wrap_3dPrimitive_getTexCoordsPtr__SWIG_0(L);} if (argc == 1) { + return _wrap_3dPrimitive_getTexCoordsPtr__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function '3dPrimitive_getTexCoordsPtr'\n" " Possible C/C++ prototypes are:\n" " of3dPrimitive::getTexCoordsPtr()\n" " of3dPrimitive::getTexCoordsPtr() const\n"); lua_error(L);return 0; } @@ -12994,11 +15997,7 @@ static int _wrap_3dPrimitive_getTexCoords__SWIG_1(lua_State* L) { int SWIG_arg = SWIG_NewPointerObj(L,result,SWIGTYPE_p_glm__vec4,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_3dPrimitive_getTexCoords(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_of3dPrimitive, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_3dPrimitive_getTexCoords__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_of3dPrimitive, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_3dPrimitive_getTexCoords__SWIG_1(L);} } + return _wrap_3dPrimitive_getTexCoords__SWIG_0(L);} if (argc == 1) { return _wrap_3dPrimitive_getTexCoords__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function '3dPrimitive_getTexCoords'\n" " Possible C/C++ prototypes are:\n" " of3dPrimitive::getTexCoords()\n" " of3dPrimitive::getTexCoords() const\n"); lua_error(L);return 0; } @@ -13094,13 +16093,8 @@ static int _wrap_3dPrimitive_drawNormals__SWIG_1(lua_State* L) { int SWIG_arg = SWIG_fail_ptr("3dPrimitive_drawNormals",1,SWIGTYPE_p_of3dPrimitive); } arg2 = (float)lua_tonumber(L, 2); ((of3dPrimitive const *)arg1)->drawNormals(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_3dPrimitive_drawNormals(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_of3dPrimitive, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_3dPrimitive_drawNormals__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_of3dPrimitive, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - return _wrap_3dPrimitive_drawNormals__SWIG_0(L);} } } } + if (argc == 2) { return _wrap_3dPrimitive_drawNormals__SWIG_1(L);} if (argc == 3) { + return _wrap_3dPrimitive_drawNormals__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function '3dPrimitive_drawNormals'\n" " Possible C/C++ prototypes are:\n" " of3dPrimitive::drawNormals(float,bool) const\n" " of3dPrimitive::drawNormals(float) const\n"); lua_error(L);return 0; } @@ -13220,12 +16214,8 @@ static int _wrap_new_PlanePrimitive__SWIG_2(lua_State* L) { int SWIG_arg = 0; fl SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofPlanePrimitive,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_new_PlanePrimitive(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); - if (argc == 0) { return _wrap_new_PlanePrimitive__SWIG_0(L);} if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_new_PlanePrimitive__SWIG_2(L);} } } } } - if (argc == 5) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_new_PlanePrimitive__SWIG_1(L);} } } } } } + if (argc == 0) { return _wrap_new_PlanePrimitive__SWIG_0(L);} if (argc == 4) { return _wrap_new_PlanePrimitive__SWIG_2(L);} + if (argc == 5) { return _wrap_new_PlanePrimitive__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_PlanePrimitive'\n" " Possible C/C++ prototypes are:\n" " ofPlanePrimitive::ofPlanePrimitive()\n" " ofPlanePrimitive::ofPlanePrimitive(float,float,int,int,ofPrimitiveMode)\n" " ofPlanePrimitive::ofPlanePrimitive(float,float,int,int)\n"); lua_error(L);return 0; } @@ -13263,18 +16253,8 @@ static int _wrap_PlanePrimitive_set__SWIG_2(lua_State* L) { int SWIG_arg = 0; of arg3 = (float)lua_tonumber(L, 3); (arg1)->set(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_PlanePrimitive_set(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPlanePrimitive, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_PlanePrimitive_set__SWIG_2(L);} } } } if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPlanePrimitive, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_PlanePrimitive_set__SWIG_1(L);} } } } } } if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPlanePrimitive, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { return _wrap_PlanePrimitive_set__SWIG_0(L);} } } } } } } + if (argc == 3) { return _wrap_PlanePrimitive_set__SWIG_2(L);} if (argc == 5) { return _wrap_PlanePrimitive_set__SWIG_1(L);} + if (argc == 6) { return _wrap_PlanePrimitive_set__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'PlanePrimitive_set'\n" " Possible C/C++ prototypes are:\n" " ofPlanePrimitive::set(float,float,int,int,ofPrimitiveMode)\n" " ofPlanePrimitive::set(float,float,int,int)\n" " ofPlanePrimitive::set(float,float)\n"); lua_error(L);return 0; } @@ -13300,17 +16280,8 @@ static int _wrap_PlanePrimitive_resizeToTexture__SWIG_1(lua_State* L) { int SWIG SWIG_fail_ptr("PlanePrimitive_resizeToTexture",2,SWIGTYPE_p_ofTexture); } (arg1)->resizeToTexture(*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_PlanePrimitive_resizeToTexture(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPlanePrimitive, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_PlanePrimitive_resizeToTexture__SWIG_1(L);} } } if (argc == 3) { int _v; - { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPlanePrimitive, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_PlanePrimitive_resizeToTexture__SWIG_0(L);} } } } + if (argc == 2) { return _wrap_PlanePrimitive_resizeToTexture__SWIG_1(L);} if (argc == 3) { + return _wrap_PlanePrimitive_resizeToTexture__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'PlanePrimitive_resizeToTexture'\n" " Possible C/C++ prototypes are:\n" " ofPlanePrimitive::resizeToTexture(ofTexture &,float)\n" " ofPlanePrimitive::resizeToTexture(ofTexture &)\n"); lua_error(L);return 0; } @@ -13477,10 +16448,8 @@ static int _wrap_new_SpherePrimitive__SWIG_2(lua_State* L) { int SWIG_arg = 0; f SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofSpherePrimitive,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_new_SpherePrimitive(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_SpherePrimitive__SWIG_0(L);} if (argc == 2) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_new_SpherePrimitive__SWIG_2(L);} } } if (argc == 3) { int _v; - { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_new_SpherePrimitive__SWIG_1(L);} } } } + return _wrap_new_SpherePrimitive__SWIG_0(L);} if (argc == 2) { return _wrap_new_SpherePrimitive__SWIG_2(L);} + if (argc == 3) { return _wrap_new_SpherePrimitive__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SpherePrimitive'\n" " Possible C/C++ prototypes are:\n" " ofSpherePrimitive::ofSpherePrimitive()\n" " ofSpherePrimitive::ofSpherePrimitive(float,int,ofPrimitiveMode)\n" @@ -13506,13 +16475,7 @@ static int _wrap_SpherePrimitive_set__SWIG_1(lua_State* L) { int SWIG_arg = 0; arg3 = (int)lua_tonumber(L, 3); (arg1)->set(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_SpherePrimitive_set(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofSpherePrimitive, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_SpherePrimitive_set__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofSpherePrimitive, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_SpherePrimitive_set__SWIG_0(L);} } } } } + return _wrap_SpherePrimitive_set__SWIG_1(L);} if (argc == 4) { return _wrap_SpherePrimitive_set__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SpherePrimitive_set'\n" " Possible C/C++ prototypes are:\n" " ofSpherePrimitive::set(float,int,ofPrimitiveMode)\n" " ofSpherePrimitive::set(float,int)\n"); lua_error(L);return 0; } @@ -13617,8 +16580,7 @@ static int _wrap_new_IcoSpherePrimitive__SWIG_1(lua_State* L) { int SWIG_arg = 0 SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofIcoSpherePrimitive,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_new_IcoSpherePrimitive(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_IcoSpherePrimitive__SWIG_0(L);} if (argc == 2) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_new_IcoSpherePrimitive__SWIG_1(L);} } } + return _wrap_new_IcoSpherePrimitive__SWIG_0(L);} if (argc == 2) { return _wrap_new_IcoSpherePrimitive__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_IcoSpherePrimitive'\n" " Possible C/C++ prototypes are:\n" " ofIcoSpherePrimitive::ofIcoSpherePrimitive()\n" " ofIcoSpherePrimitive::ofIcoSpherePrimitive(float,int)\n"); lua_error(L);return 0; } @@ -13781,20 +16743,10 @@ static int _wrap_new_CylinderPrimitive__SWIG_4(lua_State* L) { int SWIG_arg = 0; SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofCylinderPrimitive,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_new_CylinderPrimitive(lua_State* L) { int argc; int argv[8]={ 1,2,3,4,5,6,7,8} ; argc = lua_gettop(L); - if (argc == 0) { return _wrap_new_CylinderPrimitive__SWIG_0(L);} if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_new_CylinderPrimitive__SWIG_4(L);} } } } } - if (argc == 5) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_new_CylinderPrimitive__SWIG_3(L);} } } } } } - if (argc == 6) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isboolean(L,argv[5]); } if (_v) { - return _wrap_new_CylinderPrimitive__SWIG_2(L);} } } } } } } if (argc == 7) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isboolean(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { - return _wrap_new_CylinderPrimitive__SWIG_1(L);} } } } } } } } + if (argc == 0) { return _wrap_new_CylinderPrimitive__SWIG_0(L);} if (argc == 4) { + return _wrap_new_CylinderPrimitive__SWIG_4(L);} if (argc == 5) { return _wrap_new_CylinderPrimitive__SWIG_3(L);} + if (argc == 6) { return _wrap_new_CylinderPrimitive__SWIG_2(L);} if (argc == 7) { + return _wrap_new_CylinderPrimitive__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_CylinderPrimitive'\n" " Possible C/C++ prototypes are:\n" " ofCylinderPrimitive::ofCylinderPrimitive()\n" " ofCylinderPrimitive::ofCylinderPrimitive(float,float,int,int,int,bool,ofPrimitiveMode)\n" @@ -13880,34 +16832,11 @@ static int _wrap_CylinderPrimitive_set__SWIG_5(lua_State* L) { int SWIG_arg = 0; arg3 = (float)lua_tonumber(L, 3); (arg1)->set(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_CylinderPrimitive_set(lua_State* L) { int argc; int argv[9]={ 1,2,3,4,5,6,7,8,9} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCylinderPrimitive, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_CylinderPrimitive_set__SWIG_5(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCylinderPrimitive, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isboolean(L,argv[3]); } if (_v) { return _wrap_CylinderPrimitive_set__SWIG_4(L);} } } } } - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCylinderPrimitive, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_CylinderPrimitive_set__SWIG_3(L);} } } } } } if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCylinderPrimitive, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { return _wrap_CylinderPrimitive_set__SWIG_2(L);} } } } } } } - if (argc == 7) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCylinderPrimitive, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isboolean(L,argv[6]); } if (_v) { - return _wrap_CylinderPrimitive_set__SWIG_1(L);} } } } } } } } if (argc == 8) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCylinderPrimitive, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isboolean(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { return _wrap_CylinderPrimitive_set__SWIG_0(L);} } } } } } } - } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'CylinderPrimitive_set'\n" + if (argc == 3) { return _wrap_CylinderPrimitive_set__SWIG_5(L);} if (argc == 4) { + return _wrap_CylinderPrimitive_set__SWIG_4(L);} if (argc == 5) { return _wrap_CylinderPrimitive_set__SWIG_3(L);} + if (argc == 6) { return _wrap_CylinderPrimitive_set__SWIG_2(L);} if (argc == 7) { + return _wrap_CylinderPrimitive_set__SWIG_1(L);} if (argc == 8) { return _wrap_CylinderPrimitive_set__SWIG_0(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'CylinderPrimitive_set'\n" " Possible C/C++ prototypes are:\n" " ofCylinderPrimitive::set(float,float,int,int,int,bool,ofPrimitiveMode)\n" " ofCylinderPrimitive::set(float,float,int,int,int,bool)\n" " ofCylinderPrimitive::set(float,float,int,int,int)\n" " ofCylinderPrimitive::set(float,float,int,int)\n" " ofCylinderPrimitive::set(float,float,bool)\n" @@ -13979,14 +16908,9 @@ static int _wrap_CylinderPrimitive_setResolution__SWIG_1(lua_State* L) { int SWI arg3 = (int)lua_tonumber(L, 3); (arg1)->setResolution(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_CylinderPrimitive_setResolution(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCylinderPrimitive, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_CylinderPrimitive_setResolution__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCylinderPrimitive, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_CylinderPrimitive_setResolution__SWIG_0(L);} } } - } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'CylinderPrimitive_setResolution'\n" + if (argc == 3) { return _wrap_CylinderPrimitive_setResolution__SWIG_1(L);} if (argc == 4) { + return _wrap_CylinderPrimitive_setResolution__SWIG_0(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'CylinderPrimitive_setResolution'\n" " Possible C/C++ prototypes are:\n" " ofCylinderPrimitive::setResolution(int,int,int)\n" " ofCylinderPrimitive::setResolution(int,int)\n"); lua_error(L);return 0; } static int _wrap_CylinderPrimitive_setMode(lua_State* L) { int SWIG_arg = 0; @@ -14039,14 +16963,13 @@ static int _wrap_CylinderPrimitive_getTopCapIndices(lua_State* L) { int SWIG_arg SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_unsigned_int_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_CylinderPrimitive_getTopCapMesh(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; - SwigValueWrapper< ofMesh_< glm::vec3,glm::vec3,ofColor_< float >,glm::vec2 > > result; + ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; ofMesh result; SWIG_check_num_args("ofCylinderPrimitive::getTopCapMesh",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::getTopCapMesh",1,"ofCylinderPrimitive const *"); if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ SWIG_fail_ptr("CylinderPrimitive_getTopCapMesh",1,SWIGTYPE_p_ofCylinderPrimitive); } result = ((ofCylinderPrimitive const *)arg1)->getTopCapMesh(); { ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh_T_glm__vec3_glm__vec3_ofColor_T_float_t_glm__vec2_t,1); SWIG_arg++; } + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_CylinderPrimitive_getCylinderIndices(lua_State* L) { int SWIG_arg = 0; ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; SwigValueWrapper< std::vector< unsigned int > > result; @@ -14059,14 +16982,13 @@ static int _wrap_CylinderPrimitive_getCylinderIndices(lua_State* L) { int SWIG_a SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_unsigned_int_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_CylinderPrimitive_getCylinderMesh(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; - SwigValueWrapper< ofMesh_< glm::vec3,glm::vec3,ofColor_< float >,glm::vec2 > > result; + ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; ofMesh result; SWIG_check_num_args("ofCylinderPrimitive::getCylinderMesh",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::getCylinderMesh",1,"ofCylinderPrimitive const *"); if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ SWIG_fail_ptr("CylinderPrimitive_getCylinderMesh",1,SWIGTYPE_p_ofCylinderPrimitive); } result = ((ofCylinderPrimitive const *)arg1)->getCylinderMesh(); { ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh_T_glm__vec3_glm__vec3_ofColor_T_float_t_glm__vec2_t,1); SWIG_arg++; } + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_CylinderPrimitive_getBottomCapIndices(lua_State* L) { int SWIG_arg = 0; ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; SwigValueWrapper< std::vector< unsigned int > > result; @@ -14079,14 +17001,13 @@ static int _wrap_CylinderPrimitive_getBottomCapIndices(lua_State* L) { int SWIG_ SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_unsigned_int_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_CylinderPrimitive_getBottomCapMesh(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; - SwigValueWrapper< ofMesh_< glm::vec3,glm::vec3,ofColor_< float >,glm::vec2 > > result; + ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; ofMesh result; SWIG_check_num_args("ofCylinderPrimitive::getBottomCapMesh",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::getBottomCapMesh",1,"ofCylinderPrimitive const *"); if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ SWIG_fail_ptr("CylinderPrimitive_getBottomCapMesh",1,SWIGTYPE_p_ofCylinderPrimitive); } result = ((ofCylinderPrimitive const *)arg1)->getBottomCapMesh(); { ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh_T_glm__vec3_glm__vec3_ofColor_T_float_t_glm__vec2_t,1); SWIG_arg++; } + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_CylinderPrimitive_getResolutionRadius(lua_State* L) { int SWIG_arg = 0; ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; int result; @@ -14256,16 +17177,8 @@ static int _wrap_new_ConePrimitive__SWIG_3(lua_State* L) { int SWIG_arg = 0; flo SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofConePrimitive,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_new_ConePrimitive(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); - if (argc == 0) { return _wrap_new_ConePrimitive__SWIG_0(L);} if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_new_ConePrimitive__SWIG_3(L);} } } } } if (argc == 5) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_new_ConePrimitive__SWIG_2(L);} } } } } } - if (argc == 6) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { - return _wrap_new_ConePrimitive__SWIG_1(L);} } } } } } } + if (argc == 0) { return _wrap_new_ConePrimitive__SWIG_0(L);} if (argc == 4) { return _wrap_new_ConePrimitive__SWIG_3(L);} + if (argc == 5) { return _wrap_new_ConePrimitive__SWIG_2(L);} if (argc == 6) { return _wrap_new_ConePrimitive__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_ConePrimitive'\n" " Possible C/C++ prototypes are:\n" " ofConePrimitive::ofConePrimitive()\n" " ofConePrimitive::ofConePrimitive(float,float,int,int,int,ofPrimitiveMode)\n" " ofConePrimitive::ofConePrimitive(float,float,int,int,int)\n" @@ -14319,24 +17232,8 @@ static int _wrap_ConePrimitive_set__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofC arg3 = (float)lua_tonumber(L, 3); (arg1)->set(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_ConePrimitive_set(lua_State* L) { int argc; int argv[8]={ 1,2,3,4,5,6,7,8} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofConePrimitive, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_ConePrimitive_set__SWIG_3(L);} } } } if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofConePrimitive, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_ConePrimitive_set__SWIG_2(L);} } } } } } if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofConePrimitive, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { return _wrap_ConePrimitive_set__SWIG_1(L);} } } } } } } - if (argc == 7) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofConePrimitive, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { - return _wrap_ConePrimitive_set__SWIG_0(L);} } } } } } } } + if (argc == 3) { return _wrap_ConePrimitive_set__SWIG_3(L);} if (argc == 5) { return _wrap_ConePrimitive_set__SWIG_2(L);} + if (argc == 6) { return _wrap_ConePrimitive_set__SWIG_1(L);} if (argc == 7) { return _wrap_ConePrimitive_set__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ConePrimitive_set'\n" " Possible C/C++ prototypes are:\n" " ofConePrimitive::set(float,float,int,int,int,ofPrimitiveMode)\n" " ofConePrimitive::set(float,float,int,int,int)\n" " ofConePrimitive::set(float,float,int,int)\n" " ofConePrimitive::set(float,float)\n"); lua_error(L);return 0; } @@ -14420,13 +17317,12 @@ static int _wrap_ConePrimitive_getConeIndices(lua_State* L) { int SWIG_arg = 0; SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_unsigned_int_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_ConePrimitive_getConeMesh(lua_State* L) { int SWIG_arg = 0; ofConePrimitive *arg1 = (ofConePrimitive *) 0 ; - SwigValueWrapper< ofMesh_< glm::vec3,glm::vec3,ofColor_< float >,glm::vec2 > > result; - SWIG_check_num_args("ofConePrimitive::getConeMesh",1,1) + ofMesh result; SWIG_check_num_args("ofConePrimitive::getConeMesh",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofConePrimitive::getConeMesh",1,"ofConePrimitive const *"); if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofConePrimitive,0))){ SWIG_fail_ptr("ConePrimitive_getConeMesh",1,SWIGTYPE_p_ofConePrimitive); } result = ((ofConePrimitive const *)arg1)->getConeMesh(); { ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh_T_glm__vec3_glm__vec3_ofColor_T_float_t_glm__vec2_t,1); SWIG_arg++; } + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_ConePrimitive_getCapIndices(lua_State* L) { int SWIG_arg = 0; ofConePrimitive *arg1 = (ofConePrimitive *) 0 ; SwigValueWrapper< std::vector< unsigned int > > result; SWIG_check_num_args("ofConePrimitive::getCapIndices",1,1) @@ -14438,13 +17334,12 @@ static int _wrap_ConePrimitive_getCapIndices(lua_State* L) { int SWIG_arg = 0; o SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_unsigned_int_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_ConePrimitive_getCapMesh(lua_State* L) { int SWIG_arg = 0; ofConePrimitive *arg1 = (ofConePrimitive *) 0 ; - SwigValueWrapper< ofMesh_< glm::vec3,glm::vec3,ofColor_< float >,glm::vec2 > > result; - SWIG_check_num_args("ofConePrimitive::getCapMesh",1,1) + ofMesh result; SWIG_check_num_args("ofConePrimitive::getCapMesh",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofConePrimitive::getCapMesh",1,"ofConePrimitive const *"); if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofConePrimitive,0))){ SWIG_fail_ptr("ConePrimitive_getCapMesh",1,SWIGTYPE_p_ofConePrimitive); } result = ((ofConePrimitive const *)arg1)->getCapMesh(); { ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh_T_glm__vec3_glm__vec3_ofColor_T_float_t_glm__vec2_t,1); SWIG_arg++; } + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_ConePrimitive_getResolutionRadius(lua_State* L) { int SWIG_arg = 0; ofConePrimitive *arg1 = (ofConePrimitive *) 0 ; int result; SWIG_check_num_args("ofConePrimitive::getResolutionRadius",1,1) @@ -14605,18 +17500,9 @@ static int _wrap_new_BoxPrimitive__SWIG_4(lua_State* L) { int SWIG_arg = 0; floa SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofBoxPrimitive,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_new_BoxPrimitive(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); - if (argc == 0) { return _wrap_new_BoxPrimitive__SWIG_0(L);} if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_new_BoxPrimitive__SWIG_4(L);} } } } if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_new_BoxPrimitive__SWIG_3(L);} } } } } if (argc == 5) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_new_BoxPrimitive__SWIG_2(L);} } } } } } - if (argc == 6) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { - return _wrap_new_BoxPrimitive__SWIG_1(L);} } } } } } } + if (argc == 0) { return _wrap_new_BoxPrimitive__SWIG_0(L);} if (argc == 3) { return _wrap_new_BoxPrimitive__SWIG_4(L);} + if (argc == 4) { return _wrap_new_BoxPrimitive__SWIG_3(L);} if (argc == 5) { return _wrap_new_BoxPrimitive__SWIG_2(L);} + if (argc == 6) { return _wrap_new_BoxPrimitive__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_BoxPrimitive'\n" " Possible C/C++ prototypes are:\n" " ofBoxPrimitive::ofBoxPrimitive()\n" " ofBoxPrimitive::ofBoxPrimitive(float,float,float,int,int,int)\n" " ofBoxPrimitive::ofBoxPrimitive(float,float,float,int,int)\n" @@ -14654,19 +17540,8 @@ static int _wrap_BoxPrimitive_set__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofBo SWIG_fail_ptr("BoxPrimitive_set",1,SWIGTYPE_p_ofBoxPrimitive); } arg2 = (float)lua_tonumber(L, 2); (arg1)->set(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_BoxPrimitive_set(lua_State* L) { int argc; int argv[8]={ 1,2,3,4,5,6,7,8} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofBoxPrimitive, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_BoxPrimitive_set__SWIG_2(L);} } - } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofBoxPrimitive, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_BoxPrimitive_set__SWIG_1(L);} } } } } if (argc == 7) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofBoxPrimitive, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { - return _wrap_BoxPrimitive_set__SWIG_0(L);} } } } } } } } + if (argc == 2) { return _wrap_BoxPrimitive_set__SWIG_2(L);} if (argc == 4) { return _wrap_BoxPrimitive_set__SWIG_1(L);} + if (argc == 7) { return _wrap_BoxPrimitive_set__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'BoxPrimitive_set'\n" " Possible C/C++ prototypes are:\n" " ofBoxPrimitive::set(float,float,float,int,int,int)\n" " ofBoxPrimitive::set(float,float,float)\n" " ofBoxPrimitive::set(float)\n"); lua_error(L);return 0; } @@ -14711,14 +17586,13 @@ static int _wrap_BoxPrimitive_getSideIndices(lua_State* L) { int SWIG_arg = 0; o SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_unsigned_int_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_BoxPrimitive_getSideMesh(lua_State* L) { int SWIG_arg = 0; ofBoxPrimitive *arg1 = (ofBoxPrimitive *) 0 ; - int arg2 ; SwigValueWrapper< ofMesh_< glm::vec3,glm::vec3,ofColor_< float >,glm::vec2 > > result; - SWIG_check_num_args("ofBoxPrimitive::getSideMesh",2,2) + int arg2 ; ofMesh result; SWIG_check_num_args("ofBoxPrimitive::getSideMesh",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBoxPrimitive::getSideMesh",1,"ofBoxPrimitive const *"); if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBoxPrimitive::getSideMesh",2,"int"); if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBoxPrimitive,0))){ SWIG_fail_ptr("BoxPrimitive_getSideMesh",1,SWIGTYPE_p_ofBoxPrimitive); } arg2 = (int)lua_tonumber(L, 2); result = ((ofBoxPrimitive const *)arg1)->getSideMesh(arg2); { ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh_T_glm__vec3_glm__vec3_ofColor_T_float_t_glm__vec2_t,1); SWIG_arg++; } + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_BoxPrimitive_setResolution__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofBoxPrimitive *arg1 = (ofBoxPrimitive *) 0 ; int arg2 ; SWIG_check_num_args("ofBoxPrimitive::setResolution",2,2) @@ -14760,13 +17634,8 @@ static int _wrap_BoxPrimitive_setResolution__SWIG_1(lua_State* L) { int SWIG_arg arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); (arg1)->setResolution(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_BoxPrimitive_setResolution(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofBoxPrimitive, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_BoxPrimitive_setResolution__SWIG_0(L);} } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofBoxPrimitive, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_BoxPrimitive_setResolution__SWIG_1(L);} } } } } + if (argc == 2) { return _wrap_BoxPrimitive_setResolution__SWIG_0(L);} if (argc == 4) { + return _wrap_BoxPrimitive_setResolution__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'BoxPrimitive_setResolution'\n" " Possible C/C++ prototypes are:\n" " ofBoxPrimitive::setResolution(int)\n" " ofBoxPrimitive::setResolution(int,int,int)\n"); lua_error(L);return 0; } @@ -14920,27 +17789,21 @@ static swig_lua_class *swig_BoxPrimitive_bases[] = {0,0}; static const char *swig_BoxPrimitive_base_names[] = {"of3dPrimitive *",0}; static swig_lua_class _wrap_class_BoxPrimitive = { "BoxPrimitive", "BoxPrimitive", &SWIGTYPE_p_ofBoxPrimitive,_proxy__wrap_new_BoxPrimitive, swig_delete_BoxPrimitive, swig_BoxPrimitive_methods, swig_BoxPrimitive_attributes, &swig_BoxPrimitive_Sf_SwigStatic, swig_BoxPrimitive_meta, swig_BoxPrimitive_bases, swig_BoxPrimitive_base_names }; -static int _wrap_getAppPtr(lua_State* L) { int SWIG_arg = 0; ofBaseApp *result = 0 ; SWIG_check_num_args("ofGetAppPtr",0,0) - result = (ofBaseApp *)ofGetAppPtr(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofBaseApp,0); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_exit__SWIG_0(lua_State* L) { int SWIG_arg = 0; int arg1 ; SWIG_check_num_args("ofExit",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofExit",1,"int"); arg1 = (int)lua_tonumber(L, 1); ofExit(arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_exit__SWIG_1(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofExit",0,0) ofExit(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_exit(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_exit__SWIG_1(L);} if (argc == 1) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { - return _wrap_exit__SWIG_0(L);} } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'exit'\n" - " Possible C/C++ prototypes are:\n" " ofExit(int)\n" " ofExit()\n"); lua_error(L);return 0; } + return _wrap_exit__SWIG_1(L);} if (argc == 1) { return _wrap_exit__SWIG_0(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'exit'\n" " Possible C/C++ prototypes are:\n" + " ofExit(int)\n" " ofExit()\n"); lua_error(L);return 0; } static int _wrap_getFrameRate(lua_State* L) { int SWIG_arg = 0; float result; SWIG_check_num_args("ofGetFrameRate",0,0) result = (float)ofGetFrameRate(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_getTargetFrameRate(lua_State* L) { int SWIG_arg = 0; float result; SWIG_check_num_args("ofGetTargetFrameRate",0,0) result = (float)ofGetTargetFrameRate(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getFrameNum(lua_State* L) { int SWIG_arg = 0; uint64_t result; SWIG_check_num_args("ofGetFrameNum",0,0) - result = (uint64_t)ofGetFrameNum(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } static int _wrap_setFrameRate(lua_State* L) { int SWIG_arg = 0; int arg1 ; SWIG_check_num_args("ofSetFrameRate",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetFrameRate",1,"int"); arg1 = (int)lua_tonumber(L, 1); ofSetFrameRate(arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } @@ -14961,8 +17824,7 @@ static int _wrap_setTimeModeFixedRate__SWIG_1(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofSetTimeModeFixedRate",0,0) ofSetTimeModeFixedRate(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_setTimeModeFixedRate(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_setTimeModeFixedRate__SWIG_1(L);} if (argc == 1) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { - return _wrap_setTimeModeFixedRate__SWIG_0(L);} } + return _wrap_setTimeModeFixedRate__SWIG_1(L);} if (argc == 1) { return _wrap_setTimeModeFixedRate__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'setTimeModeFixedRate'\n" " Possible C/C++ prototypes are:\n" " ofSetTimeModeFixedRate(uint64_t)\n" " ofSetTimeModeFixedRate()\n"); lua_error(L);return 0; } @@ -14973,8 +17835,7 @@ static int _wrap_setTimeModeFiltered__SWIG_0(lua_State* L) { int SWIG_arg = 0; f static int _wrap_setTimeModeFiltered__SWIG_1(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofSetTimeModeFiltered",0,0) ofSetTimeModeFiltered(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_setTimeModeFiltered(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_setTimeModeFiltered__SWIG_1(L);} if (argc == 1) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { - return _wrap_setTimeModeFiltered__SWIG_0(L);} } + return _wrap_setTimeModeFiltered__SWIG_1(L);} if (argc == 1) { return _wrap_setTimeModeFiltered__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'setTimeModeFiltered'\n" " Possible C/C++ prototypes are:\n" " ofSetTimeModeFiltered(float)\n" " ofSetTimeModeFiltered()\n"); lua_error(L);return 0; } @@ -14987,10 +17848,8 @@ static int _wrap_setOrientation__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofOrie SWIG_check_num_args("ofSetOrientation",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetOrientation",1,"ofOrientation"); arg1 = (ofOrientation)(int)lua_tonumber(L, 1); ofSetOrientation(arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setOrientation(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; - { _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_setOrientation__SWIG_1(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_setOrientation__SWIG_0(L);} } } +static int _wrap_setOrientation(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { + return _wrap_setOrientation__SWIG_1(L);} if (argc == 2) { return _wrap_setOrientation__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'setOrientation'\n" " Possible C/C++ prototypes are:\n" " ofSetOrientation(ofOrientation,bool)\n" " ofSetOrientation(ofOrientation)\n"); lua_error(L);return 0; } static int _wrap_getOrientation(lua_State* L) { int SWIG_arg = 0; ofOrientation result; @@ -15054,12 +17913,6 @@ static int _wrap_getWindowRect(lua_State* L) { int SWIG_arg = 0; ofRectangle res result = ofGetWindowRect(); { ofRectangle * resultptr = new ofRectangle((const ofRectangle &) result); SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofRectangle,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getCurrentWindow(lua_State* L) { int SWIG_arg = 0; - SwigValueWrapper< std::shared_ptr< ofAppBaseWindow > > result; SWIG_check_num_args("ofGetCurrentWindow",0,0) - result = ofGetCurrentWindow(); { - std::shared_ptr< ofAppBaseWindow > * resultptr = new std::shared_ptr< ofAppBaseWindow >((const std::shared_ptr< ofAppBaseWindow > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__shared_ptrT_ofAppBaseWindow_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_setWindowPosition(lua_State* L) { int SWIG_arg = 0; int arg1 ; int arg2 ; SWIG_check_num_args("ofSetWindowPosition",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetWindowPosition",1,"int"); if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSetWindowPosition",2,"int"); arg1 = (int)lua_tonumber(L, 1); @@ -15691,13 +18544,7 @@ static int _wrap_Arduino_connect__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofArd result = (bool)(arg1)->connect((std::string const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Arduino_connect(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofArduino, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { return _wrap_Arduino_connect__SWIG_1(L);} } - } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofArduino, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Arduino_connect__SWIG_0(L);} } } } + return _wrap_Arduino_connect__SWIG_1(L);} if (argc == 3) { return _wrap_Arduino_connect__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Arduino_connect'\n" " Possible C/C++ prototypes are:\n" " ofArduino::connect(std::string const &,int)\n" " ofArduino::connect(std::string const &)\n"); lua_error(L);return 0; } static int _wrap_Arduino_isInitialized(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; bool result; @@ -15796,13 +18643,7 @@ static int _wrap_Arduino_sendDigital__SWIG_1(lua_State* L) { int SWIG_arg = 0; o arg3 = (int)lua_tonumber(L, 3); (arg1)->sendDigital(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Arduino_sendDigital(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofArduino, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Arduino_sendDigital__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofArduino, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isboolean(L,argv[3]); } if (_v) { return _wrap_Arduino_sendDigital__SWIG_0(L);} } } } } + return _wrap_Arduino_sendDigital__SWIG_1(L);} if (argc == 4) { return _wrap_Arduino_sendDigital__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Arduino_sendDigital'\n" " Possible C/C++ prototypes are:\n" " ofArduino::sendDigital(int,int,bool)\n" " ofArduino::sendDigital(int,int)\n"); lua_error(L);return 0; } @@ -15825,13 +18666,7 @@ static int _wrap_Arduino_sendPwm__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofArd SWIG_fail_ptr("Arduino_sendPwm",1,SWIGTYPE_p_ofArduino); } arg2 = (int)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); (arg1)->sendPwm(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Arduino_sendPwm(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofArduino, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Arduino_sendPwm__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofArduino, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isboolean(L,argv[3]); } if (_v) { return _wrap_Arduino_sendPwm__SWIG_0(L);} } } } } + return _wrap_Arduino_sendPwm__SWIG_1(L);} if (argc == 4) { return _wrap_Arduino_sendPwm__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Arduino_sendPwm'\n" " Possible C/C++ prototypes are:\n" " ofArduino::sendPwm(int,int,bool)\n" " ofArduino::sendPwm(int,int)\n"); lua_error(L);return 0; } static int _wrap_Arduino_sendSysEx(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; int arg2 ; @@ -16241,13 +19076,7 @@ static int _wrap_Arduino_sendServo__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofA arg3 = (int)lua_tonumber(L, 3); (arg1)->sendServo(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Arduino_sendServo(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofArduino, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Arduino_sendServo__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofArduino, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isboolean(L,argv[3]); } if (_v) { return _wrap_Arduino_sendServo__SWIG_0(L);} } } } } + return _wrap_Arduino_sendServo__SWIG_1(L);} if (argc == 4) { return _wrap_Arduino_sendServo__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Arduino_sendServo'\n" " Possible C/C++ prototypes are:\n" " ofArduino::sendServo(int,int,bool)\n" " ofArduino::sendServo(int,int)\n"); lua_error(L);return 0; } static int _wrap_Arduino_sendServoAttach__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; @@ -16277,16 +19106,8 @@ static int _wrap_Arduino_sendServoAttach__SWIG_2(lua_State* L) { int SWIG_arg = SWIG_fail_ptr("Arduino_sendServoAttach",1,SWIGTYPE_p_ofArduino); } arg2 = (int)lua_tonumber(L, 2); (arg1)->sendServoAttach(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Arduino_sendServoAttach(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofArduino, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Arduino_sendServoAttach__SWIG_2(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofArduino, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Arduino_sendServoAttach__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofArduino, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Arduino_sendServoAttach__SWIG_0(L);} } } } } + if (argc == 2) { return _wrap_Arduino_sendServoAttach__SWIG_2(L);} if (argc == 3) { + return _wrap_Arduino_sendServoAttach__SWIG_1(L);} if (argc == 4) { return _wrap_Arduino_sendServoAttach__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Arduino_sendServoAttach'\n" " Possible C/C++ prototypes are:\n" " ofArduino::sendServoAttach(int,int,int)\n" " ofArduino::sendServoAttach(int,int)\n" " ofArduino::sendServoAttach(int)\n"); lua_error(L);return 0; } @@ -16318,13 +19139,8 @@ static int _wrap_Arduino_sendStepper2Wire__SWIG_1(lua_State* L) { int SWIG_arg = arg3 = (int)lua_tonumber(L, 3); (arg1)->sendStepper2Wire(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Arduino_sendStepper2Wire(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofArduino, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Arduino_sendStepper2Wire__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofArduino, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Arduino_sendStepper2Wire__SWIG_0(L);} } } } } + if (argc == 3) { return _wrap_Arduino_sendStepper2Wire__SWIG_1(L);} if (argc == 4) { + return _wrap_Arduino_sendStepper2Wire__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Arduino_sendStepper2Wire'\n" " Possible C/C++ prototypes are:\n" " ofArduino::sendStepper2Wire(int,int,int)\n" " ofArduino::sendStepper2Wire(int,int)\n"); lua_error(L);return 0; } @@ -16353,15 +19169,8 @@ static int _wrap_Arduino_sendStepper4Wire__SWIG_1(lua_State* L) { int SWIG_arg = arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); (arg1)->sendStepper4Wire(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Arduino_sendStepper4Wire(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofArduino, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Arduino_sendStepper4Wire__SWIG_1(L);} } } } } } if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofArduino, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { return _wrap_Arduino_sendStepper4Wire__SWIG_0(L);} } } } } } } + if (argc == 5) { return _wrap_Arduino_sendStepper4Wire__SWIG_1(L);} if (argc == 6) { + return _wrap_Arduino_sendStepper4Wire__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Arduino_sendStepper4Wire'\n" " Possible C/C++ prototypes are:\n" " ofArduino::sendStepper4Wire(int,int,int,int,int)\n" " ofArduino::sendStepper4Wire(int,int,int,int)\n"); lua_error(L);return 0; } @@ -16414,25 +19223,9 @@ static int _wrap_Arduino_sendStepperMove__SWIG_3(lua_State* L) { int SWIG_arg = arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); (arg1)->sendStepperMove(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Arduino_sendStepperMove(lua_State* L) { int argc; int argv[8]={ 1,2,3,4,5,6,7,8} ; argc = lua_gettop(L); - if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofArduino, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Arduino_sendStepperMove__SWIG_3(L);} } } } } - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofArduino, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Arduino_sendStepperMove__SWIG_2(L);} } } } } } if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofArduino, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { return _wrap_Arduino_sendStepperMove__SWIG_1(L);} } } } } } } - if (argc == 7) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofArduino, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { - return _wrap_Arduino_sendStepperMove__SWIG_0(L);} } } } } } } } + if (argc == 4) { return _wrap_Arduino_sendStepperMove__SWIG_3(L);} if (argc == 5) { + return _wrap_Arduino_sendStepperMove__SWIG_2(L);} if (argc == 6) { return _wrap_Arduino_sendStepperMove__SWIG_1(L);} + if (argc == 7) { return _wrap_Arduino_sendStepperMove__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Arduino_sendStepperMove'\n" " Possible C/C++ prototypes are:\n" " ofArduino::sendStepperMove(int,int,int,int,float,float)\n" " ofArduino::sendStepperMove(int,int,int,int,float)\n" " ofArduino::sendStepperMove(int,int,int,int)\n" @@ -16451,31 +19244,6 @@ static int _wrap_Arduino_isI2CConfigured(lua_State* L) { int SWIG_arg = 0; ofArd SWIG_fail_ptr("Arduino_isI2CConfigured",1,SWIGTYPE_p_ofArduino); } result = (bool)(arg1)->isI2CConfigured(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Arduino_sendI2CWriteRequest__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; - char arg2 ; unsigned char *arg3 = (unsigned char *) 0 ; int arg4 ; int arg5 ; - SWIG_check_num_args("ofArduino::sendI2CWriteRequest",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::sendI2CWriteRequest",1,"ofArduino *"); - if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("ofArduino::sendI2CWriteRequest",2,"char"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofArduino::sendI2CWriteRequest",3,"unsigned char *"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofArduino::sendI2CWriteRequest",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofArduino::sendI2CWriteRequest",5,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_sendI2CWriteRequest",1,SWIGTYPE_p_ofArduino); } arg2 = (lua_tostring(L, 2))[0]; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_unsigned_char,0))){ - SWIG_fail_ptr("Arduino_sendI2CWriteRequest",3,SWIGTYPE_p_unsigned_char); } arg4 = (int)lua_tonumber(L, 4); - arg5 = (int)lua_tonumber(L, 5); (arg1)->sendI2CWriteRequest(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_sendI2CWriteRequest__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; - char arg2 ; unsigned char *arg3 = (unsigned char *) 0 ; int arg4 ; SWIG_check_num_args("ofArduino::sendI2CWriteRequest",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::sendI2CWriteRequest",1,"ofArduino *"); - if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("ofArduino::sendI2CWriteRequest",2,"char"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofArduino::sendI2CWriteRequest",3,"unsigned char *"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofArduino::sendI2CWriteRequest",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_sendI2CWriteRequest",1,SWIGTYPE_p_ofArduino); } arg2 = (lua_tostring(L, 2))[0]; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_unsigned_char,0))){ - SWIG_fail_ptr("Arduino_sendI2CWriteRequest",3,SWIGTYPE_p_unsigned_char); } arg4 = (int)lua_tonumber(L, 4); - (arg1)->sendI2CWriteRequest(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_sendI2CWriteRequest__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; char arg2 ; char *arg3 = (char *) 0 ; int arg4 ; int arg5 ; SWIG_check_num_args("ofArduino::sendI2CWriteRequest",5,5) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::sendI2CWriteRequest",1,"ofArduino *"); if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("ofArduino::sendI2CWriteRequest",2,"char"); @@ -16487,7 +19255,7 @@ static int _wrap_Arduino_sendI2CWriteRequest__SWIG_2(lua_State* L) { int SWIG_ar arg3 = (char *)lua_tostring(L, 3); arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); (arg1)->sendI2CWriteRequest(arg2,(char const *)arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_sendI2CWriteRequest__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; +static int _wrap_Arduino_sendI2CWriteRequest__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; char arg2 ; char *arg3 = (char *) 0 ; int arg4 ; SWIG_check_num_args("ofArduino::sendI2CWriteRequest",4,4) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::sendI2CWriteRequest",1,"ofArduino *"); if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("ofArduino::sendI2CWriteRequest",2,"char"); @@ -16497,102 +19265,12 @@ static int _wrap_Arduino_sendI2CWriteRequest__SWIG_3(lua_State* L) { int SWIG_ar SWIG_fail_ptr("Arduino_sendI2CWriteRequest",1,SWIGTYPE_p_ofArduino); } arg2 = (lua_tostring(L, 2))[0]; arg3 = (char *)lua_tostring(L, 3); arg4 = (int)lua_tonumber(L, 4); (arg1)->sendI2CWriteRequest(arg2,(char const *)arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_sendI2CWriteRequest__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; - char arg2 ; char *arg3 = (char *) 0 ; int arg4 ; int arg5 ; SWIG_check_num_args("ofArduino::sendI2CWriteRequest",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::sendI2CWriteRequest",1,"ofArduino *"); - if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("ofArduino::sendI2CWriteRequest",2,"char"); - if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("ofArduino::sendI2CWriteRequest",3,"char *"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofArduino::sendI2CWriteRequest",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofArduino::sendI2CWriteRequest",5,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_sendI2CWriteRequest",1,SWIGTYPE_p_ofArduino); } arg2 = (lua_tostring(L, 2))[0]; - arg3 = (char *)lua_tostring(L, 3); arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); - (arg1)->sendI2CWriteRequest(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_sendI2CWriteRequest__SWIG_5(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; - char arg2 ; char *arg3 = (char *) 0 ; int arg4 ; SWIG_check_num_args("ofArduino::sendI2CWriteRequest",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::sendI2CWriteRequest",1,"ofArduino *"); - if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("ofArduino::sendI2CWriteRequest",2,"char"); - if(!SWIG_lua_isnilstring(L,3)) SWIG_fail_arg("ofArduino::sendI2CWriteRequest",3,"char *"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofArduino::sendI2CWriteRequest",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_sendI2CWriteRequest",1,SWIGTYPE_p_ofArduino); } arg2 = (lua_tostring(L, 2))[0]; - arg3 = (char *)lua_tostring(L, 3); arg4 = (int)lua_tonumber(L, 4); (arg1)->sendI2CWriteRequest(arg2,arg3,arg4); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_sendI2CWriteRequest__SWIG_6(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; - char arg2 ; SwigValueWrapper< std::vector< char > > arg3 ; int arg4 ; std::vector< char > *argp3 ; - SWIG_check_num_args("ofArduino::sendI2CWriteRequest",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::sendI2CWriteRequest",1,"ofArduino *"); - if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("ofArduino::sendI2CWriteRequest",2,"char"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofArduino::sendI2CWriteRequest",3,"std::vector< char >"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofArduino::sendI2CWriteRequest",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_sendI2CWriteRequest",1,SWIGTYPE_p_ofArduino); } arg2 = (lua_tostring(L, 2))[0]; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&argp3,SWIGTYPE_p_std__vectorT_char_t,0))){ - SWIG_fail_ptr("Arduino_sendI2CWriteRequest",3,SWIGTYPE_p_std__vectorT_char_t); } arg3 = *argp3; - arg4 = (int)lua_tonumber(L, 4); (arg1)->sendI2CWriteRequest(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_sendI2CWriteRequest__SWIG_7(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; - char arg2 ; SwigValueWrapper< std::vector< char > > arg3 ; std::vector< char > *argp3 ; - SWIG_check_num_args("ofArduino::sendI2CWriteRequest",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::sendI2CWriteRequest",1,"ofArduino *"); - if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("ofArduino::sendI2CWriteRequest",2,"char"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofArduino::sendI2CWriteRequest",3,"std::vector< char >"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_sendI2CWriteRequest",1,SWIGTYPE_p_ofArduino); } arg2 = (lua_tostring(L, 2))[0]; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&argp3,SWIGTYPE_p_std__vectorT_char_t,0))){ - SWIG_fail_ptr("Arduino_sendI2CWriteRequest",3,SWIGTYPE_p_std__vectorT_char_t); } arg3 = *argp3; - (arg1)->sendI2CWriteRequest(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Arduino_sendI2CWriteRequest(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofArduino, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = SWIG_lua_isnilstring(L,argv[1]) && (lua_rawlen(L,argv[1])==1); } if (_v) { { - void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_std__vectorT_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Arduino_sendI2CWriteRequest__SWIG_7(L);} } } } - if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofArduino, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = SWIG_lua_isnilstring(L,argv[1]) && (lua_rawlen(L,argv[1])==1); } if (_v) { { - void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_std__vectorT_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { - return _wrap_Arduino_sendI2CWriteRequest__SWIG_6(L);} } } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofArduino, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = SWIG_lua_isnilstring(L,argv[1]) && (lua_rawlen(L,argv[1])==1); } if (_v) { { - void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_unsigned_char, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { - return _wrap_Arduino_sendI2CWriteRequest__SWIG_1(L);} } } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofArduino, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = SWIG_lua_isnilstring(L,argv[1]) && (lua_rawlen(L,argv[1])==1); } if (_v) { { - _v = SWIG_lua_isnilstring(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { - return _wrap_Arduino_sendI2CWriteRequest__SWIG_3(L);} } } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofArduino, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = SWIG_lua_isnilstring(L,argv[1]) && (lua_rawlen(L,argv[1])==1); } if (_v) { { - _v = SWIG_lua_isnilstring(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { - return _wrap_Arduino_sendI2CWriteRequest__SWIG_5(L);} } } } } if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofArduino, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = SWIG_lua_isnilstring(L,argv[1]) && (lua_rawlen(L,argv[1])==1); } if (_v) { { - void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_unsigned_char, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_Arduino_sendI2CWriteRequest__SWIG_0(L);} } } } } } - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofArduino, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = SWIG_lua_isnilstring(L,argv[1]) && (lua_rawlen(L,argv[1])==1); } if (_v) { { - _v = SWIG_lua_isnilstring(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_Arduino_sendI2CWriteRequest__SWIG_2(L);} } } } } } - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofArduino, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = SWIG_lua_isnilstring(L,argv[1]) && (lua_rawlen(L,argv[1])==1); } if (_v) { { - _v = SWIG_lua_isnilstring(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_Arduino_sendI2CWriteRequest__SWIG_4(L);} } } } } } + if (argc == 4) { return _wrap_Arduino_sendI2CWriteRequest__SWIG_1(L);} if (argc == 5) { + return _wrap_Arduino_sendI2CWriteRequest__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Arduino_sendI2CWriteRequest'\n" - " Possible C/C++ prototypes are:\n" " ofArduino::sendI2CWriteRequest(char,unsigned char *,int,int)\n" - " ofArduino::sendI2CWriteRequest(char,unsigned char *,int)\n" - " ofArduino::sendI2CWriteRequest(char,char const *,int,int)\n" - " ofArduino::sendI2CWriteRequest(char,char const *,int)\n" " ofArduino::sendI2CWriteRequest(char,char *,int,int)\n" - " ofArduino::sendI2CWriteRequest(char,char *,int)\n" " ofArduino::sendI2CWriteRequest(char,std::vector< char >,int)\n" - " ofArduino::sendI2CWriteRequest(char,std::vector< char >)\n"); lua_error(L);return 0; } + " Possible C/C++ prototypes are:\n" " ofArduino::sendI2CWriteRequest(char,char const *,int,int)\n" + " ofArduino::sendI2CWriteRequest(char,char const *,int)\n"); lua_error(L);return 0; } static int _wrap_Arduino_sendI2CReadRequest__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; char arg2 ; int arg3 ; int arg4 ; SWIG_check_num_args("ofArduino::sendI2CReadRequest",4,4) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::sendI2CReadRequest",1,"ofArduino *"); @@ -16613,15 +19291,8 @@ static int _wrap_Arduino_sendI2CReadRequest__SWIG_1(lua_State* L) { int SWIG_arg arg3 = (int)lua_tonumber(L, 3); (arg1)->sendI2CReadRequest(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Arduino_sendI2CReadRequest(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofArduino, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = SWIG_lua_isnilstring(L,argv[1]) && (lua_rawlen(L,argv[1])==1); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Arduino_sendI2CReadRequest__SWIG_1(L);} } } } - if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofArduino, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = SWIG_lua_isnilstring(L,argv[1]) && (lua_rawlen(L,argv[1])==1); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { - return _wrap_Arduino_sendI2CReadRequest__SWIG_0(L);} } } } } + if (argc == 3) { return _wrap_Arduino_sendI2CReadRequest__SWIG_1(L);} if (argc == 4) { + return _wrap_Arduino_sendI2CReadRequest__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Arduino_sendI2CReadRequest'\n" " Possible C/C++ prototypes are:\n" " ofArduino::sendI2CReadRequest(char,int,int)\n" " ofArduino::sendI2CReadRequest(char,int)\n"); lua_error(L);return 0; } @@ -16646,15 +19317,8 @@ static int _wrap_Arduino_sendI2ContinuousReadRequest__SWIG_1(lua_State* L) { int arg3 = (int)lua_tonumber(L, 3); (arg1)->sendI2ContinuousReadRequest(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Arduino_sendI2ContinuousReadRequest(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofArduino, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = SWIG_lua_isnilstring(L,argv[1]) && (lua_rawlen(L,argv[1])==1); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Arduino_sendI2ContinuousReadRequest__SWIG_1(L);} } } } - if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofArduino, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = SWIG_lua_isnilstring(L,argv[1]) && (lua_rawlen(L,argv[1])==1); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { - return _wrap_Arduino_sendI2ContinuousReadRequest__SWIG_0(L);} } } } } + if (argc == 3) { return _wrap_Arduino_sendI2ContinuousReadRequest__SWIG_1(L);} if (argc == 4) { + return _wrap_Arduino_sendI2ContinuousReadRequest__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Arduino_sendI2ContinuousReadRequest'\n" " Possible C/C++ prototypes are:\n" " ofArduino::sendI2ContinuousReadRequest(char,int,int)\n" " ofArduino::sendI2ContinuousReadRequest(char,int)\n"); lua_error(L);return 0; } @@ -16691,13 +19355,8 @@ static int _wrap_Arduino_sendOneWireSearch__SWIG_1(lua_State* L) { int SWIG_arg arg3 = (int)lua_tonumber(L, 3); (arg1)->sendOneWireSearch(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Arduino_sendOneWireSearch(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofArduino, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Arduino_sendOneWireSearch__SWIG_0(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofArduino, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = SWIG_lua_isnilstring(L,argv[1]) && (lua_rawlen(L,argv[1])==1); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Arduino_sendOneWireSearch__SWIG_1(L);} } } } + if (argc == 2) { return _wrap_Arduino_sendOneWireSearch__SWIG_0(L);} if (argc == 3) { + return _wrap_Arduino_sendOneWireSearch__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Arduino_sendOneWireSearch'\n" " Possible C/C++ prototypes are:\n" " ofArduino::sendOneWireSearch(int)\n" " ofArduino::sendOneWireSearch(char,int)\n"); lua_error(L);return 0; } @@ -16894,13 +19553,14 @@ static int _wrap_Arduino_serialListen(lua_State* L) { int SWIG_arg = 0; ofArduin SWIG_fail_ptr("Arduino_serialListen",1,SWIGTYPE_p_ofArduino); } arg2 = (Firmata_Serial_Ports)(int)lua_tonumber(L, 2); (arg1)->serialListen(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Arduino_getPinCapabilities(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; - SwigValueWrapper< std::map< int,supportedPinTypes > > result; SWIG_check_num_args("ofArduino::getPinCapabilities",1,1) + SwigValueWrapper< std::map< int,supportedPinTypes,std::less< int > > > result; + SWIG_check_num_args("ofArduino::getPinCapabilities",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::getPinCapabilities",1,"ofArduino *"); if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ SWIG_fail_ptr("Arduino_getPinCapabilities",1,SWIGTYPE_p_ofArduino); } result = (arg1)->getPinCapabilities(); { - std::map< int,supportedPinTypes > * resultptr = new std::map< int,supportedPinTypes >((const std::map< int,supportedPinTypes > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__mapT_int_supportedPinTypes_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } + std::map< int,supportedPinTypes,std::less< int > > * resultptr = new std::map< int,supportedPinTypes,std::less< int > >((const std::map< int,supportedPinTypes,std::less< int > > &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__mapT_int_supportedPinTypes_std__lessT_int_t_t,1); SWIG_arg++; } + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Arduino_getTotalPins(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; int result; SWIG_check_num_args("ofArduino::getTotalPins",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::getTotalPins",1,"ofArduino *"); @@ -17062,9 +19722,7 @@ static int _wrap_new_SerialDeviceInfo__SWIG_1(lua_State* L) { int SWIG_arg = 0; SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofSerialDeviceInfo,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_new_SerialDeviceInfo(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_SerialDeviceInfo__SWIG_1(L);} if (argc == 3) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { { - _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_new_SerialDeviceInfo__SWIG_0(L);} } } } + return _wrap_new_SerialDeviceInfo__SWIG_1(L);} if (argc == 3) { return _wrap_new_SerialDeviceInfo__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SerialDeviceInfo'\n" " Possible C/C++ prototypes are:\n" " ofSerialDeviceInfo::ofSerialDeviceInfo(std::string,std::string,int)\n" " ofSerialDeviceInfo::ofSerialDeviceInfo()\n"); lua_error(L);return 0; } @@ -17181,17 +19839,12 @@ static int _wrap_Serial_setup__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofSerial SWIG_fail_ptr("Serial_setup",1,SWIGTYPE_p_ofSerial); } arg2 = (int)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); result = (bool)(arg1)->setup(arg2,arg3); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Serial_setup(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 1) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofSerial, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Serial_setup__SWIG_0(L);} } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofSerial, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_Serial_setup__SWIG_2(L);} } } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofSerial, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Serial_setup__SWIG_1(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Serial_setup'\n" " Possible C/C++ prototypes are:\n" - " ofSerial::setup()\n" " ofSerial::setup(std::string,int)\n" " ofSerial::setup(int,int)\n"); lua_error(L);return 0; } +static int _wrap_Serial_setup(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 1) { + return _wrap_Serial_setup__SWIG_0(L);} if (argc == 3) { int _v = 0; { { _v = lua_isnumber(L,argv[1]); } } + if (!_v) goto check_2; return _wrap_Serial_setup__SWIG_2(L);} check_2: if (argc == 3) { + return _wrap_Serial_setup__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Serial_setup'\n" + " Possible C/C++ prototypes are:\n" " ofSerial::setup()\n" " ofSerial::setup(std::string,int)\n" + " ofSerial::setup(int,int)\n"); lua_error(L);return 0; } static int _wrap_Serial_isInitialized(lua_State* L) { int SWIG_arg = 0; ofSerial *arg1 = (ofSerial *) 0 ; bool result; SWIG_check_num_args("ofSerial::isInitialized",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSerial::isInitialized",1,"ofSerial const *"); @@ -17243,20 +19896,13 @@ static int _wrap_Serial_readBytes__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofSe result = (long)(arg1)->readBytes(*arg2,arg3); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Serial_readBytes(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofSerial, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; + int _v = 0; { { void *ptr; if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_unsigned_char, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Serial_readBytes__SWIG_0(L);} - } } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofSerial, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBuffer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Serial_readBytes__SWIG_2(L);} - } } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofSerial, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = SWIG_lua_isnilstring(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_Serial_readBytes__SWIG_1(L);} } } } + else { _v = 1; } } } if (!_v) goto check_1; return _wrap_Serial_readBytes__SWIG_0(L);} check_1: if (argc == 3) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBuffer, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_Serial_readBytes__SWIG_2(L);} check_2: + if (argc == 3) { return _wrap_Serial_readBytes__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Serial_readBytes'\n" " Possible C/C++ prototypes are:\n" " ofSerial::readBytes(unsigned char *,size_t)\n" " ofSerial::readBytes(char *,size_t)\n" " ofSerial::readBytes(ofBuffer &,size_t)\n"); lua_error(L);return 0; } @@ -17297,19 +19943,10 @@ static int _wrap_Serial_writeBytes__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofS SWIG_fail_ptr("Serial_writeBytes",2,SWIGTYPE_p_ofBuffer); } result = (long)(arg1)->writeBytes((ofBuffer const &)*arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Serial_writeBytes(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofSerial, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBuffer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Serial_writeBytes__SWIG_2(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofSerial, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; + return _wrap_Serial_writeBytes__SWIG_2(L);} if (argc == 3) { int _v = 0; { { void *ptr; if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_unsigned_char, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Serial_writeBytes__SWIG_0(L);} - } } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofSerial, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = SWIG_lua_isnilstring(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_Serial_writeBytes__SWIG_1(L);} } } } + else { _v = 1; } } } if (!_v) goto check_2; return _wrap_Serial_writeBytes__SWIG_0(L);} check_2: if (argc == 3) { + return _wrap_Serial_writeBytes__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Serial_writeBytes'\n" " Possible C/C++ prototypes are:\n" " ofSerial::writeBytes(unsigned char const *,size_t)\n" " ofSerial::writeBytes(char const *,size_t)\n" " ofSerial::writeBytes(ofBuffer const &)\n"); lua_error(L);return 0; } @@ -17331,13 +19968,8 @@ static int _wrap_Serial_writeByte__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofSe result = (bool)(arg1)->writeByte(arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Serial_writeByte(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofSerial, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Serial_writeByte__SWIG_0(L);} } - } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofSerial, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = SWIG_lua_isnilstring(L,argv[1]) && (lua_rawlen(L,argv[1])==1); } if (_v) { - return _wrap_Serial_writeByte__SWIG_1(L);} } } + int _v = 0; { { _v = lua_isnumber(L,argv[1]); } } if (!_v) goto check_1; return _wrap_Serial_writeByte__SWIG_0(L);} + check_1: if (argc == 2) { return _wrap_Serial_writeByte__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Serial_writeByte'\n" " Possible C/C++ prototypes are:\n" " ofSerial::writeByte(unsigned char)\n" " ofSerial::writeByte(char)\n"); lua_error(L);return 0; } static int _wrap_Serial_flush__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofSerial *arg1 = (ofSerial *) 0 ; bool arg2 ; @@ -17359,17 +19991,11 @@ static int _wrap_Serial_flush__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofSerial if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSerial,0))){ SWIG_fail_ptr("Serial_flush",1,SWIGTYPE_p_ofSerial); } (arg1)->flush(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Serial_flush(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 1) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofSerial, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Serial_flush__SWIG_2(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofSerial, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_Serial_flush__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofSerial, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } - if (_v) { return _wrap_Serial_flush__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Serial_flush'\n" " Possible C/C++ prototypes are:\n" - " ofSerial::flush(bool,bool)\n" " ofSerial::flush(bool)\n" " ofSerial::flush()\n"); lua_error(L);return 0; } +static int _wrap_Serial_flush(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 1) { + return _wrap_Serial_flush__SWIG_2(L);} if (argc == 2) { return _wrap_Serial_flush__SWIG_1(L);} if (argc == 3) { + return _wrap_Serial_flush__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Serial_flush'\n" + " Possible C/C++ prototypes are:\n" " ofSerial::flush(bool,bool)\n" " ofSerial::flush(bool)\n" + " ofSerial::flush()\n"); lua_error(L);return 0; } static int _wrap_Serial_drain(lua_State* L) { int SWIG_arg = 0; ofSerial *arg1 = (ofSerial *) 0 ; SWIG_check_num_args("ofSerial::drain",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSerial::drain",1,"ofSerial *"); if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSerial,0))){ @@ -17442,10 +20068,9 @@ static int _wrap_random__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; f if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRandom",2,"float"); arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); result = (float)ofRandom(arg1,arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_random(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_random__SWIG_0(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_random__SWIG_1(L);} } - } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'random'\n" " Possible C/C++ prototypes are:\n" +static int _wrap_random(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { + return _wrap_random__SWIG_0(L);} if (argc == 2) { return _wrap_random__SWIG_1(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'random'\n" " Possible C/C++ prototypes are:\n" " ofRandom(float)\n" " ofRandom(float,float)\n"); lua_error(L);return 0; } static int _wrap_randomf(lua_State* L) { int SWIG_arg = 0; float result; SWIG_check_num_args("ofRandomf",0,0) result = (float)ofRandomf(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: @@ -17459,9 +20084,9 @@ static int _wrap_seedRandom__SWIG_1(lua_State* L) { int SWIG_arg = 0; int arg1 ; if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSeedRandom",1,"int"); arg1 = (int)lua_tonumber(L, 1); ofSeedRandom(arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_seedRandom(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_seedRandom__SWIG_0(L);} if (argc == 1) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { - return _wrap_seedRandom__SWIG_1(L);} } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'seedRandom'\n" - " Possible C/C++ prototypes are:\n" " ofSeedRandom()\n" " ofSeedRandom(int)\n"); lua_error(L);return 0; } + return _wrap_seedRandom__SWIG_0(L);} if (argc == 1) { return _wrap_seedRandom__SWIG_1(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'seedRandom'\n" " Possible C/C++ prototypes are:\n" + " ofSeedRandom()\n" " ofSeedRandom(int)\n"); lua_error(L);return 0; } static int _wrap_normalize(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float result; SWIG_check_num_args("ofNormalize",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofNormalize",1,"float"); if(!lua_isnumber(L,2)) SWIG_fail_arg("ofNormalize",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofNormalize",3,"float"); @@ -17483,13 +20108,8 @@ static int _wrap_map__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; floa arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); result = (float)ofMap(arg1,arg2,arg3,arg4,arg5); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_map(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); if (argc == 5) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_map__SWIG_1(L);} } } } } } if (argc == 6) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isboolean(L,argv[5]); } if (_v) { return _wrap_map__SWIG_0(L);} } } } } } } +static int _wrap_map(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); if (argc == 5) { + return _wrap_map__SWIG_1(L);} if (argc == 6) { return _wrap_map__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'map'\n" " Possible C/C++ prototypes are:\n" " ofMap(float,float,float,float,float,bool)\n" " ofMap(float,float,float,float,float)\n"); lua_error(L);return 0; } static int _wrap_clamp(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float result; @@ -17524,13 +20144,8 @@ static int _wrap_dist__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; flo arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); result = (float)ofDist(arg1,arg2,arg3,arg4,arg5,arg6); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_dist(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); if (argc == 4) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_dist__SWIG_0(L);} } } } } if (argc == 6) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { - return _wrap_dist__SWIG_1(L);} } } } } } } +static int _wrap_dist(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); if (argc == 4) { + return _wrap_dist__SWIG_0(L);} if (argc == 6) { return _wrap_dist__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'dist'\n" " Possible C/C++ prototypes are:\n" " ofDist(float,float,float,float)\n" " ofDist(float,float,float,float,float,float)\n"); lua_error(L);return 0; } static int _wrap_distSquared__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; @@ -17554,12 +20169,7 @@ static int _wrap_distSquared__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg result = (float)ofDistSquared(arg1,arg2,arg3,arg4,arg5,arg6); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_distSquared(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); if (argc == 4) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { - return _wrap_distSquared__SWIG_0(L);} } } } } if (argc == 6) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { return _wrap_distSquared__SWIG_1(L);} } } } } } } + return _wrap_distSquared__SWIG_0(L);} if (argc == 6) { return _wrap_distSquared__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'distSquared'\n" " Possible C/C++ prototypes are:\n" " ofDistSquared(float,float,float,float)\n" " ofDistSquared(float,float,float,float,float,float)\n"); lua_error(L);return 0; } @@ -17616,15 +20226,11 @@ static int _wrap_wrapRadians__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg SWIG_check_num_args("ofWrapRadians",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofWrapRadians",1,"float"); arg1 = (float)lua_tonumber(L, 1); result = (float)ofWrapRadians(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_wrapRadians(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_wrapRadians__SWIG_2(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_wrapRadians__SWIG_1(L);} } } if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_wrapRadians__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'wrapRadians'\n" " Possible C/C++ prototypes are:\n" - " ofWrapRadians(float,float,float)\n" " ofWrapRadians(float,float)\n" " ofWrapRadians(float)\n"); - lua_error(L);return 0; } +static int _wrap_wrapRadians(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 1) { + return _wrap_wrapRadians__SWIG_2(L);} if (argc == 2) { return _wrap_wrapRadians__SWIG_1(L);} if (argc == 3) { + return _wrap_wrapRadians__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'wrapRadians'\n" + " Possible C/C++ prototypes are:\n" " ofWrapRadians(float,float,float)\n" " ofWrapRadians(float,float)\n" + " ofWrapRadians(float)\n"); lua_error(L);return 0; } static int _wrap_wrapDegrees__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float result; SWIG_check_num_args("ofWrapDegrees",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofWrapDegrees",1,"float"); if(!lua_isnumber(L,2)) SWIG_fail_arg("ofWrapDegrees",2,"float"); @@ -17640,15 +20246,11 @@ static int _wrap_wrapDegrees__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg SWIG_check_num_args("ofWrapDegrees",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofWrapDegrees",1,"float"); arg1 = (float)lua_tonumber(L, 1); result = (float)ofWrapDegrees(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_wrapDegrees(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_wrapDegrees__SWIG_2(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_wrapDegrees__SWIG_1(L);} } } if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_wrapDegrees__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'wrapDegrees'\n" " Possible C/C++ prototypes are:\n" - " ofWrapDegrees(float,float,float)\n" " ofWrapDegrees(float,float)\n" " ofWrapDegrees(float)\n"); - lua_error(L);return 0; } +static int _wrap_wrapDegrees(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 1) { + return _wrap_wrapDegrees__SWIG_2(L);} if (argc == 2) { return _wrap_wrapDegrees__SWIG_1(L);} if (argc == 3) { + return _wrap_wrapDegrees__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'wrapDegrees'\n" + " Possible C/C++ prototypes are:\n" " ofWrapDegrees(float,float,float)\n" " ofWrapDegrees(float,float)\n" + " ofWrapDegrees(float)\n"); lua_error(L);return 0; } static int _wrap_noise__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float result; SWIG_check_num_args("ofNoise",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofNoise",1,"float"); arg1 = (float)lua_tonumber(L, 1); result = (float)ofNoise(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } @@ -17684,19 +20286,18 @@ static int _wrap_noise__SWIG_6(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("noise",1,SWIGTYPE_p_glm__vec4); } result = (float)ofNoise((glm::vec4 const &)*arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_noise(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_noise__SWIG_2(L);} } if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_noise__SWIG_4(L);} } if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_noise__SWIG_6(L);} } if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_noise__SWIG_0(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_noise__SWIG_1(L);} } - } if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_noise__SWIG_3(L);} } } } if (argc == 4) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_noise__SWIG_5(L);} } } } } +static int _wrap_noise(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 1) { int _v = 0; { + { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_noise__SWIG_2(L);} check_1: if (argc == 1) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_noise__SWIG_4(L);} check_2: if (argc == 1) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; return _wrap_noise__SWIG_6(L);} check_3: if (argc == 1) { + return _wrap_noise__SWIG_0(L);} if (argc == 2) { return _wrap_noise__SWIG_1(L);} if (argc == 3) { + return _wrap_noise__SWIG_3(L);} if (argc == 4) { return _wrap_noise__SWIG_5(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'noise'\n" " Possible C/C++ prototypes are:\n" " ofNoise(float)\n" " ofNoise(float,float)\n" " ofNoise(glm::vec2 const &)\n" " ofNoise(float,float,float)\n" " ofNoise(glm::vec3 const &)\n" " ofNoise(float,float,float,float)\n" " ofNoise(glm::vec4 const &)\n"); @@ -17739,20 +20340,18 @@ static int _wrap_signedNoise__SWIG_6(lua_State* L) { int SWIG_arg = 0; glm::vec4 if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("signedNoise",1,SWIGTYPE_p_glm__vec4); } result = (float)ofSignedNoise((glm::vec4 const &)*arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_signedNoise(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 1) { int _v; - { void *ptr; if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_signedNoise__SWIG_2(L);} } if (argc == 1) { int _v; { - void *ptr; if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_signedNoise__SWIG_4(L);} } if (argc == 1) { int _v; { - void *ptr; if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec4, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_signedNoise__SWIG_6(L);} } if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_signedNoise__SWIG_0(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_signedNoise__SWIG_1(L);} } } if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_signedNoise__SWIG_3(L);} } } } if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { - { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_signedNoise__SWIG_5(L);} } } } } +static int _wrap_signedNoise(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 1) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_signedNoise__SWIG_2(L);} check_1: + if (argc == 1) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_signedNoise__SWIG_4(L);} check_2: + if (argc == 1) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; return _wrap_signedNoise__SWIG_6(L);} check_3: + if (argc == 1) { return _wrap_signedNoise__SWIG_0(L);} if (argc == 2) { return _wrap_signedNoise__SWIG_1(L);} + if (argc == 3) { return _wrap_signedNoise__SWIG_3(L);} if (argc == 4) { return _wrap_signedNoise__SWIG_5(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'signedNoise'\n" " Possible C/C++ prototypes are:\n" " ofSignedNoise(float)\n" " ofSignedNoise(float,float)\n" " ofSignedNoise(glm::vec2 const &)\n" " ofSignedNoise(float,float,float)\n" " ofSignedNoise(glm::vec3 const &)\n" @@ -17976,38 +20575,16 @@ static int _wrap_new_Matrix3x3__SWIG_10(lua_State* L) { int SWIG_arg = 0; glm::m SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMatrix3x3,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_new_Matrix3x3(lua_State* L) { int argc; int argv[10]={ 1,2,3,4,5,6,7,8,9,10} ; argc = lua_gettop(L); - if (argc == 0) { return _wrap_new_Matrix3x3__SWIG_9(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__mat3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_new_Matrix3x3__SWIG_10(L);} } if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_new_Matrix3x3__SWIG_8(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_new_Matrix3x3__SWIG_7(L);} } } if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_new_Matrix3x3__SWIG_6(L);} } } } if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_new_Matrix3x3__SWIG_5(L);} } } } } if (argc == 5) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_new_Matrix3x3__SWIG_4(L);} } } } } } - if (argc == 6) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { - return _wrap_new_Matrix3x3__SWIG_3(L);} } } } } } } if (argc == 7) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { - return _wrap_new_Matrix3x3__SWIG_2(L);} } } } } } } } if (argc == 8) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { return _wrap_new_Matrix3x3__SWIG_1(L);} } } } } } } } } - if (argc == 9) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { { - _v = lua_isnumber(L,argv[6]); } if (_v) { { _v = lua_isnumber(L,argv[7]); } if (_v) { { - _v = lua_isnumber(L,argv[8]); } if (_v) { return _wrap_new_Matrix3x3__SWIG_0(L);} } } } } } } } } - } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_Matrix3x3'\n" - " Possible C/C++ prototypes are:\n" " ofMatrix3x3::ofMatrix3x3(float,float,float,float,float,float,float,float,float)\n" + if (argc == 0) { return _wrap_new_Matrix3x3__SWIG_9(L);} if (argc == 1) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__mat3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_new_Matrix3x3__SWIG_10(L);} check_2: + if (argc == 1) { return _wrap_new_Matrix3x3__SWIG_8(L);} if (argc == 2) { return _wrap_new_Matrix3x3__SWIG_7(L);} + if (argc == 3) { return _wrap_new_Matrix3x3__SWIG_6(L);} if (argc == 4) { return _wrap_new_Matrix3x3__SWIG_5(L);} + if (argc == 5) { return _wrap_new_Matrix3x3__SWIG_4(L);} if (argc == 6) { return _wrap_new_Matrix3x3__SWIG_3(L);} + if (argc == 7) { return _wrap_new_Matrix3x3__SWIG_2(L);} if (argc == 8) { return _wrap_new_Matrix3x3__SWIG_1(L);} + if (argc == 9) { return _wrap_new_Matrix3x3__SWIG_0(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_Matrix3x3'\n" " Possible C/C++ prototypes are:\n" + " ofMatrix3x3::ofMatrix3x3(float,float,float,float,float,float,float,float,float)\n" " ofMatrix3x3::ofMatrix3x3(float,float,float,float,float,float,float,float)\n" " ofMatrix3x3::ofMatrix3x3(float,float,float,float,float,float,float)\n" " ofMatrix3x3::ofMatrix3x3(float,float,float,float,float,float)\n" @@ -18052,13 +20629,7 @@ static int _wrap_Matrix3x3_transpose__SWIG_1(lua_State* L) { int SWIG_arg = 0; o SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix3x3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Matrix3x3_transpose(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix3x3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix3x3_transpose__SWIG_0(L);} } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix3x3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofMatrix3x3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix3x3_transpose__SWIG_1(L);} } } + return _wrap_Matrix3x3_transpose__SWIG_0(L);} if (argc == 2) { return _wrap_Matrix3x3_transpose__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix3x3_transpose'\n" " Possible C/C++ prototypes are:\n" " ofMatrix3x3::transpose()\n" " ofMatrix3x3::transpose(ofMatrix3x3 const &)\n"); lua_error(L);return 0; } @@ -18080,13 +20651,7 @@ static int _wrap_Matrix3x3_determinant__SWIG_1(lua_State* L) { int SWIG_arg = 0; result = (float)(arg1)->determinant((ofMatrix3x3 const &)*arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Matrix3x3_determinant(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix3x3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix3x3_determinant__SWIG_0(L);} } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix3x3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofMatrix3x3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix3x3_determinant__SWIG_1(L);} } } + return _wrap_Matrix3x3_determinant__SWIG_0(L);} if (argc == 2) { return _wrap_Matrix3x3_determinant__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix3x3_determinant'\n" " Possible C/C++ prototypes are:\n" " ofMatrix3x3::determinant() const\n" " ofMatrix3x3::determinant(ofMatrix3x3 const &)\n"); lua_error(L);return 0; } @@ -18161,16 +20726,13 @@ static int _wrap_Matrix3x3___mul__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMat ofMatrix3x3 * resultptr = new ofMatrix3x3((const ofMatrix3x3 &) result); SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix3x3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix3x3___mul(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix3x3, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofMatrix3x3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix3x3___mul__SWIG_1(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix3x3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Matrix3x3___mul__SWIG_0(L);} } - } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix3x3___mul'\n" - " Possible C/C++ prototypes are:\n" " ofMatrix3x3::operator *(float)\n" - " ofMatrix3x3::operator *(ofMatrix3x3 const &)\n"); lua_error(L);return 0; } +static int _wrap_Matrix3x3___mul(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofMatrix3x3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_Matrix3x3___mul__SWIG_1(L);} check_1: + if (argc == 2) { return _wrap_Matrix3x3___mul__SWIG_0(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix3x3___mul'\n" " Possible C/C++ prototypes are:\n" + " ofMatrix3x3::operator *(float)\n" " ofMatrix3x3::operator *(ofMatrix3x3 const &)\n"); lua_error(L);return 0; } static int _wrap_Matrix3x3___div(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; float arg2 ; ofMatrix3x3 result; SWIG_check_num_args("ofMatrix3x3::operator /",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::operator /",1,"ofMatrix3x3 *"); @@ -18180,6 +20742,13 @@ static int _wrap_Matrix3x3___div(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 * result = (arg1)->operator /(arg2); { ofMatrix3x3 * resultptr = new ofMatrix3x3((const ofMatrix3x3 &) result); SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix3x3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Matrix3x3_mat3(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; glm::mat3 result; + SWIG_check_num_args("ofMatrix3x3::mat3",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::mat3",1,"ofMatrix3x3 *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ + SWIG_fail_ptr("Matrix3x3_mat3",1,SWIGTYPE_p_ofMatrix3x3); } result = ofMatrix3x3_mat3(arg1); { + glm::mat3 * resultptr = new glm::mat3((const glm::mat3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__mat3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } static int _wrap_Matrix3x3___tostring(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; char *result = 0 ; SWIG_check_num_args("ofMatrix3x3::__str__",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::__str__",1,"ofMatrix3x3 *"); @@ -18221,6 +20790,7 @@ static swig_lua_method swig_Matrix3x3_methods[]= { { "__sub", _wrap_Matrix3x3___sub}, { "__mul", _wrap_Matrix3x3___mul}, { "__div", _wrap_Matrix3x3___div}, + { "mat3", _wrap_Matrix3x3_mat3}, { "__tostring", _wrap_Matrix3x3___tostring}, {0,0} }; @@ -18328,22 +20898,13 @@ static int _wrap_new_Matrix4x4__SWIG_4(lua_State* L) { int SWIG_arg = 0; float a SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_new_Matrix4x4(lua_State* L) { int argc; int argv[17]={ 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17} ; - argc = lua_gettop(L); if (argc == 0) { return _wrap_new_Matrix4x4__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__mat4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_new_Matrix4x4__SWIG_1(L);} } if (argc == 1) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_new_Matrix4x4__SWIG_2(L);} } if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_new_Matrix4x4__SWIG_3(L);} } if (argc == 16) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { { _v = lua_isnumber(L,argv[8]); } if (_v) { { - _v = lua_isnumber(L,argv[9]); } if (_v) { { _v = lua_isnumber(L,argv[10]); } if (_v) { { - _v = lua_isnumber(L,argv[11]); } if (_v) { { _v = lua_isnumber(L,argv[12]); } if (_v) { { - _v = lua_isnumber(L,argv[13]); } if (_v) { { _v = lua_isnumber(L,argv[14]); } if (_v) { { - _v = lua_isnumber(L,argv[15]); } if (_v) { return _wrap_new_Matrix4x4__SWIG_4(L);} } } } - } } } } } } } } } } } } } + argc = lua_gettop(L); if (argc == 0) { return _wrap_new_Matrix4x4__SWIG_0(L);} if (argc == 1) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__mat4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_new_Matrix4x4__SWIG_1(L);} check_2: + if (argc == 1) { int _v = 0; { { void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } else { + _v = 1; } } } if (!_v) goto check_3; return _wrap_new_Matrix4x4__SWIG_2(L);} check_3: if (argc == 1) { + return _wrap_new_Matrix4x4__SWIG_3(L);} if (argc == 16) { return _wrap_new_Matrix4x4__SWIG_4(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_Matrix4x4'\n" " Possible C/C++ prototypes are:\n" " ofMatrix4x4::ofMatrix4x4()\n" " ofMatrix4x4::ofMatrix4x4(glm::mat4 const &)\n" " ofMatrix4x4::ofMatrix4x4(float const *const)\n" " ofMatrix4x4::ofMatrix4x4(ofQuaternion const &)\n" @@ -18375,14 +20936,8 @@ static int _wrap_Matrix4x4_makeScaleMatrix__SWIG_1(lua_State* L) { int SWIG_arg arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); (arg1)->makeScaleMatrix(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Matrix4x4_makeScaleMatrix(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_makeScaleMatrix__SWIG_0(L);} } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Matrix4x4_makeScaleMatrix__SWIG_1(L);} } } } } + if (argc == 2) { return _wrap_Matrix4x4_makeScaleMatrix__SWIG_0(L);} if (argc == 4) { + return _wrap_Matrix4x4_makeScaleMatrix__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4_makeScaleMatrix'\n" " Possible C/C++ prototypes are:\n" " ofMatrix4x4::makeScaleMatrix(ofVec3f const &)\n" " ofMatrix4x4::makeScaleMatrix(float,float,float)\n"); lua_error(L);return 0; } @@ -18407,15 +20962,8 @@ static int _wrap_Matrix4x4_makeTranslationMatrix__SWIG_1(lua_State* L) { int SWI arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); (arg1)->makeTranslationMatrix(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Matrix4x4_makeTranslationMatrix(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_makeTranslationMatrix__SWIG_0(L);} } } if (argc == 4) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Matrix4x4_makeTranslationMatrix__SWIG_1(L);} } } } } + if (argc == 2) { return _wrap_Matrix4x4_makeTranslationMatrix__SWIG_0(L);} if (argc == 4) { + return _wrap_Matrix4x4_makeTranslationMatrix__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4_makeTranslationMatrix'\n" " Possible C/C++ prototypes are:\n" " ofMatrix4x4::makeTranslationMatrix(ofVec3f const &)\n" " ofMatrix4x4::makeTranslationMatrix(float,float,float)\n"); lua_error(L);return 0; } @@ -18485,36 +21033,13 @@ static int _wrap_Matrix4x4_makeRotationMatrix__SWIG_4(lua_State* L) { int SWIG_a (arg1)->makeRotationMatrix(arg2,(ofVec3f const &)*arg3,arg4,(ofVec3f const &)*arg5,arg6,(ofVec3f const &)*arg7); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Matrix4x4_makeRotationMatrix(lua_State* L) { int argc; int argv[8]={ 1,2,3,4,5,6,7,8} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_makeRotationMatrix__SWIG_3(L);} } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_makeRotationMatrix__SWIG_0(L);} } } } if (argc == 3) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_makeRotationMatrix__SWIG_1(L);} } } } if (argc == 5) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Matrix4x4_makeRotationMatrix__SWIG_2(L);} } } } } } if (argc == 7) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[4])==0 || SWIG_ConvertPtr(L,argv[4], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[6])==0 || SWIG_ConvertPtr(L,argv[6], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_makeRotationMatrix__SWIG_4(L);} } } } } - } } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4_makeRotationMatrix'\n" + if (argc == 2) { return _wrap_Matrix4x4_makeRotationMatrix__SWIG_3(L);} if (argc == 3) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_Matrix4x4_makeRotationMatrix__SWIG_0(L);} + check_2: if (argc == 3) { return _wrap_Matrix4x4_makeRotationMatrix__SWIG_1(L);} if (argc == 5) { + return _wrap_Matrix4x4_makeRotationMatrix__SWIG_2(L);} if (argc == 7) { + return _wrap_Matrix4x4_makeRotationMatrix__SWIG_4(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4_makeRotationMatrix'\n" " Possible C/C++ prototypes are:\n" " ofMatrix4x4::makeRotationMatrix(ofVec3f const &,ofVec3f const &)\n" " ofMatrix4x4::makeRotationMatrix(float,ofVec3f const &)\n" " ofMatrix4x4::makeRotationMatrix(float,float,float,float)\n" " ofMatrix4x4::makeRotationMatrix(ofQuaternion const &)\n" @@ -18661,11 +21186,8 @@ static int _wrap_Matrix4x4_newScaleMatrix__SWIG_1(lua_State* L) { int SWIG_arg = SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Matrix4x4_newScaleMatrix(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); - if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_Matrix4x4_newScaleMatrix__SWIG_0(L);} } if (argc == 3) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_Matrix4x4_newScaleMatrix__SWIG_1(L);} } } } + if (argc == 1) { return _wrap_Matrix4x4_newScaleMatrix__SWIG_0(L);} if (argc == 3) { + return _wrap_Matrix4x4_newScaleMatrix__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4_newScaleMatrix'\n" " Possible C/C++ prototypes are:\n" " ofMatrix4x4::newScaleMatrix(ofVec3f const &)\n" " ofMatrix4x4::newScaleMatrix(float,float,float)\n"); lua_error(L);return 0; } @@ -18689,11 +21211,8 @@ static int _wrap_Matrix4x4_newTranslationMatrix__SWIG_1(lua_State* L) { int SWIG SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Matrix4x4_newTranslationMatrix(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); - if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_Matrix4x4_newTranslationMatrix__SWIG_0(L);} } if (argc == 3) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_Matrix4x4_newTranslationMatrix__SWIG_1(L);} } } } + if (argc == 1) { return _wrap_Matrix4x4_newTranslationMatrix__SWIG_0(L);} if (argc == 3) { + return _wrap_Matrix4x4_newTranslationMatrix__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4_newTranslationMatrix'\n" " Possible C/C++ prototypes are:\n" " ofMatrix4x4::newTranslationMatrix(ofVec3f const &)\n" " ofMatrix4x4::newTranslationMatrix(float,float,float)\n"); lua_error(L);return 0; } @@ -18759,26 +21278,12 @@ static int _wrap_Matrix4x4_newRotationMatrix__SWIG_4(lua_State* L) { int SWIG_ar SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Matrix4x4_newRotationMatrix(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); - if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_newRotationMatrix__SWIG_4(L);} } if (argc == 2) { int _v; { - void *ptr; if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_newRotationMatrix__SWIG_0(L);} } } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_newRotationMatrix__SWIG_2(L);} } } if (argc == 4) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Matrix4x4_newRotationMatrix__SWIG_1(L);} } } } } - if (argc == 6) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[5])==0 || SWIG_ConvertPtr(L,argv[5], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_newRotationMatrix__SWIG_3(L);} } } } } } - } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4_newRotationMatrix'\n" + if (argc == 1) { return _wrap_Matrix4x4_newRotationMatrix__SWIG_4(L);} if (argc == 2) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_Matrix4x4_newRotationMatrix__SWIG_0(L);} + check_2: if (argc == 2) { return _wrap_Matrix4x4_newRotationMatrix__SWIG_2(L);} if (argc == 4) { + return _wrap_Matrix4x4_newRotationMatrix__SWIG_1(L);} if (argc == 6) { return _wrap_Matrix4x4_newRotationMatrix__SWIG_3(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4_newRotationMatrix'\n" " Possible C/C++ prototypes are:\n" " ofMatrix4x4::newRotationMatrix(ofVec3f const &,ofVec3f const &)\n" " ofMatrix4x4::newRotationMatrix(float,float,float,float)\n" " ofMatrix4x4::newRotationMatrix(float,ofVec3f const &)\n" " ofMatrix4x4::newRotationMatrix(float,ofVec3f const &,float,ofVec3f const &,float,ofVec3f const &)\n" @@ -18893,11 +21398,8 @@ static int _wrap_Matrix4x4_getPtr__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMa SWIG_fail_ptr("Matrix4x4_getPtr",1,SWIGTYPE_p_ofMatrix4x4); } result = (float *)((ofMatrix4x4 const *)arg1)->getPtr(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_float,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_getPtr(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_getPtr__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_getPtr__SWIG_1(L);} } +static int _wrap_Matrix4x4_getPtr(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { + return _wrap_Matrix4x4_getPtr__SWIG_0(L);} if (argc == 1) { return _wrap_Matrix4x4_getPtr__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4_getPtr'\n" " Possible C/C++ prototypes are:\n" " ofMatrix4x4::getPtr()\n" " ofMatrix4x4::getPtr() const\n"); lua_error(L);return 0; } static int _wrap_Matrix4x4_isValid(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; bool result; @@ -18973,30 +21475,14 @@ static int _wrap_Matrix4x4_set__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofMatri (arg1)->set(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Matrix4x4_set(lua_State* L) { int argc; int argv[18]={ 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18} ; - argc = lua_gettop(L); if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_set__SWIG_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; + argc = lua_gettop(L); if (argc == 2) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_Matrix4x4_set__SWIG_0(L);} check_1: + if (argc == 2) { int _v = 0; { { void *ptr; if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_Matrix4x4_set__SWIG_1(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_double, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_set__SWIG_2(L);} } } if (argc == 17) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { { _v = lua_isnumber(L,argv[8]); } if (_v) { { - _v = lua_isnumber(L,argv[9]); } if (_v) { { _v = lua_isnumber(L,argv[10]); } if (_v) { { - _v = lua_isnumber(L,argv[11]); } if (_v) { { _v = lua_isnumber(L,argv[12]); } if (_v) { { - _v = lua_isnumber(L,argv[13]); } if (_v) { { _v = lua_isnumber(L,argv[14]); } if (_v) { { - _v = lua_isnumber(L,argv[15]); } if (_v) { { _v = lua_isnumber(L,argv[16]); } if (_v) { - return _wrap_Matrix4x4_set__SWIG_3(L);} } } } } } } } } } } } } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4_set'\n" " Possible C/C++ prototypes are:\n" + _v = 1; } } } if (!_v) goto check_2; return _wrap_Matrix4x4_set__SWIG_1(L);} check_2: if (argc == 2) { + return _wrap_Matrix4x4_set__SWIG_2(L);} if (argc == 17) { return _wrap_Matrix4x4_set__SWIG_3(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4_set'\n" " Possible C/C++ prototypes are:\n" " ofMatrix4x4::set(ofMatrix4x4 const &)\n" " ofMatrix4x4::set(float const *const)\n" " ofMatrix4x4::set(double const *const)\n" " ofMatrix4x4::set(float,float,float,float,float,float,float,float,float,float,float,float,float,float,float,float)\n"); @@ -19114,25 +21600,8 @@ static int _wrap_Matrix4x4_getLookAt__SWIG_1(lua_State* L) { int SWIG_arg = 0; o SWIG_fail_ptr("Matrix4x4_getLookAt",4,SWIGTYPE_p_ofVec3f); } ((ofMatrix4x4 const *)arg1)->getLookAt(*arg2,*arg3,*arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Matrix4x4_getLookAt(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); - if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_getLookAt__SWIG_1(L);} } } } } if (argc == 5) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Matrix4x4_getLookAt__SWIG_0(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4_getLookAt'\n" + if (argc == 4) { return _wrap_Matrix4x4_getLookAt__SWIG_1(L);} if (argc == 5) { return _wrap_Matrix4x4_getLookAt__SWIG_0(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4_getLookAt'\n" " Possible C/C++ prototypes are:\n" " ofMatrix4x4::getLookAt(ofVec3f &,ofVec3f &,ofVec3f &,float) const\n" " ofMatrix4x4::getLookAt(ofVec3f &,ofVec3f &,ofVec3f &) const\n"); lua_error(L);return 0; } static int _wrap_Matrix4x4_decompose(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; @@ -19216,19 +21685,13 @@ static int _wrap_Matrix4x4_postMult__SWIG_2(lua_State* L) { int SWIG_arg = 0; of SWIG_fail_ptr("Matrix4x4_postMult",2,SWIGTYPE_p_ofMatrix4x4); } (arg1)->postMult((ofMatrix4x4 const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Matrix4x4_postMult(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_postMult__SWIG_0(L);} } } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_postMult__SWIG_1(L);} } } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_postMult__SWIG_2(L);} } } + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_Matrix4x4_postMult__SWIG_0(L);} check_1: + if (argc == 2) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec4f, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_Matrix4x4_postMult__SWIG_1(L);} check_2: + if (argc == 2) { return _wrap_Matrix4x4_postMult__SWIG_2(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4_postMult'\n" " Possible C/C++ prototypes are:\n" " ofMatrix4x4::postMult(ofVec3f const &) const\n" " ofMatrix4x4::postMult(ofVec4f const &) const\n" " ofMatrix4x4::postMult(ofMatrix4x4 const &)\n"); lua_error(L);return 0; } @@ -19266,19 +21729,13 @@ static int _wrap_Matrix4x4_preMult__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofM SWIG_fail_ptr("Matrix4x4_preMult",2,SWIGTYPE_p_ofMatrix4x4); } (arg1)->preMult((ofMatrix4x4 const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Matrix4x4_preMult(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_preMult__SWIG_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_preMult__SWIG_1(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_preMult__SWIG_2(L);} } } + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_Matrix4x4_preMult__SWIG_0(L);} check_1: + if (argc == 2) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec4f, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_Matrix4x4_preMult__SWIG_1(L);} check_2: + if (argc == 2) { return _wrap_Matrix4x4_preMult__SWIG_2(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4_preMult'\n" " Possible C/C++ prototypes are:\n" " ofMatrix4x4::preMult(ofVec3f const &) const\n" " ofMatrix4x4::preMult(ofVec4f const &) const\n" " ofMatrix4x4::preMult(ofMatrix4x4 const &)\n"); lua_error(L);return 0; } @@ -19318,19 +21775,14 @@ static int _wrap_Matrix4x4___mul__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofMat ofVec4f * resultptr = new ofVec4f((const ofVec4f &) result); SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec4f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4___mul(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4___mul__SWIG_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4___mul__SWIG_1(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4___mul__SWIG_2(L);} } } +static int _wrap_Matrix4x4___mul(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_Matrix4x4___mul__SWIG_0(L);} check_1: + if (argc == 2) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_Matrix4x4___mul__SWIG_1(L);} check_2: + if (argc == 2) { return _wrap_Matrix4x4___mul__SWIG_2(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4___mul'\n" " Possible C/C++ prototypes are:\n" " ofMatrix4x4::operator *(ofMatrix4x4 const &) const\n" " ofMatrix4x4::operator *(ofVec3f const &) const\n" " ofMatrix4x4::operator *(ofVec4f const &) const\n"); lua_error(L);return 0; } @@ -19372,15 +21824,9 @@ static int _wrap_Matrix4x4_postMultTranslate__SWIG_1(lua_State* L) { int SWIG_ar arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); (arg1)->postMultTranslate(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Matrix4x4_postMultTranslate(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_postMultTranslate__SWIG_0(L);} } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Matrix4x4_postMultTranslate__SWIG_1(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4_postMultTranslate'\n" + if (argc == 2) { return _wrap_Matrix4x4_postMultTranslate__SWIG_0(L);} if (argc == 4) { + return _wrap_Matrix4x4_postMultTranslate__SWIG_1(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4_postMultTranslate'\n" " Possible C/C++ prototypes are:\n" " ofMatrix4x4::postMultTranslate(ofVec3f const &)\n" " ofMatrix4x4::postMultTranslate(float,float,float)\n"); lua_error(L);return 0; } static int _wrap_Matrix4x4_postMultRotate__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; @@ -19395,15 +21841,8 @@ static int _wrap_Matrix4x4_postMultRotate__SWIG_1(lua_State* L) { int SWIG_arg = arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); (arg1)->postMultRotate(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Matrix4x4_postMultRotate(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_postMultRotate__SWIG_0(L);} } } if (argc == 5) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Matrix4x4_postMultRotate__SWIG_1(L);} } } } } } + if (argc == 2) { return _wrap_Matrix4x4_postMultRotate__SWIG_0(L);} if (argc == 5) { + return _wrap_Matrix4x4_postMultRotate__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4_postMultRotate'\n" " Possible C/C++ prototypes are:\n" " ofMatrix4x4::postMultRotate(ofQuaternion const &)\n" " ofMatrix4x4::postMultRotate(float,float,float,float)\n"); lua_error(L);return 0; } @@ -19418,14 +21857,8 @@ static int _wrap_Matrix4x4_postMultScale__SWIG_1(lua_State* L) { int SWIG_arg = arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); (arg1)->postMultScale(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Matrix4x4_postMultScale(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_postMultScale__SWIG_0(L);} } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Matrix4x4_postMultScale__SWIG_1(L);} } } } } + if (argc == 2) { return _wrap_Matrix4x4_postMultScale__SWIG_0(L);} if (argc == 4) { + return _wrap_Matrix4x4_postMultScale__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4_postMultScale'\n" " Possible C/C++ prototypes are:\n" " ofMatrix4x4::postMultScale(ofVec3f const &)\n" " ofMatrix4x4::postMultScale(float,float,float)\n"); lua_error(L);return 0; } @@ -19485,14 +21918,8 @@ static int _wrap_Matrix4x4_setTranslation__SWIG_1(lua_State* L) { int SWIG_arg = SWIG_fail_ptr("Matrix4x4_setTranslation",2,SWIGTYPE_p_ofVec3f); } (arg1)->setTranslation((ofVec3f const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Matrix4x4_setTranslation(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_setTranslation__SWIG_1(L);} } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Matrix4x4_setTranslation__SWIG_0(L);} } } } } + if (argc == 2) { return _wrap_Matrix4x4_setTranslation__SWIG_1(L);} if (argc == 4) { + return _wrap_Matrix4x4_setTranslation__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4_setTranslation'\n" " Possible C/C++ prototypes are:\n" " ofMatrix4x4::setTranslation(float,float,float)\n" " ofMatrix4x4::setTranslation(ofVec3f const &)\n"); lua_error(L);return 0; } @@ -19528,15 +21955,7 @@ static int _wrap_Matrix4x4_rotate__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMa SWIG_fail_ptr("Matrix4x4_rotate",2,SWIGTYPE_p_ofQuaternion); } (arg1)->rotate((ofQuaternion const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Matrix4x4_rotate(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_rotate__SWIG_1(L);} } } if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Matrix4x4_rotate__SWIG_0(L);} } } } } } + return _wrap_Matrix4x4_rotate__SWIG_1(L);} if (argc == 5) { return _wrap_Matrix4x4_rotate__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4_rotate'\n" " Possible C/C++ prototypes are:\n" " ofMatrix4x4::rotate(float,float,float,float)\n" " ofMatrix4x4::rotate(ofQuaternion const &)\n"); lua_error(L);return 0; } @@ -19560,14 +21979,7 @@ static int _wrap_Matrix4x4_translate__SWIG_1(lua_State* L) { int SWIG_arg = 0; o SWIG_fail_ptr("Matrix4x4_translate",2,SWIGTYPE_p_ofVec3f); } (arg1)->translate((ofVec3f const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Matrix4x4_translate(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_translate__SWIG_1(L);} } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Matrix4x4_translate__SWIG_0(L);} } } } } + return _wrap_Matrix4x4_translate__SWIG_1(L);} if (argc == 4) { return _wrap_Matrix4x4_translate__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4_translate'\n" " Possible C/C++ prototypes are:\n" " ofMatrix4x4::translate(float,float,float)\n" " ofMatrix4x4::translate(ofVec3f const &)\n"); lua_error(L);return 0; } @@ -19591,14 +22003,7 @@ static int _wrap_Matrix4x4_scale__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMat SWIG_fail_ptr("Matrix4x4_scale",2,SWIGTYPE_p_ofVec3f); } (arg1)->scale((ofVec3f const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Matrix4x4_scale(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_scale__SWIG_1(L);} } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Matrix4x4_scale__SWIG_0(L);} } } } } + return _wrap_Matrix4x4_scale__SWIG_1(L);} if (argc == 4) { return _wrap_Matrix4x4_scale__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4_scale'\n" " Possible C/C++ prototypes are:\n" " ofMatrix4x4::scale(float,float,float)\n" " ofMatrix4x4::scale(ofVec3f const &)\n"); lua_error(L);return 0; } static int _wrap_Matrix4x4_glRotate__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; @@ -19633,15 +22038,7 @@ static int _wrap_Matrix4x4_glRotate__SWIG_1(lua_State* L) { int SWIG_arg = 0; of SWIG_fail_ptr("Matrix4x4_glRotate",2,SWIGTYPE_p_ofQuaternion); } (arg1)->glRotate((ofQuaternion const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Matrix4x4_glRotate(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_glRotate__SWIG_1(L);} } } if (argc == 5) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Matrix4x4_glRotate__SWIG_0(L);} } } } } } + if (argc == 2) { return _wrap_Matrix4x4_glRotate__SWIG_1(L);} if (argc == 5) { return _wrap_Matrix4x4_glRotate__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4_glRotate'\n" " Possible C/C++ prototypes are:\n" " ofMatrix4x4::glRotate(float,float,float,float)\n" " ofMatrix4x4::glRotate(ofQuaternion const &)\n"); lua_error(L);return 0; } @@ -19665,14 +22062,8 @@ static int _wrap_Matrix4x4_glTranslate__SWIG_1(lua_State* L) { int SWIG_arg = 0; SWIG_fail_ptr("Matrix4x4_glTranslate",2,SWIGTYPE_p_ofVec3f); } (arg1)->glTranslate((ofVec3f const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Matrix4x4_glTranslate(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_glTranslate__SWIG_1(L);} } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Matrix4x4_glTranslate__SWIG_0(L);} } } } } + if (argc == 2) { return _wrap_Matrix4x4_glTranslate__SWIG_1(L);} if (argc == 4) { + return _wrap_Matrix4x4_glTranslate__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4_glTranslate'\n" " Possible C/C++ prototypes are:\n" " ofMatrix4x4::glTranslate(float,float,float)\n" " ofMatrix4x4::glTranslate(ofVec3f const &)\n"); lua_error(L);return 0; } @@ -19696,14 +22087,7 @@ static int _wrap_Matrix4x4_glScale__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofM SWIG_fail_ptr("Matrix4x4_glScale",2,SWIGTYPE_p_ofVec3f); } (arg1)->glScale((ofVec3f const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Matrix4x4_glScale(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_glScale__SWIG_1(L);} } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Matrix4x4_glScale__SWIG_0(L);} } } } } + return _wrap_Matrix4x4_glScale__SWIG_1(L);} if (argc == 4) { return _wrap_Matrix4x4_glScale__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4_glScale'\n" " Possible C/C++ prototypes are:\n" " ofMatrix4x4::glScale(float,float,float)\n" " ofMatrix4x4::glScale(ofVec3f const &)\n"); lua_error(L);return 0; } static int _wrap_Matrix4x4_getRotate(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; @@ -19755,18 +22139,22 @@ static int _wrap_Matrix4x4_transform3x3__SWIG_1(lua_State* L) { int SWIG_arg = 0 SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Matrix4x4_transform3x3(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_transform3x3__SWIG_0(L);} } } if (argc == 2) { int _v; { - void *ptr; if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_transform3x3__SWIG_1(L);} } } + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_Matrix4x4_transform3x3__SWIG_0(L);} check_1: + if (argc == 2) { return _wrap_Matrix4x4_transform3x3__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4_transform3x3'\n" " Possible C/C++ prototypes are:\n" " ofMatrix4x4::transform3x3(ofVec3f const &,ofMatrix4x4 const &)\n" " ofMatrix4x4::transform3x3(ofMatrix4x4 const &,ofVec3f const &)\n"); lua_error(L);return 0; } +static int _wrap_Matrix4x4_mat4(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; glm::mat4 result; + SWIG_check_num_args("ofMatrix4x4::mat4",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::mat4",1,"ofMatrix4x4 *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ + SWIG_fail_ptr("Matrix4x4_mat4",1,SWIGTYPE_p_ofMatrix4x4); } result = ofMatrix4x4_mat4(arg1); { + glm::mat4 * resultptr = new glm::mat4((const glm::mat4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__mat4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } static int _wrap_Matrix4x4___tostring(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; char *result = 0 ; SWIG_check_num_args("ofMatrix4x4::__str__",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::__str__",1,"ofMatrix4x4 *"); @@ -19839,6 +22227,7 @@ static swig_lua_method swig_Matrix4x4_methods[]= { { "getRotate", _wrap_Matrix4x4_getRotate}, { "getTranslation", _wrap_Matrix4x4_getTranslation}, { "getScale", _wrap_Matrix4x4_getScale}, + { "mat4", _wrap_Matrix4x4_mat4}, { "__tostring", _wrap_Matrix4x4___tostring}, {0,0} }; @@ -19960,23 +22349,11 @@ static int _wrap_new_Quaternion__SWIG_5(lua_State* L) { int SWIG_arg = 0; glm::q SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofQuaternion,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_new_Quaternion(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_Quaternion__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_new_Quaternion__SWIG_2(L);} } if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__quat, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_new_Quaternion__SWIG_5(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_new_Quaternion__SWIG_3(L);} } } if (argc == 4) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_new_Quaternion__SWIG_1(L);} } } } } - if (argc == 6) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[5])==0 || SWIG_ConvertPtr(L,argv[5], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_new_Quaternion__SWIG_4(L);} } } } } } } + return _wrap_new_Quaternion__SWIG_0(L);} if (argc == 1) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec4f, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_new_Quaternion__SWIG_2(L);} check_2: + if (argc == 1) { return _wrap_new_Quaternion__SWIG_5(L);} if (argc == 2) { return _wrap_new_Quaternion__SWIG_3(L);} + if (argc == 4) { return _wrap_new_Quaternion__SWIG_1(L);} if (argc == 6) { return _wrap_new_Quaternion__SWIG_4(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_Quaternion'\n" " Possible C/C++ prototypes are:\n" " ofQuaternion::ofQuaternion()\n" " ofQuaternion::ofQuaternion(float,float,float,float)\n" " ofQuaternion::ofQuaternion(ofVec4f const &)\n" " ofQuaternion::ofQuaternion(float,ofVec3f const &)\n" @@ -20012,19 +22389,10 @@ static int _wrap_Quaternion_set__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofQuat SWIG_fail_ptr("Quaternion_set",2,SWIGTYPE_p_ofMatrix4x4); } (arg1)->set((ofMatrix4x4 const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Quaternion_set(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Quaternion_set__SWIG_1(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Quaternion_set__SWIG_2(L);} } } if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Quaternion_set__SWIG_0(L);} } } } } } + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec4f, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_Quaternion_set__SWIG_1(L);} check_1: + if (argc == 2) { return _wrap_Quaternion_set__SWIG_2(L);} if (argc == 5) { return _wrap_Quaternion_set__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Quaternion_set'\n" " Possible C/C++ prototypes are:\n" " ofQuaternion::set(float,float,float,float)\n" " ofQuaternion::set(ofVec4f const &)\n" " ofQuaternion::set(ofMatrix4x4 const &)\n"); lua_error(L);return 0; } @@ -20167,30 +22535,12 @@ static int _wrap_Quaternion_makeRotate__SWIG_3(lua_State* L) { int SWIG_arg = 0; (arg1)->makeRotate((ofVec3f const &)*arg2,(ofVec3f const &)*arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Quaternion_makeRotate(lua_State* L) { int argc; int argv[8]={ 1,2,3,4,5,6,7,8} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Quaternion_makeRotate__SWIG_3(L);} } } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Quaternion_makeRotate__SWIG_1(L);} } } } if (argc == 5) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Quaternion_makeRotate__SWIG_0(L);} } } } } } if (argc == 7) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[4])==0 || SWIG_ConvertPtr(L,argv[4], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[6])==0 || SWIG_ConvertPtr(L,argv[6], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Quaternion_makeRotate__SWIG_2(L);} } } } } } } - } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Quaternion_makeRotate'\n" + if (argc == 3) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_Quaternion_makeRotate__SWIG_3(L);} check_1: + if (argc == 3) { return _wrap_Quaternion_makeRotate__SWIG_1(L);} if (argc == 5) { + return _wrap_Quaternion_makeRotate__SWIG_0(L);} if (argc == 7) { return _wrap_Quaternion_makeRotate__SWIG_2(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Quaternion_makeRotate'\n" " Possible C/C++ prototypes are:\n" " ofQuaternion::makeRotate(float,float,float,float)\n" " ofQuaternion::makeRotate(float,ofVec3f const &)\n" " ofQuaternion::makeRotate(float,ofVec3f const &,float,ofVec3f const &,float,ofVec3f const &)\n" @@ -20240,23 +22590,8 @@ static int _wrap_Quaternion_getRotate__SWIG_1(lua_State* L) { int SWIG_arg = 0; SWIG_fail_ptr("Quaternion_getRotate",3,SWIGTYPE_p_ofVec3f); } ((ofQuaternion const *)arg1)->getRotate(*arg2,*arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Quaternion_getRotate(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Quaternion_getRotate__SWIG_1(L);} } } } if (argc == 5) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[4])==0 || SWIG_ConvertPtr(L,argv[4], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Quaternion_getRotate__SWIG_0(L);} } } } } } + if (argc == 3) { return _wrap_Quaternion_getRotate__SWIG_1(L);} if (argc == 5) { + return _wrap_Quaternion_getRotate__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Quaternion_getRotate'\n" " Possible C/C++ prototypes are:\n" " ofQuaternion::getRotate(float &,float &,float &,float &) const\n" " ofQuaternion::getRotate(float &,ofVec3f &) const\n"); lua_error(L);return 0; } @@ -20333,21 +22668,16 @@ static int _wrap_Quaternion___mul__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofQu SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Quaternion___mul(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Quaternion___mul__SWIG_1(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Quaternion___mul__SWIG_2(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Quaternion___mul__SWIG_0(L);} } - } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Quaternion___mul'\n" - " Possible C/C++ prototypes are:\n" " ofQuaternion::operator *(float) const\n" - " ofQuaternion::operator *(ofQuaternion const &) const\n" " ofQuaternion::operator *(ofVec3f const &) const\n"); - lua_error(L);return 0; } + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofQuaternion, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_Quaternion___mul__SWIG_1(L);} check_1: + if (argc == 2) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_Quaternion___mul__SWIG_2(L);} check_2: + if (argc == 2) { return _wrap_Quaternion___mul__SWIG_0(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Quaternion___mul'\n" " Possible C/C++ prototypes are:\n" + " ofQuaternion::operator *(float) const\n" " ofQuaternion::operator *(ofQuaternion const &) const\n" + " ofQuaternion::operator *(ofVec3f const &) const\n"); lua_error(L);return 0; } static int _wrap_Quaternion___div__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; float arg2 ; ofQuaternion result; SWIG_check_num_args("ofQuaternion::operator /",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::operator /",1,"ofQuaternion const *"); @@ -20371,16 +22701,13 @@ static int _wrap_Quaternion___div__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofQu SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofQuaternion,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Quaternion___div(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Quaternion___div__SWIG_1(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Quaternion___div__SWIG_0(L);} } - } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Quaternion___div'\n" - " Possible C/C++ prototypes are:\n" " ofQuaternion::operator /(float) const\n" - " ofQuaternion::operator /(ofQuaternion const &) const\n"); lua_error(L);return 0; } + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofQuaternion, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_Quaternion___div__SWIG_1(L);} check_1: + if (argc == 2) { return _wrap_Quaternion___div__SWIG_0(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Quaternion___div'\n" " Possible C/C++ prototypes are:\n" + " ofQuaternion::operator /(float) const\n" " ofQuaternion::operator /(ofQuaternion const &) const\n"); + lua_error(L);return 0; } static int _wrap_Quaternion___add(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; ofQuaternion *arg2 = 0 ; ofQuaternion result; SWIG_check_num_args("ofQuaternion::operator +",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::operator +",1,"ofQuaternion const *"); @@ -20413,6 +22740,13 @@ static int _wrap_Quaternion___unm(lua_State* L) { int SWIG_arg = 0; ofQuaternion ofQuaternion * resultptr = new ofQuaternion((const ofQuaternion &) result); SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofQuaternion,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Quaternion_quat(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; glm::quat result; + SWIG_check_num_args("ofQuaternion::quat",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::quat",1,"ofQuaternion *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ + SWIG_fail_ptr("Quaternion_quat",1,SWIGTYPE_p_ofQuaternion); } result = ofQuaternion_quat(arg1); { + glm::quat * resultptr = new glm::quat((const glm::quat &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__quat,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } static int _wrap_Quaternion___tostring(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; char *result = 0 ; SWIG_check_num_args("ofQuaternion::__str__",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::__str__",1,"ofQuaternion *"); @@ -20461,6 +22795,7 @@ static swig_lua_method swig_Quaternion_methods[]= { { "__add", _wrap_Quaternion___add}, { "__sub", _wrap_Quaternion___sub}, { "__unm", _wrap_Quaternion___unm}, + { "quat", _wrap_Quaternion_quat}, { "__tostring", _wrap_Quaternion___tostring}, {0,0} }; @@ -20566,22 +22901,25 @@ static int _wrap_new_Vec2f__SWIG_7(lua_State* L) { int SWIG_arg = 0; glm::vec4 * SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_new_Vec2f(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_Vec2f__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_new_Vec2f__SWIG_3(L);} } if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_new_Vec2f__SWIG_4(L);} } if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_new_Vec2f__SWIG_5(L);} } if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_new_Vec2f__SWIG_6(L);} } if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_new_Vec2f__SWIG_7(L);} } if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_new_Vec2f__SWIG_1(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_new_Vec2f__SWIG_2(L);} - } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_Vec2f'\n" - " Possible C/C++ prototypes are:\n" " ofVec2f::ofVec2f()\n" " ofVec2f::ofVec2f(float)\n" - " ofVec2f::ofVec2f(float,float)\n" " ofVec2f::ofVec2f(ofVec3f const &)\n" " ofVec2f::ofVec2f(ofVec4f const &)\n" + return _wrap_new_Vec2f__SWIG_0(L);} if (argc == 1) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_new_Vec2f__SWIG_3(L);} check_2: + if (argc == 1) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec4f, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; return _wrap_new_Vec2f__SWIG_4(L);} check_3: + if (argc == 1) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_4; return _wrap_new_Vec2f__SWIG_5(L);} check_4: + if (argc == 1) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_5; return _wrap_new_Vec2f__SWIG_6(L);} check_5: + if (argc == 1) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_6; return _wrap_new_Vec2f__SWIG_7(L);} check_6: + if (argc == 1) { return _wrap_new_Vec2f__SWIG_1(L);} if (argc == 2) { return _wrap_new_Vec2f__SWIG_2(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_Vec2f'\n" " Possible C/C++ prototypes are:\n" + " ofVec2f::ofVec2f()\n" " ofVec2f::ofVec2f(float)\n" " ofVec2f::ofVec2f(float,float)\n" + " ofVec2f::ofVec2f(ofVec3f const &)\n" " ofVec2f::ofVec2f(ofVec4f const &)\n" " ofVec2f::ofVec2f(glm::vec2 const &)\n" " ofVec2f::ofVec2f(glm::vec3 const &)\n" " ofVec2f::ofVec2f(glm::vec4 const &)\n"); lua_error(L);return 0; } static int _wrap_Vec2f_getPtr__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; float *result = 0 ; @@ -20594,11 +22932,8 @@ static int _wrap_Vec2f_getPtr__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec2f if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_getPtr",1,SWIGTYPE_p_ofVec2f); } result = (float *)((ofVec2f const *)arg1)->getPtr(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_float,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_getPtr(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Vec2f_getPtr__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Vec2f_getPtr__SWIG_1(L);} } +static int _wrap_Vec2f_getPtr(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { + return _wrap_Vec2f_getPtr__SWIG_0(L);} if (argc == 1) { return _wrap_Vec2f_getPtr__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec2f_getPtr'\n" " Possible C/C++ prototypes are:\n" " ofVec2f::getPtr()\n" " ofVec2f::getPtr() const\n"); lua_error(L);return 0; } static int _wrap_Vec2f_set__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; float arg2 ; float arg3 ; @@ -20619,17 +22954,11 @@ static int _wrap_Vec2f_set__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofVec2f *ar if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec2f::set",2,"float"); if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_set",1,SWIGTYPE_p_ofVec2f); } arg2 = (float)lua_tonumber(L, 2); (arg1)->set(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_set(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec2f_set__SWIG_1(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Vec2f_set__SWIG_2(L);} } } - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Vec2f_set__SWIG_0(L);} } } } +static int _wrap_Vec2f_set(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { int _v = 0; + { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec2f, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_Vec2f_set__SWIG_1(L);} check_1: + if (argc == 2) { return _wrap_Vec2f_set__SWIG_2(L);} if (argc == 3) { return _wrap_Vec2f_set__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec2f_set'\n" " Possible C/C++ prototypes are:\n" " ofVec2f::set(float,float)\n" " ofVec2f::set(ofVec2f const &)\n" " ofVec2f::set(float)\n"); lua_error(L);return 0; } static int _wrap_Vec2f___eq(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f *arg2 = 0 ; bool result; @@ -20657,16 +22986,9 @@ static int _wrap_Vec2f_match__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec2f * if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_match",2,SWIGTYPE_p_ofVec2f); } result = (bool)((ofVec2f const *)arg1)->match((ofVec2f const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_match(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec2f_match__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Vec2f_match__SWIG_0(L);} } } - } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec2f_match'\n" " Possible C/C++ prototypes are:\n" +static int _wrap_Vec2f_match(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { + return _wrap_Vec2f_match__SWIG_1(L);} if (argc == 3) { return _wrap_Vec2f_match__SWIG_0(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec2f_match'\n" " Possible C/C++ prototypes are:\n" " ofVec2f::match(ofVec2f const &,float) const\n" " ofVec2f::match(ofVec2f const &) const\n"); lua_error(L);return 0; } static int _wrap_Vec2f_isAligned__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f *arg2 = 0 ; float arg3 ; bool result; SWIG_check_num_args("ofVec2f::isAligned",3,3) @@ -20690,18 +23012,10 @@ static int _wrap_Vec2f_isAligned__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec result = (bool)((ofVec2f const *)arg1)->isAligned((ofVec2f const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Vec2f_isAligned(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec2f_isAligned__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Vec2f_isAligned__SWIG_0(L);} } - } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec2f_isAligned'\n" - " Possible C/C++ prototypes are:\n" " ofVec2f::isAligned(ofVec2f const &,float) const\n" - " ofVec2f::isAligned(ofVec2f const &) const\n"); lua_error(L);return 0; } + return _wrap_Vec2f_isAligned__SWIG_1(L);} if (argc == 3) { return _wrap_Vec2f_isAligned__SWIG_0(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec2f_isAligned'\n" " Possible C/C++ prototypes are:\n" + " ofVec2f::isAligned(ofVec2f const &,float) const\n" " ofVec2f::isAligned(ofVec2f const &) const\n"); + lua_error(L);return 0; } static int _wrap_Vec2f_isAlignedRad__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f *arg2 = 0 ; float arg3 ; bool result; SWIG_check_num_args("ofVec2f::isAlignedRad",3,3) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::isAlignedRad",1,"ofVec2f const *"); @@ -20724,18 +23038,10 @@ static int _wrap_Vec2f_isAlignedRad__SWIG_1(lua_State* L) { int SWIG_arg = 0; of result = (bool)((ofVec2f const *)arg1)->isAlignedRad((ofVec2f const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Vec2f_isAlignedRad(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec2f_isAlignedRad__SWIG_1(L);} } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Vec2f_isAlignedRad__SWIG_0(L);} - } } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec2f_isAlignedRad'\n" - " Possible C/C++ prototypes are:\n" " ofVec2f::isAlignedRad(ofVec2f const &,float) const\n" - " ofVec2f::isAlignedRad(ofVec2f const &) const\n"); lua_error(L);return 0; } + return _wrap_Vec2f_isAlignedRad__SWIG_1(L);} if (argc == 3) { return _wrap_Vec2f_isAlignedRad__SWIG_0(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec2f_isAlignedRad'\n" " Possible C/C++ prototypes are:\n" + " ofVec2f::isAlignedRad(ofVec2f const &,float) const\n" " ofVec2f::isAlignedRad(ofVec2f const &) const\n"); + lua_error(L);return 0; } static int _wrap_Vec2f_align__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f *arg2 = 0 ; float arg3 ; bool result; SWIG_check_num_args("ofVec2f::align",3,3) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::align",1,"ofVec2f const *"); @@ -20753,16 +23059,9 @@ static int _wrap_Vec2f_align__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec2f * if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_align",2,SWIGTYPE_p_ofVec2f); } result = (bool)((ofVec2f const *)arg1)->align((ofVec2f const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_align(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec2f_align__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Vec2f_align__SWIG_0(L);} } } - } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec2f_align'\n" " Possible C/C++ prototypes are:\n" +static int _wrap_Vec2f_align(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { + return _wrap_Vec2f_align__SWIG_1(L);} if (argc == 3) { return _wrap_Vec2f_align__SWIG_0(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec2f_align'\n" " Possible C/C++ prototypes are:\n" " ofVec2f::align(ofVec2f const &,float) const\n" " ofVec2f::align(ofVec2f const &) const\n"); lua_error(L);return 0; } static int _wrap_Vec2f_alignRad__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f *arg2 = 0 ; float arg3 ; bool result; SWIG_check_num_args("ofVec2f::alignRad",3,3) @@ -20786,18 +23085,10 @@ static int _wrap_Vec2f_alignRad__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec2 result = (bool)((ofVec2f const *)arg1)->alignRad((ofVec2f const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Vec2f_alignRad(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec2f_alignRad__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Vec2f_alignRad__SWIG_0(L);} } - } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec2f_alignRad'\n" - " Possible C/C++ prototypes are:\n" " ofVec2f::alignRad(ofVec2f const &,float) const\n" - " ofVec2f::alignRad(ofVec2f const &) const\n"); lua_error(L);return 0; } + return _wrap_Vec2f_alignRad__SWIG_1(L);} if (argc == 3) { return _wrap_Vec2f_alignRad__SWIG_0(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec2f_alignRad'\n" " Possible C/C++ prototypes are:\n" + " ofVec2f::alignRad(ofVec2f const &,float) const\n" " ofVec2f::alignRad(ofVec2f const &) const\n"); + lua_error(L);return 0; } static int _wrap_Vec2f___add__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f *arg2 = 0 ; ofVec2f result; SWIG_check_num_args("ofVec2f::operator +",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::operator +",1,"ofVec2f const *"); @@ -20817,13 +23108,11 @@ static int _wrap_Vec2f___add__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec2f * ofVec2f * resultptr = new ofVec2f((const ofVec2f &) result); SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f___add(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec2f___add__SWIG_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Vec2f___add__SWIG_1(L);} } } +static int _wrap_Vec2f___add(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v = 0; + { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec2f, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_Vec2f___add__SWIG_0(L);} check_1: + if (argc == 2) { return _wrap_Vec2f___add__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec2f___add'\n" " Possible C/C++ prototypes are:\n" " ofVec2f::operator +(ofVec2f const &) const\n" " ofVec2f::operator +(float const) const\n"); lua_error(L);return 0; } static int _wrap_Vec2f___sub__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f *arg2 = 0 ; @@ -20845,13 +23134,11 @@ static int _wrap_Vec2f___sub__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec2f * ofVec2f * resultptr = new ofVec2f((const ofVec2f &) result); SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f___sub(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec2f___sub__SWIG_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Vec2f___sub__SWIG_1(L);} } } +static int _wrap_Vec2f___sub(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v = 0; + { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec2f, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_Vec2f___sub__SWIG_0(L);} check_1: + if (argc == 2) { return _wrap_Vec2f___sub__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec2f___sub'\n" " Possible C/C++ prototypes are:\n" " ofVec2f::operator -(ofVec2f const &) const\n" " ofVec2f::operator -(float const) const\n"); lua_error(L);return 0; } static int _wrap_Vec2f___unm(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f result; @@ -20880,13 +23167,11 @@ static int _wrap_Vec2f___mul__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec2f * ofVec2f * resultptr = new ofVec2f((const ofVec2f &) result); SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f___mul(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec2f___mul__SWIG_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Vec2f___mul__SWIG_1(L);} } } +static int _wrap_Vec2f___mul(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v = 0; + { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec2f, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_Vec2f___mul__SWIG_0(L);} check_1: + if (argc == 2) { return _wrap_Vec2f___mul__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec2f___mul'\n" " Possible C/C++ prototypes are:\n" " ofVec2f::operator *(ofVec2f const &) const\n" " ofVec2f::operator *(float const) const\n"); lua_error(L);return 0; } static int _wrap_Vec2f___div__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f *arg2 = 0 ; @@ -20908,13 +23193,11 @@ static int _wrap_Vec2f___div__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec2f * ofVec2f * resultptr = new ofVec2f((const ofVec2f &) result); SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f___div(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec2f___div__SWIG_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Vec2f___div__SWIG_1(L);} } } +static int _wrap_Vec2f___div(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v = 0; + { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec2f, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_Vec2f___div__SWIG_0(L);} check_1: + if (argc == 2) { return _wrap_Vec2f___div__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec2f___div'\n" " Possible C/C++ prototypes are:\n" " ofVec2f::operator /(ofVec2f const &) const\n" " ofVec2f::operator /(float const) const\n"); lua_error(L);return 0; } static int _wrap_Vec2f_getScaled(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; float arg2 ; ofVec2f result; @@ -20957,14 +23240,7 @@ static int _wrap_Vec2f_getRotated__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVe SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Vec2f_getRotated(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Vec2f_getRotated__SWIG_0(L);} } } - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec2f_getRotated__SWIG_1(L);} } } } + return _wrap_Vec2f_getRotated__SWIG_0(L);} if (argc == 3) { return _wrap_Vec2f_getRotated__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec2f_getRotated'\n" " Possible C/C++ prototypes are:\n" " ofVec2f::getRotated(float) const\n" " ofVec2f::getRotated(float,ofVec2f const &) const\n"); lua_error(L);return 0; } static int _wrap_Vec2f_getRotatedRad__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; float arg2 ; @@ -20990,14 +23266,7 @@ static int _wrap_Vec2f_getRotatedRad__SWIG_1(lua_State* L) { int SWIG_arg = 0; o SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Vec2f_getRotatedRad(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Vec2f_getRotatedRad__SWIG_0(L);} } } - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec2f_getRotatedRad__SWIG_1(L);} } } } + return _wrap_Vec2f_getRotatedRad__SWIG_0(L);} if (argc == 3) { return _wrap_Vec2f_getRotatedRad__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec2f_getRotatedRad'\n" " Possible C/C++ prototypes are:\n" " ofVec2f::getRotatedRad(float) const\n" " ofVec2f::getRotatedRad(float,ofVec2f const &) const\n"); lua_error(L);return 0; } @@ -21019,14 +23288,8 @@ static int _wrap_Vec2f_rotate__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec2f SWIG_fail_ptr("Vec2f_rotate",3,SWIGTYPE_p_ofVec2f); } result = (ofVec2f *) &(arg1)->rotate(arg2,(ofVec2f const &)*arg3); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec2f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_rotate(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Vec2f_rotate__SWIG_0(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec2f_rotate__SWIG_1(L);} } } } +static int _wrap_Vec2f_rotate(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { + return _wrap_Vec2f_rotate__SWIG_0(L);} if (argc == 3) { return _wrap_Vec2f_rotate__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec2f_rotate'\n" " Possible C/C++ prototypes are:\n" " ofVec2f::rotate(float)\n" " ofVec2f::rotate(float,ofVec2f const &)\n"); lua_error(L);return 0; } static int _wrap_Vec2f_rotateRad__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; float arg2 ; @@ -21050,14 +23313,7 @@ static int _wrap_Vec2f_rotateRad__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec2f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Vec2f_rotateRad(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Vec2f_rotateRad__SWIG_0(L);} } } - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec2f_rotateRad__SWIG_1(L);} } } } + return _wrap_Vec2f_rotateRad__SWIG_0(L);} if (argc == 3) { return _wrap_Vec2f_rotateRad__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec2f_rotateRad'\n" " Possible C/C++ prototypes are:\n" " ofVec2f::rotateRad(float)\n" " ofVec2f::rotateRad(float,ofVec2f const &)\n"); lua_error(L);return 0; } static int _wrap_Vec2f_getMapped(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f *arg2 = 0 ; @@ -21259,6 +23515,12 @@ static int _wrap_Vec2f_one(lua_State* L) { int SWIG_arg = 0; ofVec2f result; SWI result = ofVec2f::one(); { ofVec2f * resultptr = new ofVec2f((const ofVec2f &) result); SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Vec2f_vec2(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; glm::vec2 result; + SWIG_check_num_args("ofVec2f::vec2",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::vec2",1,"ofVec2f *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_vec2",1,SWIGTYPE_p_ofVec2f); } + result = ofVec2f_vec2(arg1); { glm::vec2 * resultptr = new glm::vec2((const glm::vec2 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } static int _wrap_Vec2f___tostring(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; char *result = 0 ; SWIG_check_num_args("ofVec2f::__str__",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::__str__",1,"ofVec2f *"); if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ @@ -21321,6 +23583,7 @@ static swig_lua_method swig_Vec2f_methods[]= { { "getPerpendicular", _wrap_Vec2f_getPerpendicular}, { "perpendicular", _wrap_Vec2f_perpendicular}, { "dot", _wrap_Vec2f_dot}, + { "vec2", _wrap_Vec2f_vec2}, { "__tostring", _wrap_Vec2f___tostring}, {0,0} }; @@ -21448,26 +23711,27 @@ static int _wrap_new_Vec3f__SWIG_8(lua_State* L) { int SWIG_arg = 0; glm::vec4 * SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_new_Vec3f(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_Vec3f__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_new_Vec3f__SWIG_4(L);} } if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_new_Vec3f__SWIG_5(L);} } if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_new_Vec3f__SWIG_6(L);} } if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_new_Vec3f__SWIG_7(L);} } if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_new_Vec3f__SWIG_8(L);} } if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_new_Vec3f__SWIG_3(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_new_Vec3f__SWIG_2(L);} - } } if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_new_Vec3f__SWIG_1(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_Vec3f'\n" " Possible C/C++ prototypes are:\n" - " ofVec3f::ofVec3f()\n" " ofVec3f::ofVec3f(float,float,float)\n" " ofVec3f::ofVec3f(float,float)\n" - " ofVec3f::ofVec3f(float)\n" " ofVec3f::ofVec3f(ofVec2f const &)\n" " ofVec3f::ofVec3f(ofVec4f const &)\n" - " ofVec3f::ofVec3f(glm::vec2 const &)\n" " ofVec3f::ofVec3f(glm::vec3 const &)\n" - " ofVec3f::ofVec3f(glm::vec4 const &)\n"); lua_error(L);return 0; } + return _wrap_new_Vec3f__SWIG_0(L);} if (argc == 1) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_new_Vec3f__SWIG_4(L);} check_2: + if (argc == 1) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec4f, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; return _wrap_new_Vec3f__SWIG_5(L);} check_3: + if (argc == 1) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_4; return _wrap_new_Vec3f__SWIG_6(L);} check_4: + if (argc == 1) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_5; return _wrap_new_Vec3f__SWIG_7(L);} check_5: + if (argc == 1) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_6; return _wrap_new_Vec3f__SWIG_8(L);} check_6: + if (argc == 1) { return _wrap_new_Vec3f__SWIG_3(L);} if (argc == 2) { return _wrap_new_Vec3f__SWIG_2(L);} if (argc == 3) { + return _wrap_new_Vec3f__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_Vec3f'\n" + " Possible C/C++ prototypes are:\n" " ofVec3f::ofVec3f()\n" " ofVec3f::ofVec3f(float,float,float)\n" + " ofVec3f::ofVec3f(float,float)\n" " ofVec3f::ofVec3f(float)\n" " ofVec3f::ofVec3f(ofVec2f const &)\n" + " ofVec3f::ofVec3f(ofVec4f const &)\n" " ofVec3f::ofVec3f(glm::vec2 const &)\n" + " ofVec3f::ofVec3f(glm::vec3 const &)\n" " ofVec3f::ofVec3f(glm::vec4 const &)\n"); lua_error(L);return 0; } static int _wrap_Vec3f_getPtr__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float *result = 0 ; SWIG_check_num_args("ofVec3f::getPtr",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::getPtr",1,"ofVec3f *"); if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_getPtr",1,SWIGTYPE_p_ofVec3f); } @@ -21478,11 +23742,8 @@ static int _wrap_Vec3f_getPtr__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec3f if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_getPtr",1,SWIGTYPE_p_ofVec3f); } result = (float *)((ofVec3f const *)arg1)->getPtr(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_float,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_getPtr(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Vec3f_getPtr__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Vec3f_getPtr__SWIG_1(L);} } +static int _wrap_Vec3f_getPtr(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { + return _wrap_Vec3f_getPtr__SWIG_0(L);} if (argc == 1) { return _wrap_Vec3f_getPtr__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec3f_getPtr'\n" " Possible C/C++ prototypes are:\n" " ofVec3f::getPtr()\n" " ofVec3f::getPtr() const\n"); lua_error(L);return 0; } static int _wrap_Vec3f_set__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float arg2 ; float arg3 ; @@ -21511,23 +23772,14 @@ static int _wrap_Vec3f_set__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofVec3f *ar if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec3f::set",2,"float"); if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_set",1,SWIGTYPE_p_ofVec3f); } arg2 = (float)lua_tonumber(L, 2); (arg1)->set(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_set(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec3f_set__SWIG_2(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Vec3f_set__SWIG_3(L);} } } - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Vec3f_set__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Vec3f_set__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec3f_set'\n" " Possible C/C++ prototypes are:\n" - " ofVec3f::set(float,float,float)\n" " ofVec3f::set(float,float)\n" " ofVec3f::set(ofVec3f const &)\n" - " ofVec3f::set(float)\n"); lua_error(L);return 0; } +static int _wrap_Vec3f_set(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_Vec3f_set__SWIG_2(L);} check_1: + if (argc == 2) { return _wrap_Vec3f_set__SWIG_3(L);} if (argc == 3) { return _wrap_Vec3f_set__SWIG_1(L);} if (argc == 4) { + return _wrap_Vec3f_set__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec3f_set'\n" + " Possible C/C++ prototypes are:\n" " ofVec3f::set(float,float,float)\n" " ofVec3f::set(float,float)\n" + " ofVec3f::set(ofVec3f const &)\n" " ofVec3f::set(float)\n"); lua_error(L);return 0; } static int _wrap_Vec3f___eq(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; bool result; SWIG_check_num_args("ofVec3f::operator ==",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::operator ==",1,"ofVec3f const *"); @@ -21553,16 +23805,9 @@ static int _wrap_Vec3f_match__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec3f * if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_match",2,SWIGTYPE_p_ofVec3f); } result = (bool)((ofVec3f const *)arg1)->match((ofVec3f const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_match(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec3f_match__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Vec3f_match__SWIG_0(L);} } } - } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec3f_match'\n" " Possible C/C++ prototypes are:\n" +static int _wrap_Vec3f_match(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { + return _wrap_Vec3f_match__SWIG_1(L);} if (argc == 3) { return _wrap_Vec3f_match__SWIG_0(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec3f_match'\n" " Possible C/C++ prototypes are:\n" " ofVec3f::match(ofVec3f const &,float) const\n" " ofVec3f::match(ofVec3f const &) const\n"); lua_error(L);return 0; } static int _wrap_Vec3f_isAligned__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; float arg3 ; bool result; SWIG_check_num_args("ofVec3f::isAligned",3,3) @@ -21586,18 +23831,10 @@ static int _wrap_Vec3f_isAligned__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec result = (bool)((ofVec3f const *)arg1)->isAligned((ofVec3f const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Vec3f_isAligned(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec3f_isAligned__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Vec3f_isAligned__SWIG_0(L);} } - } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec3f_isAligned'\n" - " Possible C/C++ prototypes are:\n" " ofVec3f::isAligned(ofVec3f const &,float) const\n" - " ofVec3f::isAligned(ofVec3f const &) const\n"); lua_error(L);return 0; } + return _wrap_Vec3f_isAligned__SWIG_1(L);} if (argc == 3) { return _wrap_Vec3f_isAligned__SWIG_0(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec3f_isAligned'\n" " Possible C/C++ prototypes are:\n" + " ofVec3f::isAligned(ofVec3f const &,float) const\n" " ofVec3f::isAligned(ofVec3f const &) const\n"); + lua_error(L);return 0; } static int _wrap_Vec3f_isAlignedRad__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; float arg3 ; bool result; SWIG_check_num_args("ofVec3f::isAlignedRad",3,3) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::isAlignedRad",1,"ofVec3f const *"); @@ -21620,18 +23857,10 @@ static int _wrap_Vec3f_isAlignedRad__SWIG_1(lua_State* L) { int SWIG_arg = 0; of result = (bool)((ofVec3f const *)arg1)->isAlignedRad((ofVec3f const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Vec3f_isAlignedRad(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec3f_isAlignedRad__SWIG_1(L);} } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Vec3f_isAlignedRad__SWIG_0(L);} - } } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec3f_isAlignedRad'\n" - " Possible C/C++ prototypes are:\n" " ofVec3f::isAlignedRad(ofVec3f const &,float) const\n" - " ofVec3f::isAlignedRad(ofVec3f const &) const\n"); lua_error(L);return 0; } + return _wrap_Vec3f_isAlignedRad__SWIG_1(L);} if (argc == 3) { return _wrap_Vec3f_isAlignedRad__SWIG_0(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec3f_isAlignedRad'\n" " Possible C/C++ prototypes are:\n" + " ofVec3f::isAlignedRad(ofVec3f const &,float) const\n" " ofVec3f::isAlignedRad(ofVec3f const &) const\n"); + lua_error(L);return 0; } static int _wrap_Vec3f_align__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; float arg3 ; bool result; SWIG_check_num_args("ofVec3f::align",3,3) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::align",1,"ofVec3f const *"); @@ -21649,16 +23878,9 @@ static int _wrap_Vec3f_align__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec3f * if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_align",2,SWIGTYPE_p_ofVec3f); } result = (bool)((ofVec3f const *)arg1)->align((ofVec3f const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_align(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec3f_align__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Vec3f_align__SWIG_0(L);} } } - } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec3f_align'\n" " Possible C/C++ prototypes are:\n" +static int _wrap_Vec3f_align(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { + return _wrap_Vec3f_align__SWIG_1(L);} if (argc == 3) { return _wrap_Vec3f_align__SWIG_0(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec3f_align'\n" " Possible C/C++ prototypes are:\n" " ofVec3f::align(ofVec3f const &,float) const\n" " ofVec3f::align(ofVec3f const &) const\n"); lua_error(L);return 0; } static int _wrap_Vec3f_alignRad__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; float arg3 ; bool result; SWIG_check_num_args("ofVec3f::alignRad",3,3) @@ -21682,18 +23904,10 @@ static int _wrap_Vec3f_alignRad__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec3 result = (bool)((ofVec3f const *)arg1)->alignRad((ofVec3f const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Vec3f_alignRad(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec3f_alignRad__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Vec3f_alignRad__SWIG_0(L);} } - } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec3f_alignRad'\n" - " Possible C/C++ prototypes are:\n" " ofVec3f::alignRad(ofVec3f const &,float) const\n" - " ofVec3f::alignRad(ofVec3f const &) const\n"); lua_error(L);return 0; } + return _wrap_Vec3f_alignRad__SWIG_1(L);} if (argc == 3) { return _wrap_Vec3f_alignRad__SWIG_0(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec3f_alignRad'\n" " Possible C/C++ prototypes are:\n" + " ofVec3f::alignRad(ofVec3f const &,float) const\n" " ofVec3f::alignRad(ofVec3f const &) const\n"); + lua_error(L);return 0; } static int _wrap_Vec3f___add__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; ofVec3f result; SWIG_check_num_args("ofVec3f::operator +",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::operator +",1,"ofVec3f const *"); @@ -21713,13 +23927,11 @@ static int _wrap_Vec3f___add__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec3f * ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f___add(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec3f___add__SWIG_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Vec3f___add__SWIG_1(L);} } } +static int _wrap_Vec3f___add(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v = 0; + { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_Vec3f___add__SWIG_0(L);} check_1: + if (argc == 2) { return _wrap_Vec3f___add__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec3f___add'\n" " Possible C/C++ prototypes are:\n" " ofVec3f::operator +(ofVec3f const &) const\n" " ofVec3f::operator +(float const) const\n"); lua_error(L);return 0; } static int _wrap_Vec3f___sub__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; @@ -21741,13 +23953,11 @@ static int _wrap_Vec3f___sub__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec3f * ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f___sub(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec3f___sub__SWIG_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Vec3f___sub__SWIG_1(L);} } } +static int _wrap_Vec3f___sub(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v = 0; + { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_Vec3f___sub__SWIG_0(L);} check_1: + if (argc == 2) { return _wrap_Vec3f___sub__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec3f___sub'\n" " Possible C/C++ prototypes are:\n" " ofVec3f::operator -(ofVec3f const &) const\n" " ofVec3f::operator -(float const) const\n"); lua_error(L);return 0; } static int _wrap_Vec3f___unm(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f result; @@ -21776,13 +23986,11 @@ static int _wrap_Vec3f___mul__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec3f * ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f___mul(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec3f___mul__SWIG_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Vec3f___mul__SWIG_1(L);} } } +static int _wrap_Vec3f___mul(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v = 0; + { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_Vec3f___mul__SWIG_0(L);} check_1: + if (argc == 2) { return _wrap_Vec3f___mul__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec3f___mul'\n" " Possible C/C++ prototypes are:\n" " ofVec3f::operator *(ofVec3f const &) const\n" " ofVec3f::operator *(float const) const\n"); lua_error(L);return 0; } static int _wrap_Vec3f___div__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; @@ -21804,13 +24012,11 @@ static int _wrap_Vec3f___div__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec3f * ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f___div(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec3f___div__SWIG_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Vec3f___div__SWIG_1(L);} } } +static int _wrap_Vec3f___div(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v = 0; + { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_Vec3f___div__SWIG_0(L);} check_1: + if (argc == 2) { return _wrap_Vec3f___div__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec3f___div'\n" " Possible C/C++ prototypes are:\n" " ofVec3f::operator /(ofVec3f const &) const\n" " ofVec3f::operator /(float const) const\n"); lua_error(L);return 0; } static int _wrap_Vec3f_getScaled(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float arg2 ; ofVec3f result; @@ -21872,20 +24078,12 @@ static int _wrap_Vec3f_getRotated__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofVe SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Vec3f_getRotated(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec3f_getRotated__SWIG_0(L);} } } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec3f_getRotated__SWIG_2(L);} } } } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Vec3f_getRotated__SWIG_1(L);} } } } } + return _wrap_Vec3f_getRotated__SWIG_0(L);} if (argc == 4) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; { { void *ptr; + if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofVec3f, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_Vec3f_getRotated__SWIG_2(L);} check_2: + if (argc == 4) { return _wrap_Vec3f_getRotated__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec3f_getRotated'\n" " Possible C/C++ prototypes are:\n" " ofVec3f::getRotated(float,ofVec3f const &) const\n" " ofVec3f::getRotated(float,float,float) const\n" " ofVec3f::getRotated(float,ofVec3f const &,ofVec3f const &) const\n"); lua_error(L);return 0; } @@ -21932,20 +24130,12 @@ static int _wrap_Vec3f_getRotatedRad__SWIG_2(lua_State* L) { int SWIG_arg = 0; o SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Vec3f_getRotatedRad(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec3f_getRotatedRad__SWIG_0(L);} } } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec3f_getRotatedRad__SWIG_2(L);} } } } } if (argc == 4) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Vec3f_getRotatedRad__SWIG_1(L);} } } } } + return _wrap_Vec3f_getRotatedRad__SWIG_0(L);} if (argc == 4) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; { { void *ptr; + if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofVec3f, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_Vec3f_getRotatedRad__SWIG_2(L);} check_2: + if (argc == 4) { return _wrap_Vec3f_getRotatedRad__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec3f_getRotatedRad'\n" " Possible C/C++ prototypes are:\n" " ofVec3f::getRotatedRad(float,ofVec3f const &) const\n" " ofVec3f::getRotatedRad(float,float,float) const\n" @@ -21984,20 +24174,12 @@ static int _wrap_Vec3f_rotate__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofVec3f SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Vec3f_rotate(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec3f_rotate__SWIG_0(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec3f_rotate__SWIG_2(L);} } } } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Vec3f_rotate__SWIG_1(L);} } } } } + return _wrap_Vec3f_rotate__SWIG_0(L);} if (argc == 4) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; { { void *ptr; + if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofVec3f, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_Vec3f_rotate__SWIG_2(L);} check_2: + if (argc == 4) { return _wrap_Vec3f_rotate__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec3f_rotate'\n" " Possible C/C++ prototypes are:\n" " ofVec3f::rotate(float,ofVec3f const &)\n" " ofVec3f::rotate(float,float,float)\n" " ofVec3f::rotate(float,ofVec3f const &,ofVec3f const &)\n"); lua_error(L);return 0; } @@ -22040,20 +24222,12 @@ static int _wrap_Vec3f_rotateRad__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofVec SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Vec3f_rotateRad(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec3f_rotateRad__SWIG_0(L);} } } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec3f_rotateRad__SWIG_2(L);} } } } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Vec3f_rotateRad__SWIG_1(L);} } } } } + return _wrap_Vec3f_rotateRad__SWIG_0(L);} if (argc == 4) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; { { void *ptr; + if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofVec3f, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_Vec3f_rotateRad__SWIG_2(L);} check_2: + if (argc == 4) { return _wrap_Vec3f_rotateRad__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec3f_rotateRad'\n" " Possible C/C++ prototypes are:\n" " ofVec3f::rotateRad(float,ofVec3f const &)\n" " ofVec3f::rotateRad(float,float,float)\n" " ofVec3f::rotateRad(float,ofVec3f const &,ofVec3f const &)\n"); lua_error(L);return 0; } @@ -22288,6 +24462,12 @@ static int _wrap_Vec3f_one(lua_State* L) { int SWIG_arg = 0; ofVec3f result; SWI result = ofVec3f::one(); { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Vec3f_vec3(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; glm::vec3 result; + SWIG_check_num_args("ofVec3f::vec3",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::vec3",1,"ofVec3f *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_vec3",1,SWIGTYPE_p_ofVec3f); } + result = ofVec3f_vec3(arg1); { glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } static int _wrap_Vec3f___tostring(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; char *result = 0 ; SWIG_check_num_args("ofVec3f::__str__",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::__str__",1,"ofVec3f *"); if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ @@ -22353,6 +24533,7 @@ static swig_lua_method swig_Vec3f_methods[]= { { "getCrossed", _wrap_Vec3f_getCrossed}, { "cross", _wrap_Vec3f_cross}, { "dot", _wrap_Vec3f_dot}, + { "vec3", _wrap_Vec3f_vec3}, { "__tostring", _wrap_Vec3f___tostring}, {0,0} }; @@ -22486,20 +24667,22 @@ static int _wrap_new_Vec4f__SWIG_7(lua_State* L) { int SWIG_arg = 0; glm::vec4 * SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec4f,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_new_Vec4f(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_Vec4f__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_new_Vec4f__SWIG_3(L);} } if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_new_Vec4f__SWIG_4(L);} } if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_new_Vec4f__SWIG_5(L);} } if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_new_Vec4f__SWIG_6(L);} } if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_new_Vec4f__SWIG_7(L);} } if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_new_Vec4f__SWIG_1(L);} } if (argc == 4) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_new_Vec4f__SWIG_2(L);} } } } } + return _wrap_new_Vec4f__SWIG_0(L);} if (argc == 1) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_new_Vec4f__SWIG_3(L);} check_2: + if (argc == 1) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; return _wrap_new_Vec4f__SWIG_4(L);} check_3: + if (argc == 1) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_4; return _wrap_new_Vec4f__SWIG_5(L);} check_4: + if (argc == 1) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_5; return _wrap_new_Vec4f__SWIG_6(L);} check_5: + if (argc == 1) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_6; return _wrap_new_Vec4f__SWIG_7(L);} check_6: + if (argc == 1) { return _wrap_new_Vec4f__SWIG_1(L);} if (argc == 4) { return _wrap_new_Vec4f__SWIG_2(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_Vec4f'\n" " Possible C/C++ prototypes are:\n" " ofVec4f::ofVec4f()\n" " ofVec4f::ofVec4f(float)\n" " ofVec4f::ofVec4f(float,float,float,float)\n" " ofVec4f::ofVec4f(ofVec2f const &)\n" " ofVec4f::ofVec4f(ofVec3f const &)\n" @@ -22515,11 +24698,8 @@ static int _wrap_Vec4f_getPtr__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec4f if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f_getPtr",1,SWIGTYPE_p_ofVec4f); } result = (float *)((ofVec4f const *)arg1)->getPtr(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_float,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f_getPtr(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Vec4f_getPtr__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Vec4f_getPtr__SWIG_1(L);} } +static int _wrap_Vec4f_getPtr(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { + return _wrap_Vec4f_getPtr__SWIG_0(L);} if (argc == 1) { return _wrap_Vec4f_getPtr__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec4f_getPtr'\n" " Possible C/C++ prototypes are:\n" " ofVec4f::getPtr()\n" " ofVec4f::getPtr() const\n"); lua_error(L);return 0; } static int _wrap_Vec4f_set__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; float arg2 ; @@ -22544,18 +24724,11 @@ static int _wrap_Vec4f_set__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofVec4f *ar if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f_set",1,SWIGTYPE_p_ofVec4f); } if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f_set",2,SWIGTYPE_p_ofVec4f); } (arg1)->set((ofVec4f const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f_set(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 2) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec4f_set__SWIG_2(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Vec4f_set__SWIG_0(L);} } } - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Vec4f_set__SWIG_1(L);} } } } } } +static int _wrap_Vec4f_set(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec4f, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_Vec4f_set__SWIG_2(L);} check_1: + if (argc == 2) { return _wrap_Vec4f_set__SWIG_0(L);} if (argc == 5) { return _wrap_Vec4f_set__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec4f_set'\n" " Possible C/C++ prototypes are:\n" " ofVec4f::set(float)\n" " ofVec4f::set(float,float,float,float)\n" " ofVec4f::set(ofVec4f const &)\n"); lua_error(L);return 0; } @@ -22584,16 +24757,9 @@ static int _wrap_Vec4f_match__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec4f * if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f_match",2,SWIGTYPE_p_ofVec4f); } result = (bool)((ofVec4f const *)arg1)->match((ofVec4f const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f_match(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec4f_match__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Vec4f_match__SWIG_0(L);} } } - } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec4f_match'\n" " Possible C/C++ prototypes are:\n" +static int _wrap_Vec4f_match(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { + return _wrap_Vec4f_match__SWIG_1(L);} if (argc == 3) { return _wrap_Vec4f_match__SWIG_0(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec4f_match'\n" " Possible C/C++ prototypes are:\n" " ofVec4f::match(ofVec4f const &,float) const\n" " ofVec4f::match(ofVec4f const &) const\n"); lua_error(L);return 0; } static int _wrap_Vec4f___add__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; ofVec4f *arg2 = 0 ; ofVec4f result; SWIG_check_num_args("ofVec4f::operator +",2,2) @@ -22614,13 +24780,11 @@ static int _wrap_Vec4f___add__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec4f * ofVec4f * resultptr = new ofVec4f((const ofVec4f &) result); SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec4f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f___add(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec4f___add__SWIG_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Vec4f___add__SWIG_1(L);} } } +static int _wrap_Vec4f___add(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v = 0; + { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec4f, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_Vec4f___add__SWIG_0(L);} check_1: + if (argc == 2) { return _wrap_Vec4f___add__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec4f___add'\n" " Possible C/C++ prototypes are:\n" " ofVec4f::operator +(ofVec4f const &) const\n" " ofVec4f::operator +(float const) const\n"); lua_error(L);return 0; } static int _wrap_Vec4f___sub__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; float arg2 ; @@ -22642,13 +24806,11 @@ static int _wrap_Vec4f___sub__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec4f * ofVec4f * resultptr = new ofVec4f((const ofVec4f &) result); SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec4f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f___sub(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec4f___sub__SWIG_1(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Vec4f___sub__SWIG_0(L);} } } +static int _wrap_Vec4f___sub(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v = 0; + { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec4f, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_Vec4f___sub__SWIG_1(L);} check_1: + if (argc == 2) { return _wrap_Vec4f___sub__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec4f___sub'\n" " Possible C/C++ prototypes are:\n" " ofVec4f::operator -(float const) const\n" " ofVec4f::operator -(ofVec4f const &) const\n"); lua_error(L);return 0; } static int _wrap_Vec4f___unm(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; ofVec4f result; @@ -22677,13 +24839,11 @@ static int _wrap_Vec4f___mul__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec4f * ofVec4f * resultptr = new ofVec4f((const ofVec4f &) result); SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec4f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f___mul(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec4f___mul__SWIG_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Vec4f___mul__SWIG_1(L);} } } +static int _wrap_Vec4f___mul(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v = 0; + { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec4f, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_Vec4f___mul__SWIG_0(L);} check_1: + if (argc == 2) { return _wrap_Vec4f___mul__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec4f___mul'\n" " Possible C/C++ prototypes are:\n" " ofVec4f::operator *(ofVec4f const &) const\n" " ofVec4f::operator *(float const) const\n"); lua_error(L);return 0; } static int _wrap_Vec4f___div__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; ofVec4f *arg2 = 0 ; @@ -22705,13 +24865,11 @@ static int _wrap_Vec4f___div__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec4f * ofVec4f * resultptr = new ofVec4f((const ofVec4f &) result); SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec4f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f___div(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec4f___div__SWIG_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Vec4f___div__SWIG_1(L);} } } +static int _wrap_Vec4f___div(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v = 0; + { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec4f, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_Vec4f___div__SWIG_0(L);} check_1: + if (argc == 2) { return _wrap_Vec4f___div__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec4f___div'\n" " Possible C/C++ prototypes are:\n" " ofVec4f::operator /(ofVec4f const &) const\n" " ofVec4f::operator /(float const) const\n"); lua_error(L);return 0; } static int _wrap_Vec4f_getScaled(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; float arg2 ; ofVec4f result; @@ -22866,6 +25024,12 @@ static int _wrap_Vec4f_one(lua_State* L) { int SWIG_arg = 0; ofVec4f result; SWI result = ofVec4f::one(); { ofVec4f * resultptr = new ofVec4f((const ofVec4f &) result); SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec4f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Vec4f_vec4(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; glm::vec4 result; + SWIG_check_num_args("ofVec4f::vec4",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::vec4",1,"ofVec4f *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f_vec4",1,SWIGTYPE_p_ofVec4f); } + result = ofVec4f_vec4(arg1); { glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } static int _wrap_Vec4f___tostring(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; char *result = 0 ; SWIG_check_num_args("ofVec4f::__str__",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::__str__",1,"ofVec4f *"); if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ @@ -22916,6 +25080,7 @@ static swig_lua_method swig_Vec4f_methods[]= { { "length", _wrap_Vec4f_length}, { "lengthSquared", _wrap_Vec4f_lengthSquared}, { "dot", _wrap_Vec4f_dot}, + { "vec4", _wrap_Vec4f_vec4}, { "__tostring", _wrap_Vec4f___tostring}, {0,0} }; @@ -22966,8 +25131,7 @@ static int _wrap_getMousePressed__SWIG_1(lua_State* L) { int SWIG_arg = 0; bool SWIG_check_num_args("ofGetMousePressed",0,0) result = (bool)ofGetMousePressed(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_getMousePressed(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_getMousePressed__SWIG_1(L);} if (argc == 1) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { - return _wrap_getMousePressed__SWIG_0(L);} } + return _wrap_getMousePressed__SWIG_1(L);} if (argc == 1) { return _wrap_getMousePressed__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'getMousePressed'\n" " Possible C/C++ prototypes are:\n" " ofGetMousePressed(int)\n" " ofGetMousePressed()\n"); lua_error(L);return 0; } static int _wrap_getKeyPressed__SWIG_0(lua_State* L) { int SWIG_arg = 0; int arg1 ; bool result; @@ -22978,8 +25142,7 @@ static int _wrap_getKeyPressed__SWIG_1(lua_State* L) { int SWIG_arg = 0; bool re result = (bool)ofGetKeyPressed(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_getKeyPressed(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_getKeyPressed__SWIG_1(L);} if (argc == 1) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { - return _wrap_getKeyPressed__SWIG_0(L);} } + return _wrap_getKeyPressed__SWIG_1(L);} if (argc == 1) { return _wrap_getKeyPressed__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'getKeyPressed'\n" " Possible C/C++ prototypes are:\n" " ofGetKeyPressed(int)\n" " ofGetKeyPressed()\n"); lua_error(L);return 0; } static int _wrap_getMouseX(lua_State* L) { int SWIG_arg = 0; int result; SWIG_check_num_args("ofGetMouseX",0,0) @@ -23010,23 +25173,22 @@ static int _wrap_DragInfo_files_get(lua_State* L) { int SWIG_arg = 0; ofDragInfo SWIG_fail_ptr("DragInfo_files_get",1,SWIGTYPE_p_ofDragInfo); } result = (std::vector< std::string > *)& ((arg1)->files); SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_std__string_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_DragInfo_position_set(lua_State* L) { int SWIG_arg = 0; ofDragInfo *arg1 = (ofDragInfo *) 0 ; glm::vec2 arg2 ; - glm::vec2 *argp2 ; SWIG_check_num_args("ofDragInfo::position",2,2) +static int _wrap_DragInfo_position_set(lua_State* L) { int SWIG_arg = 0; ofDragInfo *arg1 = (ofDragInfo *) 0 ; + glm::vec2 *arg2 = (glm::vec2 *) 0 ; SWIG_check_num_args("ofDragInfo::position",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDragInfo::position",1,"ofDragInfo *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofDragInfo::position",2,"glm::vec2"); + if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofDragInfo::position",2,"glm::vec2 *"); if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDragInfo,0))){ SWIG_fail_ptr("DragInfo_position_set",1,SWIGTYPE_p_ofDragInfo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_glm__vec2,0))){ - SWIG_fail_ptr("DragInfo_position_set",2,SWIGTYPE_p_glm__vec2); } arg2 = *argp2; if (arg1) (arg1)->position = arg2; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_DragInfo_position_get(lua_State* L) { int SWIG_arg = 0; ofDragInfo *arg1 = (ofDragInfo *) 0 ; glm::vec2 result; - SWIG_check_num_args("ofDragInfo::position",1,1) + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec2,0))){ + SWIG_fail_ptr("DragInfo_position_set",2,SWIGTYPE_p_glm__vec2); } if (arg1) (arg1)->position = *arg2; return SWIG_arg; + if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_DragInfo_position_get(lua_State* L) { int SWIG_arg = 0; ofDragInfo *arg1 = (ofDragInfo *) 0 ; + glm::vec2 *result = 0 ; SWIG_check_num_args("ofDragInfo::position",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDragInfo::position",1,"ofDragInfo *"); if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDragInfo,0))){ - SWIG_fail_ptr("DragInfo_position_get",1,SWIGTYPE_p_ofDragInfo); } result = ((arg1)->position); { - glm::vec2 * resultptr = new glm::vec2((const glm::vec2 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } + SWIG_fail_ptr("DragInfo_position_get",1,SWIGTYPE_p_ofDragInfo); } result = (glm::vec2 *)& ((arg1)->position); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_glm__vec2,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } static int _wrap_new_DragInfo(lua_State* L) { int SWIG_arg = 0; ofDragInfo *result = 0 ; SWIG_check_num_args("ofDragInfo::ofDragInfo",0,0) result = (ofDragInfo *)new ofDragInfo(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofDragInfo,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); @@ -23095,9 +25257,7 @@ static int _wrap_new_TouchEventArgs__SWIG_1(lua_State* L) { int SWIG_arg = 0; of SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTouchEventArgs,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_new_TouchEventArgs(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_TouchEventArgs__SWIG_0(L);} if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_new_TouchEventArgs__SWIG_1(L);} } } } } + return _wrap_new_TouchEventArgs__SWIG_0(L);} if (argc == 4) { return _wrap_new_TouchEventArgs__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_TouchEventArgs'\n" " Possible C/C++ prototypes are:\n" " ofTouchEventArgs::ofTouchEventArgs()\n" " ofTouchEventArgs::ofTouchEventArgs(ofTouchEventArgs::Type,float,float,int)\n"); lua_error(L);return 0; } @@ -23285,6 +25445,39 @@ static int _wrap_TouchEventArgs_yaccel_get(lua_State* L) { int SWIG_arg = 0; ofT if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTouchEventArgs,0))){ SWIG_fail_ptr("TouchEventArgs_yaccel_get",1,SWIGTYPE_p_ofTouchEventArgs); } result = (float) ((arg1)->yaccel); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_TouchEventArgs___tostring(lua_State* L) { int SWIG_arg = 0; ofTouchEventArgs *arg1 = (ofTouchEventArgs *) 0 ; + char *result = 0 ; SWIG_check_num_args("ofTouchEventArgs::__str__",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTouchEventArgs::__str__",1,"ofTouchEventArgs *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTouchEventArgs,0))){ + SWIG_fail_ptr("TouchEventArgs___tostring",1,SWIGTYPE_p_ofTouchEventArgs); } + result = (char *)ofTouchEventArgs___str__(arg1); lua_pushstring(L,(const char *)result); SWIG_arg++; return SWIG_arg; + if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_TouchEventArgs_x_set(lua_State* L) { int SWIG_arg = 0; ofTouchEventArgs *arg1 = (ofTouchEventArgs *) 0 ; + float arg2 ; SWIG_check_num_args("ofTouchEventArgs::x",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTouchEventArgs::x",1,"ofTouchEventArgs *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTouchEventArgs::x",2,"float"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTouchEventArgs,0))){ + SWIG_fail_ptr("TouchEventArgs_x_set",1,SWIGTYPE_p_ofTouchEventArgs); } arg2 = (float)lua_tonumber(L, 2); + ofTouchEventArgs_x_set(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_TouchEventArgs_x_get(lua_State* L) { int SWIG_arg = 0; ofTouchEventArgs *arg1 = (ofTouchEventArgs *) 0 ; + float result; SWIG_check_num_args("ofTouchEventArgs::x",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTouchEventArgs::x",1,"ofTouchEventArgs *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTouchEventArgs,0))){ + SWIG_fail_ptr("TouchEventArgs_x_get",1,SWIGTYPE_p_ofTouchEventArgs); } result = (float)ofTouchEventArgs_x_get(arg1); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_TouchEventArgs_y_set(lua_State* L) { int SWIG_arg = 0; ofTouchEventArgs *arg1 = (ofTouchEventArgs *) 0 ; + float arg2 ; SWIG_check_num_args("ofTouchEventArgs::y",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTouchEventArgs::y",1,"ofTouchEventArgs *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTouchEventArgs::y",2,"float"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTouchEventArgs,0))){ + SWIG_fail_ptr("TouchEventArgs_y_set",1,SWIGTYPE_p_ofTouchEventArgs); } arg2 = (float)lua_tonumber(L, 2); + ofTouchEventArgs_y_set(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_TouchEventArgs_y_get(lua_State* L) { int SWIG_arg = 0; ofTouchEventArgs *arg1 = (ofTouchEventArgs *) 0 ; + float result; SWIG_check_num_args("ofTouchEventArgs::y",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTouchEventArgs::y",1,"ofTouchEventArgs *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTouchEventArgs,0))){ + SWIG_fail_ptr("TouchEventArgs_y_get",1,SWIGTYPE_p_ofTouchEventArgs); } result = (float)ofTouchEventArgs_y_get(arg1); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static void swig_delete_TouchEventArgs(void *obj) { ofTouchEventArgs *arg1 = (ofTouchEventArgs *) obj; delete arg1; @@ -23312,12 +25505,16 @@ static swig_lua_attribute swig_TouchEventArgs_attributes[] = { { "yspeed", _wrap_TouchEventArgs_yspeed_get, _wrap_TouchEventArgs_yspeed_set }, { "xaccel", _wrap_TouchEventArgs_xaccel_get, _wrap_TouchEventArgs_xaccel_set }, { "yaccel", _wrap_TouchEventArgs_yaccel_get, _wrap_TouchEventArgs_yaccel_set }, + { "x", _wrap_TouchEventArgs_x_get, _wrap_TouchEventArgs_x_set }, + { "y", _wrap_TouchEventArgs_y_get, _wrap_TouchEventArgs_y_set }, {0,0,0} }; static swig_lua_method swig_TouchEventArgs_methods[]= { + { "__tostring", _wrap_TouchEventArgs___tostring}, {0,0} }; static swig_lua_method swig_TouchEventArgs_meta[] = { + { "__tostring", _wrap_TouchEventArgs___tostring}, {0,0} }; @@ -23347,75 +25544,10 @@ static swig_lua_namespace swig_TouchEventArgs_Sf_SwigStatic = { swig_TouchEventArgs_Sf_SwigStatic_classes, 0 }; -static swig_lua_class *swig_TouchEventArgs_bases[] = {0}; -static const char *swig_TouchEventArgs_base_names[] = {0}; +static swig_lua_class *swig_TouchEventArgs_bases[] = {0,0}; +static const char *swig_TouchEventArgs_base_names[] = {"glm::vec2 *",0}; static swig_lua_class _wrap_class_TouchEventArgs = { "TouchEventArgs", "TouchEventArgs", &SWIGTYPE_p_ofTouchEventArgs,_proxy__wrap_new_TouchEventArgs, swig_delete_TouchEventArgs, swig_TouchEventArgs_methods, swig_TouchEventArgs_attributes, &swig_TouchEventArgs_Sf_SwigStatic, swig_TouchEventArgs_meta, swig_TouchEventArgs_bases, swig_TouchEventArgs_base_names }; -static int _wrap_new_WindowPosEventArgs__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofWindowPosEventArgs *result = 0 ; - SWIG_check_num_args("ofWindowPosEventArgs::ofWindowPosEventArgs",0,0) - result = (ofWindowPosEventArgs *)new ofWindowPosEventArgs(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofWindowPosEventArgs,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_WindowPosEventArgs__SWIG_1(lua_State* L) { int SWIG_arg = 0; int arg1 ; int arg2 ; - ofWindowPosEventArgs *result = 0 ; SWIG_check_num_args("ofWindowPosEventArgs::ofWindowPosEventArgs",2,2) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofWindowPosEventArgs::ofWindowPosEventArgs",1,"int"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofWindowPosEventArgs::ofWindowPosEventArgs",2,"int"); arg1 = (int)lua_tonumber(L, 1); - arg2 = (int)lua_tonumber(L, 2); result = (ofWindowPosEventArgs *)new ofWindowPosEventArgs(arg1,arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofWindowPosEventArgs,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_WindowPosEventArgs(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_WindowPosEventArgs__SWIG_0(L);} if (argc == 2) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_new_WindowPosEventArgs__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_WindowPosEventArgs'\n" - " Possible C/C++ prototypes are:\n" " ofWindowPosEventArgs::ofWindowPosEventArgs()\n" - " ofWindowPosEventArgs::ofWindowPosEventArgs(int,int)\n"); lua_error(L);return 0; } -static void swig_delete_WindowPosEventArgs(void *obj) { -ofWindowPosEventArgs *arg1 = (ofWindowPosEventArgs *) obj; -delete arg1; -} -static int _proxy__wrap_new_WindowPosEventArgs(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_WindowPosEventArgs); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_WindowPosEventArgs_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_WindowPosEventArgs_methods[]= { - {0,0} -}; -static swig_lua_method swig_WindowPosEventArgs_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_WindowPosEventArgs_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_WindowPosEventArgs_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_WindowPosEventArgs_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_WindowPosEventArgs_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_WindowPosEventArgs_Sf_SwigStatic = { - "WindowPosEventArgs", - swig_WindowPosEventArgs_Sf_SwigStatic_methods, - swig_WindowPosEventArgs_Sf_SwigStatic_attributes, - swig_WindowPosEventArgs_Sf_SwigStatic_constants, - swig_WindowPosEventArgs_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_WindowPosEventArgs_bases[] = {0}; -static const char *swig_WindowPosEventArgs_base_names[] = {0}; -static swig_lua_class _wrap_class_WindowPosEventArgs = { "WindowPosEventArgs", "WindowPosEventArgs", &SWIGTYPE_p_ofWindowPosEventArgs,_proxy__wrap_new_WindowPosEventArgs, swig_delete_WindowPosEventArgs, swig_WindowPosEventArgs_methods, swig_WindowPosEventArgs_attributes, &swig_WindowPosEventArgs_Sf_SwigStatic, swig_WindowPosEventArgs_meta, swig_WindowPosEventArgs_bases, swig_WindowPosEventArgs_base_names }; - static int _wrap_sendMessage(lua_State* L) { int SWIG_arg = 0; std::string arg1 ; bool result; SWIG_check_num_args("ofSendMessage",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofSendMessage",1,"std::string"); (&arg1)->assign(lua_tostring(L,1),lua_rawlen(L,1)); result = (bool)ofSendMessage(arg1); @@ -23456,20 +25588,8 @@ static int _wrap_BufferObject_allocate__SWIG_2(lua_State* L) { int SWIG_arg = 0; SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (GLenum)lua_tonumber(L, 4); (arg1)->allocate(arg2,(void const *)arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_BufferObject_allocate(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 1) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofBufferObject, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_BufferObject_allocate__SWIG_0(L);} } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofBufferObject, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_GLsizeiptr, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_BufferObject_allocate__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofBufferObject, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_GLsizeiptr, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, 0, 0)) { _v = 0; } else { _v = 1; } } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_BufferObject_allocate__SWIG_2(L);} } } } } + if (argc == 1) { return _wrap_BufferObject_allocate__SWIG_0(L);} if (argc == 3) { + return _wrap_BufferObject_allocate__SWIG_1(L);} if (argc == 4) { return _wrap_BufferObject_allocate__SWIG_2(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'BufferObject_allocate'\n" " Possible C/C++ prototypes are:\n" " ofBufferObject::allocate()\n" " ofBufferObject::allocate(GLsizeiptr,GLenum)\n" " ofBufferObject::allocate(GLsizeiptr,void const *,GLenum)\n"); lua_error(L);return 0; } @@ -23593,21 +25713,8 @@ static int _wrap_BufferObject_updateData__SWIG_1(lua_State* L) { int SWIG_arg = arg3=(void *)SWIG_MustGetPtr(L,3,0,0,3,"BufferObject_updateData"); (arg1)->updateData(arg2,(void const *)arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_BufferObject_updateData(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofBufferObject, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_GLsizeiptr, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, 0, 0)) { _v = 0; } else { _v = 1; } } - if (_v) { return _wrap_BufferObject_updateData__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofBufferObject, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_GLintptr, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_GLsizeiptr, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, 0, 0)) { _v = 0; } else { _v = 1; } - } if (_v) { return _wrap_BufferObject_updateData__SWIG_0(L);} } } } } + if (argc == 3) { return _wrap_BufferObject_updateData__SWIG_1(L);} if (argc == 4) { + return _wrap_BufferObject_updateData__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'BufferObject_updateData'\n" " Possible C/C++ prototypes are:\n" " ofBufferObject::updateData(GLintptr,GLsizeiptr,void const *)\n" " ofBufferObject::updateData(GLsizeiptr,void const *)\n"); lua_error(L);return 0; } @@ -23672,17 +25779,8 @@ static int _wrap_BufferObject_copyTo__SWIG_1(lua_State* L) { int SWIG_arg = 0; o arg5 = (size_t)lua_tonumber(L, 5); ((ofBufferObject const *)arg1)->copyTo(*arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_BufferObject_copyTo(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofBufferObject, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBufferObject, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_BufferObject_copyTo__SWIG_0(L);} } } if (argc == 5) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofBufferObject, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBufferObject, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_BufferObject_copyTo__SWIG_1(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'BufferObject_copyTo'\n" + if (argc == 2) { return _wrap_BufferObject_copyTo__SWIG_0(L);} if (argc == 5) { return _wrap_BufferObject_copyTo__SWIG_1(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'BufferObject_copyTo'\n" " Possible C/C++ prototypes are:\n" " ofBufferObject::copyTo(ofBufferObject &) const\n" " ofBufferObject::copyTo(ofBufferObject &,int,int,size_t) const\n"); lua_error(L);return 0; } static int _wrap_BufferObject_invalidate(lua_State* L) { int SWIG_arg = 0; ofBufferObject *arg1 = (ofBufferObject *) 0 ; @@ -23699,19 +25797,6 @@ static int _wrap_BufferObject_size(lua_State* L) { int SWIG_arg = 0; ofBufferObj GLsizeiptr * resultptr = new GLsizeiptr((const GLsizeiptr &) result); SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_GLsizeiptr,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BufferObject_allocated_get(lua_State* L) { int SWIG_arg = 0; ofBufferObject *arg1 = (ofBufferObject *) 0 ; - bool result; SWIG_check_num_args("ofBufferObject::allocated",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBufferObject::allocated",1,"ofBufferObject *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBufferObject,0))){ - SWIG_fail_ptr("BufferObject_allocated_get",1,SWIGTYPE_p_ofBufferObject); } - result = (bool)ofBufferObject_allocated_get(arg1); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BufferObject_id_get(lua_State* L) { int SWIG_arg = 0; ofBufferObject *arg1 = (ofBufferObject *) 0 ; - unsigned int result; SWIG_check_num_args("ofBufferObject::id",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBufferObject::id",1,"ofBufferObject *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBufferObject,0))){ - SWIG_fail_ptr("BufferObject_id_get",1,SWIGTYPE_p_ofBufferObject); } result = (unsigned int)ofBufferObject_id_get(arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static void swig_delete_BufferObject(void *obj) { ofBufferObject *arg1 = (ofBufferObject *) obj; delete arg1; @@ -23725,8 +25810,6 @@ static int _proxy__wrap_new_BufferObject(lua_State *L) { return 1; } static swig_lua_attribute swig_BufferObject_attributes[] = { - { "allocated", _wrap_BufferObject_allocated_get, SWIG_Lua_set_immutable }, - { "id", _wrap_BufferObject_id_get, SWIG_Lua_set_immutable }, {0,0,0} }; static swig_lua_method swig_BufferObject_methods[]= { @@ -23779,82 +25862,80 @@ static swig_lua_class *swig_BufferObject_bases[] = {0}; static const char *swig_BufferObject_base_names[] = {0}; static swig_lua_class _wrap_class_BufferObject = { "BufferObject", "BufferObject", &SWIGTYPE_p_ofBufferObject,_proxy__wrap_new_BufferObject, swig_delete_BufferObject, swig_BufferObject_methods, swig_BufferObject_attributes, &swig_BufferObject_Sf_SwigStatic, swig_BufferObject_meta, swig_BufferObject_bases, swig_BufferObject_base_names }; -static int _wrap_getGlInternalFormat__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPixels *arg1 = 0 ; int result; - SWIG_check_num_args("ofGetGlInternalFormat",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofGetGlInternalFormat",1,"ofPixels const &"); +static int _wrap_getGLInternalFormat__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPixels *arg1 = 0 ; int result; + SWIG_check_num_args("ofGetGLInternalFormat",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofGetGLInternalFormat",1,"ofPixels const &"); if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("getGlInternalFormat",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - result = (int)ofGetGlInternalFormat((ofPixels_< unsigned char > const &)*arg1); + SWIG_fail_ptr("getGLInternalFormat",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } + result = (int)ofGetGLInternalFormat((ofPixels_< unsigned char > const &)*arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getGlInternalFormat__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofShortPixels *arg1 = 0 ; int result; - SWIG_check_num_args("ofGetGlInternalFormat",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofGetGlInternalFormat",1,"ofShortPixels const &"); +static int _wrap_getGLInternalFormat__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofShortPixels *arg1 = 0 ; int result; + SWIG_check_num_args("ofGetGLInternalFormat",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofGetGLInternalFormat",1,"ofShortPixels const &"); if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("getGlInternalFormat",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - result = (int)ofGetGlInternalFormat((ofPixels_< unsigned short > const &)*arg1); + SWIG_fail_ptr("getGLInternalFormat",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } + result = (int)ofGetGLInternalFormat((ofPixels_< unsigned short > const &)*arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getGlInternalFormat__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofFloatPixels *arg1 = 0 ; int result; - SWIG_check_num_args("ofGetGlInternalFormat",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofGetGlInternalFormat",1,"ofFloatPixels const &"); +static int _wrap_getGLInternalFormat__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofFloatPixels *arg1 = 0 ; int result; + SWIG_check_num_args("ofGetGLInternalFormat",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofGetGLInternalFormat",1,"ofFloatPixels const &"); if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("getGlInternalFormat",1,SWIGTYPE_p_ofPixels_T_float_t); } - result = (int)ofGetGlInternalFormat((ofPixels_< float > const &)*arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getGlInternalFormat(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_getGlInternalFormat__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_getGlInternalFormat__SWIG_1(L);} } if (argc == 1) { int _v; { - void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_getGlInternalFormat__SWIG_2(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'getGlInternalFormat'\n" - " Possible C/C++ prototypes are:\n" " ofGetGlInternalFormat(ofPixels const &)\n" - " ofGetGlInternalFormat(ofShortPixels const &)\n" " ofGetGlInternalFormat(ofFloatPixels const &)\n"); + SWIG_fail_ptr("getGLInternalFormat",1,SWIGTYPE_p_ofPixels_T_float_t); } + result = (int)ofGetGLInternalFormat((ofPixels_< float > const &)*arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_getGLInternalFormat(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_getGLInternalFormat__SWIG_0(L);} check_1: + if (argc == 1) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_getGLInternalFormat__SWIG_1(L);} check_2: + if (argc == 1) { return _wrap_getGLInternalFormat__SWIG_2(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'getGLInternalFormat'\n" + " Possible C/C++ prototypes are:\n" " ofGetGLInternalFormat(ofPixels const &)\n" + " ofGetGLInternalFormat(ofShortPixels const &)\n" " ofGetGLInternalFormat(ofFloatPixels const &)\n"); lua_error(L);return 0; } -static int _wrap_getGlInternalFormatName(lua_State* L) { int SWIG_arg = 0; int arg1 ; std::string result; - SWIG_check_num_args("ofGetGlInternalFormatName",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofGetGlInternalFormatName",1,"int"); arg1 = (int)lua_tonumber(L, 1); - result = ofGetGlInternalFormatName(arg1); lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; +static int _wrap_getGLInternalFormatName(lua_State* L) { int SWIG_arg = 0; int arg1 ; std::string result; + SWIG_check_num_args("ofGetGLInternalFormatName",1,1) + if(!lua_isnumber(L,1)) SWIG_fail_arg("ofGetGLInternalFormatName",1,"int"); arg1 = (int)lua_tonumber(L, 1); + result = ofGetGLInternalFormatName(arg1); lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_getGLFormatFromInternal(lua_State* L) { int SWIG_arg = 0; int arg1 ; int result; SWIG_check_num_args("ofGetGLFormatFromInternal",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofGetGLFormatFromInternal",1,"int"); arg1 = (int)lua_tonumber(L, 1); result = (int)ofGetGLFormatFromInternal(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getGlTypeFromInternal(lua_State* L) { int SWIG_arg = 0; int arg1 ; int result; - SWIG_check_num_args("ofGetGlTypeFromInternal",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofGetGlTypeFromInternal",1,"int"); - arg1 = (int)lua_tonumber(L, 1); result = (int)ofGetGlTypeFromInternal(arg1); +static int _wrap_getGLTypeFromInternal(lua_State* L) { int SWIG_arg = 0; int arg1 ; int result; + SWIG_check_num_args("ofGetGLTypeFromInternal",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofGetGLTypeFromInternal",1,"int"); + arg1 = (int)lua_tonumber(L, 1); result = (int)ofGetGLTypeFromInternal(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getGlType__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPixels *arg1 = 0 ; int result; - SWIG_check_num_args("ofGetGlType",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofGetGlType",1,"ofPixels const &"); +static int _wrap_getGLType__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPixels *arg1 = 0 ; int result; + SWIG_check_num_args("ofGetGLType",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofGetGLType",1,"ofPixels const &"); if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("getGlType",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - result = (int)ofGetGlType((ofPixels_< unsigned char > const &)*arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; + SWIG_fail_ptr("getGLType",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } + result = (int)ofGetGLType((ofPixels_< unsigned char > const &)*arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getGlType__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofShortPixels *arg1 = 0 ; int result; - SWIG_check_num_args("ofGetGlType",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofGetGlType",1,"ofShortPixels const &"); +static int _wrap_getGLType__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofShortPixels *arg1 = 0 ; int result; + SWIG_check_num_args("ofGetGLType",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofGetGLType",1,"ofShortPixels const &"); if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("getGlType",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - result = (int)ofGetGlType((ofPixels_< unsigned short > const &)*arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; + SWIG_fail_ptr("getGLType",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } + result = (int)ofGetGLType((ofPixels_< unsigned short > const &)*arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getGlType__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofFloatPixels *arg1 = 0 ; int result; - SWIG_check_num_args("ofGetGlType",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofGetGlType",1,"ofFloatPixels const &"); +static int _wrap_getGLType__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofFloatPixels *arg1 = 0 ; int result; + SWIG_check_num_args("ofGetGLType",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofGetGLType",1,"ofFloatPixels const &"); if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("getGlType",1,SWIGTYPE_p_ofPixels_T_float_t); } result = (int)ofGetGlType((ofPixels_< float > const &)*arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getGlType(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_getGlType__SWIG_0(L);} } if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_getGlType__SWIG_1(L);} } if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_getGlType__SWIG_2(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'getGlType'\n" " Possible C/C++ prototypes are:\n" - " ofGetGlType(ofPixels const &)\n" " ofGetGlType(ofShortPixels const &)\n" " ofGetGlType(ofFloatPixels const &)\n"); + SWIG_fail_ptr("getGLType",1,SWIGTYPE_p_ofPixels_T_float_t); } result = (int)ofGetGLType((ofPixels_< float > const &)*arg1); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_getGLType(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v = 0; { { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_getGLType__SWIG_0(L);} check_1: + if (argc == 1) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_getGLType__SWIG_1(L);} check_2: + if (argc == 1) { return _wrap_getGLType__SWIG_2(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'getGLType'\n" " Possible C/C++ prototypes are:\n" + " ofGetGLType(ofPixels const &)\n" " ofGetGLType(ofShortPixels const &)\n" " ofGetGLType(ofFloatPixels const &)\n"); lua_error(L);return 0; } static int _wrap_getImageTypeFromGLType(lua_State* L) { int SWIG_arg = 0; int arg1 ; ofImageType result; SWIG_check_num_args("ofGetImageTypeFromGLType",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofGetImageTypeFromGLType",1,"int"); @@ -23917,29 +25998,27 @@ static int _wrap_setPixelStoreiAlignment__SWIG_1(lua_State* L) { int SWIG_arg = arg2 = (int)lua_tonumber(L, 2); ofSetPixelStoreiAlignment(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_setPixelStoreiAlignment(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_setPixelStoreiAlignment__SWIG_1(L);} } } if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_setPixelStoreiAlignment__SWIG_0(L);} } } } } + if (argc == 2) { return _wrap_setPixelStoreiAlignment__SWIG_1(L);} if (argc == 4) { + return _wrap_setPixelStoreiAlignment__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'setPixelStoreiAlignment'\n" " Possible C/C++ prototypes are:\n" " ofSetPixelStoreiAlignment(GLenum,int,int,int)\n" " ofSetPixelStoreiAlignment(GLenum,int)\n"); lua_error(L);return 0; } -static int _wrap_GLSupportedExtensions(lua_State* L) { int SWIG_arg = 0; std::vector< std::string > result; +static int _wrap_gLSupportedExtensions(lua_State* L) { int SWIG_arg = 0; std::vector< std::string > result; SWIG_check_num_args("ofGLSupportedExtensions",0,0) result = ofGLSupportedExtensions(); { std::vector< std::string > * resultptr = new std::vector< std::string >((const std::vector< std::string > &) result); SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_std__string_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_GLCheckExtension(lua_State* L) { int SWIG_arg = 0; std::string arg1 ; bool result; +static int _wrap_gLCheckExtension(lua_State* L) { int SWIG_arg = 0; std::string arg1 ; bool result; SWIG_check_num_args("ofGLCheckExtension",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofGLCheckExtension",1,"std::string"); (&arg1)->assign(lua_tostring(L,1),lua_rawlen(L,1)); result = (bool)ofGLCheckExtension(arg1); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_GLSupportsNPOTTextures(lua_State* L) { int SWIG_arg = 0; bool result; +static int _wrap_gLSupportsNPOTTextures(lua_State* L) { int SWIG_arg = 0; bool result; SWIG_check_num_args("ofGLSupportsNPOTTextures",0,0) result = (bool)ofGLSupportsNPOTTextures(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_isGLProgrammableRenderer(lua_State* L) { int SWIG_arg = 0; bool result; SWIG_check_num_args("ofIsGLProgrammableRenderer",0,0) result = (bool)ofIsGLProgrammableRenderer(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_GLSLVersionFromGL(lua_State* L) { int SWIG_arg = 0; int arg1 ; int arg2 ; std::string result; +static int _wrap_gLSLVersionFromGL(lua_State* L) { int SWIG_arg = 0; int arg1 ; int arg2 ; std::string result; SWIG_check_num_args("ofGLSLVersionFromGL",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofGLSLVersionFromGL",1,"int"); if(!lua_isnumber(L,2)) SWIG_fail_arg("ofGLSLVersionFromGL",2,"int"); arg1 = (int)lua_tonumber(L, 1); arg2 = (int)lua_tonumber(L, 2); result = ofGLSLVersionFromGL(arg1,arg2); @@ -24033,15 +26112,8 @@ static int _wrap_Light_setSpotlight__SWIG_2(lua_State* L) { int SWIG_arg = 0; of SWIG_fail_ptr("Light_setSpotlight",1,SWIGTYPE_p_ofLight); } (arg1)->setSpotlight(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Light_setSpotlight(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofLight, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_Light_setSpotlight__SWIG_2(L);} } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofLight, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Light_setSpotlight__SWIG_1(L);} } } - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofLight, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Light_setSpotlight__SWIG_0(L);} } } } + return _wrap_Light_setSpotlight__SWIG_2(L);} if (argc == 2) { return _wrap_Light_setSpotlight__SWIG_1(L);} + if (argc == 3) { return _wrap_Light_setSpotlight__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Light_setSpotlight'\n" " Possible C/C++ prototypes are:\n" " ofLight::setSpotlight(float,float)\n" " ofLight::setSpotlight(float)\n" " ofLight::setSpotlight()\n"); lua_error(L);return 0; } @@ -24124,18 +26196,9 @@ static int _wrap_Light_setAttenuation__SWIG_3(lua_State* L) { int SWIG_arg = 0; SWIG_fail_ptr("Light_setAttenuation",1,SWIGTYPE_p_ofLight); } (arg1)->setAttenuation(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Light_setAttenuation(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 1) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofLight, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_Light_setAttenuation__SWIG_3(L);} } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofLight, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Light_setAttenuation__SWIG_2(L);} } } - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofLight, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Light_setAttenuation__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofLight, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Light_setAttenuation__SWIG_0(L);} } } } } + if (argc == 1) { return _wrap_Light_setAttenuation__SWIG_3(L);} if (argc == 2) { + return _wrap_Light_setAttenuation__SWIG_2(L);} if (argc == 3) { return _wrap_Light_setAttenuation__SWIG_1(L);} + if (argc == 4) { return _wrap_Light_setAttenuation__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Light_setAttenuation'\n" " Possible C/C++ prototypes are:\n" " ofLight::setAttenuation(float,float,float)\n" " ofLight::setAttenuation(float,float)\n" " ofLight::setAttenuation(float)\n" " ofLight::setAttenuation()\n"); @@ -24313,22 +26376,195 @@ static swig_lua_class *swig_Light_bases[] = {0,0}; static const char *swig_Light_base_names[] = {"ofNode *",0}; static swig_lua_class _wrap_class_Light = { "Light", "Light", &SWIGTYPE_p_ofLight,_proxy__wrap_new_Light, swig_delete_Light, swig_Light_methods, swig_Light_attributes, &swig_Light_Sf_SwigStatic, swig_Light_meta, swig_Light_bases, swig_Light_base_names }; -static int _wrap_lightsData(lua_State* L) { int SWIG_arg = 0; std::vector< std::weak_ptr< ofLight::Data > > *result = 0 ; - SWIG_check_num_args("ofLightsData",0,0) result = (std::vector< std::weak_ptr< ofLight::Data > > *) &ofLightsData(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_std__weak_ptrT_ofLight__Data_t_t,0); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_MaterialSettings_diffuse_set(lua_State* L) { int SWIG_arg = 0; + ofMaterialSettings *arg1 = (ofMaterialSettings *) 0 ; ofFloatColor *arg2 = (ofFloatColor *) 0 ; + SWIG_check_num_args("ofMaterialSettings::diffuse",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMaterialSettings::diffuse",1,"ofMaterialSettings *"); + if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofMaterialSettings::diffuse",2,"ofFloatColor *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMaterialSettings,0))){ + SWIG_fail_ptr("MaterialSettings_diffuse_set",1,SWIGTYPE_p_ofMaterialSettings); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_float_t,0))){ + SWIG_fail_ptr("MaterialSettings_diffuse_set",2,SWIGTYPE_p_ofColor_T_float_t); } if (arg1) (arg1)->diffuse = *arg2; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_MaterialSettings_diffuse_get(lua_State* L) { int SWIG_arg = 0; + ofMaterialSettings *arg1 = (ofMaterialSettings *) 0 ; ofFloatColor *result = 0 ; + SWIG_check_num_args("ofMaterialSettings::diffuse",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMaterialSettings::diffuse",1,"ofMaterialSettings *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMaterialSettings,0))){ + SWIG_fail_ptr("MaterialSettings_diffuse_get",1,SWIGTYPE_p_ofMaterialSettings); } + result = (ofFloatColor *)& ((arg1)->diffuse); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_MaterialSettings_ambient_set(lua_State* L) { int SWIG_arg = 0; + ofMaterialSettings *arg1 = (ofMaterialSettings *) 0 ; ofFloatColor *arg2 = (ofFloatColor *) 0 ; + SWIG_check_num_args("ofMaterialSettings::ambient",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMaterialSettings::ambient",1,"ofMaterialSettings *"); + if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofMaterialSettings::ambient",2,"ofFloatColor *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMaterialSettings,0))){ + SWIG_fail_ptr("MaterialSettings_ambient_set",1,SWIGTYPE_p_ofMaterialSettings); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_float_t,0))){ + SWIG_fail_ptr("MaterialSettings_ambient_set",2,SWIGTYPE_p_ofColor_T_float_t); } if (arg1) (arg1)->ambient = *arg2; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_MaterialSettings_ambient_get(lua_State* L) { int SWIG_arg = 0; + ofMaterialSettings *arg1 = (ofMaterialSettings *) 0 ; ofFloatColor *result = 0 ; + SWIG_check_num_args("ofMaterialSettings::ambient",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMaterialSettings::ambient",1,"ofMaterialSettings *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMaterialSettings,0))){ + SWIG_fail_ptr("MaterialSettings_ambient_get",1,SWIGTYPE_p_ofMaterialSettings); } + result = (ofFloatColor *)& ((arg1)->ambient); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_MaterialSettings_specular_set(lua_State* L) { int SWIG_arg = 0; + ofMaterialSettings *arg1 = (ofMaterialSettings *) 0 ; ofFloatColor *arg2 = (ofFloatColor *) 0 ; + SWIG_check_num_args("ofMaterialSettings::specular",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMaterialSettings::specular",1,"ofMaterialSettings *"); + if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofMaterialSettings::specular",2,"ofFloatColor *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMaterialSettings,0))){ + SWIG_fail_ptr("MaterialSettings_specular_set",1,SWIGTYPE_p_ofMaterialSettings); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_float_t,0))){ + SWIG_fail_ptr("MaterialSettings_specular_set",2,SWIGTYPE_p_ofColor_T_float_t); } if (arg1) (arg1)->specular = *arg2; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_MaterialSettings_specular_get(lua_State* L) { int SWIG_arg = 0; + ofMaterialSettings *arg1 = (ofMaterialSettings *) 0 ; ofFloatColor *result = 0 ; + SWIG_check_num_args("ofMaterialSettings::specular",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMaterialSettings::specular",1,"ofMaterialSettings *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMaterialSettings,0))){ + SWIG_fail_ptr("MaterialSettings_specular_get",1,SWIGTYPE_p_ofMaterialSettings); } + result = (ofFloatColor *)& ((arg1)->specular); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_MaterialSettings_emissive_set(lua_State* L) { int SWIG_arg = 0; + ofMaterialSettings *arg1 = (ofMaterialSettings *) 0 ; ofFloatColor *arg2 = (ofFloatColor *) 0 ; + SWIG_check_num_args("ofMaterialSettings::emissive",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMaterialSettings::emissive",1,"ofMaterialSettings *"); + if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofMaterialSettings::emissive",2,"ofFloatColor *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMaterialSettings,0))){ + SWIG_fail_ptr("MaterialSettings_emissive_set",1,SWIGTYPE_p_ofMaterialSettings); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_float_t,0))){ + SWIG_fail_ptr("MaterialSettings_emissive_set",2,SWIGTYPE_p_ofColor_T_float_t); } if (arg1) (arg1)->emissive = *arg2; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_MaterialSettings_emissive_get(lua_State* L) { int SWIG_arg = 0; + ofMaterialSettings *arg1 = (ofMaterialSettings *) 0 ; ofFloatColor *result = 0 ; + SWIG_check_num_args("ofMaterialSettings::emissive",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMaterialSettings::emissive",1,"ofMaterialSettings *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMaterialSettings,0))){ + SWIG_fail_ptr("MaterialSettings_emissive_get",1,SWIGTYPE_p_ofMaterialSettings); } + result = (ofFloatColor *)& ((arg1)->emissive); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_MaterialSettings_shininess_set(lua_State* L) { int SWIG_arg = 0; + ofMaterialSettings *arg1 = (ofMaterialSettings *) 0 ; float arg2 ; SWIG_check_num_args("ofMaterialSettings::shininess",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMaterialSettings::shininess",1,"ofMaterialSettings *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMaterialSettings::shininess",2,"float"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMaterialSettings,0))){ + SWIG_fail_ptr("MaterialSettings_shininess_set",1,SWIGTYPE_p_ofMaterialSettings); } arg2 = (float)lua_tonumber(L, 2); + if (arg1) (arg1)->shininess = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_MaterialSettings_shininess_get(lua_State* L) { int SWIG_arg = 0; + ofMaterialSettings *arg1 = (ofMaterialSettings *) 0 ; float result; SWIG_check_num_args("ofMaterialSettings::shininess",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMaterialSettings::shininess",1,"ofMaterialSettings *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMaterialSettings,0))){ + SWIG_fail_ptr("MaterialSettings_shininess_get",1,SWIGTYPE_p_ofMaterialSettings); } result = (float) ((arg1)->shininess); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_MaterialSettings_postFragment_set(lua_State* L) { int SWIG_arg = 0; + ofMaterialSettings *arg1 = (ofMaterialSettings *) 0 ; std::string *arg2 = 0 ; std::string temp2 ; + SWIG_check_num_args("ofMaterialSettings::postFragment",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMaterialSettings::postFragment",1,"ofMaterialSettings *"); + if(!lua_isstring(L,2)) SWIG_fail_arg("ofMaterialSettings::postFragment",2,"std::string const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMaterialSettings,0))){ + SWIG_fail_ptr("MaterialSettings_postFragment_set",1,SWIGTYPE_p_ofMaterialSettings); } + temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; if (arg1) (arg1)->postFragment = *arg2; return SWIG_arg; + if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_MaterialSettings_postFragment_get(lua_State* L) { int SWIG_arg = 0; + ofMaterialSettings *arg1 = (ofMaterialSettings *) 0 ; std::string *result = 0 ; + SWIG_check_num_args("ofMaterialSettings::postFragment",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMaterialSettings::postFragment",1,"ofMaterialSettings *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMaterialSettings,0))){ + SWIG_fail_ptr("MaterialSettings_postFragment_get",1,SWIGTYPE_p_ofMaterialSettings); } + result = (std::string *) & ((arg1)->postFragment); lua_pushlstring(L,result->data(),result->size()); SWIG_arg++; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_MaterialSettings_customUniforms_set(lua_State* L) { int SWIG_arg = 0; + ofMaterialSettings *arg1 = (ofMaterialSettings *) 0 ; std::string *arg2 = 0 ; std::string temp2 ; + SWIG_check_num_args("ofMaterialSettings::customUniforms",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMaterialSettings::customUniforms",1,"ofMaterialSettings *"); + if(!lua_isstring(L,2)) SWIG_fail_arg("ofMaterialSettings::customUniforms",2,"std::string const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMaterialSettings,0))){ + SWIG_fail_ptr("MaterialSettings_customUniforms_set",1,SWIGTYPE_p_ofMaterialSettings); } + temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; if (arg1) (arg1)->customUniforms = *arg2; return SWIG_arg; + if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_MaterialSettings_customUniforms_get(lua_State* L) { int SWIG_arg = 0; + ofMaterialSettings *arg1 = (ofMaterialSettings *) 0 ; std::string *result = 0 ; + SWIG_check_num_args("ofMaterialSettings::customUniforms",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMaterialSettings::customUniforms",1,"ofMaterialSettings *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMaterialSettings,0))){ + SWIG_fail_ptr("MaterialSettings_customUniforms_get",1,SWIGTYPE_p_ofMaterialSettings); } + result = (std::string *) & ((arg1)->customUniforms); lua_pushlstring(L,result->data(),result->size()); SWIG_arg++; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_new_MaterialSettings(lua_State* L) { int SWIG_arg = 0; ofMaterialSettings *result = 0 ; + SWIG_check_num_args("ofMaterialSettings::ofMaterialSettings",0,0) result = (ofMaterialSettings *)new ofMaterialSettings(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMaterialSettings,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static void swig_delete_MaterialSettings(void *obj) { +ofMaterialSettings *arg1 = (ofMaterialSettings *) obj; +delete arg1; +} +static int _proxy__wrap_new_MaterialSettings(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_MaterialSettings); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_MaterialSettings_attributes[] = { + { "diffuse", _wrap_MaterialSettings_diffuse_get, _wrap_MaterialSettings_diffuse_set }, + { "ambient", _wrap_MaterialSettings_ambient_get, _wrap_MaterialSettings_ambient_set }, + { "specular", _wrap_MaterialSettings_specular_get, _wrap_MaterialSettings_specular_set }, + { "emissive", _wrap_MaterialSettings_emissive_get, _wrap_MaterialSettings_emissive_set }, + { "shininess", _wrap_MaterialSettings_shininess_get, _wrap_MaterialSettings_shininess_set }, + { "postFragment", _wrap_MaterialSettings_postFragment_get, _wrap_MaterialSettings_postFragment_set }, + { "customUniforms", _wrap_MaterialSettings_customUniforms_get, _wrap_MaterialSettings_customUniforms_set }, + {0,0,0} +}; +static swig_lua_method swig_MaterialSettings_methods[]= { + {0,0} +}; +static swig_lua_method swig_MaterialSettings_meta[] = { + {0,0} +}; + +static swig_lua_attribute swig_MaterialSettings_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_MaterialSettings_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_MaterialSettings_Sf_SwigStatic_methods[]= { + {0,0} +}; +static swig_lua_class* swig_MaterialSettings_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_MaterialSettings_Sf_SwigStatic = { + "MaterialSettings", + swig_MaterialSettings_Sf_SwigStatic_methods, + swig_MaterialSettings_Sf_SwigStatic_attributes, + swig_MaterialSettings_Sf_SwigStatic_constants, + swig_MaterialSettings_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_MaterialSettings_bases[] = {0}; +static const char *swig_MaterialSettings_base_names[] = {0}; +static swig_lua_class _wrap_class_MaterialSettings = { "MaterialSettings", "MaterialSettings", &SWIGTYPE_p_ofMaterialSettings,_proxy__wrap_new_MaterialSettings, swig_delete_MaterialSettings, swig_MaterialSettings_methods, swig_MaterialSettings_attributes, &swig_MaterialSettings_Sf_SwigStatic, swig_MaterialSettings_meta, swig_MaterialSettings_bases, swig_MaterialSettings_base_names }; + static int _wrap_new_Material(lua_State* L) { int SWIG_arg = 0; ofMaterial *result = 0 ; SWIG_check_num_args("ofMaterial::ofMaterial",0,0) result = (ofMaterial *)new ofMaterial(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMaterial,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Material_setup(lua_State* L) { int SWIG_arg = 0; ofMaterial *arg1 = (ofMaterial *) 0 ; - ofMaterial::Settings *arg2 = 0 ; SWIG_check_num_args("ofMaterial::setup",2,2) + ofMaterialSettings *arg2 = 0 ; SWIG_check_num_args("ofMaterial::setup",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMaterial::setup",1,"ofMaterial *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMaterial::setup",2,"ofMaterial::Settings const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMaterial::setup",2,"ofMaterialSettings const &"); if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMaterial,0))){ SWIG_fail_ptr("Material_setup",1,SWIGTYPE_p_ofMaterial); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofMaterial__Settings,0))){ - SWIG_fail_ptr("Material_setup",2,SWIGTYPE_p_ofMaterial__Settings); } (arg1)->setup((ofMaterial::Settings const &)*arg2); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofMaterialSettings,0))){ + SWIG_fail_ptr("Material_setup",2,SWIGTYPE_p_ofMaterialSettings); } (arg1)->setup((ofMaterialSettings const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Material_setColors(lua_State* L) { int SWIG_arg = 0; ofMaterial *arg1 = (ofMaterial *) 0 ; ofFloatColor arg2 ; ofFloatColor arg3 ; ofFloatColor arg4 ; ofFloatColor arg5 ; ofFloatColor *argp2 ; ofFloatColor *argp3 ; ofFloatColor *argp4 ; @@ -24436,12 +26672,12 @@ static int _wrap_Material_getShininess(lua_State* L) { int SWIG_arg = 0; ofMater result = (float)((ofMaterial const *)arg1)->getShininess(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Material_getSettings(lua_State* L) { int SWIG_arg = 0; ofMaterial *arg1 = (ofMaterial *) 0 ; - ofMaterial::Settings result; SWIG_check_num_args("ofMaterial::getSettings",1,1) + ofMaterialSettings result; SWIG_check_num_args("ofMaterial::getSettings",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMaterial::getSettings",1,"ofMaterial const *"); if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMaterial,0))){ SWIG_fail_ptr("Material_getSettings",1,SWIGTYPE_p_ofMaterial); } result = ((ofMaterial const *)arg1)->getSettings(); { - ofMaterial::Settings * resultptr = new ofMaterial::Settings((const ofMaterial::Settings &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMaterial__Settings,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; + ofMaterialSettings * resultptr = new ofMaterialSettings((const ofMaterialSettings &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMaterialSettings,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Material_beginMaterial(lua_State* L) { int SWIG_arg = 0; ofMaterial *arg1 = (ofMaterial *) 0 ; SWIG_check_num_args("ofMaterial::begin",1,1) @@ -24540,42 +26776,42 @@ static int _wrap_Material_setCustomUniform1i(lua_State* L) { int SWIG_arg = 0; o (arg1)->setCustomUniform1i((std::string const &)*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Material_setCustomUniform2i(lua_State* L) { int SWIG_arg = 0; ofMaterial *arg1 = (ofMaterial *) 0 ; - std::string *arg2 = 0 ; glm::tvec2< int,glm::precision::defaultp > arg3 ; std::string temp2 ; - glm::tvec2< int,glm::precision::defaultp > *argp3 ; SWIG_check_num_args("ofMaterial::setCustomUniform2i",3,3) + std::string *arg2 = 0 ; glm::vec< 2,int,glm::precision::defaultp > arg3 ; std::string temp2 ; + glm::vec< 2,int,glm::precision::defaultp > *argp3 ; SWIG_check_num_args("ofMaterial::setCustomUniform2i",3,3) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMaterial::setCustomUniform2i",1,"ofMaterial *"); if(!lua_isstring(L,2)) SWIG_fail_arg("ofMaterial::setCustomUniform2i",2,"std::string const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofMaterial::setCustomUniform2i",3,"glm::tvec2< int,glm::precision::defaultp >"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofMaterial::setCustomUniform2i",3,"glm::vec< 2,int,glm::precision::defaultp >"); if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMaterial,0))){ SWIG_fail_ptr("Material_setCustomUniform2i",1,SWIGTYPE_p_ofMaterial); } temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&argp3,SWIGTYPE_p_glm__tvec2T_int_glm__precision__defaultp_t,0))){ - SWIG_fail_ptr("Material_setCustomUniform2i",3,SWIGTYPE_p_glm__tvec2T_int_glm__precision__defaultp_t); } arg3 = *argp3; + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&argp3,SWIGTYPE_p_glm__vecT_2_int_glm__precision__defaultp_t,0))){ + SWIG_fail_ptr("Material_setCustomUniform2i",3,SWIGTYPE_p_glm__vecT_2_int_glm__precision__defaultp_t); } arg3 = *argp3; (arg1)->setCustomUniform2i((std::string const &)*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Material_setCustomUniform3i(lua_State* L) { int SWIG_arg = 0; ofMaterial *arg1 = (ofMaterial *) 0 ; - std::string *arg2 = 0 ; glm::tvec3< int,glm::precision::defaultp > arg3 ; std::string temp2 ; - glm::tvec3< int,glm::precision::defaultp > *argp3 ; SWIG_check_num_args("ofMaterial::setCustomUniform3i",3,3) + std::string *arg2 = 0 ; glm::vec< 3,int,glm::precision::defaultp > arg3 ; std::string temp2 ; + glm::vec< 3,int,glm::precision::defaultp > *argp3 ; SWIG_check_num_args("ofMaterial::setCustomUniform3i",3,3) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMaterial::setCustomUniform3i",1,"ofMaterial *"); if(!lua_isstring(L,2)) SWIG_fail_arg("ofMaterial::setCustomUniform3i",2,"std::string const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofMaterial::setCustomUniform3i",3,"glm::tvec3< int,glm::precision::defaultp >"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofMaterial::setCustomUniform3i",3,"glm::vec< 3,int,glm::precision::defaultp >"); if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMaterial,0))){ SWIG_fail_ptr("Material_setCustomUniform3i",1,SWIGTYPE_p_ofMaterial); } temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&argp3,SWIGTYPE_p_glm__tvec3T_int_glm__precision__defaultp_t,0))){ - SWIG_fail_ptr("Material_setCustomUniform3i",3,SWIGTYPE_p_glm__tvec3T_int_glm__precision__defaultp_t); } arg3 = *argp3; + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&argp3,SWIGTYPE_p_glm__vecT_3_int_glm__precision__defaultp_t,0))){ + SWIG_fail_ptr("Material_setCustomUniform3i",3,SWIGTYPE_p_glm__vecT_3_int_glm__precision__defaultp_t); } arg3 = *argp3; (arg1)->setCustomUniform3i((std::string const &)*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Material_setCustomUniform4i(lua_State* L) { int SWIG_arg = 0; ofMaterial *arg1 = (ofMaterial *) 0 ; - std::string *arg2 = 0 ; glm::tvec4< int,glm::precision::defaultp > arg3 ; std::string temp2 ; - glm::tvec4< int,glm::precision::defaultp > *argp3 ; SWIG_check_num_args("ofMaterial::setCustomUniform4i",3,3) + std::string *arg2 = 0 ; glm::vec< 4,int,glm::precision::defaultp > arg3 ; std::string temp2 ; + glm::vec< 4,int,glm::precision::defaultp > *argp3 ; SWIG_check_num_args("ofMaterial::setCustomUniform4i",3,3) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMaterial::setCustomUniform4i",1,"ofMaterial *"); if(!lua_isstring(L,2)) SWIG_fail_arg("ofMaterial::setCustomUniform4i",2,"std::string const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofMaterial::setCustomUniform4i",3,"glm::tvec4< int,glm::precision::defaultp >"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofMaterial::setCustomUniform4i",3,"glm::vec< 4,int,glm::precision::defaultp >"); if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMaterial,0))){ SWIG_fail_ptr("Material_setCustomUniform4i",1,SWIGTYPE_p_ofMaterial); } temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&argp3,SWIGTYPE_p_glm__tvec4T_int_glm__precision__defaultp_t,0))){ - SWIG_fail_ptr("Material_setCustomUniform4i",3,SWIGTYPE_p_glm__tvec4T_int_glm__precision__defaultp_t); } arg3 = *argp3; + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&argp3,SWIGTYPE_p_glm__vecT_4_int_glm__precision__defaultp_t,0))){ + SWIG_fail_ptr("Material_setCustomUniform4i",3,SWIGTYPE_p_glm__vecT_4_int_glm__precision__defaultp_t); } arg3 = *argp3; (arg1)->setCustomUniform4i((std::string const &)*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Material_setCustomUniformTexture__SWIG_0(lua_State* L) { int SWIG_arg = 0; @@ -24607,16 +26843,8 @@ static int _wrap_Material_setCustomUniformTexture__SWIG_1(lua_State* L) { int SW (arg1)->setCustomUniformTexture((std::string const &)*arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Material_setCustomUniformTexture(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); - if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMaterial, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { - return _wrap_Material_setCustomUniformTexture__SWIG_0(L);} } } } } if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMaterial, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Material_setCustomUniformTexture__SWIG_1(L);} } } } } } + if (argc == 4) { return _wrap_Material_setCustomUniformTexture__SWIG_0(L);} if (argc == 5) { + return _wrap_Material_setCustomUniformTexture__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Material_setCustomUniformTexture'\n" " Possible C/C++ prototypes are:\n" " ofMaterial::setCustomUniformTexture(std::string const &,ofTexture const &,int)\n" " ofMaterial::setCustomUniformTexture(std::string const &,int,GLint,int)\n"); lua_error(L);return 0; } @@ -24703,9 +26931,7 @@ static int _wrap_new_Shader__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofShader * result = (ofShader *)new ofShader((ofShader &&)*arg1); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofShader,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_new_Shader(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_Shader__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_new_Shader__SWIG_1(L);} } + return _wrap_new_Shader__SWIG_0(L);} if (argc == 1) { return _wrap_new_Shader__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_Shader'\n" " Possible C/C++ prototypes are:\n" " ofShader::ofShader()\n" " ofShader::ofShader(ofShader &&)\n"); lua_error(L);return 0; } static int _wrap_Shader_load__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; @@ -24740,29 +26966,21 @@ static int _wrap_Shader_load__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofShader arg2 = &temp2; } { size_t len = lua_rawlen(L, 3); temp3 = lua_tolstring(L, 3, &len); arg3 = &temp3; } result = (bool)(arg1)->load((std::filesystem::path const &)*arg2,(std::filesystem::path const &)*arg3); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_load(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L, argv[1]); } if (_v) { - return _wrap_Shader_load__SWIG_0(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L, argv[1]); } if (_v) { { _v = lua_isstring(L, argv[2]); } - if (_v) { return _wrap_Shader_load__SWIG_2(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L, argv[1]); } if (_v) { { _v = lua_isstring(L, argv[2]); } - if (_v) { { _v = lua_isstring(L, argv[3]); } if (_v) { return _wrap_Shader_load__SWIG_1(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Shader_load'\n" " Possible C/C++ prototypes are:\n" - " ofShader::load(std::filesystem::path const &)\n" +static int _wrap_Shader_load(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { + return _wrap_Shader_load__SWIG_0(L);} if (argc == 3) { return _wrap_Shader_load__SWIG_2(L);} if (argc == 4) { + return _wrap_Shader_load__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Shader_load'\n" + " Possible C/C++ prototypes are:\n" " ofShader::load(std::filesystem::path const &)\n" " ofShader::load(std::filesystem::path const &,std::filesystem::path const &,std::filesystem::path const &)\n" " ofShader::load(std::filesystem::path const &,std::filesystem::path const &)\n"); lua_error(L);return 0; } static int _wrap_Shader_setup__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - ofShader::Settings *arg2 = 0 ; bool result; SWIG_check_num_args("ofShader::setup",2,2) + ofShaderSettings *arg2 = 0 ; bool result; SWIG_check_num_args("ofShader::setup",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setup",1,"ofShader *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofShader::setup",2,"ofShader::Settings const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofShader::setup",2,"ofShaderSettings const &"); if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ SWIG_fail_ptr("Shader_setup",1,SWIGTYPE_p_ofShader); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofShader__Settings,0))){ - SWIG_fail_ptr("Shader_setup",2,SWIGTYPE_p_ofShader__Settings); } - result = (bool)(arg1)->setup((ofShader::Settings const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofShaderSettings,0))){ + SWIG_fail_ptr("Shader_setup",2,SWIGTYPE_p_ofShaderSettings); } + result = (bool)(arg1)->setup((ofShaderSettings const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Shader_setup__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; ofShader::TransformFeedbackSettings *arg2 = 0 ; bool result; SWIG_check_num_args("ofShader::setup",2,2) @@ -24774,17 +26992,13 @@ static int _wrap_Shader_setup__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofShader SWIG_fail_ptr("Shader_setup",2,SWIGTYPE_p_ofShader__TransformFeedbackSettings); } result = (bool)(arg1)->setup((ofShader::TransformFeedbackSettings const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setup(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofShader__Settings, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Shader_setup__SWIG_0(L);} } } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofShader__TransformFeedbackSettings, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Shader_setup__SWIG_1(L);} } } +static int _wrap_Shader_setup(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofShaderSettings, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_Shader_setup__SWIG_0(L);} check_1: + if (argc == 2) { return _wrap_Shader_setup__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Shader_setup'\n" " Possible C/C++ prototypes are:\n" - " ofShader::setup(ofShader::Settings const &)\n" " ofShader::setup(ofShader::TransformFeedbackSettings const &)\n"); + " ofShader::setup(ofShaderSettings const &)\n" " ofShader::setup(ofShader::TransformFeedbackSettings const &)\n"); lua_error(L);return 0; } static int _wrap_Shader_setGeometryInputType(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; GLenum arg2 ; SWIG_check_num_args("ofShader::setGeometryInputType",2,2) @@ -24837,172 +27051,6 @@ static int _wrap_Shader_endShader(lua_State* L) { int SWIG_arg = 0; ofShader *ar if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ SWIG_fail_ptr("Shader_endShader",1,SWIGTYPE_p_ofShader); } ((ofShader const *)arg1)->end(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_beginTransformFeedback__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - GLenum arg2 ; SWIG_check_num_args("ofShader::beginTransformFeedback",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::beginTransformFeedback",1,"ofShader const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofShader::beginTransformFeedback",2,"GLenum"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_beginTransformFeedback",1,SWIGTYPE_p_ofShader); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (GLenum)lua_tonumber(L, 2); - ((ofShader const *)arg1)->beginTransformFeedback(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Shader_beginTransformFeedback__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - GLenum arg2 ; ofShader::TransformFeedbackRangeBinding *arg3 = 0 ; SWIG_check_num_args("ofShader::beginTransformFeedback",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::beginTransformFeedback",1,"ofShader const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofShader::beginTransformFeedback",2,"GLenum"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofShader::beginTransformFeedback",3,"ofShader::TransformFeedbackRangeBinding const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_beginTransformFeedback",1,SWIGTYPE_p_ofShader); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (GLenum)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofShader__TransformFeedbackRangeBinding,0))){ - SWIG_fail_ptr("Shader_beginTransformFeedback",3,SWIGTYPE_p_ofShader__TransformFeedbackRangeBinding); } - ((ofShader const *)arg1)->beginTransformFeedback(arg2,(ofShader::TransformFeedbackRangeBinding const &)*arg3); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_beginTransformFeedback__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - GLenum arg2 ; std::vector< ofShader::TransformFeedbackRangeBinding > *arg3 = 0 ; - SWIG_check_num_args("ofShader::beginTransformFeedback",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::beginTransformFeedback",1,"ofShader const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofShader::beginTransformFeedback",2,"GLenum"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofShader::beginTransformFeedback",3,"std::vector< ofShader::TransformFeedbackRangeBinding > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_beginTransformFeedback",1,SWIGTYPE_p_ofShader); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (GLenum)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_std__vectorT_ofShader__TransformFeedbackRangeBinding_t,0))){ - SWIG_fail_ptr("Shader_beginTransformFeedback",3,SWIGTYPE_p_std__vectorT_ofShader__TransformFeedbackRangeBinding_t); } - ((ofShader const *)arg1)->beginTransformFeedback(arg2,(std::vector< ofShader::TransformFeedbackRangeBinding > const &)*arg3); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_beginTransformFeedback__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - GLenum arg2 ; ofShader::TransformFeedbackBaseBinding *arg3 = 0 ; SWIG_check_num_args("ofShader::beginTransformFeedback",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::beginTransformFeedback",1,"ofShader const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofShader::beginTransformFeedback",2,"GLenum"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofShader::beginTransformFeedback",3,"ofShader::TransformFeedbackBaseBinding const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_beginTransformFeedback",1,SWIGTYPE_p_ofShader); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (GLenum)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofShader__TransformFeedbackBaseBinding,0))){ - SWIG_fail_ptr("Shader_beginTransformFeedback",3,SWIGTYPE_p_ofShader__TransformFeedbackBaseBinding); } - ((ofShader const *)arg1)->beginTransformFeedback(arg2,(ofShader::TransformFeedbackBaseBinding const &)*arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_beginTransformFeedback__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - GLenum arg2 ; std::vector< ofShader::TransformFeedbackBaseBinding > *arg3 = 0 ; - SWIG_check_num_args("ofShader::beginTransformFeedback",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::beginTransformFeedback",1,"ofShader const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofShader::beginTransformFeedback",2,"GLenum"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofShader::beginTransformFeedback",3,"std::vector< ofShader::TransformFeedbackBaseBinding > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_beginTransformFeedback",1,SWIGTYPE_p_ofShader); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (GLenum)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_std__vectorT_ofShader__TransformFeedbackBaseBinding_t,0))){ - SWIG_fail_ptr("Shader_beginTransformFeedback",3,SWIGTYPE_p_std__vectorT_ofShader__TransformFeedbackBaseBinding_t); } - ((ofShader const *)arg1)->beginTransformFeedback(arg2,(std::vector< ofShader::TransformFeedbackBaseBinding > const &)*arg3); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_beginTransformFeedback(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Shader_beginTransformFeedback__SWIG_0(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofShader__TransformFeedbackRangeBinding, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Shader_beginTransformFeedback__SWIG_1(L);} } } } - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_std__vectorT_ofShader__TransformFeedbackRangeBinding_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Shader_beginTransformFeedback__SWIG_2(L);} } } } - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofShader__TransformFeedbackBaseBinding, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Shader_beginTransformFeedback__SWIG_3(L);} } } } - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_std__vectorT_ofShader__TransformFeedbackBaseBinding_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Shader_beginTransformFeedback__SWIG_4(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Shader_beginTransformFeedback'\n" - " Possible C/C++ prototypes are:\n" " ofShader::beginTransformFeedback(GLenum) const\n" - " ofShader::beginTransformFeedback(GLenum,ofShader::TransformFeedbackRangeBinding const &) const\n" - " ofShader::beginTransformFeedback(GLenum,std::vector< ofShader::TransformFeedbackRangeBinding > const &) const\n" - " ofShader::beginTransformFeedback(GLenum,ofShader::TransformFeedbackBaseBinding const &) const\n" - " ofShader::beginTransformFeedback(GLenum,std::vector< ofShader::TransformFeedbackBaseBinding > const &) const\n"); - lua_error(L);return 0; } -static int _wrap_Shader_endTransformFeedback__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - SWIG_check_num_args("ofShader::endTransformFeedback",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::endTransformFeedback",1,"ofShader const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_endTransformFeedback",1,SWIGTYPE_p_ofShader); } ((ofShader const *)arg1)->endTransformFeedback(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_endTransformFeedback__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - ofShader::TransformFeedbackRangeBinding *arg2 = 0 ; SWIG_check_num_args("ofShader::endTransformFeedback",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::endTransformFeedback",1,"ofShader const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofShader::endTransformFeedback",2,"ofShader::TransformFeedbackRangeBinding const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_endTransformFeedback",1,SWIGTYPE_p_ofShader); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofShader__TransformFeedbackRangeBinding,0))){ - SWIG_fail_ptr("Shader_endTransformFeedback",2,SWIGTYPE_p_ofShader__TransformFeedbackRangeBinding); } - ((ofShader const *)arg1)->endTransformFeedback((ofShader::TransformFeedbackRangeBinding const &)*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_endTransformFeedback__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::vector< ofShader::TransformFeedbackRangeBinding > *arg2 = 0 ; SWIG_check_num_args("ofShader::endTransformFeedback",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::endTransformFeedback",1,"ofShader const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofShader::endTransformFeedback",2,"std::vector< ofShader::TransformFeedbackRangeBinding > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_endTransformFeedback",1,SWIGTYPE_p_ofShader); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__vectorT_ofShader__TransformFeedbackRangeBinding_t,0))){ - SWIG_fail_ptr("Shader_endTransformFeedback",2,SWIGTYPE_p_std__vectorT_ofShader__TransformFeedbackRangeBinding_t); } - ((ofShader const *)arg1)->endTransformFeedback((std::vector< ofShader::TransformFeedbackRangeBinding > const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_endTransformFeedback__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - ofShader::TransformFeedbackBaseBinding *arg2 = 0 ; SWIG_check_num_args("ofShader::endTransformFeedback",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::endTransformFeedback",1,"ofShader const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofShader::endTransformFeedback",2,"ofShader::TransformFeedbackBaseBinding const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_endTransformFeedback",1,SWIGTYPE_p_ofShader); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofShader__TransformFeedbackBaseBinding,0))){ - SWIG_fail_ptr("Shader_endTransformFeedback",2,SWIGTYPE_p_ofShader__TransformFeedbackBaseBinding); } - ((ofShader const *)arg1)->endTransformFeedback((ofShader::TransformFeedbackBaseBinding const &)*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_endTransformFeedback__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::vector< ofShader::TransformFeedbackBaseBinding > *arg2 = 0 ; SWIG_check_num_args("ofShader::endTransformFeedback",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::endTransformFeedback",1,"ofShader const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofShader::endTransformFeedback",2,"std::vector< ofShader::TransformFeedbackBaseBinding > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_endTransformFeedback",1,SWIGTYPE_p_ofShader); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__vectorT_ofShader__TransformFeedbackBaseBinding_t,0))){ - SWIG_fail_ptr("Shader_endTransformFeedback",2,SWIGTYPE_p_std__vectorT_ofShader__TransformFeedbackBaseBinding_t); } - ((ofShader const *)arg1)->endTransformFeedback((std::vector< ofShader::TransformFeedbackBaseBinding > const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_endTransformFeedback(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); - if (argc == 1) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Shader_endTransformFeedback__SWIG_0(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofShader__TransformFeedbackRangeBinding, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Shader_endTransformFeedback__SWIG_1(L);} } } - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_std__vectorT_ofShader__TransformFeedbackRangeBinding_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Shader_endTransformFeedback__SWIG_2(L);} } } - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofShader__TransformFeedbackBaseBinding, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Shader_endTransformFeedback__SWIG_3(L);} } } - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_std__vectorT_ofShader__TransformFeedbackBaseBinding_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Shader_endTransformFeedback__SWIG_4(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Shader_endTransformFeedback'\n" - " Possible C/C++ prototypes are:\n" " ofShader::endTransformFeedback() const\n" - " ofShader::endTransformFeedback(ofShader::TransformFeedbackRangeBinding const &) const\n" - " ofShader::endTransformFeedback(std::vector< ofShader::TransformFeedbackRangeBinding > const &) const\n" - " ofShader::endTransformFeedback(ofShader::TransformFeedbackBaseBinding const &) const\n" - " ofShader::endTransformFeedback(std::vector< ofShader::TransformFeedbackBaseBinding > const &) const\n"); - lua_error(L);return 0; } static int _wrap_Shader_setUniformTexture__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; std::string *arg2 = 0 ; ofBaseHasTexture *arg3 = 0 ; int arg4 ; std::string temp2 ; SWIG_check_num_args("ofShader::setUniformTexture",4,4) @@ -25046,21 +27094,11 @@ static int _wrap_Shader_setUniformTexture__SWIG_2(lua_State* L) { int SWIG_arg = ((ofShader const *)arg1)->setUniformTexture((std::string const &)*arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Shader_setUniformTexture(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); - if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofBaseHasTexture, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { - return _wrap_Shader_setUniformTexture__SWIG_0(L);} } } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { - return _wrap_Shader_setUniformTexture__SWIG_1(L);} } } } } if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Shader_setUniformTexture__SWIG_2(L);} } } } } } + if (argc == 4) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofBaseHasTexture, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_Shader_setUniformTexture__SWIG_0(L);} check_1: + if (argc == 4) { return _wrap_Shader_setUniformTexture__SWIG_1(L);} if (argc == 5) { + return _wrap_Shader_setUniformTexture__SWIG_2(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Shader_setUniformTexture'\n" " Possible C/C++ prototypes are:\n" " ofShader::setUniformTexture(std::string const &,ofBaseHasTexture const &,int) const\n" @@ -25170,14 +27208,7 @@ static int _wrap_Shader_setUniform2f__SWIG_1(lua_State* L) { int SWIG_arg = 0; o ((ofShader const *)arg1)->setUniform2f((std::string const &)*arg2,(glm::vec2 const &)*arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Shader_setUniform2f(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_glm__vec2, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Shader_setUniform2f__SWIG_1(L);} } } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Shader_setUniform2f__SWIG_0(L);} } } } } + return _wrap_Shader_setUniform2f__SWIG_1(L);} if (argc == 4) { return _wrap_Shader_setUniform2f__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Shader_setUniform2f'\n" " Possible C/C++ prototypes are:\n" " ofShader::setUniform2f(std::string const &,float,float) const\n" " ofShader::setUniform2f(std::string const &,glm::vec2 const &) const\n"); lua_error(L);return 0; } @@ -25193,16 +27224,8 @@ static int _wrap_Shader_setUniform3f__SWIG_1(lua_State* L) { int SWIG_arg = 0; o ((ofShader const *)arg1)->setUniform3f((std::string const &)*arg2,(glm::vec3 const &)*arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Shader_setUniform3f(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Shader_setUniform3f__SWIG_1(L);} } } } if (argc == 5) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Shader_setUniform3f__SWIG_0(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Shader_setUniform3f'\n" + if (argc == 3) { return _wrap_Shader_setUniform3f__SWIG_1(L);} if (argc == 5) { return _wrap_Shader_setUniform3f__SWIG_0(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Shader_setUniform3f'\n" " Possible C/C++ prototypes are:\n" " ofShader::setUniform3f(std::string const &,float,float,float) const\n" " ofShader::setUniform3f(std::string const &,glm::vec3 const &) const\n"); lua_error(L);return 0; } static int _wrap_Shader_setUniform4f__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; @@ -25228,21 +27251,11 @@ static int _wrap_Shader_setUniform4f__SWIG_2(lua_State* L) { int SWIG_arg = 0; o ((ofShader const *)arg1)->setUniform4f((std::string const &)*arg2,(ofFloatColor const &)*arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Shader_setUniform4f(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_glm__vec4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Shader_setUniform4f__SWIG_1(L);} } } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Shader_setUniform4f__SWIG_2(L);} } } } if (argc == 6) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { return _wrap_Shader_setUniform4f__SWIG_0(L);} } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Shader_setUniform4f'\n" + if (argc == 3) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_Shader_setUniform4f__SWIG_1(L);} check_1: + if (argc == 3) { return _wrap_Shader_setUniform4f__SWIG_2(L);} if (argc == 6) { return _wrap_Shader_setUniform4f__SWIG_0(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Shader_setUniform4f'\n" " Possible C/C++ prototypes are:\n" " ofShader::setUniform4f(std::string const &,float,float,float,float) const\n" " ofShader::setUniform4f(std::string const &,glm::vec4 const &) const\n" " ofShader::setUniform4f(std::string const &,ofFloatColor const &) const\n"); lua_error(L);return 0; } @@ -25271,16 +27284,9 @@ static int _wrap_Shader_setUniform1iv__SWIG_1(lua_State* L) { int SWIG_arg = 0; ((ofShader const *)arg1)->setUniform1iv((std::string const &)*arg2,(int const *)arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Shader_setUniform1iv(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_int, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_Shader_setUniform1iv__SWIG_1(L);} } } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_int, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Shader_setUniform1iv__SWIG_0(L);} - } } } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Shader_setUniform1iv'\n" + if (argc == 3) { return _wrap_Shader_setUniform1iv__SWIG_1(L);} if (argc == 4) { + return _wrap_Shader_setUniform1iv__SWIG_0(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Shader_setUniform1iv'\n" " Possible C/C++ prototypes are:\n" " ofShader::setUniform1iv(std::string const &,int const *,int) const\n" " ofShader::setUniform1iv(std::string const &,int const *) const\n"); lua_error(L);return 0; } static int _wrap_Shader_setUniform2iv__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; @@ -25308,16 +27314,9 @@ static int _wrap_Shader_setUniform2iv__SWIG_1(lua_State* L) { int SWIG_arg = 0; ((ofShader const *)arg1)->setUniform2iv((std::string const &)*arg2,(int const *)arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Shader_setUniform2iv(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_int, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_Shader_setUniform2iv__SWIG_1(L);} } } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_int, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Shader_setUniform2iv__SWIG_0(L);} - } } } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Shader_setUniform2iv'\n" + if (argc == 3) { return _wrap_Shader_setUniform2iv__SWIG_1(L);} if (argc == 4) { + return _wrap_Shader_setUniform2iv__SWIG_0(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Shader_setUniform2iv'\n" " Possible C/C++ prototypes are:\n" " ofShader::setUniform2iv(std::string const &,int const *,int) const\n" " ofShader::setUniform2iv(std::string const &,int const *) const\n"); lua_error(L);return 0; } static int _wrap_Shader_setUniform3iv__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; @@ -25345,16 +27344,9 @@ static int _wrap_Shader_setUniform3iv__SWIG_1(lua_State* L) { int SWIG_arg = 0; ((ofShader const *)arg1)->setUniform3iv((std::string const &)*arg2,(int const *)arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Shader_setUniform3iv(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_int, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_Shader_setUniform3iv__SWIG_1(L);} } } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_int, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Shader_setUniform3iv__SWIG_0(L);} - } } } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Shader_setUniform3iv'\n" + if (argc == 3) { return _wrap_Shader_setUniform3iv__SWIG_1(L);} if (argc == 4) { + return _wrap_Shader_setUniform3iv__SWIG_0(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Shader_setUniform3iv'\n" " Possible C/C++ prototypes are:\n" " ofShader::setUniform3iv(std::string const &,int const *,int) const\n" " ofShader::setUniform3iv(std::string const &,int const *) const\n"); lua_error(L);return 0; } static int _wrap_Shader_setUniform4iv__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; @@ -25382,16 +27374,9 @@ static int _wrap_Shader_setUniform4iv__SWIG_1(lua_State* L) { int SWIG_arg = 0; ((ofShader const *)arg1)->setUniform4iv((std::string const &)*arg2,(int const *)arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Shader_setUniform4iv(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_int, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_Shader_setUniform4iv__SWIG_1(L);} } } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_int, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Shader_setUniform4iv__SWIG_0(L);} - } } } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Shader_setUniform4iv'\n" + if (argc == 3) { return _wrap_Shader_setUniform4iv__SWIG_1(L);} if (argc == 4) { + return _wrap_Shader_setUniform4iv__SWIG_0(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Shader_setUniform4iv'\n" " Possible C/C++ prototypes are:\n" " ofShader::setUniform4iv(std::string const &,int const *,int) const\n" " ofShader::setUniform4iv(std::string const &,int const *) const\n"); lua_error(L);return 0; } static int _wrap_Shader_setUniform1fv__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; @@ -25421,16 +27406,8 @@ static int _wrap_Shader_setUniform1fv__SWIG_1(lua_State* L) { int SWIG_arg = 0; ((ofShader const *)arg1)->setUniform1fv((std::string const &)*arg2,(float const *)arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Shader_setUniform1fv(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Shader_setUniform1fv__SWIG_1(L);} } } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { - return _wrap_Shader_setUniform1fv__SWIG_0(L);} } } } } + if (argc == 3) { return _wrap_Shader_setUniform1fv__SWIG_1(L);} if (argc == 4) { + return _wrap_Shader_setUniform1fv__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Shader_setUniform1fv'\n" " Possible C/C++ prototypes are:\n" " ofShader::setUniform1fv(std::string const &,float const *,int) const\n" " ofShader::setUniform1fv(std::string const &,float const *) const\n"); lua_error(L);return 0; } @@ -25461,16 +27438,8 @@ static int _wrap_Shader_setUniform2fv__SWIG_1(lua_State* L) { int SWIG_arg = 0; ((ofShader const *)arg1)->setUniform2fv((std::string const &)*arg2,(float const *)arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Shader_setUniform2fv(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Shader_setUniform2fv__SWIG_1(L);} } } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { - return _wrap_Shader_setUniform2fv__SWIG_0(L);} } } } } + if (argc == 3) { return _wrap_Shader_setUniform2fv__SWIG_1(L);} if (argc == 4) { + return _wrap_Shader_setUniform2fv__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Shader_setUniform2fv'\n" " Possible C/C++ prototypes are:\n" " ofShader::setUniform2fv(std::string const &,float const *,int) const\n" " ofShader::setUniform2fv(std::string const &,float const *) const\n"); lua_error(L);return 0; } @@ -25501,16 +27470,8 @@ static int _wrap_Shader_setUniform3fv__SWIG_1(lua_State* L) { int SWIG_arg = 0; ((ofShader const *)arg1)->setUniform3fv((std::string const &)*arg2,(float const *)arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Shader_setUniform3fv(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Shader_setUniform3fv__SWIG_1(L);} } } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { - return _wrap_Shader_setUniform3fv__SWIG_0(L);} } } } } + if (argc == 3) { return _wrap_Shader_setUniform3fv__SWIG_1(L);} if (argc == 4) { + return _wrap_Shader_setUniform3fv__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Shader_setUniform3fv'\n" " Possible C/C++ prototypes are:\n" " ofShader::setUniform3fv(std::string const &,float const *,int) const\n" " ofShader::setUniform3fv(std::string const &,float const *) const\n"); lua_error(L);return 0; } @@ -25541,16 +27502,8 @@ static int _wrap_Shader_setUniform4fv__SWIG_1(lua_State* L) { int SWIG_arg = 0; ((ofShader const *)arg1)->setUniform4fv((std::string const &)*arg2,(float const *)arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Shader_setUniform4fv(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Shader_setUniform4fv__SWIG_1(L);} } } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { - return _wrap_Shader_setUniform4fv__SWIG_0(L);} } } } } + if (argc == 3) { return _wrap_Shader_setUniform4fv__SWIG_1(L);} if (argc == 4) { + return _wrap_Shader_setUniform4fv__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Shader_setUniform4fv'\n" " Possible C/C++ prototypes are:\n" " ofShader::setUniform4fv(std::string const &,float const *,int) const\n" " ofShader::setUniform4fv(std::string const &,float const *) const\n"); lua_error(L);return 0; } @@ -25591,16 +27544,8 @@ static int _wrap_Shader_setUniformMatrix3f__SWIG_1(lua_State* L) { int SWIG_arg ((ofShader const *)arg1)->setUniformMatrix3f((std::string const &)*arg2,(glm::mat3 const &)*arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Shader_setUniformMatrix3f(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_glm__mat3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Shader_setUniformMatrix3f__SWIG_1(L);} } } } if (argc == 4) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_glm__mat3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { - return _wrap_Shader_setUniformMatrix3f__SWIG_0(L);} } } } } + if (argc == 3) { return _wrap_Shader_setUniformMatrix3f__SWIG_1(L);} if (argc == 4) { + return _wrap_Shader_setUniformMatrix3f__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Shader_setUniformMatrix3f'\n" " Possible C/C++ prototypes are:\n" " ofShader::setUniformMatrix3f(std::string const &,glm::mat3 const &,int) const\n" " ofShader::setUniformMatrix3f(std::string const &,glm::mat3 const &) const\n"); lua_error(L);return 0; } @@ -25631,16 +27576,8 @@ static int _wrap_Shader_setUniformMatrix4f__SWIG_1(lua_State* L) { int SWIG_arg ((ofShader const *)arg1)->setUniformMatrix4f((std::string const &)*arg2,(glm::mat4 const &)*arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Shader_setUniformMatrix4f(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_glm__mat4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Shader_setUniformMatrix4f__SWIG_1(L);} } } } if (argc == 4) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_glm__mat4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { - return _wrap_Shader_setUniformMatrix4f__SWIG_0(L);} } } } } + if (argc == 3) { return _wrap_Shader_setUniformMatrix4f__SWIG_1(L);} if (argc == 4) { + return _wrap_Shader_setUniformMatrix4f__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Shader_setUniformMatrix4f'\n" " Possible C/C++ prototypes are:\n" " ofShader::setUniformMatrix4f(std::string const &,glm::mat4 const &,int) const\n" " ofShader::setUniformMatrix4f(std::string const &,glm::mat4 const &) const\n"); lua_error(L);return 0; } @@ -25824,17 +27761,8 @@ static int _wrap_Shader_setAttribute1fv__SWIG_1(lua_State* L) { int SWIG_arg = 0 ((ofShader const *)arg1)->setAttribute1fv((std::string const &)*arg2,(float const *)arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Shader_setAttribute1fv(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Shader_setAttribute1fv__SWIG_1(L);} } } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_GLsizei, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Shader_setAttribute1fv__SWIG_0(L);} } } } } + if (argc == 3) { return _wrap_Shader_setAttribute1fv__SWIG_1(L);} if (argc == 4) { + return _wrap_Shader_setAttribute1fv__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Shader_setAttribute1fv'\n" " Possible C/C++ prototypes are:\n" " ofShader::setAttribute1fv(std::string const &,float const *,GLsizei) const\n" " ofShader::setAttribute1fv(std::string const &,float const *) const\n"); lua_error(L);return 0; } @@ -25867,17 +27795,8 @@ static int _wrap_Shader_setAttribute2fv__SWIG_1(lua_State* L) { int SWIG_arg = 0 ((ofShader const *)arg1)->setAttribute2fv((std::string const &)*arg2,(float const *)arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Shader_setAttribute2fv(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Shader_setAttribute2fv__SWIG_1(L);} } } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_GLsizei, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Shader_setAttribute2fv__SWIG_0(L);} } } } } + if (argc == 3) { return _wrap_Shader_setAttribute2fv__SWIG_1(L);} if (argc == 4) { + return _wrap_Shader_setAttribute2fv__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Shader_setAttribute2fv'\n" " Possible C/C++ prototypes are:\n" " ofShader::setAttribute2fv(std::string const &,float const *,GLsizei) const\n" " ofShader::setAttribute2fv(std::string const &,float const *) const\n"); lua_error(L);return 0; } @@ -25910,17 +27829,8 @@ static int _wrap_Shader_setAttribute3fv__SWIG_1(lua_State* L) { int SWIG_arg = 0 ((ofShader const *)arg1)->setAttribute3fv((std::string const &)*arg2,(float const *)arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Shader_setAttribute3fv(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Shader_setAttribute3fv__SWIG_1(L);} } } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_GLsizei, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Shader_setAttribute3fv__SWIG_0(L);} } } } } + if (argc == 3) { return _wrap_Shader_setAttribute3fv__SWIG_1(L);} if (argc == 4) { + return _wrap_Shader_setAttribute3fv__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Shader_setAttribute3fv'\n" " Possible C/C++ prototypes are:\n" " ofShader::setAttribute3fv(std::string const &,float const *,GLsizei) const\n" " ofShader::setAttribute3fv(std::string const &,float const *) const\n"); lua_error(L);return 0; } @@ -25953,17 +27863,8 @@ static int _wrap_Shader_setAttribute4fv__SWIG_1(lua_State* L) { int SWIG_arg = 0 ((ofShader const *)arg1)->setAttribute4fv((std::string const &)*arg2,(float const *)arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Shader_setAttribute4fv(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Shader_setAttribute4fv__SWIG_1(L);} } } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_GLsizei, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Shader_setAttribute4fv__SWIG_0(L);} } } } } + if (argc == 3) { return _wrap_Shader_setAttribute4fv__SWIG_1(L);} if (argc == 4) { + return _wrap_Shader_setAttribute4fv__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Shader_setAttribute4fv'\n" " Possible C/C++ prototypes are:\n" " ofShader::setAttribute4fv(std::string const &,float const *,GLsizei) const\n" " ofShader::setAttribute4fv(std::string const &,float const *) const\n"); lua_error(L);return 0; } @@ -26013,13 +27914,8 @@ static int _wrap_Shader_setupShaderFromSource__SWIG_1(lua_State* L) { int SWIG_a (&arg3)->assign(lua_tostring(L,3),lua_rawlen(L,3)); result = (bool)(arg1)->setupShaderFromSource(arg2,arg3); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Shader_setupShaderFromSource(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isstring(L,argv[2]); } if (_v) { - return _wrap_Shader_setupShaderFromSource__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isstring(L,argv[2]); } if (_v) { - { _v = lua_isstring(L,argv[3]); } if (_v) { return _wrap_Shader_setupShaderFromSource__SWIG_0(L);} } } } } + if (argc == 3) { return _wrap_Shader_setupShaderFromSource__SWIG_1(L);} if (argc == 4) { + return _wrap_Shader_setupShaderFromSource__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Shader_setupShaderFromSource'\n" " Possible C/C++ prototypes are:\n" " ofShader::setupShaderFromSource(GLenum,std::string,std::string)\n" " ofShader::setupShaderFromSource(GLenum,std::string)\n"); lua_error(L);return 0; } @@ -26083,7 +27979,7 @@ static int _wrap_Shader_getShaderSource(lua_State* L) { int SWIG_arg = 0; ofShad return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static void swig_delete_Shader(void *obj) { ofShader *arg1 = (ofShader *) obj; -delete_ofShader(arg1); +delete arg1; } static int _proxy__wrap_new_Shader(lua_State *L) { assert(lua_istable(L,1)); @@ -26107,8 +28003,6 @@ static swig_lua_method swig_Shader_methods[]= { { "isLoaded", _wrap_Shader_isLoaded}, { "beginShader", _wrap_Shader_beginShader}, { "endShader", _wrap_Shader_endShader}, - { "beginTransformFeedback", _wrap_Shader_beginTransformFeedback}, - { "endTransformFeedback", _wrap_Shader_endTransformFeedback}, { "setUniformTexture", _wrap_Shader_setUniformTexture}, { "setUniform1i", _wrap_Shader_setUniform1i}, { "setUniform2i", _wrap_Shader_setUniform2i}, @@ -26169,11 +28063,6 @@ static swig_lua_attribute swig_Shader_Sf_SwigStatic_attributes[] = { {0,0,0} }; static swig_lua_const_info swig_Shader_Sf_SwigStatic_constants[]= { - {SWIG_LUA_CONSTTAB_INT("POSITION_ATTRIBUTE", ofShader::POSITION_ATTRIBUTE)}, - {SWIG_LUA_CONSTTAB_INT("COLOR_ATTRIBUTE", ofShader::COLOR_ATTRIBUTE)}, - {SWIG_LUA_CONSTTAB_INT("NORMAL_ATTRIBUTE", ofShader::NORMAL_ATTRIBUTE)}, - {SWIG_LUA_CONSTTAB_INT("TEXCOORD_ATTRIBUTE", ofShader::TEXCOORD_ATTRIBUTE)}, - {SWIG_LUA_CONSTTAB_INT("INDEX_ATTRIBUTE", ofShader::INDEX_ATTRIBUTE)}, {0,0,0,0,0,0} }; static swig_lua_method swig_Shader_Sf_SwigStatic_methods[]= { @@ -26204,9 +28093,7 @@ static int _wrap_new_Vbo__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = result = (ofVbo *)new ofVbo((ofVbo const &)*arg1); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVbo,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_new_Vbo(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_Vbo__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_new_Vbo__SWIG_1(L);} } + return _wrap_new_Vbo__SWIG_0(L);} if (argc == 1) { return _wrap_new_Vbo__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_Vbo'\n" " Possible C/C++ prototypes are:\n" " ofVbo::ofVbo()\n" " ofVbo::ofVbo(ofVbo const &)\n"); lua_error(L);return 0; } static int _wrap_Vbo_setMesh__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; ofMesh *arg2 = 0 ; int arg3 ; @@ -26214,9 +28101,9 @@ static int _wrap_Vbo_setMesh__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVbo *ar if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVbo::setMesh",2,"ofMesh const &"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::setMesh",3,"int"); if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ SWIG_fail_ptr("Vbo_setMesh",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofMesh_T_glm__vec3_glm__vec3_ofColor_T_float_t_glm__vec2_t,0))){ - SWIG_fail_ptr("Vbo_setMesh",2,SWIGTYPE_p_ofMesh_T_glm__vec3_glm__vec3_ofColor_T_float_t_glm__vec2_t); } - arg3 = (int)lua_tonumber(L, 3); (arg1)->setMesh((ofMesh const &)*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Vbo_setMesh",2,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + arg3 = (int)lua_tonumber(L, 3); (arg1)->setMesh((ofMesh const &)*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Vbo_setMesh__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; ofMesh *arg2 = 0 ; int arg3 ; bool arg4 ; bool arg5 ; bool arg6 ; SWIG_check_num_args("ofVbo::setMesh",6,6) @@ -26227,23 +28114,13 @@ static int _wrap_Vbo_setMesh__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVbo *ar if(!lua_isboolean(L,5)) SWIG_fail_arg("ofVbo::setMesh",5,"bool"); if(!lua_isboolean(L,6)) SWIG_fail_arg("ofVbo::setMesh",6,"bool"); if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ SWIG_fail_ptr("Vbo_setMesh",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofMesh_T_glm__vec3_glm__vec3_ofColor_T_float_t_glm__vec2_t,0))){ - SWIG_fail_ptr("Vbo_setMesh",2,SWIGTYPE_p_ofMesh_T_glm__vec3_glm__vec3_ofColor_T_float_t_glm__vec2_t); } - arg3 = (int)lua_tonumber(L, 3); arg4 = (lua_toboolean(L, 4)!=0); arg5 = (lua_toboolean(L, 5)!=0); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Vbo_setMesh",2,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + arg3 = (int)lua_tonumber(L, 3); arg4 = (lua_toboolean(L, 4)!=0); arg5 = (lua_toboolean(L, 5)!=0); arg6 = (lua_toboolean(L, 6)!=0); (arg1)->setMesh((ofMesh const &)*arg2,arg3,arg4,arg5,arg6); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Vbo_setMesh(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofMesh_T_glm__vec3_glm__vec3_ofColor_T_float_t_glm__vec2_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Vbo_setMesh__SWIG_0(L);} } } } if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofMesh_T_glm__vec3_glm__vec3_ofColor_T_float_t_glm__vec2_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isboolean(L,argv[3]); } if (_v) { { _v = lua_isboolean(L,argv[4]); } if (_v) { { - _v = lua_isboolean(L,argv[5]); } if (_v) { return _wrap_Vbo_setMesh__SWIG_1(L);} } } } } } } + return _wrap_Vbo_setMesh__SWIG_0(L);} if (argc == 6) { return _wrap_Vbo_setMesh__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_setMesh'\n" " Possible C/C++ prototypes are:\n" " ofVbo::setMesh(ofMesh const &,int)\n" " ofVbo::setMesh(ofMesh const &,int,bool,bool,bool)\n"); lua_error(L);return 0; } static int _wrap_Vbo_setVertexData__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; @@ -26393,39 +28270,17 @@ static int _wrap_Vbo_setVertexData__SWIG_5(lua_State* L) { int SWIG_arg = 0; ofV arg5 = (int)lua_tonumber(L, 5); (arg1)->setVertexData((float const *)arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Vbo_setVertexData(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); - if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; + if (argc == 4) { int _v = 0; { { void *ptr; if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Vbo_setVertexData__SWIG_0(L);} } } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; + else { _v = 1; } } } if (!_v) goto check_1; return _wrap_Vbo_setVertexData__SWIG_0(L);} check_1: if (argc == 4) { + int _v = 0; { { void *ptr; if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Vbo_setVertexData__SWIG_1(L);} } } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; + else { _v = 1; } } } if (!_v) goto check_2; return _wrap_Vbo_setVertexData__SWIG_1(L);} check_2: if (argc == 4) { + int _v = 0; { { void *ptr; if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Vbo_setVertexData__SWIG_2(L);} } } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Vbo_setVertexData__SWIG_3(L);} } } } } if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_Vbo_setVertexData__SWIG_5(L);} } } } } } - if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { - return _wrap_Vbo_setVertexData__SWIG_4(L);} } } } } } } + else { _v = 1; } } } if (!_v) goto check_3; return _wrap_Vbo_setVertexData__SWIG_2(L);} check_3: if (argc == 4) { + return _wrap_Vbo_setVertexData__SWIG_3(L);} if (argc == 5) { return _wrap_Vbo_setVertexData__SWIG_5(L);} if (argc == 6) { + return _wrap_Vbo_setVertexData__SWIG_4(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_setVertexData'\n" " Possible C/C++ prototypes are:\n" " ofVbo::setVertexData(glm::vec3 const *,int,int)\n" " ofVbo::setVertexData(glm::vec2 const *,int,int)\n" " ofVbo::setVertexData(ofVec3f const *,int,int)\n" " ofVbo::setVertexData(ofVec2f const *,int,int)\n" @@ -26454,21 +28309,10 @@ static int _wrap_Vbo_setColorData__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofVb SWIG_fail_ptr("Vbo_setColorData",2,SWIGTYPE_p_float); } arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); (arg1)->setColorData((float const *)arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Vbo_setColorData(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 4) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; + int _v = 0; { { void *ptr; if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Vbo_setColorData__SWIG_0(L);} } } } } if (argc == 4) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { - return _wrap_Vbo_setColorData__SWIG_2(L);} } } } } if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_Vbo_setColorData__SWIG_1(L);} } } } } } + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_Vbo_setColorData__SWIG_0(L);} check_1: + if (argc == 4) { return _wrap_Vbo_setColorData__SWIG_2(L);} if (argc == 5) { return _wrap_Vbo_setColorData__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_setColorData'\n" " Possible C/C++ prototypes are:\n" " ofVbo::setColorData(ofFloatColor const *,int,int)\n" " ofVbo::setColorData(float const *,int,int,int)\n" " ofVbo::setColorData(float const *,int,int)\n"); lua_error(L);return 0; } @@ -26497,26 +28341,13 @@ static int _wrap_Vbo_setNormalData__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofV SWIG_fail_ptr("Vbo_setNormalData",2,SWIGTYPE_p_float); } arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); (arg1)->setNormalData((float const *)arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Vbo_setNormalData(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 4) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; + int _v = 0; { { void *ptr; if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Vbo_setNormalData__SWIG_0(L);} } } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; + else { _v = 1; } } } if (!_v) goto check_1; return _wrap_Vbo_setNormalData__SWIG_0(L);} check_1: if (argc == 4) { + int _v = 0; { { void *ptr; if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Vbo_setNormalData__SWIG_1(L);} } } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { - return _wrap_Vbo_setNormalData__SWIG_3(L);} } } } } if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_Vbo_setNormalData__SWIG_2(L);} } } } } } + else { _v = 1; } } } if (!_v) goto check_2; return _wrap_Vbo_setNormalData__SWIG_1(L);} check_2: if (argc == 4) { + return _wrap_Vbo_setNormalData__SWIG_3(L);} if (argc == 5) { return _wrap_Vbo_setNormalData__SWIG_2(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_setNormalData'\n" " Possible C/C++ prototypes are:\n" " ofVbo::setNormalData(glm::vec3 const *,int,int)\n" " ofVbo::setNormalData(ofVec3f const *,int,int)\n" " ofVbo::setNormalData(float const *,int,int,int)\n" " ofVbo::setNormalData(float const *,int,int)\n"); @@ -26547,27 +28378,13 @@ static int _wrap_Vbo_setTexCoordData__SWIG_3(lua_State* L) { int SWIG_arg = 0; o (arg1)->setTexCoordData((float const *)arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Vbo_setTexCoordData(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); - if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; + if (argc == 4) { int _v = 0; { { void *ptr; if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Vbo_setTexCoordData__SWIG_0(L);} } } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; + else { _v = 1; } } } if (!_v) goto check_1; return _wrap_Vbo_setTexCoordData__SWIG_0(L);} check_1: if (argc == 4) { + int _v = 0; { { void *ptr; if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Vbo_setTexCoordData__SWIG_1(L);} } } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { - return _wrap_Vbo_setTexCoordData__SWIG_3(L);} } } } } if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_Vbo_setTexCoordData__SWIG_2(L);} } } } } } + else { _v = 1; } } } if (!_v) goto check_2; return _wrap_Vbo_setTexCoordData__SWIG_1(L);} check_2: if (argc == 4) { + return _wrap_Vbo_setTexCoordData__SWIG_3(L);} if (argc == 5) { return _wrap_Vbo_setTexCoordData__SWIG_2(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_setTexCoordData'\n" " Possible C/C++ prototypes are:\n" " ofVbo::setTexCoordData(glm::vec2 const *,int,int)\n" " ofVbo::setTexCoordData(ofVec2f const *,int,int)\n" " ofVbo::setTexCoordData(float const *,int,int,int)\n" @@ -26603,19 +28420,8 @@ static int _wrap_Vbo_setAttributeData__SWIG_1(lua_State* L) { int SWIG_arg = 0; arg6 = (int)lua_tonumber(L, 6); (arg1)->setAttributeData(arg2,(float const *)arg3,arg4,arg5,arg6); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Vbo_setAttributeData(lua_State* L) { int argc; int argv[8]={ 1,2,3,4,5,6,7,8} ; argc = lua_gettop(L); - if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } - if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { return _wrap_Vbo_setAttributeData__SWIG_1(L);} } } } } } - } if (argc == 7) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } - if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { - return _wrap_Vbo_setAttributeData__SWIG_0(L);} } } } } } } } + if (argc == 6) { return _wrap_Vbo_setAttributeData__SWIG_1(L);} if (argc == 7) { + return _wrap_Vbo_setAttributeData__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_setAttributeData'\n" " Possible C/C++ prototypes are:\n" " ofVbo::setAttributeData(int,float const *,int,int,int,int)\n" " ofVbo::setAttributeData(int,float const *,int,int,int)\n"); lua_error(L);return 0; } @@ -26654,18 +28460,8 @@ static int _wrap_Vbo_setVertexBuffer__SWIG_1(lua_State* L) { int SWIG_arg = 0; o arg4 = (int)lua_tonumber(L, 4); (arg1)->setVertexBuffer(*arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Vbo_setVertexBuffer(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); - if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBufferObject, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Vbo_setVertexBuffer__SWIG_1(L);} } } } } if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBufferObject, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_Vbo_setVertexBuffer__SWIG_0(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_setVertexBuffer'\n" + if (argc == 4) { return _wrap_Vbo_setVertexBuffer__SWIG_1(L);} if (argc == 5) { return _wrap_Vbo_setVertexBuffer__SWIG_0(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_setVertexBuffer'\n" " Possible C/C++ prototypes are:\n" " ofVbo::setVertexBuffer(ofBufferObject &,int,int,int)\n" " ofVbo::setVertexBuffer(ofBufferObject &,int,int)\n"); lua_error(L);return 0; } static int _wrap_Vbo_setColorBuffer__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; @@ -26691,16 +28487,7 @@ static int _wrap_Vbo_setColorBuffer__SWIG_1(lua_State* L) { int SWIG_arg = 0; of SWIG_fail_ptr("Vbo_setColorBuffer",2,SWIGTYPE_p_ofBufferObject); } arg3 = (int)lua_tonumber(L, 3); (arg1)->setColorBuffer(*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Vbo_setColorBuffer(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBufferObject, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Vbo_setColorBuffer__SWIG_1(L);} - } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBufferObject, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Vbo_setColorBuffer__SWIG_0(L);} } } } } + return _wrap_Vbo_setColorBuffer__SWIG_1(L);} if (argc == 4) { return _wrap_Vbo_setColorBuffer__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_setColorBuffer'\n" " Possible C/C++ prototypes are:\n" " ofVbo::setColorBuffer(ofBufferObject &,int,int)\n" " ofVbo::setColorBuffer(ofBufferObject &,int)\n"); lua_error(L);return 0; } @@ -26727,16 +28514,7 @@ static int _wrap_Vbo_setNormalBuffer__SWIG_1(lua_State* L) { int SWIG_arg = 0; o SWIG_fail_ptr("Vbo_setNormalBuffer",2,SWIGTYPE_p_ofBufferObject); } arg3 = (int)lua_tonumber(L, 3); (arg1)->setNormalBuffer(*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Vbo_setNormalBuffer(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBufferObject, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Vbo_setNormalBuffer__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBufferObject, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Vbo_setNormalBuffer__SWIG_0(L);} } } } } + return _wrap_Vbo_setNormalBuffer__SWIG_1(L);} if (argc == 4) { return _wrap_Vbo_setNormalBuffer__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_setNormalBuffer'\n" " Possible C/C++ prototypes are:\n" " ofVbo::setNormalBuffer(ofBufferObject &,int,int)\n" " ofVbo::setNormalBuffer(ofBufferObject &,int)\n"); lua_error(L);return 0; } @@ -26763,17 +28541,8 @@ static int _wrap_Vbo_setTexCoordBuffer__SWIG_1(lua_State* L) { int SWIG_arg = 0; SWIG_fail_ptr("Vbo_setTexCoordBuffer",2,SWIGTYPE_p_ofBufferObject); } arg3 = (int)lua_tonumber(L, 3); (arg1)->setTexCoordBuffer(*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Vbo_setTexCoordBuffer(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBufferObject, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Vbo_setTexCoordBuffer__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBufferObject, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Vbo_setTexCoordBuffer__SWIG_0(L);} } } } } + if (argc == 3) { return _wrap_Vbo_setTexCoordBuffer__SWIG_1(L);} if (argc == 4) { + return _wrap_Vbo_setTexCoordBuffer__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_setTexCoordBuffer'\n" " Possible C/C++ prototypes are:\n" " ofVbo::setTexCoordBuffer(ofBufferObject &,int,int)\n" " ofVbo::setTexCoordBuffer(ofBufferObject &,int)\n"); lua_error(L);return 0; } @@ -26813,19 +28582,8 @@ static int _wrap_Vbo_setAttributeBuffer__SWIG_1(lua_State* L) { int SWIG_arg = 0 arg5 = (int)lua_tonumber(L, 5); (arg1)->setAttributeBuffer(arg2,*arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Vbo_setAttributeBuffer(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofBufferObject, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_Vbo_setAttributeBuffer__SWIG_1(L);} } } } } } - if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofBufferObject, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { - return _wrap_Vbo_setAttributeBuffer__SWIG_0(L);} } } } } } } + if (argc == 5) { return _wrap_Vbo_setAttributeBuffer__SWIG_1(L);} if (argc == 6) { + return _wrap_Vbo_setAttributeBuffer__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_setAttributeBuffer'\n" " Possible C/C++ prototypes are:\n" " ofVbo::setAttributeBuffer(int,ofBufferObject &,int,int,int)\n" " ofVbo::setAttributeBuffer(int,ofBufferObject &,int,int)\n"); lua_error(L);return 0; } @@ -26882,10 +28640,7 @@ static int _wrap_Vbo_getVertexBuffer__SWIG_1(lua_State* L) { int SWIG_arg = 0; o SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofBufferObject,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Vbo_getVertexBuffer(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Vbo_getVertexBuffer__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vbo_getVertexBuffer__SWIG_1(L);} } + return _wrap_Vbo_getVertexBuffer__SWIG_0(L);} if (argc == 1) { return _wrap_Vbo_getVertexBuffer__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_getVertexBuffer'\n" " Possible C/C++ prototypes are:\n" " ofVbo::getVertexBuffer()\n" " ofVbo::getVertexBuffer() const\n"); lua_error(L);return 0; } @@ -26898,10 +28653,7 @@ static int _wrap_Vbo_getColorBuffer__SWIG_1(lua_State* L) { int SWIG_arg = 0; of SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofBufferObject,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Vbo_getColorBuffer(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Vbo_getColorBuffer__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vbo_getColorBuffer__SWIG_1(L);} } + return _wrap_Vbo_getColorBuffer__SWIG_0(L);} if (argc == 1) { return _wrap_Vbo_getColorBuffer__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_getColorBuffer'\n" " Possible C/C++ prototypes are:\n" " ofVbo::getColorBuffer()\n" " ofVbo::getColorBuffer() const\n"); lua_error(L);return 0; } static int _wrap_Vbo_getNormalBuffer__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; @@ -26913,10 +28665,7 @@ static int _wrap_Vbo_getNormalBuffer__SWIG_1(lua_State* L) { int SWIG_arg = 0; o SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofBufferObject,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Vbo_getNormalBuffer(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Vbo_getNormalBuffer__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vbo_getNormalBuffer__SWIG_1(L);} } + return _wrap_Vbo_getNormalBuffer__SWIG_0(L);} if (argc == 1) { return _wrap_Vbo_getNormalBuffer__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_getNormalBuffer'\n" " Possible C/C++ prototypes are:\n" " ofVbo::getNormalBuffer()\n" " ofVbo::getNormalBuffer() const\n"); lua_error(L);return 0; } @@ -26929,10 +28678,7 @@ static int _wrap_Vbo_getTexCoordBuffer__SWIG_1(lua_State* L) { int SWIG_arg = 0; SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofBufferObject,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Vbo_getTexCoordBuffer(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Vbo_getTexCoordBuffer__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vbo_getTexCoordBuffer__SWIG_1(L);} } + return _wrap_Vbo_getTexCoordBuffer__SWIG_0(L);} if (argc == 1) { return _wrap_Vbo_getTexCoordBuffer__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_getTexCoordBuffer'\n" " Possible C/C++ prototypes are:\n" " ofVbo::getTexCoordBuffer()\n" " ofVbo::getTexCoordBuffer() const\n"); lua_error(L);return 0; } @@ -26945,10 +28691,7 @@ static int _wrap_Vbo_getIndexBuffer__SWIG_1(lua_State* L) { int SWIG_arg = 0; of SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofBufferObject,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Vbo_getIndexBuffer(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Vbo_getIndexBuffer__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vbo_getIndexBuffer__SWIG_1(L);} } + return _wrap_Vbo_getIndexBuffer__SWIG_0(L);} if (argc == 1) { return _wrap_Vbo_getIndexBuffer__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_getIndexBuffer'\n" " Possible C/C++ prototypes are:\n" " ofVbo::getIndexBuffer()\n" " ofVbo::getIndexBuffer() const\n"); lua_error(L);return 0; } static int _wrap_Vbo_getAttributeBuffer__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; int arg2 ; @@ -26961,21 +28704,17 @@ static int _wrap_Vbo_getAttributeBuffer__SWIG_1(lua_State* L) { int SWIG_arg = 0 SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofBufferObject,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Vbo_getAttributeBuffer(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Vbo_getAttributeBuffer__SWIG_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Vbo_getAttributeBuffer__SWIG_1(L);} } - } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_getAttributeBuffer'\n" + return _wrap_Vbo_getAttributeBuffer__SWIG_0(L);} if (argc == 2) { return _wrap_Vbo_getAttributeBuffer__SWIG_1(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_getAttributeBuffer'\n" " Possible C/C++ prototypes are:\n" " ofVbo::getAttributeBuffer(int)\n" " ofVbo::getAttributeBuffer(int) const\n"); lua_error(L);return 0; } static int _wrap_Vbo_updateMesh(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; ofMesh *arg2 = 0 ; SWIG_check_num_args("ofVbo::updateMesh",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::updateMesh",1,"ofVbo *"); if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVbo::updateMesh",2,"ofMesh const &"); if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ SWIG_fail_ptr("Vbo_updateMesh",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofMesh_T_glm__vec3_glm__vec3_ofColor_T_float_t_glm__vec2_t,0))){ - SWIG_fail_ptr("Vbo_updateMesh",2,SWIGTYPE_p_ofMesh_T_glm__vec3_glm__vec3_ofColor_T_float_t_glm__vec2_t); } - (arg1)->updateMesh((ofMesh const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("Vbo_updateMesh",2,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + (arg1)->updateMesh((ofMesh const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Vbo_updateVertexData__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; glm::vec3 *arg2 = (glm::vec3 *) 0 ; int arg3 ; SWIG_check_num_args("ofVbo::updateVertexData",3,3) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::updateVertexData",1,"ofVbo *"); @@ -27094,31 +28833,20 @@ static int _wrap_Vbo_updateVertexData__SWIG_4(lua_State* L) { int SWIG_arg = 0; SWIG_fail_ptr("Vbo_updateVertexData",2,SWIGTYPE_p_float); } arg3 = (int)lua_tonumber(L, 3); (arg1)->updateVertexData((float const *)arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Vbo_updateVertexData(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; + int _v = 0; { { void *ptr; if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Vbo_updateVertexData__SWIG_0(L);} } } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; + else { _v = 1; } } } if (!_v) goto check_1; return _wrap_Vbo_updateVertexData__SWIG_0(L);} check_1: if (argc == 3) { + int _v = 0; { { void *ptr; if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Vbo_updateVertexData__SWIG_1(L);} } } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; + else { _v = 1; } } } if (!_v) goto check_2; return _wrap_Vbo_updateVertexData__SWIG_1(L);} check_2: if (argc == 3) { + int _v = 0; { { void *ptr; if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Vbo_updateVertexData__SWIG_2(L);} } } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; + else { _v = 1; } } } if (!_v) goto check_3; return _wrap_Vbo_updateVertexData__SWIG_2(L);} check_3: if (argc == 3) { + int _v = 0; { { void *ptr; if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Vbo_updateVertexData__SWIG_3(L);} } } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Vbo_updateVertexData__SWIG_4(L);} } - } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_updateVertexData'\n" + else { _v = 1; } } } if (!_v) goto check_4; return _wrap_Vbo_updateVertexData__SWIG_3(L);} check_4: if (argc == 3) { + return _wrap_Vbo_updateVertexData__SWIG_4(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_updateVertexData'\n" " Possible C/C++ prototypes are:\n" " ofVbo::updateVertexData(glm::vec3 const *,int)\n" " ofVbo::updateVertexData(glm::vec2 const *,int)\n" " ofVbo::updateVertexData(ofVec3f const *,int)\n" " ofVbo::updateVertexData(ofVec2f const *,int)\n" " ofVbo::updateVertexData(float const *,int)\n"); @@ -27134,16 +28862,11 @@ static int _wrap_Vbo_updateColorData__SWIG_1(lua_State* L) { int SWIG_arg = 0; o SWIG_fail_ptr("Vbo_updateColorData",2,SWIGTYPE_p_float); } arg3 = (int)lua_tonumber(L, 3); (arg1)->updateColorData((float const *)arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Vbo_updateColorData(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; + int _v = 0; { { void *ptr; if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Vbo_updateColorData__SWIG_0(L);} } } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Vbo_updateColorData__SWIG_1(L);} } - } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_updateColorData'\n" + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_Vbo_updateColorData__SWIG_0(L);} check_1: + if (argc == 3) { return _wrap_Vbo_updateColorData__SWIG_1(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_updateColorData'\n" " Possible C/C++ prototypes are:\n" " ofVbo::updateColorData(ofFloatColor const *,int)\n" " ofVbo::updateColorData(float const *,int)\n"); lua_error(L);return 0; } static int _wrap_Vbo_updateNormalData__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; @@ -27157,21 +28880,14 @@ static int _wrap_Vbo_updateNormalData__SWIG_2(lua_State* L) { int SWIG_arg = 0; SWIG_fail_ptr("Vbo_updateNormalData",2,SWIGTYPE_p_float); } arg3 = (int)lua_tonumber(L, 3); (arg1)->updateNormalData((float const *)arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Vbo_updateNormalData(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; + int _v = 0; { { void *ptr; if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Vbo_updateNormalData__SWIG_0(L);} } } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; + else { _v = 1; } } } if (!_v) goto check_1; return _wrap_Vbo_updateNormalData__SWIG_0(L);} check_1: if (argc == 3) { + int _v = 0; { { void *ptr; if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Vbo_updateNormalData__SWIG_1(L);} } } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Vbo_updateNormalData__SWIG_2(L);} } - } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_updateNormalData'\n" + else { _v = 1; } } } if (!_v) goto check_2; return _wrap_Vbo_updateNormalData__SWIG_1(L);} check_2: if (argc == 3) { + return _wrap_Vbo_updateNormalData__SWIG_2(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_updateNormalData'\n" " Possible C/C++ prototypes are:\n" " ofVbo::updateNormalData(glm::vec3 const *,int)\n" " ofVbo::updateNormalData(ofVec3f const *,int)\n" " ofVbo::updateNormalData(float const *,int)\n"); lua_error(L);return 0; } @@ -27186,22 +28902,14 @@ static int _wrap_Vbo_updateTexCoordData__SWIG_2(lua_State* L) { int SWIG_arg = 0 SWIG_fail_ptr("Vbo_updateTexCoordData",2,SWIGTYPE_p_float); } arg3 = (int)lua_tonumber(L, 3); (arg1)->updateTexCoordData((float const *)arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Vbo_updateTexCoordData(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; + if (argc == 3) { int _v = 0; { { void *ptr; if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Vbo_updateTexCoordData__SWIG_0(L);} } } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; + else { _v = 1; } } } if (!_v) goto check_1; return _wrap_Vbo_updateTexCoordData__SWIG_0(L);} check_1: + if (argc == 3) { int _v = 0; { { void *ptr; if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Vbo_updateTexCoordData__SWIG_1(L);} } } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Vbo_updateTexCoordData__SWIG_2(L);} - } } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_updateTexCoordData'\n" + else { _v = 1; } } } if (!_v) goto check_2; return _wrap_Vbo_updateTexCoordData__SWIG_1(L);} check_2: + if (argc == 3) { return _wrap_Vbo_updateTexCoordData__SWIG_2(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_updateTexCoordData'\n" " Possible C/C++ prototypes are:\n" " ofVbo::updateTexCoordData(glm::vec2 const *,int)\n" " ofVbo::updateTexCoordData(ofVec2f const *,int)\n" " ofVbo::updateTexCoordData(float const *,int)\n"); lua_error(L);return 0; } @@ -27358,12 +29066,7 @@ static int _wrap_Vbo_drawElements__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVb arg2 = (int)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); ((ofVbo const *)arg1)->drawElements(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Vbo_drawElements(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_Vbo_drawElements__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Vbo_drawElements__SWIG_0(L);} } } } } + return _wrap_Vbo_drawElements__SWIG_1(L);} if (argc == 4) { return _wrap_Vbo_drawElements__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_drawElements'\n" " Possible C/C++ prototypes are:\n" " ofVbo::drawElements(int,int,int) const\n" " ofVbo::drawElements(int,int) const\n"); lua_error(L);return 0; } static int _wrap_Vbo_drawInstanced(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; int arg2 ; int arg3 ; @@ -27557,6 +29260,11 @@ static swig_lua_class *swig_Vbo_bases[] = {0}; static const char *swig_Vbo_base_names[] = {0}; static swig_lua_class _wrap_class_Vbo = { "Vbo", "Vbo", &SWIGTYPE_p_ofVbo,_proxy__wrap_new_Vbo, swig_delete_Vbo, swig_Vbo_methods, swig_Vbo_attributes, &swig_Vbo_Sf_SwigStatic, swig_Vbo_meta, swig_Vbo_bases, swig_Vbo_base_names }; +static int _wrap_VboMesh_draw__SWIG_0_0(lua_State* L) { int SWIG_arg = 0; ofVboMesh *arg1 = (ofVboMesh *) 0 ; + SWIG_check_num_args("draw",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("draw",1,"ofVboMesh const *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVboMesh,0))){ + SWIG_fail_ptr("VboMesh_draw",1,SWIGTYPE_p_ofVboMesh); } ((ofVboMesh const *)arg1)->draw(); return SWIG_arg; + if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_new_VboMesh__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVboMesh *result = 0 ; SWIG_check_num_args("ofVboMesh::ofVboMesh",0,0) result = (ofVboMesh *)new ofVboMesh(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVboMesh,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); @@ -27564,14 +29272,12 @@ static int _wrap_new_VboMesh__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVboMesh static int _wrap_new_VboMesh__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = 0 ; ofVboMesh *result = 0 ; SWIG_check_num_args("ofVboMesh::ofVboMesh",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofVboMesh::ofVboMesh",1,"ofMesh const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_glm__vec3_glm__vec3_ofColor_T_float_t_glm__vec2_t,0))){ - SWIG_fail_ptr("new_VboMesh",1,SWIGTYPE_p_ofMesh_T_glm__vec3_glm__vec3_ofColor_T_float_t_glm__vec2_t); } - result = (ofVboMesh *)new ofVboMesh((ofMesh const &)*arg1); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVboMesh,1); SWIG_arg++; + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0))){ + SWIG_fail_ptr("new_VboMesh",1,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t); } + result = (ofVboMesh *)new ofVboMesh((ofMesh const &)*arg1); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVboMesh,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_new_VboMesh(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_VboMesh__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh_T_glm__vec3_glm__vec3_ofColor_T_float_t_glm__vec2_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_new_VboMesh__SWIG_1(L);} } + return _wrap_new_VboMesh__SWIG_0(L);} if (argc == 1) { return _wrap_new_VboMesh__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_VboMesh'\n" " Possible C/C++ prototypes are:\n" " ofVboMesh::ofVboMesh()\n" " ofVboMesh::ofVboMesh(ofMesh const &)\n"); lua_error(L);return 0; } static int _wrap_VboMesh_setUsage(lua_State* L) { int SWIG_arg = 0; ofVboMesh *arg1 = (ofVboMesh *) 0 ; int arg2 ; @@ -27580,78 +29286,6 @@ static int _wrap_VboMesh_setUsage(lua_State* L) { int SWIG_arg = 0; ofVboMesh *a if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVboMesh,0))){ SWIG_fail_ptr("VboMesh_setUsage",1,SWIGTYPE_p_ofVboMesh); } arg2 = (int)lua_tonumber(L, 2); (arg1)->setUsage(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VboMesh_enableColors(lua_State* L) { int SWIG_arg = 0; ofVboMesh *arg1 = (ofVboMesh *) 0 ; - SWIG_check_num_args("ofVboMesh::enableColors",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVboMesh::enableColors",1,"ofVboMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVboMesh,0))){ - SWIG_fail_ptr("VboMesh_enableColors",1,SWIGTYPE_p_ofVboMesh); } (arg1)->enableColors(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_VboMesh_enableTextures(lua_State* L) { int SWIG_arg = 0; ofVboMesh *arg1 = (ofVboMesh *) 0 ; - SWIG_check_num_args("ofVboMesh::enableTextures",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVboMesh::enableTextures",1,"ofVboMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVboMesh,0))){ - SWIG_fail_ptr("VboMesh_enableTextures",1,SWIGTYPE_p_ofVboMesh); } (arg1)->enableTextures(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VboMesh_enableNormals(lua_State* L) { int SWIG_arg = 0; ofVboMesh *arg1 = (ofVboMesh *) 0 ; - SWIG_check_num_args("ofVboMesh::enableNormals",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVboMesh::enableNormals",1,"ofVboMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVboMesh,0))){ - SWIG_fail_ptr("VboMesh_enableNormals",1,SWIGTYPE_p_ofVboMesh); } (arg1)->enableNormals(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_VboMesh_enableIndices(lua_State* L) { int SWIG_arg = 0; ofVboMesh *arg1 = (ofVboMesh *) 0 ; - SWIG_check_num_args("ofVboMesh::enableIndices",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVboMesh::enableIndices",1,"ofVboMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVboMesh,0))){ - SWIG_fail_ptr("VboMesh_enableIndices",1,SWIGTYPE_p_ofVboMesh); } (arg1)->enableIndices(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_VboMesh_disableColors(lua_State* L) { int SWIG_arg = 0; ofVboMesh *arg1 = (ofVboMesh *) 0 ; - SWIG_check_num_args("ofVboMesh::disableColors",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVboMesh::disableColors",1,"ofVboMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVboMesh,0))){ - SWIG_fail_ptr("VboMesh_disableColors",1,SWIGTYPE_p_ofVboMesh); } (arg1)->disableColors(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_VboMesh_disableTextures(lua_State* L) { int SWIG_arg = 0; ofVboMesh *arg1 = (ofVboMesh *) 0 ; - SWIG_check_num_args("ofVboMesh::disableTextures",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVboMesh::disableTextures",1,"ofVboMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVboMesh,0))){ - SWIG_fail_ptr("VboMesh_disableTextures",1,SWIGTYPE_p_ofVboMesh); } (arg1)->disableTextures(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VboMesh_disableNormals(lua_State* L) { int SWIG_arg = 0; ofVboMesh *arg1 = (ofVboMesh *) 0 ; - SWIG_check_num_args("ofVboMesh::disableNormals",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVboMesh::disableNormals",1,"ofVboMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVboMesh,0))){ - SWIG_fail_ptr("VboMesh_disableNormals",1,SWIGTYPE_p_ofVboMesh); } (arg1)->disableNormals(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VboMesh_disableIndices(lua_State* L) { int SWIG_arg = 0; ofVboMesh *arg1 = (ofVboMesh *) 0 ; - SWIG_check_num_args("ofVboMesh::disableIndices",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVboMesh::disableIndices",1,"ofVboMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVboMesh,0))){ - SWIG_fail_ptr("VboMesh_disableIndices",1,SWIGTYPE_p_ofVboMesh); } (arg1)->disableIndices(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VboMesh_usingColors(lua_State* L) { int SWIG_arg = 0; ofVboMesh *arg1 = (ofVboMesh *) 0 ; bool result; - SWIG_check_num_args("ofVboMesh::usingColors",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVboMesh::usingColors",1,"ofVboMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVboMesh,0))){ - SWIG_fail_ptr("VboMesh_usingColors",1,SWIGTYPE_p_ofVboMesh); } result = (bool)((ofVboMesh const *)arg1)->usingColors(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VboMesh_usingTextures(lua_State* L) { int SWIG_arg = 0; ofVboMesh *arg1 = (ofVboMesh *) 0 ; bool result; - SWIG_check_num_args("ofVboMesh::usingTextures",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVboMesh::usingTextures",1,"ofVboMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVboMesh,0))){ - SWIG_fail_ptr("VboMesh_usingTextures",1,SWIGTYPE_p_ofVboMesh); } result = (bool)((ofVboMesh const *)arg1)->usingTextures(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VboMesh_usingNormals(lua_State* L) { int SWIG_arg = 0; ofVboMesh *arg1 = (ofVboMesh *) 0 ; bool result; - SWIG_check_num_args("ofVboMesh::usingNormals",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVboMesh::usingNormals",1,"ofVboMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVboMesh,0))){ - SWIG_fail_ptr("VboMesh_usingNormals",1,SWIGTYPE_p_ofVboMesh); } result = (bool)((ofVboMesh const *)arg1)->usingNormals(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VboMesh_usingIndices(lua_State* L) { int SWIG_arg = 0; ofVboMesh *arg1 = (ofVboMesh *) 0 ; bool result; - SWIG_check_num_args("ofVboMesh::usingIndices",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVboMesh::usingIndices",1,"ofVboMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVboMesh,0))){ - SWIG_fail_ptr("VboMesh_usingIndices",1,SWIGTYPE_p_ofVboMesh); } result = (bool)((ofVboMesh const *)arg1)->usingIndices(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_VboMesh_draw__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVboMesh *arg1 = (ofVboMesh *) 0 ; ofPolyRenderMode arg2 ; SWIG_check_num_args("ofVboMesh::draw",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVboMesh::draw",1,"ofVboMesh const *"); @@ -27659,12 +29293,10 @@ static int _wrap_VboMesh_draw__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVboMes if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVboMesh,0))){ SWIG_fail_ptr("VboMesh_draw",1,SWIGTYPE_p_ofVboMesh); } arg2 = (ofPolyRenderMode)(int)lua_tonumber(L, 2); ((ofVboMesh const *)arg1)->draw(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VboMesh_draw(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVboMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_VboMesh_draw__SWIG_1(L);} } } +static int _wrap_VboMesh_draw(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { + return _wrap_VboMesh_draw__SWIG_0_0(L);} if (argc == 2) { return _wrap_VboMesh_draw__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'VboMesh_draw'\n" " Possible C/C++ prototypes are:\n" - " ofVboMesh::draw()\n" " ofVboMesh::draw(ofPolyRenderMode) const\n"); lua_error(L);return 0; } + " draw() const\n" " ofVboMesh::draw(ofPolyRenderMode) const\n"); lua_error(L);return 0; } static int _wrap_VboMesh_drawInstanced(lua_State* L) { int SWIG_arg = 0; ofVboMesh *arg1 = (ofVboMesh *) 0 ; ofPolyRenderMode arg2 ; int arg3 ; SWIG_check_num_args("ofVboMesh::drawInstanced",3,3) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVboMesh::drawInstanced",1,"ofVboMesh const *"); @@ -27688,11 +29320,8 @@ static int _wrap_VboMesh_getVbo__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVboM SWIG_fail_ptr("VboMesh_getVbo",1,SWIGTYPE_p_ofVboMesh); } result = (ofVbo *) &((ofVboMesh const *)arg1)->getVbo(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVbo,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VboMesh_getVbo(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVboMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_VboMesh_getVbo__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVboMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_VboMesh_getVbo__SWIG_1(L);} } +static int _wrap_VboMesh_getVbo(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { + return _wrap_VboMesh_getVbo__SWIG_0(L);} if (argc == 1) { return _wrap_VboMesh_getVbo__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'VboMesh_getVbo'\n" " Possible C/C++ prototypes are:\n" " ofVboMesh::getVbo()\n" " ofVboMesh::getVbo() const\n"); lua_error(L);return 0; } static void swig_delete_VboMesh(void *obj) { @@ -27712,18 +29341,6 @@ static swig_lua_attribute swig_VboMesh_attributes[] = { }; static swig_lua_method swig_VboMesh_methods[]= { { "setUsage", _wrap_VboMesh_setUsage}, - { "enableColors", _wrap_VboMesh_enableColors}, - { "enableTextures", _wrap_VboMesh_enableTextures}, - { "enableNormals", _wrap_VboMesh_enableNormals}, - { "enableIndices", _wrap_VboMesh_enableIndices}, - { "disableColors", _wrap_VboMesh_disableColors}, - { "disableTextures", _wrap_VboMesh_disableTextures}, - { "disableNormals", _wrap_VboMesh_disableNormals}, - { "disableIndices", _wrap_VboMesh_disableIndices}, - { "usingColors", _wrap_VboMesh_usingColors}, - { "usingTextures", _wrap_VboMesh_usingTextures}, - { "usingNormals", _wrap_VboMesh_usingNormals}, - { "usingIndices", _wrap_VboMesh_usingIndices}, { "draw", _wrap_VboMesh_draw}, { "drawInstanced", _wrap_VboMesh_drawInstanced}, { "getVbo", _wrap_VboMesh_getVbo}, @@ -27754,8 +29371,8 @@ static swig_lua_namespace swig_VboMesh_Sf_SwigStatic = { swig_VboMesh_Sf_SwigStatic_classes, 0 }; -static swig_lua_class *swig_VboMesh_bases[] = {0}; -static const char *swig_VboMesh_base_names[] = {0}; +static swig_lua_class *swig_VboMesh_bases[] = {0,0}; +static const char *swig_VboMesh_base_names[] = {"ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *",0}; static swig_lua_class _wrap_class_VboMesh = { "VboMesh", "VboMesh", &SWIGTYPE_p_ofVboMesh,_proxy__wrap_new_VboMesh, swig_delete_VboMesh, swig_VboMesh_methods, swig_VboMesh_attributes, &swig_VboMesh_Sf_SwigStatic, swig_VboMesh_meta, swig_VboMesh_bases, swig_VboMesh_base_names }; static int _wrap_new_Pixels__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPixels_< unsigned char > *result = 0 ; @@ -27772,9 +29389,7 @@ static int _wrap_new_Pixels__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPixels_< SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofPixels_T_unsigned_char_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_new_Pixels(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_Pixels__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_new_Pixels__SWIG_1(L);} } + return _wrap_new_Pixels__SWIG_0(L);} if (argc == 1) { return _wrap_new_Pixels__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_Pixels'\n" " Possible C/C++ prototypes are:\n" " ofPixels_< unsigned char >::ofPixels_()\n" " ofPixels_< unsigned char >::ofPixels_(ofPixels_< unsigned char > &&)\n"); lua_error(L);return 0; } @@ -27852,14 +29467,8 @@ static int _wrap_Pixels_set__SWIG_1(lua_State* L) { int SWIG_arg = 0; SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (unsigned char)lua_tonumber(L, 3); (arg1)->set(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_set(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Pixels_set__SWIG_0(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_Pixels_set__SWIG_1(L);} } } } +static int _wrap_Pixels_set(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { + return _wrap_Pixels_set__SWIG_0(L);} if (argc == 3) { return _wrap_Pixels_set__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Pixels_set'\n" " Possible C/C++ prototypes are:\n" " ofPixels_< unsigned char >::set(unsigned char)\n" " ofPixels_< unsigned char >::set(size_t,unsigned char)\n"); lua_error(L);return 0; } @@ -28043,13 +29652,7 @@ static int _wrap_Pixels_resize__SWIG_1(lua_State* L) { int SWIG_arg = 0; result = (bool)(arg1)->resize(arg2,arg3); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Pixels_resize(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_Pixels_resize__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Pixels_resize__SWIG_0(L);} } } } } + return _wrap_Pixels_resize__SWIG_1(L);} if (argc == 4) { return _wrap_Pixels_resize__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Pixels_resize'\n" " Possible C/C++ prototypes are:\n" " ofPixels_< unsigned char >::resize(size_t,size_t,ofInterpolationMethod)\n" " ofPixels_< unsigned char >::resize(size_t,size_t)\n"); lua_error(L);return 0; } @@ -28078,17 +29681,7 @@ static int _wrap_Pixels_resizeTo__SWIG_1(lua_State* L) { int SWIG_arg = 0; result = (bool)((ofPixels_< unsigned char > const *)arg1)->resizeTo(*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Pixels_resizeTo(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Pixels_resizeTo__SWIG_1(L);} } } if (argc == 3) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Pixels_resizeTo__SWIG_0(L);} } } } + return _wrap_Pixels_resizeTo__SWIG_1(L);} if (argc == 3) { return _wrap_Pixels_resizeTo__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Pixels_resizeTo'\n" " Possible C/C++ prototypes are:\n" " ofPixels_< unsigned char >::resizeTo(ofPixels_< unsigned char > &,ofInterpolationMethod) const\n" " ofPixels_< unsigned char >::resizeTo(ofPixels_< unsigned char > &) const\n"); lua_error(L);return 0; } @@ -28146,13 +29739,8 @@ static int _wrap_Pixels_getData__SWIG_1(lua_State* L) { int SWIG_arg = 0; result = (unsigned char *)((ofPixels_< unsigned char > const *)arg1)->getData(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_unsigned_char,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_getData(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Pixels_getData__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Pixels_getData__SWIG_1(L);} } +static int _wrap_Pixels_getData(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { + return _wrap_Pixels_getData__SWIG_0(L);} if (argc == 1) { return _wrap_Pixels_getData__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Pixels_getData'\n" " Possible C/C++ prototypes are:\n" " ofPixels_< unsigned char >::getData()\n" " ofPixels_< unsigned char >::getData() const\n"); lua_error(L);return 0; } static int _wrap_Pixels_getPixelIndex(lua_State* L) { int SWIG_arg = 0; @@ -28194,13 +29782,7 @@ static int _wrap_Pixels_getColor__SWIG_1(lua_State* L) { int SWIG_arg = 0; SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Pixels_getColor(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Pixels_getColor__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_Pixels_getColor__SWIG_0(L);} } } } + return _wrap_Pixels_getColor__SWIG_1(L);} if (argc == 3) { return _wrap_Pixels_getColor__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Pixels_getColor'\n" " Possible C/C++ prototypes are:\n" " ofPixels_< unsigned char >::getColor(size_t,size_t) const\n" " ofPixels_< unsigned char >::getColor(size_t) const\n"); lua_error(L);return 0; } @@ -28244,22 +29826,8 @@ static int _wrap_Pixels_setColor__SWIG_2(lua_State* L) { int SWIG_arg = 0; (arg1)->setColor((ofColor_< unsigned char > const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Pixels_setColor(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Pixels_setColor__SWIG_2(L);} } } if (argc == 3) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Pixels_setColor__SWIG_1(L);} } } } if (argc == 4) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Pixels_setColor__SWIG_0(L);} } } } } + return _wrap_Pixels_setColor__SWIG_2(L);} if (argc == 3) { return _wrap_Pixels_setColor__SWIG_1(L);} if (argc == 4) { + return _wrap_Pixels_setColor__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Pixels_setColor'\n" " Possible C/C++ prototypes are:\n" " ofPixels_< unsigned char >::setColor(size_t,size_t,ofColor_< unsigned char > const &)\n" " ofPixels_< unsigned char >::setColor(size_t,ofColor_< unsigned char > const &)\n" @@ -28424,22 +29992,6 @@ static int _wrap_Pixels_setNumChannels(lua_State* L) { int SWIG_arg = 0; SWIG_fail_ptr("Pixels_setNumChannels",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); (arg1)->setNumChannels(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_width_get(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; float result; - SWIG_check_num_args("ofPixels_< unsigned char >::width",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::width",1,"ofPixels_< unsigned char > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_width_get",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - result = (float)ofPixels__Sl_unsigned_SS_char_Sg__width_get(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_height_get(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; float result; - SWIG_check_num_args("ofPixels_< unsigned char >::height",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::height",1,"ofPixels_< unsigned char > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_height_get",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - result = (float)ofPixels__Sl_unsigned_SS_char_Sg__height_get(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static void swig_delete_Pixels(void *obj) { ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) obj; delete arg1; @@ -28453,8 +30005,6 @@ static int _proxy__wrap_new_Pixels(lua_State *L) { return 1; } static swig_lua_attribute swig_Pixels_attributes[] = { - { "width", _wrap_Pixels_width_get, SWIG_Lua_set_immutable }, - { "height", _wrap_Pixels_height_get, SWIG_Lua_set_immutable }, {0,0,0} }; static swig_lua_method swig_Pixels_methods[]= { @@ -28546,9 +30096,7 @@ static int _wrap_new_FloatPixels__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPix SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofPixels_T_float_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_new_FloatPixels(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_FloatPixels__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_new_FloatPixels__SWIG_1(L);} } + return _wrap_new_FloatPixels__SWIG_0(L);} if (argc == 1) { return _wrap_new_FloatPixels__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_FloatPixels'\n" " Possible C/C++ prototypes are:\n" " ofPixels_< float >::ofPixels_()\n" " ofPixels_< float >::ofPixels_(ofPixels_< float > &&)\n"); lua_error(L);return 0; } static int _wrap_FloatPixels_allocate(lua_State* L) { int SWIG_arg = 0; ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; @@ -28620,13 +30168,7 @@ static int _wrap_FloatPixels_set__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPix arg3 = (float)lua_tonumber(L, 3); (arg1)->set(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_FloatPixels_set(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_FloatPixels_set__SWIG_0(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_FloatPixels_set__SWIG_1(L);} } } } + return _wrap_FloatPixels_set__SWIG_0(L);} if (argc == 3) { return _wrap_FloatPixels_set__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatPixels_set'\n" " Possible C/C++ prototypes are:\n" " ofPixels_< float >::set(float)\n" " ofPixels_< float >::set(size_t,float)\n"); lua_error(L);return 0; } static int _wrap_FloatPixels_setFromPixels(lua_State* L) { int SWIG_arg = 0; @@ -28802,13 +30344,7 @@ static int _wrap_FloatPixels_resize__SWIG_1(lua_State* L) { int SWIG_arg = 0; result = (bool)(arg1)->resize(arg2,arg3); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_FloatPixels_resize(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_FloatPixels_resize__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_FloatPixels_resize__SWIG_0(L);} } } } } + return _wrap_FloatPixels_resize__SWIG_1(L);} if (argc == 4) { return _wrap_FloatPixels_resize__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatPixels_resize'\n" " Possible C/C++ prototypes are:\n" " ofPixels_< float >::resize(size_t,size_t,ofInterpolationMethod)\n" " ofPixels_< float >::resize(size_t,size_t)\n"); lua_error(L);return 0; } @@ -28837,17 +30373,7 @@ static int _wrap_FloatPixels_resizeTo__SWIG_1(lua_State* L) { int SWIG_arg = 0; result = (bool)((ofPixels_< float > const *)arg1)->resizeTo(*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_FloatPixels_resizeTo(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_FloatPixels_resizeTo__SWIG_1(L);} } } if (argc == 3) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_FloatPixels_resizeTo__SWIG_0(L);} } } } + return _wrap_FloatPixels_resizeTo__SWIG_1(L);} if (argc == 3) { return _wrap_FloatPixels_resizeTo__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatPixels_resizeTo'\n" " Possible C/C++ prototypes are:\n" " ofPixels_< float >::resizeTo(ofPixels_< float > &,ofInterpolationMethod) const\n" " ofPixels_< float >::resizeTo(ofPixels_< float > &) const\n"); lua_error(L);return 0; } @@ -28904,12 +30430,7 @@ static int _wrap_FloatPixels_getData__SWIG_1(lua_State* L) { int SWIG_arg = 0; result = (float *)((ofPixels_< float > const *)arg1)->getData(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_float,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_FloatPixels_getData(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_FloatPixels_getData__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_FloatPixels_getData__SWIG_1(L);} } + return _wrap_FloatPixels_getData__SWIG_0(L);} if (argc == 1) { return _wrap_FloatPixels_getData__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatPixels_getData'\n" " Possible C/C++ prototypes are:\n" " ofPixels_< float >::getData()\n" " ofPixels_< float >::getData() const\n"); lua_error(L);return 0; } @@ -28952,13 +30473,7 @@ static int _wrap_FloatPixels_getColor__SWIG_1(lua_State* L) { int SWIG_arg = 0; SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_FloatPixels_getColor(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_FloatPixels_getColor__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_FloatPixels_getColor__SWIG_0(L);} } } } + return _wrap_FloatPixels_getColor__SWIG_1(L);} if (argc == 3) { return _wrap_FloatPixels_getColor__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatPixels_getColor'\n" " Possible C/C++ prototypes are:\n" " ofPixels_< float >::getColor(size_t,size_t) const\n" " ofPixels_< float >::getColor(size_t) const\n"); lua_error(L);return 0; } @@ -29001,22 +30516,8 @@ static int _wrap_FloatPixels_setColor__SWIG_2(lua_State* L) { int SWIG_arg = 0; SWIG_fail_ptr("FloatPixels_setColor",2,SWIGTYPE_p_ofColor_T_float_t); } (arg1)->setColor((ofColor_< float > const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_FloatPixels_setColor(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_FloatPixels_setColor__SWIG_2(L);} } } if (argc == 3) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_FloatPixels_setColor__SWIG_1(L);} } } } if (argc == 4) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_FloatPixels_setColor__SWIG_0(L);} } } } } + if (argc == 2) { return _wrap_FloatPixels_setColor__SWIG_2(L);} if (argc == 3) { + return _wrap_FloatPixels_setColor__SWIG_1(L);} if (argc == 4) { return _wrap_FloatPixels_setColor__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatPixels_setColor'\n" " Possible C/C++ prototypes are:\n" " ofPixels_< float >::setColor(size_t,size_t,ofColor_< float > const &)\n" " ofPixels_< float >::setColor(size_t,ofColor_< float > const &)\n" @@ -29174,20 +30675,6 @@ static int _wrap_FloatPixels_setNumChannels(lua_State* L) { int SWIG_arg = 0; SWIG_fail_ptr("FloatPixels_setNumChannels",1,SWIGTYPE_p_ofPixels_T_float_t); } SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); (arg1)->setNumChannels(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_width_get(lua_State* L) { int SWIG_arg = 0; ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; - float result; SWIG_check_num_args("ofPixels_< float >::width",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::width",1,"ofPixels_< float > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_width_get",1,SWIGTYPE_p_ofPixels_T_float_t); } - result = (float)ofPixels__Sl_float_Sg__width_get(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_height_get(lua_State* L) { int SWIG_arg = 0; ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; - float result; SWIG_check_num_args("ofPixels_< float >::height",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::height",1,"ofPixels_< float > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_height_get",1,SWIGTYPE_p_ofPixels_T_float_t); } - result = (float)ofPixels__Sl_float_Sg__height_get(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static void swig_delete_FloatPixels(void *obj) { ofPixels_< float > *arg1 = (ofPixels_< float > *) obj; delete arg1; @@ -29201,8 +30688,6 @@ static int _proxy__wrap_new_FloatPixels(lua_State *L) { return 1; } static swig_lua_attribute swig_FloatPixels_attributes[] = { - { "width", _wrap_FloatPixels_width_get, SWIG_Lua_set_immutable }, - { "height", _wrap_FloatPixels_height_get, SWIG_Lua_set_immutable }, {0,0,0} }; static swig_lua_method swig_FloatPixels_methods[]= { @@ -29295,9 +30780,7 @@ static int _wrap_new_ShortPixels__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPix SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofPixels_T_unsigned_short_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_new_ShortPixels(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_ShortPixels__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_new_ShortPixels__SWIG_1(L);} } + return _wrap_new_ShortPixels__SWIG_0(L);} if (argc == 1) { return _wrap_new_ShortPixels__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_ShortPixels'\n" " Possible C/C++ prototypes are:\n" " ofPixels_< unsigned short >::ofPixels_()\n" " ofPixels_< unsigned short >::ofPixels_(ofPixels_< unsigned short > &&)\n"); lua_error(L);return 0; } @@ -29376,13 +30859,7 @@ static int _wrap_ShortPixels_set__SWIG_1(lua_State* L) { int SWIG_arg = 0; SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (unsigned short)lua_tonumber(L, 3); (arg1)->set(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_ShortPixels_set(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_ShortPixels_set__SWIG_0(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_ShortPixels_set__SWIG_1(L);} } } } + return _wrap_ShortPixels_set__SWIG_0(L);} if (argc == 3) { return _wrap_ShortPixels_set__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortPixels_set'\n" " Possible C/C++ prototypes are:\n" " ofPixels_< unsigned short >::set(unsigned short)\n" " ofPixels_< unsigned short >::set(size_t,unsigned short)\n"); lua_error(L);return 0; } @@ -29566,13 +31043,7 @@ static int _wrap_ShortPixels_resize__SWIG_1(lua_State* L) { int SWIG_arg = 0; result = (bool)(arg1)->resize(arg2,arg3); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_ShortPixels_resize(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_ShortPixels_resize__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_ShortPixels_resize__SWIG_0(L);} } } } } + return _wrap_ShortPixels_resize__SWIG_1(L);} if (argc == 4) { return _wrap_ShortPixels_resize__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortPixels_resize'\n" " Possible C/C++ prototypes are:\n" " ofPixels_< unsigned short >::resize(size_t,size_t,ofInterpolationMethod)\n" " ofPixels_< unsigned short >::resize(size_t,size_t)\n"); lua_error(L);return 0; } @@ -29601,17 +31072,7 @@ static int _wrap_ShortPixels_resizeTo__SWIG_1(lua_State* L) { int SWIG_arg = 0; result = (bool)((ofPixels_< unsigned short > const *)arg1)->resizeTo(*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_ShortPixels_resizeTo(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_ShortPixels_resizeTo__SWIG_1(L);} } } if (argc == 3) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_ShortPixels_resizeTo__SWIG_0(L);} } } } + return _wrap_ShortPixels_resizeTo__SWIG_1(L);} if (argc == 3) { return _wrap_ShortPixels_resizeTo__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortPixels_resizeTo'\n" " Possible C/C++ prototypes are:\n" " ofPixels_< unsigned short >::resizeTo(ofPixels_< unsigned short > &,ofInterpolationMethod) const\n" @@ -29671,12 +31132,7 @@ static int _wrap_ShortPixels_getData__SWIG_1(lua_State* L) { int SWIG_arg = 0; SWIG_NewPointerObj(L,result,SWIGTYPE_p_unsigned_short,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_ShortPixels_getData(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_ShortPixels_getData__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_ShortPixels_getData__SWIG_1(L);} } + return _wrap_ShortPixels_getData__SWIG_0(L);} if (argc == 1) { return _wrap_ShortPixels_getData__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortPixels_getData'\n" " Possible C/C++ prototypes are:\n" " ofPixels_< unsigned short >::getData()\n" " ofPixels_< unsigned short >::getData() const\n"); lua_error(L);return 0; } @@ -29719,13 +31175,7 @@ static int _wrap_ShortPixels_getColor__SWIG_1(lua_State* L) { int SWIG_arg = 0; SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_short_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_ShortPixels_getColor(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_ShortPixels_getColor__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_ShortPixels_getColor__SWIG_0(L);} } } } + return _wrap_ShortPixels_getColor__SWIG_1(L);} if (argc == 3) { return _wrap_ShortPixels_getColor__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortPixels_getColor'\n" " Possible C/C++ prototypes are:\n" " ofPixels_< unsigned short >::getColor(size_t,size_t) const\n" " ofPixels_< unsigned short >::getColor(size_t) const\n"); lua_error(L);return 0; } @@ -29769,22 +31219,8 @@ static int _wrap_ShortPixels_setColor__SWIG_2(lua_State* L) { int SWIG_arg = 0; (arg1)->setColor((ofColor_< unsigned short > const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_ShortPixels_setColor(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_ShortPixels_setColor__SWIG_2(L);} } } if (argc == 3) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_ShortPixels_setColor__SWIG_1(L);} } } } if (argc == 4) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_ShortPixels_setColor__SWIG_0(L);} } } } } + if (argc == 2) { return _wrap_ShortPixels_setColor__SWIG_2(L);} if (argc == 3) { + return _wrap_ShortPixels_setColor__SWIG_1(L);} if (argc == 4) { return _wrap_ShortPixels_setColor__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortPixels_setColor'\n" " Possible C/C++ prototypes are:\n" " ofPixels_< unsigned short >::setColor(size_t,size_t,ofColor_< unsigned short > const &)\n" @@ -29950,22 +31386,6 @@ static int _wrap_ShortPixels_setNumChannels(lua_State* L) { int SWIG_arg = 0; SWIG_fail_ptr("ShortPixels_setNumChannels",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); (arg1)->setNumChannels(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_width_get(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; float result; - SWIG_check_num_args("ofPixels_< unsigned short >::width",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::width",1,"ofPixels_< unsigned short > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_width_get",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - result = (float)ofPixels__Sl_unsigned_SS_short_Sg__width_get(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_height_get(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; float result; - SWIG_check_num_args("ofPixels_< unsigned short >::height",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::height",1,"ofPixels_< unsigned short > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_height_get",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - result = (float)ofPixels__Sl_unsigned_SS_short_Sg__height_get(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static void swig_delete_ShortPixels(void *obj) { ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) obj; delete arg1; @@ -29979,8 +31399,6 @@ static int _proxy__wrap_new_ShortPixels(lua_State *L) { return 1; } static swig_lua_attribute swig_ShortPixels_attributes[] = { - { "width", _wrap_ShortPixels_width_get, SWIG_Lua_set_immutable }, - { "height", _wrap_ShortPixels_height_get, SWIG_Lua_set_immutable }, {0,0,0} }; static swig_lua_method swig_ShortPixels_methods[]= { @@ -30104,21 +31522,12 @@ static int _wrap_Path_lineTo__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofPath *a if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_lineTo",1,SWIGTYPE_p_ofPath); } arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); (arg1)->lineTo(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_lineTo(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Path_lineTo__SWIG_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Path_lineTo__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Path_lineTo__SWIG_2(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Path_lineTo__SWIG_3(L);} } } } } +static int _wrap_Path_lineTo(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_Path_lineTo__SWIG_0(L);} check_1: + if (argc == 2) { return _wrap_Path_lineTo__SWIG_1(L);} if (argc == 3) { return _wrap_Path_lineTo__SWIG_2(L);} + if (argc == 4) { return _wrap_Path_lineTo__SWIG_3(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Path_lineTo'\n" " Possible C/C++ prototypes are:\n" " ofPath::lineTo(glm::vec3 const &)\n" " ofPath::lineTo(glm::vec2 const &)\n" " ofPath::lineTo(float,float)\n" " ofPath::lineTo(float,float,float)\n"); lua_error(L);return 0; } @@ -30151,21 +31560,12 @@ static int _wrap_Path_moveTo__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofPath *a if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_moveTo",1,SWIGTYPE_p_ofPath); } arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); (arg1)->moveTo(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_moveTo(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Path_moveTo__SWIG_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Path_moveTo__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Path_moveTo__SWIG_3(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Path_moveTo__SWIG_2(L);} } } } } +static int _wrap_Path_moveTo(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_Path_moveTo__SWIG_0(L);} check_1: + if (argc == 2) { return _wrap_Path_moveTo__SWIG_1(L);} if (argc == 3) { return _wrap_Path_moveTo__SWIG_3(L);} + if (argc == 4) { return _wrap_Path_moveTo__SWIG_2(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Path_moveTo'\n" " Possible C/C++ prototypes are:\n" " ofPath::moveTo(glm::vec3 const &)\n" " ofPath::moveTo(glm::vec2 const &)\n" " ofPath::moveTo(float,float,float)\n" " ofPath::moveTo(float,float)\n"); lua_error(L);return 0; } @@ -30200,20 +31600,11 @@ static int _wrap_Path_curveTo__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofPath * arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); (arg1)->curveTo(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Path_curveTo(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Path_curveTo__SWIG_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Path_curveTo__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Path_curveTo__SWIG_2(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Path_curveTo__SWIG_3(L);} } } } } + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_Path_curveTo__SWIG_0(L);} check_1: + if (argc == 2) { return _wrap_Path_curveTo__SWIG_1(L);} if (argc == 3) { return _wrap_Path_curveTo__SWIG_2(L);} + if (argc == 4) { return _wrap_Path_curveTo__SWIG_3(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Path_curveTo'\n" " Possible C/C++ prototypes are:\n" " ofPath::curveTo(glm::vec3 const &)\n" " ofPath::curveTo(glm::vec2 const &)\n" " ofPath::curveTo(float,float)\n" " ofPath::curveTo(float,float,float)\n"); lua_error(L);return 0; } @@ -30279,36 +31670,17 @@ static int _wrap_Path_bezierTo__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofPath (arg1)->bezierTo(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Path_bezierTo(lua_State* L) { int argc; int argv[11]={ 1,2,3,4,5,6,7,8,9,10,11} ; argc = lua_gettop(L); - if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Path_bezierTo__SWIG_0(L);} } } } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_glm__vec2, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_glm__vec2, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Path_bezierTo__SWIG_1(L);} } } } } if (argc == 7) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { - return _wrap_Path_bezierTo__SWIG_2(L);} } } } } } } } if (argc == 10) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { { _v = lua_isnumber(L,argv[8]); } if (_v) { { - _v = lua_isnumber(L,argv[9]); } if (_v) { return _wrap_Path_bezierTo__SWIG_3(L);} } } } } } } } - } } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Path_bezierTo'\n" - " Possible C/C++ prototypes are:\n" " ofPath::bezierTo(glm::vec3 const &,glm::vec3 const &,glm::vec3 const &)\n" + if (argc == 4) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; { { void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; { { void *ptr; + if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_Path_bezierTo__SWIG_0(L);} check_1: + if (argc == 4) { return _wrap_Path_bezierTo__SWIG_1(L);} if (argc == 7) { return _wrap_Path_bezierTo__SWIG_2(L);} + if (argc == 10) { return _wrap_Path_bezierTo__SWIG_3(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Path_bezierTo'\n" " Possible C/C++ prototypes are:\n" + " ofPath::bezierTo(glm::vec3 const &,glm::vec3 const &,glm::vec3 const &)\n" " ofPath::bezierTo(glm::vec2 const &,glm::vec2 const &,glm::vec2 const &)\n" " ofPath::bezierTo(float,float,float,float,float,float)\n" " ofPath::bezierTo(float,float,float,float,float,float,float,float,float)\n"); lua_error(L);return 0; } @@ -30378,36 +31750,17 @@ static int _wrap_Path_quadBezierTo__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofP (arg1)->quadBezierTo(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Path_quadBezierTo(lua_State* L) { int argc; int argv[11]={ 1,2,3,4,5,6,7,8,9,10,11} ; argc = lua_gettop(L); - if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Path_quadBezierTo__SWIG_0(L);} } } } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_glm__vec2, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_glm__vec2, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Path_quadBezierTo__SWIG_1(L);} } } } } if (argc == 7) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { - return _wrap_Path_quadBezierTo__SWIG_2(L);} } } } } } } } if (argc == 10) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { { _v = lua_isnumber(L,argv[8]); } if (_v) { { - _v = lua_isnumber(L,argv[9]); } if (_v) { return _wrap_Path_quadBezierTo__SWIG_3(L);} } } } } } } - } } } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Path_quadBezierTo'\n" - " Possible C/C++ prototypes are:\n" " ofPath::quadBezierTo(glm::vec3 const &,glm::vec3 const &,glm::vec3 const &)\n" + if (argc == 4) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; { { void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; { { void *ptr; + if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_Path_quadBezierTo__SWIG_0(L);} check_1: + if (argc == 4) { return _wrap_Path_quadBezierTo__SWIG_1(L);} if (argc == 7) { return _wrap_Path_quadBezierTo__SWIG_2(L);} + if (argc == 10) { return _wrap_Path_quadBezierTo__SWIG_3(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Path_quadBezierTo'\n" " Possible C/C++ prototypes are:\n" + " ofPath::quadBezierTo(glm::vec3 const &,glm::vec3 const &,glm::vec3 const &)\n" " ofPath::quadBezierTo(glm::vec2 const &,glm::vec2 const &,glm::vec2 const &)\n" " ofPath::quadBezierTo(float,float,float,float,float,float)\n" " ofPath::quadBezierTo(float,float,float,float,float,float,float,float,float)\n"); lua_error(L);return 0; } @@ -30482,42 +31835,17 @@ static int _wrap_Path_arc__SWIG_5(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 arg8 = (float)lua_tonumber(L, 8); (arg1)->arc(arg2,arg3,arg4,arg5,arg6,arg7,arg8); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Path_arc(lua_State* L) { int argc; int argv[9]={ 1,2,3,4,5,6,7,8,9} ; argc = lua_gettop(L); if (argc == 6) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { - return _wrap_Path_arc__SWIG_0(L);} } } } } } } if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { - return _wrap_Path_arc__SWIG_2(L);} } } } } } } if (argc == 7) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { { - _v = lua_isboolean(L,argv[6]); } if (_v) { return _wrap_Path_arc__SWIG_1(L);} } } } } } } } - if (argc == 7) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { { - _v = lua_isboolean(L,argv[6]); } if (_v) { return _wrap_Path_arc__SWIG_3(L);} } } } } } } } - if (argc == 7) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { - return _wrap_Path_arc__SWIG_4(L);} } } } } } } } if (argc == 8) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { return _wrap_Path_arc__SWIG_5(L);} } } } } } } } } + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_Path_arc__SWIG_0(L);} check_1: if (argc == 6) { + return _wrap_Path_arc__SWIG_2(L);} if (argc == 7) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; { { _v = lua_isboolean(L,argv[6]); } } + if (!_v) goto check_3; return _wrap_Path_arc__SWIG_1(L);} check_3: if (argc == 7) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_4; { { _v = lua_isboolean(L,argv[6]); } } + if (!_v) goto check_4; return _wrap_Path_arc__SWIG_3(L);} check_4: if (argc == 7) { return _wrap_Path_arc__SWIG_4(L);} + if (argc == 8) { return _wrap_Path_arc__SWIG_5(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Path_arc'\n" " Possible C/C++ prototypes are:\n" " ofPath::arc(glm::vec3 const &,float,float,float,float)\n" " ofPath::arc(glm::vec3 const &,float,float,float,float,bool)\n" @@ -30585,30 +31913,12 @@ static int _wrap_Path_arcNegative__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofPa (arg1)->arcNegative(arg2,arg3,arg4,arg5,arg6,arg7,arg8); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Path_arcNegative(lua_State* L) { int argc; int argv[9]={ 1,2,3,4,5,6,7,8,9} ; argc = lua_gettop(L); - if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { - return _wrap_Path_arcNegative__SWIG_0(L);} } } } } } } if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { - return _wrap_Path_arcNegative__SWIG_1(L);} } } } } } } if (argc == 7) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { - return _wrap_Path_arcNegative__SWIG_2(L);} } } } } } } } if (argc == 8) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { return _wrap_Path_arcNegative__SWIG_3(L);} } } } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Path_arcNegative'\n" " Possible C/C++ prototypes are:\n" + if (argc == 6) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_Path_arcNegative__SWIG_0(L);} check_1: + if (argc == 6) { return _wrap_Path_arcNegative__SWIG_1(L);} if (argc == 7) { return _wrap_Path_arcNegative__SWIG_2(L);} + if (argc == 8) { return _wrap_Path_arcNegative__SWIG_3(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Path_arcNegative'\n" " Possible C/C++ prototypes are:\n" " ofPath::arcNegative(glm::vec3 const &,float,float,float,float)\n" " ofPath::arcNegative(glm::vec2 const &,float,float,float,float)\n" " ofPath::arcNegative(float,float,float,float,float,float)\n" @@ -30675,36 +31985,17 @@ static int _wrap_Path_triangle__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofPath (arg1)->triangle((glm::vec2 const &)*arg2,(glm::vec2 const &)*arg3,(glm::vec2 const &)*arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Path_triangle(lua_State* L) { int argc; int argv[11]={ 1,2,3,4,5,6,7,8,9,10,11} ; argc = lua_gettop(L); - if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Path_triangle__SWIG_2(L);} } } } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_glm__vec2, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_glm__vec2, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Path_triangle__SWIG_3(L);} } } } } if (argc == 7) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { - return _wrap_Path_triangle__SWIG_0(L);} } } } } } } } if (argc == 10) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { { _v = lua_isnumber(L,argv[8]); } if (_v) { { - _v = lua_isnumber(L,argv[9]); } if (_v) { return _wrap_Path_triangle__SWIG_1(L);} } } } } } } } - } } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Path_triangle'\n" - " Possible C/C++ prototypes are:\n" " ofPath::triangle(float,float,float,float,float,float)\n" + if (argc == 4) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; { { void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; { { void *ptr; + if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_Path_triangle__SWIG_2(L);} check_1: + if (argc == 4) { return _wrap_Path_triangle__SWIG_3(L);} if (argc == 7) { return _wrap_Path_triangle__SWIG_0(L);} + if (argc == 10) { return _wrap_Path_triangle__SWIG_1(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Path_triangle'\n" " Possible C/C++ prototypes are:\n" + " ofPath::triangle(float,float,float,float,float,float)\n" " ofPath::triangle(float,float,float,float,float,float,float,float,float)\n" " ofPath::triangle(glm::vec3 const &,glm::vec3 const &,glm::vec3 const &)\n" " ofPath::triangle(glm::vec2 const &,glm::vec2 const &,glm::vec2 const &)\n"); lua_error(L);return 0; } @@ -30744,23 +32035,11 @@ static int _wrap_Path_circle__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofPath *a SWIG_fail_ptr("Path_circle",2,SWIGTYPE_p_glm__vec2); } arg3 = (float)lua_tonumber(L, 3); (arg1)->circle((glm::vec2 const &)*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Path_circle(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Path_circle__SWIG_2(L);} } } - } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Path_circle__SWIG_3(L);} } } - } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Path_circle__SWIG_0(L);} } } } } if (argc == 5) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Path_circle__SWIG_1(L);} } } } } } + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_Path_circle__SWIG_2(L);} check_1: + if (argc == 3) { return _wrap_Path_circle__SWIG_3(L);} if (argc == 4) { return _wrap_Path_circle__SWIG_0(L);} + if (argc == 5) { return _wrap_Path_circle__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Path_circle'\n" " Possible C/C++ prototypes are:\n" " ofPath::circle(float,float,float)\n" " ofPath::circle(float,float,float,float)\n" " ofPath::circle(glm::vec3 const &,float)\n" " ofPath::circle(glm::vec2 const &,float)\n"); lua_error(L);return 0; } @@ -30808,24 +32087,11 @@ static int _wrap_Path_ellipse__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofPath * SWIG_fail_ptr("Path_ellipse",2,SWIGTYPE_p_glm__vec2); } arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); (arg1)->ellipse((glm::vec2 const &)*arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Path_ellipse(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); if (argc == 4) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Path_ellipse__SWIG_2(L);} } } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Path_ellipse__SWIG_3(L);} } } } } if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Path_ellipse__SWIG_0(L);} } } } } } if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { return _wrap_Path_ellipse__SWIG_1(L);} } } } } } } + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_Path_ellipse__SWIG_2(L);} check_1: + if (argc == 4) { return _wrap_Path_ellipse__SWIG_3(L);} if (argc == 5) { return _wrap_Path_ellipse__SWIG_0(L);} + if (argc == 6) { return _wrap_Path_ellipse__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Path_ellipse'\n" " Possible C/C++ prototypes are:\n" " ofPath::ellipse(float,float,float,float)\n" " ofPath::ellipse(float,float,float,float,float)\n" " ofPath::ellipse(glm::vec3 const &,float,float)\n" " ofPath::ellipse(glm::vec2 const &,float,float)\n"); @@ -30883,28 +32149,11 @@ static int _wrap_Path_rectangle__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofPath arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); (arg1)->rectangle(arg2,arg3,arg4,arg5,arg6); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Path_rectangle(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Path_rectangle__SWIG_0(L);} } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Path_rectangle__SWIG_1(L);} } } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Path_rectangle__SWIG_2(L);} } } } } if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Path_rectangle__SWIG_3(L);} } } } } } if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { return _wrap_Path_rectangle__SWIG_4(L);} } } } } } } + return _wrap_Path_rectangle__SWIG_0(L);} if (argc == 4) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_Path_rectangle__SWIG_1(L);} check_2: + if (argc == 4) { return _wrap_Path_rectangle__SWIG_2(L);} if (argc == 5) { return _wrap_Path_rectangle__SWIG_3(L);} + if (argc == 6) { return _wrap_Path_rectangle__SWIG_4(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Path_rectangle'\n" " Possible C/C++ prototypes are:\n" " ofPath::rectangle(ofRectangle const &)\n" " ofPath::rectangle(glm::vec3 const &,float,float)\n" " ofPath::rectangle(glm::vec2 const &,float,float)\n" " ofPath::rectangle(float,float,float,float)\n" @@ -31031,58 +32280,18 @@ static int _wrap_Path_rectRounded__SWIG_7(lua_State* L) { int SWIG_arg = 0; ofPa (arg1)->rectRounded(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Path_rectRounded(lua_State* L) { int argc; int argv[11]={ 1,2,3,4,5,6,7,8,9,10,11} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Path_rectRounded__SWIG_0(L);} - } } } if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_Path_rectRounded__SWIG_1(L);} } } } } } - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_Path_rectRounded__SWIG_2(L);} } } } } } - if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { - return _wrap_Path_rectRounded__SWIG_6(L);} } } } } } } if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { return _wrap_Path_rectRounded__SWIG_3(L);} } } } } } } - if (argc == 8) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { { - _v = lua_isnumber(L,argv[6]); } if (_v) { { _v = lua_isnumber(L,argv[7]); } if (_v) { - return _wrap_Path_rectRounded__SWIG_5(L);} } } } } } } } } if (argc == 8) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { { - _v = lua_isnumber(L,argv[6]); } if (_v) { { _v = lua_isnumber(L,argv[7]); } if (_v) { - return _wrap_Path_rectRounded__SWIG_4(L);} } } } } } } } } if (argc == 10) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { { _v = lua_isnumber(L,argv[8]); } if (_v) { { - _v = lua_isnumber(L,argv[9]); } if (_v) { return _wrap_Path_rectRounded__SWIG_7(L);} } } } } } } - } } } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Path_rectRounded'\n" - " Possible C/C++ prototypes are:\n" " ofPath::rectRounded(ofRectangle const &,float)\n" - " ofPath::rectRounded(glm::vec3 const &,float,float,float)\n" + if (argc == 3) { return _wrap_Path_rectRounded__SWIG_0(L);} if (argc == 5) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_Path_rectRounded__SWIG_1(L);} check_2: + if (argc == 5) { return _wrap_Path_rectRounded__SWIG_2(L);} if (argc == 6) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_4; return _wrap_Path_rectRounded__SWIG_6(L);} check_4: + if (argc == 6) { return _wrap_Path_rectRounded__SWIG_3(L);} if (argc == 8) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_6; return _wrap_Path_rectRounded__SWIG_5(L);} check_6: + if (argc == 8) { return _wrap_Path_rectRounded__SWIG_4(L);} if (argc == 10) { return _wrap_Path_rectRounded__SWIG_7(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Path_rectRounded'\n" " Possible C/C++ prototypes are:\n" + " ofPath::rectRounded(ofRectangle const &,float)\n" " ofPath::rectRounded(glm::vec3 const &,float,float,float)\n" " ofPath::rectRounded(glm::vec2 const &,float,float,float)\n" " ofPath::rectRounded(float,float,float,float,float)\n" " ofPath::rectRounded(glm::vec3 const &,float,float,float,float,float,float)\n" " ofPath::rectRounded(glm::vec2 const &,float,float,float,float,float,float)\n" @@ -31243,12 +32452,8 @@ static int _wrap_Path_draw__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPath *arg if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_draw",1,SWIGTYPE_p_ofPath); } arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); ((ofPath const *)arg1)->draw(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_draw(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Path_draw__SWIG_0(L);} } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Path_draw__SWIG_1(L);} } } } +static int _wrap_Path_draw(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 1) { + return _wrap_Path_draw__SWIG_0(L);} if (argc == 3) { return _wrap_Path_draw__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Path_draw'\n" " Possible C/C++ prototypes are:\n" " ofPath::draw() const\n" " ofPath::draw(float,float) const\n"); lua_error(L);return 0; } static int _wrap_Path_getOutline(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; @@ -31257,8 +32462,8 @@ static int _wrap_Path_getOutline(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_getOutline",1,SWIGTYPE_p_ofPath); } result = (std::vector< ofPolyline > *) &((ofPath const *)arg1)->getOutline(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofPolyline_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } + SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofPolyline_T_ofDefaultVertexType_t_t,0); SWIG_arg++; return SWIG_arg; + if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Path_tessellate(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; SWIG_check_num_args("ofPath::tessellate",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::tessellate",1,"ofPath *"); if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ @@ -31270,7 +32475,7 @@ static int _wrap_Path_getTessellation(lua_State* L) { int SWIG_arg = 0; ofPath * if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_getTessellation",1,SWIGTYPE_p_ofPath); } result = (ofMesh *) &((ofPath const *)arg1)->getTessellation(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMesh_T_glm__vec3_glm__vec3_ofColor_T_float_t_glm__vec2_t,0); SWIG_arg++; + SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Path_simplify__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; SWIG_check_num_args("ofPath::simplify",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::simplify",1,"ofPath *"); @@ -31282,12 +32487,8 @@ static int _wrap_Path_simplify__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPath SWIG_check_num_args("ofPath::simplify",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::simplify",1,"ofPath *"); if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_simplify",1,SWIGTYPE_p_ofPath); } (arg1)->simplify(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_simplify(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Path_simplify__SWIG_1(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Path_simplify__SWIG_0(L);} } } +static int _wrap_Path_simplify(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { + return _wrap_Path_simplify__SWIG_1(L);} if (argc == 2) { return _wrap_Path_simplify__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Path_simplify'\n" " Possible C/C++ prototypes are:\n" " ofPath::simplify(float)\n" " ofPath::simplify()\n"); lua_error(L);return 0; } static int _wrap_Path_translate__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; glm::vec3 *arg2 = 0 ; @@ -31297,15 +32498,24 @@ static int _wrap_Path_translate__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPath if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("Path_translate",2,SWIGTYPE_p_glm__vec3); } (arg1)->translate((glm::vec3 const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_rotate__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; - glm::vec3 *arg3 = 0 ; SWIG_check_num_args("ofPath::rotate",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::rotate",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::rotate",2,"float"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofPath::rotate",3,"glm::vec3 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_rotate",1,SWIGTYPE_p_ofPath); } - arg2 = (float)lua_tonumber(L, 2); if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_glm__vec3,0))){ - SWIG_fail_ptr("Path_rotate",3,SWIGTYPE_p_glm__vec3); } (arg1)->rotate(arg2,(glm::vec3 const &)*arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Path_rotateDeg__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; + glm::vec3 *arg3 = 0 ; SWIG_check_num_args("ofPath::rotateDeg",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::rotateDeg",1,"ofPath *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::rotateDeg",2,"float"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofPath::rotateDeg",3,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_rotateDeg",1,SWIGTYPE_p_ofPath); } + arg2 = (float)lua_tonumber(L, 2); if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_glm__vec3,0))){ + SWIG_fail_ptr("Path_rotateDeg",3,SWIGTYPE_p_glm__vec3); } (arg1)->rotateDeg(arg2,(glm::vec3 const &)*arg3); + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Path_rotateRad__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; + glm::vec3 *arg3 = 0 ; SWIG_check_num_args("ofPath::rotateRad",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::rotateRad",1,"ofPath *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::rotateRad",2,"float"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofPath::rotateRad",3,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_rotateRad",1,SWIGTYPE_p_ofPath); } + arg2 = (float)lua_tonumber(L, 2); if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_glm__vec3,0))){ + SWIG_fail_ptr("Path_rotateRad",3,SWIGTYPE_p_glm__vec3); } (arg1)->rotateRad(arg2,(glm::vec3 const &)*arg3); + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Path_translate__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; glm::vec2 *arg2 = 0 ; SWIG_check_num_args("ofPath::translate",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::translate",1,"ofPath *"); if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPath::translate",2,"glm::vec2 const &"); @@ -31313,37 +32523,47 @@ static int _wrap_Path_translate__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPath if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("Path_translate",2,SWIGTYPE_p_glm__vec2); } (arg1)->translate((glm::vec2 const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_translate(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Path_translate__SWIG_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Path_translate__SWIG_1(L);} } } +static int _wrap_Path_translate(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_Path_translate__SWIG_0(L);} check_1: + if (argc == 2) { return _wrap_Path_translate__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Path_translate'\n" " Possible C/C++ prototypes are:\n" " ofPath::translate(glm::vec3 const &)\n" " ofPath::translate(glm::vec2 const &)\n"); lua_error(L);return 0; } -static int _wrap_Path_rotate__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; - glm::vec2 *arg3 = 0 ; SWIG_check_num_args("ofPath::rotate",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::rotate",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::rotate",2,"float"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofPath::rotate",3,"glm::vec2 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_rotate",1,SWIGTYPE_p_ofPath); } - arg2 = (float)lua_tonumber(L, 2); if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_glm__vec2,0))){ - SWIG_fail_ptr("Path_rotate",3,SWIGTYPE_p_glm__vec2); } (arg1)->rotate(arg2,(glm::vec2 const &)*arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_rotate(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Path_rotate__SWIG_0(L);} } } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_glm__vec2, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Path_rotate__SWIG_1(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Path_rotate'\n" " Possible C/C++ prototypes are:\n" - " ofPath::rotate(float,glm::vec3 const &)\n" " ofPath::rotate(float,glm::vec2 const &)\n"); lua_error(L);return 0; } +static int _wrap_Path_rotateDeg__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; + glm::vec2 *arg3 = 0 ; SWIG_check_num_args("ofPath::rotateDeg",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::rotateDeg",1,"ofPath *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::rotateDeg",2,"float"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofPath::rotateDeg",3,"glm::vec2 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_rotateDeg",1,SWIGTYPE_p_ofPath); } + arg2 = (float)lua_tonumber(L, 2); if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_glm__vec2,0))){ + SWIG_fail_ptr("Path_rotateDeg",3,SWIGTYPE_p_glm__vec2); } (arg1)->rotateDeg(arg2,(glm::vec2 const &)*arg3); + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Path_rotateDeg(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 3) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_Path_rotateDeg__SWIG_0(L);} check_1: + if (argc == 3) { return _wrap_Path_rotateDeg__SWIG_1(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Path_rotateDeg'\n" " Possible C/C++ prototypes are:\n" + " ofPath::rotateDeg(float,glm::vec3 const &)\n" " ofPath::rotateDeg(float,glm::vec2 const &)\n"); + lua_error(L);return 0; } +static int _wrap_Path_rotateRad__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; + glm::vec2 *arg3 = 0 ; SWIG_check_num_args("ofPath::rotateRad",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::rotateRad",1,"ofPath *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::rotateRad",2,"float"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofPath::rotateRad",3,"glm::vec2 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_rotateRad",1,SWIGTYPE_p_ofPath); } + arg2 = (float)lua_tonumber(L, 2); if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_glm__vec2,0))){ + SWIG_fail_ptr("Path_rotateRad",3,SWIGTYPE_p_glm__vec2); } (arg1)->rotateRad(arg2,(glm::vec2 const &)*arg3); + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Path_rotateRad(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 3) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_Path_rotateRad__SWIG_0(L);} check_1: + if (argc == 3) { return _wrap_Path_rotateRad__SWIG_1(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Path_rotateRad'\n" " Possible C/C++ prototypes are:\n" + " ofPath::rotateRad(float,glm::vec3 const &)\n" " ofPath::rotateRad(float,glm::vec2 const &)\n"); + lua_error(L);return 0; } static int _wrap_Path_scale(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; float arg3 ; SWIG_check_num_args("ofPath::scale",3,3) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::scale",1,"ofPath *"); if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::scale",2,"float"); @@ -31364,10 +32584,10 @@ static int _wrap_Path_setMode(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = ( arg2 = (ofPath::Mode)(int)lua_tonumber(L, 2); (arg1)->setMode(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Path_getMode(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; ofPath::Mode result; - SWIG_check_num_args("ofPath::getMode",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::getMode",1,"ofPath *"); + SWIG_check_num_args("ofPath::getMode",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::getMode",1,"ofPath const *"); if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_getMode",1,SWIGTYPE_p_ofPath); } - result = (ofPath::Mode)(arg1)->getMode(); lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } + result = (ofPath::Mode)((ofPath const *)arg1)->getMode(); lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Path_getCommands__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; std::vector< ofPath::Command > *result = 0 ; SWIG_check_num_args("ofPath::getCommands",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::getCommands",1,"ofPath *"); @@ -31384,11 +32604,8 @@ static int _wrap_Path_getCommands__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPa result = (std::vector< ofPath::Command > *) &((ofPath const *)arg1)->getCommands(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofPath__Command_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_getCommands(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Path_getCommands__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Path_getCommands__SWIG_1(L);} } +static int _wrap_Path_getCommands(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { + return _wrap_Path_getCommands__SWIG_0(L);} if (argc == 1) { return _wrap_Path_getCommands__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Path_getCommands'\n" " Possible C/C++ prototypes are:\n" " ofPath::getCommands()\n" " ofPath::getCommands() const\n"); lua_error(L);return 0; } static void swig_delete_Path(void *obj) { @@ -31449,7 +32666,8 @@ static swig_lua_method swig_Path_methods[]= { { "getTessellation", _wrap_Path_getTessellation}, { "simplify", _wrap_Path_simplify}, { "translate", _wrap_Path_translate}, - { "rotate", _wrap_Path_rotate}, + { "rotateDeg", _wrap_Path_rotateDeg}, + { "rotateRad", _wrap_Path_rotateRad}, { "scale", _wrap_Path_scale}, { "append", _wrap_Path_append}, { "setMode", _wrap_Path_setMode}, @@ -31491,136 +32709,135 @@ static swig_lua_class _wrap_class_Path = { "Path", "Path", &SWIGTYPE_p_ofPath,_p static int _wrap_new_PolylineVector__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::vector< ofPolyline > *result = 0 ; SWIG_check_num_args("std::vector< ofPolyline >::vector",0,0) result = (std::vector< ofPolyline > *)new std::vector< ofPolyline >(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofPolyline_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } + SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofPolyline_T_ofDefaultVertexType_t_t,1); SWIG_arg++; return SWIG_arg; + if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_new_PolylineVector__SWIG_1(lua_State* L) { int SWIG_arg = 0; unsigned int arg1 ; std::vector< ofPolyline > *result = 0 ; SWIG_check_num_args("std::vector< ofPolyline >::vector",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("std::vector< ofPolyline >::vector",1,"unsigned int"); SWIG_contract_assert((lua_tonumber(L,1)>=0),"number must not be negative") arg1 = (unsigned int)lua_tonumber(L, 1); result = (std::vector< ofPolyline > *)new std::vector< ofPolyline >(arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofPolyline_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } + SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofPolyline_T_ofDefaultVertexType_t_t,1); SWIG_arg++; return SWIG_arg; + if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_new_PolylineVector__SWIG_2(lua_State* L) { int SWIG_arg = 0; std::vector< ofPolyline > *arg1 = 0 ; std::vector< ofPolyline > *result = 0 ; SWIG_check_num_args("std::vector< ofPolyline >::vector",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("std::vector< ofPolyline >::vector",1,"std::vector< ofPolyline > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofPolyline_t,0))){ - SWIG_fail_ptr("new_PolylineVector",1,SWIGTYPE_p_std__vectorT_ofPolyline_t); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofPolyline_T_ofDefaultVertexType_t_t,0))){ + SWIG_fail_ptr("new_PolylineVector",1,SWIGTYPE_p_std__vectorT_ofPolyline_T_ofDefaultVertexType_t_t); } result = (std::vector< ofPolyline > *)new std::vector< ofPolyline >((std::vector< ofPolyline > const &)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofPolyline_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_PolylineVector__SWIG_3(lua_State* L) { int SWIG_arg = 0; unsigned int arg1 ; ofPolyline arg2 ; - ofPolyline *argp2 ; std::vector< ofPolyline > *result = 0 ; SWIG_check_num_args("std::vector< ofPolyline >::vector",2,2) + SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofPolyline_T_ofDefaultVertexType_t_t,1); SWIG_arg++; return SWIG_arg; + if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_new_PolylineVector__SWIG_3(lua_State* L) { int SWIG_arg = 0; unsigned int arg1 ; + ofPolyline_< glm::vec3 > arg2 ; ofPolyline_< glm::vec3 > *argp2 ; std::vector< ofPolyline > *result = 0 ; + SWIG_check_num_args("std::vector< ofPolyline >::vector",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("std::vector< ofPolyline >::vector",1,"unsigned int"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("std::vector< ofPolyline >::vector",2,"ofPolyline"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("std::vector< ofPolyline >::vector",2,"ofPolyline_< glm::vec3 >"); SWIG_contract_assert((lua_tonumber(L,1)>=0),"number must not be negative") arg1 = (unsigned int)lua_tonumber(L, 1); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("new_PolylineVector",2,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } arg2 = *argp2; + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("new_PolylineVector",2,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } arg2 = *argp2; result = (std::vector< ofPolyline > *)new std::vector< ofPolyline >(arg1,arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofPolyline_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } + SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofPolyline_T_ofDefaultVertexType_t_t,1); SWIG_arg++; return SWIG_arg; + if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_new_PolylineVector(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_PolylineVector__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_std__vectorT_ofPolyline_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_new_PolylineVector__SWIG_2(L);} } if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_new_PolylineVector__SWIG_1(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_new_PolylineVector__SWIG_3(L);} } } + return _wrap_new_PolylineVector__SWIG_0(L);} if (argc == 1) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_std__vectorT_ofPolyline_T_ofDefaultVertexType_t_t, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_new_PolylineVector__SWIG_2(L);} check_2: + if (argc == 1) { return _wrap_new_PolylineVector__SWIG_1(L);} if (argc == 2) { return _wrap_new_PolylineVector__SWIG_3(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_PolylineVector'\n" " Possible C/C++ prototypes are:\n" " std::vector< ofPolyline >::vector()\n" " std::vector< ofPolyline >::vector(unsigned int)\n" " std::vector< ofPolyline >::vector(std::vector< ofPolyline > const &)\n" - " std::vector< ofPolyline >::vector(unsigned int,ofPolyline)\n"); lua_error(L);return 0; } + " std::vector< ofPolyline >::vector(unsigned int,ofPolyline_< glm::vec3 >)\n"); lua_error(L);return 0; } static int _wrap_PolylineVector_size(lua_State* L) { int SWIG_arg = 0; std::vector< ofPolyline > *arg1 = (std::vector< ofPolyline > *) 0 ; unsigned int result; SWIG_check_num_args("std::vector< ofPolyline >::size",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< ofPolyline >::size",1,"std::vector< ofPolyline > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofPolyline_t,0))){ - SWIG_fail_ptr("PolylineVector_size",1,SWIGTYPE_p_std__vectorT_ofPolyline_t); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofPolyline_T_ofDefaultVertexType_t_t,0))){ + SWIG_fail_ptr("PolylineVector_size",1,SWIGTYPE_p_std__vectorT_ofPolyline_T_ofDefaultVertexType_t_t); } result = (unsigned int)((std::vector< ofPolyline > const *)arg1)->size(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_PolylineVector_max_size(lua_State* L) { int SWIG_arg = 0; std::vector< ofPolyline > *arg1 = (std::vector< ofPolyline > *) 0 ; unsigned int result; SWIG_check_num_args("std::vector< ofPolyline >::max_size",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< ofPolyline >::max_size",1,"std::vector< ofPolyline > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofPolyline_t,0))){ - SWIG_fail_ptr("PolylineVector_max_size",1,SWIGTYPE_p_std__vectorT_ofPolyline_t); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofPolyline_T_ofDefaultVertexType_t_t,0))){ + SWIG_fail_ptr("PolylineVector_max_size",1,SWIGTYPE_p_std__vectorT_ofPolyline_T_ofDefaultVertexType_t_t); } result = (unsigned int)((std::vector< ofPolyline > const *)arg1)->max_size(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_PolylineVector_empty(lua_State* L) { int SWIG_arg = 0; std::vector< ofPolyline > *arg1 = (std::vector< ofPolyline > *) 0 ; bool result; SWIG_check_num_args("std::vector< ofPolyline >::empty",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< ofPolyline >::empty",1,"std::vector< ofPolyline > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofPolyline_t,0))){ - SWIG_fail_ptr("PolylineVector_empty",1,SWIGTYPE_p_std__vectorT_ofPolyline_t); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofPolyline_T_ofDefaultVertexType_t_t,0))){ + SWIG_fail_ptr("PolylineVector_empty",1,SWIGTYPE_p_std__vectorT_ofPolyline_T_ofDefaultVertexType_t_t); } result = (bool)((std::vector< ofPolyline > const *)arg1)->empty(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_PolylineVector_clear(lua_State* L) { int SWIG_arg = 0; std::vector< ofPolyline > *arg1 = (std::vector< ofPolyline > *) 0 ; SWIG_check_num_args("std::vector< ofPolyline >::clear",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< ofPolyline >::clear",1,"std::vector< ofPolyline > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofPolyline_t,0))){ - SWIG_fail_ptr("PolylineVector_clear",1,SWIGTYPE_p_std__vectorT_ofPolyline_t); } (arg1)->clear(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofPolyline_T_ofDefaultVertexType_t_t,0))){ + SWIG_fail_ptr("PolylineVector_clear",1,SWIGTYPE_p_std__vectorT_ofPolyline_T_ofDefaultVertexType_t_t); } (arg1)->clear(); + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_PolylineVector_push_back(lua_State* L) { int SWIG_arg = 0; - std::vector< ofPolyline > *arg1 = (std::vector< ofPolyline > *) 0 ; ofPolyline arg2 ; ofPolyline *argp2 ; - SWIG_check_num_args("std::vector< ofPolyline >::push_back",2,2) + std::vector< ofPolyline > *arg1 = (std::vector< ofPolyline > *) 0 ; ofPolyline_< glm::vec3 > arg2 ; + ofPolyline_< glm::vec3 > *argp2 ; SWIG_check_num_args("std::vector< ofPolyline >::push_back",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< ofPolyline >::push_back",1,"std::vector< ofPolyline > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("std::vector< ofPolyline >::push_back",2,"ofPolyline"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofPolyline_t,0))){ - SWIG_fail_ptr("PolylineVector_push_back",1,SWIGTYPE_p_std__vectorT_ofPolyline_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("PolylineVector_push_back",2,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } arg2 = *argp2; - (arg1)->push_back(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } + if(!lua_isuserdata(L,2)) SWIG_fail_arg("std::vector< ofPolyline >::push_back",2,"ofPolyline_< glm::vec3 >"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofPolyline_T_ofDefaultVertexType_t_t,0))){ + SWIG_fail_ptr("PolylineVector_push_back",1,SWIGTYPE_p_std__vectorT_ofPolyline_T_ofDefaultVertexType_t_t); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("PolylineVector_push_back",2,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } arg2 = *argp2; (arg1)->push_back(arg2); + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_PolylineVector_pop_back(lua_State* L) { int SWIG_arg = 0; std::vector< ofPolyline > *arg1 = (std::vector< ofPolyline > *) 0 ; SWIG_check_num_args("std::vector< ofPolyline >::pop_back",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< ofPolyline >::pop_back",1,"std::vector< ofPolyline > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofPolyline_t,0))){ - SWIG_fail_ptr("PolylineVector_pop_back",1,SWIGTYPE_p_std__vectorT_ofPolyline_t); } (arg1)->pop_back(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofPolyline_T_ofDefaultVertexType_t_t,0))){ + SWIG_fail_ptr("PolylineVector_pop_back",1,SWIGTYPE_p_std__vectorT_ofPolyline_T_ofDefaultVertexType_t_t); } + (arg1)->pop_back(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_PolylineVector_front(lua_State* L) { int SWIG_arg = 0; - std::vector< ofPolyline > *arg1 = (std::vector< ofPolyline > *) 0 ; ofPolyline result; + std::vector< ofPolyline > *arg1 = (std::vector< ofPolyline > *) 0 ; ofPolyline_< glm::vec3 > result; SWIG_check_num_args("std::vector< ofPolyline >::front",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< ofPolyline >::front",1,"std::vector< ofPolyline > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofPolyline_t,0))){ - SWIG_fail_ptr("PolylineVector_front",1,SWIGTYPE_p_std__vectorT_ofPolyline_t); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofPolyline_T_ofDefaultVertexType_t_t,0))){ + SWIG_fail_ptr("PolylineVector_front",1,SWIGTYPE_p_std__vectorT_ofPolyline_T_ofDefaultVertexType_t_t); } result = ((std::vector< ofPolyline > const *)arg1)->front(); { - ofPolyline * resultptr = new ofPolyline((const ofPolyline &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,1); SWIG_arg++; } return SWIG_arg; + ofPolyline_< glm::vec3 > * resultptr = new ofPolyline_< glm::vec3 >((const ofPolyline_< glm::vec3 > &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_PolylineVector_back(lua_State* L) { int SWIG_arg = 0; - std::vector< ofPolyline > *arg1 = (std::vector< ofPolyline > *) 0 ; ofPolyline result; + std::vector< ofPolyline > *arg1 = (std::vector< ofPolyline > *) 0 ; ofPolyline_< glm::vec3 > result; SWIG_check_num_args("std::vector< ofPolyline >::back",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< ofPolyline >::back",1,"std::vector< ofPolyline > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofPolyline_t,0))){ - SWIG_fail_ptr("PolylineVector_back",1,SWIGTYPE_p_std__vectorT_ofPolyline_t); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofPolyline_T_ofDefaultVertexType_t_t,0))){ + SWIG_fail_ptr("PolylineVector_back",1,SWIGTYPE_p_std__vectorT_ofPolyline_T_ofDefaultVertexType_t_t); } result = ((std::vector< ofPolyline > const *)arg1)->back(); { - ofPolyline * resultptr = new ofPolyline((const ofPolyline &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,1); SWIG_arg++; } return SWIG_arg; + ofPolyline_< glm::vec3 > * resultptr = new ofPolyline_< glm::vec3 >((const ofPolyline_< glm::vec3 > &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_PolylineVector___getitem(lua_State* L) { int SWIG_arg = 0; - std::vector< ofPolyline > *arg1 = (std::vector< ofPolyline > *) 0 ; unsigned int arg2 ; ofPolyline result; + std::vector< ofPolyline > *arg1 = (std::vector< ofPolyline > *) 0 ; unsigned int arg2 ; ofPolyline_< glm::vec3 > result; SWIG_check_num_args("std::vector< ofPolyline >::__getitem__",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< ofPolyline >::__getitem__",1,"std::vector< ofPolyline > *"); if(!lua_isnumber(L,2)) SWIG_fail_arg("std::vector< ofPolyline >::__getitem__",2,"unsigned int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofPolyline_t,0))){ - SWIG_fail_ptr("PolylineVector___getitem",1,SWIGTYPE_p_std__vectorT_ofPolyline_t); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofPolyline_T_ofDefaultVertexType_t_t,0))){ + SWIG_fail_ptr("PolylineVector___getitem",1,SWIGTYPE_p_std__vectorT_ofPolyline_T_ofDefaultVertexType_t_t); } SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned int)lua_tonumber(L, 2); try { result = std_vector_Sl_ofPolyline_Sg____getitem__(arg1,arg2);} catch(std::out_of_range &_e) { - SWIG_exception(SWIG_IndexError, (&_e)->what()); } { ofPolyline * resultptr = new ofPolyline((const ofPolyline &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,1); SWIG_arg++; } return SWIG_arg; + SWIG_exception(SWIG_IndexError, (&_e)->what()); } { + ofPolyline_< glm::vec3 > * resultptr = new ofPolyline_< glm::vec3 >((const ofPolyline_< glm::vec3 > &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_PolylineVector___setitem(lua_State* L) { int SWIG_arg = 0; - std::vector< ofPolyline > *arg1 = (std::vector< ofPolyline > *) 0 ; unsigned int arg2 ; ofPolyline arg3 ; ofPolyline *argp3 ; - SWIG_check_num_args("std::vector< ofPolyline >::__setitem__",3,3) + std::vector< ofPolyline > *arg1 = (std::vector< ofPolyline > *) 0 ; unsigned int arg2 ; ofPolyline_< glm::vec3 > arg3 ; + ofPolyline_< glm::vec3 > *argp3 ; SWIG_check_num_args("std::vector< ofPolyline >::__setitem__",3,3) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< ofPolyline >::__setitem__",1,"std::vector< ofPolyline > *"); if(!lua_isnumber(L,2)) SWIG_fail_arg("std::vector< ofPolyline >::__setitem__",2,"unsigned int"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("std::vector< ofPolyline >::__setitem__",3,"ofPolyline"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofPolyline_t,0))){ - SWIG_fail_ptr("PolylineVector___setitem",1,SWIGTYPE_p_std__vectorT_ofPolyline_t); } + if(!lua_isuserdata(L,3)) SWIG_fail_arg("std::vector< ofPolyline >::__setitem__",3,"ofPolyline_< glm::vec3 >"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofPolyline_T_ofDefaultVertexType_t_t,0))){ + SWIG_fail_ptr("PolylineVector___setitem",1,SWIGTYPE_p_std__vectorT_ofPolyline_T_ofDefaultVertexType_t_t); } SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned int)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&argp3,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("PolylineVector___setitem",3,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } arg3 = *argp3; try { + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&argp3,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("PolylineVector___setitem",3,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } arg3 = *argp3; try { std_vector_Sl_ofPolyline_Sg____setitem__(arg1,arg2,arg3);} catch(std::out_of_range &_e) { SWIG_exception(SWIG_IndexError, (&_e)->what()); } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static void swig_delete_PolylineVector(void *obj) { @@ -31680,28 +32897,218 @@ static swig_lua_namespace swig_PolylineVector_Sf_SwigStatic = { }; static swig_lua_class *swig_PolylineVector_bases[] = {0}; static const char *swig_PolylineVector_base_names[] = {0}; -static swig_lua_class _wrap_class_PolylineVector = { "PolylineVector", "PolylineVector", &SWIGTYPE_p_std__vectorT_ofPolyline_t,_proxy__wrap_new_PolylineVector, swig_delete_PolylineVector, swig_PolylineVector_methods, swig_PolylineVector_attributes, &swig_PolylineVector_Sf_SwigStatic, swig_PolylineVector_meta, swig_PolylineVector_bases, swig_PolylineVector_base_names }; +static swig_lua_class _wrap_class_PolylineVector = { "PolylineVector", "PolylineVector", &SWIGTYPE_p_std__vectorT_ofPolyline_T_ofDefaultVertexType_t_t,_proxy__wrap_new_PolylineVector, swig_delete_PolylineVector, swig_PolylineVector_methods, swig_PolylineVector_attributes, &swig_PolylineVector_Sf_SwigStatic, swig_PolylineVector_meta, swig_PolylineVector_bases, swig_PolylineVector_base_names }; + +static int _wrap_new_VertexVector__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::vector< ofDefaultVertexType > *result = 0 ; + SWIG_check_num_args("std::vector< ofDefaultVertexType >::vector",0,0) + result = (std::vector< ofDefaultVertexType > *)new std::vector< ofDefaultVertexType >(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_glm__vec3_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_new_VertexVector__SWIG_1(lua_State* L) { int SWIG_arg = 0; unsigned int arg1 ; + std::vector< ofDefaultVertexType > *result = 0 ; SWIG_check_num_args("std::vector< ofDefaultVertexType >::vector",1,1) + if(!lua_isnumber(L,1)) SWIG_fail_arg("std::vector< ofDefaultVertexType >::vector",1,"unsigned int"); + SWIG_contract_assert((lua_tonumber(L,1)>=0),"number must not be negative") arg1 = (unsigned int)lua_tonumber(L, 1); + result = (std::vector< ofDefaultVertexType > *)new std::vector< ofDefaultVertexType >(arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_glm__vec3_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_new_VertexVector__SWIG_2(lua_State* L) { int SWIG_arg = 0; std::vector< ofDefaultVertexType > *arg1 = 0 ; + std::vector< ofDefaultVertexType > *result = 0 ; SWIG_check_num_args("std::vector< ofDefaultVertexType >::vector",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("std::vector< ofDefaultVertexType >::vector",1,"std::vector< ofDefaultVertexType > const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_glm__vec3_t,0))){ + SWIG_fail_ptr("new_VertexVector",1,SWIGTYPE_p_std__vectorT_glm__vec3_t); } + result = (std::vector< ofDefaultVertexType > *)new std::vector< ofDefaultVertexType >((std::vector< ofDefaultVertexType > const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_glm__vec3_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_new_VertexVector__SWIG_3(lua_State* L) { int SWIG_arg = 0; unsigned int arg1 ; glm::vec3 arg2 ; + glm::vec3 *argp2 ; std::vector< ofDefaultVertexType > *result = 0 ; + SWIG_check_num_args("std::vector< ofDefaultVertexType >::vector",2,2) + if(!lua_isnumber(L,1)) SWIG_fail_arg("std::vector< ofDefaultVertexType >::vector",1,"unsigned int"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("std::vector< ofDefaultVertexType >::vector",2,"glm::vec3"); + SWIG_contract_assert((lua_tonumber(L,1)>=0),"number must not be negative") arg1 = (unsigned int)lua_tonumber(L, 1); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_glm__vec3,0))){ + SWIG_fail_ptr("new_VertexVector",2,SWIGTYPE_p_glm__vec3); } arg2 = *argp2; + result = (std::vector< ofDefaultVertexType > *)new std::vector< ofDefaultVertexType >(arg1,arg2); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_glm__vec3_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_new_VertexVector(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 0) { + return _wrap_new_VertexVector__SWIG_0(L);} if (argc == 1) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_std__vectorT_glm__vec3_t, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_new_VertexVector__SWIG_2(L);} check_2: + if (argc == 1) { return _wrap_new_VertexVector__SWIG_1(L);} if (argc == 2) { return _wrap_new_VertexVector__SWIG_3(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_VertexVector'\n" " Possible C/C++ prototypes are:\n" + " std::vector< ofDefaultVertexType >::vector()\n" " std::vector< ofDefaultVertexType >::vector(unsigned int)\n" + " std::vector< ofDefaultVertexType >::vector(std::vector< ofDefaultVertexType > const &)\n" + " std::vector< ofDefaultVertexType >::vector(unsigned int,glm::vec3)\n"); lua_error(L);return 0; } +static int _wrap_VertexVector_size(lua_State* L) { int SWIG_arg = 0; + std::vector< ofDefaultVertexType > *arg1 = (std::vector< ofDefaultVertexType > *) 0 ; unsigned int result; + SWIG_check_num_args("std::vector< ofDefaultVertexType >::size",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< ofDefaultVertexType >::size",1,"std::vector< ofDefaultVertexType > const *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_glm__vec3_t,0))){ + SWIG_fail_ptr("VertexVector_size",1,SWIGTYPE_p_std__vectorT_glm__vec3_t); } + result = (unsigned int)((std::vector< ofDefaultVertexType > const *)arg1)->size(); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_VertexVector_max_size(lua_State* L) { int SWIG_arg = 0; + std::vector< ofDefaultVertexType > *arg1 = (std::vector< ofDefaultVertexType > *) 0 ; unsigned int result; + SWIG_check_num_args("std::vector< ofDefaultVertexType >::max_size",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< ofDefaultVertexType >::max_size",1,"std::vector< ofDefaultVertexType > const *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_glm__vec3_t,0))){ + SWIG_fail_ptr("VertexVector_max_size",1,SWIGTYPE_p_std__vectorT_glm__vec3_t); } + result = (unsigned int)((std::vector< ofDefaultVertexType > const *)arg1)->max_size(); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_VertexVector_empty(lua_State* L) { int SWIG_arg = 0; + std::vector< ofDefaultVertexType > *arg1 = (std::vector< ofDefaultVertexType > *) 0 ; bool result; + SWIG_check_num_args("std::vector< ofDefaultVertexType >::empty",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< ofDefaultVertexType >::empty",1,"std::vector< ofDefaultVertexType > const *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_glm__vec3_t,0))){ + SWIG_fail_ptr("VertexVector_empty",1,SWIGTYPE_p_std__vectorT_glm__vec3_t); } + result = (bool)((std::vector< ofDefaultVertexType > const *)arg1)->empty(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_VertexVector_clear(lua_State* L) { int SWIG_arg = 0; + std::vector< ofDefaultVertexType > *arg1 = (std::vector< ofDefaultVertexType > *) 0 ; + SWIG_check_num_args("std::vector< ofDefaultVertexType >::clear",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< ofDefaultVertexType >::clear",1,"std::vector< ofDefaultVertexType > *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_glm__vec3_t,0))){ + SWIG_fail_ptr("VertexVector_clear",1,SWIGTYPE_p_std__vectorT_glm__vec3_t); } (arg1)->clear(); return SWIG_arg; + if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_VertexVector_push_back(lua_State* L) { int SWIG_arg = 0; + std::vector< ofDefaultVertexType > *arg1 = (std::vector< ofDefaultVertexType > *) 0 ; glm::vec3 arg2 ; glm::vec3 *argp2 ; + SWIG_check_num_args("std::vector< ofDefaultVertexType >::push_back",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< ofDefaultVertexType >::push_back",1,"std::vector< ofDefaultVertexType > *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("std::vector< ofDefaultVertexType >::push_back",2,"glm::vec3"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_glm__vec3_t,0))){ + SWIG_fail_ptr("VertexVector_push_back",1,SWIGTYPE_p_std__vectorT_glm__vec3_t); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_glm__vec3,0))){ + SWIG_fail_ptr("VertexVector_push_back",2,SWIGTYPE_p_glm__vec3); } arg2 = *argp2; (arg1)->push_back(arg2); return SWIG_arg; + if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_VertexVector_pop_back(lua_State* L) { int SWIG_arg = 0; + std::vector< ofDefaultVertexType > *arg1 = (std::vector< ofDefaultVertexType > *) 0 ; + SWIG_check_num_args("std::vector< ofDefaultVertexType >::pop_back",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< ofDefaultVertexType >::pop_back",1,"std::vector< ofDefaultVertexType > *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_glm__vec3_t,0))){ + SWIG_fail_ptr("VertexVector_pop_back",1,SWIGTYPE_p_std__vectorT_glm__vec3_t); } (arg1)->pop_back(); return SWIG_arg; + if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_VertexVector_front(lua_State* L) { int SWIG_arg = 0; + std::vector< ofDefaultVertexType > *arg1 = (std::vector< ofDefaultVertexType > *) 0 ; glm::vec3 result; + SWIG_check_num_args("std::vector< ofDefaultVertexType >::front",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< ofDefaultVertexType >::front",1,"std::vector< ofDefaultVertexType > const *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_glm__vec3_t,0))){ + SWIG_fail_ptr("VertexVector_front",1,SWIGTYPE_p_std__vectorT_glm__vec3_t); } + result = ((std::vector< ofDefaultVertexType > const *)arg1)->front(); { + glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_VertexVector_back(lua_State* L) { int SWIG_arg = 0; + std::vector< ofDefaultVertexType > *arg1 = (std::vector< ofDefaultVertexType > *) 0 ; glm::vec3 result; + SWIG_check_num_args("std::vector< ofDefaultVertexType >::back",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< ofDefaultVertexType >::back",1,"std::vector< ofDefaultVertexType > const *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_glm__vec3_t,0))){ + SWIG_fail_ptr("VertexVector_back",1,SWIGTYPE_p_std__vectorT_glm__vec3_t); } + result = ((std::vector< ofDefaultVertexType > const *)arg1)->back(); { + glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_VertexVector___getitem(lua_State* L) { int SWIG_arg = 0; + std::vector< ofDefaultVertexType > *arg1 = (std::vector< ofDefaultVertexType > *) 0 ; unsigned int arg2 ; glm::vec3 result; + SWIG_check_num_args("std::vector< ofDefaultVertexType >::__getitem__",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< ofDefaultVertexType >::__getitem__",1,"std::vector< ofDefaultVertexType > *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("std::vector< ofDefaultVertexType >::__getitem__",2,"unsigned int"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_glm__vec3_t,0))){ + SWIG_fail_ptr("VertexVector___getitem",1,SWIGTYPE_p_std__vectorT_glm__vec3_t); } + SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned int)lua_tonumber(L, 2); try { + result = std_vector_Sl_ofDefaultVertexType_Sg____getitem__(arg1,arg2);} catch(std::out_of_range &_e) { + SWIG_exception(SWIG_IndexError, (&_e)->what()); } { glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_VertexVector___setitem(lua_State* L) { int SWIG_arg = 0; + std::vector< ofDefaultVertexType > *arg1 = (std::vector< ofDefaultVertexType > *) 0 ; unsigned int arg2 ; glm::vec3 arg3 ; + glm::vec3 *argp3 ; SWIG_check_num_args("std::vector< ofDefaultVertexType >::__setitem__",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< ofDefaultVertexType >::__setitem__",1,"std::vector< ofDefaultVertexType > *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("std::vector< ofDefaultVertexType >::__setitem__",2,"unsigned int"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("std::vector< ofDefaultVertexType >::__setitem__",3,"glm::vec3"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_glm__vec3_t,0))){ + SWIG_fail_ptr("VertexVector___setitem",1,SWIGTYPE_p_std__vectorT_glm__vec3_t); } + SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned int)lua_tonumber(L, 2); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&argp3,SWIGTYPE_p_glm__vec3,0))){ + SWIG_fail_ptr("VertexVector___setitem",3,SWIGTYPE_p_glm__vec3); } arg3 = *argp3; try { + std_vector_Sl_ofDefaultVertexType_Sg____setitem__(arg1,arg2,arg3);} catch(std::out_of_range &_e) { + SWIG_exception(SWIG_IndexError, (&_e)->what()); } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static void swig_delete_VertexVector(void *obj) { +std::vector< ofDefaultVertexType > *arg1 = (std::vector< ofDefaultVertexType > *) obj; +delete arg1; +} +static int _proxy__wrap_new_VertexVector(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_VertexVector); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_VertexVector_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_VertexVector_methods[]= { + { "size", _wrap_VertexVector_size}, + { "max_size", _wrap_VertexVector_max_size}, + { "empty", _wrap_VertexVector_empty}, + { "clear", _wrap_VertexVector_clear}, + { "push_back", _wrap_VertexVector_push_back}, + { "pop_back", _wrap_VertexVector_pop_back}, + { "front", _wrap_VertexVector_front}, + { "back", _wrap_VertexVector_back}, + { "__getitem", _wrap_VertexVector___getitem}, + { "__setitem", _wrap_VertexVector___setitem}, + {0,0} +}; +static swig_lua_method swig_VertexVector_meta[] = { + { "__getitem", _wrap_VertexVector___getitem}, + { "__setitem", _wrap_VertexVector___setitem}, + {0,0} +}; + +static swig_lua_attribute swig_VertexVector_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_VertexVector_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_VertexVector_Sf_SwigStatic_methods[]= { + {0,0} +}; +static swig_lua_class* swig_VertexVector_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_VertexVector_Sf_SwigStatic = { + "VertexVector", + swig_VertexVector_Sf_SwigStatic_methods, + swig_VertexVector_Sf_SwigStatic_attributes, + swig_VertexVector_Sf_SwigStatic_constants, + swig_VertexVector_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_VertexVector_bases[] = {0}; +static const char *swig_VertexVector_base_names[] = {0}; +static swig_lua_class _wrap_class_VertexVector = { "VertexVector", "VertexVector", &SWIGTYPE_p_std__vectorT_glm__vec3_t,_proxy__wrap_new_VertexVector, swig_delete_VertexVector, swig_VertexVector_methods, swig_VertexVector_attributes, &swig_VertexVector_Sf_SwigStatic, swig_VertexVector_meta, swig_VertexVector_bases, swig_VertexVector_base_names }; static int _wrap_new_Polyline__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPolyline_< ofDefaultVertexType > *result = 0 ; SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::ofPolyline_",0,0) result = (ofPolyline_< ofDefaultVertexType > *)new ofPolyline_< ofDefaultVertexType >(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_new_Polyline__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::vector< ofDefaultVertexType > *arg1 = 0 ; + SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_new_Polyline__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::vector< glm::vec3 > *arg1 = 0 ; ofPolyline_< ofDefaultVertexType > *result = 0 ; SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::ofPolyline_",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::ofPolyline_",1,"std::vector< ofDefaultVertexType > const &"); + if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::ofPolyline_",1,"std::vector< glm::vec3 > const &"); if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_glm__vec3_t,0))){ SWIG_fail_ptr("new_Polyline",1,SWIGTYPE_p_std__vectorT_glm__vec3_t); } - result = (ofPolyline_< ofDefaultVertexType > *)new ofPolyline_< ofDefaultVertexType >((std::vector< ofDefaultVertexType > const &)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } + result = (ofPolyline_< ofDefaultVertexType > *)new ofPolyline_< ofDefaultVertexType >((std::vector< glm::vec3 > const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } static int _wrap_new_Polyline(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_Polyline__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_std__vectorT_glm__vec3_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_new_Polyline__SWIG_1(L);} } + return _wrap_new_Polyline__SWIG_0(L);} if (argc == 1) { return _wrap_new_Polyline__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_Polyline'\n" " Possible C/C++ prototypes are:\n" " ofPolyline_< ofDefaultVertexType >::ofPolyline_()\n" - " ofPolyline_< ofDefaultVertexType >::ofPolyline_(std::vector< ofDefaultVertexType > const &)\n"); lua_error(L);return 0; } + " ofPolyline_< ofDefaultVertexType >::ofPolyline_(std::vector< glm::vec3 > const &)\n"); lua_error(L);return 0; } static int _wrap_Polyline_fromRectangle(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = 0 ; ofPolyline_< ofDefaultVertexType > result; SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::fromRectangle",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::fromRectangle",1,"ofRectangle const &"); @@ -31709,25 +33116,25 @@ static int _wrap_Polyline_fromRectangle(lua_State* L) { int SWIG_arg = 0; ofRect SWIG_fail_ptr("Polyline_fromRectangle",1,SWIGTYPE_p_ofRectangle); } result = ofPolyline_< ofDefaultVertexType >::SWIGTEMPLATEDISAMBIGUATOR fromRectangle((ofRectangle const &)*arg1); { ofPolyline_< ofDefaultVertexType > * resultptr = new ofPolyline_< ofDefaultVertexType >((const ofPolyline_< ofDefaultVertexType > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,1); SWIG_arg++; } return SWIG_arg; + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Polyline_clear(lua_State* L) { int SWIG_arg = 0; ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::clear",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::clear",1,"ofPolyline_< ofDefaultVertexType > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_clear",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } (arg1)->clear(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_clear",1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } (arg1)->clear(); return SWIG_arg; if(0) SWIG_fail; + fail: lua_error(L); return SWIG_arg; } static int _wrap_Polyline_addVertex__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; ofDefaultVertexType *arg2 = 0 ; + ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; glm::vec3 *arg2 = 0 ; SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::addVertex",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::addVertex",1,"ofPolyline_< ofDefaultVertexType > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::addVertex",2,"ofDefaultVertexType const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_addVertex",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } + if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::addVertex",2,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_addVertex",1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ - SWIG_fail_ptr("Polyline_addVertex",2,SWIGTYPE_p_glm__vec3); } (arg1)->addVertex((ofDefaultVertexType const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } + SWIG_fail_ptr("Polyline_addVertex",2,SWIGTYPE_p_glm__vec3); } (arg1)->addVertex((glm::vec3 const &)*arg2); return SWIG_arg; + if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Polyline_addVertex__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; float arg2 ; float arg3 ; float arg4 ; SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::addVertex",4,4) @@ -31735,8 +33142,8 @@ static int _wrap_Polyline_addVertex__SWIG_1(lua_State* L) { int SWIG_arg = 0; if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::addVertex",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::addVertex",3,"float"); if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::addVertex",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_addVertex",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } arg2 = (float)lua_tonumber(L, 2); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_addVertex",1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); (arg1)->addVertex(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Polyline_addVertex__SWIG_2(lua_State* L) { int SWIG_arg = 0; @@ -31745,79 +33152,55 @@ static int _wrap_Polyline_addVertex__SWIG_2(lua_State* L) { int SWIG_arg = 0; if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::addVertex",1,"ofPolyline_< ofDefaultVertexType > *"); if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::addVertex",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::addVertex",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_addVertex",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } arg2 = (float)lua_tonumber(L, 2); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_addVertex",1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); (arg1)->addVertex(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Polyline_addVertex(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Polyline_addVertex__SWIG_0(L);} } } if (argc == 3) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_Polyline_addVertex__SWIG_2(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Polyline_addVertex__SWIG_1(L);} } } } } + return _wrap_Polyline_addVertex__SWIG_0(L);} if (argc == 3) { return _wrap_Polyline_addVertex__SWIG_2(L);} + if (argc == 4) { return _wrap_Polyline_addVertex__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Polyline_addVertex'\n" " Possible C/C++ prototypes are:\n" - " ofPolyline_< ofDefaultVertexType >::addVertex(ofDefaultVertexType const &)\n" + " ofPolyline_< ofDefaultVertexType >::addVertex(glm::vec3 const &)\n" " ofPolyline_< ofDefaultVertexType >::addVertex(float,float,float)\n" " ofPolyline_< ofDefaultVertexType >::addVertex(float,float)\n"); lua_error(L);return 0; } static int _wrap_Polyline_addVertices__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; - std::vector< ofDefaultVertexType > *arg2 = 0 ; SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::addVertices",2,2) + ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; std::vector< glm::vec3 > *arg2 = 0 ; + SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::addVertices",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::addVertices",1,"ofPolyline_< ofDefaultVertexType > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::addVertices",2,"std::vector< ofDefaultVertexType > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_addVertices",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } + if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::addVertices",2,"std::vector< glm::vec3 > const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_addVertices",1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__vectorT_glm__vec3_t,0))){ SWIG_fail_ptr("Polyline_addVertices",2,SWIGTYPE_p_std__vectorT_glm__vec3_t); } - (arg1)->addVertices((std::vector< ofDefaultVertexType > const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + (arg1)->addVertices((std::vector< glm::vec3 > const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Polyline_addVertices__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; - ofDefaultVertexType *arg2 = (ofDefaultVertexType *) 0 ; int arg3 ; - SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::addVertices",3,3) + ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; glm::vec3 *arg2 = (glm::vec3 *) 0 ; + int arg3 ; SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::addVertices",3,3) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::addVertices",1,"ofPolyline_< ofDefaultVertexType > *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::addVertices",2,"ofDefaultVertexType const *"); + if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::addVertices",2,"glm::vec3 const *"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::addVertices",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_addVertices",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_addVertices",1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("Polyline_addVertices",2,SWIGTYPE_p_glm__vec3); } arg3 = (int)lua_tonumber(L, 3); - (arg1)->addVertices((ofDefaultVertexType const *)arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } + (arg1)->addVertices((glm::vec3 const *)arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Polyline_addVertices(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_std__vectorT_glm__vec3_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Polyline_addVertices__SWIG_0(L);} } } if (argc == 3) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Polyline_addVertices__SWIG_1(L);} } } } + return _wrap_Polyline_addVertices__SWIG_0(L);} if (argc == 3) { return _wrap_Polyline_addVertices__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Polyline_addVertices'\n" - " Possible C/C++ prototypes are:\n" - " ofPolyline_< ofDefaultVertexType >::addVertices(std::vector< ofDefaultVertexType > const &)\n" - " ofPolyline_< ofDefaultVertexType >::addVertices(ofDefaultVertexType const *,int)\n"); lua_error(L);return 0; } + " Possible C/C++ prototypes are:\n" " ofPolyline_< ofDefaultVertexType >::addVertices(std::vector< glm::vec3 > const &)\n" + " ofPolyline_< ofDefaultVertexType >::addVertices(glm::vec3 const *,int)\n"); lua_error(L);return 0; } static int _wrap_Polyline_insertVertex__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; ofDefaultVertexType *arg2 = 0 ; - int arg3 ; SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::insertVertex",3,3) + ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; glm::vec3 *arg2 = 0 ; int arg3 ; + SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::insertVertex",3,3) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::insertVertex",1,"ofPolyline_< ofDefaultVertexType > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::insertVertex",2,"ofDefaultVertexType const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::insertVertex",2,"glm::vec3 const &"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::insertVertex",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_insertVertex",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_insertVertex",1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("Polyline_insertVertex",2,SWIGTYPE_p_glm__vec3); } arg3 = (int)lua_tonumber(L, 3); - (arg1)->insertVertex((ofDefaultVertexType const &)*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } + (arg1)->insertVertex((glm::vec3 const &)*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Polyline_insertVertex__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; float arg2 ; float arg3 ; float arg4 ; int arg5 ; SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::insertVertex",5,5) @@ -31826,203 +33209,74 @@ static int _wrap_Polyline_insertVertex__SWIG_1(lua_State* L) { int SWIG_arg = 0; if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::insertVertex",3,"float"); if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::insertVertex",4,"float"); if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::insertVertex",5,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_insertVertex",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } arg2 = (float)lua_tonumber(L, 2); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_insertVertex",1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); (arg1)->insertVertex(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Polyline_insertVertex(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Polyline_insertVertex__SWIG_0(L);} } } } if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Polyline_insertVertex__SWIG_1(L);} } } } } } + if (argc == 3) { return _wrap_Polyline_insertVertex__SWIG_0(L);} if (argc == 5) { + return _wrap_Polyline_insertVertex__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Polyline_insertVertex'\n" - " Possible C/C++ prototypes are:\n" " ofPolyline_< ofDefaultVertexType >::insertVertex(ofDefaultVertexType const &,int)\n" + " Possible C/C++ prototypes are:\n" " ofPolyline_< ofDefaultVertexType >::insertVertex(glm::vec3 const &,int)\n" " ofPolyline_< ofDefaultVertexType >::insertVertex(float,float,float,int)\n"); lua_error(L);return 0; } +static int _wrap_Polyline_removeVertex(lua_State* L) { int SWIG_arg = 0; + ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; int arg2 ; + SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::removeVertex",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::removeVertex",1,"ofPolyline_< ofDefaultVertexType > *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::removeVertex",2,"int"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_removeVertex",1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } arg2 = (int)lua_tonumber(L, 2); + (arg1)->removeVertex(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Polyline_resize(lua_State* L) { int SWIG_arg = 0; ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; size_t arg2 ; SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::resize",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::resize",1,"ofPolyline_< ofDefaultVertexType > *"); if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::resize",2,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_resize",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_resize",1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); (arg1)->resize(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Polyline_size(lua_State* L) { int SWIG_arg = 0; ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; size_t result; SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::size",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::size",1,"ofPolyline_< ofDefaultVertexType > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_size",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_size",1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } result = (size_t)((ofPolyline_< ofDefaultVertexType > const *)arg1)->size(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Polyline_getVertices__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; - std::vector< ofDefaultVertexType > *result = 0 ; SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::getVertices",1,1) + ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; std::vector< glm::vec3 > *result = 0 ; + SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::getVertices",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::getVertices",1,"ofPolyline_< ofDefaultVertexType > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_getVertices",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } - result = (std::vector< ofDefaultVertexType > *) &(arg1)->getVertices(); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_getVertices",1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } + result = (std::vector< glm::vec3 > *) &(arg1)->getVertices(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_glm__vec3_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Polyline_getVertices__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; - std::vector< ofDefaultVertexType > *result = 0 ; SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::getVertices",1,1) + ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; std::vector< glm::vec3 > *result = 0 ; + SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::getVertices",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::getVertices",1,"ofPolyline_< ofDefaultVertexType > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_getVertices",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } - result = (std::vector< ofDefaultVertexType > *) &((ofPolyline_< ofDefaultVertexType > const *)arg1)->getVertices(); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_getVertices",1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } + result = (std::vector< glm::vec3 > *) &((ofPolyline_< ofDefaultVertexType > const *)arg1)->getVertices(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_glm__vec3_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Polyline_getVertices(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Polyline_getVertices__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Polyline_getVertices__SWIG_1(L);} } + return _wrap_Polyline_getVertices__SWIG_0(L);} if (argc == 1) { return _wrap_Polyline_getVertices__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Polyline_getVertices'\n" " Possible C/C++ prototypes are:\n" " ofPolyline_< ofDefaultVertexType >::getVertices()\n" " ofPolyline_< ofDefaultVertexType >::getVertices() const\n"); lua_error(L);return 0; } -static int _wrap_Polyline_begin__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; - SwigValueWrapper< std::vector< glm::vec3 >::iterator > result; - SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::begin",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::begin",1,"ofPolyline_< ofDefaultVertexType > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_begin",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } result = (arg1)->begin(); { - std::vector< ofDefaultVertexType >::iterator * resultptr = new std::vector< ofDefaultVertexType >::iterator((const std::vector< ofDefaultVertexType >::iterator &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_glm__vec3_t__iterator,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_begin__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; - SwigValueWrapper< std::vector< glm::vec3 >::const_iterator > result; - SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::begin",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::begin",1,"ofPolyline_< ofDefaultVertexType > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_begin",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } - result = ((ofPolyline_< ofDefaultVertexType > const *)arg1)->begin(); { - std::vector< ofDefaultVertexType >::const_iterator * resultptr = new std::vector< ofDefaultVertexType >::const_iterator((const std::vector< ofDefaultVertexType >::const_iterator &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_glm__vec3_t__const_iterator,1); SWIG_arg++; } - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_begin(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Polyline_begin__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Polyline_begin__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Polyline_begin'\n" " Possible C/C++ prototypes are:\n" - " ofPolyline_< ofDefaultVertexType >::begin()\n" " ofPolyline_< ofDefaultVertexType >::begin() const\n"); - lua_error(L);return 0; } -static int _wrap_Polyline_rbegin__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; - SwigValueWrapper< std::vector< glm::vec3 >::reverse_iterator > result; - SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::rbegin",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::rbegin",1,"ofPolyline_< ofDefaultVertexType > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_rbegin",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } result = (arg1)->rbegin(); { - std::vector< ofDefaultVertexType >::reverse_iterator * resultptr = new std::vector< ofDefaultVertexType >::reverse_iterator((const std::vector< ofDefaultVertexType >::reverse_iterator &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_glm__vec3_t__reverse_iterator,1); SWIG_arg++; } - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_rbegin__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; - SwigValueWrapper< std::vector< glm::vec3 >::const_reverse_iterator > result; - SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::rbegin",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::rbegin",1,"ofPolyline_< ofDefaultVertexType > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_rbegin",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } - result = ((ofPolyline_< ofDefaultVertexType > const *)arg1)->rbegin(); { - std::vector< ofDefaultVertexType >::const_reverse_iterator * resultptr = new std::vector< ofDefaultVertexType >::const_reverse_iterator((const std::vector< ofDefaultVertexType >::const_reverse_iterator &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_glm__vec3_t__const_reverse_iterator,1); SWIG_arg++; } - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_rbegin(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Polyline_rbegin__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Polyline_rbegin__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Polyline_rbegin'\n" " Possible C/C++ prototypes are:\n" - " ofPolyline_< ofDefaultVertexType >::rbegin()\n" " ofPolyline_< ofDefaultVertexType >::rbegin() const\n"); - lua_error(L);return 0; } -static int _wrap_Polyline_c_end__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; - SwigValueWrapper< std::vector< glm::vec3 >::iterator > result; - SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::end",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::end",1,"ofPolyline_< ofDefaultVertexType > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_c_end",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } result = (arg1)->end(); { - std::vector< ofDefaultVertexType >::iterator * resultptr = new std::vector< ofDefaultVertexType >::iterator((const std::vector< ofDefaultVertexType >::iterator &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_glm__vec3_t__iterator,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_c_end__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; - SwigValueWrapper< std::vector< glm::vec3 >::const_iterator > result; - SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::end",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::end",1,"ofPolyline_< ofDefaultVertexType > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_c_end",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } - result = ((ofPolyline_< ofDefaultVertexType > const *)arg1)->end(); { - std::vector< ofDefaultVertexType >::const_iterator * resultptr = new std::vector< ofDefaultVertexType >::const_iterator((const std::vector< ofDefaultVertexType >::const_iterator &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_glm__vec3_t__const_iterator,1); SWIG_arg++; } - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_c_end(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Polyline_c_end__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Polyline_c_end__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Polyline_c_end'\n" " Possible C/C++ prototypes are:\n" - " ofPolyline_< ofDefaultVertexType >::end()\n" " ofPolyline_< ofDefaultVertexType >::end() const\n"); - lua_error(L);return 0; } -static int _wrap_Polyline_rend__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; - SwigValueWrapper< std::vector< glm::vec3 >::reverse_iterator > result; - SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::rend",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::rend",1,"ofPolyline_< ofDefaultVertexType > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_rend",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } result = (arg1)->rend(); { - std::vector< ofDefaultVertexType >::reverse_iterator * resultptr = new std::vector< ofDefaultVertexType >::reverse_iterator((const std::vector< ofDefaultVertexType >::reverse_iterator &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_glm__vec3_t__reverse_iterator,1); SWIG_arg++; } - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_rend__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; - SwigValueWrapper< std::vector< glm::vec3 >::const_reverse_iterator > result; - SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::rend",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::rend",1,"ofPolyline_< ofDefaultVertexType > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_rend",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } - result = ((ofPolyline_< ofDefaultVertexType > const *)arg1)->rend(); { - std::vector< ofDefaultVertexType >::const_reverse_iterator * resultptr = new std::vector< ofDefaultVertexType >::const_reverse_iterator((const std::vector< ofDefaultVertexType >::const_reverse_iterator &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_glm__vec3_t__const_reverse_iterator,1); SWIG_arg++; } - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_rend(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Polyline_rend__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Polyline_rend__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Polyline_rend'\n" " Possible C/C++ prototypes are:\n" - " ofPolyline_< ofDefaultVertexType >::rend()\n" " ofPolyline_< ofDefaultVertexType >::rend() const\n"); - lua_error(L);return 0; } static int _wrap_Polyline_lineTo__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; ofDefaultVertexType *arg2 = 0 ; + ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; glm::vec3 *arg2 = 0 ; SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::lineTo",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::lineTo",1,"ofPolyline_< ofDefaultVertexType > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::lineTo",2,"ofDefaultVertexType const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_lineTo",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } + if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::lineTo",2,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_lineTo",1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ - SWIG_fail_ptr("Polyline_lineTo",2,SWIGTYPE_p_glm__vec3); } (arg1)->lineTo((ofDefaultVertexType const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } + SWIG_fail_ptr("Polyline_lineTo",2,SWIGTYPE_p_glm__vec3); } (arg1)->lineTo((glm::vec3 const &)*arg2); return SWIG_arg; + if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Polyline_lineTo__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; float arg2 ; float arg3 ; float arg4 ; SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::lineTo",4,4) @@ -32030,8 +33284,8 @@ static int _wrap_Polyline_lineTo__SWIG_1(lua_State* L) { int SWIG_arg = 0; if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::lineTo",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::lineTo",3,"float"); if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::lineTo",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_lineTo",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } arg2 = (float)lua_tonumber(L, 2); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_lineTo",1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); (arg1)->lineTo(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Polyline_lineTo__SWIG_2(lua_State* L) { int SWIG_arg = 0; @@ -32040,97 +33294,85 @@ static int _wrap_Polyline_lineTo__SWIG_2(lua_State* L) { int SWIG_arg = 0; if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::lineTo",1,"ofPolyline_< ofDefaultVertexType > *"); if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::lineTo",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::lineTo",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_lineTo",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } arg2 = (float)lua_tonumber(L, 2); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_lineTo",1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); (arg1)->lineTo(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Polyline_lineTo(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Polyline_lineTo__SWIG_0(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_Polyline_lineTo__SWIG_2(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Polyline_lineTo__SWIG_1(L);} } } } } + return _wrap_Polyline_lineTo__SWIG_0(L);} if (argc == 3) { return _wrap_Polyline_lineTo__SWIG_2(L);} if (argc == 4) { + return _wrap_Polyline_lineTo__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Polyline_lineTo'\n" " Possible C/C++ prototypes are:\n" - " ofPolyline_< ofDefaultVertexType >::lineTo(ofDefaultVertexType const &)\n" + " ofPolyline_< ofDefaultVertexType >::lineTo(glm::vec3 const &)\n" " ofPolyline_< ofDefaultVertexType >::lineTo(float,float,float)\n" " ofPolyline_< ofDefaultVertexType >::lineTo(float,float)\n"); lua_error(L);return 0; } static int _wrap_Polyline_arc__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; ofDefaultVertexType *arg2 = 0 ; - float arg3 ; float arg4 ; float arg5 ; float arg6 ; bool arg7 ; int arg8 ; + ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; glm::vec3 *arg2 = 0 ; float arg3 ; + float arg4 ; float arg5 ; float arg6 ; bool arg7 ; int arg8 ; SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::arc",8,8) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::arc",1,"ofPolyline_< ofDefaultVertexType > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::arc",2,"ofDefaultVertexType const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::arc",2,"glm::vec3 const &"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::arc",3,"float"); if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::arc",4,"float"); if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::arc",5,"float"); if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::arc",6,"float"); if(!lua_isboolean(L,7)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::arc",7,"bool"); if(!lua_isnumber(L,8)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::arc",8,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_arc",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_arc",1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("Polyline_arc",2,SWIGTYPE_p_glm__vec3); } arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); arg7 = (lua_toboolean(L, 7)!=0); - arg8 = (int)lua_tonumber(L, 8); (arg1)->arc((ofDefaultVertexType const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } + arg8 = (int)lua_tonumber(L, 8); (arg1)->arc((glm::vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8); return SWIG_arg; + if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Polyline_arc__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; ofDefaultVertexType *arg2 = 0 ; - float arg3 ; float arg4 ; float arg5 ; float arg6 ; bool arg7 ; - SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::arc",7,7) + ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; glm::vec3 *arg2 = 0 ; float arg3 ; + float arg4 ; float arg5 ; float arg6 ; bool arg7 ; SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::arc",7,7) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::arc",1,"ofPolyline_< ofDefaultVertexType > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::arc",2,"ofDefaultVertexType const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::arc",2,"glm::vec3 const &"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::arc",3,"float"); if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::arc",4,"float"); if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::arc",5,"float"); if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::arc",6,"float"); if(!lua_isboolean(L,7)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::arc",7,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_arc",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_arc",1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("Polyline_arc",2,SWIGTYPE_p_glm__vec3); } arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); arg7 = (lua_toboolean(L, 7)!=0); - (arg1)->arc((ofDefaultVertexType const &)*arg2,arg3,arg4,arg5,arg6,arg7); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } + (arg1)->arc((glm::vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } static int _wrap_Polyline_arc__SWIG_2(lua_State* L) { int SWIG_arg = 0; - ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; ofDefaultVertexType *arg2 = 0 ; - float arg3 ; float arg4 ; float arg5 ; float arg6 ; int arg7 ; - SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::arc",7,7) + ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; glm::vec3 *arg2 = 0 ; float arg3 ; + float arg4 ; float arg5 ; float arg6 ; int arg7 ; SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::arc",7,7) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::arc",1,"ofPolyline_< ofDefaultVertexType > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::arc",2,"ofDefaultVertexType const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::arc",2,"glm::vec3 const &"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::arc",3,"float"); if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::arc",4,"float"); if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::arc",5,"float"); if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::arc",6,"float"); if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::arc",7,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_arc",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_arc",1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("Polyline_arc",2,SWIGTYPE_p_glm__vec3); } arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); arg7 = (int)lua_tonumber(L, 7); - (arg1)->arc((ofDefaultVertexType const &)*arg2,arg3,arg4,arg5,arg6,arg7); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } + (arg1)->arc((glm::vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } static int _wrap_Polyline_arc__SWIG_3(lua_State* L) { int SWIG_arg = 0; - ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; ofDefaultVertexType *arg2 = 0 ; - float arg3 ; float arg4 ; float arg5 ; float arg6 ; SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::arc",6,6) + ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; glm::vec3 *arg2 = 0 ; float arg3 ; + float arg4 ; float arg5 ; float arg6 ; SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::arc",6,6) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::arc",1,"ofPolyline_< ofDefaultVertexType > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::arc",2,"ofDefaultVertexType const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::arc",2,"glm::vec3 const &"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::arc",3,"float"); if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::arc",4,"float"); if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::arc",5,"float"); if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::arc",6,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_arc",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_arc",1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("Polyline_arc",2,SWIGTYPE_p_glm__vec3); } arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); - (arg1)->arc((ofDefaultVertexType const &)*arg2,arg3,arg4,arg5,arg6); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } + arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); (arg1)->arc((glm::vec3 const &)*arg2,arg3,arg4,arg5,arg6); + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Polyline_arc__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; float arg2 ; float arg3 ; float arg4 ; float arg5 ; float arg6 ; float arg7 ; int arg8 ; SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::arc",8,8) @@ -32142,8 +33384,8 @@ static int _wrap_Polyline_arc__SWIG_4(lua_State* L) { int SWIG_arg = 0; if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::arc",6,"float"); if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::arc",7,"float"); if(!lua_isnumber(L,8)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::arc",8,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_arc",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } arg2 = (float)lua_tonumber(L, 2); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_arc",1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (int)lua_tonumber(L, 8); (arg1)->arc(arg2,arg3,arg4,arg5,arg6,arg7,arg8); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } @@ -32157,8 +33399,8 @@ static int _wrap_Polyline_arc__SWIG_5(lua_State* L) { int SWIG_arg = 0; if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::arc",5,"float"); if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::arc",6,"float"); if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::arc",7,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_arc",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } arg2 = (float)lua_tonumber(L, 2); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_arc",1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); (arg1)->arc(arg2,arg3,arg4,arg5,arg6,arg7); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } @@ -32175,123 +33417,65 @@ static int _wrap_Polyline_arc__SWIG_6(lua_State* L) { int SWIG_arg = 0; if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::arc",7,"float"); if(!lua_isnumber(L,8)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::arc",8,"float"); if(!lua_isnumber(L,9)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::arc",9,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_arc",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } arg2 = (float)lua_tonumber(L, 2); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_arc",1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (float)lua_tonumber(L, 8); arg9 = (int)lua_tonumber(L, 9); (arg1)->arc(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_arc__SWIG_7(lua_State* L) { int SWIG_arg = 0; - ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; float arg2 ; float arg3 ; float arg4 ; - float arg5 ; float arg6 ; float arg7 ; float arg8 ; SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::arc",8,8) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::arc",1,"ofPolyline_< ofDefaultVertexType > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::arc",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::arc",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::arc",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::arc",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::arc",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::arc",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::arc",8,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_arc",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (float)lua_tonumber(L, 8); - (arg1)->arc(arg2,arg3,arg4,arg5,arg6,arg7,arg8); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Polyline_arc(lua_State* L) { int argc; int argv[10]={ 1,2,3,4,5,6,7,8,9,10} ; argc = lua_gettop(L); - if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { - return _wrap_Polyline_arc__SWIG_3(L);} } } } } } } if (argc == 7) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { { - _v = lua_isboolean(L,argv[6]); } if (_v) { return _wrap_Polyline_arc__SWIG_1(L);} } } } } } } } - if (argc == 7) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { { - _v = lua_isnumber(L,argv[6]); } if (_v) { return _wrap_Polyline_arc__SWIG_2(L);} } } } } } } } - if (argc == 7) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { - return _wrap_Polyline_arc__SWIG_5(L);} } } } } } } } if (argc == 8) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { { - _v = lua_isboolean(L,argv[6]); } if (_v) { { _v = lua_isnumber(L,argv[7]); } if (_v) { - return _wrap_Polyline_arc__SWIG_0(L);} } } } } } } } } if (argc == 8) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { return _wrap_Polyline_arc__SWIG_4(L);} } } } } } } } } - if (argc == 8) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { return _wrap_Polyline_arc__SWIG_7(L);} } } } } } } } } - if (argc == 9) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { { _v = lua_isnumber(L,argv[8]); } if (_v) { - return _wrap_Polyline_arc__SWIG_6(L);} } } } } } } } } } + if (argc == 6) { return _wrap_Polyline_arc__SWIG_3(L);} if (argc == 7) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; { { _v = lua_isboolean(L,argv[6]); } } + if (!_v) goto check_2; return _wrap_Polyline_arc__SWIG_1(L);} check_2: if (argc == 7) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; return _wrap_Polyline_arc__SWIG_2(L);} check_3: + if (argc == 7) { return _wrap_Polyline_arc__SWIG_5(L);} if (argc == 8) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_5; { { _v = lua_isboolean(L,argv[6]); } } + if (!_v) goto check_5; return _wrap_Polyline_arc__SWIG_0(L);} check_5: if (argc == 8) { + return _wrap_Polyline_arc__SWIG_4(L);} if (argc == 9) { return _wrap_Polyline_arc__SWIG_6(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Polyline_arc'\n" " Possible C/C++ prototypes are:\n" - " ofPolyline_< ofDefaultVertexType >::arc(ofDefaultVertexType const &,float,float,float,float,bool,int)\n" - " ofPolyline_< ofDefaultVertexType >::arc(ofDefaultVertexType const &,float,float,float,float,bool)\n" - " ofPolyline_< ofDefaultVertexType >::arc(ofDefaultVertexType const &,float,float,float,float,int)\n" - " ofPolyline_< ofDefaultVertexType >::arc(ofDefaultVertexType const &,float,float,float,float)\n" + " ofPolyline_< ofDefaultVertexType >::arc(glm::vec3 const &,float,float,float,float,bool,int)\n" + " ofPolyline_< ofDefaultVertexType >::arc(glm::vec3 const &,float,float,float,float,bool)\n" + " ofPolyline_< ofDefaultVertexType >::arc(glm::vec3 const &,float,float,float,float,int)\n" + " ofPolyline_< ofDefaultVertexType >::arc(glm::vec3 const &,float,float,float,float)\n" " ofPolyline_< ofDefaultVertexType >::arc(float,float,float,float,float,float,int)\n" " ofPolyline_< ofDefaultVertexType >::arc(float,float,float,float,float,float)\n" - " ofPolyline_< ofDefaultVertexType >::arc(float,float,float,float,float,float,float,int)\n" - " ofPolyline_< ofDefaultVertexType >::arc(float,float,float,float,float,float,float)\n"); lua_error(L);return 0; } + " ofPolyline_< ofDefaultVertexType >::arc(float,float,float,float,float,float,float,int)\n"); lua_error(L);return 0; } static int _wrap_Polyline_arcNegative__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; ofDefaultVertexType *arg2 = 0 ; - float arg3 ; float arg4 ; float arg5 ; float arg6 ; int arg7 ; - SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::arcNegative",7,7) + ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; glm::vec3 *arg2 = 0 ; float arg3 ; + float arg4 ; float arg5 ; float arg6 ; int arg7 ; SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::arcNegative",7,7) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::arcNegative",1,"ofPolyline_< ofDefaultVertexType > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::arcNegative",2,"ofDefaultVertexType const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::arcNegative",2,"glm::vec3 const &"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::arcNegative",3,"float"); if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::arcNegative",4,"float"); if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::arcNegative",5,"float"); if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::arcNegative",6,"float"); if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::arcNegative",7,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_arcNegative",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_arcNegative",1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("Polyline_arcNegative",2,SWIGTYPE_p_glm__vec3); } arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); - arg7 = (int)lua_tonumber(L, 7); (arg1)->arcNegative((ofDefaultVertexType const &)*arg2,arg3,arg4,arg5,arg6,arg7); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } + arg7 = (int)lua_tonumber(L, 7); (arg1)->arcNegative((glm::vec3 const &)*arg2,arg3,arg4,arg5,arg6,arg7); return SWIG_arg; + if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Polyline_arcNegative__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; ofDefaultVertexType *arg2 = 0 ; - float arg3 ; float arg4 ; float arg5 ; float arg6 ; SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::arcNegative",6,6) + ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; glm::vec3 *arg2 = 0 ; float arg3 ; + float arg4 ; float arg5 ; float arg6 ; SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::arcNegative",6,6) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::arcNegative",1,"ofPolyline_< ofDefaultVertexType > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::arcNegative",2,"ofDefaultVertexType const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::arcNegative",2,"glm::vec3 const &"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::arcNegative",3,"float"); if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::arcNegative",4,"float"); if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::arcNegative",5,"float"); if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::arcNegative",6,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_arcNegative",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_arcNegative",1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("Polyline_arcNegative",2,SWIGTYPE_p_glm__vec3); } arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); - (arg1)->arcNegative((ofDefaultVertexType const &)*arg2,arg3,arg4,arg5,arg6); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } + (arg1)->arcNegative((glm::vec3 const &)*arg2,arg3,arg4,arg5,arg6); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } static int _wrap_Polyline_arcNegative__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; float arg2 ; float arg3 ; float arg4 ; float arg5 ; float arg6 ; float arg7 ; int arg8 ; SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::arcNegative",8,8) @@ -32303,8 +33487,8 @@ static int _wrap_Polyline_arcNegative__SWIG_2(lua_State* L) { int SWIG_arg = 0; if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::arcNegative",6,"float"); if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::arcNegative",7,"float"); if(!lua_isnumber(L,8)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::arcNegative",8,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_arcNegative",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } arg2 = (float)lua_tonumber(L, 2); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_arcNegative",1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (int)lua_tonumber(L, 8); (arg1)->arcNegative(arg2,arg3,arg4,arg5,arg6,arg7,arg8); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); @@ -32319,8 +33503,8 @@ static int _wrap_Polyline_arcNegative__SWIG_3(lua_State* L) { int SWIG_arg = 0; if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::arcNegative",5,"float"); if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::arcNegative",6,"float"); if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::arcNegative",7,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_arcNegative",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } arg2 = (float)lua_tonumber(L, 2); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_arcNegative",1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); (arg1)->arcNegative(arg2,arg3,arg4,arg5,arg6,arg7); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } @@ -32337,97 +33521,47 @@ static int _wrap_Polyline_arcNegative__SWIG_4(lua_State* L) { int SWIG_arg = 0; if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::arcNegative",7,"float"); if(!lua_isnumber(L,8)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::arcNegative",8,"float"); if(!lua_isnumber(L,9)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::arcNegative",9,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_arcNegative",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } arg2 = (float)lua_tonumber(L, 2); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_arcNegative",1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (float)lua_tonumber(L, 8); arg9 = (int)lua_tonumber(L, 9); (arg1)->arcNegative(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_arcNegative__SWIG_5(lua_State* L) { int SWIG_arg = 0; - ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; float arg2 ; float arg3 ; float arg4 ; - float arg5 ; float arg6 ; float arg7 ; float arg8 ; SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::arcNegative",8,8) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::arcNegative",1,"ofPolyline_< ofDefaultVertexType > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::arcNegative",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::arcNegative",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::arcNegative",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::arcNegative",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::arcNegative",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::arcNegative",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::arcNegative",8,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_arcNegative",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (float)lua_tonumber(L, 8); - (arg1)->arcNegative(arg2,arg3,arg4,arg5,arg6,arg7,arg8); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } static int _wrap_Polyline_arcNegative(lua_State* L) { int argc; int argv[10]={ 1,2,3,4,5,6,7,8,9,10} ; argc = lua_gettop(L); - if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { - return _wrap_Polyline_arcNegative__SWIG_1(L);} } } } } } } if (argc == 7) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { { - _v = lua_isnumber(L,argv[6]); } if (_v) { return _wrap_Polyline_arcNegative__SWIG_0(L);} } } } } } } } - if (argc == 7) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { - return _wrap_Polyline_arcNegative__SWIG_3(L);} } } } } } } } if (argc == 8) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { return _wrap_Polyline_arcNegative__SWIG_2(L);} } } } } } } - } } if (argc == 8) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { return _wrap_Polyline_arcNegative__SWIG_5(L);} } } } } } } - } } if (argc == 9) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { { _v = lua_isnumber(L,argv[8]); } if (_v) { - return _wrap_Polyline_arcNegative__SWIG_4(L);} } } } } } } } } } + if (argc == 6) { return _wrap_Polyline_arcNegative__SWIG_1(L);} if (argc == 7) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_Polyline_arcNegative__SWIG_0(L);} check_2: + if (argc == 7) { return _wrap_Polyline_arcNegative__SWIG_3(L);} if (argc == 8) { + return _wrap_Polyline_arcNegative__SWIG_2(L);} if (argc == 9) { return _wrap_Polyline_arcNegative__SWIG_4(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Polyline_arcNegative'\n" " Possible C/C++ prototypes are:\n" - " ofPolyline_< ofDefaultVertexType >::arcNegative(ofDefaultVertexType const &,float,float,float,float,int)\n" - " ofPolyline_< ofDefaultVertexType >::arcNegative(ofDefaultVertexType const &,float,float,float,float)\n" + " ofPolyline_< ofDefaultVertexType >::arcNegative(glm::vec3 const &,float,float,float,float,int)\n" + " ofPolyline_< ofDefaultVertexType >::arcNegative(glm::vec3 const &,float,float,float,float)\n" " ofPolyline_< ofDefaultVertexType >::arcNegative(float,float,float,float,float,float,int)\n" " ofPolyline_< ofDefaultVertexType >::arcNegative(float,float,float,float,float,float)\n" - " ofPolyline_< ofDefaultVertexType >::arcNegative(float,float,float,float,float,float,float,int)\n" - " ofPolyline_< ofDefaultVertexType >::arcNegative(float,float,float,float,float,float,float)\n"); lua_error(L);return 0; } + " ofPolyline_< ofDefaultVertexType >::arcNegative(float,float,float,float,float,float,float,int)\n"); + lua_error(L);return 0; } static int _wrap_Polyline_curveTo__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; ofDefaultVertexType *arg2 = 0 ; - int arg3 ; SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::curveTo",3,3) + ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; glm::vec3 *arg2 = 0 ; int arg3 ; + SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::curveTo",3,3) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::curveTo",1,"ofPolyline_< ofDefaultVertexType > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::curveTo",2,"ofDefaultVertexType const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::curveTo",2,"glm::vec3 const &"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::curveTo",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_curveTo",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_curveTo",1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("Polyline_curveTo",2,SWIGTYPE_p_glm__vec3); } arg3 = (int)lua_tonumber(L, 3); - (arg1)->curveTo((ofDefaultVertexType const &)*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } + (arg1)->curveTo((glm::vec3 const &)*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Polyline_curveTo__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; ofDefaultVertexType *arg2 = 0 ; + ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; glm::vec3 *arg2 = 0 ; SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::curveTo",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::curveTo",1,"ofPolyline_< ofDefaultVertexType > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::curveTo",2,"ofDefaultVertexType const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_curveTo",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } + if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::curveTo",2,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_curveTo",1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ - SWIG_fail_ptr("Polyline_curveTo",2,SWIGTYPE_p_glm__vec3); } (arg1)->curveTo((ofDefaultVertexType const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } + SWIG_fail_ptr("Polyline_curveTo",2,SWIGTYPE_p_glm__vec3); } (arg1)->curveTo((glm::vec3 const &)*arg2); return SWIG_arg; + if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Polyline_curveTo__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; float arg2 ; float arg3 ; float arg4 ; int arg5 ; SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::curveTo",5,5) @@ -32436,8 +33570,8 @@ static int _wrap_Polyline_curveTo__SWIG_2(lua_State* L) { int SWIG_arg = 0; if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::curveTo",3,"float"); if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::curveTo",4,"float"); if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::curveTo",5,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_curveTo",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } arg2 = (float)lua_tonumber(L, 2); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_curveTo",1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); (arg1)->curveTo(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Polyline_curveTo__SWIG_3(lua_State* L) { int SWIG_arg = 0; @@ -32447,8 +33581,8 @@ static int _wrap_Polyline_curveTo__SWIG_3(lua_State* L) { int SWIG_arg = 0; if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::curveTo",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::curveTo",3,"float"); if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::curveTo",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_curveTo",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } arg2 = (float)lua_tonumber(L, 2); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_curveTo",1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); (arg1)->curveTo(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Polyline_curveTo__SWIG_4(lua_State* L) { int SWIG_arg = 0; @@ -32457,75 +33591,57 @@ static int _wrap_Polyline_curveTo__SWIG_4(lua_State* L) { int SWIG_arg = 0; if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::curveTo",1,"ofPolyline_< ofDefaultVertexType > *"); if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::curveTo",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::curveTo",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_curveTo",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } arg2 = (float)lua_tonumber(L, 2); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_curveTo",1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); (arg1)->curveTo(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Polyline_curveTo(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Polyline_curveTo__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Polyline_curveTo__SWIG_0(L);} - } } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_Polyline_curveTo__SWIG_4(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Polyline_curveTo__SWIG_3(L);} } } } } - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Polyline_curveTo__SWIG_2(L);} } } } } } + return _wrap_Polyline_curveTo__SWIG_1(L);} if (argc == 3) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_Polyline_curveTo__SWIG_0(L);} check_2: + if (argc == 3) { return _wrap_Polyline_curveTo__SWIG_4(L);} if (argc == 4) { return _wrap_Polyline_curveTo__SWIG_3(L);} + if (argc == 5) { return _wrap_Polyline_curveTo__SWIG_2(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Polyline_curveTo'\n" " Possible C/C++ prototypes are:\n" - " ofPolyline_< ofDefaultVertexType >::curveTo(ofDefaultVertexType const &,int)\n" - " ofPolyline_< ofDefaultVertexType >::curveTo(ofDefaultVertexType const &)\n" + " ofPolyline_< ofDefaultVertexType >::curveTo(glm::vec3 const &,int)\n" + " ofPolyline_< ofDefaultVertexType >::curveTo(glm::vec3 const &)\n" " ofPolyline_< ofDefaultVertexType >::curveTo(float,float,float,int)\n" " ofPolyline_< ofDefaultVertexType >::curveTo(float,float,float)\n" " ofPolyline_< ofDefaultVertexType >::curveTo(float,float)\n"); lua_error(L);return 0; } static int _wrap_Polyline_bezierTo__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; ofDefaultVertexType *arg2 = 0 ; - ofDefaultVertexType *arg3 = 0 ; ofDefaultVertexType *arg4 = 0 ; int arg5 ; - SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::bezierTo",5,5) + ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; glm::vec3 *arg2 = 0 ; + glm::vec3 *arg3 = 0 ; glm::vec3 *arg4 = 0 ; int arg5 ; SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::bezierTo",5,5) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::bezierTo",1,"ofPolyline_< ofDefaultVertexType > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::bezierTo",2,"ofDefaultVertexType const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::bezierTo",3,"ofDefaultVertexType const &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::bezierTo",4,"ofDefaultVertexType const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::bezierTo",2,"glm::vec3 const &"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::bezierTo",3,"glm::vec3 const &"); + if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::bezierTo",4,"glm::vec3 const &"); if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::bezierTo",5,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_bezierTo",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_bezierTo",1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("Polyline_bezierTo",2,SWIGTYPE_p_glm__vec3); } if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("Polyline_bezierTo",3,SWIGTYPE_p_glm__vec3); } if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("Polyline_bezierTo",4,SWIGTYPE_p_glm__vec3); } arg5 = (int)lua_tonumber(L, 5); - (arg1)->bezierTo((ofDefaultVertexType const &)*arg2,(ofDefaultVertexType const &)*arg3,(ofDefaultVertexType const &)*arg4,arg5); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } + (arg1)->bezierTo((glm::vec3 const &)*arg2,(glm::vec3 const &)*arg3,(glm::vec3 const &)*arg4,arg5); return SWIG_arg; + if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Polyline_bezierTo__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; ofDefaultVertexType *arg2 = 0 ; - ofDefaultVertexType *arg3 = 0 ; ofDefaultVertexType *arg4 = 0 ; - SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::bezierTo",4,4) + ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; glm::vec3 *arg2 = 0 ; + glm::vec3 *arg3 = 0 ; glm::vec3 *arg4 = 0 ; SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::bezierTo",4,4) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::bezierTo",1,"ofPolyline_< ofDefaultVertexType > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::bezierTo",2,"ofDefaultVertexType const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::bezierTo",3,"ofDefaultVertexType const &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::bezierTo",4,"ofDefaultVertexType const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_bezierTo",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } + if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::bezierTo",2,"glm::vec3 const &"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::bezierTo",3,"glm::vec3 const &"); + if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::bezierTo",4,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_bezierTo",1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("Polyline_bezierTo",2,SWIGTYPE_p_glm__vec3); } if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("Polyline_bezierTo",3,SWIGTYPE_p_glm__vec3); } if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("Polyline_bezierTo",4,SWIGTYPE_p_glm__vec3); } - (arg1)->bezierTo((ofDefaultVertexType const &)*arg2,(ofDefaultVertexType const &)*arg3,(ofDefaultVertexType const &)*arg4); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } + (arg1)->bezierTo((glm::vec3 const &)*arg2,(glm::vec3 const &)*arg3,(glm::vec3 const &)*arg4); return SWIG_arg; + if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Polyline_bezierTo__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; float arg2 ; float arg3 ; float arg4 ; float arg5 ; float arg6 ; float arg7 ; int arg8 ; SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::bezierTo",8,8) @@ -32537,8 +33653,8 @@ static int _wrap_Polyline_bezierTo__SWIG_2(lua_State* L) { int SWIG_arg = 0; if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::bezierTo",6,"float"); if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::bezierTo",7,"float"); if(!lua_isnumber(L,8)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::bezierTo",8,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_bezierTo",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } arg2 = (float)lua_tonumber(L, 2); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_bezierTo",1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (int)lua_tonumber(L, 8); (arg1)->bezierTo(arg2,arg3,arg4,arg5,arg6,arg7,arg8); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } @@ -32552,8 +33668,8 @@ static int _wrap_Polyline_bezierTo__SWIG_3(lua_State* L) { int SWIG_arg = 0; if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::bezierTo",5,"float"); if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::bezierTo",6,"float"); if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::bezierTo",7,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_bezierTo",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } arg2 = (float)lua_tonumber(L, 2); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_bezierTo",1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); (arg1)->bezierTo(arg2,arg3,arg4,arg5,arg6,arg7); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } @@ -32572,8 +33688,8 @@ static int _wrap_Polyline_bezierTo__SWIG_4(lua_State* L) { int SWIG_arg = 0; if(!lua_isnumber(L,9)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::bezierTo",9,"float"); if(!lua_isnumber(L,10)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::bezierTo",10,"float"); if(!lua_isnumber(L,11)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::bezierTo",11,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_bezierTo",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } arg2 = (float)lua_tonumber(L, 2); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_bezierTo",1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (float)lua_tonumber(L, 8); arg9 = (float)lua_tonumber(L, 9); arg10 = (float)lua_tonumber(L, 10); arg11 = (int)lua_tonumber(L, 11); @@ -32593,61 +33709,20 @@ static int _wrap_Polyline_bezierTo__SWIG_5(lua_State* L) { int SWIG_arg = 0; if(!lua_isnumber(L,8)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::bezierTo",8,"float"); if(!lua_isnumber(L,9)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::bezierTo",9,"float"); if(!lua_isnumber(L,10)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::bezierTo",10,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_bezierTo",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } arg2 = (float)lua_tonumber(L, 2); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_bezierTo",1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (float)lua_tonumber(L, 8); arg9 = (float)lua_tonumber(L, 9); arg10 = (float)lua_tonumber(L, 10); (arg1)->bezierTo(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Polyline_bezierTo(lua_State* L) { int argc; int argv[12]={ 1,2,3,4,5,6,7,8,9,10,11,12} ; argc = lua_gettop(L); - if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Polyline_bezierTo__SWIG_1(L);} } } } } if (argc == 5) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Polyline_bezierTo__SWIG_0(L);} } } } } } if (argc == 7) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { - return _wrap_Polyline_bezierTo__SWIG_3(L);} } } } } } } } if (argc == 8) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { return _wrap_Polyline_bezierTo__SWIG_2(L);} } } } } } } } - } if (argc == 10) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { { _v = lua_isnumber(L,argv[8]); } if (_v) { { - _v = lua_isnumber(L,argv[9]); } if (_v) { return _wrap_Polyline_bezierTo__SWIG_5(L);} } } } } } } - } } } } if (argc == 11) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { { _v = lua_isnumber(L,argv[8]); } if (_v) { { - _v = lua_isnumber(L,argv[9]); } if (_v) { { _v = lua_isnumber(L,argv[10]); } if (_v) { - return _wrap_Polyline_bezierTo__SWIG_4(L);} } } } } } } } } } } } + if (argc == 4) { return _wrap_Polyline_bezierTo__SWIG_1(L);} if (argc == 5) { return _wrap_Polyline_bezierTo__SWIG_0(L);} + if (argc == 7) { return _wrap_Polyline_bezierTo__SWIG_3(L);} if (argc == 8) { return _wrap_Polyline_bezierTo__SWIG_2(L);} + if (argc == 10) { return _wrap_Polyline_bezierTo__SWIG_5(L);} if (argc == 11) { return _wrap_Polyline_bezierTo__SWIG_4(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Polyline_bezierTo'\n" " Possible C/C++ prototypes are:\n" - " ofPolyline_< ofDefaultVertexType >::bezierTo(ofDefaultVertexType const &,ofDefaultVertexType const &,ofDefaultVertexType const &,int)\n" - " ofPolyline_< ofDefaultVertexType >::bezierTo(ofDefaultVertexType const &,ofDefaultVertexType const &,ofDefaultVertexType const &)\n" + " ofPolyline_< ofDefaultVertexType >::bezierTo(glm::vec3 const &,glm::vec3 const &,glm::vec3 const &,int)\n" + " ofPolyline_< ofDefaultVertexType >::bezierTo(glm::vec3 const &,glm::vec3 const &,glm::vec3 const &)\n" " ofPolyline_< ofDefaultVertexType >::bezierTo(float,float,float,float,float,float,int)\n" " ofPolyline_< ofDefaultVertexType >::bezierTo(float,float,float,float,float,float)\n" " ofPolyline_< ofDefaultVertexType >::bezierTo(float,float,float,float,float,float,float,float,float,int)\n" @@ -32668,8 +33743,8 @@ static int _wrap_Polyline_quadBezierTo__SWIG_0(lua_State* L) { int SWIG_arg = 0; if(!lua_isnumber(L,9)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::quadBezierTo",9,"float"); if(!lua_isnumber(L,10)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::quadBezierTo",10,"float"); if(!lua_isnumber(L,11)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::quadBezierTo",11,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_quadBezierTo",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } arg2 = (float)lua_tonumber(L, 2); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_quadBezierTo",1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (float)lua_tonumber(L, 8); arg9 = (float)lua_tonumber(L, 9); arg10 = (float)lua_tonumber(L, 10); arg11 = (int)lua_tonumber(L, 11); @@ -32689,50 +33764,49 @@ static int _wrap_Polyline_quadBezierTo__SWIG_1(lua_State* L) { int SWIG_arg = 0; if(!lua_isnumber(L,8)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::quadBezierTo",8,"float"); if(!lua_isnumber(L,9)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::quadBezierTo",9,"float"); if(!lua_isnumber(L,10)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::quadBezierTo",10,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_quadBezierTo",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } arg2 = (float)lua_tonumber(L, 2); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_quadBezierTo",1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (float)lua_tonumber(L, 8); arg9 = (float)lua_tonumber(L, 9); arg10 = (float)lua_tonumber(L, 10); (arg1)->quadBezierTo(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Polyline_quadBezierTo__SWIG_2(lua_State* L) { int SWIG_arg = 0; - ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; ofDefaultVertexType *arg2 = 0 ; - ofDefaultVertexType *arg3 = 0 ; ofDefaultVertexType *arg4 = 0 ; int arg5 ; + ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; glm::vec3 *arg2 = 0 ; + glm::vec3 *arg3 = 0 ; glm::vec3 *arg4 = 0 ; int arg5 ; SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::quadBezierTo",5,5) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::quadBezierTo",1,"ofPolyline_< ofDefaultVertexType > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::quadBezierTo",2,"ofDefaultVertexType const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::quadBezierTo",3,"ofDefaultVertexType const &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::quadBezierTo",4,"ofDefaultVertexType const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::quadBezierTo",2,"glm::vec3 const &"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::quadBezierTo",3,"glm::vec3 const &"); + if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::quadBezierTo",4,"glm::vec3 const &"); if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::quadBezierTo",5,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_quadBezierTo",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_quadBezierTo",1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("Polyline_quadBezierTo",2,SWIGTYPE_p_glm__vec3); } if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("Polyline_quadBezierTo",3,SWIGTYPE_p_glm__vec3); } if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("Polyline_quadBezierTo",4,SWIGTYPE_p_glm__vec3); } arg5 = (int)lua_tonumber(L, 5); - (arg1)->quadBezierTo((ofDefaultVertexType const &)*arg2,(ofDefaultVertexType const &)*arg3,(ofDefaultVertexType const &)*arg4,arg5); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } + (arg1)->quadBezierTo((glm::vec3 const &)*arg2,(glm::vec3 const &)*arg3,(glm::vec3 const &)*arg4,arg5); return SWIG_arg; + if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Polyline_quadBezierTo__SWIG_3(lua_State* L) { int SWIG_arg = 0; - ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; ofDefaultVertexType *arg2 = 0 ; - ofDefaultVertexType *arg3 = 0 ; ofDefaultVertexType *arg4 = 0 ; - SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::quadBezierTo",4,4) + ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; glm::vec3 *arg2 = 0 ; + glm::vec3 *arg3 = 0 ; glm::vec3 *arg4 = 0 ; SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::quadBezierTo",4,4) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::quadBezierTo",1,"ofPolyline_< ofDefaultVertexType > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::quadBezierTo",2,"ofDefaultVertexType const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::quadBezierTo",3,"ofDefaultVertexType const &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::quadBezierTo",4,"ofDefaultVertexType const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_quadBezierTo",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } + if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::quadBezierTo",2,"glm::vec3 const &"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::quadBezierTo",3,"glm::vec3 const &"); + if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::quadBezierTo",4,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_quadBezierTo",1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("Polyline_quadBezierTo",2,SWIGTYPE_p_glm__vec3); } if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("Polyline_quadBezierTo",3,SWIGTYPE_p_glm__vec3); } if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("Polyline_quadBezierTo",4,SWIGTYPE_p_glm__vec3); } - (arg1)->quadBezierTo((ofDefaultVertexType const &)*arg2,(ofDefaultVertexType const &)*arg3,(ofDefaultVertexType const &)*arg4); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } + (arg1)->quadBezierTo((glm::vec3 const &)*arg2,(glm::vec3 const &)*arg3,(glm::vec3 const &)*arg4); return SWIG_arg; + if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Polyline_quadBezierTo__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; float arg2 ; float arg3 ; float arg4 ; float arg5 ; float arg6 ; float arg7 ; int arg8 ; SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::quadBezierTo",8,8) @@ -32744,8 +33818,8 @@ static int _wrap_Polyline_quadBezierTo__SWIG_4(lua_State* L) { int SWIG_arg = 0; if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::quadBezierTo",6,"float"); if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::quadBezierTo",7,"float"); if(!lua_isnumber(L,8)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::quadBezierTo",8,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_quadBezierTo",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } arg2 = (float)lua_tonumber(L, 2); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_quadBezierTo",1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (int)lua_tonumber(L, 8); (arg1)->quadBezierTo(arg2,arg3,arg4,arg5,arg6,arg7,arg8); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); @@ -32760,62 +33834,22 @@ static int _wrap_Polyline_quadBezierTo__SWIG_5(lua_State* L) { int SWIG_arg = 0; if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::quadBezierTo",5,"float"); if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::quadBezierTo",6,"float"); if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::quadBezierTo",7,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_quadBezierTo",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } arg2 = (float)lua_tonumber(L, 2); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_quadBezierTo",1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); (arg1)->quadBezierTo(arg2,arg3,arg4,arg5,arg6,arg7); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Polyline_quadBezierTo(lua_State* L) { int argc; int argv[12]={ 1,2,3,4,5,6,7,8,9,10,11,12} ; - argc = lua_gettop(L); if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Polyline_quadBezierTo__SWIG_3(L);} } } } } if (argc == 5) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Polyline_quadBezierTo__SWIG_2(L);} } } } } } if (argc == 7) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { - return _wrap_Polyline_quadBezierTo__SWIG_5(L);} } } } } } } } if (argc == 8) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { return _wrap_Polyline_quadBezierTo__SWIG_4(L);} } } } } } } - } } if (argc == 10) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { { _v = lua_isnumber(L,argv[8]); } if (_v) { { - _v = lua_isnumber(L,argv[9]); } if (_v) { return _wrap_Polyline_quadBezierTo__SWIG_1(L);} } } } } } - } } } } } if (argc == 11) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { { _v = lua_isnumber(L,argv[8]); } if (_v) { { - _v = lua_isnumber(L,argv[9]); } if (_v) { { _v = lua_isnumber(L,argv[10]); } if (_v) { - return _wrap_Polyline_quadBezierTo__SWIG_0(L);} } } } } } } } } } } } + argc = lua_gettop(L); if (argc == 4) { return _wrap_Polyline_quadBezierTo__SWIG_3(L);} if (argc == 5) { + return _wrap_Polyline_quadBezierTo__SWIG_2(L);} if (argc == 7) { return _wrap_Polyline_quadBezierTo__SWIG_5(L);} + if (argc == 8) { return _wrap_Polyline_quadBezierTo__SWIG_4(L);} if (argc == 10) { + return _wrap_Polyline_quadBezierTo__SWIG_1(L);} if (argc == 11) { return _wrap_Polyline_quadBezierTo__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Polyline_quadBezierTo'\n" " Possible C/C++ prototypes are:\n" " ofPolyline_< ofDefaultVertexType >::quadBezierTo(float,float,float,float,float,float,float,float,float,int)\n" " ofPolyline_< ofDefaultVertexType >::quadBezierTo(float,float,float,float,float,float,float,float,float)\n" - " ofPolyline_< ofDefaultVertexType >::quadBezierTo(ofDefaultVertexType const &,ofDefaultVertexType const &,ofDefaultVertexType const &,int)\n" - " ofPolyline_< ofDefaultVertexType >::quadBezierTo(ofDefaultVertexType const &,ofDefaultVertexType const &,ofDefaultVertexType const &)\n" + " ofPolyline_< ofDefaultVertexType >::quadBezierTo(glm::vec3 const &,glm::vec3 const &,glm::vec3 const &,int)\n" + " ofPolyline_< ofDefaultVertexType >::quadBezierTo(glm::vec3 const &,glm::vec3 const &,glm::vec3 const &)\n" " ofPolyline_< ofDefaultVertexType >::quadBezierTo(float,float,float,float,float,float,int)\n" " ofPolyline_< ofDefaultVertexType >::quadBezierTo(float,float,float,float,float,float)\n"); lua_error(L);return 0; } static int _wrap_Polyline_getSmoothed__SWIG_0(lua_State* L) { int SWIG_arg = 0; @@ -32824,31 +33858,25 @@ static int _wrap_Polyline_getSmoothed__SWIG_0(lua_State* L) { int SWIG_arg = 0; if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::getSmoothed",1,"ofPolyline_< ofDefaultVertexType > const *"); if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::getSmoothed",2,"int"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::getSmoothed",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_getSmoothed",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } arg2 = (int)lua_tonumber(L, 2); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_getSmoothed",1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } arg2 = (int)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); result = ((ofPolyline_< ofDefaultVertexType > const *)arg1)->getSmoothed(arg2,arg3); { ofPolyline_< ofDefaultVertexType > * resultptr = new ofPolyline_< ofDefaultVertexType >((const ofPolyline_< ofDefaultVertexType > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,1); SWIG_arg++; } return SWIG_arg; + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Polyline_getSmoothed__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; int arg2 ; ofPolyline_< ofDefaultVertexType > result; SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::getSmoothed",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::getSmoothed",1,"ofPolyline_< ofDefaultVertexType > const *"); if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::getSmoothed",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_getSmoothed",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } arg2 = (int)lua_tonumber(L, 2); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_getSmoothed",1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } arg2 = (int)lua_tonumber(L, 2); result = ((ofPolyline_< ofDefaultVertexType > const *)arg1)->getSmoothed(arg2); { ofPolyline_< ofDefaultVertexType > * resultptr = new ofPolyline_< ofDefaultVertexType >((const ofPolyline_< ofDefaultVertexType > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,1); SWIG_arg++; } return SWIG_arg; + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Polyline_getSmoothed(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Polyline_getSmoothed__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_Polyline_getSmoothed__SWIG_0(L);} } } } + return _wrap_Polyline_getSmoothed__SWIG_1(L);} if (argc == 3) { return _wrap_Polyline_getSmoothed__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Polyline_getSmoothed'\n" " Possible C/C++ prototypes are:\n" " ofPolyline_< ofDefaultVertexType >::getSmoothed(int,float) const\n" " ofPolyline_< ofDefaultVertexType >::getSmoothed(int) const\n"); lua_error(L);return 0; } @@ -32858,86 +33886,177 @@ static int _wrap_Polyline_getResampledBySpacing(lua_State* L) { int SWIG_arg = 0 SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::getResampledBySpacing",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::getResampledBySpacing",1,"ofPolyline_< ofDefaultVertexType > const *"); if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::getResampledBySpacing",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_getResampledBySpacing",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } - arg2 = (float)lua_tonumber(L, 2); result = ((ofPolyline_< ofDefaultVertexType > const *)arg1)->getResampledBySpacing(arg2); { + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_getResampledBySpacing",1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } arg2 = (float)lua_tonumber(L, 2); + result = ((ofPolyline_< ofDefaultVertexType > const *)arg1)->getResampledBySpacing(arg2); { ofPolyline_< ofDefaultVertexType > * resultptr = new ofPolyline_< ofDefaultVertexType >((const ofPolyline_< ofDefaultVertexType > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,1); SWIG_arg++; } return SWIG_arg; + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Polyline_getResampledByCount(lua_State* L) { int SWIG_arg = 0; ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; int arg2 ; ofPolyline_< ofDefaultVertexType > result; SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::getResampledByCount",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::getResampledByCount",1,"ofPolyline_< ofDefaultVertexType > const *"); if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::getResampledByCount",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_getResampledByCount",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } - arg2 = (int)lua_tonumber(L, 2); result = ((ofPolyline_< ofDefaultVertexType > const *)arg1)->getResampledByCount(arg2); { + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_getResampledByCount",1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } arg2 = (int)lua_tonumber(L, 2); + result = ((ofPolyline_< ofDefaultVertexType > const *)arg1)->getResampledByCount(arg2); { ofPolyline_< ofDefaultVertexType > * resultptr = new ofPolyline_< ofDefaultVertexType >((const ofPolyline_< ofDefaultVertexType > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,1); SWIG_arg++; } return SWIG_arg; + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Polyline_simplify__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; float arg2 ; SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::simplify",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::simplify",1,"ofPolyline_< ofDefaultVertexType > *"); if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::simplify",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_simplify",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } arg2 = (float)lua_tonumber(L, 2); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_simplify",1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } arg2 = (float)lua_tonumber(L, 2); (arg1)->simplify(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Polyline_simplify__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::simplify",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::simplify",1,"ofPolyline_< ofDefaultVertexType > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_simplify",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } (arg1)->simplify(); return SWIG_arg; + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_simplify",1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } (arg1)->simplify(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Polyline_simplify(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Polyline_simplify__SWIG_1(L);} } if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Polyline_simplify__SWIG_0(L);} } } + return _wrap_Polyline_simplify__SWIG_1(L);} if (argc == 2) { return _wrap_Polyline_simplify__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Polyline_simplify'\n" " Possible C/C++ prototypes are:\n" " ofPolyline_< ofDefaultVertexType >::simplify(float)\n" " ofPolyline_< ofDefaultVertexType >::simplify()\n"); lua_error(L);return 0; } +static int _wrap_Polyline_rotateDeg__SWIG_0(lua_State* L) { int SWIG_arg = 0; + ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; float arg2 ; glm::vec3 *arg3 = 0 ; + SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::rotateDeg",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::rotateDeg",1,"ofPolyline_< ofDefaultVertexType > *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::rotateDeg",2,"float"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::rotateDeg",3,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_rotateDeg",1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } arg2 = (float)lua_tonumber(L, 2); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_glm__vec3,0))){ + SWIG_fail_ptr("Polyline_rotateDeg",3,SWIGTYPE_p_glm__vec3); } (arg1)->rotateDeg(arg2,(glm::vec3 const &)*arg3); + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Polyline_rotateRad__SWIG_0(lua_State* L) { int SWIG_arg = 0; + ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; float arg2 ; glm::vec3 *arg3 = 0 ; + SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::rotateRad",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::rotateRad",1,"ofPolyline_< ofDefaultVertexType > *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::rotateRad",2,"float"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::rotateRad",3,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_rotateRad",1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } arg2 = (float)lua_tonumber(L, 2); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_glm__vec3,0))){ + SWIG_fail_ptr("Polyline_rotateRad",3,SWIGTYPE_p_glm__vec3); } (arg1)->rotateRad(arg2,(glm::vec3 const &)*arg3); + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Polyline_translate__SWIG_0(lua_State* L) { int SWIG_arg = 0; + ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; glm::vec3 *arg2 = 0 ; + SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::translate",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::translate",1,"ofPolyline_< ofDefaultVertexType > *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::translate",2,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_translate",1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ + SWIG_fail_ptr("Polyline_translate",2,SWIGTYPE_p_glm__vec3); } (arg1)->translate((glm::vec3 const &)*arg2); return SWIG_arg; + if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Polyline_rotateDeg__SWIG_1(lua_State* L) { int SWIG_arg = 0; + ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; float arg2 ; glm::vec2 *arg3 = 0 ; + SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::rotateDeg",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::rotateDeg",1,"ofPolyline_< ofDefaultVertexType > *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::rotateDeg",2,"float"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::rotateDeg",3,"glm::vec2 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_rotateDeg",1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } arg2 = (float)lua_tonumber(L, 2); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_glm__vec2,0))){ + SWIG_fail_ptr("Polyline_rotateDeg",3,SWIGTYPE_p_glm__vec2); } (arg1)->rotateDeg(arg2,(glm::vec2 const &)*arg3); + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Polyline_rotateDeg(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 3) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_Polyline_rotateDeg__SWIG_0(L);} check_1: + if (argc == 3) { return _wrap_Polyline_rotateDeg__SWIG_1(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Polyline_rotateDeg'\n" " Possible C/C++ prototypes are:\n" + " ofPolyline_< ofDefaultVertexType >::rotateDeg(float,glm::vec3 const &)\n" + " ofPolyline_< ofDefaultVertexType >::rotateDeg(float,glm::vec2 const &)\n"); lua_error(L);return 0; } +static int _wrap_Polyline_rotateRad__SWIG_1(lua_State* L) { int SWIG_arg = 0; + ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; float arg2 ; glm::vec2 *arg3 = 0 ; + SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::rotateRad",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::rotateRad",1,"ofPolyline_< ofDefaultVertexType > *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::rotateRad",2,"float"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::rotateRad",3,"glm::vec2 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_rotateRad",1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } arg2 = (float)lua_tonumber(L, 2); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_glm__vec2,0))){ + SWIG_fail_ptr("Polyline_rotateRad",3,SWIGTYPE_p_glm__vec2); } (arg1)->rotateRad(arg2,(glm::vec2 const &)*arg3); + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Polyline_rotateRad(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 3) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_Polyline_rotateRad__SWIG_0(L);} check_1: + if (argc == 3) { return _wrap_Polyline_rotateRad__SWIG_1(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Polyline_rotateRad'\n" " Possible C/C++ prototypes are:\n" + " ofPolyline_< ofDefaultVertexType >::rotateRad(float,glm::vec3 const &)\n" + " ofPolyline_< ofDefaultVertexType >::rotateRad(float,glm::vec2 const &)\n"); lua_error(L);return 0; } +static int _wrap_Polyline_translate__SWIG_1(lua_State* L) { int SWIG_arg = 0; + ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; glm::vec2 *arg2 = 0 ; + SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::translate",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::translate",1,"ofPolyline_< ofDefaultVertexType > *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::translate",2,"glm::vec2 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_translate",1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec2,0))){ + SWIG_fail_ptr("Polyline_translate",2,SWIGTYPE_p_glm__vec2); } (arg1)->translate((glm::vec2 const &)*arg2); return SWIG_arg; + if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Polyline_translate(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_Polyline_translate__SWIG_0(L);} check_1: + if (argc == 2) { return _wrap_Polyline_translate__SWIG_1(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Polyline_translate'\n" " Possible C/C++ prototypes are:\n" + " ofPolyline_< ofDefaultVertexType >::translate(glm::vec3 const &)\n" + " ofPolyline_< ofDefaultVertexType >::translate(glm::vec2 const &)\n"); lua_error(L);return 0; } +static int _wrap_Polyline_scale(lua_State* L) { int SWIG_arg = 0; + ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; float arg2 ; float arg3 ; + SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::scale",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::scale",1,"ofPolyline_< ofDefaultVertexType > *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::scale",2,"float"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::scale",3,"float"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_scale",1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } arg2 = (float)lua_tonumber(L, 2); + arg3 = (float)lua_tonumber(L, 3); (arg1)->scale(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } static int _wrap_Polyline_close(lua_State* L) { int SWIG_arg = 0; ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::close",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::close",1,"ofPolyline_< ofDefaultVertexType > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_close",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } (arg1)->close(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_close",1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } (arg1)->close(); return SWIG_arg; if(0) SWIG_fail; + fail: lua_error(L); return SWIG_arg; } static int _wrap_Polyline_setClosed(lua_State* L) { int SWIG_arg = 0; ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; bool arg2 ; SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::setClosed",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::setClosed",1,"ofPolyline_< ofDefaultVertexType > *"); if(!lua_isboolean(L,2)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::setClosed",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_setClosed",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } arg2 = (lua_toboolean(L, 2)!=0); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_setClosed",1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } arg2 = (lua_toboolean(L, 2)!=0); (arg1)->setClosed(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Polyline_isClosed(lua_State* L) { int SWIG_arg = 0; ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; bool result; SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::isClosed",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::isClosed",1,"ofPolyline_< ofDefaultVertexType > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_isClosed",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_isClosed",1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } result = (bool)((ofPolyline_< ofDefaultVertexType > const *)arg1)->isClosed(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Polyline_hasChanged(lua_State* L) { int SWIG_arg = 0; ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; bool result; SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::hasChanged",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::hasChanged",1,"ofPolyline_< ofDefaultVertexType > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_hasChanged",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } - result = (bool)(arg1)->hasChanged(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_hasChanged",1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } result = (bool)(arg1)->hasChanged(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Polyline_flagHasChanged(lua_State* L) { int SWIG_arg = 0; ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::flagHasChanged",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::flagHasChanged",1,"ofPolyline_< ofDefaultVertexType > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_flagHasChanged",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } (arg1)->flagHasChanged(); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_flagHasChanged",1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } (arg1)->flagHasChanged(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Polyline_inside__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; ofPolyline_< ofDefaultVertexType > *arg3 = 0 ; bool result; @@ -32946,9 +34065,9 @@ static int _wrap_Polyline_inside__SWIG_0(lua_State* L) { int SWIG_arg = 0; float if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::inside",2,"float"); if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::inside",3,"ofPolyline_< ofDefaultVertexType > const &"); arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_inside",3,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } - result = (bool)ofPolyline_< ofDefaultVertexType >::SWIGTEMPLATEDISAMBIGUATOR inside(arg1,arg2,(ofPolyline_< ofDefaultVertexType > const &)*arg3); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_inside",3,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } + result = (bool)ofPolyline_< ofDefaultVertexType >::SWIGTEMPLATEDISAMBIGUATOR inside(arg1,arg2,(ofPolyline_< glm::vec3 > const &)*arg3); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Polyline_inside__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; float arg2 ; float arg3 ; bool result; @@ -32956,60 +34075,53 @@ static int _wrap_Polyline_inside__SWIG_1(lua_State* L) { int SWIG_arg = 0; if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::inside",1,"ofPolyline_< ofDefaultVertexType > const *"); if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::inside",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::inside",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_inside",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } arg2 = (float)lua_tonumber(L, 2); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_inside",1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); result = (bool)((ofPolyline_< ofDefaultVertexType > const *)arg1)->inside(arg2,arg3); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_inside__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofDefaultVertexType *arg1 = 0 ; +static int _wrap_Polyline_inside__SWIG_2(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; ofPolyline_< ofDefaultVertexType > *arg2 = 0 ; bool result; SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::inside",2,2) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::inside",1,"ofDefaultVertexType const &"); + if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::inside",1,"glm::vec3 const &"); if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::inside",2,"ofPolyline_< ofDefaultVertexType > const &"); if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("Polyline_inside",1,SWIGTYPE_p_glm__vec3); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_inside",2,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } - result = (bool)ofPolyline_< ofDefaultVertexType >::SWIGTEMPLATEDISAMBIGUATOR inside((glm::vec3 const &)*arg1,(ofPolyline_< ofDefaultVertexType > const &)*arg2); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_inside",2,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } + result = (bool)ofPolyline_< ofDefaultVertexType >::SWIGTEMPLATEDISAMBIGUATOR inside((glm::vec3 const &)*arg1,(ofPolyline_< glm::vec3 > const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Polyline_inside__SWIG_3(lua_State* L) { int SWIG_arg = 0; - ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; ofDefaultVertexType *arg2 = 0 ; - bool result; SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::inside",2,2) + ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; glm::vec3 *arg2 = 0 ; bool result; + SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::inside",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::inside",1,"ofPolyline_< ofDefaultVertexType > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::inside",2,"ofDefaultVertexType const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_inside",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } + if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::inside",2,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_inside",1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("Polyline_inside",2,SWIGTYPE_p_glm__vec3); } - result = (bool)((ofPolyline_< ofDefaultVertexType > const *)arg1)->inside((ofDefaultVertexType const &)*arg2); + result = (bool)((ofPolyline_< ofDefaultVertexType > const *)arg1)->inside((glm::vec3 const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Polyline_inside(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Polyline_inside__SWIG_2(L);} } } if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Polyline_inside__SWIG_3(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_Polyline_inside__SWIG_1(L);} } } } if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Polyline_inside__SWIG_0(L);} } } } + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPolyline_T_glm__vec3_t, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_Polyline_inside__SWIG_2(L);} check_1: + if (argc == 2) { return _wrap_Polyline_inside__SWIG_3(L);} if (argc == 3) { int _v = 0; { { void *ptr; + if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline_T_glm__vec3_t, 0)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; { { _v = lua_isnumber(L,argv[2]); } } if (!_v) goto check_3; + return _wrap_Polyline_inside__SWIG_1(L);} check_3: if (argc == 3) { return _wrap_Polyline_inside__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Polyline_inside'\n" " Possible C/C++ prototypes are:\n" " ofPolyline_< ofDefaultVertexType >::inside(float,float,ofPolyline_< ofDefaultVertexType > const &)\n" " ofPolyline_< ofDefaultVertexType >::inside(float,float) const\n" - " ofPolyline_< ofDefaultVertexType >::inside(ofDefaultVertexType const &,ofPolyline_< ofDefaultVertexType > const &)\n" - " ofPolyline_< ofDefaultVertexType >::inside(ofDefaultVertexType const &) const\n"); lua_error(L);return 0; } + " ofPolyline_< ofDefaultVertexType >::inside(glm::vec3 const &,ofPolyline_< ofDefaultVertexType > const &)\n" + " ofPolyline_< ofDefaultVertexType >::inside(glm::vec3 const &) const\n"); lua_error(L);return 0; } static int _wrap_Polyline_getBoundingBox(lua_State* L) { int SWIG_arg = 0; ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; ofRectangle result; SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::getBoundingBox",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::getBoundingBox",1,"ofPolyline_< ofDefaultVertexType > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_getBoundingBox",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_getBoundingBox",1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } result = ((ofPolyline_< ofDefaultVertexType > const *)arg1)->getBoundingBox(); { ofRectangle * resultptr = new ofRectangle((const ofRectangle &) result); SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofRectangle,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: @@ -33018,186 +34130,157 @@ static int _wrap_Polyline_getPerimeter(lua_State* L) { int SWIG_arg = 0; ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; float result; SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::getPerimeter",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::getPerimeter",1,"ofPolyline_< ofDefaultVertexType > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_getPerimeter",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_getPerimeter",1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } result = (float)((ofPolyline_< ofDefaultVertexType > const *)arg1)->getPerimeter(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Polyline_getArea(lua_State* L) { int SWIG_arg = 0; ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; float result; SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::getArea",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::getArea",1,"ofPolyline_< ofDefaultVertexType > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_getArea",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_getArea",1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } result = (float)((ofPolyline_< ofDefaultVertexType > const *)arg1)->getArea(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Polyline_getCentroid2D(lua_State* L) { int SWIG_arg = 0; - ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; ofDefaultVertexType result; + ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; glm::vec3 result; SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::getCentroid2D",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::getCentroid2D",1,"ofPolyline_< ofDefaultVertexType > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_getCentroid2D",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_getCentroid2D",1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } result = ((ofPolyline_< ofDefaultVertexType > const *)arg1)->getCentroid2D(); { - ofDefaultVertexType * resultptr = new ofDefaultVertexType((const ofDefaultVertexType &) result); + glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Polyline_getClosestPoint__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; ofDefaultVertexType *arg2 = 0 ; - unsigned int *arg3 = (unsigned int *) 0 ; ofDefaultVertexType result; + ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; glm::vec3 *arg2 = 0 ; + unsigned int *arg3 = (unsigned int *) 0 ; glm::vec3 result; SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::getClosestPoint",3,3) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::getClosestPoint",1,"ofPolyline_< ofDefaultVertexType > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::getClosestPoint",2,"ofDefaultVertexType const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::getClosestPoint",2,"glm::vec3 const &"); if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::getClosestPoint",3,"unsigned int *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_getClosestPoint",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_getClosestPoint",1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("Polyline_getClosestPoint",2,SWIGTYPE_p_glm__vec3); } if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_unsigned_int,0))){ SWIG_fail_ptr("Polyline_getClosestPoint",3,SWIGTYPE_p_unsigned_int); } - result = ((ofPolyline_< ofDefaultVertexType > const *)arg1)->getClosestPoint((ofDefaultVertexType const &)*arg2,arg3); { - ofDefaultVertexType * resultptr = new ofDefaultVertexType((const ofDefaultVertexType &) result); + result = ((ofPolyline_< ofDefaultVertexType > const *)arg1)->getClosestPoint((glm::vec3 const &)*arg2,arg3); { + glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Polyline_getClosestPoint__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; ofDefaultVertexType *arg2 = 0 ; - ofDefaultVertexType result; SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::getClosestPoint",2,2) + ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; glm::vec3 *arg2 = 0 ; glm::vec3 result; + SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::getClosestPoint",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::getClosestPoint",1,"ofPolyline_< ofDefaultVertexType > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::getClosestPoint",2,"ofDefaultVertexType const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_getClosestPoint",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } + if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::getClosestPoint",2,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_getClosestPoint",1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("Polyline_getClosestPoint",2,SWIGTYPE_p_glm__vec3); } - result = ((ofPolyline_< ofDefaultVertexType > const *)arg1)->getClosestPoint((ofDefaultVertexType const &)*arg2); { - ofDefaultVertexType * resultptr = new ofDefaultVertexType((const ofDefaultVertexType &) result); + result = ((ofPolyline_< ofDefaultVertexType > const *)arg1)->getClosestPoint((glm::vec3 const &)*arg2); { + glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Polyline_getClosestPoint(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Polyline_getClosestPoint__SWIG_1(L);} } } if (argc == 3) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_unsigned_int, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Polyline_getClosestPoint__SWIG_0(L);} } } } + if (argc == 2) { return _wrap_Polyline_getClosestPoint__SWIG_1(L);} if (argc == 3) { + return _wrap_Polyline_getClosestPoint__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Polyline_getClosestPoint'\n" " Possible C/C++ prototypes are:\n" - " ofPolyline_< ofDefaultVertexType >::getClosestPoint(ofDefaultVertexType const &,unsigned int *) const\n" - " ofPolyline_< ofDefaultVertexType >::getClosestPoint(ofDefaultVertexType const &) const\n"); lua_error(L);return 0; } + " ofPolyline_< ofDefaultVertexType >::getClosestPoint(glm::vec3 const &,unsigned int *) const\n" + " ofPolyline_< ofDefaultVertexType >::getClosestPoint(glm::vec3 const &) const\n"); lua_error(L);return 0; } static int _wrap_Polyline_getIndexAtLength(lua_State* L) { int SWIG_arg = 0; ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; float arg2 ; float result; SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::getIndexAtLength",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::getIndexAtLength",1,"ofPolyline_< ofDefaultVertexType > const *"); if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::getIndexAtLength",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_getIndexAtLength",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } - arg2 = (float)lua_tonumber(L, 2); result = (float)((ofPolyline_< ofDefaultVertexType > const *)arg1)->getIndexAtLength(arg2); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_getIndexAtLength",1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } arg2 = (float)lua_tonumber(L, 2); + result = (float)((ofPolyline_< ofDefaultVertexType > const *)arg1)->getIndexAtLength(arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Polyline_getIndexAtPercent(lua_State* L) { int SWIG_arg = 0; ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; float arg2 ; float result; SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::getIndexAtPercent",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::getIndexAtPercent",1,"ofPolyline_< ofDefaultVertexType > const *"); if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::getIndexAtPercent",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_getIndexAtPercent",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } - arg2 = (float)lua_tonumber(L, 2); result = (float)((ofPolyline_< ofDefaultVertexType > const *)arg1)->getIndexAtPercent(arg2); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_getIndexAtPercent",1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } arg2 = (float)lua_tonumber(L, 2); + result = (float)((ofPolyline_< ofDefaultVertexType > const *)arg1)->getIndexAtPercent(arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Polyline_getLengthAtIndex(lua_State* L) { int SWIG_arg = 0; ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; int arg2 ; float result; SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::getLengthAtIndex",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::getLengthAtIndex",1,"ofPolyline_< ofDefaultVertexType > const *"); if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::getLengthAtIndex",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_getLengthAtIndex",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } - arg2 = (int)lua_tonumber(L, 2); result = (float)((ofPolyline_< ofDefaultVertexType > const *)arg1)->getLengthAtIndex(arg2); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_getLengthAtIndex",1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } arg2 = (int)lua_tonumber(L, 2); + result = (float)((ofPolyline_< ofDefaultVertexType > const *)arg1)->getLengthAtIndex(arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Polyline_getLengthAtIndexInterpolated(lua_State* L) { int SWIG_arg = 0; ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; float arg2 ; float result; SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::getLengthAtIndexInterpolated",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::getLengthAtIndexInterpolated",1,"ofPolyline_< ofDefaultVertexType > const *"); if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::getLengthAtIndexInterpolated",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_getLengthAtIndexInterpolated",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_getLengthAtIndexInterpolated",1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } arg2 = (float)lua_tonumber(L, 2); result = (float)((ofPolyline_< ofDefaultVertexType > const *)arg1)->getLengthAtIndexInterpolated(arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Polyline_getPointAtLength(lua_State* L) { int SWIG_arg = 0; - ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; float arg2 ; ofDefaultVertexType result; + ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; float arg2 ; glm::vec3 result; SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::getPointAtLength",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::getPointAtLength",1,"ofPolyline_< ofDefaultVertexType > const *"); if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::getPointAtLength",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_getPointAtLength",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } - arg2 = (float)lua_tonumber(L, 2); result = ((ofPolyline_< ofDefaultVertexType > const *)arg1)->getPointAtLength(arg2); { - ofDefaultVertexType * resultptr = new ofDefaultVertexType((const ofDefaultVertexType &) result); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_getPointAtLength",1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } arg2 = (float)lua_tonumber(L, 2); + result = ((ofPolyline_< ofDefaultVertexType > const *)arg1)->getPointAtLength(arg2); { + glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Polyline_getPointAtPercent(lua_State* L) { int SWIG_arg = 0; - ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; float arg2 ; ofDefaultVertexType result; + ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; float arg2 ; glm::vec3 result; SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::getPointAtPercent",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::getPointAtPercent",1,"ofPolyline_< ofDefaultVertexType > const *"); if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::getPointAtPercent",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_getPointAtPercent",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } - arg2 = (float)lua_tonumber(L, 2); result = ((ofPolyline_< ofDefaultVertexType > const *)arg1)->getPointAtPercent(arg2); { - ofDefaultVertexType * resultptr = new ofDefaultVertexType((const ofDefaultVertexType &) result); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_getPointAtPercent",1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } arg2 = (float)lua_tonumber(L, 2); + result = ((ofPolyline_< ofDefaultVertexType > const *)arg1)->getPointAtPercent(arg2); { + glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Polyline_getPointAtIndexInterpolated(lua_State* L) { int SWIG_arg = 0; - ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; float arg2 ; ofDefaultVertexType result; + ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; float arg2 ; glm::vec3 result; SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::getPointAtIndexInterpolated",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::getPointAtIndexInterpolated",1,"ofPolyline_< ofDefaultVertexType > const *"); if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::getPointAtIndexInterpolated",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_getPointAtIndexInterpolated",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_getPointAtIndexInterpolated",1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } arg2 = (float)lua_tonumber(L, 2); result = ((ofPolyline_< ofDefaultVertexType > const *)arg1)->getPointAtIndexInterpolated(arg2); { - ofDefaultVertexType * resultptr = new ofDefaultVertexType((const ofDefaultVertexType &) result); + glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_getAngleAtIndex(lua_State* L) { int SWIG_arg = 0; - ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; int arg2 ; float result; - SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::getAngleAtIndex",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::getAngleAtIndex",1,"ofPolyline_< ofDefaultVertexType > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::getAngleAtIndex",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_getAngleAtIndex",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } - arg2 = (int)lua_tonumber(L, 2); result = (float)((ofPolyline_< ofDefaultVertexType > const *)arg1)->getAngleAtIndex(arg2); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_getAngleAtIndexInterpolated(lua_State* L) { int SWIG_arg = 0; - ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; float arg2 ; float result; - SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::getAngleAtIndexInterpolated",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::getAngleAtIndexInterpolated",1,"ofPolyline_< ofDefaultVertexType > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::getAngleAtIndexInterpolated",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_getAngleAtIndexInterpolated",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } - arg2 = (float)lua_tonumber(L, 2); - result = (float)((ofPolyline_< ofDefaultVertexType > const *)arg1)->getAngleAtIndexInterpolated(arg2); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Polyline_getRotationAtIndex(lua_State* L) { int SWIG_arg = 0; - ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; int arg2 ; ofDefaultVertexType result; + ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; int arg2 ; glm::vec3 result; SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::getRotationAtIndex",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::getRotationAtIndex",1,"ofPolyline_< ofDefaultVertexType > const *"); if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::getRotationAtIndex",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_getRotationAtIndex",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } - arg2 = (int)lua_tonumber(L, 2); result = ((ofPolyline_< ofDefaultVertexType > const *)arg1)->getRotationAtIndex(arg2); { - ofDefaultVertexType * resultptr = new ofDefaultVertexType((const ofDefaultVertexType &) result); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_getRotationAtIndex",1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } arg2 = (int)lua_tonumber(L, 2); + result = ((ofPolyline_< ofDefaultVertexType > const *)arg1)->getRotationAtIndex(arg2); { + glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Polyline_getRotationAtIndexInterpolated(lua_State* L) { int SWIG_arg = 0; - ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; float arg2 ; ofDefaultVertexType result; + ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; float arg2 ; glm::vec3 result; SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::getRotationAtIndexInterpolated",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::getRotationAtIndexInterpolated",1,"ofPolyline_< ofDefaultVertexType > const *"); if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::getRotationAtIndexInterpolated",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_getRotationAtIndexInterpolated",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_getRotationAtIndexInterpolated",1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } arg2 = (float)lua_tonumber(L, 2); result = ((ofPolyline_< ofDefaultVertexType > const *)arg1)->getRotationAtIndexInterpolated(arg2); { - ofDefaultVertexType * resultptr = new ofDefaultVertexType((const ofDefaultVertexType &) result); + glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Polyline_getDegreesAtIndex(lua_State* L) { int SWIG_arg = 0; @@ -33205,17 +34288,17 @@ static int _wrap_Polyline_getDegreesAtIndex(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::getDegreesAtIndex",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::getDegreesAtIndex",1,"ofPolyline_< ofDefaultVertexType > const *"); if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::getDegreesAtIndex",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_getDegreesAtIndex",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } - arg2 = (int)lua_tonumber(L, 2); result = (float)((ofPolyline_< ofDefaultVertexType > const *)arg1)->getDegreesAtIndex(arg2); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_getDegreesAtIndex",1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } arg2 = (int)lua_tonumber(L, 2); + result = (float)((ofPolyline_< ofDefaultVertexType > const *)arg1)->getDegreesAtIndex(arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Polyline_getDegreesAtIndexInterpolated(lua_State* L) { int SWIG_arg = 0; ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; float arg2 ; float result; SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::getDegreesAtIndexInterpolated",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::getDegreesAtIndexInterpolated",1,"ofPolyline_< ofDefaultVertexType > const *"); if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::getDegreesAtIndexInterpolated",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_getDegreesAtIndexInterpolated",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_getDegreesAtIndexInterpolated",1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } arg2 = (float)lua_tonumber(L, 2); result = (float)((ofPolyline_< ofDefaultVertexType > const *)arg1)->getDegreesAtIndexInterpolated(arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } @@ -33224,64 +34307,64 @@ static int _wrap_Polyline_getRadiansAtIndex(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::getRadiansAtIndex",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::getRadiansAtIndex",1,"ofPolyline_< ofDefaultVertexType > const *"); if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::getRadiansAtIndex",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_getRadiansAtIndex",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } - arg2 = (int)lua_tonumber(L, 2); result = (float)((ofPolyline_< ofDefaultVertexType > const *)arg1)->getRadiansAtIndex(arg2); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_getRadiansAtIndex",1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } arg2 = (int)lua_tonumber(L, 2); + result = (float)((ofPolyline_< ofDefaultVertexType > const *)arg1)->getRadiansAtIndex(arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Polyline_getRadiansAtIndexInterpolated(lua_State* L) { int SWIG_arg = 0; ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; float arg2 ; float result; SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::getRadiansAtIndexInterpolated",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::getRadiansAtIndexInterpolated",1,"ofPolyline_< ofDefaultVertexType > const *"); if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::getRadiansAtIndexInterpolated",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_getRadiansAtIndexInterpolated",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_getRadiansAtIndexInterpolated",1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } arg2 = (float)lua_tonumber(L, 2); result = (float)((ofPolyline_< ofDefaultVertexType > const *)arg1)->getRadiansAtIndexInterpolated(arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Polyline_getTangentAtIndex(lua_State* L) { int SWIG_arg = 0; - ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; int arg2 ; ofDefaultVertexType result; + ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; int arg2 ; glm::vec3 result; SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::getTangentAtIndex",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::getTangentAtIndex",1,"ofPolyline_< ofDefaultVertexType > const *"); if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::getTangentAtIndex",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_getTangentAtIndex",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } - arg2 = (int)lua_tonumber(L, 2); result = ((ofPolyline_< ofDefaultVertexType > const *)arg1)->getTangentAtIndex(arg2); { - ofDefaultVertexType * resultptr = new ofDefaultVertexType((const ofDefaultVertexType &) result); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_getTangentAtIndex",1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } arg2 = (int)lua_tonumber(L, 2); + result = ((ofPolyline_< ofDefaultVertexType > const *)arg1)->getTangentAtIndex(arg2); { + glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Polyline_getTangentAtIndexInterpolated(lua_State* L) { int SWIG_arg = 0; - ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; float arg2 ; ofDefaultVertexType result; + ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; float arg2 ; glm::vec3 result; SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::getTangentAtIndexInterpolated",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::getTangentAtIndexInterpolated",1,"ofPolyline_< ofDefaultVertexType > const *"); if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::getTangentAtIndexInterpolated",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_getTangentAtIndexInterpolated",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_getTangentAtIndexInterpolated",1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } arg2 = (float)lua_tonumber(L, 2); result = ((ofPolyline_< ofDefaultVertexType > const *)arg1)->getTangentAtIndexInterpolated(arg2); { - ofDefaultVertexType * resultptr = new ofDefaultVertexType((const ofDefaultVertexType &) result); + glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Polyline_getNormalAtIndex(lua_State* L) { int SWIG_arg = 0; - ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; int arg2 ; ofDefaultVertexType result; + ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; int arg2 ; glm::vec3 result; SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::getNormalAtIndex",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::getNormalAtIndex",1,"ofPolyline_< ofDefaultVertexType > const *"); if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::getNormalAtIndex",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_getNormalAtIndex",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } - arg2 = (int)lua_tonumber(L, 2); result = ((ofPolyline_< ofDefaultVertexType > const *)arg1)->getNormalAtIndex(arg2); { - ofDefaultVertexType * resultptr = new ofDefaultVertexType((const ofDefaultVertexType &) result); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_getNormalAtIndex",1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } arg2 = (int)lua_tonumber(L, 2); + result = ((ofPolyline_< ofDefaultVertexType > const *)arg1)->getNormalAtIndex(arg2); { + glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Polyline_getNormalAtIndexInterpolated(lua_State* L) { int SWIG_arg = 0; - ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; float arg2 ; ofDefaultVertexType result; + ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; float arg2 ; glm::vec3 result; SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::getNormalAtIndexInterpolated",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::getNormalAtIndexInterpolated",1,"ofPolyline_< ofDefaultVertexType > const *"); if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::getNormalAtIndexInterpolated",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_getNormalAtIndexInterpolated",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_getNormalAtIndexInterpolated",1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } arg2 = (float)lua_tonumber(L, 2); result = ((ofPolyline_< ofDefaultVertexType > const *)arg1)->getNormalAtIndexInterpolated(arg2); { - ofDefaultVertexType * resultptr = new ofDefaultVertexType((const ofDefaultVertexType &) result); + glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Polyline_getWrappedIndex(lua_State* L) { int SWIG_arg = 0; @@ -33289,17 +34372,17 @@ static int _wrap_Polyline_getWrappedIndex(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::getWrappedIndex",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::getWrappedIndex",1,"ofPolyline_< ofDefaultVertexType > const *"); if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::getWrappedIndex",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_getWrappedIndex",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } - arg2 = (int)lua_tonumber(L, 2); result = (int)((ofPolyline_< ofDefaultVertexType > const *)arg1)->getWrappedIndex(arg2); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_getWrappedIndex",1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } arg2 = (int)lua_tonumber(L, 2); + result = (int)((ofPolyline_< ofDefaultVertexType > const *)arg1)->getWrappedIndex(arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Polyline_setRightVector__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; ofDefaultVertexType arg2 ; - ofDefaultVertexType *argp2 ; SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::setRightVector",2,2) + ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; glm::vec3 arg2 ; glm::vec3 *argp2 ; + SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::setRightVector",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::setRightVector",1,"ofPolyline_< ofDefaultVertexType > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::setRightVector",2,"ofDefaultVertexType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_setRightVector",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } + if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::setRightVector",2,"glm::vec3"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_setRightVector",1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("Polyline_setRightVector",2,SWIGTYPE_p_glm__vec3); } arg2 = *argp2; (arg1)->setRightVector(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } @@ -33307,37 +34390,30 @@ static int _wrap_Polyline_setRightVector__SWIG_1(lua_State* L) { int SWIG_arg = ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::setRightVector",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::setRightVector",1,"ofPolyline_< ofDefaultVertexType > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_setRightVector",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } (arg1)->setRightVector(); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_setRightVector",1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } (arg1)->setRightVector(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Polyline_setRightVector(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Polyline_setRightVector__SWIG_1(L);} } if (argc == 2) { int _v; - { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Polyline_setRightVector__SWIG_0(L);} } } + return _wrap_Polyline_setRightVector__SWIG_1(L);} if (argc == 2) { return _wrap_Polyline_setRightVector__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Polyline_setRightVector'\n" - " Possible C/C++ prototypes are:\n" " ofPolyline_< ofDefaultVertexType >::setRightVector(ofDefaultVertexType)\n" + " Possible C/C++ prototypes are:\n" " ofPolyline_< ofDefaultVertexType >::setRightVector(glm::vec3)\n" " ofPolyline_< ofDefaultVertexType >::setRightVector()\n"); lua_error(L);return 0; } static int _wrap_Polyline_getRightVector(lua_State* L) { int SWIG_arg = 0; - ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; ofDefaultVertexType result; + ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; glm::vec3 result; SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::getRightVector",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::getRightVector",1,"ofPolyline_< ofDefaultVertexType > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_getRightVector",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_getRightVector",1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } result = ((ofPolyline_< ofDefaultVertexType > const *)arg1)->getRightVector(); { - ofDefaultVertexType * resultptr = new ofDefaultVertexType((const ofDefaultVertexType &) result); + glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Polyline_draw(lua_State* L) { int SWIG_arg = 0; ofPolyline_< ofDefaultVertexType > *arg1 = (ofPolyline_< ofDefaultVertexType > *) 0 ; SWIG_check_num_args("ofPolyline_< ofDefaultVertexType >::draw",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline_< ofDefaultVertexType >::draw",1,"ofPolyline_< ofDefaultVertexType > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,0))){ - SWIG_fail_ptr("Polyline_draw",1,SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t,0))){ + SWIG_fail_ptr("Polyline_draw",1,SWIGTYPE_p_ofPolyline_T_glm__vec3_t); } ((ofPolyline_< ofDefaultVertexType > const *)arg1)->draw(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static void swig_delete_Polyline(void *obj) { @@ -33360,13 +34436,10 @@ static swig_lua_method swig_Polyline_methods[]= { { "addVertex", _wrap_Polyline_addVertex}, { "addVertices", _wrap_Polyline_addVertices}, { "insertVertex", _wrap_Polyline_insertVertex}, + { "removeVertex", _wrap_Polyline_removeVertex}, { "resize", _wrap_Polyline_resize}, { "size", _wrap_Polyline_size}, { "getVertices", _wrap_Polyline_getVertices}, - { "begin", _wrap_Polyline_begin}, - { "rbegin", _wrap_Polyline_rbegin}, - { "c_end", _wrap_Polyline_c_end}, - { "rend", _wrap_Polyline_rend}, { "lineTo", _wrap_Polyline_lineTo}, { "arc", _wrap_Polyline_arc}, { "arcNegative", _wrap_Polyline_arcNegative}, @@ -33377,6 +34450,10 @@ static swig_lua_method swig_Polyline_methods[]= { { "getResampledBySpacing", _wrap_Polyline_getResampledBySpacing}, { "getResampledByCount", _wrap_Polyline_getResampledByCount}, { "simplify", _wrap_Polyline_simplify}, + { "rotateDeg", _wrap_Polyline_rotateDeg}, + { "rotateRad", _wrap_Polyline_rotateRad}, + { "translate", _wrap_Polyline_translate}, + { "scale", _wrap_Polyline_scale}, { "close", _wrap_Polyline_close}, { "setClosed", _wrap_Polyline_setClosed}, { "isClosed", _wrap_Polyline_isClosed}, @@ -33395,8 +34472,6 @@ static swig_lua_method swig_Polyline_methods[]= { { "getPointAtLength", _wrap_Polyline_getPointAtLength}, { "getPointAtPercent", _wrap_Polyline_getPointAtPercent}, { "getPointAtIndexInterpolated", _wrap_Polyline_getPointAtIndexInterpolated}, - { "getAngleAtIndex", _wrap_Polyline_getAngleAtIndex}, - { "getAngleAtIndexInterpolated", _wrap_Polyline_getAngleAtIndexInterpolated}, { "getRotationAtIndex", _wrap_Polyline_getRotationAtIndex}, { "getRotationAtIndexInterpolated", _wrap_Polyline_getRotationAtIndexInterpolated}, { "getDegreesAtIndex", _wrap_Polyline_getDegreesAtIndex}, @@ -33441,48 +34516,54 @@ static swig_lua_namespace swig_Polyline_Sf_SwigStatic = { }; static swig_lua_class *swig_Polyline_bases[] = {0}; static const char *swig_Polyline_base_names[] = {0}; -static swig_lua_class _wrap_class_Polyline = { "Polyline", "Polyline", &SWIGTYPE_p_ofPolyline_T_ofDefaultVertexType_t,_proxy__wrap_new_Polyline, swig_delete_Polyline, swig_Polyline_methods, swig_Polyline_attributes, &swig_Polyline_Sf_SwigStatic, swig_Polyline_meta, swig_Polyline_bases, swig_Polyline_base_names }; +static swig_lua_class _wrap_class_Polyline = { "Polyline", "Polyline", &SWIGTYPE_p_ofPolyline_T_glm__vec3_t,_proxy__wrap_new_Polyline, swig_delete_Polyline, swig_Polyline_methods, swig_Polyline_attributes, &swig_Polyline_Sf_SwigStatic, swig_Polyline_meta, swig_Polyline_bases, swig_Polyline_base_names }; -static int _wrap_drawBitmapString__SWIG_0(lua_State* L) { int SWIG_arg = 0; string *arg1 = 0 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofDrawBitmapString",3,3) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofDrawBitmapString",1,"string const &"); +static int _wrap_drawBitmapString__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; float arg2 ; float arg3 ; + std::string temp1 ; SWIG_check_num_args("ofDrawBitmapString",3,3) + if(!lua_isstring(L,1)) SWIG_fail_arg("ofDrawBitmapString",1,"std::string const &"); if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawBitmapString",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawBitmapString",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_string,0))){ - SWIG_fail_ptr("drawBitmapString",1,SWIGTYPE_p_string); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); ofDrawBitmapString((string const &)*arg1,arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_drawBitmapString__SWIG_1(lua_State* L) { int SWIG_arg = 0; string *arg1 = 0 ; ofPoint *arg2 = 0 ; - SWIG_check_num_args("ofDrawBitmapString",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofDrawBitmapString",1,"string const &"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofDrawBitmapString",2,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_string,0))){ - SWIG_fail_ptr("drawBitmapString",1,SWIGTYPE_p_string); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("drawBitmapString",2,SWIGTYPE_p_ofVec3f); } ofDrawBitmapString((string const &)*arg1,(ofVec3f const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawBitmapString__SWIG_2(lua_State* L) { int SWIG_arg = 0; string *arg1 = 0 ; float arg2 ; float arg3 ; - float arg4 ; SWIG_check_num_args("ofDrawBitmapString",4,4) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofDrawBitmapString",1,"string const &"); + temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; arg2 = (float)lua_tonumber(L, 2); + arg3 = (float)lua_tonumber(L, 3); ofDrawBitmapString((std::string const &)*arg1,arg2,arg3); return SWIG_arg; if(0) SWIG_fail; + fail: lua_error(L); return SWIG_arg; } +static int _wrap_drawBitmapString__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; glm::vec3 *arg2 = 0 ; + std::string temp1 ; SWIG_check_num_args("ofDrawBitmapString",2,2) + if(!lua_isstring(L,1)) SWIG_fail_arg("ofDrawBitmapString",1,"std::string const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofDrawBitmapString",2,"glm::vec3 const &"); + temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ + SWIG_fail_ptr("drawBitmapString",2,SWIGTYPE_p_glm__vec3); } + ofDrawBitmapString((std::string const &)*arg1,(glm::vec3 const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_drawBitmapString__SWIG_2(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; glm::vec2 *arg2 = 0 ; + std::string temp1 ; SWIG_check_num_args("ofDrawBitmapString",2,2) + if(!lua_isstring(L,1)) SWIG_fail_arg("ofDrawBitmapString",1,"std::string const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofDrawBitmapString",2,"glm::vec2 const &"); + temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec2,0))){ + SWIG_fail_ptr("drawBitmapString",2,SWIGTYPE_p_glm__vec2); } + ofDrawBitmapString((std::string const &)*arg1,(glm::vec2 const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_drawBitmapString__SWIG_3(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; float arg2 ; float arg3 ; + float arg4 ; std::string temp1 ; SWIG_check_num_args("ofDrawBitmapString",4,4) + if(!lua_isstring(L,1)) SWIG_fail_arg("ofDrawBitmapString",1,"std::string const &"); if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawBitmapString",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawBitmapString",3,"float"); if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawBitmapString",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_string,0))){ - SWIG_fail_ptr("drawBitmapString",1,SWIGTYPE_p_string); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); ofDrawBitmapString((string const &)*arg1,arg2,arg3,arg4); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } + temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; arg2 = (float)lua_tonumber(L, 2); + arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); + ofDrawBitmapString((std::string const &)*arg1,arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } static int _wrap_drawBitmapString(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_string, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_drawBitmapString__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_string, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_drawBitmapString__SWIG_0(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_string, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_drawBitmapString__SWIG_2(L);} } } } } + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_drawBitmapString__SWIG_1(L);} check_1: + if (argc == 2) { return _wrap_drawBitmapString__SWIG_2(L);} if (argc == 3) { return _wrap_drawBitmapString__SWIG_0(L);} + if (argc == 4) { return _wrap_drawBitmapString__SWIG_3(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'drawBitmapString'\n" " Possible C/C++ prototypes are:\n" - " ofDrawBitmapString(string const &,float,float)\n" " ofDrawBitmapString(string const &,ofPoint const &)\n" - " ofDrawBitmapString(string const &,float,float,float)\n"); lua_error(L);return 0; } + " ofDrawBitmapString(std::string const &,float,float)\n" " ofDrawBitmapString(std::string const &,glm::vec3 const &)\n" + " ofDrawBitmapString(std::string const &,glm::vec2 const &)\n" + " ofDrawBitmapString(std::string const &,float,float,float)\n"); lua_error(L);return 0; } static int _wrap_setColor__SWIG_0(lua_State* L) { int SWIG_arg = 0; int arg1 ; int arg2 ; int arg3 ; SWIG_check_num_args("ofSetColor",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetColor",1,"int"); if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSetColor",2,"int"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofSetColor",3,"int"); @@ -33509,17 +34590,12 @@ static int _wrap_setColor__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofColor *arg static int _wrap_setColor__SWIG_4(lua_State* L) { int SWIG_arg = 0; int arg1 ; SWIG_check_num_args("ofSetColor",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetColor",1,"int"); arg1 = (int)lua_tonumber(L, 1); ofSetColor(arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setColor(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_setColor__SWIG_2(L);} } if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_setColor__SWIG_4(L);} } if (argc == 2) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_setColor__SWIG_3(L);} - } } if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_setColor__SWIG_0(L);} } } } if (argc == 4) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_setColor__SWIG_1(L);} } } } } +static int _wrap_setColor(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 1) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_setColor__SWIG_2(L);} check_1: if (argc == 1) { + return _wrap_setColor__SWIG_4(L);} if (argc == 2) { return _wrap_setColor__SWIG_3(L);} if (argc == 3) { + return _wrap_setColor__SWIG_0(L);} if (argc == 4) { return _wrap_setColor__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'setColor'\n" " Possible C/C++ prototypes are:\n" " ofSetColor(int,int,int)\n" " ofSetColor(int,int,int,int)\n" " ofSetColor(ofColor const &)\n" " ofSetColor(ofColor const &,int)\n" " ofSetColor(int)\n"); lua_error(L);return 0; } @@ -33562,17 +34638,12 @@ static int _wrap_background__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofColor *a SWIG_fail_ptr("background",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } ofBackground((ofColor_< unsigned char > const &)*arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_background(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 1) { int _v; - { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_background__SWIG_4(L);} } if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_background__SWIG_3(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_background__SWIG_2(L);} } } if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_background__SWIG_1(L);} } } } if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_background__SWIG_0(L);} } } } } +static int _wrap_background(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 1) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_background__SWIG_4(L);} check_1: + if (argc == 1) { return _wrap_background__SWIG_3(L);} if (argc == 2) { return _wrap_background__SWIG_2(L);} if (argc == 3) { + return _wrap_background__SWIG_1(L);} if (argc == 4) { return _wrap_background__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'background'\n" " Possible C/C++ prototypes are:\n" " ofBackground(int,int,int,int)\n" " ofBackground(int,int,int)\n" " ofBackground(int,int)\n" " ofBackground(int)\n" " ofBackground(ofColor const &)\n"); lua_error(L);return 0; } @@ -33584,10 +34655,8 @@ static int _wrap_backgroundHex__SWIG_0(lua_State* L) { int SWIG_arg = 0; int arg static int _wrap_backgroundHex__SWIG_1(lua_State* L) { int SWIG_arg = 0; int arg1 ; SWIG_check_num_args("ofBackgroundHex",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofBackgroundHex",1,"int"); arg1 = (int)lua_tonumber(L, 1); ofBackgroundHex(arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_backgroundHex(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_backgroundHex__SWIG_1(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_backgroundHex__SWIG_0(L);} } } +static int _wrap_backgroundHex(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { + return _wrap_backgroundHex__SWIG_1(L);} if (argc == 2) { return _wrap_backgroundHex__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'backgroundHex'\n" " Possible C/C++ prototypes are:\n" " ofBackgroundHex(int,int)\n" " ofBackgroundHex(int)\n"); lua_error(L);return 0; } static int _wrap_backgroundGradient__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofColor *arg1 = 0 ; ofColor *arg2 = 0 ; @@ -33613,17 +34682,7 @@ static int _wrap_backgroundGradient__SWIG_1(lua_State* L) { int SWIG_arg = 0; of ofBackgroundGradient((ofColor_< unsigned char > const &)*arg1,(ofColor_< unsigned char > const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_backgroundGradient(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_backgroundGradient__SWIG_1(L);} } } if (argc == 3) { int _v; - { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_backgroundGradient__SWIG_0(L);} } } } + return _wrap_backgroundGradient__SWIG_1(L);} if (argc == 3) { return _wrap_backgroundGradient__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'backgroundGradient'\n" " Possible C/C++ prototypes are:\n" " ofBackgroundGradient(ofColor const &,ofColor const &,ofGradientMode)\n" " ofBackgroundGradient(ofColor const &,ofColor const &)\n"); lua_error(L);return 0; } @@ -33657,16 +34716,11 @@ static int _wrap_setBackgroundColor__SWIG_4(lua_State* L) { int SWIG_arg = 0; of ofSetBackgroundColor((ofColor_< unsigned char > const &)*arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_setBackgroundColor(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_setBackgroundColor__SWIG_4(L);} } if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_setBackgroundColor__SWIG_3(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_setBackgroundColor__SWIG_2(L);} } } if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_setBackgroundColor__SWIG_1(L);} } } } if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_setBackgroundColor__SWIG_0(L);} } } } } + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_setBackgroundColor__SWIG_4(L);} check_1: + if (argc == 1) { return _wrap_setBackgroundColor__SWIG_3(L);} if (argc == 2) { return _wrap_setBackgroundColor__SWIG_2(L);} + if (argc == 3) { return _wrap_setBackgroundColor__SWIG_1(L);} if (argc == 4) { return _wrap_setBackgroundColor__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'setBackgroundColor'\n" " Possible C/C++ prototypes are:\n" " ofSetBackgroundColor(int,int,int,int)\n" " ofSetBackgroundColor(int,int,int)\n" " ofSetBackgroundColor(int,int)\n" " ofSetBackgroundColor(int)\n" " ofSetBackgroundColor(ofColor const &)\n"); lua_error(L);return 0; } @@ -33680,9 +34734,7 @@ static int _wrap_setBackgroundColorHex__SWIG_1(lua_State* L) { int SWIG_arg = 0; arg1 = (int)lua_tonumber(L, 1); ofSetBackgroundColorHex(arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_setBackgroundColorHex(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_setBackgroundColorHex__SWIG_1(L);} } if (argc == 2) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_setBackgroundColorHex__SWIG_0(L);} } } + return _wrap_setBackgroundColorHex__SWIG_1(L);} if (argc == 2) { return _wrap_setBackgroundColorHex__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'setBackgroundColorHex'\n" " Possible C/C++ prototypes are:\n" " ofSetBackgroundColorHex(int,int)\n" " ofSetBackgroundColorHex(int)\n"); lua_error(L);return 0; } @@ -33715,16 +34767,12 @@ static int _wrap_clear__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofColor *arg1 = if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ SWIG_fail_ptr("clear",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } ofClear((ofColor_< unsigned char > const &)*arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_clear(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_clear__SWIG_4(L);} } if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_clear__SWIG_3(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_clear__SWIG_2(L);} } - } if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_clear__SWIG_1(L);} } } } if (argc == 4) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_clear__SWIG_0(L);} } } } } +static int _wrap_clear(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 1) { int _v = 0; { + { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_clear__SWIG_4(L);} check_1: if (argc == 1) { + return _wrap_clear__SWIG_3(L);} if (argc == 2) { return _wrap_clear__SWIG_2(L);} if (argc == 3) { + return _wrap_clear__SWIG_1(L);} if (argc == 4) { return _wrap_clear__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'clear'\n" " Possible C/C++ prototypes are:\n" " ofClear(float,float,float,float)\n" " ofClear(float,float,float)\n" " ofClear(float,float)\n" " ofClear(float)\n" " ofClear(ofColor const &)\n"); lua_error(L);return 0; } @@ -33784,28 +34832,16 @@ static int _wrap_drawTriangle__SWIG_3(lua_State* L) { int SWIG_arg = 0; glm::vec ofDrawTriangle((glm::vec2 const &)*arg1,(glm::vec2 const &)*arg2,(glm::vec2 const &)*arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_drawTriangle(lua_State* L) { int argc; int argv[10]={ 1,2,3,4,5,6,7,8,9,10} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_drawTriangle__SWIG_2(L);} } } } if (argc == 3) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_glm__vec2, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_drawTriangle__SWIG_3(L);} } } } if (argc == 6) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { return _wrap_drawTriangle__SWIG_0(L);} } } } } } } - if (argc == 9) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { { - _v = lua_isnumber(L,argv[6]); } if (_v) { { _v = lua_isnumber(L,argv[7]); } if (_v) { { - _v = lua_isnumber(L,argv[8]); } if (_v) { return _wrap_drawTriangle__SWIG_1(L);} } } } } } } } } - } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'drawTriangle'\n" " Possible C/C++ prototypes are:\n" + if (argc == 3) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; { { void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_drawTriangle__SWIG_2(L);} check_1: + if (argc == 3) { return _wrap_drawTriangle__SWIG_3(L);} if (argc == 6) { return _wrap_drawTriangle__SWIG_0(L);} + if (argc == 9) { return _wrap_drawTriangle__SWIG_1(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'drawTriangle'\n" " Possible C/C++ prototypes are:\n" " ofDrawTriangle(float,float,float,float,float,float)\n" " ofDrawTriangle(float,float,float,float,float,float,float,float,float)\n" " ofDrawTriangle(glm::vec3 const &,glm::vec3 const &,glm::vec3 const &)\n" @@ -33835,18 +34871,13 @@ static int _wrap_drawCircle__SWIG_3(lua_State* L) { int SWIG_arg = 0; glm::vec2 if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("drawCircle",1,SWIGTYPE_p_glm__vec2); } arg2 = (float)lua_tonumber(L, 2); ofDrawCircle((glm::vec2 const &)*arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawCircle(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { int _v; - { void *ptr; if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_drawCircle__SWIG_2(L);} } } if (argc == 2) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_drawCircle__SWIG_3(L);} } } - if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_drawCircle__SWIG_0(L);} } } } if (argc == 4) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_drawCircle__SWIG_1(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'drawCircle'\n" " Possible C/C++ prototypes are:\n" - " ofDrawCircle(float,float,float)\n" " ofDrawCircle(float,float,float,float)\n" +static int _wrap_drawCircle(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_drawCircle__SWIG_2(L);} check_1: + if (argc == 2) { return _wrap_drawCircle__SWIG_3(L);} if (argc == 3) { return _wrap_drawCircle__SWIG_0(L);} if (argc == 4) { + return _wrap_drawCircle__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'drawCircle'\n" + " Possible C/C++ prototypes are:\n" " ofDrawCircle(float,float,float)\n" " ofDrawCircle(float,float,float,float)\n" " ofDrawCircle(glm::vec3 const &,float)\n" " ofDrawCircle(glm::vec2 const &,float)\n"); lua_error(L);return 0; } static int _wrap_drawEllipse__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; SWIG_check_num_args("ofDrawEllipse",4,4) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawEllipse",1,"float"); @@ -33879,18 +34910,11 @@ static int _wrap_drawEllipse__SWIG_3(lua_State* L) { int SWIG_arg = 0; glm::vec2 SWIG_fail_ptr("drawEllipse",1,SWIGTYPE_p_glm__vec2); } arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); ofDrawEllipse((glm::vec2 const &)*arg1,arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_drawEllipse(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_drawEllipse__SWIG_2(L);} } } } if (argc == 3) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_drawEllipse__SWIG_3(L);} } } } if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { - { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_drawEllipse__SWIG_0(L);} } } } } if (argc == 5) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_drawEllipse__SWIG_1(L);} } } } } } + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_drawEllipse__SWIG_2(L);} check_1: + if (argc == 3) { return _wrap_drawEllipse__SWIG_3(L);} if (argc == 4) { return _wrap_drawEllipse__SWIG_0(L);} + if (argc == 5) { return _wrap_drawEllipse__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'drawEllipse'\n" " Possible C/C++ prototypes are:\n" " ofDrawEllipse(float,float,float,float)\n" " ofDrawEllipse(float,float,float,float,float)\n" " ofDrawEllipse(glm::vec3 const &,float,float)\n" " ofDrawEllipse(glm::vec2 const &,float,float)\n"); @@ -33924,25 +34948,16 @@ static int _wrap_drawLine__SWIG_3(lua_State* L) { int SWIG_arg = 0; glm::vec2 *a SWIG_fail_ptr("drawLine",2,SWIGTYPE_p_glm__vec2); } ofDrawLine((glm::vec2 const &)*arg1,(glm::vec2 const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_drawLine(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_drawLine__SWIG_2(L);} } } if (argc == 2) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_drawLine__SWIG_3(L);} } } if (argc == 4) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_drawLine__SWIG_0(L);} } } } } if (argc == 6) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { - return _wrap_drawLine__SWIG_1(L);} } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'drawLine'\n" " Possible C/C++ prototypes are:\n" - " ofDrawLine(float,float,float,float)\n" " ofDrawLine(float,float,float,float,float,float)\n" - " ofDrawLine(glm::vec3 const &,glm::vec3 const &)\n" " ofDrawLine(glm::vec2 const &,glm::vec2 const &)\n"); - lua_error(L);return 0; } + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_drawLine__SWIG_2(L);} check_1: if (argc == 2) { + return _wrap_drawLine__SWIG_3(L);} if (argc == 4) { return _wrap_drawLine__SWIG_0(L);} if (argc == 6) { + return _wrap_drawLine__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'drawLine'\n" + " Possible C/C++ prototypes are:\n" " ofDrawLine(float,float,float,float)\n" + " ofDrawLine(float,float,float,float,float,float)\n" " ofDrawLine(glm::vec3 const &,glm::vec3 const &)\n" + " ofDrawLine(glm::vec2 const &,glm::vec2 const &)\n"); lua_error(L);return 0; } static int _wrap_drawRectangle__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; SWIG_check_num_args("ofDrawRectangle",4,4) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawRectangle",1,"float"); if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawRectangle",2,"float"); @@ -33981,20 +34996,11 @@ static int _wrap_drawRectangle__SWIG_4(lua_State* L) { int SWIG_arg = 0; float a arg5 = (float)lua_tonumber(L, 5); ofDrawRectangle(arg1,arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_drawRectangle(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_drawRectangle__SWIG_1(L);} } if (argc == 3) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_drawRectangle__SWIG_2(L);} } } } if (argc == 3) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_drawRectangle__SWIG_3(L);} } } } if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_drawRectangle__SWIG_0(L);} } } } } if (argc == 5) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_drawRectangle__SWIG_4(L);} } } } } } + return _wrap_drawRectangle__SWIG_1(L);} if (argc == 3) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_drawRectangle__SWIG_2(L);} check_2: + if (argc == 3) { return _wrap_drawRectangle__SWIG_3(L);} if (argc == 4) { return _wrap_drawRectangle__SWIG_0(L);} + if (argc == 5) { return _wrap_drawRectangle__SWIG_4(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'drawRectangle'\n" " Possible C/C++ prototypes are:\n" " ofDrawRectangle(float,float,float,float)\n" " ofDrawRectangle(ofRectangle const &)\n" " ofDrawRectangle(glm::vec3 const &,float,float)\n" " ofDrawRectangle(glm::vec2 const &,float,float)\n" @@ -34107,44 +35113,17 @@ static int _wrap_drawRectRounded__SWIG_8(lua_State* L) { int SWIG_arg = 0; float ofDrawRectRounded(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_drawRectRounded(lua_State* L) { int argc; int argv[10]={ 1,2,3,4,5,6,7,8,9,10} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_drawRectRounded__SWIG_0(L);} } - } if (argc == 4) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_drawRectRounded__SWIG_1(L);} } } } } if (argc == 4) { - int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_drawRectRounded__SWIG_2(L);} } } } } if (argc == 5) { - int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_drawRectRounded__SWIG_7(L);} } } } } } if (argc == 5) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_drawRectRounded__SWIG_3(L);} } } } } } if (argc == 6) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { return _wrap_drawRectRounded__SWIG_4(L);} } } } } } } - if (argc == 7) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { - return _wrap_drawRectRounded__SWIG_6(L);} } } } } } } } if (argc == 7) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { - return _wrap_drawRectRounded__SWIG_5(L);} } } } } } } } if (argc == 9) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { { _v = lua_isnumber(L,argv[8]); } if (_v) { - return _wrap_drawRectRounded__SWIG_8(L);} } } } } } } } } } + if (argc == 2) { return _wrap_drawRectRounded__SWIG_0(L);} if (argc == 4) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_drawRectRounded__SWIG_1(L);} check_2: + if (argc == 4) { return _wrap_drawRectRounded__SWIG_2(L);} if (argc == 5) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_4; return _wrap_drawRectRounded__SWIG_7(L);} check_4: + if (argc == 5) { return _wrap_drawRectRounded__SWIG_3(L);} if (argc == 6) { return _wrap_drawRectRounded__SWIG_4(L);} + if (argc == 7) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_7; return _wrap_drawRectRounded__SWIG_6(L);} check_7: + if (argc == 7) { return _wrap_drawRectRounded__SWIG_5(L);} if (argc == 9) { return _wrap_drawRectRounded__SWIG_8(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'drawRectRounded'\n" " Possible C/C++ prototypes are:\n" " ofDrawRectRounded(ofRectangle const &,float)\n" " ofDrawRectRounded(glm::vec3 const &,float,float,float)\n" " ofDrawRectRounded(glm::vec2 const &,float,float,float)\n" " ofDrawRectRounded(float,float,float,float,float)\n" @@ -34180,19 +35159,9 @@ static int _wrap_drawCurve__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ofDrawCurve(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_drawCurve(lua_State* L) { int argc; int argv[13]={ 1,2,3,4,5,6,7,8,9,10,11,12,13} ; argc = lua_gettop(L); - if (argc == 8) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { { - _v = lua_isnumber(L,argv[6]); } if (_v) { { _v = lua_isnumber(L,argv[7]); } if (_v) { - return _wrap_drawCurve__SWIG_0(L);} } } } } } } } } if (argc == 12) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { { _v = lua_isnumber(L,argv[8]); } if (_v) { { - _v = lua_isnumber(L,argv[9]); } if (_v) { { _v = lua_isnumber(L,argv[10]); } if (_v) { { - _v = lua_isnumber(L,argv[11]); } if (_v) { return _wrap_drawCurve__SWIG_1(L);} } } } } } } } - } } } } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'drawCurve'\n" - " Possible C/C++ prototypes are:\n" " ofDrawCurve(float,float,float,float,float,float,float,float)\n" + if (argc == 8) { return _wrap_drawCurve__SWIG_0(L);} if (argc == 12) { return _wrap_drawCurve__SWIG_1(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'drawCurve'\n" " Possible C/C++ prototypes are:\n" + " ofDrawCurve(float,float,float,float,float,float,float,float)\n" " ofDrawCurve(float,float,float,float,float,float,float,float,float,float,float,float)\n"); lua_error(L);return 0; } static int _wrap_drawBezier__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; float arg5 ; float arg6 ; float arg7 ; float arg8 ; SWIG_check_num_args("ofDrawBezier",8,8) @@ -34229,19 +35198,9 @@ static int _wrap_drawBezier__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ofDrawBezier(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_drawBezier(lua_State* L) { int argc; int argv[13]={ 1,2,3,4,5,6,7,8,9,10,11,12,13} ; argc = lua_gettop(L); - if (argc == 8) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { { - _v = lua_isnumber(L,argv[6]); } if (_v) { { _v = lua_isnumber(L,argv[7]); } if (_v) { - return _wrap_drawBezier__SWIG_0(L);} } } } } } } } } if (argc == 12) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { { _v = lua_isnumber(L,argv[8]); } if (_v) { { - _v = lua_isnumber(L,argv[9]); } if (_v) { { _v = lua_isnumber(L,argv[10]); } if (_v) { { - _v = lua_isnumber(L,argv[11]); } if (_v) { return _wrap_drawBezier__SWIG_1(L);} } } } } } } } - } } } } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'drawBezier'\n" - " Possible C/C++ prototypes are:\n" " ofDrawBezier(float,float,float,float,float,float,float,float)\n" + if (argc == 8) { return _wrap_drawBezier__SWIG_0(L);} if (argc == 12) { return _wrap_drawBezier__SWIG_1(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'drawBezier'\n" " Possible C/C++ prototypes are:\n" + " ofDrawBezier(float,float,float,float,float,float,float,float)\n" " ofDrawBezier(float,float,float,float,float,float,float,float,float,float,float,float)\n"); lua_error(L);return 0; } static int _wrap_beginShape(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofBeginShape",0,0) ofBeginShape(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } @@ -34262,17 +35221,14 @@ static int _wrap_vertex__SWIG_3(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofVertex",1,"glm::vec2 const &"); if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("vertex",1,SWIGTYPE_p_glm__vec2); } ofVertex((glm::vec2 const &)*arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_vertex(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_vertex__SWIG_2(L);} } if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_vertex__SWIG_3(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_vertex__SWIG_0(L);} } - } if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_vertex__SWIG_1(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'vertex'\n" " Possible C/C++ prototypes are:\n" - " ofVertex(float,float)\n" " ofVertex(float,float,float)\n" " ofVertex(glm::vec3 const &)\n" - " ofVertex(glm::vec2 const &)\n"); lua_error(L);return 0; } +static int _wrap_vertex(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 1) { int _v = 0; { + { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_vertex__SWIG_2(L);} check_1: if (argc == 1) { + return _wrap_vertex__SWIG_3(L);} if (argc == 2) { return _wrap_vertex__SWIG_0(L);} if (argc == 3) { + return _wrap_vertex__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'vertex'\n" + " Possible C/C++ prototypes are:\n" " ofVertex(float,float)\n" " ofVertex(float,float,float)\n" + " ofVertex(glm::vec3 const &)\n" " ofVertex(glm::vec2 const &)\n"); lua_error(L);return 0; } static int _wrap_vertices__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::vector< glm::vec3 > *arg1 = 0 ; SWIG_check_num_args("ofVertices",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofVertices",1,"std::vector< glm::vec3 > const &"); @@ -34295,20 +35251,20 @@ static int _wrap_vertices__SWIG_3(lua_State* L) { int SWIG_arg = 0; std::vector< if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofVec2f_t,0))){ SWIG_fail_ptr("vertices",1,SWIGTYPE_p_std__vectorT_ofVec2f_t); } ofVertices((std::vector< ofVec2f > const &)*arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_vertices(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_std__vectorT_glm__vec3_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_vertices__SWIG_0(L);} } if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_std__vectorT_glm__vec2_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_vertices__SWIG_1(L);} } if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_std__vectorT_ofVec3f_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_vertices__SWIG_2(L);} } if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_std__vectorT_ofVec2f_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_vertices__SWIG_3(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'vertices'\n" " Possible C/C++ prototypes are:\n" - " ofVertices(std::vector< glm::vec3 > const &)\n" " ofVertices(std::vector< glm::vec2 > const &)\n" - " ofVertices(std::vector< ofVec3f > const &)\n" " ofVertices(std::vector< ofVec2f > const &)\n"); - lua_error(L);return 0; } +static int _wrap_vertices(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v = 0; { { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_std__vectorT_glm__vec3_t, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_vertices__SWIG_0(L);} check_1: if (argc == 1) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_std__vectorT_glm__vec2_t, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_vertices__SWIG_1(L);} check_2: if (argc == 1) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_std__vectorT_ofVec3f_t, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; return _wrap_vertices__SWIG_2(L);} check_3: if (argc == 1) { + return _wrap_vertices__SWIG_3(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'vertices'\n" + " Possible C/C++ prototypes are:\n" " ofVertices(std::vector< glm::vec3 > const &)\n" + " ofVertices(std::vector< glm::vec2 > const &)\n" " ofVertices(std::vector< ofVec3f > const &)\n" + " ofVertices(std::vector< ofVec2f > const &)\n"); lua_error(L);return 0; } static int _wrap_curveVertex__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; SWIG_check_num_args("ofCurveVertex",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofCurveVertex",1,"float"); if(!lua_isnumber(L,2)) SWIG_fail_arg("ofCurveVertex",2,"float"); arg1 = (float)lua_tonumber(L, 1); @@ -34330,15 +35286,12 @@ static int _wrap_curveVertex__SWIG_3(lua_State* L) { int SWIG_arg = 0; glm::vec2 if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("curveVertex",1,SWIGTYPE_p_glm__vec2); } ofCurveVertex((glm::vec2 const &)*arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_curveVertex(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_curveVertex__SWIG_2(L);} } if (argc == 1) { int _v; { - void *ptr; if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_curveVertex__SWIG_3(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_curveVertex__SWIG_0(L);} } } if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_curveVertex__SWIG_1(L);} } } } +static int _wrap_curveVertex(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 1) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_curveVertex__SWIG_2(L);} check_1: + if (argc == 1) { return _wrap_curveVertex__SWIG_3(L);} if (argc == 2) { return _wrap_curveVertex__SWIG_0(L);} + if (argc == 3) { return _wrap_curveVertex__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'curveVertex'\n" " Possible C/C++ prototypes are:\n" " ofCurveVertex(float,float)\n" " ofCurveVertex(float,float,float)\n" " ofCurveVertex(glm::vec3 const &)\n" " ofCurveVertex(glm::vec2 const &)\n"); lua_error(L);return 0; } @@ -34370,19 +35323,17 @@ static int _wrap_curveVertices__SWIG_3(lua_State* L) { int SWIG_arg = 0; std::ve SWIG_fail_ptr("curveVertices",1,SWIGTYPE_p_std__vectorT_ofVec2f_t); } ofCurveVertices((std::vector< ofVec2f > const &)*arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_curveVertices(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_std__vectorT_glm__vec3_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_curveVertices__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_std__vectorT_glm__vec2_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_curveVertices__SWIG_1(L);} } if (argc == 1) { int _v; { - void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_std__vectorT_ofVec3f_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_curveVertices__SWIG_2(L);} } if (argc == 1) { int _v; { - void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_std__vectorT_ofVec2f_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_curveVertices__SWIG_3(L);} } +static int _wrap_curveVertices(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v = 0; + { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_std__vectorT_glm__vec3_t, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_curveVertices__SWIG_0(L);} check_1: + if (argc == 1) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_std__vectorT_glm__vec2_t, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_curveVertices__SWIG_1(L);} check_2: + if (argc == 1) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_std__vectorT_ofVec3f_t, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; return _wrap_curveVertices__SWIG_2(L);} check_3: + if (argc == 1) { return _wrap_curveVertices__SWIG_3(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'curveVertices'\n" " Possible C/C++ prototypes are:\n" " ofCurveVertices(std::vector< glm::vec3 > const &)\n" " ofCurveVertices(std::vector< glm::vec2 > const &)\n" " ofCurveVertices(std::vector< ofVec3f > const &)\n" " ofCurveVertices(std::vector< ofVec2f > const &)\n"); @@ -34441,28 +35392,16 @@ static int _wrap_bezierVertex__SWIG_3(lua_State* L) { int SWIG_arg = 0; float ar ofBezierVertex(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_bezierVertex(lua_State* L) { int argc; int argv[10]={ 1,2,3,4,5,6,7,8,9,10} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_bezierVertex__SWIG_1(L);} } } } if (argc == 3) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_glm__vec2, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_bezierVertex__SWIG_2(L);} } } } if (argc == 6) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { return _wrap_bezierVertex__SWIG_0(L);} } } } } } } - if (argc == 9) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { { - _v = lua_isnumber(L,argv[6]); } if (_v) { { _v = lua_isnumber(L,argv[7]); } if (_v) { { - _v = lua_isnumber(L,argv[8]); } if (_v) { return _wrap_bezierVertex__SWIG_3(L);} } } } } } } } } - } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'bezierVertex'\n" " Possible C/C++ prototypes are:\n" + if (argc == 3) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; { { void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_bezierVertex__SWIG_1(L);} check_1: + if (argc == 3) { return _wrap_bezierVertex__SWIG_2(L);} if (argc == 6) { return _wrap_bezierVertex__SWIG_0(L);} + if (argc == 9) { return _wrap_bezierVertex__SWIG_3(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'bezierVertex'\n" " Possible C/C++ prototypes are:\n" " ofBezierVertex(float,float,float,float,float,float)\n" " ofBezierVertex(glm::vec3 const &,glm::vec3 const &,glm::vec3 const &)\n" " ofBezierVertex(glm::vec2 const &,glm::vec2 const &,glm::vec2 const &)\n" @@ -34473,17 +35412,16 @@ static int _wrap_endShape__SWIG_0(lua_State* L) { int SWIG_arg = 0; bool arg1 ; static int _wrap_endShape__SWIG_1(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofEndShape",0,0) ofEndShape(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_endShape(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_endShape__SWIG_1(L);} if (argc == 1) { int _v; { _v = lua_isboolean(L,argv[0]); } if (_v) { - return _wrap_endShape__SWIG_0(L);} } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'endShape'\n" - " Possible C/C++ prototypes are:\n" " ofEndShape(bool)\n" " ofEndShape()\n"); lua_error(L);return 0; } + return _wrap_endShape__SWIG_1(L);} if (argc == 1) { return _wrap_endShape__SWIG_0(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'endShape'\n" " Possible C/C++ prototypes are:\n" + " ofEndShape(bool)\n" " ofEndShape()\n"); lua_error(L);return 0; } static int _wrap_nextContour__SWIG_0(lua_State* L) { int SWIG_arg = 0; bool arg1 ; SWIG_check_num_args("ofNextContour",1,1) if(!lua_isboolean(L,1)) SWIG_fail_arg("ofNextContour",1,"bool"); arg1 = (lua_toboolean(L, 1)!=0); ofNextContour(arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_nextContour__SWIG_1(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofNextContour",0,0) ofNextContour(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_nextContour(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_nextContour__SWIG_1(L);} if (argc == 1) { int _v; { _v = lua_isboolean(L,argv[0]); } if (_v) { - return _wrap_nextContour__SWIG_0(L);} } + return _wrap_nextContour__SWIG_1(L);} if (argc == 1) { return _wrap_nextContour__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'nextContour'\n" " Possible C/C++ prototypes are:\n" " ofNextContour(bool)\n" " ofNextContour()\n"); lua_error(L);return 0; } static int _wrap_setDrawBitmapMode(lua_State* L) { int SWIG_arg = 0; ofDrawBitmapMode arg1 ; @@ -34596,48 +35534,31 @@ static int _wrap_drawBitmapStringHighlight__SWIG_8(lua_State* L) { int SWIG_arg (&arg1)->assign(lua_tostring(L,1),lua_rawlen(L,1)); arg2 = (int)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); ofDrawBitmapStringHighlight(arg1,arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_drawBitmapStringHighlight(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_drawBitmapStringHighlight__SWIG_2(L);} } } if (argc == 2) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_drawBitmapStringHighlight__SWIG_5(L);} } } if (argc == 3) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_drawBitmapStringHighlight__SWIG_4(L);} } } } - if (argc == 3) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_drawBitmapStringHighlight__SWIG_1(L);} } } } - if (argc == 3) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_drawBitmapStringHighlight__SWIG_8(L);} } } } - if (argc == 4) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_drawBitmapStringHighlight__SWIG_3(L);} } } } } - if (argc == 4) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_drawBitmapStringHighlight__SWIG_0(L);} } } } } - if (argc == 4) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_drawBitmapStringHighlight__SWIG_7(L);} } } } } - if (argc == 5) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[4])==0 || SWIG_ConvertPtr(L,argv[4], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_drawBitmapStringHighlight__SWIG_6(L);} } } } } } + if (argc == 2) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_drawBitmapStringHighlight__SWIG_2(L);} check_1: + if (argc == 2) { return _wrap_drawBitmapStringHighlight__SWIG_5(L);} if (argc == 3) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; { { void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; return _wrap_drawBitmapStringHighlight__SWIG_4(L);} check_3: + if (argc == 3) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_4; { { void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_4; return _wrap_drawBitmapStringHighlight__SWIG_1(L);} check_4: + if (argc == 3) { return _wrap_drawBitmapStringHighlight__SWIG_8(L);} if (argc == 4) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_6; { { void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_6; return _wrap_drawBitmapStringHighlight__SWIG_3(L);} check_6: + if (argc == 4) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_7; { { void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_7; return _wrap_drawBitmapStringHighlight__SWIG_0(L);} check_7: + if (argc == 4) { return _wrap_drawBitmapStringHighlight__SWIG_7(L);} if (argc == 5) { + return _wrap_drawBitmapStringHighlight__SWIG_6(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'drawBitmapStringHighlight'\n" " Possible C/C++ prototypes are:\n" " ofDrawBitmapStringHighlight(std::string,glm::vec3 const &,ofColor const &,ofColor const &)\n" @@ -34754,17 +35675,14 @@ static int _wrap_translate__SWIG_3(lua_State* L) { int SWIG_arg = 0; glm::vec2 * if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("translate",1,SWIGTYPE_p_glm__vec2); } ofTranslate((glm::vec2 const &)*arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_translate(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_translate__SWIG_2(L);} } if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_translate__SWIG_3(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_translate__SWIG_1(L);} - } } if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_translate__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'translate'\n" " Possible C/C++ prototypes are:\n" - " ofTranslate(float,float,float)\n" " ofTranslate(float,float)\n" " ofTranslate(glm::vec3 const &)\n" - " ofTranslate(glm::vec2 const &)\n"); lua_error(L);return 0; } +static int _wrap_translate(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 1) { int _v = 0; + { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_translate__SWIG_2(L);} check_1: + if (argc == 1) { return _wrap_translate__SWIG_3(L);} if (argc == 2) { return _wrap_translate__SWIG_1(L);} if (argc == 3) { + return _wrap_translate__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'translate'\n" + " Possible C/C++ prototypes are:\n" " ofTranslate(float,float,float)\n" " ofTranslate(float,float)\n" + " ofTranslate(glm::vec3 const &)\n" " ofTranslate(glm::vec2 const &)\n"); lua_error(L);return 0; } static int _wrap_scale__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; SWIG_check_num_args("ofScale",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofScale",1,"float"); if(!lua_isnumber(L,2)) SWIG_fail_arg("ofScale",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofScale",3,"float"); @@ -34781,40 +35699,14 @@ static int _wrap_scale__SWIG_3(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofScale",1,"glm::vec3 const &"); if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("scale",1,SWIGTYPE_p_glm__vec3); } ofScale((glm::vec3 const &)*arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_scale(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_scale__SWIG_3(L);} } if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_scale__SWIG_2(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_scale__SWIG_1(L);} } - } if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_scale__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'scale'\n" " Possible C/C++ prototypes are:\n" - " ofScale(float,float,float)\n" " ofScale(float,float)\n" " ofScale(float)\n" " ofScale(glm::vec3 const &)\n"); - lua_error(L);return 0; } -static int _wrap_rotate__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - SWIG_check_num_args("ofRotate",4,4) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofRotate",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRotate",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofRotate",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofRotate",4,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - ofRotate(arg1,arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_rotate__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; SWIG_check_num_args("ofRotate",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofRotate",1,"float"); arg1 = (float)lua_tonumber(L, 1); ofRotate(arg1); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_rotate(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_rotate__SWIG_1(L);} } if (argc == 4) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_rotate__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'rotate'\n" " Possible C/C++ prototypes are:\n" - " ofRotate(float,float,float,float)\n" " ofRotate(float)\n"); lua_error(L);return 0; } -static int _wrap_rotateX(lua_State* L) { int SWIG_arg = 0; float arg1 ; SWIG_check_num_args("ofRotateX",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofRotateX",1,"float"); arg1 = (float)lua_tonumber(L, 1); ofRotateX(arg1); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_rotateY(lua_State* L) { int SWIG_arg = 0; float arg1 ; SWIG_check_num_args("ofRotateY",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofRotateY",1,"float"); arg1 = (float)lua_tonumber(L, 1); ofRotateY(arg1); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_rotateZ(lua_State* L) { int SWIG_arg = 0; float arg1 ; SWIG_check_num_args("ofRotateZ",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofRotateZ",1,"float"); arg1 = (float)lua_tonumber(L, 1); ofRotateZ(arg1); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_scale(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 1) { int _v = 0; { { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_scale__SWIG_3(L);} check_1: if (argc == 1) { + return _wrap_scale__SWIG_2(L);} if (argc == 2) { return _wrap_scale__SWIG_1(L);} if (argc == 3) { + return _wrap_scale__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'scale'\n" + " Possible C/C++ prototypes are:\n" " ofScale(float,float,float)\n" " ofScale(float,float)\n" " ofScale(float)\n" + " ofScale(glm::vec3 const &)\n"); lua_error(L);return 0; } static int _wrap_rotateDeg__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; SWIG_check_num_args("ofRotateDeg",4,4) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofRotateDeg",1,"float"); if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRotateDeg",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofRotateDeg",3,"float"); @@ -34824,10 +35716,8 @@ static int _wrap_rotateDeg__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 static int _wrap_rotateDeg__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; SWIG_check_num_args("ofRotateDeg",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofRotateDeg",1,"float"); arg1 = (float)lua_tonumber(L, 1); ofRotateDeg(arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_rotateDeg(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_rotateDeg__SWIG_1(L);} } if (argc == 4) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_rotateDeg__SWIG_0(L);} } } } } +static int _wrap_rotateDeg(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 1) { + return _wrap_rotateDeg__SWIG_1(L);} if (argc == 4) { return _wrap_rotateDeg__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'rotateDeg'\n" " Possible C/C++ prototypes are:\n" " ofRotateDeg(float,float,float,float)\n" " ofRotateDeg(float)\n"); lua_error(L);return 0; } static int _wrap_rotateXDeg(lua_State* L) { int SWIG_arg = 0; float arg1 ; SWIG_check_num_args("ofRotateXDeg",1,1) @@ -34848,10 +35738,8 @@ static int _wrap_rotateRad__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 static int _wrap_rotateRad__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; SWIG_check_num_args("ofRotateRad",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofRotateRad",1,"float"); arg1 = (float)lua_tonumber(L, 1); ofRotateRad(arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_rotateRad(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_rotateRad__SWIG_1(L);} } if (argc == 4) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_rotateRad__SWIG_0(L);} } } } } +static int _wrap_rotateRad(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 1) { + return _wrap_rotateRad__SWIG_1(L);} if (argc == 4) { return _wrap_rotateRad__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'rotateRad'\n" " Possible C/C++ prototypes are:\n" " ofRotateRad(float,float,float,float)\n" " ofRotateRad(float)\n"); lua_error(L);return 0; } static int _wrap_rotateXRad(lua_State* L) { int SWIG_arg = 0; float arg1 ; SWIG_check_num_args("ofRotateXRad",1,1) @@ -34874,11 +35762,11 @@ static int _wrap_loadMatrix__SWIG_1(lua_State* L) { int SWIG_arg = 0; float *arg SWIG_check_num_args("ofLoadMatrix",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLoadMatrix",1,"float const *"); if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_float,0))){ SWIG_fail_ptr("loadMatrix",1,SWIGTYPE_p_float); } ofLoadMatrix((float const *)arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_loadMatrix(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__mat4, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_loadMatrix__SWIG_0(L);} } if (argc == 1) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_loadMatrix__SWIG_1(L);} } +static int _wrap_loadMatrix(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v = 0; { + { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__mat4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_loadMatrix__SWIG_0(L);} check_1: + if (argc == 1) { return _wrap_loadMatrix__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'loadMatrix'\n" " Possible C/C++ prototypes are:\n" " ofLoadMatrix(glm::mat4 const &)\n" " ofLoadMatrix(float const *)\n"); lua_error(L);return 0; } static int _wrap_multMatrix__SWIG_0(lua_State* L) { int SWIG_arg = 0; glm::mat4 *arg1 = 0 ; @@ -34890,11 +35778,11 @@ static int _wrap_multMatrix__SWIG_1(lua_State* L) { int SWIG_arg = 0; float *arg SWIG_check_num_args("ofMultMatrix",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMultMatrix",1,"float const *"); if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_float,0))){ SWIG_fail_ptr("multMatrix",1,SWIGTYPE_p_float); } ofMultMatrix((float const *)arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_multMatrix(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__mat4, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_multMatrix__SWIG_0(L);} } if (argc == 1) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_multMatrix__SWIG_1(L);} } +static int _wrap_multMatrix(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v = 0; { + { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__mat4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_multMatrix__SWIG_0(L);} check_1: + if (argc == 1) { return _wrap_multMatrix__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'multMatrix'\n" " Possible C/C++ prototypes are:\n" " ofMultMatrix(glm::mat4 const &)\n" " ofMultMatrix(float const *)\n"); lua_error(L);return 0; } static int _wrap_setMatrixMode(lua_State* L) { int SWIG_arg = 0; ofMatrixMode arg1 ; SWIG_check_num_args("ofSetMatrixMode",1,1) @@ -34956,22 +35844,15 @@ static int _wrap_viewport__SWIG_5(lua_State* L) { int SWIG_arg = 0; float arg1 ; static int _wrap_viewport__SWIG_6(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofViewport",0,0) ofViewport(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_viewport(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_viewport__SWIG_6(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_viewport__SWIG_0(L);} } if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_viewport__SWIG_5(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_viewport__SWIG_4(L);} - } } if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_viewport__SWIG_3(L);} } } } if (argc == 4) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_viewport__SWIG_2(L);} } } } } if (argc == 5) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isboolean(L,argv[4]); } if (_v) { return _wrap_viewport__SWIG_1(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'viewport'\n" " Possible C/C++ prototypes are:\n" - " ofViewport(ofRectangle)\n" " ofViewport(float,float,float,float,bool)\n" " ofViewport(float,float,float,float)\n" - " ofViewport(float,float,float)\n" " ofViewport(float,float)\n" " ofViewport(float)\n" " ofViewport()\n"); - lua_error(L);return 0; } + return _wrap_viewport__SWIG_6(L);} if (argc == 1) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_viewport__SWIG_0(L);} check_2: if (argc == 1) { + return _wrap_viewport__SWIG_5(L);} if (argc == 2) { return _wrap_viewport__SWIG_4(L);} if (argc == 3) { + return _wrap_viewport__SWIG_3(L);} if (argc == 4) { return _wrap_viewport__SWIG_2(L);} if (argc == 5) { + return _wrap_viewport__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'viewport'\n" + " Possible C/C++ prototypes are:\n" " ofViewport(ofRectangle)\n" " ofViewport(float,float,float,float,bool)\n" + " ofViewport(float,float,float,float)\n" " ofViewport(float,float,float)\n" " ofViewport(float,float)\n" + " ofViewport(float)\n" " ofViewport()\n"); lua_error(L);return 0; } static int _wrap_getCurrentViewport(lua_State* L) { int SWIG_arg = 0; ofRectangle result; SWIG_check_num_args("ofGetCurrentViewport",0,0) result = ofGetCurrentViewport(); { ofRectangle * resultptr = new ofRectangle((const ofRectangle &) result); @@ -35027,17 +35908,10 @@ static int _wrap_setupScreenPerspective__SWIG_5(lua_State* L) { int SWIG_arg = 0 SWIG_check_num_args("ofSetupScreenPerspective",0,0) ofSetupScreenPerspective(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_setupScreenPerspective(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); - if (argc == 0) { return _wrap_setupScreenPerspective__SWIG_5(L);} if (argc == 1) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { return _wrap_setupScreenPerspective__SWIG_4(L);} } if (argc == 2) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_setupScreenPerspective__SWIG_3(L);} } } - if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_setupScreenPerspective__SWIG_2(L);} } } } if (argc == 4) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { - return _wrap_setupScreenPerspective__SWIG_1(L);} } } } } if (argc == 5) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_setupScreenPerspective__SWIG_0(L);} } } } } } + if (argc == 0) { return _wrap_setupScreenPerspective__SWIG_5(L);} if (argc == 1) { + return _wrap_setupScreenPerspective__SWIG_4(L);} if (argc == 2) { return _wrap_setupScreenPerspective__SWIG_3(L);} + if (argc == 3) { return _wrap_setupScreenPerspective__SWIG_2(L);} if (argc == 4) { + return _wrap_setupScreenPerspective__SWIG_1(L);} if (argc == 5) { return _wrap_setupScreenPerspective__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'setupScreenPerspective'\n" " Possible C/C++ prototypes are:\n" " ofSetupScreenPerspective(float,float,float,float,float)\n" " ofSetupScreenPerspective(float,float,float,float)\n" " ofSetupScreenPerspective(float,float,float)\n" @@ -35068,13 +35942,9 @@ static int _wrap_setupScreenOrtho__SWIG_3(lua_State* L) { int SWIG_arg = 0; floa static int _wrap_setupScreenOrtho__SWIG_4(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofSetupScreenOrtho",0,0) ofSetupScreenOrtho(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_setupScreenOrtho(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_setupScreenOrtho__SWIG_4(L);} if (argc == 1) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { - return _wrap_setupScreenOrtho__SWIG_3(L);} } if (argc == 2) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_setupScreenOrtho__SWIG_2(L);} } } if (argc == 3) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_setupScreenOrtho__SWIG_1(L);} } } } if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_setupScreenOrtho__SWIG_0(L);} } } } } + return _wrap_setupScreenOrtho__SWIG_4(L);} if (argc == 1) { return _wrap_setupScreenOrtho__SWIG_3(L);} if (argc == 2) { + return _wrap_setupScreenOrtho__SWIG_2(L);} if (argc == 3) { return _wrap_setupScreenOrtho__SWIG_1(L);} if (argc == 4) { + return _wrap_setupScreenOrtho__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'setupScreenOrtho'\n" " Possible C/C++ prototypes are:\n" " ofSetupScreenOrtho(float,float,float,float)\n" " ofSetupScreenOrtho(float,float,float)\n" " ofSetupScreenOrtho(float,float)\n" " ofSetupScreenOrtho(float)\n" " ofSetupScreenOrtho()\n"); @@ -35122,14 +35992,9 @@ static int _wrap_beginSaveScreenAsPDF__SWIG_3(lua_State* L) { int SWIG_arg = 0; (&arg1)->assign(lua_tostring(L,1),lua_rawlen(L,1)); ofBeginSaveScreenAsPDF(arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_beginSaveScreenAsPDF(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 1) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { return _wrap_beginSaveScreenAsPDF__SWIG_3(L);} } - if (argc == 2) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_beginSaveScreenAsPDF__SWIG_2(L);} } } if (argc == 3) { int _v; { _v = lua_isstring(L,argv[0]); } - if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - return _wrap_beginSaveScreenAsPDF__SWIG_1(L);} } } } if (argc == 4) { int _v; { _v = lua_isstring(L,argv[0]); } - if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_beginSaveScreenAsPDF__SWIG_0(L);} } } } } + if (argc == 1) { return _wrap_beginSaveScreenAsPDF__SWIG_3(L);} if (argc == 2) { + return _wrap_beginSaveScreenAsPDF__SWIG_2(L);} if (argc == 3) { return _wrap_beginSaveScreenAsPDF__SWIG_1(L);} + if (argc == 4) { return _wrap_beginSaveScreenAsPDF__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'beginSaveScreenAsPDF'\n" " Possible C/C++ prototypes are:\n" " ofBeginSaveScreenAsPDF(std::string,bool,bool,ofRectangle)\n" " ofBeginSaveScreenAsPDF(std::string,bool,bool)\n" " ofBeginSaveScreenAsPDF(std::string,bool)\n" @@ -35165,14 +36030,9 @@ static int _wrap_beginSaveScreenAsSVG__SWIG_3(lua_State* L) { int SWIG_arg = 0; (&arg1)->assign(lua_tostring(L,1),lua_rawlen(L,1)); ofBeginSaveScreenAsSVG(arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_beginSaveScreenAsSVG(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 1) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { return _wrap_beginSaveScreenAsSVG__SWIG_3(L);} } - if (argc == 2) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_beginSaveScreenAsSVG__SWIG_2(L);} } } if (argc == 3) { int _v; { _v = lua_isstring(L,argv[0]); } - if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - return _wrap_beginSaveScreenAsSVG__SWIG_1(L);} } } } if (argc == 4) { int _v; { _v = lua_isstring(L,argv[0]); } - if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_beginSaveScreenAsSVG__SWIG_0(L);} } } } } + if (argc == 1) { return _wrap_beginSaveScreenAsSVG__SWIG_3(L);} if (argc == 2) { + return _wrap_beginSaveScreenAsSVG__SWIG_2(L);} if (argc == 3) { return _wrap_beginSaveScreenAsSVG__SWIG_1(L);} + if (argc == 4) { return _wrap_beginSaveScreenAsSVG__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'beginSaveScreenAsSVG'\n" " Possible C/C++ prototypes are:\n" " ofBeginSaveScreenAsSVG(std::string,bool,bool,ofRectangle)\n" " ofBeginSaveScreenAsSVG(std::string,bool,bool)\n" " ofBeginSaveScreenAsSVG(std::string,bool)\n" @@ -35213,17 +36073,9 @@ static int _wrap_drawPlane__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawPlane",2,"float"); arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); ofDrawPlane(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawPlane(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 2) { int _v; - { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_drawPlane__SWIG_3(L);} - } } if (argc == 3) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_drawPlane__SWIG_2(L);} } } } if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_drawPlane__SWIG_0(L);} } } } } if (argc == 5) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_drawPlane__SWIG_1(L);} } } } } } +static int _wrap_drawPlane(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 2) { + return _wrap_drawPlane__SWIG_3(L);} if (argc == 3) { return _wrap_drawPlane__SWIG_2(L);} if (argc == 4) { + return _wrap_drawPlane__SWIG_0(L);} if (argc == 5) { return _wrap_drawPlane__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'drawPlane'\n" " Possible C/C++ prototypes are:\n" " ofDrawPlane(float,float,float,float)\n" " ofDrawPlane(float,float,float,float,float)\n" " ofDrawPlane(glm::vec3 &,float,float)\n" " ofDrawPlane(float,float)\n"); lua_error(L);return 0; } @@ -35256,14 +36108,9 @@ static int _wrap_drawSphere__SWIG_2(lua_State* L) { int SWIG_arg = 0; glm::vec3 static int _wrap_drawSphere__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; SWIG_check_num_args("ofDrawSphere",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawSphere",1,"float"); arg1 = (float)lua_tonumber(L, 1); ofDrawSphere(arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawSphere(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 1) { int _v; - { _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_drawSphere__SWIG_3(L);} } if (argc == 2) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_drawSphere__SWIG_2(L);} } } - if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_drawSphere__SWIG_0(L);} } } } if (argc == 4) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_drawSphere__SWIG_1(L);} } } } } +static int _wrap_drawSphere(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 1) { + return _wrap_drawSphere__SWIG_3(L);} if (argc == 2) { return _wrap_drawSphere__SWIG_2(L);} if (argc == 3) { + return _wrap_drawSphere__SWIG_0(L);} if (argc == 4) { return _wrap_drawSphere__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'drawSphere'\n" " Possible C/C++ prototypes are:\n" " ofDrawSphere(float,float,float)\n" " ofDrawSphere(float,float,float,float)\n" " ofDrawSphere(glm::vec3 const &,float)\n" " ofDrawSphere(float)\n"); lua_error(L);return 0; } @@ -35297,14 +36144,8 @@ static int _wrap_drawIcoSphere__SWIG_3(lua_State* L) { int SWIG_arg = 0; float a if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawIcoSphere",1,"float"); arg1 = (float)lua_tonumber(L, 1); ofDrawIcoSphere(arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_drawIcoSphere(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_drawIcoSphere__SWIG_3(L);} } if (argc == 2) { int _v; { - void *ptr; if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_drawIcoSphere__SWIG_2(L);} } } if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_drawIcoSphere__SWIG_1(L);} } } } if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_drawIcoSphere__SWIG_0(L);} } } } } + return _wrap_drawIcoSphere__SWIG_3(L);} if (argc == 2) { return _wrap_drawIcoSphere__SWIG_2(L);} if (argc == 3) { + return _wrap_drawIcoSphere__SWIG_1(L);} if (argc == 4) { return _wrap_drawIcoSphere__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'drawIcoSphere'\n" " Possible C/C++ prototypes are:\n" " ofDrawIcoSphere(float,float,float,float)\n" " ofDrawIcoSphere(float,float,float)\n" " ofDrawIcoSphere(glm::vec3 const &,float)\n" " ofDrawIcoSphere(float)\n"); lua_error(L);return 0; } @@ -35320,10 +36161,7 @@ static int _wrap_setCylinderResolution__SWIG_1(lua_State* L) { int SWIG_arg = 0; arg2 = (int)lua_tonumber(L, 2); ofSetCylinderResolution(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_setCylinderResolution(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_setCylinderResolution__SWIG_1(L);} } } if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_setCylinderResolution__SWIG_0(L);} } } } + return _wrap_setCylinderResolution__SWIG_1(L);} if (argc == 3) { return _wrap_setCylinderResolution__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'setCylinderResolution'\n" " Possible C/C++ prototypes are:\n" " ofSetCylinderResolution(int,int,int)\n" " ofSetCylinderResolution(int,int)\n"); lua_error(L);return 0; } @@ -35361,16 +36199,8 @@ static int _wrap_drawCylinder__SWIG_3(lua_State* L) { int SWIG_arg = 0; float ar arg2 = (float)lua_tonumber(L, 2); ofDrawCylinder(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_drawCylinder(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_drawCylinder__SWIG_3(L);} } } if (argc == 3) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_drawCylinder__SWIG_2(L);} } } } if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { - { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_drawCylinder__SWIG_0(L);} } } } } if (argc == 5) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_drawCylinder__SWIG_1(L);} } } } } } + return _wrap_drawCylinder__SWIG_3(L);} if (argc == 3) { return _wrap_drawCylinder__SWIG_2(L);} if (argc == 4) { + return _wrap_drawCylinder__SWIG_0(L);} if (argc == 5) { return _wrap_drawCylinder__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'drawCylinder'\n" " Possible C/C++ prototypes are:\n" " ofDrawCylinder(float,float,float,float)\n" " ofDrawCylinder(float,float,float,float,float)\n" " ofDrawCylinder(glm::vec3 const &,float,float)\n" " ofDrawCylinder(float,float)\n"); lua_error(L);return 0; } @@ -35386,10 +36216,7 @@ static int _wrap_setConeResolution__SWIG_1(lua_State* L) { int SWIG_arg = 0; int arg2 = (int)lua_tonumber(L, 2); ofSetConeResolution(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_setConeResolution(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_setConeResolution__SWIG_1(L);} } } if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { - { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_setConeResolution__SWIG_0(L);} } } } + return _wrap_setConeResolution__SWIG_1(L);} if (argc == 3) { return _wrap_setConeResolution__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'setConeResolution'\n" " Possible C/C++ prototypes are:\n" " ofSetConeResolution(int,int,int)\n" " ofSetConeResolution(int,int)\n"); lua_error(L);return 0; } static int _wrap_getConeResolution(lua_State* L) { int SWIG_arg = 0; glm::vec3 result; @@ -35421,17 +36248,9 @@ static int _wrap_drawCone__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawCone",2,"float"); arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); ofDrawCone(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawCone(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 2) { int _v; - { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_drawCone__SWIG_3(L);} - } } if (argc == 3) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_drawCone__SWIG_2(L);} } } } if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_drawCone__SWIG_1(L);} } } } } if (argc == 5) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_drawCone__SWIG_0(L);} } } } } } +static int _wrap_drawCone(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 2) { + return _wrap_drawCone__SWIG_3(L);} if (argc == 3) { return _wrap_drawCone__SWIG_2(L);} if (argc == 4) { + return _wrap_drawCone__SWIG_1(L);} if (argc == 5) { return _wrap_drawCone__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'drawCone'\n" " Possible C/C++ prototypes are:\n" " ofDrawCone(float,float,float,float,float)\n" " ofDrawCone(float,float,float,float)\n" " ofDrawCone(glm::vec3 const &,float,float)\n" " ofDrawCone(float,float)\n"); lua_error(L);return 0; } @@ -35446,9 +36265,7 @@ static int _wrap_setBoxResolution__SWIG_1(lua_State* L) { int SWIG_arg = 0; int arg2 = (int)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); ofSetBoxResolution(arg1,arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_setBoxResolution(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_setBoxResolution__SWIG_0(L);} } if (argc == 3) { int _v; - { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_setBoxResolution__SWIG_1(L);} } } } + return _wrap_setBoxResolution__SWIG_0(L);} if (argc == 3) { return _wrap_setBoxResolution__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'setBoxResolution'\n" " Possible C/C++ prototypes are:\n" " ofSetBoxResolution(int)\n" " ofSetBoxResolution(int,int,int)\n"); lua_error(L);return 0; } static int _wrap_getBoxResolution(lua_State* L) { int SWIG_arg = 0; glm::vec3 result; @@ -35491,21 +36308,12 @@ static int _wrap_drawBox__SWIG_5(lua_State* L) { int SWIG_arg = 0; float arg1 ; if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawBox",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawBox",3,"float"); arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); ofDrawBox(arg1,arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawBox(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); if (argc == 1) { int _v; - { _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_drawBox__SWIG_4(L);} } if (argc == 2) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_drawBox__SWIG_3(L);} } } - if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_drawBox__SWIG_5(L);} } } } if (argc == 4) { int _v; { - void *ptr; if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_drawBox__SWIG_2(L);} } } } } if (argc == 4) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { - return _wrap_drawBox__SWIG_1(L);} } } } } if (argc == 6) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { - { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { - return _wrap_drawBox__SWIG_0(L);} } } } } } } +static int _wrap_drawBox(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); if (argc == 1) { + return _wrap_drawBox__SWIG_4(L);} if (argc == 2) { return _wrap_drawBox__SWIG_3(L);} if (argc == 3) { + return _wrap_drawBox__SWIG_5(L);} if (argc == 4) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_4; return _wrap_drawBox__SWIG_2(L);} check_4: if (argc == 4) { + return _wrap_drawBox__SWIG_1(L);} if (argc == 6) { return _wrap_drawBox__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'drawBox'\n" " Possible C/C++ prototypes are:\n" " ofDrawBox(float,float,float,float,float,float)\n" " ofDrawBox(float,float,float,float)\n" " ofDrawBox(glm::vec3 const &,float,float,float)\n" " ofDrawBox(glm::vec3 const &,float)\n" " ofDrawBox(float)\n" @@ -35524,6 +36332,10 @@ static int _wrap_Unicode_Space_get(lua_State* L) { int SWIG_arg = 0; ofUnicode:: SWIG_check_num_args("ofUnicode::Space",0,0) result = (ofUnicode::range *)&ofUnicode::Space; SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofUnicode__range,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Unicode_IdeographicSpace_get(lua_State* L) { int SWIG_arg = 0; ofUnicode::range *result = 0 ; + SWIG_check_num_args("ofUnicode::IdeographicSpace",0,0) result = (ofUnicode::range *)&ofUnicode::IdeographicSpace; + SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofUnicode__range,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } static int _wrap_Unicode_Latin_get(lua_State* L) { int SWIG_arg = 0; ofUnicode::range *result = 0 ; SWIG_check_num_args("ofUnicode::Latin",0,0) result = (ofUnicode::range *)&ofUnicode::Latin; SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofUnicode__range,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); @@ -35532,6 +36344,10 @@ static int _wrap_Unicode_Latin1Supplement_get(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofUnicode::Latin1Supplement",0,0) result = (ofUnicode::range *)&ofUnicode::Latin1Supplement; SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofUnicode__range,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Unicode_LatinA_get(lua_State* L) { int SWIG_arg = 0; ofUnicode::range *result = 0 ; + SWIG_check_num_args("ofUnicode::LatinA",0,0) result = (ofUnicode::range *)&ofUnicode::LatinA; + SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofUnicode__range,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } static int _wrap_Unicode_Greek_get(lua_State* L) { int SWIG_arg = 0; ofUnicode::range *result = 0 ; SWIG_check_num_args("ofUnicode::Greek",0,0) result = (ofUnicode::range *)&ofUnicode::Greek; SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofUnicode__range,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); @@ -35709,6 +36525,27 @@ static int _wrap_Unicode_TransportAndMap_get(lua_State* L) { int SWIG_arg = 0; o SWIG_check_num_args("ofUnicode::TransportAndMap",0,0) result = (ofUnicode::range *)&ofUnicode::TransportAndMap; SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofUnicode__range,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Unicode_EnclosedCharacters_get(lua_State* L) { int SWIG_arg = 0; ofUnicode::range *result = 0 ; + SWIG_check_num_args("ofUnicode::EnclosedCharacters",0,0) result = (ofUnicode::range *)&ofUnicode::EnclosedCharacters; + SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofUnicode__range,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_Unicode_Uncategorized_get(lua_State* L) { int SWIG_arg = 0; ofUnicode::range *result = 0 ; + SWIG_check_num_args("ofUnicode::Uncategorized",0,0) result = (ofUnicode::range *)&ofUnicode::Uncategorized; + SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofUnicode__range,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_Unicode_AdditionalEmoticons_get(lua_State* L) { int SWIG_arg = 0; ofUnicode::range *result = 0 ; + SWIG_check_num_args("ofUnicode::AdditionalEmoticons",0,0) result = (ofUnicode::range *)&ofUnicode::AdditionalEmoticons; + SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofUnicode__range,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_Unicode_AdditionalTransportAndMap_get(lua_State* L) { int SWIG_arg = 0; ofUnicode::range *result = 0 ; + SWIG_check_num_args("ofUnicode::AdditionalTransportAndMap",0,0) + result = (ofUnicode::range *)&ofUnicode::AdditionalTransportAndMap; + SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofUnicode__range,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_Unicode_OtherAdditionalSymbols_get(lua_State* L) { int SWIG_arg = 0; ofUnicode::range *result = 0 ; + SWIG_check_num_args("ofUnicode::OtherAdditionalSymbols",0,0) result = (ofUnicode::range *)&ofUnicode::OtherAdditionalSymbols; + SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofUnicode__range,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } static int _wrap_new_Unicode(lua_State* L) { int SWIG_arg = 0; ofUnicode *result = 0 ; SWIG_check_num_args("ofUnicode::ofUnicode",0,0) result = (ofUnicode *)new ofUnicode(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofUnicode,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); @@ -35737,8 +36574,10 @@ static swig_lua_method swig_Unicode_meta[] = { static swig_lua_attribute swig_Unicode_Sf_SwigStatic_attributes[] = { { "Space", _wrap_Unicode_Space_get, SWIG_Lua_set_immutable }, + { "IdeographicSpace", _wrap_Unicode_IdeographicSpace_get, SWIG_Lua_set_immutable }, { "Latin", _wrap_Unicode_Latin_get, SWIG_Lua_set_immutable }, { "Latin1Supplement", _wrap_Unicode_Latin1Supplement_get, SWIG_Lua_set_immutable }, + { "LatinA", _wrap_Unicode_LatinA_get, SWIG_Lua_set_immutable }, { "Greek", _wrap_Unicode_Greek_get, SWIG_Lua_set_immutable }, { "Cyrillic", _wrap_Unicode_Cyrillic_get, SWIG_Lua_set_immutable }, { "Arabic", _wrap_Unicode_Arabic_get, SWIG_Lua_set_immutable }, @@ -35782,6 +36621,11 @@ static swig_lua_attribute swig_Unicode_Sf_SwigStatic_attributes[] = { { "MiscSymbolsAndPictographs", _wrap_Unicode_MiscSymbolsAndPictographs_get, SWIG_Lua_set_immutable }, { "Emoticons", _wrap_Unicode_Emoticons_get, SWIG_Lua_set_immutable }, { "TransportAndMap", _wrap_Unicode_TransportAndMap_get, SWIG_Lua_set_immutable }, + { "EnclosedCharacters", _wrap_Unicode_EnclosedCharacters_get, SWIG_Lua_set_immutable }, + { "Uncategorized", _wrap_Unicode_Uncategorized_get, SWIG_Lua_set_immutable }, + { "AdditionalEmoticons", _wrap_Unicode_AdditionalEmoticons_get, SWIG_Lua_set_immutable }, + { "AdditionalTransportAndMap", _wrap_Unicode_AdditionalTransportAndMap_get, SWIG_Lua_set_immutable }, + { "OtherAdditionalSymbols", _wrap_Unicode_OtherAdditionalSymbols_get, SWIG_Lua_set_immutable }, {0,0,0} }; static swig_lua_const_info swig_Unicode_Sf_SwigStatic_constants[]= { @@ -35806,102 +36650,227 @@ static swig_lua_class *swig_Unicode_bases[] = {0}; static const char *swig_Unicode_base_names[] = {0}; static swig_lua_class _wrap_class_Unicode = { "Unicode", "Unicode", &SWIGTYPE_p_ofUnicode,_proxy__wrap_new_Unicode, swig_delete_Unicode, swig_Unicode_methods, swig_Unicode_attributes, &swig_Unicode_Sf_SwigStatic, swig_Unicode_meta, swig_Unicode_bases, swig_Unicode_base_names }; -static int _wrap_Alphabet_Emoji_get(lua_State* L) { int SWIG_arg = 0; std::initializer_list< ofUnicode::range > *result = 0 ; - SWIG_check_num_args("ofAlphabet::Emoji",0,0) result = (std::initializer_list< ofUnicode::range > *)&ofAlphabet::Emoji; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__initializer_listT_ofUnicode__range_t,0); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Alphabet_Japanese_get(lua_State* L) { int SWIG_arg = 0; std::initializer_list< ofUnicode::range > *result = 0 ; - SWIG_check_num_args("ofAlphabet::Japanese",0,0) result = (std::initializer_list< ofUnicode::range > *)&ofAlphabet::Japanese; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__initializer_listT_ofUnicode__range_t,0); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Alphabet_Chinese_get(lua_State* L) { int SWIG_arg = 0; std::initializer_list< ofUnicode::range > *result = 0 ; - SWIG_check_num_args("ofAlphabet::Chinese",0,0) result = (std::initializer_list< ofUnicode::range > *)&ofAlphabet::Chinese; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__initializer_listT_ofUnicode__range_t,0); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Alphabet_Korean_get(lua_State* L) { int SWIG_arg = 0; std::initializer_list< ofUnicode::range > *result = 0 ; - SWIG_check_num_args("ofAlphabet::Korean",0,0) result = (std::initializer_list< ofUnicode::range > *)&ofAlphabet::Korean; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__initializer_listT_ofUnicode__range_t,0); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Alphabet_Arabic_get(lua_State* L) { int SWIG_arg = 0; std::initializer_list< ofUnicode::range > *result = 0 ; - SWIG_check_num_args("ofAlphabet::Arabic",0,0) result = (std::initializer_list< ofUnicode::range > *)&ofAlphabet::Arabic; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__initializer_listT_ofUnicode__range_t,0); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Alphabet_Devanagari_get(lua_State* L) { int SWIG_arg = 0; - std::initializer_list< ofUnicode::range > *result = 0 ; SWIG_check_num_args("ofAlphabet::Devanagari",0,0) - result = (std::initializer_list< ofUnicode::range > *)&ofAlphabet::Devanagari; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__initializer_listT_ofUnicode__range_t,0); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Alphabet_Latin_get(lua_State* L) { int SWIG_arg = 0; std::initializer_list< ofUnicode::range > *result = 0 ; - SWIG_check_num_args("ofAlphabet::Latin",0,0) result = (std::initializer_list< ofUnicode::range > *)&ofAlphabet::Latin; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__initializer_listT_ofUnicode__range_t,0); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Alphabet_Greek_get(lua_State* L) { int SWIG_arg = 0; std::initializer_list< ofUnicode::range > *result = 0 ; - SWIG_check_num_args("ofAlphabet::Greek",0,0) result = (std::initializer_list< ofUnicode::range > *)&ofAlphabet::Greek; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__initializer_listT_ofUnicode__range_t,0); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Alphabet_Cyrillic_get(lua_State* L) { int SWIG_arg = 0; std::initializer_list< ofUnicode::range > *result = 0 ; - SWIG_check_num_args("ofAlphabet::Cyrillic",0,0) result = (std::initializer_list< ofUnicode::range > *)&ofAlphabet::Cyrillic; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__initializer_listT_ofUnicode__range_t,0); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_new_Alphabet(lua_State* L) { int SWIG_arg = 0; ofAlphabet *result = 0 ; - SWIG_check_num_args("ofAlphabet::ofAlphabet",0,0) result = (ofAlphabet *)new ofAlphabet(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofAlphabet,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static void swig_delete_Alphabet(void *obj) { -ofAlphabet *arg1 = (ofAlphabet *) obj; +static int _wrap_TrueTypeFontSettings_fontName_set(lua_State* L) { int SWIG_arg = 0; + ofTrueTypeFontSettings *arg1 = (ofTrueTypeFontSettings *) 0 ; std::filesystem::path *arg2 = (std::filesystem::path *) 0 ; + SWIG_check_num_args("ofTrueTypeFontSettings::fontName",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFontSettings::fontName",1,"ofTrueTypeFontSettings *"); + if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofTrueTypeFontSettings::fontName",2,"std::filesystem::path *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFontSettings,0))){ + SWIG_fail_ptr("TrueTypeFontSettings_fontName_set",1,SWIGTYPE_p_ofTrueTypeFontSettings); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_boost__filesystem__path,0))){ + SWIG_fail_ptr("TrueTypeFontSettings_fontName_set",2,SWIGTYPE_p_boost__filesystem__path); } + if (arg1) (arg1)->fontName = *arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_TrueTypeFontSettings_fontName_get(lua_State* L) { int SWIG_arg = 0; + ofTrueTypeFontSettings *arg1 = (ofTrueTypeFontSettings *) 0 ; std::filesystem::path *result = 0 ; + SWIG_check_num_args("ofTrueTypeFontSettings::fontName",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFontSettings::fontName",1,"ofTrueTypeFontSettings *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFontSettings,0))){ + SWIG_fail_ptr("TrueTypeFontSettings_fontName_get",1,SWIGTYPE_p_ofTrueTypeFontSettings); } + result = (std::filesystem::path *)& ((arg1)->fontName); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_boost__filesystem__path,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_TrueTypeFontSettings_fontSize_set(lua_State* L) { int SWIG_arg = 0; + ofTrueTypeFontSettings *arg1 = (ofTrueTypeFontSettings *) 0 ; int arg2 ; + SWIG_check_num_args("ofTrueTypeFontSettings::fontSize",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFontSettings::fontSize",1,"ofTrueTypeFontSettings *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTrueTypeFontSettings::fontSize",2,"int"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFontSettings,0))){ + SWIG_fail_ptr("TrueTypeFontSettings_fontSize_set",1,SWIGTYPE_p_ofTrueTypeFontSettings); } arg2 = (int)lua_tonumber(L, 2); + if (arg1) (arg1)->fontSize = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_TrueTypeFontSettings_fontSize_get(lua_State* L) { int SWIG_arg = 0; + ofTrueTypeFontSettings *arg1 = (ofTrueTypeFontSettings *) 0 ; int result; + SWIG_check_num_args("ofTrueTypeFontSettings::fontSize",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFontSettings::fontSize",1,"ofTrueTypeFontSettings *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFontSettings,0))){ + SWIG_fail_ptr("TrueTypeFontSettings_fontSize_get",1,SWIGTYPE_p_ofTrueTypeFontSettings); } + result = (int) ((arg1)->fontSize); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_TrueTypeFontSettings_antialiased_set(lua_State* L) { int SWIG_arg = 0; + ofTrueTypeFontSettings *arg1 = (ofTrueTypeFontSettings *) 0 ; bool arg2 ; + SWIG_check_num_args("ofTrueTypeFontSettings::antialiased",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFontSettings::antialiased",1,"ofTrueTypeFontSettings *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("ofTrueTypeFontSettings::antialiased",2,"bool"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFontSettings,0))){ + SWIG_fail_ptr("TrueTypeFontSettings_antialiased_set",1,SWIGTYPE_p_ofTrueTypeFontSettings); } + arg2 = (lua_toboolean(L, 2)!=0); if (arg1) (arg1)->antialiased = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_TrueTypeFontSettings_antialiased_get(lua_State* L) { int SWIG_arg = 0; + ofTrueTypeFontSettings *arg1 = (ofTrueTypeFontSettings *) 0 ; bool result; + SWIG_check_num_args("ofTrueTypeFontSettings::antialiased",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFontSettings::antialiased",1,"ofTrueTypeFontSettings *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFontSettings,0))){ + SWIG_fail_ptr("TrueTypeFontSettings_antialiased_get",1,SWIGTYPE_p_ofTrueTypeFontSettings); } + result = (bool) ((arg1)->antialiased); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; + fail: lua_error(L); return SWIG_arg; } +static int _wrap_TrueTypeFontSettings_contours_set(lua_State* L) { int SWIG_arg = 0; + ofTrueTypeFontSettings *arg1 = (ofTrueTypeFontSettings *) 0 ; bool arg2 ; + SWIG_check_num_args("ofTrueTypeFontSettings::contours",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFontSettings::contours",1,"ofTrueTypeFontSettings *"); + if(!lua_isboolean(L,2)) SWIG_fail_arg("ofTrueTypeFontSettings::contours",2,"bool"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFontSettings,0))){ + SWIG_fail_ptr("TrueTypeFontSettings_contours_set",1,SWIGTYPE_p_ofTrueTypeFontSettings); } arg2 = (lua_toboolean(L, 2)!=0); + if (arg1) (arg1)->contours = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_TrueTypeFontSettings_contours_get(lua_State* L) { int SWIG_arg = 0; + ofTrueTypeFontSettings *arg1 = (ofTrueTypeFontSettings *) 0 ; bool result; + SWIG_check_num_args("ofTrueTypeFontSettings::contours",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFontSettings::contours",1,"ofTrueTypeFontSettings *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFontSettings,0))){ + SWIG_fail_ptr("TrueTypeFontSettings_contours_get",1,SWIGTYPE_p_ofTrueTypeFontSettings); } + result = (bool) ((arg1)->contours); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_TrueTypeFontSettings_simplifyAmt_set(lua_State* L) { int SWIG_arg = 0; + ofTrueTypeFontSettings *arg1 = (ofTrueTypeFontSettings *) 0 ; float arg2 ; + SWIG_check_num_args("ofTrueTypeFontSettings::simplifyAmt",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFontSettings::simplifyAmt",1,"ofTrueTypeFontSettings *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTrueTypeFontSettings::simplifyAmt",2,"float"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFontSettings,0))){ + SWIG_fail_ptr("TrueTypeFontSettings_simplifyAmt_set",1,SWIGTYPE_p_ofTrueTypeFontSettings); } + arg2 = (float)lua_tonumber(L, 2); if (arg1) (arg1)->simplifyAmt = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_TrueTypeFontSettings_simplifyAmt_get(lua_State* L) { int SWIG_arg = 0; + ofTrueTypeFontSettings *arg1 = (ofTrueTypeFontSettings *) 0 ; float result; + SWIG_check_num_args("ofTrueTypeFontSettings::simplifyAmt",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFontSettings::simplifyAmt",1,"ofTrueTypeFontSettings *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFontSettings,0))){ + SWIG_fail_ptr("TrueTypeFontSettings_simplifyAmt_get",1,SWIGTYPE_p_ofTrueTypeFontSettings); } + result = (float) ((arg1)->simplifyAmt); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; + fail: lua_error(L); return SWIG_arg; } +static int _wrap_TrueTypeFontSettings_dpi_set(lua_State* L) { int SWIG_arg = 0; + ofTrueTypeFontSettings *arg1 = (ofTrueTypeFontSettings *) 0 ; int arg2 ; + SWIG_check_num_args("ofTrueTypeFontSettings::dpi",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFontSettings::dpi",1,"ofTrueTypeFontSettings *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTrueTypeFontSettings::dpi",2,"int"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFontSettings,0))){ + SWIG_fail_ptr("TrueTypeFontSettings_dpi_set",1,SWIGTYPE_p_ofTrueTypeFontSettings); } arg2 = (int)lua_tonumber(L, 2); + if (arg1) (arg1)->dpi = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_TrueTypeFontSettings_dpi_get(lua_State* L) { int SWIG_arg = 0; + ofTrueTypeFontSettings *arg1 = (ofTrueTypeFontSettings *) 0 ; int result; + SWIG_check_num_args("ofTrueTypeFontSettings::dpi",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFontSettings::dpi",1,"ofTrueTypeFontSettings *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFontSettings,0))){ + SWIG_fail_ptr("TrueTypeFontSettings_dpi_get",1,SWIGTYPE_p_ofTrueTypeFontSettings); } result = (int) ((arg1)->dpi); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_TrueTypeFontSettings_direction_set(lua_State* L) { int SWIG_arg = 0; + ofTrueTypeFontSettings *arg1 = (ofTrueTypeFontSettings *) 0 ; ofTrueTypeFontDirection arg2 ; + SWIG_check_num_args("ofTrueTypeFontSettings::direction",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFontSettings::direction",1,"ofTrueTypeFontSettings *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTrueTypeFontSettings::direction",2,"ofTrueTypeFontDirection"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFontSettings,0))){ + SWIG_fail_ptr("TrueTypeFontSettings_direction_set",1,SWIGTYPE_p_ofTrueTypeFontSettings); } + arg2 = (ofTrueTypeFontDirection)(int)lua_tonumber(L, 2); if (arg1) (arg1)->direction = arg2; return SWIG_arg; if(0) SWIG_fail; + fail: lua_error(L); return SWIG_arg; } +static int _wrap_TrueTypeFontSettings_direction_get(lua_State* L) { int SWIG_arg = 0; + ofTrueTypeFontSettings *arg1 = (ofTrueTypeFontSettings *) 0 ; ofTrueTypeFontDirection result; + SWIG_check_num_args("ofTrueTypeFontSettings::direction",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFontSettings::direction",1,"ofTrueTypeFontSettings *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFontSettings,0))){ + SWIG_fail_ptr("TrueTypeFontSettings_direction_get",1,SWIGTYPE_p_ofTrueTypeFontSettings); } + result = (ofTrueTypeFontDirection) ((arg1)->direction); lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_TrueTypeFontSettings_ranges_set(lua_State* L) { int SWIG_arg = 0; + ofTrueTypeFontSettings *arg1 = (ofTrueTypeFontSettings *) 0 ; + std::vector< ofUnicode::range > *arg2 = (std::vector< ofUnicode::range > *) 0 ; + SWIG_check_num_args("ofTrueTypeFontSettings::ranges",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFontSettings::ranges",1,"ofTrueTypeFontSettings *"); + if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofTrueTypeFontSettings::ranges",2,"std::vector< ofUnicode::range > *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFontSettings,0))){ + SWIG_fail_ptr("TrueTypeFontSettings_ranges_set",1,SWIGTYPE_p_ofTrueTypeFontSettings); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__vectorT_ofUnicode__range_t,0))){ + SWIG_fail_ptr("TrueTypeFontSettings_ranges_set",2,SWIGTYPE_p_std__vectorT_ofUnicode__range_t); } + if (arg1) (arg1)->ranges = *arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_TrueTypeFontSettings_ranges_get(lua_State* L) { int SWIG_arg = 0; + ofTrueTypeFontSettings *arg1 = (ofTrueTypeFontSettings *) 0 ; std::vector< ofUnicode::range > *result = 0 ; + SWIG_check_num_args("ofTrueTypeFontSettings::ranges",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFontSettings::ranges",1,"ofTrueTypeFontSettings *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFontSettings,0))){ + SWIG_fail_ptr("TrueTypeFontSettings_ranges_get",1,SWIGTYPE_p_ofTrueTypeFontSettings); } + result = (std::vector< ofUnicode::range > *)& ((arg1)->ranges); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofUnicode__range_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; + fail: lua_error(L); return SWIG_arg; } +static int _wrap_new_TrueTypeFontSettings(lua_State* L) { int SWIG_arg = 0; std::filesystem::path *arg1 = 0 ; int arg2 ; + std::filesystem::path temp1 ; ofTrueTypeFontSettings *result = 0 ; + SWIG_check_num_args("ofTrueTypeFontSettings::ofTrueTypeFontSettings",2,2) + if(!lua_isstring(L,1)) SWIG_fail_arg("ofTrueTypeFontSettings::ofTrueTypeFontSettings",1,"std::filesystem::path const &"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTrueTypeFontSettings::ofTrueTypeFontSettings",2,"int"); { + size_t len = lua_rawlen(L, 1); temp1 = lua_tolstring(L, 1, &len); arg1 = &temp1; } arg2 = (int)lua_tonumber(L, 2); + result = (ofTrueTypeFontSettings *)new ofTrueTypeFontSettings((std::filesystem::path const &)*arg1,arg2); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTrueTypeFontSettings,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_TrueTypeFontSettings_addRange(lua_State* L) { int SWIG_arg = 0; + ofTrueTypeFontSettings *arg1 = (ofTrueTypeFontSettings *) 0 ; ofUnicode::range *arg2 = 0 ; + SWIG_check_num_args("ofTrueTypeFontSettings::addRange",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFontSettings::addRange",1,"ofTrueTypeFontSettings *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofTrueTypeFontSettings::addRange",2,"ofUnicode::range const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFontSettings,0))){ + SWIG_fail_ptr("TrueTypeFontSettings_addRange",1,SWIGTYPE_p_ofTrueTypeFontSettings); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofUnicode__range,0))){ + SWIG_fail_ptr("TrueTypeFontSettings_addRange",2,SWIGTYPE_p_ofUnicode__range); } + (arg1)->addRange((ofUnicode::range const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_TrueTypeFontSettings_addRanges(lua_State* L) { int SWIG_arg = 0; + ofTrueTypeFontSettings *arg1 = (ofTrueTypeFontSettings *) 0 ; ofAlphabetEnum arg2 ; + SWIG_check_num_args("ofTrueTypeFontSettings::addRanges",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFontSettings::addRanges",1,"ofTrueTypeFontSettings *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTrueTypeFontSettings::addRanges",2,"ofAlphabetEnum"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFontSettings,0))){ + SWIG_fail_ptr("TrueTypeFontSettings_addRanges",1,SWIGTYPE_p_ofTrueTypeFontSettings); } + arg2 = (ofAlphabetEnum)(int)lua_tonumber(L, 2); ofTrueTypeFontSettings_addRanges(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; + fail: lua_error(L); return SWIG_arg; } +static void swig_delete_TrueTypeFontSettings(void *obj) { +ofTrueTypeFontSettings *arg1 = (ofTrueTypeFontSettings *) obj; delete arg1; } -static int _proxy__wrap_new_Alphabet(lua_State *L) { +static int _proxy__wrap_new_TrueTypeFontSettings(lua_State *L) { assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_Alphabet); + lua_pushcfunction(L,_wrap_new_TrueTypeFontSettings); assert(!lua_isnil(L,-1)); lua_replace(L,1); /* replace our table with real constructor */ lua_call(L,lua_gettop(L)-1,1); return 1; } -static swig_lua_attribute swig_Alphabet_attributes[] = { +static swig_lua_attribute swig_TrueTypeFontSettings_attributes[] = { + { "fontName", _wrap_TrueTypeFontSettings_fontName_get, _wrap_TrueTypeFontSettings_fontName_set }, + { "fontSize", _wrap_TrueTypeFontSettings_fontSize_get, _wrap_TrueTypeFontSettings_fontSize_set }, + { "antialiased", _wrap_TrueTypeFontSettings_antialiased_get, _wrap_TrueTypeFontSettings_antialiased_set }, + { "contours", _wrap_TrueTypeFontSettings_contours_get, _wrap_TrueTypeFontSettings_contours_set }, + { "simplifyAmt", _wrap_TrueTypeFontSettings_simplifyAmt_get, _wrap_TrueTypeFontSettings_simplifyAmt_set }, + { "dpi", _wrap_TrueTypeFontSettings_dpi_get, _wrap_TrueTypeFontSettings_dpi_set }, + { "direction", _wrap_TrueTypeFontSettings_direction_get, _wrap_TrueTypeFontSettings_direction_set }, + { "ranges", _wrap_TrueTypeFontSettings_ranges_get, _wrap_TrueTypeFontSettings_ranges_set }, {0,0,0} }; -static swig_lua_method swig_Alphabet_methods[]= { +static swig_lua_method swig_TrueTypeFontSettings_methods[]= { + { "addRange", _wrap_TrueTypeFontSettings_addRange}, + { "addRanges", _wrap_TrueTypeFontSettings_addRanges}, {0,0} }; -static swig_lua_method swig_Alphabet_meta[] = { +static swig_lua_method swig_TrueTypeFontSettings_meta[] = { {0,0} }; -static swig_lua_attribute swig_Alphabet_Sf_SwigStatic_attributes[] = { - { "Emoji", _wrap_Alphabet_Emoji_get, SWIG_Lua_set_immutable }, - { "Japanese", _wrap_Alphabet_Japanese_get, SWIG_Lua_set_immutable }, - { "Chinese", _wrap_Alphabet_Chinese_get, SWIG_Lua_set_immutable }, - { "Korean", _wrap_Alphabet_Korean_get, SWIG_Lua_set_immutable }, - { "Arabic", _wrap_Alphabet_Arabic_get, SWIG_Lua_set_immutable }, - { "Devanagari", _wrap_Alphabet_Devanagari_get, SWIG_Lua_set_immutable }, - { "Latin", _wrap_Alphabet_Latin_get, SWIG_Lua_set_immutable }, - { "Greek", _wrap_Alphabet_Greek_get, SWIG_Lua_set_immutable }, - { "Cyrillic", _wrap_Alphabet_Cyrillic_get, SWIG_Lua_set_immutable }, +static swig_lua_attribute swig_TrueTypeFontSettings_Sf_SwigStatic_attributes[] = { {0,0,0} }; -static swig_lua_const_info swig_Alphabet_Sf_SwigStatic_constants[]= { +static swig_lua_const_info swig_TrueTypeFontSettings_Sf_SwigStatic_constants[]= { {0,0,0,0,0,0} }; -static swig_lua_method swig_Alphabet_Sf_SwigStatic_methods[]= { +static swig_lua_method swig_TrueTypeFontSettings_Sf_SwigStatic_methods[]= { {0,0} }; -static swig_lua_class* swig_Alphabet_Sf_SwigStatic_classes[]= { +static swig_lua_class* swig_TrueTypeFontSettings_Sf_SwigStatic_classes[]= { 0 }; -static swig_lua_namespace swig_Alphabet_Sf_SwigStatic = { - "Alphabet", - swig_Alphabet_Sf_SwigStatic_methods, - swig_Alphabet_Sf_SwigStatic_attributes, - swig_Alphabet_Sf_SwigStatic_constants, - swig_Alphabet_Sf_SwigStatic_classes, +static swig_lua_namespace swig_TrueTypeFontSettings_Sf_SwigStatic = { + "TrueTypeFontSettings", + swig_TrueTypeFontSettings_Sf_SwigStatic_methods, + swig_TrueTypeFontSettings_Sf_SwigStatic_attributes, + swig_TrueTypeFontSettings_Sf_SwigStatic_constants, + swig_TrueTypeFontSettings_Sf_SwigStatic_classes, 0 }; -static swig_lua_class *swig_Alphabet_bases[] = {0}; -static const char *swig_Alphabet_base_names[] = {0}; -static swig_lua_class _wrap_class_Alphabet = { "Alphabet", "Alphabet", &SWIGTYPE_p_ofAlphabet,_proxy__wrap_new_Alphabet, swig_delete_Alphabet, swig_Alphabet_methods, swig_Alphabet_attributes, &swig_Alphabet_Sf_SwigStatic, swig_Alphabet_meta, swig_Alphabet_bases, swig_Alphabet_base_names }; +static swig_lua_class *swig_TrueTypeFontSettings_bases[] = {0}; +static const char *swig_TrueTypeFontSettings_base_names[] = {0}; +static swig_lua_class _wrap_class_TrueTypeFontSettings = { "TrueTypeFontSettings", "TrueTypeFontSettings", &SWIGTYPE_p_ofTrueTypeFontSettings,_proxy__wrap_new_TrueTypeFontSettings, swig_delete_TrueTypeFontSettings, swig_TrueTypeFontSettings_methods, swig_TrueTypeFontSettings_attributes, &swig_TrueTypeFontSettings_Sf_SwigStatic, swig_TrueTypeFontSettings_meta, swig_TrueTypeFontSettings_bases, swig_TrueTypeFontSettings_base_names }; static int _wrap_new_TrueTypeFont__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofTrueTypeFont *result = 0 ; SWIG_check_num_args("ofTrueTypeFont::ofTrueTypeFont",0,0) result = (ofTrueTypeFont *)new ofTrueTypeFont(); @@ -35916,9 +36885,7 @@ static int _wrap_new_TrueTypeFont__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofTr SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTrueTypeFont,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_new_TrueTypeFont(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_TrueTypeFont__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTrueTypeFont, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_new_TrueTypeFont__SWIG_1(L);} } + return _wrap_new_TrueTypeFont__SWIG_0(L);} if (argc == 1) { return _wrap_new_TrueTypeFont__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_TrueTypeFont'\n" " Possible C/C++ prototypes are:\n" " ofTrueTypeFont::ofTrueTypeFont()\n" " ofTrueTypeFont::ofTrueTypeFont(ofTrueTypeFont &&)\n"); lua_error(L);return 0; } static int _wrap_TrueTypeFont_load__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; @@ -36007,55 +36974,28 @@ static int _wrap_TrueTypeFont_load__SWIG_5(lua_State* L) { int SWIG_arg = 0; ofT result = (bool)(arg1)->load((std::filesystem::path const &)*arg2,arg3); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_TrueTypeFont_load__SWIG_6(lua_State* L) { int SWIG_arg = 0; ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; - ofTrueTypeFont::Settings *arg2 = 0 ; bool result; SWIG_check_num_args("ofTrueTypeFont::load",2,2) + ofTrueTypeFontSettings *arg2 = 0 ; bool result; SWIG_check_num_args("ofTrueTypeFont::load",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::load",1,"ofTrueTypeFont *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofTrueTypeFont::load",2,"ofTrueTypeFont::Settings const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofTrueTypeFont::load",2,"ofTrueTypeFontSettings const &"); if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ SWIG_fail_ptr("TrueTypeFont_load",1,SWIGTYPE_p_ofTrueTypeFont); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofTrueTypeFont__Settings,0))){ - SWIG_fail_ptr("TrueTypeFont_load",2,SWIGTYPE_p_ofTrueTypeFont__Settings); } - result = (bool)(arg1)->load((ofTrueTypeFont::Settings const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofTrueTypeFontSettings,0))){ + SWIG_fail_ptr("TrueTypeFont_load",2,SWIGTYPE_p_ofTrueTypeFontSettings); } + result = (bool)(arg1)->load((ofTrueTypeFontSettings const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_TrueTypeFont_load(lua_State* L) { int argc; int argv[9]={ 1,2,3,4,5,6,7,8,9} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTrueTypeFont, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofTrueTypeFont__Settings, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_TrueTypeFont_load__SWIG_6(L);} } } if (argc == 3) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTrueTypeFont, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L, argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_TrueTypeFont_load__SWIG_5(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTrueTypeFont, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L, argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isboolean(L,argv[3]); } if (_v) { return _wrap_TrueTypeFont_load__SWIG_4(L);} } } } } - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTrueTypeFont, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L, argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isboolean(L,argv[3]); } if (_v) { { _v = lua_isboolean(L,argv[4]); } if (_v) { - return _wrap_TrueTypeFont_load__SWIG_3(L);} } } } } } if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTrueTypeFont, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L, argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isboolean(L,argv[3]); } if (_v) { { _v = lua_isboolean(L,argv[4]); } if (_v) { { - _v = lua_isboolean(L,argv[5]); } if (_v) { return _wrap_TrueTypeFont_load__SWIG_2(L);} } } } } } } - if (argc == 7) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTrueTypeFont, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L, argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isboolean(L,argv[3]); } if (_v) { { _v = lua_isboolean(L,argv[4]); } if (_v) { { - _v = lua_isboolean(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { - return _wrap_TrueTypeFont_load__SWIG_1(L);} } } } } } } } if (argc == 8) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTrueTypeFont, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L, argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isboolean(L,argv[3]); } if (_v) { { _v = lua_isboolean(L,argv[4]); } if (_v) { { - _v = lua_isboolean(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { return _wrap_TrueTypeFont_load__SWIG_0(L);} } } } } } } } - } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'TrueTypeFont_load'\n" - " Possible C/C++ prototypes are:\n" " ofTrueTypeFont::load(std::filesystem::path const &,int,bool,bool,bool,float,int)\n" + if (argc == 2) { return _wrap_TrueTypeFont_load__SWIG_6(L);} if (argc == 3) { return _wrap_TrueTypeFont_load__SWIG_5(L);} + if (argc == 4) { return _wrap_TrueTypeFont_load__SWIG_4(L);} if (argc == 5) { return _wrap_TrueTypeFont_load__SWIG_3(L);} + if (argc == 6) { return _wrap_TrueTypeFont_load__SWIG_2(L);} if (argc == 7) { return _wrap_TrueTypeFont_load__SWIG_1(L);} + if (argc == 8) { return _wrap_TrueTypeFont_load__SWIG_0(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'TrueTypeFont_load'\n" " Possible C/C++ prototypes are:\n" + " ofTrueTypeFont::load(std::filesystem::path const &,int,bool,bool,bool,float,int)\n" " ofTrueTypeFont::load(std::filesystem::path const &,int,bool,bool,bool,float)\n" " ofTrueTypeFont::load(std::filesystem::path const &,int,bool,bool,bool)\n" " ofTrueTypeFont::load(std::filesystem::path const &,int,bool,bool)\n" " ofTrueTypeFont::load(std::filesystem::path const &,int,bool)\n" - " ofTrueTypeFont::load(std::filesystem::path const &,int)\n" - " ofTrueTypeFont::load(ofTrueTypeFont::Settings const &)\n"); lua_error(L);return 0; } + " ofTrueTypeFont::load(std::filesystem::path const &,int)\n" " ofTrueTypeFont::load(ofTrueTypeFontSettings const &)\n"); + lua_error(L);return 0; } static int _wrap_TrueTypeFont_isLoaded(lua_State* L) { int SWIG_arg = 0; ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; bool result; SWIG_check_num_args("ofTrueTypeFont::isLoaded",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::isLoaded",1,"ofTrueTypeFont const *"); @@ -36209,15 +37149,8 @@ static int _wrap_TrueTypeFont_getStringBoundingBox__SWIG_1(lua_State* L) { int S SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofRectangle,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_TrueTypeFont_getStringBoundingBox(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); - if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTrueTypeFont, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_TrueTypeFont_getStringBoundingBox__SWIG_1(L);} } } } } - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTrueTypeFont, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isboolean(L,argv[4]); } if (_v) { - return _wrap_TrueTypeFont_getStringBoundingBox__SWIG_0(L);} } } } } } + if (argc == 4) { return _wrap_TrueTypeFont_getStringBoundingBox__SWIG_1(L);} if (argc == 5) { + return _wrap_TrueTypeFont_getStringBoundingBox__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'TrueTypeFont_getStringBoundingBox'\n" " Possible C/C++ prototypes are:\n" " ofTrueTypeFont::getStringBoundingBox(std::string const &,float,float,bool) const\n" " ofTrueTypeFont::getStringBoundingBox(std::string const &,float,float) const\n"); lua_error(L);return 0; } @@ -36287,22 +37220,9 @@ static int _wrap_TrueTypeFont_getCharacterAsPoints__SWIG_2(lua_State* L) { int S SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofPath,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_TrueTypeFont_getCharacterAsPoints(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTrueTypeFont, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_uint32_t, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_TrueTypeFont_getCharacterAsPoints__SWIG_2(L);} } } if (argc == 3) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTrueTypeFont, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_uint32_t, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - return _wrap_TrueTypeFont_getCharacterAsPoints__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTrueTypeFont, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_uint32_t, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { { _v = lua_isboolean(L,argv[3]); } - if (_v) { return _wrap_TrueTypeFont_getCharacterAsPoints__SWIG_0(L);} } } } } + if (argc == 2) { return _wrap_TrueTypeFont_getCharacterAsPoints__SWIG_2(L);} if (argc == 3) { + return _wrap_TrueTypeFont_getCharacterAsPoints__SWIG_1(L);} if (argc == 4) { + return _wrap_TrueTypeFont_getCharacterAsPoints__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'TrueTypeFont_getCharacterAsPoints'\n" " Possible C/C++ prototypes are:\n" " ofTrueTypeFont::getCharacterAsPoints(uint32_t,bool,bool) const\n" " ofTrueTypeFont::getCharacterAsPoints(uint32_t,bool) const\n" @@ -36348,16 +37268,9 @@ static int _wrap_TrueTypeFont_getStringAsPoints__SWIG_2(lua_State* L) { int SWIG SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_ofPath_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_TrueTypeFont_getStringAsPoints(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTrueTypeFont, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { - return _wrap_TrueTypeFont_getStringAsPoints__SWIG_2(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTrueTypeFont, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - return _wrap_TrueTypeFont_getStringAsPoints__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTrueTypeFont, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - { _v = lua_isboolean(L,argv[3]); } if (_v) { return _wrap_TrueTypeFont_getStringAsPoints__SWIG_0(L);} } } } } + if (argc == 2) { return _wrap_TrueTypeFont_getStringAsPoints__SWIG_2(L);} if (argc == 3) { + return _wrap_TrueTypeFont_getStringAsPoints__SWIG_1(L);} if (argc == 4) { + return _wrap_TrueTypeFont_getStringAsPoints__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'TrueTypeFont_getStringAsPoints'\n" " Possible C/C++ prototypes are:\n" " ofTrueTypeFont::getStringAsPoints(std::string const &,bool,bool) const\n" " ofTrueTypeFont::getStringAsPoints(std::string const &,bool) const\n" @@ -36375,7 +37288,7 @@ static int _wrap_TrueTypeFont_getStringMesh__SWIG_0(lua_State* L) { int SWIG_arg temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (lua_toboolean(L, 5)!=0); result = (ofMesh *) &((ofTrueTypeFont const *)arg1)->getStringMesh((std::string const &)*arg2,arg3,arg4,arg5); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMesh_T_glm__vec3_glm__vec3_ofColor_T_float_t_glm__vec2_t,0); SWIG_arg++; + SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_TrueTypeFont_getStringMesh__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; std::string *arg2 = 0 ; float arg3 ; float arg4 ; std::string temp2 ; @@ -36389,18 +37302,11 @@ static int _wrap_TrueTypeFont_getStringMesh__SWIG_1(lua_State* L) { int SWIG_arg temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); result = (ofMesh *) &((ofTrueTypeFont const *)arg1)->getStringMesh((std::string const &)*arg2,arg3,arg4); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMesh_T_glm__vec3_glm__vec3_ofColor_T_float_t_glm__vec2_t,0); SWIG_arg++; + SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_TrueTypeFont_getStringMesh(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); - if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTrueTypeFont, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_TrueTypeFont_getStringMesh__SWIG_1(L);} } } } } - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTrueTypeFont, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isboolean(L,argv[4]); } if (_v) { - return _wrap_TrueTypeFont_getStringMesh__SWIG_0(L);} } } } } } + if (argc == 4) { return _wrap_TrueTypeFont_getStringMesh__SWIG_1(L);} if (argc == 5) { + return _wrap_TrueTypeFont_getStringMesh__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'TrueTypeFont_getStringMesh'\n" " Possible C/C++ prototypes are:\n" " ofTrueTypeFont::getStringMesh(std::string const &,float,float,bool) const\n" " ofTrueTypeFont::getStringMesh(std::string const &,float,float) const\n"); lua_error(L);return 0; } @@ -36438,13 +37344,8 @@ static int _wrap_TrueTypeFont_getStringTexture__SWIG_1(lua_State* L) { int SWIG_ SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofTexture,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_TrueTypeFont_getStringTexture(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTrueTypeFont, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { - return _wrap_TrueTypeFont_getStringTexture__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTrueTypeFont, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - return _wrap_TrueTypeFont_getStringTexture__SWIG_0(L);} } } } + if (argc == 2) { return _wrap_TrueTypeFont_getStringTexture__SWIG_1(L);} if (argc == 3) { + return _wrap_TrueTypeFont_getStringTexture__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'TrueTypeFont_getStringTexture'\n" " Possible C/C++ prototypes are:\n" " ofTrueTypeFont::getStringTexture(std::string const &,bool) const\n" " ofTrueTypeFont::getStringTexture(std::string const &) const\n"); lua_error(L);return 0; } @@ -36472,57 +37373,13 @@ static int _wrap_TrueTypeFont_isValidGlyph(lua_State* L) { int SWIG_arg = 0; ofT result = (bool)((ofTrueTypeFont const *)arg1)->isValidGlyph(arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_TrueTypeFont_setDirection(lua_State* L) { int SWIG_arg = 0; ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; - ofTrueTypeFont::Settings::Direction arg2 ; ofTrueTypeFont::Settings::Direction *argp2 ; - SWIG_check_num_args("ofTrueTypeFont::setDirection",2,2) + ofTrueTypeFontDirection arg2 ; SWIG_check_num_args("ofTrueTypeFont::setDirection",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::setDirection",1,"ofTrueTypeFont *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofTrueTypeFont::setDirection",2,"ofTrueTypeFont::Settings::Direction"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTrueTypeFont::setDirection",2,"ofTrueTypeFontDirection"); if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ SWIG_fail_ptr("TrueTypeFont_setDirection",1,SWIGTYPE_p_ofTrueTypeFont); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofTrueTypeFont__Settings__Direction,0))){ - SWIG_fail_ptr("TrueTypeFont_setDirection",2,SWIGTYPE_p_ofTrueTypeFont__Settings__Direction); } arg2 = *argp2; - (arg1)->setDirection(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_lineHeight_set(lua_State* L) { int SWIG_arg = 0; ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; - float arg2 ; SWIG_check_num_args("ofTrueTypeFont::lineHeight",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::lineHeight",1,"ofTrueTypeFont *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTrueTypeFont::lineHeight",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_lineHeight_set",1,SWIGTYPE_p_ofTrueTypeFont); } arg2 = (float)lua_tonumber(L, 2); - ofTrueTypeFont_lineHeight_set(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_lineHeight_get(lua_State* L) { int SWIG_arg = 0; ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; - float result; SWIG_check_num_args("ofTrueTypeFont::lineHeight",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::lineHeight",1,"ofTrueTypeFont *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_lineHeight_get",1,SWIGTYPE_p_ofTrueTypeFont); } - result = (float)ofTrueTypeFont_lineHeight_get(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_letterSpacing_set(lua_State* L) { int SWIG_arg = 0; ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; - float arg2 ; SWIG_check_num_args("ofTrueTypeFont::letterSpacing",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::letterSpacing",1,"ofTrueTypeFont *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTrueTypeFont::letterSpacing",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_letterSpacing_set",1,SWIGTYPE_p_ofTrueTypeFont); } arg2 = (float)lua_tonumber(L, 2); - ofTrueTypeFont_letterSpacing_set(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_letterSpacing_get(lua_State* L) { int SWIG_arg = 0; ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; - float result; SWIG_check_num_args("ofTrueTypeFont::letterSpacing",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::letterSpacing",1,"ofTrueTypeFont *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_letterSpacing_get",1,SWIGTYPE_p_ofTrueTypeFont); } - result = (float)ofTrueTypeFont_letterSpacing_get(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_spaceSize_set(lua_State* L) { int SWIG_arg = 0; ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; - float arg2 ; SWIG_check_num_args("ofTrueTypeFont::spaceSize",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::spaceSize",1,"ofTrueTypeFont *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTrueTypeFont::spaceSize",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_spaceSize_set",1,SWIGTYPE_p_ofTrueTypeFont); } arg2 = (float)lua_tonumber(L, 2); - ofTrueTypeFont_spaceSize_set(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_spaceSize_get(lua_State* L) { int SWIG_arg = 0; ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; - float result; SWIG_check_num_args("ofTrueTypeFont::spaceSize",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::spaceSize",1,"ofTrueTypeFont *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_spaceSize_get",1,SWIGTYPE_p_ofTrueTypeFont); } - result = (float)ofTrueTypeFont_spaceSize_get(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } + arg2 = (ofTrueTypeFontDirection)(int)lua_tonumber(L, 2); (arg1)->setDirection(arg2); return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } static void swig_delete_TrueTypeFont(void *obj) { ofTrueTypeFont *arg1 = (ofTrueTypeFont *) obj; delete arg1; @@ -36536,9 +37393,6 @@ static int _proxy__wrap_new_TrueTypeFont(lua_State *L) { return 1; } static swig_lua_attribute swig_TrueTypeFont_attributes[] = { - { "lineHeight", _wrap_TrueTypeFont_lineHeight_get, _wrap_TrueTypeFont_lineHeight_set }, - { "letterSpacing", _wrap_TrueTypeFont_letterSpacing_get, _wrap_TrueTypeFont_letterSpacing_set }, - { "spaceSize", _wrap_TrueTypeFont_spaceSize_get, _wrap_TrueTypeFont_spaceSize_set }, {0,0,0} }; static swig_lua_method swig_TrueTypeFont_methods[]= { @@ -36602,66 +37456,12 @@ static swig_lua_class *swig_TrueTypeFont_bases[] = {0}; static const char *swig_TrueTypeFont_base_names[] = {0}; static swig_lua_class _wrap_class_TrueTypeFont = { "TrueTypeFont", "TrueTypeFont", &SWIGTYPE_p_ofTrueTypeFont,_proxy__wrap_new_TrueTypeFont, swig_delete_TrueTypeFont, swig_TrueTypeFont_methods, swig_TrueTypeFont_attributes, &swig_TrueTypeFont_Sf_SwigStatic, swig_TrueTypeFont_meta, swig_TrueTypeFont_bases, swig_TrueTypeFont_base_names }; -static int _wrap_soundStreamSetup__SWIG_0(lua_State* L) { int SWIG_arg = 0; int arg1 ; int arg2 ; - ofBaseApp *arg3 = (ofBaseApp *) 0 ; SWIG_check_num_args("ofSoundStreamSetup",3,3) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSoundStreamSetup",1,"int"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSoundStreamSetup",2,"int"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofSoundStreamSetup",3,"ofBaseApp *"); arg1 = (int)lua_tonumber(L, 1); - arg2 = (int)lua_tonumber(L, 2); if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofBaseApp,0))){ - SWIG_fail_ptr("soundStreamSetup",3,SWIGTYPE_p_ofBaseApp); } ofSoundStreamSetup(arg1,arg2,arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_soundStreamSetup__SWIG_1(lua_State* L) { int SWIG_arg = 0; int arg1 ; int arg2 ; - SWIG_check_num_args("ofSoundStreamSetup",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSoundStreamSetup",1,"int"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSoundStreamSetup",2,"int"); arg1 = (int)lua_tonumber(L, 1); - arg2 = (int)lua_tonumber(L, 2); ofSoundStreamSetup(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_soundStreamSetup__SWIG_2(lua_State* L) { int SWIG_arg = 0; int arg1 ; int arg2 ; int arg3 ; int arg4 ; - int arg5 ; SWIG_check_num_args("ofSoundStreamSetup",5,5) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSoundStreamSetup",1,"int"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSoundStreamSetup",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofSoundStreamSetup",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofSoundStreamSetup",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofSoundStreamSetup",5,"int"); arg1 = (int)lua_tonumber(L, 1); - arg2 = (int)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - arg5 = (int)lua_tonumber(L, 5); ofSoundStreamSetup(arg1,arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_soundStreamSetup__SWIG_3(lua_State* L) { int SWIG_arg = 0; int arg1 ; int arg2 ; - ofBaseApp *arg3 = (ofBaseApp *) 0 ; int arg4 ; int arg5 ; int arg6 ; SWIG_check_num_args("ofSoundStreamSetup",6,6) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSoundStreamSetup",1,"int"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSoundStreamSetup",2,"int"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofSoundStreamSetup",3,"ofBaseApp *"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofSoundStreamSetup",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofSoundStreamSetup",5,"int"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofSoundStreamSetup",6,"int"); arg1 = (int)lua_tonumber(L, 1); - arg2 = (int)lua_tonumber(L, 2); if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofBaseApp,0))){ - SWIG_fail_ptr("soundStreamSetup",3,SWIGTYPE_p_ofBaseApp); } arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); - arg6 = (int)lua_tonumber(L, 6); ofSoundStreamSetup(arg1,arg2,arg3,arg4,arg5,arg6); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_soundStreamSetup__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofSoundStreamSettings *arg1 = 0 ; +static int _wrap_soundStreamSetup(lua_State* L) { int SWIG_arg = 0; ofSoundStreamSettings *arg1 = 0 ; SWIG_check_num_args("ofSoundStreamSetup",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofSoundStreamSetup",1,"ofSoundStreamSettings &"); if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStreamSettings,0))){ SWIG_fail_ptr("soundStreamSetup",1,SWIGTYPE_p_ofSoundStreamSettings); } ofSoundStreamSetup(*arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_soundStreamSetup(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); - if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofSoundStreamSettings, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_soundStreamSetup__SWIG_4(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_soundStreamSetup__SWIG_1(L);} } } if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { - { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofBaseApp, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_soundStreamSetup__SWIG_0(L);} } } } if (argc == 5) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_soundStreamSetup__SWIG_2(L);} } } } } } if (argc == 6) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofBaseApp, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } - if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { return _wrap_soundStreamSetup__SWIG_3(L);} } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'soundStreamSetup'\n" " Possible C/C++ prototypes are:\n" - " ofSoundStreamSetup(int,int,ofBaseApp *)\n" " ofSoundStreamSetup(int,int)\n" - " ofSoundStreamSetup(int,int,int,int,int)\n" " ofSoundStreamSetup(int,int,ofBaseApp *,int,int,int)\n" - " ofSoundStreamSetup(ofSoundStreamSettings &)\n"); lua_error(L);return 0; } static int _wrap_soundStreamStop(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofSoundStreamStop",0,0) ofSoundStreamStop(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_soundStreamStart(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofSoundStreamStart",0,0) @@ -36679,7 +37479,7 @@ static int _wrap_new_SoundStream(lua_State* L) { int SWIG_arg = 0; ofSoundStream SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofSoundStream,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_SoundStream_setSoundStream(lua_State* L) { int SWIG_arg = 0; ofSoundStream *arg1 = (ofSoundStream *) 0 ; - std::shared_ptr< ofBaseSoundStream > arg2 ; std::shared_ptr< ofBaseSoundStream > *argp2 ; + SwigValueWrapper< std::shared_ptr< ofBaseSoundStream > > arg2 ; std::shared_ptr< ofBaseSoundStream > *argp2 ; SWIG_check_num_args("ofSoundStream::setSoundStream",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStream::setSoundStream",1,"ofSoundStream *"); if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofSoundStream::setSoundStream",2,"std::shared_ptr< ofBaseSoundStream >"); @@ -36689,7 +37489,7 @@ static int _wrap_SoundStream_setSoundStream(lua_State* L) { int SWIG_arg = 0; of SWIG_fail_ptr("SoundStream_setSoundStream",2,SWIGTYPE_p_std__shared_ptrT_ofBaseSoundStream_t); } arg2 = *argp2; (arg1)->setSoundStream(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_SoundStream_getSoundStream(lua_State* L) { int SWIG_arg = 0; ofSoundStream *arg1 = (ofSoundStream *) 0 ; - std::shared_ptr< ofBaseSoundStream > result; SWIG_check_num_args("ofSoundStream::getSoundStream",1,1) + SwigValueWrapper< std::shared_ptr< ofBaseSoundStream > > result; SWIG_check_num_args("ofSoundStream::getSoundStream",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStream::getSoundStream",1,"ofSoundStream *"); if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStream,0))){ SWIG_fail_ptr("SoundStream_getSoundStream",1,SWIGTYPE_p_ofSoundStream); } result = (arg1)->getSoundStream(); { @@ -36703,15 +37503,13 @@ static int _wrap_SoundStream_printDeviceList(lua_State* L) { int SWIG_arg = 0; o SWIG_fail_ptr("SoundStream_printDeviceList",1,SWIGTYPE_p_ofSoundStream); } ((ofSoundStream const *)arg1)->printDeviceList(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_SoundStream_getDeviceList__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofSoundStream *arg1 = (ofSoundStream *) 0 ; - ofSoundDevice::Api arg2 ; ofSoundDevice::Api *argp2 ; SwigValueWrapper< std::vector< ofSoundDevice > > result; + ofSoundDevice::Api arg2 ; SwigValueWrapper< std::vector< ofSoundDevice > > result; SWIG_check_num_args("ofSoundStream::getDeviceList",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStream::getDeviceList",1,"ofSoundStream const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofSoundStream::getDeviceList",2,"ofSoundDevice::Api"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSoundStream::getDeviceList",2,"ofSoundDevice::Api"); if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStream,0))){ SWIG_fail_ptr("SoundStream_getDeviceList",1,SWIGTYPE_p_ofSoundStream); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofSoundDevice__Api,0))){ - SWIG_fail_ptr("SoundStream_getDeviceList",2,SWIGTYPE_p_ofSoundDevice__Api); } arg2 = *argp2; - result = ((ofSoundStream const *)arg1)->getDeviceList(arg2); { + arg2 = (ofSoundDevice::Api)(int)lua_tonumber(L, 2); result = ((ofSoundStream const *)arg1)->getDeviceList(arg2); { std::vector< ofSoundDevice > * resultptr = new std::vector< ofSoundDevice >((const std::vector< ofSoundDevice > &) result); SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_ofSoundDevice_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } @@ -36725,32 +37523,26 @@ static int _wrap_SoundStream_getDeviceList__SWIG_1(lua_State* L) { int SWIG_arg SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_ofSoundDevice_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_SoundStream_getDeviceList(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); - if (argc == 1) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofSoundStream, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_SoundStream_getDeviceList__SWIG_1(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofSoundStream, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofSoundDevice__Api, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_SoundStream_getDeviceList__SWIG_0(L);} } } + if (argc == 1) { return _wrap_SoundStream_getDeviceList__SWIG_1(L);} if (argc == 2) { + return _wrap_SoundStream_getDeviceList__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SoundStream_getDeviceList'\n" " Possible C/C++ prototypes are:\n" " ofSoundStream::getDeviceList(ofSoundDevice::Api) const\n" " ofSoundStream::getDeviceList() const\n"); lua_error(L);return 0; } static int _wrap_SoundStream_getMatchingDevices__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofSoundStream *arg1 = (ofSoundStream *) 0 ; std::string *arg2 = 0 ; unsigned int arg3 ; unsigned int arg4 ; - ofSoundDevice::Api arg5 ; std::string temp2 ; ofSoundDevice::Api *argp5 ; - SwigValueWrapper< std::vector< ofSoundDevice > > result; SWIG_check_num_args("ofSoundStream::getMatchingDevices",5,5) + ofSoundDevice::Api arg5 ; std::string temp2 ; SwigValueWrapper< std::vector< ofSoundDevice > > result; + SWIG_check_num_args("ofSoundStream::getMatchingDevices",5,5) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStream::getMatchingDevices",1,"ofSoundStream const *"); if(!lua_isstring(L,2)) SWIG_fail_arg("ofSoundStream::getMatchingDevices",2,"std::string const &"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofSoundStream::getMatchingDevices",3,"unsigned int"); if(!lua_isnumber(L,4)) SWIG_fail_arg("ofSoundStream::getMatchingDevices",4,"unsigned int"); - if(!lua_isuserdata(L,5)) SWIG_fail_arg("ofSoundStream::getMatchingDevices",5,"ofSoundDevice::Api"); + if(!lua_isnumber(L,5)) SWIG_fail_arg("ofSoundStream::getMatchingDevices",5,"ofSoundDevice::Api"); if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStream,0))){ SWIG_fail_ptr("SoundStream_getMatchingDevices",1,SWIGTYPE_p_ofSoundStream); } temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (unsigned int)lua_tonumber(L, 3); SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (unsigned int)lua_tonumber(L, 4); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&argp5,SWIGTYPE_p_ofSoundDevice__Api,0))){ - SWIG_fail_ptr("SoundStream_getMatchingDevices",5,SWIGTYPE_p_ofSoundDevice__Api); } arg5 = *argp5; + arg5 = (ofSoundDevice::Api)(int)lua_tonumber(L, 5); result = ((ofSoundStream const *)arg1)->getMatchingDevices((std::string const &)*arg2,arg3,arg4,arg5); { std::vector< ofSoundDevice > * resultptr = new std::vector< ofSoundDevice >((const std::vector< ofSoundDevice > &) result); SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_ofSoundDevice_t,1); SWIG_arg++; } return SWIG_arg; @@ -36799,45 +37591,17 @@ static int _wrap_SoundStream_getMatchingDevices__SWIG_3(lua_State* L) { int SWIG SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_ofSoundDevice_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_SoundStream_getMatchingDevices(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofSoundStream, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { - return _wrap_SoundStream_getMatchingDevices__SWIG_3(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofSoundStream, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_SoundStream_getMatchingDevices__SWIG_2(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofSoundStream, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_SoundStream_getMatchingDevices__SWIG_1(L);} } } } } - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofSoundStream, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[4])==0 || SWIG_ConvertPtr(L,argv[4], (void **) &ptr, SWIGTYPE_p_ofSoundDevice__Api, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_SoundStream_getMatchingDevices__SWIG_0(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SoundStream_getMatchingDevices'\n" + if (argc == 2) { return _wrap_SoundStream_getMatchingDevices__SWIG_3(L);} if (argc == 3) { + return _wrap_SoundStream_getMatchingDevices__SWIG_2(L);} if (argc == 4) { + return _wrap_SoundStream_getMatchingDevices__SWIG_1(L);} if (argc == 5) { + return _wrap_SoundStream_getMatchingDevices__SWIG_0(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SoundStream_getMatchingDevices'\n" " Possible C/C++ prototypes are:\n" " ofSoundStream::getMatchingDevices(std::string const &,unsigned int,unsigned int,ofSoundDevice::Api) const\n" " ofSoundStream::getMatchingDevices(std::string const &,unsigned int,unsigned int) const\n" " ofSoundStream::getMatchingDevices(std::string const &,unsigned int) const\n" " ofSoundStream::getMatchingDevices(std::string const &) const\n"); lua_error(L);return 0; } -static int _wrap_SoundStream_setDeviceID(lua_State* L) { int SWIG_arg = 0; ofSoundStream *arg1 = (ofSoundStream *) 0 ; - int arg2 ; SWIG_check_num_args("ofSoundStream::setDeviceID",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStream::setDeviceID",1,"ofSoundStream *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSoundStream::setDeviceID",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStream,0))){ - SWIG_fail_ptr("SoundStream_setDeviceID",1,SWIGTYPE_p_ofSoundStream); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->setDeviceID(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundStream_setDevice(lua_State* L) { int SWIG_arg = 0; ofSoundStream *arg1 = (ofSoundStream *) 0 ; - ofSoundDevice *arg2 = 0 ; SWIG_check_num_args("ofSoundStream::setDevice",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStream::setDevice",1,"ofSoundStream *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofSoundStream::setDevice",2,"ofSoundDevice const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStream,0))){ - SWIG_fail_ptr("SoundStream_setDevice",1,SWIGTYPE_p_ofSoundStream); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofSoundDevice,0))){ - SWIG_fail_ptr("SoundStream_setDevice",2,SWIGTYPE_p_ofSoundDevice); } (arg1)->setDevice((ofSoundDevice const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundStream_setup__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofSoundStream *arg1 = (ofSoundStream *) 0 ; +static int _wrap_SoundStream_setup(lua_State* L) { int SWIG_arg = 0; ofSoundStream *arg1 = (ofSoundStream *) 0 ; ofSoundStreamSettings *arg2 = 0 ; bool result; SWIG_check_num_args("ofSoundStream::setup",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStream::setup",1,"ofSoundStream *"); if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofSoundStream::setup",2,"ofSoundStreamSettings const &"); @@ -36847,56 +37611,6 @@ static int _wrap_SoundStream_setup__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofS SWIG_fail_ptr("SoundStream_setup",2,SWIGTYPE_p_ofSoundStreamSettings); } result = (bool)(arg1)->setup((ofSoundStreamSettings const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundStream_setup__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofSoundStream *arg1 = (ofSoundStream *) 0 ; - ofBaseApp *arg2 = (ofBaseApp *) 0 ; int arg3 ; int arg4 ; int arg5 ; int arg6 ; int arg7 ; bool result; - SWIG_check_num_args("ofSoundStream::setup",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStream::setup",1,"ofSoundStream *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofSoundStream::setup",2,"ofBaseApp *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofSoundStream::setup",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofSoundStream::setup",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofSoundStream::setup",5,"int"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofSoundStream::setup",6,"int"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofSoundStream::setup",7,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStream,0))){ - SWIG_fail_ptr("SoundStream_setup",1,SWIGTYPE_p_ofSoundStream); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBaseApp,0))){ - SWIG_fail_ptr("SoundStream_setup",2,SWIGTYPE_p_ofBaseApp); } arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); arg6 = (int)lua_tonumber(L, 6); - arg7 = (int)lua_tonumber(L, 7); result = (bool)(arg1)->setup(arg2,arg3,arg4,arg5,arg6,arg7); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundStream_setup__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofSoundStream *arg1 = (ofSoundStream *) 0 ; - int arg2 ; int arg3 ; int arg4 ; int arg5 ; int arg6 ; bool result; SWIG_check_num_args("ofSoundStream::setup",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStream::setup",1,"ofSoundStream *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSoundStream::setup",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofSoundStream::setup",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofSoundStream::setup",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofSoundStream::setup",5,"int"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofSoundStream::setup",6,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStream,0))){ - SWIG_fail_ptr("SoundStream_setup",1,SWIGTYPE_p_ofSoundStream); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); - arg6 = (int)lua_tonumber(L, 6); result = (bool)(arg1)->setup(arg2,arg3,arg4,arg5,arg6); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundStream_setup(lua_State* L) { int argc; int argv[8]={ 1,2,3,4,5,6,7,8} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofSoundStream, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofSoundStreamSettings, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_SoundStream_setup__SWIG_0(L);} } } if (argc == 6) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofSoundStream, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { return _wrap_SoundStream_setup__SWIG_2(L);} } } } } } } - if (argc == 7) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofSoundStream, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBaseApp, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { { - _v = lua_isnumber(L,argv[6]); } if (_v) { return _wrap_SoundStream_setup__SWIG_1(L);} } } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SoundStream_setup'\n" " Possible C/C++ prototypes are:\n" - " ofSoundStream::setup(ofSoundStreamSettings const &)\n" " ofSoundStream::setup(ofBaseApp *,int,int,int,int,int)\n" - " ofSoundStream::setup(int,int,int,int,int)\n"); lua_error(L);return 0; } static int _wrap_SoundStream_setInput(lua_State* L) { int SWIG_arg = 0; ofSoundStream *arg1 = (ofSoundStream *) 0 ; ofBaseSoundInput *arg2 = (ofBaseSoundInput *) 0 ; SWIG_check_num_args("ofSoundStream::setInput",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStream::setInput",1,"ofSoundStream *"); @@ -36968,39 +37682,6 @@ static int _wrap_SoundStream_getBufferSize(lua_State* L) { int SWIG_arg = 0; ofS SWIG_fail_ptr("SoundStream_getBufferSize",1,SWIGTYPE_p_ofSoundStream); } result = (int)((ofSoundStream const *)arg1)->getBufferSize(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundStream_tickCount_get(lua_State* L) { int SWIG_arg = 0; ofSoundStream *arg1 = (ofSoundStream *) 0 ; - unsigned long result; SWIG_check_num_args("ofSoundStream::tickCount",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStream::tickCount",1,"ofSoundStream *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStream,0))){ - SWIG_fail_ptr("SoundStream_tickCount_get",1,SWIGTYPE_p_ofSoundStream); } - result = (unsigned long)ofSoundStream_tickCount_get(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundStream_numInputChannels_get(lua_State* L) { int SWIG_arg = 0; ofSoundStream *arg1 = (ofSoundStream *) 0 ; - int result; SWIG_check_num_args("ofSoundStream::numInputChannels",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStream::numInputChannels",1,"ofSoundStream *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStream,0))){ - SWIG_fail_ptr("SoundStream_numInputChannels_get",1,SWIGTYPE_p_ofSoundStream); } - result = (int)ofSoundStream_numInputChannels_get(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundStream_numOutputChannels_get(lua_State* L) { int SWIG_arg = 0; ofSoundStream *arg1 = (ofSoundStream *) 0 ; - int result; SWIG_check_num_args("ofSoundStream::numOutputChannels",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStream::numOutputChannels",1,"ofSoundStream *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStream,0))){ - SWIG_fail_ptr("SoundStream_numOutputChannels_get",1,SWIGTYPE_p_ofSoundStream); } - result = (int)ofSoundStream_numOutputChannels_get(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundStream_sampleRate_get(lua_State* L) { int SWIG_arg = 0; ofSoundStream *arg1 = (ofSoundStream *) 0 ; - int result; SWIG_check_num_args("ofSoundStream::sampleRate",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStream::sampleRate",1,"ofSoundStream *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStream,0))){ - SWIG_fail_ptr("SoundStream_sampleRate_get",1,SWIGTYPE_p_ofSoundStream); } result = (int)ofSoundStream_sampleRate_get(arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundStream_bufferSize_get(lua_State* L) { int SWIG_arg = 0; ofSoundStream *arg1 = (ofSoundStream *) 0 ; - int result; SWIG_check_num_args("ofSoundStream::bufferSize",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStream::bufferSize",1,"ofSoundStream *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStream,0))){ - SWIG_fail_ptr("SoundStream_bufferSize_get",1,SWIGTYPE_p_ofSoundStream); } result = (int)ofSoundStream_bufferSize_get(arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static void swig_delete_SoundStream(void *obj) { ofSoundStream *arg1 = (ofSoundStream *) obj; delete arg1; @@ -37014,11 +37695,6 @@ static int _proxy__wrap_new_SoundStream(lua_State *L) { return 1; } static swig_lua_attribute swig_SoundStream_attributes[] = { - { "tickCount", _wrap_SoundStream_tickCount_get, SWIG_Lua_set_immutable }, - { "numInputChannels", _wrap_SoundStream_numInputChannels_get, SWIG_Lua_set_immutable }, - { "numOutputChannels", _wrap_SoundStream_numOutputChannels_get, SWIG_Lua_set_immutable }, - { "sampleRate", _wrap_SoundStream_sampleRate_get, SWIG_Lua_set_immutable }, - { "bufferSize", _wrap_SoundStream_bufferSize_get, SWIG_Lua_set_immutable }, {0,0,0} }; static swig_lua_method swig_SoundStream_methods[]= { @@ -37027,8 +37703,6 @@ static swig_lua_method swig_SoundStream_methods[]= { { "printDeviceList", _wrap_SoundStream_printDeviceList}, { "getDeviceList", _wrap_SoundStream_getDeviceList}, { "getMatchingDevices", _wrap_SoundStream_getMatchingDevices}, - { "setDeviceID", _wrap_SoundStream_setDeviceID}, - { "setDevice", _wrap_SoundStream_setDevice}, { "setup", _wrap_SoundStream_setup}, { "setInput", _wrap_SoundStream_setInput}, { "setOutput", _wrap_SoundStream_setOutput}, @@ -37113,215 +37787,10 @@ static int _wrap_SoundPlayer_load__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofSo temp2 = lua_tolstring(L, 2, &len); arg2 = &temp2; } result = (bool)(arg1)->load((std::filesystem::path const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_SoundPlayer_load(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofSoundPlayer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L, argv[1]); } if (_v) { return _wrap_SoundPlayer_load__SWIG_1(L);} } - } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofSoundPlayer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L, argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } - if (_v) { return _wrap_SoundPlayer_load__SWIG_0(L);} } } } + return _wrap_SoundPlayer_load__SWIG_1(L);} if (argc == 3) { return _wrap_SoundPlayer_load__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SoundPlayer_load'\n" " Possible C/C++ prototypes are:\n" " ofSoundPlayer::load(std::filesystem::path const &,bool)\n" " ofSoundPlayer::load(std::filesystem::path const &)\n"); lua_error(L);return 0; } -static int _wrap_SoundPlayer_unload(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; - SWIG_check_num_args("ofSoundPlayer::unload",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::unload",1,"ofSoundPlayer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_unload",1,SWIGTYPE_p_ofSoundPlayer); } (arg1)->unload(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_SoundPlayer_play(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; - SWIG_check_num_args("ofSoundPlayer::play",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::play",1,"ofSoundPlayer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_play",1,SWIGTYPE_p_ofSoundPlayer); } (arg1)->play(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_SoundPlayer_stop(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; - SWIG_check_num_args("ofSoundPlayer::stop",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::stop",1,"ofSoundPlayer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_stop",1,SWIGTYPE_p_ofSoundPlayer); } (arg1)->stop(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_SoundPlayer_setVolume(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; - float arg2 ; SWIG_check_num_args("ofSoundPlayer::setVolume",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::setVolume",1,"ofSoundPlayer *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSoundPlayer::setVolume",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_setVolume",1,SWIGTYPE_p_ofSoundPlayer); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setVolume(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundPlayer_setPan(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; float arg2 ; - SWIG_check_num_args("ofSoundPlayer::setPan",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::setPan",1,"ofSoundPlayer *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSoundPlayer::setPan",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_setPan",1,SWIGTYPE_p_ofSoundPlayer); } arg2 = (float)lua_tonumber(L, 2); (arg1)->setPan(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundPlayer_setSpeed(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; float arg2 ; - SWIG_check_num_args("ofSoundPlayer::setSpeed",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::setSpeed",1,"ofSoundPlayer *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSoundPlayer::setSpeed",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_setSpeed",1,SWIGTYPE_p_ofSoundPlayer); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setSpeed(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundPlayer_setPaused(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; bool arg2 ; - SWIG_check_num_args("ofSoundPlayer::setPaused",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::setPaused",1,"ofSoundPlayer *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofSoundPlayer::setPaused",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_setPaused",1,SWIGTYPE_p_ofSoundPlayer); } arg2 = (lua_toboolean(L, 2)!=0); - (arg1)->setPaused(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundPlayer_setLoop(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; bool arg2 ; - SWIG_check_num_args("ofSoundPlayer::setLoop",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::setLoop",1,"ofSoundPlayer *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofSoundPlayer::setLoop",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_setLoop",1,SWIGTYPE_p_ofSoundPlayer); } arg2 = (lua_toboolean(L, 2)!=0); (arg1)->setLoop(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundPlayer_setMultiPlay(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; - bool arg2 ; SWIG_check_num_args("ofSoundPlayer::setMultiPlay",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::setMultiPlay",1,"ofSoundPlayer *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofSoundPlayer::setMultiPlay",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_setMultiPlay",1,SWIGTYPE_p_ofSoundPlayer); } arg2 = (lua_toboolean(L, 2)!=0); - (arg1)->setMultiPlay(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundPlayer_setPosition(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; - float arg2 ; SWIG_check_num_args("ofSoundPlayer::setPosition",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::setPosition",1,"ofSoundPlayer *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSoundPlayer::setPosition",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_setPosition",1,SWIGTYPE_p_ofSoundPlayer); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setPosition(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundPlayer_setPositionMS(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; - int arg2 ; SWIG_check_num_args("ofSoundPlayer::setPositionMS",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::setPositionMS",1,"ofSoundPlayer *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSoundPlayer::setPositionMS",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_setPositionMS",1,SWIGTYPE_p_ofSoundPlayer); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->setPositionMS(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundPlayer_getPositionMS(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; - int result; SWIG_check_num_args("ofSoundPlayer::getPositionMS",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::getPositionMS",1,"ofSoundPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_getPositionMS",1,SWIGTYPE_p_ofSoundPlayer); } - result = (int)((ofSoundPlayer const *)arg1)->getPositionMS(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundPlayer_getPosition(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; - float result; SWIG_check_num_args("ofSoundPlayer::getPosition",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::getPosition",1,"ofSoundPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_getPosition",1,SWIGTYPE_p_ofSoundPlayer); } - result = (float)((ofSoundPlayer const *)arg1)->getPosition(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundPlayer_isPlaying(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; - bool result; SWIG_check_num_args("ofSoundPlayer::isPlaying",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::isPlaying",1,"ofSoundPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_isPlaying",1,SWIGTYPE_p_ofSoundPlayer); } - result = (bool)((ofSoundPlayer const *)arg1)->isPlaying(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundPlayer_getSpeed(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; - float result; SWIG_check_num_args("ofSoundPlayer::getSpeed",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::getSpeed",1,"ofSoundPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_getSpeed",1,SWIGTYPE_p_ofSoundPlayer); } - result = (float)((ofSoundPlayer const *)arg1)->getSpeed(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundPlayer_getPan(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; float result; - SWIG_check_num_args("ofSoundPlayer::getPan",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::getPan",1,"ofSoundPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_getPan",1,SWIGTYPE_p_ofSoundPlayer); } result = (float)((ofSoundPlayer const *)arg1)->getPan(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundPlayer_getVolume(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; - float result; SWIG_check_num_args("ofSoundPlayer::getVolume",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::getVolume",1,"ofSoundPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_getVolume",1,SWIGTYPE_p_ofSoundPlayer); } - result = (float)((ofSoundPlayer const *)arg1)->getVolume(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundPlayer_isLoaded(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; bool result; - SWIG_check_num_args("ofSoundPlayer::isLoaded",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::isLoaded",1,"ofSoundPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_isLoaded",1,SWIGTYPE_p_ofSoundPlayer); } - result = (bool)((ofSoundPlayer const *)arg1)->isLoaded(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundPlayer_volume_set(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; - float arg2 ; SWIG_check_num_args("ofSoundPlayer::volume",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::volume",1,"ofSoundPlayer *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSoundPlayer::volume",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_volume_set",1,SWIGTYPE_p_ofSoundPlayer); } arg2 = (float)lua_tonumber(L, 2); - ofSoundPlayer_volume_set(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundPlayer_volume_get(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; - float result; SWIG_check_num_args("ofSoundPlayer::volume",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::volume",1,"ofSoundPlayer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_volume_get",1,SWIGTYPE_p_ofSoundPlayer); } result = (float)ofSoundPlayer_volume_get(arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundPlayer_pan_set(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; float arg2 ; - SWIG_check_num_args("ofSoundPlayer::pan",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::pan",1,"ofSoundPlayer *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSoundPlayer::pan",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_pan_set",1,SWIGTYPE_p_ofSoundPlayer); } arg2 = (float)lua_tonumber(L, 2); - ofSoundPlayer_pan_set(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundPlayer_pan_get(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; float result; - SWIG_check_num_args("ofSoundPlayer::pan",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::pan",1,"ofSoundPlayer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_pan_get",1,SWIGTYPE_p_ofSoundPlayer); } result = (float)ofSoundPlayer_pan_get(arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundPlayer_speed_set(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; - float arg2 ; SWIG_check_num_args("ofSoundPlayer::speed",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::speed",1,"ofSoundPlayer *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSoundPlayer::speed",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_speed_set",1,SWIGTYPE_p_ofSoundPlayer); } arg2 = (float)lua_tonumber(L, 2); - ofSoundPlayer_speed_set(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundPlayer_speed_get(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; - float result; SWIG_check_num_args("ofSoundPlayer::speed",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::speed",1,"ofSoundPlayer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_speed_get",1,SWIGTYPE_p_ofSoundPlayer); } result = (float)ofSoundPlayer_speed_get(arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundPlayer_position_set(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; - float arg2 ; SWIG_check_num_args("ofSoundPlayer::position",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::position",1,"ofSoundPlayer *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSoundPlayer::position",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_position_set",1,SWIGTYPE_p_ofSoundPlayer); } arg2 = (float)lua_tonumber(L, 2); - ofSoundPlayer_position_set(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundPlayer_position_get(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; - float result; SWIG_check_num_args("ofSoundPlayer::position",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::position",1,"ofSoundPlayer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_position_get",1,SWIGTYPE_p_ofSoundPlayer); } result = (float)ofSoundPlayer_position_get(arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundPlayer_positionMS_set(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; - int arg2 ; SWIG_check_num_args("ofSoundPlayer::positionMS",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::positionMS",1,"ofSoundPlayer *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSoundPlayer::positionMS",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_positionMS_set",1,SWIGTYPE_p_ofSoundPlayer); } arg2 = (int)lua_tonumber(L, 2); - ofSoundPlayer_positionMS_set(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundPlayer_positionMS_get(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; - int result; SWIG_check_num_args("ofSoundPlayer::positionMS",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::positionMS",1,"ofSoundPlayer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_positionMS_get",1,SWIGTYPE_p_ofSoundPlayer); } result = (int)ofSoundPlayer_positionMS_get(arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundPlayer_playing_get(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; - bool result; SWIG_check_num_args("ofSoundPlayer::playing",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::playing",1,"ofSoundPlayer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_playing_get",1,SWIGTYPE_p_ofSoundPlayer); } result = (bool)ofSoundPlayer_playing_get(arg1); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundPlayer_loaded_get(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; - bool result; SWIG_check_num_args("ofSoundPlayer::loaded",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::loaded",1,"ofSoundPlayer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_loaded_get",1,SWIGTYPE_p_ofSoundPlayer); } result = (bool)ofSoundPlayer_loaded_get(arg1); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static void swig_delete_SoundPlayer(void *obj) { ofSoundPlayer *arg1 = (ofSoundPlayer *) obj; delete arg1; @@ -37335,37 +37804,12 @@ static int _proxy__wrap_new_SoundPlayer(lua_State *L) { return 1; } static swig_lua_attribute swig_SoundPlayer_attributes[] = { - { "volume", _wrap_SoundPlayer_volume_get, _wrap_SoundPlayer_volume_set }, - { "pan", _wrap_SoundPlayer_pan_get, _wrap_SoundPlayer_pan_set }, - { "speed", _wrap_SoundPlayer_speed_get, _wrap_SoundPlayer_speed_set }, - { "position", _wrap_SoundPlayer_position_get, _wrap_SoundPlayer_position_set }, - { "positionMS", _wrap_SoundPlayer_positionMS_get, _wrap_SoundPlayer_positionMS_set }, - { "playing", _wrap_SoundPlayer_playing_get, SWIG_Lua_set_immutable }, - { "loaded", _wrap_SoundPlayer_loaded_get, SWIG_Lua_set_immutable }, {0,0,0} }; static swig_lua_method swig_SoundPlayer_methods[]= { { "setPlayer", _wrap_SoundPlayer_setPlayer}, { "getPlayer", _wrap_SoundPlayer_getPlayer}, { "load", _wrap_SoundPlayer_load}, - { "unload", _wrap_SoundPlayer_unload}, - { "play", _wrap_SoundPlayer_play}, - { "stop", _wrap_SoundPlayer_stop}, - { "setVolume", _wrap_SoundPlayer_setVolume}, - { "setPan", _wrap_SoundPlayer_setPan}, - { "setSpeed", _wrap_SoundPlayer_setSpeed}, - { "setPaused", _wrap_SoundPlayer_setPaused}, - { "setLoop", _wrap_SoundPlayer_setLoop}, - { "setMultiPlay", _wrap_SoundPlayer_setMultiPlay}, - { "setPosition", _wrap_SoundPlayer_setPosition}, - { "setPositionMS", _wrap_SoundPlayer_setPositionMS}, - { "getPositionMS", _wrap_SoundPlayer_getPositionMS}, - { "getPosition", _wrap_SoundPlayer_getPosition}, - { "isPlaying", _wrap_SoundPlayer_isPlaying}, - { "getSpeed", _wrap_SoundPlayer_getSpeed}, - { "getPan", _wrap_SoundPlayer_getPan}, - { "getVolume", _wrap_SoundPlayer_getVolume}, - { "isLoaded", _wrap_SoundPlayer_isLoaded}, {0,0} }; static swig_lua_method swig_SoundPlayer_meta[] = { @@ -37393,8 +37837,8 @@ static swig_lua_namespace swig_SoundPlayer_Sf_SwigStatic = { swig_SoundPlayer_Sf_SwigStatic_classes, 0 }; -static swig_lua_class *swig_SoundPlayer_bases[] = {0}; -static const char *swig_SoundPlayer_base_names[] = {0}; +static swig_lua_class *swig_SoundPlayer_bases[] = {0,0}; +static const char *swig_SoundPlayer_base_names[] = {"ofBaseSoundPlayer *",0}; static swig_lua_class _wrap_class_SoundPlayer = { "SoundPlayer", "SoundPlayer", &SWIGTYPE_p_ofSoundPlayer,_proxy__wrap_new_SoundPlayer, swig_delete_SoundPlayer, swig_SoundPlayer_methods, swig_SoundPlayer_attributes, &swig_SoundPlayer_Sf_SwigStatic, swig_SoundPlayer_meta, swig_SoundPlayer_bases, swig_SoundPlayer_base_names }; static int _wrap_new_Color__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; @@ -37444,18 +37888,14 @@ static int _wrap_new_Color__SWIG_5(lua_State* L) { int SWIG_arg = 0; ofColor_< u SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_new_Color(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_Color__SWIG_0(L);} if (argc == 1) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { - return _wrap_new_Color__SWIG_4(L);} } if (argc == 2) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_new_Color__SWIG_5(L);} } } if (argc == 2) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_new_Color__SWIG_3(L);} } } if (argc == 3) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_new_Color__SWIG_2(L);} } } } if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_new_Color__SWIG_1(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_Color'\n" " Possible C/C++ prototypes are:\n" - " ofColor_< unsigned char >::ofColor_()\n" " ofColor_< unsigned char >::ofColor_(float,float,float,float)\n" + return _wrap_new_Color__SWIG_0(L);} if (argc == 1) { return _wrap_new_Color__SWIG_4(L);} if (argc == 2) { int _v = 0; { { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; return _wrap_new_Color__SWIG_5(L);} check_3: + if (argc == 2) { return _wrap_new_Color__SWIG_3(L);} if (argc == 3) { return _wrap_new_Color__SWIG_2(L);} if (argc == 4) { + return _wrap_new_Color__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_Color'\n" + " Possible C/C++ prototypes are:\n" " ofColor_< unsigned char >::ofColor_()\n" + " ofColor_< unsigned char >::ofColor_(float,float,float,float)\n" " ofColor_< unsigned char >::ofColor_(float,float,float)\n" " ofColor_< unsigned char >::ofColor_(float,float)\n" " ofColor_< unsigned char >::ofColor_(float)\n" " ofColor_< unsigned char >::ofColor_(ofColor_< unsigned char > const &,float)\n"); lua_error(L);return 0; } @@ -37481,10 +37921,7 @@ static int _wrap_Color_fromHsb__SWIG_1(lua_State* L) { int SWIG_arg = 0; float a SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Color_fromHsb(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Color_fromHsb__SWIG_1(L);} } } } if (argc == 4) { int _v; - { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Color_fromHsb__SWIG_0(L);} } } } } + return _wrap_Color_fromHsb__SWIG_1(L);} if (argc == 4) { return _wrap_Color_fromHsb__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Color_fromHsb'\n" " Possible C/C++ prototypes are:\n" " ofColor_< unsigned char >::fromHsb(float,float,float,float)\n" " ofColor_< unsigned char >::fromHsb(float,float,float)\n"); lua_error(L);return 0; } @@ -37503,10 +37940,8 @@ static int _wrap_Color_fromHex__SWIG_1(lua_State* L) { int SWIG_arg = 0; int arg ofColor_< unsigned char > * resultptr = new ofColor_< unsigned char >((const ofColor_< unsigned char > &) result); SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_fromHex(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_Color_fromHex__SWIG_1(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Color_fromHex__SWIG_0(L);} } } +static int _wrap_Color_fromHex(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { + return _wrap_Color_fromHex__SWIG_1(L);} if (argc == 2) { return _wrap_Color_fromHex__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Color_fromHex'\n" " Possible C/C++ prototypes are:\n" " ofColor_< unsigned char >::fromHex(int,float)\n" " ofColor_< unsigned char >::fromHex(int)\n"); lua_error(L);return 0; } @@ -37561,27 +37996,12 @@ static int _wrap_Color_set__SWIG_4(lua_State* L) { int SWIG_arg = 0; if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ SWIG_fail_ptr("Color_set",2,SWIGTYPE_p_ofColor_T_unsigned_char_t); } (arg1)->set((ofColor_< unsigned char > const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_set(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 2) { int _v; - { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Color_set__SWIG_4(L);} } } if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Color_set__SWIG_3(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_Color_set__SWIG_2(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Color_set__SWIG_1(L);} } } } } - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Color_set__SWIG_0(L);} } } } } } +static int _wrap_Color_set(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_Color_set__SWIG_4(L);} check_1: + if (argc == 2) { return _wrap_Color_set__SWIG_3(L);} if (argc == 3) { return _wrap_Color_set__SWIG_2(L);} if (argc == 4) { + return _wrap_Color_set__SWIG_1(L);} if (argc == 5) { return _wrap_Color_set__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Color_set'\n" " Possible C/C++ prototypes are:\n" " ofColor_< unsigned char >::set(float,float,float,float)\n" " ofColor_< unsigned char >::set(float,float,float)\n" " ofColor_< unsigned char >::set(float,float)\n" " ofColor_< unsigned char >::set(float)\n" @@ -37604,14 +38024,8 @@ static int _wrap_Color_setHex__SWIG_1(lua_State* L) { int SWIG_arg = 0; if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ SWIG_fail_ptr("Color_setHex",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } arg2 = (int)lua_tonumber(L, 2); (arg1)->setHex(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_setHex(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { int _v; - { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Color_setHex__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_Color_setHex__SWIG_0(L);} } } } +static int _wrap_Color_setHex(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { + return _wrap_Color_setHex__SWIG_1(L);} if (argc == 3) { return _wrap_Color_setHex__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Color_setHex'\n" " Possible C/C++ prototypes are:\n" " ofColor_< unsigned char >::setHex(int,float)\n" " ofColor_< unsigned char >::setHex(int)\n"); lua_error(L);return 0; } static int _wrap_Color_setHue(lua_State* L) { int SWIG_arg = 0; @@ -37670,15 +38084,7 @@ static int _wrap_Color_setHsb__SWIG_1(lua_State* L) { int SWIG_arg = 0; arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); (arg1)->setHsb(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Color_setHsb(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 4) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Color_setHsb__SWIG_1(L);} } } } } - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Color_setHsb__SWIG_0(L);} } } } } } + return _wrap_Color_setHsb__SWIG_1(L);} if (argc == 5) { return _wrap_Color_setHsb__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Color_setHsb'\n" " Possible C/C++ prototypes are:\n" " ofColor_< unsigned char >::setHsb(float,float,float,float)\n" " ofColor_< unsigned char >::setHsb(float,float,float)\n"); lua_error(L);return 0; } @@ -37867,16 +38273,11 @@ static int _wrap_Color___add__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > * resultptr = new ofColor_< unsigned char >((const ofColor_< unsigned char > &) result); SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color___add(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Color___add__SWIG_0(L);} } } if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Color___add__SWIG_1(L);} } } +static int _wrap_Color___add(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v = 0; + { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_Color___add__SWIG_0(L);} check_1: + if (argc == 2) { return _wrap_Color___add__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Color___add'\n" " Possible C/C++ prototypes are:\n" " ofColor_< unsigned char >::operator +(ofColor_< unsigned char > const &) const\n" " ofColor_< unsigned char >::operator +(float) const\n"); lua_error(L);return 0; } @@ -37904,16 +38305,11 @@ static int _wrap_Color___sub__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > * resultptr = new ofColor_< unsigned char >((const ofColor_< unsigned char > &) result); SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color___sub(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Color___sub__SWIG_0(L);} } } if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Color___sub__SWIG_1(L);} } } +static int _wrap_Color___sub(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v = 0; + { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_Color___sub__SWIG_0(L);} check_1: + if (argc == 2) { return _wrap_Color___sub__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Color___sub'\n" " Possible C/C++ prototypes are:\n" " ofColor_< unsigned char >::operator -(ofColor_< unsigned char > const &) const\n" " ofColor_< unsigned char >::operator -(float) const\n"); lua_error(L);return 0; } @@ -37941,16 +38337,11 @@ static int _wrap_Color___mul__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > * resultptr = new ofColor_< unsigned char >((const ofColor_< unsigned char > &) result); SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color___mul(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Color___mul__SWIG_0(L);} } } if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Color___mul__SWIG_1(L);} } } +static int _wrap_Color___mul(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v = 0; + { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_Color___mul__SWIG_0(L);} check_1: + if (argc == 2) { return _wrap_Color___mul__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Color___mul'\n" " Possible C/C++ prototypes are:\n" " ofColor_< unsigned char >::operator *(ofColor_< unsigned char > const &) const\n" " ofColor_< unsigned char >::operator *(float) const\n"); lua_error(L);return 0; } @@ -37978,16 +38369,11 @@ static int _wrap_Color___div__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > * resultptr = new ofColor_< unsigned char >((const ofColor_< unsigned char > &) result); SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color___div(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Color___div__SWIG_0(L);} } } if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Color___div__SWIG_1(L);} } } +static int _wrap_Color___div(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v = 0; + { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_Color___div__SWIG_0(L);} check_1: + if (argc == 2) { return _wrap_Color___div__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Color___div'\n" " Possible C/C++ prototypes are:\n" " ofColor_< unsigned char >::operator /(ofColor_< unsigned char > const &) const\n" " ofColor_< unsigned char >::operator /(float) const\n"); lua_error(L);return 0; } @@ -39165,16 +39551,12 @@ static int _wrap_new_FloatColor__SWIG_5(lua_State* L) { int SWIG_arg = 0; ofColo SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_new_FloatColor(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_FloatColor__SWIG_0(L);} if (argc == 1) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { - return _wrap_new_FloatColor__SWIG_4(L);} } if (argc == 2) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_new_FloatColor__SWIG_5(L);} } } if (argc == 2) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_new_FloatColor__SWIG_3(L);} } } if (argc == 3) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_new_FloatColor__SWIG_2(L);} } } } if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_new_FloatColor__SWIG_1(L);} } } } } + return _wrap_new_FloatColor__SWIG_0(L);} if (argc == 1) { return _wrap_new_FloatColor__SWIG_4(L);} if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; return _wrap_new_FloatColor__SWIG_5(L);} check_3: + if (argc == 2) { return _wrap_new_FloatColor__SWIG_3(L);} if (argc == 3) { return _wrap_new_FloatColor__SWIG_2(L);} + if (argc == 4) { return _wrap_new_FloatColor__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_FloatColor'\n" " Possible C/C++ prototypes are:\n" " ofColor_< float >::ofColor_()\n" " ofColor_< float >::ofColor_(float,float,float,float)\n" " ofColor_< float >::ofColor_(float,float,float)\n" " ofColor_< float >::ofColor_(float,float)\n" @@ -39202,11 +39584,7 @@ static int _wrap_FloatColor_fromHsb__SWIG_1(lua_State* L) { int SWIG_arg = 0; fl SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_FloatColor_fromHsb(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_FloatColor_fromHsb__SWIG_1(L);} } } } if (argc == 4) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { - return _wrap_FloatColor_fromHsb__SWIG_0(L);} } } } } + return _wrap_FloatColor_fromHsb__SWIG_1(L);} if (argc == 4) { return _wrap_FloatColor_fromHsb__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatColor_fromHsb'\n" " Possible C/C++ prototypes are:\n" " ofColor_< float >::fromHsb(float,float,float,float)\n" " ofColor_< float >::fromHsb(float,float,float)\n"); lua_error(L);return 0; } @@ -39226,9 +39604,7 @@ static int _wrap_FloatColor_fromHex__SWIG_1(lua_State* L) { int SWIG_arg = 0; in SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_FloatColor_fromHex(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_FloatColor_fromHex__SWIG_1(L);} } if (argc == 2) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_FloatColor_fromHex__SWIG_0(L);} } } + return _wrap_FloatColor_fromHex__SWIG_1(L);} if (argc == 2) { return _wrap_FloatColor_fromHex__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatColor_fromHex'\n" " Possible C/C++ prototypes are:\n" " ofColor_< float >::fromHex(int,float)\n" " ofColor_< float >::fromHex(int)\n"); lua_error(L);return 0; } static int _wrap_FloatColor_set__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; @@ -39278,26 +39654,11 @@ static int _wrap_FloatColor_set__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofColo SWIG_fail_ptr("FloatColor_set",2,SWIGTYPE_p_ofColor_T_float_t); } (arg1)->set((ofColor_< float > const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_FloatColor_set(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_FloatColor_set__SWIG_4(L);} } } if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_FloatColor_set__SWIG_3(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_FloatColor_set__SWIG_2(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_FloatColor_set__SWIG_1(L);} } } } } - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_FloatColor_set__SWIG_0(L);} } } } } } + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_FloatColor_set__SWIG_4(L);} check_1: + if (argc == 2) { return _wrap_FloatColor_set__SWIG_3(L);} if (argc == 3) { return _wrap_FloatColor_set__SWIG_2(L);} + if (argc == 4) { return _wrap_FloatColor_set__SWIG_1(L);} if (argc == 5) { return _wrap_FloatColor_set__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatColor_set'\n" " Possible C/C++ prototypes are:\n" " ofColor_< float >::set(float,float,float,float)\n" " ofColor_< float >::set(float,float,float)\n" " ofColor_< float >::set(float,float)\n" " ofColor_< float >::set(float)\n" @@ -39319,13 +39680,7 @@ static int _wrap_FloatColor_setHex__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofC SWIG_fail_ptr("FloatColor_setHex",1,SWIGTYPE_p_ofColor_T_float_t); } arg2 = (int)lua_tonumber(L, 2); (arg1)->setHex(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_FloatColor_setHex(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_FloatColor_setHex__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_FloatColor_setHex__SWIG_0(L);} } } } + return _wrap_FloatColor_setHex__SWIG_1(L);} if (argc == 3) { return _wrap_FloatColor_setHex__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatColor_setHex'\n" " Possible C/C++ prototypes are:\n" " ofColor_< float >::setHex(int,float)\n" " ofColor_< float >::setHex(int)\n"); lua_error(L);return 0; } static int _wrap_FloatColor_setHue(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; @@ -39378,15 +39733,7 @@ static int _wrap_FloatColor_setHsb__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofC arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); (arg1)->setHsb(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_FloatColor_setHsb(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 4) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_FloatColor_setHsb__SWIG_1(L);} } } } } - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_FloatColor_setHsb__SWIG_0(L);} } } } } } + return _wrap_FloatColor_setHsb__SWIG_1(L);} if (argc == 5) { return _wrap_FloatColor_setHsb__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatColor_setHsb'\n" " Possible C/C++ prototypes are:\n" " ofColor_< float >::setHsb(float,float,float,float)\n" " ofColor_< float >::setHsb(float,float,float)\n"); lua_error(L);return 0; } @@ -39556,15 +39903,10 @@ static int _wrap_FloatColor___add__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofCo SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_FloatColor___add(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_FloatColor___add__SWIG_0(L);} } } if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_FloatColor___add__SWIG_1(L);} } } + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_FloatColor___add__SWIG_0(L);} check_1: + if (argc == 2) { return _wrap_FloatColor___add__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatColor___add'\n" " Possible C/C++ prototypes are:\n" " ofColor_< float >::operator +(ofColor_< float > const &) const\n" " ofColor_< float >::operator +(float) const\n"); lua_error(L);return 0; } @@ -39591,15 +39933,10 @@ static int _wrap_FloatColor___sub__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofCo SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_FloatColor___sub(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_FloatColor___sub__SWIG_0(L);} } } if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_FloatColor___sub__SWIG_1(L);} } } + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_FloatColor___sub__SWIG_0(L);} check_1: + if (argc == 2) { return _wrap_FloatColor___sub__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatColor___sub'\n" " Possible C/C++ prototypes are:\n" " ofColor_< float >::operator -(ofColor_< float > const &) const\n" " ofColor_< float >::operator -(float) const\n"); lua_error(L);return 0; } @@ -39626,15 +39963,10 @@ static int _wrap_FloatColor___mul__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofCo SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_FloatColor___mul(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_FloatColor___mul__SWIG_0(L);} } } if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_FloatColor___mul__SWIG_1(L);} } } + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_FloatColor___mul__SWIG_0(L);} check_1: + if (argc == 2) { return _wrap_FloatColor___mul__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatColor___mul'\n" " Possible C/C++ prototypes are:\n" " ofColor_< float >::operator *(ofColor_< float > const &) const\n" " ofColor_< float >::operator *(float) const\n"); lua_error(L);return 0; } @@ -39661,15 +39993,10 @@ static int _wrap_FloatColor___div__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofCo SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_FloatColor___div(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_FloatColor___div__SWIG_0(L);} } } if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_FloatColor___div__SWIG_1(L);} } } + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_FloatColor___div__SWIG_0(L);} check_1: + if (argc == 2) { return _wrap_FloatColor___div__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatColor___div'\n" " Possible C/C++ prototypes are:\n" " ofColor_< float >::operator /(ofColor_< float > const &) const\n" " ofColor_< float >::operator /(float) const\n"); lua_error(L);return 0; } @@ -40673,16 +41000,12 @@ static int _wrap_new_ShortColor__SWIG_5(lua_State* L) { int SWIG_arg = 0; ofColo SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_new_ShortColor(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_ShortColor__SWIG_0(L);} if (argc == 1) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { - return _wrap_new_ShortColor__SWIG_4(L);} } if (argc == 2) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_new_ShortColor__SWIG_5(L);} } } if (argc == 2) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_new_ShortColor__SWIG_3(L);} } } if (argc == 3) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_new_ShortColor__SWIG_2(L);} } } } if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_new_ShortColor__SWIG_1(L);} } } } } + return _wrap_new_ShortColor__SWIG_0(L);} if (argc == 1) { return _wrap_new_ShortColor__SWIG_4(L);} if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; return _wrap_new_ShortColor__SWIG_5(L);} check_3: + if (argc == 2) { return _wrap_new_ShortColor__SWIG_3(L);} if (argc == 3) { return _wrap_new_ShortColor__SWIG_2(L);} + if (argc == 4) { return _wrap_new_ShortColor__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_ShortColor'\n" " Possible C/C++ prototypes are:\n" " ofColor_< unsigned short >::ofColor_()\n" " ofColor_< unsigned short >::ofColor_(float,float,float,float)\n" " ofColor_< unsigned short >::ofColor_(float,float,float)\n" " ofColor_< unsigned short >::ofColor_(float,float)\n" @@ -40710,11 +41033,7 @@ static int _wrap_ShortColor_fromHsb__SWIG_1(lua_State* L) { int SWIG_arg = 0; fl SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_short_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_ShortColor_fromHsb(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_ShortColor_fromHsb__SWIG_1(L);} } } } if (argc == 4) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { - return _wrap_ShortColor_fromHsb__SWIG_0(L);} } } } } + return _wrap_ShortColor_fromHsb__SWIG_1(L);} if (argc == 4) { return _wrap_ShortColor_fromHsb__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortColor_fromHsb'\n" " Possible C/C++ prototypes are:\n" " ofColor_< unsigned short >::fromHsb(float,float,float,float)\n" " ofColor_< unsigned short >::fromHsb(float,float,float)\n"); lua_error(L);return 0; } @@ -40734,9 +41053,7 @@ static int _wrap_ShortColor_fromHex__SWIG_1(lua_State* L) { int SWIG_arg = 0; in SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_short_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_ShortColor_fromHex(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_ShortColor_fromHex__SWIG_1(L);} } if (argc == 2) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_ShortColor_fromHex__SWIG_0(L);} } } + return _wrap_ShortColor_fromHex__SWIG_1(L);} if (argc == 2) { return _wrap_ShortColor_fromHex__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortColor_fromHex'\n" " Possible C/C++ prototypes are:\n" " ofColor_< unsigned short >::fromHex(int,float)\n" " ofColor_< unsigned short >::fromHex(int)\n"); lua_error(L);return 0; } @@ -40793,26 +41110,11 @@ static int _wrap_ShortColor_set__SWIG_4(lua_State* L) { int SWIG_arg = 0; (arg1)->set((ofColor_< unsigned short > const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_ShortColor_set(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_ShortColor_set__SWIG_4(L);} } } if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_ShortColor_set__SWIG_3(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_ShortColor_set__SWIG_2(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_ShortColor_set__SWIG_1(L);} } } } } - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_ShortColor_set__SWIG_0(L);} } } } } } + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_ShortColor_set__SWIG_4(L);} check_1: + if (argc == 2) { return _wrap_ShortColor_set__SWIG_3(L);} if (argc == 3) { return _wrap_ShortColor_set__SWIG_2(L);} + if (argc == 4) { return _wrap_ShortColor_set__SWIG_1(L);} if (argc == 5) { return _wrap_ShortColor_set__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortColor_set'\n" " Possible C/C++ prototypes are:\n" " ofColor_< unsigned short >::set(float,float,float,float)\n" " ofColor_< unsigned short >::set(float,float,float)\n" " ofColor_< unsigned short >::set(float,float)\n" " ofColor_< unsigned short >::set(float)\n" @@ -40836,13 +41138,7 @@ static int _wrap_ShortColor_setHex__SWIG_1(lua_State* L) { int SWIG_arg = 0; SWIG_fail_ptr("ShortColor_setHex",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } arg2 = (int)lua_tonumber(L, 2); (arg1)->setHex(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_ShortColor_setHex(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_ShortColor_setHex__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_ShortColor_setHex__SWIG_0(L);} } } } + return _wrap_ShortColor_setHex__SWIG_1(L);} if (argc == 3) { return _wrap_ShortColor_setHex__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortColor_setHex'\n" " Possible C/C++ prototypes are:\n" " ofColor_< unsigned short >::setHex(int,float)\n" " ofColor_< unsigned short >::setHex(int)\n"); lua_error(L);return 0; } @@ -40902,15 +41198,7 @@ static int _wrap_ShortColor_setHsb__SWIG_1(lua_State* L) { int SWIG_arg = 0; arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); (arg1)->setHsb(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_ShortColor_setHsb(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 4) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_ShortColor_setHsb__SWIG_1(L);} } } } } - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_ShortColor_setHsb__SWIG_0(L);} } } } } } + return _wrap_ShortColor_setHsb__SWIG_1(L);} if (argc == 5) { return _wrap_ShortColor_setHsb__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortColor_setHsb'\n" " Possible C/C++ prototypes are:\n" " ofColor_< unsigned short >::setHsb(float,float,float,float)\n" " ofColor_< unsigned short >::setHsb(float,float,float)\n"); lua_error(L);return 0; } @@ -41103,15 +41391,10 @@ static int _wrap_ShortColor___add__SWIG_1(lua_State* L) { int SWIG_arg = 0; SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_short_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_ShortColor___add(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_ShortColor___add__SWIG_0(L);} } } if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_ShortColor___add__SWIG_1(L);} } } + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_ShortColor___add__SWIG_0(L);} check_1: + if (argc == 2) { return _wrap_ShortColor___add__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortColor___add'\n" " Possible C/C++ prototypes are:\n" " ofColor_< unsigned short >::operator +(ofColor_< unsigned short > const &) const\n" " ofColor_< unsigned short >::operator +(float) const\n"); lua_error(L);return 0; } @@ -41140,15 +41423,10 @@ static int _wrap_ShortColor___sub__SWIG_1(lua_State* L) { int SWIG_arg = 0; SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_short_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_ShortColor___sub(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_ShortColor___sub__SWIG_0(L);} } } if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_ShortColor___sub__SWIG_1(L);} } } + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_ShortColor___sub__SWIG_0(L);} check_1: + if (argc == 2) { return _wrap_ShortColor___sub__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortColor___sub'\n" " Possible C/C++ prototypes are:\n" " ofColor_< unsigned short >::operator -(ofColor_< unsigned short > const &) const\n" " ofColor_< unsigned short >::operator -(float) const\n"); lua_error(L);return 0; } @@ -41177,15 +41455,10 @@ static int _wrap_ShortColor___mul__SWIG_1(lua_State* L) { int SWIG_arg = 0; SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_short_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_ShortColor___mul(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_ShortColor___mul__SWIG_0(L);} } } if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_ShortColor___mul__SWIG_1(L);} } } + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_ShortColor___mul__SWIG_0(L);} check_1: + if (argc == 2) { return _wrap_ShortColor___mul__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortColor___mul'\n" " Possible C/C++ prototypes are:\n" " ofColor_< unsigned short >::operator *(ofColor_< unsigned short > const &) const\n" " ofColor_< unsigned short >::operator *(float) const\n"); lua_error(L);return 0; } @@ -41214,15 +41487,10 @@ static int _wrap_ShortColor___div__SWIG_1(lua_State* L) { int SWIG_arg = 0; SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_short_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_ShortColor___div(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_ShortColor___div__SWIG_0(L);} } } if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_ShortColor___div__SWIG_1(L);} } } + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_ShortColor___div__SWIG_0(L);} check_1: + if (argc == 2) { return _wrap_ShortColor___div__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortColor___div'\n" " Possible C/C++ prototypes are:\n" " ofColor_< unsigned short >::operator /(ofColor_< unsigned short > const &) const\n" " ofColor_< unsigned short >::operator /(float) const\n"); lua_error(L);return 0; } @@ -42419,25 +42687,16 @@ static int _wrap_new_Rectangle__SWIG_6(lua_State* L) { int SWIG_arg = 0; glm::ve SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofRectangle,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_new_Rectangle(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_Rectangle__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_new_Rectangle__SWIG_4(L);} } if (argc == 2) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_new_Rectangle__SWIG_5(L);} } } if (argc == 2) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_new_Rectangle__SWIG_6(L);} } } if (argc == 3) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_new_Rectangle__SWIG_3(L);} } } } if (argc == 3) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_new_Rectangle__SWIG_2(L);} } } } if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_new_Rectangle__SWIG_1(L);} } } } } + return _wrap_new_Rectangle__SWIG_0(L);} if (argc == 1) { return _wrap_new_Rectangle__SWIG_4(L);} if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; return _wrap_new_Rectangle__SWIG_5(L);} check_3: + if (argc == 2) { return _wrap_new_Rectangle__SWIG_6(L);} if (argc == 3) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_5; return _wrap_new_Rectangle__SWIG_3(L);} check_5: + if (argc == 3) { return _wrap_new_Rectangle__SWIG_2(L);} if (argc == 4) { return _wrap_new_Rectangle__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_Rectangle'\n" " Possible C/C++ prototypes are:\n" " ofRectangle::ofRectangle()\n" " ofRectangle::ofRectangle(float,float,float,float)\n" " ofRectangle::ofRectangle(glm::vec3 const &,float,float)\n" @@ -42513,37 +42772,15 @@ static int _wrap_Rectangle_set__SWIG_5(lua_State* L) { int SWIG_arg = 0; ofRecta SWIG_fail_ptr("Rectangle_set",3,SWIGTYPE_p_glm__vec2); } (arg1)->set((glm::vec2 const &)*arg2,(glm::vec2 const &)*arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Rectangle_set(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle_set__SWIG_3(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle_set__SWIG_4(L);} } } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_glm__vec2, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle_set__SWIG_5(L);} } } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Rectangle_set__SWIG_2(L);} } } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Rectangle_set__SWIG_1(L);} } } } } if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Rectangle_set__SWIG_0(L);} } } } } } + return _wrap_Rectangle_set__SWIG_3(L);} if (argc == 3) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; { { void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_Rectangle_set__SWIG_4(L);} check_2: + if (argc == 3) { return _wrap_Rectangle_set__SWIG_5(L);} if (argc == 4) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_4; return _wrap_Rectangle_set__SWIG_2(L);} check_4: + if (argc == 4) { return _wrap_Rectangle_set__SWIG_1(L);} if (argc == 5) { return _wrap_Rectangle_set__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Rectangle_set'\n" " Possible C/C++ prototypes are:\n" " ofRectangle::set(float,float,float,float)\n" " ofRectangle::set(glm::vec3 const &,float,float)\n" " ofRectangle::set(glm::vec2 const &,float,float)\n" " ofRectangle::set(ofRectangle const &)\n" @@ -42594,14 +42831,7 @@ static int _wrap_Rectangle_setPosition__SWIG_1(lua_State* L) { int SWIG_arg = 0; SWIG_fail_ptr("Rectangle_setPosition",2,SWIGTYPE_p_glm__vec3); } (arg1)->setPosition((glm::vec3 const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Rectangle_setPosition(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle_setPosition__SWIG_1(L);} } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_Rectangle_setPosition__SWIG_0(L);} } } } + return _wrap_Rectangle_setPosition__SWIG_1(L);} if (argc == 3) { return _wrap_Rectangle_setPosition__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Rectangle_setPosition'\n" " Possible C/C++ prototypes are:\n" " ofRectangle::setPosition(float,float)\n" " ofRectangle::setPosition(glm::vec3 const &)\n"); lua_error(L);return 0; } @@ -42650,21 +42880,11 @@ static int _wrap_Rectangle_setFromCenter__SWIG_2(lua_State* L) { int SWIG_arg = arg4 = (float)lua_tonumber(L, 4); (arg1)->setFromCenter((glm::vec2 const &)*arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Rectangle_setFromCenter(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); - if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Rectangle_setFromCenter__SWIG_1(L);} } } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Rectangle_setFromCenter__SWIG_2(L);} } } } } if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Rectangle_setFromCenter__SWIG_0(L);} } } } } } + if (argc == 4) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_Rectangle_setFromCenter__SWIG_1(L);} check_1: + if (argc == 4) { return _wrap_Rectangle_setFromCenter__SWIG_2(L);} if (argc == 5) { + return _wrap_Rectangle_setFromCenter__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Rectangle_setFromCenter'\n" " Possible C/C++ prototypes are:\n" " ofRectangle::setFromCenter(float,float,float,float)\n" " ofRectangle::setFromCenter(glm::vec3 const &,float,float)\n" @@ -42697,19 +42917,11 @@ static int _wrap_Rectangle_translate__SWIG_2(lua_State* L) { int SWIG_arg = 0; o SWIG_fail_ptr("Rectangle_translate",2,SWIGTYPE_p_glm__vec2); } (arg1)->translate((glm::vec2 const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Rectangle_translate(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle_translate__SWIG_1(L);} } } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle_translate__SWIG_2(L);} } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_Rectangle_translate__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Rectangle_translate'\n" + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_Rectangle_translate__SWIG_1(L);} check_1: + if (argc == 2) { return _wrap_Rectangle_translate__SWIG_2(L);} if (argc == 3) { return _wrap_Rectangle_translate__SWIG_0(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Rectangle_translate'\n" " Possible C/C++ prototypes are:\n" " ofRectangle::translate(float,float)\n" " ofRectangle::translate(glm::vec3 const &)\n" " ofRectangle::translate(glm::vec2 const &)\n"); lua_error(L);return 0; } static int _wrap_Rectangle_translateX(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float arg2 ; @@ -42760,21 +42972,13 @@ static int _wrap_Rectangle_scale__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofRec SWIG_fail_ptr("Rectangle_scale",2,SWIGTYPE_p_glm__vec2); } (arg1)->scale((glm::vec2 const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Rectangle_scale(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle_scale__SWIG_2(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle_scale__SWIG_3(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Rectangle_scale__SWIG_0(L);} } - } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Rectangle_scale__SWIG_1(L);} } } } + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_Rectangle_scale__SWIG_2(L);} check_1: + if (argc == 2) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_Rectangle_scale__SWIG_3(L);} check_2: + if (argc == 2) { return _wrap_Rectangle_scale__SWIG_0(L);} if (argc == 3) { return _wrap_Rectangle_scale__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Rectangle_scale'\n" " Possible C/C++ prototypes are:\n" " ofRectangle::scale(float)\n" " ofRectangle::scale(float,float)\n" " ofRectangle::scale(glm::vec3 const &)\n" " ofRectangle::scale(glm::vec2 const &)\n"); lua_error(L);return 0; } @@ -42827,21 +43031,14 @@ static int _wrap_Rectangle_scaleFromCenter__SWIG_3(lua_State* L) { int SWIG_arg SWIG_fail_ptr("Rectangle_scaleFromCenter",2,SWIGTYPE_p_glm__vec2); } (arg1)->scaleFromCenter((glm::vec2 const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Rectangle_scaleFromCenter(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle_scaleFromCenter__SWIG_2(L);} } } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle_scaleFromCenter__SWIG_3(L);} } } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Rectangle_scaleFromCenter__SWIG_0(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Rectangle_scaleFromCenter__SWIG_1(L);} } } } + if (argc == 2) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_Rectangle_scaleFromCenter__SWIG_2(L);} check_1: + if (argc == 2) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_Rectangle_scaleFromCenter__SWIG_3(L);} check_2: + if (argc == 2) { return _wrap_Rectangle_scaleFromCenter__SWIG_0(L);} if (argc == 3) { + return _wrap_Rectangle_scaleFromCenter__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Rectangle_scaleFromCenter'\n" " Possible C/C++ prototypes are:\n" " ofRectangle::scaleFromCenter(float)\n" " ofRectangle::scaleFromCenter(float,float)\n" " ofRectangle::scaleFromCenter(glm::vec3 const &)\n" @@ -42922,28 +43119,8 @@ static int _wrap_Rectangle_scaleTo__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofR (arg1)->scaleTo((ofRectangle const &)*arg2,arg3,arg4,arg5,arg6,arg7); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Rectangle_scaleTo(lua_State* L) { int argc; int argv[8]={ 1,2,3,4,5,6,7,8} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle_scaleTo__SWIG_0(L);} } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Rectangle_scaleTo__SWIG_2(L);} } } } } if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_Rectangle_scaleTo__SWIG_1(L);} } } } } } - if (argc == 7) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { { - _v = lua_isnumber(L,argv[6]); } if (_v) { return _wrap_Rectangle_scaleTo__SWIG_3(L);} } } } } } } } + if (argc == 2) { return _wrap_Rectangle_scaleTo__SWIG_0(L);} if (argc == 4) { return _wrap_Rectangle_scaleTo__SWIG_2(L);} + if (argc == 5) { return _wrap_Rectangle_scaleTo__SWIG_1(L);} if (argc == 7) { return _wrap_Rectangle_scaleTo__SWIG_3(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Rectangle_scaleTo'\n" " Possible C/C++ prototypes are:\n" " ofRectangle::scaleTo(ofRectangle const &)\n" " ofRectangle::scaleTo(ofRectangle const &,ofAspectRatioMode,ofAlignHorz,ofAlignVert)\n" @@ -42998,27 +43175,14 @@ static int _wrap_Rectangle_alignToHorz__SWIG_4(lua_State* L) { int SWIG_arg = 0; arg4 = (ofAlignHorz)(int)lua_tonumber(L, 4); (arg1)->alignToHorz((ofRectangle const &)*arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Rectangle_alignToHorz(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle_alignToHorz__SWIG_3(L);} } } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Rectangle_alignToHorz__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Rectangle_alignToHorz__SWIG_2(L);} } } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Rectangle_alignToHorz__SWIG_0(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Rectangle_alignToHorz__SWIG_4(L);} } } } } + if (argc == 2) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_Rectangle_alignToHorz__SWIG_3(L);} check_1: + if (argc == 2) { return _wrap_Rectangle_alignToHorz__SWIG_1(L);} if (argc == 3) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; return _wrap_Rectangle_alignToHorz__SWIG_2(L);} check_3: + if (argc == 3) { return _wrap_Rectangle_alignToHorz__SWIG_0(L);} if (argc == 4) { + return _wrap_Rectangle_alignToHorz__SWIG_4(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Rectangle_alignToHorz'\n" " Possible C/C++ prototypes are:\n" " ofRectangle::alignToHorz(float const &,ofAlignHorz)\n" " ofRectangle::alignToHorz(float const &)\n" " ofRectangle::alignToHorz(ofRectangle const &,ofAlignHorz)\n" @@ -43072,27 +43236,14 @@ static int _wrap_Rectangle_alignToVert__SWIG_4(lua_State* L) { int SWIG_arg = 0; arg4 = (ofAlignVert)(int)lua_tonumber(L, 4); (arg1)->alignToVert((ofRectangle const &)*arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Rectangle_alignToVert(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle_alignToVert__SWIG_3(L);} } } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Rectangle_alignToVert__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Rectangle_alignToVert__SWIG_2(L);} } } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Rectangle_alignToVert__SWIG_0(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Rectangle_alignToVert__SWIG_4(L);} } } } } + if (argc == 2) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_Rectangle_alignToVert__SWIG_3(L);} check_1: + if (argc == 2) { return _wrap_Rectangle_alignToVert__SWIG_1(L);} if (argc == 3) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; return _wrap_Rectangle_alignToVert__SWIG_2(L);} check_3: + if (argc == 3) { return _wrap_Rectangle_alignToVert__SWIG_0(L);} if (argc == 4) { + return _wrap_Rectangle_alignToVert__SWIG_4(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Rectangle_alignToVert'\n" " Possible C/C++ prototypes are:\n" " ofRectangle::alignToVert(float const &,ofAlignVert)\n" " ofRectangle::alignToVert(float const &)\n" " ofRectangle::alignToVert(ofRectangle const &,ofAlignVert)\n" @@ -43208,55 +43359,25 @@ static int _wrap_Rectangle_alignTo__SWIG_9(lua_State* L) { int SWIG_arg = 0; ofR arg6 = (ofAlignVert)(int)lua_tonumber(L, 6); (arg1)->alignTo((ofRectangle const &)*arg2,arg3,arg4,arg5,arg6); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Rectangle_alignTo(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle_alignTo__SWIG_2(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle_alignTo__SWIG_5(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle_alignTo__SWIG_8(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Rectangle_alignTo__SWIG_1(L);} - } } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Rectangle_alignTo__SWIG_7(L);} - } } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Rectangle_alignTo__SWIG_4(L);} - } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Rectangle_alignTo__SWIG_6(L);} } } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Rectangle_alignTo__SWIG_0(L);} } } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Rectangle_alignTo__SWIG_3(L);} } } } } if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { - return _wrap_Rectangle_alignTo__SWIG_9(L);} } } } } } } + if (argc == 2) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_Rectangle_alignTo__SWIG_2(L);} check_1: + if (argc == 2) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_Rectangle_alignTo__SWIG_5(L);} check_2: + if (argc == 2) { return _wrap_Rectangle_alignTo__SWIG_8(L);} if (argc == 3) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_4; return _wrap_Rectangle_alignTo__SWIG_1(L);} check_4: + if (argc == 3) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_5; return _wrap_Rectangle_alignTo__SWIG_7(L);} check_5: + if (argc == 3) { return _wrap_Rectangle_alignTo__SWIG_4(L);} if (argc == 4) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_7; return _wrap_Rectangle_alignTo__SWIG_6(L);} check_7: + if (argc == 4) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_8; return _wrap_Rectangle_alignTo__SWIG_0(L);} check_8: + if (argc == 4) { return _wrap_Rectangle_alignTo__SWIG_3(L);} if (argc == 6) { return _wrap_Rectangle_alignTo__SWIG_9(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Rectangle_alignTo'\n" " Possible C/C++ prototypes are:\n" " ofRectangle::alignTo(glm::vec3 const &,ofAlignHorz,ofAlignVert)\n" " ofRectangle::alignTo(glm::vec3 const &,ofAlignHorz)\n" " ofRectangle::alignTo(glm::vec3 const &)\n" @@ -43331,34 +43452,23 @@ static int _wrap_Rectangle_inside__SWIG_5(lua_State* L) { int SWIG_arg = 0; ofRe result = (bool)((ofRectangle const *)arg1)->inside((glm::vec2 const &)*arg2,(glm::vec2 const &)*arg3); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Rectangle_inside(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle_inside__SWIG_1(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle_inside__SWIG_2(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle_inside__SWIG_3(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle_inside__SWIG_4(L);} } } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_glm__vec2, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle_inside__SWIG_5(L);} } } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_Rectangle_inside__SWIG_0(L);} } } } + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_Rectangle_inside__SWIG_1(L);} check_1: + if (argc == 2) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_Rectangle_inside__SWIG_2(L);} check_2: + if (argc == 2) { return _wrap_Rectangle_inside__SWIG_3(L);} if (argc == 3) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_4; { { void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_4; return _wrap_Rectangle_inside__SWIG_4(L);} check_4: + if (argc == 3) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_5; { { void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_5; return _wrap_Rectangle_inside__SWIG_5(L);} check_5: + if (argc == 3) { return _wrap_Rectangle_inside__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Rectangle_inside'\n" " Possible C/C++ prototypes are:\n" " ofRectangle::inside(float,float) const\n" " ofRectangle::inside(glm::vec3 const &) const\n" " ofRectangle::inside(glm::vec2 const &) const\n" " ofRectangle::inside(ofRectangle const &) const\n" @@ -43401,23 +43511,12 @@ static int _wrap_Rectangle_intersects__SWIG_2(lua_State* L) { int SWIG_arg = 0; result = (bool)((ofRectangle const *)arg1)->intersects((glm::vec2 const &)*arg2,(glm::vec2 const &)*arg3); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Rectangle_intersects(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle_intersects__SWIG_0(L);} } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle_intersects__SWIG_1(L);} } } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_glm__vec2, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle_intersects__SWIG_2(L);} } } } + return _wrap_Rectangle_intersects__SWIG_0(L);} if (argc == 3) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; { { void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_Rectangle_intersects__SWIG_1(L);} check_2: + if (argc == 3) { return _wrap_Rectangle_intersects__SWIG_2(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Rectangle_intersects'\n" " Possible C/C++ prototypes are:\n" " ofRectangle::intersects(ofRectangle const &) const\n" " ofRectangle::intersects(glm::vec3 const &,glm::vec3 const &) const\n" @@ -43485,34 +43584,23 @@ static int _wrap_Rectangle_growToInclude__SWIG_5(lua_State* L) { int SWIG_arg = (arg1)->growToInclude((glm::vec2 const &)*arg2,(glm::vec2 const &)*arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Rectangle_growToInclude(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle_growToInclude__SWIG_1(L);} } } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle_growToInclude__SWIG_2(L);} } } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle_growToInclude__SWIG_3(L);} } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle_growToInclude__SWIG_4(L);} } } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_glm__vec2, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle_growToInclude__SWIG_5(L);} } } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_Rectangle_growToInclude__SWIG_0(L);} } } } + if (argc == 2) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_Rectangle_growToInclude__SWIG_1(L);} check_1: + if (argc == 2) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_Rectangle_growToInclude__SWIG_2(L);} check_2: + if (argc == 2) { return _wrap_Rectangle_growToInclude__SWIG_3(L);} if (argc == 3) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_4; { { void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_4; return _wrap_Rectangle_growToInclude__SWIG_4(L);} check_4: + if (argc == 3) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_5; { { void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_5; return _wrap_Rectangle_growToInclude__SWIG_5(L);} check_5: + if (argc == 3) { return _wrap_Rectangle_growToInclude__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Rectangle_growToInclude'\n" " Possible C/C++ prototypes are:\n" " ofRectangle::growToInclude(float,float)\n" " ofRectangle::growToInclude(glm::vec3 const &)\n" " ofRectangle::growToInclude(glm::vec2 const &)\n" @@ -43711,13 +43799,6 @@ static int _wrap_Rectangle_getPosition(lua_State* L) { int SWIG_arg = 0; ofRecta result = (glm::vec3 *) &((ofRectangle const *)arg1)->getPosition(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_glm__vec3,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_getPositionRef(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - glm::vec3 *result = 0 ; SWIG_check_num_args("ofRectangle::getPositionRef",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::getPositionRef",1,"ofRectangle *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getPositionRef",1,SWIGTYPE_p_ofRectangle); } result = (glm::vec3 *) &(arg1)->getPositionRef(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_glm__vec3,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } static int _wrap_Rectangle_getCenter(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; glm::vec3 result; SWIG_check_num_args("ofRectangle::getCenter",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::getCenter",1,"ofRectangle const *"); @@ -43774,15 +43855,11 @@ static int _wrap_Rectangle_map__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofRecta ofRectangle * resultptr = new ofRectangle((const ofRectangle &) result); SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofRectangle,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_map(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle_map__SWIG_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle_map__SWIG_1(L);} } } +static int _wrap_Rectangle_map(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_Rectangle_map__SWIG_0(L);} check_1: + if (argc == 2) { return _wrap_Rectangle_map__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Rectangle_map'\n" " Possible C/C++ prototypes are:\n" " ofRectangle::map(glm::vec2 const &) const\n" " ofRectangle::map(ofRectangle const &) const\n"); lua_error(L);return 0; } @@ -43811,15 +43888,10 @@ static int _wrap_Rectangle_mapClamp__SWIG_1(lua_State* L) { int SWIG_arg = 0; of SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofRectangle,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Rectangle_mapClamp(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle_mapClamp__SWIG_0(L);} } } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle_mapClamp__SWIG_1(L);} } } + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_Rectangle_mapClamp__SWIG_0(L);} check_1: + if (argc == 2) { return _wrap_Rectangle_mapClamp__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Rectangle_mapClamp'\n" " Possible C/C++ prototypes are:\n" " ofRectangle::mapClamp(glm::vec2 const &) const\n" " ofRectangle::mapClamp(ofRectangle const &) const\n"); lua_error(L);return 0; } @@ -43845,15 +43917,11 @@ static int _wrap_Rectangle___add__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofRec ofRectangle * resultptr = new ofRectangle((const ofRectangle &) result); SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofRectangle,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle___add(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle___add__SWIG_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle___add__SWIG_1(L);} } } +static int _wrap_Rectangle___add(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_Rectangle___add__SWIG_0(L);} check_1: + if (argc == 2) { return _wrap_Rectangle___add__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Rectangle___add'\n" " Possible C/C++ prototypes are:\n" " ofRectangle::operator +(glm::vec3 const &)\n" " ofRectangle::operator +(glm::vec2 const &)\n"); lua_error(L);return 0; } @@ -43879,15 +43947,11 @@ static int _wrap_Rectangle___sub__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofRec ofRectangle * resultptr = new ofRectangle((const ofRectangle &) result); SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofRectangle,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle___sub(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle___sub__SWIG_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle___sub__SWIG_1(L);} } } +static int _wrap_Rectangle___sub(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_Rectangle___sub__SWIG_0(L);} check_1: + if (argc == 2) { return _wrap_Rectangle___sub__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Rectangle___sub'\n" " Possible C/C++ prototypes are:\n" " ofRectangle::operator -(glm::vec3 const &)\n" " ofRectangle::operator -(glm::vec2 const &)\n"); lua_error(L);return 0; } @@ -43908,22 +43972,21 @@ static int _wrap_Rectangle_isZero(lua_State* L) { int SWIG_arg = 0; ofRectangle SWIG_fail_ptr("Rectangle_isZero",1,SWIGTYPE_p_ofRectangle); } result = (bool)((ofRectangle const *)arg1)->isZero(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Rectangle_position_set(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - glm::vec3 arg2 ; glm::vec3 *argp2 ; SWIG_check_num_args("ofRectangle::position",2,2) + glm::vec3 *arg2 = (glm::vec3 *) 0 ; SWIG_check_num_args("ofRectangle::position",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::position",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::position",2,"glm::vec3"); + if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofRectangle::position",2,"glm::vec3 *"); if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ SWIG_fail_ptr("Rectangle_position_set",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_glm__vec3,0))){ - SWIG_fail_ptr("Rectangle_position_set",2,SWIGTYPE_p_glm__vec3); } arg2 = *argp2; if (arg1) (arg1)->position = arg2; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ + SWIG_fail_ptr("Rectangle_position_set",2,SWIGTYPE_p_glm__vec3); } if (arg1) (arg1)->position = *arg2; return SWIG_arg; + if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Rectangle_position_get(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - glm::vec3 result; SWIG_check_num_args("ofRectangle::position",1,1) + glm::vec3 *result = 0 ; SWIG_check_num_args("ofRectangle::position",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::position",1,"ofRectangle *"); if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_position_get",1,SWIGTYPE_p_ofRectangle); } result = ((arg1)->position); { - glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } + SWIG_fail_ptr("Rectangle_position_get",1,SWIGTYPE_p_ofRectangle); } result = (glm::vec3 *)& ((arg1)->position); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_glm__vec3,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } static int _wrap_Rectangle_width_set(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float arg2 ; SWIG_check_num_args("ofRectangle::width",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::width",1,"ofRectangle *"); if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::width",2,"float"); @@ -44047,7 +44110,6 @@ static swig_lua_method swig_Rectangle_methods[]= { { "getHorzAnchor", _wrap_Rectangle_getHorzAnchor}, { "getVertAnchor", _wrap_Rectangle_getVertAnchor}, { "getPosition", _wrap_Rectangle_getPosition}, - { "getPositionRef", _wrap_Rectangle_getPositionRef}, { "getCenter", _wrap_Rectangle_getCenter}, { "getX", _wrap_Rectangle_getX}, { "getY", _wrap_Rectangle_getY}, @@ -44105,8 +44167,7 @@ static int _wrap_new_FpsCounter__SWIG_1(lua_State* L) { int SWIG_arg = 0; double result = (ofFpsCounter *)new ofFpsCounter(arg1); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofFpsCounter,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_new_FpsCounter(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_FpsCounter__SWIG_0(L);} if (argc == 1) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { - return _wrap_new_FpsCounter__SWIG_1(L);} } + return _wrap_new_FpsCounter__SWIG_0(L);} if (argc == 1) { return _wrap_new_FpsCounter__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_FpsCounter'\n" " Possible C/C++ prototypes are:\n" " ofFpsCounter::ofFpsCounter()\n" " ofFpsCounter::ofFpsCounter(double)\n"); lua_error(L);return 0; } static int _wrap_FpsCounter_newFrame(lua_State* L) { int SWIG_arg = 0; ofFpsCounter *arg1 = (ofFpsCounter *) 0 ; @@ -44169,31 +44230,6 @@ static int _wrap_FpsCounter_setFilterAlpha(lua_State* L) { int SWIG_arg = 0; ofF if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFpsCounter,0))){ SWIG_fail_ptr("FpsCounter_setFilterAlpha",1,SWIGTYPE_p_ofFpsCounter); } arg2 = (float)lua_tonumber(L, 2); (arg1)->setFilterAlpha(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FpsCounter_fps_get(lua_State* L) { int SWIG_arg = 0; ofFpsCounter *arg1 = (ofFpsCounter *) 0 ; double result; - SWIG_check_num_args("ofFpsCounter::fps",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFpsCounter::fps",1,"ofFpsCounter *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFpsCounter,0))){ - SWIG_fail_ptr("FpsCounter_fps_get",1,SWIGTYPE_p_ofFpsCounter); } result = (double)ofFpsCounter_fps_get(arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FpsCounter_numFrames_get(lua_State* L) { int SWIG_arg = 0; ofFpsCounter *arg1 = (ofFpsCounter *) 0 ; - uint64_t result; SWIG_check_num_args("ofFpsCounter::numFrames",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFpsCounter::numFrames",1,"ofFpsCounter *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFpsCounter,0))){ - SWIG_fail_ptr("FpsCounter_numFrames_get",1,SWIGTYPE_p_ofFpsCounter); } result = (uint64_t)ofFpsCounter_numFrames_get(arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FpsCounter_lastFrameNanos_get(lua_State* L) { int SWIG_arg = 0; ofFpsCounter *arg1 = (ofFpsCounter *) 0 ; - uint64_t result; SWIG_check_num_args("ofFpsCounter::lastFrameNanos",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFpsCounter::lastFrameNanos",1,"ofFpsCounter *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFpsCounter,0))){ - SWIG_fail_ptr("FpsCounter_lastFrameNanos_get",1,SWIGTYPE_p_ofFpsCounter); } - result = (uint64_t)ofFpsCounter_lastFrameNanos_get(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FpsCounter_lastFrameSecs_get(lua_State* L) { int SWIG_arg = 0; ofFpsCounter *arg1 = (ofFpsCounter *) 0 ; - double result; SWIG_check_num_args("ofFpsCounter::lastFrameSecs",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFpsCounter::lastFrameSecs",1,"ofFpsCounter *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFpsCounter,0))){ - SWIG_fail_ptr("FpsCounter_lastFrameSecs_get",1,SWIGTYPE_p_ofFpsCounter); } - result = (double)ofFpsCounter_lastFrameSecs_get(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static void swig_delete_FpsCounter(void *obj) { ofFpsCounter *arg1 = (ofFpsCounter *) obj; delete arg1; @@ -44207,10 +44243,6 @@ static int _proxy__wrap_new_FpsCounter(lua_State *L) { return 1; } static swig_lua_attribute swig_FpsCounter_attributes[] = { - { "fps", _wrap_FpsCounter_fps_get, SWIG_Lua_set_immutable }, - { "numFrames", _wrap_FpsCounter_numFrames_get, SWIG_Lua_set_immutable }, - { "lastFrameNanos", _wrap_FpsCounter_lastFrameNanos_get, SWIG_Lua_set_immutable }, - { "lastFrameSecs", _wrap_FpsCounter_lastFrameSecs_get, SWIG_Lua_set_immutable }, {0,0,0} }; static swig_lua_method swig_FpsCounter_methods[]= { @@ -44272,15 +44304,13 @@ static int _wrap_Xml_load__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBuffer,0))){ SWIG_fail_ptr("Xml_load",2,SWIGTYPE_p_ofBuffer); } result = (bool)(arg1)->load((ofBuffer const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_load(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXml, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBuffer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Xml_load__SWIG_1(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXml, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isstring(L, argv[1]); } if (_v) { return _wrap_Xml_load__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Xml_load'\n" " Possible C/C++ prototypes are:\n" - " ofXml::load(std::filesystem::path const &)\n" " ofXml::load(ofBuffer const &)\n"); lua_error(L);return 0; } +static int _wrap_Xml_load(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v = 0; { + { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBuffer, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_Xml_load__SWIG_1(L);} check_1: if (argc == 2) { + return _wrap_Xml_load__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Xml_load'\n" + " Possible C/C++ prototypes are:\n" " ofXml::load(std::filesystem::path const &)\n" + " ofXml::load(ofBuffer const &)\n"); lua_error(L);return 0; } static int _wrap_Xml_parse(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; std::string *arg2 = 0 ; std::string temp2 ; bool result; SWIG_check_num_args("ofXml::parse",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::parse",1,"ofXml *"); @@ -44296,6 +44326,10 @@ static int _wrap_Xml_save(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml size_t len = lua_rawlen(L, 2); temp2 = lua_tolstring(L, 2, &len); arg2 = &temp2; } result = (bool)((ofXml const *)arg1)->save((std::filesystem::path const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Xml_clear(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; SWIG_check_num_args("ofXml::clear",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::clear",1,"ofXml *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_clear",1,SWIGTYPE_p_ofXml); } + (arg1)->clear(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Xml_toString__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; std::string *arg2 = 0 ; std::string temp2 ; std::string result; SWIG_check_num_args("ofXml::toString",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::toString",1,"ofXml const *"); @@ -44310,11 +44344,8 @@ static int _wrap_Xml_toString__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofXml *a if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_toString",1,SWIGTYPE_p_ofXml); } result = ((ofXml const *)arg1)->toString(); lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_toString(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXml, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Xml_toString__SWIG_1(L);} } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXml, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { return _wrap_Xml_toString__SWIG_0(L);} } } +static int _wrap_Xml_toString(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { + return _wrap_Xml_toString__SWIG_1(L);} if (argc == 2) { return _wrap_Xml_toString__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Xml_toString'\n" " Possible C/C++ prototypes are:\n" " ofXml::toString(std::string const &) const\n" " ofXml::toString() const\n"); lua_error(L);return 0; } static int _wrap_Xml_getChild(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; std::string *arg2 = 0 ; @@ -44344,11 +44375,8 @@ static int _wrap_Xml_getChildren__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofXml ofXml::Range< ofXmlIterator< pugi::xml_named_node_iterator > > * resultptr = new ofXml::Range< ofXmlIterator< pugi::xml_named_node_iterator > >((const ofXml::Range< ofXmlIterator< pugi::xml_named_node_iterator > > &) result); SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofXml__RangeT_ofXmlIteratorT_pugi__xml_named_node_iterator_t_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_getChildren(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXml, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Xml_getChildren__SWIG_0(L);} } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXml, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { return _wrap_Xml_getChildren__SWIG_1(L);} } } +static int _wrap_Xml_getChildren(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { + return _wrap_Xml_getChildren__SWIG_0(L);} if (argc == 2) { return _wrap_Xml_getChildren__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Xml_getChildren'\n" " Possible C/C++ prototypes are:\n" " ofXml::getChildren() const\n" " ofXml::getChildren(std::string const &) const\n"); lua_error(L);return 0; } static int _wrap_Xml_appendChild__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; ofXml *arg2 = 0 ; @@ -44370,6 +44398,14 @@ static int _wrap_Xml_prependChild__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofXm ofXml * resultptr = new ofXml((const ofXml &) result); SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofXml,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Xml_removeChild__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; ofXml *arg2 = 0 ; + bool result; SWIG_check_num_args("ofXml::removeChild",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::removeChild",1,"ofXml *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofXml::removeChild",2,"ofXml const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_removeChild",1,SWIGTYPE_p_ofXml); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_removeChild",2,SWIGTYPE_p_ofXml); } + result = (bool)(arg1)->removeChild((ofXml const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; + if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Xml_appendChild__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; std::string *arg2 = 0 ; std::string temp2 ; ofXml result; SWIG_check_num_args("ofXml::appendChild",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::appendChild",1,"ofXml *"); @@ -44379,13 +44415,11 @@ static int _wrap_Xml_appendChild__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofXml ofXml * resultptr = new ofXml((const ofXml &) result); SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofXml,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_appendChild(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXml, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofXml, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_Xml_appendChild__SWIG_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXml, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { return _wrap_Xml_appendChild__SWIG_1(L);} } } +static int _wrap_Xml_appendChild(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofXml, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_Xml_appendChild__SWIG_0(L);} check_1: + if (argc == 2) { return _wrap_Xml_appendChild__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Xml_appendChild'\n" " Possible C/C++ prototypes are:\n" " ofXml::appendChild(ofXml const &)\n" " ofXml::appendChild(std::string const &)\n"); lua_error(L);return 0; } static int _wrap_Xml_prependChild__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; std::string *arg2 = 0 ; @@ -44398,21 +44432,26 @@ static int _wrap_Xml_prependChild__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofXm SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofXml,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Xml_prependChild(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXml, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofXml, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_Xml_prependChild__SWIG_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXml, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { return _wrap_Xml_prependChild__SWIG_1(L);} } } + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofXml, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_Xml_prependChild__SWIG_0(L);} check_1: + if (argc == 2) { return _wrap_Xml_prependChild__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Xml_prependChild'\n" " Possible C/C++ prototypes are:\n" " ofXml::prependChild(ofXml const &)\n" " ofXml::prependChild(std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_Xml_removeChild(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; std::string *arg2 = 0 ; +static int _wrap_Xml_removeChild__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; std::string *arg2 = 0 ; std::string temp2 ; bool result; SWIG_check_num_args("ofXml::removeChild",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::removeChild",1,"ofXml *"); if(!lua_isstring(L,2)) SWIG_fail_arg("ofXml::removeChild",2,"std::string const &"); if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_removeChild",1,SWIGTYPE_p_ofXml); } temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; result = (bool)(arg1)->removeChild((std::string const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Xml_removeChild(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofXml, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_Xml_removeChild__SWIG_0(L);} check_1: + if (argc == 2) { return _wrap_Xml_removeChild__SWIG_1(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Xml_removeChild'\n" " Possible C/C++ prototypes are:\n" + " ofXml::removeChild(ofXml const &)\n" " ofXml::removeChild(std::string const &)\n"); lua_error(L);return 0; } static int _wrap_Xml_insertChildAfter(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; std::string *arg2 = 0 ; ofXml *arg3 = 0 ; std::string temp2 ; ofXml result; SWIG_check_num_args("ofXml::insertChildAfter",3,3) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::insertChildAfter",1,"ofXml *"); @@ -44466,13 +44505,9 @@ static int _wrap_Xml_getNextSibling__SWIG_1(lua_State* L) { int SWIG_arg = 0; of SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofXml,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Xml_getNextSibling(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXml, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Xml_getNextSibling__SWIG_0(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXml, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { return _wrap_Xml_getNextSibling__SWIG_1(L);} - } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Xml_getNextSibling'\n" - " Possible C/C++ prototypes are:\n" " ofXml::getNextSibling() const\n" - " ofXml::getNextSibling(std::string const &) const\n"); lua_error(L);return 0; } + return _wrap_Xml_getNextSibling__SWIG_0(L);} if (argc == 2) { return _wrap_Xml_getNextSibling__SWIG_1(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Xml_getNextSibling'\n" " Possible C/C++ prototypes are:\n" + " ofXml::getNextSibling() const\n" " ofXml::getNextSibling(std::string const &) const\n"); lua_error(L);return 0; } static int _wrap_Xml_getPreviousSibling__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; std::string *arg2 = 0 ; std::string temp2 ; ofXml result; SWIG_check_num_args("ofXml::getPreviousSibling",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::getPreviousSibling",1,"ofXml const *"); @@ -44484,11 +44519,7 @@ static int _wrap_Xml_getPreviousSibling__SWIG_1(lua_State* L) { int SWIG_arg = 0 SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofXml,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Xml_getPreviousSibling(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXml, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Xml_getPreviousSibling__SWIG_0(L);} } if (argc == 2) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXml, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { - return _wrap_Xml_getPreviousSibling__SWIG_1(L);} } } + return _wrap_Xml_getPreviousSibling__SWIG_0(L);} if (argc == 2) { return _wrap_Xml_getPreviousSibling__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Xml_getPreviousSibling'\n" " Possible C/C++ prototypes are:\n" " ofXml::getPreviousSibling() const\n" " ofXml::getPreviousSibling(std::string const &) const\n"); lua_error(L);return 0; } @@ -44507,6 +44538,12 @@ static int _wrap_Xml_getLastChild(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 result = ((ofXml const *)arg1)->getLastChild(); { ofXml * resultptr = new ofXml((const ofXml &) result); SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofXml,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Xml_getParent(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; ofXml result; + SWIG_check_num_args("ofXml::getParent",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::getParent",1,"ofXml const *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_getParent",1,SWIGTYPE_p_ofXml); } + result = ((ofXml const *)arg1)->getParent(); { ofXml * resultptr = new ofXml((const ofXml &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofXml,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } static int _wrap_Xml_getAttribute(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; std::string *arg2 = 0 ; std::string temp2 ; ofXml::Attribute result; SWIG_check_num_args("ofXml::getAttribute",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::getAttribute",1,"ofXml const *"); @@ -44518,14 +44555,13 @@ static int _wrap_Xml_getAttribute(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofXml__Attribute,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Xml_getAttributes(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; - SwigValueWrapper< ofXml::Range< ofXmlIterator< pugi::xml_attribute_iterator > > > result; - SWIG_check_num_args("ofXml::getAttributes",1,1) + SwigValueWrapper< ofXml::Range< ofXmlAttributeIterator > > result; SWIG_check_num_args("ofXml::getAttributes",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::getAttributes",1,"ofXml const *"); if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_getAttributes",1,SWIGTYPE_p_ofXml); } result = ((ofXml const *)arg1)->getAttributes(); { - ofXml::Range< ofXmlIterator< pugi::xml_attribute_iterator > > * resultptr = new ofXml::Range< ofXmlIterator< pugi::xml_attribute_iterator > >((const ofXml::Range< ofXmlIterator< pugi::xml_attribute_iterator > > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofXml__RangeT_ofXmlIteratorT_pugi__xml_attribute_iterator_t_t,1); SWIG_arg++; } - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } + ofXml::Range< ofXmlAttributeIterator > * resultptr = new ofXml::Range< ofXmlAttributeIterator >((const ofXml::Range< ofXmlAttributeIterator > &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofXml__RangeT_ofXmlAttributeIterator_t,1); SWIG_arg++; } + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Xml_getFirstAttribute(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; ofXml::Attribute result; SWIG_check_num_args("ofXml::getFirstAttribute",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::getFirstAttribute",1,"ofXml const *"); @@ -44562,6 +44598,32 @@ static int _wrap_Xml_prependAttribute(lua_State* L) { int SWIG_arg = 0; ofXml *a ofXml::Attribute * resultptr = new ofXml::Attribute((const ofXml::Attribute &) result); SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofXml__Attribute,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Xml_removeAttribute__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; + std::string *arg2 = 0 ; std::string temp2 ; bool result; SWIG_check_num_args("ofXml::removeAttribute",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::removeAttribute",1,"ofXml *"); + if(!lua_isstring(L,2)) SWIG_fail_arg("ofXml::removeAttribute",2,"std::string const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ + SWIG_fail_ptr("Xml_removeAttribute",1,SWIGTYPE_p_ofXml); } temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; + result = (bool)(arg1)->removeAttribute((std::string const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Xml_removeAttribute__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; + ofXml::Attribute *arg2 = 0 ; bool result; SWIG_check_num_args("ofXml::removeAttribute",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::removeAttribute",1,"ofXml *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofXml::removeAttribute",2,"ofXml::Attribute const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ + SWIG_fail_ptr("Xml_removeAttribute",1,SWIGTYPE_p_ofXml); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofXml__Attribute,0))){ + SWIG_fail_ptr("Xml_removeAttribute",2,SWIGTYPE_p_ofXml__Attribute); } + result = (bool)(arg1)->removeAttribute((ofXml::Attribute const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_Xml_removeAttribute(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofXml__Attribute, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_Xml_removeAttribute__SWIG_1(L);} check_1: + if (argc == 2) { return _wrap_Xml_removeAttribute__SWIG_0(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Xml_removeAttribute'\n" + " Possible C/C++ prototypes are:\n" " ofXml::removeAttribute(std::string const &)\n" + " ofXml::removeAttribute(ofXml::Attribute const &)\n"); lua_error(L);return 0; } static int _wrap_Xml_findFirst(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; std::string *arg2 = 0 ; std::string temp2 ; ofXml result; SWIG_check_num_args("ofXml::findFirst",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::findFirst",1,"ofXml const *"); @@ -44572,16 +44634,6 @@ static int _wrap_Xml_findFirst(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = ( ofXml * resultptr = new ofXml((const ofXml &) result); SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofXml,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_find(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; std::string *arg2 = 0 ; - std::string temp2 ; ofXml::Search result; SWIG_check_num_args("ofXml::find",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::find",1,"ofXml const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofXml::find",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_find",1,SWIGTYPE_p_ofXml); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = ((ofXml const *)arg1)->find((std::string const &)*arg2); { - ofXml::Search * resultptr = new ofXml::Search((const ofXml::Search &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofXml__Search,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } static int _wrap_Xml_getValue(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; std::string result; SWIG_check_num_args("ofXml::getValue",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::getValue",1,"ofXml const *"); if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_getValue",1,SWIGTYPE_p_ofXml); } @@ -44654,6 +44706,7 @@ static swig_lua_method swig_Xml_methods[]= { { "load", _wrap_Xml_load}, { "parse", _wrap_Xml_parse}, { "save", _wrap_Xml_save}, + { "clear", _wrap_Xml_clear}, { "toString", _wrap_Xml_toString}, { "getChild", _wrap_Xml_getChild}, { "getChildren", _wrap_Xml_getChildren}, @@ -44666,14 +44719,15 @@ static swig_lua_method swig_Xml_methods[]= { { "getPreviousSibling", _wrap_Xml_getPreviousSibling}, { "getFirstChild", _wrap_Xml_getFirstChild}, { "getLastChild", _wrap_Xml_getLastChild}, + { "getParent", _wrap_Xml_getParent}, { "getAttribute", _wrap_Xml_getAttribute}, { "getAttributes", _wrap_Xml_getAttributes}, { "getFirstAttribute", _wrap_Xml_getFirstAttribute}, { "getLastAttribute", _wrap_Xml_getLastAttribute}, { "appendAttribute", _wrap_Xml_appendAttribute}, { "prependAttribute", _wrap_Xml_prependAttribute}, + { "removeAttribute", _wrap_Xml_removeAttribute}, { "findFirst", _wrap_Xml_findFirst}, - { "find", _wrap_Xml_find}, { "getValue", _wrap_Xml_getValue}, { "getName", _wrap_Xml_getName}, { "set", _wrap_Xml_set}, @@ -44714,578 +44768,120 @@ static swig_lua_class *swig_Xml_bases[] = {0}; static const char *swig_Xml_base_names[] = {0}; static swig_lua_class _wrap_class_Xml = { "Xml", "Xml", &SWIGTYPE_p_ofXml,_proxy__wrap_new_Xml, swig_delete_Xml, swig_Xml_methods, swig_Xml_attributes, &swig_Xml_Sf_SwigStatic, swig_Xml_meta, swig_Xml_bases, swig_Xml_base_names }; -static int _wrap_new_XmlSearchIterator(lua_State* L) { int SWIG_arg = 0; ofXmlSearchIterator *result = 0 ; - SWIG_check_num_args("ofXmlSearchIterator::ofXmlSearchIterator",0,0) result = (ofXmlSearchIterator *)new ofXmlSearchIterator(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofXmlSearchIterator,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_XmlSearchIterator___eq(lua_State* L) { int SWIG_arg = 0; - ofXmlSearchIterator *arg1 = (ofXmlSearchIterator *) 0 ; ofXmlSearchIterator *arg2 = 0 ; bool result; - SWIG_check_num_args("ofXmlSearchIterator::operator ==",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXmlSearchIterator::operator ==",1,"ofXmlSearchIterator const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofXmlSearchIterator::operator ==",2,"ofXmlSearchIterator const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXmlSearchIterator,0))){ - SWIG_fail_ptr("XmlSearchIterator___eq",1,SWIGTYPE_p_ofXmlSearchIterator); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofXmlSearchIterator,0))){ - SWIG_fail_ptr("XmlSearchIterator___eq",2,SWIGTYPE_p_ofXmlSearchIterator); } - result = (bool)((ofXmlSearchIterator const *)arg1)->operator ==((ofXmlSearchIterator const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_XmlSearchIterator___ref__(lua_State* L) { int SWIG_arg = 0; - ofXmlSearchIterator *arg1 = (ofXmlSearchIterator *) 0 ; ofXml *result = 0 ; - SWIG_check_num_args("ofXmlSearchIterator::operator *",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXmlSearchIterator::operator *",1,"ofXmlSearchIterator const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXmlSearchIterator,0))){ - SWIG_fail_ptr("XmlSearchIterator___ref__",1,SWIGTYPE_p_ofXmlSearchIterator); } - result = (ofXml *) &((ofXmlSearchIterator const *)arg1)->operator *(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofXml,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_XmlSearchIterator___deref__(lua_State* L) { int SWIG_arg = 0; - ofXmlSearchIterator *arg1 = (ofXmlSearchIterator *) 0 ; ofXml *result = 0 ; - SWIG_check_num_args("ofXmlSearchIterator::operator ->",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXmlSearchIterator::operator ->",1,"ofXmlSearchIterator const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXmlSearchIterator,0))){ - SWIG_fail_ptr("XmlSearchIterator___deref__",1,SWIGTYPE_p_ofXmlSearchIterator); } - result = (ofXml *)((ofXmlSearchIterator const *)arg1)->operator ->(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofXml,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_XmlSearchIterator_load__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofXmlSearchIterator *arg1 = (ofXmlSearchIterator *) 0 ; std::filesystem::path *arg2 = 0 ; std::filesystem::path temp2 ; - bool result; SWIG_check_num_args("ofXml::load",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::load",1,"ofXmlSearchIterator *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofXml::load",2,"std::filesystem::path const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXmlSearchIterator,0))){ - SWIG_fail_ptr("XmlSearchIterator_load",1,SWIGTYPE_p_ofXmlSearchIterator); } { size_t len = lua_rawlen(L, 2); - temp2 = lua_tolstring(L, 2, &len); arg2 = &temp2; } result = (bool)(*arg1)->load((std::filesystem::path const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_XmlSearchIterator_load__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofXmlSearchIterator *arg1 = (ofXmlSearchIterator *) 0 ; ofBuffer *arg2 = 0 ; bool result; - SWIG_check_num_args("ofXml::load",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::load",1,"ofXmlSearchIterator *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofXml::load",2,"ofBuffer const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXmlSearchIterator,0))){ - SWIG_fail_ptr("XmlSearchIterator_load",1,SWIGTYPE_p_ofXmlSearchIterator); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBuffer,0))){ - SWIG_fail_ptr("XmlSearchIterator_load",2,SWIGTYPE_p_ofBuffer); } result = (bool)(*arg1)->load((ofBuffer const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_XmlSearchIterator_load(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXmlSearchIterator, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBuffer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_XmlSearchIterator_load__SWIG_1(L);} } } if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXmlSearchIterator, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L, argv[1]); } if (_v) { - return _wrap_XmlSearchIterator_load__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'XmlSearchIterator_load'\n" - " Possible C/C++ prototypes are:\n" " ofXml::load(std::filesystem::path const &)\n" - " ofXml::load(ofBuffer const &)\n"); lua_error(L);return 0; } -static int _wrap_XmlSearchIterator_parse(lua_State* L) { int SWIG_arg = 0; - ofXmlSearchIterator *arg1 = (ofXmlSearchIterator *) 0 ; std::string *arg2 = 0 ; std::string temp2 ; bool result; - SWIG_check_num_args("ofXml::parse",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::parse",1,"ofXmlSearchIterator *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofXml::parse",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXmlSearchIterator,0))){ - SWIG_fail_ptr("XmlSearchIterator_parse",1,SWIGTYPE_p_ofXmlSearchIterator); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; result = (bool)(*arg1)->parse((std::string const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_XmlSearchIterator_save(lua_State* L) { int SWIG_arg = 0; - ofXmlSearchIterator *arg1 = (ofXmlSearchIterator *) 0 ; std::filesystem::path *arg2 = 0 ; std::filesystem::path temp2 ; - bool result; SWIG_check_num_args("ofXml::save",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::save",1,"ofXmlSearchIterator const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofXml::save",2,"std::filesystem::path const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXmlSearchIterator,0))){ - SWIG_fail_ptr("XmlSearchIterator_save",1,SWIGTYPE_p_ofXmlSearchIterator); } { size_t len = lua_rawlen(L, 2); - temp2 = lua_tolstring(L, 2, &len); arg2 = &temp2; } result = (bool)(*arg1)->save((std::filesystem::path const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_XmlSearchIterator_toString__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofXmlSearchIterator *arg1 = (ofXmlSearchIterator *) 0 ; std::string *arg2 = 0 ; std::string temp2 ; std::string result; - SWIG_check_num_args("ofXml::toString",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::toString",1,"ofXmlSearchIterator const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofXml::toString",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXmlSearchIterator,0))){ - SWIG_fail_ptr("XmlSearchIterator_toString",1,SWIGTYPE_p_ofXmlSearchIterator); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; result = (*arg1)->toString((std::string const &)*arg2); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_XmlSearchIterator_toString__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofXmlSearchIterator *arg1 = (ofXmlSearchIterator *) 0 ; std::string result; SWIG_check_num_args("ofXml::toString",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::toString",1,"ofXmlSearchIterator const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXmlSearchIterator,0))){ - SWIG_fail_ptr("XmlSearchIterator_toString",1,SWIGTYPE_p_ofXmlSearchIterator); } result = (*arg1)->toString(); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_XmlSearchIterator_toString(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); - if (argc == 1) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXmlSearchIterator, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_XmlSearchIterator_toString__SWIG_1(L);} } if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXmlSearchIterator, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { - return _wrap_XmlSearchIterator_toString__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'XmlSearchIterator_toString'\n" - " Possible C/C++ prototypes are:\n" " ofXml::toString(std::string const &) const\n" " ofXml::toString() const\n"); - lua_error(L);return 0; } -static int _wrap_XmlSearchIterator_getChild(lua_State* L) { int SWIG_arg = 0; - ofXmlSearchIterator *arg1 = (ofXmlSearchIterator *) 0 ; std::string *arg2 = 0 ; std::string temp2 ; ofXml result; - SWIG_check_num_args("ofXml::getChild",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::getChild",1,"ofXmlSearchIterator const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofXml::getChild",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXmlSearchIterator,0))){ - SWIG_fail_ptr("XmlSearchIterator_getChild",1,SWIGTYPE_p_ofXmlSearchIterator); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; result = (*arg1)->getChild((std::string const &)*arg2); { - ofXml * resultptr = new ofXml((const ofXml &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofXml,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_XmlSearchIterator_getChildren__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofXmlSearchIterator *arg1 = (ofXmlSearchIterator *) 0 ; - SwigValueWrapper< ofXml::Range< ofXmlIterator< pugi::xml_node_iterator > > > result; - SWIG_check_num_args("ofXml::getChildren",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::getChildren",1,"ofXmlSearchIterator const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXmlSearchIterator,0))){ - SWIG_fail_ptr("XmlSearchIterator_getChildren",1,SWIGTYPE_p_ofXmlSearchIterator); } result = (*arg1)->getChildren(); { - ofXml::Range< ofXmlIterator< pugi::xml_node_iterator > > * resultptr = new ofXml::Range< ofXmlIterator< pugi::xml_node_iterator > >((const ofXml::Range< ofXmlIterator< pugi::xml_node_iterator > > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofXml__RangeT_ofXmlIteratorT_pugi__xml_node_iterator_t_t,1); SWIG_arg++; } - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_XmlSearchIterator_getChildren__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofXmlSearchIterator *arg1 = (ofXmlSearchIterator *) 0 ; std::string *arg2 = 0 ; std::string temp2 ; - SwigValueWrapper< ofXml::Range< ofXmlIterator< pugi::xml_named_node_iterator > > > result; - SWIG_check_num_args("ofXml::getChildren",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::getChildren",1,"ofXmlSearchIterator const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofXml::getChildren",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXmlSearchIterator,0))){ - SWIG_fail_ptr("XmlSearchIterator_getChildren",1,SWIGTYPE_p_ofXmlSearchIterator); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; result = (*arg1)->getChildren((std::string const &)*arg2); { - ofXml::Range< ofXmlIterator< pugi::xml_named_node_iterator > > * resultptr = new ofXml::Range< ofXmlIterator< pugi::xml_named_node_iterator > >((const ofXml::Range< ofXmlIterator< pugi::xml_named_node_iterator > > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofXml__RangeT_ofXmlIteratorT_pugi__xml_named_node_iterator_t_t,1); SWIG_arg++; } - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_XmlSearchIterator_getChildren(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); - if (argc == 1) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXmlSearchIterator, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_XmlSearchIterator_getChildren__SWIG_0(L);} } if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXmlSearchIterator, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { - return _wrap_XmlSearchIterator_getChildren__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'XmlSearchIterator_getChildren'\n" - " Possible C/C++ prototypes are:\n" " ofXml::getChildren() const\n" - " ofXml::getChildren(std::string const &) const\n"); lua_error(L);return 0; } -static int _wrap_XmlSearchIterator_appendChild__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofXmlSearchIterator *arg1 = (ofXmlSearchIterator *) 0 ; ofXml *arg2 = 0 ; ofXml result; - SWIG_check_num_args("ofXml::appendChild",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::appendChild",1,"ofXmlSearchIterator *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofXml::appendChild",2,"ofXml const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXmlSearchIterator,0))){ - SWIG_fail_ptr("XmlSearchIterator_appendChild",1,SWIGTYPE_p_ofXmlSearchIterator); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofXml,0))){ - SWIG_fail_ptr("XmlSearchIterator_appendChild",2,SWIGTYPE_p_ofXml); } result = (*arg1)->appendChild((ofXml const &)*arg2); { - ofXml * resultptr = new ofXml((const ofXml &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofXml,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_XmlSearchIterator_appendChild__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofXmlSearchIterator *arg1 = (ofXmlSearchIterator *) 0 ; std::string *arg2 = 0 ; std::string temp2 ; ofXml result; - SWIG_check_num_args("ofXml::appendChild",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::appendChild",1,"ofXmlSearchIterator *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofXml::appendChild",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXmlSearchIterator,0))){ - SWIG_fail_ptr("XmlSearchIterator_appendChild",1,SWIGTYPE_p_ofXmlSearchIterator); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; result = (*arg1)->appendChild((std::string const &)*arg2); { - ofXml * resultptr = new ofXml((const ofXml &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofXml,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_XmlSearchIterator_appendChild(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXmlSearchIterator, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofXml, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_XmlSearchIterator_appendChild__SWIG_0(L);} } } if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXmlSearchIterator, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { - return _wrap_XmlSearchIterator_appendChild__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'XmlSearchIterator_appendChild'\n" - " Possible C/C++ prototypes are:\n" " ofXml::appendChild(ofXml const &)\n" - " ofXml::appendChild(std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_XmlSearchIterator_prependChild__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofXmlSearchIterator *arg1 = (ofXmlSearchIterator *) 0 ; ofXml *arg2 = 0 ; ofXml result; - SWIG_check_num_args("ofXml::prependChild",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::prependChild",1,"ofXmlSearchIterator *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofXml::prependChild",2,"ofXml const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXmlSearchIterator,0))){ - SWIG_fail_ptr("XmlSearchIterator_prependChild",1,SWIGTYPE_p_ofXmlSearchIterator); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofXml,0))){ - SWIG_fail_ptr("XmlSearchIterator_prependChild",2,SWIGTYPE_p_ofXml); } result = (*arg1)->prependChild((ofXml const &)*arg2); - { ofXml * resultptr = new ofXml((const ofXml &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofXml,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_XmlSearchIterator_prependChild__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofXmlSearchIterator *arg1 = (ofXmlSearchIterator *) 0 ; std::string *arg2 = 0 ; std::string temp2 ; ofXml result; - SWIG_check_num_args("ofXml::prependChild",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::prependChild",1,"ofXmlSearchIterator *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofXml::prependChild",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXmlSearchIterator,0))){ - SWIG_fail_ptr("XmlSearchIterator_prependChild",1,SWIGTYPE_p_ofXmlSearchIterator); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; result = (*arg1)->prependChild((std::string const &)*arg2); { - ofXml * resultptr = new ofXml((const ofXml &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofXml,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_XmlSearchIterator_prependChild(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXmlSearchIterator, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofXml, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_XmlSearchIterator_prependChild__SWIG_0(L);} } } if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXmlSearchIterator, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { - return _wrap_XmlSearchIterator_prependChild__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'XmlSearchIterator_prependChild'\n" - " Possible C/C++ prototypes are:\n" " ofXml::prependChild(ofXml const &)\n" - " ofXml::prependChild(std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_XmlSearchIterator_removeChild(lua_State* L) { int SWIG_arg = 0; - ofXmlSearchIterator *arg1 = (ofXmlSearchIterator *) 0 ; std::string *arg2 = 0 ; std::string temp2 ; bool result; - SWIG_check_num_args("ofXml::removeChild",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::removeChild",1,"ofXmlSearchIterator *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofXml::removeChild",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXmlSearchIterator,0))){ - SWIG_fail_ptr("XmlSearchIterator_removeChild",1,SWIGTYPE_p_ofXmlSearchIterator); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; result = (bool)(*arg1)->removeChild((std::string const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_XmlSearchIterator_insertChildAfter(lua_State* L) { int SWIG_arg = 0; - ofXmlSearchIterator *arg1 = (ofXmlSearchIterator *) 0 ; std::string *arg2 = 0 ; ofXml *arg3 = 0 ; std::string temp2 ; - ofXml result; SWIG_check_num_args("ofXml::insertChildAfter",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::insertChildAfter",1,"ofXmlSearchIterator *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofXml::insertChildAfter",2,"std::string const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofXml::insertChildAfter",3,"ofXml const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXmlSearchIterator,0))){ - SWIG_fail_ptr("XmlSearchIterator_insertChildAfter",1,SWIGTYPE_p_ofXmlSearchIterator); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofXml,0))){ - SWIG_fail_ptr("XmlSearchIterator_insertChildAfter",3,SWIGTYPE_p_ofXml); } - result = (*arg1)->insertChildAfter((std::string const &)*arg2,(ofXml const &)*arg3); { - ofXml * resultptr = new ofXml((const ofXml &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofXml,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_XmlSearchIterator_insertChildBefore(lua_State* L) { int SWIG_arg = 0; - ofXmlSearchIterator *arg1 = (ofXmlSearchIterator *) 0 ; std::string *arg2 = 0 ; ofXml *arg3 = 0 ; std::string temp2 ; - ofXml result; SWIG_check_num_args("ofXml::insertChildBefore",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::insertChildBefore",1,"ofXmlSearchIterator *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofXml::insertChildBefore",2,"std::string const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofXml::insertChildBefore",3,"ofXml const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXmlSearchIterator,0))){ - SWIG_fail_ptr("XmlSearchIterator_insertChildBefore",1,SWIGTYPE_p_ofXmlSearchIterator); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofXml,0))){ - SWIG_fail_ptr("XmlSearchIterator_insertChildBefore",3,SWIGTYPE_p_ofXml); } - result = (*arg1)->insertChildBefore((std::string const &)*arg2,(ofXml const &)*arg3); { - ofXml * resultptr = new ofXml((const ofXml &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofXml,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_XmlSearchIterator_getNextSibling__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofXmlSearchIterator *arg1 = (ofXmlSearchIterator *) 0 ; ofXml result; SWIG_check_num_args("ofXml::getNextSibling",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::getNextSibling",1,"ofXmlSearchIterator const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXmlSearchIterator,0))){ - SWIG_fail_ptr("XmlSearchIterator_getNextSibling",1,SWIGTYPE_p_ofXmlSearchIterator); } result = (*arg1)->getNextSibling(); { - ofXml * resultptr = new ofXml((const ofXml &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofXml,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_XmlSearchIterator_getNextSibling__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofXmlSearchIterator *arg1 = (ofXmlSearchIterator *) 0 ; std::string *arg2 = 0 ; std::string temp2 ; ofXml result; - SWIG_check_num_args("ofXml::getNextSibling",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::getNextSibling",1,"ofXmlSearchIterator const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofXml::getNextSibling",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXmlSearchIterator,0))){ - SWIG_fail_ptr("XmlSearchIterator_getNextSibling",1,SWIGTYPE_p_ofXmlSearchIterator); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; result = (*arg1)->getNextSibling((std::string const &)*arg2); { - ofXml * resultptr = new ofXml((const ofXml &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofXml,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_XmlSearchIterator_getNextSibling(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); - if (argc == 1) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXmlSearchIterator, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_XmlSearchIterator_getNextSibling__SWIG_0(L);} } - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXmlSearchIterator, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { - return _wrap_XmlSearchIterator_getNextSibling__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'XmlSearchIterator_getNextSibling'\n" - " Possible C/C++ prototypes are:\n" " ofXml::getNextSibling() const\n" - " ofXml::getNextSibling(std::string const &) const\n"); lua_error(L);return 0; } -static int _wrap_XmlSearchIterator_getPreviousSibling__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofXmlSearchIterator *arg1 = (ofXmlSearchIterator *) 0 ; ofXml result; SWIG_check_num_args("ofXml::getPreviousSibling",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::getPreviousSibling",1,"ofXmlSearchIterator const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXmlSearchIterator,0))){ - SWIG_fail_ptr("XmlSearchIterator_getPreviousSibling",1,SWIGTYPE_p_ofXmlSearchIterator); } - result = (*arg1)->getPreviousSibling(); { ofXml * resultptr = new ofXml((const ofXml &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofXml,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_XmlSearchIterator_getPreviousSibling__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofXmlSearchIterator *arg1 = (ofXmlSearchIterator *) 0 ; std::string *arg2 = 0 ; std::string temp2 ; ofXml result; - SWIG_check_num_args("ofXml::getPreviousSibling",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::getPreviousSibling",1,"ofXmlSearchIterator const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofXml::getPreviousSibling",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXmlSearchIterator,0))){ - SWIG_fail_ptr("XmlSearchIterator_getPreviousSibling",1,SWIGTYPE_p_ofXmlSearchIterator); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = (*arg1)->getPreviousSibling((std::string const &)*arg2); { ofXml * resultptr = new ofXml((const ofXml &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofXml,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_XmlSearchIterator_getPreviousSibling(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); - if (argc == 1) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXmlSearchIterator, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_XmlSearchIterator_getPreviousSibling__SWIG_0(L);} } - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXmlSearchIterator, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { - return _wrap_XmlSearchIterator_getPreviousSibling__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'XmlSearchIterator_getPreviousSibling'\n" - " Possible C/C++ prototypes are:\n" " ofXml::getPreviousSibling() const\n" - " ofXml::getPreviousSibling(std::string const &) const\n"); lua_error(L);return 0; } -static int _wrap_XmlSearchIterator_getFirstChild(lua_State* L) { int SWIG_arg = 0; - ofXmlSearchIterator *arg1 = (ofXmlSearchIterator *) 0 ; ofXml result; SWIG_check_num_args("ofXml::getFirstChild",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::getFirstChild",1,"ofXmlSearchIterator const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXmlSearchIterator,0))){ - SWIG_fail_ptr("XmlSearchIterator_getFirstChild",1,SWIGTYPE_p_ofXmlSearchIterator); } result = (*arg1)->getFirstChild(); { - ofXml * resultptr = new ofXml((const ofXml &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofXml,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_XmlSearchIterator_getLastChild(lua_State* L) { int SWIG_arg = 0; - ofXmlSearchIterator *arg1 = (ofXmlSearchIterator *) 0 ; ofXml result; SWIG_check_num_args("ofXml::getLastChild",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::getLastChild",1,"ofXmlSearchIterator const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXmlSearchIterator,0))){ - SWIG_fail_ptr("XmlSearchIterator_getLastChild",1,SWIGTYPE_p_ofXmlSearchIterator); } result = (*arg1)->getLastChild(); { - ofXml * resultptr = new ofXml((const ofXml &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofXml,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_XmlSearchIterator_getAttribute(lua_State* L) { int SWIG_arg = 0; - ofXmlSearchIterator *arg1 = (ofXmlSearchIterator *) 0 ; std::string *arg2 = 0 ; std::string temp2 ; ofXml::Attribute result; - SWIG_check_num_args("ofXml::getAttribute",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::getAttribute",1,"ofXmlSearchIterator const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofXml::getAttribute",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXmlSearchIterator,0))){ - SWIG_fail_ptr("XmlSearchIterator_getAttribute",1,SWIGTYPE_p_ofXmlSearchIterator); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; result = (*arg1)->getAttribute((std::string const &)*arg2); { - ofXml::Attribute * resultptr = new ofXml::Attribute((const ofXml::Attribute &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofXml__Attribute,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_XmlSearchIterator_getAttributes(lua_State* L) { int SWIG_arg = 0; - ofXmlSearchIterator *arg1 = (ofXmlSearchIterator *) 0 ; - SwigValueWrapper< ofXml::Range< ofXmlIterator< pugi::xml_attribute_iterator > > > result; - SWIG_check_num_args("ofXml::getAttributes",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::getAttributes",1,"ofXmlSearchIterator const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXmlSearchIterator,0))){ - SWIG_fail_ptr("XmlSearchIterator_getAttributes",1,SWIGTYPE_p_ofXmlSearchIterator); } result = (*arg1)->getAttributes(); { - ofXml::Range< ofXmlIterator< pugi::xml_attribute_iterator > > * resultptr = new ofXml::Range< ofXmlIterator< pugi::xml_attribute_iterator > >((const ofXml::Range< ofXmlIterator< pugi::xml_attribute_iterator > > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofXml__RangeT_ofXmlIteratorT_pugi__xml_attribute_iterator_t_t,1); SWIG_arg++; } - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_XmlSearchIterator_getFirstAttribute(lua_State* L) { int SWIG_arg = 0; - ofXmlSearchIterator *arg1 = (ofXmlSearchIterator *) 0 ; ofXml::Attribute result; - SWIG_check_num_args("ofXml::getFirstAttribute",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::getFirstAttribute",1,"ofXmlSearchIterator const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXmlSearchIterator,0))){ - SWIG_fail_ptr("XmlSearchIterator_getFirstAttribute",1,SWIGTYPE_p_ofXmlSearchIterator); } - result = (*arg1)->getFirstAttribute(); { - ofXml::Attribute * resultptr = new ofXml::Attribute((const ofXml::Attribute &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofXml__Attribute,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_XmlSearchIterator_getLastAttribute(lua_State* L) { int SWIG_arg = 0; - ofXmlSearchIterator *arg1 = (ofXmlSearchIterator *) 0 ; ofXml::Attribute result; - SWIG_check_num_args("ofXml::getLastAttribute",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::getLastAttribute",1,"ofXmlSearchIterator const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXmlSearchIterator,0))){ - SWIG_fail_ptr("XmlSearchIterator_getLastAttribute",1,SWIGTYPE_p_ofXmlSearchIterator); } - result = (*arg1)->getLastAttribute(); { - ofXml::Attribute * resultptr = new ofXml::Attribute((const ofXml::Attribute &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofXml__Attribute,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_XmlSearchIterator_appendAttribute(lua_State* L) { int SWIG_arg = 0; - ofXmlSearchIterator *arg1 = (ofXmlSearchIterator *) 0 ; std::string *arg2 = 0 ; std::string temp2 ; ofXml::Attribute result; - SWIG_check_num_args("ofXml::appendAttribute",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::appendAttribute",1,"ofXmlSearchIterator *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofXml::appendAttribute",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXmlSearchIterator,0))){ - SWIG_fail_ptr("XmlSearchIterator_appendAttribute",1,SWIGTYPE_p_ofXmlSearchIterator); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; result = (*arg1)->appendAttribute((std::string const &)*arg2); { - ofXml::Attribute * resultptr = new ofXml::Attribute((const ofXml::Attribute &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofXml__Attribute,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_XmlSearchIterator_prependAttribute(lua_State* L) { int SWIG_arg = 0; - ofXmlSearchIterator *arg1 = (ofXmlSearchIterator *) 0 ; std::string *arg2 = 0 ; std::string temp2 ; ofXml::Attribute result; - SWIG_check_num_args("ofXml::prependAttribute",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::prependAttribute",1,"ofXmlSearchIterator *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofXml::prependAttribute",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXmlSearchIterator,0))){ - SWIG_fail_ptr("XmlSearchIterator_prependAttribute",1,SWIGTYPE_p_ofXmlSearchIterator); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; result = (*arg1)->prependAttribute((std::string const &)*arg2); - { ofXml::Attribute * resultptr = new ofXml::Attribute((const ofXml::Attribute &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofXml__Attribute,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_XmlSearchIterator_findFirst(lua_State* L) { int SWIG_arg = 0; - ofXmlSearchIterator *arg1 = (ofXmlSearchIterator *) 0 ; std::string *arg2 = 0 ; std::string temp2 ; ofXml result; - SWIG_check_num_args("ofXml::findFirst",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::findFirst",1,"ofXmlSearchIterator const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofXml::findFirst",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXmlSearchIterator,0))){ - SWIG_fail_ptr("XmlSearchIterator_findFirst",1,SWIGTYPE_p_ofXmlSearchIterator); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; result = (*arg1)->findFirst((std::string const &)*arg2); { - ofXml * resultptr = new ofXml((const ofXml &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofXml,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_XmlSearchIterator_find(lua_State* L) { int SWIG_arg = 0; - ofXmlSearchIterator *arg1 = (ofXmlSearchIterator *) 0 ; std::string *arg2 = 0 ; std::string temp2 ; ofXml::Search result; - SWIG_check_num_args("ofXml::find",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::find",1,"ofXmlSearchIterator const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofXml::find",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXmlSearchIterator,0))){ - SWIG_fail_ptr("XmlSearchIterator_find",1,SWIGTYPE_p_ofXmlSearchIterator); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; result = (*arg1)->find((std::string const &)*arg2); { - ofXml::Search * resultptr = new ofXml::Search((const ofXml::Search &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofXml__Search,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_XmlSearchIterator_getValue(lua_State* L) { int SWIG_arg = 0; - ofXmlSearchIterator *arg1 = (ofXmlSearchIterator *) 0 ; std::string result; SWIG_check_num_args("ofXml::getValue",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::getValue",1,"ofXmlSearchIterator const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXmlSearchIterator,0))){ - SWIG_fail_ptr("XmlSearchIterator_getValue",1,SWIGTYPE_p_ofXmlSearchIterator); } result = (*arg1)->getValue(); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_XmlSearchIterator_getName(lua_State* L) { int SWIG_arg = 0; - ofXmlSearchIterator *arg1 = (ofXmlSearchIterator *) 0 ; std::string result; SWIG_check_num_args("ofXml::getName",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::getName",1,"ofXmlSearchIterator const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXmlSearchIterator,0))){ - SWIG_fail_ptr("XmlSearchIterator_getName",1,SWIGTYPE_p_ofXmlSearchIterator); } result = (*arg1)->getName(); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_XmlSearchIterator_set(lua_State* L) { int SWIG_arg = 0; ofXmlSearchIterator *arg1 = (ofXmlSearchIterator *) 0 ; - unsigned char *arg2 = 0 ; unsigned char temp2 ; SWIG_check_num_args("ofXml::set",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::set",1,"ofXmlSearchIterator *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofXml::set",2,"unsigned char const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXmlSearchIterator,0))){ - SWIG_fail_ptr("XmlSearchIterator_set",1,SWIGTYPE_p_ofXmlSearchIterator); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") - temp2=(unsigned char)lua_tonumber(L,2); arg2=&temp2; (*arg1)->set((unsigned char const &)*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_XmlSearchIterator_setName(lua_State* L) { int SWIG_arg = 0; - ofXmlSearchIterator *arg1 = (ofXmlSearchIterator *) 0 ; std::string *arg2 = 0 ; std::string temp2 ; - SWIG_check_num_args("ofXml::setName",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::setName",1,"ofXmlSearchIterator *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofXml::setName",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXmlSearchIterator,0))){ - SWIG_fail_ptr("XmlSearchIterator_setName",1,SWIGTYPE_p_ofXmlSearchIterator); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; (*arg1)->setName((std::string const &)*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_XmlSearchIterator_getIntValue(lua_State* L) { int SWIG_arg = 0; - ofXmlSearchIterator *arg1 = (ofXmlSearchIterator *) 0 ; int result; SWIG_check_num_args("ofXml::getIntValue",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::getIntValue",1,"ofXmlSearchIterator const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXmlSearchIterator,0))){ - SWIG_fail_ptr("XmlSearchIterator_getIntValue",1,SWIGTYPE_p_ofXmlSearchIterator); } result = (int)(*arg1)->getIntValue(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_XmlSearchIterator_getUintValue(lua_State* L) { int SWIG_arg = 0; - ofXmlSearchIterator *arg1 = (ofXmlSearchIterator *) 0 ; unsigned int result; SWIG_check_num_args("ofXml::getUintValue",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::getUintValue",1,"ofXmlSearchIterator const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXmlSearchIterator,0))){ - SWIG_fail_ptr("XmlSearchIterator_getUintValue",1,SWIGTYPE_p_ofXmlSearchIterator); } - result = (unsigned int)(*arg1)->getUintValue(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_XmlSearchIterator_getFloatValue(lua_State* L) { int SWIG_arg = 0; - ofXmlSearchIterator *arg1 = (ofXmlSearchIterator *) 0 ; float result; SWIG_check_num_args("ofXml::getFloatValue",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::getFloatValue",1,"ofXmlSearchIterator const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXmlSearchIterator,0))){ - SWIG_fail_ptr("XmlSearchIterator_getFloatValue",1,SWIGTYPE_p_ofXmlSearchIterator); } - result = (float)(*arg1)->getFloatValue(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_XmlSearchIterator_getDoubleValue(lua_State* L) { int SWIG_arg = 0; - ofXmlSearchIterator *arg1 = (ofXmlSearchIterator *) 0 ; double result; SWIG_check_num_args("ofXml::getDoubleValue",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::getDoubleValue",1,"ofXmlSearchIterator const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXmlSearchIterator,0))){ - SWIG_fail_ptr("XmlSearchIterator_getDoubleValue",1,SWIGTYPE_p_ofXmlSearchIterator); } - result = (double)(*arg1)->getDoubleValue(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_XmlSearchIterator_getBoolValue(lua_State* L) { int SWIG_arg = 0; - ofXmlSearchIterator *arg1 = (ofXmlSearchIterator *) 0 ; bool result; SWIG_check_num_args("ofXml::getBoolValue",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::getBoolValue",1,"ofXmlSearchIterator const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXmlSearchIterator,0))){ - SWIG_fail_ptr("XmlSearchIterator_getBoolValue",1,SWIGTYPE_p_ofXmlSearchIterator); } result = (bool)(*arg1)->getBoolValue(); +static int _wrap_new_XmlAttributeIterator(lua_State* L) { int SWIG_arg = 0; ofXmlAttributeIterator *result = 0 ; + SWIG_check_num_args("ofXmlAttributeIterator::ofXmlAttributeIterator",0,0) + result = (ofXmlAttributeIterator *)new ofXmlAttributeIterator(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofXmlAttributeIterator,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_XmlAttributeIterator___eq(lua_State* L) { int SWIG_arg = 0; + ofXmlAttributeIterator *arg1 = (ofXmlAttributeIterator *) 0 ; ofXmlAttributeIterator *arg2 = 0 ; bool result; + SWIG_check_num_args("ofXmlAttributeIterator::operator ==",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXmlAttributeIterator::operator ==",1,"ofXmlAttributeIterator const *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofXmlAttributeIterator::operator ==",2,"ofXmlAttributeIterator const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXmlAttributeIterator,0))){ + SWIG_fail_ptr("XmlAttributeIterator___eq",1,SWIGTYPE_p_ofXmlAttributeIterator); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofXmlAttributeIterator,0))){ + SWIG_fail_ptr("XmlAttributeIterator___eq",2,SWIGTYPE_p_ofXmlAttributeIterator); } + result = (bool)((ofXmlAttributeIterator const *)arg1)->operator ==((ofXmlAttributeIterator const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_XmlSearchIterator(void *obj) { -ofXmlSearchIterator *arg1 = (ofXmlSearchIterator *) obj; +static int _wrap_XmlAttributeIterator___ref____SWIG_0(lua_State* L) { int SWIG_arg = 0; + ofXmlAttributeIterator *arg1 = (ofXmlAttributeIterator *) 0 ; ofXml::Attribute *result = 0 ; + SWIG_check_num_args("ofXmlAttributeIterator::operator *",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXmlAttributeIterator::operator *",1,"ofXmlAttributeIterator const *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXmlAttributeIterator,0))){ + SWIG_fail_ptr("XmlAttributeIterator___ref__",1,SWIGTYPE_p_ofXmlAttributeIterator); } + result = (ofXml::Attribute *) &((ofXmlAttributeIterator const *)arg1)->operator *(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofXml__Attribute,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_XmlAttributeIterator___deref____SWIG_0(lua_State* L) { int SWIG_arg = 0; + ofXmlAttributeIterator *arg1 = (ofXmlAttributeIterator *) 0 ; ofXml::Attribute *result = 0 ; + SWIG_check_num_args("ofXmlAttributeIterator::operator ->",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXmlAttributeIterator::operator ->",1,"ofXmlAttributeIterator const *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXmlAttributeIterator,0))){ + SWIG_fail_ptr("XmlAttributeIterator___deref__",1,SWIGTYPE_p_ofXmlAttributeIterator); } + result = (ofXml::Attribute *)((ofXmlAttributeIterator const *)arg1)->operator ->(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofXml__Attribute,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_XmlAttributeIterator___ref____SWIG_1(lua_State* L) { int SWIG_arg = 0; + ofXmlAttributeIterator *arg1 = (ofXmlAttributeIterator *) 0 ; ofXml::Attribute *result = 0 ; + SWIG_check_num_args("ofXmlAttributeIterator::operator *",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXmlAttributeIterator::operator *",1,"ofXmlAttributeIterator *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXmlAttributeIterator,0))){ + SWIG_fail_ptr("XmlAttributeIterator___ref__",1,SWIGTYPE_p_ofXmlAttributeIterator); } + result = (ofXml::Attribute *) &(arg1)->operator *(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofXml__Attribute,0); SWIG_arg++; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_XmlAttributeIterator___ref__(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); + if (argc == 1) { return _wrap_XmlAttributeIterator___ref____SWIG_1(L);} if (argc == 1) { + return _wrap_XmlAttributeIterator___ref____SWIG_0(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'XmlAttributeIterator___ref__'\n" + " Possible C/C++ prototypes are:\n" " ofXmlAttributeIterator::operator *() const\n" + " ofXmlAttributeIterator::operator *()\n"); lua_error(L);return 0; } +static int _wrap_XmlAttributeIterator___deref____SWIG_1(lua_State* L) { int SWIG_arg = 0; + ofXmlAttributeIterator *arg1 = (ofXmlAttributeIterator *) 0 ; ofXml::Attribute *result = 0 ; + SWIG_check_num_args("ofXmlAttributeIterator::operator ->",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXmlAttributeIterator::operator ->",1,"ofXmlAttributeIterator *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXmlAttributeIterator,0))){ + SWIG_fail_ptr("XmlAttributeIterator___deref__",1,SWIGTYPE_p_ofXmlAttributeIterator); } + result = (ofXml::Attribute *)(arg1)->operator ->(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofXml__Attribute,0); SWIG_arg++; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_XmlAttributeIterator___deref__(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); + if (argc == 1) { return _wrap_XmlAttributeIterator___deref____SWIG_1(L);} if (argc == 1) { + return _wrap_XmlAttributeIterator___deref____SWIG_0(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'XmlAttributeIterator___deref__'\n" + " Possible C/C++ prototypes are:\n" " ofXmlAttributeIterator::operator ->() const\n" + " ofXmlAttributeIterator::operator ->()\n"); lua_error(L);return 0; } +static void swig_delete_XmlAttributeIterator(void *obj) { +ofXmlAttributeIterator *arg1 = (ofXmlAttributeIterator *) obj; delete arg1; } -static int _proxy__wrap_new_XmlSearchIterator(lua_State *L) { +static int _proxy__wrap_new_XmlAttributeIterator(lua_State *L) { assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_XmlSearchIterator); + lua_pushcfunction(L,_wrap_new_XmlAttributeIterator); assert(!lua_isnil(L,-1)); lua_replace(L,1); /* replace our table with real constructor */ lua_call(L,lua_gettop(L)-1,1); return 1; } -static swig_lua_attribute swig_XmlSearchIterator_attributes[] = { +static swig_lua_attribute swig_XmlAttributeIterator_attributes[] = { {0,0,0} }; -static swig_lua_method swig_XmlSearchIterator_methods[]= { - { "__eq", _wrap_XmlSearchIterator___eq}, - { "__ref__", _wrap_XmlSearchIterator___ref__}, - { "__deref__", _wrap_XmlSearchIterator___deref__}, - { "load", _wrap_XmlSearchIterator_load}, - { "parse", _wrap_XmlSearchIterator_parse}, - { "save", _wrap_XmlSearchIterator_save}, - { "toString", _wrap_XmlSearchIterator_toString}, - { "getChild", _wrap_XmlSearchIterator_getChild}, - { "getChildren", _wrap_XmlSearchIterator_getChildren}, - { "appendChild", _wrap_XmlSearchIterator_appendChild}, - { "prependChild", _wrap_XmlSearchIterator_prependChild}, - { "removeChild", _wrap_XmlSearchIterator_removeChild}, - { "insertChildAfter", _wrap_XmlSearchIterator_insertChildAfter}, - { "insertChildBefore", _wrap_XmlSearchIterator_insertChildBefore}, - { "getNextSibling", _wrap_XmlSearchIterator_getNextSibling}, - { "getPreviousSibling", _wrap_XmlSearchIterator_getPreviousSibling}, - { "getFirstChild", _wrap_XmlSearchIterator_getFirstChild}, - { "getLastChild", _wrap_XmlSearchIterator_getLastChild}, - { "getAttribute", _wrap_XmlSearchIterator_getAttribute}, - { "getAttributes", _wrap_XmlSearchIterator_getAttributes}, - { "getFirstAttribute", _wrap_XmlSearchIterator_getFirstAttribute}, - { "getLastAttribute", _wrap_XmlSearchIterator_getLastAttribute}, - { "appendAttribute", _wrap_XmlSearchIterator_appendAttribute}, - { "prependAttribute", _wrap_XmlSearchIterator_prependAttribute}, - { "findFirst", _wrap_XmlSearchIterator_findFirst}, - { "find", _wrap_XmlSearchIterator_find}, - { "getValue", _wrap_XmlSearchIterator_getValue}, - { "getName", _wrap_XmlSearchIterator_getName}, - { "set", _wrap_XmlSearchIterator_set}, - { "setName", _wrap_XmlSearchIterator_setName}, - { "getIntValue", _wrap_XmlSearchIterator_getIntValue}, - { "getUintValue", _wrap_XmlSearchIterator_getUintValue}, - { "getFloatValue", _wrap_XmlSearchIterator_getFloatValue}, - { "getDoubleValue", _wrap_XmlSearchIterator_getDoubleValue}, - { "getBoolValue", _wrap_XmlSearchIterator_getBoolValue}, - {0,0} -}; -static swig_lua_method swig_XmlSearchIterator_meta[] = { - { "__eq", _wrap_XmlSearchIterator___eq}, - { "__ref__", _wrap_XmlSearchIterator___ref__}, - { "__deref__", _wrap_XmlSearchIterator___deref__}, - {0,0} -}; - -static swig_lua_attribute swig_XmlSearchIterator_Sf_SwigStatic_attributes[] = { +static swig_lua_method swig_XmlAttributeIterator_methods[]= { + { "__eq", _wrap_XmlAttributeIterator___eq}, + { "__ref__", _wrap_XmlAttributeIterator___ref__}, + { "__deref__", _wrap_XmlAttributeIterator___deref__}, + {0,0} +}; +static swig_lua_method swig_XmlAttributeIterator_meta[] = { + { "__eq", _wrap_XmlAttributeIterator___eq}, + { "__ref__", _wrap_XmlAttributeIterator___ref__}, + { "__deref__", _wrap_XmlAttributeIterator___deref__}, + {0,0} +}; + +static swig_lua_attribute swig_XmlAttributeIterator_Sf_SwigStatic_attributes[] = { {0,0,0} }; -static swig_lua_const_info swig_XmlSearchIterator_Sf_SwigStatic_constants[]= { +static swig_lua_const_info swig_XmlAttributeIterator_Sf_SwigStatic_constants[]= { {0,0,0,0,0,0} }; -static swig_lua_method swig_XmlSearchIterator_Sf_SwigStatic_methods[]= { +static swig_lua_method swig_XmlAttributeIterator_Sf_SwigStatic_methods[]= { {0,0} }; -static swig_lua_class* swig_XmlSearchIterator_Sf_SwigStatic_classes[]= { +static swig_lua_class* swig_XmlAttributeIterator_Sf_SwigStatic_classes[]= { 0 }; -static swig_lua_namespace swig_XmlSearchIterator_Sf_SwigStatic = { - "XmlSearchIterator", - swig_XmlSearchIterator_Sf_SwigStatic_methods, - swig_XmlSearchIterator_Sf_SwigStatic_attributes, - swig_XmlSearchIterator_Sf_SwigStatic_constants, - swig_XmlSearchIterator_Sf_SwigStatic_classes, +static swig_lua_namespace swig_XmlAttributeIterator_Sf_SwigStatic = { + "XmlAttributeIterator", + swig_XmlAttributeIterator_Sf_SwigStatic_methods, + swig_XmlAttributeIterator_Sf_SwigStatic_attributes, + swig_XmlAttributeIterator_Sf_SwigStatic_constants, + swig_XmlAttributeIterator_Sf_SwigStatic_classes, 0 }; -static swig_lua_class *swig_XmlSearchIterator_bases[] = {0}; -static const char *swig_XmlSearchIterator_base_names[] = {0}; -static swig_lua_class _wrap_class_XmlSearchIterator = { "XmlSearchIterator", "XmlSearchIterator", &SWIGTYPE_p_ofXmlSearchIterator,_proxy__wrap_new_XmlSearchIterator, swig_delete_XmlSearchIterator, swig_XmlSearchIterator_methods, swig_XmlSearchIterator_attributes, &swig_XmlSearchIterator_Sf_SwigStatic, swig_XmlSearchIterator_meta, swig_XmlSearchIterator_bases, swig_XmlSearchIterator_base_names }; +static swig_lua_class *swig_XmlAttributeIterator_bases[] = {0}; +static const char *swig_XmlAttributeIterator_base_names[] = {0}; +static swig_lua_class _wrap_class_XmlAttributeIterator = { "XmlAttributeIterator", "XmlAttributeIterator", &SWIGTYPE_p_ofXmlAttributeIterator,_proxy__wrap_new_XmlAttributeIterator, swig_delete_XmlAttributeIterator, swig_XmlAttributeIterator_methods, swig_XmlAttributeIterator_attributes, &swig_XmlAttributeIterator_Sf_SwigStatic, swig_XmlAttributeIterator_meta, swig_XmlAttributeIterator_bases, swig_XmlAttributeIterator_base_names }; static int _wrap_serialize(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = 0 ; ofAbstractParameter *arg2 = 0 ; SWIG_check_num_args("ofSerialize",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofSerialize",1,"ofXml &"); @@ -45341,15 +44937,10 @@ static int _wrap_MatrixStack_setRenderSurface__SWIG_1(lua_State* L) { int SWIG_a (arg1)->setRenderSurface((ofAppBaseWindow const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_MatrixStack_setRenderSurface(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrixStack, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBaseDraws, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_MatrixStack_setRenderSurface__SWIG_0(L);} } } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrixStack, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofAppBaseWindow, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_MatrixStack_setRenderSurface__SWIG_1(L);} } } + if (argc == 2) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBaseDraws, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_MatrixStack_setRenderSurface__SWIG_0(L);} + check_1: if (argc == 2) { return _wrap_MatrixStack_setRenderSurface__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'MatrixStack_setRenderSurface'\n" " Possible C/C++ prototypes are:\n" " ofMatrixStack::setRenderSurface(ofBaseDraws const &)\n" " ofMatrixStack::setRenderSurface(ofAppBaseWindow const &)\n"); lua_error(L);return 0; } @@ -45585,13 +45176,8 @@ static int _wrap_MatrixStack_translate__SWIG_1(lua_State* L) { int SWIG_arg = 0; arg3 = (float)lua_tonumber(L, 3); (arg1)->translate(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_MatrixStack_translate(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrixStack, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_MatrixStack_translate__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrixStack, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_MatrixStack_translate__SWIG_0(L);} } } } } + if (argc == 3) { return _wrap_MatrixStack_translate__SWIG_1(L);} if (argc == 4) { + return _wrap_MatrixStack_translate__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'MatrixStack_translate'\n" " Possible C/C++ prototypes are:\n" " ofMatrixStack::translate(float,float,float)\n" " ofMatrixStack::translate(float,float)\n"); lua_error(L);return 0; } @@ -45615,13 +45201,7 @@ static int _wrap_MatrixStack_scale__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofM arg3 = (float)lua_tonumber(L, 3); (arg1)->scale(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_MatrixStack_scale(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrixStack, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_MatrixStack_scale__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrixStack, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_MatrixStack_scale__SWIG_0(L);} } } } } + return _wrap_MatrixStack_scale__SWIG_1(L);} if (argc == 4) { return _wrap_MatrixStack_scale__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'MatrixStack_scale'\n" " Possible C/C++ prototypes are:\n" " ofMatrixStack::scale(float,float,float)\n" " ofMatrixStack::scale(float,float)\n"); lua_error(L);return 0; } static int _wrap_MatrixStack_rotateRad(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; @@ -45792,129 +45372,61 @@ static int _wrap_new_Buffer__SWIG_1(lua_State* L) { int SWIG_arg = 0; char *arg1 arg1 = (char *)lua_tolstring(L, 1, &arg2); } result = (ofBuffer *)new ofBuffer((char const *)arg1,arg2); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofBuffer,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_new_Buffer__SWIG_2(lua_State* L) { int SWIG_arg = 0; std::istream *arg1 = 0 ; size_t arg2 ; +static int _wrap_new_Buffer__SWIG_2(lua_State* L) { int SWIG_arg = 0; std::istream *arg1 = 0 ; std::size_t arg2 ; ofBuffer *result = 0 ; SWIG_check_num_args("ofBuffer::ofBuffer",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofBuffer::ofBuffer",1,"std::istream &"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBuffer::ofBuffer",2,"size_t"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBuffer::ofBuffer",2,"std::size_t"); if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__istream,0))){ SWIG_fail_ptr("new_Buffer",1,SWIGTYPE_p_std__istream); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); + SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (std::size_t)lua_tonumber(L, 2); result = (ofBuffer *)new ofBuffer(*arg1,arg2); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofBuffer,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_new_Buffer__SWIG_3(lua_State* L) { int SWIG_arg = 0; std::istream *arg1 = 0 ; ofBuffer *result = 0 ; - SWIG_check_num_args("ofBuffer::ofBuffer",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofBuffer::ofBuffer",1,"std::istream &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__istream,0))){ - SWIG_fail_ptr("new_Buffer",1,SWIGTYPE_p_std__istream); } result = (ofBuffer *)new ofBuffer(*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofBuffer,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } static int _wrap_new_Buffer(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_Buffer__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_std__istream, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_new_Buffer__SWIG_3(L);} } if (argc == 1) { int _v; { - _v = SWIG_lua_isnilstring(L,argv[0]); } if (_v) { if (argc <= 1) { return _wrap_new_Buffer__SWIG_1(L);} { - _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_new_Buffer__SWIG_1(L);} } } if (argc == 2) { int _v; { - void *ptr; if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_std__istream, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_new_Buffer__SWIG_2(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_Buffer'\n" " Possible C/C++ prototypes are:\n" - " ofBuffer::ofBuffer()\n" " ofBuffer::ofBuffer(char const *,std::size_t)\n" - " ofBuffer::ofBuffer(std::istream &,size_t)\n" " ofBuffer::ofBuffer(std::istream &)\n"); lua_error(L);return 0; } + return _wrap_new_Buffer__SWIG_0(L);} if (argc == 1) { return _wrap_new_Buffer__SWIG_1(L);} if (argc == 2) { + return _wrap_new_Buffer__SWIG_2(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_Buffer'\n" + " Possible C/C++ prototypes are:\n" " ofBuffer::ofBuffer()\n" " ofBuffer::ofBuffer(char const *,std::size_t)\n" + " ofBuffer::ofBuffer(std::istream &,std::size_t)\n"); lua_error(L);return 0; } static int _wrap_Buffer_set__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofBuffer *arg1 = (ofBuffer *) 0 ; char *arg2 = (char *) 0 ; std::size_t arg3 ; SWIG_check_num_args("ofBuffer::set",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBuffer::set",1,"ofBuffer *"); if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBuffer,0))){ SWIG_fail_ptr("Buffer_set",1,SWIGTYPE_p_ofBuffer); } { arg3 = (size_t)lua_tonumber(L, 2+1); arg2 = (char *)lua_tolstring(L, 2, &arg3); } (arg1)->set((char const *)arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Buffer_set__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofBuffer *arg1 = (ofBuffer *) 0 ; std::string *arg2 = 0 ; - std::string temp2 ; SWIG_check_num_args("ofBuffer::set",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBuffer::set",1,"ofBuffer *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofBuffer::set",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBuffer,0))){ SWIG_fail_ptr("Buffer_set",1,SWIGTYPE_p_ofBuffer); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; (arg1)->set((std::string const &)*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Buffer_set__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofBuffer *arg1 = (ofBuffer *) 0 ; std::istream *arg2 = 0 ; - size_t arg3 ; bool result; SWIG_check_num_args("ofBuffer::set",3,3) +static int _wrap_Buffer_set__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofBuffer *arg1 = (ofBuffer *) 0 ; std::istream *arg2 = 0 ; + std::size_t arg3 ; bool result; SWIG_check_num_args("ofBuffer::set",3,3) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBuffer::set",1,"ofBuffer *"); if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofBuffer::set",2,"std::istream &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofBuffer::set",3,"size_t"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("ofBuffer::set",3,"std::size_t"); if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBuffer,0))){ SWIG_fail_ptr("Buffer_set",1,SWIGTYPE_p_ofBuffer); } if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__istream,0))){ SWIG_fail_ptr("Buffer_set",2,SWIGTYPE_p_std__istream); } - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); + SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (std::size_t)lua_tonumber(L, 3); result = (bool)(arg1)->set(*arg2,arg3); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Buffer_set__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofBuffer *arg1 = (ofBuffer *) 0 ; std::istream *arg2 = 0 ; - bool result; SWIG_check_num_args("ofBuffer::set",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBuffer::set",1,"ofBuffer *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofBuffer::set",2,"std::istream &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBuffer,0))){ SWIG_fail_ptr("Buffer_set",1,SWIGTYPE_p_ofBuffer); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__istream,0))){ - SWIG_fail_ptr("Buffer_set",2,SWIGTYPE_p_std__istream); } result = (bool)(arg1)->set(*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Buffer_set(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofBuffer, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_std__istream, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Buffer_set__SWIG_3(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofBuffer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { return _wrap_Buffer_set__SWIG_1(L);} } } - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofBuffer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = SWIG_lua_isnilstring(L,argv[1]); } if (_v) { if (argc <= 2) { - return _wrap_Buffer_set__SWIG_0(L);} { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Buffer_set__SWIG_0(L);} - } } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofBuffer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_std__istream, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Buffer_set__SWIG_2(L);} } } - } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Buffer_set'\n" " Possible C/C++ prototypes are:\n" - " ofBuffer::set(char const *,std::size_t)\n" " ofBuffer::set(std::string const &)\n" - " ofBuffer::set(std::istream &,size_t)\n" " ofBuffer::set(std::istream &)\n"); lua_error(L);return 0; } +static int _wrap_Buffer_set(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { + return _wrap_Buffer_set__SWIG_0(L);} if (argc == 3) { return _wrap_Buffer_set__SWIG_1(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Buffer_set'\n" " Possible C/C++ prototypes are:\n" + " ofBuffer::set(char const *,std::size_t)\n" " ofBuffer::set(std::istream &,std::size_t)\n"); lua_error(L);return 0; } static int _wrap_Buffer_setall(lua_State* L) { int SWIG_arg = 0; ofBuffer *arg1 = (ofBuffer *) 0 ; char arg2 ; SWIG_check_num_args("ofBuffer::setall",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBuffer::setall",1,"ofBuffer *"); if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("ofBuffer::setall",2,"char"); if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBuffer,0))){ SWIG_fail_ptr("Buffer_setall",1,SWIGTYPE_p_ofBuffer); } arg2 = (lua_tostring(L, 2))[0]; (arg1)->setall(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Buffer_append__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofBuffer *arg1 = (ofBuffer *) 0 ; - std::string *arg2 = 0 ; std::string temp2 ; SWIG_check_num_args("ofBuffer::append",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBuffer::append",1,"ofBuffer *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofBuffer::append",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBuffer,0))){ - SWIG_fail_ptr("Buffer_append",1,SWIGTYPE_p_ofBuffer); } temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - (arg1)->append((std::string const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Buffer_append__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofBuffer *arg1 = (ofBuffer *) 0 ; - char *arg2 = (char *) 0 ; std::size_t arg3 ; SWIG_check_num_args("ofBuffer::append",2,2) +static int _wrap_Buffer_append(lua_State* L) { int SWIG_arg = 0; ofBuffer *arg1 = (ofBuffer *) 0 ; char *arg2 = (char *) 0 ; + std::size_t arg3 ; SWIG_check_num_args("ofBuffer::append",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBuffer::append",1,"ofBuffer *"); if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBuffer,0))){ SWIG_fail_ptr("Buffer_append",1,SWIGTYPE_p_ofBuffer); } { arg3 = (size_t)lua_tonumber(L, 2+1); arg2 = (char *)lua_tolstring(L, 2, &arg3); } (arg1)->append((char const *)arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Buffer_append(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofBuffer, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { - return _wrap_Buffer_append__SWIG_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofBuffer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = SWIG_lua_isnilstring(L,argv[1]); } if (_v) { if (argc <= 2) { - return _wrap_Buffer_append__SWIG_1(L);} { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Buffer_append__SWIG_1(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Buffer_append'\n" " Possible C/C++ prototypes are:\n" - " ofBuffer::append(std::string const &)\n" " ofBuffer::append(char const *,std::size_t)\n"); lua_error(L);return 0; } -static int _wrap_Buffer_reserve(lua_State* L) { int SWIG_arg = 0; ofBuffer *arg1 = (ofBuffer *) 0 ; size_t arg2 ; +static int _wrap_Buffer_reserve(lua_State* L) { int SWIG_arg = 0; ofBuffer *arg1 = (ofBuffer *) 0 ; std::size_t arg2 ; SWIG_check_num_args("ofBuffer::reserve",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBuffer::reserve",1,"ofBuffer *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBuffer::reserve",2,"size_t"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBuffer::reserve",2,"std::size_t"); if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBuffer,0))){ SWIG_fail_ptr("Buffer_reserve",1,SWIGTYPE_p_ofBuffer); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); + SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (std::size_t)lua_tonumber(L, 2); (arg1)->reserve(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Buffer_writeTo(lua_State* L) { int SWIG_arg = 0; ofBuffer *arg1 = (ofBuffer *) 0 ; std::ostream *arg2 = 0 ; - bool result; SWIG_check_num_args("ofBuffer::writeTo",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBuffer::writeTo",1,"ofBuffer const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofBuffer::writeTo",2,"std::ostream &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBuffer,0))){ - SWIG_fail_ptr("Buffer_writeTo",1,SWIGTYPE_p_ofBuffer); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__ostream,0))){ - SWIG_fail_ptr("Buffer_writeTo",2,SWIGTYPE_p_std__ostream); } result = (bool)((ofBuffer const *)arg1)->writeTo(*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Buffer_clear(lua_State* L) { int SWIG_arg = 0; ofBuffer *arg1 = (ofBuffer *) 0 ; SWIG_check_num_args("ofBuffer::clear",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBuffer::clear",1,"ofBuffer *"); if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBuffer,0))){ @@ -45950,23 +45462,6 @@ static int _wrap_Buffer_size(lua_State* L) { int SWIG_arg = 0; ofBuffer *arg1 = if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBuffer,0))){ SWIG_fail_ptr("Buffer_size",1,SWIGTYPE_p_ofBuffer); } result = (std::size_t)((ofBuffer const *)arg1)->size(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Buffer_length_get(lua_State* L) { int SWIG_arg = 0; ofBuffer *arg1 = (ofBuffer *) 0 ; long result; - SWIG_check_num_args("ofBuffer::length",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBuffer::length",1,"ofBuffer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBuffer,0))){ - SWIG_fail_ptr("Buffer_length_get",1,SWIGTYPE_p_ofBuffer); } result = (long)ofBuffer_length_get(arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Buffer_data_get(lua_State* L) { int SWIG_arg = 0; ofBuffer *arg1 = (ofBuffer *) 0 ; char *result = 0 ; - SWIG_check_num_args("ofBuffer::data",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBuffer::data",1,"ofBuffer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBuffer,0))){ - SWIG_fail_ptr("Buffer_data_get",1,SWIGTYPE_p_ofBuffer); } result = (char *)ofBuffer_data_get(arg1); - lua_pushstring(L,(const char *)result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Buffer_text_get(lua_State* L) { int SWIG_arg = 0; ofBuffer *arg1 = (ofBuffer *) 0 ; string result; - SWIG_check_num_args("ofBuffer::text",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBuffer::text",1,"ofBuffer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBuffer,0))){ - SWIG_fail_ptr("Buffer_text_get",1,SWIGTYPE_p_ofBuffer); } result = ofBuffer_text_get(arg1); { - string * resultptr = new string((const string &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_string,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } static void swig_delete_Buffer(void *obj) { ofBuffer *arg1 = (ofBuffer *) obj; delete arg1; @@ -45980,9 +45475,6 @@ static int _proxy__wrap_new_Buffer(lua_State *L) { return 1; } static swig_lua_attribute swig_Buffer_attributes[] = { - { "length", _wrap_Buffer_length_get, SWIG_Lua_set_immutable }, - { "data", _wrap_Buffer_data_get, SWIG_Lua_set_immutable }, - { "text", _wrap_Buffer_text_get, SWIG_Lua_set_immutable }, {0,0,0} }; static swig_lua_method swig_Buffer_methods[]= { @@ -45990,7 +45482,6 @@ static swig_lua_method swig_Buffer_methods[]= { { "setall", _wrap_Buffer_setall}, { "append", _wrap_Buffer_append}, { "reserve", _wrap_Buffer_reserve}, - { "writeTo", _wrap_Buffer_writeTo}, { "clear", _wrap_Buffer_clear}, { "allocate", _wrap_Buffer_allocate}, { "resize", _wrap_Buffer_resize}, @@ -46044,10 +45535,8 @@ static int _wrap_bufferFromFile__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::f ofBuffer * resultptr = new ofBuffer((const ofBuffer &) result); SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofBuffer,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_bufferFromFile(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; - { _v = lua_isstring(L, argv[0]); } if (_v) { return _wrap_bufferFromFile__SWIG_1(L);} } if (argc == 2) { int _v; { - _v = lua_isstring(L, argv[0]); } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_bufferFromFile__SWIG_0(L);} } } +static int _wrap_bufferFromFile(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { + return _wrap_bufferFromFile__SWIG_1(L);} if (argc == 2) { return _wrap_bufferFromFile__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'bufferFromFile'\n" " Possible C/C++ prototypes are:\n" " ofBufferFromFile(std::filesystem::path const &,bool)\n" " ofBufferFromFile(std::filesystem::path const &)\n"); lua_error(L);return 0; } @@ -46070,15 +45559,10 @@ static int _wrap_bufferToFile__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::fil SWIG_fail_ptr("bufferToFile",2,SWIGTYPE_p_ofBuffer); } result = (bool)ofBufferToFile((boost::filesystem::path const &)*arg1,(ofBuffer const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_bufferToFile(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { int _v; - { _v = lua_isstring(L, argv[0]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBuffer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_bufferToFile__SWIG_1(L);} } } if (argc == 3) { int _v; { - _v = lua_isstring(L, argv[0]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBuffer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { return _wrap_bufferToFile__SWIG_0(L);} } - } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'bufferToFile'\n" - " Possible C/C++ prototypes are:\n" " ofBufferToFile(std::filesystem::path const &,ofBuffer const &,bool)\n" +static int _wrap_bufferToFile(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { + return _wrap_bufferToFile__SWIG_1(L);} if (argc == 3) { return _wrap_bufferToFile__SWIG_0(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'bufferToFile'\n" " Possible C/C++ prototypes are:\n" + " ofBufferToFile(std::filesystem::path const &,ofBuffer const &,bool)\n" " ofBufferToFile(std::filesystem::path const &,ofBuffer const &)\n"); lua_error(L);return 0; } static int _wrap_FilePath_getFileExt(lua_State* L) { int SWIG_arg = 0; std::filesystem::path *arg1 = 0 ; std::filesystem::path temp1 ; std::string result; SWIG_check_num_args("ofFilePath::getFileExt",1,1) @@ -46138,9 +45622,8 @@ static int _wrap_FilePath_getAbsolutePath__SWIG_1(lua_State* L) { int SWIG_arg = lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_FilePath_getAbsolutePath(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); - if (argc == 1) { int _v; { _v = lua_isstring(L, argv[0]); } if (_v) { return _wrap_FilePath_getAbsolutePath__SWIG_1(L);} } - if (argc == 2) { int _v; { _v = lua_isstring(L, argv[0]); } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_FilePath_getAbsolutePath__SWIG_0(L);} } } + if (argc == 1) { return _wrap_FilePath_getAbsolutePath__SWIG_1(L);} if (argc == 2) { + return _wrap_FilePath_getAbsolutePath__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FilePath_getAbsolutePath'\n" " Possible C/C++ prototypes are:\n" " ofFilePath::getAbsolutePath(std::filesystem::path const &,bool)\n" " ofFilePath::getAbsolutePath(std::filesystem::path const &)\n"); lua_error(L);return 0; } @@ -46166,9 +45649,7 @@ static int _wrap_FilePath_getFileName__SWIG_1(lua_State* L) { int SWIG_arg = 0; lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_FilePath_getFileName(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { _v = lua_isstring(L, argv[0]); } if (_v) { return _wrap_FilePath_getFileName__SWIG_1(L);} } if (argc == 2) { - int _v; { _v = lua_isstring(L, argv[0]); } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_FilePath_getFileName__SWIG_0(L);} } } + return _wrap_FilePath_getFileName__SWIG_1(L);} if (argc == 2) { return _wrap_FilePath_getFileName__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FilePath_getFileName'\n" " Possible C/C++ prototypes are:\n" " ofFilePath::getFileName(std::filesystem::path const &,bool)\n" " ofFilePath::getFileName(std::filesystem::path const &)\n"); lua_error(L);return 0; } @@ -46195,9 +45676,8 @@ static int _wrap_FilePath_getEnclosingDirectory__SWIG_1(lua_State* L) { int SWIG lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_FilePath_getEnclosingDirectory(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); - if (argc == 1) { int _v; { _v = lua_isstring(L, argv[0]); } if (_v) { return _wrap_FilePath_getEnclosingDirectory__SWIG_1(L);} - } if (argc == 2) { int _v; { _v = lua_isstring(L, argv[0]); } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_FilePath_getEnclosingDirectory__SWIG_0(L);} } } + if (argc == 1) { return _wrap_FilePath_getEnclosingDirectory__SWIG_1(L);} if (argc == 2) { + return _wrap_FilePath_getEnclosingDirectory__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FilePath_getEnclosingDirectory'\n" " Possible C/C++ prototypes are:\n" " ofFilePath::getEnclosingDirectory(std::filesystem::path const &,bool)\n" " ofFilePath::getEnclosingDirectory(std::filesystem::path const &)\n"); lua_error(L);return 0; } @@ -46224,11 +45704,9 @@ static int _wrap_FilePath_createEnclosingDirectory__SWIG_2(lua_State* L) { int S result = (bool)ofFilePath::createEnclosingDirectory((boost::filesystem::path const &)*arg1); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_FilePath_createEnclosingDirectory(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); - if (argc == 1) { int _v; { _v = lua_isstring(L, argv[0]); } if (_v) { - return _wrap_FilePath_createEnclosingDirectory__SWIG_2(L);} } if (argc == 2) { int _v; { _v = lua_isstring(L, argv[0]); } - if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { return _wrap_FilePath_createEnclosingDirectory__SWIG_1(L);} } } - if (argc == 3) { int _v; { _v = lua_isstring(L, argv[0]); } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { { - _v = lua_isboolean(L,argv[2]); } if (_v) { return _wrap_FilePath_createEnclosingDirectory__SWIG_0(L);} } } } + if (argc == 1) { return _wrap_FilePath_createEnclosingDirectory__SWIG_2(L);} if (argc == 2) { + return _wrap_FilePath_createEnclosingDirectory__SWIG_1(L);} if (argc == 3) { + return _wrap_FilePath_createEnclosingDirectory__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FilePath_createEnclosingDirectory'\n" " Possible C/C++ prototypes are:\n" " ofFilePath::createEnclosingDirectory(std::filesystem::path const &,bool,bool)\n" " ofFilePath::createEnclosingDirectory(std::filesystem::path const &,bool)\n" @@ -46370,15 +45848,13 @@ static int _wrap_new_File__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 result = (ofFile *)new ofFile((ofFile const &)*arg1); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofFile,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_new_File(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_File__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_new_File__SWIG_4(L);} } if (argc == 1) { int _v; { - _v = lua_isstring(L, argv[0]); } if (_v) { return _wrap_new_File__SWIG_3(L);} } if (argc == 2) { int _v; { - _v = lua_isstring(L, argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_new_File__SWIG_2(L);} - } } if (argc == 3) { int _v; { _v = lua_isstring(L, argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - { _v = lua_isboolean(L,argv[2]); } if (_v) { return _wrap_new_File__SWIG_1(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_File'\n" " Possible C/C++ prototypes are:\n" - " ofFile::ofFile()\n" " ofFile::ofFile(std::filesystem::path const &,ofFile::Mode,bool)\n" + return _wrap_new_File__SWIG_0(L);} if (argc == 1) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_new_File__SWIG_4(L);} check_2: if (argc == 1) { + return _wrap_new_File__SWIG_3(L);} if (argc == 2) { return _wrap_new_File__SWIG_2(L);} if (argc == 3) { + return _wrap_new_File__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_File'\n" + " Possible C/C++ prototypes are:\n" " ofFile::ofFile()\n" + " ofFile::ofFile(std::filesystem::path const &,ofFile::Mode,bool)\n" " ofFile::ofFile(std::filesystem::path const &,ofFile::Mode)\n" " ofFile::ofFile(std::filesystem::path const &)\n" " ofFile::ofFile(ofFile const &)\n"); lua_error(L);return 0; } static int _wrap_File_open__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; @@ -46409,18 +45885,10 @@ static int _wrap_File_open__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofFile *arg size_t len = lua_rawlen(L, 2); temp2 = lua_tolstring(L, 2, &len); arg2 = &temp2; } result = (bool)(arg1)->open((std::filesystem::path const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_open(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L, argv[1]); } if (_v) { - return _wrap_File_open__SWIG_2(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isstring(L, argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_File_open__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isstring(L, argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isboolean(L,argv[3]); } if (_v) { return _wrap_File_open__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'File_open'\n" " Possible C/C++ prototypes are:\n" - " ofFile::open(std::filesystem::path const &,ofFile::Mode,bool)\n" +static int _wrap_File_open(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { + return _wrap_File_open__SWIG_2(L);} if (argc == 3) { return _wrap_File_open__SWIG_1(L);} if (argc == 4) { + return _wrap_File_open__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'File_open'\n" + " Possible C/C++ prototypes are:\n" " ofFile::open(std::filesystem::path const &,ofFile::Mode,bool)\n" " ofFile::open(std::filesystem::path const &,ofFile::Mode)\n" " ofFile::open(std::filesystem::path const &)\n"); lua_error(L);return 0; } static int _wrap_File_openFromCWD__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; @@ -46454,15 +45922,8 @@ static int _wrap_File_openFromCWD__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofFi result = (bool)(arg1)->openFromCWD((std::filesystem::path const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_File_openFromCWD(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L, argv[1]); } if (_v) { - return _wrap_File_openFromCWD__SWIG_2(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isstring(L, argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_File_openFromCWD__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isstring(L, argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isboolean(L,argv[3]); } if (_v) { return _wrap_File_openFromCWD__SWIG_0(L);} } } } } + return _wrap_File_openFromCWD__SWIG_2(L);} if (argc == 3) { return _wrap_File_openFromCWD__SWIG_1(L);} if (argc == 4) { + return _wrap_File_openFromCWD__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'File_openFromCWD'\n" " Possible C/C++ prototypes are:\n" " ofFile::openFromCWD(std::filesystem::path const &,ofFile::Mode,bool)\n" " ofFile::openFromCWD(std::filesystem::path const &,ofFile::Mode)\n" @@ -46485,12 +45946,7 @@ static int _wrap_File_changeMode__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofFil result = (bool)(arg1)->changeMode(arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_File_changeMode(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_File_changeMode__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - return _wrap_File_changeMode__SWIG_0(L);} } } } + return _wrap_File_changeMode__SWIG_1(L);} if (argc == 3) { return _wrap_File_changeMode__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'File_changeMode'\n" " Possible C/C++ prototypes are:\n" " ofFile::changeMode(ofFile::Mode,bool)\n" " ofFile::changeMode(ofFile::Mode)\n"); lua_error(L);return 0; } static int _wrap_File_close(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; @@ -46510,12 +45966,8 @@ static int _wrap_File_create__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofFile *a { size_t len = lua_rawlen(L, 2); temp2 = lua_tolstring(L, 2, &len); arg2 = &temp2; } result = (bool)(arg1)->create((std::filesystem::path const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_create(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_File_create__SWIG_0(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L, argv[1]); } if (_v) { - return _wrap_File_create__SWIG_1(L);} } } +static int _wrap_File_create(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { + return _wrap_File_create__SWIG_0(L);} if (argc == 2) { return _wrap_File_create__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'File_create'\n" " Possible C/C++ prototypes are:\n" " ofFile::create()\n" " ofFile::create(std::filesystem::path const &)\n"); lua_error(L);return 0; } static int _wrap_File_exists(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; bool result; @@ -46616,19 +46068,9 @@ static int _wrap_File_setWriteable__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofF SWIG_fail_ptr("File_setWriteable",1,SWIGTYPE_p_ofFile); } (arg1)->setWriteable(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_File_setWriteable(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_File_setWriteable__SWIG_1(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_File_setWriteable__SWIG_0(L);} } } + return _wrap_File_setWriteable__SWIG_1(L);} if (argc == 2) { return _wrap_File_setWriteable__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'File_setWriteable'\n" " Possible C/C++ prototypes are:\n" " ofFile::setWriteable(bool)\n" " ofFile::setWriteable()\n"); lua_error(L);return 0; } -static int _wrap_File_setReadOnly(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; bool arg2 ; - SWIG_check_num_args("ofFile::setReadOnly",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::setReadOnly",1,"ofFile *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofFile::setReadOnly",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ - SWIG_fail_ptr("File_setReadOnly",1,SWIGTYPE_p_ofFile); } arg2 = (lua_toboolean(L, 2)!=0); (arg1)->setReadOnly(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_File_setReadable__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; bool arg2 ; SWIG_check_num_args("ofFile::setReadable",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::setReadable",1,"ofFile *"); if(!lua_isboolean(L,2)) SWIG_fail_arg("ofFile::setReadable",2,"bool"); @@ -46641,11 +46083,7 @@ static int _wrap_File_setReadable__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofFi SWIG_fail_ptr("File_setReadable",1,SWIGTYPE_p_ofFile); } (arg1)->setReadable(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_File_setReadable(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_File_setReadable__SWIG_1(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_File_setReadable__SWIG_0(L);} } } + return _wrap_File_setReadable__SWIG_1(L);} if (argc == 2) { return _wrap_File_setReadable__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'File_setReadable'\n" " Possible C/C++ prototypes are:\n" " ofFile::setReadable(bool)\n" " ofFile::setReadable()\n"); lua_error(L);return 0; } static int _wrap_File_setExecutable__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; bool arg2 ; @@ -46660,11 +46098,7 @@ static int _wrap_File_setExecutable__SWIG_1(lua_State* L) { int SWIG_arg = 0; of SWIG_fail_ptr("File_setExecutable",1,SWIGTYPE_p_ofFile); } (arg1)->setExecutable(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_File_setExecutable(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_File_setExecutable__SWIG_1(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_File_setExecutable__SWIG_0(L);} } } + return _wrap_File_setExecutable__SWIG_1(L);} if (argc == 2) { return _wrap_File_setExecutable__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'File_setExecutable'\n" " Possible C/C++ prototypes are:\n" " ofFile::setExecutable(bool)\n" " ofFile::setExecutable()\n"); lua_error(L);return 0; } static int _wrap_File_copyTo__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; @@ -46695,18 +46129,10 @@ static int _wrap_File_copyTo__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofFile *a { size_t len = lua_rawlen(L, 2); temp2 = lua_tolstring(L, 2, &len); arg2 = &temp2; } result = (bool)((ofFile const *)arg1)->copyTo((std::filesystem::path const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_copyTo(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L, argv[1]); } if (_v) { - return _wrap_File_copyTo__SWIG_2(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isstring(L, argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - return _wrap_File_copyTo__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isstring(L, argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { { - _v = lua_isboolean(L,argv[3]); } if (_v) { return _wrap_File_copyTo__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'File_copyTo'\n" " Possible C/C++ prototypes are:\n" - " ofFile::copyTo(std::filesystem::path const &,bool,bool) const\n" +static int _wrap_File_copyTo(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { + return _wrap_File_copyTo__SWIG_2(L);} if (argc == 3) { return _wrap_File_copyTo__SWIG_1(L);} if (argc == 4) { + return _wrap_File_copyTo__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'File_copyTo'\n" + " Possible C/C++ prototypes are:\n" " ofFile::copyTo(std::filesystem::path const &,bool,bool) const\n" " ofFile::copyTo(std::filesystem::path const &,bool) const\n" " ofFile::copyTo(std::filesystem::path const &) const\n"); lua_error(L);return 0; } static int _wrap_File_moveTo__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; @@ -46736,19 +46162,12 @@ static int _wrap_File_moveTo__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofFile *a { size_t len = lua_rawlen(L, 2); temp2 = lua_tolstring(L, 2, &len); arg2 = &temp2; } result = (bool)(arg1)->moveTo((std::filesystem::path const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_moveTo(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L, argv[1]); } if (_v) { - return _wrap_File_moveTo__SWIG_2(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isstring(L, argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - return _wrap_File_moveTo__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isstring(L, argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { { - _v = lua_isboolean(L,argv[3]); } if (_v) { return _wrap_File_moveTo__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'File_moveTo'\n" " Possible C/C++ prototypes are:\n" - " ofFile::moveTo(std::filesystem::path const &,bool,bool)\n" " ofFile::moveTo(std::filesystem::path const &,bool)\n" - " ofFile::moveTo(std::filesystem::path const &)\n"); lua_error(L);return 0; } +static int _wrap_File_moveTo(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { + return _wrap_File_moveTo__SWIG_2(L);} if (argc == 3) { return _wrap_File_moveTo__SWIG_1(L);} if (argc == 4) { + return _wrap_File_moveTo__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'File_moveTo'\n" + " Possible C/C++ prototypes are:\n" " ofFile::moveTo(std::filesystem::path const &,bool,bool)\n" + " ofFile::moveTo(std::filesystem::path const &,bool)\n" " ofFile::moveTo(std::filesystem::path const &)\n"); + lua_error(L);return 0; } static int _wrap_File_renameTo__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; std::filesystem::path *arg2 = 0 ; bool arg3 ; bool arg4 ; std::filesystem::path temp2 ; bool result; SWIG_check_num_args("ofFile::renameTo",4,4) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::renameTo",1,"ofFile *"); @@ -46777,15 +46196,8 @@ static int _wrap_File_renameTo__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofFile result = (bool)(arg1)->renameTo((std::filesystem::path const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_File_renameTo(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L, argv[1]); } if (_v) { - return _wrap_File_renameTo__SWIG_2(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isstring(L, argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - return _wrap_File_renameTo__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isstring(L, argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { { - _v = lua_isboolean(L,argv[3]); } if (_v) { return _wrap_File_renameTo__SWIG_0(L);} } } } } + return _wrap_File_renameTo__SWIG_2(L);} if (argc == 3) { return _wrap_File_renameTo__SWIG_1(L);} if (argc == 4) { + return _wrap_File_renameTo__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'File_renameTo'\n" " Possible C/C++ prototypes are:\n" " ofFile::renameTo(std::filesystem::path const &,bool,bool)\n" " ofFile::renameTo(std::filesystem::path const &,bool)\n" " ofFile::renameTo(std::filesystem::path const &)\n"); lua_error(L);return 0; } @@ -46800,12 +46212,8 @@ static int _wrap_File_remove__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofFile *a if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File_remove",1,SWIGTYPE_p_ofFile); } result = (bool)(arg1)->remove(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_remove(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_File_remove__SWIG_1(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_File_remove__SWIG_0(L);} } } +static int _wrap_File_remove(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { + return _wrap_File_remove__SWIG_1(L);} if (argc == 2) { return _wrap_File_remove__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'File_remove'\n" " Possible C/C++ prototypes are:\n" " ofFile::remove(bool)\n" " ofFile::remove()\n"); lua_error(L);return 0; } static int _wrap_File_getSize(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; uint64_t result; @@ -46884,12 +46292,8 @@ static int _wrap_File_copyFromTo__SWIG_2(lua_State* L) { int SWIG_arg = 0; std:: result = (bool)ofFile::copyFromTo((boost::filesystem::path const &)*arg1,(boost::filesystem::path const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_File_copyFromTo(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { _v = lua_isstring(L, argv[0]); } if (_v) { { _v = lua_isstring(L, argv[1]); } if (_v) { - return _wrap_File_copyFromTo__SWIG_2(L);} } } if (argc == 3) { int _v; { _v = lua_isstring(L, argv[0]); } if (_v) { - { _v = lua_isstring(L, argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - return _wrap_File_copyFromTo__SWIG_1(L);} } } } if (argc == 4) { int _v; { _v = lua_isstring(L, argv[0]); } - if (_v) { { _v = lua_isstring(L, argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { { - _v = lua_isboolean(L,argv[3]); } if (_v) { return _wrap_File_copyFromTo__SWIG_0(L);} } } } } + return _wrap_File_copyFromTo__SWIG_2(L);} if (argc == 3) { return _wrap_File_copyFromTo__SWIG_1(L);} if (argc == 4) { + return _wrap_File_copyFromTo__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'File_copyFromTo'\n" " Possible C/C++ prototypes are:\n" " ofFile::copyFromTo(std::filesystem::path const &,std::filesystem::path const &,bool,bool)\n" " ofFile::copyFromTo(std::filesystem::path const &,std::filesystem::path const &,bool)\n" @@ -46925,12 +46329,8 @@ static int _wrap_File_moveFromTo__SWIG_2(lua_State* L) { int SWIG_arg = 0; std:: result = (bool)ofFile::moveFromTo((boost::filesystem::path const &)*arg1,(boost::filesystem::path const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_File_moveFromTo(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { _v = lua_isstring(L, argv[0]); } if (_v) { { _v = lua_isstring(L, argv[1]); } if (_v) { - return _wrap_File_moveFromTo__SWIG_2(L);} } } if (argc == 3) { int _v; { _v = lua_isstring(L, argv[0]); } if (_v) { - { _v = lua_isstring(L, argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - return _wrap_File_moveFromTo__SWIG_1(L);} } } } if (argc == 4) { int _v; { _v = lua_isstring(L, argv[0]); } - if (_v) { { _v = lua_isstring(L, argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { { - _v = lua_isboolean(L,argv[3]); } if (_v) { return _wrap_File_moveFromTo__SWIG_0(L);} } } } } + return _wrap_File_moveFromTo__SWIG_2(L);} if (argc == 3) { return _wrap_File_moveFromTo__SWIG_1(L);} if (argc == 4) { + return _wrap_File_moveFromTo__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'File_moveFromTo'\n" " Possible C/C++ prototypes are:\n" " ofFile::moveFromTo(std::filesystem::path const &,std::filesystem::path const &,bool,bool)\n" " ofFile::moveFromTo(std::filesystem::path const &,std::filesystem::path const &,bool)\n" @@ -46949,9 +46349,7 @@ static int _wrap_File_doesFileExist__SWIG_1(lua_State* L) { int SWIG_arg = 0; st result = (bool)ofFile::doesFileExist((boost::filesystem::path const &)*arg1); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_File_doesFileExist(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { _v = lua_isstring(L, argv[0]); } if (_v) { return _wrap_File_doesFileExist__SWIG_1(L);} } if (argc == 2) { - int _v; { _v = lua_isstring(L, argv[0]); } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_File_doesFileExist__SWIG_0(L);} } } + return _wrap_File_doesFileExist__SWIG_1(L);} if (argc == 2) { return _wrap_File_doesFileExist__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'File_doesFileExist'\n" " Possible C/C++ prototypes are:\n" " ofFile::doesFileExist(std::filesystem::path const &,bool)\n" " ofFile::doesFileExist(std::filesystem::path const &)\n"); lua_error(L);return 0; } @@ -46968,10 +46366,8 @@ static int _wrap_File_removeFile__SWIG_1(lua_State* L) { int SWIG_arg = 0; std:: temp1 = lua_tolstring(L, 1, &len); arg1 = &temp1; } result = (bool)ofFile::removeFile((boost::filesystem::path const &)*arg1); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_removeFile(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; - { _v = lua_isstring(L, argv[0]); } if (_v) { return _wrap_File_removeFile__SWIG_1(L);} } if (argc == 2) { int _v; { - _v = lua_isstring(L, argv[0]); } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_File_removeFile__SWIG_0(L);} } } +static int _wrap_File_removeFile(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { + return _wrap_File_removeFile__SWIG_1(L);} if (argc == 2) { return _wrap_File_removeFile__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'File_removeFile'\n" " Possible C/C++ prototypes are:\n" " ofFile::removeFile(std::filesystem::path const &,bool)\n" " ofFile::removeFile(std::filesystem::path const &)\n"); lua_error(L);return 0; } @@ -47012,7 +46408,6 @@ static swig_lua_method swig_File_methods[]= { { "isDevice", _wrap_File_isDevice}, { "isHidden", _wrap_File_isHidden}, { "setWriteable", _wrap_File_setWriteable}, - { "setReadOnly", _wrap_File_setReadOnly}, { "setReadable", _wrap_File_setReadable}, { "setExecutable", _wrap_File_setExecutable}, { "copyTo", _wrap_File_copyTo}, @@ -47080,8 +46475,7 @@ static int _wrap_new_Directory__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::fi SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofDirectory,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_new_Directory(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_Directory__SWIG_0(L);} if (argc == 1) { int _v; { _v = lua_isstring(L, argv[0]); } if (_v) { - return _wrap_new_Directory__SWIG_1(L);} } + return _wrap_new_Directory__SWIG_0(L);} if (argc == 1) { return _wrap_new_Directory__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_Directory'\n" " Possible C/C++ prototypes are:\n" " ofDirectory::ofDirectory()\n" " ofDirectory::ofDirectory(std::filesystem::path const &)\n"); lua_error(L);return 0; } static int _wrap_Directory_open(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; @@ -47120,13 +46514,9 @@ static int _wrap_Directory_create__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofDi SWIG_fail_ptr("Directory_create",1,SWIGTYPE_p_ofDirectory); } result = (bool)(arg1)->create(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Directory_create(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofDirectory, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Directory_create__SWIG_1(L);} } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofDirectory, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { return _wrap_Directory_create__SWIG_0(L);} } - } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Directory_create'\n" - " Possible C/C++ prototypes are:\n" " ofDirectory::create(bool)\n" " ofDirectory::create()\n"); lua_error(L);return 0; } + return _wrap_Directory_create__SWIG_1(L);} if (argc == 2) { return _wrap_Directory_create__SWIG_0(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Directory_create'\n" " Possible C/C++ prototypes are:\n" + " ofDirectory::create(bool)\n" " ofDirectory::create()\n"); lua_error(L);return 0; } static int _wrap_Directory_exists(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; bool result; SWIG_check_num_args("ofDirectory::exists",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::exists",1,"ofDirectory const *"); @@ -47192,22 +46582,10 @@ static int _wrap_Directory_setWriteable__SWIG_1(lua_State* L) { int SWIG_arg = 0 SWIG_fail_ptr("Directory_setWriteable",1,SWIGTYPE_p_ofDirectory); } (arg1)->setWriteable(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Directory_setWriteable(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofDirectory, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Directory_setWriteable__SWIG_1(L);} } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofDirectory, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_Directory_setWriteable__SWIG_0(L);} } } + return _wrap_Directory_setWriteable__SWIG_1(L);} if (argc == 2) { return _wrap_Directory_setWriteable__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Directory_setWriteable'\n" " Possible C/C++ prototypes are:\n" " ofDirectory::setWriteable(bool)\n" " ofDirectory::setWriteable()\n"); lua_error(L);return 0; } -static int _wrap_Directory_setReadOnly(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; bool arg2 ; - SWIG_check_num_args("ofDirectory::setReadOnly",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::setReadOnly",1,"ofDirectory *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofDirectory::setReadOnly",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_setReadOnly",1,SWIGTYPE_p_ofDirectory); } arg2 = (lua_toboolean(L, 2)!=0); - (arg1)->setReadOnly(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Directory_setReadable__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; bool arg2 ; SWIG_check_num_args("ofDirectory::setReadable",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::setReadable",1,"ofDirectory *"); @@ -47222,12 +46600,7 @@ static int _wrap_Directory_setReadable__SWIG_1(lua_State* L) { int SWIG_arg = 0; SWIG_fail_ptr("Directory_setReadable",1,SWIGTYPE_p_ofDirectory); } (arg1)->setReadable(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Directory_setReadable(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofDirectory, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Directory_setReadable__SWIG_1(L);} } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofDirectory, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_Directory_setReadable__SWIG_0(L);} } } + return _wrap_Directory_setReadable__SWIG_1(L);} if (argc == 2) { return _wrap_Directory_setReadable__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Directory_setReadable'\n" " Possible C/C++ prototypes are:\n" " ofDirectory::setReadable(bool)\n" " ofDirectory::setReadable()\n"); lua_error(L);return 0; } @@ -47245,12 +46618,7 @@ static int _wrap_Directory_setExecutable__SWIG_1(lua_State* L) { int SWIG_arg = SWIG_fail_ptr("Directory_setExecutable",1,SWIGTYPE_p_ofDirectory); } (arg1)->setExecutable(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Directory_setExecutable(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofDirectory, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Directory_setExecutable__SWIG_1(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofDirectory, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_Directory_setExecutable__SWIG_0(L);} } } + return _wrap_Directory_setExecutable__SWIG_1(L);} if (argc == 2) { return _wrap_Directory_setExecutable__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Directory_setExecutable'\n" " Possible C/C++ prototypes are:\n" " ofDirectory::setExecutable(bool)\n" " ofDirectory::setExecutable()\n"); lua_error(L);return 0; } @@ -47293,16 +46661,8 @@ static int _wrap_Directory_copyTo__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofDi temp2 = lua_tolstring(L, 2, &len); arg2 = &temp2; } result = (bool)(arg1)->copyTo((std::filesystem::path const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Directory_copyTo(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofDirectory, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L, argv[1]); } if (_v) { return _wrap_Directory_copyTo__SWIG_2(L);} } - } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofDirectory, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L, argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } - if (_v) { return _wrap_Directory_copyTo__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofDirectory, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L, argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } - if (_v) { { _v = lua_isboolean(L,argv[3]); } if (_v) { return _wrap_Directory_copyTo__SWIG_0(L);} } } } } + return _wrap_Directory_copyTo__SWIG_2(L);} if (argc == 3) { return _wrap_Directory_copyTo__SWIG_1(L);} if (argc == 4) { + return _wrap_Directory_copyTo__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Directory_copyTo'\n" " Possible C/C++ prototypes are:\n" " ofDirectory::copyTo(std::filesystem::path const &,bool,bool)\n" " ofDirectory::copyTo(std::filesystem::path const &,bool)\n" " ofDirectory::copyTo(std::filesystem::path const &)\n"); @@ -47339,16 +46699,8 @@ static int _wrap_Directory_moveTo__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofDi temp2 = lua_tolstring(L, 2, &len); arg2 = &temp2; } result = (bool)(arg1)->moveTo((std::filesystem::path const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Directory_moveTo(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofDirectory, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L, argv[1]); } if (_v) { return _wrap_Directory_moveTo__SWIG_2(L);} } - } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofDirectory, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L, argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } - if (_v) { return _wrap_Directory_moveTo__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofDirectory, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L, argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } - if (_v) { { _v = lua_isboolean(L,argv[3]); } if (_v) { return _wrap_Directory_moveTo__SWIG_0(L);} } } } } + return _wrap_Directory_moveTo__SWIG_2(L);} if (argc == 3) { return _wrap_Directory_moveTo__SWIG_1(L);} if (argc == 4) { + return _wrap_Directory_moveTo__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Directory_moveTo'\n" " Possible C/C++ prototypes are:\n" " ofDirectory::moveTo(std::filesystem::path const &,bool,bool)\n" " ofDirectory::moveTo(std::filesystem::path const &,bool)\n" " ofDirectory::moveTo(std::filesystem::path const &)\n"); @@ -47385,16 +46737,8 @@ static int _wrap_Directory_renameTo__SWIG_2(lua_State* L) { int SWIG_arg = 0; of temp2 = lua_tolstring(L, 2, &len); arg2 = &temp2; } result = (bool)(arg1)->renameTo((std::filesystem::path const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Directory_renameTo(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofDirectory, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L, argv[1]); } if (_v) { return _wrap_Directory_renameTo__SWIG_2(L);} - } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofDirectory, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L, argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } - if (_v) { return _wrap_Directory_renameTo__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofDirectory, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L, argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } - if (_v) { { _v = lua_isboolean(L,argv[3]); } if (_v) { return _wrap_Directory_renameTo__SWIG_0(L);} } } } } + return _wrap_Directory_renameTo__SWIG_2(L);} if (argc == 3) { return _wrap_Directory_renameTo__SWIG_1(L);} + if (argc == 4) { return _wrap_Directory_renameTo__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Directory_renameTo'\n" " Possible C/C++ prototypes are:\n" " ofDirectory::renameTo(std::filesystem::path const &,bool,bool)\n" " ofDirectory::renameTo(std::filesystem::path const &,bool)\n" @@ -47431,14 +46775,9 @@ static int _wrap_Directory_listDir__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofD SWIG_fail_ptr("Directory_listDir",1,SWIGTYPE_p_ofDirectory); } result = (std::size_t)(arg1)->listDir(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Directory_listDir(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofDirectory, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Directory_listDir__SWIG_1(L);} } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofDirectory, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { return _wrap_Directory_listDir__SWIG_0(L);} } - } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Directory_listDir'\n" - " Possible C/C++ prototypes are:\n" " ofDirectory::listDir(std::string const &)\n" " ofDirectory::listDir()\n"); - lua_error(L);return 0; } + return _wrap_Directory_listDir__SWIG_1(L);} if (argc == 2) { return _wrap_Directory_listDir__SWIG_0(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Directory_listDir'\n" " Possible C/C++ prototypes are:\n" + " ofDirectory::listDir(std::string const &)\n" " ofDirectory::listDir()\n"); lua_error(L);return 0; } static int _wrap_Directory_getOriginalDirectory(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; std::string result; SWIG_check_num_args("ofDirectory::getOriginalDirectory",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::getOriginalDirectory",1,"ofDirectory const *"); @@ -47501,16 +46840,8 @@ static int _wrap_Directory_getFile__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofD SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofFile,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Directory_getFile(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofDirectory, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Directory_getFile__SWIG_2(L);} } - } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofDirectory, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Directory_getFile__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofDirectory, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isboolean(L,argv[3]); } if (_v) { return _wrap_Directory_getFile__SWIG_0(L);} } } } } + return _wrap_Directory_getFile__SWIG_2(L);} if (argc == 3) { return _wrap_Directory_getFile__SWIG_1(L);} if (argc == 4) { + return _wrap_Directory_getFile__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Directory_getFile'\n" " Possible C/C++ prototypes are:\n" " ofDirectory::getFile(std::size_t,ofFile::Mode,bool) const\n" " ofDirectory::getFile(std::size_t,ofFile::Mode) const\n" " ofDirectory::getFile(std::size_t) const\n"); lua_error(L);return 0; } @@ -47611,11 +46942,8 @@ static int _wrap_Directory_createDirectory__SWIG_2(lua_State* L) { int SWIG_arg result = (bool)ofDirectory::createDirectory((boost::filesystem::path const &)*arg1); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Directory_createDirectory(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); - if (argc == 1) { int _v; { _v = lua_isstring(L, argv[0]); } if (_v) { return _wrap_Directory_createDirectory__SWIG_2(L);} } - if (argc == 2) { int _v; { _v = lua_isstring(L, argv[0]); } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_Directory_createDirectory__SWIG_1(L);} } } if (argc == 3) { int _v; { _v = lua_isstring(L, argv[0]); } - if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - return _wrap_Directory_createDirectory__SWIG_0(L);} } } } + if (argc == 1) { return _wrap_Directory_createDirectory__SWIG_2(L);} if (argc == 2) { + return _wrap_Directory_createDirectory__SWIG_1(L);} if (argc == 3) { return _wrap_Directory_createDirectory__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Directory_createDirectory'\n" " Possible C/C++ prototypes are:\n" " ofDirectory::createDirectory(std::filesystem::path const &,bool,bool)\n" " ofDirectory::createDirectory(std::filesystem::path const &,bool)\n" @@ -47634,9 +46962,8 @@ static int _wrap_Directory_isDirectoryEmpty__SWIG_1(lua_State* L) { int SWIG_arg result = (bool)ofDirectory::isDirectoryEmpty((boost::filesystem::path const &)*arg1); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Directory_isDirectoryEmpty(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); - if (argc == 1) { int _v; { _v = lua_isstring(L, argv[0]); } if (_v) { return _wrap_Directory_isDirectoryEmpty__SWIG_1(L);} } - if (argc == 2) { int _v; { _v = lua_isstring(L, argv[0]); } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_Directory_isDirectoryEmpty__SWIG_0(L);} } } + if (argc == 1) { return _wrap_Directory_isDirectoryEmpty__SWIG_1(L);} if (argc == 2) { + return _wrap_Directory_isDirectoryEmpty__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Directory_isDirectoryEmpty'\n" " Possible C/C++ prototypes are:\n" " ofDirectory::isDirectoryEmpty(std::filesystem::path const &,bool)\n" " ofDirectory::isDirectoryEmpty(std::filesystem::path const &)\n"); lua_error(L);return 0; } @@ -47654,9 +46981,8 @@ static int _wrap_Directory_doesDirectoryExist__SWIG_1(lua_State* L) { int SWIG_a result = (bool)ofDirectory::doesDirectoryExist((boost::filesystem::path const &)*arg1); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Directory_doesDirectoryExist(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); - if (argc == 1) { int _v; { _v = lua_isstring(L, argv[0]); } if (_v) { return _wrap_Directory_doesDirectoryExist__SWIG_1(L);} - } if (argc == 2) { int _v; { _v = lua_isstring(L, argv[0]); } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_Directory_doesDirectoryExist__SWIG_0(L);} } } + if (argc == 1) { return _wrap_Directory_doesDirectoryExist__SWIG_1(L);} if (argc == 2) { + return _wrap_Directory_doesDirectoryExist__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Directory_doesDirectoryExist'\n" " Possible C/C++ prototypes are:\n" " ofDirectory::doesDirectoryExist(std::filesystem::path const &,bool)\n" " ofDirectory::doesDirectoryExist(std::filesystem::path const &)\n"); lua_error(L);return 0; } @@ -47676,10 +47002,8 @@ static int _wrap_Directory_removeDirectory__SWIG_1(lua_State* L) { int SWIG_arg result = (bool)ofDirectory::removeDirectory((boost::filesystem::path const &)*arg1,arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_Directory_removeDirectory(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { _v = lua_isstring(L, argv[0]); } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_Directory_removeDirectory__SWIG_1(L);} } } if (argc == 3) { int _v; { _v = lua_isstring(L, argv[0]); } - if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - return _wrap_Directory_removeDirectory__SWIG_0(L);} } } } + if (argc == 2) { return _wrap_Directory_removeDirectory__SWIG_1(L);} if (argc == 3) { + return _wrap_Directory_removeDirectory__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Directory_removeDirectory'\n" " Possible C/C++ prototypes are:\n" " ofDirectory::removeDirectory(std::filesystem::path const &,bool,bool)\n" " ofDirectory::removeDirectory(std::filesystem::path const &,bool)\n"); lua_error(L);return 0; } @@ -47712,7 +47036,6 @@ static swig_lua_method swig_Directory_methods[]= { { "isDirectory", _wrap_Directory_isDirectory}, { "isHidden", _wrap_Directory_isHidden}, { "setWriteable", _wrap_Directory_setWriteable}, - { "setReadOnly", _wrap_Directory_setReadOnly}, { "setReadable", _wrap_Directory_setReadable}, { "setExecutable", _wrap_Directory_setExecutable}, { "setShowHidden", _wrap_Directory_setShowHidden}, @@ -47774,11 +47097,11 @@ static swig_lua_class *swig_Directory_bases[] = {0}; static const char *swig_Directory_base_names[] = {0}; static swig_lua_class _wrap_class_Directory = { "Directory", "Directory", &SWIGTYPE_p_ofDirectory,_proxy__wrap_new_Directory, swig_delete_Directory, swig_Directory_methods, swig_Directory_attributes, &swig_Directory_Sf_SwigStatic, swig_Directory_meta, swig_Directory_bases, swig_Directory_base_names }; -static int _wrap_log(lua_State* L) { int SWIG_arg = 0; ofLogLevel arg1 ; string *arg2 = 0 ; SWIG_check_num_args("log",2,2) - if(!lua_isnumber(L,1)) SWIG_fail_arg("log",1,"ofLogLevel"); if(!lua_isuserdata(L,2)) SWIG_fail_arg("log",2,"string const &"); - arg1 = (ofLogLevel)(int)lua_tonumber(L, 1); if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_string,0))){ - SWIG_fail_ptr("log",2,SWIGTYPE_p_string); } log(arg1,(string const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } +static int _wrap_log(lua_State* L) { int SWIG_arg = 0; ofLogLevel arg1 ; std::string *arg2 = 0 ; std::string temp2 ; + SWIG_check_num_args("log",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("log",1,"ofLogLevel"); + if(!lua_isstring(L,2)) SWIG_fail_arg("log",2,"std::string const &"); arg1 = (ofLogLevel)(int)lua_tonumber(L, 1); + temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; log(arg1,(std::string const &)*arg2); return SWIG_arg; + if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_setLogLevel__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofLogLevel arg1 ; SWIG_check_num_args("ofSetLogLevel",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetLogLevel",1,"ofLogLevel"); arg1 = (ofLogLevel)(int)lua_tonumber(L, 1); ofSetLogLevel(arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); @@ -47788,10 +47111,8 @@ static int _wrap_setLogLevel__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::stri if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSetLogLevel",2,"ofLogLevel"); (&arg1)->assign(lua_tostring(L,1),lua_rawlen(L,1)); arg2 = (ofLogLevel)(int)lua_tonumber(L, 2); ofSetLogLevel(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setLogLevel(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_setLogLevel__SWIG_0(L);} } if (argc == 2) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_setLogLevel__SWIG_1(L);} } } +static int _wrap_setLogLevel(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { + return _wrap_setLogLevel__SWIG_0(L);} if (argc == 2) { return _wrap_setLogLevel__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'setLogLevel'\n" " Possible C/C++ prototypes are:\n" " ofSetLogLevel(ofLogLevel)\n" " ofSetLogLevel(std::string,ofLogLevel)\n"); lua_error(L);return 0; } static int _wrap_getLogLevel__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofLogLevel result; @@ -47804,8 +47125,7 @@ static int _wrap_getLogLevel__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::stri lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_getLogLevel(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_getLogLevel__SWIG_0(L);} if (argc == 1) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { - return _wrap_getLogLevel__SWIG_1(L);} } + return _wrap_getLogLevel__SWIG_0(L);} if (argc == 1) { return _wrap_getLogLevel__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'getLogLevel'\n" " Possible C/C++ prototypes are:\n" " ofGetLogLevel()\n" " ofGetLogLevel(std::string)\n"); lua_error(L);return 0; } static int _wrap_getLogLevelName__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofLogLevel arg1 ; bool arg2 ; std::string result; @@ -47819,10 +47139,8 @@ static int _wrap_getLogLevelName__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofLog arg1 = (ofLogLevel)(int)lua_tonumber(L, 1); result = ofGetLogLevelName(arg1); lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getLogLevelName(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; - { _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_getLogLevelName__SWIG_1(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_getLogLevelName__SWIG_0(L);} } } +static int _wrap_getLogLevelName(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { + return _wrap_getLogLevelName__SWIG_1(L);} if (argc == 2) { return _wrap_getLogLevelName__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'getLogLevelName'\n" " Possible C/C++ prototypes are:\n" " ofGetLogLevelName(ofLogLevel,bool)\n" " ofGetLogLevelName(ofLogLevel)\n"); lua_error(L);return 0; } static int _wrap_logToFile__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::filesystem::path *arg1 = 0 ; bool arg2 ; @@ -47837,137 +47155,19 @@ static int _wrap_logToFile__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::filesy if(!lua_isstring(L,1)) SWIG_fail_arg("ofLogToFile",1,"std::filesystem::path const &"); { size_t len = lua_rawlen(L, 1); temp1 = lua_tolstring(L, 1, &len); arg1 = &temp1; } ofLogToFile((boost::filesystem::path const &)*arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_logToFile(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - _v = lua_isstring(L, argv[0]); } if (_v) { return _wrap_logToFile__SWIG_1(L);} } if (argc == 2) { int _v; { - _v = lua_isstring(L, argv[0]); } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_logToFile__SWIG_0(L);} } } +static int _wrap_logToFile(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { + return _wrap_logToFile__SWIG_1(L);} if (argc == 2) { return _wrap_logToFile__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'logToFile'\n" " Possible C/C++ prototypes are:\n" " ofLogToFile(std::filesystem::path const &,bool)\n" " ofLogToFile(std::filesystem::path const &)\n"); lua_error(L);return 0; } static int _wrap_logToConsole(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofLogToConsole",0,0) ofLogToConsole(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_logToDebugView(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofLogToDebugView",0,0) - ofLogToDebugView(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_getLoggerChannel(lua_State* L) { int SWIG_arg = 0; SwigValueWrapper< std::shared_ptr< ofBaseLoggerChannel > > result; SWIG_check_num_args("ofGetLoggerChannel",0,0) result = ofGetLoggerChannel(); { std::shared_ptr< ofBaseLoggerChannel > * resultptr = new std::shared_ptr< ofBaseLoggerChannel >((const std::shared_ptr< ofBaseLoggerChannel > &) result); SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__shared_ptrT_ofBaseLoggerChannel_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_DebugViewLoggerChannel_log__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofDebugViewLoggerChannel *arg1 = (ofDebugViewLoggerChannel *) 0 ; ofLogLevel arg2 ; std::string *arg3 = 0 ; - std::string *arg4 = 0 ; std::string temp3 ; std::string temp4 ; SWIG_check_num_args("ofDebugViewLoggerChannel::log",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDebugViewLoggerChannel::log",1,"ofDebugViewLoggerChannel *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDebugViewLoggerChannel::log",2,"ofLogLevel"); - if(!lua_isstring(L,3)) SWIG_fail_arg("ofDebugViewLoggerChannel::log",3,"std::string const &"); - if(!lua_isstring(L,4)) SWIG_fail_arg("ofDebugViewLoggerChannel::log",4,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDebugViewLoggerChannel,0))){ - SWIG_fail_ptr("DebugViewLoggerChannel_log",1,SWIGTYPE_p_ofDebugViewLoggerChannel); } - arg2 = (ofLogLevel)(int)lua_tonumber(L, 2); temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3; - temp4.assign(lua_tostring(L,4),lua_rawlen(L,4)); arg4=&temp4; - (arg1)->log(arg2,(std::string const &)*arg3,(std::string const &)*arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_DebugViewLoggerChannel_log__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofDebugViewLoggerChannel *arg1 = (ofDebugViewLoggerChannel *) 0 ; ofLogLevel arg2 ; std::string *arg3 = 0 ; - char *arg4 = (char *) 0 ; void *arg5 = 0 ; std::string temp3 ; SWIG_check_num_args("ofDebugViewLoggerChannel::log",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDebugViewLoggerChannel::log",1,"ofDebugViewLoggerChannel *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDebugViewLoggerChannel::log",2,"ofLogLevel"); - if(!lua_isstring(L,3)) SWIG_fail_arg("ofDebugViewLoggerChannel::log",3,"std::string const &"); - if(!SWIG_lua_isnilstring(L,4)) SWIG_fail_arg("ofDebugViewLoggerChannel::log",4,"char const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDebugViewLoggerChannel,0))){ - SWIG_fail_ptr("DebugViewLoggerChannel_log",1,SWIGTYPE_p_ofDebugViewLoggerChannel); } - arg2 = (ofLogLevel)(int)lua_tonumber(L, 2); temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3; - arg4 = (char *)lua_tostring(L, 4); (arg1)->log(arg2,(std::string const &)*arg3,(char const *)arg4,arg5); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_DebugViewLoggerChannel_log__SWIG_2(lua_State* L) { int SWIG_arg = 0; - ofDebugViewLoggerChannel *arg1 = (ofDebugViewLoggerChannel *) 0 ; ofLogLevel arg2 ; std::string *arg3 = 0 ; - char *arg4 = (char *) 0 ; va_list arg5 ; std::string temp3 ; va_list *argp5 ; - SWIG_check_num_args("ofDebugViewLoggerChannel::log",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDebugViewLoggerChannel::log",1,"ofDebugViewLoggerChannel *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDebugViewLoggerChannel::log",2,"ofLogLevel"); - if(!lua_isstring(L,3)) SWIG_fail_arg("ofDebugViewLoggerChannel::log",3,"std::string const &"); - if(!SWIG_lua_isnilstring(L,4)) SWIG_fail_arg("ofDebugViewLoggerChannel::log",4,"char const *"); - if(!lua_isuserdata(L,5)) SWIG_fail_arg("ofDebugViewLoggerChannel::log",5,"va_list"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDebugViewLoggerChannel,0))){ - SWIG_fail_ptr("DebugViewLoggerChannel_log",1,SWIGTYPE_p_ofDebugViewLoggerChannel); } - arg2 = (ofLogLevel)(int)lua_tonumber(L, 2); temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3; - arg4 = (char *)lua_tostring(L, 4); if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&argp5,SWIGTYPE_p_va_list,0))){ - SWIG_fail_ptr("DebugViewLoggerChannel_log",5,SWIGTYPE_p_va_list); } arg5 = *argp5; - (arg1)->log(arg2,(std::string const &)*arg3,(char const *)arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_DebugViewLoggerChannel_log(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); - if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofDebugViewLoggerChannel, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isstring(L,argv[2]); } - if (_v) { { _v = lua_isstring(L,argv[3]); } if (_v) { return _wrap_DebugViewLoggerChannel_log__SWIG_0(L);} } } } } - if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofDebugViewLoggerChannel, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isstring(L,argv[2]); } - if (_v) { { _v = SWIG_lua_isnilstring(L,argv[3]); } if (_v) { if (argc <= 4) { - return _wrap_DebugViewLoggerChannel_log__SWIG_1(L);} return _wrap_DebugViewLoggerChannel_log__SWIG_1(L);} } } } - } if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofDebugViewLoggerChannel, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isstring(L,argv[2]); } - if (_v) { { _v = SWIG_lua_isnilstring(L,argv[3]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[4])==0 || SWIG_ConvertPtr(L,argv[4], (void **) &ptr, SWIGTYPE_p_va_list, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_DebugViewLoggerChannel_log__SWIG_2(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'DebugViewLoggerChannel_log'\n" - " Possible C/C++ prototypes are:\n" " ofDebugViewLoggerChannel::log(ofLogLevel,std::string const &,std::string const &)\n" - " ofDebugViewLoggerChannel::log(ofLogLevel,std::string const &,char const *,...)\n" - " ofDebugViewLoggerChannel::log(ofLogLevel,std::string const &,char const *,va_list)\n"); lua_error(L);return 0; } -static int _wrap_new_DebugViewLoggerChannel(lua_State* L) { int SWIG_arg = 0; ofDebugViewLoggerChannel *result = 0 ; - SWIG_check_num_args("ofDebugViewLoggerChannel::ofDebugViewLoggerChannel",0,0) - result = (ofDebugViewLoggerChannel *)new ofDebugViewLoggerChannel(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofDebugViewLoggerChannel,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static void swig_delete_DebugViewLoggerChannel(void *obj) { -ofDebugViewLoggerChannel *arg1 = (ofDebugViewLoggerChannel *) obj; -delete arg1; -} -static int _proxy__wrap_new_DebugViewLoggerChannel(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_DebugViewLoggerChannel); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_DebugViewLoggerChannel_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_DebugViewLoggerChannel_methods[]= { - { "log", _wrap_DebugViewLoggerChannel_log}, - {0,0} -}; -static swig_lua_method swig_DebugViewLoggerChannel_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_DebugViewLoggerChannel_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_DebugViewLoggerChannel_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_DebugViewLoggerChannel_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_DebugViewLoggerChannel_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_DebugViewLoggerChannel_Sf_SwigStatic = { - "DebugViewLoggerChannel", - swig_DebugViewLoggerChannel_Sf_SwigStatic_methods, - swig_DebugViewLoggerChannel_Sf_SwigStatic_attributes, - swig_DebugViewLoggerChannel_Sf_SwigStatic_constants, - swig_DebugViewLoggerChannel_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_DebugViewLoggerChannel_bases[] = {0}; -static const char *swig_DebugViewLoggerChannel_base_names[] = {0}; -static swig_lua_class _wrap_class_DebugViewLoggerChannel = { "DebugViewLoggerChannel", "DebugViewLoggerChannel", &SWIGTYPE_p_ofDebugViewLoggerChannel,_proxy__wrap_new_DebugViewLoggerChannel, swig_delete_DebugViewLoggerChannel, swig_DebugViewLoggerChannel_methods, swig_DebugViewLoggerChannel_attributes, &swig_DebugViewLoggerChannel_Sf_SwigStatic, swig_DebugViewLoggerChannel_meta, swig_DebugViewLoggerChannel_bases, swig_DebugViewLoggerChannel_base_names }; - static int _wrap_new_FileDialogResult(lua_State* L) { int SWIG_arg = 0; ofFileDialogResult *result = 0 ; SWIG_check_num_args("ofFileDialogResult::ofFileDialogResult",0,0) result = (ofFileDialogResult *)new ofFileDialogResult(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofFileDialogResult,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: @@ -48121,11 +47321,8 @@ static int _wrap_systemLoadDialog__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofFi SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofFileDialogResult,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_systemLoadDialog(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_systemLoadDialog__SWIG_3(L);} if (argc == 1) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { - return _wrap_systemLoadDialog__SWIG_2(L);} } if (argc == 2) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { { - _v = lua_isboolean(L,argv[1]); } if (_v) { return _wrap_systemLoadDialog__SWIG_1(L);} } } if (argc == 3) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { { _v = lua_isstring(L,argv[2]); } - if (_v) { return _wrap_systemLoadDialog__SWIG_0(L);} } } } + return _wrap_systemLoadDialog__SWIG_3(L);} if (argc == 1) { return _wrap_systemLoadDialog__SWIG_2(L);} if (argc == 2) { + return _wrap_systemLoadDialog__SWIG_1(L);} if (argc == 3) { return _wrap_systemLoadDialog__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'systemLoadDialog'\n" " Possible C/C++ prototypes are:\n" " ofSystemLoadDialog(std::string,bool,std::string)\n" " ofSystemLoadDialog(std::string,bool)\n" " ofSystemLoadDialog(std::string)\n" " ofSystemLoadDialog()\n"); lua_error(L);return 0; } @@ -48152,9 +47349,7 @@ static int _wrap_systemTextBoxDialog__SWIG_1(lua_State* L) { int SWIG_arg = 0; s lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_systemTextBoxDialog(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { return _wrap_systemTextBoxDialog__SWIG_1(L);} } if (argc == 2) { - int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { - return _wrap_systemTextBoxDialog__SWIG_0(L);} } } + return _wrap_systemTextBoxDialog__SWIG_1(L);} if (argc == 2) { return _wrap_systemTextBoxDialog__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'systemTextBoxDialog'\n" " Possible C/C++ prototypes are:\n" " ofSystemTextBoxDialog(std::string,std::string)\n" " ofSystemTextBoxDialog(std::string)\n"); lua_error(L);return 0; } @@ -48182,10 +47377,8 @@ static int _wrap_new_HttpRequest__SWIG_2(lua_State* L) { int SWIG_arg = 0; std:: SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofHttpRequest,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_new_HttpRequest(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_HttpRequest__SWIG_0(L);} if (argc == 2) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { { - _v = lua_isstring(L,argv[1]); } if (_v) { return _wrap_new_HttpRequest__SWIG_2(L);} } } if (argc == 3) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } - if (_v) { return _wrap_new_HttpRequest__SWIG_1(L);} } } } + return _wrap_new_HttpRequest__SWIG_0(L);} if (argc == 2) { return _wrap_new_HttpRequest__SWIG_2(L);} if (argc == 3) { + return _wrap_new_HttpRequest__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_HttpRequest'\n" " Possible C/C++ prototypes are:\n" " ofHttpRequest::ofHttpRequest()\n" " ofHttpRequest::ofHttpRequest(std::string const &,std::string const &,bool)\n" " ofHttpRequest::ofHttpRequest(std::string const &,std::string const &)\n"); lua_error(L);return 0; } @@ -48233,23 +47426,23 @@ static int _wrap_HttpRequest_saveTo_get(lua_State* L) { int SWIG_arg = 0; ofHttp SWIG_fail_ptr("HttpRequest_saveTo_get",1,SWIGTYPE_p_ofHttpRequest); } result = (bool) ((arg1)->saveTo); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_HttpRequest_headers_set(lua_State* L) { int SWIG_arg = 0; ofHttpRequest *arg1 = (ofHttpRequest *) 0 ; - std::map< std::string,std::string > *arg2 = (std::map< std::string,std::string > *) 0 ; + std::map< std::string,std::string,std::less< std::string > > *arg2 = (std::map< std::string,std::string,std::less< std::string > > *) 0 ; SWIG_check_num_args("ofHttpRequest::headers",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofHttpRequest::headers",1,"ofHttpRequest *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofHttpRequest::headers",2,"std::map< std::string,std::string > *"); + if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofHttpRequest::headers",2,"std::map< std::string,std::string,std::less< std::string > > *"); if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofHttpRequest,0))){ SWIG_fail_ptr("HttpRequest_headers_set",1,SWIGTYPE_p_ofHttpRequest); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__mapT_std__string_std__string_t,0))){ - SWIG_fail_ptr("HttpRequest_headers_set",2,SWIGTYPE_p_std__mapT_std__string_std__string_t); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__mapT_std__string_std__string_std__lessT_std__string_t_t,0))){ + SWIG_fail_ptr("HttpRequest_headers_set",2,SWIGTYPE_p_std__mapT_std__string_std__string_std__lessT_std__string_t_t); } if (arg1) (arg1)->headers = *arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_HttpRequest_headers_get(lua_State* L) { int SWIG_arg = 0; ofHttpRequest *arg1 = (ofHttpRequest *) 0 ; - std::map< std::string,std::string > *result = 0 ; SWIG_check_num_args("ofHttpRequest::headers",1,1) + std::map< std::string,std::string,std::less< std::string > > *result = 0 ; SWIG_check_num_args("ofHttpRequest::headers",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofHttpRequest::headers",1,"ofHttpRequest *"); if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofHttpRequest,0))){ SWIG_fail_ptr("HttpRequest_headers_get",1,SWIGTYPE_p_ofHttpRequest); } - result = (std::map< std::string,std::string > *)& ((arg1)->headers); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__mapT_std__string_std__string_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } + result = (std::map< std::string,std::string,std::less< std::string > > *)& ((arg1)->headers); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__mapT_std__string_std__string_std__lessT_std__string_t_t,0); SWIG_arg++; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_HttpRequest_body_set(lua_State* L) { int SWIG_arg = 0; ofHttpRequest *arg1 = (ofHttpRequest *) 0 ; std::string *arg2 = 0 ; std::string temp2 ; SWIG_check_num_args("ofHttpRequest::body",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofHttpRequest::body",1,"ofHttpRequest *"); @@ -48424,15 +47617,8 @@ static int _wrap_new_HttpResponse__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofHt SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofHttpResponse,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_new_HttpResponse(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_HttpResponse__SWIG_0(L);} if (argc == 3) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofHttpRequest, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isstring(L,argv[2]); } if (_v) { - return _wrap_new_HttpResponse__SWIG_2(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofHttpRequest, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBuffer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isstring(L,argv[3]); } - if (_v) { return _wrap_new_HttpResponse__SWIG_1(L);} } } } } + return _wrap_new_HttpResponse__SWIG_0(L);} if (argc == 3) { return _wrap_new_HttpResponse__SWIG_2(L);} if (argc == 4) { + return _wrap_new_HttpResponse__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_HttpResponse'\n" " Possible C/C++ prototypes are:\n" " ofHttpResponse::ofHttpResponse()\n" " ofHttpResponse::ofHttpResponse(ofHttpRequest const &,ofBuffer const &,int,std::string const &)\n" @@ -48565,10 +47751,8 @@ static int _wrap_loadURLAsync__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::str SWIG_check_num_args("ofLoadURLAsync",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofLoadURLAsync",1,"std::string const &"); temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = (int)ofLoadURLAsync((std::string const &)*arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_loadURLAsync(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { return _wrap_loadURLAsync__SWIG_1(L);} } if (argc == 2) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { - return _wrap_loadURLAsync__SWIG_0(L);} } } +static int _wrap_loadURLAsync(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { + return _wrap_loadURLAsync__SWIG_1(L);} if (argc == 2) { return _wrap_loadURLAsync__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'loadURLAsync'\n" " Possible C/C++ prototypes are:\n" " ofLoadURLAsync(std::string const &,std::string const &)\n" " ofLoadURLAsync(std::string const &)\n"); lua_error(L);return 0; } @@ -48597,10 +47781,6 @@ static int _wrap_removeAllURLRequests(lua_State* L) { int SWIG_arg = 0; SWIG_che ofRemoveAllURLRequests(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_stopURLLoader(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofStopURLLoader",0,0) ofStopURLLoader(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_uRLResponseEvent(lua_State* L) { int SWIG_arg = 0; ofEvent< ofHttpResponse > *result = 0 ; - SWIG_check_num_args("ofURLResponseEvent",0,0) result = (ofEvent< ofHttpResponse > *) &ofURLResponseEvent(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofEventT_ofHttpResponse_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } static int _wrap_new_URLFileLoader(lua_State* L) { int SWIG_arg = 0; ofURLFileLoader *result = 0 ; SWIG_check_num_args("ofURLFileLoader::ofURLFileLoader",0,0) result = (ofURLFileLoader *)new ofURLFileLoader(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofURLFileLoader,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); @@ -48636,13 +47816,8 @@ static int _wrap_URLFileLoader_getAsync__SWIG_1(lua_State* L) { int SWIG_arg = 0 temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; result = (int)(arg1)->getAsync((std::string const &)*arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_URLFileLoader_getAsync(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofURLFileLoader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { - return _wrap_URLFileLoader_getAsync__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofURLFileLoader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isstring(L,argv[2]); } if (_v) { - return _wrap_URLFileLoader_getAsync__SWIG_0(L);} } } } + if (argc == 2) { return _wrap_URLFileLoader_getAsync__SWIG_1(L);} if (argc == 3) { + return _wrap_URLFileLoader_getAsync__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'URLFileLoader_getAsync'\n" " Possible C/C++ prototypes are:\n" " ofURLFileLoader::getAsync(std::string const &,std::string const &)\n" " ofURLFileLoader::getAsync(std::string const &)\n"); lua_error(L);return 0; } @@ -48770,624 +47945,6 @@ static swig_lua_class *swig_URLFileLoader_bases[] = {0}; static const char *swig_URLFileLoader_base_names[] = {0}; static swig_lua_class _wrap_class_URLFileLoader = { "URLFileLoader", "URLFileLoader", &SWIGTYPE_p_ofURLFileLoader,_proxy__wrap_new_URLFileLoader, swig_delete_URLFileLoader, swig_URLFileLoader_methods, swig_URLFileLoader_attributes, &swig_URLFileLoader_Sf_SwigStatic, swig_URLFileLoader_meta, swig_URLFileLoader_bases, swig_URLFileLoader_base_names }; -static int _wrap_resetElapsedTimeCounter(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofResetElapsedTimeCounter",0,0) - ofResetElapsedTimeCounter(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getElapsedTimef(lua_State* L) { int SWIG_arg = 0; float result; SWIG_check_num_args("ofGetElapsedTimef",0,0) - result = (float)ofGetElapsedTimef(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_getElapsedTimeMillis(lua_State* L) { int SWIG_arg = 0; uint64_t result; - SWIG_check_num_args("ofGetElapsedTimeMillis",0,0) result = (uint64_t)ofGetElapsedTimeMillis(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getElapsedTimeMicros(lua_State* L) { int SWIG_arg = 0; uint64_t result; - SWIG_check_num_args("ofGetElapsedTimeMicros",0,0) result = (uint64_t)ofGetElapsedTimeMicros(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getSeconds(lua_State* L) { int SWIG_arg = 0; int result; SWIG_check_num_args("ofGetSeconds",0,0) - result = (int)ofGetSeconds(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_getMinutes(lua_State* L) { int SWIG_arg = 0; int result; SWIG_check_num_args("ofGetMinutes",0,0) - result = (int)ofGetMinutes(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_getHours(lua_State* L) { int SWIG_arg = 0; int result; SWIG_check_num_args("ofGetHours",0,0) - result = (int)ofGetHours(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_getUnixTime(lua_State* L) { int SWIG_arg = 0; unsigned int result; SWIG_check_num_args("ofGetUnixTime",0,0) - result = (unsigned int)ofGetUnixTime(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_getSystemTime(lua_State* L) { int SWIG_arg = 0; uint64_t result; SWIG_check_num_args("ofGetSystemTime",0,0) - result = (uint64_t)ofGetSystemTime(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_getSystemTimeMillis(lua_State* L) { int SWIG_arg = 0; uint64_t result; - SWIG_check_num_args("ofGetSystemTimeMillis",0,0) result = (uint64_t)ofGetSystemTimeMillis(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getSystemTimeMicros(lua_State* L) { int SWIG_arg = 0; uint64_t result; - SWIG_check_num_args("ofGetSystemTimeMicros",0,0) result = (uint64_t)ofGetSystemTimeMicros(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Time_seconds_set(lua_State* L) { int SWIG_arg = 0; ofTime *arg1 = (ofTime *) 0 ; uint64_t arg2 ; - SWIG_check_num_args("ofTime::seconds",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTime::seconds",1,"ofTime *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTime::seconds",2,"uint64_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTime,0))){ - SWIG_fail_ptr("Time_seconds_set",1,SWIGTYPE_p_ofTime); } arg2 = (uint64_t)lua_tonumber(L, 2); - if (arg1) (arg1)->seconds = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Time_seconds_get(lua_State* L) { int SWIG_arg = 0; ofTime *arg1 = (ofTime *) 0 ; uint64_t result; - SWIG_check_num_args("ofTime::seconds",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTime::seconds",1,"ofTime *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTime,0))){ - SWIG_fail_ptr("Time_seconds_get",1,SWIGTYPE_p_ofTime); } result = (uint64_t) ((arg1)->seconds); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Time_nanoseconds_set(lua_State* L) { int SWIG_arg = 0; ofTime *arg1 = (ofTime *) 0 ; uint64_t arg2 ; - SWIG_check_num_args("ofTime::nanoseconds",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTime::nanoseconds",1,"ofTime *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTime::nanoseconds",2,"uint64_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTime,0))){ - SWIG_fail_ptr("Time_nanoseconds_set",1,SWIGTYPE_p_ofTime); } arg2 = (uint64_t)lua_tonumber(L, 2); - if (arg1) (arg1)->nanoseconds = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Time_nanoseconds_get(lua_State* L) { int SWIG_arg = 0; ofTime *arg1 = (ofTime *) 0 ; uint64_t result; - SWIG_check_num_args("ofTime::nanoseconds",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTime::nanoseconds",1,"ofTime *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTime,0))){ - SWIG_fail_ptr("Time_nanoseconds_get",1,SWIGTYPE_p_ofTime); } result = (uint64_t) ((arg1)->nanoseconds); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Time_mode_set(lua_State* L) { int SWIG_arg = 0; ofTime *arg1 = (ofTime *) 0 ; enum ofTime::Mode arg2 ; - SWIG_check_num_args("ofTime::mode",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTime::mode",1,"ofTime *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTime::mode",2,"enum ofTime::Mode"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTime,0))){ SWIG_fail_ptr("Time_mode_set",1,SWIGTYPE_p_ofTime); } - arg2 = (enum ofTime::Mode)(int)lua_tonumber(L, 2); if (arg1) (arg1)->mode = arg2; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Time_mode_get(lua_State* L) { int SWIG_arg = 0; ofTime *arg1 = (ofTime *) 0 ; enum ofTime::Mode result; - SWIG_check_num_args("ofTime::mode",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTime::mode",1,"ofTime *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTime,0))){ SWIG_fail_ptr("Time_mode_get",1,SWIGTYPE_p_ofTime); } - result = (enum ofTime::Mode) ((arg1)->mode); lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Time_getAsMilliseconds(lua_State* L) { int SWIG_arg = 0; ofTime *arg1 = (ofTime *) 0 ; uint64_t result; - SWIG_check_num_args("ofTime::getAsMilliseconds",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTime::getAsMilliseconds",1,"ofTime const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTime,0))){ - SWIG_fail_ptr("Time_getAsMilliseconds",1,SWIGTYPE_p_ofTime); } - result = (uint64_t)((ofTime const *)arg1)->getAsMilliseconds(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Time_getAsMicroseconds(lua_State* L) { int SWIG_arg = 0; ofTime *arg1 = (ofTime *) 0 ; uint64_t result; - SWIG_check_num_args("ofTime::getAsMicroseconds",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTime::getAsMicroseconds",1,"ofTime const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTime,0))){ - SWIG_fail_ptr("Time_getAsMicroseconds",1,SWIGTYPE_p_ofTime); } - result = (uint64_t)((ofTime const *)arg1)->getAsMicroseconds(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Time_getAsNanoseconds(lua_State* L) { int SWIG_arg = 0; ofTime *arg1 = (ofTime *) 0 ; uint64_t result; - SWIG_check_num_args("ofTime::getAsNanoseconds",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTime::getAsNanoseconds",1,"ofTime const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTime,0))){ - SWIG_fail_ptr("Time_getAsNanoseconds",1,SWIGTYPE_p_ofTime); } - result = (uint64_t)((ofTime const *)arg1)->getAsNanoseconds(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Time_getAsSeconds(lua_State* L) { int SWIG_arg = 0; ofTime *arg1 = (ofTime *) 0 ; double result; - SWIG_check_num_args("ofTime::getAsSeconds",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTime::getAsSeconds",1,"ofTime const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTime,0))){ - SWIG_fail_ptr("Time_getAsSeconds",1,SWIGTYPE_p_ofTime); } result = (double)((ofTime const *)arg1)->getAsSeconds(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Time_getAsTimePoint(lua_State* L) { int SWIG_arg = 0; ofTime *arg1 = (ofTime *) 0 ; - std::chrono::time_point< std::chrono::nanoseconds > result; SWIG_check_num_args("ofTime::getAsTimePoint",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTime::getAsTimePoint",1,"ofTime const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTime,0))){ - SWIG_fail_ptr("Time_getAsTimePoint",1,SWIGTYPE_p_ofTime); } result = ((ofTime const *)arg1)->getAsTimePoint(); { - std::chrono::time_point< std::chrono::nanoseconds > * resultptr = new std::chrono::time_point< std::chrono::nanoseconds >((const std::chrono::time_point< std::chrono::nanoseconds > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__chrono__time_pointT_std__chrono__nanoseconds_t,1); SWIG_arg++; } - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Time___sub(lua_State* L) { int SWIG_arg = 0; ofTime *arg1 = (ofTime *) 0 ; ofTime *arg2 = 0 ; - std::chrono::nanoseconds result; SWIG_check_num_args("ofTime::operator -",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTime::operator -",1,"ofTime const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofTime::operator -",2,"ofTime const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTime,0))){ SWIG_fail_ptr("Time___sub",1,SWIGTYPE_p_ofTime); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofTime,0))){ SWIG_fail_ptr("Time___sub",2,SWIGTYPE_p_ofTime); } - result = ((ofTime const *)arg1)->operator -((ofTime const &)*arg2); { - std::chrono::nanoseconds * resultptr = new std::chrono::nanoseconds((const std::chrono::nanoseconds &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__chrono__nanoseconds,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Time___lt(lua_State* L) { int SWIG_arg = 0; ofTime *arg1 = (ofTime *) 0 ; ofTime *arg2 = 0 ; bool result; - SWIG_check_num_args("ofTime::operator <",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTime::operator <",1,"ofTime const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofTime::operator <",2,"ofTime const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTime,0))){ SWIG_fail_ptr("Time___lt",1,SWIGTYPE_p_ofTime); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofTime,0))){ SWIG_fail_ptr("Time___lt",2,SWIGTYPE_p_ofTime); } - result = (bool)((ofTime const *)arg1)->operator <((ofTime const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Time___le(lua_State* L) { int SWIG_arg = 0; ofTime *arg1 = (ofTime *) 0 ; ofTime *arg2 = 0 ; bool result; - SWIG_check_num_args("ofTime::operator <=",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTime::operator <=",1,"ofTime const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofTime::operator <=",2,"ofTime const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTime,0))){ SWIG_fail_ptr("Time___le",1,SWIGTYPE_p_ofTime); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofTime,0))){ SWIG_fail_ptr("Time___le",2,SWIGTYPE_p_ofTime); } - result = (bool)((ofTime const *)arg1)->operator <=((ofTime const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_new_Time(lua_State* L) { int SWIG_arg = 0; ofTime *result = 0 ; SWIG_check_num_args("ofTime::ofTime",0,0) - result = (ofTime *)new ofTime(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTime,1); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_Time(void *obj) { -ofTime *arg1 = (ofTime *) obj; -delete arg1; -} -static int _proxy__wrap_new_Time(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_Time); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_Time_attributes[] = { - { "seconds", _wrap_Time_seconds_get, _wrap_Time_seconds_set }, - { "nanoseconds", _wrap_Time_nanoseconds_get, _wrap_Time_nanoseconds_set }, - { "mode", _wrap_Time_mode_get, _wrap_Time_mode_set }, - {0,0,0} -}; -static swig_lua_method swig_Time_methods[]= { - { "getAsMilliseconds", _wrap_Time_getAsMilliseconds}, - { "getAsMicroseconds", _wrap_Time_getAsMicroseconds}, - { "getAsNanoseconds", _wrap_Time_getAsNanoseconds}, - { "getAsSeconds", _wrap_Time_getAsSeconds}, - { "getAsTimePoint", _wrap_Time_getAsTimePoint}, - { "__sub", _wrap_Time___sub}, - { "__lt", _wrap_Time___lt}, - { "__le", _wrap_Time___le}, - {0,0} -}; -static swig_lua_method swig_Time_meta[] = { - { "__sub", _wrap_Time___sub}, - { "__lt", _wrap_Time___lt}, - { "__le", _wrap_Time___le}, - {0,0} -}; - -static swig_lua_attribute swig_Time_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_Time_Sf_SwigStatic_constants[]= { - {SWIG_LUA_CONSTTAB_INT("System", ofTime::System)}, - {SWIG_LUA_CONSTTAB_INT("FixedRate", ofTime::FixedRate)}, - {0,0,0,0,0,0} -}; -static swig_lua_method swig_Time_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_Time_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_Time_Sf_SwigStatic = { - "Time", - swig_Time_Sf_SwigStatic_methods, - swig_Time_Sf_SwigStatic_attributes, - swig_Time_Sf_SwigStatic_constants, - swig_Time_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_Time_bases[] = {0}; -static const char *swig_Time_base_names[] = {0}; -static swig_lua_class _wrap_class_Time = { "Time", "Time", &SWIGTYPE_p_ofTime,_proxy__wrap_new_Time, swig_delete_Time, swig_Time_methods, swig_Time_attributes, &swig_Time_Sf_SwigStatic, swig_Time_meta, swig_Time_bases, swig_Time_base_names }; - -static int _wrap_getCurrentTime(lua_State* L) { int SWIG_arg = 0; ofTime result; SWIG_check_num_args("ofGetCurrentTime",0,0) - result = ofGetCurrentTime(); { ofTime * resultptr = new ofTime((const ofTime &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofTime,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_sleepMillis(lua_State* L) { int SWIG_arg = 0; int arg1 ; SWIG_check_num_args("ofSleepMillis",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSleepMillis",1,"int"); arg1 = (int)lua_tonumber(L, 1); ofSleepMillis(arg1); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getTimestampString__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string result; - SWIG_check_num_args("ofGetTimestampString",0,0) result = ofGetTimestampString(); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_getTimestampString__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - std::string result; SWIG_check_num_args("ofGetTimestampString",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofGetTimestampString",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = ofGetTimestampString((std::string const &)*arg1); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_getTimestampString(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_getTimestampString__SWIG_0(L);} if (argc == 1) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { - return _wrap_getTimestampString__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'getTimestampString'\n" " Possible C/C++ prototypes are:\n" - " ofGetTimestampString()\n" " ofGetTimestampString(std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_getYear(lua_State* L) { int SWIG_arg = 0; int result; SWIG_check_num_args("ofGetYear",0,0) - result = (int)ofGetYear(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_getMonth(lua_State* L) { int SWIG_arg = 0; int result; SWIG_check_num_args("ofGetMonth",0,0) - result = (int)ofGetMonth(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_getDay(lua_State* L) { int SWIG_arg = 0; int result; SWIG_check_num_args("ofGetDay",0,0) - result = (int)ofGetDay(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_getWeekday(lua_State* L) { int SWIG_arg = 0; int result; SWIG_check_num_args("ofGetWeekday",0,0) - result = (int)ofGetWeekday(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_enableDataPath(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofEnableDataPath",0,0) - ofEnableDataPath(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_disableDataPath(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofDisableDataPath",0,0) - ofDisableDataPath(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_toDataPath__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::filesystem::path *arg1 = 0 ; bool arg2 ; - std::filesystem::path temp1 ; std::string result; SWIG_check_num_args("ofToDataPath",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofToDataPath",1,"std::filesystem::path const &"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofToDataPath",2,"bool"); { size_t len = lua_rawlen(L, 1); - temp1 = lua_tolstring(L, 1, &len); arg1 = &temp1; } arg2 = (lua_toboolean(L, 2)!=0); - result = ofToDataPath((boost::filesystem::path const &)*arg1,arg2); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_toDataPath__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::filesystem::path *arg1 = 0 ; - std::filesystem::path temp1 ; std::string result; SWIG_check_num_args("ofToDataPath",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofToDataPath",1,"std::filesystem::path const &"); { size_t len = lua_rawlen(L, 1); - temp1 = lua_tolstring(L, 1, &len); arg1 = &temp1; } result = ofToDataPath((boost::filesystem::path const &)*arg1); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_toDataPath(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - _v = lua_isstring(L, argv[0]); } if (_v) { return _wrap_toDataPath__SWIG_1(L);} } if (argc == 2) { int _v; { - _v = lua_isstring(L, argv[0]); } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_toDataPath__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'toDataPath'\n" " Possible C/C++ prototypes are:\n" - " ofToDataPath(std::filesystem::path const &,bool)\n" " ofToDataPath(std::filesystem::path const &)\n"); - lua_error(L);return 0; } -static int _wrap_restoreWorkingDirectoryToDefault(lua_State* L) { int SWIG_arg = 0; bool result; - SWIG_check_num_args("ofRestoreWorkingDirectoryToDefault",0,0) result = (bool)ofRestoreWorkingDirectoryToDefault(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setDataPathRoot(lua_State* L) { int SWIG_arg = 0; std::filesystem::path *arg1 = 0 ; - std::filesystem::path temp1 ; SWIG_check_num_args("ofSetDataPathRoot",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofSetDataPathRoot",1,"std::filesystem::path const &"); { size_t len = lua_rawlen(L, 1); - temp1 = lua_tolstring(L, 1, &len); arg1 = &temp1; } ofSetDataPathRoot((boost::filesystem::path const &)*arg1); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_splitString__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; - bool arg3 ; bool arg4 ; std::string temp1 ; std::string temp2 ; std::vector< std::string > result; - SWIG_check_num_args("ofSplitString",4,4) if(!lua_isstring(L,1)) SWIG_fail_arg("ofSplitString",1,"std::string const &"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofSplitString",2,"std::string const &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofSplitString",3,"bool"); - if(!lua_isboolean(L,4)) SWIG_fail_arg("ofSplitString",4,"bool"); temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; arg3 = (lua_toboolean(L, 3)!=0); - arg4 = (lua_toboolean(L, 4)!=0); result = ofSplitString((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4); { - std::vector< std::string > * resultptr = new std::vector< std::string >((const std::vector< std::string > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_std__string_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_splitString__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; - bool arg3 ; std::string temp1 ; std::string temp2 ; std::vector< std::string > result; - SWIG_check_num_args("ofSplitString",3,3) if(!lua_isstring(L,1)) SWIG_fail_arg("ofSplitString",1,"std::string const &"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofSplitString",2,"std::string const &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofSplitString",3,"bool"); temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; arg3 = (lua_toboolean(L, 3)!=0); - result = ofSplitString((std::string const &)*arg1,(std::string const &)*arg2,arg3); { - std::vector< std::string > * resultptr = new std::vector< std::string >((const std::vector< std::string > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_std__string_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_splitString__SWIG_2(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; - std::string temp1 ; std::string temp2 ; std::vector< std::string > result; SWIG_check_num_args("ofSplitString",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofSplitString",1,"std::string const &"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofSplitString",2,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = ofSplitString((std::string const &)*arg1,(std::string const &)*arg2); { - std::vector< std::string > * resultptr = new std::vector< std::string >((const std::vector< std::string > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_std__string_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_splitString(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { int _v; - { _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { - return _wrap_splitString__SWIG_2(L);} } } if (argc == 3) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { { - _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - return _wrap_splitString__SWIG_1(L);} } } } if (argc == 4) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { - { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { { - _v = lua_isboolean(L,argv[3]); } if (_v) { return _wrap_splitString__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'splitString'\n" " Possible C/C++ prototypes are:\n" - " ofSplitString(std::string const &,std::string const &,bool,bool)\n" - " ofSplitString(std::string const &,std::string const &,bool)\n" - " ofSplitString(std::string const &,std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_joinString(lua_State* L) { int SWIG_arg = 0; std::vector< std::string > *arg1 = 0 ; std::string *arg2 = 0 ; - std::string temp2 ; std::string result; SWIG_check_num_args("ofJoinString",2,2) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofJoinString",1,"std::vector< std::string > const &"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofJoinString",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_std__string_t,0))){ - SWIG_fail_ptr("joinString",1,SWIGTYPE_p_std__vectorT_std__string_t); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = ofJoinString((std::vector< std::string > const &)*arg1,(std::string const &)*arg2); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_stringReplace(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; - std::string *arg3 = 0 ; std::string temp2 ; std::string temp3 ; SWIG_check_num_args("ofStringReplace",3,3) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofStringReplace",1,"std::string &"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofStringReplace",2,"std::string const &"); - if(!lua_isstring(L,3)) SWIG_fail_arg("ofStringReplace",3,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__string,0))){ - SWIG_fail_ptr("stringReplace",1,SWIGTYPE_p_std__string); } temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3; - ofStringReplace(*arg1,(std::string const &)*arg2,(std::string const &)*arg3); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_isStringInString(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; - std::string temp1 ; std::string temp2 ; bool result; SWIG_check_num_args("ofIsStringInString",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofIsStringInString",1,"std::string const &"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofIsStringInString",2,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = (bool)ofIsStringInString((std::string const &)*arg1,(std::string const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_stringTimesInString(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; - std::string temp1 ; std::string temp2 ; std::size_t result; SWIG_check_num_args("ofStringTimesInString",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofStringTimesInString",1,"std::string const &"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofStringTimesInString",2,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = (std::size_t)ofStringTimesInString((std::string const &)*arg1,(std::string const &)*arg2); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_toLower__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; - std::string temp1 ; std::string temp2 ; std::string result; SWIG_check_num_args("ofToLower",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofToLower",1,"std::string const &"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofToLower",2,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = ofToLower((std::string const &)*arg1,(std::string const &)*arg2); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_toLower__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - std::string result; SWIG_check_num_args("ofToLower",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofToLower",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = ofToLower((std::string const &)*arg1); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_toLower(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { return _wrap_toLower__SWIG_1(L);} } if (argc == 2) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { return _wrap_toLower__SWIG_0(L);} - } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'toLower'\n" " Possible C/C++ prototypes are:\n" - " ofToLower(std::string const &,std::string const &)\n" " ofToLower(std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_toUpper__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; - std::string temp1 ; std::string temp2 ; std::string result; SWIG_check_num_args("ofToUpper",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofToUpper",1,"std::string const &"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofToUpper",2,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = ofToUpper((std::string const &)*arg1,(std::string const &)*arg2); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_toUpper__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - std::string result; SWIG_check_num_args("ofToUpper",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofToUpper",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = ofToUpper((std::string const &)*arg1); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_toUpper(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { return _wrap_toUpper__SWIG_1(L);} } if (argc == 2) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { return _wrap_toUpper__SWIG_0(L);} - } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'toUpper'\n" " Possible C/C++ prototypes are:\n" - " ofToUpper(std::string const &,std::string const &)\n" " ofToUpper(std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_trimFront__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; - std::string temp1 ; std::string temp2 ; std::string result; SWIG_check_num_args("ofTrimFront",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofTrimFront",1,"std::string const &"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofTrimFront",2,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = ofTrimFront((std::string const &)*arg1,(std::string const &)*arg2); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_trimFront__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - std::string result; SWIG_check_num_args("ofTrimFront",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofTrimFront",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = ofTrimFront((std::string const &)*arg1); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_trimFront(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { return _wrap_trimFront__SWIG_1(L);} } if (argc == 2) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { return _wrap_trimFront__SWIG_0(L);} - } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'trimFront'\n" - " Possible C/C++ prototypes are:\n" " ofTrimFront(std::string const &,std::string const &)\n" - " ofTrimFront(std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_trimBack__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; - std::string temp1 ; std::string temp2 ; std::string result; SWIG_check_num_args("ofTrimBack",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofTrimBack",1,"std::string const &"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofTrimBack",2,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = ofTrimBack((std::string const &)*arg1,(std::string const &)*arg2); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_trimBack__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - std::string result; SWIG_check_num_args("ofTrimBack",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofTrimBack",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = ofTrimBack((std::string const &)*arg1); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_trimBack(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { return _wrap_trimBack__SWIG_1(L);} } if (argc == 2) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { return _wrap_trimBack__SWIG_0(L);} - } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'trimBack'\n" - " Possible C/C++ prototypes are:\n" " ofTrimBack(std::string const &,std::string const &)\n" - " ofTrimBack(std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_trim__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; - std::string temp1 ; std::string temp2 ; std::string result; SWIG_check_num_args("ofTrim",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofTrim",1,"std::string const &"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofTrim",2,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = ofTrim((std::string const &)*arg1,(std::string const &)*arg2); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_trim__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; std::string result; - SWIG_check_num_args("ofTrim",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofTrim",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = ofTrim((std::string const &)*arg1); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_trim(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { return _wrap_trim__SWIG_1(L);} } if (argc == 2) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { return _wrap_trim__SWIG_0(L);} } - } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'trim'\n" " Possible C/C++ prototypes are:\n" - " ofTrim(std::string const &,std::string const &)\n" " ofTrim(std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_appendUTF8(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; uint32_t arg2 ; uint32_t *argp2 ; - SWIG_check_num_args("ofAppendUTF8",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofAppendUTF8",1,"std::string &"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofAppendUTF8",2,"uint32_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__string,0))){ - SWIG_fail_ptr("appendUTF8",1,SWIGTYPE_p_std__string); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_uint32_t,0))){ - SWIG_fail_ptr("appendUTF8",2,SWIGTYPE_p_uint32_t); } arg2 = *argp2; ofAppendUTF8(*arg1,arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_uTF8Append(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; uint32_t arg2 ; uint32_t *argp2 ; - SWIG_check_num_args("ofUTF8Append",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofUTF8Append",1,"std::string &"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofUTF8Append",2,"uint32_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__string,0))){ - SWIG_fail_ptr("uTF8Append",1,SWIGTYPE_p_std__string); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_uint32_t,0))){ - SWIG_fail_ptr("uTF8Append",2,SWIGTYPE_p_uint32_t); } arg2 = *argp2; ofUTF8Append(*arg1,arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_uTF8Insert(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; size_t arg2 ; uint32_t arg3 ; - uint32_t *argp3 ; SWIG_check_num_args("ofUTF8Insert",3,3) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofUTF8Insert",1,"std::string &"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofUTF8Insert",2,"size_t"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofUTF8Insert",3,"uint32_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__string,0))){ - SWIG_fail_ptr("uTF8Insert",1,SWIGTYPE_p_std__string); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&argp3,SWIGTYPE_p_uint32_t,0))){ - SWIG_fail_ptr("uTF8Insert",3,SWIGTYPE_p_uint32_t); } arg3 = *argp3; ofUTF8Insert(*arg1,arg2,arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_uTF8Erase(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; size_t arg2 ; size_t arg3 ; - SWIG_check_num_args("ofUTF8Erase",3,3) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofUTF8Erase",1,"std::string &"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofUTF8Erase",2,"size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofUTF8Erase",3,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__string,0))){ - SWIG_fail_ptr("uTF8Erase",1,SWIGTYPE_p_std__string); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - ofUTF8Erase(*arg1,arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_uTF8Substring(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; size_t arg2 ; size_t arg3 ; - std::string temp1 ; std::string result; SWIG_check_num_args("ofUTF8Substring",3,3) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofUTF8Substring",1,"std::string const &"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofUTF8Substring",2,"size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofUTF8Substring",3,"size_t"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - result = ofUTF8Substring((std::string const &)*arg1,arg2,arg3); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_uTF8ToString(lua_State* L) { int SWIG_arg = 0; uint32_t arg1 ; uint32_t *argp1 ; std::string result; - SWIG_check_num_args("ofUTF8ToString",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofUTF8ToString",1,"uint32_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&argp1,SWIGTYPE_p_uint32_t,0))){ - SWIG_fail_ptr("uTF8ToString",1,SWIGTYPE_p_uint32_t); } arg1 = *argp1; result = ofUTF8ToString(arg1); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_uTF8Length(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; size_t result; - SWIG_check_num_args("ofUTF8Length",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofUTF8Length",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = (size_t)ofUTF8Length((std::string const &)*arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_toInt(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; int result; - SWIG_check_num_args("ofToInt",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofToInt",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = (int)ofToInt((std::string const &)*arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_toInt64(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; int64_t result; - SWIG_check_num_args("ofToInt64",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofToInt64",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = (int64_t)ofToInt64((std::string const &)*arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_toFloat(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; float result; - SWIG_check_num_args("ofToFloat",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofToFloat",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = (float)ofToFloat((std::string const &)*arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_toDouble(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; double result; - SWIG_check_num_args("ofToDouble",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofToDouble",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = (double)ofToDouble((std::string const &)*arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_toBool(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; bool result; - SWIG_check_num_args("ofToBool",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofToBool",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = (bool)ofToBool((std::string const &)*arg1); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_toHex(lua_State* L) { int SWIG_arg = 0; char *arg1 = (char *) 0 ; std::string result; - SWIG_check_num_args("ofToHex",1,1) if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("ofToHex",1,"char const *"); - arg1 = (char *)lua_tostring(L, 1); result = ofToHex((char const *)arg1); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_hexToInt(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; int result; - SWIG_check_num_args("ofHexToInt",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofHexToInt",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = (int)ofHexToInt((std::string const &)*arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_hexToChar(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; char result; - SWIG_check_num_args("ofHexToChar",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofHexToChar",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = (char)ofHexToChar((std::string const &)*arg1); - lua_pushlstring(L, &result, 1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_hexToFloat(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; float result; - SWIG_check_num_args("ofHexToFloat",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofHexToFloat",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = (float)ofHexToFloat((std::string const &)*arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_hexToString(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; std::string result; - SWIG_check_num_args("ofHexToString",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofHexToString",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = ofHexToString((std::string const &)*arg1); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_toChar(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; char result; - SWIG_check_num_args("ofToChar",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofToChar",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = (char)ofToChar((std::string const &)*arg1); - lua_pushlstring(L, &result, 1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_toBinary(lua_State* L) { int SWIG_arg = 0; char *arg1 = (char *) 0 ; std::string result; - SWIG_check_num_args("ofToBinary",1,1) if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("ofToBinary",1,"char const *"); - arg1 = (char *)lua_tostring(L, 1); result = ofToBinary((char const *)arg1); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_binaryToInt(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; int result; - SWIG_check_num_args("ofBinaryToInt",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofBinaryToInt",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = (int)ofBinaryToInt((std::string const &)*arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_binaryToChar(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; char result; - SWIG_check_num_args("ofBinaryToChar",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofBinaryToChar",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = (char)ofBinaryToChar((std::string const &)*arg1); - lua_pushlstring(L, &result, 1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_binaryToFloat(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; float result; - SWIG_check_num_args("ofBinaryToFloat",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofBinaryToFloat",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = (float)ofBinaryToFloat((std::string const &)*arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_binaryToString(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - std::string result; SWIG_check_num_args("ofBinaryToString",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofBinaryToString",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = ofBinaryToString((std::string const &)*arg1); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_getVersionInfo(lua_State* L) { int SWIG_arg = 0; std::string result; - SWIG_check_num_args("ofGetVersionInfo",0,0) result = ofGetVersionInfo(); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_getVersionMajor(lua_State* L) { int SWIG_arg = 0; unsigned int result; - SWIG_check_num_args("ofGetVersionMajor",0,0) result = (unsigned int)ofGetVersionMajor(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getVersionMinor(lua_State* L) { int SWIG_arg = 0; unsigned int result; - SWIG_check_num_args("ofGetVersionMinor",0,0) result = (unsigned int)ofGetVersionMinor(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getVersionPatch(lua_State* L) { int SWIG_arg = 0; unsigned int result; - SWIG_check_num_args("ofGetVersionPatch",0,0) result = (unsigned int)ofGetVersionPatch(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getVersionPreRelease(lua_State* L) { int SWIG_arg = 0; std::string result; - SWIG_check_num_args("ofGetVersionPreRelease",0,0) result = ofGetVersionPreRelease(); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_saveScreen(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - SWIG_check_num_args("ofSaveScreen",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofSaveScreen",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; ofSaveScreen((std::string const &)*arg1); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_saveFrame__SWIG_0(lua_State* L) { int SWIG_arg = 0; bool arg1 ; SWIG_check_num_args("ofSaveFrame",1,1) - if(!lua_isboolean(L,1)) SWIG_fail_arg("ofSaveFrame",1,"bool"); arg1 = (lua_toboolean(L, 1)!=0); ofSaveFrame(arg1); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_saveFrame__SWIG_1(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofSaveFrame",0,0) ofSaveFrame(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_saveFrame(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_saveFrame__SWIG_1(L);} if (argc == 1) { int _v; { _v = lua_isboolean(L,argv[0]); } if (_v) { - return _wrap_saveFrame__SWIG_0(L);} } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'saveFrame'\n" - " Possible C/C++ prototypes are:\n" " ofSaveFrame(bool)\n" " ofSaveFrame()\n"); lua_error(L);return 0; } -static int _wrap_saveViewport(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - SWIG_check_num_args("ofSaveViewport",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofSaveViewport",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; ofSaveViewport((std::string const &)*arg1); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_launchBrowser__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; bool arg2 ; std::string temp1 ; - SWIG_check_num_args("ofLaunchBrowser",2,2) if(!lua_isstring(L,1)) SWIG_fail_arg("ofLaunchBrowser",1,"std::string const &"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofLaunchBrowser",2,"bool"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; arg2 = (lua_toboolean(L, 2)!=0); - ofLaunchBrowser((std::string const &)*arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_launchBrowser__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - SWIG_check_num_args("ofLaunchBrowser",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofLaunchBrowser",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; ofLaunchBrowser((std::string const &)*arg1); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_launchBrowser(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { return _wrap_launchBrowser__SWIG_1(L);} } if (argc == 2) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_launchBrowser__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'launchBrowser'\n" " Possible C/C++ prototypes are:\n" - " ofLaunchBrowser(std::string const &,bool)\n" " ofLaunchBrowser(std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_system(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; std::string result; - SWIG_check_num_args("ofSystem",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofSystem",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = ofSystem((std::string const &)*arg1); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_getTargetPlatform(lua_State* L) { int SWIG_arg = 0; ofTargetPlatform result; - SWIG_check_num_args("ofGetTargetPlatform",0,0) result = (ofTargetPlatform)ofGetTargetPlatform(); - lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_getEnv(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; std::string result; - SWIG_check_num_args("ofGetEnv",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofGetEnv",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = ofGetEnv((std::string const &)*arg1); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } static int _wrap_new_VideoGrabber(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *result = 0 ; SWIG_check_num_args("ofVideoGrabber::ofVideoGrabber",0,0) result = (ofVideoGrabber *)new ofVideoGrabber(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVideoGrabber,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); @@ -49440,13 +47997,7 @@ static int _wrap_VideoGrabber_setup__SWIG_1(lua_State* L) { int SWIG_arg = 0; of arg3 = (int)lua_tonumber(L, 3); arg4 = (lua_toboolean(L, 4)!=0); result = (bool)(arg1)->setup(arg2,arg3,arg4); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_VideoGrabber_setup(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVideoGrabber, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_VideoGrabber_setup__SWIG_0(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVideoGrabber, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isboolean(L,argv[3]); } if (_v) { return _wrap_VideoGrabber_setup__SWIG_1(L);} } } } } + return _wrap_VideoGrabber_setup__SWIG_0(L);} if (argc == 4) { return _wrap_VideoGrabber_setup__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'VideoGrabber_setup'\n" " Possible C/C++ prototypes are:\n" " ofVideoGrabber::setup(int,int)\n" " ofVideoGrabber::setup(int,int,bool)\n"); lua_error(L);return 0; } static int _wrap_VideoGrabber_setPixelFormat(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; @@ -49487,11 +48038,7 @@ static int _wrap_VideoGrabber_getPixels__SWIG_1(lua_State* L) { int SWIG_arg = 0 SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_VideoGrabber_getPixels(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVideoGrabber, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_VideoGrabber_getPixels__SWIG_0(L);} } if (argc == 1) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVideoGrabber, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_VideoGrabber_getPixels__SWIG_1(L);} } + return _wrap_VideoGrabber_getPixels__SWIG_0(L);} if (argc == 1) { return _wrap_VideoGrabber_getPixels__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'VideoGrabber_getPixels'\n" " Possible C/C++ prototypes are:\n" " ofVideoGrabber::getPixels()\n" " ofVideoGrabber::getPixels() const\n"); lua_error(L);return 0; } @@ -49511,11 +48058,7 @@ static int _wrap_VideoGrabber_getTexture__SWIG_1(lua_State* L) { int SWIG_arg = SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTexture,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_VideoGrabber_getTexture(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVideoGrabber, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_VideoGrabber_getTexture__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVideoGrabber, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_VideoGrabber_getTexture__SWIG_1(L);} } + return _wrap_VideoGrabber_getTexture__SWIG_0(L);} if (argc == 1) { return _wrap_VideoGrabber_getTexture__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'VideoGrabber_getTexture'\n" " Possible C/C++ prototypes are:\n" " ofVideoGrabber::getTexture()\n" " ofVideoGrabber::getTexture() const\n"); lua_error(L);return 0; } @@ -49538,11 +48081,8 @@ static int _wrap_VideoGrabber_getTexturePlanes__SWIG_1(lua_State* L) { int SWIG_ SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofTexture_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_VideoGrabber_getTexturePlanes(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); - if (argc == 1) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVideoGrabber, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_VideoGrabber_getTexturePlanes__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVideoGrabber, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_VideoGrabber_getTexturePlanes__SWIG_1(L);} } + if (argc == 1) { return _wrap_VideoGrabber_getTexturePlanes__SWIG_0(L);} if (argc == 1) { + return _wrap_VideoGrabber_getTexturePlanes__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'VideoGrabber_getTexturePlanes'\n" " Possible C/C++ prototypes are:\n" " ofVideoGrabber::getTexturePlanes()\n" " ofVideoGrabber::getTexturePlanes() const\n"); lua_error(L);return 0; } @@ -49602,6 +48142,47 @@ static int _wrap_VideoGrabber_draw__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofV SWIG_fail_ptr("VideoGrabber_draw",1,SWIGTYPE_p_ofVideoGrabber); } arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); ((ofVideoGrabber const *)arg1)->draw(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_VideoGrabber_draw__SWIG_2_0(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; + glm::vec2 *arg2 = 0 ; SWIG_check_num_args("draw",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("draw",1,"ofVideoGrabber const *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("draw",2,"glm::vec2 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ + SWIG_fail_ptr("VideoGrabber_draw",1,SWIGTYPE_p_ofVideoGrabber); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec2,0))){ + SWIG_fail_ptr("VideoGrabber_draw",2,SWIGTYPE_p_glm__vec2); } + ((ofVideoGrabber const *)arg1)->draw((glm::vec2 const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_VideoGrabber_draw__SWIG_2_1(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; + ofRectangle *arg2 = 0 ; SWIG_check_num_args("draw",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("draw",1,"ofVideoGrabber const *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("draw",2,"ofRectangle const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ + SWIG_fail_ptr("VideoGrabber_draw",1,SWIGTYPE_p_ofVideoGrabber); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ + SWIG_fail_ptr("VideoGrabber_draw",2,SWIGTYPE_p_ofRectangle); } + ((ofVideoGrabber const *)arg1)->draw((ofRectangle const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_VideoGrabber_draw__SWIG_2_2(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; + glm::vec2 *arg2 = 0 ; float arg3 ; float arg4 ; SWIG_check_num_args("draw",4,4) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("draw",1,"ofVideoGrabber const *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("draw",2,"glm::vec2 const &"); if(!lua_isnumber(L,3)) SWIG_fail_arg("draw",3,"float"); + if(!lua_isnumber(L,4)) SWIG_fail_arg("draw",4,"float"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ + SWIG_fail_ptr("VideoGrabber_draw",1,SWIGTYPE_p_ofVideoGrabber); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec2,0))){ + SWIG_fail_ptr("VideoGrabber_draw",2,SWIGTYPE_p_glm__vec2); } arg3 = (float)lua_tonumber(L, 3); + arg4 = (float)lua_tonumber(L, 4); ((ofVideoGrabber const *)arg1)->draw((glm::vec2 const &)*arg2,arg3,arg4); return SWIG_arg; + if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_VideoGrabber_draw(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_VideoGrabber_draw__SWIG_2_0(L);} check_1: + if (argc == 2) { return _wrap_VideoGrabber_draw__SWIG_2_1(L);} if (argc == 3) { return _wrap_VideoGrabber_draw__SWIG_1(L);} + if (argc == 4) { return _wrap_VideoGrabber_draw__SWIG_2_2(L);} if (argc == 5) { return _wrap_VideoGrabber_draw__SWIG_0(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'VideoGrabber_draw'\n" " Possible C/C++ prototypes are:\n" + " ofVideoGrabber::draw(float,float,float,float) const\n" " ofVideoGrabber::draw(float,float) const\n" + " draw(glm::vec2 const &) const\n" " draw(ofRectangle const &) const\n" + " draw(glm::vec2 const &,float,float) const\n"); lua_error(L);return 0; } static int _wrap_VideoGrabber_bind(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; SWIG_check_num_args("ofVideoGrabber::bind",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::bind",1,"ofVideoGrabber const *"); @@ -49660,7 +48241,7 @@ static int _wrap_VideoGrabber_isInitialized(lua_State* L) { int SWIG_arg = 0; of result = (bool)((ofVideoGrabber const *)arg1)->isInitialized(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_VideoGrabber_setGrabber(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - std::shared_ptr< ofBaseVideoGrabber > arg2 ; std::shared_ptr< ofBaseVideoGrabber > *argp2 ; + SwigValueWrapper< std::shared_ptr< ofBaseVideoGrabber > > arg2 ; std::shared_ptr< ofBaseVideoGrabber > *argp2 ; SWIG_check_num_args("ofVideoGrabber::setGrabber",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::setGrabber",1,"ofVideoGrabber *"); if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVideoGrabber::setGrabber",2,"std::shared_ptr< ofBaseVideoGrabber >"); @@ -49669,67 +48250,6 @@ static int _wrap_VideoGrabber_setGrabber(lua_State* L) { int SWIG_arg = 0; ofVid if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_std__shared_ptrT_ofBaseVideoGrabber_t,0))){ SWIG_fail_ptr("VideoGrabber_setGrabber",2,SWIGTYPE_p_std__shared_ptrT_ofBaseVideoGrabber_t); } arg2 = *argp2; (arg1)->setGrabber(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoGrabber_frameNew_get(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - bool result; SWIG_check_num_args("ofVideoGrabber::frameNew",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::frameNew",1,"ofVideoGrabber *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_frameNew_get",1,SWIGTYPE_p_ofVideoGrabber); } result = (bool)ofVideoGrabber_frameNew_get(arg1); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoGrabber_pixelFormat_get(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - ofPixelFormat result; SWIG_check_num_args("ofVideoGrabber::pixelFormat",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::pixelFormat",1,"ofVideoGrabber *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_pixelFormat_get",1,SWIGTYPE_p_ofVideoGrabber); } - result = (ofPixelFormat)ofVideoGrabber_pixelFormat_get(arg1); lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoGrabber_pixels_get(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - ofPixels *result = 0 ; SWIG_check_num_args("ofVideoGrabber::pixels",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::pixels",1,"ofVideoGrabber *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_pixels_get",1,SWIGTYPE_p_ofVideoGrabber); } - result = (ofPixels *) &ofVideoGrabber_pixels_get(arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_VideoGrabber_texture_get(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - ofTexture *result = 0 ; SWIG_check_num_args("ofVideoGrabber::texture",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::texture",1,"ofVideoGrabber *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_texture_get",1,SWIGTYPE_p_ofVideoGrabber); } - result = (ofTexture *) &ofVideoGrabber_texture_get(arg1); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTexture,0); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoGrabber_usingTexture_set(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - bool arg2 ; SWIG_check_num_args("ofVideoGrabber::usingTexture",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::usingTexture",1,"ofVideoGrabber *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofVideoGrabber::usingTexture",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_usingTexture_set",1,SWIGTYPE_p_ofVideoGrabber); } arg2 = (lua_toboolean(L, 2)!=0); - ofVideoGrabber_usingTexture_set(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoGrabber_usingTexture_get(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - bool result; SWIG_check_num_args("ofVideoGrabber::usingTexture",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::usingTexture",1,"ofVideoGrabber *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_usingTexture_get",1,SWIGTYPE_p_ofVideoGrabber); } - result = (bool)ofVideoGrabber_usingTexture_get(arg1); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoGrabber_width_get(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - float result; SWIG_check_num_args("ofVideoGrabber::width",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::width",1,"ofVideoGrabber *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_width_get",1,SWIGTYPE_p_ofVideoGrabber); } result = (float)ofVideoGrabber_width_get(arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoGrabber_height_get(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - float result; SWIG_check_num_args("ofVideoGrabber::height",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::height",1,"ofVideoGrabber *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_height_get",1,SWIGTYPE_p_ofVideoGrabber); } result = (float)ofVideoGrabber_height_get(arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoGrabber_initialized_get(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - bool result; SWIG_check_num_args("ofVideoGrabber::initialized",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::initialized",1,"ofVideoGrabber *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_initialized_get",1,SWIGTYPE_p_ofVideoGrabber); } - result = (bool)ofVideoGrabber_initialized_get(arg1); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static void swig_delete_VideoGrabber(void *obj) { ofVideoGrabber *arg1 = (ofVideoGrabber *) obj; delete arg1; @@ -49743,14 +48263,6 @@ static int _proxy__wrap_new_VideoGrabber(lua_State *L) { return 1; } static swig_lua_attribute swig_VideoGrabber_attributes[] = { - { "frameNew", _wrap_VideoGrabber_frameNew_get, SWIG_Lua_set_immutable }, - { "pixelFormat", _wrap_VideoGrabber_pixelFormat_get, SWIG_Lua_set_immutable }, - { "pixels", _wrap_VideoGrabber_pixels_get, SWIG_Lua_set_immutable }, - { "texture", _wrap_VideoGrabber_texture_get, SWIG_Lua_set_immutable }, - { "usingTexture", _wrap_VideoGrabber_usingTexture_get, _wrap_VideoGrabber_usingTexture_set }, - { "width", _wrap_VideoGrabber_width_get, SWIG_Lua_set_immutable }, - { "height", _wrap_VideoGrabber_height_get, SWIG_Lua_set_immutable }, - { "initialized", _wrap_VideoGrabber_initialized_get, SWIG_Lua_set_immutable }, {0,0,0} }; static swig_lua_method swig_VideoGrabber_methods[]= { @@ -49770,6 +48282,7 @@ static swig_lua_method swig_VideoGrabber_methods[]= { { "setDesiredFrameRate", _wrap_VideoGrabber_setDesiredFrameRate}, { "setUseTexture", _wrap_VideoGrabber_setUseTexture}, { "isUsingTexture", _wrap_VideoGrabber_isUsingTexture}, + { "draw", _wrap_VideoGrabber_draw}, { "bind", _wrap_VideoGrabber_bind}, { "unbind", _wrap_VideoGrabber_unbind}, { "setAnchorPercent", _wrap_VideoGrabber_setAnchorPercent}, @@ -49905,11 +48418,7 @@ static int _wrap_VideoPlayer_getPixels__SWIG_1(lua_State* L) { int SWIG_arg = 0; SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_VideoPlayer_getPixels(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVideoPlayer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_VideoPlayer_getPixels__SWIG_0(L);} } if (argc == 1) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVideoPlayer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_VideoPlayer_getPixels__SWIG_1(L);} } + return _wrap_VideoPlayer_getPixels__SWIG_0(L);} if (argc == 1) { return _wrap_VideoPlayer_getPixels__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'VideoPlayer_getPixels'\n" " Possible C/C++ prototypes are:\n" " ofVideoPlayer::getPixels()\n" " ofVideoPlayer::getPixels() const\n"); lua_error(L);return 0; } @@ -49956,23 +48465,19 @@ static int _wrap_VideoPlayer_setVolume(lua_State* L) { int SWIG_arg = 0; ofVideo SWIG_fail_ptr("VideoPlayer_setVolume",1,SWIGTYPE_p_ofVideoPlayer); } arg2 = (float)lua_tonumber(L, 2); (arg1)->setVolume(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_VideoPlayer_setLoopState(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - ofLoopType arg2 ; ofLoopType *argp2 ; SWIG_check_num_args("ofVideoPlayer::setLoopState",2,2) + ofLoopType arg2 ; SWIG_check_num_args("ofVideoPlayer::setLoopState",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::setLoopState",1,"ofVideoPlayer *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVideoPlayer::setLoopState",2,"ofLoopType"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVideoPlayer::setLoopState",2,"ofLoopType"); if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_setLoopState",1,SWIGTYPE_p_ofVideoPlayer); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofLoopType,0))){ - SWIG_fail_ptr("VideoPlayer_setLoopState",2,SWIGTYPE_p_ofLoopType); } arg2 = *argp2; (arg1)->setLoopState(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } + SWIG_fail_ptr("VideoPlayer_setLoopState",1,SWIGTYPE_p_ofVideoPlayer); } arg2 = (ofLoopType)(int)lua_tonumber(L, 2); + (arg1)->setLoopState(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_VideoPlayer_getLoopState(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; ofLoopType result; SWIG_check_num_args("ofVideoPlayer::getLoopState",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::getLoopState",1,"ofVideoPlayer const *"); if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ SWIG_fail_ptr("VideoPlayer_getLoopState",1,SWIGTYPE_p_ofVideoPlayer); } - result = ((ofVideoPlayer const *)arg1)->getLoopState(); { - ofLoopType * resultptr = new ofLoopType((const ofLoopType &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofLoopType,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } + result = (ofLoopType)((ofVideoPlayer const *)arg1)->getLoopState(); lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_VideoPlayer_setSpeed(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; float arg2 ; SWIG_check_num_args("ofVideoPlayer::setSpeed",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::setSpeed",1,"ofVideoPlayer *"); @@ -50017,11 +48522,7 @@ static int _wrap_VideoPlayer_getTexture__SWIG_1(lua_State* L) { int SWIG_arg = 0 SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTexture,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_VideoPlayer_getTexture(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVideoPlayer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_VideoPlayer_getTexture__SWIG_0(L);} } if (argc == 1) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVideoPlayer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_VideoPlayer_getTexture__SWIG_1(L);} } + return _wrap_VideoPlayer_getTexture__SWIG_0(L);} if (argc == 1) { return _wrap_VideoPlayer_getTexture__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'VideoPlayer_getTexture'\n" " Possible C/C++ prototypes are:\n" " ofVideoPlayer::getTexture()\n" " ofVideoPlayer::getTexture() const\n"); lua_error(L);return 0; } @@ -50044,11 +48545,8 @@ static int _wrap_VideoPlayer_getTexturePlanes__SWIG_1(lua_State* L) { int SWIG_a SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofTexture_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_VideoPlayer_getTexturePlanes(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); - if (argc == 1) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVideoPlayer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_VideoPlayer_getTexturePlanes__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVideoPlayer, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_VideoPlayer_getTexturePlanes__SWIG_1(L);} } + if (argc == 1) { return _wrap_VideoPlayer_getTexturePlanes__SWIG_0(L);} if (argc == 1) { + return _wrap_VideoPlayer_getTexturePlanes__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'VideoPlayer_getTexturePlanes'\n" " Possible C/C++ prototypes are:\n" " ofVideoPlayer::getTexturePlanes()\n" " ofVideoPlayer::getTexturePlanes() const\n"); lua_error(L);return 0; } @@ -50073,6 +48571,46 @@ static int _wrap_VideoPlayer_draw__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVi SWIG_fail_ptr("VideoPlayer_draw",1,SWIGTYPE_p_ofVideoPlayer); } arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); ((ofVideoPlayer const *)arg1)->draw(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_VideoPlayer_draw__SWIG_2_0(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; + glm::vec2 *arg2 = 0 ; SWIG_check_num_args("draw",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("draw",1,"ofVideoPlayer const *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("draw",2,"glm::vec2 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ + SWIG_fail_ptr("VideoPlayer_draw",1,SWIGTYPE_p_ofVideoPlayer); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec2,0))){ + SWIG_fail_ptr("VideoPlayer_draw",2,SWIGTYPE_p_glm__vec2); } ((ofVideoPlayer const *)arg1)->draw((glm::vec2 const &)*arg2); + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_VideoPlayer_draw__SWIG_2_1(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; + ofRectangle *arg2 = 0 ; SWIG_check_num_args("draw",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("draw",1,"ofVideoPlayer const *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("draw",2,"ofRectangle const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ + SWIG_fail_ptr("VideoPlayer_draw",1,SWIGTYPE_p_ofVideoPlayer); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ + SWIG_fail_ptr("VideoPlayer_draw",2,SWIGTYPE_p_ofRectangle); } + ((ofVideoPlayer const *)arg1)->draw((ofRectangle const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_VideoPlayer_draw__SWIG_2_2(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; + glm::vec2 *arg2 = 0 ; float arg3 ; float arg4 ; SWIG_check_num_args("draw",4,4) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("draw",1,"ofVideoPlayer const *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("draw",2,"glm::vec2 const &"); if(!lua_isnumber(L,3)) SWIG_fail_arg("draw",3,"float"); + if(!lua_isnumber(L,4)) SWIG_fail_arg("draw",4,"float"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ + SWIG_fail_ptr("VideoPlayer_draw",1,SWIGTYPE_p_ofVideoPlayer); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec2,0))){ + SWIG_fail_ptr("VideoPlayer_draw",2,SWIGTYPE_p_glm__vec2); } arg3 = (float)lua_tonumber(L, 3); + arg4 = (float)lua_tonumber(L, 4); ((ofVideoPlayer const *)arg1)->draw((glm::vec2 const &)*arg2,arg3,arg4); return SWIG_arg; + if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_VideoPlayer_draw(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_VideoPlayer_draw__SWIG_2_0(L);} check_1: + if (argc == 2) { return _wrap_VideoPlayer_draw__SWIG_2_1(L);} if (argc == 3) { return _wrap_VideoPlayer_draw__SWIG_1(L);} + if (argc == 4) { return _wrap_VideoPlayer_draw__SWIG_2_2(L);} if (argc == 5) { return _wrap_VideoPlayer_draw__SWIG_0(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'VideoPlayer_draw'\n" " Possible C/C++ prototypes are:\n" + " ofVideoPlayer::draw(float,float,float,float) const\n" " ofVideoPlayer::draw(float,float) const\n" + " draw(glm::vec2 const &) const\n" " draw(ofRectangle const &) const\n" + " draw(glm::vec2 const &,float,float) const\n"); lua_error(L);return 0; } static int _wrap_VideoPlayer_bind(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; SWIG_check_num_args("ofVideoPlayer::bind",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::bind",1,"ofVideoPlayer const *"); @@ -50191,7 +48729,7 @@ static int _wrap_VideoPlayer_isInitialized(lua_State* L) { int SWIG_arg = 0; ofV result = (bool)((ofVideoPlayer const *)arg1)->isInitialized(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static int _wrap_VideoPlayer_setPlayer(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - std::shared_ptr< ofBaseVideoPlayer > arg2 ; std::shared_ptr< ofBaseVideoPlayer > *argp2 ; + SwigValueWrapper< std::shared_ptr< ofBaseVideoPlayer > > arg2 ; std::shared_ptr< ofBaseVideoPlayer > *argp2 ; SWIG_check_num_args("ofVideoPlayer::setPlayer",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::setPlayer",1,"ofVideoPlayer *"); if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVideoPlayer::setPlayer",2,"std::shared_ptr< ofBaseVideoPlayer >"); @@ -50200,181 +48738,6 @@ static int _wrap_VideoPlayer_setPlayer(lua_State* L) { int SWIG_arg = 0; ofVideo if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_std__shared_ptrT_ofBaseVideoPlayer_t,0))){ SWIG_fail_ptr("VideoPlayer_setPlayer",2,SWIGTYPE_p_std__shared_ptrT_ofBaseVideoPlayer_t); } arg2 = *argp2; (arg1)->setPlayer(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_moviePath_get(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - string result; SWIG_check_num_args("ofVideoPlayer::moviePath",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::moviePath",1,"ofVideoPlayer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_moviePath_get",1,SWIGTYPE_p_ofVideoPlayer); } result = ofVideoPlayer_moviePath_get(arg1); { - string * resultptr = new string((const string &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_string,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_pixelFormat_set(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - ofPixelFormat arg2 ; SWIG_check_num_args("ofVideoPlayer::pixelFormat",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::pixelFormat",1,"ofVideoPlayer *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVideoPlayer::pixelFormat",2,"ofPixelFormat"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_pixelFormat_set",1,SWIGTYPE_p_ofVideoPlayer); } arg2 = (ofPixelFormat)(int)lua_tonumber(L, 2); - ofVideoPlayer_pixelFormat_set(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_pixelFormat_get(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - ofPixelFormat result; SWIG_check_num_args("ofVideoPlayer::pixelFormat",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::pixelFormat",1,"ofVideoPlayer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_pixelFormat_get",1,SWIGTYPE_p_ofVideoPlayer); } - result = (ofPixelFormat)ofVideoPlayer_pixelFormat_get(arg1); lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_frameNew_get(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - bool result; SWIG_check_num_args("ofVideoPlayer::frameNew",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::frameNew",1,"ofVideoPlayer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_frameNew_get",1,SWIGTYPE_p_ofVideoPlayer); } result = (bool)ofVideoPlayer_frameNew_get(arg1); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_pixels_get(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - ofPixels *result = 0 ; SWIG_check_num_args("ofVideoPlayer::pixels",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::pixels",1,"ofVideoPlayer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_pixels_get",1,SWIGTYPE_p_ofVideoPlayer); } - result = (ofPixels *) &ofVideoPlayer_pixels_get(arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_position_set(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - float arg2 ; SWIG_check_num_args("ofVideoPlayer::position",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::position",1,"ofVideoPlayer *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVideoPlayer::position",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_position_set",1,SWIGTYPE_p_ofVideoPlayer); } arg2 = (float)lua_tonumber(L, 2); - ofVideoPlayer_position_set(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_position_get(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - float result; SWIG_check_num_args("ofVideoPlayer::position",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::position",1,"ofVideoPlayer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_position_get",1,SWIGTYPE_p_ofVideoPlayer); } result = (float)ofVideoPlayer_position_get(arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_speed_set(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - float arg2 ; SWIG_check_num_args("ofVideoPlayer::speed",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::speed",1,"ofVideoPlayer *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVideoPlayer::speed",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_speed_set",1,SWIGTYPE_p_ofVideoPlayer); } arg2 = (float)lua_tonumber(L, 2); - ofVideoPlayer_speed_set(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_speed_get(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - float result; SWIG_check_num_args("ofVideoPlayer::speed",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::speed",1,"ofVideoPlayer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_speed_get",1,SWIGTYPE_p_ofVideoPlayer); } result = (float)ofVideoPlayer_speed_get(arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_duration_get(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - float result; SWIG_check_num_args("ofVideoPlayer::duration",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::duration",1,"ofVideoPlayer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_duration_get",1,SWIGTYPE_p_ofVideoPlayer); } result = (float)ofVideoPlayer_duration_get(arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_loopState_set(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - ofLoopType arg2 ; ofLoopType *argp2 ; SWIG_check_num_args("ofVideoPlayer::loopState",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::loopState",1,"ofVideoPlayer *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVideoPlayer::loopState",2,"ofLoopType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_loopState_set",1,SWIGTYPE_p_ofVideoPlayer); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofLoopType,0))){ - SWIG_fail_ptr("VideoPlayer_loopState_set",2,SWIGTYPE_p_ofLoopType); } arg2 = *argp2; - ofVideoPlayer_loopState_set(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_loopState_get(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - ofLoopType result; SWIG_check_num_args("ofVideoPlayer::loopState",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::loopState",1,"ofVideoPlayer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_loopState_get",1,SWIGTYPE_p_ofVideoPlayer); } result = ofVideoPlayer_loopState_get(arg1); { - ofLoopType * resultptr = new ofLoopType((const ofLoopType &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofLoopType,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_movieDone_get(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - bool result; SWIG_check_num_args("ofVideoPlayer::movieDone",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::movieDone",1,"ofVideoPlayer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_movieDone_get",1,SWIGTYPE_p_ofVideoPlayer); } result = (bool)ofVideoPlayer_movieDone_get(arg1); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_usingTexture_set(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - bool arg2 ; SWIG_check_num_args("ofVideoPlayer::usingTexture",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::usingTexture",1,"ofVideoPlayer *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofVideoPlayer::usingTexture",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_usingTexture_set",1,SWIGTYPE_p_ofVideoPlayer); } arg2 = (lua_toboolean(L, 2)!=0); - ofVideoPlayer_usingTexture_set(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_usingTexture_get(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - bool result; SWIG_check_num_args("ofVideoPlayer::usingTexture",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::usingTexture",1,"ofVideoPlayer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_usingTexture_get",1,SWIGTYPE_p_ofVideoPlayer); } - result = (bool)ofVideoPlayer_usingTexture_get(arg1); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_texture_get(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - ofTexture *result = 0 ; SWIG_check_num_args("ofVideoPlayer::texture",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::texture",1,"ofVideoPlayer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_texture_get",1,SWIGTYPE_p_ofVideoPlayer); } - result = (ofTexture *) &ofVideoPlayer_texture_get(arg1); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTexture,0); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_frame_set(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; int arg2 ; - SWIG_check_num_args("ofVideoPlayer::frame",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::frame",1,"ofVideoPlayer *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVideoPlayer::frame",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_frame_set",1,SWIGTYPE_p_ofVideoPlayer); } arg2 = (int)lua_tonumber(L, 2); - ofVideoPlayer_frame_set(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_frame_get(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; int result; - SWIG_check_num_args("ofVideoPlayer::frame",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::frame",1,"ofVideoPlayer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_frame_get",1,SWIGTYPE_p_ofVideoPlayer); } result = (int)ofVideoPlayer_frame_get(arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_numFrames_get(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - int result; SWIG_check_num_args("ofVideoPlayer::numFrames",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::numFrames",1,"ofVideoPlayer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_numFrames_get",1,SWIGTYPE_p_ofVideoPlayer); } result = (int)ofVideoPlayer_numFrames_get(arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_width_get(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - float result; SWIG_check_num_args("ofVideoPlayer::width",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::width",1,"ofVideoPlayer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_width_get",1,SWIGTYPE_p_ofVideoPlayer); } result = (float)ofVideoPlayer_width_get(arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_height_get(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - float result; SWIG_check_num_args("ofVideoPlayer::height",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::height",1,"ofVideoPlayer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_height_get",1,SWIGTYPE_p_ofVideoPlayer); } result = (float)ofVideoPlayer_height_get(arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_paused_set(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - bool arg2 ; SWIG_check_num_args("ofVideoPlayer::paused",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::paused",1,"ofVideoPlayer *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofVideoPlayer::paused",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_paused_set",1,SWIGTYPE_p_ofVideoPlayer); } arg2 = (lua_toboolean(L, 2)!=0); - ofVideoPlayer_paused_set(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_paused_get(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - bool result; SWIG_check_num_args("ofVideoPlayer::paused",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::paused",1,"ofVideoPlayer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_paused_get",1,SWIGTYPE_p_ofVideoPlayer); } result = (bool)ofVideoPlayer_paused_get(arg1); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_loaded_get(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - bool result; SWIG_check_num_args("ofVideoPlayer::loaded",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::loaded",1,"ofVideoPlayer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_loaded_get",1,SWIGTYPE_p_ofVideoPlayer); } result = (bool)ofVideoPlayer_loaded_get(arg1); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_playing_get(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - bool result; SWIG_check_num_args("ofVideoPlayer::playing",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::playing",1,"ofVideoPlayer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_playing_get",1,SWIGTYPE_p_ofVideoPlayer); } result = (bool)ofVideoPlayer_playing_get(arg1); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_initialized_get(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - bool result; SWIG_check_num_args("ofVideoPlayer::initialized",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::initialized",1,"ofVideoPlayer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_initialized_get",1,SWIGTYPE_p_ofVideoPlayer); } - result = (bool)ofVideoPlayer_initialized_get(arg1); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } static void swig_delete_VideoPlayer(void *obj) { ofVideoPlayer *arg1 = (ofVideoPlayer *) obj; delete arg1; @@ -50388,25 +48751,6 @@ static int _proxy__wrap_new_VideoPlayer(lua_State *L) { return 1; } static swig_lua_attribute swig_VideoPlayer_attributes[] = { - { "moviePath", _wrap_VideoPlayer_moviePath_get, SWIG_Lua_set_immutable }, - { "pixelFormat", _wrap_VideoPlayer_pixelFormat_get, _wrap_VideoPlayer_pixelFormat_set }, - { "frameNew", _wrap_VideoPlayer_frameNew_get, SWIG_Lua_set_immutable }, - { "pixels", _wrap_VideoPlayer_pixels_get, SWIG_Lua_set_immutable }, - { "position", _wrap_VideoPlayer_position_get, _wrap_VideoPlayer_position_set }, - { "speed", _wrap_VideoPlayer_speed_get, _wrap_VideoPlayer_speed_set }, - { "duration", _wrap_VideoPlayer_duration_get, SWIG_Lua_set_immutable }, - { "loopState", _wrap_VideoPlayer_loopState_get, _wrap_VideoPlayer_loopState_set }, - { "movieDone", _wrap_VideoPlayer_movieDone_get, SWIG_Lua_set_immutable }, - { "usingTexture", _wrap_VideoPlayer_usingTexture_get, _wrap_VideoPlayer_usingTexture_set }, - { "texture", _wrap_VideoPlayer_texture_get, SWIG_Lua_set_immutable }, - { "frame", _wrap_VideoPlayer_frame_get, _wrap_VideoPlayer_frame_set }, - { "numFrames", _wrap_VideoPlayer_numFrames_get, SWIG_Lua_set_immutable }, - { "width", _wrap_VideoPlayer_width_get, SWIG_Lua_set_immutable }, - { "height", _wrap_VideoPlayer_height_get, SWIG_Lua_set_immutable }, - { "paused", _wrap_VideoPlayer_paused_get, _wrap_VideoPlayer_paused_set }, - { "loaded", _wrap_VideoPlayer_loaded_get, SWIG_Lua_set_immutable }, - { "playing", _wrap_VideoPlayer_playing_get, SWIG_Lua_set_immutable }, - { "initialized", _wrap_VideoPlayer_initialized_get, SWIG_Lua_set_immutable }, {0,0,0} }; static swig_lua_method swig_VideoPlayer_methods[]= { @@ -50436,6 +48780,7 @@ static swig_lua_method swig_VideoPlayer_methods[]= { { "isUsingTexture", _wrap_VideoPlayer_isUsingTexture}, { "getTexture", _wrap_VideoPlayer_getTexture}, { "getTexturePlanes", _wrap_VideoPlayer_getTexturePlanes}, + { "draw", _wrap_VideoPlayer_draw}, { "bind", _wrap_VideoPlayer_bind}, { "unbind", _wrap_VideoPlayer_unbind}, { "setAnchorPercent", _wrap_VideoPlayer_setAnchorPercent}, @@ -50490,8 +48835,10 @@ static swig_lua_attribute swig_SwigModule_attributes[] = { { "TTF_SERIF", _wrap_TTF_SERIF_get, SWIG_Lua_set_immutable }, { "TTF_MONO", _wrap_TTF_MONO_get, SWIG_Lua_set_immutable }, { "Unicode_Space", _wrap_Unicode_Space_get, SWIG_Lua_set_immutable }, + { "Unicode_IdeographicSpace", _wrap_Unicode_IdeographicSpace_get, SWIG_Lua_set_immutable }, { "Unicode_Latin", _wrap_Unicode_Latin_get, SWIG_Lua_set_immutable }, { "Unicode_Latin1Supplement", _wrap_Unicode_Latin1Supplement_get, SWIG_Lua_set_immutable }, + { "Unicode_LatinA", _wrap_Unicode_LatinA_get, SWIG_Lua_set_immutable }, { "Unicode_Greek", _wrap_Unicode_Greek_get, SWIG_Lua_set_immutable }, { "Unicode_Cyrillic", _wrap_Unicode_Cyrillic_get, SWIG_Lua_set_immutable }, { "Unicode_Arabic", _wrap_Unicode_Arabic_get, SWIG_Lua_set_immutable }, @@ -50535,15 +48882,11 @@ static swig_lua_attribute swig_SwigModule_attributes[] = { { "Unicode_MiscSymbolsAndPictographs", _wrap_Unicode_MiscSymbolsAndPictographs_get, SWIG_Lua_set_immutable }, { "Unicode_Emoticons", _wrap_Unicode_Emoticons_get, SWIG_Lua_set_immutable }, { "Unicode_TransportAndMap", _wrap_Unicode_TransportAndMap_get, SWIG_Lua_set_immutable }, - { "Alphabet_Emoji", _wrap_Alphabet_Emoji_get, SWIG_Lua_set_immutable }, - { "Alphabet_Japanese", _wrap_Alphabet_Japanese_get, SWIG_Lua_set_immutable }, - { "Alphabet_Chinese", _wrap_Alphabet_Chinese_get, SWIG_Lua_set_immutable }, - { "Alphabet_Korean", _wrap_Alphabet_Korean_get, SWIG_Lua_set_immutable }, - { "Alphabet_Arabic", _wrap_Alphabet_Arabic_get, SWIG_Lua_set_immutable }, - { "Alphabet_Devanagari", _wrap_Alphabet_Devanagari_get, SWIG_Lua_set_immutable }, - { "Alphabet_Latin", _wrap_Alphabet_Latin_get, SWIG_Lua_set_immutable }, - { "Alphabet_Greek", _wrap_Alphabet_Greek_get, SWIG_Lua_set_immutable }, - { "Alphabet_Cyrillic", _wrap_Alphabet_Cyrillic_get, SWIG_Lua_set_immutable }, + { "Unicode_EnclosedCharacters", _wrap_Unicode_EnclosedCharacters_get, SWIG_Lua_set_immutable }, + { "Unicode_Uncategorized", _wrap_Unicode_Uncategorized_get, SWIG_Lua_set_immutable }, + { "Unicode_AdditionalEmoticons", _wrap_Unicode_AdditionalEmoticons_get, SWIG_Lua_set_immutable }, + { "Unicode_AdditionalTransportAndMap", _wrap_Unicode_AdditionalTransportAndMap_get, SWIG_Lua_set_immutable }, + { "Unicode_OtherAdditionalSymbols", _wrap_Unicode_OtherAdditionalSymbols_get, SWIG_Lua_set_immutable }, { "Color_white", _wrap_Color_white_get, SWIG_Lua_set_immutable }, { "Color_gray", _wrap_Color_gray_get, SWIG_Lua_set_immutable }, { "Color_black", _wrap_Color_black_get, SWIG_Lua_set_immutable }, @@ -50992,7 +49335,7 @@ static swig_lua_attribute swig_SwigModule_attributes[] = { }; static swig_lua_const_info swig_SwigModule_constants[]= { {SWIG_LUA_CONSTTAB_INT("VERSION_MAJOR", 0)}, - {SWIG_LUA_CONSTTAB_INT("VERSION_MINOR", 10)}, + {SWIG_LUA_CONSTTAB_INT("VERSION_MINOR", 11)}, {SWIG_LUA_CONSTTAB_INT("VERSION_PATCH", 0)}, {SWIG_LUA_CONSTTAB_STRING("VERSION_PRE_RELEASE", "master")}, {SWIG_LUA_CONSTTAB_INT("USE_LEGACY_VECTOR_MATH", 0)}, @@ -51007,12 +49350,21 @@ static swig_lua_const_info swig_SwigModule_constants[]= { {SWIG_LUA_CONSTTAB_INT("TARGET_LINUXARMV6L", OF_TARGET_LINUXARMV6L)}, {SWIG_LUA_CONSTTAB_INT("TARGET_LINUXARMV7L", OF_TARGET_LINUXARMV7L)}, {SWIG_LUA_CONSTTAB_INT("TARGET_EMSCRIPTEN", OF_TARGET_EMSCRIPTEN)}, - {SWIG_LUA_CONSTTAB_INT("GL_BGR_EXT", 0x80E0)}, {SWIG_LUA_CONSTTAB_INT("B14400", 14400)}, {SWIG_LUA_CONSTTAB_INT("B28800", 28800)}, - {SWIG_LUA_CONSTTAB_INT("ofFboBeginMode_NoDefaults", ofFboBeginMode::NoDefaults)}, - {SWIG_LUA_CONSTTAB_INT("ofFboBeginMode_Perspective", ofFboBeginMode::Perspective)}, - {SWIG_LUA_CONSTTAB_INT("ofFboBeginMode_MatrixFlip", ofFboBeginMode::MatrixFlip)}, + {SWIG_LUA_CONSTTAB_INT("HAS_TLS", 1)}, + {SWIG_LUA_CONSTTAB_FLOAT("PI", 3.14159265358979323846)}, + {SWIG_LUA_CONSTTAB_FLOAT("TWO_PI", 6.28318530717958647693)}, + {SWIG_LUA_CONSTTAB_FLOAT("M_TWO_PI", 6.28318530717958647693)}, + {SWIG_LUA_CONSTTAB_FLOAT("FOUR_PI", 12.56637061435917295385)}, + {SWIG_LUA_CONSTTAB_FLOAT("HALF_PI", 1.57079632679489661923)}, + {SWIG_LUA_CONSTTAB_FLOAT("DEG_TO_RAD", (3.14159265358979323846/180.0))}, + {SWIG_LUA_CONSTTAB_FLOAT("RAD_TO_DEG", (180.0/3.14159265358979323846))}, + {SWIG_LUA_CONSTTAB_INT("Time_System", ofTime::System)}, + {SWIG_LUA_CONSTTAB_INT("Time_FixedRate", ofTime::FixedRate)}, + {SWIG_LUA_CONSTTAB_INT("FBOMODE_NODEFAULTS", OF_FBOMODE_NODEFAULTS)}, + {SWIG_LUA_CONSTTAB_INT("FBOMODE_PERSPECTIVE", OF_FBOMODE_PERSPECTIVE)}, + {SWIG_LUA_CONSTTAB_INT("FBOMODE_MATRIXFLIP", OF_FBOMODE_MATRIXFLIP)}, {SWIG_LUA_CONSTTAB_INT("COMPRESS_NONE", OF_COMPRESS_NONE)}, {SWIG_LUA_CONSTTAB_INT("COMPRESS_SRGB", OF_COMPRESS_SRGB)}, {SWIG_LUA_CONSTTAB_INT("COMPRESS_ARB", OF_COMPRESS_ARB)}, @@ -51057,6 +49409,20 @@ static swig_lua_const_info swig_SwigModule_constants[]= { {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_PFM", OF_IMAGE_FORMAT_PFM)}, {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_PICT", OF_IMAGE_FORMAT_PICT)}, {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_RAW", OF_IMAGE_FORMAT_RAW)}, + {SWIG_LUA_CONSTTAB_INT("SoundDevice_UNSPECIFIED", ofSoundDevice::UNSPECIFIED)}, + {SWIG_LUA_CONSTTAB_INT("SoundDevice_DEFAULT", ofSoundDevice::DEFAULT)}, + {SWIG_LUA_CONSTTAB_INT("SoundDevice_ALSA", ofSoundDevice::ALSA)}, + {SWIG_LUA_CONSTTAB_INT("SoundDevice_PULSE", ofSoundDevice::PULSE)}, + {SWIG_LUA_CONSTTAB_INT("SoundDevice_OSS", ofSoundDevice::OSS)}, + {SWIG_LUA_CONSTTAB_INT("SoundDevice_JACK", ofSoundDevice::JACK)}, + {SWIG_LUA_CONSTTAB_INT("SoundDevice_OSX_CORE", ofSoundDevice::OSX_CORE)}, + {SWIG_LUA_CONSTTAB_INT("SoundDevice_MS_WASAPI", ofSoundDevice::MS_WASAPI)}, + {SWIG_LUA_CONSTTAB_INT("SoundDevice_MS_ASIO", ofSoundDevice::MS_ASIO)}, + {SWIG_LUA_CONSTTAB_INT("SoundDevice_MS_DS", ofSoundDevice::MS_DS)}, + {SWIG_LUA_CONSTTAB_INT("SoundDevice_NUM_APIS", ofSoundDevice::NUM_APIS)}, + {SWIG_LUA_CONSTTAB_INT("LOOP_NONE", OF_LOOP_NONE)}, + {SWIG_LUA_CONSTTAB_INT("LOOP_PALINDROME", OF_LOOP_PALINDROME)}, + {SWIG_LUA_CONSTTAB_INT("LOOP_NORMAL", OF_LOOP_NORMAL)}, {SWIG_LUA_CONSTTAB_INT("EasyCam_TRANSFORM_NONE", ofEasyCam::TRANSFORM_NONE)}, {SWIG_LUA_CONSTTAB_INT("EasyCam_TRANSFORM_ROTATE", ofEasyCam::TRANSFORM_ROTATE)}, {SWIG_LUA_CONSTTAB_INT("EasyCam_TRANSFORM_TRANSLATE_XY", ofEasyCam::TRANSFORM_TRANSLATE_XY)}, @@ -51197,13 +49563,6 @@ static swig_lua_const_info swig_SwigModule_constants[]= { {SWIG_LUA_CONSTTAB_INT("Vec2f_DIM", ofVec2f::DIM)}, {SWIG_LUA_CONSTTAB_INT("Vec3f_DIM", ofVec3f::DIM)}, {SWIG_LUA_CONSTTAB_INT("Vec4f_DIM", ofVec4f::DIM)}, - {SWIG_LUA_CONSTTAB_FLOAT("PI", 3.14159265358979323846)}, - {SWIG_LUA_CONSTTAB_FLOAT("TWO_PI", 6.28318530717958647693)}, - {SWIG_LUA_CONSTTAB_FLOAT("M_TWO_PI", 6.28318530717958647693)}, - {SWIG_LUA_CONSTTAB_FLOAT("FOUR_PI", 12.56637061435917295385)}, - {SWIG_LUA_CONSTTAB_FLOAT("HALF_PI", 1.57079632679489661923)}, - {SWIG_LUA_CONSTTAB_FLOAT("DEG_TO_RAD", (3.14159265358979323846/180.0))}, - {SWIG_LUA_CONSTTAB_FLOAT("RAD_TO_DEG", (180.0/3.14159265358979323846))}, {SWIG_LUA_CONSTTAB_INT("KEY_RETURN", OF_KEY_RETURN)}, {SWIG_LUA_CONSTTAB_INT("KEY_ESC", OF_KEY_ESC)}, {SWIG_LUA_CONSTTAB_INT("KEY_TAB", OF_KEY_TAB)}, @@ -51224,7 +49583,6 @@ static swig_lua_const_info swig_SwigModule_constants[]= { {SWIG_LUA_CONSTTAB_INT("KEY_RIGHT_SUPER", OF_KEY_RIGHT_SUPER)}, {SWIG_LUA_CONSTTAB_INT("KEY_LEFT_COMMAND", OF_KEY_LEFT_COMMAND)}, {SWIG_LUA_CONSTTAB_INT("KEY_RIGHT_COMMAND", OF_KEY_RIGHT_COMMAND)}, - {SWIG_LUA_CONSTTAB_INT("KEY_MODIFIER", OF_KEY_MODIFIER)}, {SWIG_LUA_CONSTTAB_INT("KEY_F1", OF_KEY_F1)}, {SWIG_LUA_CONSTTAB_INT("KEY_F2", OF_KEY_F2)}, {SWIG_LUA_CONSTTAB_INT("KEY_F3", OF_KEY_F3)}, @@ -51263,9 +49621,6 @@ static swig_lua_const_info swig_SwigModule_constants[]= { {SWIG_LUA_CONSTTAB_INT("TouchEventArgs_move", ofTouchEventArgs::move)}, {SWIG_LUA_CONSTTAB_INT("TouchEventArgs_doubleTap", ofTouchEventArgs::doubleTap)}, {SWIG_LUA_CONSTTAB_INT("TouchEventArgs_cancel", ofTouchEventArgs::cancel)}, - {SWIG_LUA_CONSTTAB_INT("System", System)}, - {SWIG_LUA_CONSTTAB_INT("FixedRate", FixedRate)}, - {SWIG_LUA_CONSTTAB_INT("Filtered", Filtered)}, {SWIG_LUA_CONSTTAB_INT("TEXTURE_LUMINANCE", 6409)}, {SWIG_LUA_CONSTTAB_INT("TEXTURE_RGB", 6407)}, {SWIG_LUA_CONSTTAB_INT("TEXTURE_RGBA", 6408)}, @@ -51281,40 +49636,6 @@ static swig_lua_const_info swig_SwigModule_constants[]= { {SWIG_LUA_CONSTTAB_INT("LIGHT_DIRECTIONAL", OF_LIGHT_DIRECTIONAL)}, {SWIG_LUA_CONSTTAB_INT("LIGHT_SPOT", OF_LIGHT_SPOT)}, {SWIG_LUA_CONSTTAB_INT("LIGHT_AREA", OF_LIGHT_AREA)}, - {SWIG_LUA_CONSTTAB_INT("Shader_POSITION_ATTRIBUTE", ofShader::POSITION_ATTRIBUTE)}, - {SWIG_LUA_CONSTTAB_INT("Shader_COLOR_ATTRIBUTE", ofShader::COLOR_ATTRIBUTE)}, - {SWIG_LUA_CONSTTAB_INT("Shader_NORMAL_ATTRIBUTE", ofShader::NORMAL_ATTRIBUTE)}, - {SWIG_LUA_CONSTTAB_INT("Shader_TEXCOORD_ATTRIBUTE", ofShader::TEXCOORD_ATTRIBUTE)}, - {SWIG_LUA_CONSTTAB_INT("Shader_INDEX_ATTRIBUTE", ofShader::INDEX_ATTRIBUTE)}, - {SWIG_LUA_CONSTTAB_INT("INTERPOLATE_NEAREST_NEIGHBOR", OF_INTERPOLATE_NEAREST_NEIGHBOR)}, - {SWIG_LUA_CONSTTAB_INT("INTERPOLATE_BILINEAR", OF_INTERPOLATE_BILINEAR)}, - {SWIG_LUA_CONSTTAB_INT("INTERPOLATE_BICUBIC", OF_INTERPOLATE_BICUBIC)}, - {SWIG_LUA_CONSTTAB_INT("PIXELS_GRAY", OF_PIXELS_GRAY)}, - {SWIG_LUA_CONSTTAB_INT("PIXELS_GRAY_ALPHA", OF_PIXELS_GRAY_ALPHA)}, - {SWIG_LUA_CONSTTAB_INT("PIXELS_RGB", OF_PIXELS_RGB)}, - {SWIG_LUA_CONSTTAB_INT("PIXELS_BGR", OF_PIXELS_BGR)}, - {SWIG_LUA_CONSTTAB_INT("PIXELS_RGBA", OF_PIXELS_RGBA)}, - {SWIG_LUA_CONSTTAB_INT("PIXELS_BGRA", OF_PIXELS_BGRA)}, - {SWIG_LUA_CONSTTAB_INT("PIXELS_RGB565", OF_PIXELS_RGB565)}, - {SWIG_LUA_CONSTTAB_INT("PIXELS_NV12", OF_PIXELS_NV12)}, - {SWIG_LUA_CONSTTAB_INT("PIXELS_NV21", OF_PIXELS_NV21)}, - {SWIG_LUA_CONSTTAB_INT("PIXELS_YV12", OF_PIXELS_YV12)}, - {SWIG_LUA_CONSTTAB_INT("PIXELS_I420", OF_PIXELS_I420)}, - {SWIG_LUA_CONSTTAB_INT("PIXELS_YUY2", OF_PIXELS_YUY2)}, - {SWIG_LUA_CONSTTAB_INT("PIXELS_UYVY", OF_PIXELS_UYVY)}, - {SWIG_LUA_CONSTTAB_INT("PIXELS_Y", OF_PIXELS_Y)}, - {SWIG_LUA_CONSTTAB_INT("PIXELS_U", OF_PIXELS_U)}, - {SWIG_LUA_CONSTTAB_INT("PIXELS_V", OF_PIXELS_V)}, - {SWIG_LUA_CONSTTAB_INT("PIXELS_UV", OF_PIXELS_UV)}, - {SWIG_LUA_CONSTTAB_INT("PIXELS_VU", OF_PIXELS_VU)}, - {SWIG_LUA_CONSTTAB_INT("PIXELS_NUM_FORMATS", OF_PIXELS_NUM_FORMATS)}, - {SWIG_LUA_CONSTTAB_INT("PIXELS_UNKNOWN", OF_PIXELS_UNKNOWN)}, - {SWIG_LUA_CONSTTAB_INT("PIXELS_NATIVE", OF_PIXELS_NATIVE)}, - {SWIG_LUA_CONSTTAB_INT("Path_COMMANDS", ofPath::COMMANDS)}, - {SWIG_LUA_CONSTTAB_INT("Path_POLYLINES", ofPath::POLYLINES)}, - {SWIG_LUA_CONSTTAB_INT("CIRC_RESOLUTION", 22)}, - {SWIG_LUA_CONSTTAB_INT("OPEN", OF_OPEN)}, - {SWIG_LUA_CONSTTAB_INT("CLOSE", OF_CLOSE)}, {SWIG_LUA_CONSTTAB_INT("MESH_POINTS", OF_MESH_POINTS)}, {SWIG_LUA_CONSTTAB_INT("MESH_WIREFRAME", OF_MESH_WIREFRAME)}, {SWIG_LUA_CONSTTAB_INT("MESH_FILL", OF_MESH_FILL)}, @@ -51365,6 +49686,46 @@ static swig_lua_const_info swig_SwigModule_constants[]= { {SWIG_LUA_CONSTTAB_INT("IMAGE_COLOR", OF_IMAGE_COLOR)}, {SWIG_LUA_CONSTTAB_INT("IMAGE_COLOR_ALPHA", OF_IMAGE_COLOR_ALPHA)}, {SWIG_LUA_CONSTTAB_INT("IMAGE_UNDEFINED", OF_IMAGE_UNDEFINED)}, + {SWIG_LUA_CONSTTAB_INT("INTERPOLATE_NEAREST_NEIGHBOR", OF_INTERPOLATE_NEAREST_NEIGHBOR)}, + {SWIG_LUA_CONSTTAB_INT("INTERPOLATE_BILINEAR", OF_INTERPOLATE_BILINEAR)}, + {SWIG_LUA_CONSTTAB_INT("INTERPOLATE_BICUBIC", OF_INTERPOLATE_BICUBIC)}, + {SWIG_LUA_CONSTTAB_INT("PIXELS_GRAY", OF_PIXELS_GRAY)}, + {SWIG_LUA_CONSTTAB_INT("PIXELS_GRAY_ALPHA", OF_PIXELS_GRAY_ALPHA)}, + {SWIG_LUA_CONSTTAB_INT("PIXELS_RGB", OF_PIXELS_RGB)}, + {SWIG_LUA_CONSTTAB_INT("PIXELS_BGR", OF_PIXELS_BGR)}, + {SWIG_LUA_CONSTTAB_INT("PIXELS_RGBA", OF_PIXELS_RGBA)}, + {SWIG_LUA_CONSTTAB_INT("PIXELS_BGRA", OF_PIXELS_BGRA)}, + {SWIG_LUA_CONSTTAB_INT("PIXELS_RGB565", OF_PIXELS_RGB565)}, + {SWIG_LUA_CONSTTAB_INT("PIXELS_NV12", OF_PIXELS_NV12)}, + {SWIG_LUA_CONSTTAB_INT("PIXELS_NV21", OF_PIXELS_NV21)}, + {SWIG_LUA_CONSTTAB_INT("PIXELS_YV12", OF_PIXELS_YV12)}, + {SWIG_LUA_CONSTTAB_INT("PIXELS_I420", OF_PIXELS_I420)}, + {SWIG_LUA_CONSTTAB_INT("PIXELS_YUY2", OF_PIXELS_YUY2)}, + {SWIG_LUA_CONSTTAB_INT("PIXELS_UYVY", OF_PIXELS_UYVY)}, + {SWIG_LUA_CONSTTAB_INT("PIXELS_Y", OF_PIXELS_Y)}, + {SWIG_LUA_CONSTTAB_INT("PIXELS_U", OF_PIXELS_U)}, + {SWIG_LUA_CONSTTAB_INT("PIXELS_V", OF_PIXELS_V)}, + {SWIG_LUA_CONSTTAB_INT("PIXELS_UV", OF_PIXELS_UV)}, + {SWIG_LUA_CONSTTAB_INT("PIXELS_VU", OF_PIXELS_VU)}, + {SWIG_LUA_CONSTTAB_INT("PIXELS_NUM_FORMATS", OF_PIXELS_NUM_FORMATS)}, + {SWIG_LUA_CONSTTAB_INT("PIXELS_UNKNOWN", OF_PIXELS_UNKNOWN)}, + {SWIG_LUA_CONSTTAB_INT("PIXELS_NATIVE", OF_PIXELS_NATIVE)}, + {SWIG_LUA_CONSTTAB_INT("Path_COMMANDS", ofPath::COMMANDS)}, + {SWIG_LUA_CONSTTAB_INT("Path_POLYLINES", ofPath::POLYLINES)}, + {SWIG_LUA_CONSTTAB_INT("CIRC_RESOLUTION", 22)}, + {SWIG_LUA_CONSTTAB_INT("OPEN", OF_OPEN)}, + {SWIG_LUA_CONSTTAB_INT("CLOSE", OF_CLOSE)}, + {SWIG_LUA_CONSTTAB_INT("Alphabet_Emoji", ofAlphabet_Emoji)}, + {SWIG_LUA_CONSTTAB_INT("Alphabet_Japanese", ofAlphabet_Japanese)}, + {SWIG_LUA_CONSTTAB_INT("Alphabet_Chinese", ofAlphabet_Chinese)}, + {SWIG_LUA_CONSTTAB_INT("Alphabet_Korean", ofAlphabet_Korean)}, + {SWIG_LUA_CONSTTAB_INT("Alphabet_Arabic", ofAlphabet_Arabic)}, + {SWIG_LUA_CONSTTAB_INT("Alphabet_Devanagari", ofAlphabet_Devanagari)}, + {SWIG_LUA_CONSTTAB_INT("Alphabet_Latin", ofAlphabet_Latin)}, + {SWIG_LUA_CONSTTAB_INT("Alphabet_Greek", ofAlphabet_Greek)}, + {SWIG_LUA_CONSTTAB_INT("Alphabet_Cyrillic", ofAlphabet_Cyrillic)}, + {SWIG_LUA_CONSTTAB_INT("TTF_LEFT_TO_RIGHT", OF_TTF_LEFT_TO_RIGHT)}, + {SWIG_LUA_CONSTTAB_INT("TTF_RIGHT_TO_LEFT", OF_TTF_RIGHT_TO_LEFT)}, {SWIG_LUA_CONSTTAB_INT("ASPECT_RATIO_IGNORE", OF_ASPECT_RATIO_IGNORE)}, {SWIG_LUA_CONSTTAB_INT("ASPECT_RATIO_KEEP", OF_ASPECT_RATIO_KEEP)}, {SWIG_LUA_CONSTTAB_INT("ASPECT_RATIO_KEEP_BY_EXPANDING", OF_ASPECT_RATIO_KEEP_BY_EXPANDING)}, @@ -51391,14 +49752,89 @@ static swig_lua_const_info swig_SwigModule_constants[]= { {SWIG_LUA_CONSTTAB_INT("LOG_ERROR", OF_LOG_ERROR)}, {SWIG_LUA_CONSTTAB_INT("LOG_FATAL_ERROR", OF_LOG_FATAL_ERROR)}, {SWIG_LUA_CONSTTAB_INT("LOG_SILENT", OF_LOG_SILENT)}, - {SWIG_LUA_CONSTTAB_INT("CONSOLE_COLOR_BLACK", (0))}, + {SWIG_LUA_CONSTTAB_INT("CONSOLE_COLOR_RESTORE", (0))}, + {SWIG_LUA_CONSTTAB_INT("CONSOLE_COLOR_BLACK", (30))}, + {SWIG_LUA_CONSTTAB_INT("CONSOLE_COLOR_RED", (31))}, + {SWIG_LUA_CONSTTAB_INT("CONSOLE_COLOR_GREEN", (32))}, + {SWIG_LUA_CONSTTAB_INT("CONSOLE_COLOR_YELLOW", (33))}, + {SWIG_LUA_CONSTTAB_INT("CONSOLE_COLOR_BLUE", (34))}, + {SWIG_LUA_CONSTTAB_INT("CONSOLE_COLOR_PURPLE", (35))}, + {SWIG_LUA_CONSTTAB_INT("CONSOLE_COLOR_CYAN", (36))}, + {SWIG_LUA_CONSTTAB_INT("CONSOLE_COLOR_WHITE", (37))}, {SWIG_LUA_CONSTTAB_INT("HttpRequest_GET", ofHttpRequest::GET)}, {SWIG_LUA_CONSTTAB_INT("HttpRequest_POST", ofHttpRequest::POST)}, - {SWIG_LUA_CONSTTAB_INT("Time_System", ofTime::System)}, - {SWIG_LUA_CONSTTAB_INT("Time_FixedRate", ofTime::FixedRate)}, {0,0,0,0,0,0} }; static swig_lua_method swig_SwigModule_methods[]= { + { "resetElapsedTimeCounter", _wrap_resetElapsedTimeCounter}, + { "getElapsedTimef", _wrap_getElapsedTimef}, + { "getElapsedTimeMillis", _wrap_getElapsedTimeMillis}, + { "getElapsedTimeMicros", _wrap_getElapsedTimeMicros}, + { "getFrameNum", _wrap_getFrameNum}, + { "getSeconds", _wrap_getSeconds}, + { "getMinutes", _wrap_getMinutes}, + { "getHours", _wrap_getHours}, + { "getUnixTime", _wrap_getUnixTime}, + { "getSystemTimeMillis", _wrap_getSystemTimeMillis}, + { "getSystemTimeMicros", _wrap_getSystemTimeMicros}, + { "getCurrentTime", _wrap_getCurrentTime}, + { "sleepMillis", _wrap_sleepMillis}, + { "getTimestampString", _wrap_getTimestampString}, + { "getYear", _wrap_getYear}, + { "getMonth", _wrap_getMonth}, + { "getDay", _wrap_getDay}, + { "getWeekday", _wrap_getWeekday}, + { "enableDataPath", _wrap_enableDataPath}, + { "disableDataPath", _wrap_disableDataPath}, + { "toDataPath", _wrap_toDataPath}, + { "restoreWorkingDirectoryToDefault", _wrap_restoreWorkingDirectoryToDefault}, + { "setDataPathRoot", _wrap_setDataPathRoot}, + { "splitString", _wrap_splitString}, + { "joinString", _wrap_joinString}, + { "stringReplace", _wrap_stringReplace}, + { "isStringInString", _wrap_isStringInString}, + { "stringTimesInString", _wrap_stringTimesInString}, + { "toLower", _wrap_toLower}, + { "toUpper", _wrap_toUpper}, + { "trimFront", _wrap_trimFront}, + { "trimBack", _wrap_trimBack}, + { "trim", _wrap_trim}, + { "uTF8Append", _wrap_uTF8Append}, + { "uTF8Insert", _wrap_uTF8Insert}, + { "uTF8Erase", _wrap_uTF8Erase}, + { "uTF8Substring", _wrap_uTF8Substring}, + { "uTF8ToString", _wrap_uTF8ToString}, + { "uTF8Length", _wrap_uTF8Length}, + { "toInt", _wrap_toInt}, + { "toInt64", _wrap_toInt64}, + { "toFloat", _wrap_toFloat}, + { "toDouble", _wrap_toDouble}, + { "toBool", _wrap_toBool}, + { "toHex", _wrap_toHex}, + { "hexToInt", _wrap_hexToInt}, + { "hexToChar", _wrap_hexToChar}, + { "hexToFloat", _wrap_hexToFloat}, + { "hexToString", _wrap_hexToString}, + { "toChar", _wrap_toChar}, + { "toBinary", _wrap_toBinary}, + { "binaryToInt", _wrap_binaryToInt}, + { "binaryToChar", _wrap_binaryToChar}, + { "binaryToFloat", _wrap_binaryToFloat}, + { "binaryToString", _wrap_binaryToString}, + { "getVersionInfo", _wrap_getVersionInfo}, + { "getVersionMajor", _wrap_getVersionMajor}, + { "getVersionMinor", _wrap_getVersionMinor}, + { "getVersionPatch", _wrap_getVersionPatch}, + { "getVersionPreRelease", _wrap_getVersionPreRelease}, + { "saveScreen", _wrap_saveScreen}, + { "saveFrame", _wrap_saveFrame}, + { "saveViewport", _wrap_saveViewport}, + { "launchBrowser", _wrap_launchBrowser}, + { "system", _wrap_system}, + { "getTargetPlatform", _wrap_getTargetPlatform}, + { "getEnv", _wrap_getEnv}, + { "FboModeOr", _wrap_FboModeOr}, + { "FboModeAnd", _wrap_FboModeAnd}, { "Fbo_checkGLSupport", _wrap_Fbo_checkGLSupport}, { "Fbo_maxColorAttachments", _wrap_Fbo_maxColorAttachments}, { "Fbo_maxDrawBuffers", _wrap_Fbo_maxDrawBuffers}, @@ -51413,16 +49849,25 @@ static swig_lua_method swig_SwigModule_methods[]= { { "disableTextureEdgeHack", _wrap_disableTextureEdgeHack}, { "isTextureEdgeHackEnabled", _wrap_isTextureEdgeHackEnabled}, { "imageFormatExtension", _wrap_imageFormatExtension}, + { "loadImage", _wrap_loadImage}, + { "saveImage", _wrap_saveImage}, + { "toString", _wrap_toString}, { "drawAxis", _wrap_drawAxis}, { "drawGrid", _wrap_drawGrid}, { "drawGridPlane", _wrap_drawGridPlane}, { "drawArrow", _wrap_drawArrow}, { "drawRotationAxes", _wrap_drawRotationAxes}, - { "getAppPtr", _wrap_getAppPtr}, + { "Mesh_plane", _wrap_Mesh_plane}, + { "Mesh_sphere", _wrap_Mesh_sphere}, + { "Mesh_icosahedron", _wrap_Mesh_icosahedron}, + { "Mesh_icosphere", _wrap_Mesh_icosphere}, + { "Mesh_cylinder", _wrap_Mesh_cylinder}, + { "Mesh_cone", _wrap_Mesh_cone}, + { "Mesh_box", _wrap_Mesh_box}, + { "Mesh_axis", _wrap_Mesh_axis}, { "exit", _wrap_exit}, { "getFrameRate", _wrap_getFrameRate}, { "getTargetFrameRate", _wrap_getTargetFrameRate}, - { "getFrameNum", _wrap_getFrameNum}, { "setFrameRate", _wrap_setFrameRate}, { "getLastFrameTime", _wrap_getLastFrameTime}, { "setTimeModeSystem", _wrap_setTimeModeSystem}, @@ -51449,7 +49894,6 @@ static swig_lua_method swig_SwigModule_methods[]= { { "doesHWOrientation", _wrap_doesHWOrientation}, { "getWindowSize", _wrap_getWindowSize}, { "getWindowRect", _wrap_getWindowRect}, - { "getCurrentWindow", _wrap_getCurrentWindow}, { "setWindowPosition", _wrap_setWindowPosition}, { "setWindowShape", _wrap_setWindowShape}, { "setWindowTitle", _wrap_setWindowTitle}, @@ -51510,11 +49954,11 @@ static swig_lua_method swig_SwigModule_methods[]= { { "getPreviousMouseX", _wrap_getPreviousMouseX}, { "getPreviousMouseY", _wrap_getPreviousMouseY}, { "sendMessage", _wrap_sendMessage}, - { "getGlInternalFormat", _wrap_getGlInternalFormat}, - { "getGlInternalFormatName", _wrap_getGlInternalFormatName}, + { "getGLInternalFormat", _wrap_getGLInternalFormat}, + { "getGLInternalFormatName", _wrap_getGLInternalFormatName}, { "getGLFormatFromInternal", _wrap_getGLFormatFromInternal}, - { "getGlTypeFromInternal", _wrap_getGlTypeFromInternal}, - { "getGlType", _wrap_getGlType}, + { "getGLTypeFromInternal", _wrap_getGLTypeFromInternal}, + { "getGLType", _wrap_getGLType}, { "getImageTypeFromGLType", _wrap_getImageTypeFromGLType}, { "getGLPolyMode", _wrap_getGLPolyMode}, { "getOFPolyMode", _wrap_getOFPolyMode}, @@ -51525,11 +49969,11 @@ static swig_lua_method swig_SwigModule_methods[]= { { "getBytesPerChannelFromGLType", _wrap_getBytesPerChannelFromGLType}, { "getNumChannelsFromGLFormat", _wrap_getNumChannelsFromGLFormat}, { "setPixelStoreiAlignment", _wrap_setPixelStoreiAlignment}, - { "GLSupportedExtensions", _wrap_GLSupportedExtensions}, - { "GLCheckExtension", _wrap_GLCheckExtension}, - { "GLSupportsNPOTTextures", _wrap_GLSupportsNPOTTextures}, + { "gLSupportedExtensions", _wrap_gLSupportedExtensions}, + { "gLCheckExtension", _wrap_gLCheckExtension}, + { "gLSupportsNPOTTextures", _wrap_gLSupportsNPOTTextures}, { "isGLProgrammableRenderer", _wrap_isGLProgrammableRenderer}, - { "GLSLVersionFromGL", _wrap_GLSLVersionFromGL}, + { "gLSLVersionFromGL", _wrap_gLSLVersionFromGL}, { "enableGLDebugLog", _wrap_enableGLDebugLog}, { "disableGLDebugLog", _wrap_disableGLDebugLog}, { "enableLighting", _wrap_enableLighting}, @@ -51540,7 +49984,6 @@ static swig_lua_method swig_SwigModule_methods[]= { { "setSmoothLighting", _wrap_setSmoothLighting}, { "setGlobalAmbientColor", _wrap_setGlobalAmbientColor}, { "getGlobalAmbientColor", _wrap_getGlobalAmbientColor}, - { "lightsData", _wrap_lightsData}, { "Polyline_fromRectangle", _wrap_Polyline_fromRectangle}, { "drawBitmapString", _wrap_drawBitmapString}, { "setColor", _wrap_setColor}, @@ -51608,10 +50051,6 @@ static swig_lua_method swig_SwigModule_methods[]= { { "getCurrentNormalMatrix", _wrap_getCurrentNormalMatrix}, { "translate", _wrap_translate}, { "scale", _wrap_scale}, - { "rotate", _wrap_rotate}, - { "rotateX", _wrap_rotateX}, - { "rotateY", _wrap_rotateY}, - { "rotateZ", _wrap_rotateZ}, { "rotateDeg", _wrap_rotateDeg}, { "rotateXDeg", _wrap_rotateXDeg}, { "rotateYDeg", _wrap_rotateYDeg}, @@ -51713,7 +50152,6 @@ static swig_lua_method swig_SwigModule_methods[]= { { "getLogLevelName", _wrap_getLogLevelName}, { "logToFile", _wrap_logToFile}, { "logToConsole", _wrap_logToConsole}, - { "logToDebugView", _wrap_logToDebugView}, { "getLoggerChannel", _wrap_getLoggerChannel}, { "systemAlertDialog", _wrap_systemAlertDialog}, { "systemLoadDialog", _wrap_systemLoadDialog}, @@ -51726,75 +50164,6 @@ static swig_lua_method swig_SwigModule_methods[]= { { "removeURLRequest", _wrap_removeURLRequest}, { "removeAllURLRequests", _wrap_removeAllURLRequests}, { "stopURLLoader", _wrap_stopURLLoader}, - { "uRLResponseEvent", _wrap_uRLResponseEvent}, - { "resetElapsedTimeCounter", _wrap_resetElapsedTimeCounter}, - { "getElapsedTimef", _wrap_getElapsedTimef}, - { "getElapsedTimeMillis", _wrap_getElapsedTimeMillis}, - { "getElapsedTimeMicros", _wrap_getElapsedTimeMicros}, - { "getSeconds", _wrap_getSeconds}, - { "getMinutes", _wrap_getMinutes}, - { "getHours", _wrap_getHours}, - { "getUnixTime", _wrap_getUnixTime}, - { "getSystemTime", _wrap_getSystemTime}, - { "getSystemTimeMillis", _wrap_getSystemTimeMillis}, - { "getSystemTimeMicros", _wrap_getSystemTimeMicros}, - { "getCurrentTime", _wrap_getCurrentTime}, - { "sleepMillis", _wrap_sleepMillis}, - { "getTimestampString", _wrap_getTimestampString}, - { "getYear", _wrap_getYear}, - { "getMonth", _wrap_getMonth}, - { "getDay", _wrap_getDay}, - { "getWeekday", _wrap_getWeekday}, - { "enableDataPath", _wrap_enableDataPath}, - { "disableDataPath", _wrap_disableDataPath}, - { "toDataPath", _wrap_toDataPath}, - { "restoreWorkingDirectoryToDefault", _wrap_restoreWorkingDirectoryToDefault}, - { "setDataPathRoot", _wrap_setDataPathRoot}, - { "splitString", _wrap_splitString}, - { "joinString", _wrap_joinString}, - { "stringReplace", _wrap_stringReplace}, - { "isStringInString", _wrap_isStringInString}, - { "stringTimesInString", _wrap_stringTimesInString}, - { "toLower", _wrap_toLower}, - { "toUpper", _wrap_toUpper}, - { "trimFront", _wrap_trimFront}, - { "trimBack", _wrap_trimBack}, - { "trim", _wrap_trim}, - { "appendUTF8", _wrap_appendUTF8}, - { "uTF8Append", _wrap_uTF8Append}, - { "uTF8Insert", _wrap_uTF8Insert}, - { "uTF8Erase", _wrap_uTF8Erase}, - { "uTF8Substring", _wrap_uTF8Substring}, - { "uTF8ToString", _wrap_uTF8ToString}, - { "uTF8Length", _wrap_uTF8Length}, - { "toInt", _wrap_toInt}, - { "toInt64", _wrap_toInt64}, - { "toFloat", _wrap_toFloat}, - { "toDouble", _wrap_toDouble}, - { "toBool", _wrap_toBool}, - { "toHex", _wrap_toHex}, - { "hexToInt", _wrap_hexToInt}, - { "hexToChar", _wrap_hexToChar}, - { "hexToFloat", _wrap_hexToFloat}, - { "hexToString", _wrap_hexToString}, - { "toChar", _wrap_toChar}, - { "toBinary", _wrap_toBinary}, - { "binaryToInt", _wrap_binaryToInt}, - { "binaryToChar", _wrap_binaryToChar}, - { "binaryToFloat", _wrap_binaryToFloat}, - { "binaryToString", _wrap_binaryToString}, - { "getVersionInfo", _wrap_getVersionInfo}, - { "getVersionMajor", _wrap_getVersionMajor}, - { "getVersionMinor", _wrap_getVersionMinor}, - { "getVersionPatch", _wrap_getVersionPatch}, - { "getVersionPreRelease", _wrap_getVersionPreRelease}, - { "saveScreen", _wrap_saveScreen}, - { "saveFrame", _wrap_saveFrame}, - { "saveViewport", _wrap_saveViewport}, - { "launchBrowser", _wrap_launchBrowser}, - { "system", _wrap_system}, - { "getTargetPlatform", _wrap_getTargetPlatform}, - { "getEnv", _wrap_getEnv}, {0,0} }; static swig_lua_class* swig_SwigModule_classes[]= { @@ -51806,6 +50175,7 @@ static swig_lua_class* swig_SwigModule_classes[]= { &_wrap_class_UCharVector, &_wrap_class_VideoDeviceVector, &_wrap_class_TextureVector, +&_wrap_class_Time, &_wrap_class_Fbo, &_wrap_class_TextureData, &_wrap_class_Texture, @@ -51813,10 +50183,19 @@ static swig_lua_class* swig_SwigModule_classes[]= { &_wrap_class_Image, &_wrap_class_FloatImage, &_wrap_class_ShortImage, +&_wrap_class_Style, +&_wrap_class_SoundDevice, +&_wrap_class_SoundStreamSettings, +&_wrap_class_BaseSoundStream, +&_wrap_class_BaseSoundPlayer, +&_wrap_class_VideoFormat, +&_wrap_class_VideoDevice, &_wrap_class_Node, &_wrap_class_Camera, &_wrap_class_EasyCam, -&_wrap_class_MeshData, +&_wrap_class_MeshFaceVector, +&_wrap_class_Mesh, +&_wrap_class_MeshFace, &_wrap_class_3dPrimitive, &_wrap_class_PlanePrimitive, &_wrap_class_SpherePrimitive, @@ -51840,9 +50219,9 @@ static swig_lua_class* swig_SwigModule_classes[]= { &_wrap_class_Vec4f, &_wrap_class_DragInfo, &_wrap_class_TouchEventArgs, -&_wrap_class_WindowPosEventArgs, &_wrap_class_BufferObject, &_wrap_class_Light, +&_wrap_class_MaterialSettings, &_wrap_class_Material, &_wrap_class_Shader, &_wrap_class_Vbo, @@ -51852,9 +50231,10 @@ static swig_lua_class* swig_SwigModule_classes[]= { &_wrap_class_ShortPixels, &_wrap_class_Path, &_wrap_class_PolylineVector, +&_wrap_class_VertexVector, &_wrap_class_Polyline, &_wrap_class_Unicode, -&_wrap_class_Alphabet, +&_wrap_class_TrueTypeFontSettings, &_wrap_class_TrueTypeFont, &_wrap_class_SoundStream, &_wrap_class_SoundPlayer, @@ -51864,18 +50244,16 @@ static swig_lua_class* swig_SwigModule_classes[]= { &_wrap_class_Rectangle, &_wrap_class_FpsCounter, &_wrap_class_Xml, -&_wrap_class_XmlSearchIterator, +&_wrap_class_XmlAttributeIterator, &_wrap_class_MatrixStack, &_wrap_class_Buffer, &_wrap_class_FilePath, &_wrap_class_File, &_wrap_class_Directory, -&_wrap_class_DebugViewLoggerChannel, &_wrap_class_FileDialogResult, &_wrap_class_HttpRequest, &_wrap_class_HttpResponse, &_wrap_class_URLFileLoader, -&_wrap_class_Time, &_wrap_class_VideoGrabber, &_wrap_class_VideoPlayer, 0 @@ -51931,6 +50309,9 @@ static void *_p_ofConePrimitiveTo_p_of3dPrimitive(void *x, int *SWIGUNUSEDPARM(n static void *_p_ofBoxPrimitiveTo_p_of3dPrimitive(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((of3dPrimitive *) ((ofBoxPrimitive *) x)); } +static void *_p_ofVideoPlayerTo_p_ofBaseVideoPlayer(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((ofBaseVideoPlayer *) ((ofVideoPlayer *) x)); +} static void *_p_of3dPrimitiveTo_p_ofNode(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((ofNode *) ((of3dPrimitive *) x)); } @@ -51964,12 +50345,24 @@ static void *_p_ofCameraTo_p_ofNode(void *x, int *SWIGUNUSEDPARM(newmemory)) { static void *_p_ofConsoleLoggerChannelTo_p_ofBaseLoggerChannel(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((ofBaseLoggerChannel *) ((ofConsoleLoggerChannel *) x)); } -static void *_p_ofDebugViewLoggerChannelTo_p_ofBaseLoggerChannel(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseLoggerChannel *) ((ofDebugViewLoggerChannel *) x)); -} static void *_p_ofFileLoggerChannelTo_p_ofBaseLoggerChannel(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((ofBaseLoggerChannel *) ((ofFileLoggerChannel *) x)); } +static void *_p_ofBaseVideoDrawsTo_p_ofBaseVideo(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((ofBaseVideo *) ((ofBaseVideoDraws *) x)); +} +static void *_p_ofBaseVideoGrabberTo_p_ofBaseVideo(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((ofBaseVideo *) ((ofBaseVideoGrabber *) x)); +} +static void *_p_ofVideoGrabberTo_p_ofBaseVideo(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((ofBaseVideo *) (ofBaseVideoGrabber *) ((ofVideoGrabber *) x)); +} +static void *_p_ofBaseVideoPlayerTo_p_ofBaseVideo(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((ofBaseVideo *) ((ofBaseVideoPlayer *) x)); +} +static void *_p_ofVideoPlayerTo_p_ofBaseVideo(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((ofBaseVideo *) (ofBaseVideoPlayer *) ((ofVideoPlayer *) x)); +} static void *_p_ofMouseEventArgsTo_p_glm__vec2(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((glm::vec2 *) ((ofMouseEventArgs *) x)); } @@ -51979,6 +50372,9 @@ static void *_p_ofTouchEventArgsTo_p_glm__vec2(void *x, int *SWIGUNUSEDPARM(newm static void *_p_ofWindowPosEventArgsTo_p_glm__vec2(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((glm::vec2 *) ((ofWindowPosEventArgs *) x)); } +static void *_p_ofFileTo_p_std__fstream(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((std::fstream *) ((ofFile *) x)); +} static void *_p_ofFboTo_p_ofBaseHasTexture(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((ofBaseHasTexture *) ((ofFbo *) x)); } @@ -52000,12 +50396,33 @@ static void *_p_ofWindowPosEventArgsTo_p_ofEventArgs(void *x, int *SWIGUNUSEDPAR static void *_p_ofMessageTo_p_ofEventArgs(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((ofEventArgs *) ((ofMessage *) x)); } +static void *_p_ofBaseVideoDrawsTo_p_ofBaseDraws(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((ofBaseDraws *) ((ofBaseVideoDraws *) x)); +} +static void *_p_ofVideoGrabberTo_p_ofBaseDraws(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((ofBaseDraws *) (ofBaseVideoDraws *) ((ofVideoGrabber *) x)); +} static void *_p_ofTextureTo_p_ofBaseDraws(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((ofBaseDraws *) ((ofTexture *) x)); } static void *_p_ofFboTo_p_ofBaseDraws(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((ofBaseDraws *) ((ofFbo *) x)); } +static void *_p_ofVideoPlayerTo_p_ofBaseDraws(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((ofBaseDraws *) (ofBaseVideoDraws *) ((ofVideoPlayer *) x)); +} +static void *_p_ofVboMeshTo_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *) ((ofVboMesh *) x)); +} +static void *_p_ofVideoGrabberTo_p_ofBaseVideoGrabber(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((ofBaseVideoGrabber *) ((ofVideoGrabber *) x)); +} +static void *_p_ofVideoGrabberTo_p_ofBaseVideoDraws(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((ofBaseVideoDraws *) ((ofVideoGrabber *) x)); +} +static void *_p_ofVideoPlayerTo_p_ofBaseVideoDraws(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((ofBaseVideoDraws *) ((ofVideoPlayer *) x)); +} static void *_p_ofLogErrorTo_p_ofLog(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((ofLog *) ((ofLogError *) x)); } @@ -52021,9 +50438,46 @@ static void *_p_ofLogVerboseTo_p_ofLog(void *x, int *SWIGUNUSEDPARM(newmemory)) static void *_p_ofLogWarningTo_p_ofLog(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((ofLog *) ((ofLogWarning *) x)); } +static void *_p_ofBaseVideoDrawsTo_p_ofBaseHasPixels(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((ofBaseHasPixels *) (ofBaseVideo *) ((ofBaseVideoDraws *) x)); +} +static void *_p_ofBaseVideoGrabberTo_p_ofBaseHasPixels(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((ofBaseHasPixels *) (ofBaseVideo *) ((ofBaseVideoGrabber *) x)); +} +static void *_p_ofVideoGrabberTo_p_ofBaseHasPixels(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((ofBaseHasPixels *) (ofBaseVideo *)(ofBaseVideoGrabber *) ((ofVideoGrabber *) x)); +} +static void *_p_ofBaseVideoTo_p_ofBaseHasPixels(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((ofBaseHasPixels *) ((ofBaseVideo *) x)); +} +static void *_p_ofBaseVideoPlayerTo_p_ofBaseHasPixels(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((ofBaseHasPixels *) (ofBaseVideo *) ((ofBaseVideoPlayer *) x)); +} +static void *_p_ofVideoPlayerTo_p_ofBaseHasPixels(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((ofBaseHasPixels *) (ofBaseVideo *)(ofBaseVideoPlayer *) ((ofVideoPlayer *) x)); +} static void *_p_ofImage_T_unsigned_short_tTo_p_ofBaseImage_T_unsigned_short_t(void *x, int *SWIGUNUSEDPARM(newmemory)) { return (void *)((ofBaseImage_< unsigned short > *) ((ofImage_< unsigned short > *) x)); } +static void *_p_ofBaseVideoDrawsTo_p_ofBaseUpdates(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((ofBaseUpdates *) (ofBaseVideo *) ((ofBaseVideoDraws *) x)); +} +static void *_p_ofBaseVideoGrabberTo_p_ofBaseUpdates(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((ofBaseUpdates *) (ofBaseVideo *) ((ofBaseVideoGrabber *) x)); +} +static void *_p_ofVideoGrabberTo_p_ofBaseUpdates(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((ofBaseUpdates *) (ofBaseVideo *)(ofBaseVideoGrabber *) ((ofVideoGrabber *) x)); +} +static void *_p_ofBaseVideoTo_p_ofBaseUpdates(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((ofBaseUpdates *) ((ofBaseVideo *) x)); +} +static void *_p_ofBaseVideoPlayerTo_p_ofBaseUpdates(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((ofBaseUpdates *) (ofBaseVideo *) ((ofBaseVideoPlayer *) x)); +} +static void *_p_ofVideoPlayerTo_p_ofBaseUpdates(void *x, int *SWIGUNUSEDPARM(newmemory)) { + return (void *)((ofBaseUpdates *) (ofBaseVideo *)(ofBaseVideoPlayer *) ((ofVideoPlayer *) x)); +} +static swig_type_info _swigt__p_Base = {"_p_Base", "Base *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_Firmata_Encoder_Data = {"_p_Firmata_Encoder_Data", "Firmata_Encoder_Data *", 0, 0, (void*)&_wrap_class_Firmata_Encoder_Data, 0}; static swig_type_info _swigt__p_Firmata_I2C_Data = {"_p_Firmata_I2C_Data", "Firmata_I2C_Data *", 0, 0, (void*)&_wrap_class_Firmata_I2C_Data, 0}; static swig_type_info _swigt__p_Firmata_Serial_Data = {"_p_Firmata_Serial_Data", "Firmata_Serial_Data *", 0, 0, (void*)&_wrap_class_Firmata_Serial_Data, 0}; @@ -52031,34 +50485,34 @@ static swig_type_info _swigt__p_Firmata_Stepper_Data = {"_p_Firmata_Stepper_Data static swig_type_info _swigt__p_GLintptr = {"_p_GLintptr", "GLintptr *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_GLsizei = {"_p_GLsizei", "GLsizei *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_GLsizeiptr = {"_p_GLsizeiptr", "GLsizeiptr *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_Node = {"_p_Node", "Node *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p__XDisplay = {"_p__XDisplay", "_XDisplay *|Display *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_boost__filesystem__path = {"_p_boost__filesystem__path", "boost::filesystem::path *|std::filesystem::path *", 0, 0, (void*)&_wrap_class_path, 0}; +static swig_type_info _swigt__p_difference_type = {"_p_difference_type", "difference_type *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_double = {"_p_double", "double *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_float = {"_p_float", "float *|GLfloat *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_glm__mat3 = {"_p_glm__mat3", "glm::mat3 *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_glm__mat4 = {"_p_glm__mat4", "glm::mat4 *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_glm__quat = {"_p_glm__quat", "glm::quat *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_glm__tvec2T_int_glm__precision__defaultp_t = {"_p_glm__tvec2T_int_glm__precision__defaultp_t", "glm::tvec2< int,glm::precision::defaultp > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_glm__tvec3T_int_glm__precision__defaultp_t = {"_p_glm__tvec3T_int_glm__precision__defaultp_t", "glm::tvec3< int,glm::precision::defaultp > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_glm__tvec4T_int_glm__precision__defaultp_t = {"_p_glm__tvec4T_int_glm__precision__defaultp_t", "glm::tvec4< int,glm::precision::defaultp > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_glm__vec2 = {"_p_glm__vec2", "ofDefaultTexCoordType *|ofDefaultVec2 *|glm::vec2 *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_glm__vec2 = {"_p_glm__vec2", "ofDefaultTexCoordType *|glm::vec2 *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_ofMouseEventArgs = {"_p_ofMouseEventArgs", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_glm__vec3 = {"_p_glm__vec3", "ofDefaultNormalType *|ofDefaultVertexType *|ofDefaultVec3 *|glm::vec3 *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_glm__vec4 = {"_p_glm__vec4", "ofDefaultVec4 *|glm::vec4 *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_int = {"_p_int", "int *|GLint *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_ofWindowPosEventArgs = {"_p_ofWindowPosEventArgs", 0, 0, 0, 0, 0}; +static swig_type_info _swigt__p_glm__vec3 = {"_p_glm__vec3", "ofDefaultNormalType *|ofDefaultVertexType *|glm::vec3 *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_glm__vec4 = {"_p_glm__vec4", "glm::vec4 *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_glm__vecT_2_int_glm__precision__defaultp_t = {"_p_glm__vecT_2_int_glm__precision__defaultp_t", "glm::vec< 2,int,glm::precision::defaultp > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_glm__vecT_3_int_glm__precision__defaultp_t = {"_p_glm__vecT_3_int_glm__precision__defaultp_t", "glm::vec< 3,int,glm::precision::defaultp > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_glm__vecT_4_int_glm__precision__defaultp_t = {"_p_glm__vecT_4_int_glm__precision__defaultp_t", "glm::vec< 4,int,glm::precision::defaultp > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_int = {"_p_int", "int *|glm::length_t *|GLint *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_int16_t = {"_p_int16_t", "int16_t *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_int32_t = {"_p_int32_t", "int32_t *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_int8_t = {"_p_int8_t", "int8_t *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_long_long = {"_p_long_long", "int64_t *|long long *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_of3dPrimitive = {"_p_of3dPrimitive", "of3dPrimitive *", 0, 0, (void*)&_wrap_class_3dPrimitive, 0}; static swig_type_info _swigt__p_ofAbstractParameter = {"_p_ofAbstractParameter", "ofAbstractParameter *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofAlphabet = {"_p_ofAlphabet", "ofAlphabet *", 0, 0, (void*)&_wrap_class_Alphabet, 0}; static swig_type_info _swigt__p_ofAppBaseWindow = {"_p_ofAppBaseWindow", "ofAppBaseWindow *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_ofArduino = {"_p_ofArduino", "ofArduino *|ofStandardFirmata *", 0, 0, (void*)&_wrap_class_Arduino, 0}; -static swig_type_info _swigt__p_ofArrayViewT_unsigned_int_t = {"_p_ofArrayViewT_unsigned_int_t", "ofArrayView< unsigned int > *|ofArrayView< ofIndexType > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofArrayViewT_void_t = {"_p_ofArrayViewT_void_t", "ofArrayView< void > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofBaseApp = {"_p_ofBaseApp", "ofBaseApp *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_ofBaseDraws = {"_p_ofBaseDraws", "ofBaseDraws *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_ofBaseHasPixels = {"_p_ofBaseHasPixels", "ofBaseHasPixels *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_ofBaseHasTexture = {"_p_ofBaseHasTexture", "ofBaseHasTexture *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_ofBaseImage_T_float_t = {"_p_ofBaseImage_T_float_t", "ofBaseImage_< float > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_ofBaseImage_T_unsigned_char_t = {"_p_ofBaseImage_T_unsigned_char_t", "ofBaseImage_< unsigned char > *", 0, 0, (void*)0, 0}; @@ -52070,7 +50524,13 @@ static swig_type_info _swigt__p_ofBaseMaterial = {"_p_ofBaseMaterial", "ofBaseMa static swig_type_info _swigt__p_ofBaseRenderer = {"_p_ofBaseRenderer", "ofBaseRenderer *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_ofBaseSoundInput = {"_p_ofBaseSoundInput", "ofBaseSoundInput *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_ofBaseSoundOutput = {"_p_ofBaseSoundOutput", "ofBaseSoundOutput *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofBaseSoundPlayer = {"_p_ofBaseSoundPlayer", "ofBaseSoundPlayer *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_ofBaseSoundPlayer = {"_p_ofBaseSoundPlayer", "ofBaseSoundPlayer *", 0, 0, (void*)&_wrap_class_BaseSoundPlayer, 0}; +static swig_type_info _swigt__p_ofBaseSoundStream = {"_p_ofBaseSoundStream", "ofBaseSoundStream *", 0, 0, (void*)&_wrap_class_BaseSoundStream, 0}; +static swig_type_info _swigt__p_ofBaseUpdates = {"_p_ofBaseUpdates", "ofBaseUpdates *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_ofBaseVideo = {"_p_ofBaseVideo", "ofBaseVideo *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_ofBaseVideoDraws = {"_p_ofBaseVideoDraws", "ofBaseVideoDraws *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_ofBaseVideoGrabber = {"_p_ofBaseVideoGrabber", "ofBaseVideoGrabber *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_ofBaseVideoPlayer = {"_p_ofBaseVideoPlayer", "ofBaseVideoPlayer *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_ofBoxPrimitive = {"_p_ofBoxPrimitive", "ofBoxPrimitive *", 0, 0, (void*)&_wrap_class_BoxPrimitive, 0}; static swig_type_info _swigt__p_ofBuffer = {"_p_ofBuffer", "ofBuffer *", 0, 0, (void*)&_wrap_class_Buffer, 0}; static swig_type_info _swigt__p_ofBufferObject = {"_p_ofBufferObject", "ofBufferObject *", 0, 0, (void*)&_wrap_class_BufferObject, 0}; @@ -52081,7 +50541,6 @@ static swig_type_info _swigt__p_ofColor_T_unsigned_short_t = {"_p_ofColor_T_unsi static swig_type_info _swigt__p_ofConePrimitive = {"_p_ofConePrimitive", "ofConePrimitive *", 0, 0, (void*)&_wrap_class_ConePrimitive, 0}; static swig_type_info _swigt__p_ofCoreEvents = {"_p_ofCoreEvents", "ofCoreEvents *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_ofCylinderPrimitive = {"_p_ofCylinderPrimitive", "ofCylinderPrimitive *", 0, 0, (void*)&_wrap_class_CylinderPrimitive, 0}; -static swig_type_info _swigt__p_ofDebugViewLoggerChannel = {"_p_ofDebugViewLoggerChannel", "ofDebugViewLoggerChannel *", 0, 0, (void*)&_wrap_class_DebugViewLoggerChannel, 0}; static swig_type_info _swigt__p_ofDirectory = {"_p_ofDirectory", "ofDirectory *", 0, 0, (void*)&_wrap_class_Directory, 0}; static swig_type_info _swigt__p_ofDragInfo = {"_p_ofDragInfo", "ofDragInfo *", 0, 0, (void*)&_wrap_class_DragInfo, 0}; static swig_type_info _swigt__p_ofEasyCam = {"_p_ofEasyCam", "ofEasyCam *", 0, 0, (void*)&_wrap_class_EasyCam, 0}; @@ -52093,13 +50552,11 @@ static swig_type_info _swigt__p_ofEventT_Firmata_I2C_Data_const_t = {"_p_ofEvent static swig_type_info _swigt__p_ofEventT_Firmata_Serial_Data_const_t = {"_p_ofEventT_Firmata_Serial_Data_const_t", "ofEvent< Firmata_Serial_Data const > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_ofEventT_Firmata_Stepper_Data_const_t = {"_p_ofEventT_Firmata_Stepper_Data_const_t", "ofEvent< Firmata_Stepper_Data const > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_ofEventT_int_const_t = {"_p_ofEventT_int_const_t", "ofEvent< int const > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofEventT_ofHttpResponse_t = {"_p_ofEventT_ofHttpResponse_t", "ofEvent< ofHttpResponse > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_ofEventT_std__pairT_int_Firmata_Pin_Modes_t_const_t = {"_p_ofEventT_std__pairT_int_Firmata_Pin_Modes_t_const_t", "ofEvent< std::pair< int,enum Firmata_Pin_Modes > const > *|ofEvent< std::pair< int,Firmata_Pin_Modes > const > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_ofEventT_std__string_const_t = {"_p_ofEventT_std__string_const_t", "ofEvent< std::string const > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_ofEventT_std__vectorT_Firmata_Encoder_Data_t_const_t = {"_p_ofEventT_std__vectorT_Firmata_Encoder_Data_t_const_t", "ofEvent< std::vector< Firmata_Encoder_Data > const > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_ofEventT_std__vectorT_unsigned_char_t_const_t = {"_p_ofEventT_std__vectorT_unsigned_char_t_const_t", "ofEvent< std::vector< unsigned char > const > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_ofFbo = {"_p_ofFbo", "ofFbo *", 0, 0, (void*)&_wrap_class_Fbo, 0}; -static swig_type_info _swigt__p_ofFbo__Settings = {"_p_ofFbo__Settings", "ofFbo::Settings *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_ofFile = {"_p_ofFile", "ofFile *", 0, 0, (void*)&_wrap_class_File, 0}; static swig_type_info _swigt__p_ofFileDialogResult = {"_p_ofFileDialogResult", "ofFileDialogResult *", 0, 0, (void*)&_wrap_class_FileDialogResult, 0}; static swig_type_info _swigt__p_ofFilePath = {"_p_ofFilePath", "ofFilePath *", 0, 0, (void*)&_wrap_class_FilePath, 0}; @@ -52118,15 +50575,13 @@ static swig_type_info _swigt__p_ofLogNotice = {"_p_ofLogNotice", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_ofLogFatalError = {"_p_ofLogFatalError", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_ofLogVerbose = {"_p_ofLogVerbose", 0, 0, 0, 0, 0}; static swig_type_info _swigt__p_ofLogWarning = {"_p_ofLogWarning", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_ofLoopType = {"_p_ofLoopType", "ofLoopType *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_ofMaterial = {"_p_ofMaterial", "ofMaterial *", 0, 0, (void*)&_wrap_class_Material, 0}; -static swig_type_info _swigt__p_ofMaterial__Settings = {"_p_ofMaterial__Settings", "ofMaterial::Settings *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_ofMaterialSettings = {"_p_ofMaterialSettings", "ofMaterialSettings *", 0, 0, (void*)&_wrap_class_MaterialSettings, 0}; static swig_type_info _swigt__p_ofMatrix3x3 = {"_p_ofMatrix3x3", "ofMatrix3x3 *", 0, 0, (void*)&_wrap_class_Matrix3x3, 0}; static swig_type_info _swigt__p_ofMatrix4x4 = {"_p_ofMatrix4x4", "ofMatrix4x4 *", 0, 0, (void*)&_wrap_class_Matrix4x4, 0}; static swig_type_info _swigt__p_ofMatrixStack = {"_p_ofMatrixStack", "ofMatrixStack *", 0, 0, (void*)&_wrap_class_MatrixStack, 0}; -static swig_type_info _swigt__p_ofMeshData = {"_p_ofMeshData", "ofMeshData *", 0, 0, (void*)&_wrap_class_MeshData, 0}; -static swig_type_info _swigt__p_ofMeshFace_T_glm__vec3_glm__vec3_ofColor_T_float_t_glm__vec2_t = {"_p_ofMeshFace_T_glm__vec3_glm__vec3_ofColor_T_float_t_glm__vec2_t", "ofMeshFace_< glm::vec3,glm::vec3,ofColor_< float >,glm::vec2 > *|ofMeshFace *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofMesh_T_glm__vec3_glm__vec3_ofColor_T_float_t_glm__vec2_t = {"_p_ofMesh_T_glm__vec3_glm__vec3_ofColor_T_float_t_glm__vec2_t", "ofMesh_< glm::vec3,glm::vec3,ofColor_< float >,glm::vec2 > *|ofMesh *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_ofMeshFace_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t = {"_p_ofMeshFace_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t", "ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *|ofMeshFace *", 0, 0, (void*)&_wrap_class_MeshFace, 0}; +static swig_type_info _swigt__p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t = {"_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t", "ofMesh_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > *|ofMesh *", 0, 0, (void*)&_wrap_class_Mesh, 0}; static swig_type_info _swigt__p_ofNode = {"_p_ofNode", "ofNode *", 0, 0, (void*)&_wrap_class_Node, 0}; static swig_type_info _swigt__p_ofParameterGroup = {"_p_ofParameterGroup", "ofParameterGroup *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_ofPath = {"_p_ofPath", "ofPath *", 0, 0, (void*)&_wrap_class_Path, 0}; @@ -52134,30 +50589,26 @@ static swig_type_info _swigt__p_ofPixels_T_float_t = {"_p_ofPixels_T_float_t", " static swig_type_info _swigt__p_ofPixels_T_unsigned_char_t = {"_p_ofPixels_T_unsigned_char_t", "ofPixels_< unsigned char > *|ofPixels *", 0, 0, (void*)&_wrap_class_Pixels, 0}; static swig_type_info _swigt__p_ofPixels_T_unsigned_short_t = {"_p_ofPixels_T_unsigned_short_t", "ofPixels_< unsigned short > *|ofShortPixels *", 0, 0, (void*)&_wrap_class_ShortPixels, 0}; static swig_type_info _swigt__p_ofPlanePrimitive = {"_p_ofPlanePrimitive", "ofPlanePrimitive *", 0, 0, (void*)&_wrap_class_PlanePrimitive, 0}; -static swig_type_info _swigt__p_ofPolyline_T_ofDefaultVertexType_t = {"_p_ofPolyline_T_ofDefaultVertexType_t", "ofPolyline *|ofPolyline_< ofDefaultVertexType > *", 0, 0, (void*)&_wrap_class_Polyline, 0}; +static swig_type_info _swigt__p_ofPolyline_T_glm__vec3_t = {"_p_ofPolyline_T_glm__vec3_t", "ofPolyline *|ofPolyline_< glm::vec3 > *|ofPolyline_< ofDefaultVertexType > *", 0, 0, (void*)&_wrap_class_Polyline, 0}; static swig_type_info _swigt__p_ofQuaternion = {"_p_ofQuaternion", "ofQuaternion *", 0, 0, (void*)&_wrap_class_Quaternion, 0}; static swig_type_info _swigt__p_ofRectangle = {"_p_ofRectangle", "ofRectangle *", 0, 0, (void*)&_wrap_class_Rectangle, 0}; static swig_type_info _swigt__p_ofSerial = {"_p_ofSerial", "ofSerial *", 0, 0, (void*)&_wrap_class_Serial, 0}; static swig_type_info _swigt__p_ofSerialDeviceInfo = {"_p_ofSerialDeviceInfo", "ofSerialDeviceInfo *", 0, 0, (void*)&_wrap_class_SerialDeviceInfo, 0}; static swig_type_info _swigt__p_ofShader = {"_p_ofShader", "ofShader *", 0, 0, (void*)&_wrap_class_Shader, 0}; -static swig_type_info _swigt__p_ofShader__Settings = {"_p_ofShader__Settings", "ofShader::Settings *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofShader__TransformFeedbackBaseBinding = {"_p_ofShader__TransformFeedbackBaseBinding", "ofShader::TransformFeedbackBaseBinding *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofShader__TransformFeedbackRangeBinding = {"_p_ofShader__TransformFeedbackRangeBinding", "ofShader::TransformFeedbackRangeBinding *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_ofShaderSettings = {"_p_ofShaderSettings", "ofShaderSettings *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_ofShader__TransformFeedbackSettings = {"_p_ofShader__TransformFeedbackSettings", "ofShader::TransformFeedbackSettings *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofSoundDevice = {"_p_ofSoundDevice", "ofSoundDevice *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofSoundDevice__Api = {"_p_ofSoundDevice__Api", "ofSoundDevice::Api *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_ofSoundDevice = {"_p_ofSoundDevice", "ofSoundDevice *", 0, 0, (void*)&_wrap_class_SoundDevice, 0}; static swig_type_info _swigt__p_ofSoundPlayer = {"_p_ofSoundPlayer", "ofSoundPlayer *", 0, 0, (void*)&_wrap_class_SoundPlayer, 0}; static swig_type_info _swigt__p_ofSoundStream = {"_p_ofSoundStream", "ofSoundStream *", 0, 0, (void*)&_wrap_class_SoundStream, 0}; -static swig_type_info _swigt__p_ofSoundStreamSettings = {"_p_ofSoundStreamSettings", "ofSoundStreamSettings *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_ofSoundStreamSettings = {"_p_ofSoundStreamSettings", "ofSoundStreamSettings *", 0, 0, (void*)&_wrap_class_SoundStreamSettings, 0}; static swig_type_info _swigt__p_ofSpherePrimitive = {"_p_ofSpherePrimitive", "ofSpherePrimitive *", 0, 0, (void*)&_wrap_class_SpherePrimitive, 0}; -static swig_type_info _swigt__p_ofStyle = {"_p_ofStyle", "ofStyle *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_ofStyle = {"_p_ofStyle", "ofStyle *", 0, 0, (void*)&_wrap_class_Style, 0}; static swig_type_info _swigt__p_ofTexture = {"_p_ofTexture", "ofTexture *", 0, 0, (void*)&_wrap_class_Texture, 0}; static swig_type_info _swigt__p_ofTextureData = {"_p_ofTextureData", "ofTextureData *", 0, 0, (void*)&_wrap_class_TextureData, 0}; static swig_type_info _swigt__p_ofTime = {"_p_ofTime", "ofTime *", 0, 0, (void*)&_wrap_class_Time, 0}; static swig_type_info _swigt__p_ofTouchEventArgs = {"_p_ofTouchEventArgs", "ofTouchEventArgs *", 0, 0, (void*)&_wrap_class_TouchEventArgs, 0}; static swig_type_info _swigt__p_ofTrueTypeFont = {"_p_ofTrueTypeFont", "ofTrueTypeFont *", 0, 0, (void*)&_wrap_class_TrueTypeFont, 0}; -static swig_type_info _swigt__p_ofTrueTypeFont__Settings = {"_p_ofTrueTypeFont__Settings", "ofTrueTypeFont::Settings *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofTrueTypeFont__Settings__Direction = {"_p_ofTrueTypeFont__Settings__Direction", "ofTrueTypeFont::Settings::Direction *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_ofTrueTypeFontSettings = {"_p_ofTrueTypeFontSettings", "ofTrueTypeFontSettings *", 0, 0, (void*)&_wrap_class_TrueTypeFontSettings, 0}; static swig_type_info _swigt__p_ofURLFileLoader = {"_p_ofURLFileLoader", "ofURLFileLoader *", 0, 0, (void*)&_wrap_class_URLFileLoader, 0}; static swig_type_info _swigt__p_ofUnicode = {"_p_ofUnicode", "ofUnicode *", 0, 0, (void*)&_wrap_class_Unicode, 0}; static swig_type_info _swigt__p_ofUnicode__range = {"_p_ofUnicode__range", "ofUnicode::range *", 0, 0, (void*)0, 0}; @@ -52166,26 +50617,25 @@ static swig_type_info _swigt__p_ofVboMesh = {"_p_ofVboMesh", "ofVboMesh *", 0, 0 static swig_type_info _swigt__p_ofVec2f = {"_p_ofVec2f", "ofVec2f *", 0, 0, (void*)&_wrap_class_Vec2f, 0}; static swig_type_info _swigt__p_ofVec3f = {"_p_ofVec3f", "ofPoint *|ofVec3f *", 0, 0, (void*)&_wrap_class_Vec3f, 0}; static swig_type_info _swigt__p_ofVec4f = {"_p_ofVec4f", "ofVec4f *", 0, 0, (void*)&_wrap_class_Vec4f, 0}; -static swig_type_info _swigt__p_ofVideoDevice = {"_p_ofVideoDevice", "ofVideoDevice *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_ofVideoDevice = {"_p_ofVideoDevice", "ofVideoDevice *", 0, 0, (void*)&_wrap_class_VideoDevice, 0}; +static swig_type_info _swigt__p_ofVideoFormat = {"_p_ofVideoFormat", "ofVideoFormat *", 0, 0, (void*)&_wrap_class_VideoFormat, 0}; static swig_type_info _swigt__p_ofVideoGrabber = {"_p_ofVideoGrabber", "ofVideoGrabber *", 0, 0, (void*)&_wrap_class_VideoGrabber, 0}; static swig_type_info _swigt__p_ofVideoPlayer = {"_p_ofVideoPlayer", "ofVideoPlayer *", 0, 0, (void*)&_wrap_class_VideoPlayer, 0}; -static swig_type_info _swigt__p_ofWindowPosEventArgs = {"_p_ofWindowPosEventArgs", "ofWindowPosEventArgs *", 0, 0, (void*)&_wrap_class_WindowPosEventArgs, 0}; static swig_type_info _swigt__p_ofXml = {"_p_ofXml", "ofXml *", 0, 0, (void*)&_wrap_class_Xml, 0}; -static swig_type_info _swigt__p_ofXmlSearchIterator = {"_p_ofXmlSearchIterator", "ofXmlSearchIterator *", 0, 0, (void*)&_wrap_class_XmlSearchIterator, 0}; +static swig_type_info _swigt__p_ofXmlAttributeIterator = {"_p_ofXmlAttributeIterator", "ofXmlAttributeIterator *", 0, 0, (void*)&_wrap_class_XmlAttributeIterator, 0}; static swig_type_info _swigt__p_ofXml__Attribute = {"_p_ofXml__Attribute", "ofXml::Attribute *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofXml__RangeT_ofXmlIteratorT_pugi__xml_attribute_iterator_t_t = {"_p_ofXml__RangeT_ofXmlIteratorT_pugi__xml_attribute_iterator_t_t", "ofXml::Range< ofXmlIterator< pugi::xml_attribute_iterator > > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_ofXml__RangeT_ofXmlAttributeIterator_t = {"_p_ofXml__RangeT_ofXmlAttributeIterator_t", "ofXml::Range< ofXmlAttributeIterator > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_ofXml__RangeT_ofXmlIteratorT_pugi__xml_named_node_iterator_t_t = {"_p_ofXml__RangeT_ofXmlIteratorT_pugi__xml_named_node_iterator_t_t", "ofXml::Range< ofXmlIterator< pugi::xml_named_node_iterator > > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_ofXml__RangeT_ofXmlIteratorT_pugi__xml_node_iterator_t_t = {"_p_ofXml__RangeT_ofXmlIteratorT_pugi__xml_node_iterator_t_t", "ofXml::Range< ofXmlIterator< pugi::xml_node_iterator > > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofXml__Search = {"_p_ofXml__Search", "ofXml::Search *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_size_type = {"_p_size_type", "size_type *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_std__chrono__nanoseconds = {"_p_std__chrono__nanoseconds", "std::chrono::nanoseconds *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_std__chrono__time_pointT_std__chrono__nanoseconds_t = {"_p_std__chrono__time_pointT_std__chrono__nanoseconds_t", "std::chrono::time_point< std::chrono::nanoseconds > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_std__fstream = {"_p_std__fstream", "std::fstream *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_std__functionT_void_fofHttpResponse_const_RF_t = {"_p_std__functionT_void_fofHttpResponse_const_RF_t", "std::function< void (ofHttpResponse const &) > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_std__initializer_listT_ofUnicode__range_t = {"_p_std__initializer_listT_ofUnicode__range_t", "std::initializer_list< ofUnicode::range > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_std__functionT_void_fofSoundBuffer_RF_t = {"_p_std__functionT_void_fofSoundBuffer_RF_t", "std::function< void (ofSoundBuffer &) > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_std__istream = {"_p_std__istream", "std::istream *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_std__mapT_int_supportedPinTypes_t = {"_p_std__mapT_int_supportedPinTypes_t", "std::map< int,supportedPinTypes > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_std__mapT_std__string_std__string_t = {"_p_std__mapT_std__string_std__string_t", "std::map< std::string,std::string > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_std__ostream = {"_p_std__ostream", "std::ostream *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_std__shared_ptrT_ofAppBaseWindow_t = {"_p_std__shared_ptrT_ofAppBaseWindow_t", "std::shared_ptr< ofAppBaseWindow > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_std__mapT_int_supportedPinTypes_std__lessT_int_t_t = {"_p_std__mapT_int_supportedPinTypes_std__lessT_int_t_t", "std::map< int,supportedPinTypes,std::less< int > > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_std__mapT_std__string_std__string_std__lessT_std__string_t_t = {"_p_std__mapT_std__string_std__string_std__lessT_std__string_t_t", "std::map< std::string,std::string,std::less< std::string > > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_std__shared_ptrT_ofBaseLoggerChannel_t = {"_p_std__shared_ptrT_ofBaseLoggerChannel_t", "std::shared_ptr< ofBaseLoggerChannel > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_std__shared_ptrT_ofBaseRenderer_t = {"_p_std__shared_ptrT_ofBaseRenderer_t", "std::shared_ptr< ofBaseRenderer > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_std__shared_ptrT_ofBaseSoundPlayer_t = {"_p_std__shared_ptrT_ofBaseSoundPlayer_t", "std::shared_ptr< ofBaseSoundPlayer > *", 0, 0, (void*)0, 0}; @@ -52193,33 +50643,29 @@ static swig_type_info _swigt__p_std__shared_ptrT_ofBaseSoundStream_t = {"_p_std_ static swig_type_info _swigt__p_std__shared_ptrT_ofBaseVideoGrabber_t = {"_p_std__shared_ptrT_ofBaseVideoGrabber_t", "std::shared_ptr< ofBaseVideoGrabber > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_std__shared_ptrT_ofBaseVideoPlayer_t = {"_p_std__shared_ptrT_ofBaseVideoPlayer_t", "std::shared_ptr< ofBaseVideoPlayer > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_std__string = {"_p_std__string", "std::string *", 0, 0, (void*)&_wrap_class_string, 0}; -static swig_type_info _swigt__p_std__vectorT_char_t = {"_p_std__vectorT_char_t", "std::vector< char > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_std__vectorT_float_t = {"_p_std__vectorT_float_t", "std::vector< float > *", 0, 0, (void*)&_wrap_class_FloatVector, 0}; -static swig_type_info _swigt__p_std__vectorT_glm__vec2_t = {"_p_std__vectorT_glm__vec2_t", "std::vector< glm::vec2 > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_std__vectorT_glm__vec3_t = {"_p_std__vectorT_glm__vec3_t", "std::vector< glm::vec3 > *|std::vector< ofDefaultVertexType > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_std__vectorT_glm__vec3_t__const_iterator = {"_p_std__vectorT_glm__vec3_t__const_iterator", "std::vector< glm::vec3 >::const_iterator *|std::vector< ofDefaultVertexType >::const_iterator *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_std__vectorT_glm__vec3_t__const_reverse_iterator = {"_p_std__vectorT_glm__vec3_t__const_reverse_iterator", "std::vector< glm::vec3 >::const_reverse_iterator *|std::vector< ofDefaultVertexType >::const_reverse_iterator *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_std__vectorT_glm__vec3_t__iterator = {"_p_std__vectorT_glm__vec3_t__iterator", "std::vector< glm::vec3 >::iterator *|std::vector< ofDefaultVertexType >::iterator *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_std__vectorT_glm__vec3_t__reverse_iterator = {"_p_std__vectorT_glm__vec3_t__reverse_iterator", "std::vector< glm::vec3 >::reverse_iterator *|std::vector< ofDefaultVertexType >::reverse_iterator *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_std__vectorT_glm__vec2_t = {"_p_std__vectorT_glm__vec2_t", "std::vector< glm::vec2 > *|std::vector< ofDefaultTexCoordType > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_std__vectorT_glm__vec3_t = {"_p_std__vectorT_glm__vec3_t", "std::vector< glm::vec3 > *|std::vector< ofDefaultVertexType > *|std::vector< ofDefaultNormalType > *", 0, 0, (void*)&_wrap_class_VertexVector, 0}; static swig_type_info _swigt__p_std__vectorT_int_t = {"_p_std__vectorT_int_t", "std::vector< int > *", 0, 0, (void*)&_wrap_class_IntVector, 0}; +static swig_type_info _swigt__p_std__vectorT_ofColor_T_float_t_t = {"_p_std__vectorT_ofColor_T_float_t_t", "std::vector< ofColor_< float > > *|std::vector< ofDefaultColorType > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_std__vectorT_ofFile_t = {"_p_std__vectorT_ofFile_t", "std::vector< ofFile > *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_std__vectorT_ofMeshFace_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t_t = {"_p_std__vectorT_ofMeshFace_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t_t", "std::vector< ofMeshFace_< ofDefaultVertexType,ofDefaultNormalType,ofDefaultColorType,ofDefaultTexCoordType > > *", 0, 0, (void*)&_wrap_class_MeshFaceVector, 0}; static swig_type_info _swigt__p_std__vectorT_ofPath__Command_t = {"_p_std__vectorT_ofPath__Command_t", "std::vector< ofPath::Command > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_std__vectorT_ofPath_t = {"_p_std__vectorT_ofPath_t", "std::vector< ofPath > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_std__vectorT_ofPolyline_t = {"_p_std__vectorT_ofPolyline_t", "std::vector< ofPolyline > *", 0, 0, (void*)&_wrap_class_PolylineVector, 0}; +static swig_type_info _swigt__p_std__vectorT_ofPolyline_T_ofDefaultVertexType_t_t = {"_p_std__vectorT_ofPolyline_T_ofDefaultVertexType_t_t", "std::vector< ofPolyline_< glm::vec3 > > *|std::vector< ofPolyline > *|std::vector< ofPolyline_< ofDefaultVertexType > > *", 0, 0, (void*)&_wrap_class_PolylineVector, 0}; static swig_type_info _swigt__p_std__vectorT_ofSerialDeviceInfo_t = {"_p_std__vectorT_ofSerialDeviceInfo_t", "std::vector< ofSerialDeviceInfo > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_std__vectorT_ofShader__TransformFeedbackBaseBinding_t = {"_p_std__vectorT_ofShader__TransformFeedbackBaseBinding_t", "std::vector< ofShader::TransformFeedbackBaseBinding > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_std__vectorT_ofShader__TransformFeedbackRangeBinding_t = {"_p_std__vectorT_ofShader__TransformFeedbackRangeBinding_t", "std::vector< ofShader::TransformFeedbackRangeBinding > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_std__vectorT_ofSoundDevice_t = {"_p_std__vectorT_ofSoundDevice_t", "std::vector< ofSoundDevice > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_std__vectorT_ofTexture_t = {"_p_std__vectorT_ofTexture_t", "std::vector< ofTexture > *", 0, 0, (void*)&_wrap_class_TextureVector, 0}; +static swig_type_info _swigt__p_std__vectorT_ofUnicode__range_t = {"_p_std__vectorT_ofUnicode__range_t", "std::vector< ofUnicode::range > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_std__vectorT_ofVec2f_t = {"_p_std__vectorT_ofVec2f_t", "std::vector< ofVec2f > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_std__vectorT_ofVec3f_t = {"_p_std__vectorT_ofVec3f_t", "std::vector< ofVec3f > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_std__vectorT_ofVideoDevice_t = {"_p_std__vectorT_ofVideoDevice_t", "std::vector< ofVideoDevice > *", 0, 0, (void*)&_wrap_class_VideoDeviceVector, 0}; +static swig_type_info _swigt__p_std__vectorT_ofVideoFormat_t = {"_p_std__vectorT_ofVideoFormat_t", "std::vector< ofVideoFormat > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_std__vectorT_std__string_t = {"_p_std__vectorT_std__string_t", "std::vector< std::string > *", 0, 0, (void*)&_wrap_class_StringVector, 0}; -static swig_type_info _swigt__p_std__vectorT_std__weak_ptrT_ofLight__Data_t_t = {"_p_std__vectorT_std__weak_ptrT_ofLight__Data_t_t", "std::vector< std::weak_ptr< ofLight::Data > > *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_std__vectorT_unsigned_char_t = {"_p_std__vectorT_unsigned_char_t", "std::vector< unsigned char > *", 0, 0, (void*)&_wrap_class_UCharVector, 0}; static swig_type_info _swigt__p_std__vectorT_unsigned_int_t = {"_p_std__vectorT_unsigned_int_t", "std::vector< unsigned int > *|std::vector< ofIndexType > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_string = {"_p_string", "string *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_supportedPinTypes = {"_p_supportedPinTypes", "supportedPinTypes *", 0, 0, (void*)&_wrap_class_supportedPinTypes, 0}; +static swig_type_info _swigt__p_timespec = {"_p_timespec", "timespec *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_uint16_t = {"_p_uint16_t", "uint16_t *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_uint32_t = {"_p_uint32_t", "uint32_t *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_uint8_t = {"_p_uint8_t", "uint8_t *", 0, 0, (void*)0, 0}; @@ -52228,10 +50674,11 @@ static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "ofIndexType static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "Window *|unsigned long *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_unsigned_long_long = {"_p_unsigned_long_long", "uint64_t *|unsigned long long *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_unsigned_short = {"_p_unsigned_short", "unsigned short *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_va_list = {"_p_va_list", "va_list *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_value_type = {"_p_value_type", "value_type *", 0, 0, (void*)0, 0}; static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0}; static swig_type_info *swig_type_initial[] = { + &_swigt__p_Base, &_swigt__p_Firmata_Encoder_Data, &_swigt__p_Firmata_I2C_Data, &_swigt__p_Firmata_Serial_Data, @@ -52239,19 +50686,21 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_GLintptr, &_swigt__p_GLsizei, &_swigt__p_GLsizeiptr, + &_swigt__p_Node, &_swigt__p__XDisplay, &_swigt__p_boost__filesystem__path, + &_swigt__p_difference_type, &_swigt__p_double, &_swigt__p_float, &_swigt__p_glm__mat3, &_swigt__p_glm__mat4, &_swigt__p_glm__quat, - &_swigt__p_glm__tvec2T_int_glm__precision__defaultp_t, - &_swigt__p_glm__tvec3T_int_glm__precision__defaultp_t, - &_swigt__p_glm__tvec4T_int_glm__precision__defaultp_t, &_swigt__p_glm__vec2, &_swigt__p_glm__vec3, &_swigt__p_glm__vec4, + &_swigt__p_glm__vecT_2_int_glm__precision__defaultp_t, + &_swigt__p_glm__vecT_3_int_glm__precision__defaultp_t, + &_swigt__p_glm__vecT_4_int_glm__precision__defaultp_t, &_swigt__p_int, &_swigt__p_int16_t, &_swigt__p_int32_t, @@ -52259,13 +50708,10 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_long_long, &_swigt__p_of3dPrimitive, &_swigt__p_ofAbstractParameter, - &_swigt__p_ofAlphabet, &_swigt__p_ofAppBaseWindow, &_swigt__p_ofArduino, - &_swigt__p_ofArrayViewT_unsigned_int_t, - &_swigt__p_ofArrayViewT_void_t, - &_swigt__p_ofBaseApp, &_swigt__p_ofBaseDraws, + &_swigt__p_ofBaseHasPixels, &_swigt__p_ofBaseHasTexture, &_swigt__p_ofBaseImage_T_float_t, &_swigt__p_ofBaseImage_T_unsigned_char_t, @@ -52276,6 +50722,12 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_ofBaseSoundInput, &_swigt__p_ofBaseSoundOutput, &_swigt__p_ofBaseSoundPlayer, + &_swigt__p_ofBaseSoundStream, + &_swigt__p_ofBaseUpdates, + &_swigt__p_ofBaseVideo, + &_swigt__p_ofBaseVideoDraws, + &_swigt__p_ofBaseVideoGrabber, + &_swigt__p_ofBaseVideoPlayer, &_swigt__p_ofBoxPrimitive, &_swigt__p_ofBuffer, &_swigt__p_ofBufferObject, @@ -52287,7 +50739,6 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_ofConsoleLoggerChannel, &_swigt__p_ofCoreEvents, &_swigt__p_ofCylinderPrimitive, - &_swigt__p_ofDebugViewLoggerChannel, &_swigt__p_ofDirectory, &_swigt__p_ofDragInfo, &_swigt__p_ofEasyCam, @@ -52296,13 +50747,11 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_ofEventT_Firmata_Serial_Data_const_t, &_swigt__p_ofEventT_Firmata_Stepper_Data_const_t, &_swigt__p_ofEventT_int_const_t, - &_swigt__p_ofEventT_ofHttpResponse_t, &_swigt__p_ofEventT_std__pairT_int_Firmata_Pin_Modes_t_const_t, &_swigt__p_ofEventT_std__string_const_t, &_swigt__p_ofEventT_std__vectorT_Firmata_Encoder_Data_t_const_t, &_swigt__p_ofEventT_std__vectorT_unsigned_char_t_const_t, &_swigt__p_ofFbo, - &_swigt__p_ofFbo__Settings, &_swigt__p_ofFile, &_swigt__p_ofFileDialogResult, &_swigt__p_ofFileLoggerChannel, @@ -52323,15 +50772,13 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_ofLogNotice, &_swigt__p_ofLogVerbose, &_swigt__p_ofLogWarning, - &_swigt__p_ofLoopType, &_swigt__p_ofMaterial, - &_swigt__p_ofMaterial__Settings, + &_swigt__p_ofMaterialSettings, &_swigt__p_ofMatrix3x3, &_swigt__p_ofMatrix4x4, &_swigt__p_ofMatrixStack, - &_swigt__p_ofMeshData, - &_swigt__p_ofMeshFace_T_glm__vec3_glm__vec3_ofColor_T_float_t_glm__vec2_t, - &_swigt__p_ofMesh_T_glm__vec3_glm__vec3_ofColor_T_float_t_glm__vec2_t, + &_swigt__p_ofMeshFace_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t, + &_swigt__p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t, &_swigt__p_ofMessage, &_swigt__p_ofMouseEventArgs, &_swigt__p_ofNode, @@ -52341,19 +50788,16 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_ofPixels_T_unsigned_char_t, &_swigt__p_ofPixels_T_unsigned_short_t, &_swigt__p_ofPlanePrimitive, - &_swigt__p_ofPolyline_T_ofDefaultVertexType_t, + &_swigt__p_ofPolyline_T_glm__vec3_t, &_swigt__p_ofQuaternion, &_swigt__p_ofRectangle, &_swigt__p_ofResizeEventArgs, &_swigt__p_ofSerial, &_swigt__p_ofSerialDeviceInfo, &_swigt__p_ofShader, - &_swigt__p_ofShader__Settings, - &_swigt__p_ofShader__TransformFeedbackBaseBinding, - &_swigt__p_ofShader__TransformFeedbackRangeBinding, + &_swigt__p_ofShaderSettings, &_swigt__p_ofShader__TransformFeedbackSettings, &_swigt__p_ofSoundDevice, - &_swigt__p_ofSoundDevice__Api, &_swigt__p_ofSoundPlayer, &_swigt__p_ofSoundStream, &_swigt__p_ofSoundStreamSettings, @@ -52364,8 +50808,7 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_ofTime, &_swigt__p_ofTouchEventArgs, &_swigt__p_ofTrueTypeFont, - &_swigt__p_ofTrueTypeFont__Settings, - &_swigt__p_ofTrueTypeFont__Settings__Direction, + &_swigt__p_ofTrueTypeFontSettings, &_swigt__p_ofURLFileLoader, &_swigt__p_ofUnicode, &_swigt__p_ofUnicode__range, @@ -52375,25 +50818,25 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_ofVec3f, &_swigt__p_ofVec4f, &_swigt__p_ofVideoDevice, + &_swigt__p_ofVideoFormat, &_swigt__p_ofVideoGrabber, &_swigt__p_ofVideoPlayer, &_swigt__p_ofWindowPosEventArgs, &_swigt__p_ofXml, - &_swigt__p_ofXmlSearchIterator, + &_swigt__p_ofXmlAttributeIterator, &_swigt__p_ofXml__Attribute, - &_swigt__p_ofXml__RangeT_ofXmlIteratorT_pugi__xml_attribute_iterator_t_t, + &_swigt__p_ofXml__RangeT_ofXmlAttributeIterator_t, &_swigt__p_ofXml__RangeT_ofXmlIteratorT_pugi__xml_named_node_iterator_t_t, &_swigt__p_ofXml__RangeT_ofXmlIteratorT_pugi__xml_node_iterator_t_t, - &_swigt__p_ofXml__Search, + &_swigt__p_size_type, &_swigt__p_std__chrono__nanoseconds, &_swigt__p_std__chrono__time_pointT_std__chrono__nanoseconds_t, + &_swigt__p_std__fstream, &_swigt__p_std__functionT_void_fofHttpResponse_const_RF_t, - &_swigt__p_std__initializer_listT_ofUnicode__range_t, + &_swigt__p_std__functionT_void_fofSoundBuffer_RF_t, &_swigt__p_std__istream, - &_swigt__p_std__mapT_int_supportedPinTypes_t, - &_swigt__p_std__mapT_std__string_std__string_t, - &_swigt__p_std__ostream, - &_swigt__p_std__shared_ptrT_ofAppBaseWindow_t, + &_swigt__p_std__mapT_int_supportedPinTypes_std__lessT_int_t_t, + &_swigt__p_std__mapT_std__string_std__string_std__lessT_std__string_t_t, &_swigt__p_std__shared_ptrT_ofBaseLoggerChannel_t, &_swigt__p_std__shared_ptrT_ofBaseRenderer_t, &_swigt__p_std__shared_ptrT_ofBaseSoundPlayer_t, @@ -52401,33 +50844,29 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_std__shared_ptrT_ofBaseVideoGrabber_t, &_swigt__p_std__shared_ptrT_ofBaseVideoPlayer_t, &_swigt__p_std__string, - &_swigt__p_std__vectorT_char_t, &_swigt__p_std__vectorT_float_t, &_swigt__p_std__vectorT_glm__vec2_t, &_swigt__p_std__vectorT_glm__vec3_t, - &_swigt__p_std__vectorT_glm__vec3_t__const_iterator, - &_swigt__p_std__vectorT_glm__vec3_t__const_reverse_iterator, - &_swigt__p_std__vectorT_glm__vec3_t__iterator, - &_swigt__p_std__vectorT_glm__vec3_t__reverse_iterator, &_swigt__p_std__vectorT_int_t, + &_swigt__p_std__vectorT_ofColor_T_float_t_t, &_swigt__p_std__vectorT_ofFile_t, + &_swigt__p_std__vectorT_ofMeshFace_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t_t, &_swigt__p_std__vectorT_ofPath__Command_t, &_swigt__p_std__vectorT_ofPath_t, - &_swigt__p_std__vectorT_ofPolyline_t, + &_swigt__p_std__vectorT_ofPolyline_T_ofDefaultVertexType_t_t, &_swigt__p_std__vectorT_ofSerialDeviceInfo_t, - &_swigt__p_std__vectorT_ofShader__TransformFeedbackBaseBinding_t, - &_swigt__p_std__vectorT_ofShader__TransformFeedbackRangeBinding_t, &_swigt__p_std__vectorT_ofSoundDevice_t, &_swigt__p_std__vectorT_ofTexture_t, + &_swigt__p_std__vectorT_ofUnicode__range_t, &_swigt__p_std__vectorT_ofVec2f_t, &_swigt__p_std__vectorT_ofVec3f_t, &_swigt__p_std__vectorT_ofVideoDevice_t, + &_swigt__p_std__vectorT_ofVideoFormat_t, &_swigt__p_std__vectorT_std__string_t, - &_swigt__p_std__vectorT_std__weak_ptrT_ofLight__Data_t_t, &_swigt__p_std__vectorT_unsigned_char_t, &_swigt__p_std__vectorT_unsigned_int_t, - &_swigt__p_string, &_swigt__p_supportedPinTypes, + &_swigt__p_timespec, &_swigt__p_uint16_t, &_swigt__p_uint32_t, &_swigt__p_uint8_t, @@ -52436,10 +50875,11 @@ static swig_type_info *swig_type_initial[] = { &_swigt__p_unsigned_long, &_swigt__p_unsigned_long_long, &_swigt__p_unsigned_short, - &_swigt__p_va_list, + &_swigt__p_value_type, &_swigt__p_void, }; +static swig_cast_info _swigc__p_Base[] = { {&_swigt__p_Base, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_Firmata_Encoder_Data[] = { {&_swigt__p_Firmata_Encoder_Data, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_Firmata_I2C_Data[] = { {&_swigt__p_Firmata_I2C_Data, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_Firmata_Serial_Data[] = { {&_swigt__p_Firmata_Serial_Data, 0, 0, 0},{0, 0, 0, 0}}; @@ -52447,20 +50887,23 @@ static swig_cast_info _swigc__p_Firmata_Stepper_Data[] = { {&_swigt__p_Firmata_ static swig_cast_info _swigc__p_GLintptr[] = { {&_swigt__p_GLintptr, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_GLsizei[] = { {&_swigt__p_GLsizei, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_GLsizeiptr[] = { {&_swigt__p_GLsizeiptr, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_Node[] = { {&_swigt__p_Node, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p__XDisplay[] = { {&_swigt__p__XDisplay, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_boost__filesystem__path[] = { {&_swigt__p_boost__filesystem__path, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_difference_type[] = { {&_swigt__p_difference_type, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_float[] = { {&_swigt__p_float, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_glm__mat3[] = { {&_swigt__p_glm__mat3, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_glm__mat4[] = { {&_swigt__p_glm__mat4, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_glm__quat[] = { {&_swigt__p_glm__quat, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_glm__tvec2T_int_glm__precision__defaultp_t[] = { {&_swigt__p_glm__tvec2T_int_glm__precision__defaultp_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_glm__tvec3T_int_glm__precision__defaultp_t[] = { {&_swigt__p_glm__tvec3T_int_glm__precision__defaultp_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_glm__tvec4T_int_glm__precision__defaultp_t[] = { {&_swigt__p_glm__tvec4T_int_glm__precision__defaultp_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_ofMouseEventArgs[] = {{&_swigt__p_ofMouseEventArgs, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_ofWindowPosEventArgs[] = {{&_swigt__p_ofWindowPosEventArgs, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_glm__vec2[] = { {&_swigt__p_glm__vec2, 0, 0, 0}, {&_swigt__p_ofMouseEventArgs, _p_ofMouseEventArgsTo_p_glm__vec2, 0, 0}, {&_swigt__p_ofTouchEventArgs, _p_ofTouchEventArgsTo_p_glm__vec2, 0, 0}, {&_swigt__p_ofWindowPosEventArgs, _p_ofWindowPosEventArgsTo_p_glm__vec2, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_glm__vec3[] = { {&_swigt__p_glm__vec3, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_glm__vec4[] = { {&_swigt__p_glm__vec4, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_glm__vecT_2_int_glm__precision__defaultp_t[] = { {&_swigt__p_glm__vecT_2_int_glm__precision__defaultp_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_glm__vecT_3_int_glm__precision__defaultp_t[] = { {&_swigt__p_glm__vecT_3_int_glm__precision__defaultp_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_glm__vecT_4_int_glm__precision__defaultp_t[] = { {&_swigt__p_glm__vecT_4_int_glm__precision__defaultp_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_int16_t[] = { {&_swigt__p_int16_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_int32_t[] = { {&_swigt__p_int32_t, 0, 0, 0},{0, 0, 0, 0}}; @@ -52468,25 +50911,28 @@ static swig_cast_info _swigc__p_int8_t[] = { {&_swigt__p_int8_t, 0, 0, 0},{0, 0 static swig_cast_info _swigc__p_long_long[] = { {&_swigt__p_long_long, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_of3dPrimitive[] = { {&_swigt__p_of3dPrimitive, 0, 0, 0}, {&_swigt__p_ofPlanePrimitive, _p_ofPlanePrimitiveTo_p_of3dPrimitive, 0, 0}, {&_swigt__p_ofSpherePrimitive, _p_ofSpherePrimitiveTo_p_of3dPrimitive, 0, 0}, {&_swigt__p_ofIcoSpherePrimitive, _p_ofIcoSpherePrimitiveTo_p_of3dPrimitive, 0, 0}, {&_swigt__p_ofCylinderPrimitive, _p_ofCylinderPrimitiveTo_p_of3dPrimitive, 0, 0}, {&_swigt__p_ofConePrimitive, _p_ofConePrimitiveTo_p_of3dPrimitive, 0, 0}, {&_swigt__p_ofBoxPrimitive, _p_ofBoxPrimitiveTo_p_of3dPrimitive, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_ofAbstractParameter[] = { {&_swigt__p_ofAbstractParameter, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofAlphabet[] = { {&_swigt__p_ofAlphabet, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_ofAppBaseWindow[] = { {&_swigt__p_ofAppBaseWindow, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_ofArduino[] = { {&_swigt__p_ofArduino, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofArrayViewT_unsigned_int_t[] = { {&_swigt__p_ofArrayViewT_unsigned_int_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofArrayViewT_void_t[] = { {&_swigt__p_ofArrayViewT_void_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofBaseApp[] = { {&_swigt__p_ofBaseApp, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofBaseDraws[] = { {&_swigt__p_ofBaseDraws, 0, 0, 0}, {&_swigt__p_ofTexture, _p_ofTextureTo_p_ofBaseDraws, 0, 0}, {&_swigt__p_ofFbo, _p_ofFboTo_p_ofBaseDraws, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_ofBaseDraws[] = { {&_swigt__p_ofBaseVideoDraws, _p_ofBaseVideoDrawsTo_p_ofBaseDraws, 0, 0}, {&_swigt__p_ofVideoGrabber, _p_ofVideoGrabberTo_p_ofBaseDraws, 0, 0}, {&_swigt__p_ofBaseDraws, 0, 0, 0}, {&_swigt__p_ofTexture, _p_ofTextureTo_p_ofBaseDraws, 0, 0}, {&_swigt__p_ofFbo, _p_ofFboTo_p_ofBaseDraws, 0, 0}, {&_swigt__p_ofVideoPlayer, _p_ofVideoPlayerTo_p_ofBaseDraws, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_ofBaseHasPixels[] = { {&_swigt__p_ofBaseVideoDraws, _p_ofBaseVideoDrawsTo_p_ofBaseHasPixels, 0, 0}, {&_swigt__p_ofVideoGrabber, _p_ofVideoGrabberTo_p_ofBaseHasPixels, 0, 0}, {&_swigt__p_ofBaseVideoGrabber, _p_ofBaseVideoGrabberTo_p_ofBaseHasPixels, 0, 0}, {&_swigt__p_ofBaseVideo, _p_ofBaseVideoTo_p_ofBaseHasPixels, 0, 0}, {&_swigt__p_ofBaseHasPixels, 0, 0, 0}, {&_swigt__p_ofVideoPlayer, _p_ofVideoPlayerTo_p_ofBaseHasPixels, 0, 0}, {&_swigt__p_ofBaseVideoPlayer, _p_ofBaseVideoPlayerTo_p_ofBaseHasPixels, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_ofBaseHasTexture[] = { {&_swigt__p_ofBaseHasTexture, 0, 0, 0}, {&_swigt__p_ofFbo, _p_ofFboTo_p_ofBaseHasTexture, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_ofBaseImage_T_float_t[] = { {&_swigt__p_ofBaseImage_T_float_t, 0, 0, 0}, {&_swigt__p_ofImage_T_float_t, _p_ofImage_T_float_tTo_p_ofBaseImage_T_float_t, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_ofBaseImage_T_unsigned_char_t[] = { {&_swigt__p_ofBaseImage_T_unsigned_char_t, 0, 0, 0}, {&_swigt__p_ofImage_T_unsigned_char_t, _p_ofImage_T_unsigned_char_tTo_p_ofBaseImage_T_unsigned_char_t, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_ofBaseImage_T_unsigned_short_t[] = { {&_swigt__p_ofBaseImage_T_unsigned_short_t, 0, 0, 0}, {&_swigt__p_ofImage_T_unsigned_short_t, _p_ofImage_T_unsigned_short_tTo_p_ofBaseImage_T_unsigned_short_t, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_ofConsoleLoggerChannel[] = {{&_swigt__p_ofConsoleLoggerChannel, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_ofFileLoggerChannel[] = {{&_swigt__p_ofFileLoggerChannel, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofBaseLoggerChannel[] = { {&_swigt__p_ofBaseLoggerChannel, 0, 0, 0}, {&_swigt__p_ofConsoleLoggerChannel, _p_ofConsoleLoggerChannelTo_p_ofBaseLoggerChannel, 0, 0}, {&_swigt__p_ofDebugViewLoggerChannel, _p_ofDebugViewLoggerChannelTo_p_ofBaseLoggerChannel, 0, 0}, {&_swigt__p_ofFileLoggerChannel, _p_ofFileLoggerChannelTo_p_ofBaseLoggerChannel, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_ofBaseLoggerChannel[] = { {&_swigt__p_ofBaseLoggerChannel, 0, 0, 0}, {&_swigt__p_ofConsoleLoggerChannel, _p_ofConsoleLoggerChannelTo_p_ofBaseLoggerChannel, 0, 0}, {&_swigt__p_ofFileLoggerChannel, _p_ofFileLoggerChannelTo_p_ofBaseLoggerChannel, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_ofBaseMaterial[] = { {&_swigt__p_ofBaseMaterial, 0, 0, 0}, {&_swigt__p_ofMaterial, _p_ofMaterialTo_p_ofBaseMaterial, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_ofBaseRenderer[] = { {&_swigt__p_ofBaseRenderer, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_ofBaseSoundInput[] = { {&_swigt__p_ofBaseSoundInput, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_ofBaseSoundOutput[] = { {&_swigt__p_ofBaseSoundOutput, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_ofBaseSoundPlayer[] = { {&_swigt__p_ofBaseSoundPlayer, 0, 0, 0}, {&_swigt__p_ofSoundPlayer, _p_ofSoundPlayerTo_p_ofBaseSoundPlayer, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_ofBaseSoundStream[] = { {&_swigt__p_ofBaseSoundStream, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_ofBaseUpdates[] = { {&_swigt__p_ofBaseVideoDraws, _p_ofBaseVideoDrawsTo_p_ofBaseUpdates, 0, 0}, {&_swigt__p_ofVideoGrabber, _p_ofVideoGrabberTo_p_ofBaseUpdates, 0, 0}, {&_swigt__p_ofBaseVideoGrabber, _p_ofBaseVideoGrabberTo_p_ofBaseUpdates, 0, 0}, {&_swigt__p_ofBaseVideo, _p_ofBaseVideoTo_p_ofBaseUpdates, 0, 0}, {&_swigt__p_ofBaseUpdates, 0, 0, 0}, {&_swigt__p_ofVideoPlayer, _p_ofVideoPlayerTo_p_ofBaseUpdates, 0, 0}, {&_swigt__p_ofBaseVideoPlayer, _p_ofBaseVideoPlayerTo_p_ofBaseUpdates, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_ofBaseVideo[] = { {&_swigt__p_ofBaseVideoDraws, _p_ofBaseVideoDrawsTo_p_ofBaseVideo, 0, 0}, {&_swigt__p_ofVideoGrabber, _p_ofVideoGrabberTo_p_ofBaseVideo, 0, 0}, {&_swigt__p_ofBaseVideoGrabber, _p_ofBaseVideoGrabberTo_p_ofBaseVideo, 0, 0}, {&_swigt__p_ofBaseVideo, 0, 0, 0}, {&_swigt__p_ofVideoPlayer, _p_ofVideoPlayerTo_p_ofBaseVideo, 0, 0}, {&_swigt__p_ofBaseVideoPlayer, _p_ofBaseVideoPlayerTo_p_ofBaseVideo, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_ofBaseVideoDraws[] = { {&_swigt__p_ofBaseVideoDraws, 0, 0, 0}, {&_swigt__p_ofVideoGrabber, _p_ofVideoGrabberTo_p_ofBaseVideoDraws, 0, 0}, {&_swigt__p_ofVideoPlayer, _p_ofVideoPlayerTo_p_ofBaseVideoDraws, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_ofBaseVideoGrabber[] = { {&_swigt__p_ofBaseVideoGrabber, 0, 0, 0}, {&_swigt__p_ofVideoGrabber, _p_ofVideoGrabberTo_p_ofBaseVideoGrabber, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_ofBaseVideoPlayer[] = { {&_swigt__p_ofBaseVideoPlayer, 0, 0, 0}, {&_swigt__p_ofVideoPlayer, _p_ofVideoPlayerTo_p_ofBaseVideoPlayer, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_ofBoxPrimitive[] = { {&_swigt__p_ofBoxPrimitive, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_ofBuffer[] = { {&_swigt__p_ofBuffer, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_ofBufferObject[] = { {&_swigt__p_ofBufferObject, 0, 0, 0},{0, 0, 0, 0}}; @@ -52497,7 +50943,6 @@ static swig_cast_info _swigc__p_ofColor_T_unsigned_short_t[] = { {&_swigt__p_of static swig_cast_info _swigc__p_ofConePrimitive[] = { {&_swigt__p_ofConePrimitive, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_ofCoreEvents[] = { {&_swigt__p_ofCoreEvents, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_ofCylinderPrimitive[] = { {&_swigt__p_ofCylinderPrimitive, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofDebugViewLoggerChannel[] = { {&_swigt__p_ofDebugViewLoggerChannel, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_ofDirectory[] = { {&_swigt__p_ofDirectory, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_ofDragInfo[] = { {&_swigt__p_ofDragInfo, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_ofEasyCam[] = { {&_swigt__p_ofEasyCam, 0, 0, 0},{0, 0, 0, 0}}; @@ -52509,13 +50954,11 @@ static swig_cast_info _swigc__p_ofEventT_Firmata_I2C_Data_const_t[] = { {&_swig static swig_cast_info _swigc__p_ofEventT_Firmata_Serial_Data_const_t[] = { {&_swigt__p_ofEventT_Firmata_Serial_Data_const_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_ofEventT_Firmata_Stepper_Data_const_t[] = { {&_swigt__p_ofEventT_Firmata_Stepper_Data_const_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_ofEventT_int_const_t[] = { {&_swigt__p_ofEventT_int_const_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofEventT_ofHttpResponse_t[] = { {&_swigt__p_ofEventT_ofHttpResponse_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_ofEventT_std__pairT_int_Firmata_Pin_Modes_t_const_t[] = { {&_swigt__p_ofEventT_std__pairT_int_Firmata_Pin_Modes_t_const_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_ofEventT_std__string_const_t[] = { {&_swigt__p_ofEventT_std__string_const_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_ofEventT_std__vectorT_Firmata_Encoder_Data_t_const_t[] = { {&_swigt__p_ofEventT_std__vectorT_Firmata_Encoder_Data_t_const_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_ofEventT_std__vectorT_unsigned_char_t_const_t[] = { {&_swigt__p_ofEventT_std__vectorT_unsigned_char_t_const_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_ofFbo[] = { {&_swigt__p_ofFbo, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofFbo__Settings[] = { {&_swigt__p_ofFbo__Settings, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_ofFile[] = { {&_swigt__p_ofFile, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_ofFileDialogResult[] = { {&_swigt__p_ofFileDialogResult, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_ofFilePath[] = { {&_swigt__p_ofFilePath, 0, 0, 0},{0, 0, 0, 0}}; @@ -52534,15 +50977,13 @@ static swig_cast_info _swigc__p_ofLogFatalError[] = {{&_swigt__p_ofLogFatalError static swig_cast_info _swigc__p_ofLogVerbose[] = {{&_swigt__p_ofLogVerbose, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_ofLogWarning[] = {{&_swigt__p_ofLogWarning, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_ofLog[] = { {&_swigt__p_ofLogError, _p_ofLogErrorTo_p_ofLog, 0, 0}, {&_swigt__p_ofLogNotice, _p_ofLogNoticeTo_p_ofLog, 0, 0}, {&_swigt__p_ofLogFatalError, _p_ofLogFatalErrorTo_p_ofLog, 0, 0}, {&_swigt__p_ofLogVerbose, _p_ofLogVerboseTo_p_ofLog, 0, 0}, {&_swigt__p_ofLog, 0, 0, 0}, {&_swigt__p_ofLogWarning, _p_ofLogWarningTo_p_ofLog, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofLoopType[] = { {&_swigt__p_ofLoopType, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_ofMaterial[] = { {&_swigt__p_ofMaterial, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofMaterial__Settings[] = { {&_swigt__p_ofMaterial__Settings, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_ofMaterialSettings[] = { {&_swigt__p_ofMaterialSettings, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_ofMatrix3x3[] = { {&_swigt__p_ofMatrix3x3, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_ofMatrix4x4[] = { {&_swigt__p_ofMatrix4x4, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_ofMatrixStack[] = { {&_swigt__p_ofMatrixStack, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofMeshData[] = { {&_swigt__p_ofMeshData, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofMeshFace_T_glm__vec3_glm__vec3_ofColor_T_float_t_glm__vec2_t[] = { {&_swigt__p_ofMeshFace_T_glm__vec3_glm__vec3_ofColor_T_float_t_glm__vec2_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofMesh_T_glm__vec3_glm__vec3_ofColor_T_float_t_glm__vec2_t[] = { {&_swigt__p_ofMesh_T_glm__vec3_glm__vec3_ofColor_T_float_t_glm__vec2_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_ofMeshFace_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t[] = { {&_swigt__p_ofMeshFace_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t[] = { {&_swigt__p_ofVboMesh, _p_ofVboMeshTo_p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t, 0, 0}, {&_swigt__p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_ofNode[] = { {&_swigt__p_ofNode, 0, 0, 0}, {&_swigt__p_of3dPrimitive, _p_of3dPrimitiveTo_p_ofNode, 0, 0}, {&_swigt__p_ofPlanePrimitive, _p_ofPlanePrimitiveTo_p_ofNode, 0, 0}, {&_swigt__p_ofSpherePrimitive, _p_ofSpherePrimitiveTo_p_ofNode, 0, 0}, {&_swigt__p_ofIcoSpherePrimitive, _p_ofIcoSpherePrimitiveTo_p_ofNode, 0, 0}, {&_swigt__p_ofCylinderPrimitive, _p_ofCylinderPrimitiveTo_p_ofNode, 0, 0}, {&_swigt__p_ofConePrimitive, _p_ofConePrimitiveTo_p_ofNode, 0, 0}, {&_swigt__p_ofBoxPrimitive, _p_ofBoxPrimitiveTo_p_ofNode, 0, 0}, {&_swigt__p_ofEasyCam, _p_ofEasyCamTo_p_ofNode, 0, 0}, {&_swigt__p_ofLight, _p_ofLightTo_p_ofNode, 0, 0}, {&_swigt__p_ofCamera, _p_ofCameraTo_p_ofNode, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_ofParameterGroup[] = { {&_swigt__p_ofParameterGroup, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_ofPath[] = { {&_swigt__p_ofPath, 0, 0, 0},{0, 0, 0, 0}}; @@ -52550,18 +50991,15 @@ static swig_cast_info _swigc__p_ofPixels_T_float_t[] = { {&_swigt__p_ofPixels_T static swig_cast_info _swigc__p_ofPixels_T_unsigned_char_t[] = { {&_swigt__p_ofPixels_T_unsigned_char_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_ofPixels_T_unsigned_short_t[] = { {&_swigt__p_ofPixels_T_unsigned_short_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_ofPlanePrimitive[] = { {&_swigt__p_ofPlanePrimitive, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofPolyline_T_ofDefaultVertexType_t[] = { {&_swigt__p_ofPolyline_T_ofDefaultVertexType_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_ofPolyline_T_glm__vec3_t[] = { {&_swigt__p_ofPolyline_T_glm__vec3_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_ofQuaternion[] = { {&_swigt__p_ofQuaternion, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_ofRectangle[] = { {&_swigt__p_ofRectangle, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_ofSerial[] = { {&_swigt__p_ofSerial, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_ofSerialDeviceInfo[] = { {&_swigt__p_ofSerialDeviceInfo, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_ofShader[] = { {&_swigt__p_ofShader, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofShader__Settings[] = { {&_swigt__p_ofShader__Settings, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofShader__TransformFeedbackBaseBinding[] = { {&_swigt__p_ofShader__TransformFeedbackBaseBinding, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofShader__TransformFeedbackRangeBinding[] = { {&_swigt__p_ofShader__TransformFeedbackRangeBinding, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_ofShaderSettings[] = { {&_swigt__p_ofShaderSettings, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_ofShader__TransformFeedbackSettings[] = { {&_swigt__p_ofShader__TransformFeedbackSettings, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_ofSoundDevice[] = { {&_swigt__p_ofSoundDevice, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofSoundDevice__Api[] = { {&_swigt__p_ofSoundDevice__Api, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_ofSoundPlayer[] = { {&_swigt__p_ofSoundPlayer, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_ofSoundStream[] = { {&_swigt__p_ofSoundStream, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_ofSoundStreamSettings[] = { {&_swigt__p_ofSoundStreamSettings, 0, 0, 0},{0, 0, 0, 0}}; @@ -52572,8 +51010,7 @@ static swig_cast_info _swigc__p_ofTextureData[] = { {&_swigt__p_ofTextureData, static swig_cast_info _swigc__p_ofTime[] = { {&_swigt__p_ofTime, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_ofTouchEventArgs[] = { {&_swigt__p_ofTouchEventArgs, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_ofTrueTypeFont[] = { {&_swigt__p_ofTrueTypeFont, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofTrueTypeFont__Settings[] = { {&_swigt__p_ofTrueTypeFont__Settings, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofTrueTypeFont__Settings__Direction[] = { {&_swigt__p_ofTrueTypeFont__Settings__Direction, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_ofTrueTypeFontSettings[] = { {&_swigt__p_ofTrueTypeFontSettings, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_ofURLFileLoader[] = { {&_swigt__p_ofURLFileLoader, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_ofUnicode[] = { {&_swigt__p_ofUnicode, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_ofUnicode__range[] = { {&_swigt__p_ofUnicode__range, 0, 0, 0},{0, 0, 0, 0}}; @@ -52583,25 +51020,24 @@ static swig_cast_info _swigc__p_ofVec2f[] = { {&_swigt__p_ofVec2f, 0, 0, 0},{0, static swig_cast_info _swigc__p_ofVec3f[] = { {&_swigt__p_ofVec3f, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_ofVec4f[] = { {&_swigt__p_ofVec4f, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_ofVideoDevice[] = { {&_swigt__p_ofVideoDevice, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_ofVideoFormat[] = { {&_swigt__p_ofVideoFormat, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_ofVideoGrabber[] = { {&_swigt__p_ofVideoGrabber, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_ofVideoPlayer[] = { {&_swigt__p_ofVideoPlayer, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofWindowPosEventArgs[] = { {&_swigt__p_ofWindowPosEventArgs, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_ofXml[] = { {&_swigt__p_ofXml, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofXmlSearchIterator[] = { {&_swigt__p_ofXmlSearchIterator, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_ofXmlAttributeIterator[] = { {&_swigt__p_ofXmlAttributeIterator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_ofXml__Attribute[] = { {&_swigt__p_ofXml__Attribute, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofXml__RangeT_ofXmlIteratorT_pugi__xml_attribute_iterator_t_t[] = { {&_swigt__p_ofXml__RangeT_ofXmlIteratorT_pugi__xml_attribute_iterator_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_ofXml__RangeT_ofXmlAttributeIterator_t[] = { {&_swigt__p_ofXml__RangeT_ofXmlAttributeIterator_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_ofXml__RangeT_ofXmlIteratorT_pugi__xml_named_node_iterator_t_t[] = { {&_swigt__p_ofXml__RangeT_ofXmlIteratorT_pugi__xml_named_node_iterator_t_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_ofXml__RangeT_ofXmlIteratorT_pugi__xml_node_iterator_t_t[] = { {&_swigt__p_ofXml__RangeT_ofXmlIteratorT_pugi__xml_node_iterator_t_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofXml__Search[] = { {&_swigt__p_ofXml__Search, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_size_type[] = { {&_swigt__p_size_type, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_std__chrono__nanoseconds[] = { {&_swigt__p_std__chrono__nanoseconds, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_std__chrono__time_pointT_std__chrono__nanoseconds_t[] = { {&_swigt__p_std__chrono__time_pointT_std__chrono__nanoseconds_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__fstream[] = { {&_swigt__p_std__fstream, 0, 0, 0}, {&_swigt__p_ofFile, _p_ofFileTo_p_std__fstream, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_std__functionT_void_fofHttpResponse_const_RF_t[] = { {&_swigt__p_std__functionT_void_fofHttpResponse_const_RF_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__initializer_listT_ofUnicode__range_t[] = { {&_swigt__p_std__initializer_listT_ofUnicode__range_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__functionT_void_fofSoundBuffer_RF_t[] = { {&_swigt__p_std__functionT_void_fofSoundBuffer_RF_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_std__istream[] = { {&_swigt__p_std__istream, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__mapT_int_supportedPinTypes_t[] = { {&_swigt__p_std__mapT_int_supportedPinTypes_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__mapT_std__string_std__string_t[] = { {&_swigt__p_std__mapT_std__string_std__string_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__ostream[] = { {&_swigt__p_std__ostream, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__shared_ptrT_ofAppBaseWindow_t[] = { {&_swigt__p_std__shared_ptrT_ofAppBaseWindow_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__mapT_int_supportedPinTypes_std__lessT_int_t_t[] = { {&_swigt__p_std__mapT_int_supportedPinTypes_std__lessT_int_t_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__mapT_std__string_std__string_std__lessT_std__string_t_t[] = { {&_swigt__p_std__mapT_std__string_std__string_std__lessT_std__string_t_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_std__shared_ptrT_ofBaseLoggerChannel_t[] = { {&_swigt__p_std__shared_ptrT_ofBaseLoggerChannel_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_std__shared_ptrT_ofBaseRenderer_t[] = { {&_swigt__p_std__shared_ptrT_ofBaseRenderer_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_std__shared_ptrT_ofBaseSoundPlayer_t[] = { {&_swigt__p_std__shared_ptrT_ofBaseSoundPlayer_t, 0, 0, 0},{0, 0, 0, 0}}; @@ -52609,33 +51045,29 @@ static swig_cast_info _swigc__p_std__shared_ptrT_ofBaseSoundStream_t[] = { {&_s static swig_cast_info _swigc__p_std__shared_ptrT_ofBaseVideoGrabber_t[] = { {&_swigt__p_std__shared_ptrT_ofBaseVideoGrabber_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_std__shared_ptrT_ofBaseVideoPlayer_t[] = { {&_swigt__p_std__shared_ptrT_ofBaseVideoPlayer_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_std__string[] = { {&_swigt__p_std__string, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__vectorT_char_t[] = { {&_swigt__p_std__vectorT_char_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_std__vectorT_float_t[] = { {&_swigt__p_std__vectorT_float_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_std__vectorT_glm__vec2_t[] = { {&_swigt__p_std__vectorT_glm__vec2_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_std__vectorT_glm__vec3_t[] = { {&_swigt__p_std__vectorT_glm__vec3_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__vectorT_glm__vec3_t__const_iterator[] = { {&_swigt__p_std__vectorT_glm__vec3_t__const_iterator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__vectorT_glm__vec3_t__const_reverse_iterator[] = { {&_swigt__p_std__vectorT_glm__vec3_t__const_reverse_iterator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__vectorT_glm__vec3_t__iterator[] = { {&_swigt__p_std__vectorT_glm__vec3_t__iterator, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__vectorT_glm__vec3_t__reverse_iterator[] = { {&_swigt__p_std__vectorT_glm__vec3_t__reverse_iterator, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_std__vectorT_int_t[] = { {&_swigt__p_std__vectorT_int_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__vectorT_ofColor_T_float_t_t[] = { {&_swigt__p_std__vectorT_ofColor_T_float_t_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_std__vectorT_ofFile_t[] = { {&_swigt__p_std__vectorT_ofFile_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__vectorT_ofMeshFace_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t_t[] = { {&_swigt__p_std__vectorT_ofMeshFace_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_std__vectorT_ofPath__Command_t[] = { {&_swigt__p_std__vectorT_ofPath__Command_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_std__vectorT_ofPath_t[] = { {&_swigt__p_std__vectorT_ofPath_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__vectorT_ofPolyline_t[] = { {&_swigt__p_std__vectorT_ofPolyline_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__vectorT_ofPolyline_T_ofDefaultVertexType_t_t[] = { {&_swigt__p_std__vectorT_ofPolyline_T_ofDefaultVertexType_t_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_std__vectorT_ofSerialDeviceInfo_t[] = { {&_swigt__p_std__vectorT_ofSerialDeviceInfo_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__vectorT_ofShader__TransformFeedbackBaseBinding_t[] = { {&_swigt__p_std__vectorT_ofShader__TransformFeedbackBaseBinding_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__vectorT_ofShader__TransformFeedbackRangeBinding_t[] = { {&_swigt__p_std__vectorT_ofShader__TransformFeedbackRangeBinding_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_std__vectorT_ofSoundDevice_t[] = { {&_swigt__p_std__vectorT_ofSoundDevice_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_std__vectorT_ofTexture_t[] = { {&_swigt__p_std__vectorT_ofTexture_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__vectorT_ofUnicode__range_t[] = { {&_swigt__p_std__vectorT_ofUnicode__range_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_std__vectorT_ofVec2f_t[] = { {&_swigt__p_std__vectorT_ofVec2f_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_std__vectorT_ofVec3f_t[] = { {&_swigt__p_std__vectorT_ofVec3f_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_std__vectorT_ofVideoDevice_t[] = { {&_swigt__p_std__vectorT_ofVideoDevice_t, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__vectorT_ofVideoFormat_t[] = { {&_swigt__p_std__vectorT_ofVideoFormat_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_std__vectorT_std__string_t[] = { {&_swigt__p_std__vectorT_std__string_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__vectorT_std__weak_ptrT_ofLight__Data_t_t[] = { {&_swigt__p_std__vectorT_std__weak_ptrT_ofLight__Data_t_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_std__vectorT_unsigned_char_t[] = { {&_swigt__p_std__vectorT_unsigned_char_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_std__vectorT_unsigned_int_t[] = { {&_swigt__p_std__vectorT_unsigned_int_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_string[] = { {&_swigt__p_string, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_supportedPinTypes[] = { {&_swigt__p_supportedPinTypes, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_timespec[] = { {&_swigt__p_timespec, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_uint16_t[] = { {&_swigt__p_uint16_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_uint32_t[] = { {&_swigt__p_uint32_t, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_uint8_t[] = { {&_swigt__p_uint8_t, 0, 0, 0},{0, 0, 0, 0}}; @@ -52644,10 +51076,11 @@ static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_unsigned_long_long[] = { {&_swigt__p_unsigned_long_long, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_unsigned_short[] = { {&_swigt__p_unsigned_short, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_va_list[] = { {&_swigt__p_va_list, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_value_type[] = { {&_swigt__p_value_type, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info _swigc__p_void[] = { {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}}; static swig_cast_info *swig_cast_initial[] = { + _swigc__p_Base, _swigc__p_Firmata_Encoder_Data, _swigc__p_Firmata_I2C_Data, _swigc__p_Firmata_Serial_Data, @@ -52655,19 +51088,21 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_GLintptr, _swigc__p_GLsizei, _swigc__p_GLsizeiptr, + _swigc__p_Node, _swigc__p__XDisplay, _swigc__p_boost__filesystem__path, + _swigc__p_difference_type, _swigc__p_double, _swigc__p_float, _swigc__p_glm__mat3, _swigc__p_glm__mat4, _swigc__p_glm__quat, - _swigc__p_glm__tvec2T_int_glm__precision__defaultp_t, - _swigc__p_glm__tvec3T_int_glm__precision__defaultp_t, - _swigc__p_glm__tvec4T_int_glm__precision__defaultp_t, _swigc__p_glm__vec2, _swigc__p_glm__vec3, _swigc__p_glm__vec4, + _swigc__p_glm__vecT_2_int_glm__precision__defaultp_t, + _swigc__p_glm__vecT_3_int_glm__precision__defaultp_t, + _swigc__p_glm__vecT_4_int_glm__precision__defaultp_t, _swigc__p_int, _swigc__p_int16_t, _swigc__p_int32_t, @@ -52675,13 +51110,10 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_long_long, _swigc__p_of3dPrimitive, _swigc__p_ofAbstractParameter, - _swigc__p_ofAlphabet, _swigc__p_ofAppBaseWindow, _swigc__p_ofArduino, - _swigc__p_ofArrayViewT_unsigned_int_t, - _swigc__p_ofArrayViewT_void_t, - _swigc__p_ofBaseApp, _swigc__p_ofBaseDraws, + _swigc__p_ofBaseHasPixels, _swigc__p_ofBaseHasTexture, _swigc__p_ofBaseImage_T_float_t, _swigc__p_ofBaseImage_T_unsigned_char_t, @@ -52692,6 +51124,12 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_ofBaseSoundInput, _swigc__p_ofBaseSoundOutput, _swigc__p_ofBaseSoundPlayer, + _swigc__p_ofBaseSoundStream, + _swigc__p_ofBaseUpdates, + _swigc__p_ofBaseVideo, + _swigc__p_ofBaseVideoDraws, + _swigc__p_ofBaseVideoGrabber, + _swigc__p_ofBaseVideoPlayer, _swigc__p_ofBoxPrimitive, _swigc__p_ofBuffer, _swigc__p_ofBufferObject, @@ -52703,7 +51141,6 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_ofConsoleLoggerChannel, _swigc__p_ofCoreEvents, _swigc__p_ofCylinderPrimitive, - _swigc__p_ofDebugViewLoggerChannel, _swigc__p_ofDirectory, _swigc__p_ofDragInfo, _swigc__p_ofEasyCam, @@ -52712,13 +51149,11 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_ofEventT_Firmata_Serial_Data_const_t, _swigc__p_ofEventT_Firmata_Stepper_Data_const_t, _swigc__p_ofEventT_int_const_t, - _swigc__p_ofEventT_ofHttpResponse_t, _swigc__p_ofEventT_std__pairT_int_Firmata_Pin_Modes_t_const_t, _swigc__p_ofEventT_std__string_const_t, _swigc__p_ofEventT_std__vectorT_Firmata_Encoder_Data_t_const_t, _swigc__p_ofEventT_std__vectorT_unsigned_char_t_const_t, _swigc__p_ofFbo, - _swigc__p_ofFbo__Settings, _swigc__p_ofFile, _swigc__p_ofFileDialogResult, _swigc__p_ofFileLoggerChannel, @@ -52739,15 +51174,13 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_ofLogNotice, _swigc__p_ofLogVerbose, _swigc__p_ofLogWarning, - _swigc__p_ofLoopType, _swigc__p_ofMaterial, - _swigc__p_ofMaterial__Settings, + _swigc__p_ofMaterialSettings, _swigc__p_ofMatrix3x3, _swigc__p_ofMatrix4x4, _swigc__p_ofMatrixStack, - _swigc__p_ofMeshData, - _swigc__p_ofMeshFace_T_glm__vec3_glm__vec3_ofColor_T_float_t_glm__vec2_t, - _swigc__p_ofMesh_T_glm__vec3_glm__vec3_ofColor_T_float_t_glm__vec2_t, + _swigc__p_ofMeshFace_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t, + _swigc__p_ofMesh_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t, _swigc__p_ofMessage, _swigc__p_ofMouseEventArgs, _swigc__p_ofNode, @@ -52757,19 +51190,16 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_ofPixels_T_unsigned_char_t, _swigc__p_ofPixels_T_unsigned_short_t, _swigc__p_ofPlanePrimitive, - _swigc__p_ofPolyline_T_ofDefaultVertexType_t, + _swigc__p_ofPolyline_T_glm__vec3_t, _swigc__p_ofQuaternion, _swigc__p_ofRectangle, _swigc__p_ofResizeEventArgs, _swigc__p_ofSerial, _swigc__p_ofSerialDeviceInfo, _swigc__p_ofShader, - _swigc__p_ofShader__Settings, - _swigc__p_ofShader__TransformFeedbackBaseBinding, - _swigc__p_ofShader__TransformFeedbackRangeBinding, + _swigc__p_ofShaderSettings, _swigc__p_ofShader__TransformFeedbackSettings, _swigc__p_ofSoundDevice, - _swigc__p_ofSoundDevice__Api, _swigc__p_ofSoundPlayer, _swigc__p_ofSoundStream, _swigc__p_ofSoundStreamSettings, @@ -52780,8 +51210,7 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_ofTime, _swigc__p_ofTouchEventArgs, _swigc__p_ofTrueTypeFont, - _swigc__p_ofTrueTypeFont__Settings, - _swigc__p_ofTrueTypeFont__Settings__Direction, + _swigc__p_ofTrueTypeFontSettings, _swigc__p_ofURLFileLoader, _swigc__p_ofUnicode, _swigc__p_ofUnicode__range, @@ -52791,25 +51220,25 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_ofVec3f, _swigc__p_ofVec4f, _swigc__p_ofVideoDevice, + _swigc__p_ofVideoFormat, _swigc__p_ofVideoGrabber, _swigc__p_ofVideoPlayer, _swigc__p_ofWindowPosEventArgs, _swigc__p_ofXml, - _swigc__p_ofXmlSearchIterator, + _swigc__p_ofXmlAttributeIterator, _swigc__p_ofXml__Attribute, - _swigc__p_ofXml__RangeT_ofXmlIteratorT_pugi__xml_attribute_iterator_t_t, + _swigc__p_ofXml__RangeT_ofXmlAttributeIterator_t, _swigc__p_ofXml__RangeT_ofXmlIteratorT_pugi__xml_named_node_iterator_t_t, _swigc__p_ofXml__RangeT_ofXmlIteratorT_pugi__xml_node_iterator_t_t, - _swigc__p_ofXml__Search, + _swigc__p_size_type, _swigc__p_std__chrono__nanoseconds, _swigc__p_std__chrono__time_pointT_std__chrono__nanoseconds_t, + _swigc__p_std__fstream, _swigc__p_std__functionT_void_fofHttpResponse_const_RF_t, - _swigc__p_std__initializer_listT_ofUnicode__range_t, + _swigc__p_std__functionT_void_fofSoundBuffer_RF_t, _swigc__p_std__istream, - _swigc__p_std__mapT_int_supportedPinTypes_t, - _swigc__p_std__mapT_std__string_std__string_t, - _swigc__p_std__ostream, - _swigc__p_std__shared_ptrT_ofAppBaseWindow_t, + _swigc__p_std__mapT_int_supportedPinTypes_std__lessT_int_t_t, + _swigc__p_std__mapT_std__string_std__string_std__lessT_std__string_t_t, _swigc__p_std__shared_ptrT_ofBaseLoggerChannel_t, _swigc__p_std__shared_ptrT_ofBaseRenderer_t, _swigc__p_std__shared_ptrT_ofBaseSoundPlayer_t, @@ -52817,33 +51246,29 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_std__shared_ptrT_ofBaseVideoGrabber_t, _swigc__p_std__shared_ptrT_ofBaseVideoPlayer_t, _swigc__p_std__string, - _swigc__p_std__vectorT_char_t, _swigc__p_std__vectorT_float_t, _swigc__p_std__vectorT_glm__vec2_t, _swigc__p_std__vectorT_glm__vec3_t, - _swigc__p_std__vectorT_glm__vec3_t__const_iterator, - _swigc__p_std__vectorT_glm__vec3_t__const_reverse_iterator, - _swigc__p_std__vectorT_glm__vec3_t__iterator, - _swigc__p_std__vectorT_glm__vec3_t__reverse_iterator, _swigc__p_std__vectorT_int_t, + _swigc__p_std__vectorT_ofColor_T_float_t_t, _swigc__p_std__vectorT_ofFile_t, + _swigc__p_std__vectorT_ofMeshFace_T_ofDefaultVertexType_ofDefaultNormalType_ofDefaultColorType_ofDefaultTexCoordType_t_t, _swigc__p_std__vectorT_ofPath__Command_t, _swigc__p_std__vectorT_ofPath_t, - _swigc__p_std__vectorT_ofPolyline_t, + _swigc__p_std__vectorT_ofPolyline_T_ofDefaultVertexType_t_t, _swigc__p_std__vectorT_ofSerialDeviceInfo_t, - _swigc__p_std__vectorT_ofShader__TransformFeedbackBaseBinding_t, - _swigc__p_std__vectorT_ofShader__TransformFeedbackRangeBinding_t, _swigc__p_std__vectorT_ofSoundDevice_t, _swigc__p_std__vectorT_ofTexture_t, + _swigc__p_std__vectorT_ofUnicode__range_t, _swigc__p_std__vectorT_ofVec2f_t, _swigc__p_std__vectorT_ofVec3f_t, _swigc__p_std__vectorT_ofVideoDevice_t, + _swigc__p_std__vectorT_ofVideoFormat_t, _swigc__p_std__vectorT_std__string_t, - _swigc__p_std__vectorT_std__weak_ptrT_ofLight__Data_t_t, _swigc__p_std__vectorT_unsigned_char_t, _swigc__p_std__vectorT_unsigned_int_t, - _swigc__p_string, _swigc__p_supportedPinTypes, + _swigc__p_timespec, _swigc__p_uint16_t, _swigc__p_uint32_t, _swigc__p_uint8_t, @@ -52852,7 +51277,7 @@ static swig_cast_info *swig_cast_initial[] = { _swigc__p_unsigned_long, _swigc__p_unsigned_long_long, _swigc__p_unsigned_short, - _swigc__p_va_list, + _swigc__p_value_type, _swigc__p_void, }; @@ -52959,7 +51384,7 @@ SWIG_InitializeModule(void *clientdata) { /* Now work on filling in swig_module.types */ #ifdef SWIGRUNTIME_DEBUG - printf("SWIG_InitializeModule: size %d\n", swig_module.size); + printf("SWIG_InitializeModule: size %lu\n", (unsigned long)swig_module.size); #endif for (i = 0; i < swig_module.size; ++i) { swig_type_info *type = 0; @@ -52967,7 +51392,7 @@ SWIG_InitializeModule(void *clientdata) { swig_cast_info *cast; #ifdef SWIGRUNTIME_DEBUG - printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name); + printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name); #endif /* if there is another module already loaded */ @@ -53043,7 +51468,7 @@ SWIG_InitializeModule(void *clientdata) { for (i = 0; i < swig_module.size; ++i) { int j = 0; swig_cast_info *cast = swig_module.cast_initial[i]; - printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name); + printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name); while (cast->type) { printf("SWIG_InitializeModule: cast type %s\n", cast->type->name); cast++; diff --git a/addons/ofxLua/src/bindings/desktop/ofxLuaBindings.cpp b/addons/ofxLua/src/bindings/desktop/ofxLuaBindings.cpp deleted file mode 100644 index f4e9221..0000000 --- a/addons/ofxLua/src/bindings/desktop/ofxLuaBindings.cpp +++ /dev/null @@ -1,46841 +0,0 @@ -/* ---------------------------------------------------------------------------- - * This file was automatically generated by SWIG (http://www.swig.org). - * Version 3.0.12 - * - * This file is not intended to be easily readable and contains a number of - * coding conventions designed to improve portability and efficiency. Do not make - * changes to this file unless you know what you are doing--modify the SWIG - * interface file instead. - * ----------------------------------------------------------------------------- */ - -#if defined( __WIN32__ ) || defined( _WIN32 ) - #include -#endif - - - -#ifndef SWIGLUA -#define SWIGLUA -#endif - -#define SWIG_LUA_TARGET SWIG_LUA_FLAVOR_LUA -#define SWIG_LUA_MODULE_GLOBAL - - -#ifdef __cplusplus -/* SwigValueWrapper is described in swig.swg */ -template class SwigValueWrapper { - struct SwigMovePointer { - T *ptr; - SwigMovePointer(T *p) : ptr(p) { } - ~SwigMovePointer() { delete ptr; } - SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; } - } pointer; - SwigValueWrapper& operator=(const SwigValueWrapper& rhs); - SwigValueWrapper(const SwigValueWrapper& rhs); -public: - SwigValueWrapper() : pointer(0) { } - SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; } - operator T&() const { return *pointer.ptr; } - T *operator&() { return pointer.ptr; } -}; - -template T SwigValueInit() { - return T(); -} -#endif - -/* ----------------------------------------------------------------------------- - * This section contains generic SWIG labels for method/variable - * declarations/attributes, and other compiler dependent labels. - * ----------------------------------------------------------------------------- */ - -/* template workaround for compilers that cannot correctly implement the C++ standard */ -#ifndef SWIGTEMPLATEDISAMBIGUATOR -# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560) -# define SWIGTEMPLATEDISAMBIGUATOR template -# elif defined(__HP_aCC) -/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */ -/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */ -# define SWIGTEMPLATEDISAMBIGUATOR template -# else -# define SWIGTEMPLATEDISAMBIGUATOR -# endif -#endif - -/* inline attribute */ -#ifndef SWIGINLINE -# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__)) -# define SWIGINLINE inline -# else -# define SWIGINLINE -# endif -#endif - -/* attribute recognised by some compilers to avoid 'unused' warnings */ -#ifndef SWIGUNUSED -# if defined(__GNUC__) -# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) -# define SWIGUNUSED __attribute__ ((__unused__)) -# else -# define SWIGUNUSED -# endif -# elif defined(__ICC) -# define SWIGUNUSED __attribute__ ((__unused__)) -# else -# define SWIGUNUSED -# endif -#endif - -#ifndef SWIG_MSC_UNSUPPRESS_4505 -# if defined(_MSC_VER) -# pragma warning(disable : 4505) /* unreferenced local function has been removed */ -# endif -#endif - -#ifndef SWIGUNUSEDPARM -# ifdef __cplusplus -# define SWIGUNUSEDPARM(p) -# else -# define SWIGUNUSEDPARM(p) p SWIGUNUSED -# endif -#endif - -/* internal SWIG method */ -#ifndef SWIGINTERN -# define SWIGINTERN static SWIGUNUSED -#endif - -/* internal inline SWIG method */ -#ifndef SWIGINTERNINLINE -# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE -#endif - -/* exporting methods */ -#if defined(__GNUC__) -# if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) -# ifndef GCC_HASCLASSVISIBILITY -# define GCC_HASCLASSVISIBILITY -# endif -# endif -#endif - -#ifndef SWIGEXPORT -# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) -# if defined(STATIC_LINKED) -# define SWIGEXPORT -# else -# define SWIGEXPORT __declspec(dllexport) -# endif -# else -# if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY) -# define SWIGEXPORT __attribute__ ((visibility("default"))) -# else -# define SWIGEXPORT -# endif -# endif -#endif - -/* calling conventions for Windows */ -#ifndef SWIGSTDCALL -# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) -# define SWIGSTDCALL __stdcall -# else -# define SWIGSTDCALL -# endif -#endif - -/* Deal with Microsoft's attempt at deprecating C standard runtime functions */ -#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE) -# define _CRT_SECURE_NO_DEPRECATE -#endif - -/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */ -#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE) -# define _SCL_SECURE_NO_DEPRECATE -#endif - -/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */ -#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES) -# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0 -#endif - -/* Intel's compiler complains if a variable which was never initialised is - * cast to void, which is a common idiom which we use to indicate that we - * are aware a variable isn't used. So we just silence that warning. - * See: https://github.com/swig/swig/issues/192 for more discussion. - */ -#ifdef __INTEL_COMPILER -# pragma warning disable 592 -#endif - -/* ----------------------------------------------------------------------------- - * swigrun.swg - * - * This file contains generic C API SWIG runtime support for pointer - * type checking. - * ----------------------------------------------------------------------------- */ - -/* This should only be incremented when either the layout of swig_type_info changes, - or for whatever reason, the runtime changes incompatibly */ -#define SWIG_RUNTIME_VERSION "4" - -/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */ -#ifdef SWIG_TYPE_TABLE -# define SWIG_QUOTE_STRING(x) #x -# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x) -# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE) -#else -# define SWIG_TYPE_TABLE_NAME -#endif - -/* - You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for - creating a static or dynamic library from the SWIG runtime code. - In 99.9% of the cases, SWIG just needs to declare them as 'static'. - - But only do this if strictly necessary, ie, if you have problems - with your compiler or suchlike. -*/ - -#ifndef SWIGRUNTIME -# define SWIGRUNTIME SWIGINTERN -#endif - -#ifndef SWIGRUNTIMEINLINE -# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE -#endif - -/* Generic buffer size */ -#ifndef SWIG_BUFFER_SIZE -# define SWIG_BUFFER_SIZE 1024 -#endif - -/* Flags for pointer conversions */ -#define SWIG_POINTER_DISOWN 0x1 -#define SWIG_CAST_NEW_MEMORY 0x2 - -/* Flags for new pointer objects */ -#define SWIG_POINTER_OWN 0x1 - - -/* - Flags/methods for returning states. - - The SWIG conversion methods, as ConvertPtr, return an integer - that tells if the conversion was successful or not. And if not, - an error code can be returned (see swigerrors.swg for the codes). - - Use the following macros/flags to set or process the returning - states. - - In old versions of SWIG, code such as the following was usually written: - - if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) { - // success code - } else { - //fail code - } - - Now you can be more explicit: - - int res = SWIG_ConvertPtr(obj,vptr,ty.flags); - if (SWIG_IsOK(res)) { - // success code - } else { - // fail code - } - - which is the same really, but now you can also do - - Type *ptr; - int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags); - if (SWIG_IsOK(res)) { - // success code - if (SWIG_IsNewObj(res) { - ... - delete *ptr; - } else { - ... - } - } else { - // fail code - } - - I.e., now SWIG_ConvertPtr can return new objects and you can - identify the case and take care of the deallocation. Of course that - also requires SWIG_ConvertPtr to return new result values, such as - - int SWIG_ConvertPtr(obj, ptr,...) { - if () { - if () { - *ptr = ; - return SWIG_NEWOBJ; - } else { - *ptr = ; - return SWIG_OLDOBJ; - } - } else { - return SWIG_BADOBJ; - } - } - - Of course, returning the plain '0(success)/-1(fail)' still works, but you can be - more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the - SWIG errors code. - - Finally, if the SWIG_CASTRANK_MODE is enabled, the result code - allows to return the 'cast rank', for example, if you have this - - int food(double) - int fooi(int); - - and you call - - food(1) // cast rank '1' (1 -> 1.0) - fooi(1) // cast rank '0' - - just use the SWIG_AddCast()/SWIG_CheckState() -*/ - -#define SWIG_OK (0) -#define SWIG_ERROR (-1) -#define SWIG_IsOK(r) (r >= 0) -#define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError) - -/* The CastRankLimit says how many bits are used for the cast rank */ -#define SWIG_CASTRANKLIMIT (1 << 8) -/* The NewMask denotes the object was created (using new/malloc) */ -#define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1) -/* The TmpMask is for in/out typemaps that use temporal objects */ -#define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1) -/* Simple returning values */ -#define SWIG_BADOBJ (SWIG_ERROR) -#define SWIG_OLDOBJ (SWIG_OK) -#define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK) -#define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK) -/* Check, add and del mask methods */ -#define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r) -#define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r) -#define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK)) -#define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r) -#define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r) -#define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK)) - -/* Cast-Rank Mode */ -#if defined(SWIG_CASTRANK_MODE) -# ifndef SWIG_TypeRank -# define SWIG_TypeRank unsigned long -# endif -# ifndef SWIG_MAXCASTRANK /* Default cast allowed */ -# define SWIG_MAXCASTRANK (2) -# endif -# define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1) -# define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK) -SWIGINTERNINLINE int SWIG_AddCast(int r) { - return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r; -} -SWIGINTERNINLINE int SWIG_CheckState(int r) { - return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0; -} -#else /* no cast-rank mode */ -# define SWIG_AddCast(r) (r) -# define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0) -#endif - - -#include - -#ifdef __cplusplus -extern "C" { -#endif - -typedef void *(*swig_converter_func)(void *, int *); -typedef struct swig_type_info *(*swig_dycast_func)(void **); - -/* Structure to store information on one type */ -typedef struct swig_type_info { - const char *name; /* mangled name of this type */ - const char *str; /* human readable name of this type */ - swig_dycast_func dcast; /* dynamic cast function down a hierarchy */ - struct swig_cast_info *cast; /* linked list of types that can cast into this type */ - void *clientdata; /* language specific type data */ - int owndata; /* flag if the structure owns the clientdata */ -} swig_type_info; - -/* Structure to store a type and conversion function used for casting */ -typedef struct swig_cast_info { - swig_type_info *type; /* pointer to type that is equivalent to this type */ - swig_converter_func converter; /* function to cast the void pointers */ - struct swig_cast_info *next; /* pointer to next cast in linked list */ - struct swig_cast_info *prev; /* pointer to the previous cast */ -} swig_cast_info; - -/* Structure used to store module information - * Each module generates one structure like this, and the runtime collects - * all of these structures and stores them in a circularly linked list.*/ -typedef struct swig_module_info { - swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */ - size_t size; /* Number of types in this module */ - struct swig_module_info *next; /* Pointer to next element in circularly linked list */ - swig_type_info **type_initial; /* Array of initially generated type structures */ - swig_cast_info **cast_initial; /* Array of initially generated casting structures */ - void *clientdata; /* Language specific module data */ -} swig_module_info; - -/* - Compare two type names skipping the space characters, therefore - "char*" == "char *" and "Class" == "Class", etc. - - Return 0 when the two name types are equivalent, as in - strncmp, but skipping ' '. -*/ -SWIGRUNTIME int -SWIG_TypeNameComp(const char *f1, const char *l1, - const char *f2, const char *l2) { - for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) { - while ((*f1 == ' ') && (f1 != l1)) ++f1; - while ((*f2 == ' ') && (f2 != l2)) ++f2; - if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1; - } - return (int)((l1 - f1) - (l2 - f2)); -} - -/* - Check type equivalence in a name list like ||... - Return 0 if equal, -1 if nb < tb, 1 if nb > tb -*/ -SWIGRUNTIME int -SWIG_TypeCmp(const char *nb, const char *tb) { - int equiv = 1; - const char* te = tb + strlen(tb); - const char* ne = nb; - while (equiv != 0 && *ne) { - for (nb = ne; *ne; ++ne) { - if (*ne == '|') break; - } - equiv = SWIG_TypeNameComp(nb, ne, tb, te); - if (*ne) ++ne; - } - return equiv; -} - -/* - Check type equivalence in a name list like ||... - Return 0 if not equal, 1 if equal -*/ -SWIGRUNTIME int -SWIG_TypeEquiv(const char *nb, const char *tb) { - return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0; -} - -/* - Check the typename -*/ -SWIGRUNTIME swig_cast_info * -SWIG_TypeCheck(const char *c, swig_type_info *ty) { - if (ty) { - swig_cast_info *iter = ty->cast; - while (iter) { - if (strcmp(iter->type->name, c) == 0) { - if (iter == ty->cast) - return iter; - /* Move iter to the top of the linked list */ - iter->prev->next = iter->next; - if (iter->next) - iter->next->prev = iter->prev; - iter->next = ty->cast; - iter->prev = 0; - if (ty->cast) ty->cast->prev = iter; - ty->cast = iter; - return iter; - } - iter = iter->next; - } - } - return 0; -} - -/* - Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison -*/ -SWIGRUNTIME swig_cast_info * -SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) { - if (ty) { - swig_cast_info *iter = ty->cast; - while (iter) { - if (iter->type == from) { - if (iter == ty->cast) - return iter; - /* Move iter to the top of the linked list */ - iter->prev->next = iter->next; - if (iter->next) - iter->next->prev = iter->prev; - iter->next = ty->cast; - iter->prev = 0; - if (ty->cast) ty->cast->prev = iter; - ty->cast = iter; - return iter; - } - iter = iter->next; - } - } - return 0; -} - -/* - Cast a pointer up an inheritance hierarchy -*/ -SWIGRUNTIMEINLINE void * -SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) { - return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory); -} - -/* - Dynamic pointer casting. Down an inheritance hierarchy -*/ -SWIGRUNTIME swig_type_info * -SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) { - swig_type_info *lastty = ty; - if (!ty || !ty->dcast) return ty; - while (ty && (ty->dcast)) { - ty = (*ty->dcast)(ptr); - if (ty) lastty = ty; - } - return lastty; -} - -/* - Return the name associated with this type -*/ -SWIGRUNTIMEINLINE const char * -SWIG_TypeName(const swig_type_info *ty) { - return ty->name; -} - -/* - Return the pretty name associated with this type, - that is an unmangled type name in a form presentable to the user. -*/ -SWIGRUNTIME const char * -SWIG_TypePrettyName(const swig_type_info *type) { - /* The "str" field contains the equivalent pretty names of the - type, separated by vertical-bar characters. We choose - to print the last name, as it is often (?) the most - specific. */ - if (!type) return NULL; - if (type->str != NULL) { - const char *last_name = type->str; - const char *s; - for (s = type->str; *s; s++) - if (*s == '|') last_name = s+1; - return last_name; - } - else - return type->name; -} - -/* - Set the clientdata field for a type -*/ -SWIGRUNTIME void -SWIG_TypeClientData(swig_type_info *ti, void *clientdata) { - swig_cast_info *cast = ti->cast; - /* if (ti->clientdata == clientdata) return; */ - ti->clientdata = clientdata; - - while (cast) { - if (!cast->converter) { - swig_type_info *tc = cast->type; - if (!tc->clientdata) { - SWIG_TypeClientData(tc, clientdata); - } - } - cast = cast->next; - } -} -SWIGRUNTIME void -SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) { - SWIG_TypeClientData(ti, clientdata); - ti->owndata = 1; -} - -/* - Search for a swig_type_info structure only by mangled name - Search is a O(log #types) - - We start searching at module start, and finish searching when start == end. - Note: if start == end at the beginning of the function, we go all the way around - the circular list. -*/ -SWIGRUNTIME swig_type_info * -SWIG_MangledTypeQueryModule(swig_module_info *start, - swig_module_info *end, - const char *name) { - swig_module_info *iter = start; - do { - if (iter->size) { - size_t l = 0; - size_t r = iter->size - 1; - do { - /* since l+r >= 0, we can (>> 1) instead (/ 2) */ - size_t i = (l + r) >> 1; - const char *iname = iter->types[i]->name; - if (iname) { - int compare = strcmp(name, iname); - if (compare == 0) { - return iter->types[i]; - } else if (compare < 0) { - if (i) { - r = i - 1; - } else { - break; - } - } else if (compare > 0) { - l = i + 1; - } - } else { - break; /* should never happen */ - } - } while (l <= r); - } - iter = iter->next; - } while (iter != end); - return 0; -} - -/* - Search for a swig_type_info structure for either a mangled name or a human readable name. - It first searches the mangled names of the types, which is a O(log #types) - If a type is not found it then searches the human readable names, which is O(#types). - - We start searching at module start, and finish searching when start == end. - Note: if start == end at the beginning of the function, we go all the way around - the circular list. -*/ -SWIGRUNTIME swig_type_info * -SWIG_TypeQueryModule(swig_module_info *start, - swig_module_info *end, - const char *name) { - /* STEP 1: Search the name field using binary search */ - swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name); - if (ret) { - return ret; - } else { - /* STEP 2: If the type hasn't been found, do a complete search - of the str field (the human readable name) */ - swig_module_info *iter = start; - do { - size_t i = 0; - for (; i < iter->size; ++i) { - if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name))) - return iter->types[i]; - } - iter = iter->next; - } while (iter != end); - } - - /* neither found a match */ - return 0; -} - -/* - Pack binary data into a string -*/ -SWIGRUNTIME char * -SWIG_PackData(char *c, void *ptr, size_t sz) { - static const char hex[17] = "0123456789abcdef"; - const unsigned char *u = (unsigned char *) ptr; - const unsigned char *eu = u + sz; - for (; u != eu; ++u) { - unsigned char uu = *u; - *(c++) = hex[(uu & 0xf0) >> 4]; - *(c++) = hex[uu & 0xf]; - } - return c; -} - -/* - Unpack binary data from a string -*/ -SWIGRUNTIME const char * -SWIG_UnpackData(const char *c, void *ptr, size_t sz) { - unsigned char *u = (unsigned char *) ptr; - const unsigned char *eu = u + sz; - for (; u != eu; ++u) { - char d = *(c++); - unsigned char uu; - if ((d >= '0') && (d <= '9')) - uu = (unsigned char)((d - '0') << 4); - else if ((d >= 'a') && (d <= 'f')) - uu = (unsigned char)((d - ('a'-10)) << 4); - else - return (char *) 0; - d = *(c++); - if ((d >= '0') && (d <= '9')) - uu |= (unsigned char)(d - '0'); - else if ((d >= 'a') && (d <= 'f')) - uu |= (unsigned char)(d - ('a'-10)); - else - return (char *) 0; - *u = uu; - } - return c; -} - -/* - Pack 'void *' into a string buffer. -*/ -SWIGRUNTIME char * -SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) { - char *r = buff; - if ((2*sizeof(void *) + 2) > bsz) return 0; - *(r++) = '_'; - r = SWIG_PackData(r,&ptr,sizeof(void *)); - if (strlen(name) + 1 > (bsz - (r - buff))) return 0; - strcpy(r,name); - return buff; -} - -SWIGRUNTIME const char * -SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) { - if (*c != '_') { - if (strcmp(c,"NULL") == 0) { - *ptr = (void *) 0; - return name; - } else { - return 0; - } - } - return SWIG_UnpackData(++c,ptr,sizeof(void *)); -} - -SWIGRUNTIME char * -SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) { - char *r = buff; - size_t lname = (name ? strlen(name) : 0); - if ((2*sz + 2 + lname) > bsz) return 0; - *(r++) = '_'; - r = SWIG_PackData(r,ptr,sz); - if (lname) { - strncpy(r,name,lname+1); - } else { - *r = 0; - } - return buff; -} - -SWIGRUNTIME const char * -SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) { - if (*c != '_') { - if (strcmp(c,"NULL") == 0) { - memset(ptr,0,sz); - return name; - } else { - return 0; - } - } - return SWIG_UnpackData(++c,ptr,sz); -} - -#ifdef __cplusplus -} -#endif - -/* ----------------------------------------------------------------------------- - * luarun.swg - * - * This file contains the runtime support for Lua modules - * and includes code for managing global variables and pointer - * type checking. - * ----------------------------------------------------------------------------- */ - -#ifdef __cplusplus -extern "C" { -#endif - -#include "lua.h" -#include "lauxlib.h" -#include /* for malloc */ -#include /* for a few sanity tests */ - -/* ----------------------------------------------------------------------------- - * Lua flavors - * ----------------------------------------------------------------------------- */ - -#define SWIG_LUA_FLAVOR_LUA 1 -#define SWIG_LUA_FLAVOR_ELUA 2 -#define SWIG_LUA_FLAVOR_ELUAC 3 - -#if !defined(SWIG_LUA_TARGET) -# error SWIG_LUA_TARGET not defined -#endif - -#if defined(SWIG_LUA_ELUA_EMULATE) - -struct swig_elua_entry; - -typedef struct swig_elua_key { - int type; - union { - const char* strkey; - lua_Number numkey; - } key; -} swig_elua_key; - -typedef struct swig_elua_val { - int type; - union { - lua_Number number; - const struct swig_elua_entry *table; - const char *string; - lua_CFunction function; - struct { - char member; - long lvalue; - void *pvalue; - swig_type_info **ptype; - } userdata; - } value; -} swig_elua_val; - -typedef struct swig_elua_entry { - swig_elua_key key; - swig_elua_val value; -} swig_elua_entry; - -#define LSTRKEY(x) {LUA_TSTRING, {.strkey = x} } -#define LNUMKEY(x) {LUA_TNUMBER, {.numkey = x} } -#define LNILKEY {LUA_TNIL, {.strkey = 0} } - -#define LNUMVAL(x) {LUA_TNUMBER, {.number = x} } -#define LFUNCVAL(x) {LUA_TFUNCTION, {.function = x} } -#define LROVAL(x) {LUA_TTABLE, {.table = x} } -#define LNILVAL {LUA_TNIL, {.string = 0} } -#define LSTRVAL(x) {LUA_TSTRING, {.string = x} } - -#define LUA_REG_TYPE swig_elua_entry - -#define SWIG_LUA_ELUA_EMUL_METATABLE_KEY "__metatable" - -#define lua_pushrotable(L,p)\ - lua_newtable(L);\ - assert(p);\ - SWIG_Lua_elua_emulate_register(L,(swig_elua_entry*)(p)); - -#define SWIG_LUA_CONSTTAB_POINTER(B,C,D)\ - LSTRKEY(B), {LUA_TUSERDATA, { .userdata={0,0,(void*)(C),&D} } } - -#define SWIG_LUA_CONSTTAB_BINARY(B,S,C,D)\ - LSTRKEY(B), {LUA_TUSERDATA, { .userdata={1,S,(void*)(C),&D} } } -#endif - -#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC) -# define SWIG_LUA_CONSTTAB_INT(B, C) LSTRKEY(B), LNUMVAL(C) -# define SWIG_LUA_CONSTTAB_FLOAT(B, C) LSTRKEY(B), LNUMVAL(C) -# define SWIG_LUA_CONSTTAB_STRING(B, C) LSTRKEY(B), LSTRVAL(C) -# define SWIG_LUA_CONSTTAB_CHAR(B, C) LSTRKEY(B), LNUMVAL(C) - /* Those two types of constants are not supported in elua */ - -#ifndef SWIG_LUA_CONSTTAB_POINTER -#warning eLua does not support pointers as constants. By default, nil will be used as value -#define SWIG_LUA_CONSTTAB_POINTER(B,C,D) LSTRKEY(B), LNILVAL -#endif - -#ifndef SWIG_LUA_CONSTTAB_BINARY -#warning eLua does not support pointers to member as constants. By default, nil will be used as value -#define SWIG_LUA_CONSTTAB_BINARY(B, S, C, D) LSTRKEY(B), LNILVAL -#endif -#else /* SWIG_LUA_FLAVOR_LUA */ -# define SWIG_LUA_CONSTTAB_INT(B, C) SWIG_LUA_INT, (char *)B, (long)C, 0, 0, 0 -# define SWIG_LUA_CONSTTAB_FLOAT(B, C) SWIG_LUA_FLOAT, (char *)B, 0, (double)C, 0, 0 -# define SWIG_LUA_CONSTTAB_STRING(B, C) SWIG_LUA_STRING, (char *)B, 0, 0, (void *)C, 0 -# define SWIG_LUA_CONSTTAB_CHAR(B, C) SWIG_LUA_CHAR, (char *)B, (long)C, 0, 0, 0 -# define SWIG_LUA_CONSTTAB_POINTER(B,C,D)\ - SWIG_LUA_POINTER, (char *)B, 0, 0, (void *)C, &D -# define SWIG_LUA_CONSTTAB_BINARY(B, S, C, D)\ - SWIG_LUA_BINARY, (char *)B, S, 0, (void *)C, &D -#endif - -#ifndef SWIG_LUA_ELUA_EMULATE -#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC) -# define LRO_STRVAL(v) {{.p = (char *) v}, LUA_TSTRING} -# define LSTRVAL LRO_STRVAL -#endif -#endif /* SWIG_LUA_ELUA_EMULATE*/ - -#ifndef SWIG_LUA_ELUA_EMULATE -#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC) - -#ifndef MIN_OPT_LEVEL -#define MIN_OPT_LEVEL 2 -#endif - -#include "lrodefs.h" -#include "lrotable.h" -#endif -#endif /* SWIG_LUA_ELUA_EMULATE*/ -/* ----------------------------------------------------------------------------- - * compatibility defines - * ----------------------------------------------------------------------------- */ - -/* History of Lua C API length functions: In Lua 5.0 (and before?) - there was "lua_strlen". In Lua 5.1, this was renamed "lua_objlen", - but a compatibility define of "lua_strlen" was added. In Lua 5.2, - this function was again renamed, to "lua_rawlen" (to emphasize that - it doesn't call the "__len" metamethod), and the compatibility - define of lua_strlen was removed. All SWIG uses have been updated - to "lua_rawlen", and we add our own defines of that here for older - versions of Lua. */ -#if !defined(LUA_VERSION_NUM) || LUA_VERSION_NUM < 501 -# define lua_rawlen lua_strlen -#elif LUA_VERSION_NUM == 501 -# define lua_rawlen lua_objlen -#endif - - -/* lua_pushglobaltable is the recommended "future-proof" way to get - the global table for Lua 5.2 and later. Here we define - lua_pushglobaltable ourselves for Lua versions before 5.2. */ -#if !defined(LUA_VERSION_NUM) || LUA_VERSION_NUM < 502 -# define lua_pushglobaltable(L) lua_pushvalue(L, LUA_GLOBALSINDEX) -#endif - -/* lua_absindex was introduced in Lua 5.2 */ -#if !defined(LUA_VERSION_NUM) || LUA_VERSION_NUM < 502 -# define lua_absindex(L,i) ((i)>0 || (i) <= LUA_REGISTRYINDEX ? (i) : lua_gettop(L) + (i) + 1) -#endif - -/* lua_rawsetp was introduced in Lua 5.2 */ -#if !defined(LUA_VERSION_NUM) || LUA_VERSION_NUM < 502 -#define lua_rawsetp(L,index,ptr)\ - lua_pushlightuserdata(L,(void*)(ptr));\ - lua_insert(L,-2);\ - lua_rawset(L,index); - -#define lua_rawgetp(L,index,ptr)\ - lua_pushlightuserdata(L,(void*)(ptr));\ - lua_rawget(L,index); - -#endif - -/* -------------------------------------------------------------------------- - * Helper functions for error handling - * -------------------------------------------------------------------------- */ - -/* Push the string STR on the Lua stack, like lua_pushstring, but - prefixed with the the location of the innermost Lua call-point - (as formated by luaL_where). */ -SWIGRUNTIME void -SWIG_Lua_pusherrstring (lua_State *L, const char *str) -{ - luaL_where (L, 1); - lua_pushstring (L, str); - lua_concat (L, 2); -} - -/* Push a formatted string generated from FMT and following args on - the Lua stack, like lua_pushfstring, but prefixed with the the - location of the innermost Lua call-point (as formated by luaL_where). */ -SWIGRUNTIME void -SWIG_Lua_pushferrstring (lua_State *L, const char *fmt, ...) -{ - va_list argp; - va_start(argp, fmt); - luaL_where(L, 1); - lua_pushvfstring(L, fmt, argp); - va_end(argp); - lua_concat(L, 2); -} - - -/* ----------------------------------------------------------------------------- - * global swig types - * ----------------------------------------------------------------------------- */ -/* Constant table */ -#define SWIG_LUA_INT 1 -#define SWIG_LUA_FLOAT 2 -#define SWIG_LUA_STRING 3 -#define SWIG_LUA_POINTER 4 -#define SWIG_LUA_BINARY 5 -#define SWIG_LUA_CHAR 6 - -/* Structure for variable linking table */ -typedef struct { - const char *name; - lua_CFunction get; - lua_CFunction set; -} swig_lua_var_info; - -#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC) -typedef const LUA_REG_TYPE swig_lua_method; -typedef const LUA_REG_TYPE swig_lua_const_info; -#else /* Normal lua */ -typedef luaL_Reg swig_lua_method; - -/* Constant information structure */ -typedef struct { - int type; - char *name; - long lvalue; - double dvalue; - void *pvalue; - swig_type_info **ptype; -} swig_lua_const_info; - -#endif - -typedef struct { - const char *name; - lua_CFunction getmethod; - lua_CFunction setmethod; -} swig_lua_attribute; - - -struct swig_lua_class; -/* Can be used to create namespaces. Currently used to wrap class static methods/variables/constants */ -typedef struct swig_lua_namespace { - const char *name; - swig_lua_method *ns_methods; - swig_lua_attribute *ns_attributes; - swig_lua_const_info *ns_constants; - struct swig_lua_class **ns_classes; - struct swig_lua_namespace **ns_namespaces; -} swig_lua_namespace; - -typedef struct swig_lua_class { - const char *name; /* Name that this class has in Lua */ - const char *fqname; /* Fully qualified name - Scope + class name */ - swig_type_info **type; - lua_CFunction constructor; - void (*destructor)(void *); - swig_lua_method *methods; - swig_lua_attribute *attributes; - swig_lua_namespace *cls_static; - swig_lua_method *metatable; /* 0 for -eluac */ - struct swig_lua_class **bases; - const char **base_names; -} swig_lua_class; - -/* this is the struct for wrapping all pointers in SwigLua -*/ -typedef struct { - swig_type_info *type; - int own; /* 1 if owned & must be destroyed */ - void *ptr; -} swig_lua_userdata; - -/* this is the struct for wrapping arbitrary packed binary data -(currently it is only used for member function pointers) -the data ordering is similar to swig_lua_userdata, but it is currently not possible -to tell the two structures apart within SWIG, other than by looking at the type -*/ -typedef struct { - swig_type_info *type; - int own; /* 1 if owned & must be destroyed */ - char data[1]; /* arbitary amount of data */ -} swig_lua_rawdata; - -/* Common SWIG API */ -#define SWIG_NewPointerObj(L, ptr, type, owner) SWIG_Lua_NewPointerObj(L, (void *)ptr, type, owner) -#define SWIG_ConvertPtr(L,idx, ptr, type, flags) SWIG_Lua_ConvertPtr(L,idx,ptr,type,flags) -#define SWIG_MustGetPtr(L,idx, type,flags, argnum,fnname) SWIG_Lua_MustGetPtr(L,idx, type,flags, argnum,fnname) -/* for C++ member pointers, ie, member methods */ -#define SWIG_ConvertMember(L, idx, ptr, sz, ty) SWIG_Lua_ConvertPacked(L, idx, ptr, sz, ty) -#define SWIG_NewMemberObj(L, ptr, sz, type) SWIG_Lua_NewPackedObj(L, ptr, sz, type) - -/* Runtime API */ -#define SWIG_GetModule(clientdata) SWIG_Lua_GetModule((lua_State*)(clientdata)) -#define SWIG_SetModule(clientdata, pointer) SWIG_Lua_SetModule((lua_State*) (clientdata), pointer) -#define SWIG_MODULE_CLIENTDATA_TYPE lua_State* - -/* Contract support */ -#define SWIG_contract_assert(expr, msg) \ - if (!(expr)) { SWIG_Lua_pusherrstring(L, (char *) msg); goto fail; } else - - -/* helper #defines */ -#define SWIG_fail {goto fail;} -#define SWIG_fail_arg(func_name,argnum,type) \ - {SWIG_Lua_pushferrstring(L,"Error in %s (arg %d), expected '%s' got '%s'",\ - func_name,argnum,type,SWIG_Lua_typename(L,argnum));\ - goto fail;} -#define SWIG_fail_ptr(func_name,argnum,type) \ - SWIG_fail_arg(func_name,argnum,(type && type->str)?type->str:"void*") -#define SWIG_check_num_args(func_name,a,b) \ - if (lua_gettop(L)b) \ - {SWIG_Lua_pushferrstring(L,"Error in %s expected %d..%d args, got %d",func_name,a,b,lua_gettop(L));\ - goto fail;} - - -#define SWIG_Lua_get_table(L,n) \ - (lua_pushstring(L, n), lua_rawget(L,-2)) - -#define SWIG_Lua_add_function(L,n,f) \ - (lua_pushstring(L, n), \ - lua_pushcfunction(L, f), \ - lua_rawset(L,-3)) - -#define SWIG_Lua_add_boolean(L,n,b) \ - (lua_pushstring(L, n), \ - lua_pushboolean(L, b), \ - lua_rawset(L,-3)) - -/* special helper for allowing 'nil' for usertypes */ -#define SWIG_isptrtype(L,I) (lua_isuserdata(L,I) || lua_isnil(L,I)) - -#ifdef __cplusplus -/* Special helper for member function pointers -it gets the address, casts it, then dereferences it */ -/*#define SWIG_mem_fn_as_voidptr(a) (*((char**)&(a))) */ -#endif - -/* storing/access of swig_module_info */ -SWIGRUNTIME swig_module_info * -SWIG_Lua_GetModule(lua_State *L) { - swig_module_info *ret = 0; - lua_pushstring(L,"swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME); - lua_rawget(L,LUA_REGISTRYINDEX); - if (lua_islightuserdata(L,-1)) - ret=(swig_module_info*)lua_touserdata(L,-1); - lua_pop(L,1); /* tidy */ - return ret; -} - -SWIGRUNTIME void -SWIG_Lua_SetModule(lua_State *L, swig_module_info *module) { - /* add this all into the Lua registry: */ - lua_pushstring(L,"swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME); - lua_pushlightuserdata(L,(void*)module); - lua_rawset(L,LUA_REGISTRYINDEX); -} - -/* ----------------------------------------------------------------------------- - * global variable support code: modules - * ----------------------------------------------------------------------------- */ - -/* this function is called when trying to set an immutable. -default action is to print an error. -This can removed with a compile flag SWIGLUA_IGNORE_SET_IMMUTABLE */ -SWIGINTERN int SWIG_Lua_set_immutable(lua_State *L) -{ -/* there should be 1 param passed in: the new value */ -#ifndef SWIGLUA_IGNORE_SET_IMMUTABLE - lua_pop(L,1); /* remove it */ - luaL_error(L,"This variable is immutable"); -#endif - return 0; /* should not return anything */ -} - -#ifdef SWIG_LUA_ELUA_EMULATE - -SWIGRUNTIME void SWIG_Lua_NewPointerObj(lua_State *L,void *ptr,swig_type_info *type, int own); -SWIGRUNTIME void SWIG_Lua_NewPackedObj(lua_State *L,void *ptr,size_t size,swig_type_info *type); -static int swig_lua_elua_emulate_unique_key; - -/* This function emulates eLua rotables behaviour. It loads a rotable definition into the usual lua table. */ -SWIGINTERN void SWIG_Lua_elua_emulate_register(lua_State *L, const swig_elua_entry *table) -{ - int i, table_parsed, parsed_tables_array, target_table; - assert(lua_istable(L,-1)); - target_table = lua_gettop(L); - /* Get the registry where we put all parsed tables to avoid loops */ - lua_rawgetp(L, LUA_REGISTRYINDEX, &swig_lua_elua_emulate_unique_key); - if(lua_isnil(L,-1)) { - lua_pop(L,1); - lua_newtable(L); - lua_pushvalue(L,-1); - lua_rawsetp(L,LUA_REGISTRYINDEX,(void*)(&swig_lua_elua_emulate_unique_key)); - } - parsed_tables_array = lua_gettop(L); - lua_pushvalue(L,target_table); - lua_rawsetp(L, parsed_tables_array, table); - table_parsed = 0; - const int SWIGUNUSED pairs_start = lua_gettop(L); - for(i = 0;table[i].key.type != LUA_TNIL || table[i].value.type != LUA_TNIL;i++) - { - const swig_elua_entry *entry = table + i; - int is_metatable = 0; - switch(entry->key.type) { - case LUA_TSTRING: - lua_pushstring(L,entry->key.key.strkey); - if(strcmp(entry->key.key.strkey, SWIG_LUA_ELUA_EMUL_METATABLE_KEY) == 0) - is_metatable = 1; - break; - case LUA_TNUMBER: - lua_pushnumber(L,entry->key.key.numkey); - break; - case LUA_TNIL: - lua_pushnil(L); - break; - default: - assert(0); - } - switch(entry->value.type) { - case LUA_TSTRING: - lua_pushstring(L,entry->value.value.string); - break; - case LUA_TNUMBER: - lua_pushnumber(L,entry->value.value.number); - break; - case LUA_TFUNCTION: - lua_pushcfunction(L,entry->value.value.function); - break; - case LUA_TTABLE: - lua_rawgetp(L,parsed_tables_array, entry->value.value.table); - table_parsed = !lua_isnil(L,-1); - if(!table_parsed) { - lua_pop(L,1); /*remove nil */ - lua_newtable(L); - SWIG_Lua_elua_emulate_register(L,entry->value.value.table); - } - if(is_metatable) { - assert(lua_istable(L,-1)); - lua_pushvalue(L,-1); - lua_setmetatable(L,target_table); - } - - break; - case LUA_TUSERDATA: - if(entry->value.value.userdata.member) - SWIG_NewMemberObj(L,entry->value.value.userdata.pvalue, - entry->value.value.userdata.lvalue, - *(entry->value.value.userdata.ptype)); - else - SWIG_NewPointerObj(L,entry->value.value.userdata.pvalue, - *(entry->value.value.userdata.ptype),0); - break; - case LUA_TNIL: - lua_pushnil(L); - break; - default: - assert(0); - } - assert(lua_gettop(L) == pairs_start + 2); - lua_rawset(L,target_table); - } - lua_pop(L,1); /* Removing parsed tables storage */ - assert(lua_gettop(L) == target_table); -} - -SWIGINTERN void SWIG_Lua_elua_emulate_register_clear(lua_State *L) -{ - lua_pushnil(L); - lua_rawsetp(L, LUA_REGISTRYINDEX, &swig_lua_elua_emulate_unique_key); -} - -SWIGINTERN void SWIG_Lua_get_class_registry(lua_State *L); - -SWIGINTERN int SWIG_Lua_emulate_elua_getmetatable(lua_State *L) -{ - SWIG_check_num_args("getmetatable(SWIG eLua emulation)", 1, 1); - SWIG_Lua_get_class_registry(L); - lua_getfield(L,-1,"lua_getmetatable"); - lua_remove(L,-2); /* remove the registry*/ - assert(!lua_isnil(L,-1)); - lua_pushvalue(L,1); - assert(lua_gettop(L) == 3); /* object | function | object again */ - lua_call(L,1,1); - if(!lua_isnil(L,-1)) /*There is an ordinary metatable */ - return 1; - /*if it is a table, then emulate elua behaviour - check for __metatable attribute of a table*/ - assert(lua_gettop(L) == 2); - if(lua_istable(L,-2)) { - lua_pop(L,1); /*remove the nil*/ - lua_getfield(L,-1, SWIG_LUA_ELUA_EMUL_METATABLE_KEY); - } - assert(lua_gettop(L) == 2); - return 1; - -fail: - lua_error(L); - return 0; -} - -SWIGINTERN void SWIG_Lua_emulate_elua_swap_getmetatable(lua_State *L) -{ - SWIG_Lua_get_class_registry(L); - lua_pushglobaltable(L); - lua_pushstring(L,"lua_getmetatable"); - lua_getfield(L,-2,"getmetatable"); - assert(!lua_isnil(L,-1)); - lua_rawset(L,-4); - lua_pushstring(L, "getmetatable"); - lua_pushcfunction(L, SWIG_Lua_emulate_elua_getmetatable); - lua_rawset(L,-3); - lua_pop(L,2); - -} -/* END OF REMOVE */ - -#endif -/* ----------------------------------------------------------------------------- - * global variable support code: namespaces and modules (which are the same thing) - * ----------------------------------------------------------------------------- */ - -SWIGINTERN int SWIG_Lua_namespace_get(lua_State *L) -{ -/* there should be 2 params passed in - (1) table (not the meta table) - (2) string name of the attribute -*/ - assert(lua_istable(L,-2)); /* just in case */ - lua_getmetatable(L,-2); - assert(lua_istable(L,-1)); - SWIG_Lua_get_table(L,".get"); /* find the .get table */ - assert(lua_istable(L,-1)); - /* look for the key in the .get table */ - lua_pushvalue(L,2); /* key */ - lua_rawget(L,-2); - lua_remove(L,-2); /* stack tidy, remove .get table */ - if (lua_iscfunction(L,-1)) - { /* found it so call the fn & return its value */ - lua_call(L,0,1); /* 1 value in (userdata),1 out (result) */ - lua_remove(L,-2); /* stack tidy, remove metatable */ - return 1; - } - lua_pop(L,1); /* remove whatever was there */ - /* ok, so try the .fn table */ - SWIG_Lua_get_table(L,".fn"); /* find the .get table */ - assert(lua_istable(L,-1)); /* just in case */ - lua_pushvalue(L,2); /* key */ - lua_rawget(L,-2); /* look for the fn */ - lua_remove(L,-2); /* stack tidy, remove .fn table */ - if (lua_isfunction(L,-1)) /* note: whether it's a C function or lua function */ - { /* found it so return the fn & let lua call it */ - lua_remove(L,-2); /* stack tidy, remove metatable */ - return 1; - } - lua_pop(L,1); /* remove whatever was there */ - return 0; -} - -SWIGINTERN int SWIG_Lua_namespace_set(lua_State *L) -{ -/* there should be 3 params passed in - (1) table (not the meta table) - (2) string name of the attribute - (3) any for the new value -*/ - - assert(lua_istable(L,1)); - lua_getmetatable(L,1); /* get the meta table */ - assert(lua_istable(L,-1)); - - SWIG_Lua_get_table(L,".set"); /* find the .set table */ - if (lua_istable(L,-1)) - { - /* look for the key in the .set table */ - lua_pushvalue(L,2); /* key */ - lua_rawget(L,-2); - if (lua_iscfunction(L,-1)) - { /* found it so call the fn & return its value */ - lua_pushvalue(L,3); /* value */ - lua_call(L,1,0); - return 0; - } - lua_pop(L,1); /* remove the value */ - } - lua_pop(L,1); /* remove the value .set table */ - lua_pop(L,1); /* remote metatable */ - lua_rawset(L,-3); - return 0; -} - -#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA) /* In elua this is useless */ -SWIGINTERN void SWIG_Lua_InstallConstants(lua_State *L, swig_lua_const_info constants[]); /* forward declaration */ -SWIGINTERN void SWIG_Lua_add_variable(lua_State *L,const char *name,lua_CFunction getFn,lua_CFunction setFn); /* forward declaration */ -SWIGINTERN void SWIG_Lua_class_register(lua_State *L,swig_lua_class *clss); - -/* helper function - register namespace methods and attributes into namespace */ -SWIGINTERN int SWIG_Lua_add_namespace_details(lua_State *L, swig_lua_namespace *ns) -{ - int i; - /* There must be namespace table (not metatable) at the top of the stack */ - assert(lua_istable(L,-1)); - SWIG_Lua_InstallConstants(L, ns->ns_constants); - - /* add methods to the namespace/module table */ - for(i=0;ns->ns_methods[i].name;i++){ - SWIG_Lua_add_function(L,ns->ns_methods[i].name,ns->ns_methods[i].func); - } - lua_getmetatable(L,-1); - - /* add fns */ - for(i=0;ns->ns_attributes[i].name;i++){ - SWIG_Lua_add_variable(L,ns->ns_attributes[i].name,ns->ns_attributes[i].getmethod,ns->ns_attributes[i].setmethod); - } - - /* clear stack - remove metatble */ - lua_pop(L,1); - return 0; -} - -/* Register all classes in the namespace */ -SWIGINTERN void SWIG_Lua_add_namespace_classes(lua_State *L, swig_lua_namespace *ns) -{ - swig_lua_class **classes; - - /* There must be a module/namespace table at the top of the stack */ - assert(lua_istable(L,-1)); - - classes = ns->ns_classes; - - if( classes != 0 ) { - while(*classes != 0) { - SWIG_Lua_class_register(L, *classes); - classes++; - } - } -} - -/* Helper function. Creates namespace table and adds it to module table - if 'reg' is true, then will register namespace table to parent one (must be on top of the stack - when function is called). - Function always returns newly registered table on top of the stack. -*/ -SWIGINTERN void SWIG_Lua_namespace_register(lua_State *L, swig_lua_namespace *ns, int reg) -{ - swig_lua_namespace **sub_namespace; - /* 1 argument - table on the top of the stack */ - const int SWIGUNUSED begin = lua_gettop(L); - assert(lua_istable(L,-1)); /* just in case. This is supposed to be module table or parent namespace table */ - lua_checkstack(L,5); - lua_newtable(L); /* namespace itself */ - lua_newtable(L); /* metatable for namespace */ - - /* add a table called ".get" */ - lua_pushstring(L,".get"); - lua_newtable(L); - lua_rawset(L,-3); - /* add a table called ".set" */ - lua_pushstring(L,".set"); - lua_newtable(L); - lua_rawset(L,-3); - /* add a table called ".fn" */ - lua_pushstring(L,".fn"); - lua_newtable(L); - lua_rawset(L,-3); - - /* add accessor fns for using the .get,.set&.fn */ - SWIG_Lua_add_function(L,"__index",SWIG_Lua_namespace_get); - SWIG_Lua_add_function(L,"__newindex",SWIG_Lua_namespace_set); - - lua_setmetatable(L,-2); /* set metatable */ - - /* Register all functions, variables etc */ - SWIG_Lua_add_namespace_details(L,ns); - /* Register classes */ - SWIG_Lua_add_namespace_classes(L,ns); - - sub_namespace = ns->ns_namespaces; - if( sub_namespace != 0) { - while(*sub_namespace != 0) { - SWIG_Lua_namespace_register(L, *sub_namespace, 1); - lua_pop(L,1); /* removing sub-namespace table */ - sub_namespace++; - } - } - - if (reg) { - lua_pushstring(L,ns->name); - lua_pushvalue(L,-2); - lua_rawset(L,-4); /* add namespace to module table */ - } - assert(lua_gettop(L) == begin+1); -} -#endif /* SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA */ - -/* ----------------------------------------------------------------------------- - * global variable support code: classes - * ----------------------------------------------------------------------------- */ - -SWIGINTERN void SWIG_Lua_get_class_metatable(lua_State *L,const char *cname); - -typedef int (*swig_lua_base_iterator_func)(lua_State*,swig_type_info*, int, int *ret); - -SWIGINTERN int SWIG_Lua_iterate_bases(lua_State *L, swig_type_info * SWIGUNUSED swig_type, - int first_arg, swig_lua_base_iterator_func func, int *const ret) -{ - /* first_arg - position of the object in stack. Everything that is above are arguments - * and is passed to every evocation of the func */ - int last_arg = lua_gettop(L);/* position of last argument */ - int original_metatable = last_arg + 1; - size_t bases_count; - int result = SWIG_ERROR; - int bases_table; - (void)swig_type; - lua_getmetatable(L,first_arg); - - /* initialise base search */ -#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA) - SWIG_Lua_get_table(L,".bases"); - assert(lua_istable(L,-1)); - bases_count = lua_rawlen(L,-1); - bases_table = lua_gettop(L); -#else - /* In elua .bases table doesn't exist. Use table from swig_lua_class */ - (void)bases_table; - assert(swig_type!=0); - swig_module_info *module=SWIG_GetModule(L); - swig_lua_class **bases= ((swig_lua_class*)(swig_type->clientdata))->bases; - const char **base_names= ((swig_lua_class*)(swig_type->clientdata))->base_names; - bases_count = 0; - for(;base_names[bases_count]; - bases_count++);/* get length of bases */ -#endif - - if(ret) - *ret = 0; - if(bases_count>0) - { - int to_remove; - size_t i; - int j; - int subcall_last_arg; - int subcall_first_arg = lua_gettop(L) + 1;/* Here a copy of first_arg and arguments begin */ - int valid = 1; - swig_type_info *base_swig_type = 0; - for(j=first_arg;j<=last_arg;j++) - lua_pushvalue(L,j); - subcall_last_arg = lua_gettop(L); - - /* Trick: temporarily replacing original metatable with metatable for base class and call getter */ - for(i=0;ifqname); - base_swig_type = SWIG_TypeQueryModule(module,module,base_names[i]); - assert(base_swig_type != 0); - } -#endif - - if(!valid) - continue; - assert(lua_isuserdata(L, subcall_first_arg)); - assert(lua_istable(L,-1)); - lua_setmetatable(L,subcall_first_arg); /* Set new metatable */ - assert(lua_gettop(L) == subcall_last_arg); - result = func(L, base_swig_type,subcall_first_arg, ret); /* Forward call */ - if(result != SWIG_ERROR) { - break; - } - } - /* Restore original metatable */ - lua_pushvalue(L,original_metatable); - lua_setmetatable(L,first_arg); - /* Clear - remove everything between last_arg and subcall_last_arg including */ - to_remove = subcall_last_arg - last_arg; - for(j=0;jtype; - result = SWIG_Lua_class_do_get(L,type,1,&ret); - if(result == SWIG_OK) - return ret; - - result = SWIG_Lua_class_do_get_item(L,type,1,&ret); - if(result == SWIG_OK) - return ret; - - return 0; -} - -/* helper for the class.set method, performs the lookup of class attributes - * It returns error code. Number of function return values is passed inside 'ret' - */ -SWIGINTERN int SWIG_Lua_class_do_set(lua_State *L, swig_type_info *type, int first_arg, int *ret) -{ -/* there should be 3 params passed in - (1) table (not the meta table) - (2) string name of the attribute - (3) any for the new value - */ - - int bases_search_result; - int substack_start = lua_gettop(L) - 3; - lua_checkstack(L,5); - assert(lua_isuserdata(L,substack_start+1)); /* just in case */ - lua_getmetatable(L,substack_start+1); /* get the meta table */ - assert(lua_istable(L,-1)); /* just in case */ - if(ret) - *ret = 0; /* it is setter - number of return values is always 0 */ - - SWIG_Lua_get_table(L,".set"); /* find the .set table */ - if (lua_istable(L,-1)) - { - /* look for the key in the .set table */ - lua_pushvalue(L,substack_start+2); /* key */ - lua_rawget(L,-2); - lua_remove(L,-2); /* tidy stack, remove .set table */ - if (lua_iscfunction(L,-1)) - { /* found it so call the fn & return its value */ - lua_pushvalue(L,substack_start+1); /* userdata */ - lua_pushvalue(L,substack_start+3); /* value */ - lua_call(L,2,0); - lua_remove(L,substack_start+4); /*remove metatable*/ - return SWIG_OK; - } - lua_pop(L,1); /* remove the value */ - } else { - lua_pop(L,1); /* remove the answer for .set table request*/ - } - /* NEW: looks for the __setitem() fn - this is a user provided set fn */ - SWIG_Lua_get_table(L,"__setitem"); /* find the fn */ - if (lua_iscfunction(L,-1)) /* if its there */ - { /* found it so call the fn & return its value */ - lua_pushvalue(L,substack_start+1); /* the userdata */ - lua_pushvalue(L,substack_start+2); /* the parameter */ - lua_pushvalue(L,substack_start+3); /* the value */ - lua_call(L,3,0); /* 3 values in ,0 out */ - lua_remove(L,-2); /* stack tidy, remove metatable */ - return SWIG_OK; - } - lua_pop(L,1); /* remove value */ - - lua_pop(L,1); /* remove metatable */ - /* Search among bases */ - bases_search_result = SWIG_Lua_iterate_bases(L,type,first_arg,SWIG_Lua_class_do_set,ret); - if(ret) - assert(*ret == 0); - assert(lua_gettop(L) == substack_start + 3); - return bases_search_result; -} - -/* This is the actual method exported to Lua. It calls SWIG_Lua_class_do_set and correctly - * handles return values. - */ -SWIGINTERN int SWIG_Lua_class_set(lua_State *L) -{ -/* There should be 3 params passed in - (1) table (not the meta table) - (2) string name of the attribute - (3) any for the new value - */ - int ret = 0; - int result; - swig_lua_userdata *usr; - swig_type_info *type; - assert(lua_isuserdata(L,1)); - usr=(swig_lua_userdata*)lua_touserdata(L,1); /* get data */ - type = usr->type; - result = SWIG_Lua_class_do_set(L,type,1,&ret); - if(result != SWIG_OK) { - SWIG_Lua_pushferrstring(L,"Assignment not possible. No setter/member with this name. For custom assignments implement __setitem method."); - lua_error(L); - } else { - assert(ret==0); - } - return 0; -} - -/* the class.destruct method called by the interpreter */ -SWIGINTERN int SWIG_Lua_class_destruct(lua_State *L) -{ -/* there should be 1 params passed in - (1) userdata (not the meta table) */ - swig_lua_userdata *usr; - swig_lua_class *clss; - assert(lua_isuserdata(L,-1)); /* just in case */ - usr=(swig_lua_userdata*)lua_touserdata(L,-1); /* get it */ - /* if must be destroyed & has a destructor */ - if (usr->own) /* if must be destroyed */ - { - clss=(swig_lua_class*)usr->type->clientdata; /* get the class */ - if (clss && clss->destructor) /* there is a destroy fn */ - { - clss->destructor(usr->ptr); /* bye bye */ - } - } - return 0; -} - -/* the class.__tostring method called by the interpreter and print */ -SWIGINTERN int SWIG_Lua_class_tostring(lua_State *L) -{ -/* there should be 1 param passed in - (1) userdata (not the metatable) */ - const char *className; - void* userData; - assert(lua_isuserdata(L,1)); /* just in case */ - userData = lua_touserdata(L,1); /* get the userdata address for later */ - lua_getmetatable(L,1); /* get the meta table */ - assert(lua_istable(L,-1)); /* just in case */ - - lua_getfield(L, -1, ".type"); - className = lua_tostring(L, -1); - - lua_pushfstring(L, "<%s userdata: %p>", className, userData); - return 1; -} - -/* to manually disown some userdata */ -SWIGINTERN int SWIG_Lua_class_disown(lua_State *L) -{ -/* there should be 1 params passed in - (1) userdata (not the meta table) */ - swig_lua_userdata *usr; - assert(lua_isuserdata(L,-1)); /* just in case */ - usr=(swig_lua_userdata*)lua_touserdata(L,-1); /* get it */ - - usr->own = 0; /* clear our ownership */ - return 0; -} - -/* lua callable function to compare userdata's value -the issue is that two userdata may point to the same thing -but to lua, they are different objects */ -SWIGRUNTIME int SWIG_Lua_class_equal(lua_State *L) -{ - int result; - swig_lua_userdata *usr1,*usr2; - if (!lua_isuserdata(L,1) || !lua_isuserdata(L,2)) /* just in case */ - return 0; /* nil reply */ - usr1=(swig_lua_userdata*)lua_touserdata(L,1); /* get data */ - usr2=(swig_lua_userdata*)lua_touserdata(L,2); /* get data */ - /*result=(usr1->ptr==usr2->ptr && usr1->type==usr2->type); only works if type is the same*/ - result=(usr1->ptr==usr2->ptr); - lua_pushboolean(L,result); - return 1; -} - -/* populate table at the top of the stack with metamethods that ought to be inherited */ -SWIGINTERN void SWIG_Lua_populate_inheritable_metamethods(lua_State *L) -{ - SWIG_Lua_add_boolean(L, "__add", 1); - SWIG_Lua_add_boolean(L, "__sub", 1); - SWIG_Lua_add_boolean(L, "__mul", 1); - SWIG_Lua_add_boolean(L, "__div", 1); - SWIG_Lua_add_boolean(L, "__mod", 1); - SWIG_Lua_add_boolean(L, "__pow", 1); - SWIG_Lua_add_boolean(L, "__unm", 1); - SWIG_Lua_add_boolean(L, "__len", 1 ); - SWIG_Lua_add_boolean(L, "__concat", 1 ); - SWIG_Lua_add_boolean(L, "__eq", 1); - SWIG_Lua_add_boolean(L, "__lt", 1); - SWIG_Lua_add_boolean(L, "__le", 1); - SWIG_Lua_add_boolean(L, "__call", 1); - SWIG_Lua_add_boolean(L, "__tostring", 1); - SWIG_Lua_add_boolean(L, "__gc", 0); -} - -/* creates the swig registry */ -SWIGINTERN void SWIG_Lua_create_class_registry(lua_State *L) -{ - /* create main SWIG registry table */ - lua_pushstring(L,"SWIG"); - lua_newtable(L); - /* populate it with some predefined data */ - - /* .library table. Placeholder */ - lua_pushstring(L,".library"); - lua_newtable(L); - { - /* list of metamethods that class inherits from its bases */ - lua_pushstring(L,"inheritable_metamethods"); - lua_newtable(L); - /* populate with list of metamethods */ - SWIG_Lua_populate_inheritable_metamethods(L); - lua_rawset(L,-3); - } - lua_rawset(L,-3); - - lua_rawset(L,LUA_REGISTRYINDEX); -} - -/* gets the swig registry (or creates it) */ -SWIGINTERN void SWIG_Lua_get_class_registry(lua_State *L) -{ - /* add this all into the swig registry: */ - lua_pushstring(L,"SWIG"); - lua_rawget(L,LUA_REGISTRYINDEX); /* get the registry */ - if (!lua_istable(L,-1)) /* not there */ - { /* must be first time, so add it */ - lua_pop(L,1); /* remove the result */ - SWIG_Lua_create_class_registry(L); - /* then get it */ - lua_pushstring(L,"SWIG"); - lua_rawget(L,LUA_REGISTRYINDEX); - } -} - -SWIGINTERN void SWIG_Lua_get_inheritable_metamethods(lua_State *L) -{ - SWIG_Lua_get_class_registry(L); - lua_pushstring(L, ".library"); - lua_rawget(L,-2); - assert( !lua_isnil(L,-1) ); - lua_pushstring(L, "inheritable_metamethods"); - lua_rawget(L,-2); - - /* Remove class registry and library table */ - lua_remove(L,-2); - lua_remove(L,-2); -} - -/* Helper function to get the classes metatable from the register */ -SWIGINTERN void SWIG_Lua_get_class_metatable(lua_State *L,const char *cname) -{ - SWIG_Lua_get_class_registry(L); /* get the registry */ - lua_pushstring(L,cname); /* get the name */ - lua_rawget(L,-2); /* get it */ - lua_remove(L,-2); /* tidy up (remove registry) */ -} - -/* Set up the base classes pointers. -Each class structure has a list of pointers to the base class structures. -This function fills them. -It cannot be done at compile time, as this will not work with hireachies -spread over more than one swig file. -Therefore it must be done at runtime, querying the SWIG type system. -*/ -SWIGINTERN void SWIG_Lua_init_base_class(lua_State *L,swig_lua_class *clss) -{ - int i=0; - swig_module_info *module=SWIG_GetModule(L); - for(i=0;clss->base_names[i];i++) - { - if (clss->bases[i]==0) /* not found yet */ - { - /* lookup and cache the base class */ - swig_type_info *info = SWIG_TypeQueryModule(module,module,clss->base_names[i]); - if (info) clss->bases[i] = (swig_lua_class *) info->clientdata; - } - } -} - -#if defined(SWIG_LUA_SQUASH_BASES) && (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA) -/* Merges two tables */ -SWIGINTERN void SWIG_Lua_merge_tables_by_index(lua_State *L, int target, int source) -{ - /* iterating */ - lua_pushnil(L); - while (lua_next(L,source) != 0) { - /* -1 - value, -2 - index */ - /* have to copy to assign */ - lua_pushvalue(L,-2); /* copy of index */ - lua_pushvalue(L,-2); /* copy of value */ - lua_rawset(L, target); - lua_pop(L,1); - /* only key is left */ - } -} - -/* Merges two tables with given name. original - index of target metatable, base - index of source metatable */ -SWIGINTERN void SWIG_Lua_merge_tables(lua_State *L, const char* name, int original, int base) -{ - /* push original[name], then base[name] */ - lua_pushstring(L,name); - lua_rawget(L,original); - int original_table = lua_gettop(L); - lua_pushstring(L,name); - lua_rawget(L,base); - int base_table = lua_gettop(L); - SWIG_Lua_merge_tables_by_index(L, original_table, base_table); - /* clearing stack */ - lua_pop(L,2); -} - -/* Function takes all symbols from base and adds it to derived class. It's just a helper. */ -SWIGINTERN void SWIG_Lua_class_squash_base(lua_State *L, swig_lua_class *base_cls) -{ - /* There is one parameter - original, i.e. 'derived' class metatable */ - assert(lua_istable(L,-1)); - int original = lua_gettop(L); - SWIG_Lua_get_class_metatable(L,base_cls->fqname); - int base = lua_gettop(L); - SWIG_Lua_merge_tables(L, ".fn", original, base ); - SWIG_Lua_merge_tables(L, ".set", original, base ); - SWIG_Lua_merge_tables(L, ".get", original, base ); - lua_pop(L,1); -} - -/* Function squashes all symbols from 'clss' bases into itself */ -SWIGINTERN void SWIG_Lua_class_squash_bases(lua_State *L, swig_lua_class *clss) -{ - int i; - SWIG_Lua_get_class_metatable(L,clss->fqname); - for(i=0;clss->base_names[i];i++) - { - if (clss->bases[i]==0) /* Somehow it's not found. Skip it */ - continue; - /* Thing is: all bases are already registered. Thus they have already executed - * this function. So we just need to squash them into us, because their bases - * are already squashed into them. No need for recursion here! - */ - SWIG_Lua_class_squash_base(L, clss->bases[i]); - } - lua_pop(L,1); /*tidy stack*/ -} -#endif - -#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA) /* In elua this is useless */ -/* helper add a variable to a registered class */ -SWIGINTERN void SWIG_Lua_add_variable(lua_State *L,const char *name,lua_CFunction getFn,lua_CFunction setFn) -{ - assert(lua_istable(L,-1)); /* just in case */ - SWIG_Lua_get_table(L,".get"); /* find the .get table */ - assert(lua_istable(L,-1)); /* just in case */ - SWIG_Lua_add_function(L,name,getFn); - lua_pop(L,1); /* tidy stack (remove table) */ - if (setFn) - { - SWIG_Lua_get_table(L,".set"); /* find the .set table */ - assert(lua_istable(L,-1)); /* just in case */ - SWIG_Lua_add_function(L,name,setFn); - lua_pop(L,1); /* tidy stack (remove table) */ - } -} - -/* helper to recursively add class static details (static attributes, operations and constants) */ -SWIGINTERN void SWIG_Lua_add_class_static_details(lua_State *L, swig_lua_class *clss) -{ - int i = 0; - /* The class namespace table must be on the top of the stack */ - assert(lua_istable(L,-1)); - /* call all the base classes first: we can then override these later: */ - for(i=0;clss->bases[i];i++) - { - SWIG_Lua_add_class_static_details(L,clss->bases[i]); - } - - SWIG_Lua_add_namespace_details(L, clss->cls_static); -} - -SWIGINTERN void SWIG_Lua_add_class_user_metamethods(lua_State *L, swig_lua_class *clss); /* forward declaration */ - -/* helper to recursively add class details (attributes & operations) */ -SWIGINTERN void SWIG_Lua_add_class_instance_details(lua_State *L, swig_lua_class *clss) -{ - int i; - size_t bases_count = 0; - /* Add bases to .bases table */ - SWIG_Lua_get_table(L,".bases"); - assert(lua_istable(L,-1)); /* just in case */ - for(i=0;clss->bases[i];i++) - { - SWIG_Lua_get_class_metatable(L,clss->bases[i]->fqname); - /* Base class must be already registered */ - assert(lua_istable(L,-1)); - lua_rawseti(L,-2,i+1); /* In lua indexing starts from 1 */ - bases_count++; - } - assert(lua_rawlen(L,-1) == bases_count); - lua_pop(L,1); /* remove .bases table */ - /* add attributes */ - for(i=0;clss->attributes[i].name;i++){ - SWIG_Lua_add_variable(L,clss->attributes[i].name,clss->attributes[i].getmethod,clss->attributes[i].setmethod); - } - /* add methods to the metatable */ - SWIG_Lua_get_table(L,".fn"); /* find the .fn table */ - assert(lua_istable(L,-1)); /* just in case */ - for(i=0;clss->methods[i].name;i++){ - SWIG_Lua_add_function(L,clss->methods[i].name,clss->methods[i].func); - } - lua_pop(L,1); /* tidy stack (remove table) */ - /* add operator overloads - This adds methods from metatable array to metatable. Can mess up garbage - collectind if someone defines __gc method - */ - if(clss->metatable) { - for(i=0;clss->metatable[i].name;i++) { - SWIG_Lua_add_function(L,clss->metatable[i].name,clss->metatable[i].func); - } - } - -#if !defined(SWIG_LUA_SQUASH_BASES) - /* Adding metamethods that are defined in base classes. If bases were squashed - * then it is obviously unnecessary - */ - SWIG_Lua_add_class_user_metamethods(L, clss); -#endif -} - -/* Helpers to add user defined class metamedhods - __add, __sub etc. The helpers are needed - for the following issue: Lua runtime checks for metamethod existence with rawget function - ignoring our SWIG-provided __index and __newindex functions. Thus our inheritance-aware method - search algorithm doesn't work in such case. (Not to say that Lua runtime queries metamethod directly - in metatable and not in object). - Current solution is this: if somewhere in hierarchy metamethod __x is defined, then all descendants - are automatically given a special proxy __x that calls the real __x method. - Obvious idea - to copy __x instead of creating __x-proxy is wrong because if someone changes __x in runtime, - those changes must be reflected in all descendants. -*/ - -SWIGRUNTIME int SWIG_Lua_resolve_metamethod(lua_State *L); /*forward declaration*/ - -/* The real function that resolves a metamethod. - * Function searches given class and all it's bases(recursively) for first instance of something that is - * not equal to SWIG_Lua_resolve_metatmethod. (Almost always this 'something' is actual metamethod implementation - * and it is a SWIG-generated C function.). It returns value on the top of the L and there is no garbage below the - * answer. - * Returns 1 if found, 0 otherwise. - * clss is class which metatable we will search for method - * metamethod_name_idx is index in L where metamethod name (as string) lies - * skip_check allows to skip searching metamethod in givel clss and immideatelly go to searching in bases. skip_check - * is not caried to subsequent recursive calls - false is always passed. It is set to true only at first call from - * SWIG_Lua_resolve_metamethod - * */ -SWIGINTERN int SWIG_Lua_do_resolve_metamethod(lua_State *L, const swig_lua_class *clss, int metamethod_name_idx, - int skip_check) -{ - /* This function is called recursively */ - int result = 0; - int i = 0; - - if (!skip_check) { - SWIG_Lua_get_class_metatable(L, clss->fqname); - lua_pushvalue(L, metamethod_name_idx); - lua_rawget(L,-2); - /* If this is cfunction and it is equal to SWIG_Lua_resolve_metamethod then - * this isn't the function we are looking for :) - * lua_tocfunction will return NULL if not cfunction - */ - if (!lua_isnil(L,-1) && lua_tocfunction(L,-1) != SWIG_Lua_resolve_metamethod ) { - lua_remove(L,-2); /* removing class metatable */ - return 1; - } - lua_pop(L,2); /* remove class metatable and query result */ - } - - /* Forwarding calls to bases */ - for(i=0;clss->bases[i];i++) - { - result = SWIG_Lua_do_resolve_metamethod(L, clss->bases[i], metamethod_name_idx, 0); - if (result) - break; - } - - return result; -} - -/* The proxy function for metamethod. All parameters are passed as cclosure. Searches for actual method - * and calls it */ -SWIGRUNTIME int SWIG_Lua_resolve_metamethod(lua_State *L) -{ - int numargs; - int metamethod_name_idx; - const swig_lua_class* clss; - int result; - - lua_checkstack(L,5); - numargs = lua_gettop(L); /* number of arguments to pass to actual metamethod */ - - /* Get upvalues from closure */ - lua_pushvalue(L, lua_upvalueindex(1)); /*Get function name*/ - metamethod_name_idx = lua_gettop(L); - - lua_pushvalue(L, lua_upvalueindex(2)); - clss = (const swig_lua_class*)(lua_touserdata(L,-1)); - lua_pop(L,1); /* remove lightuserdata with clss from stack */ - - /* Actual work */ - result = SWIG_Lua_do_resolve_metamethod(L, clss, metamethod_name_idx, 1); - if (!result) { - SWIG_Lua_pushferrstring(L,"The metamethod proxy is set, but it failed to find actual metamethod. Memory corruption is most likely explanation."); - lua_error(L); - return 0; - } - - lua_remove(L,-2); /* remove metamethod key */ - lua_insert(L,1); /* move function to correct position */ - lua_call(L, numargs, LUA_MULTRET); - return lua_gettop(L); /* return all results */ -} - - -/* If given metamethod must be present in given class, then creates appropriate proxy - * Returns 1 if successfully added, 0 if not added because no base class has it, -1 - * if method is defined in the class metatable itself - */ -SWIGINTERN int SWIG_Lua_add_class_user_metamethod(lua_State *L, swig_lua_class *clss, const int metatable_index) -{ - int key_index; - int success = 0; - int i = 0; - - /* metamethod name - on the top of the stack */ - assert(lua_isstring(L,-1)); - - key_index = lua_gettop(L); - - /* Check whether method is already defined in metatable */ - lua_pushvalue(L,key_index); /* copy of the key */ - lua_gettable(L,metatable_index); - if( !lua_isnil(L,-1) ) { - lua_pop(L,1); - return -1; - } - lua_pop(L,1); - - /* Iterating over immediate bases */ - for(i=0;clss->bases[i];i++) - { - const swig_lua_class *base = clss->bases[i]; - SWIG_Lua_get_class_metatable(L, base->fqname); - lua_pushvalue(L, key_index); - lua_rawget(L, -2); - if( !lua_isnil(L,-1) ) { - lua_pushvalue(L, key_index); - - /* Add proxy function */ - lua_pushvalue(L, key_index); /* first closure value is function name */ - lua_pushlightuserdata(L, clss); /* second closure value is swig_lua_class structure */ - lua_pushcclosure(L, SWIG_Lua_resolve_metamethod, 2); - - lua_rawset(L, metatable_index); - success = 1; - } - lua_pop(L,1); /* remove function or nil */ - lua_pop(L,1); /* remove base class metatable */ - - if( success ) - break; - } - - return success; -} - -SWIGINTERN void SWIG_Lua_add_class_user_metamethods(lua_State *L, swig_lua_class *clss) -{ - int metatable_index; - int metamethods_info_index; - int tostring_undefined; - int eq_undefined = 0; - - SWIG_Lua_get_class_metatable(L, clss->fqname); - metatable_index = lua_gettop(L); - SWIG_Lua_get_inheritable_metamethods(L); - assert(lua_istable(L,-1)); - metamethods_info_index = lua_gettop(L); - lua_pushnil(L); /* first key */ - while(lua_next(L, metamethods_info_index) != 0 ) { - /* key at index -2, value at index -1 */ - const int is_inheritable = lua_toboolean(L,-2); - lua_pop(L,1); /* remove value - we don't need it anymore */ - - if(is_inheritable) { /* if metamethod is inheritable */ - SWIG_Lua_add_class_user_metamethod(L,clss,metatable_index); - } - } - - lua_pop(L,1); /* remove inheritable metatmethods table */ - - /* Special handling for __tostring method */ - lua_pushstring(L, "__tostring"); - lua_pushvalue(L,-1); - lua_rawget(L,metatable_index); - tostring_undefined = lua_isnil(L,-1); - lua_pop(L,1); - if( tostring_undefined ) { - lua_pushcfunction(L, SWIG_Lua_class_tostring); - lua_rawset(L, metatable_index); - } else { - lua_pop(L,1); /* remove copy of the key */ - } - - /* Special handling for __eq method */ - lua_pushstring(L, "__eq"); - lua_pushvalue(L,-1); - lua_rawget(L,metatable_index); - eq_undefined = lua_isnil(L,-1); - lua_pop(L,1); - if( eq_undefined ) { - lua_pushcfunction(L, SWIG_Lua_class_equal); - lua_rawset(L, metatable_index); - } else { - lua_pop(L,1); /* remove copy of the key */ - } - /* Warning: __index and __newindex are SWIG-defined. For user-defined operator[] - * a __getitem/__setitem method should be defined - */ - lua_pop(L,1); /* pop class metatable */ -} - -/* Register class static methods,attributes etc as well as constructor proxy */ -SWIGINTERN void SWIG_Lua_class_register_static(lua_State *L, swig_lua_class *clss) -{ - const int SWIGUNUSED begin = lua_gettop(L); - lua_checkstack(L,5); /* just in case */ - assert(lua_istable(L,-1)); /* just in case */ - assert(strcmp(clss->name, clss->cls_static->name) == 0); /* in class those 2 must be equal */ - - SWIG_Lua_namespace_register(L,clss->cls_static, 1); - - assert(lua_istable(L,-1)); /* just in case */ - - /* add its constructor to module with the name of the class - so you can do MyClass(...) as well as new_MyClass(...) - BUT only if a constructor is defined - (this overcomes the problem of pure virtual classes without constructors)*/ - if (clss->constructor) - { - lua_getmetatable(L,-1); - assert(lua_istable(L,-1)); /* just in case */ - SWIG_Lua_add_function(L,"__call", clss->constructor); - lua_pop(L,1); - } - - assert(lua_istable(L,-1)); /* just in case */ - SWIG_Lua_add_class_static_details(L, clss); - - /* clear stack */ - lua_pop(L,1); - assert( lua_gettop(L) == begin ); -} - -/* Performs the instance (non-static) class registration process. Metatable for class is created - * and added to the class registry. - */ -SWIGINTERN void SWIG_Lua_class_register_instance(lua_State *L,swig_lua_class *clss) -{ - const int SWIGUNUSED begin = lua_gettop(L); - int i; - /* if name already there (class is already registered) then do nothing */ - SWIG_Lua_get_class_registry(L); /* get the registry */ - lua_pushstring(L,clss->fqname); /* get the name */ - lua_rawget(L,-2); - if(!lua_isnil(L,-1)) { - lua_pop(L,2); - assert(lua_gettop(L)==begin); - return; - } - lua_pop(L,2); /* tidy stack */ - /* Recursively initialize all bases */ - for(i=0;clss->bases[i];i++) - { - SWIG_Lua_class_register_instance(L,clss->bases[i]); - } - /* Again, get registry and push name */ - SWIG_Lua_get_class_registry(L); /* get the registry */ - lua_pushstring(L,clss->fqname); /* get the name */ - lua_newtable(L); /* create the metatable */ -#if defined(SWIG_LUA_SQUASH_BASES) && (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA) - /* If squashing is requested, then merges all bases metatable into this one. - * It would get us all special methods: __getitem, __add etc. - * This would set .fn, .type, and other .xxx incorrectly, but we will overwrite it right away - */ - { - int new_metatable_index = lua_absindex(L,-1); - for(i=0;clss->bases[i];i++) - { - int base_metatable; - SWIG_Lua_get_class_metatable(L,clss->bases[i]->fqname); - base_metatable = lua_absindex(L,-1); - SWIG_Lua_merge_tables_by_index(L,new_metatable_index, base_metatable); - lua_pop(L,1); - } - } - /* And now we will overwrite all incorrectly set data */ -#endif - /* add string of class name called ".type" */ - lua_pushstring(L,".type"); - lua_pushstring(L,clss->fqname); - lua_rawset(L,-3); - /* add a table called bases */ - lua_pushstring(L,".bases"); - lua_newtable(L); - lua_rawset(L,-3); - /* add a table called ".get" */ - lua_pushstring(L,".get"); - lua_newtable(L); - lua_rawset(L,-3); - /* add a table called ".set" */ - lua_pushstring(L,".set"); - lua_newtable(L); - lua_rawset(L,-3); - /* add a table called ".fn" */ - lua_pushstring(L,".fn"); - lua_newtable(L); - /* add manual disown method */ - SWIG_Lua_add_function(L,"__disown",SWIG_Lua_class_disown); - lua_rawset(L,-3); - /* add accessor fns for using the .get,.set&.fn */ - SWIG_Lua_add_function(L,"__index",SWIG_Lua_class_get); - SWIG_Lua_add_function(L,"__newindex",SWIG_Lua_class_set); - SWIG_Lua_add_function(L,"__gc",SWIG_Lua_class_destruct); - /* add it */ - lua_rawset(L,-3); /* metatable into registry */ - lua_pop(L,1); /* tidy stack (remove registry) */ - assert(lua_gettop(L) == begin); - -#if defined(SWIG_LUA_SQUASH_BASES) && (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA) - /* Now merge all symbols from .fn, .set, .get etc from bases to our tables */ - SWIG_Lua_class_squash_bases(L,clss); -#endif - SWIG_Lua_get_class_metatable(L,clss->fqname); - SWIG_Lua_add_class_instance_details(L,clss); /* recursive adding of details (atts & ops) */ - lua_pop(L,1); /* tidy stack (remove class metatable) */ - assert( lua_gettop(L) == begin ); -} - -SWIGINTERN void SWIG_Lua_class_register(lua_State *L,swig_lua_class *clss) -{ - int SWIGUNUSED begin; - assert(lua_istable(L,-1)); /* This is a table (module or namespace) where classes will be added */ - SWIG_Lua_class_register_instance(L,clss); - SWIG_Lua_class_register_static(L,clss); - - /* Add links from static part to instance part and vice versa */ - /* [SWIG registry] [Module] - * "MyClass" ----> [MyClass metatable] <===== "MyClass" -+> [static part] - * ".get" ----> ... | | getmetatable()----| - * ".set" ----> ... | | | - * ".static" --------------)----------------/ [static part metatable] - * | ".get" --> ... - * | ".set" --> .... - * |=============================== ".instance" - */ - begin = lua_gettop(L); - lua_pushstring(L,clss->cls_static->name); - lua_rawget(L,-2); /* get class static table */ - assert(lua_istable(L,-1)); - lua_getmetatable(L,-1); - assert(lua_istable(L,-1)); /* get class static metatable */ - lua_pushstring(L,".instance"); /* prepare key */ - - SWIG_Lua_get_class_metatable(L,clss->fqname); /* get class metatable */ - assert(lua_istable(L,-1)); - lua_pushstring(L,".static"); /* prepare key */ - lua_pushvalue(L, -4); /* push static class TABLE */ - assert(lua_istable(L,-1)); - lua_rawset(L,-3); /* assign static class table(!NOT metatable) as ".static" member of class metatable */ - lua_rawset(L,-3); /* assign class metatable as ".instance" member of class static METATABLE */ - lua_pop(L,2); - assert(lua_gettop(L) == begin); -} -#endif /* SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA */ - -#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC) -SWIGINTERN void SWIG_Lua_elua_class_register_instance(lua_State *L, swig_lua_class *clss) -{ - const int SWIGUNUSED begin = lua_gettop(L); - int i; - /* if name already there (class is already registered) then do nothing */ - SWIG_Lua_get_class_registry(L); /* get the registry */ - lua_pushstring(L,clss->fqname); /* get the name */ - lua_rawget(L,-2); - if(!lua_isnil(L,-1)) { - lua_pop(L,2); - assert(lua_gettop(L)==begin); - return; - } - lua_pop(L,2); /* tidy stack */ - /* Recursively initialize all bases */ - for(i=0;clss->bases[i];i++) - { - SWIG_Lua_elua_class_register_instance(L,clss->bases[i]); - } - /* Again, get registry and push name */ - SWIG_Lua_get_class_registry(L); /* get the registry */ - lua_pushstring(L,clss->fqname); /* get the name */ - assert(clss->metatable); - lua_pushrotable(L, (void*)(clss->metatable)); /* create the metatable */ - lua_rawset(L,-3); - lua_pop(L,1); - assert(lua_gettop(L) == begin); -} -#endif /* elua && eluac */ - -/* ----------------------------------------------------------------------------- - * Class/structure conversion fns - * ----------------------------------------------------------------------------- */ - -/* helper to add metatable to new lua object */ -SWIGINTERN void SWIG_Lua_AddMetatable(lua_State *L,swig_type_info *type) -{ - if (type->clientdata) /* there is clientdata: so add the metatable */ - { - SWIG_Lua_get_class_metatable(L,((swig_lua_class*)(type->clientdata))->fqname); - if (lua_istable(L,-1)) - { - lua_setmetatable(L,-2); - } - else - { - lua_pop(L,1); - } - } -} - -/* pushes a new object into the lua stack */ -SWIGRUNTIME void SWIG_Lua_NewPointerObj(lua_State *L,void *ptr,swig_type_info *type, int own) -{ - swig_lua_userdata *usr; - if (!ptr){ - lua_pushnil(L); - return; - } - usr=(swig_lua_userdata*)lua_newuserdata(L,sizeof(swig_lua_userdata)); /* get data */ - usr->ptr=ptr; /* set the ptr */ - usr->type=type; - usr->own=own; -#if (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC) - SWIG_Lua_AddMetatable(L,type); /* add metatable */ -#endif -} - -/* takes a object from the lua stack & converts it into an object of the correct type - (if possible) */ -SWIGRUNTIME int SWIG_Lua_ConvertPtr(lua_State *L,int index,void **ptr,swig_type_info *type,int flags) -{ - swig_lua_userdata *usr; - swig_cast_info *cast; - if (lua_isnil(L,index)){*ptr=0; return SWIG_OK;} /* special case: lua nil => NULL pointer */ - usr=(swig_lua_userdata*)lua_touserdata(L,index); /* get data */ - if (usr) - { - if (flags & SWIG_POINTER_DISOWN) /* must disown the object */ - { - usr->own=0; - } - if (!type) /* special cast void*, no casting fn */ - { - *ptr=usr->ptr; - return SWIG_OK; /* ok */ - } - cast=SWIG_TypeCheckStruct(usr->type,type); /* performs normal type checking */ - if (cast) - { - int newmemory = 0; - *ptr=SWIG_TypeCast(cast,usr->ptr,&newmemory); - assert(!newmemory); /* newmemory handling not yet implemented */ - return SWIG_OK; /* ok */ - } - } - return SWIG_ERROR; /* error */ -} - -SWIGRUNTIME void* SWIG_Lua_MustGetPtr(lua_State *L,int index,swig_type_info *type,int flags, - int argnum,const char *func_name){ - void *result; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,index,&result,type,flags))){ - luaL_error (L,"Error in %s, expected a %s at argument number %d\n", - func_name,(type && type->str)?type->str:"void*",argnum); - } - return result; -} - -/* pushes a packed userdata. user for member fn pointers only */ -SWIGRUNTIME void SWIG_Lua_NewPackedObj(lua_State *L,void *ptr,size_t size,swig_type_info *type) -{ - swig_lua_rawdata *raw; - assert(ptr); /* not acceptable to pass in a NULL value */ - raw=(swig_lua_rawdata*)lua_newuserdata(L,sizeof(swig_lua_rawdata)-1+size); /* alloc data */ - raw->type=type; - raw->own=0; - memcpy(raw->data,ptr,size); /* copy the data */ - SWIG_Lua_AddMetatable(L,type); /* add metatable */ -} - -/* converts a packed userdata. user for member fn pointers only */ -SWIGRUNTIME int SWIG_Lua_ConvertPacked(lua_State *L,int index,void *ptr,size_t size,swig_type_info *type) -{ - swig_lua_rawdata *raw; - raw=(swig_lua_rawdata*)lua_touserdata(L,index); /* get data */ - if (!raw) return SWIG_ERROR; /* error */ - if (type==0 || type==raw->type) /* void* or identical type */ - { - memcpy(ptr,raw->data,size); /* copy it */ - return SWIG_OK; /* ok */ - } - return SWIG_ERROR; /* error */ -} - -/* a function to get the typestring of a piece of data */ -SWIGRUNTIME const char *SWIG_Lua_typename(lua_State *L, int tp) -{ - swig_lua_userdata *usr; - if (lua_isuserdata(L,tp)) - { - usr=(swig_lua_userdata*)lua_touserdata(L,tp); /* get data */ - if (usr && usr->type && usr->type->str) - return usr->type->str; - return "userdata (unknown type)"; - } - return lua_typename(L,lua_type(L,tp)); -} - -/* lua callable function to get the userdata's type */ -SWIGRUNTIME int SWIG_Lua_type(lua_State *L) -{ - lua_pushstring(L,SWIG_Lua_typename(L,1)); - return 1; -} - -/* ----------------------------------------------------------------------------- - * global variable support code: class/struct typemap functions - * ----------------------------------------------------------------------------- */ - -#if ((SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUA) && (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC)) -/* Install Constants */ -SWIGINTERN void -SWIG_Lua_InstallConstants(lua_State *L, swig_lua_const_info constants[]) { - int i; - for (i = 0; constants[i].type; i++) { - switch(constants[i].type) { - case SWIG_LUA_INT: - lua_pushstring(L,constants[i].name); - lua_pushinteger(L,(lua_Number)constants[i].lvalue); - lua_rawset(L,-3); - break; - case SWIG_LUA_FLOAT: - lua_pushstring(L,constants[i].name); - lua_pushnumber(L,(lua_Number)constants[i].dvalue); - lua_rawset(L,-3); - break; - case SWIG_LUA_CHAR: - lua_pushstring(L,constants[i].name); - { - char c = constants[i].lvalue; - lua_pushlstring(L,&c,1); - } - lua_rawset(L,-3); - break; - case SWIG_LUA_STRING: - lua_pushstring(L,constants[i].name); - lua_pushstring(L,(char *) constants[i].pvalue); - lua_rawset(L,-3); - break; - case SWIG_LUA_POINTER: - lua_pushstring(L,constants[i].name); - SWIG_NewPointerObj(L,constants[i].pvalue, *(constants[i]).ptype,0); - lua_rawset(L,-3); - break; - case SWIG_LUA_BINARY: - lua_pushstring(L,constants[i].name); - SWIG_NewMemberObj(L,constants[i].pvalue,constants[i].lvalue,*(constants[i]).ptype); - lua_rawset(L,-3); - break; - default: - break; - } - } -} -#endif - -/* ----------------------------------------------------------------------------- - * executing lua code from within the wrapper - * ----------------------------------------------------------------------------- */ - -#ifndef SWIG_DOSTRING_FAIL /* Allows redefining of error function */ -#define SWIG_DOSTRING_FAIL(S) fprintf(stderr,"%s\n",S) -#endif -/* Executes a C string in Lua which is a really simple way of calling lua from C -Unfortunately lua keeps changing its APIs, so we need a conditional compile -In lua 5.0.X it's lua_dostring() -In lua 5.1.X it's luaL_dostring() -*/ -SWIGINTERN int -SWIG_Lua_dostring(lua_State *L, const char *str) { - int ok,top; - if (str==0 || str[0]==0) return 0; /* nothing to do */ - top=lua_gettop(L); /* save stack */ -#if (defined(LUA_VERSION_NUM) && (LUA_VERSION_NUM>=501)) - ok=luaL_dostring(L,str); /* looks like this is lua 5.1.X or later, good */ -#else - ok=lua_dostring(L,str); /* might be lua 5.0.x, using lua_dostring */ -#endif - if (ok!=0) { - SWIG_DOSTRING_FAIL(lua_tostring(L,-1)); - } - lua_settop(L,top); /* restore the stack */ - return ok; -} - -#ifdef __cplusplus -} -#endif - -/* ------------------------------ end luarun.swg ------------------------------ */ - -/* Errors in SWIG */ -#define SWIG_UnknownError -1 -#define SWIG_IOError -2 -#define SWIG_RuntimeError -3 -#define SWIG_IndexError -4 -#define SWIG_TypeError -5 -#define SWIG_DivisionByZero -6 -#define SWIG_OverflowError -7 -#define SWIG_SyntaxError -8 -#define SWIG_ValueError -9 -#define SWIG_SystemError -10 -#define SWIG_AttributeError -11 -#define SWIG_MemoryError -12 -#define SWIG_NullReferenceError -13 - - - - -/* -------- TYPES TABLE (BEGIN) -------- */ - -#define SWIGTYPE_p_GLintptr swig_types[0] -#define SWIGTYPE_p_GLsizei swig_types[1] -#define SWIGTYPE_p_GLsizeiptr swig_types[2] -#define SWIGTYPE_p_double swig_types[3] -#define SWIGTYPE_p_float swig_types[4] -#define SWIGTYPE_p_fstream swig_types[5] -#define SWIGTYPE_p_int swig_types[6] -#define SWIGTYPE_p_long_long swig_types[7] -#define SWIGTYPE_p_of3dPrimitive swig_types[8] -#define SWIGTYPE_p_ofAbstractImage swig_types[9] -#define SWIGTYPE_p_ofAbstractParameter swig_types[10] -#define SWIGTYPE_p_ofAppBaseWindow swig_types[11] -#define SWIGTYPE_p_ofArduino swig_types[12] -#define SWIGTYPE_p_ofBaseApp swig_types[13] -#define SWIGTYPE_p_ofBaseDraws swig_types[14] -#define SWIGTYPE_p_ofBaseFileSerializer swig_types[15] -#define SWIGTYPE_p_ofBaseGLRenderer swig_types[16] -#define SWIGTYPE_p_ofBaseHasPixels swig_types[17] -#define SWIGTYPE_p_ofBaseHasTexture swig_types[18] -#define SWIGTYPE_p_ofBaseHasTexturePlanes swig_types[19] -#define SWIGTYPE_p_ofBaseImage_T_float_t swig_types[20] -#define SWIGTYPE_p_ofBaseImage_T_unsigned_char_t swig_types[21] -#define SWIGTYPE_p_ofBaseImage_T_unsigned_short_t swig_types[22] -#define SWIGTYPE_p_ofBaseLoggerChannel swig_types[23] -#define SWIGTYPE_p_ofBaseMaterial swig_types[24] -#define SWIGTYPE_p_ofBaseRenderer swig_types[25] -#define SWIGTYPE_p_ofBaseSerializer swig_types[26] -#define SWIGTYPE_p_ofBaseSoundInput swig_types[27] -#define SWIGTYPE_p_ofBaseSoundOutput swig_types[28] -#define SWIGTYPE_p_ofBaseSoundPlayer swig_types[29] -#define SWIGTYPE_p_ofBaseUpdates swig_types[30] -#define SWIGTYPE_p_ofBaseVideo swig_types[31] -#define SWIGTYPE_p_ofBaseVideoDraws swig_types[32] -#define SWIGTYPE_p_ofBaseVideoGrabber swig_types[33] -#define SWIGTYPE_p_ofBaseVideoPlayer swig_types[34] -#define SWIGTYPE_p_ofBoxPrimitive swig_types[35] -#define SWIGTYPE_p_ofBuffer swig_types[36] -#define SWIGTYPE_p_ofBufferObject swig_types[37] -#define SWIGTYPE_p_ofCamera swig_types[38] -#define SWIGTYPE_p_ofColor_T_float_t swig_types[39] -#define SWIGTYPE_p_ofColor_T_unsigned_char_t swig_types[40] -#define SWIGTYPE_p_ofColor_T_unsigned_short_t swig_types[41] -#define SWIGTYPE_p_ofConePrimitive swig_types[42] -#define SWIGTYPE_p_ofConsoleLoggerChannel swig_types[43] -#define SWIGTYPE_p_ofCoreEvents swig_types[44] -#define SWIGTYPE_p_ofCylinderPrimitive swig_types[45] -#define SWIGTYPE_p_ofDirectory swig_types[46] -#define SWIGTYPE_p_ofDragInfo swig_types[47] -#define SWIGTYPE_p_ofEasyCam swig_types[48] -#define SWIGTYPE_p_ofEventArgs swig_types[49] -#define SWIGTYPE_p_ofEventT_int_const_t swig_types[50] -#define SWIGTYPE_p_ofEventT_ofHttpResponse_t swig_types[51] -#define SWIGTYPE_p_ofEventT_std__string_const_t swig_types[52] -#define SWIGTYPE_p_ofEventT_std__vectorT_unsigned_char_t_const_t swig_types[53] -#define SWIGTYPE_p_ofFbo swig_types[54] -#define SWIGTYPE_p_ofFbo__Settings swig_types[55] -#define SWIGTYPE_p_ofFile swig_types[56] -#define SWIGTYPE_p_ofFileDialogResult swig_types[57] -#define SWIGTYPE_p_ofFileLoggerChannel swig_types[58] -#define SWIGTYPE_p_ofFilePath swig_types[59] -#define SWIGTYPE_p_ofFpsCounter swig_types[60] -#define SWIGTYPE_p_ofHttpRequest swig_types[61] -#define SWIGTYPE_p_ofHttpResponse swig_types[62] -#define SWIGTYPE_p_ofIcoSpherePrimitive swig_types[63] -#define SWIGTYPE_p_ofImage_T_float_t swig_types[64] -#define SWIGTYPE_p_ofImage_T_unsigned_char_t swig_types[65] -#define SWIGTYPE_p_ofImage_T_unsigned_short_t swig_types[66] -#define SWIGTYPE_p_ofKeyEventArgs swig_types[67] -#define SWIGTYPE_p_ofLight swig_types[68] -#define SWIGTYPE_p_ofLog swig_types[69] -#define SWIGTYPE_p_ofLogError swig_types[70] -#define SWIGTYPE_p_ofLogFatalError swig_types[71] -#define SWIGTYPE_p_ofLogNotice swig_types[72] -#define SWIGTYPE_p_ofLogVerbose swig_types[73] -#define SWIGTYPE_p_ofLogWarning swig_types[74] -#define SWIGTYPE_p_ofMaterial swig_types[75] -#define SWIGTYPE_p_ofMatrix3x3 swig_types[76] -#define SWIGTYPE_p_ofMatrix4x4 swig_types[77] -#define SWIGTYPE_p_ofMatrixStack swig_types[78] -#define SWIGTYPE_p_ofMesh swig_types[79] -#define SWIGTYPE_p_ofMeshFace swig_types[80] -#define SWIGTYPE_p_ofMessage swig_types[81] -#define SWIGTYPE_p_ofMouseEventArgs swig_types[82] -#define SWIGTYPE_p_ofNode swig_types[83] -#define SWIGTYPE_p_ofParameterGroup swig_types[84] -#define SWIGTYPE_p_ofPath swig_types[85] -#define SWIGTYPE_p_ofPixels_T_float_t swig_types[86] -#define SWIGTYPE_p_ofPixels_T_unsigned_char_t swig_types[87] -#define SWIGTYPE_p_ofPixels_T_unsigned_short_t swig_types[88] -#define SWIGTYPE_p_ofPlanePrimitive swig_types[89] -#define SWIGTYPE_p_ofPolyline swig_types[90] -#define SWIGTYPE_p_ofQuaternion swig_types[91] -#define SWIGTYPE_p_ofRectangle swig_types[92] -#define SWIGTYPE_p_ofResizeEventArgs swig_types[93] -#define SWIGTYPE_p_ofSerial swig_types[94] -#define SWIGTYPE_p_ofSerialDeviceInfo swig_types[95] -#define SWIGTYPE_p_ofShader swig_types[96] -#define SWIGTYPE_p_ofSoundDevice swig_types[97] -#define SWIGTYPE_p_ofSoundPlayer swig_types[98] -#define SWIGTYPE_p_ofSoundStream swig_types[99] -#define SWIGTYPE_p_ofSpherePrimitive swig_types[100] -#define SWIGTYPE_p_ofStyle swig_types[101] -#define SWIGTYPE_p_ofTexture swig_types[102] -#define SWIGTYPE_p_ofTextureData swig_types[103] -#define SWIGTYPE_p_ofTouchEventArgs swig_types[104] -#define SWIGTYPE_p_ofTrueTypeFont swig_types[105] -#define SWIGTYPE_p_ofURLFileLoader swig_types[106] -#define SWIGTYPE_p_ofVbo swig_types[107] -#define SWIGTYPE_p_ofVboMesh swig_types[108] -#define SWIGTYPE_p_ofVec2f swig_types[109] -#define SWIGTYPE_p_ofVec3f swig_types[110] -#define SWIGTYPE_p_ofVec4f swig_types[111] -#define SWIGTYPE_p_ofVideoDevice swig_types[112] -#define SWIGTYPE_p_ofVideoGrabber swig_types[113] -#define SWIGTYPE_p_ofVideoPlayer swig_types[114] -#define SWIGTYPE_p_ofXml swig_types[115] -#define SWIGTYPE_p_shared_ptrT_ofBaseRenderer_t swig_types[116] -#define SWIGTYPE_p_shared_ptrT_ofBaseSoundPlayer_t swig_types[117] -#define SWIGTYPE_p_shared_ptrT_ofBaseSoundStream_t swig_types[118] -#define SWIGTYPE_p_shared_ptrT_ofBaseVideoGrabber_t swig_types[119] -#define SWIGTYPE_p_std__filesystem__path swig_types[120] -#define SWIGTYPE_p_std__mapT_std__string_std__string_t swig_types[121] -#define SWIGTYPE_p_std__string swig_types[122] -#define SWIGTYPE_p_std__vectorT_float_t swig_types[123] -#define SWIGTYPE_p_std__vectorT_int_t swig_types[124] -#define SWIGTYPE_p_std__vectorT_ofColor_T_float_t_t swig_types[125] -#define SWIGTYPE_p_std__vectorT_ofFile_t swig_types[126] -#define SWIGTYPE_p_std__vectorT_ofMeshFace_t swig_types[127] -#define SWIGTYPE_p_std__vectorT_ofPath__Command_t swig_types[128] -#define SWIGTYPE_p_std__vectorT_ofPath_t swig_types[129] -#define SWIGTYPE_p_std__vectorT_ofPolyline_t swig_types[130] -#define SWIGTYPE_p_std__vectorT_ofSerialDeviceInfo_t swig_types[131] -#define SWIGTYPE_p_std__vectorT_ofSoundDevice_t swig_types[132] -#define SWIGTYPE_p_std__vectorT_ofTexture_t swig_types[133] -#define SWIGTYPE_p_std__vectorT_ofVec2f_t swig_types[134] -#define SWIGTYPE_p_std__vectorT_ofVec3f_t swig_types[135] -#define SWIGTYPE_p_std__vectorT_ofVideoDevice_t swig_types[136] -#define SWIGTYPE_p_std__vectorT_std__string_t swig_types[137] -#define SWIGTYPE_p_std__vectorT_unsigned_char_t swig_types[138] -#define SWIGTYPE_p_std__vectorT_unsigned_int_t swig_types[139] -#define SWIGTYPE_p_std__vectorT_weak_ptrT_ofLight__Data_t_t swig_types[140] -#define SWIGTYPE_p_unsigned_char swig_types[141] -#define SWIGTYPE_p_unsigned_int swig_types[142] -#define SWIGTYPE_p_unsigned_long_long swig_types[143] -#define SWIGTYPE_p_unsigned_short swig_types[144] -#define SWIGTYPE_p_void swig_types[145] -static swig_type_info *swig_types[147]; -static swig_module_info swig_module = {swig_types, 146, 0, 0, 0, 0}; -#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) -#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) - -/* -------- TYPES TABLE (END) -------- */ - -#define SWIG_name "of" -#define SWIG_init luaopen_of -#define SWIG_init_user luaopen_of_user - -#define SWIG_LUACODE luaopen_of_luacode - -namespace swig { -typedef struct{} LANGUAGE_OBJ; -} - - - #include "ofMain.h" - #undef check - - -#include - - -#ifdef __cplusplus /* generic alloc/dealloc fns*/ -#define SWIG_ALLOC_ARRAY(TYPE,LEN) new TYPE[LEN] -#define SWIG_FREE_ARRAY(PTR) delete[] PTR -#else -#define SWIG_ALLOC_ARRAY(TYPE,LEN) (TYPE *)malloc(LEN*sizeof(TYPE)) -#define SWIG_FREE_ARRAY(PTR) free(PTR) -#endif -/* counting the size of arrays:*/ -SWIGINTERN int SWIG_itable_size(lua_State* L, int index) -{ - int n=0; - while(1){ - lua_rawgeti(L,index,n+1); - if (lua_isnil(L,-1))break; - ++n; - lua_pop(L,1); - } - lua_pop(L,1); - return n; -} - -SWIGINTERN int SWIG_table_size(lua_State* L, int index) -{ - int n=0; - lua_pushnil(L); /* first key*/ - while (lua_next(L, index) != 0) { - ++n; - lua_pop(L, 1); /* removes `value'; keeps `key' for next iteration*/ - } - return n; -} - -/* super macro to declare array typemap helper fns */ -#define SWIG_DECLARE_TYPEMAP_ARR_FN(NAME,TYPE)\ - SWIGINTERN int SWIG_read_##NAME##_num_array(lua_State* L,int index,TYPE *array,int size){\ - int i;\ - for (i = 0; i < size; i++) {\ - lua_rawgeti(L,index,i+1);\ - if (lua_isnumber(L,-1)){\ - array[i] = (TYPE)lua_tonumber(L,-1);\ - } else {\ - lua_pop(L,1);\ - return 0;\ - }\ - lua_pop(L,1);\ - }\ - return 1;\ - }\ - SWIGINTERN TYPE* SWIG_get_##NAME##_num_array_fixed(lua_State* L, int index, int size){\ - TYPE *array;\ - if (!lua_istable(L,index) || SWIG_itable_size(L,index) != size) {\ - SWIG_Lua_pushferrstring(L,"expected a table of size %d",size);\ - return 0;\ - }\ - array=SWIG_ALLOC_ARRAY(TYPE,size);\ - if (!SWIG_read_##NAME##_num_array(L,index,array,size)){\ - SWIG_Lua_pusherrstring(L,"table must contain numbers");\ - SWIG_FREE_ARRAY(array);\ - return 0;\ - }\ - return array;\ - }\ - SWIGINTERN TYPE* SWIG_get_##NAME##_num_array_var(lua_State* L, int index, int* size)\ - {\ - TYPE *array;\ - if (!lua_istable(L,index)) {\ - SWIG_Lua_pusherrstring(L,"expected a table");\ - return 0;\ - }\ - *size=SWIG_itable_size(L,index);\ - if (*size<1){\ - SWIG_Lua_pusherrstring(L,"table appears to be empty");\ - return 0;\ - }\ - array=SWIG_ALLOC_ARRAY(TYPE,*size);\ - if (!SWIG_read_##NAME##_num_array(L,index,array,*size)){\ - SWIG_Lua_pusherrstring(L,"table must contain numbers");\ - SWIG_FREE_ARRAY(array);\ - return 0;\ - }\ - return array;\ - }\ - SWIGINTERN void SWIG_write_##NAME##_num_array(lua_State* L,TYPE *array,int size){\ - int i;\ - lua_newtable(L);\ - for (i = 0; i < size; i++){\ - lua_pushnumber(L,(lua_Number)array[i]);\ - lua_rawseti(L,-2,i+1);/* -1 is the number, -2 is the table*/ \ - }\ - } - -SWIG_DECLARE_TYPEMAP_ARR_FN(schar,signed char) -SWIG_DECLARE_TYPEMAP_ARR_FN(uchar,unsigned char) -SWIG_DECLARE_TYPEMAP_ARR_FN(int,int) -SWIG_DECLARE_TYPEMAP_ARR_FN(uint,unsigned int) -SWIG_DECLARE_TYPEMAP_ARR_FN(short,short) -SWIG_DECLARE_TYPEMAP_ARR_FN(ushort,unsigned short) -SWIG_DECLARE_TYPEMAP_ARR_FN(long,long) -SWIG_DECLARE_TYPEMAP_ARR_FN(ulong,unsigned long) -SWIG_DECLARE_TYPEMAP_ARR_FN(float,float) -SWIG_DECLARE_TYPEMAP_ARR_FN(double,double) - -SWIGINTERN int SWIG_read_ptr_array(lua_State* L,int index,void **array,int size,swig_type_info *type){ - int i; - for (i = 0; i < size; i++) { - lua_rawgeti(L,index,i+1); - if (!lua_isuserdata(L,-1) || SWIG_ConvertPtr(L,-1,&array[i],type,0)==-1){ - lua_pop(L,1); - return 0; - } - lua_pop(L,1); - } - return 1; -} -SWIGINTERN void** SWIG_get_ptr_array_fixed(lua_State* L, int index, int size,swig_type_info *type){ - void **array; - if (!lua_istable(L,index) || SWIG_itable_size(L,index) != size) { - SWIG_Lua_pushferrstring(L,"expected a table of size %d",size); - return 0; - } - array=SWIG_ALLOC_ARRAY(void*,size); - if (!SWIG_read_ptr_array(L,index,array,size,type)){ - SWIG_Lua_pushferrstring(L,"table must contain pointers of type %s",type->name); - SWIG_FREE_ARRAY(array); - return 0; - } - return array; -} -SWIGINTERN void** SWIG_get_ptr_array_var(lua_State* L, int index, int* size,swig_type_info *type){ - void **array; - if (!lua_istable(L,index)) { - SWIG_Lua_pusherrstring(L,"expected a table"); - return 0; - } - *size=SWIG_itable_size(L,index); - if (*size<1){ - SWIG_Lua_pusherrstring(L,"table appears to be empty"); - return 0; - } - array=SWIG_ALLOC_ARRAY(void*,*size); - if (!SWIG_read_ptr_array(L,index,array,*size,type)){ - SWIG_Lua_pushferrstring(L,"table must contain pointers of type %s",type->name); - SWIG_FREE_ARRAY(array); - return 0; - } - return array; -} -SWIGINTERN void SWIG_write_ptr_array(lua_State* L,void **array,int size,swig_type_info *type,int own){ - int i; - lua_newtable(L); - for (i = 0; i < size; i++){ - SWIG_NewPointerObj(L,array[i],type,own); - lua_rawseti(L,-2,i+1);/* -1 is the number, -2 is the table*/ - } -} - - -#include -#include - - -#define SWIG_exception(a,b)\ -{ lua_pushfstring(L,"%s:%s",#a,b);SWIG_fail; } - - -#include -#include - - -#include - - -SWIGINTERN int SWIG_lua_isnilstring(lua_State *L, int idx) { - int ret = lua_isstring(L, idx); - if (!ret) - ret = lua_isnil(L, idx); - return ret; -} - - -#include - - -#include -#include -#include - - -#include - - -#include - -SWIGINTERN int std_vector_Sl_int_Sg____getitem__(std::vector< int > *self,unsigned int idx){ - if (idx>=self->size()) - throw std::out_of_range("in vector::__getitem__()"); - return (*self)[idx]; - } -SWIGINTERN void std_vector_Sl_int_Sg____setitem__(std::vector< int > *self,unsigned int idx,int val){ - if (idx>=self->size()) - throw std::out_of_range("in vector::__setitem__()"); - (*self)[idx]=val; - } -SWIGINTERN float std_vector_Sl_float_Sg____getitem__(std::vector< float > *self,unsigned int idx){ - if (idx>=self->size()) - throw std::out_of_range("in vector::__getitem__()"); - return (*self)[idx]; - } -SWIGINTERN void std_vector_Sl_float_Sg____setitem__(std::vector< float > *self,unsigned int idx,float val){ - if (idx>=self->size()) - throw std::out_of_range("in vector::__setitem__()"); - (*self)[idx]=val; - } -SWIGINTERN std::string std_vector_Sl_std_string_Sg____getitem__(std::vector< std::string > *self,unsigned int idx){ - if (idx>=self->size()) - throw std::out_of_range("in vector::__getitem__()"); - return (*self)[idx]; - } -SWIGINTERN void std_vector_Sl_std_string_Sg____setitem__(std::vector< std::string > *self,unsigned int idx,std::string val){ - if (idx>=self->size()) - throw std::out_of_range("in vector::__setitem__()"); - (*self)[idx]=val; - } -SWIGINTERN unsigned char std_vector_Sl_unsigned_SS_char_Sg____getitem__(std::vector< unsigned char > *self,unsigned int idx){ - if (idx>=self->size()) - throw std::out_of_range("in vector::__getitem__()"); - return (*self)[idx]; - } -SWIGINTERN void std_vector_Sl_unsigned_SS_char_Sg____setitem__(std::vector< unsigned char > *self,unsigned int idx,unsigned char val){ - if (idx>=self->size()) - throw std::out_of_range("in vector::__setitem__()"); - (*self)[idx]=val; - } -SWIGINTERN ofVideoDevice std_vector_Sl_ofVideoDevice_Sg____getitem__(std::vector< ofVideoDevice > *self,unsigned int idx){ - if (idx>=self->size()) - throw std::out_of_range("in vector::__getitem__()"); - return (*self)[idx]; - } -SWIGINTERN void std_vector_Sl_ofVideoDevice_Sg____setitem__(std::vector< ofVideoDevice > *self,unsigned int idx,ofVideoDevice val){ - if (idx>=self->size()) - throw std::out_of_range("in vector::__setitem__()"); - (*self)[idx]=val; - } -SWIGINTERN ofTexture std_vector_Sl_ofTexture_Sg____getitem__(std::vector< ofTexture > *self,unsigned int idx){ - if (idx>=self->size()) - throw std::out_of_range("in vector::__getitem__()"); - return (*self)[idx]; - } -SWIGINTERN void std_vector_Sl_ofTexture_Sg____setitem__(std::vector< ofTexture > *self,unsigned int idx,ofTexture val){ - if (idx>=self->size()) - throw std::out_of_range("in vector::__setitem__()"); - (*self)[idx]=val; - } -SWIGINTERN void delete_ofMesh(ofMesh *self){ - self->clear(); - delete self; - } -SWIGINTERN char const *ofMatrix3x3___str__(ofMatrix3x3 *self){ - stringstream str; - str << (*self); - return str.str().c_str(); - } -SWIGINTERN char const *ofMatrix4x4___str__(ofMatrix4x4 *self){ - stringstream str; - str << (*self); - return str.str().c_str(); - } -SWIGINTERN char const *ofQuaternion___str__(ofQuaternion *self){ - stringstream str; - str << (*self); - return str.str().c_str(); - } -SWIGINTERN char const *ofVec2f___str__(ofVec2f *self){ - stringstream str; - str << (*self); - return str.str().c_str(); - } -SWIGINTERN char const *ofVec3f___str__(ofVec3f *self){ - stringstream str; - str << (*self); - return str.str().c_str(); - } -SWIGINTERN char const *ofVec4f___str__(ofVec4f *self){ - stringstream str; - str << (*self); - return str.str().c_str(); - } -SWIGINTERN void delete_ofShader(ofShader *self){ - self->end(); - delete self; - } - -#define ofColor__Sl_unsigned_SS_char_Sg__r_get(self_) self_->r -#define ofColor__Sl_unsigned_SS_char_Sg__r_set(self_, val_) self_->r = val_ - - -#define ofColor__Sl_unsigned_SS_char_Sg__g_get(self_) self_->g -#define ofColor__Sl_unsigned_SS_char_Sg__g_set(self_, val_) self_->g = val_ - - -#define ofColor__Sl_unsigned_SS_char_Sg__b_get(self_) self_->b -#define ofColor__Sl_unsigned_SS_char_Sg__b_set(self_, val_) self_->b = val_ - - -#define ofColor__Sl_unsigned_SS_char_Sg__a_get(self_) self_->a -#define ofColor__Sl_unsigned_SS_char_Sg__a_set(self_, val_) self_->a = val_ - - -#define ofColor__Sl_float_Sg__r_get(self_) self_->r -#define ofColor__Sl_float_Sg__r_set(self_, val_) self_->r = val_ - - -#define ofColor__Sl_float_Sg__g_get(self_) self_->g -#define ofColor__Sl_float_Sg__g_set(self_, val_) self_->g = val_ - - -#define ofColor__Sl_float_Sg__b_get(self_) self_->b -#define ofColor__Sl_float_Sg__b_set(self_, val_) self_->b = val_ - - -#define ofColor__Sl_float_Sg__a_get(self_) self_->a -#define ofColor__Sl_float_Sg__a_set(self_, val_) self_->a = val_ - - -#define ofColor__Sl_unsigned_SS_short_Sg__r_get(self_) self_->r -#define ofColor__Sl_unsigned_SS_short_Sg__r_set(self_, val_) self_->r = val_ - - -#define ofColor__Sl_unsigned_SS_short_Sg__g_get(self_) self_->g -#define ofColor__Sl_unsigned_SS_short_Sg__g_set(self_, val_) self_->g = val_ - - -#define ofColor__Sl_unsigned_SS_short_Sg__b_get(self_) self_->b -#define ofColor__Sl_unsigned_SS_short_Sg__b_set(self_, val_) self_->b = val_ - - -#define ofColor__Sl_unsigned_SS_short_Sg__a_get(self_) self_->a -#define ofColor__Sl_unsigned_SS_short_Sg__a_set(self_, val_) self_->a = val_ - -SWIGINTERN unsigned char ofColor__Sl_unsigned_SS_char_Sg__getR(ofColor_< unsigned char > *self){return self->r;} -SWIGINTERN unsigned char ofColor__Sl_unsigned_SS_char_Sg__getG(ofColor_< unsigned char > *self){return self->g;} -SWIGINTERN unsigned char ofColor__Sl_unsigned_SS_char_Sg__getB(ofColor_< unsigned char > *self){return self->b;} -SWIGINTERN unsigned char ofColor__Sl_unsigned_SS_char_Sg__getA(ofColor_< unsigned char > *self){return self->a;} -SWIGINTERN void ofColor__Sl_unsigned_SS_char_Sg__setR(ofColor_< unsigned char > *self,unsigned char r){self->r = r;} -SWIGINTERN void ofColor__Sl_unsigned_SS_char_Sg__setG(ofColor_< unsigned char > *self,unsigned char g){self->g = g;} -SWIGINTERN void ofColor__Sl_unsigned_SS_char_Sg__setB(ofColor_< unsigned char > *self,unsigned char b){self->b = b;} -SWIGINTERN void ofColor__Sl_unsigned_SS_char_Sg__setA(ofColor_< unsigned char > *self,unsigned char a){self->a = a;} -SWIGINTERN char const *ofColor__Sl_unsigned_SS_char_Sg____str__(ofColor_< unsigned char > *self){ - stringstream str; - str << (*self); - return str.str().c_str(); - } -SWIGINTERN float ofColor__Sl_float_Sg__getR(ofColor_< float > *self){return self->r;} -SWIGINTERN float ofColor__Sl_float_Sg__getG(ofColor_< float > *self){return self->g;} -SWIGINTERN float ofColor__Sl_float_Sg__getB(ofColor_< float > *self){return self->b;} -SWIGINTERN float ofColor__Sl_float_Sg__getA(ofColor_< float > *self){return self->a;} -SWIGINTERN void ofColor__Sl_float_Sg__setR(ofColor_< float > *self,float r){self->r = r;} -SWIGINTERN void ofColor__Sl_float_Sg__setG(ofColor_< float > *self,float g){self->g = g;} -SWIGINTERN void ofColor__Sl_float_Sg__setB(ofColor_< float > *self,float b){self->b = b;} -SWIGINTERN void ofColor__Sl_float_Sg__setA(ofColor_< float > *self,float a){self->a = a;} -SWIGINTERN char const *ofColor__Sl_float_Sg____str__(ofColor_< float > *self){ - stringstream str; - str << (*self); - return str.str().c_str(); - } -SWIGINTERN unsigned short ofColor__Sl_unsigned_SS_short_Sg__getR(ofColor_< unsigned short > *self){return self->r;} -SWIGINTERN unsigned short ofColor__Sl_unsigned_SS_short_Sg__getG(ofColor_< unsigned short > *self){return self->g;} -SWIGINTERN unsigned short ofColor__Sl_unsigned_SS_short_Sg__getB(ofColor_< unsigned short > *self){return self->b;} -SWIGINTERN unsigned short ofColor__Sl_unsigned_SS_short_Sg__getA(ofColor_< unsigned short > *self){return self->a;} -SWIGINTERN void ofColor__Sl_unsigned_SS_short_Sg__setR(ofColor_< unsigned short > *self,unsigned short r){self->r = r;} -SWIGINTERN void ofColor__Sl_unsigned_SS_short_Sg__setG(ofColor_< unsigned short > *self,unsigned short g){self->g = g;} -SWIGINTERN void ofColor__Sl_unsigned_SS_short_Sg__setB(ofColor_< unsigned short > *self,unsigned short b){self->b = b;} -SWIGINTERN void ofColor__Sl_unsigned_SS_short_Sg__setA(ofColor_< unsigned short > *self,unsigned short a){self->a = a;} -SWIGINTERN char const *ofColor__Sl_unsigned_SS_short_Sg____str__(ofColor_< unsigned short > *self){ - stringstream str; - str << (*self); - return str.str().c_str(); - } -SWIGINTERN char const *ofRectangle___str__(ofRectangle *self){ - stringstream str; - str << (*self); - return str.str().c_str(); - } - -#define ofRectangle_x_get(self_) self_->getX() -#define ofRectangle_x_set(self_, val_) self_->setX(val_) - - -#define ofRectangle_y_get(self_) self_->getY() -#define ofRectangle_y_set(self_, val_) self_->setY(val_) - - - void log(ofLogLevel level, const string & message) { - ofLog(level, message); - } - -#ifdef __cplusplus -extern "C" { -#endif -static int _wrap_new_string__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *result = 0 ; - SWIG_check_num_args("std::string::string",0,0) result = (std::string *)new std::string(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__string,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_string__SWIG_1(lua_State* L) { int SWIG_arg = 0; char *arg1 = (char *) 0 ; std::string *result = 0 ; - SWIG_check_num_args("std::string::string",1,1) - if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("std::string::string",1,"char const *"); arg1 = (char *)lua_tostring(L, 1); - result = (std::string *)new std::string((char const *)arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__string,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_string(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_string__SWIG_0(L);} if (argc == 1) { int _v; { _v = SWIG_lua_isnilstring(L,argv[0]); } if (_v) { - return _wrap_new_string__SWIG_1(L);} } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_string'\n" - " Possible C/C++ prototypes are:\n" " std::string::string()\n" " std::string::string(char const *)\n"); - lua_error(L);return 0; } -static int _wrap_string_size(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = (std::string *) 0 ; unsigned int result; - SWIG_check_num_args("std::string::size",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::string::size",1,"std::string const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__string,0))){ - SWIG_fail_ptr("string_size",1,SWIGTYPE_p_std__string); } result = (unsigned int)((std::string const *)arg1)->size(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_string_length(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = (std::string *) 0 ; unsigned int result; - SWIG_check_num_args("std::string::length",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::string::length",1,"std::string const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__string,0))){ - SWIG_fail_ptr("string_length",1,SWIGTYPE_p_std__string); } result = (unsigned int)((std::string const *)arg1)->length(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_string_empty(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = (std::string *) 0 ; bool result; - SWIG_check_num_args("std::string::empty",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::string::empty",1,"std::string const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__string,0))){ - SWIG_fail_ptr("string_empty",1,SWIGTYPE_p_std__string); } result = (bool)((std::string const *)arg1)->empty(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_string_c_str(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = (std::string *) 0 ; char *result = 0 ; - SWIG_check_num_args("std::string::c_str",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::string::c_str",1,"std::string const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__string,0))){ - SWIG_fail_ptr("string_c_str",1,SWIGTYPE_p_std__string); } result = (char *)((std::string const *)arg1)->c_str(); - lua_pushstring(L,(const char *)result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_string_data(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = (std::string *) 0 ; char *result = 0 ; - SWIG_check_num_args("std::string::data",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::string::data",1,"std::string const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__string,0))){ - SWIG_fail_ptr("string_data",1,SWIGTYPE_p_std__string); } result = (char *)((std::string const *)arg1)->data(); - lua_pushstring(L,(const char *)result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_string_assign(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = (std::string *) 0 ; - char *arg2 = (char *) 0 ; SWIG_check_num_args("std::string::assign",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::string::assign",1,"std::string *"); - if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("std::string::assign",2,"char const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__string,0))){ - SWIG_fail_ptr("string_assign",1,SWIGTYPE_p_std__string); } arg2 = (char *)lua_tostring(L, 2); - (arg1)->assign((char const *)arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_string(void *obj) { -std::string *arg1 = (std::string *) obj; -delete arg1; -} -static int _proxy__wrap_new_string(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_string); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_string_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_string_methods[]= { - { "size", _wrap_string_size}, - { "length", _wrap_string_length}, - { "empty", _wrap_string_empty}, - { "c_str", _wrap_string_c_str}, - { "data", _wrap_string_data}, - { "assign", _wrap_string_assign}, - {0,0} -}; -static swig_lua_method swig_string_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_string_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_string_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_string_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_string_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_string_Sf_SwigStatic = { - "string", - swig_string_Sf_SwigStatic_methods, - swig_string_Sf_SwigStatic_attributes, - swig_string_Sf_SwigStatic_constants, - swig_string_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_string_bases[] = {0}; -static const char *swig_string_base_names[] = {0}; -static swig_lua_class _wrap_class_string = { "string", "string", &SWIGTYPE_p_std__string,_proxy__wrap_new_string, swig_delete_string, swig_string_methods, swig_string_attributes, &swig_string_Sf_SwigStatic, swig_string_meta, swig_string_bases, swig_string_base_names }; - -static int _wrap_new_path__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::filesystem::path *result = 0 ; - SWIG_check_num_args("std::filesystem::path::path",0,0) result = (std::filesystem::path *)new std::filesystem::path(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__filesystem__path,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_path__SWIG_1(lua_State* L) { int SWIG_arg = 0; char *arg1 = (char *) 0 ; - std::filesystem::path *result = 0 ; SWIG_check_num_args("std::filesystem::path::path",1,1) - if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("std::filesystem::path::path",1,"char const *"); - arg1 = (char *)lua_tostring(L, 1); result = (std::filesystem::path *)new std::filesystem::path((char const *)arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__filesystem__path,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_path(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_path__SWIG_0(L);} if (argc == 1) { int _v; { _v = SWIG_lua_isnilstring(L,argv[0]); } if (_v) { - return _wrap_new_path__SWIG_1(L);} } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_path'\n" - " Possible C/C++ prototypes are:\n" " std::filesystem::path::path()\n" " std::filesystem::path::path(char const *)\n"); - lua_error(L);return 0; } -static int _wrap_path_string(lua_State* L) { int SWIG_arg = 0; std::filesystem::path *arg1 = (std::filesystem::path *) 0 ; - std::string result; SWIG_check_num_args("std::filesystem::path::string",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::filesystem::path::string",1,"std::filesystem::path const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__filesystem__path,0))){ - SWIG_fail_ptr("path_string",1,SWIGTYPE_p_std__filesystem__path); } - result = ((std::filesystem::path const *)arg1)->string(); lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_path(void *obj) { -std::filesystem::path *arg1 = (std::filesystem::path *) obj; -delete arg1; -} -static int _proxy__wrap_new_path(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_path); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_path_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_path_methods[]= { - { "string", _wrap_path_string}, - {0,0} -}; -static swig_lua_method swig_path_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_path_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_path_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_path_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_path_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_path_Sf_SwigStatic = { - "path", - swig_path_Sf_SwigStatic_methods, - swig_path_Sf_SwigStatic_attributes, - swig_path_Sf_SwigStatic_constants, - swig_path_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_path_bases[] = {0}; -static const char *swig_path_base_names[] = {0}; -static swig_lua_class _wrap_class_path = { "path", "path", &SWIGTYPE_p_std__filesystem__path,_proxy__wrap_new_path, swig_delete_path, swig_path_methods, swig_path_attributes, &swig_path_Sf_SwigStatic, swig_path_meta, swig_path_bases, swig_path_base_names }; - -static int _wrap_new_IntVector__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::vector< int > *result = 0 ; - SWIG_check_num_args("std::vector< int >::vector",0,0) result = (std::vector< int > *)new std::vector< int >(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_int_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_IntVector__SWIG_1(lua_State* L) { int SWIG_arg = 0; unsigned int arg1 ; std::vector< int > *result = 0 ; - SWIG_check_num_args("std::vector< int >::vector",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("std::vector< int >::vector",1,"unsigned int"); - SWIG_contract_assert((lua_tonumber(L,1)>=0),"number must not be negative") arg1 = (unsigned int)lua_tonumber(L, 1); - result = (std::vector< int > *)new std::vector< int >(arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_int_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_IntVector__SWIG_2(lua_State* L) { int SWIG_arg = 0; std::vector< int > *arg1 = 0 ; - std::vector< int > *result = 0 ; SWIG_check_num_args("std::vector< int >::vector",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("std::vector< int >::vector",1,"std::vector< int > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_int_t,0))){ - SWIG_fail_ptr("new_IntVector",1,SWIGTYPE_p_std__vectorT_int_t); } - result = (std::vector< int > *)new std::vector< int >((std::vector< int > const &)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_int_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_IntVector__SWIG_3(lua_State* L) { int SWIG_arg = 0; unsigned int arg1 ; int arg2 ; - std::vector< int > *result = 0 ; SWIG_check_num_args("std::vector< int >::vector",2,2) - if(!lua_isnumber(L,1)) SWIG_fail_arg("std::vector< int >::vector",1,"unsigned int"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("std::vector< int >::vector",2,"int"); - SWIG_contract_assert((lua_tonumber(L,1)>=0),"number must not be negative") arg1 = (unsigned int)lua_tonumber(L, 1); - arg2 = (int)lua_tonumber(L, 2); result = (std::vector< int > *)new std::vector< int >(arg1,arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_int_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_IntVector(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_IntVector__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_std__vectorT_int_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_new_IntVector__SWIG_2(L);} } if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_new_IntVector__SWIG_1(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_new_IntVector__SWIG_3(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_IntVector'\n" " Possible C/C++ prototypes are:\n" - " std::vector< int >::vector()\n" " std::vector< int >::vector(unsigned int)\n" - " std::vector< int >::vector(std::vector< int > const &)\n" " std::vector< int >::vector(unsigned int,int)\n"); - lua_error(L);return 0; } -static int _wrap_IntVector_size(lua_State* L) { int SWIG_arg = 0; std::vector< int > *arg1 = (std::vector< int > *) 0 ; - unsigned int result; SWIG_check_num_args("std::vector< int >::size",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< int >::size",1,"std::vector< int > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_int_t,0))){ - SWIG_fail_ptr("IntVector_size",1,SWIGTYPE_p_std__vectorT_int_t); } - result = (unsigned int)((std::vector< int > const *)arg1)->size(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_IntVector_max_size(lua_State* L) { int SWIG_arg = 0; std::vector< int > *arg1 = (std::vector< int > *) 0 ; - unsigned int result; SWIG_check_num_args("std::vector< int >::max_size",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< int >::max_size",1,"std::vector< int > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_int_t,0))){ - SWIG_fail_ptr("IntVector_max_size",1,SWIGTYPE_p_std__vectorT_int_t); } - result = (unsigned int)((std::vector< int > const *)arg1)->max_size(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_IntVector_empty(lua_State* L) { int SWIG_arg = 0; std::vector< int > *arg1 = (std::vector< int > *) 0 ; - bool result; SWIG_check_num_args("std::vector< int >::empty",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< int >::empty",1,"std::vector< int > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_int_t,0))){ - SWIG_fail_ptr("IntVector_empty",1,SWIGTYPE_p_std__vectorT_int_t); } - result = (bool)((std::vector< int > const *)arg1)->empty(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_IntVector_clear(lua_State* L) { int SWIG_arg = 0; std::vector< int > *arg1 = (std::vector< int > *) 0 ; - SWIG_check_num_args("std::vector< int >::clear",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< int >::clear",1,"std::vector< int > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_int_t,0))){ - SWIG_fail_ptr("IntVector_clear",1,SWIGTYPE_p_std__vectorT_int_t); } (arg1)->clear(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_IntVector_push_back(lua_State* L) { int SWIG_arg = 0; std::vector< int > *arg1 = (std::vector< int > *) 0 ; - int arg2 ; SWIG_check_num_args("std::vector< int >::push_back",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< int >::push_back",1,"std::vector< int > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("std::vector< int >::push_back",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_int_t,0))){ - SWIG_fail_ptr("IntVector_push_back",1,SWIGTYPE_p_std__vectorT_int_t); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->push_back(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_IntVector_pop_back(lua_State* L) { int SWIG_arg = 0; std::vector< int > *arg1 = (std::vector< int > *) 0 ; - SWIG_check_num_args("std::vector< int >::pop_back",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< int >::pop_back",1,"std::vector< int > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_int_t,0))){ - SWIG_fail_ptr("IntVector_pop_back",1,SWIGTYPE_p_std__vectorT_int_t); } (arg1)->pop_back(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_IntVector_front(lua_State* L) { int SWIG_arg = 0; std::vector< int > *arg1 = (std::vector< int > *) 0 ; - int result; SWIG_check_num_args("std::vector< int >::front",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< int >::front",1,"std::vector< int > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_int_t,0))){ - SWIG_fail_ptr("IntVector_front",1,SWIGTYPE_p_std__vectorT_int_t); } - result = (int)((std::vector< int > const *)arg1)->front(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_IntVector_back(lua_State* L) { int SWIG_arg = 0; std::vector< int > *arg1 = (std::vector< int > *) 0 ; - int result; SWIG_check_num_args("std::vector< int >::back",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< int >::back",1,"std::vector< int > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_int_t,0))){ - SWIG_fail_ptr("IntVector_back",1,SWIGTYPE_p_std__vectorT_int_t); } - result = (int)((std::vector< int > const *)arg1)->back(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_IntVector___getitem(lua_State* L) { int SWIG_arg = 0; std::vector< int > *arg1 = (std::vector< int > *) 0 ; - unsigned int arg2 ; int result; SWIG_check_num_args("std::vector< int >::__getitem__",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< int >::__getitem__",1,"std::vector< int > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("std::vector< int >::__getitem__",2,"unsigned int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_int_t,0))){ - SWIG_fail_ptr("IntVector___getitem",1,SWIGTYPE_p_std__vectorT_int_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned int)lua_tonumber(L, 2); try { - result = (int)std_vector_Sl_int_Sg____getitem__(arg1,arg2);} catch(std::out_of_range &_e) { - SWIG_exception(SWIG_IndexError, (&_e)->what()); } lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_IntVector___setitem(lua_State* L) { int SWIG_arg = 0; std::vector< int > *arg1 = (std::vector< int > *) 0 ; - unsigned int arg2 ; int arg3 ; SWIG_check_num_args("std::vector< int >::__setitem__",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< int >::__setitem__",1,"std::vector< int > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("std::vector< int >::__setitem__",2,"unsigned int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("std::vector< int >::__setitem__",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_int_t,0))){ - SWIG_fail_ptr("IntVector___setitem",1,SWIGTYPE_p_std__vectorT_int_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); try { std_vector_Sl_int_Sg____setitem__(arg1,arg2,arg3);} catch(std::out_of_range &_e) { - SWIG_exception(SWIG_IndexError, (&_e)->what()); } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_IntVector(void *obj) { -std::vector< int > *arg1 = (std::vector< int > *) obj; -delete arg1; -} -static int _proxy__wrap_new_IntVector(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_IntVector); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_IntVector_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_IntVector_methods[]= { - { "size", _wrap_IntVector_size}, - { "max_size", _wrap_IntVector_max_size}, - { "empty", _wrap_IntVector_empty}, - { "clear", _wrap_IntVector_clear}, - { "push_back", _wrap_IntVector_push_back}, - { "pop_back", _wrap_IntVector_pop_back}, - { "front", _wrap_IntVector_front}, - { "back", _wrap_IntVector_back}, - { "__getitem", _wrap_IntVector___getitem}, - { "__setitem", _wrap_IntVector___setitem}, - {0,0} -}; -static swig_lua_method swig_IntVector_meta[] = { - { "__getitem", _wrap_IntVector___getitem}, - { "__setitem", _wrap_IntVector___setitem}, - {0,0} -}; - -static swig_lua_attribute swig_IntVector_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_IntVector_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_IntVector_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_IntVector_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_IntVector_Sf_SwigStatic = { - "IntVector", - swig_IntVector_Sf_SwigStatic_methods, - swig_IntVector_Sf_SwigStatic_attributes, - swig_IntVector_Sf_SwigStatic_constants, - swig_IntVector_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_IntVector_bases[] = {0}; -static const char *swig_IntVector_base_names[] = {0}; -static swig_lua_class _wrap_class_IntVector = { "IntVector", "IntVector", &SWIGTYPE_p_std__vectorT_int_t,_proxy__wrap_new_IntVector, swig_delete_IntVector, swig_IntVector_methods, swig_IntVector_attributes, &swig_IntVector_Sf_SwigStatic, swig_IntVector_meta, swig_IntVector_bases, swig_IntVector_base_names }; - -static int _wrap_new_FloatVector__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::vector< float > *result = 0 ; - SWIG_check_num_args("std::vector< float >::vector",0,0) result = (std::vector< float > *)new std::vector< float >(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_float_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_FloatVector__SWIG_1(lua_State* L) { int SWIG_arg = 0; unsigned int arg1 ; - std::vector< float > *result = 0 ; SWIG_check_num_args("std::vector< float >::vector",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("std::vector< float >::vector",1,"unsigned int"); - SWIG_contract_assert((lua_tonumber(L,1)>=0),"number must not be negative") arg1 = (unsigned int)lua_tonumber(L, 1); - result = (std::vector< float > *)new std::vector< float >(arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_float_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_FloatVector__SWIG_2(lua_State* L) { int SWIG_arg = 0; std::vector< float > *arg1 = 0 ; - std::vector< float > *result = 0 ; SWIG_check_num_args("std::vector< float >::vector",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("std::vector< float >::vector",1,"std::vector< float > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_float_t,0))){ - SWIG_fail_ptr("new_FloatVector",1,SWIGTYPE_p_std__vectorT_float_t); } - result = (std::vector< float > *)new std::vector< float >((std::vector< float > const &)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_float_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_FloatVector__SWIG_3(lua_State* L) { int SWIG_arg = 0; unsigned int arg1 ; float arg2 ; - std::vector< float > *result = 0 ; SWIG_check_num_args("std::vector< float >::vector",2,2) - if(!lua_isnumber(L,1)) SWIG_fail_arg("std::vector< float >::vector",1,"unsigned int"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("std::vector< float >::vector",2,"float"); - SWIG_contract_assert((lua_tonumber(L,1)>=0),"number must not be negative") arg1 = (unsigned int)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); result = (std::vector< float > *)new std::vector< float >(arg1,arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_float_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_FloatVector(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_FloatVector__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_std__vectorT_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_new_FloatVector__SWIG_2(L);} } if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_new_FloatVector__SWIG_1(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_new_FloatVector__SWIG_3(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_FloatVector'\n" " Possible C/C++ prototypes are:\n" - " std::vector< float >::vector()\n" " std::vector< float >::vector(unsigned int)\n" - " std::vector< float >::vector(std::vector< float > const &)\n" " std::vector< float >::vector(unsigned int,float)\n"); - lua_error(L);return 0; } -static int _wrap_FloatVector_size(lua_State* L) { int SWIG_arg = 0; std::vector< float > *arg1 = (std::vector< float > *) 0 ; - unsigned int result; SWIG_check_num_args("std::vector< float >::size",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< float >::size",1,"std::vector< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_float_t,0))){ - SWIG_fail_ptr("FloatVector_size",1,SWIGTYPE_p_std__vectorT_float_t); } - result = (unsigned int)((std::vector< float > const *)arg1)->size(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatVector_max_size(lua_State* L) { int SWIG_arg = 0; - std::vector< float > *arg1 = (std::vector< float > *) 0 ; unsigned int result; - SWIG_check_num_args("std::vector< float >::max_size",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< float >::max_size",1,"std::vector< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_float_t,0))){ - SWIG_fail_ptr("FloatVector_max_size",1,SWIGTYPE_p_std__vectorT_float_t); } - result = (unsigned int)((std::vector< float > const *)arg1)->max_size(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatVector_empty(lua_State* L) { int SWIG_arg = 0; std::vector< float > *arg1 = (std::vector< float > *) 0 ; - bool result; SWIG_check_num_args("std::vector< float >::empty",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< float >::empty",1,"std::vector< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_float_t,0))){ - SWIG_fail_ptr("FloatVector_empty",1,SWIGTYPE_p_std__vectorT_float_t); } - result = (bool)((std::vector< float > const *)arg1)->empty(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatVector_clear(lua_State* L) { int SWIG_arg = 0; std::vector< float > *arg1 = (std::vector< float > *) 0 ; - SWIG_check_num_args("std::vector< float >::clear",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< float >::clear",1,"std::vector< float > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_float_t,0))){ - SWIG_fail_ptr("FloatVector_clear",1,SWIGTYPE_p_std__vectorT_float_t); } (arg1)->clear(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatVector_push_back(lua_State* L) { int SWIG_arg = 0; - std::vector< float > *arg1 = (std::vector< float > *) 0 ; float arg2 ; - SWIG_check_num_args("std::vector< float >::push_back",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< float >::push_back",1,"std::vector< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("std::vector< float >::push_back",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_float_t,0))){ - SWIG_fail_ptr("FloatVector_push_back",1,SWIGTYPE_p_std__vectorT_float_t); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->push_back(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatVector_pop_back(lua_State* L) { int SWIG_arg = 0; - std::vector< float > *arg1 = (std::vector< float > *) 0 ; SWIG_check_num_args("std::vector< float >::pop_back",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< float >::pop_back",1,"std::vector< float > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_float_t,0))){ - SWIG_fail_ptr("FloatVector_pop_back",1,SWIGTYPE_p_std__vectorT_float_t); } (arg1)->pop_back(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatVector_front(lua_State* L) { int SWIG_arg = 0; std::vector< float > *arg1 = (std::vector< float > *) 0 ; - float result; SWIG_check_num_args("std::vector< float >::front",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< float >::front",1,"std::vector< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_float_t,0))){ - SWIG_fail_ptr("FloatVector_front",1,SWIGTYPE_p_std__vectorT_float_t); } - result = (float)((std::vector< float > const *)arg1)->front(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatVector_back(lua_State* L) { int SWIG_arg = 0; std::vector< float > *arg1 = (std::vector< float > *) 0 ; - float result; SWIG_check_num_args("std::vector< float >::back",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< float >::back",1,"std::vector< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_float_t,0))){ - SWIG_fail_ptr("FloatVector_back",1,SWIGTYPE_p_std__vectorT_float_t); } - result = (float)((std::vector< float > const *)arg1)->back(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatVector___getitem(lua_State* L) { int SWIG_arg = 0; - std::vector< float > *arg1 = (std::vector< float > *) 0 ; unsigned int arg2 ; float result; - SWIG_check_num_args("std::vector< float >::__getitem__",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< float >::__getitem__",1,"std::vector< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("std::vector< float >::__getitem__",2,"unsigned int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_float_t,0))){ - SWIG_fail_ptr("FloatVector___getitem",1,SWIGTYPE_p_std__vectorT_float_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned int)lua_tonumber(L, 2); try { - result = (float)std_vector_Sl_float_Sg____getitem__(arg1,arg2);} catch(std::out_of_range &_e) { - SWIG_exception(SWIG_IndexError, (&_e)->what()); } lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatVector___setitem(lua_State* L) { int SWIG_arg = 0; - std::vector< float > *arg1 = (std::vector< float > *) 0 ; unsigned int arg2 ; float arg3 ; - SWIG_check_num_args("std::vector< float >::__setitem__",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< float >::__setitem__",1,"std::vector< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("std::vector< float >::__setitem__",2,"unsigned int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("std::vector< float >::__setitem__",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_float_t,0))){ - SWIG_fail_ptr("FloatVector___setitem",1,SWIGTYPE_p_std__vectorT_float_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned int)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); try { std_vector_Sl_float_Sg____setitem__(arg1,arg2,arg3);} catch(std::out_of_range &_e) { - SWIG_exception(SWIG_IndexError, (&_e)->what()); } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_FloatVector(void *obj) { -std::vector< float > *arg1 = (std::vector< float > *) obj; -delete arg1; -} -static int _proxy__wrap_new_FloatVector(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_FloatVector); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_FloatVector_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_FloatVector_methods[]= { - { "size", _wrap_FloatVector_size}, - { "max_size", _wrap_FloatVector_max_size}, - { "empty", _wrap_FloatVector_empty}, - { "clear", _wrap_FloatVector_clear}, - { "push_back", _wrap_FloatVector_push_back}, - { "pop_back", _wrap_FloatVector_pop_back}, - { "front", _wrap_FloatVector_front}, - { "back", _wrap_FloatVector_back}, - { "__getitem", _wrap_FloatVector___getitem}, - { "__setitem", _wrap_FloatVector___setitem}, - {0,0} -}; -static swig_lua_method swig_FloatVector_meta[] = { - { "__getitem", _wrap_FloatVector___getitem}, - { "__setitem", _wrap_FloatVector___setitem}, - {0,0} -}; - -static swig_lua_attribute swig_FloatVector_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_FloatVector_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_FloatVector_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_FloatVector_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_FloatVector_Sf_SwigStatic = { - "FloatVector", - swig_FloatVector_Sf_SwigStatic_methods, - swig_FloatVector_Sf_SwigStatic_attributes, - swig_FloatVector_Sf_SwigStatic_constants, - swig_FloatVector_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_FloatVector_bases[] = {0}; -static const char *swig_FloatVector_base_names[] = {0}; -static swig_lua_class _wrap_class_FloatVector = { "FloatVector", "FloatVector", &SWIGTYPE_p_std__vectorT_float_t,_proxy__wrap_new_FloatVector, swig_delete_FloatVector, swig_FloatVector_methods, swig_FloatVector_attributes, &swig_FloatVector_Sf_SwigStatic, swig_FloatVector_meta, swig_FloatVector_bases, swig_FloatVector_base_names }; - -static int _wrap_new_StringVector__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::vector< std::string > *result = 0 ; - SWIG_check_num_args("std::vector< std::string >::vector",0,0) - result = (std::vector< std::string > *)new std::vector< std::string >(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_std__string_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_StringVector__SWIG_1(lua_State* L) { int SWIG_arg = 0; unsigned int arg1 ; - std::vector< std::string > *result = 0 ; SWIG_check_num_args("std::vector< std::string >::vector",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("std::vector< std::string >::vector",1,"unsigned int"); - SWIG_contract_assert((lua_tonumber(L,1)>=0),"number must not be negative") arg1 = (unsigned int)lua_tonumber(L, 1); - result = (std::vector< std::string > *)new std::vector< std::string >(arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_std__string_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_StringVector__SWIG_2(lua_State* L) { int SWIG_arg = 0; std::vector< std::string > *arg1 = 0 ; - std::vector< std::string > *result = 0 ; SWIG_check_num_args("std::vector< std::string >::vector",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("std::vector< std::string >::vector",1,"std::vector< std::string > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_std__string_t,0))){ - SWIG_fail_ptr("new_StringVector",1,SWIGTYPE_p_std__vectorT_std__string_t); } - result = (std::vector< std::string > *)new std::vector< std::string >((std::vector< std::string > const &)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_std__string_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_StringVector__SWIG_3(lua_State* L) { int SWIG_arg = 0; unsigned int arg1 ; std::string arg2 ; - std::vector< std::string > *result = 0 ; SWIG_check_num_args("std::vector< std::string >::vector",2,2) - if(!lua_isnumber(L,1)) SWIG_fail_arg("std::vector< std::string >::vector",1,"unsigned int"); - if(!lua_isstring(L,2)) SWIG_fail_arg("std::vector< std::string >::vector",2,"std::string"); - SWIG_contract_assert((lua_tonumber(L,1)>=0),"number must not be negative") arg1 = (unsigned int)lua_tonumber(L, 1); - (&arg2)->assign(lua_tostring(L,2),lua_rawlen(L,2)); - result = (std::vector< std::string > *)new std::vector< std::string >(arg1,arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_std__string_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_StringVector(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_StringVector__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_std__vectorT_std__string_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_new_StringVector__SWIG_2(L);} } if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_new_StringVector__SWIG_1(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { - return _wrap_new_StringVector__SWIG_3(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_StringVector'\n" " Possible C/C++ prototypes are:\n" - " std::vector< std::string >::vector()\n" " std::vector< std::string >::vector(unsigned int)\n" - " std::vector< std::string >::vector(std::vector< std::string > const &)\n" - " std::vector< std::string >::vector(unsigned int,std::string)\n"); lua_error(L);return 0; } -static int _wrap_StringVector_size(lua_State* L) { int SWIG_arg = 0; - std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ; unsigned int result; - SWIG_check_num_args("std::vector< std::string >::size",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< std::string >::size",1,"std::vector< std::string > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_std__string_t,0))){ - SWIG_fail_ptr("StringVector_size",1,SWIGTYPE_p_std__vectorT_std__string_t); } - result = (unsigned int)((std::vector< std::string > const *)arg1)->size(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_StringVector_max_size(lua_State* L) { int SWIG_arg = 0; - std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ; unsigned int result; - SWIG_check_num_args("std::vector< std::string >::max_size",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< std::string >::max_size",1,"std::vector< std::string > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_std__string_t,0))){ - SWIG_fail_ptr("StringVector_max_size",1,SWIGTYPE_p_std__vectorT_std__string_t); } - result = (unsigned int)((std::vector< std::string > const *)arg1)->max_size(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_StringVector_empty(lua_State* L) { int SWIG_arg = 0; - std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ; bool result; - SWIG_check_num_args("std::vector< std::string >::empty",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< std::string >::empty",1,"std::vector< std::string > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_std__string_t,0))){ - SWIG_fail_ptr("StringVector_empty",1,SWIGTYPE_p_std__vectorT_std__string_t); } - result = (bool)((std::vector< std::string > const *)arg1)->empty(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_StringVector_clear(lua_State* L) { int SWIG_arg = 0; - std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ; - SWIG_check_num_args("std::vector< std::string >::clear",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< std::string >::clear",1,"std::vector< std::string > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_std__string_t,0))){ - SWIG_fail_ptr("StringVector_clear",1,SWIGTYPE_p_std__vectorT_std__string_t); } (arg1)->clear(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_StringVector_push_back(lua_State* L) { int SWIG_arg = 0; - std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ; std::string arg2 ; - SWIG_check_num_args("std::vector< std::string >::push_back",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< std::string >::push_back",1,"std::vector< std::string > *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("std::vector< std::string >::push_back",2,"std::string"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_std__string_t,0))){ - SWIG_fail_ptr("StringVector_push_back",1,SWIGTYPE_p_std__vectorT_std__string_t); } - (&arg2)->assign(lua_tostring(L,2),lua_rawlen(L,2)); (arg1)->push_back(arg2); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_StringVector_pop_back(lua_State* L) { int SWIG_arg = 0; - std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ; - SWIG_check_num_args("std::vector< std::string >::pop_back",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< std::string >::pop_back",1,"std::vector< std::string > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_std__string_t,0))){ - SWIG_fail_ptr("StringVector_pop_back",1,SWIGTYPE_p_std__vectorT_std__string_t); } (arg1)->pop_back(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_StringVector_front(lua_State* L) { int SWIG_arg = 0; - std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ; std::string result; - SWIG_check_num_args("std::vector< std::string >::front",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< std::string >::front",1,"std::vector< std::string > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_std__string_t,0))){ - SWIG_fail_ptr("StringVector_front",1,SWIGTYPE_p_std__vectorT_std__string_t); } - result = ((std::vector< std::string > const *)arg1)->front(); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_StringVector_back(lua_State* L) { int SWIG_arg = 0; - std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ; std::string result; - SWIG_check_num_args("std::vector< std::string >::back",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< std::string >::back",1,"std::vector< std::string > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_std__string_t,0))){ - SWIG_fail_ptr("StringVector_back",1,SWIGTYPE_p_std__vectorT_std__string_t); } - result = ((std::vector< std::string > const *)arg1)->back(); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_StringVector___getitem(lua_State* L) { int SWIG_arg = 0; - std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ; unsigned int arg2 ; std::string result; - SWIG_check_num_args("std::vector< std::string >::__getitem__",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< std::string >::__getitem__",1,"std::vector< std::string > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("std::vector< std::string >::__getitem__",2,"unsigned int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_std__string_t,0))){ - SWIG_fail_ptr("StringVector___getitem",1,SWIGTYPE_p_std__vectorT_std__string_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned int)lua_tonumber(L, 2); try { - result = std_vector_Sl_std_string_Sg____getitem__(arg1,arg2);} catch(std::out_of_range &_e) { - SWIG_exception(SWIG_IndexError, (&_e)->what()); } lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_StringVector___setitem(lua_State* L) { int SWIG_arg = 0; - std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ; unsigned int arg2 ; std::string arg3 ; - SWIG_check_num_args("std::vector< std::string >::__setitem__",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< std::string >::__setitem__",1,"std::vector< std::string > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("std::vector< std::string >::__setitem__",2,"unsigned int"); - if(!lua_isstring(L,3)) SWIG_fail_arg("std::vector< std::string >::__setitem__",3,"std::string"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_std__string_t,0))){ - SWIG_fail_ptr("StringVector___setitem",1,SWIGTYPE_p_std__vectorT_std__string_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned int)lua_tonumber(L, 2); - (&arg3)->assign(lua_tostring(L,3),lua_rawlen(L,3)); try { std_vector_Sl_std_string_Sg____setitem__(arg1,arg2,arg3);} - catch(std::out_of_range &_e) { SWIG_exception(SWIG_IndexError, (&_e)->what()); } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static void swig_delete_StringVector(void *obj) { -std::vector< std::string > *arg1 = (std::vector< std::string > *) obj; -delete arg1; -} -static int _proxy__wrap_new_StringVector(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_StringVector); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_StringVector_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_StringVector_methods[]= { - { "size", _wrap_StringVector_size}, - { "max_size", _wrap_StringVector_max_size}, - { "empty", _wrap_StringVector_empty}, - { "clear", _wrap_StringVector_clear}, - { "push_back", _wrap_StringVector_push_back}, - { "pop_back", _wrap_StringVector_pop_back}, - { "front", _wrap_StringVector_front}, - { "back", _wrap_StringVector_back}, - { "__getitem", _wrap_StringVector___getitem}, - { "__setitem", _wrap_StringVector___setitem}, - {0,0} -}; -static swig_lua_method swig_StringVector_meta[] = { - { "__getitem", _wrap_StringVector___getitem}, - { "__setitem", _wrap_StringVector___setitem}, - {0,0} -}; - -static swig_lua_attribute swig_StringVector_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_StringVector_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_StringVector_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_StringVector_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_StringVector_Sf_SwigStatic = { - "StringVector", - swig_StringVector_Sf_SwigStatic_methods, - swig_StringVector_Sf_SwigStatic_attributes, - swig_StringVector_Sf_SwigStatic_constants, - swig_StringVector_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_StringVector_bases[] = {0}; -static const char *swig_StringVector_base_names[] = {0}; -static swig_lua_class _wrap_class_StringVector = { "StringVector", "StringVector", &SWIGTYPE_p_std__vectorT_std__string_t,_proxy__wrap_new_StringVector, swig_delete_StringVector, swig_StringVector_methods, swig_StringVector_attributes, &swig_StringVector_Sf_SwigStatic, swig_StringVector_meta, swig_StringVector_bases, swig_StringVector_base_names }; - -static int _wrap_new_UCharVector__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::vector< unsigned char > *result = 0 ; - SWIG_check_num_args("std::vector< unsigned char >::vector",0,0) - result = (std::vector< unsigned char > *)new std::vector< unsigned char >(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_unsigned_char_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_UCharVector__SWIG_1(lua_State* L) { int SWIG_arg = 0; unsigned int arg1 ; - std::vector< unsigned char > *result = 0 ; SWIG_check_num_args("std::vector< unsigned char >::vector",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("std::vector< unsigned char >::vector",1,"unsigned int"); - SWIG_contract_assert((lua_tonumber(L,1)>=0),"number must not be negative") arg1 = (unsigned int)lua_tonumber(L, 1); - result = (std::vector< unsigned char > *)new std::vector< unsigned char >(arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_unsigned_char_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_UCharVector__SWIG_2(lua_State* L) { int SWIG_arg = 0; std::vector< unsigned char > *arg1 = 0 ; - std::vector< unsigned char > *result = 0 ; SWIG_check_num_args("std::vector< unsigned char >::vector",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("std::vector< unsigned char >::vector",1,"std::vector< unsigned char > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_unsigned_char_t,0))){ - SWIG_fail_ptr("new_UCharVector",1,SWIGTYPE_p_std__vectorT_unsigned_char_t); } - result = (std::vector< unsigned char > *)new std::vector< unsigned char >((std::vector< unsigned char > const &)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_unsigned_char_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_UCharVector__SWIG_3(lua_State* L) { int SWIG_arg = 0; unsigned int arg1 ; unsigned char arg2 ; - std::vector< unsigned char > *result = 0 ; SWIG_check_num_args("std::vector< unsigned char >::vector",2,2) - if(!lua_isnumber(L,1)) SWIG_fail_arg("std::vector< unsigned char >::vector",1,"unsigned int"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("std::vector< unsigned char >::vector",2,"unsigned char"); - SWIG_contract_assert((lua_tonumber(L,1)>=0),"number must not be negative") arg1 = (unsigned int)lua_tonumber(L, 1); - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned char)lua_tonumber(L, 2); - result = (std::vector< unsigned char > *)new std::vector< unsigned char >(arg1,arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_unsigned_char_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_UCharVector(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_UCharVector__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_std__vectorT_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_new_UCharVector__SWIG_2(L);} } if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_new_UCharVector__SWIG_1(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_new_UCharVector__SWIG_3(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_UCharVector'\n" " Possible C/C++ prototypes are:\n" - " std::vector< unsigned char >::vector()\n" " std::vector< unsigned char >::vector(unsigned int)\n" - " std::vector< unsigned char >::vector(std::vector< unsigned char > const &)\n" - " std::vector< unsigned char >::vector(unsigned int,unsigned char)\n"); lua_error(L);return 0; } -static int _wrap_UCharVector_size(lua_State* L) { int SWIG_arg = 0; - std::vector< unsigned char > *arg1 = (std::vector< unsigned char > *) 0 ; unsigned int result; - SWIG_check_num_args("std::vector< unsigned char >::size",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< unsigned char >::size",1,"std::vector< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_unsigned_char_t,0))){ - SWIG_fail_ptr("UCharVector_size",1,SWIGTYPE_p_std__vectorT_unsigned_char_t); } - result = (unsigned int)((std::vector< unsigned char > const *)arg1)->size(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_UCharVector_max_size(lua_State* L) { int SWIG_arg = 0; - std::vector< unsigned char > *arg1 = (std::vector< unsigned char > *) 0 ; unsigned int result; - SWIG_check_num_args("std::vector< unsigned char >::max_size",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< unsigned char >::max_size",1,"std::vector< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_unsigned_char_t,0))){ - SWIG_fail_ptr("UCharVector_max_size",1,SWIGTYPE_p_std__vectorT_unsigned_char_t); } - result = (unsigned int)((std::vector< unsigned char > const *)arg1)->max_size(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_UCharVector_empty(lua_State* L) { int SWIG_arg = 0; - std::vector< unsigned char > *arg1 = (std::vector< unsigned char > *) 0 ; bool result; - SWIG_check_num_args("std::vector< unsigned char >::empty",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< unsigned char >::empty",1,"std::vector< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_unsigned_char_t,0))){ - SWIG_fail_ptr("UCharVector_empty",1,SWIGTYPE_p_std__vectorT_unsigned_char_t); } - result = (bool)((std::vector< unsigned char > const *)arg1)->empty(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_UCharVector_clear(lua_State* L) { int SWIG_arg = 0; - std::vector< unsigned char > *arg1 = (std::vector< unsigned char > *) 0 ; - SWIG_check_num_args("std::vector< unsigned char >::clear",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< unsigned char >::clear",1,"std::vector< unsigned char > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_unsigned_char_t,0))){ - SWIG_fail_ptr("UCharVector_clear",1,SWIGTYPE_p_std__vectorT_unsigned_char_t); } (arg1)->clear(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_UCharVector_push_back(lua_State* L) { int SWIG_arg = 0; - std::vector< unsigned char > *arg1 = (std::vector< unsigned char > *) 0 ; unsigned char arg2 ; - SWIG_check_num_args("std::vector< unsigned char >::push_back",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< unsigned char >::push_back",1,"std::vector< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("std::vector< unsigned char >::push_back",2,"unsigned char"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_unsigned_char_t,0))){ - SWIG_fail_ptr("UCharVector_push_back",1,SWIGTYPE_p_std__vectorT_unsigned_char_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned char)lua_tonumber(L, 2); - (arg1)->push_back(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_UCharVector_pop_back(lua_State* L) { int SWIG_arg = 0; - std::vector< unsigned char > *arg1 = (std::vector< unsigned char > *) 0 ; - SWIG_check_num_args("std::vector< unsigned char >::pop_back",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< unsigned char >::pop_back",1,"std::vector< unsigned char > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_unsigned_char_t,0))){ - SWIG_fail_ptr("UCharVector_pop_back",1,SWIGTYPE_p_std__vectorT_unsigned_char_t); } (arg1)->pop_back(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_UCharVector_front(lua_State* L) { int SWIG_arg = 0; - std::vector< unsigned char > *arg1 = (std::vector< unsigned char > *) 0 ; unsigned char result; - SWIG_check_num_args("std::vector< unsigned char >::front",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< unsigned char >::front",1,"std::vector< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_unsigned_char_t,0))){ - SWIG_fail_ptr("UCharVector_front",1,SWIGTYPE_p_std__vectorT_unsigned_char_t); } - result = (unsigned char)((std::vector< unsigned char > const *)arg1)->front(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_UCharVector_back(lua_State* L) { int SWIG_arg = 0; - std::vector< unsigned char > *arg1 = (std::vector< unsigned char > *) 0 ; unsigned char result; - SWIG_check_num_args("std::vector< unsigned char >::back",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< unsigned char >::back",1,"std::vector< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_unsigned_char_t,0))){ - SWIG_fail_ptr("UCharVector_back",1,SWIGTYPE_p_std__vectorT_unsigned_char_t); } - result = (unsigned char)((std::vector< unsigned char > const *)arg1)->back(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_UCharVector___getitem(lua_State* L) { int SWIG_arg = 0; - std::vector< unsigned char > *arg1 = (std::vector< unsigned char > *) 0 ; unsigned int arg2 ; unsigned char result; - SWIG_check_num_args("std::vector< unsigned char >::__getitem__",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< unsigned char >::__getitem__",1,"std::vector< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("std::vector< unsigned char >::__getitem__",2,"unsigned int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_unsigned_char_t,0))){ - SWIG_fail_ptr("UCharVector___getitem",1,SWIGTYPE_p_std__vectorT_unsigned_char_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned int)lua_tonumber(L, 2); try { - result = (unsigned char)std_vector_Sl_unsigned_SS_char_Sg____getitem__(arg1,arg2);} catch(std::out_of_range &_e) { - SWIG_exception(SWIG_IndexError, (&_e)->what()); } lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_UCharVector___setitem(lua_State* L) { int SWIG_arg = 0; - std::vector< unsigned char > *arg1 = (std::vector< unsigned char > *) 0 ; unsigned int arg2 ; unsigned char arg3 ; - SWIG_check_num_args("std::vector< unsigned char >::__setitem__",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< unsigned char >::__setitem__",1,"std::vector< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("std::vector< unsigned char >::__setitem__",2,"unsigned int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("std::vector< unsigned char >::__setitem__",3,"unsigned char"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_unsigned_char_t,0))){ - SWIG_fail_ptr("UCharVector___setitem",1,SWIGTYPE_p_std__vectorT_unsigned_char_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned int)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (unsigned char)lua_tonumber(L, 3); try { - std_vector_Sl_unsigned_SS_char_Sg____setitem__(arg1,arg2,arg3);} catch(std::out_of_range &_e) { - SWIG_exception(SWIG_IndexError, (&_e)->what()); } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_UCharVector(void *obj) { -std::vector< unsigned char > *arg1 = (std::vector< unsigned char > *) obj; -delete arg1; -} -static int _proxy__wrap_new_UCharVector(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_UCharVector); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_UCharVector_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_UCharVector_methods[]= { - { "size", _wrap_UCharVector_size}, - { "max_size", _wrap_UCharVector_max_size}, - { "empty", _wrap_UCharVector_empty}, - { "clear", _wrap_UCharVector_clear}, - { "push_back", _wrap_UCharVector_push_back}, - { "pop_back", _wrap_UCharVector_pop_back}, - { "front", _wrap_UCharVector_front}, - { "back", _wrap_UCharVector_back}, - { "__getitem", _wrap_UCharVector___getitem}, - { "__setitem", _wrap_UCharVector___setitem}, - {0,0} -}; -static swig_lua_method swig_UCharVector_meta[] = { - { "__getitem", _wrap_UCharVector___getitem}, - { "__setitem", _wrap_UCharVector___setitem}, - {0,0} -}; - -static swig_lua_attribute swig_UCharVector_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_UCharVector_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_UCharVector_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_UCharVector_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_UCharVector_Sf_SwigStatic = { - "UCharVector", - swig_UCharVector_Sf_SwigStatic_methods, - swig_UCharVector_Sf_SwigStatic_attributes, - swig_UCharVector_Sf_SwigStatic_constants, - swig_UCharVector_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_UCharVector_bases[] = {0}; -static const char *swig_UCharVector_base_names[] = {0}; -static swig_lua_class _wrap_class_UCharVector = { "UCharVector", "UCharVector", &SWIGTYPE_p_std__vectorT_unsigned_char_t,_proxy__wrap_new_UCharVector, swig_delete_UCharVector, swig_UCharVector_methods, swig_UCharVector_attributes, &swig_UCharVector_Sf_SwigStatic, swig_UCharVector_meta, swig_UCharVector_bases, swig_UCharVector_base_names }; - -static int _wrap_new_VideoDeviceVector__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::vector< ofVideoDevice > *result = 0 ; - SWIG_check_num_args("std::vector< ofVideoDevice >::vector",0,0) - result = (std::vector< ofVideoDevice > *)new std::vector< ofVideoDevice >(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofVideoDevice_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_VideoDeviceVector__SWIG_1(lua_State* L) { int SWIG_arg = 0; unsigned int arg1 ; - std::vector< ofVideoDevice > *result = 0 ; SWIG_check_num_args("std::vector< ofVideoDevice >::vector",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("std::vector< ofVideoDevice >::vector",1,"unsigned int"); - SWIG_contract_assert((lua_tonumber(L,1)>=0),"number must not be negative") arg1 = (unsigned int)lua_tonumber(L, 1); - result = (std::vector< ofVideoDevice > *)new std::vector< ofVideoDevice >(arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofVideoDevice_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_VideoDeviceVector__SWIG_2(lua_State* L) { int SWIG_arg = 0; std::vector< ofVideoDevice > *arg1 = 0 ; - std::vector< ofVideoDevice > *result = 0 ; SWIG_check_num_args("std::vector< ofVideoDevice >::vector",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("std::vector< ofVideoDevice >::vector",1,"std::vector< ofVideoDevice > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofVideoDevice_t,0))){ - SWIG_fail_ptr("new_VideoDeviceVector",1,SWIGTYPE_p_std__vectorT_ofVideoDevice_t); } - result = (std::vector< ofVideoDevice > *)new std::vector< ofVideoDevice >((std::vector< ofVideoDevice > const &)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofVideoDevice_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_VideoDeviceVector__SWIG_3(lua_State* L) { int SWIG_arg = 0; unsigned int arg1 ; ofVideoDevice arg2 ; - ofVideoDevice *argp2 ; std::vector< ofVideoDevice > *result = 0 ; - SWIG_check_num_args("std::vector< ofVideoDevice >::vector",2,2) - if(!lua_isnumber(L,1)) SWIG_fail_arg("std::vector< ofVideoDevice >::vector",1,"unsigned int"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("std::vector< ofVideoDevice >::vector",2,"ofVideoDevice"); - SWIG_contract_assert((lua_tonumber(L,1)>=0),"number must not be negative") arg1 = (unsigned int)lua_tonumber(L, 1); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofVideoDevice,0))){ - SWIG_fail_ptr("new_VideoDeviceVector",2,SWIGTYPE_p_ofVideoDevice); } arg2 = *argp2; - result = (std::vector< ofVideoDevice > *)new std::vector< ofVideoDevice >(arg1,arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofVideoDevice_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_VideoDeviceVector(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_VideoDeviceVector__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_std__vectorT_ofVideoDevice_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_new_VideoDeviceVector__SWIG_2(L);} } if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_new_VideoDeviceVector__SWIG_1(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVideoDevice, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_new_VideoDeviceVector__SWIG_3(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_VideoDeviceVector'\n" - " Possible C/C++ prototypes are:\n" " std::vector< ofVideoDevice >::vector()\n" - " std::vector< ofVideoDevice >::vector(unsigned int)\n" - " std::vector< ofVideoDevice >::vector(std::vector< ofVideoDevice > const &)\n" - " std::vector< ofVideoDevice >::vector(unsigned int,ofVideoDevice)\n"); lua_error(L);return 0; } -static int _wrap_VideoDeviceVector_size(lua_State* L) { int SWIG_arg = 0; - std::vector< ofVideoDevice > *arg1 = (std::vector< ofVideoDevice > *) 0 ; unsigned int result; - SWIG_check_num_args("std::vector< ofVideoDevice >::size",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< ofVideoDevice >::size",1,"std::vector< ofVideoDevice > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofVideoDevice_t,0))){ - SWIG_fail_ptr("VideoDeviceVector_size",1,SWIGTYPE_p_std__vectorT_ofVideoDevice_t); } - result = (unsigned int)((std::vector< ofVideoDevice > const *)arg1)->size(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoDeviceVector_max_size(lua_State* L) { int SWIG_arg = 0; - std::vector< ofVideoDevice > *arg1 = (std::vector< ofVideoDevice > *) 0 ; unsigned int result; - SWIG_check_num_args("std::vector< ofVideoDevice >::max_size",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< ofVideoDevice >::max_size",1,"std::vector< ofVideoDevice > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofVideoDevice_t,0))){ - SWIG_fail_ptr("VideoDeviceVector_max_size",1,SWIGTYPE_p_std__vectorT_ofVideoDevice_t); } - result = (unsigned int)((std::vector< ofVideoDevice > const *)arg1)->max_size(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoDeviceVector_empty(lua_State* L) { int SWIG_arg = 0; - std::vector< ofVideoDevice > *arg1 = (std::vector< ofVideoDevice > *) 0 ; bool result; - SWIG_check_num_args("std::vector< ofVideoDevice >::empty",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< ofVideoDevice >::empty",1,"std::vector< ofVideoDevice > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofVideoDevice_t,0))){ - SWIG_fail_ptr("VideoDeviceVector_empty",1,SWIGTYPE_p_std__vectorT_ofVideoDevice_t); } - result = (bool)((std::vector< ofVideoDevice > const *)arg1)->empty(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoDeviceVector_clear(lua_State* L) { int SWIG_arg = 0; - std::vector< ofVideoDevice > *arg1 = (std::vector< ofVideoDevice > *) 0 ; - SWIG_check_num_args("std::vector< ofVideoDevice >::clear",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< ofVideoDevice >::clear",1,"std::vector< ofVideoDevice > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofVideoDevice_t,0))){ - SWIG_fail_ptr("VideoDeviceVector_clear",1,SWIGTYPE_p_std__vectorT_ofVideoDevice_t); } (arg1)->clear(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoDeviceVector_push_back(lua_State* L) { int SWIG_arg = 0; - std::vector< ofVideoDevice > *arg1 = (std::vector< ofVideoDevice > *) 0 ; ofVideoDevice arg2 ; ofVideoDevice *argp2 ; - SWIG_check_num_args("std::vector< ofVideoDevice >::push_back",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< ofVideoDevice >::push_back",1,"std::vector< ofVideoDevice > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("std::vector< ofVideoDevice >::push_back",2,"ofVideoDevice"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofVideoDevice_t,0))){ - SWIG_fail_ptr("VideoDeviceVector_push_back",1,SWIGTYPE_p_std__vectorT_ofVideoDevice_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofVideoDevice,0))){ - SWIG_fail_ptr("VideoDeviceVector_push_back",2,SWIGTYPE_p_ofVideoDevice); } arg2 = *argp2; (arg1)->push_back(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoDeviceVector_pop_back(lua_State* L) { int SWIG_arg = 0; - std::vector< ofVideoDevice > *arg1 = (std::vector< ofVideoDevice > *) 0 ; - SWIG_check_num_args("std::vector< ofVideoDevice >::pop_back",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< ofVideoDevice >::pop_back",1,"std::vector< ofVideoDevice > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofVideoDevice_t,0))){ - SWIG_fail_ptr("VideoDeviceVector_pop_back",1,SWIGTYPE_p_std__vectorT_ofVideoDevice_t); } (arg1)->pop_back(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoDeviceVector_front(lua_State* L) { int SWIG_arg = 0; - std::vector< ofVideoDevice > *arg1 = (std::vector< ofVideoDevice > *) 0 ; ofVideoDevice result; - SWIG_check_num_args("std::vector< ofVideoDevice >::front",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< ofVideoDevice >::front",1,"std::vector< ofVideoDevice > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofVideoDevice_t,0))){ - SWIG_fail_ptr("VideoDeviceVector_front",1,SWIGTYPE_p_std__vectorT_ofVideoDevice_t); } - result = ((std::vector< ofVideoDevice > const *)arg1)->front(); { - ofVideoDevice * resultptr = new ofVideoDevice((const ofVideoDevice &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVideoDevice,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_VideoDeviceVector_back(lua_State* L) { int SWIG_arg = 0; - std::vector< ofVideoDevice > *arg1 = (std::vector< ofVideoDevice > *) 0 ; ofVideoDevice result; - SWIG_check_num_args("std::vector< ofVideoDevice >::back",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< ofVideoDevice >::back",1,"std::vector< ofVideoDevice > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofVideoDevice_t,0))){ - SWIG_fail_ptr("VideoDeviceVector_back",1,SWIGTYPE_p_std__vectorT_ofVideoDevice_t); } - result = ((std::vector< ofVideoDevice > const *)arg1)->back(); { - ofVideoDevice * resultptr = new ofVideoDevice((const ofVideoDevice &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVideoDevice,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_VideoDeviceVector___getitem(lua_State* L) { int SWIG_arg = 0; - std::vector< ofVideoDevice > *arg1 = (std::vector< ofVideoDevice > *) 0 ; unsigned int arg2 ; ofVideoDevice result; - SWIG_check_num_args("std::vector< ofVideoDevice >::__getitem__",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< ofVideoDevice >::__getitem__",1,"std::vector< ofVideoDevice > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("std::vector< ofVideoDevice >::__getitem__",2,"unsigned int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofVideoDevice_t,0))){ - SWIG_fail_ptr("VideoDeviceVector___getitem",1,SWIGTYPE_p_std__vectorT_ofVideoDevice_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned int)lua_tonumber(L, 2); try { - result = std_vector_Sl_ofVideoDevice_Sg____getitem__(arg1,arg2);} catch(std::out_of_range &_e) { - SWIG_exception(SWIG_IndexError, (&_e)->what()); } { - ofVideoDevice * resultptr = new ofVideoDevice((const ofVideoDevice &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVideoDevice,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_VideoDeviceVector___setitem(lua_State* L) { int SWIG_arg = 0; - std::vector< ofVideoDevice > *arg1 = (std::vector< ofVideoDevice > *) 0 ; unsigned int arg2 ; ofVideoDevice arg3 ; - ofVideoDevice *argp3 ; SWIG_check_num_args("std::vector< ofVideoDevice >::__setitem__",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< ofVideoDevice >::__setitem__",1,"std::vector< ofVideoDevice > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("std::vector< ofVideoDevice >::__setitem__",2,"unsigned int"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("std::vector< ofVideoDevice >::__setitem__",3,"ofVideoDevice"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofVideoDevice_t,0))){ - SWIG_fail_ptr("VideoDeviceVector___setitem",1,SWIGTYPE_p_std__vectorT_ofVideoDevice_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned int)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&argp3,SWIGTYPE_p_ofVideoDevice,0))){ - SWIG_fail_ptr("VideoDeviceVector___setitem",3,SWIGTYPE_p_ofVideoDevice); } arg3 = *argp3; try { - std_vector_Sl_ofVideoDevice_Sg____setitem__(arg1,arg2,arg3);} catch(std::out_of_range &_e) { - SWIG_exception(SWIG_IndexError, (&_e)->what()); } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_VideoDeviceVector(void *obj) { -std::vector< ofVideoDevice > *arg1 = (std::vector< ofVideoDevice > *) obj; -delete arg1; -} -static int _proxy__wrap_new_VideoDeviceVector(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_VideoDeviceVector); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_VideoDeviceVector_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_VideoDeviceVector_methods[]= { - { "size", _wrap_VideoDeviceVector_size}, - { "max_size", _wrap_VideoDeviceVector_max_size}, - { "empty", _wrap_VideoDeviceVector_empty}, - { "clear", _wrap_VideoDeviceVector_clear}, - { "push_back", _wrap_VideoDeviceVector_push_back}, - { "pop_back", _wrap_VideoDeviceVector_pop_back}, - { "front", _wrap_VideoDeviceVector_front}, - { "back", _wrap_VideoDeviceVector_back}, - { "__getitem", _wrap_VideoDeviceVector___getitem}, - { "__setitem", _wrap_VideoDeviceVector___setitem}, - {0,0} -}; -static swig_lua_method swig_VideoDeviceVector_meta[] = { - { "__getitem", _wrap_VideoDeviceVector___getitem}, - { "__setitem", _wrap_VideoDeviceVector___setitem}, - {0,0} -}; - -static swig_lua_attribute swig_VideoDeviceVector_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_VideoDeviceVector_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_VideoDeviceVector_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_VideoDeviceVector_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_VideoDeviceVector_Sf_SwigStatic = { - "VideoDeviceVector", - swig_VideoDeviceVector_Sf_SwigStatic_methods, - swig_VideoDeviceVector_Sf_SwigStatic_attributes, - swig_VideoDeviceVector_Sf_SwigStatic_constants, - swig_VideoDeviceVector_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_VideoDeviceVector_bases[] = {0}; -static const char *swig_VideoDeviceVector_base_names[] = {0}; -static swig_lua_class _wrap_class_VideoDeviceVector = { "VideoDeviceVector", "VideoDeviceVector", &SWIGTYPE_p_std__vectorT_ofVideoDevice_t,_proxy__wrap_new_VideoDeviceVector, swig_delete_VideoDeviceVector, swig_VideoDeviceVector_methods, swig_VideoDeviceVector_attributes, &swig_VideoDeviceVector_Sf_SwigStatic, swig_VideoDeviceVector_meta, swig_VideoDeviceVector_bases, swig_VideoDeviceVector_base_names }; - -static int _wrap_new_TextureVector__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::vector< ofTexture > *result = 0 ; - SWIG_check_num_args("std::vector< ofTexture >::vector",0,0) - result = (std::vector< ofTexture > *)new std::vector< ofTexture >(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofTexture_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_TextureVector__SWIG_1(lua_State* L) { int SWIG_arg = 0; unsigned int arg1 ; - std::vector< ofTexture > *result = 0 ; SWIG_check_num_args("std::vector< ofTexture >::vector",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("std::vector< ofTexture >::vector",1,"unsigned int"); - SWIG_contract_assert((lua_tonumber(L,1)>=0),"number must not be negative") arg1 = (unsigned int)lua_tonumber(L, 1); - result = (std::vector< ofTexture > *)new std::vector< ofTexture >(arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofTexture_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_TextureVector__SWIG_2(lua_State* L) { int SWIG_arg = 0; std::vector< ofTexture > *arg1 = 0 ; - std::vector< ofTexture > *result = 0 ; SWIG_check_num_args("std::vector< ofTexture >::vector",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("std::vector< ofTexture >::vector",1,"std::vector< ofTexture > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofTexture_t,0))){ - SWIG_fail_ptr("new_TextureVector",1,SWIGTYPE_p_std__vectorT_ofTexture_t); } - result = (std::vector< ofTexture > *)new std::vector< ofTexture >((std::vector< ofTexture > const &)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofTexture_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_TextureVector__SWIG_3(lua_State* L) { int SWIG_arg = 0; unsigned int arg1 ; ofTexture arg2 ; - ofTexture *argp2 ; std::vector< ofTexture > *result = 0 ; SWIG_check_num_args("std::vector< ofTexture >::vector",2,2) - if(!lua_isnumber(L,1)) SWIG_fail_arg("std::vector< ofTexture >::vector",1,"unsigned int"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("std::vector< ofTexture >::vector",2,"ofTexture"); - SWIG_contract_assert((lua_tonumber(L,1)>=0),"number must not be negative") arg1 = (unsigned int)lua_tonumber(L, 1); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("new_TextureVector",2,SWIGTYPE_p_ofTexture); } arg2 = *argp2; - result = (std::vector< ofTexture > *)new std::vector< ofTexture >(arg1,arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofTexture_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_TextureVector(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_TextureVector__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_std__vectorT_ofTexture_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_new_TextureVector__SWIG_2(L);} } if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_new_TextureVector__SWIG_1(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_new_TextureVector__SWIG_3(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_TextureVector'\n" " Possible C/C++ prototypes are:\n" - " std::vector< ofTexture >::vector()\n" " std::vector< ofTexture >::vector(unsigned int)\n" - " std::vector< ofTexture >::vector(std::vector< ofTexture > const &)\n" - " std::vector< ofTexture >::vector(unsigned int,ofTexture)\n"); lua_error(L);return 0; } -static int _wrap_TextureVector_size(lua_State* L) { int SWIG_arg = 0; - std::vector< ofTexture > *arg1 = (std::vector< ofTexture > *) 0 ; unsigned int result; - SWIG_check_num_args("std::vector< ofTexture >::size",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< ofTexture >::size",1,"std::vector< ofTexture > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofTexture_t,0))){ - SWIG_fail_ptr("TextureVector_size",1,SWIGTYPE_p_std__vectorT_ofTexture_t); } - result = (unsigned int)((std::vector< ofTexture > const *)arg1)->size(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureVector_max_size(lua_State* L) { int SWIG_arg = 0; - std::vector< ofTexture > *arg1 = (std::vector< ofTexture > *) 0 ; unsigned int result; - SWIG_check_num_args("std::vector< ofTexture >::max_size",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< ofTexture >::max_size",1,"std::vector< ofTexture > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofTexture_t,0))){ - SWIG_fail_ptr("TextureVector_max_size",1,SWIGTYPE_p_std__vectorT_ofTexture_t); } - result = (unsigned int)((std::vector< ofTexture > const *)arg1)->max_size(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureVector_empty(lua_State* L) { int SWIG_arg = 0; - std::vector< ofTexture > *arg1 = (std::vector< ofTexture > *) 0 ; bool result; - SWIG_check_num_args("std::vector< ofTexture >::empty",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< ofTexture >::empty",1,"std::vector< ofTexture > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofTexture_t,0))){ - SWIG_fail_ptr("TextureVector_empty",1,SWIGTYPE_p_std__vectorT_ofTexture_t); } - result = (bool)((std::vector< ofTexture > const *)arg1)->empty(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureVector_clear(lua_State* L) { int SWIG_arg = 0; - std::vector< ofTexture > *arg1 = (std::vector< ofTexture > *) 0 ; SWIG_check_num_args("std::vector< ofTexture >::clear",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< ofTexture >::clear",1,"std::vector< ofTexture > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofTexture_t,0))){ - SWIG_fail_ptr("TextureVector_clear",1,SWIGTYPE_p_std__vectorT_ofTexture_t); } (arg1)->clear(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureVector_push_back(lua_State* L) { int SWIG_arg = 0; - std::vector< ofTexture > *arg1 = (std::vector< ofTexture > *) 0 ; ofTexture arg2 ; ofTexture *argp2 ; - SWIG_check_num_args("std::vector< ofTexture >::push_back",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< ofTexture >::push_back",1,"std::vector< ofTexture > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("std::vector< ofTexture >::push_back",2,"ofTexture"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofTexture_t,0))){ - SWIG_fail_ptr("TextureVector_push_back",1,SWIGTYPE_p_std__vectorT_ofTexture_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("TextureVector_push_back",2,SWIGTYPE_p_ofTexture); } arg2 = *argp2; (arg1)->push_back(arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureVector_pop_back(lua_State* L) { int SWIG_arg = 0; - std::vector< ofTexture > *arg1 = (std::vector< ofTexture > *) 0 ; - SWIG_check_num_args("std::vector< ofTexture >::pop_back",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< ofTexture >::pop_back",1,"std::vector< ofTexture > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofTexture_t,0))){ - SWIG_fail_ptr("TextureVector_pop_back",1,SWIGTYPE_p_std__vectorT_ofTexture_t); } (arg1)->pop_back(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureVector_front(lua_State* L) { int SWIG_arg = 0; - std::vector< ofTexture > *arg1 = (std::vector< ofTexture > *) 0 ; ofTexture result; - SWIG_check_num_args("std::vector< ofTexture >::front",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< ofTexture >::front",1,"std::vector< ofTexture > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofTexture_t,0))){ - SWIG_fail_ptr("TextureVector_front",1,SWIGTYPE_p_std__vectorT_ofTexture_t); } - result = ((std::vector< ofTexture > const *)arg1)->front(); { - ofTexture * resultptr = new ofTexture((const ofTexture &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofTexture,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_TextureVector_back(lua_State* L) { int SWIG_arg = 0; - std::vector< ofTexture > *arg1 = (std::vector< ofTexture > *) 0 ; ofTexture result; - SWIG_check_num_args("std::vector< ofTexture >::back",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< ofTexture >::back",1,"std::vector< ofTexture > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofTexture_t,0))){ - SWIG_fail_ptr("TextureVector_back",1,SWIGTYPE_p_std__vectorT_ofTexture_t); } - result = ((std::vector< ofTexture > const *)arg1)->back(); { - ofTexture * resultptr = new ofTexture((const ofTexture &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofTexture,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_TextureVector___getitem(lua_State* L) { int SWIG_arg = 0; - std::vector< ofTexture > *arg1 = (std::vector< ofTexture > *) 0 ; unsigned int arg2 ; ofTexture result; - SWIG_check_num_args("std::vector< ofTexture >::__getitem__",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< ofTexture >::__getitem__",1,"std::vector< ofTexture > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("std::vector< ofTexture >::__getitem__",2,"unsigned int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofTexture_t,0))){ - SWIG_fail_ptr("TextureVector___getitem",1,SWIGTYPE_p_std__vectorT_ofTexture_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned int)lua_tonumber(L, 2); try { - result = std_vector_Sl_ofTexture_Sg____getitem__(arg1,arg2);} catch(std::out_of_range &_e) { - SWIG_exception(SWIG_IndexError, (&_e)->what()); } { ofTexture * resultptr = new ofTexture((const ofTexture &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofTexture,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_TextureVector___setitem(lua_State* L) { int SWIG_arg = 0; - std::vector< ofTexture > *arg1 = (std::vector< ofTexture > *) 0 ; unsigned int arg2 ; ofTexture arg3 ; ofTexture *argp3 ; - SWIG_check_num_args("std::vector< ofTexture >::__setitem__",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< ofTexture >::__setitem__",1,"std::vector< ofTexture > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("std::vector< ofTexture >::__setitem__",2,"unsigned int"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("std::vector< ofTexture >::__setitem__",3,"ofTexture"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofTexture_t,0))){ - SWIG_fail_ptr("TextureVector___setitem",1,SWIGTYPE_p_std__vectorT_ofTexture_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned int)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&argp3,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("TextureVector___setitem",3,SWIGTYPE_p_ofTexture); } arg3 = *argp3; try { - std_vector_Sl_ofTexture_Sg____setitem__(arg1,arg2,arg3);} catch(std::out_of_range &_e) { - SWIG_exception(SWIG_IndexError, (&_e)->what()); } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_TextureVector(void *obj) { -std::vector< ofTexture > *arg1 = (std::vector< ofTexture > *) obj; -delete arg1; -} -static int _proxy__wrap_new_TextureVector(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_TextureVector); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_TextureVector_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_TextureVector_methods[]= { - { "size", _wrap_TextureVector_size}, - { "max_size", _wrap_TextureVector_max_size}, - { "empty", _wrap_TextureVector_empty}, - { "clear", _wrap_TextureVector_clear}, - { "push_back", _wrap_TextureVector_push_back}, - { "pop_back", _wrap_TextureVector_pop_back}, - { "front", _wrap_TextureVector_front}, - { "back", _wrap_TextureVector_back}, - { "__getitem", _wrap_TextureVector___getitem}, - { "__setitem", _wrap_TextureVector___setitem}, - {0,0} -}; -static swig_lua_method swig_TextureVector_meta[] = { - { "__getitem", _wrap_TextureVector___getitem}, - { "__setitem", _wrap_TextureVector___setitem}, - {0,0} -}; - -static swig_lua_attribute swig_TextureVector_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_TextureVector_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_TextureVector_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_TextureVector_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_TextureVector_Sf_SwigStatic = { - "TextureVector", - swig_TextureVector_Sf_SwigStatic_methods, - swig_TextureVector_Sf_SwigStatic_attributes, - swig_TextureVector_Sf_SwigStatic_constants, - swig_TextureVector_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_TextureVector_bases[] = {0}; -static const char *swig_TextureVector_base_names[] = {0}; -static swig_lua_class _wrap_class_TextureVector = { "TextureVector", "TextureVector", &SWIGTYPE_p_std__vectorT_ofTexture_t,_proxy__wrap_new_TextureVector, swig_delete_TextureVector, swig_TextureVector_methods, swig_TextureVector_attributes, &swig_TextureVector_Sf_SwigStatic, swig_TextureVector_meta, swig_TextureVector_bases, swig_TextureVector_base_names }; - -static int _wrap_new_Fbo__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofFbo *result = 0 ; SWIG_check_num_args("ofFbo::ofFbo",0,0) - result = (ofFbo *)new ofFbo(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofFbo,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_new_Fbo__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = 0 ; ofFbo *result = 0 ; - SWIG_check_num_args("ofFbo::ofFbo",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofFbo::ofFbo",1,"ofFbo &&"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("new_Fbo",1,SWIGTYPE_p_ofFbo); } - result = (ofFbo *)new ofFbo((ofFbo &&)*arg1); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofFbo,1); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_new_Fbo(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_Fbo__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_new_Fbo__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_Fbo'\n" " Possible C/C++ prototypes are:\n" - " ofFbo::ofFbo()\n" " ofFbo::ofFbo(ofFbo &&)\n"); lua_error(L);return 0; } -static int _wrap_Fbo_allocate__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; int arg2 ; int arg3 ; - int arg4 ; int arg5 ; SWIG_check_num_args("ofFbo::allocate",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::allocate",1,"ofFbo *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofFbo::allocate",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofFbo::allocate",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofFbo::allocate",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofFbo::allocate",5,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_allocate",1,SWIGTYPE_p_ofFbo); } - arg2 = (int)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - arg5 = (int)lua_tonumber(L, 5); (arg1)->allocate(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Fbo_allocate__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; int arg2 ; int arg3 ; - int arg4 ; SWIG_check_num_args("ofFbo::allocate",4,4) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::allocate",1,"ofFbo *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofFbo::allocate",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofFbo::allocate",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofFbo::allocate",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_allocate",1,SWIGTYPE_p_ofFbo); } - arg2 = (int)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - (arg1)->allocate(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_allocate__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; int arg2 ; int arg3 ; - SWIG_check_num_args("ofFbo::allocate",3,3) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::allocate",1,"ofFbo *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofFbo::allocate",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofFbo::allocate",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_allocate",1,SWIGTYPE_p_ofFbo); } - arg2 = (int)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); (arg1)->allocate(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_allocate__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; ofFbo::Settings arg2 ; - ofFbo::Settings *argp2 ; SWIG_check_num_args("ofFbo::allocate",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::allocate",1,"ofFbo *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofFbo::allocate",2,"ofFbo::Settings"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_allocate",1,SWIGTYPE_p_ofFbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofFbo__Settings,0))){ - SWIG_fail_ptr("Fbo_allocate",2,SWIGTYPE_p_ofFbo__Settings); } arg2 = *argp2; (arg1)->allocate(arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_allocate__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; - SWIG_check_num_args("ofFbo::allocate",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::allocate",1,"ofFbo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_allocate",1,SWIGTYPE_p_ofFbo); } - (arg1)->allocate(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_allocate(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Fbo_allocate__SWIG_4(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofFbo__Settings, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Fbo_allocate__SWIG_3(L);} } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Fbo_allocate__SWIG_2(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Fbo_allocate__SWIG_1(L);} } } } } if (argc == 5) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Fbo_allocate__SWIG_0(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Fbo_allocate'\n" " Possible C/C++ prototypes are:\n" - " ofFbo::allocate(int,int,int,int)\n" " ofFbo::allocate(int,int,int)\n" " ofFbo::allocate(int,int)\n" - " ofFbo::allocate(ofFbo::Settings)\n" " ofFbo::allocate()\n"); lua_error(L);return 0; } -static int _wrap_Fbo_isAllocated(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; bool result; - SWIG_check_num_args("ofFbo::isAllocated",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::isAllocated",1,"ofFbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_isAllocated",1,SWIGTYPE_p_ofFbo); } - result = (bool)((ofFbo const *)arg1)->isAllocated(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_clear(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; SWIG_check_num_args("ofFbo::clear",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::clear",1,"ofFbo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_clear",1,SWIGTYPE_p_ofFbo); } - (arg1)->clear(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_draw__SWIG_0_0(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; ofPoint *arg2 = 0 ; - SWIG_check_num_args("draw",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("draw",1,"ofFbo const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("draw",2,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_draw",1,SWIGTYPE_p_ofFbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Fbo_draw",2,SWIGTYPE_p_ofVec3f); } - ((ofFbo const *)arg1)->draw((ofPoint const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_draw__SWIG_0_1(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; ofRectangle *arg2 = 0 ; - SWIG_check_num_args("draw",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("draw",1,"ofFbo const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("draw",2,"ofRectangle const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_draw",1,SWIGTYPE_p_ofFbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Fbo_draw",2,SWIGTYPE_p_ofRectangle); } ((ofFbo const *)arg1)->draw((ofRectangle const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_draw__SWIG_0_2(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; ofPoint *arg2 = 0 ; - float arg3 ; float arg4 ; SWIG_check_num_args("draw",4,4) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("draw",1,"ofFbo const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("draw",2,"ofPoint const &"); if(!lua_isnumber(L,3)) SWIG_fail_arg("draw",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("draw",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_draw",1,SWIGTYPE_p_ofFbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Fbo_draw",2,SWIGTYPE_p_ofVec3f); } - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - ((ofFbo const *)arg1)->draw((ofPoint const &)*arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Fbo_draw__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofFbo::draw",3,3) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::draw",1,"ofFbo const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofFbo::draw",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofFbo::draw",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_draw",1,SWIGTYPE_p_ofFbo); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); ((ofFbo const *)arg1)->draw(arg2,arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_draw__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; float arg2 ; float arg3 ; - float arg4 ; float arg5 ; SWIG_check_num_args("ofFbo::draw",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::draw",1,"ofFbo const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofFbo::draw",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofFbo::draw",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofFbo::draw",4,"float"); if(!lua_isnumber(L,5)) SWIG_fail_arg("ofFbo::draw",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_draw",1,SWIGTYPE_p_ofFbo); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); ((ofFbo const *)arg1)->draw(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_draw(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 2) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Fbo_draw__SWIG_0_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Fbo_draw__SWIG_0_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Fbo_draw__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Fbo_draw__SWIG_0_2(L);} } } } } if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Fbo_draw__SWIG_2(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Fbo_draw'\n" " Possible C/C++ prototypes are:\n" - " draw(ofPoint const &) const\n" " draw(ofRectangle const &) const\n" " draw(ofPoint const &,float,float) const\n" - " ofFbo::draw(float,float) const\n" " ofFbo::draw(float,float,float,float) const\n"); lua_error(L);return 0; } -static int _wrap_Fbo_setAnchorPercent(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofFbo::setAnchorPercent",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::setAnchorPercent",1,"ofFbo *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofFbo::setAnchorPercent",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofFbo::setAnchorPercent",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ - SWIG_fail_ptr("Fbo_setAnchorPercent",1,SWIGTYPE_p_ofFbo); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->setAnchorPercent(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Fbo_setAnchorPoint(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofFbo::setAnchorPoint",3,3) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::setAnchorPoint",1,"ofFbo *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofFbo::setAnchorPoint",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofFbo::setAnchorPoint",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ - SWIG_fail_ptr("Fbo_setAnchorPoint",1,SWIGTYPE_p_ofFbo); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->setAnchorPoint(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Fbo_resetAnchor(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; - SWIG_check_num_args("ofFbo::resetAnchor",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::resetAnchor",1,"ofFbo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_resetAnchor",1,SWIGTYPE_p_ofFbo); } - (arg1)->resetAnchor(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_setDefaultTextureIndex(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; int arg2 ; - SWIG_check_num_args("ofFbo::setDefaultTextureIndex",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::setDefaultTextureIndex",1,"ofFbo *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofFbo::setDefaultTextureIndex",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ - SWIG_fail_ptr("Fbo_setDefaultTextureIndex",1,SWIGTYPE_p_ofFbo); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->setDefaultTextureIndex(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_getDefaultTextureIndex(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; int result; - SWIG_check_num_args("ofFbo::getDefaultTextureIndex",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::getDefaultTextureIndex",1,"ofFbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ - SWIG_fail_ptr("Fbo_getDefaultTextureIndex",1,SWIGTYPE_p_ofFbo); } - result = (int)((ofFbo const *)arg1)->getDefaultTextureIndex(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_getTexture__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; ofTexture *result = 0 ; - SWIG_check_num_args("ofFbo::getTexture",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::getTexture",1,"ofFbo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_getTexture",1,SWIGTYPE_p_ofFbo); } - result = (ofTexture *) &(arg1)->getTexture(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTexture,0); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_getTexture__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; int arg2 ; - ofTexture *result = 0 ; SWIG_check_num_args("ofFbo::getTexture",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::getTexture",1,"ofFbo *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofFbo::getTexture",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_getTexture",1,SWIGTYPE_p_ofFbo); } - arg2 = (int)lua_tonumber(L, 2); result = (ofTexture *) &(arg1)->getTexture(arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTexture,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Fbo_getDepthTexture__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; - ofTexture *result = 0 ; SWIG_check_num_args("ofFbo::getDepthTexture",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::getDepthTexture",1,"ofFbo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ - SWIG_fail_ptr("Fbo_getDepthTexture",1,SWIGTYPE_p_ofFbo); } result = (ofTexture *) &(arg1)->getDepthTexture(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTexture,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Fbo_getTexture__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; ofTexture *result = 0 ; - SWIG_check_num_args("ofFbo::getTexture",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::getTexture",1,"ofFbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_getTexture",1,SWIGTYPE_p_ofFbo); } - result = (ofTexture *) &((ofFbo const *)arg1)->getTexture(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTexture,0); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_getTexture__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; int arg2 ; - ofTexture *result = 0 ; SWIG_check_num_args("ofFbo::getTexture",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::getTexture",1,"ofFbo const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofFbo::getTexture",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_getTexture",1,SWIGTYPE_p_ofFbo); } - arg2 = (int)lua_tonumber(L, 2); result = (ofTexture *) &((ofFbo const *)arg1)->getTexture(arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTexture,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Fbo_getTexture(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Fbo_getTexture__SWIG_0(L);} } if (argc == 1) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_Fbo_getTexture__SWIG_2(L);} } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Fbo_getTexture__SWIG_1(L);} } } - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Fbo_getTexture__SWIG_3(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Fbo_getTexture'\n" " Possible C/C++ prototypes are:\n" - " ofFbo::getTexture()\n" " ofFbo::getTexture(int)\n" " ofFbo::getTexture() const\n" - " ofFbo::getTexture(int) const\n"); lua_error(L);return 0; } -static int _wrap_Fbo_getDepthTexture__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; - ofTexture *result = 0 ; SWIG_check_num_args("ofFbo::getDepthTexture",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::getDepthTexture",1,"ofFbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ - SWIG_fail_ptr("Fbo_getDepthTexture",1,SWIGTYPE_p_ofFbo); } - result = (ofTexture *) &((ofFbo const *)arg1)->getDepthTexture(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTexture,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Fbo_getDepthTexture(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Fbo_getDepthTexture__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Fbo_getDepthTexture__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Fbo_getDepthTexture'\n" - " Possible C/C++ prototypes are:\n" " ofFbo::getDepthTexture()\n" " ofFbo::getDepthTexture() const\n"); - lua_error(L);return 0; } -static int _wrap_Fbo_beginFbo__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; bool arg2 ; - SWIG_check_num_args("ofFbo::begin",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::begin",1,"ofFbo const *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofFbo::begin",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_beginFbo",1,SWIGTYPE_p_ofFbo); } - arg2 = (lua_toboolean(L, 2)!=0); ((ofFbo const *)arg1)->begin(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Fbo_beginFbo__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; - SWIG_check_num_args("ofFbo::begin",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::begin",1,"ofFbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_beginFbo",1,SWIGTYPE_p_ofFbo); } - ((ofFbo const *)arg1)->begin(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_beginFbo(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Fbo_beginFbo__SWIG_1(L);} } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { return _wrap_Fbo_beginFbo__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Fbo_beginFbo'\n" " Possible C/C++ prototypes are:\n" - " ofFbo::begin(bool) const\n" " ofFbo::begin() const\n"); lua_error(L);return 0; } -static int _wrap_Fbo_endFbo(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; SWIG_check_num_args("ofFbo::end",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::end",1,"ofFbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_endFbo",1,SWIGTYPE_p_ofFbo); } - ((ofFbo const *)arg1)->end(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_readToPixels__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; ofPixels *arg2 = 0 ; - int arg3 ; SWIG_check_num_args("ofFbo::readToPixels",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::readToPixels",1,"ofFbo const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofFbo::readToPixels",2,"ofPixels &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofFbo::readToPixels",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_readToPixels",1,SWIGTYPE_p_ofFbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Fbo_readToPixels",2,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } arg3 = (int)lua_tonumber(L, 3); - ((ofFbo const *)arg1)->readToPixels(*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_readToPixels__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; ofPixels *arg2 = 0 ; - SWIG_check_num_args("ofFbo::readToPixels",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::readToPixels",1,"ofFbo const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofFbo::readToPixels",2,"ofPixels &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_readToPixels",1,SWIGTYPE_p_ofFbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Fbo_readToPixels",2,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } ((ofFbo const *)arg1)->readToPixels(*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_readToPixels__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; - ofShortPixels *arg2 = 0 ; int arg3 ; SWIG_check_num_args("ofFbo::readToPixels",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::readToPixels",1,"ofFbo const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofFbo::readToPixels",2,"ofShortPixels &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofFbo::readToPixels",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_readToPixels",1,SWIGTYPE_p_ofFbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("Fbo_readToPixels",2,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } arg3 = (int)lua_tonumber(L, 3); - ((ofFbo const *)arg1)->readToPixels(*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_readToPixels__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; - ofShortPixels *arg2 = 0 ; SWIG_check_num_args("ofFbo::readToPixels",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::readToPixels",1,"ofFbo const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofFbo::readToPixels",2,"ofShortPixels &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_readToPixels",1,SWIGTYPE_p_ofFbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("Fbo_readToPixels",2,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } ((ofFbo const *)arg1)->readToPixels(*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_readToPixels__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; - ofFloatPixels *arg2 = 0 ; int arg3 ; SWIG_check_num_args("ofFbo::readToPixels",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::readToPixels",1,"ofFbo const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofFbo::readToPixels",2,"ofFloatPixels &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofFbo::readToPixels",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_readToPixels",1,SWIGTYPE_p_ofFbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("Fbo_readToPixels",2,SWIGTYPE_p_ofPixels_T_float_t); } arg3 = (int)lua_tonumber(L, 3); - ((ofFbo const *)arg1)->readToPixels(*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_readToPixels__SWIG_5(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; - ofFloatPixels *arg2 = 0 ; SWIG_check_num_args("ofFbo::readToPixels",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::readToPixels",1,"ofFbo const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofFbo::readToPixels",2,"ofFloatPixels &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_readToPixels",1,SWIGTYPE_p_ofFbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("Fbo_readToPixels",2,SWIGTYPE_p_ofPixels_T_float_t); } ((ofFbo const *)arg1)->readToPixels(*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_readToPixels(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Fbo_readToPixels__SWIG_1(L);} } } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Fbo_readToPixels__SWIG_3(L);} } } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Fbo_readToPixels__SWIG_5(L);} } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Fbo_readToPixels__SWIG_0(L);} } } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Fbo_readToPixels__SWIG_4(L);} } } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Fbo_readToPixels__SWIG_2(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Fbo_readToPixels'\n" " Possible C/C++ prototypes are:\n" - " ofFbo::readToPixels(ofPixels &,int) const\n" " ofFbo::readToPixels(ofPixels &) const\n" - " ofFbo::readToPixels(ofShortPixels &,int) const\n" " ofFbo::readToPixels(ofShortPixels &) const\n" - " ofFbo::readToPixels(ofFloatPixels &,int) const\n" " ofFbo::readToPixels(ofFloatPixels &) const\n"); - lua_error(L);return 0; } -static int _wrap_Fbo_getWidth(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; float result; - SWIG_check_num_args("ofFbo::getWidth",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::getWidth",1,"ofFbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_getWidth",1,SWIGTYPE_p_ofFbo); } - result = (float)((ofFbo const *)arg1)->getWidth(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_getHeight(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; float result; - SWIG_check_num_args("ofFbo::getHeight",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::getHeight",1,"ofFbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_getHeight",1,SWIGTYPE_p_ofFbo); } - result = (float)((ofFbo const *)arg1)->getHeight(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_bind(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; SWIG_check_num_args("ofFbo::bind",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::bind",1,"ofFbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_bind",1,SWIGTYPE_p_ofFbo); } - ((ofFbo const *)arg1)->bind(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_unbind(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; - SWIG_check_num_args("ofFbo::unbind",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::unbind",1,"ofFbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_unbind",1,SWIGTYPE_p_ofFbo); } - ((ofFbo const *)arg1)->unbind(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_flagDirty(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; - SWIG_check_num_args("ofFbo::flagDirty",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::flagDirty",1,"ofFbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_flagDirty",1,SWIGTYPE_p_ofFbo); } - ((ofFbo const *)arg1)->flagDirty(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_updateTexture(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; int arg2 ; - SWIG_check_num_args("ofFbo::updateTexture",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::updateTexture",1,"ofFbo *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofFbo::updateTexture",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ - SWIG_fail_ptr("Fbo_updateTexture",1,SWIGTYPE_p_ofFbo); } arg2 = (int)lua_tonumber(L, 2); (arg1)->updateTexture(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_checkStatus(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; bool result; - SWIG_check_num_args("ofFbo::checkStatus",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::checkStatus",1,"ofFbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_checkStatus",1,SWIGTYPE_p_ofFbo); } - result = (bool)((ofFbo const *)arg1)->checkStatus(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_createAndAttachTexture(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; GLenum arg2 ; - GLenum arg3 ; SWIG_check_num_args("ofFbo::createAndAttachTexture",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::createAndAttachTexture",1,"ofFbo *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofFbo::createAndAttachTexture",2,"GLenum"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofFbo::createAndAttachTexture",3,"GLenum"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ - SWIG_fail_ptr("Fbo_createAndAttachTexture",1,SWIGTYPE_p_ofFbo); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (GLenum)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (GLenum)lua_tonumber(L, 3); - (arg1)->createAndAttachTexture(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_attachTexture(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; ofTexture *arg2 = 0 ; - GLenum arg3 ; GLenum arg4 ; SWIG_check_num_args("ofFbo::attachTexture",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::attachTexture",1,"ofFbo *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofFbo::attachTexture",2,"ofTexture &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofFbo::attachTexture",3,"GLenum"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofFbo::attachTexture",4,"GLenum"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ - SWIG_fail_ptr("Fbo_attachTexture",1,SWIGTYPE_p_ofFbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Fbo_attachTexture",2,SWIGTYPE_p_ofTexture); } - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (GLenum)lua_tonumber(L, 3); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (GLenum)lua_tonumber(L, 4); - (arg1)->attachTexture(*arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_createAndAttachRenderbuffer(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; GLenum arg2 ; - GLenum arg3 ; GLuint result; SWIG_check_num_args("ofFbo::createAndAttachRenderbuffer",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::createAndAttachRenderbuffer",1,"ofFbo *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofFbo::createAndAttachRenderbuffer",2,"GLenum"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofFbo::createAndAttachRenderbuffer",3,"GLenum"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ - SWIG_fail_ptr("Fbo_createAndAttachRenderbuffer",1,SWIGTYPE_p_ofFbo); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (GLenum)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (GLenum)lua_tonumber(L, 3); - result = (GLuint)(arg1)->createAndAttachRenderbuffer(arg2,arg3); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_createAndAttachDepthStencilTexture__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; - GLenum arg2 ; GLint arg3 ; GLenum arg4 ; SWIG_check_num_args("ofFbo::createAndAttachDepthStencilTexture",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::createAndAttachDepthStencilTexture",1,"ofFbo *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofFbo::createAndAttachDepthStencilTexture",2,"GLenum"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofFbo::createAndAttachDepthStencilTexture",3,"GLint"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofFbo::createAndAttachDepthStencilTexture",4,"GLenum"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ - SWIG_fail_ptr("Fbo_createAndAttachDepthStencilTexture",1,SWIGTYPE_p_ofFbo); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (GLenum)lua_tonumber(L, 2); - arg3 = (GLint)lua_tonumber(L, 3); SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") - arg4 = (GLenum)lua_tonumber(L, 4); (arg1)->createAndAttachDepthStencilTexture(arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_createAndAttachDepthStencilTexture__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; - GLenum arg2 ; GLint arg3 ; GLenum arg4 ; GLenum arg5 ; GLenum arg6 ; - SWIG_check_num_args("ofFbo::createAndAttachDepthStencilTexture",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::createAndAttachDepthStencilTexture",1,"ofFbo *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofFbo::createAndAttachDepthStencilTexture",2,"GLenum"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofFbo::createAndAttachDepthStencilTexture",3,"GLint"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofFbo::createAndAttachDepthStencilTexture",4,"GLenum"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofFbo::createAndAttachDepthStencilTexture",5,"GLenum"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofFbo::createAndAttachDepthStencilTexture",6,"GLenum"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ - SWIG_fail_ptr("Fbo_createAndAttachDepthStencilTexture",1,SWIGTYPE_p_ofFbo); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (GLenum)lua_tonumber(L, 2); - arg3 = (GLint)lua_tonumber(L, 3); SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") - arg4 = (GLenum)lua_tonumber(L, 4); SWIG_contract_assert((lua_tonumber(L,5)>=0),"number must not be negative") - arg5 = (GLenum)lua_tonumber(L, 5); SWIG_contract_assert((lua_tonumber(L,6)>=0),"number must not be negative") - arg6 = (GLenum)lua_tonumber(L, 6); (arg1)->createAndAttachDepthStencilTexture(arg2,arg3,arg4,arg5,arg6); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_createAndAttachDepthStencilTexture(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; - argc = lua_gettop(L); if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Fbo_createAndAttachDepthStencilTexture__SWIG_0(L);} } } } - } if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { return _wrap_Fbo_createAndAttachDepthStencilTexture__SWIG_1(L);} } } - } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Fbo_createAndAttachDepthStencilTexture'\n" - " Possible C/C++ prototypes are:\n" " ofFbo::createAndAttachDepthStencilTexture(GLenum,GLint,GLenum)\n" - " ofFbo::createAndAttachDepthStencilTexture(GLenum,GLint,GLenum,GLenum,GLenum)\n"); lua_error(L);return 0; } -static int _wrap_Fbo_getNumTextures(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; int result; - SWIG_check_num_args("ofFbo::getNumTextures",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::getNumTextures",1,"ofFbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ - SWIG_fail_ptr("Fbo_getNumTextures",1,SWIGTYPE_p_ofFbo); } result = (int)((ofFbo const *)arg1)->getNumTextures(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_setActiveDrawBuffer(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; int arg2 ; - SWIG_check_num_args("ofFbo::setActiveDrawBuffer",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::setActiveDrawBuffer",1,"ofFbo *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofFbo::setActiveDrawBuffer",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ - SWIG_fail_ptr("Fbo_setActiveDrawBuffer",1,SWIGTYPE_p_ofFbo); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->setActiveDrawBuffer(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_activateAllDrawBuffers(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; - SWIG_check_num_args("ofFbo::activateAllDrawBuffers",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::activateAllDrawBuffers",1,"ofFbo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ - SWIG_fail_ptr("Fbo_activateAllDrawBuffers",1,SWIGTYPE_p_ofFbo); } (arg1)->activateAllDrawBuffers(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_getId(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; GLuint result; - SWIG_check_num_args("ofFbo::getId",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::getId",1,"ofFbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_getId",1,SWIGTYPE_p_ofFbo); } - result = (GLuint)((ofFbo const *)arg1)->getId(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_getIdDrawBuffer(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; GLuint result; - SWIG_check_num_args("ofFbo::getIdDrawBuffer",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::getIdDrawBuffer",1,"ofFbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ - SWIG_fail_ptr("Fbo_getIdDrawBuffer",1,SWIGTYPE_p_ofFbo); } result = (GLuint)((ofFbo const *)arg1)->getIdDrawBuffer(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_checkGLSupport(lua_State* L) { int SWIG_arg = 0; bool result; - SWIG_check_num_args("ofFbo::checkGLSupport",0,0) result = (bool)ofFbo::checkGLSupport(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_maxColorAttachments(lua_State* L) { int SWIG_arg = 0; int result; - SWIG_check_num_args("ofFbo::maxColorAttachments",0,0) result = (int)ofFbo::maxColorAttachments(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_maxDrawBuffers(lua_State* L) { int SWIG_arg = 0; int result; - SWIG_check_num_args("ofFbo::maxDrawBuffers",0,0) result = (int)ofFbo::maxDrawBuffers(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_maxSamples(lua_State* L) { int SWIG_arg = 0; int result; SWIG_check_num_args("ofFbo::maxSamples",0,0) - result = (int)ofFbo::maxSamples(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_getDepthBuffer(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; GLuint result; - SWIG_check_num_args("ofFbo::getDepthBuffer",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::getDepthBuffer",1,"ofFbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ - SWIG_fail_ptr("Fbo_getDepthBuffer",1,SWIGTYPE_p_ofFbo); } result = (GLuint)((ofFbo const *)arg1)->getDepthBuffer(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_getStencilBuffer(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; GLuint result; - SWIG_check_num_args("ofFbo::getStencilBuffer",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::getStencilBuffer",1,"ofFbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ - SWIG_fail_ptr("Fbo_getStencilBuffer",1,SWIGTYPE_p_ofFbo); } result = (GLuint)((ofFbo const *)arg1)->getStencilBuffer(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_Fbo(void *obj) { -ofFbo *arg1 = (ofFbo *) obj; -delete arg1; -} -static int _proxy__wrap_new_Fbo(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_Fbo); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_Fbo_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_Fbo_methods[]= { - { "allocate", _wrap_Fbo_allocate}, - { "isAllocated", _wrap_Fbo_isAllocated}, - { "clear", _wrap_Fbo_clear}, - { "draw", _wrap_Fbo_draw}, - { "setAnchorPercent", _wrap_Fbo_setAnchorPercent}, - { "setAnchorPoint", _wrap_Fbo_setAnchorPoint}, - { "resetAnchor", _wrap_Fbo_resetAnchor}, - { "setDefaultTextureIndex", _wrap_Fbo_setDefaultTextureIndex}, - { "getDefaultTextureIndex", _wrap_Fbo_getDefaultTextureIndex}, - { "getTexture", _wrap_Fbo_getTexture}, - { "getDepthTexture", _wrap_Fbo_getDepthTexture}, - { "beginFbo", _wrap_Fbo_beginFbo}, - { "endFbo", _wrap_Fbo_endFbo}, - { "readToPixels", _wrap_Fbo_readToPixels}, - { "getWidth", _wrap_Fbo_getWidth}, - { "getHeight", _wrap_Fbo_getHeight}, - { "bind", _wrap_Fbo_bind}, - { "unbind", _wrap_Fbo_unbind}, - { "flagDirty", _wrap_Fbo_flagDirty}, - { "updateTexture", _wrap_Fbo_updateTexture}, - { "checkStatus", _wrap_Fbo_checkStatus}, - { "createAndAttachTexture", _wrap_Fbo_createAndAttachTexture}, - { "attachTexture", _wrap_Fbo_attachTexture}, - { "createAndAttachRenderbuffer", _wrap_Fbo_createAndAttachRenderbuffer}, - { "createAndAttachDepthStencilTexture", _wrap_Fbo_createAndAttachDepthStencilTexture}, - { "getNumTextures", _wrap_Fbo_getNumTextures}, - { "setActiveDrawBuffer", _wrap_Fbo_setActiveDrawBuffer}, - { "activateAllDrawBuffers", _wrap_Fbo_activateAllDrawBuffers}, - { "getId", _wrap_Fbo_getId}, - { "getIdDrawBuffer", _wrap_Fbo_getIdDrawBuffer}, - { "getDepthBuffer", _wrap_Fbo_getDepthBuffer}, - { "getStencilBuffer", _wrap_Fbo_getStencilBuffer}, - {0,0} -}; -static swig_lua_method swig_Fbo_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_Fbo_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_Fbo_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_Fbo_Sf_SwigStatic_methods[]= { - { "checkGLSupport", _wrap_Fbo_checkGLSupport}, - { "maxColorAttachments", _wrap_Fbo_maxColorAttachments}, - { "maxDrawBuffers", _wrap_Fbo_maxDrawBuffers}, - { "maxSamples", _wrap_Fbo_maxSamples}, - {0,0} -}; -static swig_lua_class* swig_Fbo_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_Fbo_Sf_SwigStatic = { - "Fbo", - swig_Fbo_Sf_SwigStatic_methods, - swig_Fbo_Sf_SwigStatic_attributes, - swig_Fbo_Sf_SwigStatic_constants, - swig_Fbo_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_Fbo_bases[] = {0}; -static const char *swig_Fbo_base_names[] = {0}; -static swig_lua_class _wrap_class_Fbo = { "Fbo", "Fbo", &SWIGTYPE_p_ofFbo,_proxy__wrap_new_Fbo, swig_delete_Fbo, swig_Fbo_methods, swig_Fbo_attributes, &swig_Fbo_Sf_SwigStatic, swig_Fbo_meta, swig_Fbo_bases, swig_Fbo_base_names }; - -static int _wrap_getUsingArbTex(lua_State* L) { int SWIG_arg = 0; bool result; SWIG_check_num_args("ofGetUsingArbTex",0,0) - result = (bool)ofGetUsingArbTex(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_enableArbTex(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofEnableArbTex",0,0) ofEnableArbTex(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_disableArbTex(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofDisableArbTex",0,0) ofDisableArbTex(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getUsingNormalizedTexCoords(lua_State* L) { int SWIG_arg = 0; bool result; - SWIG_check_num_args("ofGetUsingNormalizedTexCoords",0,0) result = (bool)ofGetUsingNormalizedTexCoords(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_enableNormalizedTexCoords(lua_State* L) { int SWIG_arg = 0; - SWIG_check_num_args("ofEnableNormalizedTexCoords",0,0) ofEnableNormalizedTexCoords(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_disableNormalizedTexCoords(lua_State* L) { int SWIG_arg = 0; - SWIG_check_num_args("ofDisableNormalizedTexCoords",0,0) ofDisableNormalizedTexCoords(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_new_TextureData(lua_State* L) { int SWIG_arg = 0; ofTextureData *result = 0 ; - SWIG_check_num_args("ofTextureData::ofTextureData",0,0) result = (ofTextureData *)new ofTextureData(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTextureData,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_TextureData_textureID_set(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - unsigned int arg2 ; SWIG_check_num_args("ofTextureData::textureID",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::textureID",1,"ofTextureData *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTextureData::textureID",2,"unsigned int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_textureID_set",1,SWIGTYPE_p_ofTextureData); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned int)lua_tonumber(L, 2); - if (arg1) (arg1)->textureID = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_textureID_get(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - unsigned int result; SWIG_check_num_args("ofTextureData::textureID",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::textureID",1,"ofTextureData *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_textureID_get",1,SWIGTYPE_p_ofTextureData); } result = (unsigned int) ((arg1)->textureID); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_textureTarget_set(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - int arg2 ; SWIG_check_num_args("ofTextureData::textureTarget",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::textureTarget",1,"ofTextureData *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTextureData::textureTarget",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_textureTarget_set",1,SWIGTYPE_p_ofTextureData); } arg2 = (int)lua_tonumber(L, 2); - if (arg1) (arg1)->textureTarget = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_textureTarget_get(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - int result; SWIG_check_num_args("ofTextureData::textureTarget",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::textureTarget",1,"ofTextureData *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_textureTarget_get",1,SWIGTYPE_p_ofTextureData); } result = (int) ((arg1)->textureTarget); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_glInternalFormat_set(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - int arg2 ; SWIG_check_num_args("ofTextureData::glInternalFormat",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::glInternalFormat",1,"ofTextureData *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTextureData::glInternalFormat",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_glInternalFormat_set",1,SWIGTYPE_p_ofTextureData); } arg2 = (int)lua_tonumber(L, 2); - if (arg1) (arg1)->glInternalFormat = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_glInternalFormat_get(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - int result; SWIG_check_num_args("ofTextureData::glInternalFormat",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::glInternalFormat",1,"ofTextureData *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_glInternalFormat_get",1,SWIGTYPE_p_ofTextureData); } result = (int) ((arg1)->glInternalFormat); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_tex_t_set(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - float arg2 ; SWIG_check_num_args("ofTextureData::tex_t",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::tex_t",1,"ofTextureData *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTextureData::tex_t",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_tex_t_set",1,SWIGTYPE_p_ofTextureData); } arg2 = (float)lua_tonumber(L, 2); - if (arg1) (arg1)->tex_t = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_tex_t_get(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - float result; SWIG_check_num_args("ofTextureData::tex_t",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::tex_t",1,"ofTextureData *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_tex_t_get",1,SWIGTYPE_p_ofTextureData); } result = (float) ((arg1)->tex_t); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_tex_u_set(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - float arg2 ; SWIG_check_num_args("ofTextureData::tex_u",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::tex_u",1,"ofTextureData *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTextureData::tex_u",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_tex_u_set",1,SWIGTYPE_p_ofTextureData); } arg2 = (float)lua_tonumber(L, 2); - if (arg1) (arg1)->tex_u = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_tex_u_get(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - float result; SWIG_check_num_args("ofTextureData::tex_u",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::tex_u",1,"ofTextureData *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_tex_u_get",1,SWIGTYPE_p_ofTextureData); } result = (float) ((arg1)->tex_u); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_tex_w_set(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - float arg2 ; SWIG_check_num_args("ofTextureData::tex_w",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::tex_w",1,"ofTextureData *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTextureData::tex_w",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_tex_w_set",1,SWIGTYPE_p_ofTextureData); } arg2 = (float)lua_tonumber(L, 2); - if (arg1) (arg1)->tex_w = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_tex_w_get(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - float result; SWIG_check_num_args("ofTextureData::tex_w",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::tex_w",1,"ofTextureData *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_tex_w_get",1,SWIGTYPE_p_ofTextureData); } result = (float) ((arg1)->tex_w); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_tex_h_set(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - float arg2 ; SWIG_check_num_args("ofTextureData::tex_h",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::tex_h",1,"ofTextureData *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTextureData::tex_h",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_tex_h_set",1,SWIGTYPE_p_ofTextureData); } arg2 = (float)lua_tonumber(L, 2); - if (arg1) (arg1)->tex_h = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_tex_h_get(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - float result; SWIG_check_num_args("ofTextureData::tex_h",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::tex_h",1,"ofTextureData *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_tex_h_get",1,SWIGTYPE_p_ofTextureData); } result = (float) ((arg1)->tex_h); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_width_set(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - float arg2 ; SWIG_check_num_args("ofTextureData::width",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::width",1,"ofTextureData *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTextureData::width",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_width_set",1,SWIGTYPE_p_ofTextureData); } arg2 = (float)lua_tonumber(L, 2); - if (arg1) (arg1)->width = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_width_get(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - float result; SWIG_check_num_args("ofTextureData::width",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::width",1,"ofTextureData *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_width_get",1,SWIGTYPE_p_ofTextureData); } result = (float) ((arg1)->width); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_height_set(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - float arg2 ; SWIG_check_num_args("ofTextureData::height",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::height",1,"ofTextureData *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTextureData::height",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_height_set",1,SWIGTYPE_p_ofTextureData); } arg2 = (float)lua_tonumber(L, 2); - if (arg1) (arg1)->height = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_height_get(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - float result; SWIG_check_num_args("ofTextureData::height",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::height",1,"ofTextureData *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_height_get",1,SWIGTYPE_p_ofTextureData); } result = (float) ((arg1)->height); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_bFlipTexture_set(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - bool arg2 ; SWIG_check_num_args("ofTextureData::bFlipTexture",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::bFlipTexture",1,"ofTextureData *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofTextureData::bFlipTexture",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_bFlipTexture_set",1,SWIGTYPE_p_ofTextureData); } arg2 = (lua_toboolean(L, 2)!=0); - if (arg1) (arg1)->bFlipTexture = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_bFlipTexture_get(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - bool result; SWIG_check_num_args("ofTextureData::bFlipTexture",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::bFlipTexture",1,"ofTextureData *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_bFlipTexture_get",1,SWIGTYPE_p_ofTextureData); } result = (bool) ((arg1)->bFlipTexture); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_compressionType_set(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - ofTexCompression arg2 ; SWIG_check_num_args("ofTextureData::compressionType",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::compressionType",1,"ofTextureData *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTextureData::compressionType",2,"ofTexCompression"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_compressionType_set",1,SWIGTYPE_p_ofTextureData); } - arg2 = (ofTexCompression)(int)lua_tonumber(L, 2); if (arg1) (arg1)->compressionType = arg2; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_compressionType_get(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - ofTexCompression result; SWIG_check_num_args("ofTextureData::compressionType",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::compressionType",1,"ofTextureData *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_compressionType_get",1,SWIGTYPE_p_ofTextureData); } - result = (ofTexCompression) ((arg1)->compressionType); lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_bAllocated_set(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - bool arg2 ; SWIG_check_num_args("ofTextureData::bAllocated",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::bAllocated",1,"ofTextureData *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofTextureData::bAllocated",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_bAllocated_set",1,SWIGTYPE_p_ofTextureData); } arg2 = (lua_toboolean(L, 2)!=0); - if (arg1) (arg1)->bAllocated = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_bAllocated_get(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - bool result; SWIG_check_num_args("ofTextureData::bAllocated",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::bAllocated",1,"ofTextureData *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_bAllocated_get",1,SWIGTYPE_p_ofTextureData); } result = (bool) ((arg1)->bAllocated); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_minFilter_set(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - GLint arg2 ; SWIG_check_num_args("ofTextureData::minFilter",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::minFilter",1,"ofTextureData *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTextureData::minFilter",2,"GLint"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_minFilter_set",1,SWIGTYPE_p_ofTextureData); } arg2 = (GLint)lua_tonumber(L, 2); - if (arg1) (arg1)->minFilter = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_minFilter_get(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - GLint result; SWIG_check_num_args("ofTextureData::minFilter",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::minFilter",1,"ofTextureData *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_minFilter_get",1,SWIGTYPE_p_ofTextureData); } result = (GLint) ((arg1)->minFilter); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_magFilter_set(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - GLint arg2 ; SWIG_check_num_args("ofTextureData::magFilter",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::magFilter",1,"ofTextureData *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTextureData::magFilter",2,"GLint"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_magFilter_set",1,SWIGTYPE_p_ofTextureData); } arg2 = (GLint)lua_tonumber(L, 2); - if (arg1) (arg1)->magFilter = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_magFilter_get(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - GLint result; SWIG_check_num_args("ofTextureData::magFilter",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::magFilter",1,"ofTextureData *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_magFilter_get",1,SWIGTYPE_p_ofTextureData); } result = (GLint) ((arg1)->magFilter); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_wrapModeHorizontal_set(lua_State* L) { int SWIG_arg = 0; - ofTextureData *arg1 = (ofTextureData *) 0 ; GLint arg2 ; SWIG_check_num_args("ofTextureData::wrapModeHorizontal",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::wrapModeHorizontal",1,"ofTextureData *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTextureData::wrapModeHorizontal",2,"GLint"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_wrapModeHorizontal_set",1,SWIGTYPE_p_ofTextureData); } arg2 = (GLint)lua_tonumber(L, 2); - if (arg1) (arg1)->wrapModeHorizontal = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_wrapModeHorizontal_get(lua_State* L) { int SWIG_arg = 0; - ofTextureData *arg1 = (ofTextureData *) 0 ; GLint result; SWIG_check_num_args("ofTextureData::wrapModeHorizontal",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::wrapModeHorizontal",1,"ofTextureData *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_wrapModeHorizontal_get",1,SWIGTYPE_p_ofTextureData); } - result = (GLint) ((arg1)->wrapModeHorizontal); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_wrapModeVertical_set(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - GLint arg2 ; SWIG_check_num_args("ofTextureData::wrapModeVertical",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::wrapModeVertical",1,"ofTextureData *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTextureData::wrapModeVertical",2,"GLint"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_wrapModeVertical_set",1,SWIGTYPE_p_ofTextureData); } arg2 = (GLint)lua_tonumber(L, 2); - if (arg1) (arg1)->wrapModeVertical = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_wrapModeVertical_get(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - GLint result; SWIG_check_num_args("ofTextureData::wrapModeVertical",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::wrapModeVertical",1,"ofTextureData *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_wrapModeVertical_get",1,SWIGTYPE_p_ofTextureData); } - result = (GLint) ((arg1)->wrapModeVertical); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_bufferId_set(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - unsigned int arg2 ; SWIG_check_num_args("ofTextureData::bufferId",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::bufferId",1,"ofTextureData *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTextureData::bufferId",2,"unsigned int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_bufferId_set",1,SWIGTYPE_p_ofTextureData); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned int)lua_tonumber(L, 2); - if (arg1) (arg1)->bufferId = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_bufferId_get(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - unsigned int result; SWIG_check_num_args("ofTextureData::bufferId",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::bufferId",1,"ofTextureData *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_bufferId_get",1,SWIGTYPE_p_ofTextureData); } result = (unsigned int) ((arg1)->bufferId); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_TextureData(void *obj) { -ofTextureData *arg1 = (ofTextureData *) obj; -delete arg1; -} -static int _proxy__wrap_new_TextureData(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_TextureData); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_TextureData_attributes[] = { - { "textureID", _wrap_TextureData_textureID_get, _wrap_TextureData_textureID_set }, - { "textureTarget", _wrap_TextureData_textureTarget_get, _wrap_TextureData_textureTarget_set }, - { "glInternalFormat", _wrap_TextureData_glInternalFormat_get, _wrap_TextureData_glInternalFormat_set }, - { "tex_t", _wrap_TextureData_tex_t_get, _wrap_TextureData_tex_t_set }, - { "tex_u", _wrap_TextureData_tex_u_get, _wrap_TextureData_tex_u_set }, - { "tex_w", _wrap_TextureData_tex_w_get, _wrap_TextureData_tex_w_set }, - { "tex_h", _wrap_TextureData_tex_h_get, _wrap_TextureData_tex_h_set }, - { "width", _wrap_TextureData_width_get, _wrap_TextureData_width_set }, - { "height", _wrap_TextureData_height_get, _wrap_TextureData_height_set }, - { "bFlipTexture", _wrap_TextureData_bFlipTexture_get, _wrap_TextureData_bFlipTexture_set }, - { "compressionType", _wrap_TextureData_compressionType_get, _wrap_TextureData_compressionType_set }, - { "bAllocated", _wrap_TextureData_bAllocated_get, _wrap_TextureData_bAllocated_set }, - { "minFilter", _wrap_TextureData_minFilter_get, _wrap_TextureData_minFilter_set }, - { "magFilter", _wrap_TextureData_magFilter_get, _wrap_TextureData_magFilter_set }, - { "wrapModeHorizontal", _wrap_TextureData_wrapModeHorizontal_get, _wrap_TextureData_wrapModeHorizontal_set }, - { "wrapModeVertical", _wrap_TextureData_wrapModeVertical_get, _wrap_TextureData_wrapModeVertical_set }, - { "bufferId", _wrap_TextureData_bufferId_get, _wrap_TextureData_bufferId_set }, - {0,0,0} -}; -static swig_lua_method swig_TextureData_methods[]= { - {0,0} -}; -static swig_lua_method swig_TextureData_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_TextureData_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_TextureData_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_TextureData_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_TextureData_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_TextureData_Sf_SwigStatic = { - "TextureData", - swig_TextureData_Sf_SwigStatic_methods, - swig_TextureData_Sf_SwigStatic_attributes, - swig_TextureData_Sf_SwigStatic_constants, - swig_TextureData_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_TextureData_bases[] = {0}; -static const char *swig_TextureData_base_names[] = {0}; -static swig_lua_class _wrap_class_TextureData = { "TextureData", "TextureData", &SWIGTYPE_p_ofTextureData,_proxy__wrap_new_TextureData, swig_delete_TextureData, swig_TextureData_methods, swig_TextureData_attributes, &swig_TextureData_Sf_SwigStatic, swig_TextureData_meta, swig_TextureData_bases, swig_TextureData_base_names }; - -static int _wrap_enableTextureEdgeHack(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofEnableTextureEdgeHack",0,0) - ofEnableTextureEdgeHack(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_disableTextureEdgeHack(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofDisableTextureEdgeHack",0,0) - ofDisableTextureEdgeHack(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_isTextureEdgeHackEnabled(lua_State* L) { int SWIG_arg = 0; bool result; - SWIG_check_num_args("ofIsTextureEdgeHackEnabled",0,0) result = (bool)ofIsTextureEdgeHackEnabled(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_new_Texture__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofTexture *result = 0 ; - SWIG_check_num_args("ofTexture::ofTexture",0,0) result = (ofTexture *)new ofTexture(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTexture,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Texture__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = 0 ; ofTexture *result = 0 ; - SWIG_check_num_args("ofTexture::ofTexture",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofTexture::ofTexture",1,"ofTexture &&"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("new_Texture",1,SWIGTYPE_p_ofTexture); } result = (ofTexture *)new ofTexture((ofTexture &&)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTexture,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Texture(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_Texture__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_new_Texture__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_Texture'\n" " Possible C/C++ prototypes are:\n" - " ofTexture::ofTexture()\n" " ofTexture::ofTexture(ofTexture &&)\n"); lua_error(L);return 0; } -static int _wrap_Texture_allocate__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - ofTextureData *arg2 = 0 ; SWIG_check_num_args("ofTexture::allocate",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::allocate",1,"ofTexture *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofTexture::allocate",2,"ofTextureData const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_allocate",1,SWIGTYPE_p_ofTexture); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("Texture_allocate",2,SWIGTYPE_p_ofTextureData); } (arg1)->allocate((ofTextureData const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_allocate__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - ofTextureData *arg2 = 0 ; int arg3 ; int arg4 ; SWIG_check_num_args("ofTexture::allocate",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::allocate",1,"ofTexture *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofTexture::allocate",2,"ofTextureData const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTexture::allocate",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofTexture::allocate",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_allocate",1,SWIGTYPE_p_ofTexture); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("Texture_allocate",2,SWIGTYPE_p_ofTextureData); } arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); (arg1)->allocate((ofTextureData const &)*arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_allocate__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; int arg2 ; - int arg3 ; int arg4 ; SWIG_check_num_args("ofTexture::allocate",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::allocate",1,"ofTexture *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTexture::allocate",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTexture::allocate",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofTexture::allocate",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_allocate",1,SWIGTYPE_p_ofTexture); } arg2 = (int)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); (arg1)->allocate(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Texture_allocate__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; int arg2 ; - int arg3 ; int arg4 ; int arg5 ; int arg6 ; SWIG_check_num_args("ofTexture::allocate",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::allocate",1,"ofTexture *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTexture::allocate",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTexture::allocate",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofTexture::allocate",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofTexture::allocate",5,"int"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofTexture::allocate",6,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_allocate",1,SWIGTYPE_p_ofTexture); } arg2 = (int)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); arg6 = (int)lua_tonumber(L, 6); - (arg1)->allocate(arg2,arg3,arg4,arg5,arg6); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_allocate__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; int arg2 ; - int arg3 ; int arg4 ; bool arg5 ; SWIG_check_num_args("ofTexture::allocate",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::allocate",1,"ofTexture *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTexture::allocate",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTexture::allocate",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofTexture::allocate",4,"int"); - if(!lua_isboolean(L,5)) SWIG_fail_arg("ofTexture::allocate",5,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_allocate",1,SWIGTYPE_p_ofTexture); } arg2 = (int)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); arg5 = (lua_toboolean(L, 5)!=0); (arg1)->allocate(arg2,arg3,arg4,arg5); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_allocate__SWIG_5(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; int arg2 ; - int arg3 ; int arg4 ; bool arg5 ; int arg6 ; int arg7 ; SWIG_check_num_args("ofTexture::allocate",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::allocate",1,"ofTexture *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTexture::allocate",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTexture::allocate",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofTexture::allocate",4,"int"); - if(!lua_isboolean(L,5)) SWIG_fail_arg("ofTexture::allocate",5,"bool"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofTexture::allocate",6,"int"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofTexture::allocate",7,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_allocate",1,SWIGTYPE_p_ofTexture); } arg2 = (int)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); arg5 = (lua_toboolean(L, 5)!=0); arg6 = (int)lua_tonumber(L, 6); - arg7 = (int)lua_tonumber(L, 7); (arg1)->allocate(arg2,arg3,arg4,arg5,arg6,arg7); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Texture_allocate__SWIG_6(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - ofPixels *arg2 = 0 ; SWIG_check_num_args("ofTexture::allocate",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::allocate",1,"ofTexture *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofTexture::allocate",2,"ofPixels const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_allocate",1,SWIGTYPE_p_ofTexture); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Texture_allocate",2,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } (arg1)->allocate((ofPixels const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_allocate__SWIG_7(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - ofPixels *arg2 = 0 ; bool arg3 ; SWIG_check_num_args("ofTexture::allocate",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::allocate",1,"ofTexture *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofTexture::allocate",2,"ofPixels const &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofTexture::allocate",3,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_allocate",1,SWIGTYPE_p_ofTexture); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Texture_allocate",2,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } arg3 = (lua_toboolean(L, 3)!=0); - (arg1)->allocate((ofPixels const &)*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_allocate__SWIG_8(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - ofShortPixels *arg2 = 0 ; SWIG_check_num_args("ofTexture::allocate",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::allocate",1,"ofTexture *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofTexture::allocate",2,"ofShortPixels const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_allocate",1,SWIGTYPE_p_ofTexture); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("Texture_allocate",2,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - (arg1)->allocate((ofShortPixels const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_allocate__SWIG_9(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - ofShortPixels *arg2 = 0 ; bool arg3 ; SWIG_check_num_args("ofTexture::allocate",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::allocate",1,"ofTexture *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofTexture::allocate",2,"ofShortPixels const &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofTexture::allocate",3,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_allocate",1,SWIGTYPE_p_ofTexture); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("Texture_allocate",2,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } arg3 = (lua_toboolean(L, 3)!=0); - (arg1)->allocate((ofShortPixels const &)*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_allocate__SWIG_10(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - ofFloatPixels *arg2 = 0 ; SWIG_check_num_args("ofTexture::allocate",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::allocate",1,"ofTexture *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofTexture::allocate",2,"ofFloatPixels const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_allocate",1,SWIGTYPE_p_ofTexture); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("Texture_allocate",2,SWIGTYPE_p_ofPixels_T_float_t); } (arg1)->allocate((ofFloatPixels const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_allocate__SWIG_11(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - ofFloatPixels *arg2 = 0 ; bool arg3 ; SWIG_check_num_args("ofTexture::allocate",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::allocate",1,"ofTexture *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofTexture::allocate",2,"ofFloatPixels const &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofTexture::allocate",3,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_allocate",1,SWIGTYPE_p_ofTexture); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("Texture_allocate",2,SWIGTYPE_p_ofPixels_T_float_t); } arg3 = (lua_toboolean(L, 3)!=0); - (arg1)->allocate((ofFloatPixels const &)*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_allocate(lua_State* L) { int argc; int argv[8]={ 1,2,3,4,5,6,7,8} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofTextureData, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Texture_allocate__SWIG_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Texture_allocate__SWIG_6(L);} } } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Texture_allocate__SWIG_8(L);} } } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Texture_allocate__SWIG_10(L);} } } if (argc == 3) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - return _wrap_Texture_allocate__SWIG_9(L);} } } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - return _wrap_Texture_allocate__SWIG_7(L);} } } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - return _wrap_Texture_allocate__SWIG_11(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofTextureData, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Texture_allocate__SWIG_1(L);} } } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Texture_allocate__SWIG_2(L);} } } } } if (argc == 5) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isboolean(L,argv[4]); } if (_v) { - return _wrap_Texture_allocate__SWIG_4(L);} } } } } } if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { return _wrap_Texture_allocate__SWIG_3(L);} } } } } } } - if (argc == 7) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isboolean(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { - return _wrap_Texture_allocate__SWIG_5(L);} } } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Texture_allocate'\n" " Possible C/C++ prototypes are:\n" - " ofTexture::allocate(ofTextureData const &)\n" " ofTexture::allocate(ofTextureData const &,int,int)\n" - " ofTexture::allocate(int,int,int)\n" " ofTexture::allocate(int,int,int,int,int)\n" - " ofTexture::allocate(int,int,int,bool)\n" " ofTexture::allocate(int,int,int,bool,int,int)\n" - " ofTexture::allocate(ofPixels const &)\n" " ofTexture::allocate(ofPixels const &,bool)\n" - " ofTexture::allocate(ofShortPixels const &)\n" " ofTexture::allocate(ofShortPixels const &,bool)\n" - " ofTexture::allocate(ofFloatPixels const &)\n" " ofTexture::allocate(ofFloatPixels const &,bool)\n"); - lua_error(L);return 0; } -static int _wrap_Texture_allocateAsBufferTexture(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - ofBufferObject *arg2 = 0 ; int arg3 ; SWIG_check_num_args("ofTexture::allocateAsBufferTexture",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::allocateAsBufferTexture",1,"ofTexture *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofTexture::allocateAsBufferTexture",2,"ofBufferObject const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTexture::allocateAsBufferTexture",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_allocateAsBufferTexture",1,SWIGTYPE_p_ofTexture); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBufferObject,0))){ - SWIG_fail_ptr("Texture_allocateAsBufferTexture",2,SWIGTYPE_p_ofBufferObject); } arg3 = (int)lua_tonumber(L, 3); - (arg1)->allocateAsBufferTexture((ofBufferObject const &)*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Texture_isAllocated(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; bool result; - SWIG_check_num_args("ofTexture::isAllocated",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::isAllocated",1,"ofTexture const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_isAllocated",1,SWIGTYPE_p_ofTexture); } result = (bool)((ofTexture const *)arg1)->isAllocated(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_clear(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - SWIG_check_num_args("ofTexture::clear",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::clear",1,"ofTexture *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_clear",1,SWIGTYPE_p_ofTexture); } (arg1)->clear(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Texture_setUseExternalTextureID(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - GLuint arg2 ; SWIG_check_num_args("ofTexture::setUseExternalTextureID",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::setUseExternalTextureID",1,"ofTexture *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTexture::setUseExternalTextureID",2,"GLuint"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_setUseExternalTextureID",1,SWIGTYPE_p_ofTexture); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (GLuint)lua_tonumber(L, 2); - (arg1)->setUseExternalTextureID(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_loadData__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - unsigned char *arg2 = (unsigned char *) (unsigned char *)0 ; int arg3 ; int arg4 ; int arg5 ; - SWIG_check_num_args("ofTexture::loadData",5,5) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::loadData",1,"ofTexture *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofTexture::loadData",2,"unsigned char const *const"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTexture::loadData",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofTexture::loadData",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofTexture::loadData",5,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_loadData",1,SWIGTYPE_p_ofTexture); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_unsigned_char,0))){ - SWIG_fail_ptr("Texture_loadData",2,SWIGTYPE_p_unsigned_char); } arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); (arg1)->loadData((unsigned char const *)arg2,arg3,arg4,arg5); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_loadData__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - unsigned short *arg2 = (unsigned short *) 0 ; int arg3 ; int arg4 ; int arg5 ; SWIG_check_num_args("ofTexture::loadData",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::loadData",1,"ofTexture *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofTexture::loadData",2,"unsigned short const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTexture::loadData",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofTexture::loadData",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofTexture::loadData",5,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_loadData",1,SWIGTYPE_p_ofTexture); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_unsigned_short,0))){ - SWIG_fail_ptr("Texture_loadData",2,SWIGTYPE_p_unsigned_short); } arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); (arg1)->loadData((unsigned short const *)arg2,arg3,arg4,arg5); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_loadData__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - float *arg2 = (float *) 0 ; int arg3 ; int arg4 ; int arg5 ; SWIG_check_num_args("ofTexture::loadData",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::loadData",1,"ofTexture *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofTexture::loadData",2,"float const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTexture::loadData",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofTexture::loadData",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofTexture::loadData",5,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_loadData",1,SWIGTYPE_p_ofTexture); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_float,0))){ SWIG_fail_ptr("Texture_loadData",2,SWIGTYPE_p_float); } - arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); - (arg1)->loadData((float const *)arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_loadData__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - ofPixels *arg2 = 0 ; SWIG_check_num_args("ofTexture::loadData",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::loadData",1,"ofTexture *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofTexture::loadData",2,"ofPixels const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_loadData",1,SWIGTYPE_p_ofTexture); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Texture_loadData",2,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } (arg1)->loadData((ofPixels const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_loadData__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - ofShortPixels *arg2 = 0 ; SWIG_check_num_args("ofTexture::loadData",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::loadData",1,"ofTexture *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofTexture::loadData",2,"ofShortPixels const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_loadData",1,SWIGTYPE_p_ofTexture); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("Texture_loadData",2,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - (arg1)->loadData((ofShortPixels const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_loadData__SWIG_5(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - ofFloatPixels *arg2 = 0 ; SWIG_check_num_args("ofTexture::loadData",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::loadData",1,"ofTexture *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofTexture::loadData",2,"ofFloatPixels const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_loadData",1,SWIGTYPE_p_ofTexture); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("Texture_loadData",2,SWIGTYPE_p_ofPixels_T_float_t); } (arg1)->loadData((ofFloatPixels const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_loadData__SWIG_6(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - ofPixels *arg2 = 0 ; int arg3 ; SWIG_check_num_args("ofTexture::loadData",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::loadData",1,"ofTexture *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofTexture::loadData",2,"ofPixels const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTexture::loadData",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_loadData",1,SWIGTYPE_p_ofTexture); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Texture_loadData",2,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } arg3 = (int)lua_tonumber(L, 3); - (arg1)->loadData((ofPixels const &)*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_loadData__SWIG_7(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - ofShortPixels *arg2 = 0 ; int arg3 ; SWIG_check_num_args("ofTexture::loadData",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::loadData",1,"ofTexture *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofTexture::loadData",2,"ofShortPixels const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTexture::loadData",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_loadData",1,SWIGTYPE_p_ofTexture); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("Texture_loadData",2,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } arg3 = (int)lua_tonumber(L, 3); - (arg1)->loadData((ofShortPixels const &)*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_loadData__SWIG_8(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - ofFloatPixels *arg2 = 0 ; int arg3 ; SWIG_check_num_args("ofTexture::loadData",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::loadData",1,"ofTexture *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofTexture::loadData",2,"ofFloatPixels const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTexture::loadData",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_loadData",1,SWIGTYPE_p_ofTexture); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("Texture_loadData",2,SWIGTYPE_p_ofPixels_T_float_t); } arg3 = (int)lua_tonumber(L, 3); - (arg1)->loadData((ofFloatPixels const &)*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_loadData__SWIG_9(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - ofBufferObject *arg2 = 0 ; int arg3 ; int arg4 ; SWIG_check_num_args("ofTexture::loadData",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::loadData",1,"ofTexture *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofTexture::loadData",2,"ofBufferObject const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTexture::loadData",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofTexture::loadData",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_loadData",1,SWIGTYPE_p_ofTexture); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBufferObject,0))){ - SWIG_fail_ptr("Texture_loadData",2,SWIGTYPE_p_ofBufferObject); } arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); (arg1)->loadData((ofBufferObject const &)*arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_loadData(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Texture_loadData__SWIG_3(L);} } } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Texture_loadData__SWIG_4(L);} } } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Texture_loadData__SWIG_5(L);} } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Texture_loadData__SWIG_6(L);} } } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Texture_loadData__SWIG_7(L);} } } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Texture_loadData__SWIG_8(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBufferObject, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Texture_loadData__SWIG_9(L);} } } } } if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_unsigned_short, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_Texture_loadData__SWIG_1(L);} } } } } } - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_Texture_loadData__SWIG_2(L);} } } } } } - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_unsigned_char, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_Texture_loadData__SWIG_0(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Texture_loadData'\n" " Possible C/C++ prototypes are:\n" - " ofTexture::loadData(unsigned char const *const,int,int,int)\n" - " ofTexture::loadData(unsigned short const *,int,int,int)\n" " ofTexture::loadData(float const *,int,int,int)\n" - " ofTexture::loadData(ofPixels const &)\n" " ofTexture::loadData(ofShortPixels const &)\n" - " ofTexture::loadData(ofFloatPixels const &)\n" " ofTexture::loadData(ofPixels const &,int)\n" - " ofTexture::loadData(ofShortPixels const &,int)\n" " ofTexture::loadData(ofFloatPixels const &,int)\n" - " ofTexture::loadData(ofBufferObject const &,int,int)\n"); lua_error(L);return 0; } -static int _wrap_Texture_loadScreenData(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; int arg2 ; - int arg3 ; int arg4 ; int arg5 ; SWIG_check_num_args("ofTexture::loadScreenData",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::loadScreenData",1,"ofTexture *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTexture::loadScreenData",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTexture::loadScreenData",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofTexture::loadScreenData",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofTexture::loadScreenData",5,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_loadScreenData",1,SWIGTYPE_p_ofTexture); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); - (arg1)->loadScreenData(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_draw__SWIG_0_0(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - ofPoint *arg2 = 0 ; SWIG_check_num_args("draw",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("draw",1,"ofTexture const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("draw",2,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_draw",1,SWIGTYPE_p_ofTexture); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Texture_draw",2,SWIGTYPE_p_ofVec3f); } - ((ofTexture const *)arg1)->draw((ofPoint const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Texture_draw__SWIG_0_1(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - ofRectangle *arg2 = 0 ; SWIG_check_num_args("draw",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("draw",1,"ofTexture const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("draw",2,"ofRectangle const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_draw",1,SWIGTYPE_p_ofTexture); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Texture_draw",2,SWIGTYPE_p_ofRectangle); } ((ofTexture const *)arg1)->draw((ofRectangle const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_draw__SWIG_0_2(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - ofPoint *arg2 = 0 ; float arg3 ; float arg4 ; SWIG_check_num_args("draw",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("draw",1,"ofTexture const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("draw",2,"ofPoint const &"); if(!lua_isnumber(L,3)) SWIG_fail_arg("draw",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("draw",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_draw",1,SWIGTYPE_p_ofTexture); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Texture_draw",2,SWIGTYPE_p_ofVec3f); } - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - ((ofTexture const *)arg1)->draw((ofPoint const &)*arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Texture_draw__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; float arg2 ; - float arg3 ; SWIG_check_num_args("ofTexture::draw",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::draw",1,"ofTexture const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTexture::draw",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTexture::draw",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_draw",1,SWIGTYPE_p_ofTexture); } arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - ((ofTexture const *)arg1)->draw(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_draw__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; float arg2 ; - float arg3 ; float arg4 ; SWIG_check_num_args("ofTexture::draw",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::draw",1,"ofTexture const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTexture::draw",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTexture::draw",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofTexture::draw",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_draw",1,SWIGTYPE_p_ofTexture); } arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - arg4 = (float)lua_tonumber(L, 4); ((ofTexture const *)arg1)->draw(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Texture_draw__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; float arg2 ; - float arg3 ; float arg4 ; float arg5 ; SWIG_check_num_args("ofTexture::draw",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::draw",1,"ofTexture const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTexture::draw",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTexture::draw",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofTexture::draw",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofTexture::draw",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_draw",1,SWIGTYPE_p_ofTexture); } arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); ((ofTexture const *)arg1)->draw(arg2,arg3,arg4,arg5); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_draw__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; float arg2 ; - float arg3 ; float arg4 ; float arg5 ; float arg6 ; SWIG_check_num_args("ofTexture::draw",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::draw",1,"ofTexture const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTexture::draw",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTexture::draw",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofTexture::draw",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofTexture::draw",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofTexture::draw",6,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_draw",1,SWIGTYPE_p_ofTexture); } arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); - ((ofTexture const *)arg1)->draw(arg2,arg3,arg4,arg5,arg6); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Texture_draw__SWIG_5(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; ofPoint *arg2 = 0 ; - ofPoint *arg3 = 0 ; ofPoint *arg4 = 0 ; ofPoint *arg5 = 0 ; SWIG_check_num_args("ofTexture::draw",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::draw",1,"ofTexture const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofTexture::draw",2,"ofPoint const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofTexture::draw",3,"ofPoint const &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofTexture::draw",4,"ofPoint const &"); - if(!lua_isuserdata(L,5)) SWIG_fail_arg("ofTexture::draw",5,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_draw",1,SWIGTYPE_p_ofTexture); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Texture_draw",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Texture_draw",3,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Texture_draw",4,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Texture_draw",5,SWIGTYPE_p_ofVec3f); } - ((ofTexture const *)arg1)->draw((ofPoint const &)*arg2,(ofPoint const &)*arg3,(ofPoint const &)*arg4,(ofPoint const &)*arg5); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_draw(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Texture_draw__SWIG_0_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Texture_draw__SWIG_0_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Texture_draw__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Texture_draw__SWIG_0_2(L);} } } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Texture_draw__SWIG_2(L);} } } } } if (argc == 5) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[4])==0 || SWIG_ConvertPtr(L,argv[4], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Texture_draw__SWIG_5(L);} } } } } } if (argc == 5) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Texture_draw__SWIG_3(L);} } } } } } if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { return _wrap_Texture_draw__SWIG_4(L);} } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Texture_draw'\n" " Possible C/C++ prototypes are:\n" - " draw(ofPoint const &) const\n" " draw(ofRectangle const &) const\n" " draw(ofPoint const &,float,float) const\n" - " ofTexture::draw(float,float) const\n" " ofTexture::draw(float,float,float) const\n" - " ofTexture::draw(float,float,float,float) const\n" " ofTexture::draw(float,float,float,float,float) const\n" - " ofTexture::draw(ofPoint const &,ofPoint const &,ofPoint const &,ofPoint const &) const\n"); lua_error(L);return 0; } -static int _wrap_Texture_drawSubsection__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - float arg2 ; float arg3 ; float arg4 ; float arg5 ; float arg6 ; float arg7 ; - SWIG_check_num_args("ofTexture::drawSubsection",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::drawSubsection",1,"ofTexture const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTexture::drawSubsection",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTexture::drawSubsection",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofTexture::drawSubsection",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofTexture::drawSubsection",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofTexture::drawSubsection",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofTexture::drawSubsection",7,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_drawSubsection",1,SWIGTYPE_p_ofTexture); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); - ((ofTexture const *)arg1)->drawSubsection(arg2,arg3,arg4,arg5,arg6,arg7); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Texture_drawSubsection__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - float arg2 ; float arg3 ; float arg4 ; float arg5 ; float arg6 ; float arg7 ; float arg8 ; - SWIG_check_num_args("ofTexture::drawSubsection",8,8) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::drawSubsection",1,"ofTexture const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTexture::drawSubsection",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTexture::drawSubsection",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofTexture::drawSubsection",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofTexture::drawSubsection",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofTexture::drawSubsection",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofTexture::drawSubsection",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofTexture::drawSubsection",8,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_drawSubsection",1,SWIGTYPE_p_ofTexture); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (float)lua_tonumber(L, 8); - ((ofTexture const *)arg1)->drawSubsection(arg2,arg3,arg4,arg5,arg6,arg7,arg8); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Texture_drawSubsection__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - float arg2 ; float arg3 ; float arg4 ; float arg5 ; float arg6 ; float arg7 ; float arg8 ; float arg9 ; - SWIG_check_num_args("ofTexture::drawSubsection",9,9) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::drawSubsection",1,"ofTexture const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTexture::drawSubsection",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTexture::drawSubsection",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofTexture::drawSubsection",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofTexture::drawSubsection",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofTexture::drawSubsection",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofTexture::drawSubsection",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofTexture::drawSubsection",8,"float"); - if(!lua_isnumber(L,9)) SWIG_fail_arg("ofTexture::drawSubsection",9,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_drawSubsection",1,SWIGTYPE_p_ofTexture); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (float)lua_tonumber(L, 8); - arg9 = (float)lua_tonumber(L, 9); ((ofTexture const *)arg1)->drawSubsection(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_drawSubsection__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - float arg2 ; float arg3 ; float arg4 ; float arg5 ; float arg6 ; float arg7 ; float arg8 ; float arg9 ; float arg10 ; - SWIG_check_num_args("ofTexture::drawSubsection",10,10) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::drawSubsection",1,"ofTexture const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTexture::drawSubsection",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTexture::drawSubsection",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofTexture::drawSubsection",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofTexture::drawSubsection",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofTexture::drawSubsection",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofTexture::drawSubsection",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofTexture::drawSubsection",8,"float"); - if(!lua_isnumber(L,9)) SWIG_fail_arg("ofTexture::drawSubsection",9,"float"); - if(!lua_isnumber(L,10)) SWIG_fail_arg("ofTexture::drawSubsection",10,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_drawSubsection",1,SWIGTYPE_p_ofTexture); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (float)lua_tonumber(L, 8); - arg9 = (float)lua_tonumber(L, 9); arg10 = (float)lua_tonumber(L, 10); - ((ofTexture const *)arg1)->drawSubsection(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_drawSubsection(lua_State* L) { int argc; int argv[11]={ 1,2,3,4,5,6,7,8,9,10,11} ; - argc = lua_gettop(L); if (argc == 7) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { - return _wrap_Texture_drawSubsection__SWIG_0(L);} } } } } } } } if (argc == 8) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { return _wrap_Texture_drawSubsection__SWIG_1(L);} } } } } } } - } } if (argc == 9) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { { _v = lua_isnumber(L,argv[8]); } if (_v) { - return _wrap_Texture_drawSubsection__SWIG_2(L);} } } } } } } } } } if (argc == 10) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { { _v = lua_isnumber(L,argv[8]); } if (_v) { { - _v = lua_isnumber(L,argv[9]); } if (_v) { return _wrap_Texture_drawSubsection__SWIG_3(L);} } } } } - } } } } } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Texture_drawSubsection'\n" - " Possible C/C++ prototypes are:\n" " ofTexture::drawSubsection(float,float,float,float,float,float) const\n" - " ofTexture::drawSubsection(float,float,float,float,float,float,float) const\n" - " ofTexture::drawSubsection(float,float,float,float,float,float,float,float) const\n" - " ofTexture::drawSubsection(float,float,float,float,float,float,float,float,float) const\n"); lua_error(L);return 0; } -static int _wrap_Texture_getQuad(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; ofPoint *arg2 = 0 ; - ofPoint *arg3 = 0 ; ofPoint *arg4 = 0 ; ofPoint *arg5 = 0 ; ofMesh result; SWIG_check_num_args("ofTexture::getQuad",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::getQuad",1,"ofTexture const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofTexture::getQuad",2,"ofPoint const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofTexture::getQuad",3,"ofPoint const &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofTexture::getQuad",4,"ofPoint const &"); - if(!lua_isuserdata(L,5)) SWIG_fail_arg("ofTexture::getQuad",5,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_getQuad",1,SWIGTYPE_p_ofTexture); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Texture_getQuad",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Texture_getQuad",3,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Texture_getQuad",4,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Texture_getQuad",5,SWIGTYPE_p_ofVec3f); } - result = ((ofTexture const *)arg1)->getQuad((ofPoint const &)*arg2,(ofPoint const &)*arg3,(ofPoint const &)*arg4,(ofPoint const &)*arg5); - { ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Texture_getMeshForSubsection(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; float arg2 ; - float arg3 ; float arg4 ; float arg5 ; float arg6 ; float arg7 ; float arg8 ; float arg9 ; float arg10 ; bool arg11 ; - ofRectMode arg12 ; ofMesh result; SWIG_check_num_args("ofTexture::getMeshForSubsection",12,12) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::getMeshForSubsection",1,"ofTexture const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTexture::getMeshForSubsection",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTexture::getMeshForSubsection",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofTexture::getMeshForSubsection",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofTexture::getMeshForSubsection",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofTexture::getMeshForSubsection",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofTexture::getMeshForSubsection",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofTexture::getMeshForSubsection",8,"float"); - if(!lua_isnumber(L,9)) SWIG_fail_arg("ofTexture::getMeshForSubsection",9,"float"); - if(!lua_isnumber(L,10)) SWIG_fail_arg("ofTexture::getMeshForSubsection",10,"float"); - if(!lua_isboolean(L,11)) SWIG_fail_arg("ofTexture::getMeshForSubsection",11,"bool"); - if(!lua_isnumber(L,12)) SWIG_fail_arg("ofTexture::getMeshForSubsection",12,"ofRectMode"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_getMeshForSubsection",1,SWIGTYPE_p_ofTexture); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (float)lua_tonumber(L, 8); - arg9 = (float)lua_tonumber(L, 9); arg10 = (float)lua_tonumber(L, 10); arg11 = (lua_toboolean(L, 11)!=0); - arg12 = (ofRectMode)(int)lua_tonumber(L, 12); - result = ((ofTexture const *)arg1)->getMeshForSubsection(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12); { - ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Texture_bind__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; int arg2 ; - SWIG_check_num_args("ofTexture::bind",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::bind",1,"ofTexture const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTexture::bind",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_bind",1,SWIGTYPE_p_ofTexture); } arg2 = (int)lua_tonumber(L, 2); - ((ofTexture const *)arg1)->bind(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_bind__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - SWIG_check_num_args("ofTexture::bind",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::bind",1,"ofTexture const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_bind",1,SWIGTYPE_p_ofTexture); } ((ofTexture const *)arg1)->bind(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_bind(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Texture_bind__SWIG_1(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Texture_bind__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Texture_bind'\n" " Possible C/C++ prototypes are:\n" - " ofTexture::bind(int) const\n" " ofTexture::bind() const\n"); lua_error(L);return 0; } -static int _wrap_Texture_unbind__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; int arg2 ; - SWIG_check_num_args("ofTexture::unbind",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::unbind",1,"ofTexture const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTexture::unbind",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_unbind",1,SWIGTYPE_p_ofTexture); } arg2 = (int)lua_tonumber(L, 2); - ((ofTexture const *)arg1)->unbind(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_unbind__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - SWIG_check_num_args("ofTexture::unbind",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::unbind",1,"ofTexture const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_unbind",1,SWIGTYPE_p_ofTexture); } ((ofTexture const *)arg1)->unbind(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_unbind(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Texture_unbind__SWIG_1(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Texture_unbind__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Texture_unbind'\n" " Possible C/C++ prototypes are:\n" - " ofTexture::unbind(int) const\n" " ofTexture::unbind() const\n"); lua_error(L);return 0; } -static int _wrap_Texture_getAlphaMask(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - ofTexture *result = 0 ; SWIG_check_num_args("ofTexture::getAlphaMask",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::getAlphaMask",1,"ofTexture const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_getAlphaMask",1,SWIGTYPE_p_ofTexture); } - result = (ofTexture *)((ofTexture const *)arg1)->getAlphaMask(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTexture,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Texture_getHeight(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; float result; - SWIG_check_num_args("ofTexture::getHeight",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::getHeight",1,"ofTexture const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_getHeight",1,SWIGTYPE_p_ofTexture); } result = (float)((ofTexture const *)arg1)->getHeight(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_getWidth(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; float result; - SWIG_check_num_args("ofTexture::getWidth",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::getWidth",1,"ofTexture const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_getWidth",1,SWIGTYPE_p_ofTexture); } result = (float)((ofTexture const *)arg1)->getWidth(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_setAnchorPercent(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; float arg2 ; - float arg3 ; SWIG_check_num_args("ofTexture::setAnchorPercent",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::setAnchorPercent",1,"ofTexture *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTexture::setAnchorPercent",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTexture::setAnchorPercent",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_setAnchorPercent",1,SWIGTYPE_p_ofTexture); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->setAnchorPercent(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Texture_setAnchorPoint(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; float arg2 ; - float arg3 ; SWIG_check_num_args("ofTexture::setAnchorPoint",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::setAnchorPoint",1,"ofTexture *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTexture::setAnchorPoint",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTexture::setAnchorPoint",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_setAnchorPoint",1,SWIGTYPE_p_ofTexture); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->setAnchorPoint(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Texture_resetAnchor(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - SWIG_check_num_args("ofTexture::resetAnchor",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::resetAnchor",1,"ofTexture *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_resetAnchor",1,SWIGTYPE_p_ofTexture); } (arg1)->resetAnchor(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_getCoordFromPoint(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; float arg2 ; - float arg3 ; ofPoint result; SWIG_check_num_args("ofTexture::getCoordFromPoint",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::getCoordFromPoint",1,"ofTexture const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTexture::getCoordFromPoint",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTexture::getCoordFromPoint",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_getCoordFromPoint",1,SWIGTYPE_p_ofTexture); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); result = ((ofTexture const *)arg1)->getCoordFromPoint(arg2,arg3); { - ofPoint * resultptr = new ofPoint((const ofPoint &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Texture_getCoordFromPercent(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; float arg2 ; - float arg3 ; ofPoint result; SWIG_check_num_args("ofTexture::getCoordFromPercent",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::getCoordFromPercent",1,"ofTexture const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTexture::getCoordFromPercent",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTexture::getCoordFromPercent",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_getCoordFromPercent",1,SWIGTYPE_p_ofTexture); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); result = ((ofTexture const *)arg1)->getCoordFromPercent(arg2,arg3); { - ofPoint * resultptr = new ofPoint((const ofPoint &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Texture_setAlphaMask(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - ofTexture *arg2 = 0 ; SWIG_check_num_args("ofTexture::setAlphaMask",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::setAlphaMask",1,"ofTexture *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofTexture::setAlphaMask",2,"ofTexture &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_setAlphaMask",1,SWIGTYPE_p_ofTexture); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_setAlphaMask",2,SWIGTYPE_p_ofTexture); } (arg1)->setAlphaMask(*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_disableAlphaMask(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - SWIG_check_num_args("ofTexture::disableAlphaMask",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::disableAlphaMask",1,"ofTexture *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_disableAlphaMask",1,SWIGTYPE_p_ofTexture); } (arg1)->disableAlphaMask(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_setTextureWrap(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; GLint arg2 ; - GLint arg3 ; SWIG_check_num_args("ofTexture::setTextureWrap",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::setTextureWrap",1,"ofTexture *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTexture::setTextureWrap",2,"GLint"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTexture::setTextureWrap",3,"GLint"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_setTextureWrap",1,SWIGTYPE_p_ofTexture); } arg2 = (GLint)lua_tonumber(L, 2); - arg3 = (GLint)lua_tonumber(L, 3); (arg1)->setTextureWrap(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Texture_setTextureMinMagFilter(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - GLint arg2 ; GLint arg3 ; SWIG_check_num_args("ofTexture::setTextureMinMagFilter",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::setTextureMinMagFilter",1,"ofTexture *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTexture::setTextureMinMagFilter",2,"GLint"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTexture::setTextureMinMagFilter",3,"GLint"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_setTextureMinMagFilter",1,SWIGTYPE_p_ofTexture); } arg2 = (GLint)lua_tonumber(L, 2); - arg3 = (GLint)lua_tonumber(L, 3); (arg1)->setTextureMinMagFilter(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Texture_setTextureMatrix(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - ofMatrix4x4 *arg2 = 0 ; SWIG_check_num_args("ofTexture::setTextureMatrix",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::setTextureMatrix",1,"ofTexture *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofTexture::setTextureMatrix",2,"ofMatrix4x4 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_setTextureMatrix",1,SWIGTYPE_p_ofTexture); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Texture_setTextureMatrix",2,SWIGTYPE_p_ofMatrix4x4); } (arg1)->setTextureMatrix((ofMatrix4x4 const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_getTextureMatrix(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - ofMatrix4x4 *result = 0 ; SWIG_check_num_args("ofTexture::getTextureMatrix",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::getTextureMatrix",1,"ofTexture const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_getTextureMatrix",1,SWIGTYPE_p_ofTexture); } - result = (ofMatrix4x4 *) &((ofTexture const *)arg1)->getTextureMatrix(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMatrix4x4,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Texture_isUsingTextureMatrix(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; bool result; - SWIG_check_num_args("ofTexture::isUsingTextureMatrix",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::isUsingTextureMatrix",1,"ofTexture const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_isUsingTextureMatrix",1,SWIGTYPE_p_ofTexture); } - result = (bool)((ofTexture const *)arg1)->isUsingTextureMatrix(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_disableTextureMatrix(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - SWIG_check_num_args("ofTexture::disableTextureMatrix",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::disableTextureMatrix",1,"ofTexture *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_disableTextureMatrix",1,SWIGTYPE_p_ofTexture); } (arg1)->disableTextureMatrix(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_setCompression(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - ofTexCompression arg2 ; SWIG_check_num_args("ofTexture::setCompression",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::setCompression",1,"ofTexture *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTexture::setCompression",2,"ofTexCompression"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_setCompression",1,SWIGTYPE_p_ofTexture); } arg2 = (ofTexCompression)(int)lua_tonumber(L, 2); - (arg1)->setCompression(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_setRGToRGBASwizzles(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; bool arg2 ; - SWIG_check_num_args("ofTexture::setRGToRGBASwizzles",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::setRGToRGBASwizzles",1,"ofTexture *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofTexture::setRGToRGBASwizzles",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_setRGToRGBASwizzles",1,SWIGTYPE_p_ofTexture); } arg2 = (lua_toboolean(L, 2)!=0); - (arg1)->setRGToRGBASwizzles(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_setSwizzle(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; GLenum arg2 ; - GLenum arg3 ; SWIG_check_num_args("ofTexture::setSwizzle",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::setSwizzle",1,"ofTexture *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTexture::setSwizzle",2,"GLenum"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTexture::setSwizzle",3,"GLenum"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_setSwizzle",1,SWIGTYPE_p_ofTexture); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (GLenum)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (GLenum)lua_tonumber(L, 3); - (arg1)->setSwizzle(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_readToPixels__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - ofPixels *arg2 = 0 ; SWIG_check_num_args("ofTexture::readToPixels",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::readToPixels",1,"ofTexture const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofTexture::readToPixels",2,"ofPixels &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_readToPixels",1,SWIGTYPE_p_ofTexture); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Texture_readToPixels",2,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - ((ofTexture const *)arg1)->readToPixels(*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_readToPixels__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - ofShortPixels *arg2 = 0 ; SWIG_check_num_args("ofTexture::readToPixels",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::readToPixels",1,"ofTexture const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofTexture::readToPixels",2,"ofShortPixels &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_readToPixels",1,SWIGTYPE_p_ofTexture); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("Texture_readToPixels",2,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - ((ofTexture const *)arg1)->readToPixels(*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_readToPixels__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - ofFloatPixels *arg2 = 0 ; SWIG_check_num_args("ofTexture::readToPixels",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::readToPixels",1,"ofTexture const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofTexture::readToPixels",2,"ofFloatPixels &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_readToPixels",1,SWIGTYPE_p_ofTexture); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("Texture_readToPixels",2,SWIGTYPE_p_ofPixels_T_float_t); } ((ofTexture const *)arg1)->readToPixels(*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_readToPixels(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Texture_readToPixels__SWIG_0(L);} } } if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Texture_readToPixels__SWIG_1(L);} } } if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Texture_readToPixels__SWIG_2(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Texture_readToPixels'\n" - " Possible C/C++ prototypes are:\n" " ofTexture::readToPixels(ofPixels &) const\n" - " ofTexture::readToPixels(ofShortPixels &) const\n" " ofTexture::readToPixels(ofFloatPixels &) const\n"); - lua_error(L);return 0; } -static int _wrap_Texture_copyTo(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; ofBufferObject *arg2 = 0 ; - SWIG_check_num_args("ofTexture::copyTo",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::copyTo",1,"ofTexture const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofTexture::copyTo",2,"ofBufferObject &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_copyTo",1,SWIGTYPE_p_ofTexture); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBufferObject,0))){ - SWIG_fail_ptr("Texture_copyTo",2,SWIGTYPE_p_ofBufferObject); } ((ofTexture const *)arg1)->copyTo(*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_getTextureData__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - ofTextureData *result = 0 ; SWIG_check_num_args("ofTexture::getTextureData",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::getTextureData",1,"ofTexture *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_getTextureData",1,SWIGTYPE_p_ofTexture); } result = (ofTextureData *) &(arg1)->getTextureData(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTextureData,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Texture_getTextureData__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - ofTextureData *result = 0 ; SWIG_check_num_args("ofTexture::getTextureData",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::getTextureData",1,"ofTexture const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_getTextureData",1,SWIGTYPE_p_ofTexture); } - result = (ofTextureData *) &((ofTexture const *)arg1)->getTextureData(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTextureData,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Texture_getTextureData(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Texture_getTextureData__SWIG_0(L);} } if (argc == 1) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Texture_getTextureData__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Texture_getTextureData'\n" - " Possible C/C++ prototypes are:\n" " ofTexture::getTextureData()\n" " ofTexture::getTextureData() const\n"); - lua_error(L);return 0; } -static int _wrap_Texture_enableMipmap(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - SWIG_check_num_args("ofTexture::enableMipmap",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::enableMipmap",1,"ofTexture *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_enableMipmap",1,SWIGTYPE_p_ofTexture); } (arg1)->enableMipmap(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_disableMipmap(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - SWIG_check_num_args("ofTexture::disableMipmap",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::disableMipmap",1,"ofTexture *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_disableMipmap",1,SWIGTYPE_p_ofTexture); } (arg1)->disableMipmap(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_generateMipmap(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - SWIG_check_num_args("ofTexture::generateMipmap",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::generateMipmap",1,"ofTexture *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_generateMipmap",1,SWIGTYPE_p_ofTexture); } (arg1)->generateMipmap(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_hasMipmap(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; bool result; - SWIG_check_num_args("ofTexture::hasMipmap",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::hasMipmap",1,"ofTexture const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_hasMipmap",1,SWIGTYPE_p_ofTexture); } result = (bool)((ofTexture const *)arg1)->hasMipmap(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_Texture(void *obj) { -ofTexture *arg1 = (ofTexture *) obj; -delete arg1; -} -static int _proxy__wrap_new_Texture(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_Texture); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_Texture_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_Texture_methods[]= { - { "allocate", _wrap_Texture_allocate}, - { "allocateAsBufferTexture", _wrap_Texture_allocateAsBufferTexture}, - { "isAllocated", _wrap_Texture_isAllocated}, - { "clear", _wrap_Texture_clear}, - { "setUseExternalTextureID", _wrap_Texture_setUseExternalTextureID}, - { "loadData", _wrap_Texture_loadData}, - { "loadScreenData", _wrap_Texture_loadScreenData}, - { "draw", _wrap_Texture_draw}, - { "drawSubsection", _wrap_Texture_drawSubsection}, - { "getQuad", _wrap_Texture_getQuad}, - { "getMeshForSubsection", _wrap_Texture_getMeshForSubsection}, - { "bind", _wrap_Texture_bind}, - { "unbind", _wrap_Texture_unbind}, - { "getAlphaMask", _wrap_Texture_getAlphaMask}, - { "getHeight", _wrap_Texture_getHeight}, - { "getWidth", _wrap_Texture_getWidth}, - { "setAnchorPercent", _wrap_Texture_setAnchorPercent}, - { "setAnchorPoint", _wrap_Texture_setAnchorPoint}, - { "resetAnchor", _wrap_Texture_resetAnchor}, - { "getCoordFromPoint", _wrap_Texture_getCoordFromPoint}, - { "getCoordFromPercent", _wrap_Texture_getCoordFromPercent}, - { "setAlphaMask", _wrap_Texture_setAlphaMask}, - { "disableAlphaMask", _wrap_Texture_disableAlphaMask}, - { "setTextureWrap", _wrap_Texture_setTextureWrap}, - { "setTextureMinMagFilter", _wrap_Texture_setTextureMinMagFilter}, - { "setTextureMatrix", _wrap_Texture_setTextureMatrix}, - { "getTextureMatrix", _wrap_Texture_getTextureMatrix}, - { "isUsingTextureMatrix", _wrap_Texture_isUsingTextureMatrix}, - { "disableTextureMatrix", _wrap_Texture_disableTextureMatrix}, - { "setCompression", _wrap_Texture_setCompression}, - { "setRGToRGBASwizzles", _wrap_Texture_setRGToRGBASwizzles}, - { "setSwizzle", _wrap_Texture_setSwizzle}, - { "readToPixels", _wrap_Texture_readToPixels}, - { "copyTo", _wrap_Texture_copyTo}, - { "getTextureData", _wrap_Texture_getTextureData}, - { "enableMipmap", _wrap_Texture_enableMipmap}, - { "disableMipmap", _wrap_Texture_disableMipmap}, - { "generateMipmap", _wrap_Texture_generateMipmap}, - { "hasMipmap", _wrap_Texture_hasMipmap}, - {0,0} -}; -static swig_lua_method swig_Texture_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_Texture_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_Texture_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_Texture_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_Texture_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_Texture_Sf_SwigStatic = { - "Texture", - swig_Texture_Sf_SwigStatic_methods, - swig_Texture_Sf_SwigStatic_attributes, - swig_Texture_Sf_SwigStatic_constants, - swig_Texture_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_Texture_bases[] = {0}; -static const char *swig_Texture_base_names[] = {0}; -static swig_lua_class _wrap_class_Texture = { "Texture", "Texture", &SWIGTYPE_p_ofTexture,_proxy__wrap_new_Texture, swig_delete_Texture, swig_Texture_methods, swig_Texture_attributes, &swig_Texture_Sf_SwigStatic, swig_Texture_meta, swig_Texture_bases, swig_Texture_base_names }; - -static int _wrap_new_Image__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofImage_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofImage_< unsigned char >::ofImage_",0,0) - result = (ofImage_< unsigned char > *)new ofImage_< unsigned char >(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofImage_T_unsigned_char_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_Image__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPixels_< unsigned char > *arg1 = 0 ; - ofImage_< unsigned char > *result = 0 ; SWIG_check_num_args("ofImage_< unsigned char >::ofImage_",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::ofImage_",1,"ofPixels_< unsigned char > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("new_Image",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - result = (ofImage_< unsigned char > *)new ofImage_< unsigned char >((ofPixels_< unsigned char > const &)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofImage_T_unsigned_char_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_Image__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = 0 ; ofImage_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofImage_< unsigned char >::ofImage_",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::ofImage_",1,"ofFile const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("new_Image",1,SWIGTYPE_p_ofFile); } - result = (ofImage_< unsigned char > *)new ofImage_< unsigned char >((ofFile const &)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofImage_T_unsigned_char_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_Image__SWIG_3(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - ofImage_< unsigned char > *result = 0 ; SWIG_check_num_args("ofImage_< unsigned char >::ofImage_",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::ofImage_",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; - result = (ofImage_< unsigned char > *)new ofImage_< unsigned char >((std::string const &)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofImage_T_unsigned_char_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_Image__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofImage_< unsigned char > *arg1 = 0 ; - ofImage_< unsigned char > *result = 0 ; SWIG_check_num_args("ofImage_< unsigned char >::ofImage_",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::ofImage_",1,"ofImage_< unsigned char > &&"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("new_Image",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } - result = (ofImage_< unsigned char > *)new ofImage_< unsigned char >((ofImage_< unsigned char > &&)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofImage_T_unsigned_char_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_Image(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_Image__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_new_Image__SWIG_1(L);} } if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_new_Image__SWIG_2(L);} } if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_new_Image__SWIG_4(L);} } if (argc == 1) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { return _wrap_new_Image__SWIG_3(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_Image'\n" " Possible C/C++ prototypes are:\n" - " ofImage_< unsigned char >::ofImage_()\n" " ofImage_< unsigned char >::ofImage_(ofPixels_< unsigned char > const &)\n" - " ofImage_< unsigned char >::ofImage_(ofFile const &)\n" " ofImage_< unsigned char >::ofImage_(std::string const &)\n" - " ofImage_< unsigned char >::ofImage_(ofImage_< unsigned char > &&)\n"); lua_error(L);return 0; } -static int _wrap_Image_allocate(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; int arg2 ; int arg3 ; ofImageType arg4 ; - SWIG_check_num_args("ofImage_< unsigned char >::allocate",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::allocate",1,"ofImage_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::allocate",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned char >::allocate",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< unsigned char >::allocate",4,"ofImageType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_allocate",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); arg4 = (ofImageType)(int)lua_tonumber(L, 4); (arg1)->allocate(arg2,arg3,arg4); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_isAllocated(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; bool result; - SWIG_check_num_args("ofImage_< unsigned char >::isAllocated",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::isAllocated",1,"ofImage_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_isAllocated",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } - result = (bool)((ofImage_< unsigned char > const *)arg1)->isAllocated(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_clear(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; - SWIG_check_num_args("ofImage_< unsigned char >::clear",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::clear",1,"ofImage_< unsigned char > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_clear",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } (arg1)->clear(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_load__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; std::string *arg2 = 0 ; std::string temp2 ; bool result; - SWIG_check_num_args("ofImage_< unsigned char >::load",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::load",1,"ofImage_< unsigned char > *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::load",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_load",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; result = (bool)(arg1)->load((std::string const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_load__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; ofBuffer *arg2 = 0 ; bool result; - SWIG_check_num_args("ofImage_< unsigned char >::load",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::load",1,"ofImage_< unsigned char > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::load",2,"ofBuffer const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_load",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBuffer,0))){ SWIG_fail_ptr("Image_load",2,SWIGTYPE_p_ofBuffer); } - result = (bool)(arg1)->load((ofBuffer const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_load__SWIG_2(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; ofFile *arg2 = 0 ; bool result; - SWIG_check_num_args("ofImage_< unsigned char >::load",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::load",1,"ofImage_< unsigned char > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::load",2,"ofFile const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_load",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("Image_load",2,SWIGTYPE_p_ofFile); } - result = (bool)(arg1)->load((ofFile const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_load(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBuffer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Image_load__SWIG_1(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Image_load__SWIG_2(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { - return _wrap_Image_load__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Image_load'\n" " Possible C/C++ prototypes are:\n" - " ofImage_< unsigned char >::load(std::string const &)\n" " ofImage_< unsigned char >::load(ofBuffer const &)\n" - " ofImage_< unsigned char >::load(ofFile const &)\n"); lua_error(L);return 0; } -static int _wrap_Image_draw__SWIG_0_0(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; ofPoint *arg2 = 0 ; SWIG_check_num_args("draw",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("draw",1,"ofImage_< unsigned char > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("draw",2,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_draw",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Image_draw",2,SWIGTYPE_p_ofVec3f); } - ((ofImage_< unsigned char > const *)arg1)->draw((ofPoint const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Image_draw__SWIG_0_1(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; ofRectangle *arg2 = 0 ; SWIG_check_num_args("draw",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("draw",1,"ofImage_< unsigned char > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("draw",2,"ofRectangle const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_draw",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Image_draw",2,SWIGTYPE_p_ofRectangle); } - ((ofImage_< unsigned char > const *)arg1)->draw((ofRectangle const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Image_draw__SWIG_0_2(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; ofPoint *arg2 = 0 ; float arg3 ; float arg4 ; - SWIG_check_num_args("draw",4,4) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("draw",1,"ofImage_< unsigned char > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("draw",2,"ofPoint const &"); if(!lua_isnumber(L,3)) SWIG_fail_arg("draw",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("draw",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_draw",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Image_draw",2,SWIGTYPE_p_ofVec3f); } - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - ((ofImage_< unsigned char > const *)arg1)->draw((ofPoint const &)*arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Image_draw__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofImage_< unsigned char >::draw",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::draw",1,"ofImage_< unsigned char > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::draw",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned char >::draw",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_draw",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); ((ofImage_< unsigned char > const *)arg1)->draw(arg2,arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_draw__SWIG_2(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; float arg2 ; float arg3 ; float arg4 ; - SWIG_check_num_args("ofImage_< unsigned char >::draw",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::draw",1,"ofImage_< unsigned char > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::draw",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned char >::draw",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< unsigned char >::draw",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_draw",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - ((ofImage_< unsigned char > const *)arg1)->draw(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Image_draw__SWIG_3(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; float arg2 ; float arg3 ; float arg4 ; float arg5 ; - SWIG_check_num_args("ofImage_< unsigned char >::draw",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::draw",1,"ofImage_< unsigned char > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::draw",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned char >::draw",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< unsigned char >::draw",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< unsigned char >::draw",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_draw",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - ((ofImage_< unsigned char > const *)arg1)->draw(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Image_draw__SWIG_4(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; float arg2 ; float arg3 ; float arg4 ; float arg5 ; - float arg6 ; SWIG_check_num_args("ofImage_< unsigned char >::draw",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::draw",1,"ofImage_< unsigned char > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::draw",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned char >::draw",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< unsigned char >::draw",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< unsigned char >::draw",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofImage_< unsigned char >::draw",6,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_draw",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); ((ofImage_< unsigned char > const *)arg1)->draw(arg2,arg3,arg4,arg5,arg6); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_draw(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Image_draw__SWIG_0_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Image_draw__SWIG_0_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_Image_draw__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Image_draw__SWIG_0_2(L);} } } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Image_draw__SWIG_2(L);} } } } } - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Image_draw__SWIG_3(L);} } } } } } if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { return _wrap_Image_draw__SWIG_4(L);} } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Image_draw'\n" " Possible C/C++ prototypes are:\n" - " draw(ofPoint const &) const\n" " draw(ofRectangle const &) const\n" " draw(ofPoint const &,float,float) const\n" - " ofImage_< unsigned char >::draw(float,float) const\n" " ofImage_< unsigned char >::draw(float,float,float) const\n" - " ofImage_< unsigned char >::draw(float,float,float,float) const\n" - " ofImage_< unsigned char >::draw(float,float,float,float,float) const\n"); lua_error(L);return 0; } -static int _wrap_Image_drawSubsection__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; float arg2 ; float arg3 ; float arg4 ; float arg5 ; - float arg6 ; float arg7 ; SWIG_check_num_args("ofImage_< unsigned char >::drawSubsection",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",1,"ofImage_< unsigned char > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",7,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_drawSubsection",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); - ((ofImage_< unsigned char > const *)arg1)->drawSubsection(arg2,arg3,arg4,arg5,arg6,arg7); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_drawSubsection__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; float arg2 ; float arg3 ; float arg4 ; float arg5 ; - float arg6 ; float arg7 ; float arg8 ; SWIG_check_num_args("ofImage_< unsigned char >::drawSubsection",8,8) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",1,"ofImage_< unsigned char > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",8,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_drawSubsection",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (float)lua_tonumber(L, 8); - ((ofImage_< unsigned char > const *)arg1)->drawSubsection(arg2,arg3,arg4,arg5,arg6,arg7,arg8); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_drawSubsection__SWIG_2(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; float arg2 ; float arg3 ; float arg4 ; float arg5 ; - float arg6 ; float arg7 ; float arg8 ; float arg9 ; SWIG_check_num_args("ofImage_< unsigned char >::drawSubsection",9,9) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",1,"ofImage_< unsigned char > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",8,"float"); - if(!lua_isnumber(L,9)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",9,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_drawSubsection",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (float)lua_tonumber(L, 8); - arg9 = (float)lua_tonumber(L, 9); - ((ofImage_< unsigned char > const *)arg1)->drawSubsection(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_drawSubsection__SWIG_3(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; float arg2 ; float arg3 ; float arg4 ; float arg5 ; - float arg6 ; float arg7 ; float arg8 ; float arg9 ; float arg10 ; - SWIG_check_num_args("ofImage_< unsigned char >::drawSubsection",10,10) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",1,"ofImage_< unsigned char > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",8,"float"); - if(!lua_isnumber(L,9)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",9,"float"); - if(!lua_isnumber(L,10)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",10,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_drawSubsection",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (float)lua_tonumber(L, 8); - arg9 = (float)lua_tonumber(L, 9); arg10 = (float)lua_tonumber(L, 10); - ((ofImage_< unsigned char > const *)arg1)->drawSubsection(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_drawSubsection(lua_State* L) { int argc; int argv[11]={ 1,2,3,4,5,6,7,8,9,10,11} ; argc = lua_gettop(L); - if (argc == 7) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { - return _wrap_Image_drawSubsection__SWIG_0(L);} } } } } } } } if (argc == 8) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { return _wrap_Image_drawSubsection__SWIG_1(L);} } } } } } } - } } if (argc == 9) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { { _v = lua_isnumber(L,argv[8]); } if (_v) { - return _wrap_Image_drawSubsection__SWIG_2(L);} } } } } } } } } } if (argc == 10) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { { _v = lua_isnumber(L,argv[8]); } if (_v) { { - _v = lua_isnumber(L,argv[9]); } if (_v) { return _wrap_Image_drawSubsection__SWIG_3(L);} } } } } } - } } } } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Image_drawSubsection'\n" - " Possible C/C++ prototypes are:\n" - " ofImage_< unsigned char >::drawSubsection(float,float,float,float,float,float) const\n" - " ofImage_< unsigned char >::drawSubsection(float,float,float,float,float,float,float) const\n" - " ofImage_< unsigned char >::drawSubsection(float,float,float,float,float,float,float,float) const\n" - " ofImage_< unsigned char >::drawSubsection(float,float,float,float,float,float,float,float,float) const\n"); - lua_error(L);return 0; } -static int _wrap_Image_update(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; - SWIG_check_num_args("ofImage_< unsigned char >::update",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::update",1,"ofImage_< unsigned char > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_update",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } (arg1)->update(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_setUseTexture(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; bool arg2 ; - SWIG_check_num_args("ofImage_< unsigned char >::setUseTexture",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::setUseTexture",1,"ofImage_< unsigned char > *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::setUseTexture",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_setUseTexture",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } arg2 = (lua_toboolean(L, 2)!=0); - (arg1)->setUseTexture(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_isUsingTexture(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; bool result; - SWIG_check_num_args("ofImage_< unsigned char >::isUsingTexture",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::isUsingTexture",1,"ofImage_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_isUsingTexture",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } - result = (bool)((ofImage_< unsigned char > const *)arg1)->isUsingTexture(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_getTexture__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; ofTexture *result = 0 ; - SWIG_check_num_args("ofImage_< unsigned char >::getTexture",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::getTexture",1,"ofImage_< unsigned char > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_getTexture",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } result = (ofTexture *) &(arg1)->getTexture(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTexture,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Image_getTexture__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; ofTexture *result = 0 ; - SWIG_check_num_args("ofImage_< unsigned char >::getTexture",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::getTexture",1,"ofImage_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_getTexture",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } - result = (ofTexture *) &((ofImage_< unsigned char > const *)arg1)->getTexture(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTexture,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Image_getTexture(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v; - { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Image_getTexture__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Image_getTexture__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Image_getTexture'\n" " Possible C/C++ prototypes are:\n" - " ofImage_< unsigned char >::getTexture()\n" " ofImage_< unsigned char >::getTexture() const\n"); - lua_error(L);return 0; } -static int _wrap_Image_bind__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; int arg2 ; - SWIG_check_num_args("ofImage_< unsigned char >::bind",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::bind",1,"ofImage_< unsigned char > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::bind",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_bind",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } arg2 = (int)lua_tonumber(L, 2); - ((ofImage_< unsigned char > const *)arg1)->bind(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_bind__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; SWIG_check_num_args("ofImage_< unsigned char >::bind",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::bind",1,"ofImage_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_bind",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } ((ofImage_< unsigned char > const *)arg1)->bind(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_bind(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Image_bind__SWIG_1(L);} } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Image_bind__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Image_bind'\n" " Possible C/C++ prototypes are:\n" - " ofImage_< unsigned char >::bind(int) const\n" " ofImage_< unsigned char >::bind() const\n"); lua_error(L);return 0; } -static int _wrap_Image_unbind__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; int arg2 ; - SWIG_check_num_args("ofImage_< unsigned char >::unbind",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::unbind",1,"ofImage_< unsigned char > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::unbind",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_unbind",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } arg2 = (int)lua_tonumber(L, 2); - ((ofImage_< unsigned char > const *)arg1)->unbind(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Image_unbind__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; - SWIG_check_num_args("ofImage_< unsigned char >::unbind",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::unbind",1,"ofImage_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_unbind",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } - ((ofImage_< unsigned char > const *)arg1)->unbind(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_unbind(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Image_unbind__SWIG_1(L);} } if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Image_unbind__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Image_unbind'\n" " Possible C/C++ prototypes are:\n" - " ofImage_< unsigned char >::unbind(int) const\n" " ofImage_< unsigned char >::unbind() const\n"); - lua_error(L);return 0; } -static int _wrap_Image_setCompression(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; ofTexCompression arg2 ; - SWIG_check_num_args("ofImage_< unsigned char >::setCompression",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::setCompression",1,"ofImage_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::setCompression",2,"ofTexCompression"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_setCompression",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } - arg2 = (ofTexCompression)(int)lua_tonumber(L, 2); (arg1)->setCompression(arg2); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Image_getColor__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; int arg2 ; int arg3 ; ofColor_< unsigned char > result; - SWIG_check_num_args("ofImage_< unsigned char >::getColor",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::getColor",1,"ofImage_< unsigned char > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::getColor",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned char >::getColor",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_getColor",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); result = ((ofImage_< unsigned char > const *)arg1)->getColor(arg2,arg3); { - ofColor_< unsigned char > * resultptr = new ofColor_< unsigned char >((const ofColor_< unsigned char > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_getColor__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; int arg2 ; ofColor_< unsigned char > result; - SWIG_check_num_args("ofImage_< unsigned char >::getColor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::getColor",1,"ofImage_< unsigned char > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::getColor",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_getColor",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } arg2 = (int)lua_tonumber(L, 2); - result = ((ofImage_< unsigned char > const *)arg1)->getColor(arg2); { - ofColor_< unsigned char > * resultptr = new ofColor_< unsigned char >((const ofColor_< unsigned char > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_getColor(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Image_getColor__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_Image_getColor__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Image_getColor'\n" " Possible C/C++ prototypes are:\n" - " ofImage_< unsigned char >::getColor(int,int) const\n" " ofImage_< unsigned char >::getColor(int) const\n"); - lua_error(L);return 0; } -static int _wrap_Image_getHeight(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; float result; - SWIG_check_num_args("ofImage_< unsigned char >::getHeight",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::getHeight",1,"ofImage_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_getHeight",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } - result = (float)((ofImage_< unsigned char > const *)arg1)->getHeight(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_getWidth(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; float result; - SWIG_check_num_args("ofImage_< unsigned char >::getWidth",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::getWidth",1,"ofImage_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_getWidth",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } - result = (float)((ofImage_< unsigned char > const *)arg1)->getWidth(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_setColor__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; int arg2 ; int arg3 ; - ofColor_< unsigned char > *arg4 = 0 ; SWIG_check_num_args("ofImage_< unsigned char >::setColor",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::setColor",1,"ofImage_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::setColor",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned char >::setColor",3,"int"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofImage_< unsigned char >::setColor",4,"ofColor_< unsigned char > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_setColor",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_setColor",4,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - (arg1)->setColor(arg2,arg3,(ofColor_< unsigned char > const &)*arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Image_setColor__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; int arg2 ; ofColor_< unsigned char > *arg3 = 0 ; - SWIG_check_num_args("ofImage_< unsigned char >::setColor",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::setColor",1,"ofImage_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::setColor",2,"int"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofImage_< unsigned char >::setColor",3,"ofColor_< unsigned char > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_setColor",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } arg2 = (int)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_setColor",3,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - (arg1)->setColor(arg2,(ofColor_< unsigned char > const &)*arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Image_setColor__SWIG_2(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; ofColor_< unsigned char > *arg2 = 0 ; - SWIG_check_num_args("ofImage_< unsigned char >::setColor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::setColor",1,"ofImage_< unsigned char > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::setColor",2,"ofColor_< unsigned char > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_setColor",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_setColor",2,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - (arg1)->setColor((ofColor_< unsigned char > const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Image_setColor(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Image_setColor__SWIG_2(L);} } } if (argc == 3) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Image_setColor__SWIG_1(L);} } } } if (argc == 4) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Image_setColor__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Image_setColor'\n" " Possible C/C++ prototypes are:\n" - " ofImage_< unsigned char >::setColor(int,int,ofColor_< unsigned char > const &)\n" - " ofImage_< unsigned char >::setColor(int,ofColor_< unsigned char > const &)\n" - " ofImage_< unsigned char >::setColor(ofColor_< unsigned char > const &)\n"); lua_error(L);return 0; } -static int _wrap_Image_setFromPixels__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; unsigned char *arg2 = (unsigned char *) 0 ; int arg3 ; - int arg4 ; ofImageType arg5 ; bool arg6 ; SWIG_check_num_args("ofImage_< unsigned char >::setFromPixels",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::setFromPixels",1,"ofImage_< unsigned char > *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::setFromPixels",2,"unsigned char const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned char >::setFromPixels",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< unsigned char >::setFromPixels",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< unsigned char >::setFromPixels",5,"ofImageType"); - if(!lua_isboolean(L,6)) SWIG_fail_arg("ofImage_< unsigned char >::setFromPixels",6,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_setFromPixels",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_unsigned_char,0))){ - SWIG_fail_ptr("Image_setFromPixels",2,SWIGTYPE_p_unsigned_char); } arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); arg5 = (ofImageType)(int)lua_tonumber(L, 5); arg6 = (lua_toboolean(L, 6)!=0); - (arg1)->setFromPixels((unsigned char const *)arg2,arg3,arg4,arg5,arg6); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Image_setFromPixels__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; unsigned char *arg2 = (unsigned char *) 0 ; int arg3 ; - int arg4 ; ofImageType arg5 ; SWIG_check_num_args("ofImage_< unsigned char >::setFromPixels",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::setFromPixels",1,"ofImage_< unsigned char > *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::setFromPixels",2,"unsigned char const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned char >::setFromPixels",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< unsigned char >::setFromPixels",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< unsigned char >::setFromPixels",5,"ofImageType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_setFromPixels",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_unsigned_char,0))){ - SWIG_fail_ptr("Image_setFromPixels",2,SWIGTYPE_p_unsigned_char); } arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); arg5 = (ofImageType)(int)lua_tonumber(L, 5); - (arg1)->setFromPixels((unsigned char const *)arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Image_setFromPixels__SWIG_2(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; ofPixels_< unsigned char > *arg2 = 0 ; - SWIG_check_num_args("ofImage_< unsigned char >::setFromPixels",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::setFromPixels",1,"ofImage_< unsigned char > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::setFromPixels",2,"ofPixels_< unsigned char > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_setFromPixels",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_setFromPixels",2,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - (arg1)->setFromPixels((ofPixels_< unsigned char > const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Image_setFromPixels(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Image_setFromPixels__SWIG_2(L);} } } if (argc == 5) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_unsigned_char, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_Image_setFromPixels__SWIG_1(L);} } } } } } - if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_unsigned_char, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isboolean(L,argv[5]); } if (_v) { - return _wrap_Image_setFromPixels__SWIG_0(L);} } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Image_setFromPixels'\n" - " Possible C/C++ prototypes are:\n" - " ofImage_< unsigned char >::setFromPixels(unsigned char const *,int,int,ofImageType,bool)\n" - " ofImage_< unsigned char >::setFromPixels(unsigned char const *,int,int,ofImageType)\n" - " ofImage_< unsigned char >::setFromPixels(ofPixels_< unsigned char > const &)\n"); lua_error(L);return 0; } -static int _wrap_Image_grabScreen(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; int arg2 ; int arg3 ; int arg4 ; int arg5 ; - SWIG_check_num_args("ofImage_< unsigned char >::grabScreen",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::grabScreen",1,"ofImage_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::grabScreen",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned char >::grabScreen",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< unsigned char >::grabScreen",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< unsigned char >::grabScreen",5,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_grabScreen",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); - (arg1)->grabScreen(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_setImageType(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; ofImageType arg2 ; - SWIG_check_num_args("ofImage_< unsigned char >::setImageType",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::setImageType",1,"ofImage_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::setImageType",2,"ofImageType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_setImageType",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } arg2 = (ofImageType)(int)lua_tonumber(L, 2); - (arg1)->setImageType(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_getImageType(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; ofImageType result; - SWIG_check_num_args("ofImage_< unsigned char >::getImageType",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::getImageType",1,"ofImage_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_getImageType",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } - result = (ofImageType)((ofImage_< unsigned char > const *)arg1)->getImageType(); - lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Image_resize(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; int arg2 ; int arg3 ; - SWIG_check_num_args("ofImage_< unsigned char >::resize",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::resize",1,"ofImage_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::resize",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned char >::resize",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_resize",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); (arg1)->resize(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Image_crop(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; int arg2 ; int arg3 ; int arg4 ; int arg5 ; - SWIG_check_num_args("ofImage_< unsigned char >::crop",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::crop",1,"ofImage_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::crop",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned char >::crop",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< unsigned char >::crop",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< unsigned char >::crop",5,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_crop",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); - (arg1)->crop(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_cropFrom(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; ofImage_< unsigned char > *arg2 = 0 ; int arg3 ; - int arg4 ; int arg5 ; int arg6 ; SWIG_check_num_args("ofImage_< unsigned char >::cropFrom",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::cropFrom",1,"ofImage_< unsigned char > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::cropFrom",2,"ofImage_< unsigned char > &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned char >::cropFrom",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< unsigned char >::cropFrom",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< unsigned char >::cropFrom",5,"int"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofImage_< unsigned char >::cropFrom",6,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_cropFrom",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_cropFrom",2,SWIGTYPE_p_ofImage_T_unsigned_char_t); } arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); arg6 = (int)lua_tonumber(L, 6); - (arg1)->cropFrom(*arg2,arg3,arg4,arg5,arg6); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_rotate90(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; int arg2 ; - SWIG_check_num_args("ofImage_< unsigned char >::rotate90",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::rotate90",1,"ofImage_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::rotate90",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_rotate90",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->rotate90(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_mirror(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; bool arg2 ; bool arg3 ; - SWIG_check_num_args("ofImage_< unsigned char >::mirror",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::mirror",1,"ofImage_< unsigned char > *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::mirror",2,"bool"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofImage_< unsigned char >::mirror",3,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_mirror",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } arg2 = (lua_toboolean(L, 2)!=0); - arg3 = (lua_toboolean(L, 3)!=0); (arg1)->mirror(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Image_setAnchorPercent(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofImage_< unsigned char >::setAnchorPercent",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::setAnchorPercent",1,"ofImage_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::setAnchorPercent",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned char >::setAnchorPercent",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_setAnchorPercent",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->setAnchorPercent(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Image_setAnchorPoint(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofImage_< unsigned char >::setAnchorPoint",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::setAnchorPoint",1,"ofImage_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::setAnchorPoint",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned char >::setAnchorPoint",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_setAnchorPoint",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->setAnchorPoint(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Image_resetAnchor(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; - SWIG_check_num_args("ofImage_< unsigned char >::resetAnchor",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::resetAnchor",1,"ofImage_< unsigned char > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_resetAnchor",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } (arg1)->resetAnchor(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_save__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; std::string arg2 ; ofImageQualityType arg3 ; - SWIG_check_num_args("ofImage_< unsigned char >::save",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::save",1,"ofImage_< unsigned char > *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::save",2,"std::string"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned char >::save",3,"ofImageQualityType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_save",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } (&arg2)->assign(lua_tostring(L,2),lua_rawlen(L,2)); - arg3 = (ofImageQualityType)(int)lua_tonumber(L, 3); (arg1)->save(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Image_save__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; std::string arg2 ; - SWIG_check_num_args("ofImage_< unsigned char >::save",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::save",1,"ofImage_< unsigned char > *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::save",2,"std::string"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_save",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } (&arg2)->assign(lua_tostring(L,2),lua_rawlen(L,2)); - (arg1)->save(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_save__SWIG_2(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; ofBuffer *arg2 = 0 ; ofImageQualityType arg3 ; - SWIG_check_num_args("ofImage_< unsigned char >::save",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::save",1,"ofImage_< unsigned char > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::save",2,"ofBuffer &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned char >::save",3,"ofImageQualityType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_save",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBuffer,0))){ SWIG_fail_ptr("Image_save",2,SWIGTYPE_p_ofBuffer); } - arg3 = (ofImageQualityType)(int)lua_tonumber(L, 3); (arg1)->save(*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Image_save__SWIG_3(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; ofBuffer *arg2 = 0 ; - SWIG_check_num_args("ofImage_< unsigned char >::save",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::save",1,"ofImage_< unsigned char > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::save",2,"ofBuffer &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_save",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBuffer,0))){ SWIG_fail_ptr("Image_save",2,SWIGTYPE_p_ofBuffer); } - (arg1)->save(*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_save__SWIG_4(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; ofFile *arg2 = 0 ; ofImageQualityType arg3 ; - SWIG_check_num_args("ofImage_< unsigned char >::save",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::save",1,"ofImage_< unsigned char > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::save",2,"ofFile const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned char >::save",3,"ofImageQualityType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_save",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("Image_save",2,SWIGTYPE_p_ofFile); } - arg3 = (ofImageQualityType)(int)lua_tonumber(L, 3); (arg1)->save((ofFile const &)*arg2,arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_save__SWIG_5(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; ofFile *arg2 = 0 ; - SWIG_check_num_args("ofImage_< unsigned char >::save",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::save",1,"ofImage_< unsigned char > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::save",2,"ofFile const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_save",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("Image_save",2,SWIGTYPE_p_ofFile); } - (arg1)->save((ofFile const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_save(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBuffer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Image_save__SWIG_3(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Image_save__SWIG_5(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { - return _wrap_Image_save__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Image_save__SWIG_4(L);} } } - } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBuffer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Image_save__SWIG_2(L);} } } - } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_Image_save__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Image_save'\n" " Possible C/C++ prototypes are:\n" - " ofImage_< unsigned char >::save(std::string,ofImageQualityType)\n" " ofImage_< unsigned char >::save(std::string)\n" - " ofImage_< unsigned char >::save(ofBuffer &,ofImageQualityType)\n" " ofImage_< unsigned char >::save(ofBuffer &)\n" - " ofImage_< unsigned char >::save(ofFile const &,ofImageQualityType)\n" - " ofImage_< unsigned char >::save(ofFile const &)\n"); lua_error(L);return 0; } -static void swig_delete_Image(void *obj) { -ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) obj; -delete arg1; -} -static int _proxy__wrap_new_Image(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_Image); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_Image_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_Image_methods[]= { - { "allocate", _wrap_Image_allocate}, - { "isAllocated", _wrap_Image_isAllocated}, - { "clear", _wrap_Image_clear}, - { "load", _wrap_Image_load}, - { "draw", _wrap_Image_draw}, - { "drawSubsection", _wrap_Image_drawSubsection}, - { "update", _wrap_Image_update}, - { "setUseTexture", _wrap_Image_setUseTexture}, - { "isUsingTexture", _wrap_Image_isUsingTexture}, - { "getTexture", _wrap_Image_getTexture}, - { "bind", _wrap_Image_bind}, - { "unbind", _wrap_Image_unbind}, - { "setCompression", _wrap_Image_setCompression}, - { "getColor", _wrap_Image_getColor}, - { "getHeight", _wrap_Image_getHeight}, - { "getWidth", _wrap_Image_getWidth}, - { "setColor", _wrap_Image_setColor}, - { "setFromPixels", _wrap_Image_setFromPixels}, - { "grabScreen", _wrap_Image_grabScreen}, - { "setImageType", _wrap_Image_setImageType}, - { "getImageType", _wrap_Image_getImageType}, - { "resize", _wrap_Image_resize}, - { "crop", _wrap_Image_crop}, - { "cropFrom", _wrap_Image_cropFrom}, - { "rotate90", _wrap_Image_rotate90}, - { "mirror", _wrap_Image_mirror}, - { "setAnchorPercent", _wrap_Image_setAnchorPercent}, - { "setAnchorPoint", _wrap_Image_setAnchorPoint}, - { "resetAnchor", _wrap_Image_resetAnchor}, - { "save", _wrap_Image_save}, - {0,0} -}; -static swig_lua_method swig_Image_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_Image_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_Image_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_Image_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_Image_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_Image_Sf_SwigStatic = { - "Image", - swig_Image_Sf_SwigStatic_methods, - swig_Image_Sf_SwigStatic_attributes, - swig_Image_Sf_SwigStatic_constants, - swig_Image_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_Image_bases[] = {0}; -static const char *swig_Image_base_names[] = {0}; -static swig_lua_class _wrap_class_Image = { "Image", "Image", &SWIGTYPE_p_ofImage_T_unsigned_char_t,_proxy__wrap_new_Image, swig_delete_Image, swig_Image_methods, swig_Image_attributes, &swig_Image_Sf_SwigStatic, swig_Image_meta, swig_Image_bases, swig_Image_base_names }; - -static int _wrap_new_FloatImage__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *result = 0 ; - SWIG_check_num_args("ofImage_< float >::ofImage_",0,0) result = (ofImage_< float > *)new ofImage_< float >(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofImage_T_float_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_FloatImage__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPixels_< float > *arg1 = 0 ; - ofImage_< float > *result = 0 ; SWIG_check_num_args("ofImage_< float >::ofImage_",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofImage_< float >::ofImage_",1,"ofPixels_< float > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("new_FloatImage",1,SWIGTYPE_p_ofPixels_T_float_t); } - result = (ofImage_< float > *)new ofImage_< float >((ofPixels_< float > const &)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofImage_T_float_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_FloatImage__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = 0 ; ofImage_< float > *result = 0 ; - SWIG_check_num_args("ofImage_< float >::ofImage_",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofImage_< float >::ofImage_",1,"ofFile const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("new_FloatImage",1,SWIGTYPE_p_ofFile); } - result = (ofImage_< float > *)new ofImage_< float >((ofFile const &)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofImage_T_float_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_FloatImage__SWIG_3(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - ofImage_< float > *result = 0 ; SWIG_check_num_args("ofImage_< float >::ofImage_",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofImage_< float >::ofImage_",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; - result = (ofImage_< float > *)new ofImage_< float >((std::string const &)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofImage_T_float_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_FloatImage__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = 0 ; - ofImage_< float > *result = 0 ; SWIG_check_num_args("ofImage_< float >::ofImage_",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofImage_< float >::ofImage_",1,"ofImage_< float > &&"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("new_FloatImage",1,SWIGTYPE_p_ofImage_T_float_t); } - result = (ofImage_< float > *)new ofImage_< float >((ofImage_< float > &&)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofImage_T_float_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_FloatImage(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_FloatImage__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_new_FloatImage__SWIG_1(L);} } if (argc == 1) { int _v; { - void *ptr; if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_new_FloatImage__SWIG_2(L);} } if (argc == 1) { int _v; { - void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_new_FloatImage__SWIG_4(L);} } if (argc == 1) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { return _wrap_new_FloatImage__SWIG_3(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_FloatImage'\n" " Possible C/C++ prototypes are:\n" - " ofImage_< float >::ofImage_()\n" " ofImage_< float >::ofImage_(ofPixels_< float > const &)\n" - " ofImage_< float >::ofImage_(ofFile const &)\n" " ofImage_< float >::ofImage_(std::string const &)\n" - " ofImage_< float >::ofImage_(ofImage_< float > &&)\n"); lua_error(L);return 0; } -static int _wrap_FloatImage_allocate(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - int arg2 ; int arg3 ; ofImageType arg4 ; SWIG_check_num_args("ofImage_< float >::allocate",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::allocate",1,"ofImage_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< float >::allocate",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< float >::allocate",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< float >::allocate",4,"ofImageType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_allocate",1,SWIGTYPE_p_ofImage_T_float_t); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); arg4 = (ofImageType)(int)lua_tonumber(L, 4); (arg1)->allocate(arg2,arg3,arg4); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_isAllocated(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - bool result; SWIG_check_num_args("ofImage_< float >::isAllocated",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::isAllocated",1,"ofImage_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_isAllocated",1,SWIGTYPE_p_ofImage_T_float_t); } - result = (bool)((ofImage_< float > const *)arg1)->isAllocated(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_clear(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - SWIG_check_num_args("ofImage_< float >::clear",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::clear",1,"ofImage_< float > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_clear",1,SWIGTYPE_p_ofImage_T_float_t); } (arg1)->clear(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_load__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - std::string *arg2 = 0 ; std::string temp2 ; bool result; SWIG_check_num_args("ofImage_< float >::load",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::load",1,"ofImage_< float > *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofImage_< float >::load",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_load",1,SWIGTYPE_p_ofImage_T_float_t); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; result = (bool)(arg1)->load((std::string const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_load__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - ofBuffer *arg2 = 0 ; bool result; SWIG_check_num_args("ofImage_< float >::load",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::load",1,"ofImage_< float > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofImage_< float >::load",2,"ofBuffer const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_load",1,SWIGTYPE_p_ofImage_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBuffer,0))){ - SWIG_fail_ptr("FloatImage_load",2,SWIGTYPE_p_ofBuffer); } result = (bool)(arg1)->load((ofBuffer const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_load__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - ofFile *arg2 = 0 ; bool result; SWIG_check_num_args("ofImage_< float >::load",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::load",1,"ofImage_< float > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofImage_< float >::load",2,"ofFile const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_load",1,SWIGTYPE_p_ofImage_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofFile,0))){ - SWIG_fail_ptr("FloatImage_load",2,SWIGTYPE_p_ofFile); } result = (bool)(arg1)->load((ofFile const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_load(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v; - { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBuffer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_FloatImage_load__SWIG_1(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_FloatImage_load__SWIG_2(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { - return _wrap_FloatImage_load__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatImage_load'\n" " Possible C/C++ prototypes are:\n" - " ofImage_< float >::load(std::string const &)\n" " ofImage_< float >::load(ofBuffer const &)\n" - " ofImage_< float >::load(ofFile const &)\n"); lua_error(L);return 0; } -static int _wrap_FloatImage_draw__SWIG_0_0(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - ofPoint *arg2 = 0 ; SWIG_check_num_args("draw",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("draw",1,"ofImage_< float > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("draw",2,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_draw",1,SWIGTYPE_p_ofImage_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("FloatImage_draw",2,SWIGTYPE_p_ofVec3f); } ((ofImage_< float > const *)arg1)->draw((ofPoint const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_draw__SWIG_0_1(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - ofRectangle *arg2 = 0 ; SWIG_check_num_args("draw",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("draw",1,"ofImage_< float > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("draw",2,"ofRectangle const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_draw",1,SWIGTYPE_p_ofImage_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("FloatImage_draw",2,SWIGTYPE_p_ofRectangle); } - ((ofImage_< float > const *)arg1)->draw((ofRectangle const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FloatImage_draw__SWIG_0_2(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - ofPoint *arg2 = 0 ; float arg3 ; float arg4 ; SWIG_check_num_args("draw",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("draw",1,"ofImage_< float > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("draw",2,"ofPoint const &"); if(!lua_isnumber(L,3)) SWIG_fail_arg("draw",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("draw",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_draw",1,SWIGTYPE_p_ofImage_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("FloatImage_draw",2,SWIGTYPE_p_ofVec3f); } arg3 = (float)lua_tonumber(L, 3); - arg4 = (float)lua_tonumber(L, 4); ((ofImage_< float > const *)arg1)->draw((ofPoint const &)*arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_draw__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - float arg2 ; float arg3 ; SWIG_check_num_args("ofImage_< float >::draw",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::draw",1,"ofImage_< float > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< float >::draw",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< float >::draw",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_draw",1,SWIGTYPE_p_ofImage_T_float_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); ((ofImage_< float > const *)arg1)->draw(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_draw__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - float arg2 ; float arg3 ; float arg4 ; SWIG_check_num_args("ofImage_< float >::draw",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::draw",1,"ofImage_< float > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< float >::draw",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< float >::draw",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< float >::draw",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_draw",1,SWIGTYPE_p_ofImage_T_float_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); ((ofImage_< float > const *)arg1)->draw(arg2,arg3,arg4); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_draw__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - float arg2 ; float arg3 ; float arg4 ; float arg5 ; SWIG_check_num_args("ofImage_< float >::draw",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::draw",1,"ofImage_< float > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< float >::draw",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< float >::draw",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< float >::draw",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< float >::draw",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_draw",1,SWIGTYPE_p_ofImage_T_float_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - ((ofImage_< float > const *)arg1)->draw(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FloatImage_draw__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - float arg2 ; float arg3 ; float arg4 ; float arg5 ; float arg6 ; SWIG_check_num_args("ofImage_< float >::draw",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::draw",1,"ofImage_< float > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< float >::draw",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< float >::draw",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< float >::draw",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< float >::draw",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofImage_< float >::draw",6,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_draw",1,SWIGTYPE_p_ofImage_T_float_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); ((ofImage_< float > const *)arg1)->draw(arg2,arg3,arg4,arg5,arg6); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_draw(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_FloatImage_draw__SWIG_0_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_FloatImage_draw__SWIG_0_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_FloatImage_draw__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_FloatImage_draw__SWIG_0_2(L);} } } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_FloatImage_draw__SWIG_2(L);} } } } } - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_FloatImage_draw__SWIG_3(L);} } } } } } if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { return _wrap_FloatImage_draw__SWIG_4(L);} } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatImage_draw'\n" " Possible C/C++ prototypes are:\n" - " draw(ofPoint const &) const\n" " draw(ofRectangle const &) const\n" " draw(ofPoint const &,float,float) const\n" - " ofImage_< float >::draw(float,float) const\n" " ofImage_< float >::draw(float,float,float) const\n" - " ofImage_< float >::draw(float,float,float,float) const\n" - " ofImage_< float >::draw(float,float,float,float,float) const\n"); lua_error(L);return 0; } -static int _wrap_FloatImage_drawSubsection__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; float arg2 ; float arg3 ; float arg4 ; float arg5 ; float arg6 ; - float arg7 ; SWIG_check_num_args("ofImage_< float >::drawSubsection",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::drawSubsection",1,"ofImage_< float > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< float >::drawSubsection",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< float >::drawSubsection",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< float >::drawSubsection",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< float >::drawSubsection",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofImage_< float >::drawSubsection",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofImage_< float >::drawSubsection",7,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_drawSubsection",1,SWIGTYPE_p_ofImage_T_float_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); - ((ofImage_< float > const *)arg1)->drawSubsection(arg2,arg3,arg4,arg5,arg6,arg7); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_drawSubsection__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; float arg2 ; float arg3 ; float arg4 ; float arg5 ; float arg6 ; - float arg7 ; float arg8 ; SWIG_check_num_args("ofImage_< float >::drawSubsection",8,8) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::drawSubsection",1,"ofImage_< float > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< float >::drawSubsection",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< float >::drawSubsection",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< float >::drawSubsection",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< float >::drawSubsection",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofImage_< float >::drawSubsection",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofImage_< float >::drawSubsection",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofImage_< float >::drawSubsection",8,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_drawSubsection",1,SWIGTYPE_p_ofImage_T_float_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (float)lua_tonumber(L, 8); - ((ofImage_< float > const *)arg1)->drawSubsection(arg2,arg3,arg4,arg5,arg6,arg7,arg8); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_drawSubsection__SWIG_2(lua_State* L) { int SWIG_arg = 0; - ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; float arg2 ; float arg3 ; float arg4 ; float arg5 ; float arg6 ; - float arg7 ; float arg8 ; float arg9 ; SWIG_check_num_args("ofImage_< float >::drawSubsection",9,9) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::drawSubsection",1,"ofImage_< float > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< float >::drawSubsection",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< float >::drawSubsection",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< float >::drawSubsection",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< float >::drawSubsection",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofImage_< float >::drawSubsection",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofImage_< float >::drawSubsection",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofImage_< float >::drawSubsection",8,"float"); - if(!lua_isnumber(L,9)) SWIG_fail_arg("ofImage_< float >::drawSubsection",9,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_drawSubsection",1,SWIGTYPE_p_ofImage_T_float_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (float)lua_tonumber(L, 8); - arg9 = (float)lua_tonumber(L, 9); ((ofImage_< float > const *)arg1)->drawSubsection(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_drawSubsection__SWIG_3(lua_State* L) { int SWIG_arg = 0; - ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; float arg2 ; float arg3 ; float arg4 ; float arg5 ; float arg6 ; - float arg7 ; float arg8 ; float arg9 ; float arg10 ; SWIG_check_num_args("ofImage_< float >::drawSubsection",10,10) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::drawSubsection",1,"ofImage_< float > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< float >::drawSubsection",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< float >::drawSubsection",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< float >::drawSubsection",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< float >::drawSubsection",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofImage_< float >::drawSubsection",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofImage_< float >::drawSubsection",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofImage_< float >::drawSubsection",8,"float"); - if(!lua_isnumber(L,9)) SWIG_fail_arg("ofImage_< float >::drawSubsection",9,"float"); - if(!lua_isnumber(L,10)) SWIG_fail_arg("ofImage_< float >::drawSubsection",10,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_drawSubsection",1,SWIGTYPE_p_ofImage_T_float_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (float)lua_tonumber(L, 8); - arg9 = (float)lua_tonumber(L, 9); arg10 = (float)lua_tonumber(L, 10); - ((ofImage_< float > const *)arg1)->drawSubsection(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_drawSubsection(lua_State* L) { int argc; int argv[11]={ 1,2,3,4,5,6,7,8,9,10,11} ; - argc = lua_gettop(L); if (argc == 7) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { - return _wrap_FloatImage_drawSubsection__SWIG_0(L);} } } } } } } } if (argc == 8) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { return _wrap_FloatImage_drawSubsection__SWIG_1(L);} } } } } } - } } } if (argc == 9) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { { _v = lua_isnumber(L,argv[8]); } if (_v) { - return _wrap_FloatImage_drawSubsection__SWIG_2(L);} } } } } } } } } } if (argc == 10) { int _v; - { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { { _v = lua_isnumber(L,argv[8]); } if (_v) { { - _v = lua_isnumber(L,argv[9]); } if (_v) { return _wrap_FloatImage_drawSubsection__SWIG_3(L);} } } } - } } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatImage_drawSubsection'\n" - " Possible C/C++ prototypes are:\n" " ofImage_< float >::drawSubsection(float,float,float,float,float,float) const\n" - " ofImage_< float >::drawSubsection(float,float,float,float,float,float,float) const\n" - " ofImage_< float >::drawSubsection(float,float,float,float,float,float,float,float) const\n" - " ofImage_< float >::drawSubsection(float,float,float,float,float,float,float,float,float) const\n"); - lua_error(L);return 0; } -static int _wrap_FloatImage_update(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - SWIG_check_num_args("ofImage_< float >::update",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::update",1,"ofImage_< float > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_update",1,SWIGTYPE_p_ofImage_T_float_t); } (arg1)->update(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_setUseTexture(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - bool arg2 ; SWIG_check_num_args("ofImage_< float >::setUseTexture",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::setUseTexture",1,"ofImage_< float > *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofImage_< float >::setUseTexture",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_setUseTexture",1,SWIGTYPE_p_ofImage_T_float_t); } arg2 = (lua_toboolean(L, 2)!=0); - (arg1)->setUseTexture(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_isUsingTexture(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - bool result; SWIG_check_num_args("ofImage_< float >::isUsingTexture",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::isUsingTexture",1,"ofImage_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_isUsingTexture",1,SWIGTYPE_p_ofImage_T_float_t); } - result = (bool)((ofImage_< float > const *)arg1)->isUsingTexture(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_getTexture__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; ofTexture *result = 0 ; - SWIG_check_num_args("ofImage_< float >::getTexture",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::getTexture",1,"ofImage_< float > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_getTexture",1,SWIGTYPE_p_ofImage_T_float_t); } result = (ofTexture *) &(arg1)->getTexture(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTexture,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FloatImage_getTexture__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; ofTexture *result = 0 ; - SWIG_check_num_args("ofImage_< float >::getTexture",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::getTexture",1,"ofImage_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_getTexture",1,SWIGTYPE_p_ofImage_T_float_t); } - result = (ofTexture *) &((ofImage_< float > const *)arg1)->getTexture(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTexture,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FloatImage_getTexture(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_FloatImage_getTexture__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_FloatImage_getTexture__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatImage_getTexture'\n" - " Possible C/C++ prototypes are:\n" " ofImage_< float >::getTexture()\n" " ofImage_< float >::getTexture() const\n"); - lua_error(L);return 0; } -static int _wrap_FloatImage_bind__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - int arg2 ; SWIG_check_num_args("ofImage_< float >::bind",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::bind",1,"ofImage_< float > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< float >::bind",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_bind",1,SWIGTYPE_p_ofImage_T_float_t); } arg2 = (int)lua_tonumber(L, 2); - ((ofImage_< float > const *)arg1)->bind(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_bind__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - SWIG_check_num_args("ofImage_< float >::bind",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::bind",1,"ofImage_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_bind",1,SWIGTYPE_p_ofImage_T_float_t); } ((ofImage_< float > const *)arg1)->bind(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_bind(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; - { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_FloatImage_bind__SWIG_1(L);} } if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_FloatImage_bind__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatImage_bind'\n" " Possible C/C++ prototypes are:\n" - " ofImage_< float >::bind(int) const\n" " ofImage_< float >::bind() const\n"); lua_error(L);return 0; } -static int _wrap_FloatImage_unbind__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - int arg2 ; SWIG_check_num_args("ofImage_< float >::unbind",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::unbind",1,"ofImage_< float > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< float >::unbind",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_unbind",1,SWIGTYPE_p_ofImage_T_float_t); } arg2 = (int)lua_tonumber(L, 2); - ((ofImage_< float > const *)arg1)->unbind(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_unbind__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - SWIG_check_num_args("ofImage_< float >::unbind",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::unbind",1,"ofImage_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_unbind",1,SWIGTYPE_p_ofImage_T_float_t); } ((ofImage_< float > const *)arg1)->unbind(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_unbind(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_FloatImage_unbind__SWIG_1(L);} } if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_FloatImage_unbind__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatImage_unbind'\n" " Possible C/C++ prototypes are:\n" - " ofImage_< float >::unbind(int) const\n" " ofImage_< float >::unbind() const\n"); lua_error(L);return 0; } -static int _wrap_FloatImage_setCompression(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - ofTexCompression arg2 ; SWIG_check_num_args("ofImage_< float >::setCompression",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::setCompression",1,"ofImage_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< float >::setCompression",2,"ofTexCompression"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_setCompression",1,SWIGTYPE_p_ofImage_T_float_t); } - arg2 = (ofTexCompression)(int)lua_tonumber(L, 2); (arg1)->setCompression(arg2); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_getColor__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; int arg2 ; int arg3 ; ofColor_< float > result; - SWIG_check_num_args("ofImage_< float >::getColor",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::getColor",1,"ofImage_< float > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< float >::getColor",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< float >::getColor",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_getColor",1,SWIGTYPE_p_ofImage_T_float_t); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); result = ((ofImage_< float > const *)arg1)->getColor(arg2,arg3); { - ofColor_< float > * resultptr = new ofColor_< float >((const ofColor_< float > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_getColor__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; int arg2 ; ofColor_< float > result; - SWIG_check_num_args("ofImage_< float >::getColor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::getColor",1,"ofImage_< float > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< float >::getColor",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_getColor",1,SWIGTYPE_p_ofImage_T_float_t); } arg2 = (int)lua_tonumber(L, 2); - result = ((ofImage_< float > const *)arg1)->getColor(arg2); { - ofColor_< float > * resultptr = new ofColor_< float >((const ofColor_< float > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_getColor(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_FloatImage_getColor__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_FloatImage_getColor__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatImage_getColor'\n" - " Possible C/C++ prototypes are:\n" " ofImage_< float >::getColor(int,int) const\n" - " ofImage_< float >::getColor(int) const\n"); lua_error(L);return 0; } -static int _wrap_FloatImage_getHeight(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - float result; SWIG_check_num_args("ofImage_< float >::getHeight",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::getHeight",1,"ofImage_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_getHeight",1,SWIGTYPE_p_ofImage_T_float_t); } - result = (float)((ofImage_< float > const *)arg1)->getHeight(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_getWidth(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - float result; SWIG_check_num_args("ofImage_< float >::getWidth",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::getWidth",1,"ofImage_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_getWidth",1,SWIGTYPE_p_ofImage_T_float_t); } - result = (float)((ofImage_< float > const *)arg1)->getWidth(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_setColor__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; int arg2 ; int arg3 ; ofColor_< float > *arg4 = 0 ; - SWIG_check_num_args("ofImage_< float >::setColor",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::setColor",1,"ofImage_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< float >::setColor",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< float >::setColor",3,"int"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofImage_< float >::setColor",4,"ofColor_< float > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_setColor",1,SWIGTYPE_p_ofImage_T_float_t); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_setColor",4,SWIGTYPE_p_ofColor_T_float_t); } - (arg1)->setColor(arg2,arg3,(ofColor_< float > const &)*arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FloatImage_setColor__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; int arg2 ; ofColor_< float > *arg3 = 0 ; - SWIG_check_num_args("ofImage_< float >::setColor",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::setColor",1,"ofImage_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< float >::setColor",2,"int"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofImage_< float >::setColor",3,"ofColor_< float > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_setColor",1,SWIGTYPE_p_ofImage_T_float_t); } arg2 = (int)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_setColor",3,SWIGTYPE_p_ofColor_T_float_t); } - (arg1)->setColor(arg2,(ofColor_< float > const &)*arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FloatImage_setColor__SWIG_2(lua_State* L) { int SWIG_arg = 0; - ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; ofColor_< float > *arg2 = 0 ; - SWIG_check_num_args("ofImage_< float >::setColor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::setColor",1,"ofImage_< float > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofImage_< float >::setColor",2,"ofColor_< float > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_setColor",1,SWIGTYPE_p_ofImage_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_setColor",2,SWIGTYPE_p_ofColor_T_float_t); } (arg1)->setColor((ofColor_< float > const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_setColor(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_FloatImage_setColor__SWIG_2(L);} } } if (argc == 3) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_FloatImage_setColor__SWIG_1(L);} } } } if (argc == 4) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_FloatImage_setColor__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatImage_setColor'\n" - " Possible C/C++ prototypes are:\n" " ofImage_< float >::setColor(int,int,ofColor_< float > const &)\n" - " ofImage_< float >::setColor(int,ofColor_< float > const &)\n" - " ofImage_< float >::setColor(ofColor_< float > const &)\n"); lua_error(L);return 0; } -static int _wrap_FloatImage_setFromPixels__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; float *arg2 = (float *) 0 ; int arg3 ; int arg4 ; ofImageType arg5 ; - bool arg6 ; SWIG_check_num_args("ofImage_< float >::setFromPixels",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::setFromPixels",1,"ofImage_< float > *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofImage_< float >::setFromPixels",2,"float const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< float >::setFromPixels",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< float >::setFromPixels",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< float >::setFromPixels",5,"ofImageType"); - if(!lua_isboolean(L,6)) SWIG_fail_arg("ofImage_< float >::setFromPixels",6,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_setFromPixels",1,SWIGTYPE_p_ofImage_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("FloatImage_setFromPixels",2,SWIGTYPE_p_float); } arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); arg5 = (ofImageType)(int)lua_tonumber(L, 5); arg6 = (lua_toboolean(L, 6)!=0); - (arg1)->setFromPixels((float const *)arg2,arg3,arg4,arg5,arg6); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FloatImage_setFromPixels__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; float *arg2 = (float *) 0 ; int arg3 ; int arg4 ; ofImageType arg5 ; - SWIG_check_num_args("ofImage_< float >::setFromPixels",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::setFromPixels",1,"ofImage_< float > *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofImage_< float >::setFromPixels",2,"float const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< float >::setFromPixels",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< float >::setFromPixels",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< float >::setFromPixels",5,"ofImageType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_setFromPixels",1,SWIGTYPE_p_ofImage_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("FloatImage_setFromPixels",2,SWIGTYPE_p_float); } arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); arg5 = (ofImageType)(int)lua_tonumber(L, 5); - (arg1)->setFromPixels((float const *)arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FloatImage_setFromPixels__SWIG_2(lua_State* L) { int SWIG_arg = 0; - ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; ofPixels_< float > *arg2 = 0 ; - SWIG_check_num_args("ofImage_< float >::setFromPixels",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::setFromPixels",1,"ofImage_< float > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofImage_< float >::setFromPixels",2,"ofPixels_< float > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_setFromPixels",1,SWIGTYPE_p_ofImage_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_setFromPixels",2,SWIGTYPE_p_ofPixels_T_float_t); } - (arg1)->setFromPixels((ofPixels_< float > const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FloatImage_setFromPixels(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_FloatImage_setFromPixels__SWIG_2(L);} } } if (argc == 5) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_FloatImage_setFromPixels__SWIG_1(L);} } } } } } - if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isboolean(L,argv[5]); } if (_v) { - return _wrap_FloatImage_setFromPixels__SWIG_0(L);} } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatImage_setFromPixels'\n" - " Possible C/C++ prototypes are:\n" " ofImage_< float >::setFromPixels(float const *,int,int,ofImageType,bool)\n" - " ofImage_< float >::setFromPixels(float const *,int,int,ofImageType)\n" - " ofImage_< float >::setFromPixels(ofPixels_< float > const &)\n"); lua_error(L);return 0; } -static int _wrap_FloatImage_grabScreen(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - int arg2 ; int arg3 ; int arg4 ; int arg5 ; SWIG_check_num_args("ofImage_< float >::grabScreen",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::grabScreen",1,"ofImage_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< float >::grabScreen",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< float >::grabScreen",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< float >::grabScreen",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< float >::grabScreen",5,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_grabScreen",1,SWIGTYPE_p_ofImage_T_float_t); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); - (arg1)->grabScreen(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_setImageType(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - ofImageType arg2 ; SWIG_check_num_args("ofImage_< float >::setImageType",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::setImageType",1,"ofImage_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< float >::setImageType",2,"ofImageType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_setImageType",1,SWIGTYPE_p_ofImage_T_float_t); } arg2 = (ofImageType)(int)lua_tonumber(L, 2); - (arg1)->setImageType(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_getImageType(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - ofImageType result; SWIG_check_num_args("ofImage_< float >::getImageType",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::getImageType",1,"ofImage_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_getImageType",1,SWIGTYPE_p_ofImage_T_float_t); } - result = (ofImageType)((ofImage_< float > const *)arg1)->getImageType(); - lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FloatImage_resize(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - int arg2 ; int arg3 ; SWIG_check_num_args("ofImage_< float >::resize",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::resize",1,"ofImage_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< float >::resize",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< float >::resize",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_resize",1,SWIGTYPE_p_ofImage_T_float_t); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); (arg1)->resize(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FloatImage_crop(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - int arg2 ; int arg3 ; int arg4 ; int arg5 ; SWIG_check_num_args("ofImage_< float >::crop",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::crop",1,"ofImage_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< float >::crop",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< float >::crop",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< float >::crop",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< float >::crop",5,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_crop",1,SWIGTYPE_p_ofImage_T_float_t); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); - (arg1)->crop(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_cropFrom(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - ofImage_< float > *arg2 = 0 ; int arg3 ; int arg4 ; int arg5 ; int arg6 ; - SWIG_check_num_args("ofImage_< float >::cropFrom",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::cropFrom",1,"ofImage_< float > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofImage_< float >::cropFrom",2,"ofImage_< float > &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< float >::cropFrom",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< float >::cropFrom",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< float >::cropFrom",5,"int"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofImage_< float >::cropFrom",6,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_cropFrom",1,SWIGTYPE_p_ofImage_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_cropFrom",2,SWIGTYPE_p_ofImage_T_float_t); } arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); arg6 = (int)lua_tonumber(L, 6); - (arg1)->cropFrom(*arg2,arg3,arg4,arg5,arg6); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_rotate90(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - int arg2 ; SWIG_check_num_args("ofImage_< float >::rotate90",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::rotate90",1,"ofImage_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< float >::rotate90",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_rotate90",1,SWIGTYPE_p_ofImage_T_float_t); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->rotate90(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_mirror(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - bool arg2 ; bool arg3 ; SWIG_check_num_args("ofImage_< float >::mirror",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::mirror",1,"ofImage_< float > *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofImage_< float >::mirror",2,"bool"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofImage_< float >::mirror",3,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_mirror",1,SWIGTYPE_p_ofImage_T_float_t); } arg2 = (lua_toboolean(L, 2)!=0); - arg3 = (lua_toboolean(L, 3)!=0); (arg1)->mirror(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FloatImage_setAnchorPercent(lua_State* L) { int SWIG_arg = 0; - ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofImage_< float >::setAnchorPercent",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::setAnchorPercent",1,"ofImage_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< float >::setAnchorPercent",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< float >::setAnchorPercent",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_setAnchorPercent",1,SWIGTYPE_p_ofImage_T_float_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->setAnchorPercent(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FloatImage_setAnchorPoint(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - float arg2 ; float arg3 ; SWIG_check_num_args("ofImage_< float >::setAnchorPoint",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::setAnchorPoint",1,"ofImage_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< float >::setAnchorPoint",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< float >::setAnchorPoint",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_setAnchorPoint",1,SWIGTYPE_p_ofImage_T_float_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->setAnchorPoint(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FloatImage_resetAnchor(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - SWIG_check_num_args("ofImage_< float >::resetAnchor",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::resetAnchor",1,"ofImage_< float > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_resetAnchor",1,SWIGTYPE_p_ofImage_T_float_t); } (arg1)->resetAnchor(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_save__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - std::string arg2 ; ofImageQualityType arg3 ; SWIG_check_num_args("ofImage_< float >::save",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::save",1,"ofImage_< float > *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofImage_< float >::save",2,"std::string"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< float >::save",3,"ofImageQualityType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_save",1,SWIGTYPE_p_ofImage_T_float_t); } (&arg2)->assign(lua_tostring(L,2),lua_rawlen(L,2)); - arg3 = (ofImageQualityType)(int)lua_tonumber(L, 3); (arg1)->save(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_save__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - std::string arg2 ; SWIG_check_num_args("ofImage_< float >::save",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::save",1,"ofImage_< float > *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofImage_< float >::save",2,"std::string"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_save",1,SWIGTYPE_p_ofImage_T_float_t); } (&arg2)->assign(lua_tostring(L,2),lua_rawlen(L,2)); - (arg1)->save(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_save__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - ofBuffer *arg2 = 0 ; ofImageQualityType arg3 ; SWIG_check_num_args("ofImage_< float >::save",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::save",1,"ofImage_< float > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofImage_< float >::save",2,"ofBuffer &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< float >::save",3,"ofImageQualityType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_save",1,SWIGTYPE_p_ofImage_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBuffer,0))){ - SWIG_fail_ptr("FloatImage_save",2,SWIGTYPE_p_ofBuffer); } arg3 = (ofImageQualityType)(int)lua_tonumber(L, 3); - (arg1)->save(*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_save__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - ofBuffer *arg2 = 0 ; SWIG_check_num_args("ofImage_< float >::save",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::save",1,"ofImage_< float > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofImage_< float >::save",2,"ofBuffer &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_save",1,SWIGTYPE_p_ofImage_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBuffer,0))){ - SWIG_fail_ptr("FloatImage_save",2,SWIGTYPE_p_ofBuffer); } (arg1)->save(*arg2); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_save__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - ofFile *arg2 = 0 ; ofImageQualityType arg3 ; SWIG_check_num_args("ofImage_< float >::save",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::save",1,"ofImage_< float > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofImage_< float >::save",2,"ofFile const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< float >::save",3,"ofImageQualityType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_save",1,SWIGTYPE_p_ofImage_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofFile,0))){ - SWIG_fail_ptr("FloatImage_save",2,SWIGTYPE_p_ofFile); } arg3 = (ofImageQualityType)(int)lua_tonumber(L, 3); - (arg1)->save((ofFile const &)*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_save__SWIG_5(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - ofFile *arg2 = 0 ; SWIG_check_num_args("ofImage_< float >::save",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::save",1,"ofImage_< float > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofImage_< float >::save",2,"ofFile const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_save",1,SWIGTYPE_p_ofImage_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofFile,0))){ - SWIG_fail_ptr("FloatImage_save",2,SWIGTYPE_p_ofFile); } (arg1)->save((ofFile const &)*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_save(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBuffer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_FloatImage_save__SWIG_3(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_FloatImage_save__SWIG_5(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { - return _wrap_FloatImage_save__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_FloatImage_save__SWIG_4(L);} } - } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBuffer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_FloatImage_save__SWIG_2(L);} } - } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_FloatImage_save__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatImage_save'\n" " Possible C/C++ prototypes are:\n" - " ofImage_< float >::save(std::string,ofImageQualityType)\n" " ofImage_< float >::save(std::string)\n" - " ofImage_< float >::save(ofBuffer &,ofImageQualityType)\n" " ofImage_< float >::save(ofBuffer &)\n" - " ofImage_< float >::save(ofFile const &,ofImageQualityType)\n" " ofImage_< float >::save(ofFile const &)\n"); - lua_error(L);return 0; } -static void swig_delete_FloatImage(void *obj) { -ofImage_< float > *arg1 = (ofImage_< float > *) obj; -delete arg1; -} -static int _proxy__wrap_new_FloatImage(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_FloatImage); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_FloatImage_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_FloatImage_methods[]= { - { "allocate", _wrap_FloatImage_allocate}, - { "isAllocated", _wrap_FloatImage_isAllocated}, - { "clear", _wrap_FloatImage_clear}, - { "load", _wrap_FloatImage_load}, - { "draw", _wrap_FloatImage_draw}, - { "drawSubsection", _wrap_FloatImage_drawSubsection}, - { "update", _wrap_FloatImage_update}, - { "setUseTexture", _wrap_FloatImage_setUseTexture}, - { "isUsingTexture", _wrap_FloatImage_isUsingTexture}, - { "getTexture", _wrap_FloatImage_getTexture}, - { "bind", _wrap_FloatImage_bind}, - { "unbind", _wrap_FloatImage_unbind}, - { "setCompression", _wrap_FloatImage_setCompression}, - { "getColor", _wrap_FloatImage_getColor}, - { "getHeight", _wrap_FloatImage_getHeight}, - { "getWidth", _wrap_FloatImage_getWidth}, - { "setColor", _wrap_FloatImage_setColor}, - { "setFromPixels", _wrap_FloatImage_setFromPixels}, - { "grabScreen", _wrap_FloatImage_grabScreen}, - { "setImageType", _wrap_FloatImage_setImageType}, - { "getImageType", _wrap_FloatImage_getImageType}, - { "resize", _wrap_FloatImage_resize}, - { "crop", _wrap_FloatImage_crop}, - { "cropFrom", _wrap_FloatImage_cropFrom}, - { "rotate90", _wrap_FloatImage_rotate90}, - { "mirror", _wrap_FloatImage_mirror}, - { "setAnchorPercent", _wrap_FloatImage_setAnchorPercent}, - { "setAnchorPoint", _wrap_FloatImage_setAnchorPoint}, - { "resetAnchor", _wrap_FloatImage_resetAnchor}, - { "save", _wrap_FloatImage_save}, - {0,0} -}; -static swig_lua_method swig_FloatImage_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_FloatImage_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_FloatImage_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_FloatImage_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_FloatImage_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_FloatImage_Sf_SwigStatic = { - "FloatImage", - swig_FloatImage_Sf_SwigStatic_methods, - swig_FloatImage_Sf_SwigStatic_attributes, - swig_FloatImage_Sf_SwigStatic_constants, - swig_FloatImage_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_FloatImage_bases[] = {0}; -static const char *swig_FloatImage_base_names[] = {0}; -static swig_lua_class _wrap_class_FloatImage = { "FloatImage", "FloatImage", &SWIGTYPE_p_ofImage_T_float_t,_proxy__wrap_new_FloatImage, swig_delete_FloatImage, swig_FloatImage_methods, swig_FloatImage_attributes, &swig_FloatImage_Sf_SwigStatic, swig_FloatImage_meta, swig_FloatImage_bases, swig_FloatImage_base_names }; - -static int _wrap_new_ShortImage__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofImage_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofImage_< unsigned short >::ofImage_",0,0) - result = (ofImage_< unsigned short > *)new ofImage_< unsigned short >(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofImage_T_unsigned_short_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_ShortImage__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPixels_< unsigned short > *arg1 = 0 ; - ofImage_< unsigned short > *result = 0 ; SWIG_check_num_args("ofImage_< unsigned short >::ofImage_",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::ofImage_",1,"ofPixels_< unsigned short > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("new_ShortImage",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - result = (ofImage_< unsigned short > *)new ofImage_< unsigned short >((ofPixels_< unsigned short > const &)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofImage_T_unsigned_short_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_ShortImage__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = 0 ; - ofImage_< unsigned short > *result = 0 ; SWIG_check_num_args("ofImage_< unsigned short >::ofImage_",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::ofImage_",1,"ofFile const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("new_ShortImage",1,SWIGTYPE_p_ofFile); } - result = (ofImage_< unsigned short > *)new ofImage_< unsigned short >((ofFile const &)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofImage_T_unsigned_short_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_ShortImage__SWIG_3(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - ofImage_< unsigned short > *result = 0 ; SWIG_check_num_args("ofImage_< unsigned short >::ofImage_",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::ofImage_",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; - result = (ofImage_< unsigned short > *)new ofImage_< unsigned short >((std::string const &)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofImage_T_unsigned_short_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_ShortImage__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofImage_< unsigned short > *arg1 = 0 ; - ofImage_< unsigned short > *result = 0 ; SWIG_check_num_args("ofImage_< unsigned short >::ofImage_",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::ofImage_",1,"ofImage_< unsigned short > &&"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("new_ShortImage",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - result = (ofImage_< unsigned short > *)new ofImage_< unsigned short >((ofImage_< unsigned short > &&)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofImage_T_unsigned_short_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_ShortImage(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_ShortImage__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_new_ShortImage__SWIG_1(L);} } if (argc == 1) { int _v; { - void *ptr; if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_new_ShortImage__SWIG_2(L);} } if (argc == 1) { int _v; { - void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_new_ShortImage__SWIG_4(L);} } if (argc == 1) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { return _wrap_new_ShortImage__SWIG_3(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_ShortImage'\n" " Possible C/C++ prototypes are:\n" - " ofImage_< unsigned short >::ofImage_()\n" - " ofImage_< unsigned short >::ofImage_(ofPixels_< unsigned short > const &)\n" - " ofImage_< unsigned short >::ofImage_(ofFile const &)\n" " ofImage_< unsigned short >::ofImage_(std::string const &)\n" - " ofImage_< unsigned short >::ofImage_(ofImage_< unsigned short > &&)\n"); lua_error(L);return 0; } -static int _wrap_ShortImage_allocate(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; int arg2 ; int arg3 ; ofImageType arg4 ; - SWIG_check_num_args("ofImage_< unsigned short >::allocate",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::allocate",1,"ofImage_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::allocate",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned short >::allocate",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< unsigned short >::allocate",4,"ofImageType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_allocate",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); arg4 = (ofImageType)(int)lua_tonumber(L, 4); (arg1)->allocate(arg2,arg3,arg4); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_isAllocated(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; bool result; - SWIG_check_num_args("ofImage_< unsigned short >::isAllocated",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::isAllocated",1,"ofImage_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_isAllocated",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - result = (bool)((ofImage_< unsigned short > const *)arg1)->isAllocated(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_clear(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; - SWIG_check_num_args("ofImage_< unsigned short >::clear",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::clear",1,"ofImage_< unsigned short > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_clear",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } (arg1)->clear(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_load__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; std::string *arg2 = 0 ; std::string temp2 ; bool result; - SWIG_check_num_args("ofImage_< unsigned short >::load",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::load",1,"ofImage_< unsigned short > *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::load",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_load",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; result = (bool)(arg1)->load((std::string const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_load__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; ofBuffer *arg2 = 0 ; bool result; - SWIG_check_num_args("ofImage_< unsigned short >::load",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::load",1,"ofImage_< unsigned short > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::load",2,"ofBuffer const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_load",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBuffer,0))){ - SWIG_fail_ptr("ShortImage_load",2,SWIGTYPE_p_ofBuffer); } result = (bool)(arg1)->load((ofBuffer const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_load__SWIG_2(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; ofFile *arg2 = 0 ; bool result; - SWIG_check_num_args("ofImage_< unsigned short >::load",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::load",1,"ofImage_< unsigned short > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::load",2,"ofFile const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_load",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofFile,0))){ - SWIG_fail_ptr("ShortImage_load",2,SWIGTYPE_p_ofFile); } result = (bool)(arg1)->load((ofFile const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_load(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v; - { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBuffer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_ShortImage_load__SWIG_1(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_ShortImage_load__SWIG_2(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { - return _wrap_ShortImage_load__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortImage_load'\n" " Possible C/C++ prototypes are:\n" - " ofImage_< unsigned short >::load(std::string const &)\n" " ofImage_< unsigned short >::load(ofBuffer const &)\n" - " ofImage_< unsigned short >::load(ofFile const &)\n"); lua_error(L);return 0; } -static int _wrap_ShortImage_draw__SWIG_0_0(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; ofPoint *arg2 = 0 ; SWIG_check_num_args("draw",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("draw",1,"ofImage_< unsigned short > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("draw",2,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_draw",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("ShortImage_draw",2,SWIGTYPE_p_ofVec3f); } - ((ofImage_< unsigned short > const *)arg1)->draw((ofPoint const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_draw__SWIG_0_1(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; ofRectangle *arg2 = 0 ; SWIG_check_num_args("draw",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("draw",1,"ofImage_< unsigned short > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("draw",2,"ofRectangle const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_draw",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("ShortImage_draw",2,SWIGTYPE_p_ofRectangle); } - ((ofImage_< unsigned short > const *)arg1)->draw((ofRectangle const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_draw__SWIG_0_2(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; ofPoint *arg2 = 0 ; float arg3 ; float arg4 ; - SWIG_check_num_args("draw",4,4) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("draw",1,"ofImage_< unsigned short > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("draw",2,"ofPoint const &"); if(!lua_isnumber(L,3)) SWIG_fail_arg("draw",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("draw",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_draw",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("ShortImage_draw",2,SWIGTYPE_p_ofVec3f); } arg3 = (float)lua_tonumber(L, 3); - arg4 = (float)lua_tonumber(L, 4); ((ofImage_< unsigned short > const *)arg1)->draw((ofPoint const &)*arg2,arg3,arg4); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_draw__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofImage_< unsigned short >::draw",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::draw",1,"ofImage_< unsigned short > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::draw",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned short >::draw",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_draw",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); ((ofImage_< unsigned short > const *)arg1)->draw(arg2,arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_draw__SWIG_2(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; float arg2 ; float arg3 ; float arg4 ; - SWIG_check_num_args("ofImage_< unsigned short >::draw",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::draw",1,"ofImage_< unsigned short > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::draw",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned short >::draw",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< unsigned short >::draw",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_draw",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - ((ofImage_< unsigned short > const *)arg1)->draw(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortImage_draw__SWIG_3(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; float arg2 ; float arg3 ; float arg4 ; float arg5 ; - SWIG_check_num_args("ofImage_< unsigned short >::draw",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::draw",1,"ofImage_< unsigned short > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::draw",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned short >::draw",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< unsigned short >::draw",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< unsigned short >::draw",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_draw",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - ((ofImage_< unsigned short > const *)arg1)->draw(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortImage_draw__SWIG_4(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; float arg2 ; float arg3 ; float arg4 ; float arg5 ; - float arg6 ; SWIG_check_num_args("ofImage_< unsigned short >::draw",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::draw",1,"ofImage_< unsigned short > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::draw",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned short >::draw",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< unsigned short >::draw",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< unsigned short >::draw",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofImage_< unsigned short >::draw",6,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_draw",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); ((ofImage_< unsigned short > const *)arg1)->draw(arg2,arg3,arg4,arg5,arg6); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_draw(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_ShortImage_draw__SWIG_0_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_ShortImage_draw__SWIG_0_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_ShortImage_draw__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_ShortImage_draw__SWIG_0_2(L);} } } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_ShortImage_draw__SWIG_2(L);} } } } } - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_ShortImage_draw__SWIG_3(L);} } } } } } if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { return _wrap_ShortImage_draw__SWIG_4(L);} } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortImage_draw'\n" " Possible C/C++ prototypes are:\n" - " draw(ofPoint const &) const\n" " draw(ofRectangle const &) const\n" " draw(ofPoint const &,float,float) const\n" - " ofImage_< unsigned short >::draw(float,float) const\n" " ofImage_< unsigned short >::draw(float,float,float) const\n" - " ofImage_< unsigned short >::draw(float,float,float,float) const\n" - " ofImage_< unsigned short >::draw(float,float,float,float,float) const\n"); lua_error(L);return 0; } -static int _wrap_ShortImage_drawSubsection__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; float arg2 ; float arg3 ; float arg4 ; float arg5 ; - float arg6 ; float arg7 ; SWIG_check_num_args("ofImage_< unsigned short >::drawSubsection",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",1,"ofImage_< unsigned short > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",7,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_drawSubsection",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); - ((ofImage_< unsigned short > const *)arg1)->drawSubsection(arg2,arg3,arg4,arg5,arg6,arg7); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_drawSubsection__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; float arg2 ; float arg3 ; float arg4 ; float arg5 ; - float arg6 ; float arg7 ; float arg8 ; SWIG_check_num_args("ofImage_< unsigned short >::drawSubsection",8,8) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",1,"ofImage_< unsigned short > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",8,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_drawSubsection",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (float)lua_tonumber(L, 8); - ((ofImage_< unsigned short > const *)arg1)->drawSubsection(arg2,arg3,arg4,arg5,arg6,arg7,arg8); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_drawSubsection__SWIG_2(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; float arg2 ; float arg3 ; float arg4 ; float arg5 ; - float arg6 ; float arg7 ; float arg8 ; float arg9 ; SWIG_check_num_args("ofImage_< unsigned short >::drawSubsection",9,9) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",1,"ofImage_< unsigned short > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",8,"float"); - if(!lua_isnumber(L,9)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",9,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_drawSubsection",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (float)lua_tonumber(L, 8); - arg9 = (float)lua_tonumber(L, 9); - ((ofImage_< unsigned short > const *)arg1)->drawSubsection(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_drawSubsection__SWIG_3(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; float arg2 ; float arg3 ; float arg4 ; float arg5 ; - float arg6 ; float arg7 ; float arg8 ; float arg9 ; float arg10 ; - SWIG_check_num_args("ofImage_< unsigned short >::drawSubsection",10,10) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",1,"ofImage_< unsigned short > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",8,"float"); - if(!lua_isnumber(L,9)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",9,"float"); - if(!lua_isnumber(L,10)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",10,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_drawSubsection",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (float)lua_tonumber(L, 8); - arg9 = (float)lua_tonumber(L, 9); arg10 = (float)lua_tonumber(L, 10); - ((ofImage_< unsigned short > const *)arg1)->drawSubsection(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_drawSubsection(lua_State* L) { int argc; int argv[11]={ 1,2,3,4,5,6,7,8,9,10,11} ; - argc = lua_gettop(L); if (argc == 7) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { - return _wrap_ShortImage_drawSubsection__SWIG_0(L);} } } } } } } } if (argc == 8) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { return _wrap_ShortImage_drawSubsection__SWIG_1(L);} } } } } } - } } } if (argc == 9) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { { _v = lua_isnumber(L,argv[8]); } if (_v) { - return _wrap_ShortImage_drawSubsection__SWIG_2(L);} } } } } } } } } } if (argc == 10) { int _v; - { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { { _v = lua_isnumber(L,argv[8]); } if (_v) { { - _v = lua_isnumber(L,argv[9]); } if (_v) { return _wrap_ShortImage_drawSubsection__SWIG_3(L);} } } } - } } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortImage_drawSubsection'\n" - " Possible C/C++ prototypes are:\n" - " ofImage_< unsigned short >::drawSubsection(float,float,float,float,float,float) const\n" - " ofImage_< unsigned short >::drawSubsection(float,float,float,float,float,float,float) const\n" - " ofImage_< unsigned short >::drawSubsection(float,float,float,float,float,float,float,float) const\n" - " ofImage_< unsigned short >::drawSubsection(float,float,float,float,float,float,float,float,float) const\n"); - lua_error(L);return 0; } -static int _wrap_ShortImage_update(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; - SWIG_check_num_args("ofImage_< unsigned short >::update",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::update",1,"ofImage_< unsigned short > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_update",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } (arg1)->update(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_setUseTexture(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; bool arg2 ; - SWIG_check_num_args("ofImage_< unsigned short >::setUseTexture",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::setUseTexture",1,"ofImage_< unsigned short > *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::setUseTexture",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_setUseTexture",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } arg2 = (lua_toboolean(L, 2)!=0); - (arg1)->setUseTexture(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_isUsingTexture(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; bool result; - SWIG_check_num_args("ofImage_< unsigned short >::isUsingTexture",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::isUsingTexture",1,"ofImage_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_isUsingTexture",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - result = (bool)((ofImage_< unsigned short > const *)arg1)->isUsingTexture(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_getTexture__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; ofTexture *result = 0 ; - SWIG_check_num_args("ofImage_< unsigned short >::getTexture",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::getTexture",1,"ofImage_< unsigned short > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_getTexture",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - result = (ofTexture *) &(arg1)->getTexture(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTexture,0); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_getTexture__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; ofTexture *result = 0 ; - SWIG_check_num_args("ofImage_< unsigned short >::getTexture",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::getTexture",1,"ofImage_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_getTexture",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - result = (ofTexture *) &((ofImage_< unsigned short > const *)arg1)->getTexture(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTexture,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortImage_getTexture(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_ShortImage_getTexture__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_ShortImage_getTexture__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortImage_getTexture'\n" - " Possible C/C++ prototypes are:\n" " ofImage_< unsigned short >::getTexture()\n" - " ofImage_< unsigned short >::getTexture() const\n"); lua_error(L);return 0; } -static int _wrap_ShortImage_bind__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; int arg2 ; - SWIG_check_num_args("ofImage_< unsigned short >::bind",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::bind",1,"ofImage_< unsigned short > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::bind",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_bind",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } arg2 = (int)lua_tonumber(L, 2); - ((ofImage_< unsigned short > const *)arg1)->bind(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortImage_bind__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; - SWIG_check_num_args("ofImage_< unsigned short >::bind",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::bind",1,"ofImage_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_bind",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - ((ofImage_< unsigned short > const *)arg1)->bind(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_bind(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; - { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_ShortImage_bind__SWIG_1(L);} } if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_ShortImage_bind__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortImage_bind'\n" " Possible C/C++ prototypes are:\n" - " ofImage_< unsigned short >::bind(int) const\n" " ofImage_< unsigned short >::bind() const\n"); lua_error(L);return 0; } -static int _wrap_ShortImage_unbind__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; int arg2 ; - SWIG_check_num_args("ofImage_< unsigned short >::unbind",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::unbind",1,"ofImage_< unsigned short > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::unbind",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_unbind",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } arg2 = (int)lua_tonumber(L, 2); - ((ofImage_< unsigned short > const *)arg1)->unbind(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortImage_unbind__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; - SWIG_check_num_args("ofImage_< unsigned short >::unbind",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::unbind",1,"ofImage_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_unbind",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - ((ofImage_< unsigned short > const *)arg1)->unbind(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_unbind(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_ShortImage_unbind__SWIG_1(L);} } if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_ShortImage_unbind__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortImage_unbind'\n" " Possible C/C++ prototypes are:\n" - " ofImage_< unsigned short >::unbind(int) const\n" " ofImage_< unsigned short >::unbind() const\n"); - lua_error(L);return 0; } -static int _wrap_ShortImage_setCompression(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; ofTexCompression arg2 ; - SWIG_check_num_args("ofImage_< unsigned short >::setCompression",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::setCompression",1,"ofImage_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::setCompression",2,"ofTexCompression"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_setCompression",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - arg2 = (ofTexCompression)(int)lua_tonumber(L, 2); (arg1)->setCompression(arg2); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_getColor__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; int arg2 ; int arg3 ; ofColor_< unsigned short > result; - SWIG_check_num_args("ofImage_< unsigned short >::getColor",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::getColor",1,"ofImage_< unsigned short > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::getColor",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned short >::getColor",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_getColor",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); result = ((ofImage_< unsigned short > const *)arg1)->getColor(arg2,arg3); { - ofColor_< unsigned short > * resultptr = new ofColor_< unsigned short >((const ofColor_< unsigned short > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_short_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_getColor__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; int arg2 ; ofColor_< unsigned short > result; - SWIG_check_num_args("ofImage_< unsigned short >::getColor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::getColor",1,"ofImage_< unsigned short > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::getColor",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_getColor",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } arg2 = (int)lua_tonumber(L, 2); - result = ((ofImage_< unsigned short > const *)arg1)->getColor(arg2); { - ofColor_< unsigned short > * resultptr = new ofColor_< unsigned short >((const ofColor_< unsigned short > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_short_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_getColor(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_ShortImage_getColor__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_ShortImage_getColor__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortImage_getColor'\n" - " Possible C/C++ prototypes are:\n" " ofImage_< unsigned short >::getColor(int,int) const\n" - " ofImage_< unsigned short >::getColor(int) const\n"); lua_error(L);return 0; } -static int _wrap_ShortImage_getHeight(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; float result; - SWIG_check_num_args("ofImage_< unsigned short >::getHeight",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::getHeight",1,"ofImage_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_getHeight",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - result = (float)((ofImage_< unsigned short > const *)arg1)->getHeight(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_getWidth(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; float result; - SWIG_check_num_args("ofImage_< unsigned short >::getWidth",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::getWidth",1,"ofImage_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_getWidth",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - result = (float)((ofImage_< unsigned short > const *)arg1)->getWidth(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_setColor__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; int arg2 ; int arg3 ; - ofColor_< unsigned short > *arg4 = 0 ; SWIG_check_num_args("ofImage_< unsigned short >::setColor",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::setColor",1,"ofImage_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::setColor",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned short >::setColor",3,"int"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofImage_< unsigned short >::setColor",4,"ofColor_< unsigned short > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_setColor",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_setColor",4,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - (arg1)->setColor(arg2,arg3,(ofColor_< unsigned short > const &)*arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortImage_setColor__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; int arg2 ; ofColor_< unsigned short > *arg3 = 0 ; - SWIG_check_num_args("ofImage_< unsigned short >::setColor",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::setColor",1,"ofImage_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::setColor",2,"int"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofImage_< unsigned short >::setColor",3,"ofColor_< unsigned short > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_setColor",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } arg2 = (int)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_setColor",3,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - (arg1)->setColor(arg2,(ofColor_< unsigned short > const &)*arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortImage_setColor__SWIG_2(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; ofColor_< unsigned short > *arg2 = 0 ; - SWIG_check_num_args("ofImage_< unsigned short >::setColor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::setColor",1,"ofImage_< unsigned short > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::setColor",2,"ofColor_< unsigned short > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_setColor",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_setColor",2,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - (arg1)->setColor((ofColor_< unsigned short > const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortImage_setColor(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_ShortImage_setColor__SWIG_2(L);} } } if (argc == 3) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_ShortImage_setColor__SWIG_1(L);} } } } if (argc == 4) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_ShortImage_setColor__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortImage_setColor'\n" - " Possible C/C++ prototypes are:\n" " ofImage_< unsigned short >::setColor(int,int,ofColor_< unsigned short > const &)\n" - " ofImage_< unsigned short >::setColor(int,ofColor_< unsigned short > const &)\n" - " ofImage_< unsigned short >::setColor(ofColor_< unsigned short > const &)\n"); lua_error(L);return 0; } -static int _wrap_ShortImage_setFromPixels__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; unsigned short *arg2 = (unsigned short *) 0 ; int arg3 ; - int arg4 ; ofImageType arg5 ; bool arg6 ; SWIG_check_num_args("ofImage_< unsigned short >::setFromPixels",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::setFromPixels",1,"ofImage_< unsigned short > *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::setFromPixels",2,"unsigned short const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned short >::setFromPixels",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< unsigned short >::setFromPixels",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< unsigned short >::setFromPixels",5,"ofImageType"); - if(!lua_isboolean(L,6)) SWIG_fail_arg("ofImage_< unsigned short >::setFromPixels",6,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_setFromPixels",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_unsigned_short,0))){ - SWIG_fail_ptr("ShortImage_setFromPixels",2,SWIGTYPE_p_unsigned_short); } arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); arg5 = (ofImageType)(int)lua_tonumber(L, 5); arg6 = (lua_toboolean(L, 6)!=0); - (arg1)->setFromPixels((unsigned short const *)arg2,arg3,arg4,arg5,arg6); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortImage_setFromPixels__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; unsigned short *arg2 = (unsigned short *) 0 ; int arg3 ; - int arg4 ; ofImageType arg5 ; SWIG_check_num_args("ofImage_< unsigned short >::setFromPixels",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::setFromPixels",1,"ofImage_< unsigned short > *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::setFromPixels",2,"unsigned short const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned short >::setFromPixels",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< unsigned short >::setFromPixels",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< unsigned short >::setFromPixels",5,"ofImageType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_setFromPixels",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_unsigned_short,0))){ - SWIG_fail_ptr("ShortImage_setFromPixels",2,SWIGTYPE_p_unsigned_short); } arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); arg5 = (ofImageType)(int)lua_tonumber(L, 5); - (arg1)->setFromPixels((unsigned short const *)arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortImage_setFromPixels__SWIG_2(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; ofPixels_< unsigned short > *arg2 = 0 ; - SWIG_check_num_args("ofImage_< unsigned short >::setFromPixels",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::setFromPixels",1,"ofImage_< unsigned short > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::setFromPixels",2,"ofPixels_< unsigned short > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_setFromPixels",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_setFromPixels",2,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - (arg1)->setFromPixels((ofPixels_< unsigned short > const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortImage_setFromPixels(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_ShortImage_setFromPixels__SWIG_2(L);} } } if (argc == 5) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_unsigned_short, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_ShortImage_setFromPixels__SWIG_1(L);} } } } } - } if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_unsigned_short, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isboolean(L,argv[5]); } if (_v) { - return _wrap_ShortImage_setFromPixels__SWIG_0(L);} } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortImage_setFromPixels'\n" - " Possible C/C++ prototypes are:\n" - " ofImage_< unsigned short >::setFromPixels(unsigned short const *,int,int,ofImageType,bool)\n" - " ofImage_< unsigned short >::setFromPixels(unsigned short const *,int,int,ofImageType)\n" - " ofImage_< unsigned short >::setFromPixels(ofPixels_< unsigned short > const &)\n"); lua_error(L);return 0; } -static int _wrap_ShortImage_grabScreen(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; int arg2 ; int arg3 ; int arg4 ; int arg5 ; - SWIG_check_num_args("ofImage_< unsigned short >::grabScreen",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::grabScreen",1,"ofImage_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::grabScreen",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned short >::grabScreen",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< unsigned short >::grabScreen",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< unsigned short >::grabScreen",5,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_grabScreen",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); - (arg1)->grabScreen(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_setImageType(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; ofImageType arg2 ; - SWIG_check_num_args("ofImage_< unsigned short >::setImageType",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::setImageType",1,"ofImage_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::setImageType",2,"ofImageType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_setImageType",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - arg2 = (ofImageType)(int)lua_tonumber(L, 2); (arg1)->setImageType(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortImage_getImageType(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; ofImageType result; - SWIG_check_num_args("ofImage_< unsigned short >::getImageType",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::getImageType",1,"ofImage_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_getImageType",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - result = (ofImageType)((ofImage_< unsigned short > const *)arg1)->getImageType(); - lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortImage_resize(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; int arg2 ; int arg3 ; - SWIG_check_num_args("ofImage_< unsigned short >::resize",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::resize",1,"ofImage_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::resize",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned short >::resize",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_resize",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); (arg1)->resize(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortImage_crop(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; int arg2 ; int arg3 ; int arg4 ; int arg5 ; - SWIG_check_num_args("ofImage_< unsigned short >::crop",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::crop",1,"ofImage_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::crop",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned short >::crop",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< unsigned short >::crop",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< unsigned short >::crop",5,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_crop",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); - (arg1)->crop(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_cropFrom(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; ofImage_< unsigned short > *arg2 = 0 ; int arg3 ; - int arg4 ; int arg5 ; int arg6 ; SWIG_check_num_args("ofImage_< unsigned short >::cropFrom",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::cropFrom",1,"ofImage_< unsigned short > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::cropFrom",2,"ofImage_< unsigned short > &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned short >::cropFrom",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< unsigned short >::cropFrom",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< unsigned short >::cropFrom",5,"int"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofImage_< unsigned short >::cropFrom",6,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_cropFrom",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_cropFrom",2,SWIGTYPE_p_ofImage_T_unsigned_short_t); } arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); arg6 = (int)lua_tonumber(L, 6); - (arg1)->cropFrom(*arg2,arg3,arg4,arg5,arg6); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_rotate90(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; int arg2 ; - SWIG_check_num_args("ofImage_< unsigned short >::rotate90",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::rotate90",1,"ofImage_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::rotate90",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_rotate90",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->rotate90(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_mirror(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; bool arg2 ; bool arg3 ; - SWIG_check_num_args("ofImage_< unsigned short >::mirror",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::mirror",1,"ofImage_< unsigned short > *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::mirror",2,"bool"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofImage_< unsigned short >::mirror",3,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_mirror",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } arg2 = (lua_toboolean(L, 2)!=0); - arg3 = (lua_toboolean(L, 3)!=0); (arg1)->mirror(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortImage_setAnchorPercent(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofImage_< unsigned short >::setAnchorPercent",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::setAnchorPercent",1,"ofImage_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::setAnchorPercent",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned short >::setAnchorPercent",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_setAnchorPercent",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->setAnchorPercent(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortImage_setAnchorPoint(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofImage_< unsigned short >::setAnchorPoint",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::setAnchorPoint",1,"ofImage_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::setAnchorPoint",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned short >::setAnchorPoint",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_setAnchorPoint",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->setAnchorPoint(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortImage_resetAnchor(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; - SWIG_check_num_args("ofImage_< unsigned short >::resetAnchor",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::resetAnchor",1,"ofImage_< unsigned short > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_resetAnchor",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } (arg1)->resetAnchor(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_save__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; std::string arg2 ; ofImageQualityType arg3 ; - SWIG_check_num_args("ofImage_< unsigned short >::save",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::save",1,"ofImage_< unsigned short > *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::save",2,"std::string"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned short >::save",3,"ofImageQualityType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_save",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - (&arg2)->assign(lua_tostring(L,2),lua_rawlen(L,2)); arg3 = (ofImageQualityType)(int)lua_tonumber(L, 3); - (arg1)->save(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_save__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; std::string arg2 ; - SWIG_check_num_args("ofImage_< unsigned short >::save",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::save",1,"ofImage_< unsigned short > *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::save",2,"std::string"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_save",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - (&arg2)->assign(lua_tostring(L,2),lua_rawlen(L,2)); (arg1)->save(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortImage_save__SWIG_2(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; ofBuffer *arg2 = 0 ; ofImageQualityType arg3 ; - SWIG_check_num_args("ofImage_< unsigned short >::save",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::save",1,"ofImage_< unsigned short > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::save",2,"ofBuffer &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned short >::save",3,"ofImageQualityType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_save",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBuffer,0))){ - SWIG_fail_ptr("ShortImage_save",2,SWIGTYPE_p_ofBuffer); } arg3 = (ofImageQualityType)(int)lua_tonumber(L, 3); - (arg1)->save(*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_save__SWIG_3(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; ofBuffer *arg2 = 0 ; - SWIG_check_num_args("ofImage_< unsigned short >::save",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::save",1,"ofImage_< unsigned short > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::save",2,"ofBuffer &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_save",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBuffer,0))){ - SWIG_fail_ptr("ShortImage_save",2,SWIGTYPE_p_ofBuffer); } (arg1)->save(*arg2); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_save__SWIG_4(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; ofFile *arg2 = 0 ; ofImageQualityType arg3 ; - SWIG_check_num_args("ofImage_< unsigned short >::save",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::save",1,"ofImage_< unsigned short > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::save",2,"ofFile const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned short >::save",3,"ofImageQualityType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_save",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofFile,0))){ - SWIG_fail_ptr("ShortImage_save",2,SWIGTYPE_p_ofFile); } arg3 = (ofImageQualityType)(int)lua_tonumber(L, 3); - (arg1)->save((ofFile const &)*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_save__SWIG_5(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; ofFile *arg2 = 0 ; - SWIG_check_num_args("ofImage_< unsigned short >::save",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::save",1,"ofImage_< unsigned short > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::save",2,"ofFile const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_save",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofFile,0))){ - SWIG_fail_ptr("ShortImage_save",2,SWIGTYPE_p_ofFile); } (arg1)->save((ofFile const &)*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_save(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBuffer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_ShortImage_save__SWIG_3(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_ShortImage_save__SWIG_5(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { - return _wrap_ShortImage_save__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_ShortImage_save__SWIG_4(L);} } - } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBuffer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_ShortImage_save__SWIG_2(L);} } - } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_ShortImage_save__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortImage_save'\n" " Possible C/C++ prototypes are:\n" - " ofImage_< unsigned short >::save(std::string,ofImageQualityType)\n" " ofImage_< unsigned short >::save(std::string)\n" - " ofImage_< unsigned short >::save(ofBuffer &,ofImageQualityType)\n" " ofImage_< unsigned short >::save(ofBuffer &)\n" - " ofImage_< unsigned short >::save(ofFile const &,ofImageQualityType)\n" - " ofImage_< unsigned short >::save(ofFile const &)\n"); lua_error(L);return 0; } -static void swig_delete_ShortImage(void *obj) { -ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) obj; -delete arg1; -} -static int _proxy__wrap_new_ShortImage(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_ShortImage); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_ShortImage_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_ShortImage_methods[]= { - { "allocate", _wrap_ShortImage_allocate}, - { "isAllocated", _wrap_ShortImage_isAllocated}, - { "clear", _wrap_ShortImage_clear}, - { "load", _wrap_ShortImage_load}, - { "draw", _wrap_ShortImage_draw}, - { "drawSubsection", _wrap_ShortImage_drawSubsection}, - { "update", _wrap_ShortImage_update}, - { "setUseTexture", _wrap_ShortImage_setUseTexture}, - { "isUsingTexture", _wrap_ShortImage_isUsingTexture}, - { "getTexture", _wrap_ShortImage_getTexture}, - { "bind", _wrap_ShortImage_bind}, - { "unbind", _wrap_ShortImage_unbind}, - { "setCompression", _wrap_ShortImage_setCompression}, - { "getColor", _wrap_ShortImage_getColor}, - { "getHeight", _wrap_ShortImage_getHeight}, - { "getWidth", _wrap_ShortImage_getWidth}, - { "setColor", _wrap_ShortImage_setColor}, - { "setFromPixels", _wrap_ShortImage_setFromPixels}, - { "grabScreen", _wrap_ShortImage_grabScreen}, - { "setImageType", _wrap_ShortImage_setImageType}, - { "getImageType", _wrap_ShortImage_getImageType}, - { "resize", _wrap_ShortImage_resize}, - { "crop", _wrap_ShortImage_crop}, - { "cropFrom", _wrap_ShortImage_cropFrom}, - { "rotate90", _wrap_ShortImage_rotate90}, - { "mirror", _wrap_ShortImage_mirror}, - { "setAnchorPercent", _wrap_ShortImage_setAnchorPercent}, - { "setAnchorPoint", _wrap_ShortImage_setAnchorPoint}, - { "resetAnchor", _wrap_ShortImage_resetAnchor}, - { "save", _wrap_ShortImage_save}, - {0,0} -}; -static swig_lua_method swig_ShortImage_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_ShortImage_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_ShortImage_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_ShortImage_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_ShortImage_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_ShortImage_Sf_SwigStatic = { - "ShortImage", - swig_ShortImage_Sf_SwigStatic_methods, - swig_ShortImage_Sf_SwigStatic_attributes, - swig_ShortImage_Sf_SwigStatic_constants, - swig_ShortImage_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_ShortImage_bases[] = {0}; -static const char *swig_ShortImage_base_names[] = {0}; -static swig_lua_class _wrap_class_ShortImage = { "ShortImage", "ShortImage", &SWIGTYPE_p_ofImage_T_unsigned_short_t,_proxy__wrap_new_ShortImage, swig_delete_ShortImage, swig_ShortImage_methods, swig_ShortImage_attributes, &swig_ShortImage_Sf_SwigStatic, swig_ShortImage_meta, swig_ShortImage_bases, swig_ShortImage_base_names }; - -static int _wrap_isVFlipped(lua_State* L) { int SWIG_arg = 0; bool result; SWIG_check_num_args("ofIsVFlipped",0,0) - result = (bool)ofIsVFlipped(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_Node__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofNode *result = 0 ; - SWIG_check_num_args("ofNode::ofNode",0,0) result = (ofNode *)new ofNode(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofNode,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Node__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = 0 ; ofNode *result = 0 ; - SWIG_check_num_args("ofNode::ofNode",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofNode::ofNode",1,"ofNode &&"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("new_Node",1,SWIGTYPE_p_ofNode); } - result = (ofNode *)new ofNode((ofNode &&)*arg1); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofNode,1); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_new_Node(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_Node__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_new_Node__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_Node'\n" " Possible C/C++ prototypes are:\n" - " ofNode::ofNode()\n" " ofNode::ofNode(ofNode &&)\n"); lua_error(L);return 0; } -static int _wrap_Node_setParent__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; ofNode *arg2 = 0 ; - bool arg3 ; SWIG_check_num_args("ofNode::setParent",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::setParent",1,"ofNode *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofNode::setParent",2,"ofNode &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofNode::setParent",3,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_setParent",1,SWIGTYPE_p_ofNode); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_setParent",2,SWIGTYPE_p_ofNode); } arg3 = (lua_toboolean(L, 3)!=0); (arg1)->setParent(*arg2,arg3); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_setParent__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; ofNode *arg2 = 0 ; - SWIG_check_num_args("ofNode::setParent",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::setParent",1,"ofNode *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofNode::setParent",2,"ofNode &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_setParent",1,SWIGTYPE_p_ofNode); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_setParent",2,SWIGTYPE_p_ofNode); } (arg1)->setParent(*arg2); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Node_setParent(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Node_setParent__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { return _wrap_Node_setParent__SWIG_0(L);} } - } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Node_setParent'\n" - " Possible C/C++ prototypes are:\n" " ofNode::setParent(ofNode &,bool)\n" " ofNode::setParent(ofNode &)\n"); - lua_error(L);return 0; } -static int _wrap_Node_clearParent__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; bool arg2 ; - SWIG_check_num_args("ofNode::clearParent",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::clearParent",1,"ofNode *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofNode::clearParent",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_clearParent",1,SWIGTYPE_p_ofNode); } arg2 = (lua_toboolean(L, 2)!=0); (arg1)->clearParent(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_clearParent__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; - SWIG_check_num_args("ofNode::clearParent",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::clearParent",1,"ofNode *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_clearParent",1,SWIGTYPE_p_ofNode); } (arg1)->clearParent(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Node_clearParent(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Node_clearParent__SWIG_1(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_Node_clearParent__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Node_clearParent'\n" " Possible C/C++ prototypes are:\n" - " ofNode::clearParent(bool)\n" " ofNode::clearParent()\n"); lua_error(L);return 0; } -static int _wrap_Node_getParent(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; ofNode *result = 0 ; - SWIG_check_num_args("ofNode::getParent",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::getParent",1,"ofNode const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_getParent",1,SWIGTYPE_p_ofNode); } - result = (ofNode *)((ofNode const *)arg1)->getParent(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofNode,0); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_getPosition(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; ofVec3f result; - SWIG_check_num_args("ofNode::getPosition",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::getPosition",1,"ofNode const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_getPosition",1,SWIGTYPE_p_ofNode); } result = ((ofNode const *)arg1)->getPosition(); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Node_getX(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; float result; - SWIG_check_num_args("ofNode::getX",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::getX",1,"ofNode const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_getX",1,SWIGTYPE_p_ofNode); } - result = (float)((ofNode const *)arg1)->getX(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_getY(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; float result; - SWIG_check_num_args("ofNode::getY",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::getY",1,"ofNode const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_getY",1,SWIGTYPE_p_ofNode); } - result = (float)((ofNode const *)arg1)->getY(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_getZ(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; float result; - SWIG_check_num_args("ofNode::getZ",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::getZ",1,"ofNode const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_getZ",1,SWIGTYPE_p_ofNode); } - result = (float)((ofNode const *)arg1)->getZ(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_getXAxis(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; ofVec3f result; - SWIG_check_num_args("ofNode::getXAxis",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::getXAxis",1,"ofNode const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_getXAxis",1,SWIGTYPE_p_ofNode); } - result = ((ofNode const *)arg1)->getXAxis(); { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Node_getYAxis(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; ofVec3f result; - SWIG_check_num_args("ofNode::getYAxis",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::getYAxis",1,"ofNode const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_getYAxis",1,SWIGTYPE_p_ofNode); } - result = ((ofNode const *)arg1)->getYAxis(); { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Node_getZAxis(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; ofVec3f result; - SWIG_check_num_args("ofNode::getZAxis",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::getZAxis",1,"ofNode const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_getZAxis",1,SWIGTYPE_p_ofNode); } - result = ((ofNode const *)arg1)->getZAxis(); { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Node_getSideDir(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; ofVec3f result; - SWIG_check_num_args("ofNode::getSideDir",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::getSideDir",1,"ofNode const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_getSideDir",1,SWIGTYPE_p_ofNode); } result = ((ofNode const *)arg1)->getSideDir(); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Node_getLookAtDir(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; ofVec3f result; - SWIG_check_num_args("ofNode::getLookAtDir",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::getLookAtDir",1,"ofNode const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_getLookAtDir",1,SWIGTYPE_p_ofNode); } result = ((ofNode const *)arg1)->getLookAtDir(); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Node_getUpDir(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; ofVec3f result; - SWIG_check_num_args("ofNode::getUpDir",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::getUpDir",1,"ofNode const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_getUpDir",1,SWIGTYPE_p_ofNode); } - result = ((ofNode const *)arg1)->getUpDir(); { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Node_getPitch(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; float result; - SWIG_check_num_args("ofNode::getPitch",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::getPitch",1,"ofNode const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_getPitch",1,SWIGTYPE_p_ofNode); } - result = (float)((ofNode const *)arg1)->getPitch(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_getHeading(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; float result; - SWIG_check_num_args("ofNode::getHeading",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::getHeading",1,"ofNode const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_getHeading",1,SWIGTYPE_p_ofNode); } result = (float)((ofNode const *)arg1)->getHeading(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_getRoll(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; float result; - SWIG_check_num_args("ofNode::getRoll",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::getRoll",1,"ofNode const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_getRoll",1,SWIGTYPE_p_ofNode); } - result = (float)((ofNode const *)arg1)->getRoll(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_getOrientationQuat(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; ofQuaternion result; - SWIG_check_num_args("ofNode::getOrientationQuat",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::getOrientationQuat",1,"ofNode const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_getOrientationQuat",1,SWIGTYPE_p_ofNode); } result = ((ofNode const *)arg1)->getOrientationQuat(); { - ofQuaternion * resultptr = new ofQuaternion((const ofQuaternion &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofQuaternion,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Node_getOrientationEuler(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; ofVec3f result; - SWIG_check_num_args("ofNode::getOrientationEuler",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::getOrientationEuler",1,"ofNode const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_getOrientationEuler",1,SWIGTYPE_p_ofNode); } result = ((ofNode const *)arg1)->getOrientationEuler(); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Node_getScale(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; ofVec3f result; - SWIG_check_num_args("ofNode::getScale",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::getScale",1,"ofNode const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_getScale",1,SWIGTYPE_p_ofNode); } - result = ((ofNode const *)arg1)->getScale(); { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Node_getLocalTransformMatrix(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; - ofMatrix4x4 *result = 0 ; SWIG_check_num_args("ofNode::getLocalTransformMatrix",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::getLocalTransformMatrix",1,"ofNode const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_getLocalTransformMatrix",1,SWIGTYPE_p_ofNode); } - result = (ofMatrix4x4 *) &((ofNode const *)arg1)->getLocalTransformMatrix(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMatrix4x4,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Node_getGlobalTransformMatrix(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; - ofMatrix4x4 result; SWIG_check_num_args("ofNode::getGlobalTransformMatrix",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::getGlobalTransformMatrix",1,"ofNode const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_getGlobalTransformMatrix",1,SWIGTYPE_p_ofNode); } - result = ((ofNode const *)arg1)->getGlobalTransformMatrix(); { - ofMatrix4x4 * resultptr = new ofMatrix4x4((const ofMatrix4x4 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Node_getGlobalPosition(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; ofVec3f result; - SWIG_check_num_args("ofNode::getGlobalPosition",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::getGlobalPosition",1,"ofNode const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_getGlobalPosition",1,SWIGTYPE_p_ofNode); } result = ((ofNode const *)arg1)->getGlobalPosition(); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Node_getGlobalOrientation(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; ofQuaternion result; - SWIG_check_num_args("ofNode::getGlobalOrientation",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::getGlobalOrientation",1,"ofNode const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_getGlobalOrientation",1,SWIGTYPE_p_ofNode); } result = ((ofNode const *)arg1)->getGlobalOrientation(); - { ofQuaternion * resultptr = new ofQuaternion((const ofQuaternion &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofQuaternion,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Node_getGlobalScale(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; ofVec3f result; - SWIG_check_num_args("ofNode::getGlobalScale",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::getGlobalScale",1,"ofNode const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_getGlobalScale",1,SWIGTYPE_p_ofNode); } result = ((ofNode const *)arg1)->getGlobalScale(); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Node_setTransformMatrix(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; ofMatrix4x4 *arg2 = 0 ; - SWIG_check_num_args("ofNode::setTransformMatrix",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::setTransformMatrix",1,"ofNode *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofNode::setTransformMatrix",2,"ofMatrix4x4 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_setTransformMatrix",1,SWIGTYPE_p_ofNode); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Node_setTransformMatrix",2,SWIGTYPE_p_ofMatrix4x4); } - (arg1)->setTransformMatrix((ofMatrix4x4 const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Node_setPosition__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; float arg2 ; - float arg3 ; float arg4 ; SWIG_check_num_args("ofNode::setPosition",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::setPosition",1,"ofNode *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofNode::setPosition",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofNode::setPosition",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofNode::setPosition",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_setPosition",1,SWIGTYPE_p_ofNode); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); (arg1)->setPosition(arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_setPosition__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; ofVec3f *arg2 = 0 ; - SWIG_check_num_args("ofNode::setPosition",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::setPosition",1,"ofNode *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofNode::setPosition",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_setPosition",1,SWIGTYPE_p_ofNode); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Node_setPosition",2,SWIGTYPE_p_ofVec3f); } (arg1)->setPosition((ofVec3f const &)*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_setPosition(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Node_setPosition__SWIG_1(L);} } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Node_setPosition__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Node_setPosition'\n" " Possible C/C++ prototypes are:\n" - " ofNode::setPosition(float,float,float)\n" " ofNode::setPosition(ofVec3f const &)\n"); lua_error(L);return 0; } -static int _wrap_Node_setGlobalPosition__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; float arg2 ; - float arg3 ; float arg4 ; SWIG_check_num_args("ofNode::setGlobalPosition",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::setGlobalPosition",1,"ofNode *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofNode::setGlobalPosition",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofNode::setGlobalPosition",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofNode::setGlobalPosition",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_setGlobalPosition",1,SWIGTYPE_p_ofNode); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); (arg1)->setGlobalPosition(arg2,arg3,arg4); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_setGlobalPosition__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; - ofVec3f *arg2 = 0 ; SWIG_check_num_args("ofNode::setGlobalPosition",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::setGlobalPosition",1,"ofNode *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofNode::setGlobalPosition",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_setGlobalPosition",1,SWIGTYPE_p_ofNode); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Node_setGlobalPosition",2,SWIGTYPE_p_ofVec3f); } (arg1)->setGlobalPosition((ofVec3f const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_setGlobalPosition(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Node_setGlobalPosition__SWIG_1(L);} } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Node_setGlobalPosition__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Node_setGlobalPosition'\n" - " Possible C/C++ prototypes are:\n" " ofNode::setGlobalPosition(float,float,float)\n" - " ofNode::setGlobalPosition(ofVec3f const &)\n"); lua_error(L);return 0; } -static int _wrap_Node_setOrientation__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; - ofQuaternion *arg2 = 0 ; SWIG_check_num_args("ofNode::setOrientation",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::setOrientation",1,"ofNode *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofNode::setOrientation",2,"ofQuaternion const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_setOrientation",1,SWIGTYPE_p_ofNode); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Node_setOrientation",2,SWIGTYPE_p_ofQuaternion); } (arg1)->setOrientation((ofQuaternion const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_setOrientation__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; ofVec3f *arg2 = 0 ; - SWIG_check_num_args("ofNode::setOrientation",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::setOrientation",1,"ofNode *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofNode::setOrientation",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_setOrientation",1,SWIGTYPE_p_ofNode); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Node_setOrientation",2,SWIGTYPE_p_ofVec3f); } (arg1)->setOrientation((ofVec3f const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_setOrientation(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Node_setOrientation__SWIG_0(L);} } } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Node_setOrientation__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Node_setOrientation'\n" - " Possible C/C++ prototypes are:\n" " ofNode::setOrientation(ofQuaternion const &)\n" - " ofNode::setOrientation(ofVec3f const &)\n"); lua_error(L);return 0; } -static int _wrap_Node_setGlobalOrientation(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; - ofQuaternion *arg2 = 0 ; SWIG_check_num_args("ofNode::setGlobalOrientation",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::setGlobalOrientation",1,"ofNode *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofNode::setGlobalOrientation",2,"ofQuaternion const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_setGlobalOrientation",1,SWIGTYPE_p_ofNode); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Node_setGlobalOrientation",2,SWIGTYPE_p_ofQuaternion); } - (arg1)->setGlobalOrientation((ofQuaternion const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Node_setScale__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; float arg2 ; - SWIG_check_num_args("ofNode::setScale",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::setScale",1,"ofNode *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofNode::setScale",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_setScale",1,SWIGTYPE_p_ofNode); } - arg2 = (float)lua_tonumber(L, 2); (arg1)->setScale(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Node_setScale__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; float arg2 ; float arg3 ; - float arg4 ; SWIG_check_num_args("ofNode::setScale",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::setScale",1,"ofNode *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofNode::setScale",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofNode::setScale",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofNode::setScale",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_setScale",1,SWIGTYPE_p_ofNode); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - (arg1)->setScale(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_setScale__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; ofVec3f *arg2 = 0 ; - SWIG_check_num_args("ofNode::setScale",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::setScale",1,"ofNode *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofNode::setScale",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_setScale",1,SWIGTYPE_p_ofNode); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Node_setScale",2,SWIGTYPE_p_ofVec3f); } (arg1)->setScale((ofVec3f const &)*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_setScale(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Node_setScale__SWIG_2(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Node_setScale__SWIG_0(L);} } } - if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Node_setScale__SWIG_1(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Node_setScale'\n" " Possible C/C++ prototypes are:\n" - " ofNode::setScale(float)\n" " ofNode::setScale(float,float,float)\n" " ofNode::setScale(ofVec3f const &)\n"); - lua_error(L);return 0; } -static int _wrap_Node_move__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; float arg2 ; float arg3 ; - float arg4 ; SWIG_check_num_args("ofNode::move",4,4) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::move",1,"ofNode *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofNode::move",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofNode::move",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofNode::move",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_move",1,SWIGTYPE_p_ofNode); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - (arg1)->move(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_move__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; ofVec3f *arg2 = 0 ; - SWIG_check_num_args("ofNode::move",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::move",1,"ofNode *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofNode::move",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_move",1,SWIGTYPE_p_ofNode); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Node_move",2,SWIGTYPE_p_ofVec3f); } - (arg1)->move((ofVec3f const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_move(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Node_move__SWIG_1(L);} } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Node_move__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Node_move'\n" " Possible C/C++ prototypes are:\n" - " ofNode::move(float,float,float)\n" " ofNode::move(ofVec3f const &)\n"); lua_error(L);return 0; } -static int _wrap_Node_truck(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; float arg2 ; - SWIG_check_num_args("ofNode::truck",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::truck",1,"ofNode *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofNode::truck",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_truck",1,SWIGTYPE_p_ofNode); } - arg2 = (float)lua_tonumber(L, 2); (arg1)->truck(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_boom(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; float arg2 ; - SWIG_check_num_args("ofNode::boom",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::boom",1,"ofNode *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofNode::boom",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_boom",1,SWIGTYPE_p_ofNode); } - arg2 = (float)lua_tonumber(L, 2); (arg1)->boom(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_dolly(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; float arg2 ; - SWIG_check_num_args("ofNode::dolly",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::dolly",1,"ofNode *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofNode::dolly",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_dolly",1,SWIGTYPE_p_ofNode); } - arg2 = (float)lua_tonumber(L, 2); (arg1)->dolly(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_tilt(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; float arg2 ; - SWIG_check_num_args("ofNode::tilt",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::tilt",1,"ofNode *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofNode::tilt",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_tilt",1,SWIGTYPE_p_ofNode); } - arg2 = (float)lua_tonumber(L, 2); (arg1)->tilt(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_pan(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; float arg2 ; - SWIG_check_num_args("ofNode::pan",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::pan",1,"ofNode *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofNode::pan",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_pan",1,SWIGTYPE_p_ofNode); } - arg2 = (float)lua_tonumber(L, 2); (arg1)->pan(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_roll(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; float arg2 ; - SWIG_check_num_args("ofNode::roll",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::roll",1,"ofNode *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofNode::roll",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_roll",1,SWIGTYPE_p_ofNode); } - arg2 = (float)lua_tonumber(L, 2); (arg1)->roll(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_rotate__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; ofQuaternion *arg2 = 0 ; - SWIG_check_num_args("ofNode::rotate",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::rotate",1,"ofNode *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofNode::rotate",2,"ofQuaternion const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_rotate",1,SWIGTYPE_p_ofNode); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Node_rotate",2,SWIGTYPE_p_ofQuaternion); } (arg1)->rotate((ofQuaternion const &)*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_rotate__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; float arg2 ; - ofVec3f *arg3 = 0 ; SWIG_check_num_args("ofNode::rotate",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::rotate",1,"ofNode *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofNode::rotate",2,"float"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofNode::rotate",3,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_rotate",1,SWIGTYPE_p_ofNode); } - arg2 = (float)lua_tonumber(L, 2); if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Node_rotate",3,SWIGTYPE_p_ofVec3f); } (arg1)->rotate(arg2,(ofVec3f const &)*arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_rotate__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; float arg2 ; float arg3 ; - float arg4 ; float arg5 ; SWIG_check_num_args("ofNode::rotate",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::rotate",1,"ofNode *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofNode::rotate",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofNode::rotate",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofNode::rotate",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofNode::rotate",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_rotate",1,SWIGTYPE_p_ofNode); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); (arg1)->rotate(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Node_rotate(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Node_rotate__SWIG_0(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Node_rotate__SWIG_1(L);} } } } if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Node_rotate__SWIG_2(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Node_rotate'\n" " Possible C/C++ prototypes are:\n" - " ofNode::rotate(ofQuaternion const &)\n" " ofNode::rotate(float,ofVec3f const &)\n" - " ofNode::rotate(float,float,float,float)\n"); lua_error(L);return 0; } -static int _wrap_Node_rotateAround__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; - ofQuaternion *arg2 = 0 ; ofVec3f *arg3 = 0 ; SWIG_check_num_args("ofNode::rotateAround",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::rotateAround",1,"ofNode *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofNode::rotateAround",2,"ofQuaternion const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofNode::rotateAround",3,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_rotateAround",1,SWIGTYPE_p_ofNode); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Node_rotateAround",2,SWIGTYPE_p_ofQuaternion); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Node_rotateAround",3,SWIGTYPE_p_ofVec3f); } - (arg1)->rotateAround((ofQuaternion const &)*arg2,(ofVec3f const &)*arg3); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Node_rotateAround__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; float arg2 ; - ofVec3f *arg3 = 0 ; ofVec3f *arg4 = 0 ; SWIG_check_num_args("ofNode::rotateAround",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::rotateAround",1,"ofNode *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofNode::rotateAround",2,"float"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofNode::rotateAround",3,"ofVec3f const &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofNode::rotateAround",4,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_rotateAround",1,SWIGTYPE_p_ofNode); } arg2 = (float)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Node_rotateAround",3,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Node_rotateAround",4,SWIGTYPE_p_ofVec3f); } - (arg1)->rotateAround(arg2,(ofVec3f const &)*arg3,(ofVec3f const &)*arg4); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Node_rotateAround(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Node_rotateAround__SWIG_0(L);} } } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Node_rotateAround__SWIG_1(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Node_rotateAround'\n" " Possible C/C++ prototypes are:\n" - " ofNode::rotateAround(ofQuaternion const &,ofVec3f const &)\n" - " ofNode::rotateAround(float,ofVec3f const &,ofVec3f const &)\n"); lua_error(L);return 0; } -static int _wrap_Node_lookAt__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; ofVec3f *arg2 = 0 ; - SWIG_check_num_args("ofNode::lookAt",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::lookAt",1,"ofNode *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofNode::lookAt",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_lookAt",1,SWIGTYPE_p_ofNode); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Node_lookAt",2,SWIGTYPE_p_ofVec3f); } - (arg1)->lookAt((ofVec3f const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_lookAt__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; ofVec3f *arg2 = 0 ; - ofVec3f arg3 ; ofVec3f *argp3 ; SWIG_check_num_args("ofNode::lookAt",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::lookAt",1,"ofNode *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofNode::lookAt",2,"ofVec3f const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofNode::lookAt",3,"ofVec3f"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_lookAt",1,SWIGTYPE_p_ofNode); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Node_lookAt",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&argp3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Node_lookAt",3,SWIGTYPE_p_ofVec3f); } arg3 = *argp3; (arg1)->lookAt((ofVec3f const &)*arg2,arg3); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_lookAt__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; ofNode *arg2 = 0 ; - SWIG_check_num_args("ofNode::lookAt",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::lookAt",1,"ofNode *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofNode::lookAt",2,"ofNode const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_lookAt",1,SWIGTYPE_p_ofNode); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_lookAt",2,SWIGTYPE_p_ofNode); } - (arg1)->lookAt((ofNode const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_lookAt__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; ofNode *arg2 = 0 ; - ofVec3f *arg3 = 0 ; SWIG_check_num_args("ofNode::lookAt",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::lookAt",1,"ofNode *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofNode::lookAt",2,"ofNode const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofNode::lookAt",3,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_lookAt",1,SWIGTYPE_p_ofNode); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_lookAt",2,SWIGTYPE_p_ofNode); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Node_lookAt",3,SWIGTYPE_p_ofVec3f); } - (arg1)->lookAt((ofNode const &)*arg2,(ofVec3f const &)*arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Node_lookAt(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Node_lookAt__SWIG_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Node_lookAt__SWIG_2(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Node_lookAt__SWIG_1(L);} } } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Node_lookAt__SWIG_3(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Node_lookAt'\n" " Possible C/C++ prototypes are:\n" - " ofNode::lookAt(ofVec3f const &)\n" " ofNode::lookAt(ofVec3f const &,ofVec3f)\n" " ofNode::lookAt(ofNode const &)\n" - " ofNode::lookAt(ofNode const &,ofVec3f const &)\n"); lua_error(L);return 0; } -static int _wrap_Node_orbit__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; float arg2 ; float arg3 ; - float arg4 ; ofVec3f *arg5 = 0 ; SWIG_check_num_args("ofNode::orbit",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::orbit",1,"ofNode *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofNode::orbit",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofNode::orbit",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofNode::orbit",4,"float"); - if(!lua_isuserdata(L,5)) SWIG_fail_arg("ofNode::orbit",5,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_orbit",1,SWIGTYPE_p_ofNode); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Node_orbit",5,SWIGTYPE_p_ofVec3f); } - (arg1)->orbit(arg2,arg3,arg4,(ofVec3f const &)*arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_orbit__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; float arg2 ; float arg3 ; - float arg4 ; SWIG_check_num_args("ofNode::orbit",4,4) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::orbit",1,"ofNode *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofNode::orbit",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofNode::orbit",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofNode::orbit",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_orbit",1,SWIGTYPE_p_ofNode); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - (arg1)->orbit(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_orbit__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; float arg2 ; float arg3 ; - float arg4 ; ofNode *arg5 = 0 ; SWIG_check_num_args("ofNode::orbit",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::orbit",1,"ofNode *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofNode::orbit",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofNode::orbit",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofNode::orbit",4,"float"); - if(!lua_isuserdata(L,5)) SWIG_fail_arg("ofNode::orbit",5,"ofNode &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_orbit",1,SWIGTYPE_p_ofNode); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_orbit",5,SWIGTYPE_p_ofNode); } - (arg1)->orbit(arg2,arg3,arg4,*arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_orbit(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 4) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Node_orbit__SWIG_1(L);} } } } } - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[4])==0 || SWIG_ConvertPtr(L,argv[4], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Node_orbit__SWIG_0(L);} } } } } } if (argc == 5) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[4])==0 || SWIG_ConvertPtr(L,argv[4], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Node_orbit__SWIG_2(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Node_orbit'\n" " Possible C/C++ prototypes are:\n" - " ofNode::orbit(float,float,float,ofVec3f const &)\n" " ofNode::orbit(float,float,float)\n" - " ofNode::orbit(float,float,float,ofNode &)\n"); lua_error(L);return 0; } -static int _wrap_Node_transformGL__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; - ofBaseRenderer *arg2 = (ofBaseRenderer *) 0 ; SWIG_check_num_args("ofNode::transformGL",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::transformGL",1,"ofNode const *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofNode::transformGL",2,"ofBaseRenderer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_transformGL",1,SWIGTYPE_p_ofNode); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBaseRenderer,0))){ - SWIG_fail_ptr("Node_transformGL",2,SWIGTYPE_p_ofBaseRenderer); } ((ofNode const *)arg1)->transformGL(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_transformGL__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; - SWIG_check_num_args("ofNode::transformGL",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::transformGL",1,"ofNode const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_transformGL",1,SWIGTYPE_p_ofNode); } ((ofNode const *)arg1)->transformGL(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_transformGL(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Node_transformGL__SWIG_1(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBaseRenderer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Node_transformGL__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Node_transformGL'\n" " Possible C/C++ prototypes are:\n" - " ofNode::transformGL(ofBaseRenderer *) const\n" " ofNode::transformGL() const\n"); lua_error(L);return 0; } -static int _wrap_Node_restoreTransformGL__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; - ofBaseRenderer *arg2 = (ofBaseRenderer *) 0 ; SWIG_check_num_args("ofNode::restoreTransformGL",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::restoreTransformGL",1,"ofNode const *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofNode::restoreTransformGL",2,"ofBaseRenderer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_restoreTransformGL",1,SWIGTYPE_p_ofNode); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBaseRenderer,0))){ - SWIG_fail_ptr("Node_restoreTransformGL",2,SWIGTYPE_p_ofBaseRenderer); } ((ofNode const *)arg1)->restoreTransformGL(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_restoreTransformGL__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; - SWIG_check_num_args("ofNode::restoreTransformGL",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::restoreTransformGL",1,"ofNode const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_restoreTransformGL",1,SWIGTYPE_p_ofNode); } ((ofNode const *)arg1)->restoreTransformGL(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_restoreTransformGL(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Node_restoreTransformGL__SWIG_1(L);} } if (argc == 2) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBaseRenderer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Node_restoreTransformGL__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Node_restoreTransformGL'\n" - " Possible C/C++ prototypes are:\n" " ofNode::restoreTransformGL(ofBaseRenderer *) const\n" - " ofNode::restoreTransformGL() const\n"); lua_error(L);return 0; } -static int _wrap_Node_resetTransform(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; - SWIG_check_num_args("ofNode::resetTransform",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::resetTransform",1,"ofNode *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_resetTransform",1,SWIGTYPE_p_ofNode); } (arg1)->resetTransform(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_customDraw__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; - ofBaseRenderer *arg2 = (ofBaseRenderer *) 0 ; SWIG_check_num_args("ofNode::customDraw",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::customDraw",1,"ofNode const *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofNode::customDraw",2,"ofBaseRenderer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_customDraw",1,SWIGTYPE_p_ofNode); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBaseRenderer,0))){ - SWIG_fail_ptr("Node_customDraw",2,SWIGTYPE_p_ofBaseRenderer); } - ((ofNode const *)arg1)->customDraw((ofBaseRenderer const *)arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Node_customDraw__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; - SWIG_check_num_args("ofNode::customDraw",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::customDraw",1,"ofNode *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_customDraw",1,SWIGTYPE_p_ofNode); } (arg1)->customDraw(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Node_customDraw(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Node_customDraw__SWIG_1(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBaseRenderer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Node_customDraw__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Node_customDraw'\n" " Possible C/C++ prototypes are:\n" - " ofNode::customDraw(ofBaseRenderer const *) const\n" " ofNode::customDraw()\n"); lua_error(L);return 0; } -static int _wrap_Node_draw(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; - SWIG_check_num_args("ofNode::draw",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::draw",1,"ofNode const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_draw",1,SWIGTYPE_p_ofNode); } - ((ofNode const *)arg1)->draw(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_Node(void *obj) { -ofNode *arg1 = (ofNode *) obj; -delete arg1; -} -static int _proxy__wrap_new_Node(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_Node); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_Node_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_Node_methods[]= { - { "setParent", _wrap_Node_setParent}, - { "clearParent", _wrap_Node_clearParent}, - { "getParent", _wrap_Node_getParent}, - { "getPosition", _wrap_Node_getPosition}, - { "getX", _wrap_Node_getX}, - { "getY", _wrap_Node_getY}, - { "getZ", _wrap_Node_getZ}, - { "getXAxis", _wrap_Node_getXAxis}, - { "getYAxis", _wrap_Node_getYAxis}, - { "getZAxis", _wrap_Node_getZAxis}, - { "getSideDir", _wrap_Node_getSideDir}, - { "getLookAtDir", _wrap_Node_getLookAtDir}, - { "getUpDir", _wrap_Node_getUpDir}, - { "getPitch", _wrap_Node_getPitch}, - { "getHeading", _wrap_Node_getHeading}, - { "getRoll", _wrap_Node_getRoll}, - { "getOrientationQuat", _wrap_Node_getOrientationQuat}, - { "getOrientationEuler", _wrap_Node_getOrientationEuler}, - { "getScale", _wrap_Node_getScale}, - { "getLocalTransformMatrix", _wrap_Node_getLocalTransformMatrix}, - { "getGlobalTransformMatrix", _wrap_Node_getGlobalTransformMatrix}, - { "getGlobalPosition", _wrap_Node_getGlobalPosition}, - { "getGlobalOrientation", _wrap_Node_getGlobalOrientation}, - { "getGlobalScale", _wrap_Node_getGlobalScale}, - { "setTransformMatrix", _wrap_Node_setTransformMatrix}, - { "setPosition", _wrap_Node_setPosition}, - { "setGlobalPosition", _wrap_Node_setGlobalPosition}, - { "setOrientation", _wrap_Node_setOrientation}, - { "setGlobalOrientation", _wrap_Node_setGlobalOrientation}, - { "setScale", _wrap_Node_setScale}, - { "move", _wrap_Node_move}, - { "truck", _wrap_Node_truck}, - { "boom", _wrap_Node_boom}, - { "dolly", _wrap_Node_dolly}, - { "tilt", _wrap_Node_tilt}, - { "pan", _wrap_Node_pan}, - { "roll", _wrap_Node_roll}, - { "rotate", _wrap_Node_rotate}, - { "rotateAround", _wrap_Node_rotateAround}, - { "lookAt", _wrap_Node_lookAt}, - { "orbit", _wrap_Node_orbit}, - { "transformGL", _wrap_Node_transformGL}, - { "restoreTransformGL", _wrap_Node_restoreTransformGL}, - { "resetTransform", _wrap_Node_resetTransform}, - { "customDraw", _wrap_Node_customDraw}, - { "draw", _wrap_Node_draw}, - {0,0} -}; -static swig_lua_method swig_Node_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_Node_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_Node_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_Node_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_Node_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_Node_Sf_SwigStatic = { - "Node", - swig_Node_Sf_SwigStatic_methods, - swig_Node_Sf_SwigStatic_attributes, - swig_Node_Sf_SwigStatic_constants, - swig_Node_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_Node_bases[] = {0}; -static const char *swig_Node_base_names[] = {0}; -static swig_lua_class _wrap_class_Node = { "Node", "Node", &SWIGTYPE_p_ofNode,_proxy__wrap_new_Node, swig_delete_Node, swig_Node_methods, swig_Node_attributes, &swig_Node_Sf_SwigStatic, swig_Node_meta, swig_Node_bases, swig_Node_base_names }; - -static int _wrap_drawAxis(lua_State* L) { int SWIG_arg = 0; float arg1 ; SWIG_check_num_args("ofDrawAxis",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawAxis",1,"float"); arg1 = (float)lua_tonumber(L, 1); ofDrawAxis(arg1); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawGrid__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; size_t arg2 ; bool arg3 ; bool arg4 ; - bool arg5 ; bool arg6 ; SWIG_check_num_args("ofDrawGrid",6,6) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawGrid",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawGrid",2,"size_t"); if(!lua_isboolean(L,3)) SWIG_fail_arg("ofDrawGrid",3,"bool"); - if(!lua_isboolean(L,4)) SWIG_fail_arg("ofDrawGrid",4,"bool"); if(!lua_isboolean(L,5)) SWIG_fail_arg("ofDrawGrid",5,"bool"); - if(!lua_isboolean(L,6)) SWIG_fail_arg("ofDrawGrid",6,"bool"); arg1 = (float)lua_tonumber(L, 1); - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - arg3 = (lua_toboolean(L, 3)!=0); arg4 = (lua_toboolean(L, 4)!=0); arg5 = (lua_toboolean(L, 5)!=0); - arg6 = (lua_toboolean(L, 6)!=0); ofDrawGrid(arg1,arg2,arg3,arg4,arg5,arg6); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_drawGrid__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; size_t arg2 ; bool arg3 ; bool arg4 ; - bool arg5 ; SWIG_check_num_args("ofDrawGrid",5,5) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawGrid",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawGrid",2,"size_t"); if(!lua_isboolean(L,3)) SWIG_fail_arg("ofDrawGrid",3,"bool"); - if(!lua_isboolean(L,4)) SWIG_fail_arg("ofDrawGrid",4,"bool"); if(!lua_isboolean(L,5)) SWIG_fail_arg("ofDrawGrid",5,"bool"); - arg1 = (float)lua_tonumber(L, 1); SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") - arg2 = (size_t)lua_tonumber(L, 2); arg3 = (lua_toboolean(L, 3)!=0); arg4 = (lua_toboolean(L, 4)!=0); - arg5 = (lua_toboolean(L, 5)!=0); ofDrawGrid(arg1,arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_drawGrid__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; size_t arg2 ; bool arg3 ; bool arg4 ; - SWIG_check_num_args("ofDrawGrid",4,4) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawGrid",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawGrid",2,"size_t"); if(!lua_isboolean(L,3)) SWIG_fail_arg("ofDrawGrid",3,"bool"); - if(!lua_isboolean(L,4)) SWIG_fail_arg("ofDrawGrid",4,"bool"); arg1 = (float)lua_tonumber(L, 1); - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - arg3 = (lua_toboolean(L, 3)!=0); arg4 = (lua_toboolean(L, 4)!=0); ofDrawGrid(arg1,arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawGrid__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; size_t arg2 ; bool arg3 ; - SWIG_check_num_args("ofDrawGrid",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawGrid",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawGrid",2,"size_t"); if(!lua_isboolean(L,3)) SWIG_fail_arg("ofDrawGrid",3,"bool"); - arg1 = (float)lua_tonumber(L, 1); SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") - arg2 = (size_t)lua_tonumber(L, 2); arg3 = (lua_toboolean(L, 3)!=0); ofDrawGrid(arg1,arg2,arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawGrid__SWIG_4(lua_State* L) { int SWIG_arg = 0; float arg1 ; size_t arg2 ; - SWIG_check_num_args("ofDrawGrid",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawGrid",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawGrid",2,"size_t"); arg1 = (float)lua_tonumber(L, 1); - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - ofDrawGrid(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawGrid__SWIG_5(lua_State* L) { int SWIG_arg = 0; float arg1 ; SWIG_check_num_args("ofDrawGrid",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawGrid",1,"float"); arg1 = (float)lua_tonumber(L, 1); ofDrawGrid(arg1); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawGrid__SWIG_6(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofDrawGrid",0,0) ofDrawGrid(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawGrid(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_drawGrid__SWIG_6(L);} if (argc == 1) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { - return _wrap_drawGrid__SWIG_5(L);} } if (argc == 2) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_drawGrid__SWIG_4(L);} } } if (argc == 3) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } - if (_v) { return _wrap_drawGrid__SWIG_3(L);} } } } if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { { - _v = lua_isboolean(L,argv[3]); } if (_v) { return _wrap_drawGrid__SWIG_2(L);} } } } } if (argc == 5) { int _v; - { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } - if (_v) { { _v = lua_isboolean(L,argv[3]); } if (_v) { { _v = lua_isboolean(L,argv[4]); } if (_v) { - return _wrap_drawGrid__SWIG_1(L);} } } } } } if (argc == 6) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { { - _v = lua_isboolean(L,argv[3]); } if (_v) { { _v = lua_isboolean(L,argv[4]); } if (_v) { { - _v = lua_isboolean(L,argv[5]); } if (_v) { return _wrap_drawGrid__SWIG_0(L);} } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'drawGrid'\n" " Possible C/C++ prototypes are:\n" - " ofDrawGrid(float,size_t,bool,bool,bool,bool)\n" " ofDrawGrid(float,size_t,bool,bool,bool)\n" - " ofDrawGrid(float,size_t,bool,bool)\n" " ofDrawGrid(float,size_t,bool)\n" " ofDrawGrid(float,size_t)\n" - " ofDrawGrid(float)\n" " ofDrawGrid()\n"); lua_error(L);return 0; } -static int _wrap_drawGridPlane__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; size_t arg2 ; bool arg3 ; - SWIG_check_num_args("ofDrawGridPlane",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawGridPlane",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawGridPlane",2,"size_t"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofDrawGridPlane",3,"bool"); arg1 = (float)lua_tonumber(L, 1); - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - arg3 = (lua_toboolean(L, 3)!=0); ofDrawGridPlane(arg1,arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_drawGridPlane__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; size_t arg2 ; - SWIG_check_num_args("ofDrawGridPlane",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawGridPlane",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawGridPlane",2,"size_t"); arg1 = (float)lua_tonumber(L, 1); - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - ofDrawGridPlane(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawGridPlane__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; SWIG_check_num_args("ofDrawGridPlane",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawGridPlane",1,"float"); arg1 = (float)lua_tonumber(L, 1); ofDrawGridPlane(arg1); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawGridPlane__SWIG_3(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofDrawGridPlane",0,0) - ofDrawGridPlane(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawGridPlane(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_drawGridPlane__SWIG_3(L);} if (argc == 1) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { - return _wrap_drawGridPlane__SWIG_2(L);} } if (argc == 2) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_drawGridPlane__SWIG_1(L);} } } if (argc == 3) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } - if (_v) { return _wrap_drawGridPlane__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'drawGridPlane'\n" " Possible C/C++ prototypes are:\n" - " ofDrawGridPlane(float,size_t,bool)\n" " ofDrawGridPlane(float,size_t)\n" " ofDrawGridPlane(float)\n" - " ofDrawGridPlane()\n"); lua_error(L);return 0; } -static int _wrap_drawArrow__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = 0 ; ofVec3f *arg2 = 0 ; float arg3 ; - SWIG_check_num_args("ofDrawArrow",3,3) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofDrawArrow",1,"ofVec3f const &"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofDrawArrow",2,"ofVec3f const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawArrow",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("drawArrow",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("drawArrow",2,SWIGTYPE_p_ofVec3f); } - arg3 = (float)lua_tonumber(L, 3); ofDrawArrow((ofVec3f const &)*arg1,(ofVec3f const &)*arg2,arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawArrow__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = 0 ; ofVec3f *arg2 = 0 ; - SWIG_check_num_args("ofDrawArrow",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofDrawArrow",1,"ofVec3f const &"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofDrawArrow",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("drawArrow",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("drawArrow",2,SWIGTYPE_p_ofVec3f); } - ofDrawArrow((ofVec3f const &)*arg1,(ofVec3f const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_drawArrow(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_drawArrow__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_drawArrow__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'drawArrow'\n" " Possible C/C++ prototypes are:\n" - " ofDrawArrow(ofVec3f const &,ofVec3f const &,float)\n" " ofDrawArrow(ofVec3f const &,ofVec3f const &)\n"); - lua_error(L);return 0; } -static int _wrap_drawRotationAxes__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; int arg3 ; - SWIG_check_num_args("ofDrawRotationAxes",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawRotationAxes",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawRotationAxes",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawRotationAxes",3,"int"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); ofDrawRotationAxes(arg1,arg2,arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawRotationAxes__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; - SWIG_check_num_args("ofDrawRotationAxes",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawRotationAxes",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawRotationAxes",2,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); ofDrawRotationAxes(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_drawRotationAxes__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; - SWIG_check_num_args("ofDrawRotationAxes",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawRotationAxes",1,"float"); - arg1 = (float)lua_tonumber(L, 1); ofDrawRotationAxes(arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_drawRotationAxes(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_drawRotationAxes__SWIG_2(L);} } if (argc == 2) { int _v; - { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_drawRotationAxes__SWIG_1(L);} } } if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { - { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_drawRotationAxes__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'drawRotationAxes'\n" " Possible C/C++ prototypes are:\n" - " ofDrawRotationAxes(float,float,int)\n" " ofDrawRotationAxes(float,float)\n" " ofDrawRotationAxes(float)\n"); - lua_error(L);return 0; } -static int _wrap_new_Camera(lua_State* L) { int SWIG_arg = 0; ofCamera *result = 0 ; - SWIG_check_num_args("ofCamera::ofCamera",0,0) result = (ofCamera *)new ofCamera(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofCamera,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Camera_setFov(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; float arg2 ; - SWIG_check_num_args("ofCamera::setFov",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::setFov",1,"ofCamera *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofCamera::setFov",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_setFov",1,SWIGTYPE_p_ofCamera); } arg2 = (float)lua_tonumber(L, 2); (arg1)->setFov(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Camera_setNearClip(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; float arg2 ; - SWIG_check_num_args("ofCamera::setNearClip",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::setNearClip",1,"ofCamera *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofCamera::setNearClip",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_setNearClip",1,SWIGTYPE_p_ofCamera); } arg2 = (float)lua_tonumber(L, 2); (arg1)->setNearClip(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Camera_setFarClip(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; float arg2 ; - SWIG_check_num_args("ofCamera::setFarClip",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::setFarClip",1,"ofCamera *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofCamera::setFarClip",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_setFarClip",1,SWIGTYPE_p_ofCamera); } arg2 = (float)lua_tonumber(L, 2); (arg1)->setFarClip(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Camera_setLensOffset(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; ofVec2f *arg2 = 0 ; - SWIG_check_num_args("ofCamera::setLensOffset",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::setLensOffset",1,"ofCamera *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofCamera::setLensOffset",2,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_setLensOffset",1,SWIGTYPE_p_ofCamera); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Camera_setLensOffset",2,SWIGTYPE_p_ofVec2f); } (arg1)->setLensOffset((ofVec2f const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Camera_setAspectRatio(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; float arg2 ; - SWIG_check_num_args("ofCamera::setAspectRatio",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::setAspectRatio",1,"ofCamera *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofCamera::setAspectRatio",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_setAspectRatio",1,SWIGTYPE_p_ofCamera); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setAspectRatio(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Camera_setForceAspectRatio(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; bool arg2 ; - SWIG_check_num_args("ofCamera::setForceAspectRatio",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::setForceAspectRatio",1,"ofCamera *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofCamera::setForceAspectRatio",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_setForceAspectRatio",1,SWIGTYPE_p_ofCamera); } arg2 = (lua_toboolean(L, 2)!=0); - (arg1)->setForceAspectRatio(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Camera_getFov(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; float result; - SWIG_check_num_args("ofCamera::getFov",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::getFov",1,"ofCamera const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_getFov",1,SWIGTYPE_p_ofCamera); } result = (float)((ofCamera const *)arg1)->getFov(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Camera_getNearClip(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; float result; - SWIG_check_num_args("ofCamera::getNearClip",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::getNearClip",1,"ofCamera const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_getNearClip",1,SWIGTYPE_p_ofCamera); } result = (float)((ofCamera const *)arg1)->getNearClip(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Camera_getFarClip(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; float result; - SWIG_check_num_args("ofCamera::getFarClip",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::getFarClip",1,"ofCamera const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_getFarClip",1,SWIGTYPE_p_ofCamera); } result = (float)((ofCamera const *)arg1)->getFarClip(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Camera_getLensOffset(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; ofVec2f result; - SWIG_check_num_args("ofCamera::getLensOffset",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::getLensOffset",1,"ofCamera const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_getLensOffset",1,SWIGTYPE_p_ofCamera); } result = ((ofCamera const *)arg1)->getLensOffset(); { - ofVec2f * resultptr = new ofVec2f((const ofVec2f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Camera_getForceAspectRatio(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; bool result; - SWIG_check_num_args("ofCamera::getForceAspectRatio",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::getForceAspectRatio",1,"ofCamera const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_getForceAspectRatio",1,SWIGTYPE_p_ofCamera); } - result = (bool)((ofCamera const *)arg1)->getForceAspectRatio(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Camera_getAspectRatio(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; float result; - SWIG_check_num_args("ofCamera::getAspectRatio",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::getAspectRatio",1,"ofCamera const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_getAspectRatio",1,SWIGTYPE_p_ofCamera); } result = (float)((ofCamera const *)arg1)->getAspectRatio(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Camera_setupPerspective__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; bool arg2 ; - float arg3 ; float arg4 ; float arg5 ; ofVec2f *arg6 = 0 ; SWIG_check_num_args("ofCamera::setupPerspective",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::setupPerspective",1,"ofCamera *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofCamera::setupPerspective",2,"bool"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofCamera::setupPerspective",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofCamera::setupPerspective",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofCamera::setupPerspective",5,"float"); - if(!lua_isuserdata(L,6)) SWIG_fail_arg("ofCamera::setupPerspective",6,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_setupPerspective",1,SWIGTYPE_p_ofCamera); } arg2 = (lua_toboolean(L, 2)!=0); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,6,(void**)&arg6,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Camera_setupPerspective",6,SWIGTYPE_p_ofVec2f); } - (arg1)->setupPerspective(arg2,arg3,arg4,arg5,(ofVec2f const &)*arg6); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Camera_setupPerspective__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; bool arg2 ; - float arg3 ; float arg4 ; float arg5 ; SWIG_check_num_args("ofCamera::setupPerspective",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::setupPerspective",1,"ofCamera *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofCamera::setupPerspective",2,"bool"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofCamera::setupPerspective",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofCamera::setupPerspective",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofCamera::setupPerspective",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_setupPerspective",1,SWIGTYPE_p_ofCamera); } arg2 = (lua_toboolean(L, 2)!=0); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - (arg1)->setupPerspective(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Camera_setupPerspective__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; bool arg2 ; - float arg3 ; float arg4 ; SWIG_check_num_args("ofCamera::setupPerspective",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::setupPerspective",1,"ofCamera *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofCamera::setupPerspective",2,"bool"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofCamera::setupPerspective",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofCamera::setupPerspective",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_setupPerspective",1,SWIGTYPE_p_ofCamera); } arg2 = (lua_toboolean(L, 2)!=0); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); (arg1)->setupPerspective(arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Camera_setupPerspective__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; bool arg2 ; - float arg3 ; SWIG_check_num_args("ofCamera::setupPerspective",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::setupPerspective",1,"ofCamera *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofCamera::setupPerspective",2,"bool"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofCamera::setupPerspective",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_setupPerspective",1,SWIGTYPE_p_ofCamera); } arg2 = (lua_toboolean(L, 2)!=0); - arg3 = (float)lua_tonumber(L, 3); (arg1)->setupPerspective(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Camera_setupPerspective__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; bool arg2 ; - SWIG_check_num_args("ofCamera::setupPerspective",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::setupPerspective",1,"ofCamera *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofCamera::setupPerspective",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_setupPerspective",1,SWIGTYPE_p_ofCamera); } arg2 = (lua_toboolean(L, 2)!=0); - (arg1)->setupPerspective(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Camera_setupPerspective__SWIG_5(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; - SWIG_check_num_args("ofCamera::setupPerspective",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::setupPerspective",1,"ofCamera *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_setupPerspective",1,SWIGTYPE_p_ofCamera); } (arg1)->setupPerspective(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Camera_setupPerspective(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); - if (argc == 1) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCamera, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Camera_setupPerspective__SWIG_5(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCamera, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_Camera_setupPerspective__SWIG_4(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCamera, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Camera_setupPerspective__SWIG_3(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCamera, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Camera_setupPerspective__SWIG_2(L);} } } } } - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCamera, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Camera_setupPerspective__SWIG_1(L);} } } } } } if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCamera, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[5])==0 || SWIG_ConvertPtr(L,argv[5], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Camera_setupPerspective__SWIG_0(L);} } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Camera_setupPerspective'\n" - " Possible C/C++ prototypes are:\n" " ofCamera::setupPerspective(bool,float,float,float,ofVec2f const &)\n" - " ofCamera::setupPerspective(bool,float,float,float)\n" " ofCamera::setupPerspective(bool,float,float)\n" - " ofCamera::setupPerspective(bool,float)\n" " ofCamera::setupPerspective(bool)\n" " ofCamera::setupPerspective()\n"); - lua_error(L);return 0; } -static int _wrap_Camera_setupOffAxisViewPortal(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; - ofVec3f *arg2 = 0 ; ofVec3f *arg3 = 0 ; ofVec3f *arg4 = 0 ; SWIG_check_num_args("ofCamera::setupOffAxisViewPortal",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::setupOffAxisViewPortal",1,"ofCamera *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofCamera::setupOffAxisViewPortal",2,"ofVec3f const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofCamera::setupOffAxisViewPortal",3,"ofVec3f const &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofCamera::setupOffAxisViewPortal",4,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_setupOffAxisViewPortal",1,SWIGTYPE_p_ofCamera); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Camera_setupOffAxisViewPortal",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Camera_setupOffAxisViewPortal",3,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Camera_setupOffAxisViewPortal",4,SWIGTYPE_p_ofVec3f); } - (arg1)->setupOffAxisViewPortal((ofVec3f const &)*arg2,(ofVec3f const &)*arg3,(ofVec3f const &)*arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Camera_setVFlip(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; bool arg2 ; - SWIG_check_num_args("ofCamera::setVFlip",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::setVFlip",1,"ofCamera *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofCamera::setVFlip",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_setVFlip",1,SWIGTYPE_p_ofCamera); } arg2 = (lua_toboolean(L, 2)!=0); (arg1)->setVFlip(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Camera_isVFlipped(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; bool result; - SWIG_check_num_args("ofCamera::isVFlipped",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::isVFlipped",1,"ofCamera const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_isVFlipped",1,SWIGTYPE_p_ofCamera); } result = (bool)((ofCamera const *)arg1)->isVFlipped(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Camera_enableOrtho(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; - SWIG_check_num_args("ofCamera::enableOrtho",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::enableOrtho",1,"ofCamera *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_enableOrtho",1,SWIGTYPE_p_ofCamera); } (arg1)->enableOrtho(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Camera_disableOrtho(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; - SWIG_check_num_args("ofCamera::disableOrtho",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::disableOrtho",1,"ofCamera *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_disableOrtho",1,SWIGTYPE_p_ofCamera); } (arg1)->disableOrtho(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Camera_getOrtho(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; bool result; - SWIG_check_num_args("ofCamera::getOrtho",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::getOrtho",1,"ofCamera const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_getOrtho",1,SWIGTYPE_p_ofCamera); } result = (bool)((ofCamera const *)arg1)->getOrtho(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Camera_getImagePlaneDistance__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; - ofRectangle arg2 ; ofRectangle *argp2 ; float result; SWIG_check_num_args("ofCamera::getImagePlaneDistance",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::getImagePlaneDistance",1,"ofCamera const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofCamera::getImagePlaneDistance",2,"ofRectangle"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_getImagePlaneDistance",1,SWIGTYPE_p_ofCamera); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Camera_getImagePlaneDistance",2,SWIGTYPE_p_ofRectangle); } arg2 = *argp2; - result = (float)((ofCamera const *)arg1)->getImagePlaneDistance(arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Camera_getImagePlaneDistance__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; - float result; SWIG_check_num_args("ofCamera::getImagePlaneDistance",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::getImagePlaneDistance",1,"ofCamera const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_getImagePlaneDistance",1,SWIGTYPE_p_ofCamera); } - result = (float)((ofCamera const *)arg1)->getImagePlaneDistance(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Camera_getImagePlaneDistance(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); - if (argc == 1) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCamera, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Camera_getImagePlaneDistance__SWIG_1(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCamera, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Camera_getImagePlaneDistance__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Camera_getImagePlaneDistance'\n" - " Possible C/C++ prototypes are:\n" " ofCamera::getImagePlaneDistance(ofRectangle) const\n" - " ofCamera::getImagePlaneDistance() const\n"); lua_error(L);return 0; } -static int _wrap_Camera_beginCamera__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; - ofRectangle arg2 ; ofRectangle *argp2 ; SWIG_check_num_args("ofCamera::begin",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::begin",1,"ofCamera *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofCamera::begin",2,"ofRectangle"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_beginCamera",1,SWIGTYPE_p_ofCamera); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Camera_beginCamera",2,SWIGTYPE_p_ofRectangle); } arg2 = *argp2; (arg1)->begin(arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Camera_beginCamera__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; - SWIG_check_num_args("ofCamera::begin",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::begin",1,"ofCamera *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_beginCamera",1,SWIGTYPE_p_ofCamera); } (arg1)->begin(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Camera_beginCamera(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCamera, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Camera_beginCamera__SWIG_1(L);} } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCamera, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Camera_beginCamera__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Camera_beginCamera'\n" " Possible C/C++ prototypes are:\n" - " ofCamera::begin(ofRectangle)\n" " ofCamera::begin()\n"); lua_error(L);return 0; } -static int _wrap_Camera_endCamera(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; - SWIG_check_num_args("ofCamera::end",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::end",1,"ofCamera *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_endCamera",1,SWIGTYPE_p_ofCamera); } (arg1)->end(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Camera_getProjectionMatrix__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; - ofRectangle arg2 ; ofRectangle *argp2 ; ofMatrix4x4 result; SWIG_check_num_args("ofCamera::getProjectionMatrix",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::getProjectionMatrix",1,"ofCamera const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofCamera::getProjectionMatrix",2,"ofRectangle"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_getProjectionMatrix",1,SWIGTYPE_p_ofCamera); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Camera_getProjectionMatrix",2,SWIGTYPE_p_ofRectangle); } arg2 = *argp2; - result = ((ofCamera const *)arg1)->getProjectionMatrix(arg2); { - ofMatrix4x4 * resultptr = new ofMatrix4x4((const ofMatrix4x4 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Camera_getProjectionMatrix__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; - ofMatrix4x4 result; SWIG_check_num_args("ofCamera::getProjectionMatrix",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::getProjectionMatrix",1,"ofCamera const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_getProjectionMatrix",1,SWIGTYPE_p_ofCamera); } - result = ((ofCamera const *)arg1)->getProjectionMatrix(); { - ofMatrix4x4 * resultptr = new ofMatrix4x4((const ofMatrix4x4 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Camera_getProjectionMatrix(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); - if (argc == 1) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCamera, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Camera_getProjectionMatrix__SWIG_1(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCamera, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Camera_getProjectionMatrix__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Camera_getProjectionMatrix'\n" - " Possible C/C++ prototypes are:\n" " ofCamera::getProjectionMatrix(ofRectangle) const\n" - " ofCamera::getProjectionMatrix() const\n"); lua_error(L);return 0; } -static int _wrap_Camera_getModelViewMatrix(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; - ofMatrix4x4 result; SWIG_check_num_args("ofCamera::getModelViewMatrix",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::getModelViewMatrix",1,"ofCamera const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_getModelViewMatrix",1,SWIGTYPE_p_ofCamera); } - result = ((ofCamera const *)arg1)->getModelViewMatrix(); { - ofMatrix4x4 * resultptr = new ofMatrix4x4((const ofMatrix4x4 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Camera_getModelViewProjectionMatrix__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; - ofRectangle arg2 ; ofRectangle *argp2 ; ofMatrix4x4 result; SWIG_check_num_args("ofCamera::getModelViewProjectionMatrix",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::getModelViewProjectionMatrix",1,"ofCamera const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofCamera::getModelViewProjectionMatrix",2,"ofRectangle"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_getModelViewProjectionMatrix",1,SWIGTYPE_p_ofCamera); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Camera_getModelViewProjectionMatrix",2,SWIGTYPE_p_ofRectangle); } arg2 = *argp2; - result = ((ofCamera const *)arg1)->getModelViewProjectionMatrix(arg2); { - ofMatrix4x4 * resultptr = new ofMatrix4x4((const ofMatrix4x4 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Camera_getModelViewProjectionMatrix__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; - ofMatrix4x4 result; SWIG_check_num_args("ofCamera::getModelViewProjectionMatrix",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::getModelViewProjectionMatrix",1,"ofCamera const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_getModelViewProjectionMatrix",1,SWIGTYPE_p_ofCamera); } - result = ((ofCamera const *)arg1)->getModelViewProjectionMatrix(); { - ofMatrix4x4 * resultptr = new ofMatrix4x4((const ofMatrix4x4 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Camera_getModelViewProjectionMatrix(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); - if (argc == 1) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCamera, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Camera_getModelViewProjectionMatrix__SWIG_1(L);} } if (argc == 2) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCamera, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Camera_getModelViewProjectionMatrix__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Camera_getModelViewProjectionMatrix'\n" - " Possible C/C++ prototypes are:\n" " ofCamera::getModelViewProjectionMatrix(ofRectangle) const\n" - " ofCamera::getModelViewProjectionMatrix() const\n"); lua_error(L);return 0; } -static int _wrap_Camera_worldToScreen__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; ofVec3f arg2 ; - ofRectangle arg3 ; ofVec3f *argp2 ; ofRectangle *argp3 ; ofVec3f result; SWIG_check_num_args("ofCamera::worldToScreen",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::worldToScreen",1,"ofCamera const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofCamera::worldToScreen",2,"ofVec3f"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofCamera::worldToScreen",3,"ofRectangle"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_worldToScreen",1,SWIGTYPE_p_ofCamera); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Camera_worldToScreen",2,SWIGTYPE_p_ofVec3f); } arg2 = *argp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&argp3,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Camera_worldToScreen",3,SWIGTYPE_p_ofRectangle); } arg3 = *argp3; - result = ((ofCamera const *)arg1)->worldToScreen(arg2,arg3); { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Camera_worldToScreen__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; ofVec3f arg2 ; - ofVec3f *argp2 ; ofVec3f result; SWIG_check_num_args("ofCamera::worldToScreen",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::worldToScreen",1,"ofCamera const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofCamera::worldToScreen",2,"ofVec3f"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_worldToScreen",1,SWIGTYPE_p_ofCamera); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Camera_worldToScreen",2,SWIGTYPE_p_ofVec3f); } arg2 = *argp2; - result = ((ofCamera const *)arg1)->worldToScreen(arg2); { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Camera_worldToScreen(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCamera, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Camera_worldToScreen__SWIG_1(L);} } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCamera, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Camera_worldToScreen__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Camera_worldToScreen'\n" - " Possible C/C++ prototypes are:\n" " ofCamera::worldToScreen(ofVec3f,ofRectangle) const\n" - " ofCamera::worldToScreen(ofVec3f) const\n"); lua_error(L);return 0; } -static int _wrap_Camera_screenToWorld__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; ofVec3f arg2 ; - ofRectangle arg3 ; ofVec3f *argp2 ; ofRectangle *argp3 ; ofVec3f result; SWIG_check_num_args("ofCamera::screenToWorld",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::screenToWorld",1,"ofCamera const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofCamera::screenToWorld",2,"ofVec3f"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofCamera::screenToWorld",3,"ofRectangle"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_screenToWorld",1,SWIGTYPE_p_ofCamera); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Camera_screenToWorld",2,SWIGTYPE_p_ofVec3f); } arg2 = *argp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&argp3,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Camera_screenToWorld",3,SWIGTYPE_p_ofRectangle); } arg3 = *argp3; - result = ((ofCamera const *)arg1)->screenToWorld(arg2,arg3); { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Camera_screenToWorld__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; ofVec3f arg2 ; - ofVec3f *argp2 ; ofVec3f result; SWIG_check_num_args("ofCamera::screenToWorld",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::screenToWorld",1,"ofCamera const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofCamera::screenToWorld",2,"ofVec3f"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_screenToWorld",1,SWIGTYPE_p_ofCamera); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Camera_screenToWorld",2,SWIGTYPE_p_ofVec3f); } arg2 = *argp2; - result = ((ofCamera const *)arg1)->screenToWorld(arg2); { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Camera_screenToWorld(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCamera, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Camera_screenToWorld__SWIG_1(L);} } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCamera, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Camera_screenToWorld__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Camera_screenToWorld'\n" - " Possible C/C++ prototypes are:\n" " ofCamera::screenToWorld(ofVec3f,ofRectangle) const\n" - " ofCamera::screenToWorld(ofVec3f) const\n"); lua_error(L);return 0; } -static int _wrap_Camera_worldToCamera__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; ofVec3f arg2 ; - ofRectangle arg3 ; ofVec3f *argp2 ; ofRectangle *argp3 ; ofVec3f result; SWIG_check_num_args("ofCamera::worldToCamera",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::worldToCamera",1,"ofCamera const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofCamera::worldToCamera",2,"ofVec3f"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofCamera::worldToCamera",3,"ofRectangle"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_worldToCamera",1,SWIGTYPE_p_ofCamera); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Camera_worldToCamera",2,SWIGTYPE_p_ofVec3f); } arg2 = *argp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&argp3,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Camera_worldToCamera",3,SWIGTYPE_p_ofRectangle); } arg3 = *argp3; - result = ((ofCamera const *)arg1)->worldToCamera(arg2,arg3); { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Camera_worldToCamera__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; ofVec3f arg2 ; - ofVec3f *argp2 ; ofVec3f result; SWIG_check_num_args("ofCamera::worldToCamera",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::worldToCamera",1,"ofCamera const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofCamera::worldToCamera",2,"ofVec3f"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_worldToCamera",1,SWIGTYPE_p_ofCamera); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Camera_worldToCamera",2,SWIGTYPE_p_ofVec3f); } arg2 = *argp2; - result = ((ofCamera const *)arg1)->worldToCamera(arg2); { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Camera_worldToCamera(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCamera, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Camera_worldToCamera__SWIG_1(L);} } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCamera, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Camera_worldToCamera__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Camera_worldToCamera'\n" - " Possible C/C++ prototypes are:\n" " ofCamera::worldToCamera(ofVec3f,ofRectangle) const\n" - " ofCamera::worldToCamera(ofVec3f) const\n"); lua_error(L);return 0; } -static int _wrap_Camera_cameraToWorld__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; ofVec3f arg2 ; - ofRectangle arg3 ; ofVec3f *argp2 ; ofRectangle *argp3 ; ofVec3f result; SWIG_check_num_args("ofCamera::cameraToWorld",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::cameraToWorld",1,"ofCamera const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofCamera::cameraToWorld",2,"ofVec3f"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofCamera::cameraToWorld",3,"ofRectangle"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_cameraToWorld",1,SWIGTYPE_p_ofCamera); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Camera_cameraToWorld",2,SWIGTYPE_p_ofVec3f); } arg2 = *argp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&argp3,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Camera_cameraToWorld",3,SWIGTYPE_p_ofRectangle); } arg3 = *argp3; - result = ((ofCamera const *)arg1)->cameraToWorld(arg2,arg3); { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Camera_cameraToWorld__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; ofVec3f arg2 ; - ofVec3f *argp2 ; ofVec3f result; SWIG_check_num_args("ofCamera::cameraToWorld",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::cameraToWorld",1,"ofCamera const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofCamera::cameraToWorld",2,"ofVec3f"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_cameraToWorld",1,SWIGTYPE_p_ofCamera); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Camera_cameraToWorld",2,SWIGTYPE_p_ofVec3f); } arg2 = *argp2; - result = ((ofCamera const *)arg1)->cameraToWorld(arg2); { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Camera_cameraToWorld(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCamera, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Camera_cameraToWorld__SWIG_1(L);} } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCamera, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Camera_cameraToWorld__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Camera_cameraToWorld'\n" - " Possible C/C++ prototypes are:\n" " ofCamera::cameraToWorld(ofVec3f,ofRectangle) const\n" - " ofCamera::cameraToWorld(ofVec3f) const\n"); lua_error(L);return 0; } -static int _wrap_Camera_setRenderer(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; - SwigValueWrapper< shared_ptr< ofBaseRenderer > > arg2 ; shared_ptr< ofBaseRenderer > *argp2 ; - SWIG_check_num_args("ofCamera::setRenderer",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::setRenderer",1,"ofCamera *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofCamera::setRenderer",2,"shared_ptr< ofBaseRenderer >"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_setRenderer",1,SWIGTYPE_p_ofCamera); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_shared_ptrT_ofBaseRenderer_t,0))){ - SWIG_fail_ptr("Camera_setRenderer",2,SWIGTYPE_p_shared_ptrT_ofBaseRenderer_t); } arg2 = *argp2; (arg1)->setRenderer(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_Camera(void *obj) { -ofCamera *arg1 = (ofCamera *) obj; -delete arg1; -} -static int _proxy__wrap_new_Camera(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_Camera); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_Camera_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_Camera_methods[]= { - { "setFov", _wrap_Camera_setFov}, - { "setNearClip", _wrap_Camera_setNearClip}, - { "setFarClip", _wrap_Camera_setFarClip}, - { "setLensOffset", _wrap_Camera_setLensOffset}, - { "setAspectRatio", _wrap_Camera_setAspectRatio}, - { "setForceAspectRatio", _wrap_Camera_setForceAspectRatio}, - { "getFov", _wrap_Camera_getFov}, - { "getNearClip", _wrap_Camera_getNearClip}, - { "getFarClip", _wrap_Camera_getFarClip}, - { "getLensOffset", _wrap_Camera_getLensOffset}, - { "getForceAspectRatio", _wrap_Camera_getForceAspectRatio}, - { "getAspectRatio", _wrap_Camera_getAspectRatio}, - { "setupPerspective", _wrap_Camera_setupPerspective}, - { "setupOffAxisViewPortal", _wrap_Camera_setupOffAxisViewPortal}, - { "setVFlip", _wrap_Camera_setVFlip}, - { "isVFlipped", _wrap_Camera_isVFlipped}, - { "enableOrtho", _wrap_Camera_enableOrtho}, - { "disableOrtho", _wrap_Camera_disableOrtho}, - { "getOrtho", _wrap_Camera_getOrtho}, - { "getImagePlaneDistance", _wrap_Camera_getImagePlaneDistance}, - { "beginCamera", _wrap_Camera_beginCamera}, - { "endCamera", _wrap_Camera_endCamera}, - { "getProjectionMatrix", _wrap_Camera_getProjectionMatrix}, - { "getModelViewMatrix", _wrap_Camera_getModelViewMatrix}, - { "getModelViewProjectionMatrix", _wrap_Camera_getModelViewProjectionMatrix}, - { "worldToScreen", _wrap_Camera_worldToScreen}, - { "screenToWorld", _wrap_Camera_screenToWorld}, - { "worldToCamera", _wrap_Camera_worldToCamera}, - { "cameraToWorld", _wrap_Camera_cameraToWorld}, - { "setRenderer", _wrap_Camera_setRenderer}, - {0,0} -}; -static swig_lua_method swig_Camera_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_Camera_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_Camera_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_Camera_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_Camera_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_Camera_Sf_SwigStatic = { - "Camera", - swig_Camera_Sf_SwigStatic_methods, - swig_Camera_Sf_SwigStatic_attributes, - swig_Camera_Sf_SwigStatic_constants, - swig_Camera_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_Camera_bases[] = {0,0}; -static const char *swig_Camera_base_names[] = {"ofNode *",0}; -static swig_lua_class _wrap_class_Camera = { "Camera", "Camera", &SWIGTYPE_p_ofCamera,_proxy__wrap_new_Camera, swig_delete_Camera, swig_Camera_methods, swig_Camera_attributes, &swig_Camera_Sf_SwigStatic, swig_Camera_meta, swig_Camera_bases, swig_Camera_base_names }; - -static int _wrap_new_EasyCam(lua_State* L) { int SWIG_arg = 0; ofEasyCam *result = 0 ; - SWIG_check_num_args("ofEasyCam::ofEasyCam",0,0) result = (ofEasyCam *)new ofEasyCam(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofEasyCam,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_EasyCam_beginCamera__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofEasyCam *arg1 = (ofEasyCam *) 0 ; - ofRectangle arg2 ; ofRectangle *argp2 ; SWIG_check_num_args("ofEasyCam::begin",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofEasyCam::begin",1,"ofEasyCam *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofEasyCam::begin",2,"ofRectangle"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofEasyCam,0))){ - SWIG_fail_ptr("EasyCam_beginCamera",1,SWIGTYPE_p_ofEasyCam); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("EasyCam_beginCamera",2,SWIGTYPE_p_ofRectangle); } arg2 = *argp2; (arg1)->begin(arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_EasyCam_beginCamera__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofEasyCam *arg1 = (ofEasyCam *) 0 ; - SWIG_check_num_args("ofEasyCam::begin",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofEasyCam::begin",1,"ofEasyCam *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofEasyCam,0))){ - SWIG_fail_ptr("EasyCam_beginCamera",1,SWIGTYPE_p_ofEasyCam); } (arg1)->begin(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_EasyCam_beginCamera(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofEasyCam, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_EasyCam_beginCamera__SWIG_1(L);} } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofEasyCam, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_EasyCam_beginCamera__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'EasyCam_beginCamera'\n" - " Possible C/C++ prototypes are:\n" " ofEasyCam::begin(ofRectangle)\n" " ofEasyCam::begin()\n"); - lua_error(L);return 0; } -static int _wrap_EasyCam_reset(lua_State* L) { int SWIG_arg = 0; ofEasyCam *arg1 = (ofEasyCam *) 0 ; - SWIG_check_num_args("ofEasyCam::reset",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofEasyCam::reset",1,"ofEasyCam *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofEasyCam,0))){ - SWIG_fail_ptr("EasyCam_reset",1,SWIGTYPE_p_ofEasyCam); } (arg1)->reset(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_EasyCam_setTarget__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofEasyCam *arg1 = (ofEasyCam *) 0 ; - ofVec3f *arg2 = 0 ; SWIG_check_num_args("ofEasyCam::setTarget",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofEasyCam::setTarget",1,"ofEasyCam *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofEasyCam::setTarget",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofEasyCam,0))){ - SWIG_fail_ptr("EasyCam_setTarget",1,SWIGTYPE_p_ofEasyCam); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("EasyCam_setTarget",2,SWIGTYPE_p_ofVec3f); } (arg1)->setTarget((ofVec3f const &)*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_EasyCam_setTarget__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofEasyCam *arg1 = (ofEasyCam *) 0 ; - ofNode *arg2 = 0 ; SWIG_check_num_args("ofEasyCam::setTarget",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofEasyCam::setTarget",1,"ofEasyCam *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofEasyCam::setTarget",2,"ofNode &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofEasyCam,0))){ - SWIG_fail_ptr("EasyCam_setTarget",1,SWIGTYPE_p_ofEasyCam); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("EasyCam_setTarget",2,SWIGTYPE_p_ofNode); } (arg1)->setTarget(*arg2); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_EasyCam_setTarget(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofEasyCam, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_EasyCam_setTarget__SWIG_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofEasyCam, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_EasyCam_setTarget__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'EasyCam_setTarget'\n" " Possible C/C++ prototypes are:\n" - " ofEasyCam::setTarget(ofVec3f const &)\n" " ofEasyCam::setTarget(ofNode &)\n"); lua_error(L);return 0; } -static int _wrap_EasyCam_getTarget(lua_State* L) { int SWIG_arg = 0; ofEasyCam *arg1 = (ofEasyCam *) 0 ; ofNode *result = 0 ; - SWIG_check_num_args("ofEasyCam::getTarget",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofEasyCam::getTarget",1,"ofEasyCam *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofEasyCam,0))){ - SWIG_fail_ptr("EasyCam_getTarget",1,SWIGTYPE_p_ofEasyCam); } result = (ofNode *) &(arg1)->getTarget(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofNode,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_EasyCam_setDistance(lua_State* L) { int SWIG_arg = 0; ofEasyCam *arg1 = (ofEasyCam *) 0 ; float arg2 ; - SWIG_check_num_args("ofEasyCam::setDistance",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofEasyCam::setDistance",1,"ofEasyCam *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofEasyCam::setDistance",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofEasyCam,0))){ - SWIG_fail_ptr("EasyCam_setDistance",1,SWIGTYPE_p_ofEasyCam); } arg2 = (float)lua_tonumber(L, 2); (arg1)->setDistance(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_EasyCam_getDistance(lua_State* L) { int SWIG_arg = 0; ofEasyCam *arg1 = (ofEasyCam *) 0 ; float result; - SWIG_check_num_args("ofEasyCam::getDistance",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofEasyCam::getDistance",1,"ofEasyCam const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofEasyCam,0))){ - SWIG_fail_ptr("EasyCam_getDistance",1,SWIGTYPE_p_ofEasyCam); } result = (float)((ofEasyCam const *)arg1)->getDistance(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_EasyCam_setDrag(lua_State* L) { int SWIG_arg = 0; ofEasyCam *arg1 = (ofEasyCam *) 0 ; float arg2 ; - SWIG_check_num_args("ofEasyCam::setDrag",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofEasyCam::setDrag",1,"ofEasyCam *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofEasyCam::setDrag",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofEasyCam,0))){ - SWIG_fail_ptr("EasyCam_setDrag",1,SWIGTYPE_p_ofEasyCam); } arg2 = (float)lua_tonumber(L, 2); (arg1)->setDrag(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_EasyCam_getDrag(lua_State* L) { int SWIG_arg = 0; ofEasyCam *arg1 = (ofEasyCam *) 0 ; float result; - SWIG_check_num_args("ofEasyCam::getDrag",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofEasyCam::getDrag",1,"ofEasyCam const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofEasyCam,0))){ - SWIG_fail_ptr("EasyCam_getDrag",1,SWIGTYPE_p_ofEasyCam); } result = (float)((ofEasyCam const *)arg1)->getDrag(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_EasyCam_setAutoDistance(lua_State* L) { int SWIG_arg = 0; ofEasyCam *arg1 = (ofEasyCam *) 0 ; bool arg2 ; - SWIG_check_num_args("ofEasyCam::setAutoDistance",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofEasyCam::setAutoDistance",1,"ofEasyCam *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofEasyCam::setAutoDistance",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofEasyCam,0))){ - SWIG_fail_ptr("EasyCam_setAutoDistance",1,SWIGTYPE_p_ofEasyCam); } arg2 = (lua_toboolean(L, 2)!=0); - (arg1)->setAutoDistance(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_EasyCam_setEvents(lua_State* L) { int SWIG_arg = 0; ofEasyCam *arg1 = (ofEasyCam *) 0 ; - ofCoreEvents *arg2 = 0 ; SWIG_check_num_args("ofEasyCam::setEvents",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofEasyCam::setEvents",1,"ofEasyCam *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofEasyCam::setEvents",2,"ofCoreEvents &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofEasyCam,0))){ - SWIG_fail_ptr("EasyCam_setEvents",1,SWIGTYPE_p_ofEasyCam); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofCoreEvents,0))){ - SWIG_fail_ptr("EasyCam_setEvents",2,SWIGTYPE_p_ofCoreEvents); } (arg1)->setEvents(*arg2); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_EasyCam_setTranslationKey(lua_State* L) { int SWIG_arg = 0; ofEasyCam *arg1 = (ofEasyCam *) 0 ; char arg2 ; - SWIG_check_num_args("ofEasyCam::setTranslationKey",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofEasyCam::setTranslationKey",1,"ofEasyCam *"); - if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("ofEasyCam::setTranslationKey",2,"char"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofEasyCam,0))){ - SWIG_fail_ptr("EasyCam_setTranslationKey",1,SWIGTYPE_p_ofEasyCam); } arg2 = (lua_tostring(L, 2))[0]; - (arg1)->setTranslationKey(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_EasyCam_getTranslationKey(lua_State* L) { int SWIG_arg = 0; ofEasyCam *arg1 = (ofEasyCam *) 0 ; char result; - SWIG_check_num_args("ofEasyCam::getTranslationKey",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofEasyCam::getTranslationKey",1,"ofEasyCam *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofEasyCam,0))){ - SWIG_fail_ptr("EasyCam_getTranslationKey",1,SWIGTYPE_p_ofEasyCam); } result = (char)(arg1)->getTranslationKey(); - lua_pushlstring(L, &result, 1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_EasyCam_enableMouseInput(lua_State* L) { int SWIG_arg = 0; ofEasyCam *arg1 = (ofEasyCam *) 0 ; - SWIG_check_num_args("ofEasyCam::enableMouseInput",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofEasyCam::enableMouseInput",1,"ofEasyCam *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofEasyCam,0))){ - SWIG_fail_ptr("EasyCam_enableMouseInput",1,SWIGTYPE_p_ofEasyCam); } (arg1)->enableMouseInput(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_EasyCam_disableMouseInput(lua_State* L) { int SWIG_arg = 0; ofEasyCam *arg1 = (ofEasyCam *) 0 ; - SWIG_check_num_args("ofEasyCam::disableMouseInput",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofEasyCam::disableMouseInput",1,"ofEasyCam *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofEasyCam,0))){ - SWIG_fail_ptr("EasyCam_disableMouseInput",1,SWIGTYPE_p_ofEasyCam); } (arg1)->disableMouseInput(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_EasyCam_getMouseInputEnabled(lua_State* L) { int SWIG_arg = 0; ofEasyCam *arg1 = (ofEasyCam *) 0 ; bool result; - SWIG_check_num_args("ofEasyCam::getMouseInputEnabled",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofEasyCam::getMouseInputEnabled",1,"ofEasyCam *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofEasyCam,0))){ - SWIG_fail_ptr("EasyCam_getMouseInputEnabled",1,SWIGTYPE_p_ofEasyCam); } result = (bool)(arg1)->getMouseInputEnabled(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_EasyCam_enableMouseMiddleButton(lua_State* L) { int SWIG_arg = 0; ofEasyCam *arg1 = (ofEasyCam *) 0 ; - SWIG_check_num_args("ofEasyCam::enableMouseMiddleButton",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofEasyCam::enableMouseMiddleButton",1,"ofEasyCam *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofEasyCam,0))){ - SWIG_fail_ptr("EasyCam_enableMouseMiddleButton",1,SWIGTYPE_p_ofEasyCam); } (arg1)->enableMouseMiddleButton(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_EasyCam_disableMouseMiddleButton(lua_State* L) { int SWIG_arg = 0; ofEasyCam *arg1 = (ofEasyCam *) 0 ; - SWIG_check_num_args("ofEasyCam::disableMouseMiddleButton",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofEasyCam::disableMouseMiddleButton",1,"ofEasyCam *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofEasyCam,0))){ - SWIG_fail_ptr("EasyCam_disableMouseMiddleButton",1,SWIGTYPE_p_ofEasyCam); } (arg1)->disableMouseMiddleButton(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_EasyCam_getMouseMiddleButtonEnabled(lua_State* L) { int SWIG_arg = 0; ofEasyCam *arg1 = (ofEasyCam *) 0 ; - bool result; SWIG_check_num_args("ofEasyCam::getMouseMiddleButtonEnabled",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofEasyCam::getMouseMiddleButtonEnabled",1,"ofEasyCam *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofEasyCam,0))){ - SWIG_fail_ptr("EasyCam_getMouseMiddleButtonEnabled",1,SWIGTYPE_p_ofEasyCam); } - result = (bool)(arg1)->getMouseMiddleButtonEnabled(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_EasyCam(void *obj) { -ofEasyCam *arg1 = (ofEasyCam *) obj; -delete arg1; -} -static int _proxy__wrap_new_EasyCam(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_EasyCam); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_EasyCam_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_EasyCam_methods[]= { - { "beginCamera", _wrap_EasyCam_beginCamera}, - { "reset", _wrap_EasyCam_reset}, - { "setTarget", _wrap_EasyCam_setTarget}, - { "getTarget", _wrap_EasyCam_getTarget}, - { "setDistance", _wrap_EasyCam_setDistance}, - { "getDistance", _wrap_EasyCam_getDistance}, - { "setDrag", _wrap_EasyCam_setDrag}, - { "getDrag", _wrap_EasyCam_getDrag}, - { "setAutoDistance", _wrap_EasyCam_setAutoDistance}, - { "setEvents", _wrap_EasyCam_setEvents}, - { "setTranslationKey", _wrap_EasyCam_setTranslationKey}, - { "getTranslationKey", _wrap_EasyCam_getTranslationKey}, - { "enableMouseInput", _wrap_EasyCam_enableMouseInput}, - { "disableMouseInput", _wrap_EasyCam_disableMouseInput}, - { "getMouseInputEnabled", _wrap_EasyCam_getMouseInputEnabled}, - { "enableMouseMiddleButton", _wrap_EasyCam_enableMouseMiddleButton}, - { "disableMouseMiddleButton", _wrap_EasyCam_disableMouseMiddleButton}, - { "getMouseMiddleButtonEnabled", _wrap_EasyCam_getMouseMiddleButtonEnabled}, - {0,0} -}; -static swig_lua_method swig_EasyCam_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_EasyCam_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_EasyCam_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_EasyCam_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_EasyCam_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_EasyCam_Sf_SwigStatic = { - "EasyCam", - swig_EasyCam_Sf_SwigStatic_methods, - swig_EasyCam_Sf_SwigStatic_attributes, - swig_EasyCam_Sf_SwigStatic_constants, - swig_EasyCam_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_EasyCam_bases[] = {0,0}; -static const char *swig_EasyCam_base_names[] = {"ofCamera *",0}; -static swig_lua_class _wrap_class_EasyCam = { "EasyCam", "EasyCam", &SWIGTYPE_p_ofEasyCam,_proxy__wrap_new_EasyCam, swig_delete_EasyCam, swig_EasyCam_methods, swig_EasyCam_attributes, &swig_EasyCam_Sf_SwigStatic, swig_EasyCam_meta, swig_EasyCam_bases, swig_EasyCam_base_names }; - -static int _wrap_new_Mesh__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMesh *result = 0 ; - SWIG_check_num_args("ofMesh::ofMesh",0,0) result = (ofMesh *)new ofMesh(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMesh,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Mesh__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPrimitiveMode arg1 ; std::vector< ofVec3f > *arg2 = 0 ; - ofMesh *result = 0 ; SWIG_check_num_args("ofMesh::ofMesh",2,2) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh::ofMesh",1,"ofPrimitiveMode"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMesh::ofMesh",2,"std::vector< ofVec3f > const &"); - arg1 = (ofPrimitiveMode)(int)lua_tonumber(L, 1); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__vectorT_ofVec3f_t,0))){ - SWIG_fail_ptr("new_Mesh",2,SWIGTYPE_p_std__vectorT_ofVec3f_t); } - result = (ofMesh *)new ofMesh(arg1,(std::vector< ofVec3f > const &)*arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMesh,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Mesh(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_Mesh__SWIG_0(L);} if (argc == 2) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_std__vectorT_ofVec3f_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_new_Mesh__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_Mesh'\n" " Possible C/C++ prototypes are:\n" - " ofMesh::ofMesh()\n" " ofMesh::ofMesh(ofPrimitiveMode,std::vector< ofVec3f > const &)\n"); lua_error(L);return 0; } -static int _wrap_Mesh_setFromTriangles__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - std::vector< ofMeshFace > *arg2 = 0 ; bool arg3 ; SWIG_check_num_args("ofMesh::setFromTriangles",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::setFromTriangles",1,"ofMesh *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMesh::setFromTriangles",2,"std::vector< ofMeshFace > const &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofMesh::setFromTriangles",3,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_setFromTriangles",1,SWIGTYPE_p_ofMesh); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__vectorT_ofMeshFace_t,0))){ - SWIG_fail_ptr("Mesh_setFromTriangles",2,SWIGTYPE_p_std__vectorT_ofMeshFace_t); } arg3 = (lua_toboolean(L, 3)!=0); - (arg1)->setFromTriangles((std::vector< ofMeshFace > const &)*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Mesh_setFromTriangles__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - std::vector< ofMeshFace > *arg2 = 0 ; SWIG_check_num_args("ofMesh::setFromTriangles",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::setFromTriangles",1,"ofMesh *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMesh::setFromTriangles",2,"std::vector< ofMeshFace > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_setFromTriangles",1,SWIGTYPE_p_ofMesh); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__vectorT_ofMeshFace_t,0))){ - SWIG_fail_ptr("Mesh_setFromTriangles",2,SWIGTYPE_p_std__vectorT_ofMeshFace_t); } - (arg1)->setFromTriangles((std::vector< ofMeshFace > const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Mesh_setFromTriangles(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_std__vectorT_ofMeshFace_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Mesh_setFromTriangles__SWIG_1(L);} } } if (argc == 3) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_std__vectorT_ofMeshFace_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - return _wrap_Mesh_setFromTriangles__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_setFromTriangles'\n" - " Possible C/C++ prototypes are:\n" " ofMesh::setFromTriangles(std::vector< ofMeshFace > const &,bool)\n" - " ofMesh::setFromTriangles(std::vector< ofMeshFace > const &)\n"); lua_error(L);return 0; } -static int _wrap_Mesh_setMode(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; ofPrimitiveMode arg2 ; - SWIG_check_num_args("ofMesh::setMode",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::setMode",1,"ofMesh *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::setMode",2,"ofPrimitiveMode"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Mesh_setMode",1,SWIGTYPE_p_ofMesh); } - arg2 = (ofPrimitiveMode)(int)lua_tonumber(L, 2); (arg1)->setMode(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Mesh_getMode(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; ofPrimitiveMode result; - SWIG_check_num_args("ofMesh::getMode",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getMode",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Mesh_getMode",1,SWIGTYPE_p_ofMesh); } - result = (ofPrimitiveMode)((ofMesh const *)arg1)->getMode(); lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_plane__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; int arg3 ; int arg4 ; - ofPrimitiveMode arg5 ; ofMesh result; SWIG_check_num_args("ofMesh::plane",5,5) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh::plane",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::plane",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh::plane",3,"int"); if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMesh::plane",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMesh::plane",5,"ofPrimitiveMode"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - arg5 = (ofPrimitiveMode)(int)lua_tonumber(L, 5); result = ofMesh::plane(arg1,arg2,arg3,arg4,arg5); { - ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_plane__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; int arg3 ; int arg4 ; - ofMesh result; SWIG_check_num_args("ofMesh::plane",4,4) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh::plane",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::plane",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh::plane",3,"int"); if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMesh::plane",4,"int"); - arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); result = ofMesh::plane(arg1,arg2,arg3,arg4); { - ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_plane__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; int arg3 ; ofMesh result; - SWIG_check_num_args("ofMesh::plane",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh::plane",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::plane",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh::plane",3,"int"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); result = ofMesh::plane(arg1,arg2,arg3); { - ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_plane__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; ofMesh result; - SWIG_check_num_args("ofMesh::plane",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh::plane",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::plane",2,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); result = ofMesh::plane(arg1,arg2); { - ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_plane(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Mesh_plane__SWIG_3(L);} } } if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Mesh_plane__SWIG_2(L);} } } } if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Mesh_plane__SWIG_1(L);} } } } } if (argc == 5) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Mesh_plane__SWIG_0(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_plane'\n" " Possible C/C++ prototypes are:\n" - " ofMesh::plane(float,float,int,int,ofPrimitiveMode)\n" " ofMesh::plane(float,float,int,int)\n" - " ofMesh::plane(float,float,int)\n" " ofMesh::plane(float,float)\n"); lua_error(L);return 0; } -static int _wrap_Mesh_sphere__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; int arg2 ; ofPrimitiveMode arg3 ; - ofMesh result; SWIG_check_num_args("ofMesh::sphere",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh::sphere",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::sphere",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh::sphere",3,"ofPrimitiveMode"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (int)lua_tonumber(L, 2); arg3 = (ofPrimitiveMode)(int)lua_tonumber(L, 3); result = ofMesh::sphere(arg1,arg2,arg3); { - ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_sphere__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; int arg2 ; ofMesh result; - SWIG_check_num_args("ofMesh::sphere",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh::sphere",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::sphere",2,"int"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (int)lua_tonumber(L, 2); result = ofMesh::sphere(arg1,arg2); { - ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_sphere__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; ofMesh result; - SWIG_check_num_args("ofMesh::sphere",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh::sphere",1,"float"); - arg1 = (float)lua_tonumber(L, 1); result = ofMesh::sphere(arg1); { ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_sphere(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_Mesh_sphere__SWIG_2(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Mesh_sphere__SWIG_1(L);} } } if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Mesh_sphere__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_sphere'\n" " Possible C/C++ prototypes are:\n" - " ofMesh::sphere(float,int,ofPrimitiveMode)\n" " ofMesh::sphere(float,int)\n" " ofMesh::sphere(float)\n"); - lua_error(L);return 0; } -static int _wrap_Mesh_icosahedron(lua_State* L) { int SWIG_arg = 0; float arg1 ; ofMesh result; - SWIG_check_num_args("ofMesh::icosahedron",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh::icosahedron",1,"float"); - arg1 = (float)lua_tonumber(L, 1); result = ofMesh::icosahedron(arg1); { - ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_icosphere__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; std::size_t arg2 ; ofMesh result; - SWIG_check_num_args("ofMesh::icosphere",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh::icosphere",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::icosphere",2,"std::size_t"); arg1 = (float)lua_tonumber(L, 1); - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (std::size_t)lua_tonumber(L, 2); - result = ofMesh::icosphere(arg1,arg2); { ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_icosphere__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; ofMesh result; - SWIG_check_num_args("ofMesh::icosphere",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh::icosphere",1,"float"); - arg1 = (float)lua_tonumber(L, 1); result = ofMesh::icosphere(arg1); { - ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_icosphere(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; - { _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_Mesh_icosphere__SWIG_1(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Mesh_icosphere__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_icosphere'\n" " Possible C/C++ prototypes are:\n" - " ofMesh::icosphere(float,std::size_t)\n" " ofMesh::icosphere(float)\n"); lua_error(L);return 0; } -static int _wrap_Mesh_cylinder__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; int arg3 ; int arg4 ; - int arg5 ; bool arg6 ; ofPrimitiveMode arg7 ; ofMesh result; SWIG_check_num_args("ofMesh::cylinder",7,7) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh::cylinder",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::cylinder",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh::cylinder",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMesh::cylinder",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMesh::cylinder",5,"int"); - if(!lua_isboolean(L,6)) SWIG_fail_arg("ofMesh::cylinder",6,"bool"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofMesh::cylinder",7,"ofPrimitiveMode"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - arg5 = (int)lua_tonumber(L, 5); arg6 = (lua_toboolean(L, 6)!=0); arg7 = (ofPrimitiveMode)(int)lua_tonumber(L, 7); - result = ofMesh::cylinder(arg1,arg2,arg3,arg4,arg5,arg6,arg7); { ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_cylinder__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; int arg3 ; int arg4 ; - int arg5 ; bool arg6 ; ofMesh result; SWIG_check_num_args("ofMesh::cylinder",6,6) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh::cylinder",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::cylinder",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh::cylinder",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMesh::cylinder",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMesh::cylinder",5,"int"); - if(!lua_isboolean(L,6)) SWIG_fail_arg("ofMesh::cylinder",6,"bool"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - arg5 = (int)lua_tonumber(L, 5); arg6 = (lua_toboolean(L, 6)!=0); result = ofMesh::cylinder(arg1,arg2,arg3,arg4,arg5,arg6); { - ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_cylinder__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; int arg3 ; int arg4 ; - int arg5 ; ofMesh result; SWIG_check_num_args("ofMesh::cylinder",5,5) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh::cylinder",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::cylinder",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh::cylinder",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMesh::cylinder",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMesh::cylinder",5,"int"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - arg5 = (int)lua_tonumber(L, 5); result = ofMesh::cylinder(arg1,arg2,arg3,arg4,arg5); { - ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_cylinder__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; int arg3 ; int arg4 ; - ofMesh result; SWIG_check_num_args("ofMesh::cylinder",4,4) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh::cylinder",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::cylinder",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh::cylinder",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMesh::cylinder",4,"int"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - result = ofMesh::cylinder(arg1,arg2,arg3,arg4); { ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_cylinder__SWIG_4(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; int arg3 ; ofMesh result; - SWIG_check_num_args("ofMesh::cylinder",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh::cylinder",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::cylinder",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh::cylinder",3,"int"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); result = ofMesh::cylinder(arg1,arg2,arg3); { - ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_cylinder__SWIG_5(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; ofMesh result; - SWIG_check_num_args("ofMesh::cylinder",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh::cylinder",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::cylinder",2,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); result = ofMesh::cylinder(arg1,arg2); { - ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_cylinder(lua_State* L) { int argc; int argv[8]={ 1,2,3,4,5,6,7,8} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Mesh_cylinder__SWIG_5(L);} } } if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Mesh_cylinder__SWIG_4(L);} } } } if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Mesh_cylinder__SWIG_3(L);} } } } } if (argc == 5) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_Mesh_cylinder__SWIG_2(L);} } } } } } - if (argc == 6) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isboolean(L,argv[5]); } if (_v) { - return _wrap_Mesh_cylinder__SWIG_1(L);} } } } } } } if (argc == 7) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isboolean(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { - return _wrap_Mesh_cylinder__SWIG_0(L);} } } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_cylinder'\n" " Possible C/C++ prototypes are:\n" - " ofMesh::cylinder(float,float,int,int,int,bool,ofPrimitiveMode)\n" " ofMesh::cylinder(float,float,int,int,int,bool)\n" - " ofMesh::cylinder(float,float,int,int,int)\n" " ofMesh::cylinder(float,float,int,int)\n" - " ofMesh::cylinder(float,float,int)\n" " ofMesh::cylinder(float,float)\n"); lua_error(L);return 0; } -static int _wrap_Mesh_cone__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; int arg3 ; int arg4 ; int arg5 ; - ofPrimitiveMode arg6 ; ofMesh result; SWIG_check_num_args("ofMesh::cone",6,6) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh::cone",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::cone",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh::cone",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMesh::cone",4,"int"); if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMesh::cone",5,"int"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofMesh::cone",6,"ofPrimitiveMode"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - arg5 = (int)lua_tonumber(L, 5); arg6 = (ofPrimitiveMode)(int)lua_tonumber(L, 6); - result = ofMesh::cone(arg1,arg2,arg3,arg4,arg5,arg6); { ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_cone__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; int arg3 ; int arg4 ; int arg5 ; - ofMesh result; SWIG_check_num_args("ofMesh::cone",5,5) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh::cone",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::cone",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh::cone",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMesh::cone",4,"int"); if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMesh::cone",5,"int"); - arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); result = ofMesh::cone(arg1,arg2,arg3,arg4,arg5); { - ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_cone__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; int arg3 ; int arg4 ; - ofMesh result; SWIG_check_num_args("ofMesh::cone",4,4) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh::cone",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::cone",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh::cone",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMesh::cone",4,"int"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - result = ofMesh::cone(arg1,arg2,arg3,arg4); { ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_cone__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; int arg3 ; ofMesh result; - SWIG_check_num_args("ofMesh::cone",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh::cone",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::cone",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh::cone",3,"int"); - arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); - result = ofMesh::cone(arg1,arg2,arg3); { ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_cone__SWIG_4(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; ofMesh result; - SWIG_check_num_args("ofMesh::cone",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh::cone",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::cone",2,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); result = ofMesh::cone(arg1,arg2); { - ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_cone(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Mesh_cone__SWIG_4(L);} } } if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Mesh_cone__SWIG_3(L);} } } } if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Mesh_cone__SWIG_2(L);} } } } } if (argc == 5) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Mesh_cone__SWIG_1(L);} } } } } } if (argc == 6) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { return _wrap_Mesh_cone__SWIG_0(L);} } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_cone'\n" " Possible C/C++ prototypes are:\n" - " ofMesh::cone(float,float,int,int,int,ofPrimitiveMode)\n" " ofMesh::cone(float,float,int,int,int)\n" - " ofMesh::cone(float,float,int,int)\n" " ofMesh::cone(float,float,int)\n" " ofMesh::cone(float,float)\n"); - lua_error(L);return 0; } -static int _wrap_Mesh_box__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; int arg4 ; int arg5 ; - int arg6 ; ofMesh result; SWIG_check_num_args("ofMesh::box",6,6) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh::box",1,"float"); if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::box",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh::box",3,"float"); if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMesh::box",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMesh::box",5,"int"); if(!lua_isnumber(L,6)) SWIG_fail_arg("ofMesh::box",6,"int"); - arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); arg6 = (int)lua_tonumber(L, 6); - result = ofMesh::box(arg1,arg2,arg3,arg4,arg5,arg6); { ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_box__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; int arg4 ; int arg5 ; - ofMesh result; SWIG_check_num_args("ofMesh::box",5,5) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh::box",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::box",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh::box",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMesh::box",4,"int"); if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMesh::box",5,"int"); - arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); result = ofMesh::box(arg1,arg2,arg3,arg4,arg5); { - ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_box__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; int arg4 ; - ofMesh result; SWIG_check_num_args("ofMesh::box",4,4) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh::box",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::box",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh::box",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMesh::box",4,"int"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - result = ofMesh::box(arg1,arg2,arg3,arg4); { ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_box__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; ofMesh result; - SWIG_check_num_args("ofMesh::box",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh::box",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::box",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh::box",3,"float"); - arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - result = ofMesh::box(arg1,arg2,arg3); { ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_box(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Mesh_box__SWIG_3(L);} } } } if (argc == 4) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Mesh_box__SWIG_2(L);} } } } } if (argc == 5) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_Mesh_box__SWIG_1(L);} } } } } } if (argc == 6) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { - return _wrap_Mesh_box__SWIG_0(L);} } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_box'\n" " Possible C/C++ prototypes are:\n" - " ofMesh::box(float,float,float,int,int,int)\n" " ofMesh::box(float,float,float,int,int)\n" - " ofMesh::box(float,float,float,int)\n" " ofMesh::box(float,float,float)\n"); lua_error(L);return 0; } -static int _wrap_Mesh_axis__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; ofMesh result; - SWIG_check_num_args("ofMesh::axis",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh::axis",1,"float"); - arg1 = (float)lua_tonumber(L, 1); result = ofMesh::axis(arg1); { ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_axis__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMesh result; SWIG_check_num_args("ofMesh::axis",0,0) - result = ofMesh::axis(); { ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_axis(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_Mesh_axis__SWIG_1(L);} if (argc == 1) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { - return _wrap_Mesh_axis__SWIG_0(L);} } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_axis'\n" - " Possible C/C++ prototypes are:\n" " ofMesh::axis(float)\n" " ofMesh::axis()\n"); lua_error(L);return 0; } -static int _wrap_Mesh_addVertex(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; ofVec3f *arg2 = 0 ; - SWIG_check_num_args("ofMesh::addVertex",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::addVertex",1,"ofMesh *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMesh::addVertex",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Mesh_addVertex",1,SWIGTYPE_p_ofMesh); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Mesh_addVertex",2,SWIGTYPE_p_ofVec3f); } (arg1)->addVertex((ofVec3f const &)*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_addVertices__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - std::vector< ofVec3f > *arg2 = 0 ; SWIG_check_num_args("ofMesh::addVertices",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::addVertices",1,"ofMesh *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMesh::addVertices",2,"std::vector< ofVec3f > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_addVertices",1,SWIGTYPE_p_ofMesh); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__vectorT_ofVec3f_t,0))){ - SWIG_fail_ptr("Mesh_addVertices",2,SWIGTYPE_p_std__vectorT_ofVec3f_t); } - (arg1)->addVertices((std::vector< ofVec3f > const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Mesh_addVertices__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - ofVec3f *arg2 = (ofVec3f *) 0 ; std::size_t arg3 ; SWIG_check_num_args("ofMesh::addVertices",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::addVertices",1,"ofMesh *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofMesh::addVertices",2,"ofVec3f const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh::addVertices",3,"std::size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_addVertices",1,SWIGTYPE_p_ofMesh); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Mesh_addVertices",2,SWIGTYPE_p_ofVec3f); } - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (std::size_t)lua_tonumber(L, 3); - (arg1)->addVertices((ofVec3f const *)arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_addVertices(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_std__vectorT_ofVec3f_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Mesh_addVertices__SWIG_0(L);} } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Mesh_addVertices__SWIG_1(L);} - } } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_addVertices'\n" - " Possible C/C++ prototypes are:\n" " ofMesh::addVertices(std::vector< ofVec3f > const &)\n" - " ofMesh::addVertices(ofVec3f const *,std::size_t)\n"); lua_error(L);return 0; } -static int _wrap_Mesh_removeVertex(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; ofIndexType arg2 ; - SWIG_check_num_args("ofMesh::removeVertex",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::removeVertex",1,"ofMesh *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::removeVertex",2,"ofIndexType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_removeVertex",1,SWIGTYPE_p_ofMesh); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); - (arg1)->removeVertex(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_setVertex(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; ofIndexType arg2 ; - ofVec3f *arg3 = 0 ; SWIG_check_num_args("ofMesh::setVertex",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::setVertex",1,"ofMesh *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::setVertex",2,"ofIndexType"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofMesh::setVertex",3,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Mesh_setVertex",1,SWIGTYPE_p_ofMesh); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Mesh_setVertex",3,SWIGTYPE_p_ofVec3f); } (arg1)->setVertex(arg2,(ofVec3f const &)*arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_clearVertices(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - SWIG_check_num_args("ofMesh::clearVertices",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::clearVertices",1,"ofMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_clearVertices",1,SWIGTYPE_p_ofMesh); } (arg1)->clearVertices(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_clear(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - SWIG_check_num_args("ofMesh::clear",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::clear",1,"ofMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Mesh_clear",1,SWIGTYPE_p_ofMesh); } - (arg1)->clear(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getNumVertices(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; std::size_t result; - SWIG_check_num_args("ofMesh::getNumVertices",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getNumVertices",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_getNumVertices",1,SWIGTYPE_p_ofMesh); } result = (std::size_t)((ofMesh const *)arg1)->getNumVertices(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getVerticesPointer__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - ofVec3f *result = 0 ; SWIG_check_num_args("ofMesh::getVerticesPointer",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getVerticesPointer",1,"ofMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_getVerticesPointer",1,SWIGTYPE_p_ofMesh); } result = (ofVec3f *)(arg1)->getVerticesPointer(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Mesh_getVerticesPointer__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - ofVec3f *result = 0 ; SWIG_check_num_args("ofMesh::getVerticesPointer",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getVerticesPointer",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_getVerticesPointer",1,SWIGTYPE_p_ofMesh); } - result = (ofVec3f *)((ofMesh const *)arg1)->getVerticesPointer(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Mesh_getVerticesPointer(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Mesh_getVerticesPointer__SWIG_0(L);} } if (argc == 1) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Mesh_getVerticesPointer__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_getVerticesPointer'\n" - " Possible C/C++ prototypes are:\n" " ofMesh::getVerticesPointer()\n" " ofMesh::getVerticesPointer() const\n"); - lua_error(L);return 0; } -static int _wrap_Mesh_getVertex(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; ofIndexType arg2 ; - ofVec3f result; SWIG_check_num_args("ofMesh::getVertex",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getVertex",1,"ofMesh const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::getVertex",2,"ofIndexType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Mesh_getVertex",1,SWIGTYPE_p_ofMesh); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); - result = ((ofMesh const *)arg1)->getVertex(arg2); { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getVertices__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - std::vector< ofVec3f > *result = 0 ; SWIG_check_num_args("ofMesh::getVertices",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getVertices",1,"ofMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_getVertices",1,SWIGTYPE_p_ofMesh); } result = (std::vector< ofVec3f > *) &(arg1)->getVertices(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofVec3f_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getVertices__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - std::vector< ofVec3f > *result = 0 ; SWIG_check_num_args("ofMesh::getVertices",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getVertices",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_getVertices",1,SWIGTYPE_p_ofMesh); } - result = (std::vector< ofVec3f > *) &((ofMesh const *)arg1)->getVertices(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofVec3f_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getVertices(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Mesh_getVertices__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Mesh_getVertices__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_getVertices'\n" " Possible C/C++ prototypes are:\n" - " ofMesh::getVertices()\n" " ofMesh::getVertices() const\n"); lua_error(L);return 0; } -static int _wrap_Mesh_haveVertsChanged(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; bool result; - SWIG_check_num_args("ofMesh::haveVertsChanged",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::haveVertsChanged",1,"ofMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_haveVertsChanged",1,SWIGTYPE_p_ofMesh); } result = (bool)(arg1)->haveVertsChanged(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_hasVertices(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; bool result; - SWIG_check_num_args("ofMesh::hasVertices",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::hasVertices",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_hasVertices",1,SWIGTYPE_p_ofMesh); } result = (bool)((ofMesh const *)arg1)->hasVertices(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_append(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; ofMesh *arg2 = 0 ; - SWIG_check_num_args("ofMesh::append",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::append",1,"ofMesh *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMesh::append",2,"ofMesh const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Mesh_append",1,SWIGTYPE_p_ofMesh); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Mesh_append",2,SWIGTYPE_p_ofMesh); } - (arg1)->append((ofMesh const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_mergeDuplicateVertices(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - SWIG_check_num_args("ofMesh::mergeDuplicateVertices",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::mergeDuplicateVertices",1,"ofMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_mergeDuplicateVertices",1,SWIGTYPE_p_ofMesh); } (arg1)->mergeDuplicateVertices(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getCentroid(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; ofVec3f result; - SWIG_check_num_args("ofMesh::getCentroid",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getCentroid",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_getCentroid",1,SWIGTYPE_p_ofMesh); } result = ((ofMesh const *)arg1)->getCentroid(); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getNormal(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; ofIndexType arg2 ; - ofVec3f result; SWIG_check_num_args("ofMesh::getNormal",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getNormal",1,"ofMesh const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::getNormal",2,"ofIndexType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Mesh_getNormal",1,SWIGTYPE_p_ofMesh); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); - result = ((ofMesh const *)arg1)->getNormal(arg2); { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_addNormal(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; ofVec3f *arg2 = 0 ; - SWIG_check_num_args("ofMesh::addNormal",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::addNormal",1,"ofMesh *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMesh::addNormal",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Mesh_addNormal",1,SWIGTYPE_p_ofMesh); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Mesh_addNormal",2,SWIGTYPE_p_ofVec3f); } (arg1)->addNormal((ofVec3f const &)*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_addNormals__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - std::vector< ofVec3f > *arg2 = 0 ; SWIG_check_num_args("ofMesh::addNormals",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::addNormals",1,"ofMesh *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMesh::addNormals",2,"std::vector< ofVec3f > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_addNormals",1,SWIGTYPE_p_ofMesh); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__vectorT_ofVec3f_t,0))){ - SWIG_fail_ptr("Mesh_addNormals",2,SWIGTYPE_p_std__vectorT_ofVec3f_t); } - (arg1)->addNormals((std::vector< ofVec3f > const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Mesh_addNormals__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - ofVec3f *arg2 = (ofVec3f *) 0 ; std::size_t arg3 ; SWIG_check_num_args("ofMesh::addNormals",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::addNormals",1,"ofMesh *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofMesh::addNormals",2,"ofVec3f const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh::addNormals",3,"std::size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_addNormals",1,SWIGTYPE_p_ofMesh); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Mesh_addNormals",2,SWIGTYPE_p_ofVec3f); } - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (std::size_t)lua_tonumber(L, 3); - (arg1)->addNormals((ofVec3f const *)arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_addNormals(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_std__vectorT_ofVec3f_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Mesh_addNormals__SWIG_0(L);} } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Mesh_addNormals__SWIG_1(L);} } - } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_addNormals'\n" - " Possible C/C++ prototypes are:\n" " ofMesh::addNormals(std::vector< ofVec3f > const &)\n" - " ofMesh::addNormals(ofVec3f const *,std::size_t)\n"); lua_error(L);return 0; } -static int _wrap_Mesh_removeNormal(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; ofIndexType arg2 ; - SWIG_check_num_args("ofMesh::removeNormal",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::removeNormal",1,"ofMesh *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::removeNormal",2,"ofIndexType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_removeNormal",1,SWIGTYPE_p_ofMesh); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); - (arg1)->removeNormal(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_setNormal(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; ofIndexType arg2 ; - ofVec3f *arg3 = 0 ; SWIG_check_num_args("ofMesh::setNormal",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::setNormal",1,"ofMesh *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::setNormal",2,"ofIndexType"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofMesh::setNormal",3,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Mesh_setNormal",1,SWIGTYPE_p_ofMesh); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Mesh_setNormal",3,SWIGTYPE_p_ofVec3f); } (arg1)->setNormal(arg2,(ofVec3f const &)*arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_clearNormals(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - SWIG_check_num_args("ofMesh::clearNormals",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::clearNormals",1,"ofMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_clearNormals",1,SWIGTYPE_p_ofMesh); } (arg1)->clearNormals(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getNumNormals(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; std::size_t result; - SWIG_check_num_args("ofMesh::getNumNormals",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getNumNormals",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_getNumNormals",1,SWIGTYPE_p_ofMesh); } result = (std::size_t)((ofMesh const *)arg1)->getNumNormals(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getNormalsPointer__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - ofVec3f *result = 0 ; SWIG_check_num_args("ofMesh::getNormalsPointer",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getNormalsPointer",1,"ofMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_getNormalsPointer",1,SWIGTYPE_p_ofMesh); } result = (ofVec3f *)(arg1)->getNormalsPointer(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Mesh_getNormalsPointer__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - ofVec3f *result = 0 ; SWIG_check_num_args("ofMesh::getNormalsPointer",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getNormalsPointer",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_getNormalsPointer",1,SWIGTYPE_p_ofMesh); } - result = (ofVec3f *)((ofMesh const *)arg1)->getNormalsPointer(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Mesh_getNormalsPointer(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Mesh_getNormalsPointer__SWIG_0(L);} } if (argc == 1) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Mesh_getNormalsPointer__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_getNormalsPointer'\n" - " Possible C/C++ prototypes are:\n" " ofMesh::getNormalsPointer()\n" " ofMesh::getNormalsPointer() const\n"); - lua_error(L);return 0; } -static int _wrap_Mesh_getNormals__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - std::vector< ofVec3f > *result = 0 ; SWIG_check_num_args("ofMesh::getNormals",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getNormals",1,"ofMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_getNormals",1,SWIGTYPE_p_ofMesh); } result = (std::vector< ofVec3f > *) &(arg1)->getNormals(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofVec3f_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getNormals__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - std::vector< ofVec3f > *result = 0 ; SWIG_check_num_args("ofMesh::getNormals",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getNormals",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_getNormals",1,SWIGTYPE_p_ofMesh); } - result = (std::vector< ofVec3f > *) &((ofMesh const *)arg1)->getNormals(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofVec3f_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getNormals(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Mesh_getNormals__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Mesh_getNormals__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_getNormals'\n" " Possible C/C++ prototypes are:\n" - " ofMesh::getNormals()\n" " ofMesh::getNormals() const\n"); lua_error(L);return 0; } -static int _wrap_Mesh_haveNormalsChanged(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; bool result; - SWIG_check_num_args("ofMesh::haveNormalsChanged",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::haveNormalsChanged",1,"ofMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_haveNormalsChanged",1,SWIGTYPE_p_ofMesh); } result = (bool)(arg1)->haveNormalsChanged(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_hasNormals(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; bool result; - SWIG_check_num_args("ofMesh::hasNormals",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::hasNormals",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_hasNormals",1,SWIGTYPE_p_ofMesh); } result = (bool)((ofMesh const *)arg1)->hasNormals(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_enableNormals(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - SWIG_check_num_args("ofMesh::enableNormals",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::enableNormals",1,"ofMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_enableNormals",1,SWIGTYPE_p_ofMesh); } (arg1)->enableNormals(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_disableNormals(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - SWIG_check_num_args("ofMesh::disableNormals",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::disableNormals",1,"ofMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_disableNormals",1,SWIGTYPE_p_ofMesh); } (arg1)->disableNormals(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_usingNormals(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; bool result; - SWIG_check_num_args("ofMesh::usingNormals",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::usingNormals",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_usingNormals",1,SWIGTYPE_p_ofMesh); } result = (bool)((ofMesh const *)arg1)->usingNormals(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_smoothNormals(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; float arg2 ; - SWIG_check_num_args("ofMesh::smoothNormals",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::smoothNormals",1,"ofMesh *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::smoothNormals",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_smoothNormals",1,SWIGTYPE_p_ofMesh); } arg2 = (float)lua_tonumber(L, 2); (arg1)->smoothNormals(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getFace(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; ofIndexType arg2 ; - ofMeshFace result; SWIG_check_num_args("ofMesh::getFace",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getFace",1,"ofMesh const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::getFace",2,"ofIndexType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Mesh_getFace",1,SWIGTYPE_p_ofMesh); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); - result = ((ofMesh const *)arg1)->getFace(arg2); { ofMeshFace * resultptr = new ofMeshFace((const ofMeshFace &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMeshFace,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getFaceNormals__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; bool arg2 ; - SwigValueWrapper< std::vector< ofVec3f > > result; SWIG_check_num_args("ofMesh::getFaceNormals",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getFaceNormals",1,"ofMesh const *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofMesh::getFaceNormals",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_getFaceNormals",1,SWIGTYPE_p_ofMesh); } arg2 = (lua_toboolean(L, 2)!=0); - result = ((ofMesh const *)arg1)->getFaceNormals(arg2); { - std::vector< ofVec3f > * resultptr = new std::vector< ofVec3f >((const std::vector< ofVec3f > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_ofVec3f_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getFaceNormals__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - SwigValueWrapper< std::vector< ofVec3f > > result; SWIG_check_num_args("ofMesh::getFaceNormals",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getFaceNormals",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_getFaceNormals",1,SWIGTYPE_p_ofMesh); } result = ((ofMesh const *)arg1)->getFaceNormals(); { - std::vector< ofVec3f > * resultptr = new std::vector< ofVec3f >((const std::vector< ofVec3f > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_ofVec3f_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getFaceNormals(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Mesh_getFaceNormals__SWIG_1(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_Mesh_getFaceNormals__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_getFaceNormals'\n" - " Possible C/C++ prototypes are:\n" " ofMesh::getFaceNormals(bool) const\n" " ofMesh::getFaceNormals() const\n"); - lua_error(L);return 0; } -static int _wrap_Mesh_getUniqueFaces(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - std::vector< ofMeshFace > *result = 0 ; SWIG_check_num_args("ofMesh::getUniqueFaces",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getUniqueFaces",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_getUniqueFaces",1,SWIGTYPE_p_ofMesh); } - result = (std::vector< ofMeshFace > *) &((ofMesh const *)arg1)->getUniqueFaces(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofMeshFace_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getColor(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; ofIndexType arg2 ; - ofFloatColor result; SWIG_check_num_args("ofMesh::getColor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getColor",1,"ofMesh const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::getColor",2,"ofIndexType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Mesh_getColor",1,SWIGTYPE_p_ofMesh); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); - result = ((ofMesh const *)arg1)->getColor(arg2); { ofFloatColor * resultptr = new ofFloatColor((const ofFloatColor &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_addColor(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; ofFloatColor *arg2 = 0 ; - SWIG_check_num_args("ofMesh::addColor",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::addColor",1,"ofMesh *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMesh::addColor",2,"ofFloatColor const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Mesh_addColor",1,SWIGTYPE_p_ofMesh); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("Mesh_addColor",2,SWIGTYPE_p_ofColor_T_float_t); } (arg1)->addColor((ofFloatColor const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_addColors__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - std::vector< ofFloatColor > *arg2 = 0 ; SWIG_check_num_args("ofMesh::addColors",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::addColors",1,"ofMesh *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMesh::addColors",2,"std::vector< ofFloatColor > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Mesh_addColors",1,SWIGTYPE_p_ofMesh); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__vectorT_ofColor_T_float_t_t,0))){ - SWIG_fail_ptr("Mesh_addColors",2,SWIGTYPE_p_std__vectorT_ofColor_T_float_t_t); } - (arg1)->addColors((std::vector< ofFloatColor > const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Mesh_addColors__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - ofFloatColor *arg2 = (ofFloatColor *) 0 ; std::size_t arg3 ; SWIG_check_num_args("ofMesh::addColors",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::addColors",1,"ofMesh *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofMesh::addColors",2,"ofFloatColor const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh::addColors",3,"std::size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Mesh_addColors",1,SWIGTYPE_p_ofMesh); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("Mesh_addColors",2,SWIGTYPE_p_ofColor_T_float_t); } - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (std::size_t)lua_tonumber(L, 3); - (arg1)->addColors((ofFloatColor const *)arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_addColors(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_std__vectorT_ofColor_T_float_t_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Mesh_addColors__SWIG_0(L);} } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Mesh_addColors__SWIG_1(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_addColors'\n" " Possible C/C++ prototypes are:\n" - " ofMesh::addColors(std::vector< ofFloatColor > const &)\n" " ofMesh::addColors(ofFloatColor const *,std::size_t)\n"); - lua_error(L);return 0; } -static int _wrap_Mesh_removeColor(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; ofIndexType arg2 ; - SWIG_check_num_args("ofMesh::removeColor",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::removeColor",1,"ofMesh *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::removeColor",2,"ofIndexType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_removeColor",1,SWIGTYPE_p_ofMesh); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); - (arg1)->removeColor(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_setColor(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; ofIndexType arg2 ; - ofFloatColor *arg3 = 0 ; SWIG_check_num_args("ofMesh::setColor",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::setColor",1,"ofMesh *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::setColor",2,"ofIndexType"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofMesh::setColor",3,"ofFloatColor const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Mesh_setColor",1,SWIGTYPE_p_ofMesh); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("Mesh_setColor",3,SWIGTYPE_p_ofColor_T_float_t); } (arg1)->setColor(arg2,(ofFloatColor const &)*arg3); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_clearColors(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - SWIG_check_num_args("ofMesh::clearColors",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::clearColors",1,"ofMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_clearColors",1,SWIGTYPE_p_ofMesh); } (arg1)->clearColors(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getNumColors(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; std::size_t result; - SWIG_check_num_args("ofMesh::getNumColors",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getNumColors",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_getNumColors",1,SWIGTYPE_p_ofMesh); } result = (std::size_t)((ofMesh const *)arg1)->getNumColors(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getColorsPointer__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - ofFloatColor *result = 0 ; SWIG_check_num_args("ofMesh::getColorsPointer",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getColorsPointer",1,"ofMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_getColorsPointer",1,SWIGTYPE_p_ofMesh); } result = (ofFloatColor *)(arg1)->getColorsPointer(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getColorsPointer__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - ofFloatColor *result = 0 ; SWIG_check_num_args("ofMesh::getColorsPointer",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getColorsPointer",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_getColorsPointer",1,SWIGTYPE_p_ofMesh); } - result = (ofFloatColor *)((ofMesh const *)arg1)->getColorsPointer(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getColorsPointer(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Mesh_getColorsPointer__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Mesh_getColorsPointer__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_getColorsPointer'\n" - " Possible C/C++ prototypes are:\n" " ofMesh::getColorsPointer()\n" " ofMesh::getColorsPointer() const\n"); - lua_error(L);return 0; } -static int _wrap_Mesh_getColors__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - std::vector< ofFloatColor > *result = 0 ; SWIG_check_num_args("ofMesh::getColors",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getColors",1,"ofMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Mesh_getColors",1,SWIGTYPE_p_ofMesh); } - result = (std::vector< ofFloatColor > *) &(arg1)->getColors(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofColor_T_float_t_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getColors__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - std::vector< ofFloatColor > *result = 0 ; SWIG_check_num_args("ofMesh::getColors",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getColors",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Mesh_getColors",1,SWIGTYPE_p_ofMesh); } - result = (std::vector< ofFloatColor > *) &((ofMesh const *)arg1)->getColors(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofColor_T_float_t_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getColors(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Mesh_getColors__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Mesh_getColors__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_getColors'\n" " Possible C/C++ prototypes are:\n" - " ofMesh::getColors()\n" " ofMesh::getColors() const\n"); lua_error(L);return 0; } -static int _wrap_Mesh_haveColorsChanged(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; bool result; - SWIG_check_num_args("ofMesh::haveColorsChanged",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::haveColorsChanged",1,"ofMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_haveColorsChanged",1,SWIGTYPE_p_ofMesh); } result = (bool)(arg1)->haveColorsChanged(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_hasColors(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; bool result; - SWIG_check_num_args("ofMesh::hasColors",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::hasColors",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Mesh_hasColors",1,SWIGTYPE_p_ofMesh); } - result = (bool)((ofMesh const *)arg1)->hasColors(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_enableColors(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - SWIG_check_num_args("ofMesh::enableColors",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::enableColors",1,"ofMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_enableColors",1,SWIGTYPE_p_ofMesh); } (arg1)->enableColors(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_disableColors(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - SWIG_check_num_args("ofMesh::disableColors",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::disableColors",1,"ofMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_disableColors",1,SWIGTYPE_p_ofMesh); } (arg1)->disableColors(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_usingColors(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; bool result; - SWIG_check_num_args("ofMesh::usingColors",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::usingColors",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_usingColors",1,SWIGTYPE_p_ofMesh); } result = (bool)((ofMesh const *)arg1)->usingColors(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getTexCoord(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; ofIndexType arg2 ; - ofVec2f result; SWIG_check_num_args("ofMesh::getTexCoord",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getTexCoord",1,"ofMesh const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::getTexCoord",2,"ofIndexType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_getTexCoord",1,SWIGTYPE_p_ofMesh); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); - result = ((ofMesh const *)arg1)->getTexCoord(arg2); { ofVec2f * resultptr = new ofVec2f((const ofVec2f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_addTexCoord(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; ofVec2f *arg2 = 0 ; - SWIG_check_num_args("ofMesh::addTexCoord",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::addTexCoord",1,"ofMesh *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMesh::addTexCoord",2,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_addTexCoord",1,SWIGTYPE_p_ofMesh); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Mesh_addTexCoord",2,SWIGTYPE_p_ofVec2f); } (arg1)->addTexCoord((ofVec2f const &)*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_addTexCoords__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - std::vector< ofVec2f > *arg2 = 0 ; SWIG_check_num_args("ofMesh::addTexCoords",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::addTexCoords",1,"ofMesh *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMesh::addTexCoords",2,"std::vector< ofVec2f > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_addTexCoords",1,SWIGTYPE_p_ofMesh); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__vectorT_ofVec2f_t,0))){ - SWIG_fail_ptr("Mesh_addTexCoords",2,SWIGTYPE_p_std__vectorT_ofVec2f_t); } - (arg1)->addTexCoords((std::vector< ofVec2f > const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Mesh_addTexCoords__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - ofVec2f *arg2 = (ofVec2f *) 0 ; std::size_t arg3 ; SWIG_check_num_args("ofMesh::addTexCoords",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::addTexCoords",1,"ofMesh *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofMesh::addTexCoords",2,"ofVec2f const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh::addTexCoords",3,"std::size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_addTexCoords",1,SWIGTYPE_p_ofMesh); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Mesh_addTexCoords",2,SWIGTYPE_p_ofVec2f); } - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (std::size_t)lua_tonumber(L, 3); - (arg1)->addTexCoords((ofVec2f const *)arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_addTexCoords(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_std__vectorT_ofVec2f_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Mesh_addTexCoords__SWIG_0(L);} } } if (argc == 3) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Mesh_addTexCoords__SWIG_1(L);} - } } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_addTexCoords'\n" - " Possible C/C++ prototypes are:\n" " ofMesh::addTexCoords(std::vector< ofVec2f > const &)\n" - " ofMesh::addTexCoords(ofVec2f const *,std::size_t)\n"); lua_error(L);return 0; } -static int _wrap_Mesh_removeTexCoord(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; ofIndexType arg2 ; - SWIG_check_num_args("ofMesh::removeTexCoord",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::removeTexCoord",1,"ofMesh *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::removeTexCoord",2,"ofIndexType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_removeTexCoord",1,SWIGTYPE_p_ofMesh); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); - (arg1)->removeTexCoord(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_setTexCoord(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; ofIndexType arg2 ; - ofVec2f *arg3 = 0 ; SWIG_check_num_args("ofMesh::setTexCoord",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::setTexCoord",1,"ofMesh *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::setTexCoord",2,"ofIndexType"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofMesh::setTexCoord",3,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_setTexCoord",1,SWIGTYPE_p_ofMesh); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Mesh_setTexCoord",3,SWIGTYPE_p_ofVec2f); } (arg1)->setTexCoord(arg2,(ofVec2f const &)*arg3); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_clearTexCoords(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - SWIG_check_num_args("ofMesh::clearTexCoords",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::clearTexCoords",1,"ofMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_clearTexCoords",1,SWIGTYPE_p_ofMesh); } (arg1)->clearTexCoords(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getNumTexCoords(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; std::size_t result; - SWIG_check_num_args("ofMesh::getNumTexCoords",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getNumTexCoords",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_getNumTexCoords",1,SWIGTYPE_p_ofMesh); } - result = (std::size_t)((ofMesh const *)arg1)->getNumTexCoords(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getTexCoordsPointer__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - ofVec2f *result = 0 ; SWIG_check_num_args("ofMesh::getTexCoordsPointer",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getTexCoordsPointer",1,"ofMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_getTexCoordsPointer",1,SWIGTYPE_p_ofMesh); } result = (ofVec2f *)(arg1)->getTexCoordsPointer(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec2f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Mesh_getTexCoordsPointer__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - ofVec2f *result = 0 ; SWIG_check_num_args("ofMesh::getTexCoordsPointer",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getTexCoordsPointer",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_getTexCoordsPointer",1,SWIGTYPE_p_ofMesh); } - result = (ofVec2f *)((ofMesh const *)arg1)->getTexCoordsPointer(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec2f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Mesh_getTexCoordsPointer(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Mesh_getTexCoordsPointer__SWIG_0(L);} } if (argc == 1) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Mesh_getTexCoordsPointer__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_getTexCoordsPointer'\n" - " Possible C/C++ prototypes are:\n" " ofMesh::getTexCoordsPointer()\n" " ofMesh::getTexCoordsPointer() const\n"); - lua_error(L);return 0; } -static int _wrap_Mesh_getTexCoords__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - std::vector< ofVec2f > *result = 0 ; SWIG_check_num_args("ofMesh::getTexCoords",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getTexCoords",1,"ofMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_getTexCoords",1,SWIGTYPE_p_ofMesh); } result = (std::vector< ofVec2f > *) &(arg1)->getTexCoords(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofVec2f_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getTexCoords__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - std::vector< ofVec2f > *result = 0 ; SWIG_check_num_args("ofMesh::getTexCoords",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getTexCoords",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_getTexCoords",1,SWIGTYPE_p_ofMesh); } - result = (std::vector< ofVec2f > *) &((ofMesh const *)arg1)->getTexCoords(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofVec2f_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getTexCoords(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Mesh_getTexCoords__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Mesh_getTexCoords__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_getTexCoords'\n" " Possible C/C++ prototypes are:\n" - " ofMesh::getTexCoords()\n" " ofMesh::getTexCoords() const\n"); lua_error(L);return 0; } -static int _wrap_Mesh_haveTexCoordsChanged(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; bool result; - SWIG_check_num_args("ofMesh::haveTexCoordsChanged",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::haveTexCoordsChanged",1,"ofMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_haveTexCoordsChanged",1,SWIGTYPE_p_ofMesh); } result = (bool)(arg1)->haveTexCoordsChanged(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_hasTexCoords(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; bool result; - SWIG_check_num_args("ofMesh::hasTexCoords",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::hasTexCoords",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_hasTexCoords",1,SWIGTYPE_p_ofMesh); } result = (bool)((ofMesh const *)arg1)->hasTexCoords(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_enableTextures(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - SWIG_check_num_args("ofMesh::enableTextures",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::enableTextures",1,"ofMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_enableTextures",1,SWIGTYPE_p_ofMesh); } (arg1)->enableTextures(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_disableTextures(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - SWIG_check_num_args("ofMesh::disableTextures",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::disableTextures",1,"ofMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_disableTextures",1,SWIGTYPE_p_ofMesh); } (arg1)->disableTextures(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_usingTextures(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; bool result; - SWIG_check_num_args("ofMesh::usingTextures",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::usingTextures",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_usingTextures",1,SWIGTYPE_p_ofMesh); } result = (bool)((ofMesh const *)arg1)->usingTextures(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_setupIndicesAuto(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - SWIG_check_num_args("ofMesh::setupIndicesAuto",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::setupIndicesAuto",1,"ofMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_setupIndicesAuto",1,SWIGTYPE_p_ofMesh); } (arg1)->setupIndicesAuto(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getIndices__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - std::vector< ofIndexType > *result = 0 ; SWIG_check_num_args("ofMesh::getIndices",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getIndices",1,"ofMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_getIndices",1,SWIGTYPE_p_ofMesh); } result = (std::vector< ofIndexType > *) &(arg1)->getIndices(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_unsigned_int_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getIndex(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; ofIndexType arg2 ; - ofIndexType result; SWIG_check_num_args("ofMesh::getIndex",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getIndex",1,"ofMesh const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::getIndex",2,"ofIndexType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Mesh_getIndex",1,SWIGTYPE_p_ofMesh); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); - result = (ofIndexType)((ofMesh const *)arg1)->getIndex(arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_addIndex(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; ofIndexType arg2 ; - SWIG_check_num_args("ofMesh::addIndex",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::addIndex",1,"ofMesh *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::addIndex",2,"ofIndexType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Mesh_addIndex",1,SWIGTYPE_p_ofMesh); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); - (arg1)->addIndex(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_addIndices__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - std::vector< ofIndexType > *arg2 = 0 ; SWIG_check_num_args("ofMesh::addIndices",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::addIndices",1,"ofMesh *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMesh::addIndices",2,"std::vector< ofIndexType > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_addIndices",1,SWIGTYPE_p_ofMesh); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__vectorT_unsigned_int_t,0))){ - SWIG_fail_ptr("Mesh_addIndices",2,SWIGTYPE_p_std__vectorT_unsigned_int_t); } - (arg1)->addIndices((std::vector< ofIndexType > const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Mesh_addIndices__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - ofIndexType *arg2 = (ofIndexType *) 0 ; std::size_t arg3 ; SWIG_check_num_args("ofMesh::addIndices",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::addIndices",1,"ofMesh *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofMesh::addIndices",2,"ofIndexType const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh::addIndices",3,"std::size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_addIndices",1,SWIGTYPE_p_ofMesh); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_unsigned_int,0))){ - SWIG_fail_ptr("Mesh_addIndices",2,SWIGTYPE_p_unsigned_int); } - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (std::size_t)lua_tonumber(L, 3); - (arg1)->addIndices((ofIndexType const *)arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_addIndices(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_std__vectorT_unsigned_int_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Mesh_addIndices__SWIG_0(L);} } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_unsigned_int, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Mesh_addIndices__SWIG_1(L);} } - } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_addIndices'\n" - " Possible C/C++ prototypes are:\n" " ofMesh::addIndices(std::vector< ofIndexType > const &)\n" - " ofMesh::addIndices(ofIndexType const *,std::size_t)\n"); lua_error(L);return 0; } -static int _wrap_Mesh_removeIndex(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; ofIndexType arg2 ; - SWIG_check_num_args("ofMesh::removeIndex",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::removeIndex",1,"ofMesh *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::removeIndex",2,"ofIndexType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_removeIndex",1,SWIGTYPE_p_ofMesh); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); - (arg1)->removeIndex(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_setIndex(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; ofIndexType arg2 ; - ofIndexType arg3 ; SWIG_check_num_args("ofMesh::setIndex",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::setIndex",1,"ofMesh *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::setIndex",2,"ofIndexType"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh::setIndex",3,"ofIndexType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Mesh_setIndex",1,SWIGTYPE_p_ofMesh); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (ofIndexType)lua_tonumber(L, 3); - (arg1)->setIndex(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_clearIndices(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - SWIG_check_num_args("ofMesh::clearIndices",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::clearIndices",1,"ofMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_clearIndices",1,SWIGTYPE_p_ofMesh); } (arg1)->clearIndices(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getNumIndices(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; std::size_t result; - SWIG_check_num_args("ofMesh::getNumIndices",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getNumIndices",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_getNumIndices",1,SWIGTYPE_p_ofMesh); } result = (std::size_t)((ofMesh const *)arg1)->getNumIndices(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getIndexPointer__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - ofIndexType *result = 0 ; SWIG_check_num_args("ofMesh::getIndexPointer",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getIndexPointer",1,"ofMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_getIndexPointer",1,SWIGTYPE_p_ofMesh); } result = (ofIndexType *)(arg1)->getIndexPointer(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_unsigned_int,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Mesh_getIndexPointer__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - ofIndexType *result = 0 ; SWIG_check_num_args("ofMesh::getIndexPointer",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getIndexPointer",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_getIndexPointer",1,SWIGTYPE_p_ofMesh); } - result = (ofIndexType *)((ofMesh const *)arg1)->getIndexPointer(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_unsigned_int,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Mesh_getIndexPointer(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Mesh_getIndexPointer__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Mesh_getIndexPointer__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_getIndexPointer'\n" - " Possible C/C++ prototypes are:\n" " ofMesh::getIndexPointer()\n" " ofMesh::getIndexPointer() const\n"); - lua_error(L);return 0; } -static int _wrap_Mesh_getIndices__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - std::vector< ofIndexType > *result = 0 ; SWIG_check_num_args("ofMesh::getIndices",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getIndices",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_getIndices",1,SWIGTYPE_p_ofMesh); } - result = (std::vector< ofIndexType > *) &((ofMesh const *)arg1)->getIndices(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_unsigned_int_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getIndices(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Mesh_getIndices__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Mesh_getIndices__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_getIndices'\n" " Possible C/C++ prototypes are:\n" - " ofMesh::getIndices()\n" " ofMesh::getIndices() const\n"); lua_error(L);return 0; } -static int _wrap_Mesh_haveIndicesChanged(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; bool result; - SWIG_check_num_args("ofMesh::haveIndicesChanged",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::haveIndicesChanged",1,"ofMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_haveIndicesChanged",1,SWIGTYPE_p_ofMesh); } result = (bool)(arg1)->haveIndicesChanged(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_hasIndices(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; bool result; - SWIG_check_num_args("ofMesh::hasIndices",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::hasIndices",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_hasIndices",1,SWIGTYPE_p_ofMesh); } result = (bool)((ofMesh const *)arg1)->hasIndices(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_addTriangle(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; ofIndexType arg2 ; - ofIndexType arg3 ; ofIndexType arg4 ; SWIG_check_num_args("ofMesh::addTriangle",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::addTriangle",1,"ofMesh *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::addTriangle",2,"ofIndexType"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh::addTriangle",3,"ofIndexType"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMesh::addTriangle",4,"ofIndexType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_addTriangle",1,SWIGTYPE_p_ofMesh); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (ofIndexType)lua_tonumber(L, 3); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (ofIndexType)lua_tonumber(L, 4); - (arg1)->addTriangle(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_enableIndices(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - SWIG_check_num_args("ofMesh::enableIndices",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::enableIndices",1,"ofMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_enableIndices",1,SWIGTYPE_p_ofMesh); } (arg1)->enableIndices(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_disableIndices(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - SWIG_check_num_args("ofMesh::disableIndices",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::disableIndices",1,"ofMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_disableIndices",1,SWIGTYPE_p_ofMesh); } (arg1)->disableIndices(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_usingIndices(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; bool result; - SWIG_check_num_args("ofMesh::usingIndices",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::usingIndices",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_usingIndices",1,SWIGTYPE_p_ofMesh); } result = (bool)((ofMesh const *)arg1)->usingIndices(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_setColorForIndices(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; ofIndexType arg2 ; - ofIndexType arg3 ; ofColor arg4 ; ofColor *argp4 ; SWIG_check_num_args("ofMesh::setColorForIndices",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::setColorForIndices",1,"ofMesh *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::setColorForIndices",2,"ofIndexType"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh::setColorForIndices",3,"ofIndexType"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofMesh::setColorForIndices",4,"ofColor"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_setColorForIndices",1,SWIGTYPE_p_ofMesh); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (ofIndexType)lua_tonumber(L, 3); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&argp4,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Mesh_setColorForIndices",4,SWIGTYPE_p_ofColor_T_unsigned_char_t); } arg4 = *argp4; - (arg1)->setColorForIndices(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getMeshForIndices__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - ofIndexType arg2 ; ofIndexType arg3 ; ofMesh result; SWIG_check_num_args("ofMesh::getMeshForIndices",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getMeshForIndices",1,"ofMesh const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::getMeshForIndices",2,"ofIndexType"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh::getMeshForIndices",3,"ofIndexType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_getMeshForIndices",1,SWIGTYPE_p_ofMesh); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (ofIndexType)lua_tonumber(L, 3); - result = ((ofMesh const *)arg1)->getMeshForIndices(arg2,arg3); { ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getMeshForIndices__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - ofIndexType arg2 ; ofIndexType arg3 ; ofIndexType arg4 ; ofIndexType arg5 ; ofMesh result; - SWIG_check_num_args("ofMesh::getMeshForIndices",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getMeshForIndices",1,"ofMesh const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::getMeshForIndices",2,"ofIndexType"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh::getMeshForIndices",3,"ofIndexType"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMesh::getMeshForIndices",4,"ofIndexType"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMesh::getMeshForIndices",5,"ofIndexType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_getMeshForIndices",1,SWIGTYPE_p_ofMesh); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (ofIndexType)lua_tonumber(L, 3); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (ofIndexType)lua_tonumber(L, 4); - SWIG_contract_assert((lua_tonumber(L,5)>=0),"number must not be negative") arg5 = (ofIndexType)lua_tonumber(L, 5); - result = ((ofMesh const *)arg1)->getMeshForIndices(arg2,arg3,arg4,arg5); { - ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getMeshForIndices(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Mesh_getMeshForIndices__SWIG_0(L);} } } } if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Mesh_getMeshForIndices__SWIG_1(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_getMeshForIndices'\n" - " Possible C/C++ prototypes are:\n" " ofMesh::getMeshForIndices(ofIndexType,ofIndexType) const\n" - " ofMesh::getMeshForIndices(ofIndexType,ofIndexType,ofIndexType,ofIndexType) const\n"); lua_error(L);return 0; } -static int _wrap_Mesh_drawVertices(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - SWIG_check_num_args("ofMesh::drawVertices",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::drawVertices",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_drawVertices",1,SWIGTYPE_p_ofMesh); } ((ofMesh const *)arg1)->drawVertices(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_drawWireframe(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - SWIG_check_num_args("ofMesh::drawWireframe",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::drawWireframe",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_drawWireframe",1,SWIGTYPE_p_ofMesh); } ((ofMesh const *)arg1)->drawWireframe(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_drawFaces(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - SWIG_check_num_args("ofMesh::drawFaces",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::drawFaces",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Mesh_drawFaces",1,SWIGTYPE_p_ofMesh); } - ((ofMesh const *)arg1)->drawFaces(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_draw__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - SWIG_check_num_args("ofMesh::draw",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::draw",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Mesh_draw",1,SWIGTYPE_p_ofMesh); } - ((ofMesh const *)arg1)->draw(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_draw__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; ofPolyRenderMode arg2 ; - SWIG_check_num_args("ofMesh::draw",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::draw",1,"ofMesh const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::draw",2,"ofPolyRenderMode"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Mesh_draw",1,SWIGTYPE_p_ofMesh); } - arg2 = (ofPolyRenderMode)(int)lua_tonumber(L, 2); ((ofMesh const *)arg1)->draw(arg2); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_draw(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Mesh_draw__SWIG_0(L);} } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Mesh_draw__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_draw'\n" " Possible C/C++ prototypes are:\n" - " ofMesh::draw() const\n" " ofMesh::draw(ofPolyRenderMode) const\n"); lua_error(L);return 0; } -static int _wrap_Mesh_load(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; std::string arg2 ; - SWIG_check_num_args("ofMesh::load",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::load",1,"ofMesh *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofMesh::load",2,"std::string"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Mesh_load",1,SWIGTYPE_p_ofMesh); } - (&arg2)->assign(lua_tostring(L,2),lua_rawlen(L,2)); (arg1)->load(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Mesh_save__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; std::string arg2 ; - bool arg3 ; SWIG_check_num_args("ofMesh::save",3,3) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::save",1,"ofMesh const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofMesh::save",2,"std::string"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofMesh::save",3,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Mesh_save",1,SWIGTYPE_p_ofMesh); } - (&arg2)->assign(lua_tostring(L,2),lua_rawlen(L,2)); arg3 = (lua_toboolean(L, 3)!=0); ((ofMesh const *)arg1)->save(arg2,arg3); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_save__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; std::string arg2 ; - SWIG_check_num_args("ofMesh::save",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::save",1,"ofMesh const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofMesh::save",2,"std::string"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Mesh_save",1,SWIGTYPE_p_ofMesh); } - (&arg2)->assign(lua_tostring(L,2),lua_rawlen(L,2)); ((ofMesh const *)arg1)->save(arg2); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_save(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { - return _wrap_Mesh_save__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - return _wrap_Mesh_save__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_save'\n" " Possible C/C++ prototypes are:\n" - " ofMesh::save(std::string,bool) const\n" " ofMesh::save(std::string) const\n"); lua_error(L);return 0; } -static void swig_delete_Mesh(void *obj) { -ofMesh *arg1 = (ofMesh *) obj; -delete_ofMesh(arg1); -} -static int _proxy__wrap_new_Mesh(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_Mesh); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_Mesh_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_Mesh_methods[]= { - { "setFromTriangles", _wrap_Mesh_setFromTriangles}, - { "setMode", _wrap_Mesh_setMode}, - { "getMode", _wrap_Mesh_getMode}, - { "addVertex", _wrap_Mesh_addVertex}, - { "addVertices", _wrap_Mesh_addVertices}, - { "removeVertex", _wrap_Mesh_removeVertex}, - { "setVertex", _wrap_Mesh_setVertex}, - { "clearVertices", _wrap_Mesh_clearVertices}, - { "clear", _wrap_Mesh_clear}, - { "getNumVertices", _wrap_Mesh_getNumVertices}, - { "getVerticesPointer", _wrap_Mesh_getVerticesPointer}, - { "getVertex", _wrap_Mesh_getVertex}, - { "getVertices", _wrap_Mesh_getVertices}, - { "haveVertsChanged", _wrap_Mesh_haveVertsChanged}, - { "hasVertices", _wrap_Mesh_hasVertices}, - { "append", _wrap_Mesh_append}, - { "mergeDuplicateVertices", _wrap_Mesh_mergeDuplicateVertices}, - { "getCentroid", _wrap_Mesh_getCentroid}, - { "getNormal", _wrap_Mesh_getNormal}, - { "addNormal", _wrap_Mesh_addNormal}, - { "addNormals", _wrap_Mesh_addNormals}, - { "removeNormal", _wrap_Mesh_removeNormal}, - { "setNormal", _wrap_Mesh_setNormal}, - { "clearNormals", _wrap_Mesh_clearNormals}, - { "getNumNormals", _wrap_Mesh_getNumNormals}, - { "getNormalsPointer", _wrap_Mesh_getNormalsPointer}, - { "getNormals", _wrap_Mesh_getNormals}, - { "haveNormalsChanged", _wrap_Mesh_haveNormalsChanged}, - { "hasNormals", _wrap_Mesh_hasNormals}, - { "enableNormals", _wrap_Mesh_enableNormals}, - { "disableNormals", _wrap_Mesh_disableNormals}, - { "usingNormals", _wrap_Mesh_usingNormals}, - { "smoothNormals", _wrap_Mesh_smoothNormals}, - { "getFace", _wrap_Mesh_getFace}, - { "getFaceNormals", _wrap_Mesh_getFaceNormals}, - { "getUniqueFaces", _wrap_Mesh_getUniqueFaces}, - { "getColor", _wrap_Mesh_getColor}, - { "addColor", _wrap_Mesh_addColor}, - { "addColors", _wrap_Mesh_addColors}, - { "removeColor", _wrap_Mesh_removeColor}, - { "setColor", _wrap_Mesh_setColor}, - { "clearColors", _wrap_Mesh_clearColors}, - { "getNumColors", _wrap_Mesh_getNumColors}, - { "getColorsPointer", _wrap_Mesh_getColorsPointer}, - { "getColors", _wrap_Mesh_getColors}, - { "haveColorsChanged", _wrap_Mesh_haveColorsChanged}, - { "hasColors", _wrap_Mesh_hasColors}, - { "enableColors", _wrap_Mesh_enableColors}, - { "disableColors", _wrap_Mesh_disableColors}, - { "usingColors", _wrap_Mesh_usingColors}, - { "getTexCoord", _wrap_Mesh_getTexCoord}, - { "addTexCoord", _wrap_Mesh_addTexCoord}, - { "addTexCoords", _wrap_Mesh_addTexCoords}, - { "removeTexCoord", _wrap_Mesh_removeTexCoord}, - { "setTexCoord", _wrap_Mesh_setTexCoord}, - { "clearTexCoords", _wrap_Mesh_clearTexCoords}, - { "getNumTexCoords", _wrap_Mesh_getNumTexCoords}, - { "getTexCoordsPointer", _wrap_Mesh_getTexCoordsPointer}, - { "getTexCoords", _wrap_Mesh_getTexCoords}, - { "haveTexCoordsChanged", _wrap_Mesh_haveTexCoordsChanged}, - { "hasTexCoords", _wrap_Mesh_hasTexCoords}, - { "enableTextures", _wrap_Mesh_enableTextures}, - { "disableTextures", _wrap_Mesh_disableTextures}, - { "usingTextures", _wrap_Mesh_usingTextures}, - { "setupIndicesAuto", _wrap_Mesh_setupIndicesAuto}, - { "getIndex", _wrap_Mesh_getIndex}, - { "addIndex", _wrap_Mesh_addIndex}, - { "addIndices", _wrap_Mesh_addIndices}, - { "removeIndex", _wrap_Mesh_removeIndex}, - { "setIndex", _wrap_Mesh_setIndex}, - { "clearIndices", _wrap_Mesh_clearIndices}, - { "getNumIndices", _wrap_Mesh_getNumIndices}, - { "getIndexPointer", _wrap_Mesh_getIndexPointer}, - { "getIndices", _wrap_Mesh_getIndices}, - { "haveIndicesChanged", _wrap_Mesh_haveIndicesChanged}, - { "hasIndices", _wrap_Mesh_hasIndices}, - { "addTriangle", _wrap_Mesh_addTriangle}, - { "enableIndices", _wrap_Mesh_enableIndices}, - { "disableIndices", _wrap_Mesh_disableIndices}, - { "usingIndices", _wrap_Mesh_usingIndices}, - { "setColorForIndices", _wrap_Mesh_setColorForIndices}, - { "getMeshForIndices", _wrap_Mesh_getMeshForIndices}, - { "drawVertices", _wrap_Mesh_drawVertices}, - { "drawWireframe", _wrap_Mesh_drawWireframe}, - { "drawFaces", _wrap_Mesh_drawFaces}, - { "draw", _wrap_Mesh_draw}, - { "load", _wrap_Mesh_load}, - { "save", _wrap_Mesh_save}, - {0,0} -}; -static swig_lua_method swig_Mesh_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_Mesh_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_Mesh_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_Mesh_Sf_SwigStatic_methods[]= { - { "plane", _wrap_Mesh_plane}, - { "sphere", _wrap_Mesh_sphere}, - { "icosahedron", _wrap_Mesh_icosahedron}, - { "icosphere", _wrap_Mesh_icosphere}, - { "cylinder", _wrap_Mesh_cylinder}, - { "cone", _wrap_Mesh_cone}, - { "box", _wrap_Mesh_box}, - { "axis", _wrap_Mesh_axis}, - {0,0} -}; -static swig_lua_class* swig_Mesh_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_Mesh_Sf_SwigStatic = { - "Mesh", - swig_Mesh_Sf_SwigStatic_methods, - swig_Mesh_Sf_SwigStatic_attributes, - swig_Mesh_Sf_SwigStatic_constants, - swig_Mesh_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_Mesh_bases[] = {0}; -static const char *swig_Mesh_base_names[] = {0}; -static swig_lua_class _wrap_class_Mesh = { "Mesh", "Mesh", &SWIGTYPE_p_ofMesh,_proxy__wrap_new_Mesh, swig_delete_Mesh, swig_Mesh_methods, swig_Mesh_attributes, &swig_Mesh_Sf_SwigStatic, swig_Mesh_meta, swig_Mesh_bases, swig_Mesh_base_names }; - -static int _wrap_new_MeshFace(lua_State* L) { int SWIG_arg = 0; ofMeshFace *result = 0 ; - SWIG_check_num_args("ofMeshFace::ofMeshFace",0,0) result = (ofMeshFace *)new ofMeshFace(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMeshFace,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_MeshFace_getFaceNormal(lua_State* L) { int SWIG_arg = 0; ofMeshFace *arg1 = (ofMeshFace *) 0 ; - ofVec3f *result = 0 ; SWIG_check_num_args("ofMeshFace::getFaceNormal",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMeshFace::getFaceNormal",1,"ofMeshFace const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMeshFace,0))){ - SWIG_fail_ptr("MeshFace_getFaceNormal",1,SWIGTYPE_p_ofMeshFace); } - result = (ofVec3f *) &((ofMeshFace const *)arg1)->getFaceNormal(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_MeshFace_setVertex(lua_State* L) { int SWIG_arg = 0; ofMeshFace *arg1 = (ofMeshFace *) 0 ; ofIndexType arg2 ; - ofVec3f *arg3 = 0 ; SWIG_check_num_args("ofMeshFace::setVertex",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMeshFace::setVertex",1,"ofMeshFace *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMeshFace::setVertex",2,"ofIndexType"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofMeshFace::setVertex",3,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMeshFace,0))){ - SWIG_fail_ptr("MeshFace_setVertex",1,SWIGTYPE_p_ofMeshFace); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("MeshFace_setVertex",3,SWIGTYPE_p_ofVec3f); } (arg1)->setVertex(arg2,(ofVec3f const &)*arg3); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_MeshFace_getVertex(lua_State* L) { int SWIG_arg = 0; ofMeshFace *arg1 = (ofMeshFace *) 0 ; ofIndexType arg2 ; - ofVec3f *result = 0 ; SWIG_check_num_args("ofMeshFace::getVertex",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMeshFace::getVertex",1,"ofMeshFace const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMeshFace::getVertex",2,"ofIndexType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMeshFace,0))){ - SWIG_fail_ptr("MeshFace_getVertex",1,SWIGTYPE_p_ofMeshFace); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); - result = (ofVec3f *) &((ofMeshFace const *)arg1)->getVertex(arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_MeshFace_setNormal(lua_State* L) { int SWIG_arg = 0; ofMeshFace *arg1 = (ofMeshFace *) 0 ; ofIndexType arg2 ; - ofVec3f *arg3 = 0 ; SWIG_check_num_args("ofMeshFace::setNormal",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMeshFace::setNormal",1,"ofMeshFace *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMeshFace::setNormal",2,"ofIndexType"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofMeshFace::setNormal",3,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMeshFace,0))){ - SWIG_fail_ptr("MeshFace_setNormal",1,SWIGTYPE_p_ofMeshFace); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("MeshFace_setNormal",3,SWIGTYPE_p_ofVec3f); } (arg1)->setNormal(arg2,(ofVec3f const &)*arg3); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_MeshFace_getNormal(lua_State* L) { int SWIG_arg = 0; ofMeshFace *arg1 = (ofMeshFace *) 0 ; ofIndexType arg2 ; - ofVec3f *result = 0 ; SWIG_check_num_args("ofMeshFace::getNormal",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMeshFace::getNormal",1,"ofMeshFace const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMeshFace::getNormal",2,"ofIndexType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMeshFace,0))){ - SWIG_fail_ptr("MeshFace_getNormal",1,SWIGTYPE_p_ofMeshFace); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); - result = (ofVec3f *) &((ofMeshFace const *)arg1)->getNormal(arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_MeshFace_setColor(lua_State* L) { int SWIG_arg = 0; ofMeshFace *arg1 = (ofMeshFace *) 0 ; ofIndexType arg2 ; - ofFloatColor *arg3 = 0 ; SWIG_check_num_args("ofMeshFace::setColor",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMeshFace::setColor",1,"ofMeshFace *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMeshFace::setColor",2,"ofIndexType"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofMeshFace::setColor",3,"ofFloatColor const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMeshFace,0))){ - SWIG_fail_ptr("MeshFace_setColor",1,SWIGTYPE_p_ofMeshFace); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("MeshFace_setColor",3,SWIGTYPE_p_ofColor_T_float_t); } (arg1)->setColor(arg2,(ofFloatColor const &)*arg3); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_MeshFace_getColor(lua_State* L) { int SWIG_arg = 0; ofMeshFace *arg1 = (ofMeshFace *) 0 ; ofIndexType arg2 ; - ofFloatColor *result = 0 ; SWIG_check_num_args("ofMeshFace::getColor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMeshFace::getColor",1,"ofMeshFace const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMeshFace::getColor",2,"ofIndexType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMeshFace,0))){ - SWIG_fail_ptr("MeshFace_getColor",1,SWIGTYPE_p_ofMeshFace); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); - result = (ofFloatColor *) &((ofMeshFace const *)arg1)->getColor(arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_MeshFace_setTexCoord(lua_State* L) { int SWIG_arg = 0; ofMeshFace *arg1 = (ofMeshFace *) 0 ; ofIndexType arg2 ; - ofVec2f *arg3 = 0 ; SWIG_check_num_args("ofMeshFace::setTexCoord",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMeshFace::setTexCoord",1,"ofMeshFace *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMeshFace::setTexCoord",2,"ofIndexType"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofMeshFace::setTexCoord",3,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMeshFace,0))){ - SWIG_fail_ptr("MeshFace_setTexCoord",1,SWIGTYPE_p_ofMeshFace); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("MeshFace_setTexCoord",3,SWIGTYPE_p_ofVec2f); } (arg1)->setTexCoord(arg2,(ofVec2f const &)*arg3); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_MeshFace_getTexCoord(lua_State* L) { int SWIG_arg = 0; ofMeshFace *arg1 = (ofMeshFace *) 0 ; ofIndexType arg2 ; - ofVec2f *result = 0 ; SWIG_check_num_args("ofMeshFace::getTexCoord",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMeshFace::getTexCoord",1,"ofMeshFace const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMeshFace::getTexCoord",2,"ofIndexType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMeshFace,0))){ - SWIG_fail_ptr("MeshFace_getTexCoord",1,SWIGTYPE_p_ofMeshFace); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); - result = (ofVec2f *) &((ofMeshFace const *)arg1)->getTexCoord(arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec2f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_MeshFace_setHasColors(lua_State* L) { int SWIG_arg = 0; ofMeshFace *arg1 = (ofMeshFace *) 0 ; bool arg2 ; - SWIG_check_num_args("ofMeshFace::setHasColors",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMeshFace::setHasColors",1,"ofMeshFace *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofMeshFace::setHasColors",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMeshFace,0))){ - SWIG_fail_ptr("MeshFace_setHasColors",1,SWIGTYPE_p_ofMeshFace); } arg2 = (lua_toboolean(L, 2)!=0); - (arg1)->setHasColors(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_MeshFace_setHasNormals(lua_State* L) { int SWIG_arg = 0; ofMeshFace *arg1 = (ofMeshFace *) 0 ; bool arg2 ; - SWIG_check_num_args("ofMeshFace::setHasNormals",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMeshFace::setHasNormals",1,"ofMeshFace *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofMeshFace::setHasNormals",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMeshFace,0))){ - SWIG_fail_ptr("MeshFace_setHasNormals",1,SWIGTYPE_p_ofMeshFace); } arg2 = (lua_toboolean(L, 2)!=0); - (arg1)->setHasNormals(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_MeshFace_setHasTexcoords(lua_State* L) { int SWIG_arg = 0; ofMeshFace *arg1 = (ofMeshFace *) 0 ; bool arg2 ; - SWIG_check_num_args("ofMeshFace::setHasTexcoords",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMeshFace::setHasTexcoords",1,"ofMeshFace *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofMeshFace::setHasTexcoords",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMeshFace,0))){ - SWIG_fail_ptr("MeshFace_setHasTexcoords",1,SWIGTYPE_p_ofMeshFace); } arg2 = (lua_toboolean(L, 2)!=0); - (arg1)->setHasTexcoords(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_MeshFace_hasColors(lua_State* L) { int SWIG_arg = 0; ofMeshFace *arg1 = (ofMeshFace *) 0 ; bool result; - SWIG_check_num_args("ofMeshFace::hasColors",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMeshFace::hasColors",1,"ofMeshFace const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMeshFace,0))){ - SWIG_fail_ptr("MeshFace_hasColors",1,SWIGTYPE_p_ofMeshFace); } result = (bool)((ofMeshFace const *)arg1)->hasColors(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_MeshFace_hasNormals(lua_State* L) { int SWIG_arg = 0; ofMeshFace *arg1 = (ofMeshFace *) 0 ; bool result; - SWIG_check_num_args("ofMeshFace::hasNormals",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMeshFace::hasNormals",1,"ofMeshFace const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMeshFace,0))){ - SWIG_fail_ptr("MeshFace_hasNormals",1,SWIGTYPE_p_ofMeshFace); } result = (bool)((ofMeshFace const *)arg1)->hasNormals(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_MeshFace_hasTexcoords(lua_State* L) { int SWIG_arg = 0; ofMeshFace *arg1 = (ofMeshFace *) 0 ; bool result; - SWIG_check_num_args("ofMeshFace::hasTexcoords",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMeshFace::hasTexcoords",1,"ofMeshFace const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMeshFace,0))){ - SWIG_fail_ptr("MeshFace_hasTexcoords",1,SWIGTYPE_p_ofMeshFace); } - result = (bool)((ofMeshFace const *)arg1)->hasTexcoords(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_MeshFace(void *obj) { -ofMeshFace *arg1 = (ofMeshFace *) obj; -delete arg1; -} -static int _proxy__wrap_new_MeshFace(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_MeshFace); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_MeshFace_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_MeshFace_methods[]= { - { "getFaceNormal", _wrap_MeshFace_getFaceNormal}, - { "setVertex", _wrap_MeshFace_setVertex}, - { "getVertex", _wrap_MeshFace_getVertex}, - { "setNormal", _wrap_MeshFace_setNormal}, - { "getNormal", _wrap_MeshFace_getNormal}, - { "setColor", _wrap_MeshFace_setColor}, - { "getColor", _wrap_MeshFace_getColor}, - { "setTexCoord", _wrap_MeshFace_setTexCoord}, - { "getTexCoord", _wrap_MeshFace_getTexCoord}, - { "setHasColors", _wrap_MeshFace_setHasColors}, - { "setHasNormals", _wrap_MeshFace_setHasNormals}, - { "setHasTexcoords", _wrap_MeshFace_setHasTexcoords}, - { "hasColors", _wrap_MeshFace_hasColors}, - { "hasNormals", _wrap_MeshFace_hasNormals}, - { "hasTexcoords", _wrap_MeshFace_hasTexcoords}, - {0,0} -}; -static swig_lua_method swig_MeshFace_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_MeshFace_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_MeshFace_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_MeshFace_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_MeshFace_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_MeshFace_Sf_SwigStatic = { - "MeshFace", - swig_MeshFace_Sf_SwigStatic_methods, - swig_MeshFace_Sf_SwigStatic_attributes, - swig_MeshFace_Sf_SwigStatic_constants, - swig_MeshFace_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_MeshFace_bases[] = {0}; -static const char *swig_MeshFace_base_names[] = {0}; -static swig_lua_class _wrap_class_MeshFace = { "MeshFace", "MeshFace", &SWIGTYPE_p_ofMeshFace,_proxy__wrap_new_MeshFace, swig_delete_MeshFace, swig_MeshFace_methods, swig_MeshFace_attributes, &swig_MeshFace_Sf_SwigStatic, swig_MeshFace_meta, swig_MeshFace_bases, swig_MeshFace_base_names }; - -static int _wrap_new_3dPrimitive__SWIG_0(lua_State* L) { int SWIG_arg = 0; of3dPrimitive *result = 0 ; - SWIG_check_num_args("of3dPrimitive::of3dPrimitive",0,0) result = (of3dPrimitive *)new of3dPrimitive(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_of3dPrimitive,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_3dPrimitive__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = 0 ; of3dPrimitive *result = 0 ; - SWIG_check_num_args("of3dPrimitive::of3dPrimitive",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("of3dPrimitive::of3dPrimitive",1,"ofMesh const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("new_3dPrimitive",1,SWIGTYPE_p_ofMesh); } result = (of3dPrimitive *)new of3dPrimitive((ofMesh const &)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_of3dPrimitive,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_3dPrimitive__SWIG_2(lua_State* L) { int SWIG_arg = 0; of3dPrimitive *arg1 = 0 ; of3dPrimitive *result = 0 ; - SWIG_check_num_args("of3dPrimitive::of3dPrimitive",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("of3dPrimitive::of3dPrimitive",1,"of3dPrimitive const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_of3dPrimitive,0))){ - SWIG_fail_ptr("new_3dPrimitive",1,SWIGTYPE_p_of3dPrimitive); } - result = (of3dPrimitive *)new of3dPrimitive((of3dPrimitive const &)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_of3dPrimitive,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_3dPrimitive(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_3dPrimitive__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_new_3dPrimitive__SWIG_1(L);} } if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_of3dPrimitive, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_new_3dPrimitive__SWIG_2(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_3dPrimitive'\n" " Possible C/C++ prototypes are:\n" - " of3dPrimitive::of3dPrimitive()\n" " of3dPrimitive::of3dPrimitive(ofMesh const &)\n" - " of3dPrimitive::of3dPrimitive(of3dPrimitive const &)\n"); lua_error(L);return 0; } -static int _wrap_3dPrimitive_mapTexCoords(lua_State* L) { int SWIG_arg = 0; of3dPrimitive *arg1 = (of3dPrimitive *) 0 ; - float arg2 ; float arg3 ; float arg4 ; float arg5 ; SWIG_check_num_args("of3dPrimitive::mapTexCoords",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("of3dPrimitive::mapTexCoords",1,"of3dPrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("of3dPrimitive::mapTexCoords",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("of3dPrimitive::mapTexCoords",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("of3dPrimitive::mapTexCoords",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("of3dPrimitive::mapTexCoords",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_of3dPrimitive,0))){ - SWIG_fail_ptr("3dPrimitive_mapTexCoords",1,SWIGTYPE_p_of3dPrimitive); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - (arg1)->mapTexCoords(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_3dPrimitive_mapTexCoordsFromTexture(lua_State* L) { int SWIG_arg = 0; - of3dPrimitive *arg1 = (of3dPrimitive *) 0 ; ofTexture *arg2 = 0 ; - SWIG_check_num_args("of3dPrimitive::mapTexCoordsFromTexture",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("of3dPrimitive::mapTexCoordsFromTexture",1,"of3dPrimitive *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("of3dPrimitive::mapTexCoordsFromTexture",2,"ofTexture &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_of3dPrimitive,0))){ - SWIG_fail_ptr("3dPrimitive_mapTexCoordsFromTexture",1,SWIGTYPE_p_of3dPrimitive); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("3dPrimitive_mapTexCoordsFromTexture",2,SWIGTYPE_p_ofTexture); } (arg1)->mapTexCoordsFromTexture(*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_3dPrimitive_getMeshPtr__SWIG_0(lua_State* L) { int SWIG_arg = 0; of3dPrimitive *arg1 = (of3dPrimitive *) 0 ; - ofMesh *result = 0 ; SWIG_check_num_args("of3dPrimitive::getMeshPtr",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("of3dPrimitive::getMeshPtr",1,"of3dPrimitive *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_of3dPrimitive,0))){ - SWIG_fail_ptr("3dPrimitive_getMeshPtr",1,SWIGTYPE_p_of3dPrimitive); } result = (ofMesh *)(arg1)->getMeshPtr(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMesh,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_3dPrimitive_getMesh__SWIG_0(lua_State* L) { int SWIG_arg = 0; of3dPrimitive *arg1 = (of3dPrimitive *) 0 ; - ofMesh *result = 0 ; SWIG_check_num_args("of3dPrimitive::getMesh",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("of3dPrimitive::getMesh",1,"of3dPrimitive *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_of3dPrimitive,0))){ - SWIG_fail_ptr("3dPrimitive_getMesh",1,SWIGTYPE_p_of3dPrimitive); } result = (ofMesh *) &(arg1)->getMesh(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMesh,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_3dPrimitive_getMeshPtr__SWIG_1(lua_State* L) { int SWIG_arg = 0; of3dPrimitive *arg1 = (of3dPrimitive *) 0 ; - ofMesh *result = 0 ; SWIG_check_num_args("of3dPrimitive::getMeshPtr",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("of3dPrimitive::getMeshPtr",1,"of3dPrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_of3dPrimitive,0))){ - SWIG_fail_ptr("3dPrimitive_getMeshPtr",1,SWIGTYPE_p_of3dPrimitive); } - result = (ofMesh *)((of3dPrimitive const *)arg1)->getMeshPtr(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMesh,0); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_3dPrimitive_getMeshPtr(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_of3dPrimitive, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_3dPrimitive_getMeshPtr__SWIG_0(L);} } if (argc == 1) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_of3dPrimitive, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_3dPrimitive_getMeshPtr__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function '3dPrimitive_getMeshPtr'\n" - " Possible C/C++ prototypes are:\n" " of3dPrimitive::getMeshPtr()\n" " of3dPrimitive::getMeshPtr() const\n"); - lua_error(L);return 0; } -static int _wrap_3dPrimitive_getMesh__SWIG_1(lua_State* L) { int SWIG_arg = 0; of3dPrimitive *arg1 = (of3dPrimitive *) 0 ; - ofMesh *result = 0 ; SWIG_check_num_args("of3dPrimitive::getMesh",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("of3dPrimitive::getMesh",1,"of3dPrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_of3dPrimitive,0))){ - SWIG_fail_ptr("3dPrimitive_getMesh",1,SWIGTYPE_p_of3dPrimitive); } - result = (ofMesh *) &((of3dPrimitive const *)arg1)->getMesh(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMesh,0); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_3dPrimitive_getMesh(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_of3dPrimitive, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_3dPrimitive_getMesh__SWIG_0(L);} } if (argc == 1) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_of3dPrimitive, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_3dPrimitive_getMesh__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function '3dPrimitive_getMesh'\n" - " Possible C/C++ prototypes are:\n" " of3dPrimitive::getMesh()\n" " of3dPrimitive::getMesh() const\n"); - lua_error(L);return 0; } -static int _wrap_3dPrimitive_getTexCoordsPtr__SWIG_0(lua_State* L) { int SWIG_arg = 0; - of3dPrimitive *arg1 = (of3dPrimitive *) 0 ; ofVec4f *result = 0 ; SWIG_check_num_args("of3dPrimitive::getTexCoordsPtr",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("of3dPrimitive::getTexCoordsPtr",1,"of3dPrimitive *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_of3dPrimitive,0))){ - SWIG_fail_ptr("3dPrimitive_getTexCoordsPtr",1,SWIGTYPE_p_of3dPrimitive); } result = (ofVec4f *)(arg1)->getTexCoordsPtr(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec4f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_3dPrimitive_getTexCoords__SWIG_0(lua_State* L) { int SWIG_arg = 0; of3dPrimitive *arg1 = (of3dPrimitive *) 0 ; - ofVec4f *result = 0 ; SWIG_check_num_args("of3dPrimitive::getTexCoords",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("of3dPrimitive::getTexCoords",1,"of3dPrimitive *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_of3dPrimitive,0))){ - SWIG_fail_ptr("3dPrimitive_getTexCoords",1,SWIGTYPE_p_of3dPrimitive); } result = (ofVec4f *) &(arg1)->getTexCoords(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec4f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_3dPrimitive_getTexCoordsPtr__SWIG_1(lua_State* L) { int SWIG_arg = 0; - of3dPrimitive *arg1 = (of3dPrimitive *) 0 ; ofVec4f *result = 0 ; SWIG_check_num_args("of3dPrimitive::getTexCoordsPtr",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("of3dPrimitive::getTexCoordsPtr",1,"of3dPrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_of3dPrimitive,0))){ - SWIG_fail_ptr("3dPrimitive_getTexCoordsPtr",1,SWIGTYPE_p_of3dPrimitive); } - result = (ofVec4f *)((of3dPrimitive const *)arg1)->getTexCoordsPtr(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec4f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_3dPrimitive_getTexCoordsPtr(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); - if (argc == 1) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_of3dPrimitive, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_3dPrimitive_getTexCoordsPtr__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_of3dPrimitive, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_3dPrimitive_getTexCoordsPtr__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function '3dPrimitive_getTexCoordsPtr'\n" - " Possible C/C++ prototypes are:\n" " of3dPrimitive::getTexCoordsPtr()\n" " of3dPrimitive::getTexCoordsPtr() const\n"); - lua_error(L);return 0; } -static int _wrap_3dPrimitive_getTexCoords__SWIG_1(lua_State* L) { int SWIG_arg = 0; of3dPrimitive *arg1 = (of3dPrimitive *) 0 ; - ofVec4f *result = 0 ; SWIG_check_num_args("of3dPrimitive::getTexCoords",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("of3dPrimitive::getTexCoords",1,"of3dPrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_of3dPrimitive,0))){ - SWIG_fail_ptr("3dPrimitive_getTexCoords",1,SWIGTYPE_p_of3dPrimitive); } - result = (ofVec4f *) &((of3dPrimitive const *)arg1)->getTexCoords(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec4f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_3dPrimitive_getTexCoords(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_of3dPrimitive, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_3dPrimitive_getTexCoords__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_of3dPrimitive, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_3dPrimitive_getTexCoords__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function '3dPrimitive_getTexCoords'\n" - " Possible C/C++ prototypes are:\n" " of3dPrimitive::getTexCoords()\n" " of3dPrimitive::getTexCoords() const\n"); - lua_error(L);return 0; } -static int _wrap_3dPrimitive_hasScaling(lua_State* L) { int SWIG_arg = 0; of3dPrimitive *arg1 = (of3dPrimitive *) 0 ; - bool result; SWIG_check_num_args("of3dPrimitive::hasScaling",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("of3dPrimitive::hasScaling",1,"of3dPrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_of3dPrimitive,0))){ - SWIG_fail_ptr("3dPrimitive_hasScaling",1,SWIGTYPE_p_of3dPrimitive); } - result = (bool)((of3dPrimitive const *)arg1)->hasScaling(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_3dPrimitive_hasNormalsEnabled(lua_State* L) { int SWIG_arg = 0; of3dPrimitive *arg1 = (of3dPrimitive *) 0 ; - bool result; SWIG_check_num_args("of3dPrimitive::hasNormalsEnabled",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("of3dPrimitive::hasNormalsEnabled",1,"of3dPrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_of3dPrimitive,0))){ - SWIG_fail_ptr("3dPrimitive_hasNormalsEnabled",1,SWIGTYPE_p_of3dPrimitive); } - result = (bool)((of3dPrimitive const *)arg1)->hasNormalsEnabled(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_3dPrimitive_enableNormals(lua_State* L) { int SWIG_arg = 0; of3dPrimitive *arg1 = (of3dPrimitive *) 0 ; - SWIG_check_num_args("of3dPrimitive::enableNormals",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("of3dPrimitive::enableNormals",1,"of3dPrimitive *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_of3dPrimitive,0))){ - SWIG_fail_ptr("3dPrimitive_enableNormals",1,SWIGTYPE_p_of3dPrimitive); } (arg1)->enableNormals(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_3dPrimitive_enableTextures(lua_State* L) { int SWIG_arg = 0; of3dPrimitive *arg1 = (of3dPrimitive *) 0 ; - SWIG_check_num_args("of3dPrimitive::enableTextures",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("of3dPrimitive::enableTextures",1,"of3dPrimitive *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_of3dPrimitive,0))){ - SWIG_fail_ptr("3dPrimitive_enableTextures",1,SWIGTYPE_p_of3dPrimitive); } (arg1)->enableTextures(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_3dPrimitive_enableColors(lua_State* L) { int SWIG_arg = 0; of3dPrimitive *arg1 = (of3dPrimitive *) 0 ; - SWIG_check_num_args("of3dPrimitive::enableColors",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("of3dPrimitive::enableColors",1,"of3dPrimitive *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_of3dPrimitive,0))){ - SWIG_fail_ptr("3dPrimitive_enableColors",1,SWIGTYPE_p_of3dPrimitive); } (arg1)->enableColors(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_3dPrimitive_disableNormals(lua_State* L) { int SWIG_arg = 0; of3dPrimitive *arg1 = (of3dPrimitive *) 0 ; - SWIG_check_num_args("of3dPrimitive::disableNormals",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("of3dPrimitive::disableNormals",1,"of3dPrimitive *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_of3dPrimitive,0))){ - SWIG_fail_ptr("3dPrimitive_disableNormals",1,SWIGTYPE_p_of3dPrimitive); } (arg1)->disableNormals(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_3dPrimitive_disableTextures(lua_State* L) { int SWIG_arg = 0; of3dPrimitive *arg1 = (of3dPrimitive *) 0 ; - SWIG_check_num_args("of3dPrimitive::disableTextures",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("of3dPrimitive::disableTextures",1,"of3dPrimitive *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_of3dPrimitive,0))){ - SWIG_fail_ptr("3dPrimitive_disableTextures",1,SWIGTYPE_p_of3dPrimitive); } (arg1)->disableTextures(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_3dPrimitive_disableColors(lua_State* L) { int SWIG_arg = 0; of3dPrimitive *arg1 = (of3dPrimitive *) 0 ; - SWIG_check_num_args("of3dPrimitive::disableColors",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("of3dPrimitive::disableColors",1,"of3dPrimitive *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_of3dPrimitive,0))){ - SWIG_fail_ptr("3dPrimitive_disableColors",1,SWIGTYPE_p_of3dPrimitive); } (arg1)->disableColors(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_3dPrimitive_drawVertices(lua_State* L) { int SWIG_arg = 0; of3dPrimitive *arg1 = (of3dPrimitive *) 0 ; - SWIG_check_num_args("of3dPrimitive::drawVertices",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("of3dPrimitive::drawVertices",1,"of3dPrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_of3dPrimitive,0))){ - SWIG_fail_ptr("3dPrimitive_drawVertices",1,SWIGTYPE_p_of3dPrimitive); } ((of3dPrimitive const *)arg1)->drawVertices(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_3dPrimitive_drawWireframe(lua_State* L) { int SWIG_arg = 0; of3dPrimitive *arg1 = (of3dPrimitive *) 0 ; - SWIG_check_num_args("of3dPrimitive::drawWireframe",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("of3dPrimitive::drawWireframe",1,"of3dPrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_of3dPrimitive,0))){ - SWIG_fail_ptr("3dPrimitive_drawWireframe",1,SWIGTYPE_p_of3dPrimitive); } ((of3dPrimitive const *)arg1)->drawWireframe(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_3dPrimitive_drawFaces(lua_State* L) { int SWIG_arg = 0; of3dPrimitive *arg1 = (of3dPrimitive *) 0 ; - SWIG_check_num_args("of3dPrimitive::drawFaces",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("of3dPrimitive::drawFaces",1,"of3dPrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_of3dPrimitive,0))){ - SWIG_fail_ptr("3dPrimitive_drawFaces",1,SWIGTYPE_p_of3dPrimitive); } ((of3dPrimitive const *)arg1)->drawFaces(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_3dPrimitive_draw(lua_State* L) { int SWIG_arg = 0; of3dPrimitive *arg1 = (of3dPrimitive *) 0 ; - ofPolyRenderMode arg2 ; SWIG_check_num_args("of3dPrimitive::draw",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("of3dPrimitive::draw",1,"of3dPrimitive const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("of3dPrimitive::draw",2,"ofPolyRenderMode"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_of3dPrimitive,0))){ - SWIG_fail_ptr("3dPrimitive_draw",1,SWIGTYPE_p_of3dPrimitive); } arg2 = (ofPolyRenderMode)(int)lua_tonumber(L, 2); - ((of3dPrimitive const *)arg1)->draw(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_3dPrimitive_drawNormals__SWIG_0(lua_State* L) { int SWIG_arg = 0; of3dPrimitive *arg1 = (of3dPrimitive *) 0 ; - float arg2 ; bool arg3 ; SWIG_check_num_args("of3dPrimitive::drawNormals",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("of3dPrimitive::drawNormals",1,"of3dPrimitive const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("of3dPrimitive::drawNormals",2,"float"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("of3dPrimitive::drawNormals",3,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_of3dPrimitive,0))){ - SWIG_fail_ptr("3dPrimitive_drawNormals",1,SWIGTYPE_p_of3dPrimitive); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (lua_toboolean(L, 3)!=0); ((of3dPrimitive const *)arg1)->drawNormals(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_3dPrimitive_drawNormals__SWIG_1(lua_State* L) { int SWIG_arg = 0; of3dPrimitive *arg1 = (of3dPrimitive *) 0 ; - float arg2 ; SWIG_check_num_args("of3dPrimitive::drawNormals",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("of3dPrimitive::drawNormals",1,"of3dPrimitive const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("of3dPrimitive::drawNormals",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_of3dPrimitive,0))){ - SWIG_fail_ptr("3dPrimitive_drawNormals",1,SWIGTYPE_p_of3dPrimitive); } arg2 = (float)lua_tonumber(L, 2); - ((of3dPrimitive const *)arg1)->drawNormals(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_3dPrimitive_drawNormals(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_of3dPrimitive, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_3dPrimitive_drawNormals__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_of3dPrimitive, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - return _wrap_3dPrimitive_drawNormals__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function '3dPrimitive_drawNormals'\n" - " Possible C/C++ prototypes are:\n" " of3dPrimitive::drawNormals(float,bool) const\n" - " of3dPrimitive::drawNormals(float) const\n"); lua_error(L);return 0; } -static int _wrap_3dPrimitive_drawAxes(lua_State* L) { int SWIG_arg = 0; of3dPrimitive *arg1 = (of3dPrimitive *) 0 ; float arg2 ; - SWIG_check_num_args("of3dPrimitive::drawAxes",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("of3dPrimitive::drawAxes",1,"of3dPrimitive const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("of3dPrimitive::drawAxes",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_of3dPrimitive,0))){ - SWIG_fail_ptr("3dPrimitive_drawAxes",1,SWIGTYPE_p_of3dPrimitive); } arg2 = (float)lua_tonumber(L, 2); - ((of3dPrimitive const *)arg1)->drawAxes(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_3dPrimitive_setUseVbo(lua_State* L) { int SWIG_arg = 0; of3dPrimitive *arg1 = (of3dPrimitive *) 0 ; bool arg2 ; - SWIG_check_num_args("of3dPrimitive::setUseVbo",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("of3dPrimitive::setUseVbo",1,"of3dPrimitive *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("of3dPrimitive::setUseVbo",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_of3dPrimitive,0))){ - SWIG_fail_ptr("3dPrimitive_setUseVbo",1,SWIGTYPE_p_of3dPrimitive); } arg2 = (lua_toboolean(L, 2)!=0); - (arg1)->setUseVbo(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_3dPrimitive_isUsingVbo(lua_State* L) { int SWIG_arg = 0; of3dPrimitive *arg1 = (of3dPrimitive *) 0 ; - bool result; SWIG_check_num_args("of3dPrimitive::isUsingVbo",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("of3dPrimitive::isUsingVbo",1,"of3dPrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_of3dPrimitive,0))){ - SWIG_fail_ptr("3dPrimitive_isUsingVbo",1,SWIGTYPE_p_of3dPrimitive); } - result = (bool)((of3dPrimitive const *)arg1)->isUsingVbo(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_3dPrimitive(void *obj) { -of3dPrimitive *arg1 = (of3dPrimitive *) obj; -delete arg1; -} -static int _proxy__wrap_new_3dPrimitive(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_3dPrimitive); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_3dPrimitive_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_3dPrimitive_methods[]= { - { "mapTexCoords", _wrap_3dPrimitive_mapTexCoords}, - { "mapTexCoordsFromTexture", _wrap_3dPrimitive_mapTexCoordsFromTexture}, - { "getMeshPtr", _wrap_3dPrimitive_getMeshPtr}, - { "getMesh", _wrap_3dPrimitive_getMesh}, - { "getTexCoordsPtr", _wrap_3dPrimitive_getTexCoordsPtr}, - { "getTexCoords", _wrap_3dPrimitive_getTexCoords}, - { "hasScaling", _wrap_3dPrimitive_hasScaling}, - { "hasNormalsEnabled", _wrap_3dPrimitive_hasNormalsEnabled}, - { "enableNormals", _wrap_3dPrimitive_enableNormals}, - { "enableTextures", _wrap_3dPrimitive_enableTextures}, - { "enableColors", _wrap_3dPrimitive_enableColors}, - { "disableNormals", _wrap_3dPrimitive_disableNormals}, - { "disableTextures", _wrap_3dPrimitive_disableTextures}, - { "disableColors", _wrap_3dPrimitive_disableColors}, - { "drawVertices", _wrap_3dPrimitive_drawVertices}, - { "drawWireframe", _wrap_3dPrimitive_drawWireframe}, - { "drawFaces", _wrap_3dPrimitive_drawFaces}, - { "drawNormals", _wrap_3dPrimitive_drawNormals}, - { "drawAxes", _wrap_3dPrimitive_drawAxes}, - { "setUseVbo", _wrap_3dPrimitive_setUseVbo}, - { "isUsingVbo", _wrap_3dPrimitive_isUsingVbo}, - {0,0} -}; -static swig_lua_method swig_3dPrimitive_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_3dPrimitive_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_3dPrimitive_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_3dPrimitive_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_3dPrimitive_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_3dPrimitive_Sf_SwigStatic = { - "3dPrimitive", - swig_3dPrimitive_Sf_SwigStatic_methods, - swig_3dPrimitive_Sf_SwigStatic_attributes, - swig_3dPrimitive_Sf_SwigStatic_constants, - swig_3dPrimitive_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_3dPrimitive_bases[] = {0,0}; -static const char *swig_3dPrimitive_base_names[] = {"ofNode *",0}; -static swig_lua_class _wrap_class_3dPrimitive = { "3dPrimitive", "3dPrimitive", &SWIGTYPE_p_of3dPrimitive,_proxy__wrap_new_3dPrimitive, swig_delete_3dPrimitive, swig_3dPrimitive_methods, swig_3dPrimitive_attributes, &swig_3dPrimitive_Sf_SwigStatic, swig_3dPrimitive_meta, swig_3dPrimitive_bases, swig_3dPrimitive_base_names }; - -static int _wrap_new_PlanePrimitive__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPlanePrimitive *result = 0 ; - SWIG_check_num_args("ofPlanePrimitive::ofPlanePrimitive",0,0) result = (ofPlanePrimitive *)new ofPlanePrimitive(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofPlanePrimitive,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_PlanePrimitive__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; int arg3 ; int arg4 ; - ofPrimitiveMode arg5 ; ofPlanePrimitive *result = 0 ; SWIG_check_num_args("ofPlanePrimitive::ofPlanePrimitive",5,5) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofPlanePrimitive::ofPlanePrimitive",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPlanePrimitive::ofPlanePrimitive",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPlanePrimitive::ofPlanePrimitive",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPlanePrimitive::ofPlanePrimitive",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPlanePrimitive::ofPlanePrimitive",5,"ofPrimitiveMode"); - arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); arg5 = (ofPrimitiveMode)(int)lua_tonumber(L, 5); - result = (ofPlanePrimitive *)new ofPlanePrimitive(arg1,arg2,arg3,arg4,arg5); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofPlanePrimitive,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_PlanePrimitive__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; int arg3 ; int arg4 ; - ofPlanePrimitive *result = 0 ; SWIG_check_num_args("ofPlanePrimitive::ofPlanePrimitive",4,4) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofPlanePrimitive::ofPlanePrimitive",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPlanePrimitive::ofPlanePrimitive",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPlanePrimitive::ofPlanePrimitive",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPlanePrimitive::ofPlanePrimitive",4,"int"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - result = (ofPlanePrimitive *)new ofPlanePrimitive(arg1,arg2,arg3,arg4); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofPlanePrimitive,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_PlanePrimitive(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); - if (argc == 0) { return _wrap_new_PlanePrimitive__SWIG_0(L);} if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_new_PlanePrimitive__SWIG_2(L);} } } } } - if (argc == 5) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_new_PlanePrimitive__SWIG_1(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_PlanePrimitive'\n" " Possible C/C++ prototypes are:\n" - " ofPlanePrimitive::ofPlanePrimitive()\n" " ofPlanePrimitive::ofPlanePrimitive(float,float,int,int,ofPrimitiveMode)\n" - " ofPlanePrimitive::ofPlanePrimitive(float,float,int,int)\n"); lua_error(L);return 0; } -static int _wrap_PlanePrimitive_set__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPlanePrimitive *arg1 = (ofPlanePrimitive *) 0 ; - float arg2 ; float arg3 ; int arg4 ; int arg5 ; ofPrimitiveMode arg6 ; SWIG_check_num_args("ofPlanePrimitive::set",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPlanePrimitive::set",1,"ofPlanePrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPlanePrimitive::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPlanePrimitive::set",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPlanePrimitive::set",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPlanePrimitive::set",5,"int"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPlanePrimitive::set",6,"ofPrimitiveMode"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPlanePrimitive,0))){ - SWIG_fail_ptr("PlanePrimitive_set",1,SWIGTYPE_p_ofPlanePrimitive); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); - arg6 = (ofPrimitiveMode)(int)lua_tonumber(L, 6); (arg1)->set(arg2,arg3,arg4,arg5,arg6); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_PlanePrimitive_set__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPlanePrimitive *arg1 = (ofPlanePrimitive *) 0 ; - float arg2 ; float arg3 ; int arg4 ; int arg5 ; SWIG_check_num_args("ofPlanePrimitive::set",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPlanePrimitive::set",1,"ofPlanePrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPlanePrimitive::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPlanePrimitive::set",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPlanePrimitive::set",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPlanePrimitive::set",5,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPlanePrimitive,0))){ - SWIG_fail_ptr("PlanePrimitive_set",1,SWIGTYPE_p_ofPlanePrimitive); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); - (arg1)->set(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_PlanePrimitive_set__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPlanePrimitive *arg1 = (ofPlanePrimitive *) 0 ; - float arg2 ; float arg3 ; SWIG_check_num_args("ofPlanePrimitive::set",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPlanePrimitive::set",1,"ofPlanePrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPlanePrimitive::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPlanePrimitive::set",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPlanePrimitive,0))){ - SWIG_fail_ptr("PlanePrimitive_set",1,SWIGTYPE_p_ofPlanePrimitive); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->set(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_PlanePrimitive_set(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPlanePrimitive, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_PlanePrimitive_set__SWIG_2(L);} } } } if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPlanePrimitive, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_PlanePrimitive_set__SWIG_1(L);} } } } } } if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPlanePrimitive, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { return _wrap_PlanePrimitive_set__SWIG_0(L);} } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'PlanePrimitive_set'\n" " Possible C/C++ prototypes are:\n" - " ofPlanePrimitive::set(float,float,int,int,ofPrimitiveMode)\n" " ofPlanePrimitive::set(float,float,int,int)\n" - " ofPlanePrimitive::set(float,float)\n"); lua_error(L);return 0; } -static int _wrap_PlanePrimitive_resizeToTexture__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofPlanePrimitive *arg1 = (ofPlanePrimitive *) 0 ; ofTexture *arg2 = 0 ; float arg3 ; - SWIG_check_num_args("ofPlanePrimitive::resizeToTexture",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPlanePrimitive::resizeToTexture",1,"ofPlanePrimitive *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPlanePrimitive::resizeToTexture",2,"ofTexture &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPlanePrimitive::resizeToTexture",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPlanePrimitive,0))){ - SWIG_fail_ptr("PlanePrimitive_resizeToTexture",1,SWIGTYPE_p_ofPlanePrimitive); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("PlanePrimitive_resizeToTexture",2,SWIGTYPE_p_ofTexture); } arg3 = (float)lua_tonumber(L, 3); - (arg1)->resizeToTexture(*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_PlanePrimitive_resizeToTexture__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofPlanePrimitive *arg1 = (ofPlanePrimitive *) 0 ; ofTexture *arg2 = 0 ; - SWIG_check_num_args("ofPlanePrimitive::resizeToTexture",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPlanePrimitive::resizeToTexture",1,"ofPlanePrimitive *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPlanePrimitive::resizeToTexture",2,"ofTexture &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPlanePrimitive,0))){ - SWIG_fail_ptr("PlanePrimitive_resizeToTexture",1,SWIGTYPE_p_ofPlanePrimitive); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("PlanePrimitive_resizeToTexture",2,SWIGTYPE_p_ofTexture); } (arg1)->resizeToTexture(*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_PlanePrimitive_resizeToTexture(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPlanePrimitive, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_PlanePrimitive_resizeToTexture__SWIG_1(L);} } } if (argc == 3) { int _v; - { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPlanePrimitive, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_PlanePrimitive_resizeToTexture__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'PlanePrimitive_resizeToTexture'\n" - " Possible C/C++ prototypes are:\n" " ofPlanePrimitive::resizeToTexture(ofTexture &,float)\n" - " ofPlanePrimitive::resizeToTexture(ofTexture &)\n"); lua_error(L);return 0; } -static int _wrap_PlanePrimitive_setWidth(lua_State* L) { int SWIG_arg = 0; ofPlanePrimitive *arg1 = (ofPlanePrimitive *) 0 ; - float arg2 ; SWIG_check_num_args("ofPlanePrimitive::setWidth",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPlanePrimitive::setWidth",1,"ofPlanePrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPlanePrimitive::setWidth",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPlanePrimitive,0))){ - SWIG_fail_ptr("PlanePrimitive_setWidth",1,SWIGTYPE_p_ofPlanePrimitive); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setWidth(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_PlanePrimitive_setHeight(lua_State* L) { int SWIG_arg = 0; ofPlanePrimitive *arg1 = (ofPlanePrimitive *) 0 ; - float arg2 ; SWIG_check_num_args("ofPlanePrimitive::setHeight",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPlanePrimitive::setHeight",1,"ofPlanePrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPlanePrimitive::setHeight",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPlanePrimitive,0))){ - SWIG_fail_ptr("PlanePrimitive_setHeight",1,SWIGTYPE_p_ofPlanePrimitive); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setHeight(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_PlanePrimitive_setColumns(lua_State* L) { int SWIG_arg = 0; ofPlanePrimitive *arg1 = (ofPlanePrimitive *) 0 ; - int arg2 ; SWIG_check_num_args("ofPlanePrimitive::setColumns",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPlanePrimitive::setColumns",1,"ofPlanePrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPlanePrimitive::setColumns",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPlanePrimitive,0))){ - SWIG_fail_ptr("PlanePrimitive_setColumns",1,SWIGTYPE_p_ofPlanePrimitive); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->setColumns(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_PlanePrimitive_setRows(lua_State* L) { int SWIG_arg = 0; ofPlanePrimitive *arg1 = (ofPlanePrimitive *) 0 ; - int arg2 ; SWIG_check_num_args("ofPlanePrimitive::setRows",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPlanePrimitive::setRows",1,"ofPlanePrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPlanePrimitive::setRows",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPlanePrimitive,0))){ - SWIG_fail_ptr("PlanePrimitive_setRows",1,SWIGTYPE_p_ofPlanePrimitive); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->setRows(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_PlanePrimitive_setResolution(lua_State* L) { int SWIG_arg = 0; - ofPlanePrimitive *arg1 = (ofPlanePrimitive *) 0 ; int arg2 ; int arg3 ; - SWIG_check_num_args("ofPlanePrimitive::setResolution",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPlanePrimitive::setResolution",1,"ofPlanePrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPlanePrimitive::setResolution",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPlanePrimitive::setResolution",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPlanePrimitive,0))){ - SWIG_fail_ptr("PlanePrimitive_setResolution",1,SWIGTYPE_p_ofPlanePrimitive); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); (arg1)->setResolution(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_PlanePrimitive_setMode(lua_State* L) { int SWIG_arg = 0; ofPlanePrimitive *arg1 = (ofPlanePrimitive *) 0 ; - ofPrimitiveMode arg2 ; SWIG_check_num_args("ofPlanePrimitive::setMode",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPlanePrimitive::setMode",1,"ofPlanePrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPlanePrimitive::setMode",2,"ofPrimitiveMode"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPlanePrimitive,0))){ - SWIG_fail_ptr("PlanePrimitive_setMode",1,SWIGTYPE_p_ofPlanePrimitive); } arg2 = (ofPrimitiveMode)(int)lua_tonumber(L, 2); - (arg1)->setMode(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_PlanePrimitive_getNumColumns(lua_State* L) { int SWIG_arg = 0; - ofPlanePrimitive *arg1 = (ofPlanePrimitive *) 0 ; int result; SWIG_check_num_args("ofPlanePrimitive::getNumColumns",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPlanePrimitive::getNumColumns",1,"ofPlanePrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPlanePrimitive,0))){ - SWIG_fail_ptr("PlanePrimitive_getNumColumns",1,SWIGTYPE_p_ofPlanePrimitive); } - result = (int)((ofPlanePrimitive const *)arg1)->getNumColumns(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_PlanePrimitive_getNumRows(lua_State* L) { int SWIG_arg = 0; ofPlanePrimitive *arg1 = (ofPlanePrimitive *) 0 ; - int result; SWIG_check_num_args("ofPlanePrimitive::getNumRows",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPlanePrimitive::getNumRows",1,"ofPlanePrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPlanePrimitive,0))){ - SWIG_fail_ptr("PlanePrimitive_getNumRows",1,SWIGTYPE_p_ofPlanePrimitive); } - result = (int)((ofPlanePrimitive const *)arg1)->getNumRows(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_PlanePrimitive_getResolution(lua_State* L) { int SWIG_arg = 0; - ofPlanePrimitive *arg1 = (ofPlanePrimitive *) 0 ; ofVec2f result; SWIG_check_num_args("ofPlanePrimitive::getResolution",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPlanePrimitive::getResolution",1,"ofPlanePrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPlanePrimitive,0))){ - SWIG_fail_ptr("PlanePrimitive_getResolution",1,SWIGTYPE_p_ofPlanePrimitive); } - result = ((ofPlanePrimitive const *)arg1)->getResolution(); { ofVec2f * resultptr = new ofVec2f((const ofVec2f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_PlanePrimitive_getWidth(lua_State* L) { int SWIG_arg = 0; ofPlanePrimitive *arg1 = (ofPlanePrimitive *) 0 ; - float result; SWIG_check_num_args("ofPlanePrimitive::getWidth",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPlanePrimitive::getWidth",1,"ofPlanePrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPlanePrimitive,0))){ - SWIG_fail_ptr("PlanePrimitive_getWidth",1,SWIGTYPE_p_ofPlanePrimitive); } - result = (float)((ofPlanePrimitive const *)arg1)->getWidth(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_PlanePrimitive_getHeight(lua_State* L) { int SWIG_arg = 0; ofPlanePrimitive *arg1 = (ofPlanePrimitive *) 0 ; - float result; SWIG_check_num_args("ofPlanePrimitive::getHeight",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPlanePrimitive::getHeight",1,"ofPlanePrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPlanePrimitive,0))){ - SWIG_fail_ptr("PlanePrimitive_getHeight",1,SWIGTYPE_p_ofPlanePrimitive); } - result = (float)((ofPlanePrimitive const *)arg1)->getHeight(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_PlanePrimitive(void *obj) { -ofPlanePrimitive *arg1 = (ofPlanePrimitive *) obj; -delete arg1; -} -static int _proxy__wrap_new_PlanePrimitive(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_PlanePrimitive); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_PlanePrimitive_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_PlanePrimitive_methods[]= { - { "set", _wrap_PlanePrimitive_set}, - { "resizeToTexture", _wrap_PlanePrimitive_resizeToTexture}, - { "setWidth", _wrap_PlanePrimitive_setWidth}, - { "setHeight", _wrap_PlanePrimitive_setHeight}, - { "setColumns", _wrap_PlanePrimitive_setColumns}, - { "setRows", _wrap_PlanePrimitive_setRows}, - { "setResolution", _wrap_PlanePrimitive_setResolution}, - { "setMode", _wrap_PlanePrimitive_setMode}, - { "getNumColumns", _wrap_PlanePrimitive_getNumColumns}, - { "getNumRows", _wrap_PlanePrimitive_getNumRows}, - { "getResolution", _wrap_PlanePrimitive_getResolution}, - { "getWidth", _wrap_PlanePrimitive_getWidth}, - { "getHeight", _wrap_PlanePrimitive_getHeight}, - {0,0} -}; -static swig_lua_method swig_PlanePrimitive_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_PlanePrimitive_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_PlanePrimitive_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_PlanePrimitive_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_PlanePrimitive_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_PlanePrimitive_Sf_SwigStatic = { - "PlanePrimitive", - swig_PlanePrimitive_Sf_SwigStatic_methods, - swig_PlanePrimitive_Sf_SwigStatic_attributes, - swig_PlanePrimitive_Sf_SwigStatic_constants, - swig_PlanePrimitive_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_PlanePrimitive_bases[] = {0,0}; -static const char *swig_PlanePrimitive_base_names[] = {"of3dPrimitive *",0}; -static swig_lua_class _wrap_class_PlanePrimitive = { "PlanePrimitive", "PlanePrimitive", &SWIGTYPE_p_ofPlanePrimitive,_proxy__wrap_new_PlanePrimitive, swig_delete_PlanePrimitive, swig_PlanePrimitive_methods, swig_PlanePrimitive_attributes, &swig_PlanePrimitive_Sf_SwigStatic, swig_PlanePrimitive_meta, swig_PlanePrimitive_bases, swig_PlanePrimitive_base_names }; - -static int _wrap_new_SpherePrimitive__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofSpherePrimitive *result = 0 ; - SWIG_check_num_args("ofSpherePrimitive::ofSpherePrimitive",0,0) result = (ofSpherePrimitive *)new ofSpherePrimitive(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofSpherePrimitive,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_SpherePrimitive__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; int arg2 ; ofPrimitiveMode arg3 ; - ofSpherePrimitive *result = 0 ; SWIG_check_num_args("ofSpherePrimitive::ofSpherePrimitive",3,3) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSpherePrimitive::ofSpherePrimitive",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSpherePrimitive::ofSpherePrimitive",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofSpherePrimitive::ofSpherePrimitive",3,"ofPrimitiveMode"); - arg1 = (float)lua_tonumber(L, 1); arg2 = (int)lua_tonumber(L, 2); arg3 = (ofPrimitiveMode)(int)lua_tonumber(L, 3); - result = (ofSpherePrimitive *)new ofSpherePrimitive(arg1,arg2,arg3); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofSpherePrimitive,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_SpherePrimitive__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; int arg2 ; - ofSpherePrimitive *result = 0 ; SWIG_check_num_args("ofSpherePrimitive::ofSpherePrimitive",2,2) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSpherePrimitive::ofSpherePrimitive",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSpherePrimitive::ofSpherePrimitive",2,"int"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (int)lua_tonumber(L, 2); result = (ofSpherePrimitive *)new ofSpherePrimitive(arg1,arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofSpherePrimitive,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_SpherePrimitive(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_SpherePrimitive__SWIG_0(L);} if (argc == 2) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_new_SpherePrimitive__SWIG_2(L);} } } if (argc == 3) { int _v; - { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_new_SpherePrimitive__SWIG_1(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SpherePrimitive'\n" - " Possible C/C++ prototypes are:\n" " ofSpherePrimitive::ofSpherePrimitive()\n" - " ofSpherePrimitive::ofSpherePrimitive(float,int,ofPrimitiveMode)\n" - " ofSpherePrimitive::ofSpherePrimitive(float,int)\n"); lua_error(L);return 0; } -static int _wrap_SpherePrimitive_set__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofSpherePrimitive *arg1 = (ofSpherePrimitive *) 0 ; float arg2 ; int arg3 ; ofPrimitiveMode arg4 ; - SWIG_check_num_args("ofSpherePrimitive::set",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSpherePrimitive::set",1,"ofSpherePrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSpherePrimitive::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofSpherePrimitive::set",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofSpherePrimitive::set",4,"ofPrimitiveMode"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSpherePrimitive,0))){ - SWIG_fail_ptr("SpherePrimitive_set",1,SWIGTYPE_p_ofSpherePrimitive); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); arg4 = (ofPrimitiveMode)(int)lua_tonumber(L, 4); (arg1)->set(arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SpherePrimitive_set__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofSpherePrimitive *arg1 = (ofSpherePrimitive *) 0 ; float arg2 ; int arg3 ; SWIG_check_num_args("ofSpherePrimitive::set",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSpherePrimitive::set",1,"ofSpherePrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSpherePrimitive::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofSpherePrimitive::set",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSpherePrimitive,0))){ - SWIG_fail_ptr("SpherePrimitive_set",1,SWIGTYPE_p_ofSpherePrimitive); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); (arg1)->set(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_SpherePrimitive_set(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofSpherePrimitive, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_SpherePrimitive_set__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofSpherePrimitive, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_SpherePrimitive_set__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SpherePrimitive_set'\n" - " Possible C/C++ prototypes are:\n" " ofSpherePrimitive::set(float,int,ofPrimitiveMode)\n" - " ofSpherePrimitive::set(float,int)\n"); lua_error(L);return 0; } -static int _wrap_SpherePrimitive_setResolution(lua_State* L) { int SWIG_arg = 0; - ofSpherePrimitive *arg1 = (ofSpherePrimitive *) 0 ; int arg2 ; SWIG_check_num_args("ofSpherePrimitive::setResolution",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSpherePrimitive::setResolution",1,"ofSpherePrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSpherePrimitive::setResolution",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSpherePrimitive,0))){ - SWIG_fail_ptr("SpherePrimitive_setResolution",1,SWIGTYPE_p_ofSpherePrimitive); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->setResolution(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SpherePrimitive_setRadius(lua_State* L) { int SWIG_arg = 0; ofSpherePrimitive *arg1 = (ofSpherePrimitive *) 0 ; - float arg2 ; SWIG_check_num_args("ofSpherePrimitive::setRadius",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSpherePrimitive::setRadius",1,"ofSpherePrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSpherePrimitive::setRadius",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSpherePrimitive,0))){ - SWIG_fail_ptr("SpherePrimitive_setRadius",1,SWIGTYPE_p_ofSpherePrimitive); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setRadius(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SpherePrimitive_setMode(lua_State* L) { int SWIG_arg = 0; ofSpherePrimitive *arg1 = (ofSpherePrimitive *) 0 ; - ofPrimitiveMode arg2 ; SWIG_check_num_args("ofSpherePrimitive::setMode",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSpherePrimitive::setMode",1,"ofSpherePrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSpherePrimitive::setMode",2,"ofPrimitiveMode"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSpherePrimitive,0))){ - SWIG_fail_ptr("SpherePrimitive_setMode",1,SWIGTYPE_p_ofSpherePrimitive); } arg2 = (ofPrimitiveMode)(int)lua_tonumber(L, 2); - (arg1)->setMode(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SpherePrimitive_getRadius(lua_State* L) { int SWIG_arg = 0; ofSpherePrimitive *arg1 = (ofSpherePrimitive *) 0 ; - float result; SWIG_check_num_args("ofSpherePrimitive::getRadius",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSpherePrimitive::getRadius",1,"ofSpherePrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSpherePrimitive,0))){ - SWIG_fail_ptr("SpherePrimitive_getRadius",1,SWIGTYPE_p_ofSpherePrimitive); } - result = (float)((ofSpherePrimitive const *)arg1)->getRadius(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SpherePrimitive_getResolution(lua_State* L) { int SWIG_arg = 0; - ofSpherePrimitive *arg1 = (ofSpherePrimitive *) 0 ; int result; SWIG_check_num_args("ofSpherePrimitive::getResolution",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSpherePrimitive::getResolution",1,"ofSpherePrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSpherePrimitive,0))){ - SWIG_fail_ptr("SpherePrimitive_getResolution",1,SWIGTYPE_p_ofSpherePrimitive); } - result = (int)((ofSpherePrimitive const *)arg1)->getResolution(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_SpherePrimitive(void *obj) { -ofSpherePrimitive *arg1 = (ofSpherePrimitive *) obj; -delete arg1; -} -static int _proxy__wrap_new_SpherePrimitive(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_SpherePrimitive); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_SpherePrimitive_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_SpherePrimitive_methods[]= { - { "set", _wrap_SpherePrimitive_set}, - { "setResolution", _wrap_SpherePrimitive_setResolution}, - { "setRadius", _wrap_SpherePrimitive_setRadius}, - { "setMode", _wrap_SpherePrimitive_setMode}, - { "getRadius", _wrap_SpherePrimitive_getRadius}, - { "getResolution", _wrap_SpherePrimitive_getResolution}, - {0,0} -}; -static swig_lua_method swig_SpherePrimitive_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_SpherePrimitive_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_SpherePrimitive_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_SpherePrimitive_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_SpherePrimitive_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_SpherePrimitive_Sf_SwigStatic = { - "SpherePrimitive", - swig_SpherePrimitive_Sf_SwigStatic_methods, - swig_SpherePrimitive_Sf_SwigStatic_attributes, - swig_SpherePrimitive_Sf_SwigStatic_constants, - swig_SpherePrimitive_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_SpherePrimitive_bases[] = {0,0}; -static const char *swig_SpherePrimitive_base_names[] = {"of3dPrimitive *",0}; -static swig_lua_class _wrap_class_SpherePrimitive = { "SpherePrimitive", "SpherePrimitive", &SWIGTYPE_p_ofSpherePrimitive,_proxy__wrap_new_SpherePrimitive, swig_delete_SpherePrimitive, swig_SpherePrimitive_methods, swig_SpherePrimitive_attributes, &swig_SpherePrimitive_Sf_SwigStatic, swig_SpherePrimitive_meta, swig_SpherePrimitive_bases, swig_SpherePrimitive_base_names }; - -static int _wrap_new_IcoSpherePrimitive__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofIcoSpherePrimitive *result = 0 ; - SWIG_check_num_args("ofIcoSpherePrimitive::ofIcoSpherePrimitive",0,0) - result = (ofIcoSpherePrimitive *)new ofIcoSpherePrimitive(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofIcoSpherePrimitive,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_IcoSpherePrimitive__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; int arg2 ; - ofIcoSpherePrimitive *result = 0 ; SWIG_check_num_args("ofIcoSpherePrimitive::ofIcoSpherePrimitive",2,2) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofIcoSpherePrimitive::ofIcoSpherePrimitive",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofIcoSpherePrimitive::ofIcoSpherePrimitive",2,"int"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (int)lua_tonumber(L, 2); result = (ofIcoSpherePrimitive *)new ofIcoSpherePrimitive(arg1,arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofIcoSpherePrimitive,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_IcoSpherePrimitive(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_IcoSpherePrimitive__SWIG_0(L);} if (argc == 2) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_new_IcoSpherePrimitive__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_IcoSpherePrimitive'\n" - " Possible C/C++ prototypes are:\n" " ofIcoSpherePrimitive::ofIcoSpherePrimitive()\n" - " ofIcoSpherePrimitive::ofIcoSpherePrimitive(float,int)\n"); lua_error(L);return 0; } -static int _wrap_IcoSpherePrimitive_set(lua_State* L) { int SWIG_arg = 0; - ofIcoSpherePrimitive *arg1 = (ofIcoSpherePrimitive *) 0 ; float arg2 ; int arg3 ; - SWIG_check_num_args("ofIcoSpherePrimitive::set",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofIcoSpherePrimitive::set",1,"ofIcoSpherePrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofIcoSpherePrimitive::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofIcoSpherePrimitive::set",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofIcoSpherePrimitive,0))){ - SWIG_fail_ptr("IcoSpherePrimitive_set",1,SWIGTYPE_p_ofIcoSpherePrimitive); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); (arg1)->set(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_IcoSpherePrimitive_setResolution(lua_State* L) { int SWIG_arg = 0; - ofIcoSpherePrimitive *arg1 = (ofIcoSpherePrimitive *) 0 ; int arg2 ; - SWIG_check_num_args("ofIcoSpherePrimitive::setResolution",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofIcoSpherePrimitive::setResolution",1,"ofIcoSpherePrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofIcoSpherePrimitive::setResolution",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofIcoSpherePrimitive,0))){ - SWIG_fail_ptr("IcoSpherePrimitive_setResolution",1,SWIGTYPE_p_ofIcoSpherePrimitive); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->setResolution(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_IcoSpherePrimitive_setRadius(lua_State* L) { int SWIG_arg = 0; - ofIcoSpherePrimitive *arg1 = (ofIcoSpherePrimitive *) 0 ; float arg2 ; - SWIG_check_num_args("ofIcoSpherePrimitive::setRadius",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofIcoSpherePrimitive::setRadius",1,"ofIcoSpherePrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofIcoSpherePrimitive::setRadius",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofIcoSpherePrimitive,0))){ - SWIG_fail_ptr("IcoSpherePrimitive_setRadius",1,SWIGTYPE_p_ofIcoSpherePrimitive); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setRadius(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_IcoSpherePrimitive_setMode(lua_State* L) { int SWIG_arg = 0; - ofIcoSpherePrimitive *arg1 = (ofIcoSpherePrimitive *) 0 ; ofPrimitiveMode arg2 ; - SWIG_check_num_args("ofIcoSpherePrimitive::setMode",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofIcoSpherePrimitive::setMode",1,"ofIcoSpherePrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofIcoSpherePrimitive::setMode",2,"ofPrimitiveMode"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofIcoSpherePrimitive,0))){ - SWIG_fail_ptr("IcoSpherePrimitive_setMode",1,SWIGTYPE_p_ofIcoSpherePrimitive); } - arg2 = (ofPrimitiveMode)(int)lua_tonumber(L, 2); (arg1)->setMode(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_IcoSpherePrimitive_getRadius(lua_State* L) { int SWIG_arg = 0; - ofIcoSpherePrimitive *arg1 = (ofIcoSpherePrimitive *) 0 ; float result; - SWIG_check_num_args("ofIcoSpherePrimitive::getRadius",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofIcoSpherePrimitive::getRadius",1,"ofIcoSpherePrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofIcoSpherePrimitive,0))){ - SWIG_fail_ptr("IcoSpherePrimitive_getRadius",1,SWIGTYPE_p_ofIcoSpherePrimitive); } - result = (float)((ofIcoSpherePrimitive const *)arg1)->getRadius(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_IcoSpherePrimitive_getResolution(lua_State* L) { int SWIG_arg = 0; - ofIcoSpherePrimitive *arg1 = (ofIcoSpherePrimitive *) 0 ; int result; - SWIG_check_num_args("ofIcoSpherePrimitive::getResolution",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofIcoSpherePrimitive::getResolution",1,"ofIcoSpherePrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofIcoSpherePrimitive,0))){ - SWIG_fail_ptr("IcoSpherePrimitive_getResolution",1,SWIGTYPE_p_ofIcoSpherePrimitive); } - result = (int)((ofIcoSpherePrimitive const *)arg1)->getResolution(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_IcoSpherePrimitive(void *obj) { -ofIcoSpherePrimitive *arg1 = (ofIcoSpherePrimitive *) obj; -delete arg1; -} -static int _proxy__wrap_new_IcoSpherePrimitive(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_IcoSpherePrimitive); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_IcoSpherePrimitive_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_IcoSpherePrimitive_methods[]= { - { "set", _wrap_IcoSpherePrimitive_set}, - { "setResolution", _wrap_IcoSpherePrimitive_setResolution}, - { "setRadius", _wrap_IcoSpherePrimitive_setRadius}, - { "setMode", _wrap_IcoSpherePrimitive_setMode}, - { "getRadius", _wrap_IcoSpherePrimitive_getRadius}, - { "getResolution", _wrap_IcoSpherePrimitive_getResolution}, - {0,0} -}; -static swig_lua_method swig_IcoSpherePrimitive_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_IcoSpherePrimitive_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_IcoSpherePrimitive_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_IcoSpherePrimitive_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_IcoSpherePrimitive_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_IcoSpherePrimitive_Sf_SwigStatic = { - "IcoSpherePrimitive", - swig_IcoSpherePrimitive_Sf_SwigStatic_methods, - swig_IcoSpherePrimitive_Sf_SwigStatic_attributes, - swig_IcoSpherePrimitive_Sf_SwigStatic_constants, - swig_IcoSpherePrimitive_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_IcoSpherePrimitive_bases[] = {0,0}; -static const char *swig_IcoSpherePrimitive_base_names[] = {"of3dPrimitive *",0}; -static swig_lua_class _wrap_class_IcoSpherePrimitive = { "IcoSpherePrimitive", "IcoSpherePrimitive", &SWIGTYPE_p_ofIcoSpherePrimitive,_proxy__wrap_new_IcoSpherePrimitive, swig_delete_IcoSpherePrimitive, swig_IcoSpherePrimitive_methods, swig_IcoSpherePrimitive_attributes, &swig_IcoSpherePrimitive_Sf_SwigStatic, swig_IcoSpherePrimitive_meta, swig_IcoSpherePrimitive_bases, swig_IcoSpherePrimitive_base_names }; - -static int _wrap_new_CylinderPrimitive__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofCylinderPrimitive *result = 0 ; - SWIG_check_num_args("ofCylinderPrimitive::ofCylinderPrimitive",0,0) result = (ofCylinderPrimitive *)new ofCylinderPrimitive(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofCylinderPrimitive,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_CylinderPrimitive__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; int arg3 ; int arg4 ; - int arg5 ; bool arg6 ; ofPrimitiveMode arg7 ; ofCylinderPrimitive *result = 0 ; - SWIG_check_num_args("ofCylinderPrimitive::ofCylinderPrimitive",7,7) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofCylinderPrimitive::ofCylinderPrimitive",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofCylinderPrimitive::ofCylinderPrimitive",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofCylinderPrimitive::ofCylinderPrimitive",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofCylinderPrimitive::ofCylinderPrimitive",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofCylinderPrimitive::ofCylinderPrimitive",5,"int"); - if(!lua_isboolean(L,6)) SWIG_fail_arg("ofCylinderPrimitive::ofCylinderPrimitive",6,"bool"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofCylinderPrimitive::ofCylinderPrimitive",7,"ofPrimitiveMode"); - arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); arg6 = (lua_toboolean(L, 6)!=0); - arg7 = (ofPrimitiveMode)(int)lua_tonumber(L, 7); - result = (ofCylinderPrimitive *)new ofCylinderPrimitive(arg1,arg2,arg3,arg4,arg5,arg6,arg7); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofCylinderPrimitive,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_CylinderPrimitive__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; int arg3 ; int arg4 ; - int arg5 ; bool arg6 ; ofCylinderPrimitive *result = 0 ; SWIG_check_num_args("ofCylinderPrimitive::ofCylinderPrimitive",6,6) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofCylinderPrimitive::ofCylinderPrimitive",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofCylinderPrimitive::ofCylinderPrimitive",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofCylinderPrimitive::ofCylinderPrimitive",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofCylinderPrimitive::ofCylinderPrimitive",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofCylinderPrimitive::ofCylinderPrimitive",5,"int"); - if(!lua_isboolean(L,6)) SWIG_fail_arg("ofCylinderPrimitive::ofCylinderPrimitive",6,"bool"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - arg5 = (int)lua_tonumber(L, 5); arg6 = (lua_toboolean(L, 6)!=0); - result = (ofCylinderPrimitive *)new ofCylinderPrimitive(arg1,arg2,arg3,arg4,arg5,arg6); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofCylinderPrimitive,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_CylinderPrimitive__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; int arg3 ; int arg4 ; - int arg5 ; ofCylinderPrimitive *result = 0 ; SWIG_check_num_args("ofCylinderPrimitive::ofCylinderPrimitive",5,5) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofCylinderPrimitive::ofCylinderPrimitive",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofCylinderPrimitive::ofCylinderPrimitive",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofCylinderPrimitive::ofCylinderPrimitive",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofCylinderPrimitive::ofCylinderPrimitive",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofCylinderPrimitive::ofCylinderPrimitive",5,"int"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - arg5 = (int)lua_tonumber(L, 5); result = (ofCylinderPrimitive *)new ofCylinderPrimitive(arg1,arg2,arg3,arg4,arg5); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofCylinderPrimitive,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_CylinderPrimitive__SWIG_4(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; int arg3 ; int arg4 ; - ofCylinderPrimitive *result = 0 ; SWIG_check_num_args("ofCylinderPrimitive::ofCylinderPrimitive",4,4) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofCylinderPrimitive::ofCylinderPrimitive",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofCylinderPrimitive::ofCylinderPrimitive",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofCylinderPrimitive::ofCylinderPrimitive",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofCylinderPrimitive::ofCylinderPrimitive",4,"int"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - result = (ofCylinderPrimitive *)new ofCylinderPrimitive(arg1,arg2,arg3,arg4); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofCylinderPrimitive,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_CylinderPrimitive(lua_State* L) { int argc; int argv[8]={ 1,2,3,4,5,6,7,8} ; argc = lua_gettop(L); - if (argc == 0) { return _wrap_new_CylinderPrimitive__SWIG_0(L);} if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_new_CylinderPrimitive__SWIG_4(L);} } } } } - if (argc == 5) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_new_CylinderPrimitive__SWIG_3(L);} } } } } } - if (argc == 6) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isboolean(L,argv[5]); } if (_v) { - return _wrap_new_CylinderPrimitive__SWIG_2(L);} } } } } } } if (argc == 7) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isboolean(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { - return _wrap_new_CylinderPrimitive__SWIG_1(L);} } } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_CylinderPrimitive'\n" - " Possible C/C++ prototypes are:\n" " ofCylinderPrimitive::ofCylinderPrimitive()\n" - " ofCylinderPrimitive::ofCylinderPrimitive(float,float,int,int,int,bool,ofPrimitiveMode)\n" - " ofCylinderPrimitive::ofCylinderPrimitive(float,float,int,int,int,bool)\n" - " ofCylinderPrimitive::ofCylinderPrimitive(float,float,int,int,int)\n" - " ofCylinderPrimitive::ofCylinderPrimitive(float,float,int,int)\n"); lua_error(L);return 0; } -static int _wrap_CylinderPrimitive_set__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; float arg2 ; float arg3 ; int arg4 ; int arg5 ; int arg6 ; bool arg7 ; - ofPrimitiveMode arg8 ; SWIG_check_num_args("ofCylinderPrimitive::set",8,8) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::set",1,"ofCylinderPrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofCylinderPrimitive::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofCylinderPrimitive::set",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofCylinderPrimitive::set",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofCylinderPrimitive::set",5,"int"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofCylinderPrimitive::set",6,"int"); - if(!lua_isboolean(L,7)) SWIG_fail_arg("ofCylinderPrimitive::set",7,"bool"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofCylinderPrimitive::set",8,"ofPrimitiveMode"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ - SWIG_fail_ptr("CylinderPrimitive_set",1,SWIGTYPE_p_ofCylinderPrimitive); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); - arg6 = (int)lua_tonumber(L, 6); arg7 = (lua_toboolean(L, 7)!=0); arg8 = (ofPrimitiveMode)(int)lua_tonumber(L, 8); - (arg1)->set(arg2,arg3,arg4,arg5,arg6,arg7,arg8); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_CylinderPrimitive_set__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; float arg2 ; float arg3 ; int arg4 ; int arg5 ; int arg6 ; bool arg7 ; - SWIG_check_num_args("ofCylinderPrimitive::set",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::set",1,"ofCylinderPrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofCylinderPrimitive::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofCylinderPrimitive::set",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofCylinderPrimitive::set",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofCylinderPrimitive::set",5,"int"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofCylinderPrimitive::set",6,"int"); - if(!lua_isboolean(L,7)) SWIG_fail_arg("ofCylinderPrimitive::set",7,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ - SWIG_fail_ptr("CylinderPrimitive_set",1,SWIGTYPE_p_ofCylinderPrimitive); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); - arg6 = (int)lua_tonumber(L, 6); arg7 = (lua_toboolean(L, 7)!=0); (arg1)->set(arg2,arg3,arg4,arg5,arg6,arg7); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_CylinderPrimitive_set__SWIG_2(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; float arg2 ; float arg3 ; int arg4 ; int arg5 ; int arg6 ; - SWIG_check_num_args("ofCylinderPrimitive::set",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::set",1,"ofCylinderPrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofCylinderPrimitive::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofCylinderPrimitive::set",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofCylinderPrimitive::set",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofCylinderPrimitive::set",5,"int"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofCylinderPrimitive::set",6,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ - SWIG_fail_ptr("CylinderPrimitive_set",1,SWIGTYPE_p_ofCylinderPrimitive); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); - arg6 = (int)lua_tonumber(L, 6); (arg1)->set(arg2,arg3,arg4,arg5,arg6); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_CylinderPrimitive_set__SWIG_3(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; float arg2 ; float arg3 ; int arg4 ; int arg5 ; - SWIG_check_num_args("ofCylinderPrimitive::set",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::set",1,"ofCylinderPrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofCylinderPrimitive::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofCylinderPrimitive::set",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofCylinderPrimitive::set",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofCylinderPrimitive::set",5,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ - SWIG_fail_ptr("CylinderPrimitive_set",1,SWIGTYPE_p_ofCylinderPrimitive); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); - (arg1)->set(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_CylinderPrimitive_set__SWIG_4(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; float arg2 ; float arg3 ; bool arg4 ; - SWIG_check_num_args("ofCylinderPrimitive::set",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::set",1,"ofCylinderPrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofCylinderPrimitive::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofCylinderPrimitive::set",3,"float"); - if(!lua_isboolean(L,4)) SWIG_fail_arg("ofCylinderPrimitive::set",4,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ - SWIG_fail_ptr("CylinderPrimitive_set",1,SWIGTYPE_p_ofCylinderPrimitive); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (lua_toboolean(L, 4)!=0); (arg1)->set(arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_CylinderPrimitive_set__SWIG_5(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofCylinderPrimitive::set",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::set",1,"ofCylinderPrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofCylinderPrimitive::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofCylinderPrimitive::set",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ - SWIG_fail_ptr("CylinderPrimitive_set",1,SWIGTYPE_p_ofCylinderPrimitive); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->set(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_CylinderPrimitive_set(lua_State* L) { int argc; int argv[9]={ 1,2,3,4,5,6,7,8,9} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCylinderPrimitive, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_CylinderPrimitive_set__SWIG_5(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCylinderPrimitive, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isboolean(L,argv[3]); } if (_v) { return _wrap_CylinderPrimitive_set__SWIG_4(L);} } } } } - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCylinderPrimitive, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_CylinderPrimitive_set__SWIG_3(L);} } } } } } if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCylinderPrimitive, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { return _wrap_CylinderPrimitive_set__SWIG_2(L);} } } } } } } - if (argc == 7) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCylinderPrimitive, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isboolean(L,argv[6]); } if (_v) { - return _wrap_CylinderPrimitive_set__SWIG_1(L);} } } } } } } } if (argc == 8) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCylinderPrimitive, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isboolean(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { return _wrap_CylinderPrimitive_set__SWIG_0(L);} } } } } } } - } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'CylinderPrimitive_set'\n" - " Possible C/C++ prototypes are:\n" " ofCylinderPrimitive::set(float,float,int,int,int,bool,ofPrimitiveMode)\n" - " ofCylinderPrimitive::set(float,float,int,int,int,bool)\n" " ofCylinderPrimitive::set(float,float,int,int,int)\n" - " ofCylinderPrimitive::set(float,float,int,int)\n" " ofCylinderPrimitive::set(float,float,bool)\n" - " ofCylinderPrimitive::set(float,float)\n"); lua_error(L);return 0; } -static int _wrap_CylinderPrimitive_setRadius(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; float arg2 ; SWIG_check_num_args("ofCylinderPrimitive::setRadius",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::setRadius",1,"ofCylinderPrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofCylinderPrimitive::setRadius",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ - SWIG_fail_ptr("CylinderPrimitive_setRadius",1,SWIGTYPE_p_ofCylinderPrimitive); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setRadius(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_CylinderPrimitive_setHeight(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; float arg2 ; SWIG_check_num_args("ofCylinderPrimitive::setHeight",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::setHeight",1,"ofCylinderPrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofCylinderPrimitive::setHeight",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ - SWIG_fail_ptr("CylinderPrimitive_setHeight",1,SWIGTYPE_p_ofCylinderPrimitive); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setHeight(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_CylinderPrimitive_setCapped(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; bool arg2 ; SWIG_check_num_args("ofCylinderPrimitive::setCapped",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::setCapped",1,"ofCylinderPrimitive *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofCylinderPrimitive::setCapped",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ - SWIG_fail_ptr("CylinderPrimitive_setCapped",1,SWIGTYPE_p_ofCylinderPrimitive); } arg2 = (lua_toboolean(L, 2)!=0); - (arg1)->setCapped(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_CylinderPrimitive_setResolutionRadius(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; int arg2 ; - SWIG_check_num_args("ofCylinderPrimitive::setResolutionRadius",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::setResolutionRadius",1,"ofCylinderPrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofCylinderPrimitive::setResolutionRadius",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ - SWIG_fail_ptr("CylinderPrimitive_setResolutionRadius",1,SWIGTYPE_p_ofCylinderPrimitive); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->setResolutionRadius(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_CylinderPrimitive_setResolutionHeight(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; int arg2 ; - SWIG_check_num_args("ofCylinderPrimitive::setResolutionHeight",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::setResolutionHeight",1,"ofCylinderPrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofCylinderPrimitive::setResolutionHeight",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ - SWIG_fail_ptr("CylinderPrimitive_setResolutionHeight",1,SWIGTYPE_p_ofCylinderPrimitive); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->setResolutionHeight(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_CylinderPrimitive_setResolutionCap(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; int arg2 ; - SWIG_check_num_args("ofCylinderPrimitive::setResolutionCap",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::setResolutionCap",1,"ofCylinderPrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofCylinderPrimitive::setResolutionCap",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ - SWIG_fail_ptr("CylinderPrimitive_setResolutionCap",1,SWIGTYPE_p_ofCylinderPrimitive); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->setResolutionCap(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_CylinderPrimitive_setResolution__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; int arg2 ; int arg3 ; int arg4 ; - SWIG_check_num_args("ofCylinderPrimitive::setResolution",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::setResolution",1,"ofCylinderPrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofCylinderPrimitive::setResolution",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofCylinderPrimitive::setResolution",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofCylinderPrimitive::setResolution",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ - SWIG_fail_ptr("CylinderPrimitive_setResolution",1,SWIGTYPE_p_ofCylinderPrimitive); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); (arg1)->setResolution(arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_CylinderPrimitive_setResolution__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; int arg2 ; int arg3 ; - SWIG_check_num_args("ofCylinderPrimitive::setResolution",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::setResolution",1,"ofCylinderPrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofCylinderPrimitive::setResolution",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofCylinderPrimitive::setResolution",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ - SWIG_fail_ptr("CylinderPrimitive_setResolution",1,SWIGTYPE_p_ofCylinderPrimitive); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); (arg1)->setResolution(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_CylinderPrimitive_setResolution(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCylinderPrimitive, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_CylinderPrimitive_setResolution__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCylinderPrimitive, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_CylinderPrimitive_setResolution__SWIG_0(L);} } } - } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'CylinderPrimitive_setResolution'\n" - " Possible C/C++ prototypes are:\n" " ofCylinderPrimitive::setResolution(int,int,int)\n" - " ofCylinderPrimitive::setResolution(int,int)\n"); lua_error(L);return 0; } -static int _wrap_CylinderPrimitive_setMode(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; ofPrimitiveMode arg2 ; - SWIG_check_num_args("ofCylinderPrimitive::setMode",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::setMode",1,"ofCylinderPrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofCylinderPrimitive::setMode",2,"ofPrimitiveMode"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ - SWIG_fail_ptr("CylinderPrimitive_setMode",1,SWIGTYPE_p_ofCylinderPrimitive); } - arg2 = (ofPrimitiveMode)(int)lua_tonumber(L, 2); (arg1)->setMode(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_CylinderPrimitive_setTopCapColor(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; ofColor arg2 ; ofColor *argp2 ; - SWIG_check_num_args("ofCylinderPrimitive::setTopCapColor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::setTopCapColor",1,"ofCylinderPrimitive *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofCylinderPrimitive::setTopCapColor",2,"ofColor"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ - SWIG_fail_ptr("CylinderPrimitive_setTopCapColor",1,SWIGTYPE_p_ofCylinderPrimitive); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("CylinderPrimitive_setTopCapColor",2,SWIGTYPE_p_ofColor_T_unsigned_char_t); } arg2 = *argp2; - (arg1)->setTopCapColor(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_CylinderPrimitive_setCylinderColor(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; ofColor arg2 ; ofColor *argp2 ; - SWIG_check_num_args("ofCylinderPrimitive::setCylinderColor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::setCylinderColor",1,"ofCylinderPrimitive *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofCylinderPrimitive::setCylinderColor",2,"ofColor"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ - SWIG_fail_ptr("CylinderPrimitive_setCylinderColor",1,SWIGTYPE_p_ofCylinderPrimitive); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("CylinderPrimitive_setCylinderColor",2,SWIGTYPE_p_ofColor_T_unsigned_char_t); } arg2 = *argp2; - (arg1)->setCylinderColor(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_CylinderPrimitive_setBottomCapColor(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; ofColor arg2 ; ofColor *argp2 ; - SWIG_check_num_args("ofCylinderPrimitive::setBottomCapColor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::setBottomCapColor",1,"ofCylinderPrimitive *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofCylinderPrimitive::setBottomCapColor",2,"ofColor"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ - SWIG_fail_ptr("CylinderPrimitive_setBottomCapColor",1,SWIGTYPE_p_ofCylinderPrimitive); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("CylinderPrimitive_setBottomCapColor",2,SWIGTYPE_p_ofColor_T_unsigned_char_t); } arg2 = *argp2; - (arg1)->setBottomCapColor(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_CylinderPrimitive_getTopCapIndices(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; SwigValueWrapper< std::vector< unsigned int > > result; - SWIG_check_num_args("ofCylinderPrimitive::getTopCapIndices",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::getTopCapIndices",1,"ofCylinderPrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ - SWIG_fail_ptr("CylinderPrimitive_getTopCapIndices",1,SWIGTYPE_p_ofCylinderPrimitive); } - result = ((ofCylinderPrimitive const *)arg1)->getTopCapIndices(); { - std::vector< ofIndexType > * resultptr = new std::vector< ofIndexType >((const std::vector< ofIndexType > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_unsigned_int_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_CylinderPrimitive_getTopCapMesh(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; ofMesh result; - SWIG_check_num_args("ofCylinderPrimitive::getTopCapMesh",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::getTopCapMesh",1,"ofCylinderPrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ - SWIG_fail_ptr("CylinderPrimitive_getTopCapMesh",1,SWIGTYPE_p_ofCylinderPrimitive); } - result = ((ofCylinderPrimitive const *)arg1)->getTopCapMesh(); { ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_CylinderPrimitive_getCylinderIndices(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; SwigValueWrapper< std::vector< unsigned int > > result; - SWIG_check_num_args("ofCylinderPrimitive::getCylinderIndices",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::getCylinderIndices",1,"ofCylinderPrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ - SWIG_fail_ptr("CylinderPrimitive_getCylinderIndices",1,SWIGTYPE_p_ofCylinderPrimitive); } - result = ((ofCylinderPrimitive const *)arg1)->getCylinderIndices(); { - std::vector< ofIndexType > * resultptr = new std::vector< ofIndexType >((const std::vector< ofIndexType > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_unsigned_int_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_CylinderPrimitive_getCylinderMesh(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; ofMesh result; - SWIG_check_num_args("ofCylinderPrimitive::getCylinderMesh",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::getCylinderMesh",1,"ofCylinderPrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ - SWIG_fail_ptr("CylinderPrimitive_getCylinderMesh",1,SWIGTYPE_p_ofCylinderPrimitive); } - result = ((ofCylinderPrimitive const *)arg1)->getCylinderMesh(); { ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_CylinderPrimitive_getBottomCapIndices(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; SwigValueWrapper< std::vector< unsigned int > > result; - SWIG_check_num_args("ofCylinderPrimitive::getBottomCapIndices",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::getBottomCapIndices",1,"ofCylinderPrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ - SWIG_fail_ptr("CylinderPrimitive_getBottomCapIndices",1,SWIGTYPE_p_ofCylinderPrimitive); } - result = ((ofCylinderPrimitive const *)arg1)->getBottomCapIndices(); { - std::vector< ofIndexType > * resultptr = new std::vector< ofIndexType >((const std::vector< ofIndexType > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_unsigned_int_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_CylinderPrimitive_getBottomCapMesh(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; ofMesh result; - SWIG_check_num_args("ofCylinderPrimitive::getBottomCapMesh",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::getBottomCapMesh",1,"ofCylinderPrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ - SWIG_fail_ptr("CylinderPrimitive_getBottomCapMesh",1,SWIGTYPE_p_ofCylinderPrimitive); } - result = ((ofCylinderPrimitive const *)arg1)->getBottomCapMesh(); { ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_CylinderPrimitive_getResolutionRadius(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; int result; - SWIG_check_num_args("ofCylinderPrimitive::getResolutionRadius",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::getResolutionRadius",1,"ofCylinderPrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ - SWIG_fail_ptr("CylinderPrimitive_getResolutionRadius",1,SWIGTYPE_p_ofCylinderPrimitive); } - result = (int)((ofCylinderPrimitive const *)arg1)->getResolutionRadius(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_CylinderPrimitive_getResolutionHeight(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; int result; - SWIG_check_num_args("ofCylinderPrimitive::getResolutionHeight",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::getResolutionHeight",1,"ofCylinderPrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ - SWIG_fail_ptr("CylinderPrimitive_getResolutionHeight",1,SWIGTYPE_p_ofCylinderPrimitive); } - result = (int)((ofCylinderPrimitive const *)arg1)->getResolutionHeight(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_CylinderPrimitive_getResolutionCap(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; int result; - SWIG_check_num_args("ofCylinderPrimitive::getResolutionCap",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::getResolutionCap",1,"ofCylinderPrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ - SWIG_fail_ptr("CylinderPrimitive_getResolutionCap",1,SWIGTYPE_p_ofCylinderPrimitive); } - result = (int)((ofCylinderPrimitive const *)arg1)->getResolutionCap(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_CylinderPrimitive_getResolution(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; ofVec3f result; - SWIG_check_num_args("ofCylinderPrimitive::getResolution",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::getResolution",1,"ofCylinderPrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ - SWIG_fail_ptr("CylinderPrimitive_getResolution",1,SWIGTYPE_p_ofCylinderPrimitive); } - result = ((ofCylinderPrimitive const *)arg1)->getResolution(); { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_CylinderPrimitive_getHeight(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; float result; - SWIG_check_num_args("ofCylinderPrimitive::getHeight",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::getHeight",1,"ofCylinderPrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ - SWIG_fail_ptr("CylinderPrimitive_getHeight",1,SWIGTYPE_p_ofCylinderPrimitive); } - result = (float)((ofCylinderPrimitive const *)arg1)->getHeight(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_CylinderPrimitive_getRadius(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; float result; - SWIG_check_num_args("ofCylinderPrimitive::getRadius",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::getRadius",1,"ofCylinderPrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ - SWIG_fail_ptr("CylinderPrimitive_getRadius",1,SWIGTYPE_p_ofCylinderPrimitive); } - result = (float)((ofCylinderPrimitive const *)arg1)->getRadius(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_CylinderPrimitive_getCapped(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; bool result; SWIG_check_num_args("ofCylinderPrimitive::getCapped",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::getCapped",1,"ofCylinderPrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ - SWIG_fail_ptr("CylinderPrimitive_getCapped",1,SWIGTYPE_p_ofCylinderPrimitive); } - result = (bool)((ofCylinderPrimitive const *)arg1)->getCapped(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_CylinderPrimitive(void *obj) { -ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) obj; -delete arg1; -} -static int _proxy__wrap_new_CylinderPrimitive(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_CylinderPrimitive); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_CylinderPrimitive_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_CylinderPrimitive_methods[]= { - { "set", _wrap_CylinderPrimitive_set}, - { "setRadius", _wrap_CylinderPrimitive_setRadius}, - { "setHeight", _wrap_CylinderPrimitive_setHeight}, - { "setCapped", _wrap_CylinderPrimitive_setCapped}, - { "setResolutionRadius", _wrap_CylinderPrimitive_setResolutionRadius}, - { "setResolutionHeight", _wrap_CylinderPrimitive_setResolutionHeight}, - { "setResolutionCap", _wrap_CylinderPrimitive_setResolutionCap}, - { "setResolution", _wrap_CylinderPrimitive_setResolution}, - { "setMode", _wrap_CylinderPrimitive_setMode}, - { "setTopCapColor", _wrap_CylinderPrimitive_setTopCapColor}, - { "setCylinderColor", _wrap_CylinderPrimitive_setCylinderColor}, - { "setBottomCapColor", _wrap_CylinderPrimitive_setBottomCapColor}, - { "getTopCapIndices", _wrap_CylinderPrimitive_getTopCapIndices}, - { "getTopCapMesh", _wrap_CylinderPrimitive_getTopCapMesh}, - { "getCylinderIndices", _wrap_CylinderPrimitive_getCylinderIndices}, - { "getCylinderMesh", _wrap_CylinderPrimitive_getCylinderMesh}, - { "getBottomCapIndices", _wrap_CylinderPrimitive_getBottomCapIndices}, - { "getBottomCapMesh", _wrap_CylinderPrimitive_getBottomCapMesh}, - { "getResolutionRadius", _wrap_CylinderPrimitive_getResolutionRadius}, - { "getResolutionHeight", _wrap_CylinderPrimitive_getResolutionHeight}, - { "getResolutionCap", _wrap_CylinderPrimitive_getResolutionCap}, - { "getResolution", _wrap_CylinderPrimitive_getResolution}, - { "getHeight", _wrap_CylinderPrimitive_getHeight}, - { "getRadius", _wrap_CylinderPrimitive_getRadius}, - { "getCapped", _wrap_CylinderPrimitive_getCapped}, - {0,0} -}; -static swig_lua_method swig_CylinderPrimitive_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_CylinderPrimitive_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_CylinderPrimitive_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_CylinderPrimitive_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_CylinderPrimitive_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_CylinderPrimitive_Sf_SwigStatic = { - "CylinderPrimitive", - swig_CylinderPrimitive_Sf_SwigStatic_methods, - swig_CylinderPrimitive_Sf_SwigStatic_attributes, - swig_CylinderPrimitive_Sf_SwigStatic_constants, - swig_CylinderPrimitive_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_CylinderPrimitive_bases[] = {0,0}; -static const char *swig_CylinderPrimitive_base_names[] = {"of3dPrimitive *",0}; -static swig_lua_class _wrap_class_CylinderPrimitive = { "CylinderPrimitive", "CylinderPrimitive", &SWIGTYPE_p_ofCylinderPrimitive,_proxy__wrap_new_CylinderPrimitive, swig_delete_CylinderPrimitive, swig_CylinderPrimitive_methods, swig_CylinderPrimitive_attributes, &swig_CylinderPrimitive_Sf_SwigStatic, swig_CylinderPrimitive_meta, swig_CylinderPrimitive_bases, swig_CylinderPrimitive_base_names }; - -static int _wrap_new_ConePrimitive__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofConePrimitive *result = 0 ; - SWIG_check_num_args("ofConePrimitive::ofConePrimitive",0,0) result = (ofConePrimitive *)new ofConePrimitive(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofConePrimitive,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_ConePrimitive__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; int arg3 ; int arg4 ; - int arg5 ; ofPrimitiveMode arg6 ; ofConePrimitive *result = 0 ; SWIG_check_num_args("ofConePrimitive::ofConePrimitive",6,6) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofConePrimitive::ofConePrimitive",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofConePrimitive::ofConePrimitive",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofConePrimitive::ofConePrimitive",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofConePrimitive::ofConePrimitive",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofConePrimitive::ofConePrimitive",5,"int"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofConePrimitive::ofConePrimitive",6,"ofPrimitiveMode"); - arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); arg6 = (ofPrimitiveMode)(int)lua_tonumber(L, 6); - result = (ofConePrimitive *)new ofConePrimitive(arg1,arg2,arg3,arg4,arg5,arg6); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofConePrimitive,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_ConePrimitive__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; int arg3 ; int arg4 ; - int arg5 ; ofConePrimitive *result = 0 ; SWIG_check_num_args("ofConePrimitive::ofConePrimitive",5,5) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofConePrimitive::ofConePrimitive",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofConePrimitive::ofConePrimitive",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofConePrimitive::ofConePrimitive",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofConePrimitive::ofConePrimitive",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofConePrimitive::ofConePrimitive",5,"int"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - arg5 = (int)lua_tonumber(L, 5); result = (ofConePrimitive *)new ofConePrimitive(arg1,arg2,arg3,arg4,arg5); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofConePrimitive,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_ConePrimitive__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; int arg3 ; int arg4 ; - ofConePrimitive *result = 0 ; SWIG_check_num_args("ofConePrimitive::ofConePrimitive",4,4) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofConePrimitive::ofConePrimitive",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofConePrimitive::ofConePrimitive",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofConePrimitive::ofConePrimitive",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofConePrimitive::ofConePrimitive",4,"int"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - result = (ofConePrimitive *)new ofConePrimitive(arg1,arg2,arg3,arg4); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofConePrimitive,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_ConePrimitive(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); - if (argc == 0) { return _wrap_new_ConePrimitive__SWIG_0(L);} if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_new_ConePrimitive__SWIG_3(L);} } } } } if (argc == 5) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_new_ConePrimitive__SWIG_2(L);} } } } } } - if (argc == 6) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { - return _wrap_new_ConePrimitive__SWIG_1(L);} } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_ConePrimitive'\n" " Possible C/C++ prototypes are:\n" - " ofConePrimitive::ofConePrimitive()\n" " ofConePrimitive::ofConePrimitive(float,float,int,int,int,ofPrimitiveMode)\n" - " ofConePrimitive::ofConePrimitive(float,float,int,int,int)\n" - " ofConePrimitive::ofConePrimitive(float,float,int,int)\n"); lua_error(L);return 0; } -static int _wrap_ConePrimitive_set__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofConePrimitive *arg1 = (ofConePrimitive *) 0 ; - float arg2 ; float arg3 ; int arg4 ; int arg5 ; int arg6 ; ofPrimitiveMode arg7 ; - SWIG_check_num_args("ofConePrimitive::set",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofConePrimitive::set",1,"ofConePrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofConePrimitive::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofConePrimitive::set",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofConePrimitive::set",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofConePrimitive::set",5,"int"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofConePrimitive::set",6,"int"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofConePrimitive::set",7,"ofPrimitiveMode"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofConePrimitive,0))){ - SWIG_fail_ptr("ConePrimitive_set",1,SWIGTYPE_p_ofConePrimitive); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); - arg6 = (int)lua_tonumber(L, 6); arg7 = (ofPrimitiveMode)(int)lua_tonumber(L, 7); (arg1)->set(arg2,arg3,arg4,arg5,arg6,arg7); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ConePrimitive_set__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofConePrimitive *arg1 = (ofConePrimitive *) 0 ; - float arg2 ; float arg3 ; int arg4 ; int arg5 ; int arg6 ; SWIG_check_num_args("ofConePrimitive::set",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofConePrimitive::set",1,"ofConePrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofConePrimitive::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofConePrimitive::set",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofConePrimitive::set",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofConePrimitive::set",5,"int"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofConePrimitive::set",6,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofConePrimitive,0))){ - SWIG_fail_ptr("ConePrimitive_set",1,SWIGTYPE_p_ofConePrimitive); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); - arg6 = (int)lua_tonumber(L, 6); (arg1)->set(arg2,arg3,arg4,arg5,arg6); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ConePrimitive_set__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofConePrimitive *arg1 = (ofConePrimitive *) 0 ; - float arg2 ; float arg3 ; int arg4 ; int arg5 ; SWIG_check_num_args("ofConePrimitive::set",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofConePrimitive::set",1,"ofConePrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofConePrimitive::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofConePrimitive::set",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofConePrimitive::set",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofConePrimitive::set",5,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofConePrimitive,0))){ - SWIG_fail_ptr("ConePrimitive_set",1,SWIGTYPE_p_ofConePrimitive); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); - (arg1)->set(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ConePrimitive_set__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofConePrimitive *arg1 = (ofConePrimitive *) 0 ; - float arg2 ; float arg3 ; SWIG_check_num_args("ofConePrimitive::set",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofConePrimitive::set",1,"ofConePrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofConePrimitive::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofConePrimitive::set",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofConePrimitive,0))){ - SWIG_fail_ptr("ConePrimitive_set",1,SWIGTYPE_p_ofConePrimitive); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->set(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ConePrimitive_set(lua_State* L) { int argc; int argv[8]={ 1,2,3,4,5,6,7,8} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofConePrimitive, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_ConePrimitive_set__SWIG_3(L);} } } } if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofConePrimitive, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_ConePrimitive_set__SWIG_2(L);} } } } } } if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofConePrimitive, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { return _wrap_ConePrimitive_set__SWIG_1(L);} } } } } } } - if (argc == 7) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofConePrimitive, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { - return _wrap_ConePrimitive_set__SWIG_0(L);} } } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ConePrimitive_set'\n" " Possible C/C++ prototypes are:\n" - " ofConePrimitive::set(float,float,int,int,int,ofPrimitiveMode)\n" " ofConePrimitive::set(float,float,int,int,int)\n" - " ofConePrimitive::set(float,float,int,int)\n" " ofConePrimitive::set(float,float)\n"); lua_error(L);return 0; } -static int _wrap_ConePrimitive_setResolutionRadius(lua_State* L) { int SWIG_arg = 0; - ofConePrimitive *arg1 = (ofConePrimitive *) 0 ; int arg2 ; SWIG_check_num_args("ofConePrimitive::setResolutionRadius",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofConePrimitive::setResolutionRadius",1,"ofConePrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofConePrimitive::setResolutionRadius",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofConePrimitive,0))){ - SWIG_fail_ptr("ConePrimitive_setResolutionRadius",1,SWIGTYPE_p_ofConePrimitive); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->setResolutionRadius(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ConePrimitive_setResolutionHeight(lua_State* L) { int SWIG_arg = 0; - ofConePrimitive *arg1 = (ofConePrimitive *) 0 ; int arg2 ; SWIG_check_num_args("ofConePrimitive::setResolutionHeight",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofConePrimitive::setResolutionHeight",1,"ofConePrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofConePrimitive::setResolutionHeight",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofConePrimitive,0))){ - SWIG_fail_ptr("ConePrimitive_setResolutionHeight",1,SWIGTYPE_p_ofConePrimitive); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->setResolutionHeight(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ConePrimitive_setResolutionCap(lua_State* L) { int SWIG_arg = 0; - ofConePrimitive *arg1 = (ofConePrimitive *) 0 ; int arg2 ; SWIG_check_num_args("ofConePrimitive::setResolutionCap",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofConePrimitive::setResolutionCap",1,"ofConePrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofConePrimitive::setResolutionCap",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofConePrimitive,0))){ - SWIG_fail_ptr("ConePrimitive_setResolutionCap",1,SWIGTYPE_p_ofConePrimitive); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->setResolutionCap(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ConePrimitive_setResolution(lua_State* L) { int SWIG_arg = 0; ofConePrimitive *arg1 = (ofConePrimitive *) 0 ; - int arg2 ; int arg3 ; int arg4 ; SWIG_check_num_args("ofConePrimitive::setResolution",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofConePrimitive::setResolution",1,"ofConePrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofConePrimitive::setResolution",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofConePrimitive::setResolution",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofConePrimitive::setResolution",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofConePrimitive,0))){ - SWIG_fail_ptr("ConePrimitive_setResolution",1,SWIGTYPE_p_ofConePrimitive); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); (arg1)->setResolution(arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ConePrimitive_setMode(lua_State* L) { int SWIG_arg = 0; ofConePrimitive *arg1 = (ofConePrimitive *) 0 ; - ofPrimitiveMode arg2 ; SWIG_check_num_args("ofConePrimitive::setMode",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofConePrimitive::setMode",1,"ofConePrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofConePrimitive::setMode",2,"ofPrimitiveMode"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofConePrimitive,0))){ - SWIG_fail_ptr("ConePrimitive_setMode",1,SWIGTYPE_p_ofConePrimitive); } arg2 = (ofPrimitiveMode)(int)lua_tonumber(L, 2); - (arg1)->setMode(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ConePrimitive_setRadius(lua_State* L) { int SWIG_arg = 0; ofConePrimitive *arg1 = (ofConePrimitive *) 0 ; - float arg2 ; SWIG_check_num_args("ofConePrimitive::setRadius",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofConePrimitive::setRadius",1,"ofConePrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofConePrimitive::setRadius",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofConePrimitive,0))){ - SWIG_fail_ptr("ConePrimitive_setRadius",1,SWIGTYPE_p_ofConePrimitive); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setRadius(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ConePrimitive_setHeight(lua_State* L) { int SWIG_arg = 0; ofConePrimitive *arg1 = (ofConePrimitive *) 0 ; - float arg2 ; SWIG_check_num_args("ofConePrimitive::setHeight",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofConePrimitive::setHeight",1,"ofConePrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofConePrimitive::setHeight",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofConePrimitive,0))){ - SWIG_fail_ptr("ConePrimitive_setHeight",1,SWIGTYPE_p_ofConePrimitive); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setHeight(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ConePrimitive_setTopColor(lua_State* L) { int SWIG_arg = 0; ofConePrimitive *arg1 = (ofConePrimitive *) 0 ; - ofColor arg2 ; ofColor *argp2 ; SWIG_check_num_args("ofConePrimitive::setTopColor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofConePrimitive::setTopColor",1,"ofConePrimitive *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofConePrimitive::setTopColor",2,"ofColor"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofConePrimitive,0))){ - SWIG_fail_ptr("ConePrimitive_setTopColor",1,SWIGTYPE_p_ofConePrimitive); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("ConePrimitive_setTopColor",2,SWIGTYPE_p_ofColor_T_unsigned_char_t); } arg2 = *argp2; - (arg1)->setTopColor(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ConePrimitive_setCapColor(lua_State* L) { int SWIG_arg = 0; ofConePrimitive *arg1 = (ofConePrimitive *) 0 ; - ofColor arg2 ; ofColor *argp2 ; SWIG_check_num_args("ofConePrimitive::setCapColor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofConePrimitive::setCapColor",1,"ofConePrimitive *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofConePrimitive::setCapColor",2,"ofColor"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofConePrimitive,0))){ - SWIG_fail_ptr("ConePrimitive_setCapColor",1,SWIGTYPE_p_ofConePrimitive); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("ConePrimitive_setCapColor",2,SWIGTYPE_p_ofColor_T_unsigned_char_t); } arg2 = *argp2; - (arg1)->setCapColor(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ConePrimitive_getConeIndices(lua_State* L) { int SWIG_arg = 0; ofConePrimitive *arg1 = (ofConePrimitive *) 0 ; - SwigValueWrapper< std::vector< unsigned int > > result; SWIG_check_num_args("ofConePrimitive::getConeIndices",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofConePrimitive::getConeIndices",1,"ofConePrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofConePrimitive,0))){ - SWIG_fail_ptr("ConePrimitive_getConeIndices",1,SWIGTYPE_p_ofConePrimitive); } - result = ((ofConePrimitive const *)arg1)->getConeIndices(); { - std::vector< ofIndexType > * resultptr = new std::vector< ofIndexType >((const std::vector< ofIndexType > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_unsigned_int_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ConePrimitive_getConeMesh(lua_State* L) { int SWIG_arg = 0; ofConePrimitive *arg1 = (ofConePrimitive *) 0 ; - ofMesh result; SWIG_check_num_args("ofConePrimitive::getConeMesh",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofConePrimitive::getConeMesh",1,"ofConePrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofConePrimitive,0))){ - SWIG_fail_ptr("ConePrimitive_getConeMesh",1,SWIGTYPE_p_ofConePrimitive); } - result = ((ofConePrimitive const *)arg1)->getConeMesh(); { ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ConePrimitive_getCapIndices(lua_State* L) { int SWIG_arg = 0; ofConePrimitive *arg1 = (ofConePrimitive *) 0 ; - SwigValueWrapper< std::vector< unsigned int > > result; SWIG_check_num_args("ofConePrimitive::getCapIndices",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofConePrimitive::getCapIndices",1,"ofConePrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofConePrimitive,0))){ - SWIG_fail_ptr("ConePrimitive_getCapIndices",1,SWIGTYPE_p_ofConePrimitive); } - result = ((ofConePrimitive const *)arg1)->getCapIndices(); { - std::vector< ofIndexType > * resultptr = new std::vector< ofIndexType >((const std::vector< ofIndexType > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_unsigned_int_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ConePrimitive_getCapMesh(lua_State* L) { int SWIG_arg = 0; ofConePrimitive *arg1 = (ofConePrimitive *) 0 ; - ofMesh result; SWIG_check_num_args("ofConePrimitive::getCapMesh",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofConePrimitive::getCapMesh",1,"ofConePrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofConePrimitive,0))){ - SWIG_fail_ptr("ConePrimitive_getCapMesh",1,SWIGTYPE_p_ofConePrimitive); } - result = ((ofConePrimitive const *)arg1)->getCapMesh(); { ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ConePrimitive_getResolutionRadius(lua_State* L) { int SWIG_arg = 0; - ofConePrimitive *arg1 = (ofConePrimitive *) 0 ; int result; SWIG_check_num_args("ofConePrimitive::getResolutionRadius",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofConePrimitive::getResolutionRadius",1,"ofConePrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofConePrimitive,0))){ - SWIG_fail_ptr("ConePrimitive_getResolutionRadius",1,SWIGTYPE_p_ofConePrimitive); } - result = (int)((ofConePrimitive const *)arg1)->getResolutionRadius(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ConePrimitive_getResolutionHeight(lua_State* L) { int SWIG_arg = 0; - ofConePrimitive *arg1 = (ofConePrimitive *) 0 ; int result; SWIG_check_num_args("ofConePrimitive::getResolutionHeight",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofConePrimitive::getResolutionHeight",1,"ofConePrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofConePrimitive,0))){ - SWIG_fail_ptr("ConePrimitive_getResolutionHeight",1,SWIGTYPE_p_ofConePrimitive); } - result = (int)((ofConePrimitive const *)arg1)->getResolutionHeight(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ConePrimitive_getResolutionCap(lua_State* L) { int SWIG_arg = 0; - ofConePrimitive *arg1 = (ofConePrimitive *) 0 ; int result; SWIG_check_num_args("ofConePrimitive::getResolutionCap",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofConePrimitive::getResolutionCap",1,"ofConePrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofConePrimitive,0))){ - SWIG_fail_ptr("ConePrimitive_getResolutionCap",1,SWIGTYPE_p_ofConePrimitive); } - result = (int)((ofConePrimitive const *)arg1)->getResolutionCap(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ConePrimitive_getResolution(lua_State* L) { int SWIG_arg = 0; ofConePrimitive *arg1 = (ofConePrimitive *) 0 ; - ofVec3f result; SWIG_check_num_args("ofConePrimitive::getResolution",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofConePrimitive::getResolution",1,"ofConePrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofConePrimitive,0))){ - SWIG_fail_ptr("ConePrimitive_getResolution",1,SWIGTYPE_p_ofConePrimitive); } - result = ((ofConePrimitive const *)arg1)->getResolution(); { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ConePrimitive_getRadius(lua_State* L) { int SWIG_arg = 0; ofConePrimitive *arg1 = (ofConePrimitive *) 0 ; - float result; SWIG_check_num_args("ofConePrimitive::getRadius",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofConePrimitive::getRadius",1,"ofConePrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofConePrimitive,0))){ - SWIG_fail_ptr("ConePrimitive_getRadius",1,SWIGTYPE_p_ofConePrimitive); } - result = (float)((ofConePrimitive const *)arg1)->getRadius(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ConePrimitive_getHeight(lua_State* L) { int SWIG_arg = 0; ofConePrimitive *arg1 = (ofConePrimitive *) 0 ; - float result; SWIG_check_num_args("ofConePrimitive::getHeight",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofConePrimitive::getHeight",1,"ofConePrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofConePrimitive,0))){ - SWIG_fail_ptr("ConePrimitive_getHeight",1,SWIGTYPE_p_ofConePrimitive); } - result = (float)((ofConePrimitive const *)arg1)->getHeight(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_ConePrimitive(void *obj) { -ofConePrimitive *arg1 = (ofConePrimitive *) obj; -delete arg1; -} -static int _proxy__wrap_new_ConePrimitive(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_ConePrimitive); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_ConePrimitive_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_ConePrimitive_methods[]= { - { "set", _wrap_ConePrimitive_set}, - { "setResolutionRadius", _wrap_ConePrimitive_setResolutionRadius}, - { "setResolutionHeight", _wrap_ConePrimitive_setResolutionHeight}, - { "setResolutionCap", _wrap_ConePrimitive_setResolutionCap}, - { "setResolution", _wrap_ConePrimitive_setResolution}, - { "setMode", _wrap_ConePrimitive_setMode}, - { "setRadius", _wrap_ConePrimitive_setRadius}, - { "setHeight", _wrap_ConePrimitive_setHeight}, - { "setTopColor", _wrap_ConePrimitive_setTopColor}, - { "setCapColor", _wrap_ConePrimitive_setCapColor}, - { "getConeIndices", _wrap_ConePrimitive_getConeIndices}, - { "getConeMesh", _wrap_ConePrimitive_getConeMesh}, - { "getCapIndices", _wrap_ConePrimitive_getCapIndices}, - { "getCapMesh", _wrap_ConePrimitive_getCapMesh}, - { "getResolutionRadius", _wrap_ConePrimitive_getResolutionRadius}, - { "getResolutionHeight", _wrap_ConePrimitive_getResolutionHeight}, - { "getResolutionCap", _wrap_ConePrimitive_getResolutionCap}, - { "getResolution", _wrap_ConePrimitive_getResolution}, - { "getRadius", _wrap_ConePrimitive_getRadius}, - { "getHeight", _wrap_ConePrimitive_getHeight}, - {0,0} -}; -static swig_lua_method swig_ConePrimitive_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_ConePrimitive_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_ConePrimitive_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_ConePrimitive_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_ConePrimitive_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_ConePrimitive_Sf_SwigStatic = { - "ConePrimitive", - swig_ConePrimitive_Sf_SwigStatic_methods, - swig_ConePrimitive_Sf_SwigStatic_attributes, - swig_ConePrimitive_Sf_SwigStatic_constants, - swig_ConePrimitive_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_ConePrimitive_bases[] = {0,0}; -static const char *swig_ConePrimitive_base_names[] = {"of3dPrimitive *",0}; -static swig_lua_class _wrap_class_ConePrimitive = { "ConePrimitive", "ConePrimitive", &SWIGTYPE_p_ofConePrimitive,_proxy__wrap_new_ConePrimitive, swig_delete_ConePrimitive, swig_ConePrimitive_methods, swig_ConePrimitive_attributes, &swig_ConePrimitive_Sf_SwigStatic, swig_ConePrimitive_meta, swig_ConePrimitive_bases, swig_ConePrimitive_base_names }; - -static int _wrap_new_BoxPrimitive__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofBoxPrimitive *result = 0 ; - SWIG_check_num_args("ofBoxPrimitive::ofBoxPrimitive",0,0) result = (ofBoxPrimitive *)new ofBoxPrimitive(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofBoxPrimitive,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_BoxPrimitive__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; int arg4 ; - int arg5 ; int arg6 ; ofBoxPrimitive *result = 0 ; SWIG_check_num_args("ofBoxPrimitive::ofBoxPrimitive",6,6) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofBoxPrimitive::ofBoxPrimitive",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBoxPrimitive::ofBoxPrimitive",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofBoxPrimitive::ofBoxPrimitive",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofBoxPrimitive::ofBoxPrimitive",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofBoxPrimitive::ofBoxPrimitive",5,"int"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofBoxPrimitive::ofBoxPrimitive",6,"int"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - arg5 = (int)lua_tonumber(L, 5); arg6 = (int)lua_tonumber(L, 6); - result = (ofBoxPrimitive *)new ofBoxPrimitive(arg1,arg2,arg3,arg4,arg5,arg6); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofBoxPrimitive,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_BoxPrimitive__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; int arg4 ; - int arg5 ; ofBoxPrimitive *result = 0 ; SWIG_check_num_args("ofBoxPrimitive::ofBoxPrimitive",5,5) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofBoxPrimitive::ofBoxPrimitive",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBoxPrimitive::ofBoxPrimitive",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofBoxPrimitive::ofBoxPrimitive",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofBoxPrimitive::ofBoxPrimitive",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofBoxPrimitive::ofBoxPrimitive",5,"int"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - arg5 = (int)lua_tonumber(L, 5); result = (ofBoxPrimitive *)new ofBoxPrimitive(arg1,arg2,arg3,arg4,arg5); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofBoxPrimitive,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_BoxPrimitive__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; int arg4 ; - ofBoxPrimitive *result = 0 ; SWIG_check_num_args("ofBoxPrimitive::ofBoxPrimitive",4,4) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofBoxPrimitive::ofBoxPrimitive",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBoxPrimitive::ofBoxPrimitive",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofBoxPrimitive::ofBoxPrimitive",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofBoxPrimitive::ofBoxPrimitive",4,"int"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - result = (ofBoxPrimitive *)new ofBoxPrimitive(arg1,arg2,arg3,arg4); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofBoxPrimitive,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_BoxPrimitive__SWIG_4(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; - ofBoxPrimitive *result = 0 ; SWIG_check_num_args("ofBoxPrimitive::ofBoxPrimitive",3,3) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofBoxPrimitive::ofBoxPrimitive",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBoxPrimitive::ofBoxPrimitive",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofBoxPrimitive::ofBoxPrimitive",3,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - result = (ofBoxPrimitive *)new ofBoxPrimitive(arg1,arg2,arg3); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofBoxPrimitive,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_BoxPrimitive(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); - if (argc == 0) { return _wrap_new_BoxPrimitive__SWIG_0(L);} if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_new_BoxPrimitive__SWIG_4(L);} } } } if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_new_BoxPrimitive__SWIG_3(L);} } } } } if (argc == 5) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_new_BoxPrimitive__SWIG_2(L);} } } } } } - if (argc == 6) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { - return _wrap_new_BoxPrimitive__SWIG_1(L);} } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_BoxPrimitive'\n" " Possible C/C++ prototypes are:\n" - " ofBoxPrimitive::ofBoxPrimitive()\n" " ofBoxPrimitive::ofBoxPrimitive(float,float,float,int,int,int)\n" - " ofBoxPrimitive::ofBoxPrimitive(float,float,float,int,int)\n" - " ofBoxPrimitive::ofBoxPrimitive(float,float,float,int)\n" " ofBoxPrimitive::ofBoxPrimitive(float,float,float)\n"); - lua_error(L);return 0; } -static int _wrap_BoxPrimitive_set__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofBoxPrimitive *arg1 = (ofBoxPrimitive *) 0 ; - float arg2 ; float arg3 ; float arg4 ; int arg5 ; int arg6 ; int arg7 ; SWIG_check_num_args("ofBoxPrimitive::set",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBoxPrimitive::set",1,"ofBoxPrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBoxPrimitive::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofBoxPrimitive::set",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofBoxPrimitive::set",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofBoxPrimitive::set",5,"int"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofBoxPrimitive::set",6,"int"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofBoxPrimitive::set",7,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBoxPrimitive,0))){ - SWIG_fail_ptr("BoxPrimitive_set",1,SWIGTYPE_p_ofBoxPrimitive); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); - arg6 = (int)lua_tonumber(L, 6); arg7 = (int)lua_tonumber(L, 7); (arg1)->set(arg2,arg3,arg4,arg5,arg6,arg7); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BoxPrimitive_set__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofBoxPrimitive *arg1 = (ofBoxPrimitive *) 0 ; - float arg2 ; float arg3 ; float arg4 ; SWIG_check_num_args("ofBoxPrimitive::set",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBoxPrimitive::set",1,"ofBoxPrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBoxPrimitive::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofBoxPrimitive::set",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofBoxPrimitive::set",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBoxPrimitive,0))){ - SWIG_fail_ptr("BoxPrimitive_set",1,SWIGTYPE_p_ofBoxPrimitive); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); (arg1)->set(arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BoxPrimitive_set__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofBoxPrimitive *arg1 = (ofBoxPrimitive *) 0 ; - float arg2 ; SWIG_check_num_args("ofBoxPrimitive::set",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBoxPrimitive::set",1,"ofBoxPrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBoxPrimitive::set",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBoxPrimitive,0))){ - SWIG_fail_ptr("BoxPrimitive_set",1,SWIGTYPE_p_ofBoxPrimitive); } arg2 = (float)lua_tonumber(L, 2); (arg1)->set(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BoxPrimitive_set(lua_State* L) { int argc; int argv[8]={ 1,2,3,4,5,6,7,8} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofBoxPrimitive, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_BoxPrimitive_set__SWIG_2(L);} } - } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofBoxPrimitive, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_BoxPrimitive_set__SWIG_1(L);} } } } } if (argc == 7) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofBoxPrimitive, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { - return _wrap_BoxPrimitive_set__SWIG_0(L);} } } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'BoxPrimitive_set'\n" " Possible C/C++ prototypes are:\n" - " ofBoxPrimitive::set(float,float,float,int,int,int)\n" " ofBoxPrimitive::set(float,float,float)\n" - " ofBoxPrimitive::set(float)\n"); lua_error(L);return 0; } -static int _wrap_BoxPrimitive_setWidth(lua_State* L) { int SWIG_arg = 0; ofBoxPrimitive *arg1 = (ofBoxPrimitive *) 0 ; - float arg2 ; SWIG_check_num_args("ofBoxPrimitive::setWidth",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBoxPrimitive::setWidth",1,"ofBoxPrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBoxPrimitive::setWidth",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBoxPrimitive,0))){ - SWIG_fail_ptr("BoxPrimitive_setWidth",1,SWIGTYPE_p_ofBoxPrimitive); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setWidth(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BoxPrimitive_setHeight(lua_State* L) { int SWIG_arg = 0; ofBoxPrimitive *arg1 = (ofBoxPrimitive *) 0 ; - float arg2 ; SWIG_check_num_args("ofBoxPrimitive::setHeight",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBoxPrimitive::setHeight",1,"ofBoxPrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBoxPrimitive::setHeight",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBoxPrimitive,0))){ - SWIG_fail_ptr("BoxPrimitive_setHeight",1,SWIGTYPE_p_ofBoxPrimitive); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setHeight(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BoxPrimitive_setDepth(lua_State* L) { int SWIG_arg = 0; ofBoxPrimitive *arg1 = (ofBoxPrimitive *) 0 ; - float arg2 ; SWIG_check_num_args("ofBoxPrimitive::setDepth",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBoxPrimitive::setDepth",1,"ofBoxPrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBoxPrimitive::setDepth",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBoxPrimitive,0))){ - SWIG_fail_ptr("BoxPrimitive_setDepth",1,SWIGTYPE_p_ofBoxPrimitive); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setDepth(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BoxPrimitive_resizeToTexture(lua_State* L) { int SWIG_arg = 0; ofBoxPrimitive *arg1 = (ofBoxPrimitive *) 0 ; - ofTexture *arg2 = 0 ; SWIG_check_num_args("ofBoxPrimitive::resizeToTexture",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBoxPrimitive::resizeToTexture",1,"ofBoxPrimitive *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofBoxPrimitive::resizeToTexture",2,"ofTexture &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBoxPrimitive,0))){ - SWIG_fail_ptr("BoxPrimitive_resizeToTexture",1,SWIGTYPE_p_ofBoxPrimitive); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("BoxPrimitive_resizeToTexture",2,SWIGTYPE_p_ofTexture); } (arg1)->resizeToTexture(*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BoxPrimitive_getSideIndices(lua_State* L) { int SWIG_arg = 0; ofBoxPrimitive *arg1 = (ofBoxPrimitive *) 0 ; - int arg2 ; SwigValueWrapper< std::vector< unsigned int > > result; SWIG_check_num_args("ofBoxPrimitive::getSideIndices",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBoxPrimitive::getSideIndices",1,"ofBoxPrimitive const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBoxPrimitive::getSideIndices",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBoxPrimitive,0))){ - SWIG_fail_ptr("BoxPrimitive_getSideIndices",1,SWIGTYPE_p_ofBoxPrimitive); } arg2 = (int)lua_tonumber(L, 2); - result = ((ofBoxPrimitive const *)arg1)->getSideIndices(arg2); { - std::vector< ofIndexType > * resultptr = new std::vector< ofIndexType >((const std::vector< ofIndexType > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_unsigned_int_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BoxPrimitive_getSideMesh(lua_State* L) { int SWIG_arg = 0; ofBoxPrimitive *arg1 = (ofBoxPrimitive *) 0 ; - int arg2 ; ofMesh result; SWIG_check_num_args("ofBoxPrimitive::getSideMesh",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBoxPrimitive::getSideMesh",1,"ofBoxPrimitive const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBoxPrimitive::getSideMesh",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBoxPrimitive,0))){ - SWIG_fail_ptr("BoxPrimitive_getSideMesh",1,SWIGTYPE_p_ofBoxPrimitive); } arg2 = (int)lua_tonumber(L, 2); - result = ((ofBoxPrimitive const *)arg1)->getSideMesh(arg2); { ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_BoxPrimitive_setResolution__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofBoxPrimitive *arg1 = (ofBoxPrimitive *) 0 ; int arg2 ; SWIG_check_num_args("ofBoxPrimitive::setResolution",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBoxPrimitive::setResolution",1,"ofBoxPrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBoxPrimitive::setResolution",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBoxPrimitive,0))){ - SWIG_fail_ptr("BoxPrimitive_setResolution",1,SWIGTYPE_p_ofBoxPrimitive); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->setResolution(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BoxPrimitive_setResolutionWidth(lua_State* L) { int SWIG_arg = 0; ofBoxPrimitive *arg1 = (ofBoxPrimitive *) 0 ; - int arg2 ; SWIG_check_num_args("ofBoxPrimitive::setResolutionWidth",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBoxPrimitive::setResolutionWidth",1,"ofBoxPrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBoxPrimitive::setResolutionWidth",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBoxPrimitive,0))){ - SWIG_fail_ptr("BoxPrimitive_setResolutionWidth",1,SWIGTYPE_p_ofBoxPrimitive); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->setResolutionWidth(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BoxPrimitive_setResolutionHeight(lua_State* L) { int SWIG_arg = 0; - ofBoxPrimitive *arg1 = (ofBoxPrimitive *) 0 ; int arg2 ; SWIG_check_num_args("ofBoxPrimitive::setResolutionHeight",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBoxPrimitive::setResolutionHeight",1,"ofBoxPrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBoxPrimitive::setResolutionHeight",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBoxPrimitive,0))){ - SWIG_fail_ptr("BoxPrimitive_setResolutionHeight",1,SWIGTYPE_p_ofBoxPrimitive); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->setResolutionHeight(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BoxPrimitive_setResolutionDepth(lua_State* L) { int SWIG_arg = 0; ofBoxPrimitive *arg1 = (ofBoxPrimitive *) 0 ; - int arg2 ; SWIG_check_num_args("ofBoxPrimitive::setResolutionDepth",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBoxPrimitive::setResolutionDepth",1,"ofBoxPrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBoxPrimitive::setResolutionDepth",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBoxPrimitive,0))){ - SWIG_fail_ptr("BoxPrimitive_setResolutionDepth",1,SWIGTYPE_p_ofBoxPrimitive); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->setResolutionDepth(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BoxPrimitive_setResolution__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofBoxPrimitive *arg1 = (ofBoxPrimitive *) 0 ; int arg2 ; int arg3 ; int arg4 ; - SWIG_check_num_args("ofBoxPrimitive::setResolution",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBoxPrimitive::setResolution",1,"ofBoxPrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBoxPrimitive::setResolution",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofBoxPrimitive::setResolution",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofBoxPrimitive::setResolution",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBoxPrimitive,0))){ - SWIG_fail_ptr("BoxPrimitive_setResolution",1,SWIGTYPE_p_ofBoxPrimitive); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); (arg1)->setResolution(arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BoxPrimitive_setResolution(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofBoxPrimitive, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_BoxPrimitive_setResolution__SWIG_0(L);} } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofBoxPrimitive, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_BoxPrimitive_setResolution__SWIG_1(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'BoxPrimitive_setResolution'\n" - " Possible C/C++ prototypes are:\n" " ofBoxPrimitive::setResolution(int)\n" - " ofBoxPrimitive::setResolution(int,int,int)\n"); lua_error(L);return 0; } -static int _wrap_BoxPrimitive_setMode(lua_State* L) { int SWIG_arg = 0; ofBoxPrimitive *arg1 = (ofBoxPrimitive *) 0 ; - ofPrimitiveMode arg2 ; SWIG_check_num_args("ofBoxPrimitive::setMode",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBoxPrimitive::setMode",1,"ofBoxPrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBoxPrimitive::setMode",2,"ofPrimitiveMode"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBoxPrimitive,0))){ - SWIG_fail_ptr("BoxPrimitive_setMode",1,SWIGTYPE_p_ofBoxPrimitive); } arg2 = (ofPrimitiveMode)(int)lua_tonumber(L, 2); - (arg1)->setMode(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BoxPrimitive_setSideColor(lua_State* L) { int SWIG_arg = 0; ofBoxPrimitive *arg1 = (ofBoxPrimitive *) 0 ; - int arg2 ; ofColor arg3 ; ofColor *argp3 ; SWIG_check_num_args("ofBoxPrimitive::setSideColor",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBoxPrimitive::setSideColor",1,"ofBoxPrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBoxPrimitive::setSideColor",2,"int"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofBoxPrimitive::setSideColor",3,"ofColor"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBoxPrimitive,0))){ - SWIG_fail_ptr("BoxPrimitive_setSideColor",1,SWIGTYPE_p_ofBoxPrimitive); } arg2 = (int)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&argp3,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("BoxPrimitive_setSideColor",3,SWIGTYPE_p_ofColor_T_unsigned_char_t); } arg3 = *argp3; - (arg1)->setSideColor(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BoxPrimitive_getResolutionWidth(lua_State* L) { int SWIG_arg = 0; ofBoxPrimitive *arg1 = (ofBoxPrimitive *) 0 ; - int result; SWIG_check_num_args("ofBoxPrimitive::getResolutionWidth",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBoxPrimitive::getResolutionWidth",1,"ofBoxPrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBoxPrimitive,0))){ - SWIG_fail_ptr("BoxPrimitive_getResolutionWidth",1,SWIGTYPE_p_ofBoxPrimitive); } - result = (int)((ofBoxPrimitive const *)arg1)->getResolutionWidth(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BoxPrimitive_getResolutionHeight(lua_State* L) { int SWIG_arg = 0; - ofBoxPrimitive *arg1 = (ofBoxPrimitive *) 0 ; int result; SWIG_check_num_args("ofBoxPrimitive::getResolutionHeight",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBoxPrimitive::getResolutionHeight",1,"ofBoxPrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBoxPrimitive,0))){ - SWIG_fail_ptr("BoxPrimitive_getResolutionHeight",1,SWIGTYPE_p_ofBoxPrimitive); } - result = (int)((ofBoxPrimitive const *)arg1)->getResolutionHeight(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BoxPrimitive_getResolutionDepth(lua_State* L) { int SWIG_arg = 0; ofBoxPrimitive *arg1 = (ofBoxPrimitive *) 0 ; - int result; SWIG_check_num_args("ofBoxPrimitive::getResolutionDepth",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBoxPrimitive::getResolutionDepth",1,"ofBoxPrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBoxPrimitive,0))){ - SWIG_fail_ptr("BoxPrimitive_getResolutionDepth",1,SWIGTYPE_p_ofBoxPrimitive); } - result = (int)((ofBoxPrimitive const *)arg1)->getResolutionDepth(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BoxPrimitive_getResolution(lua_State* L) { int SWIG_arg = 0; ofBoxPrimitive *arg1 = (ofBoxPrimitive *) 0 ; - ofVec3f result; SWIG_check_num_args("ofBoxPrimitive::getResolution",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBoxPrimitive::getResolution",1,"ofBoxPrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBoxPrimitive,0))){ - SWIG_fail_ptr("BoxPrimitive_getResolution",1,SWIGTYPE_p_ofBoxPrimitive); } - result = ((ofBoxPrimitive const *)arg1)->getResolution(); { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_BoxPrimitive_getWidth(lua_State* L) { int SWIG_arg = 0; ofBoxPrimitive *arg1 = (ofBoxPrimitive *) 0 ; - float result; SWIG_check_num_args("ofBoxPrimitive::getWidth",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBoxPrimitive::getWidth",1,"ofBoxPrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBoxPrimitive,0))){ - SWIG_fail_ptr("BoxPrimitive_getWidth",1,SWIGTYPE_p_ofBoxPrimitive); } - result = (float)((ofBoxPrimitive const *)arg1)->getWidth(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BoxPrimitive_getHeight(lua_State* L) { int SWIG_arg = 0; ofBoxPrimitive *arg1 = (ofBoxPrimitive *) 0 ; - float result; SWIG_check_num_args("ofBoxPrimitive::getHeight",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBoxPrimitive::getHeight",1,"ofBoxPrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBoxPrimitive,0))){ - SWIG_fail_ptr("BoxPrimitive_getHeight",1,SWIGTYPE_p_ofBoxPrimitive); } - result = (float)((ofBoxPrimitive const *)arg1)->getHeight(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BoxPrimitive_getDepth(lua_State* L) { int SWIG_arg = 0; ofBoxPrimitive *arg1 = (ofBoxPrimitive *) 0 ; - float result; SWIG_check_num_args("ofBoxPrimitive::getDepth",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBoxPrimitive::getDepth",1,"ofBoxPrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBoxPrimitive,0))){ - SWIG_fail_ptr("BoxPrimitive_getDepth",1,SWIGTYPE_p_ofBoxPrimitive); } - result = (float)((ofBoxPrimitive const *)arg1)->getDepth(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BoxPrimitive_getSize(lua_State* L) { int SWIG_arg = 0; ofBoxPrimitive *arg1 = (ofBoxPrimitive *) 0 ; - ofVec3f result; SWIG_check_num_args("ofBoxPrimitive::getSize",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBoxPrimitive::getSize",1,"ofBoxPrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBoxPrimitive,0))){ - SWIG_fail_ptr("BoxPrimitive_getSize",1,SWIGTYPE_p_ofBoxPrimitive); } result = ((ofBoxPrimitive const *)arg1)->getSize(); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static void swig_delete_BoxPrimitive(void *obj) { -ofBoxPrimitive *arg1 = (ofBoxPrimitive *) obj; -delete arg1; -} -static int _proxy__wrap_new_BoxPrimitive(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_BoxPrimitive); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_BoxPrimitive_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_BoxPrimitive_methods[]= { - { "set", _wrap_BoxPrimitive_set}, - { "setWidth", _wrap_BoxPrimitive_setWidth}, - { "setHeight", _wrap_BoxPrimitive_setHeight}, - { "setDepth", _wrap_BoxPrimitive_setDepth}, - { "resizeToTexture", _wrap_BoxPrimitive_resizeToTexture}, - { "getSideIndices", _wrap_BoxPrimitive_getSideIndices}, - { "getSideMesh", _wrap_BoxPrimitive_getSideMesh}, - { "setResolutionWidth", _wrap_BoxPrimitive_setResolutionWidth}, - { "setResolutionHeight", _wrap_BoxPrimitive_setResolutionHeight}, - { "setResolutionDepth", _wrap_BoxPrimitive_setResolutionDepth}, - { "setResolution", _wrap_BoxPrimitive_setResolution}, - { "setMode", _wrap_BoxPrimitive_setMode}, - { "setSideColor", _wrap_BoxPrimitive_setSideColor}, - { "getResolutionWidth", _wrap_BoxPrimitive_getResolutionWidth}, - { "getResolutionHeight", _wrap_BoxPrimitive_getResolutionHeight}, - { "getResolutionDepth", _wrap_BoxPrimitive_getResolutionDepth}, - { "getResolution", _wrap_BoxPrimitive_getResolution}, - { "getWidth", _wrap_BoxPrimitive_getWidth}, - { "getHeight", _wrap_BoxPrimitive_getHeight}, - { "getDepth", _wrap_BoxPrimitive_getDepth}, - { "getSize", _wrap_BoxPrimitive_getSize}, - {0,0} -}; -static swig_lua_method swig_BoxPrimitive_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_BoxPrimitive_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_BoxPrimitive_Sf_SwigStatic_constants[]= { - {SWIG_LUA_CONSTTAB_INT("SIDE_FRONT", ofBoxPrimitive::SIDE_FRONT)}, - {SWIG_LUA_CONSTTAB_INT("SIDE_RIGHT", ofBoxPrimitive::SIDE_RIGHT)}, - {SWIG_LUA_CONSTTAB_INT("SIDE_LEFT", ofBoxPrimitive::SIDE_LEFT)}, - {SWIG_LUA_CONSTTAB_INT("SIDE_BACK", ofBoxPrimitive::SIDE_BACK)}, - {SWIG_LUA_CONSTTAB_INT("SIDE_TOP", ofBoxPrimitive::SIDE_TOP)}, - {SWIG_LUA_CONSTTAB_INT("SIDE_BOTTOM", ofBoxPrimitive::SIDE_BOTTOM)}, - {SWIG_LUA_CONSTTAB_INT("SIDES_TOTAL", ofBoxPrimitive::SIDES_TOTAL)}, - {0,0,0,0,0,0} -}; -static swig_lua_method swig_BoxPrimitive_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_BoxPrimitive_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_BoxPrimitive_Sf_SwigStatic = { - "BoxPrimitive", - swig_BoxPrimitive_Sf_SwigStatic_methods, - swig_BoxPrimitive_Sf_SwigStatic_attributes, - swig_BoxPrimitive_Sf_SwigStatic_constants, - swig_BoxPrimitive_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_BoxPrimitive_bases[] = {0,0}; -static const char *swig_BoxPrimitive_base_names[] = {"of3dPrimitive *",0}; -static swig_lua_class _wrap_class_BoxPrimitive = { "BoxPrimitive", "BoxPrimitive", &SWIGTYPE_p_ofBoxPrimitive,_proxy__wrap_new_BoxPrimitive, swig_delete_BoxPrimitive, swig_BoxPrimitive_methods, swig_BoxPrimitive_attributes, &swig_BoxPrimitive_Sf_SwigStatic, swig_BoxPrimitive_meta, swig_BoxPrimitive_bases, swig_BoxPrimitive_base_names }; - -static int _wrap_getAppPtr(lua_State* L) { int SWIG_arg = 0; ofBaseApp *result = 0 ; SWIG_check_num_args("ofGetAppPtr",0,0) - result = (ofBaseApp *)ofGetAppPtr(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofBaseApp,0); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_exit__SWIG_0(lua_State* L) { int SWIG_arg = 0; int arg1 ; SWIG_check_num_args("ofExit",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofExit",1,"int"); arg1 = (int)lua_tonumber(L, 1); ofExit(arg1); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_exit__SWIG_1(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofExit",0,0) ofExit(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_exit(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_exit__SWIG_1(L);} if (argc == 1) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { - return _wrap_exit__SWIG_0(L);} } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'exit'\n" - " Possible C/C++ prototypes are:\n" " ofExit(int)\n" " ofExit()\n"); lua_error(L);return 0; } -static int _wrap_getFrameRate(lua_State* L) { int SWIG_arg = 0; float result; SWIG_check_num_args("ofGetFrameRate",0,0) - result = (float)ofGetFrameRate(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_getTargetFrameRate(lua_State* L) { int SWIG_arg = 0; float result; - SWIG_check_num_args("ofGetTargetFrameRate",0,0) result = (float)ofGetTargetFrameRate(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getFrameNum(lua_State* L) { int SWIG_arg = 0; uint64_t result; SWIG_check_num_args("ofGetFrameNum",0,0) - result = (uint64_t)ofGetFrameNum(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_setFrameRate(lua_State* L) { int SWIG_arg = 0; int arg1 ; SWIG_check_num_args("ofSetFrameRate",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetFrameRate",1,"int"); arg1 = (int)lua_tonumber(L, 1); ofSetFrameRate(arg1); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getLastFrameTime(lua_State* L) { int SWIG_arg = 0; double result; SWIG_check_num_args("ofGetLastFrameTime",0,0) - result = (double)ofGetLastFrameTime(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_setOrientation__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofOrientation arg1 ; bool arg2 ; - SWIG_check_num_args("ofSetOrientation",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetOrientation",1,"ofOrientation"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofSetOrientation",2,"bool"); arg1 = (ofOrientation)(int)lua_tonumber(L, 1); - arg2 = (lua_toboolean(L, 2)!=0); ofSetOrientation(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_setOrientation__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofOrientation arg1 ; - SWIG_check_num_args("ofSetOrientation",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetOrientation",1,"ofOrientation"); - arg1 = (ofOrientation)(int)lua_tonumber(L, 1); ofSetOrientation(arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_setOrientation(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; - { _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_setOrientation__SWIG_1(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_setOrientation__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'setOrientation'\n" " Possible C/C++ prototypes are:\n" - " ofSetOrientation(ofOrientation,bool)\n" " ofSetOrientation(ofOrientation)\n"); lua_error(L);return 0; } -static int _wrap_getOrientation(lua_State* L) { int SWIG_arg = 0; ofOrientation result; - SWIG_check_num_args("ofGetOrientation",0,0) result = (ofOrientation)ofGetOrientation(); - lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_hideCursor(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofHideCursor",0,0) ofHideCursor(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_showCursor(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofShowCursor",0,0) ofShowCursor(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getWindowPositionX(lua_State* L) { int SWIG_arg = 0; int result; - SWIG_check_num_args("ofGetWindowPositionX",0,0) result = (int)ofGetWindowPositionX(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getWindowPositionY(lua_State* L) { int SWIG_arg = 0; int result; - SWIG_check_num_args("ofGetWindowPositionY",0,0) result = (int)ofGetWindowPositionY(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getScreenWidth(lua_State* L) { int SWIG_arg = 0; int result; SWIG_check_num_args("ofGetScreenWidth",0,0) - result = (int)ofGetScreenWidth(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_getScreenHeight(lua_State* L) { int SWIG_arg = 0; int result; SWIG_check_num_args("ofGetScreenHeight",0,0) - result = (int)ofGetScreenHeight(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_getWindowMode(lua_State* L) { int SWIG_arg = 0; int result; SWIG_check_num_args("ofGetWindowMode",0,0) - result = (int)ofGetWindowMode(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_getWidth(lua_State* L) { int SWIG_arg = 0; int result; SWIG_check_num_args("ofGetWidth",0,0) - result = (int)ofGetWidth(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_getHeight(lua_State* L) { int SWIG_arg = 0; int result; SWIG_check_num_args("ofGetHeight",0,0) - result = (int)ofGetHeight(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_getWindowWidth(lua_State* L) { int SWIG_arg = 0; int result; SWIG_check_num_args("ofGetWindowWidth",0,0) - result = (int)ofGetWindowWidth(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_getWindowHeight(lua_State* L) { int SWIG_arg = 0; int result; SWIG_check_num_args("ofGetWindowHeight",0,0) - result = (int)ofGetWindowHeight(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_randomWidth(lua_State* L) { int SWIG_arg = 0; float result; SWIG_check_num_args("ofRandomWidth",0,0) - result = (float)ofRandomWidth(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_randomHeight(lua_State* L) { int SWIG_arg = 0; float result; SWIG_check_num_args("ofRandomHeight",0,0) - result = (float)ofRandomHeight(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_doesHWOrientation(lua_State* L) { int SWIG_arg = 0; bool result; SWIG_check_num_args("ofDoesHWOrientation",0,0) - result = (bool)ofDoesHWOrientation(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_getWindowSize(lua_State* L) { int SWIG_arg = 0; ofPoint result; SWIG_check_num_args("ofGetWindowSize",0,0) - result = ofGetWindowSize(); { ofPoint * resultptr = new ofPoint((const ofPoint &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_getWindowRect(lua_State* L) { int SWIG_arg = 0; ofRectangle result; SWIG_check_num_args("ofGetWindowRect",0,0) - result = ofGetWindowRect(); { ofRectangle * resultptr = new ofRectangle((const ofRectangle &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofRectangle,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_setWindowPosition(lua_State* L) { int SWIG_arg = 0; int arg1 ; int arg2 ; - SWIG_check_num_args("ofSetWindowPosition",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetWindowPosition",1,"int"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSetWindowPosition",2,"int"); arg1 = (int)lua_tonumber(L, 1); - arg2 = (int)lua_tonumber(L, 2); ofSetWindowPosition(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_setWindowShape(lua_State* L) { int SWIG_arg = 0; int arg1 ; int arg2 ; - SWIG_check_num_args("ofSetWindowShape",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetWindowShape",1,"int"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSetWindowShape",2,"int"); arg1 = (int)lua_tonumber(L, 1); - arg2 = (int)lua_tonumber(L, 2); ofSetWindowShape(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_setWindowTitle(lua_State* L) { int SWIG_arg = 0; std::string arg1 ; SWIG_check_num_args("ofSetWindowTitle",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofSetWindowTitle",1,"std::string"); (&arg1)->assign(lua_tostring(L,1),lua_rawlen(L,1)); - ofSetWindowTitle(arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_enableSetupScreen(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofEnableSetupScreen",0,0) - ofEnableSetupScreen(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_disableSetupScreen(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofDisableSetupScreen",0,0) - ofDisableSetupScreen(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setFullscreen(lua_State* L) { int SWIG_arg = 0; bool arg1 ; SWIG_check_num_args("ofSetFullscreen",1,1) - if(!lua_isboolean(L,1)) SWIG_fail_arg("ofSetFullscreen",1,"bool"); arg1 = (lua_toboolean(L, 1)!=0); ofSetFullscreen(arg1); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_toggleFullscreen(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofToggleFullscreen",0,0) - ofToggleFullscreen(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setVerticalSync(lua_State* L) { int SWIG_arg = 0; bool arg1 ; SWIG_check_num_args("ofSetVerticalSync",1,1) - if(!lua_isboolean(L,1)) SWIG_fail_arg("ofSetVerticalSync",1,"bool"); arg1 = (lua_toboolean(L, 1)!=0); ofSetVerticalSync(arg1); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_events(lua_State* L) { int SWIG_arg = 0; ofCoreEvents *result = 0 ; SWIG_check_num_args("ofEvents",0,0) - result = (ofCoreEvents *) &ofEvents(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofCoreEvents,0); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setEscapeQuitsApp(lua_State* L) { int SWIG_arg = 0; bool arg1 ; SWIG_check_num_args("ofSetEscapeQuitsApp",1,1) - if(!lua_isboolean(L,1)) SWIG_fail_arg("ofSetEscapeQuitsApp",1,"bool"); arg1 = (lua_toboolean(L, 1)!=0); - ofSetEscapeQuitsApp(arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_new_Arduino(lua_State* L) { int SWIG_arg = 0; ofArduino *result = 0 ; - SWIG_check_num_args("ofArduino::ofArduino",0,0) result = (ofArduino *)new ofArduino(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofArduino,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Arduino_connect__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; - std::string *arg2 = 0 ; int arg3 ; std::string temp2 ; bool result; SWIG_check_num_args("ofArduino::connect",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::connect",1,"ofArduino *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofArduino::connect",2,"std::string const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofArduino::connect",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_connect",1,SWIGTYPE_p_ofArduino); } temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - arg3 = (int)lua_tonumber(L, 3); result = (bool)(arg1)->connect((std::string const &)*arg2,arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_connect__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; - std::string *arg2 = 0 ; std::string temp2 ; bool result; SWIG_check_num_args("ofArduino::connect",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::connect",1,"ofArduino *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofArduino::connect",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_connect",1,SWIGTYPE_p_ofArduino); } temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = (bool)(arg1)->connect((std::string const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_connect(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofArduino, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { return _wrap_Arduino_connect__SWIG_1(L);} } - } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofArduino, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Arduino_connect__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Arduino_connect'\n" " Possible C/C++ prototypes are:\n" - " ofArduino::connect(std::string const &,int)\n" " ofArduino::connect(std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_Arduino_isInitialized(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; bool result; - SWIG_check_num_args("ofArduino::isInitialized",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::isInitialized",1,"ofArduino const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_isInitialized",1,SWIGTYPE_p_ofArduino); } result = (bool)((ofArduino const *)arg1)->isInitialized(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_isArduinoReady(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; bool result; - SWIG_check_num_args("ofArduino::isArduinoReady",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::isArduinoReady",1,"ofArduino const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_isArduinoReady",1,SWIGTYPE_p_ofArduino); } - result = (bool)((ofArduino const *)arg1)->isArduinoReady(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_disconnect(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; - SWIG_check_num_args("ofArduino::disconnect",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::disconnect",1,"ofArduino *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_disconnect",1,SWIGTYPE_p_ofArduino); } (arg1)->disconnect(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_update(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; - SWIG_check_num_args("ofArduino::update",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::update",1,"ofArduino *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_update",1,SWIGTYPE_p_ofArduino); } (arg1)->update(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_sendDigitalPinMode(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; int arg2 ; - int arg3 ; SWIG_check_num_args("ofArduino::sendDigitalPinMode",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::sendDigitalPinMode",1,"ofArduino *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofArduino::sendDigitalPinMode",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofArduino::sendDigitalPinMode",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_sendDigitalPinMode",1,SWIGTYPE_p_ofArduino); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); (arg1)->sendDigitalPinMode(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Arduino_sendAnalogPinReporting(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; int arg2 ; - int arg3 ; SWIG_check_num_args("ofArduino::sendAnalogPinReporting",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::sendAnalogPinReporting",1,"ofArduino *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofArduino::sendAnalogPinReporting",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofArduino::sendAnalogPinReporting",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_sendAnalogPinReporting",1,SWIGTYPE_p_ofArduino); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); (arg1)->sendAnalogPinReporting(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_setUseDelay(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; bool arg2 ; - SWIG_check_num_args("ofArduino::setUseDelay",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::setUseDelay",1,"ofArduino *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofArduino::setUseDelay",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_setUseDelay",1,SWIGTYPE_p_ofArduino); } arg2 = (lua_toboolean(L, 2)!=0); (arg1)->setUseDelay(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_setDigitalHistoryLength(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; - int arg2 ; SWIG_check_num_args("ofArduino::setDigitalHistoryLength",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::setDigitalHistoryLength",1,"ofArduino *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofArduino::setDigitalHistoryLength",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_setDigitalHistoryLength",1,SWIGTYPE_p_ofArduino); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->setDigitalHistoryLength(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_setAnalogHistoryLength(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; int arg2 ; - SWIG_check_num_args("ofArduino::setAnalogHistoryLength",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::setAnalogHistoryLength",1,"ofArduino *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofArduino::setAnalogHistoryLength",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_setAnalogHistoryLength",1,SWIGTYPE_p_ofArduino); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->setAnalogHistoryLength(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_setStringHistoryLength(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; int arg2 ; - SWIG_check_num_args("ofArduino::setStringHistoryLength",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::setStringHistoryLength",1,"ofArduino *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofArduino::setStringHistoryLength",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_setStringHistoryLength",1,SWIGTYPE_p_ofArduino); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->setStringHistoryLength(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_setSysExHistoryLength(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; int arg2 ; - SWIG_check_num_args("ofArduino::setSysExHistoryLength",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::setSysExHistoryLength",1,"ofArduino *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofArduino::setSysExHistoryLength",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_setSysExHistoryLength",1,SWIGTYPE_p_ofArduino); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->setSysExHistoryLength(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_sendDigital__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; int arg2 ; - int arg3 ; bool arg4 ; SWIG_check_num_args("ofArduino::sendDigital",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::sendDigital",1,"ofArduino *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofArduino::sendDigital",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofArduino::sendDigital",3,"int"); - if(!lua_isboolean(L,4)) SWIG_fail_arg("ofArduino::sendDigital",4,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_sendDigital",1,SWIGTYPE_p_ofArduino); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); arg4 = (lua_toboolean(L, 4)!=0); (arg1)->sendDigital(arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_sendDigital__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; int arg2 ; - int arg3 ; SWIG_check_num_args("ofArduino::sendDigital",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::sendDigital",1,"ofArduino *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofArduino::sendDigital",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofArduino::sendDigital",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_sendDigital",1,SWIGTYPE_p_ofArduino); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); (arg1)->sendDigital(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Arduino_sendDigital(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofArduino, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Arduino_sendDigital__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofArduino, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isboolean(L,argv[3]); } if (_v) { return _wrap_Arduino_sendDigital__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Arduino_sendDigital'\n" - " Possible C/C++ prototypes are:\n" " ofArduino::sendDigital(int,int,bool)\n" " ofArduino::sendDigital(int,int)\n"); - lua_error(L);return 0; } -static int _wrap_Arduino_sendPwm__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; int arg2 ; - int arg3 ; bool arg4 ; SWIG_check_num_args("ofArduino::sendPwm",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::sendPwm",1,"ofArduino *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofArduino::sendPwm",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofArduino::sendPwm",3,"int"); - if(!lua_isboolean(L,4)) SWIG_fail_arg("ofArduino::sendPwm",4,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_sendPwm",1,SWIGTYPE_p_ofArduino); } arg2 = (int)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); - arg4 = (lua_toboolean(L, 4)!=0); (arg1)->sendPwm(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Arduino_sendPwm__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; int arg2 ; - int arg3 ; SWIG_check_num_args("ofArduino::sendPwm",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::sendPwm",1,"ofArduino *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofArduino::sendPwm",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofArduino::sendPwm",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_sendPwm",1,SWIGTYPE_p_ofArduino); } arg2 = (int)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); - (arg1)->sendPwm(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_sendPwm(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofArduino, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Arduino_sendPwm__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofArduino, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isboolean(L,argv[3]); } if (_v) { return _wrap_Arduino_sendPwm__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Arduino_sendPwm'\n" " Possible C/C++ prototypes are:\n" - " ofArduino::sendPwm(int,int,bool)\n" " ofArduino::sendPwm(int,int)\n"); lua_error(L);return 0; } -static int _wrap_Arduino_sendSysEx(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; int arg2 ; - std::vector< unsigned char > arg3 ; std::vector< unsigned char > *argp3 ; SWIG_check_num_args("ofArduino::sendSysEx",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::sendSysEx",1,"ofArduino *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofArduino::sendSysEx",2,"int"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofArduino::sendSysEx",3,"std::vector< unsigned char >"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_sendSysEx",1,SWIGTYPE_p_ofArduino); } arg2 = (int)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&argp3,SWIGTYPE_p_std__vectorT_unsigned_char_t,0))){ - SWIG_fail_ptr("Arduino_sendSysEx",3,SWIGTYPE_p_std__vectorT_unsigned_char_t); } arg3 = *argp3; - (arg1)->sendSysEx(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_sendString(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; std::string arg2 ; - SWIG_check_num_args("ofArduino::sendString",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::sendString",1,"ofArduino *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofArduino::sendString",2,"std::string"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_sendString",1,SWIGTYPE_p_ofArduino); } (&arg2)->assign(lua_tostring(L,2),lua_rawlen(L,2)); - (arg1)->sendString(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_sendProtocolVersionRequest(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; - SWIG_check_num_args("ofArduino::sendProtocolVersionRequest",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::sendProtocolVersionRequest",1,"ofArduino *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_sendProtocolVersionRequest",1,SWIGTYPE_p_ofArduino); } (arg1)->sendProtocolVersionRequest(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_sendFirmwareVersionRequest(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; - SWIG_check_num_args("ofArduino::sendFirmwareVersionRequest",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::sendFirmwareVersionRequest",1,"ofArduino *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_sendFirmwareVersionRequest",1,SWIGTYPE_p_ofArduino); } (arg1)->sendFirmwareVersionRequest(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_sendReset(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; - SWIG_check_num_args("ofArduino::sendReset",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::sendReset",1,"ofArduino *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_sendReset",1,SWIGTYPE_p_ofArduino); } (arg1)->sendReset(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_sendSysExBegin(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; - SWIG_check_num_args("ofArduino::sendSysExBegin",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::sendSysExBegin",1,"ofArduino *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_sendSysExBegin",1,SWIGTYPE_p_ofArduino); } (arg1)->sendSysExBegin(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_sendSysExEnd(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; - SWIG_check_num_args("ofArduino::sendSysExEnd",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::sendSysExEnd",1,"ofArduino *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_sendSysExEnd",1,SWIGTYPE_p_ofArduino); } (arg1)->sendSysExEnd(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_sendByte(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; unsigned char arg2 ; - SWIG_check_num_args("ofArduino::sendByte",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::sendByte",1,"ofArduino *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofArduino::sendByte",2,"unsigned char"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_sendByte",1,SWIGTYPE_p_ofArduino); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned char)lua_tonumber(L, 2); - (arg1)->sendByte(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_sendValueAsTwo7bitBytes(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; - int arg2 ; SWIG_check_num_args("ofArduino::sendValueAsTwo7bitBytes",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::sendValueAsTwo7bitBytes",1,"ofArduino *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofArduino::sendValueAsTwo7bitBytes",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_sendValueAsTwo7bitBytes",1,SWIGTYPE_p_ofArduino); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->sendValueAsTwo7bitBytes(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_getPwm(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; int arg2 ; int result; - SWIG_check_num_args("ofArduino::getPwm",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::getPwm",1,"ofArduino const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofArduino::getPwm",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_getPwm",1,SWIGTYPE_p_ofArduino); } arg2 = (int)lua_tonumber(L, 2); - result = (int)((ofArduino const *)arg1)->getPwm(arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_getDigital(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; int arg2 ; int result; - SWIG_check_num_args("ofArduino::getDigital",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::getDigital",1,"ofArduino const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofArduino::getDigital",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_getDigital",1,SWIGTYPE_p_ofArduino); } arg2 = (int)lua_tonumber(L, 2); - result = (int)((ofArduino const *)arg1)->getDigital(arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_getAnalog(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; int arg2 ; int result; - SWIG_check_num_args("ofArduino::getAnalog",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::getAnalog",1,"ofArduino const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofArduino::getAnalog",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_getAnalog",1,SWIGTYPE_p_ofArduino); } arg2 = (int)lua_tonumber(L, 2); - result = (int)((ofArduino const *)arg1)->getAnalog(arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_getSysEx(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; - std::vector< unsigned char > result; SWIG_check_num_args("ofArduino::getSysEx",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::getSysEx",1,"ofArduino const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_getSysEx",1,SWIGTYPE_p_ofArduino); } result = ((ofArduino const *)arg1)->getSysEx(); { - std::vector< unsigned char > * resultptr = new std::vector< unsigned char >((const std::vector< unsigned char > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_unsigned_char_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_getString(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; std::string result; - SWIG_check_num_args("ofArduino::getString",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::getString",1,"ofArduino const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_getString",1,SWIGTYPE_p_ofArduino); } result = ((ofArduino const *)arg1)->getString(); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Arduino_getMajorProtocolVersion(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; - int result; SWIG_check_num_args("ofArduino::getMajorProtocolVersion",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::getMajorProtocolVersion",1,"ofArduino const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_getMajorProtocolVersion",1,SWIGTYPE_p_ofArduino); } - result = (int)((ofArduino const *)arg1)->getMajorProtocolVersion(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_getMinorProtocolVersion(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; - int result; SWIG_check_num_args("ofArduino::getMinorProtocolVersion",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::getMinorProtocolVersion",1,"ofArduino const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_getMinorProtocolVersion",1,SWIGTYPE_p_ofArduino); } - result = (int)((ofArduino const *)arg1)->getMinorProtocolVersion(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_getMajorFirmwareVersion(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; - int result; SWIG_check_num_args("ofArduino::getMajorFirmwareVersion",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::getMajorFirmwareVersion",1,"ofArduino const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_getMajorFirmwareVersion",1,SWIGTYPE_p_ofArduino); } - result = (int)((ofArduino const *)arg1)->getMajorFirmwareVersion(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_getMinorFirmwareVersion(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; - int result; SWIG_check_num_args("ofArduino::getMinorFirmwareVersion",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::getMinorFirmwareVersion",1,"ofArduino const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_getMinorFirmwareVersion",1,SWIGTYPE_p_ofArduino); } - result = (int)((ofArduino const *)arg1)->getMinorFirmwareVersion(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_getFirmwareName(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; - std::string result; SWIG_check_num_args("ofArduino::getFirmwareName",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::getFirmwareName",1,"ofArduino const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_getFirmwareName",1,SWIGTYPE_p_ofArduino); } result = ((ofArduino const *)arg1)->getFirmwareName(); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Arduino_getDigitalPinMode(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; int arg2 ; - int result; SWIG_check_num_args("ofArduino::getDigitalPinMode",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::getDigitalPinMode",1,"ofArduino const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofArduino::getDigitalPinMode",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_getDigitalPinMode",1,SWIGTYPE_p_ofArduino); } arg2 = (int)lua_tonumber(L, 2); - result = (int)((ofArduino const *)arg1)->getDigitalPinMode(arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_getAnalogPinReporting(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; int arg2 ; - int result; SWIG_check_num_args("ofArduino::getAnalogPinReporting",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::getAnalogPinReporting",1,"ofArduino const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofArduino::getAnalogPinReporting",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_getAnalogPinReporting",1,SWIGTYPE_p_ofArduino); } arg2 = (int)lua_tonumber(L, 2); - result = (int)((ofArduino const *)arg1)->getAnalogPinReporting(arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_getValueFromTwo7bitBytes(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; - unsigned char arg2 ; unsigned char arg3 ; int result; SWIG_check_num_args("ofArduino::getValueFromTwo7bitBytes",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::getValueFromTwo7bitBytes",1,"ofArduino *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofArduino::getValueFromTwo7bitBytes",2,"unsigned char"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofArduino::getValueFromTwo7bitBytes",3,"unsigned char"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_getValueFromTwo7bitBytes",1,SWIGTYPE_p_ofArduino); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned char)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (unsigned char)lua_tonumber(L, 3); - result = (int)(arg1)->getValueFromTwo7bitBytes(arg2,arg3); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_EDigitalPinChanged_set(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; - ofEvent< int const > arg2 ; ofEvent< int const > *argp2 ; SWIG_check_num_args("ofArduino::EDigitalPinChanged",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::EDigitalPinChanged",1,"ofArduino *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofArduino::EDigitalPinChanged",2,"ofEvent< int const >"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_EDigitalPinChanged_set",1,SWIGTYPE_p_ofArduino); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofEventT_int_const_t,0))){ - SWIG_fail_ptr("Arduino_EDigitalPinChanged_set",2,SWIGTYPE_p_ofEventT_int_const_t); } arg2 = *argp2; - if (arg1) (arg1)->EDigitalPinChanged = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_EDigitalPinChanged_get(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; - ofEvent< int const > result; SWIG_check_num_args("ofArduino::EDigitalPinChanged",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::EDigitalPinChanged",1,"ofArduino *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_EDigitalPinChanged_get",1,SWIGTYPE_p_ofArduino); } result = ((arg1)->EDigitalPinChanged); { - ofEvent< int const > * resultptr = new ofEvent< int const >((const ofEvent< int const > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofEventT_int_const_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_EAnalogPinChanged_set(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; - ofEvent< int const > arg2 ; ofEvent< int const > *argp2 ; SWIG_check_num_args("ofArduino::EAnalogPinChanged",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::EAnalogPinChanged",1,"ofArduino *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofArduino::EAnalogPinChanged",2,"ofEvent< int const >"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_EAnalogPinChanged_set",1,SWIGTYPE_p_ofArduino); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofEventT_int_const_t,0))){ - SWIG_fail_ptr("Arduino_EAnalogPinChanged_set",2,SWIGTYPE_p_ofEventT_int_const_t); } arg2 = *argp2; - if (arg1) (arg1)->EAnalogPinChanged = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_EAnalogPinChanged_get(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; - ofEvent< int const > result; SWIG_check_num_args("ofArduino::EAnalogPinChanged",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::EAnalogPinChanged",1,"ofArduino *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_EAnalogPinChanged_get",1,SWIGTYPE_p_ofArduino); } result = ((arg1)->EAnalogPinChanged); { - ofEvent< int const > * resultptr = new ofEvent< int const >((const ofEvent< int const > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofEventT_int_const_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_ESysExReceived_set(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; - ofEvent< std::vector< unsigned char > const > *arg2 = (ofEvent< std::vector< unsigned char > const > *) 0 ; - SWIG_check_num_args("ofArduino::ESysExReceived",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::ESysExReceived",1,"ofArduino *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofArduino::ESysExReceived",2,"ofEvent< std::vector< unsigned char > const > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_ESysExReceived_set",1,SWIGTYPE_p_ofArduino); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofEventT_std__vectorT_unsigned_char_t_const_t,0))){ - SWIG_fail_ptr("Arduino_ESysExReceived_set",2,SWIGTYPE_p_ofEventT_std__vectorT_unsigned_char_t_const_t); } - if (arg1) (arg1)->ESysExReceived = *arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_ESysExReceived_get(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; - ofEvent< std::vector< unsigned char > const > *result = 0 ; SWIG_check_num_args("ofArduino::ESysExReceived",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::ESysExReceived",1,"ofArduino *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_ESysExReceived_get",1,SWIGTYPE_p_ofArduino); } - result = (ofEvent< std::vector< unsigned char > const > *)& ((arg1)->ESysExReceived); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofEventT_std__vectorT_unsigned_char_t_const_t,0); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_EProtocolVersionReceived_set(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; - ofEvent< int const > arg2 ; ofEvent< int const > *argp2 ; SWIG_check_num_args("ofArduino::EProtocolVersionReceived",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::EProtocolVersionReceived",1,"ofArduino *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofArduino::EProtocolVersionReceived",2,"ofEvent< int const >"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_EProtocolVersionReceived_set",1,SWIGTYPE_p_ofArduino); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofEventT_int_const_t,0))){ - SWIG_fail_ptr("Arduino_EProtocolVersionReceived_set",2,SWIGTYPE_p_ofEventT_int_const_t); } arg2 = *argp2; - if (arg1) (arg1)->EProtocolVersionReceived = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_EProtocolVersionReceived_get(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; - ofEvent< int const > result; SWIG_check_num_args("ofArduino::EProtocolVersionReceived",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::EProtocolVersionReceived",1,"ofArduino *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_EProtocolVersionReceived_get",1,SWIGTYPE_p_ofArduino); } - result = ((arg1)->EProtocolVersionReceived); { - ofEvent< int const > * resultptr = new ofEvent< int const >((const ofEvent< int const > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofEventT_int_const_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_EFirmwareVersionReceived_set(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; - ofEvent< int const > arg2 ; ofEvent< int const > *argp2 ; SWIG_check_num_args("ofArduino::EFirmwareVersionReceived",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::EFirmwareVersionReceived",1,"ofArduino *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofArduino::EFirmwareVersionReceived",2,"ofEvent< int const >"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_EFirmwareVersionReceived_set",1,SWIGTYPE_p_ofArduino); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofEventT_int_const_t,0))){ - SWIG_fail_ptr("Arduino_EFirmwareVersionReceived_set",2,SWIGTYPE_p_ofEventT_int_const_t); } arg2 = *argp2; - if (arg1) (arg1)->EFirmwareVersionReceived = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_EFirmwareVersionReceived_get(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; - ofEvent< int const > result; SWIG_check_num_args("ofArduino::EFirmwareVersionReceived",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::EFirmwareVersionReceived",1,"ofArduino *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_EFirmwareVersionReceived_get",1,SWIGTYPE_p_ofArduino); } - result = ((arg1)->EFirmwareVersionReceived); { - ofEvent< int const > * resultptr = new ofEvent< int const >((const ofEvent< int const > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofEventT_int_const_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_EInitialized_set(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; - ofEvent< int const > arg2 ; ofEvent< int const > *argp2 ; SWIG_check_num_args("ofArduino::EInitialized",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::EInitialized",1,"ofArduino *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofArduino::EInitialized",2,"ofEvent< int const >"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_EInitialized_set",1,SWIGTYPE_p_ofArduino); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofEventT_int_const_t,0))){ - SWIG_fail_ptr("Arduino_EInitialized_set",2,SWIGTYPE_p_ofEventT_int_const_t); } arg2 = *argp2; - if (arg1) (arg1)->EInitialized = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_EInitialized_get(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; - ofEvent< int const > result; SWIG_check_num_args("ofArduino::EInitialized",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::EInitialized",1,"ofArduino *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_EInitialized_get",1,SWIGTYPE_p_ofArduino); } result = ((arg1)->EInitialized); { - ofEvent< int const > * resultptr = new ofEvent< int const >((const ofEvent< int const > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofEventT_int_const_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_EStringReceived_set(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; - ofEvent< std::string const > *arg2 = (ofEvent< std::string const > *) 0 ; - SWIG_check_num_args("ofArduino::EStringReceived",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::EStringReceived",1,"ofArduino *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofArduino::EStringReceived",2,"ofEvent< std::string const > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_EStringReceived_set",1,SWIGTYPE_p_ofArduino); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofEventT_std__string_const_t,0))){ - SWIG_fail_ptr("Arduino_EStringReceived_set",2,SWIGTYPE_p_ofEventT_std__string_const_t); } - if (arg1) (arg1)->EStringReceived = *arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_EStringReceived_get(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; - ofEvent< std::string const > *result = 0 ; SWIG_check_num_args("ofArduino::EStringReceived",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::EStringReceived",1,"ofArduino *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_EStringReceived_get",1,SWIGTYPE_p_ofArduino); } - result = (ofEvent< std::string const > *)& ((arg1)->EStringReceived); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofEventT_std__string_const_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_sendServo__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; int arg2 ; - int arg3 ; bool arg4 ; SWIG_check_num_args("ofArduino::sendServo",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::sendServo",1,"ofArduino *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofArduino::sendServo",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofArduino::sendServo",3,"int"); - if(!lua_isboolean(L,4)) SWIG_fail_arg("ofArduino::sendServo",4,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_sendServo",1,SWIGTYPE_p_ofArduino); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); arg4 = (lua_toboolean(L, 4)!=0); (arg1)->sendServo(arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_sendServo__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; int arg2 ; - int arg3 ; SWIG_check_num_args("ofArduino::sendServo",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::sendServo",1,"ofArduino *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofArduino::sendServo",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofArduino::sendServo",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_sendServo",1,SWIGTYPE_p_ofArduino); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); (arg1)->sendServo(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Arduino_sendServo(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofArduino, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Arduino_sendServo__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofArduino, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isboolean(L,argv[3]); } if (_v) { return _wrap_Arduino_sendServo__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Arduino_sendServo'\n" " Possible C/C++ prototypes are:\n" - " ofArduino::sendServo(int,int,bool)\n" " ofArduino::sendServo(int,int)\n"); lua_error(L);return 0; } -static int _wrap_Arduino_sendServoAttach__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; - int arg2 ; int arg3 ; int arg4 ; int arg5 ; SWIG_check_num_args("ofArduino::sendServoAttach",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::sendServoAttach",1,"ofArduino *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofArduino::sendServoAttach",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofArduino::sendServoAttach",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofArduino::sendServoAttach",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofArduino::sendServoAttach",5,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_sendServoAttach",1,SWIGTYPE_p_ofArduino); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); - (arg1)->sendServoAttach(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_sendServoAttach__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; - int arg2 ; int arg3 ; int arg4 ; SWIG_check_num_args("ofArduino::sendServoAttach",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::sendServoAttach",1,"ofArduino *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofArduino::sendServoAttach",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofArduino::sendServoAttach",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofArduino::sendServoAttach",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_sendServoAttach",1,SWIGTYPE_p_ofArduino); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); (arg1)->sendServoAttach(arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_sendServoAttach__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; - int arg2 ; int arg3 ; SWIG_check_num_args("ofArduino::sendServoAttach",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::sendServoAttach",1,"ofArduino *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofArduino::sendServoAttach",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofArduino::sendServoAttach",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_sendServoAttach",1,SWIGTYPE_p_ofArduino); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); (arg1)->sendServoAttach(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Arduino_sendServoAttach__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; - int arg2 ; SWIG_check_num_args("ofArduino::sendServoAttach",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::sendServoAttach",1,"ofArduino *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofArduino::sendServoAttach",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_sendServoAttach",1,SWIGTYPE_p_ofArduino); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->sendServoAttach(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_sendServoAttach(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofArduino, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Arduino_sendServoAttach__SWIG_3(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofArduino, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Arduino_sendServoAttach__SWIG_2(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofArduino, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Arduino_sendServoAttach__SWIG_1(L);} } } } } - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofArduino, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Arduino_sendServoAttach__SWIG_0(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Arduino_sendServoAttach'\n" - " Possible C/C++ prototypes are:\n" " ofArduino::sendServoAttach(int,int,int,int)\n" - " ofArduino::sendServoAttach(int,int,int)\n" " ofArduino::sendServoAttach(int,int)\n" - " ofArduino::sendServoAttach(int)\n"); lua_error(L);return 0; } -static int _wrap_Arduino_sendServoDetach(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; int arg2 ; - SWIG_check_num_args("ofArduino::sendServoDetach",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::sendServoDetach",1,"ofArduino *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofArduino::sendServoDetach",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_sendServoDetach",1,SWIGTYPE_p_ofArduino); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->sendServoDetach(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_getServo(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; int arg2 ; int result; - SWIG_check_num_args("ofArduino::getServo",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::getServo",1,"ofArduino const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofArduino::getServo",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_getServo",1,SWIGTYPE_p_ofArduino); } arg2 = (int)lua_tonumber(L, 2); - result = (int)((ofArduino const *)arg1)->getServo(arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_Arduino(void *obj) { -ofArduino *arg1 = (ofArduino *) obj; -delete arg1; -} -static int _proxy__wrap_new_Arduino(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_Arduino); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_Arduino_attributes[] = { - { "EDigitalPinChanged", _wrap_Arduino_EDigitalPinChanged_get, _wrap_Arduino_EDigitalPinChanged_set }, - { "EAnalogPinChanged", _wrap_Arduino_EAnalogPinChanged_get, _wrap_Arduino_EAnalogPinChanged_set }, - { "ESysExReceived", _wrap_Arduino_ESysExReceived_get, _wrap_Arduino_ESysExReceived_set }, - { "EProtocolVersionReceived", _wrap_Arduino_EProtocolVersionReceived_get, _wrap_Arduino_EProtocolVersionReceived_set }, - { "EFirmwareVersionReceived", _wrap_Arduino_EFirmwareVersionReceived_get, _wrap_Arduino_EFirmwareVersionReceived_set }, - { "EInitialized", _wrap_Arduino_EInitialized_get, _wrap_Arduino_EInitialized_set }, - { "EStringReceived", _wrap_Arduino_EStringReceived_get, _wrap_Arduino_EStringReceived_set }, - {0,0,0} -}; -static swig_lua_method swig_Arduino_methods[]= { - { "connect", _wrap_Arduino_connect}, - { "isInitialized", _wrap_Arduino_isInitialized}, - { "isArduinoReady", _wrap_Arduino_isArduinoReady}, - { "disconnect", _wrap_Arduino_disconnect}, - { "update", _wrap_Arduino_update}, - { "sendDigitalPinMode", _wrap_Arduino_sendDigitalPinMode}, - { "sendAnalogPinReporting", _wrap_Arduino_sendAnalogPinReporting}, - { "setUseDelay", _wrap_Arduino_setUseDelay}, - { "setDigitalHistoryLength", _wrap_Arduino_setDigitalHistoryLength}, - { "setAnalogHistoryLength", _wrap_Arduino_setAnalogHistoryLength}, - { "setStringHistoryLength", _wrap_Arduino_setStringHistoryLength}, - { "setSysExHistoryLength", _wrap_Arduino_setSysExHistoryLength}, - { "sendDigital", _wrap_Arduino_sendDigital}, - { "sendPwm", _wrap_Arduino_sendPwm}, - { "sendSysEx", _wrap_Arduino_sendSysEx}, - { "sendString", _wrap_Arduino_sendString}, - { "sendProtocolVersionRequest", _wrap_Arduino_sendProtocolVersionRequest}, - { "sendFirmwareVersionRequest", _wrap_Arduino_sendFirmwareVersionRequest}, - { "sendReset", _wrap_Arduino_sendReset}, - { "sendSysExBegin", _wrap_Arduino_sendSysExBegin}, - { "sendSysExEnd", _wrap_Arduino_sendSysExEnd}, - { "sendByte", _wrap_Arduino_sendByte}, - { "sendValueAsTwo7bitBytes", _wrap_Arduino_sendValueAsTwo7bitBytes}, - { "getPwm", _wrap_Arduino_getPwm}, - { "getDigital", _wrap_Arduino_getDigital}, - { "getAnalog", _wrap_Arduino_getAnalog}, - { "getSysEx", _wrap_Arduino_getSysEx}, - { "getString", _wrap_Arduino_getString}, - { "getMajorProtocolVersion", _wrap_Arduino_getMajorProtocolVersion}, - { "getMinorProtocolVersion", _wrap_Arduino_getMinorProtocolVersion}, - { "getMajorFirmwareVersion", _wrap_Arduino_getMajorFirmwareVersion}, - { "getMinorFirmwareVersion", _wrap_Arduino_getMinorFirmwareVersion}, - { "getFirmwareName", _wrap_Arduino_getFirmwareName}, - { "getDigitalPinMode", _wrap_Arduino_getDigitalPinMode}, - { "getAnalogPinReporting", _wrap_Arduino_getAnalogPinReporting}, - { "getValueFromTwo7bitBytes", _wrap_Arduino_getValueFromTwo7bitBytes}, - { "sendServo", _wrap_Arduino_sendServo}, - { "sendServoAttach", _wrap_Arduino_sendServoAttach}, - { "sendServoDetach", _wrap_Arduino_sendServoDetach}, - { "getServo", _wrap_Arduino_getServo}, - {0,0} -}; -static swig_lua_method swig_Arduino_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_Arduino_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_Arduino_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_Arduino_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_Arduino_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_Arduino_Sf_SwigStatic = { - "Arduino", - swig_Arduino_Sf_SwigStatic_methods, - swig_Arduino_Sf_SwigStatic_attributes, - swig_Arduino_Sf_SwigStatic_constants, - swig_Arduino_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_Arduino_bases[] = {0}; -static const char *swig_Arduino_base_names[] = {0}; -static swig_lua_class _wrap_class_Arduino = { "Arduino", "Arduino", &SWIGTYPE_p_ofArduino,_proxy__wrap_new_Arduino, swig_delete_Arduino, swig_Arduino_methods, swig_Arduino_attributes, &swig_Arduino_Sf_SwigStatic, swig_Arduino_meta, swig_Arduino_bases, swig_Arduino_base_names }; - -static int _wrap_new_Serial(lua_State* L) { int SWIG_arg = 0; ofSerial *result = 0 ; - SWIG_check_num_args("ofSerial::ofSerial",0,0) result = (ofSerial *)new ofSerial(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofSerial,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Serial_listDevices(lua_State* L) { int SWIG_arg = 0; ofSerial *arg1 = (ofSerial *) 0 ; - SWIG_check_num_args("ofSerial::listDevices",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSerial::listDevices",1,"ofSerial *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSerial,0))){ - SWIG_fail_ptr("Serial_listDevices",1,SWIGTYPE_p_ofSerial); } (arg1)->listDevices(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Serial_getDeviceList(lua_State* L) { int SWIG_arg = 0; ofSerial *arg1 = (ofSerial *) 0 ; - SwigValueWrapper< std::vector< ofSerialDeviceInfo > > result; SWIG_check_num_args("ofSerial::getDeviceList",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSerial::getDeviceList",1,"ofSerial *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSerial,0))){ - SWIG_fail_ptr("Serial_getDeviceList",1,SWIGTYPE_p_ofSerial); } result = (arg1)->getDeviceList(); { - std::vector< ofSerialDeviceInfo > * resultptr = new std::vector< ofSerialDeviceInfo >((const std::vector< ofSerialDeviceInfo > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_ofSerialDeviceInfo_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Serial_setup__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofSerial *arg1 = (ofSerial *) 0 ; bool result; - SWIG_check_num_args("ofSerial::setup",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSerial::setup",1,"ofSerial *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSerial,0))){ - SWIG_fail_ptr("Serial_setup",1,SWIGTYPE_p_ofSerial); } result = (bool)(arg1)->setup(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Serial_setup__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofSerial *arg1 = (ofSerial *) 0 ; std::string arg2 ; - int arg3 ; bool result; SWIG_check_num_args("ofSerial::setup",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSerial::setup",1,"ofSerial *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofSerial::setup",2,"std::string"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofSerial::setup",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSerial,0))){ - SWIG_fail_ptr("Serial_setup",1,SWIGTYPE_p_ofSerial); } (&arg2)->assign(lua_tostring(L,2),lua_rawlen(L,2)); - arg3 = (int)lua_tonumber(L, 3); result = (bool)(arg1)->setup(arg2,arg3); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Serial_setup__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofSerial *arg1 = (ofSerial *) 0 ; int arg2 ; int arg3 ; - bool result; SWIG_check_num_args("ofSerial::setup",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSerial::setup",1,"ofSerial *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSerial::setup",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofSerial::setup",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSerial,0))){ - SWIG_fail_ptr("Serial_setup",1,SWIGTYPE_p_ofSerial); } arg2 = (int)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); - result = (bool)(arg1)->setup(arg2,arg3); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Serial_setup(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 1) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofSerial, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Serial_setup__SWIG_0(L);} } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofSerial, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_Serial_setup__SWIG_2(L);} } } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofSerial, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Serial_setup__SWIG_1(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Serial_setup'\n" " Possible C/C++ prototypes are:\n" - " ofSerial::setup()\n" " ofSerial::setup(std::string,int)\n" " ofSerial::setup(int,int)\n"); lua_error(L);return 0; } -static int _wrap_Serial_isInitialized(lua_State* L) { int SWIG_arg = 0; ofSerial *arg1 = (ofSerial *) 0 ; bool result; - SWIG_check_num_args("ofSerial::isInitialized",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSerial::isInitialized",1,"ofSerial const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSerial,0))){ - SWIG_fail_ptr("Serial_isInitialized",1,SWIGTYPE_p_ofSerial); } result = (bool)((ofSerial const *)arg1)->isInitialized(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Serial_close(lua_State* L) { int SWIG_arg = 0; ofSerial *arg1 = (ofSerial *) 0 ; - SWIG_check_num_args("ofSerial::close",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSerial::close",1,"ofSerial *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSerial,0))){ - SWIG_fail_ptr("Serial_close",1,SWIGTYPE_p_ofSerial); } (arg1)->close(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Serial_available(lua_State* L) { int SWIG_arg = 0; ofSerial *arg1 = (ofSerial *) 0 ; int result; - SWIG_check_num_args("ofSerial::available",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSerial::available",1,"ofSerial *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSerial,0))){ - SWIG_fail_ptr("Serial_available",1,SWIGTYPE_p_ofSerial); } result = (int)(arg1)->available(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Serial_readBytes(lua_State* L) { int SWIG_arg = 0; ofSerial *arg1 = (ofSerial *) 0 ; - unsigned char *arg2 = (unsigned char *) 0 ; int arg3 ; int result; SWIG_check_num_args("ofSerial::readBytes",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSerial::readBytes",1,"ofSerial *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSerial,0))){ - SWIG_fail_ptr("Serial_readBytes",1,SWIGTYPE_p_ofSerial); } { arg3 = (int)lua_tonumber(L, 2+1); - arg2 = (unsigned char *)lua_tolstring(L, 2, (size_t *)&arg3); } result = (int)(arg1)->readBytes(arg2,arg3); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Serial_readByte(lua_State* L) { int SWIG_arg = 0; ofSerial *arg1 = (ofSerial *) 0 ; int result; - SWIG_check_num_args("ofSerial::readByte",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSerial::readByte",1,"ofSerial *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSerial,0))){ - SWIG_fail_ptr("Serial_readByte",1,SWIGTYPE_p_ofSerial); } result = (int)(arg1)->readByte(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Serial_writeBytes(lua_State* L) { int SWIG_arg = 0; ofSerial *arg1 = (ofSerial *) 0 ; - unsigned char *arg2 = (unsigned char *) 0 ; int arg3 ; int result; SWIG_check_num_args("ofSerial::writeBytes",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSerial::writeBytes",1,"ofSerial *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSerial,0))){ - SWIG_fail_ptr("Serial_writeBytes",1,SWIGTYPE_p_ofSerial); } { arg3 = (int)lua_tonumber(L, 2+1); - arg2 = (unsigned char *)lua_tolstring(L, 2, (size_t *)&arg3); } result = (int)(arg1)->writeBytes(arg2,arg3); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Serial_writeByte(lua_State* L) { int SWIG_arg = 0; ofSerial *arg1 = (ofSerial *) 0 ; unsigned char arg2 ; - bool result; SWIG_check_num_args("ofSerial::writeByte",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSerial::writeByte",1,"ofSerial *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSerial::writeByte",2,"unsigned char"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSerial,0))){ - SWIG_fail_ptr("Serial_writeByte",1,SWIGTYPE_p_ofSerial); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned char)lua_tonumber(L, 2); - result = (bool)(arg1)->writeByte(arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Serial_flush__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofSerial *arg1 = (ofSerial *) 0 ; bool arg2 ; - bool arg3 ; SWIG_check_num_args("ofSerial::flush",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSerial::flush",1,"ofSerial *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofSerial::flush",2,"bool"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofSerial::flush",3,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSerial,0))){ - SWIG_fail_ptr("Serial_flush",1,SWIGTYPE_p_ofSerial); } arg2 = (lua_toboolean(L, 2)!=0); arg3 = (lua_toboolean(L, 3)!=0); - (arg1)->flush(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Serial_flush__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofSerial *arg1 = (ofSerial *) 0 ; bool arg2 ; - SWIG_check_num_args("ofSerial::flush",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSerial::flush",1,"ofSerial *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofSerial::flush",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSerial,0))){ - SWIG_fail_ptr("Serial_flush",1,SWIGTYPE_p_ofSerial); } arg2 = (lua_toboolean(L, 2)!=0); (arg1)->flush(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Serial_flush__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofSerial *arg1 = (ofSerial *) 0 ; - SWIG_check_num_args("ofSerial::flush",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSerial::flush",1,"ofSerial *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSerial,0))){ - SWIG_fail_ptr("Serial_flush",1,SWIGTYPE_p_ofSerial); } (arg1)->flush(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Serial_flush(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 1) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofSerial, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Serial_flush__SWIG_2(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofSerial, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_Serial_flush__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofSerial, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } - if (_v) { return _wrap_Serial_flush__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Serial_flush'\n" " Possible C/C++ prototypes are:\n" - " ofSerial::flush(bool,bool)\n" " ofSerial::flush(bool)\n" " ofSerial::flush()\n"); lua_error(L);return 0; } -static int _wrap_Serial_drain(lua_State* L) { int SWIG_arg = 0; ofSerial *arg1 = (ofSerial *) 0 ; - SWIG_check_num_args("ofSerial::drain",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSerial::drain",1,"ofSerial *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSerial,0))){ - SWIG_fail_ptr("Serial_drain",1,SWIGTYPE_p_ofSerial); } (arg1)->drain(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static void swig_delete_Serial(void *obj) { -ofSerial *arg1 = (ofSerial *) obj; -delete arg1; -} -static int _proxy__wrap_new_Serial(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_Serial); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_Serial_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_Serial_methods[]= { - { "listDevices", _wrap_Serial_listDevices}, - { "getDeviceList", _wrap_Serial_getDeviceList}, - { "setup", _wrap_Serial_setup}, - { "isInitialized", _wrap_Serial_isInitialized}, - { "close", _wrap_Serial_close}, - { "available", _wrap_Serial_available}, - { "readBytes", _wrap_Serial_readBytes}, - { "readByte", _wrap_Serial_readByte}, - { "writeBytes", _wrap_Serial_writeBytes}, - { "writeByte", _wrap_Serial_writeByte}, - { "flush", _wrap_Serial_flush}, - { "drain", _wrap_Serial_drain}, - {0,0} -}; -static swig_lua_method swig_Serial_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_Serial_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_Serial_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_Serial_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_Serial_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_Serial_Sf_SwigStatic = { - "Serial", - swig_Serial_Sf_SwigStatic_methods, - swig_Serial_Sf_SwigStatic_attributes, - swig_Serial_Sf_SwigStatic_constants, - swig_Serial_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_Serial_bases[] = {0}; -static const char *swig_Serial_base_names[] = {0}; -static swig_lua_class _wrap_class_Serial = { "Serial", "Serial", &SWIGTYPE_p_ofSerial,_proxy__wrap_new_Serial, swig_delete_Serial, swig_Serial_methods, swig_Serial_attributes, &swig_Serial_Sf_SwigStatic, swig_Serial_meta, swig_Serial_bases, swig_Serial_base_names }; - -static int _wrap_random__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float result; SWIG_check_num_args("ofRandom",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofRandom",1,"float"); arg1 = (float)lua_tonumber(L, 1); result = (float)ofRandom(arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_random__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float result; - SWIG_check_num_args("ofRandom",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofRandom",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRandom",2,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); result = (float)ofRandom(arg1,arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_random(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_random__SWIG_0(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_random__SWIG_1(L);} } - } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'random'\n" " Possible C/C++ prototypes are:\n" - " ofRandom(float)\n" " ofRandom(float,float)\n"); lua_error(L);return 0; } -static int _wrap_randomf(lua_State* L) { int SWIG_arg = 0; float result; SWIG_check_num_args("ofRandomf",0,0) - result = (float)ofRandomf(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_randomuf(lua_State* L) { int SWIG_arg = 0; float result; SWIG_check_num_args("ofRandomuf",0,0) - result = (float)ofRandomuf(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_seedRandom__SWIG_0(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofSeedRandom",0,0) ofSeedRandom(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_seedRandom__SWIG_1(lua_State* L) { int SWIG_arg = 0; int arg1 ; SWIG_check_num_args("ofSeedRandom",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSeedRandom",1,"int"); arg1 = (int)lua_tonumber(L, 1); ofSeedRandom(arg1); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_seedRandom(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_seedRandom__SWIG_0(L);} if (argc == 1) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { - return _wrap_seedRandom__SWIG_1(L);} } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'seedRandom'\n" - " Possible C/C++ prototypes are:\n" " ofSeedRandom()\n" " ofSeedRandom(int)\n"); lua_error(L);return 0; } -static int _wrap_normalize(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float result; - SWIG_check_num_args("ofNormalize",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofNormalize",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofNormalize",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofNormalize",3,"float"); - arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - result = (float)ofNormalize(arg1,arg2,arg3); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_map__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; float arg5 ; - bool arg6 ; float result; SWIG_check_num_args("ofMap",6,6) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMap",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMap",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMap",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMap",4,"float"); if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMap",5,"float"); - if(!lua_isboolean(L,6)) SWIG_fail_arg("ofMap",6,"bool"); arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (lua_toboolean(L, 6)!=0); result = (float)ofMap(arg1,arg2,arg3,arg4,arg5,arg6); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_map__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; float arg5 ; - float result; SWIG_check_num_args("ofMap",5,5) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMap",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMap",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMap",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMap",4,"float"); if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMap",5,"float"); - arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); result = (float)ofMap(arg1,arg2,arg3,arg4,arg5); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_map(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); if (argc == 5) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_map__SWIG_1(L);} } } } } } if (argc == 6) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isboolean(L,argv[5]); } if (_v) { return _wrap_map__SWIG_0(L);} } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'map'\n" " Possible C/C++ prototypes are:\n" - " ofMap(float,float,float,float,float,bool)\n" " ofMap(float,float,float,float,float)\n"); lua_error(L);return 0; } -static int _wrap_clamp(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float result; - SWIG_check_num_args("ofClamp",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofClamp",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofClamp",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofClamp",3,"float"); - arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - result = (float)ofClamp(arg1,arg2,arg3); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_inRange(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; bool result; - SWIG_check_num_args("ofInRange",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofInRange",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofInRange",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofInRange",3,"float"); - arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - result = (bool)ofInRange(arg1,arg2,arg3); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_lerp(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float result; - SWIG_check_num_args("ofLerp",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofLerp",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofLerp",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofLerp",3,"float"); - arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - result = (float)ofLerp(arg1,arg2,arg3); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_dist__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - float result; SWIG_check_num_args("ofDist",4,4) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDist",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDist",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDist",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDist",4,"float"); arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); result = (float)ofDist(arg1,arg2,arg3,arg4); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_dist__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; float arg5 ; - float arg6 ; float result; SWIG_check_num_args("ofDist",6,6) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDist",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDist",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDist",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDist",4,"float"); if(!lua_isnumber(L,5)) SWIG_fail_arg("ofDist",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofDist",6,"float"); arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); result = (float)ofDist(arg1,arg2,arg3,arg4,arg5,arg6); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_dist(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); if (argc == 4) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_dist__SWIG_0(L);} } } } } if (argc == 6) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { - return _wrap_dist__SWIG_1(L);} } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'dist'\n" " Possible C/C++ prototypes are:\n" - " ofDist(float,float,float,float)\n" " ofDist(float,float,float,float,float,float)\n"); lua_error(L);return 0; } -static int _wrap_distSquared__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - float result; SWIG_check_num_args("ofDistSquared",4,4) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDistSquared",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDistSquared",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDistSquared",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDistSquared",4,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - result = (float)ofDistSquared(arg1,arg2,arg3,arg4); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_distSquared__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - float arg5 ; float arg6 ; float result; SWIG_check_num_args("ofDistSquared",6,6) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDistSquared",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDistSquared",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDistSquared",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDistSquared",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofDistSquared",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofDistSquared",6,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); - result = (float)ofDistSquared(arg1,arg2,arg3,arg4,arg5,arg6); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_distSquared(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); if (argc == 4) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { - return _wrap_distSquared__SWIG_0(L);} } } } } if (argc == 6) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { return _wrap_distSquared__SWIG_1(L);} } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'distSquared'\n" " Possible C/C++ prototypes are:\n" - " ofDistSquared(float,float,float,float)\n" " ofDistSquared(float,float,float,float,float,float)\n"); - lua_error(L);return 0; } -static int _wrap_radToDeg(lua_State* L) { int SWIG_arg = 0; float arg1 ; float result; SWIG_check_num_args("ofRadToDeg",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofRadToDeg",1,"float"); arg1 = (float)lua_tonumber(L, 1); - result = (float)ofRadToDeg(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_degToRad(lua_State* L) { int SWIG_arg = 0; float arg1 ; float result; SWIG_check_num_args("ofDegToRad",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDegToRad",1,"float"); arg1 = (float)lua_tonumber(L, 1); - result = (float)ofDegToRad(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_lerpDegrees(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float result; - SWIG_check_num_args("ofLerpDegrees",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofLerpDegrees",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofLerpDegrees",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofLerpDegrees",3,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); result = (float)ofLerpDegrees(arg1,arg2,arg3); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_lerpRadians(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float result; - SWIG_check_num_args("ofLerpRadians",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofLerpRadians",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofLerpRadians",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofLerpRadians",3,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); result = (float)ofLerpRadians(arg1,arg2,arg3); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_angleDifferenceDegrees(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float result; - SWIG_check_num_args("ofAngleDifferenceDegrees",2,2) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofAngleDifferenceDegrees",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofAngleDifferenceDegrees",2,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); result = (float)ofAngleDifferenceDegrees(arg1,arg2); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_angleDifferenceRadians(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float result; - SWIG_check_num_args("ofAngleDifferenceRadians",2,2) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofAngleDifferenceRadians",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofAngleDifferenceRadians",2,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); result = (float)ofAngleDifferenceRadians(arg1,arg2); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_wrap(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float result; - SWIG_check_num_args("ofWrap",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofWrap",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofWrap",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofWrap",3,"float"); - arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - result = (float)ofWrap(arg1,arg2,arg3); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_wrapRadians__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float result; - SWIG_check_num_args("ofWrapRadians",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofWrapRadians",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofWrapRadians",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofWrapRadians",3,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); result = (float)ofWrapRadians(arg1,arg2,arg3); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_wrapRadians__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float result; - SWIG_check_num_args("ofWrapRadians",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofWrapRadians",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofWrapRadians",2,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); result = (float)ofWrapRadians(arg1,arg2); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_wrapRadians__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; float result; - SWIG_check_num_args("ofWrapRadians",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofWrapRadians",1,"float"); - arg1 = (float)lua_tonumber(L, 1); result = (float)ofWrapRadians(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_wrapRadians(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_wrapRadians__SWIG_2(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_wrapRadians__SWIG_1(L);} } } if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_wrapRadians__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'wrapRadians'\n" " Possible C/C++ prototypes are:\n" - " ofWrapRadians(float,float,float)\n" " ofWrapRadians(float,float)\n" " ofWrapRadians(float)\n"); - lua_error(L);return 0; } -static int _wrap_wrapDegrees__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float result; - SWIG_check_num_args("ofWrapDegrees",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofWrapDegrees",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofWrapDegrees",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofWrapDegrees",3,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); result = (float)ofWrapDegrees(arg1,arg2,arg3); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_wrapDegrees__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float result; - SWIG_check_num_args("ofWrapDegrees",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofWrapDegrees",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofWrapDegrees",2,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); result = (float)ofWrapDegrees(arg1,arg2); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_wrapDegrees__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; float result; - SWIG_check_num_args("ofWrapDegrees",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofWrapDegrees",1,"float"); - arg1 = (float)lua_tonumber(L, 1); result = (float)ofWrapDegrees(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_wrapDegrees(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_wrapDegrees__SWIG_2(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_wrapDegrees__SWIG_1(L);} } } if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_wrapDegrees__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'wrapDegrees'\n" " Possible C/C++ prototypes are:\n" - " ofWrapDegrees(float,float,float)\n" " ofWrapDegrees(float,float)\n" " ofWrapDegrees(float)\n"); - lua_error(L);return 0; } -static int _wrap_noise__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float result; SWIG_check_num_args("ofNoise",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofNoise",1,"float"); arg1 = (float)lua_tonumber(L, 1); result = (float)ofNoise(arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_noise__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float result; - SWIG_check_num_args("ofNoise",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofNoise",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofNoise",2,"float"); arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); - result = (float)ofNoise(arg1,arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_noise__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = 0 ; float result; - SWIG_check_num_args("ofNoise",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofNoise",1,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("noise",1,SWIGTYPE_p_ofVec2f); } - result = (float)ofNoise((ofVec2f const &)*arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_noise__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float result; - SWIG_check_num_args("ofNoise",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofNoise",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofNoise",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofNoise",3,"float"); - arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - result = (float)ofNoise(arg1,arg2,arg3); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_noise__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = 0 ; float result; - SWIG_check_num_args("ofNoise",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofNoise",1,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("noise",1,SWIGTYPE_p_ofVec3f); } - result = (float)ofNoise((ofVec3f const &)*arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_noise__SWIG_5(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - float result; SWIG_check_num_args("ofNoise",4,4) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofNoise",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofNoise",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofNoise",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofNoise",4,"float"); arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); result = (float)ofNoise(arg1,arg2,arg3,arg4); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_noise__SWIG_6(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = 0 ; float result; - SWIG_check_num_args("ofNoise",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofNoise",1,"ofVec4f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("noise",1,SWIGTYPE_p_ofVec4f); } - result = (float)ofNoise((ofVec4f const &)*arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_noise(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_noise__SWIG_2(L);} } if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_noise__SWIG_4(L);} } if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_noise__SWIG_6(L);} } if (argc == 1) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { return _wrap_noise__SWIG_0(L);} } if (argc == 2) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_noise__SWIG_1(L);} } } if (argc == 3) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_noise__SWIG_3(L);} } } } if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_noise__SWIG_5(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'noise'\n" " Possible C/C++ prototypes are:\n" - " ofNoise(float)\n" " ofNoise(float,float)\n" " ofNoise(ofVec2f const &)\n" " ofNoise(float,float,float)\n" - " ofNoise(ofVec3f const &)\n" " ofNoise(float,float,float,float)\n" " ofNoise(ofVec4f const &)\n"); - lua_error(L);return 0; } -static int _wrap_signedNoise__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float result; - SWIG_check_num_args("ofSignedNoise",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSignedNoise",1,"float"); - arg1 = (float)lua_tonumber(L, 1); result = (float)ofSignedNoise(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_signedNoise__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float result; - SWIG_check_num_args("ofSignedNoise",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSignedNoise",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSignedNoise",2,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); result = (float)ofSignedNoise(arg1,arg2); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_signedNoise__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = 0 ; float result; - SWIG_check_num_args("ofSignedNoise",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofSignedNoise",1,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("signedNoise",1,SWIGTYPE_p_ofVec2f); } - result = (float)ofSignedNoise((ofVec2f const &)*arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_signedNoise__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float result; - SWIG_check_num_args("ofSignedNoise",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSignedNoise",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSignedNoise",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofSignedNoise",3,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); result = (float)ofSignedNoise(arg1,arg2,arg3); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_signedNoise__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = 0 ; float result; - SWIG_check_num_args("ofSignedNoise",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofSignedNoise",1,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("signedNoise",1,SWIGTYPE_p_ofVec3f); } - result = (float)ofSignedNoise((ofVec3f const &)*arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_signedNoise__SWIG_5(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - float result; SWIG_check_num_args("ofSignedNoise",4,4) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSignedNoise",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSignedNoise",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofSignedNoise",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofSignedNoise",4,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - result = (float)ofSignedNoise(arg1,arg2,arg3,arg4); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_signedNoise__SWIG_6(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = 0 ; float result; - SWIG_check_num_args("ofSignedNoise",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofSignedNoise",1,"ofVec4f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("signedNoise",1,SWIGTYPE_p_ofVec4f); } - result = (float)ofSignedNoise((ofVec4f const &)*arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_signedNoise(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 1) { int _v; - { void *ptr; if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_signedNoise__SWIG_2(L);} } if (argc == 1) { int _v; { - void *ptr; if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_signedNoise__SWIG_4(L);} } if (argc == 1) { int _v; { - void *ptr; if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_signedNoise__SWIG_6(L);} } if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_signedNoise__SWIG_0(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_signedNoise__SWIG_1(L);} } } if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_signedNoise__SWIG_3(L);} } } } if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { - { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_signedNoise__SWIG_5(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'signedNoise'\n" " Possible C/C++ prototypes are:\n" - " ofSignedNoise(float)\n" " ofSignedNoise(float,float)\n" " ofSignedNoise(ofVec2f const &)\n" - " ofSignedNoise(float,float,float)\n" " ofSignedNoise(ofVec3f const &)\n" " ofSignedNoise(float,float,float,float)\n" - " ofSignedNoise(ofVec4f const &)\n"); lua_error(L);return 0; } -static int _wrap_insidePoly__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; - std::vector< ofPoint > *arg3 = 0 ; bool result; SWIG_check_num_args("ofInsidePoly",3,3) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofInsidePoly",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofInsidePoly",2,"float"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofInsidePoly",3,"std::vector< ofPoint > const &"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_std__vectorT_ofVec3f_t,0))){ - SWIG_fail_ptr("insidePoly",3,SWIGTYPE_p_std__vectorT_ofVec3f_t); } - result = (bool)ofInsidePoly(arg1,arg2,(std::vector< ofVec3f > const &)*arg3); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_insidePoly__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPoint *arg1 = 0 ; std::vector< ofPoint > *arg2 = 0 ; - bool result; SWIG_check_num_args("ofInsidePoly",2,2) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofInsidePoly",1,"ofPoint const &"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofInsidePoly",2,"std::vector< ofPoint > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("insidePoly",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__vectorT_ofVec3f_t,0))){ - SWIG_fail_ptr("insidePoly",2,SWIGTYPE_p_std__vectorT_ofVec3f_t); } - result = (bool)ofInsidePoly((ofVec3f const &)*arg1,(std::vector< ofVec3f > const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_insidePoly(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_std__vectorT_ofVec3f_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_insidePoly__SWIG_1(L);} } } if (argc == 3) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_std__vectorT_ofVec3f_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_insidePoly__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'insidePoly'\n" " Possible C/C++ prototypes are:\n" - " ofInsidePoly(float,float,std::vector< ofPoint > const &)\n" - " ofInsidePoly(ofPoint const &,std::vector< ofPoint > const &)\n"); lua_error(L);return 0; } -static int _wrap_lineSegmentIntersection(lua_State* L) { int SWIG_arg = 0; ofPoint *arg1 = 0 ; ofPoint *arg2 = 0 ; - ofPoint *arg3 = 0 ; ofPoint *arg4 = 0 ; ofPoint *arg5 = 0 ; bool result; SWIG_check_num_args("ofLineSegmentIntersection",5,5) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofLineSegmentIntersection",1,"ofPoint const &"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofLineSegmentIntersection",2,"ofPoint const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofLineSegmentIntersection",3,"ofPoint const &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofLineSegmentIntersection",4,"ofPoint const &"); - if(!lua_isuserdata(L,5)) SWIG_fail_arg("ofLineSegmentIntersection",5,"ofPoint &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("lineSegmentIntersection",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("lineSegmentIntersection",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("lineSegmentIntersection",3,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("lineSegmentIntersection",4,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("lineSegmentIntersection",5,SWIGTYPE_p_ofVec3f); } - result = (bool)ofLineSegmentIntersection((ofVec3f const &)*arg1,(ofVec3f const &)*arg2,(ofVec3f const &)*arg3,(ofVec3f const &)*arg4,*arg5); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_bezierPoint(lua_State* L) { int SWIG_arg = 0; ofPoint *arg1 = 0 ; ofPoint *arg2 = 0 ; ofPoint *arg3 = 0 ; - ofPoint *arg4 = 0 ; float arg5 ; ofPoint result; SWIG_check_num_args("ofBezierPoint",5,5) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofBezierPoint",1,"ofPoint const &"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofBezierPoint",2,"ofPoint const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofBezierPoint",3,"ofPoint const &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofBezierPoint",4,"ofPoint const &"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofBezierPoint",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("bezierPoint",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("bezierPoint",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("bezierPoint",3,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("bezierPoint",4,SWIGTYPE_p_ofVec3f); } - arg5 = (float)lua_tonumber(L, 5); - result = ofBezierPoint((ofVec3f const &)*arg1,(ofVec3f const &)*arg2,(ofVec3f const &)*arg3,(ofVec3f const &)*arg4,arg5); { - ofPoint * resultptr = new ofPoint((const ofPoint &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_curvePoint(lua_State* L) { int SWIG_arg = 0; ofPoint *arg1 = 0 ; ofPoint *arg2 = 0 ; ofPoint *arg3 = 0 ; - ofPoint *arg4 = 0 ; float arg5 ; ofPoint result; SWIG_check_num_args("ofCurvePoint",5,5) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofCurvePoint",1,"ofPoint const &"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofCurvePoint",2,"ofPoint const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofCurvePoint",3,"ofPoint const &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofCurvePoint",4,"ofPoint const &"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofCurvePoint",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("curvePoint",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("curvePoint",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("curvePoint",3,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("curvePoint",4,SWIGTYPE_p_ofVec3f); } - arg5 = (float)lua_tonumber(L, 5); - result = ofCurvePoint((ofVec3f const &)*arg1,(ofVec3f const &)*arg2,(ofVec3f const &)*arg3,(ofVec3f const &)*arg4,arg5); { - ofPoint * resultptr = new ofPoint((const ofPoint &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_bezierTangent(lua_State* L) { int SWIG_arg = 0; ofPoint *arg1 = 0 ; ofPoint *arg2 = 0 ; ofPoint *arg3 = 0 ; - ofPoint *arg4 = 0 ; float arg5 ; ofPoint result; SWIG_check_num_args("ofBezierTangent",5,5) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofBezierTangent",1,"ofPoint const &"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofBezierTangent",2,"ofPoint const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofBezierTangent",3,"ofPoint const &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofBezierTangent",4,"ofPoint const &"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofBezierTangent",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("bezierTangent",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("bezierTangent",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("bezierTangent",3,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("bezierTangent",4,SWIGTYPE_p_ofVec3f); } arg5 = (float)lua_tonumber(L, 5); - result = ofBezierTangent((ofVec3f const &)*arg1,(ofVec3f const &)*arg2,(ofVec3f const &)*arg3,(ofVec3f const &)*arg4,arg5); { - ofPoint * resultptr = new ofPoint((const ofPoint &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_curveTangent(lua_State* L) { int SWIG_arg = 0; ofPoint *arg1 = 0 ; ofPoint *arg2 = 0 ; ofPoint *arg3 = 0 ; - ofPoint *arg4 = 0 ; float arg5 ; ofPoint result; SWIG_check_num_args("ofCurveTangent",5,5) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofCurveTangent",1,"ofPoint const &"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofCurveTangent",2,"ofPoint const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofCurveTangent",3,"ofPoint const &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofCurveTangent",4,"ofPoint const &"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofCurveTangent",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("curveTangent",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("curveTangent",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("curveTangent",3,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("curveTangent",4,SWIGTYPE_p_ofVec3f); } arg5 = (float)lua_tonumber(L, 5); - result = ofCurveTangent((ofVec3f const &)*arg1,(ofVec3f const &)*arg2,(ofVec3f const &)*arg3,(ofVec3f const &)*arg4,arg5); { - ofPoint * resultptr = new ofPoint((const ofPoint &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_nextPow2(lua_State* L) { int SWIG_arg = 0; int arg1 ; int result; SWIG_check_num_args("ofNextPow2",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofNextPow2",1,"int"); arg1 = (int)lua_tonumber(L, 1); result = (int)ofNextPow2(arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_sign(lua_State* L) { int SWIG_arg = 0; float arg1 ; int result; SWIG_check_num_args("ofSign",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSign",1,"float"); arg1 = (float)lua_tonumber(L, 1); result = (int)ofSign(arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix3x3_a_set(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; float arg2 ; - SWIG_check_num_args("ofMatrix3x3::a",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::a",1,"ofMatrix3x3 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix3x3::a",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3_a_set",1,SWIGTYPE_p_ofMatrix3x3); } arg2 = (float)lua_tonumber(L, 2); if (arg1) (arg1)->a = arg2; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix3x3_a_get(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; float result; - SWIG_check_num_args("ofMatrix3x3::a",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::a",1,"ofMatrix3x3 *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3_a_get",1,SWIGTYPE_p_ofMatrix3x3); } result = (float) ((arg1)->a); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix3x3_b_set(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; float arg2 ; - SWIG_check_num_args("ofMatrix3x3::b",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::b",1,"ofMatrix3x3 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix3x3::b",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3_b_set",1,SWIGTYPE_p_ofMatrix3x3); } arg2 = (float)lua_tonumber(L, 2); if (arg1) (arg1)->b = arg2; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix3x3_b_get(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; float result; - SWIG_check_num_args("ofMatrix3x3::b",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::b",1,"ofMatrix3x3 *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3_b_get",1,SWIGTYPE_p_ofMatrix3x3); } result = (float) ((arg1)->b); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix3x3_c_set(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; float arg2 ; - SWIG_check_num_args("ofMatrix3x3::c",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::c",1,"ofMatrix3x3 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix3x3::c",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3_c_set",1,SWIGTYPE_p_ofMatrix3x3); } arg2 = (float)lua_tonumber(L, 2); if (arg1) (arg1)->c = arg2; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix3x3_c_get(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; float result; - SWIG_check_num_args("ofMatrix3x3::c",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::c",1,"ofMatrix3x3 *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3_c_get",1,SWIGTYPE_p_ofMatrix3x3); } result = (float) ((arg1)->c); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix3x3_d_set(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; float arg2 ; - SWIG_check_num_args("ofMatrix3x3::d",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::d",1,"ofMatrix3x3 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix3x3::d",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3_d_set",1,SWIGTYPE_p_ofMatrix3x3); } arg2 = (float)lua_tonumber(L, 2); if (arg1) (arg1)->d = arg2; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix3x3_d_get(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; float result; - SWIG_check_num_args("ofMatrix3x3::d",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::d",1,"ofMatrix3x3 *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3_d_get",1,SWIGTYPE_p_ofMatrix3x3); } result = (float) ((arg1)->d); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix3x3_e_set(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; float arg2 ; - SWIG_check_num_args("ofMatrix3x3::e",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::e",1,"ofMatrix3x3 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix3x3::e",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3_e_set",1,SWIGTYPE_p_ofMatrix3x3); } arg2 = (float)lua_tonumber(L, 2); if (arg1) (arg1)->e = arg2; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix3x3_e_get(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; float result; - SWIG_check_num_args("ofMatrix3x3::e",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::e",1,"ofMatrix3x3 *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3_e_get",1,SWIGTYPE_p_ofMatrix3x3); } result = (float) ((arg1)->e); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix3x3_f_set(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; float arg2 ; - SWIG_check_num_args("ofMatrix3x3::f",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::f",1,"ofMatrix3x3 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix3x3::f",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3_f_set",1,SWIGTYPE_p_ofMatrix3x3); } arg2 = (float)lua_tonumber(L, 2); if (arg1) (arg1)->f = arg2; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix3x3_f_get(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; float result; - SWIG_check_num_args("ofMatrix3x3::f",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::f",1,"ofMatrix3x3 *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3_f_get",1,SWIGTYPE_p_ofMatrix3x3); } result = (float) ((arg1)->f); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix3x3_g_set(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; float arg2 ; - SWIG_check_num_args("ofMatrix3x3::g",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::g",1,"ofMatrix3x3 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix3x3::g",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3_g_set",1,SWIGTYPE_p_ofMatrix3x3); } arg2 = (float)lua_tonumber(L, 2); if (arg1) (arg1)->g = arg2; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix3x3_g_get(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; float result; - SWIG_check_num_args("ofMatrix3x3::g",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::g",1,"ofMatrix3x3 *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3_g_get",1,SWIGTYPE_p_ofMatrix3x3); } result = (float) ((arg1)->g); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix3x3_h_set(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; float arg2 ; - SWIG_check_num_args("ofMatrix3x3::h",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::h",1,"ofMatrix3x3 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix3x3::h",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3_h_set",1,SWIGTYPE_p_ofMatrix3x3); } arg2 = (float)lua_tonumber(L, 2); if (arg1) (arg1)->h = arg2; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix3x3_h_get(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; float result; - SWIG_check_num_args("ofMatrix3x3::h",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::h",1,"ofMatrix3x3 *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3_h_get",1,SWIGTYPE_p_ofMatrix3x3); } result = (float) ((arg1)->h); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix3x3_i_set(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; float arg2 ; - SWIG_check_num_args("ofMatrix3x3::i",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::i",1,"ofMatrix3x3 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix3x3::i",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3_i_set",1,SWIGTYPE_p_ofMatrix3x3); } arg2 = (float)lua_tonumber(L, 2); if (arg1) (arg1)->i = arg2; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix3x3_i_get(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; float result; - SWIG_check_num_args("ofMatrix3x3::i",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::i",1,"ofMatrix3x3 *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3_i_get",1,SWIGTYPE_p_ofMatrix3x3); } result = (float) ((arg1)->i); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_new_Matrix3x3__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - float arg5 ; float arg6 ; float arg7 ; float arg8 ; float arg9 ; ofMatrix3x3 *result = 0 ; - SWIG_check_num_args("ofMatrix3x3::ofMatrix3x3",9,9) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",8,"float"); - if(!lua_isnumber(L,9)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",9,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); - arg8 = (float)lua_tonumber(L, 8); arg9 = (float)lua_tonumber(L, 9); - result = (ofMatrix3x3 *)new ofMatrix3x3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMatrix3x3,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Matrix3x3__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - float arg5 ; float arg6 ; float arg7 ; float arg8 ; ofMatrix3x3 *result = 0 ; - SWIG_check_num_args("ofMatrix3x3::ofMatrix3x3",8,8) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",8,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); - arg8 = (float)lua_tonumber(L, 8); result = (ofMatrix3x3 *)new ofMatrix3x3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMatrix3x3,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Matrix3x3__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - float arg5 ; float arg6 ; float arg7 ; ofMatrix3x3 *result = 0 ; SWIG_check_num_args("ofMatrix3x3::ofMatrix3x3",7,7) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",7,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); - result = (ofMatrix3x3 *)new ofMatrix3x3(arg1,arg2,arg3,arg4,arg5,arg6,arg7); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMatrix3x3,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Matrix3x3__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - float arg5 ; float arg6 ; ofMatrix3x3 *result = 0 ; SWIG_check_num_args("ofMatrix3x3::ofMatrix3x3",6,6) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",6,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); - result = (ofMatrix3x3 *)new ofMatrix3x3(arg1,arg2,arg3,arg4,arg5,arg6); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMatrix3x3,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Matrix3x3__SWIG_4(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - float arg5 ; ofMatrix3x3 *result = 0 ; SWIG_check_num_args("ofMatrix3x3::ofMatrix3x3",5,5) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",5,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); result = (ofMatrix3x3 *)new ofMatrix3x3(arg1,arg2,arg3,arg4,arg5); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMatrix3x3,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Matrix3x3__SWIG_5(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - ofMatrix3x3 *result = 0 ; SWIG_check_num_args("ofMatrix3x3::ofMatrix3x3",4,4) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",4,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - result = (ofMatrix3x3 *)new ofMatrix3x3(arg1,arg2,arg3,arg4); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMatrix3x3,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Matrix3x3__SWIG_6(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; - ofMatrix3x3 *result = 0 ; SWIG_check_num_args("ofMatrix3x3::ofMatrix3x3",3,3) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",3,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); result = (ofMatrix3x3 *)new ofMatrix3x3(arg1,arg2,arg3); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMatrix3x3,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Matrix3x3__SWIG_7(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; ofMatrix3x3 *result = 0 ; - SWIG_check_num_args("ofMatrix3x3::ofMatrix3x3",2,2) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",2,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); result = (ofMatrix3x3 *)new ofMatrix3x3(arg1,arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMatrix3x3,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Matrix3x3__SWIG_8(lua_State* L) { int SWIG_arg = 0; float arg1 ; ofMatrix3x3 *result = 0 ; - SWIG_check_num_args("ofMatrix3x3::ofMatrix3x3",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",1,"float"); arg1 = (float)lua_tonumber(L, 1); - result = (ofMatrix3x3 *)new ofMatrix3x3(arg1); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMatrix3x3,1); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_new_Matrix3x3__SWIG_9(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *result = 0 ; - SWIG_check_num_args("ofMatrix3x3::ofMatrix3x3",0,0) result = (ofMatrix3x3 *)new ofMatrix3x3(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMatrix3x3,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Matrix3x3(lua_State* L) { int argc; int argv[10]={ 1,2,3,4,5,6,7,8,9,10} ; argc = lua_gettop(L); - if (argc == 0) { return _wrap_new_Matrix3x3__SWIG_9(L);} if (argc == 1) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { return _wrap_new_Matrix3x3__SWIG_8(L);} } if (argc == 2) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { - { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_new_Matrix3x3__SWIG_7(L);} } } if (argc == 3) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_new_Matrix3x3__SWIG_6(L);} } } } if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_new_Matrix3x3__SWIG_5(L);} } } } } if (argc == 5) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_new_Matrix3x3__SWIG_4(L);} } } } } } - if (argc == 6) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { - return _wrap_new_Matrix3x3__SWIG_3(L);} } } } } } } if (argc == 7) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { - return _wrap_new_Matrix3x3__SWIG_2(L);} } } } } } } } if (argc == 8) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { return _wrap_new_Matrix3x3__SWIG_1(L);} } } } } } } } } - if (argc == 9) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { { - _v = lua_isnumber(L,argv[6]); } if (_v) { { _v = lua_isnumber(L,argv[7]); } if (_v) { { - _v = lua_isnumber(L,argv[8]); } if (_v) { return _wrap_new_Matrix3x3__SWIG_0(L);} } } } } } } } } - } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_Matrix3x3'\n" - " Possible C/C++ prototypes are:\n" " ofMatrix3x3::ofMatrix3x3(float,float,float,float,float,float,float,float,float)\n" - " ofMatrix3x3::ofMatrix3x3(float,float,float,float,float,float,float,float)\n" - " ofMatrix3x3::ofMatrix3x3(float,float,float,float,float,float,float)\n" - " ofMatrix3x3::ofMatrix3x3(float,float,float,float,float,float)\n" - " ofMatrix3x3::ofMatrix3x3(float,float,float,float,float)\n" " ofMatrix3x3::ofMatrix3x3(float,float,float,float)\n" - " ofMatrix3x3::ofMatrix3x3(float,float,float)\n" " ofMatrix3x3::ofMatrix3x3(float,float)\n" - " ofMatrix3x3::ofMatrix3x3(float)\n" " ofMatrix3x3::ofMatrix3x3()\n"); lua_error(L);return 0; } -static int _wrap_Matrix3x3_set(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; float arg2 ; - float arg3 ; float arg4 ; float arg5 ; float arg6 ; float arg7 ; float arg8 ; float arg9 ; float arg10 ; - SWIG_check_num_args("ofMatrix3x3::set",10,10) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::set",1,"ofMatrix3x3 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix3x3::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix3x3::set",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix3x3::set",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMatrix3x3::set",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofMatrix3x3::set",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofMatrix3x3::set",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofMatrix3x3::set",8,"float"); - if(!lua_isnumber(L,9)) SWIG_fail_arg("ofMatrix3x3::set",9,"float"); - if(!lua_isnumber(L,10)) SWIG_fail_arg("ofMatrix3x3::set",10,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3_set",1,SWIGTYPE_p_ofMatrix3x3); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (float)lua_tonumber(L, 8); - arg9 = (float)lua_tonumber(L, 9); arg10 = (float)lua_tonumber(L, 10); - (arg1)->set(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Matrix3x3_transpose__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; - SWIG_check_num_args("ofMatrix3x3::transpose",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::transpose",1,"ofMatrix3x3 *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3_transpose",1,SWIGTYPE_p_ofMatrix3x3); } (arg1)->transpose(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix3x3_transpose__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; - ofMatrix3x3 *arg2 = 0 ; ofMatrix3x3 result; SWIG_check_num_args("ofMatrix3x3::transpose",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::transpose",1,"ofMatrix3x3 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix3x3::transpose",2,"ofMatrix3x3 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3_transpose",1,SWIGTYPE_p_ofMatrix3x3); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3_transpose",2,SWIGTYPE_p_ofMatrix3x3); } result = (arg1)->transpose((ofMatrix3x3 const &)*arg2); { - ofMatrix3x3 * resultptr = new ofMatrix3x3((const ofMatrix3x3 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix3x3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix3x3_transpose(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix3x3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix3x3_transpose__SWIG_0(L);} } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix3x3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofMatrix3x3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix3x3_transpose__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix3x3_transpose'\n" - " Possible C/C++ prototypes are:\n" " ofMatrix3x3::transpose()\n" " ofMatrix3x3::transpose(ofMatrix3x3 const &)\n"); - lua_error(L);return 0; } -static int _wrap_Matrix3x3_determinant__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; - float result; SWIG_check_num_args("ofMatrix3x3::determinant",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::determinant",1,"ofMatrix3x3 const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3_determinant",1,SWIGTYPE_p_ofMatrix3x3); } - result = (float)((ofMatrix3x3 const *)arg1)->determinant(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix3x3_determinant__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; - ofMatrix3x3 *arg2 = 0 ; float result; SWIG_check_num_args("ofMatrix3x3::determinant",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::determinant",1,"ofMatrix3x3 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix3x3::determinant",2,"ofMatrix3x3 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3_determinant",1,SWIGTYPE_p_ofMatrix3x3); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3_determinant",2,SWIGTYPE_p_ofMatrix3x3); } - result = (float)(arg1)->determinant((ofMatrix3x3 const &)*arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix3x3_determinant(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix3x3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix3x3_determinant__SWIG_0(L);} } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix3x3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofMatrix3x3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix3x3_determinant__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix3x3_determinant'\n" - " Possible C/C++ prototypes are:\n" " ofMatrix3x3::determinant() const\n" - " ofMatrix3x3::determinant(ofMatrix3x3 const &)\n"); lua_error(L);return 0; } -static int _wrap_Matrix3x3_inverse(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; - ofMatrix3x3 *arg2 = 0 ; ofMatrix3x3 result; SWIG_check_num_args("ofMatrix3x3::inverse",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::inverse",1,"ofMatrix3x3 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix3x3::inverse",2,"ofMatrix3x3 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3_inverse",1,SWIGTYPE_p_ofMatrix3x3); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3_inverse",2,SWIGTYPE_p_ofMatrix3x3); } result = (arg1)->inverse((ofMatrix3x3 const &)*arg2); { - ofMatrix3x3 * resultptr = new ofMatrix3x3((const ofMatrix3x3 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix3x3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix3x3_invert(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; - SWIG_check_num_args("ofMatrix3x3::invert",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::invert",1,"ofMatrix3x3 *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3_invert",1,SWIGTYPE_p_ofMatrix3x3); } (arg1)->invert(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix3x3_entrywiseTimes(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; - ofMatrix3x3 *arg2 = 0 ; ofMatrix3x3 result; SWIG_check_num_args("ofMatrix3x3::entrywiseTimes",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::entrywiseTimes",1,"ofMatrix3x3 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix3x3::entrywiseTimes",2,"ofMatrix3x3 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3_entrywiseTimes",1,SWIGTYPE_p_ofMatrix3x3); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3_entrywiseTimes",2,SWIGTYPE_p_ofMatrix3x3); } - result = (arg1)->entrywiseTimes((ofMatrix3x3 const &)*arg2); { - ofMatrix3x3 * resultptr = new ofMatrix3x3((const ofMatrix3x3 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix3x3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix3x3___add(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; - ofMatrix3x3 *arg2 = 0 ; ofMatrix3x3 result; SWIG_check_num_args("ofMatrix3x3::operator +",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::operator +",1,"ofMatrix3x3 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix3x3::operator +",2,"ofMatrix3x3 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3___add",1,SWIGTYPE_p_ofMatrix3x3); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3___add",2,SWIGTYPE_p_ofMatrix3x3); } result = (arg1)->operator +((ofMatrix3x3 const &)*arg2); { - ofMatrix3x3 * resultptr = new ofMatrix3x3((const ofMatrix3x3 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix3x3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix3x3___sub(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; - ofMatrix3x3 *arg2 = 0 ; ofMatrix3x3 result; SWIG_check_num_args("ofMatrix3x3::operator -",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::operator -",1,"ofMatrix3x3 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix3x3::operator -",2,"ofMatrix3x3 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3___sub",1,SWIGTYPE_p_ofMatrix3x3); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3___sub",2,SWIGTYPE_p_ofMatrix3x3); } result = (arg1)->operator -((ofMatrix3x3 const &)*arg2); { - ofMatrix3x3 * resultptr = new ofMatrix3x3((const ofMatrix3x3 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix3x3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix3x3___mul__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; float arg2 ; - ofMatrix3x3 result; SWIG_check_num_args("ofMatrix3x3::operator *",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::operator *",1,"ofMatrix3x3 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix3x3::operator *",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3___mul",1,SWIGTYPE_p_ofMatrix3x3); } arg2 = (float)lua_tonumber(L, 2); - result = (arg1)->operator *(arg2); { ofMatrix3x3 * resultptr = new ofMatrix3x3((const ofMatrix3x3 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix3x3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix3x3___mul__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; - ofMatrix3x3 *arg2 = 0 ; ofMatrix3x3 result; SWIG_check_num_args("ofMatrix3x3::operator *",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::operator *",1,"ofMatrix3x3 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix3x3::operator *",2,"ofMatrix3x3 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3___mul",1,SWIGTYPE_p_ofMatrix3x3); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3___mul",2,SWIGTYPE_p_ofMatrix3x3); } result = (arg1)->operator *((ofMatrix3x3 const &)*arg2); { - ofMatrix3x3 * resultptr = new ofMatrix3x3((const ofMatrix3x3 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix3x3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix3x3___mul(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix3x3, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofMatrix3x3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix3x3___mul__SWIG_1(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix3x3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Matrix3x3___mul__SWIG_0(L);} } - } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix3x3___mul'\n" - " Possible C/C++ prototypes are:\n" " ofMatrix3x3::operator *(float)\n" - " ofMatrix3x3::operator *(ofMatrix3x3 const &)\n"); lua_error(L);return 0; } -static int _wrap_Matrix3x3___div(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; float arg2 ; - ofMatrix3x3 result; SWIG_check_num_args("ofMatrix3x3::operator /",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::operator /",1,"ofMatrix3x3 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix3x3::operator /",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3___div",1,SWIGTYPE_p_ofMatrix3x3); } arg2 = (float)lua_tonumber(L, 2); - result = (arg1)->operator /(arg2); { ofMatrix3x3 * resultptr = new ofMatrix3x3((const ofMatrix3x3 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix3x3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix3x3___tostring(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; - char *result = 0 ; SWIG_check_num_args("ofMatrix3x3::__str__",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::__str__",1,"ofMatrix3x3 *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3___tostring",1,SWIGTYPE_p_ofMatrix3x3); } result = (char *)ofMatrix3x3___str__(arg1); - lua_pushstring(L,(const char *)result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_Matrix3x3(void *obj) { -ofMatrix3x3 *arg1 = (ofMatrix3x3 *) obj; -delete arg1; -} -static int _proxy__wrap_new_Matrix3x3(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_Matrix3x3); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_Matrix3x3_attributes[] = { - { "a", _wrap_Matrix3x3_a_get, _wrap_Matrix3x3_a_set }, - { "b", _wrap_Matrix3x3_b_get, _wrap_Matrix3x3_b_set }, - { "c", _wrap_Matrix3x3_c_get, _wrap_Matrix3x3_c_set }, - { "d", _wrap_Matrix3x3_d_get, _wrap_Matrix3x3_d_set }, - { "e", _wrap_Matrix3x3_e_get, _wrap_Matrix3x3_e_set }, - { "f", _wrap_Matrix3x3_f_get, _wrap_Matrix3x3_f_set }, - { "g", _wrap_Matrix3x3_g_get, _wrap_Matrix3x3_g_set }, - { "h", _wrap_Matrix3x3_h_get, _wrap_Matrix3x3_h_set }, - { "i", _wrap_Matrix3x3_i_get, _wrap_Matrix3x3_i_set }, - {0,0,0} -}; -static swig_lua_method swig_Matrix3x3_methods[]= { - { "set", _wrap_Matrix3x3_set}, - { "transpose", _wrap_Matrix3x3_transpose}, - { "determinant", _wrap_Matrix3x3_determinant}, - { "inverse", _wrap_Matrix3x3_inverse}, - { "invert", _wrap_Matrix3x3_invert}, - { "entrywiseTimes", _wrap_Matrix3x3_entrywiseTimes}, - { "__add", _wrap_Matrix3x3___add}, - { "__sub", _wrap_Matrix3x3___sub}, - { "__mul", _wrap_Matrix3x3___mul}, - { "__div", _wrap_Matrix3x3___div}, - { "__tostring", _wrap_Matrix3x3___tostring}, - {0,0} -}; -static swig_lua_method swig_Matrix3x3_meta[] = { - { "__add", _wrap_Matrix3x3___add}, - { "__sub", _wrap_Matrix3x3___sub}, - { "__mul", _wrap_Matrix3x3___mul}, - { "__div", _wrap_Matrix3x3___div}, - { "__tostring", _wrap_Matrix3x3___tostring}, - {0,0} -}; - -static swig_lua_attribute swig_Matrix3x3_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_Matrix3x3_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_Matrix3x3_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_Matrix3x3_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_Matrix3x3_Sf_SwigStatic = { - "Matrix3x3", - swig_Matrix3x3_Sf_SwigStatic_methods, - swig_Matrix3x3_Sf_SwigStatic_attributes, - swig_Matrix3x3_Sf_SwigStatic_constants, - swig_Matrix3x3_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_Matrix3x3_bases[] = {0}; -static const char *swig_Matrix3x3_base_names[] = {0}; -static swig_lua_class _wrap_class_Matrix3x3 = { "Matrix3x3", "Matrix3x3", &SWIGTYPE_p_ofMatrix3x3,_proxy__wrap_new_Matrix3x3, swig_delete_Matrix3x3, swig_Matrix3x3_methods, swig_Matrix3x3_attributes, &swig_Matrix3x3_Sf_SwigStatic, swig_Matrix3x3_meta, swig_Matrix3x3_bases, swig_Matrix3x3_base_names }; - -static int _wrap_Matrix4x4__mat_set(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; ofVec4f *arg2 ; - SWIG_check_num_args("ofMatrix4x4::_mat",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::_mat",1,"ofMatrix4x4 *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofMatrix4x4::_mat",2,"ofVec4f [4]"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4__mat_set",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec4f,0))){ - SWIG_fail_ptr("Matrix4x4__mat_set",2,SWIGTYPE_p_ofVec4f); } { size_t ii; ofVec4f *b = (ofVec4f *) arg1->_mat; - for (ii = 0; ii < (size_t)4; ii++) b[ii] = *((ofVec4f *) arg2 + ii); } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4__mat_get(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofVec4f *result = 0 ; SWIG_check_num_args("ofMatrix4x4::_mat",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::_mat",1,"ofMatrix4x4 *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4__mat_get",1,SWIGTYPE_p_ofMatrix4x4); } result = (ofVec4f *)(ofVec4f *) ((arg1)->_mat); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec4f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Matrix4x4__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *result = 0 ; - SWIG_check_num_args("ofMatrix4x4::ofMatrix4x4",0,0) result = (ofMatrix4x4 *)new ofMatrix4x4(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Matrix4x4__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = 0 ; ofMatrix4x4 *result = 0 ; - SWIG_check_num_args("ofMatrix4x4::ofMatrix4x4",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofMatrix4x4::ofMatrix4x4",1,"ofMatrix4x4 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("new_Matrix4x4",1,SWIGTYPE_p_ofMatrix4x4); } - result = (ofMatrix4x4 *)new ofMatrix4x4((ofMatrix4x4 const &)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Matrix4x4__SWIG_2(lua_State* L) { int SWIG_arg = 0; float *arg1 = (float *) (float *)0 ; - ofMatrix4x4 *result = 0 ; SWIG_check_num_args("ofMatrix4x4::ofMatrix4x4",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::ofMatrix4x4",1,"float const *const"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_float,0))){ SWIG_fail_ptr("new_Matrix4x4",1,SWIGTYPE_p_float); } - result = (ofMatrix4x4 *)new ofMatrix4x4((float const *)arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Matrix4x4__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = 0 ; ofMatrix4x4 *result = 0 ; - SWIG_check_num_args("ofMatrix4x4::ofMatrix4x4",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofMatrix4x4::ofMatrix4x4",1,"ofQuaternion const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("new_Matrix4x4",1,SWIGTYPE_p_ofQuaternion); } - result = (ofMatrix4x4 *)new ofMatrix4x4((ofQuaternion const &)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Matrix4x4__SWIG_4(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - float arg5 ; float arg6 ; float arg7 ; float arg8 ; float arg9 ; float arg10 ; float arg11 ; float arg12 ; float arg13 ; - float arg14 ; float arg15 ; float arg16 ; ofMatrix4x4 *result = 0 ; SWIG_check_num_args("ofMatrix4x4::ofMatrix4x4",16,16) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMatrix4x4::ofMatrix4x4",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::ofMatrix4x4",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix4x4::ofMatrix4x4",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix4x4::ofMatrix4x4",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMatrix4x4::ofMatrix4x4",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofMatrix4x4::ofMatrix4x4",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofMatrix4x4::ofMatrix4x4",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofMatrix4x4::ofMatrix4x4",8,"float"); - if(!lua_isnumber(L,9)) SWIG_fail_arg("ofMatrix4x4::ofMatrix4x4",9,"float"); - if(!lua_isnumber(L,10)) SWIG_fail_arg("ofMatrix4x4::ofMatrix4x4",10,"float"); - if(!lua_isnumber(L,11)) SWIG_fail_arg("ofMatrix4x4::ofMatrix4x4",11,"float"); - if(!lua_isnumber(L,12)) SWIG_fail_arg("ofMatrix4x4::ofMatrix4x4",12,"float"); - if(!lua_isnumber(L,13)) SWIG_fail_arg("ofMatrix4x4::ofMatrix4x4",13,"float"); - if(!lua_isnumber(L,14)) SWIG_fail_arg("ofMatrix4x4::ofMatrix4x4",14,"float"); - if(!lua_isnumber(L,15)) SWIG_fail_arg("ofMatrix4x4::ofMatrix4x4",15,"float"); - if(!lua_isnumber(L,16)) SWIG_fail_arg("ofMatrix4x4::ofMatrix4x4",16,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); - arg8 = (float)lua_tonumber(L, 8); arg9 = (float)lua_tonumber(L, 9); arg10 = (float)lua_tonumber(L, 10); - arg11 = (float)lua_tonumber(L, 11); arg12 = (float)lua_tonumber(L, 12); arg13 = (float)lua_tonumber(L, 13); - arg14 = (float)lua_tonumber(L, 14); arg15 = (float)lua_tonumber(L, 15); arg16 = (float)lua_tonumber(L, 16); - result = (ofMatrix4x4 *)new ofMatrix4x4(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Matrix4x4(lua_State* L) { int argc; int argv[17]={ 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17} ; - argc = lua_gettop(L); if (argc == 0) { return _wrap_new_Matrix4x4__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_new_Matrix4x4__SWIG_1(L);} } if (argc == 1) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_new_Matrix4x4__SWIG_2(L);} } if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_new_Matrix4x4__SWIG_3(L);} } if (argc == 16) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { { _v = lua_isnumber(L,argv[8]); } if (_v) { { - _v = lua_isnumber(L,argv[9]); } if (_v) { { _v = lua_isnumber(L,argv[10]); } if (_v) { { - _v = lua_isnumber(L,argv[11]); } if (_v) { { _v = lua_isnumber(L,argv[12]); } if (_v) { { - _v = lua_isnumber(L,argv[13]); } if (_v) { { _v = lua_isnumber(L,argv[14]); } if (_v) { { - _v = lua_isnumber(L,argv[15]); } if (_v) { return _wrap_new_Matrix4x4__SWIG_4(L);} } } } - } } } } } } } } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_Matrix4x4'\n" " Possible C/C++ prototypes are:\n" - " ofMatrix4x4::ofMatrix4x4()\n" " ofMatrix4x4::ofMatrix4x4(ofMatrix4x4 const &)\n" - " ofMatrix4x4::ofMatrix4x4(float const *const)\n" " ofMatrix4x4::ofMatrix4x4(ofQuaternion const &)\n" - " ofMatrix4x4::ofMatrix4x4(float,float,float,float,float,float,float,float,float,float,float,float,float,float,float,float)\n"); - lua_error(L);return 0; } -static int _wrap_Matrix4x4_makeIdentityMatrix(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - SWIG_check_num_args("ofMatrix4x4::makeIdentityMatrix",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::makeIdentityMatrix",1,"ofMatrix4x4 *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_makeIdentityMatrix",1,SWIGTYPE_p_ofMatrix4x4); } (arg1)->makeIdentityMatrix(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_makeScaleMatrix__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofVec3f *arg2 = 0 ; SWIG_check_num_args("ofMatrix4x4::makeScaleMatrix",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::makeScaleMatrix",1,"ofMatrix4x4 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::makeScaleMatrix",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_makeScaleMatrix",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_makeScaleMatrix",2,SWIGTYPE_p_ofVec3f); } (arg1)->makeScaleMatrix((ofVec3f const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_makeScaleMatrix__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - float arg2 ; float arg3 ; float arg4 ; SWIG_check_num_args("ofMatrix4x4::makeScaleMatrix",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::makeScaleMatrix",1,"ofMatrix4x4 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::makeScaleMatrix",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix4x4::makeScaleMatrix",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix4x4::makeScaleMatrix",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_makeScaleMatrix",1,SWIGTYPE_p_ofMatrix4x4); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); (arg1)->makeScaleMatrix(arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_makeScaleMatrix(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_makeScaleMatrix__SWIG_0(L);} } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Matrix4x4_makeScaleMatrix__SWIG_1(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4_makeScaleMatrix'\n" - " Possible C/C++ prototypes are:\n" " ofMatrix4x4::makeScaleMatrix(ofVec3f const &)\n" - " ofMatrix4x4::makeScaleMatrix(float,float,float)\n"); lua_error(L);return 0; } -static int _wrap_Matrix4x4_makeTranslationMatrix__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; ofVec3f *arg2 = 0 ; SWIG_check_num_args("ofMatrix4x4::makeTranslationMatrix",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::makeTranslationMatrix",1,"ofMatrix4x4 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::makeTranslationMatrix",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_makeTranslationMatrix",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_makeTranslationMatrix",2,SWIGTYPE_p_ofVec3f); } - (arg1)->makeTranslationMatrix((ofVec3f const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_makeTranslationMatrix__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; float arg2 ; float arg3 ; float arg4 ; - SWIG_check_num_args("ofMatrix4x4::makeTranslationMatrix",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::makeTranslationMatrix",1,"ofMatrix4x4 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::makeTranslationMatrix",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix4x4::makeTranslationMatrix",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix4x4::makeTranslationMatrix",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_makeTranslationMatrix",1,SWIGTYPE_p_ofMatrix4x4); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); (arg1)->makeTranslationMatrix(arg2,arg3,arg4); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_makeTranslationMatrix(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_makeTranslationMatrix__SWIG_0(L);} } } if (argc == 4) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Matrix4x4_makeTranslationMatrix__SWIG_1(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4_makeTranslationMatrix'\n" - " Possible C/C++ prototypes are:\n" " ofMatrix4x4::makeTranslationMatrix(ofVec3f const &)\n" - " ofMatrix4x4::makeTranslationMatrix(float,float,float)\n"); lua_error(L);return 0; } -static int _wrap_Matrix4x4_makeRotationMatrix__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofVec3f *arg2 = 0 ; ofVec3f *arg3 = 0 ; SWIG_check_num_args("ofMatrix4x4::makeRotationMatrix",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::makeRotationMatrix",1,"ofMatrix4x4 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::makeRotationMatrix",2,"ofVec3f const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofMatrix4x4::makeRotationMatrix",3,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_makeRotationMatrix",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_makeRotationMatrix",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_makeRotationMatrix",3,SWIGTYPE_p_ofVec3f); } - (arg1)->makeRotationMatrix((ofVec3f const &)*arg2,(ofVec3f const &)*arg3); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_makeRotationMatrix__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - float arg2 ; ofVec3f *arg3 = 0 ; SWIG_check_num_args("ofMatrix4x4::makeRotationMatrix",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::makeRotationMatrix",1,"ofMatrix4x4 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::makeRotationMatrix",2,"float"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofMatrix4x4::makeRotationMatrix",3,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_makeRotationMatrix",1,SWIGTYPE_p_ofMatrix4x4); } arg2 = (float)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_makeRotationMatrix",3,SWIGTYPE_p_ofVec3f); } - (arg1)->makeRotationMatrix(arg2,(ofVec3f const &)*arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Matrix4x4_makeRotationMatrix__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - float arg2 ; float arg3 ; float arg4 ; float arg5 ; SWIG_check_num_args("ofMatrix4x4::makeRotationMatrix",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::makeRotationMatrix",1,"ofMatrix4x4 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::makeRotationMatrix",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix4x4::makeRotationMatrix",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix4x4::makeRotationMatrix",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMatrix4x4::makeRotationMatrix",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_makeRotationMatrix",1,SWIGTYPE_p_ofMatrix4x4); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - (arg1)->makeRotationMatrix(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_makeRotationMatrix__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofQuaternion *arg2 = 0 ; SWIG_check_num_args("ofMatrix4x4::makeRotationMatrix",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::makeRotationMatrix",1,"ofMatrix4x4 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::makeRotationMatrix",2,"ofQuaternion const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_makeRotationMatrix",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Matrix4x4_makeRotationMatrix",2,SWIGTYPE_p_ofQuaternion); } - (arg1)->makeRotationMatrix((ofQuaternion const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Matrix4x4_makeRotationMatrix__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - float arg2 ; ofVec3f *arg3 = 0 ; float arg4 ; ofVec3f *arg5 = 0 ; float arg6 ; ofVec3f *arg7 = 0 ; - SWIG_check_num_args("ofMatrix4x4::makeRotationMatrix",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::makeRotationMatrix",1,"ofMatrix4x4 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::makeRotationMatrix",2,"float"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofMatrix4x4::makeRotationMatrix",3,"ofVec3f const &"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix4x4::makeRotationMatrix",4,"float"); - if(!lua_isuserdata(L,5)) SWIG_fail_arg("ofMatrix4x4::makeRotationMatrix",5,"ofVec3f const &"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofMatrix4x4::makeRotationMatrix",6,"float"); - if(!lua_isuserdata(L,7)) SWIG_fail_arg("ofMatrix4x4::makeRotationMatrix",7,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_makeRotationMatrix",1,SWIGTYPE_p_ofMatrix4x4); } arg2 = (float)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_makeRotationMatrix",3,SWIGTYPE_p_ofVec3f); } arg4 = (float)lua_tonumber(L, 4); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_makeRotationMatrix",5,SWIGTYPE_p_ofVec3f); } arg6 = (float)lua_tonumber(L, 6); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,7,(void**)&arg7,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_makeRotationMatrix",7,SWIGTYPE_p_ofVec3f); } - (arg1)->makeRotationMatrix(arg2,(ofVec3f const &)*arg3,arg4,(ofVec3f const &)*arg5,arg6,(ofVec3f const &)*arg7); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_makeRotationMatrix(lua_State* L) { int argc; int argv[8]={ 1,2,3,4,5,6,7,8} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_makeRotationMatrix__SWIG_3(L);} } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_makeRotationMatrix__SWIG_0(L);} } } } if (argc == 3) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_makeRotationMatrix__SWIG_1(L);} } } } if (argc == 5) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Matrix4x4_makeRotationMatrix__SWIG_2(L);} } } } } } if (argc == 7) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[4])==0 || SWIG_ConvertPtr(L,argv[4], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[6])==0 || SWIG_ConvertPtr(L,argv[6], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_makeRotationMatrix__SWIG_4(L);} } } } } - } } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4_makeRotationMatrix'\n" - " Possible C/C++ prototypes are:\n" " ofMatrix4x4::makeRotationMatrix(ofVec3f const &,ofVec3f const &)\n" - " ofMatrix4x4::makeRotationMatrix(float,ofVec3f const &)\n" - " ofMatrix4x4::makeRotationMatrix(float,float,float,float)\n" " ofMatrix4x4::makeRotationMatrix(ofQuaternion const &)\n" - " ofMatrix4x4::makeRotationMatrix(float,ofVec3f const &,float,ofVec3f const &,float,ofVec3f const &)\n"); - lua_error(L);return 0; } -static int _wrap_Matrix4x4_makeInvertOf(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofMatrix4x4 *arg2 = 0 ; bool result; SWIG_check_num_args("ofMatrix4x4::makeInvertOf",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::makeInvertOf",1,"ofMatrix4x4 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::makeInvertOf",2,"ofMatrix4x4 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_makeInvertOf",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_makeInvertOf",2,SWIGTYPE_p_ofMatrix4x4); } - result = (bool)(arg1)->makeInvertOf((ofMatrix4x4 const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_makeOrthoNormalOf(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofMatrix4x4 *arg2 = 0 ; SWIG_check_num_args("ofMatrix4x4::makeOrthoNormalOf",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::makeOrthoNormalOf",1,"ofMatrix4x4 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::makeOrthoNormalOf",2,"ofMatrix4x4 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_makeOrthoNormalOf",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_makeOrthoNormalOf",2,SWIGTYPE_p_ofMatrix4x4); } - (arg1)->makeOrthoNormalOf((ofMatrix4x4 const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_makeFromMultiplicationOf(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofMatrix4x4 *arg2 = 0 ; ofMatrix4x4 *arg3 = 0 ; SWIG_check_num_args("ofMatrix4x4::makeFromMultiplicationOf",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::makeFromMultiplicationOf",1,"ofMatrix4x4 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::makeFromMultiplicationOf",2,"ofMatrix4x4 const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofMatrix4x4::makeFromMultiplicationOf",3,"ofMatrix4x4 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_makeFromMultiplicationOf",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_makeFromMultiplicationOf",2,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_makeFromMultiplicationOf",3,SWIGTYPE_p_ofMatrix4x4); } - (arg1)->makeFromMultiplicationOf((ofMatrix4x4 const &)*arg2,(ofMatrix4x4 const &)*arg3); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_makeOrthoMatrix(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - double arg2 ; double arg3 ; double arg4 ; double arg5 ; double arg6 ; double arg7 ; - SWIG_check_num_args("ofMatrix4x4::makeOrthoMatrix",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::makeOrthoMatrix",1,"ofMatrix4x4 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::makeOrthoMatrix",2,"double"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix4x4::makeOrthoMatrix",3,"double"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix4x4::makeOrthoMatrix",4,"double"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMatrix4x4::makeOrthoMatrix",5,"double"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofMatrix4x4::makeOrthoMatrix",6,"double"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofMatrix4x4::makeOrthoMatrix",7,"double"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_makeOrthoMatrix",1,SWIGTYPE_p_ofMatrix4x4); } arg2 = (double)lua_tonumber(L, 2); - arg3 = (double)lua_tonumber(L, 3); arg4 = (double)lua_tonumber(L, 4); arg5 = (double)lua_tonumber(L, 5); - arg6 = (double)lua_tonumber(L, 6); arg7 = (double)lua_tonumber(L, 7); (arg1)->makeOrthoMatrix(arg2,arg3,arg4,arg5,arg6,arg7); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_makeOrtho2DMatrix(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - double arg2 ; double arg3 ; double arg4 ; double arg5 ; SWIG_check_num_args("ofMatrix4x4::makeOrtho2DMatrix",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::makeOrtho2DMatrix",1,"ofMatrix4x4 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::makeOrtho2DMatrix",2,"double"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix4x4::makeOrtho2DMatrix",3,"double"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix4x4::makeOrtho2DMatrix",4,"double"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMatrix4x4::makeOrtho2DMatrix",5,"double"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_makeOrtho2DMatrix",1,SWIGTYPE_p_ofMatrix4x4); } arg2 = (double)lua_tonumber(L, 2); - arg3 = (double)lua_tonumber(L, 3); arg4 = (double)lua_tonumber(L, 4); arg5 = (double)lua_tonumber(L, 5); - (arg1)->makeOrtho2DMatrix(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_makeFrustumMatrix(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - double arg2 ; double arg3 ; double arg4 ; double arg5 ; double arg6 ; double arg7 ; - SWIG_check_num_args("ofMatrix4x4::makeFrustumMatrix",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::makeFrustumMatrix",1,"ofMatrix4x4 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::makeFrustumMatrix",2,"double"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix4x4::makeFrustumMatrix",3,"double"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix4x4::makeFrustumMatrix",4,"double"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMatrix4x4::makeFrustumMatrix",5,"double"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofMatrix4x4::makeFrustumMatrix",6,"double"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofMatrix4x4::makeFrustumMatrix",7,"double"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_makeFrustumMatrix",1,SWIGTYPE_p_ofMatrix4x4); } arg2 = (double)lua_tonumber(L, 2); - arg3 = (double)lua_tonumber(L, 3); arg4 = (double)lua_tonumber(L, 4); arg5 = (double)lua_tonumber(L, 5); - arg6 = (double)lua_tonumber(L, 6); arg7 = (double)lua_tonumber(L, 7); - (arg1)->makeFrustumMatrix(arg2,arg3,arg4,arg5,arg6,arg7); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Matrix4x4_makePerspectiveMatrix(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - double arg2 ; double arg3 ; double arg4 ; double arg5 ; SWIG_check_num_args("ofMatrix4x4::makePerspectiveMatrix",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::makePerspectiveMatrix",1,"ofMatrix4x4 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::makePerspectiveMatrix",2,"double"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix4x4::makePerspectiveMatrix",3,"double"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix4x4::makePerspectiveMatrix",4,"double"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMatrix4x4::makePerspectiveMatrix",5,"double"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_makePerspectiveMatrix",1,SWIGTYPE_p_ofMatrix4x4); } arg2 = (double)lua_tonumber(L, 2); - arg3 = (double)lua_tonumber(L, 3); arg4 = (double)lua_tonumber(L, 4); arg5 = (double)lua_tonumber(L, 5); - (arg1)->makePerspectiveMatrix(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_makeLookAtMatrix(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofVec3f *arg2 = 0 ; ofVec3f *arg3 = 0 ; ofVec3f *arg4 = 0 ; SWIG_check_num_args("ofMatrix4x4::makeLookAtMatrix",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::makeLookAtMatrix",1,"ofMatrix4x4 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::makeLookAtMatrix",2,"ofVec3f const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofMatrix4x4::makeLookAtMatrix",3,"ofVec3f const &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofMatrix4x4::makeLookAtMatrix",4,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_makeLookAtMatrix",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_makeLookAtMatrix",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_makeLookAtMatrix",3,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_makeLookAtMatrix",4,SWIGTYPE_p_ofVec3f); } - (arg1)->makeLookAtMatrix((ofVec3f const &)*arg2,(ofVec3f const &)*arg3,(ofVec3f const &)*arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_makeLookAtViewMatrix(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofVec3f *arg2 = 0 ; ofVec3f *arg3 = 0 ; ofVec3f *arg4 = 0 ; SWIG_check_num_args("ofMatrix4x4::makeLookAtViewMatrix",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::makeLookAtViewMatrix",1,"ofMatrix4x4 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::makeLookAtViewMatrix",2,"ofVec3f const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofMatrix4x4::makeLookAtViewMatrix",3,"ofVec3f const &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofMatrix4x4::makeLookAtViewMatrix",4,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_makeLookAtViewMatrix",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_makeLookAtViewMatrix",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_makeLookAtViewMatrix",3,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_makeLookAtViewMatrix",4,SWIGTYPE_p_ofVec3f); } - (arg1)->makeLookAtViewMatrix((ofVec3f const &)*arg2,(ofVec3f const &)*arg3,(ofVec3f const &)*arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_newIdentityMatrix(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 result; - SWIG_check_num_args("ofMatrix4x4::newIdentityMatrix",0,0) result = ofMatrix4x4::newIdentityMatrix(); { - ofMatrix4x4 * resultptr = new ofMatrix4x4((const ofMatrix4x4 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_newScaleMatrix__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = 0 ; ofMatrix4x4 result; - SWIG_check_num_args("ofMatrix4x4::newScaleMatrix",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofMatrix4x4::newScaleMatrix",1,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_newScaleMatrix",1,SWIGTYPE_p_ofVec3f); } - result = ofMatrix4x4::newScaleMatrix((ofVec3f const &)*arg1); { - ofMatrix4x4 * resultptr = new ofMatrix4x4((const ofMatrix4x4 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_newScaleMatrix__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; - ofMatrix4x4 result; SWIG_check_num_args("ofMatrix4x4::newScaleMatrix",3,3) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMatrix4x4::newScaleMatrix",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::newScaleMatrix",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix4x4::newScaleMatrix",3,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); result = ofMatrix4x4::newScaleMatrix(arg1,arg2,arg3); { - ofMatrix4x4 * resultptr = new ofMatrix4x4((const ofMatrix4x4 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_newScaleMatrix(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); - if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_Matrix4x4_newScaleMatrix__SWIG_0(L);} } if (argc == 3) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_Matrix4x4_newScaleMatrix__SWIG_1(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4_newScaleMatrix'\n" - " Possible C/C++ prototypes are:\n" " ofMatrix4x4::newScaleMatrix(ofVec3f const &)\n" - " ofMatrix4x4::newScaleMatrix(float,float,float)\n"); lua_error(L);return 0; } -static int _wrap_Matrix4x4_newTranslationMatrix__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = 0 ; - ofMatrix4x4 result; SWIG_check_num_args("ofMatrix4x4::newTranslationMatrix",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofMatrix4x4::newTranslationMatrix",1,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_newTranslationMatrix",1,SWIGTYPE_p_ofVec3f); } - result = ofMatrix4x4::newTranslationMatrix((ofVec3f const &)*arg1); { - ofMatrix4x4 * resultptr = new ofMatrix4x4((const ofMatrix4x4 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_newTranslationMatrix__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; - ofMatrix4x4 result; SWIG_check_num_args("ofMatrix4x4::newTranslationMatrix",3,3) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMatrix4x4::newTranslationMatrix",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::newTranslationMatrix",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix4x4::newTranslationMatrix",3,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - result = ofMatrix4x4::newTranslationMatrix(arg1,arg2,arg3); { - ofMatrix4x4 * resultptr = new ofMatrix4x4((const ofMatrix4x4 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_newTranslationMatrix(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); - if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_Matrix4x4_newTranslationMatrix__SWIG_0(L);} } if (argc == 3) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_Matrix4x4_newTranslationMatrix__SWIG_1(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4_newTranslationMatrix'\n" - " Possible C/C++ prototypes are:\n" " ofMatrix4x4::newTranslationMatrix(ofVec3f const &)\n" - " ofMatrix4x4::newTranslationMatrix(float,float,float)\n"); lua_error(L);return 0; } -static int _wrap_Matrix4x4_newRotationMatrix__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = 0 ; ofVec3f *arg2 = 0 ; - ofMatrix4x4 result; SWIG_check_num_args("ofMatrix4x4::newRotationMatrix",2,2) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofMatrix4x4::newRotationMatrix",1,"ofVec3f const &"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::newRotationMatrix",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_newRotationMatrix",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_newRotationMatrix",2,SWIGTYPE_p_ofVec3f); } - result = ofMatrix4x4::newRotationMatrix((ofVec3f const &)*arg1,(ofVec3f const &)*arg2); { - ofMatrix4x4 * resultptr = new ofMatrix4x4((const ofMatrix4x4 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_newRotationMatrix__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; - float arg4 ; ofMatrix4x4 result; SWIG_check_num_args("ofMatrix4x4::newRotationMatrix",4,4) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMatrix4x4::newRotationMatrix",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::newRotationMatrix",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix4x4::newRotationMatrix",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix4x4::newRotationMatrix",4,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - result = ofMatrix4x4::newRotationMatrix(arg1,arg2,arg3,arg4); { - ofMatrix4x4 * resultptr = new ofMatrix4x4((const ofMatrix4x4 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_newRotationMatrix__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; ofVec3f *arg2 = 0 ; - ofMatrix4x4 result; SWIG_check_num_args("ofMatrix4x4::newRotationMatrix",2,2) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMatrix4x4::newRotationMatrix",1,"float"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::newRotationMatrix",2,"ofVec3f const &"); - arg1 = (float)lua_tonumber(L, 1); if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_newRotationMatrix",2,SWIGTYPE_p_ofVec3f); } - result = ofMatrix4x4::newRotationMatrix(arg1,(ofVec3f const &)*arg2); { - ofMatrix4x4 * resultptr = new ofMatrix4x4((const ofMatrix4x4 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_newRotationMatrix__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; ofVec3f *arg2 = 0 ; - float arg3 ; ofVec3f *arg4 = 0 ; float arg5 ; ofVec3f *arg6 = 0 ; ofMatrix4x4 result; - SWIG_check_num_args("ofMatrix4x4::newRotationMatrix",6,6) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMatrix4x4::newRotationMatrix",1,"float"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::newRotationMatrix",2,"ofVec3f const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix4x4::newRotationMatrix",3,"float"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofMatrix4x4::newRotationMatrix",4,"ofVec3f const &"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMatrix4x4::newRotationMatrix",5,"float"); - if(!lua_isuserdata(L,6)) SWIG_fail_arg("ofMatrix4x4::newRotationMatrix",6,"ofVec3f const &"); - arg1 = (float)lua_tonumber(L, 1); if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_newRotationMatrix",2,SWIGTYPE_p_ofVec3f); } arg3 = (float)lua_tonumber(L, 3); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_newRotationMatrix",4,SWIGTYPE_p_ofVec3f); } arg5 = (float)lua_tonumber(L, 5); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,6,(void**)&arg6,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_newRotationMatrix",6,SWIGTYPE_p_ofVec3f); } - result = ofMatrix4x4::newRotationMatrix(arg1,(ofVec3f const &)*arg2,arg3,(ofVec3f const &)*arg4,arg5,(ofVec3f const &)*arg6); - { ofMatrix4x4 * resultptr = new ofMatrix4x4((const ofMatrix4x4 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_newRotationMatrix__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = 0 ; - ofMatrix4x4 result; SWIG_check_num_args("ofMatrix4x4::newRotationMatrix",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofMatrix4x4::newRotationMatrix",1,"ofQuaternion const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Matrix4x4_newRotationMatrix",1,SWIGTYPE_p_ofQuaternion); } - result = ofMatrix4x4::newRotationMatrix((ofQuaternion const &)*arg1); { - ofMatrix4x4 * resultptr = new ofMatrix4x4((const ofMatrix4x4 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_newRotationMatrix(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); - if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_newRotationMatrix__SWIG_4(L);} } if (argc == 2) { int _v; { - void *ptr; if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_newRotationMatrix__SWIG_0(L);} } } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_newRotationMatrix__SWIG_2(L);} } } if (argc == 4) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Matrix4x4_newRotationMatrix__SWIG_1(L);} } } } } - if (argc == 6) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[5])==0 || SWIG_ConvertPtr(L,argv[5], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_newRotationMatrix__SWIG_3(L);} } } } } } - } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4_newRotationMatrix'\n" - " Possible C/C++ prototypes are:\n" " ofMatrix4x4::newRotationMatrix(ofVec3f const &,ofVec3f const &)\n" - " ofMatrix4x4::newRotationMatrix(float,float,float,float)\n" " ofMatrix4x4::newRotationMatrix(float,ofVec3f const &)\n" - " ofMatrix4x4::newRotationMatrix(float,ofVec3f const &,float,ofVec3f const &,float,ofVec3f const &)\n" - " ofMatrix4x4::newRotationMatrix(ofQuaternion const &)\n"); lua_error(L);return 0; } -static int _wrap_Matrix4x4_newOrthoMatrix(lua_State* L) { int SWIG_arg = 0; double arg1 ; double arg2 ; double arg3 ; - double arg4 ; double arg5 ; double arg6 ; ofMatrix4x4 result; SWIG_check_num_args("ofMatrix4x4::newOrthoMatrix",6,6) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMatrix4x4::newOrthoMatrix",1,"double"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::newOrthoMatrix",2,"double"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix4x4::newOrthoMatrix",3,"double"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix4x4::newOrthoMatrix",4,"double"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMatrix4x4::newOrthoMatrix",5,"double"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofMatrix4x4::newOrthoMatrix",6,"double"); arg1 = (double)lua_tonumber(L, 1); - arg2 = (double)lua_tonumber(L, 2); arg3 = (double)lua_tonumber(L, 3); arg4 = (double)lua_tonumber(L, 4); - arg5 = (double)lua_tonumber(L, 5); arg6 = (double)lua_tonumber(L, 6); - result = ofMatrix4x4::newOrthoMatrix(arg1,arg2,arg3,arg4,arg5,arg6); { - ofMatrix4x4 * resultptr = new ofMatrix4x4((const ofMatrix4x4 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_newOrtho2DMatrix(lua_State* L) { int SWIG_arg = 0; double arg1 ; double arg2 ; double arg3 ; - double arg4 ; ofMatrix4x4 result; SWIG_check_num_args("ofMatrix4x4::newOrtho2DMatrix",4,4) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMatrix4x4::newOrtho2DMatrix",1,"double"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::newOrtho2DMatrix",2,"double"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix4x4::newOrtho2DMatrix",3,"double"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix4x4::newOrtho2DMatrix",4,"double"); arg1 = (double)lua_tonumber(L, 1); - arg2 = (double)lua_tonumber(L, 2); arg3 = (double)lua_tonumber(L, 3); arg4 = (double)lua_tonumber(L, 4); - result = ofMatrix4x4::newOrtho2DMatrix(arg1,arg2,arg3,arg4); { - ofMatrix4x4 * resultptr = new ofMatrix4x4((const ofMatrix4x4 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_newFrustumMatrix(lua_State* L) { int SWIG_arg = 0; double arg1 ; double arg2 ; double arg3 ; - double arg4 ; double arg5 ; double arg6 ; ofMatrix4x4 result; SWIG_check_num_args("ofMatrix4x4::newFrustumMatrix",6,6) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMatrix4x4::newFrustumMatrix",1,"double"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::newFrustumMatrix",2,"double"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix4x4::newFrustumMatrix",3,"double"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix4x4::newFrustumMatrix",4,"double"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMatrix4x4::newFrustumMatrix",5,"double"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofMatrix4x4::newFrustumMatrix",6,"double"); arg1 = (double)lua_tonumber(L, 1); - arg2 = (double)lua_tonumber(L, 2); arg3 = (double)lua_tonumber(L, 3); arg4 = (double)lua_tonumber(L, 4); - arg5 = (double)lua_tonumber(L, 5); arg6 = (double)lua_tonumber(L, 6); - result = ofMatrix4x4::newFrustumMatrix(arg1,arg2,arg3,arg4,arg5,arg6); { - ofMatrix4x4 * resultptr = new ofMatrix4x4((const ofMatrix4x4 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_newPerspectiveMatrix(lua_State* L) { int SWIG_arg = 0; double arg1 ; double arg2 ; double arg3 ; - double arg4 ; ofMatrix4x4 result; SWIG_check_num_args("ofMatrix4x4::newPerspectiveMatrix",4,4) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMatrix4x4::newPerspectiveMatrix",1,"double"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::newPerspectiveMatrix",2,"double"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix4x4::newPerspectiveMatrix",3,"double"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix4x4::newPerspectiveMatrix",4,"double"); arg1 = (double)lua_tonumber(L, 1); - arg2 = (double)lua_tonumber(L, 2); arg3 = (double)lua_tonumber(L, 3); arg4 = (double)lua_tonumber(L, 4); - result = ofMatrix4x4::newPerspectiveMatrix(arg1,arg2,arg3,arg4); { - ofMatrix4x4 * resultptr = new ofMatrix4x4((const ofMatrix4x4 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_newLookAtMatrix(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = 0 ; ofVec3f *arg2 = 0 ; - ofVec3f *arg3 = 0 ; ofMatrix4x4 result; SWIG_check_num_args("ofMatrix4x4::newLookAtMatrix",3,3) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofMatrix4x4::newLookAtMatrix",1,"ofVec3f const &"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::newLookAtMatrix",2,"ofVec3f const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofMatrix4x4::newLookAtMatrix",3,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_newLookAtMatrix",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_newLookAtMatrix",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_newLookAtMatrix",3,SWIGTYPE_p_ofVec3f); } - result = ofMatrix4x4::newLookAtMatrix((ofVec3f const &)*arg1,(ofVec3f const &)*arg2,(ofVec3f const &)*arg3); { - ofMatrix4x4 * resultptr = new ofMatrix4x4((const ofMatrix4x4 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4___call(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; std::size_t arg2 ; - std::size_t arg3 ; float *result = 0 ; SWIG_check_num_args("ofMatrix4x4::operator ()",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::operator ()",1,"ofMatrix4x4 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::operator ()",2,"std::size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix4x4::operator ()",3,"std::size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4___call",1,SWIGTYPE_p_ofMatrix4x4); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (std::size_t)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (std::size_t)lua_tonumber(L, 3); - result = (float *) &(arg1)->operator ()(arg2,arg3); SWIG_NewPointerObj(L,result,SWIGTYPE_p_float,0); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_getRowAsVec3f(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - std::size_t arg2 ; ofVec3f result; SWIG_check_num_args("ofMatrix4x4::getRowAsVec3f",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::getRowAsVec3f",1,"ofMatrix4x4 const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::getRowAsVec3f",2,"std::size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_getRowAsVec3f",1,SWIGTYPE_p_ofMatrix4x4); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (std::size_t)lua_tonumber(L, 2); - result = ((ofMatrix4x4 const *)arg1)->getRowAsVec3f(arg2); { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_getRowAsVec4f(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - std::size_t arg2 ; ofVec4f result; SWIG_check_num_args("ofMatrix4x4::getRowAsVec4f",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::getRowAsVec4f",1,"ofMatrix4x4 const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::getRowAsVec4f",2,"std::size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_getRowAsVec4f",1,SWIGTYPE_p_ofMatrix4x4); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (std::size_t)lua_tonumber(L, 2); - result = ((ofMatrix4x4 const *)arg1)->getRowAsVec4f(arg2); { ofVec4f * resultptr = new ofVec4f((const ofVec4f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec4f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_getPtr__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - float *result = 0 ; SWIG_check_num_args("ofMatrix4x4::getPtr",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::getPtr",1,"ofMatrix4x4 *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_getPtr",1,SWIGTYPE_p_ofMatrix4x4); } result = (float *)(arg1)->getPtr(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_float,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Matrix4x4_getPtr__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - float *result = 0 ; SWIG_check_num_args("ofMatrix4x4::getPtr",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::getPtr",1,"ofMatrix4x4 const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_getPtr",1,SWIGTYPE_p_ofMatrix4x4); } result = (float *)((ofMatrix4x4 const *)arg1)->getPtr(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_float,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Matrix4x4_getPtr(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_getPtr__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_getPtr__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4_getPtr'\n" " Possible C/C++ prototypes are:\n" - " ofMatrix4x4::getPtr()\n" " ofMatrix4x4::getPtr() const\n"); lua_error(L);return 0; } -static int _wrap_Matrix4x4_isValid(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; bool result; - SWIG_check_num_args("ofMatrix4x4::isValid",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::isValid",1,"ofMatrix4x4 const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_isValid",1,SWIGTYPE_p_ofMatrix4x4); } result = (bool)((ofMatrix4x4 const *)arg1)->isValid(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_isNaN(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; bool result; - SWIG_check_num_args("ofMatrix4x4::isNaN",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::isNaN",1,"ofMatrix4x4 const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_isNaN",1,SWIGTYPE_p_ofMatrix4x4); } result = (bool)((ofMatrix4x4 const *)arg1)->isNaN(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_isIdentity(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; bool result; - SWIG_check_num_args("ofMatrix4x4::isIdentity",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::isIdentity",1,"ofMatrix4x4 const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_isIdentity",1,SWIGTYPE_p_ofMatrix4x4); } result = (bool)((ofMatrix4x4 const *)arg1)->isIdentity(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_set__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofMatrix4x4 *arg2 = 0 ; SWIG_check_num_args("ofMatrix4x4::set",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::set",1,"ofMatrix4x4 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::set",2,"ofMatrix4x4 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_set",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_set",2,SWIGTYPE_p_ofMatrix4x4); } (arg1)->set((ofMatrix4x4 const &)*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_set__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - float *arg2 = (float *) (float *)0 ; SWIG_check_num_args("ofMatrix4x4::set",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::set",1,"ofMatrix4x4 *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofMatrix4x4::set",2,"float const *const"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_set",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_float,0))){ SWIG_fail_ptr("Matrix4x4_set",2,SWIGTYPE_p_float); } - (arg1)->set((float const *)arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_set__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - double *arg2 = (double *) (double *)0 ; SWIG_check_num_args("ofMatrix4x4::set",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::set",1,"ofMatrix4x4 *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofMatrix4x4::set",2,"double const *const"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_set",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_double,0))){ SWIG_fail_ptr("Matrix4x4_set",2,SWIGTYPE_p_double); } - (arg1)->set((double const *)arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_set__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; float arg2 ; - float arg3 ; float arg4 ; float arg5 ; float arg6 ; float arg7 ; float arg8 ; float arg9 ; float arg10 ; float arg11 ; - float arg12 ; float arg13 ; float arg14 ; float arg15 ; float arg16 ; float arg17 ; - SWIG_check_num_args("ofMatrix4x4::set",17,17) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::set",1,"ofMatrix4x4 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix4x4::set",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix4x4::set",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMatrix4x4::set",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofMatrix4x4::set",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofMatrix4x4::set",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofMatrix4x4::set",8,"float"); - if(!lua_isnumber(L,9)) SWIG_fail_arg("ofMatrix4x4::set",9,"float"); - if(!lua_isnumber(L,10)) SWIG_fail_arg("ofMatrix4x4::set",10,"float"); - if(!lua_isnumber(L,11)) SWIG_fail_arg("ofMatrix4x4::set",11,"float"); - if(!lua_isnumber(L,12)) SWIG_fail_arg("ofMatrix4x4::set",12,"float"); - if(!lua_isnumber(L,13)) SWIG_fail_arg("ofMatrix4x4::set",13,"float"); - if(!lua_isnumber(L,14)) SWIG_fail_arg("ofMatrix4x4::set",14,"float"); - if(!lua_isnumber(L,15)) SWIG_fail_arg("ofMatrix4x4::set",15,"float"); - if(!lua_isnumber(L,16)) SWIG_fail_arg("ofMatrix4x4::set",16,"float"); - if(!lua_isnumber(L,17)) SWIG_fail_arg("ofMatrix4x4::set",17,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_set",1,SWIGTYPE_p_ofMatrix4x4); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (float)lua_tonumber(L, 8); - arg9 = (float)lua_tonumber(L, 9); arg10 = (float)lua_tonumber(L, 10); arg11 = (float)lua_tonumber(L, 11); - arg12 = (float)lua_tonumber(L, 12); arg13 = (float)lua_tonumber(L, 13); arg14 = (float)lua_tonumber(L, 14); - arg15 = (float)lua_tonumber(L, 15); arg16 = (float)lua_tonumber(L, 16); arg17 = (float)lua_tonumber(L, 17); - (arg1)->set(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_set(lua_State* L) { int argc; int argv[18]={ 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18} ; - argc = lua_gettop(L); if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_set__SWIG_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_Matrix4x4_set__SWIG_1(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_double, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_set__SWIG_2(L);} } } if (argc == 17) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { { _v = lua_isnumber(L,argv[8]); } if (_v) { { - _v = lua_isnumber(L,argv[9]); } if (_v) { { _v = lua_isnumber(L,argv[10]); } if (_v) { { - _v = lua_isnumber(L,argv[11]); } if (_v) { { _v = lua_isnumber(L,argv[12]); } if (_v) { { - _v = lua_isnumber(L,argv[13]); } if (_v) { { _v = lua_isnumber(L,argv[14]); } if (_v) { { - _v = lua_isnumber(L,argv[15]); } if (_v) { { _v = lua_isnumber(L,argv[16]); } if (_v) { - return _wrap_Matrix4x4_set__SWIG_3(L);} } } } } } } } } } } } } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4_set'\n" " Possible C/C++ prototypes are:\n" - " ofMatrix4x4::set(ofMatrix4x4 const &)\n" " ofMatrix4x4::set(float const *const)\n" - " ofMatrix4x4::set(double const *const)\n" - " ofMatrix4x4::set(float,float,float,float,float,float,float,float,float,float,float,float,float,float,float,float)\n"); - lua_error(L);return 0; } -static int _wrap_Matrix4x4_getInverse(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofMatrix4x4 result; SWIG_check_num_args("ofMatrix4x4::getInverse",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::getInverse",1,"ofMatrix4x4 const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_getInverse",1,SWIGTYPE_p_ofMatrix4x4); } result = ((ofMatrix4x4 const *)arg1)->getInverse(); { - ofMatrix4x4 * resultptr = new ofMatrix4x4((const ofMatrix4x4 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_getOrtho(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; double *arg2 = 0 ; - double *arg3 = 0 ; double *arg4 = 0 ; double *arg5 = 0 ; double *arg6 = 0 ; double *arg7 = 0 ; bool result; - SWIG_check_num_args("ofMatrix4x4::getOrtho",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::getOrtho",1,"ofMatrix4x4 const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::getOrtho",2,"double &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofMatrix4x4::getOrtho",3,"double &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofMatrix4x4::getOrtho",4,"double &"); - if(!lua_isuserdata(L,5)) SWIG_fail_arg("ofMatrix4x4::getOrtho",5,"double &"); - if(!lua_isuserdata(L,6)) SWIG_fail_arg("ofMatrix4x4::getOrtho",6,"double &"); - if(!lua_isuserdata(L,7)) SWIG_fail_arg("ofMatrix4x4::getOrtho",7,"double &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_getOrtho",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_double,0))){ - SWIG_fail_ptr("Matrix4x4_getOrtho",2,SWIGTYPE_p_double); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_double,0))){ - SWIG_fail_ptr("Matrix4x4_getOrtho",3,SWIGTYPE_p_double); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_double,0))){ - SWIG_fail_ptr("Matrix4x4_getOrtho",4,SWIGTYPE_p_double); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_double,0))){ - SWIG_fail_ptr("Matrix4x4_getOrtho",5,SWIGTYPE_p_double); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,6,(void**)&arg6,SWIGTYPE_p_double,0))){ - SWIG_fail_ptr("Matrix4x4_getOrtho",6,SWIGTYPE_p_double); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,7,(void**)&arg7,SWIGTYPE_p_double,0))){ - SWIG_fail_ptr("Matrix4x4_getOrtho",7,SWIGTYPE_p_double); } - result = (bool)((ofMatrix4x4 const *)arg1)->getOrtho(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_getFrustum(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - double *arg2 = 0 ; double *arg3 = 0 ; double *arg4 = 0 ; double *arg5 = 0 ; double *arg6 = 0 ; double *arg7 = 0 ; bool result; - SWIG_check_num_args("ofMatrix4x4::getFrustum",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::getFrustum",1,"ofMatrix4x4 const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::getFrustum",2,"double &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofMatrix4x4::getFrustum",3,"double &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofMatrix4x4::getFrustum",4,"double &"); - if(!lua_isuserdata(L,5)) SWIG_fail_arg("ofMatrix4x4::getFrustum",5,"double &"); - if(!lua_isuserdata(L,6)) SWIG_fail_arg("ofMatrix4x4::getFrustum",6,"double &"); - if(!lua_isuserdata(L,7)) SWIG_fail_arg("ofMatrix4x4::getFrustum",7,"double &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_getFrustum",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_double,0))){ - SWIG_fail_ptr("Matrix4x4_getFrustum",2,SWIGTYPE_p_double); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_double,0))){ - SWIG_fail_ptr("Matrix4x4_getFrustum",3,SWIGTYPE_p_double); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_double,0))){ - SWIG_fail_ptr("Matrix4x4_getFrustum",4,SWIGTYPE_p_double); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_double,0))){ - SWIG_fail_ptr("Matrix4x4_getFrustum",5,SWIGTYPE_p_double); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,6,(void**)&arg6,SWIGTYPE_p_double,0))){ - SWIG_fail_ptr("Matrix4x4_getFrustum",6,SWIGTYPE_p_double); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,7,(void**)&arg7,SWIGTYPE_p_double,0))){ - SWIG_fail_ptr("Matrix4x4_getFrustum",7,SWIGTYPE_p_double); } - result = (bool)((ofMatrix4x4 const *)arg1)->getFrustum(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_getPerspective(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - double *arg2 = 0 ; double *arg3 = 0 ; double *arg4 = 0 ; double *arg5 = 0 ; bool result; - SWIG_check_num_args("ofMatrix4x4::getPerspective",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::getPerspective",1,"ofMatrix4x4 const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::getPerspective",2,"double &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofMatrix4x4::getPerspective",3,"double &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofMatrix4x4::getPerspective",4,"double &"); - if(!lua_isuserdata(L,5)) SWIG_fail_arg("ofMatrix4x4::getPerspective",5,"double &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_getPerspective",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_double,0))){ - SWIG_fail_ptr("Matrix4x4_getPerspective",2,SWIGTYPE_p_double); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_double,0))){ - SWIG_fail_ptr("Matrix4x4_getPerspective",3,SWIGTYPE_p_double); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_double,0))){ - SWIG_fail_ptr("Matrix4x4_getPerspective",4,SWIGTYPE_p_double); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_double,0))){ - SWIG_fail_ptr("Matrix4x4_getPerspective",5,SWIGTYPE_p_double); } - result = (bool)((ofMatrix4x4 const *)arg1)->getPerspective(*arg2,*arg3,*arg4,*arg5); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_getLookAt__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofVec3f *arg2 = 0 ; ofVec3f *arg3 = 0 ; ofVec3f *arg4 = 0 ; float arg5 ; SWIG_check_num_args("ofMatrix4x4::getLookAt",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::getLookAt",1,"ofMatrix4x4 const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::getLookAt",2,"ofVec3f &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofMatrix4x4::getLookAt",3,"ofVec3f &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofMatrix4x4::getLookAt",4,"ofVec3f &"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMatrix4x4::getLookAt",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_getLookAt",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_getLookAt",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_getLookAt",3,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_getLookAt",4,SWIGTYPE_p_ofVec3f); } arg5 = (float)lua_tonumber(L, 5); - ((ofMatrix4x4 const *)arg1)->getLookAt(*arg2,*arg3,*arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Matrix4x4_getLookAt__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofVec3f *arg2 = 0 ; ofVec3f *arg3 = 0 ; ofVec3f *arg4 = 0 ; SWIG_check_num_args("ofMatrix4x4::getLookAt",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::getLookAt",1,"ofMatrix4x4 const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::getLookAt",2,"ofVec3f &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofMatrix4x4::getLookAt",3,"ofVec3f &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofMatrix4x4::getLookAt",4,"ofVec3f &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_getLookAt",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_getLookAt",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_getLookAt",3,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_getLookAt",4,SWIGTYPE_p_ofVec3f); } ((ofMatrix4x4 const *)arg1)->getLookAt(*arg2,*arg3,*arg4); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_getLookAt(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); - if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_getLookAt__SWIG_1(L);} } } } } if (argc == 5) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Matrix4x4_getLookAt__SWIG_0(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4_getLookAt'\n" - " Possible C/C++ prototypes are:\n" " ofMatrix4x4::getLookAt(ofVec3f &,ofVec3f &,ofVec3f &,float) const\n" - " ofMatrix4x4::getLookAt(ofVec3f &,ofVec3f &,ofVec3f &) const\n"); lua_error(L);return 0; } -static int _wrap_Matrix4x4_decompose(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofVec3f *arg2 = 0 ; ofQuaternion *arg3 = 0 ; ofVec3f *arg4 = 0 ; ofQuaternion *arg5 = 0 ; - SWIG_check_num_args("ofMatrix4x4::decompose",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::decompose",1,"ofMatrix4x4 const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::decompose",2,"ofVec3f &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofMatrix4x4::decompose",3,"ofQuaternion &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofMatrix4x4::decompose",4,"ofVec3f &"); - if(!lua_isuserdata(L,5)) SWIG_fail_arg("ofMatrix4x4::decompose",5,"ofQuaternion &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_decompose",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_decompose",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Matrix4x4_decompose",3,SWIGTYPE_p_ofQuaternion); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_decompose",4,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Matrix4x4_decompose",5,SWIGTYPE_p_ofQuaternion); } - ((ofMatrix4x4 const *)arg1)->decompose(*arg2,*arg3,*arg4,*arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Matrix4x4_getInverseOf(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = 0 ; ofMatrix4x4 result; - SWIG_check_num_args("ofMatrix4x4::getInverseOf",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofMatrix4x4::getInverseOf",1,"ofMatrix4x4 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_getInverseOf",1,SWIGTYPE_p_ofMatrix4x4); } - result = ofMatrix4x4::getInverseOf((ofMatrix4x4 const &)*arg1); { - ofMatrix4x4 * resultptr = new ofMatrix4x4((const ofMatrix4x4 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_getTransposedOf(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = 0 ; ofMatrix4x4 result; - SWIG_check_num_args("ofMatrix4x4::getTransposedOf",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofMatrix4x4::getTransposedOf",1,"ofMatrix4x4 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_getTransposedOf",1,SWIGTYPE_p_ofMatrix4x4); } - result = ofMatrix4x4::getTransposedOf((ofMatrix4x4 const &)*arg1); { - ofMatrix4x4 * resultptr = new ofMatrix4x4((const ofMatrix4x4 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_getOrthoNormalOf(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = 0 ; ofMatrix4x4 result; - SWIG_check_num_args("ofMatrix4x4::getOrthoNormalOf",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofMatrix4x4::getOrthoNormalOf",1,"ofMatrix4x4 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_getOrthoNormalOf",1,SWIGTYPE_p_ofMatrix4x4); } - result = ofMatrix4x4::getOrthoNormalOf((ofMatrix4x4 const &)*arg1); { - ofMatrix4x4 * resultptr = new ofMatrix4x4((const ofMatrix4x4 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_postMult__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofVec3f *arg2 = 0 ; ofVec3f result; SWIG_check_num_args("ofMatrix4x4::postMult",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::postMult",1,"ofMatrix4x4 const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::postMult",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_postMult",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_postMult",2,SWIGTYPE_p_ofVec3f); } - result = ((ofMatrix4x4 const *)arg1)->postMult((ofVec3f const &)*arg2); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_postMult__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofVec4f *arg2 = 0 ; ofVec4f result; SWIG_check_num_args("ofMatrix4x4::postMult",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::postMult",1,"ofMatrix4x4 const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::postMult",2,"ofVec4f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_postMult",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec4f,0))){ - SWIG_fail_ptr("Matrix4x4_postMult",2,SWIGTYPE_p_ofVec4f); } - result = ((ofMatrix4x4 const *)arg1)->postMult((ofVec4f const &)*arg2); { - ofVec4f * resultptr = new ofVec4f((const ofVec4f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec4f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_postMult__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofMatrix4x4 *arg2 = 0 ; SWIG_check_num_args("ofMatrix4x4::postMult",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::postMult",1,"ofMatrix4x4 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::postMult",2,"ofMatrix4x4 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_postMult",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_postMult",2,SWIGTYPE_p_ofMatrix4x4); } (arg1)->postMult((ofMatrix4x4 const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_postMult(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_postMult__SWIG_0(L);} } } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_postMult__SWIG_1(L);} } } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_postMult__SWIG_2(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4_postMult'\n" " Possible C/C++ prototypes are:\n" - " ofMatrix4x4::postMult(ofVec3f const &) const\n" " ofMatrix4x4::postMult(ofVec4f const &) const\n" - " ofMatrix4x4::postMult(ofMatrix4x4 const &)\n"); lua_error(L);return 0; } -static int _wrap_Matrix4x4_preMult__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofVec3f *arg2 = 0 ; ofVec3f result; SWIG_check_num_args("ofMatrix4x4::preMult",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::preMult",1,"ofMatrix4x4 const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::preMult",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_preMult",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_preMult",2,SWIGTYPE_p_ofVec3f); } - result = ((ofMatrix4x4 const *)arg1)->preMult((ofVec3f const &)*arg2); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_preMult__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofVec4f *arg2 = 0 ; ofVec4f result; SWIG_check_num_args("ofMatrix4x4::preMult",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::preMult",1,"ofMatrix4x4 const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::preMult",2,"ofVec4f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_preMult",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec4f,0))){ - SWIG_fail_ptr("Matrix4x4_preMult",2,SWIGTYPE_p_ofVec4f); } - result = ((ofMatrix4x4 const *)arg1)->preMult((ofVec4f const &)*arg2); { - ofVec4f * resultptr = new ofVec4f((const ofVec4f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec4f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_preMult__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofMatrix4x4 *arg2 = 0 ; SWIG_check_num_args("ofMatrix4x4::preMult",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::preMult",1,"ofMatrix4x4 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::preMult",2,"ofMatrix4x4 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_preMult",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_preMult",2,SWIGTYPE_p_ofMatrix4x4); } (arg1)->preMult((ofMatrix4x4 const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_preMult(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_preMult__SWIG_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_preMult__SWIG_1(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_preMult__SWIG_2(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4_preMult'\n" " Possible C/C++ prototypes are:\n" - " ofMatrix4x4::preMult(ofVec3f const &) const\n" " ofMatrix4x4::preMult(ofVec4f const &) const\n" - " ofMatrix4x4::preMult(ofMatrix4x4 const &)\n"); lua_error(L);return 0; } -static int _wrap_Matrix4x4___mul__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofMatrix4x4 *arg2 = 0 ; ofMatrix4x4 result; SWIG_check_num_args("ofMatrix4x4::operator *",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::operator *",1,"ofMatrix4x4 const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::operator *",2,"ofMatrix4x4 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4___mul",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4___mul",2,SWIGTYPE_p_ofMatrix4x4); } - result = ((ofMatrix4x4 const *)arg1)->operator *((ofMatrix4x4 const &)*arg2); { - ofMatrix4x4 * resultptr = new ofMatrix4x4((const ofMatrix4x4 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4___mul__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofVec3f *arg2 = 0 ; ofVec3f result; SWIG_check_num_args("ofMatrix4x4::operator *",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::operator *",1,"ofMatrix4x4 const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::operator *",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4___mul",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4___mul",2,SWIGTYPE_p_ofVec3f); } - result = ((ofMatrix4x4 const *)arg1)->operator *((ofVec3f const &)*arg2); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4___mul__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofVec4f *arg2 = 0 ; ofVec4f result; SWIG_check_num_args("ofMatrix4x4::operator *",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::operator *",1,"ofMatrix4x4 const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::operator *",2,"ofVec4f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4___mul",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec4f,0))){ - SWIG_fail_ptr("Matrix4x4___mul",2,SWIGTYPE_p_ofVec4f); } - result = ((ofMatrix4x4 const *)arg1)->operator *((ofVec4f const &)*arg2); { - ofVec4f * resultptr = new ofVec4f((const ofVec4f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec4f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4___mul(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4___mul__SWIG_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4___mul__SWIG_1(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4___mul__SWIG_2(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4___mul'\n" " Possible C/C++ prototypes are:\n" - " ofMatrix4x4::operator *(ofMatrix4x4 const &) const\n" " ofMatrix4x4::operator *(ofVec3f const &) const\n" - " ofMatrix4x4::operator *(ofVec4f const &) const\n"); lua_error(L);return 0; } -static int _wrap_Matrix4x4_postMultTranslate__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofVec3f *arg2 = 0 ; SWIG_check_num_args("ofMatrix4x4::postMultTranslate",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::postMultTranslate",1,"ofMatrix4x4 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::postMultTranslate",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_postMultTranslate",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_postMultTranslate",2,SWIGTYPE_p_ofVec3f); } (arg1)->postMultTranslate((ofVec3f const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_postMultScale__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofVec3f *arg2 = 0 ; SWIG_check_num_args("ofMatrix4x4::postMultScale",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::postMultScale",1,"ofMatrix4x4 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::postMultScale",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_postMultScale",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_postMultScale",2,SWIGTYPE_p_ofVec3f); } (arg1)->postMultScale((ofVec3f const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_postMultRotate__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofQuaternion *arg2 = 0 ; SWIG_check_num_args("ofMatrix4x4::postMultRotate",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::postMultRotate",1,"ofMatrix4x4 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::postMultRotate",2,"ofQuaternion const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_postMultRotate",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Matrix4x4_postMultRotate",2,SWIGTYPE_p_ofQuaternion); } (arg1)->postMultRotate((ofQuaternion const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_postMultTranslate__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - float arg2 ; float arg3 ; float arg4 ; SWIG_check_num_args("ofMatrix4x4::postMultTranslate",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::postMultTranslate",1,"ofMatrix4x4 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::postMultTranslate",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix4x4::postMultTranslate",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix4x4::postMultTranslate",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_postMultTranslate",1,SWIGTYPE_p_ofMatrix4x4); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); (arg1)->postMultTranslate(arg2,arg3,arg4); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_postMultTranslate(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_postMultTranslate__SWIG_0(L);} } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Matrix4x4_postMultTranslate__SWIG_1(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4_postMultTranslate'\n" - " Possible C/C++ prototypes are:\n" " ofMatrix4x4::postMultTranslate(ofVec3f const &)\n" - " ofMatrix4x4::postMultTranslate(float,float,float)\n"); lua_error(L);return 0; } -static int _wrap_Matrix4x4_postMultRotate__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - float arg2 ; float arg3 ; float arg4 ; float arg5 ; SWIG_check_num_args("ofMatrix4x4::postMultRotate",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::postMultRotate",1,"ofMatrix4x4 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::postMultRotate",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix4x4::postMultRotate",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix4x4::postMultRotate",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMatrix4x4::postMultRotate",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_postMultRotate",1,SWIGTYPE_p_ofMatrix4x4); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - (arg1)->postMultRotate(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_postMultRotate(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_postMultRotate__SWIG_0(L);} } } if (argc == 5) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Matrix4x4_postMultRotate__SWIG_1(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4_postMultRotate'\n" - " Possible C/C++ prototypes are:\n" " ofMatrix4x4::postMultRotate(ofQuaternion const &)\n" - " ofMatrix4x4::postMultRotate(float,float,float,float)\n"); lua_error(L);return 0; } -static int _wrap_Matrix4x4_postMultScale__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - float arg2 ; float arg3 ; float arg4 ; SWIG_check_num_args("ofMatrix4x4::postMultScale",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::postMultScale",1,"ofMatrix4x4 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::postMultScale",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix4x4::postMultScale",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix4x4::postMultScale",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_postMultScale",1,SWIGTYPE_p_ofMatrix4x4); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); (arg1)->postMultScale(arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_postMultScale(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_postMultScale__SWIG_0(L);} } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Matrix4x4_postMultScale__SWIG_1(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4_postMultScale'\n" - " Possible C/C++ prototypes are:\n" " ofMatrix4x4::postMultScale(ofVec3f const &)\n" - " ofMatrix4x4::postMultScale(float,float,float)\n"); lua_error(L);return 0; } -static int _wrap_Matrix4x4_preMultScale(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofVec3f *arg2 = 0 ; SWIG_check_num_args("ofMatrix4x4::preMultScale",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::preMultScale",1,"ofMatrix4x4 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::preMultScale",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_preMultScale",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_preMultScale",2,SWIGTYPE_p_ofVec3f); } (arg1)->preMultScale((ofVec3f const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_preMultTranslate(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofVec3f *arg2 = 0 ; SWIG_check_num_args("ofMatrix4x4::preMultTranslate",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::preMultTranslate",1,"ofMatrix4x4 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::preMultTranslate",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_preMultTranslate",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_preMultTranslate",2,SWIGTYPE_p_ofVec3f); } (arg1)->preMultTranslate((ofVec3f const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_preMultRotate(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofQuaternion *arg2 = 0 ; SWIG_check_num_args("ofMatrix4x4::preMultRotate",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::preMultRotate",1,"ofMatrix4x4 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::preMultRotate",2,"ofQuaternion const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_preMultRotate",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Matrix4x4_preMultRotate",2,SWIGTYPE_p_ofQuaternion); } (arg1)->preMultRotate((ofQuaternion const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_setRotate(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofQuaternion *arg2 = 0 ; SWIG_check_num_args("ofMatrix4x4::setRotate",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::setRotate",1,"ofMatrix4x4 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::setRotate",2,"ofQuaternion const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_setRotate",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Matrix4x4_setRotate",2,SWIGTYPE_p_ofQuaternion); } (arg1)->setRotate((ofQuaternion const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_setTranslation__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - float arg2 ; float arg3 ; float arg4 ; SWIG_check_num_args("ofMatrix4x4::setTranslation",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::setTranslation",1,"ofMatrix4x4 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::setTranslation",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix4x4::setTranslation",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix4x4::setTranslation",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_setTranslation",1,SWIGTYPE_p_ofMatrix4x4); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); (arg1)->setTranslation(arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_setTranslation__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofVec3f *arg2 = 0 ; SWIG_check_num_args("ofMatrix4x4::setTranslation",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::setTranslation",1,"ofMatrix4x4 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::setTranslation",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_setTranslation",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_setTranslation",2,SWIGTYPE_p_ofVec3f); } (arg1)->setTranslation((ofVec3f const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_setTranslation(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_setTranslation__SWIG_1(L);} } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Matrix4x4_setTranslation__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4_setTranslation'\n" - " Possible C/C++ prototypes are:\n" " ofMatrix4x4::setTranslation(float,float,float)\n" - " ofMatrix4x4::setTranslation(ofVec3f const &)\n"); lua_error(L);return 0; } -static int _wrap_Matrix4x4_rotate__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; float arg2 ; - float arg3 ; float arg4 ; float arg5 ; SWIG_check_num_args("ofMatrix4x4::rotate",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::rotate",1,"ofMatrix4x4 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::rotate",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix4x4::rotate",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix4x4::rotate",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMatrix4x4::rotate",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_rotate",1,SWIGTYPE_p_ofMatrix4x4); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - (arg1)->rotate(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_rotateRad(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; float arg2 ; - float arg3 ; float arg4 ; float arg5 ; SWIG_check_num_args("ofMatrix4x4::rotateRad",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::rotateRad",1,"ofMatrix4x4 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::rotateRad",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix4x4::rotateRad",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix4x4::rotateRad",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMatrix4x4::rotateRad",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_rotateRad",1,SWIGTYPE_p_ofMatrix4x4); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - (arg1)->rotateRad(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_rotate__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofQuaternion *arg2 = 0 ; SWIG_check_num_args("ofMatrix4x4::rotate",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::rotate",1,"ofMatrix4x4 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::rotate",2,"ofQuaternion const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_rotate",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Matrix4x4_rotate",2,SWIGTYPE_p_ofQuaternion); } (arg1)->rotate((ofQuaternion const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_rotate(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_rotate__SWIG_1(L);} } } if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Matrix4x4_rotate__SWIG_0(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4_rotate'\n" " Possible C/C++ prototypes are:\n" - " ofMatrix4x4::rotate(float,float,float,float)\n" " ofMatrix4x4::rotate(ofQuaternion const &)\n"); - lua_error(L);return 0; } -static int _wrap_Matrix4x4_translate__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - float arg2 ; float arg3 ; float arg4 ; SWIG_check_num_args("ofMatrix4x4::translate",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::translate",1,"ofMatrix4x4 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::translate",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix4x4::translate",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix4x4::translate",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_translate",1,SWIGTYPE_p_ofMatrix4x4); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); (arg1)->translate(arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_translate__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofVec3f *arg2 = 0 ; SWIG_check_num_args("ofMatrix4x4::translate",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::translate",1,"ofMatrix4x4 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::translate",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_translate",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_translate",2,SWIGTYPE_p_ofVec3f); } (arg1)->translate((ofVec3f const &)*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_translate(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_translate__SWIG_1(L);} } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Matrix4x4_translate__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4_translate'\n" - " Possible C/C++ prototypes are:\n" " ofMatrix4x4::translate(float,float,float)\n" - " ofMatrix4x4::translate(ofVec3f const &)\n"); lua_error(L);return 0; } -static int _wrap_Matrix4x4_scale__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; float arg2 ; - float arg3 ; float arg4 ; SWIG_check_num_args("ofMatrix4x4::scale",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::scale",1,"ofMatrix4x4 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::scale",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix4x4::scale",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix4x4::scale",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_scale",1,SWIGTYPE_p_ofMatrix4x4); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); (arg1)->scale(arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_scale__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofVec3f *arg2 = 0 ; SWIG_check_num_args("ofMatrix4x4::scale",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::scale",1,"ofMatrix4x4 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::scale",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_scale",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_scale",2,SWIGTYPE_p_ofVec3f); } (arg1)->scale((ofVec3f const &)*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_scale(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_scale__SWIG_1(L);} } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Matrix4x4_scale__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4_scale'\n" " Possible C/C++ prototypes are:\n" - " ofMatrix4x4::scale(float,float,float)\n" " ofMatrix4x4::scale(ofVec3f const &)\n"); lua_error(L);return 0; } -static int _wrap_Matrix4x4_glRotate__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - float arg2 ; float arg3 ; float arg4 ; float arg5 ; SWIG_check_num_args("ofMatrix4x4::glRotate",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::glRotate",1,"ofMatrix4x4 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::glRotate",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix4x4::glRotate",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix4x4::glRotate",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMatrix4x4::glRotate",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_glRotate",1,SWIGTYPE_p_ofMatrix4x4); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - (arg1)->glRotate(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_glRotateRad(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; float arg2 ; - float arg3 ; float arg4 ; float arg5 ; SWIG_check_num_args("ofMatrix4x4::glRotateRad",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::glRotateRad",1,"ofMatrix4x4 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::glRotateRad",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix4x4::glRotateRad",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix4x4::glRotateRad",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMatrix4x4::glRotateRad",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_glRotateRad",1,SWIGTYPE_p_ofMatrix4x4); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - (arg1)->glRotateRad(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_glRotate__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofQuaternion *arg2 = 0 ; SWIG_check_num_args("ofMatrix4x4::glRotate",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::glRotate",1,"ofMatrix4x4 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::glRotate",2,"ofQuaternion const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_glRotate",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Matrix4x4_glRotate",2,SWIGTYPE_p_ofQuaternion); } (arg1)->glRotate((ofQuaternion const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_glRotate(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_glRotate__SWIG_1(L);} } } if (argc == 5) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Matrix4x4_glRotate__SWIG_0(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4_glRotate'\n" " Possible C/C++ prototypes are:\n" - " ofMatrix4x4::glRotate(float,float,float,float)\n" " ofMatrix4x4::glRotate(ofQuaternion const &)\n"); - lua_error(L);return 0; } -static int _wrap_Matrix4x4_glTranslate__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - float arg2 ; float arg3 ; float arg4 ; SWIG_check_num_args("ofMatrix4x4::glTranslate",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::glTranslate",1,"ofMatrix4x4 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::glTranslate",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix4x4::glTranslate",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix4x4::glTranslate",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_glTranslate",1,SWIGTYPE_p_ofMatrix4x4); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); (arg1)->glTranslate(arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_glTranslate__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofVec3f *arg2 = 0 ; SWIG_check_num_args("ofMatrix4x4::glTranslate",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::glTranslate",1,"ofMatrix4x4 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::glTranslate",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_glTranslate",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_glTranslate",2,SWIGTYPE_p_ofVec3f); } (arg1)->glTranslate((ofVec3f const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_glTranslate(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_glTranslate__SWIG_1(L);} } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Matrix4x4_glTranslate__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4_glTranslate'\n" - " Possible C/C++ prototypes are:\n" " ofMatrix4x4::glTranslate(float,float,float)\n" - " ofMatrix4x4::glTranslate(ofVec3f const &)\n"); lua_error(L);return 0; } -static int _wrap_Matrix4x4_glScale__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - float arg2 ; float arg3 ; float arg4 ; SWIG_check_num_args("ofMatrix4x4::glScale",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::glScale",1,"ofMatrix4x4 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::glScale",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix4x4::glScale",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix4x4::glScale",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_glScale",1,SWIGTYPE_p_ofMatrix4x4); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); (arg1)->glScale(arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_glScale__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofVec3f *arg2 = 0 ; SWIG_check_num_args("ofMatrix4x4::glScale",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::glScale",1,"ofMatrix4x4 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::glScale",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_glScale",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_glScale",2,SWIGTYPE_p_ofVec3f); } (arg1)->glScale((ofVec3f const &)*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_glScale(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_glScale__SWIG_1(L);} } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Matrix4x4_glScale__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4_glScale'\n" " Possible C/C++ prototypes are:\n" - " ofMatrix4x4::glScale(float,float,float)\n" " ofMatrix4x4::glScale(ofVec3f const &)\n"); lua_error(L);return 0; } -static int _wrap_Matrix4x4_getRotate(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofQuaternion result; SWIG_check_num_args("ofMatrix4x4::getRotate",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::getRotate",1,"ofMatrix4x4 const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_getRotate",1,SWIGTYPE_p_ofMatrix4x4); } result = ((ofMatrix4x4 const *)arg1)->getRotate(); { - ofQuaternion * resultptr = new ofQuaternion((const ofQuaternion &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofQuaternion,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_getTranslation(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofVec3f result; SWIG_check_num_args("ofMatrix4x4::getTranslation",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::getTranslation",1,"ofMatrix4x4 const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_getTranslation",1,SWIGTYPE_p_ofMatrix4x4); } - result = ((ofMatrix4x4 const *)arg1)->getTranslation(); { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_getScale(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; ofVec3f result; - SWIG_check_num_args("ofMatrix4x4::getScale",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::getScale",1,"ofMatrix4x4 const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_getScale",1,SWIGTYPE_p_ofMatrix4x4); } result = ((ofMatrix4x4 const *)arg1)->getScale(); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_transform3x3__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = 0 ; ofMatrix4x4 *arg2 = 0 ; - ofVec3f result; SWIG_check_num_args("ofMatrix4x4::transform3x3",2,2) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofMatrix4x4::transform3x3",1,"ofVec3f const &"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::transform3x3",2,"ofMatrix4x4 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_transform3x3",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_transform3x3",2,SWIGTYPE_p_ofMatrix4x4); } - result = ofMatrix4x4::transform3x3((ofVec3f const &)*arg1,(ofMatrix4x4 const &)*arg2); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_transform3x3__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = 0 ; ofVec3f *arg2 = 0 ; - ofVec3f result; SWIG_check_num_args("ofMatrix4x4::transform3x3",2,2) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofMatrix4x4::transform3x3",1,"ofMatrix4x4 const &"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::transform3x3",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_transform3x3",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_transform3x3",2,SWIGTYPE_p_ofVec3f); } - result = ofMatrix4x4::transform3x3((ofMatrix4x4 const &)*arg1,(ofVec3f const &)*arg2); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_transform3x3(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_transform3x3__SWIG_0(L);} } } if (argc == 2) { int _v; { - void *ptr; if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_transform3x3__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4_transform3x3'\n" - " Possible C/C++ prototypes are:\n" " ofMatrix4x4::transform3x3(ofVec3f const &,ofMatrix4x4 const &)\n" - " ofMatrix4x4::transform3x3(ofMatrix4x4 const &,ofVec3f const &)\n"); lua_error(L);return 0; } -static int _wrap_Matrix4x4___tostring(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - char *result = 0 ; SWIG_check_num_args("ofMatrix4x4::__str__",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::__str__",1,"ofMatrix4x4 *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4___tostring",1,SWIGTYPE_p_ofMatrix4x4); } result = (char *)ofMatrix4x4___str__(arg1); - lua_pushstring(L,(const char *)result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_Matrix4x4(void *obj) { -ofMatrix4x4 *arg1 = (ofMatrix4x4 *) obj; -delete arg1; -} -static int _proxy__wrap_new_Matrix4x4(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_Matrix4x4); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_Matrix4x4_attributes[] = { - { "_mat", _wrap_Matrix4x4__mat_get, _wrap_Matrix4x4__mat_set }, - {0,0,0} -}; -static swig_lua_method swig_Matrix4x4_methods[]= { - { "makeIdentityMatrix", _wrap_Matrix4x4_makeIdentityMatrix}, - { "makeScaleMatrix", _wrap_Matrix4x4_makeScaleMatrix}, - { "makeTranslationMatrix", _wrap_Matrix4x4_makeTranslationMatrix}, - { "makeRotationMatrix", _wrap_Matrix4x4_makeRotationMatrix}, - { "makeInvertOf", _wrap_Matrix4x4_makeInvertOf}, - { "makeOrthoNormalOf", _wrap_Matrix4x4_makeOrthoNormalOf}, - { "makeFromMultiplicationOf", _wrap_Matrix4x4_makeFromMultiplicationOf}, - { "makeOrthoMatrix", _wrap_Matrix4x4_makeOrthoMatrix}, - { "makeOrtho2DMatrix", _wrap_Matrix4x4_makeOrtho2DMatrix}, - { "makeFrustumMatrix", _wrap_Matrix4x4_makeFrustumMatrix}, - { "makePerspectiveMatrix", _wrap_Matrix4x4_makePerspectiveMatrix}, - { "makeLookAtMatrix", _wrap_Matrix4x4_makeLookAtMatrix}, - { "makeLookAtViewMatrix", _wrap_Matrix4x4_makeLookAtViewMatrix}, - { "__call", _wrap_Matrix4x4___call}, - { "getRowAsVec3f", _wrap_Matrix4x4_getRowAsVec3f}, - { "getRowAsVec4f", _wrap_Matrix4x4_getRowAsVec4f}, - { "getPtr", _wrap_Matrix4x4_getPtr}, - { "isValid", _wrap_Matrix4x4_isValid}, - { "isNaN", _wrap_Matrix4x4_isNaN}, - { "isIdentity", _wrap_Matrix4x4_isIdentity}, - { "set", _wrap_Matrix4x4_set}, - { "getInverse", _wrap_Matrix4x4_getInverse}, - { "getOrtho", _wrap_Matrix4x4_getOrtho}, - { "getFrustum", _wrap_Matrix4x4_getFrustum}, - { "getPerspective", _wrap_Matrix4x4_getPerspective}, - { "getLookAt", _wrap_Matrix4x4_getLookAt}, - { "decompose", _wrap_Matrix4x4_decompose}, - { "postMult", _wrap_Matrix4x4_postMult}, - { "preMult", _wrap_Matrix4x4_preMult}, - { "__mul", _wrap_Matrix4x4___mul}, - { "postMultTranslate", _wrap_Matrix4x4_postMultTranslate}, - { "postMultRotate", _wrap_Matrix4x4_postMultRotate}, - { "postMultScale", _wrap_Matrix4x4_postMultScale}, - { "preMultScale", _wrap_Matrix4x4_preMultScale}, - { "preMultTranslate", _wrap_Matrix4x4_preMultTranslate}, - { "preMultRotate", _wrap_Matrix4x4_preMultRotate}, - { "setRotate", _wrap_Matrix4x4_setRotate}, - { "setTranslation", _wrap_Matrix4x4_setTranslation}, - { "rotateRad", _wrap_Matrix4x4_rotateRad}, - { "rotate", _wrap_Matrix4x4_rotate}, - { "translate", _wrap_Matrix4x4_translate}, - { "scale", _wrap_Matrix4x4_scale}, - { "glRotateRad", _wrap_Matrix4x4_glRotateRad}, - { "glRotate", _wrap_Matrix4x4_glRotate}, - { "glTranslate", _wrap_Matrix4x4_glTranslate}, - { "glScale", _wrap_Matrix4x4_glScale}, - { "getRotate", _wrap_Matrix4x4_getRotate}, - { "getTranslation", _wrap_Matrix4x4_getTranslation}, - { "getScale", _wrap_Matrix4x4_getScale}, - { "__tostring", _wrap_Matrix4x4___tostring}, - {0,0} -}; -static swig_lua_method swig_Matrix4x4_meta[] = { - { "__call", _wrap_Matrix4x4___call}, - { "__mul", _wrap_Matrix4x4___mul}, - { "__tostring", _wrap_Matrix4x4___tostring}, - {0,0} -}; - -static swig_lua_attribute swig_Matrix4x4_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_Matrix4x4_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_Matrix4x4_Sf_SwigStatic_methods[]= { - { "newIdentityMatrix", _wrap_Matrix4x4_newIdentityMatrix}, - { "newScaleMatrix", _wrap_Matrix4x4_newScaleMatrix}, - { "newTranslationMatrix", _wrap_Matrix4x4_newTranslationMatrix}, - { "newRotationMatrix", _wrap_Matrix4x4_newRotationMatrix}, - { "newOrthoMatrix", _wrap_Matrix4x4_newOrthoMatrix}, - { "newOrtho2DMatrix", _wrap_Matrix4x4_newOrtho2DMatrix}, - { "newFrustumMatrix", _wrap_Matrix4x4_newFrustumMatrix}, - { "newPerspectiveMatrix", _wrap_Matrix4x4_newPerspectiveMatrix}, - { "newLookAtMatrix", _wrap_Matrix4x4_newLookAtMatrix}, - { "getInverseOf", _wrap_Matrix4x4_getInverseOf}, - { "getTransposedOf", _wrap_Matrix4x4_getTransposedOf}, - { "getOrthoNormalOf", _wrap_Matrix4x4_getOrthoNormalOf}, - { "transform3x3", _wrap_Matrix4x4_transform3x3}, - {0,0} -}; -static swig_lua_class* swig_Matrix4x4_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_Matrix4x4_Sf_SwigStatic = { - "Matrix4x4", - swig_Matrix4x4_Sf_SwigStatic_methods, - swig_Matrix4x4_Sf_SwigStatic_attributes, - swig_Matrix4x4_Sf_SwigStatic_constants, - swig_Matrix4x4_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_Matrix4x4_bases[] = {0}; -static const char *swig_Matrix4x4_base_names[] = {0}; -static swig_lua_class _wrap_class_Matrix4x4 = { "Matrix4x4", "Matrix4x4", &SWIGTYPE_p_ofMatrix4x4,_proxy__wrap_new_Matrix4x4, swig_delete_Matrix4x4, swig_Matrix4x4_methods, swig_Matrix4x4_attributes, &swig_Matrix4x4_Sf_SwigStatic, swig_Matrix4x4_meta, swig_Matrix4x4_bases, swig_Matrix4x4_base_names }; - -static int _wrap_Quaternion__v_set(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; - ofVec4f *arg2 = (ofVec4f *) 0 ; SWIG_check_num_args("ofQuaternion::_v",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::_v",1,"ofQuaternion *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofQuaternion::_v",2,"ofVec4f *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion__v_set",1,SWIGTYPE_p_ofQuaternion); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec4f,0))){ - SWIG_fail_ptr("Quaternion__v_set",2,SWIGTYPE_p_ofVec4f); } if (arg1) (arg1)->_v = *arg2; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Quaternion__v_get(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; - ofVec4f *result = 0 ; SWIG_check_num_args("ofQuaternion::_v",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::_v",1,"ofQuaternion *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion__v_get",1,SWIGTYPE_p_ofQuaternion); } result = (ofVec4f *)& ((arg1)->_v); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec4f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Quaternion__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofQuaternion *result = 0 ; - SWIG_check_num_args("ofQuaternion::ofQuaternion",0,0) result = (ofQuaternion *)new ofQuaternion(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofQuaternion,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Quaternion__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - ofQuaternion *result = 0 ; SWIG_check_num_args("ofQuaternion::ofQuaternion",4,4) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofQuaternion::ofQuaternion",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofQuaternion::ofQuaternion",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofQuaternion::ofQuaternion",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofQuaternion::ofQuaternion",4,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - result = (ofQuaternion *)new ofQuaternion(arg1,arg2,arg3,arg4); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofQuaternion,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Quaternion__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = 0 ; ofQuaternion *result = 0 ; - SWIG_check_num_args("ofQuaternion::ofQuaternion",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofQuaternion::ofQuaternion",1,"ofVec4f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ - SWIG_fail_ptr("new_Quaternion",1,SWIGTYPE_p_ofVec4f); } result = (ofQuaternion *)new ofQuaternion((ofVec4f const &)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofQuaternion,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Quaternion__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; ofVec3f *arg2 = 0 ; - ofQuaternion *result = 0 ; SWIG_check_num_args("ofQuaternion::ofQuaternion",2,2) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofQuaternion::ofQuaternion",1,"float"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofQuaternion::ofQuaternion",2,"ofVec3f const &"); arg1 = (float)lua_tonumber(L, 1); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("new_Quaternion",2,SWIGTYPE_p_ofVec3f); } - result = (ofQuaternion *)new ofQuaternion(arg1,(ofVec3f const &)*arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofQuaternion,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Quaternion__SWIG_4(lua_State* L) { int SWIG_arg = 0; float arg1 ; ofVec3f *arg2 = 0 ; float arg3 ; - ofVec3f *arg4 = 0 ; float arg5 ; ofVec3f *arg6 = 0 ; ofQuaternion *result = 0 ; - SWIG_check_num_args("ofQuaternion::ofQuaternion",6,6) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofQuaternion::ofQuaternion",1,"float"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofQuaternion::ofQuaternion",2,"ofVec3f const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofQuaternion::ofQuaternion",3,"float"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofQuaternion::ofQuaternion",4,"ofVec3f const &"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofQuaternion::ofQuaternion",5,"float"); - if(!lua_isuserdata(L,6)) SWIG_fail_arg("ofQuaternion::ofQuaternion",6,"ofVec3f const &"); arg1 = (float)lua_tonumber(L, 1); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("new_Quaternion",2,SWIGTYPE_p_ofVec3f); } arg3 = (float)lua_tonumber(L, 3); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("new_Quaternion",4,SWIGTYPE_p_ofVec3f); } arg5 = (float)lua_tonumber(L, 5); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,6,(void**)&arg6,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("new_Quaternion",6,SWIGTYPE_p_ofVec3f); } - result = (ofQuaternion *)new ofQuaternion(arg1,(ofVec3f const &)*arg2,arg3,(ofVec3f const &)*arg4,arg5,(ofVec3f const &)*arg6); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofQuaternion,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Quaternion(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_Quaternion__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_new_Quaternion__SWIG_2(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_new_Quaternion__SWIG_3(L);} } } if (argc == 4) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_new_Quaternion__SWIG_1(L);} } } } } - if (argc == 6) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[5])==0 || SWIG_ConvertPtr(L,argv[5], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_new_Quaternion__SWIG_4(L);} } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_Quaternion'\n" " Possible C/C++ prototypes are:\n" - " ofQuaternion::ofQuaternion()\n" " ofQuaternion::ofQuaternion(float,float,float,float)\n" - " ofQuaternion::ofQuaternion(ofVec4f const &)\n" " ofQuaternion::ofQuaternion(float,ofVec3f const &)\n" - " ofQuaternion::ofQuaternion(float,ofVec3f const &,float,ofVec3f const &,float,ofVec3f const &)\n"); - lua_error(L);return 0; } -static int _wrap_Quaternion_set__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; float arg2 ; - float arg3 ; float arg4 ; float arg5 ; SWIG_check_num_args("ofQuaternion::set",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::set",1,"ofQuaternion *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofQuaternion::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofQuaternion::set",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofQuaternion::set",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofQuaternion::set",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion_set",1,SWIGTYPE_p_ofQuaternion); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - (arg1)->set(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Quaternion_set__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; - ofVec4f *arg2 = 0 ; SWIG_check_num_args("ofQuaternion::set",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::set",1,"ofQuaternion *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofQuaternion::set",2,"ofVec4f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion_set",1,SWIGTYPE_p_ofQuaternion); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec4f,0))){ - SWIG_fail_ptr("Quaternion_set",2,SWIGTYPE_p_ofVec4f); } (arg1)->set((ofVec4f const &)*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Quaternion_set__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; - ofMatrix4x4 *arg2 = 0 ; SWIG_check_num_args("ofQuaternion::set",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::set",1,"ofQuaternion *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofQuaternion::set",2,"ofMatrix4x4 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion_set",1,SWIGTYPE_p_ofQuaternion); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Quaternion_set",2,SWIGTYPE_p_ofMatrix4x4); } (arg1)->set((ofMatrix4x4 const &)*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Quaternion_set(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Quaternion_set__SWIG_1(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Quaternion_set__SWIG_2(L);} } } if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Quaternion_set__SWIG_0(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Quaternion_set'\n" " Possible C/C++ prototypes are:\n" - " ofQuaternion::set(float,float,float,float)\n" " ofQuaternion::set(ofVec4f const &)\n" - " ofQuaternion::set(ofMatrix4x4 const &)\n"); lua_error(L);return 0; } -static int _wrap_Quaternion_get(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; - ofMatrix4x4 *arg2 = 0 ; SWIG_check_num_args("ofQuaternion::get",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::get",1,"ofQuaternion const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofQuaternion::get",2,"ofMatrix4x4 &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion_get",1,SWIGTYPE_p_ofQuaternion); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Quaternion_get",2,SWIGTYPE_p_ofMatrix4x4); } ((ofQuaternion const *)arg1)->get(*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Quaternion_x(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; float *result = 0 ; - SWIG_check_num_args("ofQuaternion::x",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::x",1,"ofQuaternion *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion_x",1,SWIGTYPE_p_ofQuaternion); } result = (float *) &(arg1)->x(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_float,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Quaternion_y(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; float *result = 0 ; - SWIG_check_num_args("ofQuaternion::y",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::y",1,"ofQuaternion *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion_y",1,SWIGTYPE_p_ofQuaternion); } result = (float *) &(arg1)->y(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_float,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Quaternion_z(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; float *result = 0 ; - SWIG_check_num_args("ofQuaternion::z",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::z",1,"ofQuaternion *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion_z",1,SWIGTYPE_p_ofQuaternion); } result = (float *) &(arg1)->z(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_float,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Quaternion_w(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; float *result = 0 ; - SWIG_check_num_args("ofQuaternion::w",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::w",1,"ofQuaternion *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion_w",1,SWIGTYPE_p_ofQuaternion); } result = (float *) &(arg1)->w(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_float,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Quaternion_asVec4(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; ofVec4f result; - SWIG_check_num_args("ofQuaternion::asVec4",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::asVec4",1,"ofQuaternion const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion_asVec4",1,SWIGTYPE_p_ofQuaternion); } result = ((ofQuaternion const *)arg1)->asVec4(); { - ofVec4f * resultptr = new ofVec4f((const ofVec4f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec4f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Quaternion_asVec3(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; ofVec3f result; - SWIG_check_num_args("ofQuaternion::asVec3",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::asVec3",1,"ofQuaternion const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion_asVec3",1,SWIGTYPE_p_ofQuaternion); } result = ((ofQuaternion const *)arg1)->asVec3(); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Quaternion_zeroRotation(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; - bool result; SWIG_check_num_args("ofQuaternion::zeroRotation",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::zeroRotation",1,"ofQuaternion const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion_zeroRotation",1,SWIGTYPE_p_ofQuaternion); } - result = (bool)((ofQuaternion const *)arg1)->zeroRotation(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Quaternion_length(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; float result; - SWIG_check_num_args("ofQuaternion::length",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::length",1,"ofQuaternion const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion_length",1,SWIGTYPE_p_ofQuaternion); } result = (float)((ofQuaternion const *)arg1)->length(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Quaternion_length2(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; float result; - SWIG_check_num_args("ofQuaternion::length2",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::length2",1,"ofQuaternion const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion_length2",1,SWIGTYPE_p_ofQuaternion); } result = (float)((ofQuaternion const *)arg1)->length2(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Quaternion_conj(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; - ofQuaternion result; SWIG_check_num_args("ofQuaternion::conj",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::conj",1,"ofQuaternion const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion_conj",1,SWIGTYPE_p_ofQuaternion); } result = ((ofQuaternion const *)arg1)->conj(); { - ofQuaternion * resultptr = new ofQuaternion((const ofQuaternion &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofQuaternion,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Quaternion_inverse(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; - ofQuaternion result; SWIG_check_num_args("ofQuaternion::inverse",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::inverse",1,"ofQuaternion const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion_inverse",1,SWIGTYPE_p_ofQuaternion); } result = ((ofQuaternion const *)arg1)->inverse(); { - ofQuaternion * resultptr = new ofQuaternion((const ofQuaternion &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofQuaternion,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Quaternion_makeRotate__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; - float arg2 ; float arg3 ; float arg4 ; float arg5 ; SWIG_check_num_args("ofQuaternion::makeRotate",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::makeRotate",1,"ofQuaternion *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofQuaternion::makeRotate",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofQuaternion::makeRotate",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofQuaternion::makeRotate",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofQuaternion::makeRotate",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion_makeRotate",1,SWIGTYPE_p_ofQuaternion); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - (arg1)->makeRotate(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Quaternion_makeRotate__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; - float arg2 ; ofVec3f *arg3 = 0 ; SWIG_check_num_args("ofQuaternion::makeRotate",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::makeRotate",1,"ofQuaternion *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofQuaternion::makeRotate",2,"float"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofQuaternion::makeRotate",3,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion_makeRotate",1,SWIGTYPE_p_ofQuaternion); } arg2 = (float)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Quaternion_makeRotate",3,SWIGTYPE_p_ofVec3f); } (arg1)->makeRotate(arg2,(ofVec3f const &)*arg3); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Quaternion_makeRotate__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; - float arg2 ; ofVec3f *arg3 = 0 ; float arg4 ; ofVec3f *arg5 = 0 ; float arg6 ; ofVec3f *arg7 = 0 ; - SWIG_check_num_args("ofQuaternion::makeRotate",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::makeRotate",1,"ofQuaternion *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofQuaternion::makeRotate",2,"float"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofQuaternion::makeRotate",3,"ofVec3f const &"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofQuaternion::makeRotate",4,"float"); - if(!lua_isuserdata(L,5)) SWIG_fail_arg("ofQuaternion::makeRotate",5,"ofVec3f const &"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofQuaternion::makeRotate",6,"float"); - if(!lua_isuserdata(L,7)) SWIG_fail_arg("ofQuaternion::makeRotate",7,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion_makeRotate",1,SWIGTYPE_p_ofQuaternion); } arg2 = (float)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Quaternion_makeRotate",3,SWIGTYPE_p_ofVec3f); } arg4 = (float)lua_tonumber(L, 4); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Quaternion_makeRotate",5,SWIGTYPE_p_ofVec3f); } arg6 = (float)lua_tonumber(L, 6); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,7,(void**)&arg7,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Quaternion_makeRotate",7,SWIGTYPE_p_ofVec3f); } - (arg1)->makeRotate(arg2,(ofVec3f const &)*arg3,arg4,(ofVec3f const &)*arg5,arg6,(ofVec3f const &)*arg7); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Quaternion_makeRotate__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; - ofVec3f *arg2 = 0 ; ofVec3f *arg3 = 0 ; SWIG_check_num_args("ofQuaternion::makeRotate",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::makeRotate",1,"ofQuaternion *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofQuaternion::makeRotate",2,"ofVec3f const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofQuaternion::makeRotate",3,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion_makeRotate",1,SWIGTYPE_p_ofQuaternion); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Quaternion_makeRotate",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Quaternion_makeRotate",3,SWIGTYPE_p_ofVec3f); } - (arg1)->makeRotate((ofVec3f const &)*arg2,(ofVec3f const &)*arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Quaternion_makeRotate(lua_State* L) { int argc; int argv[8]={ 1,2,3,4,5,6,7,8} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Quaternion_makeRotate__SWIG_3(L);} } } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Quaternion_makeRotate__SWIG_1(L);} } } } if (argc == 5) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Quaternion_makeRotate__SWIG_0(L);} } } } } } if (argc == 7) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[4])==0 || SWIG_ConvertPtr(L,argv[4], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[6])==0 || SWIG_ConvertPtr(L,argv[6], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Quaternion_makeRotate__SWIG_2(L);} } } } } } } - } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Quaternion_makeRotate'\n" - " Possible C/C++ prototypes are:\n" " ofQuaternion::makeRotate(float,float,float,float)\n" - " ofQuaternion::makeRotate(float,ofVec3f const &)\n" - " ofQuaternion::makeRotate(float,ofVec3f const &,float,ofVec3f const &,float,ofVec3f const &)\n" - " ofQuaternion::makeRotate(ofVec3f const &,ofVec3f const &)\n"); lua_error(L);return 0; } -static int _wrap_Quaternion_makeRotate_original(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; - ofVec3f *arg2 = 0 ; ofVec3f *arg3 = 0 ; SWIG_check_num_args("ofQuaternion::makeRotate_original",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::makeRotate_original",1,"ofQuaternion *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofQuaternion::makeRotate_original",2,"ofVec3f const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofQuaternion::makeRotate_original",3,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion_makeRotate_original",1,SWIGTYPE_p_ofQuaternion); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Quaternion_makeRotate_original",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Quaternion_makeRotate_original",3,SWIGTYPE_p_ofVec3f); } - (arg1)->makeRotate_original((ofVec3f const &)*arg2,(ofVec3f const &)*arg3); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Quaternion_getRotate__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; - float *arg2 = 0 ; float *arg3 = 0 ; float *arg4 = 0 ; float *arg5 = 0 ; SWIG_check_num_args("ofQuaternion::getRotate",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::getRotate",1,"ofQuaternion const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofQuaternion::getRotate",2,"float &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofQuaternion::getRotate",3,"float &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofQuaternion::getRotate",4,"float &"); - if(!lua_isuserdata(L,5)) SWIG_fail_arg("ofQuaternion::getRotate",5,"float &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion_getRotate",1,SWIGTYPE_p_ofQuaternion); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Quaternion_getRotate",2,SWIGTYPE_p_float); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Quaternion_getRotate",3,SWIGTYPE_p_float); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Quaternion_getRotate",4,SWIGTYPE_p_float); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Quaternion_getRotate",5,SWIGTYPE_p_float); } - ((ofQuaternion const *)arg1)->getRotate(*arg2,*arg3,*arg4,*arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Quaternion_getRotate__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; - float *arg2 = 0 ; ofVec3f *arg3 = 0 ; SWIG_check_num_args("ofQuaternion::getRotate",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::getRotate",1,"ofQuaternion const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofQuaternion::getRotate",2,"float &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofQuaternion::getRotate",3,"ofVec3f &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion_getRotate",1,SWIGTYPE_p_ofQuaternion); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Quaternion_getRotate",2,SWIGTYPE_p_float); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Quaternion_getRotate",3,SWIGTYPE_p_ofVec3f); } ((ofQuaternion const *)arg1)->getRotate(*arg2,*arg3); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Quaternion_getRotate(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Quaternion_getRotate__SWIG_1(L);} } } } if (argc == 5) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[4])==0 || SWIG_ConvertPtr(L,argv[4], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Quaternion_getRotate__SWIG_0(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Quaternion_getRotate'\n" - " Possible C/C++ prototypes are:\n" " ofQuaternion::getRotate(float &,float &,float &,float &) const\n" - " ofQuaternion::getRotate(float &,ofVec3f &) const\n"); lua_error(L);return 0; } -static int _wrap_Quaternion_getEuler(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; ofVec3f result; - SWIG_check_num_args("ofQuaternion::getEuler",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::getEuler",1,"ofQuaternion const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion_getEuler",1,SWIGTYPE_p_ofQuaternion); } result = ((ofQuaternion const *)arg1)->getEuler(); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Quaternion_slerp(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; float arg2 ; - ofQuaternion *arg3 = 0 ; ofQuaternion *arg4 = 0 ; SWIG_check_num_args("ofQuaternion::slerp",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::slerp",1,"ofQuaternion *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofQuaternion::slerp",2,"float"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofQuaternion::slerp",3,"ofQuaternion const &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofQuaternion::slerp",4,"ofQuaternion const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion_slerp",1,SWIGTYPE_p_ofQuaternion); } arg2 = (float)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion_slerp",3,SWIGTYPE_p_ofQuaternion); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion_slerp",4,SWIGTYPE_p_ofQuaternion); } - (arg1)->slerp(arg2,(ofQuaternion const &)*arg3,(ofQuaternion const &)*arg4); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Quaternion_normalize(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; - SWIG_check_num_args("ofQuaternion::normalize",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::normalize",1,"ofQuaternion *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion_normalize",1,SWIGTYPE_p_ofQuaternion); } (arg1)->normalize(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Quaternion___eq(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; - ofQuaternion *arg2 = 0 ; bool result; SWIG_check_num_args("ofQuaternion::operator ==",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::operator ==",1,"ofQuaternion const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofQuaternion::operator ==",2,"ofQuaternion const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion___eq",1,SWIGTYPE_p_ofQuaternion); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion___eq",2,SWIGTYPE_p_ofQuaternion); } - result = (bool)((ofQuaternion const *)arg1)->operator ==((ofQuaternion const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Quaternion___mul__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; - float arg2 ; ofQuaternion result; SWIG_check_num_args("ofQuaternion::operator *",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::operator *",1,"ofQuaternion const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofQuaternion::operator *",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion___mul",1,SWIGTYPE_p_ofQuaternion); } arg2 = (float)lua_tonumber(L, 2); - result = ((ofQuaternion const *)arg1)->operator *(arg2); { - ofQuaternion * resultptr = new ofQuaternion((const ofQuaternion &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofQuaternion,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Quaternion___mul__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; - ofQuaternion *arg2 = 0 ; ofQuaternion result; SWIG_check_num_args("ofQuaternion::operator *",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::operator *",1,"ofQuaternion const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofQuaternion::operator *",2,"ofQuaternion const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion___mul",1,SWIGTYPE_p_ofQuaternion); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion___mul",2,SWIGTYPE_p_ofQuaternion); } - result = ((ofQuaternion const *)arg1)->operator *((ofQuaternion const &)*arg2); { - ofQuaternion * resultptr = new ofQuaternion((const ofQuaternion &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofQuaternion,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Quaternion___mul__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; - ofVec3f *arg2 = 0 ; ofVec3f result; SWIG_check_num_args("ofQuaternion::operator *",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::operator *",1,"ofQuaternion const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofQuaternion::operator *",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion___mul",1,SWIGTYPE_p_ofQuaternion); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Quaternion___mul",2,SWIGTYPE_p_ofVec3f); } - result = ((ofQuaternion const *)arg1)->operator *((ofVec3f const &)*arg2); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Quaternion___mul(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Quaternion___mul__SWIG_1(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Quaternion___mul__SWIG_2(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Quaternion___mul__SWIG_0(L);} } - } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Quaternion___mul'\n" - " Possible C/C++ prototypes are:\n" " ofQuaternion::operator *(float) const\n" - " ofQuaternion::operator *(ofQuaternion const &) const\n" " ofQuaternion::operator *(ofVec3f const &) const\n"); - lua_error(L);return 0; } -static int _wrap_Quaternion___div__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; - float arg2 ; ofQuaternion result; SWIG_check_num_args("ofQuaternion::operator /",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::operator /",1,"ofQuaternion const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofQuaternion::operator /",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion___div",1,SWIGTYPE_p_ofQuaternion); } arg2 = (float)lua_tonumber(L, 2); - result = ((ofQuaternion const *)arg1)->operator /(arg2); { - ofQuaternion * resultptr = new ofQuaternion((const ofQuaternion &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofQuaternion,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Quaternion___div__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; - ofQuaternion *arg2 = 0 ; ofQuaternion result; SWIG_check_num_args("ofQuaternion::operator /",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::operator /",1,"ofQuaternion const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofQuaternion::operator /",2,"ofQuaternion const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion___div",1,SWIGTYPE_p_ofQuaternion); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion___div",2,SWIGTYPE_p_ofQuaternion); } - result = ((ofQuaternion const *)arg1)->operator /((ofQuaternion const &)*arg2); { - ofQuaternion * resultptr = new ofQuaternion((const ofQuaternion &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofQuaternion,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Quaternion___div(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Quaternion___div__SWIG_1(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Quaternion___div__SWIG_0(L);} } - } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Quaternion___div'\n" - " Possible C/C++ prototypes are:\n" " ofQuaternion::operator /(float) const\n" - " ofQuaternion::operator /(ofQuaternion const &) const\n"); lua_error(L);return 0; } -static int _wrap_Quaternion___add(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; - ofQuaternion *arg2 = 0 ; ofQuaternion result; SWIG_check_num_args("ofQuaternion::operator +",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::operator +",1,"ofQuaternion const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofQuaternion::operator +",2,"ofQuaternion const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion___add",1,SWIGTYPE_p_ofQuaternion); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion___add",2,SWIGTYPE_p_ofQuaternion); } - result = ((ofQuaternion const *)arg1)->operator +((ofQuaternion const &)*arg2); { - ofQuaternion * resultptr = new ofQuaternion((const ofQuaternion &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofQuaternion,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Quaternion___sub(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; - ofQuaternion *arg2 = 0 ; ofQuaternion result; SWIG_check_num_args("ofQuaternion::operator -",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::operator -",1,"ofQuaternion const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofQuaternion::operator -",2,"ofQuaternion const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion___sub",1,SWIGTYPE_p_ofQuaternion); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion___sub",2,SWIGTYPE_p_ofQuaternion); } - result = ((ofQuaternion const *)arg1)->operator -((ofQuaternion const &)*arg2); { - ofQuaternion * resultptr = new ofQuaternion((const ofQuaternion &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofQuaternion,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Quaternion___unm(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; - ofQuaternion result; SWIG_check_num_args("ofQuaternion::operator -",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::operator -",1,"ofQuaternion const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion___unm",1,SWIGTYPE_p_ofQuaternion); } result = ((ofQuaternion const *)arg1)->operator -(); { - ofQuaternion * resultptr = new ofQuaternion((const ofQuaternion &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofQuaternion,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Quaternion___tostring(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; - char *result = 0 ; SWIG_check_num_args("ofQuaternion::__str__",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::__str__",1,"ofQuaternion *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion___tostring",1,SWIGTYPE_p_ofQuaternion); } result = (char *)ofQuaternion___str__(arg1); - lua_pushstring(L,(const char *)result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_Quaternion(void *obj) { -ofQuaternion *arg1 = (ofQuaternion *) obj; -delete arg1; -} -static int _proxy__wrap_new_Quaternion(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_Quaternion); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_Quaternion_attributes[] = { - { "_v", _wrap_Quaternion__v_get, _wrap_Quaternion__v_set }, - {0,0,0} -}; -static swig_lua_method swig_Quaternion_methods[]= { - { "set", _wrap_Quaternion_set}, - { "get", _wrap_Quaternion_get}, - { "x", _wrap_Quaternion_x}, - { "y", _wrap_Quaternion_y}, - { "z", _wrap_Quaternion_z}, - { "w", _wrap_Quaternion_w}, - { "asVec4", _wrap_Quaternion_asVec4}, - { "asVec3", _wrap_Quaternion_asVec3}, - { "zeroRotation", _wrap_Quaternion_zeroRotation}, - { "length", _wrap_Quaternion_length}, - { "length2", _wrap_Quaternion_length2}, - { "conj", _wrap_Quaternion_conj}, - { "inverse", _wrap_Quaternion_inverse}, - { "makeRotate", _wrap_Quaternion_makeRotate}, - { "makeRotate_original", _wrap_Quaternion_makeRotate_original}, - { "getRotate", _wrap_Quaternion_getRotate}, - { "getEuler", _wrap_Quaternion_getEuler}, - { "slerp", _wrap_Quaternion_slerp}, - { "normalize", _wrap_Quaternion_normalize}, - { "__eq", _wrap_Quaternion___eq}, - { "__mul", _wrap_Quaternion___mul}, - { "__div", _wrap_Quaternion___div}, - { "__add", _wrap_Quaternion___add}, - { "__sub", _wrap_Quaternion___sub}, - { "__unm", _wrap_Quaternion___unm}, - { "__tostring", _wrap_Quaternion___tostring}, - {0,0} -}; -static swig_lua_method swig_Quaternion_meta[] = { - { "__eq", _wrap_Quaternion___eq}, - { "__mul", _wrap_Quaternion___mul}, - { "__div", _wrap_Quaternion___div}, - { "__add", _wrap_Quaternion___add}, - { "__sub", _wrap_Quaternion___sub}, - { "__unm", _wrap_Quaternion___unm}, - { "__tostring", _wrap_Quaternion___tostring}, - {0,0} -}; - -static swig_lua_attribute swig_Quaternion_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_Quaternion_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_Quaternion_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_Quaternion_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_Quaternion_Sf_SwigStatic = { - "Quaternion", - swig_Quaternion_Sf_SwigStatic_methods, - swig_Quaternion_Sf_SwigStatic_attributes, - swig_Quaternion_Sf_SwigStatic_constants, - swig_Quaternion_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_Quaternion_bases[] = {0}; -static const char *swig_Quaternion_base_names[] = {0}; -static swig_lua_class _wrap_class_Quaternion = { "Quaternion", "Quaternion", &SWIGTYPE_p_ofQuaternion,_proxy__wrap_new_Quaternion, swig_delete_Quaternion, swig_Quaternion_methods, swig_Quaternion_attributes, &swig_Quaternion_Sf_SwigStatic, swig_Quaternion_meta, swig_Quaternion_bases, swig_Quaternion_base_names }; - -static int _wrap_Vec2f_x_set(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; float arg2 ; - SWIG_check_num_args("ofVec2f::x",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::x",1,"ofVec2f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec2f::x",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_x_set",1,SWIGTYPE_p_ofVec2f); } - arg2 = (float)lua_tonumber(L, 2); if (arg1) (arg1)->x = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec2f_x_get(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; float result; - SWIG_check_num_args("ofVec2f::x",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::x",1,"ofVec2f *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_x_get",1,SWIGTYPE_p_ofVec2f); } - result = (float) ((arg1)->x); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_y_set(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; float arg2 ; - SWIG_check_num_args("ofVec2f::y",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::y",1,"ofVec2f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec2f::y",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_y_set",1,SWIGTYPE_p_ofVec2f); } - arg2 = (float)lua_tonumber(L, 2); if (arg1) (arg1)->y = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec2f_y_get(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; float result; - SWIG_check_num_args("ofVec2f::y",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::y",1,"ofVec2f *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_y_get",1,SWIGTYPE_p_ofVec2f); } - result = (float) ((arg1)->y); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_Vec2f__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec2f *result = 0 ; - SWIG_check_num_args("ofVec2f::ofVec2f",0,0) result = (ofVec2f *)new ofVec2f(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Vec2f__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; ofVec2f *result = 0 ; - SWIG_check_num_args("ofVec2f::ofVec2f",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofVec2f::ofVec2f",1,"float"); - arg1 = (float)lua_tonumber(L, 1); result = (ofVec2f *)new ofVec2f(arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Vec2f__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; ofVec2f *result = 0 ; - SWIG_check_num_args("ofVec2f::ofVec2f",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofVec2f::ofVec2f",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec2f::ofVec2f",2,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); result = (ofVec2f *)new ofVec2f(arg1,arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Vec2f__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = 0 ; ofVec2f *result = 0 ; - SWIG_check_num_args("ofVec2f::ofVec2f",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofVec2f::ofVec2f",1,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("new_Vec2f",1,SWIGTYPE_p_ofVec3f); } - result = (ofVec2f *)new ofVec2f((ofVec3f const &)*arg1); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_new_Vec2f__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = 0 ; ofVec2f *result = 0 ; - SWIG_check_num_args("ofVec2f::ofVec2f",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofVec2f::ofVec2f",1,"ofVec4f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("new_Vec2f",1,SWIGTYPE_p_ofVec4f); } - result = (ofVec2f *)new ofVec2f((ofVec4f const &)*arg1); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_new_Vec2f(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_Vec2f__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_new_Vec2f__SWIG_3(L);} } if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_new_Vec2f__SWIG_4(L);} } if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_new_Vec2f__SWIG_1(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_new_Vec2f__SWIG_2(L);} - } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_Vec2f'\n" - " Possible C/C++ prototypes are:\n" " ofVec2f::ofVec2f()\n" " ofVec2f::ofVec2f(float)\n" - " ofVec2f::ofVec2f(float,float)\n" " ofVec2f::ofVec2f(ofVec3f const &)\n" " ofVec2f::ofVec2f(ofVec4f const &)\n"); - lua_error(L);return 0; } -static int _wrap_Vec2f_getPtr__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; float *result = 0 ; - SWIG_check_num_args("ofVec2f::getPtr",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::getPtr",1,"ofVec2f *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_getPtr",1,SWIGTYPE_p_ofVec2f); } - result = (float *)(arg1)->getPtr(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_float,0); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_getPtr__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; float *result = 0 ; - SWIG_check_num_args("ofVec2f::getPtr",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::getPtr",1,"ofVec2f const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_getPtr",1,SWIGTYPE_p_ofVec2f); } - result = (float *)((ofVec2f const *)arg1)->getPtr(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_float,0); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_getPtr(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Vec2f_getPtr__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Vec2f_getPtr__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec2f_getPtr'\n" " Possible C/C++ prototypes are:\n" - " ofVec2f::getPtr()\n" " ofVec2f::getPtr() const\n"); lua_error(L);return 0; } -static int _wrap_Vec2f_set__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofVec2f::set",3,3) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::set",1,"ofVec2f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec2f::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVec2f::set",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_set",1,SWIGTYPE_p_ofVec2f); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); (arg1)->set(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_set__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f *arg2 = 0 ; - SWIG_check_num_args("ofVec2f::set",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::set",1,"ofVec2f *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec2f::set",2,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_set",1,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_set",2,SWIGTYPE_p_ofVec2f); } - (arg1)->set((ofVec2f const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_set__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; float arg2 ; - SWIG_check_num_args("ofVec2f::set",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::set",1,"ofVec2f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec2f::set",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_set",1,SWIGTYPE_p_ofVec2f); } - arg2 = (float)lua_tonumber(L, 2); (arg1)->set(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_set(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec2f_set__SWIG_1(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Vec2f_set__SWIG_2(L);} } } - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Vec2f_set__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec2f_set'\n" " Possible C/C++ prototypes are:\n" - " ofVec2f::set(float,float)\n" " ofVec2f::set(ofVec2f const &)\n" " ofVec2f::set(float)\n"); lua_error(L);return 0; } -static int _wrap_Vec2f___eq(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f *arg2 = 0 ; bool result; - SWIG_check_num_args("ofVec2f::operator ==",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::operator ==",1,"ofVec2f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec2f::operator ==",2,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f___eq",1,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f___eq",2,SWIGTYPE_p_ofVec2f); } - result = (bool)((ofVec2f const *)arg1)->operator ==((ofVec2f const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_match__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f *arg2 = 0 ; - float arg3 ; bool result; SWIG_check_num_args("ofVec2f::match",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::match",1,"ofVec2f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec2f::match",2,"ofVec2f const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVec2f::match",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_match",1,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_match",2,SWIGTYPE_p_ofVec2f); } - arg3 = (float)lua_tonumber(L, 3); result = (bool)((ofVec2f const *)arg1)->match((ofVec2f const &)*arg2,arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_match__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f *arg2 = 0 ; - bool result; SWIG_check_num_args("ofVec2f::match",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::match",1,"ofVec2f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec2f::match",2,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_match",1,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_match",2,SWIGTYPE_p_ofVec2f); } - result = (bool)((ofVec2f const *)arg1)->match((ofVec2f const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_match(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec2f_match__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Vec2f_match__SWIG_0(L);} } } - } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec2f_match'\n" " Possible C/C++ prototypes are:\n" - " ofVec2f::match(ofVec2f const &,float) const\n" " ofVec2f::match(ofVec2f const &) const\n"); lua_error(L);return 0; } -static int _wrap_Vec2f_isAligned__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f *arg2 = 0 ; - float arg3 ; bool result; SWIG_check_num_args("ofVec2f::isAligned",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::isAligned",1,"ofVec2f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec2f::isAligned",2,"ofVec2f const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVec2f::isAligned",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_isAligned",1,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_isAligned",2,SWIGTYPE_p_ofVec2f); } arg3 = (float)lua_tonumber(L, 3); - result = (bool)((ofVec2f const *)arg1)->isAligned((ofVec2f const &)*arg2,arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_isAligned__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f *arg2 = 0 ; - bool result; SWIG_check_num_args("ofVec2f::isAligned",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::isAligned",1,"ofVec2f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec2f::isAligned",2,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_isAligned",1,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_isAligned",2,SWIGTYPE_p_ofVec2f); } - result = (bool)((ofVec2f const *)arg1)->isAligned((ofVec2f const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_isAligned(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec2f_isAligned__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Vec2f_isAligned__SWIG_0(L);} } - } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec2f_isAligned'\n" - " Possible C/C++ prototypes are:\n" " ofVec2f::isAligned(ofVec2f const &,float) const\n" - " ofVec2f::isAligned(ofVec2f const &) const\n"); lua_error(L);return 0; } -static int _wrap_Vec2f_isAlignedRad__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; - ofVec2f *arg2 = 0 ; float arg3 ; bool result; SWIG_check_num_args("ofVec2f::isAlignedRad",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::isAlignedRad",1,"ofVec2f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec2f::isAlignedRad",2,"ofVec2f const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVec2f::isAlignedRad",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_isAlignedRad",1,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_isAlignedRad",2,SWIGTYPE_p_ofVec2f); } arg3 = (float)lua_tonumber(L, 3); - result = (bool)((ofVec2f const *)arg1)->isAlignedRad((ofVec2f const &)*arg2,arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_isAlignedRad__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; - ofVec2f *arg2 = 0 ; bool result; SWIG_check_num_args("ofVec2f::isAlignedRad",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::isAlignedRad",1,"ofVec2f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec2f::isAlignedRad",2,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_isAlignedRad",1,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_isAlignedRad",2,SWIGTYPE_p_ofVec2f); } - result = (bool)((ofVec2f const *)arg1)->isAlignedRad((ofVec2f const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_isAlignedRad(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec2f_isAlignedRad__SWIG_1(L);} } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Vec2f_isAlignedRad__SWIG_0(L);} - } } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec2f_isAlignedRad'\n" - " Possible C/C++ prototypes are:\n" " ofVec2f::isAlignedRad(ofVec2f const &,float) const\n" - " ofVec2f::isAlignedRad(ofVec2f const &) const\n"); lua_error(L);return 0; } -static int _wrap_Vec2f_align__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f *arg2 = 0 ; - float arg3 ; bool result; SWIG_check_num_args("ofVec2f::align",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::align",1,"ofVec2f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec2f::align",2,"ofVec2f const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVec2f::align",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_align",1,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_align",2,SWIGTYPE_p_ofVec2f); } - arg3 = (float)lua_tonumber(L, 3); result = (bool)((ofVec2f const *)arg1)->align((ofVec2f const &)*arg2,arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_align__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f *arg2 = 0 ; - bool result; SWIG_check_num_args("ofVec2f::align",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::align",1,"ofVec2f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec2f::align",2,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_align",1,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_align",2,SWIGTYPE_p_ofVec2f); } - result = (bool)((ofVec2f const *)arg1)->align((ofVec2f const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_align(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec2f_align__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Vec2f_align__SWIG_0(L);} } } - } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec2f_align'\n" " Possible C/C++ prototypes are:\n" - " ofVec2f::align(ofVec2f const &,float) const\n" " ofVec2f::align(ofVec2f const &) const\n"); lua_error(L);return 0; } -static int _wrap_Vec2f_alignRad__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f *arg2 = 0 ; - float arg3 ; bool result; SWIG_check_num_args("ofVec2f::alignRad",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::alignRad",1,"ofVec2f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec2f::alignRad",2,"ofVec2f const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVec2f::alignRad",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_alignRad",1,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_alignRad",2,SWIGTYPE_p_ofVec2f); } arg3 = (float)lua_tonumber(L, 3); - result = (bool)((ofVec2f const *)arg1)->alignRad((ofVec2f const &)*arg2,arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_alignRad__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f *arg2 = 0 ; - bool result; SWIG_check_num_args("ofVec2f::alignRad",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::alignRad",1,"ofVec2f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec2f::alignRad",2,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_alignRad",1,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_alignRad",2,SWIGTYPE_p_ofVec2f); } - result = (bool)((ofVec2f const *)arg1)->alignRad((ofVec2f const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_alignRad(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec2f_alignRad__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Vec2f_alignRad__SWIG_0(L);} } - } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec2f_alignRad'\n" - " Possible C/C++ prototypes are:\n" " ofVec2f::alignRad(ofVec2f const &,float) const\n" - " ofVec2f::alignRad(ofVec2f const &) const\n"); lua_error(L);return 0; } -static int _wrap_Vec2f___add__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f *arg2 = 0 ; - ofVec2f result; SWIG_check_num_args("ofVec2f::operator +",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::operator +",1,"ofVec2f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec2f::operator +",2,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f___add",1,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f___add",2,SWIGTYPE_p_ofVec2f); } - result = ((ofVec2f const *)arg1)->operator +((ofVec2f const &)*arg2); { - ofVec2f * resultptr = new ofVec2f((const ofVec2f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f___add__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; float arg2 ; - ofVec2f result; SWIG_check_num_args("ofVec2f::operator +",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::operator +",1,"ofVec2f const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec2f::operator +",2,"float const"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f___add",1,SWIGTYPE_p_ofVec2f); } - arg2 = (float const)lua_tonumber(L, 2); result = ((ofVec2f const *)arg1)->operator +(arg2); { - ofVec2f * resultptr = new ofVec2f((const ofVec2f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f___add(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec2f___add__SWIG_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Vec2f___add__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec2f___add'\n" " Possible C/C++ prototypes are:\n" - " ofVec2f::operator +(ofVec2f const &) const\n" " ofVec2f::operator +(float const) const\n"); lua_error(L);return 0; } -static int _wrap_Vec2f___sub__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f *arg2 = 0 ; - ofVec2f result; SWIG_check_num_args("ofVec2f::operator -",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::operator -",1,"ofVec2f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec2f::operator -",2,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f___sub",1,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f___sub",2,SWIGTYPE_p_ofVec2f); } - result = ((ofVec2f const *)arg1)->operator -((ofVec2f const &)*arg2); { - ofVec2f * resultptr = new ofVec2f((const ofVec2f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f___sub__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; float arg2 ; - ofVec2f result; SWIG_check_num_args("ofVec2f::operator -",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::operator -",1,"ofVec2f const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec2f::operator -",2,"float const"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f___sub",1,SWIGTYPE_p_ofVec2f); } - arg2 = (float const)lua_tonumber(L, 2); result = ((ofVec2f const *)arg1)->operator -(arg2); { - ofVec2f * resultptr = new ofVec2f((const ofVec2f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f___sub(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec2f___sub__SWIG_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Vec2f___sub__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec2f___sub'\n" " Possible C/C++ prototypes are:\n" - " ofVec2f::operator -(ofVec2f const &) const\n" " ofVec2f::operator -(float const) const\n"); lua_error(L);return 0; } -static int _wrap_Vec2f___unm(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f result; - SWIG_check_num_args("ofVec2f::operator -",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::operator -",1,"ofVec2f const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f___unm",1,SWIGTYPE_p_ofVec2f); } - result = ((ofVec2f const *)arg1)->operator -(); { ofVec2f * resultptr = new ofVec2f((const ofVec2f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f___mul__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f *arg2 = 0 ; - ofVec2f result; SWIG_check_num_args("ofVec2f::operator *",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::operator *",1,"ofVec2f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec2f::operator *",2,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f___mul",1,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f___mul",2,SWIGTYPE_p_ofVec2f); } - result = ((ofVec2f const *)arg1)->operator *((ofVec2f const &)*arg2); { - ofVec2f * resultptr = new ofVec2f((const ofVec2f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f___mul__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; float arg2 ; - ofVec2f result; SWIG_check_num_args("ofVec2f::operator *",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::operator *",1,"ofVec2f const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec2f::operator *",2,"float const"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f___mul",1,SWIGTYPE_p_ofVec2f); } - arg2 = (float const)lua_tonumber(L, 2); result = ((ofVec2f const *)arg1)->operator *(arg2); { - ofVec2f * resultptr = new ofVec2f((const ofVec2f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f___mul(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec2f___mul__SWIG_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Vec2f___mul__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec2f___mul'\n" " Possible C/C++ prototypes are:\n" - " ofVec2f::operator *(ofVec2f const &) const\n" " ofVec2f::operator *(float const) const\n"); lua_error(L);return 0; } -static int _wrap_Vec2f___div__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f *arg2 = 0 ; - ofVec2f result; SWIG_check_num_args("ofVec2f::operator /",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::operator /",1,"ofVec2f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec2f::operator /",2,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f___div",1,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f___div",2,SWIGTYPE_p_ofVec2f); } - result = ((ofVec2f const *)arg1)->operator /((ofVec2f const &)*arg2); { - ofVec2f * resultptr = new ofVec2f((const ofVec2f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f___div__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; float arg2 ; - ofVec2f result; SWIG_check_num_args("ofVec2f::operator /",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::operator /",1,"ofVec2f const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec2f::operator /",2,"float const"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f___div",1,SWIGTYPE_p_ofVec2f); } - arg2 = (float const)lua_tonumber(L, 2); result = ((ofVec2f const *)arg1)->operator /(arg2); { - ofVec2f * resultptr = new ofVec2f((const ofVec2f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f___div(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec2f___div__SWIG_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Vec2f___div__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec2f___div'\n" " Possible C/C++ prototypes are:\n" - " ofVec2f::operator /(ofVec2f const &) const\n" " ofVec2f::operator /(float const) const\n"); lua_error(L);return 0; } -static int _wrap_Vec2f_getScaled(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; float arg2 ; ofVec2f result; - SWIG_check_num_args("ofVec2f::getScaled",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::getScaled",1,"ofVec2f const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec2f::getScaled",2,"float const"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_getScaled",1,SWIGTYPE_p_ofVec2f); } arg2 = (float const)lua_tonumber(L, 2); - result = ((ofVec2f const *)arg1)->getScaled(arg2); { ofVec2f * resultptr = new ofVec2f((const ofVec2f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_scale(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; float arg2 ; - ofVec2f *result = 0 ; SWIG_check_num_args("ofVec2f::scale",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::scale",1,"ofVec2f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec2f::scale",2,"float const"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_scale",1,SWIGTYPE_p_ofVec2f); } - arg2 = (float const)lua_tonumber(L, 2); result = (ofVec2f *) &(arg1)->scale(arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec2f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec2f_getRotated__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; float arg2 ; - ofVec2f result; SWIG_check_num_args("ofVec2f::getRotated",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::getRotated",1,"ofVec2f const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec2f::getRotated",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_getRotated",1,SWIGTYPE_p_ofVec2f); } arg2 = (float)lua_tonumber(L, 2); - result = ((ofVec2f const *)arg1)->getRotated(arg2); { ofVec2f * resultptr = new ofVec2f((const ofVec2f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_getRotated__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; float arg2 ; - ofVec2f *arg3 = 0 ; ofVec2f result; SWIG_check_num_args("ofVec2f::getRotated",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::getRotated",1,"ofVec2f const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec2f::getRotated",2,"float"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofVec2f::getRotated",3,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_getRotated",1,SWIGTYPE_p_ofVec2f); } arg2 = (float)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_getRotated",3,SWIGTYPE_p_ofVec2f); } - result = ((ofVec2f const *)arg1)->getRotated(arg2,(ofVec2f const &)*arg3); { - ofVec2f * resultptr = new ofVec2f((const ofVec2f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_getRotated(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Vec2f_getRotated__SWIG_0(L);} } } - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec2f_getRotated__SWIG_1(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec2f_getRotated'\n" " Possible C/C++ prototypes are:\n" - " ofVec2f::getRotated(float) const\n" " ofVec2f::getRotated(float,ofVec2f const &) const\n"); lua_error(L);return 0; } -static int _wrap_Vec2f_getRotatedRad__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; float arg2 ; - ofVec2f result; SWIG_check_num_args("ofVec2f::getRotatedRad",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::getRotatedRad",1,"ofVec2f const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec2f::getRotatedRad",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_getRotatedRad",1,SWIGTYPE_p_ofVec2f); } arg2 = (float)lua_tonumber(L, 2); - result = ((ofVec2f const *)arg1)->getRotatedRad(arg2); { ofVec2f * resultptr = new ofVec2f((const ofVec2f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_getRotatedRad__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; float arg2 ; - ofVec2f *arg3 = 0 ; ofVec2f result; SWIG_check_num_args("ofVec2f::getRotatedRad",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::getRotatedRad",1,"ofVec2f const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec2f::getRotatedRad",2,"float"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofVec2f::getRotatedRad",3,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_getRotatedRad",1,SWIGTYPE_p_ofVec2f); } arg2 = (float)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_getRotatedRad",3,SWIGTYPE_p_ofVec2f); } - result = ((ofVec2f const *)arg1)->getRotatedRad(arg2,(ofVec2f const &)*arg3); { - ofVec2f * resultptr = new ofVec2f((const ofVec2f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_getRotatedRad(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Vec2f_getRotatedRad__SWIG_0(L);} } } - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec2f_getRotatedRad__SWIG_1(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec2f_getRotatedRad'\n" - " Possible C/C++ prototypes are:\n" " ofVec2f::getRotatedRad(float) const\n" - " ofVec2f::getRotatedRad(float,ofVec2f const &) const\n"); lua_error(L);return 0; } -static int _wrap_Vec2f_rotate__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; float arg2 ; - ofVec2f *result = 0 ; SWIG_check_num_args("ofVec2f::rotate",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::rotate",1,"ofVec2f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec2f::rotate",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_rotate",1,SWIGTYPE_p_ofVec2f); } - arg2 = (float)lua_tonumber(L, 2); result = (ofVec2f *) &(arg1)->rotate(arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec2f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec2f_rotate__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; float arg2 ; - ofVec2f *arg3 = 0 ; ofVec2f *result = 0 ; SWIG_check_num_args("ofVec2f::rotate",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::rotate",1,"ofVec2f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec2f::rotate",2,"float"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofVec2f::rotate",3,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_rotate",1,SWIGTYPE_p_ofVec2f); } - arg2 = (float)lua_tonumber(L, 2); if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_rotate",3,SWIGTYPE_p_ofVec2f); } result = (ofVec2f *) &(arg1)->rotate(arg2,(ofVec2f const &)*arg3); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec2f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec2f_rotate(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Vec2f_rotate__SWIG_0(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec2f_rotate__SWIG_1(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec2f_rotate'\n" " Possible C/C++ prototypes are:\n" - " ofVec2f::rotate(float)\n" " ofVec2f::rotate(float,ofVec2f const &)\n"); lua_error(L);return 0; } -static int _wrap_Vec2f_rotateRad__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; float arg2 ; - ofVec2f *result = 0 ; SWIG_check_num_args("ofVec2f::rotateRad",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::rotateRad",1,"ofVec2f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec2f::rotateRad",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_rotateRad",1,SWIGTYPE_p_ofVec2f); } arg2 = (float)lua_tonumber(L, 2); - result = (ofVec2f *) &(arg1)->rotateRad(arg2); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec2f,0); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_rotateRad__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; float arg2 ; - ofVec2f *arg3 = 0 ; ofVec2f *result = 0 ; SWIG_check_num_args("ofVec2f::rotateRad",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::rotateRad",1,"ofVec2f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec2f::rotateRad",2,"float"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofVec2f::rotateRad",3,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_rotateRad",1,SWIGTYPE_p_ofVec2f); } arg2 = (float)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_rotateRad",3,SWIGTYPE_p_ofVec2f); } - result = (ofVec2f *) &(arg1)->rotateRad(arg2,(ofVec2f const &)*arg3); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec2f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec2f_rotateRad(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Vec2f_rotateRad__SWIG_0(L);} } } - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec2f_rotateRad__SWIG_1(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec2f_rotateRad'\n" " Possible C/C++ prototypes are:\n" - " ofVec2f::rotateRad(float)\n" " ofVec2f::rotateRad(float,ofVec2f const &)\n"); lua_error(L);return 0; } -static int _wrap_Vec2f_getMapped(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f *arg2 = 0 ; - ofVec2f *arg3 = 0 ; ofVec2f *arg4 = 0 ; ofVec2f result; SWIG_check_num_args("ofVec2f::getMapped",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::getMapped",1,"ofVec2f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec2f::getMapped",2,"ofVec2f const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofVec2f::getMapped",3,"ofVec2f const &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofVec2f::getMapped",4,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_getMapped",1,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_getMapped",2,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_getMapped",3,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_getMapped",4,SWIGTYPE_p_ofVec2f); } - result = ((ofVec2f const *)arg1)->getMapped((ofVec2f const &)*arg2,(ofVec2f const &)*arg3,(ofVec2f const &)*arg4); { - ofVec2f * resultptr = new ofVec2f((const ofVec2f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_map(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f *arg2 = 0 ; - ofVec2f *arg3 = 0 ; ofVec2f *arg4 = 0 ; ofVec2f *result = 0 ; SWIG_check_num_args("ofVec2f::map",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::map",1,"ofVec2f *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec2f::map",2,"ofVec2f const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofVec2f::map",3,"ofVec2f const &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofVec2f::map",4,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_map",1,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_map",2,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_map",3,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_map",4,SWIGTYPE_p_ofVec2f); } - result = (ofVec2f *) &(arg1)->map((ofVec2f const &)*arg2,(ofVec2f const &)*arg3,(ofVec2f const &)*arg4); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec2f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec2f_distance(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f *arg2 = 0 ; - float result; SWIG_check_num_args("ofVec2f::distance",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::distance",1,"ofVec2f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec2f::distance",2,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_distance",1,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_distance",2,SWIGTYPE_p_ofVec2f); } - result = (float)((ofVec2f const *)arg1)->distance((ofVec2f const &)*arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_squareDistance(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f *arg2 = 0 ; - float result; SWIG_check_num_args("ofVec2f::squareDistance",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::squareDistance",1,"ofVec2f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec2f::squareDistance",2,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_squareDistance",1,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_squareDistance",2,SWIGTYPE_p_ofVec2f); } - result = (float)((ofVec2f const *)arg1)->squareDistance((ofVec2f const &)*arg2); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_getInterpolated(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f *arg2 = 0 ; - float arg3 ; ofVec2f result; SWIG_check_num_args("ofVec2f::getInterpolated",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::getInterpolated",1,"ofVec2f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec2f::getInterpolated",2,"ofVec2f const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVec2f::getInterpolated",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_getInterpolated",1,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_getInterpolated",2,SWIGTYPE_p_ofVec2f); } arg3 = (float)lua_tonumber(L, 3); - result = ((ofVec2f const *)arg1)->getInterpolated((ofVec2f const &)*arg2,arg3); { - ofVec2f * resultptr = new ofVec2f((const ofVec2f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_interpolate(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f *arg2 = 0 ; - float arg3 ; ofVec2f *result = 0 ; SWIG_check_num_args("ofVec2f::interpolate",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::interpolate",1,"ofVec2f *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec2f::interpolate",2,"ofVec2f const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVec2f::interpolate",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_interpolate",1,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_interpolate",2,SWIGTYPE_p_ofVec2f); } arg3 = (float)lua_tonumber(L, 3); - result = (ofVec2f *) &(arg1)->interpolate((ofVec2f const &)*arg2,arg3); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec2f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec2f_getMiddle(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f *arg2 = 0 ; - ofVec2f result; SWIG_check_num_args("ofVec2f::getMiddle",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::getMiddle",1,"ofVec2f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec2f::getMiddle",2,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_getMiddle",1,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_getMiddle",2,SWIGTYPE_p_ofVec2f); } - result = ((ofVec2f const *)arg1)->getMiddle((ofVec2f const &)*arg2); { - ofVec2f * resultptr = new ofVec2f((const ofVec2f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_middle(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f *arg2 = 0 ; - ofVec2f *result = 0 ; SWIG_check_num_args("ofVec2f::middle",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::middle",1,"ofVec2f *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec2f::middle",2,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_middle",1,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_middle",2,SWIGTYPE_p_ofVec2f); } result = (ofVec2f *) &(arg1)->middle((ofVec2f const &)*arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec2f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec2f_average(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f *arg2 = (ofVec2f *) 0 ; - std::size_t arg3 ; ofVec2f *result = 0 ; SWIG_check_num_args("ofVec2f::average",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::average",1,"ofVec2f *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofVec2f::average",2,"ofVec2f const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVec2f::average",3,"std::size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_average",1,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_average",2,SWIGTYPE_p_ofVec2f); } - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (std::size_t)lua_tonumber(L, 3); - result = (ofVec2f *) &(arg1)->average((ofVec2f const *)arg2,arg3); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec2f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec2f_getNormalized(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f result; - SWIG_check_num_args("ofVec2f::getNormalized",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::getNormalized",1,"ofVec2f const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_getNormalized",1,SWIGTYPE_p_ofVec2f); } result = ((ofVec2f const *)arg1)->getNormalized(); { - ofVec2f * resultptr = new ofVec2f((const ofVec2f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_normalize(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f *result = 0 ; - SWIG_check_num_args("ofVec2f::normalize",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::normalize",1,"ofVec2f *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_normalize",1,SWIGTYPE_p_ofVec2f); } result = (ofVec2f *) &(arg1)->normalize(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec2f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec2f_getLimited(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; float arg2 ; ofVec2f result; - SWIG_check_num_args("ofVec2f::getLimited",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::getLimited",1,"ofVec2f const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec2f::getLimited",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_getLimited",1,SWIGTYPE_p_ofVec2f); } arg2 = (float)lua_tonumber(L, 2); - result = ((ofVec2f const *)arg1)->getLimited(arg2); { ofVec2f * resultptr = new ofVec2f((const ofVec2f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_limit(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; float arg2 ; - ofVec2f *result = 0 ; SWIG_check_num_args("ofVec2f::limit",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::limit",1,"ofVec2f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec2f::limit",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_limit",1,SWIGTYPE_p_ofVec2f); } - arg2 = (float)lua_tonumber(L, 2); result = (ofVec2f *) &(arg1)->limit(arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec2f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec2f_length(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; float result; - SWIG_check_num_args("ofVec2f::length",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::length",1,"ofVec2f const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_length",1,SWIGTYPE_p_ofVec2f); } - result = (float)((ofVec2f const *)arg1)->length(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_lengthSquared(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; float result; - SWIG_check_num_args("ofVec2f::lengthSquared",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::lengthSquared",1,"ofVec2f const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_lengthSquared",1,SWIGTYPE_p_ofVec2f); } result = (float)((ofVec2f const *)arg1)->lengthSquared(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_angle(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f *arg2 = 0 ; float result; - SWIG_check_num_args("ofVec2f::angle",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::angle",1,"ofVec2f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec2f::angle",2,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_angle",1,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_angle",2,SWIGTYPE_p_ofVec2f); } - result = (float)((ofVec2f const *)arg1)->angle((ofVec2f const &)*arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_angleRad(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f *arg2 = 0 ; - float result; SWIG_check_num_args("ofVec2f::angleRad",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::angleRad",1,"ofVec2f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec2f::angleRad",2,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_angleRad",1,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_angleRad",2,SWIGTYPE_p_ofVec2f); } - result = (float)((ofVec2f const *)arg1)->angleRad((ofVec2f const &)*arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_getPerpendicular(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f result; - SWIG_check_num_args("ofVec2f::getPerpendicular",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::getPerpendicular",1,"ofVec2f const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_getPerpendicular",1,SWIGTYPE_p_ofVec2f); } result = ((ofVec2f const *)arg1)->getPerpendicular(); { - ofVec2f * resultptr = new ofVec2f((const ofVec2f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_perpendicular(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f *result = 0 ; - SWIG_check_num_args("ofVec2f::perpendicular",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::perpendicular",1,"ofVec2f *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_perpendicular",1,SWIGTYPE_p_ofVec2f); } result = (ofVec2f *) &(arg1)->perpendicular(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec2f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec2f_dot(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f *arg2 = 0 ; float result; - SWIG_check_num_args("ofVec2f::dot",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::dot",1,"ofVec2f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec2f::dot",2,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_dot",1,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_dot",2,SWIGTYPE_p_ofVec2f); } - result = (float)((ofVec2f const *)arg1)->dot((ofVec2f const &)*arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_zero(lua_State* L) { int SWIG_arg = 0; ofVec2f result; SWIG_check_num_args("ofVec2f::zero",0,0) - result = ofVec2f::zero(); { ofVec2f * resultptr = new ofVec2f((const ofVec2f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_one(lua_State* L) { int SWIG_arg = 0; ofVec2f result; SWIG_check_num_args("ofVec2f::one",0,0) - result = ofVec2f::one(); { ofVec2f * resultptr = new ofVec2f((const ofVec2f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f___tostring(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; char *result = 0 ; - SWIG_check_num_args("ofVec2f::__str__",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::__str__",1,"ofVec2f *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f___tostring",1,SWIGTYPE_p_ofVec2f); } result = (char *)ofVec2f___str__(arg1); - lua_pushstring(L,(const char *)result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_Vec2f(void *obj) { -ofVec2f *arg1 = (ofVec2f *) obj; -delete arg1; -} -static int _proxy__wrap_new_Vec2f(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_Vec2f); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_Vec2f_attributes[] = { - { "x", _wrap_Vec2f_x_get, _wrap_Vec2f_x_set }, - { "y", _wrap_Vec2f_y_get, _wrap_Vec2f_y_set }, - {0,0,0} -}; -static swig_lua_method swig_Vec2f_methods[]= { - { "getPtr", _wrap_Vec2f_getPtr}, - { "set", _wrap_Vec2f_set}, - { "__eq", _wrap_Vec2f___eq}, - { "match", _wrap_Vec2f_match}, - { "isAligned", _wrap_Vec2f_isAligned}, - { "isAlignedRad", _wrap_Vec2f_isAlignedRad}, - { "align", _wrap_Vec2f_align}, - { "alignRad", _wrap_Vec2f_alignRad}, - { "__add", _wrap_Vec2f___add}, - { "__sub", _wrap_Vec2f___sub}, - { "__unm", _wrap_Vec2f___unm}, - { "__mul", _wrap_Vec2f___mul}, - { "__div", _wrap_Vec2f___div}, - { "getScaled", _wrap_Vec2f_getScaled}, - { "scale", _wrap_Vec2f_scale}, - { "getRotated", _wrap_Vec2f_getRotated}, - { "getRotatedRad", _wrap_Vec2f_getRotatedRad}, - { "rotate", _wrap_Vec2f_rotate}, - { "rotateRad", _wrap_Vec2f_rotateRad}, - { "getMapped", _wrap_Vec2f_getMapped}, - { "map", _wrap_Vec2f_map}, - { "distance", _wrap_Vec2f_distance}, - { "squareDistance", _wrap_Vec2f_squareDistance}, - { "getInterpolated", _wrap_Vec2f_getInterpolated}, - { "interpolate", _wrap_Vec2f_interpolate}, - { "getMiddle", _wrap_Vec2f_getMiddle}, - { "middle", _wrap_Vec2f_middle}, - { "average", _wrap_Vec2f_average}, - { "getNormalized", _wrap_Vec2f_getNormalized}, - { "normalize", _wrap_Vec2f_normalize}, - { "getLimited", _wrap_Vec2f_getLimited}, - { "limit", _wrap_Vec2f_limit}, - { "length", _wrap_Vec2f_length}, - { "lengthSquared", _wrap_Vec2f_lengthSquared}, - { "angle", _wrap_Vec2f_angle}, - { "angleRad", _wrap_Vec2f_angleRad}, - { "getPerpendicular", _wrap_Vec2f_getPerpendicular}, - { "perpendicular", _wrap_Vec2f_perpendicular}, - { "dot", _wrap_Vec2f_dot}, - { "__tostring", _wrap_Vec2f___tostring}, - {0,0} -}; -static swig_lua_method swig_Vec2f_meta[] = { - { "__eq", _wrap_Vec2f___eq}, - { "__add", _wrap_Vec2f___add}, - { "__sub", _wrap_Vec2f___sub}, - { "__unm", _wrap_Vec2f___unm}, - { "__mul", _wrap_Vec2f___mul}, - { "__div", _wrap_Vec2f___div}, - { "__tostring", _wrap_Vec2f___tostring}, - {0,0} -}; - -static swig_lua_attribute swig_Vec2f_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_Vec2f_Sf_SwigStatic_constants[]= { - {SWIG_LUA_CONSTTAB_INT("DIM", ofVec2f::DIM)}, - {0,0,0,0,0,0} -}; -static swig_lua_method swig_Vec2f_Sf_SwigStatic_methods[]= { - { "zero", _wrap_Vec2f_zero}, - { "one", _wrap_Vec2f_one}, - {0,0} -}; -static swig_lua_class* swig_Vec2f_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_Vec2f_Sf_SwigStatic = { - "Vec2f", - swig_Vec2f_Sf_SwigStatic_methods, - swig_Vec2f_Sf_SwigStatic_attributes, - swig_Vec2f_Sf_SwigStatic_constants, - swig_Vec2f_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_Vec2f_bases[] = {0}; -static const char *swig_Vec2f_base_names[] = {0}; -static swig_lua_class _wrap_class_Vec2f = { "Vec2f", "Vec2f", &SWIGTYPE_p_ofVec2f,_proxy__wrap_new_Vec2f, swig_delete_Vec2f, swig_Vec2f_methods, swig_Vec2f_attributes, &swig_Vec2f_Sf_SwigStatic, swig_Vec2f_meta, swig_Vec2f_bases, swig_Vec2f_base_names }; - -static int _wrap_Vec3f_x_set(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float arg2 ; - SWIG_check_num_args("ofVec3f::x",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::x",1,"ofVec3f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec3f::x",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_x_set",1,SWIGTYPE_p_ofVec3f); } - arg2 = (float)lua_tonumber(L, 2); if (arg1) (arg1)->x = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec3f_x_get(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float result; - SWIG_check_num_args("ofVec3f::x",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::x",1,"ofVec3f *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_x_get",1,SWIGTYPE_p_ofVec3f); } - result = (float) ((arg1)->x); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_y_set(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float arg2 ; - SWIG_check_num_args("ofVec3f::y",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::y",1,"ofVec3f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec3f::y",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_y_set",1,SWIGTYPE_p_ofVec3f); } - arg2 = (float)lua_tonumber(L, 2); if (arg1) (arg1)->y = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec3f_y_get(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float result; - SWIG_check_num_args("ofVec3f::y",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::y",1,"ofVec3f *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_y_get",1,SWIGTYPE_p_ofVec3f); } - result = (float) ((arg1)->y); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_z_set(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float arg2 ; - SWIG_check_num_args("ofVec3f::z",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::z",1,"ofVec3f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec3f::z",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_z_set",1,SWIGTYPE_p_ofVec3f); } - arg2 = (float)lua_tonumber(L, 2); if (arg1) (arg1)->z = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec3f_z_get(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float result; - SWIG_check_num_args("ofVec3f::z",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::z",1,"ofVec3f *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_z_get",1,SWIGTYPE_p_ofVec3f); } - result = (float) ((arg1)->z); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_Vec3f__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec3f *result = 0 ; - SWIG_check_num_args("ofVec3f::ofVec3f",0,0) result = (ofVec3f *)new ofVec3f(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Vec3f__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; - ofVec3f *result = 0 ; SWIG_check_num_args("ofVec3f::ofVec3f",3,3) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofVec3f::ofVec3f",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec3f::ofVec3f",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVec3f::ofVec3f",3,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); result = (ofVec3f *)new ofVec3f(arg1,arg2,arg3); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Vec3f__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; ofVec3f *result = 0 ; - SWIG_check_num_args("ofVec3f::ofVec3f",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofVec3f::ofVec3f",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec3f::ofVec3f",2,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); result = (ofVec3f *)new ofVec3f(arg1,arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Vec3f__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; ofVec3f *result = 0 ; - SWIG_check_num_args("ofVec3f::ofVec3f",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofVec3f::ofVec3f",1,"float"); - arg1 = (float)lua_tonumber(L, 1); result = (ofVec3f *)new ofVec3f(arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Vec3f__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = 0 ; ofVec3f *result = 0 ; - SWIG_check_num_args("ofVec3f::ofVec3f",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofVec3f::ofVec3f",1,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("new_Vec3f",1,SWIGTYPE_p_ofVec2f); } - result = (ofVec3f *)new ofVec3f((ofVec2f const &)*arg1); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_new_Vec3f__SWIG_5(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = 0 ; ofVec3f *result = 0 ; - SWIG_check_num_args("ofVec3f::ofVec3f",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofVec3f::ofVec3f",1,"ofVec4f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("new_Vec3f",1,SWIGTYPE_p_ofVec4f); } - result = (ofVec3f *)new ofVec3f((ofVec4f const &)*arg1); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_new_Vec3f(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_Vec3f__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_new_Vec3f__SWIG_4(L);} } if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_new_Vec3f__SWIG_5(L);} } if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_new_Vec3f__SWIG_3(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_new_Vec3f__SWIG_2(L);} - } } if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_new_Vec3f__SWIG_1(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_Vec3f'\n" " Possible C/C++ prototypes are:\n" - " ofVec3f::ofVec3f()\n" " ofVec3f::ofVec3f(float,float,float)\n" " ofVec3f::ofVec3f(float,float)\n" - " ofVec3f::ofVec3f(float)\n" " ofVec3f::ofVec3f(ofVec2f const &)\n" " ofVec3f::ofVec3f(ofVec4f const &)\n"); - lua_error(L);return 0; } -static int _wrap_Vec3f_getPtr__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float *result = 0 ; - SWIG_check_num_args("ofVec3f::getPtr",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::getPtr",1,"ofVec3f *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_getPtr",1,SWIGTYPE_p_ofVec3f); } - result = (float *)(arg1)->getPtr(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_float,0); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_getPtr__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float *result = 0 ; - SWIG_check_num_args("ofVec3f::getPtr",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::getPtr",1,"ofVec3f const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_getPtr",1,SWIGTYPE_p_ofVec3f); } - result = (float *)((ofVec3f const *)arg1)->getPtr(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_float,0); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_getPtr(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Vec3f_getPtr__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Vec3f_getPtr__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec3f_getPtr'\n" " Possible C/C++ prototypes are:\n" - " ofVec3f::getPtr()\n" " ofVec3f::getPtr() const\n"); lua_error(L);return 0; } -static int _wrap_Vec3f_set__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float arg2 ; float arg3 ; - float arg4 ; SWIG_check_num_args("ofVec3f::set",4,4) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::set",1,"ofVec3f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec3f::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVec3f::set",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVec3f::set",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_set",1,SWIGTYPE_p_ofVec3f); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - (arg1)->set(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_set__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofVec3f::set",3,3) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::set",1,"ofVec3f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec3f::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVec3f::set",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_set",1,SWIGTYPE_p_ofVec3f); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); (arg1)->set(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_set__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; - SWIG_check_num_args("ofVec3f::set",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::set",1,"ofVec3f *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec3f::set",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_set",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_set",2,SWIGTYPE_p_ofVec3f); } - (arg1)->set((ofVec3f const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_set__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float arg2 ; - SWIG_check_num_args("ofVec3f::set",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::set",1,"ofVec3f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec3f::set",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_set",1,SWIGTYPE_p_ofVec3f); } - arg2 = (float)lua_tonumber(L, 2); (arg1)->set(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_set(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec3f_set__SWIG_2(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Vec3f_set__SWIG_3(L);} } } - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Vec3f_set__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Vec3f_set__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec3f_set'\n" " Possible C/C++ prototypes are:\n" - " ofVec3f::set(float,float,float)\n" " ofVec3f::set(float,float)\n" " ofVec3f::set(ofVec3f const &)\n" - " ofVec3f::set(float)\n"); lua_error(L);return 0; } -static int _wrap_Vec3f___eq(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; bool result; - SWIG_check_num_args("ofVec3f::operator ==",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::operator ==",1,"ofVec3f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec3f::operator ==",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f___eq",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f___eq",2,SWIGTYPE_p_ofVec3f); } - result = (bool)((ofVec3f const *)arg1)->operator ==((ofVec3f const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_match__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; - float arg3 ; bool result; SWIG_check_num_args("ofVec3f::match",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::match",1,"ofVec3f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec3f::match",2,"ofVec3f const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVec3f::match",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_match",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_match",2,SWIGTYPE_p_ofVec3f); } - arg3 = (float)lua_tonumber(L, 3); result = (bool)((ofVec3f const *)arg1)->match((ofVec3f const &)*arg2,arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_match__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; - bool result; SWIG_check_num_args("ofVec3f::match",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::match",1,"ofVec3f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec3f::match",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_match",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_match",2,SWIGTYPE_p_ofVec3f); } - result = (bool)((ofVec3f const *)arg1)->match((ofVec3f const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_match(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec3f_match__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Vec3f_match__SWIG_0(L);} } } - } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec3f_match'\n" " Possible C/C++ prototypes are:\n" - " ofVec3f::match(ofVec3f const &,float) const\n" " ofVec3f::match(ofVec3f const &) const\n"); lua_error(L);return 0; } -static int _wrap_Vec3f_isAligned__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; - float arg3 ; bool result; SWIG_check_num_args("ofVec3f::isAligned",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::isAligned",1,"ofVec3f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec3f::isAligned",2,"ofVec3f const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVec3f::isAligned",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_isAligned",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_isAligned",2,SWIGTYPE_p_ofVec3f); } arg3 = (float)lua_tonumber(L, 3); - result = (bool)((ofVec3f const *)arg1)->isAligned((ofVec3f const &)*arg2,arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_isAligned__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; - bool result; SWIG_check_num_args("ofVec3f::isAligned",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::isAligned",1,"ofVec3f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec3f::isAligned",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_isAligned",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_isAligned",2,SWIGTYPE_p_ofVec3f); } - result = (bool)((ofVec3f const *)arg1)->isAligned((ofVec3f const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_isAligned(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec3f_isAligned__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Vec3f_isAligned__SWIG_0(L);} } - } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec3f_isAligned'\n" - " Possible C/C++ prototypes are:\n" " ofVec3f::isAligned(ofVec3f const &,float) const\n" - " ofVec3f::isAligned(ofVec3f const &) const\n"); lua_error(L);return 0; } -static int _wrap_Vec3f_isAlignedRad__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; - ofVec3f *arg2 = 0 ; float arg3 ; bool result; SWIG_check_num_args("ofVec3f::isAlignedRad",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::isAlignedRad",1,"ofVec3f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec3f::isAlignedRad",2,"ofVec3f const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVec3f::isAlignedRad",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_isAlignedRad",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_isAlignedRad",2,SWIGTYPE_p_ofVec3f); } arg3 = (float)lua_tonumber(L, 3); - result = (bool)((ofVec3f const *)arg1)->isAlignedRad((ofVec3f const &)*arg2,arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_isAlignedRad__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; - ofVec3f *arg2 = 0 ; bool result; SWIG_check_num_args("ofVec3f::isAlignedRad",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::isAlignedRad",1,"ofVec3f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec3f::isAlignedRad",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_isAlignedRad",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_isAlignedRad",2,SWIGTYPE_p_ofVec3f); } - result = (bool)((ofVec3f const *)arg1)->isAlignedRad((ofVec3f const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_isAlignedRad(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec3f_isAlignedRad__SWIG_1(L);} } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Vec3f_isAlignedRad__SWIG_0(L);} - } } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec3f_isAlignedRad'\n" - " Possible C/C++ prototypes are:\n" " ofVec3f::isAlignedRad(ofVec3f const &,float) const\n" - " ofVec3f::isAlignedRad(ofVec3f const &) const\n"); lua_error(L);return 0; } -static int _wrap_Vec3f_align__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; - float arg3 ; bool result; SWIG_check_num_args("ofVec3f::align",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::align",1,"ofVec3f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec3f::align",2,"ofVec3f const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVec3f::align",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_align",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_align",2,SWIGTYPE_p_ofVec3f); } - arg3 = (float)lua_tonumber(L, 3); result = (bool)((ofVec3f const *)arg1)->align((ofVec3f const &)*arg2,arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_align__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; - bool result; SWIG_check_num_args("ofVec3f::align",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::align",1,"ofVec3f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec3f::align",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_align",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_align",2,SWIGTYPE_p_ofVec3f); } - result = (bool)((ofVec3f const *)arg1)->align((ofVec3f const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_align(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec3f_align__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Vec3f_align__SWIG_0(L);} } } - } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec3f_align'\n" " Possible C/C++ prototypes are:\n" - " ofVec3f::align(ofVec3f const &,float) const\n" " ofVec3f::align(ofVec3f const &) const\n"); lua_error(L);return 0; } -static int _wrap_Vec3f_alignRad__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; - float arg3 ; bool result; SWIG_check_num_args("ofVec3f::alignRad",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::alignRad",1,"ofVec3f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec3f::alignRad",2,"ofVec3f const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVec3f::alignRad",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_alignRad",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_alignRad",2,SWIGTYPE_p_ofVec3f); } arg3 = (float)lua_tonumber(L, 3); - result = (bool)((ofVec3f const *)arg1)->alignRad((ofVec3f const &)*arg2,arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_alignRad__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; - bool result; SWIG_check_num_args("ofVec3f::alignRad",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::alignRad",1,"ofVec3f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec3f::alignRad",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_alignRad",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_alignRad",2,SWIGTYPE_p_ofVec3f); } - result = (bool)((ofVec3f const *)arg1)->alignRad((ofVec3f const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_alignRad(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec3f_alignRad__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Vec3f_alignRad__SWIG_0(L);} } - } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec3f_alignRad'\n" - " Possible C/C++ prototypes are:\n" " ofVec3f::alignRad(ofVec3f const &,float) const\n" - " ofVec3f::alignRad(ofVec3f const &) const\n"); lua_error(L);return 0; } -static int _wrap_Vec3f___add__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; - ofVec3f result; SWIG_check_num_args("ofVec3f::operator +",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::operator +",1,"ofVec3f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec3f::operator +",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f___add",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f___add",2,SWIGTYPE_p_ofVec3f); } - result = ((ofVec3f const *)arg1)->operator +((ofVec3f const &)*arg2); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f___add__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float arg2 ; - ofVec3f result; SWIG_check_num_args("ofVec3f::operator +",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::operator +",1,"ofVec3f const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec3f::operator +",2,"float const"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f___add",1,SWIGTYPE_p_ofVec3f); } - arg2 = (float const)lua_tonumber(L, 2); result = ((ofVec3f const *)arg1)->operator +(arg2); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f___add(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec3f___add__SWIG_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Vec3f___add__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec3f___add'\n" " Possible C/C++ prototypes are:\n" - " ofVec3f::operator +(ofVec3f const &) const\n" " ofVec3f::operator +(float const) const\n"); lua_error(L);return 0; } -static int _wrap_Vec3f___sub__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; - ofVec3f result; SWIG_check_num_args("ofVec3f::operator -",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::operator -",1,"ofVec3f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec3f::operator -",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f___sub",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f___sub",2,SWIGTYPE_p_ofVec3f); } - result = ((ofVec3f const *)arg1)->operator -((ofVec3f const &)*arg2); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f___sub__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float arg2 ; - ofVec3f result; SWIG_check_num_args("ofVec3f::operator -",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::operator -",1,"ofVec3f const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec3f::operator -",2,"float const"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f___sub",1,SWIGTYPE_p_ofVec3f); } - arg2 = (float const)lua_tonumber(L, 2); result = ((ofVec3f const *)arg1)->operator -(arg2); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f___sub(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec3f___sub__SWIG_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Vec3f___sub__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec3f___sub'\n" " Possible C/C++ prototypes are:\n" - " ofVec3f::operator -(ofVec3f const &) const\n" " ofVec3f::operator -(float const) const\n"); lua_error(L);return 0; } -static int _wrap_Vec3f___unm(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f result; - SWIG_check_num_args("ofVec3f::operator -",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::operator -",1,"ofVec3f const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f___unm",1,SWIGTYPE_p_ofVec3f); } - result = ((ofVec3f const *)arg1)->operator -(); { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f___mul__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; - ofVec3f result; SWIG_check_num_args("ofVec3f::operator *",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::operator *",1,"ofVec3f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec3f::operator *",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f___mul",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f___mul",2,SWIGTYPE_p_ofVec3f); } - result = ((ofVec3f const *)arg1)->operator *((ofVec3f const &)*arg2); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f___mul__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float arg2 ; - ofVec3f result; SWIG_check_num_args("ofVec3f::operator *",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::operator *",1,"ofVec3f const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec3f::operator *",2,"float const"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f___mul",1,SWIGTYPE_p_ofVec3f); } - arg2 = (float const)lua_tonumber(L, 2); result = ((ofVec3f const *)arg1)->operator *(arg2); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f___mul(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec3f___mul__SWIG_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Vec3f___mul__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec3f___mul'\n" " Possible C/C++ prototypes are:\n" - " ofVec3f::operator *(ofVec3f const &) const\n" " ofVec3f::operator *(float const) const\n"); lua_error(L);return 0; } -static int _wrap_Vec3f___div__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; - ofVec3f result; SWIG_check_num_args("ofVec3f::operator /",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::operator /",1,"ofVec3f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec3f::operator /",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f___div",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f___div",2,SWIGTYPE_p_ofVec3f); } - result = ((ofVec3f const *)arg1)->operator /((ofVec3f const &)*arg2); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f___div__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float arg2 ; - ofVec3f result; SWIG_check_num_args("ofVec3f::operator /",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::operator /",1,"ofVec3f const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec3f::operator /",2,"float const"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f___div",1,SWIGTYPE_p_ofVec3f); } - arg2 = (float const)lua_tonumber(L, 2); result = ((ofVec3f const *)arg1)->operator /(arg2); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f___div(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec3f___div__SWIG_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Vec3f___div__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec3f___div'\n" " Possible C/C++ prototypes are:\n" - " ofVec3f::operator /(ofVec3f const &) const\n" " ofVec3f::operator /(float const) const\n"); lua_error(L);return 0; } -static int _wrap_Vec3f_getScaled(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float arg2 ; ofVec3f result; - SWIG_check_num_args("ofVec3f::getScaled",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::getScaled",1,"ofVec3f const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec3f::getScaled",2,"float const"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_getScaled",1,SWIGTYPE_p_ofVec3f); } arg2 = (float const)lua_tonumber(L, 2); - result = ((ofVec3f const *)arg1)->getScaled(arg2); { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_scale(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float arg2 ; - ofVec3f *result = 0 ; SWIG_check_num_args("ofVec3f::scale",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::scale",1,"ofVec3f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec3f::scale",2,"float const"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_scale",1,SWIGTYPE_p_ofVec3f); } - arg2 = (float const)lua_tonumber(L, 2); result = (ofVec3f *) &(arg1)->scale(arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec3f_getRotated__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float arg2 ; - ofVec3f *arg3 = 0 ; ofVec3f result; SWIG_check_num_args("ofVec3f::getRotated",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::getRotated",1,"ofVec3f const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec3f::getRotated",2,"float"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofVec3f::getRotated",3,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_getRotated",1,SWIGTYPE_p_ofVec3f); } arg2 = (float)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_getRotated",3,SWIGTYPE_p_ofVec3f); } - result = ((ofVec3f const *)arg1)->getRotated(arg2,(ofVec3f const &)*arg3); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_getRotated__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float arg2 ; - float arg3 ; float arg4 ; ofVec3f result; SWIG_check_num_args("ofVec3f::getRotated",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::getRotated",1,"ofVec3f const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec3f::getRotated",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVec3f::getRotated",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVec3f::getRotated",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_getRotated",1,SWIGTYPE_p_ofVec3f); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - result = ((ofVec3f const *)arg1)->getRotated(arg2,arg3,arg4); { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_getRotated__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float arg2 ; - ofVec3f *arg3 = 0 ; ofVec3f *arg4 = 0 ; ofVec3f result; SWIG_check_num_args("ofVec3f::getRotated",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::getRotated",1,"ofVec3f const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec3f::getRotated",2,"float"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofVec3f::getRotated",3,"ofVec3f const &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofVec3f::getRotated",4,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_getRotated",1,SWIGTYPE_p_ofVec3f); } arg2 = (float)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_getRotated",3,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_getRotated",4,SWIGTYPE_p_ofVec3f); } - result = ((ofVec3f const *)arg1)->getRotated(arg2,(ofVec3f const &)*arg3,(ofVec3f const &)*arg4); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_getRotated(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec3f_getRotated__SWIG_0(L);} } } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec3f_getRotated__SWIG_2(L);} } } } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Vec3f_getRotated__SWIG_1(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec3f_getRotated'\n" " Possible C/C++ prototypes are:\n" - " ofVec3f::getRotated(float,ofVec3f const &) const\n" " ofVec3f::getRotated(float,float,float) const\n" - " ofVec3f::getRotated(float,ofVec3f const &,ofVec3f const &) const\n"); lua_error(L);return 0; } -static int _wrap_Vec3f_getRotatedRad__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float arg2 ; - ofVec3f *arg3 = 0 ; ofVec3f result; SWIG_check_num_args("ofVec3f::getRotatedRad",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::getRotatedRad",1,"ofVec3f const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec3f::getRotatedRad",2,"float"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofVec3f::getRotatedRad",3,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_getRotatedRad",1,SWIGTYPE_p_ofVec3f); } arg2 = (float)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_getRotatedRad",3,SWIGTYPE_p_ofVec3f); } - result = ((ofVec3f const *)arg1)->getRotatedRad(arg2,(ofVec3f const &)*arg3); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_getRotatedRad__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float arg2 ; - float arg3 ; float arg4 ; ofVec3f result; SWIG_check_num_args("ofVec3f::getRotatedRad",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::getRotatedRad",1,"ofVec3f const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec3f::getRotatedRad",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVec3f::getRotatedRad",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVec3f::getRotatedRad",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_getRotatedRad",1,SWIGTYPE_p_ofVec3f); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - result = ((ofVec3f const *)arg1)->getRotatedRad(arg2,arg3,arg4); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_getRotatedRad__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float arg2 ; - ofVec3f *arg3 = 0 ; ofVec3f *arg4 = 0 ; ofVec3f result; SWIG_check_num_args("ofVec3f::getRotatedRad",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::getRotatedRad",1,"ofVec3f const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec3f::getRotatedRad",2,"float"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofVec3f::getRotatedRad",3,"ofVec3f const &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofVec3f::getRotatedRad",4,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_getRotatedRad",1,SWIGTYPE_p_ofVec3f); } arg2 = (float)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_getRotatedRad",3,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_getRotatedRad",4,SWIGTYPE_p_ofVec3f); } - result = ((ofVec3f const *)arg1)->getRotatedRad(arg2,(ofVec3f const &)*arg3,(ofVec3f const &)*arg4); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_getRotatedRad(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec3f_getRotatedRad__SWIG_0(L);} } } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec3f_getRotatedRad__SWIG_2(L);} } } } } if (argc == 4) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Vec3f_getRotatedRad__SWIG_1(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec3f_getRotatedRad'\n" - " Possible C/C++ prototypes are:\n" " ofVec3f::getRotatedRad(float,ofVec3f const &) const\n" - " ofVec3f::getRotatedRad(float,float,float) const\n" - " ofVec3f::getRotatedRad(float,ofVec3f const &,ofVec3f const &) const\n"); lua_error(L);return 0; } -static int _wrap_Vec3f_rotate__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float arg2 ; - ofVec3f *arg3 = 0 ; ofVec3f *result = 0 ; SWIG_check_num_args("ofVec3f::rotate",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::rotate",1,"ofVec3f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec3f::rotate",2,"float"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofVec3f::rotate",3,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_rotate",1,SWIGTYPE_p_ofVec3f); } - arg2 = (float)lua_tonumber(L, 2); if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_rotate",3,SWIGTYPE_p_ofVec3f); } result = (ofVec3f *) &(arg1)->rotate(arg2,(ofVec3f const &)*arg3); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec3f_rotate__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float arg2 ; - float arg3 ; float arg4 ; ofVec3f *result = 0 ; SWIG_check_num_args("ofVec3f::rotate",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::rotate",1,"ofVec3f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec3f::rotate",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVec3f::rotate",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVec3f::rotate",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_rotate",1,SWIGTYPE_p_ofVec3f); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - result = (ofVec3f *) &(arg1)->rotate(arg2,arg3,arg4); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,0); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_rotate__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float arg2 ; - ofVec3f *arg3 = 0 ; ofVec3f *arg4 = 0 ; ofVec3f *result = 0 ; SWIG_check_num_args("ofVec3f::rotate",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::rotate",1,"ofVec3f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec3f::rotate",2,"float"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofVec3f::rotate",3,"ofVec3f const &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofVec3f::rotate",4,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_rotate",1,SWIGTYPE_p_ofVec3f); } - arg2 = (float)lua_tonumber(L, 2); if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_rotate",3,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_rotate",4,SWIGTYPE_p_ofVec3f); } - result = (ofVec3f *) &(arg1)->rotate(arg2,(ofVec3f const &)*arg3,(ofVec3f const &)*arg4); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec3f_rotate(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec3f_rotate__SWIG_0(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec3f_rotate__SWIG_2(L);} } } } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Vec3f_rotate__SWIG_1(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec3f_rotate'\n" " Possible C/C++ prototypes are:\n" - " ofVec3f::rotate(float,ofVec3f const &)\n" " ofVec3f::rotate(float,float,float)\n" - " ofVec3f::rotate(float,ofVec3f const &,ofVec3f const &)\n"); lua_error(L);return 0; } -static int _wrap_Vec3f_rotateRad__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float arg2 ; - ofVec3f *arg3 = 0 ; ofVec3f *result = 0 ; SWIG_check_num_args("ofVec3f::rotateRad",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::rotateRad",1,"ofVec3f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec3f::rotateRad",2,"float"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofVec3f::rotateRad",3,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_rotateRad",1,SWIGTYPE_p_ofVec3f); } arg2 = (float)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_rotateRad",3,SWIGTYPE_p_ofVec3f); } - result = (ofVec3f *) &(arg1)->rotateRad(arg2,(ofVec3f const &)*arg3); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec3f_rotateRad__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float arg2 ; - float arg3 ; float arg4 ; ofVec3f *result = 0 ; SWIG_check_num_args("ofVec3f::rotateRad",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::rotateRad",1,"ofVec3f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec3f::rotateRad",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVec3f::rotateRad",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVec3f::rotateRad",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_rotateRad",1,SWIGTYPE_p_ofVec3f); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); result = (ofVec3f *) &(arg1)->rotateRad(arg2,arg3,arg4); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec3f_rotateRad__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float arg2 ; - ofVec3f *arg3 = 0 ; ofVec3f *arg4 = 0 ; ofVec3f *result = 0 ; SWIG_check_num_args("ofVec3f::rotateRad",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::rotateRad",1,"ofVec3f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec3f::rotateRad",2,"float"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofVec3f::rotateRad",3,"ofVec3f const &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofVec3f::rotateRad",4,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_rotateRad",1,SWIGTYPE_p_ofVec3f); } arg2 = (float)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_rotateRad",3,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_rotateRad",4,SWIGTYPE_p_ofVec3f); } - result = (ofVec3f *) &(arg1)->rotateRad(arg2,(ofVec3f const &)*arg3,(ofVec3f const &)*arg4); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec3f_rotateRad(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec3f_rotateRad__SWIG_0(L);} } } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec3f_rotateRad__SWIG_2(L);} } } } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Vec3f_rotateRad__SWIG_1(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec3f_rotateRad'\n" " Possible C/C++ prototypes are:\n" - " ofVec3f::rotateRad(float,ofVec3f const &)\n" " ofVec3f::rotateRad(float,float,float)\n" - " ofVec3f::rotateRad(float,ofVec3f const &,ofVec3f const &)\n"); lua_error(L);return 0; } -static int _wrap_Vec3f_getMapped(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; - ofVec3f *arg3 = 0 ; ofVec3f *arg4 = 0 ; ofVec3f *arg5 = 0 ; ofVec3f result; SWIG_check_num_args("ofVec3f::getMapped",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::getMapped",1,"ofVec3f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec3f::getMapped",2,"ofVec3f const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofVec3f::getMapped",3,"ofVec3f const &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofVec3f::getMapped",4,"ofVec3f const &"); - if(!lua_isuserdata(L,5)) SWIG_fail_arg("ofVec3f::getMapped",5,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_getMapped",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_getMapped",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_getMapped",3,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_getMapped",4,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_getMapped",5,SWIGTYPE_p_ofVec3f); } - result = ((ofVec3f const *)arg1)->getMapped((ofVec3f const &)*arg2,(ofVec3f const &)*arg3,(ofVec3f const &)*arg4,(ofVec3f const &)*arg5); - { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_map(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; - ofVec3f *arg3 = 0 ; ofVec3f *arg4 = 0 ; ofVec3f *arg5 = 0 ; ofVec3f *result = 0 ; SWIG_check_num_args("ofVec3f::map",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::map",1,"ofVec3f *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec3f::map",2,"ofVec3f const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofVec3f::map",3,"ofVec3f const &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofVec3f::map",4,"ofVec3f const &"); - if(!lua_isuserdata(L,5)) SWIG_fail_arg("ofVec3f::map",5,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_map",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_map",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_map",3,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_map",4,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_map",5,SWIGTYPE_p_ofVec3f); } - result = (ofVec3f *) &(arg1)->map((ofVec3f const &)*arg2,(ofVec3f const &)*arg3,(ofVec3f const &)*arg4,(ofVec3f const &)*arg5); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec3f_distance(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; - float result; SWIG_check_num_args("ofVec3f::distance",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::distance",1,"ofVec3f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec3f::distance",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_distance",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_distance",2,SWIGTYPE_p_ofVec3f); } - result = (float)((ofVec3f const *)arg1)->distance((ofVec3f const &)*arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_squareDistance(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; - float result; SWIG_check_num_args("ofVec3f::squareDistance",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::squareDistance",1,"ofVec3f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec3f::squareDistance",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_squareDistance",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_squareDistance",2,SWIGTYPE_p_ofVec3f); } - result = (float)((ofVec3f const *)arg1)->squareDistance((ofVec3f const &)*arg2); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_getInterpolated(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; - float arg3 ; ofVec3f result; SWIG_check_num_args("ofVec3f::getInterpolated",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::getInterpolated",1,"ofVec3f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec3f::getInterpolated",2,"ofVec3f const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVec3f::getInterpolated",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_getInterpolated",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_getInterpolated",2,SWIGTYPE_p_ofVec3f); } arg3 = (float)lua_tonumber(L, 3); - result = ((ofVec3f const *)arg1)->getInterpolated((ofVec3f const &)*arg2,arg3); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_interpolate(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; - float arg3 ; ofVec3f *result = 0 ; SWIG_check_num_args("ofVec3f::interpolate",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::interpolate",1,"ofVec3f *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec3f::interpolate",2,"ofVec3f const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVec3f::interpolate",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_interpolate",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_interpolate",2,SWIGTYPE_p_ofVec3f); } arg3 = (float)lua_tonumber(L, 3); - result = (ofVec3f *) &(arg1)->interpolate((ofVec3f const &)*arg2,arg3); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec3f_getMiddle(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; - ofVec3f result; SWIG_check_num_args("ofVec3f::getMiddle",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::getMiddle",1,"ofVec3f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec3f::getMiddle",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_getMiddle",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_getMiddle",2,SWIGTYPE_p_ofVec3f); } - result = ((ofVec3f const *)arg1)->getMiddle((ofVec3f const &)*arg2); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_middle(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; - ofVec3f *result = 0 ; SWIG_check_num_args("ofVec3f::middle",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::middle",1,"ofVec3f *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec3f::middle",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_middle",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_middle",2,SWIGTYPE_p_ofVec3f); } result = (ofVec3f *) &(arg1)->middle((ofVec3f const &)*arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec3f_average(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = (ofVec3f *) 0 ; - int arg3 ; ofVec3f *result = 0 ; SWIG_check_num_args("ofVec3f::average",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::average",1,"ofVec3f *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofVec3f::average",2,"ofVec3f const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVec3f::average",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_average",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_average",2,SWIGTYPE_p_ofVec3f); } arg3 = (int)lua_tonumber(L, 3); - result = (ofVec3f *) &(arg1)->average((ofVec3f const *)arg2,arg3); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec3f_getNormalized(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f result; - SWIG_check_num_args("ofVec3f::getNormalized",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::getNormalized",1,"ofVec3f const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_getNormalized",1,SWIGTYPE_p_ofVec3f); } result = ((ofVec3f const *)arg1)->getNormalized(); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_normalize(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *result = 0 ; - SWIG_check_num_args("ofVec3f::normalize",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::normalize",1,"ofVec3f *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_normalize",1,SWIGTYPE_p_ofVec3f); } result = (ofVec3f *) &(arg1)->normalize(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec3f_getLimited(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float arg2 ; ofVec3f result; - SWIG_check_num_args("ofVec3f::getLimited",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::getLimited",1,"ofVec3f const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec3f::getLimited",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_getLimited",1,SWIGTYPE_p_ofVec3f); } arg2 = (float)lua_tonumber(L, 2); - result = ((ofVec3f const *)arg1)->getLimited(arg2); { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_limit(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float arg2 ; - ofVec3f *result = 0 ; SWIG_check_num_args("ofVec3f::limit",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::limit",1,"ofVec3f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec3f::limit",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_limit",1,SWIGTYPE_p_ofVec3f); } - arg2 = (float)lua_tonumber(L, 2); result = (ofVec3f *) &(arg1)->limit(arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec3f_length(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float result; - SWIG_check_num_args("ofVec3f::length",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::length",1,"ofVec3f const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_length",1,SWIGTYPE_p_ofVec3f); } - result = (float)((ofVec3f const *)arg1)->length(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_lengthSquared(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float result; - SWIG_check_num_args("ofVec3f::lengthSquared",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::lengthSquared",1,"ofVec3f const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_lengthSquared",1,SWIGTYPE_p_ofVec3f); } result = (float)((ofVec3f const *)arg1)->lengthSquared(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_angle(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; float result; - SWIG_check_num_args("ofVec3f::angle",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::angle",1,"ofVec3f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec3f::angle",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_angle",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_angle",2,SWIGTYPE_p_ofVec3f); } - result = (float)((ofVec3f const *)arg1)->angle((ofVec3f const &)*arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_angleRad(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; - float result; SWIG_check_num_args("ofVec3f::angleRad",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::angleRad",1,"ofVec3f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec3f::angleRad",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_angleRad",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_angleRad",2,SWIGTYPE_p_ofVec3f); } - result = (float)((ofVec3f const *)arg1)->angleRad((ofVec3f const &)*arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_getPerpendicular(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; - ofVec3f result; SWIG_check_num_args("ofVec3f::getPerpendicular",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::getPerpendicular",1,"ofVec3f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec3f::getPerpendicular",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_getPerpendicular",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_getPerpendicular",2,SWIGTYPE_p_ofVec3f); } - result = ((ofVec3f const *)arg1)->getPerpendicular((ofVec3f const &)*arg2); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_perpendicular(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; - ofVec3f *result = 0 ; SWIG_check_num_args("ofVec3f::perpendicular",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::perpendicular",1,"ofVec3f *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec3f::perpendicular",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_perpendicular",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_perpendicular",2,SWIGTYPE_p_ofVec3f); } - result = (ofVec3f *) &(arg1)->perpendicular((ofVec3f const &)*arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec3f_getCrossed(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; - ofVec3f result; SWIG_check_num_args("ofVec3f::getCrossed",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::getCrossed",1,"ofVec3f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec3f::getCrossed",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_getCrossed",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_getCrossed",2,SWIGTYPE_p_ofVec3f); } - result = ((ofVec3f const *)arg1)->getCrossed((ofVec3f const &)*arg2); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_cross(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; - ofVec3f *result = 0 ; SWIG_check_num_args("ofVec3f::cross",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::cross",1,"ofVec3f *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec3f::cross",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_cross",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_cross",2,SWIGTYPE_p_ofVec3f); } - result = (ofVec3f *) &(arg1)->cross((ofVec3f const &)*arg2); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,0); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_dot(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; float result; - SWIG_check_num_args("ofVec3f::dot",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::dot",1,"ofVec3f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec3f::dot",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_dot",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_dot",2,SWIGTYPE_p_ofVec3f); } - result = (float)((ofVec3f const *)arg1)->dot((ofVec3f const &)*arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_zero(lua_State* L) { int SWIG_arg = 0; ofVec3f result; SWIG_check_num_args("ofVec3f::zero",0,0) - result = ofVec3f::zero(); { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_one(lua_State* L) { int SWIG_arg = 0; ofVec3f result; SWIG_check_num_args("ofVec3f::one",0,0) - result = ofVec3f::one(); { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f___tostring(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; char *result = 0 ; - SWIG_check_num_args("ofVec3f::__str__",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::__str__",1,"ofVec3f *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f___tostring",1,SWIGTYPE_p_ofVec3f); } result = (char *)ofVec3f___str__(arg1); - lua_pushstring(L,(const char *)result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_Vec3f(void *obj) { -ofVec3f *arg1 = (ofVec3f *) obj; -delete arg1; -} -static int _proxy__wrap_new_Vec3f(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_Vec3f); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_Vec3f_attributes[] = { - { "x", _wrap_Vec3f_x_get, _wrap_Vec3f_x_set }, - { "y", _wrap_Vec3f_y_get, _wrap_Vec3f_y_set }, - { "z", _wrap_Vec3f_z_get, _wrap_Vec3f_z_set }, - {0,0,0} -}; -static swig_lua_method swig_Vec3f_methods[]= { - { "getPtr", _wrap_Vec3f_getPtr}, - { "set", _wrap_Vec3f_set}, - { "__eq", _wrap_Vec3f___eq}, - { "match", _wrap_Vec3f_match}, - { "isAligned", _wrap_Vec3f_isAligned}, - { "isAlignedRad", _wrap_Vec3f_isAlignedRad}, - { "align", _wrap_Vec3f_align}, - { "alignRad", _wrap_Vec3f_alignRad}, - { "__add", _wrap_Vec3f___add}, - { "__sub", _wrap_Vec3f___sub}, - { "__unm", _wrap_Vec3f___unm}, - { "__mul", _wrap_Vec3f___mul}, - { "__div", _wrap_Vec3f___div}, - { "getScaled", _wrap_Vec3f_getScaled}, - { "scale", _wrap_Vec3f_scale}, - { "getRotated", _wrap_Vec3f_getRotated}, - { "getRotatedRad", _wrap_Vec3f_getRotatedRad}, - { "rotate", _wrap_Vec3f_rotate}, - { "rotateRad", _wrap_Vec3f_rotateRad}, - { "getMapped", _wrap_Vec3f_getMapped}, - { "map", _wrap_Vec3f_map}, - { "distance", _wrap_Vec3f_distance}, - { "squareDistance", _wrap_Vec3f_squareDistance}, - { "getInterpolated", _wrap_Vec3f_getInterpolated}, - { "interpolate", _wrap_Vec3f_interpolate}, - { "getMiddle", _wrap_Vec3f_getMiddle}, - { "middle", _wrap_Vec3f_middle}, - { "average", _wrap_Vec3f_average}, - { "getNormalized", _wrap_Vec3f_getNormalized}, - { "normalize", _wrap_Vec3f_normalize}, - { "getLimited", _wrap_Vec3f_getLimited}, - { "limit", _wrap_Vec3f_limit}, - { "length", _wrap_Vec3f_length}, - { "lengthSquared", _wrap_Vec3f_lengthSquared}, - { "angle", _wrap_Vec3f_angle}, - { "angleRad", _wrap_Vec3f_angleRad}, - { "getPerpendicular", _wrap_Vec3f_getPerpendicular}, - { "perpendicular", _wrap_Vec3f_perpendicular}, - { "getCrossed", _wrap_Vec3f_getCrossed}, - { "cross", _wrap_Vec3f_cross}, - { "dot", _wrap_Vec3f_dot}, - { "__tostring", _wrap_Vec3f___tostring}, - {0,0} -}; -static swig_lua_method swig_Vec3f_meta[] = { - { "__eq", _wrap_Vec3f___eq}, - { "__add", _wrap_Vec3f___add}, - { "__sub", _wrap_Vec3f___sub}, - { "__unm", _wrap_Vec3f___unm}, - { "__mul", _wrap_Vec3f___mul}, - { "__div", _wrap_Vec3f___div}, - { "__tostring", _wrap_Vec3f___tostring}, - {0,0} -}; - -static swig_lua_attribute swig_Vec3f_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_Vec3f_Sf_SwigStatic_constants[]= { - {SWIG_LUA_CONSTTAB_INT("DIM", ofVec3f::DIM)}, - {0,0,0,0,0,0} -}; -static swig_lua_method swig_Vec3f_Sf_SwigStatic_methods[]= { - { "zero", _wrap_Vec3f_zero}, - { "one", _wrap_Vec3f_one}, - {0,0} -}; -static swig_lua_class* swig_Vec3f_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_Vec3f_Sf_SwigStatic = { - "Vec3f", - swig_Vec3f_Sf_SwigStatic_methods, - swig_Vec3f_Sf_SwigStatic_attributes, - swig_Vec3f_Sf_SwigStatic_constants, - swig_Vec3f_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_Vec3f_bases[] = {0}; -static const char *swig_Vec3f_base_names[] = {0}; -static swig_lua_class _wrap_class_Vec3f = { "Vec3f", "Vec3f", &SWIGTYPE_p_ofVec3f,_proxy__wrap_new_Vec3f, swig_delete_Vec3f, swig_Vec3f_methods, swig_Vec3f_attributes, &swig_Vec3f_Sf_SwigStatic, swig_Vec3f_meta, swig_Vec3f_bases, swig_Vec3f_base_names }; - -static int _wrap_Vec4f_x_set(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; float arg2 ; - SWIG_check_num_args("ofVec4f::x",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::x",1,"ofVec4f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec4f::x",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f_x_set",1,SWIGTYPE_p_ofVec4f); } - arg2 = (float)lua_tonumber(L, 2); if (arg1) (arg1)->x = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec4f_x_get(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; float result; - SWIG_check_num_args("ofVec4f::x",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::x",1,"ofVec4f *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f_x_get",1,SWIGTYPE_p_ofVec4f); } - result = (float) ((arg1)->x); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f_y_set(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; float arg2 ; - SWIG_check_num_args("ofVec4f::y",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::y",1,"ofVec4f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec4f::y",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f_y_set",1,SWIGTYPE_p_ofVec4f); } - arg2 = (float)lua_tonumber(L, 2); if (arg1) (arg1)->y = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec4f_y_get(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; float result; - SWIG_check_num_args("ofVec4f::y",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::y",1,"ofVec4f *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f_y_get",1,SWIGTYPE_p_ofVec4f); } - result = (float) ((arg1)->y); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f_z_set(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; float arg2 ; - SWIG_check_num_args("ofVec4f::z",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::z",1,"ofVec4f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec4f::z",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f_z_set",1,SWIGTYPE_p_ofVec4f); } - arg2 = (float)lua_tonumber(L, 2); if (arg1) (arg1)->z = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec4f_z_get(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; float result; - SWIG_check_num_args("ofVec4f::z",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::z",1,"ofVec4f *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f_z_get",1,SWIGTYPE_p_ofVec4f); } - result = (float) ((arg1)->z); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f_w_set(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; float arg2 ; - SWIG_check_num_args("ofVec4f::w",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::w",1,"ofVec4f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec4f::w",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f_w_set",1,SWIGTYPE_p_ofVec4f); } - arg2 = (float)lua_tonumber(L, 2); if (arg1) (arg1)->w = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec4f_w_get(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; float result; - SWIG_check_num_args("ofVec4f::w",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::w",1,"ofVec4f *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f_w_get",1,SWIGTYPE_p_ofVec4f); } - result = (float) ((arg1)->w); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_Vec4f__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec4f *result = 0 ; - SWIG_check_num_args("ofVec4f::ofVec4f",0,0) result = (ofVec4f *)new ofVec4f(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec4f,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Vec4f__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; ofVec4f *result = 0 ; - SWIG_check_num_args("ofVec4f::ofVec4f",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofVec4f::ofVec4f",1,"float"); - arg1 = (float)lua_tonumber(L, 1); result = (ofVec4f *)new ofVec4f(arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec4f,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Vec4f__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - ofVec4f *result = 0 ; SWIG_check_num_args("ofVec4f::ofVec4f",4,4) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofVec4f::ofVec4f",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec4f::ofVec4f",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVec4f::ofVec4f",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVec4f::ofVec4f",4,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - result = (ofVec4f *)new ofVec4f(arg1,arg2,arg3,arg4); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec4f,1); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_new_Vec4f__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = 0 ; ofVec4f *result = 0 ; - SWIG_check_num_args("ofVec4f::ofVec4f",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofVec4f::ofVec4f",1,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("new_Vec4f",1,SWIGTYPE_p_ofVec2f); } - result = (ofVec4f *)new ofVec4f((ofVec2f const &)*arg1); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec4f,1); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_new_Vec4f__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = 0 ; ofVec4f *result = 0 ; - SWIG_check_num_args("ofVec4f::ofVec4f",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofVec4f::ofVec4f",1,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("new_Vec4f",1,SWIGTYPE_p_ofVec3f); } - result = (ofVec4f *)new ofVec4f((ofVec3f const &)*arg1); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec4f,1); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_new_Vec4f(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_Vec4f__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_new_Vec4f__SWIG_3(L);} } if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_new_Vec4f__SWIG_4(L);} } if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_new_Vec4f__SWIG_1(L);} } if (argc == 4) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_new_Vec4f__SWIG_2(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_Vec4f'\n" " Possible C/C++ prototypes are:\n" - " ofVec4f::ofVec4f()\n" " ofVec4f::ofVec4f(float)\n" " ofVec4f::ofVec4f(float,float,float,float)\n" - " ofVec4f::ofVec4f(ofVec2f const &)\n" " ofVec4f::ofVec4f(ofVec3f const &)\n"); lua_error(L);return 0; } -static int _wrap_Vec4f_getPtr__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; float *result = 0 ; - SWIG_check_num_args("ofVec4f::getPtr",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::getPtr",1,"ofVec4f *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f_getPtr",1,SWIGTYPE_p_ofVec4f); } - result = (float *)(arg1)->getPtr(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_float,0); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f_getPtr__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; float *result = 0 ; - SWIG_check_num_args("ofVec4f::getPtr",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::getPtr",1,"ofVec4f const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f_getPtr",1,SWIGTYPE_p_ofVec4f); } - result = (float *)((ofVec4f const *)arg1)->getPtr(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_float,0); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f_getPtr(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Vec4f_getPtr__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Vec4f_getPtr__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec4f_getPtr'\n" " Possible C/C++ prototypes are:\n" - " ofVec4f::getPtr()\n" " ofVec4f::getPtr() const\n"); lua_error(L);return 0; } -static int _wrap_Vec4f_set__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; float arg2 ; - SWIG_check_num_args("ofVec4f::set",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::set",1,"ofVec4f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec4f::set",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f_set",1,SWIGTYPE_p_ofVec4f); } - arg2 = (float)lua_tonumber(L, 2); (arg1)->set(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f_set__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; float arg2 ; float arg3 ; - float arg4 ; float arg5 ; SWIG_check_num_args("ofVec4f::set",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::set",1,"ofVec4f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec4f::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVec4f::set",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVec4f::set",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofVec4f::set",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f_set",1,SWIGTYPE_p_ofVec4f); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); (arg1)->set(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec4f_set__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; ofVec4f *arg2 = 0 ; - SWIG_check_num_args("ofVec4f::set",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::set",1,"ofVec4f *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec4f::set",2,"ofVec4f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f_set",1,SWIGTYPE_p_ofVec4f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f_set",2,SWIGTYPE_p_ofVec4f); } - (arg1)->set((ofVec4f const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f_set(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 2) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec4f_set__SWIG_2(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Vec4f_set__SWIG_0(L);} } } - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Vec4f_set__SWIG_1(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec4f_set'\n" " Possible C/C++ prototypes are:\n" - " ofVec4f::set(float)\n" " ofVec4f::set(float,float,float,float)\n" " ofVec4f::set(ofVec4f const &)\n"); - lua_error(L);return 0; } -static int _wrap_Vec4f___eq(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; ofVec4f *arg2 = 0 ; bool result; - SWIG_check_num_args("ofVec4f::operator ==",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::operator ==",1,"ofVec4f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec4f::operator ==",2,"ofVec4f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f___eq",1,SWIGTYPE_p_ofVec4f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f___eq",2,SWIGTYPE_p_ofVec4f); } - result = (bool)((ofVec4f const *)arg1)->operator ==((ofVec4f const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f_match__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; ofVec4f *arg2 = 0 ; - float arg3 ; bool result; SWIG_check_num_args("ofVec4f::match",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::match",1,"ofVec4f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec4f::match",2,"ofVec4f const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVec4f::match",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f_match",1,SWIGTYPE_p_ofVec4f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f_match",2,SWIGTYPE_p_ofVec4f); } - arg3 = (float)lua_tonumber(L, 3); result = (bool)((ofVec4f const *)arg1)->match((ofVec4f const &)*arg2,arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f_match__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; ofVec4f *arg2 = 0 ; - bool result; SWIG_check_num_args("ofVec4f::match",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::match",1,"ofVec4f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec4f::match",2,"ofVec4f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f_match",1,SWIGTYPE_p_ofVec4f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f_match",2,SWIGTYPE_p_ofVec4f); } - result = (bool)((ofVec4f const *)arg1)->match((ofVec4f const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f_match(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec4f_match__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Vec4f_match__SWIG_0(L);} } } - } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec4f_match'\n" " Possible C/C++ prototypes are:\n" - " ofVec4f::match(ofVec4f const &,float) const\n" " ofVec4f::match(ofVec4f const &) const\n"); lua_error(L);return 0; } -static int _wrap_Vec4f___add__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; ofVec4f *arg2 = 0 ; - ofVec4f result; SWIG_check_num_args("ofVec4f::operator +",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::operator +",1,"ofVec4f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec4f::operator +",2,"ofVec4f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f___add",1,SWIGTYPE_p_ofVec4f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f___add",2,SWIGTYPE_p_ofVec4f); } - result = ((ofVec4f const *)arg1)->operator +((ofVec4f const &)*arg2); { - ofVec4f * resultptr = new ofVec4f((const ofVec4f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec4f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f___add__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; float arg2 ; - ofVec4f result; SWIG_check_num_args("ofVec4f::operator +",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::operator +",1,"ofVec4f const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec4f::operator +",2,"float const"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f___add",1,SWIGTYPE_p_ofVec4f); } - arg2 = (float const)lua_tonumber(L, 2); result = ((ofVec4f const *)arg1)->operator +(arg2); { - ofVec4f * resultptr = new ofVec4f((const ofVec4f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec4f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f___add(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec4f___add__SWIG_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Vec4f___add__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec4f___add'\n" " Possible C/C++ prototypes are:\n" - " ofVec4f::operator +(ofVec4f const &) const\n" " ofVec4f::operator +(float const) const\n"); lua_error(L);return 0; } -static int _wrap_Vec4f___sub__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; float arg2 ; - ofVec4f result; SWIG_check_num_args("ofVec4f::operator -",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::operator -",1,"ofVec4f const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec4f::operator -",2,"float const"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f___sub",1,SWIGTYPE_p_ofVec4f); } - arg2 = (float const)lua_tonumber(L, 2); result = ((ofVec4f const *)arg1)->operator -(arg2); { - ofVec4f * resultptr = new ofVec4f((const ofVec4f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec4f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f___sub__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; ofVec4f *arg2 = 0 ; - ofVec4f result; SWIG_check_num_args("ofVec4f::operator -",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::operator -",1,"ofVec4f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec4f::operator -",2,"ofVec4f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f___sub",1,SWIGTYPE_p_ofVec4f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f___sub",2,SWIGTYPE_p_ofVec4f); } - result = ((ofVec4f const *)arg1)->operator -((ofVec4f const &)*arg2); { - ofVec4f * resultptr = new ofVec4f((const ofVec4f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec4f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f___sub(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec4f___sub__SWIG_1(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Vec4f___sub__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec4f___sub'\n" " Possible C/C++ prototypes are:\n" - " ofVec4f::operator -(float const) const\n" " ofVec4f::operator -(ofVec4f const &) const\n"); lua_error(L);return 0; } -static int _wrap_Vec4f___unm(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; ofVec4f result; - SWIG_check_num_args("ofVec4f::operator -",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::operator -",1,"ofVec4f const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f___unm",1,SWIGTYPE_p_ofVec4f); } - result = ((ofVec4f const *)arg1)->operator -(); { ofVec4f * resultptr = new ofVec4f((const ofVec4f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec4f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f___mul__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; ofVec4f *arg2 = 0 ; - ofVec4f result; SWIG_check_num_args("ofVec4f::operator *",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::operator *",1,"ofVec4f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec4f::operator *",2,"ofVec4f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f___mul",1,SWIGTYPE_p_ofVec4f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f___mul",2,SWIGTYPE_p_ofVec4f); } - result = ((ofVec4f const *)arg1)->operator *((ofVec4f const &)*arg2); { - ofVec4f * resultptr = new ofVec4f((const ofVec4f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec4f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f___mul__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; float arg2 ; - ofVec4f result; SWIG_check_num_args("ofVec4f::operator *",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::operator *",1,"ofVec4f const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec4f::operator *",2,"float const"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f___mul",1,SWIGTYPE_p_ofVec4f); } - arg2 = (float const)lua_tonumber(L, 2); result = ((ofVec4f const *)arg1)->operator *(arg2); { - ofVec4f * resultptr = new ofVec4f((const ofVec4f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec4f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f___mul(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec4f___mul__SWIG_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Vec4f___mul__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec4f___mul'\n" " Possible C/C++ prototypes are:\n" - " ofVec4f::operator *(ofVec4f const &) const\n" " ofVec4f::operator *(float const) const\n"); lua_error(L);return 0; } -static int _wrap_Vec4f___div__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; ofVec4f *arg2 = 0 ; - ofVec4f result; SWIG_check_num_args("ofVec4f::operator /",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::operator /",1,"ofVec4f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec4f::operator /",2,"ofVec4f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f___div",1,SWIGTYPE_p_ofVec4f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f___div",2,SWIGTYPE_p_ofVec4f); } - result = ((ofVec4f const *)arg1)->operator /((ofVec4f const &)*arg2); { - ofVec4f * resultptr = new ofVec4f((const ofVec4f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec4f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f___div__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; float arg2 ; - ofVec4f result; SWIG_check_num_args("ofVec4f::operator /",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::operator /",1,"ofVec4f const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec4f::operator /",2,"float const"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f___div",1,SWIGTYPE_p_ofVec4f); } - arg2 = (float const)lua_tonumber(L, 2); result = ((ofVec4f const *)arg1)->operator /(arg2); { - ofVec4f * resultptr = new ofVec4f((const ofVec4f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec4f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f___div(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec4f___div__SWIG_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Vec4f___div__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec4f___div'\n" " Possible C/C++ prototypes are:\n" - " ofVec4f::operator /(ofVec4f const &) const\n" " ofVec4f::operator /(float const) const\n"); lua_error(L);return 0; } -static int _wrap_Vec4f_getScaled(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; float arg2 ; ofVec4f result; - SWIG_check_num_args("ofVec4f::getScaled",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::getScaled",1,"ofVec4f const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec4f::getScaled",2,"float const"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ - SWIG_fail_ptr("Vec4f_getScaled",1,SWIGTYPE_p_ofVec4f); } arg2 = (float const)lua_tonumber(L, 2); - result = ((ofVec4f const *)arg1)->getScaled(arg2); { ofVec4f * resultptr = new ofVec4f((const ofVec4f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec4f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f_scale(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; float arg2 ; - ofVec4f *result = 0 ; SWIG_check_num_args("ofVec4f::scale",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::scale",1,"ofVec4f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec4f::scale",2,"float const"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f_scale",1,SWIGTYPE_p_ofVec4f); } - arg2 = (float const)lua_tonumber(L, 2); result = (ofVec4f *) &(arg1)->scale(arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec4f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec4f_distance(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; ofVec4f *arg2 = 0 ; - float result; SWIG_check_num_args("ofVec4f::distance",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::distance",1,"ofVec4f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec4f::distance",2,"ofVec4f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ - SWIG_fail_ptr("Vec4f_distance",1,SWIGTYPE_p_ofVec4f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec4f,0))){ - SWIG_fail_ptr("Vec4f_distance",2,SWIGTYPE_p_ofVec4f); } - result = (float)((ofVec4f const *)arg1)->distance((ofVec4f const &)*arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f_squareDistance(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; ofVec4f *arg2 = 0 ; - float result; SWIG_check_num_args("ofVec4f::squareDistance",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::squareDistance",1,"ofVec4f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec4f::squareDistance",2,"ofVec4f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ - SWIG_fail_ptr("Vec4f_squareDistance",1,SWIGTYPE_p_ofVec4f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec4f,0))){ - SWIG_fail_ptr("Vec4f_squareDistance",2,SWIGTYPE_p_ofVec4f); } - result = (float)((ofVec4f const *)arg1)->squareDistance((ofVec4f const &)*arg2); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f_getInterpolated(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; ofVec4f *arg2 = 0 ; - float arg3 ; ofVec4f result; SWIG_check_num_args("ofVec4f::getInterpolated",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::getInterpolated",1,"ofVec4f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec4f::getInterpolated",2,"ofVec4f const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVec4f::getInterpolated",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ - SWIG_fail_ptr("Vec4f_getInterpolated",1,SWIGTYPE_p_ofVec4f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec4f,0))){ - SWIG_fail_ptr("Vec4f_getInterpolated",2,SWIGTYPE_p_ofVec4f); } arg3 = (float)lua_tonumber(L, 3); - result = ((ofVec4f const *)arg1)->getInterpolated((ofVec4f const &)*arg2,arg3); { - ofVec4f * resultptr = new ofVec4f((const ofVec4f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec4f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f_interpolate(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; ofVec4f *arg2 = 0 ; - float arg3 ; ofVec4f *result = 0 ; SWIG_check_num_args("ofVec4f::interpolate",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::interpolate",1,"ofVec4f *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec4f::interpolate",2,"ofVec4f const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVec4f::interpolate",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ - SWIG_fail_ptr("Vec4f_interpolate",1,SWIGTYPE_p_ofVec4f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec4f,0))){ - SWIG_fail_ptr("Vec4f_interpolate",2,SWIGTYPE_p_ofVec4f); } arg3 = (float)lua_tonumber(L, 3); - result = (ofVec4f *) &(arg1)->interpolate((ofVec4f const &)*arg2,arg3); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec4f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec4f_getMiddle(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; ofVec4f *arg2 = 0 ; - ofVec4f result; SWIG_check_num_args("ofVec4f::getMiddle",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::getMiddle",1,"ofVec4f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec4f::getMiddle",2,"ofVec4f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ - SWIG_fail_ptr("Vec4f_getMiddle",1,SWIGTYPE_p_ofVec4f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec4f,0))){ - SWIG_fail_ptr("Vec4f_getMiddle",2,SWIGTYPE_p_ofVec4f); } - result = ((ofVec4f const *)arg1)->getMiddle((ofVec4f const &)*arg2); { - ofVec4f * resultptr = new ofVec4f((const ofVec4f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec4f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f_middle(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; ofVec4f *arg2 = 0 ; - ofVec4f *result = 0 ; SWIG_check_num_args("ofVec4f::middle",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::middle",1,"ofVec4f *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec4f::middle",2,"ofVec4f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f_middle",1,SWIGTYPE_p_ofVec4f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec4f,0))){ - SWIG_fail_ptr("Vec4f_middle",2,SWIGTYPE_p_ofVec4f); } result = (ofVec4f *) &(arg1)->middle((ofVec4f const &)*arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec4f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec4f_average(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; ofVec4f *arg2 = (ofVec4f *) 0 ; - int arg3 ; ofVec4f *result = 0 ; SWIG_check_num_args("ofVec4f::average",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::average",1,"ofVec4f *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofVec4f::average",2,"ofVec4f const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVec4f::average",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ - SWIG_fail_ptr("Vec4f_average",1,SWIGTYPE_p_ofVec4f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec4f,0))){ - SWIG_fail_ptr("Vec4f_average",2,SWIGTYPE_p_ofVec4f); } arg3 = (int)lua_tonumber(L, 3); - result = (ofVec4f *) &(arg1)->average((ofVec4f const *)arg2,arg3); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec4f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec4f_getNormalized(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; ofVec4f result; - SWIG_check_num_args("ofVec4f::getNormalized",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::getNormalized",1,"ofVec4f const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ - SWIG_fail_ptr("Vec4f_getNormalized",1,SWIGTYPE_p_ofVec4f); } result = ((ofVec4f const *)arg1)->getNormalized(); { - ofVec4f * resultptr = new ofVec4f((const ofVec4f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec4f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f_normalize(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; ofVec4f *result = 0 ; - SWIG_check_num_args("ofVec4f::normalize",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::normalize",1,"ofVec4f *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ - SWIG_fail_ptr("Vec4f_normalize",1,SWIGTYPE_p_ofVec4f); } result = (ofVec4f *) &(arg1)->normalize(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec4f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec4f_getLimited(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; float arg2 ; ofVec4f result; - SWIG_check_num_args("ofVec4f::getLimited",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::getLimited",1,"ofVec4f const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec4f::getLimited",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ - SWIG_fail_ptr("Vec4f_getLimited",1,SWIGTYPE_p_ofVec4f); } arg2 = (float)lua_tonumber(L, 2); - result = ((ofVec4f const *)arg1)->getLimited(arg2); { ofVec4f * resultptr = new ofVec4f((const ofVec4f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec4f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f_limit(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; float arg2 ; - ofVec4f *result = 0 ; SWIG_check_num_args("ofVec4f::limit",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::limit",1,"ofVec4f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec4f::limit",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f_limit",1,SWIGTYPE_p_ofVec4f); } - arg2 = (float)lua_tonumber(L, 2); result = (ofVec4f *) &(arg1)->limit(arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec4f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec4f_length(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; float result; - SWIG_check_num_args("ofVec4f::length",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::length",1,"ofVec4f const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f_length",1,SWIGTYPE_p_ofVec4f); } - result = (float)((ofVec4f const *)arg1)->length(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f_lengthSquared(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; float result; - SWIG_check_num_args("ofVec4f::lengthSquared",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::lengthSquared",1,"ofVec4f const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ - SWIG_fail_ptr("Vec4f_lengthSquared",1,SWIGTYPE_p_ofVec4f); } result = (float)((ofVec4f const *)arg1)->lengthSquared(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f_dot(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; ofVec4f *arg2 = 0 ; float result; - SWIG_check_num_args("ofVec4f::dot",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::dot",1,"ofVec4f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec4f::dot",2,"ofVec4f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f_dot",1,SWIGTYPE_p_ofVec4f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f_dot",2,SWIGTYPE_p_ofVec4f); } - result = (float)((ofVec4f const *)arg1)->dot((ofVec4f const &)*arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f_zero(lua_State* L) { int SWIG_arg = 0; ofVec4f result; SWIG_check_num_args("ofVec4f::zero",0,0) - result = ofVec4f::zero(); { ofVec4f * resultptr = new ofVec4f((const ofVec4f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec4f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f_one(lua_State* L) { int SWIG_arg = 0; ofVec4f result; SWIG_check_num_args("ofVec4f::one",0,0) - result = ofVec4f::one(); { ofVec4f * resultptr = new ofVec4f((const ofVec4f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec4f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f___tostring(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; char *result = 0 ; - SWIG_check_num_args("ofVec4f::__str__",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::__str__",1,"ofVec4f *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ - SWIG_fail_ptr("Vec4f___tostring",1,SWIGTYPE_p_ofVec4f); } result = (char *)ofVec4f___str__(arg1); - lua_pushstring(L,(const char *)result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_Vec4f(void *obj) { -ofVec4f *arg1 = (ofVec4f *) obj; -delete arg1; -} -static int _proxy__wrap_new_Vec4f(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_Vec4f); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_Vec4f_attributes[] = { - { "x", _wrap_Vec4f_x_get, _wrap_Vec4f_x_set }, - { "y", _wrap_Vec4f_y_get, _wrap_Vec4f_y_set }, - { "z", _wrap_Vec4f_z_get, _wrap_Vec4f_z_set }, - { "w", _wrap_Vec4f_w_get, _wrap_Vec4f_w_set }, - {0,0,0} -}; -static swig_lua_method swig_Vec4f_methods[]= { - { "getPtr", _wrap_Vec4f_getPtr}, - { "set", _wrap_Vec4f_set}, - { "__eq", _wrap_Vec4f___eq}, - { "match", _wrap_Vec4f_match}, - { "__add", _wrap_Vec4f___add}, - { "__sub", _wrap_Vec4f___sub}, - { "__unm", _wrap_Vec4f___unm}, - { "__mul", _wrap_Vec4f___mul}, - { "__div", _wrap_Vec4f___div}, - { "getScaled", _wrap_Vec4f_getScaled}, - { "scale", _wrap_Vec4f_scale}, - { "distance", _wrap_Vec4f_distance}, - { "squareDistance", _wrap_Vec4f_squareDistance}, - { "getInterpolated", _wrap_Vec4f_getInterpolated}, - { "interpolate", _wrap_Vec4f_interpolate}, - { "getMiddle", _wrap_Vec4f_getMiddle}, - { "middle", _wrap_Vec4f_middle}, - { "average", _wrap_Vec4f_average}, - { "getNormalized", _wrap_Vec4f_getNormalized}, - { "normalize", _wrap_Vec4f_normalize}, - { "getLimited", _wrap_Vec4f_getLimited}, - { "limit", _wrap_Vec4f_limit}, - { "length", _wrap_Vec4f_length}, - { "lengthSquared", _wrap_Vec4f_lengthSquared}, - { "dot", _wrap_Vec4f_dot}, - { "__tostring", _wrap_Vec4f___tostring}, - {0,0} -}; -static swig_lua_method swig_Vec4f_meta[] = { - { "__eq", _wrap_Vec4f___eq}, - { "__add", _wrap_Vec4f___add}, - { "__sub", _wrap_Vec4f___sub}, - { "__unm", _wrap_Vec4f___unm}, - { "__mul", _wrap_Vec4f___mul}, - { "__div", _wrap_Vec4f___div}, - { "__tostring", _wrap_Vec4f___tostring}, - {0,0} -}; - -static swig_lua_attribute swig_Vec4f_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_Vec4f_Sf_SwigStatic_constants[]= { - {SWIG_LUA_CONSTTAB_INT("DIM", ofVec4f::DIM)}, - {0,0,0,0,0,0} -}; -static swig_lua_method swig_Vec4f_Sf_SwigStatic_methods[]= { - { "zero", _wrap_Vec4f_zero}, - { "one", _wrap_Vec4f_one}, - {0,0} -}; -static swig_lua_class* swig_Vec4f_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_Vec4f_Sf_SwigStatic = { - "Vec4f", - swig_Vec4f_Sf_SwigStatic_methods, - swig_Vec4f_Sf_SwigStatic_attributes, - swig_Vec4f_Sf_SwigStatic_constants, - swig_Vec4f_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_Vec4f_bases[] = {0}; -static const char *swig_Vec4f_base_names[] = {0}; -static swig_lua_class _wrap_class_Vec4f = { "Vec4f", "Vec4f", &SWIGTYPE_p_ofVec4f,_proxy__wrap_new_Vec4f, swig_delete_Vec4f, swig_Vec4f_methods, swig_Vec4f_attributes, &swig_Vec4f_Sf_SwigStatic, swig_Vec4f_meta, swig_Vec4f_bases, swig_Vec4f_base_names }; - -static int _wrap_getMousePressed__SWIG_0(lua_State* L) { int SWIG_arg = 0; int arg1 ; bool result; - SWIG_check_num_args("ofGetMousePressed",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofGetMousePressed",1,"int"); - arg1 = (int)lua_tonumber(L, 1); result = (bool)ofGetMousePressed(arg1); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getMousePressed__SWIG_1(lua_State* L) { int SWIG_arg = 0; bool result; - SWIG_check_num_args("ofGetMousePressed",0,0) result = (bool)ofGetMousePressed(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getMousePressed(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_getMousePressed__SWIG_1(L);} if (argc == 1) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { - return _wrap_getMousePressed__SWIG_0(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'getMousePressed'\n" " Possible C/C++ prototypes are:\n" - " ofGetMousePressed(int)\n" " ofGetMousePressed()\n"); lua_error(L);return 0; } -static int _wrap_getKeyPressed__SWIG_0(lua_State* L) { int SWIG_arg = 0; int arg1 ; bool result; - SWIG_check_num_args("ofGetKeyPressed",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofGetKeyPressed",1,"int"); - arg1 = (int)lua_tonumber(L, 1); result = (bool)ofGetKeyPressed(arg1); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getKeyPressed__SWIG_1(lua_State* L) { int SWIG_arg = 0; bool result; SWIG_check_num_args("ofGetKeyPressed",0,0) - result = (bool)ofGetKeyPressed(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_getKeyPressed(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_getKeyPressed__SWIG_1(L);} if (argc == 1) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { - return _wrap_getKeyPressed__SWIG_0(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'getKeyPressed'\n" " Possible C/C++ prototypes are:\n" - " ofGetKeyPressed(int)\n" " ofGetKeyPressed()\n"); lua_error(L);return 0; } -static int _wrap_getMouseX(lua_State* L) { int SWIG_arg = 0; int result; SWIG_check_num_args("ofGetMouseX",0,0) - result = (int)ofGetMouseX(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_getMouseY(lua_State* L) { int SWIG_arg = 0; int result; SWIG_check_num_args("ofGetMouseY",0,0) - result = (int)ofGetMouseY(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_getPreviousMouseX(lua_State* L) { int SWIG_arg = 0; int result; SWIG_check_num_args("ofGetPreviousMouseX",0,0) - result = (int)ofGetPreviousMouseX(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_getPreviousMouseY(lua_State* L) { int SWIG_arg = 0; int result; SWIG_check_num_args("ofGetPreviousMouseY",0,0) - result = (int)ofGetPreviousMouseY(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_DragInfo_files_set(lua_State* L) { int SWIG_arg = 0; ofDragInfo *arg1 = (ofDragInfo *) 0 ; - std::vector< std::string > *arg2 = (std::vector< std::string > *) 0 ; SWIG_check_num_args("ofDragInfo::files",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDragInfo::files",1,"ofDragInfo *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofDragInfo::files",2,"std::vector< std::string > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDragInfo,0))){ - SWIG_fail_ptr("DragInfo_files_set",1,SWIGTYPE_p_ofDragInfo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__vectorT_std__string_t,0))){ - SWIG_fail_ptr("DragInfo_files_set",2,SWIGTYPE_p_std__vectorT_std__string_t); } if (arg1) (arg1)->files = *arg2; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_DragInfo_files_get(lua_State* L) { int SWIG_arg = 0; ofDragInfo *arg1 = (ofDragInfo *) 0 ; - std::vector< std::string > *result = 0 ; SWIG_check_num_args("ofDragInfo::files",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDragInfo::files",1,"ofDragInfo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDragInfo,0))){ - SWIG_fail_ptr("DragInfo_files_get",1,SWIGTYPE_p_ofDragInfo); } result = (std::vector< std::string > *)& ((arg1)->files); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_std__string_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_DragInfo_position_set(lua_State* L) { int SWIG_arg = 0; ofDragInfo *arg1 = (ofDragInfo *) 0 ; - ofPoint *arg2 = (ofPoint *) 0 ; SWIG_check_num_args("ofDragInfo::position",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDragInfo::position",1,"ofDragInfo *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofDragInfo::position",2,"ofPoint *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDragInfo,0))){ - SWIG_fail_ptr("DragInfo_position_set",1,SWIGTYPE_p_ofDragInfo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("DragInfo_position_set",2,SWIGTYPE_p_ofVec3f); } if (arg1) (arg1)->position = *arg2; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_DragInfo_position_get(lua_State* L) { int SWIG_arg = 0; ofDragInfo *arg1 = (ofDragInfo *) 0 ; - ofPoint *result = 0 ; SWIG_check_num_args("ofDragInfo::position",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDragInfo::position",1,"ofDragInfo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDragInfo,0))){ - SWIG_fail_ptr("DragInfo_position_get",1,SWIGTYPE_p_ofDragInfo); } result = (ofPoint *)& ((arg1)->position); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_DragInfo(lua_State* L) { int SWIG_arg = 0; ofDragInfo *result = 0 ; - SWIG_check_num_args("ofDragInfo::ofDragInfo",0,0) result = (ofDragInfo *)new ofDragInfo(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofDragInfo,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static void swig_delete_DragInfo(void *obj) { -ofDragInfo *arg1 = (ofDragInfo *) obj; -delete arg1; -} -static int _proxy__wrap_new_DragInfo(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_DragInfo); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_DragInfo_attributes[] = { - { "files", _wrap_DragInfo_files_get, _wrap_DragInfo_files_set }, - { "position", _wrap_DragInfo_position_get, _wrap_DragInfo_position_set }, - {0,0,0} -}; -static swig_lua_method swig_DragInfo_methods[]= { - {0,0} -}; -static swig_lua_method swig_DragInfo_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_DragInfo_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_DragInfo_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_DragInfo_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_DragInfo_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_DragInfo_Sf_SwigStatic = { - "DragInfo", - swig_DragInfo_Sf_SwigStatic_methods, - swig_DragInfo_Sf_SwigStatic_attributes, - swig_DragInfo_Sf_SwigStatic_constants, - swig_DragInfo_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_DragInfo_bases[] = {0}; -static const char *swig_DragInfo_base_names[] = {0}; -static swig_lua_class _wrap_class_DragInfo = { "DragInfo", "DragInfo", &SWIGTYPE_p_ofDragInfo,_proxy__wrap_new_DragInfo, swig_delete_DragInfo, swig_DragInfo_methods, swig_DragInfo_attributes, &swig_DragInfo_Sf_SwigStatic, swig_DragInfo_meta, swig_DragInfo_bases, swig_DragInfo_base_names }; - -static int _wrap_new_TouchEventArgs__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofTouchEventArgs *result = 0 ; - SWIG_check_num_args("ofTouchEventArgs::ofTouchEventArgs",0,0) result = (ofTouchEventArgs *)new ofTouchEventArgs(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTouchEventArgs,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_TouchEventArgs__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofTouchEventArgs::Type arg1 ; float arg2 ; - float arg3 ; int arg4 ; ofTouchEventArgs *result = 0 ; SWIG_check_num_args("ofTouchEventArgs::ofTouchEventArgs",4,4) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofTouchEventArgs::ofTouchEventArgs",1,"ofTouchEventArgs::Type"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTouchEventArgs::ofTouchEventArgs",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTouchEventArgs::ofTouchEventArgs",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofTouchEventArgs::ofTouchEventArgs",4,"int"); - arg1 = (ofTouchEventArgs::Type)(int)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); result = (ofTouchEventArgs *)new ofTouchEventArgs(arg1,arg2,arg3,arg4); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTouchEventArgs,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_TouchEventArgs(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_TouchEventArgs__SWIG_0(L);} if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_new_TouchEventArgs__SWIG_1(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_TouchEventArgs'\n" " Possible C/C++ prototypes are:\n" - " ofTouchEventArgs::ofTouchEventArgs()\n" - " ofTouchEventArgs::ofTouchEventArgs(ofTouchEventArgs::Type,float,float,int)\n"); lua_error(L);return 0; } -static int _wrap_TouchEventArgs_type_set(lua_State* L) { int SWIG_arg = 0; ofTouchEventArgs *arg1 = (ofTouchEventArgs *) 0 ; - ofTouchEventArgs::Type arg2 ; SWIG_check_num_args("ofTouchEventArgs::type",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTouchEventArgs::type",1,"ofTouchEventArgs *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTouchEventArgs::type",2,"ofTouchEventArgs::Type"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTouchEventArgs,0))){ - SWIG_fail_ptr("TouchEventArgs_type_set",1,SWIGTYPE_p_ofTouchEventArgs); } - arg2 = (ofTouchEventArgs::Type)(int)lua_tonumber(L, 2); if (arg1) (arg1)->type = arg2; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_TouchEventArgs_type_get(lua_State* L) { int SWIG_arg = 0; ofTouchEventArgs *arg1 = (ofTouchEventArgs *) 0 ; - ofTouchEventArgs::Type result; SWIG_check_num_args("ofTouchEventArgs::type",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTouchEventArgs::type",1,"ofTouchEventArgs *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTouchEventArgs,0))){ - SWIG_fail_ptr("TouchEventArgs_type_get",1,SWIGTYPE_p_ofTouchEventArgs); } result = (ofTouchEventArgs::Type) ((arg1)->type); - lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_TouchEventArgs_id_set(lua_State* L) { int SWIG_arg = 0; ofTouchEventArgs *arg1 = (ofTouchEventArgs *) 0 ; - int arg2 ; SWIG_check_num_args("ofTouchEventArgs::id",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTouchEventArgs::id",1,"ofTouchEventArgs *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTouchEventArgs::id",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTouchEventArgs,0))){ - SWIG_fail_ptr("TouchEventArgs_id_set",1,SWIGTYPE_p_ofTouchEventArgs); } arg2 = (int)lua_tonumber(L, 2); - if (arg1) (arg1)->id = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TouchEventArgs_id_get(lua_State* L) { int SWIG_arg = 0; ofTouchEventArgs *arg1 = (ofTouchEventArgs *) 0 ; - int result; SWIG_check_num_args("ofTouchEventArgs::id",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTouchEventArgs::id",1,"ofTouchEventArgs *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTouchEventArgs,0))){ - SWIG_fail_ptr("TouchEventArgs_id_get",1,SWIGTYPE_p_ofTouchEventArgs); } result = (int) ((arg1)->id); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TouchEventArgs_time_set(lua_State* L) { int SWIG_arg = 0; ofTouchEventArgs *arg1 = (ofTouchEventArgs *) 0 ; - int arg2 ; SWIG_check_num_args("ofTouchEventArgs::time",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTouchEventArgs::time",1,"ofTouchEventArgs *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTouchEventArgs::time",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTouchEventArgs,0))){ - SWIG_fail_ptr("TouchEventArgs_time_set",1,SWIGTYPE_p_ofTouchEventArgs); } arg2 = (int)lua_tonumber(L, 2); - if (arg1) (arg1)->time = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TouchEventArgs_time_get(lua_State* L) { int SWIG_arg = 0; ofTouchEventArgs *arg1 = (ofTouchEventArgs *) 0 ; - int result; SWIG_check_num_args("ofTouchEventArgs::time",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTouchEventArgs::time",1,"ofTouchEventArgs *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTouchEventArgs,0))){ - SWIG_fail_ptr("TouchEventArgs_time_get",1,SWIGTYPE_p_ofTouchEventArgs); } result = (int) ((arg1)->time); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TouchEventArgs_numTouches_set(lua_State* L) { int SWIG_arg = 0; - ofTouchEventArgs *arg1 = (ofTouchEventArgs *) 0 ; int arg2 ; SWIG_check_num_args("ofTouchEventArgs::numTouches",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTouchEventArgs::numTouches",1,"ofTouchEventArgs *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTouchEventArgs::numTouches",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTouchEventArgs,0))){ - SWIG_fail_ptr("TouchEventArgs_numTouches_set",1,SWIGTYPE_p_ofTouchEventArgs); } arg2 = (int)lua_tonumber(L, 2); - if (arg1) (arg1)->numTouches = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TouchEventArgs_numTouches_get(lua_State* L) { int SWIG_arg = 0; - ofTouchEventArgs *arg1 = (ofTouchEventArgs *) 0 ; int result; SWIG_check_num_args("ofTouchEventArgs::numTouches",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTouchEventArgs::numTouches",1,"ofTouchEventArgs *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTouchEventArgs,0))){ - SWIG_fail_ptr("TouchEventArgs_numTouches_get",1,SWIGTYPE_p_ofTouchEventArgs); } result = (int) ((arg1)->numTouches); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TouchEventArgs_width_set(lua_State* L) { int SWIG_arg = 0; ofTouchEventArgs *arg1 = (ofTouchEventArgs *) 0 ; - float arg2 ; SWIG_check_num_args("ofTouchEventArgs::width",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTouchEventArgs::width",1,"ofTouchEventArgs *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTouchEventArgs::width",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTouchEventArgs,0))){ - SWIG_fail_ptr("TouchEventArgs_width_set",1,SWIGTYPE_p_ofTouchEventArgs); } arg2 = (float)lua_tonumber(L, 2); - if (arg1) (arg1)->width = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TouchEventArgs_width_get(lua_State* L) { int SWIG_arg = 0; ofTouchEventArgs *arg1 = (ofTouchEventArgs *) 0 ; - float result; SWIG_check_num_args("ofTouchEventArgs::width",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTouchEventArgs::width",1,"ofTouchEventArgs *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTouchEventArgs,0))){ - SWIG_fail_ptr("TouchEventArgs_width_get",1,SWIGTYPE_p_ofTouchEventArgs); } result = (float) ((arg1)->width); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TouchEventArgs_height_set(lua_State* L) { int SWIG_arg = 0; ofTouchEventArgs *arg1 = (ofTouchEventArgs *) 0 ; - float arg2 ; SWIG_check_num_args("ofTouchEventArgs::height",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTouchEventArgs::height",1,"ofTouchEventArgs *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTouchEventArgs::height",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTouchEventArgs,0))){ - SWIG_fail_ptr("TouchEventArgs_height_set",1,SWIGTYPE_p_ofTouchEventArgs); } arg2 = (float)lua_tonumber(L, 2); - if (arg1) (arg1)->height = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TouchEventArgs_height_get(lua_State* L) { int SWIG_arg = 0; ofTouchEventArgs *arg1 = (ofTouchEventArgs *) 0 ; - float result; SWIG_check_num_args("ofTouchEventArgs::height",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTouchEventArgs::height",1,"ofTouchEventArgs *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTouchEventArgs,0))){ - SWIG_fail_ptr("TouchEventArgs_height_get",1,SWIGTYPE_p_ofTouchEventArgs); } result = (float) ((arg1)->height); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TouchEventArgs_angle_set(lua_State* L) { int SWIG_arg = 0; ofTouchEventArgs *arg1 = (ofTouchEventArgs *) 0 ; - float arg2 ; SWIG_check_num_args("ofTouchEventArgs::angle",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTouchEventArgs::angle",1,"ofTouchEventArgs *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTouchEventArgs::angle",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTouchEventArgs,0))){ - SWIG_fail_ptr("TouchEventArgs_angle_set",1,SWIGTYPE_p_ofTouchEventArgs); } arg2 = (float)lua_tonumber(L, 2); - if (arg1) (arg1)->angle = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TouchEventArgs_angle_get(lua_State* L) { int SWIG_arg = 0; ofTouchEventArgs *arg1 = (ofTouchEventArgs *) 0 ; - float result; SWIG_check_num_args("ofTouchEventArgs::angle",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTouchEventArgs::angle",1,"ofTouchEventArgs *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTouchEventArgs,0))){ - SWIG_fail_ptr("TouchEventArgs_angle_get",1,SWIGTYPE_p_ofTouchEventArgs); } result = (float) ((arg1)->angle); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TouchEventArgs_minoraxis_set(lua_State* L) { int SWIG_arg = 0; - ofTouchEventArgs *arg1 = (ofTouchEventArgs *) 0 ; float arg2 ; SWIG_check_num_args("ofTouchEventArgs::minoraxis",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTouchEventArgs::minoraxis",1,"ofTouchEventArgs *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTouchEventArgs::minoraxis",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTouchEventArgs,0))){ - SWIG_fail_ptr("TouchEventArgs_minoraxis_set",1,SWIGTYPE_p_ofTouchEventArgs); } arg2 = (float)lua_tonumber(L, 2); - if (arg1) (arg1)->minoraxis = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TouchEventArgs_minoraxis_get(lua_State* L) { int SWIG_arg = 0; - ofTouchEventArgs *arg1 = (ofTouchEventArgs *) 0 ; float result; SWIG_check_num_args("ofTouchEventArgs::minoraxis",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTouchEventArgs::minoraxis",1,"ofTouchEventArgs *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTouchEventArgs,0))){ - SWIG_fail_ptr("TouchEventArgs_minoraxis_get",1,SWIGTYPE_p_ofTouchEventArgs); } result = (float) ((arg1)->minoraxis); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TouchEventArgs_majoraxis_set(lua_State* L) { int SWIG_arg = 0; - ofTouchEventArgs *arg1 = (ofTouchEventArgs *) 0 ; float arg2 ; SWIG_check_num_args("ofTouchEventArgs::majoraxis",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTouchEventArgs::majoraxis",1,"ofTouchEventArgs *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTouchEventArgs::majoraxis",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTouchEventArgs,0))){ - SWIG_fail_ptr("TouchEventArgs_majoraxis_set",1,SWIGTYPE_p_ofTouchEventArgs); } arg2 = (float)lua_tonumber(L, 2); - if (arg1) (arg1)->majoraxis = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TouchEventArgs_majoraxis_get(lua_State* L) { int SWIG_arg = 0; - ofTouchEventArgs *arg1 = (ofTouchEventArgs *) 0 ; float result; SWIG_check_num_args("ofTouchEventArgs::majoraxis",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTouchEventArgs::majoraxis",1,"ofTouchEventArgs *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTouchEventArgs,0))){ - SWIG_fail_ptr("TouchEventArgs_majoraxis_get",1,SWIGTYPE_p_ofTouchEventArgs); } result = (float) ((arg1)->majoraxis); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TouchEventArgs_pressure_set(lua_State* L) { int SWIG_arg = 0; ofTouchEventArgs *arg1 = (ofTouchEventArgs *) 0 ; - float arg2 ; SWIG_check_num_args("ofTouchEventArgs::pressure",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTouchEventArgs::pressure",1,"ofTouchEventArgs *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTouchEventArgs::pressure",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTouchEventArgs,0))){ - SWIG_fail_ptr("TouchEventArgs_pressure_set",1,SWIGTYPE_p_ofTouchEventArgs); } arg2 = (float)lua_tonumber(L, 2); - if (arg1) (arg1)->pressure = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TouchEventArgs_pressure_get(lua_State* L) { int SWIG_arg = 0; ofTouchEventArgs *arg1 = (ofTouchEventArgs *) 0 ; - float result; SWIG_check_num_args("ofTouchEventArgs::pressure",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTouchEventArgs::pressure",1,"ofTouchEventArgs *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTouchEventArgs,0))){ - SWIG_fail_ptr("TouchEventArgs_pressure_get",1,SWIGTYPE_p_ofTouchEventArgs); } result = (float) ((arg1)->pressure); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TouchEventArgs_xspeed_set(lua_State* L) { int SWIG_arg = 0; ofTouchEventArgs *arg1 = (ofTouchEventArgs *) 0 ; - float arg2 ; SWIG_check_num_args("ofTouchEventArgs::xspeed",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTouchEventArgs::xspeed",1,"ofTouchEventArgs *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTouchEventArgs::xspeed",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTouchEventArgs,0))){ - SWIG_fail_ptr("TouchEventArgs_xspeed_set",1,SWIGTYPE_p_ofTouchEventArgs); } arg2 = (float)lua_tonumber(L, 2); - if (arg1) (arg1)->xspeed = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TouchEventArgs_xspeed_get(lua_State* L) { int SWIG_arg = 0; ofTouchEventArgs *arg1 = (ofTouchEventArgs *) 0 ; - float result; SWIG_check_num_args("ofTouchEventArgs::xspeed",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTouchEventArgs::xspeed",1,"ofTouchEventArgs *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTouchEventArgs,0))){ - SWIG_fail_ptr("TouchEventArgs_xspeed_get",1,SWIGTYPE_p_ofTouchEventArgs); } result = (float) ((arg1)->xspeed); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TouchEventArgs_yspeed_set(lua_State* L) { int SWIG_arg = 0; ofTouchEventArgs *arg1 = (ofTouchEventArgs *) 0 ; - float arg2 ; SWIG_check_num_args("ofTouchEventArgs::yspeed",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTouchEventArgs::yspeed",1,"ofTouchEventArgs *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTouchEventArgs::yspeed",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTouchEventArgs,0))){ - SWIG_fail_ptr("TouchEventArgs_yspeed_set",1,SWIGTYPE_p_ofTouchEventArgs); } arg2 = (float)lua_tonumber(L, 2); - if (arg1) (arg1)->yspeed = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TouchEventArgs_yspeed_get(lua_State* L) { int SWIG_arg = 0; ofTouchEventArgs *arg1 = (ofTouchEventArgs *) 0 ; - float result; SWIG_check_num_args("ofTouchEventArgs::yspeed",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTouchEventArgs::yspeed",1,"ofTouchEventArgs *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTouchEventArgs,0))){ - SWIG_fail_ptr("TouchEventArgs_yspeed_get",1,SWIGTYPE_p_ofTouchEventArgs); } result = (float) ((arg1)->yspeed); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TouchEventArgs_xaccel_set(lua_State* L) { int SWIG_arg = 0; ofTouchEventArgs *arg1 = (ofTouchEventArgs *) 0 ; - float arg2 ; SWIG_check_num_args("ofTouchEventArgs::xaccel",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTouchEventArgs::xaccel",1,"ofTouchEventArgs *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTouchEventArgs::xaccel",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTouchEventArgs,0))){ - SWIG_fail_ptr("TouchEventArgs_xaccel_set",1,SWIGTYPE_p_ofTouchEventArgs); } arg2 = (float)lua_tonumber(L, 2); - if (arg1) (arg1)->xaccel = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TouchEventArgs_xaccel_get(lua_State* L) { int SWIG_arg = 0; ofTouchEventArgs *arg1 = (ofTouchEventArgs *) 0 ; - float result; SWIG_check_num_args("ofTouchEventArgs::xaccel",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTouchEventArgs::xaccel",1,"ofTouchEventArgs *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTouchEventArgs,0))){ - SWIG_fail_ptr("TouchEventArgs_xaccel_get",1,SWIGTYPE_p_ofTouchEventArgs); } result = (float) ((arg1)->xaccel); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TouchEventArgs_yaccel_set(lua_State* L) { int SWIG_arg = 0; ofTouchEventArgs *arg1 = (ofTouchEventArgs *) 0 ; - float arg2 ; SWIG_check_num_args("ofTouchEventArgs::yaccel",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTouchEventArgs::yaccel",1,"ofTouchEventArgs *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTouchEventArgs::yaccel",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTouchEventArgs,0))){ - SWIG_fail_ptr("TouchEventArgs_yaccel_set",1,SWIGTYPE_p_ofTouchEventArgs); } arg2 = (float)lua_tonumber(L, 2); - if (arg1) (arg1)->yaccel = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TouchEventArgs_yaccel_get(lua_State* L) { int SWIG_arg = 0; ofTouchEventArgs *arg1 = (ofTouchEventArgs *) 0 ; - float result; SWIG_check_num_args("ofTouchEventArgs::yaccel",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTouchEventArgs::yaccel",1,"ofTouchEventArgs *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTouchEventArgs,0))){ - SWIG_fail_ptr("TouchEventArgs_yaccel_get",1,SWIGTYPE_p_ofTouchEventArgs); } result = (float) ((arg1)->yaccel); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_TouchEventArgs(void *obj) { -ofTouchEventArgs *arg1 = (ofTouchEventArgs *) obj; -delete arg1; -} -static int _proxy__wrap_new_TouchEventArgs(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_TouchEventArgs); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_TouchEventArgs_attributes[] = { - { "type", _wrap_TouchEventArgs_type_get, _wrap_TouchEventArgs_type_set }, - { "id", _wrap_TouchEventArgs_id_get, _wrap_TouchEventArgs_id_set }, - { "time", _wrap_TouchEventArgs_time_get, _wrap_TouchEventArgs_time_set }, - { "numTouches", _wrap_TouchEventArgs_numTouches_get, _wrap_TouchEventArgs_numTouches_set }, - { "width", _wrap_TouchEventArgs_width_get, _wrap_TouchEventArgs_width_set }, - { "height", _wrap_TouchEventArgs_height_get, _wrap_TouchEventArgs_height_set }, - { "angle", _wrap_TouchEventArgs_angle_get, _wrap_TouchEventArgs_angle_set }, - { "minoraxis", _wrap_TouchEventArgs_minoraxis_get, _wrap_TouchEventArgs_minoraxis_set }, - { "majoraxis", _wrap_TouchEventArgs_majoraxis_get, _wrap_TouchEventArgs_majoraxis_set }, - { "pressure", _wrap_TouchEventArgs_pressure_get, _wrap_TouchEventArgs_pressure_set }, - { "xspeed", _wrap_TouchEventArgs_xspeed_get, _wrap_TouchEventArgs_xspeed_set }, - { "yspeed", _wrap_TouchEventArgs_yspeed_get, _wrap_TouchEventArgs_yspeed_set }, - { "xaccel", _wrap_TouchEventArgs_xaccel_get, _wrap_TouchEventArgs_xaccel_set }, - { "yaccel", _wrap_TouchEventArgs_yaccel_get, _wrap_TouchEventArgs_yaccel_set }, - {0,0,0} -}; -static swig_lua_method swig_TouchEventArgs_methods[]= { - {0,0} -}; -static swig_lua_method swig_TouchEventArgs_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_TouchEventArgs_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_TouchEventArgs_Sf_SwigStatic_constants[]= { - {SWIG_LUA_CONSTTAB_INT("down", ofTouchEventArgs::down)}, - {SWIG_LUA_CONSTTAB_INT("up", ofTouchEventArgs::up)}, - {SWIG_LUA_CONSTTAB_INT("move", ofTouchEventArgs::move)}, - {SWIG_LUA_CONSTTAB_INT("doubleTap", ofTouchEventArgs::doubleTap)}, - {SWIG_LUA_CONSTTAB_INT("cancel", ofTouchEventArgs::cancel)}, - {0,0,0,0,0,0} -}; -static swig_lua_method swig_TouchEventArgs_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_TouchEventArgs_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_TouchEventArgs_Sf_SwigStatic = { - "TouchEventArgs", - swig_TouchEventArgs_Sf_SwigStatic_methods, - swig_TouchEventArgs_Sf_SwigStatic_attributes, - swig_TouchEventArgs_Sf_SwigStatic_constants, - swig_TouchEventArgs_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_TouchEventArgs_bases[] = {0,0}; -static const char *swig_TouchEventArgs_base_names[] = {"ofVec2f *",0}; -static swig_lua_class _wrap_class_TouchEventArgs = { "TouchEventArgs", "TouchEventArgs", &SWIGTYPE_p_ofTouchEventArgs,_proxy__wrap_new_TouchEventArgs, swig_delete_TouchEventArgs, swig_TouchEventArgs_methods, swig_TouchEventArgs_attributes, &swig_TouchEventArgs_Sf_SwigStatic, swig_TouchEventArgs_meta, swig_TouchEventArgs_bases, swig_TouchEventArgs_base_names }; - -static int _wrap_sendMessage(lua_State* L) { int SWIG_arg = 0; std::string arg1 ; SWIG_check_num_args("ofSendMessage",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofSendMessage",1,"std::string"); (&arg1)->assign(lua_tostring(L,1),lua_rawlen(L,1)); - ofSendMessage(arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_new_BufferObject(lua_State* L) { int SWIG_arg = 0; ofBufferObject *result = 0 ; - SWIG_check_num_args("ofBufferObject::ofBufferObject",0,0) result = (ofBufferObject *)new ofBufferObject(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofBufferObject,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_BufferObject_allocate__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofBufferObject *arg1 = (ofBufferObject *) 0 ; - SWIG_check_num_args("ofBufferObject::allocate",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBufferObject::allocate",1,"ofBufferObject *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBufferObject,0))){ - SWIG_fail_ptr("BufferObject_allocate",1,SWIGTYPE_p_ofBufferObject); } (arg1)->allocate(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_BufferObject_allocate__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofBufferObject *arg1 = (ofBufferObject *) 0 ; - GLsizeiptr arg2 ; GLenum arg3 ; GLsizeiptr *argp2 ; SWIG_check_num_args("ofBufferObject::allocate",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBufferObject::allocate",1,"ofBufferObject *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofBufferObject::allocate",2,"GLsizeiptr"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofBufferObject::allocate",3,"GLenum"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBufferObject,0))){ - SWIG_fail_ptr("BufferObject_allocate",1,SWIGTYPE_p_ofBufferObject); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_GLsizeiptr,0))){ - SWIG_fail_ptr("BufferObject_allocate",2,SWIGTYPE_p_GLsizeiptr); } arg2 = *argp2; - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (GLenum)lua_tonumber(L, 3); - (arg1)->allocate(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BufferObject_allocate__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofBufferObject *arg1 = (ofBufferObject *) 0 ; - GLsizeiptr arg2 ; void *arg3 = (void *) 0 ; GLenum arg4 ; GLsizeiptr *argp2 ; - SWIG_check_num_args("ofBufferObject::allocate",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBufferObject::allocate",1,"ofBufferObject *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofBufferObject::allocate",2,"GLsizeiptr"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofBufferObject::allocate",3,"void const *"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofBufferObject::allocate",4,"GLenum"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBufferObject,0))){ - SWIG_fail_ptr("BufferObject_allocate",1,SWIGTYPE_p_ofBufferObject); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_GLsizeiptr,0))){ - SWIG_fail_ptr("BufferObject_allocate",2,SWIGTYPE_p_GLsizeiptr); } arg2 = *argp2; - arg3=(void *)SWIG_MustGetPtr(L,3,0,0,3,"BufferObject_allocate"); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (GLenum)lua_tonumber(L, 4); - (arg1)->allocate(arg2,(void const *)arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BufferObject_allocate(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 1) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofBufferObject, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_BufferObject_allocate__SWIG_0(L);} } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofBufferObject, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_GLsizeiptr, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_BufferObject_allocate__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofBufferObject, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_GLsizeiptr, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, 0, 0)) { _v = 0; } else { _v = 1; } } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_BufferObject_allocate__SWIG_2(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'BufferObject_allocate'\n" - " Possible C/C++ prototypes are:\n" " ofBufferObject::allocate()\n" " ofBufferObject::allocate(GLsizeiptr,GLenum)\n" - " ofBufferObject::allocate(GLsizeiptr,void const *,GLenum)\n"); lua_error(L);return 0; } -static int _wrap_BufferObject_isAllocated(lua_State* L) { int SWIG_arg = 0; ofBufferObject *arg1 = (ofBufferObject *) 0 ; - bool result; SWIG_check_num_args("ofBufferObject::isAllocated",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBufferObject::isAllocated",1,"ofBufferObject const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBufferObject,0))){ - SWIG_fail_ptr("BufferObject_isAllocated",1,SWIGTYPE_p_ofBufferObject); } - result = (bool)((ofBufferObject const *)arg1)->isAllocated(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BufferObject_bind(lua_State* L) { int SWIG_arg = 0; ofBufferObject *arg1 = (ofBufferObject *) 0 ; GLenum arg2 ; - SWIG_check_num_args("ofBufferObject::bind",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBufferObject::bind",1,"ofBufferObject const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBufferObject::bind",2,"GLenum"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBufferObject,0))){ - SWIG_fail_ptr("BufferObject_bind",1,SWIGTYPE_p_ofBufferObject); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (GLenum)lua_tonumber(L, 2); - ((ofBufferObject const *)arg1)->bind(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BufferObject_unbind(lua_State* L) { int SWIG_arg = 0; ofBufferObject *arg1 = (ofBufferObject *) 0 ; - GLenum arg2 ; SWIG_check_num_args("ofBufferObject::unbind",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBufferObject::unbind",1,"ofBufferObject const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBufferObject::unbind",2,"GLenum"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBufferObject,0))){ - SWIG_fail_ptr("BufferObject_unbind",1,SWIGTYPE_p_ofBufferObject); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (GLenum)lua_tonumber(L, 2); - ((ofBufferObject const *)arg1)->unbind(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BufferObject_bindBase(lua_State* L) { int SWIG_arg = 0; ofBufferObject *arg1 = (ofBufferObject *) 0 ; - GLenum arg2 ; GLuint arg3 ; SWIG_check_num_args("ofBufferObject::bindBase",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBufferObject::bindBase",1,"ofBufferObject const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBufferObject::bindBase",2,"GLenum"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofBufferObject::bindBase",3,"GLuint"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBufferObject,0))){ - SWIG_fail_ptr("BufferObject_bindBase",1,SWIGTYPE_p_ofBufferObject); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (GLenum)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (GLuint)lua_tonumber(L, 3); - ((ofBufferObject const *)arg1)->bindBase(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BufferObject_unbindBase(lua_State* L) { int SWIG_arg = 0; ofBufferObject *arg1 = (ofBufferObject *) 0 ; - GLenum arg2 ; GLuint arg3 ; SWIG_check_num_args("ofBufferObject::unbindBase",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBufferObject::unbindBase",1,"ofBufferObject const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBufferObject::unbindBase",2,"GLenum"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofBufferObject::unbindBase",3,"GLuint"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBufferObject,0))){ - SWIG_fail_ptr("BufferObject_unbindBase",1,SWIGTYPE_p_ofBufferObject); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (GLenum)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (GLuint)lua_tonumber(L, 3); - ((ofBufferObject const *)arg1)->unbindBase(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BufferObject_bindRange(lua_State* L) { int SWIG_arg = 0; ofBufferObject *arg1 = (ofBufferObject *) 0 ; - GLenum arg2 ; GLuint arg3 ; GLintptr arg4 ; GLsizeiptr arg5 ; GLintptr *argp4 ; GLsizeiptr *argp5 ; - SWIG_check_num_args("ofBufferObject::bindRange",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBufferObject::bindRange",1,"ofBufferObject const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBufferObject::bindRange",2,"GLenum"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofBufferObject::bindRange",3,"GLuint"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofBufferObject::bindRange",4,"GLintptr"); - if(!lua_isuserdata(L,5)) SWIG_fail_arg("ofBufferObject::bindRange",5,"GLsizeiptr"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBufferObject,0))){ - SWIG_fail_ptr("BufferObject_bindRange",1,SWIGTYPE_p_ofBufferObject); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (GLenum)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (GLuint)lua_tonumber(L, 3); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&argp4,SWIGTYPE_p_GLintptr,0))){ - SWIG_fail_ptr("BufferObject_bindRange",4,SWIGTYPE_p_GLintptr); } arg4 = *argp4; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&argp5,SWIGTYPE_p_GLsizeiptr,0))){ - SWIG_fail_ptr("BufferObject_bindRange",5,SWIGTYPE_p_GLsizeiptr); } arg5 = *argp5; - ((ofBufferObject const *)arg1)->bindRange(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_BufferObject_unbindRange(lua_State* L) { int SWIG_arg = 0; ofBufferObject *arg1 = (ofBufferObject *) 0 ; - GLenum arg2 ; GLuint arg3 ; SWIG_check_num_args("ofBufferObject::unbindRange",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBufferObject::unbindRange",1,"ofBufferObject const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBufferObject::unbindRange",2,"GLenum"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofBufferObject::unbindRange",3,"GLuint"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBufferObject,0))){ - SWIG_fail_ptr("BufferObject_unbindRange",1,SWIGTYPE_p_ofBufferObject); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (GLenum)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (GLuint)lua_tonumber(L, 3); - ((ofBufferObject const *)arg1)->unbindRange(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_BufferObject_getId(lua_State* L) { int SWIG_arg = 0; ofBufferObject *arg1 = (ofBufferObject *) 0 ; - GLuint result; SWIG_check_num_args("ofBufferObject::getId",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBufferObject::getId",1,"ofBufferObject const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBufferObject,0))){ - SWIG_fail_ptr("BufferObject_getId",1,SWIGTYPE_p_ofBufferObject); } - result = (GLuint)((ofBufferObject const *)arg1)->getId(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BufferObject_setData(lua_State* L) { int SWIG_arg = 0; ofBufferObject *arg1 = (ofBufferObject *) 0 ; - GLsizeiptr arg2 ; void *arg3 = (void *) 0 ; GLenum arg4 ; GLsizeiptr *argp2 ; - SWIG_check_num_args("ofBufferObject::setData",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBufferObject::setData",1,"ofBufferObject *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofBufferObject::setData",2,"GLsizeiptr"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofBufferObject::setData",3,"void const *"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofBufferObject::setData",4,"GLenum"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBufferObject,0))){ - SWIG_fail_ptr("BufferObject_setData",1,SWIGTYPE_p_ofBufferObject); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_GLsizeiptr,0))){ - SWIG_fail_ptr("BufferObject_setData",2,SWIGTYPE_p_GLsizeiptr); } arg2 = *argp2; - arg3=(void *)SWIG_MustGetPtr(L,3,0,0,3,"BufferObject_setData"); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (GLenum)lua_tonumber(L, 4); - (arg1)->setData(arg2,(void const *)arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BufferObject_updateData__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofBufferObject *arg1 = (ofBufferObject *) 0 ; - GLintptr arg2 ; GLsizeiptr arg3 ; void *arg4 = (void *) 0 ; GLintptr *argp2 ; GLsizeiptr *argp3 ; - SWIG_check_num_args("ofBufferObject::updateData",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBufferObject::updateData",1,"ofBufferObject *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofBufferObject::updateData",2,"GLintptr"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofBufferObject::updateData",3,"GLsizeiptr"); - if(!SWIG_isptrtype(L,4)) SWIG_fail_arg("ofBufferObject::updateData",4,"void const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBufferObject,0))){ - SWIG_fail_ptr("BufferObject_updateData",1,SWIGTYPE_p_ofBufferObject); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_GLintptr,0))){ - SWIG_fail_ptr("BufferObject_updateData",2,SWIGTYPE_p_GLintptr); } arg2 = *argp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&argp3,SWIGTYPE_p_GLsizeiptr,0))){ - SWIG_fail_ptr("BufferObject_updateData",3,SWIGTYPE_p_GLsizeiptr); } arg3 = *argp3; - arg4=(void *)SWIG_MustGetPtr(L,4,0,0,4,"BufferObject_updateData"); (arg1)->updateData(arg2,arg3,(void const *)arg4); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BufferObject_updateData__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofBufferObject *arg1 = (ofBufferObject *) 0 ; - GLsizeiptr arg2 ; void *arg3 = (void *) 0 ; GLsizeiptr *argp2 ; SWIG_check_num_args("ofBufferObject::updateData",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBufferObject::updateData",1,"ofBufferObject *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofBufferObject::updateData",2,"GLsizeiptr"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofBufferObject::updateData",3,"void const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBufferObject,0))){ - SWIG_fail_ptr("BufferObject_updateData",1,SWIGTYPE_p_ofBufferObject); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_GLsizeiptr,0))){ - SWIG_fail_ptr("BufferObject_updateData",2,SWIGTYPE_p_GLsizeiptr); } arg2 = *argp2; - arg3=(void *)SWIG_MustGetPtr(L,3,0,0,3,"BufferObject_updateData"); (arg1)->updateData(arg2,(void const *)arg3); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BufferObject_updateData(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofBufferObject, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_GLsizeiptr, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, 0, 0)) { _v = 0; } else { _v = 1; } } - if (_v) { return _wrap_BufferObject_updateData__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofBufferObject, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_GLintptr, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_GLsizeiptr, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, 0, 0)) { _v = 0; } else { _v = 1; } - } if (_v) { return _wrap_BufferObject_updateData__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'BufferObject_updateData'\n" - " Possible C/C++ prototypes are:\n" " ofBufferObject::updateData(GLintptr,GLsizeiptr,void const *)\n" - " ofBufferObject::updateData(GLsizeiptr,void const *)\n"); lua_error(L);return 0; } -static int _wrap_BufferObject_map(lua_State* L) { int SWIG_arg = 0; ofBufferObject *arg1 = (ofBufferObject *) 0 ; GLenum arg2 ; - void *result = 0 ; SWIG_check_num_args("ofBufferObject::map",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBufferObject::map",1,"ofBufferObject *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBufferObject::map",2,"GLenum"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBufferObject,0))){ - SWIG_fail_ptr("BufferObject_map",1,SWIGTYPE_p_ofBufferObject); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (GLenum)lua_tonumber(L, 2); - result = (void *)(arg1)->map(arg2); SWIG_NewPointerObj(L,result,SWIGTYPE_p_void,0); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BufferObject_unmap(lua_State* L) { int SWIG_arg = 0; ofBufferObject *arg1 = (ofBufferObject *) 0 ; - SWIG_check_num_args("ofBufferObject::unmap",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBufferObject::unmap",1,"ofBufferObject *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBufferObject,0))){ - SWIG_fail_ptr("BufferObject_unmap",1,SWIGTYPE_p_ofBufferObject); } (arg1)->unmap(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_BufferObject_mapRange(lua_State* L) { int SWIG_arg = 0; ofBufferObject *arg1 = (ofBufferObject *) 0 ; - GLintptr arg2 ; GLsizeiptr arg3 ; GLenum arg4 ; GLintptr *argp2 ; GLsizeiptr *argp3 ; void *result = 0 ; - SWIG_check_num_args("ofBufferObject::mapRange",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBufferObject::mapRange",1,"ofBufferObject *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofBufferObject::mapRange",2,"GLintptr"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofBufferObject::mapRange",3,"GLsizeiptr"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofBufferObject::mapRange",4,"GLenum"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBufferObject,0))){ - SWIG_fail_ptr("BufferObject_mapRange",1,SWIGTYPE_p_ofBufferObject); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_GLintptr,0))){ - SWIG_fail_ptr("BufferObject_mapRange",2,SWIGTYPE_p_GLintptr); } arg2 = *argp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&argp3,SWIGTYPE_p_GLsizeiptr,0))){ - SWIG_fail_ptr("BufferObject_mapRange",3,SWIGTYPE_p_GLsizeiptr); } arg3 = *argp3; - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (GLenum)lua_tonumber(L, 4); - result = (void *)(arg1)->mapRange(arg2,arg3,arg4); SWIG_NewPointerObj(L,result,SWIGTYPE_p_void,0); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BufferObject_unmapRange(lua_State* L) { int SWIG_arg = 0; ofBufferObject *arg1 = (ofBufferObject *) 0 ; - SWIG_check_num_args("ofBufferObject::unmapRange",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBufferObject::unmapRange",1,"ofBufferObject *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBufferObject,0))){ - SWIG_fail_ptr("BufferObject_unmapRange",1,SWIGTYPE_p_ofBufferObject); } (arg1)->unmapRange(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BufferObject_copyTo(lua_State* L) { int SWIG_arg = 0; ofBufferObject *arg1 = (ofBufferObject *) 0 ; - ofBufferObject *arg2 = 0 ; SWIG_check_num_args("ofBufferObject::copyTo",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBufferObject::copyTo",1,"ofBufferObject *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofBufferObject::copyTo",2,"ofBufferObject &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBufferObject,0))){ - SWIG_fail_ptr("BufferObject_copyTo",1,SWIGTYPE_p_ofBufferObject); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBufferObject,0))){ - SWIG_fail_ptr("BufferObject_copyTo",2,SWIGTYPE_p_ofBufferObject); } (arg1)->copyTo(*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BufferObject_size(lua_State* L) { int SWIG_arg = 0; ofBufferObject *arg1 = (ofBufferObject *) 0 ; - GLsizeiptr result; SWIG_check_num_args("ofBufferObject::size",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBufferObject::size",1,"ofBufferObject const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBufferObject,0))){ - SWIG_fail_ptr("BufferObject_size",1,SWIGTYPE_p_ofBufferObject); } result = ((ofBufferObject const *)arg1)->size(); { - GLsizeiptr * resultptr = new GLsizeiptr((const GLsizeiptr &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_GLsizeiptr,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static void swig_delete_BufferObject(void *obj) { -ofBufferObject *arg1 = (ofBufferObject *) obj; -delete arg1; -} -static int _proxy__wrap_new_BufferObject(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_BufferObject); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_BufferObject_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_BufferObject_methods[]= { - { "allocate", _wrap_BufferObject_allocate}, - { "isAllocated", _wrap_BufferObject_isAllocated}, - { "bind", _wrap_BufferObject_bind}, - { "unbind", _wrap_BufferObject_unbind}, - { "bindBase", _wrap_BufferObject_bindBase}, - { "unbindBase", _wrap_BufferObject_unbindBase}, - { "bindRange", _wrap_BufferObject_bindRange}, - { "unbindRange", _wrap_BufferObject_unbindRange}, - { "getId", _wrap_BufferObject_getId}, - { "setData", _wrap_BufferObject_setData}, - { "updateData", _wrap_BufferObject_updateData}, - { "map", _wrap_BufferObject_map}, - { "unmap", _wrap_BufferObject_unmap}, - { "mapRange", _wrap_BufferObject_mapRange}, - { "unmapRange", _wrap_BufferObject_unmapRange}, - { "copyTo", _wrap_BufferObject_copyTo}, - { "size", _wrap_BufferObject_size}, - {0,0} -}; -static swig_lua_method swig_BufferObject_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_BufferObject_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_BufferObject_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_BufferObject_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_BufferObject_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_BufferObject_Sf_SwigStatic = { - "BufferObject", - swig_BufferObject_Sf_SwigStatic_methods, - swig_BufferObject_Sf_SwigStatic_attributes, - swig_BufferObject_Sf_SwigStatic_constants, - swig_BufferObject_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_BufferObject_bases[] = {0}; -static const char *swig_BufferObject_base_names[] = {0}; -static swig_lua_class _wrap_class_BufferObject = { "BufferObject", "BufferObject", &SWIGTYPE_p_ofBufferObject,_proxy__wrap_new_BufferObject, swig_delete_BufferObject, swig_BufferObject_methods, swig_BufferObject_attributes, &swig_BufferObject_Sf_SwigStatic, swig_BufferObject_meta, swig_BufferObject_bases, swig_BufferObject_base_names }; - -static int _wrap_getGlInternalFormat__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPixels *arg1 = 0 ; int result; - SWIG_check_num_args("ofGetGlInternalFormat",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofGetGlInternalFormat",1,"ofPixels const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("getGlInternalFormat",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - result = (int)ofGetGlInternalFormat((ofPixels_< unsigned char > const &)*arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getGlInternalFormat__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofShortPixels *arg1 = 0 ; int result; - SWIG_check_num_args("ofGetGlInternalFormat",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofGetGlInternalFormat",1,"ofShortPixels const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("getGlInternalFormat",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - result = (int)ofGetGlInternalFormat((ofPixels_< unsigned short > const &)*arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getGlInternalFormat__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofFloatPixels *arg1 = 0 ; int result; - SWIG_check_num_args("ofGetGlInternalFormat",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofGetGlInternalFormat",1,"ofFloatPixels const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("getGlInternalFormat",1,SWIGTYPE_p_ofPixels_T_float_t); } - result = (int)ofGetGlInternalFormat((ofPixels_< float > const &)*arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getGlInternalFormat(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_getGlInternalFormat__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_getGlInternalFormat__SWIG_1(L);} } if (argc == 1) { int _v; { - void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_getGlInternalFormat__SWIG_2(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'getGlInternalFormat'\n" - " Possible C/C++ prototypes are:\n" " ofGetGlInternalFormat(ofPixels const &)\n" - " ofGetGlInternalFormat(ofShortPixels const &)\n" " ofGetGlInternalFormat(ofFloatPixels const &)\n"); - lua_error(L);return 0; } -static int _wrap_getGlInternalFormatName(lua_State* L) { int SWIG_arg = 0; int arg1 ; std::string result; - SWIG_check_num_args("ofGetGlInternalFormatName",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofGetGlInternalFormatName",1,"int"); arg1 = (int)lua_tonumber(L, 1); - result = ofGetGlInternalFormatName(arg1); lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getGLFormatFromInternal(lua_State* L) { int SWIG_arg = 0; int arg1 ; int result; - SWIG_check_num_args("ofGetGLFormatFromInternal",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofGetGLFormatFromInternal",1,"int"); arg1 = (int)lua_tonumber(L, 1); - result = (int)ofGetGLFormatFromInternal(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getGlTypeFromInternal(lua_State* L) { int SWIG_arg = 0; int arg1 ; int result; - SWIG_check_num_args("ofGetGlTypeFromInternal",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofGetGlTypeFromInternal",1,"int"); - arg1 = (int)lua_tonumber(L, 1); result = (int)ofGetGlTypeFromInternal(arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getGlType__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPixels *arg1 = 0 ; int result; - SWIG_check_num_args("ofGetGlType",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofGetGlType",1,"ofPixels const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("getGlType",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - result = (int)ofGetGlType((ofPixels_< unsigned char > const &)*arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getGlType__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofShortPixels *arg1 = 0 ; int result; - SWIG_check_num_args("ofGetGlType",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofGetGlType",1,"ofShortPixels const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("getGlType",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - result = (int)ofGetGlType((ofPixels_< unsigned short > const &)*arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getGlType__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofFloatPixels *arg1 = 0 ; int result; - SWIG_check_num_args("ofGetGlType",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofGetGlType",1,"ofFloatPixels const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("getGlType",1,SWIGTYPE_p_ofPixels_T_float_t); } result = (int)ofGetGlType((ofPixels_< float > const &)*arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getGlType(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_getGlType__SWIG_0(L);} } if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_getGlType__SWIG_1(L);} } if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_getGlType__SWIG_2(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'getGlType'\n" " Possible C/C++ prototypes are:\n" - " ofGetGlType(ofPixels const &)\n" " ofGetGlType(ofShortPixels const &)\n" " ofGetGlType(ofFloatPixels const &)\n"); - lua_error(L);return 0; } -static int _wrap_getImageTypeFromGLType(lua_State* L) { int SWIG_arg = 0; int arg1 ; ofImageType result; - SWIG_check_num_args("ofGetImageTypeFromGLType",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofGetImageTypeFromGLType",1,"int"); - arg1 = (int)lua_tonumber(L, 1); result = (ofImageType)ofGetImageTypeFromGLType(arg1); - lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_getGLPolyMode(lua_State* L) { int SWIG_arg = 0; ofPolyRenderMode arg1 ; GLuint result; - SWIG_check_num_args("ofGetGLPolyMode",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofGetGLPolyMode",1,"ofPolyRenderMode"); - arg1 = (ofPolyRenderMode)(int)lua_tonumber(L, 1); result = (GLuint)ofGetGLPolyMode(arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getOFPolyMode(lua_State* L) { int SWIG_arg = 0; GLuint arg1 ; ofPolyRenderMode result; - SWIG_check_num_args("ofGetOFPolyMode",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofGetOFPolyMode",1,"GLuint"); - SWIG_contract_assert((lua_tonumber(L,1)>=0),"number must not be negative") arg1 = (GLuint)lua_tonumber(L, 1); - result = (ofPolyRenderMode)ofGetOFPolyMode(arg1); lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getGLPrimitiveMode(lua_State* L) { int SWIG_arg = 0; ofPrimitiveMode arg1 ; GLuint result; - SWIG_check_num_args("ofGetGLPrimitiveMode",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofGetGLPrimitiveMode",1,"ofPrimitiveMode"); - arg1 = (ofPrimitiveMode)(int)lua_tonumber(L, 1); result = (GLuint)ofGetGLPrimitiveMode(arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getOFPrimitiveMode(lua_State* L) { int SWIG_arg = 0; GLuint arg1 ; ofPrimitiveMode result; - SWIG_check_num_args("ofGetOFPrimitiveMode",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofGetOFPrimitiveMode",1,"GLuint"); - SWIG_contract_assert((lua_tonumber(L,1)>=0),"number must not be negative") arg1 = (GLuint)lua_tonumber(L, 1); - result = (ofPrimitiveMode)ofGetOFPrimitiveMode(arg1); lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getGLInternalFormatFromPixelFormat(lua_State* L) { int SWIG_arg = 0; ofPixelFormat arg1 ; int result; - SWIG_check_num_args("ofGetGLInternalFormatFromPixelFormat",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofGetGLInternalFormatFromPixelFormat",1,"ofPixelFormat"); - arg1 = (ofPixelFormat)(int)lua_tonumber(L, 1); result = (int)ofGetGLInternalFormatFromPixelFormat(arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getGLFormatFromPixelFormat(lua_State* L) { int SWIG_arg = 0; ofPixelFormat arg1 ; int result; - SWIG_check_num_args("ofGetGLFormatFromPixelFormat",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofGetGLFormatFromPixelFormat",1,"ofPixelFormat"); - arg1 = (ofPixelFormat)(int)lua_tonumber(L, 1); result = (int)ofGetGLFormatFromPixelFormat(arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getBytesPerChannelFromGLType(lua_State* L) { int SWIG_arg = 0; int arg1 ; int result; - SWIG_check_num_args("ofGetBytesPerChannelFromGLType",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofGetBytesPerChannelFromGLType",1,"int"); arg1 = (int)lua_tonumber(L, 1); - result = (int)ofGetBytesPerChannelFromGLType(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getNumChannelsFromGLFormat(lua_State* L) { int SWIG_arg = 0; int arg1 ; int result; - SWIG_check_num_args("ofGetNumChannelsFromGLFormat",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofGetNumChannelsFromGLFormat",1,"int"); arg1 = (int)lua_tonumber(L, 1); - result = (int)ofGetNumChannelsFromGLFormat(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setPixelStoreiAlignment__SWIG_0(lua_State* L) { int SWIG_arg = 0; GLenum arg1 ; int arg2 ; int arg3 ; - int arg4 ; SWIG_check_num_args("ofSetPixelStoreiAlignment",4,4) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetPixelStoreiAlignment",1,"GLenum"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSetPixelStoreiAlignment",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofSetPixelStoreiAlignment",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofSetPixelStoreiAlignment",4,"int"); - SWIG_contract_assert((lua_tonumber(L,1)>=0),"number must not be negative") arg1 = (GLenum)lua_tonumber(L, 1); - arg2 = (int)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - ofSetPixelStoreiAlignment(arg1,arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setPixelStoreiAlignment__SWIG_1(lua_State* L) { int SWIG_arg = 0; GLenum arg1 ; int arg2 ; - SWIG_check_num_args("ofSetPixelStoreiAlignment",2,2) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetPixelStoreiAlignment",1,"GLenum"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSetPixelStoreiAlignment",2,"int"); - SWIG_contract_assert((lua_tonumber(L,1)>=0),"number must not be negative") arg1 = (GLenum)lua_tonumber(L, 1); - arg2 = (int)lua_tonumber(L, 2); ofSetPixelStoreiAlignment(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_setPixelStoreiAlignment(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_setPixelStoreiAlignment__SWIG_1(L);} } } if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_setPixelStoreiAlignment__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'setPixelStoreiAlignment'\n" - " Possible C/C++ prototypes are:\n" " ofSetPixelStoreiAlignment(GLenum,int,int,int)\n" - " ofSetPixelStoreiAlignment(GLenum,int)\n"); lua_error(L);return 0; } -static int _wrap_GLSupportedExtensions(lua_State* L) { int SWIG_arg = 0; std::vector< std::string > result; - SWIG_check_num_args("ofGLSupportedExtensions",0,0) result = ofGLSupportedExtensions(); { - std::vector< std::string > * resultptr = new std::vector< std::string >((const std::vector< std::string > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_std__string_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_GLCheckExtension(lua_State* L) { int SWIG_arg = 0; std::string arg1 ; bool result; - SWIG_check_num_args("ofGLCheckExtension",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofGLCheckExtension",1,"std::string"); - (&arg1)->assign(lua_tostring(L,1),lua_rawlen(L,1)); result = (bool)ofGLCheckExtension(arg1); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_GLSupportsNPOTTextures(lua_State* L) { int SWIG_arg = 0; bool result; - SWIG_check_num_args("ofGLSupportsNPOTTextures",0,0) result = (bool)ofGLSupportsNPOTTextures(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_isGLProgrammableRenderer(lua_State* L) { int SWIG_arg = 0; bool result; - SWIG_check_num_args("ofIsGLProgrammableRenderer",0,0) result = (bool)ofIsGLProgrammableRenderer(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_GLSLVersionFromGL(lua_State* L) { int SWIG_arg = 0; int arg1 ; int arg2 ; std::string result; - SWIG_check_num_args("ofGLSLVersionFromGL",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofGLSLVersionFromGL",1,"int"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofGLSLVersionFromGL",2,"int"); arg1 = (int)lua_tonumber(L, 1); - arg2 = (int)lua_tonumber(L, 2); result = ofGLSLVersionFromGL(arg1,arg2); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_enableLighting(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofEnableLighting",0,0) - ofEnableLighting(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_disableLighting(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofDisableLighting",0,0) - ofDisableLighting(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_enableSeparateSpecularLight(lua_State* L) { int SWIG_arg = 0; - SWIG_check_num_args("ofEnableSeparateSpecularLight",0,0) ofEnableSeparateSpecularLight(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_disableSeparateSpecularLight(lua_State* L) { int SWIG_arg = 0; - SWIG_check_num_args("ofDisableSeparateSpecularLight",0,0) ofDisableSeparateSpecularLight(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_getLightingEnabled(lua_State* L) { int SWIG_arg = 0; bool result; - SWIG_check_num_args("ofGetLightingEnabled",0,0) result = (bool)ofGetLightingEnabled(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setSmoothLighting(lua_State* L) { int SWIG_arg = 0; bool arg1 ; SWIG_check_num_args("ofSetSmoothLighting",1,1) - if(!lua_isboolean(L,1)) SWIG_fail_arg("ofSetSmoothLighting",1,"bool"); arg1 = (lua_toboolean(L, 1)!=0); - ofSetSmoothLighting(arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setGlobalAmbientColor(lua_State* L) { int SWIG_arg = 0; ofFloatColor *arg1 = 0 ; - SWIG_check_num_args("ofSetGlobalAmbientColor",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofSetGlobalAmbientColor",1,"ofFloatColor const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("setGlobalAmbientColor",1,SWIGTYPE_p_ofColor_T_float_t); } - ofSetGlobalAmbientColor((ofColor_< float > const &)*arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_getGlobalAmbientColor(lua_State* L) { int SWIG_arg = 0; ofFloatColor *result = 0 ; - SWIG_check_num_args("ofGetGlobalAmbientColor",0,0) result = (ofFloatColor *) &ofGetGlobalAmbientColor(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_Light(lua_State* L) { int SWIG_arg = 0; ofLight *result = 0 ; SWIG_check_num_args("ofLight::ofLight",0,0) - result = (ofLight *)new ofLight(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofLight,1); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Light_setup(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; - SWIG_check_num_args("ofLight::setup",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::setup",1,"ofLight *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ SWIG_fail_ptr("Light_setup",1,SWIGTYPE_p_ofLight); } - (arg1)->setup(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Light_enable(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; - SWIG_check_num_args("ofLight::enable",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::enable",1,"ofLight *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ SWIG_fail_ptr("Light_enable",1,SWIGTYPE_p_ofLight); } - (arg1)->enable(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Light_disable(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; - SWIG_check_num_args("ofLight::disable",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::disable",1,"ofLight *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ - SWIG_fail_ptr("Light_disable",1,SWIGTYPE_p_ofLight); } (arg1)->disable(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Light_getIsEnabled(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; bool result; - SWIG_check_num_args("ofLight::getIsEnabled",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::getIsEnabled",1,"ofLight const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ - SWIG_fail_ptr("Light_getIsEnabled",1,SWIGTYPE_p_ofLight); } result = (bool)((ofLight const *)arg1)->getIsEnabled(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Light_setDirectional(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; - SWIG_check_num_args("ofLight::setDirectional",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::setDirectional",1,"ofLight *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ - SWIG_fail_ptr("Light_setDirectional",1,SWIGTYPE_p_ofLight); } (arg1)->setDirectional(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Light_getIsDirectional(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; bool result; - SWIG_check_num_args("ofLight::getIsDirectional",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::getIsDirectional",1,"ofLight const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ - SWIG_fail_ptr("Light_getIsDirectional",1,SWIGTYPE_p_ofLight); } result = (bool)((ofLight const *)arg1)->getIsDirectional(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Light_setSpotlight__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; float arg2 ; - float arg3 ; SWIG_check_num_args("ofLight::setSpotlight",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::setSpotlight",1,"ofLight *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofLight::setSpotlight",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofLight::setSpotlight",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ - SWIG_fail_ptr("Light_setSpotlight",1,SWIGTYPE_p_ofLight); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->setSpotlight(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Light_setSpotlight__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; float arg2 ; - SWIG_check_num_args("ofLight::setSpotlight",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::setSpotlight",1,"ofLight *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofLight::setSpotlight",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ - SWIG_fail_ptr("Light_setSpotlight",1,SWIGTYPE_p_ofLight); } arg2 = (float)lua_tonumber(L, 2); (arg1)->setSpotlight(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Light_setSpotlight__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; - SWIG_check_num_args("ofLight::setSpotlight",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::setSpotlight",1,"ofLight *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ - SWIG_fail_ptr("Light_setSpotlight",1,SWIGTYPE_p_ofLight); } (arg1)->setSpotlight(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Light_setSpotlight(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofLight, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_Light_setSpotlight__SWIG_2(L);} } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofLight, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Light_setSpotlight__SWIG_1(L);} } } - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofLight, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Light_setSpotlight__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Light_setSpotlight'\n" " Possible C/C++ prototypes are:\n" - " ofLight::setSpotlight(float,float)\n" " ofLight::setSpotlight(float)\n" " ofLight::setSpotlight()\n"); - lua_error(L);return 0; } -static int _wrap_Light_getIsSpotlight(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; bool result; - SWIG_check_num_args("ofLight::getIsSpotlight",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::getIsSpotlight",1,"ofLight const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ - SWIG_fail_ptr("Light_getIsSpotlight",1,SWIGTYPE_p_ofLight); } result = (bool)((ofLight const *)arg1)->getIsSpotlight(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Light_setSpotlightCutOff(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; float arg2 ; - SWIG_check_num_args("ofLight::setSpotlightCutOff",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::setSpotlightCutOff",1,"ofLight *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofLight::setSpotlightCutOff",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ - SWIG_fail_ptr("Light_setSpotlightCutOff",1,SWIGTYPE_p_ofLight); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setSpotlightCutOff(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Light_getSpotlightCutOff(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; float result; - SWIG_check_num_args("ofLight::getSpotlightCutOff",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::getSpotlightCutOff",1,"ofLight const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ - SWIG_fail_ptr("Light_getSpotlightCutOff",1,SWIGTYPE_p_ofLight); } - result = (float)((ofLight const *)arg1)->getSpotlightCutOff(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Light_setSpotConcentration(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; float arg2 ; - SWIG_check_num_args("ofLight::setSpotConcentration",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::setSpotConcentration",1,"ofLight *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofLight::setSpotConcentration",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ - SWIG_fail_ptr("Light_setSpotConcentration",1,SWIGTYPE_p_ofLight); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setSpotConcentration(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Light_getSpotConcentration(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; float result; - SWIG_check_num_args("ofLight::getSpotConcentration",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::getSpotConcentration",1,"ofLight const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ - SWIG_fail_ptr("Light_getSpotConcentration",1,SWIGTYPE_p_ofLight); } - result = (float)((ofLight const *)arg1)->getSpotConcentration(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Light_setPointLight(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; - SWIG_check_num_args("ofLight::setPointLight",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::setPointLight",1,"ofLight *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ - SWIG_fail_ptr("Light_setPointLight",1,SWIGTYPE_p_ofLight); } (arg1)->setPointLight(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Light_getIsPointLight(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; bool result; - SWIG_check_num_args("ofLight::getIsPointLight",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::getIsPointLight",1,"ofLight const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ - SWIG_fail_ptr("Light_getIsPointLight",1,SWIGTYPE_p_ofLight); } result = (bool)((ofLight const *)arg1)->getIsPointLight(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Light_setAttenuation__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; float arg2 ; - float arg3 ; float arg4 ; SWIG_check_num_args("ofLight::setAttenuation",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::setAttenuation",1,"ofLight *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofLight::setAttenuation",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofLight::setAttenuation",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofLight::setAttenuation",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ - SWIG_fail_ptr("Light_setAttenuation",1,SWIGTYPE_p_ofLight); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); (arg1)->setAttenuation(arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Light_setAttenuation__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; float arg2 ; - float arg3 ; SWIG_check_num_args("ofLight::setAttenuation",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::setAttenuation",1,"ofLight *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofLight::setAttenuation",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofLight::setAttenuation",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ - SWIG_fail_ptr("Light_setAttenuation",1,SWIGTYPE_p_ofLight); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->setAttenuation(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Light_setAttenuation__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; float arg2 ; - SWIG_check_num_args("ofLight::setAttenuation",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::setAttenuation",1,"ofLight *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofLight::setAttenuation",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ - SWIG_fail_ptr("Light_setAttenuation",1,SWIGTYPE_p_ofLight); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setAttenuation(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Light_setAttenuation__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; - SWIG_check_num_args("ofLight::setAttenuation",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::setAttenuation",1,"ofLight *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ - SWIG_fail_ptr("Light_setAttenuation",1,SWIGTYPE_p_ofLight); } (arg1)->setAttenuation(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Light_setAttenuation(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 1) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofLight, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_Light_setAttenuation__SWIG_3(L);} } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofLight, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Light_setAttenuation__SWIG_2(L);} } } - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofLight, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Light_setAttenuation__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofLight, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Light_setAttenuation__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Light_setAttenuation'\n" - " Possible C/C++ prototypes are:\n" " ofLight::setAttenuation(float,float,float)\n" - " ofLight::setAttenuation(float,float)\n" " ofLight::setAttenuation(float)\n" " ofLight::setAttenuation()\n"); - lua_error(L);return 0; } -static int _wrap_Light_getAttenuationConstant(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; float result; - SWIG_check_num_args("ofLight::getAttenuationConstant",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::getAttenuationConstant",1,"ofLight const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ - SWIG_fail_ptr("Light_getAttenuationConstant",1,SWIGTYPE_p_ofLight); } - result = (float)((ofLight const *)arg1)->getAttenuationConstant(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Light_getAttenuationLinear(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; float result; - SWIG_check_num_args("ofLight::getAttenuationLinear",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::getAttenuationLinear",1,"ofLight const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ - SWIG_fail_ptr("Light_getAttenuationLinear",1,SWIGTYPE_p_ofLight); } - result = (float)((ofLight const *)arg1)->getAttenuationLinear(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Light_getAttenuationQuadratic(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; float result; - SWIG_check_num_args("ofLight::getAttenuationQuadratic",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::getAttenuationQuadratic",1,"ofLight const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ - SWIG_fail_ptr("Light_getAttenuationQuadratic",1,SWIGTYPE_p_ofLight); } - result = (float)((ofLight const *)arg1)->getAttenuationQuadratic(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Light_setAreaLight(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofLight::setAreaLight",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::setAreaLight",1,"ofLight *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofLight::setAreaLight",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofLight::setAreaLight",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ - SWIG_fail_ptr("Light_setAreaLight",1,SWIGTYPE_p_ofLight); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->setAreaLight(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Light_getIsAreaLight(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; bool result; - SWIG_check_num_args("ofLight::getIsAreaLight",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::getIsAreaLight",1,"ofLight const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ - SWIG_fail_ptr("Light_getIsAreaLight",1,SWIGTYPE_p_ofLight); } result = (bool)((ofLight const *)arg1)->getIsAreaLight(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Light_getType(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; int result; - SWIG_check_num_args("ofLight::getType",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::getType",1,"ofLight const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ - SWIG_fail_ptr("Light_getType",1,SWIGTYPE_p_ofLight); } result = (int)((ofLight const *)arg1)->getType(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Light_setAmbientColor(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; - ofFloatColor *arg2 = 0 ; SWIG_check_num_args("ofLight::setAmbientColor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::setAmbientColor",1,"ofLight *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofLight::setAmbientColor",2,"ofFloatColor const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ - SWIG_fail_ptr("Light_setAmbientColor",1,SWIGTYPE_p_ofLight); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("Light_setAmbientColor",2,SWIGTYPE_p_ofColor_T_float_t); } - (arg1)->setAmbientColor((ofFloatColor const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Light_setDiffuseColor(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; - ofFloatColor *arg2 = 0 ; SWIG_check_num_args("ofLight::setDiffuseColor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::setDiffuseColor",1,"ofLight *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofLight::setDiffuseColor",2,"ofFloatColor const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ - SWIG_fail_ptr("Light_setDiffuseColor",1,SWIGTYPE_p_ofLight); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("Light_setDiffuseColor",2,SWIGTYPE_p_ofColor_T_float_t); } - (arg1)->setDiffuseColor((ofFloatColor const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Light_setSpecularColor(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; - ofFloatColor *arg2 = 0 ; SWIG_check_num_args("ofLight::setSpecularColor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::setSpecularColor",1,"ofLight *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofLight::setSpecularColor",2,"ofFloatColor const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ - SWIG_fail_ptr("Light_setSpecularColor",1,SWIGTYPE_p_ofLight); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("Light_setSpecularColor",2,SWIGTYPE_p_ofColor_T_float_t); } - (arg1)->setSpecularColor((ofFloatColor const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Light_getAmbientColor(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; ofFloatColor result; - SWIG_check_num_args("ofLight::getAmbientColor",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::getAmbientColor",1,"ofLight const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ - SWIG_fail_ptr("Light_getAmbientColor",1,SWIGTYPE_p_ofLight); } result = ((ofLight const *)arg1)->getAmbientColor(); { - ofFloatColor * resultptr = new ofFloatColor((const ofFloatColor &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Light_getDiffuseColor(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; ofFloatColor result; - SWIG_check_num_args("ofLight::getDiffuseColor",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::getDiffuseColor",1,"ofLight const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ - SWIG_fail_ptr("Light_getDiffuseColor",1,SWIGTYPE_p_ofLight); } result = ((ofLight const *)arg1)->getDiffuseColor(); { - ofFloatColor * resultptr = new ofFloatColor((const ofFloatColor &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Light_getSpecularColor(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; ofFloatColor result; - SWIG_check_num_args("ofLight::getSpecularColor",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::getSpecularColor",1,"ofLight const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ - SWIG_fail_ptr("Light_getSpecularColor",1,SWIGTYPE_p_ofLight); } result = ((ofLight const *)arg1)->getSpecularColor(); { - ofFloatColor * resultptr = new ofFloatColor((const ofFloatColor &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Light_getLightID(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; int result; - SWIG_check_num_args("ofLight::getLightID",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::getLightID",1,"ofLight const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ - SWIG_fail_ptr("Light_getLightID",1,SWIGTYPE_p_ofLight); } result = (int)((ofLight const *)arg1)->getLightID(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_Light(void *obj) { -ofLight *arg1 = (ofLight *) obj; -delete arg1; -} -static int _proxy__wrap_new_Light(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_Light); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_Light_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_Light_methods[]= { - { "setup", _wrap_Light_setup}, - { "enable", _wrap_Light_enable}, - { "disable", _wrap_Light_disable}, - { "getIsEnabled", _wrap_Light_getIsEnabled}, - { "setDirectional", _wrap_Light_setDirectional}, - { "getIsDirectional", _wrap_Light_getIsDirectional}, - { "setSpotlight", _wrap_Light_setSpotlight}, - { "getIsSpotlight", _wrap_Light_getIsSpotlight}, - { "setSpotlightCutOff", _wrap_Light_setSpotlightCutOff}, - { "getSpotlightCutOff", _wrap_Light_getSpotlightCutOff}, - { "setSpotConcentration", _wrap_Light_setSpotConcentration}, - { "getSpotConcentration", _wrap_Light_getSpotConcentration}, - { "setPointLight", _wrap_Light_setPointLight}, - { "getIsPointLight", _wrap_Light_getIsPointLight}, - { "setAttenuation", _wrap_Light_setAttenuation}, - { "getAttenuationConstant", _wrap_Light_getAttenuationConstant}, - { "getAttenuationLinear", _wrap_Light_getAttenuationLinear}, - { "getAttenuationQuadratic", _wrap_Light_getAttenuationQuadratic}, - { "setAreaLight", _wrap_Light_setAreaLight}, - { "getIsAreaLight", _wrap_Light_getIsAreaLight}, - { "getType", _wrap_Light_getType}, - { "setAmbientColor", _wrap_Light_setAmbientColor}, - { "setDiffuseColor", _wrap_Light_setDiffuseColor}, - { "setSpecularColor", _wrap_Light_setSpecularColor}, - { "getAmbientColor", _wrap_Light_getAmbientColor}, - { "getDiffuseColor", _wrap_Light_getDiffuseColor}, - { "getSpecularColor", _wrap_Light_getSpecularColor}, - { "getLightID", _wrap_Light_getLightID}, - {0,0} -}; -static swig_lua_method swig_Light_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_Light_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_Light_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_Light_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_Light_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_Light_Sf_SwigStatic = { - "Light", - swig_Light_Sf_SwigStatic_methods, - swig_Light_Sf_SwigStatic_attributes, - swig_Light_Sf_SwigStatic_constants, - swig_Light_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_Light_bases[] = {0,0}; -static const char *swig_Light_base_names[] = {"ofNode *",0}; -static swig_lua_class _wrap_class_Light = { "Light", "Light", &SWIGTYPE_p_ofLight,_proxy__wrap_new_Light, swig_delete_Light, swig_Light_methods, swig_Light_attributes, &swig_Light_Sf_SwigStatic, swig_Light_meta, swig_Light_bases, swig_Light_base_names }; - -static int _wrap_lightsData(lua_State* L) { int SWIG_arg = 0; std::vector< weak_ptr< ofLight::Data > > *result = 0 ; - SWIG_check_num_args("ofLightsData",0,0) result = (std::vector< weak_ptr< ofLight::Data > > *) &ofLightsData(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_weak_ptrT_ofLight__Data_t_t,0); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_new_Material(lua_State* L) { int SWIG_arg = 0; ofMaterial *result = 0 ; - SWIG_check_num_args("ofMaterial::ofMaterial",0,0) result = (ofMaterial *)new ofMaterial(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMaterial,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Material_setColors(lua_State* L) { int SWIG_arg = 0; ofMaterial *arg1 = (ofMaterial *) 0 ; ofFloatColor arg2 ; - ofFloatColor arg3 ; ofFloatColor arg4 ; ofFloatColor arg5 ; ofFloatColor *argp2 ; ofFloatColor *argp3 ; ofFloatColor *argp4 ; - ofFloatColor *argp5 ; SWIG_check_num_args("ofMaterial::setColors",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMaterial::setColors",1,"ofMaterial *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMaterial::setColors",2,"ofFloatColor"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofMaterial::setColors",3,"ofFloatColor"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofMaterial::setColors",4,"ofFloatColor"); - if(!lua_isuserdata(L,5)) SWIG_fail_arg("ofMaterial::setColors",5,"ofFloatColor"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMaterial,0))){ - SWIG_fail_ptr("Material_setColors",1,SWIGTYPE_p_ofMaterial); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("Material_setColors",2,SWIGTYPE_p_ofColor_T_float_t); } arg2 = *argp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&argp3,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("Material_setColors",3,SWIGTYPE_p_ofColor_T_float_t); } arg3 = *argp3; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&argp4,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("Material_setColors",4,SWIGTYPE_p_ofColor_T_float_t); } arg4 = *argp4; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&argp5,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("Material_setColors",5,SWIGTYPE_p_ofColor_T_float_t); } arg5 = *argp5; - (arg1)->setColors(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Material_setDiffuseColor(lua_State* L) { int SWIG_arg = 0; ofMaterial *arg1 = (ofMaterial *) 0 ; - ofFloatColor arg2 ; ofFloatColor *argp2 ; SWIG_check_num_args("ofMaterial::setDiffuseColor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMaterial::setDiffuseColor",1,"ofMaterial *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMaterial::setDiffuseColor",2,"ofFloatColor"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMaterial,0))){ - SWIG_fail_ptr("Material_setDiffuseColor",1,SWIGTYPE_p_ofMaterial); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("Material_setDiffuseColor",2,SWIGTYPE_p_ofColor_T_float_t); } arg2 = *argp2; (arg1)->setDiffuseColor(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Material_setAmbientColor(lua_State* L) { int SWIG_arg = 0; ofMaterial *arg1 = (ofMaterial *) 0 ; - ofFloatColor arg2 ; ofFloatColor *argp2 ; SWIG_check_num_args("ofMaterial::setAmbientColor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMaterial::setAmbientColor",1,"ofMaterial *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMaterial::setAmbientColor",2,"ofFloatColor"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMaterial,0))){ - SWIG_fail_ptr("Material_setAmbientColor",1,SWIGTYPE_p_ofMaterial); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("Material_setAmbientColor",2,SWIGTYPE_p_ofColor_T_float_t); } arg2 = *argp2; (arg1)->setAmbientColor(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Material_setSpecularColor(lua_State* L) { int SWIG_arg = 0; ofMaterial *arg1 = (ofMaterial *) 0 ; - ofFloatColor arg2 ; ofFloatColor *argp2 ; SWIG_check_num_args("ofMaterial::setSpecularColor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMaterial::setSpecularColor",1,"ofMaterial *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMaterial::setSpecularColor",2,"ofFloatColor"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMaterial,0))){ - SWIG_fail_ptr("Material_setSpecularColor",1,SWIGTYPE_p_ofMaterial); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("Material_setSpecularColor",2,SWIGTYPE_p_ofColor_T_float_t); } arg2 = *argp2; (arg1)->setSpecularColor(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Material_setEmissiveColor(lua_State* L) { int SWIG_arg = 0; ofMaterial *arg1 = (ofMaterial *) 0 ; - ofFloatColor arg2 ; ofFloatColor *argp2 ; SWIG_check_num_args("ofMaterial::setEmissiveColor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMaterial::setEmissiveColor",1,"ofMaterial *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMaterial::setEmissiveColor",2,"ofFloatColor"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMaterial,0))){ - SWIG_fail_ptr("Material_setEmissiveColor",1,SWIGTYPE_p_ofMaterial); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("Material_setEmissiveColor",2,SWIGTYPE_p_ofColor_T_float_t); } arg2 = *argp2; (arg1)->setEmissiveColor(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Material_setShininess(lua_State* L) { int SWIG_arg = 0; ofMaterial *arg1 = (ofMaterial *) 0 ; float arg2 ; - SWIG_check_num_args("ofMaterial::setShininess",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMaterial::setShininess",1,"ofMaterial *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMaterial::setShininess",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMaterial,0))){ - SWIG_fail_ptr("Material_setShininess",1,SWIGTYPE_p_ofMaterial); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setShininess(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Material_getDiffuseColor(lua_State* L) { int SWIG_arg = 0; ofMaterial *arg1 = (ofMaterial *) 0 ; - ofFloatColor result; SWIG_check_num_args("ofMaterial::getDiffuseColor",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMaterial::getDiffuseColor",1,"ofMaterial const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMaterial,0))){ - SWIG_fail_ptr("Material_getDiffuseColor",1,SWIGTYPE_p_ofMaterial); } - result = ((ofMaterial const *)arg1)->getDiffuseColor(); { - ofFloatColor * resultptr = new ofFloatColor((const ofFloatColor &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Material_getAmbientColor(lua_State* L) { int SWIG_arg = 0; ofMaterial *arg1 = (ofMaterial *) 0 ; - ofFloatColor result; SWIG_check_num_args("ofMaterial::getAmbientColor",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMaterial::getAmbientColor",1,"ofMaterial const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMaterial,0))){ - SWIG_fail_ptr("Material_getAmbientColor",1,SWIGTYPE_p_ofMaterial); } - result = ((ofMaterial const *)arg1)->getAmbientColor(); { - ofFloatColor * resultptr = new ofFloatColor((const ofFloatColor &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Material_getSpecularColor(lua_State* L) { int SWIG_arg = 0; ofMaterial *arg1 = (ofMaterial *) 0 ; - ofFloatColor result; SWIG_check_num_args("ofMaterial::getSpecularColor",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMaterial::getSpecularColor",1,"ofMaterial const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMaterial,0))){ - SWIG_fail_ptr("Material_getSpecularColor",1,SWIGTYPE_p_ofMaterial); } - result = ((ofMaterial const *)arg1)->getSpecularColor(); { - ofFloatColor * resultptr = new ofFloatColor((const ofFloatColor &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Material_getEmissiveColor(lua_State* L) { int SWIG_arg = 0; ofMaterial *arg1 = (ofMaterial *) 0 ; - ofFloatColor result; SWIG_check_num_args("ofMaterial::getEmissiveColor",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMaterial::getEmissiveColor",1,"ofMaterial const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMaterial,0))){ - SWIG_fail_ptr("Material_getEmissiveColor",1,SWIGTYPE_p_ofMaterial); } - result = ((ofMaterial const *)arg1)->getEmissiveColor(); { - ofFloatColor * resultptr = new ofFloatColor((const ofFloatColor &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Material_getShininess(lua_State* L) { int SWIG_arg = 0; ofMaterial *arg1 = (ofMaterial *) 0 ; float result; - SWIG_check_num_args("ofMaterial::getShininess",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMaterial::getShininess",1,"ofMaterial const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMaterial,0))){ - SWIG_fail_ptr("Material_getShininess",1,SWIGTYPE_p_ofMaterial); } - result = (float)((ofMaterial const *)arg1)->getShininess(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Material_beginMaterial(lua_State* L) { int SWIG_arg = 0; ofMaterial *arg1 = (ofMaterial *) 0 ; - SWIG_check_num_args("ofMaterial::begin",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMaterial::begin",1,"ofMaterial const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMaterial,0))){ - SWIG_fail_ptr("Material_beginMaterial",1,SWIGTYPE_p_ofMaterial); } ((ofMaterial const *)arg1)->begin(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Material_endMaterial(lua_State* L) { int SWIG_arg = 0; ofMaterial *arg1 = (ofMaterial *) 0 ; - SWIG_check_num_args("ofMaterial::end",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMaterial::end",1,"ofMaterial const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMaterial,0))){ - SWIG_fail_ptr("Material_endMaterial",1,SWIGTYPE_p_ofMaterial); } ((ofMaterial const *)arg1)->end(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_Material(void *obj) { -ofMaterial *arg1 = (ofMaterial *) obj; -delete arg1; -} -static int _proxy__wrap_new_Material(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_Material); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_Material_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_Material_methods[]= { - { "setColors", _wrap_Material_setColors}, - { "setDiffuseColor", _wrap_Material_setDiffuseColor}, - { "setAmbientColor", _wrap_Material_setAmbientColor}, - { "setSpecularColor", _wrap_Material_setSpecularColor}, - { "setEmissiveColor", _wrap_Material_setEmissiveColor}, - { "setShininess", _wrap_Material_setShininess}, - { "getDiffuseColor", _wrap_Material_getDiffuseColor}, - { "getAmbientColor", _wrap_Material_getAmbientColor}, - { "getSpecularColor", _wrap_Material_getSpecularColor}, - { "getEmissiveColor", _wrap_Material_getEmissiveColor}, - { "getShininess", _wrap_Material_getShininess}, - { "beginMaterial", _wrap_Material_beginMaterial}, - { "endMaterial", _wrap_Material_endMaterial}, - {0,0} -}; -static swig_lua_method swig_Material_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_Material_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_Material_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_Material_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_Material_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_Material_Sf_SwigStatic = { - "Material", - swig_Material_Sf_SwigStatic_methods, - swig_Material_Sf_SwigStatic_attributes, - swig_Material_Sf_SwigStatic_constants, - swig_Material_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_Material_bases[] = {0}; -static const char *swig_Material_base_names[] = {0}; -static swig_lua_class _wrap_class_Material = { "Material", "Material", &SWIGTYPE_p_ofMaterial,_proxy__wrap_new_Material, swig_delete_Material, swig_Material_methods, swig_Material_attributes, &swig_Material_Sf_SwigStatic, swig_Material_meta, swig_Material_bases, swig_Material_base_names }; - -static int _wrap_new_Shader__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofShader *result = 0 ; - SWIG_check_num_args("ofShader::ofShader",0,0) result = (ofShader *)new ofShader(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofShader,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Shader__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = 0 ; ofShader *result = 0 ; - SWIG_check_num_args("ofShader::ofShader",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofShader::ofShader",1,"ofShader &&"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ SWIG_fail_ptr("new_Shader",1,SWIGTYPE_p_ofShader); } - result = (ofShader *)new ofShader((ofShader &&)*arg1); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofShader,1); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_new_Shader(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_Shader__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_new_Shader__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_Shader'\n" " Possible C/C++ prototypes are:\n" - " ofShader::ofShader()\n" " ofShader::ofShader(ofShader &&)\n"); lua_error(L);return 0; } -static int _wrap_Shader_load__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; std::string arg2 ; - bool result; SWIG_check_num_args("ofShader::load",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::load",1,"ofShader *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::load",2,"std::string"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_load",1,SWIGTYPE_p_ofShader); } (&arg2)->assign(lua_tostring(L,2),lua_rawlen(L,2)); - result = (bool)(arg1)->load(arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Shader_load__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; std::string arg2 ; - std::string arg3 ; std::string arg4 ; bool result; SWIG_check_num_args("ofShader::load",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::load",1,"ofShader *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::load",2,"std::string"); - if(!lua_isstring(L,3)) SWIG_fail_arg("ofShader::load",3,"std::string"); - if(!lua_isstring(L,4)) SWIG_fail_arg("ofShader::load",4,"std::string"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_load",1,SWIGTYPE_p_ofShader); } (&arg2)->assign(lua_tostring(L,2),lua_rawlen(L,2)); - (&arg3)->assign(lua_tostring(L,3),lua_rawlen(L,3)); (&arg4)->assign(lua_tostring(L,4),lua_rawlen(L,4)); - result = (bool)(arg1)->load(arg2,arg3,arg4); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_load__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; std::string arg2 ; - std::string arg3 ; bool result; SWIG_check_num_args("ofShader::load",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::load",1,"ofShader *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::load",2,"std::string"); - if(!lua_isstring(L,3)) SWIG_fail_arg("ofShader::load",3,"std::string"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_load",1,SWIGTYPE_p_ofShader); } (&arg2)->assign(lua_tostring(L,2),lua_rawlen(L,2)); - (&arg3)->assign(lua_tostring(L,3),lua_rawlen(L,3)); result = (bool)(arg1)->load(arg2,arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_load(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { - return _wrap_Shader_load__SWIG_0(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isstring(L,argv[2]); } if (_v) { - return _wrap_Shader_load__SWIG_2(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isstring(L,argv[2]); } if (_v) { - { _v = lua_isstring(L,argv[3]); } if (_v) { return _wrap_Shader_load__SWIG_1(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Shader_load'\n" " Possible C/C++ prototypes are:\n" - " ofShader::load(std::string)\n" " ofShader::load(std::string,std::string,std::string)\n" - " ofShader::load(std::string,std::string)\n"); lua_error(L);return 0; } -static int _wrap_Shader_setGeometryInputType(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; GLenum arg2 ; - SWIG_check_num_args("ofShader::setGeometryInputType",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setGeometryInputType",1,"ofShader *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofShader::setGeometryInputType",2,"GLenum"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setGeometryInputType",1,SWIGTYPE_p_ofShader); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (GLenum)lua_tonumber(L, 2); - (arg1)->setGeometryInputType(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setGeometryOutputType(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; GLenum arg2 ; - SWIG_check_num_args("ofShader::setGeometryOutputType",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setGeometryOutputType",1,"ofShader *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofShader::setGeometryOutputType",2,"GLenum"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setGeometryOutputType",1,SWIGTYPE_p_ofShader); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (GLenum)lua_tonumber(L, 2); - (arg1)->setGeometryOutputType(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setGeometryOutputCount(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; int arg2 ; - SWIG_check_num_args("ofShader::setGeometryOutputCount",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setGeometryOutputCount",1,"ofShader *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofShader::setGeometryOutputCount",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setGeometryOutputCount",1,SWIGTYPE_p_ofShader); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->setGeometryOutputCount(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_getGeometryMaxOutputCount(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - int result; SWIG_check_num_args("ofShader::getGeometryMaxOutputCount",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::getGeometryMaxOutputCount",1,"ofShader const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_getGeometryMaxOutputCount",1,SWIGTYPE_p_ofShader); } - result = (int)((ofShader const *)arg1)->getGeometryMaxOutputCount(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_unload(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - SWIG_check_num_args("ofShader::unload",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::unload",1,"ofShader *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_unload",1,SWIGTYPE_p_ofShader); } (arg1)->unload(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Shader_isLoaded(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; bool result; - SWIG_check_num_args("ofShader::isLoaded",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::isLoaded",1,"ofShader const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_isLoaded",1,SWIGTYPE_p_ofShader); } result = (bool)((ofShader const *)arg1)->isLoaded(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_beginShader(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - SWIG_check_num_args("ofShader::begin",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::begin",1,"ofShader const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_beginShader",1,SWIGTYPE_p_ofShader); } ((ofShader const *)arg1)->begin(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_endShader(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - SWIG_check_num_args("ofShader::end",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::end",1,"ofShader const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_endShader",1,SWIGTYPE_p_ofShader); } ((ofShader const *)arg1)->end(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniformTexture__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; ofBaseHasTexture *arg3 = 0 ; int arg4 ; std::string temp2 ; - SWIG_check_num_args("ofShader::setUniformTexture",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniformTexture",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniformTexture",2,"std::string const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofShader::setUniformTexture",3,"ofBaseHasTexture const &"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofShader::setUniformTexture",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniformTexture",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofBaseHasTexture,0))){ - SWIG_fail_ptr("Shader_setUniformTexture",3,SWIGTYPE_p_ofBaseHasTexture); } arg4 = (int)lua_tonumber(L, 4); - ((ofShader const *)arg1)->setUniformTexture((std::string const &)*arg2,(ofBaseHasTexture const &)*arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniformTexture__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; ofTexture *arg3 = 0 ; int arg4 ; std::string temp2 ; - SWIG_check_num_args("ofShader::setUniformTexture",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniformTexture",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniformTexture",2,"std::string const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofShader::setUniformTexture",3,"ofTexture const &"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofShader::setUniformTexture",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniformTexture",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Shader_setUniformTexture",3,SWIGTYPE_p_ofTexture); } arg4 = (int)lua_tonumber(L, 4); - ((ofShader const *)arg1)->setUniformTexture((std::string const &)*arg2,(ofTexture const &)*arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniformTexture__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; int arg3 ; GLint arg4 ; int arg5 ; std::string temp2 ; - SWIG_check_num_args("ofShader::setUniformTexture",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniformTexture",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniformTexture",2,"std::string const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofShader::setUniformTexture",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofShader::setUniformTexture",4,"GLint"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofShader::setUniformTexture",5,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniformTexture",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; arg3 = (int)lua_tonumber(L, 3); - arg4 = (GLint)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); - ((ofShader const *)arg1)->setUniformTexture((std::string const &)*arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniformTexture(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); - if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofBaseHasTexture, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { - return _wrap_Shader_setUniformTexture__SWIG_0(L);} } } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { - return _wrap_Shader_setUniformTexture__SWIG_1(L);} } } } } if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Shader_setUniformTexture__SWIG_2(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Shader_setUniformTexture'\n" - " Possible C/C++ prototypes are:\n" - " ofShader::setUniformTexture(std::string const &,ofBaseHasTexture const &,int) const\n" - " ofShader::setUniformTexture(std::string const &,ofTexture const &,int) const\n" - " ofShader::setUniformTexture(std::string const &,int,GLint,int) const\n"); lua_error(L);return 0; } -static int _wrap_Shader_setUniform1i(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; std::string *arg2 = 0 ; - int arg3 ; std::string temp2 ; SWIG_check_num_args("ofShader::setUniform1i",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniform1i",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniform1i",2,"std::string const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofShader::setUniform1i",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniform1i",1,SWIGTYPE_p_ofShader); } temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - arg3 = (int)lua_tonumber(L, 3); ((ofShader const *)arg1)->setUniform1i((std::string const &)*arg2,arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniform2i(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; std::string *arg2 = 0 ; - int arg3 ; int arg4 ; std::string temp2 ; SWIG_check_num_args("ofShader::setUniform2i",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniform2i",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniform2i",2,"std::string const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofShader::setUniform2i",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofShader::setUniform2i",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniform2i",1,SWIGTYPE_p_ofShader); } temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - ((ofShader const *)arg1)->setUniform2i((std::string const &)*arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniform3i(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; std::string *arg2 = 0 ; - int arg3 ; int arg4 ; int arg5 ; std::string temp2 ; SWIG_check_num_args("ofShader::setUniform3i",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniform3i",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniform3i",2,"std::string const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofShader::setUniform3i",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofShader::setUniform3i",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofShader::setUniform3i",5,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniform3i",1,SWIGTYPE_p_ofShader); } temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); - ((ofShader const *)arg1)->setUniform3i((std::string const &)*arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniform4i(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; std::string *arg2 = 0 ; - int arg3 ; int arg4 ; int arg5 ; int arg6 ; std::string temp2 ; SWIG_check_num_args("ofShader::setUniform4i",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniform4i",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniform4i",2,"std::string const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofShader::setUniform4i",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofShader::setUniform4i",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofShader::setUniform4i",5,"int"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofShader::setUniform4i",6,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniform4i",1,SWIGTYPE_p_ofShader); } temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); - arg6 = (int)lua_tonumber(L, 6); ((ofShader const *)arg1)->setUniform4i((std::string const &)*arg2,arg3,arg4,arg5,arg6); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniform1f(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; std::string *arg2 = 0 ; - float arg3 ; std::string temp2 ; SWIG_check_num_args("ofShader::setUniform1f",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniform1f",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniform1f",2,"std::string const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofShader::setUniform1f",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniform1f",1,SWIGTYPE_p_ofShader); } temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - arg3 = (float)lua_tonumber(L, 3); ((ofShader const *)arg1)->setUniform1f((std::string const &)*arg2,arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniform2f__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; float arg3 ; float arg4 ; std::string temp2 ; SWIG_check_num_args("ofShader::setUniform2f",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniform2f",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniform2f",2,"std::string const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofShader::setUniform2f",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofShader::setUniform2f",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniform2f",1,SWIGTYPE_p_ofShader); } temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - ((ofShader const *)arg1)->setUniform2f((std::string const &)*arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniform3f__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; float arg3 ; float arg4 ; float arg5 ; std::string temp2 ; - SWIG_check_num_args("ofShader::setUniform3f",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniform3f",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniform3f",2,"std::string const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofShader::setUniform3f",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofShader::setUniform3f",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofShader::setUniform3f",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniform3f",1,SWIGTYPE_p_ofShader); } temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - ((ofShader const *)arg1)->setUniform3f((std::string const &)*arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniform4f__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; float arg3 ; float arg4 ; float arg5 ; float arg6 ; std::string temp2 ; - SWIG_check_num_args("ofShader::setUniform4f",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniform4f",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniform4f",2,"std::string const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofShader::setUniform4f",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofShader::setUniform4f",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofShader::setUniform4f",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofShader::setUniform4f",6,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniform4f",1,SWIGTYPE_p_ofShader); } temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); ((ofShader const *)arg1)->setUniform4f((std::string const &)*arg2,arg3,arg4,arg5,arg6); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniform2f__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; ofVec2f *arg3 = 0 ; std::string temp2 ; SWIG_check_num_args("ofShader::setUniform2f",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniform2f",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniform2f",2,"std::string const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofShader::setUniform2f",3,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniform2f",1,SWIGTYPE_p_ofShader); } temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Shader_setUniform2f",3,SWIGTYPE_p_ofVec2f); } - ((ofShader const *)arg1)->setUniform2f((std::string const &)*arg2,(ofVec2f const &)*arg3); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniform2f(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Shader_setUniform2f__SWIG_1(L);} } } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Shader_setUniform2f__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Shader_setUniform2f'\n" - " Possible C/C++ prototypes are:\n" " ofShader::setUniform2f(std::string const &,float,float) const\n" - " ofShader::setUniform2f(std::string const &,ofVec2f const &) const\n"); lua_error(L);return 0; } -static int _wrap_Shader_setUniform3f__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; ofVec3f *arg3 = 0 ; std::string temp2 ; SWIG_check_num_args("ofShader::setUniform3f",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniform3f",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniform3f",2,"std::string const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofShader::setUniform3f",3,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniform3f",1,SWIGTYPE_p_ofShader); } temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Shader_setUniform3f",3,SWIGTYPE_p_ofVec3f); } - ((ofShader const *)arg1)->setUniform3f((std::string const &)*arg2,(ofVec3f const &)*arg3); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniform3f(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Shader_setUniform3f__SWIG_1(L);} } } } if (argc == 5) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Shader_setUniform3f__SWIG_0(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Shader_setUniform3f'\n" - " Possible C/C++ prototypes are:\n" " ofShader::setUniform3f(std::string const &,float,float,float) const\n" - " ofShader::setUniform3f(std::string const &,ofVec3f const &) const\n"); lua_error(L);return 0; } -static int _wrap_Shader_setUniform4f__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; ofVec4f *arg3 = 0 ; std::string temp2 ; SWIG_check_num_args("ofShader::setUniform4f",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniform4f",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniform4f",2,"std::string const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofShader::setUniform4f",3,"ofVec4f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniform4f",1,SWIGTYPE_p_ofShader); } temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec4f,0))){ - SWIG_fail_ptr("Shader_setUniform4f",3,SWIGTYPE_p_ofVec4f); } - ((ofShader const *)arg1)->setUniform4f((std::string const &)*arg2,(ofVec4f const &)*arg3); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniform4f__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; ofFloatColor *arg3 = 0 ; std::string temp2 ; SWIG_check_num_args("ofShader::setUniform4f",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniform4f",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniform4f",2,"std::string const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofShader::setUniform4f",3,"ofFloatColor const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniform4f",1,SWIGTYPE_p_ofShader); } temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("Shader_setUniform4f",3,SWIGTYPE_p_ofColor_T_float_t); } - ((ofShader const *)arg1)->setUniform4f((std::string const &)*arg2,(ofFloatColor const &)*arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniform4f(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Shader_setUniform4f__SWIG_1(L);} } } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Shader_setUniform4f__SWIG_2(L);} } } } if (argc == 6) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { return _wrap_Shader_setUniform4f__SWIG_0(L);} } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Shader_setUniform4f'\n" - " Possible C/C++ prototypes are:\n" " ofShader::setUniform4f(std::string const &,float,float,float,float) const\n" - " ofShader::setUniform4f(std::string const &,ofVec4f const &) const\n" - " ofShader::setUniform4f(std::string const &,ofFloatColor const &) const\n"); lua_error(L);return 0; } -static int _wrap_Shader_setUniform1iv__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; int *arg3 = (int *) 0 ; int arg4 ; std::string temp2 ; - SWIG_check_num_args("ofShader::setUniform1iv",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniform1iv",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniform1iv",2,"std::string const &"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofShader::setUniform1iv",3,"int const *"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofShader::setUniform1iv",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniform1iv",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_int,0))){ SWIG_fail_ptr("Shader_setUniform1iv",3,SWIGTYPE_p_int); } - arg4 = (int)lua_tonumber(L, 4); ((ofShader const *)arg1)->setUniform1iv((std::string const &)*arg2,(int const *)arg3,arg4); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniform1iv__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; int *arg3 = (int *) 0 ; std::string temp2 ; SWIG_check_num_args("ofShader::setUniform1iv",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniform1iv",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniform1iv",2,"std::string const &"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofShader::setUniform1iv",3,"int const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniform1iv",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_int,0))){ SWIG_fail_ptr("Shader_setUniform1iv",3,SWIGTYPE_p_int); } - ((ofShader const *)arg1)->setUniform1iv((std::string const &)*arg2,(int const *)arg3); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniform1iv(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_int, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_Shader_setUniform1iv__SWIG_1(L);} } } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_int, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Shader_setUniform1iv__SWIG_0(L);} - } } } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Shader_setUniform1iv'\n" - " Possible C/C++ prototypes are:\n" " ofShader::setUniform1iv(std::string const &,int const *,int) const\n" - " ofShader::setUniform1iv(std::string const &,int const *) const\n"); lua_error(L);return 0; } -static int _wrap_Shader_setUniform2iv__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; int *arg3 = (int *) 0 ; int arg4 ; std::string temp2 ; - SWIG_check_num_args("ofShader::setUniform2iv",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniform2iv",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniform2iv",2,"std::string const &"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofShader::setUniform2iv",3,"int const *"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofShader::setUniform2iv",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniform2iv",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_int,0))){ SWIG_fail_ptr("Shader_setUniform2iv",3,SWIGTYPE_p_int); } - arg4 = (int)lua_tonumber(L, 4); ((ofShader const *)arg1)->setUniform2iv((std::string const &)*arg2,(int const *)arg3,arg4); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniform2iv__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; int *arg3 = (int *) 0 ; std::string temp2 ; SWIG_check_num_args("ofShader::setUniform2iv",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniform2iv",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniform2iv",2,"std::string const &"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofShader::setUniform2iv",3,"int const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniform2iv",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_int,0))){ SWIG_fail_ptr("Shader_setUniform2iv",3,SWIGTYPE_p_int); } - ((ofShader const *)arg1)->setUniform2iv((std::string const &)*arg2,(int const *)arg3); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniform2iv(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_int, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_Shader_setUniform2iv__SWIG_1(L);} } } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_int, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Shader_setUniform2iv__SWIG_0(L);} - } } } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Shader_setUniform2iv'\n" - " Possible C/C++ prototypes are:\n" " ofShader::setUniform2iv(std::string const &,int const *,int) const\n" - " ofShader::setUniform2iv(std::string const &,int const *) const\n"); lua_error(L);return 0; } -static int _wrap_Shader_setUniform3iv__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; int *arg3 = (int *) 0 ; int arg4 ; std::string temp2 ; - SWIG_check_num_args("ofShader::setUniform3iv",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniform3iv",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniform3iv",2,"std::string const &"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofShader::setUniform3iv",3,"int const *"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofShader::setUniform3iv",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniform3iv",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_int,0))){ SWIG_fail_ptr("Shader_setUniform3iv",3,SWIGTYPE_p_int); } - arg4 = (int)lua_tonumber(L, 4); ((ofShader const *)arg1)->setUniform3iv((std::string const &)*arg2,(int const *)arg3,arg4); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniform3iv__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; int *arg3 = (int *) 0 ; std::string temp2 ; SWIG_check_num_args("ofShader::setUniform3iv",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniform3iv",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniform3iv",2,"std::string const &"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofShader::setUniform3iv",3,"int const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniform3iv",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_int,0))){ SWIG_fail_ptr("Shader_setUniform3iv",3,SWIGTYPE_p_int); } - ((ofShader const *)arg1)->setUniform3iv((std::string const &)*arg2,(int const *)arg3); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniform3iv(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_int, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_Shader_setUniform3iv__SWIG_1(L);} } } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_int, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Shader_setUniform3iv__SWIG_0(L);} - } } } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Shader_setUniform3iv'\n" - " Possible C/C++ prototypes are:\n" " ofShader::setUniform3iv(std::string const &,int const *,int) const\n" - " ofShader::setUniform3iv(std::string const &,int const *) const\n"); lua_error(L);return 0; } -static int _wrap_Shader_setUniform4iv__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; int *arg3 = (int *) 0 ; int arg4 ; std::string temp2 ; - SWIG_check_num_args("ofShader::setUniform4iv",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniform4iv",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniform4iv",2,"std::string const &"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofShader::setUniform4iv",3,"int const *"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofShader::setUniform4iv",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniform4iv",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_int,0))){ SWIG_fail_ptr("Shader_setUniform4iv",3,SWIGTYPE_p_int); } - arg4 = (int)lua_tonumber(L, 4); ((ofShader const *)arg1)->setUniform4iv((std::string const &)*arg2,(int const *)arg3,arg4); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniform4iv__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; int *arg3 = (int *) 0 ; std::string temp2 ; SWIG_check_num_args("ofShader::setUniform4iv",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniform4iv",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniform4iv",2,"std::string const &"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofShader::setUniform4iv",3,"int const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniform4iv",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_int,0))){ SWIG_fail_ptr("Shader_setUniform4iv",3,SWIGTYPE_p_int); } - ((ofShader const *)arg1)->setUniform4iv((std::string const &)*arg2,(int const *)arg3); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniform4iv(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_int, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_Shader_setUniform4iv__SWIG_1(L);} } } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_int, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Shader_setUniform4iv__SWIG_0(L);} - } } } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Shader_setUniform4iv'\n" - " Possible C/C++ prototypes are:\n" " ofShader::setUniform4iv(std::string const &,int const *,int) const\n" - " ofShader::setUniform4iv(std::string const &,int const *) const\n"); lua_error(L);return 0; } -static int _wrap_Shader_setUniform1fv__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; float *arg3 = (float *) 0 ; int arg4 ; std::string temp2 ; - SWIG_check_num_args("ofShader::setUniform1fv",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniform1fv",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniform1fv",2,"std::string const &"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofShader::setUniform1fv",3,"float const *"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofShader::setUniform1fv",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniform1fv",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Shader_setUniform1fv",3,SWIGTYPE_p_float); } arg4 = (int)lua_tonumber(L, 4); - ((ofShader const *)arg1)->setUniform1fv((std::string const &)*arg2,(float const *)arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniform1fv__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; float *arg3 = (float *) 0 ; std::string temp2 ; SWIG_check_num_args("ofShader::setUniform1fv",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniform1fv",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniform1fv",2,"std::string const &"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofShader::setUniform1fv",3,"float const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniform1fv",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Shader_setUniform1fv",3,SWIGTYPE_p_float); } - ((ofShader const *)arg1)->setUniform1fv((std::string const &)*arg2,(float const *)arg3); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniform1fv(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Shader_setUniform1fv__SWIG_1(L);} } } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { - return _wrap_Shader_setUniform1fv__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Shader_setUniform1fv'\n" - " Possible C/C++ prototypes are:\n" " ofShader::setUniform1fv(std::string const &,float const *,int) const\n" - " ofShader::setUniform1fv(std::string const &,float const *) const\n"); lua_error(L);return 0; } -static int _wrap_Shader_setUniform2fv__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; float *arg3 = (float *) 0 ; int arg4 ; std::string temp2 ; - SWIG_check_num_args("ofShader::setUniform2fv",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniform2fv",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniform2fv",2,"std::string const &"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofShader::setUniform2fv",3,"float const *"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofShader::setUniform2fv",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniform2fv",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Shader_setUniform2fv",3,SWIGTYPE_p_float); } arg4 = (int)lua_tonumber(L, 4); - ((ofShader const *)arg1)->setUniform2fv((std::string const &)*arg2,(float const *)arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniform2fv__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; float *arg3 = (float *) 0 ; std::string temp2 ; SWIG_check_num_args("ofShader::setUniform2fv",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniform2fv",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniform2fv",2,"std::string const &"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofShader::setUniform2fv",3,"float const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniform2fv",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Shader_setUniform2fv",3,SWIGTYPE_p_float); } - ((ofShader const *)arg1)->setUniform2fv((std::string const &)*arg2,(float const *)arg3); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniform2fv(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Shader_setUniform2fv__SWIG_1(L);} } } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { - return _wrap_Shader_setUniform2fv__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Shader_setUniform2fv'\n" - " Possible C/C++ prototypes are:\n" " ofShader::setUniform2fv(std::string const &,float const *,int) const\n" - " ofShader::setUniform2fv(std::string const &,float const *) const\n"); lua_error(L);return 0; } -static int _wrap_Shader_setUniform3fv__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; float *arg3 = (float *) 0 ; int arg4 ; std::string temp2 ; - SWIG_check_num_args("ofShader::setUniform3fv",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniform3fv",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniform3fv",2,"std::string const &"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofShader::setUniform3fv",3,"float const *"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofShader::setUniform3fv",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniform3fv",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Shader_setUniform3fv",3,SWIGTYPE_p_float); } arg4 = (int)lua_tonumber(L, 4); - ((ofShader const *)arg1)->setUniform3fv((std::string const &)*arg2,(float const *)arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniform3fv__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; float *arg3 = (float *) 0 ; std::string temp2 ; SWIG_check_num_args("ofShader::setUniform3fv",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniform3fv",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniform3fv",2,"std::string const &"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofShader::setUniform3fv",3,"float const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniform3fv",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Shader_setUniform3fv",3,SWIGTYPE_p_float); } - ((ofShader const *)arg1)->setUniform3fv((std::string const &)*arg2,(float const *)arg3); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniform3fv(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Shader_setUniform3fv__SWIG_1(L);} } } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { - return _wrap_Shader_setUniform3fv__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Shader_setUniform3fv'\n" - " Possible C/C++ prototypes are:\n" " ofShader::setUniform3fv(std::string const &,float const *,int) const\n" - " ofShader::setUniform3fv(std::string const &,float const *) const\n"); lua_error(L);return 0; } -static int _wrap_Shader_setUniform4fv__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; float *arg3 = (float *) 0 ; int arg4 ; std::string temp2 ; - SWIG_check_num_args("ofShader::setUniform4fv",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniform4fv",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniform4fv",2,"std::string const &"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofShader::setUniform4fv",3,"float const *"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofShader::setUniform4fv",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniform4fv",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Shader_setUniform4fv",3,SWIGTYPE_p_float); } arg4 = (int)lua_tonumber(L, 4); - ((ofShader const *)arg1)->setUniform4fv((std::string const &)*arg2,(float const *)arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniform4fv__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; float *arg3 = (float *) 0 ; std::string temp2 ; SWIG_check_num_args("ofShader::setUniform4fv",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniform4fv",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniform4fv",2,"std::string const &"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofShader::setUniform4fv",3,"float const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniform4fv",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Shader_setUniform4fv",3,SWIGTYPE_p_float); } - ((ofShader const *)arg1)->setUniform4fv((std::string const &)*arg2,(float const *)arg3); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniform4fv(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Shader_setUniform4fv__SWIG_1(L);} } } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { - return _wrap_Shader_setUniform4fv__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Shader_setUniform4fv'\n" - " Possible C/C++ prototypes are:\n" " ofShader::setUniform4fv(std::string const &,float const *,int) const\n" - " ofShader::setUniform4fv(std::string const &,float const *) const\n"); lua_error(L);return 0; } -static int _wrap_Shader_setUniforms(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - ofParameterGroup *arg2 = 0 ; SWIG_check_num_args("ofShader::setUniforms",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniforms",1,"ofShader const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofShader::setUniforms",2,"ofParameterGroup const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniforms",1,SWIGTYPE_p_ofShader); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofParameterGroup,0))){ - SWIG_fail_ptr("Shader_setUniforms",2,SWIGTYPE_p_ofParameterGroup); } - ((ofShader const *)arg1)->setUniforms((ofParameterGroup const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Shader_setUniformMatrix3f__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; ofMatrix3x3 *arg3 = 0 ; int arg4 ; std::string temp2 ; - SWIG_check_num_args("ofShader::setUniformMatrix3f",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniformMatrix3f",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniformMatrix3f",2,"std::string const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofShader::setUniformMatrix3f",3,"ofMatrix3x3 const &"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofShader::setUniformMatrix3f",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniformMatrix3f",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Shader_setUniformMatrix3f",3,SWIGTYPE_p_ofMatrix3x3); } arg4 = (int)lua_tonumber(L, 4); - ((ofShader const *)arg1)->setUniformMatrix3f((std::string const &)*arg2,(ofMatrix3x3 const &)*arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniformMatrix3f__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; ofMatrix3x3 *arg3 = 0 ; std::string temp2 ; SWIG_check_num_args("ofShader::setUniformMatrix3f",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniformMatrix3f",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniformMatrix3f",2,"std::string const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofShader::setUniformMatrix3f",3,"ofMatrix3x3 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniformMatrix3f",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Shader_setUniformMatrix3f",3,SWIGTYPE_p_ofMatrix3x3); } - ((ofShader const *)arg1)->setUniformMatrix3f((std::string const &)*arg2,(ofMatrix3x3 const &)*arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniformMatrix3f(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofMatrix3x3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Shader_setUniformMatrix3f__SWIG_1(L);} } } } if (argc == 4) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofMatrix3x3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { - return _wrap_Shader_setUniformMatrix3f__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Shader_setUniformMatrix3f'\n" - " Possible C/C++ prototypes are:\n" " ofShader::setUniformMatrix3f(std::string const &,ofMatrix3x3 const &,int) const\n" - " ofShader::setUniformMatrix3f(std::string const &,ofMatrix3x3 const &) const\n"); lua_error(L);return 0; } -static int _wrap_Shader_setUniformMatrix4f__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; ofMatrix4x4 *arg3 = 0 ; int arg4 ; std::string temp2 ; - SWIG_check_num_args("ofShader::setUniformMatrix4f",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniformMatrix4f",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniformMatrix4f",2,"std::string const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofShader::setUniformMatrix4f",3,"ofMatrix4x4 const &"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofShader::setUniformMatrix4f",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniformMatrix4f",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Shader_setUniformMatrix4f",3,SWIGTYPE_p_ofMatrix4x4); } arg4 = (int)lua_tonumber(L, 4); - ((ofShader const *)arg1)->setUniformMatrix4f((std::string const &)*arg2,(ofMatrix4x4 const &)*arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniformMatrix4f__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; ofMatrix4x4 *arg3 = 0 ; std::string temp2 ; SWIG_check_num_args("ofShader::setUniformMatrix4f",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniformMatrix4f",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniformMatrix4f",2,"std::string const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofShader::setUniformMatrix4f",3,"ofMatrix4x4 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniformMatrix4f",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Shader_setUniformMatrix4f",3,SWIGTYPE_p_ofMatrix4x4); } - ((ofShader const *)arg1)->setUniformMatrix4f((std::string const &)*arg2,(ofMatrix4x4 const &)*arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniformMatrix4f(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Shader_setUniformMatrix4f__SWIG_1(L);} } } } if (argc == 4) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { - return _wrap_Shader_setUniformMatrix4f__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Shader_setUniformMatrix4f'\n" - " Possible C/C++ prototypes are:\n" " ofShader::setUniformMatrix4f(std::string const &,ofMatrix4x4 const &,int) const\n" - " ofShader::setUniformMatrix4f(std::string const &,ofMatrix4x4 const &) const\n"); lua_error(L);return 0; } -static int _wrap_Shader_getUniformLocation(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; std::string temp2 ; GLint result; SWIG_check_num_args("ofShader::getUniformLocation",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::getUniformLocation",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::getUniformLocation",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_getUniformLocation",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = (GLint)((ofShader const *)arg1)->getUniformLocation((std::string const &)*arg2); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_getAttributeLocation(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; std::string temp2 ; GLint result; SWIG_check_num_args("ofShader::getAttributeLocation",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::getAttributeLocation",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::getAttributeLocation",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_getAttributeLocation",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = (GLint)((ofShader const *)arg1)->getAttributeLocation((std::string const &)*arg2); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setAttribute1s(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; GLint arg2 ; - short arg3 ; SWIG_check_num_args("ofShader::setAttribute1s",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setAttribute1s",1,"ofShader const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofShader::setAttribute1s",2,"GLint"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofShader::setAttribute1s",3,"short"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setAttribute1s",1,SWIGTYPE_p_ofShader); } arg2 = (GLint)lua_tonumber(L, 2); - arg3 = (short)lua_tonumber(L, 3); ((ofShader const *)arg1)->setAttribute1s(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setAttribute2s(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; GLint arg2 ; - short arg3 ; short arg4 ; SWIG_check_num_args("ofShader::setAttribute2s",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setAttribute2s",1,"ofShader const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofShader::setAttribute2s",2,"GLint"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofShader::setAttribute2s",3,"short"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofShader::setAttribute2s",4,"short"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setAttribute2s",1,SWIGTYPE_p_ofShader); } arg2 = (GLint)lua_tonumber(L, 2); - arg3 = (short)lua_tonumber(L, 3); arg4 = (short)lua_tonumber(L, 4); ((ofShader const *)arg1)->setAttribute2s(arg2,arg3,arg4); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setAttribute3s(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; GLint arg2 ; - short arg3 ; short arg4 ; short arg5 ; SWIG_check_num_args("ofShader::setAttribute3s",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setAttribute3s",1,"ofShader const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofShader::setAttribute3s",2,"GLint"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofShader::setAttribute3s",3,"short"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofShader::setAttribute3s",4,"short"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofShader::setAttribute3s",5,"short"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setAttribute3s",1,SWIGTYPE_p_ofShader); } arg2 = (GLint)lua_tonumber(L, 2); - arg3 = (short)lua_tonumber(L, 3); arg4 = (short)lua_tonumber(L, 4); arg5 = (short)lua_tonumber(L, 5); - ((ofShader const *)arg1)->setAttribute3s(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Shader_setAttribute4s(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; GLint arg2 ; - short arg3 ; short arg4 ; short arg5 ; short arg6 ; SWIG_check_num_args("ofShader::setAttribute4s",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setAttribute4s",1,"ofShader const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofShader::setAttribute4s",2,"GLint"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofShader::setAttribute4s",3,"short"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofShader::setAttribute4s",4,"short"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofShader::setAttribute4s",5,"short"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofShader::setAttribute4s",6,"short"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setAttribute4s",1,SWIGTYPE_p_ofShader); } arg2 = (GLint)lua_tonumber(L, 2); - arg3 = (short)lua_tonumber(L, 3); arg4 = (short)lua_tonumber(L, 4); arg5 = (short)lua_tonumber(L, 5); - arg6 = (short)lua_tonumber(L, 6); ((ofShader const *)arg1)->setAttribute4s(arg2,arg3,arg4,arg5,arg6); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setAttribute1f(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; GLint arg2 ; - float arg3 ; SWIG_check_num_args("ofShader::setAttribute1f",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setAttribute1f",1,"ofShader const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofShader::setAttribute1f",2,"GLint"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofShader::setAttribute1f",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setAttribute1f",1,SWIGTYPE_p_ofShader); } arg2 = (GLint)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); ((ofShader const *)arg1)->setAttribute1f(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setAttribute2f(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; GLint arg2 ; - float arg3 ; float arg4 ; SWIG_check_num_args("ofShader::setAttribute2f",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setAttribute2f",1,"ofShader const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofShader::setAttribute2f",2,"GLint"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofShader::setAttribute2f",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofShader::setAttribute2f",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setAttribute2f",1,SWIGTYPE_p_ofShader); } arg2 = (GLint)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); ((ofShader const *)arg1)->setAttribute2f(arg2,arg3,arg4); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setAttribute3f(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; GLint arg2 ; - float arg3 ; float arg4 ; float arg5 ; SWIG_check_num_args("ofShader::setAttribute3f",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setAttribute3f",1,"ofShader const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofShader::setAttribute3f",2,"GLint"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofShader::setAttribute3f",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofShader::setAttribute3f",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofShader::setAttribute3f",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setAttribute3f",1,SWIGTYPE_p_ofShader); } arg2 = (GLint)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - ((ofShader const *)arg1)->setAttribute3f(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Shader_setAttribute4f(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; GLint arg2 ; - float arg3 ; float arg4 ; float arg5 ; float arg6 ; SWIG_check_num_args("ofShader::setAttribute4f",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setAttribute4f",1,"ofShader const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofShader::setAttribute4f",2,"GLint"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofShader::setAttribute4f",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofShader::setAttribute4f",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofShader::setAttribute4f",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofShader::setAttribute4f",6,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setAttribute4f",1,SWIGTYPE_p_ofShader); } arg2 = (GLint)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); ((ofShader const *)arg1)->setAttribute4f(arg2,arg3,arg4,arg5,arg6); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setAttribute1d(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; GLint arg2 ; - double arg3 ; SWIG_check_num_args("ofShader::setAttribute1d",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setAttribute1d",1,"ofShader const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofShader::setAttribute1d",2,"GLint"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofShader::setAttribute1d",3,"double"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setAttribute1d",1,SWIGTYPE_p_ofShader); } arg2 = (GLint)lua_tonumber(L, 2); - arg3 = (double)lua_tonumber(L, 3); ((ofShader const *)arg1)->setAttribute1d(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setAttribute2d(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; GLint arg2 ; - double arg3 ; double arg4 ; SWIG_check_num_args("ofShader::setAttribute2d",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setAttribute2d",1,"ofShader const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofShader::setAttribute2d",2,"GLint"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofShader::setAttribute2d",3,"double"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofShader::setAttribute2d",4,"double"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setAttribute2d",1,SWIGTYPE_p_ofShader); } arg2 = (GLint)lua_tonumber(L, 2); - arg3 = (double)lua_tonumber(L, 3); arg4 = (double)lua_tonumber(L, 4); - ((ofShader const *)arg1)->setAttribute2d(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Shader_setAttribute3d(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; GLint arg2 ; - double arg3 ; double arg4 ; double arg5 ; SWIG_check_num_args("ofShader::setAttribute3d",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setAttribute3d",1,"ofShader const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofShader::setAttribute3d",2,"GLint"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofShader::setAttribute3d",3,"double"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofShader::setAttribute3d",4,"double"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofShader::setAttribute3d",5,"double"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setAttribute3d",1,SWIGTYPE_p_ofShader); } arg2 = (GLint)lua_tonumber(L, 2); - arg3 = (double)lua_tonumber(L, 3); arg4 = (double)lua_tonumber(L, 4); arg5 = (double)lua_tonumber(L, 5); - ((ofShader const *)arg1)->setAttribute3d(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Shader_setAttribute4d(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; GLint arg2 ; - double arg3 ; double arg4 ; double arg5 ; double arg6 ; SWIG_check_num_args("ofShader::setAttribute4d",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setAttribute4d",1,"ofShader const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofShader::setAttribute4d",2,"GLint"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofShader::setAttribute4d",3,"double"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofShader::setAttribute4d",4,"double"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofShader::setAttribute4d",5,"double"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofShader::setAttribute4d",6,"double"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setAttribute4d",1,SWIGTYPE_p_ofShader); } arg2 = (GLint)lua_tonumber(L, 2); - arg3 = (double)lua_tonumber(L, 3); arg4 = (double)lua_tonumber(L, 4); arg5 = (double)lua_tonumber(L, 5); - arg6 = (double)lua_tonumber(L, 6); ((ofShader const *)arg1)->setAttribute4d(arg2,arg3,arg4,arg5,arg6); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setAttribute1fv__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; float *arg3 = (float *) 0 ; GLsizei arg4 ; std::string temp2 ; GLsizei *argp4 ; - SWIG_check_num_args("ofShader::setAttribute1fv",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setAttribute1fv",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setAttribute1fv",2,"std::string const &"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofShader::setAttribute1fv",3,"float const *"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofShader::setAttribute1fv",4,"GLsizei"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setAttribute1fv",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Shader_setAttribute1fv",3,SWIGTYPE_p_float); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&argp4,SWIGTYPE_p_GLsizei,0))){ - SWIG_fail_ptr("Shader_setAttribute1fv",4,SWIGTYPE_p_GLsizei); } arg4 = *argp4; - ((ofShader const *)arg1)->setAttribute1fv((std::string const &)*arg2,(float const *)arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setAttribute1fv__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; float *arg3 = (float *) 0 ; std::string temp2 ; SWIG_check_num_args("ofShader::setAttribute1fv",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setAttribute1fv",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setAttribute1fv",2,"std::string const &"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofShader::setAttribute1fv",3,"float const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setAttribute1fv",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Shader_setAttribute1fv",3,SWIGTYPE_p_float); } - ((ofShader const *)arg1)->setAttribute1fv((std::string const &)*arg2,(float const *)arg3); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setAttribute1fv(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Shader_setAttribute1fv__SWIG_1(L);} } } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_GLsizei, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Shader_setAttribute1fv__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Shader_setAttribute1fv'\n" - " Possible C/C++ prototypes are:\n" " ofShader::setAttribute1fv(std::string const &,float const *,GLsizei) const\n" - " ofShader::setAttribute1fv(std::string const &,float const *) const\n"); lua_error(L);return 0; } -static int _wrap_Shader_setAttribute2fv__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; float *arg3 = (float *) 0 ; GLsizei arg4 ; std::string temp2 ; GLsizei *argp4 ; - SWIG_check_num_args("ofShader::setAttribute2fv",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setAttribute2fv",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setAttribute2fv",2,"std::string const &"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofShader::setAttribute2fv",3,"float const *"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofShader::setAttribute2fv",4,"GLsizei"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setAttribute2fv",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Shader_setAttribute2fv",3,SWIGTYPE_p_float); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&argp4,SWIGTYPE_p_GLsizei,0))){ - SWIG_fail_ptr("Shader_setAttribute2fv",4,SWIGTYPE_p_GLsizei); } arg4 = *argp4; - ((ofShader const *)arg1)->setAttribute2fv((std::string const &)*arg2,(float const *)arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setAttribute2fv__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; float *arg3 = (float *) 0 ; std::string temp2 ; SWIG_check_num_args("ofShader::setAttribute2fv",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setAttribute2fv",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setAttribute2fv",2,"std::string const &"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofShader::setAttribute2fv",3,"float const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setAttribute2fv",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Shader_setAttribute2fv",3,SWIGTYPE_p_float); } - ((ofShader const *)arg1)->setAttribute2fv((std::string const &)*arg2,(float const *)arg3); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setAttribute2fv(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Shader_setAttribute2fv__SWIG_1(L);} } } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_GLsizei, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Shader_setAttribute2fv__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Shader_setAttribute2fv'\n" - " Possible C/C++ prototypes are:\n" " ofShader::setAttribute2fv(std::string const &,float const *,GLsizei) const\n" - " ofShader::setAttribute2fv(std::string const &,float const *) const\n"); lua_error(L);return 0; } -static int _wrap_Shader_setAttribute3fv__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; float *arg3 = (float *) 0 ; GLsizei arg4 ; std::string temp2 ; GLsizei *argp4 ; - SWIG_check_num_args("ofShader::setAttribute3fv",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setAttribute3fv",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setAttribute3fv",2,"std::string const &"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofShader::setAttribute3fv",3,"float const *"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofShader::setAttribute3fv",4,"GLsizei"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setAttribute3fv",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Shader_setAttribute3fv",3,SWIGTYPE_p_float); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&argp4,SWIGTYPE_p_GLsizei,0))){ - SWIG_fail_ptr("Shader_setAttribute3fv",4,SWIGTYPE_p_GLsizei); } arg4 = *argp4; - ((ofShader const *)arg1)->setAttribute3fv((std::string const &)*arg2,(float const *)arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setAttribute3fv__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; float *arg3 = (float *) 0 ; std::string temp2 ; SWIG_check_num_args("ofShader::setAttribute3fv",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setAttribute3fv",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setAttribute3fv",2,"std::string const &"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofShader::setAttribute3fv",3,"float const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setAttribute3fv",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Shader_setAttribute3fv",3,SWIGTYPE_p_float); } - ((ofShader const *)arg1)->setAttribute3fv((std::string const &)*arg2,(float const *)arg3); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setAttribute3fv(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Shader_setAttribute3fv__SWIG_1(L);} } } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_GLsizei, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Shader_setAttribute3fv__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Shader_setAttribute3fv'\n" - " Possible C/C++ prototypes are:\n" " ofShader::setAttribute3fv(std::string const &,float const *,GLsizei) const\n" - " ofShader::setAttribute3fv(std::string const &,float const *) const\n"); lua_error(L);return 0; } -static int _wrap_Shader_setAttribute4fv__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; float *arg3 = (float *) 0 ; GLsizei arg4 ; std::string temp2 ; GLsizei *argp4 ; - SWIG_check_num_args("ofShader::setAttribute4fv",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setAttribute4fv",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setAttribute4fv",2,"std::string const &"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofShader::setAttribute4fv",3,"float const *"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofShader::setAttribute4fv",4,"GLsizei"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setAttribute4fv",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Shader_setAttribute4fv",3,SWIGTYPE_p_float); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&argp4,SWIGTYPE_p_GLsizei,0))){ - SWIG_fail_ptr("Shader_setAttribute4fv",4,SWIGTYPE_p_GLsizei); } arg4 = *argp4; - ((ofShader const *)arg1)->setAttribute4fv((std::string const &)*arg2,(float const *)arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setAttribute4fv__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; float *arg3 = (float *) 0 ; std::string temp2 ; SWIG_check_num_args("ofShader::setAttribute4fv",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setAttribute4fv",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setAttribute4fv",2,"std::string const &"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofShader::setAttribute4fv",3,"float const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setAttribute4fv",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Shader_setAttribute4fv",3,SWIGTYPE_p_float); } - ((ofShader const *)arg1)->setAttribute4fv((std::string const &)*arg2,(float const *)arg3); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setAttribute4fv(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Shader_setAttribute4fv__SWIG_1(L);} } } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_GLsizei, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Shader_setAttribute4fv__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Shader_setAttribute4fv'\n" - " Possible C/C++ prototypes are:\n" " ofShader::setAttribute4fv(std::string const &,float const *,GLsizei) const\n" - " ofShader::setAttribute4fv(std::string const &,float const *) const\n"); lua_error(L);return 0; } -static int _wrap_Shader_bindAttribute(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; GLuint arg2 ; - std::string *arg3 = 0 ; std::string temp3 ; SWIG_check_num_args("ofShader::bindAttribute",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::bindAttribute",1,"ofShader const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofShader::bindAttribute",2,"GLuint"); - if(!lua_isstring(L,3)) SWIG_fail_arg("ofShader::bindAttribute",3,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_bindAttribute",1,SWIGTYPE_p_ofShader); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (GLuint)lua_tonumber(L, 2); - temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3; - ((ofShader const *)arg1)->bindAttribute(arg2,(std::string const &)*arg3); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Shader_printActiveUniforms(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - SWIG_check_num_args("ofShader::printActiveUniforms",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::printActiveUniforms",1,"ofShader const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_printActiveUniforms",1,SWIGTYPE_p_ofShader); } ((ofShader const *)arg1)->printActiveUniforms(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_printActiveAttributes(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - SWIG_check_num_args("ofShader::printActiveAttributes",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::printActiveAttributes",1,"ofShader const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_printActiveAttributes",1,SWIGTYPE_p_ofShader); } ((ofShader const *)arg1)->printActiveAttributes(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setupShaderFromSource__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - GLenum arg2 ; std::string arg3 ; std::string arg4 ; bool result; SWIG_check_num_args("ofShader::setupShaderFromSource",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setupShaderFromSource",1,"ofShader *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofShader::setupShaderFromSource",2,"GLenum"); - if(!lua_isstring(L,3)) SWIG_fail_arg("ofShader::setupShaderFromSource",3,"std::string"); - if(!lua_isstring(L,4)) SWIG_fail_arg("ofShader::setupShaderFromSource",4,"std::string"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setupShaderFromSource",1,SWIGTYPE_p_ofShader); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (GLenum)lua_tonumber(L, 2); - (&arg3)->assign(lua_tostring(L,3),lua_rawlen(L,3)); (&arg4)->assign(lua_tostring(L,4),lua_rawlen(L,4)); - result = (bool)(arg1)->setupShaderFromSource(arg2,arg3,arg4); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setupShaderFromSource__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - GLenum arg2 ; std::string arg3 ; bool result; SWIG_check_num_args("ofShader::setupShaderFromSource",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setupShaderFromSource",1,"ofShader *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofShader::setupShaderFromSource",2,"GLenum"); - if(!lua_isstring(L,3)) SWIG_fail_arg("ofShader::setupShaderFromSource",3,"std::string"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setupShaderFromSource",1,SWIGTYPE_p_ofShader); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (GLenum)lua_tonumber(L, 2); - (&arg3)->assign(lua_tostring(L,3),lua_rawlen(L,3)); result = (bool)(arg1)->setupShaderFromSource(arg2,arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setupShaderFromSource(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isstring(L,argv[2]); } if (_v) { - return _wrap_Shader_setupShaderFromSource__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isstring(L,argv[2]); } if (_v) { - { _v = lua_isstring(L,argv[3]); } if (_v) { return _wrap_Shader_setupShaderFromSource__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Shader_setupShaderFromSource'\n" - " Possible C/C++ prototypes are:\n" " ofShader::setupShaderFromSource(GLenum,std::string,std::string)\n" - " ofShader::setupShaderFromSource(GLenum,std::string)\n"); lua_error(L);return 0; } -static int _wrap_Shader_setupShaderFromFile(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; GLenum arg2 ; - std::string arg3 ; bool result; SWIG_check_num_args("ofShader::setupShaderFromFile",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setupShaderFromFile",1,"ofShader *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofShader::setupShaderFromFile",2,"GLenum"); - if(!lua_isstring(L,3)) SWIG_fail_arg("ofShader::setupShaderFromFile",3,"std::string"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setupShaderFromFile",1,SWIGTYPE_p_ofShader); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (GLenum)lua_tonumber(L, 2); - (&arg3)->assign(lua_tostring(L,3),lua_rawlen(L,3)); result = (bool)(arg1)->setupShaderFromFile(arg2,arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_linkProgram(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; bool result; - SWIG_check_num_args("ofShader::linkProgram",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::linkProgram",1,"ofShader *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_linkProgram",1,SWIGTYPE_p_ofShader); } result = (bool)(arg1)->linkProgram(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_bindDefaults(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; bool result; - SWIG_check_num_args("ofShader::bindDefaults",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::bindDefaults",1,"ofShader const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_bindDefaults",1,SWIGTYPE_p_ofShader); } result = (bool)((ofShader const *)arg1)->bindDefaults(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_getProgram(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; GLuint result; - SWIG_check_num_args("ofShader::getProgram",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::getProgram",1,"ofShader const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_getProgram",1,SWIGTYPE_p_ofShader); } result = (GLuint)((ofShader const *)arg1)->getProgram(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_getShader(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; GLenum arg2 ; - GLuint result; SWIG_check_num_args("ofShader::getShader",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::getShader",1,"ofShader const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofShader::getShader",2,"GLenum"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_getShader",1,SWIGTYPE_p_ofShader); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (GLenum)lua_tonumber(L, 2); - result = (GLuint)((ofShader const *)arg1)->getShader(arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader___eq(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; ofShader *arg2 = 0 ; - bool result; SWIG_check_num_args("ofShader::operator ==",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::operator ==",1,"ofShader const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofShader::operator ==",2,"ofShader const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader___eq",1,SWIGTYPE_p_ofShader); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader___eq",2,SWIGTYPE_p_ofShader); } - result = (bool)((ofShader const *)arg1)->operator ==((ofShader const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_getShaderSource(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; GLenum arg2 ; - std::string result; SWIG_check_num_args("ofShader::getShaderSource",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::getShaderSource",1,"ofShader const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofShader::getShaderSource",2,"GLenum"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_getShaderSource",1,SWIGTYPE_p_ofShader); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (GLenum)lua_tonumber(L, 2); - result = ((ofShader const *)arg1)->getShaderSource(arg2); lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_Shader(void *obj) { -ofShader *arg1 = (ofShader *) obj; -delete_ofShader(arg1); -} -static int _proxy__wrap_new_Shader(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_Shader); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_Shader_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_Shader_methods[]= { - { "load", _wrap_Shader_load}, - { "setGeometryInputType", _wrap_Shader_setGeometryInputType}, - { "setGeometryOutputType", _wrap_Shader_setGeometryOutputType}, - { "setGeometryOutputCount", _wrap_Shader_setGeometryOutputCount}, - { "getGeometryMaxOutputCount", _wrap_Shader_getGeometryMaxOutputCount}, - { "unload", _wrap_Shader_unload}, - { "isLoaded", _wrap_Shader_isLoaded}, - { "beginShader", _wrap_Shader_beginShader}, - { "endShader", _wrap_Shader_endShader}, - { "setUniformTexture", _wrap_Shader_setUniformTexture}, - { "setUniform1i", _wrap_Shader_setUniform1i}, - { "setUniform2i", _wrap_Shader_setUniform2i}, - { "setUniform3i", _wrap_Shader_setUniform3i}, - { "setUniform4i", _wrap_Shader_setUniform4i}, - { "setUniform1f", _wrap_Shader_setUniform1f}, - { "setUniform2f", _wrap_Shader_setUniform2f}, - { "setUniform3f", _wrap_Shader_setUniform3f}, - { "setUniform4f", _wrap_Shader_setUniform4f}, - { "setUniform1iv", _wrap_Shader_setUniform1iv}, - { "setUniform2iv", _wrap_Shader_setUniform2iv}, - { "setUniform3iv", _wrap_Shader_setUniform3iv}, - { "setUniform4iv", _wrap_Shader_setUniform4iv}, - { "setUniform1fv", _wrap_Shader_setUniform1fv}, - { "setUniform2fv", _wrap_Shader_setUniform2fv}, - { "setUniform3fv", _wrap_Shader_setUniform3fv}, - { "setUniform4fv", _wrap_Shader_setUniform4fv}, - { "setUniforms", _wrap_Shader_setUniforms}, - { "setUniformMatrix3f", _wrap_Shader_setUniformMatrix3f}, - { "setUniformMatrix4f", _wrap_Shader_setUniformMatrix4f}, - { "getUniformLocation", _wrap_Shader_getUniformLocation}, - { "getAttributeLocation", _wrap_Shader_getAttributeLocation}, - { "setAttribute1s", _wrap_Shader_setAttribute1s}, - { "setAttribute2s", _wrap_Shader_setAttribute2s}, - { "setAttribute3s", _wrap_Shader_setAttribute3s}, - { "setAttribute4s", _wrap_Shader_setAttribute4s}, - { "setAttribute1f", _wrap_Shader_setAttribute1f}, - { "setAttribute2f", _wrap_Shader_setAttribute2f}, - { "setAttribute3f", _wrap_Shader_setAttribute3f}, - { "setAttribute4f", _wrap_Shader_setAttribute4f}, - { "setAttribute1d", _wrap_Shader_setAttribute1d}, - { "setAttribute2d", _wrap_Shader_setAttribute2d}, - { "setAttribute3d", _wrap_Shader_setAttribute3d}, - { "setAttribute4d", _wrap_Shader_setAttribute4d}, - { "setAttribute1fv", _wrap_Shader_setAttribute1fv}, - { "setAttribute2fv", _wrap_Shader_setAttribute2fv}, - { "setAttribute3fv", _wrap_Shader_setAttribute3fv}, - { "setAttribute4fv", _wrap_Shader_setAttribute4fv}, - { "bindAttribute", _wrap_Shader_bindAttribute}, - { "printActiveUniforms", _wrap_Shader_printActiveUniforms}, - { "printActiveAttributes", _wrap_Shader_printActiveAttributes}, - { "setupShaderFromSource", _wrap_Shader_setupShaderFromSource}, - { "setupShaderFromFile", _wrap_Shader_setupShaderFromFile}, - { "linkProgram", _wrap_Shader_linkProgram}, - { "bindDefaults", _wrap_Shader_bindDefaults}, - { "getProgram", _wrap_Shader_getProgram}, - { "getShader", _wrap_Shader_getShader}, - { "__eq", _wrap_Shader___eq}, - { "getShaderSource", _wrap_Shader_getShaderSource}, - {0,0} -}; -static swig_lua_method swig_Shader_meta[] = { - { "__eq", _wrap_Shader___eq}, - {0,0} -}; - -static swig_lua_attribute swig_Shader_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_Shader_Sf_SwigStatic_constants[]= { - {SWIG_LUA_CONSTTAB_INT("POSITION_ATTRIBUTE", ofShader::POSITION_ATTRIBUTE)}, - {SWIG_LUA_CONSTTAB_INT("COLOR_ATTRIBUTE", ofShader::COLOR_ATTRIBUTE)}, - {SWIG_LUA_CONSTTAB_INT("NORMAL_ATTRIBUTE", ofShader::NORMAL_ATTRIBUTE)}, - {SWIG_LUA_CONSTTAB_INT("TEXCOORD_ATTRIBUTE", ofShader::TEXCOORD_ATTRIBUTE)}, - {SWIG_LUA_CONSTTAB_INT("INDEX_ATTRIBUTE", ofShader::INDEX_ATTRIBUTE)}, - {0,0,0,0,0,0} -}; -static swig_lua_method swig_Shader_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_Shader_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_Shader_Sf_SwigStatic = { - "Shader", - swig_Shader_Sf_SwigStatic_methods, - swig_Shader_Sf_SwigStatic_attributes, - swig_Shader_Sf_SwigStatic_constants, - swig_Shader_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_Shader_bases[] = {0}; -static const char *swig_Shader_base_names[] = {0}; -static swig_lua_class _wrap_class_Shader = { "Shader", "Shader", &SWIGTYPE_p_ofShader,_proxy__wrap_new_Shader, swig_delete_Shader, swig_Shader_methods, swig_Shader_attributes, &swig_Shader_Sf_SwigStatic, swig_Shader_meta, swig_Shader_bases, swig_Shader_base_names }; - -static int _wrap_new_Vbo__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVbo *result = 0 ; SWIG_check_num_args("ofVbo::ofVbo",0,0) - result = (ofVbo *)new ofVbo(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVbo,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_new_Vbo__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = 0 ; ofVbo *result = 0 ; - SWIG_check_num_args("ofVbo::ofVbo",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofVbo::ofVbo",1,"ofVbo const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ SWIG_fail_ptr("new_Vbo",1,SWIGTYPE_p_ofVbo); } - result = (ofVbo *)new ofVbo((ofVbo const &)*arg1); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVbo,1); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_new_Vbo(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_Vbo__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_new_Vbo__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_Vbo'\n" " Possible C/C++ prototypes are:\n" - " ofVbo::ofVbo()\n" " ofVbo::ofVbo(ofVbo const &)\n"); lua_error(L);return 0; } -static int _wrap_Vbo_setMesh__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; ofMesh *arg2 = 0 ; int arg3 ; - SWIG_check_num_args("ofVbo::setMesh",3,3) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::setMesh",1,"ofVbo *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVbo::setMesh",2,"ofMesh const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::setMesh",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ SWIG_fail_ptr("Vbo_setMesh",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Vbo_setMesh",2,SWIGTYPE_p_ofMesh); } - arg3 = (int)lua_tonumber(L, 3); (arg1)->setMesh((ofMesh const &)*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_setMesh__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; ofMesh *arg2 = 0 ; int arg3 ; - bool arg4 ; bool arg5 ; bool arg6 ; SWIG_check_num_args("ofVbo::setMesh",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::setMesh",1,"ofVbo *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVbo::setMesh",2,"ofMesh const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::setMesh",3,"int"); - if(!lua_isboolean(L,4)) SWIG_fail_arg("ofVbo::setMesh",4,"bool"); - if(!lua_isboolean(L,5)) SWIG_fail_arg("ofVbo::setMesh",5,"bool"); - if(!lua_isboolean(L,6)) SWIG_fail_arg("ofVbo::setMesh",6,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ SWIG_fail_ptr("Vbo_setMesh",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Vbo_setMesh",2,SWIGTYPE_p_ofMesh); } - arg3 = (int)lua_tonumber(L, 3); arg4 = (lua_toboolean(L, 4)!=0); arg5 = (lua_toboolean(L, 5)!=0); - arg6 = (lua_toboolean(L, 6)!=0); (arg1)->setMesh((ofMesh const &)*arg2,arg3,arg4,arg5,arg6); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_setMesh(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Vbo_setMesh__SWIG_0(L);} } } - } if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isboolean(L,argv[3]); } - if (_v) { { _v = lua_isboolean(L,argv[4]); } if (_v) { { _v = lua_isboolean(L,argv[5]); } if (_v) { - return _wrap_Vbo_setMesh__SWIG_1(L);} } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_setMesh'\n" " Possible C/C++ prototypes are:\n" - " ofVbo::setMesh(ofMesh const &,int)\n" " ofVbo::setMesh(ofMesh const &,int,bool,bool,bool)\n"); lua_error(L);return 0; } -static int _wrap_Vbo_setVertexData__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - ofVec3f *arg2 = (ofVec3f *) 0 ; int arg3 ; int arg4 ; SWIG_check_num_args("ofVbo::setVertexData",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::setVertexData",1,"ofVbo *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofVbo::setVertexData",2,"ofVec3f const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::setVertexData",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVbo::setVertexData",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_setVertexData",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vbo_setVertexData",2,SWIGTYPE_p_ofVec3f); } arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - (arg1)->setVertexData((ofVec3f const *)arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vbo_setVertexData__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - ofVec2f *arg2 = (ofVec2f *) 0 ; int arg3 ; int arg4 ; SWIG_check_num_args("ofVbo::setVertexData",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::setVertexData",1,"ofVbo *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofVbo::setVertexData",2,"ofVec2f const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::setVertexData",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVbo::setVertexData",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_setVertexData",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vbo_setVertexData",2,SWIGTYPE_p_ofVec2f); } arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - (arg1)->setVertexData((ofVec2f const *)arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vbo_setColorData__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - ofFloatColor *arg2 = (ofFloatColor *) 0 ; int arg3 ; int arg4 ; SWIG_check_num_args("ofVbo::setColorData",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::setColorData",1,"ofVbo *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofVbo::setColorData",2,"ofFloatColor const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::setColorData",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVbo::setColorData",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ SWIG_fail_ptr("Vbo_setColorData",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("Vbo_setColorData",2,SWIGTYPE_p_ofColor_T_float_t); } arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); (arg1)->setColorData((ofFloatColor const *)arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_setNormalData__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - ofVec3f *arg2 = (ofVec3f *) 0 ; int arg3 ; int arg4 ; SWIG_check_num_args("ofVbo::setNormalData",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::setNormalData",1,"ofVbo *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofVbo::setNormalData",2,"ofVec3f const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::setNormalData",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVbo::setNormalData",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_setNormalData",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vbo_setNormalData",2,SWIGTYPE_p_ofVec3f); } arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - (arg1)->setNormalData((ofVec3f const *)arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vbo_setTexCoordData__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - ofVec2f *arg2 = (ofVec2f *) 0 ; int arg3 ; int arg4 ; SWIG_check_num_args("ofVbo::setTexCoordData",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::setTexCoordData",1,"ofVbo *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofVbo::setTexCoordData",2,"ofVec2f const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::setTexCoordData",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVbo::setTexCoordData",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_setTexCoordData",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vbo_setTexCoordData",2,SWIGTYPE_p_ofVec2f); } arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); (arg1)->setTexCoordData((ofVec2f const *)arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_setIndexData(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - ofIndexType *arg2 = (ofIndexType *) 0 ; int arg3 ; int arg4 ; SWIG_check_num_args("ofVbo::setIndexData",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::setIndexData",1,"ofVbo *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofVbo::setIndexData",2,"ofIndexType const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::setIndexData",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVbo::setIndexData",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ SWIG_fail_ptr("Vbo_setIndexData",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_unsigned_int,0))){ - SWIG_fail_ptr("Vbo_setIndexData",2,SWIGTYPE_p_unsigned_int); } arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); (arg1)->setIndexData((ofIndexType const *)arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_setVertexData__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - float *arg2 = (float *) 0 ; int arg3 ; int arg4 ; int arg5 ; int arg6 ; SWIG_check_num_args("ofVbo::setVertexData",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::setVertexData",1,"ofVbo *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofVbo::setVertexData",2,"float const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::setVertexData",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVbo::setVertexData",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofVbo::setVertexData",5,"int"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofVbo::setVertexData",6,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_setVertexData",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Vbo_setVertexData",2,SWIGTYPE_p_float); } arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - arg5 = (int)lua_tonumber(L, 5); arg6 = (int)lua_tonumber(L, 6); - (arg1)->setVertexData((float const *)arg2,arg3,arg4,arg5,arg6); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vbo_setVertexData__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - float *arg2 = (float *) 0 ; int arg3 ; int arg4 ; int arg5 ; SWIG_check_num_args("ofVbo::setVertexData",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::setVertexData",1,"ofVbo *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofVbo::setVertexData",2,"float const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::setVertexData",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVbo::setVertexData",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofVbo::setVertexData",5,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_setVertexData",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Vbo_setVertexData",2,SWIGTYPE_p_float); } arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - arg5 = (int)lua_tonumber(L, 5); (arg1)->setVertexData((float const *)arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_setVertexData(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); - if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Vbo_setVertexData__SWIG_0(L);} } } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Vbo_setVertexData__SWIG_1(L);} } } } } if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_Vbo_setVertexData__SWIG_3(L);} } } } } } - if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { - return _wrap_Vbo_setVertexData__SWIG_2(L);} } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_setVertexData'\n" " Possible C/C++ prototypes are:\n" - " ofVbo::setVertexData(ofVec3f const *,int,int)\n" " ofVbo::setVertexData(ofVec2f const *,int,int)\n" - " ofVbo::setVertexData(float const *,int,int,int,int)\n" " ofVbo::setVertexData(float const *,int,int,int)\n"); - lua_error(L);return 0; } -static int _wrap_Vbo_setColorData__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - float *arg2 = (float *) 0 ; int arg3 ; int arg4 ; int arg5 ; SWIG_check_num_args("ofVbo::setColorData",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::setColorData",1,"ofVbo *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofVbo::setColorData",2,"float const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::setColorData",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVbo::setColorData",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofVbo::setColorData",5,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ SWIG_fail_ptr("Vbo_setColorData",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Vbo_setColorData",2,SWIGTYPE_p_float); } arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - arg5 = (int)lua_tonumber(L, 5); (arg1)->setColorData((float const *)arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_setColorData__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - float *arg2 = (float *) 0 ; int arg3 ; int arg4 ; SWIG_check_num_args("ofVbo::setColorData",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::setColorData",1,"ofVbo *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofVbo::setColorData",2,"float const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::setColorData",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVbo::setColorData",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ SWIG_fail_ptr("Vbo_setColorData",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Vbo_setColorData",2,SWIGTYPE_p_float); } arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - (arg1)->setColorData((float const *)arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_setColorData(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 4) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Vbo_setColorData__SWIG_0(L);} } } } } if (argc == 4) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { - return _wrap_Vbo_setColorData__SWIG_2(L);} } } } } if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_Vbo_setColorData__SWIG_1(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_setColorData'\n" " Possible C/C++ prototypes are:\n" - " ofVbo::setColorData(ofFloatColor const *,int,int)\n" " ofVbo::setColorData(float const *,int,int,int)\n" - " ofVbo::setColorData(float const *,int,int)\n"); lua_error(L);return 0; } -static int _wrap_Vbo_setNormalData__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - float *arg2 = (float *) 0 ; int arg3 ; int arg4 ; int arg5 ; SWIG_check_num_args("ofVbo::setNormalData",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::setNormalData",1,"ofVbo *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofVbo::setNormalData",2,"float const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::setNormalData",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVbo::setNormalData",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofVbo::setNormalData",5,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_setNormalData",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Vbo_setNormalData",2,SWIGTYPE_p_float); } arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - arg5 = (int)lua_tonumber(L, 5); (arg1)->setNormalData((float const *)arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_setNormalData__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - float *arg2 = (float *) 0 ; int arg3 ; int arg4 ; SWIG_check_num_args("ofVbo::setNormalData",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::setNormalData",1,"ofVbo *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofVbo::setNormalData",2,"float const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::setNormalData",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVbo::setNormalData",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_setNormalData",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Vbo_setNormalData",2,SWIGTYPE_p_float); } arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - (arg1)->setNormalData((float const *)arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_setNormalData(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 4) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Vbo_setNormalData__SWIG_0(L);} } } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { - return _wrap_Vbo_setNormalData__SWIG_2(L);} } } } } if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_Vbo_setNormalData__SWIG_1(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_setNormalData'\n" " Possible C/C++ prototypes are:\n" - " ofVbo::setNormalData(ofVec3f const *,int,int)\n" " ofVbo::setNormalData(float const *,int,int,int)\n" - " ofVbo::setNormalData(float const *,int,int)\n"); lua_error(L);return 0; } -static int _wrap_Vbo_setTexCoordData__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - float *arg2 = (float *) 0 ; int arg3 ; int arg4 ; int arg5 ; SWIG_check_num_args("ofVbo::setTexCoordData",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::setTexCoordData",1,"ofVbo *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofVbo::setTexCoordData",2,"float const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::setTexCoordData",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVbo::setTexCoordData",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofVbo::setTexCoordData",5,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_setTexCoordData",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Vbo_setTexCoordData",2,SWIGTYPE_p_float); } arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - arg5 = (int)lua_tonumber(L, 5); (arg1)->setTexCoordData((float const *)arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_setTexCoordData__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - float *arg2 = (float *) 0 ; int arg3 ; int arg4 ; SWIG_check_num_args("ofVbo::setTexCoordData",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::setTexCoordData",1,"ofVbo *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofVbo::setTexCoordData",2,"float const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::setTexCoordData",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVbo::setTexCoordData",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_setTexCoordData",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Vbo_setTexCoordData",2,SWIGTYPE_p_float); } arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - (arg1)->setTexCoordData((float const *)arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vbo_setTexCoordData(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); - if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Vbo_setTexCoordData__SWIG_0(L);} } } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { - return _wrap_Vbo_setTexCoordData__SWIG_2(L);} } } } } if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_Vbo_setTexCoordData__SWIG_1(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_setTexCoordData'\n" - " Possible C/C++ prototypes are:\n" " ofVbo::setTexCoordData(ofVec2f const *,int,int)\n" - " ofVbo::setTexCoordData(float const *,int,int,int)\n" " ofVbo::setTexCoordData(float const *,int,int)\n"); - lua_error(L);return 0; } -static int _wrap_Vbo_setAttributeData__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; int arg2 ; - float *arg3 = (float *) 0 ; int arg4 ; int arg5 ; int arg6 ; int arg7 ; SWIG_check_num_args("ofVbo::setAttributeData",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::setAttributeData",1,"ofVbo *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVbo::setAttributeData",2,"int"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofVbo::setAttributeData",3,"float const *"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVbo::setAttributeData",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofVbo::setAttributeData",5,"int"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofVbo::setAttributeData",6,"int"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofVbo::setAttributeData",7,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_setAttributeData",1,SWIGTYPE_p_ofVbo); } arg2 = (int)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Vbo_setAttributeData",3,SWIGTYPE_p_float); } arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); - arg6 = (int)lua_tonumber(L, 6); arg7 = (int)lua_tonumber(L, 7); - (arg1)->setAttributeData(arg2,(float const *)arg3,arg4,arg5,arg6,arg7); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vbo_setAttributeData__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; int arg2 ; - float *arg3 = (float *) 0 ; int arg4 ; int arg5 ; int arg6 ; SWIG_check_num_args("ofVbo::setAttributeData",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::setAttributeData",1,"ofVbo *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVbo::setAttributeData",2,"int"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofVbo::setAttributeData",3,"float const *"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVbo::setAttributeData",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofVbo::setAttributeData",5,"int"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofVbo::setAttributeData",6,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_setAttributeData",1,SWIGTYPE_p_ofVbo); } arg2 = (int)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Vbo_setAttributeData",3,SWIGTYPE_p_float); } arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); - arg6 = (int)lua_tonumber(L, 6); (arg1)->setAttributeData(arg2,(float const *)arg3,arg4,arg5,arg6); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_setAttributeData(lua_State* L) { int argc; int argv[8]={ 1,2,3,4,5,6,7,8} ; argc = lua_gettop(L); - if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } - if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { return _wrap_Vbo_setAttributeData__SWIG_1(L);} } } } } } - } if (argc == 7) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } - if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { - return _wrap_Vbo_setAttributeData__SWIG_0(L);} } } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_setAttributeData'\n" - " Possible C/C++ prototypes are:\n" " ofVbo::setAttributeData(int,float const *,int,int,int,int)\n" - " ofVbo::setAttributeData(int,float const *,int,int,int)\n"); lua_error(L);return 0; } -static int _wrap_Vbo_setAttributeDivisor(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; int arg2 ; int arg3 ; - SWIG_check_num_args("ofVbo::setAttributeDivisor",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::setAttributeDivisor",1,"ofVbo *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVbo::setAttributeDivisor",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::setAttributeDivisor",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_setAttributeDivisor",1,SWIGTYPE_p_ofVbo); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); (arg1)->setAttributeDivisor(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vbo_setVertexBuffer__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - ofBufferObject *arg2 = 0 ; int arg3 ; int arg4 ; int arg5 ; SWIG_check_num_args("ofVbo::setVertexBuffer",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::setVertexBuffer",1,"ofVbo *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVbo::setVertexBuffer",2,"ofBufferObject &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::setVertexBuffer",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVbo::setVertexBuffer",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofVbo::setVertexBuffer",5,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_setVertexBuffer",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBufferObject,0))){ - SWIG_fail_ptr("Vbo_setVertexBuffer",2,SWIGTYPE_p_ofBufferObject); } arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); (arg1)->setVertexBuffer(*arg2,arg3,arg4,arg5); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_setVertexBuffer__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - ofBufferObject *arg2 = 0 ; int arg3 ; int arg4 ; SWIG_check_num_args("ofVbo::setVertexBuffer",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::setVertexBuffer",1,"ofVbo *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVbo::setVertexBuffer",2,"ofBufferObject &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::setVertexBuffer",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVbo::setVertexBuffer",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_setVertexBuffer",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBufferObject,0))){ - SWIG_fail_ptr("Vbo_setVertexBuffer",2,SWIGTYPE_p_ofBufferObject); } arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); (arg1)->setVertexBuffer(*arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_setVertexBuffer(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); - if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBufferObject, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Vbo_setVertexBuffer__SWIG_1(L);} } } } } if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBufferObject, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_Vbo_setVertexBuffer__SWIG_0(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_setVertexBuffer'\n" - " Possible C/C++ prototypes are:\n" " ofVbo::setVertexBuffer(ofBufferObject &,int,int,int)\n" - " ofVbo::setVertexBuffer(ofBufferObject &,int,int)\n"); lua_error(L);return 0; } -static int _wrap_Vbo_setColorBuffer__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - ofBufferObject *arg2 = 0 ; int arg3 ; int arg4 ; SWIG_check_num_args("ofVbo::setColorBuffer",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::setColorBuffer",1,"ofVbo *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVbo::setColorBuffer",2,"ofBufferObject &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::setColorBuffer",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVbo::setColorBuffer",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_setColorBuffer",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBufferObject,0))){ - SWIG_fail_ptr("Vbo_setColorBuffer",2,SWIGTYPE_p_ofBufferObject); } arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); (arg1)->setColorBuffer(*arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vbo_setColorBuffer__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - ofBufferObject *arg2 = 0 ; int arg3 ; SWIG_check_num_args("ofVbo::setColorBuffer",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::setColorBuffer",1,"ofVbo *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVbo::setColorBuffer",2,"ofBufferObject &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::setColorBuffer",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_setColorBuffer",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBufferObject,0))){ - SWIG_fail_ptr("Vbo_setColorBuffer",2,SWIGTYPE_p_ofBufferObject); } arg3 = (int)lua_tonumber(L, 3); - (arg1)->setColorBuffer(*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_setColorBuffer(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBufferObject, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Vbo_setColorBuffer__SWIG_1(L);} - } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBufferObject, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Vbo_setColorBuffer__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_setColorBuffer'\n" " Possible C/C++ prototypes are:\n" - " ofVbo::setColorBuffer(ofBufferObject &,int,int)\n" " ofVbo::setColorBuffer(ofBufferObject &,int)\n"); - lua_error(L);return 0; } -static int _wrap_Vbo_setNormalBuffer__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - ofBufferObject *arg2 = 0 ; int arg3 ; int arg4 ; SWIG_check_num_args("ofVbo::setNormalBuffer",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::setNormalBuffer",1,"ofVbo *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVbo::setNormalBuffer",2,"ofBufferObject &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::setNormalBuffer",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVbo::setNormalBuffer",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_setNormalBuffer",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBufferObject,0))){ - SWIG_fail_ptr("Vbo_setNormalBuffer",2,SWIGTYPE_p_ofBufferObject); } arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); (arg1)->setNormalBuffer(*arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_setNormalBuffer__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - ofBufferObject *arg2 = 0 ; int arg3 ; SWIG_check_num_args("ofVbo::setNormalBuffer",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::setNormalBuffer",1,"ofVbo *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVbo::setNormalBuffer",2,"ofBufferObject &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::setNormalBuffer",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_setNormalBuffer",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBufferObject,0))){ - SWIG_fail_ptr("Vbo_setNormalBuffer",2,SWIGTYPE_p_ofBufferObject); } arg3 = (int)lua_tonumber(L, 3); - (arg1)->setNormalBuffer(*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_setNormalBuffer(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBufferObject, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Vbo_setNormalBuffer__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBufferObject, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Vbo_setNormalBuffer__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_setNormalBuffer'\n" - " Possible C/C++ prototypes are:\n" " ofVbo::setNormalBuffer(ofBufferObject &,int,int)\n" - " ofVbo::setNormalBuffer(ofBufferObject &,int)\n"); lua_error(L);return 0; } -static int _wrap_Vbo_setTexCoordBuffer__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - ofBufferObject *arg2 = 0 ; int arg3 ; int arg4 ; SWIG_check_num_args("ofVbo::setTexCoordBuffer",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::setTexCoordBuffer",1,"ofVbo *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVbo::setTexCoordBuffer",2,"ofBufferObject &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::setTexCoordBuffer",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVbo::setTexCoordBuffer",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_setTexCoordBuffer",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBufferObject,0))){ - SWIG_fail_ptr("Vbo_setTexCoordBuffer",2,SWIGTYPE_p_ofBufferObject); } arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); (arg1)->setTexCoordBuffer(*arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_setTexCoordBuffer__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - ofBufferObject *arg2 = 0 ; int arg3 ; SWIG_check_num_args("ofVbo::setTexCoordBuffer",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::setTexCoordBuffer",1,"ofVbo *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVbo::setTexCoordBuffer",2,"ofBufferObject &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::setTexCoordBuffer",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_setTexCoordBuffer",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBufferObject,0))){ - SWIG_fail_ptr("Vbo_setTexCoordBuffer",2,SWIGTYPE_p_ofBufferObject); } arg3 = (int)lua_tonumber(L, 3); - (arg1)->setTexCoordBuffer(*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_setTexCoordBuffer(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBufferObject, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Vbo_setTexCoordBuffer__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBufferObject, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Vbo_setTexCoordBuffer__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_setTexCoordBuffer'\n" - " Possible C/C++ prototypes are:\n" " ofVbo::setTexCoordBuffer(ofBufferObject &,int,int)\n" - " ofVbo::setTexCoordBuffer(ofBufferObject &,int)\n"); lua_error(L);return 0; } -static int _wrap_Vbo_setIndexBuffer(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; ofBufferObject *arg2 = 0 ; - SWIG_check_num_args("ofVbo::setIndexBuffer",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::setIndexBuffer",1,"ofVbo *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVbo::setIndexBuffer",2,"ofBufferObject &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_setIndexBuffer",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBufferObject,0))){ - SWIG_fail_ptr("Vbo_setIndexBuffer",2,SWIGTYPE_p_ofBufferObject); } (arg1)->setIndexBuffer(*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_setAttributeBuffer__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; int arg2 ; - ofBufferObject *arg3 = 0 ; int arg4 ; int arg5 ; int arg6 ; SWIG_check_num_args("ofVbo::setAttributeBuffer",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::setAttributeBuffer",1,"ofVbo *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVbo::setAttributeBuffer",2,"int"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofVbo::setAttributeBuffer",3,"ofBufferObject &"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVbo::setAttributeBuffer",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofVbo::setAttributeBuffer",5,"int"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofVbo::setAttributeBuffer",6,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_setAttributeBuffer",1,SWIGTYPE_p_ofVbo); } arg2 = (int)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofBufferObject,0))){ - SWIG_fail_ptr("Vbo_setAttributeBuffer",3,SWIGTYPE_p_ofBufferObject); } arg4 = (int)lua_tonumber(L, 4); - arg5 = (int)lua_tonumber(L, 5); arg6 = (int)lua_tonumber(L, 6); (arg1)->setAttributeBuffer(arg2,*arg3,arg4,arg5,arg6); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_setAttributeBuffer__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; int arg2 ; - ofBufferObject *arg3 = 0 ; int arg4 ; int arg5 ; SWIG_check_num_args("ofVbo::setAttributeBuffer",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::setAttributeBuffer",1,"ofVbo *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVbo::setAttributeBuffer",2,"int"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofVbo::setAttributeBuffer",3,"ofBufferObject &"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVbo::setAttributeBuffer",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofVbo::setAttributeBuffer",5,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_setAttributeBuffer",1,SWIGTYPE_p_ofVbo); } arg2 = (int)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofBufferObject,0))){ - SWIG_fail_ptr("Vbo_setAttributeBuffer",3,SWIGTYPE_p_ofBufferObject); } arg4 = (int)lua_tonumber(L, 4); - arg5 = (int)lua_tonumber(L, 5); (arg1)->setAttributeBuffer(arg2,*arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_setAttributeBuffer(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofBufferObject, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_Vbo_setAttributeBuffer__SWIG_1(L);} } } } } } - if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofBufferObject, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { - return _wrap_Vbo_setAttributeBuffer__SWIG_0(L);} } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_setAttributeBuffer'\n" - " Possible C/C++ prototypes are:\n" " ofVbo::setAttributeBuffer(int,ofBufferObject &,int,int,int)\n" - " ofVbo::setAttributeBuffer(int,ofBufferObject &,int,int)\n"); lua_error(L);return 0; } -static int _wrap_Vbo_getVertexBuffer__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - ofBufferObject *result = 0 ; SWIG_check_num_args("ofVbo::getVertexBuffer",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::getVertexBuffer",1,"ofVbo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_getVertexBuffer",1,SWIGTYPE_p_ofVbo); } result = (ofBufferObject *) &(arg1)->getVertexBuffer(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofBufferObject,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vbo_getColorBuffer__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - ofBufferObject *result = 0 ; SWIG_check_num_args("ofVbo::getColorBuffer",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::getColorBuffer",1,"ofVbo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_getColorBuffer",1,SWIGTYPE_p_ofVbo); } result = (ofBufferObject *) &(arg1)->getColorBuffer(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofBufferObject,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vbo_getNormalBuffer__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - ofBufferObject *result = 0 ; SWIG_check_num_args("ofVbo::getNormalBuffer",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::getNormalBuffer",1,"ofVbo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_getNormalBuffer",1,SWIGTYPE_p_ofVbo); } result = (ofBufferObject *) &(arg1)->getNormalBuffer(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofBufferObject,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vbo_getTexCoordBuffer__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - ofBufferObject *result = 0 ; SWIG_check_num_args("ofVbo::getTexCoordBuffer",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::getTexCoordBuffer",1,"ofVbo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_getTexCoordBuffer",1,SWIGTYPE_p_ofVbo); } result = (ofBufferObject *) &(arg1)->getTexCoordBuffer(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofBufferObject,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vbo_getIndexBuffer__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - ofBufferObject *result = 0 ; SWIG_check_num_args("ofVbo::getIndexBuffer",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::getIndexBuffer",1,"ofVbo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_getIndexBuffer",1,SWIGTYPE_p_ofVbo); } result = (ofBufferObject *) &(arg1)->getIndexBuffer(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofBufferObject,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vbo_getAttributeBuffer__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; int arg2 ; - ofBufferObject *result = 0 ; SWIG_check_num_args("ofVbo::getAttributeBuffer",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::getAttributeBuffer",1,"ofVbo *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVbo::getAttributeBuffer",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_getAttributeBuffer",1,SWIGTYPE_p_ofVbo); } arg2 = (int)lua_tonumber(L, 2); - result = (ofBufferObject *) &(arg1)->getAttributeBuffer(arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofBufferObject,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vbo_getVertexBuffer__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - ofBufferObject *result = 0 ; SWIG_check_num_args("ofVbo::getVertexBuffer",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::getVertexBuffer",1,"ofVbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_getVertexBuffer",1,SWIGTYPE_p_ofVbo); } - result = (ofBufferObject *) &((ofVbo const *)arg1)->getVertexBuffer(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofBufferObject,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vbo_getVertexBuffer(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Vbo_getVertexBuffer__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vbo_getVertexBuffer__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_getVertexBuffer'\n" - " Possible C/C++ prototypes are:\n" " ofVbo::getVertexBuffer()\n" " ofVbo::getVertexBuffer() const\n"); - lua_error(L);return 0; } -static int _wrap_Vbo_getColorBuffer__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - ofBufferObject *result = 0 ; SWIG_check_num_args("ofVbo::getColorBuffer",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::getColorBuffer",1,"ofVbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_getColorBuffer",1,SWIGTYPE_p_ofVbo); } - result = (ofBufferObject *) &((ofVbo const *)arg1)->getColorBuffer(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofBufferObject,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vbo_getColorBuffer(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Vbo_getColorBuffer__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vbo_getColorBuffer__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_getColorBuffer'\n" " Possible C/C++ prototypes are:\n" - " ofVbo::getColorBuffer()\n" " ofVbo::getColorBuffer() const\n"); lua_error(L);return 0; } -static int _wrap_Vbo_getNormalBuffer__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - ofBufferObject *result = 0 ; SWIG_check_num_args("ofVbo::getNormalBuffer",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::getNormalBuffer",1,"ofVbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_getNormalBuffer",1,SWIGTYPE_p_ofVbo); } - result = (ofBufferObject *) &((ofVbo const *)arg1)->getNormalBuffer(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofBufferObject,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vbo_getNormalBuffer(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Vbo_getNormalBuffer__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vbo_getNormalBuffer__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_getNormalBuffer'\n" - " Possible C/C++ prototypes are:\n" " ofVbo::getNormalBuffer()\n" " ofVbo::getNormalBuffer() const\n"); - lua_error(L);return 0; } -static int _wrap_Vbo_getTexCoordBuffer__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - ofBufferObject *result = 0 ; SWIG_check_num_args("ofVbo::getTexCoordBuffer",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::getTexCoordBuffer",1,"ofVbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_getTexCoordBuffer",1,SWIGTYPE_p_ofVbo); } - result = (ofBufferObject *) &((ofVbo const *)arg1)->getTexCoordBuffer(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofBufferObject,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vbo_getTexCoordBuffer(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Vbo_getTexCoordBuffer__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vbo_getTexCoordBuffer__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_getTexCoordBuffer'\n" - " Possible C/C++ prototypes are:\n" " ofVbo::getTexCoordBuffer()\n" " ofVbo::getTexCoordBuffer() const\n"); - lua_error(L);return 0; } -static int _wrap_Vbo_getIndexBuffer__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - ofBufferObject *result = 0 ; SWIG_check_num_args("ofVbo::getIndexBuffer",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::getIndexBuffer",1,"ofVbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_getIndexBuffer",1,SWIGTYPE_p_ofVbo); } - result = (ofBufferObject *) &((ofVbo const *)arg1)->getIndexBuffer(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofBufferObject,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vbo_getIndexBuffer(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Vbo_getIndexBuffer__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vbo_getIndexBuffer__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_getIndexBuffer'\n" " Possible C/C++ prototypes are:\n" - " ofVbo::getIndexBuffer()\n" " ofVbo::getIndexBuffer() const\n"); lua_error(L);return 0; } -static int _wrap_Vbo_getAttributeBuffer__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; int arg2 ; - ofBufferObject *result = 0 ; SWIG_check_num_args("ofVbo::getAttributeBuffer",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::getAttributeBuffer",1,"ofVbo const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVbo::getAttributeBuffer",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_getAttributeBuffer",1,SWIGTYPE_p_ofVbo); } arg2 = (int)lua_tonumber(L, 2); - result = (ofBufferObject *) &((ofVbo const *)arg1)->getAttributeBuffer(arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofBufferObject,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vbo_getAttributeBuffer(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Vbo_getAttributeBuffer__SWIG_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Vbo_getAttributeBuffer__SWIG_1(L);} } - } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_getAttributeBuffer'\n" - " Possible C/C++ prototypes are:\n" " ofVbo::getAttributeBuffer(int)\n" " ofVbo::getAttributeBuffer(int) const\n"); - lua_error(L);return 0; } -static int _wrap_Vbo_updateMesh(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; ofMesh *arg2 = 0 ; - SWIG_check_num_args("ofVbo::updateMesh",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::updateMesh",1,"ofVbo *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVbo::updateMesh",2,"ofMesh const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ SWIG_fail_ptr("Vbo_updateMesh",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Vbo_updateMesh",2,SWIGTYPE_p_ofMesh); } - (arg1)->updateMesh((ofMesh const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_updateVertexData__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - ofVec3f *arg2 = (ofVec3f *) 0 ; int arg3 ; SWIG_check_num_args("ofVbo::updateVertexData",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::updateVertexData",1,"ofVbo *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofVbo::updateVertexData",2,"ofVec3f const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::updateVertexData",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_updateVertexData",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vbo_updateVertexData",2,SWIGTYPE_p_ofVec3f); } arg3 = (int)lua_tonumber(L, 3); - (arg1)->updateVertexData((ofVec3f const *)arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_updateVertexData__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - ofVec2f *arg2 = (ofVec2f *) 0 ; int arg3 ; SWIG_check_num_args("ofVbo::updateVertexData",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::updateVertexData",1,"ofVbo *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofVbo::updateVertexData",2,"ofVec2f const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::updateVertexData",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_updateVertexData",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vbo_updateVertexData",2,SWIGTYPE_p_ofVec2f); } arg3 = (int)lua_tonumber(L, 3); - (arg1)->updateVertexData((ofVec2f const *)arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_updateColorData__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - ofFloatColor *arg2 = (ofFloatColor *) 0 ; int arg3 ; SWIG_check_num_args("ofVbo::updateColorData",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::updateColorData",1,"ofVbo *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofVbo::updateColorData",2,"ofFloatColor const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::updateColorData",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_updateColorData",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("Vbo_updateColorData",2,SWIGTYPE_p_ofColor_T_float_t); } arg3 = (int)lua_tonumber(L, 3); - (arg1)->updateColorData((ofFloatColor const *)arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vbo_updateNormalData__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - ofVec3f *arg2 = (ofVec3f *) 0 ; int arg3 ; SWIG_check_num_args("ofVbo::updateNormalData",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::updateNormalData",1,"ofVbo *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofVbo::updateNormalData",2,"ofVec3f const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::updateNormalData",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_updateNormalData",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vbo_updateNormalData",2,SWIGTYPE_p_ofVec3f); } arg3 = (int)lua_tonumber(L, 3); - (arg1)->updateNormalData((ofVec3f const *)arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_updateTexCoordData__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - ofVec2f *arg2 = (ofVec2f *) 0 ; int arg3 ; SWIG_check_num_args("ofVbo::updateTexCoordData",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::updateTexCoordData",1,"ofVbo *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofVbo::updateTexCoordData",2,"ofVec2f const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::updateTexCoordData",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_updateTexCoordData",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vbo_updateTexCoordData",2,SWIGTYPE_p_ofVec2f); } arg3 = (int)lua_tonumber(L, 3); - (arg1)->updateTexCoordData((ofVec2f const *)arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vbo_updateIndexData(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - ofIndexType *arg2 = (ofIndexType *) 0 ; int arg3 ; SWIG_check_num_args("ofVbo::updateIndexData",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::updateIndexData",1,"ofVbo *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofVbo::updateIndexData",2,"ofIndexType const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::updateIndexData",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_updateIndexData",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_unsigned_int,0))){ - SWIG_fail_ptr("Vbo_updateIndexData",2,SWIGTYPE_p_unsigned_int); } arg3 = (int)lua_tonumber(L, 3); - (arg1)->updateIndexData((ofIndexType const *)arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vbo_updateVertexData__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - float *arg2 = (float *) 0 ; int arg3 ; SWIG_check_num_args("ofVbo::updateVertexData",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::updateVertexData",1,"ofVbo *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofVbo::updateVertexData",2,"float const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::updateVertexData",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_updateVertexData",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Vbo_updateVertexData",2,SWIGTYPE_p_float); } arg3 = (int)lua_tonumber(L, 3); - (arg1)->updateVertexData((float const *)arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_updateVertexData(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Vbo_updateVertexData__SWIG_0(L);} } } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Vbo_updateVertexData__SWIG_1(L);} } } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Vbo_updateVertexData__SWIG_2(L);} } - } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_updateVertexData'\n" - " Possible C/C++ prototypes are:\n" " ofVbo::updateVertexData(ofVec3f const *,int)\n" - " ofVbo::updateVertexData(ofVec2f const *,int)\n" " ofVbo::updateVertexData(float const *,int)\n"); - lua_error(L);return 0; } -static int _wrap_Vbo_updateColorData__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - float *arg2 = (float *) 0 ; int arg3 ; SWIG_check_num_args("ofVbo::updateColorData",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::updateColorData",1,"ofVbo *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofVbo::updateColorData",2,"float const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::updateColorData",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_updateColorData",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Vbo_updateColorData",2,SWIGTYPE_p_float); } arg3 = (int)lua_tonumber(L, 3); - (arg1)->updateColorData((float const *)arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_updateColorData(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Vbo_updateColorData__SWIG_0(L);} } } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Vbo_updateColorData__SWIG_1(L);} } - } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_updateColorData'\n" - " Possible C/C++ prototypes are:\n" " ofVbo::updateColorData(ofFloatColor const *,int)\n" - " ofVbo::updateColorData(float const *,int)\n"); lua_error(L);return 0; } -static int _wrap_Vbo_updateNormalData__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - float *arg2 = (float *) 0 ; int arg3 ; SWIG_check_num_args("ofVbo::updateNormalData",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::updateNormalData",1,"ofVbo *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofVbo::updateNormalData",2,"float const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::updateNormalData",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_updateNormalData",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Vbo_updateNormalData",2,SWIGTYPE_p_float); } arg3 = (int)lua_tonumber(L, 3); - (arg1)->updateNormalData((float const *)arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_updateNormalData(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Vbo_updateNormalData__SWIG_0(L);} } } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Vbo_updateNormalData__SWIG_1(L);} } - } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_updateNormalData'\n" - " Possible C/C++ prototypes are:\n" " ofVbo::updateNormalData(ofVec3f const *,int)\n" - " ofVbo::updateNormalData(float const *,int)\n"); lua_error(L);return 0; } -static int _wrap_Vbo_updateTexCoordData__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - float *arg2 = (float *) 0 ; int arg3 ; SWIG_check_num_args("ofVbo::updateTexCoordData",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::updateTexCoordData",1,"ofVbo *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofVbo::updateTexCoordData",2,"float const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::updateTexCoordData",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_updateTexCoordData",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Vbo_updateTexCoordData",2,SWIGTYPE_p_float); } arg3 = (int)lua_tonumber(L, 3); - (arg1)->updateTexCoordData((float const *)arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_updateTexCoordData(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Vbo_updateTexCoordData__SWIG_0(L);} } } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Vbo_updateTexCoordData__SWIG_1(L);} - } } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_updateTexCoordData'\n" - " Possible C/C++ prototypes are:\n" " ofVbo::updateTexCoordData(ofVec2f const *,int)\n" - " ofVbo::updateTexCoordData(float const *,int)\n"); lua_error(L);return 0; } -static int _wrap_Vbo_updateAttributeData(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; int arg2 ; - float *arg3 = (float *) 0 ; int arg4 ; SWIG_check_num_args("ofVbo::updateAttributeData",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::updateAttributeData",1,"ofVbo *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVbo::updateAttributeData",2,"int"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofVbo::updateAttributeData",3,"float const *"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVbo::updateAttributeData",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_updateAttributeData",1,SWIGTYPE_p_ofVbo); } arg2 = (int)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Vbo_updateAttributeData",3,SWIGTYPE_p_float); } arg4 = (int)lua_tonumber(L, 4); - (arg1)->updateAttributeData(arg2,(float const *)arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vbo_enableColors(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - SWIG_check_num_args("ofVbo::enableColors",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::enableColors",1,"ofVbo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ SWIG_fail_ptr("Vbo_enableColors",1,SWIGTYPE_p_ofVbo); } - (arg1)->enableColors(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_enableNormals(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - SWIG_check_num_args("ofVbo::enableNormals",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::enableNormals",1,"ofVbo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_enableNormals",1,SWIGTYPE_p_ofVbo); } (arg1)->enableNormals(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_enableTexCoords(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - SWIG_check_num_args("ofVbo::enableTexCoords",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::enableTexCoords",1,"ofVbo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_enableTexCoords",1,SWIGTYPE_p_ofVbo); } (arg1)->enableTexCoords(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_enableIndices(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - SWIG_check_num_args("ofVbo::enableIndices",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::enableIndices",1,"ofVbo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_enableIndices",1,SWIGTYPE_p_ofVbo); } (arg1)->enableIndices(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_disableColors(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - SWIG_check_num_args("ofVbo::disableColors",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::disableColors",1,"ofVbo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_disableColors",1,SWIGTYPE_p_ofVbo); } (arg1)->disableColors(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_disableNormals(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - SWIG_check_num_args("ofVbo::disableNormals",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::disableNormals",1,"ofVbo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_disableNormals",1,SWIGTYPE_p_ofVbo); } (arg1)->disableNormals(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_disableTexCoords(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - SWIG_check_num_args("ofVbo::disableTexCoords",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::disableTexCoords",1,"ofVbo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_disableTexCoords",1,SWIGTYPE_p_ofVbo); } (arg1)->disableTexCoords(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_disableIndices(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - SWIG_check_num_args("ofVbo::disableIndices",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::disableIndices",1,"ofVbo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_disableIndices",1,SWIGTYPE_p_ofVbo); } (arg1)->disableIndices(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_getVaoId(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; GLuint result; - SWIG_check_num_args("ofVbo::getVaoId",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::getVaoId",1,"ofVbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ SWIG_fail_ptr("Vbo_getVaoId",1,SWIGTYPE_p_ofVbo); } - result = (GLuint)((ofVbo const *)arg1)->getVaoId(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_getVertId(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; GLuint result; - SWIG_check_num_args("ofVbo::getVertId",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::getVertId",1,"ofVbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ SWIG_fail_ptr("Vbo_getVertId",1,SWIGTYPE_p_ofVbo); } - result = (GLuint)((ofVbo const *)arg1)->getVertId(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_getColorId(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; GLuint result; - SWIG_check_num_args("ofVbo::getColorId",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::getColorId",1,"ofVbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ SWIG_fail_ptr("Vbo_getColorId",1,SWIGTYPE_p_ofVbo); } - result = (GLuint)((ofVbo const *)arg1)->getColorId(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_getNormalId(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; GLuint result; - SWIG_check_num_args("ofVbo::getNormalId",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::getNormalId",1,"ofVbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ SWIG_fail_ptr("Vbo_getNormalId",1,SWIGTYPE_p_ofVbo); } - result = (GLuint)((ofVbo const *)arg1)->getNormalId(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_getTexCoordId(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; GLuint result; - SWIG_check_num_args("ofVbo::getTexCoordId",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::getTexCoordId",1,"ofVbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_getTexCoordId",1,SWIGTYPE_p_ofVbo); } result = (GLuint)((ofVbo const *)arg1)->getTexCoordId(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_getIndexId(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; GLuint result; - SWIG_check_num_args("ofVbo::getIndexId",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::getIndexId",1,"ofVbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ SWIG_fail_ptr("Vbo_getIndexId",1,SWIGTYPE_p_ofVbo); } - result = (GLuint)((ofVbo const *)arg1)->getIndexId(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_getAttributeId(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; int arg2 ; GLuint result; - SWIG_check_num_args("ofVbo::getAttributeId",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::getAttributeId",1,"ofVbo const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVbo::getAttributeId",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_getAttributeId",1,SWIGTYPE_p_ofVbo); } arg2 = (int)lua_tonumber(L, 2); - result = (GLuint)((ofVbo const *)arg1)->getAttributeId(arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_getIsAllocated(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; bool result; - SWIG_check_num_args("ofVbo::getIsAllocated",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::getIsAllocated",1,"ofVbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_getIsAllocated",1,SWIGTYPE_p_ofVbo); } result = (bool)((ofVbo const *)arg1)->getIsAllocated(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_getUsingVerts(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; bool result; - SWIG_check_num_args("ofVbo::getUsingVerts",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::getUsingVerts",1,"ofVbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_getUsingVerts",1,SWIGTYPE_p_ofVbo); } result = (bool)((ofVbo const *)arg1)->getUsingVerts(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_getUsingColors(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; bool result; - SWIG_check_num_args("ofVbo::getUsingColors",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::getUsingColors",1,"ofVbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_getUsingColors",1,SWIGTYPE_p_ofVbo); } result = (bool)((ofVbo const *)arg1)->getUsingColors(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_getUsingNormals(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; bool result; - SWIG_check_num_args("ofVbo::getUsingNormals",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::getUsingNormals",1,"ofVbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_getUsingNormals",1,SWIGTYPE_p_ofVbo); } result = (bool)((ofVbo const *)arg1)->getUsingNormals(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_getUsingTexCoords(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; bool result; - SWIG_check_num_args("ofVbo::getUsingTexCoords",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::getUsingTexCoords",1,"ofVbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_getUsingTexCoords",1,SWIGTYPE_p_ofVbo); } result = (bool)((ofVbo const *)arg1)->getUsingTexCoords(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_getUsingIndices(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; bool result; - SWIG_check_num_args("ofVbo::getUsingIndices",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::getUsingIndices",1,"ofVbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_getUsingIndices",1,SWIGTYPE_p_ofVbo); } result = (bool)((ofVbo const *)arg1)->getUsingIndices(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_draw(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; int arg2 ; int arg3 ; int arg4 ; - SWIG_check_num_args("ofVbo::draw",4,4) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::draw",1,"ofVbo const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVbo::draw",2,"int"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::draw",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVbo::draw",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ SWIG_fail_ptr("Vbo_draw",1,SWIGTYPE_p_ofVbo); } - arg2 = (int)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - ((ofVbo const *)arg1)->draw(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_drawElements__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; int arg2 ; int arg3 ; - int arg4 ; SWIG_check_num_args("ofVbo::drawElements",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::drawElements",1,"ofVbo const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVbo::drawElements",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::drawElements",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVbo::drawElements",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ SWIG_fail_ptr("Vbo_drawElements",1,SWIGTYPE_p_ofVbo); } - arg2 = (int)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - ((ofVbo const *)arg1)->drawElements(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_drawElements__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; int arg2 ; int arg3 ; - SWIG_check_num_args("ofVbo::drawElements",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::drawElements",1,"ofVbo const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVbo::drawElements",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::drawElements",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ SWIG_fail_ptr("Vbo_drawElements",1,SWIGTYPE_p_ofVbo); } - arg2 = (int)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); ((ofVbo const *)arg1)->drawElements(arg2,arg3); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_drawElements(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_Vbo_drawElements__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Vbo_drawElements__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_drawElements'\n" " Possible C/C++ prototypes are:\n" - " ofVbo::drawElements(int,int,int) const\n" " ofVbo::drawElements(int,int) const\n"); lua_error(L);return 0; } -static int _wrap_Vbo_drawInstanced(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; int arg2 ; int arg3 ; - int arg4 ; int arg5 ; SWIG_check_num_args("ofVbo::drawInstanced",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::drawInstanced",1,"ofVbo const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVbo::drawInstanced",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::drawInstanced",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVbo::drawInstanced",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofVbo::drawInstanced",5,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_drawInstanced",1,SWIGTYPE_p_ofVbo); } arg2 = (int)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); ((ofVbo const *)arg1)->drawInstanced(arg2,arg3,arg4,arg5); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_drawElementsInstanced(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; int arg2 ; int arg3 ; - int arg4 ; SWIG_check_num_args("ofVbo::drawElementsInstanced",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::drawElementsInstanced",1,"ofVbo const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVbo::drawElementsInstanced",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::drawElementsInstanced",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVbo::drawElementsInstanced",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_drawElementsInstanced",1,SWIGTYPE_p_ofVbo); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); ((ofVbo const *)arg1)->drawElementsInstanced(arg2,arg3,arg4); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_bind(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; SWIG_check_num_args("ofVbo::bind",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::bind",1,"ofVbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ SWIG_fail_ptr("Vbo_bind",1,SWIGTYPE_p_ofVbo); } - ((ofVbo const *)arg1)->bind(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_unbind(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - SWIG_check_num_args("ofVbo::unbind",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::unbind",1,"ofVbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ SWIG_fail_ptr("Vbo_unbind",1,SWIGTYPE_p_ofVbo); } - ((ofVbo const *)arg1)->unbind(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_clear(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; SWIG_check_num_args("ofVbo::clear",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::clear",1,"ofVbo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ SWIG_fail_ptr("Vbo_clear",1,SWIGTYPE_p_ofVbo); } - (arg1)->clear(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_clearVertices(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - SWIG_check_num_args("ofVbo::clearVertices",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::clearVertices",1,"ofVbo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_clearVertices",1,SWIGTYPE_p_ofVbo); } (arg1)->clearVertices(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_clearNormals(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - SWIG_check_num_args("ofVbo::clearNormals",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::clearNormals",1,"ofVbo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ SWIG_fail_ptr("Vbo_clearNormals",1,SWIGTYPE_p_ofVbo); } - (arg1)->clearNormals(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_clearColors(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - SWIG_check_num_args("ofVbo::clearColors",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::clearColors",1,"ofVbo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ SWIG_fail_ptr("Vbo_clearColors",1,SWIGTYPE_p_ofVbo); } - (arg1)->clearColors(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_clearTexCoords(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - SWIG_check_num_args("ofVbo::clearTexCoords",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::clearTexCoords",1,"ofVbo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_clearTexCoords",1,SWIGTYPE_p_ofVbo); } (arg1)->clearTexCoords(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_clearIndices(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - SWIG_check_num_args("ofVbo::clearIndices",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::clearIndices",1,"ofVbo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ SWIG_fail_ptr("Vbo_clearIndices",1,SWIGTYPE_p_ofVbo); } - (arg1)->clearIndices(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_clearAttribute(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; int arg2 ; - SWIG_check_num_args("ofVbo::clearAttribute",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::clearAttribute",1,"ofVbo *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVbo::clearAttribute",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_clearAttribute",1,SWIGTYPE_p_ofVbo); } arg2 = (int)lua_tonumber(L, 2); (arg1)->clearAttribute(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_getNumVertices(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; int result; - SWIG_check_num_args("ofVbo::getNumVertices",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::getNumVertices",1,"ofVbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_getNumVertices",1,SWIGTYPE_p_ofVbo); } result = (int)((ofVbo const *)arg1)->getNumVertices(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_getNumIndices(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; int result; - SWIG_check_num_args("ofVbo::getNumIndices",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::getNumIndices",1,"ofVbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_getNumIndices",1,SWIGTYPE_p_ofVbo); } result = (int)((ofVbo const *)arg1)->getNumIndices(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_hasAttribute(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; int arg2 ; bool result; - SWIG_check_num_args("ofVbo::hasAttribute",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::hasAttribute",1,"ofVbo const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVbo::hasAttribute",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ SWIG_fail_ptr("Vbo_hasAttribute",1,SWIGTYPE_p_ofVbo); } - arg2 = (int)lua_tonumber(L, 2); result = (bool)((ofVbo const *)arg1)->hasAttribute(arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_Vbo(void *obj) { -ofVbo *arg1 = (ofVbo *) obj; -delete arg1; -} -static int _proxy__wrap_new_Vbo(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_Vbo); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_Vbo_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_Vbo_methods[]= { - { "setMesh", _wrap_Vbo_setMesh}, - { "setIndexData", _wrap_Vbo_setIndexData}, - { "setVertexData", _wrap_Vbo_setVertexData}, - { "setColorData", _wrap_Vbo_setColorData}, - { "setNormalData", _wrap_Vbo_setNormalData}, - { "setTexCoordData", _wrap_Vbo_setTexCoordData}, - { "setAttributeData", _wrap_Vbo_setAttributeData}, - { "setAttributeDivisor", _wrap_Vbo_setAttributeDivisor}, - { "setVertexBuffer", _wrap_Vbo_setVertexBuffer}, - { "setColorBuffer", _wrap_Vbo_setColorBuffer}, - { "setNormalBuffer", _wrap_Vbo_setNormalBuffer}, - { "setTexCoordBuffer", _wrap_Vbo_setTexCoordBuffer}, - { "setIndexBuffer", _wrap_Vbo_setIndexBuffer}, - { "setAttributeBuffer", _wrap_Vbo_setAttributeBuffer}, - { "getVertexBuffer", _wrap_Vbo_getVertexBuffer}, - { "getColorBuffer", _wrap_Vbo_getColorBuffer}, - { "getNormalBuffer", _wrap_Vbo_getNormalBuffer}, - { "getTexCoordBuffer", _wrap_Vbo_getTexCoordBuffer}, - { "getIndexBuffer", _wrap_Vbo_getIndexBuffer}, - { "getAttributeBuffer", _wrap_Vbo_getAttributeBuffer}, - { "updateMesh", _wrap_Vbo_updateMesh}, - { "updateIndexData", _wrap_Vbo_updateIndexData}, - { "updateVertexData", _wrap_Vbo_updateVertexData}, - { "updateColorData", _wrap_Vbo_updateColorData}, - { "updateNormalData", _wrap_Vbo_updateNormalData}, - { "updateTexCoordData", _wrap_Vbo_updateTexCoordData}, - { "updateAttributeData", _wrap_Vbo_updateAttributeData}, - { "enableColors", _wrap_Vbo_enableColors}, - { "enableNormals", _wrap_Vbo_enableNormals}, - { "enableTexCoords", _wrap_Vbo_enableTexCoords}, - { "enableIndices", _wrap_Vbo_enableIndices}, - { "disableColors", _wrap_Vbo_disableColors}, - { "disableNormals", _wrap_Vbo_disableNormals}, - { "disableTexCoords", _wrap_Vbo_disableTexCoords}, - { "disableIndices", _wrap_Vbo_disableIndices}, - { "getVaoId", _wrap_Vbo_getVaoId}, - { "getVertId", _wrap_Vbo_getVertId}, - { "getColorId", _wrap_Vbo_getColorId}, - { "getNormalId", _wrap_Vbo_getNormalId}, - { "getTexCoordId", _wrap_Vbo_getTexCoordId}, - { "getIndexId", _wrap_Vbo_getIndexId}, - { "getAttributeId", _wrap_Vbo_getAttributeId}, - { "getIsAllocated", _wrap_Vbo_getIsAllocated}, - { "getUsingVerts", _wrap_Vbo_getUsingVerts}, - { "getUsingColors", _wrap_Vbo_getUsingColors}, - { "getUsingNormals", _wrap_Vbo_getUsingNormals}, - { "getUsingTexCoords", _wrap_Vbo_getUsingTexCoords}, - { "getUsingIndices", _wrap_Vbo_getUsingIndices}, - { "draw", _wrap_Vbo_draw}, - { "drawElements", _wrap_Vbo_drawElements}, - { "drawInstanced", _wrap_Vbo_drawInstanced}, - { "drawElementsInstanced", _wrap_Vbo_drawElementsInstanced}, - { "bind", _wrap_Vbo_bind}, - { "unbind", _wrap_Vbo_unbind}, - { "clear", _wrap_Vbo_clear}, - { "clearVertices", _wrap_Vbo_clearVertices}, - { "clearNormals", _wrap_Vbo_clearNormals}, - { "clearColors", _wrap_Vbo_clearColors}, - { "clearTexCoords", _wrap_Vbo_clearTexCoords}, - { "clearIndices", _wrap_Vbo_clearIndices}, - { "clearAttribute", _wrap_Vbo_clearAttribute}, - { "getNumVertices", _wrap_Vbo_getNumVertices}, - { "getNumIndices", _wrap_Vbo_getNumIndices}, - { "hasAttribute", _wrap_Vbo_hasAttribute}, - {0,0} -}; -static swig_lua_method swig_Vbo_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_Vbo_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_Vbo_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_Vbo_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_Vbo_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_Vbo_Sf_SwigStatic = { - "Vbo", - swig_Vbo_Sf_SwigStatic_methods, - swig_Vbo_Sf_SwigStatic_attributes, - swig_Vbo_Sf_SwigStatic_constants, - swig_Vbo_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_Vbo_bases[] = {0}; -static const char *swig_Vbo_base_names[] = {0}; -static swig_lua_class _wrap_class_Vbo = { "Vbo", "Vbo", &SWIGTYPE_p_ofVbo,_proxy__wrap_new_Vbo, swig_delete_Vbo, swig_Vbo_methods, swig_Vbo_attributes, &swig_Vbo_Sf_SwigStatic, swig_Vbo_meta, swig_Vbo_bases, swig_Vbo_base_names }; - -static int _wrap_VboMesh_draw__SWIG_0_0(lua_State* L) { int SWIG_arg = 0; ofVboMesh *arg1 = (ofVboMesh *) 0 ; - SWIG_check_num_args("draw",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("draw",1,"ofVboMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVboMesh,0))){ - SWIG_fail_ptr("VboMesh_draw",1,SWIGTYPE_p_ofVboMesh); } ((ofVboMesh const *)arg1)->draw(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_new_VboMesh__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVboMesh *result = 0 ; - SWIG_check_num_args("ofVboMesh::ofVboMesh",0,0) result = (ofVboMesh *)new ofVboMesh(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVboMesh,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_VboMesh__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = 0 ; ofVboMesh *result = 0 ; - SWIG_check_num_args("ofVboMesh::ofVboMesh",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofVboMesh::ofVboMesh",1,"ofMesh const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("new_VboMesh",1,SWIGTYPE_p_ofMesh); } - result = (ofVboMesh *)new ofVboMesh((ofMesh const &)*arg1); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVboMesh,1); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_new_VboMesh(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_VboMesh__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_new_VboMesh__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_VboMesh'\n" " Possible C/C++ prototypes are:\n" - " ofVboMesh::ofVboMesh()\n" " ofVboMesh::ofVboMesh(ofMesh const &)\n"); lua_error(L);return 0; } -static int _wrap_VboMesh_setUsage(lua_State* L) { int SWIG_arg = 0; ofVboMesh *arg1 = (ofVboMesh *) 0 ; int arg2 ; - SWIG_check_num_args("ofVboMesh::setUsage",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVboMesh::setUsage",1,"ofVboMesh *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVboMesh::setUsage",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVboMesh,0))){ - SWIG_fail_ptr("VboMesh_setUsage",1,SWIGTYPE_p_ofVboMesh); } arg2 = (int)lua_tonumber(L, 2); (arg1)->setUsage(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VboMesh_draw__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVboMesh *arg1 = (ofVboMesh *) 0 ; - ofPolyRenderMode arg2 ; SWIG_check_num_args("ofVboMesh::draw",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVboMesh::draw",1,"ofVboMesh const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVboMesh::draw",2,"ofPolyRenderMode"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVboMesh,0))){ - SWIG_fail_ptr("VboMesh_draw",1,SWIGTYPE_p_ofVboMesh); } arg2 = (ofPolyRenderMode)(int)lua_tonumber(L, 2); - ((ofVboMesh const *)arg1)->draw(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VboMesh_draw(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVboMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_VboMesh_draw__SWIG_0_0(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVboMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_VboMesh_draw__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'VboMesh_draw'\n" " Possible C/C++ prototypes are:\n" - " draw() const\n" " ofVboMesh::draw(ofPolyRenderMode) const\n"); lua_error(L);return 0; } -static int _wrap_VboMesh_drawInstanced(lua_State* L) { int SWIG_arg = 0; ofVboMesh *arg1 = (ofVboMesh *) 0 ; - ofPolyRenderMode arg2 ; int arg3 ; SWIG_check_num_args("ofVboMesh::drawInstanced",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVboMesh::drawInstanced",1,"ofVboMesh const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVboMesh::drawInstanced",2,"ofPolyRenderMode"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVboMesh::drawInstanced",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVboMesh,0))){ - SWIG_fail_ptr("VboMesh_drawInstanced",1,SWIGTYPE_p_ofVboMesh); } arg2 = (ofPolyRenderMode)(int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); ((ofVboMesh const *)arg1)->drawInstanced(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_VboMesh_getVbo__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVboMesh *arg1 = (ofVboMesh *) 0 ; - ofVbo *result = 0 ; SWIG_check_num_args("ofVboMesh::getVbo",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVboMesh::getVbo",1,"ofVboMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVboMesh,0))){ - SWIG_fail_ptr("VboMesh_getVbo",1,SWIGTYPE_p_ofVboMesh); } result = (ofVbo *) &(arg1)->getVbo(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVbo,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_VboMesh_getVbo__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVboMesh *arg1 = (ofVboMesh *) 0 ; - ofVbo *result = 0 ; SWIG_check_num_args("ofVboMesh::getVbo",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVboMesh::getVbo",1,"ofVboMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVboMesh,0))){ - SWIG_fail_ptr("VboMesh_getVbo",1,SWIGTYPE_p_ofVboMesh); } result = (ofVbo *) &((ofVboMesh const *)arg1)->getVbo(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVbo,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_VboMesh_getVbo(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVboMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_VboMesh_getVbo__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVboMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_VboMesh_getVbo__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'VboMesh_getVbo'\n" " Possible C/C++ prototypes are:\n" - " ofVboMesh::getVbo()\n" " ofVboMesh::getVbo() const\n"); lua_error(L);return 0; } -static void swig_delete_VboMesh(void *obj) { -ofVboMesh *arg1 = (ofVboMesh *) obj; -delete arg1; -} -static int _proxy__wrap_new_VboMesh(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_VboMesh); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_VboMesh_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_VboMesh_methods[]= { - { "setUsage", _wrap_VboMesh_setUsage}, - { "draw", _wrap_VboMesh_draw}, - { "drawInstanced", _wrap_VboMesh_drawInstanced}, - { "getVbo", _wrap_VboMesh_getVbo}, - {0,0} -}; -static swig_lua_method swig_VboMesh_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_VboMesh_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_VboMesh_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_VboMesh_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_VboMesh_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_VboMesh_Sf_SwigStatic = { - "VboMesh", - swig_VboMesh_Sf_SwigStatic_methods, - swig_VboMesh_Sf_SwigStatic_attributes, - swig_VboMesh_Sf_SwigStatic_constants, - swig_VboMesh_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_VboMesh_bases[] = {0,0}; -static const char *swig_VboMesh_base_names[] = {"ofMesh *",0}; -static swig_lua_class _wrap_class_VboMesh = { "VboMesh", "VboMesh", &SWIGTYPE_p_ofVboMesh,_proxy__wrap_new_VboMesh, swig_delete_VboMesh, swig_VboMesh_methods, swig_VboMesh_attributes, &swig_VboMesh_Sf_SwigStatic, swig_VboMesh_meta, swig_VboMesh_bases, swig_VboMesh_base_names }; - -static int _wrap_new_Pixels__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPixels_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofPixels_< unsigned char >::ofPixels_",0,0) - result = (ofPixels_< unsigned char > *)new ofPixels_< unsigned char >(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofPixels_T_unsigned_char_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_Pixels__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPixels_< unsigned char > *arg1 = 0 ; - ofPixels_< unsigned char > *result = 0 ; SWIG_check_num_args("ofPixels_< unsigned char >::ofPixels_",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::ofPixels_",1,"ofPixels_< unsigned char > &&"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("new_Pixels",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - result = (ofPixels_< unsigned char > *)new ofPixels_< unsigned char >((ofPixels_< unsigned char > &&)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofPixels_T_unsigned_char_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_Pixels(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_Pixels__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_new_Pixels__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_Pixels'\n" " Possible C/C++ prototypes are:\n" - " ofPixels_< unsigned char >::ofPixels_()\n" " ofPixels_< unsigned char >::ofPixels_(ofPixels_< unsigned char > &&)\n"); - lua_error(L);return 0; } -static int _wrap_Pixels_allocate(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; size_t arg2 ; size_t arg3 ; size_t arg4 ; - SWIG_check_num_args("ofPixels_< unsigned char >::allocate",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::allocate",1,"ofPixels_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::allocate",2,"size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned char >::allocate",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< unsigned char >::allocate",4,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_allocate",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (size_t)lua_tonumber(L, 4); - (arg1)->allocate(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_allocatePixelFormat(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; size_t arg2 ; size_t arg3 ; ofPixelFormat arg4 ; - SWIG_check_num_args("ofPixels_< unsigned char >::allocate",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::allocate",1,"ofPixels_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::allocate",2,"size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned char >::allocate",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< unsigned char >::allocate",4,"ofPixelFormat"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_allocatePixelFormat",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - arg4 = (ofPixelFormat)(int)lua_tonumber(L, 4); (arg1)->allocate(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_allocateImageType(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; size_t arg2 ; size_t arg3 ; ofImageType arg4 ; - SWIG_check_num_args("ofPixels_< unsigned char >::allocate",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::allocate",1,"ofPixels_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::allocate",2,"size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned char >::allocate",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< unsigned char >::allocate",4,"ofImageType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_allocateImageType",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - arg4 = (ofImageType)(int)lua_tonumber(L, 4); (arg1)->allocate(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_isAllocated(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; bool result; - SWIG_check_num_args("ofPixels_< unsigned char >::isAllocated",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::isAllocated",1,"ofPixels_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_isAllocated",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - result = (bool)((ofPixels_< unsigned char > const *)arg1)->isAllocated(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_clear(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; - SWIG_check_num_args("ofPixels_< unsigned char >::clear",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::clear",1,"ofPixels_< unsigned char > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_clear",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } (arg1)->clear(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_set__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; unsigned char arg2 ; - SWIG_check_num_args("ofPixels_< unsigned char >::set",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::set",1,"ofPixels_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::set",2,"unsigned char"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_set",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned char)lua_tonumber(L, 2); - (arg1)->set(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_set__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; size_t arg2 ; unsigned char arg3 ; - SWIG_check_num_args("ofPixels_< unsigned char >::set",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::set",1,"ofPixels_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::set",2,"size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned char >::set",3,"unsigned char"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_set",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (unsigned char)lua_tonumber(L, 3); - (arg1)->set(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_set(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Pixels_set__SWIG_0(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_Pixels_set__SWIG_1(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Pixels_set'\n" " Possible C/C++ prototypes are:\n" - " ofPixels_< unsigned char >::set(unsigned char)\n" " ofPixels_< unsigned char >::set(size_t,unsigned char)\n"); - lua_error(L);return 0; } -static int _wrap_Pixels_setFromPixels(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; unsigned char *arg2 = (unsigned char *) 0 ; - size_t arg3 ; size_t arg4 ; ofPixelFormat arg5 ; SWIG_check_num_args("ofPixels_< unsigned char >::setFromPixels",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::setFromPixels",1,"ofPixels_< unsigned char > *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::setFromPixels",2,"unsigned char const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned char >::setFromPixels",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< unsigned char >::setFromPixels",4,"size_t"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPixels_< unsigned char >::setFromPixels",5,"ofPixelFormat"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_setFromPixels",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_unsigned_char,0))){ - SWIG_fail_ptr("Pixels_setFromPixels",2,SWIGTYPE_p_unsigned_char); } - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (size_t)lua_tonumber(L, 4); - arg5 = (ofPixelFormat)(int)lua_tonumber(L, 5); (arg1)->setFromPixels((unsigned char const *)arg2,arg3,arg4,arg5); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_setFromPixelsImageType(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; unsigned char *arg2 = (unsigned char *) 0 ; - size_t arg3 ; size_t arg4 ; ofImageType arg5 ; SWIG_check_num_args("ofPixels_< unsigned char >::setFromPixels",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::setFromPixels",1,"ofPixels_< unsigned char > *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::setFromPixels",2,"unsigned char const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned char >::setFromPixels",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< unsigned char >::setFromPixels",4,"size_t"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPixels_< unsigned char >::setFromPixels",5,"ofImageType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_setFromPixelsImageType",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_unsigned_char,0))){ - SWIG_fail_ptr("Pixels_setFromPixelsImageType",2,SWIGTYPE_p_unsigned_char); } - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (size_t)lua_tonumber(L, 4); - arg5 = (ofImageType)(int)lua_tonumber(L, 5); (arg1)->setFromPixels((unsigned char const *)arg2,arg3,arg4,arg5); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_setFromExternalPixels(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; unsigned char *arg2 = (unsigned char *) 0 ; - size_t arg3 ; size_t arg4 ; ofPixelFormat arg5 ; SWIG_check_num_args("ofPixels_< unsigned char >::setFromExternalPixels",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::setFromExternalPixels",1,"ofPixels_< unsigned char > *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::setFromExternalPixels",2,"unsigned char *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned char >::setFromExternalPixels",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< unsigned char >::setFromExternalPixels",4,"size_t"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPixels_< unsigned char >::setFromExternalPixels",5,"ofPixelFormat"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_setFromExternalPixels",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_unsigned_char,0))){ - SWIG_fail_ptr("Pixels_setFromExternalPixels",2,SWIGTYPE_p_unsigned_char); } - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (size_t)lua_tonumber(L, 4); - arg5 = (ofPixelFormat)(int)lua_tonumber(L, 5); (arg1)->setFromExternalPixels(arg2,arg3,arg4,arg5); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_setFromAlignedPixels(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; unsigned char *arg2 = (unsigned char *) 0 ; - size_t arg3 ; size_t arg4 ; ofPixelFormat arg5 ; size_t arg6 ; - SWIG_check_num_args("ofPixels_< unsigned char >::setFromAlignedPixels",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::setFromAlignedPixels",1,"ofPixels_< unsigned char > *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::setFromAlignedPixels",2,"unsigned char const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned char >::setFromAlignedPixels",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< unsigned char >::setFromAlignedPixels",4,"size_t"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPixels_< unsigned char >::setFromAlignedPixels",5,"ofPixelFormat"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPixels_< unsigned char >::setFromAlignedPixels",6,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_setFromAlignedPixels",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_unsigned_char,0))){ - SWIG_fail_ptr("Pixels_setFromAlignedPixels",2,SWIGTYPE_p_unsigned_char); } - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (size_t)lua_tonumber(L, 4); - arg5 = (ofPixelFormat)(int)lua_tonumber(L, 5); SWIG_contract_assert((lua_tonumber(L,6)>=0),"number must not be negative") - arg6 = (size_t)lua_tonumber(L, 6); (arg1)->setFromAlignedPixels((unsigned char const *)arg2,arg3,arg4,arg5,arg6); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_swap(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; ofPixels_< unsigned char > *arg2 = 0 ; - SWIG_check_num_args("ofPixels_< unsigned char >::swap",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::swap",1,"ofPixels_< unsigned char > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::swap",2,"ofPixels_< unsigned char > &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_swap",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_swap",2,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } (arg1)->swap(*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_crop(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; size_t arg2 ; size_t arg3 ; size_t arg4 ; size_t arg5 ; - SWIG_check_num_args("ofPixels_< unsigned char >::crop",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::crop",1,"ofPixels_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::crop",2,"size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned char >::crop",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< unsigned char >::crop",4,"size_t"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPixels_< unsigned char >::crop",5,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_crop",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (size_t)lua_tonumber(L, 4); - SWIG_contract_assert((lua_tonumber(L,5)>=0),"number must not be negative") arg5 = (size_t)lua_tonumber(L, 5); - (arg1)->crop(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_cropTo(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; ofPixels_< unsigned char > *arg2 = 0 ; size_t arg3 ; - size_t arg4 ; size_t arg5 ; size_t arg6 ; SWIG_check_num_args("ofPixels_< unsigned char >::cropTo",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::cropTo",1,"ofPixels_< unsigned char > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::cropTo",2,"ofPixels_< unsigned char > &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned char >::cropTo",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< unsigned char >::cropTo",4,"size_t"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPixels_< unsigned char >::cropTo",5,"size_t"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPixels_< unsigned char >::cropTo",6,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_cropTo",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_cropTo",2,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (size_t)lua_tonumber(L, 4); - SWIG_contract_assert((lua_tonumber(L,5)>=0),"number must not be negative") arg5 = (size_t)lua_tonumber(L, 5); - SWIG_contract_assert((lua_tonumber(L,6)>=0),"number must not be negative") arg6 = (size_t)lua_tonumber(L, 6); - ((ofPixels_< unsigned char > const *)arg1)->cropTo(*arg2,arg3,arg4,arg5,arg6); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_rotate90(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; int arg2 ; - SWIG_check_num_args("ofPixels_< unsigned char >::rotate90",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::rotate90",1,"ofPixels_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::rotate90",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_rotate90",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->rotate90(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_rotate90To(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; ofPixels_< unsigned char > *arg2 = 0 ; int arg3 ; - SWIG_check_num_args("ofPixels_< unsigned char >::rotate90To",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::rotate90To",1,"ofPixels_< unsigned char > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::rotate90To",2,"ofPixels_< unsigned char > &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned char >::rotate90To",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_rotate90To",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_rotate90To",2,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } arg3 = (int)lua_tonumber(L, 3); - ((ofPixels_< unsigned char > const *)arg1)->rotate90To(*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Pixels_mirrorTo(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; ofPixels_< unsigned char > *arg2 = 0 ; bool arg3 ; - bool arg4 ; SWIG_check_num_args("ofPixels_< unsigned char >::mirrorTo",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::mirrorTo",1,"ofPixels_< unsigned char > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::mirrorTo",2,"ofPixels_< unsigned char > &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofPixels_< unsigned char >::mirrorTo",3,"bool"); - if(!lua_isboolean(L,4)) SWIG_fail_arg("ofPixels_< unsigned char >::mirrorTo",4,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_mirrorTo",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_mirrorTo",2,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } arg3 = (lua_toboolean(L, 3)!=0); - arg4 = (lua_toboolean(L, 4)!=0); ((ofPixels_< unsigned char > const *)arg1)->mirrorTo(*arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_mirror(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; bool arg2 ; bool arg3 ; - SWIG_check_num_args("ofPixels_< unsigned char >::mirror",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::mirror",1,"ofPixels_< unsigned char > *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::mirror",2,"bool"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofPixels_< unsigned char >::mirror",3,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_mirror",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } arg2 = (lua_toboolean(L, 2)!=0); - arg3 = (lua_toboolean(L, 3)!=0); (arg1)->mirror(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Pixels_resize__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; size_t arg2 ; size_t arg3 ; ofInterpolationMethod arg4 ; - bool result; SWIG_check_num_args("ofPixels_< unsigned char >::resize",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::resize",1,"ofPixels_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::resize",2,"size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned char >::resize",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< unsigned char >::resize",4,"ofInterpolationMethod"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_resize",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - arg4 = (ofInterpolationMethod)(int)lua_tonumber(L, 4); result = (bool)(arg1)->resize(arg2,arg3,arg4); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_resize__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; size_t arg2 ; size_t arg3 ; bool result; - SWIG_check_num_args("ofPixels_< unsigned char >::resize",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::resize",1,"ofPixels_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::resize",2,"size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned char >::resize",3,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_resize",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - result = (bool)(arg1)->resize(arg2,arg3); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_resize(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_Pixels_resize__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Pixels_resize__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Pixels_resize'\n" " Possible C/C++ prototypes are:\n" - " ofPixels_< unsigned char >::resize(size_t,size_t,ofInterpolationMethod)\n" - " ofPixels_< unsigned char >::resize(size_t,size_t)\n"); lua_error(L);return 0; } -static int _wrap_Pixels_resizeTo__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; ofPixels_< unsigned char > *arg2 = 0 ; - ofInterpolationMethod arg3 ; bool result; SWIG_check_num_args("ofPixels_< unsigned char >::resizeTo",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::resizeTo",1,"ofPixels_< unsigned char > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::resizeTo",2,"ofPixels_< unsigned char > &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned char >::resizeTo",3,"ofInterpolationMethod"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_resizeTo",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_resizeTo",2,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - arg3 = (ofInterpolationMethod)(int)lua_tonumber(L, 3); - result = (bool)((ofPixels_< unsigned char > const *)arg1)->resizeTo(*arg2,arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_resizeTo__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; ofPixels_< unsigned char > *arg2 = 0 ; bool result; - SWIG_check_num_args("ofPixels_< unsigned char >::resizeTo",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::resizeTo",1,"ofPixels_< unsigned char > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::resizeTo",2,"ofPixels_< unsigned char > &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_resizeTo",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_resizeTo",2,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - result = (bool)((ofPixels_< unsigned char > const *)arg1)->resizeTo(*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_resizeTo(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Pixels_resizeTo__SWIG_1(L);} } } if (argc == 3) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Pixels_resizeTo__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Pixels_resizeTo'\n" " Possible C/C++ prototypes are:\n" - " ofPixels_< unsigned char >::resizeTo(ofPixels_< unsigned char > &,ofInterpolationMethod) const\n" - " ofPixels_< unsigned char >::resizeTo(ofPixels_< unsigned char > &) const\n"); lua_error(L);return 0; } -static int _wrap_Pixels_pasteInto(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; ofPixels_< unsigned char > *arg2 = 0 ; size_t arg3 ; - size_t arg4 ; bool result; SWIG_check_num_args("ofPixels_< unsigned char >::pasteInto",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::pasteInto",1,"ofPixels_< unsigned char > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::pasteInto",2,"ofPixels_< unsigned char > &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned char >::pasteInto",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< unsigned char >::pasteInto",4,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_pasteInto",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_pasteInto",2,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (size_t)lua_tonumber(L, 4); - result = (bool)((ofPixels_< unsigned char > const *)arg1)->pasteInto(*arg2,arg3,arg4); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_blendInto(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; ofPixels_< unsigned char > *arg2 = 0 ; size_t arg3 ; - size_t arg4 ; bool result; SWIG_check_num_args("ofPixels_< unsigned char >::blendInto",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::blendInto",1,"ofPixels_< unsigned char > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::blendInto",2,"ofPixels_< unsigned char > &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned char >::blendInto",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< unsigned char >::blendInto",4,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_blendInto",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_blendInto",2,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (size_t)lua_tonumber(L, 4); - result = (bool)((ofPixels_< unsigned char > const *)arg1)->blendInto(*arg2,arg3,arg4); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_swapRgb(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; - SWIG_check_num_args("ofPixels_< unsigned char >::swapRgb",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::swapRgb",1,"ofPixels_< unsigned char > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_swapRgb",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } (arg1)->swapRgb(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_getData__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; unsigned char *result = 0 ; - SWIG_check_num_args("ofPixels_< unsigned char >::getData",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::getData",1,"ofPixels_< unsigned char > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_getData",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } result = (unsigned char *)(arg1)->getData(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_unsigned_char,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Pixels_getData__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; unsigned char *result = 0 ; - SWIG_check_num_args("ofPixels_< unsigned char >::getData",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::getData",1,"ofPixels_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_getData",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - result = (unsigned char *)((ofPixels_< unsigned char > const *)arg1)->getData(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_unsigned_char,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Pixels_getData(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Pixels_getData__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Pixels_getData__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Pixels_getData'\n" " Possible C/C++ prototypes are:\n" - " ofPixels_< unsigned char >::getData()\n" " ofPixels_< unsigned char >::getData() const\n"); lua_error(L);return 0; } -static int _wrap_Pixels_getPixelIndex(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; size_t arg2 ; size_t arg3 ; size_t result; - SWIG_check_num_args("ofPixels_< unsigned char >::getPixelIndex",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::getPixelIndex",1,"ofPixels_< unsigned char > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::getPixelIndex",2,"size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned char >::getPixelIndex",3,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_getPixelIndex",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - result = (size_t)((ofPixels_< unsigned char > const *)arg1)->getPixelIndex(arg2,arg3); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_getColor__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; size_t arg2 ; size_t arg3 ; - ofColor_< unsigned char > result; SWIG_check_num_args("ofPixels_< unsigned char >::getColor",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::getColor",1,"ofPixels_< unsigned char > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::getColor",2,"size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned char >::getColor",3,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_getColor",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - result = ((ofPixels_< unsigned char > const *)arg1)->getColor(arg2,arg3); { - ofColor_< unsigned char > * resultptr = new ofColor_< unsigned char >((const ofColor_< unsigned char > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_getColor__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; size_t arg2 ; ofColor_< unsigned char > result; - SWIG_check_num_args("ofPixels_< unsigned char >::getColor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::getColor",1,"ofPixels_< unsigned char > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::getColor",2,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_getColor",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - result = ((ofPixels_< unsigned char > const *)arg1)->getColor(arg2); { - ofColor_< unsigned char > * resultptr = new ofColor_< unsigned char >((const ofColor_< unsigned char > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_getColor(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Pixels_getColor__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_Pixels_getColor__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Pixels_getColor'\n" " Possible C/C++ prototypes are:\n" - " ofPixels_< unsigned char >::getColor(size_t,size_t) const\n" " ofPixels_< unsigned char >::getColor(size_t) const\n"); - lua_error(L);return 0; } -static int _wrap_Pixels_setColor__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; size_t arg2 ; size_t arg3 ; - ofColor_< unsigned char > *arg4 = 0 ; SWIG_check_num_args("ofPixels_< unsigned char >::setColor",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::setColor",1,"ofPixels_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::setColor",2,"size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned char >::setColor",3,"size_t"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofPixels_< unsigned char >::setColor",4,"ofColor_< unsigned char > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_setColor",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_setColor",4,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - (arg1)->setColor(arg2,arg3,(ofColor_< unsigned char > const &)*arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Pixels_setColor__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; size_t arg2 ; ofColor_< unsigned char > *arg3 = 0 ; - SWIG_check_num_args("ofPixels_< unsigned char >::setColor",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::setColor",1,"ofPixels_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::setColor",2,"size_t"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofPixels_< unsigned char >::setColor",3,"ofColor_< unsigned char > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_setColor",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_setColor",3,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - (arg1)->setColor(arg2,(ofColor_< unsigned char > const &)*arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Pixels_setColor__SWIG_2(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; ofColor_< unsigned char > *arg2 = 0 ; - SWIG_check_num_args("ofPixels_< unsigned char >::setColor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::setColor",1,"ofPixels_< unsigned char > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::setColor",2,"ofColor_< unsigned char > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_setColor",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_setColor",2,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - (arg1)->setColor((ofColor_< unsigned char > const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Pixels_setColor(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Pixels_setColor__SWIG_2(L);} } } if (argc == 3) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Pixels_setColor__SWIG_1(L);} } } } if (argc == 4) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Pixels_setColor__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Pixels_setColor'\n" " Possible C/C++ prototypes are:\n" - " ofPixels_< unsigned char >::setColor(size_t,size_t,ofColor_< unsigned char > const &)\n" - " ofPixels_< unsigned char >::setColor(size_t,ofColor_< unsigned char > const &)\n" - " ofPixels_< unsigned char >::setColor(ofColor_< unsigned char > const &)\n"); lua_error(L);return 0; } -static int _wrap_Pixels_getWidth(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; size_t result; - SWIG_check_num_args("ofPixels_< unsigned char >::getWidth",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::getWidth",1,"ofPixels_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_getWidth",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - result = (size_t)((ofPixels_< unsigned char > const *)arg1)->getWidth(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_getHeight(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; size_t result; - SWIG_check_num_args("ofPixels_< unsigned char >::getHeight",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::getHeight",1,"ofPixels_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_getHeight",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - result = (size_t)((ofPixels_< unsigned char > const *)arg1)->getHeight(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_getBytesPerPixel(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; size_t result; - SWIG_check_num_args("ofPixels_< unsigned char >::getBytesPerPixel",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::getBytesPerPixel",1,"ofPixels_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_getBytesPerPixel",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - result = (size_t)((ofPixels_< unsigned char > const *)arg1)->getBytesPerPixel(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_getBitsPerPixel(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; size_t result; - SWIG_check_num_args("ofPixels_< unsigned char >::getBitsPerPixel",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::getBitsPerPixel",1,"ofPixels_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_getBitsPerPixel",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - result = (size_t)((ofPixels_< unsigned char > const *)arg1)->getBitsPerPixel(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_getBytesPerChannel(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; size_t result; - SWIG_check_num_args("ofPixels_< unsigned char >::getBytesPerChannel",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::getBytesPerChannel",1,"ofPixels_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_getBytesPerChannel",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - result = (size_t)((ofPixels_< unsigned char > const *)arg1)->getBytesPerChannel(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_getBitsPerChannel(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; size_t result; - SWIG_check_num_args("ofPixels_< unsigned char >::getBitsPerChannel",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::getBitsPerChannel",1,"ofPixels_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_getBitsPerChannel",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - result = (size_t)((ofPixels_< unsigned char > const *)arg1)->getBitsPerChannel(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_getBytesStride(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; size_t result; - SWIG_check_num_args("ofPixels_< unsigned char >::getBytesStride",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::getBytesStride",1,"ofPixels_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_getBytesStride",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - result = (size_t)((ofPixels_< unsigned char > const *)arg1)->getBytesStride(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_getNumChannels(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; size_t result; - SWIG_check_num_args("ofPixels_< unsigned char >::getNumChannels",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::getNumChannels",1,"ofPixels_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_getNumChannels",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - result = (size_t)((ofPixels_< unsigned char > const *)arg1)->getNumChannels(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_getTotalBytes(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; size_t result; - SWIG_check_num_args("ofPixels_< unsigned char >::getTotalBytes",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::getTotalBytes",1,"ofPixels_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_getTotalBytes",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - result = (size_t)((ofPixels_< unsigned char > const *)arg1)->getTotalBytes(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_getNumPlanes(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; size_t result; - SWIG_check_num_args("ofPixels_< unsigned char >::getNumPlanes",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::getNumPlanes",1,"ofPixels_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_getNumPlanes",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - result = (size_t)((ofPixels_< unsigned char > const *)arg1)->getNumPlanes(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_getPlane(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; size_t arg2 ; ofPixels_< unsigned char > result; - SWIG_check_num_args("ofPixels_< unsigned char >::getPlane",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::getPlane",1,"ofPixels_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::getPlane",2,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_getPlane",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - result = (arg1)->getPlane(arg2); { - ofPixels_< unsigned char > * resultptr = new ofPixels_< unsigned char >((const ofPixels_< unsigned char > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofPixels_T_unsigned_char_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_getChannel(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; size_t arg2 ; ofPixels_< unsigned char > result; - SWIG_check_num_args("ofPixels_< unsigned char >::getChannel",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::getChannel",1,"ofPixels_< unsigned char > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::getChannel",2,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_getChannel",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - result = ((ofPixels_< unsigned char > const *)arg1)->getChannel(arg2); { - ofPixels_< unsigned char > * resultptr = new ofPixels_< unsigned char >((const ofPixels_< unsigned char > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofPixels_T_unsigned_char_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_getPixelFormat(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; ofPixelFormat result; - SWIG_check_num_args("ofPixels_< unsigned char >::getPixelFormat",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::getPixelFormat",1,"ofPixels_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_getPixelFormat",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - result = (ofPixelFormat)((ofPixels_< unsigned char > const *)arg1)->getPixelFormat(); - lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Pixels_size(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; size_t result; - SWIG_check_num_args("ofPixels_< unsigned char >::size",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::size",1,"ofPixels_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_size",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - result = (size_t)((ofPixels_< unsigned char > const *)arg1)->size(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_getImageType(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; ofImageType result; - SWIG_check_num_args("ofPixels_< unsigned char >::getImageType",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::getImageType",1,"ofPixels_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_getImageType",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - result = (ofImageType)((ofPixels_< unsigned char > const *)arg1)->getImageType(); - lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Pixels_setChannel(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; size_t arg2 ; ofPixels_< unsigned char > arg3 ; - ofPixels_< unsigned char > *argp3 ; SWIG_check_num_args("ofPixels_< unsigned char >::setChannel",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::setChannel",1,"ofPixels_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::setChannel",2,"size_t"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofPixels_< unsigned char >::setChannel",3,"ofPixels_< unsigned char > const"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_setChannel",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&argp3,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_setChannel",3,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } arg3 = *argp3; (arg1)->setChannel(arg2,arg3); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_setImageType(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; ofImageType arg2 ; - SWIG_check_num_args("ofPixels_< unsigned char >::setImageType",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::setImageType",1,"ofPixels_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::setImageType",2,"ofImageType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_setImageType",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - arg2 = (ofImageType)(int)lua_tonumber(L, 2); (arg1)->setImageType(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Pixels_setNumChannels(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; size_t arg2 ; - SWIG_check_num_args("ofPixels_< unsigned char >::setNumChannels",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::setNumChannels",1,"ofPixels_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::setNumChannels",2,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_setNumChannels",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - (arg1)->setNumChannels(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_Pixels(void *obj) { -ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) obj; -delete arg1; -} -static int _proxy__wrap_new_Pixels(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_Pixels); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_Pixels_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_Pixels_methods[]= { - { "allocate", _wrap_Pixels_allocate}, - { "allocatePixelFormat", _wrap_Pixels_allocatePixelFormat}, - { "allocateImageType", _wrap_Pixels_allocateImageType}, - { "isAllocated", _wrap_Pixels_isAllocated}, - { "clear", _wrap_Pixels_clear}, - { "set", _wrap_Pixels_set}, - { "setFromPixels", _wrap_Pixels_setFromPixels}, - { "setFromPixelsImageType", _wrap_Pixels_setFromPixelsImageType}, - { "setFromExternalPixels", _wrap_Pixels_setFromExternalPixels}, - { "setFromAlignedPixels", _wrap_Pixels_setFromAlignedPixels}, - { "swap", _wrap_Pixels_swap}, - { "crop", _wrap_Pixels_crop}, - { "cropTo", _wrap_Pixels_cropTo}, - { "rotate90", _wrap_Pixels_rotate90}, - { "rotate90To", _wrap_Pixels_rotate90To}, - { "mirrorTo", _wrap_Pixels_mirrorTo}, - { "mirror", _wrap_Pixels_mirror}, - { "resize", _wrap_Pixels_resize}, - { "resizeTo", _wrap_Pixels_resizeTo}, - { "pasteInto", _wrap_Pixels_pasteInto}, - { "blendInto", _wrap_Pixels_blendInto}, - { "swapRgb", _wrap_Pixels_swapRgb}, - { "getData", _wrap_Pixels_getData}, - { "getPixelIndex", _wrap_Pixels_getPixelIndex}, - { "getColor", _wrap_Pixels_getColor}, - { "setColor", _wrap_Pixels_setColor}, - { "getWidth", _wrap_Pixels_getWidth}, - { "getHeight", _wrap_Pixels_getHeight}, - { "getBytesPerPixel", _wrap_Pixels_getBytesPerPixel}, - { "getBitsPerPixel", _wrap_Pixels_getBitsPerPixel}, - { "getBytesPerChannel", _wrap_Pixels_getBytesPerChannel}, - { "getBitsPerChannel", _wrap_Pixels_getBitsPerChannel}, - { "getBytesStride", _wrap_Pixels_getBytesStride}, - { "getNumChannels", _wrap_Pixels_getNumChannels}, - { "getTotalBytes", _wrap_Pixels_getTotalBytes}, - { "getNumPlanes", _wrap_Pixels_getNumPlanes}, - { "getPlane", _wrap_Pixels_getPlane}, - { "getChannel", _wrap_Pixels_getChannel}, - { "getPixelFormat", _wrap_Pixels_getPixelFormat}, - { "size", _wrap_Pixels_size}, - { "getImageType", _wrap_Pixels_getImageType}, - { "setChannel", _wrap_Pixels_setChannel}, - { "setImageType", _wrap_Pixels_setImageType}, - { "setNumChannels", _wrap_Pixels_setNumChannels}, - {0,0} -}; -static swig_lua_method swig_Pixels_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_Pixels_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_Pixels_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_Pixels_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_Pixels_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_Pixels_Sf_SwigStatic = { - "Pixels", - swig_Pixels_Sf_SwigStatic_methods, - swig_Pixels_Sf_SwigStatic_attributes, - swig_Pixels_Sf_SwigStatic_constants, - swig_Pixels_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_Pixels_bases[] = {0}; -static const char *swig_Pixels_base_names[] = {0}; -static swig_lua_class _wrap_class_Pixels = { "Pixels", "Pixels", &SWIGTYPE_p_ofPixels_T_unsigned_char_t,_proxy__wrap_new_Pixels, swig_delete_Pixels, swig_Pixels_methods, swig_Pixels_attributes, &swig_Pixels_Sf_SwigStatic, swig_Pixels_meta, swig_Pixels_bases, swig_Pixels_base_names }; - -static int _wrap_new_FloatPixels__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPixels_< float > *result = 0 ; - SWIG_check_num_args("ofPixels_< float >::ofPixels_",0,0) result = (ofPixels_< float > *)new ofPixels_< float >(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofPixels_T_float_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_FloatPixels__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPixels_< float > *arg1 = 0 ; - ofPixels_< float > *result = 0 ; SWIG_check_num_args("ofPixels_< float >::ofPixels_",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofPixels_< float >::ofPixels_",1,"ofPixels_< float > &&"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("new_FloatPixels",1,SWIGTYPE_p_ofPixels_T_float_t); } - result = (ofPixels_< float > *)new ofPixels_< float >((ofPixels_< float > &&)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofPixels_T_float_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_FloatPixels(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_FloatPixels__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_new_FloatPixels__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_FloatPixels'\n" " Possible C/C++ prototypes are:\n" - " ofPixels_< float >::ofPixels_()\n" " ofPixels_< float >::ofPixels_(ofPixels_< float > &&)\n"); lua_error(L);return 0; } -static int _wrap_FloatPixels_allocate(lua_State* L) { int SWIG_arg = 0; ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; - size_t arg2 ; size_t arg3 ; size_t arg4 ; SWIG_check_num_args("ofPixels_< float >::allocate",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::allocate",1,"ofPixels_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< float >::allocate",2,"size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< float >::allocate",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< float >::allocate",4,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_allocate",1,SWIGTYPE_p_ofPixels_T_float_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (size_t)lua_tonumber(L, 4); - (arg1)->allocate(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_allocatePixelFormat(lua_State* L) { int SWIG_arg = 0; - ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; size_t arg2 ; size_t arg3 ; ofPixelFormat arg4 ; - SWIG_check_num_args("ofPixels_< float >::allocate",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::allocate",1,"ofPixels_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< float >::allocate",2,"size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< float >::allocate",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< float >::allocate",4,"ofPixelFormat"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_allocatePixelFormat",1,SWIGTYPE_p_ofPixels_T_float_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - arg4 = (ofPixelFormat)(int)lua_tonumber(L, 4); (arg1)->allocate(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_allocateImageType(lua_State* L) { int SWIG_arg = 0; - ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; size_t arg2 ; size_t arg3 ; ofImageType arg4 ; - SWIG_check_num_args("ofPixels_< float >::allocate",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::allocate",1,"ofPixels_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< float >::allocate",2,"size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< float >::allocate",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< float >::allocate",4,"ofImageType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_allocateImageType",1,SWIGTYPE_p_ofPixels_T_float_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - arg4 = (ofImageType)(int)lua_tonumber(L, 4); (arg1)->allocate(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_isAllocated(lua_State* L) { int SWIG_arg = 0; ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; - bool result; SWIG_check_num_args("ofPixels_< float >::isAllocated",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::isAllocated",1,"ofPixels_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_isAllocated",1,SWIGTYPE_p_ofPixels_T_float_t); } - result = (bool)((ofPixels_< float > const *)arg1)->isAllocated(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_clear(lua_State* L) { int SWIG_arg = 0; ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; - SWIG_check_num_args("ofPixels_< float >::clear",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::clear",1,"ofPixels_< float > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_clear",1,SWIGTYPE_p_ofPixels_T_float_t); } (arg1)->clear(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_set__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; - float arg2 ; SWIG_check_num_args("ofPixels_< float >::set",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::set",1,"ofPixels_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< float >::set",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_set",1,SWIGTYPE_p_ofPixels_T_float_t); } arg2 = (float)lua_tonumber(L, 2); (arg1)->set(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_set__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; - size_t arg2 ; float arg3 ; SWIG_check_num_args("ofPixels_< float >::set",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::set",1,"ofPixels_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< float >::set",2,"size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< float >::set",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_set",1,SWIGTYPE_p_ofPixels_T_float_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->set(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FloatPixels_set(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_FloatPixels_set__SWIG_0(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_FloatPixels_set__SWIG_1(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatPixels_set'\n" " Possible C/C++ prototypes are:\n" - " ofPixels_< float >::set(float)\n" " ofPixels_< float >::set(size_t,float)\n"); lua_error(L);return 0; } -static int _wrap_FloatPixels_setFromPixels(lua_State* L) { int SWIG_arg = 0; - ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; float *arg2 = (float *) 0 ; size_t arg3 ; size_t arg4 ; - ofPixelFormat arg5 ; SWIG_check_num_args("ofPixels_< float >::setFromPixels",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::setFromPixels",1,"ofPixels_< float > *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofPixels_< float >::setFromPixels",2,"float const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< float >::setFromPixels",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< float >::setFromPixels",4,"size_t"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPixels_< float >::setFromPixels",5,"ofPixelFormat"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_setFromPixels",1,SWIGTYPE_p_ofPixels_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("FloatPixels_setFromPixels",2,SWIGTYPE_p_float); } - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (size_t)lua_tonumber(L, 4); - arg5 = (ofPixelFormat)(int)lua_tonumber(L, 5); (arg1)->setFromPixels((float const *)arg2,arg3,arg4,arg5); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_setFromPixelsImageType(lua_State* L) { int SWIG_arg = 0; - ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; float *arg2 = (float *) 0 ; size_t arg3 ; size_t arg4 ; - ofImageType arg5 ; SWIG_check_num_args("ofPixels_< float >::setFromPixels",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::setFromPixels",1,"ofPixels_< float > *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofPixels_< float >::setFromPixels",2,"float const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< float >::setFromPixels",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< float >::setFromPixels",4,"size_t"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPixels_< float >::setFromPixels",5,"ofImageType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_setFromPixelsImageType",1,SWIGTYPE_p_ofPixels_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("FloatPixels_setFromPixelsImageType",2,SWIGTYPE_p_float); } - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (size_t)lua_tonumber(L, 4); - arg5 = (ofImageType)(int)lua_tonumber(L, 5); (arg1)->setFromPixels((float const *)arg2,arg3,arg4,arg5); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_setFromExternalPixels(lua_State* L) { int SWIG_arg = 0; - ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; float *arg2 = (float *) 0 ; size_t arg3 ; size_t arg4 ; - ofPixelFormat arg5 ; SWIG_check_num_args("ofPixels_< float >::setFromExternalPixels",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::setFromExternalPixels",1,"ofPixels_< float > *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofPixels_< float >::setFromExternalPixels",2,"float *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< float >::setFromExternalPixels",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< float >::setFromExternalPixels",4,"size_t"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPixels_< float >::setFromExternalPixels",5,"ofPixelFormat"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_setFromExternalPixels",1,SWIGTYPE_p_ofPixels_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("FloatPixels_setFromExternalPixels",2,SWIGTYPE_p_float); } - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (size_t)lua_tonumber(L, 4); - arg5 = (ofPixelFormat)(int)lua_tonumber(L, 5); (arg1)->setFromExternalPixels(arg2,arg3,arg4,arg5); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_setFromAlignedPixels(lua_State* L) { int SWIG_arg = 0; - ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; float *arg2 = (float *) 0 ; size_t arg3 ; size_t arg4 ; - ofPixelFormat arg5 ; size_t arg6 ; SWIG_check_num_args("ofPixels_< float >::setFromAlignedPixels",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::setFromAlignedPixels",1,"ofPixels_< float > *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofPixels_< float >::setFromAlignedPixels",2,"float const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< float >::setFromAlignedPixels",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< float >::setFromAlignedPixels",4,"size_t"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPixels_< float >::setFromAlignedPixels",5,"ofPixelFormat"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPixels_< float >::setFromAlignedPixels",6,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_setFromAlignedPixels",1,SWIGTYPE_p_ofPixels_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("FloatPixels_setFromAlignedPixels",2,SWIGTYPE_p_float); } - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (size_t)lua_tonumber(L, 4); - arg5 = (ofPixelFormat)(int)lua_tonumber(L, 5); SWIG_contract_assert((lua_tonumber(L,6)>=0),"number must not be negative") - arg6 = (size_t)lua_tonumber(L, 6); (arg1)->setFromAlignedPixels((float const *)arg2,arg3,arg4,arg5,arg6); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_swap(lua_State* L) { int SWIG_arg = 0; ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; - ofPixels_< float > *arg2 = 0 ; SWIG_check_num_args("ofPixels_< float >::swap",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::swap",1,"ofPixels_< float > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPixels_< float >::swap",2,"ofPixels_< float > &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_swap",1,SWIGTYPE_p_ofPixels_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_swap",2,SWIGTYPE_p_ofPixels_T_float_t); } (arg1)->swap(*arg2); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_crop(lua_State* L) { int SWIG_arg = 0; ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; - size_t arg2 ; size_t arg3 ; size_t arg4 ; size_t arg5 ; SWIG_check_num_args("ofPixels_< float >::crop",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::crop",1,"ofPixels_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< float >::crop",2,"size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< float >::crop",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< float >::crop",4,"size_t"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPixels_< float >::crop",5,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_crop",1,SWIGTYPE_p_ofPixels_T_float_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (size_t)lua_tonumber(L, 4); - SWIG_contract_assert((lua_tonumber(L,5)>=0),"number must not be negative") arg5 = (size_t)lua_tonumber(L, 5); - (arg1)->crop(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_cropTo(lua_State* L) { int SWIG_arg = 0; ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; - ofPixels_< float > *arg2 = 0 ; size_t arg3 ; size_t arg4 ; size_t arg5 ; size_t arg6 ; - SWIG_check_num_args("ofPixels_< float >::cropTo",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::cropTo",1,"ofPixels_< float > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPixels_< float >::cropTo",2,"ofPixels_< float > &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< float >::cropTo",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< float >::cropTo",4,"size_t"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPixels_< float >::cropTo",5,"size_t"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPixels_< float >::cropTo",6,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_cropTo",1,SWIGTYPE_p_ofPixels_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_cropTo",2,SWIGTYPE_p_ofPixels_T_float_t); } - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (size_t)lua_tonumber(L, 4); - SWIG_contract_assert((lua_tonumber(L,5)>=0),"number must not be negative") arg5 = (size_t)lua_tonumber(L, 5); - SWIG_contract_assert((lua_tonumber(L,6)>=0),"number must not be negative") arg6 = (size_t)lua_tonumber(L, 6); - ((ofPixels_< float > const *)arg1)->cropTo(*arg2,arg3,arg4,arg5,arg6); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FloatPixels_rotate90(lua_State* L) { int SWIG_arg = 0; ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; - int arg2 ; SWIG_check_num_args("ofPixels_< float >::rotate90",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::rotate90",1,"ofPixels_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< float >::rotate90",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_rotate90",1,SWIGTYPE_p_ofPixels_T_float_t); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->rotate90(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_rotate90To(lua_State* L) { int SWIG_arg = 0; ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; - ofPixels_< float > *arg2 = 0 ; int arg3 ; SWIG_check_num_args("ofPixels_< float >::rotate90To",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::rotate90To",1,"ofPixels_< float > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPixels_< float >::rotate90To",2,"ofPixels_< float > &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< float >::rotate90To",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_rotate90To",1,SWIGTYPE_p_ofPixels_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_rotate90To",2,SWIGTYPE_p_ofPixels_T_float_t); } arg3 = (int)lua_tonumber(L, 3); - ((ofPixels_< float > const *)arg1)->rotate90To(*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FloatPixels_mirrorTo(lua_State* L) { int SWIG_arg = 0; ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; - ofPixels_< float > *arg2 = 0 ; bool arg3 ; bool arg4 ; SWIG_check_num_args("ofPixels_< float >::mirrorTo",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::mirrorTo",1,"ofPixels_< float > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPixels_< float >::mirrorTo",2,"ofPixels_< float > &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofPixels_< float >::mirrorTo",3,"bool"); - if(!lua_isboolean(L,4)) SWIG_fail_arg("ofPixels_< float >::mirrorTo",4,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_mirrorTo",1,SWIGTYPE_p_ofPixels_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_mirrorTo",2,SWIGTYPE_p_ofPixels_T_float_t); } arg3 = (lua_toboolean(L, 3)!=0); - arg4 = (lua_toboolean(L, 4)!=0); ((ofPixels_< float > const *)arg1)->mirrorTo(*arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_mirror(lua_State* L) { int SWIG_arg = 0; ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; - bool arg2 ; bool arg3 ; SWIG_check_num_args("ofPixels_< float >::mirror",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::mirror",1,"ofPixels_< float > *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofPixels_< float >::mirror",2,"bool"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofPixels_< float >::mirror",3,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_mirror",1,SWIGTYPE_p_ofPixels_T_float_t); } arg2 = (lua_toboolean(L, 2)!=0); - arg3 = (lua_toboolean(L, 3)!=0); (arg1)->mirror(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FloatPixels_resize__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; size_t arg2 ; size_t arg3 ; ofInterpolationMethod arg4 ; bool result; - SWIG_check_num_args("ofPixels_< float >::resize",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::resize",1,"ofPixels_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< float >::resize",2,"size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< float >::resize",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< float >::resize",4,"ofInterpolationMethod"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_resize",1,SWIGTYPE_p_ofPixels_T_float_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - arg4 = (ofInterpolationMethod)(int)lua_tonumber(L, 4); result = (bool)(arg1)->resize(arg2,arg3,arg4); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_resize__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; size_t arg2 ; size_t arg3 ; bool result; - SWIG_check_num_args("ofPixels_< float >::resize",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::resize",1,"ofPixels_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< float >::resize",2,"size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< float >::resize",3,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_resize",1,SWIGTYPE_p_ofPixels_T_float_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - result = (bool)(arg1)->resize(arg2,arg3); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_resize(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_FloatPixels_resize__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_FloatPixels_resize__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatPixels_resize'\n" " Possible C/C++ prototypes are:\n" - " ofPixels_< float >::resize(size_t,size_t,ofInterpolationMethod)\n" " ofPixels_< float >::resize(size_t,size_t)\n"); - lua_error(L);return 0; } -static int _wrap_FloatPixels_resizeTo__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; ofPixels_< float > *arg2 = 0 ; ofInterpolationMethod arg3 ; bool result; - SWIG_check_num_args("ofPixels_< float >::resizeTo",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::resizeTo",1,"ofPixels_< float > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPixels_< float >::resizeTo",2,"ofPixels_< float > &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< float >::resizeTo",3,"ofInterpolationMethod"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_resizeTo",1,SWIGTYPE_p_ofPixels_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_resizeTo",2,SWIGTYPE_p_ofPixels_T_float_t); } - arg3 = (ofInterpolationMethod)(int)lua_tonumber(L, 3); - result = (bool)((ofPixels_< float > const *)arg1)->resizeTo(*arg2,arg3); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_resizeTo__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; ofPixels_< float > *arg2 = 0 ; bool result; - SWIG_check_num_args("ofPixels_< float >::resizeTo",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::resizeTo",1,"ofPixels_< float > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPixels_< float >::resizeTo",2,"ofPixels_< float > &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_resizeTo",1,SWIGTYPE_p_ofPixels_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_resizeTo",2,SWIGTYPE_p_ofPixels_T_float_t); } - result = (bool)((ofPixels_< float > const *)arg1)->resizeTo(*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_resizeTo(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_FloatPixels_resizeTo__SWIG_1(L);} } } if (argc == 3) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_FloatPixels_resizeTo__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatPixels_resizeTo'\n" - " Possible C/C++ prototypes are:\n" " ofPixels_< float >::resizeTo(ofPixels_< float > &,ofInterpolationMethod) const\n" - " ofPixels_< float >::resizeTo(ofPixels_< float > &) const\n"); lua_error(L);return 0; } -static int _wrap_FloatPixels_pasteInto(lua_State* L) { int SWIG_arg = 0; ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; - ofPixels_< float > *arg2 = 0 ; size_t arg3 ; size_t arg4 ; bool result; - SWIG_check_num_args("ofPixels_< float >::pasteInto",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::pasteInto",1,"ofPixels_< float > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPixels_< float >::pasteInto",2,"ofPixels_< float > &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< float >::pasteInto",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< float >::pasteInto",4,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_pasteInto",1,SWIGTYPE_p_ofPixels_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_pasteInto",2,SWIGTYPE_p_ofPixels_T_float_t); } - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (size_t)lua_tonumber(L, 4); - result = (bool)((ofPixels_< float > const *)arg1)->pasteInto(*arg2,arg3,arg4); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_blendInto(lua_State* L) { int SWIG_arg = 0; ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; - ofPixels_< float > *arg2 = 0 ; size_t arg3 ; size_t arg4 ; bool result; - SWIG_check_num_args("ofPixels_< float >::blendInto",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::blendInto",1,"ofPixels_< float > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPixels_< float >::blendInto",2,"ofPixels_< float > &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< float >::blendInto",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< float >::blendInto",4,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_blendInto",1,SWIGTYPE_p_ofPixels_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_blendInto",2,SWIGTYPE_p_ofPixels_T_float_t); } - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (size_t)lua_tonumber(L, 4); - result = (bool)((ofPixels_< float > const *)arg1)->blendInto(*arg2,arg3,arg4); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_swapRgb(lua_State* L) { int SWIG_arg = 0; ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; - SWIG_check_num_args("ofPixels_< float >::swapRgb",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::swapRgb",1,"ofPixels_< float > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_swapRgb",1,SWIGTYPE_p_ofPixels_T_float_t); } (arg1)->swapRgb(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_getData__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; float *result = 0 ; - SWIG_check_num_args("ofPixels_< float >::getData",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::getData",1,"ofPixels_< float > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_getData",1,SWIGTYPE_p_ofPixels_T_float_t); } result = (float *)(arg1)->getData(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_float,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FloatPixels_getData__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; float *result = 0 ; - SWIG_check_num_args("ofPixels_< float >::getData",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::getData",1,"ofPixels_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_getData",1,SWIGTYPE_p_ofPixels_T_float_t); } - result = (float *)((ofPixels_< float > const *)arg1)->getData(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_float,0); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_getData(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_FloatPixels_getData__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_FloatPixels_getData__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatPixels_getData'\n" - " Possible C/C++ prototypes are:\n" " ofPixels_< float >::getData()\n" " ofPixels_< float >::getData() const\n"); - lua_error(L);return 0; } -static int _wrap_FloatPixels_getPixelIndex(lua_State* L) { int SWIG_arg = 0; - ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; size_t arg2 ; size_t arg3 ; size_t result; - SWIG_check_num_args("ofPixels_< float >::getPixelIndex",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::getPixelIndex",1,"ofPixels_< float > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< float >::getPixelIndex",2,"size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< float >::getPixelIndex",3,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_getPixelIndex",1,SWIGTYPE_p_ofPixels_T_float_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - result = (size_t)((ofPixels_< float > const *)arg1)->getPixelIndex(arg2,arg3); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_getColor__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; size_t arg2 ; size_t arg3 ; ofColor_< float > result; - SWIG_check_num_args("ofPixels_< float >::getColor",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::getColor",1,"ofPixels_< float > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< float >::getColor",2,"size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< float >::getColor",3,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_getColor",1,SWIGTYPE_p_ofPixels_T_float_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - result = ((ofPixels_< float > const *)arg1)->getColor(arg2,arg3); { - ofColor_< float > * resultptr = new ofColor_< float >((const ofColor_< float > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_getColor__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; size_t arg2 ; ofColor_< float > result; - SWIG_check_num_args("ofPixels_< float >::getColor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::getColor",1,"ofPixels_< float > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< float >::getColor",2,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_getColor",1,SWIGTYPE_p_ofPixels_T_float_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - result = ((ofPixels_< float > const *)arg1)->getColor(arg2); { - ofColor_< float > * resultptr = new ofColor_< float >((const ofColor_< float > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_getColor(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_FloatPixels_getColor__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_FloatPixels_getColor__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatPixels_getColor'\n" - " Possible C/C++ prototypes are:\n" " ofPixels_< float >::getColor(size_t,size_t) const\n" - " ofPixels_< float >::getColor(size_t) const\n"); lua_error(L);return 0; } -static int _wrap_FloatPixels_setColor__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; size_t arg2 ; size_t arg3 ; ofColor_< float > *arg4 = 0 ; - SWIG_check_num_args("ofPixels_< float >::setColor",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::setColor",1,"ofPixels_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< float >::setColor",2,"size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< float >::setColor",3,"size_t"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofPixels_< float >::setColor",4,"ofColor_< float > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_setColor",1,SWIGTYPE_p_ofPixels_T_float_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_setColor",4,SWIGTYPE_p_ofColor_T_float_t); } - (arg1)->setColor(arg2,arg3,(ofColor_< float > const &)*arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FloatPixels_setColor__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; size_t arg2 ; ofColor_< float > *arg3 = 0 ; - SWIG_check_num_args("ofPixels_< float >::setColor",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::setColor",1,"ofPixels_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< float >::setColor",2,"size_t"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofPixels_< float >::setColor",3,"ofColor_< float > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_setColor",1,SWIGTYPE_p_ofPixels_T_float_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_setColor",3,SWIGTYPE_p_ofColor_T_float_t); } - (arg1)->setColor(arg2,(ofColor_< float > const &)*arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FloatPixels_setColor__SWIG_2(lua_State* L) { int SWIG_arg = 0; - ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; ofColor_< float > *arg2 = 0 ; - SWIG_check_num_args("ofPixels_< float >::setColor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::setColor",1,"ofPixels_< float > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPixels_< float >::setColor",2,"ofColor_< float > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_setColor",1,SWIGTYPE_p_ofPixels_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_setColor",2,SWIGTYPE_p_ofColor_T_float_t); } (arg1)->setColor((ofColor_< float > const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_setColor(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_FloatPixels_setColor__SWIG_2(L);} } } if (argc == 3) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_FloatPixels_setColor__SWIG_1(L);} } } } if (argc == 4) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_FloatPixels_setColor__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatPixels_setColor'\n" - " Possible C/C++ prototypes are:\n" " ofPixels_< float >::setColor(size_t,size_t,ofColor_< float > const &)\n" - " ofPixels_< float >::setColor(size_t,ofColor_< float > const &)\n" - " ofPixels_< float >::setColor(ofColor_< float > const &)\n"); lua_error(L);return 0; } -static int _wrap_FloatPixels_getWidth(lua_State* L) { int SWIG_arg = 0; ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; - size_t result; SWIG_check_num_args("ofPixels_< float >::getWidth",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::getWidth",1,"ofPixels_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_getWidth",1,SWIGTYPE_p_ofPixels_T_float_t); } - result = (size_t)((ofPixels_< float > const *)arg1)->getWidth(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_getHeight(lua_State* L) { int SWIG_arg = 0; ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; - size_t result; SWIG_check_num_args("ofPixels_< float >::getHeight",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::getHeight",1,"ofPixels_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_getHeight",1,SWIGTYPE_p_ofPixels_T_float_t); } - result = (size_t)((ofPixels_< float > const *)arg1)->getHeight(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_getBytesPerPixel(lua_State* L) { int SWIG_arg = 0; - ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; size_t result; - SWIG_check_num_args("ofPixels_< float >::getBytesPerPixel",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::getBytesPerPixel",1,"ofPixels_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_getBytesPerPixel",1,SWIGTYPE_p_ofPixels_T_float_t); } - result = (size_t)((ofPixels_< float > const *)arg1)->getBytesPerPixel(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_getBitsPerPixel(lua_State* L) { int SWIG_arg = 0; - ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; size_t result; - SWIG_check_num_args("ofPixels_< float >::getBitsPerPixel",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::getBitsPerPixel",1,"ofPixels_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_getBitsPerPixel",1,SWIGTYPE_p_ofPixels_T_float_t); } - result = (size_t)((ofPixels_< float > const *)arg1)->getBitsPerPixel(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_getBytesPerChannel(lua_State* L) { int SWIG_arg = 0; - ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; size_t result; - SWIG_check_num_args("ofPixels_< float >::getBytesPerChannel",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::getBytesPerChannel",1,"ofPixels_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_getBytesPerChannel",1,SWIGTYPE_p_ofPixels_T_float_t); } - result = (size_t)((ofPixels_< float > const *)arg1)->getBytesPerChannel(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_getBitsPerChannel(lua_State* L) { int SWIG_arg = 0; - ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; size_t result; - SWIG_check_num_args("ofPixels_< float >::getBitsPerChannel",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::getBitsPerChannel",1,"ofPixels_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_getBitsPerChannel",1,SWIGTYPE_p_ofPixels_T_float_t); } - result = (size_t)((ofPixels_< float > const *)arg1)->getBitsPerChannel(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_getBytesStride(lua_State* L) { int SWIG_arg = 0; - ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; size_t result; - SWIG_check_num_args("ofPixels_< float >::getBytesStride",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::getBytesStride",1,"ofPixels_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_getBytesStride",1,SWIGTYPE_p_ofPixels_T_float_t); } - result = (size_t)((ofPixels_< float > const *)arg1)->getBytesStride(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_getNumChannels(lua_State* L) { int SWIG_arg = 0; - ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; size_t result; - SWIG_check_num_args("ofPixels_< float >::getNumChannels",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::getNumChannels",1,"ofPixels_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_getNumChannels",1,SWIGTYPE_p_ofPixels_T_float_t); } - result = (size_t)((ofPixels_< float > const *)arg1)->getNumChannels(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_getTotalBytes(lua_State* L) { int SWIG_arg = 0; - ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; size_t result; - SWIG_check_num_args("ofPixels_< float >::getTotalBytes",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::getTotalBytes",1,"ofPixels_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_getTotalBytes",1,SWIGTYPE_p_ofPixels_T_float_t); } - result = (size_t)((ofPixels_< float > const *)arg1)->getTotalBytes(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_getNumPlanes(lua_State* L) { int SWIG_arg = 0; - ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; size_t result; - SWIG_check_num_args("ofPixels_< float >::getNumPlanes",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::getNumPlanes",1,"ofPixels_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_getNumPlanes",1,SWIGTYPE_p_ofPixels_T_float_t); } - result = (size_t)((ofPixels_< float > const *)arg1)->getNumPlanes(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_getPlane(lua_State* L) { int SWIG_arg = 0; ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; - size_t arg2 ; ofPixels_< float > result; SWIG_check_num_args("ofPixels_< float >::getPlane",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::getPlane",1,"ofPixels_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< float >::getPlane",2,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_getPlane",1,SWIGTYPE_p_ofPixels_T_float_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - result = (arg1)->getPlane(arg2); { - ofPixels_< float > * resultptr = new ofPixels_< float >((const ofPixels_< float > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofPixels_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_getChannel(lua_State* L) { int SWIG_arg = 0; ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; - size_t arg2 ; ofPixels_< float > result; SWIG_check_num_args("ofPixels_< float >::getChannel",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::getChannel",1,"ofPixels_< float > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< float >::getChannel",2,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_getChannel",1,SWIGTYPE_p_ofPixels_T_float_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - result = ((ofPixels_< float > const *)arg1)->getChannel(arg2); { - ofPixels_< float > * resultptr = new ofPixels_< float >((const ofPixels_< float > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofPixels_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_getPixelFormat(lua_State* L) { int SWIG_arg = 0; - ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; ofPixelFormat result; - SWIG_check_num_args("ofPixels_< float >::getPixelFormat",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::getPixelFormat",1,"ofPixels_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_getPixelFormat",1,SWIGTYPE_p_ofPixels_T_float_t); } - result = (ofPixelFormat)((ofPixels_< float > const *)arg1)->getPixelFormat(); - lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FloatPixels_size(lua_State* L) { int SWIG_arg = 0; ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; - size_t result; SWIG_check_num_args("ofPixels_< float >::size",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::size",1,"ofPixels_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_size",1,SWIGTYPE_p_ofPixels_T_float_t); } - result = (size_t)((ofPixels_< float > const *)arg1)->size(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_getImageType(lua_State* L) { int SWIG_arg = 0; - ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; ofImageType result; - SWIG_check_num_args("ofPixels_< float >::getImageType",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::getImageType",1,"ofPixels_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_getImageType",1,SWIGTYPE_p_ofPixels_T_float_t); } - result = (ofImageType)((ofPixels_< float > const *)arg1)->getImageType(); - lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FloatPixels_setChannel(lua_State* L) { int SWIG_arg = 0; ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; - size_t arg2 ; ofPixels_< float > arg3 ; ofPixels_< float > *argp3 ; SWIG_check_num_args("ofPixels_< float >::setChannel",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::setChannel",1,"ofPixels_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< float >::setChannel",2,"size_t"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofPixels_< float >::setChannel",3,"ofPixels_< float > const"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_setChannel",1,SWIGTYPE_p_ofPixels_T_float_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&argp3,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_setChannel",3,SWIGTYPE_p_ofPixels_T_float_t); } arg3 = *argp3; (arg1)->setChannel(arg2,arg3); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_setImageType(lua_State* L) { int SWIG_arg = 0; - ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; ofImageType arg2 ; - SWIG_check_num_args("ofPixels_< float >::setImageType",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::setImageType",1,"ofPixels_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< float >::setImageType",2,"ofImageType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_setImageType",1,SWIGTYPE_p_ofPixels_T_float_t); } arg2 = (ofImageType)(int)lua_tonumber(L, 2); - (arg1)->setImageType(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_setNumChannels(lua_State* L) { int SWIG_arg = 0; - ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; size_t arg2 ; - SWIG_check_num_args("ofPixels_< float >::setNumChannels",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::setNumChannels",1,"ofPixels_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< float >::setNumChannels",2,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_setNumChannels",1,SWIGTYPE_p_ofPixels_T_float_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - (arg1)->setNumChannels(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_FloatPixels(void *obj) { -ofPixels_< float > *arg1 = (ofPixels_< float > *) obj; -delete arg1; -} -static int _proxy__wrap_new_FloatPixels(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_FloatPixels); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_FloatPixels_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_FloatPixels_methods[]= { - { "allocate", _wrap_FloatPixels_allocate}, - { "allocatePixelFormat", _wrap_FloatPixels_allocatePixelFormat}, - { "allocateImageType", _wrap_FloatPixels_allocateImageType}, - { "isAllocated", _wrap_FloatPixels_isAllocated}, - { "clear", _wrap_FloatPixels_clear}, - { "set", _wrap_FloatPixels_set}, - { "setFromPixels", _wrap_FloatPixels_setFromPixels}, - { "setFromPixelsImageType", _wrap_FloatPixels_setFromPixelsImageType}, - { "setFromExternalPixels", _wrap_FloatPixels_setFromExternalPixels}, - { "setFromAlignedPixels", _wrap_FloatPixels_setFromAlignedPixels}, - { "swap", _wrap_FloatPixels_swap}, - { "crop", _wrap_FloatPixels_crop}, - { "cropTo", _wrap_FloatPixels_cropTo}, - { "rotate90", _wrap_FloatPixels_rotate90}, - { "rotate90To", _wrap_FloatPixels_rotate90To}, - { "mirrorTo", _wrap_FloatPixels_mirrorTo}, - { "mirror", _wrap_FloatPixels_mirror}, - { "resize", _wrap_FloatPixels_resize}, - { "resizeTo", _wrap_FloatPixels_resizeTo}, - { "pasteInto", _wrap_FloatPixels_pasteInto}, - { "blendInto", _wrap_FloatPixels_blendInto}, - { "swapRgb", _wrap_FloatPixels_swapRgb}, - { "getData", _wrap_FloatPixels_getData}, - { "getPixelIndex", _wrap_FloatPixels_getPixelIndex}, - { "getColor", _wrap_FloatPixels_getColor}, - { "setColor", _wrap_FloatPixels_setColor}, - { "getWidth", _wrap_FloatPixels_getWidth}, - { "getHeight", _wrap_FloatPixels_getHeight}, - { "getBytesPerPixel", _wrap_FloatPixels_getBytesPerPixel}, - { "getBitsPerPixel", _wrap_FloatPixels_getBitsPerPixel}, - { "getBytesPerChannel", _wrap_FloatPixels_getBytesPerChannel}, - { "getBitsPerChannel", _wrap_FloatPixels_getBitsPerChannel}, - { "getBytesStride", _wrap_FloatPixels_getBytesStride}, - { "getNumChannels", _wrap_FloatPixels_getNumChannels}, - { "getTotalBytes", _wrap_FloatPixels_getTotalBytes}, - { "getNumPlanes", _wrap_FloatPixels_getNumPlanes}, - { "getPlane", _wrap_FloatPixels_getPlane}, - { "getChannel", _wrap_FloatPixels_getChannel}, - { "getPixelFormat", _wrap_FloatPixels_getPixelFormat}, - { "size", _wrap_FloatPixels_size}, - { "getImageType", _wrap_FloatPixels_getImageType}, - { "setChannel", _wrap_FloatPixels_setChannel}, - { "setImageType", _wrap_FloatPixels_setImageType}, - { "setNumChannels", _wrap_FloatPixels_setNumChannels}, - {0,0} -}; -static swig_lua_method swig_FloatPixels_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_FloatPixels_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_FloatPixels_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_FloatPixels_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_FloatPixels_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_FloatPixels_Sf_SwigStatic = { - "FloatPixels", - swig_FloatPixels_Sf_SwigStatic_methods, - swig_FloatPixels_Sf_SwigStatic_attributes, - swig_FloatPixels_Sf_SwigStatic_constants, - swig_FloatPixels_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_FloatPixels_bases[] = {0}; -static const char *swig_FloatPixels_base_names[] = {0}; -static swig_lua_class _wrap_class_FloatPixels = { "FloatPixels", "FloatPixels", &SWIGTYPE_p_ofPixels_T_float_t,_proxy__wrap_new_FloatPixels, swig_delete_FloatPixels, swig_FloatPixels_methods, swig_FloatPixels_attributes, &swig_FloatPixels_Sf_SwigStatic, swig_FloatPixels_meta, swig_FloatPixels_bases, swig_FloatPixels_base_names }; - -static int _wrap_new_ShortPixels__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPixels_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofPixels_< unsigned short >::ofPixels_",0,0) - result = (ofPixels_< unsigned short > *)new ofPixels_< unsigned short >(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofPixels_T_unsigned_short_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_ShortPixels__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPixels_< unsigned short > *arg1 = 0 ; - ofPixels_< unsigned short > *result = 0 ; SWIG_check_num_args("ofPixels_< unsigned short >::ofPixels_",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::ofPixels_",1,"ofPixels_< unsigned short > &&"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("new_ShortPixels",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - result = (ofPixels_< unsigned short > *)new ofPixels_< unsigned short >((ofPixels_< unsigned short > &&)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofPixels_T_unsigned_short_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_ShortPixels(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_ShortPixels__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_new_ShortPixels__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_ShortPixels'\n" " Possible C/C++ prototypes are:\n" - " ofPixels_< unsigned short >::ofPixels_()\n" - " ofPixels_< unsigned short >::ofPixels_(ofPixels_< unsigned short > &&)\n"); lua_error(L);return 0; } -static int _wrap_ShortPixels_allocate(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; size_t arg2 ; size_t arg3 ; size_t arg4 ; - SWIG_check_num_args("ofPixels_< unsigned short >::allocate",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::allocate",1,"ofPixels_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::allocate",2,"size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned short >::allocate",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< unsigned short >::allocate",4,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_allocate",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (size_t)lua_tonumber(L, 4); - (arg1)->allocate(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_allocatePixelFormat(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; size_t arg2 ; size_t arg3 ; ofPixelFormat arg4 ; - SWIG_check_num_args("ofPixels_< unsigned short >::allocate",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::allocate",1,"ofPixels_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::allocate",2,"size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned short >::allocate",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< unsigned short >::allocate",4,"ofPixelFormat"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_allocatePixelFormat",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - arg4 = (ofPixelFormat)(int)lua_tonumber(L, 4); (arg1)->allocate(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_allocateImageType(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; size_t arg2 ; size_t arg3 ; ofImageType arg4 ; - SWIG_check_num_args("ofPixels_< unsigned short >::allocate",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::allocate",1,"ofPixels_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::allocate",2,"size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned short >::allocate",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< unsigned short >::allocate",4,"ofImageType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_allocateImageType",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - arg4 = (ofImageType)(int)lua_tonumber(L, 4); (arg1)->allocate(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_isAllocated(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; bool result; - SWIG_check_num_args("ofPixels_< unsigned short >::isAllocated",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::isAllocated",1,"ofPixels_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_isAllocated",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - result = (bool)((ofPixels_< unsigned short > const *)arg1)->isAllocated(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_clear(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; - SWIG_check_num_args("ofPixels_< unsigned short >::clear",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::clear",1,"ofPixels_< unsigned short > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_clear",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } (arg1)->clear(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_set__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; unsigned short arg2 ; - SWIG_check_num_args("ofPixels_< unsigned short >::set",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::set",1,"ofPixels_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::set",2,"unsigned short"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_set",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned short)lua_tonumber(L, 2); - (arg1)->set(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_set__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; size_t arg2 ; unsigned short arg3 ; - SWIG_check_num_args("ofPixels_< unsigned short >::set",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::set",1,"ofPixels_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::set",2,"size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned short >::set",3,"unsigned short"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_set",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (unsigned short)lua_tonumber(L, 3); - (arg1)->set(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_set(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_ShortPixels_set__SWIG_0(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_ShortPixels_set__SWIG_1(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortPixels_set'\n" " Possible C/C++ prototypes are:\n" - " ofPixels_< unsigned short >::set(unsigned short)\n" " ofPixels_< unsigned short >::set(size_t,unsigned short)\n"); - lua_error(L);return 0; } -static int _wrap_ShortPixels_setFromPixels(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; unsigned short *arg2 = (unsigned short *) 0 ; - size_t arg3 ; size_t arg4 ; ofPixelFormat arg5 ; SWIG_check_num_args("ofPixels_< unsigned short >::setFromPixels",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::setFromPixels",1,"ofPixels_< unsigned short > *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::setFromPixels",2,"unsigned short const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned short >::setFromPixels",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< unsigned short >::setFromPixels",4,"size_t"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPixels_< unsigned short >::setFromPixels",5,"ofPixelFormat"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_setFromPixels",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_unsigned_short,0))){ - SWIG_fail_ptr("ShortPixels_setFromPixels",2,SWIGTYPE_p_unsigned_short); } - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (size_t)lua_tonumber(L, 4); - arg5 = (ofPixelFormat)(int)lua_tonumber(L, 5); (arg1)->setFromPixels((unsigned short const *)arg2,arg3,arg4,arg5); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_setFromPixelsImageType(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; unsigned short *arg2 = (unsigned short *) 0 ; - size_t arg3 ; size_t arg4 ; ofImageType arg5 ; SWIG_check_num_args("ofPixels_< unsigned short >::setFromPixels",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::setFromPixels",1,"ofPixels_< unsigned short > *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::setFromPixels",2,"unsigned short const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned short >::setFromPixels",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< unsigned short >::setFromPixels",4,"size_t"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPixels_< unsigned short >::setFromPixels",5,"ofImageType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_setFromPixelsImageType",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_unsigned_short,0))){ - SWIG_fail_ptr("ShortPixels_setFromPixelsImageType",2,SWIGTYPE_p_unsigned_short); } - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (size_t)lua_tonumber(L, 4); - arg5 = (ofImageType)(int)lua_tonumber(L, 5); (arg1)->setFromPixels((unsigned short const *)arg2,arg3,arg4,arg5); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_setFromExternalPixels(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; unsigned short *arg2 = (unsigned short *) 0 ; - size_t arg3 ; size_t arg4 ; ofPixelFormat arg5 ; SWIG_check_num_args("ofPixels_< unsigned short >::setFromExternalPixels",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::setFromExternalPixels",1,"ofPixels_< unsigned short > *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::setFromExternalPixels",2,"unsigned short *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned short >::setFromExternalPixels",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< unsigned short >::setFromExternalPixels",4,"size_t"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPixels_< unsigned short >::setFromExternalPixels",5,"ofPixelFormat"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_setFromExternalPixels",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_unsigned_short,0))){ - SWIG_fail_ptr("ShortPixels_setFromExternalPixels",2,SWIGTYPE_p_unsigned_short); } - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (size_t)lua_tonumber(L, 4); - arg5 = (ofPixelFormat)(int)lua_tonumber(L, 5); (arg1)->setFromExternalPixels(arg2,arg3,arg4,arg5); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_setFromAlignedPixels(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; unsigned short *arg2 = (unsigned short *) 0 ; - size_t arg3 ; size_t arg4 ; ofPixelFormat arg5 ; size_t arg6 ; - SWIG_check_num_args("ofPixels_< unsigned short >::setFromAlignedPixels",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::setFromAlignedPixels",1,"ofPixels_< unsigned short > *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::setFromAlignedPixels",2,"unsigned short const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned short >::setFromAlignedPixels",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< unsigned short >::setFromAlignedPixels",4,"size_t"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPixels_< unsigned short >::setFromAlignedPixels",5,"ofPixelFormat"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPixels_< unsigned short >::setFromAlignedPixels",6,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_setFromAlignedPixels",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_unsigned_short,0))){ - SWIG_fail_ptr("ShortPixels_setFromAlignedPixels",2,SWIGTYPE_p_unsigned_short); } - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (size_t)lua_tonumber(L, 4); - arg5 = (ofPixelFormat)(int)lua_tonumber(L, 5); SWIG_contract_assert((lua_tonumber(L,6)>=0),"number must not be negative") - arg6 = (size_t)lua_tonumber(L, 6); (arg1)->setFromAlignedPixels((unsigned short const *)arg2,arg3,arg4,arg5,arg6); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_swap(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; ofPixels_< unsigned short > *arg2 = 0 ; - SWIG_check_num_args("ofPixels_< unsigned short >::swap",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::swap",1,"ofPixels_< unsigned short > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::swap",2,"ofPixels_< unsigned short > &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_swap",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_swap",2,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } (arg1)->swap(*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_crop(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; size_t arg2 ; size_t arg3 ; size_t arg4 ; - size_t arg5 ; SWIG_check_num_args("ofPixels_< unsigned short >::crop",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::crop",1,"ofPixels_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::crop",2,"size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned short >::crop",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< unsigned short >::crop",4,"size_t"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPixels_< unsigned short >::crop",5,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_crop",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (size_t)lua_tonumber(L, 4); - SWIG_contract_assert((lua_tonumber(L,5)>=0),"number must not be negative") arg5 = (size_t)lua_tonumber(L, 5); - (arg1)->crop(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_cropTo(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; ofPixels_< unsigned short > *arg2 = 0 ; size_t arg3 ; - size_t arg4 ; size_t arg5 ; size_t arg6 ; SWIG_check_num_args("ofPixels_< unsigned short >::cropTo",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::cropTo",1,"ofPixels_< unsigned short > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::cropTo",2,"ofPixels_< unsigned short > &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned short >::cropTo",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< unsigned short >::cropTo",4,"size_t"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPixels_< unsigned short >::cropTo",5,"size_t"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPixels_< unsigned short >::cropTo",6,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_cropTo",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_cropTo",2,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (size_t)lua_tonumber(L, 4); - SWIG_contract_assert((lua_tonumber(L,5)>=0),"number must not be negative") arg5 = (size_t)lua_tonumber(L, 5); - SWIG_contract_assert((lua_tonumber(L,6)>=0),"number must not be negative") arg6 = (size_t)lua_tonumber(L, 6); - ((ofPixels_< unsigned short > const *)arg1)->cropTo(*arg2,arg3,arg4,arg5,arg6); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_rotate90(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; int arg2 ; - SWIG_check_num_args("ofPixels_< unsigned short >::rotate90",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::rotate90",1,"ofPixels_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::rotate90",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_rotate90",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->rotate90(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_rotate90To(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; ofPixels_< unsigned short > *arg2 = 0 ; int arg3 ; - SWIG_check_num_args("ofPixels_< unsigned short >::rotate90To",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::rotate90To",1,"ofPixels_< unsigned short > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::rotate90To",2,"ofPixels_< unsigned short > &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned short >::rotate90To",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_rotate90To",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_rotate90To",2,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } arg3 = (int)lua_tonumber(L, 3); - ((ofPixels_< unsigned short > const *)arg1)->rotate90To(*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortPixels_mirrorTo(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; ofPixels_< unsigned short > *arg2 = 0 ; bool arg3 ; - bool arg4 ; SWIG_check_num_args("ofPixels_< unsigned short >::mirrorTo",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::mirrorTo",1,"ofPixels_< unsigned short > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::mirrorTo",2,"ofPixels_< unsigned short > &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofPixels_< unsigned short >::mirrorTo",3,"bool"); - if(!lua_isboolean(L,4)) SWIG_fail_arg("ofPixels_< unsigned short >::mirrorTo",4,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_mirrorTo",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_mirrorTo",2,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } arg3 = (lua_toboolean(L, 3)!=0); - arg4 = (lua_toboolean(L, 4)!=0); ((ofPixels_< unsigned short > const *)arg1)->mirrorTo(*arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_mirror(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; bool arg2 ; bool arg3 ; - SWIG_check_num_args("ofPixels_< unsigned short >::mirror",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::mirror",1,"ofPixels_< unsigned short > *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::mirror",2,"bool"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofPixels_< unsigned short >::mirror",3,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_mirror",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } arg2 = (lua_toboolean(L, 2)!=0); - arg3 = (lua_toboolean(L, 3)!=0); (arg1)->mirror(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortPixels_resize__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; size_t arg2 ; size_t arg3 ; - ofInterpolationMethod arg4 ; bool result; SWIG_check_num_args("ofPixels_< unsigned short >::resize",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::resize",1,"ofPixels_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::resize",2,"size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned short >::resize",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< unsigned short >::resize",4,"ofInterpolationMethod"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_resize",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - arg4 = (ofInterpolationMethod)(int)lua_tonumber(L, 4); result = (bool)(arg1)->resize(arg2,arg3,arg4); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_resize__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; size_t arg2 ; size_t arg3 ; bool result; - SWIG_check_num_args("ofPixels_< unsigned short >::resize",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::resize",1,"ofPixels_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::resize",2,"size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned short >::resize",3,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_resize",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - result = (bool)(arg1)->resize(arg2,arg3); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_resize(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_ShortPixels_resize__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_ShortPixels_resize__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortPixels_resize'\n" " Possible C/C++ prototypes are:\n" - " ofPixels_< unsigned short >::resize(size_t,size_t,ofInterpolationMethod)\n" - " ofPixels_< unsigned short >::resize(size_t,size_t)\n"); lua_error(L);return 0; } -static int _wrap_ShortPixels_resizeTo__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; ofPixels_< unsigned short > *arg2 = 0 ; - ofInterpolationMethod arg3 ; bool result; SWIG_check_num_args("ofPixels_< unsigned short >::resizeTo",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::resizeTo",1,"ofPixels_< unsigned short > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::resizeTo",2,"ofPixels_< unsigned short > &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned short >::resizeTo",3,"ofInterpolationMethod"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_resizeTo",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_resizeTo",2,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - arg3 = (ofInterpolationMethod)(int)lua_tonumber(L, 3); - result = (bool)((ofPixels_< unsigned short > const *)arg1)->resizeTo(*arg2,arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_resizeTo__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; ofPixels_< unsigned short > *arg2 = 0 ; bool result; - SWIG_check_num_args("ofPixels_< unsigned short >::resizeTo",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::resizeTo",1,"ofPixels_< unsigned short > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::resizeTo",2,"ofPixels_< unsigned short > &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_resizeTo",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_resizeTo",2,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - result = (bool)((ofPixels_< unsigned short > const *)arg1)->resizeTo(*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_resizeTo(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_ShortPixels_resizeTo__SWIG_1(L);} } } if (argc == 3) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_ShortPixels_resizeTo__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortPixels_resizeTo'\n" - " Possible C/C++ prototypes are:\n" - " ofPixels_< unsigned short >::resizeTo(ofPixels_< unsigned short > &,ofInterpolationMethod) const\n" - " ofPixels_< unsigned short >::resizeTo(ofPixels_< unsigned short > &) const\n"); lua_error(L);return 0; } -static int _wrap_ShortPixels_pasteInto(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; ofPixels_< unsigned short > *arg2 = 0 ; size_t arg3 ; - size_t arg4 ; bool result; SWIG_check_num_args("ofPixels_< unsigned short >::pasteInto",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::pasteInto",1,"ofPixels_< unsigned short > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::pasteInto",2,"ofPixels_< unsigned short > &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned short >::pasteInto",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< unsigned short >::pasteInto",4,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_pasteInto",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_pasteInto",2,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (size_t)lua_tonumber(L, 4); - result = (bool)((ofPixels_< unsigned short > const *)arg1)->pasteInto(*arg2,arg3,arg4); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_blendInto(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; ofPixels_< unsigned short > *arg2 = 0 ; size_t arg3 ; - size_t arg4 ; bool result; SWIG_check_num_args("ofPixels_< unsigned short >::blendInto",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::blendInto",1,"ofPixels_< unsigned short > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::blendInto",2,"ofPixels_< unsigned short > &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned short >::blendInto",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< unsigned short >::blendInto",4,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_blendInto",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_blendInto",2,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (size_t)lua_tonumber(L, 4); - result = (bool)((ofPixels_< unsigned short > const *)arg1)->blendInto(*arg2,arg3,arg4); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_swapRgb(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; - SWIG_check_num_args("ofPixels_< unsigned short >::swapRgb",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::swapRgb",1,"ofPixels_< unsigned short > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_swapRgb",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } (arg1)->swapRgb(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_getData__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; unsigned short *result = 0 ; - SWIG_check_num_args("ofPixels_< unsigned short >::getData",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::getData",1,"ofPixels_< unsigned short > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_getData",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - result = (unsigned short *)(arg1)->getData(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_unsigned_short,0); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_getData__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; unsigned short *result = 0 ; - SWIG_check_num_args("ofPixels_< unsigned short >::getData",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::getData",1,"ofPixels_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_getData",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - result = (unsigned short *)((ofPixels_< unsigned short > const *)arg1)->getData(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_unsigned_short,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortPixels_getData(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_ShortPixels_getData__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_ShortPixels_getData__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortPixels_getData'\n" - " Possible C/C++ prototypes are:\n" " ofPixels_< unsigned short >::getData()\n" - " ofPixels_< unsigned short >::getData() const\n"); lua_error(L);return 0; } -static int _wrap_ShortPixels_getPixelIndex(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; size_t arg2 ; size_t arg3 ; size_t result; - SWIG_check_num_args("ofPixels_< unsigned short >::getPixelIndex",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::getPixelIndex",1,"ofPixels_< unsigned short > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::getPixelIndex",2,"size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned short >::getPixelIndex",3,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_getPixelIndex",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - result = (size_t)((ofPixels_< unsigned short > const *)arg1)->getPixelIndex(arg2,arg3); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_getColor__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; size_t arg2 ; size_t arg3 ; - ofColor_< unsigned short > result; SWIG_check_num_args("ofPixels_< unsigned short >::getColor",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::getColor",1,"ofPixels_< unsigned short > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::getColor",2,"size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned short >::getColor",3,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_getColor",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - result = ((ofPixels_< unsigned short > const *)arg1)->getColor(arg2,arg3); { - ofColor_< unsigned short > * resultptr = new ofColor_< unsigned short >((const ofColor_< unsigned short > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_short_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_getColor__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; size_t arg2 ; ofColor_< unsigned short > result; - SWIG_check_num_args("ofPixels_< unsigned short >::getColor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::getColor",1,"ofPixels_< unsigned short > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::getColor",2,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_getColor",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - result = ((ofPixels_< unsigned short > const *)arg1)->getColor(arg2); { - ofColor_< unsigned short > * resultptr = new ofColor_< unsigned short >((const ofColor_< unsigned short > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_short_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_getColor(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_ShortPixels_getColor__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_ShortPixels_getColor__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortPixels_getColor'\n" - " Possible C/C++ prototypes are:\n" " ofPixels_< unsigned short >::getColor(size_t,size_t) const\n" - " ofPixels_< unsigned short >::getColor(size_t) const\n"); lua_error(L);return 0; } -static int _wrap_ShortPixels_setColor__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; size_t arg2 ; size_t arg3 ; - ofColor_< unsigned short > *arg4 = 0 ; SWIG_check_num_args("ofPixels_< unsigned short >::setColor",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::setColor",1,"ofPixels_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::setColor",2,"size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned short >::setColor",3,"size_t"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofPixels_< unsigned short >::setColor",4,"ofColor_< unsigned short > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_setColor",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_setColor",4,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - (arg1)->setColor(arg2,arg3,(ofColor_< unsigned short > const &)*arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortPixels_setColor__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; size_t arg2 ; ofColor_< unsigned short > *arg3 = 0 ; - SWIG_check_num_args("ofPixels_< unsigned short >::setColor",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::setColor",1,"ofPixels_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::setColor",2,"size_t"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofPixels_< unsigned short >::setColor",3,"ofColor_< unsigned short > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_setColor",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_setColor",3,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - (arg1)->setColor(arg2,(ofColor_< unsigned short > const &)*arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortPixels_setColor__SWIG_2(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; ofColor_< unsigned short > *arg2 = 0 ; - SWIG_check_num_args("ofPixels_< unsigned short >::setColor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::setColor",1,"ofPixels_< unsigned short > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::setColor",2,"ofColor_< unsigned short > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_setColor",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_setColor",2,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - (arg1)->setColor((ofColor_< unsigned short > const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortPixels_setColor(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_ShortPixels_setColor__SWIG_2(L);} } } if (argc == 3) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_ShortPixels_setColor__SWIG_1(L);} } } } if (argc == 4) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_ShortPixels_setColor__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortPixels_setColor'\n" - " Possible C/C++ prototypes are:\n" - " ofPixels_< unsigned short >::setColor(size_t,size_t,ofColor_< unsigned short > const &)\n" - " ofPixels_< unsigned short >::setColor(size_t,ofColor_< unsigned short > const &)\n" - " ofPixels_< unsigned short >::setColor(ofColor_< unsigned short > const &)\n"); lua_error(L);return 0; } -static int _wrap_ShortPixels_getWidth(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; size_t result; - SWIG_check_num_args("ofPixels_< unsigned short >::getWidth",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::getWidth",1,"ofPixels_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_getWidth",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - result = (size_t)((ofPixels_< unsigned short > const *)arg1)->getWidth(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_getHeight(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; size_t result; - SWIG_check_num_args("ofPixels_< unsigned short >::getHeight",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::getHeight",1,"ofPixels_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_getHeight",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - result = (size_t)((ofPixels_< unsigned short > const *)arg1)->getHeight(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_getBytesPerPixel(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; size_t result; - SWIG_check_num_args("ofPixels_< unsigned short >::getBytesPerPixel",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::getBytesPerPixel",1,"ofPixels_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_getBytesPerPixel",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - result = (size_t)((ofPixels_< unsigned short > const *)arg1)->getBytesPerPixel(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_getBitsPerPixel(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; size_t result; - SWIG_check_num_args("ofPixels_< unsigned short >::getBitsPerPixel",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::getBitsPerPixel",1,"ofPixels_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_getBitsPerPixel",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - result = (size_t)((ofPixels_< unsigned short > const *)arg1)->getBitsPerPixel(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_getBytesPerChannel(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; size_t result; - SWIG_check_num_args("ofPixels_< unsigned short >::getBytesPerChannel",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::getBytesPerChannel",1,"ofPixels_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_getBytesPerChannel",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - result = (size_t)((ofPixels_< unsigned short > const *)arg1)->getBytesPerChannel(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_getBitsPerChannel(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; size_t result; - SWIG_check_num_args("ofPixels_< unsigned short >::getBitsPerChannel",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::getBitsPerChannel",1,"ofPixels_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_getBitsPerChannel",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - result = (size_t)((ofPixels_< unsigned short > const *)arg1)->getBitsPerChannel(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_getBytesStride(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; size_t result; - SWIG_check_num_args("ofPixels_< unsigned short >::getBytesStride",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::getBytesStride",1,"ofPixels_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_getBytesStride",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - result = (size_t)((ofPixels_< unsigned short > const *)arg1)->getBytesStride(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_getNumChannels(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; size_t result; - SWIG_check_num_args("ofPixels_< unsigned short >::getNumChannels",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::getNumChannels",1,"ofPixels_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_getNumChannels",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - result = (size_t)((ofPixels_< unsigned short > const *)arg1)->getNumChannels(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_getTotalBytes(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; size_t result; - SWIG_check_num_args("ofPixels_< unsigned short >::getTotalBytes",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::getTotalBytes",1,"ofPixels_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_getTotalBytes",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - result = (size_t)((ofPixels_< unsigned short > const *)arg1)->getTotalBytes(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_getNumPlanes(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; size_t result; - SWIG_check_num_args("ofPixels_< unsigned short >::getNumPlanes",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::getNumPlanes",1,"ofPixels_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_getNumPlanes",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - result = (size_t)((ofPixels_< unsigned short > const *)arg1)->getNumPlanes(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_getPlane(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; size_t arg2 ; ofPixels_< unsigned short > result; - SWIG_check_num_args("ofPixels_< unsigned short >::getPlane",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::getPlane",1,"ofPixels_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::getPlane",2,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_getPlane",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - result = (arg1)->getPlane(arg2); { - ofPixels_< unsigned short > * resultptr = new ofPixels_< unsigned short >((const ofPixels_< unsigned short > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofPixels_T_unsigned_short_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_getChannel(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; size_t arg2 ; ofPixels_< unsigned short > result; - SWIG_check_num_args("ofPixels_< unsigned short >::getChannel",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::getChannel",1,"ofPixels_< unsigned short > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::getChannel",2,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_getChannel",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - result = ((ofPixels_< unsigned short > const *)arg1)->getChannel(arg2); { - ofPixels_< unsigned short > * resultptr = new ofPixels_< unsigned short >((const ofPixels_< unsigned short > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofPixels_T_unsigned_short_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_getPixelFormat(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; ofPixelFormat result; - SWIG_check_num_args("ofPixels_< unsigned short >::getPixelFormat",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::getPixelFormat",1,"ofPixels_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_getPixelFormat",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - result = (ofPixelFormat)((ofPixels_< unsigned short > const *)arg1)->getPixelFormat(); - lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortPixels_size(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; size_t result; - SWIG_check_num_args("ofPixels_< unsigned short >::size",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::size",1,"ofPixels_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_size",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - result = (size_t)((ofPixels_< unsigned short > const *)arg1)->size(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_getImageType(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; ofImageType result; - SWIG_check_num_args("ofPixels_< unsigned short >::getImageType",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::getImageType",1,"ofPixels_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_getImageType",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - result = (ofImageType)((ofPixels_< unsigned short > const *)arg1)->getImageType(); - lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortPixels_setChannel(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; size_t arg2 ; ofPixels_< unsigned short > arg3 ; - ofPixels_< unsigned short > *argp3 ; SWIG_check_num_args("ofPixels_< unsigned short >::setChannel",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::setChannel",1,"ofPixels_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::setChannel",2,"size_t"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofPixels_< unsigned short >::setChannel",3,"ofPixels_< unsigned short > const"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_setChannel",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&argp3,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_setChannel",3,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } arg3 = *argp3; - (arg1)->setChannel(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_setImageType(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; ofImageType arg2 ; - SWIG_check_num_args("ofPixels_< unsigned short >::setImageType",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::setImageType",1,"ofPixels_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::setImageType",2,"ofImageType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_setImageType",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - arg2 = (ofImageType)(int)lua_tonumber(L, 2); (arg1)->setImageType(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortPixels_setNumChannels(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; size_t arg2 ; - SWIG_check_num_args("ofPixels_< unsigned short >::setNumChannels",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::setNumChannels",1,"ofPixels_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::setNumChannels",2,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_setNumChannels",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - (arg1)->setNumChannels(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_ShortPixels(void *obj) { -ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) obj; -delete arg1; -} -static int _proxy__wrap_new_ShortPixels(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_ShortPixels); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_ShortPixels_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_ShortPixels_methods[]= { - { "allocate", _wrap_ShortPixels_allocate}, - { "allocatePixelFormat", _wrap_ShortPixels_allocatePixelFormat}, - { "allocateImageType", _wrap_ShortPixels_allocateImageType}, - { "isAllocated", _wrap_ShortPixels_isAllocated}, - { "clear", _wrap_ShortPixels_clear}, - { "set", _wrap_ShortPixels_set}, - { "setFromPixels", _wrap_ShortPixels_setFromPixels}, - { "setFromPixelsImageType", _wrap_ShortPixels_setFromPixelsImageType}, - { "setFromExternalPixels", _wrap_ShortPixels_setFromExternalPixels}, - { "setFromAlignedPixels", _wrap_ShortPixels_setFromAlignedPixels}, - { "swap", _wrap_ShortPixels_swap}, - { "crop", _wrap_ShortPixels_crop}, - { "cropTo", _wrap_ShortPixels_cropTo}, - { "rotate90", _wrap_ShortPixels_rotate90}, - { "rotate90To", _wrap_ShortPixels_rotate90To}, - { "mirrorTo", _wrap_ShortPixels_mirrorTo}, - { "mirror", _wrap_ShortPixels_mirror}, - { "resize", _wrap_ShortPixels_resize}, - { "resizeTo", _wrap_ShortPixels_resizeTo}, - { "pasteInto", _wrap_ShortPixels_pasteInto}, - { "blendInto", _wrap_ShortPixels_blendInto}, - { "swapRgb", _wrap_ShortPixels_swapRgb}, - { "getData", _wrap_ShortPixels_getData}, - { "getPixelIndex", _wrap_ShortPixels_getPixelIndex}, - { "getColor", _wrap_ShortPixels_getColor}, - { "setColor", _wrap_ShortPixels_setColor}, - { "getWidth", _wrap_ShortPixels_getWidth}, - { "getHeight", _wrap_ShortPixels_getHeight}, - { "getBytesPerPixel", _wrap_ShortPixels_getBytesPerPixel}, - { "getBitsPerPixel", _wrap_ShortPixels_getBitsPerPixel}, - { "getBytesPerChannel", _wrap_ShortPixels_getBytesPerChannel}, - { "getBitsPerChannel", _wrap_ShortPixels_getBitsPerChannel}, - { "getBytesStride", _wrap_ShortPixels_getBytesStride}, - { "getNumChannels", _wrap_ShortPixels_getNumChannels}, - { "getTotalBytes", _wrap_ShortPixels_getTotalBytes}, - { "getNumPlanes", _wrap_ShortPixels_getNumPlanes}, - { "getPlane", _wrap_ShortPixels_getPlane}, - { "getChannel", _wrap_ShortPixels_getChannel}, - { "getPixelFormat", _wrap_ShortPixels_getPixelFormat}, - { "size", _wrap_ShortPixels_size}, - { "getImageType", _wrap_ShortPixels_getImageType}, - { "setChannel", _wrap_ShortPixels_setChannel}, - { "setImageType", _wrap_ShortPixels_setImageType}, - { "setNumChannels", _wrap_ShortPixels_setNumChannels}, - {0,0} -}; -static swig_lua_method swig_ShortPixels_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_ShortPixels_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_ShortPixels_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_ShortPixels_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_ShortPixels_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_ShortPixels_Sf_SwigStatic = { - "ShortPixels", - swig_ShortPixels_Sf_SwigStatic_methods, - swig_ShortPixels_Sf_SwigStatic_attributes, - swig_ShortPixels_Sf_SwigStatic_constants, - swig_ShortPixels_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_ShortPixels_bases[] = {0}; -static const char *swig_ShortPixels_base_names[] = {0}; -static swig_lua_class _wrap_class_ShortPixels = { "ShortPixels", "ShortPixels", &SWIGTYPE_p_ofPixels_T_unsigned_short_t,_proxy__wrap_new_ShortPixels, swig_delete_ShortPixels, swig_ShortPixels_methods, swig_ShortPixels_attributes, &swig_ShortPixels_Sf_SwigStatic, swig_ShortPixels_meta, swig_ShortPixels_bases, swig_ShortPixels_base_names }; - -static int _wrap_new_Path(lua_State* L) { int SWIG_arg = 0; ofPath *result = 0 ; SWIG_check_num_args("ofPath::ofPath",0,0) - result = (ofPath *)new ofPath(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofPath,1); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_clear(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; - SWIG_check_num_args("ofPath::clear",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::clear",1,"ofPath *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_clear",1,SWIGTYPE_p_ofPath); } - (arg1)->clear(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_newSubPath(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; - SWIG_check_num_args("ofPath::newSubPath",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::newSubPath",1,"ofPath *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_newSubPath",1,SWIGTYPE_p_ofPath); } (arg1)->newSubPath(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Path_close(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; - SWIG_check_num_args("ofPath::close",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::close",1,"ofPath *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_close",1,SWIGTYPE_p_ofPath); } - (arg1)->close(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_lineTo__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; ofPoint *arg2 = 0 ; - SWIG_check_num_args("ofPath::lineTo",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::lineTo",1,"ofPath *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPath::lineTo",2,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_lineTo",1,SWIGTYPE_p_ofPath); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Path_lineTo",2,SWIGTYPE_p_ofVec3f); } - (arg1)->lineTo((ofPoint const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_lineTo__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofPath::lineTo",3,3) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::lineTo",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::lineTo",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::lineTo",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_lineTo",1,SWIGTYPE_p_ofPath); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); (arg1)->lineTo(arg2,arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_lineTo__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; float arg3 ; - float arg4 ; SWIG_check_num_args("ofPath::lineTo",4,4) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::lineTo",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::lineTo",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::lineTo",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPath::lineTo",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_lineTo",1,SWIGTYPE_p_ofPath); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - (arg1)->lineTo(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_lineTo(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Path_lineTo__SWIG_0(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Path_lineTo__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Path_lineTo__SWIG_2(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Path_lineTo'\n" " Possible C/C++ prototypes are:\n" - " ofPath::lineTo(ofPoint const &)\n" " ofPath::lineTo(float,float)\n" " ofPath::lineTo(float,float,float)\n"); - lua_error(L);return 0; } -static int _wrap_Path_moveTo__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; ofPoint *arg2 = 0 ; - SWIG_check_num_args("ofPath::moveTo",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::moveTo",1,"ofPath *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPath::moveTo",2,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_moveTo",1,SWIGTYPE_p_ofPath); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Path_moveTo",2,SWIGTYPE_p_ofVec3f); } - (arg1)->moveTo((ofPoint const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_moveTo__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; float arg3 ; - float arg4 ; SWIG_check_num_args("ofPath::moveTo",4,4) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::moveTo",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::moveTo",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::moveTo",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPath::moveTo",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_moveTo",1,SWIGTYPE_p_ofPath); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - (arg1)->moveTo(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_moveTo__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofPath::moveTo",3,3) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::moveTo",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::moveTo",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::moveTo",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_moveTo",1,SWIGTYPE_p_ofPath); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); (arg1)->moveTo(arg2,arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_moveTo(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Path_moveTo__SWIG_0(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Path_moveTo__SWIG_2(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Path_moveTo__SWIG_1(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Path_moveTo'\n" " Possible C/C++ prototypes are:\n" - " ofPath::moveTo(ofPoint const &)\n" " ofPath::moveTo(float,float,float)\n" " ofPath::moveTo(float,float)\n"); - lua_error(L);return 0; } -static int _wrap_Path_curveTo__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; ofPoint *arg2 = 0 ; - SWIG_check_num_args("ofPath::curveTo",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::curveTo",1,"ofPath *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPath::curveTo",2,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_curveTo",1,SWIGTYPE_p_ofPath); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Path_curveTo",2,SWIGTYPE_p_ofVec3f); } - (arg1)->curveTo((ofPoint const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_curveTo__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofPath::curveTo",3,3) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::curveTo",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::curveTo",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::curveTo",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_curveTo",1,SWIGTYPE_p_ofPath); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); (arg1)->curveTo(arg2,arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_curveTo__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; float arg3 ; - float arg4 ; SWIG_check_num_args("ofPath::curveTo",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::curveTo",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::curveTo",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::curveTo",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPath::curveTo",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_curveTo",1,SWIGTYPE_p_ofPath); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - (arg1)->curveTo(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_curveTo(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Path_curveTo__SWIG_0(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Path_curveTo__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Path_curveTo__SWIG_2(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Path_curveTo'\n" " Possible C/C++ prototypes are:\n" - " ofPath::curveTo(ofPoint const &)\n" " ofPath::curveTo(float,float)\n" " ofPath::curveTo(float,float,float)\n"); - lua_error(L);return 0; } -static int _wrap_Path_bezierTo__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; ofPoint *arg2 = 0 ; - ofPoint *arg3 = 0 ; ofPoint *arg4 = 0 ; SWIG_check_num_args("ofPath::bezierTo",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::bezierTo",1,"ofPath *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPath::bezierTo",2,"ofPoint const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofPath::bezierTo",3,"ofPoint const &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofPath::bezierTo",4,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_bezierTo",1,SWIGTYPE_p_ofPath); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Path_bezierTo",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Path_bezierTo",3,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Path_bezierTo",4,SWIGTYPE_p_ofVec3f); } - (arg1)->bezierTo((ofPoint const &)*arg2,(ofPoint const &)*arg3,(ofPoint const &)*arg4); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_bezierTo__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; float arg3 ; - float arg4 ; float arg5 ; float arg6 ; float arg7 ; SWIG_check_num_args("ofPath::bezierTo",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::bezierTo",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::bezierTo",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::bezierTo",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPath::bezierTo",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPath::bezierTo",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPath::bezierTo",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPath::bezierTo",7,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_bezierTo",1,SWIGTYPE_p_ofPath); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); - (arg1)->bezierTo(arg2,arg3,arg4,arg5,arg6,arg7); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_bezierTo__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; float arg3 ; - float arg4 ; float arg5 ; float arg6 ; float arg7 ; float arg8 ; float arg9 ; float arg10 ; - SWIG_check_num_args("ofPath::bezierTo",10,10) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::bezierTo",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::bezierTo",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::bezierTo",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPath::bezierTo",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPath::bezierTo",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPath::bezierTo",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPath::bezierTo",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofPath::bezierTo",8,"float"); - if(!lua_isnumber(L,9)) SWIG_fail_arg("ofPath::bezierTo",9,"float"); - if(!lua_isnumber(L,10)) SWIG_fail_arg("ofPath::bezierTo",10,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_bezierTo",1,SWIGTYPE_p_ofPath); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); - arg8 = (float)lua_tonumber(L, 8); arg9 = (float)lua_tonumber(L, 9); arg10 = (float)lua_tonumber(L, 10); - (arg1)->bezierTo(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Path_bezierTo(lua_State* L) { int argc; int argv[11]={ 1,2,3,4,5,6,7,8,9,10,11} ; argc = lua_gettop(L); - if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Path_bezierTo__SWIG_0(L);} } } } } if (argc == 7) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { - return _wrap_Path_bezierTo__SWIG_1(L);} } } } } } } } if (argc == 10) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { { _v = lua_isnumber(L,argv[8]); } if (_v) { { - _v = lua_isnumber(L,argv[9]); } if (_v) { return _wrap_Path_bezierTo__SWIG_2(L);} } } } } } } } - } } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Path_bezierTo'\n" - " Possible C/C++ prototypes are:\n" " ofPath::bezierTo(ofPoint const &,ofPoint const &,ofPoint const &)\n" - " ofPath::bezierTo(float,float,float,float,float,float)\n" - " ofPath::bezierTo(float,float,float,float,float,float,float,float,float)\n"); lua_error(L);return 0; } -static int _wrap_Path_quadBezierTo__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; ofPoint *arg2 = 0 ; - ofPoint *arg3 = 0 ; ofPoint *arg4 = 0 ; SWIG_check_num_args("ofPath::quadBezierTo",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::quadBezierTo",1,"ofPath *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPath::quadBezierTo",2,"ofPoint const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofPath::quadBezierTo",3,"ofPoint const &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofPath::quadBezierTo",4,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_quadBezierTo",1,SWIGTYPE_p_ofPath); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Path_quadBezierTo",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Path_quadBezierTo",3,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Path_quadBezierTo",4,SWIGTYPE_p_ofVec3f); } - (arg1)->quadBezierTo((ofPoint const &)*arg2,(ofPoint const &)*arg3,(ofPoint const &)*arg4); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_quadBezierTo__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; - float arg3 ; float arg4 ; float arg5 ; float arg6 ; float arg7 ; SWIG_check_num_args("ofPath::quadBezierTo",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::quadBezierTo",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::quadBezierTo",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::quadBezierTo",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPath::quadBezierTo",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPath::quadBezierTo",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPath::quadBezierTo",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPath::quadBezierTo",7,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_quadBezierTo",1,SWIGTYPE_p_ofPath); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); (arg1)->quadBezierTo(arg2,arg3,arg4,arg5,arg6,arg7); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_quadBezierTo__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; - float arg3 ; float arg4 ; float arg5 ; float arg6 ; float arg7 ; float arg8 ; float arg9 ; float arg10 ; - SWIG_check_num_args("ofPath::quadBezierTo",10,10) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::quadBezierTo",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::quadBezierTo",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::quadBezierTo",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPath::quadBezierTo",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPath::quadBezierTo",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPath::quadBezierTo",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPath::quadBezierTo",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofPath::quadBezierTo",8,"float"); - if(!lua_isnumber(L,9)) SWIG_fail_arg("ofPath::quadBezierTo",9,"float"); - if(!lua_isnumber(L,10)) SWIG_fail_arg("ofPath::quadBezierTo",10,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_quadBezierTo",1,SWIGTYPE_p_ofPath); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (float)lua_tonumber(L, 8); - arg9 = (float)lua_tonumber(L, 9); arg10 = (float)lua_tonumber(L, 10); - (arg1)->quadBezierTo(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Path_quadBezierTo(lua_State* L) { int argc; int argv[11]={ 1,2,3,4,5,6,7,8,9,10,11} ; argc = lua_gettop(L); - if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Path_quadBezierTo__SWIG_0(L);} } } } } if (argc == 7) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { - return _wrap_Path_quadBezierTo__SWIG_1(L);} } } } } } } } if (argc == 10) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { { _v = lua_isnumber(L,argv[8]); } if (_v) { { - _v = lua_isnumber(L,argv[9]); } if (_v) { return _wrap_Path_quadBezierTo__SWIG_2(L);} } } } } } } - } } } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Path_quadBezierTo'\n" - " Possible C/C++ prototypes are:\n" " ofPath::quadBezierTo(ofPoint const &,ofPoint const &,ofPoint const &)\n" - " ofPath::quadBezierTo(float,float,float,float,float,float)\n" - " ofPath::quadBezierTo(float,float,float,float,float,float,float,float,float)\n"); lua_error(L);return 0; } -static int _wrap_Path_arc__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; ofPoint *arg2 = 0 ; - float arg3 ; float arg4 ; float arg5 ; float arg6 ; SWIG_check_num_args("ofPath::arc",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::arc",1,"ofPath *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPath::arc",2,"ofPoint const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::arc",3,"float"); if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPath::arc",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPath::arc",5,"float"); if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPath::arc",6,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_arc",1,SWIGTYPE_p_ofPath); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Path_arc",2,SWIGTYPE_p_ofVec3f); } - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); (arg1)->arc((ofPoint const &)*arg2,arg3,arg4,arg5,arg6); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_arc__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; ofPoint *arg2 = 0 ; - float arg3 ; float arg4 ; float arg5 ; float arg6 ; bool arg7 ; SWIG_check_num_args("ofPath::arc",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::arc",1,"ofPath *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPath::arc",2,"ofPoint const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::arc",3,"float"); if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPath::arc",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPath::arc",5,"float"); if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPath::arc",6,"float"); - if(!lua_isboolean(L,7)) SWIG_fail_arg("ofPath::arc",7,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_arc",1,SWIGTYPE_p_ofPath); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Path_arc",2,SWIGTYPE_p_ofVec3f); } - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (lua_toboolean(L, 7)!=0); - (arg1)->arc((ofPoint const &)*arg2,arg3,arg4,arg5,arg6,arg7); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Path_arc__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; float arg3 ; - float arg4 ; float arg5 ; float arg6 ; float arg7 ; SWIG_check_num_args("ofPath::arc",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::arc",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::arc",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::arc",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPath::arc",4,"float"); if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPath::arc",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPath::arc",6,"float"); if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPath::arc",7,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_arc",1,SWIGTYPE_p_ofPath); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); - (arg1)->arc(arg2,arg3,arg4,arg5,arg6,arg7); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_arc__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; float arg3 ; - float arg4 ; float arg5 ; float arg6 ; float arg7 ; float arg8 ; SWIG_check_num_args("ofPath::arc",8,8) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::arc",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::arc",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::arc",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPath::arc",4,"float"); if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPath::arc",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPath::arc",6,"float"); if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPath::arc",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofPath::arc",8,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_arc",1,SWIGTYPE_p_ofPath); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); - arg8 = (float)lua_tonumber(L, 8); (arg1)->arc(arg2,arg3,arg4,arg5,arg6,arg7,arg8); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Path_arc(lua_State* L) { int argc; int argv[9]={ 1,2,3,4,5,6,7,8,9} ; argc = lua_gettop(L); if (argc == 6) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { - return _wrap_Path_arc__SWIG_0(L);} } } } } } } if (argc == 7) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { { - _v = lua_isboolean(L,argv[6]); } if (_v) { return _wrap_Path_arc__SWIG_1(L);} } } } } } } } - if (argc == 7) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { - return _wrap_Path_arc__SWIG_2(L);} } } } } } } } if (argc == 8) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { return _wrap_Path_arc__SWIG_3(L);} } } } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Path_arc'\n" " Possible C/C++ prototypes are:\n" - " ofPath::arc(ofPoint const &,float,float,float,float)\n" " ofPath::arc(ofPoint const &,float,float,float,float,bool)\n" - " ofPath::arc(float,float,float,float,float,float)\n" " ofPath::arc(float,float,float,float,float,float,float)\n"); - lua_error(L);return 0; } -static int _wrap_Path_arcNegative__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; ofPoint *arg2 = 0 ; - float arg3 ; float arg4 ; float arg5 ; float arg6 ; SWIG_check_num_args("ofPath::arcNegative",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::arcNegative",1,"ofPath *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPath::arcNegative",2,"ofPoint const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::arcNegative",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPath::arcNegative",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPath::arcNegative",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPath::arcNegative",6,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_arcNegative",1,SWIGTYPE_p_ofPath); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Path_arcNegative",2,SWIGTYPE_p_ofVec3f); } arg3 = (float)lua_tonumber(L, 3); - arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); - (arg1)->arcNegative((ofPoint const &)*arg2,arg3,arg4,arg5,arg6); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Path_arcNegative__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; - float arg3 ; float arg4 ; float arg5 ; float arg6 ; float arg7 ; SWIG_check_num_args("ofPath::arcNegative",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::arcNegative",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::arcNegative",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::arcNegative",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPath::arcNegative",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPath::arcNegative",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPath::arcNegative",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPath::arcNegative",7,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_arcNegative",1,SWIGTYPE_p_ofPath); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); (arg1)->arcNegative(arg2,arg3,arg4,arg5,arg6,arg7); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_arcNegative__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; - float arg3 ; float arg4 ; float arg5 ; float arg6 ; float arg7 ; float arg8 ; SWIG_check_num_args("ofPath::arcNegative",8,8) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::arcNegative",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::arcNegative",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::arcNegative",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPath::arcNegative",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPath::arcNegative",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPath::arcNegative",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPath::arcNegative",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofPath::arcNegative",8,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_arcNegative",1,SWIGTYPE_p_ofPath); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (float)lua_tonumber(L, 8); - (arg1)->arcNegative(arg2,arg3,arg4,arg5,arg6,arg7,arg8); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Path_arcNegative(lua_State* L) { int argc; int argv[9]={ 1,2,3,4,5,6,7,8,9} ; argc = lua_gettop(L); - if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { - return _wrap_Path_arcNegative__SWIG_0(L);} } } } } } } if (argc == 7) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { - return _wrap_Path_arcNegative__SWIG_1(L);} } } } } } } } if (argc == 8) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { return _wrap_Path_arcNegative__SWIG_2(L);} } } } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Path_arcNegative'\n" " Possible C/C++ prototypes are:\n" - " ofPath::arcNegative(ofPoint const &,float,float,float,float)\n" - " ofPath::arcNegative(float,float,float,float,float,float)\n" - " ofPath::arcNegative(float,float,float,float,float,float,float)\n"); lua_error(L);return 0; } -static int _wrap_Path_triangle__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; float arg3 ; - float arg4 ; float arg5 ; float arg6 ; float arg7 ; SWIG_check_num_args("ofPath::triangle",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::triangle",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::triangle",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::triangle",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPath::triangle",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPath::triangle",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPath::triangle",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPath::triangle",7,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_triangle",1,SWIGTYPE_p_ofPath); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); - (arg1)->triangle(arg2,arg3,arg4,arg5,arg6,arg7); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_triangle__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; float arg3 ; - float arg4 ; float arg5 ; float arg6 ; float arg7 ; float arg8 ; float arg9 ; float arg10 ; - SWIG_check_num_args("ofPath::triangle",10,10) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::triangle",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::triangle",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::triangle",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPath::triangle",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPath::triangle",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPath::triangle",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPath::triangle",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofPath::triangle",8,"float"); - if(!lua_isnumber(L,9)) SWIG_fail_arg("ofPath::triangle",9,"float"); - if(!lua_isnumber(L,10)) SWIG_fail_arg("ofPath::triangle",10,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_triangle",1,SWIGTYPE_p_ofPath); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); - arg8 = (float)lua_tonumber(L, 8); arg9 = (float)lua_tonumber(L, 9); arg10 = (float)lua_tonumber(L, 10); - (arg1)->triangle(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Path_triangle__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; ofPoint *arg2 = 0 ; - ofPoint *arg3 = 0 ; ofPoint *arg4 = 0 ; SWIG_check_num_args("ofPath::triangle",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::triangle",1,"ofPath *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPath::triangle",2,"ofPoint const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofPath::triangle",3,"ofPoint const &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofPath::triangle",4,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_triangle",1,SWIGTYPE_p_ofPath); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Path_triangle",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Path_triangle",3,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Path_triangle",4,SWIGTYPE_p_ofVec3f); } - (arg1)->triangle((ofPoint const &)*arg2,(ofPoint const &)*arg3,(ofPoint const &)*arg4); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_triangle(lua_State* L) { int argc; int argv[11]={ 1,2,3,4,5,6,7,8,9,10,11} ; argc = lua_gettop(L); - if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Path_triangle__SWIG_2(L);} } } } } if (argc == 7) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { - return _wrap_Path_triangle__SWIG_0(L);} } } } } } } } if (argc == 10) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { { _v = lua_isnumber(L,argv[8]); } if (_v) { { - _v = lua_isnumber(L,argv[9]); } if (_v) { return _wrap_Path_triangle__SWIG_1(L);} } } } } } } } - } } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Path_triangle'\n" - " Possible C/C++ prototypes are:\n" " ofPath::triangle(float,float,float,float,float,float)\n" - " ofPath::triangle(float,float,float,float,float,float,float,float,float)\n" - " ofPath::triangle(ofPoint const &,ofPoint const &,ofPoint const &)\n"); lua_error(L);return 0; } -static int _wrap_Path_circle__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; float arg3 ; - float arg4 ; SWIG_check_num_args("ofPath::circle",4,4) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::circle",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::circle",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::circle",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPath::circle",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_circle",1,SWIGTYPE_p_ofPath); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - (arg1)->circle(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_circle__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; float arg3 ; - float arg4 ; float arg5 ; SWIG_check_num_args("ofPath::circle",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::circle",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::circle",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::circle",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPath::circle",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPath::circle",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_circle",1,SWIGTYPE_p_ofPath); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); (arg1)->circle(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Path_circle__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; ofPoint *arg2 = 0 ; - float arg3 ; SWIG_check_num_args("ofPath::circle",3,3) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::circle",1,"ofPath *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPath::circle",2,"ofPoint const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::circle",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_circle",1,SWIGTYPE_p_ofPath); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Path_circle",2,SWIGTYPE_p_ofVec3f); } - arg3 = (float)lua_tonumber(L, 3); (arg1)->circle((ofPoint const &)*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Path_circle(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Path_circle__SWIG_2(L);} } } - } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Path_circle__SWIG_0(L);} } } } } if (argc == 5) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Path_circle__SWIG_1(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Path_circle'\n" " Possible C/C++ prototypes are:\n" - " ofPath::circle(float,float,float)\n" " ofPath::circle(float,float,float,float)\n" - " ofPath::circle(ofPoint const &,float)\n"); lua_error(L);return 0; } -static int _wrap_Path_ellipse__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; float arg3 ; - float arg4 ; float arg5 ; SWIG_check_num_args("ofPath::ellipse",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::ellipse",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::ellipse",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::ellipse",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPath::ellipse",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPath::ellipse",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_ellipse",1,SWIGTYPE_p_ofPath); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); (arg1)->ellipse(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Path_ellipse__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; float arg3 ; - float arg4 ; float arg5 ; float arg6 ; SWIG_check_num_args("ofPath::ellipse",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::ellipse",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::ellipse",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::ellipse",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPath::ellipse",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPath::ellipse",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPath::ellipse",6,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_ellipse",1,SWIGTYPE_p_ofPath); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); (arg1)->ellipse(arg2,arg3,arg4,arg5,arg6); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_ellipse__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; ofPoint *arg2 = 0 ; - float arg3 ; float arg4 ; SWIG_check_num_args("ofPath::ellipse",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::ellipse",1,"ofPath *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPath::ellipse",2,"ofPoint const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::ellipse",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPath::ellipse",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_ellipse",1,SWIGTYPE_p_ofPath); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Path_ellipse",2,SWIGTYPE_p_ofVec3f); } - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); (arg1)->ellipse((ofPoint const &)*arg2,arg3,arg4); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_ellipse(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); if (argc == 4) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Path_ellipse__SWIG_2(L);} } } } } if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Path_ellipse__SWIG_0(L);} } } } } } if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { return _wrap_Path_ellipse__SWIG_1(L);} } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Path_ellipse'\n" " Possible C/C++ prototypes are:\n" - " ofPath::ellipse(float,float,float,float)\n" " ofPath::ellipse(float,float,float,float,float)\n" - " ofPath::ellipse(ofPoint const &,float,float)\n"); lua_error(L);return 0; } -static int _wrap_Path_rectangle__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; ofRectangle *arg2 = 0 ; - SWIG_check_num_args("ofPath::rectangle",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::rectangle",1,"ofPath *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPath::rectangle",2,"ofRectangle const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_rectangle",1,SWIGTYPE_p_ofPath); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Path_rectangle",2,SWIGTYPE_p_ofRectangle); } (arg1)->rectangle((ofRectangle const &)*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_rectangle__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; ofPoint *arg2 = 0 ; - float arg3 ; float arg4 ; SWIG_check_num_args("ofPath::rectangle",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::rectangle",1,"ofPath *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPath::rectangle",2,"ofPoint const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::rectangle",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPath::rectangle",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_rectangle",1,SWIGTYPE_p_ofPath); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Path_rectangle",2,SWIGTYPE_p_ofVec3f); } arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - (arg1)->rectangle((ofPoint const &)*arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_rectangle__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; - float arg3 ; float arg4 ; float arg5 ; SWIG_check_num_args("ofPath::rectangle",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::rectangle",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::rectangle",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::rectangle",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPath::rectangle",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPath::rectangle",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_rectangle",1,SWIGTYPE_p_ofPath); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); (arg1)->rectangle(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Path_rectangle__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; - float arg3 ; float arg4 ; float arg5 ; float arg6 ; SWIG_check_num_args("ofPath::rectangle",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::rectangle",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::rectangle",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::rectangle",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPath::rectangle",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPath::rectangle",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPath::rectangle",6,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_rectangle",1,SWIGTYPE_p_ofPath); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); (arg1)->rectangle(arg2,arg3,arg4,arg5,arg6); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_rectangle(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Path_rectangle__SWIG_0(L);} } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Path_rectangle__SWIG_1(L);} } } } } if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Path_rectangle__SWIG_2(L);} } } } } } if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { return _wrap_Path_rectangle__SWIG_3(L);} } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Path_rectangle'\n" " Possible C/C++ prototypes are:\n" - " ofPath::rectangle(ofRectangle const &)\n" " ofPath::rectangle(ofPoint const &,float,float)\n" - " ofPath::rectangle(float,float,float,float)\n" " ofPath::rectangle(float,float,float,float,float)\n"); - lua_error(L);return 0; } -static int _wrap_Path_rectRounded__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; - ofRectangle *arg2 = 0 ; float arg3 ; SWIG_check_num_args("ofPath::rectRounded",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::rectRounded",1,"ofPath *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPath::rectRounded",2,"ofRectangle const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::rectRounded",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_rectRounded",1,SWIGTYPE_p_ofPath); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Path_rectRounded",2,SWIGTYPE_p_ofRectangle); } arg3 = (float)lua_tonumber(L, 3); - (arg1)->rectRounded((ofRectangle const &)*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_rectRounded__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; ofPoint *arg2 = 0 ; - float arg3 ; float arg4 ; float arg5 ; SWIG_check_num_args("ofPath::rectRounded",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::rectRounded",1,"ofPath *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPath::rectRounded",2,"ofPoint const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::rectRounded",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPath::rectRounded",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPath::rectRounded",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_rectRounded",1,SWIGTYPE_p_ofPath); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Path_rectRounded",2,SWIGTYPE_p_ofVec3f); } arg3 = (float)lua_tonumber(L, 3); - arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - (arg1)->rectRounded((ofPoint const &)*arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Path_rectRounded__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; - float arg3 ; float arg4 ; float arg5 ; float arg6 ; SWIG_check_num_args("ofPath::rectRounded",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::rectRounded",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::rectRounded",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::rectRounded",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPath::rectRounded",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPath::rectRounded",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPath::rectRounded",6,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_rectRounded",1,SWIGTYPE_p_ofPath); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); (arg1)->rectRounded(arg2,arg3,arg4,arg5,arg6); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Path_rectRounded__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; ofPoint *arg2 = 0 ; - float arg3 ; float arg4 ; float arg5 ; float arg6 ; float arg7 ; float arg8 ; SWIG_check_num_args("ofPath::rectRounded",8,8) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::rectRounded",1,"ofPath *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPath::rectRounded",2,"ofPoint const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::rectRounded",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPath::rectRounded",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPath::rectRounded",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPath::rectRounded",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPath::rectRounded",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofPath::rectRounded",8,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_rectRounded",1,SWIGTYPE_p_ofPath); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Path_rectRounded",2,SWIGTYPE_p_ofVec3f); } arg3 = (float)lua_tonumber(L, 3); - arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); - arg7 = (float)lua_tonumber(L, 7); arg8 = (float)lua_tonumber(L, 8); - (arg1)->rectRounded((ofPoint const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Path_rectRounded__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; - ofRectangle *arg2 = 0 ; float arg3 ; float arg4 ; float arg5 ; float arg6 ; SWIG_check_num_args("ofPath::rectRounded",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::rectRounded",1,"ofPath *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPath::rectRounded",2,"ofRectangle const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::rectRounded",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPath::rectRounded",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPath::rectRounded",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPath::rectRounded",6,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_rectRounded",1,SWIGTYPE_p_ofPath); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Path_rectRounded",2,SWIGTYPE_p_ofRectangle); } arg3 = (float)lua_tonumber(L, 3); - arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); - (arg1)->rectRounded((ofRectangle const &)*arg2,arg3,arg4,arg5,arg6); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Path_rectRounded__SWIG_5(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; - float arg3 ; float arg4 ; float arg5 ; float arg6 ; float arg7 ; float arg8 ; float arg9 ; float arg10 ; - SWIG_check_num_args("ofPath::rectRounded",10,10) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::rectRounded",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::rectRounded",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::rectRounded",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPath::rectRounded",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPath::rectRounded",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPath::rectRounded",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPath::rectRounded",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofPath::rectRounded",8,"float"); - if(!lua_isnumber(L,9)) SWIG_fail_arg("ofPath::rectRounded",9,"float"); - if(!lua_isnumber(L,10)) SWIG_fail_arg("ofPath::rectRounded",10,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_rectRounded",1,SWIGTYPE_p_ofPath); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (float)lua_tonumber(L, 8); - arg9 = (float)lua_tonumber(L, 9); arg10 = (float)lua_tonumber(L, 10); - (arg1)->rectRounded(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Path_rectRounded(lua_State* L) { int argc; int argv[11]={ 1,2,3,4,5,6,7,8,9,10,11} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Path_rectRounded__SWIG_0(L);} - } } } if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_Path_rectRounded__SWIG_1(L);} } } } } } - if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { - return _wrap_Path_rectRounded__SWIG_4(L);} } } } } } } if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { return _wrap_Path_rectRounded__SWIG_2(L);} } } } } } } - if (argc == 8) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { { - _v = lua_isnumber(L,argv[6]); } if (_v) { { _v = lua_isnumber(L,argv[7]); } if (_v) { - return _wrap_Path_rectRounded__SWIG_3(L);} } } } } } } } } if (argc == 10) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { { _v = lua_isnumber(L,argv[8]); } if (_v) { { - _v = lua_isnumber(L,argv[9]); } if (_v) { return _wrap_Path_rectRounded__SWIG_5(L);} } } } } } } - } } } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Path_rectRounded'\n" - " Possible C/C++ prototypes are:\n" " ofPath::rectRounded(ofRectangle const &,float)\n" - " ofPath::rectRounded(ofPoint const &,float,float,float)\n" " ofPath::rectRounded(float,float,float,float,float)\n" - " ofPath::rectRounded(ofPoint const &,float,float,float,float,float,float)\n" - " ofPath::rectRounded(ofRectangle const &,float,float,float,float)\n" - " ofPath::rectRounded(float,float,float,float,float,float,float,float,float)\n"); lua_error(L);return 0; } -static int _wrap_Path_setPolyWindingMode(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; - ofPolyWindingMode arg2 ; SWIG_check_num_args("ofPath::setPolyWindingMode",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::setPolyWindingMode",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::setPolyWindingMode",2,"ofPolyWindingMode"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_setPolyWindingMode",1,SWIGTYPE_p_ofPath); } arg2 = (ofPolyWindingMode)(int)lua_tonumber(L, 2); - (arg1)->setPolyWindingMode(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_getWindingMode(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; ofPolyWindingMode result; - SWIG_check_num_args("ofPath::getWindingMode",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::getWindingMode",1,"ofPath const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_getWindingMode",1,SWIGTYPE_p_ofPath); } - result = (ofPolyWindingMode)((ofPath const *)arg1)->getWindingMode(); - lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Path_setFilled(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; bool arg2 ; - SWIG_check_num_args("ofPath::setFilled",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::setFilled",1,"ofPath *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofPath::setFilled",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_setFilled",1,SWIGTYPE_p_ofPath); } - arg2 = (lua_toboolean(L, 2)!=0); (arg1)->setFilled(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Path_setStrokeWidth(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; - SWIG_check_num_args("ofPath::setStrokeWidth",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::setStrokeWidth",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::setStrokeWidth",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_setStrokeWidth",1,SWIGTYPE_p_ofPath); } arg2 = (float)lua_tonumber(L, 2); (arg1)->setStrokeWidth(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_setColor(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; ofColor *arg2 = 0 ; - SWIG_check_num_args("ofPath::setColor",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::setColor",1,"ofPath *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPath::setColor",2,"ofColor const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_setColor",1,SWIGTYPE_p_ofPath); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Path_setColor",2,SWIGTYPE_p_ofColor_T_unsigned_char_t); } (arg1)->setColor((ofColor const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_setHexColor(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; int arg2 ; - SWIG_check_num_args("ofPath::setHexColor",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::setHexColor",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::setHexColor",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_setHexColor",1,SWIGTYPE_p_ofPath); } arg2 = (int)lua_tonumber(L, 2); (arg1)->setHexColor(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_setFillColor(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; ofColor *arg2 = 0 ; - SWIG_check_num_args("ofPath::setFillColor",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::setFillColor",1,"ofPath *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPath::setFillColor",2,"ofColor const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_setFillColor",1,SWIGTYPE_p_ofPath); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Path_setFillColor",2,SWIGTYPE_p_ofColor_T_unsigned_char_t); } (arg1)->setFillColor((ofColor const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_setFillHexColor(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; int arg2 ; - SWIG_check_num_args("ofPath::setFillHexColor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::setFillHexColor",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::setFillHexColor",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_setFillHexColor",1,SWIGTYPE_p_ofPath); } arg2 = (int)lua_tonumber(L, 2); (arg1)->setFillHexColor(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_setStrokeColor(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; ofColor *arg2 = 0 ; - SWIG_check_num_args("ofPath::setStrokeColor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::setStrokeColor",1,"ofPath *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPath::setStrokeColor",2,"ofColor const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_setStrokeColor",1,SWIGTYPE_p_ofPath); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Path_setStrokeColor",2,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - (arg1)->setStrokeColor((ofColor const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_setStrokeHexColor(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; int arg2 ; - SWIG_check_num_args("ofPath::setStrokeHexColor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::setStrokeHexColor",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::setStrokeHexColor",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_setStrokeHexColor",1,SWIGTYPE_p_ofPath); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->setStrokeHexColor(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_isFilled(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; bool result; - SWIG_check_num_args("ofPath::isFilled",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::isFilled",1,"ofPath const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_isFilled",1,SWIGTYPE_p_ofPath); } - result = (bool)((ofPath const *)arg1)->isFilled(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_getFillColor(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; ofColor result; - SWIG_check_num_args("ofPath::getFillColor",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::getFillColor",1,"ofPath const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_getFillColor",1,SWIGTYPE_p_ofPath); } result = ((ofPath const *)arg1)->getFillColor(); { - ofColor * resultptr = new ofColor((const ofColor &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_getStrokeColor(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; ofColor result; - SWIG_check_num_args("ofPath::getStrokeColor",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::getStrokeColor",1,"ofPath const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_getStrokeColor",1,SWIGTYPE_p_ofPath); } result = ((ofPath const *)arg1)->getStrokeColor(); { - ofColor * resultptr = new ofColor((const ofColor &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_getStrokeWidth(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float result; - SWIG_check_num_args("ofPath::getStrokeWidth",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::getStrokeWidth",1,"ofPath const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_getStrokeWidth",1,SWIGTYPE_p_ofPath); } result = (float)((ofPath const *)arg1)->getStrokeWidth(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_hasOutline(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; bool result; - SWIG_check_num_args("ofPath::hasOutline",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::hasOutline",1,"ofPath const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_hasOutline",1,SWIGTYPE_p_ofPath); } result = (bool)((ofPath const *)arg1)->hasOutline(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_setCurveResolution(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; int arg2 ; - SWIG_check_num_args("ofPath::setCurveResolution",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::setCurveResolution",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::setCurveResolution",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_setCurveResolution",1,SWIGTYPE_p_ofPath); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->setCurveResolution(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_getCurveResolution(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; int result; - SWIG_check_num_args("ofPath::getCurveResolution",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::getCurveResolution",1,"ofPath const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_getCurveResolution",1,SWIGTYPE_p_ofPath); } result = (int)((ofPath const *)arg1)->getCurveResolution(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_setCircleResolution(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; int arg2 ; - SWIG_check_num_args("ofPath::setCircleResolution",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::setCircleResolution",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::setCircleResolution",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_setCircleResolution",1,SWIGTYPE_p_ofPath); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->setCircleResolution(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_getCircleResolution(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; int result; - SWIG_check_num_args("ofPath::getCircleResolution",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::getCircleResolution",1,"ofPath const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_getCircleResolution",1,SWIGTYPE_p_ofPath); } - result = (int)((ofPath const *)arg1)->getCircleResolution(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_setUseShapeColor(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; bool arg2 ; - SWIG_check_num_args("ofPath::setUseShapeColor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::setUseShapeColor",1,"ofPath *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofPath::setUseShapeColor",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_setUseShapeColor",1,SWIGTYPE_p_ofPath); } arg2 = (lua_toboolean(L, 2)!=0); - (arg1)->setUseShapeColor(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_getUseShapeColor(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; bool result; - SWIG_check_num_args("ofPath::getUseShapeColor",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::getUseShapeColor",1,"ofPath const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_getUseShapeColor",1,SWIGTYPE_p_ofPath); } result = (bool)((ofPath const *)arg1)->getUseShapeColor(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_draw__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; - SWIG_check_num_args("ofPath::draw",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::draw",1,"ofPath const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_draw",1,SWIGTYPE_p_ofPath); } - ((ofPath const *)arg1)->draw(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_draw__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofPath::draw",3,3) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::draw",1,"ofPath const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::draw",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::draw",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_draw",1,SWIGTYPE_p_ofPath); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); ((ofPath const *)arg1)->draw(arg2,arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_draw(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Path_draw__SWIG_0(L);} } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Path_draw__SWIG_1(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Path_draw'\n" " Possible C/C++ prototypes are:\n" - " ofPath::draw() const\n" " ofPath::draw(float,float) const\n"); lua_error(L);return 0; } -static int _wrap_Path_getOutline(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; - std::vector< ofPolyline > *result = 0 ; SWIG_check_num_args("ofPath::getOutline",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::getOutline",1,"ofPath const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_getOutline",1,SWIGTYPE_p_ofPath); } - result = (std::vector< ofPolyline > *) &((ofPath const *)arg1)->getOutline(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofPolyline_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Path_tessellate(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; - SWIG_check_num_args("ofPath::tessellate",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::tessellate",1,"ofPath *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_tessellate",1,SWIGTYPE_p_ofPath); } (arg1)->tessellate(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Path_getTessellation(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; ofMesh *result = 0 ; - SWIG_check_num_args("ofPath::getTessellation",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::getTessellation",1,"ofPath const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_getTessellation",1,SWIGTYPE_p_ofPath); } - result = (ofMesh *) &((ofPath const *)arg1)->getTessellation(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMesh,0); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_simplify__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; - SWIG_check_num_args("ofPath::simplify",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::simplify",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::simplify",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_simplify",1,SWIGTYPE_p_ofPath); } - arg2 = (float)lua_tonumber(L, 2); (arg1)->simplify(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Path_simplify__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; - SWIG_check_num_args("ofPath::simplify",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::simplify",1,"ofPath *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_simplify",1,SWIGTYPE_p_ofPath); } - (arg1)->simplify(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_simplify(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Path_simplify__SWIG_1(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Path_simplify__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Path_simplify'\n" " Possible C/C++ prototypes are:\n" - " ofPath::simplify(float)\n" " ofPath::simplify()\n"); lua_error(L);return 0; } -static int _wrap_Path_translate(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; ofPoint *arg2 = 0 ; - SWIG_check_num_args("ofPath::translate",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::translate",1,"ofPath *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPath::translate",2,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_translate",1,SWIGTYPE_p_ofPath); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Path_translate",2,SWIGTYPE_p_ofVec3f); } (arg1)->translate((ofPoint const &)*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_rotate(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; ofVec3f *arg3 = 0 ; - SWIG_check_num_args("ofPath::rotate",3,3) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::rotate",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::rotate",2,"float"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofPath::rotate",3,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_rotate",1,SWIGTYPE_p_ofPath); } - arg2 = (float)lua_tonumber(L, 2); if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Path_rotate",3,SWIGTYPE_p_ofVec3f); } (arg1)->rotate(arg2,(ofVec3f const &)*arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_scale(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofPath::scale",3,3) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::scale",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::scale",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::scale",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_scale",1,SWIGTYPE_p_ofPath); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); (arg1)->scale(arg2,arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_append(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; ofPath *arg2 = 0 ; - SWIG_check_num_args("ofPath::append",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::append",1,"ofPath *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPath::append",2,"ofPath const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_append",1,SWIGTYPE_p_ofPath); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_append",2,SWIGTYPE_p_ofPath); } - (arg1)->append((ofPath const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_setMode(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; ofPath::Mode arg2 ; - SWIG_check_num_args("ofPath::setMode",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::setMode",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::setMode",2,"ofPath::Mode"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_setMode",1,SWIGTYPE_p_ofPath); } - arg2 = (ofPath::Mode)(int)lua_tonumber(L, 2); (arg1)->setMode(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Path_getMode(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; ofPath::Mode result; - SWIG_check_num_args("ofPath::getMode",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::getMode",1,"ofPath *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_getMode",1,SWIGTYPE_p_ofPath); } - result = (ofPath::Mode)(arg1)->getMode(); lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_getCommands__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; - std::vector< ofPath::Command > *result = 0 ; SWIG_check_num_args("ofPath::getCommands",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::getCommands",1,"ofPath *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_getCommands",1,SWIGTYPE_p_ofPath); } - result = (std::vector< ofPath::Command > *) &(arg1)->getCommands(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofPath__Command_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Path_getCommands__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; - std::vector< ofPath::Command > *result = 0 ; SWIG_check_num_args("ofPath::getCommands",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::getCommands",1,"ofPath const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_getCommands",1,SWIGTYPE_p_ofPath); } - result = (std::vector< ofPath::Command > *) &((ofPath const *)arg1)->getCommands(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofPath__Command_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Path_getCommands(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Path_getCommands__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Path_getCommands__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Path_getCommands'\n" " Possible C/C++ prototypes are:\n" - " ofPath::getCommands()\n" " ofPath::getCommands() const\n"); lua_error(L);return 0; } -static void swig_delete_Path(void *obj) { -ofPath *arg1 = (ofPath *) obj; -delete arg1; -} -static int _proxy__wrap_new_Path(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_Path); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_Path_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_Path_methods[]= { - { "clear", _wrap_Path_clear}, - { "newSubPath", _wrap_Path_newSubPath}, - { "close", _wrap_Path_close}, - { "lineTo", _wrap_Path_lineTo}, - { "moveTo", _wrap_Path_moveTo}, - { "curveTo", _wrap_Path_curveTo}, - { "bezierTo", _wrap_Path_bezierTo}, - { "quadBezierTo", _wrap_Path_quadBezierTo}, - { "arc", _wrap_Path_arc}, - { "arcNegative", _wrap_Path_arcNegative}, - { "triangle", _wrap_Path_triangle}, - { "circle", _wrap_Path_circle}, - { "ellipse", _wrap_Path_ellipse}, - { "rectangle", _wrap_Path_rectangle}, - { "rectRounded", _wrap_Path_rectRounded}, - { "setPolyWindingMode", _wrap_Path_setPolyWindingMode}, - { "getWindingMode", _wrap_Path_getWindingMode}, - { "setFilled", _wrap_Path_setFilled}, - { "setStrokeWidth", _wrap_Path_setStrokeWidth}, - { "setColor", _wrap_Path_setColor}, - { "setHexColor", _wrap_Path_setHexColor}, - { "setFillColor", _wrap_Path_setFillColor}, - { "setFillHexColor", _wrap_Path_setFillHexColor}, - { "setStrokeColor", _wrap_Path_setStrokeColor}, - { "setStrokeHexColor", _wrap_Path_setStrokeHexColor}, - { "isFilled", _wrap_Path_isFilled}, - { "getFillColor", _wrap_Path_getFillColor}, - { "getStrokeColor", _wrap_Path_getStrokeColor}, - { "getStrokeWidth", _wrap_Path_getStrokeWidth}, - { "hasOutline", _wrap_Path_hasOutline}, - { "setCurveResolution", _wrap_Path_setCurveResolution}, - { "getCurveResolution", _wrap_Path_getCurveResolution}, - { "setCircleResolution", _wrap_Path_setCircleResolution}, - { "getCircleResolution", _wrap_Path_getCircleResolution}, - { "setUseShapeColor", _wrap_Path_setUseShapeColor}, - { "getUseShapeColor", _wrap_Path_getUseShapeColor}, - { "draw", _wrap_Path_draw}, - { "getOutline", _wrap_Path_getOutline}, - { "tessellate", _wrap_Path_tessellate}, - { "getTessellation", _wrap_Path_getTessellation}, - { "simplify", _wrap_Path_simplify}, - { "translate", _wrap_Path_translate}, - { "rotate", _wrap_Path_rotate}, - { "scale", _wrap_Path_scale}, - { "append", _wrap_Path_append}, - { "setMode", _wrap_Path_setMode}, - { "getMode", _wrap_Path_getMode}, - { "getCommands", _wrap_Path_getCommands}, - {0,0} -}; -static swig_lua_method swig_Path_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_Path_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_Path_Sf_SwigStatic_constants[]= { - {SWIG_LUA_CONSTTAB_INT("COMMANDS", ofPath::COMMANDS)}, - {SWIG_LUA_CONSTTAB_INT("POLYLINES", ofPath::POLYLINES)}, - {0,0,0,0,0,0} -}; -static swig_lua_method swig_Path_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_Path_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_Path_Sf_SwigStatic = { - "Path", - swig_Path_Sf_SwigStatic_methods, - swig_Path_Sf_SwigStatic_attributes, - swig_Path_Sf_SwigStatic_constants, - swig_Path_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_Path_bases[] = {0}; -static const char *swig_Path_base_names[] = {0}; -static swig_lua_class _wrap_class_Path = { "Path", "Path", &SWIGTYPE_p_ofPath,_proxy__wrap_new_Path, swig_delete_Path, swig_Path_methods, swig_Path_attributes, &swig_Path_Sf_SwigStatic, swig_Path_meta, swig_Path_bases, swig_Path_base_names }; - -static int _wrap_new_Polyline__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPolyline *result = 0 ; - SWIG_check_num_args("ofPolyline::ofPolyline",0,0) result = (ofPolyline *)new ofPolyline(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofPolyline,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Polyline__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::vector< ofPoint > *arg1 = 0 ; - ofPolyline *result = 0 ; SWIG_check_num_args("ofPolyline::ofPolyline",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofPolyline::ofPolyline",1,"std::vector< ofPoint > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofVec3f_t,0))){ - SWIG_fail_ptr("new_Polyline",1,SWIGTYPE_p_std__vectorT_ofVec3f_t); } - result = (ofPolyline *)new ofPolyline((std::vector< ofPoint > const &)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofPolyline,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Polyline(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_Polyline__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_std__vectorT_ofVec3f_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_new_Polyline__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_Polyline'\n" " Possible C/C++ prototypes are:\n" - " ofPolyline::ofPolyline()\n" " ofPolyline::ofPolyline(std::vector< ofPoint > const &)\n"); lua_error(L);return 0; } -static int _wrap_Polyline_fromRectangle(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = 0 ; ofPolyline result; - SWIG_check_num_args("ofPolyline::fromRectangle",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofPolyline::fromRectangle",1,"ofRectangle const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Polyline_fromRectangle",1,SWIGTYPE_p_ofRectangle); } - result = ofPolyline::fromRectangle((ofRectangle const &)*arg1); { - ofPolyline * resultptr = new ofPolyline((const ofPolyline &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofPolyline,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_clear(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - SWIG_check_num_args("ofPolyline::clear",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::clear",1,"ofPolyline *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_clear",1,SWIGTYPE_p_ofPolyline); } (arg1)->clear(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_addVertex__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - ofPoint *arg2 = 0 ; SWIG_check_num_args("ofPolyline::addVertex",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::addVertex",1,"ofPolyline *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline::addVertex",2,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_addVertex",1,SWIGTYPE_p_ofPolyline); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Polyline_addVertex",2,SWIGTYPE_p_ofVec3f); } (arg1)->addVertex((ofPoint const &)*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_addVertex__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; float arg2 ; - float arg3 ; float arg4 ; SWIG_check_num_args("ofPolyline::addVertex",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::addVertex",1,"ofPolyline *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::addVertex",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::addVertex",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPolyline::addVertex",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_addVertex",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); (arg1)->addVertex(arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_addVertex__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; float arg2 ; - float arg3 ; SWIG_check_num_args("ofPolyline::addVertex",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::addVertex",1,"ofPolyline *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::addVertex",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::addVertex",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_addVertex",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->addVertex(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Polyline_addVertex(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Polyline_addVertex__SWIG_0(L);} } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_Polyline_addVertex__SWIG_2(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Polyline_addVertex__SWIG_1(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Polyline_addVertex'\n" " Possible C/C++ prototypes are:\n" - " ofPolyline::addVertex(ofPoint const &)\n" " ofPolyline::addVertex(float,float,float)\n" - " ofPolyline::addVertex(float,float)\n"); lua_error(L);return 0; } -static int _wrap_Polyline_addVertices__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - std::vector< ofPoint > *arg2 = 0 ; SWIG_check_num_args("ofPolyline::addVertices",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::addVertices",1,"ofPolyline *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline::addVertices",2,"std::vector< ofPoint > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_addVertices",1,SWIGTYPE_p_ofPolyline); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__vectorT_ofVec3f_t,0))){ - SWIG_fail_ptr("Polyline_addVertices",2,SWIGTYPE_p_std__vectorT_ofVec3f_t); } - (arg1)->addVertices((std::vector< ofPoint > const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Polyline_addVertices__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - ofPoint *arg2 = (ofPoint *) 0 ; int arg3 ; SWIG_check_num_args("ofPolyline::addVertices",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::addVertices",1,"ofPolyline *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofPolyline::addVertices",2,"ofPoint const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::addVertices",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_addVertices",1,SWIGTYPE_p_ofPolyline); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Polyline_addVertices",2,SWIGTYPE_p_ofVec3f); } arg3 = (int)lua_tonumber(L, 3); - (arg1)->addVertices((ofPoint const *)arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_addVertices(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_std__vectorT_ofVec3f_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Polyline_addVertices__SWIG_0(L);} } } if (argc == 3) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Polyline_addVertices__SWIG_1(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Polyline_addVertices'\n" - " Possible C/C++ prototypes are:\n" " ofPolyline::addVertices(std::vector< ofPoint > const &)\n" - " ofPolyline::addVertices(ofPoint const *,int)\n"); lua_error(L);return 0; } -static int _wrap_Polyline_insertVertex__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - ofPoint *arg2 = 0 ; int arg3 ; SWIG_check_num_args("ofPolyline::insertVertex",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::insertVertex",1,"ofPolyline *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline::insertVertex",2,"ofPoint const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::insertVertex",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_insertVertex",1,SWIGTYPE_p_ofPolyline); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Polyline_insertVertex",2,SWIGTYPE_p_ofVec3f); } arg3 = (int)lua_tonumber(L, 3); - (arg1)->insertVertex((ofPoint const &)*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_insertVertex__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - float arg2 ; float arg3 ; float arg4 ; int arg5 ; SWIG_check_num_args("ofPolyline::insertVertex",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::insertVertex",1,"ofPolyline *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::insertVertex",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::insertVertex",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPolyline::insertVertex",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPolyline::insertVertex",5,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_insertVertex",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); - (arg1)->insertVertex(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_insertVertex(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Polyline_insertVertex__SWIG_0(L);} } } } if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Polyline_insertVertex__SWIG_1(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Polyline_insertVertex'\n" - " Possible C/C++ prototypes are:\n" " ofPolyline::insertVertex(ofPoint const &,int)\n" - " ofPolyline::insertVertex(float,float,float,int)\n"); lua_error(L);return 0; } -static int _wrap_Polyline_resize(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; size_t arg2 ; - SWIG_check_num_args("ofPolyline::resize",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::resize",1,"ofPolyline *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::resize",2,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_resize",1,SWIGTYPE_p_ofPolyline); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - (arg1)->resize(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_size(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; size_t result; - SWIG_check_num_args("ofPolyline::size",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::size",1,"ofPolyline const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_size",1,SWIGTYPE_p_ofPolyline); } result = (size_t)((ofPolyline const *)arg1)->size(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_getVertices__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - std::vector< ofPoint > *result = 0 ; SWIG_check_num_args("ofPolyline::getVertices",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::getVertices",1,"ofPolyline *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_getVertices",1,SWIGTYPE_p_ofPolyline); } - result = (std::vector< ofPoint > *) &(arg1)->getVertices(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofVec3f_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_getVertices__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - std::vector< ofPoint > *result = 0 ; SWIG_check_num_args("ofPolyline::getVertices",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::getVertices",1,"ofPolyline const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_getVertices",1,SWIGTYPE_p_ofPolyline); } - result = (std::vector< ofPoint > *) &((ofPolyline const *)arg1)->getVertices(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofVec3f_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_getVertices(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Polyline_getVertices__SWIG_0(L);} } if (argc == 1) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Polyline_getVertices__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Polyline_getVertices'\n" - " Possible C/C++ prototypes are:\n" " ofPolyline::getVertices()\n" " ofPolyline::getVertices() const\n"); - lua_error(L);return 0; } -static int _wrap_Polyline_lineTo__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - ofPoint *arg2 = 0 ; SWIG_check_num_args("ofPolyline::lineTo",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::lineTo",1,"ofPolyline *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline::lineTo",2,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_lineTo",1,SWIGTYPE_p_ofPolyline); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Polyline_lineTo",2,SWIGTYPE_p_ofVec3f); } (arg1)->lineTo((ofPoint const &)*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_lineTo__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; float arg2 ; - float arg3 ; float arg4 ; SWIG_check_num_args("ofPolyline::lineTo",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::lineTo",1,"ofPolyline *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::lineTo",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::lineTo",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPolyline::lineTo",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_lineTo",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); (arg1)->lineTo(arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_lineTo__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; float arg2 ; - float arg3 ; SWIG_check_num_args("ofPolyline::lineTo",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::lineTo",1,"ofPolyline *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::lineTo",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::lineTo",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_lineTo",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->lineTo(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Polyline_lineTo(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Polyline_lineTo__SWIG_0(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Polyline_lineTo__SWIG_2(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Polyline_lineTo__SWIG_1(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Polyline_lineTo'\n" " Possible C/C++ prototypes are:\n" - " ofPolyline::lineTo(ofPoint const &)\n" " ofPolyline::lineTo(float,float,float)\n" - " ofPolyline::lineTo(float,float)\n"); lua_error(L);return 0; } -static int _wrap_Polyline_arc__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - ofPoint *arg2 = 0 ; float arg3 ; float arg4 ; float arg5 ; float arg6 ; bool arg7 ; int arg8 ; - SWIG_check_num_args("ofPolyline::arc",8,8) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::arc",1,"ofPolyline *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline::arc",2,"ofPoint const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::arc",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPolyline::arc",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPolyline::arc",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPolyline::arc",6,"float"); - if(!lua_isboolean(L,7)) SWIG_fail_arg("ofPolyline::arc",7,"bool"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofPolyline::arc",8,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_arc",1,SWIGTYPE_p_ofPolyline); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Polyline_arc",2,SWIGTYPE_p_ofVec3f); } - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (lua_toboolean(L, 7)!=0); arg8 = (int)lua_tonumber(L, 8); - (arg1)->arc((ofPoint const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Polyline_arc__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - ofPoint *arg2 = 0 ; float arg3 ; float arg4 ; float arg5 ; float arg6 ; bool arg7 ; SWIG_check_num_args("ofPolyline::arc",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::arc",1,"ofPolyline *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline::arc",2,"ofPoint const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::arc",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPolyline::arc",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPolyline::arc",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPolyline::arc",6,"float"); - if(!lua_isboolean(L,7)) SWIG_fail_arg("ofPolyline::arc",7,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_arc",1,SWIGTYPE_p_ofPolyline); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Polyline_arc",2,SWIGTYPE_p_ofVec3f); } - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (lua_toboolean(L, 7)!=0); - (arg1)->arc((ofPoint const &)*arg2,arg3,arg4,arg5,arg6,arg7); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Polyline_arc__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - ofPoint *arg2 = 0 ; float arg3 ; float arg4 ; float arg5 ; float arg6 ; int arg7 ; SWIG_check_num_args("ofPolyline::arc",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::arc",1,"ofPolyline *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline::arc",2,"ofPoint const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::arc",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPolyline::arc",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPolyline::arc",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPolyline::arc",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPolyline::arc",7,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_arc",1,SWIGTYPE_p_ofPolyline); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Polyline_arc",2,SWIGTYPE_p_ofVec3f); } - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (int)lua_tonumber(L, 7); - (arg1)->arc((ofPoint const &)*arg2,arg3,arg4,arg5,arg6,arg7); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Polyline_arc__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - ofPoint *arg2 = 0 ; float arg3 ; float arg4 ; float arg5 ; float arg6 ; SWIG_check_num_args("ofPolyline::arc",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::arc",1,"ofPolyline *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline::arc",2,"ofPoint const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::arc",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPolyline::arc",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPolyline::arc",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPolyline::arc",6,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_arc",1,SWIGTYPE_p_ofPolyline); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Polyline_arc",2,SWIGTYPE_p_ofVec3f); } - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); (arg1)->arc((ofPoint const &)*arg2,arg3,arg4,arg5,arg6); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_arc__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; float arg2 ; - float arg3 ; float arg4 ; float arg5 ; float arg6 ; float arg7 ; int arg8 ; SWIG_check_num_args("ofPolyline::arc",8,8) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::arc",1,"ofPolyline *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::arc",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::arc",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPolyline::arc",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPolyline::arc",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPolyline::arc",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPolyline::arc",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofPolyline::arc",8,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_arc",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (int)lua_tonumber(L, 8); - (arg1)->arc(arg2,arg3,arg4,arg5,arg6,arg7,arg8); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_arc__SWIG_5(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; float arg2 ; - float arg3 ; float arg4 ; float arg5 ; float arg6 ; float arg7 ; SWIG_check_num_args("ofPolyline::arc",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::arc",1,"ofPolyline *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::arc",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::arc",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPolyline::arc",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPolyline::arc",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPolyline::arc",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPolyline::arc",7,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_arc",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); (arg1)->arc(arg2,arg3,arg4,arg5,arg6,arg7); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_arc__SWIG_6(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; float arg2 ; - float arg3 ; float arg4 ; float arg5 ; float arg6 ; float arg7 ; float arg8 ; int arg9 ; - SWIG_check_num_args("ofPolyline::arc",9,9) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::arc",1,"ofPolyline *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::arc",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::arc",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPolyline::arc",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPolyline::arc",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPolyline::arc",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPolyline::arc",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofPolyline::arc",8,"float"); - if(!lua_isnumber(L,9)) SWIG_fail_arg("ofPolyline::arc",9,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_arc",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (float)lua_tonumber(L, 8); - arg9 = (int)lua_tonumber(L, 9); (arg1)->arc(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_arc(lua_State* L) { int argc; int argv[10]={ 1,2,3,4,5,6,7,8,9,10} ; argc = lua_gettop(L); - if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { - return _wrap_Polyline_arc__SWIG_3(L);} } } } } } } if (argc == 7) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { { - _v = lua_isboolean(L,argv[6]); } if (_v) { return _wrap_Polyline_arc__SWIG_1(L);} } } } } } } } - if (argc == 7) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { { - _v = lua_isnumber(L,argv[6]); } if (_v) { return _wrap_Polyline_arc__SWIG_2(L);} } } } } } } } - if (argc == 7) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { - return _wrap_Polyline_arc__SWIG_5(L);} } } } } } } } if (argc == 8) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { { - _v = lua_isboolean(L,argv[6]); } if (_v) { { _v = lua_isnumber(L,argv[7]); } if (_v) { - return _wrap_Polyline_arc__SWIG_0(L);} } } } } } } } } if (argc == 8) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { return _wrap_Polyline_arc__SWIG_4(L);} } } } } } } } } - if (argc == 9) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { { _v = lua_isnumber(L,argv[8]); } if (_v) { - return _wrap_Polyline_arc__SWIG_6(L);} } } } } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Polyline_arc'\n" " Possible C/C++ prototypes are:\n" - " ofPolyline::arc(ofPoint const &,float,float,float,float,bool,int)\n" - " ofPolyline::arc(ofPoint const &,float,float,float,float,bool)\n" - " ofPolyline::arc(ofPoint const &,float,float,float,float,int)\n" - " ofPolyline::arc(ofPoint const &,float,float,float,float)\n" - " ofPolyline::arc(float,float,float,float,float,float,int)\n" " ofPolyline::arc(float,float,float,float,float,float)\n" - " ofPolyline::arc(float,float,float,float,float,float,float,int)\n"); lua_error(L);return 0; } -static int _wrap_Polyline_arcNegative__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - ofPoint *arg2 = 0 ; float arg3 ; float arg4 ; float arg5 ; float arg6 ; int arg7 ; - SWIG_check_num_args("ofPolyline::arcNegative",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::arcNegative",1,"ofPolyline *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline::arcNegative",2,"ofPoint const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::arcNegative",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPolyline::arcNegative",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPolyline::arcNegative",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPolyline::arcNegative",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPolyline::arcNegative",7,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_arcNegative",1,SWIGTYPE_p_ofPolyline); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Polyline_arcNegative",2,SWIGTYPE_p_ofVec3f); } arg3 = (float)lua_tonumber(L, 3); - arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); - arg7 = (int)lua_tonumber(L, 7); (arg1)->arcNegative((ofPoint const &)*arg2,arg3,arg4,arg5,arg6,arg7); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_arcNegative__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - ofPoint *arg2 = 0 ; float arg3 ; float arg4 ; float arg5 ; float arg6 ; SWIG_check_num_args("ofPolyline::arcNegative",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::arcNegative",1,"ofPolyline *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline::arcNegative",2,"ofPoint const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::arcNegative",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPolyline::arcNegative",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPolyline::arcNegative",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPolyline::arcNegative",6,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_arcNegative",1,SWIGTYPE_p_ofPolyline); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Polyline_arcNegative",2,SWIGTYPE_p_ofVec3f); } arg3 = (float)lua_tonumber(L, 3); - arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); - (arg1)->arcNegative((ofPoint const &)*arg2,arg3,arg4,arg5,arg6); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Polyline_arcNegative__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - float arg2 ; float arg3 ; float arg4 ; float arg5 ; float arg6 ; float arg7 ; int arg8 ; - SWIG_check_num_args("ofPolyline::arcNegative",8,8) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::arcNegative",1,"ofPolyline *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::arcNegative",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::arcNegative",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPolyline::arcNegative",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPolyline::arcNegative",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPolyline::arcNegative",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPolyline::arcNegative",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofPolyline::arcNegative",8,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_arcNegative",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (int)lua_tonumber(L, 8); - (arg1)->arcNegative(arg2,arg3,arg4,arg5,arg6,arg7,arg8); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Polyline_arcNegative__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - float arg2 ; float arg3 ; float arg4 ; float arg5 ; float arg6 ; float arg7 ; - SWIG_check_num_args("ofPolyline::arcNegative",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::arcNegative",1,"ofPolyline *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::arcNegative",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::arcNegative",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPolyline::arcNegative",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPolyline::arcNegative",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPolyline::arcNegative",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPolyline::arcNegative",7,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_arcNegative",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); (arg1)->arcNegative(arg2,arg3,arg4,arg5,arg6,arg7); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_arcNegative__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - float arg2 ; float arg3 ; float arg4 ; float arg5 ; float arg6 ; float arg7 ; float arg8 ; int arg9 ; - SWIG_check_num_args("ofPolyline::arcNegative",9,9) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::arcNegative",1,"ofPolyline *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::arcNegative",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::arcNegative",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPolyline::arcNegative",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPolyline::arcNegative",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPolyline::arcNegative",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPolyline::arcNegative",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofPolyline::arcNegative",8,"float"); - if(!lua_isnumber(L,9)) SWIG_fail_arg("ofPolyline::arcNegative",9,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_arcNegative",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (float)lua_tonumber(L, 8); - arg9 = (int)lua_tonumber(L, 9); (arg1)->arcNegative(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_arcNegative(lua_State* L) { int argc; int argv[10]={ 1,2,3,4,5,6,7,8,9,10} ; argc = lua_gettop(L); - if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { - return _wrap_Polyline_arcNegative__SWIG_1(L);} } } } } } } if (argc == 7) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { { - _v = lua_isnumber(L,argv[6]); } if (_v) { return _wrap_Polyline_arcNegative__SWIG_0(L);} } } } } } } } - if (argc == 7) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { - return _wrap_Polyline_arcNegative__SWIG_3(L);} } } } } } } } if (argc == 8) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { return _wrap_Polyline_arcNegative__SWIG_2(L);} } } } } } } - } } if (argc == 9) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { { _v = lua_isnumber(L,argv[8]); } if (_v) { - return _wrap_Polyline_arcNegative__SWIG_4(L);} } } } } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Polyline_arcNegative'\n" - " Possible C/C++ prototypes are:\n" " ofPolyline::arcNegative(ofPoint const &,float,float,float,float,int)\n" - " ofPolyline::arcNegative(ofPoint const &,float,float,float,float)\n" - " ofPolyline::arcNegative(float,float,float,float,float,float,int)\n" - " ofPolyline::arcNegative(float,float,float,float,float,float)\n" - " ofPolyline::arcNegative(float,float,float,float,float,float,float,int)\n"); lua_error(L);return 0; } -static int _wrap_Polyline_curveTo__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - ofPoint *arg2 = 0 ; int arg3 ; SWIG_check_num_args("ofPolyline::curveTo",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::curveTo",1,"ofPolyline *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline::curveTo",2,"ofPoint const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::curveTo",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_curveTo",1,SWIGTYPE_p_ofPolyline); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Polyline_curveTo",2,SWIGTYPE_p_ofVec3f); } arg3 = (int)lua_tonumber(L, 3); - (arg1)->curveTo((ofPoint const &)*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_curveTo__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - ofPoint *arg2 = 0 ; SWIG_check_num_args("ofPolyline::curveTo",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::curveTo",1,"ofPolyline *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline::curveTo",2,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_curveTo",1,SWIGTYPE_p_ofPolyline); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Polyline_curveTo",2,SWIGTYPE_p_ofVec3f); } (arg1)->curveTo((ofPoint const &)*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_curveTo__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; float arg2 ; - float arg3 ; float arg4 ; int arg5 ; SWIG_check_num_args("ofPolyline::curveTo",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::curveTo",1,"ofPolyline *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::curveTo",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::curveTo",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPolyline::curveTo",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPolyline::curveTo",5,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_curveTo",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); - (arg1)->curveTo(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_curveTo__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; float arg2 ; - float arg3 ; float arg4 ; SWIG_check_num_args("ofPolyline::curveTo",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::curveTo",1,"ofPolyline *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::curveTo",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::curveTo",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPolyline::curveTo",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_curveTo",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); (arg1)->curveTo(arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_curveTo__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; float arg2 ; - float arg3 ; SWIG_check_num_args("ofPolyline::curveTo",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::curveTo",1,"ofPolyline *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::curveTo",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::curveTo",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_curveTo",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->curveTo(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Polyline_curveTo(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Polyline_curveTo__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Polyline_curveTo__SWIG_0(L);} - } } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Polyline_curveTo__SWIG_4(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Polyline_curveTo__SWIG_3(L);} } } } } if (argc == 5) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Polyline_curveTo__SWIG_2(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Polyline_curveTo'\n" " Possible C/C++ prototypes are:\n" - " ofPolyline::curveTo(ofPoint const &,int)\n" " ofPolyline::curveTo(ofPoint const &)\n" - " ofPolyline::curveTo(float,float,float,int)\n" " ofPolyline::curveTo(float,float,float)\n" - " ofPolyline::curveTo(float,float)\n"); lua_error(L);return 0; } -static int _wrap_Polyline_bezierTo__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - ofPoint *arg2 = 0 ; ofPoint *arg3 = 0 ; ofPoint *arg4 = 0 ; int arg5 ; SWIG_check_num_args("ofPolyline::bezierTo",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::bezierTo",1,"ofPolyline *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline::bezierTo",2,"ofPoint const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofPolyline::bezierTo",3,"ofPoint const &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofPolyline::bezierTo",4,"ofPoint const &"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPolyline::bezierTo",5,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_bezierTo",1,SWIGTYPE_p_ofPolyline); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Polyline_bezierTo",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Polyline_bezierTo",3,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Polyline_bezierTo",4,SWIGTYPE_p_ofVec3f); } arg5 = (int)lua_tonumber(L, 5); - (arg1)->bezierTo((ofPoint const &)*arg2,(ofPoint const &)*arg3,(ofPoint const &)*arg4,arg5); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_bezierTo__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - ofPoint *arg2 = 0 ; ofPoint *arg3 = 0 ; ofPoint *arg4 = 0 ; SWIG_check_num_args("ofPolyline::bezierTo",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::bezierTo",1,"ofPolyline *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline::bezierTo",2,"ofPoint const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofPolyline::bezierTo",3,"ofPoint const &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofPolyline::bezierTo",4,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_bezierTo",1,SWIGTYPE_p_ofPolyline); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Polyline_bezierTo",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Polyline_bezierTo",3,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Polyline_bezierTo",4,SWIGTYPE_p_ofVec3f); } - (arg1)->bezierTo((ofPoint const &)*arg2,(ofPoint const &)*arg3,(ofPoint const &)*arg4); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_bezierTo__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; float arg2 ; - float arg3 ; float arg4 ; float arg5 ; float arg6 ; float arg7 ; int arg8 ; SWIG_check_num_args("ofPolyline::bezierTo",8,8) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::bezierTo",1,"ofPolyline *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::bezierTo",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::bezierTo",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPolyline::bezierTo",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPolyline::bezierTo",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPolyline::bezierTo",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPolyline::bezierTo",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofPolyline::bezierTo",8,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_bezierTo",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (int)lua_tonumber(L, 8); - (arg1)->bezierTo(arg2,arg3,arg4,arg5,arg6,arg7,arg8); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_bezierTo__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; float arg2 ; - float arg3 ; float arg4 ; float arg5 ; float arg6 ; float arg7 ; SWIG_check_num_args("ofPolyline::bezierTo",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::bezierTo",1,"ofPolyline *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::bezierTo",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::bezierTo",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPolyline::bezierTo",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPolyline::bezierTo",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPolyline::bezierTo",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPolyline::bezierTo",7,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_bezierTo",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); (arg1)->bezierTo(arg2,arg3,arg4,arg5,arg6,arg7); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_bezierTo__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; float arg2 ; - float arg3 ; float arg4 ; float arg5 ; float arg6 ; float arg7 ; float arg8 ; float arg9 ; float arg10 ; int arg11 ; - SWIG_check_num_args("ofPolyline::bezierTo",11,11) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::bezierTo",1,"ofPolyline *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::bezierTo",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::bezierTo",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPolyline::bezierTo",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPolyline::bezierTo",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPolyline::bezierTo",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPolyline::bezierTo",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofPolyline::bezierTo",8,"float"); - if(!lua_isnumber(L,9)) SWIG_fail_arg("ofPolyline::bezierTo",9,"float"); - if(!lua_isnumber(L,10)) SWIG_fail_arg("ofPolyline::bezierTo",10,"float"); - if(!lua_isnumber(L,11)) SWIG_fail_arg("ofPolyline::bezierTo",11,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_bezierTo",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (float)lua_tonumber(L, 8); - arg9 = (float)lua_tonumber(L, 9); arg10 = (float)lua_tonumber(L, 10); arg11 = (int)lua_tonumber(L, 11); - (arg1)->bezierTo(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Polyline_bezierTo__SWIG_5(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; float arg2 ; - float arg3 ; float arg4 ; float arg5 ; float arg6 ; float arg7 ; float arg8 ; float arg9 ; float arg10 ; - SWIG_check_num_args("ofPolyline::bezierTo",10,10) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::bezierTo",1,"ofPolyline *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::bezierTo",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::bezierTo",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPolyline::bezierTo",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPolyline::bezierTo",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPolyline::bezierTo",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPolyline::bezierTo",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofPolyline::bezierTo",8,"float"); - if(!lua_isnumber(L,9)) SWIG_fail_arg("ofPolyline::bezierTo",9,"float"); - if(!lua_isnumber(L,10)) SWIG_fail_arg("ofPolyline::bezierTo",10,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_bezierTo",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (float)lua_tonumber(L, 8); - arg9 = (float)lua_tonumber(L, 9); arg10 = (float)lua_tonumber(L, 10); - (arg1)->bezierTo(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Polyline_bezierTo(lua_State* L) { int argc; int argv[12]={ 1,2,3,4,5,6,7,8,9,10,11,12} ; argc = lua_gettop(L); - if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Polyline_bezierTo__SWIG_1(L);} } } } } if (argc == 5) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Polyline_bezierTo__SWIG_0(L);} } } } } } if (argc == 7) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { - return _wrap_Polyline_bezierTo__SWIG_3(L);} } } } } } } } if (argc == 8) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { return _wrap_Polyline_bezierTo__SWIG_2(L);} } } } } } } } - } if (argc == 10) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { { _v = lua_isnumber(L,argv[8]); } if (_v) { { - _v = lua_isnumber(L,argv[9]); } if (_v) { return _wrap_Polyline_bezierTo__SWIG_5(L);} } } } } } } - } } } } if (argc == 11) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { { _v = lua_isnumber(L,argv[8]); } if (_v) { { - _v = lua_isnumber(L,argv[9]); } if (_v) { { _v = lua_isnumber(L,argv[10]); } if (_v) { - return _wrap_Polyline_bezierTo__SWIG_4(L);} } } } } } } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Polyline_bezierTo'\n" " Possible C/C++ prototypes are:\n" - " ofPolyline::bezierTo(ofPoint const &,ofPoint const &,ofPoint const &,int)\n" - " ofPolyline::bezierTo(ofPoint const &,ofPoint const &,ofPoint const &)\n" - " ofPolyline::bezierTo(float,float,float,float,float,float,int)\n" - " ofPolyline::bezierTo(float,float,float,float,float,float)\n" - " ofPolyline::bezierTo(float,float,float,float,float,float,float,float,float,int)\n" - " ofPolyline::bezierTo(float,float,float,float,float,float,float,float,float)\n"); lua_error(L);return 0; } -static int _wrap_Polyline_quadBezierTo__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - float arg2 ; float arg3 ; float arg4 ; float arg5 ; float arg6 ; float arg7 ; float arg8 ; float arg9 ; float arg10 ; - int arg11 ; SWIG_check_num_args("ofPolyline::quadBezierTo",11,11) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::quadBezierTo",1,"ofPolyline *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::quadBezierTo",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::quadBezierTo",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPolyline::quadBezierTo",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPolyline::quadBezierTo",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPolyline::quadBezierTo",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPolyline::quadBezierTo",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofPolyline::quadBezierTo",8,"float"); - if(!lua_isnumber(L,9)) SWIG_fail_arg("ofPolyline::quadBezierTo",9,"float"); - if(!lua_isnumber(L,10)) SWIG_fail_arg("ofPolyline::quadBezierTo",10,"float"); - if(!lua_isnumber(L,11)) SWIG_fail_arg("ofPolyline::quadBezierTo",11,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_quadBezierTo",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (float)lua_tonumber(L, 8); - arg9 = (float)lua_tonumber(L, 9); arg10 = (float)lua_tonumber(L, 10); arg11 = (int)lua_tonumber(L, 11); - (arg1)->quadBezierTo(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_quadBezierTo__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - float arg2 ; float arg3 ; float arg4 ; float arg5 ; float arg6 ; float arg7 ; float arg8 ; float arg9 ; float arg10 ; - SWIG_check_num_args("ofPolyline::quadBezierTo",10,10) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::quadBezierTo",1,"ofPolyline *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::quadBezierTo",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::quadBezierTo",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPolyline::quadBezierTo",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPolyline::quadBezierTo",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPolyline::quadBezierTo",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPolyline::quadBezierTo",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofPolyline::quadBezierTo",8,"float"); - if(!lua_isnumber(L,9)) SWIG_fail_arg("ofPolyline::quadBezierTo",9,"float"); - if(!lua_isnumber(L,10)) SWIG_fail_arg("ofPolyline::quadBezierTo",10,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_quadBezierTo",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (float)lua_tonumber(L, 8); - arg9 = (float)lua_tonumber(L, 9); arg10 = (float)lua_tonumber(L, 10); - (arg1)->quadBezierTo(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Polyline_quadBezierTo__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - ofPoint *arg2 = 0 ; ofPoint *arg3 = 0 ; ofPoint *arg4 = 0 ; int arg5 ; SWIG_check_num_args("ofPolyline::quadBezierTo",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::quadBezierTo",1,"ofPolyline *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline::quadBezierTo",2,"ofPoint const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofPolyline::quadBezierTo",3,"ofPoint const &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofPolyline::quadBezierTo",4,"ofPoint const &"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPolyline::quadBezierTo",5,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_quadBezierTo",1,SWIGTYPE_p_ofPolyline); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Polyline_quadBezierTo",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Polyline_quadBezierTo",3,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Polyline_quadBezierTo",4,SWIGTYPE_p_ofVec3f); } arg5 = (int)lua_tonumber(L, 5); - (arg1)->quadBezierTo((ofPoint const &)*arg2,(ofPoint const &)*arg3,(ofPoint const &)*arg4,arg5); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_quadBezierTo__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - ofPoint *arg2 = 0 ; ofPoint *arg3 = 0 ; ofPoint *arg4 = 0 ; SWIG_check_num_args("ofPolyline::quadBezierTo",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::quadBezierTo",1,"ofPolyline *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline::quadBezierTo",2,"ofPoint const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofPolyline::quadBezierTo",3,"ofPoint const &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofPolyline::quadBezierTo",4,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_quadBezierTo",1,SWIGTYPE_p_ofPolyline); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Polyline_quadBezierTo",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Polyline_quadBezierTo",3,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Polyline_quadBezierTo",4,SWIGTYPE_p_ofVec3f); } - (arg1)->quadBezierTo((ofPoint const &)*arg2,(ofPoint const &)*arg3,(ofPoint const &)*arg4); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_quadBezierTo__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - float arg2 ; float arg3 ; float arg4 ; float arg5 ; float arg6 ; float arg7 ; int arg8 ; - SWIG_check_num_args("ofPolyline::quadBezierTo",8,8) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::quadBezierTo",1,"ofPolyline *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::quadBezierTo",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::quadBezierTo",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPolyline::quadBezierTo",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPolyline::quadBezierTo",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPolyline::quadBezierTo",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPolyline::quadBezierTo",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofPolyline::quadBezierTo",8,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_quadBezierTo",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (int)lua_tonumber(L, 8); - (arg1)->quadBezierTo(arg2,arg3,arg4,arg5,arg6,arg7,arg8); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Polyline_quadBezierTo__SWIG_5(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - float arg2 ; float arg3 ; float arg4 ; float arg5 ; float arg6 ; float arg7 ; - SWIG_check_num_args("ofPolyline::quadBezierTo",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::quadBezierTo",1,"ofPolyline *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::quadBezierTo",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::quadBezierTo",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPolyline::quadBezierTo",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPolyline::quadBezierTo",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPolyline::quadBezierTo",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPolyline::quadBezierTo",7,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_quadBezierTo",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); (arg1)->quadBezierTo(arg2,arg3,arg4,arg5,arg6,arg7); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_quadBezierTo(lua_State* L) { int argc; int argv[12]={ 1,2,3,4,5,6,7,8,9,10,11,12} ; - argc = lua_gettop(L); if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Polyline_quadBezierTo__SWIG_3(L);} } } } } if (argc == 5) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Polyline_quadBezierTo__SWIG_2(L);} } } } } } if (argc == 7) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { - return _wrap_Polyline_quadBezierTo__SWIG_5(L);} } } } } } } } if (argc == 8) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { return _wrap_Polyline_quadBezierTo__SWIG_4(L);} } } } } } } - } } if (argc == 10) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { { _v = lua_isnumber(L,argv[8]); } if (_v) { { - _v = lua_isnumber(L,argv[9]); } if (_v) { return _wrap_Polyline_quadBezierTo__SWIG_1(L);} } } } } } - } } } } } if (argc == 11) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { { _v = lua_isnumber(L,argv[8]); } if (_v) { { - _v = lua_isnumber(L,argv[9]); } if (_v) { { _v = lua_isnumber(L,argv[10]); } if (_v) { - return _wrap_Polyline_quadBezierTo__SWIG_0(L);} } } } } } } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Polyline_quadBezierTo'\n" - " Possible C/C++ prototypes are:\n" - " ofPolyline::quadBezierTo(float,float,float,float,float,float,float,float,float,int)\n" - " ofPolyline::quadBezierTo(float,float,float,float,float,float,float,float,float)\n" - " ofPolyline::quadBezierTo(ofPoint const &,ofPoint const &,ofPoint const &,int)\n" - " ofPolyline::quadBezierTo(ofPoint const &,ofPoint const &,ofPoint const &)\n" - " ofPolyline::quadBezierTo(float,float,float,float,float,float,int)\n" - " ofPolyline::quadBezierTo(float,float,float,float,float,float)\n"); lua_error(L);return 0; } -static int _wrap_Polyline_getSmoothed__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; int arg2 ; - float arg3 ; ofPolyline result; SWIG_check_num_args("ofPolyline::getSmoothed",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::getSmoothed",1,"ofPolyline const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::getSmoothed",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::getSmoothed",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_getSmoothed",1,SWIGTYPE_p_ofPolyline); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); result = ((ofPolyline const *)arg1)->getSmoothed(arg2,arg3); { - ofPolyline * resultptr = new ofPolyline((const ofPolyline &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofPolyline,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_getSmoothed__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; int arg2 ; - ofPolyline result; SWIG_check_num_args("ofPolyline::getSmoothed",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::getSmoothed",1,"ofPolyline const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::getSmoothed",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_getSmoothed",1,SWIGTYPE_p_ofPolyline); } arg2 = (int)lua_tonumber(L, 2); - result = ((ofPolyline const *)arg1)->getSmoothed(arg2); { - ofPolyline * resultptr = new ofPolyline((const ofPolyline &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofPolyline,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_getSmoothed(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Polyline_getSmoothed__SWIG_1(L);} - } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Polyline_getSmoothed__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Polyline_getSmoothed'\n" - " Possible C/C++ prototypes are:\n" " ofPolyline::getSmoothed(int,float) const\n" - " ofPolyline::getSmoothed(int) const\n"); lua_error(L);return 0; } -static int _wrap_Polyline_getResampledBySpacing(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - float arg2 ; ofPolyline result; SWIG_check_num_args("ofPolyline::getResampledBySpacing",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::getResampledBySpacing",1,"ofPolyline const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::getResampledBySpacing",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_getResampledBySpacing",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - result = ((ofPolyline const *)arg1)->getResampledBySpacing(arg2); { - ofPolyline * resultptr = new ofPolyline((const ofPolyline &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofPolyline,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_getResampledByCount(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; int arg2 ; - ofPolyline result; SWIG_check_num_args("ofPolyline::getResampledByCount",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::getResampledByCount",1,"ofPolyline const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::getResampledByCount",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_getResampledByCount",1,SWIGTYPE_p_ofPolyline); } arg2 = (int)lua_tonumber(L, 2); - result = ((ofPolyline const *)arg1)->getResampledByCount(arg2); { - ofPolyline * resultptr = new ofPolyline((const ofPolyline &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofPolyline,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_simplify__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; float arg2 ; - SWIG_check_num_args("ofPolyline::simplify",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::simplify",1,"ofPolyline *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::simplify",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_simplify",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); (arg1)->simplify(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_simplify__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - SWIG_check_num_args("ofPolyline::simplify",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::simplify",1,"ofPolyline *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_simplify",1,SWIGTYPE_p_ofPolyline); } (arg1)->simplify(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_simplify(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Polyline_simplify__SWIG_1(L);} } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Polyline_simplify__SWIG_0(L);} } - } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Polyline_simplify'\n" - " Possible C/C++ prototypes are:\n" " ofPolyline::simplify(float)\n" " ofPolyline::simplify()\n"); - lua_error(L);return 0; } -static int _wrap_Polyline_close(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - SWIG_check_num_args("ofPolyline::close",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::close",1,"ofPolyline *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_close",1,SWIGTYPE_p_ofPolyline); } (arg1)->close(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_setClosed(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; bool arg2 ; - SWIG_check_num_args("ofPolyline::setClosed",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::setClosed",1,"ofPolyline *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofPolyline::setClosed",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_setClosed",1,SWIGTYPE_p_ofPolyline); } arg2 = (lua_toboolean(L, 2)!=0); (arg1)->setClosed(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_isClosed(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; bool result; - SWIG_check_num_args("ofPolyline::isClosed",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::isClosed",1,"ofPolyline const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_isClosed",1,SWIGTYPE_p_ofPolyline); } result = (bool)((ofPolyline const *)arg1)->isClosed(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_hasChanged(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; bool result; - SWIG_check_num_args("ofPolyline::hasChanged",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::hasChanged",1,"ofPolyline *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_hasChanged",1,SWIGTYPE_p_ofPolyline); } result = (bool)(arg1)->hasChanged(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_flagHasChanged(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - SWIG_check_num_args("ofPolyline::flagHasChanged",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::flagHasChanged",1,"ofPolyline *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_flagHasChanged",1,SWIGTYPE_p_ofPolyline); } (arg1)->flagHasChanged(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_inside__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; ofPolyline *arg3 = 0 ; - bool result; SWIG_check_num_args("ofPolyline::inside",3,3) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofPolyline::inside",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::inside",2,"float"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofPolyline::inside",3,"ofPolyline const &"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_inside",3,SWIGTYPE_p_ofPolyline); } - result = (bool)ofPolyline::inside(arg1,arg2,(ofPolyline const &)*arg3); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_inside__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; float arg2 ; - float arg3 ; bool result; SWIG_check_num_args("ofPolyline::inside",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::inside",1,"ofPolyline const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::inside",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::inside",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_inside",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); result = (bool)((ofPolyline const *)arg1)->inside(arg2,arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_inside__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPoint *arg1 = 0 ; ofPolyline *arg2 = 0 ; - bool result; SWIG_check_num_args("ofPolyline::inside",2,2) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofPolyline::inside",1,"ofPoint const &"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline::inside",2,"ofPolyline const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Polyline_inside",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_inside",2,SWIGTYPE_p_ofPolyline); } - result = (bool)ofPolyline::inside((ofVec3f const &)*arg1,(ofPolyline const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_inside__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - ofPoint *arg2 = 0 ; bool result; SWIG_check_num_args("ofPolyline::inside",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::inside",1,"ofPolyline const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline::inside",2,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_inside",1,SWIGTYPE_p_ofPolyline); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Polyline_inside",2,SWIGTYPE_p_ofVec3f); } - result = (bool)((ofPolyline const *)arg1)->inside((ofPoint const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_inside(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Polyline_inside__SWIG_2(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Polyline_inside__SWIG_3(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Polyline_inside__SWIG_1(L);} } } } if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Polyline_inside__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Polyline_inside'\n" " Possible C/C++ prototypes are:\n" - " ofPolyline::inside(float,float,ofPolyline const &)\n" " ofPolyline::inside(float,float) const\n" - " ofPolyline::inside(ofPoint const &,ofPolyline const &)\n" " ofPolyline::inside(ofPoint const &) const\n"); - lua_error(L);return 0; } -static int _wrap_Polyline_getBoundingBox(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - ofRectangle result; SWIG_check_num_args("ofPolyline::getBoundingBox",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::getBoundingBox",1,"ofPolyline const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_getBoundingBox",1,SWIGTYPE_p_ofPolyline); } result = ((ofPolyline const *)arg1)->getBoundingBox(); - { ofRectangle * resultptr = new ofRectangle((const ofRectangle &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofRectangle,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_getPerimeter(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; float result; - SWIG_check_num_args("ofPolyline::getPerimeter",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::getPerimeter",1,"ofPolyline const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_getPerimeter",1,SWIGTYPE_p_ofPolyline); } - result = (float)((ofPolyline const *)arg1)->getPerimeter(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_getArea(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; float result; - SWIG_check_num_args("ofPolyline::getArea",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::getArea",1,"ofPolyline const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_getArea",1,SWIGTYPE_p_ofPolyline); } result = (float)((ofPolyline const *)arg1)->getArea(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_getCentroid2D(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; ofPoint result; - SWIG_check_num_args("ofPolyline::getCentroid2D",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::getCentroid2D",1,"ofPolyline const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_getCentroid2D",1,SWIGTYPE_p_ofPolyline); } result = ((ofPolyline const *)arg1)->getCentroid2D(); { - ofPoint * resultptr = new ofPoint((const ofPoint &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_getClosestPoint__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - ofPoint *arg2 = 0 ; unsigned int *arg3 = (unsigned int *) 0 ; ofPoint result; - SWIG_check_num_args("ofPolyline::getClosestPoint",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::getClosestPoint",1,"ofPolyline const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline::getClosestPoint",2,"ofPoint const &"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofPolyline::getClosestPoint",3,"unsigned int *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_getClosestPoint",1,SWIGTYPE_p_ofPolyline); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Polyline_getClosestPoint",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_unsigned_int,0))){ - SWIG_fail_ptr("Polyline_getClosestPoint",3,SWIGTYPE_p_unsigned_int); } - result = ((ofPolyline const *)arg1)->getClosestPoint((ofPoint const &)*arg2,arg3); { - ofPoint * resultptr = new ofPoint((const ofPoint &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_getClosestPoint__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - ofPoint *arg2 = 0 ; ofPoint result; SWIG_check_num_args("ofPolyline::getClosestPoint",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::getClosestPoint",1,"ofPolyline const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline::getClosestPoint",2,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_getClosestPoint",1,SWIGTYPE_p_ofPolyline); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Polyline_getClosestPoint",2,SWIGTYPE_p_ofVec3f); } - result = ((ofPolyline const *)arg1)->getClosestPoint((ofPoint const &)*arg2); { - ofPoint * resultptr = new ofPoint((const ofPoint &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_getClosestPoint(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Polyline_getClosestPoint__SWIG_1(L);} } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_unsigned_int, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Polyline_getClosestPoint__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Polyline_getClosestPoint'\n" - " Possible C/C++ prototypes are:\n" " ofPolyline::getClosestPoint(ofPoint const &,unsigned int *) const\n" - " ofPolyline::getClosestPoint(ofPoint const &) const\n"); lua_error(L);return 0; } -static int _wrap_Polyline_getIndexAtLength(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; float arg2 ; - float result; SWIG_check_num_args("ofPolyline::getIndexAtLength",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::getIndexAtLength",1,"ofPolyline const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::getIndexAtLength",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_getIndexAtLength",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - result = (float)((ofPolyline const *)arg1)->getIndexAtLength(arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_getIndexAtPercent(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; float arg2 ; - float result; SWIG_check_num_args("ofPolyline::getIndexAtPercent",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::getIndexAtPercent",1,"ofPolyline const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::getIndexAtPercent",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_getIndexAtPercent",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - result = (float)((ofPolyline const *)arg1)->getIndexAtPercent(arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_getLengthAtIndex(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; int arg2 ; - float result; SWIG_check_num_args("ofPolyline::getLengthAtIndex",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::getLengthAtIndex",1,"ofPolyline const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::getLengthAtIndex",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_getLengthAtIndex",1,SWIGTYPE_p_ofPolyline); } arg2 = (int)lua_tonumber(L, 2); - result = (float)((ofPolyline const *)arg1)->getLengthAtIndex(arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_getLengthAtIndexInterpolated(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - float arg2 ; float result; SWIG_check_num_args("ofPolyline::getLengthAtIndexInterpolated",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::getLengthAtIndexInterpolated",1,"ofPolyline const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::getLengthAtIndexInterpolated",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_getLengthAtIndexInterpolated",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - result = (float)((ofPolyline const *)arg1)->getLengthAtIndexInterpolated(arg2); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_getPointAtLength(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; float arg2 ; - ofPoint result; SWIG_check_num_args("ofPolyline::getPointAtLength",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::getPointAtLength",1,"ofPolyline const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::getPointAtLength",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_getPointAtLength",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - result = ((ofPolyline const *)arg1)->getPointAtLength(arg2); { ofPoint * resultptr = new ofPoint((const ofPoint &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_getPointAtPercent(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; float arg2 ; - ofPoint result; SWIG_check_num_args("ofPolyline::getPointAtPercent",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::getPointAtPercent",1,"ofPolyline const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::getPointAtPercent",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_getPointAtPercent",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - result = ((ofPolyline const *)arg1)->getPointAtPercent(arg2); { ofPoint * resultptr = new ofPoint((const ofPoint &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_getPointAtIndexInterpolated(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - float arg2 ; ofPoint result; SWIG_check_num_args("ofPolyline::getPointAtIndexInterpolated",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::getPointAtIndexInterpolated",1,"ofPolyline const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::getPointAtIndexInterpolated",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_getPointAtIndexInterpolated",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - result = ((ofPolyline const *)arg1)->getPointAtIndexInterpolated(arg2); { - ofPoint * resultptr = new ofPoint((const ofPoint &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_getAngleAtIndex(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; int arg2 ; - float result; SWIG_check_num_args("ofPolyline::getAngleAtIndex",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::getAngleAtIndex",1,"ofPolyline const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::getAngleAtIndex",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_getAngleAtIndex",1,SWIGTYPE_p_ofPolyline); } arg2 = (int)lua_tonumber(L, 2); - result = (float)((ofPolyline const *)arg1)->getAngleAtIndex(arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_getAngleAtIndexInterpolated(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - float arg2 ; float result; SWIG_check_num_args("ofPolyline::getAngleAtIndexInterpolated",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::getAngleAtIndexInterpolated",1,"ofPolyline const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::getAngleAtIndexInterpolated",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_getAngleAtIndexInterpolated",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - result = (float)((ofPolyline const *)arg1)->getAngleAtIndexInterpolated(arg2); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_getRotationAtIndex(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; int arg2 ; - ofVec3f result; SWIG_check_num_args("ofPolyline::getRotationAtIndex",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::getRotationAtIndex",1,"ofPolyline const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::getRotationAtIndex",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_getRotationAtIndex",1,SWIGTYPE_p_ofPolyline); } arg2 = (int)lua_tonumber(L, 2); - result = ((ofPolyline const *)arg1)->getRotationAtIndex(arg2); { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_getRotationAtIndexInterpolated(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - float arg2 ; ofVec3f result; SWIG_check_num_args("ofPolyline::getRotationAtIndexInterpolated",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::getRotationAtIndexInterpolated",1,"ofPolyline const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::getRotationAtIndexInterpolated",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_getRotationAtIndexInterpolated",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - result = ((ofPolyline const *)arg1)->getRotationAtIndexInterpolated(arg2); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_getTangentAtIndex(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; int arg2 ; - ofVec3f result; SWIG_check_num_args("ofPolyline::getTangentAtIndex",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::getTangentAtIndex",1,"ofPolyline const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::getTangentAtIndex",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_getTangentAtIndex",1,SWIGTYPE_p_ofPolyline); } arg2 = (int)lua_tonumber(L, 2); - result = ((ofPolyline const *)arg1)->getTangentAtIndex(arg2); { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_getTangentAtIndexInterpolated(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - float arg2 ; ofVec3f result; SWIG_check_num_args("ofPolyline::getTangentAtIndexInterpolated",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::getTangentAtIndexInterpolated",1,"ofPolyline const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::getTangentAtIndexInterpolated",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_getTangentAtIndexInterpolated",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - result = ((ofPolyline const *)arg1)->getTangentAtIndexInterpolated(arg2); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_getNormalAtIndex(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; int arg2 ; - ofVec3f result; SWIG_check_num_args("ofPolyline::getNormalAtIndex",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::getNormalAtIndex",1,"ofPolyline const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::getNormalAtIndex",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_getNormalAtIndex",1,SWIGTYPE_p_ofPolyline); } arg2 = (int)lua_tonumber(L, 2); - result = ((ofPolyline const *)arg1)->getNormalAtIndex(arg2); { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_getNormalAtIndexInterpolated(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - float arg2 ; ofVec3f result; SWIG_check_num_args("ofPolyline::getNormalAtIndexInterpolated",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::getNormalAtIndexInterpolated",1,"ofPolyline const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::getNormalAtIndexInterpolated",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_getNormalAtIndexInterpolated",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - result = ((ofPolyline const *)arg1)->getNormalAtIndexInterpolated(arg2); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_getWrappedIndex(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; int arg2 ; - int result; SWIG_check_num_args("ofPolyline::getWrappedIndex",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::getWrappedIndex",1,"ofPolyline const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::getWrappedIndex",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_getWrappedIndex",1,SWIGTYPE_p_ofPolyline); } arg2 = (int)lua_tonumber(L, 2); - result = (int)((ofPolyline const *)arg1)->getWrappedIndex(arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_setRightVector__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - ofVec3f arg2 ; ofVec3f *argp2 ; SWIG_check_num_args("ofPolyline::setRightVector",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::setRightVector",1,"ofPolyline *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline::setRightVector",2,"ofVec3f"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_setRightVector",1,SWIGTYPE_p_ofPolyline); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Polyline_setRightVector",2,SWIGTYPE_p_ofVec3f); } arg2 = *argp2; (arg1)->setRightVector(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_setRightVector__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - SWIG_check_num_args("ofPolyline::setRightVector",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::setRightVector",1,"ofPolyline *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_setRightVector",1,SWIGTYPE_p_ofPolyline); } (arg1)->setRightVector(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_setRightVector(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Polyline_setRightVector__SWIG_1(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Polyline_setRightVector__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Polyline_setRightVector'\n" - " Possible C/C++ prototypes are:\n" " ofPolyline::setRightVector(ofVec3f)\n" " ofPolyline::setRightVector()\n"); - lua_error(L);return 0; } -static int _wrap_Polyline_getRightVector(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; ofVec3f result; - SWIG_check_num_args("ofPolyline::getRightVector",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::getRightVector",1,"ofPolyline const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_getRightVector",1,SWIGTYPE_p_ofPolyline); } result = ((ofPolyline const *)arg1)->getRightVector(); - { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_draw(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - SWIG_check_num_args("ofPolyline::draw",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::draw",1,"ofPolyline const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_draw",1,SWIGTYPE_p_ofPolyline); } ((ofPolyline const *)arg1)->draw(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_Polyline(void *obj) { -ofPolyline *arg1 = (ofPolyline *) obj; -delete arg1; -} -static int _proxy__wrap_new_Polyline(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_Polyline); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_Polyline_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_Polyline_methods[]= { - { "clear", _wrap_Polyline_clear}, - { "addVertex", _wrap_Polyline_addVertex}, - { "addVertices", _wrap_Polyline_addVertices}, - { "insertVertex", _wrap_Polyline_insertVertex}, - { "resize", _wrap_Polyline_resize}, - { "size", _wrap_Polyline_size}, - { "getVertices", _wrap_Polyline_getVertices}, - { "lineTo", _wrap_Polyline_lineTo}, - { "arc", _wrap_Polyline_arc}, - { "arcNegative", _wrap_Polyline_arcNegative}, - { "curveTo", _wrap_Polyline_curveTo}, - { "bezierTo", _wrap_Polyline_bezierTo}, - { "quadBezierTo", _wrap_Polyline_quadBezierTo}, - { "getSmoothed", _wrap_Polyline_getSmoothed}, - { "getResampledBySpacing", _wrap_Polyline_getResampledBySpacing}, - { "getResampledByCount", _wrap_Polyline_getResampledByCount}, - { "simplify", _wrap_Polyline_simplify}, - { "close", _wrap_Polyline_close}, - { "setClosed", _wrap_Polyline_setClosed}, - { "isClosed", _wrap_Polyline_isClosed}, - { "hasChanged", _wrap_Polyline_hasChanged}, - { "flagHasChanged", _wrap_Polyline_flagHasChanged}, - { "inside", _wrap_Polyline_inside}, - { "getBoundingBox", _wrap_Polyline_getBoundingBox}, - { "getPerimeter", _wrap_Polyline_getPerimeter}, - { "getArea", _wrap_Polyline_getArea}, - { "getCentroid2D", _wrap_Polyline_getCentroid2D}, - { "getClosestPoint", _wrap_Polyline_getClosestPoint}, - { "getIndexAtLength", _wrap_Polyline_getIndexAtLength}, - { "getIndexAtPercent", _wrap_Polyline_getIndexAtPercent}, - { "getLengthAtIndex", _wrap_Polyline_getLengthAtIndex}, - { "getLengthAtIndexInterpolated", _wrap_Polyline_getLengthAtIndexInterpolated}, - { "getPointAtLength", _wrap_Polyline_getPointAtLength}, - { "getPointAtPercent", _wrap_Polyline_getPointAtPercent}, - { "getPointAtIndexInterpolated", _wrap_Polyline_getPointAtIndexInterpolated}, - { "getAngleAtIndex", _wrap_Polyline_getAngleAtIndex}, - { "getAngleAtIndexInterpolated", _wrap_Polyline_getAngleAtIndexInterpolated}, - { "getRotationAtIndex", _wrap_Polyline_getRotationAtIndex}, - { "getRotationAtIndexInterpolated", _wrap_Polyline_getRotationAtIndexInterpolated}, - { "getTangentAtIndex", _wrap_Polyline_getTangentAtIndex}, - { "getTangentAtIndexInterpolated", _wrap_Polyline_getTangentAtIndexInterpolated}, - { "getNormalAtIndex", _wrap_Polyline_getNormalAtIndex}, - { "getNormalAtIndexInterpolated", _wrap_Polyline_getNormalAtIndexInterpolated}, - { "getWrappedIndex", _wrap_Polyline_getWrappedIndex}, - { "setRightVector", _wrap_Polyline_setRightVector}, - { "getRightVector", _wrap_Polyline_getRightVector}, - { "draw", _wrap_Polyline_draw}, - {0,0} -}; -static swig_lua_method swig_Polyline_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_Polyline_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_Polyline_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_Polyline_Sf_SwigStatic_methods[]= { - { "fromRectangle", _wrap_Polyline_fromRectangle}, - {0,0} -}; -static swig_lua_class* swig_Polyline_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_Polyline_Sf_SwigStatic = { - "Polyline", - swig_Polyline_Sf_SwigStatic_methods, - swig_Polyline_Sf_SwigStatic_attributes, - swig_Polyline_Sf_SwigStatic_constants, - swig_Polyline_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_Polyline_bases[] = {0}; -static const char *swig_Polyline_base_names[] = {0}; -static swig_lua_class _wrap_class_Polyline = { "Polyline", "Polyline", &SWIGTYPE_p_ofPolyline,_proxy__wrap_new_Polyline, swig_delete_Polyline, swig_Polyline_methods, swig_Polyline_attributes, &swig_Polyline_Sf_SwigStatic, swig_Polyline_meta, swig_Polyline_bases, swig_Polyline_base_names }; - -static int _wrap_drawBitmapString__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; float arg2 ; float arg3 ; - std::string temp1 ; SWIG_check_num_args("ofDrawBitmapString",3,3) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofDrawBitmapString",1,"std::string const &"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawBitmapString",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawBitmapString",3,"float"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); ofDrawBitmapString((std::string const &)*arg1,arg2,arg3); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawBitmapString__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; ofPoint *arg2 = 0 ; - std::string temp1 ; SWIG_check_num_args("ofDrawBitmapString",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofDrawBitmapString",1,"std::string const &"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofDrawBitmapString",2,"ofPoint const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("drawBitmapString",2,SWIGTYPE_p_ofVec3f); } - ofDrawBitmapString((std::string const &)*arg1,(ofVec3f const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_drawBitmapString__SWIG_2(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; float arg2 ; float arg3 ; - float arg4 ; std::string temp1 ; SWIG_check_num_args("ofDrawBitmapString",4,4) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofDrawBitmapString",1,"std::string const &"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawBitmapString",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawBitmapString",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawBitmapString",4,"float"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - ofDrawBitmapString((std::string const &)*arg1,arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_drawBitmapString(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_drawBitmapString__SWIG_1(L);} } } if (argc == 3) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_drawBitmapString__SWIG_0(L);} } } } if (argc == 4) { int _v; { _v = lua_isstring(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_drawBitmapString__SWIG_2(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'drawBitmapString'\n" " Possible C/C++ prototypes are:\n" - " ofDrawBitmapString(std::string const &,float,float)\n" " ofDrawBitmapString(std::string const &,ofPoint const &)\n" - " ofDrawBitmapString(std::string const &,float,float,float)\n"); lua_error(L);return 0; } -static int _wrap_setColor__SWIG_0(lua_State* L) { int SWIG_arg = 0; int arg1 ; int arg2 ; int arg3 ; - SWIG_check_num_args("ofSetColor",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetColor",1,"int"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSetColor",2,"int"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofSetColor",3,"int"); - arg1 = (int)lua_tonumber(L, 1); arg2 = (int)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); ofSetColor(arg1,arg2,arg3); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setColor__SWIG_1(lua_State* L) { int SWIG_arg = 0; int arg1 ; int arg2 ; int arg3 ; int arg4 ; - SWIG_check_num_args("ofSetColor",4,4) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetColor",1,"int"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSetColor",2,"int"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofSetColor",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofSetColor",4,"int"); arg1 = (int)lua_tonumber(L, 1); arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); ofSetColor(arg1,arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setColor__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofColor *arg1 = 0 ; SWIG_check_num_args("ofSetColor",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofSetColor",1,"ofColor const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("setColor",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } ofSetColor((ofColor_< unsigned char > const &)*arg1); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setColor__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofColor *arg1 = 0 ; int arg2 ; - SWIG_check_num_args("ofSetColor",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofSetColor",1,"ofColor const &"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSetColor",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("setColor",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } arg2 = (int)lua_tonumber(L, 2); - ofSetColor((ofColor_< unsigned char > const &)*arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_setColor__SWIG_4(lua_State* L) { int SWIG_arg = 0; int arg1 ; SWIG_check_num_args("ofSetColor",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetColor",1,"int"); arg1 = (int)lua_tonumber(L, 1); ofSetColor(arg1); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setColor(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_setColor__SWIG_2(L);} } if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_setColor__SWIG_4(L);} } if (argc == 2) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_setColor__SWIG_3(L);} - } } if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_setColor__SWIG_0(L);} } } } if (argc == 4) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_setColor__SWIG_1(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'setColor'\n" " Possible C/C++ prototypes are:\n" - " ofSetColor(int,int,int)\n" " ofSetColor(int,int,int,int)\n" " ofSetColor(ofColor const &)\n" - " ofSetColor(ofColor const &,int)\n" " ofSetColor(int)\n"); lua_error(L);return 0; } -static int _wrap_setHexColor(lua_State* L) { int SWIG_arg = 0; int arg1 ; SWIG_check_num_args("ofSetHexColor",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetHexColor",1,"int"); arg1 = (int)lua_tonumber(L, 1); ofSetHexColor(arg1); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_noFill(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofNoFill",0,0) ofNoFill(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_fill(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofFill",0,0) ofFill(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getFill(lua_State* L) { int SWIG_arg = 0; ofFillFlag result; SWIG_check_num_args("ofGetFill",0,0) - result = (ofFillFlag)ofGetFill(); lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_getBackgroundColor(lua_State* L) { int SWIG_arg = 0; ofColor result; - SWIG_check_num_args("ofGetBackgroundColor",0,0) result = ofGetBackgroundColor(); { - ofColor * resultptr = new ofColor((const ofColor &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_background__SWIG_0(lua_State* L) { int SWIG_arg = 0; int arg1 ; int arg2 ; int arg3 ; int arg4 ; - SWIG_check_num_args("ofBackground",4,4) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofBackground",1,"int"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBackground",2,"int"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofBackground",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofBackground",4,"int"); arg1 = (int)lua_tonumber(L, 1); arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); ofBackground(arg1,arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_background__SWIG_1(lua_State* L) { int SWIG_arg = 0; int arg1 ; int arg2 ; int arg3 ; - SWIG_check_num_args("ofBackground",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofBackground",1,"int"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBackground",2,"int"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofBackground",3,"int"); - arg1 = (int)lua_tonumber(L, 1); arg2 = (int)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); ofBackground(arg1,arg2,arg3); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_background__SWIG_2(lua_State* L) { int SWIG_arg = 0; int arg1 ; int arg2 ; - SWIG_check_num_args("ofBackground",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofBackground",1,"int"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBackground",2,"int"); arg1 = (int)lua_tonumber(L, 1); arg2 = (int)lua_tonumber(L, 2); - ofBackground(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_background__SWIG_3(lua_State* L) { int SWIG_arg = 0; int arg1 ; SWIG_check_num_args("ofBackground",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofBackground",1,"int"); arg1 = (int)lua_tonumber(L, 1); ofBackground(arg1); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_background__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofColor *arg1 = 0 ; - SWIG_check_num_args("ofBackground",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofBackground",1,"ofColor const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("background",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - ofBackground((ofColor_< unsigned char > const &)*arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_background(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 1) { int _v; - { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_background__SWIG_4(L);} } if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_background__SWIG_3(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_background__SWIG_2(L);} } } if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_background__SWIG_1(L);} } } } if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_background__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'background'\n" " Possible C/C++ prototypes are:\n" - " ofBackground(int,int,int,int)\n" " ofBackground(int,int,int)\n" " ofBackground(int,int)\n" - " ofBackground(int)\n" " ofBackground(ofColor const &)\n"); lua_error(L);return 0; } -static int _wrap_backgroundHex__SWIG_0(lua_State* L) { int SWIG_arg = 0; int arg1 ; int arg2 ; - SWIG_check_num_args("ofBackgroundHex",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofBackgroundHex",1,"int"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBackgroundHex",2,"int"); arg1 = (int)lua_tonumber(L, 1); - arg2 = (int)lua_tonumber(L, 2); ofBackgroundHex(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_backgroundHex__SWIG_1(lua_State* L) { int SWIG_arg = 0; int arg1 ; SWIG_check_num_args("ofBackgroundHex",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofBackgroundHex",1,"int"); arg1 = (int)lua_tonumber(L, 1); ofBackgroundHex(arg1); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_backgroundHex(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_backgroundHex__SWIG_1(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_backgroundHex__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'backgroundHex'\n" " Possible C/C++ prototypes are:\n" - " ofBackgroundHex(int,int)\n" " ofBackgroundHex(int)\n"); lua_error(L);return 0; } -static int _wrap_backgroundGradient__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofColor *arg1 = 0 ; ofColor *arg2 = 0 ; - ofGradientMode arg3 ; SWIG_check_num_args("ofBackgroundGradient",3,3) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofBackgroundGradient",1,"ofColor const &"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofBackgroundGradient",2,"ofColor const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofBackgroundGradient",3,"ofGradientMode"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("backgroundGradient",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("backgroundGradient",2,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - arg3 = (ofGradientMode)(int)lua_tonumber(L, 3); - ofBackgroundGradient((ofColor_< unsigned char > const &)*arg1,(ofColor_< unsigned char > const &)*arg2,arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_backgroundGradient__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofColor *arg1 = 0 ; ofColor *arg2 = 0 ; - SWIG_check_num_args("ofBackgroundGradient",2,2) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofBackgroundGradient",1,"ofColor const &"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofBackgroundGradient",2,"ofColor const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("backgroundGradient",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("backgroundGradient",2,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - ofBackgroundGradient((ofColor_< unsigned char > const &)*arg1,(ofColor_< unsigned char > const &)*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_backgroundGradient(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_backgroundGradient__SWIG_1(L);} } } if (argc == 3) { int _v; - { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_backgroundGradient__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'backgroundGradient'\n" " Possible C/C++ prototypes are:\n" - " ofBackgroundGradient(ofColor const &,ofColor const &,ofGradientMode)\n" - " ofBackgroundGradient(ofColor const &,ofColor const &)\n"); lua_error(L);return 0; } -static int _wrap_setBackgroundColor__SWIG_0(lua_State* L) { int SWIG_arg = 0; int arg1 ; int arg2 ; int arg3 ; int arg4 ; - SWIG_check_num_args("ofSetBackgroundColor",4,4) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetBackgroundColor",1,"int"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSetBackgroundColor",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofSetBackgroundColor",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofSetBackgroundColor",4,"int"); arg1 = (int)lua_tonumber(L, 1); - arg2 = (int)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - ofSetBackgroundColor(arg1,arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setBackgroundColor__SWIG_1(lua_State* L) { int SWIG_arg = 0; int arg1 ; int arg2 ; int arg3 ; - SWIG_check_num_args("ofSetBackgroundColor",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetBackgroundColor",1,"int"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSetBackgroundColor",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofSetBackgroundColor",3,"int"); arg1 = (int)lua_tonumber(L, 1); - arg2 = (int)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); ofSetBackgroundColor(arg1,arg2,arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setBackgroundColor__SWIG_2(lua_State* L) { int SWIG_arg = 0; int arg1 ; int arg2 ; - SWIG_check_num_args("ofSetBackgroundColor",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetBackgroundColor",1,"int"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSetBackgroundColor",2,"int"); arg1 = (int)lua_tonumber(L, 1); - arg2 = (int)lua_tonumber(L, 2); ofSetBackgroundColor(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_setBackgroundColor__SWIG_3(lua_State* L) { int SWIG_arg = 0; int arg1 ; - SWIG_check_num_args("ofSetBackgroundColor",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetBackgroundColor",1,"int"); - arg1 = (int)lua_tonumber(L, 1); ofSetBackgroundColor(arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_setBackgroundColor__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofColor *arg1 = 0 ; - SWIG_check_num_args("ofSetBackgroundColor",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofSetBackgroundColor",1,"ofColor const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("setBackgroundColor",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - ofSetBackgroundColor((ofColor_< unsigned char > const &)*arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_setBackgroundColor(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_setBackgroundColor__SWIG_4(L);} } if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_setBackgroundColor__SWIG_3(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_setBackgroundColor__SWIG_2(L);} } } if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_setBackgroundColor__SWIG_1(L);} } } } if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_setBackgroundColor__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'setBackgroundColor'\n" " Possible C/C++ prototypes are:\n" - " ofSetBackgroundColor(int,int,int,int)\n" " ofSetBackgroundColor(int,int,int)\n" " ofSetBackgroundColor(int,int)\n" - " ofSetBackgroundColor(int)\n" " ofSetBackgroundColor(ofColor const &)\n"); lua_error(L);return 0; } -static int _wrap_setBackgroundColorHex__SWIG_0(lua_State* L) { int SWIG_arg = 0; int arg1 ; int arg2 ; - SWIG_check_num_args("ofSetBackgroundColorHex",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetBackgroundColorHex",1,"int"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSetBackgroundColorHex",2,"int"); arg1 = (int)lua_tonumber(L, 1); - arg2 = (int)lua_tonumber(L, 2); ofSetBackgroundColorHex(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_setBackgroundColorHex__SWIG_1(lua_State* L) { int SWIG_arg = 0; int arg1 ; - SWIG_check_num_args("ofSetBackgroundColorHex",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetBackgroundColorHex",1,"int"); - arg1 = (int)lua_tonumber(L, 1); ofSetBackgroundColorHex(arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_setBackgroundColorHex(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_setBackgroundColorHex__SWIG_1(L);} } if (argc == 2) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_setBackgroundColorHex__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'setBackgroundColorHex'\n" - " Possible C/C++ prototypes are:\n" " ofSetBackgroundColorHex(int,int)\n" " ofSetBackgroundColorHex(int)\n"); - lua_error(L);return 0; } -static int _wrap_setBackgroundAuto(lua_State* L) { int SWIG_arg = 0; bool arg1 ; SWIG_check_num_args("ofSetBackgroundAuto",1,1) - if(!lua_isboolean(L,1)) SWIG_fail_arg("ofSetBackgroundAuto",1,"bool"); arg1 = (lua_toboolean(L, 1)!=0); - ofSetBackgroundAuto(arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getBackgroundAuto(lua_State* L) { int SWIG_arg = 0; bool result; SWIG_check_num_args("ofGetBackgroundAuto",0,0) - result = (bool)ofGetBackgroundAuto(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_clear__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - SWIG_check_num_args("ofClear",4,4) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofClear",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofClear",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofClear",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofClear",4,"float"); arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); ofClear(arg1,arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_clear__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofClear",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofClear",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofClear",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofClear",3,"float"); - arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); ofClear(arg1,arg2,arg3); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_clear__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; SWIG_check_num_args("ofClear",2,2) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofClear",1,"float"); if(!lua_isnumber(L,2)) SWIG_fail_arg("ofClear",2,"float"); - arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); ofClear(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_clear__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; SWIG_check_num_args("ofClear",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofClear",1,"float"); arg1 = (float)lua_tonumber(L, 1); ofClear(arg1); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_clear__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofColor *arg1 = 0 ; SWIG_check_num_args("ofClear",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofClear",1,"ofColor const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("clear",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } ofClear((ofColor_< unsigned char > const &)*arg1); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_clear(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_clear__SWIG_4(L);} } if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_clear__SWIG_3(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_clear__SWIG_2(L);} } - } if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_clear__SWIG_1(L);} } } } if (argc == 4) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_clear__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'clear'\n" " Possible C/C++ prototypes are:\n" - " ofClear(float,float,float,float)\n" " ofClear(float,float,float)\n" " ofClear(float,float)\n" - " ofClear(float)\n" " ofClear(ofColor const &)\n"); lua_error(L);return 0; } -static int _wrap_clearAlpha(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofClearAlpha",0,0) ofClearAlpha(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawTriangle__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - float arg5 ; float arg6 ; SWIG_check_num_args("ofDrawTriangle",6,6) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawTriangle",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawTriangle",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawTriangle",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawTriangle",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofDrawTriangle",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofDrawTriangle",6,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); ofDrawTriangle(arg1,arg2,arg3,arg4,arg5,arg6); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawTriangle__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - float arg5 ; float arg6 ; float arg7 ; float arg8 ; float arg9 ; SWIG_check_num_args("ofDrawTriangle",9,9) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawTriangle",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawTriangle",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawTriangle",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawTriangle",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofDrawTriangle",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofDrawTriangle",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofDrawTriangle",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofDrawTriangle",8,"float"); - if(!lua_isnumber(L,9)) SWIG_fail_arg("ofDrawTriangle",9,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); - arg8 = (float)lua_tonumber(L, 8); arg9 = (float)lua_tonumber(L, 9); - ofDrawTriangle(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_drawTriangle__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPoint *arg1 = 0 ; ofPoint *arg2 = 0 ; - ofPoint *arg3 = 0 ; SWIG_check_num_args("ofDrawTriangle",3,3) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofDrawTriangle",1,"ofPoint const &"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofDrawTriangle",2,"ofPoint const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofDrawTriangle",3,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("drawTriangle",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("drawTriangle",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("drawTriangle",3,SWIGTYPE_p_ofVec3f); } - ofDrawTriangle((ofVec3f const &)*arg1,(ofVec3f const &)*arg2,(ofVec3f const &)*arg3); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_drawTriangle(lua_State* L) { int argc; int argv[10]={ 1,2,3,4,5,6,7,8,9,10} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_drawTriangle__SWIG_2(L);} } } } if (argc == 6) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { return _wrap_drawTriangle__SWIG_0(L);} } } } } } } - if (argc == 9) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { { - _v = lua_isnumber(L,argv[6]); } if (_v) { { _v = lua_isnumber(L,argv[7]); } if (_v) { { - _v = lua_isnumber(L,argv[8]); } if (_v) { return _wrap_drawTriangle__SWIG_1(L);} } } } } } } } } - } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'drawTriangle'\n" " Possible C/C++ prototypes are:\n" - " ofDrawTriangle(float,float,float,float,float,float)\n" - " ofDrawTriangle(float,float,float,float,float,float,float,float,float)\n" - " ofDrawTriangle(ofPoint const &,ofPoint const &,ofPoint const &)\n"); lua_error(L);return 0; } -static int _wrap_drawCircle__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofDrawCircle",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawCircle",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawCircle",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawCircle",3,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); ofDrawCircle(arg1,arg2,arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawCircle__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - SWIG_check_num_args("ofDrawCircle",4,4) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawCircle",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawCircle",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawCircle",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawCircle",4,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - ofDrawCircle(arg1,arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawCircle__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPoint *arg1 = 0 ; float arg2 ; - SWIG_check_num_args("ofDrawCircle",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofDrawCircle",1,"ofPoint const &"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawCircle",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("drawCircle",1,SWIGTYPE_p_ofVec3f); } - arg2 = (float)lua_tonumber(L, 2); ofDrawCircle((ofVec3f const &)*arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_drawCircle(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { int _v; - { void *ptr; if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_drawCircle__SWIG_2(L);} } } if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_drawCircle__SWIG_0(L);} } } } if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_drawCircle__SWIG_1(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'drawCircle'\n" " Possible C/C++ prototypes are:\n" - " ofDrawCircle(float,float,float)\n" " ofDrawCircle(float,float,float,float)\n" - " ofDrawCircle(ofPoint const &,float)\n"); lua_error(L);return 0; } -static int _wrap_drawEllipse__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - SWIG_check_num_args("ofDrawEllipse",4,4) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawEllipse",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawEllipse",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawEllipse",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawEllipse",4,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - ofDrawEllipse(arg1,arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawEllipse__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - float arg5 ; SWIG_check_num_args("ofDrawEllipse",5,5) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawEllipse",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawEllipse",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawEllipse",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawEllipse",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofDrawEllipse",5,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); ofDrawEllipse(arg1,arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_drawEllipse__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPoint *arg1 = 0 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofDrawEllipse",3,3) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofDrawEllipse",1,"ofPoint const &"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawEllipse",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawEllipse",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("drawEllipse",1,SWIGTYPE_p_ofVec3f); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); ofDrawEllipse((ofVec3f const &)*arg1,arg2,arg3); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawEllipse(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_drawEllipse__SWIG_2(L);} } } } if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { - { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_drawEllipse__SWIG_0(L);} } } } } if (argc == 5) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_drawEllipse__SWIG_1(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'drawEllipse'\n" " Possible C/C++ prototypes are:\n" - " ofDrawEllipse(float,float,float,float)\n" " ofDrawEllipse(float,float,float,float,float)\n" - " ofDrawEllipse(ofPoint const &,float,float)\n"); lua_error(L);return 0; } -static int _wrap_drawLine__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - SWIG_check_num_args("ofDrawLine",4,4) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawLine",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawLine",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawLine",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawLine",4,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - ofDrawLine(arg1,arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawLine__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - float arg5 ; float arg6 ; SWIG_check_num_args("ofDrawLine",6,6) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawLine",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawLine",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawLine",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawLine",4,"float"); if(!lua_isnumber(L,5)) SWIG_fail_arg("ofDrawLine",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofDrawLine",6,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); ofDrawLine(arg1,arg2,arg3,arg4,arg5,arg6); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawLine__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPoint *arg1 = 0 ; ofPoint *arg2 = 0 ; - SWIG_check_num_args("ofDrawLine",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofDrawLine",1,"ofPoint const &"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofDrawLine",2,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("drawLine",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("drawLine",2,SWIGTYPE_p_ofVec3f); } - ofDrawLine((ofVec3f const &)*arg1,(ofVec3f const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_drawLine(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_drawLine__SWIG_2(L);} } } if (argc == 4) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_drawLine__SWIG_0(L);} } } } } if (argc == 6) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { - return _wrap_drawLine__SWIG_1(L);} } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'drawLine'\n" " Possible C/C++ prototypes are:\n" - " ofDrawLine(float,float,float,float)\n" " ofDrawLine(float,float,float,float,float,float)\n" - " ofDrawLine(ofPoint const &,ofPoint const &)\n"); lua_error(L);return 0; } -static int _wrap_drawRectangle__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - SWIG_check_num_args("ofDrawRectangle",4,4) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawRectangle",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawRectangle",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawRectangle",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawRectangle",4,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - ofDrawRectangle(arg1,arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawRectangle__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = 0 ; - SWIG_check_num_args("ofDrawRectangle",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofDrawRectangle",1,"ofRectangle const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("drawRectangle",1,SWIGTYPE_p_ofRectangle); } ofDrawRectangle((ofRectangle const &)*arg1); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawRectangle__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPoint *arg1 = 0 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofDrawRectangle",3,3) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofDrawRectangle",1,"ofPoint const &"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawRectangle",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawRectangle",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("drawRectangle",1,SWIGTYPE_p_ofVec3f); } arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - ofDrawRectangle((ofVec3f const &)*arg1,arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawRectangle__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - float arg5 ; SWIG_check_num_args("ofDrawRectangle",5,5) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawRectangle",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawRectangle",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawRectangle",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawRectangle",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofDrawRectangle",5,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); ofDrawRectangle(arg1,arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_drawRectangle(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_drawRectangle__SWIG_1(L);} } if (argc == 3) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_drawRectangle__SWIG_2(L);} } } } if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_drawRectangle__SWIG_0(L);} } } } } if (argc == 5) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_drawRectangle__SWIG_3(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'drawRectangle'\n" " Possible C/C++ prototypes are:\n" - " ofDrawRectangle(float,float,float,float)\n" " ofDrawRectangle(ofRectangle const &)\n" - " ofDrawRectangle(ofPoint const &,float,float)\n" " ofDrawRectangle(float,float,float,float,float)\n"); - lua_error(L);return 0; } -static int _wrap_drawRectRounded__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = 0 ; float arg2 ; - SWIG_check_num_args("ofDrawRectRounded",2,2) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofDrawRectRounded",1,"ofRectangle const &"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawRectRounded",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("drawRectRounded",1,SWIGTYPE_p_ofRectangle); } arg2 = (float)lua_tonumber(L, 2); - ofDrawRectRounded((ofRectangle const &)*arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawRectRounded__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPoint *arg1 = 0 ; float arg2 ; float arg3 ; - float arg4 ; SWIG_check_num_args("ofDrawRectRounded",4,4) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofDrawRectRounded",1,"ofPoint const &"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawRectRounded",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawRectRounded",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawRectRounded",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("drawRectRounded",1,SWIGTYPE_p_ofVec3f); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); ofDrawRectRounded((ofVec3f const &)*arg1,arg2,arg3,arg4); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawRectRounded__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - float arg5 ; SWIG_check_num_args("ofDrawRectRounded",5,5) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawRectRounded",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawRectRounded",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawRectRounded",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawRectRounded",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofDrawRectRounded",5,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); ofDrawRectRounded(arg1,arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_drawRectRounded__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - float arg5 ; float arg6 ; SWIG_check_num_args("ofDrawRectRounded",6,6) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawRectRounded",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawRectRounded",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawRectRounded",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawRectRounded",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofDrawRectRounded",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofDrawRectRounded",6,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); ofDrawRectRounded(arg1,arg2,arg3,arg4,arg5,arg6); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawRectRounded__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofPoint *arg1 = 0 ; float arg2 ; float arg3 ; - float arg4 ; float arg5 ; float arg6 ; float arg7 ; SWIG_check_num_args("ofDrawRectRounded",7,7) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofDrawRectRounded",1,"ofPoint const &"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawRectRounded",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawRectRounded",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawRectRounded",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofDrawRectRounded",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofDrawRectRounded",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofDrawRectRounded",7,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("drawRectRounded",1,SWIGTYPE_p_ofVec3f); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); - ofDrawRectRounded((ofVec3f const &)*arg1,arg2,arg3,arg4,arg5,arg6,arg7); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_drawRectRounded__SWIG_5(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = 0 ; float arg2 ; float arg3 ; - float arg4 ; float arg5 ; SWIG_check_num_args("ofDrawRectRounded",5,5) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofDrawRectRounded",1,"ofRectangle const &"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawRectRounded",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawRectRounded",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawRectRounded",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofDrawRectRounded",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("drawRectRounded",1,SWIGTYPE_p_ofRectangle); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - ofDrawRectRounded((ofRectangle const &)*arg1,arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_drawRectRounded__SWIG_6(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - float arg5 ; float arg6 ; float arg7 ; float arg8 ; float arg9 ; SWIG_check_num_args("ofDrawRectRounded",9,9) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawRectRounded",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawRectRounded",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawRectRounded",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawRectRounded",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofDrawRectRounded",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofDrawRectRounded",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofDrawRectRounded",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofDrawRectRounded",8,"float"); - if(!lua_isnumber(L,9)) SWIG_fail_arg("ofDrawRectRounded",9,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); - arg8 = (float)lua_tonumber(L, 8); arg9 = (float)lua_tonumber(L, 9); - ofDrawRectRounded(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_drawRectRounded(lua_State* L) { int argc; int argv[10]={ 1,2,3,4,5,6,7,8,9,10} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_drawRectRounded__SWIG_0(L);} } - } if (argc == 4) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_drawRectRounded__SWIG_1(L);} } } } } if (argc == 5) { - int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_drawRectRounded__SWIG_5(L);} } } } } } if (argc == 5) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_drawRectRounded__SWIG_2(L);} } } } } } if (argc == 6) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { return _wrap_drawRectRounded__SWIG_3(L);} } } } } } } - if (argc == 7) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { - return _wrap_drawRectRounded__SWIG_4(L);} } } } } } } } if (argc == 9) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { { _v = lua_isnumber(L,argv[8]); } if (_v) { - return _wrap_drawRectRounded__SWIG_6(L);} } } } } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'drawRectRounded'\n" " Possible C/C++ prototypes are:\n" - " ofDrawRectRounded(ofRectangle const &,float)\n" " ofDrawRectRounded(ofPoint const &,float,float,float)\n" - " ofDrawRectRounded(float,float,float,float,float)\n" " ofDrawRectRounded(float,float,float,float,float,float)\n" - " ofDrawRectRounded(ofPoint const &,float,float,float,float,float,float)\n" - " ofDrawRectRounded(ofRectangle const &,float,float,float,float)\n" - " ofDrawRectRounded(float,float,float,float,float,float,float,float,float)\n"); lua_error(L);return 0; } -static int _wrap_drawCurve__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - float arg5 ; float arg6 ; float arg7 ; float arg8 ; SWIG_check_num_args("ofDrawCurve",8,8) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawCurve",1,"float"); if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawCurve",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawCurve",3,"float"); if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawCurve",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofDrawCurve",5,"float"); if(!lua_isnumber(L,6)) SWIG_fail_arg("ofDrawCurve",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofDrawCurve",7,"float"); if(!lua_isnumber(L,8)) SWIG_fail_arg("ofDrawCurve",8,"float"); - arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); - arg7 = (float)lua_tonumber(L, 7); arg8 = (float)lua_tonumber(L, 8); ofDrawCurve(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawCurve__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - float arg5 ; float arg6 ; float arg7 ; float arg8 ; float arg9 ; float arg10 ; float arg11 ; float arg12 ; - SWIG_check_num_args("ofDrawCurve",12,12) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawCurve",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawCurve",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawCurve",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawCurve",4,"float"); if(!lua_isnumber(L,5)) SWIG_fail_arg("ofDrawCurve",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofDrawCurve",6,"float"); if(!lua_isnumber(L,7)) SWIG_fail_arg("ofDrawCurve",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofDrawCurve",8,"float"); if(!lua_isnumber(L,9)) SWIG_fail_arg("ofDrawCurve",9,"float"); - if(!lua_isnumber(L,10)) SWIG_fail_arg("ofDrawCurve",10,"float"); - if(!lua_isnumber(L,11)) SWIG_fail_arg("ofDrawCurve",11,"float"); - if(!lua_isnumber(L,12)) SWIG_fail_arg("ofDrawCurve",12,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); - arg8 = (float)lua_tonumber(L, 8); arg9 = (float)lua_tonumber(L, 9); arg10 = (float)lua_tonumber(L, 10); - arg11 = (float)lua_tonumber(L, 11); arg12 = (float)lua_tonumber(L, 12); - ofDrawCurve(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_drawCurve(lua_State* L) { int argc; int argv[13]={ 1,2,3,4,5,6,7,8,9,10,11,12,13} ; argc = lua_gettop(L); - if (argc == 8) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { { - _v = lua_isnumber(L,argv[6]); } if (_v) { { _v = lua_isnumber(L,argv[7]); } if (_v) { - return _wrap_drawCurve__SWIG_0(L);} } } } } } } } } if (argc == 12) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { { _v = lua_isnumber(L,argv[8]); } if (_v) { { - _v = lua_isnumber(L,argv[9]); } if (_v) { { _v = lua_isnumber(L,argv[10]); } if (_v) { { - _v = lua_isnumber(L,argv[11]); } if (_v) { return _wrap_drawCurve__SWIG_1(L);} } } } } } } } - } } } } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'drawCurve'\n" - " Possible C/C++ prototypes are:\n" " ofDrawCurve(float,float,float,float,float,float,float,float)\n" - " ofDrawCurve(float,float,float,float,float,float,float,float,float,float,float,float)\n"); lua_error(L);return 0; } -static int _wrap_drawBezier__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - float arg5 ; float arg6 ; float arg7 ; float arg8 ; SWIG_check_num_args("ofDrawBezier",8,8) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawBezier",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawBezier",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawBezier",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawBezier",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofDrawBezier",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofDrawBezier",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofDrawBezier",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofDrawBezier",8,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); - arg8 = (float)lua_tonumber(L, 8); ofDrawBezier(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawBezier__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - float arg5 ; float arg6 ; float arg7 ; float arg8 ; float arg9 ; float arg10 ; float arg11 ; float arg12 ; - SWIG_check_num_args("ofDrawBezier",12,12) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawBezier",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawBezier",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawBezier",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawBezier",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofDrawBezier",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofDrawBezier",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofDrawBezier",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofDrawBezier",8,"float"); - if(!lua_isnumber(L,9)) SWIG_fail_arg("ofDrawBezier",9,"float"); - if(!lua_isnumber(L,10)) SWIG_fail_arg("ofDrawBezier",10,"float"); - if(!lua_isnumber(L,11)) SWIG_fail_arg("ofDrawBezier",11,"float"); - if(!lua_isnumber(L,12)) SWIG_fail_arg("ofDrawBezier",12,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); - arg8 = (float)lua_tonumber(L, 8); arg9 = (float)lua_tonumber(L, 9); arg10 = (float)lua_tonumber(L, 10); - arg11 = (float)lua_tonumber(L, 11); arg12 = (float)lua_tonumber(L, 12); - ofDrawBezier(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_drawBezier(lua_State* L) { int argc; int argv[13]={ 1,2,3,4,5,6,7,8,9,10,11,12,13} ; argc = lua_gettop(L); - if (argc == 8) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { { - _v = lua_isnumber(L,argv[6]); } if (_v) { { _v = lua_isnumber(L,argv[7]); } if (_v) { - return _wrap_drawBezier__SWIG_0(L);} } } } } } } } } if (argc == 12) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { { _v = lua_isnumber(L,argv[8]); } if (_v) { { - _v = lua_isnumber(L,argv[9]); } if (_v) { { _v = lua_isnumber(L,argv[10]); } if (_v) { { - _v = lua_isnumber(L,argv[11]); } if (_v) { return _wrap_drawBezier__SWIG_1(L);} } } } } } } } - } } } } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'drawBezier'\n" - " Possible C/C++ prototypes are:\n" " ofDrawBezier(float,float,float,float,float,float,float,float)\n" - " ofDrawBezier(float,float,float,float,float,float,float,float,float,float,float,float)\n"); lua_error(L);return 0; } -static int _wrap_beginShape(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofBeginShape",0,0) ofBeginShape(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_vertex__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; SWIG_check_num_args("ofVertex",2,2) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofVertex",1,"float"); if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVertex",2,"float"); - arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); ofVertex(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_vertex__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofVertex",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofVertex",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVertex",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVertex",3,"float"); - arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - ofVertex(arg1,arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_vertex__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPoint *arg1 = 0 ; SWIG_check_num_args("ofVertex",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofVertex",1,"ofPoint &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("vertex",1,SWIGTYPE_p_ofVec3f); } - ofVertex(*arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_vertex(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_vertex__SWIG_2(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_vertex__SWIG_0(L);} } - } if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_vertex__SWIG_1(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'vertex'\n" " Possible C/C++ prototypes are:\n" - " ofVertex(float,float)\n" " ofVertex(float,float,float)\n" " ofVertex(ofPoint &)\n"); lua_error(L);return 0; } -static int _wrap_vertices(lua_State* L) { int SWIG_arg = 0; std::vector< ofPoint > *arg1 = 0 ; - SWIG_check_num_args("ofVertices",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofVertices",1,"std::vector< ofPoint > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofVec3f_t,0))){ - SWIG_fail_ptr("vertices",1,SWIGTYPE_p_std__vectorT_ofVec3f_t); } ofVertices((std::vector< ofVec3f > const &)*arg1); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_curveVertex__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; - SWIG_check_num_args("ofCurveVertex",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofCurveVertex",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofCurveVertex",2,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); ofCurveVertex(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_curveVertex__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofCurveVertex",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofCurveVertex",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofCurveVertex",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofCurveVertex",3,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); ofCurveVertex(arg1,arg2,arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_curveVertex__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPoint *arg1 = 0 ; - SWIG_check_num_args("ofCurveVertex",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofCurveVertex",1,"ofPoint &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("curveVertex",1,SWIGTYPE_p_ofVec3f); } - ofCurveVertex(*arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_curveVertex(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_curveVertex__SWIG_2(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_curveVertex__SWIG_0(L);} } } if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_curveVertex__SWIG_1(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'curveVertex'\n" " Possible C/C++ prototypes are:\n" - " ofCurveVertex(float,float)\n" " ofCurveVertex(float,float,float)\n" " ofCurveVertex(ofPoint &)\n"); - lua_error(L);return 0; } -static int _wrap_curveVertices(lua_State* L) { int SWIG_arg = 0; std::vector< ofPoint > *arg1 = 0 ; - SWIG_check_num_args("ofCurveVertices",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofCurveVertices",1,"std::vector< ofPoint > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofVec3f_t,0))){ - SWIG_fail_ptr("curveVertices",1,SWIGTYPE_p_std__vectorT_ofVec3f_t); } - ofCurveVertices((std::vector< ofVec3f > const &)*arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_bezierVertex__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - float arg5 ; float arg6 ; SWIG_check_num_args("ofBezierVertex",6,6) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofBezierVertex",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBezierVertex",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofBezierVertex",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofBezierVertex",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofBezierVertex",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofBezierVertex",6,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); ofBezierVertex(arg1,arg2,arg3,arg4,arg5,arg6); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_bezierVertex__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPoint *arg1 = 0 ; ofPoint *arg2 = 0 ; - ofPoint *arg3 = 0 ; SWIG_check_num_args("ofBezierVertex",3,3) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofBezierVertex",1,"ofPoint const &"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofBezierVertex",2,"ofPoint const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofBezierVertex",3,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("bezierVertex",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("bezierVertex",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("bezierVertex",3,SWIGTYPE_p_ofVec3f); } - ofBezierVertex((ofVec3f const &)*arg1,(ofVec3f const &)*arg2,(ofVec3f const &)*arg3); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_bezierVertex__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - float arg5 ; float arg6 ; float arg7 ; float arg8 ; float arg9 ; SWIG_check_num_args("ofBezierVertex",9,9) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofBezierVertex",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBezierVertex",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofBezierVertex",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofBezierVertex",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofBezierVertex",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofBezierVertex",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofBezierVertex",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofBezierVertex",8,"float"); - if(!lua_isnumber(L,9)) SWIG_fail_arg("ofBezierVertex",9,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); - arg8 = (float)lua_tonumber(L, 8); arg9 = (float)lua_tonumber(L, 9); - ofBezierVertex(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_bezierVertex(lua_State* L) { int argc; int argv[10]={ 1,2,3,4,5,6,7,8,9,10} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_bezierVertex__SWIG_1(L);} } } } if (argc == 6) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { return _wrap_bezierVertex__SWIG_0(L);} } } } } } } - if (argc == 9) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { { - _v = lua_isnumber(L,argv[6]); } if (_v) { { _v = lua_isnumber(L,argv[7]); } if (_v) { { - _v = lua_isnumber(L,argv[8]); } if (_v) { return _wrap_bezierVertex__SWIG_2(L);} } } } } } } } } - } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'bezierVertex'\n" " Possible C/C++ prototypes are:\n" - " ofBezierVertex(float,float,float,float,float,float)\n" - " ofBezierVertex(ofPoint const &,ofPoint const &,ofPoint const &)\n" - " ofBezierVertex(float,float,float,float,float,float,float,float,float)\n"); lua_error(L);return 0; } -static int _wrap_endShape__SWIG_0(lua_State* L) { int SWIG_arg = 0; bool arg1 ; SWIG_check_num_args("ofEndShape",1,1) - if(!lua_isboolean(L,1)) SWIG_fail_arg("ofEndShape",1,"bool"); arg1 = (lua_toboolean(L, 1)!=0); ofEndShape(arg1); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_endShape__SWIG_1(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofEndShape",0,0) ofEndShape(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_endShape(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_endShape__SWIG_1(L);} if (argc == 1) { int _v; { _v = lua_isboolean(L,argv[0]); } if (_v) { - return _wrap_endShape__SWIG_0(L);} } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'endShape'\n" - " Possible C/C++ prototypes are:\n" " ofEndShape(bool)\n" " ofEndShape()\n"); lua_error(L);return 0; } -static int _wrap_nextContour__SWIG_0(lua_State* L) { int SWIG_arg = 0; bool arg1 ; SWIG_check_num_args("ofNextContour",1,1) - if(!lua_isboolean(L,1)) SWIG_fail_arg("ofNextContour",1,"bool"); arg1 = (lua_toboolean(L, 1)!=0); ofNextContour(arg1); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_nextContour__SWIG_1(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofNextContour",0,0) ofNextContour(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_nextContour(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_nextContour__SWIG_1(L);} if (argc == 1) { int _v; { _v = lua_isboolean(L,argv[0]); } if (_v) { - return _wrap_nextContour__SWIG_0(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'nextContour'\n" " Possible C/C++ prototypes are:\n" - " ofNextContour(bool)\n" " ofNextContour()\n"); lua_error(L);return 0; } -static int _wrap_setDrawBitmapMode(lua_State* L) { int SWIG_arg = 0; ofDrawBitmapMode arg1 ; - SWIG_check_num_args("ofSetDrawBitmapMode",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetDrawBitmapMode",1,"ofDrawBitmapMode"); - arg1 = (ofDrawBitmapMode)(int)lua_tonumber(L, 1); ofSetDrawBitmapMode(arg1); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_drawBitmapStringHighlight__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string arg1 ; ofPoint *arg2 = 0 ; - ofColor *arg3 = 0 ; ofColor *arg4 = 0 ; SWIG_check_num_args("ofDrawBitmapStringHighlight",4,4) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofDrawBitmapStringHighlight",1,"std::string"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofDrawBitmapStringHighlight",2,"ofPoint const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofDrawBitmapStringHighlight",3,"ofColor const &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofDrawBitmapStringHighlight",4,"ofColor const &"); - (&arg1)->assign(lua_tostring(L,1),lua_rawlen(L,1)); if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("drawBitmapStringHighlight",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("drawBitmapStringHighlight",3,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("drawBitmapStringHighlight",4,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - ofDrawBitmapStringHighlight(arg1,(ofVec3f const &)*arg2,(ofColor_< unsigned char > const &)*arg3,(ofColor_< unsigned char > const &)*arg4); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawBitmapStringHighlight__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string arg1 ; ofPoint *arg2 = 0 ; - ofColor *arg3 = 0 ; SWIG_check_num_args("ofDrawBitmapStringHighlight",3,3) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofDrawBitmapStringHighlight",1,"std::string"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofDrawBitmapStringHighlight",2,"ofPoint const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofDrawBitmapStringHighlight",3,"ofColor const &"); - (&arg1)->assign(lua_tostring(L,1),lua_rawlen(L,1)); if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("drawBitmapStringHighlight",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("drawBitmapStringHighlight",3,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - ofDrawBitmapStringHighlight(arg1,(ofVec3f const &)*arg2,(ofColor_< unsigned char > const &)*arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawBitmapStringHighlight__SWIG_2(lua_State* L) { int SWIG_arg = 0; std::string arg1 ; ofPoint *arg2 = 0 ; - SWIG_check_num_args("ofDrawBitmapStringHighlight",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofDrawBitmapStringHighlight",1,"std::string"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofDrawBitmapStringHighlight",2,"ofPoint const &"); - (&arg1)->assign(lua_tostring(L,1),lua_rawlen(L,1)); if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("drawBitmapStringHighlight",2,SWIGTYPE_p_ofVec3f); } - ofDrawBitmapStringHighlight(arg1,(ofVec3f const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_drawBitmapStringHighlight__SWIG_3(lua_State* L) { int SWIG_arg = 0; std::string arg1 ; int arg2 ; int arg3 ; - ofColor *arg4 = 0 ; ofColor *arg5 = 0 ; SWIG_check_num_args("ofDrawBitmapStringHighlight",5,5) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofDrawBitmapStringHighlight",1,"std::string"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawBitmapStringHighlight",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawBitmapStringHighlight",3,"int"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofDrawBitmapStringHighlight",4,"ofColor const &"); - if(!lua_isuserdata(L,5)) SWIG_fail_arg("ofDrawBitmapStringHighlight",5,"ofColor const &"); - (&arg1)->assign(lua_tostring(L,1),lua_rawlen(L,1)); arg2 = (int)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("drawBitmapStringHighlight",4,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("drawBitmapStringHighlight",5,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - ofDrawBitmapStringHighlight(arg1,arg2,arg3,(ofColor_< unsigned char > const &)*arg4,(ofColor_< unsigned char > const &)*arg5); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawBitmapStringHighlight__SWIG_4(lua_State* L) { int SWIG_arg = 0; std::string arg1 ; int arg2 ; int arg3 ; - ofColor *arg4 = 0 ; SWIG_check_num_args("ofDrawBitmapStringHighlight",4,4) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofDrawBitmapStringHighlight",1,"std::string"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawBitmapStringHighlight",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawBitmapStringHighlight",3,"int"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofDrawBitmapStringHighlight",4,"ofColor const &"); - (&arg1)->assign(lua_tostring(L,1),lua_rawlen(L,1)); arg2 = (int)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("drawBitmapStringHighlight",4,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - ofDrawBitmapStringHighlight(arg1,arg2,arg3,(ofColor_< unsigned char > const &)*arg4); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_drawBitmapStringHighlight__SWIG_5(lua_State* L) { int SWIG_arg = 0; std::string arg1 ; int arg2 ; int arg3 ; - SWIG_check_num_args("ofDrawBitmapStringHighlight",3,3) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofDrawBitmapStringHighlight",1,"std::string"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawBitmapStringHighlight",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawBitmapStringHighlight",3,"int"); - (&arg1)->assign(lua_tostring(L,1),lua_rawlen(L,1)); arg2 = (int)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); - ofDrawBitmapStringHighlight(arg1,arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawBitmapStringHighlight(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_drawBitmapStringHighlight__SWIG_2(L);} } } if (argc == 3) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_drawBitmapStringHighlight__SWIG_1(L);} } } } - if (argc == 3) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_drawBitmapStringHighlight__SWIG_5(L);} } } } - if (argc == 4) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_drawBitmapStringHighlight__SWIG_0(L);} } } } } - if (argc == 4) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_drawBitmapStringHighlight__SWIG_4(L);} } } } } - if (argc == 5) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[4])==0 || SWIG_ConvertPtr(L,argv[4], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_drawBitmapStringHighlight__SWIG_3(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'drawBitmapStringHighlight'\n" - " Possible C/C++ prototypes are:\n" - " ofDrawBitmapStringHighlight(std::string,ofPoint const &,ofColor const &,ofColor const &)\n" - " ofDrawBitmapStringHighlight(std::string,ofPoint const &,ofColor const &)\n" - " ofDrawBitmapStringHighlight(std::string,ofPoint const &)\n" - " ofDrawBitmapStringHighlight(std::string,int,int,ofColor const &,ofColor const &)\n" - " ofDrawBitmapStringHighlight(std::string,int,int,ofColor const &)\n" - " ofDrawBitmapStringHighlight(std::string,int,int)\n"); lua_error(L);return 0; } -static int _wrap_setupGraphicDefaults(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofSetupGraphicDefaults",0,0) - ofSetupGraphicDefaults(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setupScreen(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofSetupScreen",0,0) ofSetupScreen(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getRectMode(lua_State* L) { int SWIG_arg = 0; ofRectMode result; SWIG_check_num_args("ofGetRectMode",0,0) - result = (ofRectMode)ofGetRectMode(); lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setCircleResolution(lua_State* L) { int SWIG_arg = 0; int arg1 ; - SWIG_check_num_args("ofSetCircleResolution",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetCircleResolution",1,"int"); - arg1 = (int)lua_tonumber(L, 1); ofSetCircleResolution(arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_setCurveResolution(lua_State* L) { int SWIG_arg = 0; int arg1 ; SWIG_check_num_args("ofSetCurveResolution",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetCurveResolution",1,"int"); arg1 = (int)lua_tonumber(L, 1); - ofSetCurveResolution(arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setLineWidth(lua_State* L) { int SWIG_arg = 0; float arg1 ; SWIG_check_num_args("ofSetLineWidth",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetLineWidth",1,"float"); arg1 = (float)lua_tonumber(L, 1); ofSetLineWidth(arg1); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setDepthTest(lua_State* L) { int SWIG_arg = 0; bool arg1 ; SWIG_check_num_args("ofSetDepthTest",1,1) - if(!lua_isboolean(L,1)) SWIG_fail_arg("ofSetDepthTest",1,"bool"); arg1 = (lua_toboolean(L, 1)!=0); ofSetDepthTest(arg1); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_enableDepthTest(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofEnableDepthTest",0,0) - ofEnableDepthTest(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_disableDepthTest(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofDisableDepthTest",0,0) - ofDisableDepthTest(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_enableBlendMode(lua_State* L) { int SWIG_arg = 0; ofBlendMode arg1 ; - SWIG_check_num_args("ofEnableBlendMode",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofEnableBlendMode",1,"ofBlendMode"); - arg1 = (ofBlendMode)(int)lua_tonumber(L, 1); ofEnableBlendMode(arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_disableBlendMode(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofDisableBlendMode",0,0) - ofDisableBlendMode(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_enablePointSprites(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofEnablePointSprites",0,0) - ofEnablePointSprites(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_disablePointSprites(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofDisablePointSprites",0,0) - ofDisablePointSprites(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_enableAlphaBlending(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofEnableAlphaBlending",0,0) - ofEnableAlphaBlending(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_disableAlphaBlending(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofDisableAlphaBlending",0,0) - ofDisableAlphaBlending(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_enableSmoothing(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofEnableSmoothing",0,0) - ofEnableSmoothing(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_disableSmoothing(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofDisableSmoothing",0,0) - ofDisableSmoothing(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_enableAntiAliasing(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofEnableAntiAliasing",0,0) - ofEnableAntiAliasing(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_disableAntiAliasing(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofDisableAntiAliasing",0,0) - ofDisableAntiAliasing(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getStyle(lua_State* L) { int SWIG_arg = 0; ofStyle result; SWIG_check_num_args("ofGetStyle",0,0) - result = ofGetStyle(); { ofStyle * resultptr = new ofStyle((const ofStyle &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofStyle,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_setStyle(lua_State* L) { int SWIG_arg = 0; ofStyle arg1 ; ofStyle *argp1 ; - SWIG_check_num_args("ofSetStyle",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofSetStyle",1,"ofStyle"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&argp1,SWIGTYPE_p_ofStyle,0))){ SWIG_fail_ptr("setStyle",1,SWIGTYPE_p_ofStyle); } - arg1 = *argp1; ofSetStyle(arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_pushStyle(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofPushStyle",0,0) ofPushStyle(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_popStyle(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofPopStyle",0,0) ofPopStyle(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setPolyMode(lua_State* L) { int SWIG_arg = 0; ofPolyWindingMode arg1 ; SWIG_check_num_args("ofSetPolyMode",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetPolyMode",1,"ofPolyWindingMode"); - arg1 = (ofPolyWindingMode)(int)lua_tonumber(L, 1); ofSetPolyMode(arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_setRectMode(lua_State* L) { int SWIG_arg = 0; ofRectMode arg1 ; SWIG_check_num_args("ofSetRectMode",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetRectMode",1,"ofRectMode"); arg1 = (ofRectMode)(int)lua_tonumber(L, 1); - ofSetRectMode(arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_pushMatrix(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofPushMatrix",0,0) ofPushMatrix(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_popMatrix(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofPopMatrix",0,0) ofPopMatrix(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getCurrentMatrix(lua_State* L) { int SWIG_arg = 0; ofMatrixMode arg1 ; ofMatrix4x4 result; - SWIG_check_num_args("ofGetCurrentMatrix",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofGetCurrentMatrix",1,"ofMatrixMode"); - arg1 = (ofMatrixMode)(int)lua_tonumber(L, 1); result = ofGetCurrentMatrix(arg1); { - ofMatrix4x4 * resultptr = new ofMatrix4x4((const ofMatrix4x4 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_getCurrentOrientationMatrix(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 result; - SWIG_check_num_args("ofGetCurrentOrientationMatrix",0,0) result = ofGetCurrentOrientationMatrix(); { - ofMatrix4x4 * resultptr = new ofMatrix4x4((const ofMatrix4x4 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_getCurrentNormalMatrix(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 result; - SWIG_check_num_args("ofGetCurrentNormalMatrix",0,0) result = ofGetCurrentNormalMatrix(); { - ofMatrix4x4 * resultptr = new ofMatrix4x4((const ofMatrix4x4 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_translate__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofTranslate",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofTranslate",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTranslate",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTranslate",3,"float"); - arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - ofTranslate(arg1,arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_translate__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; - SWIG_check_num_args("ofTranslate",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofTranslate",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTranslate",2,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); ofTranslate(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_translate__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPoint *arg1 = 0 ; SWIG_check_num_args("ofTranslate",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofTranslate",1,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("translate",1,SWIGTYPE_p_ofVec3f); } - ofTranslate((ofVec3f const &)*arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_translate(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_translate__SWIG_2(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_translate__SWIG_1(L);} - } } if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_translate__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'translate'\n" " Possible C/C++ prototypes are:\n" - " ofTranslate(float,float,float)\n" " ofTranslate(float,float)\n" " ofTranslate(ofPoint const &)\n"); - lua_error(L);return 0; } -static int _wrap_scale__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofScale",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofScale",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofScale",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofScale",3,"float"); - arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); ofScale(arg1,arg2,arg3); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_scale__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; SWIG_check_num_args("ofScale",2,2) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofScale",1,"float"); if(!lua_isnumber(L,2)) SWIG_fail_arg("ofScale",2,"float"); - arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); ofScale(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_scale__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPoint *arg1 = 0 ; SWIG_check_num_args("ofScale",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofScale",1,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("scale",1,SWIGTYPE_p_ofVec3f); } - ofScale((ofVec3f const &)*arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_scale(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_scale__SWIG_2(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_scale__SWIG_1(L);} } - } if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_scale__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'scale'\n" " Possible C/C++ prototypes are:\n" - " ofScale(float,float,float)\n" " ofScale(float,float)\n" " ofScale(ofPoint const &)\n"); lua_error(L);return 0; } -static int _wrap_rotate__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - SWIG_check_num_args("ofRotate",4,4) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofRotate",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRotate",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofRotate",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofRotate",4,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - ofRotate(arg1,arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_rotate__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; SWIG_check_num_args("ofRotate",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofRotate",1,"float"); arg1 = (float)lua_tonumber(L, 1); ofRotate(arg1); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_rotate(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_rotate__SWIG_1(L);} } if (argc == 4) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_rotate__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'rotate'\n" " Possible C/C++ prototypes are:\n" - " ofRotate(float,float,float,float)\n" " ofRotate(float)\n"); lua_error(L);return 0; } -static int _wrap_rotateX(lua_State* L) { int SWIG_arg = 0; float arg1 ; SWIG_check_num_args("ofRotateX",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofRotateX",1,"float"); arg1 = (float)lua_tonumber(L, 1); ofRotateX(arg1); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_rotateY(lua_State* L) { int SWIG_arg = 0; float arg1 ; SWIG_check_num_args("ofRotateY",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofRotateY",1,"float"); arg1 = (float)lua_tonumber(L, 1); ofRotateY(arg1); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_rotateZ(lua_State* L) { int SWIG_arg = 0; float arg1 ; SWIG_check_num_args("ofRotateZ",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofRotateZ",1,"float"); arg1 = (float)lua_tonumber(L, 1); ofRotateZ(arg1); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_loadIdentityMatrix(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofLoadIdentityMatrix",0,0) - ofLoadIdentityMatrix(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_loadMatrix__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = 0 ; - SWIG_check_num_args("ofLoadMatrix",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofLoadMatrix",1,"ofMatrix4x4 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("loadMatrix",1,SWIGTYPE_p_ofMatrix4x4); } ofLoadMatrix((ofMatrix4x4 const &)*arg1); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_loadMatrix__SWIG_1(lua_State* L) { int SWIG_arg = 0; float *arg1 = (float *) 0 ; - SWIG_check_num_args("ofLoadMatrix",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLoadMatrix",1,"float const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_float,0))){ SWIG_fail_ptr("loadMatrix",1,SWIGTYPE_p_float); } - ofLoadMatrix((float const *)arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_loadMatrix(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_loadMatrix__SWIG_0(L);} } if (argc == 1) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_loadMatrix__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'loadMatrix'\n" " Possible C/C++ prototypes are:\n" - " ofLoadMatrix(ofMatrix4x4 const &)\n" " ofLoadMatrix(float const *)\n"); lua_error(L);return 0; } -static int _wrap_multMatrix__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = 0 ; - SWIG_check_num_args("ofMultMatrix",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofMultMatrix",1,"ofMatrix4x4 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("multMatrix",1,SWIGTYPE_p_ofMatrix4x4); } ofMultMatrix((ofMatrix4x4 const &)*arg1); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_multMatrix__SWIG_1(lua_State* L) { int SWIG_arg = 0; float *arg1 = (float *) 0 ; - SWIG_check_num_args("ofMultMatrix",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMultMatrix",1,"float const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_float,0))){ SWIG_fail_ptr("multMatrix",1,SWIGTYPE_p_float); } - ofMultMatrix((float const *)arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_multMatrix(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_multMatrix__SWIG_0(L);} } if (argc == 1) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_multMatrix__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'multMatrix'\n" " Possible C/C++ prototypes are:\n" - " ofMultMatrix(ofMatrix4x4 const &)\n" " ofMultMatrix(float const *)\n"); lua_error(L);return 0; } -static int _wrap_setMatrixMode(lua_State* L) { int SWIG_arg = 0; ofMatrixMode arg1 ; SWIG_check_num_args("ofSetMatrixMode",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetMatrixMode",1,"ofMatrixMode"); arg1 = (ofMatrixMode)(int)lua_tonumber(L, 1); - ofSetMatrixMode(arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_loadViewMatrix(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = 0 ; - SWIG_check_num_args("ofLoadViewMatrix",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofLoadViewMatrix",1,"ofMatrix4x4 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("loadViewMatrix",1,SWIGTYPE_p_ofMatrix4x4); } ofLoadViewMatrix((ofMatrix4x4 const &)*arg1); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_multViewMatrix(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = 0 ; - SWIG_check_num_args("ofMultViewMatrix",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofMultViewMatrix",1,"ofMatrix4x4 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("multViewMatrix",1,SWIGTYPE_p_ofMatrix4x4); } ofMultViewMatrix((ofMatrix4x4 const &)*arg1); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getCurrentViewMatrix(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 result; - SWIG_check_num_args("ofGetCurrentViewMatrix",0,0) result = ofGetCurrentViewMatrix(); { - ofMatrix4x4 * resultptr = new ofMatrix4x4((const ofMatrix4x4 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_pushView(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofPushView",0,0) ofPushView(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_popView(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofPopView",0,0) ofPopView(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_viewport__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofRectangle arg1 ; ofRectangle *argp1 ; - SWIG_check_num_args("ofViewport",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofViewport",1,"ofRectangle"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&argp1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("viewport",1,SWIGTYPE_p_ofRectangle); } arg1 = *argp1; ofViewport(arg1); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_viewport__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - bool arg5 ; SWIG_check_num_args("ofViewport",5,5) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofViewport",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofViewport",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofViewport",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofViewport",4,"float"); if(!lua_isboolean(L,5)) SWIG_fail_arg("ofViewport",5,"bool"); - arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - arg4 = (float)lua_tonumber(L, 4); arg5 = (lua_toboolean(L, 5)!=0); ofViewport(arg1,arg2,arg3,arg4,arg5); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_viewport__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - SWIG_check_num_args("ofViewport",4,4) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofViewport",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofViewport",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofViewport",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofViewport",4,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - ofViewport(arg1,arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_viewport__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofViewport",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofViewport",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofViewport",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofViewport",3,"float"); - arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - ofViewport(arg1,arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_viewport__SWIG_4(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; - SWIG_check_num_args("ofViewport",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofViewport",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofViewport",2,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); ofViewport(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_viewport__SWIG_5(lua_State* L) { int SWIG_arg = 0; float arg1 ; SWIG_check_num_args("ofViewport",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofViewport",1,"float"); arg1 = (float)lua_tonumber(L, 1); ofViewport(arg1); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_viewport__SWIG_6(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofViewport",0,0) ofViewport(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_viewport(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_viewport__SWIG_6(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_viewport__SWIG_0(L);} } if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_viewport__SWIG_5(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_viewport__SWIG_4(L);} - } } if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_viewport__SWIG_3(L);} } } } if (argc == 4) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_viewport__SWIG_2(L);} } } } } if (argc == 5) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isboolean(L,argv[4]); } if (_v) { return _wrap_viewport__SWIG_1(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'viewport'\n" " Possible C/C++ prototypes are:\n" - " ofViewport(ofRectangle)\n" " ofViewport(float,float,float,float,bool)\n" " ofViewport(float,float,float,float)\n" - " ofViewport(float,float,float)\n" " ofViewport(float,float)\n" " ofViewport(float)\n" " ofViewport()\n"); - lua_error(L);return 0; } -static int _wrap_getCurrentViewport(lua_State* L) { int SWIG_arg = 0; ofRectangle result; - SWIG_check_num_args("ofGetCurrentViewport",0,0) result = ofGetCurrentViewport(); { - ofRectangle * resultptr = new ofRectangle((const ofRectangle &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofRectangle,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_getNativeViewport(lua_State* L) { int SWIG_arg = 0; ofRectangle result; - SWIG_check_num_args("ofGetNativeViewport",0,0) result = ofGetNativeViewport(); { - ofRectangle * resultptr = new ofRectangle((const ofRectangle &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofRectangle,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_getViewportWidth(lua_State* L) { int SWIG_arg = 0; int result; SWIG_check_num_args("ofGetViewportWidth",0,0) - result = (int)ofGetViewportWidth(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_getViewportHeight(lua_State* L) { int SWIG_arg = 0; int result; SWIG_check_num_args("ofGetViewportHeight",0,0) - result = (int)ofGetViewportHeight(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_setupScreenPerspective__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; - float arg4 ; float arg5 ; SWIG_check_num_args("ofSetupScreenPerspective",5,5) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetupScreenPerspective",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSetupScreenPerspective",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofSetupScreenPerspective",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofSetupScreenPerspective",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofSetupScreenPerspective",5,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); ofSetupScreenPerspective(arg1,arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_setupScreenPerspective__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; - float arg4 ; SWIG_check_num_args("ofSetupScreenPerspective",4,4) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetupScreenPerspective",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSetupScreenPerspective",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofSetupScreenPerspective",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofSetupScreenPerspective",4,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - ofSetupScreenPerspective(arg1,arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setupScreenPerspective__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofSetupScreenPerspective",3,3) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetupScreenPerspective",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSetupScreenPerspective",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofSetupScreenPerspective",3,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); ofSetupScreenPerspective(arg1,arg2,arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setupScreenPerspective__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; - SWIG_check_num_args("ofSetupScreenPerspective",2,2) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetupScreenPerspective",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSetupScreenPerspective",2,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); ofSetupScreenPerspective(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_setupScreenPerspective__SWIG_4(lua_State* L) { int SWIG_arg = 0; float arg1 ; - SWIG_check_num_args("ofSetupScreenPerspective",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetupScreenPerspective",1,"float"); arg1 = (float)lua_tonumber(L, 1); - ofSetupScreenPerspective(arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setupScreenPerspective__SWIG_5(lua_State* L) { int SWIG_arg = 0; - SWIG_check_num_args("ofSetupScreenPerspective",0,0) ofSetupScreenPerspective(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_setupScreenPerspective(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); - if (argc == 0) { return _wrap_setupScreenPerspective__SWIG_5(L);} if (argc == 1) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { return _wrap_setupScreenPerspective__SWIG_4(L);} } if (argc == 2) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_setupScreenPerspective__SWIG_3(L);} } } - if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_setupScreenPerspective__SWIG_2(L);} } } } if (argc == 4) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { - return _wrap_setupScreenPerspective__SWIG_1(L);} } } } } if (argc == 5) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_setupScreenPerspective__SWIG_0(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'setupScreenPerspective'\n" - " Possible C/C++ prototypes are:\n" " ofSetupScreenPerspective(float,float,float,float,float)\n" - " ofSetupScreenPerspective(float,float,float,float)\n" " ofSetupScreenPerspective(float,float,float)\n" - " ofSetupScreenPerspective(float,float)\n" " ofSetupScreenPerspective(float)\n" " ofSetupScreenPerspective()\n"); - lua_error(L);return 0; } -static int _wrap_setupScreenOrtho__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - SWIG_check_num_args("ofSetupScreenOrtho",4,4) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetupScreenOrtho",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSetupScreenOrtho",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofSetupScreenOrtho",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofSetupScreenOrtho",4,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - ofSetupScreenOrtho(arg1,arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setupScreenOrtho__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofSetupScreenOrtho",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetupScreenOrtho",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSetupScreenOrtho",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofSetupScreenOrtho",3,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); ofSetupScreenOrtho(arg1,arg2,arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setupScreenOrtho__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; - SWIG_check_num_args("ofSetupScreenOrtho",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetupScreenOrtho",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSetupScreenOrtho",2,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); ofSetupScreenOrtho(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_setupScreenOrtho__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; - SWIG_check_num_args("ofSetupScreenOrtho",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetupScreenOrtho",1,"float"); - arg1 = (float)lua_tonumber(L, 1); ofSetupScreenOrtho(arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_setupScreenOrtho__SWIG_4(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofSetupScreenOrtho",0,0) - ofSetupScreenOrtho(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setupScreenOrtho(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_setupScreenOrtho__SWIG_4(L);} if (argc == 1) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { - return _wrap_setupScreenOrtho__SWIG_3(L);} } if (argc == 2) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_setupScreenOrtho__SWIG_2(L);} } } if (argc == 3) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_setupScreenOrtho__SWIG_1(L);} } } } if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_setupScreenOrtho__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'setupScreenOrtho'\n" " Possible C/C++ prototypes are:\n" - " ofSetupScreenOrtho(float,float,float,float)\n" " ofSetupScreenOrtho(float,float,float)\n" - " ofSetupScreenOrtho(float,float)\n" " ofSetupScreenOrtho(float)\n" " ofSetupScreenOrtho()\n"); - lua_error(L);return 0; } -static int _wrap_orientationToDegrees(lua_State* L) { int SWIG_arg = 0; ofOrientation arg1 ; int result; - SWIG_check_num_args("ofOrientationToDegrees",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofOrientationToDegrees",1,"ofOrientation"); - arg1 = (ofOrientation)(int)lua_tonumber(L, 1); result = (int)ofOrientationToDegrees(arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setCoordHandedness(lua_State* L) { int SWIG_arg = 0; ofHandednessType arg1 ; - SWIG_check_num_args("ofSetCoordHandedness",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetCoordHandedness",1,"ofHandednessType"); - arg1 = (ofHandednessType)(int)lua_tonumber(L, 1); ofSetCoordHandedness(arg1); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_getCoordHandedness(lua_State* L) { int SWIG_arg = 0; ofHandednessType result; - SWIG_check_num_args("ofGetCoordHandedness",0,0) result = (ofHandednessType)ofGetCoordHandedness(); - lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_beginSaveScreenAsPDF__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string arg1 ; bool arg2 ; bool arg3 ; - ofRectangle arg4 ; ofRectangle *argp4 ; SWIG_check_num_args("ofBeginSaveScreenAsPDF",4,4) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofBeginSaveScreenAsPDF",1,"std::string"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofBeginSaveScreenAsPDF",2,"bool"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofBeginSaveScreenAsPDF",3,"bool"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofBeginSaveScreenAsPDF",4,"ofRectangle"); - (&arg1)->assign(lua_tostring(L,1),lua_rawlen(L,1)); arg2 = (lua_toboolean(L, 2)!=0); arg3 = (lua_toboolean(L, 3)!=0); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&argp4,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("beginSaveScreenAsPDF",4,SWIGTYPE_p_ofRectangle); } arg4 = *argp4; - ofBeginSaveScreenAsPDF(arg1,arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_beginSaveScreenAsPDF__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string arg1 ; bool arg2 ; bool arg3 ; - SWIG_check_num_args("ofBeginSaveScreenAsPDF",3,3) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofBeginSaveScreenAsPDF",1,"std::string"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofBeginSaveScreenAsPDF",2,"bool"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofBeginSaveScreenAsPDF",3,"bool"); (&arg1)->assign(lua_tostring(L,1),lua_rawlen(L,1)); - arg2 = (lua_toboolean(L, 2)!=0); arg3 = (lua_toboolean(L, 3)!=0); ofBeginSaveScreenAsPDF(arg1,arg2,arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_beginSaveScreenAsPDF__SWIG_2(lua_State* L) { int SWIG_arg = 0; std::string arg1 ; bool arg2 ; - SWIG_check_num_args("ofBeginSaveScreenAsPDF",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofBeginSaveScreenAsPDF",1,"std::string"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofBeginSaveScreenAsPDF",2,"bool"); (&arg1)->assign(lua_tostring(L,1),lua_rawlen(L,1)); - arg2 = (lua_toboolean(L, 2)!=0); ofBeginSaveScreenAsPDF(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_beginSaveScreenAsPDF__SWIG_3(lua_State* L) { int SWIG_arg = 0; std::string arg1 ; - SWIG_check_num_args("ofBeginSaveScreenAsPDF",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofBeginSaveScreenAsPDF",1,"std::string"); - (&arg1)->assign(lua_tostring(L,1),lua_rawlen(L,1)); ofBeginSaveScreenAsPDF(arg1); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_beginSaveScreenAsPDF(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 1) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { return _wrap_beginSaveScreenAsPDF__SWIG_3(L);} } - if (argc == 2) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_beginSaveScreenAsPDF__SWIG_2(L);} } } if (argc == 3) { int _v; { _v = lua_isstring(L,argv[0]); } - if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - return _wrap_beginSaveScreenAsPDF__SWIG_1(L);} } } } if (argc == 4) { int _v; { _v = lua_isstring(L,argv[0]); } - if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_beginSaveScreenAsPDF__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'beginSaveScreenAsPDF'\n" - " Possible C/C++ prototypes are:\n" " ofBeginSaveScreenAsPDF(std::string,bool,bool,ofRectangle)\n" - " ofBeginSaveScreenAsPDF(std::string,bool,bool)\n" " ofBeginSaveScreenAsPDF(std::string,bool)\n" - " ofBeginSaveScreenAsPDF(std::string)\n"); lua_error(L);return 0; } -static int _wrap_endSaveScreenAsPDF(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofEndSaveScreenAsPDF",0,0) - ofEndSaveScreenAsPDF(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_beginSaveScreenAsSVG__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string arg1 ; bool arg2 ; bool arg3 ; - ofRectangle arg4 ; ofRectangle *argp4 ; SWIG_check_num_args("ofBeginSaveScreenAsSVG",4,4) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofBeginSaveScreenAsSVG",1,"std::string"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofBeginSaveScreenAsSVG",2,"bool"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofBeginSaveScreenAsSVG",3,"bool"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofBeginSaveScreenAsSVG",4,"ofRectangle"); - (&arg1)->assign(lua_tostring(L,1),lua_rawlen(L,1)); arg2 = (lua_toboolean(L, 2)!=0); arg3 = (lua_toboolean(L, 3)!=0); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&argp4,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("beginSaveScreenAsSVG",4,SWIGTYPE_p_ofRectangle); } arg4 = *argp4; - ofBeginSaveScreenAsSVG(arg1,arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_beginSaveScreenAsSVG__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string arg1 ; bool arg2 ; bool arg3 ; - SWIG_check_num_args("ofBeginSaveScreenAsSVG",3,3) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofBeginSaveScreenAsSVG",1,"std::string"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofBeginSaveScreenAsSVG",2,"bool"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofBeginSaveScreenAsSVG",3,"bool"); (&arg1)->assign(lua_tostring(L,1),lua_rawlen(L,1)); - arg2 = (lua_toboolean(L, 2)!=0); arg3 = (lua_toboolean(L, 3)!=0); ofBeginSaveScreenAsSVG(arg1,arg2,arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_beginSaveScreenAsSVG__SWIG_2(lua_State* L) { int SWIG_arg = 0; std::string arg1 ; bool arg2 ; - SWIG_check_num_args("ofBeginSaveScreenAsSVG",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofBeginSaveScreenAsSVG",1,"std::string"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofBeginSaveScreenAsSVG",2,"bool"); (&arg1)->assign(lua_tostring(L,1),lua_rawlen(L,1)); - arg2 = (lua_toboolean(L, 2)!=0); ofBeginSaveScreenAsSVG(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_beginSaveScreenAsSVG__SWIG_3(lua_State* L) { int SWIG_arg = 0; std::string arg1 ; - SWIG_check_num_args("ofBeginSaveScreenAsSVG",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofBeginSaveScreenAsSVG",1,"std::string"); - (&arg1)->assign(lua_tostring(L,1),lua_rawlen(L,1)); ofBeginSaveScreenAsSVG(arg1); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_beginSaveScreenAsSVG(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 1) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { return _wrap_beginSaveScreenAsSVG__SWIG_3(L);} } - if (argc == 2) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_beginSaveScreenAsSVG__SWIG_2(L);} } } if (argc == 3) { int _v; { _v = lua_isstring(L,argv[0]); } - if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - return _wrap_beginSaveScreenAsSVG__SWIG_1(L);} } } } if (argc == 4) { int _v; { _v = lua_isstring(L,argv[0]); } - if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_beginSaveScreenAsSVG__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'beginSaveScreenAsSVG'\n" - " Possible C/C++ prototypes are:\n" " ofBeginSaveScreenAsSVG(std::string,bool,bool,ofRectangle)\n" - " ofBeginSaveScreenAsSVG(std::string,bool,bool)\n" " ofBeginSaveScreenAsSVG(std::string,bool)\n" - " ofBeginSaveScreenAsSVG(std::string)\n"); lua_error(L);return 0; } -static int _wrap_endSaveScreenAsSVG(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofEndSaveScreenAsSVG",0,0) - ofEndSaveScreenAsSVG(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setPlaneResolution(lua_State* L) { int SWIG_arg = 0; int arg1 ; int arg2 ; - SWIG_check_num_args("ofSetPlaneResolution",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetPlaneResolution",1,"int"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSetPlaneResolution",2,"int"); arg1 = (int)lua_tonumber(L, 1); - arg2 = (int)lua_tonumber(L, 2); ofSetPlaneResolution(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_getPlaneResolution(lua_State* L) { int SWIG_arg = 0; ofVec2f result; - SWIG_check_num_args("ofGetPlaneResolution",0,0) result = ofGetPlaneResolution(); { - ofVec2f * resultptr = new ofVec2f((const ofVec2f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_drawPlane__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - SWIG_check_num_args("ofDrawPlane",4,4) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawPlane",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawPlane",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawPlane",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawPlane",4,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - ofDrawPlane(arg1,arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawPlane__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - float arg5 ; SWIG_check_num_args("ofDrawPlane",5,5) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawPlane",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawPlane",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawPlane",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawPlane",4,"float"); if(!lua_isnumber(L,5)) SWIG_fail_arg("ofDrawPlane",5,"float"); - arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); ofDrawPlane(arg1,arg2,arg3,arg4,arg5); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawPlane__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPoint *arg1 = 0 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofDrawPlane",3,3) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofDrawPlane",1,"ofPoint &"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawPlane",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawPlane",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("drawPlane",1,SWIGTYPE_p_ofVec3f); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); ofDrawPlane(*arg1,arg2,arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawPlane__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; - SWIG_check_num_args("ofDrawPlane",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawPlane",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawPlane",2,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); ofDrawPlane(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_drawPlane(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 2) { int _v; - { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_drawPlane__SWIG_3(L);} - } } if (argc == 3) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_drawPlane__SWIG_2(L);} } } } if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_drawPlane__SWIG_0(L);} } } } } if (argc == 5) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_drawPlane__SWIG_1(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'drawPlane'\n" " Possible C/C++ prototypes are:\n" - " ofDrawPlane(float,float,float,float)\n" " ofDrawPlane(float,float,float,float,float)\n" - " ofDrawPlane(ofPoint &,float,float)\n" " ofDrawPlane(float,float)\n"); lua_error(L);return 0; } -static int _wrap_setSphereResolution(lua_State* L) { int SWIG_arg = 0; int arg1 ; - SWIG_check_num_args("ofSetSphereResolution",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetSphereResolution",1,"int"); - arg1 = (int)lua_tonumber(L, 1); ofSetSphereResolution(arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_getSphereResolution(lua_State* L) { int SWIG_arg = 0; int result; - SWIG_check_num_args("ofGetSphereResolution",0,0) result = (int)ofGetSphereResolution(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawSphere__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofDrawSphere",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawSphere",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawSphere",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawSphere",3,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); ofDrawSphere(arg1,arg2,arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawSphere__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - SWIG_check_num_args("ofDrawSphere",4,4) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawSphere",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawSphere",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawSphere",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawSphere",4,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - ofDrawSphere(arg1,arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawSphere__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPoint *arg1 = 0 ; float arg2 ; - SWIG_check_num_args("ofDrawSphere",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofDrawSphere",1,"ofPoint const &"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawSphere",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("drawSphere",1,SWIGTYPE_p_ofVec3f); } - arg2 = (float)lua_tonumber(L, 2); ofDrawSphere((ofVec3f const &)*arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_drawSphere__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; SWIG_check_num_args("ofDrawSphere",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawSphere",1,"float"); arg1 = (float)lua_tonumber(L, 1); ofDrawSphere(arg1); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawSphere(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 1) { int _v; - { _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_drawSphere__SWIG_3(L);} } if (argc == 2) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_drawSphere__SWIG_2(L);} } } - if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_drawSphere__SWIG_0(L);} } } } if (argc == 4) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_drawSphere__SWIG_1(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'drawSphere'\n" " Possible C/C++ prototypes are:\n" - " ofDrawSphere(float,float,float)\n" " ofDrawSphere(float,float,float,float)\n" - " ofDrawSphere(ofPoint const &,float)\n" " ofDrawSphere(float)\n"); lua_error(L);return 0; } -static int _wrap_setIcoSphereResolution(lua_State* L) { int SWIG_arg = 0; int arg1 ; - SWIG_check_num_args("ofSetIcoSphereResolution",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetIcoSphereResolution",1,"int"); - arg1 = (int)lua_tonumber(L, 1); ofSetIcoSphereResolution(arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_getIcoSphereResolution(lua_State* L) { int SWIG_arg = 0; int result; - SWIG_check_num_args("ofGetIcoSphereResolution",0,0) result = (int)ofGetIcoSphereResolution(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawIcoSphere__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - SWIG_check_num_args("ofDrawIcoSphere",4,4) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawIcoSphere",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawIcoSphere",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawIcoSphere",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawIcoSphere",4,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - ofDrawIcoSphere(arg1,arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawIcoSphere__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofDrawIcoSphere",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawIcoSphere",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawIcoSphere",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawIcoSphere",3,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); ofDrawIcoSphere(arg1,arg2,arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawIcoSphere__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPoint *arg1 = 0 ; float arg2 ; - SWIG_check_num_args("ofDrawIcoSphere",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofDrawIcoSphere",1,"ofPoint const &"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawIcoSphere",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("drawIcoSphere",1,SWIGTYPE_p_ofVec3f); } arg2 = (float)lua_tonumber(L, 2); - ofDrawIcoSphere((ofVec3f const &)*arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawIcoSphere__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; SWIG_check_num_args("ofDrawIcoSphere",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawIcoSphere",1,"float"); arg1 = (float)lua_tonumber(L, 1); ofDrawIcoSphere(arg1); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawIcoSphere(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_drawIcoSphere__SWIG_3(L);} } if (argc == 2) { int _v; { - void *ptr; if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_drawIcoSphere__SWIG_2(L);} } } if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_drawIcoSphere__SWIG_1(L);} } } } if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_drawIcoSphere__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'drawIcoSphere'\n" " Possible C/C++ prototypes are:\n" - " ofDrawIcoSphere(float,float,float,float)\n" " ofDrawIcoSphere(float,float,float)\n" - " ofDrawIcoSphere(ofPoint const &,float)\n" " ofDrawIcoSphere(float)\n"); lua_error(L);return 0; } -static int _wrap_setCylinderResolution__SWIG_0(lua_State* L) { int SWIG_arg = 0; int arg1 ; int arg2 ; int arg3 ; - SWIG_check_num_args("ofSetCylinderResolution",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetCylinderResolution",1,"int"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSetCylinderResolution",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofSetCylinderResolution",3,"int"); arg1 = (int)lua_tonumber(L, 1); - arg2 = (int)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); ofSetCylinderResolution(arg1,arg2,arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setCylinderResolution__SWIG_1(lua_State* L) { int SWIG_arg = 0; int arg1 ; int arg2 ; - SWIG_check_num_args("ofSetCylinderResolution",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetCylinderResolution",1,"int"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSetCylinderResolution",2,"int"); arg1 = (int)lua_tonumber(L, 1); - arg2 = (int)lua_tonumber(L, 2); ofSetCylinderResolution(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_setCylinderResolution(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_setCylinderResolution__SWIG_1(L);} } } if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_setCylinderResolution__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'setCylinderResolution'\n" - " Possible C/C++ prototypes are:\n" " ofSetCylinderResolution(int,int,int)\n" " ofSetCylinderResolution(int,int)\n"); - lua_error(L);return 0; } -static int _wrap_getCylinderResolution(lua_State* L) { int SWIG_arg = 0; ofVec3f result; - SWIG_check_num_args("ofGetCylinderResolution",0,0) result = ofGetCylinderResolution(); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_drawCylinder__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - SWIG_check_num_args("ofDrawCylinder",4,4) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawCylinder",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawCylinder",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawCylinder",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawCylinder",4,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - ofDrawCylinder(arg1,arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawCylinder__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - float arg5 ; SWIG_check_num_args("ofDrawCylinder",5,5) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawCylinder",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawCylinder",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawCylinder",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawCylinder",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofDrawCylinder",5,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); ofDrawCylinder(arg1,arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_drawCylinder__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPoint *arg1 = 0 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofDrawCylinder",3,3) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofDrawCylinder",1,"ofPoint const &"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawCylinder",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawCylinder",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("drawCylinder",1,SWIGTYPE_p_ofVec3f); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); ofDrawCylinder((ofVec3f const &)*arg1,arg2,arg3); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawCylinder__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; - SWIG_check_num_args("ofDrawCylinder",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawCylinder",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawCylinder",2,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); ofDrawCylinder(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_drawCylinder(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_drawCylinder__SWIG_3(L);} } } if (argc == 3) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_drawCylinder__SWIG_2(L);} } } } if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { - { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_drawCylinder__SWIG_0(L);} } } } } if (argc == 5) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_drawCylinder__SWIG_1(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'drawCylinder'\n" " Possible C/C++ prototypes are:\n" - " ofDrawCylinder(float,float,float,float)\n" " ofDrawCylinder(float,float,float,float,float)\n" - " ofDrawCylinder(ofPoint const &,float,float)\n" " ofDrawCylinder(float,float)\n"); lua_error(L);return 0; } -static int _wrap_setConeResolution__SWIG_0(lua_State* L) { int SWIG_arg = 0; int arg1 ; int arg2 ; int arg3 ; - SWIG_check_num_args("ofSetConeResolution",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetConeResolution",1,"int"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSetConeResolution",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofSetConeResolution",3,"int"); arg1 = (int)lua_tonumber(L, 1); - arg2 = (int)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); ofSetConeResolution(arg1,arg2,arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setConeResolution__SWIG_1(lua_State* L) { int SWIG_arg = 0; int arg1 ; int arg2 ; - SWIG_check_num_args("ofSetConeResolution",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetConeResolution",1,"int"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSetConeResolution",2,"int"); arg1 = (int)lua_tonumber(L, 1); - arg2 = (int)lua_tonumber(L, 2); ofSetConeResolution(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_setConeResolution(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_setConeResolution__SWIG_1(L);} } } if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { - { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_setConeResolution__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'setConeResolution'\n" " Possible C/C++ prototypes are:\n" - " ofSetConeResolution(int,int,int)\n" " ofSetConeResolution(int,int)\n"); lua_error(L);return 0; } -static int _wrap_getConeResolution(lua_State* L) { int SWIG_arg = 0; ofVec3f result; - SWIG_check_num_args("ofGetConeResolution",0,0) result = ofGetConeResolution(); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_drawCone__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - float arg5 ; SWIG_check_num_args("ofDrawCone",5,5) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawCone",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawCone",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawCone",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawCone",4,"float"); if(!lua_isnumber(L,5)) SWIG_fail_arg("ofDrawCone",5,"float"); - arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); ofDrawCone(arg1,arg2,arg3,arg4,arg5); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawCone__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - SWIG_check_num_args("ofDrawCone",4,4) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawCone",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawCone",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawCone",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawCone",4,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - ofDrawCone(arg1,arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawCone__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPoint *arg1 = 0 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofDrawCone",3,3) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofDrawCone",1,"ofPoint const &"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawCone",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawCone",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("drawCone",1,SWIGTYPE_p_ofVec3f); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); ofDrawCone((ofVec3f const &)*arg1,arg2,arg3); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawCone__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; - SWIG_check_num_args("ofDrawCone",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawCone",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawCone",2,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); ofDrawCone(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_drawCone(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 2) { int _v; - { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_drawCone__SWIG_3(L);} - } } if (argc == 3) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_drawCone__SWIG_2(L);} } } } if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_drawCone__SWIG_1(L);} } } } } if (argc == 5) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_drawCone__SWIG_0(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'drawCone'\n" " Possible C/C++ prototypes are:\n" - " ofDrawCone(float,float,float,float,float)\n" " ofDrawCone(float,float,float,float)\n" - " ofDrawCone(ofPoint const &,float,float)\n" " ofDrawCone(float,float)\n"); lua_error(L);return 0; } -static int _wrap_setBoxResolution__SWIG_0(lua_State* L) { int SWIG_arg = 0; int arg1 ; - SWIG_check_num_args("ofSetBoxResolution",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetBoxResolution",1,"int"); - arg1 = (int)lua_tonumber(L, 1); ofSetBoxResolution(arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_setBoxResolution__SWIG_1(lua_State* L) { int SWIG_arg = 0; int arg1 ; int arg2 ; int arg3 ; - SWIG_check_num_args("ofSetBoxResolution",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetBoxResolution",1,"int"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSetBoxResolution",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofSetBoxResolution",3,"int"); arg1 = (int)lua_tonumber(L, 1); - arg2 = (int)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); ofSetBoxResolution(arg1,arg2,arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setBoxResolution(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_setBoxResolution__SWIG_0(L);} } if (argc == 3) { int _v; - { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_setBoxResolution__SWIG_1(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'setBoxResolution'\n" " Possible C/C++ prototypes are:\n" - " ofSetBoxResolution(int)\n" " ofSetBoxResolution(int,int,int)\n"); lua_error(L);return 0; } -static int _wrap_getBoxResolution(lua_State* L) { int SWIG_arg = 0; ofVec3f result; - SWIG_check_num_args("ofGetBoxResolution",0,0) result = ofGetBoxResolution(); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_drawBox__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - float arg5 ; float arg6 ; SWIG_check_num_args("ofDrawBox",6,6) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawBox",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawBox",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawBox",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawBox",4,"float"); if(!lua_isnumber(L,5)) SWIG_fail_arg("ofDrawBox",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofDrawBox",6,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); ofDrawBox(arg1,arg2,arg3,arg4,arg5,arg6); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawBox__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - SWIG_check_num_args("ofDrawBox",4,4) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawBox",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawBox",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawBox",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawBox",4,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - ofDrawBox(arg1,arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawBox__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPoint *arg1 = 0 ; float arg2 ; float arg3 ; float arg4 ; - SWIG_check_num_args("ofDrawBox",4,4) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofDrawBox",1,"ofPoint const &"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawBox",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawBox",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawBox",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("drawBox",1,SWIGTYPE_p_ofVec3f); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - ofDrawBox((ofVec3f const &)*arg1,arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawBox__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofPoint *arg1 = 0 ; float arg2 ; - SWIG_check_num_args("ofDrawBox",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofDrawBox",1,"ofPoint const &"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawBox",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("drawBox",1,SWIGTYPE_p_ofVec3f); } - arg2 = (float)lua_tonumber(L, 2); ofDrawBox((ofVec3f const &)*arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_drawBox__SWIG_4(lua_State* L) { int SWIG_arg = 0; float arg1 ; SWIG_check_num_args("ofDrawBox",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawBox",1,"float"); arg1 = (float)lua_tonumber(L, 1); ofDrawBox(arg1); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawBox__SWIG_5(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofDrawBox",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawBox",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawBox",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawBox",3,"float"); - arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - ofDrawBox(arg1,arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawBox(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); if (argc == 1) { int _v; - { _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_drawBox__SWIG_4(L);} } if (argc == 2) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_drawBox__SWIG_3(L);} } } - if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_drawBox__SWIG_5(L);} } } } if (argc == 4) { int _v; { - void *ptr; if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_drawBox__SWIG_2(L);} } } } } if (argc == 4) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { - return _wrap_drawBox__SWIG_1(L);} } } } } if (argc == 6) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { - { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { - return _wrap_drawBox__SWIG_0(L);} } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'drawBox'\n" " Possible C/C++ prototypes are:\n" - " ofDrawBox(float,float,float,float,float,float)\n" " ofDrawBox(float,float,float,float)\n" - " ofDrawBox(ofPoint const &,float,float,float)\n" " ofDrawBox(ofPoint const &,float)\n" " ofDrawBox(float)\n" - " ofDrawBox(float,float,float)\n"); lua_error(L);return 0; } -static int _wrap_TTF_SANS_get(lua_State* L) { int SWIG_arg = 0; std::string *result = 0 ; SWIG_check_num_args("OF_TTF_SANS",0,0) - result = (std::string *) &OF_TTF_SANS; lua_pushlstring(L,result->data(),result->size()); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TTF_SERIF_get(lua_State* L) { int SWIG_arg = 0; std::string *result = 0 ; - SWIG_check_num_args("OF_TTF_SERIF",0,0) result = (std::string *) &OF_TTF_SERIF; - lua_pushlstring(L,result->data(),result->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_TTF_MONO_get(lua_State* L) { int SWIG_arg = 0; std::string *result = 0 ; SWIG_check_num_args("OF_TTF_MONO",0,0) - result = (std::string *) &OF_TTF_MONO; lua_pushlstring(L,result->data(),result->size()); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_new_TrueTypeFont__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofTrueTypeFont *result = 0 ; - SWIG_check_num_args("ofTrueTypeFont::ofTrueTypeFont",0,0) result = (ofTrueTypeFont *)new ofTrueTypeFont(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTrueTypeFont,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_TrueTypeFont__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofTrueTypeFont *arg1 = 0 ; - ofTrueTypeFont *result = 0 ; SWIG_check_num_args("ofTrueTypeFont::ofTrueTypeFont",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofTrueTypeFont::ofTrueTypeFont",1,"ofTrueTypeFont &&"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("new_TrueTypeFont",1,SWIGTYPE_p_ofTrueTypeFont); } - result = (ofTrueTypeFont *)new ofTrueTypeFont((ofTrueTypeFont &&)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTrueTypeFont,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_TrueTypeFont(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_TrueTypeFont__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTrueTypeFont, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_new_TrueTypeFont__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_TrueTypeFont'\n" " Possible C/C++ prototypes are:\n" - " ofTrueTypeFont::ofTrueTypeFont()\n" " ofTrueTypeFont::ofTrueTypeFont(ofTrueTypeFont &&)\n"); lua_error(L);return 0; } -static int _wrap_TrueTypeFont_load__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; - std::string *arg2 = 0 ; int arg3 ; bool arg4 ; bool arg5 ; bool arg6 ; float arg7 ; int arg8 ; std::string temp2 ; - bool result; SWIG_check_num_args("ofTrueTypeFont::load",8,8) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::load",1,"ofTrueTypeFont *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofTrueTypeFont::load",2,"std::string const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTrueTypeFont::load",3,"int"); - if(!lua_isboolean(L,4)) SWIG_fail_arg("ofTrueTypeFont::load",4,"bool"); - if(!lua_isboolean(L,5)) SWIG_fail_arg("ofTrueTypeFont::load",5,"bool"); - if(!lua_isboolean(L,6)) SWIG_fail_arg("ofTrueTypeFont::load",6,"bool"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofTrueTypeFont::load",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofTrueTypeFont::load",8,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_load",1,SWIGTYPE_p_ofTrueTypeFont); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; arg3 = (int)lua_tonumber(L, 3); arg4 = (lua_toboolean(L, 4)!=0); - arg5 = (lua_toboolean(L, 5)!=0); arg6 = (lua_toboolean(L, 6)!=0); arg7 = (float)lua_tonumber(L, 7); - arg8 = (int)lua_tonumber(L, 8); result = (bool)(arg1)->load((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_load__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; - std::string *arg2 = 0 ; int arg3 ; bool arg4 ; bool arg5 ; bool arg6 ; float arg7 ; std::string temp2 ; bool result; - SWIG_check_num_args("ofTrueTypeFont::load",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::load",1,"ofTrueTypeFont *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofTrueTypeFont::load",2,"std::string const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTrueTypeFont::load",3,"int"); - if(!lua_isboolean(L,4)) SWIG_fail_arg("ofTrueTypeFont::load",4,"bool"); - if(!lua_isboolean(L,5)) SWIG_fail_arg("ofTrueTypeFont::load",5,"bool"); - if(!lua_isboolean(L,6)) SWIG_fail_arg("ofTrueTypeFont::load",6,"bool"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofTrueTypeFont::load",7,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_load",1,SWIGTYPE_p_ofTrueTypeFont); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; arg3 = (int)lua_tonumber(L, 3); arg4 = (lua_toboolean(L, 4)!=0); - arg5 = (lua_toboolean(L, 5)!=0); arg6 = (lua_toboolean(L, 6)!=0); arg7 = (float)lua_tonumber(L, 7); - result = (bool)(arg1)->load((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_load__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; - std::string *arg2 = 0 ; int arg3 ; bool arg4 ; bool arg5 ; bool arg6 ; std::string temp2 ; bool result; - SWIG_check_num_args("ofTrueTypeFont::load",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::load",1,"ofTrueTypeFont *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofTrueTypeFont::load",2,"std::string const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTrueTypeFont::load",3,"int"); - if(!lua_isboolean(L,4)) SWIG_fail_arg("ofTrueTypeFont::load",4,"bool"); - if(!lua_isboolean(L,5)) SWIG_fail_arg("ofTrueTypeFont::load",5,"bool"); - if(!lua_isboolean(L,6)) SWIG_fail_arg("ofTrueTypeFont::load",6,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_load",1,SWIGTYPE_p_ofTrueTypeFont); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; arg3 = (int)lua_tonumber(L, 3); arg4 = (lua_toboolean(L, 4)!=0); - arg5 = (lua_toboolean(L, 5)!=0); arg6 = (lua_toboolean(L, 6)!=0); - result = (bool)(arg1)->load((std::string const &)*arg2,arg3,arg4,arg5,arg6); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_load__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; - std::string *arg2 = 0 ; int arg3 ; bool arg4 ; bool arg5 ; std::string temp2 ; bool result; - SWIG_check_num_args("ofTrueTypeFont::load",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::load",1,"ofTrueTypeFont *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofTrueTypeFont::load",2,"std::string const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTrueTypeFont::load",3,"int"); - if(!lua_isboolean(L,4)) SWIG_fail_arg("ofTrueTypeFont::load",4,"bool"); - if(!lua_isboolean(L,5)) SWIG_fail_arg("ofTrueTypeFont::load",5,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_load",1,SWIGTYPE_p_ofTrueTypeFont); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; arg3 = (int)lua_tonumber(L, 3); arg4 = (lua_toboolean(L, 4)!=0); - arg5 = (lua_toboolean(L, 5)!=0); result = (bool)(arg1)->load((std::string const &)*arg2,arg3,arg4,arg5); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_load__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; - std::string *arg2 = 0 ; int arg3 ; bool arg4 ; std::string temp2 ; bool result; - SWIG_check_num_args("ofTrueTypeFont::load",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::load",1,"ofTrueTypeFont *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofTrueTypeFont::load",2,"std::string const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTrueTypeFont::load",3,"int"); - if(!lua_isboolean(L,4)) SWIG_fail_arg("ofTrueTypeFont::load",4,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_load",1,SWIGTYPE_p_ofTrueTypeFont); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; arg3 = (int)lua_tonumber(L, 3); arg4 = (lua_toboolean(L, 4)!=0); - result = (bool)(arg1)->load((std::string const &)*arg2,arg3,arg4); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_load__SWIG_5(lua_State* L) { int SWIG_arg = 0; ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; - std::string *arg2 = 0 ; int arg3 ; std::string temp2 ; bool result; SWIG_check_num_args("ofTrueTypeFont::load",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::load",1,"ofTrueTypeFont *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofTrueTypeFont::load",2,"std::string const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTrueTypeFont::load",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_load",1,SWIGTYPE_p_ofTrueTypeFont); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; arg3 = (int)lua_tonumber(L, 3); - result = (bool)(arg1)->load((std::string const &)*arg2,arg3); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_load(lua_State* L) { int argc; int argv[9]={ 1,2,3,4,5,6,7,8,9} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTrueTypeFont, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_TrueTypeFont_load__SWIG_5(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTrueTypeFont, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isboolean(L,argv[3]); } if (_v) { return _wrap_TrueTypeFont_load__SWIG_4(L);} } } } } - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTrueTypeFont, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isboolean(L,argv[3]); } if (_v) { { _v = lua_isboolean(L,argv[4]); } if (_v) { - return _wrap_TrueTypeFont_load__SWIG_3(L);} } } } } } if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTrueTypeFont, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isboolean(L,argv[3]); } if (_v) { { _v = lua_isboolean(L,argv[4]); } if (_v) { { - _v = lua_isboolean(L,argv[5]); } if (_v) { return _wrap_TrueTypeFont_load__SWIG_2(L);} } } } } } } - if (argc == 7) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTrueTypeFont, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isboolean(L,argv[3]); } if (_v) { { _v = lua_isboolean(L,argv[4]); } if (_v) { { - _v = lua_isboolean(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { - return _wrap_TrueTypeFont_load__SWIG_1(L);} } } } } } } } if (argc == 8) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTrueTypeFont, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isboolean(L,argv[3]); } if (_v) { { _v = lua_isboolean(L,argv[4]); } if (_v) { { - _v = lua_isboolean(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { return _wrap_TrueTypeFont_load__SWIG_0(L);} } } } } } } } - } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'TrueTypeFont_load'\n" - " Possible C/C++ prototypes are:\n" " ofTrueTypeFont::load(std::string const &,int,bool,bool,bool,float,int)\n" - " ofTrueTypeFont::load(std::string const &,int,bool,bool,bool,float)\n" - " ofTrueTypeFont::load(std::string const &,int,bool,bool,bool)\n" - " ofTrueTypeFont::load(std::string const &,int,bool,bool)\n" " ofTrueTypeFont::load(std::string const &,int,bool)\n" - " ofTrueTypeFont::load(std::string const &,int)\n"); lua_error(L);return 0; } -static int _wrap_TrueTypeFont_isLoaded(lua_State* L) { int SWIG_arg = 0; ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; - bool result; SWIG_check_num_args("ofTrueTypeFont::isLoaded",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::isLoaded",1,"ofTrueTypeFont const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_isLoaded",1,SWIGTYPE_p_ofTrueTypeFont); } - result = (bool)((ofTrueTypeFont const *)arg1)->isLoaded(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_setGlobalDpi(lua_State* L) { int SWIG_arg = 0; int arg1 ; - SWIG_check_num_args("ofTrueTypeFont::setGlobalDpi",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofTrueTypeFont::setGlobalDpi",1,"int"); arg1 = (int)lua_tonumber(L, 1); - ofTrueTypeFont::setGlobalDpi(arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_isAntiAliased(lua_State* L) { int SWIG_arg = 0; ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; - bool result; SWIG_check_num_args("ofTrueTypeFont::isAntiAliased",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::isAntiAliased",1,"ofTrueTypeFont const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_isAntiAliased",1,SWIGTYPE_p_ofTrueTypeFont); } - result = (bool)((ofTrueTypeFont const *)arg1)->isAntiAliased(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_hasFullCharacterSet(lua_State* L) { int SWIG_arg = 0; - ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; bool result; SWIG_check_num_args("ofTrueTypeFont::hasFullCharacterSet",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::hasFullCharacterSet",1,"ofTrueTypeFont const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_hasFullCharacterSet",1,SWIGTYPE_p_ofTrueTypeFont); } - result = (bool)((ofTrueTypeFont const *)arg1)->hasFullCharacterSet(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_getNumCharacters(lua_State* L) { int SWIG_arg = 0; ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; - int result; SWIG_check_num_args("ofTrueTypeFont::getNumCharacters",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::getNumCharacters",1,"ofTrueTypeFont const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_getNumCharacters",1,SWIGTYPE_p_ofTrueTypeFont); } - result = (int)((ofTrueTypeFont const *)arg1)->getNumCharacters(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_getSize(lua_State* L) { int SWIG_arg = 0; ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; - int result; SWIG_check_num_args("ofTrueTypeFont::getSize",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::getSize",1,"ofTrueTypeFont const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_getSize",1,SWIGTYPE_p_ofTrueTypeFont); } - result = (int)((ofTrueTypeFont const *)arg1)->getSize(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_getLineHeight(lua_State* L) { int SWIG_arg = 0; ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; - float result; SWIG_check_num_args("ofTrueTypeFont::getLineHeight",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::getLineHeight",1,"ofTrueTypeFont const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_getLineHeight",1,SWIGTYPE_p_ofTrueTypeFont); } - result = (float)((ofTrueTypeFont const *)arg1)->getLineHeight(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_setLineHeight(lua_State* L) { int SWIG_arg = 0; ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; - float arg2 ; SWIG_check_num_args("ofTrueTypeFont::setLineHeight",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::setLineHeight",1,"ofTrueTypeFont *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTrueTypeFont::setLineHeight",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_setLineHeight",1,SWIGTYPE_p_ofTrueTypeFont); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setLineHeight(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_getAscenderHeight(lua_State* L) { int SWIG_arg = 0; ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; - float result; SWIG_check_num_args("ofTrueTypeFont::getAscenderHeight",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::getAscenderHeight",1,"ofTrueTypeFont const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_getAscenderHeight",1,SWIGTYPE_p_ofTrueTypeFont); } - result = (float)((ofTrueTypeFont const *)arg1)->getAscenderHeight(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_getDescenderHeight(lua_State* L) { int SWIG_arg = 0; ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; - float result; SWIG_check_num_args("ofTrueTypeFont::getDescenderHeight",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::getDescenderHeight",1,"ofTrueTypeFont const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_getDescenderHeight",1,SWIGTYPE_p_ofTrueTypeFont); } - result = (float)((ofTrueTypeFont const *)arg1)->getDescenderHeight(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_getGlyphBBox(lua_State* L) { int SWIG_arg = 0; ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; - ofRectangle *result = 0 ; SWIG_check_num_args("ofTrueTypeFont::getGlyphBBox",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::getGlyphBBox",1,"ofTrueTypeFont const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_getGlyphBBox",1,SWIGTYPE_p_ofTrueTypeFont); } - result = (ofRectangle *) &((ofTrueTypeFont const *)arg1)->getGlyphBBox(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofRectangle,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_TrueTypeFont_getLetterSpacing(lua_State* L) { int SWIG_arg = 0; ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; - float result; SWIG_check_num_args("ofTrueTypeFont::getLetterSpacing",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::getLetterSpacing",1,"ofTrueTypeFont const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_getLetterSpacing",1,SWIGTYPE_p_ofTrueTypeFont); } - result = (float)((ofTrueTypeFont const *)arg1)->getLetterSpacing(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_setLetterSpacing(lua_State* L) { int SWIG_arg = 0; ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; - float arg2 ; SWIG_check_num_args("ofTrueTypeFont::setLetterSpacing",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::setLetterSpacing",1,"ofTrueTypeFont *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTrueTypeFont::setLetterSpacing",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_setLetterSpacing",1,SWIGTYPE_p_ofTrueTypeFont); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setLetterSpacing(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_getSpaceSize(lua_State* L) { int SWIG_arg = 0; ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; - float result; SWIG_check_num_args("ofTrueTypeFont::getSpaceSize",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::getSpaceSize",1,"ofTrueTypeFont const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_getSpaceSize",1,SWIGTYPE_p_ofTrueTypeFont); } - result = (float)((ofTrueTypeFont const *)arg1)->getSpaceSize(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_setSpaceSize(lua_State* L) { int SWIG_arg = 0; ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; - float arg2 ; SWIG_check_num_args("ofTrueTypeFont::setSpaceSize",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::setSpaceSize",1,"ofTrueTypeFont *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTrueTypeFont::setSpaceSize",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_setSpaceSize",1,SWIGTYPE_p_ofTrueTypeFont); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setSpaceSize(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_stringWidth(lua_State* L) { int SWIG_arg = 0; ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; - std::string *arg2 = 0 ; std::string temp2 ; float result; SWIG_check_num_args("ofTrueTypeFont::stringWidth",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::stringWidth",1,"ofTrueTypeFont const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofTrueTypeFont::stringWidth",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_stringWidth",1,SWIGTYPE_p_ofTrueTypeFont); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = (float)((ofTrueTypeFont const *)arg1)->stringWidth((std::string const &)*arg2); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_stringHeight(lua_State* L) { int SWIG_arg = 0; ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; - std::string *arg2 = 0 ; std::string temp2 ; float result; SWIG_check_num_args("ofTrueTypeFont::stringHeight",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::stringHeight",1,"ofTrueTypeFont const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofTrueTypeFont::stringHeight",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_stringHeight",1,SWIGTYPE_p_ofTrueTypeFont); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = (float)((ofTrueTypeFont const *)arg1)->stringHeight((std::string const &)*arg2); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_getStringBoundingBox__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; std::string *arg2 = 0 ; float arg3 ; float arg4 ; bool arg5 ; - std::string temp2 ; ofRectangle result; SWIG_check_num_args("ofTrueTypeFont::getStringBoundingBox",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::getStringBoundingBox",1,"ofTrueTypeFont const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofTrueTypeFont::getStringBoundingBox",2,"std::string const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTrueTypeFont::getStringBoundingBox",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofTrueTypeFont::getStringBoundingBox",4,"float"); - if(!lua_isboolean(L,5)) SWIG_fail_arg("ofTrueTypeFont::getStringBoundingBox",5,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_getStringBoundingBox",1,SWIGTYPE_p_ofTrueTypeFont); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; arg3 = (float)lua_tonumber(L, 3); - arg4 = (float)lua_tonumber(L, 4); arg5 = (lua_toboolean(L, 5)!=0); - result = ((ofTrueTypeFont const *)arg1)->getStringBoundingBox((std::string const &)*arg2,arg3,arg4,arg5); { - ofRectangle * resultptr = new ofRectangle((const ofRectangle &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofRectangle,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_getStringBoundingBox__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; std::string *arg2 = 0 ; float arg3 ; float arg4 ; std::string temp2 ; - ofRectangle result; SWIG_check_num_args("ofTrueTypeFont::getStringBoundingBox",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::getStringBoundingBox",1,"ofTrueTypeFont const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofTrueTypeFont::getStringBoundingBox",2,"std::string const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTrueTypeFont::getStringBoundingBox",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofTrueTypeFont::getStringBoundingBox",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_getStringBoundingBox",1,SWIGTYPE_p_ofTrueTypeFont); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; arg3 = (float)lua_tonumber(L, 3); - arg4 = (float)lua_tonumber(L, 4); - result = ((ofTrueTypeFont const *)arg1)->getStringBoundingBox((std::string const &)*arg2,arg3,arg4); { - ofRectangle * resultptr = new ofRectangle((const ofRectangle &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofRectangle,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_getStringBoundingBox(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); - if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTrueTypeFont, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_TrueTypeFont_getStringBoundingBox__SWIG_1(L);} } } } } - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTrueTypeFont, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isboolean(L,argv[4]); } if (_v) { - return _wrap_TrueTypeFont_getStringBoundingBox__SWIG_0(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'TrueTypeFont_getStringBoundingBox'\n" - " Possible C/C++ prototypes are:\n" " ofTrueTypeFont::getStringBoundingBox(std::string const &,float,float,bool) const\n" - " ofTrueTypeFont::getStringBoundingBox(std::string const &,float,float) const\n"); lua_error(L);return 0; } -static int _wrap_TrueTypeFont_drawString(lua_State* L) { int SWIG_arg = 0; ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; - std::string *arg2 = 0 ; float arg3 ; float arg4 ; std::string temp2 ; SWIG_check_num_args("ofTrueTypeFont::drawString",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::drawString",1,"ofTrueTypeFont const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofTrueTypeFont::drawString",2,"std::string const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTrueTypeFont::drawString",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofTrueTypeFont::drawString",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_drawString",1,SWIGTYPE_p_ofTrueTypeFont); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; arg3 = (float)lua_tonumber(L, 3); - arg4 = (float)lua_tonumber(L, 4); ((ofTrueTypeFont const *)arg1)->drawString((std::string const &)*arg2,arg3,arg4); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_drawStringAsShapes(lua_State* L) { int SWIG_arg = 0; ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; - std::string *arg2 = 0 ; float arg3 ; float arg4 ; std::string temp2 ; - SWIG_check_num_args("ofTrueTypeFont::drawStringAsShapes",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::drawStringAsShapes",1,"ofTrueTypeFont const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofTrueTypeFont::drawStringAsShapes",2,"std::string const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTrueTypeFont::drawStringAsShapes",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofTrueTypeFont::drawStringAsShapes",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_drawStringAsShapes",1,SWIGTYPE_p_ofTrueTypeFont); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; arg3 = (float)lua_tonumber(L, 3); - arg4 = (float)lua_tonumber(L, 4); ((ofTrueTypeFont const *)arg1)->drawStringAsShapes((std::string const &)*arg2,arg3,arg4); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_getCharacterAsPoints__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; int arg2 ; bool arg3 ; bool arg4 ; ofTTFCharacter result; - SWIG_check_num_args("ofTrueTypeFont::getCharacterAsPoints",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::getCharacterAsPoints",1,"ofTrueTypeFont const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTrueTypeFont::getCharacterAsPoints",2,"int"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofTrueTypeFont::getCharacterAsPoints",3,"bool"); - if(!lua_isboolean(L,4)) SWIG_fail_arg("ofTrueTypeFont::getCharacterAsPoints",4,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_getCharacterAsPoints",1,SWIGTYPE_p_ofTrueTypeFont); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (lua_toboolean(L, 3)!=0); arg4 = (lua_toboolean(L, 4)!=0); - result = ((ofTrueTypeFont const *)arg1)->getCharacterAsPoints(arg2,arg3,arg4); { - ofTTFCharacter * resultptr = new ofTTFCharacter((const ofTTFCharacter &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofPath,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_getCharacterAsPoints__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; int arg2 ; bool arg3 ; ofTTFCharacter result; - SWIG_check_num_args("ofTrueTypeFont::getCharacterAsPoints",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::getCharacterAsPoints",1,"ofTrueTypeFont const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTrueTypeFont::getCharacterAsPoints",2,"int"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofTrueTypeFont::getCharacterAsPoints",3,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_getCharacterAsPoints",1,SWIGTYPE_p_ofTrueTypeFont); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (lua_toboolean(L, 3)!=0); result = ((ofTrueTypeFont const *)arg1)->getCharacterAsPoints(arg2,arg3); { - ofTTFCharacter * resultptr = new ofTTFCharacter((const ofTTFCharacter &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofPath,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_getCharacterAsPoints__SWIG_2(lua_State* L) { int SWIG_arg = 0; - ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; int arg2 ; ofTTFCharacter result; - SWIG_check_num_args("ofTrueTypeFont::getCharacterAsPoints",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::getCharacterAsPoints",1,"ofTrueTypeFont const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTrueTypeFont::getCharacterAsPoints",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_getCharacterAsPoints",1,SWIGTYPE_p_ofTrueTypeFont); } arg2 = (int)lua_tonumber(L, 2); - result = ((ofTrueTypeFont const *)arg1)->getCharacterAsPoints(arg2); { - ofTTFCharacter * resultptr = new ofTTFCharacter((const ofTTFCharacter &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofPath,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_getCharacterAsPoints(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTrueTypeFont, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_TrueTypeFont_getCharacterAsPoints__SWIG_2(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTrueTypeFont, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - return _wrap_TrueTypeFont_getCharacterAsPoints__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTrueTypeFont, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - { _v = lua_isboolean(L,argv[3]); } if (_v) { return _wrap_TrueTypeFont_getCharacterAsPoints__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'TrueTypeFont_getCharacterAsPoints'\n" - " Possible C/C++ prototypes are:\n" " ofTrueTypeFont::getCharacterAsPoints(int,bool,bool) const\n" - " ofTrueTypeFont::getCharacterAsPoints(int,bool) const\n" " ofTrueTypeFont::getCharacterAsPoints(int) const\n"); - lua_error(L);return 0; } -static int _wrap_TrueTypeFont_getStringAsPoints__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; std::string *arg2 = 0 ; bool arg3 ; bool arg4 ; std::string temp2 ; - SwigValueWrapper< std::vector< ofPath > > result; SWIG_check_num_args("ofTrueTypeFont::getStringAsPoints",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::getStringAsPoints",1,"ofTrueTypeFont const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofTrueTypeFont::getStringAsPoints",2,"std::string const &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofTrueTypeFont::getStringAsPoints",3,"bool"); - if(!lua_isboolean(L,4)) SWIG_fail_arg("ofTrueTypeFont::getStringAsPoints",4,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_getStringAsPoints",1,SWIGTYPE_p_ofTrueTypeFont); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; arg3 = (lua_toboolean(L, 3)!=0); - arg4 = (lua_toboolean(L, 4)!=0); - result = ((ofTrueTypeFont const *)arg1)->getStringAsPoints((std::string const &)*arg2,arg3,arg4); { - std::vector< ofTTFCharacter > * resultptr = new std::vector< ofTTFCharacter >((const std::vector< ofTTFCharacter > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_ofPath_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_getStringAsPoints__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; std::string *arg2 = 0 ; bool arg3 ; std::string temp2 ; - SwigValueWrapper< std::vector< ofPath > > result; SWIG_check_num_args("ofTrueTypeFont::getStringAsPoints",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::getStringAsPoints",1,"ofTrueTypeFont const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofTrueTypeFont::getStringAsPoints",2,"std::string const &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofTrueTypeFont::getStringAsPoints",3,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_getStringAsPoints",1,SWIGTYPE_p_ofTrueTypeFont); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; arg3 = (lua_toboolean(L, 3)!=0); - result = ((ofTrueTypeFont const *)arg1)->getStringAsPoints((std::string const &)*arg2,arg3); { - std::vector< ofTTFCharacter > * resultptr = new std::vector< ofTTFCharacter >((const std::vector< ofTTFCharacter > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_ofPath_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_getStringAsPoints__SWIG_2(lua_State* L) { int SWIG_arg = 0; - ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; std::string *arg2 = 0 ; std::string temp2 ; - SwigValueWrapper< std::vector< ofPath > > result; SWIG_check_num_args("ofTrueTypeFont::getStringAsPoints",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::getStringAsPoints",1,"ofTrueTypeFont const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofTrueTypeFont::getStringAsPoints",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_getStringAsPoints",1,SWIGTYPE_p_ofTrueTypeFont); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = ((ofTrueTypeFont const *)arg1)->getStringAsPoints((std::string const &)*arg2); { - std::vector< ofTTFCharacter > * resultptr = new std::vector< ofTTFCharacter >((const std::vector< ofTTFCharacter > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_ofPath_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_getStringAsPoints(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTrueTypeFont, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { - return _wrap_TrueTypeFont_getStringAsPoints__SWIG_2(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTrueTypeFont, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - return _wrap_TrueTypeFont_getStringAsPoints__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTrueTypeFont, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - { _v = lua_isboolean(L,argv[3]); } if (_v) { return _wrap_TrueTypeFont_getStringAsPoints__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'TrueTypeFont_getStringAsPoints'\n" - " Possible C/C++ prototypes are:\n" " ofTrueTypeFont::getStringAsPoints(std::string const &,bool,bool) const\n" - " ofTrueTypeFont::getStringAsPoints(std::string const &,bool) const\n" - " ofTrueTypeFont::getStringAsPoints(std::string const &) const\n"); lua_error(L);return 0; } -static int _wrap_TrueTypeFont_getStringMesh__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; std::string *arg2 = 0 ; float arg3 ; float arg4 ; bool arg5 ; - std::string temp2 ; ofMesh *result = 0 ; SWIG_check_num_args("ofTrueTypeFont::getStringMesh",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::getStringMesh",1,"ofTrueTypeFont const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofTrueTypeFont::getStringMesh",2,"std::string const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTrueTypeFont::getStringMesh",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofTrueTypeFont::getStringMesh",4,"float"); - if(!lua_isboolean(L,5)) SWIG_fail_arg("ofTrueTypeFont::getStringMesh",5,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_getStringMesh",1,SWIGTYPE_p_ofTrueTypeFont); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; arg3 = (float)lua_tonumber(L, 3); - arg4 = (float)lua_tonumber(L, 4); arg5 = (lua_toboolean(L, 5)!=0); - result = (ofMesh *) &((ofTrueTypeFont const *)arg1)->getStringMesh((std::string const &)*arg2,arg3,arg4,arg5); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMesh,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_TrueTypeFont_getStringMesh__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; std::string *arg2 = 0 ; float arg3 ; float arg4 ; std::string temp2 ; - ofMesh *result = 0 ; SWIG_check_num_args("ofTrueTypeFont::getStringMesh",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::getStringMesh",1,"ofTrueTypeFont const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofTrueTypeFont::getStringMesh",2,"std::string const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTrueTypeFont::getStringMesh",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofTrueTypeFont::getStringMesh",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_getStringMesh",1,SWIGTYPE_p_ofTrueTypeFont); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; arg3 = (float)lua_tonumber(L, 3); - arg4 = (float)lua_tonumber(L, 4); - result = (ofMesh *) &((ofTrueTypeFont const *)arg1)->getStringMesh((std::string const &)*arg2,arg3,arg4); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMesh,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_TrueTypeFont_getStringMesh(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); - if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTrueTypeFont, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_TrueTypeFont_getStringMesh__SWIG_1(L);} } } } } - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTrueTypeFont, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isboolean(L,argv[4]); } if (_v) { - return _wrap_TrueTypeFont_getStringMesh__SWIG_0(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'TrueTypeFont_getStringMesh'\n" - " Possible C/C++ prototypes are:\n" " ofTrueTypeFont::getStringMesh(std::string const &,float,float,bool) const\n" - " ofTrueTypeFont::getStringMesh(std::string const &,float,float) const\n"); lua_error(L);return 0; } -static int _wrap_TrueTypeFont_getFontTexture(lua_State* L) { int SWIG_arg = 0; ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; - ofTexture *result = 0 ; SWIG_check_num_args("ofTrueTypeFont::getFontTexture",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::getFontTexture",1,"ofTrueTypeFont const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_getFontTexture",1,SWIGTYPE_p_ofTrueTypeFont); } - result = (ofTexture *) &((ofTrueTypeFont const *)arg1)->getFontTexture(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTexture,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static void swig_delete_TrueTypeFont(void *obj) { -ofTrueTypeFont *arg1 = (ofTrueTypeFont *) obj; -delete arg1; -} -static int _proxy__wrap_new_TrueTypeFont(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_TrueTypeFont); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_TrueTypeFont_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_TrueTypeFont_methods[]= { - { "load", _wrap_TrueTypeFont_load}, - { "isLoaded", _wrap_TrueTypeFont_isLoaded}, - { "isAntiAliased", _wrap_TrueTypeFont_isAntiAliased}, - { "hasFullCharacterSet", _wrap_TrueTypeFont_hasFullCharacterSet}, - { "getNumCharacters", _wrap_TrueTypeFont_getNumCharacters}, - { "getSize", _wrap_TrueTypeFont_getSize}, - { "getLineHeight", _wrap_TrueTypeFont_getLineHeight}, - { "setLineHeight", _wrap_TrueTypeFont_setLineHeight}, - { "getAscenderHeight", _wrap_TrueTypeFont_getAscenderHeight}, - { "getDescenderHeight", _wrap_TrueTypeFont_getDescenderHeight}, - { "getGlyphBBox", _wrap_TrueTypeFont_getGlyphBBox}, - { "getLetterSpacing", _wrap_TrueTypeFont_getLetterSpacing}, - { "setLetterSpacing", _wrap_TrueTypeFont_setLetterSpacing}, - { "getSpaceSize", _wrap_TrueTypeFont_getSpaceSize}, - { "setSpaceSize", _wrap_TrueTypeFont_setSpaceSize}, - { "stringWidth", _wrap_TrueTypeFont_stringWidth}, - { "stringHeight", _wrap_TrueTypeFont_stringHeight}, - { "getStringBoundingBox", _wrap_TrueTypeFont_getStringBoundingBox}, - { "drawString", _wrap_TrueTypeFont_drawString}, - { "drawStringAsShapes", _wrap_TrueTypeFont_drawStringAsShapes}, - { "getCharacterAsPoints", _wrap_TrueTypeFont_getCharacterAsPoints}, - { "getStringAsPoints", _wrap_TrueTypeFont_getStringAsPoints}, - { "getStringMesh", _wrap_TrueTypeFont_getStringMesh}, - { "getFontTexture", _wrap_TrueTypeFont_getFontTexture}, - {0,0} -}; -static swig_lua_method swig_TrueTypeFont_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_TrueTypeFont_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_TrueTypeFont_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_TrueTypeFont_Sf_SwigStatic_methods[]= { - { "setGlobalDpi", _wrap_TrueTypeFont_setGlobalDpi}, - {0,0} -}; -static swig_lua_class* swig_TrueTypeFont_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_TrueTypeFont_Sf_SwigStatic = { - "TrueTypeFont", - swig_TrueTypeFont_Sf_SwigStatic_methods, - swig_TrueTypeFont_Sf_SwigStatic_attributes, - swig_TrueTypeFont_Sf_SwigStatic_constants, - swig_TrueTypeFont_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_TrueTypeFont_bases[] = {0}; -static const char *swig_TrueTypeFont_base_names[] = {0}; -static swig_lua_class _wrap_class_TrueTypeFont = { "TrueTypeFont", "TrueTypeFont", &SWIGTYPE_p_ofTrueTypeFont,_proxy__wrap_new_TrueTypeFont, swig_delete_TrueTypeFont, swig_TrueTypeFont_methods, swig_TrueTypeFont_attributes, &swig_TrueTypeFont_Sf_SwigStatic, swig_TrueTypeFont_meta, swig_TrueTypeFont_bases, swig_TrueTypeFont_base_names }; - -static int _wrap_soundStreamSetup__SWIG_0(lua_State* L) { int SWIG_arg = 0; int arg1 ; int arg2 ; - ofBaseApp *arg3 = (ofBaseApp *) 0 ; SWIG_check_num_args("ofSoundStreamSetup",3,3) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSoundStreamSetup",1,"int"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSoundStreamSetup",2,"int"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofSoundStreamSetup",3,"ofBaseApp *"); arg1 = (int)lua_tonumber(L, 1); - arg2 = (int)lua_tonumber(L, 2); if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofBaseApp,0))){ - SWIG_fail_ptr("soundStreamSetup",3,SWIGTYPE_p_ofBaseApp); } ofSoundStreamSetup(arg1,arg2,arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_soundStreamSetup__SWIG_1(lua_State* L) { int SWIG_arg = 0; int arg1 ; int arg2 ; - SWIG_check_num_args("ofSoundStreamSetup",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSoundStreamSetup",1,"int"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSoundStreamSetup",2,"int"); arg1 = (int)lua_tonumber(L, 1); - arg2 = (int)lua_tonumber(L, 2); ofSoundStreamSetup(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_soundStreamSetup__SWIG_2(lua_State* L) { int SWIG_arg = 0; int arg1 ; int arg2 ; int arg3 ; int arg4 ; - int arg5 ; SWIG_check_num_args("ofSoundStreamSetup",5,5) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSoundStreamSetup",1,"int"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSoundStreamSetup",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofSoundStreamSetup",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofSoundStreamSetup",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofSoundStreamSetup",5,"int"); arg1 = (int)lua_tonumber(L, 1); - arg2 = (int)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - arg5 = (int)lua_tonumber(L, 5); ofSoundStreamSetup(arg1,arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_soundStreamSetup__SWIG_3(lua_State* L) { int SWIG_arg = 0; int arg1 ; int arg2 ; - ofBaseApp *arg3 = (ofBaseApp *) 0 ; int arg4 ; int arg5 ; int arg6 ; SWIG_check_num_args("ofSoundStreamSetup",6,6) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSoundStreamSetup",1,"int"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSoundStreamSetup",2,"int"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofSoundStreamSetup",3,"ofBaseApp *"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofSoundStreamSetup",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofSoundStreamSetup",5,"int"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofSoundStreamSetup",6,"int"); arg1 = (int)lua_tonumber(L, 1); - arg2 = (int)lua_tonumber(L, 2); if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofBaseApp,0))){ - SWIG_fail_ptr("soundStreamSetup",3,SWIGTYPE_p_ofBaseApp); } arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); - arg6 = (int)lua_tonumber(L, 6); ofSoundStreamSetup(arg1,arg2,arg3,arg4,arg5,arg6); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_soundStreamSetup(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_soundStreamSetup__SWIG_1(L);} } } if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { - { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofBaseApp, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_soundStreamSetup__SWIG_0(L);} } } } if (argc == 5) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_soundStreamSetup__SWIG_2(L);} } } } } } if (argc == 6) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofBaseApp, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } - if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { return _wrap_soundStreamSetup__SWIG_3(L);} } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'soundStreamSetup'\n" " Possible C/C++ prototypes are:\n" - " ofSoundStreamSetup(int,int,ofBaseApp *)\n" " ofSoundStreamSetup(int,int)\n" - " ofSoundStreamSetup(int,int,int,int,int)\n" " ofSoundStreamSetup(int,int,ofBaseApp *,int,int,int)\n"); - lua_error(L);return 0; } -static int _wrap_soundStreamStop(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofSoundStreamStop",0,0) - ofSoundStreamStop(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_soundStreamStart(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofSoundStreamStart",0,0) - ofSoundStreamStart(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_soundStreamClose(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofSoundStreamClose",0,0) - ofSoundStreamClose(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_soundStreamListDevices(lua_State* L) { int SWIG_arg = 0; - SwigValueWrapper< std::vector< ofSoundDevice > > result; SWIG_check_num_args("ofSoundStreamListDevices",0,0) - result = ofSoundStreamListDevices(); { - std::vector< ofSoundDevice > * resultptr = new std::vector< ofSoundDevice >((const std::vector< ofSoundDevice > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_ofSoundDevice_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_new_SoundStream(lua_State* L) { int SWIG_arg = 0; ofSoundStream *result = 0 ; - SWIG_check_num_args("ofSoundStream::ofSoundStream",0,0) result = (ofSoundStream *)new ofSoundStream(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofSoundStream,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_SoundStream_setSoundStream(lua_State* L) { int SWIG_arg = 0; ofSoundStream *arg1 = (ofSoundStream *) 0 ; - shared_ptr< ofBaseSoundStream > arg2 ; shared_ptr< ofBaseSoundStream > *argp2 ; - SWIG_check_num_args("ofSoundStream::setSoundStream",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStream::setSoundStream",1,"ofSoundStream *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofSoundStream::setSoundStream",2,"shared_ptr< ofBaseSoundStream >"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStream,0))){ - SWIG_fail_ptr("SoundStream_setSoundStream",1,SWIGTYPE_p_ofSoundStream); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_shared_ptrT_ofBaseSoundStream_t,0))){ - SWIG_fail_ptr("SoundStream_setSoundStream",2,SWIGTYPE_p_shared_ptrT_ofBaseSoundStream_t); } arg2 = *argp2; - (arg1)->setSoundStream(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundStream_getSoundStream(lua_State* L) { int SWIG_arg = 0; ofSoundStream *arg1 = (ofSoundStream *) 0 ; - shared_ptr< ofBaseSoundStream > result; SWIG_check_num_args("ofSoundStream::getSoundStream",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStream::getSoundStream",1,"ofSoundStream *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStream,0))){ - SWIG_fail_ptr("SoundStream_getSoundStream",1,SWIGTYPE_p_ofSoundStream); } result = (arg1)->getSoundStream(); { - shared_ptr< ofBaseSoundStream > * resultptr = new shared_ptr< ofBaseSoundStream >((const shared_ptr< ofBaseSoundStream > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_shared_ptrT_ofBaseSoundStream_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundStream_printDeviceList(lua_State* L) { int SWIG_arg = 0; ofSoundStream *arg1 = (ofSoundStream *) 0 ; - SWIG_check_num_args("ofSoundStream::printDeviceList",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStream::printDeviceList",1,"ofSoundStream const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStream,0))){ - SWIG_fail_ptr("SoundStream_printDeviceList",1,SWIGTYPE_p_ofSoundStream); } - ((ofSoundStream const *)arg1)->printDeviceList(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundStream_getDeviceList(lua_State* L) { int SWIG_arg = 0; ofSoundStream *arg1 = (ofSoundStream *) 0 ; - SwigValueWrapper< std::vector< ofSoundDevice > > result; SWIG_check_num_args("ofSoundStream::getDeviceList",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStream::getDeviceList",1,"ofSoundStream const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStream,0))){ - SWIG_fail_ptr("SoundStream_getDeviceList",1,SWIGTYPE_p_ofSoundStream); } - result = ((ofSoundStream const *)arg1)->getDeviceList(); { - std::vector< ofSoundDevice > * resultptr = new std::vector< ofSoundDevice >((const std::vector< ofSoundDevice > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_ofSoundDevice_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundStream_getMatchingDevices__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofSoundStream *arg1 = (ofSoundStream *) 0 ; std::string *arg2 = 0 ; unsigned int arg3 ; unsigned int arg4 ; - std::string temp2 ; SwigValueWrapper< std::vector< ofSoundDevice > > result; - SWIG_check_num_args("ofSoundStream::getMatchingDevices",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStream::getMatchingDevices",1,"ofSoundStream const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofSoundStream::getMatchingDevices",2,"std::string const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofSoundStream::getMatchingDevices",3,"unsigned int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofSoundStream::getMatchingDevices",4,"unsigned int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStream,0))){ - SWIG_fail_ptr("SoundStream_getMatchingDevices",1,SWIGTYPE_p_ofSoundStream); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (unsigned int)lua_tonumber(L, 3); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (unsigned int)lua_tonumber(L, 4); - result = ((ofSoundStream const *)arg1)->getMatchingDevices((std::string const &)*arg2,arg3,arg4); { - std::vector< ofSoundDevice > * resultptr = new std::vector< ofSoundDevice >((const std::vector< ofSoundDevice > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_ofSoundDevice_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundStream_getMatchingDevices__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofSoundStream *arg1 = (ofSoundStream *) 0 ; std::string *arg2 = 0 ; unsigned int arg3 ; std::string temp2 ; - SwigValueWrapper< std::vector< ofSoundDevice > > result; SWIG_check_num_args("ofSoundStream::getMatchingDevices",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStream::getMatchingDevices",1,"ofSoundStream const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofSoundStream::getMatchingDevices",2,"std::string const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofSoundStream::getMatchingDevices",3,"unsigned int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStream,0))){ - SWIG_fail_ptr("SoundStream_getMatchingDevices",1,SWIGTYPE_p_ofSoundStream); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (unsigned int)lua_tonumber(L, 3); - result = ((ofSoundStream const *)arg1)->getMatchingDevices((std::string const &)*arg2,arg3); { - std::vector< ofSoundDevice > * resultptr = new std::vector< ofSoundDevice >((const std::vector< ofSoundDevice > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_ofSoundDevice_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundStream_getMatchingDevices__SWIG_2(lua_State* L) { int SWIG_arg = 0; - ofSoundStream *arg1 = (ofSoundStream *) 0 ; std::string *arg2 = 0 ; std::string temp2 ; - SwigValueWrapper< std::vector< ofSoundDevice > > result; SWIG_check_num_args("ofSoundStream::getMatchingDevices",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStream::getMatchingDevices",1,"ofSoundStream const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofSoundStream::getMatchingDevices",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStream,0))){ - SWIG_fail_ptr("SoundStream_getMatchingDevices",1,SWIGTYPE_p_ofSoundStream); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = ((ofSoundStream const *)arg1)->getMatchingDevices((std::string const &)*arg2); { - std::vector< ofSoundDevice > * resultptr = new std::vector< ofSoundDevice >((const std::vector< ofSoundDevice > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_ofSoundDevice_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundStream_getMatchingDevices(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofSoundStream, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { - return _wrap_SoundStream_getMatchingDevices__SWIG_2(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofSoundStream, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_SoundStream_getMatchingDevices__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofSoundStream, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_SoundStream_getMatchingDevices__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SoundStream_getMatchingDevices'\n" - " Possible C/C++ prototypes are:\n" - " ofSoundStream::getMatchingDevices(std::string const &,unsigned int,unsigned int) const\n" - " ofSoundStream::getMatchingDevices(std::string const &,unsigned int) const\n" - " ofSoundStream::getMatchingDevices(std::string const &) const\n"); lua_error(L);return 0; } -static int _wrap_SoundStream_setDeviceID(lua_State* L) { int SWIG_arg = 0; ofSoundStream *arg1 = (ofSoundStream *) 0 ; - int arg2 ; SWIG_check_num_args("ofSoundStream::setDeviceID",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStream::setDeviceID",1,"ofSoundStream *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSoundStream::setDeviceID",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStream,0))){ - SWIG_fail_ptr("SoundStream_setDeviceID",1,SWIGTYPE_p_ofSoundStream); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->setDeviceID(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundStream_setDevice(lua_State* L) { int SWIG_arg = 0; ofSoundStream *arg1 = (ofSoundStream *) 0 ; - ofSoundDevice *arg2 = 0 ; SWIG_check_num_args("ofSoundStream::setDevice",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStream::setDevice",1,"ofSoundStream *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofSoundStream::setDevice",2,"ofSoundDevice const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStream,0))){ - SWIG_fail_ptr("SoundStream_setDevice",1,SWIGTYPE_p_ofSoundStream); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofSoundDevice,0))){ - SWIG_fail_ptr("SoundStream_setDevice",2,SWIGTYPE_p_ofSoundDevice); } (arg1)->setDevice((ofSoundDevice const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundStream_setup__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofSoundStream *arg1 = (ofSoundStream *) 0 ; - ofBaseApp *arg2 = (ofBaseApp *) 0 ; int arg3 ; int arg4 ; int arg5 ; int arg6 ; int arg7 ; bool result; - SWIG_check_num_args("ofSoundStream::setup",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStream::setup",1,"ofSoundStream *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofSoundStream::setup",2,"ofBaseApp *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofSoundStream::setup",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofSoundStream::setup",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofSoundStream::setup",5,"int"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofSoundStream::setup",6,"int"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofSoundStream::setup",7,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStream,0))){ - SWIG_fail_ptr("SoundStream_setup",1,SWIGTYPE_p_ofSoundStream); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBaseApp,0))){ - SWIG_fail_ptr("SoundStream_setup",2,SWIGTYPE_p_ofBaseApp); } arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); arg6 = (int)lua_tonumber(L, 6); - arg7 = (int)lua_tonumber(L, 7); result = (bool)(arg1)->setup(arg2,arg3,arg4,arg5,arg6,arg7); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundStream_setup__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofSoundStream *arg1 = (ofSoundStream *) 0 ; - int arg2 ; int arg3 ; int arg4 ; int arg5 ; int arg6 ; bool result; SWIG_check_num_args("ofSoundStream::setup",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStream::setup",1,"ofSoundStream *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSoundStream::setup",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofSoundStream::setup",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofSoundStream::setup",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofSoundStream::setup",5,"int"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofSoundStream::setup",6,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStream,0))){ - SWIG_fail_ptr("SoundStream_setup",1,SWIGTYPE_p_ofSoundStream); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); - arg6 = (int)lua_tonumber(L, 6); result = (bool)(arg1)->setup(arg2,arg3,arg4,arg5,arg6); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundStream_setup(lua_State* L) { int argc; int argv[8]={ 1,2,3,4,5,6,7,8} ; argc = lua_gettop(L); - if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofSoundStream, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { return _wrap_SoundStream_setup__SWIG_1(L);} } } } } } } - if (argc == 7) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofSoundStream, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBaseApp, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { { - _v = lua_isnumber(L,argv[6]); } if (_v) { return _wrap_SoundStream_setup__SWIG_0(L);} } } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SoundStream_setup'\n" " Possible C/C++ prototypes are:\n" - " ofSoundStream::setup(ofBaseApp *,int,int,int,int,int)\n" " ofSoundStream::setup(int,int,int,int,int)\n"); - lua_error(L);return 0; } -static int _wrap_SoundStream_setInput(lua_State* L) { int SWIG_arg = 0; ofSoundStream *arg1 = (ofSoundStream *) 0 ; - ofBaseSoundInput *arg2 = (ofBaseSoundInput *) 0 ; SWIG_check_num_args("ofSoundStream::setInput",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStream::setInput",1,"ofSoundStream *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofSoundStream::setInput",2,"ofBaseSoundInput *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStream,0))){ - SWIG_fail_ptr("SoundStream_setInput",1,SWIGTYPE_p_ofSoundStream); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBaseSoundInput,0))){ - SWIG_fail_ptr("SoundStream_setInput",2,SWIGTYPE_p_ofBaseSoundInput); } (arg1)->setInput(arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundStream_setOutput(lua_State* L) { int SWIG_arg = 0; ofSoundStream *arg1 = (ofSoundStream *) 0 ; - ofBaseSoundOutput *arg2 = (ofBaseSoundOutput *) 0 ; SWIG_check_num_args("ofSoundStream::setOutput",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStream::setOutput",1,"ofSoundStream *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofSoundStream::setOutput",2,"ofBaseSoundOutput *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStream,0))){ - SWIG_fail_ptr("SoundStream_setOutput",1,SWIGTYPE_p_ofSoundStream); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBaseSoundOutput,0))){ - SWIG_fail_ptr("SoundStream_setOutput",2,SWIGTYPE_p_ofBaseSoundOutput); } (arg1)->setOutput(arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundStream_start(lua_State* L) { int SWIG_arg = 0; ofSoundStream *arg1 = (ofSoundStream *) 0 ; - SWIG_check_num_args("ofSoundStream::start",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStream::start",1,"ofSoundStream *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStream,0))){ - SWIG_fail_ptr("SoundStream_start",1,SWIGTYPE_p_ofSoundStream); } (arg1)->start(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_SoundStream_stop(lua_State* L) { int SWIG_arg = 0; ofSoundStream *arg1 = (ofSoundStream *) 0 ; - SWIG_check_num_args("ofSoundStream::stop",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStream::stop",1,"ofSoundStream *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStream,0))){ - SWIG_fail_ptr("SoundStream_stop",1,SWIGTYPE_p_ofSoundStream); } (arg1)->stop(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_SoundStream_close(lua_State* L) { int SWIG_arg = 0; ofSoundStream *arg1 = (ofSoundStream *) 0 ; - SWIG_check_num_args("ofSoundStream::close",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStream::close",1,"ofSoundStream *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStream,0))){ - SWIG_fail_ptr("SoundStream_close",1,SWIGTYPE_p_ofSoundStream); } (arg1)->close(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_SoundStream_getTickCount(lua_State* L) { int SWIG_arg = 0; ofSoundStream *arg1 = (ofSoundStream *) 0 ; - unsigned long long result; SWIG_check_num_args("ofSoundStream::getTickCount",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStream::getTickCount",1,"ofSoundStream const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStream,0))){ - SWIG_fail_ptr("SoundStream_getTickCount",1,SWIGTYPE_p_ofSoundStream); } - result = (unsigned long long)((ofSoundStream const *)arg1)->getTickCount(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundStream_getNumInputChannels(lua_State* L) { int SWIG_arg = 0; ofSoundStream *arg1 = (ofSoundStream *) 0 ; - int result; SWIG_check_num_args("ofSoundStream::getNumInputChannels",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStream::getNumInputChannels",1,"ofSoundStream const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStream,0))){ - SWIG_fail_ptr("SoundStream_getNumInputChannels",1,SWIGTYPE_p_ofSoundStream); } - result = (int)((ofSoundStream const *)arg1)->getNumInputChannels(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundStream_getNumOutputChannels(lua_State* L) { int SWIG_arg = 0; ofSoundStream *arg1 = (ofSoundStream *) 0 ; - int result; SWIG_check_num_args("ofSoundStream::getNumOutputChannels",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStream::getNumOutputChannels",1,"ofSoundStream const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStream,0))){ - SWIG_fail_ptr("SoundStream_getNumOutputChannels",1,SWIGTYPE_p_ofSoundStream); } - result = (int)((ofSoundStream const *)arg1)->getNumOutputChannels(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundStream_getSampleRate(lua_State* L) { int SWIG_arg = 0; ofSoundStream *arg1 = (ofSoundStream *) 0 ; - int result; SWIG_check_num_args("ofSoundStream::getSampleRate",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStream::getSampleRate",1,"ofSoundStream const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStream,0))){ - SWIG_fail_ptr("SoundStream_getSampleRate",1,SWIGTYPE_p_ofSoundStream); } - result = (int)((ofSoundStream const *)arg1)->getSampleRate(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundStream_getBufferSize(lua_State* L) { int SWIG_arg = 0; ofSoundStream *arg1 = (ofSoundStream *) 0 ; - int result; SWIG_check_num_args("ofSoundStream::getBufferSize",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStream::getBufferSize",1,"ofSoundStream const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStream,0))){ - SWIG_fail_ptr("SoundStream_getBufferSize",1,SWIGTYPE_p_ofSoundStream); } - result = (int)((ofSoundStream const *)arg1)->getBufferSize(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_SoundStream(void *obj) { -ofSoundStream *arg1 = (ofSoundStream *) obj; -delete arg1; -} -static int _proxy__wrap_new_SoundStream(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_SoundStream); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_SoundStream_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_SoundStream_methods[]= { - { "setSoundStream", _wrap_SoundStream_setSoundStream}, - { "getSoundStream", _wrap_SoundStream_getSoundStream}, - { "printDeviceList", _wrap_SoundStream_printDeviceList}, - { "getDeviceList", _wrap_SoundStream_getDeviceList}, - { "getMatchingDevices", _wrap_SoundStream_getMatchingDevices}, - { "setDeviceID", _wrap_SoundStream_setDeviceID}, - { "setDevice", _wrap_SoundStream_setDevice}, - { "setup", _wrap_SoundStream_setup}, - { "setInput", _wrap_SoundStream_setInput}, - { "setOutput", _wrap_SoundStream_setOutput}, - { "start", _wrap_SoundStream_start}, - { "stop", _wrap_SoundStream_stop}, - { "close", _wrap_SoundStream_close}, - { "getTickCount", _wrap_SoundStream_getTickCount}, - { "getNumInputChannels", _wrap_SoundStream_getNumInputChannels}, - { "getNumOutputChannels", _wrap_SoundStream_getNumOutputChannels}, - { "getSampleRate", _wrap_SoundStream_getSampleRate}, - { "getBufferSize", _wrap_SoundStream_getBufferSize}, - {0,0} -}; -static swig_lua_method swig_SoundStream_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_SoundStream_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_SoundStream_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_SoundStream_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_SoundStream_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_SoundStream_Sf_SwigStatic = { - "SoundStream", - swig_SoundStream_Sf_SwigStatic_methods, - swig_SoundStream_Sf_SwigStatic_attributes, - swig_SoundStream_Sf_SwigStatic_constants, - swig_SoundStream_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_SoundStream_bases[] = {0}; -static const char *swig_SoundStream_base_names[] = {0}; -static swig_lua_class _wrap_class_SoundStream = { "SoundStream", "SoundStream", &SWIGTYPE_p_ofSoundStream,_proxy__wrap_new_SoundStream, swig_delete_SoundStream, swig_SoundStream_methods, swig_SoundStream_attributes, &swig_SoundStream_Sf_SwigStatic, swig_SoundStream_meta, swig_SoundStream_bases, swig_SoundStream_base_names }; - -static int _wrap_new_SoundPlayer(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *result = 0 ; - SWIG_check_num_args("ofSoundPlayer::ofSoundPlayer",0,0) result = (ofSoundPlayer *)new ofSoundPlayer(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofSoundPlayer,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_SoundPlayer_setPlayer(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; - SwigValueWrapper< shared_ptr< ofBaseSoundPlayer > > arg2 ; shared_ptr< ofBaseSoundPlayer > *argp2 ; - SWIG_check_num_args("ofSoundPlayer::setPlayer",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::setPlayer",1,"ofSoundPlayer *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofSoundPlayer::setPlayer",2,"shared_ptr< ofBaseSoundPlayer >"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_setPlayer",1,SWIGTYPE_p_ofSoundPlayer); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_shared_ptrT_ofBaseSoundPlayer_t,0))){ - SWIG_fail_ptr("SoundPlayer_setPlayer",2,SWIGTYPE_p_shared_ptrT_ofBaseSoundPlayer_t); } arg2 = *argp2; - (arg1)->setPlayer(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundPlayer_getPlayer(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; - SwigValueWrapper< shared_ptr< ofBaseSoundPlayer > > result; SWIG_check_num_args("ofSoundPlayer::getPlayer",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::getPlayer",1,"ofSoundPlayer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_getPlayer",1,SWIGTYPE_p_ofSoundPlayer); } result = (arg1)->getPlayer(); { - shared_ptr< ofBaseSoundPlayer > * resultptr = new shared_ptr< ofBaseSoundPlayer >((const shared_ptr< ofBaseSoundPlayer > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_shared_ptrT_ofBaseSoundPlayer_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundPlayer_load__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; - std::string arg2 ; bool arg3 ; bool result; SWIG_check_num_args("ofSoundPlayer::load",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::load",1,"ofSoundPlayer *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofSoundPlayer::load",2,"std::string"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofSoundPlayer::load",3,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_load",1,SWIGTYPE_p_ofSoundPlayer); } (&arg2)->assign(lua_tostring(L,2),lua_rawlen(L,2)); - arg3 = (lua_toboolean(L, 3)!=0); result = (bool)(arg1)->load(arg2,arg3); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundPlayer_load__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; - std::string arg2 ; bool result; SWIG_check_num_args("ofSoundPlayer::load",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::load",1,"ofSoundPlayer *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofSoundPlayer::load",2,"std::string"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_load",1,SWIGTYPE_p_ofSoundPlayer); } (&arg2)->assign(lua_tostring(L,2),lua_rawlen(L,2)); - result = (bool)(arg1)->load(arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_SoundPlayer_load(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofSoundPlayer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { return _wrap_SoundPlayer_load__SWIG_1(L);} } - } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofSoundPlayer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - return _wrap_SoundPlayer_load__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SoundPlayer_load'\n" " Possible C/C++ prototypes are:\n" - " ofSoundPlayer::load(std::string,bool)\n" " ofSoundPlayer::load(std::string)\n"); lua_error(L);return 0; } -static int _wrap_SoundPlayer_unload(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; - SWIG_check_num_args("ofSoundPlayer::unload",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::unload",1,"ofSoundPlayer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_unload",1,SWIGTYPE_p_ofSoundPlayer); } (arg1)->unload(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_SoundPlayer_play(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; - SWIG_check_num_args("ofSoundPlayer::play",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::play",1,"ofSoundPlayer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_play",1,SWIGTYPE_p_ofSoundPlayer); } (arg1)->play(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_SoundPlayer_stop(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; - SWIG_check_num_args("ofSoundPlayer::stop",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::stop",1,"ofSoundPlayer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_stop",1,SWIGTYPE_p_ofSoundPlayer); } (arg1)->stop(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_SoundPlayer_setVolume(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; - float arg2 ; SWIG_check_num_args("ofSoundPlayer::setVolume",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::setVolume",1,"ofSoundPlayer *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSoundPlayer::setVolume",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_setVolume",1,SWIGTYPE_p_ofSoundPlayer); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setVolume(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundPlayer_setPan(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; float arg2 ; - SWIG_check_num_args("ofSoundPlayer::setPan",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::setPan",1,"ofSoundPlayer *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSoundPlayer::setPan",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_setPan",1,SWIGTYPE_p_ofSoundPlayer); } arg2 = (float)lua_tonumber(L, 2); (arg1)->setPan(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundPlayer_setSpeed(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; float arg2 ; - SWIG_check_num_args("ofSoundPlayer::setSpeed",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::setSpeed",1,"ofSoundPlayer *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSoundPlayer::setSpeed",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_setSpeed",1,SWIGTYPE_p_ofSoundPlayer); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setSpeed(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundPlayer_setPaused(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; bool arg2 ; - SWIG_check_num_args("ofSoundPlayer::setPaused",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::setPaused",1,"ofSoundPlayer *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofSoundPlayer::setPaused",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_setPaused",1,SWIGTYPE_p_ofSoundPlayer); } arg2 = (lua_toboolean(L, 2)!=0); - (arg1)->setPaused(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundPlayer_setLoop(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; bool arg2 ; - SWIG_check_num_args("ofSoundPlayer::setLoop",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::setLoop",1,"ofSoundPlayer *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofSoundPlayer::setLoop",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_setLoop",1,SWIGTYPE_p_ofSoundPlayer); } arg2 = (lua_toboolean(L, 2)!=0); (arg1)->setLoop(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundPlayer_setMultiPlay(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; - bool arg2 ; SWIG_check_num_args("ofSoundPlayer::setMultiPlay",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::setMultiPlay",1,"ofSoundPlayer *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofSoundPlayer::setMultiPlay",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_setMultiPlay",1,SWIGTYPE_p_ofSoundPlayer); } arg2 = (lua_toboolean(L, 2)!=0); - (arg1)->setMultiPlay(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundPlayer_setPosition(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; - float arg2 ; SWIG_check_num_args("ofSoundPlayer::setPosition",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::setPosition",1,"ofSoundPlayer *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSoundPlayer::setPosition",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_setPosition",1,SWIGTYPE_p_ofSoundPlayer); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setPosition(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundPlayer_setPositionMS(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; - int arg2 ; SWIG_check_num_args("ofSoundPlayer::setPositionMS",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::setPositionMS",1,"ofSoundPlayer *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSoundPlayer::setPositionMS",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_setPositionMS",1,SWIGTYPE_p_ofSoundPlayer); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->setPositionMS(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundPlayer_getPositionMS(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; - int result; SWIG_check_num_args("ofSoundPlayer::getPositionMS",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::getPositionMS",1,"ofSoundPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_getPositionMS",1,SWIGTYPE_p_ofSoundPlayer); } - result = (int)((ofSoundPlayer const *)arg1)->getPositionMS(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundPlayer_getPosition(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; - float result; SWIG_check_num_args("ofSoundPlayer::getPosition",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::getPosition",1,"ofSoundPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_getPosition",1,SWIGTYPE_p_ofSoundPlayer); } - result = (float)((ofSoundPlayer const *)arg1)->getPosition(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundPlayer_isPlaying(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; - bool result; SWIG_check_num_args("ofSoundPlayer::isPlaying",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::isPlaying",1,"ofSoundPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_isPlaying",1,SWIGTYPE_p_ofSoundPlayer); } - result = (bool)((ofSoundPlayer const *)arg1)->isPlaying(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundPlayer_getSpeed(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; - float result; SWIG_check_num_args("ofSoundPlayer::getSpeed",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::getSpeed",1,"ofSoundPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_getSpeed",1,SWIGTYPE_p_ofSoundPlayer); } - result = (float)((ofSoundPlayer const *)arg1)->getSpeed(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundPlayer_getPan(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; float result; - SWIG_check_num_args("ofSoundPlayer::getPan",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::getPan",1,"ofSoundPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_getPan",1,SWIGTYPE_p_ofSoundPlayer); } result = (float)((ofSoundPlayer const *)arg1)->getPan(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundPlayer_getVolume(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; - float result; SWIG_check_num_args("ofSoundPlayer::getVolume",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::getVolume",1,"ofSoundPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_getVolume",1,SWIGTYPE_p_ofSoundPlayer); } - result = (float)((ofSoundPlayer const *)arg1)->getVolume(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundPlayer_isLoaded(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; bool result; - SWIG_check_num_args("ofSoundPlayer::isLoaded",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::isLoaded",1,"ofSoundPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_isLoaded",1,SWIGTYPE_p_ofSoundPlayer); } - result = (bool)((ofSoundPlayer const *)arg1)->isLoaded(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_SoundPlayer(void *obj) { -ofSoundPlayer *arg1 = (ofSoundPlayer *) obj; -delete arg1; -} -static int _proxy__wrap_new_SoundPlayer(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_SoundPlayer); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_SoundPlayer_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_SoundPlayer_methods[]= { - { "setPlayer", _wrap_SoundPlayer_setPlayer}, - { "getPlayer", _wrap_SoundPlayer_getPlayer}, - { "load", _wrap_SoundPlayer_load}, - { "unload", _wrap_SoundPlayer_unload}, - { "play", _wrap_SoundPlayer_play}, - { "stop", _wrap_SoundPlayer_stop}, - { "setVolume", _wrap_SoundPlayer_setVolume}, - { "setPan", _wrap_SoundPlayer_setPan}, - { "setSpeed", _wrap_SoundPlayer_setSpeed}, - { "setPaused", _wrap_SoundPlayer_setPaused}, - { "setLoop", _wrap_SoundPlayer_setLoop}, - { "setMultiPlay", _wrap_SoundPlayer_setMultiPlay}, - { "setPosition", _wrap_SoundPlayer_setPosition}, - { "setPositionMS", _wrap_SoundPlayer_setPositionMS}, - { "getPositionMS", _wrap_SoundPlayer_getPositionMS}, - { "getPosition", _wrap_SoundPlayer_getPosition}, - { "isPlaying", _wrap_SoundPlayer_isPlaying}, - { "getSpeed", _wrap_SoundPlayer_getSpeed}, - { "getPan", _wrap_SoundPlayer_getPan}, - { "getVolume", _wrap_SoundPlayer_getVolume}, - { "isLoaded", _wrap_SoundPlayer_isLoaded}, - {0,0} -}; -static swig_lua_method swig_SoundPlayer_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_SoundPlayer_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_SoundPlayer_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_SoundPlayer_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_SoundPlayer_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_SoundPlayer_Sf_SwigStatic = { - "SoundPlayer", - swig_SoundPlayer_Sf_SwigStatic_methods, - swig_SoundPlayer_Sf_SwigStatic_attributes, - swig_SoundPlayer_Sf_SwigStatic_constants, - swig_SoundPlayer_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_SoundPlayer_bases[] = {0}; -static const char *swig_SoundPlayer_base_names[] = {0}; -static swig_lua_class _wrap_class_SoundPlayer = { "SoundPlayer", "SoundPlayer", &SWIGTYPE_p_ofSoundPlayer,_proxy__wrap_new_SoundPlayer, swig_delete_SoundPlayer, swig_SoundPlayer_methods, swig_SoundPlayer_attributes, &swig_SoundPlayer_Sf_SwigStatic, swig_SoundPlayer_meta, swig_SoundPlayer_bases, swig_SoundPlayer_base_names }; - -static int _wrap_new_Color__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::ofColor_",0,0) - result = (ofColor_< unsigned char > *)new ofColor_< unsigned char >(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_Color__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - ofColor_< unsigned char > *result = 0 ; SWIG_check_num_args("ofColor_< unsigned char >::ofColor_",4,4) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::ofColor_",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::ofColor_",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< unsigned char >::ofColor_",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofColor_< unsigned char >::ofColor_",4,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - result = (ofColor_< unsigned char > *)new ofColor_< unsigned char >(arg1,arg2,arg3,arg4); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_Color__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; - ofColor_< unsigned char > *result = 0 ; SWIG_check_num_args("ofColor_< unsigned char >::ofColor_",3,3) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::ofColor_",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::ofColor_",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< unsigned char >::ofColor_",3,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - result = (ofColor_< unsigned char > *)new ofColor_< unsigned char >(arg1,arg2,arg3); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_Color__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; - ofColor_< unsigned char > *result = 0 ; SWIG_check_num_args("ofColor_< unsigned char >::ofColor_",2,2) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::ofColor_",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::ofColor_",2,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); result = (ofColor_< unsigned char > *)new ofColor_< unsigned char >(arg1,arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_Color__SWIG_4(lua_State* L) { int SWIG_arg = 0; float arg1 ; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::ofColor_",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::ofColor_",1,"float"); arg1 = (float)lua_tonumber(L, 1); - result = (ofColor_< unsigned char > *)new ofColor_< unsigned char >(arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_Color__SWIG_5(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *arg1 = 0 ; float arg2 ; - ofColor_< unsigned char > *result = 0 ; SWIG_check_num_args("ofColor_< unsigned char >::ofColor_",2,2) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::ofColor_",1,"ofColor_< unsigned char > const &"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::ofColor_",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("new_Color",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } arg2 = (float)lua_tonumber(L, 2); - result = (ofColor_< unsigned char > *)new ofColor_< unsigned char >((ofColor_< unsigned char > const &)*arg1,arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_Color(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_Color__SWIG_0(L);} if (argc == 1) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { - return _wrap_new_Color__SWIG_4(L);} } if (argc == 2) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_new_Color__SWIG_5(L);} } } if (argc == 2) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_new_Color__SWIG_3(L);} } } if (argc == 3) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_new_Color__SWIG_2(L);} } } } if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_new_Color__SWIG_1(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_Color'\n" " Possible C/C++ prototypes are:\n" - " ofColor_< unsigned char >::ofColor_()\n" " ofColor_< unsigned char >::ofColor_(float,float,float,float)\n" - " ofColor_< unsigned char >::ofColor_(float,float,float)\n" " ofColor_< unsigned char >::ofColor_(float,float)\n" - " ofColor_< unsigned char >::ofColor_(float)\n" - " ofColor_< unsigned char >::ofColor_(ofColor_< unsigned char > const &,float)\n"); lua_error(L);return 0; } -static int _wrap_Color_fromHsb__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - ofColor_< unsigned char > result; SWIG_check_num_args("ofColor_< unsigned char >::fromHsb",4,4) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::fromHsb",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::fromHsb",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< unsigned char >::fromHsb",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofColor_< unsigned char >::fromHsb",4,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - result = ofColor_< unsigned char >::SWIGTEMPLATEDISAMBIGUATOR fromHsb(arg1,arg2,arg3,arg4); { - ofColor_< unsigned char > * resultptr = new ofColor_< unsigned char >((const ofColor_< unsigned char > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_fromHsb__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; - ofColor_< unsigned char > result; SWIG_check_num_args("ofColor_< unsigned char >::fromHsb",3,3) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::fromHsb",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::fromHsb",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< unsigned char >::fromHsb",3,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - result = ofColor_< unsigned char >::SWIGTEMPLATEDISAMBIGUATOR fromHsb(arg1,arg2,arg3); { - ofColor_< unsigned char > * resultptr = new ofColor_< unsigned char >((const ofColor_< unsigned char > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_fromHsb(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Color_fromHsb__SWIG_1(L);} } } } if (argc == 4) { int _v; - { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Color_fromHsb__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Color_fromHsb'\n" " Possible C/C++ prototypes are:\n" - " ofColor_< unsigned char >::fromHsb(float,float,float,float)\n" - " ofColor_< unsigned char >::fromHsb(float,float,float)\n"); lua_error(L);return 0; } -static int _wrap_Color_fromHex__SWIG_0(lua_State* L) { int SWIG_arg = 0; int arg1 ; float arg2 ; - ofColor_< unsigned char > result; SWIG_check_num_args("ofColor_< unsigned char >::fromHex",2,2) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::fromHex",1,"int"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::fromHex",2,"float"); arg1 = (int)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); result = ofColor_< unsigned char >::SWIGTEMPLATEDISAMBIGUATOR fromHex(arg1,arg2); { - ofColor_< unsigned char > * resultptr = new ofColor_< unsigned char >((const ofColor_< unsigned char > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_fromHex__SWIG_1(lua_State* L) { int SWIG_arg = 0; int arg1 ; ofColor_< unsigned char > result; - SWIG_check_num_args("ofColor_< unsigned char >::fromHex",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::fromHex",1,"int"); arg1 = (int)lua_tonumber(L, 1); - result = ofColor_< unsigned char >::SWIGTEMPLATEDISAMBIGUATOR fromHex(arg1); { - ofColor_< unsigned char > * resultptr = new ofColor_< unsigned char >((const ofColor_< unsigned char > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_fromHex(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_Color_fromHex__SWIG_1(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Color_fromHex__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Color_fromHex'\n" " Possible C/C++ prototypes are:\n" - " ofColor_< unsigned char >::fromHex(int,float)\n" " ofColor_< unsigned char >::fromHex(int)\n"); - lua_error(L);return 0; } -static int _wrap_Color_set__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; float arg2 ; float arg3 ; float arg4 ; float arg5 ; - SWIG_check_num_args("ofColor_< unsigned char >::set",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::set",1,"ofColor_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< unsigned char >::set",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofColor_< unsigned char >::set",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofColor_< unsigned char >::set",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_set",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - (arg1)->set(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_set__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; float arg2 ; float arg3 ; float arg4 ; - SWIG_check_num_args("ofColor_< unsigned char >::set",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::set",1,"ofColor_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< unsigned char >::set",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofColor_< unsigned char >::set",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_set",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); (arg1)->set(arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_set__SWIG_2(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofColor_< unsigned char >::set",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::set",1,"ofColor_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< unsigned char >::set",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_set",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->set(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Color_set__SWIG_3(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; float arg2 ; - SWIG_check_num_args("ofColor_< unsigned char >::set",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::set",1,"ofColor_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::set",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_set",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } arg2 = (float)lua_tonumber(L, 2); (arg1)->set(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_set__SWIG_4(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; ofColor_< unsigned char > *arg2 = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::set",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::set",1,"ofColor_< unsigned char > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::set",2,"ofColor_< unsigned char > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_set",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_set",2,SWIGTYPE_p_ofColor_T_unsigned_char_t); } (arg1)->set((ofColor_< unsigned char > const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_set(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 2) { int _v; - { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Color_set__SWIG_4(L);} } } if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Color_set__SWIG_3(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_Color_set__SWIG_2(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Color_set__SWIG_1(L);} } } } } - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Color_set__SWIG_0(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Color_set'\n" " Possible C/C++ prototypes are:\n" - " ofColor_< unsigned char >::set(float,float,float,float)\n" " ofColor_< unsigned char >::set(float,float,float)\n" - " ofColor_< unsigned char >::set(float,float)\n" " ofColor_< unsigned char >::set(float)\n" - " ofColor_< unsigned char >::set(ofColor_< unsigned char > const &)\n"); lua_error(L);return 0; } -static int _wrap_Color_setHex__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; int arg2 ; float arg3 ; - SWIG_check_num_args("ofColor_< unsigned char >::setHex",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::setHex",1,"ofColor_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::setHex",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< unsigned char >::setHex",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_setHex",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->setHex(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Color_setHex__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; int arg2 ; - SWIG_check_num_args("ofColor_< unsigned char >::setHex",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::setHex",1,"ofColor_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::setHex",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_setHex",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->setHex(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_setHex(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { int _v; - { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Color_setHex__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_Color_setHex__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Color_setHex'\n" " Possible C/C++ prototypes are:\n" - " ofColor_< unsigned char >::setHex(int,float)\n" " ofColor_< unsigned char >::setHex(int)\n"); lua_error(L);return 0; } -static int _wrap_Color_setHue(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; float arg2 ; - SWIG_check_num_args("ofColor_< unsigned char >::setHue",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::setHue",1,"ofColor_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::setHue",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_setHue",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setHue(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_setHueAngle(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; float arg2 ; - SWIG_check_num_args("ofColor_< unsigned char >::setHueAngle",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::setHueAngle",1,"ofColor_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::setHueAngle",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_setHueAngle",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setHueAngle(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_setSaturation(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; float arg2 ; - SWIG_check_num_args("ofColor_< unsigned char >::setSaturation",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::setSaturation",1,"ofColor_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::setSaturation",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_setSaturation",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setSaturation(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_setBrightness(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; float arg2 ; - SWIG_check_num_args("ofColor_< unsigned char >::setBrightness",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::setBrightness",1,"ofColor_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::setBrightness",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_setBrightness",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setBrightness(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_setHsb__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; float arg2 ; float arg3 ; float arg4 ; float arg5 ; - SWIG_check_num_args("ofColor_< unsigned char >::setHsb",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::setHsb",1,"ofColor_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::setHsb",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< unsigned char >::setHsb",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofColor_< unsigned char >::setHsb",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofColor_< unsigned char >::setHsb",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_setHsb",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - (arg1)->setHsb(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_setHsb__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; float arg2 ; float arg3 ; float arg4 ; - SWIG_check_num_args("ofColor_< unsigned char >::setHsb",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::setHsb",1,"ofColor_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::setHsb",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< unsigned char >::setHsb",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofColor_< unsigned char >::setHsb",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_setHsb",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); (arg1)->setHsb(arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_setHsb(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 4) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Color_setHsb__SWIG_1(L);} } } } } - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Color_setHsb__SWIG_0(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Color_setHsb'\n" " Possible C/C++ prototypes are:\n" - " ofColor_< unsigned char >::setHsb(float,float,float,float)\n" - " ofColor_< unsigned char >::setHsb(float,float,float)\n"); lua_error(L);return 0; } -static int _wrap_Color_clamp(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::clamp",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::clamp",1,"ofColor_< unsigned char > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_clamp",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - result = (ofColor_< unsigned char > *) &(arg1)->clamp(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_invert(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::invert",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::invert",1,"ofColor_< unsigned char > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_invert",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - result = (ofColor_< unsigned char > *) &(arg1)->invert(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_normalize(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::normalize",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::normalize",1,"ofColor_< unsigned char > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_normalize",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - result = (ofColor_< unsigned char > *) &(arg1)->normalize(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_lerp(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; ofColor_< unsigned char > *arg2 = 0 ; float arg3 ; - ofColor_< unsigned char > *result = 0 ; SWIG_check_num_args("ofColor_< unsigned char >::lerp",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::lerp",1,"ofColor_< unsigned char > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::lerp",2,"ofColor_< unsigned char > const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< unsigned char >::lerp",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_lerp",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_lerp",2,SWIGTYPE_p_ofColor_T_unsigned_char_t); } arg3 = (float)lua_tonumber(L, 3); - result = (ofColor_< unsigned char > *) &(arg1)->lerp((ofColor_< unsigned char > const &)*arg2,arg3); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_getClamped(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; ofColor_< unsigned char > result; - SWIG_check_num_args("ofColor_< unsigned char >::getClamped",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::getClamped",1,"ofColor_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_getClamped",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - result = ((ofColor_< unsigned char > const *)arg1)->getClamped(); { - ofColor_< unsigned char > * resultptr = new ofColor_< unsigned char >((const ofColor_< unsigned char > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_getInverted(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; ofColor_< unsigned char > result; - SWIG_check_num_args("ofColor_< unsigned char >::getInverted",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::getInverted",1,"ofColor_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_getInverted",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - result = ((ofColor_< unsigned char > const *)arg1)->getInverted(); { - ofColor_< unsigned char > * resultptr = new ofColor_< unsigned char >((const ofColor_< unsigned char > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_getNormalized(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; ofColor_< unsigned char > result; - SWIG_check_num_args("ofColor_< unsigned char >::getNormalized",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::getNormalized",1,"ofColor_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_getNormalized",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - result = ((ofColor_< unsigned char > const *)arg1)->getNormalized(); { - ofColor_< unsigned char > * resultptr = new ofColor_< unsigned char >((const ofColor_< unsigned char > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_getLerped(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; ofColor_< unsigned char > *arg2 = 0 ; float arg3 ; - ofColor_< unsigned char > result; SWIG_check_num_args("ofColor_< unsigned char >::getLerped",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::getLerped",1,"ofColor_< unsigned char > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::getLerped",2,"ofColor_< unsigned char > const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< unsigned char >::getLerped",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_getLerped",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_getLerped",2,SWIGTYPE_p_ofColor_T_unsigned_char_t); } arg3 = (float)lua_tonumber(L, 3); - result = ((ofColor_< unsigned char > const *)arg1)->getLerped((ofColor_< unsigned char > const &)*arg2,arg3); { - ofColor_< unsigned char > * resultptr = new ofColor_< unsigned char >((const ofColor_< unsigned char > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_getHex(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; int result; - SWIG_check_num_args("ofColor_< unsigned char >::getHex",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::getHex",1,"ofColor_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_getHex",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - result = (int)((ofColor_< unsigned char > const *)arg1)->getHex(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_getHue(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; float result; - SWIG_check_num_args("ofColor_< unsigned char >::getHue",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::getHue",1,"ofColor_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_getHue",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - result = (float)((ofColor_< unsigned char > const *)arg1)->getHue(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_getHueAngle(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; float result; - SWIG_check_num_args("ofColor_< unsigned char >::getHueAngle",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::getHueAngle",1,"ofColor_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_getHueAngle",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - result = (float)((ofColor_< unsigned char > const *)arg1)->getHueAngle(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_getSaturation(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; float result; - SWIG_check_num_args("ofColor_< unsigned char >::getSaturation",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::getSaturation",1,"ofColor_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_getSaturation",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - result = (float)((ofColor_< unsigned char > const *)arg1)->getSaturation(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_getBrightness(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; float result; - SWIG_check_num_args("ofColor_< unsigned char >::getBrightness",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::getBrightness",1,"ofColor_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_getBrightness",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - result = (float)((ofColor_< unsigned char > const *)arg1)->getBrightness(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_getLightness(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; float result; - SWIG_check_num_args("ofColor_< unsigned char >::getLightness",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::getLightness",1,"ofColor_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_getLightness",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - result = (float)((ofColor_< unsigned char > const *)arg1)->getLightness(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_getHsb(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; float *arg2 = 0 ; float *arg3 = 0 ; float *arg4 = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::getHsb",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::getHsb",1,"ofColor_< unsigned char > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::getHsb",2,"float &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofColor_< unsigned char >::getHsb",3,"float &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofColor_< unsigned char >::getHsb",4,"float &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_getHsb",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_float,0))){ SWIG_fail_ptr("Color_getHsb",2,SWIGTYPE_p_float); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_float,0))){ SWIG_fail_ptr("Color_getHsb",3,SWIGTYPE_p_float); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_float,0))){ SWIG_fail_ptr("Color_getHsb",4,SWIGTYPE_p_float); } - ((ofColor_< unsigned char > const *)arg1)->getHsb(*arg2,*arg3,*arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Color_limit(lua_State* L) { int SWIG_arg = 0; float result; - SWIG_check_num_args("ofColor_< unsigned char >::limit",0,0) - result = (float)ofColor_< unsigned char >::SWIGTEMPLATEDISAMBIGUATOR limit(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color___eq(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; ofColor_< unsigned char > *arg2 = 0 ; bool result; - SWIG_check_num_args("ofColor_< unsigned char >::operator ==",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::operator ==",1,"ofColor_< unsigned char > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::operator ==",2,"ofColor_< unsigned char > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color___eq",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color___eq",2,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - result = (bool)((ofColor_< unsigned char > const *)arg1)->operator ==((ofColor_< unsigned char > const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color___add__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; ofColor_< unsigned char > *arg2 = 0 ; - ofColor_< unsigned char > result; SWIG_check_num_args("ofColor_< unsigned char >::operator +",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::operator +",1,"ofColor_< unsigned char > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::operator +",2,"ofColor_< unsigned char > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color___add",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color___add",2,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - result = ((ofColor_< unsigned char > const *)arg1)->operator +((ofColor_< unsigned char > const &)*arg2); { - ofColor_< unsigned char > * resultptr = new ofColor_< unsigned char >((const ofColor_< unsigned char > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color___add__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; float *arg2 = 0 ; float temp2 ; - ofColor_< unsigned char > result; SWIG_check_num_args("ofColor_< unsigned char >::operator +",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::operator +",1,"ofColor_< unsigned char > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::operator +",2,"float const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color___add",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } temp2=(float)lua_tonumber(L,2); arg2=&temp2; - result = ((ofColor_< unsigned char > const *)arg1)->operator +((float const &)*arg2); { - ofColor_< unsigned char > * resultptr = new ofColor_< unsigned char >((const ofColor_< unsigned char > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color___add(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Color___add__SWIG_0(L);} } } if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Color___add__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Color___add'\n" " Possible C/C++ prototypes are:\n" - " ofColor_< unsigned char >::operator +(ofColor_< unsigned char > const &) const\n" - " ofColor_< unsigned char >::operator +(float const &) const\n"); lua_error(L);return 0; } -static int _wrap_Color___sub__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; ofColor_< unsigned char > *arg2 = 0 ; - ofColor_< unsigned char > result; SWIG_check_num_args("ofColor_< unsigned char >::operator -",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::operator -",1,"ofColor_< unsigned char > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::operator -",2,"ofColor_< unsigned char > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color___sub",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color___sub",2,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - result = ((ofColor_< unsigned char > const *)arg1)->operator -((ofColor_< unsigned char > const &)*arg2); { - ofColor_< unsigned char > * resultptr = new ofColor_< unsigned char >((const ofColor_< unsigned char > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color___sub__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; float *arg2 = 0 ; float temp2 ; - ofColor_< unsigned char > result; SWIG_check_num_args("ofColor_< unsigned char >::operator -",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::operator -",1,"ofColor_< unsigned char > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::operator -",2,"float const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color___sub",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } temp2=(float)lua_tonumber(L,2); arg2=&temp2; - result = ((ofColor_< unsigned char > const *)arg1)->operator -((float const &)*arg2); { - ofColor_< unsigned char > * resultptr = new ofColor_< unsigned char >((const ofColor_< unsigned char > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color___sub(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Color___sub__SWIG_0(L);} } } if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Color___sub__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Color___sub'\n" " Possible C/C++ prototypes are:\n" - " ofColor_< unsigned char >::operator -(ofColor_< unsigned char > const &) const\n" - " ofColor_< unsigned char >::operator -(float const &) const\n"); lua_error(L);return 0; } -static int _wrap_Color___mul__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; ofColor_< unsigned char > *arg2 = 0 ; - ofColor_< unsigned char > result; SWIG_check_num_args("ofColor_< unsigned char >::operator *",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::operator *",1,"ofColor_< unsigned char > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::operator *",2,"ofColor_< unsigned char > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color___mul",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color___mul",2,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - result = ((ofColor_< unsigned char > const *)arg1)->operator *((ofColor_< unsigned char > const &)*arg2); { - ofColor_< unsigned char > * resultptr = new ofColor_< unsigned char >((const ofColor_< unsigned char > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color___mul__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; float *arg2 = 0 ; float temp2 ; - ofColor_< unsigned char > result; SWIG_check_num_args("ofColor_< unsigned char >::operator *",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::operator *",1,"ofColor_< unsigned char > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::operator *",2,"float const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color___mul",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } temp2=(float)lua_tonumber(L,2); arg2=&temp2; - result = ((ofColor_< unsigned char > const *)arg1)->operator *((float const &)*arg2); { - ofColor_< unsigned char > * resultptr = new ofColor_< unsigned char >((const ofColor_< unsigned char > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color___mul(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Color___mul__SWIG_0(L);} } } if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Color___mul__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Color___mul'\n" " Possible C/C++ prototypes are:\n" - " ofColor_< unsigned char >::operator *(ofColor_< unsigned char > const &) const\n" - " ofColor_< unsigned char >::operator *(float const &) const\n"); lua_error(L);return 0; } -static int _wrap_Color___div__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; ofColor_< unsigned char > *arg2 = 0 ; - ofColor_< unsigned char > result; SWIG_check_num_args("ofColor_< unsigned char >::operator /",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::operator /",1,"ofColor_< unsigned char > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::operator /",2,"ofColor_< unsigned char > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color___div",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color___div",2,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - result = ((ofColor_< unsigned char > const *)arg1)->operator /((ofColor_< unsigned char > const &)*arg2); { - ofColor_< unsigned char > * resultptr = new ofColor_< unsigned char >((const ofColor_< unsigned char > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color___div__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; float *arg2 = 0 ; float temp2 ; - ofColor_< unsigned char > result; SWIG_check_num_args("ofColor_< unsigned char >::operator /",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::operator /",1,"ofColor_< unsigned char > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::operator /",2,"float const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color___div",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } temp2=(float)lua_tonumber(L,2); arg2=&temp2; - result = ((ofColor_< unsigned char > const *)arg1)->operator /((float const &)*arg2); { - ofColor_< unsigned char > * resultptr = new ofColor_< unsigned char >((const ofColor_< unsigned char > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color___div(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Color___div__SWIG_0(L);} } } if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Color___div__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Color___div'\n" " Possible C/C++ prototypes are:\n" - " ofColor_< unsigned char >::operator /(ofColor_< unsigned char > const &) const\n" - " ofColor_< unsigned char >::operator /(float const &) const\n"); lua_error(L);return 0; } -static int _wrap_Color_white_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::white",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::white; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_gray_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::gray",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::gray; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_black_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::black",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::black; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_red_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::red",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::red; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_green_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::green",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::green; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_blue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::blue",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::blue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_cyan_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::cyan",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::cyan; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_magenta_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::magenta",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::magenta; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_yellow_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::yellow",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::yellow; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_aliceBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::aliceBlue",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::aliceBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_antiqueWhite_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::antiqueWhite",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::antiqueWhite; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_aqua_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::aqua",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::aqua; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_aquamarine_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::aquamarine",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::aquamarine; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_azure_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::azure",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::azure; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_beige_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::beige",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::beige; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_bisque_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::bisque",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::bisque; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_blanchedAlmond_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::blanchedAlmond",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::blanchedAlmond; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_blueViolet_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::blueViolet",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::blueViolet; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_brown_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::brown",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::brown; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_burlyWood_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::burlyWood",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::burlyWood; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_cadetBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::cadetBlue",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::cadetBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_chartreuse_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::chartreuse",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::chartreuse; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_chocolate_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::chocolate",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::chocolate; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_coral_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::coral",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::coral; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_cornflowerBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::cornflowerBlue",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::cornflowerBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_cornsilk_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::cornsilk",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::cornsilk; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_crimson_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::crimson",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::crimson; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_darkBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::darkBlue",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::darkBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_darkCyan_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::darkCyan",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::darkCyan; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_darkGoldenRod_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::darkGoldenRod",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::darkGoldenRod; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_darkGray_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::darkGray",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::darkGray; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_darkGrey_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::darkGrey",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::darkGrey; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_darkGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::darkGreen",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::darkGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_darkKhaki_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::darkKhaki",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::darkKhaki; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_darkMagenta_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::darkMagenta",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::darkMagenta; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_darkOliveGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::darkOliveGreen",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::darkOliveGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_darkorange_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::darkorange",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::darkorange; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_darkOrchid_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::darkOrchid",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::darkOrchid; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_darkRed_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::darkRed",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::darkRed; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_darkSalmon_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::darkSalmon",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::darkSalmon; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_darkSeaGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::darkSeaGreen",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::darkSeaGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_darkSlateBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::darkSlateBlue",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::darkSlateBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_darkSlateGray_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::darkSlateGray",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::darkSlateGray; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_darkSlateGrey_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::darkSlateGrey",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::darkSlateGrey; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_darkTurquoise_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::darkTurquoise",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::darkTurquoise; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_darkViolet_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::darkViolet",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::darkViolet; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_deepPink_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::deepPink",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::deepPink; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_deepSkyBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::deepSkyBlue",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::deepSkyBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_dimGray_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::dimGray",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::dimGray; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_dimGrey_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::dimGrey",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::dimGrey; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_dodgerBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::dodgerBlue",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::dodgerBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_fireBrick_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::fireBrick",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::fireBrick; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_floralWhite_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::floralWhite",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::floralWhite; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_forestGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::forestGreen",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::forestGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_fuchsia_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::fuchsia",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::fuchsia; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_gainsboro_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::gainsboro",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::gainsboro; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_ghostWhite_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::ghostWhite",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::ghostWhite; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_gold_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::gold",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::gold; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_goldenRod_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::goldenRod",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::goldenRod; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_grey_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::grey",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::grey; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_greenYellow_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::greenYellow",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::greenYellow; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_honeyDew_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::honeyDew",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::honeyDew; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_hotPink_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::hotPink",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::hotPink; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_indianRed_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::indianRed",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::indianRed; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_indigo_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::indigo",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::indigo; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_ivory_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::ivory",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::ivory; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_khaki_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::khaki",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::khaki; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_lavender_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::lavender",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::lavender; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_lavenderBlush_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::lavenderBlush",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::lavenderBlush; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_lawnGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::lawnGreen",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::lawnGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_lemonChiffon_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::lemonChiffon",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::lemonChiffon; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_lightBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::lightBlue",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::lightBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_lightCoral_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::lightCoral",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::lightCoral; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_lightCyan_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::lightCyan",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::lightCyan; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_lightGoldenRodYellow_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::lightGoldenRodYellow",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::lightGoldenRodYellow; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_lightGray_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::lightGray",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::lightGray; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_lightGrey_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::lightGrey",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::lightGrey; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_lightGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::lightGreen",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::lightGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_lightPink_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::lightPink",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::lightPink; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_lightSalmon_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::lightSalmon",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::lightSalmon; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_lightSeaGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::lightSeaGreen",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::lightSeaGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_lightSkyBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::lightSkyBlue",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::lightSkyBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_lightSlateGray_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::lightSlateGray",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::lightSlateGray; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_lightSlateGrey_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::lightSlateGrey",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::lightSlateGrey; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_lightSteelBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::lightSteelBlue",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::lightSteelBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_lightYellow_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::lightYellow",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::lightYellow; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_lime_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::lime",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::lime; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_limeGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::limeGreen",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::limeGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_linen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::linen",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::linen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_maroon_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::maroon",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::maroon; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_mediumAquaMarine_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::mediumAquaMarine",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::mediumAquaMarine; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_mediumBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::mediumBlue",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::mediumBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_mediumOrchid_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::mediumOrchid",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::mediumOrchid; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_mediumPurple_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::mediumPurple",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::mediumPurple; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_mediumSeaGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::mediumSeaGreen",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::mediumSeaGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_mediumSlateBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::mediumSlateBlue",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::mediumSlateBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_mediumSpringGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::mediumSpringGreen",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::mediumSpringGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_mediumTurquoise_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::mediumTurquoise",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::mediumTurquoise; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_mediumVioletRed_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::mediumVioletRed",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::mediumVioletRed; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_midnightBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::midnightBlue",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::midnightBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_mintCream_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::mintCream",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::mintCream; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_mistyRose_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::mistyRose",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::mistyRose; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_moccasin_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::moccasin",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::moccasin; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_navajoWhite_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::navajoWhite",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::navajoWhite; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_navy_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::navy",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::navy; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_oldLace_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::oldLace",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::oldLace; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_olive_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::olive",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::olive; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_oliveDrab_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::oliveDrab",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::oliveDrab; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_orange_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::orange",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::orange; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_orangeRed_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::orangeRed",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::orangeRed; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_orchid_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::orchid",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::orchid; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_paleGoldenRod_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::paleGoldenRod",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::paleGoldenRod; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_paleGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::paleGreen",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::paleGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_paleTurquoise_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::paleTurquoise",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::paleTurquoise; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_paleVioletRed_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::paleVioletRed",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::paleVioletRed; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_papayaWhip_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::papayaWhip",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::papayaWhip; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_peachPuff_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::peachPuff",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::peachPuff; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_peru_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::peru",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::peru; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_pink_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::pink",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::pink; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_plum_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::plum",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::plum; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_powderBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::powderBlue",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::powderBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_purple_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::purple",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::purple; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_rosyBrown_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::rosyBrown",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::rosyBrown; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_royalBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::royalBlue",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::royalBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_saddleBrown_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::saddleBrown",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::saddleBrown; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_salmon_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::salmon",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::salmon; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_sandyBrown_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::sandyBrown",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::sandyBrown; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_seaGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::seaGreen",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::seaGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_seaShell_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::seaShell",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::seaShell; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_sienna_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::sienna",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::sienna; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_silver_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::silver",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::silver; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_skyBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::skyBlue",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::skyBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_slateBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::slateBlue",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::slateBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_slateGray_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::slateGray",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::slateGray; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_slateGrey_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::slateGrey",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::slateGrey; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_snow_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::snow",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::snow; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_springGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::springGreen",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::springGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_steelBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::steelBlue",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::steelBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_blueSteel_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::blueSteel",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::blueSteel; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_tan_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::tan",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::tan; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_teal_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::teal",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::teal; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_thistle_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::thistle",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::thistle; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_tomato_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::tomato",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::tomato; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_turquoise_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::turquoise",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::turquoise; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_violet_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::violet",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::violet; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_wheat_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::wheat",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::wheat; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_whiteSmoke_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::whiteSmoke",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::whiteSmoke; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_yellowGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::yellowGreen",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::yellowGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_getR(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; unsigned char result; - SWIG_check_num_args("ofColor_< unsigned char >::getR",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::getR",1,"ofColor_< unsigned char > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_getR",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - result = (unsigned char)ofColor__Sl_unsigned_SS_char_Sg__getR(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_getG(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; unsigned char result; - SWIG_check_num_args("ofColor_< unsigned char >::getG",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::getG",1,"ofColor_< unsigned char > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_getG",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - result = (unsigned char)ofColor__Sl_unsigned_SS_char_Sg__getG(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_getB(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; unsigned char result; - SWIG_check_num_args("ofColor_< unsigned char >::getB",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::getB",1,"ofColor_< unsigned char > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_getB",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - result = (unsigned char)ofColor__Sl_unsigned_SS_char_Sg__getB(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_getA(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; unsigned char result; - SWIG_check_num_args("ofColor_< unsigned char >::getA",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::getA",1,"ofColor_< unsigned char > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_getA",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - result = (unsigned char)ofColor__Sl_unsigned_SS_char_Sg__getA(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_setR(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; unsigned char arg2 ; - SWIG_check_num_args("ofColor_< unsigned char >::setR",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::setR",1,"ofColor_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::setR",2,"unsigned char"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_setR",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned char)lua_tonumber(L, 2); - ofColor__Sl_unsigned_SS_char_Sg__setR(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_setG(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; unsigned char arg2 ; - SWIG_check_num_args("ofColor_< unsigned char >::setG",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::setG",1,"ofColor_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::setG",2,"unsigned char"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_setG",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned char)lua_tonumber(L, 2); - ofColor__Sl_unsigned_SS_char_Sg__setG(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_setB(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; unsigned char arg2 ; - SWIG_check_num_args("ofColor_< unsigned char >::setB",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::setB",1,"ofColor_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::setB",2,"unsigned char"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_setB",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned char)lua_tonumber(L, 2); - ofColor__Sl_unsigned_SS_char_Sg__setB(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_setA(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; unsigned char arg2 ; - SWIG_check_num_args("ofColor_< unsigned char >::setA",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::setA",1,"ofColor_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::setA",2,"unsigned char"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_setA",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned char)lua_tonumber(L, 2); - ofColor__Sl_unsigned_SS_char_Sg__setA(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color___tostring(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; char *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::__str__",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::__str__",1,"ofColor_< unsigned char > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color___tostring",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - result = (char *)ofColor__Sl_unsigned_SS_char_Sg____str__(arg1); lua_pushstring(L,(const char *)result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_r_set(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; unsigned char arg2 ; - SWIG_check_num_args("ofColor_< unsigned char >::r",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::r",1,"ofColor_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::r",2,"unsigned char"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_r_set",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned char)lua_tonumber(L, 2); - ofColor__Sl_unsigned_SS_char_Sg__r_set(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_r_get(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; unsigned char result; - SWIG_check_num_args("ofColor_< unsigned char >::r",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::r",1,"ofColor_< unsigned char > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_r_get",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - result = (unsigned char)ofColor__Sl_unsigned_SS_char_Sg__r_get(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_g_set(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; unsigned char arg2 ; - SWIG_check_num_args("ofColor_< unsigned char >::g",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::g",1,"ofColor_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::g",2,"unsigned char"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_g_set",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned char)lua_tonumber(L, 2); - ofColor__Sl_unsigned_SS_char_Sg__g_set(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_g_get(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; unsigned char result; - SWIG_check_num_args("ofColor_< unsigned char >::g",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::g",1,"ofColor_< unsigned char > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_g_get",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - result = (unsigned char)ofColor__Sl_unsigned_SS_char_Sg__g_get(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_b_set(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; unsigned char arg2 ; - SWIG_check_num_args("ofColor_< unsigned char >::b",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::b",1,"ofColor_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::b",2,"unsigned char"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_b_set",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned char)lua_tonumber(L, 2); - ofColor__Sl_unsigned_SS_char_Sg__b_set(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_b_get(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; unsigned char result; - SWIG_check_num_args("ofColor_< unsigned char >::b",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::b",1,"ofColor_< unsigned char > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_b_get",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - result = (unsigned char)ofColor__Sl_unsigned_SS_char_Sg__b_get(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_a_set(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; unsigned char arg2 ; - SWIG_check_num_args("ofColor_< unsigned char >::a",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::a",1,"ofColor_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::a",2,"unsigned char"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_a_set",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned char)lua_tonumber(L, 2); - ofColor__Sl_unsigned_SS_char_Sg__a_set(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_a_get(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; unsigned char result; - SWIG_check_num_args("ofColor_< unsigned char >::a",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::a",1,"ofColor_< unsigned char > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_a_get",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - result = (unsigned char)ofColor__Sl_unsigned_SS_char_Sg__a_get(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_Color(void *obj) { -ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) obj; -delete arg1; -} -static int _proxy__wrap_new_Color(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_Color); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_Color_attributes[] = { - { "r", _wrap_Color_r_get, _wrap_Color_r_set }, - { "g", _wrap_Color_g_get, _wrap_Color_g_set }, - { "b", _wrap_Color_b_get, _wrap_Color_b_set }, - { "a", _wrap_Color_a_get, _wrap_Color_a_set }, - {0,0,0} -}; -static swig_lua_method swig_Color_methods[]= { - { "set", _wrap_Color_set}, - { "setHex", _wrap_Color_setHex}, - { "setHue", _wrap_Color_setHue}, - { "setHueAngle", _wrap_Color_setHueAngle}, - { "setSaturation", _wrap_Color_setSaturation}, - { "setBrightness", _wrap_Color_setBrightness}, - { "setHsb", _wrap_Color_setHsb}, - { "clamp", _wrap_Color_clamp}, - { "invert", _wrap_Color_invert}, - { "normalize", _wrap_Color_normalize}, - { "lerp", _wrap_Color_lerp}, - { "getClamped", _wrap_Color_getClamped}, - { "getInverted", _wrap_Color_getInverted}, - { "getNormalized", _wrap_Color_getNormalized}, - { "getLerped", _wrap_Color_getLerped}, - { "getHex", _wrap_Color_getHex}, - { "getHue", _wrap_Color_getHue}, - { "getHueAngle", _wrap_Color_getHueAngle}, - { "getSaturation", _wrap_Color_getSaturation}, - { "getBrightness", _wrap_Color_getBrightness}, - { "getLightness", _wrap_Color_getLightness}, - { "getHsb", _wrap_Color_getHsb}, - { "__eq", _wrap_Color___eq}, - { "__add", _wrap_Color___add}, - { "__sub", _wrap_Color___sub}, - { "__mul", _wrap_Color___mul}, - { "__div", _wrap_Color___div}, - { "getR", _wrap_Color_getR}, - { "getG", _wrap_Color_getG}, - { "getB", _wrap_Color_getB}, - { "getA", _wrap_Color_getA}, - { "setR", _wrap_Color_setR}, - { "setG", _wrap_Color_setG}, - { "setB", _wrap_Color_setB}, - { "setA", _wrap_Color_setA}, - { "__tostring", _wrap_Color___tostring}, - {0,0} -}; -static swig_lua_method swig_Color_meta[] = { - { "__eq", _wrap_Color___eq}, - { "__add", _wrap_Color___add}, - { "__sub", _wrap_Color___sub}, - { "__mul", _wrap_Color___mul}, - { "__div", _wrap_Color___div}, - { "__tostring", _wrap_Color___tostring}, - {0,0} -}; - -static swig_lua_attribute swig_Color_Sf_SwigStatic_attributes[] = { - { "white", _wrap_Color_white_get, SWIG_Lua_set_immutable }, - { "gray", _wrap_Color_gray_get, SWIG_Lua_set_immutable }, - { "black", _wrap_Color_black_get, SWIG_Lua_set_immutable }, - { "red", _wrap_Color_red_get, SWIG_Lua_set_immutable }, - { "green", _wrap_Color_green_get, SWIG_Lua_set_immutable }, - { "blue", _wrap_Color_blue_get, SWIG_Lua_set_immutable }, - { "cyan", _wrap_Color_cyan_get, SWIG_Lua_set_immutable }, - { "magenta", _wrap_Color_magenta_get, SWIG_Lua_set_immutable }, - { "yellow", _wrap_Color_yellow_get, SWIG_Lua_set_immutable }, - { "aliceBlue", _wrap_Color_aliceBlue_get, SWIG_Lua_set_immutable }, - { "antiqueWhite", _wrap_Color_antiqueWhite_get, SWIG_Lua_set_immutable }, - { "aqua", _wrap_Color_aqua_get, SWIG_Lua_set_immutable }, - { "aquamarine", _wrap_Color_aquamarine_get, SWIG_Lua_set_immutable }, - { "azure", _wrap_Color_azure_get, SWIG_Lua_set_immutable }, - { "beige", _wrap_Color_beige_get, SWIG_Lua_set_immutable }, - { "bisque", _wrap_Color_bisque_get, SWIG_Lua_set_immutable }, - { "blanchedAlmond", _wrap_Color_blanchedAlmond_get, SWIG_Lua_set_immutable }, - { "blueViolet", _wrap_Color_blueViolet_get, SWIG_Lua_set_immutable }, - { "brown", _wrap_Color_brown_get, SWIG_Lua_set_immutable }, - { "burlyWood", _wrap_Color_burlyWood_get, SWIG_Lua_set_immutable }, - { "cadetBlue", _wrap_Color_cadetBlue_get, SWIG_Lua_set_immutable }, - { "chartreuse", _wrap_Color_chartreuse_get, SWIG_Lua_set_immutable }, - { "chocolate", _wrap_Color_chocolate_get, SWIG_Lua_set_immutable }, - { "coral", _wrap_Color_coral_get, SWIG_Lua_set_immutable }, - { "cornflowerBlue", _wrap_Color_cornflowerBlue_get, SWIG_Lua_set_immutable }, - { "cornsilk", _wrap_Color_cornsilk_get, SWIG_Lua_set_immutable }, - { "crimson", _wrap_Color_crimson_get, SWIG_Lua_set_immutable }, - { "darkBlue", _wrap_Color_darkBlue_get, SWIG_Lua_set_immutable }, - { "darkCyan", _wrap_Color_darkCyan_get, SWIG_Lua_set_immutable }, - { "darkGoldenRod", _wrap_Color_darkGoldenRod_get, SWIG_Lua_set_immutable }, - { "darkGray", _wrap_Color_darkGray_get, SWIG_Lua_set_immutable }, - { "darkGrey", _wrap_Color_darkGrey_get, SWIG_Lua_set_immutable }, - { "darkGreen", _wrap_Color_darkGreen_get, SWIG_Lua_set_immutable }, - { "darkKhaki", _wrap_Color_darkKhaki_get, SWIG_Lua_set_immutable }, - { "darkMagenta", _wrap_Color_darkMagenta_get, SWIG_Lua_set_immutable }, - { "darkOliveGreen", _wrap_Color_darkOliveGreen_get, SWIG_Lua_set_immutable }, - { "darkorange", _wrap_Color_darkorange_get, SWIG_Lua_set_immutable }, - { "darkOrchid", _wrap_Color_darkOrchid_get, SWIG_Lua_set_immutable }, - { "darkRed", _wrap_Color_darkRed_get, SWIG_Lua_set_immutable }, - { "darkSalmon", _wrap_Color_darkSalmon_get, SWIG_Lua_set_immutable }, - { "darkSeaGreen", _wrap_Color_darkSeaGreen_get, SWIG_Lua_set_immutable }, - { "darkSlateBlue", _wrap_Color_darkSlateBlue_get, SWIG_Lua_set_immutable }, - { "darkSlateGray", _wrap_Color_darkSlateGray_get, SWIG_Lua_set_immutable }, - { "darkSlateGrey", _wrap_Color_darkSlateGrey_get, SWIG_Lua_set_immutable }, - { "darkTurquoise", _wrap_Color_darkTurquoise_get, SWIG_Lua_set_immutable }, - { "darkViolet", _wrap_Color_darkViolet_get, SWIG_Lua_set_immutable }, - { "deepPink", _wrap_Color_deepPink_get, SWIG_Lua_set_immutable }, - { "deepSkyBlue", _wrap_Color_deepSkyBlue_get, SWIG_Lua_set_immutable }, - { "dimGray", _wrap_Color_dimGray_get, SWIG_Lua_set_immutable }, - { "dimGrey", _wrap_Color_dimGrey_get, SWIG_Lua_set_immutable }, - { "dodgerBlue", _wrap_Color_dodgerBlue_get, SWIG_Lua_set_immutable }, - { "fireBrick", _wrap_Color_fireBrick_get, SWIG_Lua_set_immutable }, - { "floralWhite", _wrap_Color_floralWhite_get, SWIG_Lua_set_immutable }, - { "forestGreen", _wrap_Color_forestGreen_get, SWIG_Lua_set_immutable }, - { "fuchsia", _wrap_Color_fuchsia_get, SWIG_Lua_set_immutable }, - { "gainsboro", _wrap_Color_gainsboro_get, SWIG_Lua_set_immutable }, - { "ghostWhite", _wrap_Color_ghostWhite_get, SWIG_Lua_set_immutable }, - { "gold", _wrap_Color_gold_get, SWIG_Lua_set_immutable }, - { "goldenRod", _wrap_Color_goldenRod_get, SWIG_Lua_set_immutable }, - { "grey", _wrap_Color_grey_get, SWIG_Lua_set_immutable }, - { "greenYellow", _wrap_Color_greenYellow_get, SWIG_Lua_set_immutable }, - { "honeyDew", _wrap_Color_honeyDew_get, SWIG_Lua_set_immutable }, - { "hotPink", _wrap_Color_hotPink_get, SWIG_Lua_set_immutable }, - { "indianRed", _wrap_Color_indianRed_get, SWIG_Lua_set_immutable }, - { "indigo", _wrap_Color_indigo_get, SWIG_Lua_set_immutable }, - { "ivory", _wrap_Color_ivory_get, SWIG_Lua_set_immutable }, - { "khaki", _wrap_Color_khaki_get, SWIG_Lua_set_immutable }, - { "lavender", _wrap_Color_lavender_get, SWIG_Lua_set_immutable }, - { "lavenderBlush", _wrap_Color_lavenderBlush_get, SWIG_Lua_set_immutable }, - { "lawnGreen", _wrap_Color_lawnGreen_get, SWIG_Lua_set_immutable }, - { "lemonChiffon", _wrap_Color_lemonChiffon_get, SWIG_Lua_set_immutable }, - { "lightBlue", _wrap_Color_lightBlue_get, SWIG_Lua_set_immutable }, - { "lightCoral", _wrap_Color_lightCoral_get, SWIG_Lua_set_immutable }, - { "lightCyan", _wrap_Color_lightCyan_get, SWIG_Lua_set_immutable }, - { "lightGoldenRodYellow", _wrap_Color_lightGoldenRodYellow_get, SWIG_Lua_set_immutable }, - { "lightGray", _wrap_Color_lightGray_get, SWIG_Lua_set_immutable }, - { "lightGrey", _wrap_Color_lightGrey_get, SWIG_Lua_set_immutable }, - { "lightGreen", _wrap_Color_lightGreen_get, SWIG_Lua_set_immutable }, - { "lightPink", _wrap_Color_lightPink_get, SWIG_Lua_set_immutable }, - { "lightSalmon", _wrap_Color_lightSalmon_get, SWIG_Lua_set_immutable }, - { "lightSeaGreen", _wrap_Color_lightSeaGreen_get, SWIG_Lua_set_immutable }, - { "lightSkyBlue", _wrap_Color_lightSkyBlue_get, SWIG_Lua_set_immutable }, - { "lightSlateGray", _wrap_Color_lightSlateGray_get, SWIG_Lua_set_immutable }, - { "lightSlateGrey", _wrap_Color_lightSlateGrey_get, SWIG_Lua_set_immutable }, - { "lightSteelBlue", _wrap_Color_lightSteelBlue_get, SWIG_Lua_set_immutable }, - { "lightYellow", _wrap_Color_lightYellow_get, SWIG_Lua_set_immutable }, - { "lime", _wrap_Color_lime_get, SWIG_Lua_set_immutable }, - { "limeGreen", _wrap_Color_limeGreen_get, SWIG_Lua_set_immutable }, - { "linen", _wrap_Color_linen_get, SWIG_Lua_set_immutable }, - { "maroon", _wrap_Color_maroon_get, SWIG_Lua_set_immutable }, - { "mediumAquaMarine", _wrap_Color_mediumAquaMarine_get, SWIG_Lua_set_immutable }, - { "mediumBlue", _wrap_Color_mediumBlue_get, SWIG_Lua_set_immutable }, - { "mediumOrchid", _wrap_Color_mediumOrchid_get, SWIG_Lua_set_immutable }, - { "mediumPurple", _wrap_Color_mediumPurple_get, SWIG_Lua_set_immutable }, - { "mediumSeaGreen", _wrap_Color_mediumSeaGreen_get, SWIG_Lua_set_immutable }, - { "mediumSlateBlue", _wrap_Color_mediumSlateBlue_get, SWIG_Lua_set_immutable }, - { "mediumSpringGreen", _wrap_Color_mediumSpringGreen_get, SWIG_Lua_set_immutable }, - { "mediumTurquoise", _wrap_Color_mediumTurquoise_get, SWIG_Lua_set_immutable }, - { "mediumVioletRed", _wrap_Color_mediumVioletRed_get, SWIG_Lua_set_immutable }, - { "midnightBlue", _wrap_Color_midnightBlue_get, SWIG_Lua_set_immutable }, - { "mintCream", _wrap_Color_mintCream_get, SWIG_Lua_set_immutable }, - { "mistyRose", _wrap_Color_mistyRose_get, SWIG_Lua_set_immutable }, - { "moccasin", _wrap_Color_moccasin_get, SWIG_Lua_set_immutable }, - { "navajoWhite", _wrap_Color_navajoWhite_get, SWIG_Lua_set_immutable }, - { "navy", _wrap_Color_navy_get, SWIG_Lua_set_immutable }, - { "oldLace", _wrap_Color_oldLace_get, SWIG_Lua_set_immutable }, - { "olive", _wrap_Color_olive_get, SWIG_Lua_set_immutable }, - { "oliveDrab", _wrap_Color_oliveDrab_get, SWIG_Lua_set_immutable }, - { "orange", _wrap_Color_orange_get, SWIG_Lua_set_immutable }, - { "orangeRed", _wrap_Color_orangeRed_get, SWIG_Lua_set_immutable }, - { "orchid", _wrap_Color_orchid_get, SWIG_Lua_set_immutable }, - { "paleGoldenRod", _wrap_Color_paleGoldenRod_get, SWIG_Lua_set_immutable }, - { "paleGreen", _wrap_Color_paleGreen_get, SWIG_Lua_set_immutable }, - { "paleTurquoise", _wrap_Color_paleTurquoise_get, SWIG_Lua_set_immutable }, - { "paleVioletRed", _wrap_Color_paleVioletRed_get, SWIG_Lua_set_immutable }, - { "papayaWhip", _wrap_Color_papayaWhip_get, SWIG_Lua_set_immutable }, - { "peachPuff", _wrap_Color_peachPuff_get, SWIG_Lua_set_immutable }, - { "peru", _wrap_Color_peru_get, SWIG_Lua_set_immutable }, - { "pink", _wrap_Color_pink_get, SWIG_Lua_set_immutable }, - { "plum", _wrap_Color_plum_get, SWIG_Lua_set_immutable }, - { "powderBlue", _wrap_Color_powderBlue_get, SWIG_Lua_set_immutable }, - { "purple", _wrap_Color_purple_get, SWIG_Lua_set_immutable }, - { "rosyBrown", _wrap_Color_rosyBrown_get, SWIG_Lua_set_immutable }, - { "royalBlue", _wrap_Color_royalBlue_get, SWIG_Lua_set_immutable }, - { "saddleBrown", _wrap_Color_saddleBrown_get, SWIG_Lua_set_immutable }, - { "salmon", _wrap_Color_salmon_get, SWIG_Lua_set_immutable }, - { "sandyBrown", _wrap_Color_sandyBrown_get, SWIG_Lua_set_immutable }, - { "seaGreen", _wrap_Color_seaGreen_get, SWIG_Lua_set_immutable }, - { "seaShell", _wrap_Color_seaShell_get, SWIG_Lua_set_immutable }, - { "sienna", _wrap_Color_sienna_get, SWIG_Lua_set_immutable }, - { "silver", _wrap_Color_silver_get, SWIG_Lua_set_immutable }, - { "skyBlue", _wrap_Color_skyBlue_get, SWIG_Lua_set_immutable }, - { "slateBlue", _wrap_Color_slateBlue_get, SWIG_Lua_set_immutable }, - { "slateGray", _wrap_Color_slateGray_get, SWIG_Lua_set_immutable }, - { "slateGrey", _wrap_Color_slateGrey_get, SWIG_Lua_set_immutable }, - { "snow", _wrap_Color_snow_get, SWIG_Lua_set_immutable }, - { "springGreen", _wrap_Color_springGreen_get, SWIG_Lua_set_immutable }, - { "steelBlue", _wrap_Color_steelBlue_get, SWIG_Lua_set_immutable }, - { "blueSteel", _wrap_Color_blueSteel_get, SWIG_Lua_set_immutable }, - { "tan", _wrap_Color_tan_get, SWIG_Lua_set_immutable }, - { "teal", _wrap_Color_teal_get, SWIG_Lua_set_immutable }, - { "thistle", _wrap_Color_thistle_get, SWIG_Lua_set_immutable }, - { "tomato", _wrap_Color_tomato_get, SWIG_Lua_set_immutable }, - { "turquoise", _wrap_Color_turquoise_get, SWIG_Lua_set_immutable }, - { "violet", _wrap_Color_violet_get, SWIG_Lua_set_immutable }, - { "wheat", _wrap_Color_wheat_get, SWIG_Lua_set_immutable }, - { "whiteSmoke", _wrap_Color_whiteSmoke_get, SWIG_Lua_set_immutable }, - { "yellowGreen", _wrap_Color_yellowGreen_get, SWIG_Lua_set_immutable }, - {0,0,0} -}; -static swig_lua_const_info swig_Color_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_Color_Sf_SwigStatic_methods[]= { - { "fromHsb", _wrap_Color_fromHsb}, - { "fromHex", _wrap_Color_fromHex}, - { "limit", _wrap_Color_limit}, - {0,0} -}; -static swig_lua_class* swig_Color_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_Color_Sf_SwigStatic = { - "Color", - swig_Color_Sf_SwigStatic_methods, - swig_Color_Sf_SwigStatic_attributes, - swig_Color_Sf_SwigStatic_constants, - swig_Color_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_Color_bases[] = {0}; -static const char *swig_Color_base_names[] = {0}; -static swig_lua_class _wrap_class_Color = { "Color", "Color", &SWIGTYPE_p_ofColor_T_unsigned_char_t,_proxy__wrap_new_Color, swig_delete_Color, swig_Color_methods, swig_Color_attributes, &swig_Color_Sf_SwigStatic, swig_Color_meta, swig_Color_bases, swig_Color_base_names }; - -static int _wrap_new_FloatColor__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::ofColor_",0,0) result = (ofColor_< float > *)new ofColor_< float >(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_FloatColor__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - ofColor_< float > *result = 0 ; SWIG_check_num_args("ofColor_< float >::ofColor_",4,4) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofColor_< float >::ofColor_",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< float >::ofColor_",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< float >::ofColor_",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofColor_< float >::ofColor_",4,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - result = (ofColor_< float > *)new ofColor_< float >(arg1,arg2,arg3,arg4); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_FloatColor__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; - ofColor_< float > *result = 0 ; SWIG_check_num_args("ofColor_< float >::ofColor_",3,3) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofColor_< float >::ofColor_",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< float >::ofColor_",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< float >::ofColor_",3,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - result = (ofColor_< float > *)new ofColor_< float >(arg1,arg2,arg3); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_FloatColor__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; - ofColor_< float > *result = 0 ; SWIG_check_num_args("ofColor_< float >::ofColor_",2,2) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofColor_< float >::ofColor_",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< float >::ofColor_",2,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); result = (ofColor_< float > *)new ofColor_< float >(arg1,arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_FloatColor__SWIG_4(lua_State* L) { int SWIG_arg = 0; float arg1 ; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::ofColor_",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofColor_< float >::ofColor_",1,"float"); arg1 = (float)lua_tonumber(L, 1); - result = (ofColor_< float > *)new ofColor_< float >(arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_FloatColor__SWIG_5(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = 0 ; float arg2 ; - ofColor_< float > *result = 0 ; SWIG_check_num_args("ofColor_< float >::ofColor_",2,2) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofColor_< float >::ofColor_",1,"ofColor_< float > const &"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< float >::ofColor_",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("new_FloatColor",1,SWIGTYPE_p_ofColor_T_float_t); } arg2 = (float)lua_tonumber(L, 2); - result = (ofColor_< float > *)new ofColor_< float >((ofColor_< float > const &)*arg1,arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_FloatColor(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_FloatColor__SWIG_0(L);} if (argc == 1) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { - return _wrap_new_FloatColor__SWIG_4(L);} } if (argc == 2) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_new_FloatColor__SWIG_5(L);} } } if (argc == 2) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_new_FloatColor__SWIG_3(L);} } } if (argc == 3) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_new_FloatColor__SWIG_2(L);} } } } if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_new_FloatColor__SWIG_1(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_FloatColor'\n" " Possible C/C++ prototypes are:\n" - " ofColor_< float >::ofColor_()\n" " ofColor_< float >::ofColor_(float,float,float,float)\n" - " ofColor_< float >::ofColor_(float,float,float)\n" " ofColor_< float >::ofColor_(float,float)\n" - " ofColor_< float >::ofColor_(float)\n" " ofColor_< float >::ofColor_(ofColor_< float > const &,float)\n"); - lua_error(L);return 0; } -static int _wrap_FloatColor_fromHsb__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; - float arg4 ; ofColor_< float > result; SWIG_check_num_args("ofColor_< float >::fromHsb",4,4) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofColor_< float >::fromHsb",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< float >::fromHsb",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< float >::fromHsb",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofColor_< float >::fromHsb",4,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - result = ofColor_< float >::SWIGTEMPLATEDISAMBIGUATOR fromHsb(arg1,arg2,arg3,arg4); { - ofColor_< float > * resultptr = new ofColor_< float >((const ofColor_< float > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_fromHsb__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; - ofColor_< float > result; SWIG_check_num_args("ofColor_< float >::fromHsb",3,3) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofColor_< float >::fromHsb",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< float >::fromHsb",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< float >::fromHsb",3,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - result = ofColor_< float >::SWIGTEMPLATEDISAMBIGUATOR fromHsb(arg1,arg2,arg3); { - ofColor_< float > * resultptr = new ofColor_< float >((const ofColor_< float > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_fromHsb(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_FloatColor_fromHsb__SWIG_1(L);} } } } if (argc == 4) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { - return _wrap_FloatColor_fromHsb__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatColor_fromHsb'\n" " Possible C/C++ prototypes are:\n" - " ofColor_< float >::fromHsb(float,float,float,float)\n" " ofColor_< float >::fromHsb(float,float,float)\n"); - lua_error(L);return 0; } -static int _wrap_FloatColor_fromHex__SWIG_0(lua_State* L) { int SWIG_arg = 0; int arg1 ; float arg2 ; ofColor_< float > result; - SWIG_check_num_args("ofColor_< float >::fromHex",2,2) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofColor_< float >::fromHex",1,"int"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< float >::fromHex",2,"float"); arg1 = (int)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); result = ofColor_< float >::SWIGTEMPLATEDISAMBIGUATOR fromHex(arg1,arg2); { - ofColor_< float > * resultptr = new ofColor_< float >((const ofColor_< float > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_fromHex__SWIG_1(lua_State* L) { int SWIG_arg = 0; int arg1 ; ofColor_< float > result; - SWIG_check_num_args("ofColor_< float >::fromHex",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofColor_< float >::fromHex",1,"int"); arg1 = (int)lua_tonumber(L, 1); - result = ofColor_< float >::SWIGTEMPLATEDISAMBIGUATOR fromHex(arg1); { - ofColor_< float > * resultptr = new ofColor_< float >((const ofColor_< float > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_fromHex(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_FloatColor_fromHex__SWIG_1(L);} } if (argc == 2) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_FloatColor_fromHex__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatColor_fromHex'\n" " Possible C/C++ prototypes are:\n" - " ofColor_< float >::fromHex(int,float)\n" " ofColor_< float >::fromHex(int)\n"); lua_error(L);return 0; } -static int _wrap_FloatColor_set__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float arg2 ; float arg3 ; float arg4 ; float arg5 ; SWIG_check_num_args("ofColor_< float >::set",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::set",1,"ofColor_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< float >::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< float >::set",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofColor_< float >::set",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofColor_< float >::set",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_set",1,SWIGTYPE_p_ofColor_T_float_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - (arg1)->set(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_set__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float arg2 ; float arg3 ; float arg4 ; SWIG_check_num_args("ofColor_< float >::set",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::set",1,"ofColor_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< float >::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< float >::set",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofColor_< float >::set",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_set",1,SWIGTYPE_p_ofColor_T_float_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); (arg1)->set(arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_set__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float arg2 ; float arg3 ; SWIG_check_num_args("ofColor_< float >::set",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::set",1,"ofColor_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< float >::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< float >::set",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_set",1,SWIGTYPE_p_ofColor_T_float_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->set(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FloatColor_set__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float arg2 ; SWIG_check_num_args("ofColor_< float >::set",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::set",1,"ofColor_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< float >::set",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_set",1,SWIGTYPE_p_ofColor_T_float_t); } arg2 = (float)lua_tonumber(L, 2); (arg1)->set(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_set__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - ofColor_< float > *arg2 = 0 ; SWIG_check_num_args("ofColor_< float >::set",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::set",1,"ofColor_< float > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofColor_< float >::set",2,"ofColor_< float > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_set",1,SWIGTYPE_p_ofColor_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_set",2,SWIGTYPE_p_ofColor_T_float_t); } (arg1)->set((ofColor_< float > const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_set(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_FloatColor_set__SWIG_4(L);} } } if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_FloatColor_set__SWIG_3(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_FloatColor_set__SWIG_2(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_FloatColor_set__SWIG_1(L);} } } } } - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_FloatColor_set__SWIG_0(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatColor_set'\n" " Possible C/C++ prototypes are:\n" - " ofColor_< float >::set(float,float,float,float)\n" " ofColor_< float >::set(float,float,float)\n" - " ofColor_< float >::set(float,float)\n" " ofColor_< float >::set(float)\n" - " ofColor_< float >::set(ofColor_< float > const &)\n"); lua_error(L);return 0; } -static int _wrap_FloatColor_setHex__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - int arg2 ; float arg3 ; SWIG_check_num_args("ofColor_< float >::setHex",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::setHex",1,"ofColor_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< float >::setHex",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< float >::setHex",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_setHex",1,SWIGTYPE_p_ofColor_T_float_t); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->setHex(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FloatColor_setHex__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - int arg2 ; SWIG_check_num_args("ofColor_< float >::setHex",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::setHex",1,"ofColor_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< float >::setHex",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_setHex",1,SWIGTYPE_p_ofColor_T_float_t); } arg2 = (int)lua_tonumber(L, 2); (arg1)->setHex(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_setHex(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_FloatColor_setHex__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_FloatColor_setHex__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatColor_setHex'\n" " Possible C/C++ prototypes are:\n" - " ofColor_< float >::setHex(int,float)\n" " ofColor_< float >::setHex(int)\n"); lua_error(L);return 0; } -static int _wrap_FloatColor_setHue(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float arg2 ; SWIG_check_num_args("ofColor_< float >::setHue",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::setHue",1,"ofColor_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< float >::setHue",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_setHue",1,SWIGTYPE_p_ofColor_T_float_t); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setHue(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_setHueAngle(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float arg2 ; SWIG_check_num_args("ofColor_< float >::setHueAngle",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::setHueAngle",1,"ofColor_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< float >::setHueAngle",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_setHueAngle",1,SWIGTYPE_p_ofColor_T_float_t); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setHueAngle(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_setSaturation(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float arg2 ; SWIG_check_num_args("ofColor_< float >::setSaturation",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::setSaturation",1,"ofColor_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< float >::setSaturation",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_setSaturation",1,SWIGTYPE_p_ofColor_T_float_t); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setSaturation(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_setBrightness(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float arg2 ; SWIG_check_num_args("ofColor_< float >::setBrightness",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::setBrightness",1,"ofColor_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< float >::setBrightness",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_setBrightness",1,SWIGTYPE_p_ofColor_T_float_t); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setBrightness(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_setHsb__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float arg2 ; float arg3 ; float arg4 ; float arg5 ; SWIG_check_num_args("ofColor_< float >::setHsb",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::setHsb",1,"ofColor_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< float >::setHsb",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< float >::setHsb",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofColor_< float >::setHsb",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofColor_< float >::setHsb",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_setHsb",1,SWIGTYPE_p_ofColor_T_float_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - (arg1)->setHsb(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_setHsb__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float arg2 ; float arg3 ; float arg4 ; SWIG_check_num_args("ofColor_< float >::setHsb",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::setHsb",1,"ofColor_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< float >::setHsb",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< float >::setHsb",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofColor_< float >::setHsb",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_setHsb",1,SWIGTYPE_p_ofColor_T_float_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); (arg1)->setHsb(arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_setHsb(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 4) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_FloatColor_setHsb__SWIG_1(L);} } } } } - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_FloatColor_setHsb__SWIG_0(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatColor_setHsb'\n" " Possible C/C++ prototypes are:\n" - " ofColor_< float >::setHsb(float,float,float,float)\n" " ofColor_< float >::setHsb(float,float,float)\n"); - lua_error(L);return 0; } -static int _wrap_FloatColor_clamp(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - ofColor_< float > *result = 0 ; SWIG_check_num_args("ofColor_< float >::clamp",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::clamp",1,"ofColor_< float > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_clamp",1,SWIGTYPE_p_ofColor_T_float_t); } result = (ofColor_< float > *) &(arg1)->clamp(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_invert(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - ofColor_< float > *result = 0 ; SWIG_check_num_args("ofColor_< float >::invert",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::invert",1,"ofColor_< float > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_invert",1,SWIGTYPE_p_ofColor_T_float_t); } result = (ofColor_< float > *) &(arg1)->invert(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_normalize(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - ofColor_< float > *result = 0 ; SWIG_check_num_args("ofColor_< float >::normalize",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::normalize",1,"ofColor_< float > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_normalize",1,SWIGTYPE_p_ofColor_T_float_t); } - result = (ofColor_< float > *) &(arg1)->normalize(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_lerp(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - ofColor_< float > *arg2 = 0 ; float arg3 ; ofColor_< float > *result = 0 ; SWIG_check_num_args("ofColor_< float >::lerp",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::lerp",1,"ofColor_< float > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofColor_< float >::lerp",2,"ofColor_< float > const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< float >::lerp",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_lerp",1,SWIGTYPE_p_ofColor_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_lerp",2,SWIGTYPE_p_ofColor_T_float_t); } arg3 = (float)lua_tonumber(L, 3); - result = (ofColor_< float > *) &(arg1)->lerp((ofColor_< float > const &)*arg2,arg3); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_getClamped(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - ofColor_< float > result; SWIG_check_num_args("ofColor_< float >::getClamped",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::getClamped",1,"ofColor_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_getClamped",1,SWIGTYPE_p_ofColor_T_float_t); } - result = ((ofColor_< float > const *)arg1)->getClamped(); { - ofColor_< float > * resultptr = new ofColor_< float >((const ofColor_< float > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_getInverted(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - ofColor_< float > result; SWIG_check_num_args("ofColor_< float >::getInverted",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::getInverted",1,"ofColor_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_getInverted",1,SWIGTYPE_p_ofColor_T_float_t); } - result = ((ofColor_< float > const *)arg1)->getInverted(); { - ofColor_< float > * resultptr = new ofColor_< float >((const ofColor_< float > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_getNormalized(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - ofColor_< float > result; SWIG_check_num_args("ofColor_< float >::getNormalized",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::getNormalized",1,"ofColor_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_getNormalized",1,SWIGTYPE_p_ofColor_T_float_t); } - result = ((ofColor_< float > const *)arg1)->getNormalized(); { - ofColor_< float > * resultptr = new ofColor_< float >((const ofColor_< float > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_getLerped(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - ofColor_< float > *arg2 = 0 ; float arg3 ; ofColor_< float > result; SWIG_check_num_args("ofColor_< float >::getLerped",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::getLerped",1,"ofColor_< float > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofColor_< float >::getLerped",2,"ofColor_< float > const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< float >::getLerped",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_getLerped",1,SWIGTYPE_p_ofColor_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_getLerped",2,SWIGTYPE_p_ofColor_T_float_t); } arg3 = (float)lua_tonumber(L, 3); - result = ((ofColor_< float > const *)arg1)->getLerped((ofColor_< float > const &)*arg2,arg3); { - ofColor_< float > * resultptr = new ofColor_< float >((const ofColor_< float > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_getHex(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - int result; SWIG_check_num_args("ofColor_< float >::getHex",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::getHex",1,"ofColor_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_getHex",1,SWIGTYPE_p_ofColor_T_float_t); } - result = (int)((ofColor_< float > const *)arg1)->getHex(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_getHue(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float result; SWIG_check_num_args("ofColor_< float >::getHue",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::getHue",1,"ofColor_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_getHue",1,SWIGTYPE_p_ofColor_T_float_t); } - result = (float)((ofColor_< float > const *)arg1)->getHue(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_getHueAngle(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float result; SWIG_check_num_args("ofColor_< float >::getHueAngle",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::getHueAngle",1,"ofColor_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_getHueAngle",1,SWIGTYPE_p_ofColor_T_float_t); } - result = (float)((ofColor_< float > const *)arg1)->getHueAngle(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_getSaturation(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float result; SWIG_check_num_args("ofColor_< float >::getSaturation",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::getSaturation",1,"ofColor_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_getSaturation",1,SWIGTYPE_p_ofColor_T_float_t); } - result = (float)((ofColor_< float > const *)arg1)->getSaturation(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_getBrightness(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float result; SWIG_check_num_args("ofColor_< float >::getBrightness",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::getBrightness",1,"ofColor_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_getBrightness",1,SWIGTYPE_p_ofColor_T_float_t); } - result = (float)((ofColor_< float > const *)arg1)->getBrightness(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_getLightness(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float result; SWIG_check_num_args("ofColor_< float >::getLightness",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::getLightness",1,"ofColor_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_getLightness",1,SWIGTYPE_p_ofColor_T_float_t); } - result = (float)((ofColor_< float > const *)arg1)->getLightness(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_getHsb(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float *arg2 = 0 ; float *arg3 = 0 ; float *arg4 = 0 ; SWIG_check_num_args("ofColor_< float >::getHsb",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::getHsb",1,"ofColor_< float > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofColor_< float >::getHsb",2,"float &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofColor_< float >::getHsb",3,"float &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofColor_< float >::getHsb",4,"float &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_getHsb",1,SWIGTYPE_p_ofColor_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("FloatColor_getHsb",2,SWIGTYPE_p_float); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("FloatColor_getHsb",3,SWIGTYPE_p_float); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("FloatColor_getHsb",4,SWIGTYPE_p_float); } ((ofColor_< float > const *)arg1)->getHsb(*arg2,*arg3,*arg4); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_limit(lua_State* L) { int SWIG_arg = 0; float result; - SWIG_check_num_args("ofColor_< float >::limit",0,0) result = (float)ofColor_< float >::SWIGTEMPLATEDISAMBIGUATOR limit(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor___eq(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - ofColor_< float > *arg2 = 0 ; bool result; SWIG_check_num_args("ofColor_< float >::operator ==",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::operator ==",1,"ofColor_< float > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofColor_< float >::operator ==",2,"ofColor_< float > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor___eq",1,SWIGTYPE_p_ofColor_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor___eq",2,SWIGTYPE_p_ofColor_T_float_t); } - result = (bool)((ofColor_< float > const *)arg1)->operator ==((ofColor_< float > const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor___add__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - ofColor_< float > *arg2 = 0 ; ofColor_< float > result; SWIG_check_num_args("ofColor_< float >::operator +",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::operator +",1,"ofColor_< float > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofColor_< float >::operator +",2,"ofColor_< float > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor___add",1,SWIGTYPE_p_ofColor_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor___add",2,SWIGTYPE_p_ofColor_T_float_t); } - result = ((ofColor_< float > const *)arg1)->operator +((ofColor_< float > const &)*arg2); { - ofColor_< float > * resultptr = new ofColor_< float >((const ofColor_< float > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor___add__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float *arg2 = 0 ; float temp2 ; ofColor_< float > result; SWIG_check_num_args("ofColor_< float >::operator +",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::operator +",1,"ofColor_< float > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< float >::operator +",2,"float const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor___add",1,SWIGTYPE_p_ofColor_T_float_t); } temp2=(float)lua_tonumber(L,2); arg2=&temp2; - result = ((ofColor_< float > const *)arg1)->operator +((float const &)*arg2); { - ofColor_< float > * resultptr = new ofColor_< float >((const ofColor_< float > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor___add(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_FloatColor___add__SWIG_0(L);} } } if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_FloatColor___add__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatColor___add'\n" " Possible C/C++ prototypes are:\n" - " ofColor_< float >::operator +(ofColor_< float > const &) const\n" - " ofColor_< float >::operator +(float const &) const\n"); lua_error(L);return 0; } -static int _wrap_FloatColor___sub__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - ofColor_< float > *arg2 = 0 ; ofColor_< float > result; SWIG_check_num_args("ofColor_< float >::operator -",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::operator -",1,"ofColor_< float > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofColor_< float >::operator -",2,"ofColor_< float > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor___sub",1,SWIGTYPE_p_ofColor_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor___sub",2,SWIGTYPE_p_ofColor_T_float_t); } - result = ((ofColor_< float > const *)arg1)->operator -((ofColor_< float > const &)*arg2); { - ofColor_< float > * resultptr = new ofColor_< float >((const ofColor_< float > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor___sub__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float *arg2 = 0 ; float temp2 ; ofColor_< float > result; SWIG_check_num_args("ofColor_< float >::operator -",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::operator -",1,"ofColor_< float > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< float >::operator -",2,"float const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor___sub",1,SWIGTYPE_p_ofColor_T_float_t); } temp2=(float)lua_tonumber(L,2); arg2=&temp2; - result = ((ofColor_< float > const *)arg1)->operator -((float const &)*arg2); { - ofColor_< float > * resultptr = new ofColor_< float >((const ofColor_< float > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor___sub(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_FloatColor___sub__SWIG_0(L);} } } if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_FloatColor___sub__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatColor___sub'\n" " Possible C/C++ prototypes are:\n" - " ofColor_< float >::operator -(ofColor_< float > const &) const\n" - " ofColor_< float >::operator -(float const &) const\n"); lua_error(L);return 0; } -static int _wrap_FloatColor___mul__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - ofColor_< float > *arg2 = 0 ; ofColor_< float > result; SWIG_check_num_args("ofColor_< float >::operator *",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::operator *",1,"ofColor_< float > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofColor_< float >::operator *",2,"ofColor_< float > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor___mul",1,SWIGTYPE_p_ofColor_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor___mul",2,SWIGTYPE_p_ofColor_T_float_t); } - result = ((ofColor_< float > const *)arg1)->operator *((ofColor_< float > const &)*arg2); { - ofColor_< float > * resultptr = new ofColor_< float >((const ofColor_< float > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor___mul__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float *arg2 = 0 ; float temp2 ; ofColor_< float > result; SWIG_check_num_args("ofColor_< float >::operator *",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::operator *",1,"ofColor_< float > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< float >::operator *",2,"float const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor___mul",1,SWIGTYPE_p_ofColor_T_float_t); } temp2=(float)lua_tonumber(L,2); arg2=&temp2; - result = ((ofColor_< float > const *)arg1)->operator *((float const &)*arg2); { - ofColor_< float > * resultptr = new ofColor_< float >((const ofColor_< float > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor___mul(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_FloatColor___mul__SWIG_0(L);} } } if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_FloatColor___mul__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatColor___mul'\n" " Possible C/C++ prototypes are:\n" - " ofColor_< float >::operator *(ofColor_< float > const &) const\n" - " ofColor_< float >::operator *(float const &) const\n"); lua_error(L);return 0; } -static int _wrap_FloatColor___div__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - ofColor_< float > *arg2 = 0 ; ofColor_< float > result; SWIG_check_num_args("ofColor_< float >::operator /",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::operator /",1,"ofColor_< float > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofColor_< float >::operator /",2,"ofColor_< float > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor___div",1,SWIGTYPE_p_ofColor_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor___div",2,SWIGTYPE_p_ofColor_T_float_t); } - result = ((ofColor_< float > const *)arg1)->operator /((ofColor_< float > const &)*arg2); { - ofColor_< float > * resultptr = new ofColor_< float >((const ofColor_< float > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor___div__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float *arg2 = 0 ; float temp2 ; ofColor_< float > result; SWIG_check_num_args("ofColor_< float >::operator /",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::operator /",1,"ofColor_< float > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< float >::operator /",2,"float const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor___div",1,SWIGTYPE_p_ofColor_T_float_t); } temp2=(float)lua_tonumber(L,2); arg2=&temp2; - result = ((ofColor_< float > const *)arg1)->operator /((float const &)*arg2); { - ofColor_< float > * resultptr = new ofColor_< float >((const ofColor_< float > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor___div(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_FloatColor___div__SWIG_0(L);} } } if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_FloatColor___div__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatColor___div'\n" " Possible C/C++ prototypes are:\n" - " ofColor_< float >::operator /(ofColor_< float > const &) const\n" - " ofColor_< float >::operator /(float const &) const\n"); lua_error(L);return 0; } -static int _wrap_FloatColor_white_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::white",0,0) result = (ofColor_< float > *)&ofColor_< float >::white; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_gray_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::gray",0,0) result = (ofColor_< float > *)&ofColor_< float >::gray; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_black_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::black",0,0) result = (ofColor_< float > *)&ofColor_< float >::black; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_red_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::red",0,0) result = (ofColor_< float > *)&ofColor_< float >::red; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_green_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::green",0,0) result = (ofColor_< float > *)&ofColor_< float >::green; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_blue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::blue",0,0) result = (ofColor_< float > *)&ofColor_< float >::blue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_cyan_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::cyan",0,0) result = (ofColor_< float > *)&ofColor_< float >::cyan; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_magenta_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::magenta",0,0) result = (ofColor_< float > *)&ofColor_< float >::magenta; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_yellow_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::yellow",0,0) result = (ofColor_< float > *)&ofColor_< float >::yellow; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_aliceBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::aliceBlue",0,0) result = (ofColor_< float > *)&ofColor_< float >::aliceBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_antiqueWhite_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::antiqueWhite",0,0) result = (ofColor_< float > *)&ofColor_< float >::antiqueWhite; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_aqua_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::aqua",0,0) result = (ofColor_< float > *)&ofColor_< float >::aqua; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_aquamarine_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::aquamarine",0,0) result = (ofColor_< float > *)&ofColor_< float >::aquamarine; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_azure_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::azure",0,0) result = (ofColor_< float > *)&ofColor_< float >::azure; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_beige_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::beige",0,0) result = (ofColor_< float > *)&ofColor_< float >::beige; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_bisque_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::bisque",0,0) result = (ofColor_< float > *)&ofColor_< float >::bisque; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_blanchedAlmond_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::blanchedAlmond",0,0) result = (ofColor_< float > *)&ofColor_< float >::blanchedAlmond; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_blueViolet_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::blueViolet",0,0) result = (ofColor_< float > *)&ofColor_< float >::blueViolet; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_brown_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::brown",0,0) result = (ofColor_< float > *)&ofColor_< float >::brown; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_burlyWood_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::burlyWood",0,0) result = (ofColor_< float > *)&ofColor_< float >::burlyWood; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_cadetBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::cadetBlue",0,0) result = (ofColor_< float > *)&ofColor_< float >::cadetBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_chartreuse_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::chartreuse",0,0) result = (ofColor_< float > *)&ofColor_< float >::chartreuse; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_chocolate_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::chocolate",0,0) result = (ofColor_< float > *)&ofColor_< float >::chocolate; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_coral_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::coral",0,0) result = (ofColor_< float > *)&ofColor_< float >::coral; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_cornflowerBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::cornflowerBlue",0,0) result = (ofColor_< float > *)&ofColor_< float >::cornflowerBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_cornsilk_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::cornsilk",0,0) result = (ofColor_< float > *)&ofColor_< float >::cornsilk; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_crimson_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::crimson",0,0) result = (ofColor_< float > *)&ofColor_< float >::crimson; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_darkBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::darkBlue",0,0) result = (ofColor_< float > *)&ofColor_< float >::darkBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_darkCyan_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::darkCyan",0,0) result = (ofColor_< float > *)&ofColor_< float >::darkCyan; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_darkGoldenRod_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::darkGoldenRod",0,0) result = (ofColor_< float > *)&ofColor_< float >::darkGoldenRod; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_darkGray_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::darkGray",0,0) result = (ofColor_< float > *)&ofColor_< float >::darkGray; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_darkGrey_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::darkGrey",0,0) result = (ofColor_< float > *)&ofColor_< float >::darkGrey; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_darkGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::darkGreen",0,0) result = (ofColor_< float > *)&ofColor_< float >::darkGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_darkKhaki_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::darkKhaki",0,0) result = (ofColor_< float > *)&ofColor_< float >::darkKhaki; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_darkMagenta_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::darkMagenta",0,0) result = (ofColor_< float > *)&ofColor_< float >::darkMagenta; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_darkOliveGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::darkOliveGreen",0,0) result = (ofColor_< float > *)&ofColor_< float >::darkOliveGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_darkorange_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::darkorange",0,0) result = (ofColor_< float > *)&ofColor_< float >::darkorange; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_darkOrchid_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::darkOrchid",0,0) result = (ofColor_< float > *)&ofColor_< float >::darkOrchid; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_darkRed_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::darkRed",0,0) result = (ofColor_< float > *)&ofColor_< float >::darkRed; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_darkSalmon_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::darkSalmon",0,0) result = (ofColor_< float > *)&ofColor_< float >::darkSalmon; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_darkSeaGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::darkSeaGreen",0,0) result = (ofColor_< float > *)&ofColor_< float >::darkSeaGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_darkSlateBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::darkSlateBlue",0,0) result = (ofColor_< float > *)&ofColor_< float >::darkSlateBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_darkSlateGray_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::darkSlateGray",0,0) result = (ofColor_< float > *)&ofColor_< float >::darkSlateGray; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_darkSlateGrey_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::darkSlateGrey",0,0) result = (ofColor_< float > *)&ofColor_< float >::darkSlateGrey; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_darkTurquoise_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::darkTurquoise",0,0) result = (ofColor_< float > *)&ofColor_< float >::darkTurquoise; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_darkViolet_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::darkViolet",0,0) result = (ofColor_< float > *)&ofColor_< float >::darkViolet; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_deepPink_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::deepPink",0,0) result = (ofColor_< float > *)&ofColor_< float >::deepPink; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_deepSkyBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::deepSkyBlue",0,0) result = (ofColor_< float > *)&ofColor_< float >::deepSkyBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_dimGray_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::dimGray",0,0) result = (ofColor_< float > *)&ofColor_< float >::dimGray; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_dimGrey_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::dimGrey",0,0) result = (ofColor_< float > *)&ofColor_< float >::dimGrey; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_dodgerBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::dodgerBlue",0,0) result = (ofColor_< float > *)&ofColor_< float >::dodgerBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_fireBrick_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::fireBrick",0,0) result = (ofColor_< float > *)&ofColor_< float >::fireBrick; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_floralWhite_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::floralWhite",0,0) result = (ofColor_< float > *)&ofColor_< float >::floralWhite; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_forestGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::forestGreen",0,0) result = (ofColor_< float > *)&ofColor_< float >::forestGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_fuchsia_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::fuchsia",0,0) result = (ofColor_< float > *)&ofColor_< float >::fuchsia; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_gainsboro_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::gainsboro",0,0) result = (ofColor_< float > *)&ofColor_< float >::gainsboro; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_ghostWhite_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::ghostWhite",0,0) result = (ofColor_< float > *)&ofColor_< float >::ghostWhite; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_gold_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::gold",0,0) result = (ofColor_< float > *)&ofColor_< float >::gold; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_goldenRod_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::goldenRod",0,0) result = (ofColor_< float > *)&ofColor_< float >::goldenRod; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_grey_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::grey",0,0) result = (ofColor_< float > *)&ofColor_< float >::grey; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_greenYellow_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::greenYellow",0,0) result = (ofColor_< float > *)&ofColor_< float >::greenYellow; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_honeyDew_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::honeyDew",0,0) result = (ofColor_< float > *)&ofColor_< float >::honeyDew; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_hotPink_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::hotPink",0,0) result = (ofColor_< float > *)&ofColor_< float >::hotPink; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_indianRed_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::indianRed",0,0) result = (ofColor_< float > *)&ofColor_< float >::indianRed; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_indigo_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::indigo",0,0) result = (ofColor_< float > *)&ofColor_< float >::indigo; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_ivory_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::ivory",0,0) result = (ofColor_< float > *)&ofColor_< float >::ivory; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_khaki_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::khaki",0,0) result = (ofColor_< float > *)&ofColor_< float >::khaki; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_lavender_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::lavender",0,0) result = (ofColor_< float > *)&ofColor_< float >::lavender; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_lavenderBlush_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::lavenderBlush",0,0) result = (ofColor_< float > *)&ofColor_< float >::lavenderBlush; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_lawnGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::lawnGreen",0,0) result = (ofColor_< float > *)&ofColor_< float >::lawnGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_lemonChiffon_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::lemonChiffon",0,0) result = (ofColor_< float > *)&ofColor_< float >::lemonChiffon; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_lightBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::lightBlue",0,0) result = (ofColor_< float > *)&ofColor_< float >::lightBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_lightCoral_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::lightCoral",0,0) result = (ofColor_< float > *)&ofColor_< float >::lightCoral; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_lightCyan_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::lightCyan",0,0) result = (ofColor_< float > *)&ofColor_< float >::lightCyan; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_lightGoldenRodYellow_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::lightGoldenRodYellow",0,0) - result = (ofColor_< float > *)&ofColor_< float >::lightGoldenRodYellow; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_lightGray_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::lightGray",0,0) result = (ofColor_< float > *)&ofColor_< float >::lightGray; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_lightGrey_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::lightGrey",0,0) result = (ofColor_< float > *)&ofColor_< float >::lightGrey; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_lightGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::lightGreen",0,0) result = (ofColor_< float > *)&ofColor_< float >::lightGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_lightPink_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::lightPink",0,0) result = (ofColor_< float > *)&ofColor_< float >::lightPink; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_lightSalmon_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::lightSalmon",0,0) result = (ofColor_< float > *)&ofColor_< float >::lightSalmon; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_lightSeaGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::lightSeaGreen",0,0) result = (ofColor_< float > *)&ofColor_< float >::lightSeaGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_lightSkyBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::lightSkyBlue",0,0) result = (ofColor_< float > *)&ofColor_< float >::lightSkyBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_lightSlateGray_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::lightSlateGray",0,0) result = (ofColor_< float > *)&ofColor_< float >::lightSlateGray; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_lightSlateGrey_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::lightSlateGrey",0,0) result = (ofColor_< float > *)&ofColor_< float >::lightSlateGrey; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_lightSteelBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::lightSteelBlue",0,0) result = (ofColor_< float > *)&ofColor_< float >::lightSteelBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_lightYellow_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::lightYellow",0,0) result = (ofColor_< float > *)&ofColor_< float >::lightYellow; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_lime_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::lime",0,0) result = (ofColor_< float > *)&ofColor_< float >::lime; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_limeGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::limeGreen",0,0) result = (ofColor_< float > *)&ofColor_< float >::limeGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_linen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::linen",0,0) result = (ofColor_< float > *)&ofColor_< float >::linen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_maroon_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::maroon",0,0) result = (ofColor_< float > *)&ofColor_< float >::maroon; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_mediumAquaMarine_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::mediumAquaMarine",0,0) - result = (ofColor_< float > *)&ofColor_< float >::mediumAquaMarine; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_mediumBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::mediumBlue",0,0) result = (ofColor_< float > *)&ofColor_< float >::mediumBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_mediumOrchid_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::mediumOrchid",0,0) result = (ofColor_< float > *)&ofColor_< float >::mediumOrchid; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_mediumPurple_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::mediumPurple",0,0) result = (ofColor_< float > *)&ofColor_< float >::mediumPurple; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_mediumSeaGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::mediumSeaGreen",0,0) result = (ofColor_< float > *)&ofColor_< float >::mediumSeaGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_mediumSlateBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::mediumSlateBlue",0,0) - result = (ofColor_< float > *)&ofColor_< float >::mediumSlateBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_mediumSpringGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::mediumSpringGreen",0,0) - result = (ofColor_< float > *)&ofColor_< float >::mediumSpringGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_mediumTurquoise_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::mediumTurquoise",0,0) - result = (ofColor_< float > *)&ofColor_< float >::mediumTurquoise; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_mediumVioletRed_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::mediumVioletRed",0,0) - result = (ofColor_< float > *)&ofColor_< float >::mediumVioletRed; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_midnightBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::midnightBlue",0,0) result = (ofColor_< float > *)&ofColor_< float >::midnightBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_mintCream_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::mintCream",0,0) result = (ofColor_< float > *)&ofColor_< float >::mintCream; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_mistyRose_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::mistyRose",0,0) result = (ofColor_< float > *)&ofColor_< float >::mistyRose; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_moccasin_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::moccasin",0,0) result = (ofColor_< float > *)&ofColor_< float >::moccasin; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_navajoWhite_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::navajoWhite",0,0) result = (ofColor_< float > *)&ofColor_< float >::navajoWhite; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_navy_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::navy",0,0) result = (ofColor_< float > *)&ofColor_< float >::navy; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_oldLace_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::oldLace",0,0) result = (ofColor_< float > *)&ofColor_< float >::oldLace; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_olive_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::olive",0,0) result = (ofColor_< float > *)&ofColor_< float >::olive; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_oliveDrab_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::oliveDrab",0,0) result = (ofColor_< float > *)&ofColor_< float >::oliveDrab; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_orange_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::orange",0,0) result = (ofColor_< float > *)&ofColor_< float >::orange; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_orangeRed_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::orangeRed",0,0) result = (ofColor_< float > *)&ofColor_< float >::orangeRed; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_orchid_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::orchid",0,0) result = (ofColor_< float > *)&ofColor_< float >::orchid; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_paleGoldenRod_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::paleGoldenRod",0,0) result = (ofColor_< float > *)&ofColor_< float >::paleGoldenRod; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_paleGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::paleGreen",0,0) result = (ofColor_< float > *)&ofColor_< float >::paleGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_paleTurquoise_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::paleTurquoise",0,0) result = (ofColor_< float > *)&ofColor_< float >::paleTurquoise; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_paleVioletRed_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::paleVioletRed",0,0) result = (ofColor_< float > *)&ofColor_< float >::paleVioletRed; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_papayaWhip_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::papayaWhip",0,0) result = (ofColor_< float > *)&ofColor_< float >::papayaWhip; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_peachPuff_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::peachPuff",0,0) result = (ofColor_< float > *)&ofColor_< float >::peachPuff; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_peru_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::peru",0,0) result = (ofColor_< float > *)&ofColor_< float >::peru; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_pink_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::pink",0,0) result = (ofColor_< float > *)&ofColor_< float >::pink; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_plum_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::plum",0,0) result = (ofColor_< float > *)&ofColor_< float >::plum; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_powderBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::powderBlue",0,0) result = (ofColor_< float > *)&ofColor_< float >::powderBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_purple_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::purple",0,0) result = (ofColor_< float > *)&ofColor_< float >::purple; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_rosyBrown_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::rosyBrown",0,0) result = (ofColor_< float > *)&ofColor_< float >::rosyBrown; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_royalBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::royalBlue",0,0) result = (ofColor_< float > *)&ofColor_< float >::royalBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_saddleBrown_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::saddleBrown",0,0) result = (ofColor_< float > *)&ofColor_< float >::saddleBrown; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_salmon_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::salmon",0,0) result = (ofColor_< float > *)&ofColor_< float >::salmon; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_sandyBrown_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::sandyBrown",0,0) result = (ofColor_< float > *)&ofColor_< float >::sandyBrown; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_seaGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::seaGreen",0,0) result = (ofColor_< float > *)&ofColor_< float >::seaGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_seaShell_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::seaShell",0,0) result = (ofColor_< float > *)&ofColor_< float >::seaShell; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_sienna_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::sienna",0,0) result = (ofColor_< float > *)&ofColor_< float >::sienna; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_silver_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::silver",0,0) result = (ofColor_< float > *)&ofColor_< float >::silver; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_skyBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::skyBlue",0,0) result = (ofColor_< float > *)&ofColor_< float >::skyBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_slateBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::slateBlue",0,0) result = (ofColor_< float > *)&ofColor_< float >::slateBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_slateGray_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::slateGray",0,0) result = (ofColor_< float > *)&ofColor_< float >::slateGray; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_slateGrey_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::slateGrey",0,0) result = (ofColor_< float > *)&ofColor_< float >::slateGrey; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_snow_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::snow",0,0) result = (ofColor_< float > *)&ofColor_< float >::snow; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_springGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::springGreen",0,0) result = (ofColor_< float > *)&ofColor_< float >::springGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_steelBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::steelBlue",0,0) result = (ofColor_< float > *)&ofColor_< float >::steelBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_blueSteel_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::blueSteel",0,0) result = (ofColor_< float > *)&ofColor_< float >::blueSteel; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_tan_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::tan",0,0) result = (ofColor_< float > *)&ofColor_< float >::tan; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_teal_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::teal",0,0) result = (ofColor_< float > *)&ofColor_< float >::teal; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_thistle_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::thistle",0,0) result = (ofColor_< float > *)&ofColor_< float >::thistle; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_tomato_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::tomato",0,0) result = (ofColor_< float > *)&ofColor_< float >::tomato; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_turquoise_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::turquoise",0,0) result = (ofColor_< float > *)&ofColor_< float >::turquoise; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_violet_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::violet",0,0) result = (ofColor_< float > *)&ofColor_< float >::violet; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_wheat_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::wheat",0,0) result = (ofColor_< float > *)&ofColor_< float >::wheat; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_whiteSmoke_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::whiteSmoke",0,0) result = (ofColor_< float > *)&ofColor_< float >::whiteSmoke; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_yellowGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::yellowGreen",0,0) result = (ofColor_< float > *)&ofColor_< float >::yellowGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_getR(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float result; SWIG_check_num_args("ofColor_< float >::getR",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::getR",1,"ofColor_< float > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_getR",1,SWIGTYPE_p_ofColor_T_float_t); } result = (float)ofColor__Sl_float_Sg__getR(arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_getG(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float result; SWIG_check_num_args("ofColor_< float >::getG",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::getG",1,"ofColor_< float > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_getG",1,SWIGTYPE_p_ofColor_T_float_t); } result = (float)ofColor__Sl_float_Sg__getG(arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_getB(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float result; SWIG_check_num_args("ofColor_< float >::getB",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::getB",1,"ofColor_< float > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_getB",1,SWIGTYPE_p_ofColor_T_float_t); } result = (float)ofColor__Sl_float_Sg__getB(arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_getA(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float result; SWIG_check_num_args("ofColor_< float >::getA",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::getA",1,"ofColor_< float > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_getA",1,SWIGTYPE_p_ofColor_T_float_t); } result = (float)ofColor__Sl_float_Sg__getA(arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_setR(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float arg2 ; SWIG_check_num_args("ofColor_< float >::setR",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::setR",1,"ofColor_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< float >::setR",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_setR",1,SWIGTYPE_p_ofColor_T_float_t); } arg2 = (float)lua_tonumber(L, 2); - ofColor__Sl_float_Sg__setR(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_setG(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float arg2 ; SWIG_check_num_args("ofColor_< float >::setG",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::setG",1,"ofColor_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< float >::setG",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_setG",1,SWIGTYPE_p_ofColor_T_float_t); } arg2 = (float)lua_tonumber(L, 2); - ofColor__Sl_float_Sg__setG(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_setB(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float arg2 ; SWIG_check_num_args("ofColor_< float >::setB",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::setB",1,"ofColor_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< float >::setB",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_setB",1,SWIGTYPE_p_ofColor_T_float_t); } arg2 = (float)lua_tonumber(L, 2); - ofColor__Sl_float_Sg__setB(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_setA(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float arg2 ; SWIG_check_num_args("ofColor_< float >::setA",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::setA",1,"ofColor_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< float >::setA",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_setA",1,SWIGTYPE_p_ofColor_T_float_t); } arg2 = (float)lua_tonumber(L, 2); - ofColor__Sl_float_Sg__setA(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor___tostring(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - char *result = 0 ; SWIG_check_num_args("ofColor_< float >::__str__",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::__str__",1,"ofColor_< float > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor___tostring",1,SWIGTYPE_p_ofColor_T_float_t); } - result = (char *)ofColor__Sl_float_Sg____str__(arg1); lua_pushstring(L,(const char *)result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_r_set(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float arg2 ; SWIG_check_num_args("ofColor_< float >::r",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::r",1,"ofColor_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< float >::r",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_r_set",1,SWIGTYPE_p_ofColor_T_float_t); } arg2 = (float)lua_tonumber(L, 2); - ofColor__Sl_float_Sg__r_set(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_r_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float result; SWIG_check_num_args("ofColor_< float >::r",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::r",1,"ofColor_< float > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_r_get",1,SWIGTYPE_p_ofColor_T_float_t); } result = (float)ofColor__Sl_float_Sg__r_get(arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_g_set(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float arg2 ; SWIG_check_num_args("ofColor_< float >::g",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::g",1,"ofColor_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< float >::g",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_g_set",1,SWIGTYPE_p_ofColor_T_float_t); } arg2 = (float)lua_tonumber(L, 2); - ofColor__Sl_float_Sg__g_set(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_g_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float result; SWIG_check_num_args("ofColor_< float >::g",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::g",1,"ofColor_< float > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_g_get",1,SWIGTYPE_p_ofColor_T_float_t); } result = (float)ofColor__Sl_float_Sg__g_get(arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_b_set(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float arg2 ; SWIG_check_num_args("ofColor_< float >::b",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::b",1,"ofColor_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< float >::b",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_b_set",1,SWIGTYPE_p_ofColor_T_float_t); } arg2 = (float)lua_tonumber(L, 2); - ofColor__Sl_float_Sg__b_set(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_b_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float result; SWIG_check_num_args("ofColor_< float >::b",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::b",1,"ofColor_< float > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_b_get",1,SWIGTYPE_p_ofColor_T_float_t); } result = (float)ofColor__Sl_float_Sg__b_get(arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_a_set(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float arg2 ; SWIG_check_num_args("ofColor_< float >::a",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::a",1,"ofColor_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< float >::a",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_a_set",1,SWIGTYPE_p_ofColor_T_float_t); } arg2 = (float)lua_tonumber(L, 2); - ofColor__Sl_float_Sg__a_set(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_a_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float result; SWIG_check_num_args("ofColor_< float >::a",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::a",1,"ofColor_< float > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_a_get",1,SWIGTYPE_p_ofColor_T_float_t); } result = (float)ofColor__Sl_float_Sg__a_get(arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_FloatColor(void *obj) { -ofColor_< float > *arg1 = (ofColor_< float > *) obj; -delete arg1; -} -static int _proxy__wrap_new_FloatColor(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_FloatColor); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_FloatColor_attributes[] = { - { "r", _wrap_FloatColor_r_get, _wrap_FloatColor_r_set }, - { "g", _wrap_FloatColor_g_get, _wrap_FloatColor_g_set }, - { "b", _wrap_FloatColor_b_get, _wrap_FloatColor_b_set }, - { "a", _wrap_FloatColor_a_get, _wrap_FloatColor_a_set }, - {0,0,0} -}; -static swig_lua_method swig_FloatColor_methods[]= { - { "set", _wrap_FloatColor_set}, - { "setHex", _wrap_FloatColor_setHex}, - { "setHue", _wrap_FloatColor_setHue}, - { "setHueAngle", _wrap_FloatColor_setHueAngle}, - { "setSaturation", _wrap_FloatColor_setSaturation}, - { "setBrightness", _wrap_FloatColor_setBrightness}, - { "setHsb", _wrap_FloatColor_setHsb}, - { "clamp", _wrap_FloatColor_clamp}, - { "invert", _wrap_FloatColor_invert}, - { "normalize", _wrap_FloatColor_normalize}, - { "lerp", _wrap_FloatColor_lerp}, - { "getClamped", _wrap_FloatColor_getClamped}, - { "getInverted", _wrap_FloatColor_getInverted}, - { "getNormalized", _wrap_FloatColor_getNormalized}, - { "getLerped", _wrap_FloatColor_getLerped}, - { "getHex", _wrap_FloatColor_getHex}, - { "getHue", _wrap_FloatColor_getHue}, - { "getHueAngle", _wrap_FloatColor_getHueAngle}, - { "getSaturation", _wrap_FloatColor_getSaturation}, - { "getBrightness", _wrap_FloatColor_getBrightness}, - { "getLightness", _wrap_FloatColor_getLightness}, - { "getHsb", _wrap_FloatColor_getHsb}, - { "__eq", _wrap_FloatColor___eq}, - { "__add", _wrap_FloatColor___add}, - { "__sub", _wrap_FloatColor___sub}, - { "__mul", _wrap_FloatColor___mul}, - { "__div", _wrap_FloatColor___div}, - { "getR", _wrap_FloatColor_getR}, - { "getG", _wrap_FloatColor_getG}, - { "getB", _wrap_FloatColor_getB}, - { "getA", _wrap_FloatColor_getA}, - { "setR", _wrap_FloatColor_setR}, - { "setG", _wrap_FloatColor_setG}, - { "setB", _wrap_FloatColor_setB}, - { "setA", _wrap_FloatColor_setA}, - { "__tostring", _wrap_FloatColor___tostring}, - {0,0} -}; -static swig_lua_method swig_FloatColor_meta[] = { - { "__eq", _wrap_FloatColor___eq}, - { "__add", _wrap_FloatColor___add}, - { "__sub", _wrap_FloatColor___sub}, - { "__mul", _wrap_FloatColor___mul}, - { "__div", _wrap_FloatColor___div}, - { "__tostring", _wrap_FloatColor___tostring}, - {0,0} -}; - -static swig_lua_attribute swig_FloatColor_Sf_SwigStatic_attributes[] = { - { "white", _wrap_FloatColor_white_get, SWIG_Lua_set_immutable }, - { "gray", _wrap_FloatColor_gray_get, SWIG_Lua_set_immutable }, - { "black", _wrap_FloatColor_black_get, SWIG_Lua_set_immutable }, - { "red", _wrap_FloatColor_red_get, SWIG_Lua_set_immutable }, - { "green", _wrap_FloatColor_green_get, SWIG_Lua_set_immutable }, - { "blue", _wrap_FloatColor_blue_get, SWIG_Lua_set_immutable }, - { "cyan", _wrap_FloatColor_cyan_get, SWIG_Lua_set_immutable }, - { "magenta", _wrap_FloatColor_magenta_get, SWIG_Lua_set_immutable }, - { "yellow", _wrap_FloatColor_yellow_get, SWIG_Lua_set_immutable }, - { "aliceBlue", _wrap_FloatColor_aliceBlue_get, SWIG_Lua_set_immutable }, - { "antiqueWhite", _wrap_FloatColor_antiqueWhite_get, SWIG_Lua_set_immutable }, - { "aqua", _wrap_FloatColor_aqua_get, SWIG_Lua_set_immutable }, - { "aquamarine", _wrap_FloatColor_aquamarine_get, SWIG_Lua_set_immutable }, - { "azure", _wrap_FloatColor_azure_get, SWIG_Lua_set_immutable }, - { "beige", _wrap_FloatColor_beige_get, SWIG_Lua_set_immutable }, - { "bisque", _wrap_FloatColor_bisque_get, SWIG_Lua_set_immutable }, - { "blanchedAlmond", _wrap_FloatColor_blanchedAlmond_get, SWIG_Lua_set_immutable }, - { "blueViolet", _wrap_FloatColor_blueViolet_get, SWIG_Lua_set_immutable }, - { "brown", _wrap_FloatColor_brown_get, SWIG_Lua_set_immutable }, - { "burlyWood", _wrap_FloatColor_burlyWood_get, SWIG_Lua_set_immutable }, - { "cadetBlue", _wrap_FloatColor_cadetBlue_get, SWIG_Lua_set_immutable }, - { "chartreuse", _wrap_FloatColor_chartreuse_get, SWIG_Lua_set_immutable }, - { "chocolate", _wrap_FloatColor_chocolate_get, SWIG_Lua_set_immutable }, - { "coral", _wrap_FloatColor_coral_get, SWIG_Lua_set_immutable }, - { "cornflowerBlue", _wrap_FloatColor_cornflowerBlue_get, SWIG_Lua_set_immutable }, - { "cornsilk", _wrap_FloatColor_cornsilk_get, SWIG_Lua_set_immutable }, - { "crimson", _wrap_FloatColor_crimson_get, SWIG_Lua_set_immutable }, - { "darkBlue", _wrap_FloatColor_darkBlue_get, SWIG_Lua_set_immutable }, - { "darkCyan", _wrap_FloatColor_darkCyan_get, SWIG_Lua_set_immutable }, - { "darkGoldenRod", _wrap_FloatColor_darkGoldenRod_get, SWIG_Lua_set_immutable }, - { "darkGray", _wrap_FloatColor_darkGray_get, SWIG_Lua_set_immutable }, - { "darkGrey", _wrap_FloatColor_darkGrey_get, SWIG_Lua_set_immutable }, - { "darkGreen", _wrap_FloatColor_darkGreen_get, SWIG_Lua_set_immutable }, - { "darkKhaki", _wrap_FloatColor_darkKhaki_get, SWIG_Lua_set_immutable }, - { "darkMagenta", _wrap_FloatColor_darkMagenta_get, SWIG_Lua_set_immutable }, - { "darkOliveGreen", _wrap_FloatColor_darkOliveGreen_get, SWIG_Lua_set_immutable }, - { "darkorange", _wrap_FloatColor_darkorange_get, SWIG_Lua_set_immutable }, - { "darkOrchid", _wrap_FloatColor_darkOrchid_get, SWIG_Lua_set_immutable }, - { "darkRed", _wrap_FloatColor_darkRed_get, SWIG_Lua_set_immutable }, - { "darkSalmon", _wrap_FloatColor_darkSalmon_get, SWIG_Lua_set_immutable }, - { "darkSeaGreen", _wrap_FloatColor_darkSeaGreen_get, SWIG_Lua_set_immutable }, - { "darkSlateBlue", _wrap_FloatColor_darkSlateBlue_get, SWIG_Lua_set_immutable }, - { "darkSlateGray", _wrap_FloatColor_darkSlateGray_get, SWIG_Lua_set_immutable }, - { "darkSlateGrey", _wrap_FloatColor_darkSlateGrey_get, SWIG_Lua_set_immutable }, - { "darkTurquoise", _wrap_FloatColor_darkTurquoise_get, SWIG_Lua_set_immutable }, - { "darkViolet", _wrap_FloatColor_darkViolet_get, SWIG_Lua_set_immutable }, - { "deepPink", _wrap_FloatColor_deepPink_get, SWIG_Lua_set_immutable }, - { "deepSkyBlue", _wrap_FloatColor_deepSkyBlue_get, SWIG_Lua_set_immutable }, - { "dimGray", _wrap_FloatColor_dimGray_get, SWIG_Lua_set_immutable }, - { "dimGrey", _wrap_FloatColor_dimGrey_get, SWIG_Lua_set_immutable }, - { "dodgerBlue", _wrap_FloatColor_dodgerBlue_get, SWIG_Lua_set_immutable }, - { "fireBrick", _wrap_FloatColor_fireBrick_get, SWIG_Lua_set_immutable }, - { "floralWhite", _wrap_FloatColor_floralWhite_get, SWIG_Lua_set_immutable }, - { "forestGreen", _wrap_FloatColor_forestGreen_get, SWIG_Lua_set_immutable }, - { "fuchsia", _wrap_FloatColor_fuchsia_get, SWIG_Lua_set_immutable }, - { "gainsboro", _wrap_FloatColor_gainsboro_get, SWIG_Lua_set_immutable }, - { "ghostWhite", _wrap_FloatColor_ghostWhite_get, SWIG_Lua_set_immutable }, - { "gold", _wrap_FloatColor_gold_get, SWIG_Lua_set_immutable }, - { "goldenRod", _wrap_FloatColor_goldenRod_get, SWIG_Lua_set_immutable }, - { "grey", _wrap_FloatColor_grey_get, SWIG_Lua_set_immutable }, - { "greenYellow", _wrap_FloatColor_greenYellow_get, SWIG_Lua_set_immutable }, - { "honeyDew", _wrap_FloatColor_honeyDew_get, SWIG_Lua_set_immutable }, - { "hotPink", _wrap_FloatColor_hotPink_get, SWIG_Lua_set_immutable }, - { "indianRed", _wrap_FloatColor_indianRed_get, SWIG_Lua_set_immutable }, - { "indigo", _wrap_FloatColor_indigo_get, SWIG_Lua_set_immutable }, - { "ivory", _wrap_FloatColor_ivory_get, SWIG_Lua_set_immutable }, - { "khaki", _wrap_FloatColor_khaki_get, SWIG_Lua_set_immutable }, - { "lavender", _wrap_FloatColor_lavender_get, SWIG_Lua_set_immutable }, - { "lavenderBlush", _wrap_FloatColor_lavenderBlush_get, SWIG_Lua_set_immutable }, - { "lawnGreen", _wrap_FloatColor_lawnGreen_get, SWIG_Lua_set_immutable }, - { "lemonChiffon", _wrap_FloatColor_lemonChiffon_get, SWIG_Lua_set_immutable }, - { "lightBlue", _wrap_FloatColor_lightBlue_get, SWIG_Lua_set_immutable }, - { "lightCoral", _wrap_FloatColor_lightCoral_get, SWIG_Lua_set_immutable }, - { "lightCyan", _wrap_FloatColor_lightCyan_get, SWIG_Lua_set_immutable }, - { "lightGoldenRodYellow", _wrap_FloatColor_lightGoldenRodYellow_get, SWIG_Lua_set_immutable }, - { "lightGray", _wrap_FloatColor_lightGray_get, SWIG_Lua_set_immutable }, - { "lightGrey", _wrap_FloatColor_lightGrey_get, SWIG_Lua_set_immutable }, - { "lightGreen", _wrap_FloatColor_lightGreen_get, SWIG_Lua_set_immutable }, - { "lightPink", _wrap_FloatColor_lightPink_get, SWIG_Lua_set_immutable }, - { "lightSalmon", _wrap_FloatColor_lightSalmon_get, SWIG_Lua_set_immutable }, - { "lightSeaGreen", _wrap_FloatColor_lightSeaGreen_get, SWIG_Lua_set_immutable }, - { "lightSkyBlue", _wrap_FloatColor_lightSkyBlue_get, SWIG_Lua_set_immutable }, - { "lightSlateGray", _wrap_FloatColor_lightSlateGray_get, SWIG_Lua_set_immutable }, - { "lightSlateGrey", _wrap_FloatColor_lightSlateGrey_get, SWIG_Lua_set_immutable }, - { "lightSteelBlue", _wrap_FloatColor_lightSteelBlue_get, SWIG_Lua_set_immutable }, - { "lightYellow", _wrap_FloatColor_lightYellow_get, SWIG_Lua_set_immutable }, - { "lime", _wrap_FloatColor_lime_get, SWIG_Lua_set_immutable }, - { "limeGreen", _wrap_FloatColor_limeGreen_get, SWIG_Lua_set_immutable }, - { "linen", _wrap_FloatColor_linen_get, SWIG_Lua_set_immutable }, - { "maroon", _wrap_FloatColor_maroon_get, SWIG_Lua_set_immutable }, - { "mediumAquaMarine", _wrap_FloatColor_mediumAquaMarine_get, SWIG_Lua_set_immutable }, - { "mediumBlue", _wrap_FloatColor_mediumBlue_get, SWIG_Lua_set_immutable }, - { "mediumOrchid", _wrap_FloatColor_mediumOrchid_get, SWIG_Lua_set_immutable }, - { "mediumPurple", _wrap_FloatColor_mediumPurple_get, SWIG_Lua_set_immutable }, - { "mediumSeaGreen", _wrap_FloatColor_mediumSeaGreen_get, SWIG_Lua_set_immutable }, - { "mediumSlateBlue", _wrap_FloatColor_mediumSlateBlue_get, SWIG_Lua_set_immutable }, - { "mediumSpringGreen", _wrap_FloatColor_mediumSpringGreen_get, SWIG_Lua_set_immutable }, - { "mediumTurquoise", _wrap_FloatColor_mediumTurquoise_get, SWIG_Lua_set_immutable }, - { "mediumVioletRed", _wrap_FloatColor_mediumVioletRed_get, SWIG_Lua_set_immutable }, - { "midnightBlue", _wrap_FloatColor_midnightBlue_get, SWIG_Lua_set_immutable }, - { "mintCream", _wrap_FloatColor_mintCream_get, SWIG_Lua_set_immutable }, - { "mistyRose", _wrap_FloatColor_mistyRose_get, SWIG_Lua_set_immutable }, - { "moccasin", _wrap_FloatColor_moccasin_get, SWIG_Lua_set_immutable }, - { "navajoWhite", _wrap_FloatColor_navajoWhite_get, SWIG_Lua_set_immutable }, - { "navy", _wrap_FloatColor_navy_get, SWIG_Lua_set_immutable }, - { "oldLace", _wrap_FloatColor_oldLace_get, SWIG_Lua_set_immutable }, - { "olive", _wrap_FloatColor_olive_get, SWIG_Lua_set_immutable }, - { "oliveDrab", _wrap_FloatColor_oliveDrab_get, SWIG_Lua_set_immutable }, - { "orange", _wrap_FloatColor_orange_get, SWIG_Lua_set_immutable }, - { "orangeRed", _wrap_FloatColor_orangeRed_get, SWIG_Lua_set_immutable }, - { "orchid", _wrap_FloatColor_orchid_get, SWIG_Lua_set_immutable }, - { "paleGoldenRod", _wrap_FloatColor_paleGoldenRod_get, SWIG_Lua_set_immutable }, - { "paleGreen", _wrap_FloatColor_paleGreen_get, SWIG_Lua_set_immutable }, - { "paleTurquoise", _wrap_FloatColor_paleTurquoise_get, SWIG_Lua_set_immutable }, - { "paleVioletRed", _wrap_FloatColor_paleVioletRed_get, SWIG_Lua_set_immutable }, - { "papayaWhip", _wrap_FloatColor_papayaWhip_get, SWIG_Lua_set_immutable }, - { "peachPuff", _wrap_FloatColor_peachPuff_get, SWIG_Lua_set_immutable }, - { "peru", _wrap_FloatColor_peru_get, SWIG_Lua_set_immutable }, - { "pink", _wrap_FloatColor_pink_get, SWIG_Lua_set_immutable }, - { "plum", _wrap_FloatColor_plum_get, SWIG_Lua_set_immutable }, - { "powderBlue", _wrap_FloatColor_powderBlue_get, SWIG_Lua_set_immutable }, - { "purple", _wrap_FloatColor_purple_get, SWIG_Lua_set_immutable }, - { "rosyBrown", _wrap_FloatColor_rosyBrown_get, SWIG_Lua_set_immutable }, - { "royalBlue", _wrap_FloatColor_royalBlue_get, SWIG_Lua_set_immutable }, - { "saddleBrown", _wrap_FloatColor_saddleBrown_get, SWIG_Lua_set_immutable }, - { "salmon", _wrap_FloatColor_salmon_get, SWIG_Lua_set_immutable }, - { "sandyBrown", _wrap_FloatColor_sandyBrown_get, SWIG_Lua_set_immutable }, - { "seaGreen", _wrap_FloatColor_seaGreen_get, SWIG_Lua_set_immutable }, - { "seaShell", _wrap_FloatColor_seaShell_get, SWIG_Lua_set_immutable }, - { "sienna", _wrap_FloatColor_sienna_get, SWIG_Lua_set_immutable }, - { "silver", _wrap_FloatColor_silver_get, SWIG_Lua_set_immutable }, - { "skyBlue", _wrap_FloatColor_skyBlue_get, SWIG_Lua_set_immutable }, - { "slateBlue", _wrap_FloatColor_slateBlue_get, SWIG_Lua_set_immutable }, - { "slateGray", _wrap_FloatColor_slateGray_get, SWIG_Lua_set_immutable }, - { "slateGrey", _wrap_FloatColor_slateGrey_get, SWIG_Lua_set_immutable }, - { "snow", _wrap_FloatColor_snow_get, SWIG_Lua_set_immutable }, - { "springGreen", _wrap_FloatColor_springGreen_get, SWIG_Lua_set_immutable }, - { "steelBlue", _wrap_FloatColor_steelBlue_get, SWIG_Lua_set_immutable }, - { "blueSteel", _wrap_FloatColor_blueSteel_get, SWIG_Lua_set_immutable }, - { "tan", _wrap_FloatColor_tan_get, SWIG_Lua_set_immutable }, - { "teal", _wrap_FloatColor_teal_get, SWIG_Lua_set_immutable }, - { "thistle", _wrap_FloatColor_thistle_get, SWIG_Lua_set_immutable }, - { "tomato", _wrap_FloatColor_tomato_get, SWIG_Lua_set_immutable }, - { "turquoise", _wrap_FloatColor_turquoise_get, SWIG_Lua_set_immutable }, - { "violet", _wrap_FloatColor_violet_get, SWIG_Lua_set_immutable }, - { "wheat", _wrap_FloatColor_wheat_get, SWIG_Lua_set_immutable }, - { "whiteSmoke", _wrap_FloatColor_whiteSmoke_get, SWIG_Lua_set_immutable }, - { "yellowGreen", _wrap_FloatColor_yellowGreen_get, SWIG_Lua_set_immutable }, - {0,0,0} -}; -static swig_lua_const_info swig_FloatColor_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_FloatColor_Sf_SwigStatic_methods[]= { - { "fromHsb", _wrap_FloatColor_fromHsb}, - { "fromHex", _wrap_FloatColor_fromHex}, - { "limit", _wrap_FloatColor_limit}, - {0,0} -}; -static swig_lua_class* swig_FloatColor_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_FloatColor_Sf_SwigStatic = { - "FloatColor", - swig_FloatColor_Sf_SwigStatic_methods, - swig_FloatColor_Sf_SwigStatic_attributes, - swig_FloatColor_Sf_SwigStatic_constants, - swig_FloatColor_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_FloatColor_bases[] = {0}; -static const char *swig_FloatColor_base_names[] = {0}; -static swig_lua_class _wrap_class_FloatColor = { "FloatColor", "FloatColor", &SWIGTYPE_p_ofColor_T_float_t,_proxy__wrap_new_FloatColor, swig_delete_FloatColor, swig_FloatColor_methods, swig_FloatColor_attributes, &swig_FloatColor_Sf_SwigStatic, swig_FloatColor_meta, swig_FloatColor_bases, swig_FloatColor_base_names }; - -static int _wrap_new_ShortColor__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::ofColor_",0,0) - result = (ofColor_< unsigned short > *)new ofColor_< unsigned short >(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_ShortColor__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - ofColor_< unsigned short > *result = 0 ; SWIG_check_num_args("ofColor_< unsigned short >::ofColor_",4,4) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::ofColor_",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::ofColor_",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< unsigned short >::ofColor_",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofColor_< unsigned short >::ofColor_",4,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - result = (ofColor_< unsigned short > *)new ofColor_< unsigned short >(arg1,arg2,arg3,arg4); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_ShortColor__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; - ofColor_< unsigned short > *result = 0 ; SWIG_check_num_args("ofColor_< unsigned short >::ofColor_",3,3) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::ofColor_",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::ofColor_",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< unsigned short >::ofColor_",3,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - result = (ofColor_< unsigned short > *)new ofColor_< unsigned short >(arg1,arg2,arg3); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_ShortColor__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; - ofColor_< unsigned short > *result = 0 ; SWIG_check_num_args("ofColor_< unsigned short >::ofColor_",2,2) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::ofColor_",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::ofColor_",2,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); result = (ofColor_< unsigned short > *)new ofColor_< unsigned short >(arg1,arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_ShortColor__SWIG_4(lua_State* L) { int SWIG_arg = 0; float arg1 ; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::ofColor_",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::ofColor_",1,"float"); arg1 = (float)lua_tonumber(L, 1); - result = (ofColor_< unsigned short > *)new ofColor_< unsigned short >(arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_ShortColor__SWIG_5(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *arg1 = 0 ; float arg2 ; - ofColor_< unsigned short > *result = 0 ; SWIG_check_num_args("ofColor_< unsigned short >::ofColor_",2,2) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::ofColor_",1,"ofColor_< unsigned short > const &"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::ofColor_",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("new_ShortColor",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } arg2 = (float)lua_tonumber(L, 2); - result = (ofColor_< unsigned short > *)new ofColor_< unsigned short >((ofColor_< unsigned short > const &)*arg1,arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_ShortColor(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_ShortColor__SWIG_0(L);} if (argc == 1) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { - return _wrap_new_ShortColor__SWIG_4(L);} } if (argc == 2) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_new_ShortColor__SWIG_5(L);} } } if (argc == 2) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_new_ShortColor__SWIG_3(L);} } } if (argc == 3) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_new_ShortColor__SWIG_2(L);} } } } if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_new_ShortColor__SWIG_1(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_ShortColor'\n" " Possible C/C++ prototypes are:\n" - " ofColor_< unsigned short >::ofColor_()\n" " ofColor_< unsigned short >::ofColor_(float,float,float,float)\n" - " ofColor_< unsigned short >::ofColor_(float,float,float)\n" " ofColor_< unsigned short >::ofColor_(float,float)\n" - " ofColor_< unsigned short >::ofColor_(float)\n" - " ofColor_< unsigned short >::ofColor_(ofColor_< unsigned short > const &,float)\n"); lua_error(L);return 0; } -static int _wrap_ShortColor_fromHsb__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; - float arg4 ; ofColor_< unsigned short > result; SWIG_check_num_args("ofColor_< unsigned short >::fromHsb",4,4) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::fromHsb",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::fromHsb",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< unsigned short >::fromHsb",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofColor_< unsigned short >::fromHsb",4,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - result = ofColor_< unsigned short >::SWIGTEMPLATEDISAMBIGUATOR fromHsb(arg1,arg2,arg3,arg4); { - ofColor_< unsigned short > * resultptr = new ofColor_< unsigned short >((const ofColor_< unsigned short > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_short_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_fromHsb__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; - ofColor_< unsigned short > result; SWIG_check_num_args("ofColor_< unsigned short >::fromHsb",3,3) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::fromHsb",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::fromHsb",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< unsigned short >::fromHsb",3,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - result = ofColor_< unsigned short >::SWIGTEMPLATEDISAMBIGUATOR fromHsb(arg1,arg2,arg3); { - ofColor_< unsigned short > * resultptr = new ofColor_< unsigned short >((const ofColor_< unsigned short > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_short_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_fromHsb(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_ShortColor_fromHsb__SWIG_1(L);} } } } if (argc == 4) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { - return _wrap_ShortColor_fromHsb__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortColor_fromHsb'\n" " Possible C/C++ prototypes are:\n" - " ofColor_< unsigned short >::fromHsb(float,float,float,float)\n" - " ofColor_< unsigned short >::fromHsb(float,float,float)\n"); lua_error(L);return 0; } -static int _wrap_ShortColor_fromHex__SWIG_0(lua_State* L) { int SWIG_arg = 0; int arg1 ; float arg2 ; - ofColor_< unsigned short > result; SWIG_check_num_args("ofColor_< unsigned short >::fromHex",2,2) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::fromHex",1,"int"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::fromHex",2,"float"); arg1 = (int)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); result = ofColor_< unsigned short >::SWIGTEMPLATEDISAMBIGUATOR fromHex(arg1,arg2); { - ofColor_< unsigned short > * resultptr = new ofColor_< unsigned short >((const ofColor_< unsigned short > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_short_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_fromHex__SWIG_1(lua_State* L) { int SWIG_arg = 0; int arg1 ; ofColor_< unsigned short > result; - SWIG_check_num_args("ofColor_< unsigned short >::fromHex",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::fromHex",1,"int"); arg1 = (int)lua_tonumber(L, 1); - result = ofColor_< unsigned short >::SWIGTEMPLATEDISAMBIGUATOR fromHex(arg1); { - ofColor_< unsigned short > * resultptr = new ofColor_< unsigned short >((const ofColor_< unsigned short > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_short_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_fromHex(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_ShortColor_fromHex__SWIG_1(L);} } if (argc == 2) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_ShortColor_fromHex__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortColor_fromHex'\n" " Possible C/C++ prototypes are:\n" - " ofColor_< unsigned short >::fromHex(int,float)\n" " ofColor_< unsigned short >::fromHex(int)\n"); - lua_error(L);return 0; } -static int _wrap_ShortColor_set__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; float arg2 ; float arg3 ; float arg4 ; float arg5 ; - SWIG_check_num_args("ofColor_< unsigned short >::set",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::set",1,"ofColor_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< unsigned short >::set",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofColor_< unsigned short >::set",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofColor_< unsigned short >::set",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_set",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - (arg1)->set(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_set__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; float arg2 ; float arg3 ; float arg4 ; - SWIG_check_num_args("ofColor_< unsigned short >::set",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::set",1,"ofColor_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< unsigned short >::set",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofColor_< unsigned short >::set",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_set",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); (arg1)->set(arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_set__SWIG_2(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofColor_< unsigned short >::set",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::set",1,"ofColor_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< unsigned short >::set",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_set",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->set(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortColor_set__SWIG_3(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; float arg2 ; - SWIG_check_num_args("ofColor_< unsigned short >::set",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::set",1,"ofColor_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::set",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_set",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->set(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_set__SWIG_4(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; ofColor_< unsigned short > *arg2 = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::set",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::set",1,"ofColor_< unsigned short > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::set",2,"ofColor_< unsigned short > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_set",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_set",2,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - (arg1)->set((ofColor_< unsigned short > const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortColor_set(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_ShortColor_set__SWIG_4(L);} } } if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_ShortColor_set__SWIG_3(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_ShortColor_set__SWIG_2(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_ShortColor_set__SWIG_1(L);} } } } } - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_ShortColor_set__SWIG_0(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortColor_set'\n" " Possible C/C++ prototypes are:\n" - " ofColor_< unsigned short >::set(float,float,float,float)\n" " ofColor_< unsigned short >::set(float,float,float)\n" - " ofColor_< unsigned short >::set(float,float)\n" " ofColor_< unsigned short >::set(float)\n" - " ofColor_< unsigned short >::set(ofColor_< unsigned short > const &)\n"); lua_error(L);return 0; } -static int _wrap_ShortColor_setHex__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; int arg2 ; float arg3 ; - SWIG_check_num_args("ofColor_< unsigned short >::setHex",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::setHex",1,"ofColor_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::setHex",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< unsigned short >::setHex",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_setHex",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->setHex(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortColor_setHex__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; int arg2 ; - SWIG_check_num_args("ofColor_< unsigned short >::setHex",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::setHex",1,"ofColor_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::setHex",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_setHex",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->setHex(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_setHex(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_ShortColor_setHex__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_ShortColor_setHex__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortColor_setHex'\n" " Possible C/C++ prototypes are:\n" - " ofColor_< unsigned short >::setHex(int,float)\n" " ofColor_< unsigned short >::setHex(int)\n"); - lua_error(L);return 0; } -static int _wrap_ShortColor_setHue(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; float arg2 ; - SWIG_check_num_args("ofColor_< unsigned short >::setHue",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::setHue",1,"ofColor_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::setHue",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_setHue",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setHue(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_setHueAngle(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; float arg2 ; - SWIG_check_num_args("ofColor_< unsigned short >::setHueAngle",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::setHueAngle",1,"ofColor_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::setHueAngle",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_setHueAngle",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setHueAngle(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_setSaturation(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; float arg2 ; - SWIG_check_num_args("ofColor_< unsigned short >::setSaturation",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::setSaturation",1,"ofColor_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::setSaturation",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_setSaturation",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setSaturation(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_setBrightness(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; float arg2 ; - SWIG_check_num_args("ofColor_< unsigned short >::setBrightness",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::setBrightness",1,"ofColor_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::setBrightness",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_setBrightness",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setBrightness(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_setHsb__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; float arg2 ; float arg3 ; float arg4 ; float arg5 ; - SWIG_check_num_args("ofColor_< unsigned short >::setHsb",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::setHsb",1,"ofColor_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::setHsb",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< unsigned short >::setHsb",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofColor_< unsigned short >::setHsb",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofColor_< unsigned short >::setHsb",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_setHsb",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - (arg1)->setHsb(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_setHsb__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; float arg2 ; float arg3 ; float arg4 ; - SWIG_check_num_args("ofColor_< unsigned short >::setHsb",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::setHsb",1,"ofColor_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::setHsb",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< unsigned short >::setHsb",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofColor_< unsigned short >::setHsb",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_setHsb",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); (arg1)->setHsb(arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_setHsb(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 4) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_ShortColor_setHsb__SWIG_1(L);} } } } } - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_ShortColor_setHsb__SWIG_0(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortColor_setHsb'\n" " Possible C/C++ prototypes are:\n" - " ofColor_< unsigned short >::setHsb(float,float,float,float)\n" - " ofColor_< unsigned short >::setHsb(float,float,float)\n"); lua_error(L);return 0; } -static int _wrap_ShortColor_clamp(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::clamp",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::clamp",1,"ofColor_< unsigned short > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_clamp",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - result = (ofColor_< unsigned short > *) &(arg1)->clamp(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_invert(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::invert",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::invert",1,"ofColor_< unsigned short > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_invert",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - result = (ofColor_< unsigned short > *) &(arg1)->invert(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_normalize(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::normalize",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::normalize",1,"ofColor_< unsigned short > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_normalize",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - result = (ofColor_< unsigned short > *) &(arg1)->normalize(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_lerp(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; ofColor_< unsigned short > *arg2 = 0 ; float arg3 ; - ofColor_< unsigned short > *result = 0 ; SWIG_check_num_args("ofColor_< unsigned short >::lerp",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::lerp",1,"ofColor_< unsigned short > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::lerp",2,"ofColor_< unsigned short > const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< unsigned short >::lerp",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_lerp",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_lerp",2,SWIGTYPE_p_ofColor_T_unsigned_short_t); } arg3 = (float)lua_tonumber(L, 3); - result = (ofColor_< unsigned short > *) &(arg1)->lerp((ofColor_< unsigned short > const &)*arg2,arg3); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_getClamped(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; ofColor_< unsigned short > result; - SWIG_check_num_args("ofColor_< unsigned short >::getClamped",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::getClamped",1,"ofColor_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_getClamped",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - result = ((ofColor_< unsigned short > const *)arg1)->getClamped(); { - ofColor_< unsigned short > * resultptr = new ofColor_< unsigned short >((const ofColor_< unsigned short > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_short_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_getInverted(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; ofColor_< unsigned short > result; - SWIG_check_num_args("ofColor_< unsigned short >::getInverted",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::getInverted",1,"ofColor_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_getInverted",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - result = ((ofColor_< unsigned short > const *)arg1)->getInverted(); { - ofColor_< unsigned short > * resultptr = new ofColor_< unsigned short >((const ofColor_< unsigned short > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_short_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_getNormalized(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; ofColor_< unsigned short > result; - SWIG_check_num_args("ofColor_< unsigned short >::getNormalized",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::getNormalized",1,"ofColor_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_getNormalized",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - result = ((ofColor_< unsigned short > const *)arg1)->getNormalized(); { - ofColor_< unsigned short > * resultptr = new ofColor_< unsigned short >((const ofColor_< unsigned short > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_short_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_getLerped(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; ofColor_< unsigned short > *arg2 = 0 ; float arg3 ; - ofColor_< unsigned short > result; SWIG_check_num_args("ofColor_< unsigned short >::getLerped",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::getLerped",1,"ofColor_< unsigned short > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::getLerped",2,"ofColor_< unsigned short > const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< unsigned short >::getLerped",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_getLerped",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_getLerped",2,SWIGTYPE_p_ofColor_T_unsigned_short_t); } arg3 = (float)lua_tonumber(L, 3); - result = ((ofColor_< unsigned short > const *)arg1)->getLerped((ofColor_< unsigned short > const &)*arg2,arg3); { - ofColor_< unsigned short > * resultptr = new ofColor_< unsigned short >((const ofColor_< unsigned short > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_short_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_getHex(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; int result; - SWIG_check_num_args("ofColor_< unsigned short >::getHex",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::getHex",1,"ofColor_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_getHex",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - result = (int)((ofColor_< unsigned short > const *)arg1)->getHex(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_getHue(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; float result; - SWIG_check_num_args("ofColor_< unsigned short >::getHue",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::getHue",1,"ofColor_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_getHue",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - result = (float)((ofColor_< unsigned short > const *)arg1)->getHue(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_getHueAngle(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; float result; - SWIG_check_num_args("ofColor_< unsigned short >::getHueAngle",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::getHueAngle",1,"ofColor_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_getHueAngle",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - result = (float)((ofColor_< unsigned short > const *)arg1)->getHueAngle(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_getSaturation(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; float result; - SWIG_check_num_args("ofColor_< unsigned short >::getSaturation",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::getSaturation",1,"ofColor_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_getSaturation",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - result = (float)((ofColor_< unsigned short > const *)arg1)->getSaturation(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_getBrightness(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; float result; - SWIG_check_num_args("ofColor_< unsigned short >::getBrightness",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::getBrightness",1,"ofColor_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_getBrightness",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - result = (float)((ofColor_< unsigned short > const *)arg1)->getBrightness(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_getLightness(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; float result; - SWIG_check_num_args("ofColor_< unsigned short >::getLightness",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::getLightness",1,"ofColor_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_getLightness",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - result = (float)((ofColor_< unsigned short > const *)arg1)->getLightness(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_getHsb(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; float *arg2 = 0 ; float *arg3 = 0 ; float *arg4 = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::getHsb",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::getHsb",1,"ofColor_< unsigned short > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::getHsb",2,"float &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofColor_< unsigned short >::getHsb",3,"float &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofColor_< unsigned short >::getHsb",4,"float &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_getHsb",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("ShortColor_getHsb",2,SWIGTYPE_p_float); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("ShortColor_getHsb",3,SWIGTYPE_p_float); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("ShortColor_getHsb",4,SWIGTYPE_p_float); } - ((ofColor_< unsigned short > const *)arg1)->getHsb(*arg2,*arg3,*arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortColor_limit(lua_State* L) { int SWIG_arg = 0; float result; - SWIG_check_num_args("ofColor_< unsigned short >::limit",0,0) - result = (float)ofColor_< unsigned short >::SWIGTEMPLATEDISAMBIGUATOR limit(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor___eq(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; ofColor_< unsigned short > *arg2 = 0 ; bool result; - SWIG_check_num_args("ofColor_< unsigned short >::operator ==",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::operator ==",1,"ofColor_< unsigned short > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::operator ==",2,"ofColor_< unsigned short > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor___eq",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor___eq",2,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - result = (bool)((ofColor_< unsigned short > const *)arg1)->operator ==((ofColor_< unsigned short > const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor___add__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; ofColor_< unsigned short > *arg2 = 0 ; - ofColor_< unsigned short > result; SWIG_check_num_args("ofColor_< unsigned short >::operator +",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::operator +",1,"ofColor_< unsigned short > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::operator +",2,"ofColor_< unsigned short > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor___add",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor___add",2,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - result = ((ofColor_< unsigned short > const *)arg1)->operator +((ofColor_< unsigned short > const &)*arg2); { - ofColor_< unsigned short > * resultptr = new ofColor_< unsigned short >((const ofColor_< unsigned short > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_short_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor___add__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; float *arg2 = 0 ; float temp2 ; - ofColor_< unsigned short > result; SWIG_check_num_args("ofColor_< unsigned short >::operator +",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::operator +",1,"ofColor_< unsigned short > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::operator +",2,"float const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor___add",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } temp2=(float)lua_tonumber(L,2); arg2=&temp2; - result = ((ofColor_< unsigned short > const *)arg1)->operator +((float const &)*arg2); { - ofColor_< unsigned short > * resultptr = new ofColor_< unsigned short >((const ofColor_< unsigned short > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_short_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor___add(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_ShortColor___add__SWIG_0(L);} } } if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_ShortColor___add__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortColor___add'\n" " Possible C/C++ prototypes are:\n" - " ofColor_< unsigned short >::operator +(ofColor_< unsigned short > const &) const\n" - " ofColor_< unsigned short >::operator +(float const &) const\n"); lua_error(L);return 0; } -static int _wrap_ShortColor___sub__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; ofColor_< unsigned short > *arg2 = 0 ; - ofColor_< unsigned short > result; SWIG_check_num_args("ofColor_< unsigned short >::operator -",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::operator -",1,"ofColor_< unsigned short > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::operator -",2,"ofColor_< unsigned short > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor___sub",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor___sub",2,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - result = ((ofColor_< unsigned short > const *)arg1)->operator -((ofColor_< unsigned short > const &)*arg2); { - ofColor_< unsigned short > * resultptr = new ofColor_< unsigned short >((const ofColor_< unsigned short > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_short_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor___sub__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; float *arg2 = 0 ; float temp2 ; - ofColor_< unsigned short > result; SWIG_check_num_args("ofColor_< unsigned short >::operator -",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::operator -",1,"ofColor_< unsigned short > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::operator -",2,"float const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor___sub",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } temp2=(float)lua_tonumber(L,2); arg2=&temp2; - result = ((ofColor_< unsigned short > const *)arg1)->operator -((float const &)*arg2); { - ofColor_< unsigned short > * resultptr = new ofColor_< unsigned short >((const ofColor_< unsigned short > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_short_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor___sub(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_ShortColor___sub__SWIG_0(L);} } } if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_ShortColor___sub__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortColor___sub'\n" " Possible C/C++ prototypes are:\n" - " ofColor_< unsigned short >::operator -(ofColor_< unsigned short > const &) const\n" - " ofColor_< unsigned short >::operator -(float const &) const\n"); lua_error(L);return 0; } -static int _wrap_ShortColor___mul__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; ofColor_< unsigned short > *arg2 = 0 ; - ofColor_< unsigned short > result; SWIG_check_num_args("ofColor_< unsigned short >::operator *",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::operator *",1,"ofColor_< unsigned short > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::operator *",2,"ofColor_< unsigned short > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor___mul",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor___mul",2,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - result = ((ofColor_< unsigned short > const *)arg1)->operator *((ofColor_< unsigned short > const &)*arg2); { - ofColor_< unsigned short > * resultptr = new ofColor_< unsigned short >((const ofColor_< unsigned short > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_short_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor___mul__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; float *arg2 = 0 ; float temp2 ; - ofColor_< unsigned short > result; SWIG_check_num_args("ofColor_< unsigned short >::operator *",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::operator *",1,"ofColor_< unsigned short > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::operator *",2,"float const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor___mul",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } temp2=(float)lua_tonumber(L,2); arg2=&temp2; - result = ((ofColor_< unsigned short > const *)arg1)->operator *((float const &)*arg2); { - ofColor_< unsigned short > * resultptr = new ofColor_< unsigned short >((const ofColor_< unsigned short > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_short_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor___mul(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_ShortColor___mul__SWIG_0(L);} } } if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_ShortColor___mul__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortColor___mul'\n" " Possible C/C++ prototypes are:\n" - " ofColor_< unsigned short >::operator *(ofColor_< unsigned short > const &) const\n" - " ofColor_< unsigned short >::operator *(float const &) const\n"); lua_error(L);return 0; } -static int _wrap_ShortColor___div__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; ofColor_< unsigned short > *arg2 = 0 ; - ofColor_< unsigned short > result; SWIG_check_num_args("ofColor_< unsigned short >::operator /",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::operator /",1,"ofColor_< unsigned short > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::operator /",2,"ofColor_< unsigned short > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor___div",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor___div",2,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - result = ((ofColor_< unsigned short > const *)arg1)->operator /((ofColor_< unsigned short > const &)*arg2); { - ofColor_< unsigned short > * resultptr = new ofColor_< unsigned short >((const ofColor_< unsigned short > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_short_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor___div__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; float *arg2 = 0 ; float temp2 ; - ofColor_< unsigned short > result; SWIG_check_num_args("ofColor_< unsigned short >::operator /",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::operator /",1,"ofColor_< unsigned short > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::operator /",2,"float const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor___div",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } temp2=(float)lua_tonumber(L,2); arg2=&temp2; - result = ((ofColor_< unsigned short > const *)arg1)->operator /((float const &)*arg2); { - ofColor_< unsigned short > * resultptr = new ofColor_< unsigned short >((const ofColor_< unsigned short > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_short_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor___div(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_ShortColor___div__SWIG_0(L);} } } if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_ShortColor___div__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortColor___div'\n" " Possible C/C++ prototypes are:\n" - " ofColor_< unsigned short >::operator /(ofColor_< unsigned short > const &) const\n" - " ofColor_< unsigned short >::operator /(float const &) const\n"); lua_error(L);return 0; } -static int _wrap_ShortColor_white_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::white",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::white; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_gray_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::gray",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::gray; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_black_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::black",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::black; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_red_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::red",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::red; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_green_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::green",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::green; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_blue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::blue",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::blue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_cyan_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::cyan",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::cyan; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_magenta_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::magenta",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::magenta; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_yellow_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::yellow",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::yellow; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_aliceBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::aliceBlue",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::aliceBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_antiqueWhite_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::antiqueWhite",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::antiqueWhite; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_aqua_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::aqua",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::aqua; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_aquamarine_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::aquamarine",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::aquamarine; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_azure_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::azure",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::azure; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_beige_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::beige",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::beige; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_bisque_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::bisque",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::bisque; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_blanchedAlmond_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::blanchedAlmond",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::blanchedAlmond; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_blueViolet_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::blueViolet",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::blueViolet; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_brown_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::brown",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::brown; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_burlyWood_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::burlyWood",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::burlyWood; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_cadetBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::cadetBlue",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::cadetBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_chartreuse_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::chartreuse",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::chartreuse; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_chocolate_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::chocolate",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::chocolate; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_coral_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::coral",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::coral; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_cornflowerBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::cornflowerBlue",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::cornflowerBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_cornsilk_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::cornsilk",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::cornsilk; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_crimson_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::crimson",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::crimson; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_darkBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::darkBlue",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::darkBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_darkCyan_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::darkCyan",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::darkCyan; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_darkGoldenRod_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::darkGoldenRod",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::darkGoldenRod; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_darkGray_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::darkGray",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::darkGray; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_darkGrey_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::darkGrey",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::darkGrey; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_darkGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::darkGreen",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::darkGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_darkKhaki_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::darkKhaki",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::darkKhaki; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_darkMagenta_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::darkMagenta",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::darkMagenta; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_darkOliveGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::darkOliveGreen",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::darkOliveGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_darkorange_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::darkorange",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::darkorange; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_darkOrchid_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::darkOrchid",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::darkOrchid; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_darkRed_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::darkRed",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::darkRed; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_darkSalmon_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::darkSalmon",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::darkSalmon; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_darkSeaGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::darkSeaGreen",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::darkSeaGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_darkSlateBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::darkSlateBlue",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::darkSlateBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_darkSlateGray_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::darkSlateGray",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::darkSlateGray; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_darkSlateGrey_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::darkSlateGrey",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::darkSlateGrey; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_darkTurquoise_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::darkTurquoise",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::darkTurquoise; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_darkViolet_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::darkViolet",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::darkViolet; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_deepPink_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::deepPink",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::deepPink; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_deepSkyBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::deepSkyBlue",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::deepSkyBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_dimGray_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::dimGray",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::dimGray; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_dimGrey_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::dimGrey",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::dimGrey; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_dodgerBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::dodgerBlue",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::dodgerBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_fireBrick_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::fireBrick",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::fireBrick; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_floralWhite_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::floralWhite",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::floralWhite; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_forestGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::forestGreen",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::forestGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_fuchsia_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::fuchsia",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::fuchsia; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_gainsboro_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::gainsboro",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::gainsboro; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_ghostWhite_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::ghostWhite",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::ghostWhite; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_gold_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::gold",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::gold; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_goldenRod_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::goldenRod",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::goldenRod; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_grey_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::grey",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::grey; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_greenYellow_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::greenYellow",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::greenYellow; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_honeyDew_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::honeyDew",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::honeyDew; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_hotPink_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::hotPink",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::hotPink; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_indianRed_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::indianRed",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::indianRed; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_indigo_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::indigo",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::indigo; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_ivory_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::ivory",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::ivory; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_khaki_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::khaki",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::khaki; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_lavender_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::lavender",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::lavender; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_lavenderBlush_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::lavenderBlush",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::lavenderBlush; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_lawnGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::lawnGreen",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::lawnGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_lemonChiffon_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::lemonChiffon",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::lemonChiffon; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_lightBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::lightBlue",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::lightBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_lightCoral_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::lightCoral",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::lightCoral; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_lightCyan_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::lightCyan",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::lightCyan; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_lightGoldenRodYellow_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::lightGoldenRodYellow",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::lightGoldenRodYellow; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_lightGray_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::lightGray",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::lightGray; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_lightGrey_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::lightGrey",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::lightGrey; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_lightGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::lightGreen",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::lightGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_lightPink_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::lightPink",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::lightPink; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_lightSalmon_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::lightSalmon",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::lightSalmon; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_lightSeaGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::lightSeaGreen",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::lightSeaGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_lightSkyBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::lightSkyBlue",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::lightSkyBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_lightSlateGray_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::lightSlateGray",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::lightSlateGray; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_lightSlateGrey_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::lightSlateGrey",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::lightSlateGrey; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_lightSteelBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::lightSteelBlue",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::lightSteelBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_lightYellow_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::lightYellow",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::lightYellow; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_lime_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::lime",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::lime; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_limeGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::limeGreen",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::limeGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_linen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::linen",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::linen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_maroon_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::maroon",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::maroon; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_mediumAquaMarine_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::mediumAquaMarine",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::mediumAquaMarine; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_mediumBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::mediumBlue",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::mediumBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_mediumOrchid_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::mediumOrchid",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::mediumOrchid; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_mediumPurple_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::mediumPurple",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::mediumPurple; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_mediumSeaGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::mediumSeaGreen",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::mediumSeaGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_mediumSlateBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::mediumSlateBlue",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::mediumSlateBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_mediumSpringGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::mediumSpringGreen",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::mediumSpringGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_mediumTurquoise_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::mediumTurquoise",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::mediumTurquoise; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_mediumVioletRed_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::mediumVioletRed",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::mediumVioletRed; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_midnightBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::midnightBlue",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::midnightBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_mintCream_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::mintCream",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::mintCream; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_mistyRose_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::mistyRose",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::mistyRose; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_moccasin_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::moccasin",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::moccasin; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_navajoWhite_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::navajoWhite",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::navajoWhite; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_navy_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::navy",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::navy; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_oldLace_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::oldLace",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::oldLace; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_olive_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::olive",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::olive; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_oliveDrab_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::oliveDrab",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::oliveDrab; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_orange_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::orange",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::orange; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_orangeRed_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::orangeRed",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::orangeRed; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_orchid_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::orchid",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::orchid; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_paleGoldenRod_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::paleGoldenRod",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::paleGoldenRod; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_paleGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::paleGreen",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::paleGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_paleTurquoise_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::paleTurquoise",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::paleTurquoise; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_paleVioletRed_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::paleVioletRed",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::paleVioletRed; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_papayaWhip_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::papayaWhip",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::papayaWhip; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_peachPuff_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::peachPuff",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::peachPuff; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_peru_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::peru",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::peru; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_pink_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::pink",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::pink; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_plum_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::plum",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::plum; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_powderBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::powderBlue",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::powderBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_purple_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::purple",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::purple; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_rosyBrown_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::rosyBrown",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::rosyBrown; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_royalBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::royalBlue",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::royalBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_saddleBrown_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::saddleBrown",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::saddleBrown; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_salmon_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::salmon",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::salmon; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_sandyBrown_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::sandyBrown",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::sandyBrown; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_seaGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::seaGreen",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::seaGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_seaShell_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::seaShell",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::seaShell; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_sienna_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::sienna",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::sienna; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_silver_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::silver",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::silver; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_skyBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::skyBlue",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::skyBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_slateBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::slateBlue",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::slateBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_slateGray_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::slateGray",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::slateGray; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_slateGrey_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::slateGrey",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::slateGrey; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_snow_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::snow",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::snow; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_springGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::springGreen",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::springGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_steelBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::steelBlue",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::steelBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_blueSteel_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::blueSteel",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::blueSteel; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_tan_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::tan",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::tan; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_teal_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::teal",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::teal; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_thistle_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::thistle",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::thistle; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_tomato_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::tomato",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::tomato; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_turquoise_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::turquoise",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::turquoise; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_violet_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::violet",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::violet; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_wheat_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::wheat",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::wheat; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_whiteSmoke_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::whiteSmoke",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::whiteSmoke; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_yellowGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::yellowGreen",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::yellowGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_getR(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; unsigned short result; - SWIG_check_num_args("ofColor_< unsigned short >::getR",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::getR",1,"ofColor_< unsigned short > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_getR",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - result = (unsigned short)ofColor__Sl_unsigned_SS_short_Sg__getR(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_getG(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; unsigned short result; - SWIG_check_num_args("ofColor_< unsigned short >::getG",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::getG",1,"ofColor_< unsigned short > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_getG",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - result = (unsigned short)ofColor__Sl_unsigned_SS_short_Sg__getG(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_getB(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; unsigned short result; - SWIG_check_num_args("ofColor_< unsigned short >::getB",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::getB",1,"ofColor_< unsigned short > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_getB",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - result = (unsigned short)ofColor__Sl_unsigned_SS_short_Sg__getB(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_getA(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; unsigned short result; - SWIG_check_num_args("ofColor_< unsigned short >::getA",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::getA",1,"ofColor_< unsigned short > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_getA",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - result = (unsigned short)ofColor__Sl_unsigned_SS_short_Sg__getA(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_setR(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; unsigned short arg2 ; - SWIG_check_num_args("ofColor_< unsigned short >::setR",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::setR",1,"ofColor_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::setR",2,"unsigned short"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_setR",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned short)lua_tonumber(L, 2); - ofColor__Sl_unsigned_SS_short_Sg__setR(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_setG(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; unsigned short arg2 ; - SWIG_check_num_args("ofColor_< unsigned short >::setG",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::setG",1,"ofColor_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::setG",2,"unsigned short"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_setG",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned short)lua_tonumber(L, 2); - ofColor__Sl_unsigned_SS_short_Sg__setG(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_setB(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; unsigned short arg2 ; - SWIG_check_num_args("ofColor_< unsigned short >::setB",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::setB",1,"ofColor_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::setB",2,"unsigned short"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_setB",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned short)lua_tonumber(L, 2); - ofColor__Sl_unsigned_SS_short_Sg__setB(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_setA(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; unsigned short arg2 ; - SWIG_check_num_args("ofColor_< unsigned short >::setA",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::setA",1,"ofColor_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::setA",2,"unsigned short"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_setA",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned short)lua_tonumber(L, 2); - ofColor__Sl_unsigned_SS_short_Sg__setA(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor___tostring(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; char *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::__str__",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::__str__",1,"ofColor_< unsigned short > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor___tostring",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - result = (char *)ofColor__Sl_unsigned_SS_short_Sg____str__(arg1); lua_pushstring(L,(const char *)result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_r_set(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; unsigned short arg2 ; - SWIG_check_num_args("ofColor_< unsigned short >::r",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::r",1,"ofColor_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::r",2,"unsigned short"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_r_set",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned short)lua_tonumber(L, 2); - ofColor__Sl_unsigned_SS_short_Sg__r_set(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_r_get(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; unsigned short result; - SWIG_check_num_args("ofColor_< unsigned short >::r",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::r",1,"ofColor_< unsigned short > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_r_get",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - result = (unsigned short)ofColor__Sl_unsigned_SS_short_Sg__r_get(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_g_set(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; unsigned short arg2 ; - SWIG_check_num_args("ofColor_< unsigned short >::g",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::g",1,"ofColor_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::g",2,"unsigned short"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_g_set",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned short)lua_tonumber(L, 2); - ofColor__Sl_unsigned_SS_short_Sg__g_set(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_g_get(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; unsigned short result; - SWIG_check_num_args("ofColor_< unsigned short >::g",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::g",1,"ofColor_< unsigned short > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_g_get",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - result = (unsigned short)ofColor__Sl_unsigned_SS_short_Sg__g_get(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_b_set(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; unsigned short arg2 ; - SWIG_check_num_args("ofColor_< unsigned short >::b",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::b",1,"ofColor_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::b",2,"unsigned short"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_b_set",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned short)lua_tonumber(L, 2); - ofColor__Sl_unsigned_SS_short_Sg__b_set(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_b_get(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; unsigned short result; - SWIG_check_num_args("ofColor_< unsigned short >::b",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::b",1,"ofColor_< unsigned short > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_b_get",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - result = (unsigned short)ofColor__Sl_unsigned_SS_short_Sg__b_get(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_a_set(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; unsigned short arg2 ; - SWIG_check_num_args("ofColor_< unsigned short >::a",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::a",1,"ofColor_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::a",2,"unsigned short"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_a_set",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned short)lua_tonumber(L, 2); - ofColor__Sl_unsigned_SS_short_Sg__a_set(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_a_get(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; unsigned short result; - SWIG_check_num_args("ofColor_< unsigned short >::a",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::a",1,"ofColor_< unsigned short > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_a_get",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - result = (unsigned short)ofColor__Sl_unsigned_SS_short_Sg__a_get(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_ShortColor(void *obj) { -ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) obj; -delete arg1; -} -static int _proxy__wrap_new_ShortColor(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_ShortColor); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_ShortColor_attributes[] = { - { "r", _wrap_ShortColor_r_get, _wrap_ShortColor_r_set }, - { "g", _wrap_ShortColor_g_get, _wrap_ShortColor_g_set }, - { "b", _wrap_ShortColor_b_get, _wrap_ShortColor_b_set }, - { "a", _wrap_ShortColor_a_get, _wrap_ShortColor_a_set }, - {0,0,0} -}; -static swig_lua_method swig_ShortColor_methods[]= { - { "set", _wrap_ShortColor_set}, - { "setHex", _wrap_ShortColor_setHex}, - { "setHue", _wrap_ShortColor_setHue}, - { "setHueAngle", _wrap_ShortColor_setHueAngle}, - { "setSaturation", _wrap_ShortColor_setSaturation}, - { "setBrightness", _wrap_ShortColor_setBrightness}, - { "setHsb", _wrap_ShortColor_setHsb}, - { "clamp", _wrap_ShortColor_clamp}, - { "invert", _wrap_ShortColor_invert}, - { "normalize", _wrap_ShortColor_normalize}, - { "lerp", _wrap_ShortColor_lerp}, - { "getClamped", _wrap_ShortColor_getClamped}, - { "getInverted", _wrap_ShortColor_getInverted}, - { "getNormalized", _wrap_ShortColor_getNormalized}, - { "getLerped", _wrap_ShortColor_getLerped}, - { "getHex", _wrap_ShortColor_getHex}, - { "getHue", _wrap_ShortColor_getHue}, - { "getHueAngle", _wrap_ShortColor_getHueAngle}, - { "getSaturation", _wrap_ShortColor_getSaturation}, - { "getBrightness", _wrap_ShortColor_getBrightness}, - { "getLightness", _wrap_ShortColor_getLightness}, - { "getHsb", _wrap_ShortColor_getHsb}, - { "__eq", _wrap_ShortColor___eq}, - { "__add", _wrap_ShortColor___add}, - { "__sub", _wrap_ShortColor___sub}, - { "__mul", _wrap_ShortColor___mul}, - { "__div", _wrap_ShortColor___div}, - { "getR", _wrap_ShortColor_getR}, - { "getG", _wrap_ShortColor_getG}, - { "getB", _wrap_ShortColor_getB}, - { "getA", _wrap_ShortColor_getA}, - { "setR", _wrap_ShortColor_setR}, - { "setG", _wrap_ShortColor_setG}, - { "setB", _wrap_ShortColor_setB}, - { "setA", _wrap_ShortColor_setA}, - { "__tostring", _wrap_ShortColor___tostring}, - {0,0} -}; -static swig_lua_method swig_ShortColor_meta[] = { - { "__eq", _wrap_ShortColor___eq}, - { "__add", _wrap_ShortColor___add}, - { "__sub", _wrap_ShortColor___sub}, - { "__mul", _wrap_ShortColor___mul}, - { "__div", _wrap_ShortColor___div}, - { "__tostring", _wrap_ShortColor___tostring}, - {0,0} -}; - -static swig_lua_attribute swig_ShortColor_Sf_SwigStatic_attributes[] = { - { "white", _wrap_ShortColor_white_get, SWIG_Lua_set_immutable }, - { "gray", _wrap_ShortColor_gray_get, SWIG_Lua_set_immutable }, - { "black", _wrap_ShortColor_black_get, SWIG_Lua_set_immutable }, - { "red", _wrap_ShortColor_red_get, SWIG_Lua_set_immutable }, - { "green", _wrap_ShortColor_green_get, SWIG_Lua_set_immutable }, - { "blue", _wrap_ShortColor_blue_get, SWIG_Lua_set_immutable }, - { "cyan", _wrap_ShortColor_cyan_get, SWIG_Lua_set_immutable }, - { "magenta", _wrap_ShortColor_magenta_get, SWIG_Lua_set_immutable }, - { "yellow", _wrap_ShortColor_yellow_get, SWIG_Lua_set_immutable }, - { "aliceBlue", _wrap_ShortColor_aliceBlue_get, SWIG_Lua_set_immutable }, - { "antiqueWhite", _wrap_ShortColor_antiqueWhite_get, SWIG_Lua_set_immutable }, - { "aqua", _wrap_ShortColor_aqua_get, SWIG_Lua_set_immutable }, - { "aquamarine", _wrap_ShortColor_aquamarine_get, SWIG_Lua_set_immutable }, - { "azure", _wrap_ShortColor_azure_get, SWIG_Lua_set_immutable }, - { "beige", _wrap_ShortColor_beige_get, SWIG_Lua_set_immutable }, - { "bisque", _wrap_ShortColor_bisque_get, SWIG_Lua_set_immutable }, - { "blanchedAlmond", _wrap_ShortColor_blanchedAlmond_get, SWIG_Lua_set_immutable }, - { "blueViolet", _wrap_ShortColor_blueViolet_get, SWIG_Lua_set_immutable }, - { "brown", _wrap_ShortColor_brown_get, SWIG_Lua_set_immutable }, - { "burlyWood", _wrap_ShortColor_burlyWood_get, SWIG_Lua_set_immutable }, - { "cadetBlue", _wrap_ShortColor_cadetBlue_get, SWIG_Lua_set_immutable }, - { "chartreuse", _wrap_ShortColor_chartreuse_get, SWIG_Lua_set_immutable }, - { "chocolate", _wrap_ShortColor_chocolate_get, SWIG_Lua_set_immutable }, - { "coral", _wrap_ShortColor_coral_get, SWIG_Lua_set_immutable }, - { "cornflowerBlue", _wrap_ShortColor_cornflowerBlue_get, SWIG_Lua_set_immutable }, - { "cornsilk", _wrap_ShortColor_cornsilk_get, SWIG_Lua_set_immutable }, - { "crimson", _wrap_ShortColor_crimson_get, SWIG_Lua_set_immutable }, - { "darkBlue", _wrap_ShortColor_darkBlue_get, SWIG_Lua_set_immutable }, - { "darkCyan", _wrap_ShortColor_darkCyan_get, SWIG_Lua_set_immutable }, - { "darkGoldenRod", _wrap_ShortColor_darkGoldenRod_get, SWIG_Lua_set_immutable }, - { "darkGray", _wrap_ShortColor_darkGray_get, SWIG_Lua_set_immutable }, - { "darkGrey", _wrap_ShortColor_darkGrey_get, SWIG_Lua_set_immutable }, - { "darkGreen", _wrap_ShortColor_darkGreen_get, SWIG_Lua_set_immutable }, - { "darkKhaki", _wrap_ShortColor_darkKhaki_get, SWIG_Lua_set_immutable }, - { "darkMagenta", _wrap_ShortColor_darkMagenta_get, SWIG_Lua_set_immutable }, - { "darkOliveGreen", _wrap_ShortColor_darkOliveGreen_get, SWIG_Lua_set_immutable }, - { "darkorange", _wrap_ShortColor_darkorange_get, SWIG_Lua_set_immutable }, - { "darkOrchid", _wrap_ShortColor_darkOrchid_get, SWIG_Lua_set_immutable }, - { "darkRed", _wrap_ShortColor_darkRed_get, SWIG_Lua_set_immutable }, - { "darkSalmon", _wrap_ShortColor_darkSalmon_get, SWIG_Lua_set_immutable }, - { "darkSeaGreen", _wrap_ShortColor_darkSeaGreen_get, SWIG_Lua_set_immutable }, - { "darkSlateBlue", _wrap_ShortColor_darkSlateBlue_get, SWIG_Lua_set_immutable }, - { "darkSlateGray", _wrap_ShortColor_darkSlateGray_get, SWIG_Lua_set_immutable }, - { "darkSlateGrey", _wrap_ShortColor_darkSlateGrey_get, SWIG_Lua_set_immutable }, - { "darkTurquoise", _wrap_ShortColor_darkTurquoise_get, SWIG_Lua_set_immutable }, - { "darkViolet", _wrap_ShortColor_darkViolet_get, SWIG_Lua_set_immutable }, - { "deepPink", _wrap_ShortColor_deepPink_get, SWIG_Lua_set_immutable }, - { "deepSkyBlue", _wrap_ShortColor_deepSkyBlue_get, SWIG_Lua_set_immutable }, - { "dimGray", _wrap_ShortColor_dimGray_get, SWIG_Lua_set_immutable }, - { "dimGrey", _wrap_ShortColor_dimGrey_get, SWIG_Lua_set_immutable }, - { "dodgerBlue", _wrap_ShortColor_dodgerBlue_get, SWIG_Lua_set_immutable }, - { "fireBrick", _wrap_ShortColor_fireBrick_get, SWIG_Lua_set_immutable }, - { "floralWhite", _wrap_ShortColor_floralWhite_get, SWIG_Lua_set_immutable }, - { "forestGreen", _wrap_ShortColor_forestGreen_get, SWIG_Lua_set_immutable }, - { "fuchsia", _wrap_ShortColor_fuchsia_get, SWIG_Lua_set_immutable }, - { "gainsboro", _wrap_ShortColor_gainsboro_get, SWIG_Lua_set_immutable }, - { "ghostWhite", _wrap_ShortColor_ghostWhite_get, SWIG_Lua_set_immutable }, - { "gold", _wrap_ShortColor_gold_get, SWIG_Lua_set_immutable }, - { "goldenRod", _wrap_ShortColor_goldenRod_get, SWIG_Lua_set_immutable }, - { "grey", _wrap_ShortColor_grey_get, SWIG_Lua_set_immutable }, - { "greenYellow", _wrap_ShortColor_greenYellow_get, SWIG_Lua_set_immutable }, - { "honeyDew", _wrap_ShortColor_honeyDew_get, SWIG_Lua_set_immutable }, - { "hotPink", _wrap_ShortColor_hotPink_get, SWIG_Lua_set_immutable }, - { "indianRed", _wrap_ShortColor_indianRed_get, SWIG_Lua_set_immutable }, - { "indigo", _wrap_ShortColor_indigo_get, SWIG_Lua_set_immutable }, - { "ivory", _wrap_ShortColor_ivory_get, SWIG_Lua_set_immutable }, - { "khaki", _wrap_ShortColor_khaki_get, SWIG_Lua_set_immutable }, - { "lavender", _wrap_ShortColor_lavender_get, SWIG_Lua_set_immutable }, - { "lavenderBlush", _wrap_ShortColor_lavenderBlush_get, SWIG_Lua_set_immutable }, - { "lawnGreen", _wrap_ShortColor_lawnGreen_get, SWIG_Lua_set_immutable }, - { "lemonChiffon", _wrap_ShortColor_lemonChiffon_get, SWIG_Lua_set_immutable }, - { "lightBlue", _wrap_ShortColor_lightBlue_get, SWIG_Lua_set_immutable }, - { "lightCoral", _wrap_ShortColor_lightCoral_get, SWIG_Lua_set_immutable }, - { "lightCyan", _wrap_ShortColor_lightCyan_get, SWIG_Lua_set_immutable }, - { "lightGoldenRodYellow", _wrap_ShortColor_lightGoldenRodYellow_get, SWIG_Lua_set_immutable }, - { "lightGray", _wrap_ShortColor_lightGray_get, SWIG_Lua_set_immutable }, - { "lightGrey", _wrap_ShortColor_lightGrey_get, SWIG_Lua_set_immutable }, - { "lightGreen", _wrap_ShortColor_lightGreen_get, SWIG_Lua_set_immutable }, - { "lightPink", _wrap_ShortColor_lightPink_get, SWIG_Lua_set_immutable }, - { "lightSalmon", _wrap_ShortColor_lightSalmon_get, SWIG_Lua_set_immutable }, - { "lightSeaGreen", _wrap_ShortColor_lightSeaGreen_get, SWIG_Lua_set_immutable }, - { "lightSkyBlue", _wrap_ShortColor_lightSkyBlue_get, SWIG_Lua_set_immutable }, - { "lightSlateGray", _wrap_ShortColor_lightSlateGray_get, SWIG_Lua_set_immutable }, - { "lightSlateGrey", _wrap_ShortColor_lightSlateGrey_get, SWIG_Lua_set_immutable }, - { "lightSteelBlue", _wrap_ShortColor_lightSteelBlue_get, SWIG_Lua_set_immutable }, - { "lightYellow", _wrap_ShortColor_lightYellow_get, SWIG_Lua_set_immutable }, - { "lime", _wrap_ShortColor_lime_get, SWIG_Lua_set_immutable }, - { "limeGreen", _wrap_ShortColor_limeGreen_get, SWIG_Lua_set_immutable }, - { "linen", _wrap_ShortColor_linen_get, SWIG_Lua_set_immutable }, - { "maroon", _wrap_ShortColor_maroon_get, SWIG_Lua_set_immutable }, - { "mediumAquaMarine", _wrap_ShortColor_mediumAquaMarine_get, SWIG_Lua_set_immutable }, - { "mediumBlue", _wrap_ShortColor_mediumBlue_get, SWIG_Lua_set_immutable }, - { "mediumOrchid", _wrap_ShortColor_mediumOrchid_get, SWIG_Lua_set_immutable }, - { "mediumPurple", _wrap_ShortColor_mediumPurple_get, SWIG_Lua_set_immutable }, - { "mediumSeaGreen", _wrap_ShortColor_mediumSeaGreen_get, SWIG_Lua_set_immutable }, - { "mediumSlateBlue", _wrap_ShortColor_mediumSlateBlue_get, SWIG_Lua_set_immutable }, - { "mediumSpringGreen", _wrap_ShortColor_mediumSpringGreen_get, SWIG_Lua_set_immutable }, - { "mediumTurquoise", _wrap_ShortColor_mediumTurquoise_get, SWIG_Lua_set_immutable }, - { "mediumVioletRed", _wrap_ShortColor_mediumVioletRed_get, SWIG_Lua_set_immutable }, - { "midnightBlue", _wrap_ShortColor_midnightBlue_get, SWIG_Lua_set_immutable }, - { "mintCream", _wrap_ShortColor_mintCream_get, SWIG_Lua_set_immutable }, - { "mistyRose", _wrap_ShortColor_mistyRose_get, SWIG_Lua_set_immutable }, - { "moccasin", _wrap_ShortColor_moccasin_get, SWIG_Lua_set_immutable }, - { "navajoWhite", _wrap_ShortColor_navajoWhite_get, SWIG_Lua_set_immutable }, - { "navy", _wrap_ShortColor_navy_get, SWIG_Lua_set_immutable }, - { "oldLace", _wrap_ShortColor_oldLace_get, SWIG_Lua_set_immutable }, - { "olive", _wrap_ShortColor_olive_get, SWIG_Lua_set_immutable }, - { "oliveDrab", _wrap_ShortColor_oliveDrab_get, SWIG_Lua_set_immutable }, - { "orange", _wrap_ShortColor_orange_get, SWIG_Lua_set_immutable }, - { "orangeRed", _wrap_ShortColor_orangeRed_get, SWIG_Lua_set_immutable }, - { "orchid", _wrap_ShortColor_orchid_get, SWIG_Lua_set_immutable }, - { "paleGoldenRod", _wrap_ShortColor_paleGoldenRod_get, SWIG_Lua_set_immutable }, - { "paleGreen", _wrap_ShortColor_paleGreen_get, SWIG_Lua_set_immutable }, - { "paleTurquoise", _wrap_ShortColor_paleTurquoise_get, SWIG_Lua_set_immutable }, - { "paleVioletRed", _wrap_ShortColor_paleVioletRed_get, SWIG_Lua_set_immutable }, - { "papayaWhip", _wrap_ShortColor_papayaWhip_get, SWIG_Lua_set_immutable }, - { "peachPuff", _wrap_ShortColor_peachPuff_get, SWIG_Lua_set_immutable }, - { "peru", _wrap_ShortColor_peru_get, SWIG_Lua_set_immutable }, - { "pink", _wrap_ShortColor_pink_get, SWIG_Lua_set_immutable }, - { "plum", _wrap_ShortColor_plum_get, SWIG_Lua_set_immutable }, - { "powderBlue", _wrap_ShortColor_powderBlue_get, SWIG_Lua_set_immutable }, - { "purple", _wrap_ShortColor_purple_get, SWIG_Lua_set_immutable }, - { "rosyBrown", _wrap_ShortColor_rosyBrown_get, SWIG_Lua_set_immutable }, - { "royalBlue", _wrap_ShortColor_royalBlue_get, SWIG_Lua_set_immutable }, - { "saddleBrown", _wrap_ShortColor_saddleBrown_get, SWIG_Lua_set_immutable }, - { "salmon", _wrap_ShortColor_salmon_get, SWIG_Lua_set_immutable }, - { "sandyBrown", _wrap_ShortColor_sandyBrown_get, SWIG_Lua_set_immutable }, - { "seaGreen", _wrap_ShortColor_seaGreen_get, SWIG_Lua_set_immutable }, - { "seaShell", _wrap_ShortColor_seaShell_get, SWIG_Lua_set_immutable }, - { "sienna", _wrap_ShortColor_sienna_get, SWIG_Lua_set_immutable }, - { "silver", _wrap_ShortColor_silver_get, SWIG_Lua_set_immutable }, - { "skyBlue", _wrap_ShortColor_skyBlue_get, SWIG_Lua_set_immutable }, - { "slateBlue", _wrap_ShortColor_slateBlue_get, SWIG_Lua_set_immutable }, - { "slateGray", _wrap_ShortColor_slateGray_get, SWIG_Lua_set_immutable }, - { "slateGrey", _wrap_ShortColor_slateGrey_get, SWIG_Lua_set_immutable }, - { "snow", _wrap_ShortColor_snow_get, SWIG_Lua_set_immutable }, - { "springGreen", _wrap_ShortColor_springGreen_get, SWIG_Lua_set_immutable }, - { "steelBlue", _wrap_ShortColor_steelBlue_get, SWIG_Lua_set_immutable }, - { "blueSteel", _wrap_ShortColor_blueSteel_get, SWIG_Lua_set_immutable }, - { "tan", _wrap_ShortColor_tan_get, SWIG_Lua_set_immutable }, - { "teal", _wrap_ShortColor_teal_get, SWIG_Lua_set_immutable }, - { "thistle", _wrap_ShortColor_thistle_get, SWIG_Lua_set_immutable }, - { "tomato", _wrap_ShortColor_tomato_get, SWIG_Lua_set_immutable }, - { "turquoise", _wrap_ShortColor_turquoise_get, SWIG_Lua_set_immutable }, - { "violet", _wrap_ShortColor_violet_get, SWIG_Lua_set_immutable }, - { "wheat", _wrap_ShortColor_wheat_get, SWIG_Lua_set_immutable }, - { "whiteSmoke", _wrap_ShortColor_whiteSmoke_get, SWIG_Lua_set_immutable }, - { "yellowGreen", _wrap_ShortColor_yellowGreen_get, SWIG_Lua_set_immutable }, - {0,0,0} -}; -static swig_lua_const_info swig_ShortColor_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_ShortColor_Sf_SwigStatic_methods[]= { - { "fromHsb", _wrap_ShortColor_fromHsb}, - { "fromHex", _wrap_ShortColor_fromHex}, - { "limit", _wrap_ShortColor_limit}, - {0,0} -}; -static swig_lua_class* swig_ShortColor_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_ShortColor_Sf_SwigStatic = { - "ShortColor", - swig_ShortColor_Sf_SwigStatic_methods, - swig_ShortColor_Sf_SwigStatic_attributes, - swig_ShortColor_Sf_SwigStatic_constants, - swig_ShortColor_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_ShortColor_bases[] = {0}; -static const char *swig_ShortColor_base_names[] = {0}; -static swig_lua_class _wrap_class_ShortColor = { "ShortColor", "ShortColor", &SWIGTYPE_p_ofColor_T_unsigned_short_t,_proxy__wrap_new_ShortColor, swig_delete_ShortColor, swig_ShortColor_methods, swig_ShortColor_attributes, &swig_ShortColor_Sf_SwigStatic, swig_ShortColor_meta, swig_ShortColor_bases, swig_ShortColor_base_names }; - -static int _wrap_new_Rectangle__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofRectangle *result = 0 ; - SWIG_check_num_args("ofRectangle::ofRectangle",0,0) result = (ofRectangle *)new ofRectangle(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofRectangle,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Rectangle__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - ofRectangle *result = 0 ; SWIG_check_num_args("ofRectangle::ofRectangle",4,4) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofRectangle::ofRectangle",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::ofRectangle",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofRectangle::ofRectangle",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofRectangle::ofRectangle",4,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - result = (ofRectangle *)new ofRectangle(arg1,arg2,arg3,arg4); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofRectangle,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Rectangle__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPoint *arg1 = 0 ; float arg2 ; float arg3 ; - ofRectangle *result = 0 ; SWIG_check_num_args("ofRectangle::ofRectangle",3,3) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofRectangle::ofRectangle",1,"ofPoint const &"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::ofRectangle",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofRectangle::ofRectangle",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("new_Rectangle",1,SWIGTYPE_p_ofVec3f); } arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - result = (ofRectangle *)new ofRectangle((ofPoint const &)*arg1,arg2,arg3); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofRectangle,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Rectangle__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = 0 ; ofRectangle *result = 0 ; - SWIG_check_num_args("ofRectangle::ofRectangle",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofRectangle::ofRectangle",1,"ofRectangle const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("new_Rectangle",1,SWIGTYPE_p_ofRectangle); } - result = (ofRectangle *)new ofRectangle((ofRectangle const &)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofRectangle,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Rectangle__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofPoint *arg1 = 0 ; ofPoint *arg2 = 0 ; - ofRectangle *result = 0 ; SWIG_check_num_args("ofRectangle::ofRectangle",2,2) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofRectangle::ofRectangle",1,"ofPoint const &"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::ofRectangle",2,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("new_Rectangle",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("new_Rectangle",2,SWIGTYPE_p_ofVec3f); } - result = (ofRectangle *)new ofRectangle((ofPoint const &)*arg1,(ofPoint const &)*arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofRectangle,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Rectangle(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_Rectangle__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_new_Rectangle__SWIG_3(L);} } if (argc == 2) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_new_Rectangle__SWIG_4(L);} } } if (argc == 3) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_new_Rectangle__SWIG_2(L);} } } } if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_new_Rectangle__SWIG_1(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_Rectangle'\n" " Possible C/C++ prototypes are:\n" - " ofRectangle::ofRectangle()\n" " ofRectangle::ofRectangle(float,float,float,float)\n" - " ofRectangle::ofRectangle(ofPoint const &,float,float)\n" " ofRectangle::ofRectangle(ofRectangle const &)\n" - " ofRectangle::ofRectangle(ofPoint const &,ofPoint const &)\n"); lua_error(L);return 0; } -static int _wrap_Rectangle_set__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float arg2 ; - float arg3 ; float arg4 ; float arg5 ; SWIG_check_num_args("ofRectangle::set",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::set",1,"ofRectangle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofRectangle::set",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofRectangle::set",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofRectangle::set",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_set",1,SWIGTYPE_p_ofRectangle); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - (arg1)->set(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_set__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofPoint *arg2 = 0 ; float arg3 ; float arg4 ; SWIG_check_num_args("ofRectangle::set",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::set",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::set",2,"ofPoint const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofRectangle::set",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofRectangle::set",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_set",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Rectangle_set",2,SWIGTYPE_p_ofVec3f); } arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - (arg1)->set((ofPoint const &)*arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_set__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofRectangle *arg2 = 0 ; SWIG_check_num_args("ofRectangle::set",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::set",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::set",2,"ofRectangle const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_set",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_set",2,SWIGTYPE_p_ofRectangle); } (arg1)->set((ofRectangle const &)*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_set__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofPoint *arg2 = 0 ; ofPoint *arg3 = 0 ; SWIG_check_num_args("ofRectangle::set",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::set",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::set",2,"ofPoint const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofRectangle::set",3,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_set",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Rectangle_set",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Rectangle_set",3,SWIGTYPE_p_ofVec3f); } (arg1)->set((ofPoint const &)*arg2,(ofPoint const &)*arg3); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_set(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle_set__SWIG_2(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle_set__SWIG_3(L);} } } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Rectangle_set__SWIG_1(L);} } } } } if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Rectangle_set__SWIG_0(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Rectangle_set'\n" " Possible C/C++ prototypes are:\n" - " ofRectangle::set(float,float,float,float)\n" " ofRectangle::set(ofPoint const &,float,float)\n" - " ofRectangle::set(ofRectangle const &)\n" " ofRectangle::set(ofPoint const &,ofPoint const &)\n"); - lua_error(L);return 0; } -static int _wrap_Rectangle_setX(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float arg2 ; - SWIG_check_num_args("ofRectangle::setX",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::setX",1,"ofRectangle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::setX",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_setX",1,SWIGTYPE_p_ofRectangle); } arg2 = (float)lua_tonumber(L, 2); (arg1)->setX(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_setY(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float arg2 ; - SWIG_check_num_args("ofRectangle::setY",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::setY",1,"ofRectangle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::setY",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_setY",1,SWIGTYPE_p_ofRectangle); } arg2 = (float)lua_tonumber(L, 2); (arg1)->setY(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_setWidth(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float arg2 ; - SWIG_check_num_args("ofRectangle::setWidth",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::setWidth",1,"ofRectangle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::setWidth",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_setWidth",1,SWIGTYPE_p_ofRectangle); } arg2 = (float)lua_tonumber(L, 2); (arg1)->setWidth(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_setHeight(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float arg2 ; - SWIG_check_num_args("ofRectangle::setHeight",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::setHeight",1,"ofRectangle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::setHeight",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_setHeight",1,SWIGTYPE_p_ofRectangle); } arg2 = (float)lua_tonumber(L, 2); (arg1)->setHeight(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_setPosition__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - float arg2 ; float arg3 ; SWIG_check_num_args("ofRectangle::setPosition",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::setPosition",1,"ofRectangle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::setPosition",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofRectangle::setPosition",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_setPosition",1,SWIGTYPE_p_ofRectangle); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->setPosition(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Rectangle_setPosition__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofPoint *arg2 = 0 ; SWIG_check_num_args("ofRectangle::setPosition",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::setPosition",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::setPosition",2,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_setPosition",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Rectangle_setPosition",2,SWIGTYPE_p_ofVec3f); } (arg1)->setPosition((ofPoint const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_setPosition(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle_setPosition__SWIG_1(L);} } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_Rectangle_setPosition__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Rectangle_setPosition'\n" - " Possible C/C++ prototypes are:\n" " ofRectangle::setPosition(float,float)\n" - " ofRectangle::setPosition(ofPoint const &)\n"); lua_error(L);return 0; } -static int _wrap_Rectangle_setSize(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float arg2 ; - float arg3 ; SWIG_check_num_args("ofRectangle::setSize",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::setSize",1,"ofRectangle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::setSize",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofRectangle::setSize",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_setSize",1,SWIGTYPE_p_ofRectangle); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->setSize(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Rectangle_setFromCenter__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - float arg2 ; float arg3 ; float arg4 ; float arg5 ; SWIG_check_num_args("ofRectangle::setFromCenter",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::setFromCenter",1,"ofRectangle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::setFromCenter",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofRectangle::setFromCenter",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofRectangle::setFromCenter",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofRectangle::setFromCenter",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_setFromCenter",1,SWIGTYPE_p_ofRectangle); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - (arg1)->setFromCenter(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_setFromCenter__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofPoint *arg2 = 0 ; float arg3 ; float arg4 ; SWIG_check_num_args("ofRectangle::setFromCenter",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::setFromCenter",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::setFromCenter",2,"ofPoint const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofRectangle::setFromCenter",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofRectangle::setFromCenter",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_setFromCenter",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Rectangle_setFromCenter",2,SWIGTYPE_p_ofVec3f); } arg3 = (float)lua_tonumber(L, 3); - arg4 = (float)lua_tonumber(L, 4); (arg1)->setFromCenter((ofPoint const &)*arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_setFromCenter(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); - if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Rectangle_setFromCenter__SWIG_1(L);} } } } } if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Rectangle_setFromCenter__SWIG_0(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Rectangle_setFromCenter'\n" - " Possible C/C++ prototypes are:\n" " ofRectangle::setFromCenter(float,float,float,float)\n" - " ofRectangle::setFromCenter(ofPoint const &,float,float)\n"); lua_error(L);return 0; } -static int _wrap_Rectangle_translate__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - float arg2 ; float arg3 ; SWIG_check_num_args("ofRectangle::translate",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::translate",1,"ofRectangle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::translate",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofRectangle::translate",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_translate",1,SWIGTYPE_p_ofRectangle); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->translate(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Rectangle_translate__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofPoint *arg2 = 0 ; SWIG_check_num_args("ofRectangle::translate",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::translate",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::translate",2,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_translate",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Rectangle_translate",2,SWIGTYPE_p_ofVec3f); } (arg1)->translate((ofPoint const &)*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_translate(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle_translate__SWIG_1(L);} } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_Rectangle_translate__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Rectangle_translate'\n" - " Possible C/C++ prototypes are:\n" " ofRectangle::translate(float,float)\n" - " ofRectangle::translate(ofPoint const &)\n"); lua_error(L);return 0; } -static int _wrap_Rectangle_translateX(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float arg2 ; - SWIG_check_num_args("ofRectangle::translateX",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::translateX",1,"ofRectangle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::translateX",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_translateX",1,SWIGTYPE_p_ofRectangle); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->translateX(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_translateY(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float arg2 ; - SWIG_check_num_args("ofRectangle::translateY",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::translateY",1,"ofRectangle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::translateY",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_translateY",1,SWIGTYPE_p_ofRectangle); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->translateY(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_scale__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float arg2 ; - SWIG_check_num_args("ofRectangle::scale",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::scale",1,"ofRectangle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::scale",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_scale",1,SWIGTYPE_p_ofRectangle); } arg2 = (float)lua_tonumber(L, 2); (arg1)->scale(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_scale__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float arg2 ; - float arg3 ; SWIG_check_num_args("ofRectangle::scale",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::scale",1,"ofRectangle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::scale",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofRectangle::scale",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_scale",1,SWIGTYPE_p_ofRectangle); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->scale(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Rectangle_scale__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofPoint *arg2 = 0 ; SWIG_check_num_args("ofRectangle::scale",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::scale",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::scale",2,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_scale",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Rectangle_scale",2,SWIGTYPE_p_ofVec3f); } (arg1)->scale((ofPoint const &)*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_scale(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle_scale__SWIG_2(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Rectangle_scale__SWIG_0(L);} } - } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Rectangle_scale__SWIG_1(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Rectangle_scale'\n" " Possible C/C++ prototypes are:\n" - " ofRectangle::scale(float)\n" " ofRectangle::scale(float,float)\n" " ofRectangle::scale(ofPoint const &)\n"); - lua_error(L);return 0; } -static int _wrap_Rectangle_scaleWidth(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float arg2 ; - SWIG_check_num_args("ofRectangle::scaleWidth",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::scaleWidth",1,"ofRectangle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::scaleWidth",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_scaleWidth",1,SWIGTYPE_p_ofRectangle); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->scaleWidth(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_scaleHeight(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float arg2 ; - SWIG_check_num_args("ofRectangle::scaleHeight",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::scaleHeight",1,"ofRectangle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::scaleHeight",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_scaleHeight",1,SWIGTYPE_p_ofRectangle); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->scaleHeight(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_scaleFromCenter__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - float arg2 ; SWIG_check_num_args("ofRectangle::scaleFromCenter",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::scaleFromCenter",1,"ofRectangle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::scaleFromCenter",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_scaleFromCenter",1,SWIGTYPE_p_ofRectangle); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->scaleFromCenter(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_scaleFromCenter__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - float arg2 ; float arg3 ; SWIG_check_num_args("ofRectangle::scaleFromCenter",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::scaleFromCenter",1,"ofRectangle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::scaleFromCenter",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofRectangle::scaleFromCenter",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_scaleFromCenter",1,SWIGTYPE_p_ofRectangle); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->scaleFromCenter(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Rectangle_scaleFromCenter__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofPoint *arg2 = 0 ; SWIG_check_num_args("ofRectangle::scaleFromCenter",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::scaleFromCenter",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::scaleFromCenter",2,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_scaleFromCenter",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Rectangle_scaleFromCenter",2,SWIGTYPE_p_ofVec3f); } (arg1)->scaleFromCenter((ofPoint const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_scaleFromCenter(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle_scaleFromCenter__SWIG_2(L);} } } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Rectangle_scaleFromCenter__SWIG_0(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Rectangle_scaleFromCenter__SWIG_1(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Rectangle_scaleFromCenter'\n" - " Possible C/C++ prototypes are:\n" " ofRectangle::scaleFromCenter(float)\n" - " ofRectangle::scaleFromCenter(float,float)\n" " ofRectangle::scaleFromCenter(ofPoint const &)\n"); - lua_error(L);return 0; } -static int _wrap_Rectangle_scaleToScaleMode(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofRectangle *arg2 = 0 ; ofScaleMode arg3 ; SWIG_check_num_args("ofRectangle::scaleTo",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::scaleTo",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::scaleTo",2,"ofRectangle const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofRectangle::scaleTo",3,"ofScaleMode"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_scaleToScaleMode",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_scaleToScaleMode",2,SWIGTYPE_p_ofRectangle); } arg3 = (ofScaleMode)(int)lua_tonumber(L, 3); - (arg1)->scaleTo((ofRectangle const &)*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_scaleTo__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofRectangle *arg2 = 0 ; SWIG_check_num_args("ofRectangle::scaleTo",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::scaleTo",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::scaleTo",2,"ofRectangle const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_scaleTo",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_scaleTo",2,SWIGTYPE_p_ofRectangle); } (arg1)->scaleTo((ofRectangle const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_scaleTo__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofRectangle *arg2 = 0 ; ofAspectRatioMode arg3 ; ofAlignHorz arg4 ; ofAlignVert arg5 ; - SWIG_check_num_args("ofRectangle::scaleTo",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::scaleTo",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::scaleTo",2,"ofRectangle const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofRectangle::scaleTo",3,"ofAspectRatioMode"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofRectangle::scaleTo",4,"ofAlignHorz"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofRectangle::scaleTo",5,"ofAlignVert"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_scaleTo",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_scaleTo",2,SWIGTYPE_p_ofRectangle); } arg3 = (ofAspectRatioMode)(int)lua_tonumber(L, 3); - arg4 = (ofAlignHorz)(int)lua_tonumber(L, 4); arg5 = (ofAlignVert)(int)lua_tonumber(L, 5); - (arg1)->scaleTo((ofRectangle const &)*arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Rectangle_scaleTo__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofRectangle *arg2 = 0 ; ofAspectRatioMode arg3 ; ofAlignHorz arg4 ; SWIG_check_num_args("ofRectangle::scaleTo",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::scaleTo",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::scaleTo",2,"ofRectangle const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofRectangle::scaleTo",3,"ofAspectRatioMode"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofRectangle::scaleTo",4,"ofAlignHorz"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_scaleTo",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_scaleTo",2,SWIGTYPE_p_ofRectangle); } arg3 = (ofAspectRatioMode)(int)lua_tonumber(L, 3); - arg4 = (ofAlignHorz)(int)lua_tonumber(L, 4); (arg1)->scaleTo((ofRectangle const &)*arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_scaleToAspectRatio(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofRectangle *arg2 = 0 ; ofAspectRatioMode arg3 ; SWIG_check_num_args("ofRectangle::scaleTo",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::scaleTo",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::scaleTo",2,"ofRectangle const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofRectangle::scaleTo",3,"ofAspectRatioMode"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_scaleToAspectRatio",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_scaleToAspectRatio",2,SWIGTYPE_p_ofRectangle); } - arg3 = (ofAspectRatioMode)(int)lua_tonumber(L, 3); (arg1)->scaleTo((ofRectangle const &)*arg2,arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_scaleTo__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofRectangle *arg2 = 0 ; ofAspectRatioMode arg3 ; ofAlignHorz arg4 ; ofAlignVert arg5 ; ofAlignHorz arg6 ; ofAlignVert arg7 ; - SWIG_check_num_args("ofRectangle::scaleTo",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::scaleTo",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::scaleTo",2,"ofRectangle const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofRectangle::scaleTo",3,"ofAspectRatioMode"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofRectangle::scaleTo",4,"ofAlignHorz"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofRectangle::scaleTo",5,"ofAlignVert"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofRectangle::scaleTo",6,"ofAlignHorz"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofRectangle::scaleTo",7,"ofAlignVert"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_scaleTo",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_scaleTo",2,SWIGTYPE_p_ofRectangle); } arg3 = (ofAspectRatioMode)(int)lua_tonumber(L, 3); - arg4 = (ofAlignHorz)(int)lua_tonumber(L, 4); arg5 = (ofAlignVert)(int)lua_tonumber(L, 5); - arg6 = (ofAlignHorz)(int)lua_tonumber(L, 6); arg7 = (ofAlignVert)(int)lua_tonumber(L, 7); - (arg1)->scaleTo((ofRectangle const &)*arg2,arg3,arg4,arg5,arg6,arg7); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Rectangle_scaleTo(lua_State* L) { int argc; int argv[8]={ 1,2,3,4,5,6,7,8} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle_scaleTo__SWIG_0(L);} } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Rectangle_scaleTo__SWIG_2(L);} } } } } if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_Rectangle_scaleTo__SWIG_1(L);} } } } } } - if (argc == 7) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { { - _v = lua_isnumber(L,argv[6]); } if (_v) { return _wrap_Rectangle_scaleTo__SWIG_3(L);} } } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Rectangle_scaleTo'\n" " Possible C/C++ prototypes are:\n" - " ofRectangle::scaleTo(ofRectangle const &)\n" - " ofRectangle::scaleTo(ofRectangle const &,ofAspectRatioMode,ofAlignHorz,ofAlignVert)\n" - " ofRectangle::scaleTo(ofRectangle const &,ofAspectRatioMode,ofAlignHorz)\n" - " ofRectangle::scaleTo(ofRectangle const &,ofAspectRatioMode,ofAlignHorz,ofAlignVert,ofAlignHorz,ofAlignVert)\n"); - lua_error(L);return 0; } -static int _wrap_Rectangle_alignToHorz__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - float *arg2 = 0 ; ofAlignHorz arg3 ; float temp2 ; SWIG_check_num_args("ofRectangle::alignToHorz",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::alignToHorz",1,"ofRectangle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::alignToHorz",2,"float const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofRectangle::alignToHorz",3,"ofAlignHorz"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_alignToHorz",1,SWIGTYPE_p_ofRectangle); } temp2=(float)lua_tonumber(L,2); arg2=&temp2; - arg3 = (ofAlignHorz)(int)lua_tonumber(L, 3); (arg1)->alignToHorz((float const &)*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_alignToHorz__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - float *arg2 = 0 ; float temp2 ; SWIG_check_num_args("ofRectangle::alignToHorz",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::alignToHorz",1,"ofRectangle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::alignToHorz",2,"float const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_alignToHorz",1,SWIGTYPE_p_ofRectangle); } temp2=(float)lua_tonumber(L,2); arg2=&temp2; - (arg1)->alignToHorz((float const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_alignToHorz__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofRectangle *arg2 = 0 ; ofAlignHorz arg3 ; SWIG_check_num_args("ofRectangle::alignToHorz",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::alignToHorz",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::alignToHorz",2,"ofRectangle const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofRectangle::alignToHorz",3,"ofAlignHorz"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_alignToHorz",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_alignToHorz",2,SWIGTYPE_p_ofRectangle); } arg3 = (ofAlignHorz)(int)lua_tonumber(L, 3); - (arg1)->alignToHorz((ofRectangle const &)*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_alignToHorz__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofRectangle *arg2 = 0 ; SWIG_check_num_args("ofRectangle::alignToHorz",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::alignToHorz",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::alignToHorz",2,"ofRectangle const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_alignToHorz",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_alignToHorz",2,SWIGTYPE_p_ofRectangle); } (arg1)->alignToHorz((ofRectangle const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_alignToHorz__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofRectangle *arg2 = 0 ; ofAlignHorz arg3 ; ofAlignHorz arg4 ; SWIG_check_num_args("ofRectangle::alignToHorz",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::alignToHorz",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::alignToHorz",2,"ofRectangle const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofRectangle::alignToHorz",3,"ofAlignHorz"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofRectangle::alignToHorz",4,"ofAlignHorz"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_alignToHorz",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_alignToHorz",2,SWIGTYPE_p_ofRectangle); } arg3 = (ofAlignHorz)(int)lua_tonumber(L, 3); - arg4 = (ofAlignHorz)(int)lua_tonumber(L, 4); (arg1)->alignToHorz((ofRectangle const &)*arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_alignToHorz(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle_alignToHorz__SWIG_3(L);} } } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Rectangle_alignToHorz__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Rectangle_alignToHorz__SWIG_2(L);} } } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Rectangle_alignToHorz__SWIG_0(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Rectangle_alignToHorz__SWIG_4(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Rectangle_alignToHorz'\n" - " Possible C/C++ prototypes are:\n" " ofRectangle::alignToHorz(float const &,ofAlignHorz)\n" - " ofRectangle::alignToHorz(float const &)\n" " ofRectangle::alignToHorz(ofRectangle const &,ofAlignHorz)\n" - " ofRectangle::alignToHorz(ofRectangle const &)\n" - " ofRectangle::alignToHorz(ofRectangle const &,ofAlignHorz,ofAlignHorz)\n"); lua_error(L);return 0; } -static int _wrap_Rectangle_alignToVert__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - float *arg2 = 0 ; ofAlignVert arg3 ; float temp2 ; SWIG_check_num_args("ofRectangle::alignToVert",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::alignToVert",1,"ofRectangle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::alignToVert",2,"float const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofRectangle::alignToVert",3,"ofAlignVert"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_alignToVert",1,SWIGTYPE_p_ofRectangle); } temp2=(float)lua_tonumber(L,2); arg2=&temp2; - arg3 = (ofAlignVert)(int)lua_tonumber(L, 3); (arg1)->alignToVert((float const &)*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_alignToVert__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - float *arg2 = 0 ; float temp2 ; SWIG_check_num_args("ofRectangle::alignToVert",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::alignToVert",1,"ofRectangle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::alignToVert",2,"float const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_alignToVert",1,SWIGTYPE_p_ofRectangle); } temp2=(float)lua_tonumber(L,2); arg2=&temp2; - (arg1)->alignToVert((float const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_alignToVert__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofRectangle *arg2 = 0 ; ofAlignVert arg3 ; SWIG_check_num_args("ofRectangle::alignToVert",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::alignToVert",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::alignToVert",2,"ofRectangle const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofRectangle::alignToVert",3,"ofAlignVert"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_alignToVert",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_alignToVert",2,SWIGTYPE_p_ofRectangle); } arg3 = (ofAlignVert)(int)lua_tonumber(L, 3); - (arg1)->alignToVert((ofRectangle const &)*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_alignToVert__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofRectangle *arg2 = 0 ; SWIG_check_num_args("ofRectangle::alignToVert",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::alignToVert",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::alignToVert",2,"ofRectangle const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_alignToVert",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_alignToVert",2,SWIGTYPE_p_ofRectangle); } (arg1)->alignToVert((ofRectangle const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_alignToVert__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofRectangle *arg2 = 0 ; ofAlignVert arg3 ; ofAlignVert arg4 ; SWIG_check_num_args("ofRectangle::alignToVert",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::alignToVert",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::alignToVert",2,"ofRectangle const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofRectangle::alignToVert",3,"ofAlignVert"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofRectangle::alignToVert",4,"ofAlignVert"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_alignToVert",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_alignToVert",2,SWIGTYPE_p_ofRectangle); } arg3 = (ofAlignVert)(int)lua_tonumber(L, 3); - arg4 = (ofAlignVert)(int)lua_tonumber(L, 4); (arg1)->alignToVert((ofRectangle const &)*arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_alignToVert(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle_alignToVert__SWIG_3(L);} } } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Rectangle_alignToVert__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Rectangle_alignToVert__SWIG_2(L);} } } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Rectangle_alignToVert__SWIG_0(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Rectangle_alignToVert__SWIG_4(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Rectangle_alignToVert'\n" - " Possible C/C++ prototypes are:\n" " ofRectangle::alignToVert(float const &,ofAlignVert)\n" - " ofRectangle::alignToVert(float const &)\n" " ofRectangle::alignToVert(ofRectangle const &,ofAlignVert)\n" - " ofRectangle::alignToVert(ofRectangle const &)\n" - " ofRectangle::alignToVert(ofRectangle const &,ofAlignVert,ofAlignVert)\n"); lua_error(L);return 0; } -static int _wrap_Rectangle_alignTo__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofPoint *arg2 = 0 ; ofAlignHorz arg3 ; ofAlignVert arg4 ; SWIG_check_num_args("ofRectangle::alignTo",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::alignTo",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::alignTo",2,"ofPoint const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofRectangle::alignTo",3,"ofAlignHorz"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofRectangle::alignTo",4,"ofAlignVert"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_alignTo",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Rectangle_alignTo",2,SWIGTYPE_p_ofVec3f); } arg3 = (ofAlignHorz)(int)lua_tonumber(L, 3); - arg4 = (ofAlignVert)(int)lua_tonumber(L, 4); (arg1)->alignTo((ofPoint const &)*arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_alignTo__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofPoint *arg2 = 0 ; ofAlignHorz arg3 ; SWIG_check_num_args("ofRectangle::alignTo",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::alignTo",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::alignTo",2,"ofPoint const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofRectangle::alignTo",3,"ofAlignHorz"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_alignTo",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Rectangle_alignTo",2,SWIGTYPE_p_ofVec3f); } arg3 = (ofAlignHorz)(int)lua_tonumber(L, 3); - (arg1)->alignTo((ofPoint const &)*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_alignTo__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofPoint *arg2 = 0 ; SWIG_check_num_args("ofRectangle::alignTo",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::alignTo",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::alignTo",2,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_alignTo",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Rectangle_alignTo",2,SWIGTYPE_p_ofVec3f); } (arg1)->alignTo((ofPoint const &)*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_alignTo__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofRectangle *arg2 = 0 ; ofAlignHorz arg3 ; ofAlignVert arg4 ; SWIG_check_num_args("ofRectangle::alignTo",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::alignTo",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::alignTo",2,"ofRectangle const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofRectangle::alignTo",3,"ofAlignHorz"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofRectangle::alignTo",4,"ofAlignVert"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_alignTo",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_alignTo",2,SWIGTYPE_p_ofRectangle); } arg3 = (ofAlignHorz)(int)lua_tonumber(L, 3); - arg4 = (ofAlignVert)(int)lua_tonumber(L, 4); (arg1)->alignTo((ofRectangle const &)*arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_alignTo__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofRectangle *arg2 = 0 ; ofAlignHorz arg3 ; SWIG_check_num_args("ofRectangle::alignTo",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::alignTo",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::alignTo",2,"ofRectangle const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofRectangle::alignTo",3,"ofAlignHorz"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_alignTo",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_alignTo",2,SWIGTYPE_p_ofRectangle); } arg3 = (ofAlignHorz)(int)lua_tonumber(L, 3); - (arg1)->alignTo((ofRectangle const &)*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_alignTo__SWIG_5(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofRectangle *arg2 = 0 ; SWIG_check_num_args("ofRectangle::alignTo",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::alignTo",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::alignTo",2,"ofRectangle const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_alignTo",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_alignTo",2,SWIGTYPE_p_ofRectangle); } (arg1)->alignTo((ofRectangle const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_alignTo__SWIG_6(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofRectangle *arg2 = 0 ; ofAlignHorz arg3 ; ofAlignVert arg4 ; ofAlignHorz arg5 ; ofAlignVert arg6 ; - SWIG_check_num_args("ofRectangle::alignTo",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::alignTo",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::alignTo",2,"ofRectangle const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofRectangle::alignTo",3,"ofAlignHorz"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofRectangle::alignTo",4,"ofAlignVert"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofRectangle::alignTo",5,"ofAlignHorz"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofRectangle::alignTo",6,"ofAlignVert"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_alignTo",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_alignTo",2,SWIGTYPE_p_ofRectangle); } arg3 = (ofAlignHorz)(int)lua_tonumber(L, 3); - arg4 = (ofAlignVert)(int)lua_tonumber(L, 4); arg5 = (ofAlignHorz)(int)lua_tonumber(L, 5); - arg6 = (ofAlignVert)(int)lua_tonumber(L, 6); (arg1)->alignTo((ofRectangle const &)*arg2,arg3,arg4,arg5,arg6); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_alignTo(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle_alignTo__SWIG_2(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle_alignTo__SWIG_5(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Rectangle_alignTo__SWIG_4(L);} - } } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Rectangle_alignTo__SWIG_1(L);} - } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Rectangle_alignTo__SWIG_0(L);} } } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Rectangle_alignTo__SWIG_3(L);} } } } } if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { - return _wrap_Rectangle_alignTo__SWIG_6(L);} } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Rectangle_alignTo'\n" " Possible C/C++ prototypes are:\n" - " ofRectangle::alignTo(ofPoint const &,ofAlignHorz,ofAlignVert)\n" - " ofRectangle::alignTo(ofPoint const &,ofAlignHorz)\n" " ofRectangle::alignTo(ofPoint const &)\n" - " ofRectangle::alignTo(ofRectangle const &,ofAlignHorz,ofAlignVert)\n" - " ofRectangle::alignTo(ofRectangle const &,ofAlignHorz)\n" " ofRectangle::alignTo(ofRectangle const &)\n" - " ofRectangle::alignTo(ofRectangle const &,ofAlignHorz,ofAlignVert,ofAlignHorz,ofAlignVert)\n"); lua_error(L);return 0; } -static int _wrap_Rectangle_inside__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float arg2 ; - float arg3 ; bool result; SWIG_check_num_args("ofRectangle::inside",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::inside",1,"ofRectangle const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::inside",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofRectangle::inside",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_inside",1,SWIGTYPE_p_ofRectangle); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); result = (bool)((ofRectangle const *)arg1)->inside(arg2,arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_inside__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofPoint *arg2 = 0 ; bool result; SWIG_check_num_args("ofRectangle::inside",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::inside",1,"ofRectangle const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::inside",2,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_inside",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Rectangle_inside",2,SWIGTYPE_p_ofVec3f); } - result = (bool)((ofRectangle const *)arg1)->inside((ofPoint const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_inside__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofRectangle *arg2 = 0 ; bool result; SWIG_check_num_args("ofRectangle::inside",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::inside",1,"ofRectangle const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::inside",2,"ofRectangle const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_inside",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_inside",2,SWIGTYPE_p_ofRectangle); } - result = (bool)((ofRectangle const *)arg1)->inside((ofRectangle const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_inside__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofPoint *arg2 = 0 ; ofPoint *arg3 = 0 ; bool result; SWIG_check_num_args("ofRectangle::inside",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::inside",1,"ofRectangle const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::inside",2,"ofPoint const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofRectangle::inside",3,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_inside",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Rectangle_inside",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Rectangle_inside",3,SWIGTYPE_p_ofVec3f); } - result = (bool)((ofRectangle const *)arg1)->inside((ofPoint const &)*arg2,(ofPoint const &)*arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_inside(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle_inside__SWIG_1(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle_inside__SWIG_2(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle_inside__SWIG_3(L);} } } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_Rectangle_inside__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Rectangle_inside'\n" " Possible C/C++ prototypes are:\n" - " ofRectangle::inside(float,float) const\n" " ofRectangle::inside(ofPoint const &) const\n" - " ofRectangle::inside(ofRectangle const &) const\n" " ofRectangle::inside(ofPoint const &,ofPoint const &) const\n"); - lua_error(L);return 0; } -static int _wrap_Rectangle_intersects__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofRectangle *arg2 = 0 ; bool result; SWIG_check_num_args("ofRectangle::intersects",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::intersects",1,"ofRectangle const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::intersects",2,"ofRectangle const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_intersects",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_intersects",2,SWIGTYPE_p_ofRectangle); } - result = (bool)((ofRectangle const *)arg1)->intersects((ofRectangle const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_intersects__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofPoint *arg2 = 0 ; ofPoint *arg3 = 0 ; bool result; SWIG_check_num_args("ofRectangle::intersects",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::intersects",1,"ofRectangle const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::intersects",2,"ofPoint const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofRectangle::intersects",3,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_intersects",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Rectangle_intersects",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Rectangle_intersects",3,SWIGTYPE_p_ofVec3f); } - result = (bool)((ofRectangle const *)arg1)->intersects((ofPoint const &)*arg2,(ofPoint const &)*arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_intersects(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle_intersects__SWIG_0(L);} } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle_intersects__SWIG_1(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Rectangle_intersects'\n" - " Possible C/C++ prototypes are:\n" " ofRectangle::intersects(ofRectangle const &) const\n" - " ofRectangle::intersects(ofPoint const &,ofPoint const &) const\n"); lua_error(L);return 0; } -static int _wrap_Rectangle_growToInclude__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - float arg2 ; float arg3 ; SWIG_check_num_args("ofRectangle::growToInclude",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::growToInclude",1,"ofRectangle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::growToInclude",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofRectangle::growToInclude",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_growToInclude",1,SWIGTYPE_p_ofRectangle); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->growToInclude(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Rectangle_growToInclude__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofPoint *arg2 = 0 ; SWIG_check_num_args("ofRectangle::growToInclude",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::growToInclude",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::growToInclude",2,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_growToInclude",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Rectangle_growToInclude",2,SWIGTYPE_p_ofVec3f); } (arg1)->growToInclude((ofPoint const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_growToInclude__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofRectangle *arg2 = 0 ; SWIG_check_num_args("ofRectangle::growToInclude",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::growToInclude",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::growToInclude",2,"ofRectangle const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_growToInclude",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_growToInclude",2,SWIGTYPE_p_ofRectangle); } (arg1)->growToInclude((ofRectangle const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_growToInclude__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofPoint *arg2 = 0 ; ofPoint *arg3 = 0 ; SWIG_check_num_args("ofRectangle::growToInclude",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::growToInclude",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::growToInclude",2,"ofPoint const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofRectangle::growToInclude",3,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_growToInclude",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Rectangle_growToInclude",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Rectangle_growToInclude",3,SWIGTYPE_p_ofVec3f); } - (arg1)->growToInclude((ofPoint const &)*arg2,(ofPoint const &)*arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Rectangle_growToInclude(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle_growToInclude__SWIG_1(L);} } } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle_growToInclude__SWIG_2(L);} } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle_growToInclude__SWIG_3(L);} } } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_Rectangle_growToInclude__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Rectangle_growToInclude'\n" - " Possible C/C++ prototypes are:\n" " ofRectangle::growToInclude(float,float)\n" - " ofRectangle::growToInclude(ofPoint const &)\n" " ofRectangle::growToInclude(ofRectangle const &)\n" - " ofRectangle::growToInclude(ofPoint const &,ofPoint const &)\n"); lua_error(L);return 0; } -static int _wrap_Rectangle_getIntersection(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofRectangle *arg2 = 0 ; ofRectangle result; SWIG_check_num_args("ofRectangle::getIntersection",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::getIntersection",1,"ofRectangle const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::getIntersection",2,"ofRectangle const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getIntersection",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getIntersection",2,SWIGTYPE_p_ofRectangle); } - result = ((ofRectangle const *)arg1)->getIntersection((ofRectangle const &)*arg2); { - ofRectangle * resultptr = new ofRectangle((const ofRectangle &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofRectangle,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_getUnion(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofRectangle *arg2 = 0 ; ofRectangle result; SWIG_check_num_args("ofRectangle::getUnion",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::getUnion",1,"ofRectangle const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::getUnion",2,"ofRectangle const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getUnion",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getUnion",2,SWIGTYPE_p_ofRectangle); } - result = ((ofRectangle const *)arg1)->getUnion((ofRectangle const &)*arg2); { - ofRectangle * resultptr = new ofRectangle((const ofRectangle &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofRectangle,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_standardize(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - SWIG_check_num_args("ofRectangle::standardize",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::standardize",1,"ofRectangle *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_standardize",1,SWIGTYPE_p_ofRectangle); } (arg1)->standardize(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_getStandardized(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofRectangle result; SWIG_check_num_args("ofRectangle::getStandardized",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::getStandardized",1,"ofRectangle const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getStandardized",1,SWIGTYPE_p_ofRectangle); } - result = ((ofRectangle const *)arg1)->getStandardized(); { - ofRectangle * resultptr = new ofRectangle((const ofRectangle &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofRectangle,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_isStandardized(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; bool result; - SWIG_check_num_args("ofRectangle::isStandardized",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::isStandardized",1,"ofRectangle const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_isStandardized",1,SWIGTYPE_p_ofRectangle); } - result = (bool)((ofRectangle const *)arg1)->isStandardized(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_getArea(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float result; - SWIG_check_num_args("ofRectangle::getArea",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::getArea",1,"ofRectangle const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getArea",1,SWIGTYPE_p_ofRectangle); } result = (float)((ofRectangle const *)arg1)->getArea(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_getPerimeter(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float result; - SWIG_check_num_args("ofRectangle::getPerimeter",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::getPerimeter",1,"ofRectangle const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getPerimeter",1,SWIGTYPE_p_ofRectangle); } - result = (float)((ofRectangle const *)arg1)->getPerimeter(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_getAspectRatio(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - float result; SWIG_check_num_args("ofRectangle::getAspectRatio",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::getAspectRatio",1,"ofRectangle const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getAspectRatio",1,SWIGTYPE_p_ofRectangle); } - result = (float)((ofRectangle const *)arg1)->getAspectRatio(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_isEmpty(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; bool result; - SWIG_check_num_args("ofRectangle::isEmpty",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::isEmpty",1,"ofRectangle const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_isEmpty",1,SWIGTYPE_p_ofRectangle); } result = (bool)((ofRectangle const *)arg1)->isEmpty(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_getMin(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; ofPoint result; - SWIG_check_num_args("ofRectangle::getMin",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::getMin",1,"ofRectangle const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getMin",1,SWIGTYPE_p_ofRectangle); } result = ((ofRectangle const *)arg1)->getMin(); { - ofPoint * resultptr = new ofPoint((const ofPoint &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_getMax(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; ofPoint result; - SWIG_check_num_args("ofRectangle::getMax",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::getMax",1,"ofRectangle const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getMax",1,SWIGTYPE_p_ofRectangle); } result = ((ofRectangle const *)arg1)->getMax(); { - ofPoint * resultptr = new ofPoint((const ofPoint &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_getMinX(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float result; - SWIG_check_num_args("ofRectangle::getMinX",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::getMinX",1,"ofRectangle const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getMinX",1,SWIGTYPE_p_ofRectangle); } result = (float)((ofRectangle const *)arg1)->getMinX(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_getMaxX(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float result; - SWIG_check_num_args("ofRectangle::getMaxX",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::getMaxX",1,"ofRectangle const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getMaxX",1,SWIGTYPE_p_ofRectangle); } result = (float)((ofRectangle const *)arg1)->getMaxX(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_getMinY(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float result; - SWIG_check_num_args("ofRectangle::getMinY",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::getMinY",1,"ofRectangle const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getMinY",1,SWIGTYPE_p_ofRectangle); } result = (float)((ofRectangle const *)arg1)->getMinY(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_getMaxY(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float result; - SWIG_check_num_args("ofRectangle::getMaxY",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::getMaxY",1,"ofRectangle const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getMaxY",1,SWIGTYPE_p_ofRectangle); } result = (float)((ofRectangle const *)arg1)->getMaxY(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_getLeft(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float result; - SWIG_check_num_args("ofRectangle::getLeft",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::getLeft",1,"ofRectangle const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getLeft",1,SWIGTYPE_p_ofRectangle); } result = (float)((ofRectangle const *)arg1)->getLeft(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_getRight(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float result; - SWIG_check_num_args("ofRectangle::getRight",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::getRight",1,"ofRectangle const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getRight",1,SWIGTYPE_p_ofRectangle); } result = (float)((ofRectangle const *)arg1)->getRight(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_getTop(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float result; - SWIG_check_num_args("ofRectangle::getTop",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::getTop",1,"ofRectangle const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getTop",1,SWIGTYPE_p_ofRectangle); } result = (float)((ofRectangle const *)arg1)->getTop(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_getBottom(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float result; - SWIG_check_num_args("ofRectangle::getBottom",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::getBottom",1,"ofRectangle const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getBottom",1,SWIGTYPE_p_ofRectangle); } result = (float)((ofRectangle const *)arg1)->getBottom(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_getTopLeft(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; ofPoint result; - SWIG_check_num_args("ofRectangle::getTopLeft",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::getTopLeft",1,"ofRectangle const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getTopLeft",1,SWIGTYPE_p_ofRectangle); } result = ((ofRectangle const *)arg1)->getTopLeft(); { - ofPoint * resultptr = new ofPoint((const ofPoint &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_getTopRight(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; ofPoint result; - SWIG_check_num_args("ofRectangle::getTopRight",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::getTopRight",1,"ofRectangle const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getTopRight",1,SWIGTYPE_p_ofRectangle); } result = ((ofRectangle const *)arg1)->getTopRight(); { - ofPoint * resultptr = new ofPoint((const ofPoint &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_getBottomLeft(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofPoint result; SWIG_check_num_args("ofRectangle::getBottomLeft",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::getBottomLeft",1,"ofRectangle const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getBottomLeft",1,SWIGTYPE_p_ofRectangle); } result = ((ofRectangle const *)arg1)->getBottomLeft(); - { ofPoint * resultptr = new ofPoint((const ofPoint &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_getBottomRight(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofPoint result; SWIG_check_num_args("ofRectangle::getBottomRight",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::getBottomRight",1,"ofRectangle const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getBottomRight",1,SWIGTYPE_p_ofRectangle); } - result = ((ofRectangle const *)arg1)->getBottomRight(); { ofPoint * resultptr = new ofPoint((const ofPoint &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_getHorzAnchor(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofAlignHorz arg2 ; float result; SWIG_check_num_args("ofRectangle::getHorzAnchor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::getHorzAnchor",1,"ofRectangle const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::getHorzAnchor",2,"ofAlignHorz"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getHorzAnchor",1,SWIGTYPE_p_ofRectangle); } arg2 = (ofAlignHorz)(int)lua_tonumber(L, 2); - result = (float)((ofRectangle const *)arg1)->getHorzAnchor(arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_getVertAnchor(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofAlignVert arg2 ; float result; SWIG_check_num_args("ofRectangle::getVertAnchor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::getVertAnchor",1,"ofRectangle const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::getVertAnchor",2,"ofAlignVert"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getVertAnchor",1,SWIGTYPE_p_ofRectangle); } arg2 = (ofAlignVert)(int)lua_tonumber(L, 2); - result = (float)((ofRectangle const *)arg1)->getVertAnchor(arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_getPosition(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; ofPoint result; - SWIG_check_num_args("ofRectangle::getPosition",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::getPosition",1,"ofRectangle const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getPosition",1,SWIGTYPE_p_ofRectangle); } result = ((ofRectangle const *)arg1)->getPosition(); { - ofPoint * resultptr = new ofPoint((const ofPoint &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_getPositionRef(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofPoint *result = 0 ; SWIG_check_num_args("ofRectangle::getPositionRef",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::getPositionRef",1,"ofRectangle *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getPositionRef",1,SWIGTYPE_p_ofRectangle); } result = (ofPoint *) &(arg1)->getPositionRef(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Rectangle_getCenter(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; ofPoint result; - SWIG_check_num_args("ofRectangle::getCenter",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::getCenter",1,"ofRectangle const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getCenter",1,SWIGTYPE_p_ofRectangle); } result = ((ofRectangle const *)arg1)->getCenter(); { - ofPoint * resultptr = new ofPoint((const ofPoint &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_getX(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float result; - SWIG_check_num_args("ofRectangle::getX",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::getX",1,"ofRectangle const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getX",1,SWIGTYPE_p_ofRectangle); } result = (float)((ofRectangle const *)arg1)->getX(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_getY(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float result; - SWIG_check_num_args("ofRectangle::getY",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::getY",1,"ofRectangle const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getY",1,SWIGTYPE_p_ofRectangle); } result = (float)((ofRectangle const *)arg1)->getY(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_getWidth(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float result; - SWIG_check_num_args("ofRectangle::getWidth",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::getWidth",1,"ofRectangle const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getWidth",1,SWIGTYPE_p_ofRectangle); } result = (float)((ofRectangle const *)arg1)->getWidth(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_getHeight(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float result; - SWIG_check_num_args("ofRectangle::getHeight",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::getHeight",1,"ofRectangle const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getHeight",1,SWIGTYPE_p_ofRectangle); } result = (float)((ofRectangle const *)arg1)->getHeight(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle___add(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; ofPoint *arg2 = 0 ; - ofRectangle result; SWIG_check_num_args("ofRectangle::operator +",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::operator +",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::operator +",2,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle___add",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Rectangle___add",2,SWIGTYPE_p_ofVec3f); } result = (arg1)->operator +((ofPoint const &)*arg2); { - ofRectangle * resultptr = new ofRectangle((const ofRectangle &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofRectangle,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle___sub(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; ofPoint *arg2 = 0 ; - ofRectangle result; SWIG_check_num_args("ofRectangle::operator -",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::operator -",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::operator -",2,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle___sub",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Rectangle___sub",2,SWIGTYPE_p_ofVec3f); } result = (arg1)->operator -((ofPoint const &)*arg2); { - ofRectangle * resultptr = new ofRectangle((const ofRectangle &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofRectangle,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle___eq(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofRectangle *arg2 = 0 ; bool result; SWIG_check_num_args("ofRectangle::operator ==",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::operator ==",1,"ofRectangle const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::operator ==",2,"ofRectangle const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle___eq",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle___eq",2,SWIGTYPE_p_ofRectangle); } - result = (bool)((ofRectangle const *)arg1)->operator ==((ofRectangle const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_isZero(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; bool result; - SWIG_check_num_args("ofRectangle::isZero",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::isZero",1,"ofRectangle const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_isZero",1,SWIGTYPE_p_ofRectangle); } result = (bool)((ofRectangle const *)arg1)->isZero(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_position_set(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofPoint *arg2 = (ofPoint *) 0 ; SWIG_check_num_args("ofRectangle::position",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::position",1,"ofRectangle *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofRectangle::position",2,"ofPoint *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_position_set",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Rectangle_position_set",2,SWIGTYPE_p_ofVec3f); } if (arg1) (arg1)->position = *arg2; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_position_get(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofPoint *result = 0 ; SWIG_check_num_args("ofRectangle::position",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::position",1,"ofRectangle *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_position_get",1,SWIGTYPE_p_ofRectangle); } result = (ofPoint *)& ((arg1)->position); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Rectangle_width_set(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float arg2 ; - SWIG_check_num_args("ofRectangle::width",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::width",1,"ofRectangle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::width",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_width_set",1,SWIGTYPE_p_ofRectangle); } arg2 = (float)lua_tonumber(L, 2); - if (arg1) (arg1)->width = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_width_get(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float result; - SWIG_check_num_args("ofRectangle::width",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::width",1,"ofRectangle *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_width_get",1,SWIGTYPE_p_ofRectangle); } result = (float) ((arg1)->width); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_height_set(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float arg2 ; - SWIG_check_num_args("ofRectangle::height",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::height",1,"ofRectangle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::height",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_height_set",1,SWIGTYPE_p_ofRectangle); } arg2 = (float)lua_tonumber(L, 2); - if (arg1) (arg1)->height = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_height_get(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float result; - SWIG_check_num_args("ofRectangle::height",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::height",1,"ofRectangle *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_height_get",1,SWIGTYPE_p_ofRectangle); } result = (float) ((arg1)->height); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_x_set(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float arg2 ; - SWIG_check_num_args("ofRectangle::x",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::x",1,"ofRectangle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::x",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_x_set",1,SWIGTYPE_p_ofRectangle); } arg2 = (float)lua_tonumber(L, 2); - ofRectangle_x_set(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_x_get(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float result; - SWIG_check_num_args("ofRectangle::x",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::x",1,"ofRectangle *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_x_get",1,SWIGTYPE_p_ofRectangle); } result = (float)ofRectangle_x_get(arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_y_set(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float arg2 ; - SWIG_check_num_args("ofRectangle::y",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::y",1,"ofRectangle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::y",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_y_set",1,SWIGTYPE_p_ofRectangle); } arg2 = (float)lua_tonumber(L, 2); - ofRectangle_y_set(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_y_get(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float result; - SWIG_check_num_args("ofRectangle::y",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::y",1,"ofRectangle *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_y_get",1,SWIGTYPE_p_ofRectangle); } result = (float)ofRectangle_y_get(arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle___tostring(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - char *result = 0 ; SWIG_check_num_args("ofRectangle::__str__",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::__str__",1,"ofRectangle *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle___tostring",1,SWIGTYPE_p_ofRectangle); } result = (char *)ofRectangle___str__(arg1); - lua_pushstring(L,(const char *)result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_Rectangle(void *obj) { -ofRectangle *arg1 = (ofRectangle *) obj; -delete arg1; -} -static int _proxy__wrap_new_Rectangle(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_Rectangle); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_Rectangle_attributes[] = { - { "position", _wrap_Rectangle_position_get, _wrap_Rectangle_position_set }, - { "width", _wrap_Rectangle_width_get, _wrap_Rectangle_width_set }, - { "height", _wrap_Rectangle_height_get, _wrap_Rectangle_height_set }, - { "x", _wrap_Rectangle_x_get, _wrap_Rectangle_x_set }, - { "y", _wrap_Rectangle_y_get, _wrap_Rectangle_y_set }, - {0,0,0} -}; -static swig_lua_method swig_Rectangle_methods[]= { - { "set", _wrap_Rectangle_set}, - { "setX", _wrap_Rectangle_setX}, - { "setY", _wrap_Rectangle_setY}, - { "setWidth", _wrap_Rectangle_setWidth}, - { "setHeight", _wrap_Rectangle_setHeight}, - { "setPosition", _wrap_Rectangle_setPosition}, - { "setSize", _wrap_Rectangle_setSize}, - { "setFromCenter", _wrap_Rectangle_setFromCenter}, - { "translate", _wrap_Rectangle_translate}, - { "translateX", _wrap_Rectangle_translateX}, - { "translateY", _wrap_Rectangle_translateY}, - { "scale", _wrap_Rectangle_scale}, - { "scaleWidth", _wrap_Rectangle_scaleWidth}, - { "scaleHeight", _wrap_Rectangle_scaleHeight}, - { "scaleFromCenter", _wrap_Rectangle_scaleFromCenter}, - { "scaleToScaleMode", _wrap_Rectangle_scaleToScaleMode}, - { "scaleToAspectRatio", _wrap_Rectangle_scaleToAspectRatio}, - { "scaleTo", _wrap_Rectangle_scaleTo}, - { "alignToHorz", _wrap_Rectangle_alignToHorz}, - { "alignToVert", _wrap_Rectangle_alignToVert}, - { "alignTo", _wrap_Rectangle_alignTo}, - { "inside", _wrap_Rectangle_inside}, - { "intersects", _wrap_Rectangle_intersects}, - { "growToInclude", _wrap_Rectangle_growToInclude}, - { "getIntersection", _wrap_Rectangle_getIntersection}, - { "getUnion", _wrap_Rectangle_getUnion}, - { "standardize", _wrap_Rectangle_standardize}, - { "getStandardized", _wrap_Rectangle_getStandardized}, - { "isStandardized", _wrap_Rectangle_isStandardized}, - { "getArea", _wrap_Rectangle_getArea}, - { "getPerimeter", _wrap_Rectangle_getPerimeter}, - { "getAspectRatio", _wrap_Rectangle_getAspectRatio}, - { "isEmpty", _wrap_Rectangle_isEmpty}, - { "getMin", _wrap_Rectangle_getMin}, - { "getMax", _wrap_Rectangle_getMax}, - { "getMinX", _wrap_Rectangle_getMinX}, - { "getMaxX", _wrap_Rectangle_getMaxX}, - { "getMinY", _wrap_Rectangle_getMinY}, - { "getMaxY", _wrap_Rectangle_getMaxY}, - { "getLeft", _wrap_Rectangle_getLeft}, - { "getRight", _wrap_Rectangle_getRight}, - { "getTop", _wrap_Rectangle_getTop}, - { "getBottom", _wrap_Rectangle_getBottom}, - { "getTopLeft", _wrap_Rectangle_getTopLeft}, - { "getTopRight", _wrap_Rectangle_getTopRight}, - { "getBottomLeft", _wrap_Rectangle_getBottomLeft}, - { "getBottomRight", _wrap_Rectangle_getBottomRight}, - { "getHorzAnchor", _wrap_Rectangle_getHorzAnchor}, - { "getVertAnchor", _wrap_Rectangle_getVertAnchor}, - { "getPosition", _wrap_Rectangle_getPosition}, - { "getPositionRef", _wrap_Rectangle_getPositionRef}, - { "getCenter", _wrap_Rectangle_getCenter}, - { "getX", _wrap_Rectangle_getX}, - { "getY", _wrap_Rectangle_getY}, - { "getWidth", _wrap_Rectangle_getWidth}, - { "getHeight", _wrap_Rectangle_getHeight}, - { "__add", _wrap_Rectangle___add}, - { "__sub", _wrap_Rectangle___sub}, - { "__eq", _wrap_Rectangle___eq}, - { "isZero", _wrap_Rectangle_isZero}, - { "__tostring", _wrap_Rectangle___tostring}, - {0,0} -}; -static swig_lua_method swig_Rectangle_meta[] = { - { "__add", _wrap_Rectangle___add}, - { "__sub", _wrap_Rectangle___sub}, - { "__eq", _wrap_Rectangle___eq}, - { "__tostring", _wrap_Rectangle___tostring}, - {0,0} -}; - -static swig_lua_attribute swig_Rectangle_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_Rectangle_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_Rectangle_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_Rectangle_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_Rectangle_Sf_SwigStatic = { - "Rectangle", - swig_Rectangle_Sf_SwigStatic_methods, - swig_Rectangle_Sf_SwigStatic_attributes, - swig_Rectangle_Sf_SwigStatic_constants, - swig_Rectangle_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_Rectangle_bases[] = {0}; -static const char *swig_Rectangle_base_names[] = {0}; -static swig_lua_class _wrap_class_Rectangle = { "Rectangle", "Rectangle", &SWIGTYPE_p_ofRectangle,_proxy__wrap_new_Rectangle, swig_delete_Rectangle, swig_Rectangle_methods, swig_Rectangle_attributes, &swig_Rectangle_Sf_SwigStatic, swig_Rectangle_meta, swig_Rectangle_bases, swig_Rectangle_base_names }; - -static int _wrap_new_SerialDeviceInfo__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string arg1 ; std::string arg2 ; int arg3 ; - ofSerialDeviceInfo *result = 0 ; SWIG_check_num_args("ofSerialDeviceInfo::ofSerialDeviceInfo",3,3) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofSerialDeviceInfo::ofSerialDeviceInfo",1,"std::string"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofSerialDeviceInfo::ofSerialDeviceInfo",2,"std::string"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofSerialDeviceInfo::ofSerialDeviceInfo",3,"int"); - (&arg1)->assign(lua_tostring(L,1),lua_rawlen(L,1)); (&arg2)->assign(lua_tostring(L,2),lua_rawlen(L,2)); - arg3 = (int)lua_tonumber(L, 3); result = (ofSerialDeviceInfo *)new ofSerialDeviceInfo(arg1,arg2,arg3); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofSerialDeviceInfo,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_SerialDeviceInfo__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofSerialDeviceInfo *result = 0 ; - SWIG_check_num_args("ofSerialDeviceInfo::ofSerialDeviceInfo",0,0) result = (ofSerialDeviceInfo *)new ofSerialDeviceInfo(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofSerialDeviceInfo,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_SerialDeviceInfo(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_SerialDeviceInfo__SWIG_1(L);} if (argc == 3) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { { - _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_new_SerialDeviceInfo__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SerialDeviceInfo'\n" - " Possible C/C++ prototypes are:\n" " ofSerialDeviceInfo::ofSerialDeviceInfo(std::string,std::string,int)\n" - " ofSerialDeviceInfo::ofSerialDeviceInfo()\n"); lua_error(L);return 0; } -static int _wrap_SerialDeviceInfo_getDevicePath(lua_State* L) { int SWIG_arg = 0; - ofSerialDeviceInfo *arg1 = (ofSerialDeviceInfo *) 0 ; std::string result; - SWIG_check_num_args("ofSerialDeviceInfo::getDevicePath",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSerialDeviceInfo::getDevicePath",1,"ofSerialDeviceInfo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSerialDeviceInfo,0))){ - SWIG_fail_ptr("SerialDeviceInfo_getDevicePath",1,SWIGTYPE_p_ofSerialDeviceInfo); } result = (arg1)->getDevicePath(); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_SerialDeviceInfo_getDeviceName(lua_State* L) { int SWIG_arg = 0; - ofSerialDeviceInfo *arg1 = (ofSerialDeviceInfo *) 0 ; std::string result; - SWIG_check_num_args("ofSerialDeviceInfo::getDeviceName",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSerialDeviceInfo::getDeviceName",1,"ofSerialDeviceInfo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSerialDeviceInfo,0))){ - SWIG_fail_ptr("SerialDeviceInfo_getDeviceName",1,SWIGTYPE_p_ofSerialDeviceInfo); } result = (arg1)->getDeviceName(); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_SerialDeviceInfo_getDeviceID(lua_State* L) { int SWIG_arg = 0; - ofSerialDeviceInfo *arg1 = (ofSerialDeviceInfo *) 0 ; int result; SWIG_check_num_args("ofSerialDeviceInfo::getDeviceID",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSerialDeviceInfo::getDeviceID",1,"ofSerialDeviceInfo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSerialDeviceInfo,0))){ - SWIG_fail_ptr("SerialDeviceInfo_getDeviceID",1,SWIGTYPE_p_ofSerialDeviceInfo); } result = (int)(arg1)->getDeviceID(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_SerialDeviceInfo(void *obj) { -ofSerialDeviceInfo *arg1 = (ofSerialDeviceInfo *) obj; -delete arg1; -} -static int _proxy__wrap_new_SerialDeviceInfo(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_SerialDeviceInfo); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_SerialDeviceInfo_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_SerialDeviceInfo_methods[]= { - { "getDevicePath", _wrap_SerialDeviceInfo_getDevicePath}, - { "getDeviceName", _wrap_SerialDeviceInfo_getDeviceName}, - { "getDeviceID", _wrap_SerialDeviceInfo_getDeviceID}, - {0,0} -}; -static swig_lua_method swig_SerialDeviceInfo_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_SerialDeviceInfo_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_SerialDeviceInfo_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_SerialDeviceInfo_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_SerialDeviceInfo_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_SerialDeviceInfo_Sf_SwigStatic = { - "SerialDeviceInfo", - swig_SerialDeviceInfo_Sf_SwigStatic_methods, - swig_SerialDeviceInfo_Sf_SwigStatic_attributes, - swig_SerialDeviceInfo_Sf_SwigStatic_constants, - swig_SerialDeviceInfo_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_SerialDeviceInfo_bases[] = {0}; -static const char *swig_SerialDeviceInfo_base_names[] = {0}; -static swig_lua_class _wrap_class_SerialDeviceInfo = { "SerialDeviceInfo", "SerialDeviceInfo", &SWIGTYPE_p_ofSerialDeviceInfo,_proxy__wrap_new_SerialDeviceInfo, swig_delete_SerialDeviceInfo, swig_SerialDeviceInfo_methods, swig_SerialDeviceInfo_attributes, &swig_SerialDeviceInfo_Sf_SwigStatic, swig_SerialDeviceInfo_meta, swig_SerialDeviceInfo_bases, swig_SerialDeviceInfo_base_names }; - -static int _wrap_new_Style(lua_State* L) { int SWIG_arg = 0; ofStyle *result = 0 ; SWIG_check_num_args("ofStyle::ofStyle",0,0) - result = (ofStyle *)new ofStyle(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofStyle,1); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Style_color_set(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; - ofColor *arg2 = (ofColor *) 0 ; SWIG_check_num_args("ofStyle::color",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::color",1,"ofStyle *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofStyle::color",2,"ofColor *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ - SWIG_fail_ptr("Style_color_set",1,SWIGTYPE_p_ofStyle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Style_color_set",2,SWIGTYPE_p_ofColor_T_unsigned_char_t); } if (arg1) (arg1)->color = *arg2; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Style_color_get(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; ofColor *result = 0 ; - SWIG_check_num_args("ofStyle::color",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::color",1,"ofStyle *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ - SWIG_fail_ptr("Style_color_get",1,SWIGTYPE_p_ofStyle); } result = (ofColor *)& ((arg1)->color); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Style_bgColor_set(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; - ofColor *arg2 = (ofColor *) 0 ; SWIG_check_num_args("ofStyle::bgColor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::bgColor",1,"ofStyle *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofStyle::bgColor",2,"ofColor *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ - SWIG_fail_ptr("Style_bgColor_set",1,SWIGTYPE_p_ofStyle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Style_bgColor_set",2,SWIGTYPE_p_ofColor_T_unsigned_char_t); } if (arg1) (arg1)->bgColor = *arg2; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Style_bgColor_get(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; ofColor *result = 0 ; - SWIG_check_num_args("ofStyle::bgColor",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::bgColor",1,"ofStyle *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ - SWIG_fail_ptr("Style_bgColor_get",1,SWIGTYPE_p_ofStyle); } result = (ofColor *)& ((arg1)->bgColor); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Style_polyMode_set(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; ofPolyWindingMode arg2 ; - SWIG_check_num_args("ofStyle::polyMode",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::polyMode",1,"ofStyle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofStyle::polyMode",2,"ofPolyWindingMode"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ - SWIG_fail_ptr("Style_polyMode_set",1,SWIGTYPE_p_ofStyle); } arg2 = (ofPolyWindingMode)(int)lua_tonumber(L, 2); - if (arg1) (arg1)->polyMode = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Style_polyMode_get(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; ofPolyWindingMode result; - SWIG_check_num_args("ofStyle::polyMode",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::polyMode",1,"ofStyle *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ - SWIG_fail_ptr("Style_polyMode_get",1,SWIGTYPE_p_ofStyle); } result = (ofPolyWindingMode) ((arg1)->polyMode); - lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Style_rectMode_set(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; ofRectMode arg2 ; - SWIG_check_num_args("ofStyle::rectMode",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::rectMode",1,"ofStyle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofStyle::rectMode",2,"ofRectMode"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ - SWIG_fail_ptr("Style_rectMode_set",1,SWIGTYPE_p_ofStyle); } arg2 = (ofRectMode)(int)lua_tonumber(L, 2); - if (arg1) (arg1)->rectMode = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Style_rectMode_get(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; ofRectMode result; - SWIG_check_num_args("ofStyle::rectMode",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::rectMode",1,"ofStyle *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ - SWIG_fail_ptr("Style_rectMode_get",1,SWIGTYPE_p_ofStyle); } result = (ofRectMode) ((arg1)->rectMode); - lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Style_bFill_set(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; bool arg2 ; - SWIG_check_num_args("ofStyle::bFill",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::bFill",1,"ofStyle *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofStyle::bFill",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ - SWIG_fail_ptr("Style_bFill_set",1,SWIGTYPE_p_ofStyle); } arg2 = (lua_toboolean(L, 2)!=0); if (arg1) (arg1)->bFill = arg2; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Style_bFill_get(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; bool result; - SWIG_check_num_args("ofStyle::bFill",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::bFill",1,"ofStyle *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ - SWIG_fail_ptr("Style_bFill_get",1,SWIGTYPE_p_ofStyle); } result = (bool) ((arg1)->bFill); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Style_drawBitmapMode_set(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; - ofDrawBitmapMode arg2 ; SWIG_check_num_args("ofStyle::drawBitmapMode",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::drawBitmapMode",1,"ofStyle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofStyle::drawBitmapMode",2,"ofDrawBitmapMode"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ - SWIG_fail_ptr("Style_drawBitmapMode_set",1,SWIGTYPE_p_ofStyle); } arg2 = (ofDrawBitmapMode)(int)lua_tonumber(L, 2); - if (arg1) (arg1)->drawBitmapMode = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Style_drawBitmapMode_get(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; - ofDrawBitmapMode result; SWIG_check_num_args("ofStyle::drawBitmapMode",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::drawBitmapMode",1,"ofStyle *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ - SWIG_fail_ptr("Style_drawBitmapMode_get",1,SWIGTYPE_p_ofStyle); } result = (ofDrawBitmapMode) ((arg1)->drawBitmapMode); - lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Style_blendingMode_set(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; ofBlendMode arg2 ; - SWIG_check_num_args("ofStyle::blendingMode",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::blendingMode",1,"ofStyle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofStyle::blendingMode",2,"ofBlendMode"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ - SWIG_fail_ptr("Style_blendingMode_set",1,SWIGTYPE_p_ofStyle); } arg2 = (ofBlendMode)(int)lua_tonumber(L, 2); - if (arg1) (arg1)->blendingMode = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Style_blendingMode_get(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; ofBlendMode result; - SWIG_check_num_args("ofStyle::blendingMode",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::blendingMode",1,"ofStyle *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ - SWIG_fail_ptr("Style_blendingMode_get",1,SWIGTYPE_p_ofStyle); } result = (ofBlendMode) ((arg1)->blendingMode); - lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Style_smoothing_set(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; bool arg2 ; - SWIG_check_num_args("ofStyle::smoothing",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::smoothing",1,"ofStyle *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofStyle::smoothing",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ - SWIG_fail_ptr("Style_smoothing_set",1,SWIGTYPE_p_ofStyle); } arg2 = (lua_toboolean(L, 2)!=0); - if (arg1) (arg1)->smoothing = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Style_smoothing_get(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; bool result; - SWIG_check_num_args("ofStyle::smoothing",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::smoothing",1,"ofStyle *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ - SWIG_fail_ptr("Style_smoothing_get",1,SWIGTYPE_p_ofStyle); } result = (bool) ((arg1)->smoothing); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Style_circleResolution_set(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; int arg2 ; - SWIG_check_num_args("ofStyle::circleResolution",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::circleResolution",1,"ofStyle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofStyle::circleResolution",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ - SWIG_fail_ptr("Style_circleResolution_set",1,SWIGTYPE_p_ofStyle); } arg2 = (int)lua_tonumber(L, 2); - if (arg1) (arg1)->circleResolution = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Style_circleResolution_get(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; int result; - SWIG_check_num_args("ofStyle::circleResolution",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::circleResolution",1,"ofStyle *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ - SWIG_fail_ptr("Style_circleResolution_get",1,SWIGTYPE_p_ofStyle); } result = (int) ((arg1)->circleResolution); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Style_sphereResolution_set(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; int arg2 ; - SWIG_check_num_args("ofStyle::sphereResolution",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::sphereResolution",1,"ofStyle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofStyle::sphereResolution",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ - SWIG_fail_ptr("Style_sphereResolution_set",1,SWIGTYPE_p_ofStyle); } arg2 = (int)lua_tonumber(L, 2); - if (arg1) (arg1)->sphereResolution = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Style_sphereResolution_get(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; int result; - SWIG_check_num_args("ofStyle::sphereResolution",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::sphereResolution",1,"ofStyle *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ - SWIG_fail_ptr("Style_sphereResolution_get",1,SWIGTYPE_p_ofStyle); } result = (int) ((arg1)->sphereResolution); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Style_curveResolution_set(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; int arg2 ; - SWIG_check_num_args("ofStyle::curveResolution",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::curveResolution",1,"ofStyle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofStyle::curveResolution",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ - SWIG_fail_ptr("Style_curveResolution_set",1,SWIGTYPE_p_ofStyle); } arg2 = (int)lua_tonumber(L, 2); - if (arg1) (arg1)->curveResolution = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Style_curveResolution_get(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; int result; - SWIG_check_num_args("ofStyle::curveResolution",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::curveResolution",1,"ofStyle *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ - SWIG_fail_ptr("Style_curveResolution_get",1,SWIGTYPE_p_ofStyle); } result = (int) ((arg1)->curveResolution); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Style_lineWidth_set(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; float arg2 ; - SWIG_check_num_args("ofStyle::lineWidth",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::lineWidth",1,"ofStyle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofStyle::lineWidth",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ - SWIG_fail_ptr("Style_lineWidth_set",1,SWIGTYPE_p_ofStyle); } arg2 = (float)lua_tonumber(L, 2); - if (arg1) (arg1)->lineWidth = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Style_lineWidth_get(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; float result; - SWIG_check_num_args("ofStyle::lineWidth",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::lineWidth",1,"ofStyle *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ - SWIG_fail_ptr("Style_lineWidth_get",1,SWIGTYPE_p_ofStyle); } result = (float) ((arg1)->lineWidth); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_Style(void *obj) { -ofStyle *arg1 = (ofStyle *) obj; -delete arg1; -} -static int _proxy__wrap_new_Style(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_Style); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_Style_attributes[] = { - { "color", _wrap_Style_color_get, _wrap_Style_color_set }, - { "bgColor", _wrap_Style_bgColor_get, _wrap_Style_bgColor_set }, - { "polyMode", _wrap_Style_polyMode_get, _wrap_Style_polyMode_set }, - { "rectMode", _wrap_Style_rectMode_get, _wrap_Style_rectMode_set }, - { "bFill", _wrap_Style_bFill_get, _wrap_Style_bFill_set }, - { "drawBitmapMode", _wrap_Style_drawBitmapMode_get, _wrap_Style_drawBitmapMode_set }, - { "blendingMode", _wrap_Style_blendingMode_get, _wrap_Style_blendingMode_set }, - { "smoothing", _wrap_Style_smoothing_get, _wrap_Style_smoothing_set }, - { "circleResolution", _wrap_Style_circleResolution_get, _wrap_Style_circleResolution_set }, - { "sphereResolution", _wrap_Style_sphereResolution_get, _wrap_Style_sphereResolution_set }, - { "curveResolution", _wrap_Style_curveResolution_get, _wrap_Style_curveResolution_set }, - { "lineWidth", _wrap_Style_lineWidth_get, _wrap_Style_lineWidth_set }, - {0,0,0} -}; -static swig_lua_method swig_Style_methods[]= { - {0,0} -}; -static swig_lua_method swig_Style_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_Style_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_Style_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_Style_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_Style_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_Style_Sf_SwigStatic = { - "Style", - swig_Style_Sf_SwigStatic_methods, - swig_Style_Sf_SwigStatic_attributes, - swig_Style_Sf_SwigStatic_constants, - swig_Style_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_Style_bases[] = {0}; -static const char *swig_Style_base_names[] = {0}; -static swig_lua_class _wrap_class_Style = { "Style", "Style", &SWIGTYPE_p_ofStyle,_proxy__wrap_new_Style, swig_delete_Style, swig_Style_methods, swig_Style_attributes, &swig_Style_Sf_SwigStatic, swig_Style_meta, swig_Style_bases, swig_Style_base_names }; - -static int _wrap_new_FpsCounter__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofFpsCounter *result = 0 ; - SWIG_check_num_args("ofFpsCounter::ofFpsCounter",0,0) result = (ofFpsCounter *)new ofFpsCounter(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofFpsCounter,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_FpsCounter__SWIG_1(lua_State* L) { int SWIG_arg = 0; double arg1 ; ofFpsCounter *result = 0 ; - SWIG_check_num_args("ofFpsCounter::ofFpsCounter",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofFpsCounter::ofFpsCounter",1,"double"); arg1 = (double)lua_tonumber(L, 1); - result = (ofFpsCounter *)new ofFpsCounter(arg1); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofFpsCounter,1); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_new_FpsCounter(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_FpsCounter__SWIG_0(L);} if (argc == 1) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { - return _wrap_new_FpsCounter__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_FpsCounter'\n" " Possible C/C++ prototypes are:\n" - " ofFpsCounter::ofFpsCounter()\n" " ofFpsCounter::ofFpsCounter(double)\n"); lua_error(L);return 0; } -static int _wrap_FpsCounter_newFrame(lua_State* L) { int SWIG_arg = 0; ofFpsCounter *arg1 = (ofFpsCounter *) 0 ; - SWIG_check_num_args("ofFpsCounter::newFrame",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFpsCounter::newFrame",1,"ofFpsCounter *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFpsCounter,0))){ - SWIG_fail_ptr("FpsCounter_newFrame",1,SWIGTYPE_p_ofFpsCounter); } (arg1)->newFrame(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_FpsCounter_update(lua_State* L) { int SWIG_arg = 0; ofFpsCounter *arg1 = (ofFpsCounter *) 0 ; - SWIG_check_num_args("ofFpsCounter::update",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFpsCounter::update",1,"ofFpsCounter *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFpsCounter,0))){ - SWIG_fail_ptr("FpsCounter_update",1,SWIGTYPE_p_ofFpsCounter); } (arg1)->update(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FpsCounter_getFps(lua_State* L) { int SWIG_arg = 0; ofFpsCounter *arg1 = (ofFpsCounter *) 0 ; double result; - SWIG_check_num_args("ofFpsCounter::getFps",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFpsCounter::getFps",1,"ofFpsCounter const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFpsCounter,0))){ - SWIG_fail_ptr("FpsCounter_getFps",1,SWIGTYPE_p_ofFpsCounter); } result = (double)((ofFpsCounter const *)arg1)->getFps(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FpsCounter_getNumFrames(lua_State* L) { int SWIG_arg = 0; ofFpsCounter *arg1 = (ofFpsCounter *) 0 ; - uint64_t result; SWIG_check_num_args("ofFpsCounter::getNumFrames",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFpsCounter::getNumFrames",1,"ofFpsCounter const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFpsCounter,0))){ - SWIG_fail_ptr("FpsCounter_getNumFrames",1,SWIGTYPE_p_ofFpsCounter); } - result = (uint64_t)((ofFpsCounter const *)arg1)->getNumFrames(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FpsCounter_getLastFrameNanos(lua_State* L) { int SWIG_arg = 0; ofFpsCounter *arg1 = (ofFpsCounter *) 0 ; - uint64_t result; SWIG_check_num_args("ofFpsCounter::getLastFrameNanos",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFpsCounter::getLastFrameNanos",1,"ofFpsCounter const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFpsCounter,0))){ - SWIG_fail_ptr("FpsCounter_getLastFrameNanos",1,SWIGTYPE_p_ofFpsCounter); } - result = (uint64_t)((ofFpsCounter const *)arg1)->getLastFrameNanos(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FpsCounter_getLastFrameSecs(lua_State* L) { int SWIG_arg = 0; ofFpsCounter *arg1 = (ofFpsCounter *) 0 ; - double result; SWIG_check_num_args("ofFpsCounter::getLastFrameSecs",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFpsCounter::getLastFrameSecs",1,"ofFpsCounter const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFpsCounter,0))){ - SWIG_fail_ptr("FpsCounter_getLastFrameSecs",1,SWIGTYPE_p_ofFpsCounter); } - result = (double)((ofFpsCounter const *)arg1)->getLastFrameSecs(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_FpsCounter(void *obj) { -ofFpsCounter *arg1 = (ofFpsCounter *) obj; -delete arg1; -} -static int _proxy__wrap_new_FpsCounter(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_FpsCounter); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_FpsCounter_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_FpsCounter_methods[]= { - { "newFrame", _wrap_FpsCounter_newFrame}, - { "update", _wrap_FpsCounter_update}, - { "getFps", _wrap_FpsCounter_getFps}, - { "getNumFrames", _wrap_FpsCounter_getNumFrames}, - { "getLastFrameNanos", _wrap_FpsCounter_getLastFrameNanos}, - { "getLastFrameSecs", _wrap_FpsCounter_getLastFrameSecs}, - {0,0} -}; -static swig_lua_method swig_FpsCounter_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_FpsCounter_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_FpsCounter_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_FpsCounter_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_FpsCounter_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_FpsCounter_Sf_SwigStatic = { - "FpsCounter", - swig_FpsCounter_Sf_SwigStatic_methods, - swig_FpsCounter_Sf_SwigStatic_attributes, - swig_FpsCounter_Sf_SwigStatic_constants, - swig_FpsCounter_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_FpsCounter_bases[] = {0}; -static const char *swig_FpsCounter_base_names[] = {0}; -static swig_lua_class _wrap_class_FpsCounter = { "FpsCounter", "FpsCounter", &SWIGTYPE_p_ofFpsCounter,_proxy__wrap_new_FpsCounter, swig_delete_FpsCounter, swig_FpsCounter_methods, swig_FpsCounter_attributes, &swig_FpsCounter_Sf_SwigStatic, swig_FpsCounter_meta, swig_FpsCounter_bases, swig_FpsCounter_base_names }; - -static int _wrap_new_Xml__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofXml *result = 0 ; SWIG_check_num_args("ofXml::ofXml",0,0) - result = (ofXml *)new ofXml(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofXml,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_new_Xml__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - ofXml *result = 0 ; SWIG_check_num_args("ofXml::ofXml",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofXml::ofXml",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = (ofXml *)new ofXml((std::string const &)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofXml,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Xml__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = 0 ; ofXml *result = 0 ; - SWIG_check_num_args("ofXml::ofXml",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofXml::ofXml",1,"ofXml const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("new_Xml",1,SWIGTYPE_p_ofXml); } - result = (ofXml *)new ofXml((ofXml const &)*arg1); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofXml,1); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_new_Xml(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_Xml__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXml, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_new_Xml__SWIG_2(L);} } if (argc == 1) { int _v; { _v = lua_isstring(L,argv[0]); } - if (_v) { return _wrap_new_Xml__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_Xml'\n" " Possible C/C++ prototypes are:\n" - " ofXml::ofXml()\n" " ofXml::ofXml(std::string const &)\n" " ofXml::ofXml(ofXml const &)\n"); lua_error(L);return 0; } -static int _wrap_Xml_load(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; std::string *arg2 = 0 ; - std::string temp2 ; bool result; SWIG_check_num_args("ofXml::load",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::load",1,"ofXml *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofXml::load",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_load",1,SWIGTYPE_p_ofXml); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; result = (bool)(arg1)->load((std::string const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_save(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; std::string *arg2 = 0 ; - std::string temp2 ; bool result; SWIG_check_num_args("ofXml::save",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::save",1,"ofXml *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofXml::save",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_save",1,SWIGTYPE_p_ofXml); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; result = (bool)(arg1)->save((std::string const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_addChild(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; std::string *arg2 = 0 ; - std::string temp2 ; bool result; SWIG_check_num_args("ofXml::addChild",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::addChild",1,"ofXml *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofXml::addChild",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_addChild",1,SWIGTYPE_p_ofXml); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; result = (bool)(arg1)->addChild((std::string const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_addXml__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; ofXml *arg2 = 0 ; bool arg3 ; - SWIG_check_num_args("ofXml::addXml",3,3) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::addXml",1,"ofXml *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofXml::addXml",2,"ofXml &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofXml::addXml",3,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_addXml",1,SWIGTYPE_p_ofXml); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_addXml",2,SWIGTYPE_p_ofXml); } - arg3 = (lua_toboolean(L, 3)!=0); (arg1)->addXml(*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Xml_addXml__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; ofXml *arg2 = 0 ; - SWIG_check_num_args("ofXml::addXml",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::addXml",1,"ofXml *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofXml::addXml",2,"ofXml &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_addXml",1,SWIGTYPE_p_ofXml); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_addXml",2,SWIGTYPE_p_ofXml); } - (arg1)->addXml(*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_addXml(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXml, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofXml, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_Xml_addXml__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXml, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofXml, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { return _wrap_Xml_addXml__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Xml_addXml'\n" " Possible C/C++ prototypes are:\n" - " ofXml::addXml(ofXml &,bool)\n" " ofXml::addXml(ofXml &)\n"); lua_error(L);return 0; } -static int _wrap_Xml_getValue__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; std::string result; - SWIG_check_num_args("ofXml::getValue",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::getValue",1,"ofXml const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_getValue",1,SWIGTYPE_p_ofXml); } - result = ((ofXml const *)arg1)->getValue(); lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_getValue__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; std::string *arg2 = 0 ; - std::string temp2 ; std::string result; SWIG_check_num_args("ofXml::getValue",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::getValue",1,"ofXml const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofXml::getValue",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_getValue",1,SWIGTYPE_p_ofXml); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = ((ofXml const *)arg1)->getValue((std::string const &)*arg2); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Xml_getValue(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXml, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Xml_getValue__SWIG_0(L);} } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXml, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { return _wrap_Xml_getValue__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Xml_getValue'\n" " Possible C/C++ prototypes are:\n" - " ofXml::getValue() const\n" " ofXml::getValue(std::string const &) const\n"); lua_error(L);return 0; } -static int _wrap_Xml_getIntValue__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; int result; - SWIG_check_num_args("ofXml::getIntValue",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::getIntValue",1,"ofXml const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_getIntValue",1,SWIGTYPE_p_ofXml); } - result = (int)((ofXml const *)arg1)->getIntValue(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_getIntValue__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; std::string *arg2 = 0 ; - std::string temp2 ; int result; SWIG_check_num_args("ofXml::getIntValue",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::getIntValue",1,"ofXml const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofXml::getIntValue",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_getIntValue",1,SWIGTYPE_p_ofXml); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = (int)((ofXml const *)arg1)->getIntValue((std::string const &)*arg2); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_getIntValue(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXml, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Xml_getIntValue__SWIG_0(L);} } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXml, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { return _wrap_Xml_getIntValue__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Xml_getIntValue'\n" " Possible C/C++ prototypes are:\n" - " ofXml::getIntValue() const\n" " ofXml::getIntValue(std::string const &) const\n"); lua_error(L);return 0; } -static int _wrap_Xml_getInt64Value__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; int64_t result; - SWIG_check_num_args("ofXml::getInt64Value",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::getInt64Value",1,"ofXml const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ - SWIG_fail_ptr("Xml_getInt64Value",1,SWIGTYPE_p_ofXml); } result = (int64_t)((ofXml const *)arg1)->getInt64Value(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_getInt64Value__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; std::string *arg2 = 0 ; - std::string temp2 ; int64_t result; SWIG_check_num_args("ofXml::getInt64Value",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::getInt64Value",1,"ofXml const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofXml::getInt64Value",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ - SWIG_fail_ptr("Xml_getInt64Value",1,SWIGTYPE_p_ofXml); } temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = (int64_t)((ofXml const *)arg1)->getInt64Value((std::string const &)*arg2); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_getInt64Value(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXml, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Xml_getInt64Value__SWIG_0(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXml, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { return _wrap_Xml_getInt64Value__SWIG_1(L);} } - } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Xml_getInt64Value'\n" - " Possible C/C++ prototypes are:\n" " ofXml::getInt64Value() const\n" - " ofXml::getInt64Value(std::string const &) const\n"); lua_error(L);return 0; } -static int _wrap_Xml_getFloatValue__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; float result; - SWIG_check_num_args("ofXml::getFloatValue",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::getFloatValue",1,"ofXml const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ - SWIG_fail_ptr("Xml_getFloatValue",1,SWIGTYPE_p_ofXml); } result = (float)((ofXml const *)arg1)->getFloatValue(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_getFloatValue__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; std::string *arg2 = 0 ; - std::string temp2 ; float result; SWIG_check_num_args("ofXml::getFloatValue",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::getFloatValue",1,"ofXml const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofXml::getFloatValue",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ - SWIG_fail_ptr("Xml_getFloatValue",1,SWIGTYPE_p_ofXml); } temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = (float)((ofXml const *)arg1)->getFloatValue((std::string const &)*arg2); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_getFloatValue(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXml, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Xml_getFloatValue__SWIG_0(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXml, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { return _wrap_Xml_getFloatValue__SWIG_1(L);} } - } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Xml_getFloatValue'\n" - " Possible C/C++ prototypes are:\n" " ofXml::getFloatValue() const\n" - " ofXml::getFloatValue(std::string const &) const\n"); lua_error(L);return 0; } -static int _wrap_Xml_getBoolValue__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; bool result; - SWIG_check_num_args("ofXml::getBoolValue",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::getBoolValue",1,"ofXml const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_getBoolValue",1,SWIGTYPE_p_ofXml); } - result = (bool)((ofXml const *)arg1)->getBoolValue(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_getBoolValue__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; std::string *arg2 = 0 ; - std::string temp2 ; bool result; SWIG_check_num_args("ofXml::getBoolValue",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::getBoolValue",1,"ofXml const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofXml::getBoolValue",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_getBoolValue",1,SWIGTYPE_p_ofXml); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = (bool)((ofXml const *)arg1)->getBoolValue((std::string const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_getBoolValue(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXml, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Xml_getBoolValue__SWIG_0(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXml, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { return _wrap_Xml_getBoolValue__SWIG_1(L);} } - } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Xml_getBoolValue'\n" - " Possible C/C++ prototypes are:\n" " ofXml::getBoolValue() const\n" - " ofXml::getBoolValue(std::string const &) const\n"); lua_error(L);return 0; } -static int _wrap_Xml_setValue(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; std::string *arg2 = 0 ; - std::string *arg3 = 0 ; std::string temp2 ; std::string temp3 ; bool result; SWIG_check_num_args("ofXml::setValue",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::setValue",1,"ofXml *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofXml::setValue",2,"std::string const &"); - if(!lua_isstring(L,3)) SWIG_fail_arg("ofXml::setValue",3,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_setValue",1,SWIGTYPE_p_ofXml); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3; - result = (bool)(arg1)->setValue((std::string const &)*arg2,(std::string const &)*arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_getAttribute(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; std::string *arg2 = 0 ; - std::string temp2 ; std::string result; SWIG_check_num_args("ofXml::getAttribute",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::getAttribute",1,"ofXml const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofXml::getAttribute",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_getAttribute",1,SWIGTYPE_p_ofXml); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = ((ofXml const *)arg1)->getAttribute((std::string const &)*arg2); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Xml_setAttribute(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; std::string *arg2 = 0 ; - std::string *arg3 = 0 ; std::string temp2 ; std::string temp3 ; bool result; SWIG_check_num_args("ofXml::setAttribute",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::setAttribute",1,"ofXml *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofXml::setAttribute",2,"std::string const &"); - if(!lua_isstring(L,3)) SWIG_fail_arg("ofXml::setAttribute",3,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_setAttribute",1,SWIGTYPE_p_ofXml); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3; - result = (bool)(arg1)->setAttribute((std::string const &)*arg2,(std::string const &)*arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_getAttributes(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; - SwigValueWrapper< std::map< std::string,std::string > > result; SWIG_check_num_args("ofXml::getAttributes",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::getAttributes",1,"ofXml const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ - SWIG_fail_ptr("Xml_getAttributes",1,SWIGTYPE_p_ofXml); } result = ((ofXml const *)arg1)->getAttributes(); { - std::map< std::string,std::string > * resultptr = new std::map< std::string,std::string >((const std::map< std::string,std::string > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__mapT_std__string_std__string_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_getNumChildren__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; int result; - SWIG_check_num_args("ofXml::getNumChildren",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::getNumChildren",1,"ofXml const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ - SWIG_fail_ptr("Xml_getNumChildren",1,SWIGTYPE_p_ofXml); } result = (int)((ofXml const *)arg1)->getNumChildren(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_getNumChildren__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; - std::string *arg2 = 0 ; std::string temp2 ; int result; SWIG_check_num_args("ofXml::getNumChildren",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::getNumChildren",1,"ofXml const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofXml::getNumChildren",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ - SWIG_fail_ptr("Xml_getNumChildren",1,SWIGTYPE_p_ofXml); } temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = (int)((ofXml const *)arg1)->getNumChildren((std::string const &)*arg2); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_getNumChildren(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXml, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Xml_getNumChildren__SWIG_0(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXml, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { return _wrap_Xml_getNumChildren__SWIG_1(L);} - } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Xml_getNumChildren'\n" - " Possible C/C++ prototypes are:\n" " ofXml::getNumChildren() const\n" - " ofXml::getNumChildren(std::string const &) const\n"); lua_error(L);return 0; } -static int _wrap_Xml_removeAttribute(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; std::string *arg2 = 0 ; - std::string temp2 ; bool result; SWIG_check_num_args("ofXml::removeAttribute",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::removeAttribute",1,"ofXml *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofXml::removeAttribute",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ - SWIG_fail_ptr("Xml_removeAttribute",1,SWIGTYPE_p_ofXml); } temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = (bool)(arg1)->removeAttribute((std::string const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_removeAttributes__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; - std::string *arg2 = 0 ; std::string temp2 ; bool result; SWIG_check_num_args("ofXml::removeAttributes",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::removeAttributes",1,"ofXml *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofXml::removeAttributes",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ - SWIG_fail_ptr("Xml_removeAttributes",1,SWIGTYPE_p_ofXml); } temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = (bool)(arg1)->removeAttributes((std::string const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_removeAttributes__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; bool result; - SWIG_check_num_args("ofXml::removeAttributes",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::removeAttributes",1,"ofXml *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ - SWIG_fail_ptr("Xml_removeAttributes",1,SWIGTYPE_p_ofXml); } result = (bool)(arg1)->removeAttributes(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_removeAttributes(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXml, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Xml_removeAttributes__SWIG_1(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXml, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { return _wrap_Xml_removeAttributes__SWIG_0(L);} - } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Xml_removeAttributes'\n" - " Possible C/C++ prototypes are:\n" " ofXml::removeAttributes(std::string const &)\n" " ofXml::removeAttributes()\n"); - lua_error(L);return 0; } -static int _wrap_Xml_removeContents__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; - std::string *arg2 = 0 ; std::string temp2 ; bool result; SWIG_check_num_args("ofXml::removeContents",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::removeContents",1,"ofXml *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofXml::removeContents",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ - SWIG_fail_ptr("Xml_removeContents",1,SWIGTYPE_p_ofXml); } temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = (bool)(arg1)->removeContents((std::string const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_removeContents__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; bool result; - SWIG_check_num_args("ofXml::removeContents",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::removeContents",1,"ofXml *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ - SWIG_fail_ptr("Xml_removeContents",1,SWIGTYPE_p_ofXml); } result = (bool)(arg1)->removeContents(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_removeContents(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXml, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Xml_removeContents__SWIG_1(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXml, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { return _wrap_Xml_removeContents__SWIG_0(L);} - } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Xml_removeContents'\n" - " Possible C/C++ prototypes are:\n" " ofXml::removeContents(std::string const &)\n" " ofXml::removeContents()\n"); - lua_error(L);return 0; } -static int _wrap_Xml_remove__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; std::string *arg2 = 0 ; - std::string temp2 ; bool result; SWIG_check_num_args("ofXml::remove",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::remove",1,"ofXml *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofXml::remove",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_remove",1,SWIGTYPE_p_ofXml); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; result = (bool)(arg1)->remove((std::string const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_remove__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; - SWIG_check_num_args("ofXml::remove",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::remove",1,"ofXml *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_remove",1,SWIGTYPE_p_ofXml); } - (arg1)->remove(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_remove(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXml, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Xml_remove__SWIG_1(L);} } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXml, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { return _wrap_Xml_remove__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Xml_remove'\n" " Possible C/C++ prototypes are:\n" - " ofXml::remove(std::string const &)\n" " ofXml::remove()\n"); lua_error(L);return 0; } -static int _wrap_Xml_exists(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; std::string *arg2 = 0 ; - std::string temp2 ; bool result; SWIG_check_num_args("ofXml::exists",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::exists",1,"ofXml const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofXml::exists",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_exists",1,SWIGTYPE_p_ofXml); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = (bool)((ofXml const *)arg1)->exists((std::string const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_clear(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; SWIG_check_num_args("ofXml::clear",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::clear",1,"ofXml *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_clear",1,SWIGTYPE_p_ofXml); } - (arg1)->clear(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_getName(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; std::string result; - SWIG_check_num_args("ofXml::getName",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::getName",1,"ofXml const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_getName",1,SWIGTYPE_p_ofXml); } - result = ((ofXml const *)arg1)->getName(); lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_reset(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; bool result; - SWIG_check_num_args("ofXml::reset",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::reset",1,"ofXml *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_reset",1,SWIGTYPE_p_ofXml); } - result = (bool)(arg1)->reset(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Xml_setToChild(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; unsigned long arg2 ; bool result; - SWIG_check_num_args("ofXml::setToChild",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::setToChild",1,"ofXml *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofXml::setToChild",2,"unsigned long"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_setToChild",1,SWIGTYPE_p_ofXml); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned long)lua_tonumber(L, 2); - result = (bool)(arg1)->setToChild(arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_setTo(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; std::string *arg2 = 0 ; - std::string temp2 ; bool result; SWIG_check_num_args("ofXml::setTo",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::setTo",1,"ofXml *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofXml::setTo",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_setTo",1,SWIGTYPE_p_ofXml); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; result = (bool)(arg1)->setTo((std::string const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_setToParent__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; bool result; - SWIG_check_num_args("ofXml::setToParent",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::setToParent",1,"ofXml *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_setToParent",1,SWIGTYPE_p_ofXml); } - result = (bool)(arg1)->setToParent(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_setToParent__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; int arg2 ; bool result; - SWIG_check_num_args("ofXml::setToParent",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::setToParent",1,"ofXml *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofXml::setToParent",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_setToParent",1,SWIGTYPE_p_ofXml); } - arg2 = (int)lua_tonumber(L, 2); result = (bool)(arg1)->setToParent(arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_setToParent(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXml, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Xml_setToParent__SWIG_0(L);} } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXml, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Xml_setToParent__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Xml_setToParent'\n" " Possible C/C++ prototypes are:\n" - " ofXml::setToParent()\n" " ofXml::setToParent(int)\n"); lua_error(L);return 0; } -static int _wrap_Xml_setToSibling(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; bool result; - SWIG_check_num_args("ofXml::setToSibling",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::setToSibling",1,"ofXml *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_setToSibling",1,SWIGTYPE_p_ofXml); } - result = (bool)(arg1)->setToSibling(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_setToPrevSibling(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; bool result; - SWIG_check_num_args("ofXml::setToPrevSibling",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::setToPrevSibling",1,"ofXml *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ - SWIG_fail_ptr("Xml_setToPrevSibling",1,SWIGTYPE_p_ofXml); } result = (bool)(arg1)->setToPrevSibling(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_loadFromBuffer(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; std::string *arg2 = 0 ; - std::string temp2 ; bool result; SWIG_check_num_args("ofXml::loadFromBuffer",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::loadFromBuffer",1,"ofXml *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofXml::loadFromBuffer",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ - SWIG_fail_ptr("Xml_loadFromBuffer",1,SWIGTYPE_p_ofXml); } temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = (bool)(arg1)->loadFromBuffer((std::string const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_toString(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; std::string result; - SWIG_check_num_args("ofXml::toString",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::toString",1,"ofXml const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_toString",1,SWIGTYPE_p_ofXml); } - result = ((ofXml const *)arg1)->toString(); lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_serialize(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; ofAbstractParameter *arg2 = 0 ; - SWIG_check_num_args("ofXml::serialize",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::serialize",1,"ofXml *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofXml::serialize",2,"ofAbstractParameter const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_serialize",1,SWIGTYPE_p_ofXml); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofAbstractParameter,0))){ - SWIG_fail_ptr("Xml_serialize",2,SWIGTYPE_p_ofAbstractParameter); } (arg1)->serialize((ofAbstractParameter const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_deserialize(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; ofAbstractParameter *arg2 = 0 ; - SWIG_check_num_args("ofXml::deserialize",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::deserialize",1,"ofXml *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofXml::deserialize",2,"ofAbstractParameter &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_deserialize",1,SWIGTYPE_p_ofXml); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofAbstractParameter,0))){ - SWIG_fail_ptr("Xml_deserialize",2,SWIGTYPE_p_ofAbstractParameter); } (arg1)->deserialize(*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_tokenize(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; - std::string temp1 ; std::string temp2 ; std::vector< std::string > result; SWIG_check_num_args("ofXml::tokenize",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofXml::tokenize",1,"std::string const &"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofXml::tokenize",2,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = ofXml::tokenize((std::string const &)*arg1,(std::string const &)*arg2); { - std::vector< std::string > * resultptr = new std::vector< std::string >((const std::vector< std::string > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_std__string_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_Xml(void *obj) { -ofXml *arg1 = (ofXml *) obj; -delete arg1; -} -static int _proxy__wrap_new_Xml(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_Xml); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_Xml_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_Xml_methods[]= { - { "load", _wrap_Xml_load}, - { "save", _wrap_Xml_save}, - { "addChild", _wrap_Xml_addChild}, - { "addXml", _wrap_Xml_addXml}, - { "getValue", _wrap_Xml_getValue}, - { "getIntValue", _wrap_Xml_getIntValue}, - { "getInt64Value", _wrap_Xml_getInt64Value}, - { "getFloatValue", _wrap_Xml_getFloatValue}, - { "getBoolValue", _wrap_Xml_getBoolValue}, - { "setValue", _wrap_Xml_setValue}, - { "getAttribute", _wrap_Xml_getAttribute}, - { "setAttribute", _wrap_Xml_setAttribute}, - { "getAttributes", _wrap_Xml_getAttributes}, - { "getNumChildren", _wrap_Xml_getNumChildren}, - { "removeAttribute", _wrap_Xml_removeAttribute}, - { "removeAttributes", _wrap_Xml_removeAttributes}, - { "removeContents", _wrap_Xml_removeContents}, - { "remove", _wrap_Xml_remove}, - { "exists", _wrap_Xml_exists}, - { "clear", _wrap_Xml_clear}, - { "getName", _wrap_Xml_getName}, - { "reset", _wrap_Xml_reset}, - { "setToChild", _wrap_Xml_setToChild}, - { "setTo", _wrap_Xml_setTo}, - { "setToParent", _wrap_Xml_setToParent}, - { "setToSibling", _wrap_Xml_setToSibling}, - { "setToPrevSibling", _wrap_Xml_setToPrevSibling}, - { "loadFromBuffer", _wrap_Xml_loadFromBuffer}, - { "toString", _wrap_Xml_toString}, - { "serialize", _wrap_Xml_serialize}, - { "deserialize", _wrap_Xml_deserialize}, - {0,0} -}; -static swig_lua_method swig_Xml_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_Xml_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_Xml_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_Xml_Sf_SwigStatic_methods[]= { - { "tokenize", _wrap_Xml_tokenize}, - {0,0} -}; -static swig_lua_class* swig_Xml_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_Xml_Sf_SwigStatic = { - "Xml", - swig_Xml_Sf_SwigStatic_methods, - swig_Xml_Sf_SwigStatic_attributes, - swig_Xml_Sf_SwigStatic_constants, - swig_Xml_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_Xml_bases[] = {0}; -static const char *swig_Xml_base_names[] = {0}; -static swig_lua_class _wrap_class_Xml = { "Xml", "Xml", &SWIGTYPE_p_ofXml,_proxy__wrap_new_Xml, swig_delete_Xml, swig_Xml_methods, swig_Xml_attributes, &swig_Xml_Sf_SwigStatic, swig_Xml_meta, swig_Xml_bases, swig_Xml_base_names }; - -static int _wrap_new_MatrixStack(lua_State* L) { int SWIG_arg = 0; ofAppBaseWindow *arg1 = (ofAppBaseWindow *) 0 ; - ofMatrixStack *result = 0 ; SWIG_check_num_args("ofMatrixStack::ofMatrixStack",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::ofMatrixStack",1,"ofAppBaseWindow const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofAppBaseWindow,0))){ - SWIG_fail_ptr("new_MatrixStack",1,SWIGTYPE_p_ofAppBaseWindow); } - result = (ofMatrixStack *)new ofMatrixStack((ofAppBaseWindow const *)arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMatrixStack,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_MatrixStack_setRenderSurface__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; ofFbo *arg2 = 0 ; SWIG_check_num_args("ofMatrixStack::setRenderSurface",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::setRenderSurface",1,"ofMatrixStack *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrixStack::setRenderSurface",2,"ofFbo const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_setRenderSurface",1,SWIGTYPE_p_ofMatrixStack); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofFbo,0))){ - SWIG_fail_ptr("MatrixStack_setRenderSurface",2,SWIGTYPE_p_ofFbo); } (arg1)->setRenderSurface((ofFbo const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_MatrixStack_setRenderSurface__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; ofAppBaseWindow *arg2 = 0 ; - SWIG_check_num_args("ofMatrixStack::setRenderSurface",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::setRenderSurface",1,"ofMatrixStack *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrixStack::setRenderSurface",2,"ofAppBaseWindow const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_setRenderSurface",1,SWIGTYPE_p_ofMatrixStack); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofAppBaseWindow,0))){ - SWIG_fail_ptr("MatrixStack_setRenderSurface",2,SWIGTYPE_p_ofAppBaseWindow); } - (arg1)->setRenderSurface((ofAppBaseWindow const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_MatrixStack_setRenderSurface(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrixStack, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_MatrixStack_setRenderSurface__SWIG_0(L);} } } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrixStack, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofAppBaseWindow, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_MatrixStack_setRenderSurface__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'MatrixStack_setRenderSurface'\n" - " Possible C/C++ prototypes are:\n" " ofMatrixStack::setRenderSurface(ofFbo const &)\n" - " ofMatrixStack::setRenderSurface(ofAppBaseWindow const &)\n"); lua_error(L);return 0; } -static int _wrap_MatrixStack_setOrientation(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; - ofOrientation arg2 ; bool arg3 ; SWIG_check_num_args("ofMatrixStack::setOrientation",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::setOrientation",1,"ofMatrixStack *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrixStack::setOrientation",2,"ofOrientation"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofMatrixStack::setOrientation",3,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_setOrientation",1,SWIGTYPE_p_ofMatrixStack); } arg2 = (ofOrientation)(int)lua_tonumber(L, 2); - arg3 = (lua_toboolean(L, 3)!=0); (arg1)->setOrientation(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_MatrixStack_getOrientation(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; - ofOrientation result; SWIG_check_num_args("ofMatrixStack::getOrientation",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::getOrientation",1,"ofMatrixStack const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_getOrientation",1,SWIGTYPE_p_ofMatrixStack); } - result = (ofOrientation)((ofMatrixStack const *)arg1)->getOrientation(); - lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_MatrixStack_viewport(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; float arg2 ; - float arg3 ; float arg4 ; float arg5 ; bool arg6 ; SWIG_check_num_args("ofMatrixStack::viewport",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::viewport",1,"ofMatrixStack *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrixStack::viewport",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrixStack::viewport",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrixStack::viewport",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMatrixStack::viewport",5,"float"); - if(!lua_isboolean(L,6)) SWIG_fail_arg("ofMatrixStack::viewport",6,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_viewport",1,SWIGTYPE_p_ofMatrixStack); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (lua_toboolean(L, 6)!=0); (arg1)->viewport(arg2,arg3,arg4,arg5,arg6); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_MatrixStack_nativeViewport(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; - ofRectangle arg2 ; ofRectangle *argp2 ; SWIG_check_num_args("ofMatrixStack::nativeViewport",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::nativeViewport",1,"ofMatrixStack *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrixStack::nativeViewport",2,"ofRectangle"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_nativeViewport",1,SWIGTYPE_p_ofMatrixStack); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("MatrixStack_nativeViewport",2,SWIGTYPE_p_ofRectangle); } arg2 = *argp2; (arg1)->nativeViewport(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_MatrixStack_getCurrentViewport(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; - ofRectangle result; SWIG_check_num_args("ofMatrixStack::getCurrentViewport",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::getCurrentViewport",1,"ofMatrixStack const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_getCurrentViewport",1,SWIGTYPE_p_ofMatrixStack); } - result = ((ofMatrixStack const *)arg1)->getCurrentViewport(); { - ofRectangle * resultptr = new ofRectangle((const ofRectangle &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofRectangle,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_MatrixStack_getNativeViewport(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; - ofRectangle result; SWIG_check_num_args("ofMatrixStack::getNativeViewport",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::getNativeViewport",1,"ofMatrixStack const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_getNativeViewport",1,SWIGTYPE_p_ofMatrixStack); } - result = ((ofMatrixStack const *)arg1)->getNativeViewport(); { - ofRectangle * resultptr = new ofRectangle((const ofRectangle &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofRectangle,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_MatrixStack_getFullSurfaceViewport(lua_State* L) { int SWIG_arg = 0; - ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; ofRectangle result; - SWIG_check_num_args("ofMatrixStack::getFullSurfaceViewport",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::getFullSurfaceViewport",1,"ofMatrixStack const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_getFullSurfaceViewport",1,SWIGTYPE_p_ofMatrixStack); } - result = ((ofMatrixStack const *)arg1)->getFullSurfaceViewport(); { - ofRectangle * resultptr = new ofRectangle((const ofRectangle &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofRectangle,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_MatrixStack_getProjectionMatrix(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; - ofMatrix4x4 *result = 0 ; SWIG_check_num_args("ofMatrixStack::getProjectionMatrix",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::getProjectionMatrix",1,"ofMatrixStack const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_getProjectionMatrix",1,SWIGTYPE_p_ofMatrixStack); } - result = (ofMatrix4x4 *) &((ofMatrixStack const *)arg1)->getProjectionMatrix(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMatrix4x4,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_MatrixStack_getViewMatrix(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; - ofMatrix4x4 *result = 0 ; SWIG_check_num_args("ofMatrixStack::getViewMatrix",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::getViewMatrix",1,"ofMatrixStack const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_getViewMatrix",1,SWIGTYPE_p_ofMatrixStack); } - result = (ofMatrix4x4 *) &((ofMatrixStack const *)arg1)->getViewMatrix(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMatrix4x4,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_MatrixStack_getModelViewMatrix(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; - ofMatrix4x4 *result = 0 ; SWIG_check_num_args("ofMatrixStack::getModelViewMatrix",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::getModelViewMatrix",1,"ofMatrixStack const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_getModelViewMatrix",1,SWIGTYPE_p_ofMatrixStack); } - result = (ofMatrix4x4 *) &((ofMatrixStack const *)arg1)->getModelViewMatrix(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMatrix4x4,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_MatrixStack_getModelViewProjectionMatrix(lua_State* L) { int SWIG_arg = 0; - ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; ofMatrix4x4 *result = 0 ; - SWIG_check_num_args("ofMatrixStack::getModelViewProjectionMatrix",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::getModelViewProjectionMatrix",1,"ofMatrixStack const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_getModelViewProjectionMatrix",1,SWIGTYPE_p_ofMatrixStack); } - result = (ofMatrix4x4 *) &((ofMatrixStack const *)arg1)->getModelViewProjectionMatrix(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMatrix4x4,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_MatrixStack_getTextureMatrix(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; - ofMatrix4x4 *result = 0 ; SWIG_check_num_args("ofMatrixStack::getTextureMatrix",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::getTextureMatrix",1,"ofMatrixStack const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_getTextureMatrix",1,SWIGTYPE_p_ofMatrixStack); } - result = (ofMatrix4x4 *) &((ofMatrixStack const *)arg1)->getTextureMatrix(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMatrix4x4,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_MatrixStack_getCurrentMatrix(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; - ofMatrix4x4 *result = 0 ; SWIG_check_num_args("ofMatrixStack::getCurrentMatrix",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::getCurrentMatrix",1,"ofMatrixStack const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_getCurrentMatrix",1,SWIGTYPE_p_ofMatrixStack); } - result = (ofMatrix4x4 *) &((ofMatrixStack const *)arg1)->getCurrentMatrix(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMatrix4x4,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_MatrixStack_getProjectionMatrixNoOrientation(lua_State* L) { int SWIG_arg = 0; - ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; ofMatrix4x4 *result = 0 ; - SWIG_check_num_args("ofMatrixStack::getProjectionMatrixNoOrientation",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::getProjectionMatrixNoOrientation",1,"ofMatrixStack const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_getProjectionMatrixNoOrientation",1,SWIGTYPE_p_ofMatrixStack); } - result = (ofMatrix4x4 *) &((ofMatrixStack const *)arg1)->getProjectionMatrixNoOrientation(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMatrix4x4,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_MatrixStack_getOrientationMatrix(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; - ofMatrix4x4 *result = 0 ; SWIG_check_num_args("ofMatrixStack::getOrientationMatrix",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::getOrientationMatrix",1,"ofMatrixStack const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_getOrientationMatrix",1,SWIGTYPE_p_ofMatrixStack); } - result = (ofMatrix4x4 *) &((ofMatrixStack const *)arg1)->getOrientationMatrix(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMatrix4x4,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_MatrixStack_getOrientationMatrixInverse(lua_State* L) { int SWIG_arg = 0; - ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; ofMatrix4x4 *result = 0 ; - SWIG_check_num_args("ofMatrixStack::getOrientationMatrixInverse",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::getOrientationMatrixInverse",1,"ofMatrixStack const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_getOrientationMatrixInverse",1,SWIGTYPE_p_ofMatrixStack); } - result = (ofMatrix4x4 *) &((ofMatrixStack const *)arg1)->getOrientationMatrixInverse(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMatrix4x4,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_MatrixStack_getCurrentMatrixMode(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; - ofMatrixMode result; SWIG_check_num_args("ofMatrixStack::getCurrentMatrixMode",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::getCurrentMatrixMode",1,"ofMatrixStack const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_getCurrentMatrixMode",1,SWIGTYPE_p_ofMatrixStack); } - result = (ofMatrixMode)((ofMatrixStack const *)arg1)->getCurrentMatrixMode(); - lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_MatrixStack_getHandedness(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; - ofHandednessType result; SWIG_check_num_args("ofMatrixStack::getHandedness",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::getHandedness",1,"ofMatrixStack const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_getHandedness",1,SWIGTYPE_p_ofMatrixStack); } - result = (ofHandednessType)((ofMatrixStack const *)arg1)->getHandedness(); - lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_MatrixStack_isVFlipped(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; - bool result; SWIG_check_num_args("ofMatrixStack::isVFlipped",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::isVFlipped",1,"ofMatrixStack const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_isVFlipped",1,SWIGTYPE_p_ofMatrixStack); } - result = (bool)((ofMatrixStack const *)arg1)->isVFlipped(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_MatrixStack_customMatrixNeedsFlip(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; - bool result; SWIG_check_num_args("ofMatrixStack::customMatrixNeedsFlip",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::customMatrixNeedsFlip",1,"ofMatrixStack const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_customMatrixNeedsFlip",1,SWIGTYPE_p_ofMatrixStack); } - result = (bool)((ofMatrixStack const *)arg1)->customMatrixNeedsFlip(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_MatrixStack_pushView(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; - SWIG_check_num_args("ofMatrixStack::pushView",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::pushView",1,"ofMatrixStack *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_pushView",1,SWIGTYPE_p_ofMatrixStack); } (arg1)->pushView(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_MatrixStack_popView(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; - SWIG_check_num_args("ofMatrixStack::popView",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::popView",1,"ofMatrixStack *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_popView",1,SWIGTYPE_p_ofMatrixStack); } (arg1)->popView(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_MatrixStack_pushMatrix(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; - SWIG_check_num_args("ofMatrixStack::pushMatrix",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::pushMatrix",1,"ofMatrixStack *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_pushMatrix",1,SWIGTYPE_p_ofMatrixStack); } (arg1)->pushMatrix(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_MatrixStack_popMatrix(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; - SWIG_check_num_args("ofMatrixStack::popMatrix",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::popMatrix",1,"ofMatrixStack *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_popMatrix",1,SWIGTYPE_p_ofMatrixStack); } (arg1)->popMatrix(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_MatrixStack_translate__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; - float arg2 ; float arg3 ; float arg4 ; SWIG_check_num_args("ofMatrixStack::translate",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::translate",1,"ofMatrixStack *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrixStack::translate",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrixStack::translate",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrixStack::translate",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_translate",1,SWIGTYPE_p_ofMatrixStack); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); (arg1)->translate(arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_MatrixStack_translate__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; - float arg2 ; float arg3 ; SWIG_check_num_args("ofMatrixStack::translate",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::translate",1,"ofMatrixStack *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrixStack::translate",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrixStack::translate",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_translate",1,SWIGTYPE_p_ofMatrixStack); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->translate(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_MatrixStack_translate(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrixStack, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_MatrixStack_translate__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrixStack, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_MatrixStack_translate__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'MatrixStack_translate'\n" - " Possible C/C++ prototypes are:\n" " ofMatrixStack::translate(float,float,float)\n" - " ofMatrixStack::translate(float,float)\n"); lua_error(L);return 0; } -static int _wrap_MatrixStack_scale__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; - float arg2 ; float arg3 ; float arg4 ; SWIG_check_num_args("ofMatrixStack::scale",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::scale",1,"ofMatrixStack *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrixStack::scale",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrixStack::scale",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrixStack::scale",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_scale",1,SWIGTYPE_p_ofMatrixStack); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); (arg1)->scale(arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_MatrixStack_scale__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; - float arg2 ; float arg3 ; SWIG_check_num_args("ofMatrixStack::scale",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::scale",1,"ofMatrixStack *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrixStack::scale",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrixStack::scale",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_scale",1,SWIGTYPE_p_ofMatrixStack); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->scale(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_MatrixStack_scale(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrixStack, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_MatrixStack_scale__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrixStack, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_MatrixStack_scale__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'MatrixStack_scale'\n" " Possible C/C++ prototypes are:\n" - " ofMatrixStack::scale(float,float,float)\n" " ofMatrixStack::scale(float,float)\n"); lua_error(L);return 0; } -static int _wrap_MatrixStack_rotate(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; float arg2 ; - float arg3 ; float arg4 ; float arg5 ; SWIG_check_num_args("ofMatrixStack::rotate",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::rotate",1,"ofMatrixStack *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrixStack::rotate",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrixStack::rotate",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrixStack::rotate",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMatrixStack::rotate",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_rotate",1,SWIGTYPE_p_ofMatrixStack); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - (arg1)->rotate(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_MatrixStack_matrixMode(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; - ofMatrixMode arg2 ; SWIG_check_num_args("ofMatrixStack::matrixMode",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::matrixMode",1,"ofMatrixStack *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrixStack::matrixMode",2,"ofMatrixMode"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_matrixMode",1,SWIGTYPE_p_ofMatrixStack); } arg2 = (ofMatrixMode)(int)lua_tonumber(L, 2); - (arg1)->matrixMode(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_MatrixStack_loadIdentityMatrix(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; - SWIG_check_num_args("ofMatrixStack::loadIdentityMatrix",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::loadIdentityMatrix",1,"ofMatrixStack *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_loadIdentityMatrix",1,SWIGTYPE_p_ofMatrixStack); } (arg1)->loadIdentityMatrix(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_MatrixStack_loadMatrix(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; - float *arg2 = (float *) 0 ; SWIG_check_num_args("ofMatrixStack::loadMatrix",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::loadMatrix",1,"ofMatrixStack *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofMatrixStack::loadMatrix",2,"float const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_loadMatrix",1,SWIGTYPE_p_ofMatrixStack); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("MatrixStack_loadMatrix",2,SWIGTYPE_p_float); } (arg1)->loadMatrix((float const *)arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_MatrixStack_multMatrix(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; - float *arg2 = (float *) 0 ; SWIG_check_num_args("ofMatrixStack::multMatrix",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::multMatrix",1,"ofMatrixStack *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofMatrixStack::multMatrix",2,"float const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_multMatrix",1,SWIGTYPE_p_ofMatrixStack); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("MatrixStack_multMatrix",2,SWIGTYPE_p_float); } (arg1)->multMatrix((float const *)arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_MatrixStack_loadViewMatrix(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; - ofMatrix4x4 *arg2 = 0 ; SWIG_check_num_args("ofMatrixStack::loadViewMatrix",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::loadViewMatrix",1,"ofMatrixStack *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrixStack::loadViewMatrix",2,"ofMatrix4x4 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_loadViewMatrix",1,SWIGTYPE_p_ofMatrixStack); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("MatrixStack_loadViewMatrix",2,SWIGTYPE_p_ofMatrix4x4); } (arg1)->loadViewMatrix((ofMatrix4x4 const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_MatrixStack_multViewMatrix(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; - ofMatrix4x4 *arg2 = 0 ; SWIG_check_num_args("ofMatrixStack::multViewMatrix",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::multViewMatrix",1,"ofMatrixStack *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrixStack::multViewMatrix",2,"ofMatrix4x4 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_multViewMatrix",1,SWIGTYPE_p_ofMatrixStack); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("MatrixStack_multViewMatrix",2,SWIGTYPE_p_ofMatrix4x4); } (arg1)->multViewMatrix((ofMatrix4x4 const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_MatrixStack_clearStacks(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; - SWIG_check_num_args("ofMatrixStack::clearStacks",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::clearStacks",1,"ofMatrixStack *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_clearStacks",1,SWIGTYPE_p_ofMatrixStack); } (arg1)->clearStacks(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_MatrixStack_doesHardwareOrientation(lua_State* L) { int SWIG_arg = 0; - ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; bool result; SWIG_check_num_args("ofMatrixStack::doesHardwareOrientation",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::doesHardwareOrientation",1,"ofMatrixStack const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_doesHardwareOrientation",1,SWIGTYPE_p_ofMatrixStack); } - result = (bool)((ofMatrixStack const *)arg1)->doesHardwareOrientation(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_MatrixStack(void *obj) { -ofMatrixStack *arg1 = (ofMatrixStack *) obj; -delete arg1; -} -static int _proxy__wrap_new_MatrixStack(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_MatrixStack); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_MatrixStack_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_MatrixStack_methods[]= { - { "setRenderSurface", _wrap_MatrixStack_setRenderSurface}, - { "setOrientation", _wrap_MatrixStack_setOrientation}, - { "getOrientation", _wrap_MatrixStack_getOrientation}, - { "viewport", _wrap_MatrixStack_viewport}, - { "nativeViewport", _wrap_MatrixStack_nativeViewport}, - { "getCurrentViewport", _wrap_MatrixStack_getCurrentViewport}, - { "getNativeViewport", _wrap_MatrixStack_getNativeViewport}, - { "getFullSurfaceViewport", _wrap_MatrixStack_getFullSurfaceViewport}, - { "getProjectionMatrix", _wrap_MatrixStack_getProjectionMatrix}, - { "getViewMatrix", _wrap_MatrixStack_getViewMatrix}, - { "getModelViewMatrix", _wrap_MatrixStack_getModelViewMatrix}, - { "getModelViewProjectionMatrix", _wrap_MatrixStack_getModelViewProjectionMatrix}, - { "getTextureMatrix", _wrap_MatrixStack_getTextureMatrix}, - { "getCurrentMatrix", _wrap_MatrixStack_getCurrentMatrix}, - { "getProjectionMatrixNoOrientation", _wrap_MatrixStack_getProjectionMatrixNoOrientation}, - { "getOrientationMatrix", _wrap_MatrixStack_getOrientationMatrix}, - { "getOrientationMatrixInverse", _wrap_MatrixStack_getOrientationMatrixInverse}, - { "getCurrentMatrixMode", _wrap_MatrixStack_getCurrentMatrixMode}, - { "getHandedness", _wrap_MatrixStack_getHandedness}, - { "isVFlipped", _wrap_MatrixStack_isVFlipped}, - { "customMatrixNeedsFlip", _wrap_MatrixStack_customMatrixNeedsFlip}, - { "pushView", _wrap_MatrixStack_pushView}, - { "popView", _wrap_MatrixStack_popView}, - { "pushMatrix", _wrap_MatrixStack_pushMatrix}, - { "popMatrix", _wrap_MatrixStack_popMatrix}, - { "translate", _wrap_MatrixStack_translate}, - { "scale", _wrap_MatrixStack_scale}, - { "rotate", _wrap_MatrixStack_rotate}, - { "matrixMode", _wrap_MatrixStack_matrixMode}, - { "loadIdentityMatrix", _wrap_MatrixStack_loadIdentityMatrix}, - { "loadMatrix", _wrap_MatrixStack_loadMatrix}, - { "multMatrix", _wrap_MatrixStack_multMatrix}, - { "loadViewMatrix", _wrap_MatrixStack_loadViewMatrix}, - { "multViewMatrix", _wrap_MatrixStack_multViewMatrix}, - { "clearStacks", _wrap_MatrixStack_clearStacks}, - { "doesHardwareOrientation", _wrap_MatrixStack_doesHardwareOrientation}, - {0,0} -}; -static swig_lua_method swig_MatrixStack_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_MatrixStack_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_MatrixStack_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_MatrixStack_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_MatrixStack_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_MatrixStack_Sf_SwigStatic = { - "MatrixStack", - swig_MatrixStack_Sf_SwigStatic_methods, - swig_MatrixStack_Sf_SwigStatic_attributes, - swig_MatrixStack_Sf_SwigStatic_constants, - swig_MatrixStack_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_MatrixStack_bases[] = {0}; -static const char *swig_MatrixStack_base_names[] = {0}; -static swig_lua_class _wrap_class_MatrixStack = { "MatrixStack", "MatrixStack", &SWIGTYPE_p_ofMatrixStack,_proxy__wrap_new_MatrixStack, swig_delete_MatrixStack, swig_MatrixStack_methods, swig_MatrixStack_attributes, &swig_MatrixStack_Sf_SwigStatic, swig_MatrixStack_meta, swig_MatrixStack_bases, swig_MatrixStack_base_names }; - -static int _wrap_new_Buffer__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofBuffer *result = 0 ; - SWIG_check_num_args("ofBuffer::ofBuffer",0,0) result = (ofBuffer *)new ofBuffer(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofBuffer,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Buffer__SWIG_1(lua_State* L) { int SWIG_arg = 0; char *arg1 = (char *) 0 ; std::size_t arg2 ; - ofBuffer *result = 0 ; SWIG_check_num_args("ofBuffer::ofBuffer",1,1) { arg2 = (size_t)lua_tonumber(L, 1+1); - arg1 = (char *)lua_tolstring(L, 1, &arg2); } result = (ofBuffer *)new ofBuffer((char const *)arg1,arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofBuffer,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Buffer(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_Buffer__SWIG_0(L);} if (argc == 1) { int _v; { _v = SWIG_lua_isnilstring(L,argv[0]); } if (_v) { - if (argc <= 1) { return _wrap_new_Buffer__SWIG_1(L);} { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_new_Buffer__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_Buffer'\n" " Possible C/C++ prototypes are:\n" - " ofBuffer::ofBuffer()\n" " ofBuffer::ofBuffer(char const *,std::size_t)\n"); lua_error(L);return 0; } -static int _wrap_Buffer_set(lua_State* L) { int SWIG_arg = 0; ofBuffer *arg1 = (ofBuffer *) 0 ; char *arg2 = (char *) 0 ; - std::size_t arg3 ; SWIG_check_num_args("ofBuffer::set",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBuffer::set",1,"ofBuffer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBuffer,0))){ SWIG_fail_ptr("Buffer_set",1,SWIGTYPE_p_ofBuffer); } - { arg3 = (size_t)lua_tonumber(L, 2+1); arg2 = (char *)lua_tolstring(L, 2, &arg3); } (arg1)->set((char const *)arg2,arg3); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Buffer_append(lua_State* L) { int SWIG_arg = 0; ofBuffer *arg1 = (ofBuffer *) 0 ; char *arg2 = (char *) 0 ; - std::size_t arg3 ; SWIG_check_num_args("ofBuffer::append",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBuffer::append",1,"ofBuffer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBuffer,0))){ - SWIG_fail_ptr("Buffer_append",1,SWIGTYPE_p_ofBuffer); } { arg3 = (size_t)lua_tonumber(L, 2+1); - arg2 = (char *)lua_tolstring(L, 2, &arg3); } (arg1)->append((char const *)arg2,arg3); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Buffer_clear(lua_State* L) { int SWIG_arg = 0; ofBuffer *arg1 = (ofBuffer *) 0 ; - SWIG_check_num_args("ofBuffer::clear",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBuffer::clear",1,"ofBuffer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBuffer,0))){ - SWIG_fail_ptr("Buffer_clear",1,SWIGTYPE_p_ofBuffer); } (arg1)->clear(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Buffer_allocate(lua_State* L) { int SWIG_arg = 0; ofBuffer *arg1 = (ofBuffer *) 0 ; std::size_t arg2 ; - SWIG_check_num_args("ofBuffer::allocate",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBuffer::allocate",1,"ofBuffer *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBuffer::allocate",2,"std::size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBuffer,0))){ - SWIG_fail_ptr("Buffer_allocate",1,SWIGTYPE_p_ofBuffer); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (std::size_t)lua_tonumber(L, 2); - (arg1)->allocate(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Buffer_getData(lua_State* L) { int SWIG_arg = 0; ofBuffer *arg1 = (ofBuffer *) 0 ; char *result = 0 ; - SWIG_check_num_args("ofBuffer::getData",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBuffer::getData",1,"ofBuffer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBuffer,0))){ - SWIG_fail_ptr("Buffer_getData",1,SWIGTYPE_p_ofBuffer); } result = (char *)((ofBuffer const *)arg1)->getData(); - lua_pushstring(L,(const char *)result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Buffer_getText(lua_State* L) { int SWIG_arg = 0; ofBuffer *arg1 = (ofBuffer *) 0 ; std::string result; - SWIG_check_num_args("ofBuffer::getText",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBuffer::getText",1,"ofBuffer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBuffer,0))){ - SWIG_fail_ptr("Buffer_getText",1,SWIGTYPE_p_ofBuffer); } result = ((ofBuffer const *)arg1)->getText(); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Buffer_size(lua_State* L) { int SWIG_arg = 0; ofBuffer *arg1 = (ofBuffer *) 0 ; long result; - SWIG_check_num_args("ofBuffer::size",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBuffer::size",1,"ofBuffer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBuffer,0))){ - SWIG_fail_ptr("Buffer_size",1,SWIGTYPE_p_ofBuffer); } result = (long)((ofBuffer const *)arg1)->size(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_Buffer(void *obj) { -ofBuffer *arg1 = (ofBuffer *) obj; -delete arg1; -} -static int _proxy__wrap_new_Buffer(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_Buffer); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_Buffer_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_Buffer_methods[]= { - { "set", _wrap_Buffer_set}, - { "append", _wrap_Buffer_append}, - { "clear", _wrap_Buffer_clear}, - { "allocate", _wrap_Buffer_allocate}, - { "getData", _wrap_Buffer_getData}, - { "getText", _wrap_Buffer_getText}, - { "size", _wrap_Buffer_size}, - {0,0} -}; -static swig_lua_method swig_Buffer_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_Buffer_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_Buffer_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_Buffer_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_Buffer_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_Buffer_Sf_SwigStatic = { - "Buffer", - swig_Buffer_Sf_SwigStatic_methods, - swig_Buffer_Sf_SwigStatic_attributes, - swig_Buffer_Sf_SwigStatic_constants, - swig_Buffer_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_Buffer_bases[] = {0}; -static const char *swig_Buffer_base_names[] = {0}; -static swig_lua_class _wrap_class_Buffer = { "Buffer", "Buffer", &SWIGTYPE_p_ofBuffer,_proxy__wrap_new_Buffer, swig_delete_Buffer, swig_Buffer_methods, swig_Buffer_attributes, &swig_Buffer_Sf_SwigStatic, swig_Buffer_meta, swig_Buffer_bases, swig_Buffer_base_names }; - -static int _wrap_bufferFromFile__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; bool arg2 ; - std::string temp1 ; ofBuffer result; SWIG_check_num_args("ofBufferFromFile",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofBufferFromFile",1,"std::string const &"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofBufferFromFile",2,"bool"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; arg2 = (lua_toboolean(L, 2)!=0); - result = ofBufferFromFile((std::string const &)*arg1,arg2); { ofBuffer * resultptr = new ofBuffer((const ofBuffer &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofBuffer,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_bufferFromFile__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - ofBuffer result; SWIG_check_num_args("ofBufferFromFile",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofBufferFromFile",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = ofBufferFromFile((std::string const &)*arg1); { - ofBuffer * resultptr = new ofBuffer((const ofBuffer &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofBuffer,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_bufferFromFile(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; - { _v = lua_isstring(L,argv[0]); } if (_v) { return _wrap_bufferFromFile__SWIG_1(L);} } if (argc == 2) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_bufferFromFile__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'bufferFromFile'\n" " Possible C/C++ prototypes are:\n" - " ofBufferFromFile(std::string const &,bool)\n" " ofBufferFromFile(std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_bufferToFile__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; ofBuffer *arg2 = 0 ; bool arg3 ; - std::string temp1 ; bool result; SWIG_check_num_args("ofBufferToFile",3,3) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofBufferToFile",1,"std::string const &"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofBufferToFile",2,"ofBuffer &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofBufferToFile",3,"bool"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBuffer,0))){ - SWIG_fail_ptr("bufferToFile",2,SWIGTYPE_p_ofBuffer); } arg3 = (lua_toboolean(L, 3)!=0); - result = (bool)ofBufferToFile((std::string const &)*arg1,*arg2,arg3); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_bufferToFile__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; ofBuffer *arg2 = 0 ; - std::string temp1 ; bool result; SWIG_check_num_args("ofBufferToFile",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofBufferToFile",1,"std::string const &"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofBufferToFile",2,"ofBuffer &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBuffer,0))){ - SWIG_fail_ptr("bufferToFile",2,SWIGTYPE_p_ofBuffer); } result = (bool)ofBufferToFile((std::string const &)*arg1,*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_bufferToFile(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { int _v; - { _v = lua_isstring(L,argv[0]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBuffer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_bufferToFile__SWIG_1(L);} } } if (argc == 3) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBuffer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { return _wrap_bufferToFile__SWIG_0(L);} } - } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'bufferToFile'\n" - " Possible C/C++ prototypes are:\n" " ofBufferToFile(std::string const &,ofBuffer &,bool)\n" - " ofBufferToFile(std::string const &,ofBuffer &)\n"); lua_error(L);return 0; } -static int _wrap_FilePath_getFileExt(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - std::string result; SWIG_check_num_args("ofFilePath::getFileExt",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFilePath::getFileExt",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = ofFilePath::getFileExt((std::string const &)*arg1); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FilePath_removeExt(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - std::string result; SWIG_check_num_args("ofFilePath::removeExt",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFilePath::removeExt",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = ofFilePath::removeExt((std::string const &)*arg1); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FilePath_addLeadingSlash(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - std::string result; SWIG_check_num_args("ofFilePath::addLeadingSlash",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFilePath::addLeadingSlash",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; - result = ofFilePath::addLeadingSlash((std::string const &)*arg1); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FilePath_addTrailingSlash(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - std::string result; SWIG_check_num_args("ofFilePath::addTrailingSlash",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFilePath::addTrailingSlash",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; - result = ofFilePath::addTrailingSlash((std::string const &)*arg1); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FilePath_removeTrailingSlash(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - std::string result; SWIG_check_num_args("ofFilePath::removeTrailingSlash",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFilePath::removeTrailingSlash",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; - result = ofFilePath::removeTrailingSlash((std::string const &)*arg1); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FilePath_getPathForDirectory(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - std::string result; SWIG_check_num_args("ofFilePath::getPathForDirectory",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFilePath::getPathForDirectory",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; - result = ofFilePath::getPathForDirectory((std::string const &)*arg1); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FilePath_getAbsolutePath__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; bool arg2 ; - std::string temp1 ; std::string result; SWIG_check_num_args("ofFilePath::getAbsolutePath",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFilePath::getAbsolutePath",1,"std::string const &"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofFilePath::getAbsolutePath",2,"bool"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; arg2 = (lua_toboolean(L, 2)!=0); - result = ofFilePath::getAbsolutePath((std::string const &)*arg1,arg2); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FilePath_getAbsolutePath__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - std::string result; SWIG_check_num_args("ofFilePath::getAbsolutePath",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFilePath::getAbsolutePath",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; - result = ofFilePath::getAbsolutePath((std::string const &)*arg1); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FilePath_getAbsolutePath(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); - if (argc == 1) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { return _wrap_FilePath_getAbsolutePath__SWIG_1(L);} } - if (argc == 2) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_FilePath_getAbsolutePath__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FilePath_getAbsolutePath'\n" - " Possible C/C++ prototypes are:\n" " ofFilePath::getAbsolutePath(std::string const &,bool)\n" - " ofFilePath::getAbsolutePath(std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_FilePath_isAbsolute(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; bool result; - SWIG_check_num_args("ofFilePath::isAbsolute",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFilePath::isAbsolute",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; - result = (bool)ofFilePath::isAbsolute((std::string const &)*arg1); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FilePath_getFileName__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; bool arg2 ; - std::string temp1 ; std::string result; SWIG_check_num_args("ofFilePath::getFileName",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFilePath::getFileName",1,"std::string const &"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofFilePath::getFileName",2,"bool"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; arg2 = (lua_toboolean(L, 2)!=0); - result = ofFilePath::getFileName((std::string const &)*arg1,arg2); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FilePath_getFileName__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - std::string result; SWIG_check_num_args("ofFilePath::getFileName",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFilePath::getFileName",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = ofFilePath::getFileName((std::string const &)*arg1); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FilePath_getFileName(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { return _wrap_FilePath_getFileName__SWIG_1(L);} } if (argc == 2) { - int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_FilePath_getFileName__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FilePath_getFileName'\n" - " Possible C/C++ prototypes are:\n" " ofFilePath::getFileName(std::string const &,bool)\n" - " ofFilePath::getFileName(std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_FilePath_getBaseName(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - std::string result; SWIG_check_num_args("ofFilePath::getBaseName",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFilePath::getBaseName",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = ofFilePath::getBaseName((std::string const &)*arg1); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FilePath_getEnclosingDirectory__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; bool arg2 ; - std::string temp1 ; std::string result; SWIG_check_num_args("ofFilePath::getEnclosingDirectory",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFilePath::getEnclosingDirectory",1,"std::string const &"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofFilePath::getEnclosingDirectory",2,"bool"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; arg2 = (lua_toboolean(L, 2)!=0); - result = ofFilePath::getEnclosingDirectory((std::string const &)*arg1,arg2); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FilePath_getEnclosingDirectory__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; - std::string temp1 ; std::string result; SWIG_check_num_args("ofFilePath::getEnclosingDirectory",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFilePath::getEnclosingDirectory",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; - result = ofFilePath::getEnclosingDirectory((std::string const &)*arg1); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FilePath_getEnclosingDirectory(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); - if (argc == 1) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { return _wrap_FilePath_getEnclosingDirectory__SWIG_1(L);} - } if (argc == 2) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_FilePath_getEnclosingDirectory__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FilePath_getEnclosingDirectory'\n" - " Possible C/C++ prototypes are:\n" " ofFilePath::getEnclosingDirectory(std::string const &,bool)\n" - " ofFilePath::getEnclosingDirectory(std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_FilePath_createEnclosingDirectory__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; bool arg2 ; - bool arg3 ; std::string temp1 ; bool result; SWIG_check_num_args("ofFilePath::createEnclosingDirectory",3,3) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFilePath::createEnclosingDirectory",1,"std::string const &"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofFilePath::createEnclosingDirectory",2,"bool"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofFilePath::createEnclosingDirectory",3,"bool"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; arg2 = (lua_toboolean(L, 2)!=0); - arg3 = (lua_toboolean(L, 3)!=0); result = (bool)ofFilePath::createEnclosingDirectory((std::string const &)*arg1,arg2,arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FilePath_createEnclosingDirectory__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; bool arg2 ; - std::string temp1 ; bool result; SWIG_check_num_args("ofFilePath::createEnclosingDirectory",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFilePath::createEnclosingDirectory",1,"std::string const &"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofFilePath::createEnclosingDirectory",2,"bool"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; arg2 = (lua_toboolean(L, 2)!=0); - result = (bool)ofFilePath::createEnclosingDirectory((std::string const &)*arg1,arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FilePath_createEnclosingDirectory__SWIG_2(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; - std::string temp1 ; bool result; SWIG_check_num_args("ofFilePath::createEnclosingDirectory",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFilePath::createEnclosingDirectory",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; - result = (bool)ofFilePath::createEnclosingDirectory((std::string const &)*arg1); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FilePath_createEnclosingDirectory(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); - if (argc == 1) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { - return _wrap_FilePath_createEnclosingDirectory__SWIG_2(L);} } if (argc == 2) { int _v; { _v = lua_isstring(L,argv[0]); } - if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { return _wrap_FilePath_createEnclosingDirectory__SWIG_1(L);} } } - if (argc == 3) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { { - _v = lua_isboolean(L,argv[2]); } if (_v) { return _wrap_FilePath_createEnclosingDirectory__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FilePath_createEnclosingDirectory'\n" - " Possible C/C++ prototypes are:\n" " ofFilePath::createEnclosingDirectory(std::string const &,bool,bool)\n" - " ofFilePath::createEnclosingDirectory(std::string const &,bool)\n" - " ofFilePath::createEnclosingDirectory(std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_FilePath_getCurrentWorkingDirectory(lua_State* L) { int SWIG_arg = 0; std::string result; - SWIG_check_num_args("ofFilePath::getCurrentWorkingDirectory",0,0) result = ofFilePath::getCurrentWorkingDirectory(); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FilePath_join(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; - std::string temp1 ; std::string temp2 ; std::string result; SWIG_check_num_args("ofFilePath::join",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFilePath::join",1,"std::string const &"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofFilePath::join",2,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = ofFilePath::join((std::string const &)*arg1,(std::string const &)*arg2); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FilePath_getCurrentExePath(lua_State* L) { int SWIG_arg = 0; std::string result; - SWIG_check_num_args("ofFilePath::getCurrentExePath",0,0) result = ofFilePath::getCurrentExePath(); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FilePath_getCurrentExeDir(lua_State* L) { int SWIG_arg = 0; std::string result; - SWIG_check_num_args("ofFilePath::getCurrentExeDir",0,0) result = ofFilePath::getCurrentExeDir(); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FilePath_getUserHomeDir(lua_State* L) { int SWIG_arg = 0; std::string result; - SWIG_check_num_args("ofFilePath::getUserHomeDir",0,0) result = ofFilePath::getUserHomeDir(); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FilePath_makeRelative(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; - std::string temp1 ; std::string temp2 ; std::string result; SWIG_check_num_args("ofFilePath::makeRelative",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFilePath::makeRelative",1,"std::string const &"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofFilePath::makeRelative",2,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = ofFilePath::makeRelative((std::string const &)*arg1,(std::string const &)*arg2); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_FilePath(lua_State* L) { int SWIG_arg = 0; ofFilePath *result = 0 ; - SWIG_check_num_args("ofFilePath::ofFilePath",0,0) result = (ofFilePath *)new ofFilePath(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofFilePath,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static void swig_delete_FilePath(void *obj) { -ofFilePath *arg1 = (ofFilePath *) obj; -delete arg1; -} -static int _proxy__wrap_new_FilePath(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_FilePath); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_FilePath_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_FilePath_methods[]= { - {0,0} -}; -static swig_lua_method swig_FilePath_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_FilePath_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_FilePath_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_FilePath_Sf_SwigStatic_methods[]= { - { "getFileExt", _wrap_FilePath_getFileExt}, - { "removeExt", _wrap_FilePath_removeExt}, - { "addLeadingSlash", _wrap_FilePath_addLeadingSlash}, - { "addTrailingSlash", _wrap_FilePath_addTrailingSlash}, - { "removeTrailingSlash", _wrap_FilePath_removeTrailingSlash}, - { "getPathForDirectory", _wrap_FilePath_getPathForDirectory}, - { "getAbsolutePath", _wrap_FilePath_getAbsolutePath}, - { "isAbsolute", _wrap_FilePath_isAbsolute}, - { "getFileName", _wrap_FilePath_getFileName}, - { "getBaseName", _wrap_FilePath_getBaseName}, - { "getEnclosingDirectory", _wrap_FilePath_getEnclosingDirectory}, - { "createEnclosingDirectory", _wrap_FilePath_createEnclosingDirectory}, - { "getCurrentWorkingDirectory", _wrap_FilePath_getCurrentWorkingDirectory}, - { "join", _wrap_FilePath_join}, - { "getCurrentExePath", _wrap_FilePath_getCurrentExePath}, - { "getCurrentExeDir", _wrap_FilePath_getCurrentExeDir}, - { "getUserHomeDir", _wrap_FilePath_getUserHomeDir}, - { "makeRelative", _wrap_FilePath_makeRelative}, - {0,0} -}; -static swig_lua_class* swig_FilePath_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_FilePath_Sf_SwigStatic = { - "FilePath", - swig_FilePath_Sf_SwigStatic_methods, - swig_FilePath_Sf_SwigStatic_attributes, - swig_FilePath_Sf_SwigStatic_constants, - swig_FilePath_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_FilePath_bases[] = {0}; -static const char *swig_FilePath_base_names[] = {0}; -static swig_lua_class _wrap_class_FilePath = { "FilePath", "FilePath", &SWIGTYPE_p_ofFilePath,_proxy__wrap_new_FilePath, swig_delete_FilePath, swig_FilePath_methods, swig_FilePath_attributes, &swig_FilePath_Sf_SwigStatic, swig_FilePath_meta, swig_FilePath_bases, swig_FilePath_base_names }; - -static int _wrap_new_File__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofFile *result = 0 ; - SWIG_check_num_args("ofFile::ofFile",0,0) result = (ofFile *)new ofFile(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofFile,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_File__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::filesystem::path *arg1 = 0 ; ofFile::Mode arg2 ; - bool arg3 ; std::filesystem::path temp1 ; ofFile *result = 0 ; SWIG_check_num_args("ofFile::ofFile",3,3) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFile::ofFile",1,"std::filesystem::path const &"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofFile::ofFile",2,"ofFile::Mode"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofFile::ofFile",3,"bool"); { size_t len = lua_rawlen(L, 1); - temp1 = lua_tolstring(L, 1, &len); arg1 = &temp1; } arg2 = (ofFile::Mode)(int)lua_tonumber(L, 2); - arg3 = (lua_toboolean(L, 3)!=0); result = (ofFile *)new ofFile((std::filesystem::path const &)*arg1,arg2,arg3); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofFile,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_File__SWIG_2(lua_State* L) { int SWIG_arg = 0; std::filesystem::path *arg1 = 0 ; ofFile::Mode arg2 ; - std::filesystem::path temp1 ; ofFile *result = 0 ; SWIG_check_num_args("ofFile::ofFile",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFile::ofFile",1,"std::filesystem::path const &"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofFile::ofFile",2,"ofFile::Mode"); { size_t len = lua_rawlen(L, 1); - temp1 = lua_tolstring(L, 1, &len); arg1 = &temp1; } arg2 = (ofFile::Mode)(int)lua_tonumber(L, 2); - result = (ofFile *)new ofFile((std::filesystem::path const &)*arg1,arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofFile,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_File__SWIG_3(lua_State* L) { int SWIG_arg = 0; std::filesystem::path *arg1 = 0 ; - std::filesystem::path temp1 ; ofFile *result = 0 ; SWIG_check_num_args("ofFile::ofFile",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFile::ofFile",1,"std::filesystem::path const &"); { size_t len = lua_rawlen(L, 1); - temp1 = lua_tolstring(L, 1, &len); arg1 = &temp1; } result = (ofFile *)new ofFile((std::filesystem::path const &)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofFile,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_File__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = 0 ; ofFile *result = 0 ; - SWIG_check_num_args("ofFile::ofFile",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofFile::ofFile",1,"ofFile const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("new_File",1,SWIGTYPE_p_ofFile); } - result = (ofFile *)new ofFile((ofFile const &)*arg1); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofFile,1); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_new_File(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_File__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_new_File__SWIG_4(L);} } if (argc == 1) { int _v; { - _v = lua_isstring(L, argv[0]); } if (_v) { return _wrap_new_File__SWIG_3(L);} } if (argc == 2) { int _v; { - _v = lua_isstring(L, argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_new_File__SWIG_2(L);} - } } if (argc == 3) { int _v; { _v = lua_isstring(L, argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - { _v = lua_isboolean(L,argv[2]); } if (_v) { return _wrap_new_File__SWIG_1(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_File'\n" " Possible C/C++ prototypes are:\n" - " ofFile::ofFile()\n" " ofFile::ofFile(std::filesystem::path const &,ofFile::Mode,bool)\n" - " ofFile::ofFile(std::filesystem::path const &,ofFile::Mode)\n" " ofFile::ofFile(std::filesystem::path const &)\n" - " ofFile::ofFile(ofFile const &)\n"); lua_error(L);return 0; } -static int _wrap_File_open__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; - std::filesystem::path *arg2 = 0 ; ofFile::Mode arg3 ; bool arg4 ; std::filesystem::path temp2 ; bool result; - SWIG_check_num_args("ofFile::open",4,4) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::open",1,"ofFile *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofFile::open",2,"std::filesystem::path const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofFile::open",3,"ofFile::Mode"); - if(!lua_isboolean(L,4)) SWIG_fail_arg("ofFile::open",4,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File_open",1,SWIGTYPE_p_ofFile); } { - size_t len = lua_rawlen(L, 2); temp2 = lua_tolstring(L, 2, &len); arg2 = &temp2; } - arg3 = (ofFile::Mode)(int)lua_tonumber(L, 3); arg4 = (lua_toboolean(L, 4)!=0); - result = (bool)(arg1)->open((std::filesystem::path const &)*arg2,arg3,arg4); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_open__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; - std::filesystem::path *arg2 = 0 ; ofFile::Mode arg3 ; std::filesystem::path temp2 ; bool result; - SWIG_check_num_args("ofFile::open",3,3) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::open",1,"ofFile *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofFile::open",2,"std::filesystem::path const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofFile::open",3,"ofFile::Mode"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File_open",1,SWIGTYPE_p_ofFile); } { - size_t len = lua_rawlen(L, 2); temp2 = lua_tolstring(L, 2, &len); arg2 = &temp2; } - arg3 = (ofFile::Mode)(int)lua_tonumber(L, 3); result = (bool)(arg1)->open((std::filesystem::path const &)*arg2,arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_open__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; - std::filesystem::path *arg2 = 0 ; std::filesystem::path temp2 ; bool result; SWIG_check_num_args("ofFile::open",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::open",1,"ofFile *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofFile::open",2,"std::filesystem::path const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File_open",1,SWIGTYPE_p_ofFile); } { - size_t len = lua_rawlen(L, 2); temp2 = lua_tolstring(L, 2, &len); arg2 = &temp2; } - result = (bool)(arg1)->open((std::filesystem::path const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_open(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L, argv[1]); } if (_v) { - return _wrap_File_open__SWIG_2(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isstring(L, argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_File_open__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isstring(L, argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isboolean(L,argv[3]); } if (_v) { return _wrap_File_open__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'File_open'\n" " Possible C/C++ prototypes are:\n" - " ofFile::open(std::filesystem::path const &,ofFile::Mode,bool)\n" - " ofFile::open(std::filesystem::path const &,ofFile::Mode)\n" " ofFile::open(std::filesystem::path const &)\n"); - lua_error(L);return 0; } -static int _wrap_File_changeMode__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; ofFile::Mode arg2 ; - bool arg3 ; bool result; SWIG_check_num_args("ofFile::changeMode",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::changeMode",1,"ofFile *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofFile::changeMode",2,"ofFile::Mode"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofFile::changeMode",3,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ - SWIG_fail_ptr("File_changeMode",1,SWIGTYPE_p_ofFile); } arg2 = (ofFile::Mode)(int)lua_tonumber(L, 2); - arg3 = (lua_toboolean(L, 3)!=0); result = (bool)(arg1)->changeMode(arg2,arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_changeMode__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; ofFile::Mode arg2 ; - bool result; SWIG_check_num_args("ofFile::changeMode",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::changeMode",1,"ofFile *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofFile::changeMode",2,"ofFile::Mode"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ - SWIG_fail_ptr("File_changeMode",1,SWIGTYPE_p_ofFile); } arg2 = (ofFile::Mode)(int)lua_tonumber(L, 2); - result = (bool)(arg1)->changeMode(arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_changeMode(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_File_changeMode__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - return _wrap_File_changeMode__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'File_changeMode'\n" " Possible C/C++ prototypes are:\n" - " ofFile::changeMode(ofFile::Mode,bool)\n" " ofFile::changeMode(ofFile::Mode)\n"); lua_error(L);return 0; } -static int _wrap_File_close(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; - SWIG_check_num_args("ofFile::close",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::close",1,"ofFile *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File_close",1,SWIGTYPE_p_ofFile); } - (arg1)->close(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_create(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; bool result; - SWIG_check_num_args("ofFile::create",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::create",1,"ofFile *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File_create",1,SWIGTYPE_p_ofFile); } - result = (bool)(arg1)->create(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_File_exists(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; bool result; - SWIG_check_num_args("ofFile::exists",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::exists",1,"ofFile const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File_exists",1,SWIGTYPE_p_ofFile); } - result = (bool)((ofFile const *)arg1)->exists(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_path(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; std::string result; - SWIG_check_num_args("ofFile::path",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::path",1,"ofFile const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File_path",1,SWIGTYPE_p_ofFile); } - result = ((ofFile const *)arg1)->path(); lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_getExtension(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; std::string result; - SWIG_check_num_args("ofFile::getExtension",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::getExtension",1,"ofFile const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ - SWIG_fail_ptr("File_getExtension",1,SWIGTYPE_p_ofFile); } result = ((ofFile const *)arg1)->getExtension(); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_File_getFileName(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; std::string result; - SWIG_check_num_args("ofFile::getFileName",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::getFileName",1,"ofFile const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ - SWIG_fail_ptr("File_getFileName",1,SWIGTYPE_p_ofFile); } result = ((ofFile const *)arg1)->getFileName(); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_File_getBaseName(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; std::string result; - SWIG_check_num_args("ofFile::getBaseName",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::getBaseName",1,"ofFile const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ - SWIG_fail_ptr("File_getBaseName",1,SWIGTYPE_p_ofFile); } result = ((ofFile const *)arg1)->getBaseName(); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_File_getEnclosingDirectory(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; std::string result; - SWIG_check_num_args("ofFile::getEnclosingDirectory",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::getEnclosingDirectory",1,"ofFile const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ - SWIG_fail_ptr("File_getEnclosingDirectory",1,SWIGTYPE_p_ofFile); } - result = ((ofFile const *)arg1)->getEnclosingDirectory(); lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_getAbsolutePath(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; std::string result; - SWIG_check_num_args("ofFile::getAbsolutePath",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::getAbsolutePath",1,"ofFile const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ - SWIG_fail_ptr("File_getAbsolutePath",1,SWIGTYPE_p_ofFile); } result = ((ofFile const *)arg1)->getAbsolutePath(); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_File_canRead(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; bool result; - SWIG_check_num_args("ofFile::canRead",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::canRead",1,"ofFile const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File_canRead",1,SWIGTYPE_p_ofFile); } - result = (bool)((ofFile const *)arg1)->canRead(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_canWrite(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; bool result; - SWIG_check_num_args("ofFile::canWrite",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::canWrite",1,"ofFile const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File_canWrite",1,SWIGTYPE_p_ofFile); } - result = (bool)((ofFile const *)arg1)->canWrite(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_canExecute(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; bool result; - SWIG_check_num_args("ofFile::canExecute",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::canExecute",1,"ofFile const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ - SWIG_fail_ptr("File_canExecute",1,SWIGTYPE_p_ofFile); } result = (bool)((ofFile const *)arg1)->canExecute(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_isFile(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; bool result; - SWIG_check_num_args("ofFile::isFile",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::isFile",1,"ofFile const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File_isFile",1,SWIGTYPE_p_ofFile); } - result = (bool)((ofFile const *)arg1)->isFile(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_isLink(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; bool result; - SWIG_check_num_args("ofFile::isLink",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::isLink",1,"ofFile const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File_isLink",1,SWIGTYPE_p_ofFile); } - result = (bool)((ofFile const *)arg1)->isLink(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_isDirectory(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; bool result; - SWIG_check_num_args("ofFile::isDirectory",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::isDirectory",1,"ofFile const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ - SWIG_fail_ptr("File_isDirectory",1,SWIGTYPE_p_ofFile); } result = (bool)((ofFile const *)arg1)->isDirectory(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_isDevice(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; bool result; - SWIG_check_num_args("ofFile::isDevice",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::isDevice",1,"ofFile const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File_isDevice",1,SWIGTYPE_p_ofFile); } - result = (bool)((ofFile const *)arg1)->isDevice(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_isHidden(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; bool result; - SWIG_check_num_args("ofFile::isHidden",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::isHidden",1,"ofFile const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File_isHidden",1,SWIGTYPE_p_ofFile); } - result = (bool)((ofFile const *)arg1)->isHidden(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_setWriteable__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; bool arg2 ; - SWIG_check_num_args("ofFile::setWriteable",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::setWriteable",1,"ofFile *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofFile::setWriteable",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ - SWIG_fail_ptr("File_setWriteable",1,SWIGTYPE_p_ofFile); } arg2 = (lua_toboolean(L, 2)!=0); (arg1)->setWriteable(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_setWriteable__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; - SWIG_check_num_args("ofFile::setWriteable",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::setWriteable",1,"ofFile *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ - SWIG_fail_ptr("File_setWriteable",1,SWIGTYPE_p_ofFile); } (arg1)->setWriteable(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_File_setWriteable(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_File_setWriteable__SWIG_1(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_File_setWriteable__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'File_setWriteable'\n" " Possible C/C++ prototypes are:\n" - " ofFile::setWriteable(bool)\n" " ofFile::setWriteable()\n"); lua_error(L);return 0; } -static int _wrap_File_setReadOnly__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; bool arg2 ; - SWIG_check_num_args("ofFile::setReadOnly",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::setReadOnly",1,"ofFile *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofFile::setReadOnly",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ - SWIG_fail_ptr("File_setReadOnly",1,SWIGTYPE_p_ofFile); } arg2 = (lua_toboolean(L, 2)!=0); (arg1)->setReadOnly(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_setReadOnly__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; - SWIG_check_num_args("ofFile::setReadOnly",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::setReadOnly",1,"ofFile *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ - SWIG_fail_ptr("File_setReadOnly",1,SWIGTYPE_p_ofFile); } (arg1)->setReadOnly(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_File_setReadOnly(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_File_setReadOnly__SWIG_1(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_File_setReadOnly__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'File_setReadOnly'\n" " Possible C/C++ prototypes are:\n" - " ofFile::setReadOnly(bool)\n" " ofFile::setReadOnly()\n"); lua_error(L);return 0; } -static int _wrap_File_setExecutable__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; bool arg2 ; - SWIG_check_num_args("ofFile::setExecutable",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::setExecutable",1,"ofFile *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofFile::setExecutable",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ - SWIG_fail_ptr("File_setExecutable",1,SWIGTYPE_p_ofFile); } arg2 = (lua_toboolean(L, 2)!=0); (arg1)->setExecutable(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_setExecutable__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; - SWIG_check_num_args("ofFile::setExecutable",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::setExecutable",1,"ofFile *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ - SWIG_fail_ptr("File_setExecutable",1,SWIGTYPE_p_ofFile); } (arg1)->setExecutable(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_File_setExecutable(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_File_setExecutable__SWIG_1(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_File_setExecutable__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'File_setExecutable'\n" " Possible C/C++ prototypes are:\n" - " ofFile::setExecutable(bool)\n" " ofFile::setExecutable()\n"); lua_error(L);return 0; } -static int _wrap_File_copyTo__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; std::string *arg2 = 0 ; - bool arg3 ; bool arg4 ; std::string temp2 ; bool result; SWIG_check_num_args("ofFile::copyTo",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::copyTo",1,"ofFile const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofFile::copyTo",2,"std::string const &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofFile::copyTo",3,"bool"); - if(!lua_isboolean(L,4)) SWIG_fail_arg("ofFile::copyTo",4,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File_copyTo",1,SWIGTYPE_p_ofFile); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; arg3 = (lua_toboolean(L, 3)!=0); - arg4 = (lua_toboolean(L, 4)!=0); result = (bool)((ofFile const *)arg1)->copyTo((std::string const &)*arg2,arg3,arg4); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_copyTo__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; std::string *arg2 = 0 ; - bool arg3 ; std::string temp2 ; bool result; SWIG_check_num_args("ofFile::copyTo",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::copyTo",1,"ofFile const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofFile::copyTo",2,"std::string const &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofFile::copyTo",3,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File_copyTo",1,SWIGTYPE_p_ofFile); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; arg3 = (lua_toboolean(L, 3)!=0); - result = (bool)((ofFile const *)arg1)->copyTo((std::string const &)*arg2,arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_copyTo__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; std::string *arg2 = 0 ; - std::string temp2 ; bool result; SWIG_check_num_args("ofFile::copyTo",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::copyTo",1,"ofFile const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofFile::copyTo",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File_copyTo",1,SWIGTYPE_p_ofFile); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = (bool)((ofFile const *)arg1)->copyTo((std::string const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_copyTo(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { - return _wrap_File_copyTo__SWIG_2(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - return _wrap_File_copyTo__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { { - _v = lua_isboolean(L,argv[3]); } if (_v) { return _wrap_File_copyTo__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'File_copyTo'\n" " Possible C/C++ prototypes are:\n" - " ofFile::copyTo(std::string const &,bool,bool) const\n" " ofFile::copyTo(std::string const &,bool) const\n" - " ofFile::copyTo(std::string const &) const\n"); lua_error(L);return 0; } -static int _wrap_File_moveTo__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; std::string *arg2 = 0 ; - bool arg3 ; bool arg4 ; std::string temp2 ; bool result; SWIG_check_num_args("ofFile::moveTo",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::moveTo",1,"ofFile *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofFile::moveTo",2,"std::string const &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofFile::moveTo",3,"bool"); - if(!lua_isboolean(L,4)) SWIG_fail_arg("ofFile::moveTo",4,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File_moveTo",1,SWIGTYPE_p_ofFile); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; arg3 = (lua_toboolean(L, 3)!=0); - arg4 = (lua_toboolean(L, 4)!=0); result = (bool)(arg1)->moveTo((std::string const &)*arg2,arg3,arg4); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_moveTo__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; std::string *arg2 = 0 ; - bool arg3 ; std::string temp2 ; bool result; SWIG_check_num_args("ofFile::moveTo",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::moveTo",1,"ofFile *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofFile::moveTo",2,"std::string const &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofFile::moveTo",3,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File_moveTo",1,SWIGTYPE_p_ofFile); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; arg3 = (lua_toboolean(L, 3)!=0); - result = (bool)(arg1)->moveTo((std::string const &)*arg2,arg3); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_moveTo__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; std::string *arg2 = 0 ; - std::string temp2 ; bool result; SWIG_check_num_args("ofFile::moveTo",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::moveTo",1,"ofFile *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofFile::moveTo",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File_moveTo",1,SWIGTYPE_p_ofFile); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; result = (bool)(arg1)->moveTo((std::string const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_moveTo(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { - return _wrap_File_moveTo__SWIG_2(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - return _wrap_File_moveTo__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { { - _v = lua_isboolean(L,argv[3]); } if (_v) { return _wrap_File_moveTo__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'File_moveTo'\n" " Possible C/C++ prototypes are:\n" - " ofFile::moveTo(std::string const &,bool,bool)\n" " ofFile::moveTo(std::string const &,bool)\n" - " ofFile::moveTo(std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_File_renameTo__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; std::string *arg2 = 0 ; - bool arg3 ; bool arg4 ; std::string temp2 ; bool result; SWIG_check_num_args("ofFile::renameTo",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::renameTo",1,"ofFile *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofFile::renameTo",2,"std::string const &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofFile::renameTo",3,"bool"); - if(!lua_isboolean(L,4)) SWIG_fail_arg("ofFile::renameTo",4,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File_renameTo",1,SWIGTYPE_p_ofFile); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; arg3 = (lua_toboolean(L, 3)!=0); - arg4 = (lua_toboolean(L, 4)!=0); result = (bool)(arg1)->renameTo((std::string const &)*arg2,arg3,arg4); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_renameTo__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; std::string *arg2 = 0 ; - bool arg3 ; std::string temp2 ; bool result; SWIG_check_num_args("ofFile::renameTo",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::renameTo",1,"ofFile *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofFile::renameTo",2,"std::string const &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofFile::renameTo",3,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File_renameTo",1,SWIGTYPE_p_ofFile); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; arg3 = (lua_toboolean(L, 3)!=0); - result = (bool)(arg1)->renameTo((std::string const &)*arg2,arg3); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_renameTo__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; std::string *arg2 = 0 ; - std::string temp2 ; bool result; SWIG_check_num_args("ofFile::renameTo",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::renameTo",1,"ofFile *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofFile::renameTo",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File_renameTo",1,SWIGTYPE_p_ofFile); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; result = (bool)(arg1)->renameTo((std::string const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_renameTo(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { - return _wrap_File_renameTo__SWIG_2(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - return _wrap_File_renameTo__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { { - _v = lua_isboolean(L,argv[3]); } if (_v) { return _wrap_File_renameTo__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'File_renameTo'\n" " Possible C/C++ prototypes are:\n" - " ofFile::renameTo(std::string const &,bool,bool)\n" " ofFile::renameTo(std::string const &,bool)\n" - " ofFile::renameTo(std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_File_remove__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; bool arg2 ; bool result; - SWIG_check_num_args("ofFile::remove",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::remove",1,"ofFile *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofFile::remove",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File_remove",1,SWIGTYPE_p_ofFile); } - arg2 = (lua_toboolean(L, 2)!=0); result = (bool)(arg1)->remove(arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_remove__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; bool result; - SWIG_check_num_args("ofFile::remove",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::remove",1,"ofFile *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File_remove",1,SWIGTYPE_p_ofFile); } - result = (bool)(arg1)->remove(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_File_remove(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_File_remove__SWIG_1(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_File_remove__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'File_remove'\n" " Possible C/C++ prototypes are:\n" - " ofFile::remove(bool)\n" " ofFile::remove()\n"); lua_error(L);return 0; } -static int _wrap_File_getSize(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; uint64_t result; - SWIG_check_num_args("ofFile::getSize",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::getSize",1,"ofFile const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File_getSize",1,SWIGTYPE_p_ofFile); } - result = (uint64_t)((ofFile const *)arg1)->getSize(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File___eq(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; ofFile *arg2 = 0 ; bool result; - SWIG_check_num_args("ofFile::operator ==",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::operator ==",1,"ofFile const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofFile::operator ==",2,"ofFile const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File___eq",1,SWIGTYPE_p_ofFile); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File___eq",2,SWIGTYPE_p_ofFile); } - result = (bool)((ofFile const *)arg1)->operator ==((ofFile const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File___lt(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; ofFile *arg2 = 0 ; bool result; - SWIG_check_num_args("ofFile::operator <",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::operator <",1,"ofFile const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofFile::operator <",2,"ofFile const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File___lt",1,SWIGTYPE_p_ofFile); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File___lt",2,SWIGTYPE_p_ofFile); } - result = (bool)((ofFile const *)arg1)->operator <((ofFile const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File___le(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; ofFile *arg2 = 0 ; bool result; - SWIG_check_num_args("ofFile::operator <=",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::operator <=",1,"ofFile const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofFile::operator <=",2,"ofFile const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File___le",1,SWIGTYPE_p_ofFile); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File___le",2,SWIGTYPE_p_ofFile); } - result = (bool)((ofFile const *)arg1)->operator <=((ofFile const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_readToBuffer(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; ofBuffer result; - SWIG_check_num_args("ofFile::readToBuffer",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::readToBuffer",1,"ofFile *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ - SWIG_fail_ptr("File_readToBuffer",1,SWIGTYPE_p_ofFile); } result = (arg1)->readToBuffer(); { - ofBuffer * resultptr = new ofBuffer((const ofBuffer &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofBuffer,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_File_writeFromBuffer(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; ofBuffer *arg2 = 0 ; - bool result; SWIG_check_num_args("ofFile::writeFromBuffer",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::writeFromBuffer",1,"ofFile *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofFile::writeFromBuffer",2,"ofBuffer const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ - SWIG_fail_ptr("File_writeFromBuffer",1,SWIGTYPE_p_ofFile); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBuffer,0))){ - SWIG_fail_ptr("File_writeFromBuffer",2,SWIGTYPE_p_ofBuffer); } - result = (bool)(arg1)->writeFromBuffer((ofBuffer const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_copyFromTo__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; - bool arg3 ; bool arg4 ; std::string temp1 ; std::string temp2 ; bool result; SWIG_check_num_args("ofFile::copyFromTo",4,4) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFile::copyFromTo",1,"std::string const &"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofFile::copyFromTo",2,"std::string const &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofFile::copyFromTo",3,"bool"); - if(!lua_isboolean(L,4)) SWIG_fail_arg("ofFile::copyFromTo",4,"bool"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - arg3 = (lua_toboolean(L, 3)!=0); arg4 = (lua_toboolean(L, 4)!=0); - result = (bool)ofFile::copyFromTo((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_copyFromTo__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; - bool arg3 ; std::string temp1 ; std::string temp2 ; bool result; SWIG_check_num_args("ofFile::copyFromTo",3,3) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFile::copyFromTo",1,"std::string const &"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofFile::copyFromTo",2,"std::string const &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofFile::copyFromTo",3,"bool"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - arg3 = (lua_toboolean(L, 3)!=0); - result = (bool)ofFile::copyFromTo((std::string const &)*arg1,(std::string const &)*arg2,arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_copyFromTo__SWIG_2(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; - std::string temp1 ; std::string temp2 ; bool result; SWIG_check_num_args("ofFile::copyFromTo",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFile::copyFromTo",1,"std::string const &"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofFile::copyFromTo",2,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = (bool)ofFile::copyFromTo((std::string const &)*arg1,(std::string const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_copyFromTo(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { - return _wrap_File_copyFromTo__SWIG_2(L);} } } if (argc == 3) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { { - _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - return _wrap_File_copyFromTo__SWIG_1(L);} } } } if (argc == 4) { int _v; { _v = lua_isstring(L,argv[0]); } - if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { { - _v = lua_isboolean(L,argv[3]); } if (_v) { return _wrap_File_copyFromTo__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'File_copyFromTo'\n" " Possible C/C++ prototypes are:\n" - " ofFile::copyFromTo(std::string const &,std::string const &,bool,bool)\n" - " ofFile::copyFromTo(std::string const &,std::string const &,bool)\n" - " ofFile::copyFromTo(std::string const &,std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_File_moveFromTo__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; - bool arg3 ; bool arg4 ; std::string temp1 ; std::string temp2 ; bool result; SWIG_check_num_args("ofFile::moveFromTo",4,4) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFile::moveFromTo",1,"std::string const &"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofFile::moveFromTo",2,"std::string const &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofFile::moveFromTo",3,"bool"); - if(!lua_isboolean(L,4)) SWIG_fail_arg("ofFile::moveFromTo",4,"bool"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - arg3 = (lua_toboolean(L, 3)!=0); arg4 = (lua_toboolean(L, 4)!=0); - result = (bool)ofFile::moveFromTo((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_moveFromTo__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; - bool arg3 ; std::string temp1 ; std::string temp2 ; bool result; SWIG_check_num_args("ofFile::moveFromTo",3,3) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFile::moveFromTo",1,"std::string const &"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofFile::moveFromTo",2,"std::string const &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofFile::moveFromTo",3,"bool"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - arg3 = (lua_toboolean(L, 3)!=0); - result = (bool)ofFile::moveFromTo((std::string const &)*arg1,(std::string const &)*arg2,arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_moveFromTo__SWIG_2(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; - std::string temp1 ; std::string temp2 ; bool result; SWIG_check_num_args("ofFile::moveFromTo",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFile::moveFromTo",1,"std::string const &"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofFile::moveFromTo",2,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = (bool)ofFile::moveFromTo((std::string const &)*arg1,(std::string const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_moveFromTo(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { - return _wrap_File_moveFromTo__SWIG_2(L);} } } if (argc == 3) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { { - _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - return _wrap_File_moveFromTo__SWIG_1(L);} } } } if (argc == 4) { int _v; { _v = lua_isstring(L,argv[0]); } - if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { { - _v = lua_isboolean(L,argv[3]); } if (_v) { return _wrap_File_moveFromTo__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'File_moveFromTo'\n" " Possible C/C++ prototypes are:\n" - " ofFile::moveFromTo(std::string const &,std::string const &,bool,bool)\n" - " ofFile::moveFromTo(std::string const &,std::string const &,bool)\n" - " ofFile::moveFromTo(std::string const &,std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_File_doesFileExist__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; bool arg2 ; - std::string temp1 ; bool result; SWIG_check_num_args("ofFile::doesFileExist",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFile::doesFileExist",1,"std::string const &"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofFile::doesFileExist",2,"bool"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; arg2 = (lua_toboolean(L, 2)!=0); - result = (bool)ofFile::doesFileExist((std::string const &)*arg1,arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_doesFileExist__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - bool result; SWIG_check_num_args("ofFile::doesFileExist",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFile::doesFileExist",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; - result = (bool)ofFile::doesFileExist((std::string const &)*arg1); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_doesFileExist(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { return _wrap_File_doesFileExist__SWIG_1(L);} } if (argc == 2) { - int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_File_doesFileExist__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'File_doesFileExist'\n" " Possible C/C++ prototypes are:\n" - " ofFile::doesFileExist(std::string const &,bool)\n" " ofFile::doesFileExist(std::string const &)\n"); - lua_error(L);return 0; } -static int _wrap_File_removeFile__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; bool arg2 ; - std::string temp1 ; bool result; SWIG_check_num_args("ofFile::removeFile",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFile::removeFile",1,"std::string const &"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofFile::removeFile",2,"bool"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; arg2 = (lua_toboolean(L, 2)!=0); - result = (bool)ofFile::removeFile((std::string const &)*arg1,arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_removeFile__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - bool result; SWIG_check_num_args("ofFile::removeFile",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFile::removeFile",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = (bool)ofFile::removeFile((std::string const &)*arg1); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_removeFile(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; - { _v = lua_isstring(L,argv[0]); } if (_v) { return _wrap_File_removeFile__SWIG_1(L);} } if (argc == 2) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_File_removeFile__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'File_removeFile'\n" " Possible C/C++ prototypes are:\n" - " ofFile::removeFile(std::string const &,bool)\n" " ofFile::removeFile(std::string const &)\n"); lua_error(L);return 0; } -static void swig_delete_File(void *obj) { -ofFile *arg1 = (ofFile *) obj; -delete arg1; -} -static int _proxy__wrap_new_File(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_File); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_File_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_File_methods[]= { - { "open", _wrap_File_open}, - { "changeMode", _wrap_File_changeMode}, - { "close", _wrap_File_close}, - { "create", _wrap_File_create}, - { "exists", _wrap_File_exists}, - { "path", _wrap_File_path}, - { "getExtension", _wrap_File_getExtension}, - { "getFileName", _wrap_File_getFileName}, - { "getBaseName", _wrap_File_getBaseName}, - { "getEnclosingDirectory", _wrap_File_getEnclosingDirectory}, - { "getAbsolutePath", _wrap_File_getAbsolutePath}, - { "canRead", _wrap_File_canRead}, - { "canWrite", _wrap_File_canWrite}, - { "canExecute", _wrap_File_canExecute}, - { "isFile", _wrap_File_isFile}, - { "isLink", _wrap_File_isLink}, - { "isDirectory", _wrap_File_isDirectory}, - { "isDevice", _wrap_File_isDevice}, - { "isHidden", _wrap_File_isHidden}, - { "setWriteable", _wrap_File_setWriteable}, - { "setReadOnly", _wrap_File_setReadOnly}, - { "setExecutable", _wrap_File_setExecutable}, - { "copyTo", _wrap_File_copyTo}, - { "moveTo", _wrap_File_moveTo}, - { "renameTo", _wrap_File_renameTo}, - { "remove", _wrap_File_remove}, - { "getSize", _wrap_File_getSize}, - { "__eq", _wrap_File___eq}, - { "__lt", _wrap_File___lt}, - { "__le", _wrap_File___le}, - { "readToBuffer", _wrap_File_readToBuffer}, - { "writeFromBuffer", _wrap_File_writeFromBuffer}, - {0,0} -}; -static swig_lua_method swig_File_meta[] = { - { "__eq", _wrap_File___eq}, - { "__lt", _wrap_File___lt}, - { "__le", _wrap_File___le}, - {0,0} -}; - -static swig_lua_attribute swig_File_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_File_Sf_SwigStatic_constants[]= { - {SWIG_LUA_CONSTTAB_INT("Reference", ofFile::Reference)}, - {SWIG_LUA_CONSTTAB_INT("ReadOnly", ofFile::ReadOnly)}, - {SWIG_LUA_CONSTTAB_INT("WriteOnly", ofFile::WriteOnly)}, - {SWIG_LUA_CONSTTAB_INT("ReadWrite", ofFile::ReadWrite)}, - {SWIG_LUA_CONSTTAB_INT("Append", ofFile::Append)}, - {0,0,0,0,0,0} -}; -static swig_lua_method swig_File_Sf_SwigStatic_methods[]= { - { "copyFromTo", _wrap_File_copyFromTo}, - { "moveFromTo", _wrap_File_moveFromTo}, - { "doesFileExist", _wrap_File_doesFileExist}, - { "removeFile", _wrap_File_removeFile}, - {0,0} -}; -static swig_lua_class* swig_File_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_File_Sf_SwigStatic = { - "File", - swig_File_Sf_SwigStatic_methods, - swig_File_Sf_SwigStatic_attributes, - swig_File_Sf_SwigStatic_constants, - swig_File_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_File_bases[] = {0}; -static const char *swig_File_base_names[] = {0}; -static swig_lua_class _wrap_class_File = { "File", "File", &SWIGTYPE_p_ofFile,_proxy__wrap_new_File, swig_delete_File, swig_File_methods, swig_File_attributes, &swig_File_Sf_SwigStatic, swig_File_meta, swig_File_bases, swig_File_base_names }; - -static int _wrap_new_Directory__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofDirectory *result = 0 ; - SWIG_check_num_args("ofDirectory::ofDirectory",0,0) result = (ofDirectory *)new ofDirectory(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofDirectory,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Directory__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::filesystem::path *arg1 = 0 ; - std::filesystem::path temp1 ; ofDirectory *result = 0 ; SWIG_check_num_args("ofDirectory::ofDirectory",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofDirectory::ofDirectory",1,"std::filesystem::path const &"); { - size_t len = lua_rawlen(L, 1); temp1 = lua_tolstring(L, 1, &len); arg1 = &temp1; } - result = (ofDirectory *)new ofDirectory((std::filesystem::path const &)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofDirectory,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Directory(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_Directory__SWIG_0(L);} if (argc == 1) { int _v; { _v = lua_isstring(L, argv[0]); } if (_v) { - return _wrap_new_Directory__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_Directory'\n" " Possible C/C++ prototypes are:\n" - " ofDirectory::ofDirectory()\n" " ofDirectory::ofDirectory(std::filesystem::path const &)\n"); lua_error(L);return 0; } -static int _wrap_Directory_open(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - std::filesystem::path *arg2 = 0 ; std::filesystem::path temp2 ; SWIG_check_num_args("ofDirectory::open",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::open",1,"ofDirectory *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofDirectory::open",2,"std::filesystem::path const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_open",1,SWIGTYPE_p_ofDirectory); } { size_t len = lua_rawlen(L, 2); - temp2 = lua_tolstring(L, 2, &len); arg2 = &temp2; } (arg1)->open((std::filesystem::path const &)*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_close(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - SWIG_check_num_args("ofDirectory::close",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::close",1,"ofDirectory *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_close",1,SWIGTYPE_p_ofDirectory); } (arg1)->close(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Directory_create__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; bool arg2 ; - bool result; SWIG_check_num_args("ofDirectory::create",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::create",1,"ofDirectory *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofDirectory::create",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_create",1,SWIGTYPE_p_ofDirectory); } arg2 = (lua_toboolean(L, 2)!=0); - result = (bool)(arg1)->create(arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Directory_create__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; bool result; - SWIG_check_num_args("ofDirectory::create",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::create",1,"ofDirectory *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_create",1,SWIGTYPE_p_ofDirectory); } result = (bool)(arg1)->create(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_create(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofDirectory, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Directory_create__SWIG_1(L);} } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofDirectory, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { return _wrap_Directory_create__SWIG_0(L);} } - } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Directory_create'\n" - " Possible C/C++ prototypes are:\n" " ofDirectory::create(bool)\n" " ofDirectory::create()\n"); lua_error(L);return 0; } -static int _wrap_Directory_exists(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; bool result; - SWIG_check_num_args("ofDirectory::exists",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::exists",1,"ofDirectory const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_exists",1,SWIGTYPE_p_ofDirectory); } result = (bool)((ofDirectory const *)arg1)->exists(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_path(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; std::string result; - SWIG_check_num_args("ofDirectory::path",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::path",1,"ofDirectory const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_path",1,SWIGTYPE_p_ofDirectory); } result = ((ofDirectory const *)arg1)->path(); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Directory_getAbsolutePath(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - std::string result; SWIG_check_num_args("ofDirectory::getAbsolutePath",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::getAbsolutePath",1,"ofDirectory const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_getAbsolutePath",1,SWIGTYPE_p_ofDirectory); } - result = ((ofDirectory const *)arg1)->getAbsolutePath(); lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_canRead(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; bool result; - SWIG_check_num_args("ofDirectory::canRead",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::canRead",1,"ofDirectory const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_canRead",1,SWIGTYPE_p_ofDirectory); } result = (bool)((ofDirectory const *)arg1)->canRead(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_canWrite(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; bool result; - SWIG_check_num_args("ofDirectory::canWrite",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::canWrite",1,"ofDirectory const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_canWrite",1,SWIGTYPE_p_ofDirectory); } result = (bool)((ofDirectory const *)arg1)->canWrite(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_canExecute(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; bool result; - SWIG_check_num_args("ofDirectory::canExecute",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::canExecute",1,"ofDirectory const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_canExecute",1,SWIGTYPE_p_ofDirectory); } result = (bool)((ofDirectory const *)arg1)->canExecute(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_isDirectory(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; bool result; - SWIG_check_num_args("ofDirectory::isDirectory",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::isDirectory",1,"ofDirectory const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_isDirectory",1,SWIGTYPE_p_ofDirectory); } - result = (bool)((ofDirectory const *)arg1)->isDirectory(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_isHidden(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; bool result; - SWIG_check_num_args("ofDirectory::isHidden",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::isHidden",1,"ofDirectory const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_isHidden",1,SWIGTYPE_p_ofDirectory); } result = (bool)((ofDirectory const *)arg1)->isHidden(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_setWriteable__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - bool arg2 ; SWIG_check_num_args("ofDirectory::setWriteable",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::setWriteable",1,"ofDirectory *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofDirectory::setWriteable",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_setWriteable",1,SWIGTYPE_p_ofDirectory); } arg2 = (lua_toboolean(L, 2)!=0); - (arg1)->setWriteable(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_setWriteable__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - SWIG_check_num_args("ofDirectory::setWriteable",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::setWriteable",1,"ofDirectory *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_setWriteable",1,SWIGTYPE_p_ofDirectory); } (arg1)->setWriteable(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_setWriteable(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofDirectory, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Directory_setWriteable__SWIG_1(L);} } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofDirectory, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_Directory_setWriteable__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Directory_setWriteable'\n" - " Possible C/C++ prototypes are:\n" " ofDirectory::setWriteable(bool)\n" " ofDirectory::setWriteable()\n"); - lua_error(L);return 0; } -static int _wrap_Directory_setReadOnly__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - bool arg2 ; SWIG_check_num_args("ofDirectory::setReadOnly",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::setReadOnly",1,"ofDirectory *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofDirectory::setReadOnly",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_setReadOnly",1,SWIGTYPE_p_ofDirectory); } arg2 = (lua_toboolean(L, 2)!=0); - (arg1)->setReadOnly(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_setReadOnly__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - SWIG_check_num_args("ofDirectory::setReadOnly",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::setReadOnly",1,"ofDirectory *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_setReadOnly",1,SWIGTYPE_p_ofDirectory); } (arg1)->setReadOnly(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_setReadOnly(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofDirectory, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Directory_setReadOnly__SWIG_1(L);} } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofDirectory, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_Directory_setReadOnly__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Directory_setReadOnly'\n" - " Possible C/C++ prototypes are:\n" " ofDirectory::setReadOnly(bool)\n" " ofDirectory::setReadOnly()\n"); - lua_error(L);return 0; } -static int _wrap_Directory_setExecutable__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - bool arg2 ; SWIG_check_num_args("ofDirectory::setExecutable",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::setExecutable",1,"ofDirectory *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofDirectory::setExecutable",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_setExecutable",1,SWIGTYPE_p_ofDirectory); } arg2 = (lua_toboolean(L, 2)!=0); - (arg1)->setExecutable(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_setExecutable__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - SWIG_check_num_args("ofDirectory::setExecutable",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::setExecutable",1,"ofDirectory *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_setExecutable",1,SWIGTYPE_p_ofDirectory); } (arg1)->setExecutable(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_setExecutable(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofDirectory, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Directory_setExecutable__SWIG_1(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofDirectory, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_Directory_setExecutable__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Directory_setExecutable'\n" - " Possible C/C++ prototypes are:\n" " ofDirectory::setExecutable(bool)\n" " ofDirectory::setExecutable()\n"); - lua_error(L);return 0; } -static int _wrap_Directory_setShowHidden(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; bool arg2 ; - SWIG_check_num_args("ofDirectory::setShowHidden",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::setShowHidden",1,"ofDirectory *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofDirectory::setShowHidden",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_setShowHidden",1,SWIGTYPE_p_ofDirectory); } arg2 = (lua_toboolean(L, 2)!=0); - (arg1)->setShowHidden(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_copyTo__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - std::string *arg2 = 0 ; bool arg3 ; bool arg4 ; std::string temp2 ; bool result; - SWIG_check_num_args("ofDirectory::copyTo",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::copyTo",1,"ofDirectory *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofDirectory::copyTo",2,"std::string const &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofDirectory::copyTo",3,"bool"); - if(!lua_isboolean(L,4)) SWIG_fail_arg("ofDirectory::copyTo",4,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_copyTo",1,SWIGTYPE_p_ofDirectory); } temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - arg3 = (lua_toboolean(L, 3)!=0); arg4 = (lua_toboolean(L, 4)!=0); - result = (bool)(arg1)->copyTo((std::string const &)*arg2,arg3,arg4); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_copyTo__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - std::string *arg2 = 0 ; bool arg3 ; std::string temp2 ; bool result; SWIG_check_num_args("ofDirectory::copyTo",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::copyTo",1,"ofDirectory *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofDirectory::copyTo",2,"std::string const &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofDirectory::copyTo",3,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_copyTo",1,SWIGTYPE_p_ofDirectory); } temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - arg3 = (lua_toboolean(L, 3)!=0); result = (bool)(arg1)->copyTo((std::string const &)*arg2,arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_copyTo__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - std::string *arg2 = 0 ; std::string temp2 ; bool result; SWIG_check_num_args("ofDirectory::copyTo",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::copyTo",1,"ofDirectory *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofDirectory::copyTo",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_copyTo",1,SWIGTYPE_p_ofDirectory); } temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = (bool)(arg1)->copyTo((std::string const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_copyTo(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofDirectory, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { return _wrap_Directory_copyTo__SWIG_2(L);} } - } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofDirectory, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - return _wrap_Directory_copyTo__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofDirectory, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - { _v = lua_isboolean(L,argv[3]); } if (_v) { return _wrap_Directory_copyTo__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Directory_copyTo'\n" " Possible C/C++ prototypes are:\n" - " ofDirectory::copyTo(std::string const &,bool,bool)\n" " ofDirectory::copyTo(std::string const &,bool)\n" - " ofDirectory::copyTo(std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_Directory_moveTo__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - std::string *arg2 = 0 ; bool arg3 ; bool arg4 ; std::string temp2 ; bool result; - SWIG_check_num_args("ofDirectory::moveTo",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::moveTo",1,"ofDirectory *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofDirectory::moveTo",2,"std::string const &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofDirectory::moveTo",3,"bool"); - if(!lua_isboolean(L,4)) SWIG_fail_arg("ofDirectory::moveTo",4,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_moveTo",1,SWIGTYPE_p_ofDirectory); } temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - arg3 = (lua_toboolean(L, 3)!=0); arg4 = (lua_toboolean(L, 4)!=0); - result = (bool)(arg1)->moveTo((std::string const &)*arg2,arg3,arg4); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_moveTo__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - std::string *arg2 = 0 ; bool arg3 ; std::string temp2 ; bool result; SWIG_check_num_args("ofDirectory::moveTo",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::moveTo",1,"ofDirectory *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofDirectory::moveTo",2,"std::string const &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofDirectory::moveTo",3,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_moveTo",1,SWIGTYPE_p_ofDirectory); } temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - arg3 = (lua_toboolean(L, 3)!=0); result = (bool)(arg1)->moveTo((std::string const &)*arg2,arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_moveTo__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - std::string *arg2 = 0 ; std::string temp2 ; bool result; SWIG_check_num_args("ofDirectory::moveTo",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::moveTo",1,"ofDirectory *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofDirectory::moveTo",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_moveTo",1,SWIGTYPE_p_ofDirectory); } temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = (bool)(arg1)->moveTo((std::string const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_moveTo(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofDirectory, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { return _wrap_Directory_moveTo__SWIG_2(L);} } - } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofDirectory, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - return _wrap_Directory_moveTo__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofDirectory, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - { _v = lua_isboolean(L,argv[3]); } if (_v) { return _wrap_Directory_moveTo__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Directory_moveTo'\n" " Possible C/C++ prototypes are:\n" - " ofDirectory::moveTo(std::string const &,bool,bool)\n" " ofDirectory::moveTo(std::string const &,bool)\n" - " ofDirectory::moveTo(std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_Directory_renameTo__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - std::string *arg2 = 0 ; bool arg3 ; bool arg4 ; std::string temp2 ; bool result; - SWIG_check_num_args("ofDirectory::renameTo",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::renameTo",1,"ofDirectory *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofDirectory::renameTo",2,"std::string const &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofDirectory::renameTo",3,"bool"); - if(!lua_isboolean(L,4)) SWIG_fail_arg("ofDirectory::renameTo",4,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_renameTo",1,SWIGTYPE_p_ofDirectory); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; arg3 = (lua_toboolean(L, 3)!=0); - arg4 = (lua_toboolean(L, 4)!=0); result = (bool)(arg1)->renameTo((std::string const &)*arg2,arg3,arg4); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_renameTo__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - std::string *arg2 = 0 ; bool arg3 ; std::string temp2 ; bool result; SWIG_check_num_args("ofDirectory::renameTo",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::renameTo",1,"ofDirectory *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofDirectory::renameTo",2,"std::string const &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofDirectory::renameTo",3,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_renameTo",1,SWIGTYPE_p_ofDirectory); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; arg3 = (lua_toboolean(L, 3)!=0); - result = (bool)(arg1)->renameTo((std::string const &)*arg2,arg3); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_renameTo__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - std::string *arg2 = 0 ; std::string temp2 ; bool result; SWIG_check_num_args("ofDirectory::renameTo",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::renameTo",1,"ofDirectory *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofDirectory::renameTo",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_renameTo",1,SWIGTYPE_p_ofDirectory); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; result = (bool)(arg1)->renameTo((std::string const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_renameTo(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofDirectory, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { return _wrap_Directory_renameTo__SWIG_2(L);} - } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofDirectory, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - return _wrap_Directory_renameTo__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofDirectory, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - { _v = lua_isboolean(L,argv[3]); } if (_v) { return _wrap_Directory_renameTo__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Directory_renameTo'\n" " Possible C/C++ prototypes are:\n" - " ofDirectory::renameTo(std::string const &,bool,bool)\n" " ofDirectory::renameTo(std::string const &,bool)\n" - " ofDirectory::renameTo(std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_Directory_remove(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; bool arg2 ; - bool result; SWIG_check_num_args("ofDirectory::remove",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::remove",1,"ofDirectory *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofDirectory::remove",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_remove",1,SWIGTYPE_p_ofDirectory); } arg2 = (lua_toboolean(L, 2)!=0); - result = (bool)(arg1)->remove(arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Directory_allowExt(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - std::string *arg2 = 0 ; std::string temp2 ; SWIG_check_num_args("ofDirectory::allowExt",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::allowExt",1,"ofDirectory *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofDirectory::allowExt",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_allowExt",1,SWIGTYPE_p_ofDirectory); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; (arg1)->allowExt((std::string const &)*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_listDir__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - std::string *arg2 = 0 ; std::string temp2 ; std::size_t result; SWIG_check_num_args("ofDirectory::listDir",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::listDir",1,"ofDirectory *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofDirectory::listDir",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_listDir",1,SWIGTYPE_p_ofDirectory); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = (std::size_t)(arg1)->listDir((std::string const &)*arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_listDir__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - std::size_t result; SWIG_check_num_args("ofDirectory::listDir",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::listDir",1,"ofDirectory *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_listDir",1,SWIGTYPE_p_ofDirectory); } result = (std::size_t)(arg1)->listDir(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_listDir(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofDirectory, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Directory_listDir__SWIG_1(L);} } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofDirectory, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { return _wrap_Directory_listDir__SWIG_0(L);} } - } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Directory_listDir'\n" - " Possible C/C++ prototypes are:\n" " ofDirectory::listDir(std::string const &)\n" " ofDirectory::listDir()\n"); - lua_error(L);return 0; } -static int _wrap_Directory_getOriginalDirectory(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - std::string result; SWIG_check_num_args("ofDirectory::getOriginalDirectory",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::getOriginalDirectory",1,"ofDirectory const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_getOriginalDirectory",1,SWIGTYPE_p_ofDirectory); } - result = ((ofDirectory const *)arg1)->getOriginalDirectory(); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Directory_getName(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; std::size_t arg2 ; - std::string result; SWIG_check_num_args("ofDirectory::getName",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::getName",1,"ofDirectory const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDirectory::getName",2,"std::size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_getName",1,SWIGTYPE_p_ofDirectory); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (std::size_t)lua_tonumber(L, 2); - result = ((ofDirectory const *)arg1)->getName(arg2); lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_getPath(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; std::size_t arg2 ; - std::string result; SWIG_check_num_args("ofDirectory::getPath",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::getPath",1,"ofDirectory const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDirectory::getPath",2,"std::size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_getPath",1,SWIGTYPE_p_ofDirectory); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (std::size_t)lua_tonumber(L, 2); - result = ((ofDirectory const *)arg1)->getPath(arg2); lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_getFile__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - std::size_t arg2 ; ofFile::Mode arg3 ; bool arg4 ; ofFile result; SWIG_check_num_args("ofDirectory::getFile",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::getFile",1,"ofDirectory const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDirectory::getFile",2,"std::size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDirectory::getFile",3,"ofFile::Mode"); - if(!lua_isboolean(L,4)) SWIG_fail_arg("ofDirectory::getFile",4,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_getFile",1,SWIGTYPE_p_ofDirectory); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (std::size_t)lua_tonumber(L, 2); - arg3 = (ofFile::Mode)(int)lua_tonumber(L, 3); arg4 = (lua_toboolean(L, 4)!=0); - result = ((ofDirectory const *)arg1)->getFile(arg2,arg3,arg4); { ofFile * resultptr = new ofFile((const ofFile &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofFile,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Directory_getFile__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - std::size_t arg2 ; ofFile::Mode arg3 ; ofFile result; SWIG_check_num_args("ofDirectory::getFile",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::getFile",1,"ofDirectory const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDirectory::getFile",2,"std::size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDirectory::getFile",3,"ofFile::Mode"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_getFile",1,SWIGTYPE_p_ofDirectory); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (std::size_t)lua_tonumber(L, 2); - arg3 = (ofFile::Mode)(int)lua_tonumber(L, 3); result = ((ofDirectory const *)arg1)->getFile(arg2,arg3); { - ofFile * resultptr = new ofFile((const ofFile &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofFile,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Directory_getFile__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - std::size_t arg2 ; ofFile result; SWIG_check_num_args("ofDirectory::getFile",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::getFile",1,"ofDirectory const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDirectory::getFile",2,"std::size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_getFile",1,SWIGTYPE_p_ofDirectory); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (std::size_t)lua_tonumber(L, 2); - result = ((ofDirectory const *)arg1)->getFile(arg2); { ofFile * resultptr = new ofFile((const ofFile &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofFile,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Directory_getFile(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofDirectory, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Directory_getFile__SWIG_2(L);} } - } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofDirectory, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Directory_getFile__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofDirectory, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isboolean(L,argv[3]); } if (_v) { return _wrap_Directory_getFile__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Directory_getFile'\n" " Possible C/C++ prototypes are:\n" - " ofDirectory::getFile(std::size_t,ofFile::Mode,bool) const\n" " ofDirectory::getFile(std::size_t,ofFile::Mode) const\n" - " ofDirectory::getFile(std::size_t) const\n"); lua_error(L);return 0; } -static int _wrap_Directory_getFiles(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - std::vector< ofFile > *result = 0 ; SWIG_check_num_args("ofDirectory::getFiles",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::getFiles",1,"ofDirectory const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_getFiles",1,SWIGTYPE_p_ofDirectory); } - result = (std::vector< ofFile > *) &((ofDirectory const *)arg1)->getFiles(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofFile_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Directory_getShowHidden(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; bool result; - SWIG_check_num_args("ofDirectory::getShowHidden",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::getShowHidden",1,"ofDirectory const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_getShowHidden",1,SWIGTYPE_p_ofDirectory); } - result = (bool)((ofDirectory const *)arg1)->getShowHidden(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_reset(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - SWIG_check_num_args("ofDirectory::reset",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::reset",1,"ofDirectory *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_reset",1,SWIGTYPE_p_ofDirectory); } (arg1)->reset(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Directory_sort(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - SWIG_check_num_args("ofDirectory::sort",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::sort",1,"ofDirectory *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_sort",1,SWIGTYPE_p_ofDirectory); } (arg1)->sort(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Directory_getSorted(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - ofDirectory result; SWIG_check_num_args("ofDirectory::getSorted",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::getSorted",1,"ofDirectory *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_getSorted",1,SWIGTYPE_p_ofDirectory); } result = (arg1)->getSorted(); { - ofDirectory * resultptr = new ofDirectory((const ofDirectory &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofDirectory,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Directory_size(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; std::size_t result; - SWIG_check_num_args("ofDirectory::size",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::size",1,"ofDirectory const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_size",1,SWIGTYPE_p_ofDirectory); } result = (std::size_t)((ofDirectory const *)arg1)->size(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory___eq(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - ofDirectory *arg2 = 0 ; bool result; SWIG_check_num_args("ofDirectory::operator ==",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::operator ==",1,"ofDirectory const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofDirectory::operator ==",2,"ofDirectory const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory___eq",1,SWIGTYPE_p_ofDirectory); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory___eq",2,SWIGTYPE_p_ofDirectory); } - result = (bool)((ofDirectory const *)arg1)->operator ==((ofDirectory const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory___lt(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - ofDirectory *arg2 = 0 ; bool result; SWIG_check_num_args("ofDirectory::operator <",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::operator <",1,"ofDirectory const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofDirectory::operator <",2,"ofDirectory const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory___lt",1,SWIGTYPE_p_ofDirectory); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory___lt",2,SWIGTYPE_p_ofDirectory); } - result = (bool)((ofDirectory const *)arg1)->operator <((ofDirectory const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory___le(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - ofDirectory *arg2 = 0 ; bool result; SWIG_check_num_args("ofDirectory::operator <=",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::operator <=",1,"ofDirectory const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofDirectory::operator <=",2,"ofDirectory const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory___le",1,SWIGTYPE_p_ofDirectory); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory___le",2,SWIGTYPE_p_ofDirectory); } - result = (bool)((ofDirectory const *)arg1)->operator <=((ofDirectory const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_createDirectory__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; bool arg2 ; - bool arg3 ; std::string temp1 ; bool result; SWIG_check_num_args("ofDirectory::createDirectory",3,3) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofDirectory::createDirectory",1,"std::string const &"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofDirectory::createDirectory",2,"bool"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofDirectory::createDirectory",3,"bool"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; arg2 = (lua_toboolean(L, 2)!=0); - arg3 = (lua_toboolean(L, 3)!=0); result = (bool)ofDirectory::createDirectory((std::string const &)*arg1,arg2,arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_createDirectory__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; bool arg2 ; - std::string temp1 ; bool result; SWIG_check_num_args("ofDirectory::createDirectory",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofDirectory::createDirectory",1,"std::string const &"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofDirectory::createDirectory",2,"bool"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; arg2 = (lua_toboolean(L, 2)!=0); - result = (bool)ofDirectory::createDirectory((std::string const &)*arg1,arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_createDirectory__SWIG_2(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - bool result; SWIG_check_num_args("ofDirectory::createDirectory",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofDirectory::createDirectory",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; - result = (bool)ofDirectory::createDirectory((std::string const &)*arg1); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_createDirectory(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); - if (argc == 1) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { return _wrap_Directory_createDirectory__SWIG_2(L);} } - if (argc == 2) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_Directory_createDirectory__SWIG_1(L);} } } if (argc == 3) { int _v; { _v = lua_isstring(L,argv[0]); } - if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - return _wrap_Directory_createDirectory__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Directory_createDirectory'\n" - " Possible C/C++ prototypes are:\n" " ofDirectory::createDirectory(std::string const &,bool,bool)\n" - " ofDirectory::createDirectory(std::string const &,bool)\n" " ofDirectory::createDirectory(std::string const &)\n"); - lua_error(L);return 0; } -static int _wrap_Directory_isDirectoryEmpty__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; bool arg2 ; - std::string temp1 ; bool result; SWIG_check_num_args("ofDirectory::isDirectoryEmpty",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofDirectory::isDirectoryEmpty",1,"std::string const &"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofDirectory::isDirectoryEmpty",2,"bool"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; arg2 = (lua_toboolean(L, 2)!=0); - result = (bool)ofDirectory::isDirectoryEmpty((std::string const &)*arg1,arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_isDirectoryEmpty__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; - std::string temp1 ; bool result; SWIG_check_num_args("ofDirectory::isDirectoryEmpty",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofDirectory::isDirectoryEmpty",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; - result = (bool)ofDirectory::isDirectoryEmpty((std::string const &)*arg1); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_isDirectoryEmpty(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); - if (argc == 1) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { return _wrap_Directory_isDirectoryEmpty__SWIG_1(L);} } - if (argc == 2) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_Directory_isDirectoryEmpty__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Directory_isDirectoryEmpty'\n" - " Possible C/C++ prototypes are:\n" " ofDirectory::isDirectoryEmpty(std::string const &,bool)\n" - " ofDirectory::isDirectoryEmpty(std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_Directory_doesDirectoryExist__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; bool arg2 ; - std::string temp1 ; bool result; SWIG_check_num_args("ofDirectory::doesDirectoryExist",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofDirectory::doesDirectoryExist",1,"std::string const &"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofDirectory::doesDirectoryExist",2,"bool"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; arg2 = (lua_toboolean(L, 2)!=0); - result = (bool)ofDirectory::doesDirectoryExist((std::string const &)*arg1,arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_doesDirectoryExist__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; - std::string temp1 ; bool result; SWIG_check_num_args("ofDirectory::doesDirectoryExist",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofDirectory::doesDirectoryExist",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; - result = (bool)ofDirectory::doesDirectoryExist((std::string const &)*arg1); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_doesDirectoryExist(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); - if (argc == 1) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { return _wrap_Directory_doesDirectoryExist__SWIG_1(L);} } - if (argc == 2) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_Directory_doesDirectoryExist__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Directory_doesDirectoryExist'\n" - " Possible C/C++ prototypes are:\n" " ofDirectory::doesDirectoryExist(std::string const &,bool)\n" - " ofDirectory::doesDirectoryExist(std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_Directory_removeDirectory__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; bool arg2 ; - bool arg3 ; std::string temp1 ; bool result; SWIG_check_num_args("ofDirectory::removeDirectory",3,3) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofDirectory::removeDirectory",1,"std::string const &"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofDirectory::removeDirectory",2,"bool"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofDirectory::removeDirectory",3,"bool"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; arg2 = (lua_toboolean(L, 2)!=0); - arg3 = (lua_toboolean(L, 3)!=0); result = (bool)ofDirectory::removeDirectory((std::string const &)*arg1,arg2,arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_removeDirectory__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; bool arg2 ; - std::string temp1 ; bool result; SWIG_check_num_args("ofDirectory::removeDirectory",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofDirectory::removeDirectory",1,"std::string const &"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofDirectory::removeDirectory",2,"bool"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; arg2 = (lua_toboolean(L, 2)!=0); - result = (bool)ofDirectory::removeDirectory((std::string const &)*arg1,arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_removeDirectory(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_Directory_removeDirectory__SWIG_1(L);} } } if (argc == 3) { int _v; { _v = lua_isstring(L,argv[0]); } - if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - return _wrap_Directory_removeDirectory__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Directory_removeDirectory'\n" - " Possible C/C++ prototypes are:\n" " ofDirectory::removeDirectory(std::string const &,bool,bool)\n" - " ofDirectory::removeDirectory(std::string const &,bool)\n"); lua_error(L);return 0; } -static void swig_delete_Directory(void *obj) { -ofDirectory *arg1 = (ofDirectory *) obj; -delete arg1; -} -static int _proxy__wrap_new_Directory(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_Directory); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_Directory_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_Directory_methods[]= { - { "open", _wrap_Directory_open}, - { "close", _wrap_Directory_close}, - { "create", _wrap_Directory_create}, - { "exists", _wrap_Directory_exists}, - { "path", _wrap_Directory_path}, - { "getAbsolutePath", _wrap_Directory_getAbsolutePath}, - { "canRead", _wrap_Directory_canRead}, - { "canWrite", _wrap_Directory_canWrite}, - { "canExecute", _wrap_Directory_canExecute}, - { "isDirectory", _wrap_Directory_isDirectory}, - { "isHidden", _wrap_Directory_isHidden}, - { "setWriteable", _wrap_Directory_setWriteable}, - { "setReadOnly", _wrap_Directory_setReadOnly}, - { "setExecutable", _wrap_Directory_setExecutable}, - { "setShowHidden", _wrap_Directory_setShowHidden}, - { "copyTo", _wrap_Directory_copyTo}, - { "moveTo", _wrap_Directory_moveTo}, - { "renameTo", _wrap_Directory_renameTo}, - { "remove", _wrap_Directory_remove}, - { "allowExt", _wrap_Directory_allowExt}, - { "listDir", _wrap_Directory_listDir}, - { "getOriginalDirectory", _wrap_Directory_getOriginalDirectory}, - { "getName", _wrap_Directory_getName}, - { "getPath", _wrap_Directory_getPath}, - { "getFile", _wrap_Directory_getFile}, - { "getFiles", _wrap_Directory_getFiles}, - { "getShowHidden", _wrap_Directory_getShowHidden}, - { "reset", _wrap_Directory_reset}, - { "sort", _wrap_Directory_sort}, - { "getSorted", _wrap_Directory_getSorted}, - { "size", _wrap_Directory_size}, - { "__eq", _wrap_Directory___eq}, - { "__lt", _wrap_Directory___lt}, - { "__le", _wrap_Directory___le}, - {0,0} -}; -static swig_lua_method swig_Directory_meta[] = { - { "__eq", _wrap_Directory___eq}, - { "__lt", _wrap_Directory___lt}, - { "__le", _wrap_Directory___le}, - {0,0} -}; - -static swig_lua_attribute swig_Directory_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_Directory_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_Directory_Sf_SwigStatic_methods[]= { - { "createDirectory", _wrap_Directory_createDirectory}, - { "isDirectoryEmpty", _wrap_Directory_isDirectoryEmpty}, - { "doesDirectoryExist", _wrap_Directory_doesDirectoryExist}, - { "removeDirectory", _wrap_Directory_removeDirectory}, - {0,0} -}; -static swig_lua_class* swig_Directory_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_Directory_Sf_SwigStatic = { - "Directory", - swig_Directory_Sf_SwigStatic_methods, - swig_Directory_Sf_SwigStatic_attributes, - swig_Directory_Sf_SwigStatic_constants, - swig_Directory_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_Directory_bases[] = {0}; -static const char *swig_Directory_base_names[] = {0}; -static swig_lua_class _wrap_class_Directory = { "Directory", "Directory", &SWIGTYPE_p_ofDirectory,_proxy__wrap_new_Directory, swig_delete_Directory, swig_Directory_methods, swig_Directory_attributes, &swig_Directory_Sf_SwigStatic, swig_Directory_meta, swig_Directory_bases, swig_Directory_base_names }; - -static int _wrap_log(lua_State* L) { int SWIG_arg = 0; ofLogLevel arg1 ; std::string *arg2 = 0 ; std::string temp2 ; - SWIG_check_num_args("log",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("log",1,"ofLogLevel"); - if(!lua_isstring(L,2)) SWIG_fail_arg("log",2,"std::string const &"); arg1 = (ofLogLevel)(int)lua_tonumber(L, 1); - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; log(arg1,(std::string const &)*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setLogLevel__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofLogLevel arg1 ; - SWIG_check_num_args("ofSetLogLevel",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetLogLevel",1,"ofLogLevel"); - arg1 = (ofLogLevel)(int)lua_tonumber(L, 1); ofSetLogLevel(arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_setLogLevel__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string arg1 ; ofLogLevel arg2 ; - SWIG_check_num_args("ofSetLogLevel",2,2) if(!lua_isstring(L,1)) SWIG_fail_arg("ofSetLogLevel",1,"std::string"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSetLogLevel",2,"ofLogLevel"); (&arg1)->assign(lua_tostring(L,1),lua_rawlen(L,1)); - arg2 = (ofLogLevel)(int)lua_tonumber(L, 2); ofSetLogLevel(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_setLogLevel(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_setLogLevel__SWIG_0(L);} } if (argc == 2) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_setLogLevel__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'setLogLevel'\n" " Possible C/C++ prototypes are:\n" - " ofSetLogLevel(ofLogLevel)\n" " ofSetLogLevel(std::string,ofLogLevel)\n"); lua_error(L);return 0; } -static int _wrap_getLogLevel(lua_State* L) { int SWIG_arg = 0; ofLogLevel result; SWIG_check_num_args("ofGetLogLevel",0,0) - result = (ofLogLevel)ofGetLogLevel(); lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getLogLevelName__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofLogLevel arg1 ; bool arg2 ; std::string result; - SWIG_check_num_args("ofGetLogLevelName",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofGetLogLevelName",1,"ofLogLevel"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofGetLogLevelName",2,"bool"); arg1 = (ofLogLevel)(int)lua_tonumber(L, 1); - arg2 = (lua_toboolean(L, 2)!=0); result = ofGetLogLevelName(arg1,arg2); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_getLogLevelName__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofLogLevel arg1 ; std::string result; - SWIG_check_num_args("ofGetLogLevelName",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofGetLogLevelName",1,"ofLogLevel"); - arg1 = (ofLogLevel)(int)lua_tonumber(L, 1); result = ofGetLogLevelName(arg1); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_getLogLevelName(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; - { _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_getLogLevelName__SWIG_1(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_getLogLevelName__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'getLogLevelName'\n" " Possible C/C++ prototypes are:\n" - " ofGetLogLevelName(ofLogLevel,bool)\n" " ofGetLogLevelName(ofLogLevel)\n"); lua_error(L);return 0; } -static int _wrap_logToFile__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; bool arg2 ; std::string temp1 ; - SWIG_check_num_args("ofLogToFile",2,2) if(!lua_isstring(L,1)) SWIG_fail_arg("ofLogToFile",1,"std::string const &"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofLogToFile",2,"bool"); temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; - arg2 = (lua_toboolean(L, 2)!=0); ofLogToFile((std::string const &)*arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_logToFile__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - SWIG_check_num_args("ofLogToFile",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofLogToFile",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; ofLogToFile((std::string const &)*arg1); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_logToFile(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { return _wrap_logToFile__SWIG_1(L);} } if (argc == 2) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_logToFile__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'logToFile'\n" " Possible C/C++ prototypes are:\n" - " ofLogToFile(std::string const &,bool)\n" " ofLogToFile(std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_logToConsole(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofLogToConsole",0,0) ofLogToConsole(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_new_FileDialogResult(lua_State* L) { int SWIG_arg = 0; ofFileDialogResult *result = 0 ; - SWIG_check_num_args("ofFileDialogResult::ofFileDialogResult",0,0) result = (ofFileDialogResult *)new ofFileDialogResult(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofFileDialogResult,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FileDialogResult_getName(lua_State* L) { int SWIG_arg = 0; - ofFileDialogResult *arg1 = (ofFileDialogResult *) 0 ; std::string result; - SWIG_check_num_args("ofFileDialogResult::getName",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFileDialogResult::getName",1,"ofFileDialogResult *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFileDialogResult,0))){ - SWIG_fail_ptr("FileDialogResult_getName",1,SWIGTYPE_p_ofFileDialogResult); } result = (arg1)->getName(); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FileDialogResult_getPath(lua_State* L) { int SWIG_arg = 0; - ofFileDialogResult *arg1 = (ofFileDialogResult *) 0 ; std::string result; - SWIG_check_num_args("ofFileDialogResult::getPath",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFileDialogResult::getPath",1,"ofFileDialogResult *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFileDialogResult,0))){ - SWIG_fail_ptr("FileDialogResult_getPath",1,SWIGTYPE_p_ofFileDialogResult); } result = (arg1)->getPath(); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FileDialogResult_filePath_set(lua_State* L) { int SWIG_arg = 0; - ofFileDialogResult *arg1 = (ofFileDialogResult *) 0 ; std::string *arg2 = 0 ; std::string temp2 ; - SWIG_check_num_args("ofFileDialogResult::filePath",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFileDialogResult::filePath",1,"ofFileDialogResult *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofFileDialogResult::filePath",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFileDialogResult,0))){ - SWIG_fail_ptr("FileDialogResult_filePath_set",1,SWIGTYPE_p_ofFileDialogResult); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; if (arg1) (arg1)->filePath = *arg2; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FileDialogResult_filePath_get(lua_State* L) { int SWIG_arg = 0; - ofFileDialogResult *arg1 = (ofFileDialogResult *) 0 ; std::string *result = 0 ; - SWIG_check_num_args("ofFileDialogResult::filePath",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFileDialogResult::filePath",1,"ofFileDialogResult *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFileDialogResult,0))){ - SWIG_fail_ptr("FileDialogResult_filePath_get",1,SWIGTYPE_p_ofFileDialogResult); } - result = (std::string *) & ((arg1)->filePath); lua_pushlstring(L,result->data(),result->size()); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FileDialogResult_fileName_set(lua_State* L) { int SWIG_arg = 0; - ofFileDialogResult *arg1 = (ofFileDialogResult *) 0 ; std::string *arg2 = 0 ; std::string temp2 ; - SWIG_check_num_args("ofFileDialogResult::fileName",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFileDialogResult::fileName",1,"ofFileDialogResult *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofFileDialogResult::fileName",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFileDialogResult,0))){ - SWIG_fail_ptr("FileDialogResult_fileName_set",1,SWIGTYPE_p_ofFileDialogResult); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; if (arg1) (arg1)->fileName = *arg2; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FileDialogResult_fileName_get(lua_State* L) { int SWIG_arg = 0; - ofFileDialogResult *arg1 = (ofFileDialogResult *) 0 ; std::string *result = 0 ; - SWIG_check_num_args("ofFileDialogResult::fileName",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFileDialogResult::fileName",1,"ofFileDialogResult *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFileDialogResult,0))){ - SWIG_fail_ptr("FileDialogResult_fileName_get",1,SWIGTYPE_p_ofFileDialogResult); } - result = (std::string *) & ((arg1)->fileName); lua_pushlstring(L,result->data(),result->size()); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FileDialogResult_bSuccess_set(lua_State* L) { int SWIG_arg = 0; - ofFileDialogResult *arg1 = (ofFileDialogResult *) 0 ; bool arg2 ; SWIG_check_num_args("ofFileDialogResult::bSuccess",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFileDialogResult::bSuccess",1,"ofFileDialogResult *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofFileDialogResult::bSuccess",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFileDialogResult,0))){ - SWIG_fail_ptr("FileDialogResult_bSuccess_set",1,SWIGTYPE_p_ofFileDialogResult); } arg2 = (lua_toboolean(L, 2)!=0); - if (arg1) (arg1)->bSuccess = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FileDialogResult_bSuccess_get(lua_State* L) { int SWIG_arg = 0; - ofFileDialogResult *arg1 = (ofFileDialogResult *) 0 ; bool result; SWIG_check_num_args("ofFileDialogResult::bSuccess",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFileDialogResult::bSuccess",1,"ofFileDialogResult *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFileDialogResult,0))){ - SWIG_fail_ptr("FileDialogResult_bSuccess_get",1,SWIGTYPE_p_ofFileDialogResult); } result = (bool) ((arg1)->bSuccess); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_FileDialogResult(void *obj) { -ofFileDialogResult *arg1 = (ofFileDialogResult *) obj; -delete arg1; -} -static int _proxy__wrap_new_FileDialogResult(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_FileDialogResult); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_FileDialogResult_attributes[] = { - { "filePath", _wrap_FileDialogResult_filePath_get, _wrap_FileDialogResult_filePath_set }, - { "fileName", _wrap_FileDialogResult_fileName_get, _wrap_FileDialogResult_fileName_set }, - { "bSuccess", _wrap_FileDialogResult_bSuccess_get, _wrap_FileDialogResult_bSuccess_set }, - {0,0,0} -}; -static swig_lua_method swig_FileDialogResult_methods[]= { - { "getName", _wrap_FileDialogResult_getName}, - { "getPath", _wrap_FileDialogResult_getPath}, - {0,0} -}; -static swig_lua_method swig_FileDialogResult_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_FileDialogResult_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_FileDialogResult_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_FileDialogResult_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_FileDialogResult_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_FileDialogResult_Sf_SwigStatic = { - "FileDialogResult", - swig_FileDialogResult_Sf_SwigStatic_methods, - swig_FileDialogResult_Sf_SwigStatic_attributes, - swig_FileDialogResult_Sf_SwigStatic_constants, - swig_FileDialogResult_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_FileDialogResult_bases[] = {0}; -static const char *swig_FileDialogResult_base_names[] = {0}; -static swig_lua_class _wrap_class_FileDialogResult = { "FileDialogResult", "FileDialogResult", &SWIGTYPE_p_ofFileDialogResult,_proxy__wrap_new_FileDialogResult, swig_delete_FileDialogResult, swig_FileDialogResult_methods, swig_FileDialogResult_attributes, &swig_FileDialogResult_Sf_SwigStatic, swig_FileDialogResult_meta, swig_FileDialogResult_bases, swig_FileDialogResult_base_names }; - -static int _wrap_systemAlertDialog(lua_State* L) { int SWIG_arg = 0; std::string arg1 ; - SWIG_check_num_args("ofSystemAlertDialog",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofSystemAlertDialog",1,"std::string"); - (&arg1)->assign(lua_tostring(L,1),lua_rawlen(L,1)); ofSystemAlertDialog(arg1); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_systemLoadDialog__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string arg1 ; bool arg2 ; std::string arg3 ; - ofFileDialogResult result; SWIG_check_num_args("ofSystemLoadDialog",3,3) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofSystemLoadDialog",1,"std::string"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofSystemLoadDialog",2,"bool"); - if(!lua_isstring(L,3)) SWIG_fail_arg("ofSystemLoadDialog",3,"std::string"); - (&arg1)->assign(lua_tostring(L,1),lua_rawlen(L,1)); arg2 = (lua_toboolean(L, 2)!=0); - (&arg3)->assign(lua_tostring(L,3),lua_rawlen(L,3)); result = ofSystemLoadDialog(arg1,arg2,arg3); { - ofFileDialogResult * resultptr = new ofFileDialogResult((const ofFileDialogResult &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofFileDialogResult,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_systemLoadDialog__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string arg1 ; bool arg2 ; - ofFileDialogResult result; SWIG_check_num_args("ofSystemLoadDialog",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofSystemLoadDialog",1,"std::string"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofSystemLoadDialog",2,"bool"); (&arg1)->assign(lua_tostring(L,1),lua_rawlen(L,1)); - arg2 = (lua_toboolean(L, 2)!=0); result = ofSystemLoadDialog(arg1,arg2); { - ofFileDialogResult * resultptr = new ofFileDialogResult((const ofFileDialogResult &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofFileDialogResult,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_systemLoadDialog__SWIG_2(lua_State* L) { int SWIG_arg = 0; std::string arg1 ; ofFileDialogResult result; - SWIG_check_num_args("ofSystemLoadDialog",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofSystemLoadDialog",1,"std::string"); - (&arg1)->assign(lua_tostring(L,1),lua_rawlen(L,1)); result = ofSystemLoadDialog(arg1); { - ofFileDialogResult * resultptr = new ofFileDialogResult((const ofFileDialogResult &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofFileDialogResult,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_systemLoadDialog__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofFileDialogResult result; - SWIG_check_num_args("ofSystemLoadDialog",0,0) result = ofSystemLoadDialog(); { - ofFileDialogResult * resultptr = new ofFileDialogResult((const ofFileDialogResult &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofFileDialogResult,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_systemLoadDialog(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_systemLoadDialog__SWIG_3(L);} if (argc == 1) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { - return _wrap_systemLoadDialog__SWIG_2(L);} } if (argc == 2) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { { - _v = lua_isboolean(L,argv[1]); } if (_v) { return _wrap_systemLoadDialog__SWIG_1(L);} } } if (argc == 3) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { { _v = lua_isstring(L,argv[2]); } - if (_v) { return _wrap_systemLoadDialog__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'systemLoadDialog'\n" " Possible C/C++ prototypes are:\n" - " ofSystemLoadDialog(std::string,bool,std::string)\n" " ofSystemLoadDialog(std::string,bool)\n" - " ofSystemLoadDialog(std::string)\n" " ofSystemLoadDialog()\n"); lua_error(L);return 0; } -static int _wrap_systemSaveDialog(lua_State* L) { int SWIG_arg = 0; std::string arg1 ; std::string arg2 ; - ofFileDialogResult result; SWIG_check_num_args("ofSystemSaveDialog",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofSystemSaveDialog",1,"std::string"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofSystemSaveDialog",2,"std::string"); - (&arg1)->assign(lua_tostring(L,1),lua_rawlen(L,1)); (&arg2)->assign(lua_tostring(L,2),lua_rawlen(L,2)); - result = ofSystemSaveDialog(arg1,arg2); { - ofFileDialogResult * resultptr = new ofFileDialogResult((const ofFileDialogResult &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofFileDialogResult,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_systemTextBoxDialog__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string arg1 ; std::string arg2 ; - std::string result; SWIG_check_num_args("ofSystemTextBoxDialog",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofSystemTextBoxDialog",1,"std::string"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofSystemTextBoxDialog",2,"std::string"); - (&arg1)->assign(lua_tostring(L,1),lua_rawlen(L,1)); (&arg2)->assign(lua_tostring(L,2),lua_rawlen(L,2)); - result = ofSystemTextBoxDialog(arg1,arg2); lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_systemTextBoxDialog__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string arg1 ; std::string result; - SWIG_check_num_args("ofSystemTextBoxDialog",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofSystemTextBoxDialog",1,"std::string"); - (&arg1)->assign(lua_tostring(L,1),lua_rawlen(L,1)); result = ofSystemTextBoxDialog(arg1); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_systemTextBoxDialog(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { return _wrap_systemTextBoxDialog__SWIG_1(L);} } if (argc == 2) { - int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { - return _wrap_systemTextBoxDialog__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'systemTextBoxDialog'\n" - " Possible C/C++ prototypes are:\n" " ofSystemTextBoxDialog(std::string,std::string)\n" - " ofSystemTextBoxDialog(std::string)\n"); lua_error(L);return 0; } -static int _wrap_new_HttpRequest__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofHttpRequest *result = 0 ; - SWIG_check_num_args("ofHttpRequest::ofHttpRequest",0,0) result = (ofHttpRequest *)new ofHttpRequest(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofHttpRequest,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_HttpRequest__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; - bool arg3 ; std::string temp1 ; std::string temp2 ; ofHttpRequest *result = 0 ; - SWIG_check_num_args("ofHttpRequest::ofHttpRequest",3,3) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofHttpRequest::ofHttpRequest",1,"std::string const &"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofHttpRequest::ofHttpRequest",2,"std::string const &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofHttpRequest::ofHttpRequest",3,"bool"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - arg3 = (lua_toboolean(L, 3)!=0); - result = (ofHttpRequest *)new ofHttpRequest((std::string const &)*arg1,(std::string const &)*arg2,arg3); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofHttpRequest,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_HttpRequest__SWIG_2(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; - std::string temp1 ; std::string temp2 ; ofHttpRequest *result = 0 ; SWIG_check_num_args("ofHttpRequest::ofHttpRequest",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofHttpRequest::ofHttpRequest",1,"std::string const &"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofHttpRequest::ofHttpRequest",2,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = (ofHttpRequest *)new ofHttpRequest((std::string const &)*arg1,(std::string const &)*arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofHttpRequest,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_HttpRequest(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_HttpRequest__SWIG_0(L);} if (argc == 2) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { { - _v = lua_isstring(L,argv[1]); } if (_v) { return _wrap_new_HttpRequest__SWIG_2(L);} } } if (argc == 3) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } - if (_v) { return _wrap_new_HttpRequest__SWIG_1(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_HttpRequest'\n" " Possible C/C++ prototypes are:\n" - " ofHttpRequest::ofHttpRequest()\n" " ofHttpRequest::ofHttpRequest(std::string const &,std::string const &,bool)\n" - " ofHttpRequest::ofHttpRequest(std::string const &,std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_HttpRequest_url_set(lua_State* L) { int SWIG_arg = 0; ofHttpRequest *arg1 = (ofHttpRequest *) 0 ; - std::string *arg2 = 0 ; std::string temp2 ; SWIG_check_num_args("ofHttpRequest::url",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofHttpRequest::url",1,"ofHttpRequest *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofHttpRequest::url",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofHttpRequest,0))){ - SWIG_fail_ptr("HttpRequest_url_set",1,SWIGTYPE_p_ofHttpRequest); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; if (arg1) (arg1)->url = *arg2; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_HttpRequest_url_get(lua_State* L) { int SWIG_arg = 0; ofHttpRequest *arg1 = (ofHttpRequest *) 0 ; - std::string *result = 0 ; SWIG_check_num_args("ofHttpRequest::url",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofHttpRequest::url",1,"ofHttpRequest *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofHttpRequest,0))){ - SWIG_fail_ptr("HttpRequest_url_get",1,SWIGTYPE_p_ofHttpRequest); } result = (std::string *) & ((arg1)->url); - lua_pushlstring(L,result->data(),result->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_HttpRequest_name_set(lua_State* L) { int SWIG_arg = 0; ofHttpRequest *arg1 = (ofHttpRequest *) 0 ; - std::string *arg2 = 0 ; std::string temp2 ; SWIG_check_num_args("ofHttpRequest::name",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofHttpRequest::name",1,"ofHttpRequest *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofHttpRequest::name",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofHttpRequest,0))){ - SWIG_fail_ptr("HttpRequest_name_set",1,SWIGTYPE_p_ofHttpRequest); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; if (arg1) (arg1)->name = *arg2; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_HttpRequest_name_get(lua_State* L) { int SWIG_arg = 0; ofHttpRequest *arg1 = (ofHttpRequest *) 0 ; - std::string *result = 0 ; SWIG_check_num_args("ofHttpRequest::name",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofHttpRequest::name",1,"ofHttpRequest *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofHttpRequest,0))){ - SWIG_fail_ptr("HttpRequest_name_get",1,SWIGTYPE_p_ofHttpRequest); } result = (std::string *) & ((arg1)->name); - lua_pushlstring(L,result->data(),result->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_HttpRequest_saveTo_set(lua_State* L) { int SWIG_arg = 0; ofHttpRequest *arg1 = (ofHttpRequest *) 0 ; - bool arg2 ; SWIG_check_num_args("ofHttpRequest::saveTo",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofHttpRequest::saveTo",1,"ofHttpRequest *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofHttpRequest::saveTo",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofHttpRequest,0))){ - SWIG_fail_ptr("HttpRequest_saveTo_set",1,SWIGTYPE_p_ofHttpRequest); } arg2 = (lua_toboolean(L, 2)!=0); - if (arg1) (arg1)->saveTo = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_HttpRequest_saveTo_get(lua_State* L) { int SWIG_arg = 0; ofHttpRequest *arg1 = (ofHttpRequest *) 0 ; - bool result; SWIG_check_num_args("ofHttpRequest::saveTo",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofHttpRequest::saveTo",1,"ofHttpRequest *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofHttpRequest,0))){ - SWIG_fail_ptr("HttpRequest_saveTo_get",1,SWIGTYPE_p_ofHttpRequest); } result = (bool) ((arg1)->saveTo); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_HttpRequest_headers_set(lua_State* L) { int SWIG_arg = 0; ofHttpRequest *arg1 = (ofHttpRequest *) 0 ; - std::map< std::string,std::string > *arg2 = (std::map< std::string,std::string > *) 0 ; - SWIG_check_num_args("ofHttpRequest::headers",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofHttpRequest::headers",1,"ofHttpRequest *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofHttpRequest::headers",2,"std::map< std::string,std::string > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofHttpRequest,0))){ - SWIG_fail_ptr("HttpRequest_headers_set",1,SWIGTYPE_p_ofHttpRequest); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__mapT_std__string_std__string_t,0))){ - SWIG_fail_ptr("HttpRequest_headers_set",2,SWIGTYPE_p_std__mapT_std__string_std__string_t); } - if (arg1) (arg1)->headers = *arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_HttpRequest_headers_get(lua_State* L) { int SWIG_arg = 0; ofHttpRequest *arg1 = (ofHttpRequest *) 0 ; - std::map< std::string,std::string > *result = 0 ; SWIG_check_num_args("ofHttpRequest::headers",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofHttpRequest::headers",1,"ofHttpRequest *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofHttpRequest,0))){ - SWIG_fail_ptr("HttpRequest_headers_get",1,SWIGTYPE_p_ofHttpRequest); } - result = (std::map< std::string,std::string > *)& ((arg1)->headers); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__mapT_std__string_std__string_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_HttpRequest_getId(lua_State* L) { int SWIG_arg = 0; ofHttpRequest *arg1 = (ofHttpRequest *) 0 ; int result; - SWIG_check_num_args("ofHttpRequest::getId",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofHttpRequest::getId",1,"ofHttpRequest const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofHttpRequest,0))){ - SWIG_fail_ptr("HttpRequest_getId",1,SWIGTYPE_p_ofHttpRequest); } result = (int)((ofHttpRequest const *)arg1)->getId(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_HttpRequest(void *obj) { -ofHttpRequest *arg1 = (ofHttpRequest *) obj; -delete arg1; -} -static int _proxy__wrap_new_HttpRequest(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_HttpRequest); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_HttpRequest_attributes[] = { - { "url", _wrap_HttpRequest_url_get, _wrap_HttpRequest_url_set }, - { "name", _wrap_HttpRequest_name_get, _wrap_HttpRequest_name_set }, - { "saveTo", _wrap_HttpRequest_saveTo_get, _wrap_HttpRequest_saveTo_set }, - { "headers", _wrap_HttpRequest_headers_get, _wrap_HttpRequest_headers_set }, - {0,0,0} -}; -static swig_lua_method swig_HttpRequest_methods[]= { - { "getId", _wrap_HttpRequest_getId}, - {0,0} -}; -static swig_lua_method swig_HttpRequest_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_HttpRequest_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_HttpRequest_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_HttpRequest_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_HttpRequest_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_HttpRequest_Sf_SwigStatic = { - "HttpRequest", - swig_HttpRequest_Sf_SwigStatic_methods, - swig_HttpRequest_Sf_SwigStatic_attributes, - swig_HttpRequest_Sf_SwigStatic_constants, - swig_HttpRequest_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_HttpRequest_bases[] = {0}; -static const char *swig_HttpRequest_base_names[] = {0}; -static swig_lua_class _wrap_class_HttpRequest = { "HttpRequest", "HttpRequest", &SWIGTYPE_p_ofHttpRequest,_proxy__wrap_new_HttpRequest, swig_delete_HttpRequest, swig_HttpRequest_methods, swig_HttpRequest_attributes, &swig_HttpRequest_Sf_SwigStatic, swig_HttpRequest_meta, swig_HttpRequest_bases, swig_HttpRequest_base_names }; - -static int _wrap_new_HttpResponse__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofHttpResponse *result = 0 ; - SWIG_check_num_args("ofHttpResponse::ofHttpResponse",0,0) result = (ofHttpResponse *)new ofHttpResponse(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofHttpResponse,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_HttpResponse__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofHttpRequest *arg1 = 0 ; ofBuffer *arg2 = 0 ; - int arg3 ; std::string *arg4 = 0 ; std::string temp4 ; ofHttpResponse *result = 0 ; - SWIG_check_num_args("ofHttpResponse::ofHttpResponse",4,4) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofHttpResponse::ofHttpResponse",1,"ofHttpRequest const &"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofHttpResponse::ofHttpResponse",2,"ofBuffer const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofHttpResponse::ofHttpResponse",3,"int"); - if(!lua_isstring(L,4)) SWIG_fail_arg("ofHttpResponse::ofHttpResponse",4,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofHttpRequest,0))){ - SWIG_fail_ptr("new_HttpResponse",1,SWIGTYPE_p_ofHttpRequest); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBuffer,0))){ - SWIG_fail_ptr("new_HttpResponse",2,SWIGTYPE_p_ofBuffer); } arg3 = (int)lua_tonumber(L, 3); - temp4.assign(lua_tostring(L,4),lua_rawlen(L,4)); arg4=&temp4; - result = (ofHttpResponse *)new ofHttpResponse((ofHttpRequest const &)*arg1,(ofBuffer const &)*arg2,arg3,(std::string const &)*arg4); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofHttpResponse,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_HttpResponse__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofHttpRequest *arg1 = 0 ; int arg2 ; - std::string *arg3 = 0 ; std::string temp3 ; ofHttpResponse *result = 0 ; - SWIG_check_num_args("ofHttpResponse::ofHttpResponse",3,3) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofHttpResponse::ofHttpResponse",1,"ofHttpRequest const &"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofHttpResponse::ofHttpResponse",2,"int"); - if(!lua_isstring(L,3)) SWIG_fail_arg("ofHttpResponse::ofHttpResponse",3,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofHttpRequest,0))){ - SWIG_fail_ptr("new_HttpResponse",1,SWIGTYPE_p_ofHttpRequest); } arg2 = (int)lua_tonumber(L, 2); - temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3; - result = (ofHttpResponse *)new ofHttpResponse((ofHttpRequest const &)*arg1,arg2,(std::string const &)*arg3); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofHttpResponse,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_HttpResponse(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_HttpResponse__SWIG_0(L);} if (argc == 3) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofHttpRequest, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isstring(L,argv[2]); } if (_v) { - return _wrap_new_HttpResponse__SWIG_2(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofHttpRequest, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBuffer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isstring(L,argv[3]); } - if (_v) { return _wrap_new_HttpResponse__SWIG_1(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_HttpResponse'\n" " Possible C/C++ prototypes are:\n" - " ofHttpResponse::ofHttpResponse()\n" - " ofHttpResponse::ofHttpResponse(ofHttpRequest const &,ofBuffer const &,int,std::string const &)\n" - " ofHttpResponse::ofHttpResponse(ofHttpRequest const &,int,std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_HttpResponse_request_set(lua_State* L) { int SWIG_arg = 0; ofHttpResponse *arg1 = (ofHttpResponse *) 0 ; - ofHttpRequest *arg2 = (ofHttpRequest *) 0 ; SWIG_check_num_args("ofHttpResponse::request",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofHttpResponse::request",1,"ofHttpResponse *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofHttpResponse::request",2,"ofHttpRequest *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofHttpResponse,0))){ - SWIG_fail_ptr("HttpResponse_request_set",1,SWIGTYPE_p_ofHttpResponse); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofHttpRequest,0))){ - SWIG_fail_ptr("HttpResponse_request_set",2,SWIGTYPE_p_ofHttpRequest); } if (arg1) (arg1)->request = *arg2; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_HttpResponse_request_get(lua_State* L) { int SWIG_arg = 0; ofHttpResponse *arg1 = (ofHttpResponse *) 0 ; - ofHttpRequest *result = 0 ; SWIG_check_num_args("ofHttpResponse::request",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofHttpResponse::request",1,"ofHttpResponse *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofHttpResponse,0))){ - SWIG_fail_ptr("HttpResponse_request_get",1,SWIGTYPE_p_ofHttpResponse); } result = (ofHttpRequest *)& ((arg1)->request); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofHttpRequest,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_HttpResponse_data_set(lua_State* L) { int SWIG_arg = 0; ofHttpResponse *arg1 = (ofHttpResponse *) 0 ; - ofBuffer *arg2 = (ofBuffer *) 0 ; SWIG_check_num_args("ofHttpResponse::data",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofHttpResponse::data",1,"ofHttpResponse *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofHttpResponse::data",2,"ofBuffer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofHttpResponse,0))){ - SWIG_fail_ptr("HttpResponse_data_set",1,SWIGTYPE_p_ofHttpResponse); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBuffer,0))){ - SWIG_fail_ptr("HttpResponse_data_set",2,SWIGTYPE_p_ofBuffer); } if (arg1) (arg1)->data = *arg2; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_HttpResponse_data_get(lua_State* L) { int SWIG_arg = 0; ofHttpResponse *arg1 = (ofHttpResponse *) 0 ; - ofBuffer *result = 0 ; SWIG_check_num_args("ofHttpResponse::data",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofHttpResponse::data",1,"ofHttpResponse *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofHttpResponse,0))){ - SWIG_fail_ptr("HttpResponse_data_get",1,SWIGTYPE_p_ofHttpResponse); } result = (ofBuffer *)& ((arg1)->data); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofBuffer,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_HttpResponse_status_set(lua_State* L) { int SWIG_arg = 0; ofHttpResponse *arg1 = (ofHttpResponse *) 0 ; - int arg2 ; SWIG_check_num_args("ofHttpResponse::status",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofHttpResponse::status",1,"ofHttpResponse *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofHttpResponse::status",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofHttpResponse,0))){ - SWIG_fail_ptr("HttpResponse_status_set",1,SWIGTYPE_p_ofHttpResponse); } arg2 = (int)lua_tonumber(L, 2); - if (arg1) (arg1)->status = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_HttpResponse_status_get(lua_State* L) { int SWIG_arg = 0; ofHttpResponse *arg1 = (ofHttpResponse *) 0 ; - int result; SWIG_check_num_args("ofHttpResponse::status",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofHttpResponse::status",1,"ofHttpResponse *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofHttpResponse,0))){ - SWIG_fail_ptr("HttpResponse_status_get",1,SWIGTYPE_p_ofHttpResponse); } result = (int) ((arg1)->status); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_HttpResponse_error_set(lua_State* L) { int SWIG_arg = 0; ofHttpResponse *arg1 = (ofHttpResponse *) 0 ; - std::string *arg2 = 0 ; std::string temp2 ; SWIG_check_num_args("ofHttpResponse::error",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofHttpResponse::error",1,"ofHttpResponse *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofHttpResponse::error",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofHttpResponse,0))){ - SWIG_fail_ptr("HttpResponse_error_set",1,SWIGTYPE_p_ofHttpResponse); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; if (arg1) (arg1)->error = *arg2; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_HttpResponse_error_get(lua_State* L) { int SWIG_arg = 0; ofHttpResponse *arg1 = (ofHttpResponse *) 0 ; - std::string *result = 0 ; SWIG_check_num_args("ofHttpResponse::error",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofHttpResponse::error",1,"ofHttpResponse *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofHttpResponse,0))){ - SWIG_fail_ptr("HttpResponse_error_get",1,SWIGTYPE_p_ofHttpResponse); } result = (std::string *) & ((arg1)->error); - lua_pushlstring(L,result->data(),result->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static void swig_delete_HttpResponse(void *obj) { -ofHttpResponse *arg1 = (ofHttpResponse *) obj; -delete arg1; -} -static int _proxy__wrap_new_HttpResponse(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_HttpResponse); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_HttpResponse_attributes[] = { - { "request", _wrap_HttpResponse_request_get, _wrap_HttpResponse_request_set }, - { "data", _wrap_HttpResponse_data_get, _wrap_HttpResponse_data_set }, - { "status", _wrap_HttpResponse_status_get, _wrap_HttpResponse_status_set }, - { "error", _wrap_HttpResponse_error_get, _wrap_HttpResponse_error_set }, - {0,0,0} -}; -static swig_lua_method swig_HttpResponse_methods[]= { - {0,0} -}; -static swig_lua_method swig_HttpResponse_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_HttpResponse_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_HttpResponse_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_HttpResponse_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_HttpResponse_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_HttpResponse_Sf_SwigStatic = { - "HttpResponse", - swig_HttpResponse_Sf_SwigStatic_methods, - swig_HttpResponse_Sf_SwigStatic_attributes, - swig_HttpResponse_Sf_SwigStatic_constants, - swig_HttpResponse_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_HttpResponse_bases[] = {0}; -static const char *swig_HttpResponse_base_names[] = {0}; -static swig_lua_class _wrap_class_HttpResponse = { "HttpResponse", "HttpResponse", &SWIGTYPE_p_ofHttpResponse,_proxy__wrap_new_HttpResponse, swig_delete_HttpResponse, swig_HttpResponse_methods, swig_HttpResponse_attributes, &swig_HttpResponse_Sf_SwigStatic, swig_HttpResponse_meta, swig_HttpResponse_bases, swig_HttpResponse_base_names }; - -static int _wrap_loadURL(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; ofHttpResponse result; - SWIG_check_num_args("ofLoadURL",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofLoadURL",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = ofLoadURL((std::string const &)*arg1); { - ofHttpResponse * resultptr = new ofHttpResponse((const ofHttpResponse &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofHttpResponse,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_loadURLAsync__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; - std::string temp1 ; std::string temp2 ; int result; SWIG_check_num_args("ofLoadURLAsync",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofLoadURLAsync",1,"std::string const &"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofLoadURLAsync",2,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = (int)ofLoadURLAsync((std::string const &)*arg1,(std::string const &)*arg2); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_loadURLAsync__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; int result; - SWIG_check_num_args("ofLoadURLAsync",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofLoadURLAsync",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = (int)ofLoadURLAsync((std::string const &)*arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_loadURLAsync(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { return _wrap_loadURLAsync__SWIG_1(L);} } if (argc == 2) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { - return _wrap_loadURLAsync__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'loadURLAsync'\n" " Possible C/C++ prototypes are:\n" - " ofLoadURLAsync(std::string const &,std::string const &)\n" " ofLoadURLAsync(std::string const &)\n"); - lua_error(L);return 0; } -static int _wrap_saveURLTo(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; std::string temp1 ; - std::string temp2 ; ofHttpResponse result; SWIG_check_num_args("ofSaveURLTo",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofSaveURLTo",1,"std::string const &"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofSaveURLTo",2,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = ofSaveURLTo((std::string const &)*arg1,(std::string const &)*arg2); { - ofHttpResponse * resultptr = new ofHttpResponse((const ofHttpResponse &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofHttpResponse,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_saveURLAsync(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; - std::string temp1 ; std::string temp2 ; int result; SWIG_check_num_args("ofSaveURLAsync",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofSaveURLAsync",1,"std::string const &"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofSaveURLAsync",2,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = (int)ofSaveURLAsync((std::string const &)*arg1,(std::string const &)*arg2); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_removeURLRequest(lua_State* L) { int SWIG_arg = 0; int arg1 ; SWIG_check_num_args("ofRemoveURLRequest",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofRemoveURLRequest",1,"int"); arg1 = (int)lua_tonumber(L, 1); ofRemoveURLRequest(arg1); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_removeAllURLRequests(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofRemoveAllURLRequests",0,0) - ofRemoveAllURLRequests(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_stopURLLoader(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofStopURLLoader",0,0) ofStopURLLoader(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_uRLResponseEvent(lua_State* L) { int SWIG_arg = 0; ofEvent< ofHttpResponse > *result = 0 ; - SWIG_check_num_args("ofURLResponseEvent",0,0) result = (ofEvent< ofHttpResponse > *) &ofURLResponseEvent(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofEventT_ofHttpResponse_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_URLFileLoader(lua_State* L) { int SWIG_arg = 0; ofURLFileLoader *result = 0 ; - SWIG_check_num_args("ofURLFileLoader::ofURLFileLoader",0,0) result = (ofURLFileLoader *)new ofURLFileLoader(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofURLFileLoader,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_URLFileLoader_get(lua_State* L) { int SWIG_arg = 0; ofURLFileLoader *arg1 = (ofURLFileLoader *) 0 ; - std::string *arg2 = 0 ; std::string temp2 ; ofHttpResponse result; SWIG_check_num_args("ofURLFileLoader::get",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofURLFileLoader::get",1,"ofURLFileLoader *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofURLFileLoader::get",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofURLFileLoader,0))){ - SWIG_fail_ptr("URLFileLoader_get",1,SWIGTYPE_p_ofURLFileLoader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; result = (arg1)->get((std::string const &)*arg2); { - ofHttpResponse * resultptr = new ofHttpResponse((const ofHttpResponse &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofHttpResponse,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_URLFileLoader_getAsync__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofURLFileLoader *arg1 = (ofURLFileLoader *) 0 ; std::string *arg2 = 0 ; std::string *arg3 = 0 ; std::string temp2 ; - std::string temp3 ; int result; SWIG_check_num_args("ofURLFileLoader::getAsync",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofURLFileLoader::getAsync",1,"ofURLFileLoader *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofURLFileLoader::getAsync",2,"std::string const &"); - if(!lua_isstring(L,3)) SWIG_fail_arg("ofURLFileLoader::getAsync",3,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofURLFileLoader,0))){ - SWIG_fail_ptr("URLFileLoader_getAsync",1,SWIGTYPE_p_ofURLFileLoader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3; - result = (int)(arg1)->getAsync((std::string const &)*arg2,(std::string const &)*arg3); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_URLFileLoader_getAsync__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofURLFileLoader *arg1 = (ofURLFileLoader *) 0 ; std::string *arg2 = 0 ; std::string temp2 ; int result; - SWIG_check_num_args("ofURLFileLoader::getAsync",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofURLFileLoader::getAsync",1,"ofURLFileLoader *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofURLFileLoader::getAsync",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofURLFileLoader,0))){ - SWIG_fail_ptr("URLFileLoader_getAsync",1,SWIGTYPE_p_ofURLFileLoader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; result = (int)(arg1)->getAsync((std::string const &)*arg2); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_URLFileLoader_getAsync(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofURLFileLoader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { - return _wrap_URLFileLoader_getAsync__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofURLFileLoader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isstring(L,argv[2]); } if (_v) { - return _wrap_URLFileLoader_getAsync__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'URLFileLoader_getAsync'\n" - " Possible C/C++ prototypes are:\n" " ofURLFileLoader::getAsync(std::string const &,std::string const &)\n" - " ofURLFileLoader::getAsync(std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_URLFileLoader_saveTo(lua_State* L) { int SWIG_arg = 0; ofURLFileLoader *arg1 = (ofURLFileLoader *) 0 ; - std::string *arg2 = 0 ; std::string *arg3 = 0 ; std::string temp2 ; std::string temp3 ; ofHttpResponse result; - SWIG_check_num_args("ofURLFileLoader::saveTo",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofURLFileLoader::saveTo",1,"ofURLFileLoader *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofURLFileLoader::saveTo",2,"std::string const &"); - if(!lua_isstring(L,3)) SWIG_fail_arg("ofURLFileLoader::saveTo",3,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofURLFileLoader,0))){ - SWIG_fail_ptr("URLFileLoader_saveTo",1,SWIGTYPE_p_ofURLFileLoader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3; - result = (arg1)->saveTo((std::string const &)*arg2,(std::string const &)*arg3); { - ofHttpResponse * resultptr = new ofHttpResponse((const ofHttpResponse &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofHttpResponse,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_URLFileLoader_saveAsync(lua_State* L) { int SWIG_arg = 0; ofURLFileLoader *arg1 = (ofURLFileLoader *) 0 ; - std::string *arg2 = 0 ; std::string *arg3 = 0 ; std::string temp2 ; std::string temp3 ; int result; - SWIG_check_num_args("ofURLFileLoader::saveAsync",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofURLFileLoader::saveAsync",1,"ofURLFileLoader *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofURLFileLoader::saveAsync",2,"std::string const &"); - if(!lua_isstring(L,3)) SWIG_fail_arg("ofURLFileLoader::saveAsync",3,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofURLFileLoader,0))){ - SWIG_fail_ptr("URLFileLoader_saveAsync",1,SWIGTYPE_p_ofURLFileLoader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3; - result = (int)(arg1)->saveAsync((std::string const &)*arg2,(std::string const &)*arg3); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_URLFileLoader_remove(lua_State* L) { int SWIG_arg = 0; ofURLFileLoader *arg1 = (ofURLFileLoader *) 0 ; - int arg2 ; SWIG_check_num_args("ofURLFileLoader::remove",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofURLFileLoader::remove",1,"ofURLFileLoader *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofURLFileLoader::remove",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofURLFileLoader,0))){ - SWIG_fail_ptr("URLFileLoader_remove",1,SWIGTYPE_p_ofURLFileLoader); } arg2 = (int)lua_tonumber(L, 2); (arg1)->remove(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_URLFileLoader_clear(lua_State* L) { int SWIG_arg = 0; ofURLFileLoader *arg1 = (ofURLFileLoader *) 0 ; - SWIG_check_num_args("ofURLFileLoader::clear",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofURLFileLoader::clear",1,"ofURLFileLoader *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofURLFileLoader,0))){ - SWIG_fail_ptr("URLFileLoader_clear",1,SWIGTYPE_p_ofURLFileLoader); } (arg1)->clear(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_URLFileLoader_stop(lua_State* L) { int SWIG_arg = 0; ofURLFileLoader *arg1 = (ofURLFileLoader *) 0 ; - SWIG_check_num_args("ofURLFileLoader::stop",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofURLFileLoader::stop",1,"ofURLFileLoader *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofURLFileLoader,0))){ - SWIG_fail_ptr("URLFileLoader_stop",1,SWIGTYPE_p_ofURLFileLoader); } (arg1)->stop(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_URLFileLoader_handleRequest(lua_State* L) { int SWIG_arg = 0; ofURLFileLoader *arg1 = (ofURLFileLoader *) 0 ; - ofHttpRequest *arg2 = 0 ; ofHttpResponse result; SWIG_check_num_args("ofURLFileLoader::handleRequest",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofURLFileLoader::handleRequest",1,"ofURLFileLoader *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofURLFileLoader::handleRequest",2,"ofHttpRequest &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofURLFileLoader,0))){ - SWIG_fail_ptr("URLFileLoader_handleRequest",1,SWIGTYPE_p_ofURLFileLoader); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofHttpRequest,0))){ - SWIG_fail_ptr("URLFileLoader_handleRequest",2,SWIGTYPE_p_ofHttpRequest); } result = (arg1)->handleRequest(*arg2); { - ofHttpResponse * resultptr = new ofHttpResponse((const ofHttpResponse &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofHttpResponse,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static void swig_delete_URLFileLoader(void *obj) { -ofURLFileLoader *arg1 = (ofURLFileLoader *) obj; -delete arg1; -} -static int _proxy__wrap_new_URLFileLoader(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_URLFileLoader); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_URLFileLoader_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_URLFileLoader_methods[]= { - { "get", _wrap_URLFileLoader_get}, - { "getAsync", _wrap_URLFileLoader_getAsync}, - { "saveTo", _wrap_URLFileLoader_saveTo}, - { "saveAsync", _wrap_URLFileLoader_saveAsync}, - { "remove", _wrap_URLFileLoader_remove}, - { "clear", _wrap_URLFileLoader_clear}, - { "stop", _wrap_URLFileLoader_stop}, - { "handleRequest", _wrap_URLFileLoader_handleRequest}, - {0,0} -}; -static swig_lua_method swig_URLFileLoader_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_URLFileLoader_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_URLFileLoader_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_URLFileLoader_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_URLFileLoader_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_URLFileLoader_Sf_SwigStatic = { - "URLFileLoader", - swig_URLFileLoader_Sf_SwigStatic_methods, - swig_URLFileLoader_Sf_SwigStatic_attributes, - swig_URLFileLoader_Sf_SwigStatic_constants, - swig_URLFileLoader_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_URLFileLoader_bases[] = {0}; -static const char *swig_URLFileLoader_base_names[] = {0}; -static swig_lua_class _wrap_class_URLFileLoader = { "URLFileLoader", "URLFileLoader", &SWIGTYPE_p_ofURLFileLoader,_proxy__wrap_new_URLFileLoader, swig_delete_URLFileLoader, swig_URLFileLoader_methods, swig_URLFileLoader_attributes, &swig_URLFileLoader_Sf_SwigStatic, swig_URLFileLoader_meta, swig_URLFileLoader_bases, swig_URLFileLoader_base_names }; - -static int _wrap_resetElapsedTimeCounter(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofResetElapsedTimeCounter",0,0) - ofResetElapsedTimeCounter(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getElapsedTimef(lua_State* L) { int SWIG_arg = 0; float result; SWIG_check_num_args("ofGetElapsedTimef",0,0) - result = (float)ofGetElapsedTimef(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_getElapsedTimeMillis(lua_State* L) { int SWIG_arg = 0; uint64_t result; - SWIG_check_num_args("ofGetElapsedTimeMillis",0,0) result = (uint64_t)ofGetElapsedTimeMillis(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getElapsedTimeMicros(lua_State* L) { int SWIG_arg = 0; uint64_t result; - SWIG_check_num_args("ofGetElapsedTimeMicros",0,0) result = (uint64_t)ofGetElapsedTimeMicros(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getSeconds(lua_State* L) { int SWIG_arg = 0; int result; SWIG_check_num_args("ofGetSeconds",0,0) - result = (int)ofGetSeconds(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_getMinutes(lua_State* L) { int SWIG_arg = 0; int result; SWIG_check_num_args("ofGetMinutes",0,0) - result = (int)ofGetMinutes(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_getHours(lua_State* L) { int SWIG_arg = 0; int result; SWIG_check_num_args("ofGetHours",0,0) - result = (int)ofGetHours(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_getUnixTime(lua_State* L) { int SWIG_arg = 0; unsigned int result; SWIG_check_num_args("ofGetUnixTime",0,0) - result = (unsigned int)ofGetUnixTime(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_getSystemTime(lua_State* L) { int SWIG_arg = 0; uint64_t result; SWIG_check_num_args("ofGetSystemTime",0,0) - result = (uint64_t)ofGetSystemTime(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_getSystemTimeMicros(lua_State* L) { int SWIG_arg = 0; uint64_t result; - SWIG_check_num_args("ofGetSystemTimeMicros",0,0) result = (uint64_t)ofGetSystemTimeMicros(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_sleepMillis(lua_State* L) { int SWIG_arg = 0; int arg1 ; SWIG_check_num_args("ofSleepMillis",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSleepMillis",1,"int"); arg1 = (int)lua_tonumber(L, 1); ofSleepMillis(arg1); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getTimestampString__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string result; - SWIG_check_num_args("ofGetTimestampString",0,0) result = ofGetTimestampString(); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_getTimestampString__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - std::string result; SWIG_check_num_args("ofGetTimestampString",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofGetTimestampString",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = ofGetTimestampString((std::string const &)*arg1); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_getTimestampString(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_getTimestampString__SWIG_0(L);} if (argc == 1) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { - return _wrap_getTimestampString__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'getTimestampString'\n" " Possible C/C++ prototypes are:\n" - " ofGetTimestampString()\n" " ofGetTimestampString(std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_getYear(lua_State* L) { int SWIG_arg = 0; int result; SWIG_check_num_args("ofGetYear",0,0) - result = (int)ofGetYear(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_getMonth(lua_State* L) { int SWIG_arg = 0; int result; SWIG_check_num_args("ofGetMonth",0,0) - result = (int)ofGetMonth(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_getDay(lua_State* L) { int SWIG_arg = 0; int result; SWIG_check_num_args("ofGetDay",0,0) - result = (int)ofGetDay(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_getWeekday(lua_State* L) { int SWIG_arg = 0; int result; SWIG_check_num_args("ofGetWeekday",0,0) - result = (int)ofGetWeekday(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_enableDataPath(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofEnableDataPath",0,0) - ofEnableDataPath(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_disableDataPath(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofDisableDataPath",0,0) - ofDisableDataPath(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_toDataPath__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; bool arg2 ; std::string temp1 ; - std::string result; SWIG_check_num_args("ofToDataPath",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofToDataPath",1,"std::string const &"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofToDataPath",2,"bool"); temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; - arg2 = (lua_toboolean(L, 2)!=0); result = ofToDataPath((std::string const &)*arg1,arg2); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_toDataPath__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - std::string result; SWIG_check_num_args("ofToDataPath",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofToDataPath",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = ofToDataPath((std::string const &)*arg1); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_toDataPath(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { return _wrap_toDataPath__SWIG_1(L);} } if (argc == 2) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_toDataPath__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'toDataPath'\n" " Possible C/C++ prototypes are:\n" - " ofToDataPath(std::string const &,bool)\n" " ofToDataPath(std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_restoreWorkingDirectoryToDefault(lua_State* L) { int SWIG_arg = 0; bool result; - SWIG_check_num_args("ofRestoreWorkingDirectoryToDefault",0,0) result = (bool)ofRestoreWorkingDirectoryToDefault(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setDataPathRoot(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - SWIG_check_num_args("ofSetDataPathRoot",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofSetDataPathRoot",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; ofSetDataPathRoot((std::string const &)*arg1); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_splitString__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; - bool arg3 ; bool arg4 ; std::string temp1 ; std::string temp2 ; std::vector< std::string > result; - SWIG_check_num_args("ofSplitString",4,4) if(!lua_isstring(L,1)) SWIG_fail_arg("ofSplitString",1,"std::string const &"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofSplitString",2,"std::string const &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofSplitString",3,"bool"); - if(!lua_isboolean(L,4)) SWIG_fail_arg("ofSplitString",4,"bool"); temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; arg3 = (lua_toboolean(L, 3)!=0); - arg4 = (lua_toboolean(L, 4)!=0); result = ofSplitString((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4); { - std::vector< std::string > * resultptr = new std::vector< std::string >((const std::vector< std::string > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_std__string_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_splitString__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; - bool arg3 ; std::string temp1 ; std::string temp2 ; std::vector< std::string > result; - SWIG_check_num_args("ofSplitString",3,3) if(!lua_isstring(L,1)) SWIG_fail_arg("ofSplitString",1,"std::string const &"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofSplitString",2,"std::string const &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofSplitString",3,"bool"); temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; arg3 = (lua_toboolean(L, 3)!=0); - result = ofSplitString((std::string const &)*arg1,(std::string const &)*arg2,arg3); { - std::vector< std::string > * resultptr = new std::vector< std::string >((const std::vector< std::string > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_std__string_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_splitString__SWIG_2(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; - std::string temp1 ; std::string temp2 ; std::vector< std::string > result; SWIG_check_num_args("ofSplitString",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofSplitString",1,"std::string const &"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofSplitString",2,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = ofSplitString((std::string const &)*arg1,(std::string const &)*arg2); { - std::vector< std::string > * resultptr = new std::vector< std::string >((const std::vector< std::string > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_std__string_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_splitString(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { int _v; - { _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { - return _wrap_splitString__SWIG_2(L);} } } if (argc == 3) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { { - _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - return _wrap_splitString__SWIG_1(L);} } } } if (argc == 4) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { - { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { { - _v = lua_isboolean(L,argv[3]); } if (_v) { return _wrap_splitString__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'splitString'\n" " Possible C/C++ prototypes are:\n" - " ofSplitString(std::string const &,std::string const &,bool,bool)\n" - " ofSplitString(std::string const &,std::string const &,bool)\n" - " ofSplitString(std::string const &,std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_joinString(lua_State* L) { int SWIG_arg = 0; std::vector< std::string > *arg1 = 0 ; std::string *arg2 = 0 ; - std::string temp2 ; std::string result; SWIG_check_num_args("ofJoinString",2,2) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofJoinString",1,"std::vector< std::string > const &"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofJoinString",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_std__string_t,0))){ - SWIG_fail_ptr("joinString",1,SWIGTYPE_p_std__vectorT_std__string_t); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = ofJoinString((std::vector< std::string > const &)*arg1,(std::string const &)*arg2); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_stringReplace(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; - std::string *arg3 = 0 ; std::string temp2 ; std::string temp3 ; SWIG_check_num_args("ofStringReplace",3,3) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofStringReplace",1,"std::string &"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofStringReplace",2,"std::string const &"); - if(!lua_isstring(L,3)) SWIG_fail_arg("ofStringReplace",3,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__string,0))){ - SWIG_fail_ptr("stringReplace",1,SWIGTYPE_p_std__string); } temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3; - ofStringReplace(*arg1,(std::string const &)*arg2,(std::string const &)*arg3); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_isStringInString(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; - std::string temp1 ; std::string temp2 ; bool result; SWIG_check_num_args("ofIsStringInString",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofIsStringInString",1,"std::string const &"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofIsStringInString",2,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = (bool)ofIsStringInString((std::string const &)*arg1,(std::string const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_stringTimesInString(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; - std::string temp1 ; std::string temp2 ; std::size_t result; SWIG_check_num_args("ofStringTimesInString",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofStringTimesInString",1,"std::string const &"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofStringTimesInString",2,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = (std::size_t)ofStringTimesInString((std::string const &)*arg1,(std::string const &)*arg2); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_toLower__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; - std::string temp1 ; std::string temp2 ; std::string result; SWIG_check_num_args("ofToLower",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofToLower",1,"std::string const &"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofToLower",2,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = ofToLower((std::string const &)*arg1,(std::string const &)*arg2); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_toLower__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - std::string result; SWIG_check_num_args("ofToLower",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofToLower",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = ofToLower((std::string const &)*arg1); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_toLower(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { return _wrap_toLower__SWIG_1(L);} } if (argc == 2) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { return _wrap_toLower__SWIG_0(L);} - } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'toLower'\n" " Possible C/C++ prototypes are:\n" - " ofToLower(std::string const &,std::string const &)\n" " ofToLower(std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_toUpper__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; - std::string temp1 ; std::string temp2 ; std::string result; SWIG_check_num_args("ofToUpper",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofToUpper",1,"std::string const &"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofToUpper",2,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = ofToUpper((std::string const &)*arg1,(std::string const &)*arg2); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_toUpper__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - std::string result; SWIG_check_num_args("ofToUpper",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofToUpper",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = ofToUpper((std::string const &)*arg1); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_toUpper(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { return _wrap_toUpper__SWIG_1(L);} } if (argc == 2) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { return _wrap_toUpper__SWIG_0(L);} - } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'toUpper'\n" " Possible C/C++ prototypes are:\n" - " ofToUpper(std::string const &,std::string const &)\n" " ofToUpper(std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_trimFront__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; - std::string temp1 ; std::string temp2 ; std::string result; SWIG_check_num_args("ofTrimFront",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofTrimFront",1,"std::string const &"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofTrimFront",2,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = ofTrimFront((std::string const &)*arg1,(std::string const &)*arg2); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_trimFront__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - std::string result; SWIG_check_num_args("ofTrimFront",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofTrimFront",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = ofTrimFront((std::string const &)*arg1); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_trimFront(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { return _wrap_trimFront__SWIG_1(L);} } if (argc == 2) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { return _wrap_trimFront__SWIG_0(L);} - } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'trimFront'\n" - " Possible C/C++ prototypes are:\n" " ofTrimFront(std::string const &,std::string const &)\n" - " ofTrimFront(std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_trimBack__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; - std::string temp1 ; std::string temp2 ; std::string result; SWIG_check_num_args("ofTrimBack",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofTrimBack",1,"std::string const &"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofTrimBack",2,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = ofTrimBack((std::string const &)*arg1,(std::string const &)*arg2); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_trimBack__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - std::string result; SWIG_check_num_args("ofTrimBack",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofTrimBack",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = ofTrimBack((std::string const &)*arg1); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_trimBack(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { return _wrap_trimBack__SWIG_1(L);} } if (argc == 2) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { return _wrap_trimBack__SWIG_0(L);} - } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'trimBack'\n" - " Possible C/C++ prototypes are:\n" " ofTrimBack(std::string const &,std::string const &)\n" - " ofTrimBack(std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_trim__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; - std::string temp1 ; std::string temp2 ; std::string result; SWIG_check_num_args("ofTrim",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofTrim",1,"std::string const &"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofTrim",2,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = ofTrim((std::string const &)*arg1,(std::string const &)*arg2); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_trim__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; std::string result; - SWIG_check_num_args("ofTrim",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofTrim",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = ofTrim((std::string const &)*arg1); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_trim(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { return _wrap_trim__SWIG_1(L);} } if (argc == 2) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { return _wrap_trim__SWIG_0(L);} } - } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'trim'\n" " Possible C/C++ prototypes are:\n" - " ofTrim(std::string const &,std::string const &)\n" " ofTrim(std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_appendUTF8(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; int arg2 ; - SWIG_check_num_args("ofAppendUTF8",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofAppendUTF8",1,"std::string &"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofAppendUTF8",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__string,0))){ - SWIG_fail_ptr("appendUTF8",1,SWIGTYPE_p_std__string); } arg2 = (int)lua_tonumber(L, 2); ofAppendUTF8(*arg1,arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_toInt(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; int result; - SWIG_check_num_args("ofToInt",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofToInt",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = (int)ofToInt((std::string const &)*arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_toInt64(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; int64_t result; - SWIG_check_num_args("ofToInt64",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofToInt64",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = (int64_t)ofToInt64((std::string const &)*arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_toFloat(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; float result; - SWIG_check_num_args("ofToFloat",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofToFloat",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = (float)ofToFloat((std::string const &)*arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_toDouble(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; double result; - SWIG_check_num_args("ofToDouble",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofToDouble",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = (double)ofToDouble((std::string const &)*arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_toBool(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; bool result; - SWIG_check_num_args("ofToBool",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofToBool",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = (bool)ofToBool((std::string const &)*arg1); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_toHex(lua_State* L) { int SWIG_arg = 0; char *arg1 = (char *) 0 ; std::string result; - SWIG_check_num_args("ofToHex",1,1) if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("ofToHex",1,"char const *"); - arg1 = (char *)lua_tostring(L, 1); result = ofToHex((char const *)arg1); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_hexToInt(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; int result; - SWIG_check_num_args("ofHexToInt",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofHexToInt",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = (int)ofHexToInt((std::string const &)*arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_hexToChar(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; char result; - SWIG_check_num_args("ofHexToChar",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofHexToChar",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = (char)ofHexToChar((std::string const &)*arg1); - lua_pushlstring(L, &result, 1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_hexToFloat(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; float result; - SWIG_check_num_args("ofHexToFloat",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofHexToFloat",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = (float)ofHexToFloat((std::string const &)*arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_hexToString(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; std::string result; - SWIG_check_num_args("ofHexToString",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofHexToString",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = ofHexToString((std::string const &)*arg1); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_toChar(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; char result; - SWIG_check_num_args("ofToChar",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofToChar",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = (char)ofToChar((std::string const &)*arg1); - lua_pushlstring(L, &result, 1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_toBinary(lua_State* L) { int SWIG_arg = 0; char *arg1 = (char *) 0 ; std::string result; - SWIG_check_num_args("ofToBinary",1,1) if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("ofToBinary",1,"char const *"); - arg1 = (char *)lua_tostring(L, 1); result = ofToBinary((char const *)arg1); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_binaryToInt(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; int result; - SWIG_check_num_args("ofBinaryToInt",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofBinaryToInt",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = (int)ofBinaryToInt((std::string const &)*arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_binaryToChar(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; char result; - SWIG_check_num_args("ofBinaryToChar",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofBinaryToChar",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = (char)ofBinaryToChar((std::string const &)*arg1); - lua_pushlstring(L, &result, 1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_binaryToFloat(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; float result; - SWIG_check_num_args("ofBinaryToFloat",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofBinaryToFloat",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = (float)ofBinaryToFloat((std::string const &)*arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_binaryToString(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - std::string result; SWIG_check_num_args("ofBinaryToString",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofBinaryToString",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = ofBinaryToString((std::string const &)*arg1); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_getVersionInfo(lua_State* L) { int SWIG_arg = 0; std::string result; - SWIG_check_num_args("ofGetVersionInfo",0,0) result = ofGetVersionInfo(); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_getVersionMajor(lua_State* L) { int SWIG_arg = 0; unsigned int result; - SWIG_check_num_args("ofGetVersionMajor",0,0) result = (unsigned int)ofGetVersionMajor(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getVersionMinor(lua_State* L) { int SWIG_arg = 0; unsigned int result; - SWIG_check_num_args("ofGetVersionMinor",0,0) result = (unsigned int)ofGetVersionMinor(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getVersionPatch(lua_State* L) { int SWIG_arg = 0; unsigned int result; - SWIG_check_num_args("ofGetVersionPatch",0,0) result = (unsigned int)ofGetVersionPatch(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getVersionPreRelease(lua_State* L) { int SWIG_arg = 0; std::string result; - SWIG_check_num_args("ofGetVersionPreRelease",0,0) result = ofGetVersionPreRelease(); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_saveScreen(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - SWIG_check_num_args("ofSaveScreen",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofSaveScreen",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; ofSaveScreen((std::string const &)*arg1); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_saveFrame__SWIG_0(lua_State* L) { int SWIG_arg = 0; bool arg1 ; SWIG_check_num_args("ofSaveFrame",1,1) - if(!lua_isboolean(L,1)) SWIG_fail_arg("ofSaveFrame",1,"bool"); arg1 = (lua_toboolean(L, 1)!=0); ofSaveFrame(arg1); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_saveFrame__SWIG_1(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofSaveFrame",0,0) ofSaveFrame(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_saveFrame(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_saveFrame__SWIG_1(L);} if (argc == 1) { int _v; { _v = lua_isboolean(L,argv[0]); } if (_v) { - return _wrap_saveFrame__SWIG_0(L);} } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'saveFrame'\n" - " Possible C/C++ prototypes are:\n" " ofSaveFrame(bool)\n" " ofSaveFrame()\n"); lua_error(L);return 0; } -static int _wrap_saveViewport(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - SWIG_check_num_args("ofSaveViewport",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofSaveViewport",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; ofSaveViewport((std::string const &)*arg1); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_launchBrowser__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; bool arg2 ; std::string temp1 ; - SWIG_check_num_args("ofLaunchBrowser",2,2) if(!lua_isstring(L,1)) SWIG_fail_arg("ofLaunchBrowser",1,"std::string const &"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofLaunchBrowser",2,"bool"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; arg2 = (lua_toboolean(L, 2)!=0); - ofLaunchBrowser((std::string const &)*arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_launchBrowser__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - SWIG_check_num_args("ofLaunchBrowser",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofLaunchBrowser",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; ofLaunchBrowser((std::string const &)*arg1); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_launchBrowser(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { return _wrap_launchBrowser__SWIG_1(L);} } if (argc == 2) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_launchBrowser__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'launchBrowser'\n" " Possible C/C++ prototypes are:\n" - " ofLaunchBrowser(std::string const &,bool)\n" " ofLaunchBrowser(std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_system(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; std::string result; - SWIG_check_num_args("ofSystem",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofSystem",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = ofSystem((std::string const &)*arg1); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_getTargetPlatform(lua_State* L) { int SWIG_arg = 0; ofTargetPlatform result; - SWIG_check_num_args("ofGetTargetPlatform",0,0) result = (ofTargetPlatform)ofGetTargetPlatform(); - lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_getEnv(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; std::string result; - SWIG_check_num_args("ofGetEnv",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofGetEnv",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = ofGetEnv((std::string const &)*arg1); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_VideoGrabber(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *result = 0 ; - SWIG_check_num_args("ofVideoGrabber::ofVideoGrabber",0,0) result = (ofVideoGrabber *)new ofVideoGrabber(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVideoGrabber,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_VideoGrabber_listDevices(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - std::vector< ofVideoDevice > result; SWIG_check_num_args("ofVideoGrabber::listDevices",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::listDevices",1,"ofVideoGrabber const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_listDevices",1,SWIGTYPE_p_ofVideoGrabber); } - result = ((ofVideoGrabber const *)arg1)->listDevices(); { - std::vector< ofVideoDevice > * resultptr = new std::vector< ofVideoDevice >((const std::vector< ofVideoDevice > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_ofVideoDevice_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoGrabber_isFrameNew(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - bool result; SWIG_check_num_args("ofVideoGrabber::isFrameNew",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::isFrameNew",1,"ofVideoGrabber const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_isFrameNew",1,SWIGTYPE_p_ofVideoGrabber); } - result = (bool)((ofVideoGrabber const *)arg1)->isFrameNew(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoGrabber_update(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - SWIG_check_num_args("ofVideoGrabber::update",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::update",1,"ofVideoGrabber *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_update",1,SWIGTYPE_p_ofVideoGrabber); } (arg1)->update(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoGrabber_close(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - SWIG_check_num_args("ofVideoGrabber::close",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::close",1,"ofVideoGrabber *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_close",1,SWIGTYPE_p_ofVideoGrabber); } (arg1)->close(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_VideoGrabber_setup__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - int arg2 ; int arg3 ; bool result; SWIG_check_num_args("ofVideoGrabber::setup",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::setup",1,"ofVideoGrabber *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVideoGrabber::setup",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVideoGrabber::setup",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_setup",1,SWIGTYPE_p_ofVideoGrabber); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); result = (bool)(arg1)->setup(arg2,arg3); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoGrabber_setup__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - int arg2 ; int arg3 ; bool arg4 ; bool result; SWIG_check_num_args("ofVideoGrabber::setup",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::setup",1,"ofVideoGrabber *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVideoGrabber::setup",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVideoGrabber::setup",3,"int"); - if(!lua_isboolean(L,4)) SWIG_fail_arg("ofVideoGrabber::setup",4,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_setup",1,SWIGTYPE_p_ofVideoGrabber); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); arg4 = (lua_toboolean(L, 4)!=0); result = (bool)(arg1)->setup(arg2,arg3,arg4); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoGrabber_setup(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVideoGrabber, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_VideoGrabber_setup__SWIG_0(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVideoGrabber, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isboolean(L,argv[3]); } if (_v) { return _wrap_VideoGrabber_setup__SWIG_1(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'VideoGrabber_setup'\n" " Possible C/C++ prototypes are:\n" - " ofVideoGrabber::setup(int,int)\n" " ofVideoGrabber::setup(int,int,bool)\n"); lua_error(L);return 0; } -static int _wrap_VideoGrabber_setPixelFormat(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - ofPixelFormat arg2 ; bool result; SWIG_check_num_args("ofVideoGrabber::setPixelFormat",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::setPixelFormat",1,"ofVideoGrabber *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVideoGrabber::setPixelFormat",2,"ofPixelFormat"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_setPixelFormat",1,SWIGTYPE_p_ofVideoGrabber); } arg2 = (ofPixelFormat)(int)lua_tonumber(L, 2); - result = (bool)(arg1)->setPixelFormat(arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoGrabber_getPixelFormat(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - ofPixelFormat result; SWIG_check_num_args("ofVideoGrabber::getPixelFormat",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::getPixelFormat",1,"ofVideoGrabber const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_getPixelFormat",1,SWIGTYPE_p_ofVideoGrabber); } - result = (ofPixelFormat)((ofVideoGrabber const *)arg1)->getPixelFormat(); - lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_VideoGrabber_videoSettings(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - SWIG_check_num_args("ofVideoGrabber::videoSettings",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::videoSettings",1,"ofVideoGrabber *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_videoSettings",1,SWIGTYPE_p_ofVideoGrabber); } (arg1)->videoSettings(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoGrabber_getPixels__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - ofPixels *result = 0 ; SWIG_check_num_args("ofVideoGrabber::getPixels",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::getPixels",1,"ofVideoGrabber *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_getPixels",1,SWIGTYPE_p_ofVideoGrabber); } result = (ofPixels *) &(arg1)->getPixels(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_VideoGrabber_getPixels__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - ofPixels *result = 0 ; SWIG_check_num_args("ofVideoGrabber::getPixels",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::getPixels",1,"ofVideoGrabber const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_getPixels",1,SWIGTYPE_p_ofVideoGrabber); } - result = (ofPixels *) &((ofVideoGrabber const *)arg1)->getPixels(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_VideoGrabber_getPixels(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVideoGrabber, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_VideoGrabber_getPixels__SWIG_0(L);} } if (argc == 1) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVideoGrabber, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_VideoGrabber_getPixels__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'VideoGrabber_getPixels'\n" - " Possible C/C++ prototypes are:\n" " ofVideoGrabber::getPixels()\n" " ofVideoGrabber::getPixels() const\n"); - lua_error(L);return 0; } -static int _wrap_VideoGrabber_getTexture__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - ofTexture *result = 0 ; SWIG_check_num_args("ofVideoGrabber::getTexture",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::getTexture",1,"ofVideoGrabber *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_getTexture",1,SWIGTYPE_p_ofVideoGrabber); } result = (ofTexture *) &(arg1)->getTexture(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTexture,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_VideoGrabber_getTexture__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - ofTexture *result = 0 ; SWIG_check_num_args("ofVideoGrabber::getTexture",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::getTexture",1,"ofVideoGrabber const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_getTexture",1,SWIGTYPE_p_ofVideoGrabber); } - result = (ofTexture *) &((ofVideoGrabber const *)arg1)->getTexture(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTexture,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_VideoGrabber_getTexture(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVideoGrabber, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_VideoGrabber_getTexture__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVideoGrabber, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_VideoGrabber_getTexture__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'VideoGrabber_getTexture'\n" - " Possible C/C++ prototypes are:\n" " ofVideoGrabber::getTexture()\n" " ofVideoGrabber::getTexture() const\n"); - lua_error(L);return 0; } -static int _wrap_VideoGrabber_getTexturePlanes__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; std::vector< ofTexture > *result = 0 ; - SWIG_check_num_args("ofVideoGrabber::getTexturePlanes",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::getTexturePlanes",1,"ofVideoGrabber *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_getTexturePlanes",1,SWIGTYPE_p_ofVideoGrabber); } - result = (std::vector< ofTexture > *) &(arg1)->getTexturePlanes(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofTexture_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_VideoGrabber_getTexturePlanes__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; std::vector< ofTexture > *result = 0 ; - SWIG_check_num_args("ofVideoGrabber::getTexturePlanes",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::getTexturePlanes",1,"ofVideoGrabber const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_getTexturePlanes",1,SWIGTYPE_p_ofVideoGrabber); } - result = (std::vector< ofTexture > *) &((ofVideoGrabber const *)arg1)->getTexturePlanes(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofTexture_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_VideoGrabber_getTexturePlanes(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); - if (argc == 1) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVideoGrabber, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_VideoGrabber_getTexturePlanes__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVideoGrabber, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_VideoGrabber_getTexturePlanes__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'VideoGrabber_getTexturePlanes'\n" - " Possible C/C++ prototypes are:\n" " ofVideoGrabber::getTexturePlanes()\n" - " ofVideoGrabber::getTexturePlanes() const\n"); lua_error(L);return 0; } -static int _wrap_VideoGrabber_setVerbose(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - bool arg2 ; SWIG_check_num_args("ofVideoGrabber::setVerbose",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::setVerbose",1,"ofVideoGrabber *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofVideoGrabber::setVerbose",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_setVerbose",1,SWIGTYPE_p_ofVideoGrabber); } arg2 = (lua_toboolean(L, 2)!=0); - (arg1)->setVerbose(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoGrabber_setDeviceID(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - int arg2 ; SWIG_check_num_args("ofVideoGrabber::setDeviceID",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::setDeviceID",1,"ofVideoGrabber *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVideoGrabber::setDeviceID",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_setDeviceID",1,SWIGTYPE_p_ofVideoGrabber); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->setDeviceID(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoGrabber_setDesiredFrameRate(lua_State* L) { int SWIG_arg = 0; - ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; int arg2 ; SWIG_check_num_args("ofVideoGrabber::setDesiredFrameRate",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::setDesiredFrameRate",1,"ofVideoGrabber *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVideoGrabber::setDesiredFrameRate",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_setDesiredFrameRate",1,SWIGTYPE_p_ofVideoGrabber); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->setDesiredFrameRate(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoGrabber_setUseTexture(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - bool arg2 ; SWIG_check_num_args("ofVideoGrabber::setUseTexture",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::setUseTexture",1,"ofVideoGrabber *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofVideoGrabber::setUseTexture",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_setUseTexture",1,SWIGTYPE_p_ofVideoGrabber); } arg2 = (lua_toboolean(L, 2)!=0); - (arg1)->setUseTexture(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoGrabber_isUsingTexture(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - bool result; SWIG_check_num_args("ofVideoGrabber::isUsingTexture",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::isUsingTexture",1,"ofVideoGrabber const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_isUsingTexture",1,SWIGTYPE_p_ofVideoGrabber); } - result = (bool)((ofVideoGrabber const *)arg1)->isUsingTexture(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoGrabber_draw__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - float arg2 ; float arg3 ; float arg4 ; float arg5 ; SWIG_check_num_args("ofVideoGrabber::draw",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::draw",1,"ofVideoGrabber const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVideoGrabber::draw",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVideoGrabber::draw",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVideoGrabber::draw",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofVideoGrabber::draw",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_draw",1,SWIGTYPE_p_ofVideoGrabber); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - ((ofVideoGrabber const *)arg1)->draw(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_VideoGrabber_draw__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - float arg2 ; float arg3 ; SWIG_check_num_args("ofVideoGrabber::draw",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::draw",1,"ofVideoGrabber const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVideoGrabber::draw",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVideoGrabber::draw",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_draw",1,SWIGTYPE_p_ofVideoGrabber); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); ((ofVideoGrabber const *)arg1)->draw(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_VideoGrabber_draw__SWIG_2_0(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - ofPoint *arg2 = 0 ; SWIG_check_num_args("draw",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("draw",1,"ofVideoGrabber const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("draw",2,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_draw",1,SWIGTYPE_p_ofVideoGrabber); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("VideoGrabber_draw",2,SWIGTYPE_p_ofVec3f); } ((ofVideoGrabber const *)arg1)->draw((ofPoint const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoGrabber_draw__SWIG_2_1(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - ofRectangle *arg2 = 0 ; SWIG_check_num_args("draw",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("draw",1,"ofVideoGrabber const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("draw",2,"ofRectangle const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_draw",1,SWIGTYPE_p_ofVideoGrabber); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("VideoGrabber_draw",2,SWIGTYPE_p_ofRectangle); } - ((ofVideoGrabber const *)arg1)->draw((ofRectangle const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_VideoGrabber_draw__SWIG_2_2(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - ofPoint *arg2 = 0 ; float arg3 ; float arg4 ; SWIG_check_num_args("draw",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("draw",1,"ofVideoGrabber const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("draw",2,"ofPoint const &"); if(!lua_isnumber(L,3)) SWIG_fail_arg("draw",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("draw",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_draw",1,SWIGTYPE_p_ofVideoGrabber); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("VideoGrabber_draw",2,SWIGTYPE_p_ofVec3f); } arg3 = (float)lua_tonumber(L, 3); - arg4 = (float)lua_tonumber(L, 4); ((ofVideoGrabber const *)arg1)->draw((ofPoint const &)*arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoGrabber_draw(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVideoGrabber, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_VideoGrabber_draw__SWIG_2_0(L);} } } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVideoGrabber, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_VideoGrabber_draw__SWIG_2_1(L);} } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVideoGrabber, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_VideoGrabber_draw__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVideoGrabber, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_VideoGrabber_draw__SWIG_2_2(L);} } } } } if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVideoGrabber, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_VideoGrabber_draw__SWIG_0(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'VideoGrabber_draw'\n" " Possible C/C++ prototypes are:\n" - " ofVideoGrabber::draw(float,float,float,float) const\n" " ofVideoGrabber::draw(float,float) const\n" - " draw(ofPoint const &) const\n" " draw(ofRectangle const &) const\n" " draw(ofPoint const &,float,float) const\n"); - lua_error(L);return 0; } -static int _wrap_VideoGrabber_bind(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - SWIG_check_num_args("ofVideoGrabber::bind",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::bind",1,"ofVideoGrabber const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_bind",1,SWIGTYPE_p_ofVideoGrabber); } ((ofVideoGrabber const *)arg1)->bind(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoGrabber_unbind(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - SWIG_check_num_args("ofVideoGrabber::unbind",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::unbind",1,"ofVideoGrabber const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_unbind",1,SWIGTYPE_p_ofVideoGrabber); } ((ofVideoGrabber const *)arg1)->unbind(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoGrabber_setAnchorPercent(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - float arg2 ; float arg3 ; SWIG_check_num_args("ofVideoGrabber::setAnchorPercent",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::setAnchorPercent",1,"ofVideoGrabber *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVideoGrabber::setAnchorPercent",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVideoGrabber::setAnchorPercent",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_setAnchorPercent",1,SWIGTYPE_p_ofVideoGrabber); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->setAnchorPercent(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_VideoGrabber_setAnchorPoint(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - float arg2 ; float arg3 ; SWIG_check_num_args("ofVideoGrabber::setAnchorPoint",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::setAnchorPoint",1,"ofVideoGrabber *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVideoGrabber::setAnchorPoint",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVideoGrabber::setAnchorPoint",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_setAnchorPoint",1,SWIGTYPE_p_ofVideoGrabber); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->setAnchorPoint(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_VideoGrabber_resetAnchor(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - SWIG_check_num_args("ofVideoGrabber::resetAnchor",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::resetAnchor",1,"ofVideoGrabber *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_resetAnchor",1,SWIGTYPE_p_ofVideoGrabber); } (arg1)->resetAnchor(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoGrabber_getHeight(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - float result; SWIG_check_num_args("ofVideoGrabber::getHeight",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::getHeight",1,"ofVideoGrabber const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_getHeight",1,SWIGTYPE_p_ofVideoGrabber); } - result = (float)((ofVideoGrabber const *)arg1)->getHeight(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoGrabber_getWidth(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - float result; SWIG_check_num_args("ofVideoGrabber::getWidth",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::getWidth",1,"ofVideoGrabber const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_getWidth",1,SWIGTYPE_p_ofVideoGrabber); } - result = (float)((ofVideoGrabber const *)arg1)->getWidth(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoGrabber_isInitialized(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - bool result; SWIG_check_num_args("ofVideoGrabber::isInitialized",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::isInitialized",1,"ofVideoGrabber const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_isInitialized",1,SWIGTYPE_p_ofVideoGrabber); } - result = (bool)((ofVideoGrabber const *)arg1)->isInitialized(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoGrabber_setGrabber(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - SwigValueWrapper< shared_ptr< ofBaseVideoGrabber > > arg2 ; shared_ptr< ofBaseVideoGrabber > *argp2 ; - SWIG_check_num_args("ofVideoGrabber::setGrabber",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::setGrabber",1,"ofVideoGrabber *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVideoGrabber::setGrabber",2,"shared_ptr< ofBaseVideoGrabber >"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_setGrabber",1,SWIGTYPE_p_ofVideoGrabber); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_shared_ptrT_ofBaseVideoGrabber_t,0))){ - SWIG_fail_ptr("VideoGrabber_setGrabber",2,SWIGTYPE_p_shared_ptrT_ofBaseVideoGrabber_t); } arg2 = *argp2; - (arg1)->setGrabber(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_VideoGrabber(void *obj) { -ofVideoGrabber *arg1 = (ofVideoGrabber *) obj; -delete arg1; -} -static int _proxy__wrap_new_VideoGrabber(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_VideoGrabber); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_VideoGrabber_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_VideoGrabber_methods[]= { - { "listDevices", _wrap_VideoGrabber_listDevices}, - { "isFrameNew", _wrap_VideoGrabber_isFrameNew}, - { "update", _wrap_VideoGrabber_update}, - { "close", _wrap_VideoGrabber_close}, - { "setup", _wrap_VideoGrabber_setup}, - { "setPixelFormat", _wrap_VideoGrabber_setPixelFormat}, - { "getPixelFormat", _wrap_VideoGrabber_getPixelFormat}, - { "videoSettings", _wrap_VideoGrabber_videoSettings}, - { "getPixels", _wrap_VideoGrabber_getPixels}, - { "getTexture", _wrap_VideoGrabber_getTexture}, - { "getTexturePlanes", _wrap_VideoGrabber_getTexturePlanes}, - { "setVerbose", _wrap_VideoGrabber_setVerbose}, - { "setDeviceID", _wrap_VideoGrabber_setDeviceID}, - { "setDesiredFrameRate", _wrap_VideoGrabber_setDesiredFrameRate}, - { "setUseTexture", _wrap_VideoGrabber_setUseTexture}, - { "isUsingTexture", _wrap_VideoGrabber_isUsingTexture}, - { "draw", _wrap_VideoGrabber_draw}, - { "bind", _wrap_VideoGrabber_bind}, - { "unbind", _wrap_VideoGrabber_unbind}, - { "setAnchorPercent", _wrap_VideoGrabber_setAnchorPercent}, - { "setAnchorPoint", _wrap_VideoGrabber_setAnchorPoint}, - { "resetAnchor", _wrap_VideoGrabber_resetAnchor}, - { "getHeight", _wrap_VideoGrabber_getHeight}, - { "getWidth", _wrap_VideoGrabber_getWidth}, - { "isInitialized", _wrap_VideoGrabber_isInitialized}, - { "setGrabber", _wrap_VideoGrabber_setGrabber}, - {0,0} -}; -static swig_lua_method swig_VideoGrabber_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_VideoGrabber_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_VideoGrabber_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_VideoGrabber_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_VideoGrabber_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_VideoGrabber_Sf_SwigStatic = { - "VideoGrabber", - swig_VideoGrabber_Sf_SwigStatic_methods, - swig_VideoGrabber_Sf_SwigStatic_attributes, - swig_VideoGrabber_Sf_SwigStatic_constants, - swig_VideoGrabber_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_VideoGrabber_bases[] = {0}; -static const char *swig_VideoGrabber_base_names[] = {0}; -static swig_lua_class _wrap_class_VideoGrabber = { "VideoGrabber", "VideoGrabber", &SWIGTYPE_p_ofVideoGrabber,_proxy__wrap_new_VideoGrabber, swig_delete_VideoGrabber, swig_VideoGrabber_methods, swig_VideoGrabber_attributes, &swig_VideoGrabber_Sf_SwigStatic, swig_VideoGrabber_meta, swig_VideoGrabber_bases, swig_VideoGrabber_base_names }; - -static int _wrap_new_VideoPlayer(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *result = 0 ; - SWIG_check_num_args("ofVideoPlayer::ofVideoPlayer",0,0) result = (ofVideoPlayer *)new ofVideoPlayer(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVideoPlayer,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_VideoPlayer_load(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - std::string arg2 ; bool result; SWIG_check_num_args("ofVideoPlayer::load",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::load",1,"ofVideoPlayer *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofVideoPlayer::load",2,"std::string"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_load",1,SWIGTYPE_p_ofVideoPlayer); } (&arg2)->assign(lua_tostring(L,2),lua_rawlen(L,2)); - result = (bool)(arg1)->load(arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_loadAsync(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - std::string arg2 ; SWIG_check_num_args("ofVideoPlayer::loadAsync",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::loadAsync",1,"ofVideoPlayer *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofVideoPlayer::loadAsync",2,"std::string"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_loadAsync",1,SWIGTYPE_p_ofVideoPlayer); } (&arg2)->assign(lua_tostring(L,2),lua_rawlen(L,2)); - (arg1)->loadAsync(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_getMoviePath(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - std::string result; SWIG_check_num_args("ofVideoPlayer::getMoviePath",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::getMoviePath",1,"ofVideoPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_getMoviePath",1,SWIGTYPE_p_ofVideoPlayer); } - result = ((ofVideoPlayer const *)arg1)->getMoviePath(); lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_setPixelFormat(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - ofPixelFormat arg2 ; bool result; SWIG_check_num_args("ofVideoPlayer::setPixelFormat",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::setPixelFormat",1,"ofVideoPlayer *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVideoPlayer::setPixelFormat",2,"ofPixelFormat"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_setPixelFormat",1,SWIGTYPE_p_ofVideoPlayer); } arg2 = (ofPixelFormat)(int)lua_tonumber(L, 2); - result = (bool)(arg1)->setPixelFormat(arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_getPixelFormat(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - ofPixelFormat result; SWIG_check_num_args("ofVideoPlayer::getPixelFormat",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::getPixelFormat",1,"ofVideoPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_getPixelFormat",1,SWIGTYPE_p_ofVideoPlayer); } - result = (ofPixelFormat)((ofVideoPlayer const *)arg1)->getPixelFormat(); - lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_VideoPlayer_closeMovie(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - SWIG_check_num_args("ofVideoPlayer::closeMovie",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::closeMovie",1,"ofVideoPlayer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_closeMovie",1,SWIGTYPE_p_ofVideoPlayer); } (arg1)->closeMovie(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_close(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - SWIG_check_num_args("ofVideoPlayer::close",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::close",1,"ofVideoPlayer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_close",1,SWIGTYPE_p_ofVideoPlayer); } (arg1)->close(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_update(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - SWIG_check_num_args("ofVideoPlayer::update",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::update",1,"ofVideoPlayer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_update",1,SWIGTYPE_p_ofVideoPlayer); } (arg1)->update(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_play(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - SWIG_check_num_args("ofVideoPlayer::play",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::play",1,"ofVideoPlayer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_play",1,SWIGTYPE_p_ofVideoPlayer); } (arg1)->play(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_stop(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - SWIG_check_num_args("ofVideoPlayer::stop",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::stop",1,"ofVideoPlayer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_stop",1,SWIGTYPE_p_ofVideoPlayer); } (arg1)->stop(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_isFrameNew(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - bool result; SWIG_check_num_args("ofVideoPlayer::isFrameNew",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::isFrameNew",1,"ofVideoPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_isFrameNew",1,SWIGTYPE_p_ofVideoPlayer); } - result = (bool)((ofVideoPlayer const *)arg1)->isFrameNew(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_getPixels__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - ofPixels *result = 0 ; SWIG_check_num_args("ofVideoPlayer::getPixels",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::getPixels",1,"ofVideoPlayer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_getPixels",1,SWIGTYPE_p_ofVideoPlayer); } result = (ofPixels *) &(arg1)->getPixels(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_getPixels__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - ofPixels *result = 0 ; SWIG_check_num_args("ofVideoPlayer::getPixels",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::getPixels",1,"ofVideoPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_getPixels",1,SWIGTYPE_p_ofVideoPlayer); } - result = (ofPixels *) &((ofVideoPlayer const *)arg1)->getPixels(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_getPixels(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVideoPlayer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_VideoPlayer_getPixels__SWIG_0(L);} } if (argc == 1) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVideoPlayer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_VideoPlayer_getPixels__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'VideoPlayer_getPixels'\n" - " Possible C/C++ prototypes are:\n" " ofVideoPlayer::getPixels()\n" " ofVideoPlayer::getPixels() const\n"); - lua_error(L);return 0; } -static int _wrap_VideoPlayer_getPosition(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - float result; SWIG_check_num_args("ofVideoPlayer::getPosition",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::getPosition",1,"ofVideoPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_getPosition",1,SWIGTYPE_p_ofVideoPlayer); } - result = (float)((ofVideoPlayer const *)arg1)->getPosition(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_getSpeed(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - float result; SWIG_check_num_args("ofVideoPlayer::getSpeed",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::getSpeed",1,"ofVideoPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_getSpeed",1,SWIGTYPE_p_ofVideoPlayer); } - result = (float)((ofVideoPlayer const *)arg1)->getSpeed(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_getDuration(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - float result; SWIG_check_num_args("ofVideoPlayer::getDuration",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::getDuration",1,"ofVideoPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_getDuration",1,SWIGTYPE_p_ofVideoPlayer); } - result = (float)((ofVideoPlayer const *)arg1)->getDuration(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_getIsMovieDone(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - bool result; SWIG_check_num_args("ofVideoPlayer::getIsMovieDone",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::getIsMovieDone",1,"ofVideoPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_getIsMovieDone",1,SWIGTYPE_p_ofVideoPlayer); } - result = (bool)((ofVideoPlayer const *)arg1)->getIsMovieDone(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_setPosition(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - float arg2 ; SWIG_check_num_args("ofVideoPlayer::setPosition",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::setPosition",1,"ofVideoPlayer *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVideoPlayer::setPosition",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_setPosition",1,SWIGTYPE_p_ofVideoPlayer); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setPosition(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_setVolume(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - float arg2 ; SWIG_check_num_args("ofVideoPlayer::setVolume",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::setVolume",1,"ofVideoPlayer *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVideoPlayer::setVolume",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_setVolume",1,SWIGTYPE_p_ofVideoPlayer); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setVolume(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_setLoopState(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - ofLoopType arg2 ; SWIG_check_num_args("ofVideoPlayer::setLoopState",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::setLoopState",1,"ofVideoPlayer *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVideoPlayer::setLoopState",2,"ofLoopType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_setLoopState",1,SWIGTYPE_p_ofVideoPlayer); } arg2 = (ofLoopType)(int)lua_tonumber(L, 2); - (arg1)->setLoopState(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_getLoopState(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - ofLoopType result; SWIG_check_num_args("ofVideoPlayer::getLoopState",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::getLoopState",1,"ofVideoPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_getLoopState",1,SWIGTYPE_p_ofVideoPlayer); } - result = (ofLoopType)((ofVideoPlayer const *)arg1)->getLoopState(); lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_setSpeed(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; float arg2 ; - SWIG_check_num_args("ofVideoPlayer::setSpeed",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::setSpeed",1,"ofVideoPlayer *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVideoPlayer::setSpeed",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_setSpeed",1,SWIGTYPE_p_ofVideoPlayer); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setSpeed(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_setFrame(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; int arg2 ; - SWIG_check_num_args("ofVideoPlayer::setFrame",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::setFrame",1,"ofVideoPlayer *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVideoPlayer::setFrame",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_setFrame",1,SWIGTYPE_p_ofVideoPlayer); } arg2 = (int)lua_tonumber(L, 2); (arg1)->setFrame(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_setUseTexture(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - bool arg2 ; SWIG_check_num_args("ofVideoPlayer::setUseTexture",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::setUseTexture",1,"ofVideoPlayer *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofVideoPlayer::setUseTexture",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_setUseTexture",1,SWIGTYPE_p_ofVideoPlayer); } arg2 = (lua_toboolean(L, 2)!=0); - (arg1)->setUseTexture(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_isUsingTexture(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - bool result; SWIG_check_num_args("ofVideoPlayer::isUsingTexture",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::isUsingTexture",1,"ofVideoPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_isUsingTexture",1,SWIGTYPE_p_ofVideoPlayer); } - result = (bool)((ofVideoPlayer const *)arg1)->isUsingTexture(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_getTexture__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - ofTexture *result = 0 ; SWIG_check_num_args("ofVideoPlayer::getTexture",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::getTexture",1,"ofVideoPlayer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_getTexture",1,SWIGTYPE_p_ofVideoPlayer); } result = (ofTexture *) &(arg1)->getTexture(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTexture,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_VideoPlayer_getTexture__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - ofTexture *result = 0 ; SWIG_check_num_args("ofVideoPlayer::getTexture",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::getTexture",1,"ofVideoPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_getTexture",1,SWIGTYPE_p_ofVideoPlayer); } - result = (ofTexture *) &((ofVideoPlayer const *)arg1)->getTexture(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTexture,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_VideoPlayer_getTexture(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVideoPlayer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_VideoPlayer_getTexture__SWIG_0(L);} } if (argc == 1) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVideoPlayer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_VideoPlayer_getTexture__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'VideoPlayer_getTexture'\n" - " Possible C/C++ prototypes are:\n" " ofVideoPlayer::getTexture()\n" " ofVideoPlayer::getTexture() const\n"); - lua_error(L);return 0; } -static int _wrap_VideoPlayer_getTexturePlanes__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; std::vector< ofTexture > *result = 0 ; - SWIG_check_num_args("ofVideoPlayer::getTexturePlanes",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::getTexturePlanes",1,"ofVideoPlayer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_getTexturePlanes",1,SWIGTYPE_p_ofVideoPlayer); } - result = (std::vector< ofTexture > *) &(arg1)->getTexturePlanes(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofTexture_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_getTexturePlanes__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; std::vector< ofTexture > *result = 0 ; - SWIG_check_num_args("ofVideoPlayer::getTexturePlanes",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::getTexturePlanes",1,"ofVideoPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_getTexturePlanes",1,SWIGTYPE_p_ofVideoPlayer); } - result = (std::vector< ofTexture > *) &((ofVideoPlayer const *)arg1)->getTexturePlanes(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofTexture_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_getTexturePlanes(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); - if (argc == 1) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVideoPlayer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_VideoPlayer_getTexturePlanes__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVideoPlayer, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_VideoPlayer_getTexturePlanes__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'VideoPlayer_getTexturePlanes'\n" - " Possible C/C++ prototypes are:\n" " ofVideoPlayer::getTexturePlanes()\n" - " ofVideoPlayer::getTexturePlanes() const\n"); lua_error(L);return 0; } -static int _wrap_VideoPlayer_draw__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - float arg2 ; float arg3 ; float arg4 ; float arg5 ; SWIG_check_num_args("ofVideoPlayer::draw",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::draw",1,"ofVideoPlayer const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVideoPlayer::draw",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVideoPlayer::draw",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVideoPlayer::draw",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofVideoPlayer::draw",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_draw",1,SWIGTYPE_p_ofVideoPlayer); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - ((ofVideoPlayer const *)arg1)->draw(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_VideoPlayer_draw__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - float arg2 ; float arg3 ; SWIG_check_num_args("ofVideoPlayer::draw",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::draw",1,"ofVideoPlayer const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVideoPlayer::draw",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVideoPlayer::draw",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_draw",1,SWIGTYPE_p_ofVideoPlayer); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); ((ofVideoPlayer const *)arg1)->draw(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_draw__SWIG_2_0(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - ofPoint *arg2 = 0 ; SWIG_check_num_args("draw",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("draw",1,"ofVideoPlayer const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("draw",2,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_draw",1,SWIGTYPE_p_ofVideoPlayer); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("VideoPlayer_draw",2,SWIGTYPE_p_ofVec3f); } ((ofVideoPlayer const *)arg1)->draw((ofPoint const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_draw__SWIG_2_1(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - ofRectangle *arg2 = 0 ; SWIG_check_num_args("draw",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("draw",1,"ofVideoPlayer const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("draw",2,"ofRectangle const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_draw",1,SWIGTYPE_p_ofVideoPlayer); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("VideoPlayer_draw",2,SWIGTYPE_p_ofRectangle); } - ((ofVideoPlayer const *)arg1)->draw((ofRectangle const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_VideoPlayer_draw__SWIG_2_2(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - ofPoint *arg2 = 0 ; float arg3 ; float arg4 ; SWIG_check_num_args("draw",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("draw",1,"ofVideoPlayer const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("draw",2,"ofPoint const &"); if(!lua_isnumber(L,3)) SWIG_fail_arg("draw",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("draw",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_draw",1,SWIGTYPE_p_ofVideoPlayer); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("VideoPlayer_draw",2,SWIGTYPE_p_ofVec3f); } arg3 = (float)lua_tonumber(L, 3); - arg4 = (float)lua_tonumber(L, 4); ((ofVideoPlayer const *)arg1)->draw((ofPoint const &)*arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_draw(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVideoPlayer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_VideoPlayer_draw__SWIG_2_0(L);} } } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVideoPlayer, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_VideoPlayer_draw__SWIG_2_1(L);} } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVideoPlayer, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_VideoPlayer_draw__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVideoPlayer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_VideoPlayer_draw__SWIG_2_2(L);} } } } } if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVideoPlayer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_VideoPlayer_draw__SWIG_0(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'VideoPlayer_draw'\n" " Possible C/C++ prototypes are:\n" - " ofVideoPlayer::draw(float,float,float,float) const\n" " ofVideoPlayer::draw(float,float) const\n" - " draw(ofPoint const &) const\n" " draw(ofRectangle const &) const\n" " draw(ofPoint const &,float,float) const\n"); - lua_error(L);return 0; } -static int _wrap_VideoPlayer_bind(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - SWIG_check_num_args("ofVideoPlayer::bind",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::bind",1,"ofVideoPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_bind",1,SWIGTYPE_p_ofVideoPlayer); } ((ofVideoPlayer const *)arg1)->bind(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_unbind(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - SWIG_check_num_args("ofVideoPlayer::unbind",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::unbind",1,"ofVideoPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_unbind",1,SWIGTYPE_p_ofVideoPlayer); } ((ofVideoPlayer const *)arg1)->unbind(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_setAnchorPercent(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - float arg2 ; float arg3 ; SWIG_check_num_args("ofVideoPlayer::setAnchorPercent",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::setAnchorPercent",1,"ofVideoPlayer *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVideoPlayer::setAnchorPercent",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVideoPlayer::setAnchorPercent",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_setAnchorPercent",1,SWIGTYPE_p_ofVideoPlayer); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->setAnchorPercent(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_VideoPlayer_setAnchorPoint(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - float arg2 ; float arg3 ; SWIG_check_num_args("ofVideoPlayer::setAnchorPoint",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::setAnchorPoint",1,"ofVideoPlayer *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVideoPlayer::setAnchorPoint",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVideoPlayer::setAnchorPoint",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_setAnchorPoint",1,SWIGTYPE_p_ofVideoPlayer); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->setAnchorPoint(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_VideoPlayer_resetAnchor(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - SWIG_check_num_args("ofVideoPlayer::resetAnchor",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::resetAnchor",1,"ofVideoPlayer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_resetAnchor",1,SWIGTYPE_p_ofVideoPlayer); } (arg1)->resetAnchor(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_setPaused(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; bool arg2 ; - SWIG_check_num_args("ofVideoPlayer::setPaused",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::setPaused",1,"ofVideoPlayer *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofVideoPlayer::setPaused",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_setPaused",1,SWIGTYPE_p_ofVideoPlayer); } arg2 = (lua_toboolean(L, 2)!=0); - (arg1)->setPaused(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_getCurrentFrame(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - int result; SWIG_check_num_args("ofVideoPlayer::getCurrentFrame",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::getCurrentFrame",1,"ofVideoPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_getCurrentFrame",1,SWIGTYPE_p_ofVideoPlayer); } - result = (int)((ofVideoPlayer const *)arg1)->getCurrentFrame(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_getTotalNumFrames(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - int result; SWIG_check_num_args("ofVideoPlayer::getTotalNumFrames",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::getTotalNumFrames",1,"ofVideoPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_getTotalNumFrames",1,SWIGTYPE_p_ofVideoPlayer); } - result = (int)((ofVideoPlayer const *)arg1)->getTotalNumFrames(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_firstFrame(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - SWIG_check_num_args("ofVideoPlayer::firstFrame",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::firstFrame",1,"ofVideoPlayer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_firstFrame",1,SWIGTYPE_p_ofVideoPlayer); } (arg1)->firstFrame(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_nextFrame(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - SWIG_check_num_args("ofVideoPlayer::nextFrame",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::nextFrame",1,"ofVideoPlayer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_nextFrame",1,SWIGTYPE_p_ofVideoPlayer); } (arg1)->nextFrame(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_previousFrame(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - SWIG_check_num_args("ofVideoPlayer::previousFrame",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::previousFrame",1,"ofVideoPlayer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_previousFrame",1,SWIGTYPE_p_ofVideoPlayer); } (arg1)->previousFrame(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_getHeight(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - float result; SWIG_check_num_args("ofVideoPlayer::getHeight",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::getHeight",1,"ofVideoPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_getHeight",1,SWIGTYPE_p_ofVideoPlayer); } - result = (float)((ofVideoPlayer const *)arg1)->getHeight(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_getWidth(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - float result; SWIG_check_num_args("ofVideoPlayer::getWidth",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::getWidth",1,"ofVideoPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_getWidth",1,SWIGTYPE_p_ofVideoPlayer); } - result = (float)((ofVideoPlayer const *)arg1)->getWidth(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_isPaused(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; bool result; - SWIG_check_num_args("ofVideoPlayer::isPaused",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::isPaused",1,"ofVideoPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_isPaused",1,SWIGTYPE_p_ofVideoPlayer); } - result = (bool)((ofVideoPlayer const *)arg1)->isPaused(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_isLoaded(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; bool result; - SWIG_check_num_args("ofVideoPlayer::isLoaded",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::isLoaded",1,"ofVideoPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_isLoaded",1,SWIGTYPE_p_ofVideoPlayer); } - result = (bool)((ofVideoPlayer const *)arg1)->isLoaded(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_isPlaying(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - bool result; SWIG_check_num_args("ofVideoPlayer::isPlaying",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::isPlaying",1,"ofVideoPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_isPlaying",1,SWIGTYPE_p_ofVideoPlayer); } - result = (bool)((ofVideoPlayer const *)arg1)->isPlaying(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_isInitialized(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - bool result; SWIG_check_num_args("ofVideoPlayer::isInitialized",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::isInitialized",1,"ofVideoPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_isInitialized",1,SWIGTYPE_p_ofVideoPlayer); } - result = (bool)((ofVideoPlayer const *)arg1)->isInitialized(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_VideoPlayer(void *obj) { -ofVideoPlayer *arg1 = (ofVideoPlayer *) obj; -delete arg1; -} -static int _proxy__wrap_new_VideoPlayer(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_VideoPlayer); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_VideoPlayer_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_VideoPlayer_methods[]= { - { "load", _wrap_VideoPlayer_load}, - { "loadAsync", _wrap_VideoPlayer_loadAsync}, - { "getMoviePath", _wrap_VideoPlayer_getMoviePath}, - { "setPixelFormat", _wrap_VideoPlayer_setPixelFormat}, - { "getPixelFormat", _wrap_VideoPlayer_getPixelFormat}, - { "closeMovie", _wrap_VideoPlayer_closeMovie}, - { "close", _wrap_VideoPlayer_close}, - { "update", _wrap_VideoPlayer_update}, - { "play", _wrap_VideoPlayer_play}, - { "stop", _wrap_VideoPlayer_stop}, - { "isFrameNew", _wrap_VideoPlayer_isFrameNew}, - { "getPixels", _wrap_VideoPlayer_getPixels}, - { "getPosition", _wrap_VideoPlayer_getPosition}, - { "getSpeed", _wrap_VideoPlayer_getSpeed}, - { "getDuration", _wrap_VideoPlayer_getDuration}, - { "getIsMovieDone", _wrap_VideoPlayer_getIsMovieDone}, - { "setPosition", _wrap_VideoPlayer_setPosition}, - { "setVolume", _wrap_VideoPlayer_setVolume}, - { "setLoopState", _wrap_VideoPlayer_setLoopState}, - { "getLoopState", _wrap_VideoPlayer_getLoopState}, - { "setSpeed", _wrap_VideoPlayer_setSpeed}, - { "setFrame", _wrap_VideoPlayer_setFrame}, - { "setUseTexture", _wrap_VideoPlayer_setUseTexture}, - { "isUsingTexture", _wrap_VideoPlayer_isUsingTexture}, - { "getTexture", _wrap_VideoPlayer_getTexture}, - { "getTexturePlanes", _wrap_VideoPlayer_getTexturePlanes}, - { "draw", _wrap_VideoPlayer_draw}, - { "bind", _wrap_VideoPlayer_bind}, - { "unbind", _wrap_VideoPlayer_unbind}, - { "setAnchorPercent", _wrap_VideoPlayer_setAnchorPercent}, - { "setAnchorPoint", _wrap_VideoPlayer_setAnchorPoint}, - { "resetAnchor", _wrap_VideoPlayer_resetAnchor}, - { "setPaused", _wrap_VideoPlayer_setPaused}, - { "getCurrentFrame", _wrap_VideoPlayer_getCurrentFrame}, - { "getTotalNumFrames", _wrap_VideoPlayer_getTotalNumFrames}, - { "firstFrame", _wrap_VideoPlayer_firstFrame}, - { "nextFrame", _wrap_VideoPlayer_nextFrame}, - { "previousFrame", _wrap_VideoPlayer_previousFrame}, - { "getHeight", _wrap_VideoPlayer_getHeight}, - { "getWidth", _wrap_VideoPlayer_getWidth}, - { "isPaused", _wrap_VideoPlayer_isPaused}, - { "isLoaded", _wrap_VideoPlayer_isLoaded}, - { "isPlaying", _wrap_VideoPlayer_isPlaying}, - { "isInitialized", _wrap_VideoPlayer_isInitialized}, - {0,0} -}; -static swig_lua_method swig_VideoPlayer_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_VideoPlayer_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_VideoPlayer_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_VideoPlayer_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_VideoPlayer_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_VideoPlayer_Sf_SwigStatic = { - "VideoPlayer", - swig_VideoPlayer_Sf_SwigStatic_methods, - swig_VideoPlayer_Sf_SwigStatic_attributes, - swig_VideoPlayer_Sf_SwigStatic_constants, - swig_VideoPlayer_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_VideoPlayer_bases[] = {0}; -static const char *swig_VideoPlayer_base_names[] = {0}; -static swig_lua_class _wrap_class_VideoPlayer = { "VideoPlayer", "VideoPlayer", &SWIGTYPE_p_ofVideoPlayer,_proxy__wrap_new_VideoPlayer, swig_delete_VideoPlayer, swig_VideoPlayer_methods, swig_VideoPlayer_attributes, &swig_VideoPlayer_Sf_SwigStatic, swig_VideoPlayer_meta, swig_VideoPlayer_bases, swig_VideoPlayer_base_names }; - -static swig_lua_attribute swig_SwigModule_attributes[] = { - { "TTF_SANS", _wrap_TTF_SANS_get, SWIG_Lua_set_immutable }, - { "TTF_SERIF", _wrap_TTF_SERIF_get, SWIG_Lua_set_immutable }, - { "TTF_MONO", _wrap_TTF_MONO_get, SWIG_Lua_set_immutable }, - { "Color_white", _wrap_Color_white_get, SWIG_Lua_set_immutable }, - { "Color_gray", _wrap_Color_gray_get, SWIG_Lua_set_immutable }, - { "Color_black", _wrap_Color_black_get, SWIG_Lua_set_immutable }, - { "Color_red", _wrap_Color_red_get, SWIG_Lua_set_immutable }, - { "Color_green", _wrap_Color_green_get, SWIG_Lua_set_immutable }, - { "Color_blue", _wrap_Color_blue_get, SWIG_Lua_set_immutable }, - { "Color_cyan", _wrap_Color_cyan_get, SWIG_Lua_set_immutable }, - { "Color_magenta", _wrap_Color_magenta_get, SWIG_Lua_set_immutable }, - { "Color_yellow", _wrap_Color_yellow_get, SWIG_Lua_set_immutable }, - { "Color_aliceBlue", _wrap_Color_aliceBlue_get, SWIG_Lua_set_immutable }, - { "Color_antiqueWhite", _wrap_Color_antiqueWhite_get, SWIG_Lua_set_immutable }, - { "Color_aqua", _wrap_Color_aqua_get, SWIG_Lua_set_immutable }, - { "Color_aquamarine", _wrap_Color_aquamarine_get, SWIG_Lua_set_immutable }, - { "Color_azure", _wrap_Color_azure_get, SWIG_Lua_set_immutable }, - { "Color_beige", _wrap_Color_beige_get, SWIG_Lua_set_immutable }, - { "Color_bisque", _wrap_Color_bisque_get, SWIG_Lua_set_immutable }, - { "Color_blanchedAlmond", _wrap_Color_blanchedAlmond_get, SWIG_Lua_set_immutable }, - { "Color_blueViolet", _wrap_Color_blueViolet_get, SWIG_Lua_set_immutable }, - { "Color_brown", _wrap_Color_brown_get, SWIG_Lua_set_immutable }, - { "Color_burlyWood", _wrap_Color_burlyWood_get, SWIG_Lua_set_immutable }, - { "Color_cadetBlue", _wrap_Color_cadetBlue_get, SWIG_Lua_set_immutable }, - { "Color_chartreuse", _wrap_Color_chartreuse_get, SWIG_Lua_set_immutable }, - { "Color_chocolate", _wrap_Color_chocolate_get, SWIG_Lua_set_immutable }, - { "Color_coral", _wrap_Color_coral_get, SWIG_Lua_set_immutable }, - { "Color_cornflowerBlue", _wrap_Color_cornflowerBlue_get, SWIG_Lua_set_immutable }, - { "Color_cornsilk", _wrap_Color_cornsilk_get, SWIG_Lua_set_immutable }, - { "Color_crimson", _wrap_Color_crimson_get, SWIG_Lua_set_immutable }, - { "Color_darkBlue", _wrap_Color_darkBlue_get, SWIG_Lua_set_immutable }, - { "Color_darkCyan", _wrap_Color_darkCyan_get, SWIG_Lua_set_immutable }, - { "Color_darkGoldenRod", _wrap_Color_darkGoldenRod_get, SWIG_Lua_set_immutable }, - { "Color_darkGray", _wrap_Color_darkGray_get, SWIG_Lua_set_immutable }, - { "Color_darkGrey", _wrap_Color_darkGrey_get, SWIG_Lua_set_immutable }, - { "Color_darkGreen", _wrap_Color_darkGreen_get, SWIG_Lua_set_immutable }, - { "Color_darkKhaki", _wrap_Color_darkKhaki_get, SWIG_Lua_set_immutable }, - { "Color_darkMagenta", _wrap_Color_darkMagenta_get, SWIG_Lua_set_immutable }, - { "Color_darkOliveGreen", _wrap_Color_darkOliveGreen_get, SWIG_Lua_set_immutable }, - { "Color_darkorange", _wrap_Color_darkorange_get, SWIG_Lua_set_immutable }, - { "Color_darkOrchid", _wrap_Color_darkOrchid_get, SWIG_Lua_set_immutable }, - { "Color_darkRed", _wrap_Color_darkRed_get, SWIG_Lua_set_immutable }, - { "Color_darkSalmon", _wrap_Color_darkSalmon_get, SWIG_Lua_set_immutable }, - { "Color_darkSeaGreen", _wrap_Color_darkSeaGreen_get, SWIG_Lua_set_immutable }, - { "Color_darkSlateBlue", _wrap_Color_darkSlateBlue_get, SWIG_Lua_set_immutable }, - { "Color_darkSlateGray", _wrap_Color_darkSlateGray_get, SWIG_Lua_set_immutable }, - { "Color_darkSlateGrey", _wrap_Color_darkSlateGrey_get, SWIG_Lua_set_immutable }, - { "Color_darkTurquoise", _wrap_Color_darkTurquoise_get, SWIG_Lua_set_immutable }, - { "Color_darkViolet", _wrap_Color_darkViolet_get, SWIG_Lua_set_immutable }, - { "Color_deepPink", _wrap_Color_deepPink_get, SWIG_Lua_set_immutable }, - { "Color_deepSkyBlue", _wrap_Color_deepSkyBlue_get, SWIG_Lua_set_immutable }, - { "Color_dimGray", _wrap_Color_dimGray_get, SWIG_Lua_set_immutable }, - { "Color_dimGrey", _wrap_Color_dimGrey_get, SWIG_Lua_set_immutable }, - { "Color_dodgerBlue", _wrap_Color_dodgerBlue_get, SWIG_Lua_set_immutable }, - { "Color_fireBrick", _wrap_Color_fireBrick_get, SWIG_Lua_set_immutable }, - { "Color_floralWhite", _wrap_Color_floralWhite_get, SWIG_Lua_set_immutable }, - { "Color_forestGreen", _wrap_Color_forestGreen_get, SWIG_Lua_set_immutable }, - { "Color_fuchsia", _wrap_Color_fuchsia_get, SWIG_Lua_set_immutable }, - { "Color_gainsboro", _wrap_Color_gainsboro_get, SWIG_Lua_set_immutable }, - { "Color_ghostWhite", _wrap_Color_ghostWhite_get, SWIG_Lua_set_immutable }, - { "Color_gold", _wrap_Color_gold_get, SWIG_Lua_set_immutable }, - { "Color_goldenRod", _wrap_Color_goldenRod_get, SWIG_Lua_set_immutable }, - { "Color_grey", _wrap_Color_grey_get, SWIG_Lua_set_immutable }, - { "Color_greenYellow", _wrap_Color_greenYellow_get, SWIG_Lua_set_immutable }, - { "Color_honeyDew", _wrap_Color_honeyDew_get, SWIG_Lua_set_immutable }, - { "Color_hotPink", _wrap_Color_hotPink_get, SWIG_Lua_set_immutable }, - { "Color_indianRed", _wrap_Color_indianRed_get, SWIG_Lua_set_immutable }, - { "Color_indigo", _wrap_Color_indigo_get, SWIG_Lua_set_immutable }, - { "Color_ivory", _wrap_Color_ivory_get, SWIG_Lua_set_immutable }, - { "Color_khaki", _wrap_Color_khaki_get, SWIG_Lua_set_immutable }, - { "Color_lavender", _wrap_Color_lavender_get, SWIG_Lua_set_immutable }, - { "Color_lavenderBlush", _wrap_Color_lavenderBlush_get, SWIG_Lua_set_immutable }, - { "Color_lawnGreen", _wrap_Color_lawnGreen_get, SWIG_Lua_set_immutable }, - { "Color_lemonChiffon", _wrap_Color_lemonChiffon_get, SWIG_Lua_set_immutable }, - { "Color_lightBlue", _wrap_Color_lightBlue_get, SWIG_Lua_set_immutable }, - { "Color_lightCoral", _wrap_Color_lightCoral_get, SWIG_Lua_set_immutable }, - { "Color_lightCyan", _wrap_Color_lightCyan_get, SWIG_Lua_set_immutable }, - { "Color_lightGoldenRodYellow", _wrap_Color_lightGoldenRodYellow_get, SWIG_Lua_set_immutable }, - { "Color_lightGray", _wrap_Color_lightGray_get, SWIG_Lua_set_immutable }, - { "Color_lightGrey", _wrap_Color_lightGrey_get, SWIG_Lua_set_immutable }, - { "Color_lightGreen", _wrap_Color_lightGreen_get, SWIG_Lua_set_immutable }, - { "Color_lightPink", _wrap_Color_lightPink_get, SWIG_Lua_set_immutable }, - { "Color_lightSalmon", _wrap_Color_lightSalmon_get, SWIG_Lua_set_immutable }, - { "Color_lightSeaGreen", _wrap_Color_lightSeaGreen_get, SWIG_Lua_set_immutable }, - { "Color_lightSkyBlue", _wrap_Color_lightSkyBlue_get, SWIG_Lua_set_immutable }, - { "Color_lightSlateGray", _wrap_Color_lightSlateGray_get, SWIG_Lua_set_immutable }, - { "Color_lightSlateGrey", _wrap_Color_lightSlateGrey_get, SWIG_Lua_set_immutable }, - { "Color_lightSteelBlue", _wrap_Color_lightSteelBlue_get, SWIG_Lua_set_immutable }, - { "Color_lightYellow", _wrap_Color_lightYellow_get, SWIG_Lua_set_immutable }, - { "Color_lime", _wrap_Color_lime_get, SWIG_Lua_set_immutable }, - { "Color_limeGreen", _wrap_Color_limeGreen_get, SWIG_Lua_set_immutable }, - { "Color_linen", _wrap_Color_linen_get, SWIG_Lua_set_immutable }, - { "Color_maroon", _wrap_Color_maroon_get, SWIG_Lua_set_immutable }, - { "Color_mediumAquaMarine", _wrap_Color_mediumAquaMarine_get, SWIG_Lua_set_immutable }, - { "Color_mediumBlue", _wrap_Color_mediumBlue_get, SWIG_Lua_set_immutable }, - { "Color_mediumOrchid", _wrap_Color_mediumOrchid_get, SWIG_Lua_set_immutable }, - { "Color_mediumPurple", _wrap_Color_mediumPurple_get, SWIG_Lua_set_immutable }, - { "Color_mediumSeaGreen", _wrap_Color_mediumSeaGreen_get, SWIG_Lua_set_immutable }, - { "Color_mediumSlateBlue", _wrap_Color_mediumSlateBlue_get, SWIG_Lua_set_immutable }, - { "Color_mediumSpringGreen", _wrap_Color_mediumSpringGreen_get, SWIG_Lua_set_immutable }, - { "Color_mediumTurquoise", _wrap_Color_mediumTurquoise_get, SWIG_Lua_set_immutable }, - { "Color_mediumVioletRed", _wrap_Color_mediumVioletRed_get, SWIG_Lua_set_immutable }, - { "Color_midnightBlue", _wrap_Color_midnightBlue_get, SWIG_Lua_set_immutable }, - { "Color_mintCream", _wrap_Color_mintCream_get, SWIG_Lua_set_immutable }, - { "Color_mistyRose", _wrap_Color_mistyRose_get, SWIG_Lua_set_immutable }, - { "Color_moccasin", _wrap_Color_moccasin_get, SWIG_Lua_set_immutable }, - { "Color_navajoWhite", _wrap_Color_navajoWhite_get, SWIG_Lua_set_immutable }, - { "Color_navy", _wrap_Color_navy_get, SWIG_Lua_set_immutable }, - { "Color_oldLace", _wrap_Color_oldLace_get, SWIG_Lua_set_immutable }, - { "Color_olive", _wrap_Color_olive_get, SWIG_Lua_set_immutable }, - { "Color_oliveDrab", _wrap_Color_oliveDrab_get, SWIG_Lua_set_immutable }, - { "Color_orange", _wrap_Color_orange_get, SWIG_Lua_set_immutable }, - { "Color_orangeRed", _wrap_Color_orangeRed_get, SWIG_Lua_set_immutable }, - { "Color_orchid", _wrap_Color_orchid_get, SWIG_Lua_set_immutable }, - { "Color_paleGoldenRod", _wrap_Color_paleGoldenRod_get, SWIG_Lua_set_immutable }, - { "Color_paleGreen", _wrap_Color_paleGreen_get, SWIG_Lua_set_immutable }, - { "Color_paleTurquoise", _wrap_Color_paleTurquoise_get, SWIG_Lua_set_immutable }, - { "Color_paleVioletRed", _wrap_Color_paleVioletRed_get, SWIG_Lua_set_immutable }, - { "Color_papayaWhip", _wrap_Color_papayaWhip_get, SWIG_Lua_set_immutable }, - { "Color_peachPuff", _wrap_Color_peachPuff_get, SWIG_Lua_set_immutable }, - { "Color_peru", _wrap_Color_peru_get, SWIG_Lua_set_immutable }, - { "Color_pink", _wrap_Color_pink_get, SWIG_Lua_set_immutable }, - { "Color_plum", _wrap_Color_plum_get, SWIG_Lua_set_immutable }, - { "Color_powderBlue", _wrap_Color_powderBlue_get, SWIG_Lua_set_immutable }, - { "Color_purple", _wrap_Color_purple_get, SWIG_Lua_set_immutable }, - { "Color_rosyBrown", _wrap_Color_rosyBrown_get, SWIG_Lua_set_immutable }, - { "Color_royalBlue", _wrap_Color_royalBlue_get, SWIG_Lua_set_immutable }, - { "Color_saddleBrown", _wrap_Color_saddleBrown_get, SWIG_Lua_set_immutable }, - { "Color_salmon", _wrap_Color_salmon_get, SWIG_Lua_set_immutable }, - { "Color_sandyBrown", _wrap_Color_sandyBrown_get, SWIG_Lua_set_immutable }, - { "Color_seaGreen", _wrap_Color_seaGreen_get, SWIG_Lua_set_immutable }, - { "Color_seaShell", _wrap_Color_seaShell_get, SWIG_Lua_set_immutable }, - { "Color_sienna", _wrap_Color_sienna_get, SWIG_Lua_set_immutable }, - { "Color_silver", _wrap_Color_silver_get, SWIG_Lua_set_immutable }, - { "Color_skyBlue", _wrap_Color_skyBlue_get, SWIG_Lua_set_immutable }, - { "Color_slateBlue", _wrap_Color_slateBlue_get, SWIG_Lua_set_immutable }, - { "Color_slateGray", _wrap_Color_slateGray_get, SWIG_Lua_set_immutable }, - { "Color_slateGrey", _wrap_Color_slateGrey_get, SWIG_Lua_set_immutable }, - { "Color_snow", _wrap_Color_snow_get, SWIG_Lua_set_immutable }, - { "Color_springGreen", _wrap_Color_springGreen_get, SWIG_Lua_set_immutable }, - { "Color_steelBlue", _wrap_Color_steelBlue_get, SWIG_Lua_set_immutable }, - { "Color_blueSteel", _wrap_Color_blueSteel_get, SWIG_Lua_set_immutable }, - { "Color_tan", _wrap_Color_tan_get, SWIG_Lua_set_immutable }, - { "Color_teal", _wrap_Color_teal_get, SWIG_Lua_set_immutable }, - { "Color_thistle", _wrap_Color_thistle_get, SWIG_Lua_set_immutable }, - { "Color_tomato", _wrap_Color_tomato_get, SWIG_Lua_set_immutable }, - { "Color_turquoise", _wrap_Color_turquoise_get, SWIG_Lua_set_immutable }, - { "Color_violet", _wrap_Color_violet_get, SWIG_Lua_set_immutable }, - { "Color_wheat", _wrap_Color_wheat_get, SWIG_Lua_set_immutable }, - { "Color_whiteSmoke", _wrap_Color_whiteSmoke_get, SWIG_Lua_set_immutable }, - { "Color_yellowGreen", _wrap_Color_yellowGreen_get, SWIG_Lua_set_immutable }, - { "FloatColor_white", _wrap_FloatColor_white_get, SWIG_Lua_set_immutable }, - { "FloatColor_gray", _wrap_FloatColor_gray_get, SWIG_Lua_set_immutable }, - { "FloatColor_black", _wrap_FloatColor_black_get, SWIG_Lua_set_immutable }, - { "FloatColor_red", _wrap_FloatColor_red_get, SWIG_Lua_set_immutable }, - { "FloatColor_green", _wrap_FloatColor_green_get, SWIG_Lua_set_immutable }, - { "FloatColor_blue", _wrap_FloatColor_blue_get, SWIG_Lua_set_immutable }, - { "FloatColor_cyan", _wrap_FloatColor_cyan_get, SWIG_Lua_set_immutable }, - { "FloatColor_magenta", _wrap_FloatColor_magenta_get, SWIG_Lua_set_immutable }, - { "FloatColor_yellow", _wrap_FloatColor_yellow_get, SWIG_Lua_set_immutable }, - { "FloatColor_aliceBlue", _wrap_FloatColor_aliceBlue_get, SWIG_Lua_set_immutable }, - { "FloatColor_antiqueWhite", _wrap_FloatColor_antiqueWhite_get, SWIG_Lua_set_immutable }, - { "FloatColor_aqua", _wrap_FloatColor_aqua_get, SWIG_Lua_set_immutable }, - { "FloatColor_aquamarine", _wrap_FloatColor_aquamarine_get, SWIG_Lua_set_immutable }, - { "FloatColor_azure", _wrap_FloatColor_azure_get, SWIG_Lua_set_immutable }, - { "FloatColor_beige", _wrap_FloatColor_beige_get, SWIG_Lua_set_immutable }, - { "FloatColor_bisque", _wrap_FloatColor_bisque_get, SWIG_Lua_set_immutable }, - { "FloatColor_blanchedAlmond", _wrap_FloatColor_blanchedAlmond_get, SWIG_Lua_set_immutable }, - { "FloatColor_blueViolet", _wrap_FloatColor_blueViolet_get, SWIG_Lua_set_immutable }, - { "FloatColor_brown", _wrap_FloatColor_brown_get, SWIG_Lua_set_immutable }, - { "FloatColor_burlyWood", _wrap_FloatColor_burlyWood_get, SWIG_Lua_set_immutable }, - { "FloatColor_cadetBlue", _wrap_FloatColor_cadetBlue_get, SWIG_Lua_set_immutable }, - { "FloatColor_chartreuse", _wrap_FloatColor_chartreuse_get, SWIG_Lua_set_immutable }, - { "FloatColor_chocolate", _wrap_FloatColor_chocolate_get, SWIG_Lua_set_immutable }, - { "FloatColor_coral", _wrap_FloatColor_coral_get, SWIG_Lua_set_immutable }, - { "FloatColor_cornflowerBlue", _wrap_FloatColor_cornflowerBlue_get, SWIG_Lua_set_immutable }, - { "FloatColor_cornsilk", _wrap_FloatColor_cornsilk_get, SWIG_Lua_set_immutable }, - { "FloatColor_crimson", _wrap_FloatColor_crimson_get, SWIG_Lua_set_immutable }, - { "FloatColor_darkBlue", _wrap_FloatColor_darkBlue_get, SWIG_Lua_set_immutable }, - { "FloatColor_darkCyan", _wrap_FloatColor_darkCyan_get, SWIG_Lua_set_immutable }, - { "FloatColor_darkGoldenRod", _wrap_FloatColor_darkGoldenRod_get, SWIG_Lua_set_immutable }, - { "FloatColor_darkGray", _wrap_FloatColor_darkGray_get, SWIG_Lua_set_immutable }, - { "FloatColor_darkGrey", _wrap_FloatColor_darkGrey_get, SWIG_Lua_set_immutable }, - { "FloatColor_darkGreen", _wrap_FloatColor_darkGreen_get, SWIG_Lua_set_immutable }, - { "FloatColor_darkKhaki", _wrap_FloatColor_darkKhaki_get, SWIG_Lua_set_immutable }, - { "FloatColor_darkMagenta", _wrap_FloatColor_darkMagenta_get, SWIG_Lua_set_immutable }, - { "FloatColor_darkOliveGreen", _wrap_FloatColor_darkOliveGreen_get, SWIG_Lua_set_immutable }, - { "FloatColor_darkorange", _wrap_FloatColor_darkorange_get, SWIG_Lua_set_immutable }, - { "FloatColor_darkOrchid", _wrap_FloatColor_darkOrchid_get, SWIG_Lua_set_immutable }, - { "FloatColor_darkRed", _wrap_FloatColor_darkRed_get, SWIG_Lua_set_immutable }, - { "FloatColor_darkSalmon", _wrap_FloatColor_darkSalmon_get, SWIG_Lua_set_immutable }, - { "FloatColor_darkSeaGreen", _wrap_FloatColor_darkSeaGreen_get, SWIG_Lua_set_immutable }, - { "FloatColor_darkSlateBlue", _wrap_FloatColor_darkSlateBlue_get, SWIG_Lua_set_immutable }, - { "FloatColor_darkSlateGray", _wrap_FloatColor_darkSlateGray_get, SWIG_Lua_set_immutable }, - { "FloatColor_darkSlateGrey", _wrap_FloatColor_darkSlateGrey_get, SWIG_Lua_set_immutable }, - { "FloatColor_darkTurquoise", _wrap_FloatColor_darkTurquoise_get, SWIG_Lua_set_immutable }, - { "FloatColor_darkViolet", _wrap_FloatColor_darkViolet_get, SWIG_Lua_set_immutable }, - { "FloatColor_deepPink", _wrap_FloatColor_deepPink_get, SWIG_Lua_set_immutable }, - { "FloatColor_deepSkyBlue", _wrap_FloatColor_deepSkyBlue_get, SWIG_Lua_set_immutable }, - { "FloatColor_dimGray", _wrap_FloatColor_dimGray_get, SWIG_Lua_set_immutable }, - { "FloatColor_dimGrey", _wrap_FloatColor_dimGrey_get, SWIG_Lua_set_immutable }, - { "FloatColor_dodgerBlue", _wrap_FloatColor_dodgerBlue_get, SWIG_Lua_set_immutable }, - { "FloatColor_fireBrick", _wrap_FloatColor_fireBrick_get, SWIG_Lua_set_immutable }, - { "FloatColor_floralWhite", _wrap_FloatColor_floralWhite_get, SWIG_Lua_set_immutable }, - { "FloatColor_forestGreen", _wrap_FloatColor_forestGreen_get, SWIG_Lua_set_immutable }, - { "FloatColor_fuchsia", _wrap_FloatColor_fuchsia_get, SWIG_Lua_set_immutable }, - { "FloatColor_gainsboro", _wrap_FloatColor_gainsboro_get, SWIG_Lua_set_immutable }, - { "FloatColor_ghostWhite", _wrap_FloatColor_ghostWhite_get, SWIG_Lua_set_immutable }, - { "FloatColor_gold", _wrap_FloatColor_gold_get, SWIG_Lua_set_immutable }, - { "FloatColor_goldenRod", _wrap_FloatColor_goldenRod_get, SWIG_Lua_set_immutable }, - { "FloatColor_grey", _wrap_FloatColor_grey_get, SWIG_Lua_set_immutable }, - { "FloatColor_greenYellow", _wrap_FloatColor_greenYellow_get, SWIG_Lua_set_immutable }, - { "FloatColor_honeyDew", _wrap_FloatColor_honeyDew_get, SWIG_Lua_set_immutable }, - { "FloatColor_hotPink", _wrap_FloatColor_hotPink_get, SWIG_Lua_set_immutable }, - { "FloatColor_indianRed", _wrap_FloatColor_indianRed_get, SWIG_Lua_set_immutable }, - { "FloatColor_indigo", _wrap_FloatColor_indigo_get, SWIG_Lua_set_immutable }, - { "FloatColor_ivory", _wrap_FloatColor_ivory_get, SWIG_Lua_set_immutable }, - { "FloatColor_khaki", _wrap_FloatColor_khaki_get, SWIG_Lua_set_immutable }, - { "FloatColor_lavender", _wrap_FloatColor_lavender_get, SWIG_Lua_set_immutable }, - { "FloatColor_lavenderBlush", _wrap_FloatColor_lavenderBlush_get, SWIG_Lua_set_immutable }, - { "FloatColor_lawnGreen", _wrap_FloatColor_lawnGreen_get, SWIG_Lua_set_immutable }, - { "FloatColor_lemonChiffon", _wrap_FloatColor_lemonChiffon_get, SWIG_Lua_set_immutable }, - { "FloatColor_lightBlue", _wrap_FloatColor_lightBlue_get, SWIG_Lua_set_immutable }, - { "FloatColor_lightCoral", _wrap_FloatColor_lightCoral_get, SWIG_Lua_set_immutable }, - { "FloatColor_lightCyan", _wrap_FloatColor_lightCyan_get, SWIG_Lua_set_immutable }, - { "FloatColor_lightGoldenRodYellow", _wrap_FloatColor_lightGoldenRodYellow_get, SWIG_Lua_set_immutable }, - { "FloatColor_lightGray", _wrap_FloatColor_lightGray_get, SWIG_Lua_set_immutable }, - { "FloatColor_lightGrey", _wrap_FloatColor_lightGrey_get, SWIG_Lua_set_immutable }, - { "FloatColor_lightGreen", _wrap_FloatColor_lightGreen_get, SWIG_Lua_set_immutable }, - { "FloatColor_lightPink", _wrap_FloatColor_lightPink_get, SWIG_Lua_set_immutable }, - { "FloatColor_lightSalmon", _wrap_FloatColor_lightSalmon_get, SWIG_Lua_set_immutable }, - { "FloatColor_lightSeaGreen", _wrap_FloatColor_lightSeaGreen_get, SWIG_Lua_set_immutable }, - { "FloatColor_lightSkyBlue", _wrap_FloatColor_lightSkyBlue_get, SWIG_Lua_set_immutable }, - { "FloatColor_lightSlateGray", _wrap_FloatColor_lightSlateGray_get, SWIG_Lua_set_immutable }, - { "FloatColor_lightSlateGrey", _wrap_FloatColor_lightSlateGrey_get, SWIG_Lua_set_immutable }, - { "FloatColor_lightSteelBlue", _wrap_FloatColor_lightSteelBlue_get, SWIG_Lua_set_immutable }, - { "FloatColor_lightYellow", _wrap_FloatColor_lightYellow_get, SWIG_Lua_set_immutable }, - { "FloatColor_lime", _wrap_FloatColor_lime_get, SWIG_Lua_set_immutable }, - { "FloatColor_limeGreen", _wrap_FloatColor_limeGreen_get, SWIG_Lua_set_immutable }, - { "FloatColor_linen", _wrap_FloatColor_linen_get, SWIG_Lua_set_immutable }, - { "FloatColor_maroon", _wrap_FloatColor_maroon_get, SWIG_Lua_set_immutable }, - { "FloatColor_mediumAquaMarine", _wrap_FloatColor_mediumAquaMarine_get, SWIG_Lua_set_immutable }, - { "FloatColor_mediumBlue", _wrap_FloatColor_mediumBlue_get, SWIG_Lua_set_immutable }, - { "FloatColor_mediumOrchid", _wrap_FloatColor_mediumOrchid_get, SWIG_Lua_set_immutable }, - { "FloatColor_mediumPurple", _wrap_FloatColor_mediumPurple_get, SWIG_Lua_set_immutable }, - { "FloatColor_mediumSeaGreen", _wrap_FloatColor_mediumSeaGreen_get, SWIG_Lua_set_immutable }, - { "FloatColor_mediumSlateBlue", _wrap_FloatColor_mediumSlateBlue_get, SWIG_Lua_set_immutable }, - { "FloatColor_mediumSpringGreen", _wrap_FloatColor_mediumSpringGreen_get, SWIG_Lua_set_immutable }, - { "FloatColor_mediumTurquoise", _wrap_FloatColor_mediumTurquoise_get, SWIG_Lua_set_immutable }, - { "FloatColor_mediumVioletRed", _wrap_FloatColor_mediumVioletRed_get, SWIG_Lua_set_immutable }, - { "FloatColor_midnightBlue", _wrap_FloatColor_midnightBlue_get, SWIG_Lua_set_immutable }, - { "FloatColor_mintCream", _wrap_FloatColor_mintCream_get, SWIG_Lua_set_immutable }, - { "FloatColor_mistyRose", _wrap_FloatColor_mistyRose_get, SWIG_Lua_set_immutable }, - { "FloatColor_moccasin", _wrap_FloatColor_moccasin_get, SWIG_Lua_set_immutable }, - { "FloatColor_navajoWhite", _wrap_FloatColor_navajoWhite_get, SWIG_Lua_set_immutable }, - { "FloatColor_navy", _wrap_FloatColor_navy_get, SWIG_Lua_set_immutable }, - { "FloatColor_oldLace", _wrap_FloatColor_oldLace_get, SWIG_Lua_set_immutable }, - { "FloatColor_olive", _wrap_FloatColor_olive_get, SWIG_Lua_set_immutable }, - { "FloatColor_oliveDrab", _wrap_FloatColor_oliveDrab_get, SWIG_Lua_set_immutable }, - { "FloatColor_orange", _wrap_FloatColor_orange_get, SWIG_Lua_set_immutable }, - { "FloatColor_orangeRed", _wrap_FloatColor_orangeRed_get, SWIG_Lua_set_immutable }, - { "FloatColor_orchid", _wrap_FloatColor_orchid_get, SWIG_Lua_set_immutable }, - { "FloatColor_paleGoldenRod", _wrap_FloatColor_paleGoldenRod_get, SWIG_Lua_set_immutable }, - { "FloatColor_paleGreen", _wrap_FloatColor_paleGreen_get, SWIG_Lua_set_immutable }, - { "FloatColor_paleTurquoise", _wrap_FloatColor_paleTurquoise_get, SWIG_Lua_set_immutable }, - { "FloatColor_paleVioletRed", _wrap_FloatColor_paleVioletRed_get, SWIG_Lua_set_immutable }, - { "FloatColor_papayaWhip", _wrap_FloatColor_papayaWhip_get, SWIG_Lua_set_immutable }, - { "FloatColor_peachPuff", _wrap_FloatColor_peachPuff_get, SWIG_Lua_set_immutable }, - { "FloatColor_peru", _wrap_FloatColor_peru_get, SWIG_Lua_set_immutable }, - { "FloatColor_pink", _wrap_FloatColor_pink_get, SWIG_Lua_set_immutable }, - { "FloatColor_plum", _wrap_FloatColor_plum_get, SWIG_Lua_set_immutable }, - { "FloatColor_powderBlue", _wrap_FloatColor_powderBlue_get, SWIG_Lua_set_immutable }, - { "FloatColor_purple", _wrap_FloatColor_purple_get, SWIG_Lua_set_immutable }, - { "FloatColor_rosyBrown", _wrap_FloatColor_rosyBrown_get, SWIG_Lua_set_immutable }, - { "FloatColor_royalBlue", _wrap_FloatColor_royalBlue_get, SWIG_Lua_set_immutable }, - { "FloatColor_saddleBrown", _wrap_FloatColor_saddleBrown_get, SWIG_Lua_set_immutable }, - { "FloatColor_salmon", _wrap_FloatColor_salmon_get, SWIG_Lua_set_immutable }, - { "FloatColor_sandyBrown", _wrap_FloatColor_sandyBrown_get, SWIG_Lua_set_immutable }, - { "FloatColor_seaGreen", _wrap_FloatColor_seaGreen_get, SWIG_Lua_set_immutable }, - { "FloatColor_seaShell", _wrap_FloatColor_seaShell_get, SWIG_Lua_set_immutable }, - { "FloatColor_sienna", _wrap_FloatColor_sienna_get, SWIG_Lua_set_immutable }, - { "FloatColor_silver", _wrap_FloatColor_silver_get, SWIG_Lua_set_immutable }, - { "FloatColor_skyBlue", _wrap_FloatColor_skyBlue_get, SWIG_Lua_set_immutable }, - { "FloatColor_slateBlue", _wrap_FloatColor_slateBlue_get, SWIG_Lua_set_immutable }, - { "FloatColor_slateGray", _wrap_FloatColor_slateGray_get, SWIG_Lua_set_immutable }, - { "FloatColor_slateGrey", _wrap_FloatColor_slateGrey_get, SWIG_Lua_set_immutable }, - { "FloatColor_snow", _wrap_FloatColor_snow_get, SWIG_Lua_set_immutable }, - { "FloatColor_springGreen", _wrap_FloatColor_springGreen_get, SWIG_Lua_set_immutable }, - { "FloatColor_steelBlue", _wrap_FloatColor_steelBlue_get, SWIG_Lua_set_immutable }, - { "FloatColor_blueSteel", _wrap_FloatColor_blueSteel_get, SWIG_Lua_set_immutable }, - { "FloatColor_tan", _wrap_FloatColor_tan_get, SWIG_Lua_set_immutable }, - { "FloatColor_teal", _wrap_FloatColor_teal_get, SWIG_Lua_set_immutable }, - { "FloatColor_thistle", _wrap_FloatColor_thistle_get, SWIG_Lua_set_immutable }, - { "FloatColor_tomato", _wrap_FloatColor_tomato_get, SWIG_Lua_set_immutable }, - { "FloatColor_turquoise", _wrap_FloatColor_turquoise_get, SWIG_Lua_set_immutable }, - { "FloatColor_violet", _wrap_FloatColor_violet_get, SWIG_Lua_set_immutable }, - { "FloatColor_wheat", _wrap_FloatColor_wheat_get, SWIG_Lua_set_immutable }, - { "FloatColor_whiteSmoke", _wrap_FloatColor_whiteSmoke_get, SWIG_Lua_set_immutable }, - { "FloatColor_yellowGreen", _wrap_FloatColor_yellowGreen_get, SWIG_Lua_set_immutable }, - { "ShortColor_white", _wrap_ShortColor_white_get, SWIG_Lua_set_immutable }, - { "ShortColor_gray", _wrap_ShortColor_gray_get, SWIG_Lua_set_immutable }, - { "ShortColor_black", _wrap_ShortColor_black_get, SWIG_Lua_set_immutable }, - { "ShortColor_red", _wrap_ShortColor_red_get, SWIG_Lua_set_immutable }, - { "ShortColor_green", _wrap_ShortColor_green_get, SWIG_Lua_set_immutable }, - { "ShortColor_blue", _wrap_ShortColor_blue_get, SWIG_Lua_set_immutable }, - { "ShortColor_cyan", _wrap_ShortColor_cyan_get, SWIG_Lua_set_immutable }, - { "ShortColor_magenta", _wrap_ShortColor_magenta_get, SWIG_Lua_set_immutable }, - { "ShortColor_yellow", _wrap_ShortColor_yellow_get, SWIG_Lua_set_immutable }, - { "ShortColor_aliceBlue", _wrap_ShortColor_aliceBlue_get, SWIG_Lua_set_immutable }, - { "ShortColor_antiqueWhite", _wrap_ShortColor_antiqueWhite_get, SWIG_Lua_set_immutable }, - { "ShortColor_aqua", _wrap_ShortColor_aqua_get, SWIG_Lua_set_immutable }, - { "ShortColor_aquamarine", _wrap_ShortColor_aquamarine_get, SWIG_Lua_set_immutable }, - { "ShortColor_azure", _wrap_ShortColor_azure_get, SWIG_Lua_set_immutable }, - { "ShortColor_beige", _wrap_ShortColor_beige_get, SWIG_Lua_set_immutable }, - { "ShortColor_bisque", _wrap_ShortColor_bisque_get, SWIG_Lua_set_immutable }, - { "ShortColor_blanchedAlmond", _wrap_ShortColor_blanchedAlmond_get, SWIG_Lua_set_immutable }, - { "ShortColor_blueViolet", _wrap_ShortColor_blueViolet_get, SWIG_Lua_set_immutable }, - { "ShortColor_brown", _wrap_ShortColor_brown_get, SWIG_Lua_set_immutable }, - { "ShortColor_burlyWood", _wrap_ShortColor_burlyWood_get, SWIG_Lua_set_immutable }, - { "ShortColor_cadetBlue", _wrap_ShortColor_cadetBlue_get, SWIG_Lua_set_immutable }, - { "ShortColor_chartreuse", _wrap_ShortColor_chartreuse_get, SWIG_Lua_set_immutable }, - { "ShortColor_chocolate", _wrap_ShortColor_chocolate_get, SWIG_Lua_set_immutable }, - { "ShortColor_coral", _wrap_ShortColor_coral_get, SWIG_Lua_set_immutable }, - { "ShortColor_cornflowerBlue", _wrap_ShortColor_cornflowerBlue_get, SWIG_Lua_set_immutable }, - { "ShortColor_cornsilk", _wrap_ShortColor_cornsilk_get, SWIG_Lua_set_immutable }, - { "ShortColor_crimson", _wrap_ShortColor_crimson_get, SWIG_Lua_set_immutable }, - { "ShortColor_darkBlue", _wrap_ShortColor_darkBlue_get, SWIG_Lua_set_immutable }, - { "ShortColor_darkCyan", _wrap_ShortColor_darkCyan_get, SWIG_Lua_set_immutable }, - { "ShortColor_darkGoldenRod", _wrap_ShortColor_darkGoldenRod_get, SWIG_Lua_set_immutable }, - { "ShortColor_darkGray", _wrap_ShortColor_darkGray_get, SWIG_Lua_set_immutable }, - { "ShortColor_darkGrey", _wrap_ShortColor_darkGrey_get, SWIG_Lua_set_immutable }, - { "ShortColor_darkGreen", _wrap_ShortColor_darkGreen_get, SWIG_Lua_set_immutable }, - { "ShortColor_darkKhaki", _wrap_ShortColor_darkKhaki_get, SWIG_Lua_set_immutable }, - { "ShortColor_darkMagenta", _wrap_ShortColor_darkMagenta_get, SWIG_Lua_set_immutable }, - { "ShortColor_darkOliveGreen", _wrap_ShortColor_darkOliveGreen_get, SWIG_Lua_set_immutable }, - { "ShortColor_darkorange", _wrap_ShortColor_darkorange_get, SWIG_Lua_set_immutable }, - { "ShortColor_darkOrchid", _wrap_ShortColor_darkOrchid_get, SWIG_Lua_set_immutable }, - { "ShortColor_darkRed", _wrap_ShortColor_darkRed_get, SWIG_Lua_set_immutable }, - { "ShortColor_darkSalmon", _wrap_ShortColor_darkSalmon_get, SWIG_Lua_set_immutable }, - { "ShortColor_darkSeaGreen", _wrap_ShortColor_darkSeaGreen_get, SWIG_Lua_set_immutable }, - { "ShortColor_darkSlateBlue", _wrap_ShortColor_darkSlateBlue_get, SWIG_Lua_set_immutable }, - { "ShortColor_darkSlateGray", _wrap_ShortColor_darkSlateGray_get, SWIG_Lua_set_immutable }, - { "ShortColor_darkSlateGrey", _wrap_ShortColor_darkSlateGrey_get, SWIG_Lua_set_immutable }, - { "ShortColor_darkTurquoise", _wrap_ShortColor_darkTurquoise_get, SWIG_Lua_set_immutable }, - { "ShortColor_darkViolet", _wrap_ShortColor_darkViolet_get, SWIG_Lua_set_immutable }, - { "ShortColor_deepPink", _wrap_ShortColor_deepPink_get, SWIG_Lua_set_immutable }, - { "ShortColor_deepSkyBlue", _wrap_ShortColor_deepSkyBlue_get, SWIG_Lua_set_immutable }, - { "ShortColor_dimGray", _wrap_ShortColor_dimGray_get, SWIG_Lua_set_immutable }, - { "ShortColor_dimGrey", _wrap_ShortColor_dimGrey_get, SWIG_Lua_set_immutable }, - { "ShortColor_dodgerBlue", _wrap_ShortColor_dodgerBlue_get, SWIG_Lua_set_immutable }, - { "ShortColor_fireBrick", _wrap_ShortColor_fireBrick_get, SWIG_Lua_set_immutable }, - { "ShortColor_floralWhite", _wrap_ShortColor_floralWhite_get, SWIG_Lua_set_immutable }, - { "ShortColor_forestGreen", _wrap_ShortColor_forestGreen_get, SWIG_Lua_set_immutable }, - { "ShortColor_fuchsia", _wrap_ShortColor_fuchsia_get, SWIG_Lua_set_immutable }, - { "ShortColor_gainsboro", _wrap_ShortColor_gainsboro_get, SWIG_Lua_set_immutable }, - { "ShortColor_ghostWhite", _wrap_ShortColor_ghostWhite_get, SWIG_Lua_set_immutable }, - { "ShortColor_gold", _wrap_ShortColor_gold_get, SWIG_Lua_set_immutable }, - { "ShortColor_goldenRod", _wrap_ShortColor_goldenRod_get, SWIG_Lua_set_immutable }, - { "ShortColor_grey", _wrap_ShortColor_grey_get, SWIG_Lua_set_immutable }, - { "ShortColor_greenYellow", _wrap_ShortColor_greenYellow_get, SWIG_Lua_set_immutable }, - { "ShortColor_honeyDew", _wrap_ShortColor_honeyDew_get, SWIG_Lua_set_immutable }, - { "ShortColor_hotPink", _wrap_ShortColor_hotPink_get, SWIG_Lua_set_immutable }, - { "ShortColor_indianRed", _wrap_ShortColor_indianRed_get, SWIG_Lua_set_immutable }, - { "ShortColor_indigo", _wrap_ShortColor_indigo_get, SWIG_Lua_set_immutable }, - { "ShortColor_ivory", _wrap_ShortColor_ivory_get, SWIG_Lua_set_immutable }, - { "ShortColor_khaki", _wrap_ShortColor_khaki_get, SWIG_Lua_set_immutable }, - { "ShortColor_lavender", _wrap_ShortColor_lavender_get, SWIG_Lua_set_immutable }, - { "ShortColor_lavenderBlush", _wrap_ShortColor_lavenderBlush_get, SWIG_Lua_set_immutable }, - { "ShortColor_lawnGreen", _wrap_ShortColor_lawnGreen_get, SWIG_Lua_set_immutable }, - { "ShortColor_lemonChiffon", _wrap_ShortColor_lemonChiffon_get, SWIG_Lua_set_immutable }, - { "ShortColor_lightBlue", _wrap_ShortColor_lightBlue_get, SWIG_Lua_set_immutable }, - { "ShortColor_lightCoral", _wrap_ShortColor_lightCoral_get, SWIG_Lua_set_immutable }, - { "ShortColor_lightCyan", _wrap_ShortColor_lightCyan_get, SWIG_Lua_set_immutable }, - { "ShortColor_lightGoldenRodYellow", _wrap_ShortColor_lightGoldenRodYellow_get, SWIG_Lua_set_immutable }, - { "ShortColor_lightGray", _wrap_ShortColor_lightGray_get, SWIG_Lua_set_immutable }, - { "ShortColor_lightGrey", _wrap_ShortColor_lightGrey_get, SWIG_Lua_set_immutable }, - { "ShortColor_lightGreen", _wrap_ShortColor_lightGreen_get, SWIG_Lua_set_immutable }, - { "ShortColor_lightPink", _wrap_ShortColor_lightPink_get, SWIG_Lua_set_immutable }, - { "ShortColor_lightSalmon", _wrap_ShortColor_lightSalmon_get, SWIG_Lua_set_immutable }, - { "ShortColor_lightSeaGreen", _wrap_ShortColor_lightSeaGreen_get, SWIG_Lua_set_immutable }, - { "ShortColor_lightSkyBlue", _wrap_ShortColor_lightSkyBlue_get, SWIG_Lua_set_immutable }, - { "ShortColor_lightSlateGray", _wrap_ShortColor_lightSlateGray_get, SWIG_Lua_set_immutable }, - { "ShortColor_lightSlateGrey", _wrap_ShortColor_lightSlateGrey_get, SWIG_Lua_set_immutable }, - { "ShortColor_lightSteelBlue", _wrap_ShortColor_lightSteelBlue_get, SWIG_Lua_set_immutable }, - { "ShortColor_lightYellow", _wrap_ShortColor_lightYellow_get, SWIG_Lua_set_immutable }, - { "ShortColor_lime", _wrap_ShortColor_lime_get, SWIG_Lua_set_immutable }, - { "ShortColor_limeGreen", _wrap_ShortColor_limeGreen_get, SWIG_Lua_set_immutable }, - { "ShortColor_linen", _wrap_ShortColor_linen_get, SWIG_Lua_set_immutable }, - { "ShortColor_maroon", _wrap_ShortColor_maroon_get, SWIG_Lua_set_immutable }, - { "ShortColor_mediumAquaMarine", _wrap_ShortColor_mediumAquaMarine_get, SWIG_Lua_set_immutable }, - { "ShortColor_mediumBlue", _wrap_ShortColor_mediumBlue_get, SWIG_Lua_set_immutable }, - { "ShortColor_mediumOrchid", _wrap_ShortColor_mediumOrchid_get, SWIG_Lua_set_immutable }, - { "ShortColor_mediumPurple", _wrap_ShortColor_mediumPurple_get, SWIG_Lua_set_immutable }, - { "ShortColor_mediumSeaGreen", _wrap_ShortColor_mediumSeaGreen_get, SWIG_Lua_set_immutable }, - { "ShortColor_mediumSlateBlue", _wrap_ShortColor_mediumSlateBlue_get, SWIG_Lua_set_immutable }, - { "ShortColor_mediumSpringGreen", _wrap_ShortColor_mediumSpringGreen_get, SWIG_Lua_set_immutable }, - { "ShortColor_mediumTurquoise", _wrap_ShortColor_mediumTurquoise_get, SWIG_Lua_set_immutable }, - { "ShortColor_mediumVioletRed", _wrap_ShortColor_mediumVioletRed_get, SWIG_Lua_set_immutable }, - { "ShortColor_midnightBlue", _wrap_ShortColor_midnightBlue_get, SWIG_Lua_set_immutable }, - { "ShortColor_mintCream", _wrap_ShortColor_mintCream_get, SWIG_Lua_set_immutable }, - { "ShortColor_mistyRose", _wrap_ShortColor_mistyRose_get, SWIG_Lua_set_immutable }, - { "ShortColor_moccasin", _wrap_ShortColor_moccasin_get, SWIG_Lua_set_immutable }, - { "ShortColor_navajoWhite", _wrap_ShortColor_navajoWhite_get, SWIG_Lua_set_immutable }, - { "ShortColor_navy", _wrap_ShortColor_navy_get, SWIG_Lua_set_immutable }, - { "ShortColor_oldLace", _wrap_ShortColor_oldLace_get, SWIG_Lua_set_immutable }, - { "ShortColor_olive", _wrap_ShortColor_olive_get, SWIG_Lua_set_immutable }, - { "ShortColor_oliveDrab", _wrap_ShortColor_oliveDrab_get, SWIG_Lua_set_immutable }, - { "ShortColor_orange", _wrap_ShortColor_orange_get, SWIG_Lua_set_immutable }, - { "ShortColor_orangeRed", _wrap_ShortColor_orangeRed_get, SWIG_Lua_set_immutable }, - { "ShortColor_orchid", _wrap_ShortColor_orchid_get, SWIG_Lua_set_immutable }, - { "ShortColor_paleGoldenRod", _wrap_ShortColor_paleGoldenRod_get, SWIG_Lua_set_immutable }, - { "ShortColor_paleGreen", _wrap_ShortColor_paleGreen_get, SWIG_Lua_set_immutable }, - { "ShortColor_paleTurquoise", _wrap_ShortColor_paleTurquoise_get, SWIG_Lua_set_immutable }, - { "ShortColor_paleVioletRed", _wrap_ShortColor_paleVioletRed_get, SWIG_Lua_set_immutable }, - { "ShortColor_papayaWhip", _wrap_ShortColor_papayaWhip_get, SWIG_Lua_set_immutable }, - { "ShortColor_peachPuff", _wrap_ShortColor_peachPuff_get, SWIG_Lua_set_immutable }, - { "ShortColor_peru", _wrap_ShortColor_peru_get, SWIG_Lua_set_immutable }, - { "ShortColor_pink", _wrap_ShortColor_pink_get, SWIG_Lua_set_immutable }, - { "ShortColor_plum", _wrap_ShortColor_plum_get, SWIG_Lua_set_immutable }, - { "ShortColor_powderBlue", _wrap_ShortColor_powderBlue_get, SWIG_Lua_set_immutable }, - { "ShortColor_purple", _wrap_ShortColor_purple_get, SWIG_Lua_set_immutable }, - { "ShortColor_rosyBrown", _wrap_ShortColor_rosyBrown_get, SWIG_Lua_set_immutable }, - { "ShortColor_royalBlue", _wrap_ShortColor_royalBlue_get, SWIG_Lua_set_immutable }, - { "ShortColor_saddleBrown", _wrap_ShortColor_saddleBrown_get, SWIG_Lua_set_immutable }, - { "ShortColor_salmon", _wrap_ShortColor_salmon_get, SWIG_Lua_set_immutable }, - { "ShortColor_sandyBrown", _wrap_ShortColor_sandyBrown_get, SWIG_Lua_set_immutable }, - { "ShortColor_seaGreen", _wrap_ShortColor_seaGreen_get, SWIG_Lua_set_immutable }, - { "ShortColor_seaShell", _wrap_ShortColor_seaShell_get, SWIG_Lua_set_immutable }, - { "ShortColor_sienna", _wrap_ShortColor_sienna_get, SWIG_Lua_set_immutable }, - { "ShortColor_silver", _wrap_ShortColor_silver_get, SWIG_Lua_set_immutable }, - { "ShortColor_skyBlue", _wrap_ShortColor_skyBlue_get, SWIG_Lua_set_immutable }, - { "ShortColor_slateBlue", _wrap_ShortColor_slateBlue_get, SWIG_Lua_set_immutable }, - { "ShortColor_slateGray", _wrap_ShortColor_slateGray_get, SWIG_Lua_set_immutable }, - { "ShortColor_slateGrey", _wrap_ShortColor_slateGrey_get, SWIG_Lua_set_immutable }, - { "ShortColor_snow", _wrap_ShortColor_snow_get, SWIG_Lua_set_immutable }, - { "ShortColor_springGreen", _wrap_ShortColor_springGreen_get, SWIG_Lua_set_immutable }, - { "ShortColor_steelBlue", _wrap_ShortColor_steelBlue_get, SWIG_Lua_set_immutable }, - { "ShortColor_blueSteel", _wrap_ShortColor_blueSteel_get, SWIG_Lua_set_immutable }, - { "ShortColor_tan", _wrap_ShortColor_tan_get, SWIG_Lua_set_immutable }, - { "ShortColor_teal", _wrap_ShortColor_teal_get, SWIG_Lua_set_immutable }, - { "ShortColor_thistle", _wrap_ShortColor_thistle_get, SWIG_Lua_set_immutable }, - { "ShortColor_tomato", _wrap_ShortColor_tomato_get, SWIG_Lua_set_immutable }, - { "ShortColor_turquoise", _wrap_ShortColor_turquoise_get, SWIG_Lua_set_immutable }, - { "ShortColor_violet", _wrap_ShortColor_violet_get, SWIG_Lua_set_immutable }, - { "ShortColor_wheat", _wrap_ShortColor_wheat_get, SWIG_Lua_set_immutable }, - { "ShortColor_whiteSmoke", _wrap_ShortColor_whiteSmoke_get, SWIG_Lua_set_immutable }, - { "ShortColor_yellowGreen", _wrap_ShortColor_yellowGreen_get, SWIG_Lua_set_immutable }, - {0,0,0} -}; -static swig_lua_const_info swig_SwigModule_constants[]= { - {SWIG_LUA_CONSTTAB_INT("VERSION_MAJOR", 0)}, - {SWIG_LUA_CONSTTAB_INT("VERSION_MINOR", 9)}, - {SWIG_LUA_CONSTTAB_INT("VERSION_PATCH", 6)}, - {SWIG_LUA_CONSTTAB_STRING("VERSION_PRE_RELEASE", "stable")}, - {SWIG_LUA_CONSTTAB_INT("LOOP_NONE", OF_LOOP_NONE)}, - {SWIG_LUA_CONSTTAB_INT("LOOP_PALINDROME", OF_LOOP_PALINDROME)}, - {SWIG_LUA_CONSTTAB_INT("LOOP_NORMAL", OF_LOOP_NORMAL)}, - {SWIG_LUA_CONSTTAB_INT("TARGET_OSX", OF_TARGET_OSX)}, - {SWIG_LUA_CONSTTAB_INT("TARGET_MINGW", OF_TARGET_MINGW)}, - {SWIG_LUA_CONSTTAB_INT("TARGET_WINVS", OF_TARGET_WINVS)}, - {SWIG_LUA_CONSTTAB_INT("TARGET_IOS", OF_TARGET_IOS)}, - {SWIG_LUA_CONSTTAB_INT("TARGET_ANDROID", OF_TARGET_ANDROID)}, - {SWIG_LUA_CONSTTAB_INT("TARGET_LINUX", OF_TARGET_LINUX)}, - {SWIG_LUA_CONSTTAB_INT("TARGET_LINUX64", OF_TARGET_LINUX64)}, - {SWIG_LUA_CONSTTAB_INT("TARGET_LINUXARMV6L", OF_TARGET_LINUXARMV6L)}, - {SWIG_LUA_CONSTTAB_INT("TARGET_LINUXARMV7L", OF_TARGET_LINUXARMV7L)}, - {SWIG_LUA_CONSTTAB_INT("TARGET_EMSCRIPTEN", OF_TARGET_EMSCRIPTEN)}, - {SWIG_LUA_CONSTTAB_INT("B14400", 14400)}, - {SWIG_LUA_CONSTTAB_INT("B28800", 28800)}, - {SWIG_LUA_CONSTTAB_INT("HAS_TLS", 1)}, - {SWIG_LUA_CONSTTAB_INT("SERIAL_NO_DATA", -2)}, - {SWIG_LUA_CONSTTAB_INT("SERIAL_ERROR", -1)}, - {SWIG_LUA_CONSTTAB_FLOAT("PI", 3.14159265358979323846)}, - {SWIG_LUA_CONSTTAB_FLOAT("TWO_PI", 6.28318530717958647693)}, - {SWIG_LUA_CONSTTAB_FLOAT("M_TWO_PI", 6.28318530717958647693)}, - {SWIG_LUA_CONSTTAB_FLOAT("FOUR_PI", 12.56637061435917295385)}, - {SWIG_LUA_CONSTTAB_FLOAT("HALF_PI", 1.57079632679489661923)}, - {SWIG_LUA_CONSTTAB_FLOAT("DEG_TO_RAD", (3.14159265358979323846/180.0))}, - {SWIG_LUA_CONSTTAB_FLOAT("RAD_TO_DEG", (180.0/3.14159265358979323846))}, - {SWIG_LUA_CONSTTAB_INT("OUTLINE", OF_OUTLINE)}, - {SWIG_LUA_CONSTTAB_INT("FILLED", OF_FILLED)}, - {SWIG_LUA_CONSTTAB_INT("WINDOW", OF_WINDOW)}, - {SWIG_LUA_CONSTTAB_INT("FULLSCREEN", OF_FULLSCREEN)}, - {SWIG_LUA_CONSTTAB_INT("GAME_MODE", OF_GAME_MODE)}, - {SWIG_LUA_CONSTTAB_INT("ASPECT_RATIO_IGNORE", OF_ASPECT_RATIO_IGNORE)}, - {SWIG_LUA_CONSTTAB_INT("ASPECT_RATIO_KEEP", OF_ASPECT_RATIO_KEEP)}, - {SWIG_LUA_CONSTTAB_INT("ASPECT_RATIO_KEEP_BY_EXPANDING", OF_ASPECT_RATIO_KEEP_BY_EXPANDING)}, - {SWIG_LUA_CONSTTAB_INT("ALIGN_VERT_IGNORE", OF_ALIGN_VERT_IGNORE)}, - {SWIG_LUA_CONSTTAB_INT("ALIGN_VERT_TOP", OF_ALIGN_VERT_TOP)}, - {SWIG_LUA_CONSTTAB_INT("ALIGN_VERT_BOTTOM", OF_ALIGN_VERT_BOTTOM)}, - {SWIG_LUA_CONSTTAB_INT("ALIGN_VERT_CENTER", OF_ALIGN_VERT_CENTER)}, - {SWIG_LUA_CONSTTAB_INT("ALIGN_HORZ_IGNORE", OF_ALIGN_HORZ_IGNORE)}, - {SWIG_LUA_CONSTTAB_INT("ALIGN_HORZ_LEFT", OF_ALIGN_HORZ_LEFT)}, - {SWIG_LUA_CONSTTAB_INT("ALIGN_HORZ_RIGHT", OF_ALIGN_HORZ_RIGHT)}, - {SWIG_LUA_CONSTTAB_INT("ALIGN_HORZ_CENTER", OF_ALIGN_HORZ_CENTER)}, - {SWIG_LUA_CONSTTAB_INT("RECTMODE_CORNER", OF_RECTMODE_CORNER)}, - {SWIG_LUA_CONSTTAB_INT("RECTMODE_CENTER", OF_RECTMODE_CENTER)}, - {SWIG_LUA_CONSTTAB_INT("SCALEMODE_FIT", OF_SCALEMODE_FIT)}, - {SWIG_LUA_CONSTTAB_INT("SCALEMODE_FILL", OF_SCALEMODE_FILL)}, - {SWIG_LUA_CONSTTAB_INT("SCALEMODE_CENTER", OF_SCALEMODE_CENTER)}, - {SWIG_LUA_CONSTTAB_INT("SCALEMODE_STRETCH_TO_FILL", OF_SCALEMODE_STRETCH_TO_FILL)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_GRAYSCALE", OF_IMAGE_GRAYSCALE)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_COLOR", OF_IMAGE_COLOR)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_COLOR_ALPHA", OF_IMAGE_COLOR_ALPHA)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_UNDEFINED", OF_IMAGE_UNDEFINED)}, - {SWIG_LUA_CONSTTAB_INT("MAX_STYLE_HISTORY", 32)}, - {SWIG_LUA_CONSTTAB_INT("MAX_VIEWPORT_HISTORY", 32)}, - {SWIG_LUA_CONSTTAB_INT("MAX_CIRCLE_PTS", 1024)}, - {SWIG_LUA_CONSTTAB_INT("BLENDMODE_DISABLED", OF_BLENDMODE_DISABLED)}, - {SWIG_LUA_CONSTTAB_INT("BLENDMODE_ALPHA", OF_BLENDMODE_ALPHA)}, - {SWIG_LUA_CONSTTAB_INT("BLENDMODE_ADD", OF_BLENDMODE_ADD)}, - {SWIG_LUA_CONSTTAB_INT("BLENDMODE_SUBTRACT", OF_BLENDMODE_SUBTRACT)}, - {SWIG_LUA_CONSTTAB_INT("BLENDMODE_MULTIPLY", OF_BLENDMODE_MULTIPLY)}, - {SWIG_LUA_CONSTTAB_INT("BLENDMODE_SCREEN", OF_BLENDMODE_SCREEN)}, - {SWIG_LUA_CONSTTAB_INT("ORIENTATION_DEFAULT", OF_ORIENTATION_DEFAULT)}, - {SWIG_LUA_CONSTTAB_INT("ORIENTATION_180", OF_ORIENTATION_180)}, - {SWIG_LUA_CONSTTAB_INT("ORIENTATION_90_LEFT", OF_ORIENTATION_90_LEFT)}, - {SWIG_LUA_CONSTTAB_INT("ORIENTATION_90_RIGHT", OF_ORIENTATION_90_RIGHT)}, - {SWIG_LUA_CONSTTAB_INT("ORIENTATION_UNKNOWN", OF_ORIENTATION_UNKNOWN)}, - {SWIG_LUA_CONSTTAB_INT("GRADIENT_LINEAR", OF_GRADIENT_LINEAR)}, - {SWIG_LUA_CONSTTAB_INT("GRADIENT_CIRCULAR", OF_GRADIENT_CIRCULAR)}, - {SWIG_LUA_CONSTTAB_INT("GRADIENT_BAR", OF_GRADIENT_BAR)}, - {SWIG_LUA_CONSTTAB_INT("POLY_WINDING_ODD", OF_POLY_WINDING_ODD)}, - {SWIG_LUA_CONSTTAB_INT("POLY_WINDING_NONZERO", OF_POLY_WINDING_NONZERO)}, - {SWIG_LUA_CONSTTAB_INT("POLY_WINDING_POSITIVE", OF_POLY_WINDING_POSITIVE)}, - {SWIG_LUA_CONSTTAB_INT("POLY_WINDING_NEGATIVE", OF_POLY_WINDING_NEGATIVE)}, - {SWIG_LUA_CONSTTAB_INT("POLY_WINDING_ABS_GEQ_TWO", OF_POLY_WINDING_ABS_GEQ_TWO)}, - {SWIG_LUA_CONSTTAB_INT("CLOSE", (true))}, - {SWIG_LUA_CONSTTAB_INT("LEFT_HANDED", OF_LEFT_HANDED)}, - {SWIG_LUA_CONSTTAB_INT("RIGHT_HANDED", OF_RIGHT_HANDED)}, - {SWIG_LUA_CONSTTAB_INT("MATRIX_MODELVIEW", OF_MATRIX_MODELVIEW)}, - {SWIG_LUA_CONSTTAB_INT("MATRIX_PROJECTION", OF_MATRIX_PROJECTION)}, - {SWIG_LUA_CONSTTAB_INT("MATRIX_TEXTURE", OF_MATRIX_TEXTURE)}, - {SWIG_LUA_CONSTTAB_INT("KEY_MODIFIER", 0x0100)}, - {SWIG_LUA_CONSTTAB_INT("KEY_RETURN", 13)}, - {SWIG_LUA_CONSTTAB_INT("KEY_ESC", 27)}, - {SWIG_LUA_CONSTTAB_INT("KEY_TAB", 9)}, - {SWIG_LUA_CONSTTAB_INT("KEY_BACKSPACE", 8)}, - {SWIG_LUA_CONSTTAB_INT("KEY_DEL", 127)}, - {SWIG_LUA_CONSTTAB_INT("KEY_F1", (1|0x0100))}, - {SWIG_LUA_CONSTTAB_INT("KEY_F2", (2|0x0100))}, - {SWIG_LUA_CONSTTAB_INT("KEY_F3", (3|0x0100))}, - {SWIG_LUA_CONSTTAB_INT("KEY_F4", (4|0x0100))}, - {SWIG_LUA_CONSTTAB_INT("KEY_F5", (5|0x0100))}, - {SWIG_LUA_CONSTTAB_INT("KEY_F6", (6|0x0100))}, - {SWIG_LUA_CONSTTAB_INT("KEY_F7", (7|0x0100))}, - {SWIG_LUA_CONSTTAB_INT("KEY_F8", (8|0x0100))}, - {SWIG_LUA_CONSTTAB_INT("KEY_F9", (9|0x0100))}, - {SWIG_LUA_CONSTTAB_INT("KEY_F10", (10|0x0100))}, - {SWIG_LUA_CONSTTAB_INT("KEY_F11", (11|0x0100))}, - {SWIG_LUA_CONSTTAB_INT("KEY_F12", (12|0x0100))}, - {SWIG_LUA_CONSTTAB_INT("KEY_LEFT", (100|0x0100))}, - {SWIG_LUA_CONSTTAB_INT("KEY_UP", (101|0x0100))}, - {SWIG_LUA_CONSTTAB_INT("KEY_RIGHT", (102|0x0100))}, - {SWIG_LUA_CONSTTAB_INT("KEY_DOWN", (103|0x0100))}, - {SWIG_LUA_CONSTTAB_INT("KEY_PAGE_UP", (104|0x0100))}, - {SWIG_LUA_CONSTTAB_INT("KEY_PAGE_DOWN", (105|0x0100))}, - {SWIG_LUA_CONSTTAB_INT("KEY_HOME", (106|0x0100))}, - {SWIG_LUA_CONSTTAB_INT("KEY_END", (107|0x0100))}, - {SWIG_LUA_CONSTTAB_INT("KEY_INSERT", (108|0x0100))}, - {SWIG_LUA_CONSTTAB_INT("KEY_CONTROL", (0x200|0x0100))}, - {SWIG_LUA_CONSTTAB_INT("KEY_ALT", (0x400|0x0100))}, - {SWIG_LUA_CONSTTAB_INT("KEY_SHIFT", (0x800|0x0100))}, - {SWIG_LUA_CONSTTAB_INT("KEY_SUPER", (0x1000|0x0100))}, - {SWIG_LUA_CONSTTAB_INT("KEY_LEFT_SHIFT", (0x1|(0x800|0x0100)))}, - {SWIG_LUA_CONSTTAB_INT("KEY_RIGHT_SHIFT", (0x2|(0x800|0x0100)))}, - {SWIG_LUA_CONSTTAB_INT("KEY_LEFT_CONTROL", (0x1|(0x200|0x0100)))}, - {SWIG_LUA_CONSTTAB_INT("KEY_RIGHT_CONTROL", (0x2|(0x200|0x0100)))}, - {SWIG_LUA_CONSTTAB_INT("KEY_LEFT_ALT", (0x1|(0x400|0x0100)))}, - {SWIG_LUA_CONSTTAB_INT("KEY_RIGHT_ALT", (0x2|(0x400|0x0100)))}, - {SWIG_LUA_CONSTTAB_INT("KEY_LEFT_SUPER", (0x1|(0x1000|0x0100)))}, - {SWIG_LUA_CONSTTAB_INT("KEY_RIGHT_SUPER", (0x2|(0x1000|0x0100)))}, - {SWIG_LUA_CONSTTAB_INT("KEY_LEFT_COMMAND", (0x1|(0x1000|0x0100)))}, - {SWIG_LUA_CONSTTAB_INT("KEY_RIGHT_COMMAND", (0x2|(0x1000|0x0100)))}, - {SWIG_LUA_CONSTTAB_INT("MOUSE_BUTTON_1", 0)}, - {SWIG_LUA_CONSTTAB_INT("MOUSE_BUTTON_2", 1)}, - {SWIG_LUA_CONSTTAB_INT("MOUSE_BUTTON_3", 2)}, - {SWIG_LUA_CONSTTAB_INT("MOUSE_BUTTON_4", 3)}, - {SWIG_LUA_CONSTTAB_INT("MOUSE_BUTTON_5", 4)}, - {SWIG_LUA_CONSTTAB_INT("MOUSE_BUTTON_6", 5)}, - {SWIG_LUA_CONSTTAB_INT("MOUSE_BUTTON_7", 6)}, - {SWIG_LUA_CONSTTAB_INT("MOUSE_BUTTON_8", 7)}, - {SWIG_LUA_CONSTTAB_INT("MOUSE_BUTTON_LAST", 7)}, - {SWIG_LUA_CONSTTAB_INT("MOUSE_BUTTON_LEFT", 0)}, - {SWIG_LUA_CONSTTAB_INT("MOUSE_BUTTON_MIDDLE", 1)}, - {SWIG_LUA_CONSTTAB_INT("MOUSE_BUTTON_RIGHT", 2)}, - {SWIG_LUA_CONSTTAB_INT("CONSOLE_COLOR_RESTORE", (0))}, - {SWIG_LUA_CONSTTAB_INT("CONSOLE_COLOR_BLACK", (30))}, - {SWIG_LUA_CONSTTAB_INT("CONSOLE_COLOR_RED", (31))}, - {SWIG_LUA_CONSTTAB_INT("CONSOLE_COLOR_GREEN", (32))}, - {SWIG_LUA_CONSTTAB_INT("CONSOLE_COLOR_YELLOW", (33))}, - {SWIG_LUA_CONSTTAB_INT("CONSOLE_COLOR_BLUE", (34))}, - {SWIG_LUA_CONSTTAB_INT("CONSOLE_COLOR_PURPLE", (35))}, - {SWIG_LUA_CONSTTAB_INT("CONSOLE_COLOR_CYAN", (36))}, - {SWIG_LUA_CONSTTAB_INT("CONSOLE_COLOR_WHITE", (37))}, - {SWIG_LUA_CONSTTAB_INT("PIXELS_GRAY", OF_PIXELS_GRAY)}, - {SWIG_LUA_CONSTTAB_INT("PIXELS_GRAY_ALPHA", OF_PIXELS_GRAY_ALPHA)}, - {SWIG_LUA_CONSTTAB_INT("PIXELS_RGB", OF_PIXELS_RGB)}, - {SWIG_LUA_CONSTTAB_INT("PIXELS_BGR", OF_PIXELS_BGR)}, - {SWIG_LUA_CONSTTAB_INT("PIXELS_RGBA", OF_PIXELS_RGBA)}, - {SWIG_LUA_CONSTTAB_INT("PIXELS_BGRA", OF_PIXELS_BGRA)}, - {SWIG_LUA_CONSTTAB_INT("PIXELS_RGB565", OF_PIXELS_RGB565)}, - {SWIG_LUA_CONSTTAB_INT("PIXELS_NV12", OF_PIXELS_NV12)}, - {SWIG_LUA_CONSTTAB_INT("PIXELS_NV21", OF_PIXELS_NV21)}, - {SWIG_LUA_CONSTTAB_INT("PIXELS_YV12", OF_PIXELS_YV12)}, - {SWIG_LUA_CONSTTAB_INT("PIXELS_I420", OF_PIXELS_I420)}, - {SWIG_LUA_CONSTTAB_INT("PIXELS_YUY2", OF_PIXELS_YUY2)}, - {SWIG_LUA_CONSTTAB_INT("PIXELS_UYVY", OF_PIXELS_UYVY)}, - {SWIG_LUA_CONSTTAB_INT("PIXELS_Y", OF_PIXELS_Y)}, - {SWIG_LUA_CONSTTAB_INT("PIXELS_U", OF_PIXELS_U)}, - {SWIG_LUA_CONSTTAB_INT("PIXELS_V", OF_PIXELS_V)}, - {SWIG_LUA_CONSTTAB_INT("PIXELS_UV", OF_PIXELS_UV)}, - {SWIG_LUA_CONSTTAB_INT("PIXELS_VU", OF_PIXELS_VU)}, - {SWIG_LUA_CONSTTAB_INT("PIXELS_NUM_FORMATS", OF_PIXELS_NUM_FORMATS)}, - {SWIG_LUA_CONSTTAB_INT("PIXELS_UNKNOWN", OF_PIXELS_UNKNOWN)}, - {SWIG_LUA_CONSTTAB_INT("PIXELS_NATIVE", OF_PIXELS_NATIVE)}, - {SWIG_LUA_CONSTTAB_INT("BITMAPMODE_SIMPLE", OF_BITMAPMODE_SIMPLE)}, - {SWIG_LUA_CONSTTAB_INT("BITMAPMODE_SCREEN", OF_BITMAPMODE_SCREEN)}, - {SWIG_LUA_CONSTTAB_INT("BITMAPMODE_VIEWPORT", OF_BITMAPMODE_VIEWPORT)}, - {SWIG_LUA_CONSTTAB_INT("BITMAPMODE_MODEL", OF_BITMAPMODE_MODEL)}, - {SWIG_LUA_CONSTTAB_INT("BITMAPMODE_MODEL_BILLBOARD", OF_BITMAPMODE_MODEL_BILLBOARD)}, - {SWIG_LUA_CONSTTAB_INT("ENCODING_UTF8", OF_ENCODING_UTF8)}, - {SWIG_LUA_CONSTTAB_INT("ENCODING_ISO_8859_15", OF_ENCODING_ISO_8859_15)}, - {SWIG_LUA_CONSTTAB_INT("COMPRESS_NONE", OF_COMPRESS_NONE)}, - {SWIG_LUA_CONSTTAB_INT("COMPRESS_SRGB", OF_COMPRESS_SRGB)}, - {SWIG_LUA_CONSTTAB_INT("COMPRESS_ARB", OF_COMPRESS_ARB)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_QUALITY_BEST", OF_IMAGE_QUALITY_BEST)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_QUALITY_HIGH", OF_IMAGE_QUALITY_HIGH)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_QUALITY_MEDIUM", OF_IMAGE_QUALITY_MEDIUM)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_QUALITY_LOW", OF_IMAGE_QUALITY_LOW)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_QUALITY_WORST", OF_IMAGE_QUALITY_WORST)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_BMP", OF_IMAGE_FORMAT_BMP)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_ICO", OF_IMAGE_FORMAT_ICO)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_JPEG", OF_IMAGE_FORMAT_JPEG)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_JNG", OF_IMAGE_FORMAT_JNG)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_KOALA", OF_IMAGE_FORMAT_KOALA)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_LBM", OF_IMAGE_FORMAT_LBM)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_IFF", OF_IMAGE_FORMAT_IFF)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_MNG", OF_IMAGE_FORMAT_MNG)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_PBM", OF_IMAGE_FORMAT_PBM)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_PBMRAW", OF_IMAGE_FORMAT_PBMRAW)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_PCD", OF_IMAGE_FORMAT_PCD)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_PCX", OF_IMAGE_FORMAT_PCX)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_PGM", OF_IMAGE_FORMAT_PGM)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_PGMRAW", OF_IMAGE_FORMAT_PGMRAW)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_PNG", OF_IMAGE_FORMAT_PNG)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_PPM", OF_IMAGE_FORMAT_PPM)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_PPMRAW", OF_IMAGE_FORMAT_PPMRAW)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_RAS", OF_IMAGE_FORMAT_RAS)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_TARGA", OF_IMAGE_FORMAT_TARGA)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_TIFF", OF_IMAGE_FORMAT_TIFF)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_WBMP", OF_IMAGE_FORMAT_WBMP)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_PSD", OF_IMAGE_FORMAT_PSD)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_CUT", OF_IMAGE_FORMAT_CUT)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_XBM", OF_IMAGE_FORMAT_XBM)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_XPM", OF_IMAGE_FORMAT_XPM)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_DDS", OF_IMAGE_FORMAT_DDS)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_GIF", OF_IMAGE_FORMAT_GIF)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_HDR", OF_IMAGE_FORMAT_HDR)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_FAXG3", OF_IMAGE_FORMAT_FAXG3)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_SGI", OF_IMAGE_FORMAT_SGI)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_EXR", OF_IMAGE_FORMAT_EXR)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_J2K", OF_IMAGE_FORMAT_J2K)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_JP2", OF_IMAGE_FORMAT_JP2)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_PFM", OF_IMAGE_FORMAT_PFM)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_PICT", OF_IMAGE_FORMAT_PICT)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_RAW", OF_IMAGE_FORMAT_RAW)}, - {SWIG_LUA_CONSTTAB_INT("BoxPrimitive_SIDE_FRONT", ofBoxPrimitive::SIDE_FRONT)}, - {SWIG_LUA_CONSTTAB_INT("BoxPrimitive_SIDE_RIGHT", ofBoxPrimitive::SIDE_RIGHT)}, - {SWIG_LUA_CONSTTAB_INT("BoxPrimitive_SIDE_LEFT", ofBoxPrimitive::SIDE_LEFT)}, - {SWIG_LUA_CONSTTAB_INT("BoxPrimitive_SIDE_BACK", ofBoxPrimitive::SIDE_BACK)}, - {SWIG_LUA_CONSTTAB_INT("BoxPrimitive_SIDE_TOP", ofBoxPrimitive::SIDE_TOP)}, - {SWIG_LUA_CONSTTAB_INT("BoxPrimitive_SIDE_BOTTOM", ofBoxPrimitive::SIDE_BOTTOM)}, - {SWIG_LUA_CONSTTAB_INT("BoxPrimitive_SIDES_TOTAL", ofBoxPrimitive::SIDES_TOTAL)}, - {SWIG_LUA_CONSTTAB_INT("FIRMATA_MAJOR_VERSION", 2)}, - {SWIG_LUA_CONSTTAB_INT("FIRMATA_MINOR_VERSION", 0)}, - {SWIG_LUA_CONSTTAB_INT("FIRMATA_MAX_DATA_BYTES", 32)}, - {SWIG_LUA_CONSTTAB_INT("FIRMATA_DIGITAL_MESSAGE", 0x90)}, - {SWIG_LUA_CONSTTAB_INT("FIRMATA_ANALOG_MESSAGE", 0xE0)}, - {SWIG_LUA_CONSTTAB_INT("FIRMATA_REPORT_ANALOG", 0xC0)}, - {SWIG_LUA_CONSTTAB_INT("FIRMATA_REPORT_DIGITAL", 0xD0)}, - {SWIG_LUA_CONSTTAB_INT("FIRMATA_SET_PIN_MODE", 0xF4)}, - {SWIG_LUA_CONSTTAB_INT("FIRMATA_REPORT_VERSION", 0xF9)}, - {SWIG_LUA_CONSTTAB_INT("FIRMATA_SYSTEM_RESET", 0xFF)}, - {SWIG_LUA_CONSTTAB_INT("FIRMATA_START_SYSEX", 0xF0)}, - {SWIG_LUA_CONSTTAB_INT("FIRMATA_END_SYSEX", 0xF7)}, - {SWIG_LUA_CONSTTAB_INT("FIRMATA_INPUT", 0x00)}, - {SWIG_LUA_CONSTTAB_INT("FIRMATA_OUTPUT", 0x01)}, - {SWIG_LUA_CONSTTAB_INT("FIRMATA_ANALOG", 0x02)}, - {SWIG_LUA_CONSTTAB_INT("FIRMATA_PWM", 0x03)}, - {SWIG_LUA_CONSTTAB_INT("FIRMATA_SERVO", 0x04)}, - {SWIG_LUA_CONSTTAB_INT("SHIFT", 0x05)}, - {SWIG_LUA_CONSTTAB_INT("I2C", 0x06)}, - {SWIG_LUA_CONSTTAB_INT("TOTAL_PIN_MODES", 7)}, - {SWIG_LUA_CONSTTAB_INT("FIRMATA_SYSEX_SERVO_CONFIG", 0x70)}, - {SWIG_LUA_CONSTTAB_INT("FIRMATA_SYSEX_FIRMATA_STRING", 0x71)}, - {SWIG_LUA_CONSTTAB_INT("SHIFT_DATA", 0x75)}, - {SWIG_LUA_CONSTTAB_INT("I2C_REQUEST", 0x76)}, - {SWIG_LUA_CONSTTAB_INT("I2C_REPLY", 0x77)}, - {SWIG_LUA_CONSTTAB_INT("I2C_CONFIG", 0x78)}, - {SWIG_LUA_CONSTTAB_INT("EXTENDED_ANALOG", 0x6F)}, - {SWIG_LUA_CONSTTAB_INT("PIN_STATE_QUERY", 0x6D)}, - {SWIG_LUA_CONSTTAB_INT("PIN_STATE_RESPONSE", 0x6E)}, - {SWIG_LUA_CONSTTAB_INT("CAPABILITY_QUERY", 0x6B)}, - {SWIG_LUA_CONSTTAB_INT("CAPABILITY_RESPONSE", 0x6C)}, - {SWIG_LUA_CONSTTAB_INT("ANALOG_MAPPING_QUERY", 0x69)}, - {SWIG_LUA_CONSTTAB_INT("ANALOG_MAPPING_RESPONSE", 0x6A)}, - {SWIG_LUA_CONSTTAB_INT("FIRMATA_SYSEX_REPORT_FIRMWARE", 0x79)}, - {SWIG_LUA_CONSTTAB_INT("SAMPLING_INTERVAL", 0x7A)}, - {SWIG_LUA_CONSTTAB_INT("FIRMATA_SYSEX_NON_REALTIME", 0x7E)}, - {SWIG_LUA_CONSTTAB_INT("FIRMATA_SYSEX_REALTIME", 0x7F)}, - {SWIG_LUA_CONSTTAB_INT("ARD_TOTAL_DIGITAL_PINS", 22)}, - {SWIG_LUA_CONSTTAB_INT("ARD_TOTAL_ANALOG_PINS", 6)}, - {SWIG_LUA_CONSTTAB_INT("ARD_TOTAL_PORTS", 3)}, - {SWIG_LUA_CONSTTAB_INT("ARD_INPUT", 0x00)}, - {SWIG_LUA_CONSTTAB_INT("ARD_OUTPUT", 0x01)}, - {SWIG_LUA_CONSTTAB_INT("ARD_ANALOG", 0x02)}, - {SWIG_LUA_CONSTTAB_INT("ARD_PWM", 0x03)}, - {SWIG_LUA_CONSTTAB_INT("ARD_SERVO", 0x04)}, - {SWIG_LUA_CONSTTAB_INT("ARD_HIGH", 1)}, - {SWIG_LUA_CONSTTAB_INT("ARD_LOW", 0)}, - {SWIG_LUA_CONSTTAB_INT("ARD_ON", 1)}, - {SWIG_LUA_CONSTTAB_INT("ARD_OFF", 0)}, - {SWIG_LUA_CONSTTAB_INT("SYSEX_SERVO_ATTACH", 0x00)}, - {SWIG_LUA_CONSTTAB_INT("SYSEX_SERVO_DETACH", 0x01)}, - {SWIG_LUA_CONSTTAB_INT("SYSEX_SERVO_WRITE", 0x02)}, - {SWIG_LUA_CONSTTAB_FLOAT("ARDUINO_DELAY_LENGTH", 4.0)}, - {SWIG_LUA_CONSTTAB_INT("FIRMWARE2_2", 22)}, - {SWIG_LUA_CONSTTAB_INT("FIRMWARE2_3", 23)}, - {SWIG_LUA_CONSTTAB_INT("Vec2f_DIM", ofVec2f::DIM)}, - {SWIG_LUA_CONSTTAB_INT("Vec3f_DIM", ofVec3f::DIM)}, - {SWIG_LUA_CONSTTAB_INT("Vec4f_DIM", ofVec4f::DIM)}, - {SWIG_LUA_CONSTTAB_INT("TouchEventArgs_down", ofTouchEventArgs::down)}, - {SWIG_LUA_CONSTTAB_INT("TouchEventArgs_up", ofTouchEventArgs::up)}, - {SWIG_LUA_CONSTTAB_INT("TouchEventArgs_move", ofTouchEventArgs::move)}, - {SWIG_LUA_CONSTTAB_INT("TouchEventArgs_doubleTap", ofTouchEventArgs::doubleTap)}, - {SWIG_LUA_CONSTTAB_INT("TouchEventArgs_cancel", ofTouchEventArgs::cancel)}, - {SWIG_LUA_CONSTTAB_INT("TEXTURE_LUMINANCE", 6409)}, - {SWIG_LUA_CONSTTAB_INT("TEXTURE_RGB", 6407)}, - {SWIG_LUA_CONSTTAB_INT("TEXTURE_RGBA", 6408)}, - {SWIG_LUA_CONSTTAB_INT("NEAREST", 9728)}, - {SWIG_LUA_CONSTTAB_INT("LINEAR", 9729)}, - {SWIG_LUA_CONSTTAB_INT("FRAGMENT_SHADER", 35632)}, - {SWIG_LUA_CONSTTAB_INT("VERTEX_SHADER", 35633)}, - {SWIG_LUA_CONSTTAB_INT("CLAMP_TO_EDGE", 33071)}, - {SWIG_LUA_CONSTTAB_INT("CLAMP_TO_BORDER", 33069)}, - {SWIG_LUA_CONSTTAB_INT("REPEAT", 10497)}, - {SWIG_LUA_CONSTTAB_INT("MIRRORED_REPEAT", 33648)}, - {SWIG_LUA_CONSTTAB_INT("PRIMITIVE_TRIANGLES", OF_PRIMITIVE_TRIANGLES)}, - {SWIG_LUA_CONSTTAB_INT("PRIMITIVE_TRIANGLE_STRIP", OF_PRIMITIVE_TRIANGLE_STRIP)}, - {SWIG_LUA_CONSTTAB_INT("PRIMITIVE_TRIANGLE_FAN", OF_PRIMITIVE_TRIANGLE_FAN)}, - {SWIG_LUA_CONSTTAB_INT("PRIMITIVE_LINES", OF_PRIMITIVE_LINES)}, - {SWIG_LUA_CONSTTAB_INT("PRIMITIVE_LINE_STRIP", OF_PRIMITIVE_LINE_STRIP)}, - {SWIG_LUA_CONSTTAB_INT("PRIMITIVE_LINE_LOOP", OF_PRIMITIVE_LINE_LOOP)}, - {SWIG_LUA_CONSTTAB_INT("PRIMITIVE_POINTS", OF_PRIMITIVE_POINTS)}, - {SWIG_LUA_CONSTTAB_INT("PRIMITIVE_LINES_ADJACENCY", OF_PRIMITIVE_LINES_ADJACENCY)}, - {SWIG_LUA_CONSTTAB_INT("PRIMITIVE_LINE_STRIP_ADJACENCY", OF_PRIMITIVE_LINE_STRIP_ADJACENCY)}, - {SWIG_LUA_CONSTTAB_INT("PRIMITIVE_TRIANGLES_ADJACENCY", OF_PRIMITIVE_TRIANGLES_ADJACENCY)}, - {SWIG_LUA_CONSTTAB_INT("PRIMITIVE_TRIANGLE_STRIP_ADJACENCY", OF_PRIMITIVE_TRIANGLE_STRIP_ADJACENCY)}, - {SWIG_LUA_CONSTTAB_INT("PRIMITIVE_PATCHES", OF_PRIMITIVE_PATCHES)}, - {SWIG_LUA_CONSTTAB_INT("MESH_POINTS", OF_MESH_POINTS)}, - {SWIG_LUA_CONSTTAB_INT("MESH_WIREFRAME", OF_MESH_WIREFRAME)}, - {SWIG_LUA_CONSTTAB_INT("MESH_FILL", OF_MESH_FILL)}, - {SWIG_LUA_CONSTTAB_INT("LIGHT_POINT", OF_LIGHT_POINT)}, - {SWIG_LUA_CONSTTAB_INT("LIGHT_DIRECTIONAL", OF_LIGHT_DIRECTIONAL)}, - {SWIG_LUA_CONSTTAB_INT("LIGHT_SPOT", OF_LIGHT_SPOT)}, - {SWIG_LUA_CONSTTAB_INT("LIGHT_AREA", OF_LIGHT_AREA)}, - {SWIG_LUA_CONSTTAB_INT("Shader_POSITION_ATTRIBUTE", ofShader::POSITION_ATTRIBUTE)}, - {SWIG_LUA_CONSTTAB_INT("Shader_COLOR_ATTRIBUTE", ofShader::COLOR_ATTRIBUTE)}, - {SWIG_LUA_CONSTTAB_INT("Shader_NORMAL_ATTRIBUTE", ofShader::NORMAL_ATTRIBUTE)}, - {SWIG_LUA_CONSTTAB_INT("Shader_TEXCOORD_ATTRIBUTE", ofShader::TEXCOORD_ATTRIBUTE)}, - {SWIG_LUA_CONSTTAB_INT("Shader_INDEX_ATTRIBUTE", ofShader::INDEX_ATTRIBUTE)}, - {SWIG_LUA_CONSTTAB_INT("INTERPOLATE_NEAREST_NEIGHBOR", OF_INTERPOLATE_NEAREST_NEIGHBOR)}, - {SWIG_LUA_CONSTTAB_INT("INTERPOLATE_BILINEAR", OF_INTERPOLATE_BILINEAR)}, - {SWIG_LUA_CONSTTAB_INT("INTERPOLATE_BICUBIC", OF_INTERPOLATE_BICUBIC)}, - {SWIG_LUA_CONSTTAB_INT("Path_COMMANDS", ofPath::COMMANDS)}, - {SWIG_LUA_CONSTTAB_INT("Path_POLYLINES", ofPath::POLYLINES)}, - {SWIG_LUA_CONSTTAB_INT("CIRC_RESOLUTION", 22)}, - {SWIG_LUA_CONSTTAB_INT("NUM_CHARACTER_TO_START", 32)}, - {SWIG_LUA_CONSTTAB_INT("File_Reference", ofFile::Reference)}, - {SWIG_LUA_CONSTTAB_INT("File_ReadOnly", ofFile::ReadOnly)}, - {SWIG_LUA_CONSTTAB_INT("File_WriteOnly", ofFile::WriteOnly)}, - {SWIG_LUA_CONSTTAB_INT("File_ReadWrite", ofFile::ReadWrite)}, - {SWIG_LUA_CONSTTAB_INT("File_Append", ofFile::Append)}, - {SWIG_LUA_CONSTTAB_INT("LOG_VERBOSE", OF_LOG_VERBOSE)}, - {SWIG_LUA_CONSTTAB_INT("LOG_NOTICE", OF_LOG_NOTICE)}, - {SWIG_LUA_CONSTTAB_INT("LOG_WARNING", OF_LOG_WARNING)}, - {SWIG_LUA_CONSTTAB_INT("LOG_ERROR", OF_LOG_ERROR)}, - {SWIG_LUA_CONSTTAB_INT("LOG_FATAL_ERROR", OF_LOG_FATAL_ERROR)}, - {SWIG_LUA_CONSTTAB_INT("LOG_SILENT", OF_LOG_SILENT)}, - {0,0,0,0,0,0} -}; -static swig_lua_method swig_SwigModule_methods[]= { - { "Fbo_checkGLSupport", _wrap_Fbo_checkGLSupport}, - { "Fbo_maxColorAttachments", _wrap_Fbo_maxColorAttachments}, - { "Fbo_maxDrawBuffers", _wrap_Fbo_maxDrawBuffers}, - { "Fbo_maxSamples", _wrap_Fbo_maxSamples}, - { "getUsingArbTex", _wrap_getUsingArbTex}, - { "enableArbTex", _wrap_enableArbTex}, - { "disableArbTex", _wrap_disableArbTex}, - { "getUsingNormalizedTexCoords", _wrap_getUsingNormalizedTexCoords}, - { "enableNormalizedTexCoords", _wrap_enableNormalizedTexCoords}, - { "disableNormalizedTexCoords", _wrap_disableNormalizedTexCoords}, - { "enableTextureEdgeHack", _wrap_enableTextureEdgeHack}, - { "disableTextureEdgeHack", _wrap_disableTextureEdgeHack}, - { "isTextureEdgeHackEnabled", _wrap_isTextureEdgeHackEnabled}, - { "isVFlipped", _wrap_isVFlipped}, - { "drawAxis", _wrap_drawAxis}, - { "drawGrid", _wrap_drawGrid}, - { "drawGridPlane", _wrap_drawGridPlane}, - { "drawArrow", _wrap_drawArrow}, - { "drawRotationAxes", _wrap_drawRotationAxes}, - { "Mesh_plane", _wrap_Mesh_plane}, - { "Mesh_sphere", _wrap_Mesh_sphere}, - { "Mesh_icosahedron", _wrap_Mesh_icosahedron}, - { "Mesh_icosphere", _wrap_Mesh_icosphere}, - { "Mesh_cylinder", _wrap_Mesh_cylinder}, - { "Mesh_cone", _wrap_Mesh_cone}, - { "Mesh_box", _wrap_Mesh_box}, - { "Mesh_axis", _wrap_Mesh_axis}, - { "getAppPtr", _wrap_getAppPtr}, - { "exit", _wrap_exit}, - { "getFrameRate", _wrap_getFrameRate}, - { "getTargetFrameRate", _wrap_getTargetFrameRate}, - { "getFrameNum", _wrap_getFrameNum}, - { "setFrameRate", _wrap_setFrameRate}, - { "getLastFrameTime", _wrap_getLastFrameTime}, - { "setOrientation", _wrap_setOrientation}, - { "getOrientation", _wrap_getOrientation}, - { "hideCursor", _wrap_hideCursor}, - { "showCursor", _wrap_showCursor}, - { "getWindowPositionX", _wrap_getWindowPositionX}, - { "getWindowPositionY", _wrap_getWindowPositionY}, - { "getScreenWidth", _wrap_getScreenWidth}, - { "getScreenHeight", _wrap_getScreenHeight}, - { "getWindowMode", _wrap_getWindowMode}, - { "getWidth", _wrap_getWidth}, - { "getHeight", _wrap_getHeight}, - { "getWindowWidth", _wrap_getWindowWidth}, - { "getWindowHeight", _wrap_getWindowHeight}, - { "randomWidth", _wrap_randomWidth}, - { "randomHeight", _wrap_randomHeight}, - { "doesHWOrientation", _wrap_doesHWOrientation}, - { "getWindowSize", _wrap_getWindowSize}, - { "getWindowRect", _wrap_getWindowRect}, - { "setWindowPosition", _wrap_setWindowPosition}, - { "setWindowShape", _wrap_setWindowShape}, - { "setWindowTitle", _wrap_setWindowTitle}, - { "enableSetupScreen", _wrap_enableSetupScreen}, - { "disableSetupScreen", _wrap_disableSetupScreen}, - { "setFullscreen", _wrap_setFullscreen}, - { "toggleFullscreen", _wrap_toggleFullscreen}, - { "setVerticalSync", _wrap_setVerticalSync}, - { "events", _wrap_events}, - { "setEscapeQuitsApp", _wrap_setEscapeQuitsApp}, - { "random", _wrap_random}, - { "randomf", _wrap_randomf}, - { "randomuf", _wrap_randomuf}, - { "seedRandom", _wrap_seedRandom}, - { "normalize", _wrap_normalize}, - { "map", _wrap_map}, - { "clamp", _wrap_clamp}, - { "inRange", _wrap_inRange}, - { "lerp", _wrap_lerp}, - { "dist", _wrap_dist}, - { "distSquared", _wrap_distSquared}, - { "radToDeg", _wrap_radToDeg}, - { "degToRad", _wrap_degToRad}, - { "lerpDegrees", _wrap_lerpDegrees}, - { "lerpRadians", _wrap_lerpRadians}, - { "angleDifferenceDegrees", _wrap_angleDifferenceDegrees}, - { "angleDifferenceRadians", _wrap_angleDifferenceRadians}, - { "wrap", _wrap_wrap}, - { "wrapRadians", _wrap_wrapRadians}, - { "wrapDegrees", _wrap_wrapDegrees}, - { "noise", _wrap_noise}, - { "signedNoise", _wrap_signedNoise}, - { "insidePoly", _wrap_insidePoly}, - { "lineSegmentIntersection", _wrap_lineSegmentIntersection}, - { "bezierPoint", _wrap_bezierPoint}, - { "curvePoint", _wrap_curvePoint}, - { "bezierTangent", _wrap_bezierTangent}, - { "curveTangent", _wrap_curveTangent}, - { "nextPow2", _wrap_nextPow2}, - { "sign", _wrap_sign}, - { "Matrix4x4_newIdentityMatrix", _wrap_Matrix4x4_newIdentityMatrix}, - { "Matrix4x4_newScaleMatrix", _wrap_Matrix4x4_newScaleMatrix}, - { "Matrix4x4_newTranslationMatrix", _wrap_Matrix4x4_newTranslationMatrix}, - { "Matrix4x4_newRotationMatrix", _wrap_Matrix4x4_newRotationMatrix}, - { "Matrix4x4_newOrthoMatrix", _wrap_Matrix4x4_newOrthoMatrix}, - { "Matrix4x4_newOrtho2DMatrix", _wrap_Matrix4x4_newOrtho2DMatrix}, - { "Matrix4x4_newFrustumMatrix", _wrap_Matrix4x4_newFrustumMatrix}, - { "Matrix4x4_newPerspectiveMatrix", _wrap_Matrix4x4_newPerspectiveMatrix}, - { "Matrix4x4_newLookAtMatrix", _wrap_Matrix4x4_newLookAtMatrix}, - { "Matrix4x4_getInverseOf", _wrap_Matrix4x4_getInverseOf}, - { "Matrix4x4_getTransposedOf", _wrap_Matrix4x4_getTransposedOf}, - { "Matrix4x4_getOrthoNormalOf", _wrap_Matrix4x4_getOrthoNormalOf}, - { "Matrix4x4_transform3x3", _wrap_Matrix4x4_transform3x3}, - { "Vec2f_zero", _wrap_Vec2f_zero}, - { "Vec2f_one", _wrap_Vec2f_one}, - { "Vec3f_zero", _wrap_Vec3f_zero}, - { "Vec3f_one", _wrap_Vec3f_one}, - { "Vec4f_zero", _wrap_Vec4f_zero}, - { "Vec4f_one", _wrap_Vec4f_one}, - { "getMousePressed", _wrap_getMousePressed}, - { "getKeyPressed", _wrap_getKeyPressed}, - { "getMouseX", _wrap_getMouseX}, - { "getMouseY", _wrap_getMouseY}, - { "getPreviousMouseX", _wrap_getPreviousMouseX}, - { "getPreviousMouseY", _wrap_getPreviousMouseY}, - { "sendMessage", _wrap_sendMessage}, - { "getGlInternalFormat", _wrap_getGlInternalFormat}, - { "getGlInternalFormatName", _wrap_getGlInternalFormatName}, - { "getGLFormatFromInternal", _wrap_getGLFormatFromInternal}, - { "getGlTypeFromInternal", _wrap_getGlTypeFromInternal}, - { "getGlType", _wrap_getGlType}, - { "getImageTypeFromGLType", _wrap_getImageTypeFromGLType}, - { "getGLPolyMode", _wrap_getGLPolyMode}, - { "getOFPolyMode", _wrap_getOFPolyMode}, - { "getGLPrimitiveMode", _wrap_getGLPrimitiveMode}, - { "getOFPrimitiveMode", _wrap_getOFPrimitiveMode}, - { "getGLInternalFormatFromPixelFormat", _wrap_getGLInternalFormatFromPixelFormat}, - { "getGLFormatFromPixelFormat", _wrap_getGLFormatFromPixelFormat}, - { "getBytesPerChannelFromGLType", _wrap_getBytesPerChannelFromGLType}, - { "getNumChannelsFromGLFormat", _wrap_getNumChannelsFromGLFormat}, - { "setPixelStoreiAlignment", _wrap_setPixelStoreiAlignment}, - { "GLSupportedExtensions", _wrap_GLSupportedExtensions}, - { "GLCheckExtension", _wrap_GLCheckExtension}, - { "GLSupportsNPOTTextures", _wrap_GLSupportsNPOTTextures}, - { "isGLProgrammableRenderer", _wrap_isGLProgrammableRenderer}, - { "GLSLVersionFromGL", _wrap_GLSLVersionFromGL}, - { "enableLighting", _wrap_enableLighting}, - { "disableLighting", _wrap_disableLighting}, - { "enableSeparateSpecularLight", _wrap_enableSeparateSpecularLight}, - { "disableSeparateSpecularLight", _wrap_disableSeparateSpecularLight}, - { "getLightingEnabled", _wrap_getLightingEnabled}, - { "setSmoothLighting", _wrap_setSmoothLighting}, - { "setGlobalAmbientColor", _wrap_setGlobalAmbientColor}, - { "getGlobalAmbientColor", _wrap_getGlobalAmbientColor}, - { "lightsData", _wrap_lightsData}, - { "Polyline_fromRectangle", _wrap_Polyline_fromRectangle}, - { "drawBitmapString", _wrap_drawBitmapString}, - { "setColor", _wrap_setColor}, - { "setHexColor", _wrap_setHexColor}, - { "noFill", _wrap_noFill}, - { "fill", _wrap_fill}, - { "getFill", _wrap_getFill}, - { "getBackgroundColor", _wrap_getBackgroundColor}, - { "background", _wrap_background}, - { "backgroundHex", _wrap_backgroundHex}, - { "backgroundGradient", _wrap_backgroundGradient}, - { "setBackgroundColor", _wrap_setBackgroundColor}, - { "setBackgroundColorHex", _wrap_setBackgroundColorHex}, - { "setBackgroundAuto", _wrap_setBackgroundAuto}, - { "getBackgroundAuto", _wrap_getBackgroundAuto}, - { "clear", _wrap_clear}, - { "clearAlpha", _wrap_clearAlpha}, - { "drawTriangle", _wrap_drawTriangle}, - { "drawCircle", _wrap_drawCircle}, - { "drawEllipse", _wrap_drawEllipse}, - { "drawLine", _wrap_drawLine}, - { "drawRectangle", _wrap_drawRectangle}, - { "drawRectRounded", _wrap_drawRectRounded}, - { "drawCurve", _wrap_drawCurve}, - { "drawBezier", _wrap_drawBezier}, - { "beginShape", _wrap_beginShape}, - { "vertex", _wrap_vertex}, - { "vertices", _wrap_vertices}, - { "curveVertex", _wrap_curveVertex}, - { "curveVertices", _wrap_curveVertices}, - { "bezierVertex", _wrap_bezierVertex}, - { "endShape", _wrap_endShape}, - { "nextContour", _wrap_nextContour}, - { "setDrawBitmapMode", _wrap_setDrawBitmapMode}, - { "drawBitmapStringHighlight", _wrap_drawBitmapStringHighlight}, - { "setupGraphicDefaults", _wrap_setupGraphicDefaults}, - { "setupScreen", _wrap_setupScreen}, - { "getRectMode", _wrap_getRectMode}, - { "setCircleResolution", _wrap_setCircleResolution}, - { "setCurveResolution", _wrap_setCurveResolution}, - { "setLineWidth", _wrap_setLineWidth}, - { "setDepthTest", _wrap_setDepthTest}, - { "enableDepthTest", _wrap_enableDepthTest}, - { "disableDepthTest", _wrap_disableDepthTest}, - { "enableBlendMode", _wrap_enableBlendMode}, - { "disableBlendMode", _wrap_disableBlendMode}, - { "enablePointSprites", _wrap_enablePointSprites}, - { "disablePointSprites", _wrap_disablePointSprites}, - { "enableAlphaBlending", _wrap_enableAlphaBlending}, - { "disableAlphaBlending", _wrap_disableAlphaBlending}, - { "enableSmoothing", _wrap_enableSmoothing}, - { "disableSmoothing", _wrap_disableSmoothing}, - { "enableAntiAliasing", _wrap_enableAntiAliasing}, - { "disableAntiAliasing", _wrap_disableAntiAliasing}, - { "getStyle", _wrap_getStyle}, - { "setStyle", _wrap_setStyle}, - { "pushStyle", _wrap_pushStyle}, - { "popStyle", _wrap_popStyle}, - { "setPolyMode", _wrap_setPolyMode}, - { "setRectMode", _wrap_setRectMode}, - { "pushMatrix", _wrap_pushMatrix}, - { "popMatrix", _wrap_popMatrix}, - { "getCurrentMatrix", _wrap_getCurrentMatrix}, - { "getCurrentOrientationMatrix", _wrap_getCurrentOrientationMatrix}, - { "getCurrentNormalMatrix", _wrap_getCurrentNormalMatrix}, - { "translate", _wrap_translate}, - { "scale", _wrap_scale}, - { "rotate", _wrap_rotate}, - { "rotateX", _wrap_rotateX}, - { "rotateY", _wrap_rotateY}, - { "rotateZ", _wrap_rotateZ}, - { "loadIdentityMatrix", _wrap_loadIdentityMatrix}, - { "loadMatrix", _wrap_loadMatrix}, - { "multMatrix", _wrap_multMatrix}, - { "setMatrixMode", _wrap_setMatrixMode}, - { "loadViewMatrix", _wrap_loadViewMatrix}, - { "multViewMatrix", _wrap_multViewMatrix}, - { "getCurrentViewMatrix", _wrap_getCurrentViewMatrix}, - { "pushView", _wrap_pushView}, - { "popView", _wrap_popView}, - { "viewport", _wrap_viewport}, - { "getCurrentViewport", _wrap_getCurrentViewport}, - { "getNativeViewport", _wrap_getNativeViewport}, - { "getViewportWidth", _wrap_getViewportWidth}, - { "getViewportHeight", _wrap_getViewportHeight}, - { "setupScreenPerspective", _wrap_setupScreenPerspective}, - { "setupScreenOrtho", _wrap_setupScreenOrtho}, - { "orientationToDegrees", _wrap_orientationToDegrees}, - { "setCoordHandedness", _wrap_setCoordHandedness}, - { "getCoordHandedness", _wrap_getCoordHandedness}, - { "beginSaveScreenAsPDF", _wrap_beginSaveScreenAsPDF}, - { "endSaveScreenAsPDF", _wrap_endSaveScreenAsPDF}, - { "beginSaveScreenAsSVG", _wrap_beginSaveScreenAsSVG}, - { "endSaveScreenAsSVG", _wrap_endSaveScreenAsSVG}, - { "setPlaneResolution", _wrap_setPlaneResolution}, - { "getPlaneResolution", _wrap_getPlaneResolution}, - { "drawPlane", _wrap_drawPlane}, - { "setSphereResolution", _wrap_setSphereResolution}, - { "getSphereResolution", _wrap_getSphereResolution}, - { "drawSphere", _wrap_drawSphere}, - { "setIcoSphereResolution", _wrap_setIcoSphereResolution}, - { "getIcoSphereResolution", _wrap_getIcoSphereResolution}, - { "drawIcoSphere", _wrap_drawIcoSphere}, - { "setCylinderResolution", _wrap_setCylinderResolution}, - { "getCylinderResolution", _wrap_getCylinderResolution}, - { "drawCylinder", _wrap_drawCylinder}, - { "setConeResolution", _wrap_setConeResolution}, - { "getConeResolution", _wrap_getConeResolution}, - { "drawCone", _wrap_drawCone}, - { "setBoxResolution", _wrap_setBoxResolution}, - { "getBoxResolution", _wrap_getBoxResolution}, - { "drawBox", _wrap_drawBox}, - { "TrueTypeFont_setGlobalDpi", _wrap_TrueTypeFont_setGlobalDpi}, - { "soundStreamSetup", _wrap_soundStreamSetup}, - { "soundStreamStop", _wrap_soundStreamStop}, - { "soundStreamStart", _wrap_soundStreamStart}, - { "soundStreamClose", _wrap_soundStreamClose}, - { "soundStreamListDevices", _wrap_soundStreamListDevices}, - { "Color_fromHsb", _wrap_Color_fromHsb}, - { "Color_fromHex", _wrap_Color_fromHex}, - { "Color_limit", _wrap_Color_limit}, - { "FloatColor_fromHsb", _wrap_FloatColor_fromHsb}, - { "FloatColor_fromHex", _wrap_FloatColor_fromHex}, - { "FloatColor_limit", _wrap_FloatColor_limit}, - { "ShortColor_fromHsb", _wrap_ShortColor_fromHsb}, - { "ShortColor_fromHex", _wrap_ShortColor_fromHex}, - { "ShortColor_limit", _wrap_ShortColor_limit}, - { "Xml_tokenize", _wrap_Xml_tokenize}, - { "bufferFromFile", _wrap_bufferFromFile}, - { "bufferToFile", _wrap_bufferToFile}, - { "FilePath_getFileExt", _wrap_FilePath_getFileExt}, - { "FilePath_removeExt", _wrap_FilePath_removeExt}, - { "FilePath_addLeadingSlash", _wrap_FilePath_addLeadingSlash}, - { "FilePath_addTrailingSlash", _wrap_FilePath_addTrailingSlash}, - { "FilePath_removeTrailingSlash", _wrap_FilePath_removeTrailingSlash}, - { "FilePath_getPathForDirectory", _wrap_FilePath_getPathForDirectory}, - { "FilePath_getAbsolutePath", _wrap_FilePath_getAbsolutePath}, - { "FilePath_isAbsolute", _wrap_FilePath_isAbsolute}, - { "FilePath_getFileName", _wrap_FilePath_getFileName}, - { "FilePath_getBaseName", _wrap_FilePath_getBaseName}, - { "FilePath_getEnclosingDirectory", _wrap_FilePath_getEnclosingDirectory}, - { "FilePath_createEnclosingDirectory", _wrap_FilePath_createEnclosingDirectory}, - { "FilePath_getCurrentWorkingDirectory", _wrap_FilePath_getCurrentWorkingDirectory}, - { "FilePath_join", _wrap_FilePath_join}, - { "FilePath_getCurrentExePath", _wrap_FilePath_getCurrentExePath}, - { "FilePath_getCurrentExeDir", _wrap_FilePath_getCurrentExeDir}, - { "FilePath_getUserHomeDir", _wrap_FilePath_getUserHomeDir}, - { "FilePath_makeRelative", _wrap_FilePath_makeRelative}, - { "File_copyFromTo", _wrap_File_copyFromTo}, - { "File_moveFromTo", _wrap_File_moveFromTo}, - { "File_doesFileExist", _wrap_File_doesFileExist}, - { "File_removeFile", _wrap_File_removeFile}, - { "Directory_createDirectory", _wrap_Directory_createDirectory}, - { "Directory_isDirectoryEmpty", _wrap_Directory_isDirectoryEmpty}, - { "Directory_doesDirectoryExist", _wrap_Directory_doesDirectoryExist}, - { "Directory_removeDirectory", _wrap_Directory_removeDirectory}, - { "log", _wrap_log}, - { "setLogLevel", _wrap_setLogLevel}, - { "getLogLevel", _wrap_getLogLevel}, - { "getLogLevelName", _wrap_getLogLevelName}, - { "logToFile", _wrap_logToFile}, - { "logToConsole", _wrap_logToConsole}, - { "systemAlertDialog", _wrap_systemAlertDialog}, - { "systemLoadDialog", _wrap_systemLoadDialog}, - { "systemSaveDialog", _wrap_systemSaveDialog}, - { "systemTextBoxDialog", _wrap_systemTextBoxDialog}, - { "loadURL", _wrap_loadURL}, - { "loadURLAsync", _wrap_loadURLAsync}, - { "saveURLTo", _wrap_saveURLTo}, - { "saveURLAsync", _wrap_saveURLAsync}, - { "removeURLRequest", _wrap_removeURLRequest}, - { "removeAllURLRequests", _wrap_removeAllURLRequests}, - { "stopURLLoader", _wrap_stopURLLoader}, - { "uRLResponseEvent", _wrap_uRLResponseEvent}, - { "resetElapsedTimeCounter", _wrap_resetElapsedTimeCounter}, - { "getElapsedTimef", _wrap_getElapsedTimef}, - { "getElapsedTimeMillis", _wrap_getElapsedTimeMillis}, - { "getElapsedTimeMicros", _wrap_getElapsedTimeMicros}, - { "getSeconds", _wrap_getSeconds}, - { "getMinutes", _wrap_getMinutes}, - { "getHours", _wrap_getHours}, - { "getUnixTime", _wrap_getUnixTime}, - { "getSystemTime", _wrap_getSystemTime}, - { "getSystemTimeMicros", _wrap_getSystemTimeMicros}, - { "sleepMillis", _wrap_sleepMillis}, - { "getTimestampString", _wrap_getTimestampString}, - { "getYear", _wrap_getYear}, - { "getMonth", _wrap_getMonth}, - { "getDay", _wrap_getDay}, - { "getWeekday", _wrap_getWeekday}, - { "enableDataPath", _wrap_enableDataPath}, - { "disableDataPath", _wrap_disableDataPath}, - { "toDataPath", _wrap_toDataPath}, - { "restoreWorkingDirectoryToDefault", _wrap_restoreWorkingDirectoryToDefault}, - { "setDataPathRoot", _wrap_setDataPathRoot}, - { "splitString", _wrap_splitString}, - { "joinString", _wrap_joinString}, - { "stringReplace", _wrap_stringReplace}, - { "isStringInString", _wrap_isStringInString}, - { "stringTimesInString", _wrap_stringTimesInString}, - { "toLower", _wrap_toLower}, - { "toUpper", _wrap_toUpper}, - { "trimFront", _wrap_trimFront}, - { "trimBack", _wrap_trimBack}, - { "trim", _wrap_trim}, - { "appendUTF8", _wrap_appendUTF8}, - { "toInt", _wrap_toInt}, - { "toInt64", _wrap_toInt64}, - { "toFloat", _wrap_toFloat}, - { "toDouble", _wrap_toDouble}, - { "toBool", _wrap_toBool}, - { "toHex", _wrap_toHex}, - { "hexToInt", _wrap_hexToInt}, - { "hexToChar", _wrap_hexToChar}, - { "hexToFloat", _wrap_hexToFloat}, - { "hexToString", _wrap_hexToString}, - { "toChar", _wrap_toChar}, - { "toBinary", _wrap_toBinary}, - { "binaryToInt", _wrap_binaryToInt}, - { "binaryToChar", _wrap_binaryToChar}, - { "binaryToFloat", _wrap_binaryToFloat}, - { "binaryToString", _wrap_binaryToString}, - { "getVersionInfo", _wrap_getVersionInfo}, - { "getVersionMajor", _wrap_getVersionMajor}, - { "getVersionMinor", _wrap_getVersionMinor}, - { "getVersionPatch", _wrap_getVersionPatch}, - { "getVersionPreRelease", _wrap_getVersionPreRelease}, - { "saveScreen", _wrap_saveScreen}, - { "saveFrame", _wrap_saveFrame}, - { "saveViewport", _wrap_saveViewport}, - { "launchBrowser", _wrap_launchBrowser}, - { "system", _wrap_system}, - { "getTargetPlatform", _wrap_getTargetPlatform}, - { "getEnv", _wrap_getEnv}, - {0,0} -}; -static swig_lua_class* swig_SwigModule_classes[]= { -&_wrap_class_string, -&_wrap_class_path, -&_wrap_class_IntVector, -&_wrap_class_FloatVector, -&_wrap_class_StringVector, -&_wrap_class_UCharVector, -&_wrap_class_VideoDeviceVector, -&_wrap_class_TextureVector, -&_wrap_class_Fbo, -&_wrap_class_TextureData, -&_wrap_class_Texture, -&_wrap_class_Image, -&_wrap_class_FloatImage, -&_wrap_class_ShortImage, -&_wrap_class_Node, -&_wrap_class_Camera, -&_wrap_class_EasyCam, -&_wrap_class_Mesh, -&_wrap_class_MeshFace, -&_wrap_class_3dPrimitive, -&_wrap_class_PlanePrimitive, -&_wrap_class_SpherePrimitive, -&_wrap_class_IcoSpherePrimitive, -&_wrap_class_CylinderPrimitive, -&_wrap_class_ConePrimitive, -&_wrap_class_BoxPrimitive, -&_wrap_class_Arduino, -&_wrap_class_Serial, -&_wrap_class_Matrix3x3, -&_wrap_class_Matrix4x4, -&_wrap_class_Quaternion, -&_wrap_class_Vec2f, -&_wrap_class_Vec3f, -&_wrap_class_Vec4f, -&_wrap_class_DragInfo, -&_wrap_class_TouchEventArgs, -&_wrap_class_BufferObject, -&_wrap_class_Light, -&_wrap_class_Material, -&_wrap_class_Shader, -&_wrap_class_Vbo, -&_wrap_class_VboMesh, -&_wrap_class_Pixels, -&_wrap_class_FloatPixels, -&_wrap_class_ShortPixels, -&_wrap_class_Path, -&_wrap_class_Polyline, -&_wrap_class_TrueTypeFont, -&_wrap_class_SoundStream, -&_wrap_class_SoundPlayer, -&_wrap_class_Color, -&_wrap_class_FloatColor, -&_wrap_class_ShortColor, -&_wrap_class_Rectangle, -&_wrap_class_SerialDeviceInfo, -&_wrap_class_Style, -&_wrap_class_FpsCounter, -&_wrap_class_Xml, -&_wrap_class_MatrixStack, -&_wrap_class_Buffer, -&_wrap_class_FilePath, -&_wrap_class_File, -&_wrap_class_Directory, -&_wrap_class_FileDialogResult, -&_wrap_class_HttpRequest, -&_wrap_class_HttpResponse, -&_wrap_class_URLFileLoader, -&_wrap_class_VideoGrabber, -&_wrap_class_VideoPlayer, - 0 -}; -static swig_lua_namespace* swig_SwigModule_namespaces[] = { - 0 -}; - -static swig_lua_namespace swig_SwigModule = { - "of", - swig_SwigModule_methods, - swig_SwigModule_attributes, - swig_SwigModule_constants, - swig_SwigModule_classes, - swig_SwigModule_namespaces -}; -#ifdef __cplusplus -} -#endif - -/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */ - -static void *_p_ofImage_T_unsigned_char_tTo_p_ofBaseImage_T_unsigned_char_t(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseImage_< unsigned char > *) ((ofImage_< unsigned char > *) x)); -} -static void *_p_ofImage_T_float_tTo_p_ofBaseImage_T_float_t(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseImage_< float > *) ((ofImage_< float > *) x)); -} -static void *_p_ofMaterialTo_p_ofBaseMaterial(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseMaterial *) ((ofMaterial *) x)); -} -static void *_p_ofSoundPlayerTo_p_ofBaseSoundPlayer(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseSoundPlayer *) ((ofSoundPlayer *) x)); -} -static void *_p_ofEasyCamTo_p_ofCamera(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofCamera *) ((ofEasyCam *) x)); -} -static void *_p_ofBaseVideoDrawsTo_p_ofBaseHasTexturePlanes(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseHasTexturePlanes *) ((ofBaseVideoDraws *) x)); -} -static void *_p_ofVideoGrabberTo_p_ofBaseHasTexturePlanes(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseHasTexturePlanes *) (ofBaseVideoDraws *) ((ofVideoGrabber *) x)); -} -static void *_p_ofVideoPlayerTo_p_ofBaseHasTexturePlanes(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseHasTexturePlanes *) (ofBaseVideoDraws *) ((ofVideoPlayer *) x)); -} -static void *_p_ofMouseEventArgsTo_p_ofVec2f(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofVec2f *) ((ofMouseEventArgs *) x)); -} -static void *_p_ofTouchEventArgsTo_p_ofVec2f(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofVec2f *) ((ofTouchEventArgs *) x)); -} -static void *_p_ofPlanePrimitiveTo_p_of3dPrimitive(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((of3dPrimitive *) ((ofPlanePrimitive *) x)); -} -static void *_p_ofSpherePrimitiveTo_p_of3dPrimitive(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((of3dPrimitive *) ((ofSpherePrimitive *) x)); -} -static void *_p_ofIcoSpherePrimitiveTo_p_of3dPrimitive(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((of3dPrimitive *) ((ofIcoSpherePrimitive *) x)); -} -static void *_p_ofCylinderPrimitiveTo_p_of3dPrimitive(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((of3dPrimitive *) ((ofCylinderPrimitive *) x)); -} -static void *_p_ofConePrimitiveTo_p_of3dPrimitive(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((of3dPrimitive *) ((ofConePrimitive *) x)); -} -static void *_p_ofBoxPrimitiveTo_p_of3dPrimitive(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((of3dPrimitive *) ((ofBoxPrimitive *) x)); -} -static void *_p_ofVideoPlayerTo_p_ofBaseVideoPlayer(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseVideoPlayer *) ((ofVideoPlayer *) x)); -} -static void *_p_of3dPrimitiveTo_p_ofNode(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofNode *) ((of3dPrimitive *) x)); -} -static void *_p_ofPlanePrimitiveTo_p_ofNode(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofNode *) (of3dPrimitive *) ((ofPlanePrimitive *) x)); -} -static void *_p_ofSpherePrimitiveTo_p_ofNode(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofNode *) (of3dPrimitive *) ((ofSpherePrimitive *) x)); -} -static void *_p_ofIcoSpherePrimitiveTo_p_ofNode(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofNode *) (of3dPrimitive *) ((ofIcoSpherePrimitive *) x)); -} -static void *_p_ofCylinderPrimitiveTo_p_ofNode(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofNode *) (of3dPrimitive *) ((ofCylinderPrimitive *) x)); -} -static void *_p_ofConePrimitiveTo_p_ofNode(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofNode *) (of3dPrimitive *) ((ofConePrimitive *) x)); -} -static void *_p_ofBoxPrimitiveTo_p_ofNode(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofNode *) (of3dPrimitive *) ((ofBoxPrimitive *) x)); -} -static void *_p_ofEasyCamTo_p_ofNode(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofNode *) (ofCamera *) ((ofEasyCam *) x)); -} -static void *_p_ofLightTo_p_ofNode(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofNode *) ((ofLight *) x)); -} -static void *_p_ofCameraTo_p_ofNode(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofNode *) ((ofCamera *) x)); -} -static void *_p_ofConsoleLoggerChannelTo_p_ofBaseLoggerChannel(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseLoggerChannel *) ((ofConsoleLoggerChannel *) x)); -} -static void *_p_ofFileLoggerChannelTo_p_ofBaseLoggerChannel(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseLoggerChannel *) ((ofFileLoggerChannel *) x)); -} -static void *_p_ofBaseVideoDrawsTo_p_ofBaseVideo(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseVideo *) ((ofBaseVideoDraws *) x)); -} -static void *_p_ofBaseVideoGrabberTo_p_ofBaseVideo(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseVideo *) ((ofBaseVideoGrabber *) x)); -} -static void *_p_ofVideoGrabberTo_p_ofBaseVideo(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseVideo *) (ofBaseVideoGrabber *) ((ofVideoGrabber *) x)); -} -static void *_p_ofBaseVideoPlayerTo_p_ofBaseVideo(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseVideo *) ((ofBaseVideoPlayer *) x)); -} -static void *_p_ofVideoPlayerTo_p_ofBaseVideo(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseVideo *) (ofBaseVideoPlayer *) ((ofVideoPlayer *) x)); -} -static void *_p_ofVboMeshTo_p_ofMesh(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofMesh *) ((ofVboMesh *) x)); -} -static void *_p_ofFileTo_p_fstream(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((fstream *) ((ofFile *) x)); -} -static void *_p_ofAbstractImageTo_p_ofBaseHasTexture(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseHasTexture *) ((ofAbstractImage *) x)); -} -static void *_p_ofBaseVideoDrawsTo_p_ofBaseHasTexture(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseHasTexture *) (ofBaseHasTexturePlanes *) ((ofBaseVideoDraws *) x)); -} -static void *_p_ofVideoGrabberTo_p_ofBaseHasTexture(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseHasTexture *) (ofBaseHasTexturePlanes *)(ofBaseVideoDraws *) ((ofVideoGrabber *) x)); -} -static void *_p_ofFboTo_p_ofBaseHasTexture(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseHasTexture *) ((ofFbo *) x)); -} -static void *_p_ofBaseHasTexturePlanesTo_p_ofBaseHasTexture(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseHasTexture *) ((ofBaseHasTexturePlanes *) x)); -} -static void *_p_ofVideoPlayerTo_p_ofBaseHasTexture(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseHasTexture *) (ofBaseHasTexturePlanes *)(ofBaseVideoDraws *) ((ofVideoPlayer *) x)); -} -static void *_p_ofXmlTo_p_ofBaseFileSerializer(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseFileSerializer *) ((ofXml *) x)); -} -static void *_p_ofBaseFileSerializerTo_p_ofBaseSerializer(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseSerializer *) ((ofBaseFileSerializer *) x)); -} -static void *_p_ofXmlTo_p_ofBaseSerializer(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseSerializer *) (ofBaseFileSerializer *) ((ofXml *) x)); -} -static void *_p_ofBaseGLRendererTo_p_ofBaseRenderer(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseRenderer *) ((ofBaseGLRenderer *) x)); -} -static void *_p_ofKeyEventArgsTo_p_ofEventArgs(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofEventArgs *) ((ofKeyEventArgs *) x)); -} -static void *_p_ofMouseEventArgsTo_p_ofEventArgs(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofEventArgs *) ((ofMouseEventArgs *) x)); -} -static void *_p_ofTouchEventArgsTo_p_ofEventArgs(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofEventArgs *) ((ofTouchEventArgs *) x)); -} -static void *_p_ofResizeEventArgsTo_p_ofEventArgs(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofEventArgs *) ((ofResizeEventArgs *) x)); -} -static void *_p_ofMessageTo_p_ofEventArgs(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofEventArgs *) ((ofMessage *) x)); -} -static void *_p_ofAbstractImageTo_p_ofBaseDraws(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseDraws *) ((ofAbstractImage *) x)); -} -static void *_p_ofBaseVideoDrawsTo_p_ofBaseDraws(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseDraws *) ((ofBaseVideoDraws *) x)); -} -static void *_p_ofVideoGrabberTo_p_ofBaseDraws(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseDraws *) (ofBaseVideoDraws *) ((ofVideoGrabber *) x)); -} -static void *_p_ofTextureTo_p_ofBaseDraws(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseDraws *) ((ofTexture *) x)); -} -static void *_p_ofFboTo_p_ofBaseDraws(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseDraws *) ((ofFbo *) x)); -} -static void *_p_ofVideoPlayerTo_p_ofBaseDraws(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseDraws *) (ofBaseVideoDraws *) ((ofVideoPlayer *) x)); -} -static void *_p_ofVideoGrabberTo_p_ofBaseVideoGrabber(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseVideoGrabber *) ((ofVideoGrabber *) x)); -} -static void *_p_ofVideoGrabberTo_p_ofBaseVideoDraws(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseVideoDraws *) ((ofVideoGrabber *) x)); -} -static void *_p_ofVideoPlayerTo_p_ofBaseVideoDraws(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseVideoDraws *) ((ofVideoPlayer *) x)); -} -static void *_p_ofLogErrorTo_p_ofLog(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofLog *) ((ofLogError *) x)); -} -static void *_p_ofLogNoticeTo_p_ofLog(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofLog *) ((ofLogNotice *) x)); -} -static void *_p_ofLogFatalErrorTo_p_ofLog(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofLog *) ((ofLogFatalError *) x)); -} -static void *_p_ofLogVerboseTo_p_ofLog(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofLog *) ((ofLogVerbose *) x)); -} -static void *_p_ofLogWarningTo_p_ofLog(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofLog *) ((ofLogWarning *) x)); -} -static void *_p_ofBaseVideoDrawsTo_p_ofBaseHasPixels(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseHasPixels *) (ofBaseVideo *) ((ofBaseVideoDraws *) x)); -} -static void *_p_ofBaseVideoGrabberTo_p_ofBaseHasPixels(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseHasPixels *) (ofBaseVideo *) ((ofBaseVideoGrabber *) x)); -} -static void *_p_ofVideoGrabberTo_p_ofBaseHasPixels(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseHasPixels *) (ofBaseVideo *)(ofBaseVideoGrabber *) ((ofVideoGrabber *) x)); -} -static void *_p_ofBaseVideoTo_p_ofBaseHasPixels(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseHasPixels *) ((ofBaseVideo *) x)); -} -static void *_p_ofBaseVideoPlayerTo_p_ofBaseHasPixels(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseHasPixels *) (ofBaseVideo *) ((ofBaseVideoPlayer *) x)); -} -static void *_p_ofVideoPlayerTo_p_ofBaseHasPixels(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseHasPixels *) (ofBaseVideo *)(ofBaseVideoPlayer *) ((ofVideoPlayer *) x)); -} -static void *_p_ofImage_T_unsigned_short_tTo_p_ofBaseImage_T_unsigned_short_t(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseImage_< unsigned short > *) ((ofImage_< unsigned short > *) x)); -} -static void *_p_ofBaseVideoDrawsTo_p_ofBaseUpdates(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseUpdates *) (ofBaseVideo *) ((ofBaseVideoDraws *) x)); -} -static void *_p_ofBaseVideoGrabberTo_p_ofBaseUpdates(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseUpdates *) (ofBaseVideo *) ((ofBaseVideoGrabber *) x)); -} -static void *_p_ofVideoGrabberTo_p_ofBaseUpdates(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseUpdates *) (ofBaseVideo *)(ofBaseVideoGrabber *) ((ofVideoGrabber *) x)); -} -static void *_p_ofBaseVideoTo_p_ofBaseUpdates(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseUpdates *) ((ofBaseVideo *) x)); -} -static void *_p_ofBaseVideoPlayerTo_p_ofBaseUpdates(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseUpdates *) (ofBaseVideo *) ((ofBaseVideoPlayer *) x)); -} -static void *_p_ofVideoPlayerTo_p_ofBaseUpdates(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseUpdates *) (ofBaseVideo *)(ofBaseVideoPlayer *) ((ofVideoPlayer *) x)); -} -static swig_type_info _swigt__p_GLintptr = {"_p_GLintptr", "GLintptr *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_GLsizei = {"_p_GLsizei", "GLsizei *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_GLsizeiptr = {"_p_GLsizeiptr", "GLsizeiptr *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_double = {"_p_double", "double *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_float = {"_p_float", "float *|GLfloat *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_fstream = {"_p_fstream", "fstream *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_int = {"_p_int", "int *|GLint *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_long_long = {"_p_long_long", "int64_t *|long long *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_of3dPrimitive = {"_p_of3dPrimitive", "of3dPrimitive *", 0, 0, (void*)&_wrap_class_3dPrimitive, 0}; -static swig_type_info _swigt__p_ofAbstractParameter = {"_p_ofAbstractParameter", "ofAbstractParameter *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofAppBaseWindow = {"_p_ofAppBaseWindow", "ofAppBaseWindow *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofArduino = {"_p_ofArduino", "ofArduino *|ofStandardFirmata *", 0, 0, (void*)&_wrap_class_Arduino, 0}; -static swig_type_info _swigt__p_ofBaseApp = {"_p_ofBaseApp", "ofSimpleApp *|ofBaseApp *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofBaseDraws = {"_p_ofBaseDraws", "ofBaseDraws *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofAbstractImage = {"_p_ofAbstractImage", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_ofBaseFileSerializer = {"_p_ofBaseFileSerializer", "ofBaseFileSerializer *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofBaseHasPixels = {"_p_ofBaseHasPixels", "ofBaseHasPixels *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofBaseHasTexture = {"_p_ofBaseHasTexture", "ofBaseHasTexture *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofBaseHasTexturePlanes = {"_p_ofBaseHasTexturePlanes", "ofBaseHasTexturePlanes *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofBaseImage_T_float_t = {"_p_ofBaseImage_T_float_t", "ofBaseImage_< float > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofBaseImage_T_unsigned_char_t = {"_p_ofBaseImage_T_unsigned_char_t", "ofBaseImage_< unsigned char > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofBaseImage_T_unsigned_short_t = {"_p_ofBaseImage_T_unsigned_short_t", "ofBaseImage_< unsigned short > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofBaseLoggerChannel = {"_p_ofBaseLoggerChannel", "ofBaseLoggerChannel *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofConsoleLoggerChannel = {"_p_ofConsoleLoggerChannel", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_ofFileLoggerChannel = {"_p_ofFileLoggerChannel", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_ofBaseMaterial = {"_p_ofBaseMaterial", "ofBaseMaterial *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofBaseRenderer = {"_p_ofBaseRenderer", "ofBaseRenderer *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofBaseGLRenderer = {"_p_ofBaseGLRenderer", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_ofBaseSerializer = {"_p_ofBaseSerializer", "ofBaseSerializer *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofBaseSoundInput = {"_p_ofBaseSoundInput", "ofBaseSoundInput *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofBaseSoundOutput = {"_p_ofBaseSoundOutput", "ofBaseSoundOutput *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofBaseSoundPlayer = {"_p_ofBaseSoundPlayer", "ofBaseSoundPlayer *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofBaseUpdates = {"_p_ofBaseUpdates", "ofBaseUpdates *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofBaseVideo = {"_p_ofBaseVideo", "ofBaseVideo *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofBaseVideoDraws = {"_p_ofBaseVideoDraws", "ofBaseVideoDraws *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofBaseVideoGrabber = {"_p_ofBaseVideoGrabber", "ofBaseVideoGrabber *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofBaseVideoPlayer = {"_p_ofBaseVideoPlayer", "ofBaseVideoPlayer *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofBoxPrimitive = {"_p_ofBoxPrimitive", "ofBoxPrimitive *", 0, 0, (void*)&_wrap_class_BoxPrimitive, 0}; -static swig_type_info _swigt__p_ofBuffer = {"_p_ofBuffer", "ofBuffer *", 0, 0, (void*)&_wrap_class_Buffer, 0}; -static swig_type_info _swigt__p_ofBufferObject = {"_p_ofBufferObject", "ofBufferObject *", 0, 0, (void*)&_wrap_class_BufferObject, 0}; -static swig_type_info _swigt__p_ofCamera = {"_p_ofCamera", "ofCamera *", 0, 0, (void*)&_wrap_class_Camera, 0}; -static swig_type_info _swigt__p_ofColor_T_float_t = {"_p_ofColor_T_float_t", "ofColor_< float > *|ofFloatColor *", 0, 0, (void*)&_wrap_class_FloatColor, 0}; -static swig_type_info _swigt__p_ofColor_T_unsigned_char_t = {"_p_ofColor_T_unsigned_char_t", "ofColor_< unsigned char > *|ofColor *", 0, 0, (void*)&_wrap_class_Color, 0}; -static swig_type_info _swigt__p_ofColor_T_unsigned_short_t = {"_p_ofColor_T_unsigned_short_t", "ofColor_< unsigned short > *|ofShortColor *", 0, 0, (void*)&_wrap_class_ShortColor, 0}; -static swig_type_info _swigt__p_ofConePrimitive = {"_p_ofConePrimitive", "ofConePrimitive *", 0, 0, (void*)&_wrap_class_ConePrimitive, 0}; -static swig_type_info _swigt__p_ofCoreEvents = {"_p_ofCoreEvents", "ofCoreEvents *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofCylinderPrimitive = {"_p_ofCylinderPrimitive", "ofCylinderPrimitive *", 0, 0, (void*)&_wrap_class_CylinderPrimitive, 0}; -static swig_type_info _swigt__p_ofDirectory = {"_p_ofDirectory", "ofDirectory *", 0, 0, (void*)&_wrap_class_Directory, 0}; -static swig_type_info _swigt__p_ofDragInfo = {"_p_ofDragInfo", "ofDragInfo *", 0, 0, (void*)&_wrap_class_DragInfo, 0}; -static swig_type_info _swigt__p_ofEasyCam = {"_p_ofEasyCam", "ofEasyCam *", 0, 0, (void*)&_wrap_class_EasyCam, 0}; -static swig_type_info _swigt__p_ofEventArgs = {"_p_ofEventArgs", "ofEventArgs *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofKeyEventArgs = {"_p_ofKeyEventArgs", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_ofMouseEventArgs = {"_p_ofMouseEventArgs", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_ofResizeEventArgs = {"_p_ofResizeEventArgs", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_ofMessage = {"_p_ofMessage", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_ofEventT_int_const_t = {"_p_ofEventT_int_const_t", "ofEvent< int const > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofEventT_ofHttpResponse_t = {"_p_ofEventT_ofHttpResponse_t", "ofEvent< ofHttpResponse > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofEventT_std__string_const_t = {"_p_ofEventT_std__string_const_t", "ofEvent< std::string const > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofEventT_std__vectorT_unsigned_char_t_const_t = {"_p_ofEventT_std__vectorT_unsigned_char_t_const_t", "ofEvent< std::vector< unsigned char > const > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofFbo = {"_p_ofFbo", "ofFbo *", 0, 0, (void*)&_wrap_class_Fbo, 0}; -static swig_type_info _swigt__p_ofFbo__Settings = {"_p_ofFbo__Settings", "ofFbo::Settings *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofFile = {"_p_ofFile", "ofFile *", 0, 0, (void*)&_wrap_class_File, 0}; -static swig_type_info _swigt__p_ofFileDialogResult = {"_p_ofFileDialogResult", "ofFileDialogResult *", 0, 0, (void*)&_wrap_class_FileDialogResult, 0}; -static swig_type_info _swigt__p_ofFilePath = {"_p_ofFilePath", "ofFilePath *", 0, 0, (void*)&_wrap_class_FilePath, 0}; -static swig_type_info _swigt__p_ofFpsCounter = {"_p_ofFpsCounter", "ofFpsCounter *", 0, 0, (void*)&_wrap_class_FpsCounter, 0}; -static swig_type_info _swigt__p_ofHttpRequest = {"_p_ofHttpRequest", "ofHttpRequest *", 0, 0, (void*)&_wrap_class_HttpRequest, 0}; -static swig_type_info _swigt__p_ofHttpResponse = {"_p_ofHttpResponse", "ofHttpResponse *", 0, 0, (void*)&_wrap_class_HttpResponse, 0}; -static swig_type_info _swigt__p_ofIcoSpherePrimitive = {"_p_ofIcoSpherePrimitive", "ofIcoSpherePrimitive *", 0, 0, (void*)&_wrap_class_IcoSpherePrimitive, 0}; -static swig_type_info _swigt__p_ofImage_T_float_t = {"_p_ofImage_T_float_t", "ofFloatImage *|ofImage_< float > *", 0, 0, (void*)&_wrap_class_FloatImage, 0}; -static swig_type_info _swigt__p_ofImage_T_unsigned_char_t = {"_p_ofImage_T_unsigned_char_t", "ofImage *|ofImage_< unsigned char > *", 0, 0, (void*)&_wrap_class_Image, 0}; -static swig_type_info _swigt__p_ofImage_T_unsigned_short_t = {"_p_ofImage_T_unsigned_short_t", "ofImage_< unsigned short > *|ofShortImage *", 0, 0, (void*)&_wrap_class_ShortImage, 0}; -static swig_type_info _swigt__p_ofLight = {"_p_ofLight", "ofLight *", 0, 0, (void*)&_wrap_class_Light, 0}; -static swig_type_info _swigt__p_ofLog = {"_p_ofLog", "ofLog *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofLogError = {"_p_ofLogError", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_ofLogNotice = {"_p_ofLogNotice", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_ofLogFatalError = {"_p_ofLogFatalError", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_ofLogVerbose = {"_p_ofLogVerbose", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_ofLogWarning = {"_p_ofLogWarning", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_ofMaterial = {"_p_ofMaterial", "ofMaterial *", 0, 0, (void*)&_wrap_class_Material, 0}; -static swig_type_info _swigt__p_ofMatrix3x3 = {"_p_ofMatrix3x3", "ofMatrix3x3 *", 0, 0, (void*)&_wrap_class_Matrix3x3, 0}; -static swig_type_info _swigt__p_ofMatrix4x4 = {"_p_ofMatrix4x4", "ofMatrix4x4 *", 0, 0, (void*)&_wrap_class_Matrix4x4, 0}; -static swig_type_info _swigt__p_ofMatrixStack = {"_p_ofMatrixStack", "ofMatrixStack *", 0, 0, (void*)&_wrap_class_MatrixStack, 0}; -static swig_type_info _swigt__p_ofMesh = {"_p_ofMesh", "ofMesh *", 0, 0, (void*)&_wrap_class_Mesh, 0}; -static swig_type_info _swigt__p_ofMeshFace = {"_p_ofMeshFace", "ofMeshFace *", 0, 0, (void*)&_wrap_class_MeshFace, 0}; -static swig_type_info _swigt__p_ofNode = {"_p_ofNode", "ofNode *", 0, 0, (void*)&_wrap_class_Node, 0}; -static swig_type_info _swigt__p_ofParameterGroup = {"_p_ofParameterGroup", "ofParameterGroup *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofPath = {"_p_ofPath", "ofTTFCharacter *|ofPath *", 0, 0, (void*)&_wrap_class_Path, 0}; -static swig_type_info _swigt__p_ofPixels_T_float_t = {"_p_ofPixels_T_float_t", "ofPixels_< float > *|ofFloatPixels *", 0, 0, (void*)&_wrap_class_FloatPixels, 0}; -static swig_type_info _swigt__p_ofPixels_T_unsigned_char_t = {"_p_ofPixels_T_unsigned_char_t", "ofPixels_< unsigned char > *|ofPixels *", 0, 0, (void*)&_wrap_class_Pixels, 0}; -static swig_type_info _swigt__p_ofPixels_T_unsigned_short_t = {"_p_ofPixels_T_unsigned_short_t", "ofPixels_< unsigned short > *|ofShortPixels *", 0, 0, (void*)&_wrap_class_ShortPixels, 0}; -static swig_type_info _swigt__p_ofPlanePrimitive = {"_p_ofPlanePrimitive", "ofPlanePrimitive *", 0, 0, (void*)&_wrap_class_PlanePrimitive, 0}; -static swig_type_info _swigt__p_ofPolyline = {"_p_ofPolyline", "ofPolyline *", 0, 0, (void*)&_wrap_class_Polyline, 0}; -static swig_type_info _swigt__p_ofQuaternion = {"_p_ofQuaternion", "ofQuaternion *", 0, 0, (void*)&_wrap_class_Quaternion, 0}; -static swig_type_info _swigt__p_ofRectangle = {"_p_ofRectangle", "ofRectangle *", 0, 0, (void*)&_wrap_class_Rectangle, 0}; -static swig_type_info _swigt__p_ofSerial = {"_p_ofSerial", "ofSerial *", 0, 0, (void*)&_wrap_class_Serial, 0}; -static swig_type_info _swigt__p_ofSerialDeviceInfo = {"_p_ofSerialDeviceInfo", "ofSerialDeviceInfo *", 0, 0, (void*)&_wrap_class_SerialDeviceInfo, 0}; -static swig_type_info _swigt__p_ofShader = {"_p_ofShader", "ofShader *", 0, 0, (void*)&_wrap_class_Shader, 0}; -static swig_type_info _swigt__p_ofSoundDevice = {"_p_ofSoundDevice", "ofSoundDevice *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofSoundPlayer = {"_p_ofSoundPlayer", "ofSoundPlayer *", 0, 0, (void*)&_wrap_class_SoundPlayer, 0}; -static swig_type_info _swigt__p_ofSoundStream = {"_p_ofSoundStream", "ofSoundStream *", 0, 0, (void*)&_wrap_class_SoundStream, 0}; -static swig_type_info _swigt__p_ofSpherePrimitive = {"_p_ofSpherePrimitive", "ofSpherePrimitive *", 0, 0, (void*)&_wrap_class_SpherePrimitive, 0}; -static swig_type_info _swigt__p_ofStyle = {"_p_ofStyle", "ofStyle *", 0, 0, (void*)&_wrap_class_Style, 0}; -static swig_type_info _swigt__p_ofTexture = {"_p_ofTexture", "ofTexture *", 0, 0, (void*)&_wrap_class_Texture, 0}; -static swig_type_info _swigt__p_ofTextureData = {"_p_ofTextureData", "ofTextureData *", 0, 0, (void*)&_wrap_class_TextureData, 0}; -static swig_type_info _swigt__p_ofTouchEventArgs = {"_p_ofTouchEventArgs", "ofTouchEventArgs *", 0, 0, (void*)&_wrap_class_TouchEventArgs, 0}; -static swig_type_info _swigt__p_ofTrueTypeFont = {"_p_ofTrueTypeFont", "ofTrueTypeFont *", 0, 0, (void*)&_wrap_class_TrueTypeFont, 0}; -static swig_type_info _swigt__p_ofURLFileLoader = {"_p_ofURLFileLoader", "ofURLFileLoader *", 0, 0, (void*)&_wrap_class_URLFileLoader, 0}; -static swig_type_info _swigt__p_ofVbo = {"_p_ofVbo", "ofVbo *", 0, 0, (void*)&_wrap_class_Vbo, 0}; -static swig_type_info _swigt__p_ofVboMesh = {"_p_ofVboMesh", "ofVboMesh *", 0, 0, (void*)&_wrap_class_VboMesh, 0}; -static swig_type_info _swigt__p_ofVec2f = {"_p_ofVec2f", "ofVec2f *", 0, 0, (void*)&_wrap_class_Vec2f, 0}; -static swig_type_info _swigt__p_ofVec3f = {"_p_ofVec3f", "ofPoint *|ofVec3f *", 0, 0, (void*)&_wrap_class_Vec3f, 0}; -static swig_type_info _swigt__p_ofVec4f = {"_p_ofVec4f", "ofVec4f *", 0, 0, (void*)&_wrap_class_Vec4f, 0}; -static swig_type_info _swigt__p_ofVideoDevice = {"_p_ofVideoDevice", "ofVideoDevice *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofVideoGrabber = {"_p_ofVideoGrabber", "ofVideoGrabber *", 0, 0, (void*)&_wrap_class_VideoGrabber, 0}; -static swig_type_info _swigt__p_ofVideoPlayer = {"_p_ofVideoPlayer", "ofVideoPlayer *", 0, 0, (void*)&_wrap_class_VideoPlayer, 0}; -static swig_type_info _swigt__p_ofXml = {"_p_ofXml", "ofXml *", 0, 0, (void*)&_wrap_class_Xml, 0}; -static swig_type_info _swigt__p_shared_ptrT_ofBaseRenderer_t = {"_p_shared_ptrT_ofBaseRenderer_t", "shared_ptr< ofBaseRenderer > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_shared_ptrT_ofBaseSoundPlayer_t = {"_p_shared_ptrT_ofBaseSoundPlayer_t", "shared_ptr< ofBaseSoundPlayer > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_shared_ptrT_ofBaseSoundStream_t = {"_p_shared_ptrT_ofBaseSoundStream_t", "shared_ptr< ofBaseSoundStream > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_shared_ptrT_ofBaseVideoGrabber_t = {"_p_shared_ptrT_ofBaseVideoGrabber_t", "shared_ptr< ofBaseVideoGrabber > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_std__filesystem__path = {"_p_std__filesystem__path", "std::filesystem::path *", 0, 0, (void*)&_wrap_class_path, 0}; -static swig_type_info _swigt__p_std__mapT_std__string_std__string_t = {"_p_std__mapT_std__string_std__string_t", "std::map< std::string,std::string > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_std__string = {"_p_std__string", "std::string *", 0, 0, (void*)&_wrap_class_string, 0}; -static swig_type_info _swigt__p_std__vectorT_float_t = {"_p_std__vectorT_float_t", "std::vector< float > *", 0, 0, (void*)&_wrap_class_FloatVector, 0}; -static swig_type_info _swigt__p_std__vectorT_int_t = {"_p_std__vectorT_int_t", "std::vector< int > *", 0, 0, (void*)&_wrap_class_IntVector, 0}; -static swig_type_info _swigt__p_std__vectorT_ofColor_T_float_t_t = {"_p_std__vectorT_ofColor_T_float_t_t", "std::vector< ofColor_< float > > *|std::vector< ofFloatColor > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_std__vectorT_ofFile_t = {"_p_std__vectorT_ofFile_t", "std::vector< ofFile > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_std__vectorT_ofMeshFace_t = {"_p_std__vectorT_ofMeshFace_t", "std::vector< ofMeshFace > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_std__vectorT_ofPath__Command_t = {"_p_std__vectorT_ofPath__Command_t", "std::vector< ofPath::Command > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_std__vectorT_ofPath_t = {"_p_std__vectorT_ofPath_t", "std::vector< ofTTFCharacter > *|std::vector< ofPath > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_std__vectorT_ofPolyline_t = {"_p_std__vectorT_ofPolyline_t", "std::vector< ofPolyline > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_std__vectorT_ofSerialDeviceInfo_t = {"_p_std__vectorT_ofSerialDeviceInfo_t", "std::vector< ofSerialDeviceInfo > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_std__vectorT_ofSoundDevice_t = {"_p_std__vectorT_ofSoundDevice_t", "std::vector< ofSoundDevice > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_std__vectorT_ofTexture_t = {"_p_std__vectorT_ofTexture_t", "std::vector< ofTexture > *", 0, 0, (void*)&_wrap_class_TextureVector, 0}; -static swig_type_info _swigt__p_std__vectorT_ofVec2f_t = {"_p_std__vectorT_ofVec2f_t", "std::vector< ofVec2f > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_std__vectorT_ofVec3f_t = {"_p_std__vectorT_ofVec3f_t", "std::vector< ofVec3f > *|std::vector< ofPoint > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_std__vectorT_ofVideoDevice_t = {"_p_std__vectorT_ofVideoDevice_t", "std::vector< ofVideoDevice > *", 0, 0, (void*)&_wrap_class_VideoDeviceVector, 0}; -static swig_type_info _swigt__p_std__vectorT_std__string_t = {"_p_std__vectorT_std__string_t", "std::vector< std::string > *", 0, 0, (void*)&_wrap_class_StringVector, 0}; -static swig_type_info _swigt__p_std__vectorT_unsigned_char_t = {"_p_std__vectorT_unsigned_char_t", "std::vector< unsigned char > *", 0, 0, (void*)&_wrap_class_UCharVector, 0}; -static swig_type_info _swigt__p_std__vectorT_unsigned_int_t = {"_p_std__vectorT_unsigned_int_t", "std::vector< unsigned int > *|std::vector< ofIndexType > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_std__vectorT_weak_ptrT_ofLight__Data_t_t = {"_p_std__vectorT_weak_ptrT_ofLight__Data_t_t", "std::vector< weak_ptr< ofLight::Data > > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "ofIndexType *|size_t *|TESSindex *|unsigned int *|GLuint *|GLenum *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_unsigned_long_long = {"_p_unsigned_long_long", "uint64_t *|unsigned long long *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_unsigned_short = {"_p_unsigned_short", "unsigned short *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0}; - -static swig_type_info *swig_type_initial[] = { - &_swigt__p_GLintptr, - &_swigt__p_GLsizei, - &_swigt__p_GLsizeiptr, - &_swigt__p_double, - &_swigt__p_float, - &_swigt__p_fstream, - &_swigt__p_int, - &_swigt__p_long_long, - &_swigt__p_of3dPrimitive, - &_swigt__p_ofAbstractImage, - &_swigt__p_ofAbstractParameter, - &_swigt__p_ofAppBaseWindow, - &_swigt__p_ofArduino, - &_swigt__p_ofBaseApp, - &_swigt__p_ofBaseDraws, - &_swigt__p_ofBaseFileSerializer, - &_swigt__p_ofBaseGLRenderer, - &_swigt__p_ofBaseHasPixels, - &_swigt__p_ofBaseHasTexture, - &_swigt__p_ofBaseHasTexturePlanes, - &_swigt__p_ofBaseImage_T_float_t, - &_swigt__p_ofBaseImage_T_unsigned_char_t, - &_swigt__p_ofBaseImage_T_unsigned_short_t, - &_swigt__p_ofBaseLoggerChannel, - &_swigt__p_ofBaseMaterial, - &_swigt__p_ofBaseRenderer, - &_swigt__p_ofBaseSerializer, - &_swigt__p_ofBaseSoundInput, - &_swigt__p_ofBaseSoundOutput, - &_swigt__p_ofBaseSoundPlayer, - &_swigt__p_ofBaseUpdates, - &_swigt__p_ofBaseVideo, - &_swigt__p_ofBaseVideoDraws, - &_swigt__p_ofBaseVideoGrabber, - &_swigt__p_ofBaseVideoPlayer, - &_swigt__p_ofBoxPrimitive, - &_swigt__p_ofBuffer, - &_swigt__p_ofBufferObject, - &_swigt__p_ofCamera, - &_swigt__p_ofColor_T_float_t, - &_swigt__p_ofColor_T_unsigned_char_t, - &_swigt__p_ofColor_T_unsigned_short_t, - &_swigt__p_ofConePrimitive, - &_swigt__p_ofConsoleLoggerChannel, - &_swigt__p_ofCoreEvents, - &_swigt__p_ofCylinderPrimitive, - &_swigt__p_ofDirectory, - &_swigt__p_ofDragInfo, - &_swigt__p_ofEasyCam, - &_swigt__p_ofEventArgs, - &_swigt__p_ofEventT_int_const_t, - &_swigt__p_ofEventT_ofHttpResponse_t, - &_swigt__p_ofEventT_std__string_const_t, - &_swigt__p_ofEventT_std__vectorT_unsigned_char_t_const_t, - &_swigt__p_ofFbo, - &_swigt__p_ofFbo__Settings, - &_swigt__p_ofFile, - &_swigt__p_ofFileDialogResult, - &_swigt__p_ofFileLoggerChannel, - &_swigt__p_ofFilePath, - &_swigt__p_ofFpsCounter, - &_swigt__p_ofHttpRequest, - &_swigt__p_ofHttpResponse, - &_swigt__p_ofIcoSpherePrimitive, - &_swigt__p_ofImage_T_float_t, - &_swigt__p_ofImage_T_unsigned_char_t, - &_swigt__p_ofImage_T_unsigned_short_t, - &_swigt__p_ofKeyEventArgs, - &_swigt__p_ofLight, - &_swigt__p_ofLog, - &_swigt__p_ofLogError, - &_swigt__p_ofLogFatalError, - &_swigt__p_ofLogNotice, - &_swigt__p_ofLogVerbose, - &_swigt__p_ofLogWarning, - &_swigt__p_ofMaterial, - &_swigt__p_ofMatrix3x3, - &_swigt__p_ofMatrix4x4, - &_swigt__p_ofMatrixStack, - &_swigt__p_ofMesh, - &_swigt__p_ofMeshFace, - &_swigt__p_ofMessage, - &_swigt__p_ofMouseEventArgs, - &_swigt__p_ofNode, - &_swigt__p_ofParameterGroup, - &_swigt__p_ofPath, - &_swigt__p_ofPixels_T_float_t, - &_swigt__p_ofPixels_T_unsigned_char_t, - &_swigt__p_ofPixels_T_unsigned_short_t, - &_swigt__p_ofPlanePrimitive, - &_swigt__p_ofPolyline, - &_swigt__p_ofQuaternion, - &_swigt__p_ofRectangle, - &_swigt__p_ofResizeEventArgs, - &_swigt__p_ofSerial, - &_swigt__p_ofSerialDeviceInfo, - &_swigt__p_ofShader, - &_swigt__p_ofSoundDevice, - &_swigt__p_ofSoundPlayer, - &_swigt__p_ofSoundStream, - &_swigt__p_ofSpherePrimitive, - &_swigt__p_ofStyle, - &_swigt__p_ofTexture, - &_swigt__p_ofTextureData, - &_swigt__p_ofTouchEventArgs, - &_swigt__p_ofTrueTypeFont, - &_swigt__p_ofURLFileLoader, - &_swigt__p_ofVbo, - &_swigt__p_ofVboMesh, - &_swigt__p_ofVec2f, - &_swigt__p_ofVec3f, - &_swigt__p_ofVec4f, - &_swigt__p_ofVideoDevice, - &_swigt__p_ofVideoGrabber, - &_swigt__p_ofVideoPlayer, - &_swigt__p_ofXml, - &_swigt__p_shared_ptrT_ofBaseRenderer_t, - &_swigt__p_shared_ptrT_ofBaseSoundPlayer_t, - &_swigt__p_shared_ptrT_ofBaseSoundStream_t, - &_swigt__p_shared_ptrT_ofBaseVideoGrabber_t, - &_swigt__p_std__filesystem__path, - &_swigt__p_std__mapT_std__string_std__string_t, - &_swigt__p_std__string, - &_swigt__p_std__vectorT_float_t, - &_swigt__p_std__vectorT_int_t, - &_swigt__p_std__vectorT_ofColor_T_float_t_t, - &_swigt__p_std__vectorT_ofFile_t, - &_swigt__p_std__vectorT_ofMeshFace_t, - &_swigt__p_std__vectorT_ofPath__Command_t, - &_swigt__p_std__vectorT_ofPath_t, - &_swigt__p_std__vectorT_ofPolyline_t, - &_swigt__p_std__vectorT_ofSerialDeviceInfo_t, - &_swigt__p_std__vectorT_ofSoundDevice_t, - &_swigt__p_std__vectorT_ofTexture_t, - &_swigt__p_std__vectorT_ofVec2f_t, - &_swigt__p_std__vectorT_ofVec3f_t, - &_swigt__p_std__vectorT_ofVideoDevice_t, - &_swigt__p_std__vectorT_std__string_t, - &_swigt__p_std__vectorT_unsigned_char_t, - &_swigt__p_std__vectorT_unsigned_int_t, - &_swigt__p_std__vectorT_weak_ptrT_ofLight__Data_t_t, - &_swigt__p_unsigned_char, - &_swigt__p_unsigned_int, - &_swigt__p_unsigned_long_long, - &_swigt__p_unsigned_short, - &_swigt__p_void, -}; - -static swig_cast_info _swigc__p_GLintptr[] = { {&_swigt__p_GLintptr, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_GLsizei[] = { {&_swigt__p_GLsizei, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_GLsizeiptr[] = { {&_swigt__p_GLsizeiptr, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_float[] = { {&_swigt__p_float, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_fstream[] = { {&_swigt__p_fstream, 0, 0, 0}, {&_swigt__p_ofFile, _p_ofFileTo_p_fstream, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_long_long[] = { {&_swigt__p_long_long, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_of3dPrimitive[] = { {&_swigt__p_of3dPrimitive, 0, 0, 0}, {&_swigt__p_ofPlanePrimitive, _p_ofPlanePrimitiveTo_p_of3dPrimitive, 0, 0}, {&_swigt__p_ofSpherePrimitive, _p_ofSpherePrimitiveTo_p_of3dPrimitive, 0, 0}, {&_swigt__p_ofIcoSpherePrimitive, _p_ofIcoSpherePrimitiveTo_p_of3dPrimitive, 0, 0}, {&_swigt__p_ofCylinderPrimitive, _p_ofCylinderPrimitiveTo_p_of3dPrimitive, 0, 0}, {&_swigt__p_ofConePrimitive, _p_ofConePrimitiveTo_p_of3dPrimitive, 0, 0}, {&_swigt__p_ofBoxPrimitive, _p_ofBoxPrimitiveTo_p_of3dPrimitive, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofAbstractParameter[] = { {&_swigt__p_ofAbstractParameter, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofAppBaseWindow[] = { {&_swigt__p_ofAppBaseWindow, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofArduino[] = { {&_swigt__p_ofArduino, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofBaseApp[] = { {&_swigt__p_ofBaseApp, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofAbstractImage[] = {{&_swigt__p_ofAbstractImage, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofBaseDraws[] = { {&_swigt__p_ofAbstractImage, _p_ofAbstractImageTo_p_ofBaseDraws, 0, 0}, {&_swigt__p_ofBaseVideoDraws, _p_ofBaseVideoDrawsTo_p_ofBaseDraws, 0, 0}, {&_swigt__p_ofVideoGrabber, _p_ofVideoGrabberTo_p_ofBaseDraws, 0, 0}, {&_swigt__p_ofBaseDraws, 0, 0, 0}, {&_swigt__p_ofTexture, _p_ofTextureTo_p_ofBaseDraws, 0, 0}, {&_swigt__p_ofFbo, _p_ofFboTo_p_ofBaseDraws, 0, 0}, {&_swigt__p_ofVideoPlayer, _p_ofVideoPlayerTo_p_ofBaseDraws, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofBaseFileSerializer[] = { {&_swigt__p_ofXml, _p_ofXmlTo_p_ofBaseFileSerializer, 0, 0}, {&_swigt__p_ofBaseFileSerializer, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofBaseHasPixels[] = { {&_swigt__p_ofBaseVideoDraws, _p_ofBaseVideoDrawsTo_p_ofBaseHasPixels, 0, 0}, {&_swigt__p_ofVideoGrabber, _p_ofVideoGrabberTo_p_ofBaseHasPixels, 0, 0}, {&_swigt__p_ofBaseVideoGrabber, _p_ofBaseVideoGrabberTo_p_ofBaseHasPixels, 0, 0}, {&_swigt__p_ofBaseVideo, _p_ofBaseVideoTo_p_ofBaseHasPixels, 0, 0}, {&_swigt__p_ofBaseHasPixels, 0, 0, 0}, {&_swigt__p_ofVideoPlayer, _p_ofVideoPlayerTo_p_ofBaseHasPixels, 0, 0}, {&_swigt__p_ofBaseVideoPlayer, _p_ofBaseVideoPlayerTo_p_ofBaseHasPixels, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofBaseHasTexture[] = { {&_swigt__p_ofAbstractImage, _p_ofAbstractImageTo_p_ofBaseHasTexture, 0, 0}, {&_swigt__p_ofBaseVideoDraws, _p_ofBaseVideoDrawsTo_p_ofBaseHasTexture, 0, 0}, {&_swigt__p_ofVideoGrabber, _p_ofVideoGrabberTo_p_ofBaseHasTexture, 0, 0}, {&_swigt__p_ofBaseHasTexture, 0, 0, 0}, {&_swigt__p_ofFbo, _p_ofFboTo_p_ofBaseHasTexture, 0, 0}, {&_swigt__p_ofVideoPlayer, _p_ofVideoPlayerTo_p_ofBaseHasTexture, 0, 0}, {&_swigt__p_ofBaseHasTexturePlanes, _p_ofBaseHasTexturePlanesTo_p_ofBaseHasTexture, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofBaseHasTexturePlanes[] = { {&_swigt__p_ofBaseVideoDraws, _p_ofBaseVideoDrawsTo_p_ofBaseHasTexturePlanes, 0, 0}, {&_swigt__p_ofVideoGrabber, _p_ofVideoGrabberTo_p_ofBaseHasTexturePlanes, 0, 0}, {&_swigt__p_ofBaseHasTexturePlanes, 0, 0, 0}, {&_swigt__p_ofVideoPlayer, _p_ofVideoPlayerTo_p_ofBaseHasTexturePlanes, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofBaseImage_T_float_t[] = { {&_swigt__p_ofBaseImage_T_float_t, 0, 0, 0}, {&_swigt__p_ofImage_T_float_t, _p_ofImage_T_float_tTo_p_ofBaseImage_T_float_t, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofBaseImage_T_unsigned_char_t[] = { {&_swigt__p_ofBaseImage_T_unsigned_char_t, 0, 0, 0}, {&_swigt__p_ofImage_T_unsigned_char_t, _p_ofImage_T_unsigned_char_tTo_p_ofBaseImage_T_unsigned_char_t, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofBaseImage_T_unsigned_short_t[] = { {&_swigt__p_ofBaseImage_T_unsigned_short_t, 0, 0, 0}, {&_swigt__p_ofImage_T_unsigned_short_t, _p_ofImage_T_unsigned_short_tTo_p_ofBaseImage_T_unsigned_short_t, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofConsoleLoggerChannel[] = {{&_swigt__p_ofConsoleLoggerChannel, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofFileLoggerChannel[] = {{&_swigt__p_ofFileLoggerChannel, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofBaseLoggerChannel[] = { {&_swigt__p_ofBaseLoggerChannel, 0, 0, 0}, {&_swigt__p_ofConsoleLoggerChannel, _p_ofConsoleLoggerChannelTo_p_ofBaseLoggerChannel, 0, 0}, {&_swigt__p_ofFileLoggerChannel, _p_ofFileLoggerChannelTo_p_ofBaseLoggerChannel, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofBaseMaterial[] = { {&_swigt__p_ofBaseMaterial, 0, 0, 0}, {&_swigt__p_ofMaterial, _p_ofMaterialTo_p_ofBaseMaterial, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofBaseGLRenderer[] = {{&_swigt__p_ofBaseGLRenderer, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofBaseRenderer[] = { {&_swigt__p_ofBaseRenderer, 0, 0, 0}, {&_swigt__p_ofBaseGLRenderer, _p_ofBaseGLRendererTo_p_ofBaseRenderer, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofBaseSerializer[] = { {&_swigt__p_ofXml, _p_ofXmlTo_p_ofBaseSerializer, 0, 0}, {&_swigt__p_ofBaseSerializer, 0, 0, 0}, {&_swigt__p_ofBaseFileSerializer, _p_ofBaseFileSerializerTo_p_ofBaseSerializer, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofBaseSoundInput[] = { {&_swigt__p_ofBaseSoundInput, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofBaseSoundOutput[] = { {&_swigt__p_ofBaseSoundOutput, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofBaseSoundPlayer[] = { {&_swigt__p_ofBaseSoundPlayer, 0, 0, 0}, {&_swigt__p_ofSoundPlayer, _p_ofSoundPlayerTo_p_ofBaseSoundPlayer, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofBaseUpdates[] = { {&_swigt__p_ofBaseVideoDraws, _p_ofBaseVideoDrawsTo_p_ofBaseUpdates, 0, 0}, {&_swigt__p_ofVideoGrabber, _p_ofVideoGrabberTo_p_ofBaseUpdates, 0, 0}, {&_swigt__p_ofBaseVideoGrabber, _p_ofBaseVideoGrabberTo_p_ofBaseUpdates, 0, 0}, {&_swigt__p_ofBaseVideo, _p_ofBaseVideoTo_p_ofBaseUpdates, 0, 0}, {&_swigt__p_ofBaseUpdates, 0, 0, 0}, {&_swigt__p_ofVideoPlayer, _p_ofVideoPlayerTo_p_ofBaseUpdates, 0, 0}, {&_swigt__p_ofBaseVideoPlayer, _p_ofBaseVideoPlayerTo_p_ofBaseUpdates, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofBaseVideo[] = { {&_swigt__p_ofBaseVideoDraws, _p_ofBaseVideoDrawsTo_p_ofBaseVideo, 0, 0}, {&_swigt__p_ofVideoGrabber, _p_ofVideoGrabberTo_p_ofBaseVideo, 0, 0}, {&_swigt__p_ofBaseVideoGrabber, _p_ofBaseVideoGrabberTo_p_ofBaseVideo, 0, 0}, {&_swigt__p_ofBaseVideo, 0, 0, 0}, {&_swigt__p_ofVideoPlayer, _p_ofVideoPlayerTo_p_ofBaseVideo, 0, 0}, {&_swigt__p_ofBaseVideoPlayer, _p_ofBaseVideoPlayerTo_p_ofBaseVideo, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofBaseVideoDraws[] = { {&_swigt__p_ofBaseVideoDraws, 0, 0, 0}, {&_swigt__p_ofVideoGrabber, _p_ofVideoGrabberTo_p_ofBaseVideoDraws, 0, 0}, {&_swigt__p_ofVideoPlayer, _p_ofVideoPlayerTo_p_ofBaseVideoDraws, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofBaseVideoGrabber[] = { {&_swigt__p_ofBaseVideoGrabber, 0, 0, 0}, {&_swigt__p_ofVideoGrabber, _p_ofVideoGrabberTo_p_ofBaseVideoGrabber, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofBaseVideoPlayer[] = { {&_swigt__p_ofBaseVideoPlayer, 0, 0, 0}, {&_swigt__p_ofVideoPlayer, _p_ofVideoPlayerTo_p_ofBaseVideoPlayer, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofBoxPrimitive[] = { {&_swigt__p_ofBoxPrimitive, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofBuffer[] = { {&_swigt__p_ofBuffer, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofBufferObject[] = { {&_swigt__p_ofBufferObject, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofCamera[] = { {&_swigt__p_ofEasyCam, _p_ofEasyCamTo_p_ofCamera, 0, 0}, {&_swigt__p_ofCamera, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofColor_T_float_t[] = { {&_swigt__p_ofColor_T_float_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofColor_T_unsigned_char_t[] = { {&_swigt__p_ofColor_T_unsigned_char_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofColor_T_unsigned_short_t[] = { {&_swigt__p_ofColor_T_unsigned_short_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofConePrimitive[] = { {&_swigt__p_ofConePrimitive, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofCoreEvents[] = { {&_swigt__p_ofCoreEvents, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofCylinderPrimitive[] = { {&_swigt__p_ofCylinderPrimitive, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofDirectory[] = { {&_swigt__p_ofDirectory, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofDragInfo[] = { {&_swigt__p_ofDragInfo, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofEasyCam[] = { {&_swigt__p_ofEasyCam, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofKeyEventArgs[] = {{&_swigt__p_ofKeyEventArgs, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofMouseEventArgs[] = {{&_swigt__p_ofMouseEventArgs, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofResizeEventArgs[] = {{&_swigt__p_ofResizeEventArgs, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofMessage[] = {{&_swigt__p_ofMessage, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofEventArgs[] = { {&_swigt__p_ofEventArgs, 0, 0, 0}, {&_swigt__p_ofKeyEventArgs, _p_ofKeyEventArgsTo_p_ofEventArgs, 0, 0}, {&_swigt__p_ofMouseEventArgs, _p_ofMouseEventArgsTo_p_ofEventArgs, 0, 0}, {&_swigt__p_ofTouchEventArgs, _p_ofTouchEventArgsTo_p_ofEventArgs, 0, 0}, {&_swigt__p_ofResizeEventArgs, _p_ofResizeEventArgsTo_p_ofEventArgs, 0, 0}, {&_swigt__p_ofMessage, _p_ofMessageTo_p_ofEventArgs, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofEventT_int_const_t[] = { {&_swigt__p_ofEventT_int_const_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofEventT_ofHttpResponse_t[] = { {&_swigt__p_ofEventT_ofHttpResponse_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofEventT_std__string_const_t[] = { {&_swigt__p_ofEventT_std__string_const_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofEventT_std__vectorT_unsigned_char_t_const_t[] = { {&_swigt__p_ofEventT_std__vectorT_unsigned_char_t_const_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofFbo[] = { {&_swigt__p_ofFbo, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofFbo__Settings[] = { {&_swigt__p_ofFbo__Settings, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofFile[] = { {&_swigt__p_ofFile, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofFileDialogResult[] = { {&_swigt__p_ofFileDialogResult, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofFilePath[] = { {&_swigt__p_ofFilePath, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofFpsCounter[] = { {&_swigt__p_ofFpsCounter, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofHttpRequest[] = { {&_swigt__p_ofHttpRequest, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofHttpResponse[] = { {&_swigt__p_ofHttpResponse, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofIcoSpherePrimitive[] = { {&_swigt__p_ofIcoSpherePrimitive, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofImage_T_float_t[] = { {&_swigt__p_ofImage_T_float_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofImage_T_unsigned_char_t[] = { {&_swigt__p_ofImage_T_unsigned_char_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofImage_T_unsigned_short_t[] = { {&_swigt__p_ofImage_T_unsigned_short_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofLight[] = { {&_swigt__p_ofLight, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofLogError[] = {{&_swigt__p_ofLogError, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofLogNotice[] = {{&_swigt__p_ofLogNotice, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofLogFatalError[] = {{&_swigt__p_ofLogFatalError, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofLogVerbose[] = {{&_swigt__p_ofLogVerbose, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofLogWarning[] = {{&_swigt__p_ofLogWarning, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofLog[] = { {&_swigt__p_ofLogError, _p_ofLogErrorTo_p_ofLog, 0, 0}, {&_swigt__p_ofLogNotice, _p_ofLogNoticeTo_p_ofLog, 0, 0}, {&_swigt__p_ofLogFatalError, _p_ofLogFatalErrorTo_p_ofLog, 0, 0}, {&_swigt__p_ofLogVerbose, _p_ofLogVerboseTo_p_ofLog, 0, 0}, {&_swigt__p_ofLog, 0, 0, 0}, {&_swigt__p_ofLogWarning, _p_ofLogWarningTo_p_ofLog, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofMaterial[] = { {&_swigt__p_ofMaterial, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofMatrix3x3[] = { {&_swigt__p_ofMatrix3x3, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofMatrix4x4[] = { {&_swigt__p_ofMatrix4x4, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofMatrixStack[] = { {&_swigt__p_ofMatrixStack, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofMesh[] = { {&_swigt__p_ofMesh, 0, 0, 0}, {&_swigt__p_ofVboMesh, _p_ofVboMeshTo_p_ofMesh, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofMeshFace[] = { {&_swigt__p_ofMeshFace, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofNode[] = { {&_swigt__p_ofNode, 0, 0, 0}, {&_swigt__p_of3dPrimitive, _p_of3dPrimitiveTo_p_ofNode, 0, 0}, {&_swigt__p_ofPlanePrimitive, _p_ofPlanePrimitiveTo_p_ofNode, 0, 0}, {&_swigt__p_ofSpherePrimitive, _p_ofSpherePrimitiveTo_p_ofNode, 0, 0}, {&_swigt__p_ofIcoSpherePrimitive, _p_ofIcoSpherePrimitiveTo_p_ofNode, 0, 0}, {&_swigt__p_ofCylinderPrimitive, _p_ofCylinderPrimitiveTo_p_ofNode, 0, 0}, {&_swigt__p_ofConePrimitive, _p_ofConePrimitiveTo_p_ofNode, 0, 0}, {&_swigt__p_ofBoxPrimitive, _p_ofBoxPrimitiveTo_p_ofNode, 0, 0}, {&_swigt__p_ofEasyCam, _p_ofEasyCamTo_p_ofNode, 0, 0}, {&_swigt__p_ofLight, _p_ofLightTo_p_ofNode, 0, 0}, {&_swigt__p_ofCamera, _p_ofCameraTo_p_ofNode, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofParameterGroup[] = { {&_swigt__p_ofParameterGroup, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofPath[] = { {&_swigt__p_ofPath, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofPixels_T_float_t[] = { {&_swigt__p_ofPixels_T_float_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofPixels_T_unsigned_char_t[] = { {&_swigt__p_ofPixels_T_unsigned_char_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofPixels_T_unsigned_short_t[] = { {&_swigt__p_ofPixels_T_unsigned_short_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofPlanePrimitive[] = { {&_swigt__p_ofPlanePrimitive, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofPolyline[] = { {&_swigt__p_ofPolyline, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofQuaternion[] = { {&_swigt__p_ofQuaternion, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofRectangle[] = { {&_swigt__p_ofRectangle, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofSerial[] = { {&_swigt__p_ofSerial, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofSerialDeviceInfo[] = { {&_swigt__p_ofSerialDeviceInfo, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofShader[] = { {&_swigt__p_ofShader, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofSoundDevice[] = { {&_swigt__p_ofSoundDevice, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofSoundPlayer[] = { {&_swigt__p_ofSoundPlayer, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofSoundStream[] = { {&_swigt__p_ofSoundStream, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofSpherePrimitive[] = { {&_swigt__p_ofSpherePrimitive, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofStyle[] = { {&_swigt__p_ofStyle, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofTexture[] = { {&_swigt__p_ofTexture, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofTextureData[] = { {&_swigt__p_ofTextureData, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofTouchEventArgs[] = { {&_swigt__p_ofTouchEventArgs, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofTrueTypeFont[] = { {&_swigt__p_ofTrueTypeFont, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofURLFileLoader[] = { {&_swigt__p_ofURLFileLoader, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofVbo[] = { {&_swigt__p_ofVbo, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofVboMesh[] = { {&_swigt__p_ofVboMesh, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofVec2f[] = { {&_swigt__p_ofMouseEventArgs, _p_ofMouseEventArgsTo_p_ofVec2f, 0, 0}, {&_swigt__p_ofTouchEventArgs, _p_ofTouchEventArgsTo_p_ofVec2f, 0, 0}, {&_swigt__p_ofVec2f, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofVec3f[] = { {&_swigt__p_ofVec3f, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofVec4f[] = { {&_swigt__p_ofVec4f, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofVideoDevice[] = { {&_swigt__p_ofVideoDevice, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofVideoGrabber[] = { {&_swigt__p_ofVideoGrabber, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofVideoPlayer[] = { {&_swigt__p_ofVideoPlayer, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofXml[] = { {&_swigt__p_ofXml, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_shared_ptrT_ofBaseRenderer_t[] = { {&_swigt__p_shared_ptrT_ofBaseRenderer_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_shared_ptrT_ofBaseSoundPlayer_t[] = { {&_swigt__p_shared_ptrT_ofBaseSoundPlayer_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_shared_ptrT_ofBaseSoundStream_t[] = { {&_swigt__p_shared_ptrT_ofBaseSoundStream_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_shared_ptrT_ofBaseVideoGrabber_t[] = { {&_swigt__p_shared_ptrT_ofBaseVideoGrabber_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__filesystem__path[] = { {&_swigt__p_std__filesystem__path, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__mapT_std__string_std__string_t[] = { {&_swigt__p_std__mapT_std__string_std__string_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__string[] = { {&_swigt__p_std__string, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__vectorT_float_t[] = { {&_swigt__p_std__vectorT_float_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__vectorT_int_t[] = { {&_swigt__p_std__vectorT_int_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__vectorT_ofColor_T_float_t_t[] = { {&_swigt__p_std__vectorT_ofColor_T_float_t_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__vectorT_ofFile_t[] = { {&_swigt__p_std__vectorT_ofFile_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__vectorT_ofMeshFace_t[] = { {&_swigt__p_std__vectorT_ofMeshFace_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__vectorT_ofPath__Command_t[] = { {&_swigt__p_std__vectorT_ofPath__Command_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__vectorT_ofPath_t[] = { {&_swigt__p_std__vectorT_ofPath_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__vectorT_ofPolyline_t[] = { {&_swigt__p_std__vectorT_ofPolyline_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__vectorT_ofSerialDeviceInfo_t[] = { {&_swigt__p_std__vectorT_ofSerialDeviceInfo_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__vectorT_ofSoundDevice_t[] = { {&_swigt__p_std__vectorT_ofSoundDevice_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__vectorT_ofTexture_t[] = { {&_swigt__p_std__vectorT_ofTexture_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__vectorT_ofVec2f_t[] = { {&_swigt__p_std__vectorT_ofVec2f_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__vectorT_ofVec3f_t[] = { {&_swigt__p_std__vectorT_ofVec3f_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__vectorT_ofVideoDevice_t[] = { {&_swigt__p_std__vectorT_ofVideoDevice_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__vectorT_std__string_t[] = { {&_swigt__p_std__vectorT_std__string_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__vectorT_unsigned_char_t[] = { {&_swigt__p_std__vectorT_unsigned_char_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__vectorT_unsigned_int_t[] = { {&_swigt__p_std__vectorT_unsigned_int_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__vectorT_weak_ptrT_ofLight__Data_t_t[] = { {&_swigt__p_std__vectorT_weak_ptrT_ofLight__Data_t_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_unsigned_long_long[] = { {&_swigt__p_unsigned_long_long, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_unsigned_short[] = { {&_swigt__p_unsigned_short, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_void[] = { {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}}; - -static swig_cast_info *swig_cast_initial[] = { - _swigc__p_GLintptr, - _swigc__p_GLsizei, - _swigc__p_GLsizeiptr, - _swigc__p_double, - _swigc__p_float, - _swigc__p_fstream, - _swigc__p_int, - _swigc__p_long_long, - _swigc__p_of3dPrimitive, - _swigc__p_ofAbstractImage, - _swigc__p_ofAbstractParameter, - _swigc__p_ofAppBaseWindow, - _swigc__p_ofArduino, - _swigc__p_ofBaseApp, - _swigc__p_ofBaseDraws, - _swigc__p_ofBaseFileSerializer, - _swigc__p_ofBaseGLRenderer, - _swigc__p_ofBaseHasPixels, - _swigc__p_ofBaseHasTexture, - _swigc__p_ofBaseHasTexturePlanes, - _swigc__p_ofBaseImage_T_float_t, - _swigc__p_ofBaseImage_T_unsigned_char_t, - _swigc__p_ofBaseImage_T_unsigned_short_t, - _swigc__p_ofBaseLoggerChannel, - _swigc__p_ofBaseMaterial, - _swigc__p_ofBaseRenderer, - _swigc__p_ofBaseSerializer, - _swigc__p_ofBaseSoundInput, - _swigc__p_ofBaseSoundOutput, - _swigc__p_ofBaseSoundPlayer, - _swigc__p_ofBaseUpdates, - _swigc__p_ofBaseVideo, - _swigc__p_ofBaseVideoDraws, - _swigc__p_ofBaseVideoGrabber, - _swigc__p_ofBaseVideoPlayer, - _swigc__p_ofBoxPrimitive, - _swigc__p_ofBuffer, - _swigc__p_ofBufferObject, - _swigc__p_ofCamera, - _swigc__p_ofColor_T_float_t, - _swigc__p_ofColor_T_unsigned_char_t, - _swigc__p_ofColor_T_unsigned_short_t, - _swigc__p_ofConePrimitive, - _swigc__p_ofConsoleLoggerChannel, - _swigc__p_ofCoreEvents, - _swigc__p_ofCylinderPrimitive, - _swigc__p_ofDirectory, - _swigc__p_ofDragInfo, - _swigc__p_ofEasyCam, - _swigc__p_ofEventArgs, - _swigc__p_ofEventT_int_const_t, - _swigc__p_ofEventT_ofHttpResponse_t, - _swigc__p_ofEventT_std__string_const_t, - _swigc__p_ofEventT_std__vectorT_unsigned_char_t_const_t, - _swigc__p_ofFbo, - _swigc__p_ofFbo__Settings, - _swigc__p_ofFile, - _swigc__p_ofFileDialogResult, - _swigc__p_ofFileLoggerChannel, - _swigc__p_ofFilePath, - _swigc__p_ofFpsCounter, - _swigc__p_ofHttpRequest, - _swigc__p_ofHttpResponse, - _swigc__p_ofIcoSpherePrimitive, - _swigc__p_ofImage_T_float_t, - _swigc__p_ofImage_T_unsigned_char_t, - _swigc__p_ofImage_T_unsigned_short_t, - _swigc__p_ofKeyEventArgs, - _swigc__p_ofLight, - _swigc__p_ofLog, - _swigc__p_ofLogError, - _swigc__p_ofLogFatalError, - _swigc__p_ofLogNotice, - _swigc__p_ofLogVerbose, - _swigc__p_ofLogWarning, - _swigc__p_ofMaterial, - _swigc__p_ofMatrix3x3, - _swigc__p_ofMatrix4x4, - _swigc__p_ofMatrixStack, - _swigc__p_ofMesh, - _swigc__p_ofMeshFace, - _swigc__p_ofMessage, - _swigc__p_ofMouseEventArgs, - _swigc__p_ofNode, - _swigc__p_ofParameterGroup, - _swigc__p_ofPath, - _swigc__p_ofPixels_T_float_t, - _swigc__p_ofPixels_T_unsigned_char_t, - _swigc__p_ofPixels_T_unsigned_short_t, - _swigc__p_ofPlanePrimitive, - _swigc__p_ofPolyline, - _swigc__p_ofQuaternion, - _swigc__p_ofRectangle, - _swigc__p_ofResizeEventArgs, - _swigc__p_ofSerial, - _swigc__p_ofSerialDeviceInfo, - _swigc__p_ofShader, - _swigc__p_ofSoundDevice, - _swigc__p_ofSoundPlayer, - _swigc__p_ofSoundStream, - _swigc__p_ofSpherePrimitive, - _swigc__p_ofStyle, - _swigc__p_ofTexture, - _swigc__p_ofTextureData, - _swigc__p_ofTouchEventArgs, - _swigc__p_ofTrueTypeFont, - _swigc__p_ofURLFileLoader, - _swigc__p_ofVbo, - _swigc__p_ofVboMesh, - _swigc__p_ofVec2f, - _swigc__p_ofVec3f, - _swigc__p_ofVec4f, - _swigc__p_ofVideoDevice, - _swigc__p_ofVideoGrabber, - _swigc__p_ofVideoPlayer, - _swigc__p_ofXml, - _swigc__p_shared_ptrT_ofBaseRenderer_t, - _swigc__p_shared_ptrT_ofBaseSoundPlayer_t, - _swigc__p_shared_ptrT_ofBaseSoundStream_t, - _swigc__p_shared_ptrT_ofBaseVideoGrabber_t, - _swigc__p_std__filesystem__path, - _swigc__p_std__mapT_std__string_std__string_t, - _swigc__p_std__string, - _swigc__p_std__vectorT_float_t, - _swigc__p_std__vectorT_int_t, - _swigc__p_std__vectorT_ofColor_T_float_t_t, - _swigc__p_std__vectorT_ofFile_t, - _swigc__p_std__vectorT_ofMeshFace_t, - _swigc__p_std__vectorT_ofPath__Command_t, - _swigc__p_std__vectorT_ofPath_t, - _swigc__p_std__vectorT_ofPolyline_t, - _swigc__p_std__vectorT_ofSerialDeviceInfo_t, - _swigc__p_std__vectorT_ofSoundDevice_t, - _swigc__p_std__vectorT_ofTexture_t, - _swigc__p_std__vectorT_ofVec2f_t, - _swigc__p_std__vectorT_ofVec3f_t, - _swigc__p_std__vectorT_ofVideoDevice_t, - _swigc__p_std__vectorT_std__string_t, - _swigc__p_std__vectorT_unsigned_char_t, - _swigc__p_std__vectorT_unsigned_int_t, - _swigc__p_std__vectorT_weak_ptrT_ofLight__Data_t_t, - _swigc__p_unsigned_char, - _swigc__p_unsigned_int, - _swigc__p_unsigned_long_long, - _swigc__p_unsigned_short, - _swigc__p_void, -}; - - -/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */ - -/* ----------------------------------------------------------------------------- - * Type initialization: - * This problem is tough by the requirement that no dynamic - * memory is used. Also, since swig_type_info structures store pointers to - * swig_cast_info structures and swig_cast_info structures store pointers back - * to swig_type_info structures, we need some lookup code at initialization. - * The idea is that swig generates all the structures that are needed. - * The runtime then collects these partially filled structures. - * The SWIG_InitializeModule function takes these initial arrays out of - * swig_module, and does all the lookup, filling in the swig_module.types - * array with the correct data and linking the correct swig_cast_info - * structures together. - * - * The generated swig_type_info structures are assigned statically to an initial - * array. We just loop through that array, and handle each type individually. - * First we lookup if this type has been already loaded, and if so, use the - * loaded structure instead of the generated one. Then we have to fill in the - * cast linked list. The cast data is initially stored in something like a - * two-dimensional array. Each row corresponds to a type (there are the same - * number of rows as there are in the swig_type_initial array). Each entry in - * a column is one of the swig_cast_info structures for that type. - * The cast_initial array is actually an array of arrays, because each row has - * a variable number of columns. So to actually build the cast linked list, - * we find the array of casts associated with the type, and loop through it - * adding the casts to the list. The one last trick we need to do is making - * sure the type pointer in the swig_cast_info struct is correct. - * - * First off, we lookup the cast->type name to see if it is already loaded. - * There are three cases to handle: - * 1) If the cast->type has already been loaded AND the type we are adding - * casting info to has not been loaded (it is in this module), THEN we - * replace the cast->type pointer with the type pointer that has already - * been loaded. - * 2) If BOTH types (the one we are adding casting info to, and the - * cast->type) are loaded, THEN the cast info has already been loaded by - * the previous module so we just ignore it. - * 3) Finally, if cast->type has not already been loaded, then we add that - * swig_cast_info to the linked list (because the cast->type) pointer will - * be correct. - * ----------------------------------------------------------------------------- */ - -#ifdef __cplusplus -extern "C" { -#if 0 -} /* c-mode */ -#endif -#endif - -#if 0 -#define SWIGRUNTIME_DEBUG -#endif - - -SWIGRUNTIME void -SWIG_InitializeModule(void *clientdata) { - size_t i; - swig_module_info *module_head, *iter; - int init; - - /* check to see if the circular list has been setup, if not, set it up */ - if (swig_module.next==0) { - /* Initialize the swig_module */ - swig_module.type_initial = swig_type_initial; - swig_module.cast_initial = swig_cast_initial; - swig_module.next = &swig_module; - init = 1; - } else { - init = 0; - } - - /* Try and load any already created modules */ - module_head = SWIG_GetModule(clientdata); - if (!module_head) { - /* This is the first module loaded for this interpreter */ - /* so set the swig module into the interpreter */ - SWIG_SetModule(clientdata, &swig_module); - } else { - /* the interpreter has loaded a SWIG module, but has it loaded this one? */ - iter=module_head; - do { - if (iter==&swig_module) { - /* Our module is already in the list, so there's nothing more to do. */ - return; - } - iter=iter->next; - } while (iter!= module_head); - - /* otherwise we must add our module into the list */ - swig_module.next = module_head->next; - module_head->next = &swig_module; - } - - /* When multiple interpreters are used, a module could have already been initialized in - a different interpreter, but not yet have a pointer in this interpreter. - In this case, we do not want to continue adding types... everything should be - set up already */ - if (init == 0) return; - - /* Now work on filling in swig_module.types */ -#ifdef SWIGRUNTIME_DEBUG - printf("SWIG_InitializeModule: size %d\n", swig_module.size); -#endif - for (i = 0; i < swig_module.size; ++i) { - swig_type_info *type = 0; - swig_type_info *ret; - swig_cast_info *cast; - -#ifdef SWIGRUNTIME_DEBUG - printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name); -#endif - - /* if there is another module already loaded */ - if (swig_module.next != &swig_module) { - type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name); - } - if (type) { - /* Overwrite clientdata field */ -#ifdef SWIGRUNTIME_DEBUG - printf("SWIG_InitializeModule: found type %s\n", type->name); -#endif - if (swig_module.type_initial[i]->clientdata) { - type->clientdata = swig_module.type_initial[i]->clientdata; -#ifdef SWIGRUNTIME_DEBUG - printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name); -#endif - } - } else { - type = swig_module.type_initial[i]; - } - - /* Insert casting types */ - cast = swig_module.cast_initial[i]; - while (cast->type) { - - /* Don't need to add information already in the list */ - ret = 0; -#ifdef SWIGRUNTIME_DEBUG - printf("SWIG_InitializeModule: look cast %s\n", cast->type->name); -#endif - if (swig_module.next != &swig_module) { - ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name); -#ifdef SWIGRUNTIME_DEBUG - if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name); -#endif - } - if (ret) { - if (type == swig_module.type_initial[i]) { -#ifdef SWIGRUNTIME_DEBUG - printf("SWIG_InitializeModule: skip old type %s\n", ret->name); -#endif - cast->type = ret; - ret = 0; - } else { - /* Check for casting already in the list */ - swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type); -#ifdef SWIGRUNTIME_DEBUG - if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name); -#endif - if (!ocast) ret = 0; - } - } - - if (!ret) { -#ifdef SWIGRUNTIME_DEBUG - printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name); -#endif - if (type->cast) { - type->cast->prev = cast; - cast->next = type->cast; - } - type->cast = cast; - } - cast++; - } - /* Set entry in modules->types array equal to the type */ - swig_module.types[i] = type; - } - swig_module.types[i] = 0; - -#ifdef SWIGRUNTIME_DEBUG - printf("**** SWIG_InitializeModule: Cast List ******\n"); - for (i = 0; i < swig_module.size; ++i) { - int j = 0; - swig_cast_info *cast = swig_module.cast_initial[i]; - printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name); - while (cast->type) { - printf("SWIG_InitializeModule: cast type %s\n", cast->type->name); - cast++; - ++j; - } - printf("---- Total casts: %d\n",j); - } - printf("**** SWIG_InitializeModule: Cast List ******\n"); -#endif -} - -/* This function will propagate the clientdata field of type to -* any new swig_type_info structures that have been added into the list -* of equivalent types. It is like calling -* SWIG_TypeClientData(type, clientdata) a second time. -*/ -SWIGRUNTIME void -SWIG_PropagateClientData(void) { - size_t i; - swig_cast_info *equiv; - static int init_run = 0; - - if (init_run) return; - init_run = 1; - - for (i = 0; i < swig_module.size; i++) { - if (swig_module.types[i]->clientdata) { - equiv = swig_module.types[i]->cast; - while (equiv) { - if (!equiv->converter) { - if (equiv->type && !equiv->type->clientdata) - SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata); - } - equiv = equiv->next; - } - } - } -} - -#ifdef __cplusplus -#if 0 -{ /* c-mode */ -#endif -} -#endif - - - -/* Forward declaration of where the user's %init{} gets inserted */ -void SWIG_init_user(lua_State* L ); - -#ifdef __cplusplus -extern "C" { -#endif -/* this is the initialization function - added at the very end of the code - the function is always called SWIG_init, but an earlier #define will rename it -*/ -#if ((SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC)) -LUALIB_API int SWIG_init(lua_State* L) -#else -SWIGEXPORT int SWIG_init(lua_State* L) /* default Lua action */ -#endif -{ -#if (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC) /* valid for both Lua and eLua */ - int i; - int globalRegister = 0; - /* start with global table */ - lua_pushglobaltable (L); - /* SWIG's internal initialisation */ - SWIG_InitializeModule((void*)L); - SWIG_PropagateClientData(); -#endif - -#if ((SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUA) && (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC)) || defined(SWIG_LUA_ELUA_EMULATE) - /* add a global fn */ - SWIG_Lua_add_function(L,"swig_type",SWIG_Lua_type); - SWIG_Lua_add_function(L,"swig_equals",SWIG_Lua_class_equal); -#endif - -#if (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC) - /* set up base class pointers (the hierarchy) */ - for (i = 0; swig_types[i]; i++){ - if (swig_types[i]->clientdata){ - SWIG_Lua_init_base_class(L,(swig_lua_class*)(swig_types[i]->clientdata)); - } - } -#ifdef SWIG_LUA_MODULE_GLOBAL - globalRegister = 1; -#endif - - -#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA) - SWIG_Lua_namespace_register(L,&swig_SwigModule, globalRegister); -#endif - -#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC) - for (i = 0; swig_types[i]; i++){ - if (swig_types[i]->clientdata){ - SWIG_Lua_elua_class_register_instance(L,(swig_lua_class*)(swig_types[i]->clientdata)); - } - } -#endif - -#if defined(SWIG_LUA_ELUA_EMULATE) - lua_newtable(L); - SWIG_Lua_elua_emulate_register(L,swig_SwigModule.ns_methods); - SWIG_Lua_elua_emulate_register_clear(L); - if(globalRegister) { - lua_pushstring(L,swig_SwigModule.name); - lua_pushvalue(L,-2); - lua_rawset(L,-4); - } -#endif - -#endif - -#if (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC) - /* invoke user-specific initialization */ - SWIG_init_user(L); - /* end module */ - /* Note: We do not clean up the stack here (Lua will do this for us). At this - point, we have the globals table and out module table on the stack. Returning - one value makes the module table the result of the require command. */ - return 1; -#else - return 0; -#endif -} - -#ifdef __cplusplus -} -#endif - - -const char* SWIG_LUACODE= - "\n" - "\n" - "-- this isn't wrapped correctly, so set it here\n" - "of.CLOSE = true\n" - "\n" - "-- handle typedefs which swig doesn't wrap\n" - "of.Point = of.Vec3f\n" - "\n" - "-- class.lua\n" - "-- Compatible with Lua 5.1 (not 5.0).\n" - "function class(base, __init)\n" - " local c = {} -- a new class instance\n" - " if not __init and type(base) == 'function' then\n" - " __init = base\n" - " base = nil\n" - " elseif type(base) == 'table' then\n" - " -- our new class is a shallow copy of the base class!\n" - " for i,v in pairs(base) do\n" - " c[i] = v\n" - " end\n" - " c._base = base\n" - " end\n" - " -- the class will be the metatable for all its objects,\n" - " -- and they will look up their methods in it.\n" - " c.__index = c\n" - "\n" - " -- expose a constructor which can be called by ()\n" - " local mt = {}\n" - " mt.__call = function(class_tbl, ...)\n" - " local obj = {}\n" - " setmetatable(obj,c)\n" - " if class_tbl.__init then\n" - " class_tbl.__init(obj,...)\n" - " else\n" - " -- make sure that any stuff from the base class is initialized!\n" - " if base and base.__init then\n" - " base.__init(obj, ...)\n" - " end\n" - " end\n" - " return obj\n" - " end\n" - " c.__init = __init\n" - " c.is_a = function(self, klass)\n" - " local m = getmetatable(self)\n" - " while m do\n" - " if m == klass then return true end\n" - " m = m._base\n" - " end\n" - " return false\n" - " end\n" - " setmetatable(c, mt)\n" - " return c\n" - "end"; - -void SWIG_init_user(lua_State* L) -{ - /* exec Lua code if applicable */ - SWIG_Lua_dostring(L,SWIG_LUACODE); -} - diff --git a/addons/ofxLua/src/bindings/glmBindings.cpp b/addons/ofxLua/src/bindings/glmBindings.cpp new file mode 100644 index 0000000..abc2680 --- /dev/null +++ b/addons/ofxLua/src/bindings/glmBindings.cpp @@ -0,0 +1,10712 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 4.0.1 + * + * This file is not intended to be easily readable and contains a number of + * coding conventions designed to improve portability and efficiency. Do not make + * changes to this file unless you know what you are doing--modify the SWIG + * interface file instead. + * ----------------------------------------------------------------------------- */ + + +#ifndef SWIGLUA +#define SWIGLUA +#endif + +#define SWIG_LUA_TARGET SWIG_LUA_FLAVOR_LUA +#define SWIG_LUA_MODULE_GLOBAL + + +#ifdef __cplusplus +/* SwigValueWrapper is described in swig.swg */ +template class SwigValueWrapper { + struct SwigMovePointer { + T *ptr; + SwigMovePointer(T *p) : ptr(p) { } + ~SwigMovePointer() { delete ptr; } + SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; } + } pointer; + SwigValueWrapper& operator=(const SwigValueWrapper& rhs); + SwigValueWrapper(const SwigValueWrapper& rhs); +public: + SwigValueWrapper() : pointer(0) { } + SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; } + operator T&() const { return *pointer.ptr; } + T *operator&() { return pointer.ptr; } +}; + +template T SwigValueInit() { + return T(); +} +#endif + +/* ----------------------------------------------------------------------------- + * This section contains generic SWIG labels for method/variable + * declarations/attributes, and other compiler dependent labels. + * ----------------------------------------------------------------------------- */ + +/* template workaround for compilers that cannot correctly implement the C++ standard */ +#ifndef SWIGTEMPLATEDISAMBIGUATOR +# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560) +# define SWIGTEMPLATEDISAMBIGUATOR template +# elif defined(__HP_aCC) +/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */ +/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */ +# define SWIGTEMPLATEDISAMBIGUATOR template +# else +# define SWIGTEMPLATEDISAMBIGUATOR +# endif +#endif + +/* inline attribute */ +#ifndef SWIGINLINE +# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__)) +# define SWIGINLINE inline +# else +# define SWIGINLINE +# endif +#endif + +/* attribute recognised by some compilers to avoid 'unused' warnings */ +#ifndef SWIGUNUSED +# if defined(__GNUC__) +# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) +# define SWIGUNUSED __attribute__ ((__unused__)) +# else +# define SWIGUNUSED +# endif +# elif defined(__ICC) +# define SWIGUNUSED __attribute__ ((__unused__)) +# else +# define SWIGUNUSED +# endif +#endif + +#ifndef SWIG_MSC_UNSUPPRESS_4505 +# if defined(_MSC_VER) +# pragma warning(disable : 4505) /* unreferenced local function has been removed */ +# endif +#endif + +#ifndef SWIGUNUSEDPARM +# ifdef __cplusplus +# define SWIGUNUSEDPARM(p) +# else +# define SWIGUNUSEDPARM(p) p SWIGUNUSED +# endif +#endif + +/* internal SWIG method */ +#ifndef SWIGINTERN +# define SWIGINTERN static SWIGUNUSED +#endif + +/* internal inline SWIG method */ +#ifndef SWIGINTERNINLINE +# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE +#endif + +/* exporting methods */ +#if defined(__GNUC__) +# if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) +# ifndef GCC_HASCLASSVISIBILITY +# define GCC_HASCLASSVISIBILITY +# endif +# endif +#endif + +#ifndef SWIGEXPORT +# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) +# if defined(STATIC_LINKED) +# define SWIGEXPORT +# else +# define SWIGEXPORT __declspec(dllexport) +# endif +# else +# if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY) +# define SWIGEXPORT __attribute__ ((visibility("default"))) +# else +# define SWIGEXPORT +# endif +# endif +#endif + +/* calling conventions for Windows */ +#ifndef SWIGSTDCALL +# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) +# define SWIGSTDCALL __stdcall +# else +# define SWIGSTDCALL +# endif +#endif + +/* Deal with Microsoft's attempt at deprecating C standard runtime functions */ +#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE) +# define _CRT_SECURE_NO_DEPRECATE +#endif + +/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */ +#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE) +# define _SCL_SECURE_NO_DEPRECATE +#endif + +/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */ +#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES) +# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0 +#endif + +/* Intel's compiler complains if a variable which was never initialised is + * cast to void, which is a common idiom which we use to indicate that we + * are aware a variable isn't used. So we just silence that warning. + * See: https://github.com/swig/swig/issues/192 for more discussion. + */ +#ifdef __INTEL_COMPILER +# pragma warning disable 592 +#endif + +/* ----------------------------------------------------------------------------- + * swigrun.swg + * + * This file contains generic C API SWIG runtime support for pointer + * type checking. + * ----------------------------------------------------------------------------- */ + +/* This should only be incremented when either the layout of swig_type_info changes, + or for whatever reason, the runtime changes incompatibly */ +#define SWIG_RUNTIME_VERSION "4" + +/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */ +#ifdef SWIG_TYPE_TABLE +# define SWIG_QUOTE_STRING(x) #x +# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x) +# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE) +#else +# define SWIG_TYPE_TABLE_NAME +#endif + +/* + You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for + creating a static or dynamic library from the SWIG runtime code. + In 99.9% of the cases, SWIG just needs to declare them as 'static'. + + But only do this if strictly necessary, ie, if you have problems + with your compiler or suchlike. +*/ + +#ifndef SWIGRUNTIME +# define SWIGRUNTIME SWIGINTERN +#endif + +#ifndef SWIGRUNTIMEINLINE +# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE +#endif + +/* Generic buffer size */ +#ifndef SWIG_BUFFER_SIZE +# define SWIG_BUFFER_SIZE 1024 +#endif + +/* Flags for pointer conversions */ +#define SWIG_POINTER_DISOWN 0x1 +#define SWIG_CAST_NEW_MEMORY 0x2 +#define SWIG_POINTER_NO_NULL 0x4 + +/* Flags for new pointer objects */ +#define SWIG_POINTER_OWN 0x1 + + +/* + Flags/methods for returning states. + + The SWIG conversion methods, as ConvertPtr, return an integer + that tells if the conversion was successful or not. And if not, + an error code can be returned (see swigerrors.swg for the codes). + + Use the following macros/flags to set or process the returning + states. + + In old versions of SWIG, code such as the following was usually written: + + if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) { + // success code + } else { + //fail code + } + + Now you can be more explicit: + + int res = SWIG_ConvertPtr(obj,vptr,ty.flags); + if (SWIG_IsOK(res)) { + // success code + } else { + // fail code + } + + which is the same really, but now you can also do + + Type *ptr; + int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags); + if (SWIG_IsOK(res)) { + // success code + if (SWIG_IsNewObj(res) { + ... + delete *ptr; + } else { + ... + } + } else { + // fail code + } + + I.e., now SWIG_ConvertPtr can return new objects and you can + identify the case and take care of the deallocation. Of course that + also requires SWIG_ConvertPtr to return new result values, such as + + int SWIG_ConvertPtr(obj, ptr,...) { + if () { + if () { + *ptr = ; + return SWIG_NEWOBJ; + } else { + *ptr = ; + return SWIG_OLDOBJ; + } + } else { + return SWIG_BADOBJ; + } + } + + Of course, returning the plain '0(success)/-1(fail)' still works, but you can be + more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the + SWIG errors code. + + Finally, if the SWIG_CASTRANK_MODE is enabled, the result code + allows to return the 'cast rank', for example, if you have this + + int food(double) + int fooi(int); + + and you call + + food(1) // cast rank '1' (1 -> 1.0) + fooi(1) // cast rank '0' + + just use the SWIG_AddCast()/SWIG_CheckState() +*/ + +#define SWIG_OK (0) +#define SWIG_ERROR (-1) +#define SWIG_IsOK(r) (r >= 0) +#define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError) + +/* The CastRankLimit says how many bits are used for the cast rank */ +#define SWIG_CASTRANKLIMIT (1 << 8) +/* The NewMask denotes the object was created (using new/malloc) */ +#define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1) +/* The TmpMask is for in/out typemaps that use temporal objects */ +#define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1) +/* Simple returning values */ +#define SWIG_BADOBJ (SWIG_ERROR) +#define SWIG_OLDOBJ (SWIG_OK) +#define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK) +#define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK) +/* Check, add and del mask methods */ +#define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r) +#define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r) +#define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK)) +#define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r) +#define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r) +#define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK)) + +/* Cast-Rank Mode */ +#if defined(SWIG_CASTRANK_MODE) +# ifndef SWIG_TypeRank +# define SWIG_TypeRank unsigned long +# endif +# ifndef SWIG_MAXCASTRANK /* Default cast allowed */ +# define SWIG_MAXCASTRANK (2) +# endif +# define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1) +# define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK) +SWIGINTERNINLINE int SWIG_AddCast(int r) { + return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r; +} +SWIGINTERNINLINE int SWIG_CheckState(int r) { + return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0; +} +#else /* no cast-rank mode */ +# define SWIG_AddCast(r) (r) +# define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0) +#endif + + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef void *(*swig_converter_func)(void *, int *); +typedef struct swig_type_info *(*swig_dycast_func)(void **); + +/* Structure to store information on one type */ +typedef struct swig_type_info { + const char *name; /* mangled name of this type */ + const char *str; /* human readable name of this type */ + swig_dycast_func dcast; /* dynamic cast function down a hierarchy */ + struct swig_cast_info *cast; /* linked list of types that can cast into this type */ + void *clientdata; /* language specific type data */ + int owndata; /* flag if the structure owns the clientdata */ +} swig_type_info; + +/* Structure to store a type and conversion function used for casting */ +typedef struct swig_cast_info { + swig_type_info *type; /* pointer to type that is equivalent to this type */ + swig_converter_func converter; /* function to cast the void pointers */ + struct swig_cast_info *next; /* pointer to next cast in linked list */ + struct swig_cast_info *prev; /* pointer to the previous cast */ +} swig_cast_info; + +/* Structure used to store module information + * Each module generates one structure like this, and the runtime collects + * all of these structures and stores them in a circularly linked list.*/ +typedef struct swig_module_info { + swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */ + size_t size; /* Number of types in this module */ + struct swig_module_info *next; /* Pointer to next element in circularly linked list */ + swig_type_info **type_initial; /* Array of initially generated type structures */ + swig_cast_info **cast_initial; /* Array of initially generated casting structures */ + void *clientdata; /* Language specific module data */ +} swig_module_info; + +/* + Compare two type names skipping the space characters, therefore + "char*" == "char *" and "Class" == "Class", etc. + + Return 0 when the two name types are equivalent, as in + strncmp, but skipping ' '. +*/ +SWIGRUNTIME int +SWIG_TypeNameComp(const char *f1, const char *l1, + const char *f2, const char *l2) { + for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) { + while ((*f1 == ' ') && (f1 != l1)) ++f1; + while ((*f2 == ' ') && (f2 != l2)) ++f2; + if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1; + } + return (int)((l1 - f1) - (l2 - f2)); +} + +/* + Check type equivalence in a name list like ||... + Return 0 if equal, -1 if nb < tb, 1 if nb > tb +*/ +SWIGRUNTIME int +SWIG_TypeCmp(const char *nb, const char *tb) { + int equiv = 1; + const char* te = tb + strlen(tb); + const char* ne = nb; + while (equiv != 0 && *ne) { + for (nb = ne; *ne; ++ne) { + if (*ne == '|') break; + } + equiv = SWIG_TypeNameComp(nb, ne, tb, te); + if (*ne) ++ne; + } + return equiv; +} + +/* + Check type equivalence in a name list like ||... + Return 0 if not equal, 1 if equal +*/ +SWIGRUNTIME int +SWIG_TypeEquiv(const char *nb, const char *tb) { + return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0; +} + +/* + Check the typename +*/ +SWIGRUNTIME swig_cast_info * +SWIG_TypeCheck(const char *c, swig_type_info *ty) { + if (ty) { + swig_cast_info *iter = ty->cast; + while (iter) { + if (strcmp(iter->type->name, c) == 0) { + if (iter == ty->cast) + return iter; + /* Move iter to the top of the linked list */ + iter->prev->next = iter->next; + if (iter->next) + iter->next->prev = iter->prev; + iter->next = ty->cast; + iter->prev = 0; + if (ty->cast) ty->cast->prev = iter; + ty->cast = iter; + return iter; + } + iter = iter->next; + } + } + return 0; +} + +/* + Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison +*/ +SWIGRUNTIME swig_cast_info * +SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) { + if (ty) { + swig_cast_info *iter = ty->cast; + while (iter) { + if (iter->type == from) { + if (iter == ty->cast) + return iter; + /* Move iter to the top of the linked list */ + iter->prev->next = iter->next; + if (iter->next) + iter->next->prev = iter->prev; + iter->next = ty->cast; + iter->prev = 0; + if (ty->cast) ty->cast->prev = iter; + ty->cast = iter; + return iter; + } + iter = iter->next; + } + } + return 0; +} + +/* + Cast a pointer up an inheritance hierarchy +*/ +SWIGRUNTIMEINLINE void * +SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) { + return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory); +} + +/* + Dynamic pointer casting. Down an inheritance hierarchy +*/ +SWIGRUNTIME swig_type_info * +SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) { + swig_type_info *lastty = ty; + if (!ty || !ty->dcast) return ty; + while (ty && (ty->dcast)) { + ty = (*ty->dcast)(ptr); + if (ty) lastty = ty; + } + return lastty; +} + +/* + Return the name associated with this type +*/ +SWIGRUNTIMEINLINE const char * +SWIG_TypeName(const swig_type_info *ty) { + return ty->name; +} + +/* + Return the pretty name associated with this type, + that is an unmangled type name in a form presentable to the user. +*/ +SWIGRUNTIME const char * +SWIG_TypePrettyName(const swig_type_info *type) { + /* The "str" field contains the equivalent pretty names of the + type, separated by vertical-bar characters. We choose + to print the last name, as it is often (?) the most + specific. */ + if (!type) return NULL; + if (type->str != NULL) { + const char *last_name = type->str; + const char *s; + for (s = type->str; *s; s++) + if (*s == '|') last_name = s+1; + return last_name; + } + else + return type->name; +} + +/* + Set the clientdata field for a type +*/ +SWIGRUNTIME void +SWIG_TypeClientData(swig_type_info *ti, void *clientdata) { + swig_cast_info *cast = ti->cast; + /* if (ti->clientdata == clientdata) return; */ + ti->clientdata = clientdata; + + while (cast) { + if (!cast->converter) { + swig_type_info *tc = cast->type; + if (!tc->clientdata) { + SWIG_TypeClientData(tc, clientdata); + } + } + cast = cast->next; + } +} +SWIGRUNTIME void +SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) { + SWIG_TypeClientData(ti, clientdata); + ti->owndata = 1; +} + +/* + Search for a swig_type_info structure only by mangled name + Search is a O(log #types) + + We start searching at module start, and finish searching when start == end. + Note: if start == end at the beginning of the function, we go all the way around + the circular list. +*/ +SWIGRUNTIME swig_type_info * +SWIG_MangledTypeQueryModule(swig_module_info *start, + swig_module_info *end, + const char *name) { + swig_module_info *iter = start; + do { + if (iter->size) { + size_t l = 0; + size_t r = iter->size - 1; + do { + /* since l+r >= 0, we can (>> 1) instead (/ 2) */ + size_t i = (l + r) >> 1; + const char *iname = iter->types[i]->name; + if (iname) { + int compare = strcmp(name, iname); + if (compare == 0) { + return iter->types[i]; + } else if (compare < 0) { + if (i) { + r = i - 1; + } else { + break; + } + } else if (compare > 0) { + l = i + 1; + } + } else { + break; /* should never happen */ + } + } while (l <= r); + } + iter = iter->next; + } while (iter != end); + return 0; +} + +/* + Search for a swig_type_info structure for either a mangled name or a human readable name. + It first searches the mangled names of the types, which is a O(log #types) + If a type is not found it then searches the human readable names, which is O(#types). + + We start searching at module start, and finish searching when start == end. + Note: if start == end at the beginning of the function, we go all the way around + the circular list. +*/ +SWIGRUNTIME swig_type_info * +SWIG_TypeQueryModule(swig_module_info *start, + swig_module_info *end, + const char *name) { + /* STEP 1: Search the name field using binary search */ + swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name); + if (ret) { + return ret; + } else { + /* STEP 2: If the type hasn't been found, do a complete search + of the str field (the human readable name) */ + swig_module_info *iter = start; + do { + size_t i = 0; + for (; i < iter->size; ++i) { + if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name))) + return iter->types[i]; + } + iter = iter->next; + } while (iter != end); + } + + /* neither found a match */ + return 0; +} + +/* + Pack binary data into a string +*/ +SWIGRUNTIME char * +SWIG_PackData(char *c, void *ptr, size_t sz) { + static const char hex[17] = "0123456789abcdef"; + const unsigned char *u = (unsigned char *) ptr; + const unsigned char *eu = u + sz; + for (; u != eu; ++u) { + unsigned char uu = *u; + *(c++) = hex[(uu & 0xf0) >> 4]; + *(c++) = hex[uu & 0xf]; + } + return c; +} + +/* + Unpack binary data from a string +*/ +SWIGRUNTIME const char * +SWIG_UnpackData(const char *c, void *ptr, size_t sz) { + unsigned char *u = (unsigned char *) ptr; + const unsigned char *eu = u + sz; + for (; u != eu; ++u) { + char d = *(c++); + unsigned char uu; + if ((d >= '0') && (d <= '9')) + uu = (unsigned char)((d - '0') << 4); + else if ((d >= 'a') && (d <= 'f')) + uu = (unsigned char)((d - ('a'-10)) << 4); + else + return (char *) 0; + d = *(c++); + if ((d >= '0') && (d <= '9')) + uu |= (unsigned char)(d - '0'); + else if ((d >= 'a') && (d <= 'f')) + uu |= (unsigned char)(d - ('a'-10)); + else + return (char *) 0; + *u = uu; + } + return c; +} + +/* + Pack 'void *' into a string buffer. +*/ +SWIGRUNTIME char * +SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) { + char *r = buff; + if ((2*sizeof(void *) + 2) > bsz) return 0; + *(r++) = '_'; + r = SWIG_PackData(r,&ptr,sizeof(void *)); + if (strlen(name) + 1 > (bsz - (r - buff))) return 0; + strcpy(r,name); + return buff; +} + +SWIGRUNTIME const char * +SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) { + if (*c != '_') { + if (strcmp(c,"NULL") == 0) { + *ptr = (void *) 0; + return name; + } else { + return 0; + } + } + return SWIG_UnpackData(++c,ptr,sizeof(void *)); +} + +SWIGRUNTIME char * +SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) { + char *r = buff; + size_t lname = (name ? strlen(name) : 0); + if ((2*sz + 2 + lname) > bsz) return 0; + *(r++) = '_'; + r = SWIG_PackData(r,ptr,sz); + if (lname) { + strncpy(r,name,lname+1); + } else { + *r = 0; + } + return buff; +} + +SWIGRUNTIME const char * +SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) { + if (*c != '_') { + if (strcmp(c,"NULL") == 0) { + memset(ptr,0,sz); + return name; + } else { + return 0; + } + } + return SWIG_UnpackData(++c,ptr,sz); +} + +#ifdef __cplusplus +} +#endif + +/* Errors in SWIG */ +#define SWIG_UnknownError -1 +#define SWIG_IOError -2 +#define SWIG_RuntimeError -3 +#define SWIG_IndexError -4 +#define SWIG_TypeError -5 +#define SWIG_DivisionByZero -6 +#define SWIG_OverflowError -7 +#define SWIG_SyntaxError -8 +#define SWIG_ValueError -9 +#define SWIG_SystemError -10 +#define SWIG_AttributeError -11 +#define SWIG_MemoryError -12 +#define SWIG_NullReferenceError -13 + + + +/* ----------------------------------------------------------------------------- + * luarun.swg + * + * This file contains the runtime support for Lua modules + * and includes code for managing global variables and pointer + * type checking. + * ----------------------------------------------------------------------------- */ + +#ifdef __cplusplus +extern "C" { +#endif + +#include "lua.h" +#include "lauxlib.h" +#include /* for malloc */ +#include /* for a few sanity tests */ + +/* ----------------------------------------------------------------------------- + * Lua flavors + * ----------------------------------------------------------------------------- */ + +#define SWIG_LUA_FLAVOR_LUA 1 +#define SWIG_LUA_FLAVOR_ELUA 2 +#define SWIG_LUA_FLAVOR_ELUAC 3 + +#if !defined(SWIG_LUA_TARGET) +# error SWIG_LUA_TARGET not defined +#endif + +#if defined(SWIG_LUA_ELUA_EMULATE) + +struct swig_elua_entry; + +typedef struct swig_elua_key { + int type; + union { + const char* strkey; + lua_Number numkey; + } key; +} swig_elua_key; + +typedef struct swig_elua_val { + int type; + union { + lua_Number number; + const struct swig_elua_entry *table; + const char *string; + lua_CFunction function; + struct { + char member; + long lvalue; + void *pvalue; + swig_type_info **ptype; + } userdata; + } value; +} swig_elua_val; + +typedef struct swig_elua_entry { + swig_elua_key key; + swig_elua_val value; +} swig_elua_entry; + +#define LSTRKEY(x) {LUA_TSTRING, {.strkey = x} } +#define LNUMKEY(x) {LUA_TNUMBER, {.numkey = x} } +#define LNILKEY {LUA_TNIL, {.strkey = 0} } + +#define LNUMVAL(x) {LUA_TNUMBER, {.number = x} } +#define LFUNCVAL(x) {LUA_TFUNCTION, {.function = x} } +#define LROVAL(x) {LUA_TTABLE, {.table = x} } +#define LNILVAL {LUA_TNIL, {.string = 0} } +#define LSTRVAL(x) {LUA_TSTRING, {.string = x} } + +#define LUA_REG_TYPE swig_elua_entry + +#define SWIG_LUA_ELUA_EMUL_METATABLE_KEY "__metatable" + +#define lua_pushrotable(L,p)\ + lua_newtable(L);\ + assert(p);\ + SWIG_Lua_elua_emulate_register(L,(swig_elua_entry*)(p)); + +#define SWIG_LUA_CONSTTAB_POINTER(B,C,D)\ + LSTRKEY(B), {LUA_TUSERDATA, { .userdata={0,0,(void*)(C),&D} } } + +#define SWIG_LUA_CONSTTAB_BINARY(B,S,C,D)\ + LSTRKEY(B), {LUA_TUSERDATA, { .userdata={1,S,(void*)(C),&D} } } +#endif + +#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC) +# define SWIG_LUA_CONSTTAB_INT(B, C) LSTRKEY(B), LNUMVAL(C) +# define SWIG_LUA_CONSTTAB_FLOAT(B, C) LSTRKEY(B), LNUMVAL(C) +# define SWIG_LUA_CONSTTAB_STRING(B, C) LSTRKEY(B), LSTRVAL(C) +# define SWIG_LUA_CONSTTAB_CHAR(B, C) LSTRKEY(B), LNUMVAL(C) + /* Those two types of constants are not supported in elua */ + +#ifndef SWIG_LUA_CONSTTAB_POINTER +#warning eLua does not support pointers as constants. By default, nil will be used as value +#define SWIG_LUA_CONSTTAB_POINTER(B,C,D) LSTRKEY(B), LNILVAL +#endif + +#ifndef SWIG_LUA_CONSTTAB_BINARY +#warning eLua does not support pointers to member as constants. By default, nil will be used as value +#define SWIG_LUA_CONSTTAB_BINARY(B, S, C, D) LSTRKEY(B), LNILVAL +#endif +#else /* SWIG_LUA_FLAVOR_LUA */ +# define SWIG_LUA_CONSTTAB_INT(B, C) SWIG_LUA_INT, (char *)B, (long)C, 0, 0, 0 +# define SWIG_LUA_CONSTTAB_FLOAT(B, C) SWIG_LUA_FLOAT, (char *)B, 0, (double)C, 0, 0 +# define SWIG_LUA_CONSTTAB_STRING(B, C) SWIG_LUA_STRING, (char *)B, 0, 0, (void *)C, 0 +# define SWIG_LUA_CONSTTAB_CHAR(B, C) SWIG_LUA_CHAR, (char *)B, (long)C, 0, 0, 0 +# define SWIG_LUA_CONSTTAB_POINTER(B,C,D)\ + SWIG_LUA_POINTER, (char *)B, 0, 0, (void *)C, &D +# define SWIG_LUA_CONSTTAB_BINARY(B, S, C, D)\ + SWIG_LUA_BINARY, (char *)B, S, 0, (void *)C, &D +#endif + +#ifndef SWIG_LUA_ELUA_EMULATE +#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC) +# define LRO_STRVAL(v) {{.p = (char *) v}, LUA_TSTRING} +# define LSTRVAL LRO_STRVAL +#endif +#endif /* SWIG_LUA_ELUA_EMULATE*/ + +#ifndef SWIG_LUA_ELUA_EMULATE +#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC) + +#ifndef MIN_OPT_LEVEL +#define MIN_OPT_LEVEL 2 +#endif + +#include "lrodefs.h" +#include "lrotable.h" +#endif +#endif /* SWIG_LUA_ELUA_EMULATE*/ +/* ----------------------------------------------------------------------------- + * compatibility defines + * ----------------------------------------------------------------------------- */ + +/* History of Lua C API length functions: In Lua 5.0 (and before?) + there was "lua_strlen". In Lua 5.1, this was renamed "lua_objlen", + but a compatibility define of "lua_strlen" was added. In Lua 5.2, + this function was again renamed, to "lua_rawlen" (to emphasize that + it doesn't call the "__len" metamethod), and the compatibility + define of lua_strlen was removed. All SWIG uses have been updated + to "lua_rawlen", and we add our own defines of that here for older + versions of Lua. */ +#if !defined(LUA_VERSION_NUM) || LUA_VERSION_NUM < 501 +# define lua_rawlen lua_strlen +#elif LUA_VERSION_NUM == 501 +# define lua_rawlen lua_objlen +#endif + + +/* lua_pushglobaltable is the recommended "future-proof" way to get + the global table for Lua 5.2 and later. Here we define + lua_pushglobaltable ourselves for Lua versions before 5.2. */ +#if !defined(LUA_VERSION_NUM) || LUA_VERSION_NUM < 502 +# define lua_pushglobaltable(L) lua_pushvalue(L, LUA_GLOBALSINDEX) +#endif + +/* lua_absindex was introduced in Lua 5.2 */ +#if !defined(LUA_VERSION_NUM) || LUA_VERSION_NUM < 502 +# define lua_absindex(L,i) ((i)>0 || (i) <= LUA_REGISTRYINDEX ? (i) : lua_gettop(L) + (i) + 1) +#endif + +/* lua_rawsetp was introduced in Lua 5.2 */ +#if !defined(LUA_VERSION_NUM) || LUA_VERSION_NUM < 502 +#define lua_rawsetp(L,index,ptr)\ + lua_pushlightuserdata(L,(void*)(ptr));\ + lua_insert(L,-2);\ + lua_rawset(L,index); + +#define lua_rawgetp(L,index,ptr)\ + lua_pushlightuserdata(L,(void*)(ptr));\ + lua_rawget(L,index); + +#endif + +/* -------------------------------------------------------------------------- + * Helper functions for error handling + * -------------------------------------------------------------------------- */ + +/* Push the string STR on the Lua stack, like lua_pushstring, but + prefixed with the location of the innermost Lua call-point + (as formatted by luaL_where). */ +SWIGRUNTIME void +SWIG_Lua_pusherrstring (lua_State *L, const char *str) +{ + luaL_where (L, 1); + lua_pushstring (L, str); + lua_concat (L, 2); +} + +/* Push a formatted string generated from FMT and following args on + the Lua stack, like lua_pushfstring, but prefixed with the + location of the innermost Lua call-point (as formatted by luaL_where). */ +SWIGRUNTIME void +SWIG_Lua_pushferrstring (lua_State *L, const char *fmt, ...) +{ + va_list argp; + va_start(argp, fmt); + luaL_where(L, 1); + lua_pushvfstring(L, fmt, argp); + va_end(argp); + lua_concat(L, 2); +} + + +/* ----------------------------------------------------------------------------- + * global swig types + * ----------------------------------------------------------------------------- */ +/* Constant table */ +#define SWIG_LUA_INT 1 +#define SWIG_LUA_FLOAT 2 +#define SWIG_LUA_STRING 3 +#define SWIG_LUA_POINTER 4 +#define SWIG_LUA_BINARY 5 +#define SWIG_LUA_CHAR 6 + +/* Structure for variable linking table */ +typedef struct { + const char *name; + lua_CFunction get; + lua_CFunction set; +} swig_lua_var_info; + +#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC) +typedef const LUA_REG_TYPE swig_lua_method; +typedef const LUA_REG_TYPE swig_lua_const_info; +#else /* Normal lua */ +typedef luaL_Reg swig_lua_method; + +/* Constant information structure */ +typedef struct { + int type; + char *name; + long lvalue; + double dvalue; + void *pvalue; + swig_type_info **ptype; +} swig_lua_const_info; + +#endif + +typedef struct { + const char *name; + lua_CFunction getmethod; + lua_CFunction setmethod; +} swig_lua_attribute; + + +struct swig_lua_class; +/* Can be used to create namespaces. Currently used to wrap class static methods/variables/constants */ +typedef struct swig_lua_namespace { + const char *name; + swig_lua_method *ns_methods; + swig_lua_attribute *ns_attributes; + swig_lua_const_info *ns_constants; + struct swig_lua_class **ns_classes; + struct swig_lua_namespace **ns_namespaces; +} swig_lua_namespace; + +typedef struct swig_lua_class { + const char *name; /* Name that this class has in Lua */ + const char *fqname; /* Fully qualified name - Scope + class name */ + swig_type_info **type; + lua_CFunction constructor; + void (*destructor)(void *); + swig_lua_method *methods; + swig_lua_attribute *attributes; + swig_lua_namespace *cls_static; + swig_lua_method *metatable; /* 0 for -eluac */ + struct swig_lua_class **bases; + const char **base_names; +} swig_lua_class; + +/* this is the struct for wrapping all pointers in SwigLua +*/ +typedef struct { + swig_type_info *type; + int own; /* 1 if owned & must be destroyed */ + void *ptr; +} swig_lua_userdata; + +/* this is the struct for wrapping arbitrary packed binary data +(currently it is only used for member function pointers) +the data ordering is similar to swig_lua_userdata, but it is currently not possible +to tell the two structures apart within SWIG, other than by looking at the type +*/ +typedef struct { + swig_type_info *type; + int own; /* 1 if owned & must be destroyed */ + char data[1]; /* arbitrary amount of data */ +} swig_lua_rawdata; + +/* Common SWIG API */ +#define SWIG_NewPointerObj(L, ptr, type, owner) SWIG_Lua_NewPointerObj(L, (void *)ptr, type, owner) +#define SWIG_ConvertPtr(L,idx, ptr, type, flags) SWIG_Lua_ConvertPtr(L,idx,ptr,type,flags) +#define SWIG_MustGetPtr(L,idx, type,flags, argnum,fnname) SWIG_Lua_MustGetPtr(L,idx, type,flags, argnum,fnname) +/* for C++ member pointers, ie, member methods */ +#define SWIG_ConvertMember(L, idx, ptr, sz, ty) SWIG_Lua_ConvertPacked(L, idx, ptr, sz, ty) +#define SWIG_NewMemberObj(L, ptr, sz, type) SWIG_Lua_NewPackedObj(L, ptr, sz, type) + +/* Runtime API */ +#define SWIG_GetModule(clientdata) SWIG_Lua_GetModule((lua_State*)(clientdata)) +#define SWIG_SetModule(clientdata, pointer) SWIG_Lua_SetModule((lua_State*) (clientdata), pointer) +#define SWIG_MODULE_CLIENTDATA_TYPE lua_State* + +/* Contract support */ +#define SWIG_contract_assert(expr, msg) \ + if (!(expr)) { SWIG_Lua_pusherrstring(L, (char *) msg); goto fail; } else + + +/* helper #defines */ +#define SWIG_fail {goto fail;} +#define SWIG_fail_arg(func_name,argnum,type) \ + {SWIG_Lua_pushferrstring(L,"Error in %s (arg %d), expected '%s' got '%s'",\ + func_name,argnum,type,SWIG_Lua_typename(L,argnum));\ + goto fail;} +#define SWIG_fail_ptr(func_name,argnum,type) \ + SWIG_fail_arg(func_name,argnum,(type && type->str)?type->str:"void*") +#define SWIG_check_num_args(func_name,a,b) \ + if (lua_gettop(L)b) \ + {SWIG_Lua_pushferrstring(L,"Error in %s expected %d..%d args, got %d",func_name,a,b,lua_gettop(L));\ + goto fail;} + + +#define SWIG_Lua_get_table(L,n) \ + (lua_pushstring(L, n), lua_rawget(L,-2)) + +#define SWIG_Lua_add_function(L,n,f) \ + (lua_pushstring(L, n), \ + lua_pushcfunction(L, f), \ + lua_rawset(L,-3)) + +#define SWIG_Lua_add_boolean(L,n,b) \ + (lua_pushstring(L, n), \ + lua_pushboolean(L, b), \ + lua_rawset(L,-3)) + +/* special helper for allowing 'nil' for usertypes */ +#define SWIG_isptrtype(L,I) (lua_isuserdata(L,I) || lua_isnil(L,I)) + +#ifdef __cplusplus +/* Special helper for member function pointers +it gets the address, casts it, then dereferences it */ +/*#define SWIG_mem_fn_as_voidptr(a) (*((char**)&(a))) */ +#endif + +/* storing/access of swig_module_info */ +SWIGRUNTIME swig_module_info * +SWIG_Lua_GetModule(lua_State *L) { + swig_module_info *ret = 0; + lua_pushstring(L,"swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME); + lua_rawget(L,LUA_REGISTRYINDEX); + if (lua_islightuserdata(L,-1)) + ret=(swig_module_info*)lua_touserdata(L,-1); + lua_pop(L,1); /* tidy */ + return ret; +} + +SWIGRUNTIME void +SWIG_Lua_SetModule(lua_State *L, swig_module_info *module) { + /* add this all into the Lua registry: */ + lua_pushstring(L,"swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME); + lua_pushlightuserdata(L,(void*)module); + lua_rawset(L,LUA_REGISTRYINDEX); +} + +/* ----------------------------------------------------------------------------- + * global variable support code: modules + * ----------------------------------------------------------------------------- */ + +/* this function is called when trying to set an immutable. +default action is to print an error. +This can removed with a compile flag SWIGLUA_IGNORE_SET_IMMUTABLE */ +SWIGINTERN int SWIG_Lua_set_immutable(lua_State *L) +{ +/* there should be 1 param passed in: the new value */ +#ifndef SWIGLUA_IGNORE_SET_IMMUTABLE + lua_pop(L,1); /* remove it */ + luaL_error(L,"This variable is immutable"); +#endif + return 0; /* should not return anything */ +} + +#ifdef SWIG_LUA_ELUA_EMULATE + +SWIGRUNTIME void SWIG_Lua_NewPointerObj(lua_State *L,void *ptr,swig_type_info *type, int own); +SWIGRUNTIME void SWIG_Lua_NewPackedObj(lua_State *L,void *ptr,size_t size,swig_type_info *type); +static int swig_lua_elua_emulate_unique_key; + +/* This function emulates eLua rotables behaviour. It loads a rotable definition into the usual lua table. */ +SWIGINTERN void SWIG_Lua_elua_emulate_register(lua_State *L, const swig_elua_entry *table) +{ + int i, table_parsed, parsed_tables_array, target_table; + assert(lua_istable(L,-1)); + target_table = lua_gettop(L); + /* Get the registry where we put all parsed tables to avoid loops */ + lua_rawgetp(L, LUA_REGISTRYINDEX, &swig_lua_elua_emulate_unique_key); + if(lua_isnil(L,-1)) { + lua_pop(L,1); + lua_newtable(L); + lua_pushvalue(L,-1); + lua_rawsetp(L,LUA_REGISTRYINDEX,(void*)(&swig_lua_elua_emulate_unique_key)); + } + parsed_tables_array = lua_gettop(L); + lua_pushvalue(L,target_table); + lua_rawsetp(L, parsed_tables_array, table); + table_parsed = 0; + const int SWIGUNUSED pairs_start = lua_gettop(L); + for(i = 0;table[i].key.type != LUA_TNIL || table[i].value.type != LUA_TNIL;i++) + { + const swig_elua_entry *entry = table + i; + int is_metatable = 0; + switch(entry->key.type) { + case LUA_TSTRING: + lua_pushstring(L,entry->key.key.strkey); + if(strcmp(entry->key.key.strkey, SWIG_LUA_ELUA_EMUL_METATABLE_KEY) == 0) + is_metatable = 1; + break; + case LUA_TNUMBER: + lua_pushnumber(L,entry->key.key.numkey); + break; + case LUA_TNIL: + lua_pushnil(L); + break; + default: + assert(0); + } + switch(entry->value.type) { + case LUA_TSTRING: + lua_pushstring(L,entry->value.value.string); + break; + case LUA_TNUMBER: + lua_pushnumber(L,entry->value.value.number); + break; + case LUA_TFUNCTION: + lua_pushcfunction(L,entry->value.value.function); + break; + case LUA_TTABLE: + lua_rawgetp(L,parsed_tables_array, entry->value.value.table); + table_parsed = !lua_isnil(L,-1); + if(!table_parsed) { + lua_pop(L,1); /*remove nil */ + lua_newtable(L); + SWIG_Lua_elua_emulate_register(L,entry->value.value.table); + } + if(is_metatable) { + assert(lua_istable(L,-1)); + lua_pushvalue(L,-1); + lua_setmetatable(L,target_table); + } + + break; + case LUA_TUSERDATA: + if(entry->value.value.userdata.member) + SWIG_NewMemberObj(L,entry->value.value.userdata.pvalue, + entry->value.value.userdata.lvalue, + *(entry->value.value.userdata.ptype)); + else + SWIG_NewPointerObj(L,entry->value.value.userdata.pvalue, + *(entry->value.value.userdata.ptype),0); + break; + case LUA_TNIL: + lua_pushnil(L); + break; + default: + assert(0); + } + assert(lua_gettop(L) == pairs_start + 2); + lua_rawset(L,target_table); + } + lua_pop(L,1); /* Removing parsed tables storage */ + assert(lua_gettop(L) == target_table); +} + +SWIGINTERN void SWIG_Lua_elua_emulate_register_clear(lua_State *L) +{ + lua_pushnil(L); + lua_rawsetp(L, LUA_REGISTRYINDEX, &swig_lua_elua_emulate_unique_key); +} + +SWIGINTERN void SWIG_Lua_get_class_registry(lua_State *L); + +SWIGINTERN int SWIG_Lua_emulate_elua_getmetatable(lua_State *L) +{ + SWIG_check_num_args("getmetatable(SWIG eLua emulation)", 1, 1); + SWIG_Lua_get_class_registry(L); + lua_getfield(L,-1,"lua_getmetatable"); + lua_remove(L,-2); /* remove the registry*/ + assert(!lua_isnil(L,-1)); + lua_pushvalue(L,1); + assert(lua_gettop(L) == 3); /* object | function | object again */ + lua_call(L,1,1); + if(!lua_isnil(L,-1)) /*There is an ordinary metatable */ + return 1; + /*if it is a table, then emulate elua behaviour - check for __metatable attribute of a table*/ + assert(lua_gettop(L) == 2); + if(lua_istable(L,-2)) { + lua_pop(L,1); /*remove the nil*/ + lua_getfield(L,-1, SWIG_LUA_ELUA_EMUL_METATABLE_KEY); + } + assert(lua_gettop(L) == 2); + return 1; + +fail: + lua_error(L); + return 0; +} + +SWIGINTERN void SWIG_Lua_emulate_elua_swap_getmetatable(lua_State *L) +{ + SWIG_Lua_get_class_registry(L); + lua_pushglobaltable(L); + lua_pushstring(L,"lua_getmetatable"); + lua_getfield(L,-2,"getmetatable"); + assert(!lua_isnil(L,-1)); + lua_rawset(L,-4); + lua_pushstring(L, "getmetatable"); + lua_pushcfunction(L, SWIG_Lua_emulate_elua_getmetatable); + lua_rawset(L,-3); + lua_pop(L,2); + +} +/* END OF REMOVE */ + +#endif +/* ----------------------------------------------------------------------------- + * global variable support code: namespaces and modules (which are the same thing) + * ----------------------------------------------------------------------------- */ + +SWIGINTERN int SWIG_Lua_namespace_get(lua_State *L) +{ +/* there should be 2 params passed in + (1) table (not the meta table) + (2) string name of the attribute +*/ + assert(lua_istable(L,-2)); /* just in case */ + lua_getmetatable(L,-2); + assert(lua_istable(L,-1)); + SWIG_Lua_get_table(L,".get"); /* find the .get table */ + assert(lua_istable(L,-1)); + /* look for the key in the .get table */ + lua_pushvalue(L,2); /* key */ + lua_rawget(L,-2); + lua_remove(L,-2); /* stack tidy, remove .get table */ + if (lua_iscfunction(L,-1)) + { /* found it so call the fn & return its value */ + lua_call(L,0,1); /* 1 value in (userdata),1 out (result) */ + lua_remove(L,-2); /* stack tidy, remove metatable */ + return 1; + } + lua_pop(L,1); /* remove whatever was there */ + /* ok, so try the .fn table */ + SWIG_Lua_get_table(L,".fn"); /* find the .get table */ + assert(lua_istable(L,-1)); /* just in case */ + lua_pushvalue(L,2); /* key */ + lua_rawget(L,-2); /* look for the fn */ + lua_remove(L,-2); /* stack tidy, remove .fn table */ + if (lua_isfunction(L,-1)) /* note: whether it's a C function or lua function */ + { /* found it so return the fn & let lua call it */ + lua_remove(L,-2); /* stack tidy, remove metatable */ + return 1; + } + lua_pop(L,1); /* remove whatever was there */ + return 0; +} + +SWIGINTERN int SWIG_Lua_namespace_set(lua_State *L) +{ +/* there should be 3 params passed in + (1) table (not the meta table) + (2) string name of the attribute + (3) any for the new value +*/ + + assert(lua_istable(L,1)); + lua_getmetatable(L,1); /* get the meta table */ + assert(lua_istable(L,-1)); + + SWIG_Lua_get_table(L,".set"); /* find the .set table */ + if (lua_istable(L,-1)) + { + /* look for the key in the .set table */ + lua_pushvalue(L,2); /* key */ + lua_rawget(L,-2); + if (lua_iscfunction(L,-1)) + { /* found it so call the fn & return its value */ + lua_pushvalue(L,3); /* value */ + lua_call(L,1,0); + return 0; + } + lua_pop(L,1); /* remove the value */ + } + lua_pop(L,1); /* remove the value .set table */ + lua_pop(L,1); /* remote metatable */ + lua_rawset(L,-3); + return 0; +} + +#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA) /* In elua this is useless */ +SWIGINTERN void SWIG_Lua_InstallConstants(lua_State *L, swig_lua_const_info constants[]); /* forward declaration */ +SWIGINTERN void SWIG_Lua_add_variable(lua_State *L,const char *name,lua_CFunction getFn,lua_CFunction setFn); /* forward declaration */ +SWIGINTERN void SWIG_Lua_class_register(lua_State *L,swig_lua_class *clss); + +/* helper function - register namespace methods and attributes into namespace */ +SWIGINTERN int SWIG_Lua_add_namespace_details(lua_State *L, swig_lua_namespace *ns) +{ + int i; + /* There must be namespace table (not metatable) at the top of the stack */ + assert(lua_istable(L,-1)); + SWIG_Lua_InstallConstants(L, ns->ns_constants); + + /* add methods to the namespace/module table */ + for(i=0;ns->ns_methods[i].name;i++){ + SWIG_Lua_add_function(L,ns->ns_methods[i].name,ns->ns_methods[i].func); + } + lua_getmetatable(L,-1); + + /* add fns */ + for(i=0;ns->ns_attributes[i].name;i++){ + SWIG_Lua_add_variable(L,ns->ns_attributes[i].name,ns->ns_attributes[i].getmethod,ns->ns_attributes[i].setmethod); + } + + /* clear stack - remove metatble */ + lua_pop(L,1); + return 0; +} + +/* Register all classes in the namespace */ +SWIGINTERN void SWIG_Lua_add_namespace_classes(lua_State *L, swig_lua_namespace *ns) +{ + swig_lua_class **classes; + + /* There must be a module/namespace table at the top of the stack */ + assert(lua_istable(L,-1)); + + classes = ns->ns_classes; + + if( classes != 0 ) { + while(*classes != 0) { + SWIG_Lua_class_register(L, *classes); + classes++; + } + } +} + +/* Helper function. Creates namespace table and adds it to module table + if 'reg' is true, then will register namespace table to parent one (must be on top of the stack + when function is called). + Function always returns newly registered table on top of the stack. +*/ +SWIGINTERN void SWIG_Lua_namespace_register(lua_State *L, swig_lua_namespace *ns, int reg) +{ + swig_lua_namespace **sub_namespace; + /* 1 argument - table on the top of the stack */ + const int SWIGUNUSED begin = lua_gettop(L); + assert(lua_istable(L,-1)); /* just in case. This is supposed to be module table or parent namespace table */ + lua_checkstack(L,5); + lua_newtable(L); /* namespace itself */ + lua_newtable(L); /* metatable for namespace */ + + /* add a table called ".get" */ + lua_pushstring(L,".get"); + lua_newtable(L); + lua_rawset(L,-3); + /* add a table called ".set" */ + lua_pushstring(L,".set"); + lua_newtable(L); + lua_rawset(L,-3); + /* add a table called ".fn" */ + lua_pushstring(L,".fn"); + lua_newtable(L); + lua_rawset(L,-3); + + /* add accessor fns for using the .get,.set&.fn */ + SWIG_Lua_add_function(L,"__index",SWIG_Lua_namespace_get); + SWIG_Lua_add_function(L,"__newindex",SWIG_Lua_namespace_set); + + lua_setmetatable(L,-2); /* set metatable */ + + /* Register all functions, variables etc */ + SWIG_Lua_add_namespace_details(L,ns); + /* Register classes */ + SWIG_Lua_add_namespace_classes(L,ns); + + sub_namespace = ns->ns_namespaces; + if( sub_namespace != 0) { + while(*sub_namespace != 0) { + SWIG_Lua_namespace_register(L, *sub_namespace, 1); + lua_pop(L,1); /* removing sub-namespace table */ + sub_namespace++; + } + } + + if (reg) { + lua_pushstring(L,ns->name); + lua_pushvalue(L,-2); + lua_rawset(L,-4); /* add namespace to module table */ + } + assert(lua_gettop(L) == begin+1); +} +#endif /* SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA */ + +/* ----------------------------------------------------------------------------- + * global variable support code: classes + * ----------------------------------------------------------------------------- */ + +SWIGINTERN void SWIG_Lua_get_class_metatable(lua_State *L,const char *cname); + +typedef int (*swig_lua_base_iterator_func)(lua_State*,swig_type_info*, int, int *ret); + +SWIGINTERN int SWIG_Lua_iterate_bases(lua_State *L, swig_type_info * SWIGUNUSED swig_type, + int first_arg, swig_lua_base_iterator_func func, int *const ret) +{ + /* first_arg - position of the object in stack. Everything that is above are arguments + * and is passed to every evocation of the func */ + int last_arg = lua_gettop(L);/* position of last argument */ + int original_metatable = last_arg + 1; + size_t bases_count; + int result = SWIG_ERROR; + int bases_table; + (void)swig_type; + lua_getmetatable(L,first_arg); + + /* initialise base search */ +#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA) + SWIG_Lua_get_table(L,".bases"); + assert(lua_istable(L,-1)); + bases_count = lua_rawlen(L,-1); + bases_table = lua_gettop(L); +#else + /* In elua .bases table doesn't exist. Use table from swig_lua_class */ + (void)bases_table; + assert(swig_type!=0); + swig_module_info *module=SWIG_GetModule(L); + swig_lua_class **bases= ((swig_lua_class*)(swig_type->clientdata))->bases; + const char **base_names= ((swig_lua_class*)(swig_type->clientdata))->base_names; + bases_count = 0; + for(;base_names[bases_count]; + bases_count++);/* get length of bases */ +#endif + + if(ret) + *ret = 0; + if(bases_count>0) + { + int to_remove; + size_t i; + int j; + int subcall_last_arg; + int subcall_first_arg = lua_gettop(L) + 1;/* Here a copy of first_arg and arguments begin */ + int valid = 1; + swig_type_info *base_swig_type = 0; + for(j=first_arg;j<=last_arg;j++) + lua_pushvalue(L,j); + subcall_last_arg = lua_gettop(L); + + /* Trick: temporarily replacing original metatable with metatable for base class and call getter */ + for(i=0;ifqname); + base_swig_type = SWIG_TypeQueryModule(module,module,base_names[i]); + assert(base_swig_type != 0); + } +#endif + + if(!valid) + continue; + assert(lua_isuserdata(L, subcall_first_arg)); + assert(lua_istable(L,-1)); + lua_setmetatable(L,subcall_first_arg); /* Set new metatable */ + assert(lua_gettop(L) == subcall_last_arg); + result = func(L, base_swig_type,subcall_first_arg, ret); /* Forward call */ + if(result != SWIG_ERROR) { + break; + } + } + /* Restore original metatable */ + lua_pushvalue(L,original_metatable); + lua_setmetatable(L,first_arg); + /* Clear - remove everything between last_arg and subcall_last_arg including */ + to_remove = subcall_last_arg - last_arg; + for(j=0;jtype; + result = SWIG_Lua_class_do_get(L,type,1,&ret); + if(result == SWIG_OK) + return ret; + + result = SWIG_Lua_class_do_get_item(L,type,1,&ret); + if(result == SWIG_OK) + return ret; + + return 0; +} + +/* helper for the class.set method, performs the lookup of class attributes + * It returns error code. Number of function return values is passed inside 'ret' + */ +SWIGINTERN int SWIG_Lua_class_do_set(lua_State *L, swig_type_info *type, int first_arg, int *ret) +{ +/* there should be 3 params passed in + (1) table (not the meta table) + (2) string name of the attribute + (3) any for the new value + */ + + int bases_search_result; + int substack_start = lua_gettop(L) - 3; + lua_checkstack(L,5); + assert(lua_isuserdata(L,substack_start+1)); /* just in case */ + lua_getmetatable(L,substack_start+1); /* get the meta table */ + assert(lua_istable(L,-1)); /* just in case */ + if(ret) + *ret = 0; /* it is setter - number of return values is always 0 */ + + SWIG_Lua_get_table(L,".set"); /* find the .set table */ + if (lua_istable(L,-1)) + { + /* look for the key in the .set table */ + lua_pushvalue(L,substack_start+2); /* key */ + lua_rawget(L,-2); + lua_remove(L,-2); /* tidy stack, remove .set table */ + if (lua_iscfunction(L,-1)) + { /* found it so call the fn & return its value */ + lua_pushvalue(L,substack_start+1); /* userdata */ + lua_pushvalue(L,substack_start+3); /* value */ + lua_call(L,2,0); + lua_remove(L,substack_start+4); /*remove metatable*/ + return SWIG_OK; + } + lua_pop(L,1); /* remove the value */ + } else { + lua_pop(L,1); /* remove the answer for .set table request*/ + } + /* NEW: looks for the __setitem() fn + this is a user provided set fn */ + SWIG_Lua_get_table(L,"__setitem"); /* find the fn */ + if (lua_iscfunction(L,-1)) /* if its there */ + { /* found it so call the fn & return its value */ + lua_pushvalue(L,substack_start+1); /* the userdata */ + lua_pushvalue(L,substack_start+2); /* the parameter */ + lua_pushvalue(L,substack_start+3); /* the value */ + lua_call(L,3,0); /* 3 values in ,0 out */ + lua_remove(L,-2); /* stack tidy, remove metatable */ + return SWIG_OK; + } + lua_pop(L,1); /* remove value */ + + lua_pop(L,1); /* remove metatable */ + /* Search among bases */ + bases_search_result = SWIG_Lua_iterate_bases(L,type,first_arg,SWIG_Lua_class_do_set,ret); + if(ret) + assert(*ret == 0); + assert(lua_gettop(L) == substack_start + 3); + return bases_search_result; +} + +/* This is the actual method exported to Lua. It calls SWIG_Lua_class_do_set and correctly + * handles return values. + */ +SWIGINTERN int SWIG_Lua_class_set(lua_State *L) +{ +/* There should be 3 params passed in + (1) table (not the meta table) + (2) string name of the attribute + (3) any for the new value + */ + int ret = 0; + int result; + swig_lua_userdata *usr; + swig_type_info *type; + assert(lua_isuserdata(L,1)); + usr=(swig_lua_userdata*)lua_touserdata(L,1); /* get data */ + type = usr->type; + result = SWIG_Lua_class_do_set(L,type,1,&ret); + if(result != SWIG_OK) { + SWIG_Lua_pushferrstring(L,"Assignment not possible. No setter/member with this name. For custom assignments implement __setitem method."); + lua_error(L); + } else { + assert(ret==0); + } + return 0; +} + +/* the class.destruct method called by the interpreter */ +SWIGINTERN int SWIG_Lua_class_destruct(lua_State *L) +{ +/* there should be 1 params passed in + (1) userdata (not the meta table) */ + swig_lua_userdata *usr; + swig_lua_class *clss; + assert(lua_isuserdata(L,-1)); /* just in case */ + usr=(swig_lua_userdata*)lua_touserdata(L,-1); /* get it */ + /* if must be destroyed & has a destructor */ + if (usr->own) /* if must be destroyed */ + { + clss=(swig_lua_class*)usr->type->clientdata; /* get the class */ + if (clss && clss->destructor) /* there is a destroy fn */ + { + clss->destructor(usr->ptr); /* bye bye */ + } + } + return 0; +} + +/* the class.__tostring method called by the interpreter and print */ +SWIGINTERN int SWIG_Lua_class_tostring(lua_State *L) +{ +/* there should be 1 param passed in + (1) userdata (not the metatable) */ + swig_lua_userdata* userData; + assert(lua_isuserdata(L,1)); /* just in case */ + userData = (swig_lua_userdata*)lua_touserdata(L,1); /* get the userdata address */ + + lua_pushfstring(L, "", userData->type->str, userData->ptr); + return 1; +} + +/* to manually disown some userdata */ +SWIGINTERN int SWIG_Lua_class_disown(lua_State *L) +{ +/* there should be 1 params passed in + (1) userdata (not the meta table) */ + swig_lua_userdata *usr; + assert(lua_isuserdata(L,-1)); /* just in case */ + usr=(swig_lua_userdata*)lua_touserdata(L,-1); /* get it */ + + usr->own = 0; /* clear our ownership */ + return 0; +} + +/* lua callable function to compare userdata's value +the issue is that two userdata may point to the same thing +but to lua, they are different objects */ +SWIGRUNTIME int SWIG_Lua_class_equal(lua_State *L) +{ + int result; + swig_lua_userdata *usr1,*usr2; + if (!lua_isuserdata(L,1) || !lua_isuserdata(L,2)) /* just in case */ + return 0; /* nil reply */ + usr1=(swig_lua_userdata*)lua_touserdata(L,1); /* get data */ + usr2=(swig_lua_userdata*)lua_touserdata(L,2); /* get data */ + /*result=(usr1->ptr==usr2->ptr && usr1->type==usr2->type); only works if type is the same*/ + result=(usr1->ptr==usr2->ptr); + lua_pushboolean(L,result); + return 1; +} + +/* populate table at the top of the stack with metamethods that ought to be inherited */ +SWIGINTERN void SWIG_Lua_populate_inheritable_metamethods(lua_State *L) +{ + SWIG_Lua_add_boolean(L, "__add", 1); + SWIG_Lua_add_boolean(L, "__sub", 1); + SWIG_Lua_add_boolean(L, "__mul", 1); + SWIG_Lua_add_boolean(L, "__div", 1); + SWIG_Lua_add_boolean(L, "__mod", 1); + SWIG_Lua_add_boolean(L, "__pow", 1); + SWIG_Lua_add_boolean(L, "__unm", 1); + SWIG_Lua_add_boolean(L, "__len", 1 ); + SWIG_Lua_add_boolean(L, "__concat", 1 ); + SWIG_Lua_add_boolean(L, "__eq", 1); + SWIG_Lua_add_boolean(L, "__lt", 1); + SWIG_Lua_add_boolean(L, "__le", 1); + SWIG_Lua_add_boolean(L, "__call", 1); + SWIG_Lua_add_boolean(L, "__tostring", 1); + SWIG_Lua_add_boolean(L, "__gc", 0); +} + +/* creates the swig registry */ +SWIGINTERN void SWIG_Lua_create_class_registry(lua_State *L) +{ + /* create main SWIG registry table */ + lua_pushstring(L,"SWIG"); + lua_newtable(L); + /* populate it with some predefined data */ + + /* .library table. Placeholder */ + lua_pushstring(L,".library"); + lua_newtable(L); + { + /* list of metamethods that class inherits from its bases */ + lua_pushstring(L,"inheritable_metamethods"); + lua_newtable(L); + /* populate with list of metamethods */ + SWIG_Lua_populate_inheritable_metamethods(L); + lua_rawset(L,-3); + } + lua_rawset(L,-3); + + lua_rawset(L,LUA_REGISTRYINDEX); +} + +/* gets the swig registry (or creates it) */ +SWIGINTERN void SWIG_Lua_get_class_registry(lua_State *L) +{ + /* add this all into the swig registry: */ + lua_pushstring(L,"SWIG"); + lua_rawget(L,LUA_REGISTRYINDEX); /* get the registry */ + if (!lua_istable(L,-1)) /* not there */ + { /* must be first time, so add it */ + lua_pop(L,1); /* remove the result */ + SWIG_Lua_create_class_registry(L); + /* then get it */ + lua_pushstring(L,"SWIG"); + lua_rawget(L,LUA_REGISTRYINDEX); + } +} + +SWIGINTERN void SWIG_Lua_get_inheritable_metamethods(lua_State *L) +{ + SWIG_Lua_get_class_registry(L); + lua_pushstring(L, ".library"); + lua_rawget(L,-2); + assert( !lua_isnil(L,-1) ); + lua_pushstring(L, "inheritable_metamethods"); + lua_rawget(L,-2); + + /* Remove class registry and library table */ + lua_remove(L,-2); + lua_remove(L,-2); +} + +/* Helper function to get the classes metatable from the register */ +SWIGINTERN void SWIG_Lua_get_class_metatable(lua_State *L,const char *cname) +{ + SWIG_Lua_get_class_registry(L); /* get the registry */ + lua_pushstring(L,cname); /* get the name */ + lua_rawget(L,-2); /* get it */ + lua_remove(L,-2); /* tidy up (remove registry) */ +} + +/* Set up the base classes pointers. +Each class structure has a list of pointers to the base class structures. +This function fills them. +It cannot be done at compile time, as this will not work with hireachies +spread over more than one swig file. +Therefore it must be done at runtime, querying the SWIG type system. +*/ +SWIGINTERN void SWIG_Lua_init_base_class(lua_State *L,swig_lua_class *clss) +{ + int i=0; + swig_module_info *module=SWIG_GetModule(L); + for(i=0;clss->base_names[i];i++) + { + if (clss->bases[i]==0) /* not found yet */ + { + /* lookup and cache the base class */ + swig_type_info *info = SWIG_TypeQueryModule(module,module,clss->base_names[i]); + if (info) clss->bases[i] = (swig_lua_class *) info->clientdata; + } + } +} + +#if defined(SWIG_LUA_SQUASH_BASES) && (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA) +/* Merges two tables */ +SWIGINTERN void SWIG_Lua_merge_tables_by_index(lua_State *L, int target, int source) +{ + /* iterating */ + lua_pushnil(L); + while (lua_next(L,source) != 0) { + /* -1 - value, -2 - index */ + /* have to copy to assign */ + lua_pushvalue(L,-2); /* copy of index */ + lua_pushvalue(L,-2); /* copy of value */ + lua_rawset(L, target); + lua_pop(L,1); + /* only key is left */ + } +} + +/* Merges two tables with given name. original - index of target metatable, base - index of source metatable */ +SWIGINTERN void SWIG_Lua_merge_tables(lua_State *L, const char* name, int original, int base) +{ + /* push original[name], then base[name] */ + lua_pushstring(L,name); + lua_rawget(L,original); + int original_table = lua_gettop(L); + lua_pushstring(L,name); + lua_rawget(L,base); + int base_table = lua_gettop(L); + SWIG_Lua_merge_tables_by_index(L, original_table, base_table); + /* clearing stack */ + lua_pop(L,2); +} + +/* Function takes all symbols from base and adds it to derived class. It's just a helper. */ +SWIGINTERN void SWIG_Lua_class_squash_base(lua_State *L, swig_lua_class *base_cls) +{ + /* There is one parameter - original, i.e. 'derived' class metatable */ + assert(lua_istable(L,-1)); + int original = lua_gettop(L); + SWIG_Lua_get_class_metatable(L,base_cls->fqname); + int base = lua_gettop(L); + SWIG_Lua_merge_tables(L, ".fn", original, base ); + SWIG_Lua_merge_tables(L, ".set", original, base ); + SWIG_Lua_merge_tables(L, ".get", original, base ); + lua_pop(L,1); +} + +/* Function squashes all symbols from 'clss' bases into itself */ +SWIGINTERN void SWIG_Lua_class_squash_bases(lua_State *L, swig_lua_class *clss) +{ + int i; + SWIG_Lua_get_class_metatable(L,clss->fqname); + for(i=0;clss->base_names[i];i++) + { + if (clss->bases[i]==0) /* Somehow it's not found. Skip it */ + continue; + /* Thing is: all bases are already registered. Thus they have already executed + * this function. So we just need to squash them into us, because their bases + * are already squashed into them. No need for recursion here! + */ + SWIG_Lua_class_squash_base(L, clss->bases[i]); + } + lua_pop(L,1); /*tidy stack*/ +} +#endif + +#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA) /* In elua this is useless */ +/* helper add a variable to a registered class */ +SWIGINTERN void SWIG_Lua_add_variable(lua_State *L,const char *name,lua_CFunction getFn,lua_CFunction setFn) +{ + assert(lua_istable(L,-1)); /* just in case */ + SWIG_Lua_get_table(L,".get"); /* find the .get table */ + assert(lua_istable(L,-1)); /* just in case */ + SWIG_Lua_add_function(L,name,getFn); + lua_pop(L,1); /* tidy stack (remove table) */ + if (setFn) + { + SWIG_Lua_get_table(L,".set"); /* find the .set table */ + assert(lua_istable(L,-1)); /* just in case */ + SWIG_Lua_add_function(L,name,setFn); + lua_pop(L,1); /* tidy stack (remove table) */ + } +} + +/* helper to recursively add class static details (static attributes, operations and constants) */ +SWIGINTERN void SWIG_Lua_add_class_static_details(lua_State *L, swig_lua_class *clss) +{ + int i = 0; + /* The class namespace table must be on the top of the stack */ + assert(lua_istable(L,-1)); + /* call all the base classes first: we can then override these later: */ + for(i=0;clss->bases[i];i++) + { + SWIG_Lua_add_class_static_details(L,clss->bases[i]); + } + + SWIG_Lua_add_namespace_details(L, clss->cls_static); +} + +SWIGINTERN void SWIG_Lua_add_class_user_metamethods(lua_State *L, swig_lua_class *clss); /* forward declaration */ + +/* helper to recursively add class details (attributes & operations) */ +SWIGINTERN void SWIG_Lua_add_class_instance_details(lua_State *L, swig_lua_class *clss) +{ + int i; + size_t bases_count = 0; + /* Add bases to .bases table */ + SWIG_Lua_get_table(L,".bases"); + assert(lua_istable(L,-1)); /* just in case */ + for(i=0;clss->bases[i];i++) + { + SWIG_Lua_get_class_metatable(L,clss->bases[i]->fqname); + /* Base class must be already registered */ + assert(lua_istable(L,-1)); + lua_rawseti(L,-2,i+1); /* In lua indexing starts from 1 */ + bases_count++; + } + assert(lua_rawlen(L,-1) == bases_count); + lua_pop(L,1); /* remove .bases table */ + /* add attributes */ + for(i=0;clss->attributes[i].name;i++){ + SWIG_Lua_add_variable(L,clss->attributes[i].name,clss->attributes[i].getmethod,clss->attributes[i].setmethod); + } + /* add methods to the metatable */ + SWIG_Lua_get_table(L,".fn"); /* find the .fn table */ + assert(lua_istable(L,-1)); /* just in case */ + for(i=0;clss->methods[i].name;i++){ + SWIG_Lua_add_function(L,clss->methods[i].name,clss->methods[i].func); + } + lua_pop(L,1); /* tidy stack (remove table) */ + /* add operator overloads + This adds methods from metatable array to metatable. Can mess up garbage + collectind if someone defines __gc method + */ + if(clss->metatable) { + for(i=0;clss->metatable[i].name;i++) { + SWIG_Lua_add_function(L,clss->metatable[i].name,clss->metatable[i].func); + } + } + +#if !defined(SWIG_LUA_SQUASH_BASES) + /* Adding metamethods that are defined in base classes. If bases were squashed + * then it is obviously unnecessary + */ + SWIG_Lua_add_class_user_metamethods(L, clss); +#endif +} + +/* Helpers to add user defined class metamedhods - __add, __sub etc. The helpers are needed + for the following issue: Lua runtime checks for metamethod existence with rawget function + ignoring our SWIG-provided __index and __newindex functions. Thus our inheritance-aware method + search algorithm doesn't work in such case. (Not to say that Lua runtime queries metamethod directly + in metatable and not in object). + Current solution is this: if somewhere in hierarchy metamethod __x is defined, then all descendants + are automatically given a special proxy __x that calls the real __x method. + Obvious idea - to copy __x instead of creating __x-proxy is wrong because if someone changes __x in runtime, + those changes must be reflected in all descendants. +*/ + +SWIGRUNTIME int SWIG_Lua_resolve_metamethod(lua_State *L); /*forward declaration*/ + +/* The real function that resolves a metamethod. + * Function searches given class and all it's bases(recursively) for first instance of something that is + * not equal to SWIG_Lua_resolve_metatmethod. (Almost always this 'something' is actual metamethod implementation + * and it is a SWIG-generated C function.). It returns value on the top of the L and there is no garbage below the + * answer. + * Returns 1 if found, 0 otherwise. + * clss is class which metatable we will search for method + * metamethod_name_idx is index in L where metamethod name (as string) lies + * skip_check allows to skip searching metamethod in givel clss and immideatelly go to searching in bases. skip_check + * is not caried to subsequent recursive calls - false is always passed. It is set to true only at first call from + * SWIG_Lua_resolve_metamethod + * */ +SWIGINTERN int SWIG_Lua_do_resolve_metamethod(lua_State *L, const swig_lua_class *clss, int metamethod_name_idx, + int skip_check) +{ + /* This function is called recursively */ + int result = 0; + int i = 0; + + if (!skip_check) { + SWIG_Lua_get_class_metatable(L, clss->fqname); + lua_pushvalue(L, metamethod_name_idx); + lua_rawget(L,-2); + /* If this is cfunction and it is equal to SWIG_Lua_resolve_metamethod then + * this isn't the function we are looking for :) + * lua_tocfunction will return NULL if not cfunction + */ + if (!lua_isnil(L,-1) && lua_tocfunction(L,-1) != SWIG_Lua_resolve_metamethod ) { + lua_remove(L,-2); /* removing class metatable */ + return 1; + } + lua_pop(L,2); /* remove class metatable and query result */ + } + + /* Forwarding calls to bases */ + for(i=0;clss->bases[i];i++) + { + result = SWIG_Lua_do_resolve_metamethod(L, clss->bases[i], metamethod_name_idx, 0); + if (result) + break; + } + + return result; +} + +/* The proxy function for metamethod. All parameters are passed as cclosure. Searches for actual method + * and calls it */ +SWIGRUNTIME int SWIG_Lua_resolve_metamethod(lua_State *L) +{ + int numargs; + int metamethod_name_idx; + const swig_lua_class* clss; + int result; + + lua_checkstack(L,5); + numargs = lua_gettop(L); /* number of arguments to pass to actual metamethod */ + + /* Get upvalues from closure */ + lua_pushvalue(L, lua_upvalueindex(1)); /*Get function name*/ + metamethod_name_idx = lua_gettop(L); + + lua_pushvalue(L, lua_upvalueindex(2)); + clss = (const swig_lua_class*)(lua_touserdata(L,-1)); + lua_pop(L,1); /* remove lightuserdata with clss from stack */ + + /* Actual work */ + result = SWIG_Lua_do_resolve_metamethod(L, clss, metamethod_name_idx, 1); + if (!result) { + SWIG_Lua_pushferrstring(L,"The metamethod proxy is set, but it failed to find actual metamethod. Memory corruption is most likely explanation."); + lua_error(L); + return 0; + } + + lua_remove(L,-2); /* remove metamethod key */ + lua_insert(L,1); /* move function to correct position */ + lua_call(L, numargs, LUA_MULTRET); + return lua_gettop(L); /* return all results */ +} + + +/* If given metamethod must be present in given class, then creates appropriate proxy + * Returns 1 if successfully added, 0 if not added because no base class has it, -1 + * if method is defined in the class metatable itself + */ +SWIGINTERN int SWIG_Lua_add_class_user_metamethod(lua_State *L, swig_lua_class *clss, const int metatable_index) +{ + int key_index; + int success = 0; + int i = 0; + + /* metamethod name - on the top of the stack */ + assert(lua_isstring(L,-1)); + + key_index = lua_gettop(L); + + /* Check whether method is already defined in metatable */ + lua_pushvalue(L,key_index); /* copy of the key */ + lua_gettable(L,metatable_index); + if( !lua_isnil(L,-1) ) { + lua_pop(L,1); + return -1; + } + lua_pop(L,1); + + /* Iterating over immediate bases */ + for(i=0;clss->bases[i];i++) + { + const swig_lua_class *base = clss->bases[i]; + SWIG_Lua_get_class_metatable(L, base->fqname); + lua_pushvalue(L, key_index); + lua_rawget(L, -2); + if( !lua_isnil(L,-1) ) { + lua_pushvalue(L, key_index); + + /* Add proxy function */ + lua_pushvalue(L, key_index); /* first closure value is function name */ + lua_pushlightuserdata(L, clss); /* second closure value is swig_lua_class structure */ + lua_pushcclosure(L, SWIG_Lua_resolve_metamethod, 2); + + lua_rawset(L, metatable_index); + success = 1; + } + lua_pop(L,1); /* remove function or nil */ + lua_pop(L,1); /* remove base class metatable */ + + if( success ) + break; + } + + return success; +} + +SWIGINTERN void SWIG_Lua_add_class_user_metamethods(lua_State *L, swig_lua_class *clss) +{ + int metatable_index; + int metamethods_info_index; + int tostring_undefined; + int eq_undefined = 0; + + SWIG_Lua_get_class_metatable(L, clss->fqname); + metatable_index = lua_gettop(L); + SWIG_Lua_get_inheritable_metamethods(L); + assert(lua_istable(L,-1)); + metamethods_info_index = lua_gettop(L); + lua_pushnil(L); /* first key */ + while(lua_next(L, metamethods_info_index) != 0 ) { + /* key at index -2, value at index -1 */ + const int is_inheritable = lua_toboolean(L,-2); + lua_pop(L,1); /* remove value - we don't need it anymore */ + + if(is_inheritable) { /* if metamethod is inheritable */ + SWIG_Lua_add_class_user_metamethod(L,clss,metatable_index); + } + } + + lua_pop(L,1); /* remove inheritable metatmethods table */ + + /* Special handling for __tostring method */ + lua_pushstring(L, "__tostring"); + lua_pushvalue(L,-1); + lua_rawget(L,metatable_index); + tostring_undefined = lua_isnil(L,-1); + lua_pop(L,1); + if( tostring_undefined ) { + lua_pushcfunction(L, SWIG_Lua_class_tostring); + lua_rawset(L, metatable_index); + } else { + lua_pop(L,1); /* remove copy of the key */ + } + + /* Special handling for __eq method */ + lua_pushstring(L, "__eq"); + lua_pushvalue(L,-1); + lua_rawget(L,metatable_index); + eq_undefined = lua_isnil(L,-1); + lua_pop(L,1); + if( eq_undefined ) { + lua_pushcfunction(L, SWIG_Lua_class_equal); + lua_rawset(L, metatable_index); + } else { + lua_pop(L,1); /* remove copy of the key */ + } + /* Warning: __index and __newindex are SWIG-defined. For user-defined operator[] + * a __getitem/__setitem method should be defined + */ + lua_pop(L,1); /* pop class metatable */ +} + +/* Register class static methods,attributes etc as well as constructor proxy */ +SWIGINTERN void SWIG_Lua_class_register_static(lua_State *L, swig_lua_class *clss) +{ + const int SWIGUNUSED begin = lua_gettop(L); + lua_checkstack(L,5); /* just in case */ + assert(lua_istable(L,-1)); /* just in case */ + assert(strcmp(clss->name, clss->cls_static->name) == 0); /* in class those 2 must be equal */ + + SWIG_Lua_namespace_register(L,clss->cls_static, 1); + + assert(lua_istable(L,-1)); /* just in case */ + + /* add its constructor to module with the name of the class + so you can do MyClass(...) as well as new_MyClass(...) + BUT only if a constructor is defined + (this overcomes the problem of pure virtual classes without constructors)*/ + if (clss->constructor) + { + lua_getmetatable(L,-1); + assert(lua_istable(L,-1)); /* just in case */ + SWIG_Lua_add_function(L,"__call", clss->constructor); + lua_pop(L,1); + } + + assert(lua_istable(L,-1)); /* just in case */ + SWIG_Lua_add_class_static_details(L, clss); + + /* clear stack */ + lua_pop(L,1); + assert( lua_gettop(L) == begin ); +} + +/* Performs the instance (non-static) class registration process. Metatable for class is created + * and added to the class registry. + */ +SWIGINTERN void SWIG_Lua_class_register_instance(lua_State *L,swig_lua_class *clss) +{ + const int SWIGUNUSED begin = lua_gettop(L); + int i; + /* if name already there (class is already registered) then do nothing */ + SWIG_Lua_get_class_registry(L); /* get the registry */ + lua_pushstring(L,clss->fqname); /* get the name */ + lua_rawget(L,-2); + if(!lua_isnil(L,-1)) { + lua_pop(L,2); + assert(lua_gettop(L)==begin); + return; + } + lua_pop(L,2); /* tidy stack */ + /* Recursively initialize all bases */ + for(i=0;clss->bases[i];i++) + { + SWIG_Lua_class_register_instance(L,clss->bases[i]); + } + /* Again, get registry and push name */ + SWIG_Lua_get_class_registry(L); /* get the registry */ + lua_pushstring(L,clss->fqname); /* get the name */ + lua_newtable(L); /* create the metatable */ +#if defined(SWIG_LUA_SQUASH_BASES) && (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA) + /* If squashing is requested, then merges all bases metatable into this one. + * It would get us all special methods: __getitem, __add etc. + * This would set .fn, .type, and other .xxx incorrectly, but we will overwrite it right away + */ + { + int new_metatable_index = lua_absindex(L,-1); + for(i=0;clss->bases[i];i++) + { + int base_metatable; + SWIG_Lua_get_class_metatable(L,clss->bases[i]->fqname); + base_metatable = lua_absindex(L,-1); + SWIG_Lua_merge_tables_by_index(L,new_metatable_index, base_metatable); + lua_pop(L,1); + } + } + /* And now we will overwrite all incorrectly set data */ +#endif + /* add string of class name called ".type" */ + lua_pushstring(L,".type"); + lua_pushstring(L,clss->fqname); + lua_rawset(L,-3); + /* add a table called bases */ + lua_pushstring(L,".bases"); + lua_newtable(L); + lua_rawset(L,-3); + /* add a table called ".get" */ + lua_pushstring(L,".get"); + lua_newtable(L); + lua_rawset(L,-3); + /* add a table called ".set" */ + lua_pushstring(L,".set"); + lua_newtable(L); + lua_rawset(L,-3); + /* add a table called ".fn" */ + lua_pushstring(L,".fn"); + lua_newtable(L); + /* add manual disown method */ + SWIG_Lua_add_function(L,"__disown",SWIG_Lua_class_disown); + lua_rawset(L,-3); + /* add accessor fns for using the .get,.set&.fn */ + SWIG_Lua_add_function(L,"__index",SWIG_Lua_class_get); + SWIG_Lua_add_function(L,"__newindex",SWIG_Lua_class_set); + SWIG_Lua_add_function(L,"__gc",SWIG_Lua_class_destruct); + /* add it */ + lua_rawset(L,-3); /* metatable into registry */ + lua_pop(L,1); /* tidy stack (remove registry) */ + assert(lua_gettop(L) == begin); + +#if defined(SWIG_LUA_SQUASH_BASES) && (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA) + /* Now merge all symbols from .fn, .set, .get etc from bases to our tables */ + SWIG_Lua_class_squash_bases(L,clss); +#endif + SWIG_Lua_get_class_metatable(L,clss->fqname); + SWIG_Lua_add_class_instance_details(L,clss); /* recursive adding of details (atts & ops) */ + lua_pop(L,1); /* tidy stack (remove class metatable) */ + assert( lua_gettop(L) == begin ); +} + +SWIGINTERN void SWIG_Lua_class_register(lua_State *L,swig_lua_class *clss) +{ + int SWIGUNUSED begin; + assert(lua_istable(L,-1)); /* This is a table (module or namespace) where classes will be added */ + SWIG_Lua_class_register_instance(L,clss); + SWIG_Lua_class_register_static(L,clss); + + /* Add links from static part to instance part and vice versa */ + /* [SWIG registry] [Module] + * "MyClass" ----> [MyClass metatable] <===== "MyClass" -+> [static part] + * ".get" ----> ... | | getmetatable()----| + * ".set" ----> ... | | | + * ".static" --------------)----------------/ [static part metatable] + * | ".get" --> ... + * | ".set" --> .... + * |=============================== ".instance" + */ + begin = lua_gettop(L); + lua_pushstring(L,clss->cls_static->name); + lua_rawget(L,-2); /* get class static table */ + assert(lua_istable(L,-1)); + lua_getmetatable(L,-1); + assert(lua_istable(L,-1)); /* get class static metatable */ + lua_pushstring(L,".instance"); /* prepare key */ + + SWIG_Lua_get_class_metatable(L,clss->fqname); /* get class metatable */ + assert(lua_istable(L,-1)); + lua_pushstring(L,".static"); /* prepare key */ + lua_pushvalue(L, -4); /* push static class TABLE */ + assert(lua_istable(L,-1)); + lua_rawset(L,-3); /* assign static class table(!NOT metatable) as ".static" member of class metatable */ + lua_rawset(L,-3); /* assign class metatable as ".instance" member of class static METATABLE */ + lua_pop(L,2); + assert(lua_gettop(L) == begin); +} +#endif /* SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA */ + +#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC) +SWIGINTERN void SWIG_Lua_elua_class_register_instance(lua_State *L, swig_lua_class *clss) +{ + const int SWIGUNUSED begin = lua_gettop(L); + int i; + /* if name already there (class is already registered) then do nothing */ + SWIG_Lua_get_class_registry(L); /* get the registry */ + lua_pushstring(L,clss->fqname); /* get the name */ + lua_rawget(L,-2); + if(!lua_isnil(L,-1)) { + lua_pop(L,2); + assert(lua_gettop(L)==begin); + return; + } + lua_pop(L,2); /* tidy stack */ + /* Recursively initialize all bases */ + for(i=0;clss->bases[i];i++) + { + SWIG_Lua_elua_class_register_instance(L,clss->bases[i]); + } + /* Again, get registry and push name */ + SWIG_Lua_get_class_registry(L); /* get the registry */ + lua_pushstring(L,clss->fqname); /* get the name */ + assert(clss->metatable); + lua_pushrotable(L, (void*)(clss->metatable)); /* create the metatable */ + lua_rawset(L,-3); + lua_pop(L,1); + assert(lua_gettop(L) == begin); +} +#endif /* elua && eluac */ + +/* ----------------------------------------------------------------------------- + * Class/structure conversion fns + * ----------------------------------------------------------------------------- */ + +/* helper to add metatable to new lua object */ +SWIGINTERN void SWIG_Lua_AddMetatable(lua_State *L,swig_type_info *type) +{ + if (type->clientdata) /* there is clientdata: so add the metatable */ + { + SWIG_Lua_get_class_metatable(L,((swig_lua_class*)(type->clientdata))->fqname); + if (lua_istable(L,-1)) + { + lua_setmetatable(L,-2); + } + else + { + lua_pop(L,1); + } + } +} + +/* pushes a new object into the lua stack */ +SWIGRUNTIME void SWIG_Lua_NewPointerObj(lua_State *L,void *ptr,swig_type_info *type, int own) +{ + swig_lua_userdata *usr; + if (!ptr){ + lua_pushnil(L); + return; + } + usr=(swig_lua_userdata*)lua_newuserdata(L,sizeof(swig_lua_userdata)); /* get data */ + usr->ptr=ptr; /* set the ptr */ + usr->type=type; + usr->own=own; +#if (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC) + SWIG_Lua_AddMetatable(L,type); /* add metatable */ +#endif +} + +/* takes a object from the lua stack & converts it into an object of the correct type + (if possible) */ +SWIGRUNTIME int SWIG_Lua_ConvertPtr(lua_State *L,int index,void **ptr,swig_type_info *type,int flags) +{ + swig_lua_userdata *usr; + swig_cast_info *cast; + /* special case: lua nil => NULL pointer */ + if (lua_isnil(L,index)) + { + *ptr=0; + return (flags & SWIG_POINTER_NO_NULL) ? SWIG_NullReferenceError : SWIG_OK; + } + usr=(swig_lua_userdata*)lua_touserdata(L,index); /* get data */ + if (usr) + { + if (flags & SWIG_POINTER_DISOWN) /* must disown the object */ + { + usr->own=0; + } + if (!type) /* special cast void*, no casting fn */ + { + *ptr=usr->ptr; + return SWIG_OK; /* ok */ + } + cast=SWIG_TypeCheckStruct(usr->type,type); /* performs normal type checking */ + if (cast) + { + int newmemory = 0; + *ptr=SWIG_TypeCast(cast,usr->ptr,&newmemory); + assert(!newmemory); /* newmemory handling not yet implemented */ + return SWIG_OK; /* ok */ + } + } + return SWIG_ERROR; /* error */ +} + +SWIGRUNTIME void* SWIG_Lua_MustGetPtr(lua_State *L,int index,swig_type_info *type,int flags, + int argnum,const char *func_name){ + void *result; + if (!SWIG_IsOK(SWIG_ConvertPtr(L,index,&result,type,flags))){ + luaL_error (L,"Error in %s, expected a %s at argument number %d\n", + func_name,(type && type->str)?type->str:"void*",argnum); + } + return result; +} + +/* pushes a packed userdata. user for member fn pointers only */ +SWIGRUNTIME void SWIG_Lua_NewPackedObj(lua_State *L,void *ptr,size_t size,swig_type_info *type) +{ + swig_lua_rawdata *raw; + assert(ptr); /* not acceptable to pass in a NULL value */ + raw=(swig_lua_rawdata*)lua_newuserdata(L,sizeof(swig_lua_rawdata)-1+size); /* alloc data */ + raw->type=type; + raw->own=0; + memcpy(raw->data,ptr,size); /* copy the data */ + SWIG_Lua_AddMetatable(L,type); /* add metatable */ +} + +/* converts a packed userdata. user for member fn pointers only */ +SWIGRUNTIME int SWIG_Lua_ConvertPacked(lua_State *L,int index,void *ptr,size_t size,swig_type_info *type) +{ + swig_lua_rawdata *raw; + raw=(swig_lua_rawdata*)lua_touserdata(L,index); /* get data */ + if (!raw) return SWIG_ERROR; /* error */ + if (type==0 || type==raw->type) /* void* or identical type */ + { + memcpy(ptr,raw->data,size); /* copy it */ + return SWIG_OK; /* ok */ + } + return SWIG_ERROR; /* error */ +} + +/* a function to get the typestring of a piece of data */ +SWIGRUNTIME const char *SWIG_Lua_typename(lua_State *L, int tp) +{ + swig_lua_userdata *usr; + if (lua_isuserdata(L,tp)) + { + usr=(swig_lua_userdata*)lua_touserdata(L,tp); /* get data */ + if (usr && usr->type && usr->type->str) + return usr->type->str; + return "userdata (unknown type)"; + } + return lua_typename(L,lua_type(L,tp)); +} + +/* lua callable function to get the userdata's type */ +SWIGRUNTIME int SWIG_Lua_type(lua_State *L) +{ + lua_pushstring(L,SWIG_Lua_typename(L,1)); + return 1; +} + +/* ----------------------------------------------------------------------------- + * global variable support code: class/struct typemap functions + * ----------------------------------------------------------------------------- */ + +#if ((SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUA) && (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC)) +/* Install Constants */ +SWIGINTERN void +SWIG_Lua_InstallConstants(lua_State *L, swig_lua_const_info constants[]) { + int i; + for (i = 0; constants[i].type; i++) { + switch(constants[i].type) { + case SWIG_LUA_INT: + lua_pushstring(L,constants[i].name); + lua_pushinteger(L,(lua_Integer)constants[i].lvalue); + lua_rawset(L,-3); + break; + case SWIG_LUA_FLOAT: + lua_pushstring(L,constants[i].name); + lua_pushnumber(L,(lua_Number)constants[i].dvalue); + lua_rawset(L,-3); + break; + case SWIG_LUA_CHAR: + lua_pushstring(L,constants[i].name); + { + char c = (char)constants[i].lvalue; + lua_pushlstring(L,&c,1); + } + lua_rawset(L,-3); + break; + case SWIG_LUA_STRING: + lua_pushstring(L,constants[i].name); + lua_pushstring(L,(char *) constants[i].pvalue); + lua_rawset(L,-3); + break; + case SWIG_LUA_POINTER: + lua_pushstring(L,constants[i].name); + SWIG_NewPointerObj(L,constants[i].pvalue, *(constants[i]).ptype,0); + lua_rawset(L,-3); + break; + case SWIG_LUA_BINARY: + lua_pushstring(L,constants[i].name); + SWIG_NewMemberObj(L,constants[i].pvalue,constants[i].lvalue,*(constants[i]).ptype); + lua_rawset(L,-3); + break; + default: + break; + } + } +} +#endif + +/* ----------------------------------------------------------------------------- + * executing lua code from within the wrapper + * ----------------------------------------------------------------------------- */ + +#ifndef SWIG_DOSTRING_FAIL /* Allows redefining of error function */ +#define SWIG_DOSTRING_FAIL(S) fprintf(stderr,"%s\n",S) +#endif +/* Executes a C string in Lua which is a really simple way of calling lua from C +Unfortunately lua keeps changing its APIs, so we need a conditional compile +In lua 5.0.X it's lua_dostring() +In lua 5.1.X it's luaL_dostring() +*/ +SWIGINTERN int +SWIG_Lua_dostring(lua_State *L, const char *str) { + int ok,top; + if (str==0 || str[0]==0) return 0; /* nothing to do */ + top=lua_gettop(L); /* save stack */ +#if (defined(LUA_VERSION_NUM) && (LUA_VERSION_NUM>=501)) + ok=luaL_dostring(L,str); /* looks like this is lua 5.1.X or later, good */ +#else + ok=lua_dostring(L,str); /* might be lua 5.0.x, using lua_dostring */ +#endif + if (ok!=0) { + SWIG_DOSTRING_FAIL(lua_tostring(L,-1)); + } + lua_settop(L,top); /* restore the stack */ + return ok; +} + +#ifdef __cplusplus +} +#endif + +/* ------------------------------ end luarun.swg ------------------------------ */ + +/* Errors in SWIG */ +#define SWIG_UnknownError -1 +#define SWIG_IOError -2 +#define SWIG_RuntimeError -3 +#define SWIG_IndexError -4 +#define SWIG_TypeError -5 +#define SWIG_DivisionByZero -6 +#define SWIG_OverflowError -7 +#define SWIG_SyntaxError -8 +#define SWIG_ValueError -9 +#define SWIG_SystemError -10 +#define SWIG_AttributeError -11 +#define SWIG_MemoryError -12 +#define SWIG_NullReferenceError -13 + + + + +/* -------- TYPES TABLE (BEGIN) -------- */ + +#define SWIGTYPE_p_float swig_types[0] +#define SWIGTYPE_p_glm__mat3 swig_types[1] +#define SWIGTYPE_p_glm__mat4 swig_types[2] +#define SWIGTYPE_p_glm__quat swig_types[3] +#define SWIGTYPE_p_glm__vec2 swig_types[4] +#define SWIGTYPE_p_glm__vec3 swig_types[5] +#define SWIGTYPE_p_glm__vec4 swig_types[6] +#define SWIGTYPE_p_int swig_types[7] +#define SWIGTYPE_p_std__string swig_types[8] +static swig_type_info *swig_types[10]; +static swig_module_info swig_module = {swig_types, 9, 0, 0, 0, 0}; +#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) +#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) + +/* -------- TYPES TABLE (END) -------- */ + +#define SWIG_name "glm" +#define SWIG_init luaopen_glm +#define SWIG_init_user luaopen_glm_user + +#define SWIG_LUACODE luaopen_glm_luacode + +namespace swig { +typedef struct{} LANGUAGE_OBJ; +} + + +#include +#include +#include + +// these included in math/ofVectorMath.h +// we declare some things manually, so some includes are commented out +#include "glm/vec2.hpp" +#include "glm/vec3.hpp" +#include "glm/vec4.hpp" +#include "glm/mat3x3.hpp" +#include "glm/mat4x4.hpp" +#include "glm/geometric.hpp" +#include "glm/common.hpp" +#include "glm/trigonometric.hpp" +#include "glm/exponential.hpp" +//#include "glm/vector_relational.hpp" +//#include "glm/ext.hpp" + +//#include "glm/gtc/constants.hpp" +#include "glm/gtc/matrix_transform.hpp" +#include "glm/gtc/matrix_inverse.hpp" +//#include "glm/gtc/quaternion.hpp" +#include "glm/gtc/epsilon.hpp" +#include "glm/gtx/norm.hpp" +#include "glm/gtx/perpendicular.hpp" +#include "glm/gtx/quaternion.hpp" +#include "glm/gtx/rotate_vector.hpp" +#include "glm/gtx/spline.hpp" +#include "glm/gtx/transform.hpp" +#include "glm/gtx/vector_angle.hpp" +//#include "glm/gtx/scalar_multiplication.hpp" +//#include + +// extras included via glm/ext.h +#include +#include +#include +#include +#include + + +#include +#include + + +#define SWIG_exception(a,b)\ +{ lua_pushfstring(L,"%s:%s",#a,b);SWIG_fail; } + + +#include +#include + + +#include + + +SWIGINTERN int SWIG_lua_isnilstring(lua_State *L, int idx) { + int ret = lua_isstring(L, idx); + if (!ret) + ret = lua_isnil(L, idx); + return ret; +} + +SWIGINTERN float glm_vec2___getitem__(glm::vec2 *self,int i){ + + if(i < 1 || i > self->length()) { + throw std::out_of_range("in glm::vec2::__getitem__()"); + } + return (*self)[i-1]; + + + + + + + } +SWIGINTERN void glm_vec2___setitem__(glm::vec2 *self,int i,float f){ + + if(i < 1 || i > self->length()) { + throw std::out_of_range("in glm::vec2::__setitem__()"); + } + (*self)[i-1] = f; + + + + + + + } +SWIGINTERN std::string glm_vec2___tostring(glm::vec2 *self){ + std::stringstream str; + for(glm::length_t i = 0; i < self->length(); ++i) { + str << (*self)[i]; + if(i + 1 != self->length()) { + str << " "; + } + } + return str.str(); + } +SWIGINTERN glm::vec2 glm_vec2_operator_Sa___SWIG_0(glm::vec2 *self,glm::vec2 const &v){return (*self) + v;} +SWIGINTERN glm::vec2 glm_vec2_operator_Sa___SWIG_1(glm::vec2 *self,float scalar){return (*self) + scalar;} +SWIGINTERN glm::vec2 glm_vec2_operator_Ss___SWIG_0(glm::vec2 *self,glm::vec2 const &v){return (*self) - v;} +SWIGINTERN glm::vec2 glm_vec2_operator_Ss___SWIG_1(glm::vec2 *self,float scalar){return (*self) - scalar;} +SWIGINTERN glm::vec2 glm_vec2_operator_Sm___SWIG_0(glm::vec2 *self,glm::vec2 const &v){return (*self) * v;} +SWIGINTERN glm::vec2 glm_vec2_operator_Sm___SWIG_1(glm::vec2 *self,float scalar){return (*self) * scalar;} +SWIGINTERN glm::vec2 glm_vec2_operator_Sd___SWIG_0(glm::vec2 *self,glm::vec2 const &v){return (*self) / v;} +SWIGINTERN glm::vec2 glm_vec2_operator_Sd___SWIG_1(glm::vec2 *self,float scalar){return (*self) / scalar;} +SWIGINTERN bool glm_vec2_operator_Se__Se_(glm::vec2 *self,glm::vec2 const &v){return (*self) == v;} +SWIGINTERN float glm_vec3___getitem__(glm::vec3 *self,int i){ + + if(i < 1 || i > self->length()) { + throw std::out_of_range("in glm::vec3::__getitem__()"); + } + return (*self)[i-1]; + + + + + + + } +SWIGINTERN void glm_vec3___setitem__(glm::vec3 *self,int i,float f){ + + if(i < 1 || i > self->length()) { + throw std::out_of_range("in glm::vec3::__setitem__()"); + } + (*self)[i-1] = f; + + + + + + + } +SWIGINTERN std::string glm_vec3___tostring(glm::vec3 *self){ + std::stringstream str; + for(glm::length_t i = 0; i < self->length(); ++i) { + str << (*self)[i]; + if(i + 1 != self->length()) { + str << " "; + } + } + return str.str(); + } +SWIGINTERN glm::vec3 glm_vec3_operator_Sa___SWIG_0(glm::vec3 *self,glm::vec3 const &v){return (*self) + v;} +SWIGINTERN glm::vec3 glm_vec3_operator_Sa___SWIG_1(glm::vec3 *self,float scalar){return (*self) + scalar;} +SWIGINTERN glm::vec3 glm_vec3_operator_Ss___SWIG_0(glm::vec3 *self,glm::vec3 const &v){return (*self) - v;} +SWIGINTERN glm::vec3 glm_vec3_operator_Ss___SWIG_1(glm::vec3 *self,float scalar){return (*self) - scalar;} +SWIGINTERN glm::vec3 glm_vec3_operator_Sm___SWIG_0(glm::vec3 *self,glm::vec3 const &v){return (*self) * v;} +SWIGINTERN glm::vec3 glm_vec3_operator_Sm___SWIG_1(glm::vec3 *self,float scalar){return (*self) * scalar;} +SWIGINTERN glm::vec3 glm_vec3_operator_Sd___SWIG_0(glm::vec3 *self,glm::vec3 const &v){return (*self) / v;} +SWIGINTERN glm::vec3 glm_vec3_operator_Sd___SWIG_1(glm::vec3 *self,float scalar){return (*self) / scalar;} +SWIGINTERN bool glm_vec3_operator_Se__Se_(glm::vec3 *self,glm::vec3 const &v){return (*self) == v;} +SWIGINTERN float glm_vec4___getitem__(glm::vec4 *self,int i){ + + if(i < 1 || i > self->length()) { + throw std::out_of_range("in glm::vec4::__getitem__()"); + } + return (*self)[i-1]; + + + + + + + } +SWIGINTERN void glm_vec4___setitem__(glm::vec4 *self,int i,float f){ + + if(i < 1 || i > self->length()) { + throw std::out_of_range("in glm::vec4::__setitem__()"); + } + (*self)[i-1] = f; + + + + + + + } +SWIGINTERN std::string glm_vec4___tostring(glm::vec4 *self){ + std::stringstream str; + for(glm::length_t i = 0; i < self->length(); ++i) { + str << (*self)[i]; + if(i + 1 != self->length()) { + str << " "; + } + } + return str.str(); + } +SWIGINTERN glm::vec4 glm_vec4_operator_Sa___SWIG_0(glm::vec4 *self,glm::vec4 const &v){return (*self) + v;} +SWIGINTERN glm::vec4 glm_vec4_operator_Sa___SWIG_1(glm::vec4 *self,float scalar){return (*self) + scalar;} +SWIGINTERN glm::vec4 glm_vec4_operator_Ss___SWIG_0(glm::vec4 *self,glm::vec4 const &v){return (*self) - v;} +SWIGINTERN glm::vec4 glm_vec4_operator_Ss___SWIG_1(glm::vec4 *self,float scalar){return (*self) - scalar;} +SWIGINTERN glm::vec4 glm_vec4_operator_Sm___SWIG_0(glm::vec4 *self,glm::vec4 const &v){return (*self) * v;} +SWIGINTERN glm::vec4 glm_vec4_operator_Sm___SWIG_1(glm::vec4 *self,float scalar){return (*self) * scalar;} +SWIGINTERN glm::vec4 glm_vec4_operator_Sd___SWIG_0(glm::vec4 *self,glm::vec4 const &v){return (*self) / v;} +SWIGINTERN glm::vec4 glm_vec4_operator_Sd___SWIG_1(glm::vec4 *self,float scalar){return (*self) / scalar;} +SWIGINTERN bool glm_vec4_operator_Se__Se_(glm::vec4 *self,glm::vec4 const &v){return (*self) == v;} +SWIGINTERN glm::vec3 glm_mat3___getitem__(glm::mat3 *self,int i){ + + if(i < 1 || i > self->length()) { + throw std::out_of_range("in glm::mat3::__getitem__()"); + } + return (*self)[i-1]; + + + + + + + } +SWIGINTERN void glm_mat3___setitem__(glm::mat3 *self,int i,glm::vec3 v){ + + if(i < 1 || i > self->length()) { + throw std::out_of_range("in glm::mat3::__setitem__()"); + } + (*self)[i-1] = v; + + + + + + + } +SWIGINTERN std::string glm_mat3___tostring(glm::mat3 *self){ + std::stringstream str; + const glm::length_t width = self->length(); + const glm::length_t height = (*self)[0].length(); + for(glm::length_t row = 0; row < height; ++row) { + for(glm::length_t col = 0; col < width; ++col) { + str << (*self)[col][row]; + if(col + 1 != width) { + str << "\t"; + } + } + if(row + 1 != height) { + str << "\n"; + } + } + return str.str(); + } +SWIGINTERN glm::mat3 glm_mat3_operator_Sa___SWIG_0(glm::mat3 *self,float scalar){return (*self) + scalar;} +SWIGINTERN glm::mat3 glm_mat3_operator_Sa___SWIG_1(glm::mat3 *self,glm::mat3 const &m){return (*self) + m;} +SWIGINTERN glm::mat3 glm_mat3_operator_Ss___SWIG_0(glm::mat3 *self,float scalar){return (*self) - scalar;} +SWIGINTERN glm::mat3 glm_mat3_operator_Ss___SWIG_1(glm::mat3 *self,glm::mat3 const &m){return (*self) - m;} +SWIGINTERN glm::mat3 glm_mat3_operator_Sm___SWIG_0(glm::mat3 *self,float scalar){return (*self) * scalar;} +SWIGINTERN glm::mat3 glm_mat3_operator_Sm___SWIG_1(glm::mat3 *self,glm::mat3 const &m){return (*self) * m;} +SWIGINTERN glm::vec3 glm_mat3_operator_Sm___SWIG_2(glm::mat3 *self,glm::vec3 const &v){return (*self) * v;} +SWIGINTERN glm::mat3 glm_mat3_operator_Sd___SWIG_0(glm::mat3 *self,float scalar){return (*self) / scalar;} +SWIGINTERN glm::mat3 glm_mat3_operator_Sd___SWIG_1(glm::mat3 *self,glm::mat3 const &m){return (*self) / m;} +SWIGINTERN glm::vec3 glm_mat3_operator_Sd___SWIG_2(glm::mat3 *self,glm::vec3 const &v){return (*self) / v;} +SWIGINTERN bool glm_mat3_operator_Se__Se_(glm::mat3 *self,glm::mat3 const &m){return (*self) == m;} +SWIGINTERN glm::vec4 glm_mat4___getitem__(glm::mat4 *self,int i){ + + if(i < 1 || i > self->length()) { + throw std::out_of_range("in glm::mat4::__getitem__()"); + } + return (*self)[i-1]; + + + + + + + } +SWIGINTERN void glm_mat4___setitem__(glm::mat4 *self,int i,glm::vec4 v){ + + if(i < 1 || i > self->length()) { + throw std::out_of_range("in glm::mat4::__setitem__()"); + } + (*self)[i-1] = v; + + + + + + + } +SWIGINTERN std::string glm_mat4___tostring(glm::mat4 *self){ + std::stringstream str; + const glm::length_t width = self->length(); + const glm::length_t height = (*self)[0].length(); + for(glm::length_t row = 0; row < height; ++row) { + for(glm::length_t col = 0; col < width; ++col) { + str << (*self)[col][row]; + if(col + 1 != width) { + str << "\t"; + } + } + if(row + 1 != height) { + str << "\n"; + } + } + return str.str(); + } +SWIGINTERN glm::mat4 glm_mat4_operator_Sa___SWIG_0(glm::mat4 *self,float scalar){return (*self) + scalar;} +SWIGINTERN glm::mat4 glm_mat4_operator_Sa___SWIG_1(glm::mat4 *self,glm::mat4 const &m){return (*self) + m;} +SWIGINTERN glm::mat4 glm_mat4_operator_Ss___SWIG_0(glm::mat4 *self,float scalar){return (*self) - scalar;} +SWIGINTERN glm::mat4 glm_mat4_operator_Ss___SWIG_1(glm::mat4 *self,glm::mat4 const &m){return (*self) - m;} +SWIGINTERN glm::mat4 glm_mat4_operator_Sm___SWIG_0(glm::mat4 *self,float scalar){return (*self) * scalar;} +SWIGINTERN glm::mat4 glm_mat4_operator_Sm___SWIG_1(glm::mat4 *self,glm::mat4 const &m){return (*self) * m;} +SWIGINTERN glm::vec4 glm_mat4_operator_Sm___SWIG_2(glm::mat4 *self,glm::vec4 const &v){return (*self) * v;} +SWIGINTERN glm::mat4 glm_mat4_operator_Sd___SWIG_0(glm::mat4 *self,float scalar){return (*self) / scalar;} +SWIGINTERN glm::mat4 glm_mat4_operator_Sd___SWIG_1(glm::mat4 *self,glm::mat4 const &m){return (*self) / m;} +SWIGINTERN glm::vec4 glm_mat4_operator_Sd___SWIG_2(glm::mat4 *self,glm::vec4 const &v){return (*self) / v;} +SWIGINTERN bool glm_mat4_operator_Se__Se_(glm::mat4 *self,glm::mat4 const &m){return (*self) == m;} +SWIGINTERN float glm_quat___getitem__(glm::quat *self,int i){ + + if(i < 1 || i > self->length()) { + throw std::out_of_range("in glm::quat::__getitem__()"); + } + return (*self)[i-1]; + + + + + + + } +SWIGINTERN void glm_quat___setitem__(glm::quat *self,int i,float f){ + + if(i < 1 || i > self->length()) { + throw std::out_of_range("in glm::quat::__setitem__()"); + } + (*self)[i-1] = f; + + + + + + + } +SWIGINTERN std::string glm_quat___tostring(glm::quat *self){ + std::stringstream str; + for(glm::length_t i = 0; i < self->length(); ++i) { + str << (*self)[i]; + if(i + 1 != self->length()) { + str << " "; + } + } + return str.str(); + } +SWIGINTERN glm::quat glm_quat_operator_Sa_(glm::quat *self,glm::quat const &q){return (*self) + q;} +SWIGINTERN glm::quat glm_quat_operator_Sm___SWIG_0(glm::quat *self,glm::quat const &q){return (*self) * q;} +SWIGINTERN glm::vec3 glm_quat_operator_Sm___SWIG_1(glm::quat *self,glm::vec3 const &v){return (*self) * v;} +SWIGINTERN glm::vec4 glm_quat_operator_Sm___SWIG_2(glm::quat *self,glm::vec4 const &v){return (*self) * v;} +SWIGINTERN glm::quat glm_quat_operator_Sm___SWIG_3(glm::quat *self,float const &s){return (*self) * s;} +SWIGINTERN glm::quat glm_quat_operator_Sd_(glm::quat *self,float const &s){return (*self) / s;} +SWIGINTERN bool glm_quat_operator_Se__Se_(glm::quat *self,glm::quat const &q){return (*self) == q;} +#ifdef __cplusplus +extern "C" { +#endif +static int _wrap_new_string__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *result = 0 ; + SWIG_check_num_args("std::string::string",0,0) result = (std::string *)new std::string(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__string,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_new_string__SWIG_1(lua_State* L) { int SWIG_arg = 0; char *arg1 = (char *) 0 ; std::string *result = 0 ; + SWIG_check_num_args("std::string::string",1,1) + if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("std::string::string",1,"char const *"); arg1 = (char *)lua_tostring(L, 1); + result = (std::string *)new std::string((char const *)arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__string,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_new_string(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { + return _wrap_new_string__SWIG_0(L);} if (argc == 1) { return _wrap_new_string__SWIG_1(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_string'\n" " Possible C/C++ prototypes are:\n" + " std::string::string()\n" " std::string::string(char const *)\n"); lua_error(L);return 0; } +static int _wrap_string_size(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = (std::string *) 0 ; unsigned int result; + SWIG_check_num_args("std::string::size",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::string::size",1,"std::string const *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__string,0))){ + SWIG_fail_ptr("string_size",1,SWIGTYPE_p_std__string); } result = (unsigned int)((std::string const *)arg1)->size(); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_string_length(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = (std::string *) 0 ; unsigned int result; + SWIG_check_num_args("std::string::length",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::string::length",1,"std::string const *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__string,0))){ + SWIG_fail_ptr("string_length",1,SWIGTYPE_p_std__string); } result = (unsigned int)((std::string const *)arg1)->length(); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_string_empty(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = (std::string *) 0 ; bool result; + SWIG_check_num_args("std::string::empty",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::string::empty",1,"std::string const *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__string,0))){ + SWIG_fail_ptr("string_empty",1,SWIGTYPE_p_std__string); } result = (bool)((std::string const *)arg1)->empty(); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_string_c_str(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = (std::string *) 0 ; char *result = 0 ; + SWIG_check_num_args("std::string::c_str",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::string::c_str",1,"std::string const *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__string,0))){ + SWIG_fail_ptr("string_c_str",1,SWIGTYPE_p_std__string); } result = (char *)((std::string const *)arg1)->c_str(); + lua_pushstring(L,(const char *)result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_string_data(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = (std::string *) 0 ; char *result = 0 ; + SWIG_check_num_args("std::string::data",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::string::data",1,"std::string const *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__string,0))){ + SWIG_fail_ptr("string_data",1,SWIGTYPE_p_std__string); } result = (char *)((std::string const *)arg1)->data(); + lua_pushstring(L,(const char *)result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_string_assign(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = (std::string *) 0 ; + char *arg2 = (char *) 0 ; SWIG_check_num_args("std::string::assign",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::string::assign",1,"std::string *"); + if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("std::string::assign",2,"char const *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__string,0))){ + SWIG_fail_ptr("string_assign",1,SWIGTYPE_p_std__string); } arg2 = (char *)lua_tostring(L, 2); + (arg1)->assign((char const *)arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static void swig_delete_string(void *obj) { +std::string *arg1 = (std::string *) obj; +delete arg1; +} +static int _proxy__wrap_new_string(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_string); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_string_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_string_methods[]= { + { "size", _wrap_string_size}, + { "length", _wrap_string_length}, + { "empty", _wrap_string_empty}, + { "c_str", _wrap_string_c_str}, + { "data", _wrap_string_data}, + { "assign", _wrap_string_assign}, + {0,0} +}; +static swig_lua_method swig_string_meta[] = { + {0,0} +}; + +static swig_lua_attribute swig_string_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_string_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_string_Sf_SwigStatic_methods[]= { + {0,0} +}; +static swig_lua_class* swig_string_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_string_Sf_SwigStatic = { + "string", + swig_string_Sf_SwigStatic_methods, + swig_string_Sf_SwigStatic_attributes, + swig_string_Sf_SwigStatic_constants, + swig_string_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_string_bases[] = {0}; +static const char *swig_string_base_names[] = {0}; +static swig_lua_class _wrap_class_string = { "string", "string", &SWIGTYPE_p_std__string,_proxy__wrap_new_string, swig_delete_string, swig_string_methods, swig_string_attributes, &swig_string_Sf_SwigStatic, swig_string_meta, swig_string_bases, swig_string_base_names }; + +static int _wrap_vec2_x_set(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = (glm::vec2 *) 0 ; float arg2 ; + SWIG_check_num_args("glm::vec2::x",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::vec2::x",1,"glm::vec2 *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::vec2::x",2,"float"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ + SWIG_fail_ptr("vec2_x_set",1,SWIGTYPE_p_glm__vec2); } arg2 = (float)lua_tonumber(L, 2); if (arg1) (arg1)->x = arg2; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_vec2_x_get(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = (glm::vec2 *) 0 ; float result; + SWIG_check_num_args("glm::vec2::x",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::vec2::x",1,"glm::vec2 *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ + SWIG_fail_ptr("vec2_x_get",1,SWIGTYPE_p_glm__vec2); } result = (float) ((arg1)->x); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_vec2_y_set(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = (glm::vec2 *) 0 ; float arg2 ; + SWIG_check_num_args("glm::vec2::y",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::vec2::y",1,"glm::vec2 *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::vec2::y",2,"float"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ + SWIG_fail_ptr("vec2_y_set",1,SWIGTYPE_p_glm__vec2); } arg2 = (float)lua_tonumber(L, 2); if (arg1) (arg1)->y = arg2; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_vec2_y_get(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = (glm::vec2 *) 0 ; float result; + SWIG_check_num_args("glm::vec2::y",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::vec2::y",1,"glm::vec2 *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ + SWIG_fail_ptr("vec2_y_get",1,SWIGTYPE_p_glm__vec2); } result = (float) ((arg1)->y); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_vec2_length(lua_State* L) { int SWIG_arg = 0; glm::length_t result; + SWIG_check_num_args("glm::vec2::length",0,0) result = (glm::length_t)glm::vec2::length(); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_new_vec2__SWIG_0(lua_State* L) { int SWIG_arg = 0; glm::vec2 *result = 0 ; + SWIG_check_num_args("glm::vec2::vec2",0,0) result = (glm::vec2 *)new glm::vec2(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_new_vec2__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = 0 ; glm::vec2 *result = 0 ; + SWIG_check_num_args("glm::vec2::vec2",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::vec2::vec2",1,"glm::vec2 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("new_vec2",1,SWIGTYPE_p_glm__vec2); } + result = (glm::vec2 *)new glm::vec2((glm::vec2 const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_new_vec2__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; glm::vec2 *result = 0 ; + SWIG_check_num_args("glm::vec2::vec2",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::vec2::vec2",1,"float"); + arg1 = (float)lua_tonumber(L, 1); result = (glm::vec2 *)new glm::vec2(arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_new_vec2__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; glm::vec2 *result = 0 ; + SWIG_check_num_args("glm::vec2::vec2",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::vec2::vec2",1,"float"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::vec2::vec2",2,"float"); arg1 = (float)lua_tonumber(L, 1); + arg2 = (float)lua_tonumber(L, 2); result = (glm::vec2 *)new glm::vec2(arg1,arg2); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_new_vec2__SWIG_4(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; glm::vec2 *result = 0 ; + SWIG_check_num_args("glm::vec2::vec2",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::vec2::vec2",1,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("new_vec2",1,SWIGTYPE_p_glm__vec3); } + result = (glm::vec2 *)new glm::vec2((glm::vec3 const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_new_vec2__SWIG_5(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = 0 ; glm::vec2 *result = 0 ; + SWIG_check_num_args("glm::vec2::vec2",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::vec2::vec2",1,"glm::vec4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("new_vec2",1,SWIGTYPE_p_glm__vec4); } + result = (glm::vec2 *)new glm::vec2((glm::vec4 const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_new_vec2(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 0) { + return _wrap_new_vec2__SWIG_0(L);} if (argc == 1) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_new_vec2__SWIG_1(L);} check_2: if (argc == 1) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; return _wrap_new_vec2__SWIG_4(L);} check_3: if (argc == 1) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_4; return _wrap_new_vec2__SWIG_5(L);} check_4: if (argc == 1) { + return _wrap_new_vec2__SWIG_2(L);} if (argc == 2) { return _wrap_new_vec2__SWIG_3(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_vec2'\n" " Possible C/C++ prototypes are:\n" + " glm::vec2::vec2()\n" " glm::vec2::vec2(glm::vec2 const &)\n" " glm::vec2::vec2(float)\n" + " glm::vec2::vec2(float,float)\n" " glm::vec2::vec2(glm::vec3 const &)\n" " glm::vec2::vec2(glm::vec4 const &)\n"); + lua_error(L);return 0; } +static int _wrap_vec2___getitem(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = (glm::vec2 *) 0 ; int arg2 ; float result; + SWIG_check_num_args("glm::vec2::__getitem__",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::vec2::__getitem__",1,"glm::vec2 *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::vec2::__getitem__",2,"int"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ + SWIG_fail_ptr("vec2___getitem",1,SWIGTYPE_p_glm__vec2); } arg2 = (int)lua_tonumber(L, 2); try { + result = (float)glm_vec2___getitem__(arg1,arg2);} catch(std::out_of_range &_e) { + SWIG_exception(SWIG_IndexError, (&_e)->what()); } lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; + if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_vec2___setitem(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = (glm::vec2 *) 0 ; int arg2 ; float arg3 ; + SWIG_check_num_args("glm::vec2::__setitem__",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::vec2::__setitem__",1,"glm::vec2 *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::vec2::__setitem__",2,"int"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("glm::vec2::__setitem__",3,"float"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ + SWIG_fail_ptr("vec2___setitem",1,SWIGTYPE_p_glm__vec2); } arg2 = (int)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); + try { glm_vec2___setitem__(arg1,arg2,arg3);} catch(std::out_of_range &_e) { SWIG_exception(SWIG_IndexError, (&_e)->what()); } + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_vec2___tostring(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = (glm::vec2 *) 0 ; std::string result; + SWIG_check_num_args("glm::vec2::__tostring",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::vec2::__tostring",1,"glm::vec2 *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ + SWIG_fail_ptr("vec2___tostring",1,SWIGTYPE_p_glm__vec2); } result = glm_vec2___tostring(arg1); + lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_vec2___add__SWIG_0(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = (glm::vec2 *) 0 ; glm::vec2 *arg2 = 0 ; + glm::vec2 result; SWIG_check_num_args("glm::vec2::operator +",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::vec2::operator +",1,"glm::vec2 *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::vec2::operator +",2,"glm::vec2 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ + SWIG_fail_ptr("vec2___add",1,SWIGTYPE_p_glm__vec2); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec2,0))){ + SWIG_fail_ptr("vec2___add",2,SWIGTYPE_p_glm__vec2); } + result = glm_vec2_operator_Sa___SWIG_0(arg1,(glm::vec2 const &)*arg2); { + glm::vec2 * resultptr = new glm::vec2((const glm::vec2 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_vec2___add__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = (glm::vec2 *) 0 ; float arg2 ; + glm::vec2 result; SWIG_check_num_args("glm::vec2::operator +",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::vec2::operator +",1,"glm::vec2 *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::vec2::operator +",2,"float"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ + SWIG_fail_ptr("vec2___add",1,SWIGTYPE_p_glm__vec2); } arg2 = (float)lua_tonumber(L, 2); + result = glm_vec2_operator_Sa___SWIG_1(arg1,arg2); { glm::vec2 * resultptr = new glm::vec2((const glm::vec2 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_vec2___add(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v = 0; + { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_vec2___add__SWIG_0(L);} check_1: + if (argc == 2) { return _wrap_vec2___add__SWIG_1(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'vec2___add'\n" " Possible C/C++ prototypes are:\n" + " glm::vec2::operator +(glm::vec2 const &)\n" " glm::vec2::operator +(float)\n"); lua_error(L);return 0; } +static int _wrap_vec2___sub__SWIG_0(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = (glm::vec2 *) 0 ; glm::vec2 *arg2 = 0 ; + glm::vec2 result; SWIG_check_num_args("glm::vec2::operator -",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::vec2::operator -",1,"glm::vec2 *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::vec2::operator -",2,"glm::vec2 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ + SWIG_fail_ptr("vec2___sub",1,SWIGTYPE_p_glm__vec2); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec2,0))){ + SWIG_fail_ptr("vec2___sub",2,SWIGTYPE_p_glm__vec2); } + result = glm_vec2_operator_Ss___SWIG_0(arg1,(glm::vec2 const &)*arg2); { + glm::vec2 * resultptr = new glm::vec2((const glm::vec2 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_vec2___sub__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = (glm::vec2 *) 0 ; float arg2 ; + glm::vec2 result; SWIG_check_num_args("glm::vec2::operator -",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::vec2::operator -",1,"glm::vec2 *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::vec2::operator -",2,"float"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ + SWIG_fail_ptr("vec2___sub",1,SWIGTYPE_p_glm__vec2); } arg2 = (float)lua_tonumber(L, 2); + result = glm_vec2_operator_Ss___SWIG_1(arg1,arg2); { glm::vec2 * resultptr = new glm::vec2((const glm::vec2 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_vec2___sub(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v = 0; + { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_vec2___sub__SWIG_0(L);} check_1: + if (argc == 2) { return _wrap_vec2___sub__SWIG_1(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'vec2___sub'\n" " Possible C/C++ prototypes are:\n" + " glm::vec2::operator -(glm::vec2 const &)\n" " glm::vec2::operator -(float)\n"); lua_error(L);return 0; } +static int _wrap_vec2___mul__SWIG_0(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = (glm::vec2 *) 0 ; glm::vec2 *arg2 = 0 ; + glm::vec2 result; SWIG_check_num_args("glm::vec2::operator *",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::vec2::operator *",1,"glm::vec2 *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::vec2::operator *",2,"glm::vec2 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ + SWIG_fail_ptr("vec2___mul",1,SWIGTYPE_p_glm__vec2); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec2,0))){ + SWIG_fail_ptr("vec2___mul",2,SWIGTYPE_p_glm__vec2); } + result = glm_vec2_operator_Sm___SWIG_0(arg1,(glm::vec2 const &)*arg2); { + glm::vec2 * resultptr = new glm::vec2((const glm::vec2 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_vec2___mul__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = (glm::vec2 *) 0 ; float arg2 ; + glm::vec2 result; SWIG_check_num_args("glm::vec2::operator *",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::vec2::operator *",1,"glm::vec2 *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::vec2::operator *",2,"float"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ + SWIG_fail_ptr("vec2___mul",1,SWIGTYPE_p_glm__vec2); } arg2 = (float)lua_tonumber(L, 2); + result = glm_vec2_operator_Sm___SWIG_1(arg1,arg2); { glm::vec2 * resultptr = new glm::vec2((const glm::vec2 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_vec2___mul(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v = 0; + { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_vec2___mul__SWIG_0(L);} check_1: + if (argc == 2) { return _wrap_vec2___mul__SWIG_1(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'vec2___mul'\n" " Possible C/C++ prototypes are:\n" + " glm::vec2::operator *(glm::vec2 const &)\n" " glm::vec2::operator *(float)\n"); lua_error(L);return 0; } +static int _wrap_vec2___div__SWIG_0(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = (glm::vec2 *) 0 ; glm::vec2 *arg2 = 0 ; + glm::vec2 result; SWIG_check_num_args("glm::vec2::operator /",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::vec2::operator /",1,"glm::vec2 *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::vec2::operator /",2,"glm::vec2 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ + SWIG_fail_ptr("vec2___div",1,SWIGTYPE_p_glm__vec2); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec2,0))){ + SWIG_fail_ptr("vec2___div",2,SWIGTYPE_p_glm__vec2); } + result = glm_vec2_operator_Sd___SWIG_0(arg1,(glm::vec2 const &)*arg2); { + glm::vec2 * resultptr = new glm::vec2((const glm::vec2 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_vec2___div__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = (glm::vec2 *) 0 ; float arg2 ; + glm::vec2 result; SWIG_check_num_args("glm::vec2::operator /",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::vec2::operator /",1,"glm::vec2 *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::vec2::operator /",2,"float"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ + SWIG_fail_ptr("vec2___div",1,SWIGTYPE_p_glm__vec2); } arg2 = (float)lua_tonumber(L, 2); + result = glm_vec2_operator_Sd___SWIG_1(arg1,arg2); { glm::vec2 * resultptr = new glm::vec2((const glm::vec2 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_vec2___div(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v = 0; + { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_vec2___div__SWIG_0(L);} check_1: + if (argc == 2) { return _wrap_vec2___div__SWIG_1(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'vec2___div'\n" " Possible C/C++ prototypes are:\n" + " glm::vec2::operator /(glm::vec2 const &)\n" " glm::vec2::operator /(float)\n"); lua_error(L);return 0; } +static int _wrap_vec2___eq(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = (glm::vec2 *) 0 ; glm::vec2 *arg2 = 0 ; + bool result; SWIG_check_num_args("glm::vec2::operator ==",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::vec2::operator ==",1,"glm::vec2 *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::vec2::operator ==",2,"glm::vec2 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ + SWIG_fail_ptr("vec2___eq",1,SWIGTYPE_p_glm__vec2); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec2,0))){ + SWIG_fail_ptr("vec2___eq",2,SWIGTYPE_p_glm__vec2); } + result = (bool)glm_vec2_operator_Se__Se_(arg1,(glm::vec2 const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static void swig_delete_vec2(void *obj) { +glm::vec2 *arg1 = (glm::vec2 *) obj; +delete arg1; +} +static int _proxy__wrap_new_vec2(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_vec2); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_vec2_attributes[] = { + { "x", _wrap_vec2_x_get, _wrap_vec2_x_set }, + { "y", _wrap_vec2_y_get, _wrap_vec2_y_set }, + {0,0,0} +}; +static swig_lua_method swig_vec2_methods[]= { + { "__getitem", _wrap_vec2___getitem}, + { "__setitem", _wrap_vec2___setitem}, + { "__tostring", _wrap_vec2___tostring}, + { "__add", _wrap_vec2___add}, + { "__sub", _wrap_vec2___sub}, + { "__mul", _wrap_vec2___mul}, + { "__div", _wrap_vec2___div}, + { "__eq", _wrap_vec2___eq}, + {0,0} +}; +static swig_lua_method swig_vec2_meta[] = { + { "__getitem", _wrap_vec2___getitem}, + { "__setitem", _wrap_vec2___setitem}, + { "__tostring", _wrap_vec2___tostring}, + { "__add", _wrap_vec2___add}, + { "__sub", _wrap_vec2___sub}, + { "__mul", _wrap_vec2___mul}, + { "__div", _wrap_vec2___div}, + { "__eq", _wrap_vec2___eq}, + {0,0} +}; + +static swig_lua_attribute swig_vec2_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_vec2_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_vec2_Sf_SwigStatic_methods[]= { + { "length", _wrap_vec2_length}, + {0,0} +}; +static swig_lua_class* swig_vec2_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_vec2_Sf_SwigStatic = { + "vec2", + swig_vec2_Sf_SwigStatic_methods, + swig_vec2_Sf_SwigStatic_attributes, + swig_vec2_Sf_SwigStatic_constants, + swig_vec2_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_vec2_bases[] = {0}; +static const char *swig_vec2_base_names[] = {0}; +static swig_lua_class _wrap_class_vec2 = { "vec2", "vec2", &SWIGTYPE_p_glm__vec2,_proxy__wrap_new_vec2, swig_delete_vec2, swig_vec2_methods, swig_vec2_attributes, &swig_vec2_Sf_SwigStatic, swig_vec2_meta, swig_vec2_bases, swig_vec2_base_names }; + +static int _wrap_add__SWIG_0(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = 0 ; float arg2 ; glm::vec2 result; + SWIG_check_num_args("glm::operator +",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::operator +",1,"glm::vec2 const &"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::operator +",2,"float"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("add",1,SWIGTYPE_p_glm__vec2); } + arg2 = (float)lua_tonumber(L, 2); result = glm::operator +((glm::vec2 const &)*arg1,arg2); { + glm::vec2 * resultptr = new glm::vec2((const glm::vec2 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_add__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; glm::vec2 *arg2 = 0 ; glm::vec2 result; + SWIG_check_num_args("glm::operator +",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::operator +",1,"float"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::operator +",2,"glm::vec2 const &"); arg1 = (float)lua_tonumber(L, 1); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("add",2,SWIGTYPE_p_glm__vec2); } + result = glm::operator +(arg1,(glm::vec2 const &)*arg2); { glm::vec2 * resultptr = new glm::vec2((const glm::vec2 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_add__SWIG_2(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = 0 ; glm::vec2 *arg2 = 0 ; glm::vec2 result; + SWIG_check_num_args("glm::operator +",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::operator +",1,"glm::vec2 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::operator +",2,"glm::vec2 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("add",1,SWIGTYPE_p_glm__vec2); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("add",2,SWIGTYPE_p_glm__vec2); } + result = glm::operator +((glm::vec2 const &)*arg1,(glm::vec2 const &)*arg2); { + glm::vec2 * resultptr = new glm::vec2((const glm::vec2 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_sub__SWIG_0(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = 0 ; float arg2 ; glm::vec2 result; + SWIG_check_num_args("glm::operator -",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::operator -",1,"glm::vec2 const &"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::operator -",2,"float"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("sub",1,SWIGTYPE_p_glm__vec2); } + arg2 = (float)lua_tonumber(L, 2); result = glm::operator -((glm::vec2 const &)*arg1,arg2); { + glm::vec2 * resultptr = new glm::vec2((const glm::vec2 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_sub__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; glm::vec2 *arg2 = 0 ; glm::vec2 result; + SWIG_check_num_args("glm::operator -",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::operator -",1,"float"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::operator -",2,"glm::vec2 const &"); arg1 = (float)lua_tonumber(L, 1); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("sub",2,SWIGTYPE_p_glm__vec2); } + result = glm::operator -(arg1,(glm::vec2 const &)*arg2); { glm::vec2 * resultptr = new glm::vec2((const glm::vec2 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_sub__SWIG_2(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = 0 ; glm::vec2 *arg2 = 0 ; glm::vec2 result; + SWIG_check_num_args("glm::operator -",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::operator -",1,"glm::vec2 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::operator -",2,"glm::vec2 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("sub",1,SWIGTYPE_p_glm__vec2); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("sub",2,SWIGTYPE_p_glm__vec2); } + result = glm::operator -((glm::vec2 const &)*arg1,(glm::vec2 const &)*arg2); { + glm::vec2 * resultptr = new glm::vec2((const glm::vec2 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_mul__SWIG_0(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = 0 ; float arg2 ; glm::vec2 result; + SWIG_check_num_args("glm::operator *",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::operator *",1,"glm::vec2 const &"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::operator *",2,"float"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("mul",1,SWIGTYPE_p_glm__vec2); } + arg2 = (float)lua_tonumber(L, 2); result = glm::operator *((glm::vec2 const &)*arg1,arg2); { + glm::vec2 * resultptr = new glm::vec2((const glm::vec2 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_mul__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; glm::vec2 *arg2 = 0 ; glm::vec2 result; + SWIG_check_num_args("glm::operator *",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::operator *",1,"float"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::operator *",2,"glm::vec2 const &"); arg1 = (float)lua_tonumber(L, 1); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("mul",2,SWIGTYPE_p_glm__vec2); } + result = glm::operator *(arg1,(glm::vec2 const &)*arg2); { glm::vec2 * resultptr = new glm::vec2((const glm::vec2 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_mul__SWIG_2(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = 0 ; glm::vec2 *arg2 = 0 ; glm::vec2 result; + SWIG_check_num_args("glm::operator *",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::operator *",1,"glm::vec2 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::operator *",2,"glm::vec2 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("mul",1,SWIGTYPE_p_glm__vec2); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("mul",2,SWIGTYPE_p_glm__vec2); } + result = glm::operator *((glm::vec2 const &)*arg1,(glm::vec2 const &)*arg2); { + glm::vec2 * resultptr = new glm::vec2((const glm::vec2 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_div__SWIG_0(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = 0 ; float arg2 ; glm::vec2 result; + SWIG_check_num_args("glm::operator /",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::operator /",1,"glm::vec2 const &"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::operator /",2,"float"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("div",1,SWIGTYPE_p_glm__vec2); } + arg2 = (float)lua_tonumber(L, 2); result = glm::operator /((glm::vec2 const &)*arg1,arg2); { + glm::vec2 * resultptr = new glm::vec2((const glm::vec2 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_div__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; glm::vec2 *arg2 = 0 ; glm::vec2 result; + SWIG_check_num_args("glm::operator /",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::operator /",1,"float"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::operator /",2,"glm::vec2 const &"); arg1 = (float)lua_tonumber(L, 1); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("div",2,SWIGTYPE_p_glm__vec2); } + result = glm::operator /(arg1,(glm::vec2 const &)*arg2); { glm::vec2 * resultptr = new glm::vec2((const glm::vec2 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_div__SWIG_2(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = 0 ; glm::vec2 *arg2 = 0 ; glm::vec2 result; + SWIG_check_num_args("glm::operator /",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::operator /",1,"glm::vec2 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::operator /",2,"glm::vec2 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("div",1,SWIGTYPE_p_glm__vec2); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("div",2,SWIGTYPE_p_glm__vec2); } + result = glm::operator /((glm::vec2 const &)*arg1,(glm::vec2 const &)*arg2); { + glm::vec2 * resultptr = new glm::vec2((const glm::vec2 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_eq__SWIG_0(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = 0 ; glm::vec2 *arg2 = 0 ; bool result; + SWIG_check_num_args("glm::operator ==",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::operator ==",1,"glm::vec2 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::operator ==",2,"glm::vec2 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("eq",1,SWIGTYPE_p_glm__vec2); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("eq",2,SWIGTYPE_p_glm__vec2); } + result = (bool)glm::operator ==((glm::vec2 const &)*arg1,(glm::vec2 const &)*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_vec3_x_set(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = (glm::vec3 *) 0 ; float arg2 ; + SWIG_check_num_args("glm::vec3::x",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::vec3::x",1,"glm::vec3 *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::vec3::x",2,"float"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ + SWIG_fail_ptr("vec3_x_set",1,SWIGTYPE_p_glm__vec3); } arg2 = (float)lua_tonumber(L, 2); if (arg1) (arg1)->x = arg2; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_vec3_x_get(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = (glm::vec3 *) 0 ; float result; + SWIG_check_num_args("glm::vec3::x",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::vec3::x",1,"glm::vec3 *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ + SWIG_fail_ptr("vec3_x_get",1,SWIGTYPE_p_glm__vec3); } result = (float) ((arg1)->x); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_vec3_y_set(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = (glm::vec3 *) 0 ; float arg2 ; + SWIG_check_num_args("glm::vec3::y",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::vec3::y",1,"glm::vec3 *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::vec3::y",2,"float"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ + SWIG_fail_ptr("vec3_y_set",1,SWIGTYPE_p_glm__vec3); } arg2 = (float)lua_tonumber(L, 2); if (arg1) (arg1)->y = arg2; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_vec3_y_get(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = (glm::vec3 *) 0 ; float result; + SWIG_check_num_args("glm::vec3::y",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::vec3::y",1,"glm::vec3 *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ + SWIG_fail_ptr("vec3_y_get",1,SWIGTYPE_p_glm__vec3); } result = (float) ((arg1)->y); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_vec3_z_set(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = (glm::vec3 *) 0 ; float arg2 ; + SWIG_check_num_args("glm::vec3::z",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::vec3::z",1,"glm::vec3 *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::vec3::z",2,"float"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ + SWIG_fail_ptr("vec3_z_set",1,SWIGTYPE_p_glm__vec3); } arg2 = (float)lua_tonumber(L, 2); if (arg1) (arg1)->z = arg2; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_vec3_z_get(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = (glm::vec3 *) 0 ; float result; + SWIG_check_num_args("glm::vec3::z",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::vec3::z",1,"glm::vec3 *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ + SWIG_fail_ptr("vec3_z_get",1,SWIGTYPE_p_glm__vec3); } result = (float) ((arg1)->z); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_vec3_length(lua_State* L) { int SWIG_arg = 0; glm::length_t result; + SWIG_check_num_args("glm::vec3::length",0,0) result = (glm::length_t)glm::vec3::length(); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_new_vec3__SWIG_0(lua_State* L) { int SWIG_arg = 0; glm::vec3 *result = 0 ; + SWIG_check_num_args("glm::vec3::vec3",0,0) result = (glm::vec3 *)new glm::vec3(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_new_vec3__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; glm::vec3 *result = 0 ; + SWIG_check_num_args("glm::vec3::vec3",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::vec3::vec3",1,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("new_vec3",1,SWIGTYPE_p_glm__vec3); } + result = (glm::vec3 *)new glm::vec3((glm::vec3 const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_new_vec3__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; glm::vec3 *result = 0 ; + SWIG_check_num_args("glm::vec3::vec3",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::vec3::vec3",1,"float"); + arg1 = (float)lua_tonumber(L, 1); result = (glm::vec3 *)new glm::vec3(arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_new_vec3__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; + glm::vec3 *result = 0 ; SWIG_check_num_args("glm::vec3::vec3",3,3) + if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::vec3::vec3",1,"float"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::vec3::vec3",2,"float"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("glm::vec3::vec3",3,"float"); arg1 = (float)lua_tonumber(L, 1); + arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); result = (glm::vec3 *)new glm::vec3(arg1,arg2,arg3); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_new_vec3__SWIG_4(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = 0 ; float arg2 ; glm::vec3 *result = 0 ; + SWIG_check_num_args("glm::vec3::vec3",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::vec3::vec3",1,"glm::vec2 const &"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::vec3::vec3",2,"float"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("new_vec3",1,SWIGTYPE_p_glm__vec2); } + arg2 = (float)lua_tonumber(L, 2); result = (glm::vec3 *)new glm::vec3((glm::vec2 const &)*arg1,arg2); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_new_vec3__SWIG_5(lua_State* L) { int SWIG_arg = 0; float arg1 ; glm::vec2 *arg2 = 0 ; glm::vec3 *result = 0 ; + SWIG_check_num_args("glm::vec3::vec3",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::vec3::vec3",1,"float"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::vec3::vec3",2,"glm::vec2 const &"); arg1 = (float)lua_tonumber(L, 1); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("new_vec3",2,SWIGTYPE_p_glm__vec2); } + result = (glm::vec3 *)new glm::vec3(arg1,(glm::vec2 const &)*arg2); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_new_vec3__SWIG_6(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = 0 ; glm::vec3 *result = 0 ; + SWIG_check_num_args("glm::vec3::vec3",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::vec3::vec3",1,"glm::vec4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("new_vec3",1,SWIGTYPE_p_glm__vec4); } + result = (glm::vec3 *)new glm::vec3((glm::vec4 const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_new_vec3(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 0) { + return _wrap_new_vec3__SWIG_0(L);} if (argc == 1) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_new_vec3__SWIG_1(L);} check_2: if (argc == 1) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; return _wrap_new_vec3__SWIG_6(L);} check_3: if (argc == 1) { + return _wrap_new_vec3__SWIG_2(L);} if (argc == 2) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_5; { { _v = lua_isnumber(L,argv[1]); } } if (!_v) goto check_5; + return _wrap_new_vec3__SWIG_4(L);} check_5: if (argc == 2) { return _wrap_new_vec3__SWIG_5(L);} if (argc == 3) { + return _wrap_new_vec3__SWIG_3(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_vec3'\n" + " Possible C/C++ prototypes are:\n" " glm::vec3::vec3()\n" " glm::vec3::vec3(glm::vec3 const &)\n" + " glm::vec3::vec3(float)\n" " glm::vec3::vec3(float,float,float)\n" " glm::vec3::vec3(glm::vec2 const &,float)\n" + " glm::vec3::vec3(float,glm::vec2 const &)\n" " glm::vec3::vec3(glm::vec4 const &)\n"); lua_error(L);return 0; } +static int _wrap_vec3___getitem(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = (glm::vec3 *) 0 ; int arg2 ; float result; + SWIG_check_num_args("glm::vec3::__getitem__",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::vec3::__getitem__",1,"glm::vec3 *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::vec3::__getitem__",2,"int"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ + SWIG_fail_ptr("vec3___getitem",1,SWIGTYPE_p_glm__vec3); } arg2 = (int)lua_tonumber(L, 2); try { + result = (float)glm_vec3___getitem__(arg1,arg2);} catch(std::out_of_range &_e) { + SWIG_exception(SWIG_IndexError, (&_e)->what()); } lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; + if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_vec3___setitem(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = (glm::vec3 *) 0 ; int arg2 ; float arg3 ; + SWIG_check_num_args("glm::vec3::__setitem__",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::vec3::__setitem__",1,"glm::vec3 *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::vec3::__setitem__",2,"int"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("glm::vec3::__setitem__",3,"float"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ + SWIG_fail_ptr("vec3___setitem",1,SWIGTYPE_p_glm__vec3); } arg2 = (int)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); + try { glm_vec3___setitem__(arg1,arg2,arg3);} catch(std::out_of_range &_e) { SWIG_exception(SWIG_IndexError, (&_e)->what()); } + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_vec3___tostring(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = (glm::vec3 *) 0 ; std::string result; + SWIG_check_num_args("glm::vec3::__tostring",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::vec3::__tostring",1,"glm::vec3 *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ + SWIG_fail_ptr("vec3___tostring",1,SWIGTYPE_p_glm__vec3); } result = glm_vec3___tostring(arg1); + lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_vec3___add__SWIG_0(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = (glm::vec3 *) 0 ; glm::vec3 *arg2 = 0 ; + glm::vec3 result; SWIG_check_num_args("glm::vec3::operator +",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::vec3::operator +",1,"glm::vec3 *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::vec3::operator +",2,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ + SWIG_fail_ptr("vec3___add",1,SWIGTYPE_p_glm__vec3); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ + SWIG_fail_ptr("vec3___add",2,SWIGTYPE_p_glm__vec3); } + result = glm_vec3_operator_Sa___SWIG_0(arg1,(glm::vec3 const &)*arg2); { + glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_vec3___add__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = (glm::vec3 *) 0 ; float arg2 ; + glm::vec3 result; SWIG_check_num_args("glm::vec3::operator +",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::vec3::operator +",1,"glm::vec3 *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::vec3::operator +",2,"float"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ + SWIG_fail_ptr("vec3___add",1,SWIGTYPE_p_glm__vec3); } arg2 = (float)lua_tonumber(L, 2); + result = glm_vec3_operator_Sa___SWIG_1(arg1,arg2); { glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_vec3___add(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v = 0; + { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_vec3___add__SWIG_0(L);} check_1: + if (argc == 2) { return _wrap_vec3___add__SWIG_1(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'vec3___add'\n" " Possible C/C++ prototypes are:\n" + " glm::vec3::operator +(glm::vec3 const &)\n" " glm::vec3::operator +(float)\n"); lua_error(L);return 0; } +static int _wrap_vec3___sub__SWIG_0(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = (glm::vec3 *) 0 ; glm::vec3 *arg2 = 0 ; + glm::vec3 result; SWIG_check_num_args("glm::vec3::operator -",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::vec3::operator -",1,"glm::vec3 *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::vec3::operator -",2,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ + SWIG_fail_ptr("vec3___sub",1,SWIGTYPE_p_glm__vec3); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ + SWIG_fail_ptr("vec3___sub",2,SWIGTYPE_p_glm__vec3); } + result = glm_vec3_operator_Ss___SWIG_0(arg1,(glm::vec3 const &)*arg2); { + glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_vec3___sub__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = (glm::vec3 *) 0 ; float arg2 ; + glm::vec3 result; SWIG_check_num_args("glm::vec3::operator -",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::vec3::operator -",1,"glm::vec3 *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::vec3::operator -",2,"float"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ + SWIG_fail_ptr("vec3___sub",1,SWIGTYPE_p_glm__vec3); } arg2 = (float)lua_tonumber(L, 2); + result = glm_vec3_operator_Ss___SWIG_1(arg1,arg2); { glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_vec3___sub(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v = 0; + { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_vec3___sub__SWIG_0(L);} check_1: + if (argc == 2) { return _wrap_vec3___sub__SWIG_1(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'vec3___sub'\n" " Possible C/C++ prototypes are:\n" + " glm::vec3::operator -(glm::vec3 const &)\n" " glm::vec3::operator -(float)\n"); lua_error(L);return 0; } +static int _wrap_vec3___mul__SWIG_0(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = (glm::vec3 *) 0 ; glm::vec3 *arg2 = 0 ; + glm::vec3 result; SWIG_check_num_args("glm::vec3::operator *",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::vec3::operator *",1,"glm::vec3 *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::vec3::operator *",2,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ + SWIG_fail_ptr("vec3___mul",1,SWIGTYPE_p_glm__vec3); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ + SWIG_fail_ptr("vec3___mul",2,SWIGTYPE_p_glm__vec3); } + result = glm_vec3_operator_Sm___SWIG_0(arg1,(glm::vec3 const &)*arg2); { + glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_vec3___mul__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = (glm::vec3 *) 0 ; float arg2 ; + glm::vec3 result; SWIG_check_num_args("glm::vec3::operator *",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::vec3::operator *",1,"glm::vec3 *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::vec3::operator *",2,"float"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ + SWIG_fail_ptr("vec3___mul",1,SWIGTYPE_p_glm__vec3); } arg2 = (float)lua_tonumber(L, 2); + result = glm_vec3_operator_Sm___SWIG_1(arg1,arg2); { glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_vec3___mul(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v = 0; + { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_vec3___mul__SWIG_0(L);} check_1: + if (argc == 2) { return _wrap_vec3___mul__SWIG_1(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'vec3___mul'\n" " Possible C/C++ prototypes are:\n" + " glm::vec3::operator *(glm::vec3 const &)\n" " glm::vec3::operator *(float)\n"); lua_error(L);return 0; } +static int _wrap_vec3___div__SWIG_0(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = (glm::vec3 *) 0 ; glm::vec3 *arg2 = 0 ; + glm::vec3 result; SWIG_check_num_args("glm::vec3::operator /",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::vec3::operator /",1,"glm::vec3 *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::vec3::operator /",2,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ + SWIG_fail_ptr("vec3___div",1,SWIGTYPE_p_glm__vec3); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ + SWIG_fail_ptr("vec3___div",2,SWIGTYPE_p_glm__vec3); } + result = glm_vec3_operator_Sd___SWIG_0(arg1,(glm::vec3 const &)*arg2); { + glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_vec3___div__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = (glm::vec3 *) 0 ; float arg2 ; + glm::vec3 result; SWIG_check_num_args("glm::vec3::operator /",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::vec3::operator /",1,"glm::vec3 *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::vec3::operator /",2,"float"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ + SWIG_fail_ptr("vec3___div",1,SWIGTYPE_p_glm__vec3); } arg2 = (float)lua_tonumber(L, 2); + result = glm_vec3_operator_Sd___SWIG_1(arg1,arg2); { glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_vec3___div(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v = 0; + { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_vec3___div__SWIG_0(L);} check_1: + if (argc == 2) { return _wrap_vec3___div__SWIG_1(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'vec3___div'\n" " Possible C/C++ prototypes are:\n" + " glm::vec3::operator /(glm::vec3 const &)\n" " glm::vec3::operator /(float)\n"); lua_error(L);return 0; } +static int _wrap_vec3___eq(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = (glm::vec3 *) 0 ; glm::vec3 *arg2 = 0 ; + bool result; SWIG_check_num_args("glm::vec3::operator ==",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::vec3::operator ==",1,"glm::vec3 *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::vec3::operator ==",2,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ + SWIG_fail_ptr("vec3___eq",1,SWIGTYPE_p_glm__vec3); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ + SWIG_fail_ptr("vec3___eq",2,SWIGTYPE_p_glm__vec3); } + result = (bool)glm_vec3_operator_Se__Se_(arg1,(glm::vec3 const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static void swig_delete_vec3(void *obj) { +glm::vec3 *arg1 = (glm::vec3 *) obj; +delete arg1; +} +static int _proxy__wrap_new_vec3(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_vec3); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_vec3_attributes[] = { + { "x", _wrap_vec3_x_get, _wrap_vec3_x_set }, + { "y", _wrap_vec3_y_get, _wrap_vec3_y_set }, + { "z", _wrap_vec3_z_get, _wrap_vec3_z_set }, + {0,0,0} +}; +static swig_lua_method swig_vec3_methods[]= { + { "__getitem", _wrap_vec3___getitem}, + { "__setitem", _wrap_vec3___setitem}, + { "__tostring", _wrap_vec3___tostring}, + { "__add", _wrap_vec3___add}, + { "__sub", _wrap_vec3___sub}, + { "__mul", _wrap_vec3___mul}, + { "__div", _wrap_vec3___div}, + { "__eq", _wrap_vec3___eq}, + {0,0} +}; +static swig_lua_method swig_vec3_meta[] = { + { "__getitem", _wrap_vec3___getitem}, + { "__setitem", _wrap_vec3___setitem}, + { "__tostring", _wrap_vec3___tostring}, + { "__add", _wrap_vec3___add}, + { "__sub", _wrap_vec3___sub}, + { "__mul", _wrap_vec3___mul}, + { "__div", _wrap_vec3___div}, + { "__eq", _wrap_vec3___eq}, + {0,0} +}; + +static swig_lua_attribute swig_vec3_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_vec3_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_vec3_Sf_SwigStatic_methods[]= { + { "length", _wrap_vec3_length}, + {0,0} +}; +static swig_lua_class* swig_vec3_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_vec3_Sf_SwigStatic = { + "vec3", + swig_vec3_Sf_SwigStatic_methods, + swig_vec3_Sf_SwigStatic_attributes, + swig_vec3_Sf_SwigStatic_constants, + swig_vec3_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_vec3_bases[] = {0}; +static const char *swig_vec3_base_names[] = {0}; +static swig_lua_class _wrap_class_vec3 = { "vec3", "vec3", &SWIGTYPE_p_glm__vec3,_proxy__wrap_new_vec3, swig_delete_vec3, swig_vec3_methods, swig_vec3_attributes, &swig_vec3_Sf_SwigStatic, swig_vec3_meta, swig_vec3_bases, swig_vec3_base_names }; + +static int _wrap_add__SWIG_3(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; float arg2 ; glm::vec3 result; + SWIG_check_num_args("glm::operator +",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::operator +",1,"glm::vec3 const &"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::operator +",2,"float"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("add",1,SWIGTYPE_p_glm__vec3); } + arg2 = (float)lua_tonumber(L, 2); result = glm::operator +((glm::vec3 const &)*arg1,arg2); { + glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_add__SWIG_4(lua_State* L) { int SWIG_arg = 0; float arg1 ; glm::vec3 *arg2 = 0 ; glm::vec3 result; + SWIG_check_num_args("glm::operator +",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::operator +",1,"float"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::operator +",2,"glm::vec3 const &"); arg1 = (float)lua_tonumber(L, 1); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("add",2,SWIGTYPE_p_glm__vec3); } + result = glm::operator +(arg1,(glm::vec3 const &)*arg2); { glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_add__SWIG_5(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; glm::vec3 *arg2 = 0 ; glm::vec3 result; + SWIG_check_num_args("glm::operator +",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::operator +",1,"glm::vec3 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::operator +",2,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("add",1,SWIGTYPE_p_glm__vec3); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("add",2,SWIGTYPE_p_glm__vec3); } + result = glm::operator +((glm::vec3 const &)*arg1,(glm::vec3 const &)*arg2); { + glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_sub__SWIG_3(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; float arg2 ; glm::vec3 result; + SWIG_check_num_args("glm::operator -",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::operator -",1,"glm::vec3 const &"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::operator -",2,"float"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("sub",1,SWIGTYPE_p_glm__vec3); } + arg2 = (float)lua_tonumber(L, 2); result = glm::operator -((glm::vec3 const &)*arg1,arg2); { + glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_sub__SWIG_4(lua_State* L) { int SWIG_arg = 0; float arg1 ; glm::vec3 *arg2 = 0 ; glm::vec3 result; + SWIG_check_num_args("glm::operator -",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::operator -",1,"float"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::operator -",2,"glm::vec3 const &"); arg1 = (float)lua_tonumber(L, 1); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("sub",2,SWIGTYPE_p_glm__vec3); } + result = glm::operator -(arg1,(glm::vec3 const &)*arg2); { glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_sub__SWIG_5(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; glm::vec3 *arg2 = 0 ; glm::vec3 result; + SWIG_check_num_args("glm::operator -",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::operator -",1,"glm::vec3 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::operator -",2,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("sub",1,SWIGTYPE_p_glm__vec3); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("sub",2,SWIGTYPE_p_glm__vec3); } + result = glm::operator -((glm::vec3 const &)*arg1,(glm::vec3 const &)*arg2); { + glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_mul__SWIG_3(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; float arg2 ; glm::vec3 result; + SWIG_check_num_args("glm::operator *",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::operator *",1,"glm::vec3 const &"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::operator *",2,"float"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("mul",1,SWIGTYPE_p_glm__vec3); } + arg2 = (float)lua_tonumber(L, 2); result = glm::operator *((glm::vec3 const &)*arg1,arg2); { + glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_mul__SWIG_4(lua_State* L) { int SWIG_arg = 0; float arg1 ; glm::vec3 *arg2 = 0 ; glm::vec3 result; + SWIG_check_num_args("glm::operator *",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::operator *",1,"float"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::operator *",2,"glm::vec3 const &"); arg1 = (float)lua_tonumber(L, 1); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("mul",2,SWIGTYPE_p_glm__vec3); } + result = glm::operator *(arg1,(glm::vec3 const &)*arg2); { glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_mul__SWIG_5(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; glm::vec3 *arg2 = 0 ; glm::vec3 result; + SWIG_check_num_args("glm::operator *",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::operator *",1,"glm::vec3 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::operator *",2,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("mul",1,SWIGTYPE_p_glm__vec3); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("mul",2,SWIGTYPE_p_glm__vec3); } + result = glm::operator *((glm::vec3 const &)*arg1,(glm::vec3 const &)*arg2); { + glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_div__SWIG_3(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; float arg2 ; glm::vec3 result; + SWIG_check_num_args("glm::operator /",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::operator /",1,"glm::vec3 const &"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::operator /",2,"float"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("div",1,SWIGTYPE_p_glm__vec3); } + arg2 = (float)lua_tonumber(L, 2); result = glm::operator /((glm::vec3 const &)*arg1,arg2); { + glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_div__SWIG_4(lua_State* L) { int SWIG_arg = 0; float arg1 ; glm::vec3 *arg2 = 0 ; glm::vec3 result; + SWIG_check_num_args("glm::operator /",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::operator /",1,"float"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::operator /",2,"glm::vec3 const &"); arg1 = (float)lua_tonumber(L, 1); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("div",2,SWIGTYPE_p_glm__vec3); } + result = glm::operator /(arg1,(glm::vec3 const &)*arg2); { glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_div__SWIG_5(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; glm::vec3 *arg2 = 0 ; glm::vec3 result; + SWIG_check_num_args("glm::operator /",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::operator /",1,"glm::vec3 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::operator /",2,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("div",1,SWIGTYPE_p_glm__vec3); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("div",2,SWIGTYPE_p_glm__vec3); } + result = glm::operator /((glm::vec3 const &)*arg1,(glm::vec3 const &)*arg2); { + glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_eq__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; glm::vec3 *arg2 = 0 ; bool result; + SWIG_check_num_args("glm::operator ==",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::operator ==",1,"glm::vec3 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::operator ==",2,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("eq",1,SWIGTYPE_p_glm__vec3); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("eq",2,SWIGTYPE_p_glm__vec3); } + result = (bool)glm::operator ==((glm::vec3 const &)*arg1,(glm::vec3 const &)*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_vec4_x_set(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = (glm::vec4 *) 0 ; float arg2 ; + SWIG_check_num_args("glm::vec4::x",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::vec4::x",1,"glm::vec4 *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::vec4::x",2,"float"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ + SWIG_fail_ptr("vec4_x_set",1,SWIGTYPE_p_glm__vec4); } arg2 = (float)lua_tonumber(L, 2); if (arg1) (arg1)->x = arg2; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_vec4_x_get(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = (glm::vec4 *) 0 ; float result; + SWIG_check_num_args("glm::vec4::x",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::vec4::x",1,"glm::vec4 *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ + SWIG_fail_ptr("vec4_x_get",1,SWIGTYPE_p_glm__vec4); } result = (float) ((arg1)->x); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_vec4_y_set(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = (glm::vec4 *) 0 ; float arg2 ; + SWIG_check_num_args("glm::vec4::y",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::vec4::y",1,"glm::vec4 *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::vec4::y",2,"float"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ + SWIG_fail_ptr("vec4_y_set",1,SWIGTYPE_p_glm__vec4); } arg2 = (float)lua_tonumber(L, 2); if (arg1) (arg1)->y = arg2; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_vec4_y_get(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = (glm::vec4 *) 0 ; float result; + SWIG_check_num_args("glm::vec4::y",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::vec4::y",1,"glm::vec4 *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ + SWIG_fail_ptr("vec4_y_get",1,SWIGTYPE_p_glm__vec4); } result = (float) ((arg1)->y); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_vec4_z_set(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = (glm::vec4 *) 0 ; float arg2 ; + SWIG_check_num_args("glm::vec4::z",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::vec4::z",1,"glm::vec4 *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::vec4::z",2,"float"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ + SWIG_fail_ptr("vec4_z_set",1,SWIGTYPE_p_glm__vec4); } arg2 = (float)lua_tonumber(L, 2); if (arg1) (arg1)->z = arg2; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_vec4_z_get(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = (glm::vec4 *) 0 ; float result; + SWIG_check_num_args("glm::vec4::z",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::vec4::z",1,"glm::vec4 *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ + SWIG_fail_ptr("vec4_z_get",1,SWIGTYPE_p_glm__vec4); } result = (float) ((arg1)->z); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_vec4_w_set(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = (glm::vec4 *) 0 ; float arg2 ; + SWIG_check_num_args("glm::vec4::w",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::vec4::w",1,"glm::vec4 *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::vec4::w",2,"float"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ + SWIG_fail_ptr("vec4_w_set",1,SWIGTYPE_p_glm__vec4); } arg2 = (float)lua_tonumber(L, 2); if (arg1) (arg1)->w = arg2; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_vec4_w_get(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = (glm::vec4 *) 0 ; float result; + SWIG_check_num_args("glm::vec4::w",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::vec4::w",1,"glm::vec4 *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ + SWIG_fail_ptr("vec4_w_get",1,SWIGTYPE_p_glm__vec4); } result = (float) ((arg1)->w); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_vec4_length(lua_State* L) { int SWIG_arg = 0; glm::length_t result; + SWIG_check_num_args("glm::vec4::length",0,0) result = (glm::length_t)glm::vec4::length(); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_new_vec4__SWIG_0(lua_State* L) { int SWIG_arg = 0; glm::vec4 *result = 0 ; + SWIG_check_num_args("glm::vec4::vec4",0,0) result = (glm::vec4 *)new glm::vec4(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_new_vec4__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = 0 ; glm::vec4 *result = 0 ; + SWIG_check_num_args("glm::vec4::vec4",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::vec4::vec4",1,"glm::vec4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("new_vec4",1,SWIGTYPE_p_glm__vec4); } + result = (glm::vec4 *)new glm::vec4((glm::vec4 const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_new_vec4__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; glm::vec4 *result = 0 ; + SWIG_check_num_args("glm::vec4::vec4",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::vec4::vec4",1,"float"); + arg1 = (float)lua_tonumber(L, 1); result = (glm::vec4 *)new glm::vec4(arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_new_vec4__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; + glm::vec4 *result = 0 ; SWIG_check_num_args("glm::vec4::vec4",4,4) + if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::vec4::vec4",1,"float"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::vec4::vec4",2,"float"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("glm::vec4::vec4",3,"float"); + if(!lua_isnumber(L,4)) SWIG_fail_arg("glm::vec4::vec4",4,"float"); arg1 = (float)lua_tonumber(L, 1); + arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); + result = (glm::vec4 *)new glm::vec4(arg1,arg2,arg3,arg4); SWIG_NewPointerObj(L,result,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_new_vec4__SWIG_4(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = 0 ; glm::vec2 *arg2 = 0 ; + glm::vec4 *result = 0 ; SWIG_check_num_args("glm::vec4::vec4",2,2) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::vec4::vec4",1,"glm::vec2 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::vec4::vec4",2,"glm::vec2 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("new_vec4",1,SWIGTYPE_p_glm__vec2); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec2,0))){ + SWIG_fail_ptr("new_vec4",2,SWIGTYPE_p_glm__vec2); } + result = (glm::vec4 *)new glm::vec4((glm::vec2 const &)*arg1,(glm::vec2 const &)*arg2); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_new_vec4__SWIG_5(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = 0 ; float arg2 ; float arg3 ; + glm::vec4 *result = 0 ; SWIG_check_num_args("glm::vec4::vec4",3,3) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::vec4::vec4",1,"glm::vec2 const &"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::vec4::vec4",2,"float"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("glm::vec4::vec4",3,"float"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("new_vec4",1,SWIGTYPE_p_glm__vec2); } + arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); + result = (glm::vec4 *)new glm::vec4((glm::vec2 const &)*arg1,arg2,arg3); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_new_vec4__SWIG_6(lua_State* L) { int SWIG_arg = 0; float arg1 ; glm::vec2 *arg2 = 0 ; float arg3 ; + glm::vec4 *result = 0 ; SWIG_check_num_args("glm::vec4::vec4",3,3) + if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::vec4::vec4",1,"float"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::vec4::vec4",2,"glm::vec2 const &"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("glm::vec4::vec4",3,"float"); arg1 = (float)lua_tonumber(L, 1); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("new_vec4",2,SWIGTYPE_p_glm__vec2); } + arg3 = (float)lua_tonumber(L, 3); result = (glm::vec4 *)new glm::vec4(arg1,(glm::vec2 const &)*arg2,arg3); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_new_vec4__SWIG_7(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; glm::vec2 *arg3 = 0 ; + glm::vec4 *result = 0 ; SWIG_check_num_args("glm::vec4::vec4",3,3) + if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::vec4::vec4",1,"float"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::vec4::vec4",2,"float"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("glm::vec4::vec4",3,"glm::vec2 const &"); arg1 = (float)lua_tonumber(L, 1); + arg2 = (float)lua_tonumber(L, 2); if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_glm__vec2,0))){ + SWIG_fail_ptr("new_vec4",3,SWIGTYPE_p_glm__vec2); } + result = (glm::vec4 *)new glm::vec4(arg1,arg2,(glm::vec2 const &)*arg3); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_new_vec4__SWIG_8(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; float arg2 ; glm::vec4 *result = 0 ; + SWIG_check_num_args("glm::vec4::vec4",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::vec4::vec4",1,"glm::vec3 const &"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::vec4::vec4",2,"float"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("new_vec4",1,SWIGTYPE_p_glm__vec3); } + arg2 = (float)lua_tonumber(L, 2); result = (glm::vec4 *)new glm::vec4((glm::vec3 const &)*arg1,arg2); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_new_vec4__SWIG_9(lua_State* L) { int SWIG_arg = 0; float arg1 ; glm::vec3 *arg2 = 0 ; glm::vec4 *result = 0 ; + SWIG_check_num_args("glm::vec4::vec4",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::vec4::vec4",1,"float"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::vec4::vec4",2,"glm::vec3 const &"); arg1 = (float)lua_tonumber(L, 1); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("new_vec4",2,SWIGTYPE_p_glm__vec3); } + result = (glm::vec4 *)new glm::vec4(arg1,(glm::vec3 const &)*arg2); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_new_vec4(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 0) { + return _wrap_new_vec4__SWIG_0(L);} if (argc == 1) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_new_vec4__SWIG_1(L);} check_2: if (argc == 1) { + return _wrap_new_vec4__SWIG_2(L);} if (argc == 2) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_4; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_4; return _wrap_new_vec4__SWIG_4(L);} check_4: if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_5; { { _v = lua_isnumber(L,argv[1]); } } if (!_v) goto check_5; + return _wrap_new_vec4__SWIG_8(L);} check_5: if (argc == 2) { return _wrap_new_vec4__SWIG_9(L);} if (argc == 3) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_7; { { _v = lua_isnumber(L,argv[1]); } } if (!_v) goto check_7; + { { _v = lua_isnumber(L,argv[2]); } } if (!_v) goto check_7; return _wrap_new_vec4__SWIG_5(L);} check_7: if (argc == 3) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_8; { { _v = lua_isnumber(L,argv[2]); } } if (!_v) goto check_8; + return _wrap_new_vec4__SWIG_6(L);} check_8: if (argc == 3) { return _wrap_new_vec4__SWIG_7(L);} if (argc == 4) { + return _wrap_new_vec4__SWIG_3(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_vec4'\n" + " Possible C/C++ prototypes are:\n" " glm::vec4::vec4()\n" " glm::vec4::vec4(glm::vec4 const &)\n" + " glm::vec4::vec4(float)\n" " glm::vec4::vec4(float,float,float,float)\n" + " glm::vec4::vec4(glm::vec2 const &,glm::vec2 const &)\n" " glm::vec4::vec4(glm::vec2 const &,float,float)\n" + " glm::vec4::vec4(float,glm::vec2 const &,float)\n" " glm::vec4::vec4(float,float,glm::vec2 const &)\n" + " glm::vec4::vec4(glm::vec3 const &,float)\n" " glm::vec4::vec4(float,glm::vec3 const &)\n"); lua_error(L);return 0; } +static int _wrap_vec4___getitem(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = (glm::vec4 *) 0 ; int arg2 ; float result; + SWIG_check_num_args("glm::vec4::__getitem__",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::vec4::__getitem__",1,"glm::vec4 *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::vec4::__getitem__",2,"int"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ + SWIG_fail_ptr("vec4___getitem",1,SWIGTYPE_p_glm__vec4); } arg2 = (int)lua_tonumber(L, 2); try { + result = (float)glm_vec4___getitem__(arg1,arg2);} catch(std::out_of_range &_e) { + SWIG_exception(SWIG_IndexError, (&_e)->what()); } lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; + if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_vec4___setitem(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = (glm::vec4 *) 0 ; int arg2 ; float arg3 ; + SWIG_check_num_args("glm::vec4::__setitem__",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::vec4::__setitem__",1,"glm::vec4 *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::vec4::__setitem__",2,"int"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("glm::vec4::__setitem__",3,"float"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ + SWIG_fail_ptr("vec4___setitem",1,SWIGTYPE_p_glm__vec4); } arg2 = (int)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); + try { glm_vec4___setitem__(arg1,arg2,arg3);} catch(std::out_of_range &_e) { SWIG_exception(SWIG_IndexError, (&_e)->what()); } + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_vec4___tostring(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = (glm::vec4 *) 0 ; std::string result; + SWIG_check_num_args("glm::vec4::__tostring",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::vec4::__tostring",1,"glm::vec4 *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ + SWIG_fail_ptr("vec4___tostring",1,SWIGTYPE_p_glm__vec4); } result = glm_vec4___tostring(arg1); + lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_vec4___add__SWIG_0(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = (glm::vec4 *) 0 ; glm::vec4 *arg2 = 0 ; + glm::vec4 result; SWIG_check_num_args("glm::vec4::operator +",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::vec4::operator +",1,"glm::vec4 *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::vec4::operator +",2,"glm::vec4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ + SWIG_fail_ptr("vec4___add",1,SWIGTYPE_p_glm__vec4); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec4,0))){ + SWIG_fail_ptr("vec4___add",2,SWIGTYPE_p_glm__vec4); } + result = glm_vec4_operator_Sa___SWIG_0(arg1,(glm::vec4 const &)*arg2); { + glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_vec4___add__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = (glm::vec4 *) 0 ; float arg2 ; + glm::vec4 result; SWIG_check_num_args("glm::vec4::operator +",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::vec4::operator +",1,"glm::vec4 *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::vec4::operator +",2,"float"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ + SWIG_fail_ptr("vec4___add",1,SWIGTYPE_p_glm__vec4); } arg2 = (float)lua_tonumber(L, 2); + result = glm_vec4_operator_Sa___SWIG_1(arg1,arg2); { glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_vec4___add(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v = 0; + { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_vec4___add__SWIG_0(L);} check_1: + if (argc == 2) { return _wrap_vec4___add__SWIG_1(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'vec4___add'\n" " Possible C/C++ prototypes are:\n" + " glm::vec4::operator +(glm::vec4 const &)\n" " glm::vec4::operator +(float)\n"); lua_error(L);return 0; } +static int _wrap_vec4___sub__SWIG_0(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = (glm::vec4 *) 0 ; glm::vec4 *arg2 = 0 ; + glm::vec4 result; SWIG_check_num_args("glm::vec4::operator -",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::vec4::operator -",1,"glm::vec4 *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::vec4::operator -",2,"glm::vec4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ + SWIG_fail_ptr("vec4___sub",1,SWIGTYPE_p_glm__vec4); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec4,0))){ + SWIG_fail_ptr("vec4___sub",2,SWIGTYPE_p_glm__vec4); } + result = glm_vec4_operator_Ss___SWIG_0(arg1,(glm::vec4 const &)*arg2); { + glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_vec4___sub__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = (glm::vec4 *) 0 ; float arg2 ; + glm::vec4 result; SWIG_check_num_args("glm::vec4::operator -",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::vec4::operator -",1,"glm::vec4 *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::vec4::operator -",2,"float"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ + SWIG_fail_ptr("vec4___sub",1,SWIGTYPE_p_glm__vec4); } arg2 = (float)lua_tonumber(L, 2); + result = glm_vec4_operator_Ss___SWIG_1(arg1,arg2); { glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_vec4___sub(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v = 0; + { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_vec4___sub__SWIG_0(L);} check_1: + if (argc == 2) { return _wrap_vec4___sub__SWIG_1(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'vec4___sub'\n" " Possible C/C++ prototypes are:\n" + " glm::vec4::operator -(glm::vec4 const &)\n" " glm::vec4::operator -(float)\n"); lua_error(L);return 0; } +static int _wrap_vec4___mul__SWIG_0(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = (glm::vec4 *) 0 ; glm::vec4 *arg2 = 0 ; + glm::vec4 result; SWIG_check_num_args("glm::vec4::operator *",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::vec4::operator *",1,"glm::vec4 *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::vec4::operator *",2,"glm::vec4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ + SWIG_fail_ptr("vec4___mul",1,SWIGTYPE_p_glm__vec4); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec4,0))){ + SWIG_fail_ptr("vec4___mul",2,SWIGTYPE_p_glm__vec4); } + result = glm_vec4_operator_Sm___SWIG_0(arg1,(glm::vec4 const &)*arg2); { + glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_vec4___mul__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = (glm::vec4 *) 0 ; float arg2 ; + glm::vec4 result; SWIG_check_num_args("glm::vec4::operator *",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::vec4::operator *",1,"glm::vec4 *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::vec4::operator *",2,"float"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ + SWIG_fail_ptr("vec4___mul",1,SWIGTYPE_p_glm__vec4); } arg2 = (float)lua_tonumber(L, 2); + result = glm_vec4_operator_Sm___SWIG_1(arg1,arg2); { glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_vec4___mul(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v = 0; + { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_vec4___mul__SWIG_0(L);} check_1: + if (argc == 2) { return _wrap_vec4___mul__SWIG_1(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'vec4___mul'\n" " Possible C/C++ prototypes are:\n" + " glm::vec4::operator *(glm::vec4 const &)\n" " glm::vec4::operator *(float)\n"); lua_error(L);return 0; } +static int _wrap_vec4___div__SWIG_0(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = (glm::vec4 *) 0 ; glm::vec4 *arg2 = 0 ; + glm::vec4 result; SWIG_check_num_args("glm::vec4::operator /",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::vec4::operator /",1,"glm::vec4 *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::vec4::operator /",2,"glm::vec4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ + SWIG_fail_ptr("vec4___div",1,SWIGTYPE_p_glm__vec4); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec4,0))){ + SWIG_fail_ptr("vec4___div",2,SWIGTYPE_p_glm__vec4); } + result = glm_vec4_operator_Sd___SWIG_0(arg1,(glm::vec4 const &)*arg2); { + glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_vec4___div__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = (glm::vec4 *) 0 ; float arg2 ; + glm::vec4 result; SWIG_check_num_args("glm::vec4::operator /",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::vec4::operator /",1,"glm::vec4 *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::vec4::operator /",2,"float"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ + SWIG_fail_ptr("vec4___div",1,SWIGTYPE_p_glm__vec4); } arg2 = (float)lua_tonumber(L, 2); + result = glm_vec4_operator_Sd___SWIG_1(arg1,arg2); { glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_vec4___div(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v = 0; + { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_vec4___div__SWIG_0(L);} check_1: + if (argc == 2) { return _wrap_vec4___div__SWIG_1(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'vec4___div'\n" " Possible C/C++ prototypes are:\n" + " glm::vec4::operator /(glm::vec4 const &)\n" " glm::vec4::operator /(float)\n"); lua_error(L);return 0; } +static int _wrap_vec4___eq(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = (glm::vec4 *) 0 ; glm::vec4 *arg2 = 0 ; + bool result; SWIG_check_num_args("glm::vec4::operator ==",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::vec4::operator ==",1,"glm::vec4 *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::vec4::operator ==",2,"glm::vec4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ + SWIG_fail_ptr("vec4___eq",1,SWIGTYPE_p_glm__vec4); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec4,0))){ + SWIG_fail_ptr("vec4___eq",2,SWIGTYPE_p_glm__vec4); } + result = (bool)glm_vec4_operator_Se__Se_(arg1,(glm::vec4 const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static void swig_delete_vec4(void *obj) { +glm::vec4 *arg1 = (glm::vec4 *) obj; +delete arg1; +} +static int _proxy__wrap_new_vec4(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_vec4); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_vec4_attributes[] = { + { "x", _wrap_vec4_x_get, _wrap_vec4_x_set }, + { "y", _wrap_vec4_y_get, _wrap_vec4_y_set }, + { "z", _wrap_vec4_z_get, _wrap_vec4_z_set }, + { "w", _wrap_vec4_w_get, _wrap_vec4_w_set }, + {0,0,0} +}; +static swig_lua_method swig_vec4_methods[]= { + { "__getitem", _wrap_vec4___getitem}, + { "__setitem", _wrap_vec4___setitem}, + { "__tostring", _wrap_vec4___tostring}, + { "__add", _wrap_vec4___add}, + { "__sub", _wrap_vec4___sub}, + { "__mul", _wrap_vec4___mul}, + { "__div", _wrap_vec4___div}, + { "__eq", _wrap_vec4___eq}, + {0,0} +}; +static swig_lua_method swig_vec4_meta[] = { + { "__getitem", _wrap_vec4___getitem}, + { "__setitem", _wrap_vec4___setitem}, + { "__tostring", _wrap_vec4___tostring}, + { "__add", _wrap_vec4___add}, + { "__sub", _wrap_vec4___sub}, + { "__mul", _wrap_vec4___mul}, + { "__div", _wrap_vec4___div}, + { "__eq", _wrap_vec4___eq}, + {0,0} +}; + +static swig_lua_attribute swig_vec4_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_vec4_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_vec4_Sf_SwigStatic_methods[]= { + { "length", _wrap_vec4_length}, + {0,0} +}; +static swig_lua_class* swig_vec4_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_vec4_Sf_SwigStatic = { + "vec4", + swig_vec4_Sf_SwigStatic_methods, + swig_vec4_Sf_SwigStatic_attributes, + swig_vec4_Sf_SwigStatic_constants, + swig_vec4_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_vec4_bases[] = {0}; +static const char *swig_vec4_base_names[] = {0}; +static swig_lua_class _wrap_class_vec4 = { "vec4", "vec4", &SWIGTYPE_p_glm__vec4,_proxy__wrap_new_vec4, swig_delete_vec4, swig_vec4_methods, swig_vec4_attributes, &swig_vec4_Sf_SwigStatic, swig_vec4_meta, swig_vec4_bases, swig_vec4_base_names }; + +static int _wrap_add__SWIG_6(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = 0 ; float arg2 ; glm::vec4 result; + SWIG_check_num_args("glm::operator +",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::operator +",1,"glm::vec4 const &"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::operator +",2,"float"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("add",1,SWIGTYPE_p_glm__vec4); } + arg2 = (float)lua_tonumber(L, 2); result = glm::operator +((glm::vec4 const &)*arg1,arg2); { + glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_add__SWIG_7(lua_State* L) { int SWIG_arg = 0; float arg1 ; glm::vec4 *arg2 = 0 ; glm::vec4 result; + SWIG_check_num_args("glm::operator +",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::operator +",1,"float"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::operator +",2,"glm::vec4 const &"); arg1 = (float)lua_tonumber(L, 1); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("add",2,SWIGTYPE_p_glm__vec4); } + result = glm::operator +(arg1,(glm::vec4 const &)*arg2); { glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_add__SWIG_8(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = 0 ; glm::vec4 *arg2 = 0 ; glm::vec4 result; + SWIG_check_num_args("glm::operator +",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::operator +",1,"glm::vec4 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::operator +",2,"glm::vec4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("add",1,SWIGTYPE_p_glm__vec4); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("add",2,SWIGTYPE_p_glm__vec4); } + result = glm::operator +((glm::vec4 const &)*arg1,(glm::vec4 const &)*arg2); { + glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_sub__SWIG_6(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = 0 ; float arg2 ; glm::vec4 result; + SWIG_check_num_args("glm::operator -",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::operator -",1,"glm::vec4 const &"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::operator -",2,"float"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("sub",1,SWIGTYPE_p_glm__vec4); } + arg2 = (float)lua_tonumber(L, 2); result = glm::operator -((glm::vec4 const &)*arg1,arg2); { + glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_sub__SWIG_7(lua_State* L) { int SWIG_arg = 0; float arg1 ; glm::vec4 *arg2 = 0 ; glm::vec4 result; + SWIG_check_num_args("glm::operator -",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::operator -",1,"float"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::operator -",2,"glm::vec4 const &"); arg1 = (float)lua_tonumber(L, 1); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("sub",2,SWIGTYPE_p_glm__vec4); } + result = glm::operator -(arg1,(glm::vec4 const &)*arg2); { glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_sub__SWIG_8(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = 0 ; glm::vec4 *arg2 = 0 ; glm::vec4 result; + SWIG_check_num_args("glm::operator -",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::operator -",1,"glm::vec4 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::operator -",2,"glm::vec4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("sub",1,SWIGTYPE_p_glm__vec4); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("sub",2,SWIGTYPE_p_glm__vec4); } + result = glm::operator -((glm::vec4 const &)*arg1,(glm::vec4 const &)*arg2); { + glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_mul__SWIG_6(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = 0 ; float arg2 ; glm::vec4 result; + SWIG_check_num_args("glm::operator *",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::operator *",1,"glm::vec4 const &"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::operator *",2,"float"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("mul",1,SWIGTYPE_p_glm__vec4); } + arg2 = (float)lua_tonumber(L, 2); result = glm::operator *((glm::vec4 const &)*arg1,arg2); { + glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_mul__SWIG_7(lua_State* L) { int SWIG_arg = 0; float arg1 ; glm::vec4 *arg2 = 0 ; glm::vec4 result; + SWIG_check_num_args("glm::operator *",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::operator *",1,"float"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::operator *",2,"glm::vec4 const &"); arg1 = (float)lua_tonumber(L, 1); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("mul",2,SWIGTYPE_p_glm__vec4); } + result = glm::operator *(arg1,(glm::vec4 const &)*arg2); { glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_mul__SWIG_8(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = 0 ; glm::vec4 *arg2 = 0 ; glm::vec4 result; + SWIG_check_num_args("glm::operator *",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::operator *",1,"glm::vec4 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::operator *",2,"glm::vec4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("mul",1,SWIGTYPE_p_glm__vec4); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("mul",2,SWIGTYPE_p_glm__vec4); } + result = glm::operator *((glm::vec4 const &)*arg1,(glm::vec4 const &)*arg2); { + glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_div__SWIG_6(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = 0 ; float arg2 ; glm::vec4 result; + SWIG_check_num_args("glm::operator /",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::operator /",1,"glm::vec4 const &"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::operator /",2,"float"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("div",1,SWIGTYPE_p_glm__vec4); } + arg2 = (float)lua_tonumber(L, 2); result = glm::operator /((glm::vec4 const &)*arg1,arg2); { + glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_div__SWIG_7(lua_State* L) { int SWIG_arg = 0; float arg1 ; glm::vec4 *arg2 = 0 ; glm::vec4 result; + SWIG_check_num_args("glm::operator /",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::operator /",1,"float"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::operator /",2,"glm::vec4 const &"); arg1 = (float)lua_tonumber(L, 1); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("div",2,SWIGTYPE_p_glm__vec4); } + result = glm::operator /(arg1,(glm::vec4 const &)*arg2); { glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_div__SWIG_8(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = 0 ; glm::vec4 *arg2 = 0 ; glm::vec4 result; + SWIG_check_num_args("glm::operator /",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::operator /",1,"glm::vec4 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::operator /",2,"glm::vec4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("div",1,SWIGTYPE_p_glm__vec4); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("div",2,SWIGTYPE_p_glm__vec4); } + result = glm::operator /((glm::vec4 const &)*arg1,(glm::vec4 const &)*arg2); { + glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_eq__SWIG_2(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = 0 ; glm::vec4 *arg2 = 0 ; bool result; + SWIG_check_num_args("glm::operator ==",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::operator ==",1,"glm::vec4 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::operator ==",2,"glm::vec4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("eq",1,SWIGTYPE_p_glm__vec4); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("eq",2,SWIGTYPE_p_glm__vec4); } + result = (bool)glm::operator ==((glm::vec4 const &)*arg1,(glm::vec4 const &)*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_mat3_length(lua_State* L) { int SWIG_arg = 0; glm::length_t result; + SWIG_check_num_args("glm::mat3::length",0,0) result = (glm::length_t)glm::mat3::length(); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_new_mat3__SWIG_0(lua_State* L) { int SWIG_arg = 0; glm::mat3 *result = 0 ; + SWIG_check_num_args("glm::mat3::mat3",0,0) result = (glm::mat3 *)new glm::mat3(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_glm__mat3,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_new_mat3__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::mat3 *arg1 = 0 ; glm::mat3 *result = 0 ; + SWIG_check_num_args("glm::mat3::mat3",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::mat3::mat3",1,"glm::mat3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__mat3,0))){ SWIG_fail_ptr("new_mat3",1,SWIGTYPE_p_glm__mat3); } + result = (glm::mat3 *)new glm::mat3((glm::mat3 const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_glm__mat3,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_new_mat3__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; glm::mat3 *result = 0 ; + SWIG_check_num_args("glm::mat3::mat3",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::mat3::mat3",1,"float"); + arg1 = (float)lua_tonumber(L, 1); result = (glm::mat3 *)new glm::mat3(arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_glm__mat3,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_new_mat3__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; + float arg5 ; float arg6 ; float arg7 ; float arg8 ; float arg9 ; glm::mat3 *result = 0 ; + SWIG_check_num_args("glm::mat3::mat3",9,9) if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::mat3::mat3",1,"float"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::mat3::mat3",2,"float"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("glm::mat3::mat3",3,"float"); + if(!lua_isnumber(L,4)) SWIG_fail_arg("glm::mat3::mat3",4,"float"); + if(!lua_isnumber(L,5)) SWIG_fail_arg("glm::mat3::mat3",5,"float"); + if(!lua_isnumber(L,6)) SWIG_fail_arg("glm::mat3::mat3",6,"float"); + if(!lua_isnumber(L,7)) SWIG_fail_arg("glm::mat3::mat3",7,"float"); + if(!lua_isnumber(L,8)) SWIG_fail_arg("glm::mat3::mat3",8,"float"); + if(!lua_isnumber(L,9)) SWIG_fail_arg("glm::mat3::mat3",9,"float"); arg1 = (float)lua_tonumber(L, 1); + arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); + arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); + arg8 = (float)lua_tonumber(L, 8); arg9 = (float)lua_tonumber(L, 9); + result = (glm::mat3 *)new glm::mat3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_glm__mat3,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_new_mat3__SWIG_4(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; glm::vec3 *arg2 = 0 ; + glm::vec3 *arg3 = 0 ; glm::mat3 *result = 0 ; SWIG_check_num_args("glm::mat3::mat3",3,3) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::mat3::mat3",1,"glm::vec3 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::mat3::mat3",2,"glm::vec3 const &"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("glm::mat3::mat3",3,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("new_mat3",1,SWIGTYPE_p_glm__vec3); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ + SWIG_fail_ptr("new_mat3",2,SWIGTYPE_p_glm__vec3); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("new_mat3",3,SWIGTYPE_p_glm__vec3); } + result = (glm::mat3 *)new glm::mat3((glm::vec3 const &)*arg1,(glm::vec3 const &)*arg2,(glm::vec3 const &)*arg3); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_glm__mat3,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_new_mat3__SWIG_5(lua_State* L) { int SWIG_arg = 0; glm::mat4 *arg1 = 0 ; glm::mat3 *result = 0 ; + SWIG_check_num_args("glm::mat3::mat3",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::mat3::mat3",1,"glm::mat4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__mat4,0))){ SWIG_fail_ptr("new_mat3",1,SWIGTYPE_p_glm__mat4); } + result = (glm::mat3 *)new glm::mat3((glm::mat4 const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_glm__mat3,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_new_mat3(lua_State* L) { int argc; int argv[10]={ 1,2,3,4,5,6,7,8,9,10} ; argc = lua_gettop(L); + if (argc == 0) { return _wrap_new_mat3__SWIG_0(L);} if (argc == 1) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__mat3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_new_mat3__SWIG_1(L);} check_2: if (argc == 1) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__mat4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; return _wrap_new_mat3__SWIG_5(L);} check_3: if (argc == 1) { + return _wrap_new_mat3__SWIG_2(L);} if (argc == 3) { return _wrap_new_mat3__SWIG_4(L);} if (argc == 9) { + return _wrap_new_mat3__SWIG_3(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_mat3'\n" + " Possible C/C++ prototypes are:\n" " glm::mat3::mat3()\n" " glm::mat3::mat3(glm::mat3 const &)\n" + " glm::mat3::mat3(float)\n" " glm::mat3::mat3(float,float,float,float,float,float,float,float,float)\n" + " glm::mat3::mat3(glm::vec3 const &,glm::vec3 const &,glm::vec3 const &)\n" " glm::mat3::mat3(glm::mat4 const &)\n"); + lua_error(L);return 0; } +static int _wrap_mat3___getitem(lua_State* L) { int SWIG_arg = 0; glm::mat3 *arg1 = (glm::mat3 *) 0 ; int arg2 ; + glm::vec3 result; SWIG_check_num_args("glm::mat3::__getitem__",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::mat3::__getitem__",1,"glm::mat3 *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::mat3::__getitem__",2,"int"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__mat3,0))){ + SWIG_fail_ptr("mat3___getitem",1,SWIGTYPE_p_glm__mat3); } arg2 = (int)lua_tonumber(L, 2); try { + result = glm_mat3___getitem__(arg1,arg2);} catch(std::out_of_range &_e) { SWIG_exception(SWIG_IndexError, (&_e)->what()); } + { glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_mat3___setitem(lua_State* L) { int SWIG_arg = 0; glm::mat3 *arg1 = (glm::mat3 *) 0 ; int arg2 ; + glm::vec3 arg3 ; glm::vec3 *argp3 ; SWIG_check_num_args("glm::mat3::__setitem__",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::mat3::__setitem__",1,"glm::mat3 *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::mat3::__setitem__",2,"int"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("glm::mat3::__setitem__",3,"glm::vec3"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__mat3,0))){ + SWIG_fail_ptr("mat3___setitem",1,SWIGTYPE_p_glm__mat3); } arg2 = (int)lua_tonumber(L, 2); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&argp3,SWIGTYPE_p_glm__vec3,0))){ + SWIG_fail_ptr("mat3___setitem",3,SWIGTYPE_p_glm__vec3); } arg3 = *argp3; try { glm_mat3___setitem__(arg1,arg2,arg3);} + catch(std::out_of_range &_e) { SWIG_exception(SWIG_IndexError, (&_e)->what()); } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_mat3___tostring(lua_State* L) { int SWIG_arg = 0; glm::mat3 *arg1 = (glm::mat3 *) 0 ; std::string result; + SWIG_check_num_args("glm::mat3::__tostring",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::mat3::__tostring",1,"glm::mat3 *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__mat3,0))){ + SWIG_fail_ptr("mat3___tostring",1,SWIGTYPE_p_glm__mat3); } result = glm_mat3___tostring(arg1); + lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_mat3___add__SWIG_0(lua_State* L) { int SWIG_arg = 0; glm::mat3 *arg1 = (glm::mat3 *) 0 ; float arg2 ; + glm::mat3 result; SWIG_check_num_args("glm::mat3::operator +",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::mat3::operator +",1,"glm::mat3 *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::mat3::operator +",2,"float"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__mat3,0))){ + SWIG_fail_ptr("mat3___add",1,SWIGTYPE_p_glm__mat3); } arg2 = (float)lua_tonumber(L, 2); + result = glm_mat3_operator_Sa___SWIG_0(arg1,arg2); { glm::mat3 * resultptr = new glm::mat3((const glm::mat3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__mat3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_mat3___add__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::mat3 *arg1 = (glm::mat3 *) 0 ; glm::mat3 *arg2 = 0 ; + glm::mat3 result; SWIG_check_num_args("glm::mat3::operator +",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::mat3::operator +",1,"glm::mat3 *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::mat3::operator +",2,"glm::mat3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__mat3,0))){ + SWIG_fail_ptr("mat3___add",1,SWIGTYPE_p_glm__mat3); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__mat3,0))){ + SWIG_fail_ptr("mat3___add",2,SWIGTYPE_p_glm__mat3); } + result = glm_mat3_operator_Sa___SWIG_1(arg1,(glm::mat3 const &)*arg2); { + glm::mat3 * resultptr = new glm::mat3((const glm::mat3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__mat3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_mat3___add(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v = 0; + { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__mat3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_mat3___add__SWIG_1(L);} check_1: + if (argc == 2) { return _wrap_mat3___add__SWIG_0(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'mat3___add'\n" " Possible C/C++ prototypes are:\n" + " glm::mat3::operator +(float)\n" " glm::mat3::operator +(glm::mat3 const &)\n"); lua_error(L);return 0; } +static int _wrap_mat3___sub__SWIG_0(lua_State* L) { int SWIG_arg = 0; glm::mat3 *arg1 = (glm::mat3 *) 0 ; float arg2 ; + glm::mat3 result; SWIG_check_num_args("glm::mat3::operator -",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::mat3::operator -",1,"glm::mat3 *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::mat3::operator -",2,"float"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__mat3,0))){ + SWIG_fail_ptr("mat3___sub",1,SWIGTYPE_p_glm__mat3); } arg2 = (float)lua_tonumber(L, 2); + result = glm_mat3_operator_Ss___SWIG_0(arg1,arg2); { glm::mat3 * resultptr = new glm::mat3((const glm::mat3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__mat3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_mat3___sub__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::mat3 *arg1 = (glm::mat3 *) 0 ; glm::mat3 *arg2 = 0 ; + glm::mat3 result; SWIG_check_num_args("glm::mat3::operator -",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::mat3::operator -",1,"glm::mat3 *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::mat3::operator -",2,"glm::mat3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__mat3,0))){ + SWIG_fail_ptr("mat3___sub",1,SWIGTYPE_p_glm__mat3); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__mat3,0))){ + SWIG_fail_ptr("mat3___sub",2,SWIGTYPE_p_glm__mat3); } + result = glm_mat3_operator_Ss___SWIG_1(arg1,(glm::mat3 const &)*arg2); { + glm::mat3 * resultptr = new glm::mat3((const glm::mat3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__mat3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_mat3___sub(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v = 0; + { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__mat3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_mat3___sub__SWIG_1(L);} check_1: + if (argc == 2) { return _wrap_mat3___sub__SWIG_0(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'mat3___sub'\n" " Possible C/C++ prototypes are:\n" + " glm::mat3::operator -(float)\n" " glm::mat3::operator -(glm::mat3 const &)\n"); lua_error(L);return 0; } +static int _wrap_mat3___mul__SWIG_0(lua_State* L) { int SWIG_arg = 0; glm::mat3 *arg1 = (glm::mat3 *) 0 ; float arg2 ; + glm::mat3 result; SWIG_check_num_args("glm::mat3::operator *",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::mat3::operator *",1,"glm::mat3 *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::mat3::operator *",2,"float"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__mat3,0))){ + SWIG_fail_ptr("mat3___mul",1,SWIGTYPE_p_glm__mat3); } arg2 = (float)lua_tonumber(L, 2); + result = glm_mat3_operator_Sm___SWIG_0(arg1,arg2); { glm::mat3 * resultptr = new glm::mat3((const glm::mat3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__mat3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_mat3___mul__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::mat3 *arg1 = (glm::mat3 *) 0 ; glm::mat3 *arg2 = 0 ; + glm::mat3 result; SWIG_check_num_args("glm::mat3::operator *",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::mat3::operator *",1,"glm::mat3 *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::mat3::operator *",2,"glm::mat3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__mat3,0))){ + SWIG_fail_ptr("mat3___mul",1,SWIGTYPE_p_glm__mat3); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__mat3,0))){ + SWIG_fail_ptr("mat3___mul",2,SWIGTYPE_p_glm__mat3); } + result = glm_mat3_operator_Sm___SWIG_1(arg1,(glm::mat3 const &)*arg2); { + glm::mat3 * resultptr = new glm::mat3((const glm::mat3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__mat3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_mat3___mul__SWIG_2(lua_State* L) { int SWIG_arg = 0; glm::mat3 *arg1 = (glm::mat3 *) 0 ; glm::vec3 *arg2 = 0 ; + glm::vec3 result; SWIG_check_num_args("glm::mat3::operator *",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::mat3::operator *",1,"glm::mat3 *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::mat3::operator *",2,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__mat3,0))){ + SWIG_fail_ptr("mat3___mul",1,SWIGTYPE_p_glm__mat3); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ + SWIG_fail_ptr("mat3___mul",2,SWIGTYPE_p_glm__vec3); } + result = glm_mat3_operator_Sm___SWIG_2(arg1,(glm::vec3 const &)*arg2); { + glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_mat3___mul(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v = 0; + { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__mat3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_mat3___mul__SWIG_1(L);} check_1: + if (argc == 2) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_mat3___mul__SWIG_2(L);} check_2: + if (argc == 2) { return _wrap_mat3___mul__SWIG_0(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'mat3___mul'\n" " Possible C/C++ prototypes are:\n" + " glm::mat3::operator *(float)\n" " glm::mat3::operator *(glm::mat3 const &)\n" + " glm::mat3::operator *(glm::vec3 const &)\n"); lua_error(L);return 0; } +static int _wrap_mat3___div__SWIG_0(lua_State* L) { int SWIG_arg = 0; glm::mat3 *arg1 = (glm::mat3 *) 0 ; float arg2 ; + glm::mat3 result; SWIG_check_num_args("glm::mat3::operator /",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::mat3::operator /",1,"glm::mat3 *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::mat3::operator /",2,"float"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__mat3,0))){ + SWIG_fail_ptr("mat3___div",1,SWIGTYPE_p_glm__mat3); } arg2 = (float)lua_tonumber(L, 2); + result = glm_mat3_operator_Sd___SWIG_0(arg1,arg2); { glm::mat3 * resultptr = new glm::mat3((const glm::mat3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__mat3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_mat3___div__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::mat3 *arg1 = (glm::mat3 *) 0 ; glm::mat3 *arg2 = 0 ; + glm::mat3 result; SWIG_check_num_args("glm::mat3::operator /",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::mat3::operator /",1,"glm::mat3 *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::mat3::operator /",2,"glm::mat3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__mat3,0))){ + SWIG_fail_ptr("mat3___div",1,SWIGTYPE_p_glm__mat3); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__mat3,0))){ + SWIG_fail_ptr("mat3___div",2,SWIGTYPE_p_glm__mat3); } + result = glm_mat3_operator_Sd___SWIG_1(arg1,(glm::mat3 const &)*arg2); { + glm::mat3 * resultptr = new glm::mat3((const glm::mat3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__mat3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_mat3___div__SWIG_2(lua_State* L) { int SWIG_arg = 0; glm::mat3 *arg1 = (glm::mat3 *) 0 ; glm::vec3 *arg2 = 0 ; + glm::vec3 result; SWIG_check_num_args("glm::mat3::operator /",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::mat3::operator /",1,"glm::mat3 *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::mat3::operator /",2,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__mat3,0))){ + SWIG_fail_ptr("mat3___div",1,SWIGTYPE_p_glm__mat3); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ + SWIG_fail_ptr("mat3___div",2,SWIGTYPE_p_glm__vec3); } + result = glm_mat3_operator_Sd___SWIG_2(arg1,(glm::vec3 const &)*arg2); { + glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_mat3___div(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v = 0; + { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__mat3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_mat3___div__SWIG_1(L);} check_1: + if (argc == 2) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_mat3___div__SWIG_2(L);} check_2: + if (argc == 2) { return _wrap_mat3___div__SWIG_0(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'mat3___div'\n" " Possible C/C++ prototypes are:\n" + " glm::mat3::operator /(float)\n" " glm::mat3::operator /(glm::mat3 const &)\n" + " glm::mat3::operator /(glm::vec3 const &)\n"); lua_error(L);return 0; } +static int _wrap_mat3___eq(lua_State* L) { int SWIG_arg = 0; glm::mat3 *arg1 = (glm::mat3 *) 0 ; glm::mat3 *arg2 = 0 ; + bool result; SWIG_check_num_args("glm::mat3::operator ==",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::mat3::operator ==",1,"glm::mat3 *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::mat3::operator ==",2,"glm::mat3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__mat3,0))){ + SWIG_fail_ptr("mat3___eq",1,SWIGTYPE_p_glm__mat3); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__mat3,0))){ + SWIG_fail_ptr("mat3___eq",2,SWIGTYPE_p_glm__mat3); } + result = (bool)glm_mat3_operator_Se__Se_(arg1,(glm::mat3 const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static void swig_delete_mat3(void *obj) { +glm::mat3 *arg1 = (glm::mat3 *) obj; +delete arg1; +} +static int _proxy__wrap_new_mat3(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_mat3); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_mat3_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_mat3_methods[]= { + { "__getitem", _wrap_mat3___getitem}, + { "__setitem", _wrap_mat3___setitem}, + { "__tostring", _wrap_mat3___tostring}, + { "__add", _wrap_mat3___add}, + { "__sub", _wrap_mat3___sub}, + { "__mul", _wrap_mat3___mul}, + { "__div", _wrap_mat3___div}, + { "__eq", _wrap_mat3___eq}, + {0,0} +}; +static swig_lua_method swig_mat3_meta[] = { + { "__getitem", _wrap_mat3___getitem}, + { "__setitem", _wrap_mat3___setitem}, + { "__tostring", _wrap_mat3___tostring}, + { "__add", _wrap_mat3___add}, + { "__sub", _wrap_mat3___sub}, + { "__mul", _wrap_mat3___mul}, + { "__div", _wrap_mat3___div}, + { "__eq", _wrap_mat3___eq}, + {0,0} +}; + +static swig_lua_attribute swig_mat3_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_mat3_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_mat3_Sf_SwigStatic_methods[]= { + { "length", _wrap_mat3_length}, + {0,0} +}; +static swig_lua_class* swig_mat3_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_mat3_Sf_SwigStatic = { + "mat3", + swig_mat3_Sf_SwigStatic_methods, + swig_mat3_Sf_SwigStatic_attributes, + swig_mat3_Sf_SwigStatic_constants, + swig_mat3_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_mat3_bases[] = {0}; +static const char *swig_mat3_base_names[] = {0}; +static swig_lua_class _wrap_class_mat3 = { "mat3", "mat3", &SWIGTYPE_p_glm__mat3,_proxy__wrap_new_mat3, swig_delete_mat3, swig_mat3_methods, swig_mat3_attributes, &swig_mat3_Sf_SwigStatic, swig_mat3_meta, swig_mat3_bases, swig_mat3_base_names }; + +static int _wrap_add__SWIG_9(lua_State* L) { int SWIG_arg = 0; glm::mat3 *arg1 = 0 ; float arg2 ; glm::mat3 result; + SWIG_check_num_args("glm::operator +",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::operator +",1,"glm::mat3 const &"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::operator +",2,"float"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__mat3,0))){ SWIG_fail_ptr("add",1,SWIGTYPE_p_glm__mat3); } + arg2 = (float)lua_tonumber(L, 2); result = glm::operator +((glm::mat3 const &)*arg1,arg2); { + glm::mat3 * resultptr = new glm::mat3((const glm::mat3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__mat3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_add__SWIG_10(lua_State* L) { int SWIG_arg = 0; float arg1 ; glm::mat3 *arg2 = 0 ; glm::mat3 result; + SWIG_check_num_args("glm::operator +",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::operator +",1,"float"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::operator +",2,"glm::mat3 const &"); arg1 = (float)lua_tonumber(L, 1); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__mat3,0))){ SWIG_fail_ptr("add",2,SWIGTYPE_p_glm__mat3); } + result = glm::operator +(arg1,(glm::mat3 const &)*arg2); { glm::mat3 * resultptr = new glm::mat3((const glm::mat3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__mat3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_add__SWIG_11(lua_State* L) { int SWIG_arg = 0; glm::mat3 *arg1 = 0 ; glm::mat3 *arg2 = 0 ; glm::mat3 result; + SWIG_check_num_args("glm::operator +",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::operator +",1,"glm::mat3 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::operator +",2,"glm::mat3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__mat3,0))){ SWIG_fail_ptr("add",1,SWIGTYPE_p_glm__mat3); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__mat3,0))){ SWIG_fail_ptr("add",2,SWIGTYPE_p_glm__mat3); } + result = glm::operator +((glm::mat3 const &)*arg1,(glm::mat3 const &)*arg2); { + glm::mat3 * resultptr = new glm::mat3((const glm::mat3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__mat3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_sub__SWIG_9(lua_State* L) { int SWIG_arg = 0; glm::mat3 *arg1 = 0 ; float arg2 ; glm::mat3 result; + SWIG_check_num_args("glm::operator -",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::operator -",1,"glm::mat3 const &"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::operator -",2,"float"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__mat3,0))){ SWIG_fail_ptr("sub",1,SWIGTYPE_p_glm__mat3); } + arg2 = (float)lua_tonumber(L, 2); result = glm::operator -((glm::mat3 const &)*arg1,arg2); { + glm::mat3 * resultptr = new glm::mat3((const glm::mat3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__mat3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_sub__SWIG_10(lua_State* L) { int SWIG_arg = 0; float arg1 ; glm::mat3 *arg2 = 0 ; glm::mat3 result; + SWIG_check_num_args("glm::operator -",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::operator -",1,"float"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::operator -",2,"glm::mat3 const &"); arg1 = (float)lua_tonumber(L, 1); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__mat3,0))){ SWIG_fail_ptr("sub",2,SWIGTYPE_p_glm__mat3); } + result = glm::operator -(arg1,(glm::mat3 const &)*arg2); { glm::mat3 * resultptr = new glm::mat3((const glm::mat3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__mat3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_sub__SWIG_11(lua_State* L) { int SWIG_arg = 0; glm::mat3 *arg1 = 0 ; glm::mat3 *arg2 = 0 ; glm::mat3 result; + SWIG_check_num_args("glm::operator -",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::operator -",1,"glm::mat3 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::operator -",2,"glm::mat3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__mat3,0))){ SWIG_fail_ptr("sub",1,SWIGTYPE_p_glm__mat3); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__mat3,0))){ SWIG_fail_ptr("sub",2,SWIGTYPE_p_glm__mat3); } + result = glm::operator -((glm::mat3 const &)*arg1,(glm::mat3 const &)*arg2); { + glm::mat3 * resultptr = new glm::mat3((const glm::mat3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__mat3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_mul__SWIG_9(lua_State* L) { int SWIG_arg = 0; glm::mat3 *arg1 = 0 ; float arg2 ; glm::mat3 result; + SWIG_check_num_args("glm::operator *",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::operator *",1,"glm::mat3 const &"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::operator *",2,"float"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__mat3,0))){ SWIG_fail_ptr("mul",1,SWIGTYPE_p_glm__mat3); } + arg2 = (float)lua_tonumber(L, 2); result = glm::operator *((glm::mat3 const &)*arg1,arg2); { + glm::mat3 * resultptr = new glm::mat3((const glm::mat3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__mat3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_mul__SWIG_10(lua_State* L) { int SWIG_arg = 0; float arg1 ; glm::mat3 *arg2 = 0 ; glm::mat3 result; + SWIG_check_num_args("glm::operator *",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::operator *",1,"float"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::operator *",2,"glm::mat3 const &"); arg1 = (float)lua_tonumber(L, 1); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__mat3,0))){ SWIG_fail_ptr("mul",2,SWIGTYPE_p_glm__mat3); } + result = glm::operator *(arg1,(glm::mat3 const &)*arg2); { glm::mat3 * resultptr = new glm::mat3((const glm::mat3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__mat3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_mul__SWIG_11(lua_State* L) { int SWIG_arg = 0; glm::mat3 *arg1 = 0 ; glm::mat3 *arg2 = 0 ; glm::mat3 result; + SWIG_check_num_args("glm::operator *",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::operator *",1,"glm::mat3 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::operator *",2,"glm::mat3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__mat3,0))){ SWIG_fail_ptr("mul",1,SWIGTYPE_p_glm__mat3); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__mat3,0))){ SWIG_fail_ptr("mul",2,SWIGTYPE_p_glm__mat3); } + result = glm::operator *((glm::mat3 const &)*arg1,(glm::mat3 const &)*arg2); { + glm::mat3 * resultptr = new glm::mat3((const glm::mat3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__mat3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_mul__SWIG_12(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; glm::mat3 *arg2 = 0 ; glm::vec3 result; + SWIG_check_num_args("glm::operator *",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::operator *",1,"glm::vec3 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::operator *",2,"glm::mat3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("mul",1,SWIGTYPE_p_glm__vec3); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__mat3,0))){ SWIG_fail_ptr("mul",2,SWIGTYPE_p_glm__mat3); } + result = glm::operator *((glm::vec3 const &)*arg1,(glm::mat3 const &)*arg2); { + glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_mul__SWIG_13(lua_State* L) { int SWIG_arg = 0; glm::mat3 *arg1 = 0 ; glm::vec3 *arg2 = 0 ; glm::vec3 result; + SWIG_check_num_args("glm::operator *",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::operator *",1,"glm::mat3 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::operator *",2,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__mat3,0))){ SWIG_fail_ptr("mul",1,SWIGTYPE_p_glm__mat3); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("mul",2,SWIGTYPE_p_glm__vec3); } + result = glm::operator *((glm::mat3 const &)*arg1,(glm::vec3 const &)*arg2); { + glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_div__SWIG_9(lua_State* L) { int SWIG_arg = 0; glm::mat3 *arg1 = 0 ; float arg2 ; glm::mat3 result; + SWIG_check_num_args("glm::operator /",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::operator /",1,"glm::mat3 const &"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::operator /",2,"float"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__mat3,0))){ SWIG_fail_ptr("div",1,SWIGTYPE_p_glm__mat3); } + arg2 = (float)lua_tonumber(L, 2); result = glm::operator /((glm::mat3 const &)*arg1,arg2); { + glm::mat3 * resultptr = new glm::mat3((const glm::mat3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__mat3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_div__SWIG_10(lua_State* L) { int SWIG_arg = 0; float arg1 ; glm::mat3 *arg2 = 0 ; glm::mat3 result; + SWIG_check_num_args("glm::operator /",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::operator /",1,"float"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::operator /",2,"glm::mat3 const &"); arg1 = (float)lua_tonumber(L, 1); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__mat3,0))){ SWIG_fail_ptr("div",2,SWIGTYPE_p_glm__mat3); } + result = glm::operator /(arg1,(glm::mat3 const &)*arg2); { glm::mat3 * resultptr = new glm::mat3((const glm::mat3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__mat3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_div__SWIG_11(lua_State* L) { int SWIG_arg = 0; glm::mat3 *arg1 = 0 ; glm::mat3 *arg2 = 0 ; glm::mat3 result; + SWIG_check_num_args("glm::operator /",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::operator /",1,"glm::mat3 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::operator /",2,"glm::mat3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__mat3,0))){ SWIG_fail_ptr("div",1,SWIGTYPE_p_glm__mat3); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__mat3,0))){ SWIG_fail_ptr("div",2,SWIGTYPE_p_glm__mat3); } + result = glm::operator /((glm::mat3 const &)*arg1,(glm::mat3 const &)*arg2); { + glm::mat3 * resultptr = new glm::mat3((const glm::mat3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__mat3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_div__SWIG_12(lua_State* L) { int SWIG_arg = 0; glm::mat3 *arg1 = 0 ; glm::vec3 *arg2 = 0 ; glm::vec3 result; + SWIG_check_num_args("glm::operator /",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::operator /",1,"glm::mat3 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::operator /",2,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__mat3,0))){ SWIG_fail_ptr("div",1,SWIGTYPE_p_glm__mat3); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("div",2,SWIGTYPE_p_glm__vec3); } + result = glm::operator /((glm::mat3 const &)*arg1,(glm::vec3 const &)*arg2); { + glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_div__SWIG_13(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; glm::mat3 *arg2 = 0 ; glm::vec3 result; + SWIG_check_num_args("glm::operator /",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::operator /",1,"glm::vec3 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::operator /",2,"glm::mat3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("div",1,SWIGTYPE_p_glm__vec3); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__mat3,0))){ SWIG_fail_ptr("div",2,SWIGTYPE_p_glm__mat3); } + result = glm::operator /((glm::vec3 const &)*arg1,(glm::mat3 const &)*arg2); { + glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_eq__SWIG_3(lua_State* L) { int SWIG_arg = 0; glm::mat3 *arg1 = 0 ; glm::mat3 *arg2 = 0 ; bool result; + SWIG_check_num_args("glm::operator ==",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::operator ==",1,"glm::mat3 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::operator ==",2,"glm::mat3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__mat3,0))){ SWIG_fail_ptr("eq",1,SWIGTYPE_p_glm__mat3); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__mat3,0))){ SWIG_fail_ptr("eq",2,SWIGTYPE_p_glm__mat3); } + result = (bool)glm::operator ==((glm::mat3 const &)*arg1,(glm::mat3 const &)*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_mat4_length(lua_State* L) { int SWIG_arg = 0; glm::length_t result; + SWIG_check_num_args("glm::mat4::length",0,0) result = (glm::length_t)glm::mat4::length(); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_new_mat4__SWIG_0(lua_State* L) { int SWIG_arg = 0; glm::mat4 *result = 0 ; + SWIG_check_num_args("glm::mat4::mat4",0,0) result = (glm::mat4 *)new glm::mat4(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_glm__mat4,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_new_mat4__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::mat4 *arg1 = 0 ; glm::mat4 *result = 0 ; + SWIG_check_num_args("glm::mat4::mat4",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::mat4::mat4",1,"glm::mat4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__mat4,0))){ SWIG_fail_ptr("new_mat4",1,SWIGTYPE_p_glm__mat4); } + result = (glm::mat4 *)new glm::mat4((glm::mat4 const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_glm__mat4,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_new_mat4__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; glm::mat4 *result = 0 ; + SWIG_check_num_args("glm::mat4::mat4",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::mat4::mat4",1,"float"); + arg1 = (float)lua_tonumber(L, 1); result = (glm::mat4 *)new glm::mat4(arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_glm__mat4,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_new_mat4__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; + float arg5 ; float arg6 ; float arg7 ; float arg8 ; float arg9 ; float arg10 ; float arg11 ; float arg12 ; float arg13 ; + float arg14 ; float arg15 ; float arg16 ; glm::mat4 *result = 0 ; SWIG_check_num_args("glm::mat4::mat4",16,16) + if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::mat4::mat4",1,"float"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::mat4::mat4",2,"float"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("glm::mat4::mat4",3,"float"); + if(!lua_isnumber(L,4)) SWIG_fail_arg("glm::mat4::mat4",4,"float"); + if(!lua_isnumber(L,5)) SWIG_fail_arg("glm::mat4::mat4",5,"float"); + if(!lua_isnumber(L,6)) SWIG_fail_arg("glm::mat4::mat4",6,"float"); + if(!lua_isnumber(L,7)) SWIG_fail_arg("glm::mat4::mat4",7,"float"); + if(!lua_isnumber(L,8)) SWIG_fail_arg("glm::mat4::mat4",8,"float"); + if(!lua_isnumber(L,9)) SWIG_fail_arg("glm::mat4::mat4",9,"float"); + if(!lua_isnumber(L,10)) SWIG_fail_arg("glm::mat4::mat4",10,"float"); + if(!lua_isnumber(L,11)) SWIG_fail_arg("glm::mat4::mat4",11,"float"); + if(!lua_isnumber(L,12)) SWIG_fail_arg("glm::mat4::mat4",12,"float"); + if(!lua_isnumber(L,13)) SWIG_fail_arg("glm::mat4::mat4",13,"float"); + if(!lua_isnumber(L,14)) SWIG_fail_arg("glm::mat4::mat4",14,"float"); + if(!lua_isnumber(L,15)) SWIG_fail_arg("glm::mat4::mat4",15,"float"); + if(!lua_isnumber(L,16)) SWIG_fail_arg("glm::mat4::mat4",16,"float"); arg1 = (float)lua_tonumber(L, 1); + arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); + arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); + arg8 = (float)lua_tonumber(L, 8); arg9 = (float)lua_tonumber(L, 9); arg10 = (float)lua_tonumber(L, 10); + arg11 = (float)lua_tonumber(L, 11); arg12 = (float)lua_tonumber(L, 12); arg13 = (float)lua_tonumber(L, 13); + arg14 = (float)lua_tonumber(L, 14); arg15 = (float)lua_tonumber(L, 15); arg16 = (float)lua_tonumber(L, 16); + result = (glm::mat4 *)new glm::mat4(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_glm__mat4,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_new_mat4__SWIG_4(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = 0 ; glm::vec4 *arg2 = 0 ; + glm::vec4 *arg3 = 0 ; glm::vec4 *arg4 = 0 ; glm::mat4 *result = 0 ; SWIG_check_num_args("glm::mat4::mat4",4,4) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::mat4::mat4",1,"glm::vec4 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::mat4::mat4",2,"glm::vec4 const &"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("glm::mat4::mat4",3,"glm::vec4 const &"); + if(!lua_isuserdata(L,4)) SWIG_fail_arg("glm::mat4::mat4",4,"glm::vec4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("new_mat4",1,SWIGTYPE_p_glm__vec4); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec4,0))){ + SWIG_fail_ptr("new_mat4",2,SWIGTYPE_p_glm__vec4); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("new_mat4",3,SWIGTYPE_p_glm__vec4); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_glm__vec4,0))){ + SWIG_fail_ptr("new_mat4",4,SWIGTYPE_p_glm__vec4); } + result = (glm::mat4 *)new glm::mat4((glm::vec4 const &)*arg1,(glm::vec4 const &)*arg2,(glm::vec4 const &)*arg3,(glm::vec4 const &)*arg4); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_glm__mat4,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_new_mat4__SWIG_5(lua_State* L) { int SWIG_arg = 0; glm::mat3 *arg1 = 0 ; glm::mat4 *result = 0 ; + SWIG_check_num_args("glm::mat4::mat4",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::mat4::mat4",1,"glm::mat3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__mat3,0))){ SWIG_fail_ptr("new_mat4",1,SWIGTYPE_p_glm__mat3); } + result = (glm::mat4 *)new glm::mat4((glm::mat3 const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_glm__mat4,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_new_mat4(lua_State* L) { int argc; int argv[17]={ 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17} ; + argc = lua_gettop(L); if (argc == 0) { return _wrap_new_mat4__SWIG_0(L);} if (argc == 1) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__mat4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_new_mat4__SWIG_1(L);} check_2: if (argc == 1) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__mat3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; return _wrap_new_mat4__SWIG_5(L);} check_3: if (argc == 1) { + return _wrap_new_mat4__SWIG_2(L);} if (argc == 4) { return _wrap_new_mat4__SWIG_4(L);} if (argc == 16) { + return _wrap_new_mat4__SWIG_3(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_mat4'\n" + " Possible C/C++ prototypes are:\n" " glm::mat4::mat4()\n" " glm::mat4::mat4(glm::mat4 const &)\n" + " glm::mat4::mat4(float)\n" + " glm::mat4::mat4(float,float,float,float,float,float,float,float,float,float,float,float,float,float,float,float)\n" + " glm::mat4::mat4(glm::vec4 const &,glm::vec4 const &,glm::vec4 const &,glm::vec4 const &)\n" + " glm::mat4::mat4(glm::mat3 const &)\n"); lua_error(L);return 0; } +static int _wrap_mat4___getitem(lua_State* L) { int SWIG_arg = 0; glm::mat4 *arg1 = (glm::mat4 *) 0 ; int arg2 ; + glm::vec4 result; SWIG_check_num_args("glm::mat4::__getitem__",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::mat4::__getitem__",1,"glm::mat4 *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::mat4::__getitem__",2,"int"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__mat4,0))){ + SWIG_fail_ptr("mat4___getitem",1,SWIGTYPE_p_glm__mat4); } arg2 = (int)lua_tonumber(L, 2); try { + result = glm_mat4___getitem__(arg1,arg2);} catch(std::out_of_range &_e) { SWIG_exception(SWIG_IndexError, (&_e)->what()); } + { glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_mat4___setitem(lua_State* L) { int SWIG_arg = 0; glm::mat4 *arg1 = (glm::mat4 *) 0 ; int arg2 ; + glm::vec4 arg3 ; glm::vec4 *argp3 ; SWIG_check_num_args("glm::mat4::__setitem__",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::mat4::__setitem__",1,"glm::mat4 *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::mat4::__setitem__",2,"int"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("glm::mat4::__setitem__",3,"glm::vec4"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__mat4,0))){ + SWIG_fail_ptr("mat4___setitem",1,SWIGTYPE_p_glm__mat4); } arg2 = (int)lua_tonumber(L, 2); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&argp3,SWIGTYPE_p_glm__vec4,0))){ + SWIG_fail_ptr("mat4___setitem",3,SWIGTYPE_p_glm__vec4); } arg3 = *argp3; try { glm_mat4___setitem__(arg1,arg2,arg3);} + catch(std::out_of_range &_e) { SWIG_exception(SWIG_IndexError, (&_e)->what()); } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_mat4___tostring(lua_State* L) { int SWIG_arg = 0; glm::mat4 *arg1 = (glm::mat4 *) 0 ; std::string result; + SWIG_check_num_args("glm::mat4::__tostring",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::mat4::__tostring",1,"glm::mat4 *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__mat4,0))){ + SWIG_fail_ptr("mat4___tostring",1,SWIGTYPE_p_glm__mat4); } result = glm_mat4___tostring(arg1); + lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_mat4___add__SWIG_0(lua_State* L) { int SWIG_arg = 0; glm::mat4 *arg1 = (glm::mat4 *) 0 ; float arg2 ; + glm::mat4 result; SWIG_check_num_args("glm::mat4::operator +",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::mat4::operator +",1,"glm::mat4 *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::mat4::operator +",2,"float"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__mat4,0))){ + SWIG_fail_ptr("mat4___add",1,SWIGTYPE_p_glm__mat4); } arg2 = (float)lua_tonumber(L, 2); + result = glm_mat4_operator_Sa___SWIG_0(arg1,arg2); { glm::mat4 * resultptr = new glm::mat4((const glm::mat4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__mat4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_mat4___add__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::mat4 *arg1 = (glm::mat4 *) 0 ; glm::mat4 *arg2 = 0 ; + glm::mat4 result; SWIG_check_num_args("glm::mat4::operator +",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::mat4::operator +",1,"glm::mat4 *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::mat4::operator +",2,"glm::mat4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__mat4,0))){ + SWIG_fail_ptr("mat4___add",1,SWIGTYPE_p_glm__mat4); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__mat4,0))){ + SWIG_fail_ptr("mat4___add",2,SWIGTYPE_p_glm__mat4); } + result = glm_mat4_operator_Sa___SWIG_1(arg1,(glm::mat4 const &)*arg2); { + glm::mat4 * resultptr = new glm::mat4((const glm::mat4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__mat4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_mat4___add(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v = 0; + { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__mat4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_mat4___add__SWIG_1(L);} check_1: + if (argc == 2) { return _wrap_mat4___add__SWIG_0(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'mat4___add'\n" " Possible C/C++ prototypes are:\n" + " glm::mat4::operator +(float)\n" " glm::mat4::operator +(glm::mat4 const &)\n"); lua_error(L);return 0; } +static int _wrap_mat4___sub__SWIG_0(lua_State* L) { int SWIG_arg = 0; glm::mat4 *arg1 = (glm::mat4 *) 0 ; float arg2 ; + glm::mat4 result; SWIG_check_num_args("glm::mat4::operator -",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::mat4::operator -",1,"glm::mat4 *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::mat4::operator -",2,"float"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__mat4,0))){ + SWIG_fail_ptr("mat4___sub",1,SWIGTYPE_p_glm__mat4); } arg2 = (float)lua_tonumber(L, 2); + result = glm_mat4_operator_Ss___SWIG_0(arg1,arg2); { glm::mat4 * resultptr = new glm::mat4((const glm::mat4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__mat4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_mat4___sub__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::mat4 *arg1 = (glm::mat4 *) 0 ; glm::mat4 *arg2 = 0 ; + glm::mat4 result; SWIG_check_num_args("glm::mat4::operator -",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::mat4::operator -",1,"glm::mat4 *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::mat4::operator -",2,"glm::mat4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__mat4,0))){ + SWIG_fail_ptr("mat4___sub",1,SWIGTYPE_p_glm__mat4); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__mat4,0))){ + SWIG_fail_ptr("mat4___sub",2,SWIGTYPE_p_glm__mat4); } + result = glm_mat4_operator_Ss___SWIG_1(arg1,(glm::mat4 const &)*arg2); { + glm::mat4 * resultptr = new glm::mat4((const glm::mat4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__mat4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_mat4___sub(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v = 0; + { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__mat4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_mat4___sub__SWIG_1(L);} check_1: + if (argc == 2) { return _wrap_mat4___sub__SWIG_0(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'mat4___sub'\n" " Possible C/C++ prototypes are:\n" + " glm::mat4::operator -(float)\n" " glm::mat4::operator -(glm::mat4 const &)\n"); lua_error(L);return 0; } +static int _wrap_mat4___mul__SWIG_0(lua_State* L) { int SWIG_arg = 0; glm::mat4 *arg1 = (glm::mat4 *) 0 ; float arg2 ; + glm::mat4 result; SWIG_check_num_args("glm::mat4::operator *",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::mat4::operator *",1,"glm::mat4 *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::mat4::operator *",2,"float"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__mat4,0))){ + SWIG_fail_ptr("mat4___mul",1,SWIGTYPE_p_glm__mat4); } arg2 = (float)lua_tonumber(L, 2); + result = glm_mat4_operator_Sm___SWIG_0(arg1,arg2); { glm::mat4 * resultptr = new glm::mat4((const glm::mat4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__mat4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_mat4___mul__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::mat4 *arg1 = (glm::mat4 *) 0 ; glm::mat4 *arg2 = 0 ; + glm::mat4 result; SWIG_check_num_args("glm::mat4::operator *",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::mat4::operator *",1,"glm::mat4 *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::mat4::operator *",2,"glm::mat4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__mat4,0))){ + SWIG_fail_ptr("mat4___mul",1,SWIGTYPE_p_glm__mat4); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__mat4,0))){ + SWIG_fail_ptr("mat4___mul",2,SWIGTYPE_p_glm__mat4); } + result = glm_mat4_operator_Sm___SWIG_1(arg1,(glm::mat4 const &)*arg2); { + glm::mat4 * resultptr = new glm::mat4((const glm::mat4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__mat4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_mat4___mul__SWIG_2(lua_State* L) { int SWIG_arg = 0; glm::mat4 *arg1 = (glm::mat4 *) 0 ; glm::vec4 *arg2 = 0 ; + glm::vec4 result; SWIG_check_num_args("glm::mat4::operator *",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::mat4::operator *",1,"glm::mat4 *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::mat4::operator *",2,"glm::vec4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__mat4,0))){ + SWIG_fail_ptr("mat4___mul",1,SWIGTYPE_p_glm__mat4); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec4,0))){ + SWIG_fail_ptr("mat4___mul",2,SWIGTYPE_p_glm__vec4); } + result = glm_mat4_operator_Sm___SWIG_2(arg1,(glm::vec4 const &)*arg2); { + glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_mat4___mul(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v = 0; + { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__mat4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_mat4___mul__SWIG_1(L);} check_1: + if (argc == 2) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_mat4___mul__SWIG_2(L);} check_2: + if (argc == 2) { return _wrap_mat4___mul__SWIG_0(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'mat4___mul'\n" " Possible C/C++ prototypes are:\n" + " glm::mat4::operator *(float)\n" " glm::mat4::operator *(glm::mat4 const &)\n" + " glm::mat4::operator *(glm::vec4 const &)\n"); lua_error(L);return 0; } +static int _wrap_mat4___div__SWIG_0(lua_State* L) { int SWIG_arg = 0; glm::mat4 *arg1 = (glm::mat4 *) 0 ; float arg2 ; + glm::mat4 result; SWIG_check_num_args("glm::mat4::operator /",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::mat4::operator /",1,"glm::mat4 *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::mat4::operator /",2,"float"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__mat4,0))){ + SWIG_fail_ptr("mat4___div",1,SWIGTYPE_p_glm__mat4); } arg2 = (float)lua_tonumber(L, 2); + result = glm_mat4_operator_Sd___SWIG_0(arg1,arg2); { glm::mat4 * resultptr = new glm::mat4((const glm::mat4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__mat4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_mat4___div__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::mat4 *arg1 = (glm::mat4 *) 0 ; glm::mat4 *arg2 = 0 ; + glm::mat4 result; SWIG_check_num_args("glm::mat4::operator /",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::mat4::operator /",1,"glm::mat4 *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::mat4::operator /",2,"glm::mat4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__mat4,0))){ + SWIG_fail_ptr("mat4___div",1,SWIGTYPE_p_glm__mat4); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__mat4,0))){ + SWIG_fail_ptr("mat4___div",2,SWIGTYPE_p_glm__mat4); } + result = glm_mat4_operator_Sd___SWIG_1(arg1,(glm::mat4 const &)*arg2); { + glm::mat4 * resultptr = new glm::mat4((const glm::mat4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__mat4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_mat4___div__SWIG_2(lua_State* L) { int SWIG_arg = 0; glm::mat4 *arg1 = (glm::mat4 *) 0 ; glm::vec4 *arg2 = 0 ; + glm::vec4 result; SWIG_check_num_args("glm::mat4::operator /",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::mat4::operator /",1,"glm::mat4 *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::mat4::operator /",2,"glm::vec4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__mat4,0))){ + SWIG_fail_ptr("mat4___div",1,SWIGTYPE_p_glm__mat4); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec4,0))){ + SWIG_fail_ptr("mat4___div",2,SWIGTYPE_p_glm__vec4); } + result = glm_mat4_operator_Sd___SWIG_2(arg1,(glm::vec4 const &)*arg2); { + glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_mat4___div(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v = 0; + { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__mat4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_mat4___div__SWIG_1(L);} check_1: + if (argc == 2) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_mat4___div__SWIG_2(L);} check_2: + if (argc == 2) { return _wrap_mat4___div__SWIG_0(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'mat4___div'\n" " Possible C/C++ prototypes are:\n" + " glm::mat4::operator /(float)\n" " glm::mat4::operator /(glm::mat4 const &)\n" + " glm::mat4::operator /(glm::vec4 const &)\n"); lua_error(L);return 0; } +static int _wrap_mat4___eq(lua_State* L) { int SWIG_arg = 0; glm::mat4 *arg1 = (glm::mat4 *) 0 ; glm::mat4 *arg2 = 0 ; + bool result; SWIG_check_num_args("glm::mat4::operator ==",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::mat4::operator ==",1,"glm::mat4 *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::mat4::operator ==",2,"glm::mat4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__mat4,0))){ + SWIG_fail_ptr("mat4___eq",1,SWIGTYPE_p_glm__mat4); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__mat4,0))){ + SWIG_fail_ptr("mat4___eq",2,SWIGTYPE_p_glm__mat4); } + result = (bool)glm_mat4_operator_Se__Se_(arg1,(glm::mat4 const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static void swig_delete_mat4(void *obj) { +glm::mat4 *arg1 = (glm::mat4 *) obj; +delete arg1; +} +static int _proxy__wrap_new_mat4(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_mat4); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_mat4_attributes[] = { + {0,0,0} +}; +static swig_lua_method swig_mat4_methods[]= { + { "__getitem", _wrap_mat4___getitem}, + { "__setitem", _wrap_mat4___setitem}, + { "__tostring", _wrap_mat4___tostring}, + { "__add", _wrap_mat4___add}, + { "__sub", _wrap_mat4___sub}, + { "__mul", _wrap_mat4___mul}, + { "__div", _wrap_mat4___div}, + { "__eq", _wrap_mat4___eq}, + {0,0} +}; +static swig_lua_method swig_mat4_meta[] = { + { "__getitem", _wrap_mat4___getitem}, + { "__setitem", _wrap_mat4___setitem}, + { "__tostring", _wrap_mat4___tostring}, + { "__add", _wrap_mat4___add}, + { "__sub", _wrap_mat4___sub}, + { "__mul", _wrap_mat4___mul}, + { "__div", _wrap_mat4___div}, + { "__eq", _wrap_mat4___eq}, + {0,0} +}; + +static swig_lua_attribute swig_mat4_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_mat4_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_mat4_Sf_SwigStatic_methods[]= { + { "length", _wrap_mat4_length}, + {0,0} +}; +static swig_lua_class* swig_mat4_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_mat4_Sf_SwigStatic = { + "mat4", + swig_mat4_Sf_SwigStatic_methods, + swig_mat4_Sf_SwigStatic_attributes, + swig_mat4_Sf_SwigStatic_constants, + swig_mat4_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_mat4_bases[] = {0}; +static const char *swig_mat4_base_names[] = {0}; +static swig_lua_class _wrap_class_mat4 = { "mat4", "mat4", &SWIGTYPE_p_glm__mat4,_proxy__wrap_new_mat4, swig_delete_mat4, swig_mat4_methods, swig_mat4_attributes, &swig_mat4_Sf_SwigStatic, swig_mat4_meta, swig_mat4_bases, swig_mat4_base_names }; + +static int _wrap_add__SWIG_12(lua_State* L) { int SWIG_arg = 0; glm::mat4 *arg1 = 0 ; float arg2 ; glm::mat4 result; + SWIG_check_num_args("glm::operator +",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::operator +",1,"glm::mat4 const &"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::operator +",2,"float"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__mat4,0))){ SWIG_fail_ptr("add",1,SWIGTYPE_p_glm__mat4); } + arg2 = (float)lua_tonumber(L, 2); result = glm::operator +((glm::mat4 const &)*arg1,arg2); { + glm::mat4 * resultptr = new glm::mat4((const glm::mat4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__mat4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_add__SWIG_13(lua_State* L) { int SWIG_arg = 0; float arg1 ; glm::mat4 *arg2 = 0 ; glm::mat4 result; + SWIG_check_num_args("glm::operator +",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::operator +",1,"float"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::operator +",2,"glm::mat4 const &"); arg1 = (float)lua_tonumber(L, 1); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__mat4,0))){ SWIG_fail_ptr("add",2,SWIGTYPE_p_glm__mat4); } + result = glm::operator +(arg1,(glm::mat4 const &)*arg2); { glm::mat4 * resultptr = new glm::mat4((const glm::mat4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__mat4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_add__SWIG_14(lua_State* L) { int SWIG_arg = 0; glm::mat4 *arg1 = 0 ; glm::mat4 *arg2 = 0 ; glm::mat4 result; + SWIG_check_num_args("glm::operator +",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::operator +",1,"glm::mat4 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::operator +",2,"glm::mat4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__mat4,0))){ SWIG_fail_ptr("add",1,SWIGTYPE_p_glm__mat4); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__mat4,0))){ SWIG_fail_ptr("add",2,SWIGTYPE_p_glm__mat4); } + result = glm::operator +((glm::mat4 const &)*arg1,(glm::mat4 const &)*arg2); { + glm::mat4 * resultptr = new glm::mat4((const glm::mat4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__mat4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_sub__SWIG_12(lua_State* L) { int SWIG_arg = 0; glm::mat4 *arg1 = 0 ; float arg2 ; glm::mat4 result; + SWIG_check_num_args("glm::operator -",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::operator -",1,"glm::mat4 const &"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::operator -",2,"float"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__mat4,0))){ SWIG_fail_ptr("sub",1,SWIGTYPE_p_glm__mat4); } + arg2 = (float)lua_tonumber(L, 2); result = glm::operator -((glm::mat4 const &)*arg1,arg2); { + glm::mat4 * resultptr = new glm::mat4((const glm::mat4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__mat4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_sub__SWIG_13(lua_State* L) { int SWIG_arg = 0; float arg1 ; glm::mat4 *arg2 = 0 ; glm::mat4 result; + SWIG_check_num_args("glm::operator -",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::operator -",1,"float"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::operator -",2,"glm::mat4 const &"); arg1 = (float)lua_tonumber(L, 1); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__mat4,0))){ SWIG_fail_ptr("sub",2,SWIGTYPE_p_glm__mat4); } + result = glm::operator -(arg1,(glm::mat4 const &)*arg2); { glm::mat4 * resultptr = new glm::mat4((const glm::mat4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__mat4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_sub__SWIG_14(lua_State* L) { int SWIG_arg = 0; glm::mat4 *arg1 = 0 ; glm::mat4 *arg2 = 0 ; glm::mat4 result; + SWIG_check_num_args("glm::operator -",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::operator -",1,"glm::mat4 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::operator -",2,"glm::mat4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__mat4,0))){ SWIG_fail_ptr("sub",1,SWIGTYPE_p_glm__mat4); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__mat4,0))){ SWIG_fail_ptr("sub",2,SWIGTYPE_p_glm__mat4); } + result = glm::operator -((glm::mat4 const &)*arg1,(glm::mat4 const &)*arg2); { + glm::mat4 * resultptr = new glm::mat4((const glm::mat4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__mat4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_sub(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v = 0; { { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_sub__SWIG_2(L);} check_1: if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; { { _v = lua_isnumber(L,argv[1]); } } if (!_v) goto check_2; + return _wrap_sub__SWIG_0(L);} check_2: if (argc == 2) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; return _wrap_sub__SWIG_5(L);} check_3: if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_4; { { _v = lua_isnumber(L,argv[1]); } } if (!_v) goto check_4; + return _wrap_sub__SWIG_3(L);} check_4: if (argc == 2) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_5; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_5; return _wrap_sub__SWIG_8(L);} check_5: if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_6; { { _v = lua_isnumber(L,argv[1]); } } if (!_v) goto check_6; + return _wrap_sub__SWIG_6(L);} check_6: if (argc == 2) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__mat3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_7; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__mat3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_7; return _wrap_sub__SWIG_11(L);} check_7: if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__mat3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_8; { { _v = lua_isnumber(L,argv[1]); } } if (!_v) goto check_8; + return _wrap_sub__SWIG_9(L);} check_8: if (argc == 2) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__mat4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_9; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__mat4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_9; return _wrap_sub__SWIG_14(L);} check_9: if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__mat4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_10; { { _v = lua_isnumber(L,argv[1]); } } + if (!_v) goto check_10; return _wrap_sub__SWIG_12(L);} check_10: if (argc == 2) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__mat3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_11; return _wrap_sub__SWIG_10(L);} check_11: if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_12; return _wrap_sub__SWIG_7(L);} check_12: if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_13; return _wrap_sub__SWIG_1(L);} check_13: if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__mat4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_14; return _wrap_sub__SWIG_13(L);} check_14: if (argc == 2) { + return _wrap_sub__SWIG_4(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'sub'\n" + " Possible C/C++ prototypes are:\n" " glm::operator -(glm::vec2 const &,float)\n" + " glm::operator -(float,glm::vec2 const &)\n" " glm::operator -(glm::vec2 const &,glm::vec2 const &)\n" + " glm::operator -(glm::vec3 const &,float)\n" " glm::operator -(float,glm::vec3 const &)\n" + " glm::operator -(glm::vec3 const &,glm::vec3 const &)\n" " glm::operator -(glm::vec4 const &,float)\n" + " glm::operator -(float,glm::vec4 const &)\n" " glm::operator -(glm::vec4 const &,glm::vec4 const &)\n" + " glm::operator -(glm::mat3 const &,float)\n" " glm::operator -(float,glm::mat3 const &)\n" + " glm::operator -(glm::mat3 const &,glm::mat3 const &)\n" " glm::operator -(glm::mat4 const &,float)\n" + " glm::operator -(float,glm::mat4 const &)\n" " glm::operator -(glm::mat4 const &,glm::mat4 const &)\n"); + lua_error(L);return 0; } +static int _wrap_mul__SWIG_14(lua_State* L) { int SWIG_arg = 0; glm::mat4 *arg1 = 0 ; float arg2 ; glm::mat4 result; + SWIG_check_num_args("glm::operator *",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::operator *",1,"glm::mat4 const &"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::operator *",2,"float"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__mat4,0))){ SWIG_fail_ptr("mul",1,SWIGTYPE_p_glm__mat4); } + arg2 = (float)lua_tonumber(L, 2); result = glm::operator *((glm::mat4 const &)*arg1,arg2); { + glm::mat4 * resultptr = new glm::mat4((const glm::mat4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__mat4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_mul__SWIG_15(lua_State* L) { int SWIG_arg = 0; float arg1 ; glm::mat4 *arg2 = 0 ; glm::mat4 result; + SWIG_check_num_args("glm::operator *",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::operator *",1,"float"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::operator *",2,"glm::mat4 const &"); arg1 = (float)lua_tonumber(L, 1); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__mat4,0))){ SWIG_fail_ptr("mul",2,SWIGTYPE_p_glm__mat4); } + result = glm::operator *(arg1,(glm::mat4 const &)*arg2); { glm::mat4 * resultptr = new glm::mat4((const glm::mat4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__mat4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_mul__SWIG_16(lua_State* L) { int SWIG_arg = 0; glm::mat4 *arg1 = 0 ; glm::mat4 *arg2 = 0 ; glm::mat4 result; + SWIG_check_num_args("glm::operator *",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::operator *",1,"glm::mat4 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::operator *",2,"glm::mat4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__mat4,0))){ SWIG_fail_ptr("mul",1,SWIGTYPE_p_glm__mat4); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__mat4,0))){ SWIG_fail_ptr("mul",2,SWIGTYPE_p_glm__mat4); } + result = glm::operator *((glm::mat4 const &)*arg1,(glm::mat4 const &)*arg2); { + glm::mat4 * resultptr = new glm::mat4((const glm::mat4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__mat4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_mul__SWIG_17(lua_State* L) { int SWIG_arg = 0; glm::mat4 *arg1 = 0 ; glm::vec4 *arg2 = 0 ; glm::vec4 result; + SWIG_check_num_args("glm::operator *",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::operator *",1,"glm::mat4 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::operator *",2,"glm::vec4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__mat4,0))){ SWIG_fail_ptr("mul",1,SWIGTYPE_p_glm__mat4); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("mul",2,SWIGTYPE_p_glm__vec4); } + result = glm::operator *((glm::mat4 const &)*arg1,(glm::vec4 const &)*arg2); { + glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_mul__SWIG_18(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = 0 ; glm::mat4 *arg2 = 0 ; glm::vec4 result; + SWIG_check_num_args("glm::operator *",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::operator *",1,"glm::vec4 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::operator *",2,"glm::mat4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("mul",1,SWIGTYPE_p_glm__vec4); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__mat4,0))){ SWIG_fail_ptr("mul",2,SWIGTYPE_p_glm__mat4); } + result = glm::operator *((glm::vec4 const &)*arg1,(glm::mat4 const &)*arg2); { + glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_div__SWIG_14(lua_State* L) { int SWIG_arg = 0; glm::mat4 *arg1 = 0 ; float arg2 ; glm::mat4 result; + SWIG_check_num_args("glm::operator /",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::operator /",1,"glm::mat4 const &"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::operator /",2,"float"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__mat4,0))){ SWIG_fail_ptr("div",1,SWIGTYPE_p_glm__mat4); } + arg2 = (float)lua_tonumber(L, 2); result = glm::operator /((glm::mat4 const &)*arg1,arg2); { + glm::mat4 * resultptr = new glm::mat4((const glm::mat4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__mat4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_div__SWIG_15(lua_State* L) { int SWIG_arg = 0; float arg1 ; glm::mat4 *arg2 = 0 ; glm::mat4 result; + SWIG_check_num_args("glm::operator /",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::operator /",1,"float"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::operator /",2,"glm::mat4 const &"); arg1 = (float)lua_tonumber(L, 1); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__mat4,0))){ SWIG_fail_ptr("div",2,SWIGTYPE_p_glm__mat4); } + result = glm::operator /(arg1,(glm::mat4 const &)*arg2); { glm::mat4 * resultptr = new glm::mat4((const glm::mat4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__mat4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_div__SWIG_16(lua_State* L) { int SWIG_arg = 0; glm::mat4 *arg1 = 0 ; glm::mat4 *arg2 = 0 ; glm::mat4 result; + SWIG_check_num_args("glm::operator /",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::operator /",1,"glm::mat4 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::operator /",2,"glm::mat4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__mat4,0))){ SWIG_fail_ptr("div",1,SWIGTYPE_p_glm__mat4); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__mat4,0))){ SWIG_fail_ptr("div",2,SWIGTYPE_p_glm__mat4); } + result = glm::operator /((glm::mat4 const &)*arg1,(glm::mat4 const &)*arg2); { + glm::mat4 * resultptr = new glm::mat4((const glm::mat4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__mat4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_div__SWIG_17(lua_State* L) { int SWIG_arg = 0; glm::mat4 *arg1 = 0 ; glm::vec4 *arg2 = 0 ; glm::vec4 result; + SWIG_check_num_args("glm::operator /",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::operator /",1,"glm::mat4 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::operator /",2,"glm::vec4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__mat4,0))){ SWIG_fail_ptr("div",1,SWIGTYPE_p_glm__mat4); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("div",2,SWIGTYPE_p_glm__vec4); } + result = glm::operator /((glm::mat4 const &)*arg1,(glm::vec4 const &)*arg2); { + glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_div__SWIG_18(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = 0 ; glm::mat4 *arg2 = 0 ; glm::vec4 result; + SWIG_check_num_args("glm::operator /",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::operator /",1,"glm::vec4 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::operator /",2,"glm::mat4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("div",1,SWIGTYPE_p_glm__vec4); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__mat4,0))){ SWIG_fail_ptr("div",2,SWIGTYPE_p_glm__mat4); } + result = glm::operator /((glm::vec4 const &)*arg1,(glm::mat4 const &)*arg2); { + glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_eq__SWIG_4(lua_State* L) { int SWIG_arg = 0; glm::mat4 *arg1 = 0 ; glm::mat4 *arg2 = 0 ; bool result; + SWIG_check_num_args("glm::operator ==",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::operator ==",1,"glm::mat4 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::operator ==",2,"glm::mat4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__mat4,0))){ SWIG_fail_ptr("eq",1,SWIGTYPE_p_glm__mat4); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__mat4,0))){ SWIG_fail_ptr("eq",2,SWIGTYPE_p_glm__mat4); } + result = (bool)glm::operator ==((glm::mat4 const &)*arg1,(glm::mat4 const &)*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_quat_x_set(lua_State* L) { int SWIG_arg = 0; glm::quat *arg1 = (glm::quat *) 0 ; float arg2 ; + SWIG_check_num_args("glm::quat::x",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::quat::x",1,"glm::quat *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::quat::x",2,"float"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__quat,0))){ + SWIG_fail_ptr("quat_x_set",1,SWIGTYPE_p_glm__quat); } arg2 = (float)lua_tonumber(L, 2); if (arg1) (arg1)->x = arg2; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_quat_x_get(lua_State* L) { int SWIG_arg = 0; glm::quat *arg1 = (glm::quat *) 0 ; float result; + SWIG_check_num_args("glm::quat::x",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::quat::x",1,"glm::quat *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__quat,0))){ + SWIG_fail_ptr("quat_x_get",1,SWIGTYPE_p_glm__quat); } result = (float) ((arg1)->x); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_quat_y_set(lua_State* L) { int SWIG_arg = 0; glm::quat *arg1 = (glm::quat *) 0 ; float arg2 ; + SWIG_check_num_args("glm::quat::y",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::quat::y",1,"glm::quat *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::quat::y",2,"float"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__quat,0))){ + SWIG_fail_ptr("quat_y_set",1,SWIGTYPE_p_glm__quat); } arg2 = (float)lua_tonumber(L, 2); if (arg1) (arg1)->y = arg2; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_quat_y_get(lua_State* L) { int SWIG_arg = 0; glm::quat *arg1 = (glm::quat *) 0 ; float result; + SWIG_check_num_args("glm::quat::y",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::quat::y",1,"glm::quat *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__quat,0))){ + SWIG_fail_ptr("quat_y_get",1,SWIGTYPE_p_glm__quat); } result = (float) ((arg1)->y); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_quat_z_set(lua_State* L) { int SWIG_arg = 0; glm::quat *arg1 = (glm::quat *) 0 ; float arg2 ; + SWIG_check_num_args("glm::quat::z",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::quat::z",1,"glm::quat *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::quat::z",2,"float"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__quat,0))){ + SWIG_fail_ptr("quat_z_set",1,SWIGTYPE_p_glm__quat); } arg2 = (float)lua_tonumber(L, 2); if (arg1) (arg1)->z = arg2; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_quat_z_get(lua_State* L) { int SWIG_arg = 0; glm::quat *arg1 = (glm::quat *) 0 ; float result; + SWIG_check_num_args("glm::quat::z",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::quat::z",1,"glm::quat *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__quat,0))){ + SWIG_fail_ptr("quat_z_get",1,SWIGTYPE_p_glm__quat); } result = (float) ((arg1)->z); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_quat_w_set(lua_State* L) { int SWIG_arg = 0; glm::quat *arg1 = (glm::quat *) 0 ; float arg2 ; + SWIG_check_num_args("glm::quat::w",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::quat::w",1,"glm::quat *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::quat::w",2,"float"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__quat,0))){ + SWIG_fail_ptr("quat_w_set",1,SWIGTYPE_p_glm__quat); } arg2 = (float)lua_tonumber(L, 2); if (arg1) (arg1)->w = arg2; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_quat_w_get(lua_State* L) { int SWIG_arg = 0; glm::quat *arg1 = (glm::quat *) 0 ; float result; + SWIG_check_num_args("glm::quat::w",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::quat::w",1,"glm::quat *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__quat,0))){ + SWIG_fail_ptr("quat_w_get",1,SWIGTYPE_p_glm__quat); } result = (float) ((arg1)->w); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_quat_length(lua_State* L) { int SWIG_arg = 0; glm::length_t result; + SWIG_check_num_args("glm::quat::length",0,0) result = (glm::length_t)glm::quat::length(); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_new_quat__SWIG_0(lua_State* L) { int SWIG_arg = 0; glm::quat *result = 0 ; + SWIG_check_num_args("glm::quat::quat",0,0) result = (glm::quat *)new glm::quat(); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_glm__quat,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_new_quat__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::quat *arg1 = 0 ; glm::quat *result = 0 ; + SWIG_check_num_args("glm::quat::quat",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::quat::quat",1,"glm::quat const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__quat,0))){ SWIG_fail_ptr("new_quat",1,SWIGTYPE_p_glm__quat); } + result = (glm::quat *)new glm::quat((glm::quat const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_glm__quat,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_new_quat__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; glm::vec3 *arg2 = 0 ; glm::quat *result = 0 ; + SWIG_check_num_args("glm::quat::quat",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::quat::quat",1,"float"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::quat::quat",2,"glm::vec3 const &"); arg1 = (float)lua_tonumber(L, 1); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("new_quat",2,SWIGTYPE_p_glm__vec3); } + result = (glm::quat *)new glm::quat(arg1,(glm::vec3 const &)*arg2); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_glm__quat,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_new_quat__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; + glm::quat *result = 0 ; SWIG_check_num_args("glm::quat::quat",4,4) + if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::quat::quat",1,"float"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::quat::quat",2,"float"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("glm::quat::quat",3,"float"); + if(!lua_isnumber(L,4)) SWIG_fail_arg("glm::quat::quat",4,"float"); arg1 = (float)lua_tonumber(L, 1); + arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); + result = (glm::quat *)new glm::quat(arg1,arg2,arg3,arg4); SWIG_NewPointerObj(L,result,SWIGTYPE_p_glm__quat,1); SWIG_arg++; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_new_quat__SWIG_4(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; glm::vec3 *arg2 = 0 ; + glm::quat *result = 0 ; SWIG_check_num_args("glm::quat::quat",2,2) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::quat::quat",1,"glm::vec3 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::quat::quat",2,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("new_quat",1,SWIGTYPE_p_glm__vec3); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ + SWIG_fail_ptr("new_quat",2,SWIGTYPE_p_glm__vec3); } + result = (glm::quat *)new glm::quat((glm::vec3 const &)*arg1,(glm::vec3 const &)*arg2); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_glm__quat,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_new_quat__SWIG_5(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; glm::quat *result = 0 ; + SWIG_check_num_args("glm::quat::quat",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::quat::quat",1,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("new_quat",1,SWIGTYPE_p_glm__vec3); } + result = (glm::quat *)new glm::quat((glm::vec3 const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_glm__quat,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_new_quat__SWIG_6(lua_State* L) { int SWIG_arg = 0; glm::mat3 *arg1 = 0 ; glm::quat *result = 0 ; + SWIG_check_num_args("glm::quat::quat",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::quat::quat",1,"glm::mat3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__mat3,0))){ SWIG_fail_ptr("new_quat",1,SWIGTYPE_p_glm__mat3); } + result = (glm::quat *)new glm::quat((glm::mat3 const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_glm__quat,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_new_quat__SWIG_7(lua_State* L) { int SWIG_arg = 0; glm::mat4 *arg1 = 0 ; glm::quat *result = 0 ; + SWIG_check_num_args("glm::quat::quat",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::quat::quat",1,"glm::mat4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__mat4,0))){ SWIG_fail_ptr("new_quat",1,SWIGTYPE_p_glm__mat4); } + result = (glm::quat *)new glm::quat((glm::mat4 const &)*arg1); + SWIG_NewPointerObj(L,result,SWIGTYPE_p_glm__quat,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_new_quat(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 0) { + return _wrap_new_quat__SWIG_0(L);} if (argc == 1) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__quat, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_new_quat__SWIG_1(L);} check_2: if (argc == 1) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; return _wrap_new_quat__SWIG_5(L);} check_3: if (argc == 1) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__mat3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_4; return _wrap_new_quat__SWIG_6(L);} check_4: if (argc == 1) { + return _wrap_new_quat__SWIG_7(L);} if (argc == 2) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_6; return _wrap_new_quat__SWIG_4(L);} check_6: if (argc == 2) { + return _wrap_new_quat__SWIG_2(L);} if (argc == 4) { return _wrap_new_quat__SWIG_3(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_quat'\n" " Possible C/C++ prototypes are:\n" + " glm::quat::quat()\n" " glm::quat::quat(glm::quat const &)\n" " glm::quat::quat(float,glm::vec3 const &)\n" + " glm::quat::quat(float,float,float,float)\n" " glm::quat::quat(glm::vec3 const &,glm::vec3 const &)\n" + " glm::quat::quat(glm::vec3 const &)\n" " glm::quat::quat(glm::mat3 const &)\n" + " glm::quat::quat(glm::mat4 const &)\n"); lua_error(L);return 0; } +static int _wrap_quat___getitem(lua_State* L) { int SWIG_arg = 0; glm::quat *arg1 = (glm::quat *) 0 ; int arg2 ; float result; + SWIG_check_num_args("glm::quat::__getitem__",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::quat::__getitem__",1,"glm::quat *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::quat::__getitem__",2,"int"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__quat,0))){ + SWIG_fail_ptr("quat___getitem",1,SWIGTYPE_p_glm__quat); } arg2 = (int)lua_tonumber(L, 2); try { + result = (float)glm_quat___getitem__(arg1,arg2);} catch(std::out_of_range &_e) { + SWIG_exception(SWIG_IndexError, (&_e)->what()); } lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; + if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_quat___setitem(lua_State* L) { int SWIG_arg = 0; glm::quat *arg1 = (glm::quat *) 0 ; int arg2 ; float arg3 ; + SWIG_check_num_args("glm::quat::__setitem__",3,3) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::quat::__setitem__",1,"glm::quat *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::quat::__setitem__",2,"int"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("glm::quat::__setitem__",3,"float"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__quat,0))){ + SWIG_fail_ptr("quat___setitem",1,SWIGTYPE_p_glm__quat); } arg2 = (int)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); + try { glm_quat___setitem__(arg1,arg2,arg3);} catch(std::out_of_range &_e) { SWIG_exception(SWIG_IndexError, (&_e)->what()); } + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_quat___tostring(lua_State* L) { int SWIG_arg = 0; glm::quat *arg1 = (glm::quat *) 0 ; std::string result; + SWIG_check_num_args("glm::quat::__tostring",1,1) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::quat::__tostring",1,"glm::quat *"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__quat,0))){ + SWIG_fail_ptr("quat___tostring",1,SWIGTYPE_p_glm__quat); } result = glm_quat___tostring(arg1); + lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); + return SWIG_arg; } +static int _wrap_quat___add(lua_State* L) { int SWIG_arg = 0; glm::quat *arg1 = (glm::quat *) 0 ; glm::quat *arg2 = 0 ; + glm::quat result; SWIG_check_num_args("glm::quat::operator +",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::quat::operator +",1,"glm::quat *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::quat::operator +",2,"glm::quat const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__quat,0))){ + SWIG_fail_ptr("quat___add",1,SWIGTYPE_p_glm__quat); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__quat,0))){ + SWIG_fail_ptr("quat___add",2,SWIGTYPE_p_glm__quat); } result = glm_quat_operator_Sa_(arg1,(glm::quat const &)*arg2); { + glm::quat * resultptr = new glm::quat((const glm::quat &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__quat,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_quat___mul__SWIG_0(lua_State* L) { int SWIG_arg = 0; glm::quat *arg1 = (glm::quat *) 0 ; glm::quat *arg2 = 0 ; + glm::quat result; SWIG_check_num_args("glm::quat::operator *",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::quat::operator *",1,"glm::quat *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::quat::operator *",2,"glm::quat const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__quat,0))){ + SWIG_fail_ptr("quat___mul",1,SWIGTYPE_p_glm__quat); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__quat,0))){ + SWIG_fail_ptr("quat___mul",2,SWIGTYPE_p_glm__quat); } + result = glm_quat_operator_Sm___SWIG_0(arg1,(glm::quat const &)*arg2); { + glm::quat * resultptr = new glm::quat((const glm::quat &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__quat,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_quat___mul__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::quat *arg1 = (glm::quat *) 0 ; glm::vec3 *arg2 = 0 ; + glm::vec3 result; SWIG_check_num_args("glm::quat::operator *",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::quat::operator *",1,"glm::quat *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::quat::operator *",2,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__quat,0))){ + SWIG_fail_ptr("quat___mul",1,SWIGTYPE_p_glm__quat); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ + SWIG_fail_ptr("quat___mul",2,SWIGTYPE_p_glm__vec3); } + result = glm_quat_operator_Sm___SWIG_1(arg1,(glm::vec3 const &)*arg2); { + glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_quat___mul__SWIG_2(lua_State* L) { int SWIG_arg = 0; glm::quat *arg1 = (glm::quat *) 0 ; glm::vec4 *arg2 = 0 ; + glm::vec4 result; SWIG_check_num_args("glm::quat::operator *",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::quat::operator *",1,"glm::quat *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::quat::operator *",2,"glm::vec4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__quat,0))){ + SWIG_fail_ptr("quat___mul",1,SWIGTYPE_p_glm__quat); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec4,0))){ + SWIG_fail_ptr("quat___mul",2,SWIGTYPE_p_glm__vec4); } + result = glm_quat_operator_Sm___SWIG_2(arg1,(glm::vec4 const &)*arg2); { + glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_quat___mul__SWIG_3(lua_State* L) { int SWIG_arg = 0; glm::quat *arg1 = (glm::quat *) 0 ; float *arg2 = 0 ; + float temp2 ; glm::quat result; SWIG_check_num_args("glm::quat::operator *",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::quat::operator *",1,"glm::quat *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::quat::operator *",2,"float const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__quat,0))){ + SWIG_fail_ptr("quat___mul",1,SWIGTYPE_p_glm__quat); } temp2=(float)lua_tonumber(L,2); arg2=&temp2; + result = glm_quat_operator_Sm___SWIG_3(arg1,(float const &)*arg2); { + glm::quat * resultptr = new glm::quat((const glm::quat &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__quat,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_quat___mul(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v = 0; + { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__quat, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_quat___mul__SWIG_0(L);} check_1: + if (argc == 2) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_quat___mul__SWIG_1(L);} check_2: + if (argc == 2) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; return _wrap_quat___mul__SWIG_2(L);} check_3: + if (argc == 2) { return _wrap_quat___mul__SWIG_3(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'quat___mul'\n" " Possible C/C++ prototypes are:\n" + " glm::quat::operator *(glm::quat const &)\n" " glm::quat::operator *(glm::vec3 const &)\n" + " glm::quat::operator *(glm::vec4 const &)\n" " glm::quat::operator *(float const &)\n"); lua_error(L);return 0; } +static int _wrap_quat___div(lua_State* L) { int SWIG_arg = 0; glm::quat *arg1 = (glm::quat *) 0 ; float *arg2 = 0 ; + float temp2 ; glm::quat result; SWIG_check_num_args("glm::quat::operator /",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::quat::operator /",1,"glm::quat *"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::quat::operator /",2,"float const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__quat,0))){ + SWIG_fail_ptr("quat___div",1,SWIGTYPE_p_glm__quat); } temp2=(float)lua_tonumber(L,2); arg2=&temp2; + result = glm_quat_operator_Sd_(arg1,(float const &)*arg2); { + glm::quat * resultptr = new glm::quat((const glm::quat &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__quat,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_quat___eq(lua_State* L) { int SWIG_arg = 0; glm::quat *arg1 = (glm::quat *) 0 ; glm::quat *arg2 = 0 ; + bool result; SWIG_check_num_args("glm::quat::operator ==",2,2) + if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("glm::quat::operator ==",1,"glm::quat *"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::quat::operator ==",2,"glm::quat const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__quat,0))){ + SWIG_fail_ptr("quat___eq",1,SWIGTYPE_p_glm__quat); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__quat,0))){ + SWIG_fail_ptr("quat___eq",2,SWIGTYPE_p_glm__quat); } + result = (bool)glm_quat_operator_Se__Se_(arg1,(glm::quat const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static void swig_delete_quat(void *obj) { +glm::quat *arg1 = (glm::quat *) obj; +delete arg1; +} +static int _proxy__wrap_new_quat(lua_State *L) { + assert(lua_istable(L,1)); + lua_pushcfunction(L,_wrap_new_quat); + assert(!lua_isnil(L,-1)); + lua_replace(L,1); /* replace our table with real constructor */ + lua_call(L,lua_gettop(L)-1,1); + return 1; +} +static swig_lua_attribute swig_quat_attributes[] = { + { "x", _wrap_quat_x_get, _wrap_quat_x_set }, + { "y", _wrap_quat_y_get, _wrap_quat_y_set }, + { "z", _wrap_quat_z_get, _wrap_quat_z_set }, + { "w", _wrap_quat_w_get, _wrap_quat_w_set }, + {0,0,0} +}; +static swig_lua_method swig_quat_methods[]= { + { "__getitem", _wrap_quat___getitem}, + { "__setitem", _wrap_quat___setitem}, + { "__tostring", _wrap_quat___tostring}, + { "__add", _wrap_quat___add}, + { "__mul", _wrap_quat___mul}, + { "__div", _wrap_quat___div}, + { "__eq", _wrap_quat___eq}, + {0,0} +}; +static swig_lua_method swig_quat_meta[] = { + { "__getitem", _wrap_quat___getitem}, + { "__setitem", _wrap_quat___setitem}, + { "__tostring", _wrap_quat___tostring}, + { "__add", _wrap_quat___add}, + { "__mul", _wrap_quat___mul}, + { "__div", _wrap_quat___div}, + { "__eq", _wrap_quat___eq}, + {0,0} +}; + +static swig_lua_attribute swig_quat_Sf_SwigStatic_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_quat_Sf_SwigStatic_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_quat_Sf_SwigStatic_methods[]= { + { "length", _wrap_quat_length}, + {0,0} +}; +static swig_lua_class* swig_quat_Sf_SwigStatic_classes[]= { + 0 +}; + +static swig_lua_namespace swig_quat_Sf_SwigStatic = { + "quat", + swig_quat_Sf_SwigStatic_methods, + swig_quat_Sf_SwigStatic_attributes, + swig_quat_Sf_SwigStatic_constants, + swig_quat_Sf_SwigStatic_classes, + 0 +}; +static swig_lua_class *swig_quat_bases[] = {0}; +static const char *swig_quat_base_names[] = {0}; +static swig_lua_class _wrap_class_quat = { "quat", "quat", &SWIGTYPE_p_glm__quat,_proxy__wrap_new_quat, swig_delete_quat, swig_quat_methods, swig_quat_attributes, &swig_quat_Sf_SwigStatic, swig_quat_meta, swig_quat_bases, swig_quat_base_names }; + +static int _wrap_add__SWIG_15(lua_State* L) { int SWIG_arg = 0; glm::quat *arg1 = 0 ; glm::quat *arg2 = 0 ; glm::quat result; + SWIG_check_num_args("glm::operator +",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::operator +",1,"glm::quat const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::operator +",2,"glm::quat const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__quat,0))){ SWIG_fail_ptr("add",1,SWIGTYPE_p_glm__quat); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__quat,0))){ SWIG_fail_ptr("add",2,SWIGTYPE_p_glm__quat); } + result = glm::operator +((glm::quat const &)*arg1,(glm::quat const &)*arg2); { + glm::quat * resultptr = new glm::quat((const glm::quat &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__quat,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_add(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v = 0; { { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_add__SWIG_2(L);} check_1: if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; { { _v = lua_isnumber(L,argv[1]); } } if (!_v) goto check_2; + return _wrap_add__SWIG_0(L);} check_2: if (argc == 2) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; return _wrap_add__SWIG_5(L);} check_3: if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_4; { { _v = lua_isnumber(L,argv[1]); } } if (!_v) goto check_4; + return _wrap_add__SWIG_3(L);} check_4: if (argc == 2) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_5; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_5; return _wrap_add__SWIG_8(L);} check_5: if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_6; { { _v = lua_isnumber(L,argv[1]); } } if (!_v) goto check_6; + return _wrap_add__SWIG_6(L);} check_6: if (argc == 2) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__mat3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_7; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__mat3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_7; return _wrap_add__SWIG_11(L);} check_7: if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__mat3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_8; { { _v = lua_isnumber(L,argv[1]); } } if (!_v) goto check_8; + return _wrap_add__SWIG_9(L);} check_8: if (argc == 2) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__mat4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_9; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__mat4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_9; return _wrap_add__SWIG_14(L);} check_9: if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__mat4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_10; { { _v = lua_isnumber(L,argv[1]); } } + if (!_v) goto check_10; return _wrap_add__SWIG_12(L);} check_10: if (argc == 2) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__quat, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_11; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__quat, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_11; return _wrap_add__SWIG_15(L);} check_11: if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_12; return _wrap_add__SWIG_7(L);} check_12: if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_13; return _wrap_add__SWIG_1(L);} check_13: if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__mat4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_14; return _wrap_add__SWIG_13(L);} check_14: if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_15; return _wrap_add__SWIG_4(L);} check_15: if (argc == 2) { + return _wrap_add__SWIG_10(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'add'\n" + " Possible C/C++ prototypes are:\n" " glm::operator +(glm::vec2 const &,float)\n" + " glm::operator +(float,glm::vec2 const &)\n" " glm::operator +(glm::vec2 const &,glm::vec2 const &)\n" + " glm::operator +(glm::vec3 const &,float)\n" " glm::operator +(float,glm::vec3 const &)\n" + " glm::operator +(glm::vec3 const &,glm::vec3 const &)\n" " glm::operator +(glm::vec4 const &,float)\n" + " glm::operator +(float,glm::vec4 const &)\n" " glm::operator +(glm::vec4 const &,glm::vec4 const &)\n" + " glm::operator +(glm::mat3 const &,float)\n" " glm::operator +(float,glm::mat3 const &)\n" + " glm::operator +(glm::mat3 const &,glm::mat3 const &)\n" " glm::operator +(glm::mat4 const &,float)\n" + " glm::operator +(float,glm::mat4 const &)\n" " glm::operator +(glm::mat4 const &,glm::mat4 const &)\n" + " glm::operator +(glm::quat const &,glm::quat const &)\n"); lua_error(L);return 0; } +static int _wrap_mul__SWIG_19(lua_State* L) { int SWIG_arg = 0; glm::quat *arg1 = 0 ; glm::quat *arg2 = 0 ; glm::quat result; + SWIG_check_num_args("glm::operator *",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::operator *",1,"glm::quat const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::operator *",2,"glm::quat const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__quat,0))){ SWIG_fail_ptr("mul",1,SWIGTYPE_p_glm__quat); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__quat,0))){ SWIG_fail_ptr("mul",2,SWIGTYPE_p_glm__quat); } + result = glm::operator *((glm::quat const &)*arg1,(glm::quat const &)*arg2); { + glm::quat * resultptr = new glm::quat((const glm::quat &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__quat,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_mul__SWIG_20(lua_State* L) { int SWIG_arg = 0; glm::quat *arg1 = 0 ; glm::vec3 *arg2 = 0 ; glm::vec3 result; + SWIG_check_num_args("glm::operator *",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::operator *",1,"glm::quat const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::operator *",2,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__quat,0))){ SWIG_fail_ptr("mul",1,SWIGTYPE_p_glm__quat); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("mul",2,SWIGTYPE_p_glm__vec3); } + result = glm::operator *((glm::quat const &)*arg1,(glm::vec3 const &)*arg2); { + glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_mul__SWIG_21(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; glm::quat *arg2 = 0 ; glm::vec3 result; + SWIG_check_num_args("glm::operator *",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::operator *",1,"glm::vec3 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::operator *",2,"glm::quat const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("mul",1,SWIGTYPE_p_glm__vec3); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__quat,0))){ SWIG_fail_ptr("mul",2,SWIGTYPE_p_glm__quat); } + result = glm::operator *((glm::vec3 const &)*arg1,(glm::quat const &)*arg2); { + glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_mul__SWIG_22(lua_State* L) { int SWIG_arg = 0; glm::quat *arg1 = 0 ; glm::vec4 *arg2 = 0 ; glm::vec4 result; + SWIG_check_num_args("glm::operator *",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::operator *",1,"glm::quat const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::operator *",2,"glm::vec4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__quat,0))){ SWIG_fail_ptr("mul",1,SWIGTYPE_p_glm__quat); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("mul",2,SWIGTYPE_p_glm__vec4); } + result = glm::operator *((glm::quat const &)*arg1,(glm::vec4 const &)*arg2); { + glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_mul__SWIG_23(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = 0 ; glm::quat *arg2 = 0 ; glm::vec4 result; + SWIG_check_num_args("glm::operator *",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::operator *",1,"glm::vec4 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::operator *",2,"glm::quat const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("mul",1,SWIGTYPE_p_glm__vec4); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__quat,0))){ SWIG_fail_ptr("mul",2,SWIGTYPE_p_glm__quat); } + result = glm::operator *((glm::vec4 const &)*arg1,(glm::quat const &)*arg2); { + glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_mul__SWIG_24(lua_State* L) { int SWIG_arg = 0; glm::quat *arg1 = 0 ; float *arg2 = 0 ; float temp2 ; + glm::quat result; SWIG_check_num_args("glm::operator *",2,2) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::operator *",1,"glm::quat const &"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::operator *",2,"float const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__quat,0))){ SWIG_fail_ptr("mul",1,SWIGTYPE_p_glm__quat); } + temp2=(float)lua_tonumber(L,2); arg2=&temp2; result = glm::operator *((glm::quat const &)*arg1,(float const &)*arg2); { + glm::quat * resultptr = new glm::quat((const glm::quat &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__quat,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_mul__SWIG_25(lua_State* L) { int SWIG_arg = 0; float *arg1 = 0 ; glm::quat *arg2 = 0 ; float temp1 ; + glm::quat result; SWIG_check_num_args("glm::operator *",2,2) + if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::operator *",1,"float const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::operator *",2,"glm::quat const &"); temp1=(float)lua_tonumber(L,1); arg1=&temp1; + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__quat,0))){ SWIG_fail_ptr("mul",2,SWIGTYPE_p_glm__quat); } + result = glm::operator *((float const &)*arg1,(glm::quat const &)*arg2); { + glm::quat * resultptr = new glm::quat((const glm::quat &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__quat,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_mul(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v = 0; { { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_mul__SWIG_2(L);} check_1: if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; { { _v = lua_isnumber(L,argv[1]); } } if (!_v) goto check_2; + return _wrap_mul__SWIG_0(L);} check_2: if (argc == 2) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; return _wrap_mul__SWIG_5(L);} check_3: if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_4; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__mat3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_4; return _wrap_mul__SWIG_12(L);} check_4: if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_5; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_5; return _wrap_mul__SWIG_8(L);} check_5: if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_6; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__mat4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_6; return _wrap_mul__SWIG_18(L);} check_6: if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__mat3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_7; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__mat3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_7; return _wrap_mul__SWIG_11(L);} check_7: if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__mat3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_8; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_8; return _wrap_mul__SWIG_13(L);} check_8: if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_9; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__quat, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_9; return _wrap_mul__SWIG_21(L);} check_9: if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__mat3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_10; { { _v = lua_isnumber(L,argv[1]); } } + if (!_v) goto check_10; return _wrap_mul__SWIG_9(L);} check_10: if (argc == 2) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__mat4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_11; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__mat4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_11; return _wrap_mul__SWIG_16(L);} check_11: if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__mat4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_12; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_12; return _wrap_mul__SWIG_17(L);} check_12: if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__mat4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_13; { { _v = lua_isnumber(L,argv[1]); } } + if (!_v) goto check_13; return _wrap_mul__SWIG_14(L);} check_13: if (argc == 2) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_14; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__quat, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_14; return _wrap_mul__SWIG_23(L);} check_14: if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__quat, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_15; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__quat, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_15; return _wrap_mul__SWIG_19(L);} check_15: if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__quat, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_16; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_16; return _wrap_mul__SWIG_20(L);} check_16: if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_17; { { _v = lua_isnumber(L,argv[1]); } } + if (!_v) goto check_17; return _wrap_mul__SWIG_3(L);} check_17: if (argc == 2) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__quat, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_18; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_18; return _wrap_mul__SWIG_22(L);} check_18: if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_19; { { _v = lua_isnumber(L,argv[1]); } } + if (!_v) goto check_19; return _wrap_mul__SWIG_6(L);} check_19: if (argc == 2) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__quat, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_20; { { _v = lua_isnumber(L,argv[1]); } } + if (!_v) goto check_20; return _wrap_mul__SWIG_24(L);} check_20: if (argc == 2) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__mat4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_21; return _wrap_mul__SWIG_15(L);} check_21: if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_22; return _wrap_mul__SWIG_7(L);} check_22: if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_23; return _wrap_mul__SWIG_1(L);} check_23: if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_24; return _wrap_mul__SWIG_4(L);} check_24: if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__mat3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_25; return _wrap_mul__SWIG_10(L);} check_25: if (argc == 2) { + return _wrap_mul__SWIG_25(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'mul'\n" + " Possible C/C++ prototypes are:\n" " glm::operator *(glm::vec2 const &,float)\n" + " glm::operator *(float,glm::vec2 const &)\n" " glm::operator *(glm::vec2 const &,glm::vec2 const &)\n" + " glm::operator *(glm::vec3 const &,float)\n" " glm::operator *(float,glm::vec3 const &)\n" + " glm::operator *(glm::vec3 const &,glm::vec3 const &)\n" " glm::operator *(glm::vec4 const &,float)\n" + " glm::operator *(float,glm::vec4 const &)\n" " glm::operator *(glm::vec4 const &,glm::vec4 const &)\n" + " glm::operator *(glm::mat3 const &,float)\n" " glm::operator *(float,glm::mat3 const &)\n" + " glm::operator *(glm::mat3 const &,glm::mat3 const &)\n" " glm::operator *(glm::vec3 const &,glm::mat3 const &)\n" + " glm::operator *(glm::mat3 const &,glm::vec3 const &)\n" " glm::operator *(glm::mat4 const &,float)\n" + " glm::operator *(float,glm::mat4 const &)\n" " glm::operator *(glm::mat4 const &,glm::mat4 const &)\n" + " glm::operator *(glm::mat4 const &,glm::vec4 const &)\n" " glm::operator *(glm::vec4 const &,glm::mat4 const &)\n" + " glm::operator *(glm::quat const &,glm::quat const &)\n" " glm::operator *(glm::quat const &,glm::vec3 const &)\n" + " glm::operator *(glm::vec3 const &,glm::quat const &)\n" " glm::operator *(glm::quat const &,glm::vec4 const &)\n" + " glm::operator *(glm::vec4 const &,glm::quat const &)\n" " glm::operator *(glm::quat const &,float const &)\n" + " glm::operator *(float const &,glm::quat const &)\n"); lua_error(L);return 0; } +static int _wrap_div__SWIG_19(lua_State* L) { int SWIG_arg = 0; glm::quat *arg1 = 0 ; float *arg2 = 0 ; float temp2 ; + glm::quat result; SWIG_check_num_args("glm::operator /",2,2) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::operator /",1,"glm::quat const &"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::operator /",2,"float const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__quat,0))){ SWIG_fail_ptr("div",1,SWIGTYPE_p_glm__quat); } + temp2=(float)lua_tonumber(L,2); arg2=&temp2; result = glm::operator /((glm::quat const &)*arg1,(float const &)*arg2); { + glm::quat * resultptr = new glm::quat((const glm::quat &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__quat,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_div(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v = 0; { { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_div__SWIG_2(L);} check_1: if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; { { _v = lua_isnumber(L,argv[1]); } } if (!_v) goto check_2; + return _wrap_div__SWIG_0(L);} check_2: if (argc == 2) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; return _wrap_div__SWIG_5(L);} check_3: if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_4; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__mat3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_4; return _wrap_div__SWIG_13(L);} check_4: if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_5; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_5; return _wrap_div__SWIG_8(L);} check_5: if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_6; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__mat4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_6; return _wrap_div__SWIG_18(L);} check_6: if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__mat3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_7; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__mat3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_7; return _wrap_div__SWIG_11(L);} check_7: if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__mat3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_8; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_8; return _wrap_div__SWIG_12(L);} check_8: if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__mat3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_9; { { _v = lua_isnumber(L,argv[1]); } } if (!_v) goto check_9; + return _wrap_div__SWIG_9(L);} check_9: if (argc == 2) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_10; { { _v = lua_isnumber(L,argv[1]); } } + if (!_v) goto check_10; return _wrap_div__SWIG_3(L);} check_10: if (argc == 2) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__mat4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_11; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__mat4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_11; return _wrap_div__SWIG_16(L);} check_11: if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__mat4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_12; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_12; return _wrap_div__SWIG_17(L);} check_12: if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__mat4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_13; { { _v = lua_isnumber(L,argv[1]); } } + if (!_v) goto check_13; return _wrap_div__SWIG_14(L);} check_13: if (argc == 2) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_14; { { _v = lua_isnumber(L,argv[1]); } } + if (!_v) goto check_14; return _wrap_div__SWIG_6(L);} check_14: if (argc == 2) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__quat, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_15; { { _v = lua_isnumber(L,argv[1]); } } + if (!_v) goto check_15; return _wrap_div__SWIG_19(L);} check_15: if (argc == 2) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__mat4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_16; return _wrap_div__SWIG_15(L);} check_16: if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_17; return _wrap_div__SWIG_7(L);} check_17: if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_18; return _wrap_div__SWIG_1(L);} check_18: if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_19; return _wrap_div__SWIG_4(L);} check_19: if (argc == 2) { + return _wrap_div__SWIG_10(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'div'\n" + " Possible C/C++ prototypes are:\n" " glm::operator /(glm::vec2 const &,float)\n" + " glm::operator /(float,glm::vec2 const &)\n" " glm::operator /(glm::vec2 const &,glm::vec2 const &)\n" + " glm::operator /(glm::vec3 const &,float)\n" " glm::operator /(float,glm::vec3 const &)\n" + " glm::operator /(glm::vec3 const &,glm::vec3 const &)\n" " glm::operator /(glm::vec4 const &,float)\n" + " glm::operator /(float,glm::vec4 const &)\n" " glm::operator /(glm::vec4 const &,glm::vec4 const &)\n" + " glm::operator /(glm::mat3 const &,float)\n" " glm::operator /(float,glm::mat3 const &)\n" + " glm::operator /(glm::mat3 const &,glm::mat3 const &)\n" " glm::operator /(glm::mat3 const &,glm::vec3 const &)\n" + " glm::operator /(glm::vec3 const &,glm::mat3 const &)\n" " glm::operator /(glm::mat4 const &,float)\n" + " glm::operator /(float,glm::mat4 const &)\n" " glm::operator /(glm::mat4 const &,glm::mat4 const &)\n" + " glm::operator /(glm::mat4 const &,glm::vec4 const &)\n" " glm::operator /(glm::vec4 const &,glm::mat4 const &)\n" + " glm::operator /(glm::quat const &,float const &)\n"); lua_error(L);return 0; } +static int _wrap_eq__SWIG_5(lua_State* L) { int SWIG_arg = 0; glm::quat *arg1 = 0 ; glm::quat *arg2 = 0 ; bool result; + SWIG_check_num_args("glm::operator ==",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::operator ==",1,"glm::quat const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::operator ==",2,"glm::quat const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__quat,0))){ SWIG_fail_ptr("eq",1,SWIGTYPE_p_glm__quat); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__quat,0))){ SWIG_fail_ptr("eq",2,SWIGTYPE_p_glm__quat); } + result = (bool)glm::operator ==((glm::quat const &)*arg1,(glm::quat const &)*arg2); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_eq(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v = 0; { { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_eq__SWIG_0(L);} check_1: if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_eq__SWIG_1(L);} check_2: if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; return _wrap_eq__SWIG_2(L);} check_3: if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__mat3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_4; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__mat3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_4; return _wrap_eq__SWIG_3(L);} check_4: if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__mat4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_5; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__mat4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_5; return _wrap_eq__SWIG_4(L);} check_5: if (argc == 2) { + return _wrap_eq__SWIG_5(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'eq'\n" + " Possible C/C++ prototypes are:\n" " glm::operator ==(glm::vec2 const &,glm::vec2 const &)\n" + " glm::operator ==(glm::vec3 const &,glm::vec3 const &)\n" " glm::operator ==(glm::vec4 const &,glm::vec4 const &)\n" + " glm::operator ==(glm::mat3 const &,glm::mat3 const &)\n" " glm::operator ==(glm::mat4 const &,glm::mat4 const &)\n" + " glm::operator ==(glm::quat const &,glm::quat const &)\n"); lua_error(L);return 0; } +static int _wrap_length__SWIG_0(lua_State* L) { int SWIG_arg = 0; glm::quat *arg1 = 0 ; float result; + SWIG_check_num_args("glm::length",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::length",1,"glm::quat const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__quat,0))){ SWIG_fail_ptr("length",1,SWIGTYPE_p_glm__quat); } + result = (float)glm::length((glm::quat const &)*arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; + if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_normalize__SWIG_0(lua_State* L) { int SWIG_arg = 0; glm::quat *arg1 = 0 ; glm::quat result; + SWIG_check_num_args("glm::normalize",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::normalize",1,"glm::quat const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__quat,0))){ + SWIG_fail_ptr("normalize",1,SWIGTYPE_p_glm__quat); } result = glm::normalize((glm::quat const &)*arg1); { + glm::quat * resultptr = new glm::quat((const glm::quat &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__quat,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_dot__SWIG_0(lua_State* L) { int SWIG_arg = 0; glm::quat *arg1 = 0 ; glm::quat *arg2 = 0 ; float result; + SWIG_check_num_args("glm::dot",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::dot",1,"glm::quat const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::dot",2,"glm::quat const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__quat,0))){ SWIG_fail_ptr("dot",1,SWIGTYPE_p_glm__quat); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__quat,0))){ SWIG_fail_ptr("dot",2,SWIGTYPE_p_glm__quat); } + result = (float)glm::dot((glm::quat const &)*arg1,(glm::quat const &)*arg2); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_mix__SWIG_0(lua_State* L) { int SWIG_arg = 0; glm::quat *arg1 = 0 ; glm::quat *arg2 = 0 ; float arg3 ; + glm::quat result; SWIG_check_num_args("glm::mix",3,3) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::mix",1,"glm::quat const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::mix",2,"glm::quat const &"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("glm::mix",3,"float"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__quat,0))){ SWIG_fail_ptr("mix",1,SWIGTYPE_p_glm__quat); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__quat,0))){ SWIG_fail_ptr("mix",2,SWIGTYPE_p_glm__quat); } + arg3 = (float)lua_tonumber(L, 3); result = glm::mix((glm::quat const &)*arg1,(glm::quat const &)*arg2,arg3); { + glm::quat * resultptr = new glm::quat((const glm::quat &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__quat,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_lerp__SWIG_0(lua_State* L) { int SWIG_arg = 0; glm::quat *arg1 = 0 ; glm::quat *arg2 = 0 ; float arg3 ; + glm::quat result; SWIG_check_num_args("glm::lerp",3,3) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::lerp",1,"glm::quat const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::lerp",2,"glm::quat const &"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("glm::lerp",3,"float"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__quat,0))){ SWIG_fail_ptr("lerp",1,SWIGTYPE_p_glm__quat); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__quat,0))){ SWIG_fail_ptr("lerp",2,SWIGTYPE_p_glm__quat); } + arg3 = (float)lua_tonumber(L, 3); result = glm::lerp((glm::quat const &)*arg1,(glm::quat const &)*arg2,arg3); { + glm::quat * resultptr = new glm::quat((const glm::quat &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__quat,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_slerp__SWIG_0(lua_State* L) { int SWIG_arg = 0; glm::quat *arg1 = 0 ; glm::quat *arg2 = 0 ; float arg3 ; + glm::quat result; SWIG_check_num_args("glm::slerp",3,3) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::slerp",1,"glm::quat const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::slerp",2,"glm::quat const &"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("glm::slerp",3,"float"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__quat,0))){ SWIG_fail_ptr("slerp",1,SWIGTYPE_p_glm__quat); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__quat,0))){ SWIG_fail_ptr("slerp",2,SWIGTYPE_p_glm__quat); } + arg3 = (float)lua_tonumber(L, 3); result = glm::slerp((glm::quat const &)*arg1,(glm::quat const &)*arg2,arg3); { + glm::quat * resultptr = new glm::quat((const glm::quat &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__quat,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_conjugate(lua_State* L) { int SWIG_arg = 0; glm::quat *arg1 = 0 ; glm::quat result; + SWIG_check_num_args("glm::conjugate",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::conjugate",1,"glm::quat const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__quat,0))){ + SWIG_fail_ptr("conjugate",1,SWIGTYPE_p_glm__quat); } result = glm::conjugate((glm::quat const &)*arg1); { + glm::quat * resultptr = new glm::quat((const glm::quat &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__quat,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_inverse__SWIG_0(lua_State* L) { int SWIG_arg = 0; glm::quat *arg1 = 0 ; glm::quat result; + SWIG_check_num_args("glm::inverse",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::inverse",1,"glm::quat const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__quat,0))){ SWIG_fail_ptr("inverse",1,SWIGTYPE_p_glm__quat); } + result = glm::inverse((glm::quat const &)*arg1); { glm::quat * resultptr = new glm::quat((const glm::quat &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__quat,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_rotate__SWIG_0(lua_State* L) { int SWIG_arg = 0; glm::quat *arg1 = 0 ; float *arg2 = 0 ; glm::vec3 *arg3 = 0 ; + float temp2 ; glm::quat result; SWIG_check_num_args("glm::rotate",3,3) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::rotate",1,"glm::quat const &"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::rotate",2,"float const &"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("glm::rotate",3,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__quat,0))){ SWIG_fail_ptr("rotate",1,SWIGTYPE_p_glm__quat); } + temp2=(float)lua_tonumber(L,2); arg2=&temp2; if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_glm__vec3,0))){ + SWIG_fail_ptr("rotate",3,SWIGTYPE_p_glm__vec3); } + result = glm::rotate((glm::quat const &)*arg1,(float const &)*arg2,(glm::vec3 const &)*arg3); { + glm::quat * resultptr = new glm::quat((const glm::quat &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__quat,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_eulerAngles(lua_State* L) { int SWIG_arg = 0; glm::quat *arg1 = 0 ; glm::vec3 result; + SWIG_check_num_args("glm::eulerAngles",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::eulerAngles",1,"glm::quat const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__quat,0))){ + SWIG_fail_ptr("eulerAngles",1,SWIGTYPE_p_glm__quat); } result = glm::eulerAngles((glm::quat const &)*arg1); { + glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_roll(lua_State* L) { int SWIG_arg = 0; glm::quat *arg1 = 0 ; float result; SWIG_check_num_args("glm::roll",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::roll",1,"glm::quat const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__quat,0))){ SWIG_fail_ptr("roll",1,SWIGTYPE_p_glm__quat); } + result = (float)glm::roll((glm::quat const &)*arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; + if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_pitch(lua_State* L) { int SWIG_arg = 0; glm::quat *arg1 = 0 ; float result; + SWIG_check_num_args("glm::pitch",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::pitch",1,"glm::quat const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__quat,0))){ SWIG_fail_ptr("pitch",1,SWIGTYPE_p_glm__quat); } + result = (float)glm::pitch((glm::quat const &)*arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; + if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_yaw(lua_State* L) { int SWIG_arg = 0; glm::quat *arg1 = 0 ; float result; SWIG_check_num_args("glm::yaw",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::yaw",1,"glm::quat const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__quat,0))){ SWIG_fail_ptr("yaw",1,SWIGTYPE_p_glm__quat); } + result = (float)glm::yaw((glm::quat const &)*arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; + if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_mat3_cast(lua_State* L) { int SWIG_arg = 0; glm::quat *arg1 = 0 ; glm::mat3 result; + SWIG_check_num_args("glm::mat3_cast",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::mat3_cast",1,"glm::quat const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__quat,0))){ + SWIG_fail_ptr("mat3_cast",1,SWIGTYPE_p_glm__quat); } result = glm::mat3_cast((glm::quat const &)*arg1); { + glm::mat3 * resultptr = new glm::mat3((const glm::mat3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__mat3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_mat4_cast(lua_State* L) { int SWIG_arg = 0; glm::quat *arg1 = 0 ; glm::mat4 result; + SWIG_check_num_args("glm::mat4_cast",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::mat4_cast",1,"glm::quat const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__quat,0))){ + SWIG_fail_ptr("mat4_cast",1,SWIGTYPE_p_glm__quat); } result = glm::mat4_cast((glm::quat const &)*arg1); { + glm::mat4 * resultptr = new glm::mat4((const glm::mat4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__mat4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_quat_cast__SWIG_0(lua_State* L) { int SWIG_arg = 0; glm::mat3 *arg1 = 0 ; glm::quat result; + SWIG_check_num_args("glm::quat_cast",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::quat_cast",1,"glm::mat3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__mat3,0))){ + SWIG_fail_ptr("quat_cast",1,SWIGTYPE_p_glm__mat3); } result = glm::quat_cast((glm::mat3 const &)*arg1); { + glm::quat * resultptr = new glm::quat((const glm::quat &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__quat,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_quat_cast__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::mat4 *arg1 = 0 ; glm::quat result; + SWIG_check_num_args("glm::quat_cast",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::quat_cast",1,"glm::mat4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__mat4,0))){ + SWIG_fail_ptr("quat_cast",1,SWIGTYPE_p_glm__mat4); } result = glm::quat_cast((glm::mat4 const &)*arg1); { + glm::quat * resultptr = new glm::quat((const glm::quat &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__quat,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_quat_cast(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v = 0; { { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__mat3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_quat_cast__SWIG_0(L);} check_1: + if (argc == 1) { return _wrap_quat_cast__SWIG_1(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'quat_cast'\n" " Possible C/C++ prototypes are:\n" + " glm::quat_cast(glm::mat3 const &)\n" " glm::quat_cast(glm::mat4 const &)\n"); lua_error(L);return 0; } +static int _wrap_angle__SWIG_0(lua_State* L) { int SWIG_arg = 0; glm::quat *arg1 = 0 ; float result; + SWIG_check_num_args("glm::angle",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::angle",1,"glm::quat const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__quat,0))){ SWIG_fail_ptr("angle",1,SWIGTYPE_p_glm__quat); } + result = (float)glm::angle((glm::quat const &)*arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; + if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_axis(lua_State* L) { int SWIG_arg = 0; glm::quat *arg1 = 0 ; glm::vec3 result; + SWIG_check_num_args("glm::axis",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::axis",1,"glm::quat const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__quat,0))){ SWIG_fail_ptr("axis",1,SWIGTYPE_p_glm__quat); } + result = glm::axis((glm::quat const &)*arg1); { glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_angleAxis(lua_State* L) { int SWIG_arg = 0; float *arg1 = 0 ; glm::vec3 *arg2 = 0 ; float temp1 ; + glm::quat result; SWIG_check_num_args("glm::angleAxis",2,2) + if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::angleAxis",1,"float const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::angleAxis",2,"glm::vec3 const &"); temp1=(float)lua_tonumber(L,1); arg1=&temp1; + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ + SWIG_fail_ptr("angleAxis",2,SWIGTYPE_p_glm__vec3); } + result = glm::angleAxis((float const &)*arg1,(glm::vec3 const &)*arg2); { + glm::quat * resultptr = new glm::quat((const glm::quat &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__quat,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_epsilon(lua_State* L) { int SWIG_arg = 0; float result; SWIG_check_num_args("glm::epsilon< float >",0,0) + result = (float)glm::SWIGTEMPLATEDISAMBIGUATOR epsilon< float >(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_zero(lua_State* L) { int SWIG_arg = 0; float result; SWIG_check_num_args("glm::zero< float >",0,0) + result = (float)glm::SWIGTEMPLATEDISAMBIGUATOR zero< float >(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_one(lua_State* L) { int SWIG_arg = 0; float result; SWIG_check_num_args("glm::one< float >",0,0) + result = (float)glm::SWIGTEMPLATEDISAMBIGUATOR one< float >(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_pi(lua_State* L) { int SWIG_arg = 0; float result; SWIG_check_num_args("glm::pi< float >",0,0) + result = (float)glm::SWIGTEMPLATEDISAMBIGUATOR pi< float >(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_root_pi(lua_State* L) { int SWIG_arg = 0; float result; SWIG_check_num_args("glm::root_pi< float >",0,0) + result = (float)glm::SWIGTEMPLATEDISAMBIGUATOR root_pi< float >(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_half_pi(lua_State* L) { int SWIG_arg = 0; float result; SWIG_check_num_args("glm::half_pi< float >",0,0) + result = (float)glm::SWIGTEMPLATEDISAMBIGUATOR half_pi< float >(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_quarter_pi(lua_State* L) { int SWIG_arg = 0; float result; SWIG_check_num_args("glm::quarter_pi< float >",0,0) + result = (float)glm::SWIGTEMPLATEDISAMBIGUATOR quarter_pi< float >(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_one_over_pi(lua_State* L) { int SWIG_arg = 0; float result; + SWIG_check_num_args("glm::one_over_pi< float >",0,0) result = (float)glm::SWIGTEMPLATEDISAMBIGUATOR one_over_pi< float >(); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_two_over_pi(lua_State* L) { int SWIG_arg = 0; float result; + SWIG_check_num_args("glm::two_over_pi< float >",0,0) result = (float)glm::SWIGTEMPLATEDISAMBIGUATOR two_over_pi< float >(); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_two_over_root_pi(lua_State* L) { int SWIG_arg = 0; float result; + SWIG_check_num_args("glm::two_over_root_pi< float >",0,0) + result = (float)glm::SWIGTEMPLATEDISAMBIGUATOR two_over_root_pi< float >(); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_one_over_root_two(lua_State* L) { int SWIG_arg = 0; float result; + SWIG_check_num_args("glm::one_over_root_two< float >",0,0) + result = (float)glm::SWIGTEMPLATEDISAMBIGUATOR one_over_root_two< float >(); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_root_half_pi(lua_State* L) { int SWIG_arg = 0; float result; + SWIG_check_num_args("glm::root_half_pi< float >",0,0) result = (float)glm::SWIGTEMPLATEDISAMBIGUATOR root_half_pi< float >(); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_root_two_pi(lua_State* L) { int SWIG_arg = 0; float result; + SWIG_check_num_args("glm::root_two_pi< float >",0,0) result = (float)glm::SWIGTEMPLATEDISAMBIGUATOR root_two_pi< float >(); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_root_ln_four(lua_State* L) { int SWIG_arg = 0; float result; + SWIG_check_num_args("glm::root_ln_four< float >",0,0) result = (float)glm::SWIGTEMPLATEDISAMBIGUATOR root_ln_four< float >(); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_e(lua_State* L) { int SWIG_arg = 0; float result; SWIG_check_num_args("glm::e< float >",0,0) + result = (float)glm::SWIGTEMPLATEDISAMBIGUATOR e< float >(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_euler(lua_State* L) { int SWIG_arg = 0; float result; SWIG_check_num_args("glm::euler< float >",0,0) + result = (float)glm::SWIGTEMPLATEDISAMBIGUATOR euler< float >(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_root_two(lua_State* L) { int SWIG_arg = 0; float result; SWIG_check_num_args("glm::root_two< float >",0,0) + result = (float)glm::SWIGTEMPLATEDISAMBIGUATOR root_two< float >(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_root_three(lua_State* L) { int SWIG_arg = 0; float result; SWIG_check_num_args("glm::root_three< float >",0,0) + result = (float)glm::SWIGTEMPLATEDISAMBIGUATOR root_three< float >(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_root_five(lua_State* L) { int SWIG_arg = 0; float result; SWIG_check_num_args("glm::root_five< float >",0,0) + result = (float)glm::SWIGTEMPLATEDISAMBIGUATOR root_five< float >(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_ln_two(lua_State* L) { int SWIG_arg = 0; float result; SWIG_check_num_args("glm::ln_two< float >",0,0) + result = (float)glm::SWIGTEMPLATEDISAMBIGUATOR ln_two< float >(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_ln_ten(lua_State* L) { int SWIG_arg = 0; float result; SWIG_check_num_args("glm::ln_ten< float >",0,0) + result = (float)glm::SWIGTEMPLATEDISAMBIGUATOR ln_ten< float >(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_ln_ln_two(lua_State* L) { int SWIG_arg = 0; float result; SWIG_check_num_args("glm::ln_ln_two< float >",0,0) + result = (float)glm::SWIGTEMPLATEDISAMBIGUATOR ln_ln_two< float >(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_third(lua_State* L) { int SWIG_arg = 0; float result; SWIG_check_num_args("glm::third< float >",0,0) + result = (float)glm::SWIGTEMPLATEDISAMBIGUATOR third< float >(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_two_thirds(lua_State* L) { int SWIG_arg = 0; float result; SWIG_check_num_args("glm::two_thirds< float >",0,0) + result = (float)glm::SWIGTEMPLATEDISAMBIGUATOR two_thirds< float >(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_golden_ratio(lua_State* L) { int SWIG_arg = 0; float result; + SWIG_check_num_args("glm::golden_ratio< float >",0,0) result = (float)glm::SWIGTEMPLATEDISAMBIGUATOR golden_ratio< float >(); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_abs__SWIG_0(lua_State* L) { int SWIG_arg = 0; float *arg1 = 0 ; float temp1 ; float result; + SWIG_check_num_args("glm::abs",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::abs",1,"float const &"); + temp1=(float)lua_tonumber(L,1); arg1=&temp1; result = (float)glm::abs((float const &)*arg1); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_abs__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = 0 ; glm::vec2 result; + SWIG_check_num_args("glm::abs",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::abs",1,"glm::vec2 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("abs",1,SWIGTYPE_p_glm__vec2); } + result = glm::abs((glm::vec2 const &)*arg1); { glm::vec2 * resultptr = new glm::vec2((const glm::vec2 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_abs__SWIG_2(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; glm::vec3 result; + SWIG_check_num_args("glm::abs",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::abs",1,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("abs",1,SWIGTYPE_p_glm__vec3); } + result = glm::abs((glm::vec3 const &)*arg1); { glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_abs__SWIG_3(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = 0 ; glm::vec4 result; + SWIG_check_num_args("glm::abs",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::abs",1,"glm::vec4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("abs",1,SWIGTYPE_p_glm__vec4); } + result = glm::abs((glm::vec4 const &)*arg1); { glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_abs(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v = 0; { { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_abs__SWIG_1(L);} check_1: if (argc == 1) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_abs__SWIG_2(L);} check_2: if (argc == 1) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; return _wrap_abs__SWIG_3(L);} check_3: if (argc == 1) { + return _wrap_abs__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'abs'\n" + " Possible C/C++ prototypes are:\n" " glm::abs(float const &)\n" " glm::abs(glm::vec2 const &)\n" + " glm::abs(glm::vec3 const &)\n" " glm::abs(glm::vec4 const &)\n"); lua_error(L);return 0; } +static int _wrap_sign__SWIG_0(lua_State* L) { int SWIG_arg = 0; float *arg1 = 0 ; float temp1 ; float result; + SWIG_check_num_args("glm::sign",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::sign",1,"float const &"); + temp1=(float)lua_tonumber(L,1); arg1=&temp1; result = (float)glm::sign((float const &)*arg1); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_sign__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = 0 ; glm::vec2 result; + SWIG_check_num_args("glm::sign",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::sign",1,"glm::vec2 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("sign",1,SWIGTYPE_p_glm__vec2); } + result = glm::sign((glm::vec2 const &)*arg1); { glm::vec2 * resultptr = new glm::vec2((const glm::vec2 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_sign__SWIG_2(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; glm::vec3 result; + SWIG_check_num_args("glm::sign",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::sign",1,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("sign",1,SWIGTYPE_p_glm__vec3); } + result = glm::sign((glm::vec3 const &)*arg1); { glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_sign__SWIG_3(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = 0 ; glm::vec4 result; + SWIG_check_num_args("glm::sign",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::sign",1,"glm::vec4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("sign",1,SWIGTYPE_p_glm__vec4); } + result = glm::sign((glm::vec4 const &)*arg1); { glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_sign(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v = 0; { { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_sign__SWIG_1(L);} check_1: if (argc == 1) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_sign__SWIG_2(L);} check_2: if (argc == 1) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; return _wrap_sign__SWIG_3(L);} check_3: if (argc == 1) { + return _wrap_sign__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'sign'\n" + " Possible C/C++ prototypes are:\n" " glm::sign(float const &)\n" " glm::sign(glm::vec2 const &)\n" + " glm::sign(glm::vec3 const &)\n" " glm::sign(glm::vec4 const &)\n"); lua_error(L);return 0; } +static int _wrap_floor__SWIG_0(lua_State* L) { int SWIG_arg = 0; float *arg1 = 0 ; float temp1 ; float result; + SWIG_check_num_args("glm::floor",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::floor",1,"float const &"); + temp1=(float)lua_tonumber(L,1); arg1=&temp1; result = (float)glm::floor((float const &)*arg1); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_floor__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = 0 ; glm::vec2 result; + SWIG_check_num_args("glm::floor",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::floor",1,"glm::vec2 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("floor",1,SWIGTYPE_p_glm__vec2); } + result = glm::floor((glm::vec2 const &)*arg1); { glm::vec2 * resultptr = new glm::vec2((const glm::vec2 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_floor__SWIG_2(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; glm::vec3 result; + SWIG_check_num_args("glm::floor",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::floor",1,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("floor",1,SWIGTYPE_p_glm__vec3); } + result = glm::floor((glm::vec3 const &)*arg1); { glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_floor__SWIG_3(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = 0 ; glm::vec4 result; + SWIG_check_num_args("glm::floor",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::floor",1,"glm::vec4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("floor",1,SWIGTYPE_p_glm__vec4); } + result = glm::floor((glm::vec4 const &)*arg1); { glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_floor(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v = 0; { { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_floor__SWIG_1(L);} check_1: if (argc == 1) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_floor__SWIG_2(L);} check_2: if (argc == 1) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; return _wrap_floor__SWIG_3(L);} check_3: if (argc == 1) { + return _wrap_floor__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'floor'\n" + " Possible C/C++ prototypes are:\n" " glm::floor(float const &)\n" " glm::floor(glm::vec2 const &)\n" + " glm::floor(glm::vec3 const &)\n" " glm::floor(glm::vec4 const &)\n"); lua_error(L);return 0; } +static int _wrap_trunc__SWIG_0(lua_State* L) { int SWIG_arg = 0; float *arg1 = 0 ; float temp1 ; float result; + SWIG_check_num_args("glm::trunc",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::trunc",1,"float const &"); + temp1=(float)lua_tonumber(L,1); arg1=&temp1; result = (float)glm::trunc((float const &)*arg1); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_trunc__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = 0 ; glm::vec2 result; + SWIG_check_num_args("glm::trunc",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::trunc",1,"glm::vec2 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("trunc",1,SWIGTYPE_p_glm__vec2); } + result = glm::trunc((glm::vec2 const &)*arg1); { glm::vec2 * resultptr = new glm::vec2((const glm::vec2 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_trunc__SWIG_2(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; glm::vec3 result; + SWIG_check_num_args("glm::trunc",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::trunc",1,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("trunc",1,SWIGTYPE_p_glm__vec3); } + result = glm::trunc((glm::vec3 const &)*arg1); { glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_trunc__SWIG_3(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = 0 ; glm::vec4 result; + SWIG_check_num_args("glm::trunc",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::trunc",1,"glm::vec4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("trunc",1,SWIGTYPE_p_glm__vec4); } + result = glm::trunc((glm::vec4 const &)*arg1); { glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_trunc(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v = 0; { { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_trunc__SWIG_1(L);} check_1: if (argc == 1) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_trunc__SWIG_2(L);} check_2: if (argc == 1) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; return _wrap_trunc__SWIG_3(L);} check_3: if (argc == 1) { + return _wrap_trunc__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'trunc'\n" + " Possible C/C++ prototypes are:\n" " glm::trunc(float const &)\n" " glm::trunc(glm::vec2 const &)\n" + " glm::trunc(glm::vec3 const &)\n" " glm::trunc(glm::vec4 const &)\n"); lua_error(L);return 0; } +static int _wrap_round__SWIG_0(lua_State* L) { int SWIG_arg = 0; float *arg1 = 0 ; float temp1 ; float result; + SWIG_check_num_args("glm::round",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::round",1,"float const &"); + temp1=(float)lua_tonumber(L,1); arg1=&temp1; result = (float)glm::round((float const &)*arg1); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_round__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = 0 ; glm::vec2 result; + SWIG_check_num_args("glm::round",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::round",1,"glm::vec2 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("round",1,SWIGTYPE_p_glm__vec2); } + result = glm::round((glm::vec2 const &)*arg1); { glm::vec2 * resultptr = new glm::vec2((const glm::vec2 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_round__SWIG_2(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; glm::vec3 result; + SWIG_check_num_args("glm::round",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::round",1,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("round",1,SWIGTYPE_p_glm__vec3); } + result = glm::round((glm::vec3 const &)*arg1); { glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_round__SWIG_3(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = 0 ; glm::vec4 result; + SWIG_check_num_args("glm::round",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::round",1,"glm::vec4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("round",1,SWIGTYPE_p_glm__vec4); } + result = glm::round((glm::vec4 const &)*arg1); { glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_round(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v = 0; { { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_round__SWIG_1(L);} check_1: if (argc == 1) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_round__SWIG_2(L);} check_2: if (argc == 1) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; return _wrap_round__SWIG_3(L);} check_3: if (argc == 1) { + return _wrap_round__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'round'\n" + " Possible C/C++ prototypes are:\n" " glm::round(float const &)\n" " glm::round(glm::vec2 const &)\n" + " glm::round(glm::vec3 const &)\n" " glm::round(glm::vec4 const &)\n"); lua_error(L);return 0; } +static int _wrap_roundEven__SWIG_0(lua_State* L) { int SWIG_arg = 0; float *arg1 = 0 ; float temp1 ; float result; + SWIG_check_num_args("glm::roundEven",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::roundEven",1,"float const &"); + temp1=(float)lua_tonumber(L,1); arg1=&temp1; result = (float)glm::roundEven((float const &)*arg1); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_roundEven__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = 0 ; glm::vec2 result; + SWIG_check_num_args("glm::roundEven",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::roundEven",1,"glm::vec2 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ + SWIG_fail_ptr("roundEven",1,SWIGTYPE_p_glm__vec2); } result = glm::roundEven((glm::vec2 const &)*arg1); { + glm::vec2 * resultptr = new glm::vec2((const glm::vec2 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_roundEven__SWIG_2(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; glm::vec3 result; + SWIG_check_num_args("glm::roundEven",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::roundEven",1,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ + SWIG_fail_ptr("roundEven",1,SWIGTYPE_p_glm__vec3); } result = glm::roundEven((glm::vec3 const &)*arg1); { + glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_roundEven__SWIG_3(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = 0 ; glm::vec4 result; + SWIG_check_num_args("glm::roundEven",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::roundEven",1,"glm::vec4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ + SWIG_fail_ptr("roundEven",1,SWIGTYPE_p_glm__vec4); } result = glm::roundEven((glm::vec4 const &)*arg1); { + glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_roundEven(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v = 0; { { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_roundEven__SWIG_1(L);} check_1: + if (argc == 1) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_roundEven__SWIG_2(L);} check_2: + if (argc == 1) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; return _wrap_roundEven__SWIG_3(L);} check_3: + if (argc == 1) { return _wrap_roundEven__SWIG_0(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'roundEven'\n" " Possible C/C++ prototypes are:\n" + " glm::roundEven(float const &)\n" " glm::roundEven(glm::vec2 const &)\n" " glm::roundEven(glm::vec3 const &)\n" + " glm::roundEven(glm::vec4 const &)\n"); lua_error(L);return 0; } +static int _wrap_ceil__SWIG_0(lua_State* L) { int SWIG_arg = 0; float *arg1 = 0 ; float temp1 ; float result; + SWIG_check_num_args("glm::ceil",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::ceil",1,"float const &"); + temp1=(float)lua_tonumber(L,1); arg1=&temp1; result = (float)glm::ceil((float const &)*arg1); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_ceil__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = 0 ; glm::vec2 result; + SWIG_check_num_args("glm::ceil",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::ceil",1,"glm::vec2 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("ceil",1,SWIGTYPE_p_glm__vec2); } + result = glm::ceil((glm::vec2 const &)*arg1); { glm::vec2 * resultptr = new glm::vec2((const glm::vec2 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_ceil__SWIG_2(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; glm::vec3 result; + SWIG_check_num_args("glm::ceil",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::ceil",1,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("ceil",1,SWIGTYPE_p_glm__vec3); } + result = glm::ceil((glm::vec3 const &)*arg1); { glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_ceil__SWIG_3(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = 0 ; glm::vec4 result; + SWIG_check_num_args("glm::ceil",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::ceil",1,"glm::vec4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("ceil",1,SWIGTYPE_p_glm__vec4); } + result = glm::ceil((glm::vec4 const &)*arg1); { glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_ceil(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v = 0; { { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_ceil__SWIG_1(L);} check_1: if (argc == 1) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_ceil__SWIG_2(L);} check_2: if (argc == 1) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; return _wrap_ceil__SWIG_3(L);} check_3: if (argc == 1) { + return _wrap_ceil__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ceil'\n" + " Possible C/C++ prototypes are:\n" " glm::ceil(float const &)\n" " glm::ceil(glm::vec2 const &)\n" + " glm::ceil(glm::vec3 const &)\n" " glm::ceil(glm::vec4 const &)\n"); lua_error(L);return 0; } +static int _wrap_fract__SWIG_0(lua_State* L) { int SWIG_arg = 0; float *arg1 = 0 ; float temp1 ; float result; + SWIG_check_num_args("glm::fract",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::fract",1,"float const &"); + temp1=(float)lua_tonumber(L,1); arg1=&temp1; result = (float)glm::fract((float const &)*arg1); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_fract__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = 0 ; glm::vec2 result; + SWIG_check_num_args("glm::fract",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::fract",1,"glm::vec2 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("fract",1,SWIGTYPE_p_glm__vec2); } + result = glm::fract((glm::vec2 const &)*arg1); { glm::vec2 * resultptr = new glm::vec2((const glm::vec2 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_fract__SWIG_2(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; glm::vec3 result; + SWIG_check_num_args("glm::fract",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::fract",1,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("fract",1,SWIGTYPE_p_glm__vec3); } + result = glm::fract((glm::vec3 const &)*arg1); { glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_fract__SWIG_3(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = 0 ; glm::vec4 result; + SWIG_check_num_args("glm::fract",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::fract",1,"glm::vec4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("fract",1,SWIGTYPE_p_glm__vec4); } + result = glm::fract((glm::vec4 const &)*arg1); { glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_fract(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v = 0; { { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_fract__SWIG_1(L);} check_1: if (argc == 1) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_fract__SWIG_2(L);} check_2: if (argc == 1) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; return _wrap_fract__SWIG_3(L);} check_3: if (argc == 1) { + return _wrap_fract__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'fract'\n" + " Possible C/C++ prototypes are:\n" " glm::fract(float const &)\n" " glm::fract(glm::vec2 const &)\n" + " glm::fract(glm::vec3 const &)\n" " glm::fract(glm::vec4 const &)\n"); lua_error(L);return 0; } +static int _wrap_mod__SWIG_0(lua_State* L) { int SWIG_arg = 0; float *arg1 = 0 ; float *arg2 = 0 ; float temp1 ; float temp2 ; + float result; SWIG_check_num_args("glm::mod",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::mod",1,"float const &"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::mod",2,"float const &"); temp1=(float)lua_tonumber(L,1); arg1=&temp1; + temp2=(float)lua_tonumber(L,2); arg2=&temp2; result = (float)glm::mod((float const &)*arg1,(float const &)*arg2); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_mod__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = 0 ; glm::vec2 *arg2 = 0 ; glm::vec2 result; + SWIG_check_num_args("glm::mod",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::mod",1,"glm::vec2 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::mod",2,"glm::vec2 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("mod",1,SWIGTYPE_p_glm__vec2); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("mod",2,SWIGTYPE_p_glm__vec2); } + result = glm::mod((glm::vec2 const &)*arg1,(glm::vec2 const &)*arg2); { + glm::vec2 * resultptr = new glm::vec2((const glm::vec2 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_mod__SWIG_2(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; glm::vec3 *arg2 = 0 ; glm::vec3 result; + SWIG_check_num_args("glm::mod",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::mod",1,"glm::vec3 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::mod",2,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("mod",1,SWIGTYPE_p_glm__vec3); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("mod",2,SWIGTYPE_p_glm__vec3); } + result = glm::mod((glm::vec3 const &)*arg1,(glm::vec3 const &)*arg2); { + glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_mod__SWIG_3(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = 0 ; glm::vec4 *arg2 = 0 ; glm::vec4 result; + SWIG_check_num_args("glm::mod",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::mod",1,"glm::vec4 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::mod",2,"glm::vec4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("mod",1,SWIGTYPE_p_glm__vec4); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("mod",2,SWIGTYPE_p_glm__vec4); } + result = glm::mod((glm::vec4 const &)*arg1,(glm::vec4 const &)*arg2); { + glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_mod__SWIG_4(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = 0 ; float *arg2 = 0 ; float temp2 ; + glm::vec2 result; SWIG_check_num_args("glm::mod",2,2) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::mod",1,"glm::vec2 const &"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::mod",2,"float const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("mod",1,SWIGTYPE_p_glm__vec2); } + temp2=(float)lua_tonumber(L,2); arg2=&temp2; result = glm::mod((glm::vec2 const &)*arg1,(float const &)*arg2); { + glm::vec2 * resultptr = new glm::vec2((const glm::vec2 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_mod__SWIG_5(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; float *arg2 = 0 ; float temp2 ; + glm::vec3 result; SWIG_check_num_args("glm::mod",2,2) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::mod",1,"glm::vec3 const &"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::mod",2,"float const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("mod",1,SWIGTYPE_p_glm__vec3); } + temp2=(float)lua_tonumber(L,2); arg2=&temp2; result = glm::mod((glm::vec3 const &)*arg1,(float const &)*arg2); { + glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_mod__SWIG_6(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = 0 ; float *arg2 = 0 ; float temp2 ; + glm::vec4 result; SWIG_check_num_args("glm::mod",2,2) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::mod",1,"glm::vec4 const &"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::mod",2,"float const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("mod",1,SWIGTYPE_p_glm__vec4); } + temp2=(float)lua_tonumber(L,2); arg2=&temp2; result = glm::mod((glm::vec4 const &)*arg1,(float const &)*arg2); { + glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_mod(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v = 0; { { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_mod__SWIG_1(L);} check_1: if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_mod__SWIG_2(L);} check_2: if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; return _wrap_mod__SWIG_3(L);} check_3: if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_4; return _wrap_mod__SWIG_4(L);} check_4: if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_5; return _wrap_mod__SWIG_5(L);} check_5: if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_6; return _wrap_mod__SWIG_6(L);} check_6: if (argc == 2) { + return _wrap_mod__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'mod'\n" + " Possible C/C++ prototypes are:\n" " glm::mod(float const &,float const &)\n" + " glm::mod(glm::vec2 const &,glm::vec2 const &)\n" " glm::mod(glm::vec3 const &,glm::vec3 const &)\n" + " glm::mod(glm::vec4 const &,glm::vec4 const &)\n" " glm::mod(glm::vec2 const &,float const &)\n" + " glm::mod(glm::vec3 const &,float const &)\n" " glm::mod(glm::vec4 const &,float const &)\n"); lua_error(L);return 0; } +static int _wrap_modf__SWIG_0(lua_State* L) { int SWIG_arg = 0; float *arg1 = 0 ; float *arg2 = 0 ; float temp1 ; float result; + SWIG_check_num_args("glm::modf",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::modf",1,"float const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::modf",2,"float &"); temp1=(float)lua_tonumber(L,1); arg1=&temp1; + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_float,0))){ SWIG_fail_ptr("modf",2,SWIGTYPE_p_float); } + result = (float)glm::modf((float const &)*arg1,*arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; + if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_modf__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = 0 ; glm::vec2 *arg2 = 0 ; glm::vec2 result; + SWIG_check_num_args("glm::modf",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::modf",1,"glm::vec2 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::modf",2,"glm::vec2 &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("modf",1,SWIGTYPE_p_glm__vec2); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("modf",2,SWIGTYPE_p_glm__vec2); } + result = glm::modf((glm::vec2 const &)*arg1,*arg2); { glm::vec2 * resultptr = new glm::vec2((const glm::vec2 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_modf__SWIG_2(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; glm::vec3 *arg2 = 0 ; glm::vec3 result; + SWIG_check_num_args("glm::modf",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::modf",1,"glm::vec3 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::modf",2,"glm::vec3 &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("modf",1,SWIGTYPE_p_glm__vec3); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("modf",2,SWIGTYPE_p_glm__vec3); } + result = glm::modf((glm::vec3 const &)*arg1,*arg2); { glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_modf__SWIG_3(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = 0 ; glm::vec4 *arg2 = 0 ; glm::vec4 result; + SWIG_check_num_args("glm::modf",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::modf",1,"glm::vec4 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::modf",2,"glm::vec4 &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("modf",1,SWIGTYPE_p_glm__vec4); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("modf",2,SWIGTYPE_p_glm__vec4); } + result = glm::modf((glm::vec4 const &)*arg1,*arg2); { glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_modf(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v = 0; { { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_modf__SWIG_1(L);} check_1: if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_modf__SWIG_2(L);} check_2: if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; return _wrap_modf__SWIG_3(L);} check_3: if (argc == 2) { + return _wrap_modf__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'modf'\n" + " Possible C/C++ prototypes are:\n" " glm::modf(float const &,float &)\n" " glm::modf(glm::vec2 const &,glm::vec2 &)\n" + " glm::modf(glm::vec3 const &,glm::vec3 &)\n" " glm::modf(glm::vec4 const &,glm::vec4 &)\n"); lua_error(L);return 0; } +static int _wrap_min__SWIG_0(lua_State* L) { int SWIG_arg = 0; float *arg1 = 0 ; float *arg2 = 0 ; float temp1 ; float temp2 ; + float result; SWIG_check_num_args("glm::min",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::min",1,"float const &"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::min",2,"float const &"); temp1=(float)lua_tonumber(L,1); arg1=&temp1; + temp2=(float)lua_tonumber(L,2); arg2=&temp2; result = (float)glm::min((float const &)*arg1,(float const &)*arg2); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_min__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = 0 ; glm::vec2 *arg2 = 0 ; glm::vec2 result; + SWIG_check_num_args("glm::min",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::min",1,"glm::vec2 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::min",2,"glm::vec2 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("min",1,SWIGTYPE_p_glm__vec2); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("min",2,SWIGTYPE_p_glm__vec2); } + result = glm::min((glm::vec2 const &)*arg1,(glm::vec2 const &)*arg2); { + glm::vec2 * resultptr = new glm::vec2((const glm::vec2 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_min__SWIG_2(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; glm::vec3 *arg2 = 0 ; glm::vec3 result; + SWIG_check_num_args("glm::min",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::min",1,"glm::vec3 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::min",2,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("min",1,SWIGTYPE_p_glm__vec3); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("min",2,SWIGTYPE_p_glm__vec3); } + result = glm::min((glm::vec3 const &)*arg1,(glm::vec3 const &)*arg2); { + glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_min__SWIG_3(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = 0 ; glm::vec4 *arg2 = 0 ; glm::vec4 result; + SWIG_check_num_args("glm::min",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::min",1,"glm::vec4 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::min",2,"glm::vec4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("min",1,SWIGTYPE_p_glm__vec4); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("min",2,SWIGTYPE_p_glm__vec4); } + result = glm::min((glm::vec4 const &)*arg1,(glm::vec4 const &)*arg2); { + glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_min__SWIG_4(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = 0 ; float *arg2 = 0 ; float temp2 ; + glm::vec2 result; SWIG_check_num_args("glm::min",2,2) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::min",1,"glm::vec2 const &"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::min",2,"float const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("min",1,SWIGTYPE_p_glm__vec2); } + temp2=(float)lua_tonumber(L,2); arg2=&temp2; result = glm::min((glm::vec2 const &)*arg1,(float const &)*arg2); { + glm::vec2 * resultptr = new glm::vec2((const glm::vec2 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_min__SWIG_5(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; float *arg2 = 0 ; float temp2 ; + glm::vec3 result; SWIG_check_num_args("glm::min",2,2) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::min",1,"glm::vec3 const &"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::min",2,"float const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("min",1,SWIGTYPE_p_glm__vec3); } + temp2=(float)lua_tonumber(L,2); arg2=&temp2; result = glm::min((glm::vec3 const &)*arg1,(float const &)*arg2); { + glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_min__SWIG_6(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = 0 ; float *arg2 = 0 ; float temp2 ; + glm::vec4 result; SWIG_check_num_args("glm::min",2,2) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::min",1,"glm::vec4 const &"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::min",2,"float const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("min",1,SWIGTYPE_p_glm__vec4); } + temp2=(float)lua_tonumber(L,2); arg2=&temp2; result = glm::min((glm::vec4 const &)*arg1,(float const &)*arg2); { + glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_min(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v = 0; { { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_min__SWIG_1(L);} check_1: if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_min__SWIG_2(L);} check_2: if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; return _wrap_min__SWIG_3(L);} check_3: if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_4; return _wrap_min__SWIG_4(L);} check_4: if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_5; return _wrap_min__SWIG_5(L);} check_5: if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_6; return _wrap_min__SWIG_6(L);} check_6: if (argc == 2) { + return _wrap_min__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'min'\n" + " Possible C/C++ prototypes are:\n" " glm::min(float const &,float const &)\n" + " glm::min(glm::vec2 const &,glm::vec2 const &)\n" " glm::min(glm::vec3 const &,glm::vec3 const &)\n" + " glm::min(glm::vec4 const &,glm::vec4 const &)\n" " glm::min(glm::vec2 const &,float const &)\n" + " glm::min(glm::vec3 const &,float const &)\n" " glm::min(glm::vec4 const &,float const &)\n"); lua_error(L);return 0; } +static int _wrap_max__SWIG_0(lua_State* L) { int SWIG_arg = 0; float *arg1 = 0 ; float *arg2 = 0 ; float temp1 ; float temp2 ; + float result; SWIG_check_num_args("glm::max",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::max",1,"float const &"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::max",2,"float const &"); temp1=(float)lua_tonumber(L,1); arg1=&temp1; + temp2=(float)lua_tonumber(L,2); arg2=&temp2; result = (float)glm::max((float const &)*arg1,(float const &)*arg2); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_max__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = 0 ; glm::vec2 *arg2 = 0 ; glm::vec2 result; + SWIG_check_num_args("glm::max",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::max",1,"glm::vec2 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::max",2,"glm::vec2 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("max",1,SWIGTYPE_p_glm__vec2); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("max",2,SWIGTYPE_p_glm__vec2); } + result = glm::max((glm::vec2 const &)*arg1,(glm::vec2 const &)*arg2); { + glm::vec2 * resultptr = new glm::vec2((const glm::vec2 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_max__SWIG_2(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; glm::vec3 *arg2 = 0 ; glm::vec3 result; + SWIG_check_num_args("glm::max",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::max",1,"glm::vec3 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::max",2,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("max",1,SWIGTYPE_p_glm__vec3); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("max",2,SWIGTYPE_p_glm__vec3); } + result = glm::max((glm::vec3 const &)*arg1,(glm::vec3 const &)*arg2); { + glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_max__SWIG_3(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = 0 ; glm::vec4 *arg2 = 0 ; glm::vec4 result; + SWIG_check_num_args("glm::max",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::max",1,"glm::vec4 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::max",2,"glm::vec4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("max",1,SWIGTYPE_p_glm__vec4); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("max",2,SWIGTYPE_p_glm__vec4); } + result = glm::max((glm::vec4 const &)*arg1,(glm::vec4 const &)*arg2); { + glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_max__SWIG_4(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = 0 ; float *arg2 = 0 ; float temp2 ; + glm::vec2 result; SWIG_check_num_args("glm::max",2,2) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::max",1,"glm::vec2 const &"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::max",2,"float const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("max",1,SWIGTYPE_p_glm__vec2); } + temp2=(float)lua_tonumber(L,2); arg2=&temp2; result = glm::max((glm::vec2 const &)*arg1,(float const &)*arg2); { + glm::vec2 * resultptr = new glm::vec2((const glm::vec2 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_max__SWIG_5(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; float *arg2 = 0 ; float temp2 ; + glm::vec3 result; SWIG_check_num_args("glm::max",2,2) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::max",1,"glm::vec3 const &"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::max",2,"float const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("max",1,SWIGTYPE_p_glm__vec3); } + temp2=(float)lua_tonumber(L,2); arg2=&temp2; result = glm::max((glm::vec3 const &)*arg1,(float const &)*arg2); { + glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_max__SWIG_6(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = 0 ; float *arg2 = 0 ; float temp2 ; + glm::vec4 result; SWIG_check_num_args("glm::max",2,2) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::max",1,"glm::vec4 const &"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::max",2,"float const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("max",1,SWIGTYPE_p_glm__vec4); } + temp2=(float)lua_tonumber(L,2); arg2=&temp2; result = glm::max((glm::vec4 const &)*arg1,(float const &)*arg2); { + glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_max(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v = 0; { { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_max__SWIG_1(L);} check_1: if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_max__SWIG_2(L);} check_2: if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; return _wrap_max__SWIG_3(L);} check_3: if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_4; return _wrap_max__SWIG_4(L);} check_4: if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_5; return _wrap_max__SWIG_5(L);} check_5: if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_6; return _wrap_max__SWIG_6(L);} check_6: if (argc == 2) { + return _wrap_max__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'max'\n" + " Possible C/C++ prototypes are:\n" " glm::max(float const &,float const &)\n" + " glm::max(glm::vec2 const &,glm::vec2 const &)\n" " glm::max(glm::vec3 const &,glm::vec3 const &)\n" + " glm::max(glm::vec4 const &,glm::vec4 const &)\n" " glm::max(glm::vec2 const &,float const &)\n" + " glm::max(glm::vec3 const &,float const &)\n" " glm::max(glm::vec4 const &,float const &)\n"); lua_error(L);return 0; } +static int _wrap_clamp__SWIG_0(lua_State* L) { int SWIG_arg = 0; float *arg1 = 0 ; float *arg2 = 0 ; float *arg3 = 0 ; + float temp1 ; float temp2 ; float temp3 ; float result; SWIG_check_num_args("glm::clamp",3,3) + if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::clamp",1,"float const &"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::clamp",2,"float const &"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("glm::clamp",3,"float const &"); temp1=(float)lua_tonumber(L,1); arg1=&temp1; + temp2=(float)lua_tonumber(L,2); arg2=&temp2; temp3=(float)lua_tonumber(L,3); arg3=&temp3; + result = (float)glm::clamp((float const &)*arg1,(float const &)*arg2,(float const &)*arg3); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_clamp__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = 0 ; glm::vec2 *arg2 = 0 ; + glm::vec2 *arg3 = 0 ; glm::vec2 result; SWIG_check_num_args("glm::clamp",3,3) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::clamp",1,"glm::vec2 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::clamp",2,"glm::vec2 const &"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("glm::clamp",3,"glm::vec2 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("clamp",1,SWIGTYPE_p_glm__vec2); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("clamp",2,SWIGTYPE_p_glm__vec2); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("clamp",3,SWIGTYPE_p_glm__vec2); } + result = glm::clamp((glm::vec2 const &)*arg1,(glm::vec2 const &)*arg2,(glm::vec2 const &)*arg3); { + glm::vec2 * resultptr = new glm::vec2((const glm::vec2 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_clamp__SWIG_2(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; glm::vec3 *arg2 = 0 ; + glm::vec3 *arg3 = 0 ; glm::vec3 result; SWIG_check_num_args("glm::clamp",3,3) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::clamp",1,"glm::vec3 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::clamp",2,"glm::vec3 const &"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("glm::clamp",3,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("clamp",1,SWIGTYPE_p_glm__vec3); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("clamp",2,SWIGTYPE_p_glm__vec3); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("clamp",3,SWIGTYPE_p_glm__vec3); } + result = glm::clamp((glm::vec3 const &)*arg1,(glm::vec3 const &)*arg2,(glm::vec3 const &)*arg3); { + glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_clamp__SWIG_3(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = 0 ; glm::vec4 *arg2 = 0 ; + glm::vec4 *arg3 = 0 ; glm::vec4 result; SWIG_check_num_args("glm::clamp",3,3) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::clamp",1,"glm::vec4 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::clamp",2,"glm::vec4 const &"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("glm::clamp",3,"glm::vec4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("clamp",1,SWIGTYPE_p_glm__vec4); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("clamp",2,SWIGTYPE_p_glm__vec4); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("clamp",3,SWIGTYPE_p_glm__vec4); } + result = glm::clamp((glm::vec4 const &)*arg1,(glm::vec4 const &)*arg2,(glm::vec4 const &)*arg3); { + glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_clamp__SWIG_4(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = 0 ; float *arg2 = 0 ; float *arg3 = 0 ; + float temp2 ; float temp3 ; glm::vec2 result; SWIG_check_num_args("glm::clamp",3,3) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::clamp",1,"glm::vec2 const &"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::clamp",2,"float const &"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("glm::clamp",3,"float const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("clamp",1,SWIGTYPE_p_glm__vec2); } + temp2=(float)lua_tonumber(L,2); arg2=&temp2; temp3=(float)lua_tonumber(L,3); arg3=&temp3; + result = glm::clamp((glm::vec2 const &)*arg1,(float const &)*arg2,(float const &)*arg3); { + glm::vec2 * resultptr = new glm::vec2((const glm::vec2 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_clamp__SWIG_5(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; float *arg2 = 0 ; float *arg3 = 0 ; + float temp2 ; float temp3 ; glm::vec3 result; SWIG_check_num_args("glm::clamp",3,3) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::clamp",1,"glm::vec3 const &"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::clamp",2,"float const &"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("glm::clamp",3,"float const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("clamp",1,SWIGTYPE_p_glm__vec3); } + temp2=(float)lua_tonumber(L,2); arg2=&temp2; temp3=(float)lua_tonumber(L,3); arg3=&temp3; + result = glm::clamp((glm::vec3 const &)*arg1,(float const &)*arg2,(float const &)*arg3); { + glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_clamp__SWIG_6(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = 0 ; float *arg2 = 0 ; float *arg3 = 0 ; + float temp2 ; float temp3 ; glm::vec4 result; SWIG_check_num_args("glm::clamp",3,3) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::clamp",1,"glm::vec4 const &"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::clamp",2,"float const &"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("glm::clamp",3,"float const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("clamp",1,SWIGTYPE_p_glm__vec4); } + temp2=(float)lua_tonumber(L,2); arg2=&temp2; temp3=(float)lua_tonumber(L,3); arg3=&temp3; + result = glm::clamp((glm::vec4 const &)*arg1,(float const &)*arg2,(float const &)*arg3); { + glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_clamp(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 3) { int _v = 0; { { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; { { void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_clamp__SWIG_1(L);} check_1: if (argc == 3) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; { { void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_clamp__SWIG_2(L);} check_2: if (argc == 3) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; { { void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; return _wrap_clamp__SWIG_3(L);} check_3: if (argc == 3) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_4; return _wrap_clamp__SWIG_4(L);} check_4: if (argc == 3) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_5; return _wrap_clamp__SWIG_5(L);} check_5: if (argc == 3) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_6; return _wrap_clamp__SWIG_6(L);} check_6: if (argc == 3) { + return _wrap_clamp__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'clamp'\n" + " Possible C/C++ prototypes are:\n" " glm::clamp(float const &,float const &,float const &)\n" + " glm::clamp(glm::vec2 const &,glm::vec2 const &,glm::vec2 const &)\n" + " glm::clamp(glm::vec3 const &,glm::vec3 const &,glm::vec3 const &)\n" + " glm::clamp(glm::vec4 const &,glm::vec4 const &,glm::vec4 const &)\n" + " glm::clamp(glm::vec2 const &,float const &,float const &)\n" + " glm::clamp(glm::vec3 const &,float const &,float const &)\n" + " glm::clamp(glm::vec4 const &,float const &,float const &)\n"); lua_error(L);return 0; } +static int _wrap_mix__SWIG_1(lua_State* L) { int SWIG_arg = 0; float *arg1 = 0 ; float *arg2 = 0 ; float *arg3 = 0 ; + float temp1 ; float temp2 ; float temp3 ; float result; SWIG_check_num_args("glm::mix",3,3) + if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::mix",1,"float const &"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::mix",2,"float const &"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("glm::mix",3,"float const &"); temp1=(float)lua_tonumber(L,1); arg1=&temp1; + temp2=(float)lua_tonumber(L,2); arg2=&temp2; temp3=(float)lua_tonumber(L,3); arg3=&temp3; + result = (float)glm::mix((float const &)*arg1,(float const &)*arg2,(float const &)*arg3); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_mix__SWIG_2(lua_State* L) { int SWIG_arg = 0; float *arg1 = 0 ; float *arg2 = 0 ; bool *arg3 = 0 ; + float temp1 ; float temp2 ; bool temp3 ; float result; SWIG_check_num_args("glm::mix",3,3) + if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::mix",1,"float const &"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::mix",2,"float const &"); + if(!lua_isboolean(L,3)) SWIG_fail_arg("glm::mix",3,"bool const &"); temp1=(float)lua_tonumber(L,1); arg1=&temp1; + temp2=(float)lua_tonumber(L,2); arg2=&temp2; temp3=(lua_toboolean(L, 3)!=0); arg3=&temp3; + result = (float)glm::mix((float const &)*arg1,(float const &)*arg2,(bool const &)*arg3); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_mix__SWIG_3(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = 0 ; glm::vec2 *arg2 = 0 ; glm::vec2 *arg3 = 0 ; + glm::vec2 result; SWIG_check_num_args("glm::mix",3,3) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::mix",1,"glm::vec2 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::mix",2,"glm::vec2 const &"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("glm::mix",3,"glm::vec2 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("mix",1,SWIGTYPE_p_glm__vec2); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("mix",2,SWIGTYPE_p_glm__vec2); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("mix",3,SWIGTYPE_p_glm__vec2); } + result = glm::mix((glm::vec2 const &)*arg1,(glm::vec2 const &)*arg2,(glm::vec2 const &)*arg3); { + glm::vec2 * resultptr = new glm::vec2((const glm::vec2 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_mix__SWIG_4(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; glm::vec3 *arg2 = 0 ; glm::vec3 *arg3 = 0 ; + glm::vec3 result; SWIG_check_num_args("glm::mix",3,3) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::mix",1,"glm::vec3 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::mix",2,"glm::vec3 const &"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("glm::mix",3,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("mix",1,SWIGTYPE_p_glm__vec3); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("mix",2,SWIGTYPE_p_glm__vec3); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("mix",3,SWIGTYPE_p_glm__vec3); } + result = glm::mix((glm::vec3 const &)*arg1,(glm::vec3 const &)*arg2,(glm::vec3 const &)*arg3); { + glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_mix__SWIG_5(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = 0 ; glm::vec4 *arg2 = 0 ; glm::vec4 *arg3 = 0 ; + glm::vec4 result; SWIG_check_num_args("glm::mix",3,3) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::mix",1,"glm::vec4 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::mix",2,"glm::vec4 const &"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("glm::mix",3,"glm::vec4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("mix",1,SWIGTYPE_p_glm__vec4); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("mix",2,SWIGTYPE_p_glm__vec4); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("mix",3,SWIGTYPE_p_glm__vec4); } + result = glm::mix((glm::vec4 const &)*arg1,(glm::vec4 const &)*arg2,(glm::vec4 const &)*arg3); { + glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_mix__SWIG_6(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = 0 ; glm::vec2 *arg2 = 0 ; bool *arg3 = 0 ; + bool temp3 ; glm::vec2 result; SWIG_check_num_args("glm::mix",3,3) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::mix",1,"glm::vec2 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::mix",2,"glm::vec2 const &"); + if(!lua_isboolean(L,3)) SWIG_fail_arg("glm::mix",3,"bool const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("mix",1,SWIGTYPE_p_glm__vec2); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("mix",2,SWIGTYPE_p_glm__vec2); } + temp3=(lua_toboolean(L, 3)!=0); arg3=&temp3; + result = glm::mix((glm::vec2 const &)*arg1,(glm::vec2 const &)*arg2,(bool const &)*arg3); { + glm::vec2 * resultptr = new glm::vec2((const glm::vec2 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_mix__SWIG_7(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; glm::vec3 *arg2 = 0 ; bool *arg3 = 0 ; + bool temp3 ; glm::vec3 result; SWIG_check_num_args("glm::mix",3,3) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::mix",1,"glm::vec3 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::mix",2,"glm::vec3 const &"); + if(!lua_isboolean(L,3)) SWIG_fail_arg("glm::mix",3,"bool const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("mix",1,SWIGTYPE_p_glm__vec3); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("mix",2,SWIGTYPE_p_glm__vec3); } + temp3=(lua_toboolean(L, 3)!=0); arg3=&temp3; + result = glm::mix((glm::vec3 const &)*arg1,(glm::vec3 const &)*arg2,(bool const &)*arg3); { + glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_mix__SWIG_8(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = 0 ; glm::vec4 *arg2 = 0 ; bool *arg3 = 0 ; + bool temp3 ; glm::vec4 result; SWIG_check_num_args("glm::mix",3,3) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::mix",1,"glm::vec4 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::mix",2,"glm::vec4 const &"); + if(!lua_isboolean(L,3)) SWIG_fail_arg("glm::mix",3,"bool const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("mix",1,SWIGTYPE_p_glm__vec4); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("mix",2,SWIGTYPE_p_glm__vec4); } + temp3=(lua_toboolean(L, 3)!=0); arg3=&temp3; + result = glm::mix((glm::vec4 const &)*arg1,(glm::vec4 const &)*arg2,(bool const &)*arg3); { + glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_mix(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 3) { int _v = 0; { { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__quat, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__quat, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; { { _v = lua_isnumber(L,argv[2]); } } if (!_v) goto check_1; + return _wrap_mix__SWIG_0(L);} check_1: if (argc == 3) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; { { void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_mix__SWIG_3(L);} check_2: if (argc == 3) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; { { void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; return _wrap_mix__SWIG_4(L);} check_3: if (argc == 3) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_4; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_4; { { void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_4; return _wrap_mix__SWIG_5(L);} check_4: if (argc == 3) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_5; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_5; { { _v = lua_isboolean(L,argv[2]); } } + if (!_v) goto check_5; return _wrap_mix__SWIG_6(L);} check_5: if (argc == 3) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_6; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_6; { { _v = lua_isboolean(L,argv[2]); } } + if (!_v) goto check_6; return _wrap_mix__SWIG_7(L);} check_6: if (argc == 3) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_7; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_7; { { _v = lua_isboolean(L,argv[2]); } } + if (!_v) goto check_7; return _wrap_mix__SWIG_8(L);} check_7: if (argc == 3) { int _v = 0; { { + _v = lua_isboolean(L,argv[2]); } } if (!_v) goto check_8; return _wrap_mix__SWIG_2(L);} check_8: if (argc == 3) { + return _wrap_mix__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'mix'\n" + " Possible C/C++ prototypes are:\n" " glm::mix(glm::quat const &,glm::quat const &,float)\n" + " glm::mix(float const &,float const &,float const &)\n" " glm::mix(float const &,float const &,bool const &)\n" + " glm::mix(glm::vec2 const &,glm::vec2 const &,glm::vec2 const &)\n" + " glm::mix(glm::vec3 const &,glm::vec3 const &,glm::vec3 const &)\n" + " glm::mix(glm::vec4 const &,glm::vec4 const &,glm::vec4 const &)\n" + " glm::mix(glm::vec2 const &,glm::vec2 const &,bool const &)\n" + " glm::mix(glm::vec3 const &,glm::vec3 const &,bool const &)\n" + " glm::mix(glm::vec4 const &,glm::vec4 const &,bool const &)\n"); lua_error(L);return 0; } +static int _wrap_step__SWIG_0(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = 0 ; glm::vec2 *arg2 = 0 ; glm::vec2 result; + SWIG_check_num_args("glm::step",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::step",1,"glm::vec2 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::step",2,"glm::vec2 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("step",1,SWIGTYPE_p_glm__vec2); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("step",2,SWIGTYPE_p_glm__vec2); } + result = glm::step((glm::vec2 const &)*arg1,(glm::vec2 const &)*arg2); { + glm::vec2 * resultptr = new glm::vec2((const glm::vec2 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_step__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; glm::vec3 *arg2 = 0 ; glm::vec3 result; + SWIG_check_num_args("glm::step",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::step",1,"glm::vec3 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::step",2,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("step",1,SWIGTYPE_p_glm__vec3); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("step",2,SWIGTYPE_p_glm__vec3); } + result = glm::step((glm::vec3 const &)*arg1,(glm::vec3 const &)*arg2); { + glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_step__SWIG_2(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = 0 ; glm::vec4 *arg2 = 0 ; glm::vec4 result; + SWIG_check_num_args("glm::step",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::step",1,"glm::vec4 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::step",2,"glm::vec4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("step",1,SWIGTYPE_p_glm__vec4); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("step",2,SWIGTYPE_p_glm__vec4); } + result = glm::step((glm::vec4 const &)*arg1,(glm::vec4 const &)*arg2); { + glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_step__SWIG_3(lua_State* L) { int SWIG_arg = 0; float *arg1 = 0 ; glm::vec2 *arg2 = 0 ; float temp1 ; + glm::vec2 result; SWIG_check_num_args("glm::step",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::step",1,"float const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::step",2,"glm::vec2 const &"); temp1=(float)lua_tonumber(L,1); arg1=&temp1; + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("step",2,SWIGTYPE_p_glm__vec2); } + result = glm::step((float const &)*arg1,(glm::vec2 const &)*arg2); { + glm::vec2 * resultptr = new glm::vec2((const glm::vec2 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_step__SWIG_4(lua_State* L) { int SWIG_arg = 0; float *arg1 = 0 ; glm::vec3 *arg2 = 0 ; float temp1 ; + glm::vec3 result; SWIG_check_num_args("glm::step",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::step",1,"float const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::step",2,"glm::vec3 const &"); temp1=(float)lua_tonumber(L,1); arg1=&temp1; + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("step",2,SWIGTYPE_p_glm__vec3); } + result = glm::step((float const &)*arg1,(glm::vec3 const &)*arg2); { + glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_step__SWIG_5(lua_State* L) { int SWIG_arg = 0; float *arg1 = 0 ; glm::vec4 *arg2 = 0 ; float temp1 ; + glm::vec4 result; SWIG_check_num_args("glm::step",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::step",1,"float const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::step",2,"glm::vec4 const &"); temp1=(float)lua_tonumber(L,1); arg1=&temp1; + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("step",2,SWIGTYPE_p_glm__vec4); } + result = glm::step((float const &)*arg1,(glm::vec4 const &)*arg2); { + glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_step(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v = 0; { { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_step__SWIG_0(L);} check_1: if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_step__SWIG_1(L);} check_2: if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; return _wrap_step__SWIG_2(L);} check_3: if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_4; return _wrap_step__SWIG_3(L);} check_4: if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_5; return _wrap_step__SWIG_4(L);} check_5: if (argc == 2) { + return _wrap_step__SWIG_5(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'step'\n" + " Possible C/C++ prototypes are:\n" " glm::step(glm::vec2 const &,glm::vec2 const &)\n" + " glm::step(glm::vec3 const &,glm::vec3 const &)\n" " glm::step(glm::vec4 const &,glm::vec4 const &)\n" + " glm::step(float const &,glm::vec2 const &)\n" " glm::step(float const &,glm::vec3 const &)\n" + " glm::step(float const &,glm::vec4 const &)\n"); lua_error(L);return 0; } +static int _wrap_smoothstep__SWIG_0(lua_State* L) { int SWIG_arg = 0; float *arg1 = 0 ; float *arg2 = 0 ; float *arg3 = 0 ; + float temp1 ; float temp2 ; float temp3 ; float result; SWIG_check_num_args("glm::smoothstep",3,3) + if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::smoothstep",1,"float const &"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::smoothstep",2,"float const &"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("glm::smoothstep",3,"float const &"); temp1=(float)lua_tonumber(L,1); arg1=&temp1; + temp2=(float)lua_tonumber(L,2); arg2=&temp2; temp3=(float)lua_tonumber(L,3); arg3=&temp3; + result = (float)glm::smoothstep((float const &)*arg1,(float const &)*arg2,(float const &)*arg3); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_smoothstep__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = 0 ; glm::vec2 *arg2 = 0 ; + glm::vec2 *arg3 = 0 ; glm::vec2 result; SWIG_check_num_args("glm::smoothstep",3,3) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::smoothstep",1,"glm::vec2 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::smoothstep",2,"glm::vec2 const &"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("glm::smoothstep",3,"glm::vec2 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ + SWIG_fail_ptr("smoothstep",1,SWIGTYPE_p_glm__vec2); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec2,0))){ + SWIG_fail_ptr("smoothstep",2,SWIGTYPE_p_glm__vec2); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_glm__vec2,0))){ + SWIG_fail_ptr("smoothstep",3,SWIGTYPE_p_glm__vec2); } + result = glm::smoothstep((glm::vec2 const &)*arg1,(glm::vec2 const &)*arg2,(glm::vec2 const &)*arg3); { + glm::vec2 * resultptr = new glm::vec2((const glm::vec2 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_smoothstep__SWIG_2(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; glm::vec3 *arg2 = 0 ; + glm::vec3 *arg3 = 0 ; glm::vec3 result; SWIG_check_num_args("glm::smoothstep",3,3) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::smoothstep",1,"glm::vec3 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::smoothstep",2,"glm::vec3 const &"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("glm::smoothstep",3,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ + SWIG_fail_ptr("smoothstep",1,SWIGTYPE_p_glm__vec3); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ + SWIG_fail_ptr("smoothstep",2,SWIGTYPE_p_glm__vec3); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_glm__vec3,0))){ + SWIG_fail_ptr("smoothstep",3,SWIGTYPE_p_glm__vec3); } + result = glm::smoothstep((glm::vec3 const &)*arg1,(glm::vec3 const &)*arg2,(glm::vec3 const &)*arg3); { + glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_smoothstep__SWIG_3(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = 0 ; glm::vec4 *arg2 = 0 ; + glm::vec4 *arg3 = 0 ; glm::vec4 result; SWIG_check_num_args("glm::smoothstep",3,3) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::smoothstep",1,"glm::vec4 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::smoothstep",2,"glm::vec4 const &"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("glm::smoothstep",3,"glm::vec4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ + SWIG_fail_ptr("smoothstep",1,SWIGTYPE_p_glm__vec4); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec4,0))){ + SWIG_fail_ptr("smoothstep",2,SWIGTYPE_p_glm__vec4); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_glm__vec4,0))){ + SWIG_fail_ptr("smoothstep",3,SWIGTYPE_p_glm__vec4); } + result = glm::smoothstep((glm::vec4 const &)*arg1,(glm::vec4 const &)*arg2,(glm::vec4 const &)*arg3); { + glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_smoothstep__SWIG_4(lua_State* L) { int SWIG_arg = 0; float *arg1 = 0 ; float *arg2 = 0 ; glm::vec2 *arg3 = 0 ; + float temp1 ; float temp2 ; glm::vec2 result; SWIG_check_num_args("glm::smoothstep",3,3) + if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::smoothstep",1,"float const &"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::smoothstep",2,"float const &"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("glm::smoothstep",3,"glm::vec2 const &"); temp1=(float)lua_tonumber(L,1); arg1=&temp1; + temp2=(float)lua_tonumber(L,2); arg2=&temp2; if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_glm__vec2,0))){ + SWIG_fail_ptr("smoothstep",3,SWIGTYPE_p_glm__vec2); } + result = glm::smoothstep((float const &)*arg1,(float const &)*arg2,(glm::vec2 const &)*arg3); { + glm::vec2 * resultptr = new glm::vec2((const glm::vec2 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_smoothstep__SWIG_5(lua_State* L) { int SWIG_arg = 0; float *arg1 = 0 ; float *arg2 = 0 ; glm::vec3 *arg3 = 0 ; + float temp1 ; float temp2 ; glm::vec3 result; SWIG_check_num_args("glm::smoothstep",3,3) + if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::smoothstep",1,"float const &"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::smoothstep",2,"float const &"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("glm::smoothstep",3,"glm::vec3 const &"); temp1=(float)lua_tonumber(L,1); arg1=&temp1; + temp2=(float)lua_tonumber(L,2); arg2=&temp2; if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_glm__vec3,0))){ + SWIG_fail_ptr("smoothstep",3,SWIGTYPE_p_glm__vec3); } + result = glm::smoothstep((float const &)*arg1,(float const &)*arg2,(glm::vec3 const &)*arg3); { + glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_smoothstep__SWIG_6(lua_State* L) { int SWIG_arg = 0; float *arg1 = 0 ; float *arg2 = 0 ; glm::vec4 *arg3 = 0 ; + float temp1 ; float temp2 ; glm::vec4 result; SWIG_check_num_args("glm::smoothstep",3,3) + if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::smoothstep",1,"float const &"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::smoothstep",2,"float const &"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("glm::smoothstep",3,"glm::vec4 const &"); temp1=(float)lua_tonumber(L,1); arg1=&temp1; + temp2=(float)lua_tonumber(L,2); arg2=&temp2; if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_glm__vec4,0))){ + SWIG_fail_ptr("smoothstep",3,SWIGTYPE_p_glm__vec4); } + result = glm::smoothstep((float const &)*arg1,(float const &)*arg2,(glm::vec4 const &)*arg3); { + glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_smoothstep(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 3) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; { { void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_smoothstep__SWIG_1(L);} check_1: + if (argc == 3) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; { { void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_smoothstep__SWIG_2(L);} check_2: + if (argc == 3) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; { { void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; return _wrap_smoothstep__SWIG_3(L);} check_3: + if (argc == 3) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_4; return _wrap_smoothstep__SWIG_4(L);} check_4: + if (argc == 3) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_5; return _wrap_smoothstep__SWIG_5(L);} check_5: + if (argc == 3) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_6; return _wrap_smoothstep__SWIG_6(L);} check_6: + if (argc == 3) { return _wrap_smoothstep__SWIG_0(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'smoothstep'\n" " Possible C/C++ prototypes are:\n" + " glm::smoothstep(float const &,float const &,float const &)\n" + " glm::smoothstep(glm::vec2 const &,glm::vec2 const &,glm::vec2 const &)\n" + " glm::smoothstep(glm::vec3 const &,glm::vec3 const &,glm::vec3 const &)\n" + " glm::smoothstep(glm::vec4 const &,glm::vec4 const &,glm::vec4 const &)\n" + " glm::smoothstep(float const &,float const &,glm::vec2 const &)\n" + " glm::smoothstep(float const &,float const &,glm::vec3 const &)\n" + " glm::smoothstep(float const &,float const &,glm::vec4 const &)\n"); lua_error(L);return 0; } +static int _wrap_isnan(lua_State* L) { int SWIG_arg = 0; float *arg1 = 0 ; float temp1 ; bool result; + SWIG_check_num_args("glm::isnan",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::isnan",1,"float const &"); + temp1=(float)lua_tonumber(L,1); arg1=&temp1; result = (bool)glm::isnan((float const &)*arg1); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_isinf(lua_State* L) { int SWIG_arg = 0; float *arg1 = 0 ; float temp1 ; bool result; + SWIG_check_num_args("glm::isinf",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::isinf",1,"float const &"); + temp1=(float)lua_tonumber(L,1); arg1=&temp1; result = (bool)glm::isinf((float const &)*arg1); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_fma__SWIG_0(lua_State* L) { int SWIG_arg = 0; float *arg1 = 0 ; float *arg2 = 0 ; float *arg3 = 0 ; + float temp1 ; float temp2 ; float temp3 ; float result; SWIG_check_num_args("glm::fma",3,3) + if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::fma",1,"float const &"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::fma",2,"float const &"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("glm::fma",3,"float const &"); temp1=(float)lua_tonumber(L,1); arg1=&temp1; + temp2=(float)lua_tonumber(L,2); arg2=&temp2; temp3=(float)lua_tonumber(L,3); arg3=&temp3; + result = (float)glm::fma((float const &)*arg1,(float const &)*arg2,(float const &)*arg3); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_fma__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = 0 ; glm::vec2 *arg2 = 0 ; glm::vec2 *arg3 = 0 ; + glm::vec2 result; SWIG_check_num_args("glm::fma",3,3) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::fma",1,"glm::vec2 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::fma",2,"glm::vec2 const &"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("glm::fma",3,"glm::vec2 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("fma",1,SWIGTYPE_p_glm__vec2); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("fma",2,SWIGTYPE_p_glm__vec2); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("fma",3,SWIGTYPE_p_glm__vec2); } + result = glm::fma((glm::vec2 const &)*arg1,(glm::vec2 const &)*arg2,(glm::vec2 const &)*arg3); { + glm::vec2 * resultptr = new glm::vec2((const glm::vec2 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_fma__SWIG_2(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; glm::vec3 *arg2 = 0 ; glm::vec3 *arg3 = 0 ; + glm::vec3 result; SWIG_check_num_args("glm::fma",3,3) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::fma",1,"glm::vec3 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::fma",2,"glm::vec3 const &"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("glm::fma",3,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("fma",1,SWIGTYPE_p_glm__vec3); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("fma",2,SWIGTYPE_p_glm__vec3); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("fma",3,SWIGTYPE_p_glm__vec3); } + result = glm::fma((glm::vec3 const &)*arg1,(glm::vec3 const &)*arg2,(glm::vec3 const &)*arg3); { + glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_fma__SWIG_3(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = 0 ; glm::vec4 *arg2 = 0 ; glm::vec4 *arg3 = 0 ; + glm::vec4 result; SWIG_check_num_args("glm::fma",3,3) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::fma",1,"glm::vec4 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::fma",2,"glm::vec4 const &"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("glm::fma",3,"glm::vec4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("fma",1,SWIGTYPE_p_glm__vec4); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("fma",2,SWIGTYPE_p_glm__vec4); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("fma",3,SWIGTYPE_p_glm__vec4); } + result = glm::fma((glm::vec4 const &)*arg1,(glm::vec4 const &)*arg2,(glm::vec4 const &)*arg3); { + glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_fma(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 3) { int _v = 0; { { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; { { void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_fma__SWIG_1(L);} check_1: if (argc == 3) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; { { void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_fma__SWIG_2(L);} check_2: if (argc == 3) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; { { void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; return _wrap_fma__SWIG_3(L);} check_3: if (argc == 3) { + return _wrap_fma__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'fma'\n" + " Possible C/C++ prototypes are:\n" " glm::fma(float const &,float const &,float const &)\n" + " glm::fma(glm::vec2 const &,glm::vec2 const &,glm::vec2 const &)\n" + " glm::fma(glm::vec3 const &,glm::vec3 const &,glm::vec3 const &)\n" + " glm::fma(glm::vec4 const &,glm::vec4 const &,glm::vec4 const &)\n"); lua_error(L);return 0; } +static int _wrap_pow__SWIG_0(lua_State* L) { int SWIG_arg = 0; float *arg1 = 0 ; float *arg2 = 0 ; float temp1 ; float temp2 ; + float result; SWIG_check_num_args("glm::pow",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::pow",1,"float const &"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::pow",2,"float const &"); temp1=(float)lua_tonumber(L,1); arg1=&temp1; + temp2=(float)lua_tonumber(L,2); arg2=&temp2; result = (float)glm::pow((float const &)*arg1,(float const &)*arg2); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_pow__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = 0 ; glm::vec2 *arg2 = 0 ; glm::vec2 result; + SWIG_check_num_args("glm::pow",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::pow",1,"glm::vec2 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::pow",2,"glm::vec2 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("pow",1,SWIGTYPE_p_glm__vec2); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("pow",2,SWIGTYPE_p_glm__vec2); } + result = glm::pow((glm::vec2 const &)*arg1,(glm::vec2 const &)*arg2); { + glm::vec2 * resultptr = new glm::vec2((const glm::vec2 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_pow__SWIG_2(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; glm::vec3 *arg2 = 0 ; glm::vec3 result; + SWIG_check_num_args("glm::pow",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::pow",1,"glm::vec3 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::pow",2,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("pow",1,SWIGTYPE_p_glm__vec3); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("pow",2,SWIGTYPE_p_glm__vec3); } + result = glm::pow((glm::vec3 const &)*arg1,(glm::vec3 const &)*arg2); { + glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_pow__SWIG_3(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = 0 ; glm::vec4 *arg2 = 0 ; glm::vec4 result; + SWIG_check_num_args("glm::pow",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::pow",1,"glm::vec4 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::pow",2,"glm::vec4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("pow",1,SWIGTYPE_p_glm__vec4); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("pow",2,SWIGTYPE_p_glm__vec4); } + result = glm::pow((glm::vec4 const &)*arg1,(glm::vec4 const &)*arg2); { + glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_pow(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v = 0; { { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_pow__SWIG_1(L);} check_1: if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_pow__SWIG_2(L);} check_2: if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; return _wrap_pow__SWIG_3(L);} check_3: if (argc == 2) { + return _wrap_pow__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'pow'\n" + " Possible C/C++ prototypes are:\n" " glm::pow(float const &,float const &)\n" + " glm::pow(glm::vec2 const &,glm::vec2 const &)\n" " glm::pow(glm::vec3 const &,glm::vec3 const &)\n" + " glm::pow(glm::vec4 const &,glm::vec4 const &)\n"); lua_error(L);return 0; } +static int _wrap_exp__SWIG_0(lua_State* L) { int SWIG_arg = 0; float *arg1 = 0 ; float temp1 ; float result; + SWIG_check_num_args("glm::exp",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::exp",1,"float const &"); + temp1=(float)lua_tonumber(L,1); arg1=&temp1; result = (float)glm::exp((float const &)*arg1); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_exp__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = 0 ; glm::vec2 result; + SWIG_check_num_args("glm::exp",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::exp",1,"glm::vec2 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("exp",1,SWIGTYPE_p_glm__vec2); } + result = glm::exp((glm::vec2 const &)*arg1); { glm::vec2 * resultptr = new glm::vec2((const glm::vec2 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_exp__SWIG_2(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; glm::vec3 result; + SWIG_check_num_args("glm::exp",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::exp",1,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("exp",1,SWIGTYPE_p_glm__vec3); } + result = glm::exp((glm::vec3 const &)*arg1); { glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_exp__SWIG_3(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = 0 ; glm::vec4 result; + SWIG_check_num_args("glm::exp",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::exp",1,"glm::vec4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("exp",1,SWIGTYPE_p_glm__vec4); } + result = glm::exp((glm::vec4 const &)*arg1); { glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_exp(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v = 0; { { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_exp__SWIG_1(L);} check_1: if (argc == 1) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_exp__SWIG_2(L);} check_2: if (argc == 1) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; return _wrap_exp__SWIG_3(L);} check_3: if (argc == 1) { + return _wrap_exp__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'exp'\n" + " Possible C/C++ prototypes are:\n" " glm::exp(float const &)\n" " glm::exp(glm::vec2 const &)\n" + " glm::exp(glm::vec3 const &)\n" " glm::exp(glm::vec4 const &)\n"); lua_error(L);return 0; } +static int _wrap_log__SWIG_0(lua_State* L) { int SWIG_arg = 0; float *arg1 = 0 ; float temp1 ; float result; + SWIG_check_num_args("glm::log",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::log",1,"float const &"); + temp1=(float)lua_tonumber(L,1); arg1=&temp1; result = (float)glm::log((float const &)*arg1); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_log__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = 0 ; glm::vec2 result; + SWIG_check_num_args("glm::log",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::log",1,"glm::vec2 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("log",1,SWIGTYPE_p_glm__vec2); } + result = glm::log((glm::vec2 const &)*arg1); { glm::vec2 * resultptr = new glm::vec2((const glm::vec2 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_log__SWIG_2(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; glm::vec3 result; + SWIG_check_num_args("glm::log",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::log",1,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("log",1,SWIGTYPE_p_glm__vec3); } + result = glm::log((glm::vec3 const &)*arg1); { glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_log__SWIG_3(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = 0 ; glm::vec4 result; + SWIG_check_num_args("glm::log",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::log",1,"glm::vec4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("log",1,SWIGTYPE_p_glm__vec4); } + result = glm::log((glm::vec4 const &)*arg1); { glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_log(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v = 0; { { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_log__SWIG_1(L);} check_1: if (argc == 1) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_log__SWIG_2(L);} check_2: if (argc == 1) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; return _wrap_log__SWIG_3(L);} check_3: if (argc == 1) { + return _wrap_log__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'log'\n" + " Possible C/C++ prototypes are:\n" " glm::log(float const &)\n" " glm::log(glm::vec2 const &)\n" + " glm::log(glm::vec3 const &)\n" " glm::log(glm::vec4 const &)\n"); lua_error(L);return 0; } +static int _wrap_exp2__SWIG_0(lua_State* L) { int SWIG_arg = 0; float *arg1 = 0 ; float temp1 ; float result; + SWIG_check_num_args("glm::exp2",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::exp2",1,"float const &"); + temp1=(float)lua_tonumber(L,1); arg1=&temp1; result = (float)glm::exp2((float const &)*arg1); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_exp2__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = 0 ; glm::vec2 result; + SWIG_check_num_args("glm::exp2",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::exp2",1,"glm::vec2 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("exp2",1,SWIGTYPE_p_glm__vec2); } + result = glm::exp2((glm::vec2 const &)*arg1); { glm::vec2 * resultptr = new glm::vec2((const glm::vec2 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_exp2__SWIG_2(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; glm::vec3 result; + SWIG_check_num_args("glm::exp2",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::exp2",1,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("exp2",1,SWIGTYPE_p_glm__vec3); } + result = glm::exp2((glm::vec3 const &)*arg1); { glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_exp2__SWIG_3(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = 0 ; glm::vec4 result; + SWIG_check_num_args("glm::exp2",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::exp2",1,"glm::vec4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("exp2",1,SWIGTYPE_p_glm__vec4); } + result = glm::exp2((glm::vec4 const &)*arg1); { glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_exp2(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v = 0; { { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_exp2__SWIG_1(L);} check_1: if (argc == 1) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_exp2__SWIG_2(L);} check_2: if (argc == 1) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; return _wrap_exp2__SWIG_3(L);} check_3: if (argc == 1) { + return _wrap_exp2__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'exp2'\n" + " Possible C/C++ prototypes are:\n" " glm::exp2(float const &)\n" " glm::exp2(glm::vec2 const &)\n" + " glm::exp2(glm::vec3 const &)\n" " glm::exp2(glm::vec4 const &)\n"); lua_error(L);return 0; } +static int _wrap_log2__SWIG_0(lua_State* L) { int SWIG_arg = 0; float *arg1 = 0 ; float temp1 ; float result; + SWIG_check_num_args("glm::log2",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::log2",1,"float const &"); + temp1=(float)lua_tonumber(L,1); arg1=&temp1; result = (float)glm::log2((float const &)*arg1); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_log2__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = 0 ; glm::vec2 result; + SWIG_check_num_args("glm::log2",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::log2",1,"glm::vec2 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("log2",1,SWIGTYPE_p_glm__vec2); } + result = glm::log2((glm::vec2 const &)*arg1); { glm::vec2 * resultptr = new glm::vec2((const glm::vec2 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_log2__SWIG_2(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; glm::vec3 result; + SWIG_check_num_args("glm::log2",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::log2",1,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("log2",1,SWIGTYPE_p_glm__vec3); } + result = glm::log2((glm::vec3 const &)*arg1); { glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_log2__SWIG_3(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = 0 ; glm::vec4 result; + SWIG_check_num_args("glm::log2",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::log2",1,"glm::vec4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("log2",1,SWIGTYPE_p_glm__vec4); } + result = glm::log2((glm::vec4 const &)*arg1); { glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_log2(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v = 0; { { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_log2__SWIG_1(L);} check_1: if (argc == 1) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_log2__SWIG_2(L);} check_2: if (argc == 1) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; return _wrap_log2__SWIG_3(L);} check_3: if (argc == 1) { + return _wrap_log2__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'log2'\n" + " Possible C/C++ prototypes are:\n" " glm::log2(float const &)\n" " glm::log2(glm::vec2 const &)\n" + " glm::log2(glm::vec3 const &)\n" " glm::log2(glm::vec4 const &)\n"); lua_error(L);return 0; } +static int _wrap_sqrt__SWIG_0(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = 0 ; glm::vec2 result; + SWIG_check_num_args("glm::sqrt",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::sqrt",1,"glm::vec2 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("sqrt",1,SWIGTYPE_p_glm__vec2); } + result = glm::sqrt((glm::vec2 const &)*arg1); { glm::vec2 * resultptr = new glm::vec2((const glm::vec2 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_sqrt__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; glm::vec3 result; + SWIG_check_num_args("glm::sqrt",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::sqrt",1,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("sqrt",1,SWIGTYPE_p_glm__vec3); } + result = glm::sqrt((glm::vec3 const &)*arg1); { glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_sqrt__SWIG_2(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = 0 ; glm::vec4 result; + SWIG_check_num_args("glm::sqrt",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::sqrt",1,"glm::vec4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("sqrt",1,SWIGTYPE_p_glm__vec4); } + result = glm::sqrt((glm::vec4 const &)*arg1); { glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_sqrt(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v = 0; { { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_sqrt__SWIG_0(L);} check_1: if (argc == 1) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_sqrt__SWIG_1(L);} check_2: if (argc == 1) { + return _wrap_sqrt__SWIG_2(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'sqrt'\n" + " Possible C/C++ prototypes are:\n" " glm::sqrt(glm::vec2 const &)\n" " glm::sqrt(glm::vec3 const &)\n" + " glm::sqrt(glm::vec4 const &)\n"); lua_error(L);return 0; } +static int _wrap_inversesqrt__SWIG_0(lua_State* L) { int SWIG_arg = 0; float *arg1 = 0 ; float temp1 ; float result; + SWIG_check_num_args("glm::inversesqrt",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::inversesqrt",1,"float const &"); + temp1=(float)lua_tonumber(L,1); arg1=&temp1; result = (float)glm::inversesqrt((float const &)*arg1); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_inversesqrt__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = 0 ; glm::vec2 result; + SWIG_check_num_args("glm::inversesqrt",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::inversesqrt",1,"glm::vec2 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ + SWIG_fail_ptr("inversesqrt",1,SWIGTYPE_p_glm__vec2); } result = glm::inversesqrt((glm::vec2 const &)*arg1); { + glm::vec2 * resultptr = new glm::vec2((const glm::vec2 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_inversesqrt__SWIG_2(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; glm::vec3 result; + SWIG_check_num_args("glm::inversesqrt",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::inversesqrt",1,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ + SWIG_fail_ptr("inversesqrt",1,SWIGTYPE_p_glm__vec3); } result = glm::inversesqrt((glm::vec3 const &)*arg1); { + glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_inversesqrt__SWIG_3(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = 0 ; glm::vec4 result; + SWIG_check_num_args("glm::inversesqrt",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::inversesqrt",1,"glm::vec4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ + SWIG_fail_ptr("inversesqrt",1,SWIGTYPE_p_glm__vec4); } result = glm::inversesqrt((glm::vec4 const &)*arg1); { + glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_inversesqrt(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v = 0; { + { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_inversesqrt__SWIG_1(L);} check_1: + if (argc == 1) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_inversesqrt__SWIG_2(L);} check_2: + if (argc == 1) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; return _wrap_inversesqrt__SWIG_3(L);} check_3: + if (argc == 1) { return _wrap_inversesqrt__SWIG_0(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'inversesqrt'\n" " Possible C/C++ prototypes are:\n" + " glm::inversesqrt(float const &)\n" " glm::inversesqrt(glm::vec2 const &)\n" + " glm::inversesqrt(glm::vec3 const &)\n" " glm::inversesqrt(glm::vec4 const &)\n"); lua_error(L);return 0; } +static int _wrap_length__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = 0 ; float result; + SWIG_check_num_args("glm::length",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::length",1,"glm::vec2 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("length",1,SWIGTYPE_p_glm__vec2); } + result = (float)glm::length((glm::vec2 const &)*arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; + if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_length__SWIG_2(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; float result; + SWIG_check_num_args("glm::length",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::length",1,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("length",1,SWIGTYPE_p_glm__vec3); } + result = (float)glm::length((glm::vec3 const &)*arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; + if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_length__SWIG_3(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = 0 ; float result; + SWIG_check_num_args("glm::length",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::length",1,"glm::vec4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("length",1,SWIGTYPE_p_glm__vec4); } + result = (float)glm::length((glm::vec4 const &)*arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; + if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_length(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v = 0; { { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__quat, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_length__SWIG_0(L);} check_1: if (argc == 1) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_length__SWIG_1(L);} check_2: if (argc == 1) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; return _wrap_length__SWIG_2(L);} check_3: if (argc == 1) { + return _wrap_length__SWIG_3(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'length'\n" + " Possible C/C++ prototypes are:\n" " glm::length(glm::quat const &)\n" " glm::length(glm::vec2 const &)\n" + " glm::length(glm::vec3 const &)\n" " glm::length(glm::vec4 const &)\n"); lua_error(L);return 0; } +static int _wrap_distance__SWIG_0(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = 0 ; glm::vec2 *arg2 = 0 ; float result; + SWIG_check_num_args("glm::distance",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::distance",1,"glm::vec2 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::distance",2,"glm::vec2 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("distance",1,SWIGTYPE_p_glm__vec2); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec2,0))){ + SWIG_fail_ptr("distance",2,SWIGTYPE_p_glm__vec2); } + result = (float)glm::distance((glm::vec2 const &)*arg1,(glm::vec2 const &)*arg2); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_distance__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; glm::vec3 *arg2 = 0 ; float result; + SWIG_check_num_args("glm::distance",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::distance",1,"glm::vec3 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::distance",2,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("distance",1,SWIGTYPE_p_glm__vec3); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ + SWIG_fail_ptr("distance",2,SWIGTYPE_p_glm__vec3); } + result = (float)glm::distance((glm::vec3 const &)*arg1,(glm::vec3 const &)*arg2); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_distance__SWIG_2(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = 0 ; glm::vec4 *arg2 = 0 ; float result; + SWIG_check_num_args("glm::distance",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::distance",1,"glm::vec4 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::distance",2,"glm::vec4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("distance",1,SWIGTYPE_p_glm__vec4); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec4,0))){ + SWIG_fail_ptr("distance",2,SWIGTYPE_p_glm__vec4); } + result = (float)glm::distance((glm::vec4 const &)*arg1,(glm::vec4 const &)*arg2); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_distance(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v = 0; { + { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_distance__SWIG_0(L);} check_1: if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_distance__SWIG_1(L);} check_2: if (argc == 2) { + return _wrap_distance__SWIG_2(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'distance'\n" + " Possible C/C++ prototypes are:\n" " glm::distance(glm::vec2 const &,glm::vec2 const &)\n" + " glm::distance(glm::vec3 const &,glm::vec3 const &)\n" " glm::distance(glm::vec4 const &,glm::vec4 const &)\n"); + lua_error(L);return 0; } +static int _wrap_dot__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = 0 ; glm::vec2 *arg2 = 0 ; float result; + SWIG_check_num_args("glm::dot",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::dot",1,"glm::vec2 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::dot",2,"glm::vec2 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("dot",1,SWIGTYPE_p_glm__vec2); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("dot",2,SWIGTYPE_p_glm__vec2); } + result = (float)glm::dot((glm::vec2 const &)*arg1,(glm::vec2 const &)*arg2); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_dot__SWIG_2(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; glm::vec3 *arg2 = 0 ; float result; + SWIG_check_num_args("glm::dot",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::dot",1,"glm::vec3 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::dot",2,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("dot",1,SWIGTYPE_p_glm__vec3); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("dot",2,SWIGTYPE_p_glm__vec3); } + result = (float)glm::dot((glm::vec3 const &)*arg1,(glm::vec3 const &)*arg2); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_dot__SWIG_3(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = 0 ; glm::vec4 *arg2 = 0 ; float result; + SWIG_check_num_args("glm::dot",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::dot",1,"glm::vec4 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::dot",2,"glm::vec4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("dot",1,SWIGTYPE_p_glm__vec4); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("dot",2,SWIGTYPE_p_glm__vec4); } + result = (float)glm::dot((glm::vec4 const &)*arg1,(glm::vec4 const &)*arg2); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_dot(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v = 0; { { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__quat, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__quat, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_dot__SWIG_0(L);} check_1: if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_dot__SWIG_1(L);} check_2: if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; return _wrap_dot__SWIG_2(L);} check_3: if (argc == 2) { + return _wrap_dot__SWIG_3(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'dot'\n" + " Possible C/C++ prototypes are:\n" " glm::dot(glm::quat const &,glm::quat const &)\n" + " glm::dot(glm::vec2 const &,glm::vec2 const &)\n" " glm::dot(glm::vec3 const &,glm::vec3 const &)\n" + " glm::dot(glm::vec4 const &,glm::vec4 const &)\n"); lua_error(L);return 0; } +static int _wrap_cross(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; glm::vec3 *arg2 = 0 ; glm::vec3 result; + SWIG_check_num_args("glm::cross",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::cross",1,"glm::vec3 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::cross",2,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("cross",1,SWIGTYPE_p_glm__vec3); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("cross",2,SWIGTYPE_p_glm__vec3); } + result = glm::cross((glm::vec3 const &)*arg1,(glm::vec3 const &)*arg2); { + glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_normalize__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = 0 ; glm::vec2 result; + SWIG_check_num_args("glm::normalize",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::normalize",1,"glm::vec2 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ + SWIG_fail_ptr("normalize",1,SWIGTYPE_p_glm__vec2); } result = glm::normalize((glm::vec2 const &)*arg1); { + glm::vec2 * resultptr = new glm::vec2((const glm::vec2 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_normalize__SWIG_2(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; glm::vec3 result; + SWIG_check_num_args("glm::normalize",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::normalize",1,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ + SWIG_fail_ptr("normalize",1,SWIGTYPE_p_glm__vec3); } result = glm::normalize((glm::vec3 const &)*arg1); { + glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_normalize__SWIG_3(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = 0 ; glm::vec4 result; + SWIG_check_num_args("glm::normalize",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::normalize",1,"glm::vec4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ + SWIG_fail_ptr("normalize",1,SWIGTYPE_p_glm__vec4); } result = glm::normalize((glm::vec4 const &)*arg1); { + glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_normalize(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v = 0; { { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__quat, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_normalize__SWIG_0(L);} check_1: + if (argc == 1) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_normalize__SWIG_1(L);} check_2: + if (argc == 1) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; return _wrap_normalize__SWIG_2(L);} check_3: + if (argc == 1) { return _wrap_normalize__SWIG_3(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'normalize'\n" " Possible C/C++ prototypes are:\n" + " glm::normalize(glm::quat const &)\n" " glm::normalize(glm::vec2 const &)\n" " glm::normalize(glm::vec3 const &)\n" + " glm::normalize(glm::vec4 const &)\n"); lua_error(L);return 0; } +static int _wrap_faceforward__SWIG_0(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = 0 ; glm::vec2 *arg2 = 0 ; + glm::vec2 *arg3 = 0 ; glm::vec2 result; SWIG_check_num_args("glm::faceforward",3,3) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::faceforward",1,"glm::vec2 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::faceforward",2,"glm::vec2 const &"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("glm::faceforward",3,"glm::vec2 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ + SWIG_fail_ptr("faceforward",1,SWIGTYPE_p_glm__vec2); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec2,0))){ + SWIG_fail_ptr("faceforward",2,SWIGTYPE_p_glm__vec2); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_glm__vec2,0))){ + SWIG_fail_ptr("faceforward",3,SWIGTYPE_p_glm__vec2); } + result = glm::faceforward((glm::vec2 const &)*arg1,(glm::vec2 const &)*arg2,(glm::vec2 const &)*arg3); { + glm::vec2 * resultptr = new glm::vec2((const glm::vec2 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_faceforward__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; glm::vec3 *arg2 = 0 ; + glm::vec3 *arg3 = 0 ; glm::vec3 result; SWIG_check_num_args("glm::faceforward",3,3) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::faceforward",1,"glm::vec3 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::faceforward",2,"glm::vec3 const &"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("glm::faceforward",3,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ + SWIG_fail_ptr("faceforward",1,SWIGTYPE_p_glm__vec3); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ + SWIG_fail_ptr("faceforward",2,SWIGTYPE_p_glm__vec3); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_glm__vec3,0))){ + SWIG_fail_ptr("faceforward",3,SWIGTYPE_p_glm__vec3); } + result = glm::faceforward((glm::vec3 const &)*arg1,(glm::vec3 const &)*arg2,(glm::vec3 const &)*arg3); { + glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_faceforward__SWIG_2(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = 0 ; glm::vec4 *arg2 = 0 ; + glm::vec4 *arg3 = 0 ; glm::vec4 result; SWIG_check_num_args("glm::faceforward",3,3) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::faceforward",1,"glm::vec4 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::faceforward",2,"glm::vec4 const &"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("glm::faceforward",3,"glm::vec4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ + SWIG_fail_ptr("faceforward",1,SWIGTYPE_p_glm__vec4); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec4,0))){ + SWIG_fail_ptr("faceforward",2,SWIGTYPE_p_glm__vec4); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_glm__vec4,0))){ + SWIG_fail_ptr("faceforward",3,SWIGTYPE_p_glm__vec4); } + result = glm::faceforward((glm::vec4 const &)*arg1,(glm::vec4 const &)*arg2,(glm::vec4 const &)*arg3); { + glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_faceforward(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 3) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; { { void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_faceforward__SWIG_0(L);} check_1: + if (argc == 3) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; { { void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_faceforward__SWIG_1(L);} check_2: + if (argc == 3) { return _wrap_faceforward__SWIG_2(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'faceforward'\n" " Possible C/C++ prototypes are:\n" + " glm::faceforward(glm::vec2 const &,glm::vec2 const &,glm::vec2 const &)\n" + " glm::faceforward(glm::vec3 const &,glm::vec3 const &,glm::vec3 const &)\n" + " glm::faceforward(glm::vec4 const &,glm::vec4 const &,glm::vec4 const &)\n"); lua_error(L);return 0; } +static int _wrap_reflect__SWIG_0(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = 0 ; glm::vec2 *arg2 = 0 ; glm::vec2 result; + SWIG_check_num_args("glm::reflect",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::reflect",1,"glm::vec2 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::reflect",2,"glm::vec2 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("reflect",1,SWIGTYPE_p_glm__vec2); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("reflect",2,SWIGTYPE_p_glm__vec2); } + result = glm::reflect((glm::vec2 const &)*arg1,(glm::vec2 const &)*arg2); { + glm::vec2 * resultptr = new glm::vec2((const glm::vec2 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_reflect__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; glm::vec3 *arg2 = 0 ; glm::vec3 result; + SWIG_check_num_args("glm::reflect",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::reflect",1,"glm::vec3 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::reflect",2,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("reflect",1,SWIGTYPE_p_glm__vec3); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("reflect",2,SWIGTYPE_p_glm__vec3); } + result = glm::reflect((glm::vec3 const &)*arg1,(glm::vec3 const &)*arg2); { + glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_reflect__SWIG_2(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = 0 ; glm::vec4 *arg2 = 0 ; glm::vec4 result; + SWIG_check_num_args("glm::reflect",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::reflect",1,"glm::vec4 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::reflect",2,"glm::vec4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("reflect",1,SWIGTYPE_p_glm__vec4); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("reflect",2,SWIGTYPE_p_glm__vec4); } + result = glm::reflect((glm::vec4 const &)*arg1,(glm::vec4 const &)*arg2); { + glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_reflect(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v = 0; { { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_reflect__SWIG_0(L);} check_1: if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_reflect__SWIG_1(L);} check_2: if (argc == 2) { + return _wrap_reflect__SWIG_2(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'reflect'\n" + " Possible C/C++ prototypes are:\n" " glm::reflect(glm::vec2 const &,glm::vec2 const &)\n" + " glm::reflect(glm::vec3 const &,glm::vec3 const &)\n" " glm::reflect(glm::vec4 const &,glm::vec4 const &)\n"); + lua_error(L);return 0; } +static int _wrap_refract__SWIG_0(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = 0 ; glm::vec2 *arg2 = 0 ; float *arg3 = 0 ; + float temp3 ; glm::vec2 result; SWIG_check_num_args("glm::refract",3,3) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::refract",1,"glm::vec2 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::refract",2,"glm::vec2 const &"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("glm::refract",3,"float const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("refract",1,SWIGTYPE_p_glm__vec2); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("refract",2,SWIGTYPE_p_glm__vec2); } + temp3=(float)lua_tonumber(L,3); arg3=&temp3; + result = glm::refract((glm::vec2 const &)*arg1,(glm::vec2 const &)*arg2,(float const &)*arg3); { + glm::vec2 * resultptr = new glm::vec2((const glm::vec2 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_refract__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; glm::vec3 *arg2 = 0 ; float *arg3 = 0 ; + float temp3 ; glm::vec3 result; SWIG_check_num_args("glm::refract",3,3) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::refract",1,"glm::vec3 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::refract",2,"glm::vec3 const &"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("glm::refract",3,"float const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("refract",1,SWIGTYPE_p_glm__vec3); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("refract",2,SWIGTYPE_p_glm__vec3); } + temp3=(float)lua_tonumber(L,3); arg3=&temp3; + result = glm::refract((glm::vec3 const &)*arg1,(glm::vec3 const &)*arg2,(float const &)*arg3); { + glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_refract__SWIG_2(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = 0 ; glm::vec4 *arg2 = 0 ; float *arg3 = 0 ; + float temp3 ; glm::vec4 result; SWIG_check_num_args("glm::refract",3,3) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::refract",1,"glm::vec4 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::refract",2,"glm::vec4 const &"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("glm::refract",3,"float const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("refract",1,SWIGTYPE_p_glm__vec4); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("refract",2,SWIGTYPE_p_glm__vec4); } + temp3=(float)lua_tonumber(L,3); arg3=&temp3; + result = glm::refract((glm::vec4 const &)*arg1,(glm::vec4 const &)*arg2,(float const &)*arg3); { + glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_refract(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 3) { int _v = 0; { + { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_refract__SWIG_0(L);} check_1: if (argc == 3) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_refract__SWIG_1(L);} check_2: if (argc == 3) { + return _wrap_refract__SWIG_2(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'refract'\n" + " Possible C/C++ prototypes are:\n" " glm::refract(glm::vec2 const &,glm::vec2 const &,float const &)\n" + " glm::refract(glm::vec3 const &,glm::vec3 const &,float const &)\n" + " glm::refract(glm::vec4 const &,glm::vec4 const &,float const &)\n"); lua_error(L);return 0; } +static int _wrap_matrixCompMult__SWIG_0(lua_State* L) { int SWIG_arg = 0; glm::mat3 *arg1 = 0 ; glm::mat3 *arg2 = 0 ; + glm::mat3 result; SWIG_check_num_args("glm::matrixCompMult",2,2) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::matrixCompMult",1,"glm::mat3 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::matrixCompMult",2,"glm::mat3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__mat3,0))){ + SWIG_fail_ptr("matrixCompMult",1,SWIGTYPE_p_glm__mat3); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__mat3,0))){ + SWIG_fail_ptr("matrixCompMult",2,SWIGTYPE_p_glm__mat3); } + result = glm::matrixCompMult((glm::mat3 const &)*arg1,(glm::mat3 const &)*arg2); { + glm::mat3 * resultptr = new glm::mat3((const glm::mat3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__mat3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_matrixCompMult__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::mat4 *arg1 = 0 ; glm::mat4 *arg2 = 0 ; + glm::mat4 result; SWIG_check_num_args("glm::matrixCompMult",2,2) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::matrixCompMult",1,"glm::mat4 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::matrixCompMult",2,"glm::mat4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__mat4,0))){ + SWIG_fail_ptr("matrixCompMult",1,SWIGTYPE_p_glm__mat4); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__mat4,0))){ + SWIG_fail_ptr("matrixCompMult",2,SWIGTYPE_p_glm__mat4); } + result = glm::matrixCompMult((glm::mat4 const &)*arg1,(glm::mat4 const &)*arg2); { + glm::mat4 * resultptr = new glm::mat4((const glm::mat4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__mat4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_matrixCompMult(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__mat3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__mat3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_matrixCompMult__SWIG_0(L);} check_1: + if (argc == 2) { return _wrap_matrixCompMult__SWIG_1(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'matrixCompMult'\n" " Possible C/C++ prototypes are:\n" + " glm::matrixCompMult(glm::mat3 const &,glm::mat3 const &)\n" + " glm::matrixCompMult(glm::mat4 const &,glm::mat4 const &)\n"); lua_error(L);return 0; } +static int _wrap_outerProduct__SWIG_0(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; glm::vec3 *arg2 = 0 ; + glm::mat3 result; SWIG_check_num_args("glm::outerProduct",2,2) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::outerProduct",1,"glm::vec3 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::outerProduct",2,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ + SWIG_fail_ptr("outerProduct",1,SWIGTYPE_p_glm__vec3); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ + SWIG_fail_ptr("outerProduct",2,SWIGTYPE_p_glm__vec3); } + result = glm::outerProduct((glm::vec3 const &)*arg1,(glm::vec3 const &)*arg2); { + glm::mat3 * resultptr = new glm::mat3((const glm::mat3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__mat3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_outerProduct__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = 0 ; glm::vec4 *arg2 = 0 ; + glm::mat4 result; SWIG_check_num_args("glm::outerProduct",2,2) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::outerProduct",1,"glm::vec4 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::outerProduct",2,"glm::vec4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ + SWIG_fail_ptr("outerProduct",1,SWIGTYPE_p_glm__vec4); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec4,0))){ + SWIG_fail_ptr("outerProduct",2,SWIGTYPE_p_glm__vec4); } + result = glm::outerProduct((glm::vec4 const &)*arg1,(glm::vec4 const &)*arg2); { + glm::mat4 * resultptr = new glm::mat4((const glm::mat4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__mat4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_outerProduct(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_outerProduct__SWIG_0(L);} check_1: + if (argc == 2) { return _wrap_outerProduct__SWIG_1(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'outerProduct'\n" " Possible C/C++ prototypes are:\n" + " glm::outerProduct(glm::vec3 const &,glm::vec3 const &)\n" + " glm::outerProduct(glm::vec4 const &,glm::vec4 const &)\n"); lua_error(L);return 0; } +static int _wrap_transpose__SWIG_0(lua_State* L) { int SWIG_arg = 0; glm::mat3 *arg1 = 0 ; glm::mat3 result; + SWIG_check_num_args("glm::transpose",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::transpose",1,"glm::mat3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__mat3,0))){ + SWIG_fail_ptr("transpose",1,SWIGTYPE_p_glm__mat3); } result = glm::transpose((glm::mat3 const &)*arg1); { + glm::mat3 * resultptr = new glm::mat3((const glm::mat3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__mat3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_transpose__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::mat4 *arg1 = 0 ; glm::mat4 result; + SWIG_check_num_args("glm::transpose",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::transpose",1,"glm::mat4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__mat4,0))){ + SWIG_fail_ptr("transpose",1,SWIGTYPE_p_glm__mat4); } result = glm::transpose((glm::mat4 const &)*arg1); { + glm::mat4 * resultptr = new glm::mat4((const glm::mat4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__mat4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_transpose(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v = 0; { { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__mat3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_transpose__SWIG_0(L);} check_1: + if (argc == 1) { return _wrap_transpose__SWIG_1(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'transpose'\n" " Possible C/C++ prototypes are:\n" + " glm::transpose(glm::mat3 const &)\n" " glm::transpose(glm::mat4 const &)\n"); lua_error(L);return 0; } +static int _wrap_determinant__SWIG_0(lua_State* L) { int SWIG_arg = 0; glm::mat3 *arg1 = 0 ; float result; + SWIG_check_num_args("glm::determinant",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::determinant",1,"glm::mat3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__mat3,0))){ + SWIG_fail_ptr("determinant",1,SWIGTYPE_p_glm__mat3); } result = (float)glm::determinant((glm::mat3 const &)*arg1); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_determinant__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::mat4 *arg1 = 0 ; float result; + SWIG_check_num_args("glm::determinant",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::determinant",1,"glm::mat4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__mat4,0))){ + SWIG_fail_ptr("determinant",1,SWIGTYPE_p_glm__mat4); } result = (float)glm::determinant((glm::mat4 const &)*arg1); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_determinant(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v = 0; { + { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__mat3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_determinant__SWIG_0(L);} check_1: + if (argc == 1) { return _wrap_determinant__SWIG_1(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'determinant'\n" " Possible C/C++ prototypes are:\n" + " glm::determinant(glm::mat3 const &)\n" " glm::determinant(glm::mat4 const &)\n"); lua_error(L);return 0; } +static int _wrap_inverse__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::mat3 *arg1 = 0 ; glm::mat3 result; + SWIG_check_num_args("glm::inverse",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::inverse",1,"glm::mat3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__mat3,0))){ SWIG_fail_ptr("inverse",1,SWIGTYPE_p_glm__mat3); } + result = glm::inverse((glm::mat3 const &)*arg1); { glm::mat3 * resultptr = new glm::mat3((const glm::mat3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__mat3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_inverse__SWIG_2(lua_State* L) { int SWIG_arg = 0; glm::mat4 *arg1 = 0 ; glm::mat4 result; + SWIG_check_num_args("glm::inverse",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::inverse",1,"glm::mat4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__mat4,0))){ SWIG_fail_ptr("inverse",1,SWIGTYPE_p_glm__mat4); } + result = glm::inverse((glm::mat4 const &)*arg1); { glm::mat4 * resultptr = new glm::mat4((const glm::mat4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__mat4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_inverse(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v = 0; { { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__quat, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_inverse__SWIG_0(L);} check_1: if (argc == 1) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__mat3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_inverse__SWIG_1(L);} check_2: if (argc == 1) { + return _wrap_inverse__SWIG_2(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'inverse'\n" + " Possible C/C++ prototypes are:\n" " glm::inverse(glm::quat const &)\n" " glm::inverse(glm::mat3 const &)\n" + " glm::inverse(glm::mat4 const &)\n"); lua_error(L);return 0; } +static int _wrap_radians__SWIG_0(lua_State* L) { int SWIG_arg = 0; float *arg1 = 0 ; float temp1 ; float result; + SWIG_check_num_args("glm::radians",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::radians",1,"float const &"); + temp1=(float)lua_tonumber(L,1); arg1=&temp1; result = (float)glm::radians((float const &)*arg1); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_radians__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = 0 ; glm::vec2 result; + SWIG_check_num_args("glm::radians",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::radians",1,"glm::vec2 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("radians",1,SWIGTYPE_p_glm__vec2); } + result = glm::radians((glm::vec2 const &)*arg1); { glm::vec2 * resultptr = new glm::vec2((const glm::vec2 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_radians__SWIG_2(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; glm::vec3 result; + SWIG_check_num_args("glm::radians",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::radians",1,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("radians",1,SWIGTYPE_p_glm__vec3); } + result = glm::radians((glm::vec3 const &)*arg1); { glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_radians__SWIG_3(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = 0 ; glm::vec4 result; + SWIG_check_num_args("glm::radians",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::radians",1,"glm::vec4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("radians",1,SWIGTYPE_p_glm__vec4); } + result = glm::radians((glm::vec4 const &)*arg1); { glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_radians(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v = 0; { { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_radians__SWIG_1(L);} check_1: if (argc == 1) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_radians__SWIG_2(L);} check_2: if (argc == 1) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; return _wrap_radians__SWIG_3(L);} check_3: if (argc == 1) { + return _wrap_radians__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'radians'\n" + " Possible C/C++ prototypes are:\n" " glm::radians(float const &)\n" " glm::radians(glm::vec2 const &)\n" + " glm::radians(glm::vec3 const &)\n" " glm::radians(glm::vec4 const &)\n"); lua_error(L);return 0; } +static int _wrap_degrees__SWIG_0(lua_State* L) { int SWIG_arg = 0; float *arg1 = 0 ; float temp1 ; float result; + SWIG_check_num_args("glm::degrees",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::degrees",1,"float const &"); + temp1=(float)lua_tonumber(L,1); arg1=&temp1; result = (float)glm::degrees((float const &)*arg1); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_degrees__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = 0 ; glm::vec2 result; + SWIG_check_num_args("glm::degrees",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::degrees",1,"glm::vec2 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("degrees",1,SWIGTYPE_p_glm__vec2); } + result = glm::degrees((glm::vec2 const &)*arg1); { glm::vec2 * resultptr = new glm::vec2((const glm::vec2 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_degrees__SWIG_2(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; glm::vec3 result; + SWIG_check_num_args("glm::degrees",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::degrees",1,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("degrees",1,SWIGTYPE_p_glm__vec3); } + result = glm::degrees((glm::vec3 const &)*arg1); { glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_degrees__SWIG_3(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = 0 ; glm::vec4 result; + SWIG_check_num_args("glm::degrees",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::degrees",1,"glm::vec4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("degrees",1,SWIGTYPE_p_glm__vec4); } + result = glm::degrees((glm::vec4 const &)*arg1); { glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_degrees(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v = 0; { { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_degrees__SWIG_1(L);} check_1: if (argc == 1) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_degrees__SWIG_2(L);} check_2: if (argc == 1) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; return _wrap_degrees__SWIG_3(L);} check_3: if (argc == 1) { + return _wrap_degrees__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'degrees'\n" + " Possible C/C++ prototypes are:\n" " glm::degrees(float const &)\n" " glm::degrees(glm::vec2 const &)\n" + " glm::degrees(glm::vec3 const &)\n" " glm::degrees(glm::vec4 const &)\n"); lua_error(L);return 0; } +static int _wrap_sin__SWIG_0(lua_State* L) { int SWIG_arg = 0; float *arg1 = 0 ; float temp1 ; float result; + SWIG_check_num_args("glm::sin",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::sin",1,"float const &"); + temp1=(float)lua_tonumber(L,1); arg1=&temp1; result = (float)glm::sin((float const &)*arg1); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_sin__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = 0 ; glm::vec2 result; + SWIG_check_num_args("glm::sin",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::sin",1,"glm::vec2 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("sin",1,SWIGTYPE_p_glm__vec2); } + result = glm::sin((glm::vec2 const &)*arg1); { glm::vec2 * resultptr = new glm::vec2((const glm::vec2 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_sin__SWIG_2(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; glm::vec3 result; + SWIG_check_num_args("glm::sin",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::sin",1,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("sin",1,SWIGTYPE_p_glm__vec3); } + result = glm::sin((glm::vec3 const &)*arg1); { glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_sin__SWIG_3(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = 0 ; glm::vec4 result; + SWIG_check_num_args("glm::sin",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::sin",1,"glm::vec4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("sin",1,SWIGTYPE_p_glm__vec4); } + result = glm::sin((glm::vec4 const &)*arg1); { glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_sin(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v = 0; { { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_sin__SWIG_1(L);} check_1: if (argc == 1) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_sin__SWIG_2(L);} check_2: if (argc == 1) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; return _wrap_sin__SWIG_3(L);} check_3: if (argc == 1) { + return _wrap_sin__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'sin'\n" + " Possible C/C++ prototypes are:\n" " glm::sin(float const &)\n" " glm::sin(glm::vec2 const &)\n" + " glm::sin(glm::vec3 const &)\n" " glm::sin(glm::vec4 const &)\n"); lua_error(L);return 0; } +static int _wrap_cos__SWIG_0(lua_State* L) { int SWIG_arg = 0; float *arg1 = 0 ; float temp1 ; float result; + SWIG_check_num_args("glm::cos",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::cos",1,"float const &"); + temp1=(float)lua_tonumber(L,1); arg1=&temp1; result = (float)glm::cos((float const &)*arg1); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_cos__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = 0 ; glm::vec2 result; + SWIG_check_num_args("glm::cos",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::cos",1,"glm::vec2 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("cos",1,SWIGTYPE_p_glm__vec2); } + result = glm::cos((glm::vec2 const &)*arg1); { glm::vec2 * resultptr = new glm::vec2((const glm::vec2 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_cos__SWIG_2(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; glm::vec3 result; + SWIG_check_num_args("glm::cos",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::cos",1,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("cos",1,SWIGTYPE_p_glm__vec3); } + result = glm::cos((glm::vec3 const &)*arg1); { glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_cos__SWIG_3(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = 0 ; glm::vec4 result; + SWIG_check_num_args("glm::cos",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::cos",1,"glm::vec4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("cos",1,SWIGTYPE_p_glm__vec4); } + result = glm::cos((glm::vec4 const &)*arg1); { glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_cos(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v = 0; { { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_cos__SWIG_1(L);} check_1: if (argc == 1) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_cos__SWIG_2(L);} check_2: if (argc == 1) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; return _wrap_cos__SWIG_3(L);} check_3: if (argc == 1) { + return _wrap_cos__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'cos'\n" + " Possible C/C++ prototypes are:\n" " glm::cos(float const &)\n" " glm::cos(glm::vec2 const &)\n" + " glm::cos(glm::vec3 const &)\n" " glm::cos(glm::vec4 const &)\n"); lua_error(L);return 0; } +static int _wrap_tan__SWIG_0(lua_State* L) { int SWIG_arg = 0; float *arg1 = 0 ; float temp1 ; float result; + SWIG_check_num_args("glm::tan",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::tan",1,"float const &"); + temp1=(float)lua_tonumber(L,1); arg1=&temp1; result = (float)glm::tan((float const &)*arg1); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_tan__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = 0 ; glm::vec2 result; + SWIG_check_num_args("glm::tan",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::tan",1,"glm::vec2 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("tan",1,SWIGTYPE_p_glm__vec2); } + result = glm::tan((glm::vec2 const &)*arg1); { glm::vec2 * resultptr = new glm::vec2((const glm::vec2 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_tan__SWIG_2(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; glm::vec3 result; + SWIG_check_num_args("glm::tan",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::tan",1,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("tan",1,SWIGTYPE_p_glm__vec3); } + result = glm::tan((glm::vec3 const &)*arg1); { glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_tan__SWIG_3(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = 0 ; glm::vec4 result; + SWIG_check_num_args("glm::tan",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::tan",1,"glm::vec4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("tan",1,SWIGTYPE_p_glm__vec4); } + result = glm::tan((glm::vec4 const &)*arg1); { glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_tan(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v = 0; { { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_tan__SWIG_1(L);} check_1: if (argc == 1) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_tan__SWIG_2(L);} check_2: if (argc == 1) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; return _wrap_tan__SWIG_3(L);} check_3: if (argc == 1) { + return _wrap_tan__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'tan'\n" + " Possible C/C++ prototypes are:\n" " glm::tan(float const &)\n" " glm::tan(glm::vec2 const &)\n" + " glm::tan(glm::vec3 const &)\n" " glm::tan(glm::vec4 const &)\n"); lua_error(L);return 0; } +static int _wrap_asin__SWIG_0(lua_State* L) { int SWIG_arg = 0; float *arg1 = 0 ; float temp1 ; float result; + SWIG_check_num_args("glm::asin",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::asin",1,"float const &"); + temp1=(float)lua_tonumber(L,1); arg1=&temp1; result = (float)glm::asin((float const &)*arg1); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_asin__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = 0 ; glm::vec2 result; + SWIG_check_num_args("glm::asin",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::asin",1,"glm::vec2 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("asin",1,SWIGTYPE_p_glm__vec2); } + result = glm::asin((glm::vec2 const &)*arg1); { glm::vec2 * resultptr = new glm::vec2((const glm::vec2 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_asin__SWIG_2(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; glm::vec3 result; + SWIG_check_num_args("glm::asin",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::asin",1,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("asin",1,SWIGTYPE_p_glm__vec3); } + result = glm::asin((glm::vec3 const &)*arg1); { glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_asin__SWIG_3(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = 0 ; glm::vec4 result; + SWIG_check_num_args("glm::asin",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::asin",1,"glm::vec4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("asin",1,SWIGTYPE_p_glm__vec4); } + result = glm::asin((glm::vec4 const &)*arg1); { glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_asin(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v = 0; { { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_asin__SWIG_1(L);} check_1: if (argc == 1) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_asin__SWIG_2(L);} check_2: if (argc == 1) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; return _wrap_asin__SWIG_3(L);} check_3: if (argc == 1) { + return _wrap_asin__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'asin'\n" + " Possible C/C++ prototypes are:\n" " glm::asin(float const &)\n" " glm::asin(glm::vec2 const &)\n" + " glm::asin(glm::vec3 const &)\n" " glm::asin(glm::vec4 const &)\n"); lua_error(L);return 0; } +static int _wrap_acos__SWIG_0(lua_State* L) { int SWIG_arg = 0; float *arg1 = 0 ; float temp1 ; float result; + SWIG_check_num_args("glm::acos",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::acos",1,"float const &"); + temp1=(float)lua_tonumber(L,1); arg1=&temp1; result = (float)glm::acos((float const &)*arg1); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_acos__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = 0 ; glm::vec2 result; + SWIG_check_num_args("glm::acos",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::acos",1,"glm::vec2 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("acos",1,SWIGTYPE_p_glm__vec2); } + result = glm::acos((glm::vec2 const &)*arg1); { glm::vec2 * resultptr = new glm::vec2((const glm::vec2 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_acos__SWIG_2(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; glm::vec3 result; + SWIG_check_num_args("glm::acos",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::acos",1,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("acos",1,SWIGTYPE_p_glm__vec3); } + result = glm::acos((glm::vec3 const &)*arg1); { glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_acos__SWIG_3(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = 0 ; glm::vec4 result; + SWIG_check_num_args("glm::acos",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::acos",1,"glm::vec4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("acos",1,SWIGTYPE_p_glm__vec4); } + result = glm::acos((glm::vec4 const &)*arg1); { glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_acos(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v = 0; { { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_acos__SWIG_1(L);} check_1: if (argc == 1) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_acos__SWIG_2(L);} check_2: if (argc == 1) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; return _wrap_acos__SWIG_3(L);} check_3: if (argc == 1) { + return _wrap_acos__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'acos'\n" + " Possible C/C++ prototypes are:\n" " glm::acos(float const &)\n" " glm::acos(glm::vec2 const &)\n" + " glm::acos(glm::vec3 const &)\n" " glm::acos(glm::vec4 const &)\n"); lua_error(L);return 0; } +static int _wrap_atan__SWIG_0(lua_State* L) { int SWIG_arg = 0; float *arg1 = 0 ; float *arg2 = 0 ; float temp1 ; float temp2 ; + float result; SWIG_check_num_args("glm::atan",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::atan",1,"float const &"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::atan",2,"float const &"); temp1=(float)lua_tonumber(L,1); arg1=&temp1; + temp2=(float)lua_tonumber(L,2); arg2=&temp2; result = (float)glm::atan((float const &)*arg1,(float const &)*arg2); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_atan__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = 0 ; glm::vec2 *arg2 = 0 ; glm::vec2 result; + SWIG_check_num_args("glm::atan",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::atan",1,"glm::vec2 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::atan",2,"glm::vec2 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("atan",1,SWIGTYPE_p_glm__vec2); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("atan",2,SWIGTYPE_p_glm__vec2); } + result = glm::atan((glm::vec2 const &)*arg1,(glm::vec2 const &)*arg2); { + glm::vec2 * resultptr = new glm::vec2((const glm::vec2 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_atan__SWIG_2(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; glm::vec3 *arg2 = 0 ; glm::vec3 result; + SWIG_check_num_args("glm::atan",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::atan",1,"glm::vec3 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::atan",2,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("atan",1,SWIGTYPE_p_glm__vec3); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("atan",2,SWIGTYPE_p_glm__vec3); } + result = glm::atan((glm::vec3 const &)*arg1,(glm::vec3 const &)*arg2); { + glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_atan__SWIG_3(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = 0 ; glm::vec4 *arg2 = 0 ; glm::vec4 result; + SWIG_check_num_args("glm::atan",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::atan",1,"glm::vec4 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::atan",2,"glm::vec4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("atan",1,SWIGTYPE_p_glm__vec4); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("atan",2,SWIGTYPE_p_glm__vec4); } + result = glm::atan((glm::vec4 const &)*arg1,(glm::vec4 const &)*arg2); { + glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_atan__SWIG_4(lua_State* L) { int SWIG_arg = 0; float *arg1 = 0 ; float temp1 ; float result; + SWIG_check_num_args("glm::atan",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::atan",1,"float const &"); + temp1=(float)lua_tonumber(L,1); arg1=&temp1; result = (float)glm::atan((float const &)*arg1); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_atan__SWIG_5(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = 0 ; glm::vec2 result; + SWIG_check_num_args("glm::atan",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::atan",1,"glm::vec2 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("atan",1,SWIGTYPE_p_glm__vec2); } + result = glm::atan((glm::vec2 const &)*arg1); { glm::vec2 * resultptr = new glm::vec2((const glm::vec2 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_atan__SWIG_6(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; glm::vec3 result; + SWIG_check_num_args("glm::atan",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::atan",1,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("atan",1,SWIGTYPE_p_glm__vec3); } + result = glm::atan((glm::vec3 const &)*arg1); { glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_atan__SWIG_7(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = 0 ; glm::vec4 result; + SWIG_check_num_args("glm::atan",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::atan",1,"glm::vec4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("atan",1,SWIGTYPE_p_glm__vec4); } + result = glm::atan((glm::vec4 const &)*arg1); { glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_atan(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v = 0; { { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_atan__SWIG_5(L);} check_1: if (argc == 1) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_atan__SWIG_6(L);} check_2: if (argc == 1) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; return _wrap_atan__SWIG_7(L);} check_3: if (argc == 1) { + return _wrap_atan__SWIG_4(L);} if (argc == 2) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_5; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_5; return _wrap_atan__SWIG_1(L);} check_5: if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_6; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_6; return _wrap_atan__SWIG_2(L);} check_6: if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_7; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_7; return _wrap_atan__SWIG_3(L);} check_7: if (argc == 2) { + return _wrap_atan__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'atan'\n" + " Possible C/C++ prototypes are:\n" " glm::atan(float const &,float const &)\n" + " glm::atan(glm::vec2 const &,glm::vec2 const &)\n" " glm::atan(glm::vec3 const &,glm::vec3 const &)\n" + " glm::atan(glm::vec4 const &,glm::vec4 const &)\n" " glm::atan(float const &)\n" " glm::atan(glm::vec2 const &)\n" + " glm::atan(glm::vec3 const &)\n" " glm::atan(glm::vec4 const &)\n"); lua_error(L);return 0; } +static int _wrap_sinh__SWIG_0(lua_State* L) { int SWIG_arg = 0; float *arg1 = 0 ; float temp1 ; float result; + SWIG_check_num_args("glm::sinh",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::sinh",1,"float const &"); + temp1=(float)lua_tonumber(L,1); arg1=&temp1; result = (float)glm::sinh((float const &)*arg1); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_sinh__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = 0 ; glm::vec2 result; + SWIG_check_num_args("glm::sinh",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::sinh",1,"glm::vec2 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("sinh",1,SWIGTYPE_p_glm__vec2); } + result = glm::sinh((glm::vec2 const &)*arg1); { glm::vec2 * resultptr = new glm::vec2((const glm::vec2 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_sinh__SWIG_2(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; glm::vec3 result; + SWIG_check_num_args("glm::sinh",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::sinh",1,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("sinh",1,SWIGTYPE_p_glm__vec3); } + result = glm::sinh((glm::vec3 const &)*arg1); { glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_sinh__SWIG_3(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = 0 ; glm::vec4 result; + SWIG_check_num_args("glm::sinh",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::sinh",1,"glm::vec4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("sinh",1,SWIGTYPE_p_glm__vec4); } + result = glm::sinh((glm::vec4 const &)*arg1); { glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_sinh(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v = 0; { { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_sinh__SWIG_1(L);} check_1: if (argc == 1) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_sinh__SWIG_2(L);} check_2: if (argc == 1) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; return _wrap_sinh__SWIG_3(L);} check_3: if (argc == 1) { + return _wrap_sinh__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'sinh'\n" + " Possible C/C++ prototypes are:\n" " glm::sinh(float const &)\n" " glm::sinh(glm::vec2 const &)\n" + " glm::sinh(glm::vec3 const &)\n" " glm::sinh(glm::vec4 const &)\n"); lua_error(L);return 0; } +static int _wrap_cosh__SWIG_0(lua_State* L) { int SWIG_arg = 0; float *arg1 = 0 ; float temp1 ; float result; + SWIG_check_num_args("glm::cosh",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::cosh",1,"float const &"); + temp1=(float)lua_tonumber(L,1); arg1=&temp1; result = (float)glm::cosh((float const &)*arg1); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_cosh__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = 0 ; glm::vec2 result; + SWIG_check_num_args("glm::cosh",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::cosh",1,"glm::vec2 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("cosh",1,SWIGTYPE_p_glm__vec2); } + result = glm::cosh((glm::vec2 const &)*arg1); { glm::vec2 * resultptr = new glm::vec2((const glm::vec2 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_cosh__SWIG_2(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; glm::vec3 result; + SWIG_check_num_args("glm::cosh",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::cosh",1,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("cosh",1,SWIGTYPE_p_glm__vec3); } + result = glm::cosh((glm::vec3 const &)*arg1); { glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_cosh__SWIG_3(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = 0 ; glm::vec4 result; + SWIG_check_num_args("glm::cosh",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::cosh",1,"glm::vec4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("cosh",1,SWIGTYPE_p_glm__vec4); } + result = glm::cosh((glm::vec4 const &)*arg1); { glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_cosh(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v = 0; { { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_cosh__SWIG_1(L);} check_1: if (argc == 1) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_cosh__SWIG_2(L);} check_2: if (argc == 1) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; return _wrap_cosh__SWIG_3(L);} check_3: if (argc == 1) { + return _wrap_cosh__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'cosh'\n" + " Possible C/C++ prototypes are:\n" " glm::cosh(float const &)\n" " glm::cosh(glm::vec2 const &)\n" + " glm::cosh(glm::vec3 const &)\n" " glm::cosh(glm::vec4 const &)\n"); lua_error(L);return 0; } +static int _wrap_tanh__SWIG_0(lua_State* L) { int SWIG_arg = 0; float *arg1 = 0 ; float temp1 ; float result; + SWIG_check_num_args("glm::tanh",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::tanh",1,"float const &"); + temp1=(float)lua_tonumber(L,1); arg1=&temp1; result = (float)glm::tanh((float const &)*arg1); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_tanh__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = 0 ; glm::vec2 result; + SWIG_check_num_args("glm::tanh",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::tanh",1,"glm::vec2 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("tanh",1,SWIGTYPE_p_glm__vec2); } + result = glm::tanh((glm::vec2 const &)*arg1); { glm::vec2 * resultptr = new glm::vec2((const glm::vec2 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_tanh__SWIG_2(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; glm::vec3 result; + SWIG_check_num_args("glm::tanh",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::tanh",1,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("tanh",1,SWIGTYPE_p_glm__vec3); } + result = glm::tanh((glm::vec3 const &)*arg1); { glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_tanh__SWIG_3(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = 0 ; glm::vec4 result; + SWIG_check_num_args("glm::tanh",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::tanh",1,"glm::vec4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("tanh",1,SWIGTYPE_p_glm__vec4); } + result = glm::tanh((glm::vec4 const &)*arg1); { glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_tanh(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v = 0; { { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_tanh__SWIG_1(L);} check_1: if (argc == 1) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_tanh__SWIG_2(L);} check_2: if (argc == 1) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; return _wrap_tanh__SWIG_3(L);} check_3: if (argc == 1) { + return _wrap_tanh__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'tanh'\n" + " Possible C/C++ prototypes are:\n" " glm::tanh(float const &)\n" " glm::tanh(glm::vec2 const &)\n" + " glm::tanh(glm::vec3 const &)\n" " glm::tanh(glm::vec4 const &)\n"); lua_error(L);return 0; } +static int _wrap_asinh__SWIG_0(lua_State* L) { int SWIG_arg = 0; float *arg1 = 0 ; float temp1 ; float result; + SWIG_check_num_args("glm::asinh",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::asinh",1,"float const &"); + temp1=(float)lua_tonumber(L,1); arg1=&temp1; result = (float)glm::asinh((float const &)*arg1); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_asinh__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = 0 ; glm::vec2 result; + SWIG_check_num_args("glm::asinh",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::asinh",1,"glm::vec2 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("asinh",1,SWIGTYPE_p_glm__vec2); } + result = glm::asinh((glm::vec2 const &)*arg1); { glm::vec2 * resultptr = new glm::vec2((const glm::vec2 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_asinh__SWIG_2(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; glm::vec3 result; + SWIG_check_num_args("glm::asinh",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::asinh",1,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("asinh",1,SWIGTYPE_p_glm__vec3); } + result = glm::asinh((glm::vec3 const &)*arg1); { glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_asinh__SWIG_3(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = 0 ; glm::vec4 result; + SWIG_check_num_args("glm::asinh",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::asinh",1,"glm::vec4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("asinh",1,SWIGTYPE_p_glm__vec4); } + result = glm::asinh((glm::vec4 const &)*arg1); { glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_asinh(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v = 0; { { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_asinh__SWIG_1(L);} check_1: if (argc == 1) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_asinh__SWIG_2(L);} check_2: if (argc == 1) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; return _wrap_asinh__SWIG_3(L);} check_3: if (argc == 1) { + return _wrap_asinh__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'asinh'\n" + " Possible C/C++ prototypes are:\n" " glm::asinh(float const &)\n" " glm::asinh(glm::vec2 const &)\n" + " glm::asinh(glm::vec3 const &)\n" " glm::asinh(glm::vec4 const &)\n"); lua_error(L);return 0; } +static int _wrap_acosh__SWIG_0(lua_State* L) { int SWIG_arg = 0; float *arg1 = 0 ; float temp1 ; float result; + SWIG_check_num_args("glm::acosh",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::acosh",1,"float const &"); + temp1=(float)lua_tonumber(L,1); arg1=&temp1; result = (float)glm::acosh((float const &)*arg1); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_acosh__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = 0 ; glm::vec2 result; + SWIG_check_num_args("glm::acosh",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::acosh",1,"glm::vec2 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("acosh",1,SWIGTYPE_p_glm__vec2); } + result = glm::acosh((glm::vec2 const &)*arg1); { glm::vec2 * resultptr = new glm::vec2((const glm::vec2 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_acosh__SWIG_2(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; glm::vec3 result; + SWIG_check_num_args("glm::acosh",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::acosh",1,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("acosh",1,SWIGTYPE_p_glm__vec3); } + result = glm::acosh((glm::vec3 const &)*arg1); { glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_acosh__SWIG_3(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = 0 ; glm::vec4 result; + SWIG_check_num_args("glm::acosh",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::acosh",1,"glm::vec4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("acosh",1,SWIGTYPE_p_glm__vec4); } + result = glm::acosh((glm::vec4 const &)*arg1); { glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_acosh(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v = 0; { { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_acosh__SWIG_1(L);} check_1: if (argc == 1) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_acosh__SWIG_2(L);} check_2: if (argc == 1) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; return _wrap_acosh__SWIG_3(L);} check_3: if (argc == 1) { + return _wrap_acosh__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'acosh'\n" + " Possible C/C++ prototypes are:\n" " glm::acosh(float const &)\n" " glm::acosh(glm::vec2 const &)\n" + " glm::acosh(glm::vec3 const &)\n" " glm::acosh(glm::vec4 const &)\n"); lua_error(L);return 0; } +static int _wrap_atanh__SWIG_0(lua_State* L) { int SWIG_arg = 0; float *arg1 = 0 ; float temp1 ; float result; + SWIG_check_num_args("glm::atanh",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::atanh",1,"float const &"); + temp1=(float)lua_tonumber(L,1); arg1=&temp1; result = (float)glm::atanh((float const &)*arg1); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_atanh__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = 0 ; glm::vec2 result; + SWIG_check_num_args("glm::atanh",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::atanh",1,"glm::vec2 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("atanh",1,SWIGTYPE_p_glm__vec2); } + result = glm::atanh((glm::vec2 const &)*arg1); { glm::vec2 * resultptr = new glm::vec2((const glm::vec2 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_atanh__SWIG_2(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; glm::vec3 result; + SWIG_check_num_args("glm::atanh",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::atanh",1,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("atanh",1,SWIGTYPE_p_glm__vec3); } + result = glm::atanh((glm::vec3 const &)*arg1); { glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_atanh__SWIG_3(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = 0 ; glm::vec4 result; + SWIG_check_num_args("glm::atanh",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::atanh",1,"glm::vec4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("atanh",1,SWIGTYPE_p_glm__vec4); } + result = glm::atanh((glm::vec4 const &)*arg1); { glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_atanh(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v = 0; { { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_atanh__SWIG_1(L);} check_1: if (argc == 1) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_atanh__SWIG_2(L);} check_2: if (argc == 1) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; return _wrap_atanh__SWIG_3(L);} check_3: if (argc == 1) { + return _wrap_atanh__SWIG_0(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'atanh'\n" + " Possible C/C++ prototypes are:\n" " glm::atanh(float const &)\n" " glm::atanh(glm::vec2 const &)\n" + " glm::atanh(glm::vec3 const &)\n" " glm::atanh(glm::vec4 const &)\n"); lua_error(L);return 0; } +static int _wrap_epsilonEqual__SWIG_0(lua_State* L) { int SWIG_arg = 0; float *arg1 = 0 ; float *arg2 = 0 ; float *arg3 = 0 ; + float temp1 ; float temp2 ; float temp3 ; bool result; SWIG_check_num_args("glm::epsilonEqual",3,3) + if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::epsilonEqual",1,"float const &"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::epsilonEqual",2,"float const &"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("glm::epsilonEqual",3,"float const &"); temp1=(float)lua_tonumber(L,1); arg1=&temp1; + temp2=(float)lua_tonumber(L,2); arg2=&temp2; temp3=(float)lua_tonumber(L,3); arg3=&temp3; + result = (bool)glm::epsilonEqual((float const &)*arg1,(float const &)*arg2,(float const &)*arg3); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_epsilonEqual__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = 0 ; glm::vec2 *arg2 = 0 ; + float *arg3 = 0 ; float temp3 ; glm::vec2 result; SWIG_check_num_args("glm::epsilonEqual",3,3) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::epsilonEqual",1,"glm::vec2 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::epsilonEqual",2,"glm::vec2 const &"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("glm::epsilonEqual",3,"float const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ + SWIG_fail_ptr("epsilonEqual",1,SWIGTYPE_p_glm__vec2); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec2,0))){ + SWIG_fail_ptr("epsilonEqual",2,SWIGTYPE_p_glm__vec2); } temp3=(float)lua_tonumber(L,3); arg3=&temp3; + result = glm::epsilonEqual((glm::vec2 const &)*arg1,(glm::vec2 const &)*arg2,(float const &)*arg3); { + glm::vec2 * resultptr = new glm::vec2((const glm::vec2 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_epsilonEqual__SWIG_2(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; glm::vec3 *arg2 = 0 ; + float *arg3 = 0 ; float temp3 ; glm::vec3 result; SWIG_check_num_args("glm::epsilonEqual",3,3) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::epsilonEqual",1,"glm::vec3 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::epsilonEqual",2,"glm::vec3 const &"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("glm::epsilonEqual",3,"float const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ + SWIG_fail_ptr("epsilonEqual",1,SWIGTYPE_p_glm__vec3); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ + SWIG_fail_ptr("epsilonEqual",2,SWIGTYPE_p_glm__vec3); } temp3=(float)lua_tonumber(L,3); arg3=&temp3; + result = glm::epsilonEqual((glm::vec3 const &)*arg1,(glm::vec3 const &)*arg2,(float const &)*arg3); { + glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_epsilonEqual(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 3) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_epsilonEqual__SWIG_1(L);} check_1: + if (argc == 3) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_epsilonEqual__SWIG_2(L);} check_2: + if (argc == 3) { return _wrap_epsilonEqual__SWIG_0(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'epsilonEqual'\n" " Possible C/C++ prototypes are:\n" + " glm::epsilonEqual(float const &,float const &,float const &)\n" + " glm::epsilonEqual(glm::vec2 const &,glm::vec2 const &,float const &)\n" + " glm::epsilonEqual(glm::vec3 const &,glm::vec3 const &,float const &)\n"); lua_error(L);return 0; } +static int _wrap_epsilonNotEqual__SWIG_0(lua_State* L) { int SWIG_arg = 0; float *arg1 = 0 ; float *arg2 = 0 ; float *arg3 = 0 ; + float temp1 ; float temp2 ; float temp3 ; bool result; SWIG_check_num_args("glm::epsilonNotEqual",3,3) + if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::epsilonNotEqual",1,"float const &"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::epsilonNotEqual",2,"float const &"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("glm::epsilonNotEqual",3,"float const &"); temp1=(float)lua_tonumber(L,1); arg1=&temp1; + temp2=(float)lua_tonumber(L,2); arg2=&temp2; temp3=(float)lua_tonumber(L,3); arg3=&temp3; + result = (bool)glm::epsilonNotEqual((float const &)*arg1,(float const &)*arg2,(float const &)*arg3); + lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_epsilonNotEqual__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = 0 ; glm::vec2 *arg2 = 0 ; + float *arg3 = 0 ; float temp3 ; glm::vec2 result; SWIG_check_num_args("glm::epsilonNotEqual",3,3) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::epsilonNotEqual",1,"glm::vec2 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::epsilonNotEqual",2,"glm::vec2 const &"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("glm::epsilonNotEqual",3,"float const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ + SWIG_fail_ptr("epsilonNotEqual",1,SWIGTYPE_p_glm__vec2); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec2,0))){ + SWIG_fail_ptr("epsilonNotEqual",2,SWIGTYPE_p_glm__vec2); } temp3=(float)lua_tonumber(L,3); arg3=&temp3; + result = glm::epsilonNotEqual((glm::vec2 const &)*arg1,(glm::vec2 const &)*arg2,(float const &)*arg3); { + glm::vec2 * resultptr = new glm::vec2((const glm::vec2 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_epsilonNotEqual__SWIG_2(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; glm::vec3 *arg2 = 0 ; + float *arg3 = 0 ; float temp3 ; glm::vec3 result; SWIG_check_num_args("glm::epsilonNotEqual",3,3) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::epsilonNotEqual",1,"glm::vec3 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::epsilonNotEqual",2,"glm::vec3 const &"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("glm::epsilonNotEqual",3,"float const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ + SWIG_fail_ptr("epsilonNotEqual",1,SWIGTYPE_p_glm__vec3); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ + SWIG_fail_ptr("epsilonNotEqual",2,SWIGTYPE_p_glm__vec3); } temp3=(float)lua_tonumber(L,3); arg3=&temp3; + result = glm::epsilonNotEqual((glm::vec3 const &)*arg1,(glm::vec3 const &)*arg2,(float const &)*arg3); { + glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_epsilonNotEqual(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 3) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_epsilonNotEqual__SWIG_1(L);} check_1: + if (argc == 3) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_epsilonNotEqual__SWIG_2(L);} check_2: + if (argc == 3) { return _wrap_epsilonNotEqual__SWIG_0(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'epsilonNotEqual'\n" " Possible C/C++ prototypes are:\n" + " glm::epsilonNotEqual(float const &,float const &,float const &)\n" + " glm::epsilonNotEqual(glm::vec2 const &,glm::vec2 const &,float const &)\n" + " glm::epsilonNotEqual(glm::vec3 const &,glm::vec3 const &,float const &)\n"); lua_error(L);return 0; } +static int _wrap_row__SWIG_0(lua_State* L) { int SWIG_arg = 0; glm::mat3 *arg1 = 0 ; glm::length_t *arg2 = 0 ; + glm::length_t temp2 ; glm::vec3 result; SWIG_check_num_args("glm::row",2,2) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::row",1,"glm::mat3 const &"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::row",2,"glm::length_t const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__mat3,0))){ SWIG_fail_ptr("row",1,SWIGTYPE_p_glm__mat3); } + temp2=(glm::length_t)lua_tonumber(L,2); arg2=&temp2; result = glm::row((glm::mat3 const &)*arg1,(int const &)*arg2); { + glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_row__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::mat4 *arg1 = 0 ; glm::length_t *arg2 = 0 ; + glm::length_t temp2 ; glm::vec4 result; SWIG_check_num_args("glm::row",2,2) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::row",1,"glm::mat4 const &"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::row",2,"glm::length_t const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__mat4,0))){ SWIG_fail_ptr("row",1,SWIGTYPE_p_glm__mat4); } + temp2=(glm::length_t)lua_tonumber(L,2); arg2=&temp2; result = glm::row((glm::mat4 const &)*arg1,(int const &)*arg2); { + glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_row__SWIG_2(lua_State* L) { int SWIG_arg = 0; glm::mat3 *arg1 = 0 ; glm::length_t *arg2 = 0 ; + glm::vec3 *arg3 = 0 ; glm::length_t temp2 ; glm::mat3 result; SWIG_check_num_args("glm::row",3,3) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::row",1,"glm::mat3 const &"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::row",2,"glm::length_t const &"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("glm::row",3,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__mat3,0))){ SWIG_fail_ptr("row",1,SWIGTYPE_p_glm__mat3); } + temp2=(glm::length_t)lua_tonumber(L,2); arg2=&temp2; + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("row",3,SWIGTYPE_p_glm__vec3); } + result = glm::row((glm::mat3 const &)*arg1,(int const &)*arg2,(glm::vec3 const &)*arg3); { + glm::mat3 * resultptr = new glm::mat3((const glm::mat3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__mat3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_row__SWIG_3(lua_State* L) { int SWIG_arg = 0; glm::mat4 *arg1 = 0 ; glm::length_t *arg2 = 0 ; + glm::vec4 *arg3 = 0 ; glm::length_t temp2 ; glm::mat4 result; SWIG_check_num_args("glm::row",3,3) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::row",1,"glm::mat4 const &"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::row",2,"glm::length_t const &"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("glm::row",3,"glm::vec4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__mat4,0))){ SWIG_fail_ptr("row",1,SWIGTYPE_p_glm__mat4); } + temp2=(glm::length_t)lua_tonumber(L,2); arg2=&temp2; + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("row",3,SWIGTYPE_p_glm__vec4); } + result = glm::row((glm::mat4 const &)*arg1,(int const &)*arg2,(glm::vec4 const &)*arg3); { + glm::mat4 * resultptr = new glm::mat4((const glm::mat4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__mat4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_row(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { int _v = 0; { { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__mat3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_row__SWIG_0(L);} check_1: if (argc == 2) { + return _wrap_row__SWIG_1(L);} if (argc == 3) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__mat3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; { { void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; return _wrap_row__SWIG_2(L);} check_3: if (argc == 3) { + return _wrap_row__SWIG_3(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'row'\n" + " Possible C/C++ prototypes are:\n" " glm::row(glm::mat3 const &,glm::length_t const &)\n" + " glm::row(glm::mat4 const &,glm::length_t const &)\n" + " glm::row(glm::mat3 const &,glm::length_t const &,glm::vec3 const &)\n" + " glm::row(glm::mat4 const &,glm::length_t const &,glm::vec4 const &)\n"); lua_error(L);return 0; } +static int _wrap_column__SWIG_0(lua_State* L) { int SWIG_arg = 0; glm::mat3 *arg1 = 0 ; glm::length_t *arg2 = 0 ; + glm::length_t temp2 ; glm::vec3 result; SWIG_check_num_args("glm::column",2,2) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::column",1,"glm::mat3 const &"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::column",2,"glm::length_t const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__mat3,0))){ SWIG_fail_ptr("column",1,SWIGTYPE_p_glm__mat3); } + temp2=(glm::length_t)lua_tonumber(L,2); arg2=&temp2; result = glm::column((glm::mat3 const &)*arg1,(int const &)*arg2); { + glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_column__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::mat4 *arg1 = 0 ; glm::length_t *arg2 = 0 ; + glm::length_t temp2 ; glm::vec4 result; SWIG_check_num_args("glm::column",2,2) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::column",1,"glm::mat4 const &"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::column",2,"glm::length_t const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__mat4,0))){ SWIG_fail_ptr("column",1,SWIGTYPE_p_glm__mat4); } + temp2=(glm::length_t)lua_tonumber(L,2); arg2=&temp2; result = glm::column((glm::mat4 const &)*arg1,(int const &)*arg2); { + glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_column__SWIG_2(lua_State* L) { int SWIG_arg = 0; glm::mat3 *arg1 = 0 ; glm::length_t *arg2 = 0 ; + glm::vec3 *arg3 = 0 ; glm::length_t temp2 ; glm::mat3 result; SWIG_check_num_args("glm::column",3,3) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::column",1,"glm::mat3 const &"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::column",2,"glm::length_t const &"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("glm::column",3,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__mat3,0))){ SWIG_fail_ptr("column",1,SWIGTYPE_p_glm__mat3); } + temp2=(glm::length_t)lua_tonumber(L,2); arg2=&temp2; + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("column",3,SWIGTYPE_p_glm__vec3); } + result = glm::column((glm::mat3 const &)*arg1,(int const &)*arg2,(glm::vec3 const &)*arg3); { + glm::mat3 * resultptr = new glm::mat3((const glm::mat3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__mat3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_column__SWIG_3(lua_State* L) { int SWIG_arg = 0; glm::mat4 *arg1 = 0 ; glm::length_t *arg2 = 0 ; + glm::vec4 *arg3 = 0 ; glm::length_t temp2 ; glm::mat4 result; SWIG_check_num_args("glm::column",3,3) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::column",1,"glm::mat4 const &"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::column",2,"glm::length_t const &"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("glm::column",3,"glm::vec4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__mat4,0))){ SWIG_fail_ptr("column",1,SWIGTYPE_p_glm__mat4); } + temp2=(glm::length_t)lua_tonumber(L,2); arg2=&temp2; + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("column",3,SWIGTYPE_p_glm__vec4); } + result = glm::column((glm::mat4 const &)*arg1,(int const &)*arg2,(glm::vec4 const &)*arg3); { + glm::mat4 * resultptr = new glm::mat4((const glm::mat4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__mat4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_column(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { int _v = 0; { + { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__mat3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_column__SWIG_0(L);} check_1: if (argc == 2) { + return _wrap_column__SWIG_1(L);} if (argc == 3) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__mat3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; { { void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; return _wrap_column__SWIG_2(L);} check_3: if (argc == 3) { + return _wrap_column__SWIG_3(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'column'\n" + " Possible C/C++ prototypes are:\n" " glm::column(glm::mat3 const &,glm::length_t const &)\n" + " glm::column(glm::mat4 const &,glm::length_t const &)\n" + " glm::column(glm::mat3 const &,glm::length_t const &,glm::vec3 const &)\n" + " glm::column(glm::mat4 const &,glm::length_t const &,glm::vec4 const &)\n"); lua_error(L);return 0; } +static int _wrap_affineInverse__SWIG_0(lua_State* L) { int SWIG_arg = 0; glm::mat3 *arg1 = 0 ; glm::mat3 result; + SWIG_check_num_args("glm::affineInverse",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::affineInverse",1,"glm::mat3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__mat3,0))){ + SWIG_fail_ptr("affineInverse",1,SWIGTYPE_p_glm__mat3); } result = glm::affineInverse((glm::mat3 const &)*arg1); { + glm::mat3 * resultptr = new glm::mat3((const glm::mat3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__mat3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_affineInverse__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::mat4 *arg1 = 0 ; glm::mat4 result; + SWIG_check_num_args("glm::affineInverse",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::affineInverse",1,"glm::mat4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__mat4,0))){ + SWIG_fail_ptr("affineInverse",1,SWIGTYPE_p_glm__mat4); } result = glm::affineInverse((glm::mat4 const &)*arg1); { + glm::mat4 * resultptr = new glm::mat4((const glm::mat4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__mat4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_affineInverse(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v = 0; + { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__mat3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_affineInverse__SWIG_0(L);} check_1: + if (argc == 1) { return _wrap_affineInverse__SWIG_1(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'affineInverse'\n" " Possible C/C++ prototypes are:\n" + " glm::affineInverse(glm::mat3 const &)\n" " glm::affineInverse(glm::mat4 const &)\n"); lua_error(L);return 0; } +static int _wrap_inverseTranspose__SWIG_0(lua_State* L) { int SWIG_arg = 0; glm::mat3 *arg1 = 0 ; glm::mat3 result; + SWIG_check_num_args("glm::inverseTranspose",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::inverseTranspose",1,"glm::mat3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__mat3,0))){ + SWIG_fail_ptr("inverseTranspose",1,SWIGTYPE_p_glm__mat3); } result = glm::inverseTranspose((glm::mat3 const &)*arg1); { + glm::mat3 * resultptr = new glm::mat3((const glm::mat3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__mat3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_inverseTranspose__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::mat4 *arg1 = 0 ; glm::mat4 result; + SWIG_check_num_args("glm::inverseTranspose",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::inverseTranspose",1,"glm::mat4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__mat4,0))){ + SWIG_fail_ptr("inverseTranspose",1,SWIGTYPE_p_glm__mat4); } result = glm::inverseTranspose((glm::mat4 const &)*arg1); { + glm::mat4 * resultptr = new glm::mat4((const glm::mat4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__mat4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_inverseTranspose(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__mat3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_inverseTranspose__SWIG_0(L);} check_1: + if (argc == 1) { return _wrap_inverseTranspose__SWIG_1(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'inverseTranspose'\n" " Possible C/C++ prototypes are:\n" + " glm::inverseTranspose(glm::mat3 const &)\n" " glm::inverseTranspose(glm::mat4 const &)\n"); lua_error(L);return 0; } +static int _wrap_translate__SWIG_0(lua_State* L) { int SWIG_arg = 0; glm::mat4 *arg1 = 0 ; glm::vec3 *arg2 = 0 ; + glm::mat4 result; SWIG_check_num_args("glm::translate",2,2) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::translate",1,"glm::mat4 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::translate",2,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__mat4,0))){ + SWIG_fail_ptr("translate",1,SWIGTYPE_p_glm__mat4); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ + SWIG_fail_ptr("translate",2,SWIGTYPE_p_glm__vec3); } + result = glm::translate((glm::mat4 const &)*arg1,(glm::vec3 const &)*arg2); { + glm::mat4 * resultptr = new glm::mat4((const glm::mat4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__mat4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_rotate__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::mat4 *arg1 = 0 ; float *arg2 = 0 ; glm::vec3 *arg3 = 0 ; + float temp2 ; glm::mat4 result; SWIG_check_num_args("glm::rotate",3,3) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::rotate",1,"glm::mat4 const &"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::rotate",2,"float const &"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("glm::rotate",3,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__mat4,0))){ SWIG_fail_ptr("rotate",1,SWIGTYPE_p_glm__mat4); } + temp2=(float)lua_tonumber(L,2); arg2=&temp2; if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_glm__vec3,0))){ + SWIG_fail_ptr("rotate",3,SWIGTYPE_p_glm__vec3); } + result = glm::rotate((glm::mat4 const &)*arg1,(float const &)*arg2,(glm::vec3 const &)*arg3); { + glm::mat4 * resultptr = new glm::mat4((const glm::mat4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__mat4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_scale__SWIG_0(lua_State* L) { int SWIG_arg = 0; glm::mat4 *arg1 = 0 ; glm::vec3 *arg2 = 0 ; glm::mat4 result; + SWIG_check_num_args("glm::scale",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::scale",1,"glm::mat4 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::scale",2,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__mat4,0))){ SWIG_fail_ptr("scale",1,SWIGTYPE_p_glm__mat4); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("scale",2,SWIGTYPE_p_glm__vec3); } + result = glm::scale((glm::mat4 const &)*arg1,(glm::vec3 const &)*arg2); { + glm::mat4 * resultptr = new glm::mat4((const glm::mat4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__mat4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_lookAt(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; glm::vec3 *arg2 = 0 ; glm::vec3 *arg3 = 0 ; + glm::mat4 result; SWIG_check_num_args("glm::lookAt",3,3) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::lookAt",1,"glm::vec3 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::lookAt",2,"glm::vec3 const &"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("glm::lookAt",3,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("lookAt",1,SWIGTYPE_p_glm__vec3); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("lookAt",2,SWIGTYPE_p_glm__vec3); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("lookAt",3,SWIGTYPE_p_glm__vec3); } + result = glm::lookAt((glm::vec3 const &)*arg1,(glm::vec3 const &)*arg2,(glm::vec3 const &)*arg3); { + glm::mat4 * resultptr = new glm::mat4((const glm::mat4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__mat4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_ortho__SWIG_0(lua_State* L) { int SWIG_arg = 0; float *arg1 = 0 ; float *arg2 = 0 ; float *arg3 = 0 ; + float *arg4 = 0 ; float temp1 ; float temp2 ; float temp3 ; float temp4 ; glm::mat4 result; + SWIG_check_num_args("glm::ortho",4,4) if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::ortho",1,"float const &"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::ortho",2,"float const &"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("glm::ortho",3,"float const &"); + if(!lua_isnumber(L,4)) SWIG_fail_arg("glm::ortho",4,"float const &"); temp1=(float)lua_tonumber(L,1); arg1=&temp1; + temp2=(float)lua_tonumber(L,2); arg2=&temp2; temp3=(float)lua_tonumber(L,3); arg3=&temp3; + temp4=(float)lua_tonumber(L,4); arg4=&temp4; + result = glm::ortho((float const &)*arg1,(float const &)*arg2,(float const &)*arg3,(float const &)*arg4); { + glm::mat4 * resultptr = new glm::mat4((const glm::mat4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__mat4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_ortho__SWIG_1(lua_State* L) { int SWIG_arg = 0; float *arg1 = 0 ; float *arg2 = 0 ; float *arg3 = 0 ; + float *arg4 = 0 ; float *arg5 = 0 ; float *arg6 = 0 ; float temp1 ; float temp2 ; float temp3 ; float temp4 ; float temp5 ; + float temp6 ; glm::mat4 result; SWIG_check_num_args("glm::ortho",6,6) + if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::ortho",1,"float const &"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::ortho",2,"float const &"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("glm::ortho",3,"float const &"); + if(!lua_isnumber(L,4)) SWIG_fail_arg("glm::ortho",4,"float const &"); + if(!lua_isnumber(L,5)) SWIG_fail_arg("glm::ortho",5,"float const &"); + if(!lua_isnumber(L,6)) SWIG_fail_arg("glm::ortho",6,"float const &"); temp1=(float)lua_tonumber(L,1); arg1=&temp1; + temp2=(float)lua_tonumber(L,2); arg2=&temp2; temp3=(float)lua_tonumber(L,3); arg3=&temp3; + temp4=(float)lua_tonumber(L,4); arg4=&temp4; temp5=(float)lua_tonumber(L,5); arg5=&temp5; + temp6=(float)lua_tonumber(L,6); arg6=&temp6; + result = glm::ortho((float const &)*arg1,(float const &)*arg2,(float const &)*arg3,(float const &)*arg4,(float const &)*arg5,(float const &)*arg6); + { glm::mat4 * resultptr = new glm::mat4((const glm::mat4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__mat4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_ortho(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); if (argc == 4) { + return _wrap_ortho__SWIG_0(L);} if (argc == 6) { return _wrap_ortho__SWIG_1(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ortho'\n" " Possible C/C++ prototypes are:\n" + " glm::ortho(float const &,float const &,float const &,float const &)\n" + " glm::ortho(float const &,float const &,float const &,float const &,float const &,float const &)\n"); + lua_error(L);return 0; } +static int _wrap_frustum(lua_State* L) { int SWIG_arg = 0; float *arg1 = 0 ; float *arg2 = 0 ; float *arg3 = 0 ; + float *arg4 = 0 ; float *arg5 = 0 ; float *arg6 = 0 ; float temp1 ; float temp2 ; float temp3 ; float temp4 ; float temp5 ; + float temp6 ; glm::mat4 result; SWIG_check_num_args("glm::frustum",6,6) + if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::frustum",1,"float const &"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::frustum",2,"float const &"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("glm::frustum",3,"float const &"); + if(!lua_isnumber(L,4)) SWIG_fail_arg("glm::frustum",4,"float const &"); + if(!lua_isnumber(L,5)) SWIG_fail_arg("glm::frustum",5,"float const &"); + if(!lua_isnumber(L,6)) SWIG_fail_arg("glm::frustum",6,"float const &"); temp1=(float)lua_tonumber(L,1); arg1=&temp1; + temp2=(float)lua_tonumber(L,2); arg2=&temp2; temp3=(float)lua_tonumber(L,3); arg3=&temp3; + temp4=(float)lua_tonumber(L,4); arg4=&temp4; temp5=(float)lua_tonumber(L,5); arg5=&temp5; + temp6=(float)lua_tonumber(L,6); arg6=&temp6; + result = glm::frustum((float const &)*arg1,(float const &)*arg2,(float const &)*arg3,(float const &)*arg4,(float const &)*arg5,(float const &)*arg6); + { glm::mat4 * resultptr = new glm::mat4((const glm::mat4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__mat4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_perspective(lua_State* L) { int SWIG_arg = 0; float *arg1 = 0 ; float *arg2 = 0 ; float *arg3 = 0 ; + float *arg4 = 0 ; float temp1 ; float temp2 ; float temp3 ; float temp4 ; glm::mat4 result; + SWIG_check_num_args("glm::perspective",4,4) if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::perspective",1,"float const &"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::perspective",2,"float const &"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("glm::perspective",3,"float const &"); + if(!lua_isnumber(L,4)) SWIG_fail_arg("glm::perspective",4,"float const &"); temp1=(float)lua_tonumber(L,1); arg1=&temp1; + temp2=(float)lua_tonumber(L,2); arg2=&temp2; temp3=(float)lua_tonumber(L,3); arg3=&temp3; + temp4=(float)lua_tonumber(L,4); arg4=&temp4; + result = glm::perspective((float const &)*arg1,(float const &)*arg2,(float const &)*arg3,(float const &)*arg4); { + glm::mat4 * resultptr = new glm::mat4((const glm::mat4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__mat4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_perspectiveFov(lua_State* L) { int SWIG_arg = 0; float *arg1 = 0 ; float *arg2 = 0 ; float *arg3 = 0 ; + float *arg4 = 0 ; float *arg5 = 0 ; float temp1 ; float temp2 ; float temp3 ; float temp4 ; float temp5 ; glm::mat4 result; + SWIG_check_num_args("glm::perspectiveFov",5,5) if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::perspectiveFov",1,"float const &"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::perspectiveFov",2,"float const &"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("glm::perspectiveFov",3,"float const &"); + if(!lua_isnumber(L,4)) SWIG_fail_arg("glm::perspectiveFov",4,"float const &"); + if(!lua_isnumber(L,5)) SWIG_fail_arg("glm::perspectiveFov",5,"float const &"); temp1=(float)lua_tonumber(L,1); arg1=&temp1; + temp2=(float)lua_tonumber(L,2); arg2=&temp2; temp3=(float)lua_tonumber(L,3); arg3=&temp3; + temp4=(float)lua_tonumber(L,4); arg4=&temp4; temp5=(float)lua_tonumber(L,5); arg5=&temp5; + result = glm::perspectiveFov((float const &)*arg1,(float const &)*arg2,(float const &)*arg3,(float const &)*arg4,(float const &)*arg5); + { glm::mat4 * resultptr = new glm::mat4((const glm::mat4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__mat4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_infinitePerspective(lua_State* L) { int SWIG_arg = 0; float *arg1 = 0 ; float *arg2 = 0 ; float *arg3 = 0 ; + float temp1 ; float temp2 ; float temp3 ; glm::mat4 result; SWIG_check_num_args("glm::infinitePerspective",3,3) + if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::infinitePerspective",1,"float const &"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::infinitePerspective",2,"float const &"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("glm::infinitePerspective",3,"float const &"); + temp1=(float)lua_tonumber(L,1); arg1=&temp1; temp2=(float)lua_tonumber(L,2); arg2=&temp2; + temp3=(float)lua_tonumber(L,3); arg3=&temp3; + result = glm::infinitePerspective((float const &)*arg1,(float const &)*arg2,(float const &)*arg3); { + glm::mat4 * resultptr = new glm::mat4((const glm::mat4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__mat4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_tweakedInfinitePerspective(lua_State* L) { int SWIG_arg = 0; float *arg1 = 0 ; float *arg2 = 0 ; + float *arg3 = 0 ; float temp1 ; float temp2 ; float temp3 ; glm::mat4 result; + SWIG_check_num_args("glm::tweakedInfinitePerspective",3,3) + if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::tweakedInfinitePerspective",1,"float const &"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::tweakedInfinitePerspective",2,"float const &"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("glm::tweakedInfinitePerspective",3,"float const &"); + temp1=(float)lua_tonumber(L,1); arg1=&temp1; temp2=(float)lua_tonumber(L,2); arg2=&temp2; + temp3=(float)lua_tonumber(L,3); arg3=&temp3; + result = glm::tweakedInfinitePerspective((float const &)*arg1,(float const &)*arg2,(float const &)*arg3); { + glm::mat4 * resultptr = new glm::mat4((const glm::mat4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__mat4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_project(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; glm::mat4 *arg2 = 0 ; glm::mat4 *arg3 = 0 ; + glm::vec4 *arg4 = 0 ; glm::vec3 result; SWIG_check_num_args("glm::project",4,4) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::project",1,"glm::vec3 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::project",2,"glm::mat4 const &"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("glm::project",3,"glm::mat4 const &"); + if(!lua_isuserdata(L,4)) SWIG_fail_arg("glm::project",4,"glm::vec4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("project",1,SWIGTYPE_p_glm__vec3); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__mat4,0))){ SWIG_fail_ptr("project",2,SWIGTYPE_p_glm__mat4); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_glm__mat4,0))){ SWIG_fail_ptr("project",3,SWIGTYPE_p_glm__mat4); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("project",4,SWIGTYPE_p_glm__vec4); } + result = glm::project((glm::vec3 const &)*arg1,(glm::mat4 const &)*arg2,(glm::mat4 const &)*arg3,(glm::vec4 const &)*arg4); { + glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_unProject(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; glm::mat4 *arg2 = 0 ; glm::mat4 *arg3 = 0 ; + glm::vec4 *arg4 = 0 ; glm::vec3 result; SWIG_check_num_args("glm::unProject",4,4) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::unProject",1,"glm::vec3 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::unProject",2,"glm::mat4 const &"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("glm::unProject",3,"glm::mat4 const &"); + if(!lua_isuserdata(L,4)) SWIG_fail_arg("glm::unProject",4,"glm::vec4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ + SWIG_fail_ptr("unProject",1,SWIGTYPE_p_glm__vec3); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__mat4,0))){ + SWIG_fail_ptr("unProject",2,SWIGTYPE_p_glm__mat4); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_glm__mat4,0))){ + SWIG_fail_ptr("unProject",3,SWIGTYPE_p_glm__mat4); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_glm__vec4,0))){ + SWIG_fail_ptr("unProject",4,SWIGTYPE_p_glm__vec4); } + result = glm::unProject((glm::vec3 const &)*arg1,(glm::mat4 const &)*arg2,(glm::mat4 const &)*arg3,(glm::vec4 const &)*arg4); + { glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_pickMatrix(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = 0 ; glm::vec2 *arg2 = 0 ; glm::vec4 *arg3 = 0 ; + glm::mat4 result; SWIG_check_num_args("glm::pickMatrix",3,3) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::pickMatrix",1,"glm::vec2 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::pickMatrix",2,"glm::vec2 const &"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("glm::pickMatrix",3,"glm::vec4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ + SWIG_fail_ptr("pickMatrix",1,SWIGTYPE_p_glm__vec2); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec2,0))){ + SWIG_fail_ptr("pickMatrix",2,SWIGTYPE_p_glm__vec2); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_glm__vec4,0))){ + SWIG_fail_ptr("pickMatrix",3,SWIGTYPE_p_glm__vec4); } + result = glm::pickMatrix((glm::vec2 const &)*arg1,(glm::vec2 const &)*arg2,(glm::vec4 const &)*arg3); { + glm::mat4 * resultptr = new glm::mat4((const glm::mat4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__mat4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_lerp__SWIG_1(lua_State* L) { int SWIG_arg = 0; float *arg1 = 0 ; float *arg2 = 0 ; float *arg3 = 0 ; + float temp1 ; float temp2 ; float temp3 ; float result; SWIG_check_num_args("glm::lerp",3,3) + if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::lerp",1,"float const &"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::lerp",2,"float const &"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("glm::lerp",3,"float const &"); temp1=(float)lua_tonumber(L,1); arg1=&temp1; + temp2=(float)lua_tonumber(L,2); arg2=&temp2; temp3=(float)lua_tonumber(L,3); arg3=&temp3; + result = (float)glm::lerp((float const &)*arg1,(float const &)*arg2,(float const &)*arg3); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_lerp__SWIG_2(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = 0 ; glm::vec2 *arg2 = 0 ; + glm::vec2 *arg3 = 0 ; glm::vec2 result; SWIG_check_num_args("glm::lerp",3,3) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::lerp",1,"glm::vec2 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::lerp",2,"glm::vec2 const &"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("glm::lerp",3,"glm::vec2 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("lerp",1,SWIGTYPE_p_glm__vec2); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("lerp",2,SWIGTYPE_p_glm__vec2); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("lerp",3,SWIGTYPE_p_glm__vec2); } + result = glm::lerp((glm::vec2 const &)*arg1,(glm::vec2 const &)*arg2,(glm::vec2 const &)*arg3); { + glm::vec2 * resultptr = new glm::vec2((const glm::vec2 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_lerp__SWIG_3(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; glm::vec3 *arg2 = 0 ; + glm::vec3 *arg3 = 0 ; glm::vec3 result; SWIG_check_num_args("glm::lerp",3,3) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::lerp",1,"glm::vec3 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::lerp",2,"glm::vec3 const &"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("glm::lerp",3,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("lerp",1,SWIGTYPE_p_glm__vec3); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("lerp",2,SWIGTYPE_p_glm__vec3); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("lerp",3,SWIGTYPE_p_glm__vec3); } + result = glm::lerp((glm::vec3 const &)*arg1,(glm::vec3 const &)*arg2,(glm::vec3 const &)*arg3); { + glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_lerp__SWIG_4(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = 0 ; glm::vec4 *arg2 = 0 ; + glm::vec4 *arg3 = 0 ; glm::vec4 result; SWIG_check_num_args("glm::lerp",3,3) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::lerp",1,"glm::vec4 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::lerp",2,"glm::vec4 const &"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("glm::lerp",3,"glm::vec4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("lerp",1,SWIGTYPE_p_glm__vec4); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("lerp",2,SWIGTYPE_p_glm__vec4); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("lerp",3,SWIGTYPE_p_glm__vec4); } + result = glm::lerp((glm::vec4 const &)*arg1,(glm::vec4 const &)*arg2,(glm::vec4 const &)*arg3); { + glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_lerp__SWIG_5(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = 0 ; glm::vec2 *arg2 = 0 ; float *arg3 = 0 ; + float temp3 ; glm::vec2 result; SWIG_check_num_args("glm::lerp",3,3) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::lerp",1,"glm::vec2 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::lerp",2,"glm::vec2 const &"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("glm::lerp",3,"float const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("lerp",1,SWIGTYPE_p_glm__vec2); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("lerp",2,SWIGTYPE_p_glm__vec2); } + temp3=(float)lua_tonumber(L,3); arg3=&temp3; + result = glm::lerp((glm::vec2 const &)*arg1,(glm::vec2 const &)*arg2,(float const &)*arg3); { + glm::vec2 * resultptr = new glm::vec2((const glm::vec2 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_lerp__SWIG_6(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; glm::vec3 *arg2 = 0 ; float *arg3 = 0 ; + float temp3 ; glm::vec3 result; SWIG_check_num_args("glm::lerp",3,3) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::lerp",1,"glm::vec3 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::lerp",2,"glm::vec3 const &"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("glm::lerp",3,"float const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("lerp",1,SWIGTYPE_p_glm__vec3); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("lerp",2,SWIGTYPE_p_glm__vec3); } + temp3=(float)lua_tonumber(L,3); arg3=&temp3; + result = glm::lerp((glm::vec3 const &)*arg1,(glm::vec3 const &)*arg2,(float const &)*arg3); { + glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_lerp__SWIG_7(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = 0 ; glm::vec4 *arg2 = 0 ; float *arg3 = 0 ; + float temp3 ; glm::vec4 result; SWIG_check_num_args("glm::lerp",3,3) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::lerp",1,"glm::vec4 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::lerp",2,"glm::vec4 const &"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("glm::lerp",3,"float const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("lerp",1,SWIGTYPE_p_glm__vec4); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("lerp",2,SWIGTYPE_p_glm__vec4); } + temp3=(float)lua_tonumber(L,3); arg3=&temp3; + result = glm::lerp((glm::vec4 const &)*arg1,(glm::vec4 const &)*arg2,(float const &)*arg3); { + glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_lerp(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 3) { int _v = 0; { { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__quat, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__quat, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; { { _v = lua_isnumber(L,argv[2]); } } if (!_v) goto check_1; + return _wrap_lerp__SWIG_0(L);} check_1: if (argc == 3) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; { { void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_lerp__SWIG_2(L);} check_2: if (argc == 3) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; { { void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; return _wrap_lerp__SWIG_3(L);} check_3: if (argc == 3) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_4; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_4; { { void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_4; return _wrap_lerp__SWIG_4(L);} check_4: if (argc == 3) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_5; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_5; return _wrap_lerp__SWIG_5(L);} check_5: if (argc == 3) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_6; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_6; return _wrap_lerp__SWIG_6(L);} check_6: if (argc == 3) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_7; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_7; return _wrap_lerp__SWIG_7(L);} check_7: if (argc == 3) { + return _wrap_lerp__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'lerp'\n" + " Possible C/C++ prototypes are:\n" " glm::lerp(glm::quat const &,glm::quat const &,float)\n" + " glm::lerp(float const &,float const &,float const &)\n" + " glm::lerp(glm::vec2 const &,glm::vec2 const &,glm::vec2 const &)\n" + " glm::lerp(glm::vec3 const &,glm::vec3 const &,glm::vec3 const &)\n" + " glm::lerp(glm::vec4 const &,glm::vec4 const &,glm::vec4 const &)\n" + " glm::lerp(glm::vec2 const &,glm::vec2 const &,float const &)\n" + " glm::lerp(glm::vec3 const &,glm::vec3 const &,float const &)\n" + " glm::lerp(glm::vec4 const &,glm::vec4 const &,float const &)\n"); lua_error(L);return 0; } +static int _wrap_saturate__SWIG_0(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = 0 ; glm::vec2 result; + SWIG_check_num_args("glm::saturate",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::saturate",1,"glm::vec2 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("saturate",1,SWIGTYPE_p_glm__vec2); } + result = glm::saturate((glm::vec2 const &)*arg1); { glm::vec2 * resultptr = new glm::vec2((const glm::vec2 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_saturate__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; glm::vec3 result; + SWIG_check_num_args("glm::saturate",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::saturate",1,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("saturate",1,SWIGTYPE_p_glm__vec3); } + result = glm::saturate((glm::vec3 const &)*arg1); { glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_saturate__SWIG_2(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = 0 ; glm::vec4 result; + SWIG_check_num_args("glm::saturate",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::saturate",1,"glm::vec4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("saturate",1,SWIGTYPE_p_glm__vec4); } + result = glm::saturate((glm::vec4 const &)*arg1); { glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_saturate(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v = 0; { { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_saturate__SWIG_0(L);} check_1: if (argc == 1) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_saturate__SWIG_1(L);} check_2: if (argc == 1) { + return _wrap_saturate__SWIG_2(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'saturate'\n" + " Possible C/C++ prototypes are:\n" " glm::saturate(glm::vec2 const &)\n" " glm::saturate(glm::vec3 const &)\n" + " glm::saturate(glm::vec4 const &)\n"); lua_error(L);return 0; } +static int _wrap_atan2__SWIG_0(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = 0 ; glm::vec2 *arg2 = 0 ; glm::vec2 result; + SWIG_check_num_args("glm::atan2",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::atan2",1,"glm::vec2 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::atan2",2,"glm::vec2 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("atan2",1,SWIGTYPE_p_glm__vec2); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("atan2",2,SWIGTYPE_p_glm__vec2); } + result = glm::atan2((glm::vec2 const &)*arg1,(glm::vec2 const &)*arg2); { + glm::vec2 * resultptr = new glm::vec2((const glm::vec2 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_atan2__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; glm::vec3 *arg2 = 0 ; glm::vec3 result; + SWIG_check_num_args("glm::atan2",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::atan2",1,"glm::vec3 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::atan2",2,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("atan2",1,SWIGTYPE_p_glm__vec3); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("atan2",2,SWIGTYPE_p_glm__vec3); } + result = glm::atan2((glm::vec3 const &)*arg1,(glm::vec3 const &)*arg2); { + glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_atan2__SWIG_2(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = 0 ; glm::vec4 *arg2 = 0 ; glm::vec4 result; + SWIG_check_num_args("glm::atan2",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::atan2",1,"glm::vec4 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::atan2",2,"glm::vec4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("atan2",1,SWIGTYPE_p_glm__vec4); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("atan2",2,SWIGTYPE_p_glm__vec4); } + result = glm::atan2((glm::vec4 const &)*arg1,(glm::vec4 const &)*arg2); { + glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_atan2(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v = 0; { { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_atan2__SWIG_0(L);} check_1: if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_atan2__SWIG_1(L);} check_2: if (argc == 2) { + return _wrap_atan2__SWIG_2(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'atan2'\n" + " Possible C/C++ prototypes are:\n" " glm::atan2(glm::vec2 const &,glm::vec2 const &)\n" + " glm::atan2(glm::vec3 const &,glm::vec3 const &)\n" " glm::atan2(glm::vec4 const &,glm::vec4 const &)\n"); + lua_error(L);return 0; } +static int _wrap_isfinite__SWIG_0(lua_State* L) { int SWIG_arg = 0; float *arg1 = 0 ; bool result; + SWIG_check_num_args("glm::isfinite",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::isfinite",1,"float &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_float,0))){ SWIG_fail_ptr("isfinite",1,SWIGTYPE_p_float); } + result = (bool)glm::isfinite(*arg1); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_isfinite__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = 0 ; glm::vec2 result; + SWIG_check_num_args("glm::isfinite",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::isfinite",1,"glm::vec2 &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("isfinite",1,SWIGTYPE_p_glm__vec2); } + result = glm::isfinite(*arg1); { glm::vec2 * resultptr = new glm::vec2((const glm::vec2 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_isfinite__SWIG_2(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; glm::vec3 result; + SWIG_check_num_args("glm::isfinite",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::isfinite",1,"glm::vec3 &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("isfinite",1,SWIGTYPE_p_glm__vec3); } + result = glm::isfinite(*arg1); { glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_isfinite__SWIG_3(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = 0 ; glm::vec4 result; + SWIG_check_num_args("glm::isfinite",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::isfinite",1,"glm::vec4 &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("isfinite",1,SWIGTYPE_p_glm__vec4); } + result = glm::isfinite(*arg1); { glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_isfinite(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v = 0; { { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_float, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_isfinite__SWIG_0(L);} check_1: if (argc == 1) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_isfinite__SWIG_1(L);} check_2: if (argc == 1) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; return _wrap_isfinite__SWIG_2(L);} check_3: if (argc == 1) { + return _wrap_isfinite__SWIG_3(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'isfinite'\n" + " Possible C/C++ prototypes are:\n" " glm::isfinite(float &)\n" " glm::isfinite(glm::vec2 &)\n" + " glm::isfinite(glm::vec3 &)\n" " glm::isfinite(glm::vec4 &)\n"); lua_error(L);return 0; } +static int _wrap_fastSqrt__SWIG_0(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = 0 ; glm::vec2 result; + SWIG_check_num_args("glm::fastSqrt",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::fastSqrt",1,"glm::vec2 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("fastSqrt",1,SWIGTYPE_p_glm__vec2); } + result = glm::fastSqrt((glm::vec2 const &)*arg1); { glm::vec2 * resultptr = new glm::vec2((const glm::vec2 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_fastSqrt__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; glm::vec3 result; + SWIG_check_num_args("glm::fastSqrt",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::fastSqrt",1,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("fastSqrt",1,SWIGTYPE_p_glm__vec3); } + result = glm::fastSqrt((glm::vec3 const &)*arg1); { glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_fastSqrt__SWIG_2(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = 0 ; glm::vec4 result; + SWIG_check_num_args("glm::fastSqrt",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::fastSqrt",1,"glm::vec4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("fastSqrt",1,SWIGTYPE_p_glm__vec4); } + result = glm::fastSqrt((glm::vec4 const &)*arg1); { glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_fastSqrt(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v = 0; { { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_fastSqrt__SWIG_0(L);} check_1: if (argc == 1) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_fastSqrt__SWIG_1(L);} check_2: if (argc == 1) { + return _wrap_fastSqrt__SWIG_2(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'fastSqrt'\n" + " Possible C/C++ prototypes are:\n" " glm::fastSqrt(glm::vec2 const &)\n" " glm::fastSqrt(glm::vec3 const &)\n" + " glm::fastSqrt(glm::vec4 const &)\n"); lua_error(L);return 0; } +static int _wrap_fastInverseSqrt__SWIG_0(lua_State* L) { int SWIG_arg = 0; float *arg1 = 0 ; float temp1 ; float result; + SWIG_check_num_args("glm::fastInverseSqrt",1,1) + if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::fastInverseSqrt",1,"float const &"); temp1=(float)lua_tonumber(L,1); arg1=&temp1; + result = (float)glm::fastInverseSqrt((float const &)*arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_fastInverseSqrt__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = 0 ; glm::vec2 result; + SWIG_check_num_args("glm::fastInverseSqrt",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::fastInverseSqrt",1,"glm::vec2 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ + SWIG_fail_ptr("fastInverseSqrt",1,SWIGTYPE_p_glm__vec2); } result = glm::fastInverseSqrt((glm::vec2 const &)*arg1); { + glm::vec2 * resultptr = new glm::vec2((const glm::vec2 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_fastInverseSqrt__SWIG_2(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; glm::vec3 result; + SWIG_check_num_args("glm::fastInverseSqrt",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::fastInverseSqrt",1,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ + SWIG_fail_ptr("fastInverseSqrt",1,SWIGTYPE_p_glm__vec3); } result = glm::fastInverseSqrt((glm::vec3 const &)*arg1); { + glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_fastInverseSqrt__SWIG_3(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = 0 ; glm::vec4 result; + SWIG_check_num_args("glm::fastInverseSqrt",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::fastInverseSqrt",1,"glm::vec4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ + SWIG_fail_ptr("fastInverseSqrt",1,SWIGTYPE_p_glm__vec4); } result = glm::fastInverseSqrt((glm::vec4 const &)*arg1); { + glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_fastInverseSqrt(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_fastInverseSqrt__SWIG_1(L);} check_1: + if (argc == 1) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_fastInverseSqrt__SWIG_2(L);} check_2: + if (argc == 1) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; return _wrap_fastInverseSqrt__SWIG_3(L);} check_3: + if (argc == 1) { return _wrap_fastInverseSqrt__SWIG_0(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'fastInverseSqrt'\n" " Possible C/C++ prototypes are:\n" + " glm::fastInverseSqrt(float const &)\n" " glm::fastInverseSqrt(glm::vec2 const &)\n" + " glm::fastInverseSqrt(glm::vec3 const &)\n" " glm::fastInverseSqrt(glm::vec4 const &)\n"); lua_error(L);return 0; } +static int _wrap_fastLength__SWIG_0(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = 0 ; float result; + SWIG_check_num_args("glm::fastLength",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::fastLength",1,"glm::vec2 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ + SWIG_fail_ptr("fastLength",1,SWIGTYPE_p_glm__vec2); } result = (float)glm::fastLength((glm::vec2 const &)*arg1); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_fastLength__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; float result; + SWIG_check_num_args("glm::fastLength",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::fastLength",1,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ + SWIG_fail_ptr("fastLength",1,SWIGTYPE_p_glm__vec3); } result = (float)glm::fastLength((glm::vec3 const &)*arg1); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_fastLength__SWIG_2(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = 0 ; float result; + SWIG_check_num_args("glm::fastLength",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::fastLength",1,"glm::vec4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ + SWIG_fail_ptr("fastLength",1,SWIGTYPE_p_glm__vec4); } result = (float)glm::fastLength((glm::vec4 const &)*arg1); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_fastLength(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v = 0; { + { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_fastLength__SWIG_0(L);} check_1: + if (argc == 1) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_fastLength__SWIG_1(L);} check_2: + if (argc == 1) { return _wrap_fastLength__SWIG_2(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'fastLength'\n" " Possible C/C++ prototypes are:\n" + " glm::fastLength(glm::vec2 const &)\n" " glm::fastLength(glm::vec3 const &)\n" + " glm::fastLength(glm::vec4 const &)\n"); lua_error(L);return 0; } +static int _wrap_fastDistance__SWIG_0(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = 0 ; glm::vec2 *arg2 = 0 ; + float result; SWIG_check_num_args("glm::fastDistance",2,2) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::fastDistance",1,"glm::vec2 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::fastDistance",2,"glm::vec2 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ + SWIG_fail_ptr("fastDistance",1,SWIGTYPE_p_glm__vec2); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec2,0))){ + SWIG_fail_ptr("fastDistance",2,SWIGTYPE_p_glm__vec2); } + result = (float)glm::fastDistance((glm::vec2 const &)*arg1,(glm::vec2 const &)*arg2); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_fastDistance__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; glm::vec3 *arg2 = 0 ; + float result; SWIG_check_num_args("glm::fastDistance",2,2) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::fastDistance",1,"glm::vec3 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::fastDistance",2,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ + SWIG_fail_ptr("fastDistance",1,SWIGTYPE_p_glm__vec3); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ + SWIG_fail_ptr("fastDistance",2,SWIGTYPE_p_glm__vec3); } + result = (float)glm::fastDistance((glm::vec3 const &)*arg1,(glm::vec3 const &)*arg2); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_fastDistance__SWIG_2(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = 0 ; glm::vec4 *arg2 = 0 ; + float result; SWIG_check_num_args("glm::fastDistance",2,2) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::fastDistance",1,"glm::vec4 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::fastDistance",2,"glm::vec4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ + SWIG_fail_ptr("fastDistance",1,SWIGTYPE_p_glm__vec4); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec4,0))){ + SWIG_fail_ptr("fastDistance",2,SWIGTYPE_p_glm__vec4); } + result = (float)glm::fastDistance((glm::vec4 const &)*arg1,(glm::vec4 const &)*arg2); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_fastDistance(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_fastDistance__SWIG_0(L);} check_1: + if (argc == 2) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_fastDistance__SWIG_1(L);} check_2: + if (argc == 2) { return _wrap_fastDistance__SWIG_2(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'fastDistance'\n" " Possible C/C++ prototypes are:\n" + " glm::fastDistance(glm::vec2 const &,glm::vec2 const &)\n" " glm::fastDistance(glm::vec3 const &,glm::vec3 const &)\n" + " glm::fastDistance(glm::vec4 const &,glm::vec4 const &)\n"); lua_error(L);return 0; } +static int _wrap_fastNormalize__SWIG_0(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = 0 ; glm::vec2 result; + SWIG_check_num_args("glm::fastNormalize",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::fastNormalize",1,"glm::vec2 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ + SWIG_fail_ptr("fastNormalize",1,SWIGTYPE_p_glm__vec2); } result = glm::fastNormalize((glm::vec2 const &)*arg1); { + glm::vec2 * resultptr = new glm::vec2((const glm::vec2 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_fastNormalize__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; glm::vec3 result; + SWIG_check_num_args("glm::fastNormalize",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::fastNormalize",1,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ + SWIG_fail_ptr("fastNormalize",1,SWIGTYPE_p_glm__vec3); } result = glm::fastNormalize((glm::vec3 const &)*arg1); { + glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_fastNormalize__SWIG_2(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = 0 ; glm::vec4 result; + SWIG_check_num_args("glm::fastNormalize",1,1) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::fastNormalize",1,"glm::vec4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ + SWIG_fail_ptr("fastNormalize",1,SWIGTYPE_p_glm__vec4); } result = glm::fastNormalize((glm::vec4 const &)*arg1); { + glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_fastNormalize(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v = 0; + { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_fastNormalize__SWIG_0(L);} check_1: + if (argc == 1) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_fastNormalize__SWIG_1(L);} check_2: + if (argc == 1) { return _wrap_fastNormalize__SWIG_2(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'fastNormalize'\n" " Possible C/C++ prototypes are:\n" + " glm::fastNormalize(glm::vec2 const &)\n" " glm::fastNormalize(glm::vec3 const &)\n" + " glm::fastNormalize(glm::vec4 const &)\n"); lua_error(L);return 0; } +static int _wrap_length2__SWIG_0(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = 0 ; float result; + SWIG_check_num_args("glm::length2",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::length2",1,"glm::vec2 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("length2",1,SWIGTYPE_p_glm__vec2); } + result = (float)glm::length2((glm::vec2 const &)*arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; + if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_length2__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; float result; + SWIG_check_num_args("glm::length2",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::length2",1,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("length2",1,SWIGTYPE_p_glm__vec3); } + result = (float)glm::length2((glm::vec3 const &)*arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; + if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_length2__SWIG_2(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = 0 ; float result; + SWIG_check_num_args("glm::length2",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::length2",1,"glm::vec4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("length2",1,SWIGTYPE_p_glm__vec4); } + result = (float)glm::length2((glm::vec4 const &)*arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; + if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_length2(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v = 0; { { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_length2__SWIG_0(L);} check_1: if (argc == 1) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_length2__SWIG_1(L);} check_2: if (argc == 1) { + return _wrap_length2__SWIG_2(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'length2'\n" + " Possible C/C++ prototypes are:\n" " glm::length2(glm::vec2 const &)\n" " glm::length2(glm::vec3 const &)\n" + " glm::length2(glm::vec4 const &)\n"); lua_error(L);return 0; } +static int _wrap_distance2__SWIG_0(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = 0 ; glm::vec2 *arg2 = 0 ; float result; + SWIG_check_num_args("glm::distance2",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::distance2",1,"glm::vec2 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::distance2",2,"glm::vec2 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ + SWIG_fail_ptr("distance2",1,SWIGTYPE_p_glm__vec2); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec2,0))){ + SWIG_fail_ptr("distance2",2,SWIGTYPE_p_glm__vec2); } + result = (float)glm::distance2((glm::vec2 const &)*arg1,(glm::vec2 const &)*arg2); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_distance2__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; glm::vec3 *arg2 = 0 ; float result; + SWIG_check_num_args("glm::distance2",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::distance2",1,"glm::vec3 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::distance2",2,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ + SWIG_fail_ptr("distance2",1,SWIGTYPE_p_glm__vec3); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ + SWIG_fail_ptr("distance2",2,SWIGTYPE_p_glm__vec3); } + result = (float)glm::distance2((glm::vec3 const &)*arg1,(glm::vec3 const &)*arg2); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_distance2__SWIG_2(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = 0 ; glm::vec4 *arg2 = 0 ; float result; + SWIG_check_num_args("glm::distance2",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::distance2",1,"glm::vec4 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::distance2",2,"glm::vec4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ + SWIG_fail_ptr("distance2",1,SWIGTYPE_p_glm__vec4); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec4,0))){ + SWIG_fail_ptr("distance2",2,SWIGTYPE_p_glm__vec4); } + result = (float)glm::distance2((glm::vec4 const &)*arg1,(glm::vec4 const &)*arg2); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_distance2(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v = 0; { + { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_distance2__SWIG_0(L);} check_1: + if (argc == 2) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_distance2__SWIG_1(L);} check_2: + if (argc == 2) { return _wrap_distance2__SWIG_2(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'distance2'\n" " Possible C/C++ prototypes are:\n" + " glm::distance2(glm::vec2 const &,glm::vec2 const &)\n" " glm::distance2(glm::vec3 const &,glm::vec3 const &)\n" + " glm::distance2(glm::vec4 const &,glm::vec4 const &)\n"); lua_error(L);return 0; } +static int _wrap_l1Norm__SWIG_0(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; glm::vec3 *arg2 = 0 ; float result; + SWIG_check_num_args("glm::l1Norm",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::l1Norm",1,"glm::vec3 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::l1Norm",2,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("l1Norm",1,SWIGTYPE_p_glm__vec3); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("l1Norm",2,SWIGTYPE_p_glm__vec3); } + result = (float)glm::l1Norm((glm::vec3 const &)*arg1,(glm::vec3 const &)*arg2); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_l1Norm__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; float result; + SWIG_check_num_args("glm::l1Norm",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::l1Norm",1,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("l1Norm",1,SWIGTYPE_p_glm__vec3); } + result = (float)glm::l1Norm((glm::vec3 const &)*arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; + if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_l1Norm(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { + return _wrap_l1Norm__SWIG_1(L);} if (argc == 2) { return _wrap_l1Norm__SWIG_0(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'l1Norm'\n" " Possible C/C++ prototypes are:\n" + " glm::l1Norm(glm::vec3 const &,glm::vec3 const &)\n" " glm::l1Norm(glm::vec3 const &)\n"); lua_error(L);return 0; } +static int _wrap_l2Norm__SWIG_0(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; glm::vec3 *arg2 = 0 ; float result; + SWIG_check_num_args("glm::l2Norm",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::l2Norm",1,"glm::vec3 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::l2Norm",2,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("l2Norm",1,SWIGTYPE_p_glm__vec3); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("l2Norm",2,SWIGTYPE_p_glm__vec3); } + result = (float)glm::l2Norm((glm::vec3 const &)*arg1,(glm::vec3 const &)*arg2); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_l2Norm__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; float result; + SWIG_check_num_args("glm::l2Norm",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::l2Norm",1,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("l2Norm",1,SWIGTYPE_p_glm__vec3); } + result = (float)glm::l2Norm((glm::vec3 const &)*arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; + if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_l2Norm(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { + return _wrap_l2Norm__SWIG_1(L);} if (argc == 2) { return _wrap_l2Norm__SWIG_0(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'l2Norm'\n" " Possible C/C++ prototypes are:\n" + " glm::l2Norm(glm::vec3 const &,glm::vec3 const &)\n" " glm::l2Norm(glm::vec3 const &)\n"); lua_error(L);return 0; } +static int _wrap_lxNorm__SWIG_0(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; glm::vec3 *arg2 = 0 ; + unsigned int arg3 ; float result; SWIG_check_num_args("glm::lxNorm",3,3) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::lxNorm",1,"glm::vec3 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::lxNorm",2,"glm::vec3 const &"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("glm::lxNorm",3,"unsigned int"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("lxNorm",1,SWIGTYPE_p_glm__vec3); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("lxNorm",2,SWIGTYPE_p_glm__vec3); } + SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (unsigned int)lua_tonumber(L, 3); + result = (float)glm::lxNorm((glm::vec3 const &)*arg1,(glm::vec3 const &)*arg2,arg3); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_lxNorm__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; unsigned int arg2 ; float result; + SWIG_check_num_args("glm::lxNorm",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::lxNorm",1,"glm::vec3 const &"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::lxNorm",2,"unsigned int"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("lxNorm",1,SWIGTYPE_p_glm__vec3); } + SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned int)lua_tonumber(L, 2); + result = (float)glm::lxNorm((glm::vec3 const &)*arg1,arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; + return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_lxNorm(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { + return _wrap_lxNorm__SWIG_1(L);} if (argc == 3) { return _wrap_lxNorm__SWIG_0(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'lxNorm'\n" " Possible C/C++ prototypes are:\n" + " glm::lxNorm(glm::vec3 const &,glm::vec3 const &,unsigned int)\n" " glm::lxNorm(glm::vec3 const &,unsigned int)\n"); + lua_error(L);return 0; } +static int _wrap_perp__SWIG_0(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = 0 ; glm::vec2 *arg2 = 0 ; glm::vec2 result; + SWIG_check_num_args("glm::perp",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::perp",1,"glm::vec2 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::perp",2,"glm::vec2 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("perp",1,SWIGTYPE_p_glm__vec2); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("perp",2,SWIGTYPE_p_glm__vec2); } + result = glm::perp((glm::vec2 const &)*arg1,(glm::vec2 const &)*arg2); { + glm::vec2 * resultptr = new glm::vec2((const glm::vec2 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_perp__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; glm::vec3 *arg2 = 0 ; glm::vec3 result; + SWIG_check_num_args("glm::perp",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::perp",1,"glm::vec3 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::perp",2,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("perp",1,SWIGTYPE_p_glm__vec3); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("perp",2,SWIGTYPE_p_glm__vec3); } + result = glm::perp((glm::vec3 const &)*arg1,(glm::vec3 const &)*arg2); { + glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_perp(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v = 0; { { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_perp__SWIG_0(L);} check_1: if (argc == 2) { + return _wrap_perp__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'perp'\n" + " Possible C/C++ prototypes are:\n" " glm::perp(glm::vec2 const &,glm::vec2 const &)\n" + " glm::perp(glm::vec3 const &,glm::vec3 const &)\n"); lua_error(L);return 0; } +static int _wrap_slerp__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; glm::vec3 *arg2 = 0 ; float *arg3 = 0 ; + float temp3 ; glm::vec3 result; SWIG_check_num_args("glm::slerp",3,3) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::slerp",1,"glm::vec3 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::slerp",2,"glm::vec3 const &"); + if(!lua_isnumber(L,3)) SWIG_fail_arg("glm::slerp",3,"float const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("slerp",1,SWIGTYPE_p_glm__vec3); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("slerp",2,SWIGTYPE_p_glm__vec3); } + temp3=(float)lua_tonumber(L,3); arg3=&temp3; + result = glm::slerp((glm::vec3 const &)*arg1,(glm::vec3 const &)*arg2,(float const &)*arg3); { + glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_slerp(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 3) { int _v = 0; { { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__quat, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__quat, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_slerp__SWIG_0(L);} check_1: if (argc == 3) { + return _wrap_slerp__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'slerp'\n" + " Possible C/C++ prototypes are:\n" " glm::slerp(glm::quat const &,glm::quat const &,float)\n" + " glm::slerp(glm::vec3 const &,glm::vec3 const &,float const &)\n"); lua_error(L);return 0; } +static int _wrap_rotate__SWIG_2(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = 0 ; float *arg2 = 0 ; float temp2 ; + glm::vec2 result; SWIG_check_num_args("glm::rotate",2,2) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::rotate",1,"glm::vec2 const &"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::rotate",2,"float const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("rotate",1,SWIGTYPE_p_glm__vec2); } + temp2=(float)lua_tonumber(L,2); arg2=&temp2; result = glm::rotate((glm::vec2 const &)*arg1,(float const &)*arg2); { + glm::vec2 * resultptr = new glm::vec2((const glm::vec2 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_rotate__SWIG_3(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; float *arg2 = 0 ; glm::vec3 *arg3 = 0 ; + float temp2 ; glm::vec3 result; SWIG_check_num_args("glm::rotate",3,3) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::rotate",1,"glm::vec3 const &"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::rotate",2,"float const &"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("glm::rotate",3,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("rotate",1,SWIGTYPE_p_glm__vec3); } + temp2=(float)lua_tonumber(L,2); arg2=&temp2; if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_glm__vec3,0))){ + SWIG_fail_ptr("rotate",3,SWIGTYPE_p_glm__vec3); } + result = glm::rotate((glm::vec3 const &)*arg1,(float const &)*arg2,(glm::vec3 const &)*arg3); { + glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_rotate__SWIG_4(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = 0 ; float *arg2 = 0 ; glm::vec3 *arg3 = 0 ; + float temp2 ; glm::vec4 result; SWIG_check_num_args("glm::rotate",3,3) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::rotate",1,"glm::vec4 const &"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::rotate",2,"float const &"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("glm::rotate",3,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("rotate",1,SWIGTYPE_p_glm__vec4); } + temp2=(float)lua_tonumber(L,2); arg2=&temp2; if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_glm__vec3,0))){ + SWIG_fail_ptr("rotate",3,SWIGTYPE_p_glm__vec3); } + result = glm::rotate((glm::vec4 const &)*arg1,(float const &)*arg2,(glm::vec3 const &)*arg3); { + glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_rotateX__SWIG_0(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; float *arg2 = 0 ; float temp2 ; + glm::vec3 result; SWIG_check_num_args("glm::rotateX",2,2) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::rotateX",1,"glm::vec3 const &"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::rotateX",2,"float const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("rotateX",1,SWIGTYPE_p_glm__vec3); } + temp2=(float)lua_tonumber(L,2); arg2=&temp2; result = glm::rotateX((glm::vec3 const &)*arg1,(float const &)*arg2); { + glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_rotateX__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = 0 ; float *arg2 = 0 ; float temp2 ; + glm::vec4 result; SWIG_check_num_args("glm::rotateX",2,2) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::rotateX",1,"glm::vec4 const &"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::rotateX",2,"float const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("rotateX",1,SWIGTYPE_p_glm__vec4); } + temp2=(float)lua_tonumber(L,2); arg2=&temp2; result = glm::rotateX((glm::vec4 const &)*arg1,(float const &)*arg2); { + glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_rotateX(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v = 0; { { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_rotateX__SWIG_0(L);} check_1: if (argc == 2) { + return _wrap_rotateX__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'rotateX'\n" + " Possible C/C++ prototypes are:\n" " glm::rotateX(glm::vec3 const &,float const &)\n" + " glm::rotateX(glm::vec4 const &,float const &)\n"); lua_error(L);return 0; } +static int _wrap_rotateY__SWIG_0(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; float *arg2 = 0 ; float temp2 ; + glm::vec3 result; SWIG_check_num_args("glm::rotateY",2,2) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::rotateY",1,"glm::vec3 const &"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::rotateY",2,"float const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("rotateY",1,SWIGTYPE_p_glm__vec3); } + temp2=(float)lua_tonumber(L,2); arg2=&temp2; result = glm::rotateY((glm::vec3 const &)*arg1,(float const &)*arg2); { + glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_rotateY__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = 0 ; float *arg2 = 0 ; float temp2 ; + glm::vec4 result; SWIG_check_num_args("glm::rotateY",2,2) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::rotateY",1,"glm::vec4 const &"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::rotateY",2,"float const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("rotateY",1,SWIGTYPE_p_glm__vec4); } + temp2=(float)lua_tonumber(L,2); arg2=&temp2; result = glm::rotateY((glm::vec4 const &)*arg1,(float const &)*arg2); { + glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_rotateY(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v = 0; { { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_rotateY__SWIG_0(L);} check_1: if (argc == 2) { + return _wrap_rotateY__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'rotateY'\n" + " Possible C/C++ prototypes are:\n" " glm::rotateY(glm::vec3 const &,float const &)\n" + " glm::rotateY(glm::vec4 const &,float const &)\n"); lua_error(L);return 0; } +static int _wrap_rotateZ__SWIG_0(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; float *arg2 = 0 ; float temp2 ; + glm::vec3 result; SWIG_check_num_args("glm::rotateZ",2,2) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::rotateZ",1,"glm::vec3 const &"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::rotateZ",2,"float const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("rotateZ",1,SWIGTYPE_p_glm__vec3); } + temp2=(float)lua_tonumber(L,2); arg2=&temp2; result = glm::rotateZ((glm::vec3 const &)*arg1,(float const &)*arg2); { + glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_rotateZ__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = 0 ; float *arg2 = 0 ; float temp2 ; + glm::vec4 result; SWIG_check_num_args("glm::rotateZ",2,2) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::rotateZ",1,"glm::vec4 const &"); + if(!lua_isnumber(L,2)) SWIG_fail_arg("glm::rotateZ",2,"float const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("rotateZ",1,SWIGTYPE_p_glm__vec4); } + temp2=(float)lua_tonumber(L,2); arg2=&temp2; result = glm::rotateZ((glm::vec4 const &)*arg1,(float const &)*arg2); { + glm::vec4 * resultptr = new glm::vec4((const glm::vec4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_rotateZ(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v = 0; { { + void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_rotateZ__SWIG_0(L);} check_1: if (argc == 2) { + return _wrap_rotateZ__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'rotateZ'\n" + " Possible C/C++ prototypes are:\n" " glm::rotateZ(glm::vec3 const &,float const &)\n" + " glm::rotateZ(glm::vec4 const &,float const &)\n"); lua_error(L);return 0; } +static int _wrap_orientation(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; glm::vec3 *arg2 = 0 ; glm::mat4 result; + SWIG_check_num_args("glm::orientation",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::orientation",1,"glm::vec3 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::orientation",2,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ + SWIG_fail_ptr("orientation",1,SWIGTYPE_p_glm__vec3); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ + SWIG_fail_ptr("orientation",2,SWIGTYPE_p_glm__vec3); } + result = glm::orientation((glm::vec3 const &)*arg1,(glm::vec3 const &)*arg2); { + glm::mat4 * resultptr = new glm::mat4((const glm::mat4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__mat4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_catmullRom__SWIG_0(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = 0 ; glm::vec2 *arg2 = 0 ; + glm::vec2 *arg3 = 0 ; glm::vec2 *arg4 = 0 ; float *arg5 = 0 ; float temp5 ; glm::vec2 result; + SWIG_check_num_args("glm::catmullRom",5,5) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::catmullRom",1,"glm::vec2 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::catmullRom",2,"glm::vec2 const &"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("glm::catmullRom",3,"glm::vec2 const &"); + if(!lua_isuserdata(L,4)) SWIG_fail_arg("glm::catmullRom",4,"glm::vec2 const &"); + if(!lua_isnumber(L,5)) SWIG_fail_arg("glm::catmullRom",5,"float const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ + SWIG_fail_ptr("catmullRom",1,SWIGTYPE_p_glm__vec2); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec2,0))){ + SWIG_fail_ptr("catmullRom",2,SWIGTYPE_p_glm__vec2); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_glm__vec2,0))){ + SWIG_fail_ptr("catmullRom",3,SWIGTYPE_p_glm__vec2); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_glm__vec2,0))){ + SWIG_fail_ptr("catmullRom",4,SWIGTYPE_p_glm__vec2); } temp5=(float)lua_tonumber(L,5); arg5=&temp5; + result = glm::catmullRom((glm::vec2 const &)*arg1,(glm::vec2 const &)*arg2,(glm::vec2 const &)*arg3,(glm::vec2 const &)*arg4,(float const &)*arg5); + { glm::vec2 * resultptr = new glm::vec2((const glm::vec2 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_catmullRom__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; glm::vec3 *arg2 = 0 ; + glm::vec3 *arg3 = 0 ; glm::vec3 *arg4 = 0 ; float *arg5 = 0 ; float temp5 ; glm::vec3 result; + SWIG_check_num_args("glm::catmullRom",5,5) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::catmullRom",1,"glm::vec3 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::catmullRom",2,"glm::vec3 const &"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("glm::catmullRom",3,"glm::vec3 const &"); + if(!lua_isuserdata(L,4)) SWIG_fail_arg("glm::catmullRom",4,"glm::vec3 const &"); + if(!lua_isnumber(L,5)) SWIG_fail_arg("glm::catmullRom",5,"float const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ + SWIG_fail_ptr("catmullRom",1,SWIGTYPE_p_glm__vec3); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ + SWIG_fail_ptr("catmullRom",2,SWIGTYPE_p_glm__vec3); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_glm__vec3,0))){ + SWIG_fail_ptr("catmullRom",3,SWIGTYPE_p_glm__vec3); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_glm__vec3,0))){ + SWIG_fail_ptr("catmullRom",4,SWIGTYPE_p_glm__vec3); } temp5=(float)lua_tonumber(L,5); arg5=&temp5; + result = glm::catmullRom((glm::vec3 const &)*arg1,(glm::vec3 const &)*arg2,(glm::vec3 const &)*arg3,(glm::vec3 const &)*arg4,(float const &)*arg5); + { glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_catmullRom(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 5) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; { { void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; { { void *ptr; + if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_catmullRom__SWIG_0(L);} check_1: + if (argc == 5) { return _wrap_catmullRom__SWIG_1(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'catmullRom'\n" " Possible C/C++ prototypes are:\n" + " glm::catmullRom(glm::vec2 const &,glm::vec2 const &,glm::vec2 const &,glm::vec2 const &,float const &)\n" + " glm::catmullRom(glm::vec3 const &,glm::vec3 const &,glm::vec3 const &,glm::vec3 const &,float const &)\n"); + lua_error(L);return 0; } +static int _wrap_hermite__SWIG_0(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = 0 ; glm::vec2 *arg2 = 0 ; + glm::vec2 *arg3 = 0 ; glm::vec2 *arg4 = 0 ; float *arg5 = 0 ; float temp5 ; glm::vec2 result; + SWIG_check_num_args("glm::hermite",5,5) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::hermite",1,"glm::vec2 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::hermite",2,"glm::vec2 const &"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("glm::hermite",3,"glm::vec2 const &"); + if(!lua_isuserdata(L,4)) SWIG_fail_arg("glm::hermite",4,"glm::vec2 const &"); + if(!lua_isnumber(L,5)) SWIG_fail_arg("glm::hermite",5,"float const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("hermite",1,SWIGTYPE_p_glm__vec2); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("hermite",2,SWIGTYPE_p_glm__vec2); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("hermite",3,SWIGTYPE_p_glm__vec2); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("hermite",4,SWIGTYPE_p_glm__vec2); } + temp5=(float)lua_tonumber(L,5); arg5=&temp5; + result = glm::hermite((glm::vec2 const &)*arg1,(glm::vec2 const &)*arg2,(glm::vec2 const &)*arg3,(glm::vec2 const &)*arg4,(float const &)*arg5); + { glm::vec2 * resultptr = new glm::vec2((const glm::vec2 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_hermite__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; glm::vec3 *arg2 = 0 ; + glm::vec3 *arg3 = 0 ; glm::vec3 *arg4 = 0 ; float *arg5 = 0 ; float temp5 ; glm::vec3 result; + SWIG_check_num_args("glm::hermite",5,5) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::hermite",1,"glm::vec3 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::hermite",2,"glm::vec3 const &"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("glm::hermite",3,"glm::vec3 const &"); + if(!lua_isuserdata(L,4)) SWIG_fail_arg("glm::hermite",4,"glm::vec3 const &"); + if(!lua_isnumber(L,5)) SWIG_fail_arg("glm::hermite",5,"float const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("hermite",1,SWIGTYPE_p_glm__vec3); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("hermite",2,SWIGTYPE_p_glm__vec3); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("hermite",3,SWIGTYPE_p_glm__vec3); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("hermite",4,SWIGTYPE_p_glm__vec3); } + temp5=(float)lua_tonumber(L,5); arg5=&temp5; + result = glm::hermite((glm::vec3 const &)*arg1,(glm::vec3 const &)*arg2,(glm::vec3 const &)*arg3,(glm::vec3 const &)*arg4,(float const &)*arg5); + { glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_hermite(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 5) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; { { void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; { { void *ptr; + if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_hermite__SWIG_0(L);} check_1: if (argc == 5) { + return _wrap_hermite__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'hermite'\n" + " Possible C/C++ prototypes are:\n" + " glm::hermite(glm::vec2 const &,glm::vec2 const &,glm::vec2 const &,glm::vec2 const &,float const &)\n" + " glm::hermite(glm::vec3 const &,glm::vec3 const &,glm::vec3 const &,glm::vec3 const &,float const &)\n"); + lua_error(L);return 0; } +static int _wrap_cubic__SWIG_0(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = 0 ; glm::vec2 *arg2 = 0 ; + glm::vec2 *arg3 = 0 ; glm::vec2 *arg4 = 0 ; float *arg5 = 0 ; float temp5 ; glm::vec2 result; + SWIG_check_num_args("glm::cubic",5,5) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::cubic",1,"glm::vec2 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::cubic",2,"glm::vec2 const &"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("glm::cubic",3,"glm::vec2 const &"); + if(!lua_isuserdata(L,4)) SWIG_fail_arg("glm::cubic",4,"glm::vec2 const &"); + if(!lua_isnumber(L,5)) SWIG_fail_arg("glm::cubic",5,"float const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("cubic",1,SWIGTYPE_p_glm__vec2); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("cubic",2,SWIGTYPE_p_glm__vec2); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("cubic",3,SWIGTYPE_p_glm__vec2); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("cubic",4,SWIGTYPE_p_glm__vec2); } + temp5=(float)lua_tonumber(L,5); arg5=&temp5; + result = glm::cubic((glm::vec2 const &)*arg1,(glm::vec2 const &)*arg2,(glm::vec2 const &)*arg3,(glm::vec2 const &)*arg4,(float const &)*arg5); + { glm::vec2 * resultptr = new glm::vec2((const glm::vec2 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec2,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_cubic__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; glm::vec3 *arg2 = 0 ; + glm::vec3 *arg3 = 0 ; glm::vec3 *arg4 = 0 ; float *arg5 = 0 ; float temp5 ; glm::vec3 result; + SWIG_check_num_args("glm::cubic",5,5) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::cubic",1,"glm::vec3 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::cubic",2,"glm::vec3 const &"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("glm::cubic",3,"glm::vec3 const &"); + if(!lua_isuserdata(L,4)) SWIG_fail_arg("glm::cubic",4,"glm::vec3 const &"); + if(!lua_isnumber(L,5)) SWIG_fail_arg("glm::cubic",5,"float const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("cubic",1,SWIGTYPE_p_glm__vec3); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("cubic",2,SWIGTYPE_p_glm__vec3); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("cubic",3,SWIGTYPE_p_glm__vec3); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("cubic",4,SWIGTYPE_p_glm__vec3); } + temp5=(float)lua_tonumber(L,5); arg5=&temp5; + result = glm::cubic((glm::vec3 const &)*arg1,(glm::vec3 const &)*arg2,(glm::vec3 const &)*arg3,(glm::vec3 const &)*arg4,(float const &)*arg5); + { glm::vec3 * resultptr = new glm::vec3((const glm::vec3 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__vec3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_cubic(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 5) { int _v = 0; + { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; { { void *ptr; + if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; { { void *ptr; + if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; return _wrap_cubic__SWIG_0(L);} check_1: if (argc == 5) { + return _wrap_cubic__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'cubic'\n" + " Possible C/C++ prototypes are:\n" + " glm::cubic(glm::vec2 const &,glm::vec2 const &,glm::vec2 const &,glm::vec2 const &,float const &)\n" + " glm::cubic(glm::vec3 const &,glm::vec3 const &,glm::vec3 const &,glm::vec3 const &,float const &)\n"); + lua_error(L);return 0; } +static int _wrap_translate__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; glm::mat4 result; + SWIG_check_num_args("glm::translate",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::translate",1,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ + SWIG_fail_ptr("translate",1,SWIGTYPE_p_glm__vec3); } result = glm::translate((glm::vec3 const &)*arg1); { + glm::mat4 * resultptr = new glm::mat4((const glm::mat4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__mat4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_translate(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { + return _wrap_translate__SWIG_1(L);} if (argc == 2) { return _wrap_translate__SWIG_0(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'translate'\n" " Possible C/C++ prototypes are:\n" + " glm::translate(glm::mat4 const &,glm::vec3 const &)\n" " glm::translate(glm::vec3 const &)\n"); + lua_error(L);return 0; } +static int _wrap_rotate__SWIG_5(lua_State* L) { int SWIG_arg = 0; float arg1 ; glm::vec3 *arg2 = 0 ; glm::mat4 result; + SWIG_check_num_args("glm::rotate",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("glm::rotate",1,"float"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::rotate",2,"glm::vec3 const &"); arg1 = (float)lua_tonumber(L, 1); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("rotate",2,SWIGTYPE_p_glm__vec3); } + result = glm::rotate(arg1,(glm::vec3 const &)*arg2); { glm::mat4 * resultptr = new glm::mat4((const glm::mat4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__mat4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_rotate(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { int _v = 0; { + { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_1; { { _v = lua_isnumber(L,argv[1]); } } if (!_v) goto check_1; + return _wrap_rotate__SWIG_2(L);} check_1: if (argc == 2) { return _wrap_rotate__SWIG_5(L);} if (argc == 3) { int _v = 0; { + { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__quat, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; return _wrap_rotate__SWIG_0(L);} check_3: if (argc == 3) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_4; return _wrap_rotate__SWIG_3(L);} check_4: if (argc == 3) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec4, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_5; return _wrap_rotate__SWIG_4(L);} check_5: if (argc == 3) { + return _wrap_rotate__SWIG_1(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'rotate'\n" + " Possible C/C++ prototypes are:\n" " glm::rotate(glm::quat const &,float const &,glm::vec3 const &)\n" + " glm::rotate(glm::mat4 const &,float const &,glm::vec3 const &)\n" " glm::rotate(glm::vec2 const &,float const &)\n" + " glm::rotate(glm::vec3 const &,float const &,glm::vec3 const &)\n" + " glm::rotate(glm::vec4 const &,float const &,glm::vec3 const &)\n" " glm::rotate(float,glm::vec3 const &)\n"); + lua_error(L);return 0; } +static int _wrap_scale__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; glm::mat4 result; + SWIG_check_num_args("glm::scale",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::scale",1,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("scale",1,SWIGTYPE_p_glm__vec3); } + result = glm::scale((glm::vec3 const &)*arg1); { glm::mat4 * resultptr = new glm::mat4((const glm::mat4 &) result); + SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_glm__mat4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: + lua_error(L); return SWIG_arg; } +static int _wrap_scale(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { + return _wrap_scale__SWIG_1(L);} if (argc == 2) { return _wrap_scale__SWIG_0(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'scale'\n" " Possible C/C++ prototypes are:\n" + " glm::scale(glm::mat4 const &,glm::vec3 const &)\n" " glm::scale(glm::vec3 const &)\n"); lua_error(L);return 0; } +static int _wrap_angle__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = 0 ; glm::vec2 *arg2 = 0 ; float result; + SWIG_check_num_args("glm::angle",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::angle",1,"glm::vec2 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::angle",2,"glm::vec2 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("angle",1,SWIGTYPE_p_glm__vec2); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec2,0))){ SWIG_fail_ptr("angle",2,SWIGTYPE_p_glm__vec2); } + result = (float)glm::angle((glm::vec2 const &)*arg1,(glm::vec2 const &)*arg2); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_angle__SWIG_2(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; glm::vec3 *arg2 = 0 ; float result; + SWIG_check_num_args("glm::angle",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::angle",1,"glm::vec3 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::angle",2,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("angle",1,SWIGTYPE_p_glm__vec3); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ SWIG_fail_ptr("angle",2,SWIGTYPE_p_glm__vec3); } + result = (float)glm::angle((glm::vec3 const &)*arg1,(glm::vec3 const &)*arg2); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_angle__SWIG_3(lua_State* L) { int SWIG_arg = 0; glm::vec4 *arg1 = 0 ; glm::vec4 *arg2 = 0 ; float result; + SWIG_check_num_args("glm::angle",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::angle",1,"glm::vec4 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::angle",2,"glm::vec4 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("angle",1,SWIGTYPE_p_glm__vec4); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec4,0))){ SWIG_fail_ptr("angle",2,SWIGTYPE_p_glm__vec4); } + result = (float)glm::angle((glm::vec4 const &)*arg1,(glm::vec4 const &)*arg2); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_angle(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { + return _wrap_angle__SWIG_0(L);} if (argc == 2) { int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec2, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_2; return _wrap_angle__SWIG_1(L);} check_2: if (argc == 2) { + int _v = 0; { { void *ptr; + if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; { { void *ptr; + if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_glm__vec3, SWIG_POINTER_NO_NULL)) { + _v = 0; } else { _v = 1; } } } if (!_v) goto check_3; return _wrap_angle__SWIG_2(L);} check_3: if (argc == 2) { + return _wrap_angle__SWIG_3(L);} SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'angle'\n" + " Possible C/C++ prototypes are:\n" " glm::angle(glm::quat const &)\n" + " glm::angle(glm::vec2 const &,glm::vec2 const &)\n" " glm::angle(glm::vec3 const &,glm::vec3 const &)\n" + " glm::angle(glm::vec4 const &,glm::vec4 const &)\n"); lua_error(L);return 0; } +static int _wrap_orientedAngle__SWIG_0(lua_State* L) { int SWIG_arg = 0; glm::vec2 *arg1 = 0 ; glm::vec2 *arg2 = 0 ; + float result; SWIG_check_num_args("glm::orientedAngle",2,2) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::orientedAngle",1,"glm::vec2 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::orientedAngle",2,"glm::vec2 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec2,0))){ + SWIG_fail_ptr("orientedAngle",1,SWIGTYPE_p_glm__vec2); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec2,0))){ + SWIG_fail_ptr("orientedAngle",2,SWIGTYPE_p_glm__vec2); } + result = (float)glm::orientedAngle((glm::vec2 const &)*arg1,(glm::vec2 const &)*arg2); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_orientedAngle__SWIG_1(lua_State* L) { int SWIG_arg = 0; glm::vec3 *arg1 = 0 ; glm::vec3 *arg2 = 0 ; + glm::vec3 *arg3 = 0 ; float result; SWIG_check_num_args("glm::orientedAngle",3,3) + if(!lua_isuserdata(L,1)) SWIG_fail_arg("glm::orientedAngle",1,"glm::vec3 const &"); + if(!lua_isuserdata(L,2)) SWIG_fail_arg("glm::orientedAngle",2,"glm::vec3 const &"); + if(!lua_isuserdata(L,3)) SWIG_fail_arg("glm::orientedAngle",3,"glm::vec3 const &"); + if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_glm__vec3,0))){ + SWIG_fail_ptr("orientedAngle",1,SWIGTYPE_p_glm__vec3); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_glm__vec3,0))){ + SWIG_fail_ptr("orientedAngle",2,SWIGTYPE_p_glm__vec3); } + if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_glm__vec3,0))){ + SWIG_fail_ptr("orientedAngle",3,SWIGTYPE_p_glm__vec3); } + result = (float)glm::orientedAngle((glm::vec3 const &)*arg1,(glm::vec3 const &)*arg2,(glm::vec3 const &)*arg3); + lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } +static int _wrap_orientedAngle(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { + return _wrap_orientedAngle__SWIG_0(L);} if (argc == 3) { return _wrap_orientedAngle__SWIG_1(L);} + SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'orientedAngle'\n" " Possible C/C++ prototypes are:\n" + " glm::orientedAngle(glm::vec2 const &,glm::vec2 const &)\n" + " glm::orientedAngle(glm::vec3 const &,glm::vec3 const &,glm::vec3 const &)\n"); lua_error(L);return 0; } +static swig_lua_attribute swig_SwigModule_attributes[] = { + {0,0,0} +}; +static swig_lua_const_info swig_SwigModule_constants[]= { + {0,0,0,0,0,0} +}; +static swig_lua_method swig_SwigModule_methods[]= { + { "vec2_length", _wrap_vec2_length}, + { "vec3_length", _wrap_vec3_length}, + { "vec4_length", _wrap_vec4_length}, + { "mat3_length", _wrap_mat3_length}, + { "mat4_length", _wrap_mat4_length}, + { "sub", _wrap_sub}, + { "quat_length", _wrap_quat_length}, + { "add", _wrap_add}, + { "mul", _wrap_mul}, + { "div", _wrap_div}, + { "eq", _wrap_eq}, + { "conjugate", _wrap_conjugate}, + { "eulerAngles", _wrap_eulerAngles}, + { "roll", _wrap_roll}, + { "pitch", _wrap_pitch}, + { "yaw", _wrap_yaw}, + { "mat3_cast", _wrap_mat3_cast}, + { "mat4_cast", _wrap_mat4_cast}, + { "quat_cast", _wrap_quat_cast}, + { "axis", _wrap_axis}, + { "angleAxis", _wrap_angleAxis}, + { "epsilon", _wrap_epsilon}, + { "zero", _wrap_zero}, + { "one", _wrap_one}, + { "pi", _wrap_pi}, + { "root_pi", _wrap_root_pi}, + { "half_pi", _wrap_half_pi}, + { "quarter_pi", _wrap_quarter_pi}, + { "one_over_pi", _wrap_one_over_pi}, + { "two_over_pi", _wrap_two_over_pi}, + { "two_over_root_pi", _wrap_two_over_root_pi}, + { "one_over_root_two", _wrap_one_over_root_two}, + { "root_half_pi", _wrap_root_half_pi}, + { "root_two_pi", _wrap_root_two_pi}, + { "root_ln_four", _wrap_root_ln_four}, + { "e", _wrap_e}, + { "euler", _wrap_euler}, + { "root_two", _wrap_root_two}, + { "root_three", _wrap_root_three}, + { "root_five", _wrap_root_five}, + { "ln_two", _wrap_ln_two}, + { "ln_ten", _wrap_ln_ten}, + { "ln_ln_two", _wrap_ln_ln_two}, + { "third", _wrap_third}, + { "two_thirds", _wrap_two_thirds}, + { "golden_ratio", _wrap_golden_ratio}, + { "abs", _wrap_abs}, + { "sign", _wrap_sign}, + { "floor", _wrap_floor}, + { "trunc", _wrap_trunc}, + { "round", _wrap_round}, + { "roundEven", _wrap_roundEven}, + { "ceil", _wrap_ceil}, + { "fract", _wrap_fract}, + { "mod", _wrap_mod}, + { "modf", _wrap_modf}, + { "min", _wrap_min}, + { "max", _wrap_max}, + { "clamp", _wrap_clamp}, + { "mix", _wrap_mix}, + { "step", _wrap_step}, + { "smoothstep", _wrap_smoothstep}, + { "isnan", _wrap_isnan}, + { "isinf", _wrap_isinf}, + { "fma", _wrap_fma}, + { "pow", _wrap_pow}, + { "exp", _wrap_exp}, + { "log", _wrap_log}, + { "exp2", _wrap_exp2}, + { "log2", _wrap_log2}, + { "sqrt", _wrap_sqrt}, + { "inversesqrt", _wrap_inversesqrt}, + { "length", _wrap_length}, + { "distance", _wrap_distance}, + { "dot", _wrap_dot}, + { "cross", _wrap_cross}, + { "normalize", _wrap_normalize}, + { "faceforward", _wrap_faceforward}, + { "reflect", _wrap_reflect}, + { "refract", _wrap_refract}, + { "matrixCompMult", _wrap_matrixCompMult}, + { "outerProduct", _wrap_outerProduct}, + { "transpose", _wrap_transpose}, + { "determinant", _wrap_determinant}, + { "inverse", _wrap_inverse}, + { "radians", _wrap_radians}, + { "degrees", _wrap_degrees}, + { "sin", _wrap_sin}, + { "cos", _wrap_cos}, + { "tan", _wrap_tan}, + { "asin", _wrap_asin}, + { "acos", _wrap_acos}, + { "atan", _wrap_atan}, + { "sinh", _wrap_sinh}, + { "cosh", _wrap_cosh}, + { "tanh", _wrap_tanh}, + { "asinh", _wrap_asinh}, + { "acosh", _wrap_acosh}, + { "atanh", _wrap_atanh}, + { "epsilonEqual", _wrap_epsilonEqual}, + { "epsilonNotEqual", _wrap_epsilonNotEqual}, + { "row", _wrap_row}, + { "column", _wrap_column}, + { "affineInverse", _wrap_affineInverse}, + { "inverseTranspose", _wrap_inverseTranspose}, + { "lookAt", _wrap_lookAt}, + { "ortho", _wrap_ortho}, + { "frustum", _wrap_frustum}, + { "perspective", _wrap_perspective}, + { "perspectiveFov", _wrap_perspectiveFov}, + { "infinitePerspective", _wrap_infinitePerspective}, + { "tweakedInfinitePerspective", _wrap_tweakedInfinitePerspective}, + { "project", _wrap_project}, + { "unProject", _wrap_unProject}, + { "pickMatrix", _wrap_pickMatrix}, + { "lerp", _wrap_lerp}, + { "saturate", _wrap_saturate}, + { "atan2", _wrap_atan2}, + { "isfinite", _wrap_isfinite}, + { "fastSqrt", _wrap_fastSqrt}, + { "fastInverseSqrt", _wrap_fastInverseSqrt}, + { "fastLength", _wrap_fastLength}, + { "fastDistance", _wrap_fastDistance}, + { "fastNormalize", _wrap_fastNormalize}, + { "length2", _wrap_length2}, + { "distance2", _wrap_distance2}, + { "l1Norm", _wrap_l1Norm}, + { "l2Norm", _wrap_l2Norm}, + { "lxNorm", _wrap_lxNorm}, + { "perp", _wrap_perp}, + { "slerp", _wrap_slerp}, + { "rotateX", _wrap_rotateX}, + { "rotateY", _wrap_rotateY}, + { "rotateZ", _wrap_rotateZ}, + { "orientation", _wrap_orientation}, + { "catmullRom", _wrap_catmullRom}, + { "hermite", _wrap_hermite}, + { "cubic", _wrap_cubic}, + { "translate", _wrap_translate}, + { "rotate", _wrap_rotate}, + { "scale", _wrap_scale}, + { "angle", _wrap_angle}, + { "orientedAngle", _wrap_orientedAngle}, + {0,0} +}; +static swig_lua_class* swig_SwigModule_classes[]= { +&_wrap_class_string, +&_wrap_class_vec2, +&_wrap_class_vec3, +&_wrap_class_vec4, +&_wrap_class_mat3, +&_wrap_class_mat4, +&_wrap_class_quat, + 0 +}; +static swig_lua_namespace* swig_SwigModule_namespaces[] = { + 0 +}; + +static swig_lua_namespace swig_SwigModule = { + "glm", + swig_SwigModule_methods, + swig_SwigModule_attributes, + swig_SwigModule_constants, + swig_SwigModule_classes, + swig_SwigModule_namespaces +}; +#ifdef __cplusplus +} +#endif + +/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */ + +static swig_type_info _swigt__p_float = {"_p_float", "float *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_glm__mat3 = {"_p_glm__mat3", "glm::mat3 *", 0, 0, (void*)&_wrap_class_mat3, 0}; +static swig_type_info _swigt__p_glm__mat4 = {"_p_glm__mat4", "glm::mat4 *", 0, 0, (void*)&_wrap_class_mat4, 0}; +static swig_type_info _swigt__p_glm__quat = {"_p_glm__quat", "glm::quat *", 0, 0, (void*)&_wrap_class_quat, 0}; +static swig_type_info _swigt__p_glm__vec2 = {"_p_glm__vec2", "glm::vec2 *", 0, 0, (void*)&_wrap_class_vec2, 0}; +static swig_type_info _swigt__p_glm__vec3 = {"_p_glm__vec3", "glm::vec3 *", 0, 0, (void*)&_wrap_class_vec3, 0}; +static swig_type_info _swigt__p_glm__vec4 = {"_p_glm__vec4", "glm::vec4 *", 0, 0, (void*)&_wrap_class_vec4, 0}; +static swig_type_info _swigt__p_int = {"_p_int", "int *|glm::length_t *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_std__string = {"_p_std__string", "std::string *", 0, 0, (void*)&_wrap_class_string, 0}; + +static swig_type_info *swig_type_initial[] = { + &_swigt__p_float, + &_swigt__p_glm__mat3, + &_swigt__p_glm__mat4, + &_swigt__p_glm__quat, + &_swigt__p_glm__vec2, + &_swigt__p_glm__vec3, + &_swigt__p_glm__vec4, + &_swigt__p_int, + &_swigt__p_std__string, +}; + +static swig_cast_info _swigc__p_float[] = { {&_swigt__p_float, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_glm__mat3[] = { {&_swigt__p_glm__mat3, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_glm__mat4[] = { {&_swigt__p_glm__mat4, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_glm__quat[] = { {&_swigt__p_glm__quat, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_glm__vec2[] = { {&_swigt__p_glm__vec2, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_glm__vec3[] = { {&_swigt__p_glm__vec3, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_glm__vec4[] = { {&_swigt__p_glm__vec4, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_std__string[] = { {&_swigt__p_std__string, 0, 0, 0},{0, 0, 0, 0}}; + +static swig_cast_info *swig_cast_initial[] = { + _swigc__p_float, + _swigc__p_glm__mat3, + _swigc__p_glm__mat4, + _swigc__p_glm__quat, + _swigc__p_glm__vec2, + _swigc__p_glm__vec3, + _swigc__p_glm__vec4, + _swigc__p_int, + _swigc__p_std__string, +}; + + +/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */ + +/* ----------------------------------------------------------------------------- + * Type initialization: + * This problem is tough by the requirement that no dynamic + * memory is used. Also, since swig_type_info structures store pointers to + * swig_cast_info structures and swig_cast_info structures store pointers back + * to swig_type_info structures, we need some lookup code at initialization. + * The idea is that swig generates all the structures that are needed. + * The runtime then collects these partially filled structures. + * The SWIG_InitializeModule function takes these initial arrays out of + * swig_module, and does all the lookup, filling in the swig_module.types + * array with the correct data and linking the correct swig_cast_info + * structures together. + * + * The generated swig_type_info structures are assigned statically to an initial + * array. We just loop through that array, and handle each type individually. + * First we lookup if this type has been already loaded, and if so, use the + * loaded structure instead of the generated one. Then we have to fill in the + * cast linked list. The cast data is initially stored in something like a + * two-dimensional array. Each row corresponds to a type (there are the same + * number of rows as there are in the swig_type_initial array). Each entry in + * a column is one of the swig_cast_info structures for that type. + * The cast_initial array is actually an array of arrays, because each row has + * a variable number of columns. So to actually build the cast linked list, + * we find the array of casts associated with the type, and loop through it + * adding the casts to the list. The one last trick we need to do is making + * sure the type pointer in the swig_cast_info struct is correct. + * + * First off, we lookup the cast->type name to see if it is already loaded. + * There are three cases to handle: + * 1) If the cast->type has already been loaded AND the type we are adding + * casting info to has not been loaded (it is in this module), THEN we + * replace the cast->type pointer with the type pointer that has already + * been loaded. + * 2) If BOTH types (the one we are adding casting info to, and the + * cast->type) are loaded, THEN the cast info has already been loaded by + * the previous module so we just ignore it. + * 3) Finally, if cast->type has not already been loaded, then we add that + * swig_cast_info to the linked list (because the cast->type) pointer will + * be correct. + * ----------------------------------------------------------------------------- */ + +#ifdef __cplusplus +extern "C" { +#if 0 +} /* c-mode */ +#endif +#endif + +#if 0 +#define SWIGRUNTIME_DEBUG +#endif + + +SWIGRUNTIME void +SWIG_InitializeModule(void *clientdata) { + size_t i; + swig_module_info *module_head, *iter; + int init; + + /* check to see if the circular list has been setup, if not, set it up */ + if (swig_module.next==0) { + /* Initialize the swig_module */ + swig_module.type_initial = swig_type_initial; + swig_module.cast_initial = swig_cast_initial; + swig_module.next = &swig_module; + init = 1; + } else { + init = 0; + } + + /* Try and load any already created modules */ + module_head = SWIG_GetModule(clientdata); + if (!module_head) { + /* This is the first module loaded for this interpreter */ + /* so set the swig module into the interpreter */ + SWIG_SetModule(clientdata, &swig_module); + } else { + /* the interpreter has loaded a SWIG module, but has it loaded this one? */ + iter=module_head; + do { + if (iter==&swig_module) { + /* Our module is already in the list, so there's nothing more to do. */ + return; + } + iter=iter->next; + } while (iter!= module_head); + + /* otherwise we must add our module into the list */ + swig_module.next = module_head->next; + module_head->next = &swig_module; + } + + /* When multiple interpreters are used, a module could have already been initialized in + a different interpreter, but not yet have a pointer in this interpreter. + In this case, we do not want to continue adding types... everything should be + set up already */ + if (init == 0) return; + + /* Now work on filling in swig_module.types */ +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: size %lu\n", (unsigned long)swig_module.size); +#endif + for (i = 0; i < swig_module.size; ++i) { + swig_type_info *type = 0; + swig_type_info *ret; + swig_cast_info *cast; + +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name); +#endif + + /* if there is another module already loaded */ + if (swig_module.next != &swig_module) { + type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name); + } + if (type) { + /* Overwrite clientdata field */ +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: found type %s\n", type->name); +#endif + if (swig_module.type_initial[i]->clientdata) { + type->clientdata = swig_module.type_initial[i]->clientdata; +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name); +#endif + } + } else { + type = swig_module.type_initial[i]; + } + + /* Insert casting types */ + cast = swig_module.cast_initial[i]; + while (cast->type) { + + /* Don't need to add information already in the list */ + ret = 0; +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: look cast %s\n", cast->type->name); +#endif + if (swig_module.next != &swig_module) { + ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name); +#ifdef SWIGRUNTIME_DEBUG + if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name); +#endif + } + if (ret) { + if (type == swig_module.type_initial[i]) { +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: skip old type %s\n", ret->name); +#endif + cast->type = ret; + ret = 0; + } else { + /* Check for casting already in the list */ + swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type); +#ifdef SWIGRUNTIME_DEBUG + if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name); +#endif + if (!ocast) ret = 0; + } + } + + if (!ret) { +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name); +#endif + if (type->cast) { + type->cast->prev = cast; + cast->next = type->cast; + } + type->cast = cast; + } + cast++; + } + /* Set entry in modules->types array equal to the type */ + swig_module.types[i] = type; + } + swig_module.types[i] = 0; + +#ifdef SWIGRUNTIME_DEBUG + printf("**** SWIG_InitializeModule: Cast List ******\n"); + for (i = 0; i < swig_module.size; ++i) { + int j = 0; + swig_cast_info *cast = swig_module.cast_initial[i]; + printf("SWIG_InitializeModule: type %lu %s\n", (unsigned long)i, swig_module.type_initial[i]->name); + while (cast->type) { + printf("SWIG_InitializeModule: cast type %s\n", cast->type->name); + cast++; + ++j; + } + printf("---- Total casts: %d\n",j); + } + printf("**** SWIG_InitializeModule: Cast List ******\n"); +#endif +} + +/* This function will propagate the clientdata field of type to +* any new swig_type_info structures that have been added into the list +* of equivalent types. It is like calling +* SWIG_TypeClientData(type, clientdata) a second time. +*/ +SWIGRUNTIME void +SWIG_PropagateClientData(void) { + size_t i; + swig_cast_info *equiv; + static int init_run = 0; + + if (init_run) return; + init_run = 1; + + for (i = 0; i < swig_module.size; i++) { + if (swig_module.types[i]->clientdata) { + equiv = swig_module.types[i]->cast; + while (equiv) { + if (!equiv->converter) { + if (equiv->type && !equiv->type->clientdata) + SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata); + } + equiv = equiv->next; + } + } + } +} + +#ifdef __cplusplus +#if 0 +{ /* c-mode */ +#endif +} +#endif + + + +/* Forward declaration of where the user's %init{} gets inserted */ +void SWIG_init_user(lua_State* L ); + +#ifdef __cplusplus +extern "C" { +#endif +/* this is the initialization function + added at the very end of the code + the function is always called SWIG_init, but an earlier #define will rename it +*/ +#if ((SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC)) +LUALIB_API int SWIG_init(lua_State* L) +#else +SWIGEXPORT int SWIG_init(lua_State* L) /* default Lua action */ +#endif +{ +#if (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC) /* valid for both Lua and eLua */ + int i; + int globalRegister = 0; + /* start with global table */ + lua_pushglobaltable (L); + /* SWIG's internal initialisation */ + SWIG_InitializeModule((void*)L); + SWIG_PropagateClientData(); +#endif + +#if ((SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUA) && (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC)) || defined(SWIG_LUA_ELUA_EMULATE) + /* add a global fn */ + SWIG_Lua_add_function(L,"swig_type",SWIG_Lua_type); + SWIG_Lua_add_function(L,"swig_equals",SWIG_Lua_class_equal); +#endif + +#if (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC) + /* set up base class pointers (the hierarchy) */ + for (i = 0; swig_types[i]; i++){ + if (swig_types[i]->clientdata){ + SWIG_Lua_init_base_class(L,(swig_lua_class*)(swig_types[i]->clientdata)); + } + } +#ifdef SWIG_LUA_MODULE_GLOBAL + globalRegister = 1; +#endif + + +#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA) + SWIG_Lua_namespace_register(L,&swig_SwigModule, globalRegister); +#endif + +#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC) + for (i = 0; swig_types[i]; i++){ + if (swig_types[i]->clientdata){ + SWIG_Lua_elua_class_register_instance(L,(swig_lua_class*)(swig_types[i]->clientdata)); + } + } +#endif + +#if defined(SWIG_LUA_ELUA_EMULATE) + lua_newtable(L); + SWIG_Lua_elua_emulate_register(L,swig_SwigModule.ns_methods); + SWIG_Lua_elua_emulate_register_clear(L); + if(globalRegister) { + lua_pushstring(L,swig_SwigModule.name); + lua_pushvalue(L,-2); + lua_rawset(L,-4); + } +#endif + +#endif + +#if (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC) + /* invoke user-specific initialization */ + SWIG_init_user(L); + /* end module */ + /* Note: We do not clean up the stack here (Lua will do this for us). At this + point, we have the globals table and out module table on the stack. Returning + one value makes the module table the result of the require command. */ + return 1; +#else + return 0; +#endif +} + +#ifdef __cplusplus +} +#endif + + +const char* SWIG_LUACODE= + ""; + +void SWIG_init_user(lua_State* L) +{ + /* exec Lua code if applicable */ + SWIG_Lua_dostring(L,SWIG_LUACODE); +} + diff --git a/addons/ofxLua/src/bindings/ios/ofxLuaBindings.cpp b/addons/ofxLua/src/bindings/ios/ofxLuaBindings.cpp deleted file mode 100644 index b2f1173..0000000 --- a/addons/ofxLua/src/bindings/ios/ofxLuaBindings.cpp +++ /dev/null @@ -1,45567 +0,0 @@ -/* ---------------------------------------------------------------------------- - * This file was automatically generated by SWIG (http://www.swig.org). - * Version 3.0.12 - * - * This file is not intended to be easily readable and contains a number of - * coding conventions designed to improve portability and efficiency. Do not make - * changes to this file unless you know what you are doing--modify the SWIG - * interface file instead. - * ----------------------------------------------------------------------------- */ - -#if defined( __WIN32__ ) || defined( _WIN32 ) - #include -#endif - - - -#ifndef SWIGLUA -#define SWIGLUA -#endif - -#define SWIG_LUA_TARGET SWIG_LUA_FLAVOR_LUA -#define SWIG_LUA_MODULE_GLOBAL - - -#ifdef __cplusplus -/* SwigValueWrapper is described in swig.swg */ -template class SwigValueWrapper { - struct SwigMovePointer { - T *ptr; - SwigMovePointer(T *p) : ptr(p) { } - ~SwigMovePointer() { delete ptr; } - SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; } - } pointer; - SwigValueWrapper& operator=(const SwigValueWrapper& rhs); - SwigValueWrapper(const SwigValueWrapper& rhs); -public: - SwigValueWrapper() : pointer(0) { } - SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; } - operator T&() const { return *pointer.ptr; } - T *operator&() { return pointer.ptr; } -}; - -template T SwigValueInit() { - return T(); -} -#endif - -/* ----------------------------------------------------------------------------- - * This section contains generic SWIG labels for method/variable - * declarations/attributes, and other compiler dependent labels. - * ----------------------------------------------------------------------------- */ - -/* template workaround for compilers that cannot correctly implement the C++ standard */ -#ifndef SWIGTEMPLATEDISAMBIGUATOR -# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560) -# define SWIGTEMPLATEDISAMBIGUATOR template -# elif defined(__HP_aCC) -/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */ -/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */ -# define SWIGTEMPLATEDISAMBIGUATOR template -# else -# define SWIGTEMPLATEDISAMBIGUATOR -# endif -#endif - -/* inline attribute */ -#ifndef SWIGINLINE -# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__)) -# define SWIGINLINE inline -# else -# define SWIGINLINE -# endif -#endif - -/* attribute recognised by some compilers to avoid 'unused' warnings */ -#ifndef SWIGUNUSED -# if defined(__GNUC__) -# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) -# define SWIGUNUSED __attribute__ ((__unused__)) -# else -# define SWIGUNUSED -# endif -# elif defined(__ICC) -# define SWIGUNUSED __attribute__ ((__unused__)) -# else -# define SWIGUNUSED -# endif -#endif - -#ifndef SWIG_MSC_UNSUPPRESS_4505 -# if defined(_MSC_VER) -# pragma warning(disable : 4505) /* unreferenced local function has been removed */ -# endif -#endif - -#ifndef SWIGUNUSEDPARM -# ifdef __cplusplus -# define SWIGUNUSEDPARM(p) -# else -# define SWIGUNUSEDPARM(p) p SWIGUNUSED -# endif -#endif - -/* internal SWIG method */ -#ifndef SWIGINTERN -# define SWIGINTERN static SWIGUNUSED -#endif - -/* internal inline SWIG method */ -#ifndef SWIGINTERNINLINE -# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE -#endif - -/* exporting methods */ -#if defined(__GNUC__) -# if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) -# ifndef GCC_HASCLASSVISIBILITY -# define GCC_HASCLASSVISIBILITY -# endif -# endif -#endif - -#ifndef SWIGEXPORT -# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) -# if defined(STATIC_LINKED) -# define SWIGEXPORT -# else -# define SWIGEXPORT __declspec(dllexport) -# endif -# else -# if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY) -# define SWIGEXPORT __attribute__ ((visibility("default"))) -# else -# define SWIGEXPORT -# endif -# endif -#endif - -/* calling conventions for Windows */ -#ifndef SWIGSTDCALL -# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) -# define SWIGSTDCALL __stdcall -# else -# define SWIGSTDCALL -# endif -#endif - -/* Deal with Microsoft's attempt at deprecating C standard runtime functions */ -#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE) -# define _CRT_SECURE_NO_DEPRECATE -#endif - -/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */ -#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE) -# define _SCL_SECURE_NO_DEPRECATE -#endif - -/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */ -#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES) -# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0 -#endif - -/* Intel's compiler complains if a variable which was never initialised is - * cast to void, which is a common idiom which we use to indicate that we - * are aware a variable isn't used. So we just silence that warning. - * See: https://github.com/swig/swig/issues/192 for more discussion. - */ -#ifdef __INTEL_COMPILER -# pragma warning disable 592 -#endif - -/* ----------------------------------------------------------------------------- - * swigrun.swg - * - * This file contains generic C API SWIG runtime support for pointer - * type checking. - * ----------------------------------------------------------------------------- */ - -/* This should only be incremented when either the layout of swig_type_info changes, - or for whatever reason, the runtime changes incompatibly */ -#define SWIG_RUNTIME_VERSION "4" - -/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */ -#ifdef SWIG_TYPE_TABLE -# define SWIG_QUOTE_STRING(x) #x -# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x) -# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE) -#else -# define SWIG_TYPE_TABLE_NAME -#endif - -/* - You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for - creating a static or dynamic library from the SWIG runtime code. - In 99.9% of the cases, SWIG just needs to declare them as 'static'. - - But only do this if strictly necessary, ie, if you have problems - with your compiler or suchlike. -*/ - -#ifndef SWIGRUNTIME -# define SWIGRUNTIME SWIGINTERN -#endif - -#ifndef SWIGRUNTIMEINLINE -# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE -#endif - -/* Generic buffer size */ -#ifndef SWIG_BUFFER_SIZE -# define SWIG_BUFFER_SIZE 1024 -#endif - -/* Flags for pointer conversions */ -#define SWIG_POINTER_DISOWN 0x1 -#define SWIG_CAST_NEW_MEMORY 0x2 - -/* Flags for new pointer objects */ -#define SWIG_POINTER_OWN 0x1 - - -/* - Flags/methods for returning states. - - The SWIG conversion methods, as ConvertPtr, return an integer - that tells if the conversion was successful or not. And if not, - an error code can be returned (see swigerrors.swg for the codes). - - Use the following macros/flags to set or process the returning - states. - - In old versions of SWIG, code such as the following was usually written: - - if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) { - // success code - } else { - //fail code - } - - Now you can be more explicit: - - int res = SWIG_ConvertPtr(obj,vptr,ty.flags); - if (SWIG_IsOK(res)) { - // success code - } else { - // fail code - } - - which is the same really, but now you can also do - - Type *ptr; - int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags); - if (SWIG_IsOK(res)) { - // success code - if (SWIG_IsNewObj(res) { - ... - delete *ptr; - } else { - ... - } - } else { - // fail code - } - - I.e., now SWIG_ConvertPtr can return new objects and you can - identify the case and take care of the deallocation. Of course that - also requires SWIG_ConvertPtr to return new result values, such as - - int SWIG_ConvertPtr(obj, ptr,...) { - if () { - if () { - *ptr = ; - return SWIG_NEWOBJ; - } else { - *ptr = ; - return SWIG_OLDOBJ; - } - } else { - return SWIG_BADOBJ; - } - } - - Of course, returning the plain '0(success)/-1(fail)' still works, but you can be - more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the - SWIG errors code. - - Finally, if the SWIG_CASTRANK_MODE is enabled, the result code - allows to return the 'cast rank', for example, if you have this - - int food(double) - int fooi(int); - - and you call - - food(1) // cast rank '1' (1 -> 1.0) - fooi(1) // cast rank '0' - - just use the SWIG_AddCast()/SWIG_CheckState() -*/ - -#define SWIG_OK (0) -#define SWIG_ERROR (-1) -#define SWIG_IsOK(r) (r >= 0) -#define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError) - -/* The CastRankLimit says how many bits are used for the cast rank */ -#define SWIG_CASTRANKLIMIT (1 << 8) -/* The NewMask denotes the object was created (using new/malloc) */ -#define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1) -/* The TmpMask is for in/out typemaps that use temporal objects */ -#define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1) -/* Simple returning values */ -#define SWIG_BADOBJ (SWIG_ERROR) -#define SWIG_OLDOBJ (SWIG_OK) -#define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK) -#define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK) -/* Check, add and del mask methods */ -#define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r) -#define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r) -#define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK)) -#define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r) -#define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r) -#define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK)) - -/* Cast-Rank Mode */ -#if defined(SWIG_CASTRANK_MODE) -# ifndef SWIG_TypeRank -# define SWIG_TypeRank unsigned long -# endif -# ifndef SWIG_MAXCASTRANK /* Default cast allowed */ -# define SWIG_MAXCASTRANK (2) -# endif -# define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1) -# define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK) -SWIGINTERNINLINE int SWIG_AddCast(int r) { - return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r; -} -SWIGINTERNINLINE int SWIG_CheckState(int r) { - return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0; -} -#else /* no cast-rank mode */ -# define SWIG_AddCast(r) (r) -# define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0) -#endif - - -#include - -#ifdef __cplusplus -extern "C" { -#endif - -typedef void *(*swig_converter_func)(void *, int *); -typedef struct swig_type_info *(*swig_dycast_func)(void **); - -/* Structure to store information on one type */ -typedef struct swig_type_info { - const char *name; /* mangled name of this type */ - const char *str; /* human readable name of this type */ - swig_dycast_func dcast; /* dynamic cast function down a hierarchy */ - struct swig_cast_info *cast; /* linked list of types that can cast into this type */ - void *clientdata; /* language specific type data */ - int owndata; /* flag if the structure owns the clientdata */ -} swig_type_info; - -/* Structure to store a type and conversion function used for casting */ -typedef struct swig_cast_info { - swig_type_info *type; /* pointer to type that is equivalent to this type */ - swig_converter_func converter; /* function to cast the void pointers */ - struct swig_cast_info *next; /* pointer to next cast in linked list */ - struct swig_cast_info *prev; /* pointer to the previous cast */ -} swig_cast_info; - -/* Structure used to store module information - * Each module generates one structure like this, and the runtime collects - * all of these structures and stores them in a circularly linked list.*/ -typedef struct swig_module_info { - swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */ - size_t size; /* Number of types in this module */ - struct swig_module_info *next; /* Pointer to next element in circularly linked list */ - swig_type_info **type_initial; /* Array of initially generated type structures */ - swig_cast_info **cast_initial; /* Array of initially generated casting structures */ - void *clientdata; /* Language specific module data */ -} swig_module_info; - -/* - Compare two type names skipping the space characters, therefore - "char*" == "char *" and "Class" == "Class", etc. - - Return 0 when the two name types are equivalent, as in - strncmp, but skipping ' '. -*/ -SWIGRUNTIME int -SWIG_TypeNameComp(const char *f1, const char *l1, - const char *f2, const char *l2) { - for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) { - while ((*f1 == ' ') && (f1 != l1)) ++f1; - while ((*f2 == ' ') && (f2 != l2)) ++f2; - if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1; - } - return (int)((l1 - f1) - (l2 - f2)); -} - -/* - Check type equivalence in a name list like ||... - Return 0 if equal, -1 if nb < tb, 1 if nb > tb -*/ -SWIGRUNTIME int -SWIG_TypeCmp(const char *nb, const char *tb) { - int equiv = 1; - const char* te = tb + strlen(tb); - const char* ne = nb; - while (equiv != 0 && *ne) { - for (nb = ne; *ne; ++ne) { - if (*ne == '|') break; - } - equiv = SWIG_TypeNameComp(nb, ne, tb, te); - if (*ne) ++ne; - } - return equiv; -} - -/* - Check type equivalence in a name list like ||... - Return 0 if not equal, 1 if equal -*/ -SWIGRUNTIME int -SWIG_TypeEquiv(const char *nb, const char *tb) { - return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0; -} - -/* - Check the typename -*/ -SWIGRUNTIME swig_cast_info * -SWIG_TypeCheck(const char *c, swig_type_info *ty) { - if (ty) { - swig_cast_info *iter = ty->cast; - while (iter) { - if (strcmp(iter->type->name, c) == 0) { - if (iter == ty->cast) - return iter; - /* Move iter to the top of the linked list */ - iter->prev->next = iter->next; - if (iter->next) - iter->next->prev = iter->prev; - iter->next = ty->cast; - iter->prev = 0; - if (ty->cast) ty->cast->prev = iter; - ty->cast = iter; - return iter; - } - iter = iter->next; - } - } - return 0; -} - -/* - Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison -*/ -SWIGRUNTIME swig_cast_info * -SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) { - if (ty) { - swig_cast_info *iter = ty->cast; - while (iter) { - if (iter->type == from) { - if (iter == ty->cast) - return iter; - /* Move iter to the top of the linked list */ - iter->prev->next = iter->next; - if (iter->next) - iter->next->prev = iter->prev; - iter->next = ty->cast; - iter->prev = 0; - if (ty->cast) ty->cast->prev = iter; - ty->cast = iter; - return iter; - } - iter = iter->next; - } - } - return 0; -} - -/* - Cast a pointer up an inheritance hierarchy -*/ -SWIGRUNTIMEINLINE void * -SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) { - return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory); -} - -/* - Dynamic pointer casting. Down an inheritance hierarchy -*/ -SWIGRUNTIME swig_type_info * -SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) { - swig_type_info *lastty = ty; - if (!ty || !ty->dcast) return ty; - while (ty && (ty->dcast)) { - ty = (*ty->dcast)(ptr); - if (ty) lastty = ty; - } - return lastty; -} - -/* - Return the name associated with this type -*/ -SWIGRUNTIMEINLINE const char * -SWIG_TypeName(const swig_type_info *ty) { - return ty->name; -} - -/* - Return the pretty name associated with this type, - that is an unmangled type name in a form presentable to the user. -*/ -SWIGRUNTIME const char * -SWIG_TypePrettyName(const swig_type_info *type) { - /* The "str" field contains the equivalent pretty names of the - type, separated by vertical-bar characters. We choose - to print the last name, as it is often (?) the most - specific. */ - if (!type) return NULL; - if (type->str != NULL) { - const char *last_name = type->str; - const char *s; - for (s = type->str; *s; s++) - if (*s == '|') last_name = s+1; - return last_name; - } - else - return type->name; -} - -/* - Set the clientdata field for a type -*/ -SWIGRUNTIME void -SWIG_TypeClientData(swig_type_info *ti, void *clientdata) { - swig_cast_info *cast = ti->cast; - /* if (ti->clientdata == clientdata) return; */ - ti->clientdata = clientdata; - - while (cast) { - if (!cast->converter) { - swig_type_info *tc = cast->type; - if (!tc->clientdata) { - SWIG_TypeClientData(tc, clientdata); - } - } - cast = cast->next; - } -} -SWIGRUNTIME void -SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) { - SWIG_TypeClientData(ti, clientdata); - ti->owndata = 1; -} - -/* - Search for a swig_type_info structure only by mangled name - Search is a O(log #types) - - We start searching at module start, and finish searching when start == end. - Note: if start == end at the beginning of the function, we go all the way around - the circular list. -*/ -SWIGRUNTIME swig_type_info * -SWIG_MangledTypeQueryModule(swig_module_info *start, - swig_module_info *end, - const char *name) { - swig_module_info *iter = start; - do { - if (iter->size) { - size_t l = 0; - size_t r = iter->size - 1; - do { - /* since l+r >= 0, we can (>> 1) instead (/ 2) */ - size_t i = (l + r) >> 1; - const char *iname = iter->types[i]->name; - if (iname) { - int compare = strcmp(name, iname); - if (compare == 0) { - return iter->types[i]; - } else if (compare < 0) { - if (i) { - r = i - 1; - } else { - break; - } - } else if (compare > 0) { - l = i + 1; - } - } else { - break; /* should never happen */ - } - } while (l <= r); - } - iter = iter->next; - } while (iter != end); - return 0; -} - -/* - Search for a swig_type_info structure for either a mangled name or a human readable name. - It first searches the mangled names of the types, which is a O(log #types) - If a type is not found it then searches the human readable names, which is O(#types). - - We start searching at module start, and finish searching when start == end. - Note: if start == end at the beginning of the function, we go all the way around - the circular list. -*/ -SWIGRUNTIME swig_type_info * -SWIG_TypeQueryModule(swig_module_info *start, - swig_module_info *end, - const char *name) { - /* STEP 1: Search the name field using binary search */ - swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name); - if (ret) { - return ret; - } else { - /* STEP 2: If the type hasn't been found, do a complete search - of the str field (the human readable name) */ - swig_module_info *iter = start; - do { - size_t i = 0; - for (; i < iter->size; ++i) { - if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name))) - return iter->types[i]; - } - iter = iter->next; - } while (iter != end); - } - - /* neither found a match */ - return 0; -} - -/* - Pack binary data into a string -*/ -SWIGRUNTIME char * -SWIG_PackData(char *c, void *ptr, size_t sz) { - static const char hex[17] = "0123456789abcdef"; - const unsigned char *u = (unsigned char *) ptr; - const unsigned char *eu = u + sz; - for (; u != eu; ++u) { - unsigned char uu = *u; - *(c++) = hex[(uu & 0xf0) >> 4]; - *(c++) = hex[uu & 0xf]; - } - return c; -} - -/* - Unpack binary data from a string -*/ -SWIGRUNTIME const char * -SWIG_UnpackData(const char *c, void *ptr, size_t sz) { - unsigned char *u = (unsigned char *) ptr; - const unsigned char *eu = u + sz; - for (; u != eu; ++u) { - char d = *(c++); - unsigned char uu; - if ((d >= '0') && (d <= '9')) - uu = (unsigned char)((d - '0') << 4); - else if ((d >= 'a') && (d <= 'f')) - uu = (unsigned char)((d - ('a'-10)) << 4); - else - return (char *) 0; - d = *(c++); - if ((d >= '0') && (d <= '9')) - uu |= (unsigned char)(d - '0'); - else if ((d >= 'a') && (d <= 'f')) - uu |= (unsigned char)(d - ('a'-10)); - else - return (char *) 0; - *u = uu; - } - return c; -} - -/* - Pack 'void *' into a string buffer. -*/ -SWIGRUNTIME char * -SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) { - char *r = buff; - if ((2*sizeof(void *) + 2) > bsz) return 0; - *(r++) = '_'; - r = SWIG_PackData(r,&ptr,sizeof(void *)); - if (strlen(name) + 1 > (bsz - (r - buff))) return 0; - strcpy(r,name); - return buff; -} - -SWIGRUNTIME const char * -SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) { - if (*c != '_') { - if (strcmp(c,"NULL") == 0) { - *ptr = (void *) 0; - return name; - } else { - return 0; - } - } - return SWIG_UnpackData(++c,ptr,sizeof(void *)); -} - -SWIGRUNTIME char * -SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) { - char *r = buff; - size_t lname = (name ? strlen(name) : 0); - if ((2*sz + 2 + lname) > bsz) return 0; - *(r++) = '_'; - r = SWIG_PackData(r,ptr,sz); - if (lname) { - strncpy(r,name,lname+1); - } else { - *r = 0; - } - return buff; -} - -SWIGRUNTIME const char * -SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) { - if (*c != '_') { - if (strcmp(c,"NULL") == 0) { - memset(ptr,0,sz); - return name; - } else { - return 0; - } - } - return SWIG_UnpackData(++c,ptr,sz); -} - -#ifdef __cplusplus -} -#endif - -/* ----------------------------------------------------------------------------- - * luarun.swg - * - * This file contains the runtime support for Lua modules - * and includes code for managing global variables and pointer - * type checking. - * ----------------------------------------------------------------------------- */ - -#ifdef __cplusplus -extern "C" { -#endif - -#include "lua.h" -#include "lauxlib.h" -#include /* for malloc */ -#include /* for a few sanity tests */ - -/* ----------------------------------------------------------------------------- - * Lua flavors - * ----------------------------------------------------------------------------- */ - -#define SWIG_LUA_FLAVOR_LUA 1 -#define SWIG_LUA_FLAVOR_ELUA 2 -#define SWIG_LUA_FLAVOR_ELUAC 3 - -#if !defined(SWIG_LUA_TARGET) -# error SWIG_LUA_TARGET not defined -#endif - -#if defined(SWIG_LUA_ELUA_EMULATE) - -struct swig_elua_entry; - -typedef struct swig_elua_key { - int type; - union { - const char* strkey; - lua_Number numkey; - } key; -} swig_elua_key; - -typedef struct swig_elua_val { - int type; - union { - lua_Number number; - const struct swig_elua_entry *table; - const char *string; - lua_CFunction function; - struct { - char member; - long lvalue; - void *pvalue; - swig_type_info **ptype; - } userdata; - } value; -} swig_elua_val; - -typedef struct swig_elua_entry { - swig_elua_key key; - swig_elua_val value; -} swig_elua_entry; - -#define LSTRKEY(x) {LUA_TSTRING, {.strkey = x} } -#define LNUMKEY(x) {LUA_TNUMBER, {.numkey = x} } -#define LNILKEY {LUA_TNIL, {.strkey = 0} } - -#define LNUMVAL(x) {LUA_TNUMBER, {.number = x} } -#define LFUNCVAL(x) {LUA_TFUNCTION, {.function = x} } -#define LROVAL(x) {LUA_TTABLE, {.table = x} } -#define LNILVAL {LUA_TNIL, {.string = 0} } -#define LSTRVAL(x) {LUA_TSTRING, {.string = x} } - -#define LUA_REG_TYPE swig_elua_entry - -#define SWIG_LUA_ELUA_EMUL_METATABLE_KEY "__metatable" - -#define lua_pushrotable(L,p)\ - lua_newtable(L);\ - assert(p);\ - SWIG_Lua_elua_emulate_register(L,(swig_elua_entry*)(p)); - -#define SWIG_LUA_CONSTTAB_POINTER(B,C,D)\ - LSTRKEY(B), {LUA_TUSERDATA, { .userdata={0,0,(void*)(C),&D} } } - -#define SWIG_LUA_CONSTTAB_BINARY(B,S,C,D)\ - LSTRKEY(B), {LUA_TUSERDATA, { .userdata={1,S,(void*)(C),&D} } } -#endif - -#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC) -# define SWIG_LUA_CONSTTAB_INT(B, C) LSTRKEY(B), LNUMVAL(C) -# define SWIG_LUA_CONSTTAB_FLOAT(B, C) LSTRKEY(B), LNUMVAL(C) -# define SWIG_LUA_CONSTTAB_STRING(B, C) LSTRKEY(B), LSTRVAL(C) -# define SWIG_LUA_CONSTTAB_CHAR(B, C) LSTRKEY(B), LNUMVAL(C) - /* Those two types of constants are not supported in elua */ - -#ifndef SWIG_LUA_CONSTTAB_POINTER -#warning eLua does not support pointers as constants. By default, nil will be used as value -#define SWIG_LUA_CONSTTAB_POINTER(B,C,D) LSTRKEY(B), LNILVAL -#endif - -#ifndef SWIG_LUA_CONSTTAB_BINARY -#warning eLua does not support pointers to member as constants. By default, nil will be used as value -#define SWIG_LUA_CONSTTAB_BINARY(B, S, C, D) LSTRKEY(B), LNILVAL -#endif -#else /* SWIG_LUA_FLAVOR_LUA */ -# define SWIG_LUA_CONSTTAB_INT(B, C) SWIG_LUA_INT, (char *)B, (long)C, 0, 0, 0 -# define SWIG_LUA_CONSTTAB_FLOAT(B, C) SWIG_LUA_FLOAT, (char *)B, 0, (double)C, 0, 0 -# define SWIG_LUA_CONSTTAB_STRING(B, C) SWIG_LUA_STRING, (char *)B, 0, 0, (void *)C, 0 -# define SWIG_LUA_CONSTTAB_CHAR(B, C) SWIG_LUA_CHAR, (char *)B, (long)C, 0, 0, 0 -# define SWIG_LUA_CONSTTAB_POINTER(B,C,D)\ - SWIG_LUA_POINTER, (char *)B, 0, 0, (void *)C, &D -# define SWIG_LUA_CONSTTAB_BINARY(B, S, C, D)\ - SWIG_LUA_BINARY, (char *)B, S, 0, (void *)C, &D -#endif - -#ifndef SWIG_LUA_ELUA_EMULATE -#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC) -# define LRO_STRVAL(v) {{.p = (char *) v}, LUA_TSTRING} -# define LSTRVAL LRO_STRVAL -#endif -#endif /* SWIG_LUA_ELUA_EMULATE*/ - -#ifndef SWIG_LUA_ELUA_EMULATE -#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC) - -#ifndef MIN_OPT_LEVEL -#define MIN_OPT_LEVEL 2 -#endif - -#include "lrodefs.h" -#include "lrotable.h" -#endif -#endif /* SWIG_LUA_ELUA_EMULATE*/ -/* ----------------------------------------------------------------------------- - * compatibility defines - * ----------------------------------------------------------------------------- */ - -/* History of Lua C API length functions: In Lua 5.0 (and before?) - there was "lua_strlen". In Lua 5.1, this was renamed "lua_objlen", - but a compatibility define of "lua_strlen" was added. In Lua 5.2, - this function was again renamed, to "lua_rawlen" (to emphasize that - it doesn't call the "__len" metamethod), and the compatibility - define of lua_strlen was removed. All SWIG uses have been updated - to "lua_rawlen", and we add our own defines of that here for older - versions of Lua. */ -#if !defined(LUA_VERSION_NUM) || LUA_VERSION_NUM < 501 -# define lua_rawlen lua_strlen -#elif LUA_VERSION_NUM == 501 -# define lua_rawlen lua_objlen -#endif - - -/* lua_pushglobaltable is the recommended "future-proof" way to get - the global table for Lua 5.2 and later. Here we define - lua_pushglobaltable ourselves for Lua versions before 5.2. */ -#if !defined(LUA_VERSION_NUM) || LUA_VERSION_NUM < 502 -# define lua_pushglobaltable(L) lua_pushvalue(L, LUA_GLOBALSINDEX) -#endif - -/* lua_absindex was introduced in Lua 5.2 */ -#if !defined(LUA_VERSION_NUM) || LUA_VERSION_NUM < 502 -# define lua_absindex(L,i) ((i)>0 || (i) <= LUA_REGISTRYINDEX ? (i) : lua_gettop(L) + (i) + 1) -#endif - -/* lua_rawsetp was introduced in Lua 5.2 */ -#if !defined(LUA_VERSION_NUM) || LUA_VERSION_NUM < 502 -#define lua_rawsetp(L,index,ptr)\ - lua_pushlightuserdata(L,(void*)(ptr));\ - lua_insert(L,-2);\ - lua_rawset(L,index); - -#define lua_rawgetp(L,index,ptr)\ - lua_pushlightuserdata(L,(void*)(ptr));\ - lua_rawget(L,index); - -#endif - -/* -------------------------------------------------------------------------- - * Helper functions for error handling - * -------------------------------------------------------------------------- */ - -/* Push the string STR on the Lua stack, like lua_pushstring, but - prefixed with the the location of the innermost Lua call-point - (as formated by luaL_where). */ -SWIGRUNTIME void -SWIG_Lua_pusherrstring (lua_State *L, const char *str) -{ - luaL_where (L, 1); - lua_pushstring (L, str); - lua_concat (L, 2); -} - -/* Push a formatted string generated from FMT and following args on - the Lua stack, like lua_pushfstring, but prefixed with the the - location of the innermost Lua call-point (as formated by luaL_where). */ -SWIGRUNTIME void -SWIG_Lua_pushferrstring (lua_State *L, const char *fmt, ...) -{ - va_list argp; - va_start(argp, fmt); - luaL_where(L, 1); - lua_pushvfstring(L, fmt, argp); - va_end(argp); - lua_concat(L, 2); -} - - -/* ----------------------------------------------------------------------------- - * global swig types - * ----------------------------------------------------------------------------- */ -/* Constant table */ -#define SWIG_LUA_INT 1 -#define SWIG_LUA_FLOAT 2 -#define SWIG_LUA_STRING 3 -#define SWIG_LUA_POINTER 4 -#define SWIG_LUA_BINARY 5 -#define SWIG_LUA_CHAR 6 - -/* Structure for variable linking table */ -typedef struct { - const char *name; - lua_CFunction get; - lua_CFunction set; -} swig_lua_var_info; - -#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC) -typedef const LUA_REG_TYPE swig_lua_method; -typedef const LUA_REG_TYPE swig_lua_const_info; -#else /* Normal lua */ -typedef luaL_Reg swig_lua_method; - -/* Constant information structure */ -typedef struct { - int type; - char *name; - long lvalue; - double dvalue; - void *pvalue; - swig_type_info **ptype; -} swig_lua_const_info; - -#endif - -typedef struct { - const char *name; - lua_CFunction getmethod; - lua_CFunction setmethod; -} swig_lua_attribute; - - -struct swig_lua_class; -/* Can be used to create namespaces. Currently used to wrap class static methods/variables/constants */ -typedef struct swig_lua_namespace { - const char *name; - swig_lua_method *ns_methods; - swig_lua_attribute *ns_attributes; - swig_lua_const_info *ns_constants; - struct swig_lua_class **ns_classes; - struct swig_lua_namespace **ns_namespaces; -} swig_lua_namespace; - -typedef struct swig_lua_class { - const char *name; /* Name that this class has in Lua */ - const char *fqname; /* Fully qualified name - Scope + class name */ - swig_type_info **type; - lua_CFunction constructor; - void (*destructor)(void *); - swig_lua_method *methods; - swig_lua_attribute *attributes; - swig_lua_namespace *cls_static; - swig_lua_method *metatable; /* 0 for -eluac */ - struct swig_lua_class **bases; - const char **base_names; -} swig_lua_class; - -/* this is the struct for wrapping all pointers in SwigLua -*/ -typedef struct { - swig_type_info *type; - int own; /* 1 if owned & must be destroyed */ - void *ptr; -} swig_lua_userdata; - -/* this is the struct for wrapping arbitrary packed binary data -(currently it is only used for member function pointers) -the data ordering is similar to swig_lua_userdata, but it is currently not possible -to tell the two structures apart within SWIG, other than by looking at the type -*/ -typedef struct { - swig_type_info *type; - int own; /* 1 if owned & must be destroyed */ - char data[1]; /* arbitary amount of data */ -} swig_lua_rawdata; - -/* Common SWIG API */ -#define SWIG_NewPointerObj(L, ptr, type, owner) SWIG_Lua_NewPointerObj(L, (void *)ptr, type, owner) -#define SWIG_ConvertPtr(L,idx, ptr, type, flags) SWIG_Lua_ConvertPtr(L,idx,ptr,type,flags) -#define SWIG_MustGetPtr(L,idx, type,flags, argnum,fnname) SWIG_Lua_MustGetPtr(L,idx, type,flags, argnum,fnname) -/* for C++ member pointers, ie, member methods */ -#define SWIG_ConvertMember(L, idx, ptr, sz, ty) SWIG_Lua_ConvertPacked(L, idx, ptr, sz, ty) -#define SWIG_NewMemberObj(L, ptr, sz, type) SWIG_Lua_NewPackedObj(L, ptr, sz, type) - -/* Runtime API */ -#define SWIG_GetModule(clientdata) SWIG_Lua_GetModule((lua_State*)(clientdata)) -#define SWIG_SetModule(clientdata, pointer) SWIG_Lua_SetModule((lua_State*) (clientdata), pointer) -#define SWIG_MODULE_CLIENTDATA_TYPE lua_State* - -/* Contract support */ -#define SWIG_contract_assert(expr, msg) \ - if (!(expr)) { SWIG_Lua_pusherrstring(L, (char *) msg); goto fail; } else - - -/* helper #defines */ -#define SWIG_fail {goto fail;} -#define SWIG_fail_arg(func_name,argnum,type) \ - {SWIG_Lua_pushferrstring(L,"Error in %s (arg %d), expected '%s' got '%s'",\ - func_name,argnum,type,SWIG_Lua_typename(L,argnum));\ - goto fail;} -#define SWIG_fail_ptr(func_name,argnum,type) \ - SWIG_fail_arg(func_name,argnum,(type && type->str)?type->str:"void*") -#define SWIG_check_num_args(func_name,a,b) \ - if (lua_gettop(L)b) \ - {SWIG_Lua_pushferrstring(L,"Error in %s expected %d..%d args, got %d",func_name,a,b,lua_gettop(L));\ - goto fail;} - - -#define SWIG_Lua_get_table(L,n) \ - (lua_pushstring(L, n), lua_rawget(L,-2)) - -#define SWIG_Lua_add_function(L,n,f) \ - (lua_pushstring(L, n), \ - lua_pushcfunction(L, f), \ - lua_rawset(L,-3)) - -#define SWIG_Lua_add_boolean(L,n,b) \ - (lua_pushstring(L, n), \ - lua_pushboolean(L, b), \ - lua_rawset(L,-3)) - -/* special helper for allowing 'nil' for usertypes */ -#define SWIG_isptrtype(L,I) (lua_isuserdata(L,I) || lua_isnil(L,I)) - -#ifdef __cplusplus -/* Special helper for member function pointers -it gets the address, casts it, then dereferences it */ -/*#define SWIG_mem_fn_as_voidptr(a) (*((char**)&(a))) */ -#endif - -/* storing/access of swig_module_info */ -SWIGRUNTIME swig_module_info * -SWIG_Lua_GetModule(lua_State *L) { - swig_module_info *ret = 0; - lua_pushstring(L,"swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME); - lua_rawget(L,LUA_REGISTRYINDEX); - if (lua_islightuserdata(L,-1)) - ret=(swig_module_info*)lua_touserdata(L,-1); - lua_pop(L,1); /* tidy */ - return ret; -} - -SWIGRUNTIME void -SWIG_Lua_SetModule(lua_State *L, swig_module_info *module) { - /* add this all into the Lua registry: */ - lua_pushstring(L,"swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME); - lua_pushlightuserdata(L,(void*)module); - lua_rawset(L,LUA_REGISTRYINDEX); -} - -/* ----------------------------------------------------------------------------- - * global variable support code: modules - * ----------------------------------------------------------------------------- */ - -/* this function is called when trying to set an immutable. -default action is to print an error. -This can removed with a compile flag SWIGLUA_IGNORE_SET_IMMUTABLE */ -SWIGINTERN int SWIG_Lua_set_immutable(lua_State *L) -{ -/* there should be 1 param passed in: the new value */ -#ifndef SWIGLUA_IGNORE_SET_IMMUTABLE - lua_pop(L,1); /* remove it */ - luaL_error(L,"This variable is immutable"); -#endif - return 0; /* should not return anything */ -} - -#ifdef SWIG_LUA_ELUA_EMULATE - -SWIGRUNTIME void SWIG_Lua_NewPointerObj(lua_State *L,void *ptr,swig_type_info *type, int own); -SWIGRUNTIME void SWIG_Lua_NewPackedObj(lua_State *L,void *ptr,size_t size,swig_type_info *type); -static int swig_lua_elua_emulate_unique_key; - -/* This function emulates eLua rotables behaviour. It loads a rotable definition into the usual lua table. */ -SWIGINTERN void SWIG_Lua_elua_emulate_register(lua_State *L, const swig_elua_entry *table) -{ - int i, table_parsed, parsed_tables_array, target_table; - assert(lua_istable(L,-1)); - target_table = lua_gettop(L); - /* Get the registry where we put all parsed tables to avoid loops */ - lua_rawgetp(L, LUA_REGISTRYINDEX, &swig_lua_elua_emulate_unique_key); - if(lua_isnil(L,-1)) { - lua_pop(L,1); - lua_newtable(L); - lua_pushvalue(L,-1); - lua_rawsetp(L,LUA_REGISTRYINDEX,(void*)(&swig_lua_elua_emulate_unique_key)); - } - parsed_tables_array = lua_gettop(L); - lua_pushvalue(L,target_table); - lua_rawsetp(L, parsed_tables_array, table); - table_parsed = 0; - const int SWIGUNUSED pairs_start = lua_gettop(L); - for(i = 0;table[i].key.type != LUA_TNIL || table[i].value.type != LUA_TNIL;i++) - { - const swig_elua_entry *entry = table + i; - int is_metatable = 0; - switch(entry->key.type) { - case LUA_TSTRING: - lua_pushstring(L,entry->key.key.strkey); - if(strcmp(entry->key.key.strkey, SWIG_LUA_ELUA_EMUL_METATABLE_KEY) == 0) - is_metatable = 1; - break; - case LUA_TNUMBER: - lua_pushnumber(L,entry->key.key.numkey); - break; - case LUA_TNIL: - lua_pushnil(L); - break; - default: - assert(0); - } - switch(entry->value.type) { - case LUA_TSTRING: - lua_pushstring(L,entry->value.value.string); - break; - case LUA_TNUMBER: - lua_pushnumber(L,entry->value.value.number); - break; - case LUA_TFUNCTION: - lua_pushcfunction(L,entry->value.value.function); - break; - case LUA_TTABLE: - lua_rawgetp(L,parsed_tables_array, entry->value.value.table); - table_parsed = !lua_isnil(L,-1); - if(!table_parsed) { - lua_pop(L,1); /*remove nil */ - lua_newtable(L); - SWIG_Lua_elua_emulate_register(L,entry->value.value.table); - } - if(is_metatable) { - assert(lua_istable(L,-1)); - lua_pushvalue(L,-1); - lua_setmetatable(L,target_table); - } - - break; - case LUA_TUSERDATA: - if(entry->value.value.userdata.member) - SWIG_NewMemberObj(L,entry->value.value.userdata.pvalue, - entry->value.value.userdata.lvalue, - *(entry->value.value.userdata.ptype)); - else - SWIG_NewPointerObj(L,entry->value.value.userdata.pvalue, - *(entry->value.value.userdata.ptype),0); - break; - case LUA_TNIL: - lua_pushnil(L); - break; - default: - assert(0); - } - assert(lua_gettop(L) == pairs_start + 2); - lua_rawset(L,target_table); - } - lua_pop(L,1); /* Removing parsed tables storage */ - assert(lua_gettop(L) == target_table); -} - -SWIGINTERN void SWIG_Lua_elua_emulate_register_clear(lua_State *L) -{ - lua_pushnil(L); - lua_rawsetp(L, LUA_REGISTRYINDEX, &swig_lua_elua_emulate_unique_key); -} - -SWIGINTERN void SWIG_Lua_get_class_registry(lua_State *L); - -SWIGINTERN int SWIG_Lua_emulate_elua_getmetatable(lua_State *L) -{ - SWIG_check_num_args("getmetatable(SWIG eLua emulation)", 1, 1); - SWIG_Lua_get_class_registry(L); - lua_getfield(L,-1,"lua_getmetatable"); - lua_remove(L,-2); /* remove the registry*/ - assert(!lua_isnil(L,-1)); - lua_pushvalue(L,1); - assert(lua_gettop(L) == 3); /* object | function | object again */ - lua_call(L,1,1); - if(!lua_isnil(L,-1)) /*There is an ordinary metatable */ - return 1; - /*if it is a table, then emulate elua behaviour - check for __metatable attribute of a table*/ - assert(lua_gettop(L) == 2); - if(lua_istable(L,-2)) { - lua_pop(L,1); /*remove the nil*/ - lua_getfield(L,-1, SWIG_LUA_ELUA_EMUL_METATABLE_KEY); - } - assert(lua_gettop(L) == 2); - return 1; - -fail: - lua_error(L); - return 0; -} - -SWIGINTERN void SWIG_Lua_emulate_elua_swap_getmetatable(lua_State *L) -{ - SWIG_Lua_get_class_registry(L); - lua_pushglobaltable(L); - lua_pushstring(L,"lua_getmetatable"); - lua_getfield(L,-2,"getmetatable"); - assert(!lua_isnil(L,-1)); - lua_rawset(L,-4); - lua_pushstring(L, "getmetatable"); - lua_pushcfunction(L, SWIG_Lua_emulate_elua_getmetatable); - lua_rawset(L,-3); - lua_pop(L,2); - -} -/* END OF REMOVE */ - -#endif -/* ----------------------------------------------------------------------------- - * global variable support code: namespaces and modules (which are the same thing) - * ----------------------------------------------------------------------------- */ - -SWIGINTERN int SWIG_Lua_namespace_get(lua_State *L) -{ -/* there should be 2 params passed in - (1) table (not the meta table) - (2) string name of the attribute -*/ - assert(lua_istable(L,-2)); /* just in case */ - lua_getmetatable(L,-2); - assert(lua_istable(L,-1)); - SWIG_Lua_get_table(L,".get"); /* find the .get table */ - assert(lua_istable(L,-1)); - /* look for the key in the .get table */ - lua_pushvalue(L,2); /* key */ - lua_rawget(L,-2); - lua_remove(L,-2); /* stack tidy, remove .get table */ - if (lua_iscfunction(L,-1)) - { /* found it so call the fn & return its value */ - lua_call(L,0,1); /* 1 value in (userdata),1 out (result) */ - lua_remove(L,-2); /* stack tidy, remove metatable */ - return 1; - } - lua_pop(L,1); /* remove whatever was there */ - /* ok, so try the .fn table */ - SWIG_Lua_get_table(L,".fn"); /* find the .get table */ - assert(lua_istable(L,-1)); /* just in case */ - lua_pushvalue(L,2); /* key */ - lua_rawget(L,-2); /* look for the fn */ - lua_remove(L,-2); /* stack tidy, remove .fn table */ - if (lua_isfunction(L,-1)) /* note: whether it's a C function or lua function */ - { /* found it so return the fn & let lua call it */ - lua_remove(L,-2); /* stack tidy, remove metatable */ - return 1; - } - lua_pop(L,1); /* remove whatever was there */ - return 0; -} - -SWIGINTERN int SWIG_Lua_namespace_set(lua_State *L) -{ -/* there should be 3 params passed in - (1) table (not the meta table) - (2) string name of the attribute - (3) any for the new value -*/ - - assert(lua_istable(L,1)); - lua_getmetatable(L,1); /* get the meta table */ - assert(lua_istable(L,-1)); - - SWIG_Lua_get_table(L,".set"); /* find the .set table */ - if (lua_istable(L,-1)) - { - /* look for the key in the .set table */ - lua_pushvalue(L,2); /* key */ - lua_rawget(L,-2); - if (lua_iscfunction(L,-1)) - { /* found it so call the fn & return its value */ - lua_pushvalue(L,3); /* value */ - lua_call(L,1,0); - return 0; - } - lua_pop(L,1); /* remove the value */ - } - lua_pop(L,1); /* remove the value .set table */ - lua_pop(L,1); /* remote metatable */ - lua_rawset(L,-3); - return 0; -} - -#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA) /* In elua this is useless */ -SWIGINTERN void SWIG_Lua_InstallConstants(lua_State *L, swig_lua_const_info constants[]); /* forward declaration */ -SWIGINTERN void SWIG_Lua_add_variable(lua_State *L,const char *name,lua_CFunction getFn,lua_CFunction setFn); /* forward declaration */ -SWIGINTERN void SWIG_Lua_class_register(lua_State *L,swig_lua_class *clss); - -/* helper function - register namespace methods and attributes into namespace */ -SWIGINTERN int SWIG_Lua_add_namespace_details(lua_State *L, swig_lua_namespace *ns) -{ - int i; - /* There must be namespace table (not metatable) at the top of the stack */ - assert(lua_istable(L,-1)); - SWIG_Lua_InstallConstants(L, ns->ns_constants); - - /* add methods to the namespace/module table */ - for(i=0;ns->ns_methods[i].name;i++){ - SWIG_Lua_add_function(L,ns->ns_methods[i].name,ns->ns_methods[i].func); - } - lua_getmetatable(L,-1); - - /* add fns */ - for(i=0;ns->ns_attributes[i].name;i++){ - SWIG_Lua_add_variable(L,ns->ns_attributes[i].name,ns->ns_attributes[i].getmethod,ns->ns_attributes[i].setmethod); - } - - /* clear stack - remove metatble */ - lua_pop(L,1); - return 0; -} - -/* Register all classes in the namespace */ -SWIGINTERN void SWIG_Lua_add_namespace_classes(lua_State *L, swig_lua_namespace *ns) -{ - swig_lua_class **classes; - - /* There must be a module/namespace table at the top of the stack */ - assert(lua_istable(L,-1)); - - classes = ns->ns_classes; - - if( classes != 0 ) { - while(*classes != 0) { - SWIG_Lua_class_register(L, *classes); - classes++; - } - } -} - -/* Helper function. Creates namespace table and adds it to module table - if 'reg' is true, then will register namespace table to parent one (must be on top of the stack - when function is called). - Function always returns newly registered table on top of the stack. -*/ -SWIGINTERN void SWIG_Lua_namespace_register(lua_State *L, swig_lua_namespace *ns, int reg) -{ - swig_lua_namespace **sub_namespace; - /* 1 argument - table on the top of the stack */ - const int SWIGUNUSED begin = lua_gettop(L); - assert(lua_istable(L,-1)); /* just in case. This is supposed to be module table or parent namespace table */ - lua_checkstack(L,5); - lua_newtable(L); /* namespace itself */ - lua_newtable(L); /* metatable for namespace */ - - /* add a table called ".get" */ - lua_pushstring(L,".get"); - lua_newtable(L); - lua_rawset(L,-3); - /* add a table called ".set" */ - lua_pushstring(L,".set"); - lua_newtable(L); - lua_rawset(L,-3); - /* add a table called ".fn" */ - lua_pushstring(L,".fn"); - lua_newtable(L); - lua_rawset(L,-3); - - /* add accessor fns for using the .get,.set&.fn */ - SWIG_Lua_add_function(L,"__index",SWIG_Lua_namespace_get); - SWIG_Lua_add_function(L,"__newindex",SWIG_Lua_namespace_set); - - lua_setmetatable(L,-2); /* set metatable */ - - /* Register all functions, variables etc */ - SWIG_Lua_add_namespace_details(L,ns); - /* Register classes */ - SWIG_Lua_add_namespace_classes(L,ns); - - sub_namespace = ns->ns_namespaces; - if( sub_namespace != 0) { - while(*sub_namespace != 0) { - SWIG_Lua_namespace_register(L, *sub_namespace, 1); - lua_pop(L,1); /* removing sub-namespace table */ - sub_namespace++; - } - } - - if (reg) { - lua_pushstring(L,ns->name); - lua_pushvalue(L,-2); - lua_rawset(L,-4); /* add namespace to module table */ - } - assert(lua_gettop(L) == begin+1); -} -#endif /* SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA */ - -/* ----------------------------------------------------------------------------- - * global variable support code: classes - * ----------------------------------------------------------------------------- */ - -SWIGINTERN void SWIG_Lua_get_class_metatable(lua_State *L,const char *cname); - -typedef int (*swig_lua_base_iterator_func)(lua_State*,swig_type_info*, int, int *ret); - -SWIGINTERN int SWIG_Lua_iterate_bases(lua_State *L, swig_type_info * SWIGUNUSED swig_type, - int first_arg, swig_lua_base_iterator_func func, int *const ret) -{ - /* first_arg - position of the object in stack. Everything that is above are arguments - * and is passed to every evocation of the func */ - int last_arg = lua_gettop(L);/* position of last argument */ - int original_metatable = last_arg + 1; - size_t bases_count; - int result = SWIG_ERROR; - int bases_table; - (void)swig_type; - lua_getmetatable(L,first_arg); - - /* initialise base search */ -#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA) - SWIG_Lua_get_table(L,".bases"); - assert(lua_istable(L,-1)); - bases_count = lua_rawlen(L,-1); - bases_table = lua_gettop(L); -#else - /* In elua .bases table doesn't exist. Use table from swig_lua_class */ - (void)bases_table; - assert(swig_type!=0); - swig_module_info *module=SWIG_GetModule(L); - swig_lua_class **bases= ((swig_lua_class*)(swig_type->clientdata))->bases; - const char **base_names= ((swig_lua_class*)(swig_type->clientdata))->base_names; - bases_count = 0; - for(;base_names[bases_count]; - bases_count++);/* get length of bases */ -#endif - - if(ret) - *ret = 0; - if(bases_count>0) - { - int to_remove; - size_t i; - int j; - int subcall_last_arg; - int subcall_first_arg = lua_gettop(L) + 1;/* Here a copy of first_arg and arguments begin */ - int valid = 1; - swig_type_info *base_swig_type = 0; - for(j=first_arg;j<=last_arg;j++) - lua_pushvalue(L,j); - subcall_last_arg = lua_gettop(L); - - /* Trick: temporarily replacing original metatable with metatable for base class and call getter */ - for(i=0;ifqname); - base_swig_type = SWIG_TypeQueryModule(module,module,base_names[i]); - assert(base_swig_type != 0); - } -#endif - - if(!valid) - continue; - assert(lua_isuserdata(L, subcall_first_arg)); - assert(lua_istable(L,-1)); - lua_setmetatable(L,subcall_first_arg); /* Set new metatable */ - assert(lua_gettop(L) == subcall_last_arg); - result = func(L, base_swig_type,subcall_first_arg, ret); /* Forward call */ - if(result != SWIG_ERROR) { - break; - } - } - /* Restore original metatable */ - lua_pushvalue(L,original_metatable); - lua_setmetatable(L,first_arg); - /* Clear - remove everything between last_arg and subcall_last_arg including */ - to_remove = subcall_last_arg - last_arg; - for(j=0;jtype; - result = SWIG_Lua_class_do_get(L,type,1,&ret); - if(result == SWIG_OK) - return ret; - - result = SWIG_Lua_class_do_get_item(L,type,1,&ret); - if(result == SWIG_OK) - return ret; - - return 0; -} - -/* helper for the class.set method, performs the lookup of class attributes - * It returns error code. Number of function return values is passed inside 'ret' - */ -SWIGINTERN int SWIG_Lua_class_do_set(lua_State *L, swig_type_info *type, int first_arg, int *ret) -{ -/* there should be 3 params passed in - (1) table (not the meta table) - (2) string name of the attribute - (3) any for the new value - */ - - int bases_search_result; - int substack_start = lua_gettop(L) - 3; - lua_checkstack(L,5); - assert(lua_isuserdata(L,substack_start+1)); /* just in case */ - lua_getmetatable(L,substack_start+1); /* get the meta table */ - assert(lua_istable(L,-1)); /* just in case */ - if(ret) - *ret = 0; /* it is setter - number of return values is always 0 */ - - SWIG_Lua_get_table(L,".set"); /* find the .set table */ - if (lua_istable(L,-1)) - { - /* look for the key in the .set table */ - lua_pushvalue(L,substack_start+2); /* key */ - lua_rawget(L,-2); - lua_remove(L,-2); /* tidy stack, remove .set table */ - if (lua_iscfunction(L,-1)) - { /* found it so call the fn & return its value */ - lua_pushvalue(L,substack_start+1); /* userdata */ - lua_pushvalue(L,substack_start+3); /* value */ - lua_call(L,2,0); - lua_remove(L,substack_start+4); /*remove metatable*/ - return SWIG_OK; - } - lua_pop(L,1); /* remove the value */ - } else { - lua_pop(L,1); /* remove the answer for .set table request*/ - } - /* NEW: looks for the __setitem() fn - this is a user provided set fn */ - SWIG_Lua_get_table(L,"__setitem"); /* find the fn */ - if (lua_iscfunction(L,-1)) /* if its there */ - { /* found it so call the fn & return its value */ - lua_pushvalue(L,substack_start+1); /* the userdata */ - lua_pushvalue(L,substack_start+2); /* the parameter */ - lua_pushvalue(L,substack_start+3); /* the value */ - lua_call(L,3,0); /* 3 values in ,0 out */ - lua_remove(L,-2); /* stack tidy, remove metatable */ - return SWIG_OK; - } - lua_pop(L,1); /* remove value */ - - lua_pop(L,1); /* remove metatable */ - /* Search among bases */ - bases_search_result = SWIG_Lua_iterate_bases(L,type,first_arg,SWIG_Lua_class_do_set,ret); - if(ret) - assert(*ret == 0); - assert(lua_gettop(L) == substack_start + 3); - return bases_search_result; -} - -/* This is the actual method exported to Lua. It calls SWIG_Lua_class_do_set and correctly - * handles return values. - */ -SWIGINTERN int SWIG_Lua_class_set(lua_State *L) -{ -/* There should be 3 params passed in - (1) table (not the meta table) - (2) string name of the attribute - (3) any for the new value - */ - int ret = 0; - int result; - swig_lua_userdata *usr; - swig_type_info *type; - assert(lua_isuserdata(L,1)); - usr=(swig_lua_userdata*)lua_touserdata(L,1); /* get data */ - type = usr->type; - result = SWIG_Lua_class_do_set(L,type,1,&ret); - if(result != SWIG_OK) { - SWIG_Lua_pushferrstring(L,"Assignment not possible. No setter/member with this name. For custom assignments implement __setitem method."); - lua_error(L); - } else { - assert(ret==0); - } - return 0; -} - -/* the class.destruct method called by the interpreter */ -SWIGINTERN int SWIG_Lua_class_destruct(lua_State *L) -{ -/* there should be 1 params passed in - (1) userdata (not the meta table) */ - swig_lua_userdata *usr; - swig_lua_class *clss; - assert(lua_isuserdata(L,-1)); /* just in case */ - usr=(swig_lua_userdata*)lua_touserdata(L,-1); /* get it */ - /* if must be destroyed & has a destructor */ - if (usr->own) /* if must be destroyed */ - { - clss=(swig_lua_class*)usr->type->clientdata; /* get the class */ - if (clss && clss->destructor) /* there is a destroy fn */ - { - clss->destructor(usr->ptr); /* bye bye */ - } - } - return 0; -} - -/* the class.__tostring method called by the interpreter and print */ -SWIGINTERN int SWIG_Lua_class_tostring(lua_State *L) -{ -/* there should be 1 param passed in - (1) userdata (not the metatable) */ - const char *className; - void* userData; - assert(lua_isuserdata(L,1)); /* just in case */ - userData = lua_touserdata(L,1); /* get the userdata address for later */ - lua_getmetatable(L,1); /* get the meta table */ - assert(lua_istable(L,-1)); /* just in case */ - - lua_getfield(L, -1, ".type"); - className = lua_tostring(L, -1); - - lua_pushfstring(L, "<%s userdata: %p>", className, userData); - return 1; -} - -/* to manually disown some userdata */ -SWIGINTERN int SWIG_Lua_class_disown(lua_State *L) -{ -/* there should be 1 params passed in - (1) userdata (not the meta table) */ - swig_lua_userdata *usr; - assert(lua_isuserdata(L,-1)); /* just in case */ - usr=(swig_lua_userdata*)lua_touserdata(L,-1); /* get it */ - - usr->own = 0; /* clear our ownership */ - return 0; -} - -/* lua callable function to compare userdata's value -the issue is that two userdata may point to the same thing -but to lua, they are different objects */ -SWIGRUNTIME int SWIG_Lua_class_equal(lua_State *L) -{ - int result; - swig_lua_userdata *usr1,*usr2; - if (!lua_isuserdata(L,1) || !lua_isuserdata(L,2)) /* just in case */ - return 0; /* nil reply */ - usr1=(swig_lua_userdata*)lua_touserdata(L,1); /* get data */ - usr2=(swig_lua_userdata*)lua_touserdata(L,2); /* get data */ - /*result=(usr1->ptr==usr2->ptr && usr1->type==usr2->type); only works if type is the same*/ - result=(usr1->ptr==usr2->ptr); - lua_pushboolean(L,result); - return 1; -} - -/* populate table at the top of the stack with metamethods that ought to be inherited */ -SWIGINTERN void SWIG_Lua_populate_inheritable_metamethods(lua_State *L) -{ - SWIG_Lua_add_boolean(L, "__add", 1); - SWIG_Lua_add_boolean(L, "__sub", 1); - SWIG_Lua_add_boolean(L, "__mul", 1); - SWIG_Lua_add_boolean(L, "__div", 1); - SWIG_Lua_add_boolean(L, "__mod", 1); - SWIG_Lua_add_boolean(L, "__pow", 1); - SWIG_Lua_add_boolean(L, "__unm", 1); - SWIG_Lua_add_boolean(L, "__len", 1 ); - SWIG_Lua_add_boolean(L, "__concat", 1 ); - SWIG_Lua_add_boolean(L, "__eq", 1); - SWIG_Lua_add_boolean(L, "__lt", 1); - SWIG_Lua_add_boolean(L, "__le", 1); - SWIG_Lua_add_boolean(L, "__call", 1); - SWIG_Lua_add_boolean(L, "__tostring", 1); - SWIG_Lua_add_boolean(L, "__gc", 0); -} - -/* creates the swig registry */ -SWIGINTERN void SWIG_Lua_create_class_registry(lua_State *L) -{ - /* create main SWIG registry table */ - lua_pushstring(L,"SWIG"); - lua_newtable(L); - /* populate it with some predefined data */ - - /* .library table. Placeholder */ - lua_pushstring(L,".library"); - lua_newtable(L); - { - /* list of metamethods that class inherits from its bases */ - lua_pushstring(L,"inheritable_metamethods"); - lua_newtable(L); - /* populate with list of metamethods */ - SWIG_Lua_populate_inheritable_metamethods(L); - lua_rawset(L,-3); - } - lua_rawset(L,-3); - - lua_rawset(L,LUA_REGISTRYINDEX); -} - -/* gets the swig registry (or creates it) */ -SWIGINTERN void SWIG_Lua_get_class_registry(lua_State *L) -{ - /* add this all into the swig registry: */ - lua_pushstring(L,"SWIG"); - lua_rawget(L,LUA_REGISTRYINDEX); /* get the registry */ - if (!lua_istable(L,-1)) /* not there */ - { /* must be first time, so add it */ - lua_pop(L,1); /* remove the result */ - SWIG_Lua_create_class_registry(L); - /* then get it */ - lua_pushstring(L,"SWIG"); - lua_rawget(L,LUA_REGISTRYINDEX); - } -} - -SWIGINTERN void SWIG_Lua_get_inheritable_metamethods(lua_State *L) -{ - SWIG_Lua_get_class_registry(L); - lua_pushstring(L, ".library"); - lua_rawget(L,-2); - assert( !lua_isnil(L,-1) ); - lua_pushstring(L, "inheritable_metamethods"); - lua_rawget(L,-2); - - /* Remove class registry and library table */ - lua_remove(L,-2); - lua_remove(L,-2); -} - -/* Helper function to get the classes metatable from the register */ -SWIGINTERN void SWIG_Lua_get_class_metatable(lua_State *L,const char *cname) -{ - SWIG_Lua_get_class_registry(L); /* get the registry */ - lua_pushstring(L,cname); /* get the name */ - lua_rawget(L,-2); /* get it */ - lua_remove(L,-2); /* tidy up (remove registry) */ -} - -/* Set up the base classes pointers. -Each class structure has a list of pointers to the base class structures. -This function fills them. -It cannot be done at compile time, as this will not work with hireachies -spread over more than one swig file. -Therefore it must be done at runtime, querying the SWIG type system. -*/ -SWIGINTERN void SWIG_Lua_init_base_class(lua_State *L,swig_lua_class *clss) -{ - int i=0; - swig_module_info *module=SWIG_GetModule(L); - for(i=0;clss->base_names[i];i++) - { - if (clss->bases[i]==0) /* not found yet */ - { - /* lookup and cache the base class */ - swig_type_info *info = SWIG_TypeQueryModule(module,module,clss->base_names[i]); - if (info) clss->bases[i] = (swig_lua_class *) info->clientdata; - } - } -} - -#if defined(SWIG_LUA_SQUASH_BASES) && (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA) -/* Merges two tables */ -SWIGINTERN void SWIG_Lua_merge_tables_by_index(lua_State *L, int target, int source) -{ - /* iterating */ - lua_pushnil(L); - while (lua_next(L,source) != 0) { - /* -1 - value, -2 - index */ - /* have to copy to assign */ - lua_pushvalue(L,-2); /* copy of index */ - lua_pushvalue(L,-2); /* copy of value */ - lua_rawset(L, target); - lua_pop(L,1); - /* only key is left */ - } -} - -/* Merges two tables with given name. original - index of target metatable, base - index of source metatable */ -SWIGINTERN void SWIG_Lua_merge_tables(lua_State *L, const char* name, int original, int base) -{ - /* push original[name], then base[name] */ - lua_pushstring(L,name); - lua_rawget(L,original); - int original_table = lua_gettop(L); - lua_pushstring(L,name); - lua_rawget(L,base); - int base_table = lua_gettop(L); - SWIG_Lua_merge_tables_by_index(L, original_table, base_table); - /* clearing stack */ - lua_pop(L,2); -} - -/* Function takes all symbols from base and adds it to derived class. It's just a helper. */ -SWIGINTERN void SWIG_Lua_class_squash_base(lua_State *L, swig_lua_class *base_cls) -{ - /* There is one parameter - original, i.e. 'derived' class metatable */ - assert(lua_istable(L,-1)); - int original = lua_gettop(L); - SWIG_Lua_get_class_metatable(L,base_cls->fqname); - int base = lua_gettop(L); - SWIG_Lua_merge_tables(L, ".fn", original, base ); - SWIG_Lua_merge_tables(L, ".set", original, base ); - SWIG_Lua_merge_tables(L, ".get", original, base ); - lua_pop(L,1); -} - -/* Function squashes all symbols from 'clss' bases into itself */ -SWIGINTERN void SWIG_Lua_class_squash_bases(lua_State *L, swig_lua_class *clss) -{ - int i; - SWIG_Lua_get_class_metatable(L,clss->fqname); - for(i=0;clss->base_names[i];i++) - { - if (clss->bases[i]==0) /* Somehow it's not found. Skip it */ - continue; - /* Thing is: all bases are already registered. Thus they have already executed - * this function. So we just need to squash them into us, because their bases - * are already squashed into them. No need for recursion here! - */ - SWIG_Lua_class_squash_base(L, clss->bases[i]); - } - lua_pop(L,1); /*tidy stack*/ -} -#endif - -#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA) /* In elua this is useless */ -/* helper add a variable to a registered class */ -SWIGINTERN void SWIG_Lua_add_variable(lua_State *L,const char *name,lua_CFunction getFn,lua_CFunction setFn) -{ - assert(lua_istable(L,-1)); /* just in case */ - SWIG_Lua_get_table(L,".get"); /* find the .get table */ - assert(lua_istable(L,-1)); /* just in case */ - SWIG_Lua_add_function(L,name,getFn); - lua_pop(L,1); /* tidy stack (remove table) */ - if (setFn) - { - SWIG_Lua_get_table(L,".set"); /* find the .set table */ - assert(lua_istable(L,-1)); /* just in case */ - SWIG_Lua_add_function(L,name,setFn); - lua_pop(L,1); /* tidy stack (remove table) */ - } -} - -/* helper to recursively add class static details (static attributes, operations and constants) */ -SWIGINTERN void SWIG_Lua_add_class_static_details(lua_State *L, swig_lua_class *clss) -{ - int i = 0; - /* The class namespace table must be on the top of the stack */ - assert(lua_istable(L,-1)); - /* call all the base classes first: we can then override these later: */ - for(i=0;clss->bases[i];i++) - { - SWIG_Lua_add_class_static_details(L,clss->bases[i]); - } - - SWIG_Lua_add_namespace_details(L, clss->cls_static); -} - -SWIGINTERN void SWIG_Lua_add_class_user_metamethods(lua_State *L, swig_lua_class *clss); /* forward declaration */ - -/* helper to recursively add class details (attributes & operations) */ -SWIGINTERN void SWIG_Lua_add_class_instance_details(lua_State *L, swig_lua_class *clss) -{ - int i; - size_t bases_count = 0; - /* Add bases to .bases table */ - SWIG_Lua_get_table(L,".bases"); - assert(lua_istable(L,-1)); /* just in case */ - for(i=0;clss->bases[i];i++) - { - SWIG_Lua_get_class_metatable(L,clss->bases[i]->fqname); - /* Base class must be already registered */ - assert(lua_istable(L,-1)); - lua_rawseti(L,-2,i+1); /* In lua indexing starts from 1 */ - bases_count++; - } - assert(lua_rawlen(L,-1) == bases_count); - lua_pop(L,1); /* remove .bases table */ - /* add attributes */ - for(i=0;clss->attributes[i].name;i++){ - SWIG_Lua_add_variable(L,clss->attributes[i].name,clss->attributes[i].getmethod,clss->attributes[i].setmethod); - } - /* add methods to the metatable */ - SWIG_Lua_get_table(L,".fn"); /* find the .fn table */ - assert(lua_istable(L,-1)); /* just in case */ - for(i=0;clss->methods[i].name;i++){ - SWIG_Lua_add_function(L,clss->methods[i].name,clss->methods[i].func); - } - lua_pop(L,1); /* tidy stack (remove table) */ - /* add operator overloads - This adds methods from metatable array to metatable. Can mess up garbage - collectind if someone defines __gc method - */ - if(clss->metatable) { - for(i=0;clss->metatable[i].name;i++) { - SWIG_Lua_add_function(L,clss->metatable[i].name,clss->metatable[i].func); - } - } - -#if !defined(SWIG_LUA_SQUASH_BASES) - /* Adding metamethods that are defined in base classes. If bases were squashed - * then it is obviously unnecessary - */ - SWIG_Lua_add_class_user_metamethods(L, clss); -#endif -} - -/* Helpers to add user defined class metamedhods - __add, __sub etc. The helpers are needed - for the following issue: Lua runtime checks for metamethod existence with rawget function - ignoring our SWIG-provided __index and __newindex functions. Thus our inheritance-aware method - search algorithm doesn't work in such case. (Not to say that Lua runtime queries metamethod directly - in metatable and not in object). - Current solution is this: if somewhere in hierarchy metamethod __x is defined, then all descendants - are automatically given a special proxy __x that calls the real __x method. - Obvious idea - to copy __x instead of creating __x-proxy is wrong because if someone changes __x in runtime, - those changes must be reflected in all descendants. -*/ - -SWIGRUNTIME int SWIG_Lua_resolve_metamethod(lua_State *L); /*forward declaration*/ - -/* The real function that resolves a metamethod. - * Function searches given class and all it's bases(recursively) for first instance of something that is - * not equal to SWIG_Lua_resolve_metatmethod. (Almost always this 'something' is actual metamethod implementation - * and it is a SWIG-generated C function.). It returns value on the top of the L and there is no garbage below the - * answer. - * Returns 1 if found, 0 otherwise. - * clss is class which metatable we will search for method - * metamethod_name_idx is index in L where metamethod name (as string) lies - * skip_check allows to skip searching metamethod in givel clss and immideatelly go to searching in bases. skip_check - * is not caried to subsequent recursive calls - false is always passed. It is set to true only at first call from - * SWIG_Lua_resolve_metamethod - * */ -SWIGINTERN int SWIG_Lua_do_resolve_metamethod(lua_State *L, const swig_lua_class *clss, int metamethod_name_idx, - int skip_check) -{ - /* This function is called recursively */ - int result = 0; - int i = 0; - - if (!skip_check) { - SWIG_Lua_get_class_metatable(L, clss->fqname); - lua_pushvalue(L, metamethod_name_idx); - lua_rawget(L,-2); - /* If this is cfunction and it is equal to SWIG_Lua_resolve_metamethod then - * this isn't the function we are looking for :) - * lua_tocfunction will return NULL if not cfunction - */ - if (!lua_isnil(L,-1) && lua_tocfunction(L,-1) != SWIG_Lua_resolve_metamethod ) { - lua_remove(L,-2); /* removing class metatable */ - return 1; - } - lua_pop(L,2); /* remove class metatable and query result */ - } - - /* Forwarding calls to bases */ - for(i=0;clss->bases[i];i++) - { - result = SWIG_Lua_do_resolve_metamethod(L, clss->bases[i], metamethod_name_idx, 0); - if (result) - break; - } - - return result; -} - -/* The proxy function for metamethod. All parameters are passed as cclosure. Searches for actual method - * and calls it */ -SWIGRUNTIME int SWIG_Lua_resolve_metamethod(lua_State *L) -{ - int numargs; - int metamethod_name_idx; - const swig_lua_class* clss; - int result; - - lua_checkstack(L,5); - numargs = lua_gettop(L); /* number of arguments to pass to actual metamethod */ - - /* Get upvalues from closure */ - lua_pushvalue(L, lua_upvalueindex(1)); /*Get function name*/ - metamethod_name_idx = lua_gettop(L); - - lua_pushvalue(L, lua_upvalueindex(2)); - clss = (const swig_lua_class*)(lua_touserdata(L,-1)); - lua_pop(L,1); /* remove lightuserdata with clss from stack */ - - /* Actual work */ - result = SWIG_Lua_do_resolve_metamethod(L, clss, metamethod_name_idx, 1); - if (!result) { - SWIG_Lua_pushferrstring(L,"The metamethod proxy is set, but it failed to find actual metamethod. Memory corruption is most likely explanation."); - lua_error(L); - return 0; - } - - lua_remove(L,-2); /* remove metamethod key */ - lua_insert(L,1); /* move function to correct position */ - lua_call(L, numargs, LUA_MULTRET); - return lua_gettop(L); /* return all results */ -} - - -/* If given metamethod must be present in given class, then creates appropriate proxy - * Returns 1 if successfully added, 0 if not added because no base class has it, -1 - * if method is defined in the class metatable itself - */ -SWIGINTERN int SWIG_Lua_add_class_user_metamethod(lua_State *L, swig_lua_class *clss, const int metatable_index) -{ - int key_index; - int success = 0; - int i = 0; - - /* metamethod name - on the top of the stack */ - assert(lua_isstring(L,-1)); - - key_index = lua_gettop(L); - - /* Check whether method is already defined in metatable */ - lua_pushvalue(L,key_index); /* copy of the key */ - lua_gettable(L,metatable_index); - if( !lua_isnil(L,-1) ) { - lua_pop(L,1); - return -1; - } - lua_pop(L,1); - - /* Iterating over immediate bases */ - for(i=0;clss->bases[i];i++) - { - const swig_lua_class *base = clss->bases[i]; - SWIG_Lua_get_class_metatable(L, base->fqname); - lua_pushvalue(L, key_index); - lua_rawget(L, -2); - if( !lua_isnil(L,-1) ) { - lua_pushvalue(L, key_index); - - /* Add proxy function */ - lua_pushvalue(L, key_index); /* first closure value is function name */ - lua_pushlightuserdata(L, clss); /* second closure value is swig_lua_class structure */ - lua_pushcclosure(L, SWIG_Lua_resolve_metamethod, 2); - - lua_rawset(L, metatable_index); - success = 1; - } - lua_pop(L,1); /* remove function or nil */ - lua_pop(L,1); /* remove base class metatable */ - - if( success ) - break; - } - - return success; -} - -SWIGINTERN void SWIG_Lua_add_class_user_metamethods(lua_State *L, swig_lua_class *clss) -{ - int metatable_index; - int metamethods_info_index; - int tostring_undefined; - int eq_undefined = 0; - - SWIG_Lua_get_class_metatable(L, clss->fqname); - metatable_index = lua_gettop(L); - SWIG_Lua_get_inheritable_metamethods(L); - assert(lua_istable(L,-1)); - metamethods_info_index = lua_gettop(L); - lua_pushnil(L); /* first key */ - while(lua_next(L, metamethods_info_index) != 0 ) { - /* key at index -2, value at index -1 */ - const int is_inheritable = lua_toboolean(L,-2); - lua_pop(L,1); /* remove value - we don't need it anymore */ - - if(is_inheritable) { /* if metamethod is inheritable */ - SWIG_Lua_add_class_user_metamethod(L,clss,metatable_index); - } - } - - lua_pop(L,1); /* remove inheritable metatmethods table */ - - /* Special handling for __tostring method */ - lua_pushstring(L, "__tostring"); - lua_pushvalue(L,-1); - lua_rawget(L,metatable_index); - tostring_undefined = lua_isnil(L,-1); - lua_pop(L,1); - if( tostring_undefined ) { - lua_pushcfunction(L, SWIG_Lua_class_tostring); - lua_rawset(L, metatable_index); - } else { - lua_pop(L,1); /* remove copy of the key */ - } - - /* Special handling for __eq method */ - lua_pushstring(L, "__eq"); - lua_pushvalue(L,-1); - lua_rawget(L,metatable_index); - eq_undefined = lua_isnil(L,-1); - lua_pop(L,1); - if( eq_undefined ) { - lua_pushcfunction(L, SWIG_Lua_class_equal); - lua_rawset(L, metatable_index); - } else { - lua_pop(L,1); /* remove copy of the key */ - } - /* Warning: __index and __newindex are SWIG-defined. For user-defined operator[] - * a __getitem/__setitem method should be defined - */ - lua_pop(L,1); /* pop class metatable */ -} - -/* Register class static methods,attributes etc as well as constructor proxy */ -SWIGINTERN void SWIG_Lua_class_register_static(lua_State *L, swig_lua_class *clss) -{ - const int SWIGUNUSED begin = lua_gettop(L); - lua_checkstack(L,5); /* just in case */ - assert(lua_istable(L,-1)); /* just in case */ - assert(strcmp(clss->name, clss->cls_static->name) == 0); /* in class those 2 must be equal */ - - SWIG_Lua_namespace_register(L,clss->cls_static, 1); - - assert(lua_istable(L,-1)); /* just in case */ - - /* add its constructor to module with the name of the class - so you can do MyClass(...) as well as new_MyClass(...) - BUT only if a constructor is defined - (this overcomes the problem of pure virtual classes without constructors)*/ - if (clss->constructor) - { - lua_getmetatable(L,-1); - assert(lua_istable(L,-1)); /* just in case */ - SWIG_Lua_add_function(L,"__call", clss->constructor); - lua_pop(L,1); - } - - assert(lua_istable(L,-1)); /* just in case */ - SWIG_Lua_add_class_static_details(L, clss); - - /* clear stack */ - lua_pop(L,1); - assert( lua_gettop(L) == begin ); -} - -/* Performs the instance (non-static) class registration process. Metatable for class is created - * and added to the class registry. - */ -SWIGINTERN void SWIG_Lua_class_register_instance(lua_State *L,swig_lua_class *clss) -{ - const int SWIGUNUSED begin = lua_gettop(L); - int i; - /* if name already there (class is already registered) then do nothing */ - SWIG_Lua_get_class_registry(L); /* get the registry */ - lua_pushstring(L,clss->fqname); /* get the name */ - lua_rawget(L,-2); - if(!lua_isnil(L,-1)) { - lua_pop(L,2); - assert(lua_gettop(L)==begin); - return; - } - lua_pop(L,2); /* tidy stack */ - /* Recursively initialize all bases */ - for(i=0;clss->bases[i];i++) - { - SWIG_Lua_class_register_instance(L,clss->bases[i]); - } - /* Again, get registry and push name */ - SWIG_Lua_get_class_registry(L); /* get the registry */ - lua_pushstring(L,clss->fqname); /* get the name */ - lua_newtable(L); /* create the metatable */ -#if defined(SWIG_LUA_SQUASH_BASES) && (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA) - /* If squashing is requested, then merges all bases metatable into this one. - * It would get us all special methods: __getitem, __add etc. - * This would set .fn, .type, and other .xxx incorrectly, but we will overwrite it right away - */ - { - int new_metatable_index = lua_absindex(L,-1); - for(i=0;clss->bases[i];i++) - { - int base_metatable; - SWIG_Lua_get_class_metatable(L,clss->bases[i]->fqname); - base_metatable = lua_absindex(L,-1); - SWIG_Lua_merge_tables_by_index(L,new_metatable_index, base_metatable); - lua_pop(L,1); - } - } - /* And now we will overwrite all incorrectly set data */ -#endif - /* add string of class name called ".type" */ - lua_pushstring(L,".type"); - lua_pushstring(L,clss->fqname); - lua_rawset(L,-3); - /* add a table called bases */ - lua_pushstring(L,".bases"); - lua_newtable(L); - lua_rawset(L,-3); - /* add a table called ".get" */ - lua_pushstring(L,".get"); - lua_newtable(L); - lua_rawset(L,-3); - /* add a table called ".set" */ - lua_pushstring(L,".set"); - lua_newtable(L); - lua_rawset(L,-3); - /* add a table called ".fn" */ - lua_pushstring(L,".fn"); - lua_newtable(L); - /* add manual disown method */ - SWIG_Lua_add_function(L,"__disown",SWIG_Lua_class_disown); - lua_rawset(L,-3); - /* add accessor fns for using the .get,.set&.fn */ - SWIG_Lua_add_function(L,"__index",SWIG_Lua_class_get); - SWIG_Lua_add_function(L,"__newindex",SWIG_Lua_class_set); - SWIG_Lua_add_function(L,"__gc",SWIG_Lua_class_destruct); - /* add it */ - lua_rawset(L,-3); /* metatable into registry */ - lua_pop(L,1); /* tidy stack (remove registry) */ - assert(lua_gettop(L) == begin); - -#if defined(SWIG_LUA_SQUASH_BASES) && (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA) - /* Now merge all symbols from .fn, .set, .get etc from bases to our tables */ - SWIG_Lua_class_squash_bases(L,clss); -#endif - SWIG_Lua_get_class_metatable(L,clss->fqname); - SWIG_Lua_add_class_instance_details(L,clss); /* recursive adding of details (atts & ops) */ - lua_pop(L,1); /* tidy stack (remove class metatable) */ - assert( lua_gettop(L) == begin ); -} - -SWIGINTERN void SWIG_Lua_class_register(lua_State *L,swig_lua_class *clss) -{ - int SWIGUNUSED begin; - assert(lua_istable(L,-1)); /* This is a table (module or namespace) where classes will be added */ - SWIG_Lua_class_register_instance(L,clss); - SWIG_Lua_class_register_static(L,clss); - - /* Add links from static part to instance part and vice versa */ - /* [SWIG registry] [Module] - * "MyClass" ----> [MyClass metatable] <===== "MyClass" -+> [static part] - * ".get" ----> ... | | getmetatable()----| - * ".set" ----> ... | | | - * ".static" --------------)----------------/ [static part metatable] - * | ".get" --> ... - * | ".set" --> .... - * |=============================== ".instance" - */ - begin = lua_gettop(L); - lua_pushstring(L,clss->cls_static->name); - lua_rawget(L,-2); /* get class static table */ - assert(lua_istable(L,-1)); - lua_getmetatable(L,-1); - assert(lua_istable(L,-1)); /* get class static metatable */ - lua_pushstring(L,".instance"); /* prepare key */ - - SWIG_Lua_get_class_metatable(L,clss->fqname); /* get class metatable */ - assert(lua_istable(L,-1)); - lua_pushstring(L,".static"); /* prepare key */ - lua_pushvalue(L, -4); /* push static class TABLE */ - assert(lua_istable(L,-1)); - lua_rawset(L,-3); /* assign static class table(!NOT metatable) as ".static" member of class metatable */ - lua_rawset(L,-3); /* assign class metatable as ".instance" member of class static METATABLE */ - lua_pop(L,2); - assert(lua_gettop(L) == begin); -} -#endif /* SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA */ - -#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC) -SWIGINTERN void SWIG_Lua_elua_class_register_instance(lua_State *L, swig_lua_class *clss) -{ - const int SWIGUNUSED begin = lua_gettop(L); - int i; - /* if name already there (class is already registered) then do nothing */ - SWIG_Lua_get_class_registry(L); /* get the registry */ - lua_pushstring(L,clss->fqname); /* get the name */ - lua_rawget(L,-2); - if(!lua_isnil(L,-1)) { - lua_pop(L,2); - assert(lua_gettop(L)==begin); - return; - } - lua_pop(L,2); /* tidy stack */ - /* Recursively initialize all bases */ - for(i=0;clss->bases[i];i++) - { - SWIG_Lua_elua_class_register_instance(L,clss->bases[i]); - } - /* Again, get registry and push name */ - SWIG_Lua_get_class_registry(L); /* get the registry */ - lua_pushstring(L,clss->fqname); /* get the name */ - assert(clss->metatable); - lua_pushrotable(L, (void*)(clss->metatable)); /* create the metatable */ - lua_rawset(L,-3); - lua_pop(L,1); - assert(lua_gettop(L) == begin); -} -#endif /* elua && eluac */ - -/* ----------------------------------------------------------------------------- - * Class/structure conversion fns - * ----------------------------------------------------------------------------- */ - -/* helper to add metatable to new lua object */ -SWIGINTERN void SWIG_Lua_AddMetatable(lua_State *L,swig_type_info *type) -{ - if (type->clientdata) /* there is clientdata: so add the metatable */ - { - SWIG_Lua_get_class_metatable(L,((swig_lua_class*)(type->clientdata))->fqname); - if (lua_istable(L,-1)) - { - lua_setmetatable(L,-2); - } - else - { - lua_pop(L,1); - } - } -} - -/* pushes a new object into the lua stack */ -SWIGRUNTIME void SWIG_Lua_NewPointerObj(lua_State *L,void *ptr,swig_type_info *type, int own) -{ - swig_lua_userdata *usr; - if (!ptr){ - lua_pushnil(L); - return; - } - usr=(swig_lua_userdata*)lua_newuserdata(L,sizeof(swig_lua_userdata)); /* get data */ - usr->ptr=ptr; /* set the ptr */ - usr->type=type; - usr->own=own; -#if (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC) - SWIG_Lua_AddMetatable(L,type); /* add metatable */ -#endif -} - -/* takes a object from the lua stack & converts it into an object of the correct type - (if possible) */ -SWIGRUNTIME int SWIG_Lua_ConvertPtr(lua_State *L,int index,void **ptr,swig_type_info *type,int flags) -{ - swig_lua_userdata *usr; - swig_cast_info *cast; - if (lua_isnil(L,index)){*ptr=0; return SWIG_OK;} /* special case: lua nil => NULL pointer */ - usr=(swig_lua_userdata*)lua_touserdata(L,index); /* get data */ - if (usr) - { - if (flags & SWIG_POINTER_DISOWN) /* must disown the object */ - { - usr->own=0; - } - if (!type) /* special cast void*, no casting fn */ - { - *ptr=usr->ptr; - return SWIG_OK; /* ok */ - } - cast=SWIG_TypeCheckStruct(usr->type,type); /* performs normal type checking */ - if (cast) - { - int newmemory = 0; - *ptr=SWIG_TypeCast(cast,usr->ptr,&newmemory); - assert(!newmemory); /* newmemory handling not yet implemented */ - return SWIG_OK; /* ok */ - } - } - return SWIG_ERROR; /* error */ -} - -SWIGRUNTIME void* SWIG_Lua_MustGetPtr(lua_State *L,int index,swig_type_info *type,int flags, - int argnum,const char *func_name){ - void *result; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,index,&result,type,flags))){ - luaL_error (L,"Error in %s, expected a %s at argument number %d\n", - func_name,(type && type->str)?type->str:"void*",argnum); - } - return result; -} - -/* pushes a packed userdata. user for member fn pointers only */ -SWIGRUNTIME void SWIG_Lua_NewPackedObj(lua_State *L,void *ptr,size_t size,swig_type_info *type) -{ - swig_lua_rawdata *raw; - assert(ptr); /* not acceptable to pass in a NULL value */ - raw=(swig_lua_rawdata*)lua_newuserdata(L,sizeof(swig_lua_rawdata)-1+size); /* alloc data */ - raw->type=type; - raw->own=0; - memcpy(raw->data,ptr,size); /* copy the data */ - SWIG_Lua_AddMetatable(L,type); /* add metatable */ -} - -/* converts a packed userdata. user for member fn pointers only */ -SWIGRUNTIME int SWIG_Lua_ConvertPacked(lua_State *L,int index,void *ptr,size_t size,swig_type_info *type) -{ - swig_lua_rawdata *raw; - raw=(swig_lua_rawdata*)lua_touserdata(L,index); /* get data */ - if (!raw) return SWIG_ERROR; /* error */ - if (type==0 || type==raw->type) /* void* or identical type */ - { - memcpy(ptr,raw->data,size); /* copy it */ - return SWIG_OK; /* ok */ - } - return SWIG_ERROR; /* error */ -} - -/* a function to get the typestring of a piece of data */ -SWIGRUNTIME const char *SWIG_Lua_typename(lua_State *L, int tp) -{ - swig_lua_userdata *usr; - if (lua_isuserdata(L,tp)) - { - usr=(swig_lua_userdata*)lua_touserdata(L,tp); /* get data */ - if (usr && usr->type && usr->type->str) - return usr->type->str; - return "userdata (unknown type)"; - } - return lua_typename(L,lua_type(L,tp)); -} - -/* lua callable function to get the userdata's type */ -SWIGRUNTIME int SWIG_Lua_type(lua_State *L) -{ - lua_pushstring(L,SWIG_Lua_typename(L,1)); - return 1; -} - -/* ----------------------------------------------------------------------------- - * global variable support code: class/struct typemap functions - * ----------------------------------------------------------------------------- */ - -#if ((SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUA) && (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC)) -/* Install Constants */ -SWIGINTERN void -SWIG_Lua_InstallConstants(lua_State *L, swig_lua_const_info constants[]) { - int i; - for (i = 0; constants[i].type; i++) { - switch(constants[i].type) { - case SWIG_LUA_INT: - lua_pushstring(L,constants[i].name); - lua_pushinteger(L,(lua_Number)constants[i].lvalue); - lua_rawset(L,-3); - break; - case SWIG_LUA_FLOAT: - lua_pushstring(L,constants[i].name); - lua_pushnumber(L,(lua_Number)constants[i].dvalue); - lua_rawset(L,-3); - break; - case SWIG_LUA_CHAR: - lua_pushstring(L,constants[i].name); - { - char c = constants[i].lvalue; - lua_pushlstring(L,&c,1); - } - lua_rawset(L,-3); - break; - case SWIG_LUA_STRING: - lua_pushstring(L,constants[i].name); - lua_pushstring(L,(char *) constants[i].pvalue); - lua_rawset(L,-3); - break; - case SWIG_LUA_POINTER: - lua_pushstring(L,constants[i].name); - SWIG_NewPointerObj(L,constants[i].pvalue, *(constants[i]).ptype,0); - lua_rawset(L,-3); - break; - case SWIG_LUA_BINARY: - lua_pushstring(L,constants[i].name); - SWIG_NewMemberObj(L,constants[i].pvalue,constants[i].lvalue,*(constants[i]).ptype); - lua_rawset(L,-3); - break; - default: - break; - } - } -} -#endif - -/* ----------------------------------------------------------------------------- - * executing lua code from within the wrapper - * ----------------------------------------------------------------------------- */ - -#ifndef SWIG_DOSTRING_FAIL /* Allows redefining of error function */ -#define SWIG_DOSTRING_FAIL(S) fprintf(stderr,"%s\n",S) -#endif -/* Executes a C string in Lua which is a really simple way of calling lua from C -Unfortunately lua keeps changing its APIs, so we need a conditional compile -In lua 5.0.X it's lua_dostring() -In lua 5.1.X it's luaL_dostring() -*/ -SWIGINTERN int -SWIG_Lua_dostring(lua_State *L, const char *str) { - int ok,top; - if (str==0 || str[0]==0) return 0; /* nothing to do */ - top=lua_gettop(L); /* save stack */ -#if (defined(LUA_VERSION_NUM) && (LUA_VERSION_NUM>=501)) - ok=luaL_dostring(L,str); /* looks like this is lua 5.1.X or later, good */ -#else - ok=lua_dostring(L,str); /* might be lua 5.0.x, using lua_dostring */ -#endif - if (ok!=0) { - SWIG_DOSTRING_FAIL(lua_tostring(L,-1)); - } - lua_settop(L,top); /* restore the stack */ - return ok; -} - -#ifdef __cplusplus -} -#endif - -/* ------------------------------ end luarun.swg ------------------------------ */ - -/* Errors in SWIG */ -#define SWIG_UnknownError -1 -#define SWIG_IOError -2 -#define SWIG_RuntimeError -3 -#define SWIG_IndexError -4 -#define SWIG_TypeError -5 -#define SWIG_DivisionByZero -6 -#define SWIG_OverflowError -7 -#define SWIG_SyntaxError -8 -#define SWIG_ValueError -9 -#define SWIG_SystemError -10 -#define SWIG_AttributeError -11 -#define SWIG_MemoryError -12 -#define SWIG_NullReferenceError -13 - - - - -/* -------- TYPES TABLE (BEGIN) -------- */ - -#define SWIGTYPE_p_GLintptr swig_types[0] -#define SWIGTYPE_p_GLsizei swig_types[1] -#define SWIGTYPE_p_GLsizeiptr swig_types[2] -#define SWIGTYPE_p_double swig_types[3] -#define SWIGTYPE_p_float swig_types[4] -#define SWIGTYPE_p_fstream swig_types[5] -#define SWIGTYPE_p_int swig_types[6] -#define SWIGTYPE_p_long_long swig_types[7] -#define SWIGTYPE_p_of3dPrimitive swig_types[8] -#define SWIGTYPE_p_ofAbstractImage swig_types[9] -#define SWIGTYPE_p_ofAbstractParameter swig_types[10] -#define SWIGTYPE_p_ofAppBaseWindow swig_types[11] -#define SWIGTYPE_p_ofBaseApp swig_types[12] -#define SWIGTYPE_p_ofBaseDraws swig_types[13] -#define SWIGTYPE_p_ofBaseFileSerializer swig_types[14] -#define SWIGTYPE_p_ofBaseGLRenderer swig_types[15] -#define SWIGTYPE_p_ofBaseHasPixels swig_types[16] -#define SWIGTYPE_p_ofBaseHasTexture swig_types[17] -#define SWIGTYPE_p_ofBaseHasTexturePlanes swig_types[18] -#define SWIGTYPE_p_ofBaseImage_T_float_t swig_types[19] -#define SWIGTYPE_p_ofBaseImage_T_unsigned_char_t swig_types[20] -#define SWIGTYPE_p_ofBaseImage_T_unsigned_short_t swig_types[21] -#define SWIGTYPE_p_ofBaseLoggerChannel swig_types[22] -#define SWIGTYPE_p_ofBaseMaterial swig_types[23] -#define SWIGTYPE_p_ofBaseRenderer swig_types[24] -#define SWIGTYPE_p_ofBaseSerializer swig_types[25] -#define SWIGTYPE_p_ofBaseSoundInput swig_types[26] -#define SWIGTYPE_p_ofBaseSoundOutput swig_types[27] -#define SWIGTYPE_p_ofBaseSoundPlayer swig_types[28] -#define SWIGTYPE_p_ofBaseUpdates swig_types[29] -#define SWIGTYPE_p_ofBaseVideo swig_types[30] -#define SWIGTYPE_p_ofBaseVideoDraws swig_types[31] -#define SWIGTYPE_p_ofBaseVideoGrabber swig_types[32] -#define SWIGTYPE_p_ofBaseVideoPlayer swig_types[33] -#define SWIGTYPE_p_ofBoxPrimitive swig_types[34] -#define SWIGTYPE_p_ofBuffer swig_types[35] -#define SWIGTYPE_p_ofBufferObject swig_types[36] -#define SWIGTYPE_p_ofCamera swig_types[37] -#define SWIGTYPE_p_ofColor_T_float_t swig_types[38] -#define SWIGTYPE_p_ofColor_T_unsigned_char_t swig_types[39] -#define SWIGTYPE_p_ofColor_T_unsigned_short_t swig_types[40] -#define SWIGTYPE_p_ofConePrimitive swig_types[41] -#define SWIGTYPE_p_ofConsoleLoggerChannel swig_types[42] -#define SWIGTYPE_p_ofCoreEvents swig_types[43] -#define SWIGTYPE_p_ofCylinderPrimitive swig_types[44] -#define SWIGTYPE_p_ofDirectory swig_types[45] -#define SWIGTYPE_p_ofDragInfo swig_types[46] -#define SWIGTYPE_p_ofEasyCam swig_types[47] -#define SWIGTYPE_p_ofEventArgs swig_types[48] -#define SWIGTYPE_p_ofEventT_ofHttpResponse_t swig_types[49] -#define SWIGTYPE_p_ofFbo swig_types[50] -#define SWIGTYPE_p_ofFbo__Settings swig_types[51] -#define SWIGTYPE_p_ofFile swig_types[52] -#define SWIGTYPE_p_ofFileDialogResult swig_types[53] -#define SWIGTYPE_p_ofFileLoggerChannel swig_types[54] -#define SWIGTYPE_p_ofFilePath swig_types[55] -#define SWIGTYPE_p_ofFpsCounter swig_types[56] -#define SWIGTYPE_p_ofHttpRequest swig_types[57] -#define SWIGTYPE_p_ofHttpResponse swig_types[58] -#define SWIGTYPE_p_ofIcoSpherePrimitive swig_types[59] -#define SWIGTYPE_p_ofImage_T_float_t swig_types[60] -#define SWIGTYPE_p_ofImage_T_unsigned_char_t swig_types[61] -#define SWIGTYPE_p_ofImage_T_unsigned_short_t swig_types[62] -#define SWIGTYPE_p_ofKeyEventArgs swig_types[63] -#define SWIGTYPE_p_ofLight swig_types[64] -#define SWIGTYPE_p_ofLog swig_types[65] -#define SWIGTYPE_p_ofLogError swig_types[66] -#define SWIGTYPE_p_ofLogFatalError swig_types[67] -#define SWIGTYPE_p_ofLogNotice swig_types[68] -#define SWIGTYPE_p_ofLogVerbose swig_types[69] -#define SWIGTYPE_p_ofLogWarning swig_types[70] -#define SWIGTYPE_p_ofMaterial swig_types[71] -#define SWIGTYPE_p_ofMatrix3x3 swig_types[72] -#define SWIGTYPE_p_ofMatrix4x4 swig_types[73] -#define SWIGTYPE_p_ofMatrixStack swig_types[74] -#define SWIGTYPE_p_ofMesh swig_types[75] -#define SWIGTYPE_p_ofMeshFace swig_types[76] -#define SWIGTYPE_p_ofMessage swig_types[77] -#define SWIGTYPE_p_ofMouseEventArgs swig_types[78] -#define SWIGTYPE_p_ofNode swig_types[79] -#define SWIGTYPE_p_ofParameterGroup swig_types[80] -#define SWIGTYPE_p_ofPath swig_types[81] -#define SWIGTYPE_p_ofPixels_T_float_t swig_types[82] -#define SWIGTYPE_p_ofPixels_T_unsigned_char_t swig_types[83] -#define SWIGTYPE_p_ofPixels_T_unsigned_short_t swig_types[84] -#define SWIGTYPE_p_ofPlanePrimitive swig_types[85] -#define SWIGTYPE_p_ofPolyline swig_types[86] -#define SWIGTYPE_p_ofQuaternion swig_types[87] -#define SWIGTYPE_p_ofRectangle swig_types[88] -#define SWIGTYPE_p_ofResizeEventArgs swig_types[89] -#define SWIGTYPE_p_ofSerialDeviceInfo swig_types[90] -#define SWIGTYPE_p_ofShader swig_types[91] -#define SWIGTYPE_p_ofSoundDevice swig_types[92] -#define SWIGTYPE_p_ofSoundPlayer swig_types[93] -#define SWIGTYPE_p_ofSoundStream swig_types[94] -#define SWIGTYPE_p_ofSpherePrimitive swig_types[95] -#define SWIGTYPE_p_ofStyle swig_types[96] -#define SWIGTYPE_p_ofTexture swig_types[97] -#define SWIGTYPE_p_ofTextureData swig_types[98] -#define SWIGTYPE_p_ofTouchEventArgs swig_types[99] -#define SWIGTYPE_p_ofTrueTypeFont swig_types[100] -#define SWIGTYPE_p_ofURLFileLoader swig_types[101] -#define SWIGTYPE_p_ofVbo swig_types[102] -#define SWIGTYPE_p_ofVboMesh swig_types[103] -#define SWIGTYPE_p_ofVec2f swig_types[104] -#define SWIGTYPE_p_ofVec3f swig_types[105] -#define SWIGTYPE_p_ofVec4f swig_types[106] -#define SWIGTYPE_p_ofVideoDevice swig_types[107] -#define SWIGTYPE_p_ofVideoGrabber swig_types[108] -#define SWIGTYPE_p_ofVideoPlayer swig_types[109] -#define SWIGTYPE_p_ofXml swig_types[110] -#define SWIGTYPE_p_shared_ptrT_ofBaseRenderer_t swig_types[111] -#define SWIGTYPE_p_shared_ptrT_ofBaseSoundPlayer_t swig_types[112] -#define SWIGTYPE_p_shared_ptrT_ofBaseSoundStream_t swig_types[113] -#define SWIGTYPE_p_shared_ptrT_ofBaseVideoGrabber_t swig_types[114] -#define SWIGTYPE_p_std__filesystem__path swig_types[115] -#define SWIGTYPE_p_std__mapT_std__string_std__string_t swig_types[116] -#define SWIGTYPE_p_std__string swig_types[117] -#define SWIGTYPE_p_std__vectorT_float_t swig_types[118] -#define SWIGTYPE_p_std__vectorT_int_t swig_types[119] -#define SWIGTYPE_p_std__vectorT_ofColor_T_float_t_t swig_types[120] -#define SWIGTYPE_p_std__vectorT_ofFile_t swig_types[121] -#define SWIGTYPE_p_std__vectorT_ofMeshFace_t swig_types[122] -#define SWIGTYPE_p_std__vectorT_ofPath__Command_t swig_types[123] -#define SWIGTYPE_p_std__vectorT_ofPath_t swig_types[124] -#define SWIGTYPE_p_std__vectorT_ofPolyline_t swig_types[125] -#define SWIGTYPE_p_std__vectorT_ofSoundDevice_t swig_types[126] -#define SWIGTYPE_p_std__vectorT_ofTexture_t swig_types[127] -#define SWIGTYPE_p_std__vectorT_ofVec2f_t swig_types[128] -#define SWIGTYPE_p_std__vectorT_ofVec3f_t swig_types[129] -#define SWIGTYPE_p_std__vectorT_ofVideoDevice_t swig_types[130] -#define SWIGTYPE_p_std__vectorT_std__string_t swig_types[131] -#define SWIGTYPE_p_std__vectorT_unsigned_char_t swig_types[132] -#define SWIGTYPE_p_std__vectorT_unsigned_short_t swig_types[133] -#define SWIGTYPE_p_std__vectorT_weak_ptrT_ofLight__Data_t_t swig_types[134] -#define SWIGTYPE_p_unsigned_char swig_types[135] -#define SWIGTYPE_p_unsigned_int swig_types[136] -#define SWIGTYPE_p_unsigned_long_long swig_types[137] -#define SWIGTYPE_p_unsigned_short swig_types[138] -static swig_type_info *swig_types[140]; -static swig_module_info swig_module = {swig_types, 139, 0, 0, 0, 0}; -#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) -#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) - -/* -------- TYPES TABLE (END) -------- */ - -#define SWIG_name "of" -#define SWIG_init luaopen_of -#define SWIG_init_user luaopen_of_user - -#define SWIG_LUACODE luaopen_of_luacode - -namespace swig { -typedef struct{} LANGUAGE_OBJ; -} - - - #include "ofMain.h" - #undef check - - -#include - - -#ifdef __cplusplus /* generic alloc/dealloc fns*/ -#define SWIG_ALLOC_ARRAY(TYPE,LEN) new TYPE[LEN] -#define SWIG_FREE_ARRAY(PTR) delete[] PTR -#else -#define SWIG_ALLOC_ARRAY(TYPE,LEN) (TYPE *)malloc(LEN*sizeof(TYPE)) -#define SWIG_FREE_ARRAY(PTR) free(PTR) -#endif -/* counting the size of arrays:*/ -SWIGINTERN int SWIG_itable_size(lua_State* L, int index) -{ - int n=0; - while(1){ - lua_rawgeti(L,index,n+1); - if (lua_isnil(L,-1))break; - ++n; - lua_pop(L,1); - } - lua_pop(L,1); - return n; -} - -SWIGINTERN int SWIG_table_size(lua_State* L, int index) -{ - int n=0; - lua_pushnil(L); /* first key*/ - while (lua_next(L, index) != 0) { - ++n; - lua_pop(L, 1); /* removes `value'; keeps `key' for next iteration*/ - } - return n; -} - -/* super macro to declare array typemap helper fns */ -#define SWIG_DECLARE_TYPEMAP_ARR_FN(NAME,TYPE)\ - SWIGINTERN int SWIG_read_##NAME##_num_array(lua_State* L,int index,TYPE *array,int size){\ - int i;\ - for (i = 0; i < size; i++) {\ - lua_rawgeti(L,index,i+1);\ - if (lua_isnumber(L,-1)){\ - array[i] = (TYPE)lua_tonumber(L,-1);\ - } else {\ - lua_pop(L,1);\ - return 0;\ - }\ - lua_pop(L,1);\ - }\ - return 1;\ - }\ - SWIGINTERN TYPE* SWIG_get_##NAME##_num_array_fixed(lua_State* L, int index, int size){\ - TYPE *array;\ - if (!lua_istable(L,index) || SWIG_itable_size(L,index) != size) {\ - SWIG_Lua_pushferrstring(L,"expected a table of size %d",size);\ - return 0;\ - }\ - array=SWIG_ALLOC_ARRAY(TYPE,size);\ - if (!SWIG_read_##NAME##_num_array(L,index,array,size)){\ - SWIG_Lua_pusherrstring(L,"table must contain numbers");\ - SWIG_FREE_ARRAY(array);\ - return 0;\ - }\ - return array;\ - }\ - SWIGINTERN TYPE* SWIG_get_##NAME##_num_array_var(lua_State* L, int index, int* size)\ - {\ - TYPE *array;\ - if (!lua_istable(L,index)) {\ - SWIG_Lua_pusherrstring(L,"expected a table");\ - return 0;\ - }\ - *size=SWIG_itable_size(L,index);\ - if (*size<1){\ - SWIG_Lua_pusherrstring(L,"table appears to be empty");\ - return 0;\ - }\ - array=SWIG_ALLOC_ARRAY(TYPE,*size);\ - if (!SWIG_read_##NAME##_num_array(L,index,array,*size)){\ - SWIG_Lua_pusherrstring(L,"table must contain numbers");\ - SWIG_FREE_ARRAY(array);\ - return 0;\ - }\ - return array;\ - }\ - SWIGINTERN void SWIG_write_##NAME##_num_array(lua_State* L,TYPE *array,int size){\ - int i;\ - lua_newtable(L);\ - for (i = 0; i < size; i++){\ - lua_pushnumber(L,(lua_Number)array[i]);\ - lua_rawseti(L,-2,i+1);/* -1 is the number, -2 is the table*/ \ - }\ - } - -SWIG_DECLARE_TYPEMAP_ARR_FN(schar,signed char) -SWIG_DECLARE_TYPEMAP_ARR_FN(uchar,unsigned char) -SWIG_DECLARE_TYPEMAP_ARR_FN(int,int) -SWIG_DECLARE_TYPEMAP_ARR_FN(uint,unsigned int) -SWIG_DECLARE_TYPEMAP_ARR_FN(short,short) -SWIG_DECLARE_TYPEMAP_ARR_FN(ushort,unsigned short) -SWIG_DECLARE_TYPEMAP_ARR_FN(long,long) -SWIG_DECLARE_TYPEMAP_ARR_FN(ulong,unsigned long) -SWIG_DECLARE_TYPEMAP_ARR_FN(float,float) -SWIG_DECLARE_TYPEMAP_ARR_FN(double,double) - -SWIGINTERN int SWIG_read_ptr_array(lua_State* L,int index,void **array,int size,swig_type_info *type){ - int i; - for (i = 0; i < size; i++) { - lua_rawgeti(L,index,i+1); - if (!lua_isuserdata(L,-1) || SWIG_ConvertPtr(L,-1,&array[i],type,0)==-1){ - lua_pop(L,1); - return 0; - } - lua_pop(L,1); - } - return 1; -} -SWIGINTERN void** SWIG_get_ptr_array_fixed(lua_State* L, int index, int size,swig_type_info *type){ - void **array; - if (!lua_istable(L,index) || SWIG_itable_size(L,index) != size) { - SWIG_Lua_pushferrstring(L,"expected a table of size %d",size); - return 0; - } - array=SWIG_ALLOC_ARRAY(void*,size); - if (!SWIG_read_ptr_array(L,index,array,size,type)){ - SWIG_Lua_pushferrstring(L,"table must contain pointers of type %s",type->name); - SWIG_FREE_ARRAY(array); - return 0; - } - return array; -} -SWIGINTERN void** SWIG_get_ptr_array_var(lua_State* L, int index, int* size,swig_type_info *type){ - void **array; - if (!lua_istable(L,index)) { - SWIG_Lua_pusherrstring(L,"expected a table"); - return 0; - } - *size=SWIG_itable_size(L,index); - if (*size<1){ - SWIG_Lua_pusherrstring(L,"table appears to be empty"); - return 0; - } - array=SWIG_ALLOC_ARRAY(void*,*size); - if (!SWIG_read_ptr_array(L,index,array,*size,type)){ - SWIG_Lua_pushferrstring(L,"table must contain pointers of type %s",type->name); - SWIG_FREE_ARRAY(array); - return 0; - } - return array; -} -SWIGINTERN void SWIG_write_ptr_array(lua_State* L,void **array,int size,swig_type_info *type,int own){ - int i; - lua_newtable(L); - for (i = 0; i < size; i++){ - SWIG_NewPointerObj(L,array[i],type,own); - lua_rawseti(L,-2,i+1);/* -1 is the number, -2 is the table*/ - } -} - - -#include -#include - - -#define SWIG_exception(a,b)\ -{ lua_pushfstring(L,"%s:%s",#a,b);SWIG_fail; } - - -#include -#include - - -#include - - -SWIGINTERN int SWIG_lua_isnilstring(lua_State *L, int idx) { - int ret = lua_isstring(L, idx); - if (!ret) - ret = lua_isnil(L, idx); - return ret; -} - - -#include - - -#include -#include -#include - - -#include - - -#include - -SWIGINTERN int std_vector_Sl_int_Sg____getitem__(std::vector< int > *self,unsigned int idx){ - if (idx>=self->size()) - throw std::out_of_range("in vector::__getitem__()"); - return (*self)[idx]; - } -SWIGINTERN void std_vector_Sl_int_Sg____setitem__(std::vector< int > *self,unsigned int idx,int val){ - if (idx>=self->size()) - throw std::out_of_range("in vector::__setitem__()"); - (*self)[idx]=val; - } -SWIGINTERN float std_vector_Sl_float_Sg____getitem__(std::vector< float > *self,unsigned int idx){ - if (idx>=self->size()) - throw std::out_of_range("in vector::__getitem__()"); - return (*self)[idx]; - } -SWIGINTERN void std_vector_Sl_float_Sg____setitem__(std::vector< float > *self,unsigned int idx,float val){ - if (idx>=self->size()) - throw std::out_of_range("in vector::__setitem__()"); - (*self)[idx]=val; - } -SWIGINTERN std::string std_vector_Sl_std_string_Sg____getitem__(std::vector< std::string > *self,unsigned int idx){ - if (idx>=self->size()) - throw std::out_of_range("in vector::__getitem__()"); - return (*self)[idx]; - } -SWIGINTERN void std_vector_Sl_std_string_Sg____setitem__(std::vector< std::string > *self,unsigned int idx,std::string val){ - if (idx>=self->size()) - throw std::out_of_range("in vector::__setitem__()"); - (*self)[idx]=val; - } -SWIGINTERN unsigned char std_vector_Sl_unsigned_SS_char_Sg____getitem__(std::vector< unsigned char > *self,unsigned int idx){ - if (idx>=self->size()) - throw std::out_of_range("in vector::__getitem__()"); - return (*self)[idx]; - } -SWIGINTERN void std_vector_Sl_unsigned_SS_char_Sg____setitem__(std::vector< unsigned char > *self,unsigned int idx,unsigned char val){ - if (idx>=self->size()) - throw std::out_of_range("in vector::__setitem__()"); - (*self)[idx]=val; - } -SWIGINTERN ofVideoDevice std_vector_Sl_ofVideoDevice_Sg____getitem__(std::vector< ofVideoDevice > *self,unsigned int idx){ - if (idx>=self->size()) - throw std::out_of_range("in vector::__getitem__()"); - return (*self)[idx]; - } -SWIGINTERN void std_vector_Sl_ofVideoDevice_Sg____setitem__(std::vector< ofVideoDevice > *self,unsigned int idx,ofVideoDevice val){ - if (idx>=self->size()) - throw std::out_of_range("in vector::__setitem__()"); - (*self)[idx]=val; - } -SWIGINTERN ofTexture std_vector_Sl_ofTexture_Sg____getitem__(std::vector< ofTexture > *self,unsigned int idx){ - if (idx>=self->size()) - throw std::out_of_range("in vector::__getitem__()"); - return (*self)[idx]; - } -SWIGINTERN void std_vector_Sl_ofTexture_Sg____setitem__(std::vector< ofTexture > *self,unsigned int idx,ofTexture val){ - if (idx>=self->size()) - throw std::out_of_range("in vector::__setitem__()"); - (*self)[idx]=val; - } -SWIGINTERN void delete_ofMesh(ofMesh *self){ - self->clear(); - delete self; - } -SWIGINTERN char const *ofMatrix3x3___str__(ofMatrix3x3 *self){ - stringstream str; - str << (*self); - return str.str().c_str(); - } -SWIGINTERN char const *ofMatrix4x4___str__(ofMatrix4x4 *self){ - stringstream str; - str << (*self); - return str.str().c_str(); - } -SWIGINTERN char const *ofQuaternion___str__(ofQuaternion *self){ - stringstream str; - str << (*self); - return str.str().c_str(); - } -SWIGINTERN char const *ofVec2f___str__(ofVec2f *self){ - stringstream str; - str << (*self); - return str.str().c_str(); - } -SWIGINTERN char const *ofVec3f___str__(ofVec3f *self){ - stringstream str; - str << (*self); - return str.str().c_str(); - } -SWIGINTERN char const *ofVec4f___str__(ofVec4f *self){ - stringstream str; - str << (*self); - return str.str().c_str(); - } -SWIGINTERN void delete_ofShader(ofShader *self){ - self->end(); - delete self; - } - -#define ofColor__Sl_unsigned_SS_char_Sg__r_get(self_) self_->r -#define ofColor__Sl_unsigned_SS_char_Sg__r_set(self_, val_) self_->r = val_ - - -#define ofColor__Sl_unsigned_SS_char_Sg__g_get(self_) self_->g -#define ofColor__Sl_unsigned_SS_char_Sg__g_set(self_, val_) self_->g = val_ - - -#define ofColor__Sl_unsigned_SS_char_Sg__b_get(self_) self_->b -#define ofColor__Sl_unsigned_SS_char_Sg__b_set(self_, val_) self_->b = val_ - - -#define ofColor__Sl_unsigned_SS_char_Sg__a_get(self_) self_->a -#define ofColor__Sl_unsigned_SS_char_Sg__a_set(self_, val_) self_->a = val_ - - -#define ofColor__Sl_float_Sg__r_get(self_) self_->r -#define ofColor__Sl_float_Sg__r_set(self_, val_) self_->r = val_ - - -#define ofColor__Sl_float_Sg__g_get(self_) self_->g -#define ofColor__Sl_float_Sg__g_set(self_, val_) self_->g = val_ - - -#define ofColor__Sl_float_Sg__b_get(self_) self_->b -#define ofColor__Sl_float_Sg__b_set(self_, val_) self_->b = val_ - - -#define ofColor__Sl_float_Sg__a_get(self_) self_->a -#define ofColor__Sl_float_Sg__a_set(self_, val_) self_->a = val_ - - -#define ofColor__Sl_unsigned_SS_short_Sg__r_get(self_) self_->r -#define ofColor__Sl_unsigned_SS_short_Sg__r_set(self_, val_) self_->r = val_ - - -#define ofColor__Sl_unsigned_SS_short_Sg__g_get(self_) self_->g -#define ofColor__Sl_unsigned_SS_short_Sg__g_set(self_, val_) self_->g = val_ - - -#define ofColor__Sl_unsigned_SS_short_Sg__b_get(self_) self_->b -#define ofColor__Sl_unsigned_SS_short_Sg__b_set(self_, val_) self_->b = val_ - - -#define ofColor__Sl_unsigned_SS_short_Sg__a_get(self_) self_->a -#define ofColor__Sl_unsigned_SS_short_Sg__a_set(self_, val_) self_->a = val_ - -SWIGINTERN unsigned char ofColor__Sl_unsigned_SS_char_Sg__getR(ofColor_< unsigned char > *self){return self->r;} -SWIGINTERN unsigned char ofColor__Sl_unsigned_SS_char_Sg__getG(ofColor_< unsigned char > *self){return self->g;} -SWIGINTERN unsigned char ofColor__Sl_unsigned_SS_char_Sg__getB(ofColor_< unsigned char > *self){return self->b;} -SWIGINTERN unsigned char ofColor__Sl_unsigned_SS_char_Sg__getA(ofColor_< unsigned char > *self){return self->a;} -SWIGINTERN void ofColor__Sl_unsigned_SS_char_Sg__setR(ofColor_< unsigned char > *self,unsigned char r){self->r = r;} -SWIGINTERN void ofColor__Sl_unsigned_SS_char_Sg__setG(ofColor_< unsigned char > *self,unsigned char g){self->g = g;} -SWIGINTERN void ofColor__Sl_unsigned_SS_char_Sg__setB(ofColor_< unsigned char > *self,unsigned char b){self->b = b;} -SWIGINTERN void ofColor__Sl_unsigned_SS_char_Sg__setA(ofColor_< unsigned char > *self,unsigned char a){self->a = a;} -SWIGINTERN char const *ofColor__Sl_unsigned_SS_char_Sg____str__(ofColor_< unsigned char > *self){ - stringstream str; - str << (*self); - return str.str().c_str(); - } -SWIGINTERN float ofColor__Sl_float_Sg__getR(ofColor_< float > *self){return self->r;} -SWIGINTERN float ofColor__Sl_float_Sg__getG(ofColor_< float > *self){return self->g;} -SWIGINTERN float ofColor__Sl_float_Sg__getB(ofColor_< float > *self){return self->b;} -SWIGINTERN float ofColor__Sl_float_Sg__getA(ofColor_< float > *self){return self->a;} -SWIGINTERN void ofColor__Sl_float_Sg__setR(ofColor_< float > *self,float r){self->r = r;} -SWIGINTERN void ofColor__Sl_float_Sg__setG(ofColor_< float > *self,float g){self->g = g;} -SWIGINTERN void ofColor__Sl_float_Sg__setB(ofColor_< float > *self,float b){self->b = b;} -SWIGINTERN void ofColor__Sl_float_Sg__setA(ofColor_< float > *self,float a){self->a = a;} -SWIGINTERN char const *ofColor__Sl_float_Sg____str__(ofColor_< float > *self){ - stringstream str; - str << (*self); - return str.str().c_str(); - } -SWIGINTERN unsigned short ofColor__Sl_unsigned_SS_short_Sg__getR(ofColor_< unsigned short > *self){return self->r;} -SWIGINTERN unsigned short ofColor__Sl_unsigned_SS_short_Sg__getG(ofColor_< unsigned short > *self){return self->g;} -SWIGINTERN unsigned short ofColor__Sl_unsigned_SS_short_Sg__getB(ofColor_< unsigned short > *self){return self->b;} -SWIGINTERN unsigned short ofColor__Sl_unsigned_SS_short_Sg__getA(ofColor_< unsigned short > *self){return self->a;} -SWIGINTERN void ofColor__Sl_unsigned_SS_short_Sg__setR(ofColor_< unsigned short > *self,unsigned short r){self->r = r;} -SWIGINTERN void ofColor__Sl_unsigned_SS_short_Sg__setG(ofColor_< unsigned short > *self,unsigned short g){self->g = g;} -SWIGINTERN void ofColor__Sl_unsigned_SS_short_Sg__setB(ofColor_< unsigned short > *self,unsigned short b){self->b = b;} -SWIGINTERN void ofColor__Sl_unsigned_SS_short_Sg__setA(ofColor_< unsigned short > *self,unsigned short a){self->a = a;} -SWIGINTERN char const *ofColor__Sl_unsigned_SS_short_Sg____str__(ofColor_< unsigned short > *self){ - stringstream str; - str << (*self); - return str.str().c_str(); - } -SWIGINTERN char const *ofRectangle___str__(ofRectangle *self){ - stringstream str; - str << (*self); - return str.str().c_str(); - } - -#define ofRectangle_x_get(self_) self_->getX() -#define ofRectangle_x_set(self_, val_) self_->setX(val_) - - -#define ofRectangle_y_get(self_) self_->getY() -#define ofRectangle_y_set(self_, val_) self_->setY(val_) - - - void log(ofLogLevel level, const string & message) { - ofLog(level, message); - } - -#ifdef __cplusplus -extern "C" { -#endif -static int _wrap_new_string__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *result = 0 ; - SWIG_check_num_args("std::string::string",0,0) result = (std::string *)new std::string(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__string,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_string__SWIG_1(lua_State* L) { int SWIG_arg = 0; char *arg1 = (char *) 0 ; std::string *result = 0 ; - SWIG_check_num_args("std::string::string",1,1) - if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("std::string::string",1,"char const *"); arg1 = (char *)lua_tostring(L, 1); - result = (std::string *)new std::string((char const *)arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__string,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_string(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_string__SWIG_0(L);} if (argc == 1) { int _v; { _v = SWIG_lua_isnilstring(L,argv[0]); } if (_v) { - return _wrap_new_string__SWIG_1(L);} } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_string'\n" - " Possible C/C++ prototypes are:\n" " std::string::string()\n" " std::string::string(char const *)\n"); - lua_error(L);return 0; } -static int _wrap_string_size(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = (std::string *) 0 ; unsigned int result; - SWIG_check_num_args("std::string::size",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::string::size",1,"std::string const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__string,0))){ - SWIG_fail_ptr("string_size",1,SWIGTYPE_p_std__string); } result = (unsigned int)((std::string const *)arg1)->size(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_string_length(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = (std::string *) 0 ; unsigned int result; - SWIG_check_num_args("std::string::length",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::string::length",1,"std::string const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__string,0))){ - SWIG_fail_ptr("string_length",1,SWIGTYPE_p_std__string); } result = (unsigned int)((std::string const *)arg1)->length(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_string_empty(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = (std::string *) 0 ; bool result; - SWIG_check_num_args("std::string::empty",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::string::empty",1,"std::string const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__string,0))){ - SWIG_fail_ptr("string_empty",1,SWIGTYPE_p_std__string); } result = (bool)((std::string const *)arg1)->empty(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_string_c_str(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = (std::string *) 0 ; char *result = 0 ; - SWIG_check_num_args("std::string::c_str",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::string::c_str",1,"std::string const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__string,0))){ - SWIG_fail_ptr("string_c_str",1,SWIGTYPE_p_std__string); } result = (char *)((std::string const *)arg1)->c_str(); - lua_pushstring(L,(const char *)result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_string_data(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = (std::string *) 0 ; char *result = 0 ; - SWIG_check_num_args("std::string::data",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::string::data",1,"std::string const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__string,0))){ - SWIG_fail_ptr("string_data",1,SWIGTYPE_p_std__string); } result = (char *)((std::string const *)arg1)->data(); - lua_pushstring(L,(const char *)result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_string_assign(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = (std::string *) 0 ; - char *arg2 = (char *) 0 ; SWIG_check_num_args("std::string::assign",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::string::assign",1,"std::string *"); - if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("std::string::assign",2,"char const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__string,0))){ - SWIG_fail_ptr("string_assign",1,SWIGTYPE_p_std__string); } arg2 = (char *)lua_tostring(L, 2); - (arg1)->assign((char const *)arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_string(void *obj) { -std::string *arg1 = (std::string *) obj; -delete arg1; -} -static int _proxy__wrap_new_string(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_string); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_string_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_string_methods[]= { - { "size", _wrap_string_size}, - { "length", _wrap_string_length}, - { "empty", _wrap_string_empty}, - { "c_str", _wrap_string_c_str}, - { "data", _wrap_string_data}, - { "assign", _wrap_string_assign}, - {0,0} -}; -static swig_lua_method swig_string_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_string_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_string_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_string_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_string_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_string_Sf_SwigStatic = { - "string", - swig_string_Sf_SwigStatic_methods, - swig_string_Sf_SwigStatic_attributes, - swig_string_Sf_SwigStatic_constants, - swig_string_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_string_bases[] = {0}; -static const char *swig_string_base_names[] = {0}; -static swig_lua_class _wrap_class_string = { "string", "string", &SWIGTYPE_p_std__string,_proxy__wrap_new_string, swig_delete_string, swig_string_methods, swig_string_attributes, &swig_string_Sf_SwigStatic, swig_string_meta, swig_string_bases, swig_string_base_names }; - -static int _wrap_new_path__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::filesystem::path *result = 0 ; - SWIG_check_num_args("std::filesystem::path::path",0,0) result = (std::filesystem::path *)new std::filesystem::path(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__filesystem__path,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_path__SWIG_1(lua_State* L) { int SWIG_arg = 0; char *arg1 = (char *) 0 ; - std::filesystem::path *result = 0 ; SWIG_check_num_args("std::filesystem::path::path",1,1) - if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("std::filesystem::path::path",1,"char const *"); - arg1 = (char *)lua_tostring(L, 1); result = (std::filesystem::path *)new std::filesystem::path((char const *)arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__filesystem__path,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_path(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_path__SWIG_0(L);} if (argc == 1) { int _v; { _v = SWIG_lua_isnilstring(L,argv[0]); } if (_v) { - return _wrap_new_path__SWIG_1(L);} } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_path'\n" - " Possible C/C++ prototypes are:\n" " std::filesystem::path::path()\n" " std::filesystem::path::path(char const *)\n"); - lua_error(L);return 0; } -static int _wrap_path_string(lua_State* L) { int SWIG_arg = 0; std::filesystem::path *arg1 = (std::filesystem::path *) 0 ; - std::string result; SWIG_check_num_args("std::filesystem::path::string",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::filesystem::path::string",1,"std::filesystem::path const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__filesystem__path,0))){ - SWIG_fail_ptr("path_string",1,SWIGTYPE_p_std__filesystem__path); } - result = ((std::filesystem::path const *)arg1)->string(); lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_path(void *obj) { -std::filesystem::path *arg1 = (std::filesystem::path *) obj; -delete arg1; -} -static int _proxy__wrap_new_path(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_path); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_path_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_path_methods[]= { - { "string", _wrap_path_string}, - {0,0} -}; -static swig_lua_method swig_path_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_path_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_path_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_path_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_path_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_path_Sf_SwigStatic = { - "path", - swig_path_Sf_SwigStatic_methods, - swig_path_Sf_SwigStatic_attributes, - swig_path_Sf_SwigStatic_constants, - swig_path_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_path_bases[] = {0}; -static const char *swig_path_base_names[] = {0}; -static swig_lua_class _wrap_class_path = { "path", "path", &SWIGTYPE_p_std__filesystem__path,_proxy__wrap_new_path, swig_delete_path, swig_path_methods, swig_path_attributes, &swig_path_Sf_SwigStatic, swig_path_meta, swig_path_bases, swig_path_base_names }; - -static int _wrap_new_IntVector__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::vector< int > *result = 0 ; - SWIG_check_num_args("std::vector< int >::vector",0,0) result = (std::vector< int > *)new std::vector< int >(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_int_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_IntVector__SWIG_1(lua_State* L) { int SWIG_arg = 0; unsigned int arg1 ; std::vector< int > *result = 0 ; - SWIG_check_num_args("std::vector< int >::vector",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("std::vector< int >::vector",1,"unsigned int"); - SWIG_contract_assert((lua_tonumber(L,1)>=0),"number must not be negative") arg1 = (unsigned int)lua_tonumber(L, 1); - result = (std::vector< int > *)new std::vector< int >(arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_int_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_IntVector__SWIG_2(lua_State* L) { int SWIG_arg = 0; std::vector< int > *arg1 = 0 ; - std::vector< int > *result = 0 ; SWIG_check_num_args("std::vector< int >::vector",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("std::vector< int >::vector",1,"std::vector< int > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_int_t,0))){ - SWIG_fail_ptr("new_IntVector",1,SWIGTYPE_p_std__vectorT_int_t); } - result = (std::vector< int > *)new std::vector< int >((std::vector< int > const &)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_int_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_IntVector__SWIG_3(lua_State* L) { int SWIG_arg = 0; unsigned int arg1 ; int arg2 ; - std::vector< int > *result = 0 ; SWIG_check_num_args("std::vector< int >::vector",2,2) - if(!lua_isnumber(L,1)) SWIG_fail_arg("std::vector< int >::vector",1,"unsigned int"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("std::vector< int >::vector",2,"int"); - SWIG_contract_assert((lua_tonumber(L,1)>=0),"number must not be negative") arg1 = (unsigned int)lua_tonumber(L, 1); - arg2 = (int)lua_tonumber(L, 2); result = (std::vector< int > *)new std::vector< int >(arg1,arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_int_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_IntVector(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_IntVector__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_std__vectorT_int_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_new_IntVector__SWIG_2(L);} } if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_new_IntVector__SWIG_1(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_new_IntVector__SWIG_3(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_IntVector'\n" " Possible C/C++ prototypes are:\n" - " std::vector< int >::vector()\n" " std::vector< int >::vector(unsigned int)\n" - " std::vector< int >::vector(std::vector< int > const &)\n" " std::vector< int >::vector(unsigned int,int)\n"); - lua_error(L);return 0; } -static int _wrap_IntVector_size(lua_State* L) { int SWIG_arg = 0; std::vector< int > *arg1 = (std::vector< int > *) 0 ; - unsigned int result; SWIG_check_num_args("std::vector< int >::size",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< int >::size",1,"std::vector< int > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_int_t,0))){ - SWIG_fail_ptr("IntVector_size",1,SWIGTYPE_p_std__vectorT_int_t); } - result = (unsigned int)((std::vector< int > const *)arg1)->size(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_IntVector_max_size(lua_State* L) { int SWIG_arg = 0; std::vector< int > *arg1 = (std::vector< int > *) 0 ; - unsigned int result; SWIG_check_num_args("std::vector< int >::max_size",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< int >::max_size",1,"std::vector< int > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_int_t,0))){ - SWIG_fail_ptr("IntVector_max_size",1,SWIGTYPE_p_std__vectorT_int_t); } - result = (unsigned int)((std::vector< int > const *)arg1)->max_size(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_IntVector_empty(lua_State* L) { int SWIG_arg = 0; std::vector< int > *arg1 = (std::vector< int > *) 0 ; - bool result; SWIG_check_num_args("std::vector< int >::empty",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< int >::empty",1,"std::vector< int > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_int_t,0))){ - SWIG_fail_ptr("IntVector_empty",1,SWIGTYPE_p_std__vectorT_int_t); } - result = (bool)((std::vector< int > const *)arg1)->empty(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_IntVector_clear(lua_State* L) { int SWIG_arg = 0; std::vector< int > *arg1 = (std::vector< int > *) 0 ; - SWIG_check_num_args("std::vector< int >::clear",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< int >::clear",1,"std::vector< int > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_int_t,0))){ - SWIG_fail_ptr("IntVector_clear",1,SWIGTYPE_p_std__vectorT_int_t); } (arg1)->clear(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_IntVector_push_back(lua_State* L) { int SWIG_arg = 0; std::vector< int > *arg1 = (std::vector< int > *) 0 ; - int arg2 ; SWIG_check_num_args("std::vector< int >::push_back",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< int >::push_back",1,"std::vector< int > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("std::vector< int >::push_back",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_int_t,0))){ - SWIG_fail_ptr("IntVector_push_back",1,SWIGTYPE_p_std__vectorT_int_t); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->push_back(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_IntVector_pop_back(lua_State* L) { int SWIG_arg = 0; std::vector< int > *arg1 = (std::vector< int > *) 0 ; - SWIG_check_num_args("std::vector< int >::pop_back",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< int >::pop_back",1,"std::vector< int > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_int_t,0))){ - SWIG_fail_ptr("IntVector_pop_back",1,SWIGTYPE_p_std__vectorT_int_t); } (arg1)->pop_back(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_IntVector_front(lua_State* L) { int SWIG_arg = 0; std::vector< int > *arg1 = (std::vector< int > *) 0 ; - int result; SWIG_check_num_args("std::vector< int >::front",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< int >::front",1,"std::vector< int > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_int_t,0))){ - SWIG_fail_ptr("IntVector_front",1,SWIGTYPE_p_std__vectorT_int_t); } - result = (int)((std::vector< int > const *)arg1)->front(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_IntVector_back(lua_State* L) { int SWIG_arg = 0; std::vector< int > *arg1 = (std::vector< int > *) 0 ; - int result; SWIG_check_num_args("std::vector< int >::back",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< int >::back",1,"std::vector< int > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_int_t,0))){ - SWIG_fail_ptr("IntVector_back",1,SWIGTYPE_p_std__vectorT_int_t); } - result = (int)((std::vector< int > const *)arg1)->back(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_IntVector___getitem(lua_State* L) { int SWIG_arg = 0; std::vector< int > *arg1 = (std::vector< int > *) 0 ; - unsigned int arg2 ; int result; SWIG_check_num_args("std::vector< int >::__getitem__",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< int >::__getitem__",1,"std::vector< int > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("std::vector< int >::__getitem__",2,"unsigned int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_int_t,0))){ - SWIG_fail_ptr("IntVector___getitem",1,SWIGTYPE_p_std__vectorT_int_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned int)lua_tonumber(L, 2); try { - result = (int)std_vector_Sl_int_Sg____getitem__(arg1,arg2);} catch(std::out_of_range &_e) { - SWIG_exception(SWIG_IndexError, (&_e)->what()); } lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_IntVector___setitem(lua_State* L) { int SWIG_arg = 0; std::vector< int > *arg1 = (std::vector< int > *) 0 ; - unsigned int arg2 ; int arg3 ; SWIG_check_num_args("std::vector< int >::__setitem__",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< int >::__setitem__",1,"std::vector< int > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("std::vector< int >::__setitem__",2,"unsigned int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("std::vector< int >::__setitem__",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_int_t,0))){ - SWIG_fail_ptr("IntVector___setitem",1,SWIGTYPE_p_std__vectorT_int_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); try { std_vector_Sl_int_Sg____setitem__(arg1,arg2,arg3);} catch(std::out_of_range &_e) { - SWIG_exception(SWIG_IndexError, (&_e)->what()); } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_IntVector(void *obj) { -std::vector< int > *arg1 = (std::vector< int > *) obj; -delete arg1; -} -static int _proxy__wrap_new_IntVector(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_IntVector); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_IntVector_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_IntVector_methods[]= { - { "size", _wrap_IntVector_size}, - { "max_size", _wrap_IntVector_max_size}, - { "empty", _wrap_IntVector_empty}, - { "clear", _wrap_IntVector_clear}, - { "push_back", _wrap_IntVector_push_back}, - { "pop_back", _wrap_IntVector_pop_back}, - { "front", _wrap_IntVector_front}, - { "back", _wrap_IntVector_back}, - { "__getitem", _wrap_IntVector___getitem}, - { "__setitem", _wrap_IntVector___setitem}, - {0,0} -}; -static swig_lua_method swig_IntVector_meta[] = { - { "__getitem", _wrap_IntVector___getitem}, - { "__setitem", _wrap_IntVector___setitem}, - {0,0} -}; - -static swig_lua_attribute swig_IntVector_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_IntVector_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_IntVector_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_IntVector_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_IntVector_Sf_SwigStatic = { - "IntVector", - swig_IntVector_Sf_SwigStatic_methods, - swig_IntVector_Sf_SwigStatic_attributes, - swig_IntVector_Sf_SwigStatic_constants, - swig_IntVector_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_IntVector_bases[] = {0}; -static const char *swig_IntVector_base_names[] = {0}; -static swig_lua_class _wrap_class_IntVector = { "IntVector", "IntVector", &SWIGTYPE_p_std__vectorT_int_t,_proxy__wrap_new_IntVector, swig_delete_IntVector, swig_IntVector_methods, swig_IntVector_attributes, &swig_IntVector_Sf_SwigStatic, swig_IntVector_meta, swig_IntVector_bases, swig_IntVector_base_names }; - -static int _wrap_new_FloatVector__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::vector< float > *result = 0 ; - SWIG_check_num_args("std::vector< float >::vector",0,0) result = (std::vector< float > *)new std::vector< float >(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_float_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_FloatVector__SWIG_1(lua_State* L) { int SWIG_arg = 0; unsigned int arg1 ; - std::vector< float > *result = 0 ; SWIG_check_num_args("std::vector< float >::vector",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("std::vector< float >::vector",1,"unsigned int"); - SWIG_contract_assert((lua_tonumber(L,1)>=0),"number must not be negative") arg1 = (unsigned int)lua_tonumber(L, 1); - result = (std::vector< float > *)new std::vector< float >(arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_float_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_FloatVector__SWIG_2(lua_State* L) { int SWIG_arg = 0; std::vector< float > *arg1 = 0 ; - std::vector< float > *result = 0 ; SWIG_check_num_args("std::vector< float >::vector",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("std::vector< float >::vector",1,"std::vector< float > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_float_t,0))){ - SWIG_fail_ptr("new_FloatVector",1,SWIGTYPE_p_std__vectorT_float_t); } - result = (std::vector< float > *)new std::vector< float >((std::vector< float > const &)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_float_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_FloatVector__SWIG_3(lua_State* L) { int SWIG_arg = 0; unsigned int arg1 ; float arg2 ; - std::vector< float > *result = 0 ; SWIG_check_num_args("std::vector< float >::vector",2,2) - if(!lua_isnumber(L,1)) SWIG_fail_arg("std::vector< float >::vector",1,"unsigned int"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("std::vector< float >::vector",2,"float"); - SWIG_contract_assert((lua_tonumber(L,1)>=0),"number must not be negative") arg1 = (unsigned int)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); result = (std::vector< float > *)new std::vector< float >(arg1,arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_float_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_FloatVector(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_FloatVector__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_std__vectorT_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_new_FloatVector__SWIG_2(L);} } if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_new_FloatVector__SWIG_1(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_new_FloatVector__SWIG_3(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_FloatVector'\n" " Possible C/C++ prototypes are:\n" - " std::vector< float >::vector()\n" " std::vector< float >::vector(unsigned int)\n" - " std::vector< float >::vector(std::vector< float > const &)\n" " std::vector< float >::vector(unsigned int,float)\n"); - lua_error(L);return 0; } -static int _wrap_FloatVector_size(lua_State* L) { int SWIG_arg = 0; std::vector< float > *arg1 = (std::vector< float > *) 0 ; - unsigned int result; SWIG_check_num_args("std::vector< float >::size",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< float >::size",1,"std::vector< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_float_t,0))){ - SWIG_fail_ptr("FloatVector_size",1,SWIGTYPE_p_std__vectorT_float_t); } - result = (unsigned int)((std::vector< float > const *)arg1)->size(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatVector_max_size(lua_State* L) { int SWIG_arg = 0; - std::vector< float > *arg1 = (std::vector< float > *) 0 ; unsigned int result; - SWIG_check_num_args("std::vector< float >::max_size",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< float >::max_size",1,"std::vector< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_float_t,0))){ - SWIG_fail_ptr("FloatVector_max_size",1,SWIGTYPE_p_std__vectorT_float_t); } - result = (unsigned int)((std::vector< float > const *)arg1)->max_size(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatVector_empty(lua_State* L) { int SWIG_arg = 0; std::vector< float > *arg1 = (std::vector< float > *) 0 ; - bool result; SWIG_check_num_args("std::vector< float >::empty",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< float >::empty",1,"std::vector< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_float_t,0))){ - SWIG_fail_ptr("FloatVector_empty",1,SWIGTYPE_p_std__vectorT_float_t); } - result = (bool)((std::vector< float > const *)arg1)->empty(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatVector_clear(lua_State* L) { int SWIG_arg = 0; std::vector< float > *arg1 = (std::vector< float > *) 0 ; - SWIG_check_num_args("std::vector< float >::clear",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< float >::clear",1,"std::vector< float > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_float_t,0))){ - SWIG_fail_ptr("FloatVector_clear",1,SWIGTYPE_p_std__vectorT_float_t); } (arg1)->clear(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatVector_push_back(lua_State* L) { int SWIG_arg = 0; - std::vector< float > *arg1 = (std::vector< float > *) 0 ; float arg2 ; - SWIG_check_num_args("std::vector< float >::push_back",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< float >::push_back",1,"std::vector< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("std::vector< float >::push_back",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_float_t,0))){ - SWIG_fail_ptr("FloatVector_push_back",1,SWIGTYPE_p_std__vectorT_float_t); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->push_back(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatVector_pop_back(lua_State* L) { int SWIG_arg = 0; - std::vector< float > *arg1 = (std::vector< float > *) 0 ; SWIG_check_num_args("std::vector< float >::pop_back",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< float >::pop_back",1,"std::vector< float > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_float_t,0))){ - SWIG_fail_ptr("FloatVector_pop_back",1,SWIGTYPE_p_std__vectorT_float_t); } (arg1)->pop_back(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatVector_front(lua_State* L) { int SWIG_arg = 0; std::vector< float > *arg1 = (std::vector< float > *) 0 ; - float result; SWIG_check_num_args("std::vector< float >::front",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< float >::front",1,"std::vector< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_float_t,0))){ - SWIG_fail_ptr("FloatVector_front",1,SWIGTYPE_p_std__vectorT_float_t); } - result = (float)((std::vector< float > const *)arg1)->front(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatVector_back(lua_State* L) { int SWIG_arg = 0; std::vector< float > *arg1 = (std::vector< float > *) 0 ; - float result; SWIG_check_num_args("std::vector< float >::back",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< float >::back",1,"std::vector< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_float_t,0))){ - SWIG_fail_ptr("FloatVector_back",1,SWIGTYPE_p_std__vectorT_float_t); } - result = (float)((std::vector< float > const *)arg1)->back(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatVector___getitem(lua_State* L) { int SWIG_arg = 0; - std::vector< float > *arg1 = (std::vector< float > *) 0 ; unsigned int arg2 ; float result; - SWIG_check_num_args("std::vector< float >::__getitem__",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< float >::__getitem__",1,"std::vector< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("std::vector< float >::__getitem__",2,"unsigned int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_float_t,0))){ - SWIG_fail_ptr("FloatVector___getitem",1,SWIGTYPE_p_std__vectorT_float_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned int)lua_tonumber(L, 2); try { - result = (float)std_vector_Sl_float_Sg____getitem__(arg1,arg2);} catch(std::out_of_range &_e) { - SWIG_exception(SWIG_IndexError, (&_e)->what()); } lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatVector___setitem(lua_State* L) { int SWIG_arg = 0; - std::vector< float > *arg1 = (std::vector< float > *) 0 ; unsigned int arg2 ; float arg3 ; - SWIG_check_num_args("std::vector< float >::__setitem__",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< float >::__setitem__",1,"std::vector< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("std::vector< float >::__setitem__",2,"unsigned int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("std::vector< float >::__setitem__",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_float_t,0))){ - SWIG_fail_ptr("FloatVector___setitem",1,SWIGTYPE_p_std__vectorT_float_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned int)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); try { std_vector_Sl_float_Sg____setitem__(arg1,arg2,arg3);} catch(std::out_of_range &_e) { - SWIG_exception(SWIG_IndexError, (&_e)->what()); } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_FloatVector(void *obj) { -std::vector< float > *arg1 = (std::vector< float > *) obj; -delete arg1; -} -static int _proxy__wrap_new_FloatVector(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_FloatVector); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_FloatVector_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_FloatVector_methods[]= { - { "size", _wrap_FloatVector_size}, - { "max_size", _wrap_FloatVector_max_size}, - { "empty", _wrap_FloatVector_empty}, - { "clear", _wrap_FloatVector_clear}, - { "push_back", _wrap_FloatVector_push_back}, - { "pop_back", _wrap_FloatVector_pop_back}, - { "front", _wrap_FloatVector_front}, - { "back", _wrap_FloatVector_back}, - { "__getitem", _wrap_FloatVector___getitem}, - { "__setitem", _wrap_FloatVector___setitem}, - {0,0} -}; -static swig_lua_method swig_FloatVector_meta[] = { - { "__getitem", _wrap_FloatVector___getitem}, - { "__setitem", _wrap_FloatVector___setitem}, - {0,0} -}; - -static swig_lua_attribute swig_FloatVector_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_FloatVector_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_FloatVector_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_FloatVector_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_FloatVector_Sf_SwigStatic = { - "FloatVector", - swig_FloatVector_Sf_SwigStatic_methods, - swig_FloatVector_Sf_SwigStatic_attributes, - swig_FloatVector_Sf_SwigStatic_constants, - swig_FloatVector_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_FloatVector_bases[] = {0}; -static const char *swig_FloatVector_base_names[] = {0}; -static swig_lua_class _wrap_class_FloatVector = { "FloatVector", "FloatVector", &SWIGTYPE_p_std__vectorT_float_t,_proxy__wrap_new_FloatVector, swig_delete_FloatVector, swig_FloatVector_methods, swig_FloatVector_attributes, &swig_FloatVector_Sf_SwigStatic, swig_FloatVector_meta, swig_FloatVector_bases, swig_FloatVector_base_names }; - -static int _wrap_new_StringVector__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::vector< std::string > *result = 0 ; - SWIG_check_num_args("std::vector< std::string >::vector",0,0) - result = (std::vector< std::string > *)new std::vector< std::string >(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_std__string_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_StringVector__SWIG_1(lua_State* L) { int SWIG_arg = 0; unsigned int arg1 ; - std::vector< std::string > *result = 0 ; SWIG_check_num_args("std::vector< std::string >::vector",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("std::vector< std::string >::vector",1,"unsigned int"); - SWIG_contract_assert((lua_tonumber(L,1)>=0),"number must not be negative") arg1 = (unsigned int)lua_tonumber(L, 1); - result = (std::vector< std::string > *)new std::vector< std::string >(arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_std__string_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_StringVector__SWIG_2(lua_State* L) { int SWIG_arg = 0; std::vector< std::string > *arg1 = 0 ; - std::vector< std::string > *result = 0 ; SWIG_check_num_args("std::vector< std::string >::vector",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("std::vector< std::string >::vector",1,"std::vector< std::string > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_std__string_t,0))){ - SWIG_fail_ptr("new_StringVector",1,SWIGTYPE_p_std__vectorT_std__string_t); } - result = (std::vector< std::string > *)new std::vector< std::string >((std::vector< std::string > const &)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_std__string_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_StringVector__SWIG_3(lua_State* L) { int SWIG_arg = 0; unsigned int arg1 ; std::string arg2 ; - std::vector< std::string > *result = 0 ; SWIG_check_num_args("std::vector< std::string >::vector",2,2) - if(!lua_isnumber(L,1)) SWIG_fail_arg("std::vector< std::string >::vector",1,"unsigned int"); - if(!lua_isstring(L,2)) SWIG_fail_arg("std::vector< std::string >::vector",2,"std::string"); - SWIG_contract_assert((lua_tonumber(L,1)>=0),"number must not be negative") arg1 = (unsigned int)lua_tonumber(L, 1); - (&arg2)->assign(lua_tostring(L,2),lua_rawlen(L,2)); - result = (std::vector< std::string > *)new std::vector< std::string >(arg1,arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_std__string_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_StringVector(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_StringVector__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_std__vectorT_std__string_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_new_StringVector__SWIG_2(L);} } if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_new_StringVector__SWIG_1(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { - return _wrap_new_StringVector__SWIG_3(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_StringVector'\n" " Possible C/C++ prototypes are:\n" - " std::vector< std::string >::vector()\n" " std::vector< std::string >::vector(unsigned int)\n" - " std::vector< std::string >::vector(std::vector< std::string > const &)\n" - " std::vector< std::string >::vector(unsigned int,std::string)\n"); lua_error(L);return 0; } -static int _wrap_StringVector_size(lua_State* L) { int SWIG_arg = 0; - std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ; unsigned int result; - SWIG_check_num_args("std::vector< std::string >::size",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< std::string >::size",1,"std::vector< std::string > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_std__string_t,0))){ - SWIG_fail_ptr("StringVector_size",1,SWIGTYPE_p_std__vectorT_std__string_t); } - result = (unsigned int)((std::vector< std::string > const *)arg1)->size(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_StringVector_max_size(lua_State* L) { int SWIG_arg = 0; - std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ; unsigned int result; - SWIG_check_num_args("std::vector< std::string >::max_size",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< std::string >::max_size",1,"std::vector< std::string > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_std__string_t,0))){ - SWIG_fail_ptr("StringVector_max_size",1,SWIGTYPE_p_std__vectorT_std__string_t); } - result = (unsigned int)((std::vector< std::string > const *)arg1)->max_size(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_StringVector_empty(lua_State* L) { int SWIG_arg = 0; - std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ; bool result; - SWIG_check_num_args("std::vector< std::string >::empty",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< std::string >::empty",1,"std::vector< std::string > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_std__string_t,0))){ - SWIG_fail_ptr("StringVector_empty",1,SWIGTYPE_p_std__vectorT_std__string_t); } - result = (bool)((std::vector< std::string > const *)arg1)->empty(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_StringVector_clear(lua_State* L) { int SWIG_arg = 0; - std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ; - SWIG_check_num_args("std::vector< std::string >::clear",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< std::string >::clear",1,"std::vector< std::string > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_std__string_t,0))){ - SWIG_fail_ptr("StringVector_clear",1,SWIGTYPE_p_std__vectorT_std__string_t); } (arg1)->clear(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_StringVector_push_back(lua_State* L) { int SWIG_arg = 0; - std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ; std::string arg2 ; - SWIG_check_num_args("std::vector< std::string >::push_back",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< std::string >::push_back",1,"std::vector< std::string > *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("std::vector< std::string >::push_back",2,"std::string"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_std__string_t,0))){ - SWIG_fail_ptr("StringVector_push_back",1,SWIGTYPE_p_std__vectorT_std__string_t); } - (&arg2)->assign(lua_tostring(L,2),lua_rawlen(L,2)); (arg1)->push_back(arg2); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_StringVector_pop_back(lua_State* L) { int SWIG_arg = 0; - std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ; - SWIG_check_num_args("std::vector< std::string >::pop_back",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< std::string >::pop_back",1,"std::vector< std::string > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_std__string_t,0))){ - SWIG_fail_ptr("StringVector_pop_back",1,SWIGTYPE_p_std__vectorT_std__string_t); } (arg1)->pop_back(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_StringVector_front(lua_State* L) { int SWIG_arg = 0; - std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ; std::string result; - SWIG_check_num_args("std::vector< std::string >::front",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< std::string >::front",1,"std::vector< std::string > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_std__string_t,0))){ - SWIG_fail_ptr("StringVector_front",1,SWIGTYPE_p_std__vectorT_std__string_t); } - result = ((std::vector< std::string > const *)arg1)->front(); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_StringVector_back(lua_State* L) { int SWIG_arg = 0; - std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ; std::string result; - SWIG_check_num_args("std::vector< std::string >::back",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< std::string >::back",1,"std::vector< std::string > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_std__string_t,0))){ - SWIG_fail_ptr("StringVector_back",1,SWIGTYPE_p_std__vectorT_std__string_t); } - result = ((std::vector< std::string > const *)arg1)->back(); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_StringVector___getitem(lua_State* L) { int SWIG_arg = 0; - std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ; unsigned int arg2 ; std::string result; - SWIG_check_num_args("std::vector< std::string >::__getitem__",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< std::string >::__getitem__",1,"std::vector< std::string > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("std::vector< std::string >::__getitem__",2,"unsigned int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_std__string_t,0))){ - SWIG_fail_ptr("StringVector___getitem",1,SWIGTYPE_p_std__vectorT_std__string_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned int)lua_tonumber(L, 2); try { - result = std_vector_Sl_std_string_Sg____getitem__(arg1,arg2);} catch(std::out_of_range &_e) { - SWIG_exception(SWIG_IndexError, (&_e)->what()); } lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_StringVector___setitem(lua_State* L) { int SWIG_arg = 0; - std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ; unsigned int arg2 ; std::string arg3 ; - SWIG_check_num_args("std::vector< std::string >::__setitem__",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< std::string >::__setitem__",1,"std::vector< std::string > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("std::vector< std::string >::__setitem__",2,"unsigned int"); - if(!lua_isstring(L,3)) SWIG_fail_arg("std::vector< std::string >::__setitem__",3,"std::string"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_std__string_t,0))){ - SWIG_fail_ptr("StringVector___setitem",1,SWIGTYPE_p_std__vectorT_std__string_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned int)lua_tonumber(L, 2); - (&arg3)->assign(lua_tostring(L,3),lua_rawlen(L,3)); try { std_vector_Sl_std_string_Sg____setitem__(arg1,arg2,arg3);} - catch(std::out_of_range &_e) { SWIG_exception(SWIG_IndexError, (&_e)->what()); } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static void swig_delete_StringVector(void *obj) { -std::vector< std::string > *arg1 = (std::vector< std::string > *) obj; -delete arg1; -} -static int _proxy__wrap_new_StringVector(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_StringVector); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_StringVector_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_StringVector_methods[]= { - { "size", _wrap_StringVector_size}, - { "max_size", _wrap_StringVector_max_size}, - { "empty", _wrap_StringVector_empty}, - { "clear", _wrap_StringVector_clear}, - { "push_back", _wrap_StringVector_push_back}, - { "pop_back", _wrap_StringVector_pop_back}, - { "front", _wrap_StringVector_front}, - { "back", _wrap_StringVector_back}, - { "__getitem", _wrap_StringVector___getitem}, - { "__setitem", _wrap_StringVector___setitem}, - {0,0} -}; -static swig_lua_method swig_StringVector_meta[] = { - { "__getitem", _wrap_StringVector___getitem}, - { "__setitem", _wrap_StringVector___setitem}, - {0,0} -}; - -static swig_lua_attribute swig_StringVector_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_StringVector_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_StringVector_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_StringVector_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_StringVector_Sf_SwigStatic = { - "StringVector", - swig_StringVector_Sf_SwigStatic_methods, - swig_StringVector_Sf_SwigStatic_attributes, - swig_StringVector_Sf_SwigStatic_constants, - swig_StringVector_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_StringVector_bases[] = {0}; -static const char *swig_StringVector_base_names[] = {0}; -static swig_lua_class _wrap_class_StringVector = { "StringVector", "StringVector", &SWIGTYPE_p_std__vectorT_std__string_t,_proxy__wrap_new_StringVector, swig_delete_StringVector, swig_StringVector_methods, swig_StringVector_attributes, &swig_StringVector_Sf_SwigStatic, swig_StringVector_meta, swig_StringVector_bases, swig_StringVector_base_names }; - -static int _wrap_new_UCharVector__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::vector< unsigned char > *result = 0 ; - SWIG_check_num_args("std::vector< unsigned char >::vector",0,0) - result = (std::vector< unsigned char > *)new std::vector< unsigned char >(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_unsigned_char_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_UCharVector__SWIG_1(lua_State* L) { int SWIG_arg = 0; unsigned int arg1 ; - std::vector< unsigned char > *result = 0 ; SWIG_check_num_args("std::vector< unsigned char >::vector",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("std::vector< unsigned char >::vector",1,"unsigned int"); - SWIG_contract_assert((lua_tonumber(L,1)>=0),"number must not be negative") arg1 = (unsigned int)lua_tonumber(L, 1); - result = (std::vector< unsigned char > *)new std::vector< unsigned char >(arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_unsigned_char_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_UCharVector__SWIG_2(lua_State* L) { int SWIG_arg = 0; std::vector< unsigned char > *arg1 = 0 ; - std::vector< unsigned char > *result = 0 ; SWIG_check_num_args("std::vector< unsigned char >::vector",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("std::vector< unsigned char >::vector",1,"std::vector< unsigned char > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_unsigned_char_t,0))){ - SWIG_fail_ptr("new_UCharVector",1,SWIGTYPE_p_std__vectorT_unsigned_char_t); } - result = (std::vector< unsigned char > *)new std::vector< unsigned char >((std::vector< unsigned char > const &)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_unsigned_char_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_UCharVector__SWIG_3(lua_State* L) { int SWIG_arg = 0; unsigned int arg1 ; unsigned char arg2 ; - std::vector< unsigned char > *result = 0 ; SWIG_check_num_args("std::vector< unsigned char >::vector",2,2) - if(!lua_isnumber(L,1)) SWIG_fail_arg("std::vector< unsigned char >::vector",1,"unsigned int"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("std::vector< unsigned char >::vector",2,"unsigned char"); - SWIG_contract_assert((lua_tonumber(L,1)>=0),"number must not be negative") arg1 = (unsigned int)lua_tonumber(L, 1); - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned char)lua_tonumber(L, 2); - result = (std::vector< unsigned char > *)new std::vector< unsigned char >(arg1,arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_unsigned_char_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_UCharVector(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_UCharVector__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_std__vectorT_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_new_UCharVector__SWIG_2(L);} } if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_new_UCharVector__SWIG_1(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_new_UCharVector__SWIG_3(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_UCharVector'\n" " Possible C/C++ prototypes are:\n" - " std::vector< unsigned char >::vector()\n" " std::vector< unsigned char >::vector(unsigned int)\n" - " std::vector< unsigned char >::vector(std::vector< unsigned char > const &)\n" - " std::vector< unsigned char >::vector(unsigned int,unsigned char)\n"); lua_error(L);return 0; } -static int _wrap_UCharVector_size(lua_State* L) { int SWIG_arg = 0; - std::vector< unsigned char > *arg1 = (std::vector< unsigned char > *) 0 ; unsigned int result; - SWIG_check_num_args("std::vector< unsigned char >::size",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< unsigned char >::size",1,"std::vector< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_unsigned_char_t,0))){ - SWIG_fail_ptr("UCharVector_size",1,SWIGTYPE_p_std__vectorT_unsigned_char_t); } - result = (unsigned int)((std::vector< unsigned char > const *)arg1)->size(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_UCharVector_max_size(lua_State* L) { int SWIG_arg = 0; - std::vector< unsigned char > *arg1 = (std::vector< unsigned char > *) 0 ; unsigned int result; - SWIG_check_num_args("std::vector< unsigned char >::max_size",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< unsigned char >::max_size",1,"std::vector< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_unsigned_char_t,0))){ - SWIG_fail_ptr("UCharVector_max_size",1,SWIGTYPE_p_std__vectorT_unsigned_char_t); } - result = (unsigned int)((std::vector< unsigned char > const *)arg1)->max_size(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_UCharVector_empty(lua_State* L) { int SWIG_arg = 0; - std::vector< unsigned char > *arg1 = (std::vector< unsigned char > *) 0 ; bool result; - SWIG_check_num_args("std::vector< unsigned char >::empty",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< unsigned char >::empty",1,"std::vector< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_unsigned_char_t,0))){ - SWIG_fail_ptr("UCharVector_empty",1,SWIGTYPE_p_std__vectorT_unsigned_char_t); } - result = (bool)((std::vector< unsigned char > const *)arg1)->empty(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_UCharVector_clear(lua_State* L) { int SWIG_arg = 0; - std::vector< unsigned char > *arg1 = (std::vector< unsigned char > *) 0 ; - SWIG_check_num_args("std::vector< unsigned char >::clear",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< unsigned char >::clear",1,"std::vector< unsigned char > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_unsigned_char_t,0))){ - SWIG_fail_ptr("UCharVector_clear",1,SWIGTYPE_p_std__vectorT_unsigned_char_t); } (arg1)->clear(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_UCharVector_push_back(lua_State* L) { int SWIG_arg = 0; - std::vector< unsigned char > *arg1 = (std::vector< unsigned char > *) 0 ; unsigned char arg2 ; - SWIG_check_num_args("std::vector< unsigned char >::push_back",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< unsigned char >::push_back",1,"std::vector< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("std::vector< unsigned char >::push_back",2,"unsigned char"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_unsigned_char_t,0))){ - SWIG_fail_ptr("UCharVector_push_back",1,SWIGTYPE_p_std__vectorT_unsigned_char_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned char)lua_tonumber(L, 2); - (arg1)->push_back(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_UCharVector_pop_back(lua_State* L) { int SWIG_arg = 0; - std::vector< unsigned char > *arg1 = (std::vector< unsigned char > *) 0 ; - SWIG_check_num_args("std::vector< unsigned char >::pop_back",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< unsigned char >::pop_back",1,"std::vector< unsigned char > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_unsigned_char_t,0))){ - SWIG_fail_ptr("UCharVector_pop_back",1,SWIGTYPE_p_std__vectorT_unsigned_char_t); } (arg1)->pop_back(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_UCharVector_front(lua_State* L) { int SWIG_arg = 0; - std::vector< unsigned char > *arg1 = (std::vector< unsigned char > *) 0 ; unsigned char result; - SWIG_check_num_args("std::vector< unsigned char >::front",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< unsigned char >::front",1,"std::vector< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_unsigned_char_t,0))){ - SWIG_fail_ptr("UCharVector_front",1,SWIGTYPE_p_std__vectorT_unsigned_char_t); } - result = (unsigned char)((std::vector< unsigned char > const *)arg1)->front(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_UCharVector_back(lua_State* L) { int SWIG_arg = 0; - std::vector< unsigned char > *arg1 = (std::vector< unsigned char > *) 0 ; unsigned char result; - SWIG_check_num_args("std::vector< unsigned char >::back",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< unsigned char >::back",1,"std::vector< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_unsigned_char_t,0))){ - SWIG_fail_ptr("UCharVector_back",1,SWIGTYPE_p_std__vectorT_unsigned_char_t); } - result = (unsigned char)((std::vector< unsigned char > const *)arg1)->back(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_UCharVector___getitem(lua_State* L) { int SWIG_arg = 0; - std::vector< unsigned char > *arg1 = (std::vector< unsigned char > *) 0 ; unsigned int arg2 ; unsigned char result; - SWIG_check_num_args("std::vector< unsigned char >::__getitem__",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< unsigned char >::__getitem__",1,"std::vector< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("std::vector< unsigned char >::__getitem__",2,"unsigned int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_unsigned_char_t,0))){ - SWIG_fail_ptr("UCharVector___getitem",1,SWIGTYPE_p_std__vectorT_unsigned_char_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned int)lua_tonumber(L, 2); try { - result = (unsigned char)std_vector_Sl_unsigned_SS_char_Sg____getitem__(arg1,arg2);} catch(std::out_of_range &_e) { - SWIG_exception(SWIG_IndexError, (&_e)->what()); } lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_UCharVector___setitem(lua_State* L) { int SWIG_arg = 0; - std::vector< unsigned char > *arg1 = (std::vector< unsigned char > *) 0 ; unsigned int arg2 ; unsigned char arg3 ; - SWIG_check_num_args("std::vector< unsigned char >::__setitem__",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< unsigned char >::__setitem__",1,"std::vector< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("std::vector< unsigned char >::__setitem__",2,"unsigned int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("std::vector< unsigned char >::__setitem__",3,"unsigned char"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_unsigned_char_t,0))){ - SWIG_fail_ptr("UCharVector___setitem",1,SWIGTYPE_p_std__vectorT_unsigned_char_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned int)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (unsigned char)lua_tonumber(L, 3); try { - std_vector_Sl_unsigned_SS_char_Sg____setitem__(arg1,arg2,arg3);} catch(std::out_of_range &_e) { - SWIG_exception(SWIG_IndexError, (&_e)->what()); } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_UCharVector(void *obj) { -std::vector< unsigned char > *arg1 = (std::vector< unsigned char > *) obj; -delete arg1; -} -static int _proxy__wrap_new_UCharVector(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_UCharVector); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_UCharVector_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_UCharVector_methods[]= { - { "size", _wrap_UCharVector_size}, - { "max_size", _wrap_UCharVector_max_size}, - { "empty", _wrap_UCharVector_empty}, - { "clear", _wrap_UCharVector_clear}, - { "push_back", _wrap_UCharVector_push_back}, - { "pop_back", _wrap_UCharVector_pop_back}, - { "front", _wrap_UCharVector_front}, - { "back", _wrap_UCharVector_back}, - { "__getitem", _wrap_UCharVector___getitem}, - { "__setitem", _wrap_UCharVector___setitem}, - {0,0} -}; -static swig_lua_method swig_UCharVector_meta[] = { - { "__getitem", _wrap_UCharVector___getitem}, - { "__setitem", _wrap_UCharVector___setitem}, - {0,0} -}; - -static swig_lua_attribute swig_UCharVector_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_UCharVector_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_UCharVector_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_UCharVector_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_UCharVector_Sf_SwigStatic = { - "UCharVector", - swig_UCharVector_Sf_SwigStatic_methods, - swig_UCharVector_Sf_SwigStatic_attributes, - swig_UCharVector_Sf_SwigStatic_constants, - swig_UCharVector_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_UCharVector_bases[] = {0}; -static const char *swig_UCharVector_base_names[] = {0}; -static swig_lua_class _wrap_class_UCharVector = { "UCharVector", "UCharVector", &SWIGTYPE_p_std__vectorT_unsigned_char_t,_proxy__wrap_new_UCharVector, swig_delete_UCharVector, swig_UCharVector_methods, swig_UCharVector_attributes, &swig_UCharVector_Sf_SwigStatic, swig_UCharVector_meta, swig_UCharVector_bases, swig_UCharVector_base_names }; - -static int _wrap_new_VideoDeviceVector__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::vector< ofVideoDevice > *result = 0 ; - SWIG_check_num_args("std::vector< ofVideoDevice >::vector",0,0) - result = (std::vector< ofVideoDevice > *)new std::vector< ofVideoDevice >(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofVideoDevice_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_VideoDeviceVector__SWIG_1(lua_State* L) { int SWIG_arg = 0; unsigned int arg1 ; - std::vector< ofVideoDevice > *result = 0 ; SWIG_check_num_args("std::vector< ofVideoDevice >::vector",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("std::vector< ofVideoDevice >::vector",1,"unsigned int"); - SWIG_contract_assert((lua_tonumber(L,1)>=0),"number must not be negative") arg1 = (unsigned int)lua_tonumber(L, 1); - result = (std::vector< ofVideoDevice > *)new std::vector< ofVideoDevice >(arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofVideoDevice_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_VideoDeviceVector__SWIG_2(lua_State* L) { int SWIG_arg = 0; std::vector< ofVideoDevice > *arg1 = 0 ; - std::vector< ofVideoDevice > *result = 0 ; SWIG_check_num_args("std::vector< ofVideoDevice >::vector",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("std::vector< ofVideoDevice >::vector",1,"std::vector< ofVideoDevice > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofVideoDevice_t,0))){ - SWIG_fail_ptr("new_VideoDeviceVector",1,SWIGTYPE_p_std__vectorT_ofVideoDevice_t); } - result = (std::vector< ofVideoDevice > *)new std::vector< ofVideoDevice >((std::vector< ofVideoDevice > const &)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofVideoDevice_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_VideoDeviceVector__SWIG_3(lua_State* L) { int SWIG_arg = 0; unsigned int arg1 ; ofVideoDevice arg2 ; - ofVideoDevice *argp2 ; std::vector< ofVideoDevice > *result = 0 ; - SWIG_check_num_args("std::vector< ofVideoDevice >::vector",2,2) - if(!lua_isnumber(L,1)) SWIG_fail_arg("std::vector< ofVideoDevice >::vector",1,"unsigned int"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("std::vector< ofVideoDevice >::vector",2,"ofVideoDevice"); - SWIG_contract_assert((lua_tonumber(L,1)>=0),"number must not be negative") arg1 = (unsigned int)lua_tonumber(L, 1); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofVideoDevice,0))){ - SWIG_fail_ptr("new_VideoDeviceVector",2,SWIGTYPE_p_ofVideoDevice); } arg2 = *argp2; - result = (std::vector< ofVideoDevice > *)new std::vector< ofVideoDevice >(arg1,arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofVideoDevice_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_VideoDeviceVector(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_VideoDeviceVector__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_std__vectorT_ofVideoDevice_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_new_VideoDeviceVector__SWIG_2(L);} } if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_new_VideoDeviceVector__SWIG_1(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVideoDevice, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_new_VideoDeviceVector__SWIG_3(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_VideoDeviceVector'\n" - " Possible C/C++ prototypes are:\n" " std::vector< ofVideoDevice >::vector()\n" - " std::vector< ofVideoDevice >::vector(unsigned int)\n" - " std::vector< ofVideoDevice >::vector(std::vector< ofVideoDevice > const &)\n" - " std::vector< ofVideoDevice >::vector(unsigned int,ofVideoDevice)\n"); lua_error(L);return 0; } -static int _wrap_VideoDeviceVector_size(lua_State* L) { int SWIG_arg = 0; - std::vector< ofVideoDevice > *arg1 = (std::vector< ofVideoDevice > *) 0 ; unsigned int result; - SWIG_check_num_args("std::vector< ofVideoDevice >::size",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< ofVideoDevice >::size",1,"std::vector< ofVideoDevice > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofVideoDevice_t,0))){ - SWIG_fail_ptr("VideoDeviceVector_size",1,SWIGTYPE_p_std__vectorT_ofVideoDevice_t); } - result = (unsigned int)((std::vector< ofVideoDevice > const *)arg1)->size(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoDeviceVector_max_size(lua_State* L) { int SWIG_arg = 0; - std::vector< ofVideoDevice > *arg1 = (std::vector< ofVideoDevice > *) 0 ; unsigned int result; - SWIG_check_num_args("std::vector< ofVideoDevice >::max_size",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< ofVideoDevice >::max_size",1,"std::vector< ofVideoDevice > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofVideoDevice_t,0))){ - SWIG_fail_ptr("VideoDeviceVector_max_size",1,SWIGTYPE_p_std__vectorT_ofVideoDevice_t); } - result = (unsigned int)((std::vector< ofVideoDevice > const *)arg1)->max_size(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoDeviceVector_empty(lua_State* L) { int SWIG_arg = 0; - std::vector< ofVideoDevice > *arg1 = (std::vector< ofVideoDevice > *) 0 ; bool result; - SWIG_check_num_args("std::vector< ofVideoDevice >::empty",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< ofVideoDevice >::empty",1,"std::vector< ofVideoDevice > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofVideoDevice_t,0))){ - SWIG_fail_ptr("VideoDeviceVector_empty",1,SWIGTYPE_p_std__vectorT_ofVideoDevice_t); } - result = (bool)((std::vector< ofVideoDevice > const *)arg1)->empty(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoDeviceVector_clear(lua_State* L) { int SWIG_arg = 0; - std::vector< ofVideoDevice > *arg1 = (std::vector< ofVideoDevice > *) 0 ; - SWIG_check_num_args("std::vector< ofVideoDevice >::clear",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< ofVideoDevice >::clear",1,"std::vector< ofVideoDevice > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofVideoDevice_t,0))){ - SWIG_fail_ptr("VideoDeviceVector_clear",1,SWIGTYPE_p_std__vectorT_ofVideoDevice_t); } (arg1)->clear(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoDeviceVector_push_back(lua_State* L) { int SWIG_arg = 0; - std::vector< ofVideoDevice > *arg1 = (std::vector< ofVideoDevice > *) 0 ; ofVideoDevice arg2 ; ofVideoDevice *argp2 ; - SWIG_check_num_args("std::vector< ofVideoDevice >::push_back",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< ofVideoDevice >::push_back",1,"std::vector< ofVideoDevice > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("std::vector< ofVideoDevice >::push_back",2,"ofVideoDevice"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofVideoDevice_t,0))){ - SWIG_fail_ptr("VideoDeviceVector_push_back",1,SWIGTYPE_p_std__vectorT_ofVideoDevice_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofVideoDevice,0))){ - SWIG_fail_ptr("VideoDeviceVector_push_back",2,SWIGTYPE_p_ofVideoDevice); } arg2 = *argp2; (arg1)->push_back(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoDeviceVector_pop_back(lua_State* L) { int SWIG_arg = 0; - std::vector< ofVideoDevice > *arg1 = (std::vector< ofVideoDevice > *) 0 ; - SWIG_check_num_args("std::vector< ofVideoDevice >::pop_back",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< ofVideoDevice >::pop_back",1,"std::vector< ofVideoDevice > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofVideoDevice_t,0))){ - SWIG_fail_ptr("VideoDeviceVector_pop_back",1,SWIGTYPE_p_std__vectorT_ofVideoDevice_t); } (arg1)->pop_back(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoDeviceVector_front(lua_State* L) { int SWIG_arg = 0; - std::vector< ofVideoDevice > *arg1 = (std::vector< ofVideoDevice > *) 0 ; ofVideoDevice result; - SWIG_check_num_args("std::vector< ofVideoDevice >::front",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< ofVideoDevice >::front",1,"std::vector< ofVideoDevice > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofVideoDevice_t,0))){ - SWIG_fail_ptr("VideoDeviceVector_front",1,SWIGTYPE_p_std__vectorT_ofVideoDevice_t); } - result = ((std::vector< ofVideoDevice > const *)arg1)->front(); { - ofVideoDevice * resultptr = new ofVideoDevice((const ofVideoDevice &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVideoDevice,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_VideoDeviceVector_back(lua_State* L) { int SWIG_arg = 0; - std::vector< ofVideoDevice > *arg1 = (std::vector< ofVideoDevice > *) 0 ; ofVideoDevice result; - SWIG_check_num_args("std::vector< ofVideoDevice >::back",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< ofVideoDevice >::back",1,"std::vector< ofVideoDevice > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofVideoDevice_t,0))){ - SWIG_fail_ptr("VideoDeviceVector_back",1,SWIGTYPE_p_std__vectorT_ofVideoDevice_t); } - result = ((std::vector< ofVideoDevice > const *)arg1)->back(); { - ofVideoDevice * resultptr = new ofVideoDevice((const ofVideoDevice &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVideoDevice,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_VideoDeviceVector___getitem(lua_State* L) { int SWIG_arg = 0; - std::vector< ofVideoDevice > *arg1 = (std::vector< ofVideoDevice > *) 0 ; unsigned int arg2 ; ofVideoDevice result; - SWIG_check_num_args("std::vector< ofVideoDevice >::__getitem__",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< ofVideoDevice >::__getitem__",1,"std::vector< ofVideoDevice > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("std::vector< ofVideoDevice >::__getitem__",2,"unsigned int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofVideoDevice_t,0))){ - SWIG_fail_ptr("VideoDeviceVector___getitem",1,SWIGTYPE_p_std__vectorT_ofVideoDevice_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned int)lua_tonumber(L, 2); try { - result = std_vector_Sl_ofVideoDevice_Sg____getitem__(arg1,arg2);} catch(std::out_of_range &_e) { - SWIG_exception(SWIG_IndexError, (&_e)->what()); } { - ofVideoDevice * resultptr = new ofVideoDevice((const ofVideoDevice &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVideoDevice,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_VideoDeviceVector___setitem(lua_State* L) { int SWIG_arg = 0; - std::vector< ofVideoDevice > *arg1 = (std::vector< ofVideoDevice > *) 0 ; unsigned int arg2 ; ofVideoDevice arg3 ; - ofVideoDevice *argp3 ; SWIG_check_num_args("std::vector< ofVideoDevice >::__setitem__",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< ofVideoDevice >::__setitem__",1,"std::vector< ofVideoDevice > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("std::vector< ofVideoDevice >::__setitem__",2,"unsigned int"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("std::vector< ofVideoDevice >::__setitem__",3,"ofVideoDevice"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofVideoDevice_t,0))){ - SWIG_fail_ptr("VideoDeviceVector___setitem",1,SWIGTYPE_p_std__vectorT_ofVideoDevice_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned int)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&argp3,SWIGTYPE_p_ofVideoDevice,0))){ - SWIG_fail_ptr("VideoDeviceVector___setitem",3,SWIGTYPE_p_ofVideoDevice); } arg3 = *argp3; try { - std_vector_Sl_ofVideoDevice_Sg____setitem__(arg1,arg2,arg3);} catch(std::out_of_range &_e) { - SWIG_exception(SWIG_IndexError, (&_e)->what()); } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_VideoDeviceVector(void *obj) { -std::vector< ofVideoDevice > *arg1 = (std::vector< ofVideoDevice > *) obj; -delete arg1; -} -static int _proxy__wrap_new_VideoDeviceVector(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_VideoDeviceVector); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_VideoDeviceVector_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_VideoDeviceVector_methods[]= { - { "size", _wrap_VideoDeviceVector_size}, - { "max_size", _wrap_VideoDeviceVector_max_size}, - { "empty", _wrap_VideoDeviceVector_empty}, - { "clear", _wrap_VideoDeviceVector_clear}, - { "push_back", _wrap_VideoDeviceVector_push_back}, - { "pop_back", _wrap_VideoDeviceVector_pop_back}, - { "front", _wrap_VideoDeviceVector_front}, - { "back", _wrap_VideoDeviceVector_back}, - { "__getitem", _wrap_VideoDeviceVector___getitem}, - { "__setitem", _wrap_VideoDeviceVector___setitem}, - {0,0} -}; -static swig_lua_method swig_VideoDeviceVector_meta[] = { - { "__getitem", _wrap_VideoDeviceVector___getitem}, - { "__setitem", _wrap_VideoDeviceVector___setitem}, - {0,0} -}; - -static swig_lua_attribute swig_VideoDeviceVector_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_VideoDeviceVector_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_VideoDeviceVector_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_VideoDeviceVector_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_VideoDeviceVector_Sf_SwigStatic = { - "VideoDeviceVector", - swig_VideoDeviceVector_Sf_SwigStatic_methods, - swig_VideoDeviceVector_Sf_SwigStatic_attributes, - swig_VideoDeviceVector_Sf_SwigStatic_constants, - swig_VideoDeviceVector_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_VideoDeviceVector_bases[] = {0}; -static const char *swig_VideoDeviceVector_base_names[] = {0}; -static swig_lua_class _wrap_class_VideoDeviceVector = { "VideoDeviceVector", "VideoDeviceVector", &SWIGTYPE_p_std__vectorT_ofVideoDevice_t,_proxy__wrap_new_VideoDeviceVector, swig_delete_VideoDeviceVector, swig_VideoDeviceVector_methods, swig_VideoDeviceVector_attributes, &swig_VideoDeviceVector_Sf_SwigStatic, swig_VideoDeviceVector_meta, swig_VideoDeviceVector_bases, swig_VideoDeviceVector_base_names }; - -static int _wrap_new_TextureVector__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::vector< ofTexture > *result = 0 ; - SWIG_check_num_args("std::vector< ofTexture >::vector",0,0) - result = (std::vector< ofTexture > *)new std::vector< ofTexture >(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofTexture_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_TextureVector__SWIG_1(lua_State* L) { int SWIG_arg = 0; unsigned int arg1 ; - std::vector< ofTexture > *result = 0 ; SWIG_check_num_args("std::vector< ofTexture >::vector",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("std::vector< ofTexture >::vector",1,"unsigned int"); - SWIG_contract_assert((lua_tonumber(L,1)>=0),"number must not be negative") arg1 = (unsigned int)lua_tonumber(L, 1); - result = (std::vector< ofTexture > *)new std::vector< ofTexture >(arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofTexture_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_TextureVector__SWIG_2(lua_State* L) { int SWIG_arg = 0; std::vector< ofTexture > *arg1 = 0 ; - std::vector< ofTexture > *result = 0 ; SWIG_check_num_args("std::vector< ofTexture >::vector",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("std::vector< ofTexture >::vector",1,"std::vector< ofTexture > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofTexture_t,0))){ - SWIG_fail_ptr("new_TextureVector",1,SWIGTYPE_p_std__vectorT_ofTexture_t); } - result = (std::vector< ofTexture > *)new std::vector< ofTexture >((std::vector< ofTexture > const &)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofTexture_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_TextureVector__SWIG_3(lua_State* L) { int SWIG_arg = 0; unsigned int arg1 ; ofTexture arg2 ; - ofTexture *argp2 ; std::vector< ofTexture > *result = 0 ; SWIG_check_num_args("std::vector< ofTexture >::vector",2,2) - if(!lua_isnumber(L,1)) SWIG_fail_arg("std::vector< ofTexture >::vector",1,"unsigned int"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("std::vector< ofTexture >::vector",2,"ofTexture"); - SWIG_contract_assert((lua_tonumber(L,1)>=0),"number must not be negative") arg1 = (unsigned int)lua_tonumber(L, 1); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("new_TextureVector",2,SWIGTYPE_p_ofTexture); } arg2 = *argp2; - result = (std::vector< ofTexture > *)new std::vector< ofTexture >(arg1,arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofTexture_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_TextureVector(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_TextureVector__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_std__vectorT_ofTexture_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_new_TextureVector__SWIG_2(L);} } if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_new_TextureVector__SWIG_1(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_new_TextureVector__SWIG_3(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_TextureVector'\n" " Possible C/C++ prototypes are:\n" - " std::vector< ofTexture >::vector()\n" " std::vector< ofTexture >::vector(unsigned int)\n" - " std::vector< ofTexture >::vector(std::vector< ofTexture > const &)\n" - " std::vector< ofTexture >::vector(unsigned int,ofTexture)\n"); lua_error(L);return 0; } -static int _wrap_TextureVector_size(lua_State* L) { int SWIG_arg = 0; - std::vector< ofTexture > *arg1 = (std::vector< ofTexture > *) 0 ; unsigned int result; - SWIG_check_num_args("std::vector< ofTexture >::size",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< ofTexture >::size",1,"std::vector< ofTexture > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofTexture_t,0))){ - SWIG_fail_ptr("TextureVector_size",1,SWIGTYPE_p_std__vectorT_ofTexture_t); } - result = (unsigned int)((std::vector< ofTexture > const *)arg1)->size(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureVector_max_size(lua_State* L) { int SWIG_arg = 0; - std::vector< ofTexture > *arg1 = (std::vector< ofTexture > *) 0 ; unsigned int result; - SWIG_check_num_args("std::vector< ofTexture >::max_size",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< ofTexture >::max_size",1,"std::vector< ofTexture > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofTexture_t,0))){ - SWIG_fail_ptr("TextureVector_max_size",1,SWIGTYPE_p_std__vectorT_ofTexture_t); } - result = (unsigned int)((std::vector< ofTexture > const *)arg1)->max_size(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureVector_empty(lua_State* L) { int SWIG_arg = 0; - std::vector< ofTexture > *arg1 = (std::vector< ofTexture > *) 0 ; bool result; - SWIG_check_num_args("std::vector< ofTexture >::empty",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< ofTexture >::empty",1,"std::vector< ofTexture > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofTexture_t,0))){ - SWIG_fail_ptr("TextureVector_empty",1,SWIGTYPE_p_std__vectorT_ofTexture_t); } - result = (bool)((std::vector< ofTexture > const *)arg1)->empty(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureVector_clear(lua_State* L) { int SWIG_arg = 0; - std::vector< ofTexture > *arg1 = (std::vector< ofTexture > *) 0 ; SWIG_check_num_args("std::vector< ofTexture >::clear",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< ofTexture >::clear",1,"std::vector< ofTexture > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofTexture_t,0))){ - SWIG_fail_ptr("TextureVector_clear",1,SWIGTYPE_p_std__vectorT_ofTexture_t); } (arg1)->clear(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureVector_push_back(lua_State* L) { int SWIG_arg = 0; - std::vector< ofTexture > *arg1 = (std::vector< ofTexture > *) 0 ; ofTexture arg2 ; ofTexture *argp2 ; - SWIG_check_num_args("std::vector< ofTexture >::push_back",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< ofTexture >::push_back",1,"std::vector< ofTexture > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("std::vector< ofTexture >::push_back",2,"ofTexture"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofTexture_t,0))){ - SWIG_fail_ptr("TextureVector_push_back",1,SWIGTYPE_p_std__vectorT_ofTexture_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("TextureVector_push_back",2,SWIGTYPE_p_ofTexture); } arg2 = *argp2; (arg1)->push_back(arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureVector_pop_back(lua_State* L) { int SWIG_arg = 0; - std::vector< ofTexture > *arg1 = (std::vector< ofTexture > *) 0 ; - SWIG_check_num_args("std::vector< ofTexture >::pop_back",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< ofTexture >::pop_back",1,"std::vector< ofTexture > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofTexture_t,0))){ - SWIG_fail_ptr("TextureVector_pop_back",1,SWIGTYPE_p_std__vectorT_ofTexture_t); } (arg1)->pop_back(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureVector_front(lua_State* L) { int SWIG_arg = 0; - std::vector< ofTexture > *arg1 = (std::vector< ofTexture > *) 0 ; ofTexture result; - SWIG_check_num_args("std::vector< ofTexture >::front",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< ofTexture >::front",1,"std::vector< ofTexture > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofTexture_t,0))){ - SWIG_fail_ptr("TextureVector_front",1,SWIGTYPE_p_std__vectorT_ofTexture_t); } - result = ((std::vector< ofTexture > const *)arg1)->front(); { - ofTexture * resultptr = new ofTexture((const ofTexture &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofTexture,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_TextureVector_back(lua_State* L) { int SWIG_arg = 0; - std::vector< ofTexture > *arg1 = (std::vector< ofTexture > *) 0 ; ofTexture result; - SWIG_check_num_args("std::vector< ofTexture >::back",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< ofTexture >::back",1,"std::vector< ofTexture > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofTexture_t,0))){ - SWIG_fail_ptr("TextureVector_back",1,SWIGTYPE_p_std__vectorT_ofTexture_t); } - result = ((std::vector< ofTexture > const *)arg1)->back(); { - ofTexture * resultptr = new ofTexture((const ofTexture &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofTexture,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_TextureVector___getitem(lua_State* L) { int SWIG_arg = 0; - std::vector< ofTexture > *arg1 = (std::vector< ofTexture > *) 0 ; unsigned int arg2 ; ofTexture result; - SWIG_check_num_args("std::vector< ofTexture >::__getitem__",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< ofTexture >::__getitem__",1,"std::vector< ofTexture > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("std::vector< ofTexture >::__getitem__",2,"unsigned int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofTexture_t,0))){ - SWIG_fail_ptr("TextureVector___getitem",1,SWIGTYPE_p_std__vectorT_ofTexture_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned int)lua_tonumber(L, 2); try { - result = std_vector_Sl_ofTexture_Sg____getitem__(arg1,arg2);} catch(std::out_of_range &_e) { - SWIG_exception(SWIG_IndexError, (&_e)->what()); } { ofTexture * resultptr = new ofTexture((const ofTexture &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofTexture,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_TextureVector___setitem(lua_State* L) { int SWIG_arg = 0; - std::vector< ofTexture > *arg1 = (std::vector< ofTexture > *) 0 ; unsigned int arg2 ; ofTexture arg3 ; ofTexture *argp3 ; - SWIG_check_num_args("std::vector< ofTexture >::__setitem__",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< ofTexture >::__setitem__",1,"std::vector< ofTexture > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("std::vector< ofTexture >::__setitem__",2,"unsigned int"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("std::vector< ofTexture >::__setitem__",3,"ofTexture"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofTexture_t,0))){ - SWIG_fail_ptr("TextureVector___setitem",1,SWIGTYPE_p_std__vectorT_ofTexture_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned int)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&argp3,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("TextureVector___setitem",3,SWIGTYPE_p_ofTexture); } arg3 = *argp3; try { - std_vector_Sl_ofTexture_Sg____setitem__(arg1,arg2,arg3);} catch(std::out_of_range &_e) { - SWIG_exception(SWIG_IndexError, (&_e)->what()); } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_TextureVector(void *obj) { -std::vector< ofTexture > *arg1 = (std::vector< ofTexture > *) obj; -delete arg1; -} -static int _proxy__wrap_new_TextureVector(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_TextureVector); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_TextureVector_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_TextureVector_methods[]= { - { "size", _wrap_TextureVector_size}, - { "max_size", _wrap_TextureVector_max_size}, - { "empty", _wrap_TextureVector_empty}, - { "clear", _wrap_TextureVector_clear}, - { "push_back", _wrap_TextureVector_push_back}, - { "pop_back", _wrap_TextureVector_pop_back}, - { "front", _wrap_TextureVector_front}, - { "back", _wrap_TextureVector_back}, - { "__getitem", _wrap_TextureVector___getitem}, - { "__setitem", _wrap_TextureVector___setitem}, - {0,0} -}; -static swig_lua_method swig_TextureVector_meta[] = { - { "__getitem", _wrap_TextureVector___getitem}, - { "__setitem", _wrap_TextureVector___setitem}, - {0,0} -}; - -static swig_lua_attribute swig_TextureVector_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_TextureVector_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_TextureVector_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_TextureVector_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_TextureVector_Sf_SwigStatic = { - "TextureVector", - swig_TextureVector_Sf_SwigStatic_methods, - swig_TextureVector_Sf_SwigStatic_attributes, - swig_TextureVector_Sf_SwigStatic_constants, - swig_TextureVector_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_TextureVector_bases[] = {0}; -static const char *swig_TextureVector_base_names[] = {0}; -static swig_lua_class _wrap_class_TextureVector = { "TextureVector", "TextureVector", &SWIGTYPE_p_std__vectorT_ofTexture_t,_proxy__wrap_new_TextureVector, swig_delete_TextureVector, swig_TextureVector_methods, swig_TextureVector_attributes, &swig_TextureVector_Sf_SwigStatic, swig_TextureVector_meta, swig_TextureVector_bases, swig_TextureVector_base_names }; - -static int _wrap_new_Fbo__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofFbo *result = 0 ; SWIG_check_num_args("ofFbo::ofFbo",0,0) - result = (ofFbo *)new ofFbo(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofFbo,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_new_Fbo__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = 0 ; ofFbo *result = 0 ; - SWIG_check_num_args("ofFbo::ofFbo",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofFbo::ofFbo",1,"ofFbo &&"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("new_Fbo",1,SWIGTYPE_p_ofFbo); } - result = (ofFbo *)new ofFbo((ofFbo &&)*arg1); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofFbo,1); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_new_Fbo(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_Fbo__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_new_Fbo__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_Fbo'\n" " Possible C/C++ prototypes are:\n" - " ofFbo::ofFbo()\n" " ofFbo::ofFbo(ofFbo &&)\n"); lua_error(L);return 0; } -static int _wrap_Fbo_allocate__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; int arg2 ; int arg3 ; - int arg4 ; int arg5 ; SWIG_check_num_args("ofFbo::allocate",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::allocate",1,"ofFbo *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofFbo::allocate",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofFbo::allocate",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofFbo::allocate",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofFbo::allocate",5,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_allocate",1,SWIGTYPE_p_ofFbo); } - arg2 = (int)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - arg5 = (int)lua_tonumber(L, 5); (arg1)->allocate(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Fbo_allocate__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; int arg2 ; int arg3 ; - int arg4 ; SWIG_check_num_args("ofFbo::allocate",4,4) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::allocate",1,"ofFbo *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofFbo::allocate",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofFbo::allocate",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofFbo::allocate",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_allocate",1,SWIGTYPE_p_ofFbo); } - arg2 = (int)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - (arg1)->allocate(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_allocate__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; int arg2 ; int arg3 ; - SWIG_check_num_args("ofFbo::allocate",3,3) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::allocate",1,"ofFbo *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofFbo::allocate",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofFbo::allocate",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_allocate",1,SWIGTYPE_p_ofFbo); } - arg2 = (int)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); (arg1)->allocate(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_allocate__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; ofFbo::Settings arg2 ; - ofFbo::Settings *argp2 ; SWIG_check_num_args("ofFbo::allocate",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::allocate",1,"ofFbo *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofFbo::allocate",2,"ofFbo::Settings"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_allocate",1,SWIGTYPE_p_ofFbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofFbo__Settings,0))){ - SWIG_fail_ptr("Fbo_allocate",2,SWIGTYPE_p_ofFbo__Settings); } arg2 = *argp2; (arg1)->allocate(arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_allocate__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; - SWIG_check_num_args("ofFbo::allocate",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::allocate",1,"ofFbo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_allocate",1,SWIGTYPE_p_ofFbo); } - (arg1)->allocate(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_allocate(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Fbo_allocate__SWIG_4(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofFbo__Settings, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Fbo_allocate__SWIG_3(L);} } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Fbo_allocate__SWIG_2(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Fbo_allocate__SWIG_1(L);} } } } } if (argc == 5) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Fbo_allocate__SWIG_0(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Fbo_allocate'\n" " Possible C/C++ prototypes are:\n" - " ofFbo::allocate(int,int,int,int)\n" " ofFbo::allocate(int,int,int)\n" " ofFbo::allocate(int,int)\n" - " ofFbo::allocate(ofFbo::Settings)\n" " ofFbo::allocate()\n"); lua_error(L);return 0; } -static int _wrap_Fbo_isAllocated(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; bool result; - SWIG_check_num_args("ofFbo::isAllocated",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::isAllocated",1,"ofFbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_isAllocated",1,SWIGTYPE_p_ofFbo); } - result = (bool)((ofFbo const *)arg1)->isAllocated(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_clear(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; SWIG_check_num_args("ofFbo::clear",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::clear",1,"ofFbo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_clear",1,SWIGTYPE_p_ofFbo); } - (arg1)->clear(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_draw__SWIG_0_0(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; ofPoint *arg2 = 0 ; - SWIG_check_num_args("draw",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("draw",1,"ofFbo const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("draw",2,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_draw",1,SWIGTYPE_p_ofFbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Fbo_draw",2,SWIGTYPE_p_ofVec3f); } - ((ofFbo const *)arg1)->draw((ofPoint const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_draw__SWIG_0_1(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; ofRectangle *arg2 = 0 ; - SWIG_check_num_args("draw",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("draw",1,"ofFbo const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("draw",2,"ofRectangle const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_draw",1,SWIGTYPE_p_ofFbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Fbo_draw",2,SWIGTYPE_p_ofRectangle); } ((ofFbo const *)arg1)->draw((ofRectangle const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_draw__SWIG_0_2(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; ofPoint *arg2 = 0 ; - float arg3 ; float arg4 ; SWIG_check_num_args("draw",4,4) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("draw",1,"ofFbo const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("draw",2,"ofPoint const &"); if(!lua_isnumber(L,3)) SWIG_fail_arg("draw",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("draw",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_draw",1,SWIGTYPE_p_ofFbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Fbo_draw",2,SWIGTYPE_p_ofVec3f); } - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - ((ofFbo const *)arg1)->draw((ofPoint const &)*arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Fbo_draw__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofFbo::draw",3,3) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::draw",1,"ofFbo const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofFbo::draw",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofFbo::draw",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_draw",1,SWIGTYPE_p_ofFbo); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); ((ofFbo const *)arg1)->draw(arg2,arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_draw__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; float arg2 ; float arg3 ; - float arg4 ; float arg5 ; SWIG_check_num_args("ofFbo::draw",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::draw",1,"ofFbo const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofFbo::draw",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofFbo::draw",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofFbo::draw",4,"float"); if(!lua_isnumber(L,5)) SWIG_fail_arg("ofFbo::draw",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_draw",1,SWIGTYPE_p_ofFbo); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); ((ofFbo const *)arg1)->draw(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_draw(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 2) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Fbo_draw__SWIG_0_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Fbo_draw__SWIG_0_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Fbo_draw__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Fbo_draw__SWIG_0_2(L);} } } } } if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Fbo_draw__SWIG_2(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Fbo_draw'\n" " Possible C/C++ prototypes are:\n" - " draw(ofPoint const &) const\n" " draw(ofRectangle const &) const\n" " draw(ofPoint const &,float,float) const\n" - " ofFbo::draw(float,float) const\n" " ofFbo::draw(float,float,float,float) const\n"); lua_error(L);return 0; } -static int _wrap_Fbo_setAnchorPercent(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofFbo::setAnchorPercent",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::setAnchorPercent",1,"ofFbo *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofFbo::setAnchorPercent",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofFbo::setAnchorPercent",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ - SWIG_fail_ptr("Fbo_setAnchorPercent",1,SWIGTYPE_p_ofFbo); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->setAnchorPercent(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Fbo_setAnchorPoint(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofFbo::setAnchorPoint",3,3) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::setAnchorPoint",1,"ofFbo *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofFbo::setAnchorPoint",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofFbo::setAnchorPoint",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ - SWIG_fail_ptr("Fbo_setAnchorPoint",1,SWIGTYPE_p_ofFbo); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->setAnchorPoint(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Fbo_resetAnchor(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; - SWIG_check_num_args("ofFbo::resetAnchor",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::resetAnchor",1,"ofFbo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_resetAnchor",1,SWIGTYPE_p_ofFbo); } - (arg1)->resetAnchor(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_setDefaultTextureIndex(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; int arg2 ; - SWIG_check_num_args("ofFbo::setDefaultTextureIndex",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::setDefaultTextureIndex",1,"ofFbo *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofFbo::setDefaultTextureIndex",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ - SWIG_fail_ptr("Fbo_setDefaultTextureIndex",1,SWIGTYPE_p_ofFbo); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->setDefaultTextureIndex(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_getDefaultTextureIndex(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; int result; - SWIG_check_num_args("ofFbo::getDefaultTextureIndex",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::getDefaultTextureIndex",1,"ofFbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ - SWIG_fail_ptr("Fbo_getDefaultTextureIndex",1,SWIGTYPE_p_ofFbo); } - result = (int)((ofFbo const *)arg1)->getDefaultTextureIndex(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_getTexture__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; ofTexture *result = 0 ; - SWIG_check_num_args("ofFbo::getTexture",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::getTexture",1,"ofFbo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_getTexture",1,SWIGTYPE_p_ofFbo); } - result = (ofTexture *) &(arg1)->getTexture(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTexture,0); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_getTexture__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; int arg2 ; - ofTexture *result = 0 ; SWIG_check_num_args("ofFbo::getTexture",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::getTexture",1,"ofFbo *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofFbo::getTexture",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_getTexture",1,SWIGTYPE_p_ofFbo); } - arg2 = (int)lua_tonumber(L, 2); result = (ofTexture *) &(arg1)->getTexture(arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTexture,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Fbo_getDepthTexture__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; - ofTexture *result = 0 ; SWIG_check_num_args("ofFbo::getDepthTexture",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::getDepthTexture",1,"ofFbo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ - SWIG_fail_ptr("Fbo_getDepthTexture",1,SWIGTYPE_p_ofFbo); } result = (ofTexture *) &(arg1)->getDepthTexture(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTexture,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Fbo_getTexture__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; ofTexture *result = 0 ; - SWIG_check_num_args("ofFbo::getTexture",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::getTexture",1,"ofFbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_getTexture",1,SWIGTYPE_p_ofFbo); } - result = (ofTexture *) &((ofFbo const *)arg1)->getTexture(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTexture,0); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_getTexture__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; int arg2 ; - ofTexture *result = 0 ; SWIG_check_num_args("ofFbo::getTexture",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::getTexture",1,"ofFbo const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofFbo::getTexture",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_getTexture",1,SWIGTYPE_p_ofFbo); } - arg2 = (int)lua_tonumber(L, 2); result = (ofTexture *) &((ofFbo const *)arg1)->getTexture(arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTexture,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Fbo_getTexture(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Fbo_getTexture__SWIG_0(L);} } if (argc == 1) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_Fbo_getTexture__SWIG_2(L);} } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Fbo_getTexture__SWIG_1(L);} } } - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Fbo_getTexture__SWIG_3(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Fbo_getTexture'\n" " Possible C/C++ prototypes are:\n" - " ofFbo::getTexture()\n" " ofFbo::getTexture(int)\n" " ofFbo::getTexture() const\n" - " ofFbo::getTexture(int) const\n"); lua_error(L);return 0; } -static int _wrap_Fbo_getDepthTexture__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; - ofTexture *result = 0 ; SWIG_check_num_args("ofFbo::getDepthTexture",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::getDepthTexture",1,"ofFbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ - SWIG_fail_ptr("Fbo_getDepthTexture",1,SWIGTYPE_p_ofFbo); } - result = (ofTexture *) &((ofFbo const *)arg1)->getDepthTexture(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTexture,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Fbo_getDepthTexture(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Fbo_getDepthTexture__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Fbo_getDepthTexture__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Fbo_getDepthTexture'\n" - " Possible C/C++ prototypes are:\n" " ofFbo::getDepthTexture()\n" " ofFbo::getDepthTexture() const\n"); - lua_error(L);return 0; } -static int _wrap_Fbo_beginFbo__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; bool arg2 ; - SWIG_check_num_args("ofFbo::begin",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::begin",1,"ofFbo const *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofFbo::begin",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_beginFbo",1,SWIGTYPE_p_ofFbo); } - arg2 = (lua_toboolean(L, 2)!=0); ((ofFbo const *)arg1)->begin(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Fbo_beginFbo__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; - SWIG_check_num_args("ofFbo::begin",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::begin",1,"ofFbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_beginFbo",1,SWIGTYPE_p_ofFbo); } - ((ofFbo const *)arg1)->begin(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_beginFbo(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Fbo_beginFbo__SWIG_1(L);} } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { return _wrap_Fbo_beginFbo__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Fbo_beginFbo'\n" " Possible C/C++ prototypes are:\n" - " ofFbo::begin(bool) const\n" " ofFbo::begin() const\n"); lua_error(L);return 0; } -static int _wrap_Fbo_endFbo(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; SWIG_check_num_args("ofFbo::end",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::end",1,"ofFbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_endFbo",1,SWIGTYPE_p_ofFbo); } - ((ofFbo const *)arg1)->end(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_readToPixels__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; ofPixels *arg2 = 0 ; - int arg3 ; SWIG_check_num_args("ofFbo::readToPixels",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::readToPixels",1,"ofFbo const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofFbo::readToPixels",2,"ofPixels &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofFbo::readToPixels",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_readToPixels",1,SWIGTYPE_p_ofFbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Fbo_readToPixels",2,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } arg3 = (int)lua_tonumber(L, 3); - ((ofFbo const *)arg1)->readToPixels(*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_readToPixels__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; ofPixels *arg2 = 0 ; - SWIG_check_num_args("ofFbo::readToPixels",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::readToPixels",1,"ofFbo const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofFbo::readToPixels",2,"ofPixels &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_readToPixels",1,SWIGTYPE_p_ofFbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Fbo_readToPixels",2,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } ((ofFbo const *)arg1)->readToPixels(*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_readToPixels__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; - ofShortPixels *arg2 = 0 ; int arg3 ; SWIG_check_num_args("ofFbo::readToPixels",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::readToPixels",1,"ofFbo const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofFbo::readToPixels",2,"ofShortPixels &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofFbo::readToPixels",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_readToPixels",1,SWIGTYPE_p_ofFbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("Fbo_readToPixels",2,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } arg3 = (int)lua_tonumber(L, 3); - ((ofFbo const *)arg1)->readToPixels(*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_readToPixels__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; - ofShortPixels *arg2 = 0 ; SWIG_check_num_args("ofFbo::readToPixels",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::readToPixels",1,"ofFbo const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofFbo::readToPixels",2,"ofShortPixels &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_readToPixels",1,SWIGTYPE_p_ofFbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("Fbo_readToPixels",2,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } ((ofFbo const *)arg1)->readToPixels(*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_readToPixels__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; - ofFloatPixels *arg2 = 0 ; int arg3 ; SWIG_check_num_args("ofFbo::readToPixels",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::readToPixels",1,"ofFbo const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofFbo::readToPixels",2,"ofFloatPixels &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofFbo::readToPixels",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_readToPixels",1,SWIGTYPE_p_ofFbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("Fbo_readToPixels",2,SWIGTYPE_p_ofPixels_T_float_t); } arg3 = (int)lua_tonumber(L, 3); - ((ofFbo const *)arg1)->readToPixels(*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_readToPixels__SWIG_5(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; - ofFloatPixels *arg2 = 0 ; SWIG_check_num_args("ofFbo::readToPixels",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::readToPixels",1,"ofFbo const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofFbo::readToPixels",2,"ofFloatPixels &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_readToPixels",1,SWIGTYPE_p_ofFbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("Fbo_readToPixels",2,SWIGTYPE_p_ofPixels_T_float_t); } ((ofFbo const *)arg1)->readToPixels(*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_readToPixels(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Fbo_readToPixels__SWIG_1(L);} } } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Fbo_readToPixels__SWIG_3(L);} } } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Fbo_readToPixels__SWIG_5(L);} } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Fbo_readToPixels__SWIG_0(L);} } } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Fbo_readToPixels__SWIG_4(L);} } } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Fbo_readToPixels__SWIG_2(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Fbo_readToPixels'\n" " Possible C/C++ prototypes are:\n" - " ofFbo::readToPixels(ofPixels &,int) const\n" " ofFbo::readToPixels(ofPixels &) const\n" - " ofFbo::readToPixels(ofShortPixels &,int) const\n" " ofFbo::readToPixels(ofShortPixels &) const\n" - " ofFbo::readToPixels(ofFloatPixels &,int) const\n" " ofFbo::readToPixels(ofFloatPixels &) const\n"); - lua_error(L);return 0; } -static int _wrap_Fbo_getWidth(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; float result; - SWIG_check_num_args("ofFbo::getWidth",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::getWidth",1,"ofFbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_getWidth",1,SWIGTYPE_p_ofFbo); } - result = (float)((ofFbo const *)arg1)->getWidth(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_getHeight(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; float result; - SWIG_check_num_args("ofFbo::getHeight",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::getHeight",1,"ofFbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_getHeight",1,SWIGTYPE_p_ofFbo); } - result = (float)((ofFbo const *)arg1)->getHeight(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_bind(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; SWIG_check_num_args("ofFbo::bind",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::bind",1,"ofFbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_bind",1,SWIGTYPE_p_ofFbo); } - ((ofFbo const *)arg1)->bind(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_unbind(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; - SWIG_check_num_args("ofFbo::unbind",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::unbind",1,"ofFbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_unbind",1,SWIGTYPE_p_ofFbo); } - ((ofFbo const *)arg1)->unbind(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_flagDirty(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; - SWIG_check_num_args("ofFbo::flagDirty",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::flagDirty",1,"ofFbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_flagDirty",1,SWIGTYPE_p_ofFbo); } - ((ofFbo const *)arg1)->flagDirty(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_updateTexture(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; int arg2 ; - SWIG_check_num_args("ofFbo::updateTexture",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::updateTexture",1,"ofFbo *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofFbo::updateTexture",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ - SWIG_fail_ptr("Fbo_updateTexture",1,SWIGTYPE_p_ofFbo); } arg2 = (int)lua_tonumber(L, 2); (arg1)->updateTexture(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_checkStatus(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; bool result; - SWIG_check_num_args("ofFbo::checkStatus",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::checkStatus",1,"ofFbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_checkStatus",1,SWIGTYPE_p_ofFbo); } - result = (bool)((ofFbo const *)arg1)->checkStatus(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_createAndAttachTexture(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; GLenum arg2 ; - GLenum arg3 ; SWIG_check_num_args("ofFbo::createAndAttachTexture",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::createAndAttachTexture",1,"ofFbo *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofFbo::createAndAttachTexture",2,"GLenum"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofFbo::createAndAttachTexture",3,"GLenum"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ - SWIG_fail_ptr("Fbo_createAndAttachTexture",1,SWIGTYPE_p_ofFbo); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (GLenum)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (GLenum)lua_tonumber(L, 3); - (arg1)->createAndAttachTexture(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_attachTexture(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; ofTexture *arg2 = 0 ; - GLenum arg3 ; GLenum arg4 ; SWIG_check_num_args("ofFbo::attachTexture",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::attachTexture",1,"ofFbo *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofFbo::attachTexture",2,"ofTexture &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofFbo::attachTexture",3,"GLenum"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofFbo::attachTexture",4,"GLenum"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ - SWIG_fail_ptr("Fbo_attachTexture",1,SWIGTYPE_p_ofFbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Fbo_attachTexture",2,SWIGTYPE_p_ofTexture); } - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (GLenum)lua_tonumber(L, 3); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (GLenum)lua_tonumber(L, 4); - (arg1)->attachTexture(*arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_createAndAttachRenderbuffer(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; GLenum arg2 ; - GLenum arg3 ; GLuint result; SWIG_check_num_args("ofFbo::createAndAttachRenderbuffer",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::createAndAttachRenderbuffer",1,"ofFbo *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofFbo::createAndAttachRenderbuffer",2,"GLenum"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofFbo::createAndAttachRenderbuffer",3,"GLenum"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ - SWIG_fail_ptr("Fbo_createAndAttachRenderbuffer",1,SWIGTYPE_p_ofFbo); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (GLenum)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (GLenum)lua_tonumber(L, 3); - result = (GLuint)(arg1)->createAndAttachRenderbuffer(arg2,arg3); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_createAndAttachDepthStencilTexture__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; - GLenum arg2 ; GLint arg3 ; GLenum arg4 ; SWIG_check_num_args("ofFbo::createAndAttachDepthStencilTexture",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::createAndAttachDepthStencilTexture",1,"ofFbo *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofFbo::createAndAttachDepthStencilTexture",2,"GLenum"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofFbo::createAndAttachDepthStencilTexture",3,"GLint"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofFbo::createAndAttachDepthStencilTexture",4,"GLenum"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ - SWIG_fail_ptr("Fbo_createAndAttachDepthStencilTexture",1,SWIGTYPE_p_ofFbo); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (GLenum)lua_tonumber(L, 2); - arg3 = (GLint)lua_tonumber(L, 3); SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") - arg4 = (GLenum)lua_tonumber(L, 4); (arg1)->createAndAttachDepthStencilTexture(arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_createAndAttachDepthStencilTexture__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; - GLenum arg2 ; GLint arg3 ; GLenum arg4 ; GLenum arg5 ; GLenum arg6 ; - SWIG_check_num_args("ofFbo::createAndAttachDepthStencilTexture",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::createAndAttachDepthStencilTexture",1,"ofFbo *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofFbo::createAndAttachDepthStencilTexture",2,"GLenum"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofFbo::createAndAttachDepthStencilTexture",3,"GLint"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofFbo::createAndAttachDepthStencilTexture",4,"GLenum"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofFbo::createAndAttachDepthStencilTexture",5,"GLenum"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofFbo::createAndAttachDepthStencilTexture",6,"GLenum"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ - SWIG_fail_ptr("Fbo_createAndAttachDepthStencilTexture",1,SWIGTYPE_p_ofFbo); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (GLenum)lua_tonumber(L, 2); - arg3 = (GLint)lua_tonumber(L, 3); SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") - arg4 = (GLenum)lua_tonumber(L, 4); SWIG_contract_assert((lua_tonumber(L,5)>=0),"number must not be negative") - arg5 = (GLenum)lua_tonumber(L, 5); SWIG_contract_assert((lua_tonumber(L,6)>=0),"number must not be negative") - arg6 = (GLenum)lua_tonumber(L, 6); (arg1)->createAndAttachDepthStencilTexture(arg2,arg3,arg4,arg5,arg6); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_createAndAttachDepthStencilTexture(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; - argc = lua_gettop(L); if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Fbo_createAndAttachDepthStencilTexture__SWIG_0(L);} } } } - } if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { return _wrap_Fbo_createAndAttachDepthStencilTexture__SWIG_1(L);} } } - } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Fbo_createAndAttachDepthStencilTexture'\n" - " Possible C/C++ prototypes are:\n" " ofFbo::createAndAttachDepthStencilTexture(GLenum,GLint,GLenum)\n" - " ofFbo::createAndAttachDepthStencilTexture(GLenum,GLint,GLenum,GLenum,GLenum)\n"); lua_error(L);return 0; } -static int _wrap_Fbo_getNumTextures(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; int result; - SWIG_check_num_args("ofFbo::getNumTextures",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::getNumTextures",1,"ofFbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ - SWIG_fail_ptr("Fbo_getNumTextures",1,SWIGTYPE_p_ofFbo); } result = (int)((ofFbo const *)arg1)->getNumTextures(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_setActiveDrawBuffer(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; int arg2 ; - SWIG_check_num_args("ofFbo::setActiveDrawBuffer",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::setActiveDrawBuffer",1,"ofFbo *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofFbo::setActiveDrawBuffer",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ - SWIG_fail_ptr("Fbo_setActiveDrawBuffer",1,SWIGTYPE_p_ofFbo); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->setActiveDrawBuffer(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_activateAllDrawBuffers(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; - SWIG_check_num_args("ofFbo::activateAllDrawBuffers",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::activateAllDrawBuffers",1,"ofFbo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ - SWIG_fail_ptr("Fbo_activateAllDrawBuffers",1,SWIGTYPE_p_ofFbo); } (arg1)->activateAllDrawBuffers(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_getId(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; GLuint result; - SWIG_check_num_args("ofFbo::getId",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::getId",1,"ofFbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_getId",1,SWIGTYPE_p_ofFbo); } - result = (GLuint)((ofFbo const *)arg1)->getId(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_getIdDrawBuffer(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; GLuint result; - SWIG_check_num_args("ofFbo::getIdDrawBuffer",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::getIdDrawBuffer",1,"ofFbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ - SWIG_fail_ptr("Fbo_getIdDrawBuffer",1,SWIGTYPE_p_ofFbo); } result = (GLuint)((ofFbo const *)arg1)->getIdDrawBuffer(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_checkGLSupport(lua_State* L) { int SWIG_arg = 0; bool result; - SWIG_check_num_args("ofFbo::checkGLSupport",0,0) result = (bool)ofFbo::checkGLSupport(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_maxColorAttachments(lua_State* L) { int SWIG_arg = 0; int result; - SWIG_check_num_args("ofFbo::maxColorAttachments",0,0) result = (int)ofFbo::maxColorAttachments(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_maxDrawBuffers(lua_State* L) { int SWIG_arg = 0; int result; - SWIG_check_num_args("ofFbo::maxDrawBuffers",0,0) result = (int)ofFbo::maxDrawBuffers(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_maxSamples(lua_State* L) { int SWIG_arg = 0; int result; SWIG_check_num_args("ofFbo::maxSamples",0,0) - result = (int)ofFbo::maxSamples(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_getDepthBuffer(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; GLuint result; - SWIG_check_num_args("ofFbo::getDepthBuffer",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::getDepthBuffer",1,"ofFbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ - SWIG_fail_ptr("Fbo_getDepthBuffer",1,SWIGTYPE_p_ofFbo); } result = (GLuint)((ofFbo const *)arg1)->getDepthBuffer(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_getStencilBuffer(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; GLuint result; - SWIG_check_num_args("ofFbo::getStencilBuffer",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::getStencilBuffer",1,"ofFbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ - SWIG_fail_ptr("Fbo_getStencilBuffer",1,SWIGTYPE_p_ofFbo); } result = (GLuint)((ofFbo const *)arg1)->getStencilBuffer(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_Fbo(void *obj) { -ofFbo *arg1 = (ofFbo *) obj; -delete arg1; -} -static int _proxy__wrap_new_Fbo(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_Fbo); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_Fbo_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_Fbo_methods[]= { - { "allocate", _wrap_Fbo_allocate}, - { "isAllocated", _wrap_Fbo_isAllocated}, - { "clear", _wrap_Fbo_clear}, - { "draw", _wrap_Fbo_draw}, - { "setAnchorPercent", _wrap_Fbo_setAnchorPercent}, - { "setAnchorPoint", _wrap_Fbo_setAnchorPoint}, - { "resetAnchor", _wrap_Fbo_resetAnchor}, - { "setDefaultTextureIndex", _wrap_Fbo_setDefaultTextureIndex}, - { "getDefaultTextureIndex", _wrap_Fbo_getDefaultTextureIndex}, - { "getTexture", _wrap_Fbo_getTexture}, - { "getDepthTexture", _wrap_Fbo_getDepthTexture}, - { "beginFbo", _wrap_Fbo_beginFbo}, - { "endFbo", _wrap_Fbo_endFbo}, - { "readToPixels", _wrap_Fbo_readToPixels}, - { "getWidth", _wrap_Fbo_getWidth}, - { "getHeight", _wrap_Fbo_getHeight}, - { "bind", _wrap_Fbo_bind}, - { "unbind", _wrap_Fbo_unbind}, - { "flagDirty", _wrap_Fbo_flagDirty}, - { "updateTexture", _wrap_Fbo_updateTexture}, - { "checkStatus", _wrap_Fbo_checkStatus}, - { "createAndAttachTexture", _wrap_Fbo_createAndAttachTexture}, - { "attachTexture", _wrap_Fbo_attachTexture}, - { "createAndAttachRenderbuffer", _wrap_Fbo_createAndAttachRenderbuffer}, - { "createAndAttachDepthStencilTexture", _wrap_Fbo_createAndAttachDepthStencilTexture}, - { "getNumTextures", _wrap_Fbo_getNumTextures}, - { "setActiveDrawBuffer", _wrap_Fbo_setActiveDrawBuffer}, - { "activateAllDrawBuffers", _wrap_Fbo_activateAllDrawBuffers}, - { "getId", _wrap_Fbo_getId}, - { "getIdDrawBuffer", _wrap_Fbo_getIdDrawBuffer}, - { "getDepthBuffer", _wrap_Fbo_getDepthBuffer}, - { "getStencilBuffer", _wrap_Fbo_getStencilBuffer}, - {0,0} -}; -static swig_lua_method swig_Fbo_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_Fbo_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_Fbo_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_Fbo_Sf_SwigStatic_methods[]= { - { "checkGLSupport", _wrap_Fbo_checkGLSupport}, - { "maxColorAttachments", _wrap_Fbo_maxColorAttachments}, - { "maxDrawBuffers", _wrap_Fbo_maxDrawBuffers}, - { "maxSamples", _wrap_Fbo_maxSamples}, - {0,0} -}; -static swig_lua_class* swig_Fbo_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_Fbo_Sf_SwigStatic = { - "Fbo", - swig_Fbo_Sf_SwigStatic_methods, - swig_Fbo_Sf_SwigStatic_attributes, - swig_Fbo_Sf_SwigStatic_constants, - swig_Fbo_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_Fbo_bases[] = {0}; -static const char *swig_Fbo_base_names[] = {0}; -static swig_lua_class _wrap_class_Fbo = { "Fbo", "Fbo", &SWIGTYPE_p_ofFbo,_proxy__wrap_new_Fbo, swig_delete_Fbo, swig_Fbo_methods, swig_Fbo_attributes, &swig_Fbo_Sf_SwigStatic, swig_Fbo_meta, swig_Fbo_bases, swig_Fbo_base_names }; - -static int _wrap_getUsingArbTex(lua_State* L) { int SWIG_arg = 0; bool result; SWIG_check_num_args("ofGetUsingArbTex",0,0) - result = (bool)ofGetUsingArbTex(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_enableArbTex(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofEnableArbTex",0,0) ofEnableArbTex(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_disableArbTex(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofDisableArbTex",0,0) ofDisableArbTex(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getUsingNormalizedTexCoords(lua_State* L) { int SWIG_arg = 0; bool result; - SWIG_check_num_args("ofGetUsingNormalizedTexCoords",0,0) result = (bool)ofGetUsingNormalizedTexCoords(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_enableNormalizedTexCoords(lua_State* L) { int SWIG_arg = 0; - SWIG_check_num_args("ofEnableNormalizedTexCoords",0,0) ofEnableNormalizedTexCoords(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_disableNormalizedTexCoords(lua_State* L) { int SWIG_arg = 0; - SWIG_check_num_args("ofDisableNormalizedTexCoords",0,0) ofDisableNormalizedTexCoords(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_new_TextureData(lua_State* L) { int SWIG_arg = 0; ofTextureData *result = 0 ; - SWIG_check_num_args("ofTextureData::ofTextureData",0,0) result = (ofTextureData *)new ofTextureData(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTextureData,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_TextureData_textureID_set(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - unsigned int arg2 ; SWIG_check_num_args("ofTextureData::textureID",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::textureID",1,"ofTextureData *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTextureData::textureID",2,"unsigned int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_textureID_set",1,SWIGTYPE_p_ofTextureData); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned int)lua_tonumber(L, 2); - if (arg1) (arg1)->textureID = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_textureID_get(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - unsigned int result; SWIG_check_num_args("ofTextureData::textureID",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::textureID",1,"ofTextureData *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_textureID_get",1,SWIGTYPE_p_ofTextureData); } result = (unsigned int) ((arg1)->textureID); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_textureTarget_set(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - int arg2 ; SWIG_check_num_args("ofTextureData::textureTarget",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::textureTarget",1,"ofTextureData *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTextureData::textureTarget",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_textureTarget_set",1,SWIGTYPE_p_ofTextureData); } arg2 = (int)lua_tonumber(L, 2); - if (arg1) (arg1)->textureTarget = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_textureTarget_get(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - int result; SWIG_check_num_args("ofTextureData::textureTarget",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::textureTarget",1,"ofTextureData *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_textureTarget_get",1,SWIGTYPE_p_ofTextureData); } result = (int) ((arg1)->textureTarget); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_glInternalFormat_set(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - int arg2 ; SWIG_check_num_args("ofTextureData::glInternalFormat",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::glInternalFormat",1,"ofTextureData *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTextureData::glInternalFormat",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_glInternalFormat_set",1,SWIGTYPE_p_ofTextureData); } arg2 = (int)lua_tonumber(L, 2); - if (arg1) (arg1)->glInternalFormat = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_glInternalFormat_get(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - int result; SWIG_check_num_args("ofTextureData::glInternalFormat",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::glInternalFormat",1,"ofTextureData *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_glInternalFormat_get",1,SWIGTYPE_p_ofTextureData); } result = (int) ((arg1)->glInternalFormat); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_tex_t_set(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - float arg2 ; SWIG_check_num_args("ofTextureData::tex_t",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::tex_t",1,"ofTextureData *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTextureData::tex_t",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_tex_t_set",1,SWIGTYPE_p_ofTextureData); } arg2 = (float)lua_tonumber(L, 2); - if (arg1) (arg1)->tex_t = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_tex_t_get(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - float result; SWIG_check_num_args("ofTextureData::tex_t",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::tex_t",1,"ofTextureData *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_tex_t_get",1,SWIGTYPE_p_ofTextureData); } result = (float) ((arg1)->tex_t); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_tex_u_set(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - float arg2 ; SWIG_check_num_args("ofTextureData::tex_u",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::tex_u",1,"ofTextureData *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTextureData::tex_u",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_tex_u_set",1,SWIGTYPE_p_ofTextureData); } arg2 = (float)lua_tonumber(L, 2); - if (arg1) (arg1)->tex_u = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_tex_u_get(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - float result; SWIG_check_num_args("ofTextureData::tex_u",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::tex_u",1,"ofTextureData *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_tex_u_get",1,SWIGTYPE_p_ofTextureData); } result = (float) ((arg1)->tex_u); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_tex_w_set(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - float arg2 ; SWIG_check_num_args("ofTextureData::tex_w",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::tex_w",1,"ofTextureData *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTextureData::tex_w",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_tex_w_set",1,SWIGTYPE_p_ofTextureData); } arg2 = (float)lua_tonumber(L, 2); - if (arg1) (arg1)->tex_w = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_tex_w_get(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - float result; SWIG_check_num_args("ofTextureData::tex_w",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::tex_w",1,"ofTextureData *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_tex_w_get",1,SWIGTYPE_p_ofTextureData); } result = (float) ((arg1)->tex_w); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_tex_h_set(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - float arg2 ; SWIG_check_num_args("ofTextureData::tex_h",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::tex_h",1,"ofTextureData *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTextureData::tex_h",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_tex_h_set",1,SWIGTYPE_p_ofTextureData); } arg2 = (float)lua_tonumber(L, 2); - if (arg1) (arg1)->tex_h = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_tex_h_get(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - float result; SWIG_check_num_args("ofTextureData::tex_h",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::tex_h",1,"ofTextureData *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_tex_h_get",1,SWIGTYPE_p_ofTextureData); } result = (float) ((arg1)->tex_h); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_width_set(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - float arg2 ; SWIG_check_num_args("ofTextureData::width",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::width",1,"ofTextureData *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTextureData::width",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_width_set",1,SWIGTYPE_p_ofTextureData); } arg2 = (float)lua_tonumber(L, 2); - if (arg1) (arg1)->width = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_width_get(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - float result; SWIG_check_num_args("ofTextureData::width",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::width",1,"ofTextureData *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_width_get",1,SWIGTYPE_p_ofTextureData); } result = (float) ((arg1)->width); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_height_set(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - float arg2 ; SWIG_check_num_args("ofTextureData::height",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::height",1,"ofTextureData *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTextureData::height",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_height_set",1,SWIGTYPE_p_ofTextureData); } arg2 = (float)lua_tonumber(L, 2); - if (arg1) (arg1)->height = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_height_get(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - float result; SWIG_check_num_args("ofTextureData::height",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::height",1,"ofTextureData *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_height_get",1,SWIGTYPE_p_ofTextureData); } result = (float) ((arg1)->height); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_bFlipTexture_set(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - bool arg2 ; SWIG_check_num_args("ofTextureData::bFlipTexture",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::bFlipTexture",1,"ofTextureData *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofTextureData::bFlipTexture",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_bFlipTexture_set",1,SWIGTYPE_p_ofTextureData); } arg2 = (lua_toboolean(L, 2)!=0); - if (arg1) (arg1)->bFlipTexture = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_bFlipTexture_get(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - bool result; SWIG_check_num_args("ofTextureData::bFlipTexture",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::bFlipTexture",1,"ofTextureData *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_bFlipTexture_get",1,SWIGTYPE_p_ofTextureData); } result = (bool) ((arg1)->bFlipTexture); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_compressionType_set(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - ofTexCompression arg2 ; SWIG_check_num_args("ofTextureData::compressionType",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::compressionType",1,"ofTextureData *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTextureData::compressionType",2,"ofTexCompression"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_compressionType_set",1,SWIGTYPE_p_ofTextureData); } - arg2 = (ofTexCompression)(int)lua_tonumber(L, 2); if (arg1) (arg1)->compressionType = arg2; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_compressionType_get(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - ofTexCompression result; SWIG_check_num_args("ofTextureData::compressionType",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::compressionType",1,"ofTextureData *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_compressionType_get",1,SWIGTYPE_p_ofTextureData); } - result = (ofTexCompression) ((arg1)->compressionType); lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_bAllocated_set(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - bool arg2 ; SWIG_check_num_args("ofTextureData::bAllocated",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::bAllocated",1,"ofTextureData *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofTextureData::bAllocated",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_bAllocated_set",1,SWIGTYPE_p_ofTextureData); } arg2 = (lua_toboolean(L, 2)!=0); - if (arg1) (arg1)->bAllocated = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_bAllocated_get(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - bool result; SWIG_check_num_args("ofTextureData::bAllocated",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::bAllocated",1,"ofTextureData *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_bAllocated_get",1,SWIGTYPE_p_ofTextureData); } result = (bool) ((arg1)->bAllocated); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_minFilter_set(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - GLint arg2 ; SWIG_check_num_args("ofTextureData::minFilter",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::minFilter",1,"ofTextureData *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTextureData::minFilter",2,"GLint"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_minFilter_set",1,SWIGTYPE_p_ofTextureData); } arg2 = (GLint)lua_tonumber(L, 2); - if (arg1) (arg1)->minFilter = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_minFilter_get(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - GLint result; SWIG_check_num_args("ofTextureData::minFilter",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::minFilter",1,"ofTextureData *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_minFilter_get",1,SWIGTYPE_p_ofTextureData); } result = (GLint) ((arg1)->minFilter); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_magFilter_set(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - GLint arg2 ; SWIG_check_num_args("ofTextureData::magFilter",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::magFilter",1,"ofTextureData *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTextureData::magFilter",2,"GLint"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_magFilter_set",1,SWIGTYPE_p_ofTextureData); } arg2 = (GLint)lua_tonumber(L, 2); - if (arg1) (arg1)->magFilter = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_magFilter_get(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - GLint result; SWIG_check_num_args("ofTextureData::magFilter",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::magFilter",1,"ofTextureData *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_magFilter_get",1,SWIGTYPE_p_ofTextureData); } result = (GLint) ((arg1)->magFilter); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_wrapModeHorizontal_set(lua_State* L) { int SWIG_arg = 0; - ofTextureData *arg1 = (ofTextureData *) 0 ; GLint arg2 ; SWIG_check_num_args("ofTextureData::wrapModeHorizontal",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::wrapModeHorizontal",1,"ofTextureData *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTextureData::wrapModeHorizontal",2,"GLint"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_wrapModeHorizontal_set",1,SWIGTYPE_p_ofTextureData); } arg2 = (GLint)lua_tonumber(L, 2); - if (arg1) (arg1)->wrapModeHorizontal = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_wrapModeHorizontal_get(lua_State* L) { int SWIG_arg = 0; - ofTextureData *arg1 = (ofTextureData *) 0 ; GLint result; SWIG_check_num_args("ofTextureData::wrapModeHorizontal",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::wrapModeHorizontal",1,"ofTextureData *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_wrapModeHorizontal_get",1,SWIGTYPE_p_ofTextureData); } - result = (GLint) ((arg1)->wrapModeHorizontal); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_wrapModeVertical_set(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - GLint arg2 ; SWIG_check_num_args("ofTextureData::wrapModeVertical",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::wrapModeVertical",1,"ofTextureData *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTextureData::wrapModeVertical",2,"GLint"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_wrapModeVertical_set",1,SWIGTYPE_p_ofTextureData); } arg2 = (GLint)lua_tonumber(L, 2); - if (arg1) (arg1)->wrapModeVertical = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_wrapModeVertical_get(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - GLint result; SWIG_check_num_args("ofTextureData::wrapModeVertical",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::wrapModeVertical",1,"ofTextureData *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_wrapModeVertical_get",1,SWIGTYPE_p_ofTextureData); } - result = (GLint) ((arg1)->wrapModeVertical); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_bufferId_set(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - unsigned int arg2 ; SWIG_check_num_args("ofTextureData::bufferId",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::bufferId",1,"ofTextureData *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTextureData::bufferId",2,"unsigned int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_bufferId_set",1,SWIGTYPE_p_ofTextureData); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned int)lua_tonumber(L, 2); - if (arg1) (arg1)->bufferId = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_bufferId_get(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - unsigned int result; SWIG_check_num_args("ofTextureData::bufferId",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::bufferId",1,"ofTextureData *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_bufferId_get",1,SWIGTYPE_p_ofTextureData); } result = (unsigned int) ((arg1)->bufferId); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_TextureData(void *obj) { -ofTextureData *arg1 = (ofTextureData *) obj; -delete arg1; -} -static int _proxy__wrap_new_TextureData(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_TextureData); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_TextureData_attributes[] = { - { "textureID", _wrap_TextureData_textureID_get, _wrap_TextureData_textureID_set }, - { "textureTarget", _wrap_TextureData_textureTarget_get, _wrap_TextureData_textureTarget_set }, - { "glInternalFormat", _wrap_TextureData_glInternalFormat_get, _wrap_TextureData_glInternalFormat_set }, - { "tex_t", _wrap_TextureData_tex_t_get, _wrap_TextureData_tex_t_set }, - { "tex_u", _wrap_TextureData_tex_u_get, _wrap_TextureData_tex_u_set }, - { "tex_w", _wrap_TextureData_tex_w_get, _wrap_TextureData_tex_w_set }, - { "tex_h", _wrap_TextureData_tex_h_get, _wrap_TextureData_tex_h_set }, - { "width", _wrap_TextureData_width_get, _wrap_TextureData_width_set }, - { "height", _wrap_TextureData_height_get, _wrap_TextureData_height_set }, - { "bFlipTexture", _wrap_TextureData_bFlipTexture_get, _wrap_TextureData_bFlipTexture_set }, - { "compressionType", _wrap_TextureData_compressionType_get, _wrap_TextureData_compressionType_set }, - { "bAllocated", _wrap_TextureData_bAllocated_get, _wrap_TextureData_bAllocated_set }, - { "minFilter", _wrap_TextureData_minFilter_get, _wrap_TextureData_minFilter_set }, - { "magFilter", _wrap_TextureData_magFilter_get, _wrap_TextureData_magFilter_set }, - { "wrapModeHorizontal", _wrap_TextureData_wrapModeHorizontal_get, _wrap_TextureData_wrapModeHorizontal_set }, - { "wrapModeVertical", _wrap_TextureData_wrapModeVertical_get, _wrap_TextureData_wrapModeVertical_set }, - { "bufferId", _wrap_TextureData_bufferId_get, _wrap_TextureData_bufferId_set }, - {0,0,0} -}; -static swig_lua_method swig_TextureData_methods[]= { - {0,0} -}; -static swig_lua_method swig_TextureData_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_TextureData_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_TextureData_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_TextureData_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_TextureData_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_TextureData_Sf_SwigStatic = { - "TextureData", - swig_TextureData_Sf_SwigStatic_methods, - swig_TextureData_Sf_SwigStatic_attributes, - swig_TextureData_Sf_SwigStatic_constants, - swig_TextureData_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_TextureData_bases[] = {0}; -static const char *swig_TextureData_base_names[] = {0}; -static swig_lua_class _wrap_class_TextureData = { "TextureData", "TextureData", &SWIGTYPE_p_ofTextureData,_proxy__wrap_new_TextureData, swig_delete_TextureData, swig_TextureData_methods, swig_TextureData_attributes, &swig_TextureData_Sf_SwigStatic, swig_TextureData_meta, swig_TextureData_bases, swig_TextureData_base_names }; - -static int _wrap_enableTextureEdgeHack(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofEnableTextureEdgeHack",0,0) - ofEnableTextureEdgeHack(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_disableTextureEdgeHack(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofDisableTextureEdgeHack",0,0) - ofDisableTextureEdgeHack(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_isTextureEdgeHackEnabled(lua_State* L) { int SWIG_arg = 0; bool result; - SWIG_check_num_args("ofIsTextureEdgeHackEnabled",0,0) result = (bool)ofIsTextureEdgeHackEnabled(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_new_Texture__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofTexture *result = 0 ; - SWIG_check_num_args("ofTexture::ofTexture",0,0) result = (ofTexture *)new ofTexture(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTexture,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Texture__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = 0 ; ofTexture *result = 0 ; - SWIG_check_num_args("ofTexture::ofTexture",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofTexture::ofTexture",1,"ofTexture &&"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("new_Texture",1,SWIGTYPE_p_ofTexture); } result = (ofTexture *)new ofTexture((ofTexture &&)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTexture,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Texture(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_Texture__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_new_Texture__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_Texture'\n" " Possible C/C++ prototypes are:\n" - " ofTexture::ofTexture()\n" " ofTexture::ofTexture(ofTexture &&)\n"); lua_error(L);return 0; } -static int _wrap_Texture_allocate__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - ofTextureData *arg2 = 0 ; SWIG_check_num_args("ofTexture::allocate",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::allocate",1,"ofTexture *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofTexture::allocate",2,"ofTextureData const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_allocate",1,SWIGTYPE_p_ofTexture); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("Texture_allocate",2,SWIGTYPE_p_ofTextureData); } (arg1)->allocate((ofTextureData const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_allocate__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - ofTextureData *arg2 = 0 ; int arg3 ; int arg4 ; SWIG_check_num_args("ofTexture::allocate",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::allocate",1,"ofTexture *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofTexture::allocate",2,"ofTextureData const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTexture::allocate",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofTexture::allocate",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_allocate",1,SWIGTYPE_p_ofTexture); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("Texture_allocate",2,SWIGTYPE_p_ofTextureData); } arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); (arg1)->allocate((ofTextureData const &)*arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_allocate__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; int arg2 ; - int arg3 ; int arg4 ; SWIG_check_num_args("ofTexture::allocate",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::allocate",1,"ofTexture *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTexture::allocate",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTexture::allocate",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofTexture::allocate",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_allocate",1,SWIGTYPE_p_ofTexture); } arg2 = (int)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); (arg1)->allocate(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Texture_allocate__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; int arg2 ; - int arg3 ; int arg4 ; int arg5 ; int arg6 ; SWIG_check_num_args("ofTexture::allocate",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::allocate",1,"ofTexture *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTexture::allocate",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTexture::allocate",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofTexture::allocate",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofTexture::allocate",5,"int"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofTexture::allocate",6,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_allocate",1,SWIGTYPE_p_ofTexture); } arg2 = (int)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); arg6 = (int)lua_tonumber(L, 6); - (arg1)->allocate(arg2,arg3,arg4,arg5,arg6); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_allocate__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; int arg2 ; - int arg3 ; int arg4 ; bool arg5 ; SWIG_check_num_args("ofTexture::allocate",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::allocate",1,"ofTexture *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTexture::allocate",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTexture::allocate",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofTexture::allocate",4,"int"); - if(!lua_isboolean(L,5)) SWIG_fail_arg("ofTexture::allocate",5,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_allocate",1,SWIGTYPE_p_ofTexture); } arg2 = (int)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); arg5 = (lua_toboolean(L, 5)!=0); (arg1)->allocate(arg2,arg3,arg4,arg5); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_allocate__SWIG_5(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; int arg2 ; - int arg3 ; int arg4 ; bool arg5 ; int arg6 ; int arg7 ; SWIG_check_num_args("ofTexture::allocate",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::allocate",1,"ofTexture *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTexture::allocate",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTexture::allocate",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofTexture::allocate",4,"int"); - if(!lua_isboolean(L,5)) SWIG_fail_arg("ofTexture::allocate",5,"bool"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofTexture::allocate",6,"int"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofTexture::allocate",7,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_allocate",1,SWIGTYPE_p_ofTexture); } arg2 = (int)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); arg5 = (lua_toboolean(L, 5)!=0); arg6 = (int)lua_tonumber(L, 6); - arg7 = (int)lua_tonumber(L, 7); (arg1)->allocate(arg2,arg3,arg4,arg5,arg6,arg7); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Texture_allocate__SWIG_6(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - ofPixels *arg2 = 0 ; SWIG_check_num_args("ofTexture::allocate",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::allocate",1,"ofTexture *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofTexture::allocate",2,"ofPixels const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_allocate",1,SWIGTYPE_p_ofTexture); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Texture_allocate",2,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } (arg1)->allocate((ofPixels const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_allocate__SWIG_7(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - ofPixels *arg2 = 0 ; bool arg3 ; SWIG_check_num_args("ofTexture::allocate",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::allocate",1,"ofTexture *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofTexture::allocate",2,"ofPixels const &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofTexture::allocate",3,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_allocate",1,SWIGTYPE_p_ofTexture); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Texture_allocate",2,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } arg3 = (lua_toboolean(L, 3)!=0); - (arg1)->allocate((ofPixels const &)*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_allocate__SWIG_8(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - ofShortPixels *arg2 = 0 ; SWIG_check_num_args("ofTexture::allocate",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::allocate",1,"ofTexture *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofTexture::allocate",2,"ofShortPixels const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_allocate",1,SWIGTYPE_p_ofTexture); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("Texture_allocate",2,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - (arg1)->allocate((ofShortPixels const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_allocate__SWIG_9(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - ofShortPixels *arg2 = 0 ; bool arg3 ; SWIG_check_num_args("ofTexture::allocate",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::allocate",1,"ofTexture *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofTexture::allocate",2,"ofShortPixels const &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofTexture::allocate",3,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_allocate",1,SWIGTYPE_p_ofTexture); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("Texture_allocate",2,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } arg3 = (lua_toboolean(L, 3)!=0); - (arg1)->allocate((ofShortPixels const &)*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_allocate__SWIG_10(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - ofFloatPixels *arg2 = 0 ; SWIG_check_num_args("ofTexture::allocate",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::allocate",1,"ofTexture *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofTexture::allocate",2,"ofFloatPixels const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_allocate",1,SWIGTYPE_p_ofTexture); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("Texture_allocate",2,SWIGTYPE_p_ofPixels_T_float_t); } (arg1)->allocate((ofFloatPixels const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_allocate__SWIG_11(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - ofFloatPixels *arg2 = 0 ; bool arg3 ; SWIG_check_num_args("ofTexture::allocate",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::allocate",1,"ofTexture *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofTexture::allocate",2,"ofFloatPixels const &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofTexture::allocate",3,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_allocate",1,SWIGTYPE_p_ofTexture); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("Texture_allocate",2,SWIGTYPE_p_ofPixels_T_float_t); } arg3 = (lua_toboolean(L, 3)!=0); - (arg1)->allocate((ofFloatPixels const &)*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_allocate(lua_State* L) { int argc; int argv[8]={ 1,2,3,4,5,6,7,8} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofTextureData, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Texture_allocate__SWIG_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Texture_allocate__SWIG_6(L);} } } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Texture_allocate__SWIG_8(L);} } } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Texture_allocate__SWIG_10(L);} } } if (argc == 3) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - return _wrap_Texture_allocate__SWIG_9(L);} } } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - return _wrap_Texture_allocate__SWIG_7(L);} } } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - return _wrap_Texture_allocate__SWIG_11(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofTextureData, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Texture_allocate__SWIG_1(L);} } } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Texture_allocate__SWIG_2(L);} } } } } if (argc == 5) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isboolean(L,argv[4]); } if (_v) { - return _wrap_Texture_allocate__SWIG_4(L);} } } } } } if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { return _wrap_Texture_allocate__SWIG_3(L);} } } } } } } - if (argc == 7) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isboolean(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { - return _wrap_Texture_allocate__SWIG_5(L);} } } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Texture_allocate'\n" " Possible C/C++ prototypes are:\n" - " ofTexture::allocate(ofTextureData const &)\n" " ofTexture::allocate(ofTextureData const &,int,int)\n" - " ofTexture::allocate(int,int,int)\n" " ofTexture::allocate(int,int,int,int,int)\n" - " ofTexture::allocate(int,int,int,bool)\n" " ofTexture::allocate(int,int,int,bool,int,int)\n" - " ofTexture::allocate(ofPixels const &)\n" " ofTexture::allocate(ofPixels const &,bool)\n" - " ofTexture::allocate(ofShortPixels const &)\n" " ofTexture::allocate(ofShortPixels const &,bool)\n" - " ofTexture::allocate(ofFloatPixels const &)\n" " ofTexture::allocate(ofFloatPixels const &,bool)\n"); - lua_error(L);return 0; } -static int _wrap_Texture_isAllocated(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; bool result; - SWIG_check_num_args("ofTexture::isAllocated",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::isAllocated",1,"ofTexture const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_isAllocated",1,SWIGTYPE_p_ofTexture); } result = (bool)((ofTexture const *)arg1)->isAllocated(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_clear(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - SWIG_check_num_args("ofTexture::clear",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::clear",1,"ofTexture *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_clear",1,SWIGTYPE_p_ofTexture); } (arg1)->clear(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Texture_setUseExternalTextureID(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - GLuint arg2 ; SWIG_check_num_args("ofTexture::setUseExternalTextureID",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::setUseExternalTextureID",1,"ofTexture *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTexture::setUseExternalTextureID",2,"GLuint"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_setUseExternalTextureID",1,SWIGTYPE_p_ofTexture); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (GLuint)lua_tonumber(L, 2); - (arg1)->setUseExternalTextureID(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_loadData__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - unsigned char *arg2 = (unsigned char *) (unsigned char *)0 ; int arg3 ; int arg4 ; int arg5 ; - SWIG_check_num_args("ofTexture::loadData",5,5) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::loadData",1,"ofTexture *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofTexture::loadData",2,"unsigned char const *const"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTexture::loadData",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofTexture::loadData",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofTexture::loadData",5,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_loadData",1,SWIGTYPE_p_ofTexture); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_unsigned_char,0))){ - SWIG_fail_ptr("Texture_loadData",2,SWIGTYPE_p_unsigned_char); } arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); (arg1)->loadData((unsigned char const *)arg2,arg3,arg4,arg5); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_loadData__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - unsigned short *arg2 = (unsigned short *) 0 ; int arg3 ; int arg4 ; int arg5 ; SWIG_check_num_args("ofTexture::loadData",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::loadData",1,"ofTexture *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofTexture::loadData",2,"unsigned short const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTexture::loadData",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofTexture::loadData",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofTexture::loadData",5,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_loadData",1,SWIGTYPE_p_ofTexture); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_unsigned_short,0))){ - SWIG_fail_ptr("Texture_loadData",2,SWIGTYPE_p_unsigned_short); } arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); (arg1)->loadData((unsigned short const *)arg2,arg3,arg4,arg5); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_loadData__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - float *arg2 = (float *) 0 ; int arg3 ; int arg4 ; int arg5 ; SWIG_check_num_args("ofTexture::loadData",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::loadData",1,"ofTexture *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofTexture::loadData",2,"float const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTexture::loadData",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofTexture::loadData",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofTexture::loadData",5,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_loadData",1,SWIGTYPE_p_ofTexture); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_float,0))){ SWIG_fail_ptr("Texture_loadData",2,SWIGTYPE_p_float); } - arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); - (arg1)->loadData((float const *)arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_loadData__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - ofPixels *arg2 = 0 ; SWIG_check_num_args("ofTexture::loadData",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::loadData",1,"ofTexture *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofTexture::loadData",2,"ofPixels const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_loadData",1,SWIGTYPE_p_ofTexture); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Texture_loadData",2,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } (arg1)->loadData((ofPixels const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_loadData__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - ofShortPixels *arg2 = 0 ; SWIG_check_num_args("ofTexture::loadData",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::loadData",1,"ofTexture *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofTexture::loadData",2,"ofShortPixels const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_loadData",1,SWIGTYPE_p_ofTexture); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("Texture_loadData",2,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - (arg1)->loadData((ofShortPixels const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_loadData__SWIG_5(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - ofFloatPixels *arg2 = 0 ; SWIG_check_num_args("ofTexture::loadData",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::loadData",1,"ofTexture *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofTexture::loadData",2,"ofFloatPixels const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_loadData",1,SWIGTYPE_p_ofTexture); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("Texture_loadData",2,SWIGTYPE_p_ofPixels_T_float_t); } (arg1)->loadData((ofFloatPixels const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_loadData__SWIG_6(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - ofPixels *arg2 = 0 ; int arg3 ; SWIG_check_num_args("ofTexture::loadData",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::loadData",1,"ofTexture *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofTexture::loadData",2,"ofPixels const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTexture::loadData",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_loadData",1,SWIGTYPE_p_ofTexture); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Texture_loadData",2,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } arg3 = (int)lua_tonumber(L, 3); - (arg1)->loadData((ofPixels const &)*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_loadData__SWIG_7(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - ofShortPixels *arg2 = 0 ; int arg3 ; SWIG_check_num_args("ofTexture::loadData",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::loadData",1,"ofTexture *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofTexture::loadData",2,"ofShortPixels const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTexture::loadData",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_loadData",1,SWIGTYPE_p_ofTexture); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("Texture_loadData",2,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } arg3 = (int)lua_tonumber(L, 3); - (arg1)->loadData((ofShortPixels const &)*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_loadData__SWIG_8(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - ofFloatPixels *arg2 = 0 ; int arg3 ; SWIG_check_num_args("ofTexture::loadData",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::loadData",1,"ofTexture *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofTexture::loadData",2,"ofFloatPixels const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTexture::loadData",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_loadData",1,SWIGTYPE_p_ofTexture); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("Texture_loadData",2,SWIGTYPE_p_ofPixels_T_float_t); } arg3 = (int)lua_tonumber(L, 3); - (arg1)->loadData((ofFloatPixels const &)*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_loadData(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Texture_loadData__SWIG_3(L);} } } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Texture_loadData__SWIG_4(L);} } } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Texture_loadData__SWIG_5(L);} } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Texture_loadData__SWIG_6(L);} } } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Texture_loadData__SWIG_7(L);} } } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Texture_loadData__SWIG_8(L);} } } } if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_unsigned_char, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_Texture_loadData__SWIG_0(L);} } } } } } - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_unsigned_short, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_Texture_loadData__SWIG_1(L);} } } } } } - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_Texture_loadData__SWIG_2(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Texture_loadData'\n" " Possible C/C++ prototypes are:\n" - " ofTexture::loadData(unsigned char const *const,int,int,int)\n" - " ofTexture::loadData(unsigned short const *,int,int,int)\n" " ofTexture::loadData(float const *,int,int,int)\n" - " ofTexture::loadData(ofPixels const &)\n" " ofTexture::loadData(ofShortPixels const &)\n" - " ofTexture::loadData(ofFloatPixels const &)\n" " ofTexture::loadData(ofPixels const &,int)\n" - " ofTexture::loadData(ofShortPixels const &,int)\n" " ofTexture::loadData(ofFloatPixels const &,int)\n"); - lua_error(L);return 0; } -static int _wrap_Texture_loadScreenData(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; int arg2 ; - int arg3 ; int arg4 ; int arg5 ; SWIG_check_num_args("ofTexture::loadScreenData",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::loadScreenData",1,"ofTexture *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTexture::loadScreenData",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTexture::loadScreenData",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofTexture::loadScreenData",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofTexture::loadScreenData",5,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_loadScreenData",1,SWIGTYPE_p_ofTexture); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); - (arg1)->loadScreenData(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_draw__SWIG_0_0(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - ofPoint *arg2 = 0 ; SWIG_check_num_args("draw",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("draw",1,"ofTexture const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("draw",2,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_draw",1,SWIGTYPE_p_ofTexture); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Texture_draw",2,SWIGTYPE_p_ofVec3f); } - ((ofTexture const *)arg1)->draw((ofPoint const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Texture_draw__SWIG_0_1(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - ofRectangle *arg2 = 0 ; SWIG_check_num_args("draw",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("draw",1,"ofTexture const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("draw",2,"ofRectangle const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_draw",1,SWIGTYPE_p_ofTexture); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Texture_draw",2,SWIGTYPE_p_ofRectangle); } ((ofTexture const *)arg1)->draw((ofRectangle const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_draw__SWIG_0_2(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - ofPoint *arg2 = 0 ; float arg3 ; float arg4 ; SWIG_check_num_args("draw",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("draw",1,"ofTexture const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("draw",2,"ofPoint const &"); if(!lua_isnumber(L,3)) SWIG_fail_arg("draw",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("draw",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_draw",1,SWIGTYPE_p_ofTexture); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Texture_draw",2,SWIGTYPE_p_ofVec3f); } - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - ((ofTexture const *)arg1)->draw((ofPoint const &)*arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Texture_draw__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; float arg2 ; - float arg3 ; SWIG_check_num_args("ofTexture::draw",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::draw",1,"ofTexture const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTexture::draw",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTexture::draw",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_draw",1,SWIGTYPE_p_ofTexture); } arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - ((ofTexture const *)arg1)->draw(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_draw__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; float arg2 ; - float arg3 ; float arg4 ; SWIG_check_num_args("ofTexture::draw",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::draw",1,"ofTexture const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTexture::draw",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTexture::draw",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofTexture::draw",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_draw",1,SWIGTYPE_p_ofTexture); } arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - arg4 = (float)lua_tonumber(L, 4); ((ofTexture const *)arg1)->draw(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Texture_draw__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; float arg2 ; - float arg3 ; float arg4 ; float arg5 ; SWIG_check_num_args("ofTexture::draw",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::draw",1,"ofTexture const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTexture::draw",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTexture::draw",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofTexture::draw",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofTexture::draw",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_draw",1,SWIGTYPE_p_ofTexture); } arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); ((ofTexture const *)arg1)->draw(arg2,arg3,arg4,arg5); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_draw__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; float arg2 ; - float arg3 ; float arg4 ; float arg5 ; float arg6 ; SWIG_check_num_args("ofTexture::draw",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::draw",1,"ofTexture const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTexture::draw",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTexture::draw",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofTexture::draw",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofTexture::draw",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofTexture::draw",6,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_draw",1,SWIGTYPE_p_ofTexture); } arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); - ((ofTexture const *)arg1)->draw(arg2,arg3,arg4,arg5,arg6); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Texture_draw__SWIG_5(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; ofPoint *arg2 = 0 ; - ofPoint *arg3 = 0 ; ofPoint *arg4 = 0 ; ofPoint *arg5 = 0 ; SWIG_check_num_args("ofTexture::draw",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::draw",1,"ofTexture const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofTexture::draw",2,"ofPoint const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofTexture::draw",3,"ofPoint const &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofTexture::draw",4,"ofPoint const &"); - if(!lua_isuserdata(L,5)) SWIG_fail_arg("ofTexture::draw",5,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_draw",1,SWIGTYPE_p_ofTexture); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Texture_draw",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Texture_draw",3,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Texture_draw",4,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Texture_draw",5,SWIGTYPE_p_ofVec3f); } - ((ofTexture const *)arg1)->draw((ofPoint const &)*arg2,(ofPoint const &)*arg3,(ofPoint const &)*arg4,(ofPoint const &)*arg5); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_draw(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Texture_draw__SWIG_0_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Texture_draw__SWIG_0_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Texture_draw__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Texture_draw__SWIG_0_2(L);} } } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Texture_draw__SWIG_2(L);} } } } } if (argc == 5) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[4])==0 || SWIG_ConvertPtr(L,argv[4], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Texture_draw__SWIG_5(L);} } } } } } if (argc == 5) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Texture_draw__SWIG_3(L);} } } } } } if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { return _wrap_Texture_draw__SWIG_4(L);} } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Texture_draw'\n" " Possible C/C++ prototypes are:\n" - " draw(ofPoint const &) const\n" " draw(ofRectangle const &) const\n" " draw(ofPoint const &,float,float) const\n" - " ofTexture::draw(float,float) const\n" " ofTexture::draw(float,float,float) const\n" - " ofTexture::draw(float,float,float,float) const\n" " ofTexture::draw(float,float,float,float,float) const\n" - " ofTexture::draw(ofPoint const &,ofPoint const &,ofPoint const &,ofPoint const &) const\n"); lua_error(L);return 0; } -static int _wrap_Texture_drawSubsection__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - float arg2 ; float arg3 ; float arg4 ; float arg5 ; float arg6 ; float arg7 ; - SWIG_check_num_args("ofTexture::drawSubsection",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::drawSubsection",1,"ofTexture const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTexture::drawSubsection",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTexture::drawSubsection",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofTexture::drawSubsection",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofTexture::drawSubsection",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofTexture::drawSubsection",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofTexture::drawSubsection",7,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_drawSubsection",1,SWIGTYPE_p_ofTexture); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); - ((ofTexture const *)arg1)->drawSubsection(arg2,arg3,arg4,arg5,arg6,arg7); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Texture_drawSubsection__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - float arg2 ; float arg3 ; float arg4 ; float arg5 ; float arg6 ; float arg7 ; float arg8 ; - SWIG_check_num_args("ofTexture::drawSubsection",8,8) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::drawSubsection",1,"ofTexture const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTexture::drawSubsection",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTexture::drawSubsection",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofTexture::drawSubsection",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofTexture::drawSubsection",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofTexture::drawSubsection",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofTexture::drawSubsection",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofTexture::drawSubsection",8,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_drawSubsection",1,SWIGTYPE_p_ofTexture); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (float)lua_tonumber(L, 8); - ((ofTexture const *)arg1)->drawSubsection(arg2,arg3,arg4,arg5,arg6,arg7,arg8); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Texture_drawSubsection__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - float arg2 ; float arg3 ; float arg4 ; float arg5 ; float arg6 ; float arg7 ; float arg8 ; float arg9 ; - SWIG_check_num_args("ofTexture::drawSubsection",9,9) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::drawSubsection",1,"ofTexture const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTexture::drawSubsection",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTexture::drawSubsection",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofTexture::drawSubsection",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofTexture::drawSubsection",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofTexture::drawSubsection",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofTexture::drawSubsection",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofTexture::drawSubsection",8,"float"); - if(!lua_isnumber(L,9)) SWIG_fail_arg("ofTexture::drawSubsection",9,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_drawSubsection",1,SWIGTYPE_p_ofTexture); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (float)lua_tonumber(L, 8); - arg9 = (float)lua_tonumber(L, 9); ((ofTexture const *)arg1)->drawSubsection(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_drawSubsection__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - float arg2 ; float arg3 ; float arg4 ; float arg5 ; float arg6 ; float arg7 ; float arg8 ; float arg9 ; float arg10 ; - SWIG_check_num_args("ofTexture::drawSubsection",10,10) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::drawSubsection",1,"ofTexture const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTexture::drawSubsection",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTexture::drawSubsection",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofTexture::drawSubsection",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofTexture::drawSubsection",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofTexture::drawSubsection",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofTexture::drawSubsection",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofTexture::drawSubsection",8,"float"); - if(!lua_isnumber(L,9)) SWIG_fail_arg("ofTexture::drawSubsection",9,"float"); - if(!lua_isnumber(L,10)) SWIG_fail_arg("ofTexture::drawSubsection",10,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_drawSubsection",1,SWIGTYPE_p_ofTexture); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (float)lua_tonumber(L, 8); - arg9 = (float)lua_tonumber(L, 9); arg10 = (float)lua_tonumber(L, 10); - ((ofTexture const *)arg1)->drawSubsection(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_drawSubsection(lua_State* L) { int argc; int argv[11]={ 1,2,3,4,5,6,7,8,9,10,11} ; - argc = lua_gettop(L); if (argc == 7) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { - return _wrap_Texture_drawSubsection__SWIG_0(L);} } } } } } } } if (argc == 8) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { return _wrap_Texture_drawSubsection__SWIG_1(L);} } } } } } } - } } if (argc == 9) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { { _v = lua_isnumber(L,argv[8]); } if (_v) { - return _wrap_Texture_drawSubsection__SWIG_2(L);} } } } } } } } } } if (argc == 10) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { { _v = lua_isnumber(L,argv[8]); } if (_v) { { - _v = lua_isnumber(L,argv[9]); } if (_v) { return _wrap_Texture_drawSubsection__SWIG_3(L);} } } } } - } } } } } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Texture_drawSubsection'\n" - " Possible C/C++ prototypes are:\n" " ofTexture::drawSubsection(float,float,float,float,float,float) const\n" - " ofTexture::drawSubsection(float,float,float,float,float,float,float) const\n" - " ofTexture::drawSubsection(float,float,float,float,float,float,float,float) const\n" - " ofTexture::drawSubsection(float,float,float,float,float,float,float,float,float) const\n"); lua_error(L);return 0; } -static int _wrap_Texture_getQuad(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; ofPoint *arg2 = 0 ; - ofPoint *arg3 = 0 ; ofPoint *arg4 = 0 ; ofPoint *arg5 = 0 ; ofMesh result; SWIG_check_num_args("ofTexture::getQuad",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::getQuad",1,"ofTexture const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofTexture::getQuad",2,"ofPoint const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofTexture::getQuad",3,"ofPoint const &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofTexture::getQuad",4,"ofPoint const &"); - if(!lua_isuserdata(L,5)) SWIG_fail_arg("ofTexture::getQuad",5,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_getQuad",1,SWIGTYPE_p_ofTexture); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Texture_getQuad",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Texture_getQuad",3,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Texture_getQuad",4,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Texture_getQuad",5,SWIGTYPE_p_ofVec3f); } - result = ((ofTexture const *)arg1)->getQuad((ofPoint const &)*arg2,(ofPoint const &)*arg3,(ofPoint const &)*arg4,(ofPoint const &)*arg5); - { ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Texture_getMeshForSubsection(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; float arg2 ; - float arg3 ; float arg4 ; float arg5 ; float arg6 ; float arg7 ; float arg8 ; float arg9 ; float arg10 ; bool arg11 ; - ofRectMode arg12 ; ofMesh result; SWIG_check_num_args("ofTexture::getMeshForSubsection",12,12) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::getMeshForSubsection",1,"ofTexture const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTexture::getMeshForSubsection",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTexture::getMeshForSubsection",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofTexture::getMeshForSubsection",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofTexture::getMeshForSubsection",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofTexture::getMeshForSubsection",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofTexture::getMeshForSubsection",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofTexture::getMeshForSubsection",8,"float"); - if(!lua_isnumber(L,9)) SWIG_fail_arg("ofTexture::getMeshForSubsection",9,"float"); - if(!lua_isnumber(L,10)) SWIG_fail_arg("ofTexture::getMeshForSubsection",10,"float"); - if(!lua_isboolean(L,11)) SWIG_fail_arg("ofTexture::getMeshForSubsection",11,"bool"); - if(!lua_isnumber(L,12)) SWIG_fail_arg("ofTexture::getMeshForSubsection",12,"ofRectMode"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_getMeshForSubsection",1,SWIGTYPE_p_ofTexture); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (float)lua_tonumber(L, 8); - arg9 = (float)lua_tonumber(L, 9); arg10 = (float)lua_tonumber(L, 10); arg11 = (lua_toboolean(L, 11)!=0); - arg12 = (ofRectMode)(int)lua_tonumber(L, 12); - result = ((ofTexture const *)arg1)->getMeshForSubsection(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12); { - ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Texture_bind__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; int arg2 ; - SWIG_check_num_args("ofTexture::bind",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::bind",1,"ofTexture const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTexture::bind",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_bind",1,SWIGTYPE_p_ofTexture); } arg2 = (int)lua_tonumber(L, 2); - ((ofTexture const *)arg1)->bind(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_bind__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - SWIG_check_num_args("ofTexture::bind",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::bind",1,"ofTexture const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_bind",1,SWIGTYPE_p_ofTexture); } ((ofTexture const *)arg1)->bind(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_bind(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Texture_bind__SWIG_1(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Texture_bind__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Texture_bind'\n" " Possible C/C++ prototypes are:\n" - " ofTexture::bind(int) const\n" " ofTexture::bind() const\n"); lua_error(L);return 0; } -static int _wrap_Texture_unbind__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; int arg2 ; - SWIG_check_num_args("ofTexture::unbind",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::unbind",1,"ofTexture const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTexture::unbind",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_unbind",1,SWIGTYPE_p_ofTexture); } arg2 = (int)lua_tonumber(L, 2); - ((ofTexture const *)arg1)->unbind(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_unbind__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - SWIG_check_num_args("ofTexture::unbind",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::unbind",1,"ofTexture const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_unbind",1,SWIGTYPE_p_ofTexture); } ((ofTexture const *)arg1)->unbind(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_unbind(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Texture_unbind__SWIG_1(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Texture_unbind__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Texture_unbind'\n" " Possible C/C++ prototypes are:\n" - " ofTexture::unbind(int) const\n" " ofTexture::unbind() const\n"); lua_error(L);return 0; } -static int _wrap_Texture_getAlphaMask(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - ofTexture *result = 0 ; SWIG_check_num_args("ofTexture::getAlphaMask",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::getAlphaMask",1,"ofTexture const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_getAlphaMask",1,SWIGTYPE_p_ofTexture); } - result = (ofTexture *)((ofTexture const *)arg1)->getAlphaMask(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTexture,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Texture_getHeight(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; float result; - SWIG_check_num_args("ofTexture::getHeight",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::getHeight",1,"ofTexture const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_getHeight",1,SWIGTYPE_p_ofTexture); } result = (float)((ofTexture const *)arg1)->getHeight(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_getWidth(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; float result; - SWIG_check_num_args("ofTexture::getWidth",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::getWidth",1,"ofTexture const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_getWidth",1,SWIGTYPE_p_ofTexture); } result = (float)((ofTexture const *)arg1)->getWidth(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_setAnchorPercent(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; float arg2 ; - float arg3 ; SWIG_check_num_args("ofTexture::setAnchorPercent",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::setAnchorPercent",1,"ofTexture *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTexture::setAnchorPercent",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTexture::setAnchorPercent",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_setAnchorPercent",1,SWIGTYPE_p_ofTexture); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->setAnchorPercent(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Texture_setAnchorPoint(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; float arg2 ; - float arg3 ; SWIG_check_num_args("ofTexture::setAnchorPoint",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::setAnchorPoint",1,"ofTexture *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTexture::setAnchorPoint",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTexture::setAnchorPoint",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_setAnchorPoint",1,SWIGTYPE_p_ofTexture); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->setAnchorPoint(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Texture_resetAnchor(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - SWIG_check_num_args("ofTexture::resetAnchor",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::resetAnchor",1,"ofTexture *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_resetAnchor",1,SWIGTYPE_p_ofTexture); } (arg1)->resetAnchor(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_getCoordFromPoint(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; float arg2 ; - float arg3 ; ofPoint result; SWIG_check_num_args("ofTexture::getCoordFromPoint",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::getCoordFromPoint",1,"ofTexture const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTexture::getCoordFromPoint",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTexture::getCoordFromPoint",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_getCoordFromPoint",1,SWIGTYPE_p_ofTexture); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); result = ((ofTexture const *)arg1)->getCoordFromPoint(arg2,arg3); { - ofPoint * resultptr = new ofPoint((const ofPoint &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Texture_getCoordFromPercent(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; float arg2 ; - float arg3 ; ofPoint result; SWIG_check_num_args("ofTexture::getCoordFromPercent",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::getCoordFromPercent",1,"ofTexture const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTexture::getCoordFromPercent",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTexture::getCoordFromPercent",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_getCoordFromPercent",1,SWIGTYPE_p_ofTexture); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); result = ((ofTexture const *)arg1)->getCoordFromPercent(arg2,arg3); { - ofPoint * resultptr = new ofPoint((const ofPoint &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Texture_setAlphaMask(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - ofTexture *arg2 = 0 ; SWIG_check_num_args("ofTexture::setAlphaMask",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::setAlphaMask",1,"ofTexture *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofTexture::setAlphaMask",2,"ofTexture &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_setAlphaMask",1,SWIGTYPE_p_ofTexture); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_setAlphaMask",2,SWIGTYPE_p_ofTexture); } (arg1)->setAlphaMask(*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_disableAlphaMask(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - SWIG_check_num_args("ofTexture::disableAlphaMask",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::disableAlphaMask",1,"ofTexture *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_disableAlphaMask",1,SWIGTYPE_p_ofTexture); } (arg1)->disableAlphaMask(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_setTextureWrap(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; GLint arg2 ; - GLint arg3 ; SWIG_check_num_args("ofTexture::setTextureWrap",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::setTextureWrap",1,"ofTexture *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTexture::setTextureWrap",2,"GLint"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTexture::setTextureWrap",3,"GLint"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_setTextureWrap",1,SWIGTYPE_p_ofTexture); } arg2 = (GLint)lua_tonumber(L, 2); - arg3 = (GLint)lua_tonumber(L, 3); (arg1)->setTextureWrap(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Texture_setTextureMinMagFilter(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - GLint arg2 ; GLint arg3 ; SWIG_check_num_args("ofTexture::setTextureMinMagFilter",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::setTextureMinMagFilter",1,"ofTexture *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTexture::setTextureMinMagFilter",2,"GLint"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTexture::setTextureMinMagFilter",3,"GLint"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_setTextureMinMagFilter",1,SWIGTYPE_p_ofTexture); } arg2 = (GLint)lua_tonumber(L, 2); - arg3 = (GLint)lua_tonumber(L, 3); (arg1)->setTextureMinMagFilter(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Texture_setTextureMatrix(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - ofMatrix4x4 *arg2 = 0 ; SWIG_check_num_args("ofTexture::setTextureMatrix",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::setTextureMatrix",1,"ofTexture *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofTexture::setTextureMatrix",2,"ofMatrix4x4 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_setTextureMatrix",1,SWIGTYPE_p_ofTexture); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Texture_setTextureMatrix",2,SWIGTYPE_p_ofMatrix4x4); } (arg1)->setTextureMatrix((ofMatrix4x4 const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_getTextureMatrix(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - ofMatrix4x4 *result = 0 ; SWIG_check_num_args("ofTexture::getTextureMatrix",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::getTextureMatrix",1,"ofTexture const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_getTextureMatrix",1,SWIGTYPE_p_ofTexture); } - result = (ofMatrix4x4 *) &((ofTexture const *)arg1)->getTextureMatrix(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMatrix4x4,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Texture_isUsingTextureMatrix(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; bool result; - SWIG_check_num_args("ofTexture::isUsingTextureMatrix",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::isUsingTextureMatrix",1,"ofTexture const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_isUsingTextureMatrix",1,SWIGTYPE_p_ofTexture); } - result = (bool)((ofTexture const *)arg1)->isUsingTextureMatrix(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_disableTextureMatrix(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - SWIG_check_num_args("ofTexture::disableTextureMatrix",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::disableTextureMatrix",1,"ofTexture *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_disableTextureMatrix",1,SWIGTYPE_p_ofTexture); } (arg1)->disableTextureMatrix(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_setCompression(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - ofTexCompression arg2 ; SWIG_check_num_args("ofTexture::setCompression",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::setCompression",1,"ofTexture *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTexture::setCompression",2,"ofTexCompression"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_setCompression",1,SWIGTYPE_p_ofTexture); } arg2 = (ofTexCompression)(int)lua_tonumber(L, 2); - (arg1)->setCompression(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_setRGToRGBASwizzles(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; bool arg2 ; - SWIG_check_num_args("ofTexture::setRGToRGBASwizzles",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::setRGToRGBASwizzles",1,"ofTexture *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofTexture::setRGToRGBASwizzles",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_setRGToRGBASwizzles",1,SWIGTYPE_p_ofTexture); } arg2 = (lua_toboolean(L, 2)!=0); - (arg1)->setRGToRGBASwizzles(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_setSwizzle(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; GLenum arg2 ; - GLenum arg3 ; SWIG_check_num_args("ofTexture::setSwizzle",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::setSwizzle",1,"ofTexture *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTexture::setSwizzle",2,"GLenum"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTexture::setSwizzle",3,"GLenum"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_setSwizzle",1,SWIGTYPE_p_ofTexture); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (GLenum)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (GLenum)lua_tonumber(L, 3); - (arg1)->setSwizzle(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_readToPixels__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - ofPixels *arg2 = 0 ; SWIG_check_num_args("ofTexture::readToPixels",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::readToPixels",1,"ofTexture const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofTexture::readToPixels",2,"ofPixels &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_readToPixels",1,SWIGTYPE_p_ofTexture); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Texture_readToPixels",2,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - ((ofTexture const *)arg1)->readToPixels(*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_readToPixels__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - ofShortPixels *arg2 = 0 ; SWIG_check_num_args("ofTexture::readToPixels",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::readToPixels",1,"ofTexture const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofTexture::readToPixels",2,"ofShortPixels &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_readToPixels",1,SWIGTYPE_p_ofTexture); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("Texture_readToPixels",2,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - ((ofTexture const *)arg1)->readToPixels(*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_readToPixels__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - ofFloatPixels *arg2 = 0 ; SWIG_check_num_args("ofTexture::readToPixels",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::readToPixels",1,"ofTexture const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofTexture::readToPixels",2,"ofFloatPixels &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_readToPixels",1,SWIGTYPE_p_ofTexture); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("Texture_readToPixels",2,SWIGTYPE_p_ofPixels_T_float_t); } ((ofTexture const *)arg1)->readToPixels(*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_readToPixels(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Texture_readToPixels__SWIG_0(L);} } } if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Texture_readToPixels__SWIG_1(L);} } } if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Texture_readToPixels__SWIG_2(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Texture_readToPixels'\n" - " Possible C/C++ prototypes are:\n" " ofTexture::readToPixels(ofPixels &) const\n" - " ofTexture::readToPixels(ofShortPixels &) const\n" " ofTexture::readToPixels(ofFloatPixels &) const\n"); - lua_error(L);return 0; } -static int _wrap_Texture_getTextureData__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - ofTextureData *result = 0 ; SWIG_check_num_args("ofTexture::getTextureData",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::getTextureData",1,"ofTexture *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_getTextureData",1,SWIGTYPE_p_ofTexture); } result = (ofTextureData *) &(arg1)->getTextureData(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTextureData,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Texture_getTextureData__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - ofTextureData *result = 0 ; SWIG_check_num_args("ofTexture::getTextureData",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::getTextureData",1,"ofTexture const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_getTextureData",1,SWIGTYPE_p_ofTexture); } - result = (ofTextureData *) &((ofTexture const *)arg1)->getTextureData(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTextureData,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Texture_getTextureData(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Texture_getTextureData__SWIG_0(L);} } if (argc == 1) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Texture_getTextureData__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Texture_getTextureData'\n" - " Possible C/C++ prototypes are:\n" " ofTexture::getTextureData()\n" " ofTexture::getTextureData() const\n"); - lua_error(L);return 0; } -static int _wrap_Texture_enableMipmap(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - SWIG_check_num_args("ofTexture::enableMipmap",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::enableMipmap",1,"ofTexture *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_enableMipmap",1,SWIGTYPE_p_ofTexture); } (arg1)->enableMipmap(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_disableMipmap(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - SWIG_check_num_args("ofTexture::disableMipmap",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::disableMipmap",1,"ofTexture *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_disableMipmap",1,SWIGTYPE_p_ofTexture); } (arg1)->disableMipmap(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_generateMipmap(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - SWIG_check_num_args("ofTexture::generateMipmap",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::generateMipmap",1,"ofTexture *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_generateMipmap",1,SWIGTYPE_p_ofTexture); } (arg1)->generateMipmap(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_hasMipmap(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; bool result; - SWIG_check_num_args("ofTexture::hasMipmap",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::hasMipmap",1,"ofTexture const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_hasMipmap",1,SWIGTYPE_p_ofTexture); } result = (bool)((ofTexture const *)arg1)->hasMipmap(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_Texture(void *obj) { -ofTexture *arg1 = (ofTexture *) obj; -delete arg1; -} -static int _proxy__wrap_new_Texture(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_Texture); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_Texture_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_Texture_methods[]= { - { "allocate", _wrap_Texture_allocate}, - { "isAllocated", _wrap_Texture_isAllocated}, - { "clear", _wrap_Texture_clear}, - { "setUseExternalTextureID", _wrap_Texture_setUseExternalTextureID}, - { "loadData", _wrap_Texture_loadData}, - { "loadScreenData", _wrap_Texture_loadScreenData}, - { "draw", _wrap_Texture_draw}, - { "drawSubsection", _wrap_Texture_drawSubsection}, - { "getQuad", _wrap_Texture_getQuad}, - { "getMeshForSubsection", _wrap_Texture_getMeshForSubsection}, - { "bind", _wrap_Texture_bind}, - { "unbind", _wrap_Texture_unbind}, - { "getAlphaMask", _wrap_Texture_getAlphaMask}, - { "getHeight", _wrap_Texture_getHeight}, - { "getWidth", _wrap_Texture_getWidth}, - { "setAnchorPercent", _wrap_Texture_setAnchorPercent}, - { "setAnchorPoint", _wrap_Texture_setAnchorPoint}, - { "resetAnchor", _wrap_Texture_resetAnchor}, - { "getCoordFromPoint", _wrap_Texture_getCoordFromPoint}, - { "getCoordFromPercent", _wrap_Texture_getCoordFromPercent}, - { "setAlphaMask", _wrap_Texture_setAlphaMask}, - { "disableAlphaMask", _wrap_Texture_disableAlphaMask}, - { "setTextureWrap", _wrap_Texture_setTextureWrap}, - { "setTextureMinMagFilter", _wrap_Texture_setTextureMinMagFilter}, - { "setTextureMatrix", _wrap_Texture_setTextureMatrix}, - { "getTextureMatrix", _wrap_Texture_getTextureMatrix}, - { "isUsingTextureMatrix", _wrap_Texture_isUsingTextureMatrix}, - { "disableTextureMatrix", _wrap_Texture_disableTextureMatrix}, - { "setCompression", _wrap_Texture_setCompression}, - { "setRGToRGBASwizzles", _wrap_Texture_setRGToRGBASwizzles}, - { "setSwizzle", _wrap_Texture_setSwizzle}, - { "readToPixels", _wrap_Texture_readToPixels}, - { "getTextureData", _wrap_Texture_getTextureData}, - { "enableMipmap", _wrap_Texture_enableMipmap}, - { "disableMipmap", _wrap_Texture_disableMipmap}, - { "generateMipmap", _wrap_Texture_generateMipmap}, - { "hasMipmap", _wrap_Texture_hasMipmap}, - {0,0} -}; -static swig_lua_method swig_Texture_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_Texture_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_Texture_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_Texture_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_Texture_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_Texture_Sf_SwigStatic = { - "Texture", - swig_Texture_Sf_SwigStatic_methods, - swig_Texture_Sf_SwigStatic_attributes, - swig_Texture_Sf_SwigStatic_constants, - swig_Texture_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_Texture_bases[] = {0}; -static const char *swig_Texture_base_names[] = {0}; -static swig_lua_class _wrap_class_Texture = { "Texture", "Texture", &SWIGTYPE_p_ofTexture,_proxy__wrap_new_Texture, swig_delete_Texture, swig_Texture_methods, swig_Texture_attributes, &swig_Texture_Sf_SwigStatic, swig_Texture_meta, swig_Texture_bases, swig_Texture_base_names }; - -static int _wrap_new_Image__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofImage_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofImage_< unsigned char >::ofImage_",0,0) - result = (ofImage_< unsigned char > *)new ofImage_< unsigned char >(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofImage_T_unsigned_char_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_Image__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPixels_< unsigned char > *arg1 = 0 ; - ofImage_< unsigned char > *result = 0 ; SWIG_check_num_args("ofImage_< unsigned char >::ofImage_",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::ofImage_",1,"ofPixels_< unsigned char > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("new_Image",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - result = (ofImage_< unsigned char > *)new ofImage_< unsigned char >((ofPixels_< unsigned char > const &)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofImage_T_unsigned_char_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_Image__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = 0 ; ofImage_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofImage_< unsigned char >::ofImage_",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::ofImage_",1,"ofFile const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("new_Image",1,SWIGTYPE_p_ofFile); } - result = (ofImage_< unsigned char > *)new ofImage_< unsigned char >((ofFile const &)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofImage_T_unsigned_char_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_Image__SWIG_3(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - ofImage_< unsigned char > *result = 0 ; SWIG_check_num_args("ofImage_< unsigned char >::ofImage_",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::ofImage_",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; - result = (ofImage_< unsigned char > *)new ofImage_< unsigned char >((std::string const &)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofImage_T_unsigned_char_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_Image__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofImage_< unsigned char > *arg1 = 0 ; - ofImage_< unsigned char > *result = 0 ; SWIG_check_num_args("ofImage_< unsigned char >::ofImage_",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::ofImage_",1,"ofImage_< unsigned char > &&"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("new_Image",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } - result = (ofImage_< unsigned char > *)new ofImage_< unsigned char >((ofImage_< unsigned char > &&)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofImage_T_unsigned_char_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_Image(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_Image__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_new_Image__SWIG_1(L);} } if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_new_Image__SWIG_2(L);} } if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_new_Image__SWIG_4(L);} } if (argc == 1) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { return _wrap_new_Image__SWIG_3(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_Image'\n" " Possible C/C++ prototypes are:\n" - " ofImage_< unsigned char >::ofImage_()\n" " ofImage_< unsigned char >::ofImage_(ofPixels_< unsigned char > const &)\n" - " ofImage_< unsigned char >::ofImage_(ofFile const &)\n" " ofImage_< unsigned char >::ofImage_(std::string const &)\n" - " ofImage_< unsigned char >::ofImage_(ofImage_< unsigned char > &&)\n"); lua_error(L);return 0; } -static int _wrap_Image_allocate(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; int arg2 ; int arg3 ; ofImageType arg4 ; - SWIG_check_num_args("ofImage_< unsigned char >::allocate",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::allocate",1,"ofImage_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::allocate",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned char >::allocate",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< unsigned char >::allocate",4,"ofImageType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_allocate",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); arg4 = (ofImageType)(int)lua_tonumber(L, 4); (arg1)->allocate(arg2,arg3,arg4); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_isAllocated(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; bool result; - SWIG_check_num_args("ofImage_< unsigned char >::isAllocated",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::isAllocated",1,"ofImage_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_isAllocated",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } - result = (bool)((ofImage_< unsigned char > const *)arg1)->isAllocated(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_clear(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; - SWIG_check_num_args("ofImage_< unsigned char >::clear",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::clear",1,"ofImage_< unsigned char > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_clear",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } (arg1)->clear(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_load__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; std::string *arg2 = 0 ; std::string temp2 ; bool result; - SWIG_check_num_args("ofImage_< unsigned char >::load",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::load",1,"ofImage_< unsigned char > *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::load",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_load",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; result = (bool)(arg1)->load((std::string const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_load__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; ofBuffer *arg2 = 0 ; bool result; - SWIG_check_num_args("ofImage_< unsigned char >::load",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::load",1,"ofImage_< unsigned char > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::load",2,"ofBuffer const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_load",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBuffer,0))){ SWIG_fail_ptr("Image_load",2,SWIGTYPE_p_ofBuffer); } - result = (bool)(arg1)->load((ofBuffer const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_load__SWIG_2(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; ofFile *arg2 = 0 ; bool result; - SWIG_check_num_args("ofImage_< unsigned char >::load",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::load",1,"ofImage_< unsigned char > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::load",2,"ofFile const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_load",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("Image_load",2,SWIGTYPE_p_ofFile); } - result = (bool)(arg1)->load((ofFile const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_load(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBuffer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Image_load__SWIG_1(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Image_load__SWIG_2(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { - return _wrap_Image_load__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Image_load'\n" " Possible C/C++ prototypes are:\n" - " ofImage_< unsigned char >::load(std::string const &)\n" " ofImage_< unsigned char >::load(ofBuffer const &)\n" - " ofImage_< unsigned char >::load(ofFile const &)\n"); lua_error(L);return 0; } -static int _wrap_Image_draw__SWIG_0_0(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; ofPoint *arg2 = 0 ; SWIG_check_num_args("draw",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("draw",1,"ofImage_< unsigned char > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("draw",2,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_draw",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Image_draw",2,SWIGTYPE_p_ofVec3f); } - ((ofImage_< unsigned char > const *)arg1)->draw((ofPoint const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Image_draw__SWIG_0_1(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; ofRectangle *arg2 = 0 ; SWIG_check_num_args("draw",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("draw",1,"ofImage_< unsigned char > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("draw",2,"ofRectangle const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_draw",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Image_draw",2,SWIGTYPE_p_ofRectangle); } - ((ofImage_< unsigned char > const *)arg1)->draw((ofRectangle const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Image_draw__SWIG_0_2(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; ofPoint *arg2 = 0 ; float arg3 ; float arg4 ; - SWIG_check_num_args("draw",4,4) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("draw",1,"ofImage_< unsigned char > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("draw",2,"ofPoint const &"); if(!lua_isnumber(L,3)) SWIG_fail_arg("draw",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("draw",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_draw",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Image_draw",2,SWIGTYPE_p_ofVec3f); } - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - ((ofImage_< unsigned char > const *)arg1)->draw((ofPoint const &)*arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Image_draw__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofImage_< unsigned char >::draw",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::draw",1,"ofImage_< unsigned char > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::draw",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned char >::draw",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_draw",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); ((ofImage_< unsigned char > const *)arg1)->draw(arg2,arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_draw__SWIG_2(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; float arg2 ; float arg3 ; float arg4 ; - SWIG_check_num_args("ofImage_< unsigned char >::draw",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::draw",1,"ofImage_< unsigned char > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::draw",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned char >::draw",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< unsigned char >::draw",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_draw",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - ((ofImage_< unsigned char > const *)arg1)->draw(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Image_draw__SWIG_3(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; float arg2 ; float arg3 ; float arg4 ; float arg5 ; - SWIG_check_num_args("ofImage_< unsigned char >::draw",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::draw",1,"ofImage_< unsigned char > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::draw",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned char >::draw",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< unsigned char >::draw",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< unsigned char >::draw",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_draw",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - ((ofImage_< unsigned char > const *)arg1)->draw(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Image_draw__SWIG_4(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; float arg2 ; float arg3 ; float arg4 ; float arg5 ; - float arg6 ; SWIG_check_num_args("ofImage_< unsigned char >::draw",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::draw",1,"ofImage_< unsigned char > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::draw",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned char >::draw",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< unsigned char >::draw",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< unsigned char >::draw",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofImage_< unsigned char >::draw",6,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_draw",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); ((ofImage_< unsigned char > const *)arg1)->draw(arg2,arg3,arg4,arg5,arg6); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_draw(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Image_draw__SWIG_0_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Image_draw__SWIG_0_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_Image_draw__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Image_draw__SWIG_0_2(L);} } } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Image_draw__SWIG_2(L);} } } } } - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Image_draw__SWIG_3(L);} } } } } } if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { return _wrap_Image_draw__SWIG_4(L);} } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Image_draw'\n" " Possible C/C++ prototypes are:\n" - " draw(ofPoint const &) const\n" " draw(ofRectangle const &) const\n" " draw(ofPoint const &,float,float) const\n" - " ofImage_< unsigned char >::draw(float,float) const\n" " ofImage_< unsigned char >::draw(float,float,float) const\n" - " ofImage_< unsigned char >::draw(float,float,float,float) const\n" - " ofImage_< unsigned char >::draw(float,float,float,float,float) const\n"); lua_error(L);return 0; } -static int _wrap_Image_drawSubsection__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; float arg2 ; float arg3 ; float arg4 ; float arg5 ; - float arg6 ; float arg7 ; SWIG_check_num_args("ofImage_< unsigned char >::drawSubsection",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",1,"ofImage_< unsigned char > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",7,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_drawSubsection",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); - ((ofImage_< unsigned char > const *)arg1)->drawSubsection(arg2,arg3,arg4,arg5,arg6,arg7); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_drawSubsection__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; float arg2 ; float arg3 ; float arg4 ; float arg5 ; - float arg6 ; float arg7 ; float arg8 ; SWIG_check_num_args("ofImage_< unsigned char >::drawSubsection",8,8) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",1,"ofImage_< unsigned char > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",8,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_drawSubsection",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (float)lua_tonumber(L, 8); - ((ofImage_< unsigned char > const *)arg1)->drawSubsection(arg2,arg3,arg4,arg5,arg6,arg7,arg8); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_drawSubsection__SWIG_2(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; float arg2 ; float arg3 ; float arg4 ; float arg5 ; - float arg6 ; float arg7 ; float arg8 ; float arg9 ; SWIG_check_num_args("ofImage_< unsigned char >::drawSubsection",9,9) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",1,"ofImage_< unsigned char > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",8,"float"); - if(!lua_isnumber(L,9)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",9,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_drawSubsection",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (float)lua_tonumber(L, 8); - arg9 = (float)lua_tonumber(L, 9); - ((ofImage_< unsigned char > const *)arg1)->drawSubsection(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_drawSubsection__SWIG_3(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; float arg2 ; float arg3 ; float arg4 ; float arg5 ; - float arg6 ; float arg7 ; float arg8 ; float arg9 ; float arg10 ; - SWIG_check_num_args("ofImage_< unsigned char >::drawSubsection",10,10) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",1,"ofImage_< unsigned char > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",8,"float"); - if(!lua_isnumber(L,9)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",9,"float"); - if(!lua_isnumber(L,10)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",10,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_drawSubsection",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (float)lua_tonumber(L, 8); - arg9 = (float)lua_tonumber(L, 9); arg10 = (float)lua_tonumber(L, 10); - ((ofImage_< unsigned char > const *)arg1)->drawSubsection(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_drawSubsection(lua_State* L) { int argc; int argv[11]={ 1,2,3,4,5,6,7,8,9,10,11} ; argc = lua_gettop(L); - if (argc == 7) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { - return _wrap_Image_drawSubsection__SWIG_0(L);} } } } } } } } if (argc == 8) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { return _wrap_Image_drawSubsection__SWIG_1(L);} } } } } } } - } } if (argc == 9) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { { _v = lua_isnumber(L,argv[8]); } if (_v) { - return _wrap_Image_drawSubsection__SWIG_2(L);} } } } } } } } } } if (argc == 10) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { { _v = lua_isnumber(L,argv[8]); } if (_v) { { - _v = lua_isnumber(L,argv[9]); } if (_v) { return _wrap_Image_drawSubsection__SWIG_3(L);} } } } } } - } } } } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Image_drawSubsection'\n" - " Possible C/C++ prototypes are:\n" - " ofImage_< unsigned char >::drawSubsection(float,float,float,float,float,float) const\n" - " ofImage_< unsigned char >::drawSubsection(float,float,float,float,float,float,float) const\n" - " ofImage_< unsigned char >::drawSubsection(float,float,float,float,float,float,float,float) const\n" - " ofImage_< unsigned char >::drawSubsection(float,float,float,float,float,float,float,float,float) const\n"); - lua_error(L);return 0; } -static int _wrap_Image_update(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; - SWIG_check_num_args("ofImage_< unsigned char >::update",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::update",1,"ofImage_< unsigned char > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_update",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } (arg1)->update(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_setUseTexture(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; bool arg2 ; - SWIG_check_num_args("ofImage_< unsigned char >::setUseTexture",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::setUseTexture",1,"ofImage_< unsigned char > *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::setUseTexture",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_setUseTexture",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } arg2 = (lua_toboolean(L, 2)!=0); - (arg1)->setUseTexture(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_isUsingTexture(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; bool result; - SWIG_check_num_args("ofImage_< unsigned char >::isUsingTexture",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::isUsingTexture",1,"ofImage_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_isUsingTexture",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } - result = (bool)((ofImage_< unsigned char > const *)arg1)->isUsingTexture(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_getTexture__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; ofTexture *result = 0 ; - SWIG_check_num_args("ofImage_< unsigned char >::getTexture",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::getTexture",1,"ofImage_< unsigned char > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_getTexture",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } result = (ofTexture *) &(arg1)->getTexture(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTexture,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Image_getTexture__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; ofTexture *result = 0 ; - SWIG_check_num_args("ofImage_< unsigned char >::getTexture",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::getTexture",1,"ofImage_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_getTexture",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } - result = (ofTexture *) &((ofImage_< unsigned char > const *)arg1)->getTexture(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTexture,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Image_getTexture(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v; - { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Image_getTexture__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Image_getTexture__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Image_getTexture'\n" " Possible C/C++ prototypes are:\n" - " ofImage_< unsigned char >::getTexture()\n" " ofImage_< unsigned char >::getTexture() const\n"); - lua_error(L);return 0; } -static int _wrap_Image_bind__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; int arg2 ; - SWIG_check_num_args("ofImage_< unsigned char >::bind",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::bind",1,"ofImage_< unsigned char > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::bind",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_bind",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } arg2 = (int)lua_tonumber(L, 2); - ((ofImage_< unsigned char > const *)arg1)->bind(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_bind__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; SWIG_check_num_args("ofImage_< unsigned char >::bind",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::bind",1,"ofImage_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_bind",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } ((ofImage_< unsigned char > const *)arg1)->bind(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_bind(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Image_bind__SWIG_1(L);} } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Image_bind__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Image_bind'\n" " Possible C/C++ prototypes are:\n" - " ofImage_< unsigned char >::bind(int) const\n" " ofImage_< unsigned char >::bind() const\n"); lua_error(L);return 0; } -static int _wrap_Image_unbind__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; int arg2 ; - SWIG_check_num_args("ofImage_< unsigned char >::unbind",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::unbind",1,"ofImage_< unsigned char > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::unbind",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_unbind",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } arg2 = (int)lua_tonumber(L, 2); - ((ofImage_< unsigned char > const *)arg1)->unbind(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Image_unbind__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; - SWIG_check_num_args("ofImage_< unsigned char >::unbind",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::unbind",1,"ofImage_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_unbind",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } - ((ofImage_< unsigned char > const *)arg1)->unbind(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_unbind(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Image_unbind__SWIG_1(L);} } if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Image_unbind__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Image_unbind'\n" " Possible C/C++ prototypes are:\n" - " ofImage_< unsigned char >::unbind(int) const\n" " ofImage_< unsigned char >::unbind() const\n"); - lua_error(L);return 0; } -static int _wrap_Image_setCompression(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; ofTexCompression arg2 ; - SWIG_check_num_args("ofImage_< unsigned char >::setCompression",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::setCompression",1,"ofImage_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::setCompression",2,"ofTexCompression"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_setCompression",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } - arg2 = (ofTexCompression)(int)lua_tonumber(L, 2); (arg1)->setCompression(arg2); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Image_getColor__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; int arg2 ; int arg3 ; ofColor_< unsigned char > result; - SWIG_check_num_args("ofImage_< unsigned char >::getColor",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::getColor",1,"ofImage_< unsigned char > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::getColor",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned char >::getColor",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_getColor",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); result = ((ofImage_< unsigned char > const *)arg1)->getColor(arg2,arg3); { - ofColor_< unsigned char > * resultptr = new ofColor_< unsigned char >((const ofColor_< unsigned char > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_getColor__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; int arg2 ; ofColor_< unsigned char > result; - SWIG_check_num_args("ofImage_< unsigned char >::getColor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::getColor",1,"ofImage_< unsigned char > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::getColor",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_getColor",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } arg2 = (int)lua_tonumber(L, 2); - result = ((ofImage_< unsigned char > const *)arg1)->getColor(arg2); { - ofColor_< unsigned char > * resultptr = new ofColor_< unsigned char >((const ofColor_< unsigned char > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_getColor(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Image_getColor__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_Image_getColor__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Image_getColor'\n" " Possible C/C++ prototypes are:\n" - " ofImage_< unsigned char >::getColor(int,int) const\n" " ofImage_< unsigned char >::getColor(int) const\n"); - lua_error(L);return 0; } -static int _wrap_Image_getHeight(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; float result; - SWIG_check_num_args("ofImage_< unsigned char >::getHeight",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::getHeight",1,"ofImage_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_getHeight",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } - result = (float)((ofImage_< unsigned char > const *)arg1)->getHeight(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_getWidth(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; float result; - SWIG_check_num_args("ofImage_< unsigned char >::getWidth",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::getWidth",1,"ofImage_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_getWidth",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } - result = (float)((ofImage_< unsigned char > const *)arg1)->getWidth(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_setColor__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; int arg2 ; int arg3 ; - ofColor_< unsigned char > *arg4 = 0 ; SWIG_check_num_args("ofImage_< unsigned char >::setColor",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::setColor",1,"ofImage_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::setColor",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned char >::setColor",3,"int"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofImage_< unsigned char >::setColor",4,"ofColor_< unsigned char > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_setColor",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_setColor",4,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - (arg1)->setColor(arg2,arg3,(ofColor_< unsigned char > const &)*arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Image_setColor__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; int arg2 ; ofColor_< unsigned char > *arg3 = 0 ; - SWIG_check_num_args("ofImage_< unsigned char >::setColor",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::setColor",1,"ofImage_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::setColor",2,"int"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofImage_< unsigned char >::setColor",3,"ofColor_< unsigned char > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_setColor",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } arg2 = (int)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_setColor",3,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - (arg1)->setColor(arg2,(ofColor_< unsigned char > const &)*arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Image_setColor__SWIG_2(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; ofColor_< unsigned char > *arg2 = 0 ; - SWIG_check_num_args("ofImage_< unsigned char >::setColor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::setColor",1,"ofImage_< unsigned char > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::setColor",2,"ofColor_< unsigned char > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_setColor",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_setColor",2,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - (arg1)->setColor((ofColor_< unsigned char > const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Image_setColor(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Image_setColor__SWIG_2(L);} } } if (argc == 3) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Image_setColor__SWIG_1(L);} } } } if (argc == 4) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Image_setColor__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Image_setColor'\n" " Possible C/C++ prototypes are:\n" - " ofImage_< unsigned char >::setColor(int,int,ofColor_< unsigned char > const &)\n" - " ofImage_< unsigned char >::setColor(int,ofColor_< unsigned char > const &)\n" - " ofImage_< unsigned char >::setColor(ofColor_< unsigned char > const &)\n"); lua_error(L);return 0; } -static int _wrap_Image_setFromPixels__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; unsigned char *arg2 = (unsigned char *) 0 ; int arg3 ; - int arg4 ; ofImageType arg5 ; bool arg6 ; SWIG_check_num_args("ofImage_< unsigned char >::setFromPixels",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::setFromPixels",1,"ofImage_< unsigned char > *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::setFromPixels",2,"unsigned char const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned char >::setFromPixels",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< unsigned char >::setFromPixels",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< unsigned char >::setFromPixels",5,"ofImageType"); - if(!lua_isboolean(L,6)) SWIG_fail_arg("ofImage_< unsigned char >::setFromPixels",6,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_setFromPixels",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_unsigned_char,0))){ - SWIG_fail_ptr("Image_setFromPixels",2,SWIGTYPE_p_unsigned_char); } arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); arg5 = (ofImageType)(int)lua_tonumber(L, 5); arg6 = (lua_toboolean(L, 6)!=0); - (arg1)->setFromPixels((unsigned char const *)arg2,arg3,arg4,arg5,arg6); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Image_setFromPixels__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; unsigned char *arg2 = (unsigned char *) 0 ; int arg3 ; - int arg4 ; ofImageType arg5 ; SWIG_check_num_args("ofImage_< unsigned char >::setFromPixels",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::setFromPixels",1,"ofImage_< unsigned char > *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::setFromPixels",2,"unsigned char const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned char >::setFromPixels",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< unsigned char >::setFromPixels",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< unsigned char >::setFromPixels",5,"ofImageType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_setFromPixels",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_unsigned_char,0))){ - SWIG_fail_ptr("Image_setFromPixels",2,SWIGTYPE_p_unsigned_char); } arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); arg5 = (ofImageType)(int)lua_tonumber(L, 5); - (arg1)->setFromPixels((unsigned char const *)arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Image_setFromPixels__SWIG_2(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; ofPixels_< unsigned char > *arg2 = 0 ; - SWIG_check_num_args("ofImage_< unsigned char >::setFromPixels",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::setFromPixels",1,"ofImage_< unsigned char > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::setFromPixels",2,"ofPixels_< unsigned char > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_setFromPixels",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_setFromPixels",2,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - (arg1)->setFromPixels((ofPixels_< unsigned char > const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Image_setFromPixels(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Image_setFromPixels__SWIG_2(L);} } } if (argc == 5) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_unsigned_char, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_Image_setFromPixels__SWIG_1(L);} } } } } } - if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_unsigned_char, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isboolean(L,argv[5]); } if (_v) { - return _wrap_Image_setFromPixels__SWIG_0(L);} } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Image_setFromPixels'\n" - " Possible C/C++ prototypes are:\n" - " ofImage_< unsigned char >::setFromPixels(unsigned char const *,int,int,ofImageType,bool)\n" - " ofImage_< unsigned char >::setFromPixels(unsigned char const *,int,int,ofImageType)\n" - " ofImage_< unsigned char >::setFromPixels(ofPixels_< unsigned char > const &)\n"); lua_error(L);return 0; } -static int _wrap_Image_grabScreen(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; int arg2 ; int arg3 ; int arg4 ; int arg5 ; - SWIG_check_num_args("ofImage_< unsigned char >::grabScreen",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::grabScreen",1,"ofImage_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::grabScreen",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned char >::grabScreen",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< unsigned char >::grabScreen",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< unsigned char >::grabScreen",5,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_grabScreen",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); - (arg1)->grabScreen(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_setImageType(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; ofImageType arg2 ; - SWIG_check_num_args("ofImage_< unsigned char >::setImageType",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::setImageType",1,"ofImage_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::setImageType",2,"ofImageType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_setImageType",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } arg2 = (ofImageType)(int)lua_tonumber(L, 2); - (arg1)->setImageType(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_getImageType(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; ofImageType result; - SWIG_check_num_args("ofImage_< unsigned char >::getImageType",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::getImageType",1,"ofImage_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_getImageType",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } - result = (ofImageType)((ofImage_< unsigned char > const *)arg1)->getImageType(); - lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Image_resize(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; int arg2 ; int arg3 ; - SWIG_check_num_args("ofImage_< unsigned char >::resize",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::resize",1,"ofImage_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::resize",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned char >::resize",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_resize",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); (arg1)->resize(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Image_crop(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; int arg2 ; int arg3 ; int arg4 ; int arg5 ; - SWIG_check_num_args("ofImage_< unsigned char >::crop",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::crop",1,"ofImage_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::crop",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned char >::crop",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< unsigned char >::crop",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< unsigned char >::crop",5,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_crop",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); - (arg1)->crop(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_cropFrom(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; ofImage_< unsigned char > *arg2 = 0 ; int arg3 ; - int arg4 ; int arg5 ; int arg6 ; SWIG_check_num_args("ofImage_< unsigned char >::cropFrom",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::cropFrom",1,"ofImage_< unsigned char > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::cropFrom",2,"ofImage_< unsigned char > &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned char >::cropFrom",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< unsigned char >::cropFrom",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< unsigned char >::cropFrom",5,"int"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofImage_< unsigned char >::cropFrom",6,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_cropFrom",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_cropFrom",2,SWIGTYPE_p_ofImage_T_unsigned_char_t); } arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); arg6 = (int)lua_tonumber(L, 6); - (arg1)->cropFrom(*arg2,arg3,arg4,arg5,arg6); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_rotate90(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; int arg2 ; - SWIG_check_num_args("ofImage_< unsigned char >::rotate90",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::rotate90",1,"ofImage_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::rotate90",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_rotate90",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->rotate90(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_mirror(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; bool arg2 ; bool arg3 ; - SWIG_check_num_args("ofImage_< unsigned char >::mirror",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::mirror",1,"ofImage_< unsigned char > *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::mirror",2,"bool"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofImage_< unsigned char >::mirror",3,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_mirror",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } arg2 = (lua_toboolean(L, 2)!=0); - arg3 = (lua_toboolean(L, 3)!=0); (arg1)->mirror(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Image_setAnchorPercent(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofImage_< unsigned char >::setAnchorPercent",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::setAnchorPercent",1,"ofImage_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::setAnchorPercent",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned char >::setAnchorPercent",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_setAnchorPercent",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->setAnchorPercent(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Image_setAnchorPoint(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofImage_< unsigned char >::setAnchorPoint",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::setAnchorPoint",1,"ofImage_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::setAnchorPoint",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned char >::setAnchorPoint",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_setAnchorPoint",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->setAnchorPoint(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Image_resetAnchor(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; - SWIG_check_num_args("ofImage_< unsigned char >::resetAnchor",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::resetAnchor",1,"ofImage_< unsigned char > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_resetAnchor",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } (arg1)->resetAnchor(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_save__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; std::string arg2 ; ofImageQualityType arg3 ; - SWIG_check_num_args("ofImage_< unsigned char >::save",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::save",1,"ofImage_< unsigned char > *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::save",2,"std::string"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned char >::save",3,"ofImageQualityType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_save",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } (&arg2)->assign(lua_tostring(L,2),lua_rawlen(L,2)); - arg3 = (ofImageQualityType)(int)lua_tonumber(L, 3); (arg1)->save(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Image_save__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; std::string arg2 ; - SWIG_check_num_args("ofImage_< unsigned char >::save",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::save",1,"ofImage_< unsigned char > *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::save",2,"std::string"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_save",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } (&arg2)->assign(lua_tostring(L,2),lua_rawlen(L,2)); - (arg1)->save(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_save__SWIG_2(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; ofBuffer *arg2 = 0 ; ofImageQualityType arg3 ; - SWIG_check_num_args("ofImage_< unsigned char >::save",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::save",1,"ofImage_< unsigned char > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::save",2,"ofBuffer &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned char >::save",3,"ofImageQualityType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_save",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBuffer,0))){ SWIG_fail_ptr("Image_save",2,SWIGTYPE_p_ofBuffer); } - arg3 = (ofImageQualityType)(int)lua_tonumber(L, 3); (arg1)->save(*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Image_save__SWIG_3(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; ofBuffer *arg2 = 0 ; - SWIG_check_num_args("ofImage_< unsigned char >::save",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::save",1,"ofImage_< unsigned char > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::save",2,"ofBuffer &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_save",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBuffer,0))){ SWIG_fail_ptr("Image_save",2,SWIGTYPE_p_ofBuffer); } - (arg1)->save(*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_save__SWIG_4(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; ofFile *arg2 = 0 ; ofImageQualityType arg3 ; - SWIG_check_num_args("ofImage_< unsigned char >::save",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::save",1,"ofImage_< unsigned char > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::save",2,"ofFile const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned char >::save",3,"ofImageQualityType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_save",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("Image_save",2,SWIGTYPE_p_ofFile); } - arg3 = (ofImageQualityType)(int)lua_tonumber(L, 3); (arg1)->save((ofFile const &)*arg2,arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_save__SWIG_5(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; ofFile *arg2 = 0 ; - SWIG_check_num_args("ofImage_< unsigned char >::save",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::save",1,"ofImage_< unsigned char > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::save",2,"ofFile const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_save",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("Image_save",2,SWIGTYPE_p_ofFile); } - (arg1)->save((ofFile const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_save(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBuffer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Image_save__SWIG_3(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Image_save__SWIG_5(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { - return _wrap_Image_save__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Image_save__SWIG_4(L);} } } - } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBuffer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Image_save__SWIG_2(L);} } } - } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_Image_save__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Image_save'\n" " Possible C/C++ prototypes are:\n" - " ofImage_< unsigned char >::save(std::string,ofImageQualityType)\n" " ofImage_< unsigned char >::save(std::string)\n" - " ofImage_< unsigned char >::save(ofBuffer &,ofImageQualityType)\n" " ofImage_< unsigned char >::save(ofBuffer &)\n" - " ofImage_< unsigned char >::save(ofFile const &,ofImageQualityType)\n" - " ofImage_< unsigned char >::save(ofFile const &)\n"); lua_error(L);return 0; } -static void swig_delete_Image(void *obj) { -ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) obj; -delete arg1; -} -static int _proxy__wrap_new_Image(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_Image); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_Image_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_Image_methods[]= { - { "allocate", _wrap_Image_allocate}, - { "isAllocated", _wrap_Image_isAllocated}, - { "clear", _wrap_Image_clear}, - { "load", _wrap_Image_load}, - { "draw", _wrap_Image_draw}, - { "drawSubsection", _wrap_Image_drawSubsection}, - { "update", _wrap_Image_update}, - { "setUseTexture", _wrap_Image_setUseTexture}, - { "isUsingTexture", _wrap_Image_isUsingTexture}, - { "getTexture", _wrap_Image_getTexture}, - { "bind", _wrap_Image_bind}, - { "unbind", _wrap_Image_unbind}, - { "setCompression", _wrap_Image_setCompression}, - { "getColor", _wrap_Image_getColor}, - { "getHeight", _wrap_Image_getHeight}, - { "getWidth", _wrap_Image_getWidth}, - { "setColor", _wrap_Image_setColor}, - { "setFromPixels", _wrap_Image_setFromPixels}, - { "grabScreen", _wrap_Image_grabScreen}, - { "setImageType", _wrap_Image_setImageType}, - { "getImageType", _wrap_Image_getImageType}, - { "resize", _wrap_Image_resize}, - { "crop", _wrap_Image_crop}, - { "cropFrom", _wrap_Image_cropFrom}, - { "rotate90", _wrap_Image_rotate90}, - { "mirror", _wrap_Image_mirror}, - { "setAnchorPercent", _wrap_Image_setAnchorPercent}, - { "setAnchorPoint", _wrap_Image_setAnchorPoint}, - { "resetAnchor", _wrap_Image_resetAnchor}, - { "save", _wrap_Image_save}, - {0,0} -}; -static swig_lua_method swig_Image_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_Image_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_Image_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_Image_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_Image_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_Image_Sf_SwigStatic = { - "Image", - swig_Image_Sf_SwigStatic_methods, - swig_Image_Sf_SwigStatic_attributes, - swig_Image_Sf_SwigStatic_constants, - swig_Image_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_Image_bases[] = {0}; -static const char *swig_Image_base_names[] = {0}; -static swig_lua_class _wrap_class_Image = { "Image", "Image", &SWIGTYPE_p_ofImage_T_unsigned_char_t,_proxy__wrap_new_Image, swig_delete_Image, swig_Image_methods, swig_Image_attributes, &swig_Image_Sf_SwigStatic, swig_Image_meta, swig_Image_bases, swig_Image_base_names }; - -static int _wrap_new_FloatImage__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *result = 0 ; - SWIG_check_num_args("ofImage_< float >::ofImage_",0,0) result = (ofImage_< float > *)new ofImage_< float >(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofImage_T_float_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_FloatImage__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPixels_< float > *arg1 = 0 ; - ofImage_< float > *result = 0 ; SWIG_check_num_args("ofImage_< float >::ofImage_",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofImage_< float >::ofImage_",1,"ofPixels_< float > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("new_FloatImage",1,SWIGTYPE_p_ofPixels_T_float_t); } - result = (ofImage_< float > *)new ofImage_< float >((ofPixels_< float > const &)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofImage_T_float_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_FloatImage__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = 0 ; ofImage_< float > *result = 0 ; - SWIG_check_num_args("ofImage_< float >::ofImage_",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofImage_< float >::ofImage_",1,"ofFile const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("new_FloatImage",1,SWIGTYPE_p_ofFile); } - result = (ofImage_< float > *)new ofImage_< float >((ofFile const &)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofImage_T_float_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_FloatImage__SWIG_3(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - ofImage_< float > *result = 0 ; SWIG_check_num_args("ofImage_< float >::ofImage_",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofImage_< float >::ofImage_",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; - result = (ofImage_< float > *)new ofImage_< float >((std::string const &)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofImage_T_float_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_FloatImage__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = 0 ; - ofImage_< float > *result = 0 ; SWIG_check_num_args("ofImage_< float >::ofImage_",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofImage_< float >::ofImage_",1,"ofImage_< float > &&"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("new_FloatImage",1,SWIGTYPE_p_ofImage_T_float_t); } - result = (ofImage_< float > *)new ofImage_< float >((ofImage_< float > &&)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofImage_T_float_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_FloatImage(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_FloatImage__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_new_FloatImage__SWIG_1(L);} } if (argc == 1) { int _v; { - void *ptr; if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_new_FloatImage__SWIG_2(L);} } if (argc == 1) { int _v; { - void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_new_FloatImage__SWIG_4(L);} } if (argc == 1) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { return _wrap_new_FloatImage__SWIG_3(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_FloatImage'\n" " Possible C/C++ prototypes are:\n" - " ofImage_< float >::ofImage_()\n" " ofImage_< float >::ofImage_(ofPixels_< float > const &)\n" - " ofImage_< float >::ofImage_(ofFile const &)\n" " ofImage_< float >::ofImage_(std::string const &)\n" - " ofImage_< float >::ofImage_(ofImage_< float > &&)\n"); lua_error(L);return 0; } -static int _wrap_FloatImage_allocate(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - int arg2 ; int arg3 ; ofImageType arg4 ; SWIG_check_num_args("ofImage_< float >::allocate",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::allocate",1,"ofImage_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< float >::allocate",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< float >::allocate",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< float >::allocate",4,"ofImageType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_allocate",1,SWIGTYPE_p_ofImage_T_float_t); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); arg4 = (ofImageType)(int)lua_tonumber(L, 4); (arg1)->allocate(arg2,arg3,arg4); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_isAllocated(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - bool result; SWIG_check_num_args("ofImage_< float >::isAllocated",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::isAllocated",1,"ofImage_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_isAllocated",1,SWIGTYPE_p_ofImage_T_float_t); } - result = (bool)((ofImage_< float > const *)arg1)->isAllocated(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_clear(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - SWIG_check_num_args("ofImage_< float >::clear",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::clear",1,"ofImage_< float > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_clear",1,SWIGTYPE_p_ofImage_T_float_t); } (arg1)->clear(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_load__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - std::string *arg2 = 0 ; std::string temp2 ; bool result; SWIG_check_num_args("ofImage_< float >::load",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::load",1,"ofImage_< float > *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofImage_< float >::load",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_load",1,SWIGTYPE_p_ofImage_T_float_t); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; result = (bool)(arg1)->load((std::string const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_load__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - ofBuffer *arg2 = 0 ; bool result; SWIG_check_num_args("ofImage_< float >::load",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::load",1,"ofImage_< float > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofImage_< float >::load",2,"ofBuffer const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_load",1,SWIGTYPE_p_ofImage_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBuffer,0))){ - SWIG_fail_ptr("FloatImage_load",2,SWIGTYPE_p_ofBuffer); } result = (bool)(arg1)->load((ofBuffer const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_load__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - ofFile *arg2 = 0 ; bool result; SWIG_check_num_args("ofImage_< float >::load",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::load",1,"ofImage_< float > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofImage_< float >::load",2,"ofFile const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_load",1,SWIGTYPE_p_ofImage_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofFile,0))){ - SWIG_fail_ptr("FloatImage_load",2,SWIGTYPE_p_ofFile); } result = (bool)(arg1)->load((ofFile const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_load(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v; - { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBuffer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_FloatImage_load__SWIG_1(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_FloatImage_load__SWIG_2(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { - return _wrap_FloatImage_load__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatImage_load'\n" " Possible C/C++ prototypes are:\n" - " ofImage_< float >::load(std::string const &)\n" " ofImage_< float >::load(ofBuffer const &)\n" - " ofImage_< float >::load(ofFile const &)\n"); lua_error(L);return 0; } -static int _wrap_FloatImage_draw__SWIG_0_0(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - ofPoint *arg2 = 0 ; SWIG_check_num_args("draw",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("draw",1,"ofImage_< float > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("draw",2,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_draw",1,SWIGTYPE_p_ofImage_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("FloatImage_draw",2,SWIGTYPE_p_ofVec3f); } ((ofImage_< float > const *)arg1)->draw((ofPoint const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_draw__SWIG_0_1(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - ofRectangle *arg2 = 0 ; SWIG_check_num_args("draw",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("draw",1,"ofImage_< float > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("draw",2,"ofRectangle const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_draw",1,SWIGTYPE_p_ofImage_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("FloatImage_draw",2,SWIGTYPE_p_ofRectangle); } - ((ofImage_< float > const *)arg1)->draw((ofRectangle const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FloatImage_draw__SWIG_0_2(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - ofPoint *arg2 = 0 ; float arg3 ; float arg4 ; SWIG_check_num_args("draw",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("draw",1,"ofImage_< float > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("draw",2,"ofPoint const &"); if(!lua_isnumber(L,3)) SWIG_fail_arg("draw",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("draw",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_draw",1,SWIGTYPE_p_ofImage_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("FloatImage_draw",2,SWIGTYPE_p_ofVec3f); } arg3 = (float)lua_tonumber(L, 3); - arg4 = (float)lua_tonumber(L, 4); ((ofImage_< float > const *)arg1)->draw((ofPoint const &)*arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_draw__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - float arg2 ; float arg3 ; SWIG_check_num_args("ofImage_< float >::draw",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::draw",1,"ofImage_< float > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< float >::draw",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< float >::draw",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_draw",1,SWIGTYPE_p_ofImage_T_float_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); ((ofImage_< float > const *)arg1)->draw(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_draw__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - float arg2 ; float arg3 ; float arg4 ; SWIG_check_num_args("ofImage_< float >::draw",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::draw",1,"ofImage_< float > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< float >::draw",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< float >::draw",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< float >::draw",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_draw",1,SWIGTYPE_p_ofImage_T_float_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); ((ofImage_< float > const *)arg1)->draw(arg2,arg3,arg4); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_draw__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - float arg2 ; float arg3 ; float arg4 ; float arg5 ; SWIG_check_num_args("ofImage_< float >::draw",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::draw",1,"ofImage_< float > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< float >::draw",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< float >::draw",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< float >::draw",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< float >::draw",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_draw",1,SWIGTYPE_p_ofImage_T_float_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - ((ofImage_< float > const *)arg1)->draw(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FloatImage_draw__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - float arg2 ; float arg3 ; float arg4 ; float arg5 ; float arg6 ; SWIG_check_num_args("ofImage_< float >::draw",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::draw",1,"ofImage_< float > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< float >::draw",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< float >::draw",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< float >::draw",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< float >::draw",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofImage_< float >::draw",6,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_draw",1,SWIGTYPE_p_ofImage_T_float_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); ((ofImage_< float > const *)arg1)->draw(arg2,arg3,arg4,arg5,arg6); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_draw(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_FloatImage_draw__SWIG_0_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_FloatImage_draw__SWIG_0_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_FloatImage_draw__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_FloatImage_draw__SWIG_0_2(L);} } } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_FloatImage_draw__SWIG_2(L);} } } } } - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_FloatImage_draw__SWIG_3(L);} } } } } } if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { return _wrap_FloatImage_draw__SWIG_4(L);} } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatImage_draw'\n" " Possible C/C++ prototypes are:\n" - " draw(ofPoint const &) const\n" " draw(ofRectangle const &) const\n" " draw(ofPoint const &,float,float) const\n" - " ofImage_< float >::draw(float,float) const\n" " ofImage_< float >::draw(float,float,float) const\n" - " ofImage_< float >::draw(float,float,float,float) const\n" - " ofImage_< float >::draw(float,float,float,float,float) const\n"); lua_error(L);return 0; } -static int _wrap_FloatImage_drawSubsection__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; float arg2 ; float arg3 ; float arg4 ; float arg5 ; float arg6 ; - float arg7 ; SWIG_check_num_args("ofImage_< float >::drawSubsection",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::drawSubsection",1,"ofImage_< float > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< float >::drawSubsection",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< float >::drawSubsection",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< float >::drawSubsection",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< float >::drawSubsection",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofImage_< float >::drawSubsection",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofImage_< float >::drawSubsection",7,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_drawSubsection",1,SWIGTYPE_p_ofImage_T_float_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); - ((ofImage_< float > const *)arg1)->drawSubsection(arg2,arg3,arg4,arg5,arg6,arg7); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_drawSubsection__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; float arg2 ; float arg3 ; float arg4 ; float arg5 ; float arg6 ; - float arg7 ; float arg8 ; SWIG_check_num_args("ofImage_< float >::drawSubsection",8,8) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::drawSubsection",1,"ofImage_< float > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< float >::drawSubsection",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< float >::drawSubsection",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< float >::drawSubsection",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< float >::drawSubsection",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofImage_< float >::drawSubsection",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofImage_< float >::drawSubsection",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofImage_< float >::drawSubsection",8,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_drawSubsection",1,SWIGTYPE_p_ofImage_T_float_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (float)lua_tonumber(L, 8); - ((ofImage_< float > const *)arg1)->drawSubsection(arg2,arg3,arg4,arg5,arg6,arg7,arg8); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_drawSubsection__SWIG_2(lua_State* L) { int SWIG_arg = 0; - ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; float arg2 ; float arg3 ; float arg4 ; float arg5 ; float arg6 ; - float arg7 ; float arg8 ; float arg9 ; SWIG_check_num_args("ofImage_< float >::drawSubsection",9,9) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::drawSubsection",1,"ofImage_< float > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< float >::drawSubsection",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< float >::drawSubsection",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< float >::drawSubsection",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< float >::drawSubsection",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofImage_< float >::drawSubsection",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofImage_< float >::drawSubsection",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofImage_< float >::drawSubsection",8,"float"); - if(!lua_isnumber(L,9)) SWIG_fail_arg("ofImage_< float >::drawSubsection",9,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_drawSubsection",1,SWIGTYPE_p_ofImage_T_float_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (float)lua_tonumber(L, 8); - arg9 = (float)lua_tonumber(L, 9); ((ofImage_< float > const *)arg1)->drawSubsection(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_drawSubsection__SWIG_3(lua_State* L) { int SWIG_arg = 0; - ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; float arg2 ; float arg3 ; float arg4 ; float arg5 ; float arg6 ; - float arg7 ; float arg8 ; float arg9 ; float arg10 ; SWIG_check_num_args("ofImage_< float >::drawSubsection",10,10) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::drawSubsection",1,"ofImage_< float > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< float >::drawSubsection",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< float >::drawSubsection",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< float >::drawSubsection",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< float >::drawSubsection",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofImage_< float >::drawSubsection",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofImage_< float >::drawSubsection",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofImage_< float >::drawSubsection",8,"float"); - if(!lua_isnumber(L,9)) SWIG_fail_arg("ofImage_< float >::drawSubsection",9,"float"); - if(!lua_isnumber(L,10)) SWIG_fail_arg("ofImage_< float >::drawSubsection",10,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_drawSubsection",1,SWIGTYPE_p_ofImage_T_float_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (float)lua_tonumber(L, 8); - arg9 = (float)lua_tonumber(L, 9); arg10 = (float)lua_tonumber(L, 10); - ((ofImage_< float > const *)arg1)->drawSubsection(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_drawSubsection(lua_State* L) { int argc; int argv[11]={ 1,2,3,4,5,6,7,8,9,10,11} ; - argc = lua_gettop(L); if (argc == 7) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { - return _wrap_FloatImage_drawSubsection__SWIG_0(L);} } } } } } } } if (argc == 8) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { return _wrap_FloatImage_drawSubsection__SWIG_1(L);} } } } } } - } } } if (argc == 9) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { { _v = lua_isnumber(L,argv[8]); } if (_v) { - return _wrap_FloatImage_drawSubsection__SWIG_2(L);} } } } } } } } } } if (argc == 10) { int _v; - { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { { _v = lua_isnumber(L,argv[8]); } if (_v) { { - _v = lua_isnumber(L,argv[9]); } if (_v) { return _wrap_FloatImage_drawSubsection__SWIG_3(L);} } } } - } } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatImage_drawSubsection'\n" - " Possible C/C++ prototypes are:\n" " ofImage_< float >::drawSubsection(float,float,float,float,float,float) const\n" - " ofImage_< float >::drawSubsection(float,float,float,float,float,float,float) const\n" - " ofImage_< float >::drawSubsection(float,float,float,float,float,float,float,float) const\n" - " ofImage_< float >::drawSubsection(float,float,float,float,float,float,float,float,float) const\n"); - lua_error(L);return 0; } -static int _wrap_FloatImage_update(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - SWIG_check_num_args("ofImage_< float >::update",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::update",1,"ofImage_< float > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_update",1,SWIGTYPE_p_ofImage_T_float_t); } (arg1)->update(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_setUseTexture(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - bool arg2 ; SWIG_check_num_args("ofImage_< float >::setUseTexture",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::setUseTexture",1,"ofImage_< float > *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofImage_< float >::setUseTexture",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_setUseTexture",1,SWIGTYPE_p_ofImage_T_float_t); } arg2 = (lua_toboolean(L, 2)!=0); - (arg1)->setUseTexture(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_isUsingTexture(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - bool result; SWIG_check_num_args("ofImage_< float >::isUsingTexture",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::isUsingTexture",1,"ofImage_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_isUsingTexture",1,SWIGTYPE_p_ofImage_T_float_t); } - result = (bool)((ofImage_< float > const *)arg1)->isUsingTexture(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_getTexture__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; ofTexture *result = 0 ; - SWIG_check_num_args("ofImage_< float >::getTexture",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::getTexture",1,"ofImage_< float > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_getTexture",1,SWIGTYPE_p_ofImage_T_float_t); } result = (ofTexture *) &(arg1)->getTexture(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTexture,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FloatImage_getTexture__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; ofTexture *result = 0 ; - SWIG_check_num_args("ofImage_< float >::getTexture",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::getTexture",1,"ofImage_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_getTexture",1,SWIGTYPE_p_ofImage_T_float_t); } - result = (ofTexture *) &((ofImage_< float > const *)arg1)->getTexture(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTexture,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FloatImage_getTexture(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_FloatImage_getTexture__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_FloatImage_getTexture__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatImage_getTexture'\n" - " Possible C/C++ prototypes are:\n" " ofImage_< float >::getTexture()\n" " ofImage_< float >::getTexture() const\n"); - lua_error(L);return 0; } -static int _wrap_FloatImage_bind__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - int arg2 ; SWIG_check_num_args("ofImage_< float >::bind",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::bind",1,"ofImage_< float > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< float >::bind",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_bind",1,SWIGTYPE_p_ofImage_T_float_t); } arg2 = (int)lua_tonumber(L, 2); - ((ofImage_< float > const *)arg1)->bind(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_bind__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - SWIG_check_num_args("ofImage_< float >::bind",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::bind",1,"ofImage_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_bind",1,SWIGTYPE_p_ofImage_T_float_t); } ((ofImage_< float > const *)arg1)->bind(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_bind(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; - { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_FloatImage_bind__SWIG_1(L);} } if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_FloatImage_bind__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatImage_bind'\n" " Possible C/C++ prototypes are:\n" - " ofImage_< float >::bind(int) const\n" " ofImage_< float >::bind() const\n"); lua_error(L);return 0; } -static int _wrap_FloatImage_unbind__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - int arg2 ; SWIG_check_num_args("ofImage_< float >::unbind",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::unbind",1,"ofImage_< float > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< float >::unbind",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_unbind",1,SWIGTYPE_p_ofImage_T_float_t); } arg2 = (int)lua_tonumber(L, 2); - ((ofImage_< float > const *)arg1)->unbind(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_unbind__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - SWIG_check_num_args("ofImage_< float >::unbind",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::unbind",1,"ofImage_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_unbind",1,SWIGTYPE_p_ofImage_T_float_t); } ((ofImage_< float > const *)arg1)->unbind(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_unbind(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_FloatImage_unbind__SWIG_1(L);} } if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_FloatImage_unbind__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatImage_unbind'\n" " Possible C/C++ prototypes are:\n" - " ofImage_< float >::unbind(int) const\n" " ofImage_< float >::unbind() const\n"); lua_error(L);return 0; } -static int _wrap_FloatImage_setCompression(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - ofTexCompression arg2 ; SWIG_check_num_args("ofImage_< float >::setCompression",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::setCompression",1,"ofImage_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< float >::setCompression",2,"ofTexCompression"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_setCompression",1,SWIGTYPE_p_ofImage_T_float_t); } - arg2 = (ofTexCompression)(int)lua_tonumber(L, 2); (arg1)->setCompression(arg2); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_getColor__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; int arg2 ; int arg3 ; ofColor_< float > result; - SWIG_check_num_args("ofImage_< float >::getColor",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::getColor",1,"ofImage_< float > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< float >::getColor",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< float >::getColor",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_getColor",1,SWIGTYPE_p_ofImage_T_float_t); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); result = ((ofImage_< float > const *)arg1)->getColor(arg2,arg3); { - ofColor_< float > * resultptr = new ofColor_< float >((const ofColor_< float > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_getColor__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; int arg2 ; ofColor_< float > result; - SWIG_check_num_args("ofImage_< float >::getColor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::getColor",1,"ofImage_< float > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< float >::getColor",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_getColor",1,SWIGTYPE_p_ofImage_T_float_t); } arg2 = (int)lua_tonumber(L, 2); - result = ((ofImage_< float > const *)arg1)->getColor(arg2); { - ofColor_< float > * resultptr = new ofColor_< float >((const ofColor_< float > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_getColor(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_FloatImage_getColor__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_FloatImage_getColor__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatImage_getColor'\n" - " Possible C/C++ prototypes are:\n" " ofImage_< float >::getColor(int,int) const\n" - " ofImage_< float >::getColor(int) const\n"); lua_error(L);return 0; } -static int _wrap_FloatImage_getHeight(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - float result; SWIG_check_num_args("ofImage_< float >::getHeight",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::getHeight",1,"ofImage_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_getHeight",1,SWIGTYPE_p_ofImage_T_float_t); } - result = (float)((ofImage_< float > const *)arg1)->getHeight(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_getWidth(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - float result; SWIG_check_num_args("ofImage_< float >::getWidth",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::getWidth",1,"ofImage_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_getWidth",1,SWIGTYPE_p_ofImage_T_float_t); } - result = (float)((ofImage_< float > const *)arg1)->getWidth(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_setColor__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; int arg2 ; int arg3 ; ofColor_< float > *arg4 = 0 ; - SWIG_check_num_args("ofImage_< float >::setColor",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::setColor",1,"ofImage_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< float >::setColor",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< float >::setColor",3,"int"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofImage_< float >::setColor",4,"ofColor_< float > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_setColor",1,SWIGTYPE_p_ofImage_T_float_t); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_setColor",4,SWIGTYPE_p_ofColor_T_float_t); } - (arg1)->setColor(arg2,arg3,(ofColor_< float > const &)*arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FloatImage_setColor__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; int arg2 ; ofColor_< float > *arg3 = 0 ; - SWIG_check_num_args("ofImage_< float >::setColor",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::setColor",1,"ofImage_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< float >::setColor",2,"int"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofImage_< float >::setColor",3,"ofColor_< float > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_setColor",1,SWIGTYPE_p_ofImage_T_float_t); } arg2 = (int)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_setColor",3,SWIGTYPE_p_ofColor_T_float_t); } - (arg1)->setColor(arg2,(ofColor_< float > const &)*arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FloatImage_setColor__SWIG_2(lua_State* L) { int SWIG_arg = 0; - ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; ofColor_< float > *arg2 = 0 ; - SWIG_check_num_args("ofImage_< float >::setColor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::setColor",1,"ofImage_< float > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofImage_< float >::setColor",2,"ofColor_< float > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_setColor",1,SWIGTYPE_p_ofImage_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_setColor",2,SWIGTYPE_p_ofColor_T_float_t); } (arg1)->setColor((ofColor_< float > const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_setColor(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_FloatImage_setColor__SWIG_2(L);} } } if (argc == 3) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_FloatImage_setColor__SWIG_1(L);} } } } if (argc == 4) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_FloatImage_setColor__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatImage_setColor'\n" - " Possible C/C++ prototypes are:\n" " ofImage_< float >::setColor(int,int,ofColor_< float > const &)\n" - " ofImage_< float >::setColor(int,ofColor_< float > const &)\n" - " ofImage_< float >::setColor(ofColor_< float > const &)\n"); lua_error(L);return 0; } -static int _wrap_FloatImage_setFromPixels__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; float *arg2 = (float *) 0 ; int arg3 ; int arg4 ; ofImageType arg5 ; - bool arg6 ; SWIG_check_num_args("ofImage_< float >::setFromPixels",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::setFromPixels",1,"ofImage_< float > *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofImage_< float >::setFromPixels",2,"float const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< float >::setFromPixels",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< float >::setFromPixels",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< float >::setFromPixels",5,"ofImageType"); - if(!lua_isboolean(L,6)) SWIG_fail_arg("ofImage_< float >::setFromPixels",6,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_setFromPixels",1,SWIGTYPE_p_ofImage_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("FloatImage_setFromPixels",2,SWIGTYPE_p_float); } arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); arg5 = (ofImageType)(int)lua_tonumber(L, 5); arg6 = (lua_toboolean(L, 6)!=0); - (arg1)->setFromPixels((float const *)arg2,arg3,arg4,arg5,arg6); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FloatImage_setFromPixels__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; float *arg2 = (float *) 0 ; int arg3 ; int arg4 ; ofImageType arg5 ; - SWIG_check_num_args("ofImage_< float >::setFromPixels",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::setFromPixels",1,"ofImage_< float > *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofImage_< float >::setFromPixels",2,"float const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< float >::setFromPixels",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< float >::setFromPixels",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< float >::setFromPixels",5,"ofImageType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_setFromPixels",1,SWIGTYPE_p_ofImage_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("FloatImage_setFromPixels",2,SWIGTYPE_p_float); } arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); arg5 = (ofImageType)(int)lua_tonumber(L, 5); - (arg1)->setFromPixels((float const *)arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FloatImage_setFromPixels__SWIG_2(lua_State* L) { int SWIG_arg = 0; - ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; ofPixels_< float > *arg2 = 0 ; - SWIG_check_num_args("ofImage_< float >::setFromPixels",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::setFromPixels",1,"ofImage_< float > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofImage_< float >::setFromPixels",2,"ofPixels_< float > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_setFromPixels",1,SWIGTYPE_p_ofImage_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_setFromPixels",2,SWIGTYPE_p_ofPixels_T_float_t); } - (arg1)->setFromPixels((ofPixels_< float > const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FloatImage_setFromPixels(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_FloatImage_setFromPixels__SWIG_2(L);} } } if (argc == 5) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_FloatImage_setFromPixels__SWIG_1(L);} } } } } } - if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isboolean(L,argv[5]); } if (_v) { - return _wrap_FloatImage_setFromPixels__SWIG_0(L);} } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatImage_setFromPixels'\n" - " Possible C/C++ prototypes are:\n" " ofImage_< float >::setFromPixels(float const *,int,int,ofImageType,bool)\n" - " ofImage_< float >::setFromPixels(float const *,int,int,ofImageType)\n" - " ofImage_< float >::setFromPixels(ofPixels_< float > const &)\n"); lua_error(L);return 0; } -static int _wrap_FloatImage_grabScreen(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - int arg2 ; int arg3 ; int arg4 ; int arg5 ; SWIG_check_num_args("ofImage_< float >::grabScreen",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::grabScreen",1,"ofImage_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< float >::grabScreen",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< float >::grabScreen",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< float >::grabScreen",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< float >::grabScreen",5,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_grabScreen",1,SWIGTYPE_p_ofImage_T_float_t); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); - (arg1)->grabScreen(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_setImageType(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - ofImageType arg2 ; SWIG_check_num_args("ofImage_< float >::setImageType",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::setImageType",1,"ofImage_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< float >::setImageType",2,"ofImageType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_setImageType",1,SWIGTYPE_p_ofImage_T_float_t); } arg2 = (ofImageType)(int)lua_tonumber(L, 2); - (arg1)->setImageType(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_getImageType(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - ofImageType result; SWIG_check_num_args("ofImage_< float >::getImageType",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::getImageType",1,"ofImage_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_getImageType",1,SWIGTYPE_p_ofImage_T_float_t); } - result = (ofImageType)((ofImage_< float > const *)arg1)->getImageType(); - lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FloatImage_resize(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - int arg2 ; int arg3 ; SWIG_check_num_args("ofImage_< float >::resize",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::resize",1,"ofImage_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< float >::resize",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< float >::resize",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_resize",1,SWIGTYPE_p_ofImage_T_float_t); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); (arg1)->resize(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FloatImage_crop(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - int arg2 ; int arg3 ; int arg4 ; int arg5 ; SWIG_check_num_args("ofImage_< float >::crop",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::crop",1,"ofImage_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< float >::crop",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< float >::crop",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< float >::crop",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< float >::crop",5,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_crop",1,SWIGTYPE_p_ofImage_T_float_t); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); - (arg1)->crop(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_cropFrom(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - ofImage_< float > *arg2 = 0 ; int arg3 ; int arg4 ; int arg5 ; int arg6 ; - SWIG_check_num_args("ofImage_< float >::cropFrom",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::cropFrom",1,"ofImage_< float > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofImage_< float >::cropFrom",2,"ofImage_< float > &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< float >::cropFrom",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< float >::cropFrom",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< float >::cropFrom",5,"int"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofImage_< float >::cropFrom",6,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_cropFrom",1,SWIGTYPE_p_ofImage_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_cropFrom",2,SWIGTYPE_p_ofImage_T_float_t); } arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); arg6 = (int)lua_tonumber(L, 6); - (arg1)->cropFrom(*arg2,arg3,arg4,arg5,arg6); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_rotate90(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - int arg2 ; SWIG_check_num_args("ofImage_< float >::rotate90",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::rotate90",1,"ofImage_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< float >::rotate90",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_rotate90",1,SWIGTYPE_p_ofImage_T_float_t); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->rotate90(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_mirror(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - bool arg2 ; bool arg3 ; SWIG_check_num_args("ofImage_< float >::mirror",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::mirror",1,"ofImage_< float > *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofImage_< float >::mirror",2,"bool"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofImage_< float >::mirror",3,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_mirror",1,SWIGTYPE_p_ofImage_T_float_t); } arg2 = (lua_toboolean(L, 2)!=0); - arg3 = (lua_toboolean(L, 3)!=0); (arg1)->mirror(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FloatImage_setAnchorPercent(lua_State* L) { int SWIG_arg = 0; - ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofImage_< float >::setAnchorPercent",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::setAnchorPercent",1,"ofImage_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< float >::setAnchorPercent",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< float >::setAnchorPercent",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_setAnchorPercent",1,SWIGTYPE_p_ofImage_T_float_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->setAnchorPercent(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FloatImage_setAnchorPoint(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - float arg2 ; float arg3 ; SWIG_check_num_args("ofImage_< float >::setAnchorPoint",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::setAnchorPoint",1,"ofImage_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< float >::setAnchorPoint",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< float >::setAnchorPoint",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_setAnchorPoint",1,SWIGTYPE_p_ofImage_T_float_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->setAnchorPoint(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FloatImage_resetAnchor(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - SWIG_check_num_args("ofImage_< float >::resetAnchor",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::resetAnchor",1,"ofImage_< float > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_resetAnchor",1,SWIGTYPE_p_ofImage_T_float_t); } (arg1)->resetAnchor(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_save__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - std::string arg2 ; ofImageQualityType arg3 ; SWIG_check_num_args("ofImage_< float >::save",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::save",1,"ofImage_< float > *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofImage_< float >::save",2,"std::string"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< float >::save",3,"ofImageQualityType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_save",1,SWIGTYPE_p_ofImage_T_float_t); } (&arg2)->assign(lua_tostring(L,2),lua_rawlen(L,2)); - arg3 = (ofImageQualityType)(int)lua_tonumber(L, 3); (arg1)->save(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_save__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - std::string arg2 ; SWIG_check_num_args("ofImage_< float >::save",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::save",1,"ofImage_< float > *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofImage_< float >::save",2,"std::string"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_save",1,SWIGTYPE_p_ofImage_T_float_t); } (&arg2)->assign(lua_tostring(L,2),lua_rawlen(L,2)); - (arg1)->save(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_save__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - ofBuffer *arg2 = 0 ; ofImageQualityType arg3 ; SWIG_check_num_args("ofImage_< float >::save",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::save",1,"ofImage_< float > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofImage_< float >::save",2,"ofBuffer &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< float >::save",3,"ofImageQualityType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_save",1,SWIGTYPE_p_ofImage_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBuffer,0))){ - SWIG_fail_ptr("FloatImage_save",2,SWIGTYPE_p_ofBuffer); } arg3 = (ofImageQualityType)(int)lua_tonumber(L, 3); - (arg1)->save(*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_save__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - ofBuffer *arg2 = 0 ; SWIG_check_num_args("ofImage_< float >::save",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::save",1,"ofImage_< float > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofImage_< float >::save",2,"ofBuffer &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_save",1,SWIGTYPE_p_ofImage_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBuffer,0))){ - SWIG_fail_ptr("FloatImage_save",2,SWIGTYPE_p_ofBuffer); } (arg1)->save(*arg2); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_save__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - ofFile *arg2 = 0 ; ofImageQualityType arg3 ; SWIG_check_num_args("ofImage_< float >::save",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::save",1,"ofImage_< float > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofImage_< float >::save",2,"ofFile const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< float >::save",3,"ofImageQualityType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_save",1,SWIGTYPE_p_ofImage_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofFile,0))){ - SWIG_fail_ptr("FloatImage_save",2,SWIGTYPE_p_ofFile); } arg3 = (ofImageQualityType)(int)lua_tonumber(L, 3); - (arg1)->save((ofFile const &)*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_save__SWIG_5(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - ofFile *arg2 = 0 ; SWIG_check_num_args("ofImage_< float >::save",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::save",1,"ofImage_< float > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofImage_< float >::save",2,"ofFile const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_save",1,SWIGTYPE_p_ofImage_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofFile,0))){ - SWIG_fail_ptr("FloatImage_save",2,SWIGTYPE_p_ofFile); } (arg1)->save((ofFile const &)*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_save(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBuffer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_FloatImage_save__SWIG_3(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_FloatImage_save__SWIG_5(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { - return _wrap_FloatImage_save__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_FloatImage_save__SWIG_4(L);} } - } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBuffer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_FloatImage_save__SWIG_2(L);} } - } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_FloatImage_save__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatImage_save'\n" " Possible C/C++ prototypes are:\n" - " ofImage_< float >::save(std::string,ofImageQualityType)\n" " ofImage_< float >::save(std::string)\n" - " ofImage_< float >::save(ofBuffer &,ofImageQualityType)\n" " ofImage_< float >::save(ofBuffer &)\n" - " ofImage_< float >::save(ofFile const &,ofImageQualityType)\n" " ofImage_< float >::save(ofFile const &)\n"); - lua_error(L);return 0; } -static void swig_delete_FloatImage(void *obj) { -ofImage_< float > *arg1 = (ofImage_< float > *) obj; -delete arg1; -} -static int _proxy__wrap_new_FloatImage(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_FloatImage); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_FloatImage_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_FloatImage_methods[]= { - { "allocate", _wrap_FloatImage_allocate}, - { "isAllocated", _wrap_FloatImage_isAllocated}, - { "clear", _wrap_FloatImage_clear}, - { "load", _wrap_FloatImage_load}, - { "draw", _wrap_FloatImage_draw}, - { "drawSubsection", _wrap_FloatImage_drawSubsection}, - { "update", _wrap_FloatImage_update}, - { "setUseTexture", _wrap_FloatImage_setUseTexture}, - { "isUsingTexture", _wrap_FloatImage_isUsingTexture}, - { "getTexture", _wrap_FloatImage_getTexture}, - { "bind", _wrap_FloatImage_bind}, - { "unbind", _wrap_FloatImage_unbind}, - { "setCompression", _wrap_FloatImage_setCompression}, - { "getColor", _wrap_FloatImage_getColor}, - { "getHeight", _wrap_FloatImage_getHeight}, - { "getWidth", _wrap_FloatImage_getWidth}, - { "setColor", _wrap_FloatImage_setColor}, - { "setFromPixels", _wrap_FloatImage_setFromPixels}, - { "grabScreen", _wrap_FloatImage_grabScreen}, - { "setImageType", _wrap_FloatImage_setImageType}, - { "getImageType", _wrap_FloatImage_getImageType}, - { "resize", _wrap_FloatImage_resize}, - { "crop", _wrap_FloatImage_crop}, - { "cropFrom", _wrap_FloatImage_cropFrom}, - { "rotate90", _wrap_FloatImage_rotate90}, - { "mirror", _wrap_FloatImage_mirror}, - { "setAnchorPercent", _wrap_FloatImage_setAnchorPercent}, - { "setAnchorPoint", _wrap_FloatImage_setAnchorPoint}, - { "resetAnchor", _wrap_FloatImage_resetAnchor}, - { "save", _wrap_FloatImage_save}, - {0,0} -}; -static swig_lua_method swig_FloatImage_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_FloatImage_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_FloatImage_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_FloatImage_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_FloatImage_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_FloatImage_Sf_SwigStatic = { - "FloatImage", - swig_FloatImage_Sf_SwigStatic_methods, - swig_FloatImage_Sf_SwigStatic_attributes, - swig_FloatImage_Sf_SwigStatic_constants, - swig_FloatImage_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_FloatImage_bases[] = {0}; -static const char *swig_FloatImage_base_names[] = {0}; -static swig_lua_class _wrap_class_FloatImage = { "FloatImage", "FloatImage", &SWIGTYPE_p_ofImage_T_float_t,_proxy__wrap_new_FloatImage, swig_delete_FloatImage, swig_FloatImage_methods, swig_FloatImage_attributes, &swig_FloatImage_Sf_SwigStatic, swig_FloatImage_meta, swig_FloatImage_bases, swig_FloatImage_base_names }; - -static int _wrap_new_ShortImage__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofImage_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofImage_< unsigned short >::ofImage_",0,0) - result = (ofImage_< unsigned short > *)new ofImage_< unsigned short >(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofImage_T_unsigned_short_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_ShortImage__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPixels_< unsigned short > *arg1 = 0 ; - ofImage_< unsigned short > *result = 0 ; SWIG_check_num_args("ofImage_< unsigned short >::ofImage_",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::ofImage_",1,"ofPixels_< unsigned short > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("new_ShortImage",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - result = (ofImage_< unsigned short > *)new ofImage_< unsigned short >((ofPixels_< unsigned short > const &)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofImage_T_unsigned_short_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_ShortImage__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = 0 ; - ofImage_< unsigned short > *result = 0 ; SWIG_check_num_args("ofImage_< unsigned short >::ofImage_",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::ofImage_",1,"ofFile const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("new_ShortImage",1,SWIGTYPE_p_ofFile); } - result = (ofImage_< unsigned short > *)new ofImage_< unsigned short >((ofFile const &)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofImage_T_unsigned_short_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_ShortImage__SWIG_3(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - ofImage_< unsigned short > *result = 0 ; SWIG_check_num_args("ofImage_< unsigned short >::ofImage_",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::ofImage_",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; - result = (ofImage_< unsigned short > *)new ofImage_< unsigned short >((std::string const &)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofImage_T_unsigned_short_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_ShortImage__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofImage_< unsigned short > *arg1 = 0 ; - ofImage_< unsigned short > *result = 0 ; SWIG_check_num_args("ofImage_< unsigned short >::ofImage_",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::ofImage_",1,"ofImage_< unsigned short > &&"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("new_ShortImage",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - result = (ofImage_< unsigned short > *)new ofImage_< unsigned short >((ofImage_< unsigned short > &&)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofImage_T_unsigned_short_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_ShortImage(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_ShortImage__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_new_ShortImage__SWIG_1(L);} } if (argc == 1) { int _v; { - void *ptr; if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_new_ShortImage__SWIG_2(L);} } if (argc == 1) { int _v; { - void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_new_ShortImage__SWIG_4(L);} } if (argc == 1) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { return _wrap_new_ShortImage__SWIG_3(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_ShortImage'\n" " Possible C/C++ prototypes are:\n" - " ofImage_< unsigned short >::ofImage_()\n" - " ofImage_< unsigned short >::ofImage_(ofPixels_< unsigned short > const &)\n" - " ofImage_< unsigned short >::ofImage_(ofFile const &)\n" " ofImage_< unsigned short >::ofImage_(std::string const &)\n" - " ofImage_< unsigned short >::ofImage_(ofImage_< unsigned short > &&)\n"); lua_error(L);return 0; } -static int _wrap_ShortImage_allocate(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; int arg2 ; int arg3 ; ofImageType arg4 ; - SWIG_check_num_args("ofImage_< unsigned short >::allocate",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::allocate",1,"ofImage_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::allocate",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned short >::allocate",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< unsigned short >::allocate",4,"ofImageType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_allocate",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); arg4 = (ofImageType)(int)lua_tonumber(L, 4); (arg1)->allocate(arg2,arg3,arg4); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_isAllocated(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; bool result; - SWIG_check_num_args("ofImage_< unsigned short >::isAllocated",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::isAllocated",1,"ofImage_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_isAllocated",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - result = (bool)((ofImage_< unsigned short > const *)arg1)->isAllocated(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_clear(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; - SWIG_check_num_args("ofImage_< unsigned short >::clear",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::clear",1,"ofImage_< unsigned short > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_clear",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } (arg1)->clear(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_load__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; std::string *arg2 = 0 ; std::string temp2 ; bool result; - SWIG_check_num_args("ofImage_< unsigned short >::load",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::load",1,"ofImage_< unsigned short > *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::load",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_load",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; result = (bool)(arg1)->load((std::string const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_load__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; ofBuffer *arg2 = 0 ; bool result; - SWIG_check_num_args("ofImage_< unsigned short >::load",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::load",1,"ofImage_< unsigned short > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::load",2,"ofBuffer const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_load",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBuffer,0))){ - SWIG_fail_ptr("ShortImage_load",2,SWIGTYPE_p_ofBuffer); } result = (bool)(arg1)->load((ofBuffer const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_load__SWIG_2(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; ofFile *arg2 = 0 ; bool result; - SWIG_check_num_args("ofImage_< unsigned short >::load",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::load",1,"ofImage_< unsigned short > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::load",2,"ofFile const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_load",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofFile,0))){ - SWIG_fail_ptr("ShortImage_load",2,SWIGTYPE_p_ofFile); } result = (bool)(arg1)->load((ofFile const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_load(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v; - { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBuffer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_ShortImage_load__SWIG_1(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_ShortImage_load__SWIG_2(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { - return _wrap_ShortImage_load__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortImage_load'\n" " Possible C/C++ prototypes are:\n" - " ofImage_< unsigned short >::load(std::string const &)\n" " ofImage_< unsigned short >::load(ofBuffer const &)\n" - " ofImage_< unsigned short >::load(ofFile const &)\n"); lua_error(L);return 0; } -static int _wrap_ShortImage_draw__SWIG_0_0(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; ofPoint *arg2 = 0 ; SWIG_check_num_args("draw",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("draw",1,"ofImage_< unsigned short > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("draw",2,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_draw",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("ShortImage_draw",2,SWIGTYPE_p_ofVec3f); } - ((ofImage_< unsigned short > const *)arg1)->draw((ofPoint const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_draw__SWIG_0_1(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; ofRectangle *arg2 = 0 ; SWIG_check_num_args("draw",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("draw",1,"ofImage_< unsigned short > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("draw",2,"ofRectangle const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_draw",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("ShortImage_draw",2,SWIGTYPE_p_ofRectangle); } - ((ofImage_< unsigned short > const *)arg1)->draw((ofRectangle const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_draw__SWIG_0_2(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; ofPoint *arg2 = 0 ; float arg3 ; float arg4 ; - SWIG_check_num_args("draw",4,4) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("draw",1,"ofImage_< unsigned short > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("draw",2,"ofPoint const &"); if(!lua_isnumber(L,3)) SWIG_fail_arg("draw",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("draw",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_draw",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("ShortImage_draw",2,SWIGTYPE_p_ofVec3f); } arg3 = (float)lua_tonumber(L, 3); - arg4 = (float)lua_tonumber(L, 4); ((ofImage_< unsigned short > const *)arg1)->draw((ofPoint const &)*arg2,arg3,arg4); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_draw__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofImage_< unsigned short >::draw",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::draw",1,"ofImage_< unsigned short > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::draw",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned short >::draw",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_draw",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); ((ofImage_< unsigned short > const *)arg1)->draw(arg2,arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_draw__SWIG_2(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; float arg2 ; float arg3 ; float arg4 ; - SWIG_check_num_args("ofImage_< unsigned short >::draw",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::draw",1,"ofImage_< unsigned short > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::draw",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned short >::draw",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< unsigned short >::draw",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_draw",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - ((ofImage_< unsigned short > const *)arg1)->draw(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortImage_draw__SWIG_3(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; float arg2 ; float arg3 ; float arg4 ; float arg5 ; - SWIG_check_num_args("ofImage_< unsigned short >::draw",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::draw",1,"ofImage_< unsigned short > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::draw",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned short >::draw",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< unsigned short >::draw",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< unsigned short >::draw",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_draw",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - ((ofImage_< unsigned short > const *)arg1)->draw(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortImage_draw__SWIG_4(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; float arg2 ; float arg3 ; float arg4 ; float arg5 ; - float arg6 ; SWIG_check_num_args("ofImage_< unsigned short >::draw",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::draw",1,"ofImage_< unsigned short > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::draw",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned short >::draw",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< unsigned short >::draw",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< unsigned short >::draw",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofImage_< unsigned short >::draw",6,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_draw",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); ((ofImage_< unsigned short > const *)arg1)->draw(arg2,arg3,arg4,arg5,arg6); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_draw(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_ShortImage_draw__SWIG_0_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_ShortImage_draw__SWIG_0_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_ShortImage_draw__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_ShortImage_draw__SWIG_0_2(L);} } } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_ShortImage_draw__SWIG_2(L);} } } } } - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_ShortImage_draw__SWIG_3(L);} } } } } } if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { return _wrap_ShortImage_draw__SWIG_4(L);} } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortImage_draw'\n" " Possible C/C++ prototypes are:\n" - " draw(ofPoint const &) const\n" " draw(ofRectangle const &) const\n" " draw(ofPoint const &,float,float) const\n" - " ofImage_< unsigned short >::draw(float,float) const\n" " ofImage_< unsigned short >::draw(float,float,float) const\n" - " ofImage_< unsigned short >::draw(float,float,float,float) const\n" - " ofImage_< unsigned short >::draw(float,float,float,float,float) const\n"); lua_error(L);return 0; } -static int _wrap_ShortImage_drawSubsection__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; float arg2 ; float arg3 ; float arg4 ; float arg5 ; - float arg6 ; float arg7 ; SWIG_check_num_args("ofImage_< unsigned short >::drawSubsection",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",1,"ofImage_< unsigned short > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",7,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_drawSubsection",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); - ((ofImage_< unsigned short > const *)arg1)->drawSubsection(arg2,arg3,arg4,arg5,arg6,arg7); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_drawSubsection__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; float arg2 ; float arg3 ; float arg4 ; float arg5 ; - float arg6 ; float arg7 ; float arg8 ; SWIG_check_num_args("ofImage_< unsigned short >::drawSubsection",8,8) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",1,"ofImage_< unsigned short > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",8,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_drawSubsection",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (float)lua_tonumber(L, 8); - ((ofImage_< unsigned short > const *)arg1)->drawSubsection(arg2,arg3,arg4,arg5,arg6,arg7,arg8); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_drawSubsection__SWIG_2(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; float arg2 ; float arg3 ; float arg4 ; float arg5 ; - float arg6 ; float arg7 ; float arg8 ; float arg9 ; SWIG_check_num_args("ofImage_< unsigned short >::drawSubsection",9,9) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",1,"ofImage_< unsigned short > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",8,"float"); - if(!lua_isnumber(L,9)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",9,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_drawSubsection",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (float)lua_tonumber(L, 8); - arg9 = (float)lua_tonumber(L, 9); - ((ofImage_< unsigned short > const *)arg1)->drawSubsection(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_drawSubsection__SWIG_3(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; float arg2 ; float arg3 ; float arg4 ; float arg5 ; - float arg6 ; float arg7 ; float arg8 ; float arg9 ; float arg10 ; - SWIG_check_num_args("ofImage_< unsigned short >::drawSubsection",10,10) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",1,"ofImage_< unsigned short > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",8,"float"); - if(!lua_isnumber(L,9)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",9,"float"); - if(!lua_isnumber(L,10)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",10,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_drawSubsection",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (float)lua_tonumber(L, 8); - arg9 = (float)lua_tonumber(L, 9); arg10 = (float)lua_tonumber(L, 10); - ((ofImage_< unsigned short > const *)arg1)->drawSubsection(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_drawSubsection(lua_State* L) { int argc; int argv[11]={ 1,2,3,4,5,6,7,8,9,10,11} ; - argc = lua_gettop(L); if (argc == 7) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { - return _wrap_ShortImage_drawSubsection__SWIG_0(L);} } } } } } } } if (argc == 8) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { return _wrap_ShortImage_drawSubsection__SWIG_1(L);} } } } } } - } } } if (argc == 9) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { { _v = lua_isnumber(L,argv[8]); } if (_v) { - return _wrap_ShortImage_drawSubsection__SWIG_2(L);} } } } } } } } } } if (argc == 10) { int _v; - { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { { _v = lua_isnumber(L,argv[8]); } if (_v) { { - _v = lua_isnumber(L,argv[9]); } if (_v) { return _wrap_ShortImage_drawSubsection__SWIG_3(L);} } } } - } } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortImage_drawSubsection'\n" - " Possible C/C++ prototypes are:\n" - " ofImage_< unsigned short >::drawSubsection(float,float,float,float,float,float) const\n" - " ofImage_< unsigned short >::drawSubsection(float,float,float,float,float,float,float) const\n" - " ofImage_< unsigned short >::drawSubsection(float,float,float,float,float,float,float,float) const\n" - " ofImage_< unsigned short >::drawSubsection(float,float,float,float,float,float,float,float,float) const\n"); - lua_error(L);return 0; } -static int _wrap_ShortImage_update(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; - SWIG_check_num_args("ofImage_< unsigned short >::update",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::update",1,"ofImage_< unsigned short > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_update",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } (arg1)->update(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_setUseTexture(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; bool arg2 ; - SWIG_check_num_args("ofImage_< unsigned short >::setUseTexture",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::setUseTexture",1,"ofImage_< unsigned short > *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::setUseTexture",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_setUseTexture",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } arg2 = (lua_toboolean(L, 2)!=0); - (arg1)->setUseTexture(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_isUsingTexture(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; bool result; - SWIG_check_num_args("ofImage_< unsigned short >::isUsingTexture",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::isUsingTexture",1,"ofImage_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_isUsingTexture",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - result = (bool)((ofImage_< unsigned short > const *)arg1)->isUsingTexture(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_getTexture__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; ofTexture *result = 0 ; - SWIG_check_num_args("ofImage_< unsigned short >::getTexture",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::getTexture",1,"ofImage_< unsigned short > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_getTexture",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - result = (ofTexture *) &(arg1)->getTexture(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTexture,0); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_getTexture__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; ofTexture *result = 0 ; - SWIG_check_num_args("ofImage_< unsigned short >::getTexture",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::getTexture",1,"ofImage_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_getTexture",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - result = (ofTexture *) &((ofImage_< unsigned short > const *)arg1)->getTexture(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTexture,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortImage_getTexture(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_ShortImage_getTexture__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_ShortImage_getTexture__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortImage_getTexture'\n" - " Possible C/C++ prototypes are:\n" " ofImage_< unsigned short >::getTexture()\n" - " ofImage_< unsigned short >::getTexture() const\n"); lua_error(L);return 0; } -static int _wrap_ShortImage_bind__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; int arg2 ; - SWIG_check_num_args("ofImage_< unsigned short >::bind",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::bind",1,"ofImage_< unsigned short > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::bind",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_bind",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } arg2 = (int)lua_tonumber(L, 2); - ((ofImage_< unsigned short > const *)arg1)->bind(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortImage_bind__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; - SWIG_check_num_args("ofImage_< unsigned short >::bind",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::bind",1,"ofImage_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_bind",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - ((ofImage_< unsigned short > const *)arg1)->bind(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_bind(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; - { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_ShortImage_bind__SWIG_1(L);} } if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_ShortImage_bind__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortImage_bind'\n" " Possible C/C++ prototypes are:\n" - " ofImage_< unsigned short >::bind(int) const\n" " ofImage_< unsigned short >::bind() const\n"); lua_error(L);return 0; } -static int _wrap_ShortImage_unbind__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; int arg2 ; - SWIG_check_num_args("ofImage_< unsigned short >::unbind",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::unbind",1,"ofImage_< unsigned short > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::unbind",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_unbind",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } arg2 = (int)lua_tonumber(L, 2); - ((ofImage_< unsigned short > const *)arg1)->unbind(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortImage_unbind__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; - SWIG_check_num_args("ofImage_< unsigned short >::unbind",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::unbind",1,"ofImage_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_unbind",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - ((ofImage_< unsigned short > const *)arg1)->unbind(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_unbind(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_ShortImage_unbind__SWIG_1(L);} } if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_ShortImage_unbind__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortImage_unbind'\n" " Possible C/C++ prototypes are:\n" - " ofImage_< unsigned short >::unbind(int) const\n" " ofImage_< unsigned short >::unbind() const\n"); - lua_error(L);return 0; } -static int _wrap_ShortImage_setCompression(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; ofTexCompression arg2 ; - SWIG_check_num_args("ofImage_< unsigned short >::setCompression",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::setCompression",1,"ofImage_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::setCompression",2,"ofTexCompression"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_setCompression",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - arg2 = (ofTexCompression)(int)lua_tonumber(L, 2); (arg1)->setCompression(arg2); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_getColor__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; int arg2 ; int arg3 ; ofColor_< unsigned short > result; - SWIG_check_num_args("ofImage_< unsigned short >::getColor",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::getColor",1,"ofImage_< unsigned short > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::getColor",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned short >::getColor",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_getColor",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); result = ((ofImage_< unsigned short > const *)arg1)->getColor(arg2,arg3); { - ofColor_< unsigned short > * resultptr = new ofColor_< unsigned short >((const ofColor_< unsigned short > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_short_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_getColor__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; int arg2 ; ofColor_< unsigned short > result; - SWIG_check_num_args("ofImage_< unsigned short >::getColor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::getColor",1,"ofImage_< unsigned short > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::getColor",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_getColor",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } arg2 = (int)lua_tonumber(L, 2); - result = ((ofImage_< unsigned short > const *)arg1)->getColor(arg2); { - ofColor_< unsigned short > * resultptr = new ofColor_< unsigned short >((const ofColor_< unsigned short > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_short_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_getColor(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_ShortImage_getColor__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_ShortImage_getColor__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortImage_getColor'\n" - " Possible C/C++ prototypes are:\n" " ofImage_< unsigned short >::getColor(int,int) const\n" - " ofImage_< unsigned short >::getColor(int) const\n"); lua_error(L);return 0; } -static int _wrap_ShortImage_getHeight(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; float result; - SWIG_check_num_args("ofImage_< unsigned short >::getHeight",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::getHeight",1,"ofImage_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_getHeight",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - result = (float)((ofImage_< unsigned short > const *)arg1)->getHeight(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_getWidth(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; float result; - SWIG_check_num_args("ofImage_< unsigned short >::getWidth",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::getWidth",1,"ofImage_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_getWidth",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - result = (float)((ofImage_< unsigned short > const *)arg1)->getWidth(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_setColor__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; int arg2 ; int arg3 ; - ofColor_< unsigned short > *arg4 = 0 ; SWIG_check_num_args("ofImage_< unsigned short >::setColor",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::setColor",1,"ofImage_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::setColor",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned short >::setColor",3,"int"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofImage_< unsigned short >::setColor",4,"ofColor_< unsigned short > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_setColor",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_setColor",4,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - (arg1)->setColor(arg2,arg3,(ofColor_< unsigned short > const &)*arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortImage_setColor__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; int arg2 ; ofColor_< unsigned short > *arg3 = 0 ; - SWIG_check_num_args("ofImage_< unsigned short >::setColor",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::setColor",1,"ofImage_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::setColor",2,"int"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofImage_< unsigned short >::setColor",3,"ofColor_< unsigned short > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_setColor",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } arg2 = (int)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_setColor",3,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - (arg1)->setColor(arg2,(ofColor_< unsigned short > const &)*arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortImage_setColor__SWIG_2(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; ofColor_< unsigned short > *arg2 = 0 ; - SWIG_check_num_args("ofImage_< unsigned short >::setColor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::setColor",1,"ofImage_< unsigned short > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::setColor",2,"ofColor_< unsigned short > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_setColor",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_setColor",2,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - (arg1)->setColor((ofColor_< unsigned short > const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortImage_setColor(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_ShortImage_setColor__SWIG_2(L);} } } if (argc == 3) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_ShortImage_setColor__SWIG_1(L);} } } } if (argc == 4) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_ShortImage_setColor__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortImage_setColor'\n" - " Possible C/C++ prototypes are:\n" " ofImage_< unsigned short >::setColor(int,int,ofColor_< unsigned short > const &)\n" - " ofImage_< unsigned short >::setColor(int,ofColor_< unsigned short > const &)\n" - " ofImage_< unsigned short >::setColor(ofColor_< unsigned short > const &)\n"); lua_error(L);return 0; } -static int _wrap_ShortImage_setFromPixels__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; unsigned short *arg2 = (unsigned short *) 0 ; int arg3 ; - int arg4 ; ofImageType arg5 ; bool arg6 ; SWIG_check_num_args("ofImage_< unsigned short >::setFromPixels",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::setFromPixels",1,"ofImage_< unsigned short > *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::setFromPixels",2,"unsigned short const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned short >::setFromPixels",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< unsigned short >::setFromPixels",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< unsigned short >::setFromPixels",5,"ofImageType"); - if(!lua_isboolean(L,6)) SWIG_fail_arg("ofImage_< unsigned short >::setFromPixels",6,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_setFromPixels",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_unsigned_short,0))){ - SWIG_fail_ptr("ShortImage_setFromPixels",2,SWIGTYPE_p_unsigned_short); } arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); arg5 = (ofImageType)(int)lua_tonumber(L, 5); arg6 = (lua_toboolean(L, 6)!=0); - (arg1)->setFromPixels((unsigned short const *)arg2,arg3,arg4,arg5,arg6); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortImage_setFromPixels__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; unsigned short *arg2 = (unsigned short *) 0 ; int arg3 ; - int arg4 ; ofImageType arg5 ; SWIG_check_num_args("ofImage_< unsigned short >::setFromPixels",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::setFromPixels",1,"ofImage_< unsigned short > *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::setFromPixels",2,"unsigned short const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned short >::setFromPixels",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< unsigned short >::setFromPixels",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< unsigned short >::setFromPixels",5,"ofImageType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_setFromPixels",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_unsigned_short,0))){ - SWIG_fail_ptr("ShortImage_setFromPixels",2,SWIGTYPE_p_unsigned_short); } arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); arg5 = (ofImageType)(int)lua_tonumber(L, 5); - (arg1)->setFromPixels((unsigned short const *)arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortImage_setFromPixels__SWIG_2(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; ofPixels_< unsigned short > *arg2 = 0 ; - SWIG_check_num_args("ofImage_< unsigned short >::setFromPixels",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::setFromPixels",1,"ofImage_< unsigned short > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::setFromPixels",2,"ofPixels_< unsigned short > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_setFromPixels",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_setFromPixels",2,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - (arg1)->setFromPixels((ofPixels_< unsigned short > const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortImage_setFromPixels(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_ShortImage_setFromPixels__SWIG_2(L);} } } if (argc == 5) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_unsigned_short, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_ShortImage_setFromPixels__SWIG_1(L);} } } } } - } if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_unsigned_short, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isboolean(L,argv[5]); } if (_v) { - return _wrap_ShortImage_setFromPixels__SWIG_0(L);} } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortImage_setFromPixels'\n" - " Possible C/C++ prototypes are:\n" - " ofImage_< unsigned short >::setFromPixels(unsigned short const *,int,int,ofImageType,bool)\n" - " ofImage_< unsigned short >::setFromPixels(unsigned short const *,int,int,ofImageType)\n" - " ofImage_< unsigned short >::setFromPixels(ofPixels_< unsigned short > const &)\n"); lua_error(L);return 0; } -static int _wrap_ShortImage_grabScreen(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; int arg2 ; int arg3 ; int arg4 ; int arg5 ; - SWIG_check_num_args("ofImage_< unsigned short >::grabScreen",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::grabScreen",1,"ofImage_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::grabScreen",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned short >::grabScreen",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< unsigned short >::grabScreen",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< unsigned short >::grabScreen",5,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_grabScreen",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); - (arg1)->grabScreen(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_setImageType(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; ofImageType arg2 ; - SWIG_check_num_args("ofImage_< unsigned short >::setImageType",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::setImageType",1,"ofImage_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::setImageType",2,"ofImageType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_setImageType",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - arg2 = (ofImageType)(int)lua_tonumber(L, 2); (arg1)->setImageType(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortImage_getImageType(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; ofImageType result; - SWIG_check_num_args("ofImage_< unsigned short >::getImageType",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::getImageType",1,"ofImage_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_getImageType",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - result = (ofImageType)((ofImage_< unsigned short > const *)arg1)->getImageType(); - lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortImage_resize(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; int arg2 ; int arg3 ; - SWIG_check_num_args("ofImage_< unsigned short >::resize",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::resize",1,"ofImage_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::resize",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned short >::resize",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_resize",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); (arg1)->resize(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortImage_crop(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; int arg2 ; int arg3 ; int arg4 ; int arg5 ; - SWIG_check_num_args("ofImage_< unsigned short >::crop",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::crop",1,"ofImage_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::crop",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned short >::crop",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< unsigned short >::crop",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< unsigned short >::crop",5,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_crop",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); - (arg1)->crop(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_cropFrom(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; ofImage_< unsigned short > *arg2 = 0 ; int arg3 ; - int arg4 ; int arg5 ; int arg6 ; SWIG_check_num_args("ofImage_< unsigned short >::cropFrom",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::cropFrom",1,"ofImage_< unsigned short > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::cropFrom",2,"ofImage_< unsigned short > &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned short >::cropFrom",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< unsigned short >::cropFrom",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< unsigned short >::cropFrom",5,"int"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofImage_< unsigned short >::cropFrom",6,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_cropFrom",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_cropFrom",2,SWIGTYPE_p_ofImage_T_unsigned_short_t); } arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); arg6 = (int)lua_tonumber(L, 6); - (arg1)->cropFrom(*arg2,arg3,arg4,arg5,arg6); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_rotate90(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; int arg2 ; - SWIG_check_num_args("ofImage_< unsigned short >::rotate90",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::rotate90",1,"ofImage_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::rotate90",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_rotate90",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->rotate90(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_mirror(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; bool arg2 ; bool arg3 ; - SWIG_check_num_args("ofImage_< unsigned short >::mirror",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::mirror",1,"ofImage_< unsigned short > *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::mirror",2,"bool"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofImage_< unsigned short >::mirror",3,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_mirror",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } arg2 = (lua_toboolean(L, 2)!=0); - arg3 = (lua_toboolean(L, 3)!=0); (arg1)->mirror(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortImage_setAnchorPercent(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofImage_< unsigned short >::setAnchorPercent",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::setAnchorPercent",1,"ofImage_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::setAnchorPercent",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned short >::setAnchorPercent",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_setAnchorPercent",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->setAnchorPercent(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortImage_setAnchorPoint(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofImage_< unsigned short >::setAnchorPoint",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::setAnchorPoint",1,"ofImage_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::setAnchorPoint",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned short >::setAnchorPoint",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_setAnchorPoint",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->setAnchorPoint(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortImage_resetAnchor(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; - SWIG_check_num_args("ofImage_< unsigned short >::resetAnchor",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::resetAnchor",1,"ofImage_< unsigned short > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_resetAnchor",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } (arg1)->resetAnchor(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_save__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; std::string arg2 ; ofImageQualityType arg3 ; - SWIG_check_num_args("ofImage_< unsigned short >::save",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::save",1,"ofImage_< unsigned short > *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::save",2,"std::string"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned short >::save",3,"ofImageQualityType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_save",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - (&arg2)->assign(lua_tostring(L,2),lua_rawlen(L,2)); arg3 = (ofImageQualityType)(int)lua_tonumber(L, 3); - (arg1)->save(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_save__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; std::string arg2 ; - SWIG_check_num_args("ofImage_< unsigned short >::save",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::save",1,"ofImage_< unsigned short > *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::save",2,"std::string"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_save",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - (&arg2)->assign(lua_tostring(L,2),lua_rawlen(L,2)); (arg1)->save(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortImage_save__SWIG_2(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; ofBuffer *arg2 = 0 ; ofImageQualityType arg3 ; - SWIG_check_num_args("ofImage_< unsigned short >::save",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::save",1,"ofImage_< unsigned short > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::save",2,"ofBuffer &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned short >::save",3,"ofImageQualityType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_save",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBuffer,0))){ - SWIG_fail_ptr("ShortImage_save",2,SWIGTYPE_p_ofBuffer); } arg3 = (ofImageQualityType)(int)lua_tonumber(L, 3); - (arg1)->save(*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_save__SWIG_3(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; ofBuffer *arg2 = 0 ; - SWIG_check_num_args("ofImage_< unsigned short >::save",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::save",1,"ofImage_< unsigned short > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::save",2,"ofBuffer &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_save",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBuffer,0))){ - SWIG_fail_ptr("ShortImage_save",2,SWIGTYPE_p_ofBuffer); } (arg1)->save(*arg2); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_save__SWIG_4(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; ofFile *arg2 = 0 ; ofImageQualityType arg3 ; - SWIG_check_num_args("ofImage_< unsigned short >::save",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::save",1,"ofImage_< unsigned short > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::save",2,"ofFile const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned short >::save",3,"ofImageQualityType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_save",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofFile,0))){ - SWIG_fail_ptr("ShortImage_save",2,SWIGTYPE_p_ofFile); } arg3 = (ofImageQualityType)(int)lua_tonumber(L, 3); - (arg1)->save((ofFile const &)*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_save__SWIG_5(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; ofFile *arg2 = 0 ; - SWIG_check_num_args("ofImage_< unsigned short >::save",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::save",1,"ofImage_< unsigned short > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::save",2,"ofFile const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_save",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofFile,0))){ - SWIG_fail_ptr("ShortImage_save",2,SWIGTYPE_p_ofFile); } (arg1)->save((ofFile const &)*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_save(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBuffer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_ShortImage_save__SWIG_3(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_ShortImage_save__SWIG_5(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { - return _wrap_ShortImage_save__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_ShortImage_save__SWIG_4(L);} } - } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBuffer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_ShortImage_save__SWIG_2(L);} } - } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_ShortImage_save__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortImage_save'\n" " Possible C/C++ prototypes are:\n" - " ofImage_< unsigned short >::save(std::string,ofImageQualityType)\n" " ofImage_< unsigned short >::save(std::string)\n" - " ofImage_< unsigned short >::save(ofBuffer &,ofImageQualityType)\n" " ofImage_< unsigned short >::save(ofBuffer &)\n" - " ofImage_< unsigned short >::save(ofFile const &,ofImageQualityType)\n" - " ofImage_< unsigned short >::save(ofFile const &)\n"); lua_error(L);return 0; } -static void swig_delete_ShortImage(void *obj) { -ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) obj; -delete arg1; -} -static int _proxy__wrap_new_ShortImage(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_ShortImage); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_ShortImage_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_ShortImage_methods[]= { - { "allocate", _wrap_ShortImage_allocate}, - { "isAllocated", _wrap_ShortImage_isAllocated}, - { "clear", _wrap_ShortImage_clear}, - { "load", _wrap_ShortImage_load}, - { "draw", _wrap_ShortImage_draw}, - { "drawSubsection", _wrap_ShortImage_drawSubsection}, - { "update", _wrap_ShortImage_update}, - { "setUseTexture", _wrap_ShortImage_setUseTexture}, - { "isUsingTexture", _wrap_ShortImage_isUsingTexture}, - { "getTexture", _wrap_ShortImage_getTexture}, - { "bind", _wrap_ShortImage_bind}, - { "unbind", _wrap_ShortImage_unbind}, - { "setCompression", _wrap_ShortImage_setCompression}, - { "getColor", _wrap_ShortImage_getColor}, - { "getHeight", _wrap_ShortImage_getHeight}, - { "getWidth", _wrap_ShortImage_getWidth}, - { "setColor", _wrap_ShortImage_setColor}, - { "setFromPixels", _wrap_ShortImage_setFromPixels}, - { "grabScreen", _wrap_ShortImage_grabScreen}, - { "setImageType", _wrap_ShortImage_setImageType}, - { "getImageType", _wrap_ShortImage_getImageType}, - { "resize", _wrap_ShortImage_resize}, - { "crop", _wrap_ShortImage_crop}, - { "cropFrom", _wrap_ShortImage_cropFrom}, - { "rotate90", _wrap_ShortImage_rotate90}, - { "mirror", _wrap_ShortImage_mirror}, - { "setAnchorPercent", _wrap_ShortImage_setAnchorPercent}, - { "setAnchorPoint", _wrap_ShortImage_setAnchorPoint}, - { "resetAnchor", _wrap_ShortImage_resetAnchor}, - { "save", _wrap_ShortImage_save}, - {0,0} -}; -static swig_lua_method swig_ShortImage_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_ShortImage_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_ShortImage_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_ShortImage_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_ShortImage_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_ShortImage_Sf_SwigStatic = { - "ShortImage", - swig_ShortImage_Sf_SwigStatic_methods, - swig_ShortImage_Sf_SwigStatic_attributes, - swig_ShortImage_Sf_SwigStatic_constants, - swig_ShortImage_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_ShortImage_bases[] = {0}; -static const char *swig_ShortImage_base_names[] = {0}; -static swig_lua_class _wrap_class_ShortImage = { "ShortImage", "ShortImage", &SWIGTYPE_p_ofImage_T_unsigned_short_t,_proxy__wrap_new_ShortImage, swig_delete_ShortImage, swig_ShortImage_methods, swig_ShortImage_attributes, &swig_ShortImage_Sf_SwigStatic, swig_ShortImage_meta, swig_ShortImage_bases, swig_ShortImage_base_names }; - -static int _wrap_isVFlipped(lua_State* L) { int SWIG_arg = 0; bool result; SWIG_check_num_args("ofIsVFlipped",0,0) - result = (bool)ofIsVFlipped(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_Node__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofNode *result = 0 ; - SWIG_check_num_args("ofNode::ofNode",0,0) result = (ofNode *)new ofNode(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofNode,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Node__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = 0 ; ofNode *result = 0 ; - SWIG_check_num_args("ofNode::ofNode",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofNode::ofNode",1,"ofNode &&"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("new_Node",1,SWIGTYPE_p_ofNode); } - result = (ofNode *)new ofNode((ofNode &&)*arg1); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofNode,1); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_new_Node(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_Node__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_new_Node__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_Node'\n" " Possible C/C++ prototypes are:\n" - " ofNode::ofNode()\n" " ofNode::ofNode(ofNode &&)\n"); lua_error(L);return 0; } -static int _wrap_Node_setParent__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; ofNode *arg2 = 0 ; - bool arg3 ; SWIG_check_num_args("ofNode::setParent",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::setParent",1,"ofNode *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofNode::setParent",2,"ofNode &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofNode::setParent",3,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_setParent",1,SWIGTYPE_p_ofNode); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_setParent",2,SWIGTYPE_p_ofNode); } arg3 = (lua_toboolean(L, 3)!=0); (arg1)->setParent(*arg2,arg3); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_setParent__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; ofNode *arg2 = 0 ; - SWIG_check_num_args("ofNode::setParent",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::setParent",1,"ofNode *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofNode::setParent",2,"ofNode &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_setParent",1,SWIGTYPE_p_ofNode); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_setParent",2,SWIGTYPE_p_ofNode); } (arg1)->setParent(*arg2); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Node_setParent(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Node_setParent__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { return _wrap_Node_setParent__SWIG_0(L);} } - } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Node_setParent'\n" - " Possible C/C++ prototypes are:\n" " ofNode::setParent(ofNode &,bool)\n" " ofNode::setParent(ofNode &)\n"); - lua_error(L);return 0; } -static int _wrap_Node_clearParent__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; bool arg2 ; - SWIG_check_num_args("ofNode::clearParent",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::clearParent",1,"ofNode *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofNode::clearParent",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_clearParent",1,SWIGTYPE_p_ofNode); } arg2 = (lua_toboolean(L, 2)!=0); (arg1)->clearParent(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_clearParent__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; - SWIG_check_num_args("ofNode::clearParent",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::clearParent",1,"ofNode *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_clearParent",1,SWIGTYPE_p_ofNode); } (arg1)->clearParent(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Node_clearParent(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Node_clearParent__SWIG_1(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_Node_clearParent__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Node_clearParent'\n" " Possible C/C++ prototypes are:\n" - " ofNode::clearParent(bool)\n" " ofNode::clearParent()\n"); lua_error(L);return 0; } -static int _wrap_Node_getParent(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; ofNode *result = 0 ; - SWIG_check_num_args("ofNode::getParent",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::getParent",1,"ofNode const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_getParent",1,SWIGTYPE_p_ofNode); } - result = (ofNode *)((ofNode const *)arg1)->getParent(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofNode,0); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_getPosition(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; ofVec3f result; - SWIG_check_num_args("ofNode::getPosition",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::getPosition",1,"ofNode const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_getPosition",1,SWIGTYPE_p_ofNode); } result = ((ofNode const *)arg1)->getPosition(); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Node_getX(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; float result; - SWIG_check_num_args("ofNode::getX",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::getX",1,"ofNode const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_getX",1,SWIGTYPE_p_ofNode); } - result = (float)((ofNode const *)arg1)->getX(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_getY(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; float result; - SWIG_check_num_args("ofNode::getY",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::getY",1,"ofNode const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_getY",1,SWIGTYPE_p_ofNode); } - result = (float)((ofNode const *)arg1)->getY(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_getZ(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; float result; - SWIG_check_num_args("ofNode::getZ",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::getZ",1,"ofNode const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_getZ",1,SWIGTYPE_p_ofNode); } - result = (float)((ofNode const *)arg1)->getZ(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_getXAxis(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; ofVec3f result; - SWIG_check_num_args("ofNode::getXAxis",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::getXAxis",1,"ofNode const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_getXAxis",1,SWIGTYPE_p_ofNode); } - result = ((ofNode const *)arg1)->getXAxis(); { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Node_getYAxis(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; ofVec3f result; - SWIG_check_num_args("ofNode::getYAxis",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::getYAxis",1,"ofNode const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_getYAxis",1,SWIGTYPE_p_ofNode); } - result = ((ofNode const *)arg1)->getYAxis(); { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Node_getZAxis(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; ofVec3f result; - SWIG_check_num_args("ofNode::getZAxis",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::getZAxis",1,"ofNode const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_getZAxis",1,SWIGTYPE_p_ofNode); } - result = ((ofNode const *)arg1)->getZAxis(); { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Node_getSideDir(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; ofVec3f result; - SWIG_check_num_args("ofNode::getSideDir",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::getSideDir",1,"ofNode const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_getSideDir",1,SWIGTYPE_p_ofNode); } result = ((ofNode const *)arg1)->getSideDir(); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Node_getLookAtDir(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; ofVec3f result; - SWIG_check_num_args("ofNode::getLookAtDir",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::getLookAtDir",1,"ofNode const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_getLookAtDir",1,SWIGTYPE_p_ofNode); } result = ((ofNode const *)arg1)->getLookAtDir(); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Node_getUpDir(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; ofVec3f result; - SWIG_check_num_args("ofNode::getUpDir",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::getUpDir",1,"ofNode const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_getUpDir",1,SWIGTYPE_p_ofNode); } - result = ((ofNode const *)arg1)->getUpDir(); { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Node_getPitch(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; float result; - SWIG_check_num_args("ofNode::getPitch",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::getPitch",1,"ofNode const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_getPitch",1,SWIGTYPE_p_ofNode); } - result = (float)((ofNode const *)arg1)->getPitch(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_getHeading(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; float result; - SWIG_check_num_args("ofNode::getHeading",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::getHeading",1,"ofNode const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_getHeading",1,SWIGTYPE_p_ofNode); } result = (float)((ofNode const *)arg1)->getHeading(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_getRoll(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; float result; - SWIG_check_num_args("ofNode::getRoll",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::getRoll",1,"ofNode const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_getRoll",1,SWIGTYPE_p_ofNode); } - result = (float)((ofNode const *)arg1)->getRoll(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_getOrientationQuat(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; ofQuaternion result; - SWIG_check_num_args("ofNode::getOrientationQuat",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::getOrientationQuat",1,"ofNode const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_getOrientationQuat",1,SWIGTYPE_p_ofNode); } result = ((ofNode const *)arg1)->getOrientationQuat(); { - ofQuaternion * resultptr = new ofQuaternion((const ofQuaternion &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofQuaternion,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Node_getOrientationEuler(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; ofVec3f result; - SWIG_check_num_args("ofNode::getOrientationEuler",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::getOrientationEuler",1,"ofNode const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_getOrientationEuler",1,SWIGTYPE_p_ofNode); } result = ((ofNode const *)arg1)->getOrientationEuler(); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Node_getScale(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; ofVec3f result; - SWIG_check_num_args("ofNode::getScale",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::getScale",1,"ofNode const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_getScale",1,SWIGTYPE_p_ofNode); } - result = ((ofNode const *)arg1)->getScale(); { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Node_getLocalTransformMatrix(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; - ofMatrix4x4 *result = 0 ; SWIG_check_num_args("ofNode::getLocalTransformMatrix",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::getLocalTransformMatrix",1,"ofNode const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_getLocalTransformMatrix",1,SWIGTYPE_p_ofNode); } - result = (ofMatrix4x4 *) &((ofNode const *)arg1)->getLocalTransformMatrix(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMatrix4x4,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Node_getGlobalTransformMatrix(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; - ofMatrix4x4 result; SWIG_check_num_args("ofNode::getGlobalTransformMatrix",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::getGlobalTransformMatrix",1,"ofNode const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_getGlobalTransformMatrix",1,SWIGTYPE_p_ofNode); } - result = ((ofNode const *)arg1)->getGlobalTransformMatrix(); { - ofMatrix4x4 * resultptr = new ofMatrix4x4((const ofMatrix4x4 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Node_getGlobalPosition(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; ofVec3f result; - SWIG_check_num_args("ofNode::getGlobalPosition",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::getGlobalPosition",1,"ofNode const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_getGlobalPosition",1,SWIGTYPE_p_ofNode); } result = ((ofNode const *)arg1)->getGlobalPosition(); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Node_getGlobalOrientation(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; ofQuaternion result; - SWIG_check_num_args("ofNode::getGlobalOrientation",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::getGlobalOrientation",1,"ofNode const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_getGlobalOrientation",1,SWIGTYPE_p_ofNode); } result = ((ofNode const *)arg1)->getGlobalOrientation(); - { ofQuaternion * resultptr = new ofQuaternion((const ofQuaternion &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofQuaternion,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Node_getGlobalScale(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; ofVec3f result; - SWIG_check_num_args("ofNode::getGlobalScale",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::getGlobalScale",1,"ofNode const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_getGlobalScale",1,SWIGTYPE_p_ofNode); } result = ((ofNode const *)arg1)->getGlobalScale(); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Node_setTransformMatrix(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; ofMatrix4x4 *arg2 = 0 ; - SWIG_check_num_args("ofNode::setTransformMatrix",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::setTransformMatrix",1,"ofNode *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofNode::setTransformMatrix",2,"ofMatrix4x4 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_setTransformMatrix",1,SWIGTYPE_p_ofNode); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Node_setTransformMatrix",2,SWIGTYPE_p_ofMatrix4x4); } - (arg1)->setTransformMatrix((ofMatrix4x4 const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Node_setPosition__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; float arg2 ; - float arg3 ; float arg4 ; SWIG_check_num_args("ofNode::setPosition",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::setPosition",1,"ofNode *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofNode::setPosition",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofNode::setPosition",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofNode::setPosition",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_setPosition",1,SWIGTYPE_p_ofNode); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); (arg1)->setPosition(arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_setPosition__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; ofVec3f *arg2 = 0 ; - SWIG_check_num_args("ofNode::setPosition",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::setPosition",1,"ofNode *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofNode::setPosition",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_setPosition",1,SWIGTYPE_p_ofNode); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Node_setPosition",2,SWIGTYPE_p_ofVec3f); } (arg1)->setPosition((ofVec3f const &)*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_setPosition(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Node_setPosition__SWIG_1(L);} } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Node_setPosition__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Node_setPosition'\n" " Possible C/C++ prototypes are:\n" - " ofNode::setPosition(float,float,float)\n" " ofNode::setPosition(ofVec3f const &)\n"); lua_error(L);return 0; } -static int _wrap_Node_setGlobalPosition__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; float arg2 ; - float arg3 ; float arg4 ; SWIG_check_num_args("ofNode::setGlobalPosition",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::setGlobalPosition",1,"ofNode *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofNode::setGlobalPosition",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofNode::setGlobalPosition",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofNode::setGlobalPosition",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_setGlobalPosition",1,SWIGTYPE_p_ofNode); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); (arg1)->setGlobalPosition(arg2,arg3,arg4); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_setGlobalPosition__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; - ofVec3f *arg2 = 0 ; SWIG_check_num_args("ofNode::setGlobalPosition",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::setGlobalPosition",1,"ofNode *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofNode::setGlobalPosition",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_setGlobalPosition",1,SWIGTYPE_p_ofNode); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Node_setGlobalPosition",2,SWIGTYPE_p_ofVec3f); } (arg1)->setGlobalPosition((ofVec3f const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_setGlobalPosition(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Node_setGlobalPosition__SWIG_1(L);} } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Node_setGlobalPosition__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Node_setGlobalPosition'\n" - " Possible C/C++ prototypes are:\n" " ofNode::setGlobalPosition(float,float,float)\n" - " ofNode::setGlobalPosition(ofVec3f const &)\n"); lua_error(L);return 0; } -static int _wrap_Node_setOrientation__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; - ofQuaternion *arg2 = 0 ; SWIG_check_num_args("ofNode::setOrientation",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::setOrientation",1,"ofNode *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofNode::setOrientation",2,"ofQuaternion const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_setOrientation",1,SWIGTYPE_p_ofNode); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Node_setOrientation",2,SWIGTYPE_p_ofQuaternion); } (arg1)->setOrientation((ofQuaternion const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_setOrientation__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; ofVec3f *arg2 = 0 ; - SWIG_check_num_args("ofNode::setOrientation",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::setOrientation",1,"ofNode *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofNode::setOrientation",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_setOrientation",1,SWIGTYPE_p_ofNode); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Node_setOrientation",2,SWIGTYPE_p_ofVec3f); } (arg1)->setOrientation((ofVec3f const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_setOrientation(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Node_setOrientation__SWIG_0(L);} } } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Node_setOrientation__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Node_setOrientation'\n" - " Possible C/C++ prototypes are:\n" " ofNode::setOrientation(ofQuaternion const &)\n" - " ofNode::setOrientation(ofVec3f const &)\n"); lua_error(L);return 0; } -static int _wrap_Node_setGlobalOrientation(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; - ofQuaternion *arg2 = 0 ; SWIG_check_num_args("ofNode::setGlobalOrientation",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::setGlobalOrientation",1,"ofNode *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofNode::setGlobalOrientation",2,"ofQuaternion const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_setGlobalOrientation",1,SWIGTYPE_p_ofNode); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Node_setGlobalOrientation",2,SWIGTYPE_p_ofQuaternion); } - (arg1)->setGlobalOrientation((ofQuaternion const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Node_setScale__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; float arg2 ; - SWIG_check_num_args("ofNode::setScale",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::setScale",1,"ofNode *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofNode::setScale",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_setScale",1,SWIGTYPE_p_ofNode); } - arg2 = (float)lua_tonumber(L, 2); (arg1)->setScale(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Node_setScale__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; float arg2 ; float arg3 ; - float arg4 ; SWIG_check_num_args("ofNode::setScale",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::setScale",1,"ofNode *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofNode::setScale",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofNode::setScale",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofNode::setScale",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_setScale",1,SWIGTYPE_p_ofNode); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - (arg1)->setScale(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_setScale__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; ofVec3f *arg2 = 0 ; - SWIG_check_num_args("ofNode::setScale",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::setScale",1,"ofNode *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofNode::setScale",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_setScale",1,SWIGTYPE_p_ofNode); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Node_setScale",2,SWIGTYPE_p_ofVec3f); } (arg1)->setScale((ofVec3f const &)*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_setScale(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Node_setScale__SWIG_2(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Node_setScale__SWIG_0(L);} } } - if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Node_setScale__SWIG_1(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Node_setScale'\n" " Possible C/C++ prototypes are:\n" - " ofNode::setScale(float)\n" " ofNode::setScale(float,float,float)\n" " ofNode::setScale(ofVec3f const &)\n"); - lua_error(L);return 0; } -static int _wrap_Node_move__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; float arg2 ; float arg3 ; - float arg4 ; SWIG_check_num_args("ofNode::move",4,4) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::move",1,"ofNode *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofNode::move",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofNode::move",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofNode::move",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_move",1,SWIGTYPE_p_ofNode); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - (arg1)->move(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_move__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; ofVec3f *arg2 = 0 ; - SWIG_check_num_args("ofNode::move",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::move",1,"ofNode *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofNode::move",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_move",1,SWIGTYPE_p_ofNode); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Node_move",2,SWIGTYPE_p_ofVec3f); } - (arg1)->move((ofVec3f const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_move(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Node_move__SWIG_1(L);} } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Node_move__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Node_move'\n" " Possible C/C++ prototypes are:\n" - " ofNode::move(float,float,float)\n" " ofNode::move(ofVec3f const &)\n"); lua_error(L);return 0; } -static int _wrap_Node_truck(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; float arg2 ; - SWIG_check_num_args("ofNode::truck",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::truck",1,"ofNode *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofNode::truck",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_truck",1,SWIGTYPE_p_ofNode); } - arg2 = (float)lua_tonumber(L, 2); (arg1)->truck(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_boom(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; float arg2 ; - SWIG_check_num_args("ofNode::boom",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::boom",1,"ofNode *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofNode::boom",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_boom",1,SWIGTYPE_p_ofNode); } - arg2 = (float)lua_tonumber(L, 2); (arg1)->boom(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_dolly(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; float arg2 ; - SWIG_check_num_args("ofNode::dolly",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::dolly",1,"ofNode *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofNode::dolly",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_dolly",1,SWIGTYPE_p_ofNode); } - arg2 = (float)lua_tonumber(L, 2); (arg1)->dolly(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_tilt(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; float arg2 ; - SWIG_check_num_args("ofNode::tilt",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::tilt",1,"ofNode *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofNode::tilt",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_tilt",1,SWIGTYPE_p_ofNode); } - arg2 = (float)lua_tonumber(L, 2); (arg1)->tilt(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_pan(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; float arg2 ; - SWIG_check_num_args("ofNode::pan",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::pan",1,"ofNode *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofNode::pan",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_pan",1,SWIGTYPE_p_ofNode); } - arg2 = (float)lua_tonumber(L, 2); (arg1)->pan(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_roll(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; float arg2 ; - SWIG_check_num_args("ofNode::roll",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::roll",1,"ofNode *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofNode::roll",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_roll",1,SWIGTYPE_p_ofNode); } - arg2 = (float)lua_tonumber(L, 2); (arg1)->roll(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_rotate__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; ofQuaternion *arg2 = 0 ; - SWIG_check_num_args("ofNode::rotate",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::rotate",1,"ofNode *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofNode::rotate",2,"ofQuaternion const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_rotate",1,SWIGTYPE_p_ofNode); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Node_rotate",2,SWIGTYPE_p_ofQuaternion); } (arg1)->rotate((ofQuaternion const &)*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_rotate__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; float arg2 ; - ofVec3f *arg3 = 0 ; SWIG_check_num_args("ofNode::rotate",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::rotate",1,"ofNode *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofNode::rotate",2,"float"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofNode::rotate",3,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_rotate",1,SWIGTYPE_p_ofNode); } - arg2 = (float)lua_tonumber(L, 2); if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Node_rotate",3,SWIGTYPE_p_ofVec3f); } (arg1)->rotate(arg2,(ofVec3f const &)*arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_rotate__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; float arg2 ; float arg3 ; - float arg4 ; float arg5 ; SWIG_check_num_args("ofNode::rotate",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::rotate",1,"ofNode *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofNode::rotate",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofNode::rotate",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofNode::rotate",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofNode::rotate",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_rotate",1,SWIGTYPE_p_ofNode); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); (arg1)->rotate(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Node_rotate(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Node_rotate__SWIG_0(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Node_rotate__SWIG_1(L);} } } } if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Node_rotate__SWIG_2(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Node_rotate'\n" " Possible C/C++ prototypes are:\n" - " ofNode::rotate(ofQuaternion const &)\n" " ofNode::rotate(float,ofVec3f const &)\n" - " ofNode::rotate(float,float,float,float)\n"); lua_error(L);return 0; } -static int _wrap_Node_rotateAround__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; - ofQuaternion *arg2 = 0 ; ofVec3f *arg3 = 0 ; SWIG_check_num_args("ofNode::rotateAround",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::rotateAround",1,"ofNode *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofNode::rotateAround",2,"ofQuaternion const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofNode::rotateAround",3,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_rotateAround",1,SWIGTYPE_p_ofNode); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Node_rotateAround",2,SWIGTYPE_p_ofQuaternion); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Node_rotateAround",3,SWIGTYPE_p_ofVec3f); } - (arg1)->rotateAround((ofQuaternion const &)*arg2,(ofVec3f const &)*arg3); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Node_rotateAround__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; float arg2 ; - ofVec3f *arg3 = 0 ; ofVec3f *arg4 = 0 ; SWIG_check_num_args("ofNode::rotateAround",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::rotateAround",1,"ofNode *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofNode::rotateAround",2,"float"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofNode::rotateAround",3,"ofVec3f const &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofNode::rotateAround",4,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_rotateAround",1,SWIGTYPE_p_ofNode); } arg2 = (float)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Node_rotateAround",3,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Node_rotateAround",4,SWIGTYPE_p_ofVec3f); } - (arg1)->rotateAround(arg2,(ofVec3f const &)*arg3,(ofVec3f const &)*arg4); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Node_rotateAround(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Node_rotateAround__SWIG_0(L);} } } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Node_rotateAround__SWIG_1(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Node_rotateAround'\n" " Possible C/C++ prototypes are:\n" - " ofNode::rotateAround(ofQuaternion const &,ofVec3f const &)\n" - " ofNode::rotateAround(float,ofVec3f const &,ofVec3f const &)\n"); lua_error(L);return 0; } -static int _wrap_Node_lookAt__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; ofVec3f *arg2 = 0 ; - SWIG_check_num_args("ofNode::lookAt",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::lookAt",1,"ofNode *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofNode::lookAt",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_lookAt",1,SWIGTYPE_p_ofNode); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Node_lookAt",2,SWIGTYPE_p_ofVec3f); } - (arg1)->lookAt((ofVec3f const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_lookAt__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; ofVec3f *arg2 = 0 ; - ofVec3f arg3 ; ofVec3f *argp3 ; SWIG_check_num_args("ofNode::lookAt",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::lookAt",1,"ofNode *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofNode::lookAt",2,"ofVec3f const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofNode::lookAt",3,"ofVec3f"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_lookAt",1,SWIGTYPE_p_ofNode); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Node_lookAt",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&argp3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Node_lookAt",3,SWIGTYPE_p_ofVec3f); } arg3 = *argp3; (arg1)->lookAt((ofVec3f const &)*arg2,arg3); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_lookAt__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; ofNode *arg2 = 0 ; - SWIG_check_num_args("ofNode::lookAt",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::lookAt",1,"ofNode *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofNode::lookAt",2,"ofNode const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_lookAt",1,SWIGTYPE_p_ofNode); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_lookAt",2,SWIGTYPE_p_ofNode); } - (arg1)->lookAt((ofNode const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_lookAt__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; ofNode *arg2 = 0 ; - ofVec3f *arg3 = 0 ; SWIG_check_num_args("ofNode::lookAt",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::lookAt",1,"ofNode *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofNode::lookAt",2,"ofNode const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofNode::lookAt",3,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_lookAt",1,SWIGTYPE_p_ofNode); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_lookAt",2,SWIGTYPE_p_ofNode); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Node_lookAt",3,SWIGTYPE_p_ofVec3f); } - (arg1)->lookAt((ofNode const &)*arg2,(ofVec3f const &)*arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Node_lookAt(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Node_lookAt__SWIG_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Node_lookAt__SWIG_2(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Node_lookAt__SWIG_1(L);} } } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Node_lookAt__SWIG_3(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Node_lookAt'\n" " Possible C/C++ prototypes are:\n" - " ofNode::lookAt(ofVec3f const &)\n" " ofNode::lookAt(ofVec3f const &,ofVec3f)\n" " ofNode::lookAt(ofNode const &)\n" - " ofNode::lookAt(ofNode const &,ofVec3f const &)\n"); lua_error(L);return 0; } -static int _wrap_Node_orbit__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; float arg2 ; float arg3 ; - float arg4 ; ofVec3f *arg5 = 0 ; SWIG_check_num_args("ofNode::orbit",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::orbit",1,"ofNode *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofNode::orbit",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofNode::orbit",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofNode::orbit",4,"float"); - if(!lua_isuserdata(L,5)) SWIG_fail_arg("ofNode::orbit",5,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_orbit",1,SWIGTYPE_p_ofNode); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Node_orbit",5,SWIGTYPE_p_ofVec3f); } - (arg1)->orbit(arg2,arg3,arg4,(ofVec3f const &)*arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_orbit__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; float arg2 ; float arg3 ; - float arg4 ; SWIG_check_num_args("ofNode::orbit",4,4) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::orbit",1,"ofNode *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofNode::orbit",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofNode::orbit",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofNode::orbit",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_orbit",1,SWIGTYPE_p_ofNode); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - (arg1)->orbit(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_orbit__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; float arg2 ; float arg3 ; - float arg4 ; ofNode *arg5 = 0 ; SWIG_check_num_args("ofNode::orbit",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::orbit",1,"ofNode *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofNode::orbit",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofNode::orbit",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofNode::orbit",4,"float"); - if(!lua_isuserdata(L,5)) SWIG_fail_arg("ofNode::orbit",5,"ofNode &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_orbit",1,SWIGTYPE_p_ofNode); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_orbit",5,SWIGTYPE_p_ofNode); } - (arg1)->orbit(arg2,arg3,arg4,*arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_orbit(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 4) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Node_orbit__SWIG_1(L);} } } } } - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[4])==0 || SWIG_ConvertPtr(L,argv[4], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Node_orbit__SWIG_0(L);} } } } } } if (argc == 5) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[4])==0 || SWIG_ConvertPtr(L,argv[4], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Node_orbit__SWIG_2(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Node_orbit'\n" " Possible C/C++ prototypes are:\n" - " ofNode::orbit(float,float,float,ofVec3f const &)\n" " ofNode::orbit(float,float,float)\n" - " ofNode::orbit(float,float,float,ofNode &)\n"); lua_error(L);return 0; } -static int _wrap_Node_transformGL__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; - ofBaseRenderer *arg2 = (ofBaseRenderer *) 0 ; SWIG_check_num_args("ofNode::transformGL",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::transformGL",1,"ofNode const *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofNode::transformGL",2,"ofBaseRenderer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_transformGL",1,SWIGTYPE_p_ofNode); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBaseRenderer,0))){ - SWIG_fail_ptr("Node_transformGL",2,SWIGTYPE_p_ofBaseRenderer); } ((ofNode const *)arg1)->transformGL(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_transformGL__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; - SWIG_check_num_args("ofNode::transformGL",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::transformGL",1,"ofNode const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_transformGL",1,SWIGTYPE_p_ofNode); } ((ofNode const *)arg1)->transformGL(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_transformGL(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Node_transformGL__SWIG_1(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBaseRenderer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Node_transformGL__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Node_transformGL'\n" " Possible C/C++ prototypes are:\n" - " ofNode::transformGL(ofBaseRenderer *) const\n" " ofNode::transformGL() const\n"); lua_error(L);return 0; } -static int _wrap_Node_restoreTransformGL__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; - ofBaseRenderer *arg2 = (ofBaseRenderer *) 0 ; SWIG_check_num_args("ofNode::restoreTransformGL",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::restoreTransformGL",1,"ofNode const *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofNode::restoreTransformGL",2,"ofBaseRenderer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_restoreTransformGL",1,SWIGTYPE_p_ofNode); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBaseRenderer,0))){ - SWIG_fail_ptr("Node_restoreTransformGL",2,SWIGTYPE_p_ofBaseRenderer); } ((ofNode const *)arg1)->restoreTransformGL(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_restoreTransformGL__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; - SWIG_check_num_args("ofNode::restoreTransformGL",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::restoreTransformGL",1,"ofNode const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_restoreTransformGL",1,SWIGTYPE_p_ofNode); } ((ofNode const *)arg1)->restoreTransformGL(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_restoreTransformGL(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Node_restoreTransformGL__SWIG_1(L);} } if (argc == 2) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBaseRenderer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Node_restoreTransformGL__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Node_restoreTransformGL'\n" - " Possible C/C++ prototypes are:\n" " ofNode::restoreTransformGL(ofBaseRenderer *) const\n" - " ofNode::restoreTransformGL() const\n"); lua_error(L);return 0; } -static int _wrap_Node_resetTransform(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; - SWIG_check_num_args("ofNode::resetTransform",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::resetTransform",1,"ofNode *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_resetTransform",1,SWIGTYPE_p_ofNode); } (arg1)->resetTransform(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_customDraw__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; - ofBaseRenderer *arg2 = (ofBaseRenderer *) 0 ; SWIG_check_num_args("ofNode::customDraw",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::customDraw",1,"ofNode const *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofNode::customDraw",2,"ofBaseRenderer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_customDraw",1,SWIGTYPE_p_ofNode); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBaseRenderer,0))){ - SWIG_fail_ptr("Node_customDraw",2,SWIGTYPE_p_ofBaseRenderer); } - ((ofNode const *)arg1)->customDraw((ofBaseRenderer const *)arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Node_customDraw__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; - SWIG_check_num_args("ofNode::customDraw",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::customDraw",1,"ofNode *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_customDraw",1,SWIGTYPE_p_ofNode); } (arg1)->customDraw(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Node_customDraw(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Node_customDraw__SWIG_1(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBaseRenderer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Node_customDraw__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Node_customDraw'\n" " Possible C/C++ prototypes are:\n" - " ofNode::customDraw(ofBaseRenderer const *) const\n" " ofNode::customDraw()\n"); lua_error(L);return 0; } -static int _wrap_Node_draw(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; - SWIG_check_num_args("ofNode::draw",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::draw",1,"ofNode const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_draw",1,SWIGTYPE_p_ofNode); } - ((ofNode const *)arg1)->draw(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_Node(void *obj) { -ofNode *arg1 = (ofNode *) obj; -delete arg1; -} -static int _proxy__wrap_new_Node(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_Node); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_Node_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_Node_methods[]= { - { "setParent", _wrap_Node_setParent}, - { "clearParent", _wrap_Node_clearParent}, - { "getParent", _wrap_Node_getParent}, - { "getPosition", _wrap_Node_getPosition}, - { "getX", _wrap_Node_getX}, - { "getY", _wrap_Node_getY}, - { "getZ", _wrap_Node_getZ}, - { "getXAxis", _wrap_Node_getXAxis}, - { "getYAxis", _wrap_Node_getYAxis}, - { "getZAxis", _wrap_Node_getZAxis}, - { "getSideDir", _wrap_Node_getSideDir}, - { "getLookAtDir", _wrap_Node_getLookAtDir}, - { "getUpDir", _wrap_Node_getUpDir}, - { "getPitch", _wrap_Node_getPitch}, - { "getHeading", _wrap_Node_getHeading}, - { "getRoll", _wrap_Node_getRoll}, - { "getOrientationQuat", _wrap_Node_getOrientationQuat}, - { "getOrientationEuler", _wrap_Node_getOrientationEuler}, - { "getScale", _wrap_Node_getScale}, - { "getLocalTransformMatrix", _wrap_Node_getLocalTransformMatrix}, - { "getGlobalTransformMatrix", _wrap_Node_getGlobalTransformMatrix}, - { "getGlobalPosition", _wrap_Node_getGlobalPosition}, - { "getGlobalOrientation", _wrap_Node_getGlobalOrientation}, - { "getGlobalScale", _wrap_Node_getGlobalScale}, - { "setTransformMatrix", _wrap_Node_setTransformMatrix}, - { "setPosition", _wrap_Node_setPosition}, - { "setGlobalPosition", _wrap_Node_setGlobalPosition}, - { "setOrientation", _wrap_Node_setOrientation}, - { "setGlobalOrientation", _wrap_Node_setGlobalOrientation}, - { "setScale", _wrap_Node_setScale}, - { "move", _wrap_Node_move}, - { "truck", _wrap_Node_truck}, - { "boom", _wrap_Node_boom}, - { "dolly", _wrap_Node_dolly}, - { "tilt", _wrap_Node_tilt}, - { "pan", _wrap_Node_pan}, - { "roll", _wrap_Node_roll}, - { "rotate", _wrap_Node_rotate}, - { "rotateAround", _wrap_Node_rotateAround}, - { "lookAt", _wrap_Node_lookAt}, - { "orbit", _wrap_Node_orbit}, - { "transformGL", _wrap_Node_transformGL}, - { "restoreTransformGL", _wrap_Node_restoreTransformGL}, - { "resetTransform", _wrap_Node_resetTransform}, - { "customDraw", _wrap_Node_customDraw}, - { "draw", _wrap_Node_draw}, - {0,0} -}; -static swig_lua_method swig_Node_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_Node_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_Node_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_Node_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_Node_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_Node_Sf_SwigStatic = { - "Node", - swig_Node_Sf_SwigStatic_methods, - swig_Node_Sf_SwigStatic_attributes, - swig_Node_Sf_SwigStatic_constants, - swig_Node_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_Node_bases[] = {0}; -static const char *swig_Node_base_names[] = {0}; -static swig_lua_class _wrap_class_Node = { "Node", "Node", &SWIGTYPE_p_ofNode,_proxy__wrap_new_Node, swig_delete_Node, swig_Node_methods, swig_Node_attributes, &swig_Node_Sf_SwigStatic, swig_Node_meta, swig_Node_bases, swig_Node_base_names }; - -static int _wrap_drawAxis(lua_State* L) { int SWIG_arg = 0; float arg1 ; SWIG_check_num_args("ofDrawAxis",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawAxis",1,"float"); arg1 = (float)lua_tonumber(L, 1); ofDrawAxis(arg1); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawGrid__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; size_t arg2 ; bool arg3 ; bool arg4 ; - bool arg5 ; bool arg6 ; SWIG_check_num_args("ofDrawGrid",6,6) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawGrid",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawGrid",2,"size_t"); if(!lua_isboolean(L,3)) SWIG_fail_arg("ofDrawGrid",3,"bool"); - if(!lua_isboolean(L,4)) SWIG_fail_arg("ofDrawGrid",4,"bool"); if(!lua_isboolean(L,5)) SWIG_fail_arg("ofDrawGrid",5,"bool"); - if(!lua_isboolean(L,6)) SWIG_fail_arg("ofDrawGrid",6,"bool"); arg1 = (float)lua_tonumber(L, 1); - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - arg3 = (lua_toboolean(L, 3)!=0); arg4 = (lua_toboolean(L, 4)!=0); arg5 = (lua_toboolean(L, 5)!=0); - arg6 = (lua_toboolean(L, 6)!=0); ofDrawGrid(arg1,arg2,arg3,arg4,arg5,arg6); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_drawGrid__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; size_t arg2 ; bool arg3 ; bool arg4 ; - bool arg5 ; SWIG_check_num_args("ofDrawGrid",5,5) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawGrid",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawGrid",2,"size_t"); if(!lua_isboolean(L,3)) SWIG_fail_arg("ofDrawGrid",3,"bool"); - if(!lua_isboolean(L,4)) SWIG_fail_arg("ofDrawGrid",4,"bool"); if(!lua_isboolean(L,5)) SWIG_fail_arg("ofDrawGrid",5,"bool"); - arg1 = (float)lua_tonumber(L, 1); SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") - arg2 = (size_t)lua_tonumber(L, 2); arg3 = (lua_toboolean(L, 3)!=0); arg4 = (lua_toboolean(L, 4)!=0); - arg5 = (lua_toboolean(L, 5)!=0); ofDrawGrid(arg1,arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_drawGrid__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; size_t arg2 ; bool arg3 ; bool arg4 ; - SWIG_check_num_args("ofDrawGrid",4,4) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawGrid",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawGrid",2,"size_t"); if(!lua_isboolean(L,3)) SWIG_fail_arg("ofDrawGrid",3,"bool"); - if(!lua_isboolean(L,4)) SWIG_fail_arg("ofDrawGrid",4,"bool"); arg1 = (float)lua_tonumber(L, 1); - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - arg3 = (lua_toboolean(L, 3)!=0); arg4 = (lua_toboolean(L, 4)!=0); ofDrawGrid(arg1,arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawGrid__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; size_t arg2 ; bool arg3 ; - SWIG_check_num_args("ofDrawGrid",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawGrid",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawGrid",2,"size_t"); if(!lua_isboolean(L,3)) SWIG_fail_arg("ofDrawGrid",3,"bool"); - arg1 = (float)lua_tonumber(L, 1); SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") - arg2 = (size_t)lua_tonumber(L, 2); arg3 = (lua_toboolean(L, 3)!=0); ofDrawGrid(arg1,arg2,arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawGrid__SWIG_4(lua_State* L) { int SWIG_arg = 0; float arg1 ; size_t arg2 ; - SWIG_check_num_args("ofDrawGrid",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawGrid",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawGrid",2,"size_t"); arg1 = (float)lua_tonumber(L, 1); - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - ofDrawGrid(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawGrid__SWIG_5(lua_State* L) { int SWIG_arg = 0; float arg1 ; SWIG_check_num_args("ofDrawGrid",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawGrid",1,"float"); arg1 = (float)lua_tonumber(L, 1); ofDrawGrid(arg1); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawGrid__SWIG_6(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofDrawGrid",0,0) ofDrawGrid(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawGrid(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_drawGrid__SWIG_6(L);} if (argc == 1) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { - return _wrap_drawGrid__SWIG_5(L);} } if (argc == 2) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_drawGrid__SWIG_4(L);} } } if (argc == 3) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } - if (_v) { return _wrap_drawGrid__SWIG_3(L);} } } } if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { { - _v = lua_isboolean(L,argv[3]); } if (_v) { return _wrap_drawGrid__SWIG_2(L);} } } } } if (argc == 5) { int _v; - { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } - if (_v) { { _v = lua_isboolean(L,argv[3]); } if (_v) { { _v = lua_isboolean(L,argv[4]); } if (_v) { - return _wrap_drawGrid__SWIG_1(L);} } } } } } if (argc == 6) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { { - _v = lua_isboolean(L,argv[3]); } if (_v) { { _v = lua_isboolean(L,argv[4]); } if (_v) { { - _v = lua_isboolean(L,argv[5]); } if (_v) { return _wrap_drawGrid__SWIG_0(L);} } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'drawGrid'\n" " Possible C/C++ prototypes are:\n" - " ofDrawGrid(float,size_t,bool,bool,bool,bool)\n" " ofDrawGrid(float,size_t,bool,bool,bool)\n" - " ofDrawGrid(float,size_t,bool,bool)\n" " ofDrawGrid(float,size_t,bool)\n" " ofDrawGrid(float,size_t)\n" - " ofDrawGrid(float)\n" " ofDrawGrid()\n"); lua_error(L);return 0; } -static int _wrap_drawGridPlane__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; size_t arg2 ; bool arg3 ; - SWIG_check_num_args("ofDrawGridPlane",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawGridPlane",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawGridPlane",2,"size_t"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofDrawGridPlane",3,"bool"); arg1 = (float)lua_tonumber(L, 1); - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - arg3 = (lua_toboolean(L, 3)!=0); ofDrawGridPlane(arg1,arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_drawGridPlane__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; size_t arg2 ; - SWIG_check_num_args("ofDrawGridPlane",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawGridPlane",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawGridPlane",2,"size_t"); arg1 = (float)lua_tonumber(L, 1); - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - ofDrawGridPlane(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawGridPlane__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; SWIG_check_num_args("ofDrawGridPlane",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawGridPlane",1,"float"); arg1 = (float)lua_tonumber(L, 1); ofDrawGridPlane(arg1); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawGridPlane__SWIG_3(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofDrawGridPlane",0,0) - ofDrawGridPlane(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawGridPlane(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_drawGridPlane__SWIG_3(L);} if (argc == 1) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { - return _wrap_drawGridPlane__SWIG_2(L);} } if (argc == 2) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_drawGridPlane__SWIG_1(L);} } } if (argc == 3) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } - if (_v) { return _wrap_drawGridPlane__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'drawGridPlane'\n" " Possible C/C++ prototypes are:\n" - " ofDrawGridPlane(float,size_t,bool)\n" " ofDrawGridPlane(float,size_t)\n" " ofDrawGridPlane(float)\n" - " ofDrawGridPlane()\n"); lua_error(L);return 0; } -static int _wrap_drawArrow__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = 0 ; ofVec3f *arg2 = 0 ; float arg3 ; - SWIG_check_num_args("ofDrawArrow",3,3) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofDrawArrow",1,"ofVec3f const &"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofDrawArrow",2,"ofVec3f const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawArrow",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("drawArrow",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("drawArrow",2,SWIGTYPE_p_ofVec3f); } - arg3 = (float)lua_tonumber(L, 3); ofDrawArrow((ofVec3f const &)*arg1,(ofVec3f const &)*arg2,arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawArrow__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = 0 ; ofVec3f *arg2 = 0 ; - SWIG_check_num_args("ofDrawArrow",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofDrawArrow",1,"ofVec3f const &"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofDrawArrow",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("drawArrow",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("drawArrow",2,SWIGTYPE_p_ofVec3f); } - ofDrawArrow((ofVec3f const &)*arg1,(ofVec3f const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_drawArrow(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_drawArrow__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_drawArrow__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'drawArrow'\n" " Possible C/C++ prototypes are:\n" - " ofDrawArrow(ofVec3f const &,ofVec3f const &,float)\n" " ofDrawArrow(ofVec3f const &,ofVec3f const &)\n"); - lua_error(L);return 0; } -static int _wrap_drawRotationAxes__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; int arg3 ; - SWIG_check_num_args("ofDrawRotationAxes",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawRotationAxes",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawRotationAxes",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawRotationAxes",3,"int"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); ofDrawRotationAxes(arg1,arg2,arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawRotationAxes__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; - SWIG_check_num_args("ofDrawRotationAxes",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawRotationAxes",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawRotationAxes",2,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); ofDrawRotationAxes(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_drawRotationAxes__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; - SWIG_check_num_args("ofDrawRotationAxes",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawRotationAxes",1,"float"); - arg1 = (float)lua_tonumber(L, 1); ofDrawRotationAxes(arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_drawRotationAxes(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_drawRotationAxes__SWIG_2(L);} } if (argc == 2) { int _v; - { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_drawRotationAxes__SWIG_1(L);} } } if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { - { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_drawRotationAxes__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'drawRotationAxes'\n" " Possible C/C++ prototypes are:\n" - " ofDrawRotationAxes(float,float,int)\n" " ofDrawRotationAxes(float,float)\n" " ofDrawRotationAxes(float)\n"); - lua_error(L);return 0; } -static int _wrap_new_Camera(lua_State* L) { int SWIG_arg = 0; ofCamera *result = 0 ; - SWIG_check_num_args("ofCamera::ofCamera",0,0) result = (ofCamera *)new ofCamera(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofCamera,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Camera_setFov(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; float arg2 ; - SWIG_check_num_args("ofCamera::setFov",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::setFov",1,"ofCamera *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofCamera::setFov",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_setFov",1,SWIGTYPE_p_ofCamera); } arg2 = (float)lua_tonumber(L, 2); (arg1)->setFov(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Camera_setNearClip(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; float arg2 ; - SWIG_check_num_args("ofCamera::setNearClip",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::setNearClip",1,"ofCamera *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofCamera::setNearClip",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_setNearClip",1,SWIGTYPE_p_ofCamera); } arg2 = (float)lua_tonumber(L, 2); (arg1)->setNearClip(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Camera_setFarClip(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; float arg2 ; - SWIG_check_num_args("ofCamera::setFarClip",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::setFarClip",1,"ofCamera *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofCamera::setFarClip",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_setFarClip",1,SWIGTYPE_p_ofCamera); } arg2 = (float)lua_tonumber(L, 2); (arg1)->setFarClip(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Camera_setLensOffset(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; ofVec2f *arg2 = 0 ; - SWIG_check_num_args("ofCamera::setLensOffset",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::setLensOffset",1,"ofCamera *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofCamera::setLensOffset",2,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_setLensOffset",1,SWIGTYPE_p_ofCamera); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Camera_setLensOffset",2,SWIGTYPE_p_ofVec2f); } (arg1)->setLensOffset((ofVec2f const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Camera_setAspectRatio(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; float arg2 ; - SWIG_check_num_args("ofCamera::setAspectRatio",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::setAspectRatio",1,"ofCamera *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofCamera::setAspectRatio",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_setAspectRatio",1,SWIGTYPE_p_ofCamera); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setAspectRatio(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Camera_setForceAspectRatio(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; bool arg2 ; - SWIG_check_num_args("ofCamera::setForceAspectRatio",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::setForceAspectRatio",1,"ofCamera *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofCamera::setForceAspectRatio",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_setForceAspectRatio",1,SWIGTYPE_p_ofCamera); } arg2 = (lua_toboolean(L, 2)!=0); - (arg1)->setForceAspectRatio(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Camera_getFov(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; float result; - SWIG_check_num_args("ofCamera::getFov",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::getFov",1,"ofCamera const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_getFov",1,SWIGTYPE_p_ofCamera); } result = (float)((ofCamera const *)arg1)->getFov(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Camera_getNearClip(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; float result; - SWIG_check_num_args("ofCamera::getNearClip",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::getNearClip",1,"ofCamera const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_getNearClip",1,SWIGTYPE_p_ofCamera); } result = (float)((ofCamera const *)arg1)->getNearClip(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Camera_getFarClip(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; float result; - SWIG_check_num_args("ofCamera::getFarClip",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::getFarClip",1,"ofCamera const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_getFarClip",1,SWIGTYPE_p_ofCamera); } result = (float)((ofCamera const *)arg1)->getFarClip(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Camera_getLensOffset(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; ofVec2f result; - SWIG_check_num_args("ofCamera::getLensOffset",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::getLensOffset",1,"ofCamera const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_getLensOffset",1,SWIGTYPE_p_ofCamera); } result = ((ofCamera const *)arg1)->getLensOffset(); { - ofVec2f * resultptr = new ofVec2f((const ofVec2f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Camera_getForceAspectRatio(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; bool result; - SWIG_check_num_args("ofCamera::getForceAspectRatio",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::getForceAspectRatio",1,"ofCamera const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_getForceAspectRatio",1,SWIGTYPE_p_ofCamera); } - result = (bool)((ofCamera const *)arg1)->getForceAspectRatio(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Camera_getAspectRatio(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; float result; - SWIG_check_num_args("ofCamera::getAspectRatio",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::getAspectRatio",1,"ofCamera const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_getAspectRatio",1,SWIGTYPE_p_ofCamera); } result = (float)((ofCamera const *)arg1)->getAspectRatio(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Camera_setupPerspective__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; bool arg2 ; - float arg3 ; float arg4 ; float arg5 ; ofVec2f *arg6 = 0 ; SWIG_check_num_args("ofCamera::setupPerspective",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::setupPerspective",1,"ofCamera *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofCamera::setupPerspective",2,"bool"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofCamera::setupPerspective",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofCamera::setupPerspective",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofCamera::setupPerspective",5,"float"); - if(!lua_isuserdata(L,6)) SWIG_fail_arg("ofCamera::setupPerspective",6,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_setupPerspective",1,SWIGTYPE_p_ofCamera); } arg2 = (lua_toboolean(L, 2)!=0); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,6,(void**)&arg6,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Camera_setupPerspective",6,SWIGTYPE_p_ofVec2f); } - (arg1)->setupPerspective(arg2,arg3,arg4,arg5,(ofVec2f const &)*arg6); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Camera_setupPerspective__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; bool arg2 ; - float arg3 ; float arg4 ; float arg5 ; SWIG_check_num_args("ofCamera::setupPerspective",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::setupPerspective",1,"ofCamera *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofCamera::setupPerspective",2,"bool"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofCamera::setupPerspective",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofCamera::setupPerspective",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofCamera::setupPerspective",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_setupPerspective",1,SWIGTYPE_p_ofCamera); } arg2 = (lua_toboolean(L, 2)!=0); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - (arg1)->setupPerspective(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Camera_setupPerspective__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; bool arg2 ; - float arg3 ; float arg4 ; SWIG_check_num_args("ofCamera::setupPerspective",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::setupPerspective",1,"ofCamera *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofCamera::setupPerspective",2,"bool"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofCamera::setupPerspective",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofCamera::setupPerspective",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_setupPerspective",1,SWIGTYPE_p_ofCamera); } arg2 = (lua_toboolean(L, 2)!=0); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); (arg1)->setupPerspective(arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Camera_setupPerspective__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; bool arg2 ; - float arg3 ; SWIG_check_num_args("ofCamera::setupPerspective",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::setupPerspective",1,"ofCamera *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofCamera::setupPerspective",2,"bool"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofCamera::setupPerspective",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_setupPerspective",1,SWIGTYPE_p_ofCamera); } arg2 = (lua_toboolean(L, 2)!=0); - arg3 = (float)lua_tonumber(L, 3); (arg1)->setupPerspective(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Camera_setupPerspective__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; bool arg2 ; - SWIG_check_num_args("ofCamera::setupPerspective",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::setupPerspective",1,"ofCamera *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofCamera::setupPerspective",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_setupPerspective",1,SWIGTYPE_p_ofCamera); } arg2 = (lua_toboolean(L, 2)!=0); - (arg1)->setupPerspective(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Camera_setupPerspective__SWIG_5(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; - SWIG_check_num_args("ofCamera::setupPerspective",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::setupPerspective",1,"ofCamera *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_setupPerspective",1,SWIGTYPE_p_ofCamera); } (arg1)->setupPerspective(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Camera_setupPerspective(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); - if (argc == 1) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCamera, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Camera_setupPerspective__SWIG_5(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCamera, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_Camera_setupPerspective__SWIG_4(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCamera, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Camera_setupPerspective__SWIG_3(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCamera, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Camera_setupPerspective__SWIG_2(L);} } } } } - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCamera, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Camera_setupPerspective__SWIG_1(L);} } } } } } if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCamera, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[5])==0 || SWIG_ConvertPtr(L,argv[5], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Camera_setupPerspective__SWIG_0(L);} } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Camera_setupPerspective'\n" - " Possible C/C++ prototypes are:\n" " ofCamera::setupPerspective(bool,float,float,float,ofVec2f const &)\n" - " ofCamera::setupPerspective(bool,float,float,float)\n" " ofCamera::setupPerspective(bool,float,float)\n" - " ofCamera::setupPerspective(bool,float)\n" " ofCamera::setupPerspective(bool)\n" " ofCamera::setupPerspective()\n"); - lua_error(L);return 0; } -static int _wrap_Camera_setupOffAxisViewPortal(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; - ofVec3f *arg2 = 0 ; ofVec3f *arg3 = 0 ; ofVec3f *arg4 = 0 ; SWIG_check_num_args("ofCamera::setupOffAxisViewPortal",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::setupOffAxisViewPortal",1,"ofCamera *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofCamera::setupOffAxisViewPortal",2,"ofVec3f const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofCamera::setupOffAxisViewPortal",3,"ofVec3f const &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofCamera::setupOffAxisViewPortal",4,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_setupOffAxisViewPortal",1,SWIGTYPE_p_ofCamera); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Camera_setupOffAxisViewPortal",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Camera_setupOffAxisViewPortal",3,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Camera_setupOffAxisViewPortal",4,SWIGTYPE_p_ofVec3f); } - (arg1)->setupOffAxisViewPortal((ofVec3f const &)*arg2,(ofVec3f const &)*arg3,(ofVec3f const &)*arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Camera_setVFlip(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; bool arg2 ; - SWIG_check_num_args("ofCamera::setVFlip",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::setVFlip",1,"ofCamera *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofCamera::setVFlip",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_setVFlip",1,SWIGTYPE_p_ofCamera); } arg2 = (lua_toboolean(L, 2)!=0); (arg1)->setVFlip(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Camera_isVFlipped(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; bool result; - SWIG_check_num_args("ofCamera::isVFlipped",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::isVFlipped",1,"ofCamera const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_isVFlipped",1,SWIGTYPE_p_ofCamera); } result = (bool)((ofCamera const *)arg1)->isVFlipped(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Camera_enableOrtho(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; - SWIG_check_num_args("ofCamera::enableOrtho",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::enableOrtho",1,"ofCamera *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_enableOrtho",1,SWIGTYPE_p_ofCamera); } (arg1)->enableOrtho(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Camera_disableOrtho(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; - SWIG_check_num_args("ofCamera::disableOrtho",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::disableOrtho",1,"ofCamera *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_disableOrtho",1,SWIGTYPE_p_ofCamera); } (arg1)->disableOrtho(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Camera_getOrtho(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; bool result; - SWIG_check_num_args("ofCamera::getOrtho",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::getOrtho",1,"ofCamera const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_getOrtho",1,SWIGTYPE_p_ofCamera); } result = (bool)((ofCamera const *)arg1)->getOrtho(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Camera_getImagePlaneDistance__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; - ofRectangle arg2 ; ofRectangle *argp2 ; float result; SWIG_check_num_args("ofCamera::getImagePlaneDistance",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::getImagePlaneDistance",1,"ofCamera const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofCamera::getImagePlaneDistance",2,"ofRectangle"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_getImagePlaneDistance",1,SWIGTYPE_p_ofCamera); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Camera_getImagePlaneDistance",2,SWIGTYPE_p_ofRectangle); } arg2 = *argp2; - result = (float)((ofCamera const *)arg1)->getImagePlaneDistance(arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Camera_getImagePlaneDistance__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; - float result; SWIG_check_num_args("ofCamera::getImagePlaneDistance",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::getImagePlaneDistance",1,"ofCamera const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_getImagePlaneDistance",1,SWIGTYPE_p_ofCamera); } - result = (float)((ofCamera const *)arg1)->getImagePlaneDistance(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Camera_getImagePlaneDistance(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); - if (argc == 1) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCamera, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Camera_getImagePlaneDistance__SWIG_1(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCamera, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Camera_getImagePlaneDistance__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Camera_getImagePlaneDistance'\n" - " Possible C/C++ prototypes are:\n" " ofCamera::getImagePlaneDistance(ofRectangle) const\n" - " ofCamera::getImagePlaneDistance() const\n"); lua_error(L);return 0; } -static int _wrap_Camera_beginCamera__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; - ofRectangle arg2 ; ofRectangle *argp2 ; SWIG_check_num_args("ofCamera::begin",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::begin",1,"ofCamera *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofCamera::begin",2,"ofRectangle"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_beginCamera",1,SWIGTYPE_p_ofCamera); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Camera_beginCamera",2,SWIGTYPE_p_ofRectangle); } arg2 = *argp2; (arg1)->begin(arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Camera_beginCamera__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; - SWIG_check_num_args("ofCamera::begin",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::begin",1,"ofCamera *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_beginCamera",1,SWIGTYPE_p_ofCamera); } (arg1)->begin(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Camera_beginCamera(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCamera, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Camera_beginCamera__SWIG_1(L);} } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCamera, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Camera_beginCamera__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Camera_beginCamera'\n" " Possible C/C++ prototypes are:\n" - " ofCamera::begin(ofRectangle)\n" " ofCamera::begin()\n"); lua_error(L);return 0; } -static int _wrap_Camera_endCamera(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; - SWIG_check_num_args("ofCamera::end",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::end",1,"ofCamera *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_endCamera",1,SWIGTYPE_p_ofCamera); } (arg1)->end(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Camera_getProjectionMatrix__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; - ofRectangle arg2 ; ofRectangle *argp2 ; ofMatrix4x4 result; SWIG_check_num_args("ofCamera::getProjectionMatrix",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::getProjectionMatrix",1,"ofCamera const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofCamera::getProjectionMatrix",2,"ofRectangle"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_getProjectionMatrix",1,SWIGTYPE_p_ofCamera); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Camera_getProjectionMatrix",2,SWIGTYPE_p_ofRectangle); } arg2 = *argp2; - result = ((ofCamera const *)arg1)->getProjectionMatrix(arg2); { - ofMatrix4x4 * resultptr = new ofMatrix4x4((const ofMatrix4x4 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Camera_getProjectionMatrix__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; - ofMatrix4x4 result; SWIG_check_num_args("ofCamera::getProjectionMatrix",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::getProjectionMatrix",1,"ofCamera const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_getProjectionMatrix",1,SWIGTYPE_p_ofCamera); } - result = ((ofCamera const *)arg1)->getProjectionMatrix(); { - ofMatrix4x4 * resultptr = new ofMatrix4x4((const ofMatrix4x4 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Camera_getProjectionMatrix(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); - if (argc == 1) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCamera, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Camera_getProjectionMatrix__SWIG_1(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCamera, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Camera_getProjectionMatrix__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Camera_getProjectionMatrix'\n" - " Possible C/C++ prototypes are:\n" " ofCamera::getProjectionMatrix(ofRectangle) const\n" - " ofCamera::getProjectionMatrix() const\n"); lua_error(L);return 0; } -static int _wrap_Camera_getModelViewMatrix(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; - ofMatrix4x4 result; SWIG_check_num_args("ofCamera::getModelViewMatrix",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::getModelViewMatrix",1,"ofCamera const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_getModelViewMatrix",1,SWIGTYPE_p_ofCamera); } - result = ((ofCamera const *)arg1)->getModelViewMatrix(); { - ofMatrix4x4 * resultptr = new ofMatrix4x4((const ofMatrix4x4 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Camera_getModelViewProjectionMatrix__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; - ofRectangle arg2 ; ofRectangle *argp2 ; ofMatrix4x4 result; SWIG_check_num_args("ofCamera::getModelViewProjectionMatrix",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::getModelViewProjectionMatrix",1,"ofCamera const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofCamera::getModelViewProjectionMatrix",2,"ofRectangle"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_getModelViewProjectionMatrix",1,SWIGTYPE_p_ofCamera); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Camera_getModelViewProjectionMatrix",2,SWIGTYPE_p_ofRectangle); } arg2 = *argp2; - result = ((ofCamera const *)arg1)->getModelViewProjectionMatrix(arg2); { - ofMatrix4x4 * resultptr = new ofMatrix4x4((const ofMatrix4x4 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Camera_getModelViewProjectionMatrix__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; - ofMatrix4x4 result; SWIG_check_num_args("ofCamera::getModelViewProjectionMatrix",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::getModelViewProjectionMatrix",1,"ofCamera const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_getModelViewProjectionMatrix",1,SWIGTYPE_p_ofCamera); } - result = ((ofCamera const *)arg1)->getModelViewProjectionMatrix(); { - ofMatrix4x4 * resultptr = new ofMatrix4x4((const ofMatrix4x4 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Camera_getModelViewProjectionMatrix(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); - if (argc == 1) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCamera, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Camera_getModelViewProjectionMatrix__SWIG_1(L);} } if (argc == 2) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCamera, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Camera_getModelViewProjectionMatrix__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Camera_getModelViewProjectionMatrix'\n" - " Possible C/C++ prototypes are:\n" " ofCamera::getModelViewProjectionMatrix(ofRectangle) const\n" - " ofCamera::getModelViewProjectionMatrix() const\n"); lua_error(L);return 0; } -static int _wrap_Camera_worldToScreen__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; ofVec3f arg2 ; - ofRectangle arg3 ; ofVec3f *argp2 ; ofRectangle *argp3 ; ofVec3f result; SWIG_check_num_args("ofCamera::worldToScreen",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::worldToScreen",1,"ofCamera const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofCamera::worldToScreen",2,"ofVec3f"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofCamera::worldToScreen",3,"ofRectangle"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_worldToScreen",1,SWIGTYPE_p_ofCamera); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Camera_worldToScreen",2,SWIGTYPE_p_ofVec3f); } arg2 = *argp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&argp3,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Camera_worldToScreen",3,SWIGTYPE_p_ofRectangle); } arg3 = *argp3; - result = ((ofCamera const *)arg1)->worldToScreen(arg2,arg3); { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Camera_worldToScreen__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; ofVec3f arg2 ; - ofVec3f *argp2 ; ofVec3f result; SWIG_check_num_args("ofCamera::worldToScreen",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::worldToScreen",1,"ofCamera const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofCamera::worldToScreen",2,"ofVec3f"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_worldToScreen",1,SWIGTYPE_p_ofCamera); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Camera_worldToScreen",2,SWIGTYPE_p_ofVec3f); } arg2 = *argp2; - result = ((ofCamera const *)arg1)->worldToScreen(arg2); { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Camera_worldToScreen(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCamera, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Camera_worldToScreen__SWIG_1(L);} } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCamera, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Camera_worldToScreen__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Camera_worldToScreen'\n" - " Possible C/C++ prototypes are:\n" " ofCamera::worldToScreen(ofVec3f,ofRectangle) const\n" - " ofCamera::worldToScreen(ofVec3f) const\n"); lua_error(L);return 0; } -static int _wrap_Camera_screenToWorld__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; ofVec3f arg2 ; - ofRectangle arg3 ; ofVec3f *argp2 ; ofRectangle *argp3 ; ofVec3f result; SWIG_check_num_args("ofCamera::screenToWorld",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::screenToWorld",1,"ofCamera const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofCamera::screenToWorld",2,"ofVec3f"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofCamera::screenToWorld",3,"ofRectangle"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_screenToWorld",1,SWIGTYPE_p_ofCamera); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Camera_screenToWorld",2,SWIGTYPE_p_ofVec3f); } arg2 = *argp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&argp3,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Camera_screenToWorld",3,SWIGTYPE_p_ofRectangle); } arg3 = *argp3; - result = ((ofCamera const *)arg1)->screenToWorld(arg2,arg3); { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Camera_screenToWorld__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; ofVec3f arg2 ; - ofVec3f *argp2 ; ofVec3f result; SWIG_check_num_args("ofCamera::screenToWorld",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::screenToWorld",1,"ofCamera const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofCamera::screenToWorld",2,"ofVec3f"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_screenToWorld",1,SWIGTYPE_p_ofCamera); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Camera_screenToWorld",2,SWIGTYPE_p_ofVec3f); } arg2 = *argp2; - result = ((ofCamera const *)arg1)->screenToWorld(arg2); { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Camera_screenToWorld(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCamera, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Camera_screenToWorld__SWIG_1(L);} } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCamera, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Camera_screenToWorld__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Camera_screenToWorld'\n" - " Possible C/C++ prototypes are:\n" " ofCamera::screenToWorld(ofVec3f,ofRectangle) const\n" - " ofCamera::screenToWorld(ofVec3f) const\n"); lua_error(L);return 0; } -static int _wrap_Camera_worldToCamera__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; ofVec3f arg2 ; - ofRectangle arg3 ; ofVec3f *argp2 ; ofRectangle *argp3 ; ofVec3f result; SWIG_check_num_args("ofCamera::worldToCamera",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::worldToCamera",1,"ofCamera const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofCamera::worldToCamera",2,"ofVec3f"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofCamera::worldToCamera",3,"ofRectangle"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_worldToCamera",1,SWIGTYPE_p_ofCamera); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Camera_worldToCamera",2,SWIGTYPE_p_ofVec3f); } arg2 = *argp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&argp3,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Camera_worldToCamera",3,SWIGTYPE_p_ofRectangle); } arg3 = *argp3; - result = ((ofCamera const *)arg1)->worldToCamera(arg2,arg3); { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Camera_worldToCamera__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; ofVec3f arg2 ; - ofVec3f *argp2 ; ofVec3f result; SWIG_check_num_args("ofCamera::worldToCamera",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::worldToCamera",1,"ofCamera const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofCamera::worldToCamera",2,"ofVec3f"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_worldToCamera",1,SWIGTYPE_p_ofCamera); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Camera_worldToCamera",2,SWIGTYPE_p_ofVec3f); } arg2 = *argp2; - result = ((ofCamera const *)arg1)->worldToCamera(arg2); { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Camera_worldToCamera(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCamera, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Camera_worldToCamera__SWIG_1(L);} } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCamera, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Camera_worldToCamera__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Camera_worldToCamera'\n" - " Possible C/C++ prototypes are:\n" " ofCamera::worldToCamera(ofVec3f,ofRectangle) const\n" - " ofCamera::worldToCamera(ofVec3f) const\n"); lua_error(L);return 0; } -static int _wrap_Camera_cameraToWorld__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; ofVec3f arg2 ; - ofRectangle arg3 ; ofVec3f *argp2 ; ofRectangle *argp3 ; ofVec3f result; SWIG_check_num_args("ofCamera::cameraToWorld",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::cameraToWorld",1,"ofCamera const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofCamera::cameraToWorld",2,"ofVec3f"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofCamera::cameraToWorld",3,"ofRectangle"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_cameraToWorld",1,SWIGTYPE_p_ofCamera); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Camera_cameraToWorld",2,SWIGTYPE_p_ofVec3f); } arg2 = *argp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&argp3,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Camera_cameraToWorld",3,SWIGTYPE_p_ofRectangle); } arg3 = *argp3; - result = ((ofCamera const *)arg1)->cameraToWorld(arg2,arg3); { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Camera_cameraToWorld__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; ofVec3f arg2 ; - ofVec3f *argp2 ; ofVec3f result; SWIG_check_num_args("ofCamera::cameraToWorld",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::cameraToWorld",1,"ofCamera const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofCamera::cameraToWorld",2,"ofVec3f"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_cameraToWorld",1,SWIGTYPE_p_ofCamera); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Camera_cameraToWorld",2,SWIGTYPE_p_ofVec3f); } arg2 = *argp2; - result = ((ofCamera const *)arg1)->cameraToWorld(arg2); { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Camera_cameraToWorld(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCamera, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Camera_cameraToWorld__SWIG_1(L);} } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCamera, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Camera_cameraToWorld__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Camera_cameraToWorld'\n" - " Possible C/C++ prototypes are:\n" " ofCamera::cameraToWorld(ofVec3f,ofRectangle) const\n" - " ofCamera::cameraToWorld(ofVec3f) const\n"); lua_error(L);return 0; } -static int _wrap_Camera_setRenderer(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; - SwigValueWrapper< shared_ptr< ofBaseRenderer > > arg2 ; shared_ptr< ofBaseRenderer > *argp2 ; - SWIG_check_num_args("ofCamera::setRenderer",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::setRenderer",1,"ofCamera *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofCamera::setRenderer",2,"shared_ptr< ofBaseRenderer >"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_setRenderer",1,SWIGTYPE_p_ofCamera); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_shared_ptrT_ofBaseRenderer_t,0))){ - SWIG_fail_ptr("Camera_setRenderer",2,SWIGTYPE_p_shared_ptrT_ofBaseRenderer_t); } arg2 = *argp2; (arg1)->setRenderer(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_Camera(void *obj) { -ofCamera *arg1 = (ofCamera *) obj; -delete arg1; -} -static int _proxy__wrap_new_Camera(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_Camera); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_Camera_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_Camera_methods[]= { - { "setFov", _wrap_Camera_setFov}, - { "setNearClip", _wrap_Camera_setNearClip}, - { "setFarClip", _wrap_Camera_setFarClip}, - { "setLensOffset", _wrap_Camera_setLensOffset}, - { "setAspectRatio", _wrap_Camera_setAspectRatio}, - { "setForceAspectRatio", _wrap_Camera_setForceAspectRatio}, - { "getFov", _wrap_Camera_getFov}, - { "getNearClip", _wrap_Camera_getNearClip}, - { "getFarClip", _wrap_Camera_getFarClip}, - { "getLensOffset", _wrap_Camera_getLensOffset}, - { "getForceAspectRatio", _wrap_Camera_getForceAspectRatio}, - { "getAspectRatio", _wrap_Camera_getAspectRatio}, - { "setupPerspective", _wrap_Camera_setupPerspective}, - { "setupOffAxisViewPortal", _wrap_Camera_setupOffAxisViewPortal}, - { "setVFlip", _wrap_Camera_setVFlip}, - { "isVFlipped", _wrap_Camera_isVFlipped}, - { "enableOrtho", _wrap_Camera_enableOrtho}, - { "disableOrtho", _wrap_Camera_disableOrtho}, - { "getOrtho", _wrap_Camera_getOrtho}, - { "getImagePlaneDistance", _wrap_Camera_getImagePlaneDistance}, - { "beginCamera", _wrap_Camera_beginCamera}, - { "endCamera", _wrap_Camera_endCamera}, - { "getProjectionMatrix", _wrap_Camera_getProjectionMatrix}, - { "getModelViewMatrix", _wrap_Camera_getModelViewMatrix}, - { "getModelViewProjectionMatrix", _wrap_Camera_getModelViewProjectionMatrix}, - { "worldToScreen", _wrap_Camera_worldToScreen}, - { "screenToWorld", _wrap_Camera_screenToWorld}, - { "worldToCamera", _wrap_Camera_worldToCamera}, - { "cameraToWorld", _wrap_Camera_cameraToWorld}, - { "setRenderer", _wrap_Camera_setRenderer}, - {0,0} -}; -static swig_lua_method swig_Camera_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_Camera_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_Camera_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_Camera_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_Camera_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_Camera_Sf_SwigStatic = { - "Camera", - swig_Camera_Sf_SwigStatic_methods, - swig_Camera_Sf_SwigStatic_attributes, - swig_Camera_Sf_SwigStatic_constants, - swig_Camera_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_Camera_bases[] = {0,0}; -static const char *swig_Camera_base_names[] = {"ofNode *",0}; -static swig_lua_class _wrap_class_Camera = { "Camera", "Camera", &SWIGTYPE_p_ofCamera,_proxy__wrap_new_Camera, swig_delete_Camera, swig_Camera_methods, swig_Camera_attributes, &swig_Camera_Sf_SwigStatic, swig_Camera_meta, swig_Camera_bases, swig_Camera_base_names }; - -static int _wrap_new_EasyCam(lua_State* L) { int SWIG_arg = 0; ofEasyCam *result = 0 ; - SWIG_check_num_args("ofEasyCam::ofEasyCam",0,0) result = (ofEasyCam *)new ofEasyCam(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofEasyCam,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_EasyCam_beginCamera__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofEasyCam *arg1 = (ofEasyCam *) 0 ; - ofRectangle arg2 ; ofRectangle *argp2 ; SWIG_check_num_args("ofEasyCam::begin",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofEasyCam::begin",1,"ofEasyCam *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofEasyCam::begin",2,"ofRectangle"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofEasyCam,0))){ - SWIG_fail_ptr("EasyCam_beginCamera",1,SWIGTYPE_p_ofEasyCam); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("EasyCam_beginCamera",2,SWIGTYPE_p_ofRectangle); } arg2 = *argp2; (arg1)->begin(arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_EasyCam_beginCamera__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofEasyCam *arg1 = (ofEasyCam *) 0 ; - SWIG_check_num_args("ofEasyCam::begin",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofEasyCam::begin",1,"ofEasyCam *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofEasyCam,0))){ - SWIG_fail_ptr("EasyCam_beginCamera",1,SWIGTYPE_p_ofEasyCam); } (arg1)->begin(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_EasyCam_beginCamera(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofEasyCam, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_EasyCam_beginCamera__SWIG_1(L);} } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofEasyCam, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_EasyCam_beginCamera__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'EasyCam_beginCamera'\n" - " Possible C/C++ prototypes are:\n" " ofEasyCam::begin(ofRectangle)\n" " ofEasyCam::begin()\n"); - lua_error(L);return 0; } -static int _wrap_EasyCam_reset(lua_State* L) { int SWIG_arg = 0; ofEasyCam *arg1 = (ofEasyCam *) 0 ; - SWIG_check_num_args("ofEasyCam::reset",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofEasyCam::reset",1,"ofEasyCam *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofEasyCam,0))){ - SWIG_fail_ptr("EasyCam_reset",1,SWIGTYPE_p_ofEasyCam); } (arg1)->reset(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_EasyCam_setTarget__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofEasyCam *arg1 = (ofEasyCam *) 0 ; - ofVec3f *arg2 = 0 ; SWIG_check_num_args("ofEasyCam::setTarget",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofEasyCam::setTarget",1,"ofEasyCam *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofEasyCam::setTarget",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofEasyCam,0))){ - SWIG_fail_ptr("EasyCam_setTarget",1,SWIGTYPE_p_ofEasyCam); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("EasyCam_setTarget",2,SWIGTYPE_p_ofVec3f); } (arg1)->setTarget((ofVec3f const &)*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_EasyCam_setTarget__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofEasyCam *arg1 = (ofEasyCam *) 0 ; - ofNode *arg2 = 0 ; SWIG_check_num_args("ofEasyCam::setTarget",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofEasyCam::setTarget",1,"ofEasyCam *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofEasyCam::setTarget",2,"ofNode &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofEasyCam,0))){ - SWIG_fail_ptr("EasyCam_setTarget",1,SWIGTYPE_p_ofEasyCam); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("EasyCam_setTarget",2,SWIGTYPE_p_ofNode); } (arg1)->setTarget(*arg2); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_EasyCam_setTarget(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofEasyCam, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_EasyCam_setTarget__SWIG_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofEasyCam, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_EasyCam_setTarget__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'EasyCam_setTarget'\n" " Possible C/C++ prototypes are:\n" - " ofEasyCam::setTarget(ofVec3f const &)\n" " ofEasyCam::setTarget(ofNode &)\n"); lua_error(L);return 0; } -static int _wrap_EasyCam_getTarget(lua_State* L) { int SWIG_arg = 0; ofEasyCam *arg1 = (ofEasyCam *) 0 ; ofNode *result = 0 ; - SWIG_check_num_args("ofEasyCam::getTarget",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofEasyCam::getTarget",1,"ofEasyCam *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofEasyCam,0))){ - SWIG_fail_ptr("EasyCam_getTarget",1,SWIGTYPE_p_ofEasyCam); } result = (ofNode *) &(arg1)->getTarget(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofNode,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_EasyCam_setDistance(lua_State* L) { int SWIG_arg = 0; ofEasyCam *arg1 = (ofEasyCam *) 0 ; float arg2 ; - SWIG_check_num_args("ofEasyCam::setDistance",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofEasyCam::setDistance",1,"ofEasyCam *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofEasyCam::setDistance",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofEasyCam,0))){ - SWIG_fail_ptr("EasyCam_setDistance",1,SWIGTYPE_p_ofEasyCam); } arg2 = (float)lua_tonumber(L, 2); (arg1)->setDistance(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_EasyCam_getDistance(lua_State* L) { int SWIG_arg = 0; ofEasyCam *arg1 = (ofEasyCam *) 0 ; float result; - SWIG_check_num_args("ofEasyCam::getDistance",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofEasyCam::getDistance",1,"ofEasyCam const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofEasyCam,0))){ - SWIG_fail_ptr("EasyCam_getDistance",1,SWIGTYPE_p_ofEasyCam); } result = (float)((ofEasyCam const *)arg1)->getDistance(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_EasyCam_setDrag(lua_State* L) { int SWIG_arg = 0; ofEasyCam *arg1 = (ofEasyCam *) 0 ; float arg2 ; - SWIG_check_num_args("ofEasyCam::setDrag",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofEasyCam::setDrag",1,"ofEasyCam *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofEasyCam::setDrag",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofEasyCam,0))){ - SWIG_fail_ptr("EasyCam_setDrag",1,SWIGTYPE_p_ofEasyCam); } arg2 = (float)lua_tonumber(L, 2); (arg1)->setDrag(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_EasyCam_getDrag(lua_State* L) { int SWIG_arg = 0; ofEasyCam *arg1 = (ofEasyCam *) 0 ; float result; - SWIG_check_num_args("ofEasyCam::getDrag",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofEasyCam::getDrag",1,"ofEasyCam const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofEasyCam,0))){ - SWIG_fail_ptr("EasyCam_getDrag",1,SWIGTYPE_p_ofEasyCam); } result = (float)((ofEasyCam const *)arg1)->getDrag(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_EasyCam_setAutoDistance(lua_State* L) { int SWIG_arg = 0; ofEasyCam *arg1 = (ofEasyCam *) 0 ; bool arg2 ; - SWIG_check_num_args("ofEasyCam::setAutoDistance",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofEasyCam::setAutoDistance",1,"ofEasyCam *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofEasyCam::setAutoDistance",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofEasyCam,0))){ - SWIG_fail_ptr("EasyCam_setAutoDistance",1,SWIGTYPE_p_ofEasyCam); } arg2 = (lua_toboolean(L, 2)!=0); - (arg1)->setAutoDistance(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_EasyCam_setEvents(lua_State* L) { int SWIG_arg = 0; ofEasyCam *arg1 = (ofEasyCam *) 0 ; - ofCoreEvents *arg2 = 0 ; SWIG_check_num_args("ofEasyCam::setEvents",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofEasyCam::setEvents",1,"ofEasyCam *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofEasyCam::setEvents",2,"ofCoreEvents &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofEasyCam,0))){ - SWIG_fail_ptr("EasyCam_setEvents",1,SWIGTYPE_p_ofEasyCam); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofCoreEvents,0))){ - SWIG_fail_ptr("EasyCam_setEvents",2,SWIGTYPE_p_ofCoreEvents); } (arg1)->setEvents(*arg2); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_EasyCam_setTranslationKey(lua_State* L) { int SWIG_arg = 0; ofEasyCam *arg1 = (ofEasyCam *) 0 ; char arg2 ; - SWIG_check_num_args("ofEasyCam::setTranslationKey",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofEasyCam::setTranslationKey",1,"ofEasyCam *"); - if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("ofEasyCam::setTranslationKey",2,"char"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofEasyCam,0))){ - SWIG_fail_ptr("EasyCam_setTranslationKey",1,SWIGTYPE_p_ofEasyCam); } arg2 = (lua_tostring(L, 2))[0]; - (arg1)->setTranslationKey(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_EasyCam_getTranslationKey(lua_State* L) { int SWIG_arg = 0; ofEasyCam *arg1 = (ofEasyCam *) 0 ; char result; - SWIG_check_num_args("ofEasyCam::getTranslationKey",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofEasyCam::getTranslationKey",1,"ofEasyCam *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofEasyCam,0))){ - SWIG_fail_ptr("EasyCam_getTranslationKey",1,SWIGTYPE_p_ofEasyCam); } result = (char)(arg1)->getTranslationKey(); - lua_pushlstring(L, &result, 1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_EasyCam_enableMouseInput(lua_State* L) { int SWIG_arg = 0; ofEasyCam *arg1 = (ofEasyCam *) 0 ; - SWIG_check_num_args("ofEasyCam::enableMouseInput",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofEasyCam::enableMouseInput",1,"ofEasyCam *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofEasyCam,0))){ - SWIG_fail_ptr("EasyCam_enableMouseInput",1,SWIGTYPE_p_ofEasyCam); } (arg1)->enableMouseInput(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_EasyCam_disableMouseInput(lua_State* L) { int SWIG_arg = 0; ofEasyCam *arg1 = (ofEasyCam *) 0 ; - SWIG_check_num_args("ofEasyCam::disableMouseInput",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofEasyCam::disableMouseInput",1,"ofEasyCam *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofEasyCam,0))){ - SWIG_fail_ptr("EasyCam_disableMouseInput",1,SWIGTYPE_p_ofEasyCam); } (arg1)->disableMouseInput(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_EasyCam_getMouseInputEnabled(lua_State* L) { int SWIG_arg = 0; ofEasyCam *arg1 = (ofEasyCam *) 0 ; bool result; - SWIG_check_num_args("ofEasyCam::getMouseInputEnabled",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofEasyCam::getMouseInputEnabled",1,"ofEasyCam *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofEasyCam,0))){ - SWIG_fail_ptr("EasyCam_getMouseInputEnabled",1,SWIGTYPE_p_ofEasyCam); } result = (bool)(arg1)->getMouseInputEnabled(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_EasyCam_enableMouseMiddleButton(lua_State* L) { int SWIG_arg = 0; ofEasyCam *arg1 = (ofEasyCam *) 0 ; - SWIG_check_num_args("ofEasyCam::enableMouseMiddleButton",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofEasyCam::enableMouseMiddleButton",1,"ofEasyCam *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofEasyCam,0))){ - SWIG_fail_ptr("EasyCam_enableMouseMiddleButton",1,SWIGTYPE_p_ofEasyCam); } (arg1)->enableMouseMiddleButton(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_EasyCam_disableMouseMiddleButton(lua_State* L) { int SWIG_arg = 0; ofEasyCam *arg1 = (ofEasyCam *) 0 ; - SWIG_check_num_args("ofEasyCam::disableMouseMiddleButton",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofEasyCam::disableMouseMiddleButton",1,"ofEasyCam *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofEasyCam,0))){ - SWIG_fail_ptr("EasyCam_disableMouseMiddleButton",1,SWIGTYPE_p_ofEasyCam); } (arg1)->disableMouseMiddleButton(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_EasyCam_getMouseMiddleButtonEnabled(lua_State* L) { int SWIG_arg = 0; ofEasyCam *arg1 = (ofEasyCam *) 0 ; - bool result; SWIG_check_num_args("ofEasyCam::getMouseMiddleButtonEnabled",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofEasyCam::getMouseMiddleButtonEnabled",1,"ofEasyCam *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofEasyCam,0))){ - SWIG_fail_ptr("EasyCam_getMouseMiddleButtonEnabled",1,SWIGTYPE_p_ofEasyCam); } - result = (bool)(arg1)->getMouseMiddleButtonEnabled(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_EasyCam(void *obj) { -ofEasyCam *arg1 = (ofEasyCam *) obj; -delete arg1; -} -static int _proxy__wrap_new_EasyCam(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_EasyCam); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_EasyCam_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_EasyCam_methods[]= { - { "beginCamera", _wrap_EasyCam_beginCamera}, - { "reset", _wrap_EasyCam_reset}, - { "setTarget", _wrap_EasyCam_setTarget}, - { "getTarget", _wrap_EasyCam_getTarget}, - { "setDistance", _wrap_EasyCam_setDistance}, - { "getDistance", _wrap_EasyCam_getDistance}, - { "setDrag", _wrap_EasyCam_setDrag}, - { "getDrag", _wrap_EasyCam_getDrag}, - { "setAutoDistance", _wrap_EasyCam_setAutoDistance}, - { "setEvents", _wrap_EasyCam_setEvents}, - { "setTranslationKey", _wrap_EasyCam_setTranslationKey}, - { "getTranslationKey", _wrap_EasyCam_getTranslationKey}, - { "enableMouseInput", _wrap_EasyCam_enableMouseInput}, - { "disableMouseInput", _wrap_EasyCam_disableMouseInput}, - { "getMouseInputEnabled", _wrap_EasyCam_getMouseInputEnabled}, - { "enableMouseMiddleButton", _wrap_EasyCam_enableMouseMiddleButton}, - { "disableMouseMiddleButton", _wrap_EasyCam_disableMouseMiddleButton}, - { "getMouseMiddleButtonEnabled", _wrap_EasyCam_getMouseMiddleButtonEnabled}, - {0,0} -}; -static swig_lua_method swig_EasyCam_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_EasyCam_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_EasyCam_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_EasyCam_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_EasyCam_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_EasyCam_Sf_SwigStatic = { - "EasyCam", - swig_EasyCam_Sf_SwigStatic_methods, - swig_EasyCam_Sf_SwigStatic_attributes, - swig_EasyCam_Sf_SwigStatic_constants, - swig_EasyCam_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_EasyCam_bases[] = {0,0}; -static const char *swig_EasyCam_base_names[] = {"ofCamera *",0}; -static swig_lua_class _wrap_class_EasyCam = { "EasyCam", "EasyCam", &SWIGTYPE_p_ofEasyCam,_proxy__wrap_new_EasyCam, swig_delete_EasyCam, swig_EasyCam_methods, swig_EasyCam_attributes, &swig_EasyCam_Sf_SwigStatic, swig_EasyCam_meta, swig_EasyCam_bases, swig_EasyCam_base_names }; - -static int _wrap_new_Mesh__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMesh *result = 0 ; - SWIG_check_num_args("ofMesh::ofMesh",0,0) result = (ofMesh *)new ofMesh(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMesh,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Mesh__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPrimitiveMode arg1 ; std::vector< ofVec3f > *arg2 = 0 ; - ofMesh *result = 0 ; SWIG_check_num_args("ofMesh::ofMesh",2,2) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh::ofMesh",1,"ofPrimitiveMode"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMesh::ofMesh",2,"std::vector< ofVec3f > const &"); - arg1 = (ofPrimitiveMode)(int)lua_tonumber(L, 1); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__vectorT_ofVec3f_t,0))){ - SWIG_fail_ptr("new_Mesh",2,SWIGTYPE_p_std__vectorT_ofVec3f_t); } - result = (ofMesh *)new ofMesh(arg1,(std::vector< ofVec3f > const &)*arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMesh,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Mesh(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_Mesh__SWIG_0(L);} if (argc == 2) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_std__vectorT_ofVec3f_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_new_Mesh__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_Mesh'\n" " Possible C/C++ prototypes are:\n" - " ofMesh::ofMesh()\n" " ofMesh::ofMesh(ofPrimitiveMode,std::vector< ofVec3f > const &)\n"); lua_error(L);return 0; } -static int _wrap_Mesh_setFromTriangles__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - std::vector< ofMeshFace > *arg2 = 0 ; bool arg3 ; SWIG_check_num_args("ofMesh::setFromTriangles",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::setFromTriangles",1,"ofMesh *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMesh::setFromTriangles",2,"std::vector< ofMeshFace > const &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofMesh::setFromTriangles",3,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_setFromTriangles",1,SWIGTYPE_p_ofMesh); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__vectorT_ofMeshFace_t,0))){ - SWIG_fail_ptr("Mesh_setFromTriangles",2,SWIGTYPE_p_std__vectorT_ofMeshFace_t); } arg3 = (lua_toboolean(L, 3)!=0); - (arg1)->setFromTriangles((std::vector< ofMeshFace > const &)*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Mesh_setFromTriangles__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - std::vector< ofMeshFace > *arg2 = 0 ; SWIG_check_num_args("ofMesh::setFromTriangles",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::setFromTriangles",1,"ofMesh *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMesh::setFromTriangles",2,"std::vector< ofMeshFace > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_setFromTriangles",1,SWIGTYPE_p_ofMesh); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__vectorT_ofMeshFace_t,0))){ - SWIG_fail_ptr("Mesh_setFromTriangles",2,SWIGTYPE_p_std__vectorT_ofMeshFace_t); } - (arg1)->setFromTriangles((std::vector< ofMeshFace > const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Mesh_setFromTriangles(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_std__vectorT_ofMeshFace_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Mesh_setFromTriangles__SWIG_1(L);} } } if (argc == 3) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_std__vectorT_ofMeshFace_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - return _wrap_Mesh_setFromTriangles__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_setFromTriangles'\n" - " Possible C/C++ prototypes are:\n" " ofMesh::setFromTriangles(std::vector< ofMeshFace > const &,bool)\n" - " ofMesh::setFromTriangles(std::vector< ofMeshFace > const &)\n"); lua_error(L);return 0; } -static int _wrap_Mesh_setMode(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; ofPrimitiveMode arg2 ; - SWIG_check_num_args("ofMesh::setMode",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::setMode",1,"ofMesh *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::setMode",2,"ofPrimitiveMode"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Mesh_setMode",1,SWIGTYPE_p_ofMesh); } - arg2 = (ofPrimitiveMode)(int)lua_tonumber(L, 2); (arg1)->setMode(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Mesh_getMode(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; ofPrimitiveMode result; - SWIG_check_num_args("ofMesh::getMode",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getMode",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Mesh_getMode",1,SWIGTYPE_p_ofMesh); } - result = (ofPrimitiveMode)((ofMesh const *)arg1)->getMode(); lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_plane__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; int arg3 ; int arg4 ; - ofPrimitiveMode arg5 ; ofMesh result; SWIG_check_num_args("ofMesh::plane",5,5) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh::plane",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::plane",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh::plane",3,"int"); if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMesh::plane",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMesh::plane",5,"ofPrimitiveMode"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - arg5 = (ofPrimitiveMode)(int)lua_tonumber(L, 5); result = ofMesh::plane(arg1,arg2,arg3,arg4,arg5); { - ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_plane__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; int arg3 ; int arg4 ; - ofMesh result; SWIG_check_num_args("ofMesh::plane",4,4) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh::plane",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::plane",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh::plane",3,"int"); if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMesh::plane",4,"int"); - arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); result = ofMesh::plane(arg1,arg2,arg3,arg4); { - ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_plane__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; int arg3 ; ofMesh result; - SWIG_check_num_args("ofMesh::plane",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh::plane",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::plane",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh::plane",3,"int"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); result = ofMesh::plane(arg1,arg2,arg3); { - ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_plane__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; ofMesh result; - SWIG_check_num_args("ofMesh::plane",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh::plane",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::plane",2,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); result = ofMesh::plane(arg1,arg2); { - ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_plane(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Mesh_plane__SWIG_3(L);} } } if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Mesh_plane__SWIG_2(L);} } } } if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Mesh_plane__SWIG_1(L);} } } } } if (argc == 5) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Mesh_plane__SWIG_0(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_plane'\n" " Possible C/C++ prototypes are:\n" - " ofMesh::plane(float,float,int,int,ofPrimitiveMode)\n" " ofMesh::plane(float,float,int,int)\n" - " ofMesh::plane(float,float,int)\n" " ofMesh::plane(float,float)\n"); lua_error(L);return 0; } -static int _wrap_Mesh_sphere__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; int arg2 ; ofPrimitiveMode arg3 ; - ofMesh result; SWIG_check_num_args("ofMesh::sphere",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh::sphere",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::sphere",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh::sphere",3,"ofPrimitiveMode"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (int)lua_tonumber(L, 2); arg3 = (ofPrimitiveMode)(int)lua_tonumber(L, 3); result = ofMesh::sphere(arg1,arg2,arg3); { - ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_sphere__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; int arg2 ; ofMesh result; - SWIG_check_num_args("ofMesh::sphere",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh::sphere",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::sphere",2,"int"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (int)lua_tonumber(L, 2); result = ofMesh::sphere(arg1,arg2); { - ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_sphere__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; ofMesh result; - SWIG_check_num_args("ofMesh::sphere",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh::sphere",1,"float"); - arg1 = (float)lua_tonumber(L, 1); result = ofMesh::sphere(arg1); { ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_sphere(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_Mesh_sphere__SWIG_2(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Mesh_sphere__SWIG_1(L);} } } if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Mesh_sphere__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_sphere'\n" " Possible C/C++ prototypes are:\n" - " ofMesh::sphere(float,int,ofPrimitiveMode)\n" " ofMesh::sphere(float,int)\n" " ofMesh::sphere(float)\n"); - lua_error(L);return 0; } -static int _wrap_Mesh_icosahedron(lua_State* L) { int SWIG_arg = 0; float arg1 ; ofMesh result; - SWIG_check_num_args("ofMesh::icosahedron",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh::icosahedron",1,"float"); - arg1 = (float)lua_tonumber(L, 1); result = ofMesh::icosahedron(arg1); { - ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_icosphere__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; std::size_t arg2 ; ofMesh result; - SWIG_check_num_args("ofMesh::icosphere",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh::icosphere",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::icosphere",2,"std::size_t"); arg1 = (float)lua_tonumber(L, 1); - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (std::size_t)lua_tonumber(L, 2); - result = ofMesh::icosphere(arg1,arg2); { ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_icosphere__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; ofMesh result; - SWIG_check_num_args("ofMesh::icosphere",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh::icosphere",1,"float"); - arg1 = (float)lua_tonumber(L, 1); result = ofMesh::icosphere(arg1); { - ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_icosphere(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; - { _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_Mesh_icosphere__SWIG_1(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Mesh_icosphere__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_icosphere'\n" " Possible C/C++ prototypes are:\n" - " ofMesh::icosphere(float,std::size_t)\n" " ofMesh::icosphere(float)\n"); lua_error(L);return 0; } -static int _wrap_Mesh_cylinder__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; int arg3 ; int arg4 ; - int arg5 ; bool arg6 ; ofPrimitiveMode arg7 ; ofMesh result; SWIG_check_num_args("ofMesh::cylinder",7,7) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh::cylinder",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::cylinder",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh::cylinder",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMesh::cylinder",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMesh::cylinder",5,"int"); - if(!lua_isboolean(L,6)) SWIG_fail_arg("ofMesh::cylinder",6,"bool"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofMesh::cylinder",7,"ofPrimitiveMode"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - arg5 = (int)lua_tonumber(L, 5); arg6 = (lua_toboolean(L, 6)!=0); arg7 = (ofPrimitiveMode)(int)lua_tonumber(L, 7); - result = ofMesh::cylinder(arg1,arg2,arg3,arg4,arg5,arg6,arg7); { ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_cylinder__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; int arg3 ; int arg4 ; - int arg5 ; bool arg6 ; ofMesh result; SWIG_check_num_args("ofMesh::cylinder",6,6) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh::cylinder",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::cylinder",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh::cylinder",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMesh::cylinder",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMesh::cylinder",5,"int"); - if(!lua_isboolean(L,6)) SWIG_fail_arg("ofMesh::cylinder",6,"bool"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - arg5 = (int)lua_tonumber(L, 5); arg6 = (lua_toboolean(L, 6)!=0); result = ofMesh::cylinder(arg1,arg2,arg3,arg4,arg5,arg6); { - ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_cylinder__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; int arg3 ; int arg4 ; - int arg5 ; ofMesh result; SWIG_check_num_args("ofMesh::cylinder",5,5) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh::cylinder",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::cylinder",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh::cylinder",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMesh::cylinder",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMesh::cylinder",5,"int"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - arg5 = (int)lua_tonumber(L, 5); result = ofMesh::cylinder(arg1,arg2,arg3,arg4,arg5); { - ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_cylinder__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; int arg3 ; int arg4 ; - ofMesh result; SWIG_check_num_args("ofMesh::cylinder",4,4) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh::cylinder",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::cylinder",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh::cylinder",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMesh::cylinder",4,"int"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - result = ofMesh::cylinder(arg1,arg2,arg3,arg4); { ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_cylinder__SWIG_4(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; int arg3 ; ofMesh result; - SWIG_check_num_args("ofMesh::cylinder",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh::cylinder",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::cylinder",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh::cylinder",3,"int"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); result = ofMesh::cylinder(arg1,arg2,arg3); { - ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_cylinder__SWIG_5(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; ofMesh result; - SWIG_check_num_args("ofMesh::cylinder",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh::cylinder",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::cylinder",2,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); result = ofMesh::cylinder(arg1,arg2); { - ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_cylinder(lua_State* L) { int argc; int argv[8]={ 1,2,3,4,5,6,7,8} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Mesh_cylinder__SWIG_5(L);} } } if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Mesh_cylinder__SWIG_4(L);} } } } if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Mesh_cylinder__SWIG_3(L);} } } } } if (argc == 5) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_Mesh_cylinder__SWIG_2(L);} } } } } } - if (argc == 6) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isboolean(L,argv[5]); } if (_v) { - return _wrap_Mesh_cylinder__SWIG_1(L);} } } } } } } if (argc == 7) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isboolean(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { - return _wrap_Mesh_cylinder__SWIG_0(L);} } } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_cylinder'\n" " Possible C/C++ prototypes are:\n" - " ofMesh::cylinder(float,float,int,int,int,bool,ofPrimitiveMode)\n" " ofMesh::cylinder(float,float,int,int,int,bool)\n" - " ofMesh::cylinder(float,float,int,int,int)\n" " ofMesh::cylinder(float,float,int,int)\n" - " ofMesh::cylinder(float,float,int)\n" " ofMesh::cylinder(float,float)\n"); lua_error(L);return 0; } -static int _wrap_Mesh_cone__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; int arg3 ; int arg4 ; int arg5 ; - ofPrimitiveMode arg6 ; ofMesh result; SWIG_check_num_args("ofMesh::cone",6,6) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh::cone",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::cone",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh::cone",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMesh::cone",4,"int"); if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMesh::cone",5,"int"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofMesh::cone",6,"ofPrimitiveMode"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - arg5 = (int)lua_tonumber(L, 5); arg6 = (ofPrimitiveMode)(int)lua_tonumber(L, 6); - result = ofMesh::cone(arg1,arg2,arg3,arg4,arg5,arg6); { ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_cone__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; int arg3 ; int arg4 ; int arg5 ; - ofMesh result; SWIG_check_num_args("ofMesh::cone",5,5) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh::cone",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::cone",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh::cone",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMesh::cone",4,"int"); if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMesh::cone",5,"int"); - arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); result = ofMesh::cone(arg1,arg2,arg3,arg4,arg5); { - ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_cone__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; int arg3 ; int arg4 ; - ofMesh result; SWIG_check_num_args("ofMesh::cone",4,4) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh::cone",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::cone",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh::cone",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMesh::cone",4,"int"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - result = ofMesh::cone(arg1,arg2,arg3,arg4); { ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_cone__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; int arg3 ; ofMesh result; - SWIG_check_num_args("ofMesh::cone",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh::cone",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::cone",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh::cone",3,"int"); - arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); - result = ofMesh::cone(arg1,arg2,arg3); { ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_cone__SWIG_4(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; ofMesh result; - SWIG_check_num_args("ofMesh::cone",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh::cone",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::cone",2,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); result = ofMesh::cone(arg1,arg2); { - ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_cone(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Mesh_cone__SWIG_4(L);} } } if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Mesh_cone__SWIG_3(L);} } } } if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Mesh_cone__SWIG_2(L);} } } } } if (argc == 5) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Mesh_cone__SWIG_1(L);} } } } } } if (argc == 6) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { return _wrap_Mesh_cone__SWIG_0(L);} } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_cone'\n" " Possible C/C++ prototypes are:\n" - " ofMesh::cone(float,float,int,int,int,ofPrimitiveMode)\n" " ofMesh::cone(float,float,int,int,int)\n" - " ofMesh::cone(float,float,int,int)\n" " ofMesh::cone(float,float,int)\n" " ofMesh::cone(float,float)\n"); - lua_error(L);return 0; } -static int _wrap_Mesh_box__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; int arg4 ; int arg5 ; - int arg6 ; ofMesh result; SWIG_check_num_args("ofMesh::box",6,6) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh::box",1,"float"); if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::box",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh::box",3,"float"); if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMesh::box",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMesh::box",5,"int"); if(!lua_isnumber(L,6)) SWIG_fail_arg("ofMesh::box",6,"int"); - arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); arg6 = (int)lua_tonumber(L, 6); - result = ofMesh::box(arg1,arg2,arg3,arg4,arg5,arg6); { ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_box__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; int arg4 ; int arg5 ; - ofMesh result; SWIG_check_num_args("ofMesh::box",5,5) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh::box",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::box",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh::box",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMesh::box",4,"int"); if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMesh::box",5,"int"); - arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); result = ofMesh::box(arg1,arg2,arg3,arg4,arg5); { - ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_box__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; int arg4 ; - ofMesh result; SWIG_check_num_args("ofMesh::box",4,4) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh::box",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::box",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh::box",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMesh::box",4,"int"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - result = ofMesh::box(arg1,arg2,arg3,arg4); { ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_box__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; ofMesh result; - SWIG_check_num_args("ofMesh::box",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh::box",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::box",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh::box",3,"float"); - arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - result = ofMesh::box(arg1,arg2,arg3); { ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_box(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Mesh_box__SWIG_3(L);} } } } if (argc == 4) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Mesh_box__SWIG_2(L);} } } } } if (argc == 5) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_Mesh_box__SWIG_1(L);} } } } } } if (argc == 6) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { - return _wrap_Mesh_box__SWIG_0(L);} } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_box'\n" " Possible C/C++ prototypes are:\n" - " ofMesh::box(float,float,float,int,int,int)\n" " ofMesh::box(float,float,float,int,int)\n" - " ofMesh::box(float,float,float,int)\n" " ofMesh::box(float,float,float)\n"); lua_error(L);return 0; } -static int _wrap_Mesh_axis__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; ofMesh result; - SWIG_check_num_args("ofMesh::axis",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh::axis",1,"float"); - arg1 = (float)lua_tonumber(L, 1); result = ofMesh::axis(arg1); { ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_axis__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMesh result; SWIG_check_num_args("ofMesh::axis",0,0) - result = ofMesh::axis(); { ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_axis(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_Mesh_axis__SWIG_1(L);} if (argc == 1) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { - return _wrap_Mesh_axis__SWIG_0(L);} } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_axis'\n" - " Possible C/C++ prototypes are:\n" " ofMesh::axis(float)\n" " ofMesh::axis()\n"); lua_error(L);return 0; } -static int _wrap_Mesh_addVertex(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; ofVec3f *arg2 = 0 ; - SWIG_check_num_args("ofMesh::addVertex",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::addVertex",1,"ofMesh *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMesh::addVertex",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Mesh_addVertex",1,SWIGTYPE_p_ofMesh); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Mesh_addVertex",2,SWIGTYPE_p_ofVec3f); } (arg1)->addVertex((ofVec3f const &)*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_addVertices__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - std::vector< ofVec3f > *arg2 = 0 ; SWIG_check_num_args("ofMesh::addVertices",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::addVertices",1,"ofMesh *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMesh::addVertices",2,"std::vector< ofVec3f > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_addVertices",1,SWIGTYPE_p_ofMesh); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__vectorT_ofVec3f_t,0))){ - SWIG_fail_ptr("Mesh_addVertices",2,SWIGTYPE_p_std__vectorT_ofVec3f_t); } - (arg1)->addVertices((std::vector< ofVec3f > const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Mesh_addVertices__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - ofVec3f *arg2 = (ofVec3f *) 0 ; std::size_t arg3 ; SWIG_check_num_args("ofMesh::addVertices",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::addVertices",1,"ofMesh *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofMesh::addVertices",2,"ofVec3f const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh::addVertices",3,"std::size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_addVertices",1,SWIGTYPE_p_ofMesh); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Mesh_addVertices",2,SWIGTYPE_p_ofVec3f); } - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (std::size_t)lua_tonumber(L, 3); - (arg1)->addVertices((ofVec3f const *)arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_addVertices(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_std__vectorT_ofVec3f_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Mesh_addVertices__SWIG_0(L);} } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Mesh_addVertices__SWIG_1(L);} - } } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_addVertices'\n" - " Possible C/C++ prototypes are:\n" " ofMesh::addVertices(std::vector< ofVec3f > const &)\n" - " ofMesh::addVertices(ofVec3f const *,std::size_t)\n"); lua_error(L);return 0; } -static int _wrap_Mesh_removeVertex(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; ofIndexType arg2 ; - SWIG_check_num_args("ofMesh::removeVertex",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::removeVertex",1,"ofMesh *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::removeVertex",2,"ofIndexType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_removeVertex",1,SWIGTYPE_p_ofMesh); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); - (arg1)->removeVertex(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_setVertex(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; ofIndexType arg2 ; - ofVec3f *arg3 = 0 ; SWIG_check_num_args("ofMesh::setVertex",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::setVertex",1,"ofMesh *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::setVertex",2,"ofIndexType"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofMesh::setVertex",3,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Mesh_setVertex",1,SWIGTYPE_p_ofMesh); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Mesh_setVertex",3,SWIGTYPE_p_ofVec3f); } (arg1)->setVertex(arg2,(ofVec3f const &)*arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_clearVertices(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - SWIG_check_num_args("ofMesh::clearVertices",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::clearVertices",1,"ofMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_clearVertices",1,SWIGTYPE_p_ofMesh); } (arg1)->clearVertices(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_clear(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - SWIG_check_num_args("ofMesh::clear",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::clear",1,"ofMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Mesh_clear",1,SWIGTYPE_p_ofMesh); } - (arg1)->clear(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getNumVertices(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; std::size_t result; - SWIG_check_num_args("ofMesh::getNumVertices",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getNumVertices",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_getNumVertices",1,SWIGTYPE_p_ofMesh); } result = (std::size_t)((ofMesh const *)arg1)->getNumVertices(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getVerticesPointer__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - ofVec3f *result = 0 ; SWIG_check_num_args("ofMesh::getVerticesPointer",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getVerticesPointer",1,"ofMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_getVerticesPointer",1,SWIGTYPE_p_ofMesh); } result = (ofVec3f *)(arg1)->getVerticesPointer(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Mesh_getVerticesPointer__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - ofVec3f *result = 0 ; SWIG_check_num_args("ofMesh::getVerticesPointer",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getVerticesPointer",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_getVerticesPointer",1,SWIGTYPE_p_ofMesh); } - result = (ofVec3f *)((ofMesh const *)arg1)->getVerticesPointer(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Mesh_getVerticesPointer(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Mesh_getVerticesPointer__SWIG_0(L);} } if (argc == 1) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Mesh_getVerticesPointer__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_getVerticesPointer'\n" - " Possible C/C++ prototypes are:\n" " ofMesh::getVerticesPointer()\n" " ofMesh::getVerticesPointer() const\n"); - lua_error(L);return 0; } -static int _wrap_Mesh_getVertex(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; ofIndexType arg2 ; - ofVec3f result; SWIG_check_num_args("ofMesh::getVertex",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getVertex",1,"ofMesh const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::getVertex",2,"ofIndexType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Mesh_getVertex",1,SWIGTYPE_p_ofMesh); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); - result = ((ofMesh const *)arg1)->getVertex(arg2); { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getVertices__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - std::vector< ofVec3f > *result = 0 ; SWIG_check_num_args("ofMesh::getVertices",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getVertices",1,"ofMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_getVertices",1,SWIGTYPE_p_ofMesh); } result = (std::vector< ofVec3f > *) &(arg1)->getVertices(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofVec3f_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getVertices__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - std::vector< ofVec3f > *result = 0 ; SWIG_check_num_args("ofMesh::getVertices",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getVertices",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_getVertices",1,SWIGTYPE_p_ofMesh); } - result = (std::vector< ofVec3f > *) &((ofMesh const *)arg1)->getVertices(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofVec3f_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getVertices(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Mesh_getVertices__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Mesh_getVertices__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_getVertices'\n" " Possible C/C++ prototypes are:\n" - " ofMesh::getVertices()\n" " ofMesh::getVertices() const\n"); lua_error(L);return 0; } -static int _wrap_Mesh_haveVertsChanged(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; bool result; - SWIG_check_num_args("ofMesh::haveVertsChanged",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::haveVertsChanged",1,"ofMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_haveVertsChanged",1,SWIGTYPE_p_ofMesh); } result = (bool)(arg1)->haveVertsChanged(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_hasVertices(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; bool result; - SWIG_check_num_args("ofMesh::hasVertices",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::hasVertices",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_hasVertices",1,SWIGTYPE_p_ofMesh); } result = (bool)((ofMesh const *)arg1)->hasVertices(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_append(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; ofMesh *arg2 = 0 ; - SWIG_check_num_args("ofMesh::append",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::append",1,"ofMesh *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMesh::append",2,"ofMesh const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Mesh_append",1,SWIGTYPE_p_ofMesh); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Mesh_append",2,SWIGTYPE_p_ofMesh); } - (arg1)->append((ofMesh const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_mergeDuplicateVertices(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - SWIG_check_num_args("ofMesh::mergeDuplicateVertices",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::mergeDuplicateVertices",1,"ofMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_mergeDuplicateVertices",1,SWIGTYPE_p_ofMesh); } (arg1)->mergeDuplicateVertices(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getCentroid(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; ofVec3f result; - SWIG_check_num_args("ofMesh::getCentroid",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getCentroid",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_getCentroid",1,SWIGTYPE_p_ofMesh); } result = ((ofMesh const *)arg1)->getCentroid(); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getNormal(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; ofIndexType arg2 ; - ofVec3f result; SWIG_check_num_args("ofMesh::getNormal",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getNormal",1,"ofMesh const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::getNormal",2,"ofIndexType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Mesh_getNormal",1,SWIGTYPE_p_ofMesh); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); - result = ((ofMesh const *)arg1)->getNormal(arg2); { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_addNormal(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; ofVec3f *arg2 = 0 ; - SWIG_check_num_args("ofMesh::addNormal",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::addNormal",1,"ofMesh *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMesh::addNormal",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Mesh_addNormal",1,SWIGTYPE_p_ofMesh); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Mesh_addNormal",2,SWIGTYPE_p_ofVec3f); } (arg1)->addNormal((ofVec3f const &)*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_addNormals__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - std::vector< ofVec3f > *arg2 = 0 ; SWIG_check_num_args("ofMesh::addNormals",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::addNormals",1,"ofMesh *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMesh::addNormals",2,"std::vector< ofVec3f > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_addNormals",1,SWIGTYPE_p_ofMesh); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__vectorT_ofVec3f_t,0))){ - SWIG_fail_ptr("Mesh_addNormals",2,SWIGTYPE_p_std__vectorT_ofVec3f_t); } - (arg1)->addNormals((std::vector< ofVec3f > const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Mesh_addNormals__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - ofVec3f *arg2 = (ofVec3f *) 0 ; std::size_t arg3 ; SWIG_check_num_args("ofMesh::addNormals",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::addNormals",1,"ofMesh *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofMesh::addNormals",2,"ofVec3f const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh::addNormals",3,"std::size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_addNormals",1,SWIGTYPE_p_ofMesh); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Mesh_addNormals",2,SWIGTYPE_p_ofVec3f); } - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (std::size_t)lua_tonumber(L, 3); - (arg1)->addNormals((ofVec3f const *)arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_addNormals(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_std__vectorT_ofVec3f_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Mesh_addNormals__SWIG_0(L);} } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Mesh_addNormals__SWIG_1(L);} } - } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_addNormals'\n" - " Possible C/C++ prototypes are:\n" " ofMesh::addNormals(std::vector< ofVec3f > const &)\n" - " ofMesh::addNormals(ofVec3f const *,std::size_t)\n"); lua_error(L);return 0; } -static int _wrap_Mesh_removeNormal(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; ofIndexType arg2 ; - SWIG_check_num_args("ofMesh::removeNormal",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::removeNormal",1,"ofMesh *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::removeNormal",2,"ofIndexType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_removeNormal",1,SWIGTYPE_p_ofMesh); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); - (arg1)->removeNormal(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_setNormal(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; ofIndexType arg2 ; - ofVec3f *arg3 = 0 ; SWIG_check_num_args("ofMesh::setNormal",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::setNormal",1,"ofMesh *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::setNormal",2,"ofIndexType"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofMesh::setNormal",3,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Mesh_setNormal",1,SWIGTYPE_p_ofMesh); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Mesh_setNormal",3,SWIGTYPE_p_ofVec3f); } (arg1)->setNormal(arg2,(ofVec3f const &)*arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_clearNormals(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - SWIG_check_num_args("ofMesh::clearNormals",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::clearNormals",1,"ofMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_clearNormals",1,SWIGTYPE_p_ofMesh); } (arg1)->clearNormals(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getNumNormals(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; std::size_t result; - SWIG_check_num_args("ofMesh::getNumNormals",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getNumNormals",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_getNumNormals",1,SWIGTYPE_p_ofMesh); } result = (std::size_t)((ofMesh const *)arg1)->getNumNormals(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getNormalsPointer__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - ofVec3f *result = 0 ; SWIG_check_num_args("ofMesh::getNormalsPointer",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getNormalsPointer",1,"ofMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_getNormalsPointer",1,SWIGTYPE_p_ofMesh); } result = (ofVec3f *)(arg1)->getNormalsPointer(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Mesh_getNormalsPointer__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - ofVec3f *result = 0 ; SWIG_check_num_args("ofMesh::getNormalsPointer",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getNormalsPointer",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_getNormalsPointer",1,SWIGTYPE_p_ofMesh); } - result = (ofVec3f *)((ofMesh const *)arg1)->getNormalsPointer(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Mesh_getNormalsPointer(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Mesh_getNormalsPointer__SWIG_0(L);} } if (argc == 1) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Mesh_getNormalsPointer__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_getNormalsPointer'\n" - " Possible C/C++ prototypes are:\n" " ofMesh::getNormalsPointer()\n" " ofMesh::getNormalsPointer() const\n"); - lua_error(L);return 0; } -static int _wrap_Mesh_getNormals__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - std::vector< ofVec3f > *result = 0 ; SWIG_check_num_args("ofMesh::getNormals",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getNormals",1,"ofMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_getNormals",1,SWIGTYPE_p_ofMesh); } result = (std::vector< ofVec3f > *) &(arg1)->getNormals(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofVec3f_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getNormals__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - std::vector< ofVec3f > *result = 0 ; SWIG_check_num_args("ofMesh::getNormals",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getNormals",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_getNormals",1,SWIGTYPE_p_ofMesh); } - result = (std::vector< ofVec3f > *) &((ofMesh const *)arg1)->getNormals(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofVec3f_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getNormals(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Mesh_getNormals__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Mesh_getNormals__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_getNormals'\n" " Possible C/C++ prototypes are:\n" - " ofMesh::getNormals()\n" " ofMesh::getNormals() const\n"); lua_error(L);return 0; } -static int _wrap_Mesh_haveNormalsChanged(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; bool result; - SWIG_check_num_args("ofMesh::haveNormalsChanged",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::haveNormalsChanged",1,"ofMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_haveNormalsChanged",1,SWIGTYPE_p_ofMesh); } result = (bool)(arg1)->haveNormalsChanged(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_hasNormals(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; bool result; - SWIG_check_num_args("ofMesh::hasNormals",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::hasNormals",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_hasNormals",1,SWIGTYPE_p_ofMesh); } result = (bool)((ofMesh const *)arg1)->hasNormals(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_enableNormals(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - SWIG_check_num_args("ofMesh::enableNormals",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::enableNormals",1,"ofMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_enableNormals",1,SWIGTYPE_p_ofMesh); } (arg1)->enableNormals(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_disableNormals(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - SWIG_check_num_args("ofMesh::disableNormals",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::disableNormals",1,"ofMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_disableNormals",1,SWIGTYPE_p_ofMesh); } (arg1)->disableNormals(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_usingNormals(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; bool result; - SWIG_check_num_args("ofMesh::usingNormals",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::usingNormals",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_usingNormals",1,SWIGTYPE_p_ofMesh); } result = (bool)((ofMesh const *)arg1)->usingNormals(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_smoothNormals(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; float arg2 ; - SWIG_check_num_args("ofMesh::smoothNormals",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::smoothNormals",1,"ofMesh *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::smoothNormals",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_smoothNormals",1,SWIGTYPE_p_ofMesh); } arg2 = (float)lua_tonumber(L, 2); (arg1)->smoothNormals(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getFace(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; ofIndexType arg2 ; - ofMeshFace result; SWIG_check_num_args("ofMesh::getFace",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getFace",1,"ofMesh const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::getFace",2,"ofIndexType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Mesh_getFace",1,SWIGTYPE_p_ofMesh); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); - result = ((ofMesh const *)arg1)->getFace(arg2); { ofMeshFace * resultptr = new ofMeshFace((const ofMeshFace &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMeshFace,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getFaceNormals__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; bool arg2 ; - SwigValueWrapper< std::vector< ofVec3f > > result; SWIG_check_num_args("ofMesh::getFaceNormals",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getFaceNormals",1,"ofMesh const *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofMesh::getFaceNormals",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_getFaceNormals",1,SWIGTYPE_p_ofMesh); } arg2 = (lua_toboolean(L, 2)!=0); - result = ((ofMesh const *)arg1)->getFaceNormals(arg2); { - std::vector< ofVec3f > * resultptr = new std::vector< ofVec3f >((const std::vector< ofVec3f > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_ofVec3f_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getFaceNormals__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - SwigValueWrapper< std::vector< ofVec3f > > result; SWIG_check_num_args("ofMesh::getFaceNormals",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getFaceNormals",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_getFaceNormals",1,SWIGTYPE_p_ofMesh); } result = ((ofMesh const *)arg1)->getFaceNormals(); { - std::vector< ofVec3f > * resultptr = new std::vector< ofVec3f >((const std::vector< ofVec3f > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_ofVec3f_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getFaceNormals(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Mesh_getFaceNormals__SWIG_1(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_Mesh_getFaceNormals__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_getFaceNormals'\n" - " Possible C/C++ prototypes are:\n" " ofMesh::getFaceNormals(bool) const\n" " ofMesh::getFaceNormals() const\n"); - lua_error(L);return 0; } -static int _wrap_Mesh_getUniqueFaces(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - std::vector< ofMeshFace > *result = 0 ; SWIG_check_num_args("ofMesh::getUniqueFaces",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getUniqueFaces",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_getUniqueFaces",1,SWIGTYPE_p_ofMesh); } - result = (std::vector< ofMeshFace > *) &((ofMesh const *)arg1)->getUniqueFaces(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofMeshFace_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getColor(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; ofIndexType arg2 ; - ofFloatColor result; SWIG_check_num_args("ofMesh::getColor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getColor",1,"ofMesh const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::getColor",2,"ofIndexType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Mesh_getColor",1,SWIGTYPE_p_ofMesh); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); - result = ((ofMesh const *)arg1)->getColor(arg2); { ofFloatColor * resultptr = new ofFloatColor((const ofFloatColor &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_addColor(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; ofFloatColor *arg2 = 0 ; - SWIG_check_num_args("ofMesh::addColor",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::addColor",1,"ofMesh *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMesh::addColor",2,"ofFloatColor const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Mesh_addColor",1,SWIGTYPE_p_ofMesh); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("Mesh_addColor",2,SWIGTYPE_p_ofColor_T_float_t); } (arg1)->addColor((ofFloatColor const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_addColors__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - std::vector< ofFloatColor > *arg2 = 0 ; SWIG_check_num_args("ofMesh::addColors",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::addColors",1,"ofMesh *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMesh::addColors",2,"std::vector< ofFloatColor > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Mesh_addColors",1,SWIGTYPE_p_ofMesh); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__vectorT_ofColor_T_float_t_t,0))){ - SWIG_fail_ptr("Mesh_addColors",2,SWIGTYPE_p_std__vectorT_ofColor_T_float_t_t); } - (arg1)->addColors((std::vector< ofFloatColor > const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Mesh_addColors__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - ofFloatColor *arg2 = (ofFloatColor *) 0 ; std::size_t arg3 ; SWIG_check_num_args("ofMesh::addColors",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::addColors",1,"ofMesh *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofMesh::addColors",2,"ofFloatColor const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh::addColors",3,"std::size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Mesh_addColors",1,SWIGTYPE_p_ofMesh); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("Mesh_addColors",2,SWIGTYPE_p_ofColor_T_float_t); } - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (std::size_t)lua_tonumber(L, 3); - (arg1)->addColors((ofFloatColor const *)arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_addColors(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_std__vectorT_ofColor_T_float_t_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Mesh_addColors__SWIG_0(L);} } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Mesh_addColors__SWIG_1(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_addColors'\n" " Possible C/C++ prototypes are:\n" - " ofMesh::addColors(std::vector< ofFloatColor > const &)\n" " ofMesh::addColors(ofFloatColor const *,std::size_t)\n"); - lua_error(L);return 0; } -static int _wrap_Mesh_removeColor(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; ofIndexType arg2 ; - SWIG_check_num_args("ofMesh::removeColor",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::removeColor",1,"ofMesh *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::removeColor",2,"ofIndexType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_removeColor",1,SWIGTYPE_p_ofMesh); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); - (arg1)->removeColor(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_setColor(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; ofIndexType arg2 ; - ofFloatColor *arg3 = 0 ; SWIG_check_num_args("ofMesh::setColor",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::setColor",1,"ofMesh *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::setColor",2,"ofIndexType"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofMesh::setColor",3,"ofFloatColor const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Mesh_setColor",1,SWIGTYPE_p_ofMesh); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("Mesh_setColor",3,SWIGTYPE_p_ofColor_T_float_t); } (arg1)->setColor(arg2,(ofFloatColor const &)*arg3); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_clearColors(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - SWIG_check_num_args("ofMesh::clearColors",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::clearColors",1,"ofMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_clearColors",1,SWIGTYPE_p_ofMesh); } (arg1)->clearColors(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getNumColors(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; std::size_t result; - SWIG_check_num_args("ofMesh::getNumColors",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getNumColors",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_getNumColors",1,SWIGTYPE_p_ofMesh); } result = (std::size_t)((ofMesh const *)arg1)->getNumColors(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getColorsPointer__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - ofFloatColor *result = 0 ; SWIG_check_num_args("ofMesh::getColorsPointer",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getColorsPointer",1,"ofMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_getColorsPointer",1,SWIGTYPE_p_ofMesh); } result = (ofFloatColor *)(arg1)->getColorsPointer(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getColorsPointer__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - ofFloatColor *result = 0 ; SWIG_check_num_args("ofMesh::getColorsPointer",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getColorsPointer",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_getColorsPointer",1,SWIGTYPE_p_ofMesh); } - result = (ofFloatColor *)((ofMesh const *)arg1)->getColorsPointer(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getColorsPointer(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Mesh_getColorsPointer__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Mesh_getColorsPointer__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_getColorsPointer'\n" - " Possible C/C++ prototypes are:\n" " ofMesh::getColorsPointer()\n" " ofMesh::getColorsPointer() const\n"); - lua_error(L);return 0; } -static int _wrap_Mesh_getColors__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - std::vector< ofFloatColor > *result = 0 ; SWIG_check_num_args("ofMesh::getColors",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getColors",1,"ofMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Mesh_getColors",1,SWIGTYPE_p_ofMesh); } - result = (std::vector< ofFloatColor > *) &(arg1)->getColors(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofColor_T_float_t_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getColors__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - std::vector< ofFloatColor > *result = 0 ; SWIG_check_num_args("ofMesh::getColors",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getColors",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Mesh_getColors",1,SWIGTYPE_p_ofMesh); } - result = (std::vector< ofFloatColor > *) &((ofMesh const *)arg1)->getColors(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofColor_T_float_t_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getColors(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Mesh_getColors__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Mesh_getColors__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_getColors'\n" " Possible C/C++ prototypes are:\n" - " ofMesh::getColors()\n" " ofMesh::getColors() const\n"); lua_error(L);return 0; } -static int _wrap_Mesh_haveColorsChanged(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; bool result; - SWIG_check_num_args("ofMesh::haveColorsChanged",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::haveColorsChanged",1,"ofMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_haveColorsChanged",1,SWIGTYPE_p_ofMesh); } result = (bool)(arg1)->haveColorsChanged(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_hasColors(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; bool result; - SWIG_check_num_args("ofMesh::hasColors",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::hasColors",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Mesh_hasColors",1,SWIGTYPE_p_ofMesh); } - result = (bool)((ofMesh const *)arg1)->hasColors(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_enableColors(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - SWIG_check_num_args("ofMesh::enableColors",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::enableColors",1,"ofMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_enableColors",1,SWIGTYPE_p_ofMesh); } (arg1)->enableColors(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_disableColors(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - SWIG_check_num_args("ofMesh::disableColors",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::disableColors",1,"ofMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_disableColors",1,SWIGTYPE_p_ofMesh); } (arg1)->disableColors(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_usingColors(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; bool result; - SWIG_check_num_args("ofMesh::usingColors",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::usingColors",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_usingColors",1,SWIGTYPE_p_ofMesh); } result = (bool)((ofMesh const *)arg1)->usingColors(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getTexCoord(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; ofIndexType arg2 ; - ofVec2f result; SWIG_check_num_args("ofMesh::getTexCoord",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getTexCoord",1,"ofMesh const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::getTexCoord",2,"ofIndexType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_getTexCoord",1,SWIGTYPE_p_ofMesh); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); - result = ((ofMesh const *)arg1)->getTexCoord(arg2); { ofVec2f * resultptr = new ofVec2f((const ofVec2f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_addTexCoord(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; ofVec2f *arg2 = 0 ; - SWIG_check_num_args("ofMesh::addTexCoord",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::addTexCoord",1,"ofMesh *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMesh::addTexCoord",2,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_addTexCoord",1,SWIGTYPE_p_ofMesh); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Mesh_addTexCoord",2,SWIGTYPE_p_ofVec2f); } (arg1)->addTexCoord((ofVec2f const &)*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_addTexCoords__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - std::vector< ofVec2f > *arg2 = 0 ; SWIG_check_num_args("ofMesh::addTexCoords",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::addTexCoords",1,"ofMesh *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMesh::addTexCoords",2,"std::vector< ofVec2f > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_addTexCoords",1,SWIGTYPE_p_ofMesh); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__vectorT_ofVec2f_t,0))){ - SWIG_fail_ptr("Mesh_addTexCoords",2,SWIGTYPE_p_std__vectorT_ofVec2f_t); } - (arg1)->addTexCoords((std::vector< ofVec2f > const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Mesh_addTexCoords__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - ofVec2f *arg2 = (ofVec2f *) 0 ; std::size_t arg3 ; SWIG_check_num_args("ofMesh::addTexCoords",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::addTexCoords",1,"ofMesh *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofMesh::addTexCoords",2,"ofVec2f const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh::addTexCoords",3,"std::size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_addTexCoords",1,SWIGTYPE_p_ofMesh); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Mesh_addTexCoords",2,SWIGTYPE_p_ofVec2f); } - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (std::size_t)lua_tonumber(L, 3); - (arg1)->addTexCoords((ofVec2f const *)arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_addTexCoords(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_std__vectorT_ofVec2f_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Mesh_addTexCoords__SWIG_0(L);} } } if (argc == 3) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Mesh_addTexCoords__SWIG_1(L);} - } } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_addTexCoords'\n" - " Possible C/C++ prototypes are:\n" " ofMesh::addTexCoords(std::vector< ofVec2f > const &)\n" - " ofMesh::addTexCoords(ofVec2f const *,std::size_t)\n"); lua_error(L);return 0; } -static int _wrap_Mesh_removeTexCoord(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; ofIndexType arg2 ; - SWIG_check_num_args("ofMesh::removeTexCoord",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::removeTexCoord",1,"ofMesh *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::removeTexCoord",2,"ofIndexType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_removeTexCoord",1,SWIGTYPE_p_ofMesh); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); - (arg1)->removeTexCoord(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_setTexCoord(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; ofIndexType arg2 ; - ofVec2f *arg3 = 0 ; SWIG_check_num_args("ofMesh::setTexCoord",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::setTexCoord",1,"ofMesh *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::setTexCoord",2,"ofIndexType"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofMesh::setTexCoord",3,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_setTexCoord",1,SWIGTYPE_p_ofMesh); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Mesh_setTexCoord",3,SWIGTYPE_p_ofVec2f); } (arg1)->setTexCoord(arg2,(ofVec2f const &)*arg3); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_clearTexCoords(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - SWIG_check_num_args("ofMesh::clearTexCoords",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::clearTexCoords",1,"ofMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_clearTexCoords",1,SWIGTYPE_p_ofMesh); } (arg1)->clearTexCoords(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getNumTexCoords(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; std::size_t result; - SWIG_check_num_args("ofMesh::getNumTexCoords",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getNumTexCoords",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_getNumTexCoords",1,SWIGTYPE_p_ofMesh); } - result = (std::size_t)((ofMesh const *)arg1)->getNumTexCoords(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getTexCoordsPointer__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - ofVec2f *result = 0 ; SWIG_check_num_args("ofMesh::getTexCoordsPointer",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getTexCoordsPointer",1,"ofMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_getTexCoordsPointer",1,SWIGTYPE_p_ofMesh); } result = (ofVec2f *)(arg1)->getTexCoordsPointer(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec2f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Mesh_getTexCoordsPointer__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - ofVec2f *result = 0 ; SWIG_check_num_args("ofMesh::getTexCoordsPointer",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getTexCoordsPointer",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_getTexCoordsPointer",1,SWIGTYPE_p_ofMesh); } - result = (ofVec2f *)((ofMesh const *)arg1)->getTexCoordsPointer(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec2f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Mesh_getTexCoordsPointer(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Mesh_getTexCoordsPointer__SWIG_0(L);} } if (argc == 1) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Mesh_getTexCoordsPointer__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_getTexCoordsPointer'\n" - " Possible C/C++ prototypes are:\n" " ofMesh::getTexCoordsPointer()\n" " ofMesh::getTexCoordsPointer() const\n"); - lua_error(L);return 0; } -static int _wrap_Mesh_getTexCoords__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - std::vector< ofVec2f > *result = 0 ; SWIG_check_num_args("ofMesh::getTexCoords",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getTexCoords",1,"ofMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_getTexCoords",1,SWIGTYPE_p_ofMesh); } result = (std::vector< ofVec2f > *) &(arg1)->getTexCoords(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofVec2f_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getTexCoords__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - std::vector< ofVec2f > *result = 0 ; SWIG_check_num_args("ofMesh::getTexCoords",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getTexCoords",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_getTexCoords",1,SWIGTYPE_p_ofMesh); } - result = (std::vector< ofVec2f > *) &((ofMesh const *)arg1)->getTexCoords(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofVec2f_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getTexCoords(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Mesh_getTexCoords__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Mesh_getTexCoords__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_getTexCoords'\n" " Possible C/C++ prototypes are:\n" - " ofMesh::getTexCoords()\n" " ofMesh::getTexCoords() const\n"); lua_error(L);return 0; } -static int _wrap_Mesh_haveTexCoordsChanged(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; bool result; - SWIG_check_num_args("ofMesh::haveTexCoordsChanged",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::haveTexCoordsChanged",1,"ofMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_haveTexCoordsChanged",1,SWIGTYPE_p_ofMesh); } result = (bool)(arg1)->haveTexCoordsChanged(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_hasTexCoords(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; bool result; - SWIG_check_num_args("ofMesh::hasTexCoords",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::hasTexCoords",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_hasTexCoords",1,SWIGTYPE_p_ofMesh); } result = (bool)((ofMesh const *)arg1)->hasTexCoords(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_enableTextures(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - SWIG_check_num_args("ofMesh::enableTextures",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::enableTextures",1,"ofMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_enableTextures",1,SWIGTYPE_p_ofMesh); } (arg1)->enableTextures(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_disableTextures(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - SWIG_check_num_args("ofMesh::disableTextures",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::disableTextures",1,"ofMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_disableTextures",1,SWIGTYPE_p_ofMesh); } (arg1)->disableTextures(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_usingTextures(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; bool result; - SWIG_check_num_args("ofMesh::usingTextures",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::usingTextures",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_usingTextures",1,SWIGTYPE_p_ofMesh); } result = (bool)((ofMesh const *)arg1)->usingTextures(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_setupIndicesAuto(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - SWIG_check_num_args("ofMesh::setupIndicesAuto",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::setupIndicesAuto",1,"ofMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_setupIndicesAuto",1,SWIGTYPE_p_ofMesh); } (arg1)->setupIndicesAuto(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getIndices__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - std::vector< ofIndexType > *result = 0 ; SWIG_check_num_args("ofMesh::getIndices",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getIndices",1,"ofMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_getIndices",1,SWIGTYPE_p_ofMesh); } result = (std::vector< ofIndexType > *) &(arg1)->getIndices(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getIndex(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; ofIndexType arg2 ; - ofIndexType result; SWIG_check_num_args("ofMesh::getIndex",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getIndex",1,"ofMesh const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::getIndex",2,"ofIndexType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Mesh_getIndex",1,SWIGTYPE_p_ofMesh); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); - result = (ofIndexType)((ofMesh const *)arg1)->getIndex(arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_addIndex(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; ofIndexType arg2 ; - SWIG_check_num_args("ofMesh::addIndex",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::addIndex",1,"ofMesh *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::addIndex",2,"ofIndexType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Mesh_addIndex",1,SWIGTYPE_p_ofMesh); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); - (arg1)->addIndex(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_addIndices__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - std::vector< ofIndexType > *arg2 = 0 ; SWIG_check_num_args("ofMesh::addIndices",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::addIndices",1,"ofMesh *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMesh::addIndices",2,"std::vector< ofIndexType > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_addIndices",1,SWIGTYPE_p_ofMesh); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__vectorT_unsigned_short_t,0))){ - SWIG_fail_ptr("Mesh_addIndices",2,SWIGTYPE_p_std__vectorT_unsigned_short_t); } - (arg1)->addIndices((std::vector< ofIndexType > const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Mesh_addIndices__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - ofIndexType *arg2 = (ofIndexType *) 0 ; std::size_t arg3 ; SWIG_check_num_args("ofMesh::addIndices",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::addIndices",1,"ofMesh *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofMesh::addIndices",2,"ofIndexType const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh::addIndices",3,"std::size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_addIndices",1,SWIGTYPE_p_ofMesh); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_unsigned_short,0))){ - SWIG_fail_ptr("Mesh_addIndices",2,SWIGTYPE_p_unsigned_short); } - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (std::size_t)lua_tonumber(L, 3); - (arg1)->addIndices((ofIndexType const *)arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_addIndices(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_std__vectorT_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Mesh_addIndices__SWIG_0(L);} } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_unsigned_short, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Mesh_addIndices__SWIG_1(L);} } - } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_addIndices'\n" - " Possible C/C++ prototypes are:\n" " ofMesh::addIndices(std::vector< ofIndexType > const &)\n" - " ofMesh::addIndices(ofIndexType const *,std::size_t)\n"); lua_error(L);return 0; } -static int _wrap_Mesh_removeIndex(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; ofIndexType arg2 ; - SWIG_check_num_args("ofMesh::removeIndex",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::removeIndex",1,"ofMesh *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::removeIndex",2,"ofIndexType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_removeIndex",1,SWIGTYPE_p_ofMesh); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); - (arg1)->removeIndex(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_setIndex(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; ofIndexType arg2 ; - ofIndexType arg3 ; SWIG_check_num_args("ofMesh::setIndex",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::setIndex",1,"ofMesh *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::setIndex",2,"ofIndexType"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh::setIndex",3,"ofIndexType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Mesh_setIndex",1,SWIGTYPE_p_ofMesh); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (ofIndexType)lua_tonumber(L, 3); - (arg1)->setIndex(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_clearIndices(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - SWIG_check_num_args("ofMesh::clearIndices",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::clearIndices",1,"ofMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_clearIndices",1,SWIGTYPE_p_ofMesh); } (arg1)->clearIndices(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getNumIndices(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; std::size_t result; - SWIG_check_num_args("ofMesh::getNumIndices",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getNumIndices",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_getNumIndices",1,SWIGTYPE_p_ofMesh); } result = (std::size_t)((ofMesh const *)arg1)->getNumIndices(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getIndexPointer__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - ofIndexType *result = 0 ; SWIG_check_num_args("ofMesh::getIndexPointer",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getIndexPointer",1,"ofMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_getIndexPointer",1,SWIGTYPE_p_ofMesh); } result = (ofIndexType *)(arg1)->getIndexPointer(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_unsigned_short,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Mesh_getIndexPointer__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - ofIndexType *result = 0 ; SWIG_check_num_args("ofMesh::getIndexPointer",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getIndexPointer",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_getIndexPointer",1,SWIGTYPE_p_ofMesh); } - result = (ofIndexType *)((ofMesh const *)arg1)->getIndexPointer(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_unsigned_short,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Mesh_getIndexPointer(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Mesh_getIndexPointer__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Mesh_getIndexPointer__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_getIndexPointer'\n" - " Possible C/C++ prototypes are:\n" " ofMesh::getIndexPointer()\n" " ofMesh::getIndexPointer() const\n"); - lua_error(L);return 0; } -static int _wrap_Mesh_getIndices__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - std::vector< ofIndexType > *result = 0 ; SWIG_check_num_args("ofMesh::getIndices",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getIndices",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_getIndices",1,SWIGTYPE_p_ofMesh); } - result = (std::vector< ofIndexType > *) &((ofMesh const *)arg1)->getIndices(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getIndices(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Mesh_getIndices__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Mesh_getIndices__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_getIndices'\n" " Possible C/C++ prototypes are:\n" - " ofMesh::getIndices()\n" " ofMesh::getIndices() const\n"); lua_error(L);return 0; } -static int _wrap_Mesh_haveIndicesChanged(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; bool result; - SWIG_check_num_args("ofMesh::haveIndicesChanged",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::haveIndicesChanged",1,"ofMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_haveIndicesChanged",1,SWIGTYPE_p_ofMesh); } result = (bool)(arg1)->haveIndicesChanged(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_hasIndices(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; bool result; - SWIG_check_num_args("ofMesh::hasIndices",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::hasIndices",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_hasIndices",1,SWIGTYPE_p_ofMesh); } result = (bool)((ofMesh const *)arg1)->hasIndices(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_addTriangle(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; ofIndexType arg2 ; - ofIndexType arg3 ; ofIndexType arg4 ; SWIG_check_num_args("ofMesh::addTriangle",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::addTriangle",1,"ofMesh *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::addTriangle",2,"ofIndexType"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh::addTriangle",3,"ofIndexType"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMesh::addTriangle",4,"ofIndexType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_addTriangle",1,SWIGTYPE_p_ofMesh); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (ofIndexType)lua_tonumber(L, 3); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (ofIndexType)lua_tonumber(L, 4); - (arg1)->addTriangle(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_enableIndices(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - SWIG_check_num_args("ofMesh::enableIndices",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::enableIndices",1,"ofMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_enableIndices",1,SWIGTYPE_p_ofMesh); } (arg1)->enableIndices(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_disableIndices(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - SWIG_check_num_args("ofMesh::disableIndices",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::disableIndices",1,"ofMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_disableIndices",1,SWIGTYPE_p_ofMesh); } (arg1)->disableIndices(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_usingIndices(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; bool result; - SWIG_check_num_args("ofMesh::usingIndices",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::usingIndices",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_usingIndices",1,SWIGTYPE_p_ofMesh); } result = (bool)((ofMesh const *)arg1)->usingIndices(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_setColorForIndices(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; ofIndexType arg2 ; - ofIndexType arg3 ; ofColor arg4 ; ofColor *argp4 ; SWIG_check_num_args("ofMesh::setColorForIndices",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::setColorForIndices",1,"ofMesh *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::setColorForIndices",2,"ofIndexType"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh::setColorForIndices",3,"ofIndexType"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofMesh::setColorForIndices",4,"ofColor"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_setColorForIndices",1,SWIGTYPE_p_ofMesh); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (ofIndexType)lua_tonumber(L, 3); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&argp4,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Mesh_setColorForIndices",4,SWIGTYPE_p_ofColor_T_unsigned_char_t); } arg4 = *argp4; - (arg1)->setColorForIndices(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getMeshForIndices__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - ofIndexType arg2 ; ofIndexType arg3 ; ofMesh result; SWIG_check_num_args("ofMesh::getMeshForIndices",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getMeshForIndices",1,"ofMesh const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::getMeshForIndices",2,"ofIndexType"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh::getMeshForIndices",3,"ofIndexType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_getMeshForIndices",1,SWIGTYPE_p_ofMesh); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (ofIndexType)lua_tonumber(L, 3); - result = ((ofMesh const *)arg1)->getMeshForIndices(arg2,arg3); { ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getMeshForIndices__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - ofIndexType arg2 ; ofIndexType arg3 ; ofIndexType arg4 ; ofIndexType arg5 ; ofMesh result; - SWIG_check_num_args("ofMesh::getMeshForIndices",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getMeshForIndices",1,"ofMesh const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::getMeshForIndices",2,"ofIndexType"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh::getMeshForIndices",3,"ofIndexType"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMesh::getMeshForIndices",4,"ofIndexType"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMesh::getMeshForIndices",5,"ofIndexType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_getMeshForIndices",1,SWIGTYPE_p_ofMesh); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (ofIndexType)lua_tonumber(L, 3); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (ofIndexType)lua_tonumber(L, 4); - SWIG_contract_assert((lua_tonumber(L,5)>=0),"number must not be negative") arg5 = (ofIndexType)lua_tonumber(L, 5); - result = ((ofMesh const *)arg1)->getMeshForIndices(arg2,arg3,arg4,arg5); { - ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getMeshForIndices(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Mesh_getMeshForIndices__SWIG_0(L);} } } } if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Mesh_getMeshForIndices__SWIG_1(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_getMeshForIndices'\n" - " Possible C/C++ prototypes are:\n" " ofMesh::getMeshForIndices(ofIndexType,ofIndexType) const\n" - " ofMesh::getMeshForIndices(ofIndexType,ofIndexType,ofIndexType,ofIndexType) const\n"); lua_error(L);return 0; } -static int _wrap_Mesh_drawVertices(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - SWIG_check_num_args("ofMesh::drawVertices",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::drawVertices",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_drawVertices",1,SWIGTYPE_p_ofMesh); } ((ofMesh const *)arg1)->drawVertices(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_drawWireframe(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - SWIG_check_num_args("ofMesh::drawWireframe",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::drawWireframe",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_drawWireframe",1,SWIGTYPE_p_ofMesh); } ((ofMesh const *)arg1)->drawWireframe(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_drawFaces(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - SWIG_check_num_args("ofMesh::drawFaces",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::drawFaces",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Mesh_drawFaces",1,SWIGTYPE_p_ofMesh); } - ((ofMesh const *)arg1)->drawFaces(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_draw__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - SWIG_check_num_args("ofMesh::draw",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::draw",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Mesh_draw",1,SWIGTYPE_p_ofMesh); } - ((ofMesh const *)arg1)->draw(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_draw__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; ofPolyRenderMode arg2 ; - SWIG_check_num_args("ofMesh::draw",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::draw",1,"ofMesh const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::draw",2,"ofPolyRenderMode"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Mesh_draw",1,SWIGTYPE_p_ofMesh); } - arg2 = (ofPolyRenderMode)(int)lua_tonumber(L, 2); ((ofMesh const *)arg1)->draw(arg2); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_draw(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Mesh_draw__SWIG_0(L);} } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Mesh_draw__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_draw'\n" " Possible C/C++ prototypes are:\n" - " ofMesh::draw() const\n" " ofMesh::draw(ofPolyRenderMode) const\n"); lua_error(L);return 0; } -static int _wrap_Mesh_load(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; std::string arg2 ; - SWIG_check_num_args("ofMesh::load",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::load",1,"ofMesh *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofMesh::load",2,"std::string"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Mesh_load",1,SWIGTYPE_p_ofMesh); } - (&arg2)->assign(lua_tostring(L,2),lua_rawlen(L,2)); (arg1)->load(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Mesh_save__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; std::string arg2 ; - bool arg3 ; SWIG_check_num_args("ofMesh::save",3,3) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::save",1,"ofMesh const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofMesh::save",2,"std::string"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofMesh::save",3,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Mesh_save",1,SWIGTYPE_p_ofMesh); } - (&arg2)->assign(lua_tostring(L,2),lua_rawlen(L,2)); arg3 = (lua_toboolean(L, 3)!=0); ((ofMesh const *)arg1)->save(arg2,arg3); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_save__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; std::string arg2 ; - SWIG_check_num_args("ofMesh::save",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::save",1,"ofMesh const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofMesh::save",2,"std::string"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Mesh_save",1,SWIGTYPE_p_ofMesh); } - (&arg2)->assign(lua_tostring(L,2),lua_rawlen(L,2)); ((ofMesh const *)arg1)->save(arg2); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_save(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { - return _wrap_Mesh_save__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - return _wrap_Mesh_save__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_save'\n" " Possible C/C++ prototypes are:\n" - " ofMesh::save(std::string,bool) const\n" " ofMesh::save(std::string) const\n"); lua_error(L);return 0; } -static void swig_delete_Mesh(void *obj) { -ofMesh *arg1 = (ofMesh *) obj; -delete_ofMesh(arg1); -} -static int _proxy__wrap_new_Mesh(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_Mesh); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_Mesh_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_Mesh_methods[]= { - { "setFromTriangles", _wrap_Mesh_setFromTriangles}, - { "setMode", _wrap_Mesh_setMode}, - { "getMode", _wrap_Mesh_getMode}, - { "addVertex", _wrap_Mesh_addVertex}, - { "addVertices", _wrap_Mesh_addVertices}, - { "removeVertex", _wrap_Mesh_removeVertex}, - { "setVertex", _wrap_Mesh_setVertex}, - { "clearVertices", _wrap_Mesh_clearVertices}, - { "clear", _wrap_Mesh_clear}, - { "getNumVertices", _wrap_Mesh_getNumVertices}, - { "getVerticesPointer", _wrap_Mesh_getVerticesPointer}, - { "getVertex", _wrap_Mesh_getVertex}, - { "getVertices", _wrap_Mesh_getVertices}, - { "haveVertsChanged", _wrap_Mesh_haveVertsChanged}, - { "hasVertices", _wrap_Mesh_hasVertices}, - { "append", _wrap_Mesh_append}, - { "mergeDuplicateVertices", _wrap_Mesh_mergeDuplicateVertices}, - { "getCentroid", _wrap_Mesh_getCentroid}, - { "getNormal", _wrap_Mesh_getNormal}, - { "addNormal", _wrap_Mesh_addNormal}, - { "addNormals", _wrap_Mesh_addNormals}, - { "removeNormal", _wrap_Mesh_removeNormal}, - { "setNormal", _wrap_Mesh_setNormal}, - { "clearNormals", _wrap_Mesh_clearNormals}, - { "getNumNormals", _wrap_Mesh_getNumNormals}, - { "getNormalsPointer", _wrap_Mesh_getNormalsPointer}, - { "getNormals", _wrap_Mesh_getNormals}, - { "haveNormalsChanged", _wrap_Mesh_haveNormalsChanged}, - { "hasNormals", _wrap_Mesh_hasNormals}, - { "enableNormals", _wrap_Mesh_enableNormals}, - { "disableNormals", _wrap_Mesh_disableNormals}, - { "usingNormals", _wrap_Mesh_usingNormals}, - { "smoothNormals", _wrap_Mesh_smoothNormals}, - { "getFace", _wrap_Mesh_getFace}, - { "getFaceNormals", _wrap_Mesh_getFaceNormals}, - { "getUniqueFaces", _wrap_Mesh_getUniqueFaces}, - { "getColor", _wrap_Mesh_getColor}, - { "addColor", _wrap_Mesh_addColor}, - { "addColors", _wrap_Mesh_addColors}, - { "removeColor", _wrap_Mesh_removeColor}, - { "setColor", _wrap_Mesh_setColor}, - { "clearColors", _wrap_Mesh_clearColors}, - { "getNumColors", _wrap_Mesh_getNumColors}, - { "getColorsPointer", _wrap_Mesh_getColorsPointer}, - { "getColors", _wrap_Mesh_getColors}, - { "haveColorsChanged", _wrap_Mesh_haveColorsChanged}, - { "hasColors", _wrap_Mesh_hasColors}, - { "enableColors", _wrap_Mesh_enableColors}, - { "disableColors", _wrap_Mesh_disableColors}, - { "usingColors", _wrap_Mesh_usingColors}, - { "getTexCoord", _wrap_Mesh_getTexCoord}, - { "addTexCoord", _wrap_Mesh_addTexCoord}, - { "addTexCoords", _wrap_Mesh_addTexCoords}, - { "removeTexCoord", _wrap_Mesh_removeTexCoord}, - { "setTexCoord", _wrap_Mesh_setTexCoord}, - { "clearTexCoords", _wrap_Mesh_clearTexCoords}, - { "getNumTexCoords", _wrap_Mesh_getNumTexCoords}, - { "getTexCoordsPointer", _wrap_Mesh_getTexCoordsPointer}, - { "getTexCoords", _wrap_Mesh_getTexCoords}, - { "haveTexCoordsChanged", _wrap_Mesh_haveTexCoordsChanged}, - { "hasTexCoords", _wrap_Mesh_hasTexCoords}, - { "enableTextures", _wrap_Mesh_enableTextures}, - { "disableTextures", _wrap_Mesh_disableTextures}, - { "usingTextures", _wrap_Mesh_usingTextures}, - { "setupIndicesAuto", _wrap_Mesh_setupIndicesAuto}, - { "getIndex", _wrap_Mesh_getIndex}, - { "addIndex", _wrap_Mesh_addIndex}, - { "addIndices", _wrap_Mesh_addIndices}, - { "removeIndex", _wrap_Mesh_removeIndex}, - { "setIndex", _wrap_Mesh_setIndex}, - { "clearIndices", _wrap_Mesh_clearIndices}, - { "getNumIndices", _wrap_Mesh_getNumIndices}, - { "getIndexPointer", _wrap_Mesh_getIndexPointer}, - { "getIndices", _wrap_Mesh_getIndices}, - { "haveIndicesChanged", _wrap_Mesh_haveIndicesChanged}, - { "hasIndices", _wrap_Mesh_hasIndices}, - { "addTriangle", _wrap_Mesh_addTriangle}, - { "enableIndices", _wrap_Mesh_enableIndices}, - { "disableIndices", _wrap_Mesh_disableIndices}, - { "usingIndices", _wrap_Mesh_usingIndices}, - { "setColorForIndices", _wrap_Mesh_setColorForIndices}, - { "getMeshForIndices", _wrap_Mesh_getMeshForIndices}, - { "drawVertices", _wrap_Mesh_drawVertices}, - { "drawWireframe", _wrap_Mesh_drawWireframe}, - { "drawFaces", _wrap_Mesh_drawFaces}, - { "draw", _wrap_Mesh_draw}, - { "load", _wrap_Mesh_load}, - { "save", _wrap_Mesh_save}, - {0,0} -}; -static swig_lua_method swig_Mesh_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_Mesh_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_Mesh_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_Mesh_Sf_SwigStatic_methods[]= { - { "plane", _wrap_Mesh_plane}, - { "sphere", _wrap_Mesh_sphere}, - { "icosahedron", _wrap_Mesh_icosahedron}, - { "icosphere", _wrap_Mesh_icosphere}, - { "cylinder", _wrap_Mesh_cylinder}, - { "cone", _wrap_Mesh_cone}, - { "box", _wrap_Mesh_box}, - { "axis", _wrap_Mesh_axis}, - {0,0} -}; -static swig_lua_class* swig_Mesh_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_Mesh_Sf_SwigStatic = { - "Mesh", - swig_Mesh_Sf_SwigStatic_methods, - swig_Mesh_Sf_SwigStatic_attributes, - swig_Mesh_Sf_SwigStatic_constants, - swig_Mesh_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_Mesh_bases[] = {0}; -static const char *swig_Mesh_base_names[] = {0}; -static swig_lua_class _wrap_class_Mesh = { "Mesh", "Mesh", &SWIGTYPE_p_ofMesh,_proxy__wrap_new_Mesh, swig_delete_Mesh, swig_Mesh_methods, swig_Mesh_attributes, &swig_Mesh_Sf_SwigStatic, swig_Mesh_meta, swig_Mesh_bases, swig_Mesh_base_names }; - -static int _wrap_new_MeshFace(lua_State* L) { int SWIG_arg = 0; ofMeshFace *result = 0 ; - SWIG_check_num_args("ofMeshFace::ofMeshFace",0,0) result = (ofMeshFace *)new ofMeshFace(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMeshFace,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_MeshFace_getFaceNormal(lua_State* L) { int SWIG_arg = 0; ofMeshFace *arg1 = (ofMeshFace *) 0 ; - ofVec3f *result = 0 ; SWIG_check_num_args("ofMeshFace::getFaceNormal",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMeshFace::getFaceNormal",1,"ofMeshFace const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMeshFace,0))){ - SWIG_fail_ptr("MeshFace_getFaceNormal",1,SWIGTYPE_p_ofMeshFace); } - result = (ofVec3f *) &((ofMeshFace const *)arg1)->getFaceNormal(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_MeshFace_setVertex(lua_State* L) { int SWIG_arg = 0; ofMeshFace *arg1 = (ofMeshFace *) 0 ; ofIndexType arg2 ; - ofVec3f *arg3 = 0 ; SWIG_check_num_args("ofMeshFace::setVertex",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMeshFace::setVertex",1,"ofMeshFace *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMeshFace::setVertex",2,"ofIndexType"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofMeshFace::setVertex",3,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMeshFace,0))){ - SWIG_fail_ptr("MeshFace_setVertex",1,SWIGTYPE_p_ofMeshFace); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("MeshFace_setVertex",3,SWIGTYPE_p_ofVec3f); } (arg1)->setVertex(arg2,(ofVec3f const &)*arg3); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_MeshFace_getVertex(lua_State* L) { int SWIG_arg = 0; ofMeshFace *arg1 = (ofMeshFace *) 0 ; ofIndexType arg2 ; - ofVec3f *result = 0 ; SWIG_check_num_args("ofMeshFace::getVertex",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMeshFace::getVertex",1,"ofMeshFace const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMeshFace::getVertex",2,"ofIndexType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMeshFace,0))){ - SWIG_fail_ptr("MeshFace_getVertex",1,SWIGTYPE_p_ofMeshFace); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); - result = (ofVec3f *) &((ofMeshFace const *)arg1)->getVertex(arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_MeshFace_setNormal(lua_State* L) { int SWIG_arg = 0; ofMeshFace *arg1 = (ofMeshFace *) 0 ; ofIndexType arg2 ; - ofVec3f *arg3 = 0 ; SWIG_check_num_args("ofMeshFace::setNormal",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMeshFace::setNormal",1,"ofMeshFace *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMeshFace::setNormal",2,"ofIndexType"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofMeshFace::setNormal",3,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMeshFace,0))){ - SWIG_fail_ptr("MeshFace_setNormal",1,SWIGTYPE_p_ofMeshFace); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("MeshFace_setNormal",3,SWIGTYPE_p_ofVec3f); } (arg1)->setNormal(arg2,(ofVec3f const &)*arg3); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_MeshFace_getNormal(lua_State* L) { int SWIG_arg = 0; ofMeshFace *arg1 = (ofMeshFace *) 0 ; ofIndexType arg2 ; - ofVec3f *result = 0 ; SWIG_check_num_args("ofMeshFace::getNormal",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMeshFace::getNormal",1,"ofMeshFace const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMeshFace::getNormal",2,"ofIndexType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMeshFace,0))){ - SWIG_fail_ptr("MeshFace_getNormal",1,SWIGTYPE_p_ofMeshFace); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); - result = (ofVec3f *) &((ofMeshFace const *)arg1)->getNormal(arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_MeshFace_setColor(lua_State* L) { int SWIG_arg = 0; ofMeshFace *arg1 = (ofMeshFace *) 0 ; ofIndexType arg2 ; - ofFloatColor *arg3 = 0 ; SWIG_check_num_args("ofMeshFace::setColor",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMeshFace::setColor",1,"ofMeshFace *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMeshFace::setColor",2,"ofIndexType"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofMeshFace::setColor",3,"ofFloatColor const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMeshFace,0))){ - SWIG_fail_ptr("MeshFace_setColor",1,SWIGTYPE_p_ofMeshFace); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("MeshFace_setColor",3,SWIGTYPE_p_ofColor_T_float_t); } (arg1)->setColor(arg2,(ofFloatColor const &)*arg3); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_MeshFace_getColor(lua_State* L) { int SWIG_arg = 0; ofMeshFace *arg1 = (ofMeshFace *) 0 ; ofIndexType arg2 ; - ofFloatColor *result = 0 ; SWIG_check_num_args("ofMeshFace::getColor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMeshFace::getColor",1,"ofMeshFace const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMeshFace::getColor",2,"ofIndexType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMeshFace,0))){ - SWIG_fail_ptr("MeshFace_getColor",1,SWIGTYPE_p_ofMeshFace); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); - result = (ofFloatColor *) &((ofMeshFace const *)arg1)->getColor(arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_MeshFace_setTexCoord(lua_State* L) { int SWIG_arg = 0; ofMeshFace *arg1 = (ofMeshFace *) 0 ; ofIndexType arg2 ; - ofVec2f *arg3 = 0 ; SWIG_check_num_args("ofMeshFace::setTexCoord",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMeshFace::setTexCoord",1,"ofMeshFace *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMeshFace::setTexCoord",2,"ofIndexType"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofMeshFace::setTexCoord",3,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMeshFace,0))){ - SWIG_fail_ptr("MeshFace_setTexCoord",1,SWIGTYPE_p_ofMeshFace); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("MeshFace_setTexCoord",3,SWIGTYPE_p_ofVec2f); } (arg1)->setTexCoord(arg2,(ofVec2f const &)*arg3); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_MeshFace_getTexCoord(lua_State* L) { int SWIG_arg = 0; ofMeshFace *arg1 = (ofMeshFace *) 0 ; ofIndexType arg2 ; - ofVec2f *result = 0 ; SWIG_check_num_args("ofMeshFace::getTexCoord",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMeshFace::getTexCoord",1,"ofMeshFace const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMeshFace::getTexCoord",2,"ofIndexType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMeshFace,0))){ - SWIG_fail_ptr("MeshFace_getTexCoord",1,SWIGTYPE_p_ofMeshFace); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); - result = (ofVec2f *) &((ofMeshFace const *)arg1)->getTexCoord(arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec2f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_MeshFace_setHasColors(lua_State* L) { int SWIG_arg = 0; ofMeshFace *arg1 = (ofMeshFace *) 0 ; bool arg2 ; - SWIG_check_num_args("ofMeshFace::setHasColors",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMeshFace::setHasColors",1,"ofMeshFace *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofMeshFace::setHasColors",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMeshFace,0))){ - SWIG_fail_ptr("MeshFace_setHasColors",1,SWIGTYPE_p_ofMeshFace); } arg2 = (lua_toboolean(L, 2)!=0); - (arg1)->setHasColors(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_MeshFace_setHasNormals(lua_State* L) { int SWIG_arg = 0; ofMeshFace *arg1 = (ofMeshFace *) 0 ; bool arg2 ; - SWIG_check_num_args("ofMeshFace::setHasNormals",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMeshFace::setHasNormals",1,"ofMeshFace *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofMeshFace::setHasNormals",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMeshFace,0))){ - SWIG_fail_ptr("MeshFace_setHasNormals",1,SWIGTYPE_p_ofMeshFace); } arg2 = (lua_toboolean(L, 2)!=0); - (arg1)->setHasNormals(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_MeshFace_setHasTexcoords(lua_State* L) { int SWIG_arg = 0; ofMeshFace *arg1 = (ofMeshFace *) 0 ; bool arg2 ; - SWIG_check_num_args("ofMeshFace::setHasTexcoords",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMeshFace::setHasTexcoords",1,"ofMeshFace *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofMeshFace::setHasTexcoords",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMeshFace,0))){ - SWIG_fail_ptr("MeshFace_setHasTexcoords",1,SWIGTYPE_p_ofMeshFace); } arg2 = (lua_toboolean(L, 2)!=0); - (arg1)->setHasTexcoords(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_MeshFace_hasColors(lua_State* L) { int SWIG_arg = 0; ofMeshFace *arg1 = (ofMeshFace *) 0 ; bool result; - SWIG_check_num_args("ofMeshFace::hasColors",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMeshFace::hasColors",1,"ofMeshFace const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMeshFace,0))){ - SWIG_fail_ptr("MeshFace_hasColors",1,SWIGTYPE_p_ofMeshFace); } result = (bool)((ofMeshFace const *)arg1)->hasColors(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_MeshFace_hasNormals(lua_State* L) { int SWIG_arg = 0; ofMeshFace *arg1 = (ofMeshFace *) 0 ; bool result; - SWIG_check_num_args("ofMeshFace::hasNormals",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMeshFace::hasNormals",1,"ofMeshFace const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMeshFace,0))){ - SWIG_fail_ptr("MeshFace_hasNormals",1,SWIGTYPE_p_ofMeshFace); } result = (bool)((ofMeshFace const *)arg1)->hasNormals(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_MeshFace_hasTexcoords(lua_State* L) { int SWIG_arg = 0; ofMeshFace *arg1 = (ofMeshFace *) 0 ; bool result; - SWIG_check_num_args("ofMeshFace::hasTexcoords",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMeshFace::hasTexcoords",1,"ofMeshFace const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMeshFace,0))){ - SWIG_fail_ptr("MeshFace_hasTexcoords",1,SWIGTYPE_p_ofMeshFace); } - result = (bool)((ofMeshFace const *)arg1)->hasTexcoords(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_MeshFace(void *obj) { -ofMeshFace *arg1 = (ofMeshFace *) obj; -delete arg1; -} -static int _proxy__wrap_new_MeshFace(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_MeshFace); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_MeshFace_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_MeshFace_methods[]= { - { "getFaceNormal", _wrap_MeshFace_getFaceNormal}, - { "setVertex", _wrap_MeshFace_setVertex}, - { "getVertex", _wrap_MeshFace_getVertex}, - { "setNormal", _wrap_MeshFace_setNormal}, - { "getNormal", _wrap_MeshFace_getNormal}, - { "setColor", _wrap_MeshFace_setColor}, - { "getColor", _wrap_MeshFace_getColor}, - { "setTexCoord", _wrap_MeshFace_setTexCoord}, - { "getTexCoord", _wrap_MeshFace_getTexCoord}, - { "setHasColors", _wrap_MeshFace_setHasColors}, - { "setHasNormals", _wrap_MeshFace_setHasNormals}, - { "setHasTexcoords", _wrap_MeshFace_setHasTexcoords}, - { "hasColors", _wrap_MeshFace_hasColors}, - { "hasNormals", _wrap_MeshFace_hasNormals}, - { "hasTexcoords", _wrap_MeshFace_hasTexcoords}, - {0,0} -}; -static swig_lua_method swig_MeshFace_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_MeshFace_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_MeshFace_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_MeshFace_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_MeshFace_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_MeshFace_Sf_SwigStatic = { - "MeshFace", - swig_MeshFace_Sf_SwigStatic_methods, - swig_MeshFace_Sf_SwigStatic_attributes, - swig_MeshFace_Sf_SwigStatic_constants, - swig_MeshFace_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_MeshFace_bases[] = {0}; -static const char *swig_MeshFace_base_names[] = {0}; -static swig_lua_class _wrap_class_MeshFace = { "MeshFace", "MeshFace", &SWIGTYPE_p_ofMeshFace,_proxy__wrap_new_MeshFace, swig_delete_MeshFace, swig_MeshFace_methods, swig_MeshFace_attributes, &swig_MeshFace_Sf_SwigStatic, swig_MeshFace_meta, swig_MeshFace_bases, swig_MeshFace_base_names }; - -static int _wrap_new_3dPrimitive__SWIG_0(lua_State* L) { int SWIG_arg = 0; of3dPrimitive *result = 0 ; - SWIG_check_num_args("of3dPrimitive::of3dPrimitive",0,0) result = (of3dPrimitive *)new of3dPrimitive(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_of3dPrimitive,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_3dPrimitive__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = 0 ; of3dPrimitive *result = 0 ; - SWIG_check_num_args("of3dPrimitive::of3dPrimitive",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("of3dPrimitive::of3dPrimitive",1,"ofMesh const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("new_3dPrimitive",1,SWIGTYPE_p_ofMesh); } result = (of3dPrimitive *)new of3dPrimitive((ofMesh const &)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_of3dPrimitive,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_3dPrimitive__SWIG_2(lua_State* L) { int SWIG_arg = 0; of3dPrimitive *arg1 = 0 ; of3dPrimitive *result = 0 ; - SWIG_check_num_args("of3dPrimitive::of3dPrimitive",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("of3dPrimitive::of3dPrimitive",1,"of3dPrimitive const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_of3dPrimitive,0))){ - SWIG_fail_ptr("new_3dPrimitive",1,SWIGTYPE_p_of3dPrimitive); } - result = (of3dPrimitive *)new of3dPrimitive((of3dPrimitive const &)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_of3dPrimitive,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_3dPrimitive(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_3dPrimitive__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_new_3dPrimitive__SWIG_1(L);} } if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_of3dPrimitive, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_new_3dPrimitive__SWIG_2(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_3dPrimitive'\n" " Possible C/C++ prototypes are:\n" - " of3dPrimitive::of3dPrimitive()\n" " of3dPrimitive::of3dPrimitive(ofMesh const &)\n" - " of3dPrimitive::of3dPrimitive(of3dPrimitive const &)\n"); lua_error(L);return 0; } -static int _wrap_3dPrimitive_mapTexCoords(lua_State* L) { int SWIG_arg = 0; of3dPrimitive *arg1 = (of3dPrimitive *) 0 ; - float arg2 ; float arg3 ; float arg4 ; float arg5 ; SWIG_check_num_args("of3dPrimitive::mapTexCoords",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("of3dPrimitive::mapTexCoords",1,"of3dPrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("of3dPrimitive::mapTexCoords",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("of3dPrimitive::mapTexCoords",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("of3dPrimitive::mapTexCoords",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("of3dPrimitive::mapTexCoords",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_of3dPrimitive,0))){ - SWIG_fail_ptr("3dPrimitive_mapTexCoords",1,SWIGTYPE_p_of3dPrimitive); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - (arg1)->mapTexCoords(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_3dPrimitive_mapTexCoordsFromTexture(lua_State* L) { int SWIG_arg = 0; - of3dPrimitive *arg1 = (of3dPrimitive *) 0 ; ofTexture *arg2 = 0 ; - SWIG_check_num_args("of3dPrimitive::mapTexCoordsFromTexture",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("of3dPrimitive::mapTexCoordsFromTexture",1,"of3dPrimitive *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("of3dPrimitive::mapTexCoordsFromTexture",2,"ofTexture &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_of3dPrimitive,0))){ - SWIG_fail_ptr("3dPrimitive_mapTexCoordsFromTexture",1,SWIGTYPE_p_of3dPrimitive); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("3dPrimitive_mapTexCoordsFromTexture",2,SWIGTYPE_p_ofTexture); } (arg1)->mapTexCoordsFromTexture(*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_3dPrimitive_getMeshPtr__SWIG_0(lua_State* L) { int SWIG_arg = 0; of3dPrimitive *arg1 = (of3dPrimitive *) 0 ; - ofMesh *result = 0 ; SWIG_check_num_args("of3dPrimitive::getMeshPtr",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("of3dPrimitive::getMeshPtr",1,"of3dPrimitive *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_of3dPrimitive,0))){ - SWIG_fail_ptr("3dPrimitive_getMeshPtr",1,SWIGTYPE_p_of3dPrimitive); } result = (ofMesh *)(arg1)->getMeshPtr(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMesh,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_3dPrimitive_getMesh__SWIG_0(lua_State* L) { int SWIG_arg = 0; of3dPrimitive *arg1 = (of3dPrimitive *) 0 ; - ofMesh *result = 0 ; SWIG_check_num_args("of3dPrimitive::getMesh",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("of3dPrimitive::getMesh",1,"of3dPrimitive *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_of3dPrimitive,0))){ - SWIG_fail_ptr("3dPrimitive_getMesh",1,SWIGTYPE_p_of3dPrimitive); } result = (ofMesh *) &(arg1)->getMesh(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMesh,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_3dPrimitive_getMeshPtr__SWIG_1(lua_State* L) { int SWIG_arg = 0; of3dPrimitive *arg1 = (of3dPrimitive *) 0 ; - ofMesh *result = 0 ; SWIG_check_num_args("of3dPrimitive::getMeshPtr",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("of3dPrimitive::getMeshPtr",1,"of3dPrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_of3dPrimitive,0))){ - SWIG_fail_ptr("3dPrimitive_getMeshPtr",1,SWIGTYPE_p_of3dPrimitive); } - result = (ofMesh *)((of3dPrimitive const *)arg1)->getMeshPtr(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMesh,0); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_3dPrimitive_getMeshPtr(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_of3dPrimitive, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_3dPrimitive_getMeshPtr__SWIG_0(L);} } if (argc == 1) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_of3dPrimitive, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_3dPrimitive_getMeshPtr__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function '3dPrimitive_getMeshPtr'\n" - " Possible C/C++ prototypes are:\n" " of3dPrimitive::getMeshPtr()\n" " of3dPrimitive::getMeshPtr() const\n"); - lua_error(L);return 0; } -static int _wrap_3dPrimitive_getMesh__SWIG_1(lua_State* L) { int SWIG_arg = 0; of3dPrimitive *arg1 = (of3dPrimitive *) 0 ; - ofMesh *result = 0 ; SWIG_check_num_args("of3dPrimitive::getMesh",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("of3dPrimitive::getMesh",1,"of3dPrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_of3dPrimitive,0))){ - SWIG_fail_ptr("3dPrimitive_getMesh",1,SWIGTYPE_p_of3dPrimitive); } - result = (ofMesh *) &((of3dPrimitive const *)arg1)->getMesh(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMesh,0); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_3dPrimitive_getMesh(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_of3dPrimitive, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_3dPrimitive_getMesh__SWIG_0(L);} } if (argc == 1) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_of3dPrimitive, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_3dPrimitive_getMesh__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function '3dPrimitive_getMesh'\n" - " Possible C/C++ prototypes are:\n" " of3dPrimitive::getMesh()\n" " of3dPrimitive::getMesh() const\n"); - lua_error(L);return 0; } -static int _wrap_3dPrimitive_getTexCoordsPtr__SWIG_0(lua_State* L) { int SWIG_arg = 0; - of3dPrimitive *arg1 = (of3dPrimitive *) 0 ; ofVec4f *result = 0 ; SWIG_check_num_args("of3dPrimitive::getTexCoordsPtr",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("of3dPrimitive::getTexCoordsPtr",1,"of3dPrimitive *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_of3dPrimitive,0))){ - SWIG_fail_ptr("3dPrimitive_getTexCoordsPtr",1,SWIGTYPE_p_of3dPrimitive); } result = (ofVec4f *)(arg1)->getTexCoordsPtr(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec4f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_3dPrimitive_getTexCoords__SWIG_0(lua_State* L) { int SWIG_arg = 0; of3dPrimitive *arg1 = (of3dPrimitive *) 0 ; - ofVec4f *result = 0 ; SWIG_check_num_args("of3dPrimitive::getTexCoords",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("of3dPrimitive::getTexCoords",1,"of3dPrimitive *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_of3dPrimitive,0))){ - SWIG_fail_ptr("3dPrimitive_getTexCoords",1,SWIGTYPE_p_of3dPrimitive); } result = (ofVec4f *) &(arg1)->getTexCoords(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec4f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_3dPrimitive_getTexCoordsPtr__SWIG_1(lua_State* L) { int SWIG_arg = 0; - of3dPrimitive *arg1 = (of3dPrimitive *) 0 ; ofVec4f *result = 0 ; SWIG_check_num_args("of3dPrimitive::getTexCoordsPtr",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("of3dPrimitive::getTexCoordsPtr",1,"of3dPrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_of3dPrimitive,0))){ - SWIG_fail_ptr("3dPrimitive_getTexCoordsPtr",1,SWIGTYPE_p_of3dPrimitive); } - result = (ofVec4f *)((of3dPrimitive const *)arg1)->getTexCoordsPtr(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec4f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_3dPrimitive_getTexCoordsPtr(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); - if (argc == 1) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_of3dPrimitive, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_3dPrimitive_getTexCoordsPtr__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_of3dPrimitive, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_3dPrimitive_getTexCoordsPtr__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function '3dPrimitive_getTexCoordsPtr'\n" - " Possible C/C++ prototypes are:\n" " of3dPrimitive::getTexCoordsPtr()\n" " of3dPrimitive::getTexCoordsPtr() const\n"); - lua_error(L);return 0; } -static int _wrap_3dPrimitive_getTexCoords__SWIG_1(lua_State* L) { int SWIG_arg = 0; of3dPrimitive *arg1 = (of3dPrimitive *) 0 ; - ofVec4f *result = 0 ; SWIG_check_num_args("of3dPrimitive::getTexCoords",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("of3dPrimitive::getTexCoords",1,"of3dPrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_of3dPrimitive,0))){ - SWIG_fail_ptr("3dPrimitive_getTexCoords",1,SWIGTYPE_p_of3dPrimitive); } - result = (ofVec4f *) &((of3dPrimitive const *)arg1)->getTexCoords(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec4f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_3dPrimitive_getTexCoords(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_of3dPrimitive, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_3dPrimitive_getTexCoords__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_of3dPrimitive, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_3dPrimitive_getTexCoords__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function '3dPrimitive_getTexCoords'\n" - " Possible C/C++ prototypes are:\n" " of3dPrimitive::getTexCoords()\n" " of3dPrimitive::getTexCoords() const\n"); - lua_error(L);return 0; } -static int _wrap_3dPrimitive_hasScaling(lua_State* L) { int SWIG_arg = 0; of3dPrimitive *arg1 = (of3dPrimitive *) 0 ; - bool result; SWIG_check_num_args("of3dPrimitive::hasScaling",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("of3dPrimitive::hasScaling",1,"of3dPrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_of3dPrimitive,0))){ - SWIG_fail_ptr("3dPrimitive_hasScaling",1,SWIGTYPE_p_of3dPrimitive); } - result = (bool)((of3dPrimitive const *)arg1)->hasScaling(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_3dPrimitive_hasNormalsEnabled(lua_State* L) { int SWIG_arg = 0; of3dPrimitive *arg1 = (of3dPrimitive *) 0 ; - bool result; SWIG_check_num_args("of3dPrimitive::hasNormalsEnabled",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("of3dPrimitive::hasNormalsEnabled",1,"of3dPrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_of3dPrimitive,0))){ - SWIG_fail_ptr("3dPrimitive_hasNormalsEnabled",1,SWIGTYPE_p_of3dPrimitive); } - result = (bool)((of3dPrimitive const *)arg1)->hasNormalsEnabled(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_3dPrimitive_enableNormals(lua_State* L) { int SWIG_arg = 0; of3dPrimitive *arg1 = (of3dPrimitive *) 0 ; - SWIG_check_num_args("of3dPrimitive::enableNormals",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("of3dPrimitive::enableNormals",1,"of3dPrimitive *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_of3dPrimitive,0))){ - SWIG_fail_ptr("3dPrimitive_enableNormals",1,SWIGTYPE_p_of3dPrimitive); } (arg1)->enableNormals(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_3dPrimitive_enableTextures(lua_State* L) { int SWIG_arg = 0; of3dPrimitive *arg1 = (of3dPrimitive *) 0 ; - SWIG_check_num_args("of3dPrimitive::enableTextures",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("of3dPrimitive::enableTextures",1,"of3dPrimitive *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_of3dPrimitive,0))){ - SWIG_fail_ptr("3dPrimitive_enableTextures",1,SWIGTYPE_p_of3dPrimitive); } (arg1)->enableTextures(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_3dPrimitive_enableColors(lua_State* L) { int SWIG_arg = 0; of3dPrimitive *arg1 = (of3dPrimitive *) 0 ; - SWIG_check_num_args("of3dPrimitive::enableColors",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("of3dPrimitive::enableColors",1,"of3dPrimitive *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_of3dPrimitive,0))){ - SWIG_fail_ptr("3dPrimitive_enableColors",1,SWIGTYPE_p_of3dPrimitive); } (arg1)->enableColors(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_3dPrimitive_disableNormals(lua_State* L) { int SWIG_arg = 0; of3dPrimitive *arg1 = (of3dPrimitive *) 0 ; - SWIG_check_num_args("of3dPrimitive::disableNormals",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("of3dPrimitive::disableNormals",1,"of3dPrimitive *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_of3dPrimitive,0))){ - SWIG_fail_ptr("3dPrimitive_disableNormals",1,SWIGTYPE_p_of3dPrimitive); } (arg1)->disableNormals(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_3dPrimitive_disableTextures(lua_State* L) { int SWIG_arg = 0; of3dPrimitive *arg1 = (of3dPrimitive *) 0 ; - SWIG_check_num_args("of3dPrimitive::disableTextures",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("of3dPrimitive::disableTextures",1,"of3dPrimitive *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_of3dPrimitive,0))){ - SWIG_fail_ptr("3dPrimitive_disableTextures",1,SWIGTYPE_p_of3dPrimitive); } (arg1)->disableTextures(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_3dPrimitive_disableColors(lua_State* L) { int SWIG_arg = 0; of3dPrimitive *arg1 = (of3dPrimitive *) 0 ; - SWIG_check_num_args("of3dPrimitive::disableColors",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("of3dPrimitive::disableColors",1,"of3dPrimitive *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_of3dPrimitive,0))){ - SWIG_fail_ptr("3dPrimitive_disableColors",1,SWIGTYPE_p_of3dPrimitive); } (arg1)->disableColors(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_3dPrimitive_drawVertices(lua_State* L) { int SWIG_arg = 0; of3dPrimitive *arg1 = (of3dPrimitive *) 0 ; - SWIG_check_num_args("of3dPrimitive::drawVertices",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("of3dPrimitive::drawVertices",1,"of3dPrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_of3dPrimitive,0))){ - SWIG_fail_ptr("3dPrimitive_drawVertices",1,SWIGTYPE_p_of3dPrimitive); } ((of3dPrimitive const *)arg1)->drawVertices(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_3dPrimitive_drawWireframe(lua_State* L) { int SWIG_arg = 0; of3dPrimitive *arg1 = (of3dPrimitive *) 0 ; - SWIG_check_num_args("of3dPrimitive::drawWireframe",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("of3dPrimitive::drawWireframe",1,"of3dPrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_of3dPrimitive,0))){ - SWIG_fail_ptr("3dPrimitive_drawWireframe",1,SWIGTYPE_p_of3dPrimitive); } ((of3dPrimitive const *)arg1)->drawWireframe(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_3dPrimitive_drawFaces(lua_State* L) { int SWIG_arg = 0; of3dPrimitive *arg1 = (of3dPrimitive *) 0 ; - SWIG_check_num_args("of3dPrimitive::drawFaces",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("of3dPrimitive::drawFaces",1,"of3dPrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_of3dPrimitive,0))){ - SWIG_fail_ptr("3dPrimitive_drawFaces",1,SWIGTYPE_p_of3dPrimitive); } ((of3dPrimitive const *)arg1)->drawFaces(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_3dPrimitive_draw(lua_State* L) { int SWIG_arg = 0; of3dPrimitive *arg1 = (of3dPrimitive *) 0 ; - ofPolyRenderMode arg2 ; SWIG_check_num_args("of3dPrimitive::draw",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("of3dPrimitive::draw",1,"of3dPrimitive const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("of3dPrimitive::draw",2,"ofPolyRenderMode"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_of3dPrimitive,0))){ - SWIG_fail_ptr("3dPrimitive_draw",1,SWIGTYPE_p_of3dPrimitive); } arg2 = (ofPolyRenderMode)(int)lua_tonumber(L, 2); - ((of3dPrimitive const *)arg1)->draw(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_3dPrimitive_drawNormals__SWIG_0(lua_State* L) { int SWIG_arg = 0; of3dPrimitive *arg1 = (of3dPrimitive *) 0 ; - float arg2 ; bool arg3 ; SWIG_check_num_args("of3dPrimitive::drawNormals",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("of3dPrimitive::drawNormals",1,"of3dPrimitive const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("of3dPrimitive::drawNormals",2,"float"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("of3dPrimitive::drawNormals",3,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_of3dPrimitive,0))){ - SWIG_fail_ptr("3dPrimitive_drawNormals",1,SWIGTYPE_p_of3dPrimitive); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (lua_toboolean(L, 3)!=0); ((of3dPrimitive const *)arg1)->drawNormals(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_3dPrimitive_drawNormals__SWIG_1(lua_State* L) { int SWIG_arg = 0; of3dPrimitive *arg1 = (of3dPrimitive *) 0 ; - float arg2 ; SWIG_check_num_args("of3dPrimitive::drawNormals",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("of3dPrimitive::drawNormals",1,"of3dPrimitive const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("of3dPrimitive::drawNormals",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_of3dPrimitive,0))){ - SWIG_fail_ptr("3dPrimitive_drawNormals",1,SWIGTYPE_p_of3dPrimitive); } arg2 = (float)lua_tonumber(L, 2); - ((of3dPrimitive const *)arg1)->drawNormals(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_3dPrimitive_drawNormals(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_of3dPrimitive, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_3dPrimitive_drawNormals__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_of3dPrimitive, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - return _wrap_3dPrimitive_drawNormals__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function '3dPrimitive_drawNormals'\n" - " Possible C/C++ prototypes are:\n" " of3dPrimitive::drawNormals(float,bool) const\n" - " of3dPrimitive::drawNormals(float) const\n"); lua_error(L);return 0; } -static int _wrap_3dPrimitive_drawAxes(lua_State* L) { int SWIG_arg = 0; of3dPrimitive *arg1 = (of3dPrimitive *) 0 ; float arg2 ; - SWIG_check_num_args("of3dPrimitive::drawAxes",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("of3dPrimitive::drawAxes",1,"of3dPrimitive const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("of3dPrimitive::drawAxes",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_of3dPrimitive,0))){ - SWIG_fail_ptr("3dPrimitive_drawAxes",1,SWIGTYPE_p_of3dPrimitive); } arg2 = (float)lua_tonumber(L, 2); - ((of3dPrimitive const *)arg1)->drawAxes(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_3dPrimitive_setUseVbo(lua_State* L) { int SWIG_arg = 0; of3dPrimitive *arg1 = (of3dPrimitive *) 0 ; bool arg2 ; - SWIG_check_num_args("of3dPrimitive::setUseVbo",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("of3dPrimitive::setUseVbo",1,"of3dPrimitive *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("of3dPrimitive::setUseVbo",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_of3dPrimitive,0))){ - SWIG_fail_ptr("3dPrimitive_setUseVbo",1,SWIGTYPE_p_of3dPrimitive); } arg2 = (lua_toboolean(L, 2)!=0); - (arg1)->setUseVbo(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_3dPrimitive_isUsingVbo(lua_State* L) { int SWIG_arg = 0; of3dPrimitive *arg1 = (of3dPrimitive *) 0 ; - bool result; SWIG_check_num_args("of3dPrimitive::isUsingVbo",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("of3dPrimitive::isUsingVbo",1,"of3dPrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_of3dPrimitive,0))){ - SWIG_fail_ptr("3dPrimitive_isUsingVbo",1,SWIGTYPE_p_of3dPrimitive); } - result = (bool)((of3dPrimitive const *)arg1)->isUsingVbo(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_3dPrimitive(void *obj) { -of3dPrimitive *arg1 = (of3dPrimitive *) obj; -delete arg1; -} -static int _proxy__wrap_new_3dPrimitive(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_3dPrimitive); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_3dPrimitive_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_3dPrimitive_methods[]= { - { "mapTexCoords", _wrap_3dPrimitive_mapTexCoords}, - { "mapTexCoordsFromTexture", _wrap_3dPrimitive_mapTexCoordsFromTexture}, - { "getMeshPtr", _wrap_3dPrimitive_getMeshPtr}, - { "getMesh", _wrap_3dPrimitive_getMesh}, - { "getTexCoordsPtr", _wrap_3dPrimitive_getTexCoordsPtr}, - { "getTexCoords", _wrap_3dPrimitive_getTexCoords}, - { "hasScaling", _wrap_3dPrimitive_hasScaling}, - { "hasNormalsEnabled", _wrap_3dPrimitive_hasNormalsEnabled}, - { "enableNormals", _wrap_3dPrimitive_enableNormals}, - { "enableTextures", _wrap_3dPrimitive_enableTextures}, - { "enableColors", _wrap_3dPrimitive_enableColors}, - { "disableNormals", _wrap_3dPrimitive_disableNormals}, - { "disableTextures", _wrap_3dPrimitive_disableTextures}, - { "disableColors", _wrap_3dPrimitive_disableColors}, - { "drawVertices", _wrap_3dPrimitive_drawVertices}, - { "drawWireframe", _wrap_3dPrimitive_drawWireframe}, - { "drawFaces", _wrap_3dPrimitive_drawFaces}, - { "drawNormals", _wrap_3dPrimitive_drawNormals}, - { "drawAxes", _wrap_3dPrimitive_drawAxes}, - { "setUseVbo", _wrap_3dPrimitive_setUseVbo}, - { "isUsingVbo", _wrap_3dPrimitive_isUsingVbo}, - {0,0} -}; -static swig_lua_method swig_3dPrimitive_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_3dPrimitive_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_3dPrimitive_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_3dPrimitive_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_3dPrimitive_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_3dPrimitive_Sf_SwigStatic = { - "3dPrimitive", - swig_3dPrimitive_Sf_SwigStatic_methods, - swig_3dPrimitive_Sf_SwigStatic_attributes, - swig_3dPrimitive_Sf_SwigStatic_constants, - swig_3dPrimitive_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_3dPrimitive_bases[] = {0,0}; -static const char *swig_3dPrimitive_base_names[] = {"ofNode *",0}; -static swig_lua_class _wrap_class_3dPrimitive = { "3dPrimitive", "3dPrimitive", &SWIGTYPE_p_of3dPrimitive,_proxy__wrap_new_3dPrimitive, swig_delete_3dPrimitive, swig_3dPrimitive_methods, swig_3dPrimitive_attributes, &swig_3dPrimitive_Sf_SwigStatic, swig_3dPrimitive_meta, swig_3dPrimitive_bases, swig_3dPrimitive_base_names }; - -static int _wrap_new_PlanePrimitive__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPlanePrimitive *result = 0 ; - SWIG_check_num_args("ofPlanePrimitive::ofPlanePrimitive",0,0) result = (ofPlanePrimitive *)new ofPlanePrimitive(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofPlanePrimitive,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_PlanePrimitive__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; int arg3 ; int arg4 ; - ofPrimitiveMode arg5 ; ofPlanePrimitive *result = 0 ; SWIG_check_num_args("ofPlanePrimitive::ofPlanePrimitive",5,5) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofPlanePrimitive::ofPlanePrimitive",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPlanePrimitive::ofPlanePrimitive",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPlanePrimitive::ofPlanePrimitive",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPlanePrimitive::ofPlanePrimitive",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPlanePrimitive::ofPlanePrimitive",5,"ofPrimitiveMode"); - arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); arg5 = (ofPrimitiveMode)(int)lua_tonumber(L, 5); - result = (ofPlanePrimitive *)new ofPlanePrimitive(arg1,arg2,arg3,arg4,arg5); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofPlanePrimitive,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_PlanePrimitive__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; int arg3 ; int arg4 ; - ofPlanePrimitive *result = 0 ; SWIG_check_num_args("ofPlanePrimitive::ofPlanePrimitive",4,4) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofPlanePrimitive::ofPlanePrimitive",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPlanePrimitive::ofPlanePrimitive",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPlanePrimitive::ofPlanePrimitive",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPlanePrimitive::ofPlanePrimitive",4,"int"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - result = (ofPlanePrimitive *)new ofPlanePrimitive(arg1,arg2,arg3,arg4); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofPlanePrimitive,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_PlanePrimitive(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); - if (argc == 0) { return _wrap_new_PlanePrimitive__SWIG_0(L);} if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_new_PlanePrimitive__SWIG_2(L);} } } } } - if (argc == 5) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_new_PlanePrimitive__SWIG_1(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_PlanePrimitive'\n" " Possible C/C++ prototypes are:\n" - " ofPlanePrimitive::ofPlanePrimitive()\n" " ofPlanePrimitive::ofPlanePrimitive(float,float,int,int,ofPrimitiveMode)\n" - " ofPlanePrimitive::ofPlanePrimitive(float,float,int,int)\n"); lua_error(L);return 0; } -static int _wrap_PlanePrimitive_set__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPlanePrimitive *arg1 = (ofPlanePrimitive *) 0 ; - float arg2 ; float arg3 ; int arg4 ; int arg5 ; ofPrimitiveMode arg6 ; SWIG_check_num_args("ofPlanePrimitive::set",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPlanePrimitive::set",1,"ofPlanePrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPlanePrimitive::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPlanePrimitive::set",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPlanePrimitive::set",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPlanePrimitive::set",5,"int"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPlanePrimitive::set",6,"ofPrimitiveMode"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPlanePrimitive,0))){ - SWIG_fail_ptr("PlanePrimitive_set",1,SWIGTYPE_p_ofPlanePrimitive); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); - arg6 = (ofPrimitiveMode)(int)lua_tonumber(L, 6); (arg1)->set(arg2,arg3,arg4,arg5,arg6); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_PlanePrimitive_set__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPlanePrimitive *arg1 = (ofPlanePrimitive *) 0 ; - float arg2 ; float arg3 ; int arg4 ; int arg5 ; SWIG_check_num_args("ofPlanePrimitive::set",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPlanePrimitive::set",1,"ofPlanePrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPlanePrimitive::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPlanePrimitive::set",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPlanePrimitive::set",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPlanePrimitive::set",5,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPlanePrimitive,0))){ - SWIG_fail_ptr("PlanePrimitive_set",1,SWIGTYPE_p_ofPlanePrimitive); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); - (arg1)->set(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_PlanePrimitive_set__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPlanePrimitive *arg1 = (ofPlanePrimitive *) 0 ; - float arg2 ; float arg3 ; SWIG_check_num_args("ofPlanePrimitive::set",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPlanePrimitive::set",1,"ofPlanePrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPlanePrimitive::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPlanePrimitive::set",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPlanePrimitive,0))){ - SWIG_fail_ptr("PlanePrimitive_set",1,SWIGTYPE_p_ofPlanePrimitive); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->set(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_PlanePrimitive_set(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPlanePrimitive, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_PlanePrimitive_set__SWIG_2(L);} } } } if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPlanePrimitive, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_PlanePrimitive_set__SWIG_1(L);} } } } } } if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPlanePrimitive, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { return _wrap_PlanePrimitive_set__SWIG_0(L);} } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'PlanePrimitive_set'\n" " Possible C/C++ prototypes are:\n" - " ofPlanePrimitive::set(float,float,int,int,ofPrimitiveMode)\n" " ofPlanePrimitive::set(float,float,int,int)\n" - " ofPlanePrimitive::set(float,float)\n"); lua_error(L);return 0; } -static int _wrap_PlanePrimitive_resizeToTexture__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofPlanePrimitive *arg1 = (ofPlanePrimitive *) 0 ; ofTexture *arg2 = 0 ; float arg3 ; - SWIG_check_num_args("ofPlanePrimitive::resizeToTexture",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPlanePrimitive::resizeToTexture",1,"ofPlanePrimitive *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPlanePrimitive::resizeToTexture",2,"ofTexture &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPlanePrimitive::resizeToTexture",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPlanePrimitive,0))){ - SWIG_fail_ptr("PlanePrimitive_resizeToTexture",1,SWIGTYPE_p_ofPlanePrimitive); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("PlanePrimitive_resizeToTexture",2,SWIGTYPE_p_ofTexture); } arg3 = (float)lua_tonumber(L, 3); - (arg1)->resizeToTexture(*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_PlanePrimitive_resizeToTexture__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofPlanePrimitive *arg1 = (ofPlanePrimitive *) 0 ; ofTexture *arg2 = 0 ; - SWIG_check_num_args("ofPlanePrimitive::resizeToTexture",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPlanePrimitive::resizeToTexture",1,"ofPlanePrimitive *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPlanePrimitive::resizeToTexture",2,"ofTexture &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPlanePrimitive,0))){ - SWIG_fail_ptr("PlanePrimitive_resizeToTexture",1,SWIGTYPE_p_ofPlanePrimitive); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("PlanePrimitive_resizeToTexture",2,SWIGTYPE_p_ofTexture); } (arg1)->resizeToTexture(*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_PlanePrimitive_resizeToTexture(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPlanePrimitive, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_PlanePrimitive_resizeToTexture__SWIG_1(L);} } } if (argc == 3) { int _v; - { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPlanePrimitive, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_PlanePrimitive_resizeToTexture__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'PlanePrimitive_resizeToTexture'\n" - " Possible C/C++ prototypes are:\n" " ofPlanePrimitive::resizeToTexture(ofTexture &,float)\n" - " ofPlanePrimitive::resizeToTexture(ofTexture &)\n"); lua_error(L);return 0; } -static int _wrap_PlanePrimitive_setWidth(lua_State* L) { int SWIG_arg = 0; ofPlanePrimitive *arg1 = (ofPlanePrimitive *) 0 ; - float arg2 ; SWIG_check_num_args("ofPlanePrimitive::setWidth",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPlanePrimitive::setWidth",1,"ofPlanePrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPlanePrimitive::setWidth",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPlanePrimitive,0))){ - SWIG_fail_ptr("PlanePrimitive_setWidth",1,SWIGTYPE_p_ofPlanePrimitive); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setWidth(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_PlanePrimitive_setHeight(lua_State* L) { int SWIG_arg = 0; ofPlanePrimitive *arg1 = (ofPlanePrimitive *) 0 ; - float arg2 ; SWIG_check_num_args("ofPlanePrimitive::setHeight",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPlanePrimitive::setHeight",1,"ofPlanePrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPlanePrimitive::setHeight",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPlanePrimitive,0))){ - SWIG_fail_ptr("PlanePrimitive_setHeight",1,SWIGTYPE_p_ofPlanePrimitive); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setHeight(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_PlanePrimitive_setColumns(lua_State* L) { int SWIG_arg = 0; ofPlanePrimitive *arg1 = (ofPlanePrimitive *) 0 ; - int arg2 ; SWIG_check_num_args("ofPlanePrimitive::setColumns",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPlanePrimitive::setColumns",1,"ofPlanePrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPlanePrimitive::setColumns",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPlanePrimitive,0))){ - SWIG_fail_ptr("PlanePrimitive_setColumns",1,SWIGTYPE_p_ofPlanePrimitive); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->setColumns(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_PlanePrimitive_setRows(lua_State* L) { int SWIG_arg = 0; ofPlanePrimitive *arg1 = (ofPlanePrimitive *) 0 ; - int arg2 ; SWIG_check_num_args("ofPlanePrimitive::setRows",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPlanePrimitive::setRows",1,"ofPlanePrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPlanePrimitive::setRows",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPlanePrimitive,0))){ - SWIG_fail_ptr("PlanePrimitive_setRows",1,SWIGTYPE_p_ofPlanePrimitive); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->setRows(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_PlanePrimitive_setResolution(lua_State* L) { int SWIG_arg = 0; - ofPlanePrimitive *arg1 = (ofPlanePrimitive *) 0 ; int arg2 ; int arg3 ; - SWIG_check_num_args("ofPlanePrimitive::setResolution",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPlanePrimitive::setResolution",1,"ofPlanePrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPlanePrimitive::setResolution",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPlanePrimitive::setResolution",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPlanePrimitive,0))){ - SWIG_fail_ptr("PlanePrimitive_setResolution",1,SWIGTYPE_p_ofPlanePrimitive); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); (arg1)->setResolution(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_PlanePrimitive_setMode(lua_State* L) { int SWIG_arg = 0; ofPlanePrimitive *arg1 = (ofPlanePrimitive *) 0 ; - ofPrimitiveMode arg2 ; SWIG_check_num_args("ofPlanePrimitive::setMode",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPlanePrimitive::setMode",1,"ofPlanePrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPlanePrimitive::setMode",2,"ofPrimitiveMode"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPlanePrimitive,0))){ - SWIG_fail_ptr("PlanePrimitive_setMode",1,SWIGTYPE_p_ofPlanePrimitive); } arg2 = (ofPrimitiveMode)(int)lua_tonumber(L, 2); - (arg1)->setMode(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_PlanePrimitive_getNumColumns(lua_State* L) { int SWIG_arg = 0; - ofPlanePrimitive *arg1 = (ofPlanePrimitive *) 0 ; int result; SWIG_check_num_args("ofPlanePrimitive::getNumColumns",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPlanePrimitive::getNumColumns",1,"ofPlanePrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPlanePrimitive,0))){ - SWIG_fail_ptr("PlanePrimitive_getNumColumns",1,SWIGTYPE_p_ofPlanePrimitive); } - result = (int)((ofPlanePrimitive const *)arg1)->getNumColumns(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_PlanePrimitive_getNumRows(lua_State* L) { int SWIG_arg = 0; ofPlanePrimitive *arg1 = (ofPlanePrimitive *) 0 ; - int result; SWIG_check_num_args("ofPlanePrimitive::getNumRows",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPlanePrimitive::getNumRows",1,"ofPlanePrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPlanePrimitive,0))){ - SWIG_fail_ptr("PlanePrimitive_getNumRows",1,SWIGTYPE_p_ofPlanePrimitive); } - result = (int)((ofPlanePrimitive const *)arg1)->getNumRows(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_PlanePrimitive_getResolution(lua_State* L) { int SWIG_arg = 0; - ofPlanePrimitive *arg1 = (ofPlanePrimitive *) 0 ; ofVec2f result; SWIG_check_num_args("ofPlanePrimitive::getResolution",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPlanePrimitive::getResolution",1,"ofPlanePrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPlanePrimitive,0))){ - SWIG_fail_ptr("PlanePrimitive_getResolution",1,SWIGTYPE_p_ofPlanePrimitive); } - result = ((ofPlanePrimitive const *)arg1)->getResolution(); { ofVec2f * resultptr = new ofVec2f((const ofVec2f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_PlanePrimitive_getWidth(lua_State* L) { int SWIG_arg = 0; ofPlanePrimitive *arg1 = (ofPlanePrimitive *) 0 ; - float result; SWIG_check_num_args("ofPlanePrimitive::getWidth",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPlanePrimitive::getWidth",1,"ofPlanePrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPlanePrimitive,0))){ - SWIG_fail_ptr("PlanePrimitive_getWidth",1,SWIGTYPE_p_ofPlanePrimitive); } - result = (float)((ofPlanePrimitive const *)arg1)->getWidth(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_PlanePrimitive_getHeight(lua_State* L) { int SWIG_arg = 0; ofPlanePrimitive *arg1 = (ofPlanePrimitive *) 0 ; - float result; SWIG_check_num_args("ofPlanePrimitive::getHeight",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPlanePrimitive::getHeight",1,"ofPlanePrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPlanePrimitive,0))){ - SWIG_fail_ptr("PlanePrimitive_getHeight",1,SWIGTYPE_p_ofPlanePrimitive); } - result = (float)((ofPlanePrimitive const *)arg1)->getHeight(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_PlanePrimitive(void *obj) { -ofPlanePrimitive *arg1 = (ofPlanePrimitive *) obj; -delete arg1; -} -static int _proxy__wrap_new_PlanePrimitive(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_PlanePrimitive); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_PlanePrimitive_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_PlanePrimitive_methods[]= { - { "set", _wrap_PlanePrimitive_set}, - { "resizeToTexture", _wrap_PlanePrimitive_resizeToTexture}, - { "setWidth", _wrap_PlanePrimitive_setWidth}, - { "setHeight", _wrap_PlanePrimitive_setHeight}, - { "setColumns", _wrap_PlanePrimitive_setColumns}, - { "setRows", _wrap_PlanePrimitive_setRows}, - { "setResolution", _wrap_PlanePrimitive_setResolution}, - { "setMode", _wrap_PlanePrimitive_setMode}, - { "getNumColumns", _wrap_PlanePrimitive_getNumColumns}, - { "getNumRows", _wrap_PlanePrimitive_getNumRows}, - { "getResolution", _wrap_PlanePrimitive_getResolution}, - { "getWidth", _wrap_PlanePrimitive_getWidth}, - { "getHeight", _wrap_PlanePrimitive_getHeight}, - {0,0} -}; -static swig_lua_method swig_PlanePrimitive_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_PlanePrimitive_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_PlanePrimitive_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_PlanePrimitive_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_PlanePrimitive_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_PlanePrimitive_Sf_SwigStatic = { - "PlanePrimitive", - swig_PlanePrimitive_Sf_SwigStatic_methods, - swig_PlanePrimitive_Sf_SwigStatic_attributes, - swig_PlanePrimitive_Sf_SwigStatic_constants, - swig_PlanePrimitive_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_PlanePrimitive_bases[] = {0,0}; -static const char *swig_PlanePrimitive_base_names[] = {"of3dPrimitive *",0}; -static swig_lua_class _wrap_class_PlanePrimitive = { "PlanePrimitive", "PlanePrimitive", &SWIGTYPE_p_ofPlanePrimitive,_proxy__wrap_new_PlanePrimitive, swig_delete_PlanePrimitive, swig_PlanePrimitive_methods, swig_PlanePrimitive_attributes, &swig_PlanePrimitive_Sf_SwigStatic, swig_PlanePrimitive_meta, swig_PlanePrimitive_bases, swig_PlanePrimitive_base_names }; - -static int _wrap_new_SpherePrimitive__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofSpherePrimitive *result = 0 ; - SWIG_check_num_args("ofSpherePrimitive::ofSpherePrimitive",0,0) result = (ofSpherePrimitive *)new ofSpherePrimitive(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofSpherePrimitive,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_SpherePrimitive__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; int arg2 ; ofPrimitiveMode arg3 ; - ofSpherePrimitive *result = 0 ; SWIG_check_num_args("ofSpherePrimitive::ofSpherePrimitive",3,3) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSpherePrimitive::ofSpherePrimitive",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSpherePrimitive::ofSpherePrimitive",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofSpherePrimitive::ofSpherePrimitive",3,"ofPrimitiveMode"); - arg1 = (float)lua_tonumber(L, 1); arg2 = (int)lua_tonumber(L, 2); arg3 = (ofPrimitiveMode)(int)lua_tonumber(L, 3); - result = (ofSpherePrimitive *)new ofSpherePrimitive(arg1,arg2,arg3); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofSpherePrimitive,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_SpherePrimitive__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; int arg2 ; - ofSpherePrimitive *result = 0 ; SWIG_check_num_args("ofSpherePrimitive::ofSpherePrimitive",2,2) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSpherePrimitive::ofSpherePrimitive",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSpherePrimitive::ofSpherePrimitive",2,"int"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (int)lua_tonumber(L, 2); result = (ofSpherePrimitive *)new ofSpherePrimitive(arg1,arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofSpherePrimitive,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_SpherePrimitive(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_SpherePrimitive__SWIG_0(L);} if (argc == 2) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_new_SpherePrimitive__SWIG_2(L);} } } if (argc == 3) { int _v; - { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_new_SpherePrimitive__SWIG_1(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SpherePrimitive'\n" - " Possible C/C++ prototypes are:\n" " ofSpherePrimitive::ofSpherePrimitive()\n" - " ofSpherePrimitive::ofSpherePrimitive(float,int,ofPrimitiveMode)\n" - " ofSpherePrimitive::ofSpherePrimitive(float,int)\n"); lua_error(L);return 0; } -static int _wrap_SpherePrimitive_set__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofSpherePrimitive *arg1 = (ofSpherePrimitive *) 0 ; float arg2 ; int arg3 ; ofPrimitiveMode arg4 ; - SWIG_check_num_args("ofSpherePrimitive::set",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSpherePrimitive::set",1,"ofSpherePrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSpherePrimitive::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofSpherePrimitive::set",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofSpherePrimitive::set",4,"ofPrimitiveMode"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSpherePrimitive,0))){ - SWIG_fail_ptr("SpherePrimitive_set",1,SWIGTYPE_p_ofSpherePrimitive); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); arg4 = (ofPrimitiveMode)(int)lua_tonumber(L, 4); (arg1)->set(arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SpherePrimitive_set__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofSpherePrimitive *arg1 = (ofSpherePrimitive *) 0 ; float arg2 ; int arg3 ; SWIG_check_num_args("ofSpherePrimitive::set",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSpherePrimitive::set",1,"ofSpherePrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSpherePrimitive::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofSpherePrimitive::set",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSpherePrimitive,0))){ - SWIG_fail_ptr("SpherePrimitive_set",1,SWIGTYPE_p_ofSpherePrimitive); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); (arg1)->set(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_SpherePrimitive_set(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofSpherePrimitive, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_SpherePrimitive_set__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofSpherePrimitive, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_SpherePrimitive_set__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SpherePrimitive_set'\n" - " Possible C/C++ prototypes are:\n" " ofSpherePrimitive::set(float,int,ofPrimitiveMode)\n" - " ofSpherePrimitive::set(float,int)\n"); lua_error(L);return 0; } -static int _wrap_SpherePrimitive_setResolution(lua_State* L) { int SWIG_arg = 0; - ofSpherePrimitive *arg1 = (ofSpherePrimitive *) 0 ; int arg2 ; SWIG_check_num_args("ofSpherePrimitive::setResolution",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSpherePrimitive::setResolution",1,"ofSpherePrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSpherePrimitive::setResolution",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSpherePrimitive,0))){ - SWIG_fail_ptr("SpherePrimitive_setResolution",1,SWIGTYPE_p_ofSpherePrimitive); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->setResolution(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SpherePrimitive_setRadius(lua_State* L) { int SWIG_arg = 0; ofSpherePrimitive *arg1 = (ofSpherePrimitive *) 0 ; - float arg2 ; SWIG_check_num_args("ofSpherePrimitive::setRadius",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSpherePrimitive::setRadius",1,"ofSpherePrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSpherePrimitive::setRadius",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSpherePrimitive,0))){ - SWIG_fail_ptr("SpherePrimitive_setRadius",1,SWIGTYPE_p_ofSpherePrimitive); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setRadius(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SpherePrimitive_setMode(lua_State* L) { int SWIG_arg = 0; ofSpherePrimitive *arg1 = (ofSpherePrimitive *) 0 ; - ofPrimitiveMode arg2 ; SWIG_check_num_args("ofSpherePrimitive::setMode",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSpherePrimitive::setMode",1,"ofSpherePrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSpherePrimitive::setMode",2,"ofPrimitiveMode"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSpherePrimitive,0))){ - SWIG_fail_ptr("SpherePrimitive_setMode",1,SWIGTYPE_p_ofSpherePrimitive); } arg2 = (ofPrimitiveMode)(int)lua_tonumber(L, 2); - (arg1)->setMode(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SpherePrimitive_getRadius(lua_State* L) { int SWIG_arg = 0; ofSpherePrimitive *arg1 = (ofSpherePrimitive *) 0 ; - float result; SWIG_check_num_args("ofSpherePrimitive::getRadius",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSpherePrimitive::getRadius",1,"ofSpherePrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSpherePrimitive,0))){ - SWIG_fail_ptr("SpherePrimitive_getRadius",1,SWIGTYPE_p_ofSpherePrimitive); } - result = (float)((ofSpherePrimitive const *)arg1)->getRadius(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SpherePrimitive_getResolution(lua_State* L) { int SWIG_arg = 0; - ofSpherePrimitive *arg1 = (ofSpherePrimitive *) 0 ; int result; SWIG_check_num_args("ofSpherePrimitive::getResolution",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSpherePrimitive::getResolution",1,"ofSpherePrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSpherePrimitive,0))){ - SWIG_fail_ptr("SpherePrimitive_getResolution",1,SWIGTYPE_p_ofSpherePrimitive); } - result = (int)((ofSpherePrimitive const *)arg1)->getResolution(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_SpherePrimitive(void *obj) { -ofSpherePrimitive *arg1 = (ofSpherePrimitive *) obj; -delete arg1; -} -static int _proxy__wrap_new_SpherePrimitive(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_SpherePrimitive); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_SpherePrimitive_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_SpherePrimitive_methods[]= { - { "set", _wrap_SpherePrimitive_set}, - { "setResolution", _wrap_SpherePrimitive_setResolution}, - { "setRadius", _wrap_SpherePrimitive_setRadius}, - { "setMode", _wrap_SpherePrimitive_setMode}, - { "getRadius", _wrap_SpherePrimitive_getRadius}, - { "getResolution", _wrap_SpherePrimitive_getResolution}, - {0,0} -}; -static swig_lua_method swig_SpherePrimitive_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_SpherePrimitive_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_SpherePrimitive_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_SpherePrimitive_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_SpherePrimitive_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_SpherePrimitive_Sf_SwigStatic = { - "SpherePrimitive", - swig_SpherePrimitive_Sf_SwigStatic_methods, - swig_SpherePrimitive_Sf_SwigStatic_attributes, - swig_SpherePrimitive_Sf_SwigStatic_constants, - swig_SpherePrimitive_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_SpherePrimitive_bases[] = {0,0}; -static const char *swig_SpherePrimitive_base_names[] = {"of3dPrimitive *",0}; -static swig_lua_class _wrap_class_SpherePrimitive = { "SpherePrimitive", "SpherePrimitive", &SWIGTYPE_p_ofSpherePrimitive,_proxy__wrap_new_SpherePrimitive, swig_delete_SpherePrimitive, swig_SpherePrimitive_methods, swig_SpherePrimitive_attributes, &swig_SpherePrimitive_Sf_SwigStatic, swig_SpherePrimitive_meta, swig_SpherePrimitive_bases, swig_SpherePrimitive_base_names }; - -static int _wrap_new_IcoSpherePrimitive__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofIcoSpherePrimitive *result = 0 ; - SWIG_check_num_args("ofIcoSpherePrimitive::ofIcoSpherePrimitive",0,0) - result = (ofIcoSpherePrimitive *)new ofIcoSpherePrimitive(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofIcoSpherePrimitive,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_IcoSpherePrimitive__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; int arg2 ; - ofIcoSpherePrimitive *result = 0 ; SWIG_check_num_args("ofIcoSpherePrimitive::ofIcoSpherePrimitive",2,2) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofIcoSpherePrimitive::ofIcoSpherePrimitive",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofIcoSpherePrimitive::ofIcoSpherePrimitive",2,"int"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (int)lua_tonumber(L, 2); result = (ofIcoSpherePrimitive *)new ofIcoSpherePrimitive(arg1,arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofIcoSpherePrimitive,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_IcoSpherePrimitive(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_IcoSpherePrimitive__SWIG_0(L);} if (argc == 2) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_new_IcoSpherePrimitive__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_IcoSpherePrimitive'\n" - " Possible C/C++ prototypes are:\n" " ofIcoSpherePrimitive::ofIcoSpherePrimitive()\n" - " ofIcoSpherePrimitive::ofIcoSpherePrimitive(float,int)\n"); lua_error(L);return 0; } -static int _wrap_IcoSpherePrimitive_set(lua_State* L) { int SWIG_arg = 0; - ofIcoSpherePrimitive *arg1 = (ofIcoSpherePrimitive *) 0 ; float arg2 ; int arg3 ; - SWIG_check_num_args("ofIcoSpherePrimitive::set",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofIcoSpherePrimitive::set",1,"ofIcoSpherePrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofIcoSpherePrimitive::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofIcoSpherePrimitive::set",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofIcoSpherePrimitive,0))){ - SWIG_fail_ptr("IcoSpherePrimitive_set",1,SWIGTYPE_p_ofIcoSpherePrimitive); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); (arg1)->set(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_IcoSpherePrimitive_setResolution(lua_State* L) { int SWIG_arg = 0; - ofIcoSpherePrimitive *arg1 = (ofIcoSpherePrimitive *) 0 ; int arg2 ; - SWIG_check_num_args("ofIcoSpherePrimitive::setResolution",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofIcoSpherePrimitive::setResolution",1,"ofIcoSpherePrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofIcoSpherePrimitive::setResolution",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofIcoSpherePrimitive,0))){ - SWIG_fail_ptr("IcoSpherePrimitive_setResolution",1,SWIGTYPE_p_ofIcoSpherePrimitive); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->setResolution(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_IcoSpherePrimitive_setRadius(lua_State* L) { int SWIG_arg = 0; - ofIcoSpherePrimitive *arg1 = (ofIcoSpherePrimitive *) 0 ; float arg2 ; - SWIG_check_num_args("ofIcoSpherePrimitive::setRadius",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofIcoSpherePrimitive::setRadius",1,"ofIcoSpherePrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofIcoSpherePrimitive::setRadius",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofIcoSpherePrimitive,0))){ - SWIG_fail_ptr("IcoSpherePrimitive_setRadius",1,SWIGTYPE_p_ofIcoSpherePrimitive); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setRadius(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_IcoSpherePrimitive_setMode(lua_State* L) { int SWIG_arg = 0; - ofIcoSpherePrimitive *arg1 = (ofIcoSpherePrimitive *) 0 ; ofPrimitiveMode arg2 ; - SWIG_check_num_args("ofIcoSpherePrimitive::setMode",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofIcoSpherePrimitive::setMode",1,"ofIcoSpherePrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofIcoSpherePrimitive::setMode",2,"ofPrimitiveMode"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofIcoSpherePrimitive,0))){ - SWIG_fail_ptr("IcoSpherePrimitive_setMode",1,SWIGTYPE_p_ofIcoSpherePrimitive); } - arg2 = (ofPrimitiveMode)(int)lua_tonumber(L, 2); (arg1)->setMode(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_IcoSpherePrimitive_getRadius(lua_State* L) { int SWIG_arg = 0; - ofIcoSpherePrimitive *arg1 = (ofIcoSpherePrimitive *) 0 ; float result; - SWIG_check_num_args("ofIcoSpherePrimitive::getRadius",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofIcoSpherePrimitive::getRadius",1,"ofIcoSpherePrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofIcoSpherePrimitive,0))){ - SWIG_fail_ptr("IcoSpherePrimitive_getRadius",1,SWIGTYPE_p_ofIcoSpherePrimitive); } - result = (float)((ofIcoSpherePrimitive const *)arg1)->getRadius(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_IcoSpherePrimitive_getResolution(lua_State* L) { int SWIG_arg = 0; - ofIcoSpherePrimitive *arg1 = (ofIcoSpherePrimitive *) 0 ; int result; - SWIG_check_num_args("ofIcoSpherePrimitive::getResolution",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofIcoSpherePrimitive::getResolution",1,"ofIcoSpherePrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofIcoSpherePrimitive,0))){ - SWIG_fail_ptr("IcoSpherePrimitive_getResolution",1,SWIGTYPE_p_ofIcoSpherePrimitive); } - result = (int)((ofIcoSpherePrimitive const *)arg1)->getResolution(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_IcoSpherePrimitive(void *obj) { -ofIcoSpherePrimitive *arg1 = (ofIcoSpherePrimitive *) obj; -delete arg1; -} -static int _proxy__wrap_new_IcoSpherePrimitive(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_IcoSpherePrimitive); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_IcoSpherePrimitive_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_IcoSpherePrimitive_methods[]= { - { "set", _wrap_IcoSpherePrimitive_set}, - { "setResolution", _wrap_IcoSpherePrimitive_setResolution}, - { "setRadius", _wrap_IcoSpherePrimitive_setRadius}, - { "setMode", _wrap_IcoSpherePrimitive_setMode}, - { "getRadius", _wrap_IcoSpherePrimitive_getRadius}, - { "getResolution", _wrap_IcoSpherePrimitive_getResolution}, - {0,0} -}; -static swig_lua_method swig_IcoSpherePrimitive_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_IcoSpherePrimitive_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_IcoSpherePrimitive_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_IcoSpherePrimitive_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_IcoSpherePrimitive_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_IcoSpherePrimitive_Sf_SwigStatic = { - "IcoSpherePrimitive", - swig_IcoSpherePrimitive_Sf_SwigStatic_methods, - swig_IcoSpherePrimitive_Sf_SwigStatic_attributes, - swig_IcoSpherePrimitive_Sf_SwigStatic_constants, - swig_IcoSpherePrimitive_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_IcoSpherePrimitive_bases[] = {0,0}; -static const char *swig_IcoSpherePrimitive_base_names[] = {"of3dPrimitive *",0}; -static swig_lua_class _wrap_class_IcoSpherePrimitive = { "IcoSpherePrimitive", "IcoSpherePrimitive", &SWIGTYPE_p_ofIcoSpherePrimitive,_proxy__wrap_new_IcoSpherePrimitive, swig_delete_IcoSpherePrimitive, swig_IcoSpherePrimitive_methods, swig_IcoSpherePrimitive_attributes, &swig_IcoSpherePrimitive_Sf_SwigStatic, swig_IcoSpherePrimitive_meta, swig_IcoSpherePrimitive_bases, swig_IcoSpherePrimitive_base_names }; - -static int _wrap_new_CylinderPrimitive__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofCylinderPrimitive *result = 0 ; - SWIG_check_num_args("ofCylinderPrimitive::ofCylinderPrimitive",0,0) result = (ofCylinderPrimitive *)new ofCylinderPrimitive(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofCylinderPrimitive,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_CylinderPrimitive__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; int arg3 ; int arg4 ; - int arg5 ; bool arg6 ; ofPrimitiveMode arg7 ; ofCylinderPrimitive *result = 0 ; - SWIG_check_num_args("ofCylinderPrimitive::ofCylinderPrimitive",7,7) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofCylinderPrimitive::ofCylinderPrimitive",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofCylinderPrimitive::ofCylinderPrimitive",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofCylinderPrimitive::ofCylinderPrimitive",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofCylinderPrimitive::ofCylinderPrimitive",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofCylinderPrimitive::ofCylinderPrimitive",5,"int"); - if(!lua_isboolean(L,6)) SWIG_fail_arg("ofCylinderPrimitive::ofCylinderPrimitive",6,"bool"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofCylinderPrimitive::ofCylinderPrimitive",7,"ofPrimitiveMode"); - arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); arg6 = (lua_toboolean(L, 6)!=0); - arg7 = (ofPrimitiveMode)(int)lua_tonumber(L, 7); - result = (ofCylinderPrimitive *)new ofCylinderPrimitive(arg1,arg2,arg3,arg4,arg5,arg6,arg7); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofCylinderPrimitive,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_CylinderPrimitive__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; int arg3 ; int arg4 ; - int arg5 ; bool arg6 ; ofCylinderPrimitive *result = 0 ; SWIG_check_num_args("ofCylinderPrimitive::ofCylinderPrimitive",6,6) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofCylinderPrimitive::ofCylinderPrimitive",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofCylinderPrimitive::ofCylinderPrimitive",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofCylinderPrimitive::ofCylinderPrimitive",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofCylinderPrimitive::ofCylinderPrimitive",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofCylinderPrimitive::ofCylinderPrimitive",5,"int"); - if(!lua_isboolean(L,6)) SWIG_fail_arg("ofCylinderPrimitive::ofCylinderPrimitive",6,"bool"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - arg5 = (int)lua_tonumber(L, 5); arg6 = (lua_toboolean(L, 6)!=0); - result = (ofCylinderPrimitive *)new ofCylinderPrimitive(arg1,arg2,arg3,arg4,arg5,arg6); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofCylinderPrimitive,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_CylinderPrimitive__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; int arg3 ; int arg4 ; - int arg5 ; ofCylinderPrimitive *result = 0 ; SWIG_check_num_args("ofCylinderPrimitive::ofCylinderPrimitive",5,5) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofCylinderPrimitive::ofCylinderPrimitive",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofCylinderPrimitive::ofCylinderPrimitive",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofCylinderPrimitive::ofCylinderPrimitive",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofCylinderPrimitive::ofCylinderPrimitive",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofCylinderPrimitive::ofCylinderPrimitive",5,"int"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - arg5 = (int)lua_tonumber(L, 5); result = (ofCylinderPrimitive *)new ofCylinderPrimitive(arg1,arg2,arg3,arg4,arg5); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofCylinderPrimitive,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_CylinderPrimitive__SWIG_4(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; int arg3 ; int arg4 ; - ofCylinderPrimitive *result = 0 ; SWIG_check_num_args("ofCylinderPrimitive::ofCylinderPrimitive",4,4) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofCylinderPrimitive::ofCylinderPrimitive",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofCylinderPrimitive::ofCylinderPrimitive",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofCylinderPrimitive::ofCylinderPrimitive",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofCylinderPrimitive::ofCylinderPrimitive",4,"int"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - result = (ofCylinderPrimitive *)new ofCylinderPrimitive(arg1,arg2,arg3,arg4); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofCylinderPrimitive,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_CylinderPrimitive(lua_State* L) { int argc; int argv[8]={ 1,2,3,4,5,6,7,8} ; argc = lua_gettop(L); - if (argc == 0) { return _wrap_new_CylinderPrimitive__SWIG_0(L);} if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_new_CylinderPrimitive__SWIG_4(L);} } } } } - if (argc == 5) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_new_CylinderPrimitive__SWIG_3(L);} } } } } } - if (argc == 6) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isboolean(L,argv[5]); } if (_v) { - return _wrap_new_CylinderPrimitive__SWIG_2(L);} } } } } } } if (argc == 7) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isboolean(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { - return _wrap_new_CylinderPrimitive__SWIG_1(L);} } } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_CylinderPrimitive'\n" - " Possible C/C++ prototypes are:\n" " ofCylinderPrimitive::ofCylinderPrimitive()\n" - " ofCylinderPrimitive::ofCylinderPrimitive(float,float,int,int,int,bool,ofPrimitiveMode)\n" - " ofCylinderPrimitive::ofCylinderPrimitive(float,float,int,int,int,bool)\n" - " ofCylinderPrimitive::ofCylinderPrimitive(float,float,int,int,int)\n" - " ofCylinderPrimitive::ofCylinderPrimitive(float,float,int,int)\n"); lua_error(L);return 0; } -static int _wrap_CylinderPrimitive_set__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; float arg2 ; float arg3 ; int arg4 ; int arg5 ; int arg6 ; bool arg7 ; - ofPrimitiveMode arg8 ; SWIG_check_num_args("ofCylinderPrimitive::set",8,8) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::set",1,"ofCylinderPrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofCylinderPrimitive::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofCylinderPrimitive::set",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofCylinderPrimitive::set",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofCylinderPrimitive::set",5,"int"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofCylinderPrimitive::set",6,"int"); - if(!lua_isboolean(L,7)) SWIG_fail_arg("ofCylinderPrimitive::set",7,"bool"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofCylinderPrimitive::set",8,"ofPrimitiveMode"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ - SWIG_fail_ptr("CylinderPrimitive_set",1,SWIGTYPE_p_ofCylinderPrimitive); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); - arg6 = (int)lua_tonumber(L, 6); arg7 = (lua_toboolean(L, 7)!=0); arg8 = (ofPrimitiveMode)(int)lua_tonumber(L, 8); - (arg1)->set(arg2,arg3,arg4,arg5,arg6,arg7,arg8); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_CylinderPrimitive_set__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; float arg2 ; float arg3 ; int arg4 ; int arg5 ; int arg6 ; bool arg7 ; - SWIG_check_num_args("ofCylinderPrimitive::set",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::set",1,"ofCylinderPrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofCylinderPrimitive::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofCylinderPrimitive::set",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofCylinderPrimitive::set",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofCylinderPrimitive::set",5,"int"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofCylinderPrimitive::set",6,"int"); - if(!lua_isboolean(L,7)) SWIG_fail_arg("ofCylinderPrimitive::set",7,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ - SWIG_fail_ptr("CylinderPrimitive_set",1,SWIGTYPE_p_ofCylinderPrimitive); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); - arg6 = (int)lua_tonumber(L, 6); arg7 = (lua_toboolean(L, 7)!=0); (arg1)->set(arg2,arg3,arg4,arg5,arg6,arg7); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_CylinderPrimitive_set__SWIG_2(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; float arg2 ; float arg3 ; int arg4 ; int arg5 ; int arg6 ; - SWIG_check_num_args("ofCylinderPrimitive::set",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::set",1,"ofCylinderPrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofCylinderPrimitive::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofCylinderPrimitive::set",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofCylinderPrimitive::set",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofCylinderPrimitive::set",5,"int"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofCylinderPrimitive::set",6,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ - SWIG_fail_ptr("CylinderPrimitive_set",1,SWIGTYPE_p_ofCylinderPrimitive); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); - arg6 = (int)lua_tonumber(L, 6); (arg1)->set(arg2,arg3,arg4,arg5,arg6); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_CylinderPrimitive_set__SWIG_3(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; float arg2 ; float arg3 ; int arg4 ; int arg5 ; - SWIG_check_num_args("ofCylinderPrimitive::set",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::set",1,"ofCylinderPrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofCylinderPrimitive::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofCylinderPrimitive::set",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofCylinderPrimitive::set",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofCylinderPrimitive::set",5,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ - SWIG_fail_ptr("CylinderPrimitive_set",1,SWIGTYPE_p_ofCylinderPrimitive); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); - (arg1)->set(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_CylinderPrimitive_set__SWIG_4(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; float arg2 ; float arg3 ; bool arg4 ; - SWIG_check_num_args("ofCylinderPrimitive::set",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::set",1,"ofCylinderPrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofCylinderPrimitive::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofCylinderPrimitive::set",3,"float"); - if(!lua_isboolean(L,4)) SWIG_fail_arg("ofCylinderPrimitive::set",4,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ - SWIG_fail_ptr("CylinderPrimitive_set",1,SWIGTYPE_p_ofCylinderPrimitive); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (lua_toboolean(L, 4)!=0); (arg1)->set(arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_CylinderPrimitive_set__SWIG_5(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofCylinderPrimitive::set",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::set",1,"ofCylinderPrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofCylinderPrimitive::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofCylinderPrimitive::set",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ - SWIG_fail_ptr("CylinderPrimitive_set",1,SWIGTYPE_p_ofCylinderPrimitive); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->set(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_CylinderPrimitive_set(lua_State* L) { int argc; int argv[9]={ 1,2,3,4,5,6,7,8,9} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCylinderPrimitive, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_CylinderPrimitive_set__SWIG_5(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCylinderPrimitive, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isboolean(L,argv[3]); } if (_v) { return _wrap_CylinderPrimitive_set__SWIG_4(L);} } } } } - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCylinderPrimitive, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_CylinderPrimitive_set__SWIG_3(L);} } } } } } if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCylinderPrimitive, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { return _wrap_CylinderPrimitive_set__SWIG_2(L);} } } } } } } - if (argc == 7) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCylinderPrimitive, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isboolean(L,argv[6]); } if (_v) { - return _wrap_CylinderPrimitive_set__SWIG_1(L);} } } } } } } } if (argc == 8) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCylinderPrimitive, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isboolean(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { return _wrap_CylinderPrimitive_set__SWIG_0(L);} } } } } } } - } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'CylinderPrimitive_set'\n" - " Possible C/C++ prototypes are:\n" " ofCylinderPrimitive::set(float,float,int,int,int,bool,ofPrimitiveMode)\n" - " ofCylinderPrimitive::set(float,float,int,int,int,bool)\n" " ofCylinderPrimitive::set(float,float,int,int,int)\n" - " ofCylinderPrimitive::set(float,float,int,int)\n" " ofCylinderPrimitive::set(float,float,bool)\n" - " ofCylinderPrimitive::set(float,float)\n"); lua_error(L);return 0; } -static int _wrap_CylinderPrimitive_setRadius(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; float arg2 ; SWIG_check_num_args("ofCylinderPrimitive::setRadius",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::setRadius",1,"ofCylinderPrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofCylinderPrimitive::setRadius",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ - SWIG_fail_ptr("CylinderPrimitive_setRadius",1,SWIGTYPE_p_ofCylinderPrimitive); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setRadius(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_CylinderPrimitive_setHeight(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; float arg2 ; SWIG_check_num_args("ofCylinderPrimitive::setHeight",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::setHeight",1,"ofCylinderPrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofCylinderPrimitive::setHeight",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ - SWIG_fail_ptr("CylinderPrimitive_setHeight",1,SWIGTYPE_p_ofCylinderPrimitive); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setHeight(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_CylinderPrimitive_setCapped(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; bool arg2 ; SWIG_check_num_args("ofCylinderPrimitive::setCapped",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::setCapped",1,"ofCylinderPrimitive *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofCylinderPrimitive::setCapped",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ - SWIG_fail_ptr("CylinderPrimitive_setCapped",1,SWIGTYPE_p_ofCylinderPrimitive); } arg2 = (lua_toboolean(L, 2)!=0); - (arg1)->setCapped(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_CylinderPrimitive_setResolutionRadius(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; int arg2 ; - SWIG_check_num_args("ofCylinderPrimitive::setResolutionRadius",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::setResolutionRadius",1,"ofCylinderPrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofCylinderPrimitive::setResolutionRadius",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ - SWIG_fail_ptr("CylinderPrimitive_setResolutionRadius",1,SWIGTYPE_p_ofCylinderPrimitive); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->setResolutionRadius(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_CylinderPrimitive_setResolutionHeight(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; int arg2 ; - SWIG_check_num_args("ofCylinderPrimitive::setResolutionHeight",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::setResolutionHeight",1,"ofCylinderPrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofCylinderPrimitive::setResolutionHeight",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ - SWIG_fail_ptr("CylinderPrimitive_setResolutionHeight",1,SWIGTYPE_p_ofCylinderPrimitive); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->setResolutionHeight(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_CylinderPrimitive_setResolutionCap(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; int arg2 ; - SWIG_check_num_args("ofCylinderPrimitive::setResolutionCap",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::setResolutionCap",1,"ofCylinderPrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofCylinderPrimitive::setResolutionCap",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ - SWIG_fail_ptr("CylinderPrimitive_setResolutionCap",1,SWIGTYPE_p_ofCylinderPrimitive); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->setResolutionCap(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_CylinderPrimitive_setResolution__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; int arg2 ; int arg3 ; int arg4 ; - SWIG_check_num_args("ofCylinderPrimitive::setResolution",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::setResolution",1,"ofCylinderPrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofCylinderPrimitive::setResolution",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofCylinderPrimitive::setResolution",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofCylinderPrimitive::setResolution",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ - SWIG_fail_ptr("CylinderPrimitive_setResolution",1,SWIGTYPE_p_ofCylinderPrimitive); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); (arg1)->setResolution(arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_CylinderPrimitive_setResolution__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; int arg2 ; int arg3 ; - SWIG_check_num_args("ofCylinderPrimitive::setResolution",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::setResolution",1,"ofCylinderPrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofCylinderPrimitive::setResolution",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofCylinderPrimitive::setResolution",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ - SWIG_fail_ptr("CylinderPrimitive_setResolution",1,SWIGTYPE_p_ofCylinderPrimitive); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); (arg1)->setResolution(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_CylinderPrimitive_setResolution(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCylinderPrimitive, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_CylinderPrimitive_setResolution__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCylinderPrimitive, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_CylinderPrimitive_setResolution__SWIG_0(L);} } } - } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'CylinderPrimitive_setResolution'\n" - " Possible C/C++ prototypes are:\n" " ofCylinderPrimitive::setResolution(int,int,int)\n" - " ofCylinderPrimitive::setResolution(int,int)\n"); lua_error(L);return 0; } -static int _wrap_CylinderPrimitive_setMode(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; ofPrimitiveMode arg2 ; - SWIG_check_num_args("ofCylinderPrimitive::setMode",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::setMode",1,"ofCylinderPrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofCylinderPrimitive::setMode",2,"ofPrimitiveMode"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ - SWIG_fail_ptr("CylinderPrimitive_setMode",1,SWIGTYPE_p_ofCylinderPrimitive); } - arg2 = (ofPrimitiveMode)(int)lua_tonumber(L, 2); (arg1)->setMode(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_CylinderPrimitive_setTopCapColor(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; ofColor arg2 ; ofColor *argp2 ; - SWIG_check_num_args("ofCylinderPrimitive::setTopCapColor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::setTopCapColor",1,"ofCylinderPrimitive *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofCylinderPrimitive::setTopCapColor",2,"ofColor"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ - SWIG_fail_ptr("CylinderPrimitive_setTopCapColor",1,SWIGTYPE_p_ofCylinderPrimitive); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("CylinderPrimitive_setTopCapColor",2,SWIGTYPE_p_ofColor_T_unsigned_char_t); } arg2 = *argp2; - (arg1)->setTopCapColor(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_CylinderPrimitive_setCylinderColor(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; ofColor arg2 ; ofColor *argp2 ; - SWIG_check_num_args("ofCylinderPrimitive::setCylinderColor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::setCylinderColor",1,"ofCylinderPrimitive *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofCylinderPrimitive::setCylinderColor",2,"ofColor"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ - SWIG_fail_ptr("CylinderPrimitive_setCylinderColor",1,SWIGTYPE_p_ofCylinderPrimitive); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("CylinderPrimitive_setCylinderColor",2,SWIGTYPE_p_ofColor_T_unsigned_char_t); } arg2 = *argp2; - (arg1)->setCylinderColor(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_CylinderPrimitive_setBottomCapColor(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; ofColor arg2 ; ofColor *argp2 ; - SWIG_check_num_args("ofCylinderPrimitive::setBottomCapColor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::setBottomCapColor",1,"ofCylinderPrimitive *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofCylinderPrimitive::setBottomCapColor",2,"ofColor"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ - SWIG_fail_ptr("CylinderPrimitive_setBottomCapColor",1,SWIGTYPE_p_ofCylinderPrimitive); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("CylinderPrimitive_setBottomCapColor",2,SWIGTYPE_p_ofColor_T_unsigned_char_t); } arg2 = *argp2; - (arg1)->setBottomCapColor(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_CylinderPrimitive_getTopCapIndices(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; SwigValueWrapper< std::vector< unsigned short > > result; - SWIG_check_num_args("ofCylinderPrimitive::getTopCapIndices",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::getTopCapIndices",1,"ofCylinderPrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ - SWIG_fail_ptr("CylinderPrimitive_getTopCapIndices",1,SWIGTYPE_p_ofCylinderPrimitive); } - result = ((ofCylinderPrimitive const *)arg1)->getTopCapIndices(); { - std::vector< ofIndexType > * resultptr = new std::vector< ofIndexType >((const std::vector< ofIndexType > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_unsigned_short_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_CylinderPrimitive_getTopCapMesh(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; ofMesh result; - SWIG_check_num_args("ofCylinderPrimitive::getTopCapMesh",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::getTopCapMesh",1,"ofCylinderPrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ - SWIG_fail_ptr("CylinderPrimitive_getTopCapMesh",1,SWIGTYPE_p_ofCylinderPrimitive); } - result = ((ofCylinderPrimitive const *)arg1)->getTopCapMesh(); { ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_CylinderPrimitive_getCylinderIndices(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; SwigValueWrapper< std::vector< unsigned short > > result; - SWIG_check_num_args("ofCylinderPrimitive::getCylinderIndices",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::getCylinderIndices",1,"ofCylinderPrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ - SWIG_fail_ptr("CylinderPrimitive_getCylinderIndices",1,SWIGTYPE_p_ofCylinderPrimitive); } - result = ((ofCylinderPrimitive const *)arg1)->getCylinderIndices(); { - std::vector< ofIndexType > * resultptr = new std::vector< ofIndexType >((const std::vector< ofIndexType > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_unsigned_short_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_CylinderPrimitive_getCylinderMesh(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; ofMesh result; - SWIG_check_num_args("ofCylinderPrimitive::getCylinderMesh",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::getCylinderMesh",1,"ofCylinderPrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ - SWIG_fail_ptr("CylinderPrimitive_getCylinderMesh",1,SWIGTYPE_p_ofCylinderPrimitive); } - result = ((ofCylinderPrimitive const *)arg1)->getCylinderMesh(); { ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_CylinderPrimitive_getBottomCapIndices(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; SwigValueWrapper< std::vector< unsigned short > > result; - SWIG_check_num_args("ofCylinderPrimitive::getBottomCapIndices",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::getBottomCapIndices",1,"ofCylinderPrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ - SWIG_fail_ptr("CylinderPrimitive_getBottomCapIndices",1,SWIGTYPE_p_ofCylinderPrimitive); } - result = ((ofCylinderPrimitive const *)arg1)->getBottomCapIndices(); { - std::vector< ofIndexType > * resultptr = new std::vector< ofIndexType >((const std::vector< ofIndexType > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_unsigned_short_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_CylinderPrimitive_getBottomCapMesh(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; ofMesh result; - SWIG_check_num_args("ofCylinderPrimitive::getBottomCapMesh",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::getBottomCapMesh",1,"ofCylinderPrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ - SWIG_fail_ptr("CylinderPrimitive_getBottomCapMesh",1,SWIGTYPE_p_ofCylinderPrimitive); } - result = ((ofCylinderPrimitive const *)arg1)->getBottomCapMesh(); { ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_CylinderPrimitive_getResolutionRadius(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; int result; - SWIG_check_num_args("ofCylinderPrimitive::getResolutionRadius",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::getResolutionRadius",1,"ofCylinderPrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ - SWIG_fail_ptr("CylinderPrimitive_getResolutionRadius",1,SWIGTYPE_p_ofCylinderPrimitive); } - result = (int)((ofCylinderPrimitive const *)arg1)->getResolutionRadius(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_CylinderPrimitive_getResolutionHeight(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; int result; - SWIG_check_num_args("ofCylinderPrimitive::getResolutionHeight",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::getResolutionHeight",1,"ofCylinderPrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ - SWIG_fail_ptr("CylinderPrimitive_getResolutionHeight",1,SWIGTYPE_p_ofCylinderPrimitive); } - result = (int)((ofCylinderPrimitive const *)arg1)->getResolutionHeight(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_CylinderPrimitive_getResolutionCap(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; int result; - SWIG_check_num_args("ofCylinderPrimitive::getResolutionCap",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::getResolutionCap",1,"ofCylinderPrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ - SWIG_fail_ptr("CylinderPrimitive_getResolutionCap",1,SWIGTYPE_p_ofCylinderPrimitive); } - result = (int)((ofCylinderPrimitive const *)arg1)->getResolutionCap(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_CylinderPrimitive_getResolution(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; ofVec3f result; - SWIG_check_num_args("ofCylinderPrimitive::getResolution",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::getResolution",1,"ofCylinderPrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ - SWIG_fail_ptr("CylinderPrimitive_getResolution",1,SWIGTYPE_p_ofCylinderPrimitive); } - result = ((ofCylinderPrimitive const *)arg1)->getResolution(); { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_CylinderPrimitive_getHeight(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; float result; - SWIG_check_num_args("ofCylinderPrimitive::getHeight",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::getHeight",1,"ofCylinderPrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ - SWIG_fail_ptr("CylinderPrimitive_getHeight",1,SWIGTYPE_p_ofCylinderPrimitive); } - result = (float)((ofCylinderPrimitive const *)arg1)->getHeight(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_CylinderPrimitive_getRadius(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; float result; - SWIG_check_num_args("ofCylinderPrimitive::getRadius",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::getRadius",1,"ofCylinderPrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ - SWIG_fail_ptr("CylinderPrimitive_getRadius",1,SWIGTYPE_p_ofCylinderPrimitive); } - result = (float)((ofCylinderPrimitive const *)arg1)->getRadius(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_CylinderPrimitive_getCapped(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; bool result; SWIG_check_num_args("ofCylinderPrimitive::getCapped",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::getCapped",1,"ofCylinderPrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ - SWIG_fail_ptr("CylinderPrimitive_getCapped",1,SWIGTYPE_p_ofCylinderPrimitive); } - result = (bool)((ofCylinderPrimitive const *)arg1)->getCapped(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_CylinderPrimitive(void *obj) { -ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) obj; -delete arg1; -} -static int _proxy__wrap_new_CylinderPrimitive(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_CylinderPrimitive); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_CylinderPrimitive_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_CylinderPrimitive_methods[]= { - { "set", _wrap_CylinderPrimitive_set}, - { "setRadius", _wrap_CylinderPrimitive_setRadius}, - { "setHeight", _wrap_CylinderPrimitive_setHeight}, - { "setCapped", _wrap_CylinderPrimitive_setCapped}, - { "setResolutionRadius", _wrap_CylinderPrimitive_setResolutionRadius}, - { "setResolutionHeight", _wrap_CylinderPrimitive_setResolutionHeight}, - { "setResolutionCap", _wrap_CylinderPrimitive_setResolutionCap}, - { "setResolution", _wrap_CylinderPrimitive_setResolution}, - { "setMode", _wrap_CylinderPrimitive_setMode}, - { "setTopCapColor", _wrap_CylinderPrimitive_setTopCapColor}, - { "setCylinderColor", _wrap_CylinderPrimitive_setCylinderColor}, - { "setBottomCapColor", _wrap_CylinderPrimitive_setBottomCapColor}, - { "getTopCapIndices", _wrap_CylinderPrimitive_getTopCapIndices}, - { "getTopCapMesh", _wrap_CylinderPrimitive_getTopCapMesh}, - { "getCylinderIndices", _wrap_CylinderPrimitive_getCylinderIndices}, - { "getCylinderMesh", _wrap_CylinderPrimitive_getCylinderMesh}, - { "getBottomCapIndices", _wrap_CylinderPrimitive_getBottomCapIndices}, - { "getBottomCapMesh", _wrap_CylinderPrimitive_getBottomCapMesh}, - { "getResolutionRadius", _wrap_CylinderPrimitive_getResolutionRadius}, - { "getResolutionHeight", _wrap_CylinderPrimitive_getResolutionHeight}, - { "getResolutionCap", _wrap_CylinderPrimitive_getResolutionCap}, - { "getResolution", _wrap_CylinderPrimitive_getResolution}, - { "getHeight", _wrap_CylinderPrimitive_getHeight}, - { "getRadius", _wrap_CylinderPrimitive_getRadius}, - { "getCapped", _wrap_CylinderPrimitive_getCapped}, - {0,0} -}; -static swig_lua_method swig_CylinderPrimitive_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_CylinderPrimitive_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_CylinderPrimitive_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_CylinderPrimitive_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_CylinderPrimitive_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_CylinderPrimitive_Sf_SwigStatic = { - "CylinderPrimitive", - swig_CylinderPrimitive_Sf_SwigStatic_methods, - swig_CylinderPrimitive_Sf_SwigStatic_attributes, - swig_CylinderPrimitive_Sf_SwigStatic_constants, - swig_CylinderPrimitive_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_CylinderPrimitive_bases[] = {0,0}; -static const char *swig_CylinderPrimitive_base_names[] = {"of3dPrimitive *",0}; -static swig_lua_class _wrap_class_CylinderPrimitive = { "CylinderPrimitive", "CylinderPrimitive", &SWIGTYPE_p_ofCylinderPrimitive,_proxy__wrap_new_CylinderPrimitive, swig_delete_CylinderPrimitive, swig_CylinderPrimitive_methods, swig_CylinderPrimitive_attributes, &swig_CylinderPrimitive_Sf_SwigStatic, swig_CylinderPrimitive_meta, swig_CylinderPrimitive_bases, swig_CylinderPrimitive_base_names }; - -static int _wrap_new_ConePrimitive__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofConePrimitive *result = 0 ; - SWIG_check_num_args("ofConePrimitive::ofConePrimitive",0,0) result = (ofConePrimitive *)new ofConePrimitive(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofConePrimitive,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_ConePrimitive__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; int arg3 ; int arg4 ; - int arg5 ; ofPrimitiveMode arg6 ; ofConePrimitive *result = 0 ; SWIG_check_num_args("ofConePrimitive::ofConePrimitive",6,6) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofConePrimitive::ofConePrimitive",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofConePrimitive::ofConePrimitive",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofConePrimitive::ofConePrimitive",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofConePrimitive::ofConePrimitive",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofConePrimitive::ofConePrimitive",5,"int"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofConePrimitive::ofConePrimitive",6,"ofPrimitiveMode"); - arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); arg6 = (ofPrimitiveMode)(int)lua_tonumber(L, 6); - result = (ofConePrimitive *)new ofConePrimitive(arg1,arg2,arg3,arg4,arg5,arg6); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofConePrimitive,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_ConePrimitive__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; int arg3 ; int arg4 ; - int arg5 ; ofConePrimitive *result = 0 ; SWIG_check_num_args("ofConePrimitive::ofConePrimitive",5,5) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofConePrimitive::ofConePrimitive",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofConePrimitive::ofConePrimitive",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofConePrimitive::ofConePrimitive",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofConePrimitive::ofConePrimitive",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofConePrimitive::ofConePrimitive",5,"int"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - arg5 = (int)lua_tonumber(L, 5); result = (ofConePrimitive *)new ofConePrimitive(arg1,arg2,arg3,arg4,arg5); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofConePrimitive,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_ConePrimitive__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; int arg3 ; int arg4 ; - ofConePrimitive *result = 0 ; SWIG_check_num_args("ofConePrimitive::ofConePrimitive",4,4) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofConePrimitive::ofConePrimitive",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofConePrimitive::ofConePrimitive",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofConePrimitive::ofConePrimitive",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofConePrimitive::ofConePrimitive",4,"int"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - result = (ofConePrimitive *)new ofConePrimitive(arg1,arg2,arg3,arg4); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofConePrimitive,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_ConePrimitive(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); - if (argc == 0) { return _wrap_new_ConePrimitive__SWIG_0(L);} if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_new_ConePrimitive__SWIG_3(L);} } } } } if (argc == 5) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_new_ConePrimitive__SWIG_2(L);} } } } } } - if (argc == 6) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { - return _wrap_new_ConePrimitive__SWIG_1(L);} } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_ConePrimitive'\n" " Possible C/C++ prototypes are:\n" - " ofConePrimitive::ofConePrimitive()\n" " ofConePrimitive::ofConePrimitive(float,float,int,int,int,ofPrimitiveMode)\n" - " ofConePrimitive::ofConePrimitive(float,float,int,int,int)\n" - " ofConePrimitive::ofConePrimitive(float,float,int,int)\n"); lua_error(L);return 0; } -static int _wrap_ConePrimitive_set__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofConePrimitive *arg1 = (ofConePrimitive *) 0 ; - float arg2 ; float arg3 ; int arg4 ; int arg5 ; int arg6 ; ofPrimitiveMode arg7 ; - SWIG_check_num_args("ofConePrimitive::set",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofConePrimitive::set",1,"ofConePrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofConePrimitive::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofConePrimitive::set",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofConePrimitive::set",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofConePrimitive::set",5,"int"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofConePrimitive::set",6,"int"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofConePrimitive::set",7,"ofPrimitiveMode"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofConePrimitive,0))){ - SWIG_fail_ptr("ConePrimitive_set",1,SWIGTYPE_p_ofConePrimitive); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); - arg6 = (int)lua_tonumber(L, 6); arg7 = (ofPrimitiveMode)(int)lua_tonumber(L, 7); (arg1)->set(arg2,arg3,arg4,arg5,arg6,arg7); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ConePrimitive_set__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofConePrimitive *arg1 = (ofConePrimitive *) 0 ; - float arg2 ; float arg3 ; int arg4 ; int arg5 ; int arg6 ; SWIG_check_num_args("ofConePrimitive::set",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofConePrimitive::set",1,"ofConePrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofConePrimitive::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofConePrimitive::set",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofConePrimitive::set",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofConePrimitive::set",5,"int"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofConePrimitive::set",6,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofConePrimitive,0))){ - SWIG_fail_ptr("ConePrimitive_set",1,SWIGTYPE_p_ofConePrimitive); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); - arg6 = (int)lua_tonumber(L, 6); (arg1)->set(arg2,arg3,arg4,arg5,arg6); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ConePrimitive_set__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofConePrimitive *arg1 = (ofConePrimitive *) 0 ; - float arg2 ; float arg3 ; int arg4 ; int arg5 ; SWIG_check_num_args("ofConePrimitive::set",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofConePrimitive::set",1,"ofConePrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofConePrimitive::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofConePrimitive::set",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofConePrimitive::set",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofConePrimitive::set",5,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofConePrimitive,0))){ - SWIG_fail_ptr("ConePrimitive_set",1,SWIGTYPE_p_ofConePrimitive); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); - (arg1)->set(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ConePrimitive_set__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofConePrimitive *arg1 = (ofConePrimitive *) 0 ; - float arg2 ; float arg3 ; SWIG_check_num_args("ofConePrimitive::set",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofConePrimitive::set",1,"ofConePrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofConePrimitive::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofConePrimitive::set",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofConePrimitive,0))){ - SWIG_fail_ptr("ConePrimitive_set",1,SWIGTYPE_p_ofConePrimitive); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->set(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ConePrimitive_set(lua_State* L) { int argc; int argv[8]={ 1,2,3,4,5,6,7,8} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofConePrimitive, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_ConePrimitive_set__SWIG_3(L);} } } } if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofConePrimitive, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_ConePrimitive_set__SWIG_2(L);} } } } } } if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofConePrimitive, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { return _wrap_ConePrimitive_set__SWIG_1(L);} } } } } } } - if (argc == 7) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofConePrimitive, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { - return _wrap_ConePrimitive_set__SWIG_0(L);} } } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ConePrimitive_set'\n" " Possible C/C++ prototypes are:\n" - " ofConePrimitive::set(float,float,int,int,int,ofPrimitiveMode)\n" " ofConePrimitive::set(float,float,int,int,int)\n" - " ofConePrimitive::set(float,float,int,int)\n" " ofConePrimitive::set(float,float)\n"); lua_error(L);return 0; } -static int _wrap_ConePrimitive_setResolutionRadius(lua_State* L) { int SWIG_arg = 0; - ofConePrimitive *arg1 = (ofConePrimitive *) 0 ; int arg2 ; SWIG_check_num_args("ofConePrimitive::setResolutionRadius",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofConePrimitive::setResolutionRadius",1,"ofConePrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofConePrimitive::setResolutionRadius",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofConePrimitive,0))){ - SWIG_fail_ptr("ConePrimitive_setResolutionRadius",1,SWIGTYPE_p_ofConePrimitive); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->setResolutionRadius(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ConePrimitive_setResolutionHeight(lua_State* L) { int SWIG_arg = 0; - ofConePrimitive *arg1 = (ofConePrimitive *) 0 ; int arg2 ; SWIG_check_num_args("ofConePrimitive::setResolutionHeight",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofConePrimitive::setResolutionHeight",1,"ofConePrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofConePrimitive::setResolutionHeight",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofConePrimitive,0))){ - SWIG_fail_ptr("ConePrimitive_setResolutionHeight",1,SWIGTYPE_p_ofConePrimitive); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->setResolutionHeight(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ConePrimitive_setResolutionCap(lua_State* L) { int SWIG_arg = 0; - ofConePrimitive *arg1 = (ofConePrimitive *) 0 ; int arg2 ; SWIG_check_num_args("ofConePrimitive::setResolutionCap",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofConePrimitive::setResolutionCap",1,"ofConePrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofConePrimitive::setResolutionCap",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofConePrimitive,0))){ - SWIG_fail_ptr("ConePrimitive_setResolutionCap",1,SWIGTYPE_p_ofConePrimitive); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->setResolutionCap(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ConePrimitive_setResolution(lua_State* L) { int SWIG_arg = 0; ofConePrimitive *arg1 = (ofConePrimitive *) 0 ; - int arg2 ; int arg3 ; int arg4 ; SWIG_check_num_args("ofConePrimitive::setResolution",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofConePrimitive::setResolution",1,"ofConePrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofConePrimitive::setResolution",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofConePrimitive::setResolution",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofConePrimitive::setResolution",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofConePrimitive,0))){ - SWIG_fail_ptr("ConePrimitive_setResolution",1,SWIGTYPE_p_ofConePrimitive); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); (arg1)->setResolution(arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ConePrimitive_setMode(lua_State* L) { int SWIG_arg = 0; ofConePrimitive *arg1 = (ofConePrimitive *) 0 ; - ofPrimitiveMode arg2 ; SWIG_check_num_args("ofConePrimitive::setMode",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofConePrimitive::setMode",1,"ofConePrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofConePrimitive::setMode",2,"ofPrimitiveMode"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofConePrimitive,0))){ - SWIG_fail_ptr("ConePrimitive_setMode",1,SWIGTYPE_p_ofConePrimitive); } arg2 = (ofPrimitiveMode)(int)lua_tonumber(L, 2); - (arg1)->setMode(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ConePrimitive_setRadius(lua_State* L) { int SWIG_arg = 0; ofConePrimitive *arg1 = (ofConePrimitive *) 0 ; - float arg2 ; SWIG_check_num_args("ofConePrimitive::setRadius",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofConePrimitive::setRadius",1,"ofConePrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofConePrimitive::setRadius",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofConePrimitive,0))){ - SWIG_fail_ptr("ConePrimitive_setRadius",1,SWIGTYPE_p_ofConePrimitive); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setRadius(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ConePrimitive_setHeight(lua_State* L) { int SWIG_arg = 0; ofConePrimitive *arg1 = (ofConePrimitive *) 0 ; - float arg2 ; SWIG_check_num_args("ofConePrimitive::setHeight",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofConePrimitive::setHeight",1,"ofConePrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofConePrimitive::setHeight",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofConePrimitive,0))){ - SWIG_fail_ptr("ConePrimitive_setHeight",1,SWIGTYPE_p_ofConePrimitive); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setHeight(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ConePrimitive_setTopColor(lua_State* L) { int SWIG_arg = 0; ofConePrimitive *arg1 = (ofConePrimitive *) 0 ; - ofColor arg2 ; ofColor *argp2 ; SWIG_check_num_args("ofConePrimitive::setTopColor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofConePrimitive::setTopColor",1,"ofConePrimitive *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofConePrimitive::setTopColor",2,"ofColor"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofConePrimitive,0))){ - SWIG_fail_ptr("ConePrimitive_setTopColor",1,SWIGTYPE_p_ofConePrimitive); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("ConePrimitive_setTopColor",2,SWIGTYPE_p_ofColor_T_unsigned_char_t); } arg2 = *argp2; - (arg1)->setTopColor(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ConePrimitive_setCapColor(lua_State* L) { int SWIG_arg = 0; ofConePrimitive *arg1 = (ofConePrimitive *) 0 ; - ofColor arg2 ; ofColor *argp2 ; SWIG_check_num_args("ofConePrimitive::setCapColor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofConePrimitive::setCapColor",1,"ofConePrimitive *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofConePrimitive::setCapColor",2,"ofColor"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofConePrimitive,0))){ - SWIG_fail_ptr("ConePrimitive_setCapColor",1,SWIGTYPE_p_ofConePrimitive); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("ConePrimitive_setCapColor",2,SWIGTYPE_p_ofColor_T_unsigned_char_t); } arg2 = *argp2; - (arg1)->setCapColor(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ConePrimitive_getConeIndices(lua_State* L) { int SWIG_arg = 0; ofConePrimitive *arg1 = (ofConePrimitive *) 0 ; - SwigValueWrapper< std::vector< unsigned short > > result; SWIG_check_num_args("ofConePrimitive::getConeIndices",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofConePrimitive::getConeIndices",1,"ofConePrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofConePrimitive,0))){ - SWIG_fail_ptr("ConePrimitive_getConeIndices",1,SWIGTYPE_p_ofConePrimitive); } - result = ((ofConePrimitive const *)arg1)->getConeIndices(); { - std::vector< ofIndexType > * resultptr = new std::vector< ofIndexType >((const std::vector< ofIndexType > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_unsigned_short_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ConePrimitive_getConeMesh(lua_State* L) { int SWIG_arg = 0; ofConePrimitive *arg1 = (ofConePrimitive *) 0 ; - ofMesh result; SWIG_check_num_args("ofConePrimitive::getConeMesh",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofConePrimitive::getConeMesh",1,"ofConePrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofConePrimitive,0))){ - SWIG_fail_ptr("ConePrimitive_getConeMesh",1,SWIGTYPE_p_ofConePrimitive); } - result = ((ofConePrimitive const *)arg1)->getConeMesh(); { ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ConePrimitive_getCapIndices(lua_State* L) { int SWIG_arg = 0; ofConePrimitive *arg1 = (ofConePrimitive *) 0 ; - SwigValueWrapper< std::vector< unsigned short > > result; SWIG_check_num_args("ofConePrimitive::getCapIndices",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofConePrimitive::getCapIndices",1,"ofConePrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofConePrimitive,0))){ - SWIG_fail_ptr("ConePrimitive_getCapIndices",1,SWIGTYPE_p_ofConePrimitive); } - result = ((ofConePrimitive const *)arg1)->getCapIndices(); { - std::vector< ofIndexType > * resultptr = new std::vector< ofIndexType >((const std::vector< ofIndexType > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_unsigned_short_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ConePrimitive_getCapMesh(lua_State* L) { int SWIG_arg = 0; ofConePrimitive *arg1 = (ofConePrimitive *) 0 ; - ofMesh result; SWIG_check_num_args("ofConePrimitive::getCapMesh",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofConePrimitive::getCapMesh",1,"ofConePrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofConePrimitive,0))){ - SWIG_fail_ptr("ConePrimitive_getCapMesh",1,SWIGTYPE_p_ofConePrimitive); } - result = ((ofConePrimitive const *)arg1)->getCapMesh(); { ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ConePrimitive_getResolutionRadius(lua_State* L) { int SWIG_arg = 0; - ofConePrimitive *arg1 = (ofConePrimitive *) 0 ; int result; SWIG_check_num_args("ofConePrimitive::getResolutionRadius",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofConePrimitive::getResolutionRadius",1,"ofConePrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofConePrimitive,0))){ - SWIG_fail_ptr("ConePrimitive_getResolutionRadius",1,SWIGTYPE_p_ofConePrimitive); } - result = (int)((ofConePrimitive const *)arg1)->getResolutionRadius(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ConePrimitive_getResolutionHeight(lua_State* L) { int SWIG_arg = 0; - ofConePrimitive *arg1 = (ofConePrimitive *) 0 ; int result; SWIG_check_num_args("ofConePrimitive::getResolutionHeight",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofConePrimitive::getResolutionHeight",1,"ofConePrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofConePrimitive,0))){ - SWIG_fail_ptr("ConePrimitive_getResolutionHeight",1,SWIGTYPE_p_ofConePrimitive); } - result = (int)((ofConePrimitive const *)arg1)->getResolutionHeight(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ConePrimitive_getResolutionCap(lua_State* L) { int SWIG_arg = 0; - ofConePrimitive *arg1 = (ofConePrimitive *) 0 ; int result; SWIG_check_num_args("ofConePrimitive::getResolutionCap",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofConePrimitive::getResolutionCap",1,"ofConePrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofConePrimitive,0))){ - SWIG_fail_ptr("ConePrimitive_getResolutionCap",1,SWIGTYPE_p_ofConePrimitive); } - result = (int)((ofConePrimitive const *)arg1)->getResolutionCap(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ConePrimitive_getResolution(lua_State* L) { int SWIG_arg = 0; ofConePrimitive *arg1 = (ofConePrimitive *) 0 ; - ofVec3f result; SWIG_check_num_args("ofConePrimitive::getResolution",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofConePrimitive::getResolution",1,"ofConePrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofConePrimitive,0))){ - SWIG_fail_ptr("ConePrimitive_getResolution",1,SWIGTYPE_p_ofConePrimitive); } - result = ((ofConePrimitive const *)arg1)->getResolution(); { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ConePrimitive_getRadius(lua_State* L) { int SWIG_arg = 0; ofConePrimitive *arg1 = (ofConePrimitive *) 0 ; - float result; SWIG_check_num_args("ofConePrimitive::getRadius",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofConePrimitive::getRadius",1,"ofConePrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofConePrimitive,0))){ - SWIG_fail_ptr("ConePrimitive_getRadius",1,SWIGTYPE_p_ofConePrimitive); } - result = (float)((ofConePrimitive const *)arg1)->getRadius(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ConePrimitive_getHeight(lua_State* L) { int SWIG_arg = 0; ofConePrimitive *arg1 = (ofConePrimitive *) 0 ; - float result; SWIG_check_num_args("ofConePrimitive::getHeight",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofConePrimitive::getHeight",1,"ofConePrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofConePrimitive,0))){ - SWIG_fail_ptr("ConePrimitive_getHeight",1,SWIGTYPE_p_ofConePrimitive); } - result = (float)((ofConePrimitive const *)arg1)->getHeight(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_ConePrimitive(void *obj) { -ofConePrimitive *arg1 = (ofConePrimitive *) obj; -delete arg1; -} -static int _proxy__wrap_new_ConePrimitive(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_ConePrimitive); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_ConePrimitive_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_ConePrimitive_methods[]= { - { "set", _wrap_ConePrimitive_set}, - { "setResolutionRadius", _wrap_ConePrimitive_setResolutionRadius}, - { "setResolutionHeight", _wrap_ConePrimitive_setResolutionHeight}, - { "setResolutionCap", _wrap_ConePrimitive_setResolutionCap}, - { "setResolution", _wrap_ConePrimitive_setResolution}, - { "setMode", _wrap_ConePrimitive_setMode}, - { "setRadius", _wrap_ConePrimitive_setRadius}, - { "setHeight", _wrap_ConePrimitive_setHeight}, - { "setTopColor", _wrap_ConePrimitive_setTopColor}, - { "setCapColor", _wrap_ConePrimitive_setCapColor}, - { "getConeIndices", _wrap_ConePrimitive_getConeIndices}, - { "getConeMesh", _wrap_ConePrimitive_getConeMesh}, - { "getCapIndices", _wrap_ConePrimitive_getCapIndices}, - { "getCapMesh", _wrap_ConePrimitive_getCapMesh}, - { "getResolutionRadius", _wrap_ConePrimitive_getResolutionRadius}, - { "getResolutionHeight", _wrap_ConePrimitive_getResolutionHeight}, - { "getResolutionCap", _wrap_ConePrimitive_getResolutionCap}, - { "getResolution", _wrap_ConePrimitive_getResolution}, - { "getRadius", _wrap_ConePrimitive_getRadius}, - { "getHeight", _wrap_ConePrimitive_getHeight}, - {0,0} -}; -static swig_lua_method swig_ConePrimitive_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_ConePrimitive_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_ConePrimitive_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_ConePrimitive_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_ConePrimitive_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_ConePrimitive_Sf_SwigStatic = { - "ConePrimitive", - swig_ConePrimitive_Sf_SwigStatic_methods, - swig_ConePrimitive_Sf_SwigStatic_attributes, - swig_ConePrimitive_Sf_SwigStatic_constants, - swig_ConePrimitive_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_ConePrimitive_bases[] = {0,0}; -static const char *swig_ConePrimitive_base_names[] = {"of3dPrimitive *",0}; -static swig_lua_class _wrap_class_ConePrimitive = { "ConePrimitive", "ConePrimitive", &SWIGTYPE_p_ofConePrimitive,_proxy__wrap_new_ConePrimitive, swig_delete_ConePrimitive, swig_ConePrimitive_methods, swig_ConePrimitive_attributes, &swig_ConePrimitive_Sf_SwigStatic, swig_ConePrimitive_meta, swig_ConePrimitive_bases, swig_ConePrimitive_base_names }; - -static int _wrap_new_BoxPrimitive__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofBoxPrimitive *result = 0 ; - SWIG_check_num_args("ofBoxPrimitive::ofBoxPrimitive",0,0) result = (ofBoxPrimitive *)new ofBoxPrimitive(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofBoxPrimitive,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_BoxPrimitive__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; int arg4 ; - int arg5 ; int arg6 ; ofBoxPrimitive *result = 0 ; SWIG_check_num_args("ofBoxPrimitive::ofBoxPrimitive",6,6) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofBoxPrimitive::ofBoxPrimitive",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBoxPrimitive::ofBoxPrimitive",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofBoxPrimitive::ofBoxPrimitive",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofBoxPrimitive::ofBoxPrimitive",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofBoxPrimitive::ofBoxPrimitive",5,"int"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofBoxPrimitive::ofBoxPrimitive",6,"int"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - arg5 = (int)lua_tonumber(L, 5); arg6 = (int)lua_tonumber(L, 6); - result = (ofBoxPrimitive *)new ofBoxPrimitive(arg1,arg2,arg3,arg4,arg5,arg6); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofBoxPrimitive,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_BoxPrimitive__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; int arg4 ; - int arg5 ; ofBoxPrimitive *result = 0 ; SWIG_check_num_args("ofBoxPrimitive::ofBoxPrimitive",5,5) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofBoxPrimitive::ofBoxPrimitive",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBoxPrimitive::ofBoxPrimitive",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofBoxPrimitive::ofBoxPrimitive",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofBoxPrimitive::ofBoxPrimitive",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofBoxPrimitive::ofBoxPrimitive",5,"int"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - arg5 = (int)lua_tonumber(L, 5); result = (ofBoxPrimitive *)new ofBoxPrimitive(arg1,arg2,arg3,arg4,arg5); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofBoxPrimitive,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_BoxPrimitive__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; int arg4 ; - ofBoxPrimitive *result = 0 ; SWIG_check_num_args("ofBoxPrimitive::ofBoxPrimitive",4,4) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofBoxPrimitive::ofBoxPrimitive",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBoxPrimitive::ofBoxPrimitive",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofBoxPrimitive::ofBoxPrimitive",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofBoxPrimitive::ofBoxPrimitive",4,"int"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - result = (ofBoxPrimitive *)new ofBoxPrimitive(arg1,arg2,arg3,arg4); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofBoxPrimitive,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_BoxPrimitive__SWIG_4(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; - ofBoxPrimitive *result = 0 ; SWIG_check_num_args("ofBoxPrimitive::ofBoxPrimitive",3,3) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofBoxPrimitive::ofBoxPrimitive",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBoxPrimitive::ofBoxPrimitive",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofBoxPrimitive::ofBoxPrimitive",3,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - result = (ofBoxPrimitive *)new ofBoxPrimitive(arg1,arg2,arg3); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofBoxPrimitive,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_BoxPrimitive(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); - if (argc == 0) { return _wrap_new_BoxPrimitive__SWIG_0(L);} if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_new_BoxPrimitive__SWIG_4(L);} } } } if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_new_BoxPrimitive__SWIG_3(L);} } } } } if (argc == 5) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_new_BoxPrimitive__SWIG_2(L);} } } } } } - if (argc == 6) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { - return _wrap_new_BoxPrimitive__SWIG_1(L);} } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_BoxPrimitive'\n" " Possible C/C++ prototypes are:\n" - " ofBoxPrimitive::ofBoxPrimitive()\n" " ofBoxPrimitive::ofBoxPrimitive(float,float,float,int,int,int)\n" - " ofBoxPrimitive::ofBoxPrimitive(float,float,float,int,int)\n" - " ofBoxPrimitive::ofBoxPrimitive(float,float,float,int)\n" " ofBoxPrimitive::ofBoxPrimitive(float,float,float)\n"); - lua_error(L);return 0; } -static int _wrap_BoxPrimitive_set__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofBoxPrimitive *arg1 = (ofBoxPrimitive *) 0 ; - float arg2 ; float arg3 ; float arg4 ; int arg5 ; int arg6 ; int arg7 ; SWIG_check_num_args("ofBoxPrimitive::set",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBoxPrimitive::set",1,"ofBoxPrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBoxPrimitive::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofBoxPrimitive::set",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofBoxPrimitive::set",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofBoxPrimitive::set",5,"int"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofBoxPrimitive::set",6,"int"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofBoxPrimitive::set",7,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBoxPrimitive,0))){ - SWIG_fail_ptr("BoxPrimitive_set",1,SWIGTYPE_p_ofBoxPrimitive); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); - arg6 = (int)lua_tonumber(L, 6); arg7 = (int)lua_tonumber(L, 7); (arg1)->set(arg2,arg3,arg4,arg5,arg6,arg7); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BoxPrimitive_set__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofBoxPrimitive *arg1 = (ofBoxPrimitive *) 0 ; - float arg2 ; float arg3 ; float arg4 ; SWIG_check_num_args("ofBoxPrimitive::set",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBoxPrimitive::set",1,"ofBoxPrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBoxPrimitive::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofBoxPrimitive::set",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofBoxPrimitive::set",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBoxPrimitive,0))){ - SWIG_fail_ptr("BoxPrimitive_set",1,SWIGTYPE_p_ofBoxPrimitive); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); (arg1)->set(arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BoxPrimitive_set__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofBoxPrimitive *arg1 = (ofBoxPrimitive *) 0 ; - float arg2 ; SWIG_check_num_args("ofBoxPrimitive::set",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBoxPrimitive::set",1,"ofBoxPrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBoxPrimitive::set",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBoxPrimitive,0))){ - SWIG_fail_ptr("BoxPrimitive_set",1,SWIGTYPE_p_ofBoxPrimitive); } arg2 = (float)lua_tonumber(L, 2); (arg1)->set(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BoxPrimitive_set(lua_State* L) { int argc; int argv[8]={ 1,2,3,4,5,6,7,8} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofBoxPrimitive, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_BoxPrimitive_set__SWIG_2(L);} } - } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofBoxPrimitive, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_BoxPrimitive_set__SWIG_1(L);} } } } } if (argc == 7) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofBoxPrimitive, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { - return _wrap_BoxPrimitive_set__SWIG_0(L);} } } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'BoxPrimitive_set'\n" " Possible C/C++ prototypes are:\n" - " ofBoxPrimitive::set(float,float,float,int,int,int)\n" " ofBoxPrimitive::set(float,float,float)\n" - " ofBoxPrimitive::set(float)\n"); lua_error(L);return 0; } -static int _wrap_BoxPrimitive_setWidth(lua_State* L) { int SWIG_arg = 0; ofBoxPrimitive *arg1 = (ofBoxPrimitive *) 0 ; - float arg2 ; SWIG_check_num_args("ofBoxPrimitive::setWidth",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBoxPrimitive::setWidth",1,"ofBoxPrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBoxPrimitive::setWidth",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBoxPrimitive,0))){ - SWIG_fail_ptr("BoxPrimitive_setWidth",1,SWIGTYPE_p_ofBoxPrimitive); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setWidth(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BoxPrimitive_setHeight(lua_State* L) { int SWIG_arg = 0; ofBoxPrimitive *arg1 = (ofBoxPrimitive *) 0 ; - float arg2 ; SWIG_check_num_args("ofBoxPrimitive::setHeight",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBoxPrimitive::setHeight",1,"ofBoxPrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBoxPrimitive::setHeight",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBoxPrimitive,0))){ - SWIG_fail_ptr("BoxPrimitive_setHeight",1,SWIGTYPE_p_ofBoxPrimitive); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setHeight(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BoxPrimitive_setDepth(lua_State* L) { int SWIG_arg = 0; ofBoxPrimitive *arg1 = (ofBoxPrimitive *) 0 ; - float arg2 ; SWIG_check_num_args("ofBoxPrimitive::setDepth",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBoxPrimitive::setDepth",1,"ofBoxPrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBoxPrimitive::setDepth",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBoxPrimitive,0))){ - SWIG_fail_ptr("BoxPrimitive_setDepth",1,SWIGTYPE_p_ofBoxPrimitive); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setDepth(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BoxPrimitive_resizeToTexture(lua_State* L) { int SWIG_arg = 0; ofBoxPrimitive *arg1 = (ofBoxPrimitive *) 0 ; - ofTexture *arg2 = 0 ; SWIG_check_num_args("ofBoxPrimitive::resizeToTexture",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBoxPrimitive::resizeToTexture",1,"ofBoxPrimitive *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofBoxPrimitive::resizeToTexture",2,"ofTexture &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBoxPrimitive,0))){ - SWIG_fail_ptr("BoxPrimitive_resizeToTexture",1,SWIGTYPE_p_ofBoxPrimitive); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("BoxPrimitive_resizeToTexture",2,SWIGTYPE_p_ofTexture); } (arg1)->resizeToTexture(*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BoxPrimitive_getSideIndices(lua_State* L) { int SWIG_arg = 0; ofBoxPrimitive *arg1 = (ofBoxPrimitive *) 0 ; - int arg2 ; SwigValueWrapper< std::vector< unsigned short > > result; SWIG_check_num_args("ofBoxPrimitive::getSideIndices",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBoxPrimitive::getSideIndices",1,"ofBoxPrimitive const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBoxPrimitive::getSideIndices",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBoxPrimitive,0))){ - SWIG_fail_ptr("BoxPrimitive_getSideIndices",1,SWIGTYPE_p_ofBoxPrimitive); } arg2 = (int)lua_tonumber(L, 2); - result = ((ofBoxPrimitive const *)arg1)->getSideIndices(arg2); { - std::vector< ofIndexType > * resultptr = new std::vector< ofIndexType >((const std::vector< ofIndexType > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_unsigned_short_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BoxPrimitive_getSideMesh(lua_State* L) { int SWIG_arg = 0; ofBoxPrimitive *arg1 = (ofBoxPrimitive *) 0 ; - int arg2 ; ofMesh result; SWIG_check_num_args("ofBoxPrimitive::getSideMesh",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBoxPrimitive::getSideMesh",1,"ofBoxPrimitive const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBoxPrimitive::getSideMesh",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBoxPrimitive,0))){ - SWIG_fail_ptr("BoxPrimitive_getSideMesh",1,SWIGTYPE_p_ofBoxPrimitive); } arg2 = (int)lua_tonumber(L, 2); - result = ((ofBoxPrimitive const *)arg1)->getSideMesh(arg2); { ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_BoxPrimitive_setResolution__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofBoxPrimitive *arg1 = (ofBoxPrimitive *) 0 ; int arg2 ; SWIG_check_num_args("ofBoxPrimitive::setResolution",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBoxPrimitive::setResolution",1,"ofBoxPrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBoxPrimitive::setResolution",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBoxPrimitive,0))){ - SWIG_fail_ptr("BoxPrimitive_setResolution",1,SWIGTYPE_p_ofBoxPrimitive); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->setResolution(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BoxPrimitive_setResolutionWidth(lua_State* L) { int SWIG_arg = 0; ofBoxPrimitive *arg1 = (ofBoxPrimitive *) 0 ; - int arg2 ; SWIG_check_num_args("ofBoxPrimitive::setResolutionWidth",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBoxPrimitive::setResolutionWidth",1,"ofBoxPrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBoxPrimitive::setResolutionWidth",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBoxPrimitive,0))){ - SWIG_fail_ptr("BoxPrimitive_setResolutionWidth",1,SWIGTYPE_p_ofBoxPrimitive); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->setResolutionWidth(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BoxPrimitive_setResolutionHeight(lua_State* L) { int SWIG_arg = 0; - ofBoxPrimitive *arg1 = (ofBoxPrimitive *) 0 ; int arg2 ; SWIG_check_num_args("ofBoxPrimitive::setResolutionHeight",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBoxPrimitive::setResolutionHeight",1,"ofBoxPrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBoxPrimitive::setResolutionHeight",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBoxPrimitive,0))){ - SWIG_fail_ptr("BoxPrimitive_setResolutionHeight",1,SWIGTYPE_p_ofBoxPrimitive); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->setResolutionHeight(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BoxPrimitive_setResolutionDepth(lua_State* L) { int SWIG_arg = 0; ofBoxPrimitive *arg1 = (ofBoxPrimitive *) 0 ; - int arg2 ; SWIG_check_num_args("ofBoxPrimitive::setResolutionDepth",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBoxPrimitive::setResolutionDepth",1,"ofBoxPrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBoxPrimitive::setResolutionDepth",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBoxPrimitive,0))){ - SWIG_fail_ptr("BoxPrimitive_setResolutionDepth",1,SWIGTYPE_p_ofBoxPrimitive); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->setResolutionDepth(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BoxPrimitive_setResolution__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofBoxPrimitive *arg1 = (ofBoxPrimitive *) 0 ; int arg2 ; int arg3 ; int arg4 ; - SWIG_check_num_args("ofBoxPrimitive::setResolution",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBoxPrimitive::setResolution",1,"ofBoxPrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBoxPrimitive::setResolution",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofBoxPrimitive::setResolution",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofBoxPrimitive::setResolution",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBoxPrimitive,0))){ - SWIG_fail_ptr("BoxPrimitive_setResolution",1,SWIGTYPE_p_ofBoxPrimitive); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); (arg1)->setResolution(arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BoxPrimitive_setResolution(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofBoxPrimitive, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_BoxPrimitive_setResolution__SWIG_0(L);} } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofBoxPrimitive, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_BoxPrimitive_setResolution__SWIG_1(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'BoxPrimitive_setResolution'\n" - " Possible C/C++ prototypes are:\n" " ofBoxPrimitive::setResolution(int)\n" - " ofBoxPrimitive::setResolution(int,int,int)\n"); lua_error(L);return 0; } -static int _wrap_BoxPrimitive_setMode(lua_State* L) { int SWIG_arg = 0; ofBoxPrimitive *arg1 = (ofBoxPrimitive *) 0 ; - ofPrimitiveMode arg2 ; SWIG_check_num_args("ofBoxPrimitive::setMode",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBoxPrimitive::setMode",1,"ofBoxPrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBoxPrimitive::setMode",2,"ofPrimitiveMode"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBoxPrimitive,0))){ - SWIG_fail_ptr("BoxPrimitive_setMode",1,SWIGTYPE_p_ofBoxPrimitive); } arg2 = (ofPrimitiveMode)(int)lua_tonumber(L, 2); - (arg1)->setMode(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BoxPrimitive_setSideColor(lua_State* L) { int SWIG_arg = 0; ofBoxPrimitive *arg1 = (ofBoxPrimitive *) 0 ; - int arg2 ; ofColor arg3 ; ofColor *argp3 ; SWIG_check_num_args("ofBoxPrimitive::setSideColor",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBoxPrimitive::setSideColor",1,"ofBoxPrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBoxPrimitive::setSideColor",2,"int"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofBoxPrimitive::setSideColor",3,"ofColor"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBoxPrimitive,0))){ - SWIG_fail_ptr("BoxPrimitive_setSideColor",1,SWIGTYPE_p_ofBoxPrimitive); } arg2 = (int)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&argp3,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("BoxPrimitive_setSideColor",3,SWIGTYPE_p_ofColor_T_unsigned_char_t); } arg3 = *argp3; - (arg1)->setSideColor(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BoxPrimitive_getResolutionWidth(lua_State* L) { int SWIG_arg = 0; ofBoxPrimitive *arg1 = (ofBoxPrimitive *) 0 ; - int result; SWIG_check_num_args("ofBoxPrimitive::getResolutionWidth",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBoxPrimitive::getResolutionWidth",1,"ofBoxPrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBoxPrimitive,0))){ - SWIG_fail_ptr("BoxPrimitive_getResolutionWidth",1,SWIGTYPE_p_ofBoxPrimitive); } - result = (int)((ofBoxPrimitive const *)arg1)->getResolutionWidth(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BoxPrimitive_getResolutionHeight(lua_State* L) { int SWIG_arg = 0; - ofBoxPrimitive *arg1 = (ofBoxPrimitive *) 0 ; int result; SWIG_check_num_args("ofBoxPrimitive::getResolutionHeight",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBoxPrimitive::getResolutionHeight",1,"ofBoxPrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBoxPrimitive,0))){ - SWIG_fail_ptr("BoxPrimitive_getResolutionHeight",1,SWIGTYPE_p_ofBoxPrimitive); } - result = (int)((ofBoxPrimitive const *)arg1)->getResolutionHeight(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BoxPrimitive_getResolutionDepth(lua_State* L) { int SWIG_arg = 0; ofBoxPrimitive *arg1 = (ofBoxPrimitive *) 0 ; - int result; SWIG_check_num_args("ofBoxPrimitive::getResolutionDepth",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBoxPrimitive::getResolutionDepth",1,"ofBoxPrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBoxPrimitive,0))){ - SWIG_fail_ptr("BoxPrimitive_getResolutionDepth",1,SWIGTYPE_p_ofBoxPrimitive); } - result = (int)((ofBoxPrimitive const *)arg1)->getResolutionDepth(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BoxPrimitive_getResolution(lua_State* L) { int SWIG_arg = 0; ofBoxPrimitive *arg1 = (ofBoxPrimitive *) 0 ; - ofVec3f result; SWIG_check_num_args("ofBoxPrimitive::getResolution",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBoxPrimitive::getResolution",1,"ofBoxPrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBoxPrimitive,0))){ - SWIG_fail_ptr("BoxPrimitive_getResolution",1,SWIGTYPE_p_ofBoxPrimitive); } - result = ((ofBoxPrimitive const *)arg1)->getResolution(); { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_BoxPrimitive_getWidth(lua_State* L) { int SWIG_arg = 0; ofBoxPrimitive *arg1 = (ofBoxPrimitive *) 0 ; - float result; SWIG_check_num_args("ofBoxPrimitive::getWidth",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBoxPrimitive::getWidth",1,"ofBoxPrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBoxPrimitive,0))){ - SWIG_fail_ptr("BoxPrimitive_getWidth",1,SWIGTYPE_p_ofBoxPrimitive); } - result = (float)((ofBoxPrimitive const *)arg1)->getWidth(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BoxPrimitive_getHeight(lua_State* L) { int SWIG_arg = 0; ofBoxPrimitive *arg1 = (ofBoxPrimitive *) 0 ; - float result; SWIG_check_num_args("ofBoxPrimitive::getHeight",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBoxPrimitive::getHeight",1,"ofBoxPrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBoxPrimitive,0))){ - SWIG_fail_ptr("BoxPrimitive_getHeight",1,SWIGTYPE_p_ofBoxPrimitive); } - result = (float)((ofBoxPrimitive const *)arg1)->getHeight(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BoxPrimitive_getDepth(lua_State* L) { int SWIG_arg = 0; ofBoxPrimitive *arg1 = (ofBoxPrimitive *) 0 ; - float result; SWIG_check_num_args("ofBoxPrimitive::getDepth",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBoxPrimitive::getDepth",1,"ofBoxPrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBoxPrimitive,0))){ - SWIG_fail_ptr("BoxPrimitive_getDepth",1,SWIGTYPE_p_ofBoxPrimitive); } - result = (float)((ofBoxPrimitive const *)arg1)->getDepth(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BoxPrimitive_getSize(lua_State* L) { int SWIG_arg = 0; ofBoxPrimitive *arg1 = (ofBoxPrimitive *) 0 ; - ofVec3f result; SWIG_check_num_args("ofBoxPrimitive::getSize",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBoxPrimitive::getSize",1,"ofBoxPrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBoxPrimitive,0))){ - SWIG_fail_ptr("BoxPrimitive_getSize",1,SWIGTYPE_p_ofBoxPrimitive); } result = ((ofBoxPrimitive const *)arg1)->getSize(); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static void swig_delete_BoxPrimitive(void *obj) { -ofBoxPrimitive *arg1 = (ofBoxPrimitive *) obj; -delete arg1; -} -static int _proxy__wrap_new_BoxPrimitive(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_BoxPrimitive); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_BoxPrimitive_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_BoxPrimitive_methods[]= { - { "set", _wrap_BoxPrimitive_set}, - { "setWidth", _wrap_BoxPrimitive_setWidth}, - { "setHeight", _wrap_BoxPrimitive_setHeight}, - { "setDepth", _wrap_BoxPrimitive_setDepth}, - { "resizeToTexture", _wrap_BoxPrimitive_resizeToTexture}, - { "getSideIndices", _wrap_BoxPrimitive_getSideIndices}, - { "getSideMesh", _wrap_BoxPrimitive_getSideMesh}, - { "setResolutionWidth", _wrap_BoxPrimitive_setResolutionWidth}, - { "setResolutionHeight", _wrap_BoxPrimitive_setResolutionHeight}, - { "setResolutionDepth", _wrap_BoxPrimitive_setResolutionDepth}, - { "setResolution", _wrap_BoxPrimitive_setResolution}, - { "setMode", _wrap_BoxPrimitive_setMode}, - { "setSideColor", _wrap_BoxPrimitive_setSideColor}, - { "getResolutionWidth", _wrap_BoxPrimitive_getResolutionWidth}, - { "getResolutionHeight", _wrap_BoxPrimitive_getResolutionHeight}, - { "getResolutionDepth", _wrap_BoxPrimitive_getResolutionDepth}, - { "getResolution", _wrap_BoxPrimitive_getResolution}, - { "getWidth", _wrap_BoxPrimitive_getWidth}, - { "getHeight", _wrap_BoxPrimitive_getHeight}, - { "getDepth", _wrap_BoxPrimitive_getDepth}, - { "getSize", _wrap_BoxPrimitive_getSize}, - {0,0} -}; -static swig_lua_method swig_BoxPrimitive_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_BoxPrimitive_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_BoxPrimitive_Sf_SwigStatic_constants[]= { - {SWIG_LUA_CONSTTAB_INT("SIDE_FRONT", ofBoxPrimitive::SIDE_FRONT)}, - {SWIG_LUA_CONSTTAB_INT("SIDE_RIGHT", ofBoxPrimitive::SIDE_RIGHT)}, - {SWIG_LUA_CONSTTAB_INT("SIDE_LEFT", ofBoxPrimitive::SIDE_LEFT)}, - {SWIG_LUA_CONSTTAB_INT("SIDE_BACK", ofBoxPrimitive::SIDE_BACK)}, - {SWIG_LUA_CONSTTAB_INT("SIDE_TOP", ofBoxPrimitive::SIDE_TOP)}, - {SWIG_LUA_CONSTTAB_INT("SIDE_BOTTOM", ofBoxPrimitive::SIDE_BOTTOM)}, - {SWIG_LUA_CONSTTAB_INT("SIDES_TOTAL", ofBoxPrimitive::SIDES_TOTAL)}, - {0,0,0,0,0,0} -}; -static swig_lua_method swig_BoxPrimitive_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_BoxPrimitive_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_BoxPrimitive_Sf_SwigStatic = { - "BoxPrimitive", - swig_BoxPrimitive_Sf_SwigStatic_methods, - swig_BoxPrimitive_Sf_SwigStatic_attributes, - swig_BoxPrimitive_Sf_SwigStatic_constants, - swig_BoxPrimitive_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_BoxPrimitive_bases[] = {0,0}; -static const char *swig_BoxPrimitive_base_names[] = {"of3dPrimitive *",0}; -static swig_lua_class _wrap_class_BoxPrimitive = { "BoxPrimitive", "BoxPrimitive", &SWIGTYPE_p_ofBoxPrimitive,_proxy__wrap_new_BoxPrimitive, swig_delete_BoxPrimitive, swig_BoxPrimitive_methods, swig_BoxPrimitive_attributes, &swig_BoxPrimitive_Sf_SwigStatic, swig_BoxPrimitive_meta, swig_BoxPrimitive_bases, swig_BoxPrimitive_base_names }; - -static int _wrap_getAppPtr(lua_State* L) { int SWIG_arg = 0; ofBaseApp *result = 0 ; SWIG_check_num_args("ofGetAppPtr",0,0) - result = (ofBaseApp *)ofGetAppPtr(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofBaseApp,0); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_exit__SWIG_0(lua_State* L) { int SWIG_arg = 0; int arg1 ; SWIG_check_num_args("ofExit",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofExit",1,"int"); arg1 = (int)lua_tonumber(L, 1); ofExit(arg1); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_exit__SWIG_1(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofExit",0,0) ofExit(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_exit(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_exit__SWIG_1(L);} if (argc == 1) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { - return _wrap_exit__SWIG_0(L);} } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'exit'\n" - " Possible C/C++ prototypes are:\n" " ofExit(int)\n" " ofExit()\n"); lua_error(L);return 0; } -static int _wrap_getFrameRate(lua_State* L) { int SWIG_arg = 0; float result; SWIG_check_num_args("ofGetFrameRate",0,0) - result = (float)ofGetFrameRate(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_getTargetFrameRate(lua_State* L) { int SWIG_arg = 0; float result; - SWIG_check_num_args("ofGetTargetFrameRate",0,0) result = (float)ofGetTargetFrameRate(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getFrameNum(lua_State* L) { int SWIG_arg = 0; uint64_t result; SWIG_check_num_args("ofGetFrameNum",0,0) - result = (uint64_t)ofGetFrameNum(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_setFrameRate(lua_State* L) { int SWIG_arg = 0; int arg1 ; SWIG_check_num_args("ofSetFrameRate",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetFrameRate",1,"int"); arg1 = (int)lua_tonumber(L, 1); ofSetFrameRate(arg1); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getLastFrameTime(lua_State* L) { int SWIG_arg = 0; double result; SWIG_check_num_args("ofGetLastFrameTime",0,0) - result = (double)ofGetLastFrameTime(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_setOrientation__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofOrientation arg1 ; bool arg2 ; - SWIG_check_num_args("ofSetOrientation",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetOrientation",1,"ofOrientation"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofSetOrientation",2,"bool"); arg1 = (ofOrientation)(int)lua_tonumber(L, 1); - arg2 = (lua_toboolean(L, 2)!=0); ofSetOrientation(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_setOrientation__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofOrientation arg1 ; - SWIG_check_num_args("ofSetOrientation",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetOrientation",1,"ofOrientation"); - arg1 = (ofOrientation)(int)lua_tonumber(L, 1); ofSetOrientation(arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_setOrientation(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; - { _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_setOrientation__SWIG_1(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_setOrientation__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'setOrientation'\n" " Possible C/C++ prototypes are:\n" - " ofSetOrientation(ofOrientation,bool)\n" " ofSetOrientation(ofOrientation)\n"); lua_error(L);return 0; } -static int _wrap_getOrientation(lua_State* L) { int SWIG_arg = 0; ofOrientation result; - SWIG_check_num_args("ofGetOrientation",0,0) result = (ofOrientation)ofGetOrientation(); - lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_hideCursor(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofHideCursor",0,0) ofHideCursor(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_showCursor(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofShowCursor",0,0) ofShowCursor(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getWindowPositionX(lua_State* L) { int SWIG_arg = 0; int result; - SWIG_check_num_args("ofGetWindowPositionX",0,0) result = (int)ofGetWindowPositionX(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getWindowPositionY(lua_State* L) { int SWIG_arg = 0; int result; - SWIG_check_num_args("ofGetWindowPositionY",0,0) result = (int)ofGetWindowPositionY(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getScreenWidth(lua_State* L) { int SWIG_arg = 0; int result; SWIG_check_num_args("ofGetScreenWidth",0,0) - result = (int)ofGetScreenWidth(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_getScreenHeight(lua_State* L) { int SWIG_arg = 0; int result; SWIG_check_num_args("ofGetScreenHeight",0,0) - result = (int)ofGetScreenHeight(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_getWindowMode(lua_State* L) { int SWIG_arg = 0; int result; SWIG_check_num_args("ofGetWindowMode",0,0) - result = (int)ofGetWindowMode(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_getWidth(lua_State* L) { int SWIG_arg = 0; int result; SWIG_check_num_args("ofGetWidth",0,0) - result = (int)ofGetWidth(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_getHeight(lua_State* L) { int SWIG_arg = 0; int result; SWIG_check_num_args("ofGetHeight",0,0) - result = (int)ofGetHeight(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_getWindowWidth(lua_State* L) { int SWIG_arg = 0; int result; SWIG_check_num_args("ofGetWindowWidth",0,0) - result = (int)ofGetWindowWidth(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_getWindowHeight(lua_State* L) { int SWIG_arg = 0; int result; SWIG_check_num_args("ofGetWindowHeight",0,0) - result = (int)ofGetWindowHeight(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_randomWidth(lua_State* L) { int SWIG_arg = 0; float result; SWIG_check_num_args("ofRandomWidth",0,0) - result = (float)ofRandomWidth(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_randomHeight(lua_State* L) { int SWIG_arg = 0; float result; SWIG_check_num_args("ofRandomHeight",0,0) - result = (float)ofRandomHeight(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_doesHWOrientation(lua_State* L) { int SWIG_arg = 0; bool result; SWIG_check_num_args("ofDoesHWOrientation",0,0) - result = (bool)ofDoesHWOrientation(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_getWindowSize(lua_State* L) { int SWIG_arg = 0; ofPoint result; SWIG_check_num_args("ofGetWindowSize",0,0) - result = ofGetWindowSize(); { ofPoint * resultptr = new ofPoint((const ofPoint &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_getWindowRect(lua_State* L) { int SWIG_arg = 0; ofRectangle result; SWIG_check_num_args("ofGetWindowRect",0,0) - result = ofGetWindowRect(); { ofRectangle * resultptr = new ofRectangle((const ofRectangle &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofRectangle,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_setWindowPosition(lua_State* L) { int SWIG_arg = 0; int arg1 ; int arg2 ; - SWIG_check_num_args("ofSetWindowPosition",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetWindowPosition",1,"int"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSetWindowPosition",2,"int"); arg1 = (int)lua_tonumber(L, 1); - arg2 = (int)lua_tonumber(L, 2); ofSetWindowPosition(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_setWindowShape(lua_State* L) { int SWIG_arg = 0; int arg1 ; int arg2 ; - SWIG_check_num_args("ofSetWindowShape",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetWindowShape",1,"int"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSetWindowShape",2,"int"); arg1 = (int)lua_tonumber(L, 1); - arg2 = (int)lua_tonumber(L, 2); ofSetWindowShape(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_setWindowTitle(lua_State* L) { int SWIG_arg = 0; std::string arg1 ; SWIG_check_num_args("ofSetWindowTitle",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofSetWindowTitle",1,"std::string"); (&arg1)->assign(lua_tostring(L,1),lua_rawlen(L,1)); - ofSetWindowTitle(arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_enableSetupScreen(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofEnableSetupScreen",0,0) - ofEnableSetupScreen(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_disableSetupScreen(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofDisableSetupScreen",0,0) - ofDisableSetupScreen(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setFullscreen(lua_State* L) { int SWIG_arg = 0; bool arg1 ; SWIG_check_num_args("ofSetFullscreen",1,1) - if(!lua_isboolean(L,1)) SWIG_fail_arg("ofSetFullscreen",1,"bool"); arg1 = (lua_toboolean(L, 1)!=0); ofSetFullscreen(arg1); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_toggleFullscreen(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofToggleFullscreen",0,0) - ofToggleFullscreen(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setVerticalSync(lua_State* L) { int SWIG_arg = 0; bool arg1 ; SWIG_check_num_args("ofSetVerticalSync",1,1) - if(!lua_isboolean(L,1)) SWIG_fail_arg("ofSetVerticalSync",1,"bool"); arg1 = (lua_toboolean(L, 1)!=0); ofSetVerticalSync(arg1); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_events(lua_State* L) { int SWIG_arg = 0; ofCoreEvents *result = 0 ; SWIG_check_num_args("ofEvents",0,0) - result = (ofCoreEvents *) &ofEvents(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofCoreEvents,0); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setEscapeQuitsApp(lua_State* L) { int SWIG_arg = 0; bool arg1 ; SWIG_check_num_args("ofSetEscapeQuitsApp",1,1) - if(!lua_isboolean(L,1)) SWIG_fail_arg("ofSetEscapeQuitsApp",1,"bool"); arg1 = (lua_toboolean(L, 1)!=0); - ofSetEscapeQuitsApp(arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_random__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float result; SWIG_check_num_args("ofRandom",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofRandom",1,"float"); arg1 = (float)lua_tonumber(L, 1); result = (float)ofRandom(arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_random__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float result; - SWIG_check_num_args("ofRandom",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofRandom",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRandom",2,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); result = (float)ofRandom(arg1,arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_random(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_random__SWIG_0(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_random__SWIG_1(L);} } - } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'random'\n" " Possible C/C++ prototypes are:\n" - " ofRandom(float)\n" " ofRandom(float,float)\n"); lua_error(L);return 0; } -static int _wrap_randomf(lua_State* L) { int SWIG_arg = 0; float result; SWIG_check_num_args("ofRandomf",0,0) - result = (float)ofRandomf(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_randomuf(lua_State* L) { int SWIG_arg = 0; float result; SWIG_check_num_args("ofRandomuf",0,0) - result = (float)ofRandomuf(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_seedRandom__SWIG_0(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofSeedRandom",0,0) ofSeedRandom(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_seedRandom__SWIG_1(lua_State* L) { int SWIG_arg = 0; int arg1 ; SWIG_check_num_args("ofSeedRandom",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSeedRandom",1,"int"); arg1 = (int)lua_tonumber(L, 1); ofSeedRandom(arg1); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_seedRandom(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_seedRandom__SWIG_0(L);} if (argc == 1) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { - return _wrap_seedRandom__SWIG_1(L);} } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'seedRandom'\n" - " Possible C/C++ prototypes are:\n" " ofSeedRandom()\n" " ofSeedRandom(int)\n"); lua_error(L);return 0; } -static int _wrap_normalize(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float result; - SWIG_check_num_args("ofNormalize",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofNormalize",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofNormalize",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofNormalize",3,"float"); - arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - result = (float)ofNormalize(arg1,arg2,arg3); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_map__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; float arg5 ; - bool arg6 ; float result; SWIG_check_num_args("ofMap",6,6) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMap",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMap",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMap",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMap",4,"float"); if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMap",5,"float"); - if(!lua_isboolean(L,6)) SWIG_fail_arg("ofMap",6,"bool"); arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (lua_toboolean(L, 6)!=0); result = (float)ofMap(arg1,arg2,arg3,arg4,arg5,arg6); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_map__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; float arg5 ; - float result; SWIG_check_num_args("ofMap",5,5) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMap",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMap",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMap",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMap",4,"float"); if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMap",5,"float"); - arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); result = (float)ofMap(arg1,arg2,arg3,arg4,arg5); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_map(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); if (argc == 5) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_map__SWIG_1(L);} } } } } } if (argc == 6) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isboolean(L,argv[5]); } if (_v) { return _wrap_map__SWIG_0(L);} } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'map'\n" " Possible C/C++ prototypes are:\n" - " ofMap(float,float,float,float,float,bool)\n" " ofMap(float,float,float,float,float)\n"); lua_error(L);return 0; } -static int _wrap_clamp(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float result; - SWIG_check_num_args("ofClamp",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofClamp",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofClamp",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofClamp",3,"float"); - arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - result = (float)ofClamp(arg1,arg2,arg3); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_inRange(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; bool result; - SWIG_check_num_args("ofInRange",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofInRange",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofInRange",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofInRange",3,"float"); - arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - result = (bool)ofInRange(arg1,arg2,arg3); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_lerp(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float result; - SWIG_check_num_args("ofLerp",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofLerp",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofLerp",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofLerp",3,"float"); - arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - result = (float)ofLerp(arg1,arg2,arg3); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_dist__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - float result; SWIG_check_num_args("ofDist",4,4) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDist",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDist",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDist",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDist",4,"float"); arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); result = (float)ofDist(arg1,arg2,arg3,arg4); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_dist__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; float arg5 ; - float arg6 ; float result; SWIG_check_num_args("ofDist",6,6) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDist",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDist",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDist",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDist",4,"float"); if(!lua_isnumber(L,5)) SWIG_fail_arg("ofDist",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofDist",6,"float"); arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); result = (float)ofDist(arg1,arg2,arg3,arg4,arg5,arg6); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_dist(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); if (argc == 4) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_dist__SWIG_0(L);} } } } } if (argc == 6) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { - return _wrap_dist__SWIG_1(L);} } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'dist'\n" " Possible C/C++ prototypes are:\n" - " ofDist(float,float,float,float)\n" " ofDist(float,float,float,float,float,float)\n"); lua_error(L);return 0; } -static int _wrap_distSquared__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - float result; SWIG_check_num_args("ofDistSquared",4,4) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDistSquared",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDistSquared",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDistSquared",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDistSquared",4,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - result = (float)ofDistSquared(arg1,arg2,arg3,arg4); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_distSquared__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - float arg5 ; float arg6 ; float result; SWIG_check_num_args("ofDistSquared",6,6) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDistSquared",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDistSquared",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDistSquared",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDistSquared",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofDistSquared",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofDistSquared",6,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); - result = (float)ofDistSquared(arg1,arg2,arg3,arg4,arg5,arg6); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_distSquared(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); if (argc == 4) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { - return _wrap_distSquared__SWIG_0(L);} } } } } if (argc == 6) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { return _wrap_distSquared__SWIG_1(L);} } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'distSquared'\n" " Possible C/C++ prototypes are:\n" - " ofDistSquared(float,float,float,float)\n" " ofDistSquared(float,float,float,float,float,float)\n"); - lua_error(L);return 0; } -static int _wrap_radToDeg(lua_State* L) { int SWIG_arg = 0; float arg1 ; float result; SWIG_check_num_args("ofRadToDeg",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofRadToDeg",1,"float"); arg1 = (float)lua_tonumber(L, 1); - result = (float)ofRadToDeg(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_degToRad(lua_State* L) { int SWIG_arg = 0; float arg1 ; float result; SWIG_check_num_args("ofDegToRad",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDegToRad",1,"float"); arg1 = (float)lua_tonumber(L, 1); - result = (float)ofDegToRad(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_lerpDegrees(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float result; - SWIG_check_num_args("ofLerpDegrees",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofLerpDegrees",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofLerpDegrees",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofLerpDegrees",3,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); result = (float)ofLerpDegrees(arg1,arg2,arg3); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_lerpRadians(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float result; - SWIG_check_num_args("ofLerpRadians",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofLerpRadians",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofLerpRadians",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofLerpRadians",3,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); result = (float)ofLerpRadians(arg1,arg2,arg3); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_angleDifferenceDegrees(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float result; - SWIG_check_num_args("ofAngleDifferenceDegrees",2,2) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofAngleDifferenceDegrees",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofAngleDifferenceDegrees",2,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); result = (float)ofAngleDifferenceDegrees(arg1,arg2); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_angleDifferenceRadians(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float result; - SWIG_check_num_args("ofAngleDifferenceRadians",2,2) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofAngleDifferenceRadians",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofAngleDifferenceRadians",2,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); result = (float)ofAngleDifferenceRadians(arg1,arg2); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_wrap(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float result; - SWIG_check_num_args("ofWrap",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofWrap",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofWrap",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofWrap",3,"float"); - arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - result = (float)ofWrap(arg1,arg2,arg3); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_wrapRadians__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float result; - SWIG_check_num_args("ofWrapRadians",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofWrapRadians",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofWrapRadians",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofWrapRadians",3,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); result = (float)ofWrapRadians(arg1,arg2,arg3); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_wrapRadians__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float result; - SWIG_check_num_args("ofWrapRadians",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofWrapRadians",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofWrapRadians",2,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); result = (float)ofWrapRadians(arg1,arg2); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_wrapRadians__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; float result; - SWIG_check_num_args("ofWrapRadians",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofWrapRadians",1,"float"); - arg1 = (float)lua_tonumber(L, 1); result = (float)ofWrapRadians(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_wrapRadians(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_wrapRadians__SWIG_2(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_wrapRadians__SWIG_1(L);} } } if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_wrapRadians__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'wrapRadians'\n" " Possible C/C++ prototypes are:\n" - " ofWrapRadians(float,float,float)\n" " ofWrapRadians(float,float)\n" " ofWrapRadians(float)\n"); - lua_error(L);return 0; } -static int _wrap_wrapDegrees__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float result; - SWIG_check_num_args("ofWrapDegrees",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofWrapDegrees",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofWrapDegrees",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofWrapDegrees",3,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); result = (float)ofWrapDegrees(arg1,arg2,arg3); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_wrapDegrees__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float result; - SWIG_check_num_args("ofWrapDegrees",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofWrapDegrees",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofWrapDegrees",2,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); result = (float)ofWrapDegrees(arg1,arg2); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_wrapDegrees__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; float result; - SWIG_check_num_args("ofWrapDegrees",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofWrapDegrees",1,"float"); - arg1 = (float)lua_tonumber(L, 1); result = (float)ofWrapDegrees(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_wrapDegrees(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_wrapDegrees__SWIG_2(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_wrapDegrees__SWIG_1(L);} } } if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_wrapDegrees__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'wrapDegrees'\n" " Possible C/C++ prototypes are:\n" - " ofWrapDegrees(float,float,float)\n" " ofWrapDegrees(float,float)\n" " ofWrapDegrees(float)\n"); - lua_error(L);return 0; } -static int _wrap_noise__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float result; SWIG_check_num_args("ofNoise",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofNoise",1,"float"); arg1 = (float)lua_tonumber(L, 1); result = (float)ofNoise(arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_noise__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float result; - SWIG_check_num_args("ofNoise",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofNoise",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofNoise",2,"float"); arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); - result = (float)ofNoise(arg1,arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_noise__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = 0 ; float result; - SWIG_check_num_args("ofNoise",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofNoise",1,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("noise",1,SWIGTYPE_p_ofVec2f); } - result = (float)ofNoise((ofVec2f const &)*arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_noise__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float result; - SWIG_check_num_args("ofNoise",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofNoise",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofNoise",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofNoise",3,"float"); - arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - result = (float)ofNoise(arg1,arg2,arg3); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_noise__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = 0 ; float result; - SWIG_check_num_args("ofNoise",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofNoise",1,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("noise",1,SWIGTYPE_p_ofVec3f); } - result = (float)ofNoise((ofVec3f const &)*arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_noise__SWIG_5(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - float result; SWIG_check_num_args("ofNoise",4,4) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofNoise",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofNoise",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofNoise",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofNoise",4,"float"); arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); result = (float)ofNoise(arg1,arg2,arg3,arg4); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_noise__SWIG_6(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = 0 ; float result; - SWIG_check_num_args("ofNoise",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofNoise",1,"ofVec4f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("noise",1,SWIGTYPE_p_ofVec4f); } - result = (float)ofNoise((ofVec4f const &)*arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_noise(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_noise__SWIG_2(L);} } if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_noise__SWIG_4(L);} } if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_noise__SWIG_6(L);} } if (argc == 1) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { return _wrap_noise__SWIG_0(L);} } if (argc == 2) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_noise__SWIG_1(L);} } } if (argc == 3) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_noise__SWIG_3(L);} } } } if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_noise__SWIG_5(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'noise'\n" " Possible C/C++ prototypes are:\n" - " ofNoise(float)\n" " ofNoise(float,float)\n" " ofNoise(ofVec2f const &)\n" " ofNoise(float,float,float)\n" - " ofNoise(ofVec3f const &)\n" " ofNoise(float,float,float,float)\n" " ofNoise(ofVec4f const &)\n"); - lua_error(L);return 0; } -static int _wrap_signedNoise__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float result; - SWIG_check_num_args("ofSignedNoise",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSignedNoise",1,"float"); - arg1 = (float)lua_tonumber(L, 1); result = (float)ofSignedNoise(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_signedNoise__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float result; - SWIG_check_num_args("ofSignedNoise",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSignedNoise",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSignedNoise",2,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); result = (float)ofSignedNoise(arg1,arg2); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_signedNoise__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = 0 ; float result; - SWIG_check_num_args("ofSignedNoise",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofSignedNoise",1,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("signedNoise",1,SWIGTYPE_p_ofVec2f); } - result = (float)ofSignedNoise((ofVec2f const &)*arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_signedNoise__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float result; - SWIG_check_num_args("ofSignedNoise",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSignedNoise",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSignedNoise",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofSignedNoise",3,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); result = (float)ofSignedNoise(arg1,arg2,arg3); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_signedNoise__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = 0 ; float result; - SWIG_check_num_args("ofSignedNoise",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofSignedNoise",1,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("signedNoise",1,SWIGTYPE_p_ofVec3f); } - result = (float)ofSignedNoise((ofVec3f const &)*arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_signedNoise__SWIG_5(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - float result; SWIG_check_num_args("ofSignedNoise",4,4) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSignedNoise",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSignedNoise",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofSignedNoise",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofSignedNoise",4,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - result = (float)ofSignedNoise(arg1,arg2,arg3,arg4); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_signedNoise__SWIG_6(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = 0 ; float result; - SWIG_check_num_args("ofSignedNoise",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofSignedNoise",1,"ofVec4f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("signedNoise",1,SWIGTYPE_p_ofVec4f); } - result = (float)ofSignedNoise((ofVec4f const &)*arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_signedNoise(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 1) { int _v; - { void *ptr; if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_signedNoise__SWIG_2(L);} } if (argc == 1) { int _v; { - void *ptr; if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_signedNoise__SWIG_4(L);} } if (argc == 1) { int _v; { - void *ptr; if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_signedNoise__SWIG_6(L);} } if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_signedNoise__SWIG_0(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_signedNoise__SWIG_1(L);} } } if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_signedNoise__SWIG_3(L);} } } } if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { - { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_signedNoise__SWIG_5(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'signedNoise'\n" " Possible C/C++ prototypes are:\n" - " ofSignedNoise(float)\n" " ofSignedNoise(float,float)\n" " ofSignedNoise(ofVec2f const &)\n" - " ofSignedNoise(float,float,float)\n" " ofSignedNoise(ofVec3f const &)\n" " ofSignedNoise(float,float,float,float)\n" - " ofSignedNoise(ofVec4f const &)\n"); lua_error(L);return 0; } -static int _wrap_insidePoly__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; - std::vector< ofPoint > *arg3 = 0 ; bool result; SWIG_check_num_args("ofInsidePoly",3,3) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofInsidePoly",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofInsidePoly",2,"float"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofInsidePoly",3,"std::vector< ofPoint > const &"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_std__vectorT_ofVec3f_t,0))){ - SWIG_fail_ptr("insidePoly",3,SWIGTYPE_p_std__vectorT_ofVec3f_t); } - result = (bool)ofInsidePoly(arg1,arg2,(std::vector< ofVec3f > const &)*arg3); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_insidePoly__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPoint *arg1 = 0 ; std::vector< ofPoint > *arg2 = 0 ; - bool result; SWIG_check_num_args("ofInsidePoly",2,2) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofInsidePoly",1,"ofPoint const &"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofInsidePoly",2,"std::vector< ofPoint > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("insidePoly",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__vectorT_ofVec3f_t,0))){ - SWIG_fail_ptr("insidePoly",2,SWIGTYPE_p_std__vectorT_ofVec3f_t); } - result = (bool)ofInsidePoly((ofVec3f const &)*arg1,(std::vector< ofVec3f > const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_insidePoly(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_std__vectorT_ofVec3f_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_insidePoly__SWIG_1(L);} } } if (argc == 3) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_std__vectorT_ofVec3f_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_insidePoly__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'insidePoly'\n" " Possible C/C++ prototypes are:\n" - " ofInsidePoly(float,float,std::vector< ofPoint > const &)\n" - " ofInsidePoly(ofPoint const &,std::vector< ofPoint > const &)\n"); lua_error(L);return 0; } -static int _wrap_lineSegmentIntersection(lua_State* L) { int SWIG_arg = 0; ofPoint *arg1 = 0 ; ofPoint *arg2 = 0 ; - ofPoint *arg3 = 0 ; ofPoint *arg4 = 0 ; ofPoint *arg5 = 0 ; bool result; SWIG_check_num_args("ofLineSegmentIntersection",5,5) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofLineSegmentIntersection",1,"ofPoint const &"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofLineSegmentIntersection",2,"ofPoint const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofLineSegmentIntersection",3,"ofPoint const &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofLineSegmentIntersection",4,"ofPoint const &"); - if(!lua_isuserdata(L,5)) SWIG_fail_arg("ofLineSegmentIntersection",5,"ofPoint &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("lineSegmentIntersection",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("lineSegmentIntersection",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("lineSegmentIntersection",3,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("lineSegmentIntersection",4,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("lineSegmentIntersection",5,SWIGTYPE_p_ofVec3f); } - result = (bool)ofLineSegmentIntersection((ofVec3f const &)*arg1,(ofVec3f const &)*arg2,(ofVec3f const &)*arg3,(ofVec3f const &)*arg4,*arg5); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_bezierPoint(lua_State* L) { int SWIG_arg = 0; ofPoint *arg1 = 0 ; ofPoint *arg2 = 0 ; ofPoint *arg3 = 0 ; - ofPoint *arg4 = 0 ; float arg5 ; ofPoint result; SWIG_check_num_args("ofBezierPoint",5,5) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofBezierPoint",1,"ofPoint const &"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofBezierPoint",2,"ofPoint const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofBezierPoint",3,"ofPoint const &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofBezierPoint",4,"ofPoint const &"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofBezierPoint",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("bezierPoint",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("bezierPoint",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("bezierPoint",3,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("bezierPoint",4,SWIGTYPE_p_ofVec3f); } - arg5 = (float)lua_tonumber(L, 5); - result = ofBezierPoint((ofVec3f const &)*arg1,(ofVec3f const &)*arg2,(ofVec3f const &)*arg3,(ofVec3f const &)*arg4,arg5); { - ofPoint * resultptr = new ofPoint((const ofPoint &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_curvePoint(lua_State* L) { int SWIG_arg = 0; ofPoint *arg1 = 0 ; ofPoint *arg2 = 0 ; ofPoint *arg3 = 0 ; - ofPoint *arg4 = 0 ; float arg5 ; ofPoint result; SWIG_check_num_args("ofCurvePoint",5,5) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofCurvePoint",1,"ofPoint const &"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofCurvePoint",2,"ofPoint const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofCurvePoint",3,"ofPoint const &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofCurvePoint",4,"ofPoint const &"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofCurvePoint",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("curvePoint",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("curvePoint",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("curvePoint",3,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("curvePoint",4,SWIGTYPE_p_ofVec3f); } - arg5 = (float)lua_tonumber(L, 5); - result = ofCurvePoint((ofVec3f const &)*arg1,(ofVec3f const &)*arg2,(ofVec3f const &)*arg3,(ofVec3f const &)*arg4,arg5); { - ofPoint * resultptr = new ofPoint((const ofPoint &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_bezierTangent(lua_State* L) { int SWIG_arg = 0; ofPoint *arg1 = 0 ; ofPoint *arg2 = 0 ; ofPoint *arg3 = 0 ; - ofPoint *arg4 = 0 ; float arg5 ; ofPoint result; SWIG_check_num_args("ofBezierTangent",5,5) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofBezierTangent",1,"ofPoint const &"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofBezierTangent",2,"ofPoint const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofBezierTangent",3,"ofPoint const &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofBezierTangent",4,"ofPoint const &"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofBezierTangent",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("bezierTangent",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("bezierTangent",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("bezierTangent",3,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("bezierTangent",4,SWIGTYPE_p_ofVec3f); } arg5 = (float)lua_tonumber(L, 5); - result = ofBezierTangent((ofVec3f const &)*arg1,(ofVec3f const &)*arg2,(ofVec3f const &)*arg3,(ofVec3f const &)*arg4,arg5); { - ofPoint * resultptr = new ofPoint((const ofPoint &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_curveTangent(lua_State* L) { int SWIG_arg = 0; ofPoint *arg1 = 0 ; ofPoint *arg2 = 0 ; ofPoint *arg3 = 0 ; - ofPoint *arg4 = 0 ; float arg5 ; ofPoint result; SWIG_check_num_args("ofCurveTangent",5,5) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofCurveTangent",1,"ofPoint const &"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofCurveTangent",2,"ofPoint const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofCurveTangent",3,"ofPoint const &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofCurveTangent",4,"ofPoint const &"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofCurveTangent",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("curveTangent",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("curveTangent",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("curveTangent",3,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("curveTangent",4,SWIGTYPE_p_ofVec3f); } arg5 = (float)lua_tonumber(L, 5); - result = ofCurveTangent((ofVec3f const &)*arg1,(ofVec3f const &)*arg2,(ofVec3f const &)*arg3,(ofVec3f const &)*arg4,arg5); { - ofPoint * resultptr = new ofPoint((const ofPoint &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_nextPow2(lua_State* L) { int SWIG_arg = 0; int arg1 ; int result; SWIG_check_num_args("ofNextPow2",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofNextPow2",1,"int"); arg1 = (int)lua_tonumber(L, 1); result = (int)ofNextPow2(arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_sign(lua_State* L) { int SWIG_arg = 0; float arg1 ; int result; SWIG_check_num_args("ofSign",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSign",1,"float"); arg1 = (float)lua_tonumber(L, 1); result = (int)ofSign(arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix3x3_a_set(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; float arg2 ; - SWIG_check_num_args("ofMatrix3x3::a",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::a",1,"ofMatrix3x3 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix3x3::a",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3_a_set",1,SWIGTYPE_p_ofMatrix3x3); } arg2 = (float)lua_tonumber(L, 2); if (arg1) (arg1)->a = arg2; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix3x3_a_get(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; float result; - SWIG_check_num_args("ofMatrix3x3::a",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::a",1,"ofMatrix3x3 *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3_a_get",1,SWIGTYPE_p_ofMatrix3x3); } result = (float) ((arg1)->a); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix3x3_b_set(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; float arg2 ; - SWIG_check_num_args("ofMatrix3x3::b",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::b",1,"ofMatrix3x3 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix3x3::b",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3_b_set",1,SWIGTYPE_p_ofMatrix3x3); } arg2 = (float)lua_tonumber(L, 2); if (arg1) (arg1)->b = arg2; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix3x3_b_get(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; float result; - SWIG_check_num_args("ofMatrix3x3::b",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::b",1,"ofMatrix3x3 *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3_b_get",1,SWIGTYPE_p_ofMatrix3x3); } result = (float) ((arg1)->b); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix3x3_c_set(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; float arg2 ; - SWIG_check_num_args("ofMatrix3x3::c",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::c",1,"ofMatrix3x3 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix3x3::c",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3_c_set",1,SWIGTYPE_p_ofMatrix3x3); } arg2 = (float)lua_tonumber(L, 2); if (arg1) (arg1)->c = arg2; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix3x3_c_get(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; float result; - SWIG_check_num_args("ofMatrix3x3::c",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::c",1,"ofMatrix3x3 *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3_c_get",1,SWIGTYPE_p_ofMatrix3x3); } result = (float) ((arg1)->c); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix3x3_d_set(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; float arg2 ; - SWIG_check_num_args("ofMatrix3x3::d",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::d",1,"ofMatrix3x3 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix3x3::d",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3_d_set",1,SWIGTYPE_p_ofMatrix3x3); } arg2 = (float)lua_tonumber(L, 2); if (arg1) (arg1)->d = arg2; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix3x3_d_get(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; float result; - SWIG_check_num_args("ofMatrix3x3::d",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::d",1,"ofMatrix3x3 *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3_d_get",1,SWIGTYPE_p_ofMatrix3x3); } result = (float) ((arg1)->d); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix3x3_e_set(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; float arg2 ; - SWIG_check_num_args("ofMatrix3x3::e",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::e",1,"ofMatrix3x3 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix3x3::e",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3_e_set",1,SWIGTYPE_p_ofMatrix3x3); } arg2 = (float)lua_tonumber(L, 2); if (arg1) (arg1)->e = arg2; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix3x3_e_get(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; float result; - SWIG_check_num_args("ofMatrix3x3::e",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::e",1,"ofMatrix3x3 *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3_e_get",1,SWIGTYPE_p_ofMatrix3x3); } result = (float) ((arg1)->e); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix3x3_f_set(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; float arg2 ; - SWIG_check_num_args("ofMatrix3x3::f",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::f",1,"ofMatrix3x3 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix3x3::f",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3_f_set",1,SWIGTYPE_p_ofMatrix3x3); } arg2 = (float)lua_tonumber(L, 2); if (arg1) (arg1)->f = arg2; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix3x3_f_get(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; float result; - SWIG_check_num_args("ofMatrix3x3::f",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::f",1,"ofMatrix3x3 *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3_f_get",1,SWIGTYPE_p_ofMatrix3x3); } result = (float) ((arg1)->f); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix3x3_g_set(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; float arg2 ; - SWIG_check_num_args("ofMatrix3x3::g",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::g",1,"ofMatrix3x3 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix3x3::g",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3_g_set",1,SWIGTYPE_p_ofMatrix3x3); } arg2 = (float)lua_tonumber(L, 2); if (arg1) (arg1)->g = arg2; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix3x3_g_get(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; float result; - SWIG_check_num_args("ofMatrix3x3::g",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::g",1,"ofMatrix3x3 *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3_g_get",1,SWIGTYPE_p_ofMatrix3x3); } result = (float) ((arg1)->g); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix3x3_h_set(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; float arg2 ; - SWIG_check_num_args("ofMatrix3x3::h",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::h",1,"ofMatrix3x3 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix3x3::h",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3_h_set",1,SWIGTYPE_p_ofMatrix3x3); } arg2 = (float)lua_tonumber(L, 2); if (arg1) (arg1)->h = arg2; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix3x3_h_get(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; float result; - SWIG_check_num_args("ofMatrix3x3::h",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::h",1,"ofMatrix3x3 *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3_h_get",1,SWIGTYPE_p_ofMatrix3x3); } result = (float) ((arg1)->h); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix3x3_i_set(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; float arg2 ; - SWIG_check_num_args("ofMatrix3x3::i",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::i",1,"ofMatrix3x3 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix3x3::i",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3_i_set",1,SWIGTYPE_p_ofMatrix3x3); } arg2 = (float)lua_tonumber(L, 2); if (arg1) (arg1)->i = arg2; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix3x3_i_get(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; float result; - SWIG_check_num_args("ofMatrix3x3::i",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::i",1,"ofMatrix3x3 *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3_i_get",1,SWIGTYPE_p_ofMatrix3x3); } result = (float) ((arg1)->i); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_new_Matrix3x3__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - float arg5 ; float arg6 ; float arg7 ; float arg8 ; float arg9 ; ofMatrix3x3 *result = 0 ; - SWIG_check_num_args("ofMatrix3x3::ofMatrix3x3",9,9) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",8,"float"); - if(!lua_isnumber(L,9)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",9,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); - arg8 = (float)lua_tonumber(L, 8); arg9 = (float)lua_tonumber(L, 9); - result = (ofMatrix3x3 *)new ofMatrix3x3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMatrix3x3,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Matrix3x3__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - float arg5 ; float arg6 ; float arg7 ; float arg8 ; ofMatrix3x3 *result = 0 ; - SWIG_check_num_args("ofMatrix3x3::ofMatrix3x3",8,8) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",8,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); - arg8 = (float)lua_tonumber(L, 8); result = (ofMatrix3x3 *)new ofMatrix3x3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMatrix3x3,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Matrix3x3__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - float arg5 ; float arg6 ; float arg7 ; ofMatrix3x3 *result = 0 ; SWIG_check_num_args("ofMatrix3x3::ofMatrix3x3",7,7) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",7,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); - result = (ofMatrix3x3 *)new ofMatrix3x3(arg1,arg2,arg3,arg4,arg5,arg6,arg7); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMatrix3x3,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Matrix3x3__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - float arg5 ; float arg6 ; ofMatrix3x3 *result = 0 ; SWIG_check_num_args("ofMatrix3x3::ofMatrix3x3",6,6) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",6,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); - result = (ofMatrix3x3 *)new ofMatrix3x3(arg1,arg2,arg3,arg4,arg5,arg6); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMatrix3x3,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Matrix3x3__SWIG_4(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - float arg5 ; ofMatrix3x3 *result = 0 ; SWIG_check_num_args("ofMatrix3x3::ofMatrix3x3",5,5) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",5,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); result = (ofMatrix3x3 *)new ofMatrix3x3(arg1,arg2,arg3,arg4,arg5); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMatrix3x3,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Matrix3x3__SWIG_5(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - ofMatrix3x3 *result = 0 ; SWIG_check_num_args("ofMatrix3x3::ofMatrix3x3",4,4) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",4,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - result = (ofMatrix3x3 *)new ofMatrix3x3(arg1,arg2,arg3,arg4); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMatrix3x3,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Matrix3x3__SWIG_6(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; - ofMatrix3x3 *result = 0 ; SWIG_check_num_args("ofMatrix3x3::ofMatrix3x3",3,3) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",3,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); result = (ofMatrix3x3 *)new ofMatrix3x3(arg1,arg2,arg3); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMatrix3x3,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Matrix3x3__SWIG_7(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; ofMatrix3x3 *result = 0 ; - SWIG_check_num_args("ofMatrix3x3::ofMatrix3x3",2,2) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",2,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); result = (ofMatrix3x3 *)new ofMatrix3x3(arg1,arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMatrix3x3,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Matrix3x3__SWIG_8(lua_State* L) { int SWIG_arg = 0; float arg1 ; ofMatrix3x3 *result = 0 ; - SWIG_check_num_args("ofMatrix3x3::ofMatrix3x3",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",1,"float"); arg1 = (float)lua_tonumber(L, 1); - result = (ofMatrix3x3 *)new ofMatrix3x3(arg1); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMatrix3x3,1); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_new_Matrix3x3__SWIG_9(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *result = 0 ; - SWIG_check_num_args("ofMatrix3x3::ofMatrix3x3",0,0) result = (ofMatrix3x3 *)new ofMatrix3x3(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMatrix3x3,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Matrix3x3(lua_State* L) { int argc; int argv[10]={ 1,2,3,4,5,6,7,8,9,10} ; argc = lua_gettop(L); - if (argc == 0) { return _wrap_new_Matrix3x3__SWIG_9(L);} if (argc == 1) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { return _wrap_new_Matrix3x3__SWIG_8(L);} } if (argc == 2) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { - { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_new_Matrix3x3__SWIG_7(L);} } } if (argc == 3) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_new_Matrix3x3__SWIG_6(L);} } } } if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_new_Matrix3x3__SWIG_5(L);} } } } } if (argc == 5) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_new_Matrix3x3__SWIG_4(L);} } } } } } - if (argc == 6) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { - return _wrap_new_Matrix3x3__SWIG_3(L);} } } } } } } if (argc == 7) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { - return _wrap_new_Matrix3x3__SWIG_2(L);} } } } } } } } if (argc == 8) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { return _wrap_new_Matrix3x3__SWIG_1(L);} } } } } } } } } - if (argc == 9) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { { - _v = lua_isnumber(L,argv[6]); } if (_v) { { _v = lua_isnumber(L,argv[7]); } if (_v) { { - _v = lua_isnumber(L,argv[8]); } if (_v) { return _wrap_new_Matrix3x3__SWIG_0(L);} } } } } } } } } - } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_Matrix3x3'\n" - " Possible C/C++ prototypes are:\n" " ofMatrix3x3::ofMatrix3x3(float,float,float,float,float,float,float,float,float)\n" - " ofMatrix3x3::ofMatrix3x3(float,float,float,float,float,float,float,float)\n" - " ofMatrix3x3::ofMatrix3x3(float,float,float,float,float,float,float)\n" - " ofMatrix3x3::ofMatrix3x3(float,float,float,float,float,float)\n" - " ofMatrix3x3::ofMatrix3x3(float,float,float,float,float)\n" " ofMatrix3x3::ofMatrix3x3(float,float,float,float)\n" - " ofMatrix3x3::ofMatrix3x3(float,float,float)\n" " ofMatrix3x3::ofMatrix3x3(float,float)\n" - " ofMatrix3x3::ofMatrix3x3(float)\n" " ofMatrix3x3::ofMatrix3x3()\n"); lua_error(L);return 0; } -static int _wrap_Matrix3x3_set(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; float arg2 ; - float arg3 ; float arg4 ; float arg5 ; float arg6 ; float arg7 ; float arg8 ; float arg9 ; float arg10 ; - SWIG_check_num_args("ofMatrix3x3::set",10,10) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::set",1,"ofMatrix3x3 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix3x3::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix3x3::set",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix3x3::set",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMatrix3x3::set",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofMatrix3x3::set",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofMatrix3x3::set",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofMatrix3x3::set",8,"float"); - if(!lua_isnumber(L,9)) SWIG_fail_arg("ofMatrix3x3::set",9,"float"); - if(!lua_isnumber(L,10)) SWIG_fail_arg("ofMatrix3x3::set",10,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3_set",1,SWIGTYPE_p_ofMatrix3x3); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (float)lua_tonumber(L, 8); - arg9 = (float)lua_tonumber(L, 9); arg10 = (float)lua_tonumber(L, 10); - (arg1)->set(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Matrix3x3_transpose__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; - SWIG_check_num_args("ofMatrix3x3::transpose",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::transpose",1,"ofMatrix3x3 *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3_transpose",1,SWIGTYPE_p_ofMatrix3x3); } (arg1)->transpose(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix3x3_transpose__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; - ofMatrix3x3 *arg2 = 0 ; ofMatrix3x3 result; SWIG_check_num_args("ofMatrix3x3::transpose",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::transpose",1,"ofMatrix3x3 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix3x3::transpose",2,"ofMatrix3x3 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3_transpose",1,SWIGTYPE_p_ofMatrix3x3); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3_transpose",2,SWIGTYPE_p_ofMatrix3x3); } result = (arg1)->transpose((ofMatrix3x3 const &)*arg2); { - ofMatrix3x3 * resultptr = new ofMatrix3x3((const ofMatrix3x3 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix3x3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix3x3_transpose(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix3x3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix3x3_transpose__SWIG_0(L);} } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix3x3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofMatrix3x3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix3x3_transpose__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix3x3_transpose'\n" - " Possible C/C++ prototypes are:\n" " ofMatrix3x3::transpose()\n" " ofMatrix3x3::transpose(ofMatrix3x3 const &)\n"); - lua_error(L);return 0; } -static int _wrap_Matrix3x3_determinant__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; - float result; SWIG_check_num_args("ofMatrix3x3::determinant",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::determinant",1,"ofMatrix3x3 const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3_determinant",1,SWIGTYPE_p_ofMatrix3x3); } - result = (float)((ofMatrix3x3 const *)arg1)->determinant(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix3x3_determinant__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; - ofMatrix3x3 *arg2 = 0 ; float result; SWIG_check_num_args("ofMatrix3x3::determinant",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::determinant",1,"ofMatrix3x3 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix3x3::determinant",2,"ofMatrix3x3 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3_determinant",1,SWIGTYPE_p_ofMatrix3x3); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3_determinant",2,SWIGTYPE_p_ofMatrix3x3); } - result = (float)(arg1)->determinant((ofMatrix3x3 const &)*arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix3x3_determinant(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix3x3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix3x3_determinant__SWIG_0(L);} } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix3x3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofMatrix3x3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix3x3_determinant__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix3x3_determinant'\n" - " Possible C/C++ prototypes are:\n" " ofMatrix3x3::determinant() const\n" - " ofMatrix3x3::determinant(ofMatrix3x3 const &)\n"); lua_error(L);return 0; } -static int _wrap_Matrix3x3_inverse(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; - ofMatrix3x3 *arg2 = 0 ; ofMatrix3x3 result; SWIG_check_num_args("ofMatrix3x3::inverse",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::inverse",1,"ofMatrix3x3 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix3x3::inverse",2,"ofMatrix3x3 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3_inverse",1,SWIGTYPE_p_ofMatrix3x3); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3_inverse",2,SWIGTYPE_p_ofMatrix3x3); } result = (arg1)->inverse((ofMatrix3x3 const &)*arg2); { - ofMatrix3x3 * resultptr = new ofMatrix3x3((const ofMatrix3x3 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix3x3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix3x3_invert(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; - SWIG_check_num_args("ofMatrix3x3::invert",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::invert",1,"ofMatrix3x3 *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3_invert",1,SWIGTYPE_p_ofMatrix3x3); } (arg1)->invert(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix3x3_entrywiseTimes(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; - ofMatrix3x3 *arg2 = 0 ; ofMatrix3x3 result; SWIG_check_num_args("ofMatrix3x3::entrywiseTimes",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::entrywiseTimes",1,"ofMatrix3x3 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix3x3::entrywiseTimes",2,"ofMatrix3x3 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3_entrywiseTimes",1,SWIGTYPE_p_ofMatrix3x3); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3_entrywiseTimes",2,SWIGTYPE_p_ofMatrix3x3); } - result = (arg1)->entrywiseTimes((ofMatrix3x3 const &)*arg2); { - ofMatrix3x3 * resultptr = new ofMatrix3x3((const ofMatrix3x3 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix3x3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix3x3___add(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; - ofMatrix3x3 *arg2 = 0 ; ofMatrix3x3 result; SWIG_check_num_args("ofMatrix3x3::operator +",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::operator +",1,"ofMatrix3x3 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix3x3::operator +",2,"ofMatrix3x3 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3___add",1,SWIGTYPE_p_ofMatrix3x3); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3___add",2,SWIGTYPE_p_ofMatrix3x3); } result = (arg1)->operator +((ofMatrix3x3 const &)*arg2); { - ofMatrix3x3 * resultptr = new ofMatrix3x3((const ofMatrix3x3 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix3x3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix3x3___sub(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; - ofMatrix3x3 *arg2 = 0 ; ofMatrix3x3 result; SWIG_check_num_args("ofMatrix3x3::operator -",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::operator -",1,"ofMatrix3x3 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix3x3::operator -",2,"ofMatrix3x3 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3___sub",1,SWIGTYPE_p_ofMatrix3x3); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3___sub",2,SWIGTYPE_p_ofMatrix3x3); } result = (arg1)->operator -((ofMatrix3x3 const &)*arg2); { - ofMatrix3x3 * resultptr = new ofMatrix3x3((const ofMatrix3x3 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix3x3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix3x3___mul__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; float arg2 ; - ofMatrix3x3 result; SWIG_check_num_args("ofMatrix3x3::operator *",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::operator *",1,"ofMatrix3x3 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix3x3::operator *",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3___mul",1,SWIGTYPE_p_ofMatrix3x3); } arg2 = (float)lua_tonumber(L, 2); - result = (arg1)->operator *(arg2); { ofMatrix3x3 * resultptr = new ofMatrix3x3((const ofMatrix3x3 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix3x3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix3x3___mul__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; - ofMatrix3x3 *arg2 = 0 ; ofMatrix3x3 result; SWIG_check_num_args("ofMatrix3x3::operator *",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::operator *",1,"ofMatrix3x3 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix3x3::operator *",2,"ofMatrix3x3 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3___mul",1,SWIGTYPE_p_ofMatrix3x3); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3___mul",2,SWIGTYPE_p_ofMatrix3x3); } result = (arg1)->operator *((ofMatrix3x3 const &)*arg2); { - ofMatrix3x3 * resultptr = new ofMatrix3x3((const ofMatrix3x3 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix3x3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix3x3___mul(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix3x3, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofMatrix3x3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix3x3___mul__SWIG_1(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix3x3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Matrix3x3___mul__SWIG_0(L);} } - } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix3x3___mul'\n" - " Possible C/C++ prototypes are:\n" " ofMatrix3x3::operator *(float)\n" - " ofMatrix3x3::operator *(ofMatrix3x3 const &)\n"); lua_error(L);return 0; } -static int _wrap_Matrix3x3___div(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; float arg2 ; - ofMatrix3x3 result; SWIG_check_num_args("ofMatrix3x3::operator /",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::operator /",1,"ofMatrix3x3 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix3x3::operator /",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3___div",1,SWIGTYPE_p_ofMatrix3x3); } arg2 = (float)lua_tonumber(L, 2); - result = (arg1)->operator /(arg2); { ofMatrix3x3 * resultptr = new ofMatrix3x3((const ofMatrix3x3 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix3x3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix3x3___tostring(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; - char *result = 0 ; SWIG_check_num_args("ofMatrix3x3::__str__",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::__str__",1,"ofMatrix3x3 *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3___tostring",1,SWIGTYPE_p_ofMatrix3x3); } result = (char *)ofMatrix3x3___str__(arg1); - lua_pushstring(L,(const char *)result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_Matrix3x3(void *obj) { -ofMatrix3x3 *arg1 = (ofMatrix3x3 *) obj; -delete arg1; -} -static int _proxy__wrap_new_Matrix3x3(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_Matrix3x3); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_Matrix3x3_attributes[] = { - { "a", _wrap_Matrix3x3_a_get, _wrap_Matrix3x3_a_set }, - { "b", _wrap_Matrix3x3_b_get, _wrap_Matrix3x3_b_set }, - { "c", _wrap_Matrix3x3_c_get, _wrap_Matrix3x3_c_set }, - { "d", _wrap_Matrix3x3_d_get, _wrap_Matrix3x3_d_set }, - { "e", _wrap_Matrix3x3_e_get, _wrap_Matrix3x3_e_set }, - { "f", _wrap_Matrix3x3_f_get, _wrap_Matrix3x3_f_set }, - { "g", _wrap_Matrix3x3_g_get, _wrap_Matrix3x3_g_set }, - { "h", _wrap_Matrix3x3_h_get, _wrap_Matrix3x3_h_set }, - { "i", _wrap_Matrix3x3_i_get, _wrap_Matrix3x3_i_set }, - {0,0,0} -}; -static swig_lua_method swig_Matrix3x3_methods[]= { - { "set", _wrap_Matrix3x3_set}, - { "transpose", _wrap_Matrix3x3_transpose}, - { "determinant", _wrap_Matrix3x3_determinant}, - { "inverse", _wrap_Matrix3x3_inverse}, - { "invert", _wrap_Matrix3x3_invert}, - { "entrywiseTimes", _wrap_Matrix3x3_entrywiseTimes}, - { "__add", _wrap_Matrix3x3___add}, - { "__sub", _wrap_Matrix3x3___sub}, - { "__mul", _wrap_Matrix3x3___mul}, - { "__div", _wrap_Matrix3x3___div}, - { "__tostring", _wrap_Matrix3x3___tostring}, - {0,0} -}; -static swig_lua_method swig_Matrix3x3_meta[] = { - { "__add", _wrap_Matrix3x3___add}, - { "__sub", _wrap_Matrix3x3___sub}, - { "__mul", _wrap_Matrix3x3___mul}, - { "__div", _wrap_Matrix3x3___div}, - { "__tostring", _wrap_Matrix3x3___tostring}, - {0,0} -}; - -static swig_lua_attribute swig_Matrix3x3_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_Matrix3x3_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_Matrix3x3_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_Matrix3x3_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_Matrix3x3_Sf_SwigStatic = { - "Matrix3x3", - swig_Matrix3x3_Sf_SwigStatic_methods, - swig_Matrix3x3_Sf_SwigStatic_attributes, - swig_Matrix3x3_Sf_SwigStatic_constants, - swig_Matrix3x3_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_Matrix3x3_bases[] = {0}; -static const char *swig_Matrix3x3_base_names[] = {0}; -static swig_lua_class _wrap_class_Matrix3x3 = { "Matrix3x3", "Matrix3x3", &SWIGTYPE_p_ofMatrix3x3,_proxy__wrap_new_Matrix3x3, swig_delete_Matrix3x3, swig_Matrix3x3_methods, swig_Matrix3x3_attributes, &swig_Matrix3x3_Sf_SwigStatic, swig_Matrix3x3_meta, swig_Matrix3x3_bases, swig_Matrix3x3_base_names }; - -static int _wrap_Matrix4x4__mat_set(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; ofVec4f *arg2 ; - SWIG_check_num_args("ofMatrix4x4::_mat",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::_mat",1,"ofMatrix4x4 *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofMatrix4x4::_mat",2,"ofVec4f [4]"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4__mat_set",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec4f,0))){ - SWIG_fail_ptr("Matrix4x4__mat_set",2,SWIGTYPE_p_ofVec4f); } { size_t ii; ofVec4f *b = (ofVec4f *) arg1->_mat; - for (ii = 0; ii < (size_t)4; ii++) b[ii] = *((ofVec4f *) arg2 + ii); } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4__mat_get(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofVec4f *result = 0 ; SWIG_check_num_args("ofMatrix4x4::_mat",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::_mat",1,"ofMatrix4x4 *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4__mat_get",1,SWIGTYPE_p_ofMatrix4x4); } result = (ofVec4f *)(ofVec4f *) ((arg1)->_mat); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec4f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Matrix4x4__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *result = 0 ; - SWIG_check_num_args("ofMatrix4x4::ofMatrix4x4",0,0) result = (ofMatrix4x4 *)new ofMatrix4x4(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Matrix4x4__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = 0 ; ofMatrix4x4 *result = 0 ; - SWIG_check_num_args("ofMatrix4x4::ofMatrix4x4",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofMatrix4x4::ofMatrix4x4",1,"ofMatrix4x4 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("new_Matrix4x4",1,SWIGTYPE_p_ofMatrix4x4); } - result = (ofMatrix4x4 *)new ofMatrix4x4((ofMatrix4x4 const &)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Matrix4x4__SWIG_2(lua_State* L) { int SWIG_arg = 0; float *arg1 = (float *) (float *)0 ; - ofMatrix4x4 *result = 0 ; SWIG_check_num_args("ofMatrix4x4::ofMatrix4x4",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::ofMatrix4x4",1,"float const *const"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_float,0))){ SWIG_fail_ptr("new_Matrix4x4",1,SWIGTYPE_p_float); } - result = (ofMatrix4x4 *)new ofMatrix4x4((float const *)arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Matrix4x4__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = 0 ; ofMatrix4x4 *result = 0 ; - SWIG_check_num_args("ofMatrix4x4::ofMatrix4x4",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofMatrix4x4::ofMatrix4x4",1,"ofQuaternion const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("new_Matrix4x4",1,SWIGTYPE_p_ofQuaternion); } - result = (ofMatrix4x4 *)new ofMatrix4x4((ofQuaternion const &)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Matrix4x4__SWIG_4(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - float arg5 ; float arg6 ; float arg7 ; float arg8 ; float arg9 ; float arg10 ; float arg11 ; float arg12 ; float arg13 ; - float arg14 ; float arg15 ; float arg16 ; ofMatrix4x4 *result = 0 ; SWIG_check_num_args("ofMatrix4x4::ofMatrix4x4",16,16) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMatrix4x4::ofMatrix4x4",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::ofMatrix4x4",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix4x4::ofMatrix4x4",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix4x4::ofMatrix4x4",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMatrix4x4::ofMatrix4x4",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofMatrix4x4::ofMatrix4x4",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofMatrix4x4::ofMatrix4x4",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofMatrix4x4::ofMatrix4x4",8,"float"); - if(!lua_isnumber(L,9)) SWIG_fail_arg("ofMatrix4x4::ofMatrix4x4",9,"float"); - if(!lua_isnumber(L,10)) SWIG_fail_arg("ofMatrix4x4::ofMatrix4x4",10,"float"); - if(!lua_isnumber(L,11)) SWIG_fail_arg("ofMatrix4x4::ofMatrix4x4",11,"float"); - if(!lua_isnumber(L,12)) SWIG_fail_arg("ofMatrix4x4::ofMatrix4x4",12,"float"); - if(!lua_isnumber(L,13)) SWIG_fail_arg("ofMatrix4x4::ofMatrix4x4",13,"float"); - if(!lua_isnumber(L,14)) SWIG_fail_arg("ofMatrix4x4::ofMatrix4x4",14,"float"); - if(!lua_isnumber(L,15)) SWIG_fail_arg("ofMatrix4x4::ofMatrix4x4",15,"float"); - if(!lua_isnumber(L,16)) SWIG_fail_arg("ofMatrix4x4::ofMatrix4x4",16,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); - arg8 = (float)lua_tonumber(L, 8); arg9 = (float)lua_tonumber(L, 9); arg10 = (float)lua_tonumber(L, 10); - arg11 = (float)lua_tonumber(L, 11); arg12 = (float)lua_tonumber(L, 12); arg13 = (float)lua_tonumber(L, 13); - arg14 = (float)lua_tonumber(L, 14); arg15 = (float)lua_tonumber(L, 15); arg16 = (float)lua_tonumber(L, 16); - result = (ofMatrix4x4 *)new ofMatrix4x4(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Matrix4x4(lua_State* L) { int argc; int argv[17]={ 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17} ; - argc = lua_gettop(L); if (argc == 0) { return _wrap_new_Matrix4x4__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_new_Matrix4x4__SWIG_1(L);} } if (argc == 1) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_new_Matrix4x4__SWIG_2(L);} } if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_new_Matrix4x4__SWIG_3(L);} } if (argc == 16) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { { _v = lua_isnumber(L,argv[8]); } if (_v) { { - _v = lua_isnumber(L,argv[9]); } if (_v) { { _v = lua_isnumber(L,argv[10]); } if (_v) { { - _v = lua_isnumber(L,argv[11]); } if (_v) { { _v = lua_isnumber(L,argv[12]); } if (_v) { { - _v = lua_isnumber(L,argv[13]); } if (_v) { { _v = lua_isnumber(L,argv[14]); } if (_v) { { - _v = lua_isnumber(L,argv[15]); } if (_v) { return _wrap_new_Matrix4x4__SWIG_4(L);} } } } - } } } } } } } } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_Matrix4x4'\n" " Possible C/C++ prototypes are:\n" - " ofMatrix4x4::ofMatrix4x4()\n" " ofMatrix4x4::ofMatrix4x4(ofMatrix4x4 const &)\n" - " ofMatrix4x4::ofMatrix4x4(float const *const)\n" " ofMatrix4x4::ofMatrix4x4(ofQuaternion const &)\n" - " ofMatrix4x4::ofMatrix4x4(float,float,float,float,float,float,float,float,float,float,float,float,float,float,float,float)\n"); - lua_error(L);return 0; } -static int _wrap_Matrix4x4_makeIdentityMatrix(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - SWIG_check_num_args("ofMatrix4x4::makeIdentityMatrix",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::makeIdentityMatrix",1,"ofMatrix4x4 *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_makeIdentityMatrix",1,SWIGTYPE_p_ofMatrix4x4); } (arg1)->makeIdentityMatrix(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_makeScaleMatrix__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofVec3f *arg2 = 0 ; SWIG_check_num_args("ofMatrix4x4::makeScaleMatrix",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::makeScaleMatrix",1,"ofMatrix4x4 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::makeScaleMatrix",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_makeScaleMatrix",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_makeScaleMatrix",2,SWIGTYPE_p_ofVec3f); } (arg1)->makeScaleMatrix((ofVec3f const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_makeScaleMatrix__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - float arg2 ; float arg3 ; float arg4 ; SWIG_check_num_args("ofMatrix4x4::makeScaleMatrix",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::makeScaleMatrix",1,"ofMatrix4x4 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::makeScaleMatrix",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix4x4::makeScaleMatrix",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix4x4::makeScaleMatrix",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_makeScaleMatrix",1,SWIGTYPE_p_ofMatrix4x4); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); (arg1)->makeScaleMatrix(arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_makeScaleMatrix(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_makeScaleMatrix__SWIG_0(L);} } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Matrix4x4_makeScaleMatrix__SWIG_1(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4_makeScaleMatrix'\n" - " Possible C/C++ prototypes are:\n" " ofMatrix4x4::makeScaleMatrix(ofVec3f const &)\n" - " ofMatrix4x4::makeScaleMatrix(float,float,float)\n"); lua_error(L);return 0; } -static int _wrap_Matrix4x4_makeTranslationMatrix__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; ofVec3f *arg2 = 0 ; SWIG_check_num_args("ofMatrix4x4::makeTranslationMatrix",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::makeTranslationMatrix",1,"ofMatrix4x4 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::makeTranslationMatrix",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_makeTranslationMatrix",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_makeTranslationMatrix",2,SWIGTYPE_p_ofVec3f); } - (arg1)->makeTranslationMatrix((ofVec3f const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_makeTranslationMatrix__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; float arg2 ; float arg3 ; float arg4 ; - SWIG_check_num_args("ofMatrix4x4::makeTranslationMatrix",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::makeTranslationMatrix",1,"ofMatrix4x4 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::makeTranslationMatrix",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix4x4::makeTranslationMatrix",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix4x4::makeTranslationMatrix",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_makeTranslationMatrix",1,SWIGTYPE_p_ofMatrix4x4); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); (arg1)->makeTranslationMatrix(arg2,arg3,arg4); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_makeTranslationMatrix(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_makeTranslationMatrix__SWIG_0(L);} } } if (argc == 4) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Matrix4x4_makeTranslationMatrix__SWIG_1(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4_makeTranslationMatrix'\n" - " Possible C/C++ prototypes are:\n" " ofMatrix4x4::makeTranslationMatrix(ofVec3f const &)\n" - " ofMatrix4x4::makeTranslationMatrix(float,float,float)\n"); lua_error(L);return 0; } -static int _wrap_Matrix4x4_makeRotationMatrix__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofVec3f *arg2 = 0 ; ofVec3f *arg3 = 0 ; SWIG_check_num_args("ofMatrix4x4::makeRotationMatrix",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::makeRotationMatrix",1,"ofMatrix4x4 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::makeRotationMatrix",2,"ofVec3f const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofMatrix4x4::makeRotationMatrix",3,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_makeRotationMatrix",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_makeRotationMatrix",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_makeRotationMatrix",3,SWIGTYPE_p_ofVec3f); } - (arg1)->makeRotationMatrix((ofVec3f const &)*arg2,(ofVec3f const &)*arg3); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_makeRotationMatrix__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - float arg2 ; ofVec3f *arg3 = 0 ; SWIG_check_num_args("ofMatrix4x4::makeRotationMatrix",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::makeRotationMatrix",1,"ofMatrix4x4 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::makeRotationMatrix",2,"float"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofMatrix4x4::makeRotationMatrix",3,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_makeRotationMatrix",1,SWIGTYPE_p_ofMatrix4x4); } arg2 = (float)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_makeRotationMatrix",3,SWIGTYPE_p_ofVec3f); } - (arg1)->makeRotationMatrix(arg2,(ofVec3f const &)*arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Matrix4x4_makeRotationMatrix__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - float arg2 ; float arg3 ; float arg4 ; float arg5 ; SWIG_check_num_args("ofMatrix4x4::makeRotationMatrix",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::makeRotationMatrix",1,"ofMatrix4x4 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::makeRotationMatrix",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix4x4::makeRotationMatrix",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix4x4::makeRotationMatrix",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMatrix4x4::makeRotationMatrix",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_makeRotationMatrix",1,SWIGTYPE_p_ofMatrix4x4); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - (arg1)->makeRotationMatrix(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_makeRotationMatrix__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofQuaternion *arg2 = 0 ; SWIG_check_num_args("ofMatrix4x4::makeRotationMatrix",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::makeRotationMatrix",1,"ofMatrix4x4 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::makeRotationMatrix",2,"ofQuaternion const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_makeRotationMatrix",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Matrix4x4_makeRotationMatrix",2,SWIGTYPE_p_ofQuaternion); } - (arg1)->makeRotationMatrix((ofQuaternion const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Matrix4x4_makeRotationMatrix__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - float arg2 ; ofVec3f *arg3 = 0 ; float arg4 ; ofVec3f *arg5 = 0 ; float arg6 ; ofVec3f *arg7 = 0 ; - SWIG_check_num_args("ofMatrix4x4::makeRotationMatrix",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::makeRotationMatrix",1,"ofMatrix4x4 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::makeRotationMatrix",2,"float"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofMatrix4x4::makeRotationMatrix",3,"ofVec3f const &"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix4x4::makeRotationMatrix",4,"float"); - if(!lua_isuserdata(L,5)) SWIG_fail_arg("ofMatrix4x4::makeRotationMatrix",5,"ofVec3f const &"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofMatrix4x4::makeRotationMatrix",6,"float"); - if(!lua_isuserdata(L,7)) SWIG_fail_arg("ofMatrix4x4::makeRotationMatrix",7,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_makeRotationMatrix",1,SWIGTYPE_p_ofMatrix4x4); } arg2 = (float)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_makeRotationMatrix",3,SWIGTYPE_p_ofVec3f); } arg4 = (float)lua_tonumber(L, 4); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_makeRotationMatrix",5,SWIGTYPE_p_ofVec3f); } arg6 = (float)lua_tonumber(L, 6); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,7,(void**)&arg7,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_makeRotationMatrix",7,SWIGTYPE_p_ofVec3f); } - (arg1)->makeRotationMatrix(arg2,(ofVec3f const &)*arg3,arg4,(ofVec3f const &)*arg5,arg6,(ofVec3f const &)*arg7); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_makeRotationMatrix(lua_State* L) { int argc; int argv[8]={ 1,2,3,4,5,6,7,8} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_makeRotationMatrix__SWIG_3(L);} } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_makeRotationMatrix__SWIG_0(L);} } } } if (argc == 3) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_makeRotationMatrix__SWIG_1(L);} } } } if (argc == 5) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Matrix4x4_makeRotationMatrix__SWIG_2(L);} } } } } } if (argc == 7) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[4])==0 || SWIG_ConvertPtr(L,argv[4], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[6])==0 || SWIG_ConvertPtr(L,argv[6], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_makeRotationMatrix__SWIG_4(L);} } } } } - } } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4_makeRotationMatrix'\n" - " Possible C/C++ prototypes are:\n" " ofMatrix4x4::makeRotationMatrix(ofVec3f const &,ofVec3f const &)\n" - " ofMatrix4x4::makeRotationMatrix(float,ofVec3f const &)\n" - " ofMatrix4x4::makeRotationMatrix(float,float,float,float)\n" " ofMatrix4x4::makeRotationMatrix(ofQuaternion const &)\n" - " ofMatrix4x4::makeRotationMatrix(float,ofVec3f const &,float,ofVec3f const &,float,ofVec3f const &)\n"); - lua_error(L);return 0; } -static int _wrap_Matrix4x4_makeInvertOf(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofMatrix4x4 *arg2 = 0 ; bool result; SWIG_check_num_args("ofMatrix4x4::makeInvertOf",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::makeInvertOf",1,"ofMatrix4x4 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::makeInvertOf",2,"ofMatrix4x4 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_makeInvertOf",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_makeInvertOf",2,SWIGTYPE_p_ofMatrix4x4); } - result = (bool)(arg1)->makeInvertOf((ofMatrix4x4 const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_makeOrthoNormalOf(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofMatrix4x4 *arg2 = 0 ; SWIG_check_num_args("ofMatrix4x4::makeOrthoNormalOf",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::makeOrthoNormalOf",1,"ofMatrix4x4 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::makeOrthoNormalOf",2,"ofMatrix4x4 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_makeOrthoNormalOf",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_makeOrthoNormalOf",2,SWIGTYPE_p_ofMatrix4x4); } - (arg1)->makeOrthoNormalOf((ofMatrix4x4 const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_makeFromMultiplicationOf(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofMatrix4x4 *arg2 = 0 ; ofMatrix4x4 *arg3 = 0 ; SWIG_check_num_args("ofMatrix4x4::makeFromMultiplicationOf",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::makeFromMultiplicationOf",1,"ofMatrix4x4 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::makeFromMultiplicationOf",2,"ofMatrix4x4 const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofMatrix4x4::makeFromMultiplicationOf",3,"ofMatrix4x4 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_makeFromMultiplicationOf",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_makeFromMultiplicationOf",2,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_makeFromMultiplicationOf",3,SWIGTYPE_p_ofMatrix4x4); } - (arg1)->makeFromMultiplicationOf((ofMatrix4x4 const &)*arg2,(ofMatrix4x4 const &)*arg3); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_makeOrthoMatrix(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - double arg2 ; double arg3 ; double arg4 ; double arg5 ; double arg6 ; double arg7 ; - SWIG_check_num_args("ofMatrix4x4::makeOrthoMatrix",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::makeOrthoMatrix",1,"ofMatrix4x4 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::makeOrthoMatrix",2,"double"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix4x4::makeOrthoMatrix",3,"double"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix4x4::makeOrthoMatrix",4,"double"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMatrix4x4::makeOrthoMatrix",5,"double"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofMatrix4x4::makeOrthoMatrix",6,"double"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofMatrix4x4::makeOrthoMatrix",7,"double"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_makeOrthoMatrix",1,SWIGTYPE_p_ofMatrix4x4); } arg2 = (double)lua_tonumber(L, 2); - arg3 = (double)lua_tonumber(L, 3); arg4 = (double)lua_tonumber(L, 4); arg5 = (double)lua_tonumber(L, 5); - arg6 = (double)lua_tonumber(L, 6); arg7 = (double)lua_tonumber(L, 7); (arg1)->makeOrthoMatrix(arg2,arg3,arg4,arg5,arg6,arg7); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_makeOrtho2DMatrix(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - double arg2 ; double arg3 ; double arg4 ; double arg5 ; SWIG_check_num_args("ofMatrix4x4::makeOrtho2DMatrix",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::makeOrtho2DMatrix",1,"ofMatrix4x4 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::makeOrtho2DMatrix",2,"double"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix4x4::makeOrtho2DMatrix",3,"double"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix4x4::makeOrtho2DMatrix",4,"double"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMatrix4x4::makeOrtho2DMatrix",5,"double"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_makeOrtho2DMatrix",1,SWIGTYPE_p_ofMatrix4x4); } arg2 = (double)lua_tonumber(L, 2); - arg3 = (double)lua_tonumber(L, 3); arg4 = (double)lua_tonumber(L, 4); arg5 = (double)lua_tonumber(L, 5); - (arg1)->makeOrtho2DMatrix(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_makeFrustumMatrix(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - double arg2 ; double arg3 ; double arg4 ; double arg5 ; double arg6 ; double arg7 ; - SWIG_check_num_args("ofMatrix4x4::makeFrustumMatrix",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::makeFrustumMatrix",1,"ofMatrix4x4 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::makeFrustumMatrix",2,"double"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix4x4::makeFrustumMatrix",3,"double"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix4x4::makeFrustumMatrix",4,"double"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMatrix4x4::makeFrustumMatrix",5,"double"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofMatrix4x4::makeFrustumMatrix",6,"double"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofMatrix4x4::makeFrustumMatrix",7,"double"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_makeFrustumMatrix",1,SWIGTYPE_p_ofMatrix4x4); } arg2 = (double)lua_tonumber(L, 2); - arg3 = (double)lua_tonumber(L, 3); arg4 = (double)lua_tonumber(L, 4); arg5 = (double)lua_tonumber(L, 5); - arg6 = (double)lua_tonumber(L, 6); arg7 = (double)lua_tonumber(L, 7); - (arg1)->makeFrustumMatrix(arg2,arg3,arg4,arg5,arg6,arg7); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Matrix4x4_makePerspectiveMatrix(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - double arg2 ; double arg3 ; double arg4 ; double arg5 ; SWIG_check_num_args("ofMatrix4x4::makePerspectiveMatrix",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::makePerspectiveMatrix",1,"ofMatrix4x4 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::makePerspectiveMatrix",2,"double"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix4x4::makePerspectiveMatrix",3,"double"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix4x4::makePerspectiveMatrix",4,"double"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMatrix4x4::makePerspectiveMatrix",5,"double"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_makePerspectiveMatrix",1,SWIGTYPE_p_ofMatrix4x4); } arg2 = (double)lua_tonumber(L, 2); - arg3 = (double)lua_tonumber(L, 3); arg4 = (double)lua_tonumber(L, 4); arg5 = (double)lua_tonumber(L, 5); - (arg1)->makePerspectiveMatrix(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_makeLookAtMatrix(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofVec3f *arg2 = 0 ; ofVec3f *arg3 = 0 ; ofVec3f *arg4 = 0 ; SWIG_check_num_args("ofMatrix4x4::makeLookAtMatrix",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::makeLookAtMatrix",1,"ofMatrix4x4 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::makeLookAtMatrix",2,"ofVec3f const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofMatrix4x4::makeLookAtMatrix",3,"ofVec3f const &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofMatrix4x4::makeLookAtMatrix",4,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_makeLookAtMatrix",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_makeLookAtMatrix",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_makeLookAtMatrix",3,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_makeLookAtMatrix",4,SWIGTYPE_p_ofVec3f); } - (arg1)->makeLookAtMatrix((ofVec3f const &)*arg2,(ofVec3f const &)*arg3,(ofVec3f const &)*arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_makeLookAtViewMatrix(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofVec3f *arg2 = 0 ; ofVec3f *arg3 = 0 ; ofVec3f *arg4 = 0 ; SWIG_check_num_args("ofMatrix4x4::makeLookAtViewMatrix",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::makeLookAtViewMatrix",1,"ofMatrix4x4 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::makeLookAtViewMatrix",2,"ofVec3f const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofMatrix4x4::makeLookAtViewMatrix",3,"ofVec3f const &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofMatrix4x4::makeLookAtViewMatrix",4,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_makeLookAtViewMatrix",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_makeLookAtViewMatrix",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_makeLookAtViewMatrix",3,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_makeLookAtViewMatrix",4,SWIGTYPE_p_ofVec3f); } - (arg1)->makeLookAtViewMatrix((ofVec3f const &)*arg2,(ofVec3f const &)*arg3,(ofVec3f const &)*arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_newIdentityMatrix(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 result; - SWIG_check_num_args("ofMatrix4x4::newIdentityMatrix",0,0) result = ofMatrix4x4::newIdentityMatrix(); { - ofMatrix4x4 * resultptr = new ofMatrix4x4((const ofMatrix4x4 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_newScaleMatrix__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = 0 ; ofMatrix4x4 result; - SWIG_check_num_args("ofMatrix4x4::newScaleMatrix",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofMatrix4x4::newScaleMatrix",1,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_newScaleMatrix",1,SWIGTYPE_p_ofVec3f); } - result = ofMatrix4x4::newScaleMatrix((ofVec3f const &)*arg1); { - ofMatrix4x4 * resultptr = new ofMatrix4x4((const ofMatrix4x4 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_newScaleMatrix__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; - ofMatrix4x4 result; SWIG_check_num_args("ofMatrix4x4::newScaleMatrix",3,3) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMatrix4x4::newScaleMatrix",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::newScaleMatrix",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix4x4::newScaleMatrix",3,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); result = ofMatrix4x4::newScaleMatrix(arg1,arg2,arg3); { - ofMatrix4x4 * resultptr = new ofMatrix4x4((const ofMatrix4x4 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_newScaleMatrix(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); - if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_Matrix4x4_newScaleMatrix__SWIG_0(L);} } if (argc == 3) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_Matrix4x4_newScaleMatrix__SWIG_1(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4_newScaleMatrix'\n" - " Possible C/C++ prototypes are:\n" " ofMatrix4x4::newScaleMatrix(ofVec3f const &)\n" - " ofMatrix4x4::newScaleMatrix(float,float,float)\n"); lua_error(L);return 0; } -static int _wrap_Matrix4x4_newTranslationMatrix__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = 0 ; - ofMatrix4x4 result; SWIG_check_num_args("ofMatrix4x4::newTranslationMatrix",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofMatrix4x4::newTranslationMatrix",1,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_newTranslationMatrix",1,SWIGTYPE_p_ofVec3f); } - result = ofMatrix4x4::newTranslationMatrix((ofVec3f const &)*arg1); { - ofMatrix4x4 * resultptr = new ofMatrix4x4((const ofMatrix4x4 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_newTranslationMatrix__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; - ofMatrix4x4 result; SWIG_check_num_args("ofMatrix4x4::newTranslationMatrix",3,3) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMatrix4x4::newTranslationMatrix",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::newTranslationMatrix",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix4x4::newTranslationMatrix",3,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - result = ofMatrix4x4::newTranslationMatrix(arg1,arg2,arg3); { - ofMatrix4x4 * resultptr = new ofMatrix4x4((const ofMatrix4x4 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_newTranslationMatrix(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); - if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_Matrix4x4_newTranslationMatrix__SWIG_0(L);} } if (argc == 3) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_Matrix4x4_newTranslationMatrix__SWIG_1(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4_newTranslationMatrix'\n" - " Possible C/C++ prototypes are:\n" " ofMatrix4x4::newTranslationMatrix(ofVec3f const &)\n" - " ofMatrix4x4::newTranslationMatrix(float,float,float)\n"); lua_error(L);return 0; } -static int _wrap_Matrix4x4_newRotationMatrix__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = 0 ; ofVec3f *arg2 = 0 ; - ofMatrix4x4 result; SWIG_check_num_args("ofMatrix4x4::newRotationMatrix",2,2) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofMatrix4x4::newRotationMatrix",1,"ofVec3f const &"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::newRotationMatrix",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_newRotationMatrix",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_newRotationMatrix",2,SWIGTYPE_p_ofVec3f); } - result = ofMatrix4x4::newRotationMatrix((ofVec3f const &)*arg1,(ofVec3f const &)*arg2); { - ofMatrix4x4 * resultptr = new ofMatrix4x4((const ofMatrix4x4 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_newRotationMatrix__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; - float arg4 ; ofMatrix4x4 result; SWIG_check_num_args("ofMatrix4x4::newRotationMatrix",4,4) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMatrix4x4::newRotationMatrix",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::newRotationMatrix",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix4x4::newRotationMatrix",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix4x4::newRotationMatrix",4,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - result = ofMatrix4x4::newRotationMatrix(arg1,arg2,arg3,arg4); { - ofMatrix4x4 * resultptr = new ofMatrix4x4((const ofMatrix4x4 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_newRotationMatrix__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; ofVec3f *arg2 = 0 ; - ofMatrix4x4 result; SWIG_check_num_args("ofMatrix4x4::newRotationMatrix",2,2) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMatrix4x4::newRotationMatrix",1,"float"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::newRotationMatrix",2,"ofVec3f const &"); - arg1 = (float)lua_tonumber(L, 1); if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_newRotationMatrix",2,SWIGTYPE_p_ofVec3f); } - result = ofMatrix4x4::newRotationMatrix(arg1,(ofVec3f const &)*arg2); { - ofMatrix4x4 * resultptr = new ofMatrix4x4((const ofMatrix4x4 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_newRotationMatrix__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; ofVec3f *arg2 = 0 ; - float arg3 ; ofVec3f *arg4 = 0 ; float arg5 ; ofVec3f *arg6 = 0 ; ofMatrix4x4 result; - SWIG_check_num_args("ofMatrix4x4::newRotationMatrix",6,6) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMatrix4x4::newRotationMatrix",1,"float"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::newRotationMatrix",2,"ofVec3f const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix4x4::newRotationMatrix",3,"float"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofMatrix4x4::newRotationMatrix",4,"ofVec3f const &"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMatrix4x4::newRotationMatrix",5,"float"); - if(!lua_isuserdata(L,6)) SWIG_fail_arg("ofMatrix4x4::newRotationMatrix",6,"ofVec3f const &"); - arg1 = (float)lua_tonumber(L, 1); if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_newRotationMatrix",2,SWIGTYPE_p_ofVec3f); } arg3 = (float)lua_tonumber(L, 3); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_newRotationMatrix",4,SWIGTYPE_p_ofVec3f); } arg5 = (float)lua_tonumber(L, 5); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,6,(void**)&arg6,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_newRotationMatrix",6,SWIGTYPE_p_ofVec3f); } - result = ofMatrix4x4::newRotationMatrix(arg1,(ofVec3f const &)*arg2,arg3,(ofVec3f const &)*arg4,arg5,(ofVec3f const &)*arg6); - { ofMatrix4x4 * resultptr = new ofMatrix4x4((const ofMatrix4x4 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_newRotationMatrix__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = 0 ; - ofMatrix4x4 result; SWIG_check_num_args("ofMatrix4x4::newRotationMatrix",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofMatrix4x4::newRotationMatrix",1,"ofQuaternion const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Matrix4x4_newRotationMatrix",1,SWIGTYPE_p_ofQuaternion); } - result = ofMatrix4x4::newRotationMatrix((ofQuaternion const &)*arg1); { - ofMatrix4x4 * resultptr = new ofMatrix4x4((const ofMatrix4x4 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_newRotationMatrix(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); - if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_newRotationMatrix__SWIG_4(L);} } if (argc == 2) { int _v; { - void *ptr; if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_newRotationMatrix__SWIG_0(L);} } } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_newRotationMatrix__SWIG_2(L);} } } if (argc == 4) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Matrix4x4_newRotationMatrix__SWIG_1(L);} } } } } - if (argc == 6) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[5])==0 || SWIG_ConvertPtr(L,argv[5], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_newRotationMatrix__SWIG_3(L);} } } } } } - } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4_newRotationMatrix'\n" - " Possible C/C++ prototypes are:\n" " ofMatrix4x4::newRotationMatrix(ofVec3f const &,ofVec3f const &)\n" - " ofMatrix4x4::newRotationMatrix(float,float,float,float)\n" " ofMatrix4x4::newRotationMatrix(float,ofVec3f const &)\n" - " ofMatrix4x4::newRotationMatrix(float,ofVec3f const &,float,ofVec3f const &,float,ofVec3f const &)\n" - " ofMatrix4x4::newRotationMatrix(ofQuaternion const &)\n"); lua_error(L);return 0; } -static int _wrap_Matrix4x4_newOrthoMatrix(lua_State* L) { int SWIG_arg = 0; double arg1 ; double arg2 ; double arg3 ; - double arg4 ; double arg5 ; double arg6 ; ofMatrix4x4 result; SWIG_check_num_args("ofMatrix4x4::newOrthoMatrix",6,6) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMatrix4x4::newOrthoMatrix",1,"double"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::newOrthoMatrix",2,"double"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix4x4::newOrthoMatrix",3,"double"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix4x4::newOrthoMatrix",4,"double"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMatrix4x4::newOrthoMatrix",5,"double"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofMatrix4x4::newOrthoMatrix",6,"double"); arg1 = (double)lua_tonumber(L, 1); - arg2 = (double)lua_tonumber(L, 2); arg3 = (double)lua_tonumber(L, 3); arg4 = (double)lua_tonumber(L, 4); - arg5 = (double)lua_tonumber(L, 5); arg6 = (double)lua_tonumber(L, 6); - result = ofMatrix4x4::newOrthoMatrix(arg1,arg2,arg3,arg4,arg5,arg6); { - ofMatrix4x4 * resultptr = new ofMatrix4x4((const ofMatrix4x4 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_newOrtho2DMatrix(lua_State* L) { int SWIG_arg = 0; double arg1 ; double arg2 ; double arg3 ; - double arg4 ; ofMatrix4x4 result; SWIG_check_num_args("ofMatrix4x4::newOrtho2DMatrix",4,4) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMatrix4x4::newOrtho2DMatrix",1,"double"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::newOrtho2DMatrix",2,"double"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix4x4::newOrtho2DMatrix",3,"double"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix4x4::newOrtho2DMatrix",4,"double"); arg1 = (double)lua_tonumber(L, 1); - arg2 = (double)lua_tonumber(L, 2); arg3 = (double)lua_tonumber(L, 3); arg4 = (double)lua_tonumber(L, 4); - result = ofMatrix4x4::newOrtho2DMatrix(arg1,arg2,arg3,arg4); { - ofMatrix4x4 * resultptr = new ofMatrix4x4((const ofMatrix4x4 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_newFrustumMatrix(lua_State* L) { int SWIG_arg = 0; double arg1 ; double arg2 ; double arg3 ; - double arg4 ; double arg5 ; double arg6 ; ofMatrix4x4 result; SWIG_check_num_args("ofMatrix4x4::newFrustumMatrix",6,6) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMatrix4x4::newFrustumMatrix",1,"double"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::newFrustumMatrix",2,"double"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix4x4::newFrustumMatrix",3,"double"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix4x4::newFrustumMatrix",4,"double"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMatrix4x4::newFrustumMatrix",5,"double"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofMatrix4x4::newFrustumMatrix",6,"double"); arg1 = (double)lua_tonumber(L, 1); - arg2 = (double)lua_tonumber(L, 2); arg3 = (double)lua_tonumber(L, 3); arg4 = (double)lua_tonumber(L, 4); - arg5 = (double)lua_tonumber(L, 5); arg6 = (double)lua_tonumber(L, 6); - result = ofMatrix4x4::newFrustumMatrix(arg1,arg2,arg3,arg4,arg5,arg6); { - ofMatrix4x4 * resultptr = new ofMatrix4x4((const ofMatrix4x4 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_newPerspectiveMatrix(lua_State* L) { int SWIG_arg = 0; double arg1 ; double arg2 ; double arg3 ; - double arg4 ; ofMatrix4x4 result; SWIG_check_num_args("ofMatrix4x4::newPerspectiveMatrix",4,4) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMatrix4x4::newPerspectiveMatrix",1,"double"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::newPerspectiveMatrix",2,"double"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix4x4::newPerspectiveMatrix",3,"double"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix4x4::newPerspectiveMatrix",4,"double"); arg1 = (double)lua_tonumber(L, 1); - arg2 = (double)lua_tonumber(L, 2); arg3 = (double)lua_tonumber(L, 3); arg4 = (double)lua_tonumber(L, 4); - result = ofMatrix4x4::newPerspectiveMatrix(arg1,arg2,arg3,arg4); { - ofMatrix4x4 * resultptr = new ofMatrix4x4((const ofMatrix4x4 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_newLookAtMatrix(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = 0 ; ofVec3f *arg2 = 0 ; - ofVec3f *arg3 = 0 ; ofMatrix4x4 result; SWIG_check_num_args("ofMatrix4x4::newLookAtMatrix",3,3) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofMatrix4x4::newLookAtMatrix",1,"ofVec3f const &"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::newLookAtMatrix",2,"ofVec3f const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofMatrix4x4::newLookAtMatrix",3,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_newLookAtMatrix",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_newLookAtMatrix",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_newLookAtMatrix",3,SWIGTYPE_p_ofVec3f); } - result = ofMatrix4x4::newLookAtMatrix((ofVec3f const &)*arg1,(ofVec3f const &)*arg2,(ofVec3f const &)*arg3); { - ofMatrix4x4 * resultptr = new ofMatrix4x4((const ofMatrix4x4 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4___call(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; std::size_t arg2 ; - std::size_t arg3 ; float *result = 0 ; SWIG_check_num_args("ofMatrix4x4::operator ()",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::operator ()",1,"ofMatrix4x4 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::operator ()",2,"std::size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix4x4::operator ()",3,"std::size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4___call",1,SWIGTYPE_p_ofMatrix4x4); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (std::size_t)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (std::size_t)lua_tonumber(L, 3); - result = (float *) &(arg1)->operator ()(arg2,arg3); SWIG_NewPointerObj(L,result,SWIGTYPE_p_float,0); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_getRowAsVec3f(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - std::size_t arg2 ; ofVec3f result; SWIG_check_num_args("ofMatrix4x4::getRowAsVec3f",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::getRowAsVec3f",1,"ofMatrix4x4 const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::getRowAsVec3f",2,"std::size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_getRowAsVec3f",1,SWIGTYPE_p_ofMatrix4x4); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (std::size_t)lua_tonumber(L, 2); - result = ((ofMatrix4x4 const *)arg1)->getRowAsVec3f(arg2); { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_getRowAsVec4f(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - std::size_t arg2 ; ofVec4f result; SWIG_check_num_args("ofMatrix4x4::getRowAsVec4f",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::getRowAsVec4f",1,"ofMatrix4x4 const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::getRowAsVec4f",2,"std::size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_getRowAsVec4f",1,SWIGTYPE_p_ofMatrix4x4); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (std::size_t)lua_tonumber(L, 2); - result = ((ofMatrix4x4 const *)arg1)->getRowAsVec4f(arg2); { ofVec4f * resultptr = new ofVec4f((const ofVec4f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec4f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_getPtr__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - float *result = 0 ; SWIG_check_num_args("ofMatrix4x4::getPtr",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::getPtr",1,"ofMatrix4x4 *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_getPtr",1,SWIGTYPE_p_ofMatrix4x4); } result = (float *)(arg1)->getPtr(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_float,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Matrix4x4_getPtr__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - float *result = 0 ; SWIG_check_num_args("ofMatrix4x4::getPtr",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::getPtr",1,"ofMatrix4x4 const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_getPtr",1,SWIGTYPE_p_ofMatrix4x4); } result = (float *)((ofMatrix4x4 const *)arg1)->getPtr(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_float,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Matrix4x4_getPtr(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_getPtr__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_getPtr__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4_getPtr'\n" " Possible C/C++ prototypes are:\n" - " ofMatrix4x4::getPtr()\n" " ofMatrix4x4::getPtr() const\n"); lua_error(L);return 0; } -static int _wrap_Matrix4x4_isValid(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; bool result; - SWIG_check_num_args("ofMatrix4x4::isValid",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::isValid",1,"ofMatrix4x4 const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_isValid",1,SWIGTYPE_p_ofMatrix4x4); } result = (bool)((ofMatrix4x4 const *)arg1)->isValid(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_isNaN(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; bool result; - SWIG_check_num_args("ofMatrix4x4::isNaN",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::isNaN",1,"ofMatrix4x4 const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_isNaN",1,SWIGTYPE_p_ofMatrix4x4); } result = (bool)((ofMatrix4x4 const *)arg1)->isNaN(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_isIdentity(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; bool result; - SWIG_check_num_args("ofMatrix4x4::isIdentity",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::isIdentity",1,"ofMatrix4x4 const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_isIdentity",1,SWIGTYPE_p_ofMatrix4x4); } result = (bool)((ofMatrix4x4 const *)arg1)->isIdentity(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_set__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofMatrix4x4 *arg2 = 0 ; SWIG_check_num_args("ofMatrix4x4::set",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::set",1,"ofMatrix4x4 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::set",2,"ofMatrix4x4 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_set",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_set",2,SWIGTYPE_p_ofMatrix4x4); } (arg1)->set((ofMatrix4x4 const &)*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_set__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - float *arg2 = (float *) (float *)0 ; SWIG_check_num_args("ofMatrix4x4::set",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::set",1,"ofMatrix4x4 *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofMatrix4x4::set",2,"float const *const"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_set",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_float,0))){ SWIG_fail_ptr("Matrix4x4_set",2,SWIGTYPE_p_float); } - (arg1)->set((float const *)arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_set__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - double *arg2 = (double *) (double *)0 ; SWIG_check_num_args("ofMatrix4x4::set",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::set",1,"ofMatrix4x4 *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofMatrix4x4::set",2,"double const *const"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_set",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_double,0))){ SWIG_fail_ptr("Matrix4x4_set",2,SWIGTYPE_p_double); } - (arg1)->set((double const *)arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_set__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; float arg2 ; - float arg3 ; float arg4 ; float arg5 ; float arg6 ; float arg7 ; float arg8 ; float arg9 ; float arg10 ; float arg11 ; - float arg12 ; float arg13 ; float arg14 ; float arg15 ; float arg16 ; float arg17 ; - SWIG_check_num_args("ofMatrix4x4::set",17,17) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::set",1,"ofMatrix4x4 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix4x4::set",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix4x4::set",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMatrix4x4::set",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofMatrix4x4::set",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofMatrix4x4::set",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofMatrix4x4::set",8,"float"); - if(!lua_isnumber(L,9)) SWIG_fail_arg("ofMatrix4x4::set",9,"float"); - if(!lua_isnumber(L,10)) SWIG_fail_arg("ofMatrix4x4::set",10,"float"); - if(!lua_isnumber(L,11)) SWIG_fail_arg("ofMatrix4x4::set",11,"float"); - if(!lua_isnumber(L,12)) SWIG_fail_arg("ofMatrix4x4::set",12,"float"); - if(!lua_isnumber(L,13)) SWIG_fail_arg("ofMatrix4x4::set",13,"float"); - if(!lua_isnumber(L,14)) SWIG_fail_arg("ofMatrix4x4::set",14,"float"); - if(!lua_isnumber(L,15)) SWIG_fail_arg("ofMatrix4x4::set",15,"float"); - if(!lua_isnumber(L,16)) SWIG_fail_arg("ofMatrix4x4::set",16,"float"); - if(!lua_isnumber(L,17)) SWIG_fail_arg("ofMatrix4x4::set",17,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_set",1,SWIGTYPE_p_ofMatrix4x4); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (float)lua_tonumber(L, 8); - arg9 = (float)lua_tonumber(L, 9); arg10 = (float)lua_tonumber(L, 10); arg11 = (float)lua_tonumber(L, 11); - arg12 = (float)lua_tonumber(L, 12); arg13 = (float)lua_tonumber(L, 13); arg14 = (float)lua_tonumber(L, 14); - arg15 = (float)lua_tonumber(L, 15); arg16 = (float)lua_tonumber(L, 16); arg17 = (float)lua_tonumber(L, 17); - (arg1)->set(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_set(lua_State* L) { int argc; int argv[18]={ 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18} ; - argc = lua_gettop(L); if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_set__SWIG_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_Matrix4x4_set__SWIG_1(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_double, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_set__SWIG_2(L);} } } if (argc == 17) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { { _v = lua_isnumber(L,argv[8]); } if (_v) { { - _v = lua_isnumber(L,argv[9]); } if (_v) { { _v = lua_isnumber(L,argv[10]); } if (_v) { { - _v = lua_isnumber(L,argv[11]); } if (_v) { { _v = lua_isnumber(L,argv[12]); } if (_v) { { - _v = lua_isnumber(L,argv[13]); } if (_v) { { _v = lua_isnumber(L,argv[14]); } if (_v) { { - _v = lua_isnumber(L,argv[15]); } if (_v) { { _v = lua_isnumber(L,argv[16]); } if (_v) { - return _wrap_Matrix4x4_set__SWIG_3(L);} } } } } } } } } } } } } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4_set'\n" " Possible C/C++ prototypes are:\n" - " ofMatrix4x4::set(ofMatrix4x4 const &)\n" " ofMatrix4x4::set(float const *const)\n" - " ofMatrix4x4::set(double const *const)\n" - " ofMatrix4x4::set(float,float,float,float,float,float,float,float,float,float,float,float,float,float,float,float)\n"); - lua_error(L);return 0; } -static int _wrap_Matrix4x4_getInverse(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofMatrix4x4 result; SWIG_check_num_args("ofMatrix4x4::getInverse",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::getInverse",1,"ofMatrix4x4 const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_getInverse",1,SWIGTYPE_p_ofMatrix4x4); } result = ((ofMatrix4x4 const *)arg1)->getInverse(); { - ofMatrix4x4 * resultptr = new ofMatrix4x4((const ofMatrix4x4 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_getOrtho(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; double *arg2 = 0 ; - double *arg3 = 0 ; double *arg4 = 0 ; double *arg5 = 0 ; double *arg6 = 0 ; double *arg7 = 0 ; bool result; - SWIG_check_num_args("ofMatrix4x4::getOrtho",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::getOrtho",1,"ofMatrix4x4 const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::getOrtho",2,"double &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofMatrix4x4::getOrtho",3,"double &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofMatrix4x4::getOrtho",4,"double &"); - if(!lua_isuserdata(L,5)) SWIG_fail_arg("ofMatrix4x4::getOrtho",5,"double &"); - if(!lua_isuserdata(L,6)) SWIG_fail_arg("ofMatrix4x4::getOrtho",6,"double &"); - if(!lua_isuserdata(L,7)) SWIG_fail_arg("ofMatrix4x4::getOrtho",7,"double &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_getOrtho",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_double,0))){ - SWIG_fail_ptr("Matrix4x4_getOrtho",2,SWIGTYPE_p_double); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_double,0))){ - SWIG_fail_ptr("Matrix4x4_getOrtho",3,SWIGTYPE_p_double); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_double,0))){ - SWIG_fail_ptr("Matrix4x4_getOrtho",4,SWIGTYPE_p_double); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_double,0))){ - SWIG_fail_ptr("Matrix4x4_getOrtho",5,SWIGTYPE_p_double); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,6,(void**)&arg6,SWIGTYPE_p_double,0))){ - SWIG_fail_ptr("Matrix4x4_getOrtho",6,SWIGTYPE_p_double); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,7,(void**)&arg7,SWIGTYPE_p_double,0))){ - SWIG_fail_ptr("Matrix4x4_getOrtho",7,SWIGTYPE_p_double); } - result = (bool)((ofMatrix4x4 const *)arg1)->getOrtho(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_getFrustum(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - double *arg2 = 0 ; double *arg3 = 0 ; double *arg4 = 0 ; double *arg5 = 0 ; double *arg6 = 0 ; double *arg7 = 0 ; bool result; - SWIG_check_num_args("ofMatrix4x4::getFrustum",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::getFrustum",1,"ofMatrix4x4 const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::getFrustum",2,"double &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofMatrix4x4::getFrustum",3,"double &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofMatrix4x4::getFrustum",4,"double &"); - if(!lua_isuserdata(L,5)) SWIG_fail_arg("ofMatrix4x4::getFrustum",5,"double &"); - if(!lua_isuserdata(L,6)) SWIG_fail_arg("ofMatrix4x4::getFrustum",6,"double &"); - if(!lua_isuserdata(L,7)) SWIG_fail_arg("ofMatrix4x4::getFrustum",7,"double &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_getFrustum",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_double,0))){ - SWIG_fail_ptr("Matrix4x4_getFrustum",2,SWIGTYPE_p_double); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_double,0))){ - SWIG_fail_ptr("Matrix4x4_getFrustum",3,SWIGTYPE_p_double); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_double,0))){ - SWIG_fail_ptr("Matrix4x4_getFrustum",4,SWIGTYPE_p_double); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_double,0))){ - SWIG_fail_ptr("Matrix4x4_getFrustum",5,SWIGTYPE_p_double); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,6,(void**)&arg6,SWIGTYPE_p_double,0))){ - SWIG_fail_ptr("Matrix4x4_getFrustum",6,SWIGTYPE_p_double); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,7,(void**)&arg7,SWIGTYPE_p_double,0))){ - SWIG_fail_ptr("Matrix4x4_getFrustum",7,SWIGTYPE_p_double); } - result = (bool)((ofMatrix4x4 const *)arg1)->getFrustum(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_getPerspective(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - double *arg2 = 0 ; double *arg3 = 0 ; double *arg4 = 0 ; double *arg5 = 0 ; bool result; - SWIG_check_num_args("ofMatrix4x4::getPerspective",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::getPerspective",1,"ofMatrix4x4 const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::getPerspective",2,"double &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofMatrix4x4::getPerspective",3,"double &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofMatrix4x4::getPerspective",4,"double &"); - if(!lua_isuserdata(L,5)) SWIG_fail_arg("ofMatrix4x4::getPerspective",5,"double &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_getPerspective",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_double,0))){ - SWIG_fail_ptr("Matrix4x4_getPerspective",2,SWIGTYPE_p_double); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_double,0))){ - SWIG_fail_ptr("Matrix4x4_getPerspective",3,SWIGTYPE_p_double); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_double,0))){ - SWIG_fail_ptr("Matrix4x4_getPerspective",4,SWIGTYPE_p_double); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_double,0))){ - SWIG_fail_ptr("Matrix4x4_getPerspective",5,SWIGTYPE_p_double); } - result = (bool)((ofMatrix4x4 const *)arg1)->getPerspective(*arg2,*arg3,*arg4,*arg5); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_getLookAt__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofVec3f *arg2 = 0 ; ofVec3f *arg3 = 0 ; ofVec3f *arg4 = 0 ; float arg5 ; SWIG_check_num_args("ofMatrix4x4::getLookAt",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::getLookAt",1,"ofMatrix4x4 const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::getLookAt",2,"ofVec3f &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofMatrix4x4::getLookAt",3,"ofVec3f &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofMatrix4x4::getLookAt",4,"ofVec3f &"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMatrix4x4::getLookAt",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_getLookAt",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_getLookAt",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_getLookAt",3,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_getLookAt",4,SWIGTYPE_p_ofVec3f); } arg5 = (float)lua_tonumber(L, 5); - ((ofMatrix4x4 const *)arg1)->getLookAt(*arg2,*arg3,*arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Matrix4x4_getLookAt__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofVec3f *arg2 = 0 ; ofVec3f *arg3 = 0 ; ofVec3f *arg4 = 0 ; SWIG_check_num_args("ofMatrix4x4::getLookAt",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::getLookAt",1,"ofMatrix4x4 const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::getLookAt",2,"ofVec3f &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofMatrix4x4::getLookAt",3,"ofVec3f &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofMatrix4x4::getLookAt",4,"ofVec3f &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_getLookAt",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_getLookAt",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_getLookAt",3,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_getLookAt",4,SWIGTYPE_p_ofVec3f); } ((ofMatrix4x4 const *)arg1)->getLookAt(*arg2,*arg3,*arg4); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_getLookAt(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); - if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_getLookAt__SWIG_1(L);} } } } } if (argc == 5) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Matrix4x4_getLookAt__SWIG_0(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4_getLookAt'\n" - " Possible C/C++ prototypes are:\n" " ofMatrix4x4::getLookAt(ofVec3f &,ofVec3f &,ofVec3f &,float) const\n" - " ofMatrix4x4::getLookAt(ofVec3f &,ofVec3f &,ofVec3f &) const\n"); lua_error(L);return 0; } -static int _wrap_Matrix4x4_decompose(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofVec3f *arg2 = 0 ; ofQuaternion *arg3 = 0 ; ofVec3f *arg4 = 0 ; ofQuaternion *arg5 = 0 ; - SWIG_check_num_args("ofMatrix4x4::decompose",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::decompose",1,"ofMatrix4x4 const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::decompose",2,"ofVec3f &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofMatrix4x4::decompose",3,"ofQuaternion &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofMatrix4x4::decompose",4,"ofVec3f &"); - if(!lua_isuserdata(L,5)) SWIG_fail_arg("ofMatrix4x4::decompose",5,"ofQuaternion &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_decompose",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_decompose",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Matrix4x4_decompose",3,SWIGTYPE_p_ofQuaternion); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_decompose",4,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Matrix4x4_decompose",5,SWIGTYPE_p_ofQuaternion); } - ((ofMatrix4x4 const *)arg1)->decompose(*arg2,*arg3,*arg4,*arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Matrix4x4_getInverseOf(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = 0 ; ofMatrix4x4 result; - SWIG_check_num_args("ofMatrix4x4::getInverseOf",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofMatrix4x4::getInverseOf",1,"ofMatrix4x4 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_getInverseOf",1,SWIGTYPE_p_ofMatrix4x4); } - result = ofMatrix4x4::getInverseOf((ofMatrix4x4 const &)*arg1); { - ofMatrix4x4 * resultptr = new ofMatrix4x4((const ofMatrix4x4 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_getTransposedOf(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = 0 ; ofMatrix4x4 result; - SWIG_check_num_args("ofMatrix4x4::getTransposedOf",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofMatrix4x4::getTransposedOf",1,"ofMatrix4x4 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_getTransposedOf",1,SWIGTYPE_p_ofMatrix4x4); } - result = ofMatrix4x4::getTransposedOf((ofMatrix4x4 const &)*arg1); { - ofMatrix4x4 * resultptr = new ofMatrix4x4((const ofMatrix4x4 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_getOrthoNormalOf(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = 0 ; ofMatrix4x4 result; - SWIG_check_num_args("ofMatrix4x4::getOrthoNormalOf",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofMatrix4x4::getOrthoNormalOf",1,"ofMatrix4x4 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_getOrthoNormalOf",1,SWIGTYPE_p_ofMatrix4x4); } - result = ofMatrix4x4::getOrthoNormalOf((ofMatrix4x4 const &)*arg1); { - ofMatrix4x4 * resultptr = new ofMatrix4x4((const ofMatrix4x4 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_postMult__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofVec3f *arg2 = 0 ; ofVec3f result; SWIG_check_num_args("ofMatrix4x4::postMult",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::postMult",1,"ofMatrix4x4 const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::postMult",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_postMult",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_postMult",2,SWIGTYPE_p_ofVec3f); } - result = ((ofMatrix4x4 const *)arg1)->postMult((ofVec3f const &)*arg2); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_postMult__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofVec4f *arg2 = 0 ; ofVec4f result; SWIG_check_num_args("ofMatrix4x4::postMult",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::postMult",1,"ofMatrix4x4 const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::postMult",2,"ofVec4f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_postMult",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec4f,0))){ - SWIG_fail_ptr("Matrix4x4_postMult",2,SWIGTYPE_p_ofVec4f); } - result = ((ofMatrix4x4 const *)arg1)->postMult((ofVec4f const &)*arg2); { - ofVec4f * resultptr = new ofVec4f((const ofVec4f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec4f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_postMult__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofMatrix4x4 *arg2 = 0 ; SWIG_check_num_args("ofMatrix4x4::postMult",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::postMult",1,"ofMatrix4x4 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::postMult",2,"ofMatrix4x4 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_postMult",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_postMult",2,SWIGTYPE_p_ofMatrix4x4); } (arg1)->postMult((ofMatrix4x4 const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_postMult(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_postMult__SWIG_0(L);} } } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_postMult__SWIG_1(L);} } } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_postMult__SWIG_2(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4_postMult'\n" " Possible C/C++ prototypes are:\n" - " ofMatrix4x4::postMult(ofVec3f const &) const\n" " ofMatrix4x4::postMult(ofVec4f const &) const\n" - " ofMatrix4x4::postMult(ofMatrix4x4 const &)\n"); lua_error(L);return 0; } -static int _wrap_Matrix4x4_preMult__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofVec3f *arg2 = 0 ; ofVec3f result; SWIG_check_num_args("ofMatrix4x4::preMult",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::preMult",1,"ofMatrix4x4 const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::preMult",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_preMult",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_preMult",2,SWIGTYPE_p_ofVec3f); } - result = ((ofMatrix4x4 const *)arg1)->preMult((ofVec3f const &)*arg2); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_preMult__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofVec4f *arg2 = 0 ; ofVec4f result; SWIG_check_num_args("ofMatrix4x4::preMult",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::preMult",1,"ofMatrix4x4 const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::preMult",2,"ofVec4f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_preMult",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec4f,0))){ - SWIG_fail_ptr("Matrix4x4_preMult",2,SWIGTYPE_p_ofVec4f); } - result = ((ofMatrix4x4 const *)arg1)->preMult((ofVec4f const &)*arg2); { - ofVec4f * resultptr = new ofVec4f((const ofVec4f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec4f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_preMult__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofMatrix4x4 *arg2 = 0 ; SWIG_check_num_args("ofMatrix4x4::preMult",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::preMult",1,"ofMatrix4x4 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::preMult",2,"ofMatrix4x4 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_preMult",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_preMult",2,SWIGTYPE_p_ofMatrix4x4); } (arg1)->preMult((ofMatrix4x4 const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_preMult(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_preMult__SWIG_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_preMult__SWIG_1(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_preMult__SWIG_2(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4_preMult'\n" " Possible C/C++ prototypes are:\n" - " ofMatrix4x4::preMult(ofVec3f const &) const\n" " ofMatrix4x4::preMult(ofVec4f const &) const\n" - " ofMatrix4x4::preMult(ofMatrix4x4 const &)\n"); lua_error(L);return 0; } -static int _wrap_Matrix4x4___mul__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofMatrix4x4 *arg2 = 0 ; ofMatrix4x4 result; SWIG_check_num_args("ofMatrix4x4::operator *",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::operator *",1,"ofMatrix4x4 const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::operator *",2,"ofMatrix4x4 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4___mul",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4___mul",2,SWIGTYPE_p_ofMatrix4x4); } - result = ((ofMatrix4x4 const *)arg1)->operator *((ofMatrix4x4 const &)*arg2); { - ofMatrix4x4 * resultptr = new ofMatrix4x4((const ofMatrix4x4 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4___mul__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofVec3f *arg2 = 0 ; ofVec3f result; SWIG_check_num_args("ofMatrix4x4::operator *",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::operator *",1,"ofMatrix4x4 const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::operator *",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4___mul",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4___mul",2,SWIGTYPE_p_ofVec3f); } - result = ((ofMatrix4x4 const *)arg1)->operator *((ofVec3f const &)*arg2); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4___mul__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofVec4f *arg2 = 0 ; ofVec4f result; SWIG_check_num_args("ofMatrix4x4::operator *",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::operator *",1,"ofMatrix4x4 const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::operator *",2,"ofVec4f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4___mul",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec4f,0))){ - SWIG_fail_ptr("Matrix4x4___mul",2,SWIGTYPE_p_ofVec4f); } - result = ((ofMatrix4x4 const *)arg1)->operator *((ofVec4f const &)*arg2); { - ofVec4f * resultptr = new ofVec4f((const ofVec4f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec4f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4___mul(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4___mul__SWIG_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4___mul__SWIG_1(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4___mul__SWIG_2(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4___mul'\n" " Possible C/C++ prototypes are:\n" - " ofMatrix4x4::operator *(ofMatrix4x4 const &) const\n" " ofMatrix4x4::operator *(ofVec3f const &) const\n" - " ofMatrix4x4::operator *(ofVec4f const &) const\n"); lua_error(L);return 0; } -static int _wrap_Matrix4x4_postMultTranslate__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofVec3f *arg2 = 0 ; SWIG_check_num_args("ofMatrix4x4::postMultTranslate",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::postMultTranslate",1,"ofMatrix4x4 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::postMultTranslate",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_postMultTranslate",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_postMultTranslate",2,SWIGTYPE_p_ofVec3f); } (arg1)->postMultTranslate((ofVec3f const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_postMultScale__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofVec3f *arg2 = 0 ; SWIG_check_num_args("ofMatrix4x4::postMultScale",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::postMultScale",1,"ofMatrix4x4 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::postMultScale",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_postMultScale",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_postMultScale",2,SWIGTYPE_p_ofVec3f); } (arg1)->postMultScale((ofVec3f const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_postMultRotate__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofQuaternion *arg2 = 0 ; SWIG_check_num_args("ofMatrix4x4::postMultRotate",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::postMultRotate",1,"ofMatrix4x4 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::postMultRotate",2,"ofQuaternion const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_postMultRotate",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Matrix4x4_postMultRotate",2,SWIGTYPE_p_ofQuaternion); } (arg1)->postMultRotate((ofQuaternion const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_postMultTranslate__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - float arg2 ; float arg3 ; float arg4 ; SWIG_check_num_args("ofMatrix4x4::postMultTranslate",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::postMultTranslate",1,"ofMatrix4x4 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::postMultTranslate",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix4x4::postMultTranslate",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix4x4::postMultTranslate",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_postMultTranslate",1,SWIGTYPE_p_ofMatrix4x4); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); (arg1)->postMultTranslate(arg2,arg3,arg4); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_postMultTranslate(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_postMultTranslate__SWIG_0(L);} } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Matrix4x4_postMultTranslate__SWIG_1(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4_postMultTranslate'\n" - " Possible C/C++ prototypes are:\n" " ofMatrix4x4::postMultTranslate(ofVec3f const &)\n" - " ofMatrix4x4::postMultTranslate(float,float,float)\n"); lua_error(L);return 0; } -static int _wrap_Matrix4x4_postMultRotate__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - float arg2 ; float arg3 ; float arg4 ; float arg5 ; SWIG_check_num_args("ofMatrix4x4::postMultRotate",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::postMultRotate",1,"ofMatrix4x4 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::postMultRotate",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix4x4::postMultRotate",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix4x4::postMultRotate",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMatrix4x4::postMultRotate",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_postMultRotate",1,SWIGTYPE_p_ofMatrix4x4); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - (arg1)->postMultRotate(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_postMultRotate(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_postMultRotate__SWIG_0(L);} } } if (argc == 5) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Matrix4x4_postMultRotate__SWIG_1(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4_postMultRotate'\n" - " Possible C/C++ prototypes are:\n" " ofMatrix4x4::postMultRotate(ofQuaternion const &)\n" - " ofMatrix4x4::postMultRotate(float,float,float,float)\n"); lua_error(L);return 0; } -static int _wrap_Matrix4x4_postMultScale__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - float arg2 ; float arg3 ; float arg4 ; SWIG_check_num_args("ofMatrix4x4::postMultScale",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::postMultScale",1,"ofMatrix4x4 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::postMultScale",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix4x4::postMultScale",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix4x4::postMultScale",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_postMultScale",1,SWIGTYPE_p_ofMatrix4x4); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); (arg1)->postMultScale(arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_postMultScale(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_postMultScale__SWIG_0(L);} } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Matrix4x4_postMultScale__SWIG_1(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4_postMultScale'\n" - " Possible C/C++ prototypes are:\n" " ofMatrix4x4::postMultScale(ofVec3f const &)\n" - " ofMatrix4x4::postMultScale(float,float,float)\n"); lua_error(L);return 0; } -static int _wrap_Matrix4x4_preMultScale(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofVec3f *arg2 = 0 ; SWIG_check_num_args("ofMatrix4x4::preMultScale",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::preMultScale",1,"ofMatrix4x4 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::preMultScale",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_preMultScale",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_preMultScale",2,SWIGTYPE_p_ofVec3f); } (arg1)->preMultScale((ofVec3f const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_preMultTranslate(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofVec3f *arg2 = 0 ; SWIG_check_num_args("ofMatrix4x4::preMultTranslate",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::preMultTranslate",1,"ofMatrix4x4 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::preMultTranslate",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_preMultTranslate",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_preMultTranslate",2,SWIGTYPE_p_ofVec3f); } (arg1)->preMultTranslate((ofVec3f const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_preMultRotate(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofQuaternion *arg2 = 0 ; SWIG_check_num_args("ofMatrix4x4::preMultRotate",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::preMultRotate",1,"ofMatrix4x4 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::preMultRotate",2,"ofQuaternion const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_preMultRotate",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Matrix4x4_preMultRotate",2,SWIGTYPE_p_ofQuaternion); } (arg1)->preMultRotate((ofQuaternion const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_setRotate(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofQuaternion *arg2 = 0 ; SWIG_check_num_args("ofMatrix4x4::setRotate",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::setRotate",1,"ofMatrix4x4 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::setRotate",2,"ofQuaternion const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_setRotate",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Matrix4x4_setRotate",2,SWIGTYPE_p_ofQuaternion); } (arg1)->setRotate((ofQuaternion const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_setTranslation__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - float arg2 ; float arg3 ; float arg4 ; SWIG_check_num_args("ofMatrix4x4::setTranslation",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::setTranslation",1,"ofMatrix4x4 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::setTranslation",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix4x4::setTranslation",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix4x4::setTranslation",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_setTranslation",1,SWIGTYPE_p_ofMatrix4x4); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); (arg1)->setTranslation(arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_setTranslation__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofVec3f *arg2 = 0 ; SWIG_check_num_args("ofMatrix4x4::setTranslation",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::setTranslation",1,"ofMatrix4x4 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::setTranslation",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_setTranslation",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_setTranslation",2,SWIGTYPE_p_ofVec3f); } (arg1)->setTranslation((ofVec3f const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_setTranslation(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_setTranslation__SWIG_1(L);} } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Matrix4x4_setTranslation__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4_setTranslation'\n" - " Possible C/C++ prototypes are:\n" " ofMatrix4x4::setTranslation(float,float,float)\n" - " ofMatrix4x4::setTranslation(ofVec3f const &)\n"); lua_error(L);return 0; } -static int _wrap_Matrix4x4_rotate__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; float arg2 ; - float arg3 ; float arg4 ; float arg5 ; SWIG_check_num_args("ofMatrix4x4::rotate",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::rotate",1,"ofMatrix4x4 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::rotate",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix4x4::rotate",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix4x4::rotate",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMatrix4x4::rotate",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_rotate",1,SWIGTYPE_p_ofMatrix4x4); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - (arg1)->rotate(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_rotateRad(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; float arg2 ; - float arg3 ; float arg4 ; float arg5 ; SWIG_check_num_args("ofMatrix4x4::rotateRad",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::rotateRad",1,"ofMatrix4x4 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::rotateRad",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix4x4::rotateRad",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix4x4::rotateRad",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMatrix4x4::rotateRad",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_rotateRad",1,SWIGTYPE_p_ofMatrix4x4); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - (arg1)->rotateRad(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_rotate__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofQuaternion *arg2 = 0 ; SWIG_check_num_args("ofMatrix4x4::rotate",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::rotate",1,"ofMatrix4x4 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::rotate",2,"ofQuaternion const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_rotate",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Matrix4x4_rotate",2,SWIGTYPE_p_ofQuaternion); } (arg1)->rotate((ofQuaternion const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_rotate(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_rotate__SWIG_1(L);} } } if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Matrix4x4_rotate__SWIG_0(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4_rotate'\n" " Possible C/C++ prototypes are:\n" - " ofMatrix4x4::rotate(float,float,float,float)\n" " ofMatrix4x4::rotate(ofQuaternion const &)\n"); - lua_error(L);return 0; } -static int _wrap_Matrix4x4_translate__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - float arg2 ; float arg3 ; float arg4 ; SWIG_check_num_args("ofMatrix4x4::translate",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::translate",1,"ofMatrix4x4 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::translate",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix4x4::translate",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix4x4::translate",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_translate",1,SWIGTYPE_p_ofMatrix4x4); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); (arg1)->translate(arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_translate__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofVec3f *arg2 = 0 ; SWIG_check_num_args("ofMatrix4x4::translate",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::translate",1,"ofMatrix4x4 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::translate",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_translate",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_translate",2,SWIGTYPE_p_ofVec3f); } (arg1)->translate((ofVec3f const &)*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_translate(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_translate__SWIG_1(L);} } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Matrix4x4_translate__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4_translate'\n" - " Possible C/C++ prototypes are:\n" " ofMatrix4x4::translate(float,float,float)\n" - " ofMatrix4x4::translate(ofVec3f const &)\n"); lua_error(L);return 0; } -static int _wrap_Matrix4x4_scale__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; float arg2 ; - float arg3 ; float arg4 ; SWIG_check_num_args("ofMatrix4x4::scale",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::scale",1,"ofMatrix4x4 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::scale",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix4x4::scale",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix4x4::scale",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_scale",1,SWIGTYPE_p_ofMatrix4x4); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); (arg1)->scale(arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_scale__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofVec3f *arg2 = 0 ; SWIG_check_num_args("ofMatrix4x4::scale",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::scale",1,"ofMatrix4x4 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::scale",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_scale",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_scale",2,SWIGTYPE_p_ofVec3f); } (arg1)->scale((ofVec3f const &)*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_scale(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_scale__SWIG_1(L);} } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Matrix4x4_scale__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4_scale'\n" " Possible C/C++ prototypes are:\n" - " ofMatrix4x4::scale(float,float,float)\n" " ofMatrix4x4::scale(ofVec3f const &)\n"); lua_error(L);return 0; } -static int _wrap_Matrix4x4_glRotate__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - float arg2 ; float arg3 ; float arg4 ; float arg5 ; SWIG_check_num_args("ofMatrix4x4::glRotate",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::glRotate",1,"ofMatrix4x4 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::glRotate",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix4x4::glRotate",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix4x4::glRotate",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMatrix4x4::glRotate",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_glRotate",1,SWIGTYPE_p_ofMatrix4x4); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - (arg1)->glRotate(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_glRotateRad(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; float arg2 ; - float arg3 ; float arg4 ; float arg5 ; SWIG_check_num_args("ofMatrix4x4::glRotateRad",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::glRotateRad",1,"ofMatrix4x4 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::glRotateRad",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix4x4::glRotateRad",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix4x4::glRotateRad",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMatrix4x4::glRotateRad",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_glRotateRad",1,SWIGTYPE_p_ofMatrix4x4); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - (arg1)->glRotateRad(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_glRotate__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofQuaternion *arg2 = 0 ; SWIG_check_num_args("ofMatrix4x4::glRotate",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::glRotate",1,"ofMatrix4x4 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::glRotate",2,"ofQuaternion const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_glRotate",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Matrix4x4_glRotate",2,SWIGTYPE_p_ofQuaternion); } (arg1)->glRotate((ofQuaternion const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_glRotate(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_glRotate__SWIG_1(L);} } } if (argc == 5) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Matrix4x4_glRotate__SWIG_0(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4_glRotate'\n" " Possible C/C++ prototypes are:\n" - " ofMatrix4x4::glRotate(float,float,float,float)\n" " ofMatrix4x4::glRotate(ofQuaternion const &)\n"); - lua_error(L);return 0; } -static int _wrap_Matrix4x4_glTranslate__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - float arg2 ; float arg3 ; float arg4 ; SWIG_check_num_args("ofMatrix4x4::glTranslate",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::glTranslate",1,"ofMatrix4x4 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::glTranslate",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix4x4::glTranslate",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix4x4::glTranslate",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_glTranslate",1,SWIGTYPE_p_ofMatrix4x4); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); (arg1)->glTranslate(arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_glTranslate__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofVec3f *arg2 = 0 ; SWIG_check_num_args("ofMatrix4x4::glTranslate",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::glTranslate",1,"ofMatrix4x4 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::glTranslate",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_glTranslate",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_glTranslate",2,SWIGTYPE_p_ofVec3f); } (arg1)->glTranslate((ofVec3f const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_glTranslate(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_glTranslate__SWIG_1(L);} } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Matrix4x4_glTranslate__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4_glTranslate'\n" - " Possible C/C++ prototypes are:\n" " ofMatrix4x4::glTranslate(float,float,float)\n" - " ofMatrix4x4::glTranslate(ofVec3f const &)\n"); lua_error(L);return 0; } -static int _wrap_Matrix4x4_glScale__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - float arg2 ; float arg3 ; float arg4 ; SWIG_check_num_args("ofMatrix4x4::glScale",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::glScale",1,"ofMatrix4x4 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::glScale",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix4x4::glScale",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix4x4::glScale",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_glScale",1,SWIGTYPE_p_ofMatrix4x4); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); (arg1)->glScale(arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_glScale__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofVec3f *arg2 = 0 ; SWIG_check_num_args("ofMatrix4x4::glScale",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::glScale",1,"ofMatrix4x4 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::glScale",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_glScale",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_glScale",2,SWIGTYPE_p_ofVec3f); } (arg1)->glScale((ofVec3f const &)*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_glScale(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_glScale__SWIG_1(L);} } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Matrix4x4_glScale__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4_glScale'\n" " Possible C/C++ prototypes are:\n" - " ofMatrix4x4::glScale(float,float,float)\n" " ofMatrix4x4::glScale(ofVec3f const &)\n"); lua_error(L);return 0; } -static int _wrap_Matrix4x4_getRotate(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofQuaternion result; SWIG_check_num_args("ofMatrix4x4::getRotate",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::getRotate",1,"ofMatrix4x4 const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_getRotate",1,SWIGTYPE_p_ofMatrix4x4); } result = ((ofMatrix4x4 const *)arg1)->getRotate(); { - ofQuaternion * resultptr = new ofQuaternion((const ofQuaternion &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofQuaternion,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_getTranslation(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofVec3f result; SWIG_check_num_args("ofMatrix4x4::getTranslation",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::getTranslation",1,"ofMatrix4x4 const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_getTranslation",1,SWIGTYPE_p_ofMatrix4x4); } - result = ((ofMatrix4x4 const *)arg1)->getTranslation(); { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_getScale(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; ofVec3f result; - SWIG_check_num_args("ofMatrix4x4::getScale",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::getScale",1,"ofMatrix4x4 const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_getScale",1,SWIGTYPE_p_ofMatrix4x4); } result = ((ofMatrix4x4 const *)arg1)->getScale(); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_transform3x3__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = 0 ; ofMatrix4x4 *arg2 = 0 ; - ofVec3f result; SWIG_check_num_args("ofMatrix4x4::transform3x3",2,2) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofMatrix4x4::transform3x3",1,"ofVec3f const &"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::transform3x3",2,"ofMatrix4x4 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_transform3x3",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_transform3x3",2,SWIGTYPE_p_ofMatrix4x4); } - result = ofMatrix4x4::transform3x3((ofVec3f const &)*arg1,(ofMatrix4x4 const &)*arg2); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_transform3x3__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = 0 ; ofVec3f *arg2 = 0 ; - ofVec3f result; SWIG_check_num_args("ofMatrix4x4::transform3x3",2,2) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofMatrix4x4::transform3x3",1,"ofMatrix4x4 const &"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::transform3x3",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_transform3x3",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_transform3x3",2,SWIGTYPE_p_ofVec3f); } - result = ofMatrix4x4::transform3x3((ofMatrix4x4 const &)*arg1,(ofVec3f const &)*arg2); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_transform3x3(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_transform3x3__SWIG_0(L);} } } if (argc == 2) { int _v; { - void *ptr; if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_transform3x3__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4_transform3x3'\n" - " Possible C/C++ prototypes are:\n" " ofMatrix4x4::transform3x3(ofVec3f const &,ofMatrix4x4 const &)\n" - " ofMatrix4x4::transform3x3(ofMatrix4x4 const &,ofVec3f const &)\n"); lua_error(L);return 0; } -static int _wrap_Matrix4x4___tostring(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - char *result = 0 ; SWIG_check_num_args("ofMatrix4x4::__str__",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::__str__",1,"ofMatrix4x4 *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4___tostring",1,SWIGTYPE_p_ofMatrix4x4); } result = (char *)ofMatrix4x4___str__(arg1); - lua_pushstring(L,(const char *)result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_Matrix4x4(void *obj) { -ofMatrix4x4 *arg1 = (ofMatrix4x4 *) obj; -delete arg1; -} -static int _proxy__wrap_new_Matrix4x4(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_Matrix4x4); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_Matrix4x4_attributes[] = { - { "_mat", _wrap_Matrix4x4__mat_get, _wrap_Matrix4x4__mat_set }, - {0,0,0} -}; -static swig_lua_method swig_Matrix4x4_methods[]= { - { "makeIdentityMatrix", _wrap_Matrix4x4_makeIdentityMatrix}, - { "makeScaleMatrix", _wrap_Matrix4x4_makeScaleMatrix}, - { "makeTranslationMatrix", _wrap_Matrix4x4_makeTranslationMatrix}, - { "makeRotationMatrix", _wrap_Matrix4x4_makeRotationMatrix}, - { "makeInvertOf", _wrap_Matrix4x4_makeInvertOf}, - { "makeOrthoNormalOf", _wrap_Matrix4x4_makeOrthoNormalOf}, - { "makeFromMultiplicationOf", _wrap_Matrix4x4_makeFromMultiplicationOf}, - { "makeOrthoMatrix", _wrap_Matrix4x4_makeOrthoMatrix}, - { "makeOrtho2DMatrix", _wrap_Matrix4x4_makeOrtho2DMatrix}, - { "makeFrustumMatrix", _wrap_Matrix4x4_makeFrustumMatrix}, - { "makePerspectiveMatrix", _wrap_Matrix4x4_makePerspectiveMatrix}, - { "makeLookAtMatrix", _wrap_Matrix4x4_makeLookAtMatrix}, - { "makeLookAtViewMatrix", _wrap_Matrix4x4_makeLookAtViewMatrix}, - { "__call", _wrap_Matrix4x4___call}, - { "getRowAsVec3f", _wrap_Matrix4x4_getRowAsVec3f}, - { "getRowAsVec4f", _wrap_Matrix4x4_getRowAsVec4f}, - { "getPtr", _wrap_Matrix4x4_getPtr}, - { "isValid", _wrap_Matrix4x4_isValid}, - { "isNaN", _wrap_Matrix4x4_isNaN}, - { "isIdentity", _wrap_Matrix4x4_isIdentity}, - { "set", _wrap_Matrix4x4_set}, - { "getInverse", _wrap_Matrix4x4_getInverse}, - { "getOrtho", _wrap_Matrix4x4_getOrtho}, - { "getFrustum", _wrap_Matrix4x4_getFrustum}, - { "getPerspective", _wrap_Matrix4x4_getPerspective}, - { "getLookAt", _wrap_Matrix4x4_getLookAt}, - { "decompose", _wrap_Matrix4x4_decompose}, - { "postMult", _wrap_Matrix4x4_postMult}, - { "preMult", _wrap_Matrix4x4_preMult}, - { "__mul", _wrap_Matrix4x4___mul}, - { "postMultTranslate", _wrap_Matrix4x4_postMultTranslate}, - { "postMultRotate", _wrap_Matrix4x4_postMultRotate}, - { "postMultScale", _wrap_Matrix4x4_postMultScale}, - { "preMultScale", _wrap_Matrix4x4_preMultScale}, - { "preMultTranslate", _wrap_Matrix4x4_preMultTranslate}, - { "preMultRotate", _wrap_Matrix4x4_preMultRotate}, - { "setRotate", _wrap_Matrix4x4_setRotate}, - { "setTranslation", _wrap_Matrix4x4_setTranslation}, - { "rotateRad", _wrap_Matrix4x4_rotateRad}, - { "rotate", _wrap_Matrix4x4_rotate}, - { "translate", _wrap_Matrix4x4_translate}, - { "scale", _wrap_Matrix4x4_scale}, - { "glRotateRad", _wrap_Matrix4x4_glRotateRad}, - { "glRotate", _wrap_Matrix4x4_glRotate}, - { "glTranslate", _wrap_Matrix4x4_glTranslate}, - { "glScale", _wrap_Matrix4x4_glScale}, - { "getRotate", _wrap_Matrix4x4_getRotate}, - { "getTranslation", _wrap_Matrix4x4_getTranslation}, - { "getScale", _wrap_Matrix4x4_getScale}, - { "__tostring", _wrap_Matrix4x4___tostring}, - {0,0} -}; -static swig_lua_method swig_Matrix4x4_meta[] = { - { "__call", _wrap_Matrix4x4___call}, - { "__mul", _wrap_Matrix4x4___mul}, - { "__tostring", _wrap_Matrix4x4___tostring}, - {0,0} -}; - -static swig_lua_attribute swig_Matrix4x4_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_Matrix4x4_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_Matrix4x4_Sf_SwigStatic_methods[]= { - { "newIdentityMatrix", _wrap_Matrix4x4_newIdentityMatrix}, - { "newScaleMatrix", _wrap_Matrix4x4_newScaleMatrix}, - { "newTranslationMatrix", _wrap_Matrix4x4_newTranslationMatrix}, - { "newRotationMatrix", _wrap_Matrix4x4_newRotationMatrix}, - { "newOrthoMatrix", _wrap_Matrix4x4_newOrthoMatrix}, - { "newOrtho2DMatrix", _wrap_Matrix4x4_newOrtho2DMatrix}, - { "newFrustumMatrix", _wrap_Matrix4x4_newFrustumMatrix}, - { "newPerspectiveMatrix", _wrap_Matrix4x4_newPerspectiveMatrix}, - { "newLookAtMatrix", _wrap_Matrix4x4_newLookAtMatrix}, - { "getInverseOf", _wrap_Matrix4x4_getInverseOf}, - { "getTransposedOf", _wrap_Matrix4x4_getTransposedOf}, - { "getOrthoNormalOf", _wrap_Matrix4x4_getOrthoNormalOf}, - { "transform3x3", _wrap_Matrix4x4_transform3x3}, - {0,0} -}; -static swig_lua_class* swig_Matrix4x4_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_Matrix4x4_Sf_SwigStatic = { - "Matrix4x4", - swig_Matrix4x4_Sf_SwigStatic_methods, - swig_Matrix4x4_Sf_SwigStatic_attributes, - swig_Matrix4x4_Sf_SwigStatic_constants, - swig_Matrix4x4_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_Matrix4x4_bases[] = {0}; -static const char *swig_Matrix4x4_base_names[] = {0}; -static swig_lua_class _wrap_class_Matrix4x4 = { "Matrix4x4", "Matrix4x4", &SWIGTYPE_p_ofMatrix4x4,_proxy__wrap_new_Matrix4x4, swig_delete_Matrix4x4, swig_Matrix4x4_methods, swig_Matrix4x4_attributes, &swig_Matrix4x4_Sf_SwigStatic, swig_Matrix4x4_meta, swig_Matrix4x4_bases, swig_Matrix4x4_base_names }; - -static int _wrap_Quaternion__v_set(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; - ofVec4f *arg2 = (ofVec4f *) 0 ; SWIG_check_num_args("ofQuaternion::_v",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::_v",1,"ofQuaternion *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofQuaternion::_v",2,"ofVec4f *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion__v_set",1,SWIGTYPE_p_ofQuaternion); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec4f,0))){ - SWIG_fail_ptr("Quaternion__v_set",2,SWIGTYPE_p_ofVec4f); } if (arg1) (arg1)->_v = *arg2; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Quaternion__v_get(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; - ofVec4f *result = 0 ; SWIG_check_num_args("ofQuaternion::_v",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::_v",1,"ofQuaternion *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion__v_get",1,SWIGTYPE_p_ofQuaternion); } result = (ofVec4f *)& ((arg1)->_v); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec4f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Quaternion__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofQuaternion *result = 0 ; - SWIG_check_num_args("ofQuaternion::ofQuaternion",0,0) result = (ofQuaternion *)new ofQuaternion(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofQuaternion,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Quaternion__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - ofQuaternion *result = 0 ; SWIG_check_num_args("ofQuaternion::ofQuaternion",4,4) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofQuaternion::ofQuaternion",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofQuaternion::ofQuaternion",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofQuaternion::ofQuaternion",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofQuaternion::ofQuaternion",4,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - result = (ofQuaternion *)new ofQuaternion(arg1,arg2,arg3,arg4); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofQuaternion,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Quaternion__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = 0 ; ofQuaternion *result = 0 ; - SWIG_check_num_args("ofQuaternion::ofQuaternion",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofQuaternion::ofQuaternion",1,"ofVec4f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ - SWIG_fail_ptr("new_Quaternion",1,SWIGTYPE_p_ofVec4f); } result = (ofQuaternion *)new ofQuaternion((ofVec4f const &)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofQuaternion,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Quaternion__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; ofVec3f *arg2 = 0 ; - ofQuaternion *result = 0 ; SWIG_check_num_args("ofQuaternion::ofQuaternion",2,2) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofQuaternion::ofQuaternion",1,"float"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofQuaternion::ofQuaternion",2,"ofVec3f const &"); arg1 = (float)lua_tonumber(L, 1); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("new_Quaternion",2,SWIGTYPE_p_ofVec3f); } - result = (ofQuaternion *)new ofQuaternion(arg1,(ofVec3f const &)*arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofQuaternion,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Quaternion__SWIG_4(lua_State* L) { int SWIG_arg = 0; float arg1 ; ofVec3f *arg2 = 0 ; float arg3 ; - ofVec3f *arg4 = 0 ; float arg5 ; ofVec3f *arg6 = 0 ; ofQuaternion *result = 0 ; - SWIG_check_num_args("ofQuaternion::ofQuaternion",6,6) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofQuaternion::ofQuaternion",1,"float"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofQuaternion::ofQuaternion",2,"ofVec3f const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofQuaternion::ofQuaternion",3,"float"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofQuaternion::ofQuaternion",4,"ofVec3f const &"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofQuaternion::ofQuaternion",5,"float"); - if(!lua_isuserdata(L,6)) SWIG_fail_arg("ofQuaternion::ofQuaternion",6,"ofVec3f const &"); arg1 = (float)lua_tonumber(L, 1); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("new_Quaternion",2,SWIGTYPE_p_ofVec3f); } arg3 = (float)lua_tonumber(L, 3); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("new_Quaternion",4,SWIGTYPE_p_ofVec3f); } arg5 = (float)lua_tonumber(L, 5); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,6,(void**)&arg6,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("new_Quaternion",6,SWIGTYPE_p_ofVec3f); } - result = (ofQuaternion *)new ofQuaternion(arg1,(ofVec3f const &)*arg2,arg3,(ofVec3f const &)*arg4,arg5,(ofVec3f const &)*arg6); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofQuaternion,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Quaternion(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_Quaternion__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_new_Quaternion__SWIG_2(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_new_Quaternion__SWIG_3(L);} } } if (argc == 4) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_new_Quaternion__SWIG_1(L);} } } } } - if (argc == 6) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[5])==0 || SWIG_ConvertPtr(L,argv[5], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_new_Quaternion__SWIG_4(L);} } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_Quaternion'\n" " Possible C/C++ prototypes are:\n" - " ofQuaternion::ofQuaternion()\n" " ofQuaternion::ofQuaternion(float,float,float,float)\n" - " ofQuaternion::ofQuaternion(ofVec4f const &)\n" " ofQuaternion::ofQuaternion(float,ofVec3f const &)\n" - " ofQuaternion::ofQuaternion(float,ofVec3f const &,float,ofVec3f const &,float,ofVec3f const &)\n"); - lua_error(L);return 0; } -static int _wrap_Quaternion_set__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; float arg2 ; - float arg3 ; float arg4 ; float arg5 ; SWIG_check_num_args("ofQuaternion::set",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::set",1,"ofQuaternion *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofQuaternion::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofQuaternion::set",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofQuaternion::set",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofQuaternion::set",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion_set",1,SWIGTYPE_p_ofQuaternion); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - (arg1)->set(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Quaternion_set__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; - ofVec4f *arg2 = 0 ; SWIG_check_num_args("ofQuaternion::set",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::set",1,"ofQuaternion *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofQuaternion::set",2,"ofVec4f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion_set",1,SWIGTYPE_p_ofQuaternion); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec4f,0))){ - SWIG_fail_ptr("Quaternion_set",2,SWIGTYPE_p_ofVec4f); } (arg1)->set((ofVec4f const &)*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Quaternion_set__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; - ofMatrix4x4 *arg2 = 0 ; SWIG_check_num_args("ofQuaternion::set",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::set",1,"ofQuaternion *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofQuaternion::set",2,"ofMatrix4x4 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion_set",1,SWIGTYPE_p_ofQuaternion); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Quaternion_set",2,SWIGTYPE_p_ofMatrix4x4); } (arg1)->set((ofMatrix4x4 const &)*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Quaternion_set(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Quaternion_set__SWIG_1(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Quaternion_set__SWIG_2(L);} } } if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Quaternion_set__SWIG_0(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Quaternion_set'\n" " Possible C/C++ prototypes are:\n" - " ofQuaternion::set(float,float,float,float)\n" " ofQuaternion::set(ofVec4f const &)\n" - " ofQuaternion::set(ofMatrix4x4 const &)\n"); lua_error(L);return 0; } -static int _wrap_Quaternion_get(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; - ofMatrix4x4 *arg2 = 0 ; SWIG_check_num_args("ofQuaternion::get",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::get",1,"ofQuaternion const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofQuaternion::get",2,"ofMatrix4x4 &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion_get",1,SWIGTYPE_p_ofQuaternion); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Quaternion_get",2,SWIGTYPE_p_ofMatrix4x4); } ((ofQuaternion const *)arg1)->get(*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Quaternion_x(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; float *result = 0 ; - SWIG_check_num_args("ofQuaternion::x",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::x",1,"ofQuaternion *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion_x",1,SWIGTYPE_p_ofQuaternion); } result = (float *) &(arg1)->x(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_float,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Quaternion_y(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; float *result = 0 ; - SWIG_check_num_args("ofQuaternion::y",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::y",1,"ofQuaternion *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion_y",1,SWIGTYPE_p_ofQuaternion); } result = (float *) &(arg1)->y(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_float,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Quaternion_z(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; float *result = 0 ; - SWIG_check_num_args("ofQuaternion::z",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::z",1,"ofQuaternion *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion_z",1,SWIGTYPE_p_ofQuaternion); } result = (float *) &(arg1)->z(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_float,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Quaternion_w(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; float *result = 0 ; - SWIG_check_num_args("ofQuaternion::w",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::w",1,"ofQuaternion *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion_w",1,SWIGTYPE_p_ofQuaternion); } result = (float *) &(arg1)->w(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_float,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Quaternion_asVec4(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; ofVec4f result; - SWIG_check_num_args("ofQuaternion::asVec4",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::asVec4",1,"ofQuaternion const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion_asVec4",1,SWIGTYPE_p_ofQuaternion); } result = ((ofQuaternion const *)arg1)->asVec4(); { - ofVec4f * resultptr = new ofVec4f((const ofVec4f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec4f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Quaternion_asVec3(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; ofVec3f result; - SWIG_check_num_args("ofQuaternion::asVec3",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::asVec3",1,"ofQuaternion const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion_asVec3",1,SWIGTYPE_p_ofQuaternion); } result = ((ofQuaternion const *)arg1)->asVec3(); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Quaternion_zeroRotation(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; - bool result; SWIG_check_num_args("ofQuaternion::zeroRotation",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::zeroRotation",1,"ofQuaternion const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion_zeroRotation",1,SWIGTYPE_p_ofQuaternion); } - result = (bool)((ofQuaternion const *)arg1)->zeroRotation(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Quaternion_length(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; float result; - SWIG_check_num_args("ofQuaternion::length",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::length",1,"ofQuaternion const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion_length",1,SWIGTYPE_p_ofQuaternion); } result = (float)((ofQuaternion const *)arg1)->length(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Quaternion_length2(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; float result; - SWIG_check_num_args("ofQuaternion::length2",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::length2",1,"ofQuaternion const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion_length2",1,SWIGTYPE_p_ofQuaternion); } result = (float)((ofQuaternion const *)arg1)->length2(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Quaternion_conj(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; - ofQuaternion result; SWIG_check_num_args("ofQuaternion::conj",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::conj",1,"ofQuaternion const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion_conj",1,SWIGTYPE_p_ofQuaternion); } result = ((ofQuaternion const *)arg1)->conj(); { - ofQuaternion * resultptr = new ofQuaternion((const ofQuaternion &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofQuaternion,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Quaternion_inverse(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; - ofQuaternion result; SWIG_check_num_args("ofQuaternion::inverse",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::inverse",1,"ofQuaternion const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion_inverse",1,SWIGTYPE_p_ofQuaternion); } result = ((ofQuaternion const *)arg1)->inverse(); { - ofQuaternion * resultptr = new ofQuaternion((const ofQuaternion &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofQuaternion,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Quaternion_makeRotate__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; - float arg2 ; float arg3 ; float arg4 ; float arg5 ; SWIG_check_num_args("ofQuaternion::makeRotate",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::makeRotate",1,"ofQuaternion *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofQuaternion::makeRotate",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofQuaternion::makeRotate",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofQuaternion::makeRotate",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofQuaternion::makeRotate",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion_makeRotate",1,SWIGTYPE_p_ofQuaternion); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - (arg1)->makeRotate(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Quaternion_makeRotate__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; - float arg2 ; ofVec3f *arg3 = 0 ; SWIG_check_num_args("ofQuaternion::makeRotate",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::makeRotate",1,"ofQuaternion *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofQuaternion::makeRotate",2,"float"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofQuaternion::makeRotate",3,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion_makeRotate",1,SWIGTYPE_p_ofQuaternion); } arg2 = (float)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Quaternion_makeRotate",3,SWIGTYPE_p_ofVec3f); } (arg1)->makeRotate(arg2,(ofVec3f const &)*arg3); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Quaternion_makeRotate__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; - float arg2 ; ofVec3f *arg3 = 0 ; float arg4 ; ofVec3f *arg5 = 0 ; float arg6 ; ofVec3f *arg7 = 0 ; - SWIG_check_num_args("ofQuaternion::makeRotate",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::makeRotate",1,"ofQuaternion *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofQuaternion::makeRotate",2,"float"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofQuaternion::makeRotate",3,"ofVec3f const &"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofQuaternion::makeRotate",4,"float"); - if(!lua_isuserdata(L,5)) SWIG_fail_arg("ofQuaternion::makeRotate",5,"ofVec3f const &"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofQuaternion::makeRotate",6,"float"); - if(!lua_isuserdata(L,7)) SWIG_fail_arg("ofQuaternion::makeRotate",7,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion_makeRotate",1,SWIGTYPE_p_ofQuaternion); } arg2 = (float)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Quaternion_makeRotate",3,SWIGTYPE_p_ofVec3f); } arg4 = (float)lua_tonumber(L, 4); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Quaternion_makeRotate",5,SWIGTYPE_p_ofVec3f); } arg6 = (float)lua_tonumber(L, 6); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,7,(void**)&arg7,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Quaternion_makeRotate",7,SWIGTYPE_p_ofVec3f); } - (arg1)->makeRotate(arg2,(ofVec3f const &)*arg3,arg4,(ofVec3f const &)*arg5,arg6,(ofVec3f const &)*arg7); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Quaternion_makeRotate__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; - ofVec3f *arg2 = 0 ; ofVec3f *arg3 = 0 ; SWIG_check_num_args("ofQuaternion::makeRotate",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::makeRotate",1,"ofQuaternion *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofQuaternion::makeRotate",2,"ofVec3f const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofQuaternion::makeRotate",3,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion_makeRotate",1,SWIGTYPE_p_ofQuaternion); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Quaternion_makeRotate",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Quaternion_makeRotate",3,SWIGTYPE_p_ofVec3f); } - (arg1)->makeRotate((ofVec3f const &)*arg2,(ofVec3f const &)*arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Quaternion_makeRotate(lua_State* L) { int argc; int argv[8]={ 1,2,3,4,5,6,7,8} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Quaternion_makeRotate__SWIG_3(L);} } } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Quaternion_makeRotate__SWIG_1(L);} } } } if (argc == 5) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Quaternion_makeRotate__SWIG_0(L);} } } } } } if (argc == 7) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[4])==0 || SWIG_ConvertPtr(L,argv[4], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[6])==0 || SWIG_ConvertPtr(L,argv[6], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Quaternion_makeRotate__SWIG_2(L);} } } } } } } - } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Quaternion_makeRotate'\n" - " Possible C/C++ prototypes are:\n" " ofQuaternion::makeRotate(float,float,float,float)\n" - " ofQuaternion::makeRotate(float,ofVec3f const &)\n" - " ofQuaternion::makeRotate(float,ofVec3f const &,float,ofVec3f const &,float,ofVec3f const &)\n" - " ofQuaternion::makeRotate(ofVec3f const &,ofVec3f const &)\n"); lua_error(L);return 0; } -static int _wrap_Quaternion_makeRotate_original(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; - ofVec3f *arg2 = 0 ; ofVec3f *arg3 = 0 ; SWIG_check_num_args("ofQuaternion::makeRotate_original",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::makeRotate_original",1,"ofQuaternion *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofQuaternion::makeRotate_original",2,"ofVec3f const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofQuaternion::makeRotate_original",3,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion_makeRotate_original",1,SWIGTYPE_p_ofQuaternion); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Quaternion_makeRotate_original",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Quaternion_makeRotate_original",3,SWIGTYPE_p_ofVec3f); } - (arg1)->makeRotate_original((ofVec3f const &)*arg2,(ofVec3f const &)*arg3); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Quaternion_getRotate__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; - float *arg2 = 0 ; float *arg3 = 0 ; float *arg4 = 0 ; float *arg5 = 0 ; SWIG_check_num_args("ofQuaternion::getRotate",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::getRotate",1,"ofQuaternion const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofQuaternion::getRotate",2,"float &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofQuaternion::getRotate",3,"float &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofQuaternion::getRotate",4,"float &"); - if(!lua_isuserdata(L,5)) SWIG_fail_arg("ofQuaternion::getRotate",5,"float &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion_getRotate",1,SWIGTYPE_p_ofQuaternion); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Quaternion_getRotate",2,SWIGTYPE_p_float); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Quaternion_getRotate",3,SWIGTYPE_p_float); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Quaternion_getRotate",4,SWIGTYPE_p_float); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Quaternion_getRotate",5,SWIGTYPE_p_float); } - ((ofQuaternion const *)arg1)->getRotate(*arg2,*arg3,*arg4,*arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Quaternion_getRotate__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; - float *arg2 = 0 ; ofVec3f *arg3 = 0 ; SWIG_check_num_args("ofQuaternion::getRotate",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::getRotate",1,"ofQuaternion const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofQuaternion::getRotate",2,"float &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofQuaternion::getRotate",3,"ofVec3f &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion_getRotate",1,SWIGTYPE_p_ofQuaternion); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Quaternion_getRotate",2,SWIGTYPE_p_float); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Quaternion_getRotate",3,SWIGTYPE_p_ofVec3f); } ((ofQuaternion const *)arg1)->getRotate(*arg2,*arg3); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Quaternion_getRotate(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Quaternion_getRotate__SWIG_1(L);} } } } if (argc == 5) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[4])==0 || SWIG_ConvertPtr(L,argv[4], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Quaternion_getRotate__SWIG_0(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Quaternion_getRotate'\n" - " Possible C/C++ prototypes are:\n" " ofQuaternion::getRotate(float &,float &,float &,float &) const\n" - " ofQuaternion::getRotate(float &,ofVec3f &) const\n"); lua_error(L);return 0; } -static int _wrap_Quaternion_getEuler(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; ofVec3f result; - SWIG_check_num_args("ofQuaternion::getEuler",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::getEuler",1,"ofQuaternion const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion_getEuler",1,SWIGTYPE_p_ofQuaternion); } result = ((ofQuaternion const *)arg1)->getEuler(); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Quaternion_slerp(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; float arg2 ; - ofQuaternion *arg3 = 0 ; ofQuaternion *arg4 = 0 ; SWIG_check_num_args("ofQuaternion::slerp",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::slerp",1,"ofQuaternion *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofQuaternion::slerp",2,"float"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofQuaternion::slerp",3,"ofQuaternion const &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofQuaternion::slerp",4,"ofQuaternion const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion_slerp",1,SWIGTYPE_p_ofQuaternion); } arg2 = (float)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion_slerp",3,SWIGTYPE_p_ofQuaternion); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion_slerp",4,SWIGTYPE_p_ofQuaternion); } - (arg1)->slerp(arg2,(ofQuaternion const &)*arg3,(ofQuaternion const &)*arg4); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Quaternion_normalize(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; - SWIG_check_num_args("ofQuaternion::normalize",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::normalize",1,"ofQuaternion *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion_normalize",1,SWIGTYPE_p_ofQuaternion); } (arg1)->normalize(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Quaternion___eq(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; - ofQuaternion *arg2 = 0 ; bool result; SWIG_check_num_args("ofQuaternion::operator ==",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::operator ==",1,"ofQuaternion const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofQuaternion::operator ==",2,"ofQuaternion const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion___eq",1,SWIGTYPE_p_ofQuaternion); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion___eq",2,SWIGTYPE_p_ofQuaternion); } - result = (bool)((ofQuaternion const *)arg1)->operator ==((ofQuaternion const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Quaternion___mul__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; - float arg2 ; ofQuaternion result; SWIG_check_num_args("ofQuaternion::operator *",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::operator *",1,"ofQuaternion const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofQuaternion::operator *",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion___mul",1,SWIGTYPE_p_ofQuaternion); } arg2 = (float)lua_tonumber(L, 2); - result = ((ofQuaternion const *)arg1)->operator *(arg2); { - ofQuaternion * resultptr = new ofQuaternion((const ofQuaternion &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofQuaternion,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Quaternion___mul__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; - ofQuaternion *arg2 = 0 ; ofQuaternion result; SWIG_check_num_args("ofQuaternion::operator *",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::operator *",1,"ofQuaternion const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofQuaternion::operator *",2,"ofQuaternion const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion___mul",1,SWIGTYPE_p_ofQuaternion); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion___mul",2,SWIGTYPE_p_ofQuaternion); } - result = ((ofQuaternion const *)arg1)->operator *((ofQuaternion const &)*arg2); { - ofQuaternion * resultptr = new ofQuaternion((const ofQuaternion &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofQuaternion,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Quaternion___mul__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; - ofVec3f *arg2 = 0 ; ofVec3f result; SWIG_check_num_args("ofQuaternion::operator *",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::operator *",1,"ofQuaternion const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofQuaternion::operator *",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion___mul",1,SWIGTYPE_p_ofQuaternion); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Quaternion___mul",2,SWIGTYPE_p_ofVec3f); } - result = ((ofQuaternion const *)arg1)->operator *((ofVec3f const &)*arg2); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Quaternion___mul(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Quaternion___mul__SWIG_1(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Quaternion___mul__SWIG_2(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Quaternion___mul__SWIG_0(L);} } - } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Quaternion___mul'\n" - " Possible C/C++ prototypes are:\n" " ofQuaternion::operator *(float) const\n" - " ofQuaternion::operator *(ofQuaternion const &) const\n" " ofQuaternion::operator *(ofVec3f const &) const\n"); - lua_error(L);return 0; } -static int _wrap_Quaternion___div__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; - float arg2 ; ofQuaternion result; SWIG_check_num_args("ofQuaternion::operator /",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::operator /",1,"ofQuaternion const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofQuaternion::operator /",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion___div",1,SWIGTYPE_p_ofQuaternion); } arg2 = (float)lua_tonumber(L, 2); - result = ((ofQuaternion const *)arg1)->operator /(arg2); { - ofQuaternion * resultptr = new ofQuaternion((const ofQuaternion &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofQuaternion,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Quaternion___div__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; - ofQuaternion *arg2 = 0 ; ofQuaternion result; SWIG_check_num_args("ofQuaternion::operator /",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::operator /",1,"ofQuaternion const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofQuaternion::operator /",2,"ofQuaternion const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion___div",1,SWIGTYPE_p_ofQuaternion); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion___div",2,SWIGTYPE_p_ofQuaternion); } - result = ((ofQuaternion const *)arg1)->operator /((ofQuaternion const &)*arg2); { - ofQuaternion * resultptr = new ofQuaternion((const ofQuaternion &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofQuaternion,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Quaternion___div(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Quaternion___div__SWIG_1(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Quaternion___div__SWIG_0(L);} } - } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Quaternion___div'\n" - " Possible C/C++ prototypes are:\n" " ofQuaternion::operator /(float) const\n" - " ofQuaternion::operator /(ofQuaternion const &) const\n"); lua_error(L);return 0; } -static int _wrap_Quaternion___add(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; - ofQuaternion *arg2 = 0 ; ofQuaternion result; SWIG_check_num_args("ofQuaternion::operator +",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::operator +",1,"ofQuaternion const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofQuaternion::operator +",2,"ofQuaternion const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion___add",1,SWIGTYPE_p_ofQuaternion); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion___add",2,SWIGTYPE_p_ofQuaternion); } - result = ((ofQuaternion const *)arg1)->operator +((ofQuaternion const &)*arg2); { - ofQuaternion * resultptr = new ofQuaternion((const ofQuaternion &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofQuaternion,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Quaternion___sub(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; - ofQuaternion *arg2 = 0 ; ofQuaternion result; SWIG_check_num_args("ofQuaternion::operator -",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::operator -",1,"ofQuaternion const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofQuaternion::operator -",2,"ofQuaternion const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion___sub",1,SWIGTYPE_p_ofQuaternion); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion___sub",2,SWIGTYPE_p_ofQuaternion); } - result = ((ofQuaternion const *)arg1)->operator -((ofQuaternion const &)*arg2); { - ofQuaternion * resultptr = new ofQuaternion((const ofQuaternion &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofQuaternion,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Quaternion___unm(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; - ofQuaternion result; SWIG_check_num_args("ofQuaternion::operator -",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::operator -",1,"ofQuaternion const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion___unm",1,SWIGTYPE_p_ofQuaternion); } result = ((ofQuaternion const *)arg1)->operator -(); { - ofQuaternion * resultptr = new ofQuaternion((const ofQuaternion &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofQuaternion,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Quaternion___tostring(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; - char *result = 0 ; SWIG_check_num_args("ofQuaternion::__str__",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::__str__",1,"ofQuaternion *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion___tostring",1,SWIGTYPE_p_ofQuaternion); } result = (char *)ofQuaternion___str__(arg1); - lua_pushstring(L,(const char *)result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_Quaternion(void *obj) { -ofQuaternion *arg1 = (ofQuaternion *) obj; -delete arg1; -} -static int _proxy__wrap_new_Quaternion(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_Quaternion); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_Quaternion_attributes[] = { - { "_v", _wrap_Quaternion__v_get, _wrap_Quaternion__v_set }, - {0,0,0} -}; -static swig_lua_method swig_Quaternion_methods[]= { - { "set", _wrap_Quaternion_set}, - { "get", _wrap_Quaternion_get}, - { "x", _wrap_Quaternion_x}, - { "y", _wrap_Quaternion_y}, - { "z", _wrap_Quaternion_z}, - { "w", _wrap_Quaternion_w}, - { "asVec4", _wrap_Quaternion_asVec4}, - { "asVec3", _wrap_Quaternion_asVec3}, - { "zeroRotation", _wrap_Quaternion_zeroRotation}, - { "length", _wrap_Quaternion_length}, - { "length2", _wrap_Quaternion_length2}, - { "conj", _wrap_Quaternion_conj}, - { "inverse", _wrap_Quaternion_inverse}, - { "makeRotate", _wrap_Quaternion_makeRotate}, - { "makeRotate_original", _wrap_Quaternion_makeRotate_original}, - { "getRotate", _wrap_Quaternion_getRotate}, - { "getEuler", _wrap_Quaternion_getEuler}, - { "slerp", _wrap_Quaternion_slerp}, - { "normalize", _wrap_Quaternion_normalize}, - { "__eq", _wrap_Quaternion___eq}, - { "__mul", _wrap_Quaternion___mul}, - { "__div", _wrap_Quaternion___div}, - { "__add", _wrap_Quaternion___add}, - { "__sub", _wrap_Quaternion___sub}, - { "__unm", _wrap_Quaternion___unm}, - { "__tostring", _wrap_Quaternion___tostring}, - {0,0} -}; -static swig_lua_method swig_Quaternion_meta[] = { - { "__eq", _wrap_Quaternion___eq}, - { "__mul", _wrap_Quaternion___mul}, - { "__div", _wrap_Quaternion___div}, - { "__add", _wrap_Quaternion___add}, - { "__sub", _wrap_Quaternion___sub}, - { "__unm", _wrap_Quaternion___unm}, - { "__tostring", _wrap_Quaternion___tostring}, - {0,0} -}; - -static swig_lua_attribute swig_Quaternion_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_Quaternion_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_Quaternion_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_Quaternion_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_Quaternion_Sf_SwigStatic = { - "Quaternion", - swig_Quaternion_Sf_SwigStatic_methods, - swig_Quaternion_Sf_SwigStatic_attributes, - swig_Quaternion_Sf_SwigStatic_constants, - swig_Quaternion_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_Quaternion_bases[] = {0}; -static const char *swig_Quaternion_base_names[] = {0}; -static swig_lua_class _wrap_class_Quaternion = { "Quaternion", "Quaternion", &SWIGTYPE_p_ofQuaternion,_proxy__wrap_new_Quaternion, swig_delete_Quaternion, swig_Quaternion_methods, swig_Quaternion_attributes, &swig_Quaternion_Sf_SwigStatic, swig_Quaternion_meta, swig_Quaternion_bases, swig_Quaternion_base_names }; - -static int _wrap_Vec2f_x_set(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; float arg2 ; - SWIG_check_num_args("ofVec2f::x",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::x",1,"ofVec2f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec2f::x",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_x_set",1,SWIGTYPE_p_ofVec2f); } - arg2 = (float)lua_tonumber(L, 2); if (arg1) (arg1)->x = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec2f_x_get(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; float result; - SWIG_check_num_args("ofVec2f::x",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::x",1,"ofVec2f *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_x_get",1,SWIGTYPE_p_ofVec2f); } - result = (float) ((arg1)->x); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_y_set(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; float arg2 ; - SWIG_check_num_args("ofVec2f::y",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::y",1,"ofVec2f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec2f::y",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_y_set",1,SWIGTYPE_p_ofVec2f); } - arg2 = (float)lua_tonumber(L, 2); if (arg1) (arg1)->y = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec2f_y_get(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; float result; - SWIG_check_num_args("ofVec2f::y",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::y",1,"ofVec2f *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_y_get",1,SWIGTYPE_p_ofVec2f); } - result = (float) ((arg1)->y); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_Vec2f__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec2f *result = 0 ; - SWIG_check_num_args("ofVec2f::ofVec2f",0,0) result = (ofVec2f *)new ofVec2f(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Vec2f__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; ofVec2f *result = 0 ; - SWIG_check_num_args("ofVec2f::ofVec2f",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofVec2f::ofVec2f",1,"float"); - arg1 = (float)lua_tonumber(L, 1); result = (ofVec2f *)new ofVec2f(arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Vec2f__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; ofVec2f *result = 0 ; - SWIG_check_num_args("ofVec2f::ofVec2f",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofVec2f::ofVec2f",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec2f::ofVec2f",2,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); result = (ofVec2f *)new ofVec2f(arg1,arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Vec2f__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = 0 ; ofVec2f *result = 0 ; - SWIG_check_num_args("ofVec2f::ofVec2f",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofVec2f::ofVec2f",1,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("new_Vec2f",1,SWIGTYPE_p_ofVec3f); } - result = (ofVec2f *)new ofVec2f((ofVec3f const &)*arg1); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_new_Vec2f__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = 0 ; ofVec2f *result = 0 ; - SWIG_check_num_args("ofVec2f::ofVec2f",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofVec2f::ofVec2f",1,"ofVec4f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("new_Vec2f",1,SWIGTYPE_p_ofVec4f); } - result = (ofVec2f *)new ofVec2f((ofVec4f const &)*arg1); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_new_Vec2f(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_Vec2f__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_new_Vec2f__SWIG_3(L);} } if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_new_Vec2f__SWIG_4(L);} } if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_new_Vec2f__SWIG_1(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_new_Vec2f__SWIG_2(L);} - } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_Vec2f'\n" - " Possible C/C++ prototypes are:\n" " ofVec2f::ofVec2f()\n" " ofVec2f::ofVec2f(float)\n" - " ofVec2f::ofVec2f(float,float)\n" " ofVec2f::ofVec2f(ofVec3f const &)\n" " ofVec2f::ofVec2f(ofVec4f const &)\n"); - lua_error(L);return 0; } -static int _wrap_Vec2f_getPtr__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; float *result = 0 ; - SWIG_check_num_args("ofVec2f::getPtr",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::getPtr",1,"ofVec2f *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_getPtr",1,SWIGTYPE_p_ofVec2f); } - result = (float *)(arg1)->getPtr(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_float,0); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_getPtr__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; float *result = 0 ; - SWIG_check_num_args("ofVec2f::getPtr",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::getPtr",1,"ofVec2f const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_getPtr",1,SWIGTYPE_p_ofVec2f); } - result = (float *)((ofVec2f const *)arg1)->getPtr(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_float,0); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_getPtr(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Vec2f_getPtr__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Vec2f_getPtr__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec2f_getPtr'\n" " Possible C/C++ prototypes are:\n" - " ofVec2f::getPtr()\n" " ofVec2f::getPtr() const\n"); lua_error(L);return 0; } -static int _wrap_Vec2f_set__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofVec2f::set",3,3) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::set",1,"ofVec2f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec2f::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVec2f::set",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_set",1,SWIGTYPE_p_ofVec2f); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); (arg1)->set(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_set__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f *arg2 = 0 ; - SWIG_check_num_args("ofVec2f::set",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::set",1,"ofVec2f *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec2f::set",2,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_set",1,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_set",2,SWIGTYPE_p_ofVec2f); } - (arg1)->set((ofVec2f const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_set__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; float arg2 ; - SWIG_check_num_args("ofVec2f::set",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::set",1,"ofVec2f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec2f::set",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_set",1,SWIGTYPE_p_ofVec2f); } - arg2 = (float)lua_tonumber(L, 2); (arg1)->set(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_set(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec2f_set__SWIG_1(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Vec2f_set__SWIG_2(L);} } } - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Vec2f_set__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec2f_set'\n" " Possible C/C++ prototypes are:\n" - " ofVec2f::set(float,float)\n" " ofVec2f::set(ofVec2f const &)\n" " ofVec2f::set(float)\n"); lua_error(L);return 0; } -static int _wrap_Vec2f___eq(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f *arg2 = 0 ; bool result; - SWIG_check_num_args("ofVec2f::operator ==",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::operator ==",1,"ofVec2f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec2f::operator ==",2,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f___eq",1,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f___eq",2,SWIGTYPE_p_ofVec2f); } - result = (bool)((ofVec2f const *)arg1)->operator ==((ofVec2f const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_match__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f *arg2 = 0 ; - float arg3 ; bool result; SWIG_check_num_args("ofVec2f::match",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::match",1,"ofVec2f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec2f::match",2,"ofVec2f const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVec2f::match",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_match",1,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_match",2,SWIGTYPE_p_ofVec2f); } - arg3 = (float)lua_tonumber(L, 3); result = (bool)((ofVec2f const *)arg1)->match((ofVec2f const &)*arg2,arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_match__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f *arg2 = 0 ; - bool result; SWIG_check_num_args("ofVec2f::match",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::match",1,"ofVec2f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec2f::match",2,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_match",1,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_match",2,SWIGTYPE_p_ofVec2f); } - result = (bool)((ofVec2f const *)arg1)->match((ofVec2f const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_match(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec2f_match__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Vec2f_match__SWIG_0(L);} } } - } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec2f_match'\n" " Possible C/C++ prototypes are:\n" - " ofVec2f::match(ofVec2f const &,float) const\n" " ofVec2f::match(ofVec2f const &) const\n"); lua_error(L);return 0; } -static int _wrap_Vec2f_isAligned__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f *arg2 = 0 ; - float arg3 ; bool result; SWIG_check_num_args("ofVec2f::isAligned",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::isAligned",1,"ofVec2f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec2f::isAligned",2,"ofVec2f const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVec2f::isAligned",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_isAligned",1,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_isAligned",2,SWIGTYPE_p_ofVec2f); } arg3 = (float)lua_tonumber(L, 3); - result = (bool)((ofVec2f const *)arg1)->isAligned((ofVec2f const &)*arg2,arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_isAligned__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f *arg2 = 0 ; - bool result; SWIG_check_num_args("ofVec2f::isAligned",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::isAligned",1,"ofVec2f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec2f::isAligned",2,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_isAligned",1,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_isAligned",2,SWIGTYPE_p_ofVec2f); } - result = (bool)((ofVec2f const *)arg1)->isAligned((ofVec2f const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_isAligned(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec2f_isAligned__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Vec2f_isAligned__SWIG_0(L);} } - } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec2f_isAligned'\n" - " Possible C/C++ prototypes are:\n" " ofVec2f::isAligned(ofVec2f const &,float) const\n" - " ofVec2f::isAligned(ofVec2f const &) const\n"); lua_error(L);return 0; } -static int _wrap_Vec2f_isAlignedRad__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; - ofVec2f *arg2 = 0 ; float arg3 ; bool result; SWIG_check_num_args("ofVec2f::isAlignedRad",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::isAlignedRad",1,"ofVec2f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec2f::isAlignedRad",2,"ofVec2f const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVec2f::isAlignedRad",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_isAlignedRad",1,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_isAlignedRad",2,SWIGTYPE_p_ofVec2f); } arg3 = (float)lua_tonumber(L, 3); - result = (bool)((ofVec2f const *)arg1)->isAlignedRad((ofVec2f const &)*arg2,arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_isAlignedRad__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; - ofVec2f *arg2 = 0 ; bool result; SWIG_check_num_args("ofVec2f::isAlignedRad",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::isAlignedRad",1,"ofVec2f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec2f::isAlignedRad",2,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_isAlignedRad",1,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_isAlignedRad",2,SWIGTYPE_p_ofVec2f); } - result = (bool)((ofVec2f const *)arg1)->isAlignedRad((ofVec2f const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_isAlignedRad(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec2f_isAlignedRad__SWIG_1(L);} } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Vec2f_isAlignedRad__SWIG_0(L);} - } } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec2f_isAlignedRad'\n" - " Possible C/C++ prototypes are:\n" " ofVec2f::isAlignedRad(ofVec2f const &,float) const\n" - " ofVec2f::isAlignedRad(ofVec2f const &) const\n"); lua_error(L);return 0; } -static int _wrap_Vec2f_align__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f *arg2 = 0 ; - float arg3 ; bool result; SWIG_check_num_args("ofVec2f::align",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::align",1,"ofVec2f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec2f::align",2,"ofVec2f const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVec2f::align",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_align",1,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_align",2,SWIGTYPE_p_ofVec2f); } - arg3 = (float)lua_tonumber(L, 3); result = (bool)((ofVec2f const *)arg1)->align((ofVec2f const &)*arg2,arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_align__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f *arg2 = 0 ; - bool result; SWIG_check_num_args("ofVec2f::align",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::align",1,"ofVec2f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec2f::align",2,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_align",1,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_align",2,SWIGTYPE_p_ofVec2f); } - result = (bool)((ofVec2f const *)arg1)->align((ofVec2f const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_align(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec2f_align__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Vec2f_align__SWIG_0(L);} } } - } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec2f_align'\n" " Possible C/C++ prototypes are:\n" - " ofVec2f::align(ofVec2f const &,float) const\n" " ofVec2f::align(ofVec2f const &) const\n"); lua_error(L);return 0; } -static int _wrap_Vec2f_alignRad__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f *arg2 = 0 ; - float arg3 ; bool result; SWIG_check_num_args("ofVec2f::alignRad",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::alignRad",1,"ofVec2f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec2f::alignRad",2,"ofVec2f const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVec2f::alignRad",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_alignRad",1,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_alignRad",2,SWIGTYPE_p_ofVec2f); } arg3 = (float)lua_tonumber(L, 3); - result = (bool)((ofVec2f const *)arg1)->alignRad((ofVec2f const &)*arg2,arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_alignRad__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f *arg2 = 0 ; - bool result; SWIG_check_num_args("ofVec2f::alignRad",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::alignRad",1,"ofVec2f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec2f::alignRad",2,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_alignRad",1,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_alignRad",2,SWIGTYPE_p_ofVec2f); } - result = (bool)((ofVec2f const *)arg1)->alignRad((ofVec2f const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_alignRad(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec2f_alignRad__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Vec2f_alignRad__SWIG_0(L);} } - } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec2f_alignRad'\n" - " Possible C/C++ prototypes are:\n" " ofVec2f::alignRad(ofVec2f const &,float) const\n" - " ofVec2f::alignRad(ofVec2f const &) const\n"); lua_error(L);return 0; } -static int _wrap_Vec2f___add__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f *arg2 = 0 ; - ofVec2f result; SWIG_check_num_args("ofVec2f::operator +",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::operator +",1,"ofVec2f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec2f::operator +",2,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f___add",1,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f___add",2,SWIGTYPE_p_ofVec2f); } - result = ((ofVec2f const *)arg1)->operator +((ofVec2f const &)*arg2); { - ofVec2f * resultptr = new ofVec2f((const ofVec2f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f___add__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; float arg2 ; - ofVec2f result; SWIG_check_num_args("ofVec2f::operator +",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::operator +",1,"ofVec2f const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec2f::operator +",2,"float const"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f___add",1,SWIGTYPE_p_ofVec2f); } - arg2 = (float const)lua_tonumber(L, 2); result = ((ofVec2f const *)arg1)->operator +(arg2); { - ofVec2f * resultptr = new ofVec2f((const ofVec2f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f___add(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec2f___add__SWIG_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Vec2f___add__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec2f___add'\n" " Possible C/C++ prototypes are:\n" - " ofVec2f::operator +(ofVec2f const &) const\n" " ofVec2f::operator +(float const) const\n"); lua_error(L);return 0; } -static int _wrap_Vec2f___sub__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f *arg2 = 0 ; - ofVec2f result; SWIG_check_num_args("ofVec2f::operator -",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::operator -",1,"ofVec2f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec2f::operator -",2,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f___sub",1,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f___sub",2,SWIGTYPE_p_ofVec2f); } - result = ((ofVec2f const *)arg1)->operator -((ofVec2f const &)*arg2); { - ofVec2f * resultptr = new ofVec2f((const ofVec2f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f___sub__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; float arg2 ; - ofVec2f result; SWIG_check_num_args("ofVec2f::operator -",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::operator -",1,"ofVec2f const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec2f::operator -",2,"float const"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f___sub",1,SWIGTYPE_p_ofVec2f); } - arg2 = (float const)lua_tonumber(L, 2); result = ((ofVec2f const *)arg1)->operator -(arg2); { - ofVec2f * resultptr = new ofVec2f((const ofVec2f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f___sub(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec2f___sub__SWIG_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Vec2f___sub__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec2f___sub'\n" " Possible C/C++ prototypes are:\n" - " ofVec2f::operator -(ofVec2f const &) const\n" " ofVec2f::operator -(float const) const\n"); lua_error(L);return 0; } -static int _wrap_Vec2f___unm(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f result; - SWIG_check_num_args("ofVec2f::operator -",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::operator -",1,"ofVec2f const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f___unm",1,SWIGTYPE_p_ofVec2f); } - result = ((ofVec2f const *)arg1)->operator -(); { ofVec2f * resultptr = new ofVec2f((const ofVec2f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f___mul__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f *arg2 = 0 ; - ofVec2f result; SWIG_check_num_args("ofVec2f::operator *",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::operator *",1,"ofVec2f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec2f::operator *",2,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f___mul",1,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f___mul",2,SWIGTYPE_p_ofVec2f); } - result = ((ofVec2f const *)arg1)->operator *((ofVec2f const &)*arg2); { - ofVec2f * resultptr = new ofVec2f((const ofVec2f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f___mul__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; float arg2 ; - ofVec2f result; SWIG_check_num_args("ofVec2f::operator *",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::operator *",1,"ofVec2f const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec2f::operator *",2,"float const"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f___mul",1,SWIGTYPE_p_ofVec2f); } - arg2 = (float const)lua_tonumber(L, 2); result = ((ofVec2f const *)arg1)->operator *(arg2); { - ofVec2f * resultptr = new ofVec2f((const ofVec2f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f___mul(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec2f___mul__SWIG_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Vec2f___mul__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec2f___mul'\n" " Possible C/C++ prototypes are:\n" - " ofVec2f::operator *(ofVec2f const &) const\n" " ofVec2f::operator *(float const) const\n"); lua_error(L);return 0; } -static int _wrap_Vec2f___div__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f *arg2 = 0 ; - ofVec2f result; SWIG_check_num_args("ofVec2f::operator /",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::operator /",1,"ofVec2f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec2f::operator /",2,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f___div",1,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f___div",2,SWIGTYPE_p_ofVec2f); } - result = ((ofVec2f const *)arg1)->operator /((ofVec2f const &)*arg2); { - ofVec2f * resultptr = new ofVec2f((const ofVec2f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f___div__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; float arg2 ; - ofVec2f result; SWIG_check_num_args("ofVec2f::operator /",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::operator /",1,"ofVec2f const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec2f::operator /",2,"float const"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f___div",1,SWIGTYPE_p_ofVec2f); } - arg2 = (float const)lua_tonumber(L, 2); result = ((ofVec2f const *)arg1)->operator /(arg2); { - ofVec2f * resultptr = new ofVec2f((const ofVec2f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f___div(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec2f___div__SWIG_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Vec2f___div__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec2f___div'\n" " Possible C/C++ prototypes are:\n" - " ofVec2f::operator /(ofVec2f const &) const\n" " ofVec2f::operator /(float const) const\n"); lua_error(L);return 0; } -static int _wrap_Vec2f_getScaled(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; float arg2 ; ofVec2f result; - SWIG_check_num_args("ofVec2f::getScaled",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::getScaled",1,"ofVec2f const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec2f::getScaled",2,"float const"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_getScaled",1,SWIGTYPE_p_ofVec2f); } arg2 = (float const)lua_tonumber(L, 2); - result = ((ofVec2f const *)arg1)->getScaled(arg2); { ofVec2f * resultptr = new ofVec2f((const ofVec2f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_scale(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; float arg2 ; - ofVec2f *result = 0 ; SWIG_check_num_args("ofVec2f::scale",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::scale",1,"ofVec2f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec2f::scale",2,"float const"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_scale",1,SWIGTYPE_p_ofVec2f); } - arg2 = (float const)lua_tonumber(L, 2); result = (ofVec2f *) &(arg1)->scale(arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec2f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec2f_getRotated__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; float arg2 ; - ofVec2f result; SWIG_check_num_args("ofVec2f::getRotated",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::getRotated",1,"ofVec2f const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec2f::getRotated",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_getRotated",1,SWIGTYPE_p_ofVec2f); } arg2 = (float)lua_tonumber(L, 2); - result = ((ofVec2f const *)arg1)->getRotated(arg2); { ofVec2f * resultptr = new ofVec2f((const ofVec2f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_getRotated__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; float arg2 ; - ofVec2f *arg3 = 0 ; ofVec2f result; SWIG_check_num_args("ofVec2f::getRotated",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::getRotated",1,"ofVec2f const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec2f::getRotated",2,"float"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofVec2f::getRotated",3,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_getRotated",1,SWIGTYPE_p_ofVec2f); } arg2 = (float)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_getRotated",3,SWIGTYPE_p_ofVec2f); } - result = ((ofVec2f const *)arg1)->getRotated(arg2,(ofVec2f const &)*arg3); { - ofVec2f * resultptr = new ofVec2f((const ofVec2f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_getRotated(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Vec2f_getRotated__SWIG_0(L);} } } - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec2f_getRotated__SWIG_1(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec2f_getRotated'\n" " Possible C/C++ prototypes are:\n" - " ofVec2f::getRotated(float) const\n" " ofVec2f::getRotated(float,ofVec2f const &) const\n"); lua_error(L);return 0; } -static int _wrap_Vec2f_getRotatedRad__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; float arg2 ; - ofVec2f result; SWIG_check_num_args("ofVec2f::getRotatedRad",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::getRotatedRad",1,"ofVec2f const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec2f::getRotatedRad",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_getRotatedRad",1,SWIGTYPE_p_ofVec2f); } arg2 = (float)lua_tonumber(L, 2); - result = ((ofVec2f const *)arg1)->getRotatedRad(arg2); { ofVec2f * resultptr = new ofVec2f((const ofVec2f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_getRotatedRad__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; float arg2 ; - ofVec2f *arg3 = 0 ; ofVec2f result; SWIG_check_num_args("ofVec2f::getRotatedRad",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::getRotatedRad",1,"ofVec2f const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec2f::getRotatedRad",2,"float"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofVec2f::getRotatedRad",3,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_getRotatedRad",1,SWIGTYPE_p_ofVec2f); } arg2 = (float)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_getRotatedRad",3,SWIGTYPE_p_ofVec2f); } - result = ((ofVec2f const *)arg1)->getRotatedRad(arg2,(ofVec2f const &)*arg3); { - ofVec2f * resultptr = new ofVec2f((const ofVec2f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_getRotatedRad(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Vec2f_getRotatedRad__SWIG_0(L);} } } - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec2f_getRotatedRad__SWIG_1(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec2f_getRotatedRad'\n" - " Possible C/C++ prototypes are:\n" " ofVec2f::getRotatedRad(float) const\n" - " ofVec2f::getRotatedRad(float,ofVec2f const &) const\n"); lua_error(L);return 0; } -static int _wrap_Vec2f_rotate__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; float arg2 ; - ofVec2f *result = 0 ; SWIG_check_num_args("ofVec2f::rotate",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::rotate",1,"ofVec2f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec2f::rotate",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_rotate",1,SWIGTYPE_p_ofVec2f); } - arg2 = (float)lua_tonumber(L, 2); result = (ofVec2f *) &(arg1)->rotate(arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec2f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec2f_rotate__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; float arg2 ; - ofVec2f *arg3 = 0 ; ofVec2f *result = 0 ; SWIG_check_num_args("ofVec2f::rotate",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::rotate",1,"ofVec2f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec2f::rotate",2,"float"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofVec2f::rotate",3,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_rotate",1,SWIGTYPE_p_ofVec2f); } - arg2 = (float)lua_tonumber(L, 2); if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_rotate",3,SWIGTYPE_p_ofVec2f); } result = (ofVec2f *) &(arg1)->rotate(arg2,(ofVec2f const &)*arg3); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec2f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec2f_rotate(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Vec2f_rotate__SWIG_0(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec2f_rotate__SWIG_1(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec2f_rotate'\n" " Possible C/C++ prototypes are:\n" - " ofVec2f::rotate(float)\n" " ofVec2f::rotate(float,ofVec2f const &)\n"); lua_error(L);return 0; } -static int _wrap_Vec2f_rotateRad__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; float arg2 ; - ofVec2f *result = 0 ; SWIG_check_num_args("ofVec2f::rotateRad",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::rotateRad",1,"ofVec2f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec2f::rotateRad",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_rotateRad",1,SWIGTYPE_p_ofVec2f); } arg2 = (float)lua_tonumber(L, 2); - result = (ofVec2f *) &(arg1)->rotateRad(arg2); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec2f,0); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_rotateRad__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; float arg2 ; - ofVec2f *arg3 = 0 ; ofVec2f *result = 0 ; SWIG_check_num_args("ofVec2f::rotateRad",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::rotateRad",1,"ofVec2f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec2f::rotateRad",2,"float"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofVec2f::rotateRad",3,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_rotateRad",1,SWIGTYPE_p_ofVec2f); } arg2 = (float)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_rotateRad",3,SWIGTYPE_p_ofVec2f); } - result = (ofVec2f *) &(arg1)->rotateRad(arg2,(ofVec2f const &)*arg3); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec2f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec2f_rotateRad(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Vec2f_rotateRad__SWIG_0(L);} } } - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec2f_rotateRad__SWIG_1(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec2f_rotateRad'\n" " Possible C/C++ prototypes are:\n" - " ofVec2f::rotateRad(float)\n" " ofVec2f::rotateRad(float,ofVec2f const &)\n"); lua_error(L);return 0; } -static int _wrap_Vec2f_getMapped(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f *arg2 = 0 ; - ofVec2f *arg3 = 0 ; ofVec2f *arg4 = 0 ; ofVec2f result; SWIG_check_num_args("ofVec2f::getMapped",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::getMapped",1,"ofVec2f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec2f::getMapped",2,"ofVec2f const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofVec2f::getMapped",3,"ofVec2f const &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofVec2f::getMapped",4,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_getMapped",1,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_getMapped",2,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_getMapped",3,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_getMapped",4,SWIGTYPE_p_ofVec2f); } - result = ((ofVec2f const *)arg1)->getMapped((ofVec2f const &)*arg2,(ofVec2f const &)*arg3,(ofVec2f const &)*arg4); { - ofVec2f * resultptr = new ofVec2f((const ofVec2f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_map(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f *arg2 = 0 ; - ofVec2f *arg3 = 0 ; ofVec2f *arg4 = 0 ; ofVec2f *result = 0 ; SWIG_check_num_args("ofVec2f::map",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::map",1,"ofVec2f *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec2f::map",2,"ofVec2f const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofVec2f::map",3,"ofVec2f const &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofVec2f::map",4,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_map",1,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_map",2,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_map",3,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_map",4,SWIGTYPE_p_ofVec2f); } - result = (ofVec2f *) &(arg1)->map((ofVec2f const &)*arg2,(ofVec2f const &)*arg3,(ofVec2f const &)*arg4); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec2f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec2f_distance(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f *arg2 = 0 ; - float result; SWIG_check_num_args("ofVec2f::distance",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::distance",1,"ofVec2f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec2f::distance",2,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_distance",1,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_distance",2,SWIGTYPE_p_ofVec2f); } - result = (float)((ofVec2f const *)arg1)->distance((ofVec2f const &)*arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_squareDistance(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f *arg2 = 0 ; - float result; SWIG_check_num_args("ofVec2f::squareDistance",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::squareDistance",1,"ofVec2f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec2f::squareDistance",2,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_squareDistance",1,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_squareDistance",2,SWIGTYPE_p_ofVec2f); } - result = (float)((ofVec2f const *)arg1)->squareDistance((ofVec2f const &)*arg2); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_getInterpolated(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f *arg2 = 0 ; - float arg3 ; ofVec2f result; SWIG_check_num_args("ofVec2f::getInterpolated",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::getInterpolated",1,"ofVec2f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec2f::getInterpolated",2,"ofVec2f const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVec2f::getInterpolated",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_getInterpolated",1,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_getInterpolated",2,SWIGTYPE_p_ofVec2f); } arg3 = (float)lua_tonumber(L, 3); - result = ((ofVec2f const *)arg1)->getInterpolated((ofVec2f const &)*arg2,arg3); { - ofVec2f * resultptr = new ofVec2f((const ofVec2f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_interpolate(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f *arg2 = 0 ; - float arg3 ; ofVec2f *result = 0 ; SWIG_check_num_args("ofVec2f::interpolate",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::interpolate",1,"ofVec2f *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec2f::interpolate",2,"ofVec2f const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVec2f::interpolate",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_interpolate",1,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_interpolate",2,SWIGTYPE_p_ofVec2f); } arg3 = (float)lua_tonumber(L, 3); - result = (ofVec2f *) &(arg1)->interpolate((ofVec2f const &)*arg2,arg3); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec2f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec2f_getMiddle(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f *arg2 = 0 ; - ofVec2f result; SWIG_check_num_args("ofVec2f::getMiddle",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::getMiddle",1,"ofVec2f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec2f::getMiddle",2,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_getMiddle",1,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_getMiddle",2,SWIGTYPE_p_ofVec2f); } - result = ((ofVec2f const *)arg1)->getMiddle((ofVec2f const &)*arg2); { - ofVec2f * resultptr = new ofVec2f((const ofVec2f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_middle(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f *arg2 = 0 ; - ofVec2f *result = 0 ; SWIG_check_num_args("ofVec2f::middle",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::middle",1,"ofVec2f *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec2f::middle",2,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_middle",1,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_middle",2,SWIGTYPE_p_ofVec2f); } result = (ofVec2f *) &(arg1)->middle((ofVec2f const &)*arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec2f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec2f_average(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f *arg2 = (ofVec2f *) 0 ; - std::size_t arg3 ; ofVec2f *result = 0 ; SWIG_check_num_args("ofVec2f::average",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::average",1,"ofVec2f *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofVec2f::average",2,"ofVec2f const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVec2f::average",3,"std::size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_average",1,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_average",2,SWIGTYPE_p_ofVec2f); } - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (std::size_t)lua_tonumber(L, 3); - result = (ofVec2f *) &(arg1)->average((ofVec2f const *)arg2,arg3); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec2f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec2f_getNormalized(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f result; - SWIG_check_num_args("ofVec2f::getNormalized",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::getNormalized",1,"ofVec2f const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_getNormalized",1,SWIGTYPE_p_ofVec2f); } result = ((ofVec2f const *)arg1)->getNormalized(); { - ofVec2f * resultptr = new ofVec2f((const ofVec2f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_normalize(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f *result = 0 ; - SWIG_check_num_args("ofVec2f::normalize",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::normalize",1,"ofVec2f *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_normalize",1,SWIGTYPE_p_ofVec2f); } result = (ofVec2f *) &(arg1)->normalize(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec2f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec2f_getLimited(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; float arg2 ; ofVec2f result; - SWIG_check_num_args("ofVec2f::getLimited",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::getLimited",1,"ofVec2f const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec2f::getLimited",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_getLimited",1,SWIGTYPE_p_ofVec2f); } arg2 = (float)lua_tonumber(L, 2); - result = ((ofVec2f const *)arg1)->getLimited(arg2); { ofVec2f * resultptr = new ofVec2f((const ofVec2f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_limit(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; float arg2 ; - ofVec2f *result = 0 ; SWIG_check_num_args("ofVec2f::limit",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::limit",1,"ofVec2f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec2f::limit",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_limit",1,SWIGTYPE_p_ofVec2f); } - arg2 = (float)lua_tonumber(L, 2); result = (ofVec2f *) &(arg1)->limit(arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec2f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec2f_length(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; float result; - SWIG_check_num_args("ofVec2f::length",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::length",1,"ofVec2f const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_length",1,SWIGTYPE_p_ofVec2f); } - result = (float)((ofVec2f const *)arg1)->length(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_lengthSquared(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; float result; - SWIG_check_num_args("ofVec2f::lengthSquared",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::lengthSquared",1,"ofVec2f const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_lengthSquared",1,SWIGTYPE_p_ofVec2f); } result = (float)((ofVec2f const *)arg1)->lengthSquared(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_angle(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f *arg2 = 0 ; float result; - SWIG_check_num_args("ofVec2f::angle",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::angle",1,"ofVec2f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec2f::angle",2,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_angle",1,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_angle",2,SWIGTYPE_p_ofVec2f); } - result = (float)((ofVec2f const *)arg1)->angle((ofVec2f const &)*arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_angleRad(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f *arg2 = 0 ; - float result; SWIG_check_num_args("ofVec2f::angleRad",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::angleRad",1,"ofVec2f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec2f::angleRad",2,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_angleRad",1,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_angleRad",2,SWIGTYPE_p_ofVec2f); } - result = (float)((ofVec2f const *)arg1)->angleRad((ofVec2f const &)*arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_getPerpendicular(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f result; - SWIG_check_num_args("ofVec2f::getPerpendicular",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::getPerpendicular",1,"ofVec2f const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_getPerpendicular",1,SWIGTYPE_p_ofVec2f); } result = ((ofVec2f const *)arg1)->getPerpendicular(); { - ofVec2f * resultptr = new ofVec2f((const ofVec2f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_perpendicular(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f *result = 0 ; - SWIG_check_num_args("ofVec2f::perpendicular",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::perpendicular",1,"ofVec2f *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_perpendicular",1,SWIGTYPE_p_ofVec2f); } result = (ofVec2f *) &(arg1)->perpendicular(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec2f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec2f_dot(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f *arg2 = 0 ; float result; - SWIG_check_num_args("ofVec2f::dot",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::dot",1,"ofVec2f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec2f::dot",2,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_dot",1,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_dot",2,SWIGTYPE_p_ofVec2f); } - result = (float)((ofVec2f const *)arg1)->dot((ofVec2f const &)*arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_zero(lua_State* L) { int SWIG_arg = 0; ofVec2f result; SWIG_check_num_args("ofVec2f::zero",0,0) - result = ofVec2f::zero(); { ofVec2f * resultptr = new ofVec2f((const ofVec2f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_one(lua_State* L) { int SWIG_arg = 0; ofVec2f result; SWIG_check_num_args("ofVec2f::one",0,0) - result = ofVec2f::one(); { ofVec2f * resultptr = new ofVec2f((const ofVec2f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f___tostring(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; char *result = 0 ; - SWIG_check_num_args("ofVec2f::__str__",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::__str__",1,"ofVec2f *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f___tostring",1,SWIGTYPE_p_ofVec2f); } result = (char *)ofVec2f___str__(arg1); - lua_pushstring(L,(const char *)result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_Vec2f(void *obj) { -ofVec2f *arg1 = (ofVec2f *) obj; -delete arg1; -} -static int _proxy__wrap_new_Vec2f(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_Vec2f); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_Vec2f_attributes[] = { - { "x", _wrap_Vec2f_x_get, _wrap_Vec2f_x_set }, - { "y", _wrap_Vec2f_y_get, _wrap_Vec2f_y_set }, - {0,0,0} -}; -static swig_lua_method swig_Vec2f_methods[]= { - { "getPtr", _wrap_Vec2f_getPtr}, - { "set", _wrap_Vec2f_set}, - { "__eq", _wrap_Vec2f___eq}, - { "match", _wrap_Vec2f_match}, - { "isAligned", _wrap_Vec2f_isAligned}, - { "isAlignedRad", _wrap_Vec2f_isAlignedRad}, - { "align", _wrap_Vec2f_align}, - { "alignRad", _wrap_Vec2f_alignRad}, - { "__add", _wrap_Vec2f___add}, - { "__sub", _wrap_Vec2f___sub}, - { "__unm", _wrap_Vec2f___unm}, - { "__mul", _wrap_Vec2f___mul}, - { "__div", _wrap_Vec2f___div}, - { "getScaled", _wrap_Vec2f_getScaled}, - { "scale", _wrap_Vec2f_scale}, - { "getRotated", _wrap_Vec2f_getRotated}, - { "getRotatedRad", _wrap_Vec2f_getRotatedRad}, - { "rotate", _wrap_Vec2f_rotate}, - { "rotateRad", _wrap_Vec2f_rotateRad}, - { "getMapped", _wrap_Vec2f_getMapped}, - { "map", _wrap_Vec2f_map}, - { "distance", _wrap_Vec2f_distance}, - { "squareDistance", _wrap_Vec2f_squareDistance}, - { "getInterpolated", _wrap_Vec2f_getInterpolated}, - { "interpolate", _wrap_Vec2f_interpolate}, - { "getMiddle", _wrap_Vec2f_getMiddle}, - { "middle", _wrap_Vec2f_middle}, - { "average", _wrap_Vec2f_average}, - { "getNormalized", _wrap_Vec2f_getNormalized}, - { "normalize", _wrap_Vec2f_normalize}, - { "getLimited", _wrap_Vec2f_getLimited}, - { "limit", _wrap_Vec2f_limit}, - { "length", _wrap_Vec2f_length}, - { "lengthSquared", _wrap_Vec2f_lengthSquared}, - { "angle", _wrap_Vec2f_angle}, - { "angleRad", _wrap_Vec2f_angleRad}, - { "getPerpendicular", _wrap_Vec2f_getPerpendicular}, - { "perpendicular", _wrap_Vec2f_perpendicular}, - { "dot", _wrap_Vec2f_dot}, - { "__tostring", _wrap_Vec2f___tostring}, - {0,0} -}; -static swig_lua_method swig_Vec2f_meta[] = { - { "__eq", _wrap_Vec2f___eq}, - { "__add", _wrap_Vec2f___add}, - { "__sub", _wrap_Vec2f___sub}, - { "__unm", _wrap_Vec2f___unm}, - { "__mul", _wrap_Vec2f___mul}, - { "__div", _wrap_Vec2f___div}, - { "__tostring", _wrap_Vec2f___tostring}, - {0,0} -}; - -static swig_lua_attribute swig_Vec2f_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_Vec2f_Sf_SwigStatic_constants[]= { - {SWIG_LUA_CONSTTAB_INT("DIM", ofVec2f::DIM)}, - {0,0,0,0,0,0} -}; -static swig_lua_method swig_Vec2f_Sf_SwigStatic_methods[]= { - { "zero", _wrap_Vec2f_zero}, - { "one", _wrap_Vec2f_one}, - {0,0} -}; -static swig_lua_class* swig_Vec2f_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_Vec2f_Sf_SwigStatic = { - "Vec2f", - swig_Vec2f_Sf_SwigStatic_methods, - swig_Vec2f_Sf_SwigStatic_attributes, - swig_Vec2f_Sf_SwigStatic_constants, - swig_Vec2f_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_Vec2f_bases[] = {0}; -static const char *swig_Vec2f_base_names[] = {0}; -static swig_lua_class _wrap_class_Vec2f = { "Vec2f", "Vec2f", &SWIGTYPE_p_ofVec2f,_proxy__wrap_new_Vec2f, swig_delete_Vec2f, swig_Vec2f_methods, swig_Vec2f_attributes, &swig_Vec2f_Sf_SwigStatic, swig_Vec2f_meta, swig_Vec2f_bases, swig_Vec2f_base_names }; - -static int _wrap_Vec3f_x_set(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float arg2 ; - SWIG_check_num_args("ofVec3f::x",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::x",1,"ofVec3f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec3f::x",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_x_set",1,SWIGTYPE_p_ofVec3f); } - arg2 = (float)lua_tonumber(L, 2); if (arg1) (arg1)->x = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec3f_x_get(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float result; - SWIG_check_num_args("ofVec3f::x",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::x",1,"ofVec3f *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_x_get",1,SWIGTYPE_p_ofVec3f); } - result = (float) ((arg1)->x); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_y_set(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float arg2 ; - SWIG_check_num_args("ofVec3f::y",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::y",1,"ofVec3f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec3f::y",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_y_set",1,SWIGTYPE_p_ofVec3f); } - arg2 = (float)lua_tonumber(L, 2); if (arg1) (arg1)->y = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec3f_y_get(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float result; - SWIG_check_num_args("ofVec3f::y",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::y",1,"ofVec3f *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_y_get",1,SWIGTYPE_p_ofVec3f); } - result = (float) ((arg1)->y); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_z_set(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float arg2 ; - SWIG_check_num_args("ofVec3f::z",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::z",1,"ofVec3f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec3f::z",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_z_set",1,SWIGTYPE_p_ofVec3f); } - arg2 = (float)lua_tonumber(L, 2); if (arg1) (arg1)->z = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec3f_z_get(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float result; - SWIG_check_num_args("ofVec3f::z",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::z",1,"ofVec3f *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_z_get",1,SWIGTYPE_p_ofVec3f); } - result = (float) ((arg1)->z); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_Vec3f__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec3f *result = 0 ; - SWIG_check_num_args("ofVec3f::ofVec3f",0,0) result = (ofVec3f *)new ofVec3f(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Vec3f__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; - ofVec3f *result = 0 ; SWIG_check_num_args("ofVec3f::ofVec3f",3,3) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofVec3f::ofVec3f",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec3f::ofVec3f",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVec3f::ofVec3f",3,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); result = (ofVec3f *)new ofVec3f(arg1,arg2,arg3); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Vec3f__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; ofVec3f *result = 0 ; - SWIG_check_num_args("ofVec3f::ofVec3f",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofVec3f::ofVec3f",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec3f::ofVec3f",2,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); result = (ofVec3f *)new ofVec3f(arg1,arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Vec3f__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; ofVec3f *result = 0 ; - SWIG_check_num_args("ofVec3f::ofVec3f",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofVec3f::ofVec3f",1,"float"); - arg1 = (float)lua_tonumber(L, 1); result = (ofVec3f *)new ofVec3f(arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Vec3f__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = 0 ; ofVec3f *result = 0 ; - SWIG_check_num_args("ofVec3f::ofVec3f",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofVec3f::ofVec3f",1,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("new_Vec3f",1,SWIGTYPE_p_ofVec2f); } - result = (ofVec3f *)new ofVec3f((ofVec2f const &)*arg1); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_new_Vec3f__SWIG_5(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = 0 ; ofVec3f *result = 0 ; - SWIG_check_num_args("ofVec3f::ofVec3f",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofVec3f::ofVec3f",1,"ofVec4f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("new_Vec3f",1,SWIGTYPE_p_ofVec4f); } - result = (ofVec3f *)new ofVec3f((ofVec4f const &)*arg1); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_new_Vec3f(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_Vec3f__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_new_Vec3f__SWIG_4(L);} } if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_new_Vec3f__SWIG_5(L);} } if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_new_Vec3f__SWIG_3(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_new_Vec3f__SWIG_2(L);} - } } if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_new_Vec3f__SWIG_1(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_Vec3f'\n" " Possible C/C++ prototypes are:\n" - " ofVec3f::ofVec3f()\n" " ofVec3f::ofVec3f(float,float,float)\n" " ofVec3f::ofVec3f(float,float)\n" - " ofVec3f::ofVec3f(float)\n" " ofVec3f::ofVec3f(ofVec2f const &)\n" " ofVec3f::ofVec3f(ofVec4f const &)\n"); - lua_error(L);return 0; } -static int _wrap_Vec3f_getPtr__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float *result = 0 ; - SWIG_check_num_args("ofVec3f::getPtr",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::getPtr",1,"ofVec3f *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_getPtr",1,SWIGTYPE_p_ofVec3f); } - result = (float *)(arg1)->getPtr(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_float,0); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_getPtr__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float *result = 0 ; - SWIG_check_num_args("ofVec3f::getPtr",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::getPtr",1,"ofVec3f const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_getPtr",1,SWIGTYPE_p_ofVec3f); } - result = (float *)((ofVec3f const *)arg1)->getPtr(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_float,0); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_getPtr(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Vec3f_getPtr__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Vec3f_getPtr__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec3f_getPtr'\n" " Possible C/C++ prototypes are:\n" - " ofVec3f::getPtr()\n" " ofVec3f::getPtr() const\n"); lua_error(L);return 0; } -static int _wrap_Vec3f_set__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float arg2 ; float arg3 ; - float arg4 ; SWIG_check_num_args("ofVec3f::set",4,4) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::set",1,"ofVec3f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec3f::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVec3f::set",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVec3f::set",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_set",1,SWIGTYPE_p_ofVec3f); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - (arg1)->set(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_set__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofVec3f::set",3,3) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::set",1,"ofVec3f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec3f::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVec3f::set",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_set",1,SWIGTYPE_p_ofVec3f); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); (arg1)->set(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_set__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; - SWIG_check_num_args("ofVec3f::set",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::set",1,"ofVec3f *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec3f::set",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_set",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_set",2,SWIGTYPE_p_ofVec3f); } - (arg1)->set((ofVec3f const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_set__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float arg2 ; - SWIG_check_num_args("ofVec3f::set",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::set",1,"ofVec3f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec3f::set",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_set",1,SWIGTYPE_p_ofVec3f); } - arg2 = (float)lua_tonumber(L, 2); (arg1)->set(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_set(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec3f_set__SWIG_2(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Vec3f_set__SWIG_3(L);} } } - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Vec3f_set__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Vec3f_set__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec3f_set'\n" " Possible C/C++ prototypes are:\n" - " ofVec3f::set(float,float,float)\n" " ofVec3f::set(float,float)\n" " ofVec3f::set(ofVec3f const &)\n" - " ofVec3f::set(float)\n"); lua_error(L);return 0; } -static int _wrap_Vec3f___eq(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; bool result; - SWIG_check_num_args("ofVec3f::operator ==",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::operator ==",1,"ofVec3f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec3f::operator ==",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f___eq",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f___eq",2,SWIGTYPE_p_ofVec3f); } - result = (bool)((ofVec3f const *)arg1)->operator ==((ofVec3f const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_match__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; - float arg3 ; bool result; SWIG_check_num_args("ofVec3f::match",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::match",1,"ofVec3f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec3f::match",2,"ofVec3f const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVec3f::match",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_match",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_match",2,SWIGTYPE_p_ofVec3f); } - arg3 = (float)lua_tonumber(L, 3); result = (bool)((ofVec3f const *)arg1)->match((ofVec3f const &)*arg2,arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_match__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; - bool result; SWIG_check_num_args("ofVec3f::match",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::match",1,"ofVec3f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec3f::match",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_match",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_match",2,SWIGTYPE_p_ofVec3f); } - result = (bool)((ofVec3f const *)arg1)->match((ofVec3f const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_match(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec3f_match__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Vec3f_match__SWIG_0(L);} } } - } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec3f_match'\n" " Possible C/C++ prototypes are:\n" - " ofVec3f::match(ofVec3f const &,float) const\n" " ofVec3f::match(ofVec3f const &) const\n"); lua_error(L);return 0; } -static int _wrap_Vec3f_isAligned__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; - float arg3 ; bool result; SWIG_check_num_args("ofVec3f::isAligned",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::isAligned",1,"ofVec3f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec3f::isAligned",2,"ofVec3f const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVec3f::isAligned",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_isAligned",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_isAligned",2,SWIGTYPE_p_ofVec3f); } arg3 = (float)lua_tonumber(L, 3); - result = (bool)((ofVec3f const *)arg1)->isAligned((ofVec3f const &)*arg2,arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_isAligned__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; - bool result; SWIG_check_num_args("ofVec3f::isAligned",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::isAligned",1,"ofVec3f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec3f::isAligned",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_isAligned",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_isAligned",2,SWIGTYPE_p_ofVec3f); } - result = (bool)((ofVec3f const *)arg1)->isAligned((ofVec3f const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_isAligned(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec3f_isAligned__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Vec3f_isAligned__SWIG_0(L);} } - } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec3f_isAligned'\n" - " Possible C/C++ prototypes are:\n" " ofVec3f::isAligned(ofVec3f const &,float) const\n" - " ofVec3f::isAligned(ofVec3f const &) const\n"); lua_error(L);return 0; } -static int _wrap_Vec3f_isAlignedRad__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; - ofVec3f *arg2 = 0 ; float arg3 ; bool result; SWIG_check_num_args("ofVec3f::isAlignedRad",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::isAlignedRad",1,"ofVec3f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec3f::isAlignedRad",2,"ofVec3f const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVec3f::isAlignedRad",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_isAlignedRad",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_isAlignedRad",2,SWIGTYPE_p_ofVec3f); } arg3 = (float)lua_tonumber(L, 3); - result = (bool)((ofVec3f const *)arg1)->isAlignedRad((ofVec3f const &)*arg2,arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_isAlignedRad__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; - ofVec3f *arg2 = 0 ; bool result; SWIG_check_num_args("ofVec3f::isAlignedRad",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::isAlignedRad",1,"ofVec3f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec3f::isAlignedRad",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_isAlignedRad",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_isAlignedRad",2,SWIGTYPE_p_ofVec3f); } - result = (bool)((ofVec3f const *)arg1)->isAlignedRad((ofVec3f const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_isAlignedRad(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec3f_isAlignedRad__SWIG_1(L);} } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Vec3f_isAlignedRad__SWIG_0(L);} - } } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec3f_isAlignedRad'\n" - " Possible C/C++ prototypes are:\n" " ofVec3f::isAlignedRad(ofVec3f const &,float) const\n" - " ofVec3f::isAlignedRad(ofVec3f const &) const\n"); lua_error(L);return 0; } -static int _wrap_Vec3f_align__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; - float arg3 ; bool result; SWIG_check_num_args("ofVec3f::align",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::align",1,"ofVec3f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec3f::align",2,"ofVec3f const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVec3f::align",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_align",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_align",2,SWIGTYPE_p_ofVec3f); } - arg3 = (float)lua_tonumber(L, 3); result = (bool)((ofVec3f const *)arg1)->align((ofVec3f const &)*arg2,arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_align__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; - bool result; SWIG_check_num_args("ofVec3f::align",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::align",1,"ofVec3f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec3f::align",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_align",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_align",2,SWIGTYPE_p_ofVec3f); } - result = (bool)((ofVec3f const *)arg1)->align((ofVec3f const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_align(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec3f_align__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Vec3f_align__SWIG_0(L);} } } - } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec3f_align'\n" " Possible C/C++ prototypes are:\n" - " ofVec3f::align(ofVec3f const &,float) const\n" " ofVec3f::align(ofVec3f const &) const\n"); lua_error(L);return 0; } -static int _wrap_Vec3f_alignRad__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; - float arg3 ; bool result; SWIG_check_num_args("ofVec3f::alignRad",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::alignRad",1,"ofVec3f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec3f::alignRad",2,"ofVec3f const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVec3f::alignRad",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_alignRad",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_alignRad",2,SWIGTYPE_p_ofVec3f); } arg3 = (float)lua_tonumber(L, 3); - result = (bool)((ofVec3f const *)arg1)->alignRad((ofVec3f const &)*arg2,arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_alignRad__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; - bool result; SWIG_check_num_args("ofVec3f::alignRad",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::alignRad",1,"ofVec3f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec3f::alignRad",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_alignRad",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_alignRad",2,SWIGTYPE_p_ofVec3f); } - result = (bool)((ofVec3f const *)arg1)->alignRad((ofVec3f const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_alignRad(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec3f_alignRad__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Vec3f_alignRad__SWIG_0(L);} } - } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec3f_alignRad'\n" - " Possible C/C++ prototypes are:\n" " ofVec3f::alignRad(ofVec3f const &,float) const\n" - " ofVec3f::alignRad(ofVec3f const &) const\n"); lua_error(L);return 0; } -static int _wrap_Vec3f___add__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; - ofVec3f result; SWIG_check_num_args("ofVec3f::operator +",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::operator +",1,"ofVec3f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec3f::operator +",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f___add",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f___add",2,SWIGTYPE_p_ofVec3f); } - result = ((ofVec3f const *)arg1)->operator +((ofVec3f const &)*arg2); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f___add__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float arg2 ; - ofVec3f result; SWIG_check_num_args("ofVec3f::operator +",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::operator +",1,"ofVec3f const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec3f::operator +",2,"float const"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f___add",1,SWIGTYPE_p_ofVec3f); } - arg2 = (float const)lua_tonumber(L, 2); result = ((ofVec3f const *)arg1)->operator +(arg2); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f___add(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec3f___add__SWIG_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Vec3f___add__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec3f___add'\n" " Possible C/C++ prototypes are:\n" - " ofVec3f::operator +(ofVec3f const &) const\n" " ofVec3f::operator +(float const) const\n"); lua_error(L);return 0; } -static int _wrap_Vec3f___sub__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; - ofVec3f result; SWIG_check_num_args("ofVec3f::operator -",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::operator -",1,"ofVec3f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec3f::operator -",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f___sub",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f___sub",2,SWIGTYPE_p_ofVec3f); } - result = ((ofVec3f const *)arg1)->operator -((ofVec3f const &)*arg2); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f___sub__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float arg2 ; - ofVec3f result; SWIG_check_num_args("ofVec3f::operator -",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::operator -",1,"ofVec3f const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec3f::operator -",2,"float const"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f___sub",1,SWIGTYPE_p_ofVec3f); } - arg2 = (float const)lua_tonumber(L, 2); result = ((ofVec3f const *)arg1)->operator -(arg2); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f___sub(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec3f___sub__SWIG_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Vec3f___sub__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec3f___sub'\n" " Possible C/C++ prototypes are:\n" - " ofVec3f::operator -(ofVec3f const &) const\n" " ofVec3f::operator -(float const) const\n"); lua_error(L);return 0; } -static int _wrap_Vec3f___unm(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f result; - SWIG_check_num_args("ofVec3f::operator -",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::operator -",1,"ofVec3f const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f___unm",1,SWIGTYPE_p_ofVec3f); } - result = ((ofVec3f const *)arg1)->operator -(); { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f___mul__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; - ofVec3f result; SWIG_check_num_args("ofVec3f::operator *",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::operator *",1,"ofVec3f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec3f::operator *",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f___mul",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f___mul",2,SWIGTYPE_p_ofVec3f); } - result = ((ofVec3f const *)arg1)->operator *((ofVec3f const &)*arg2); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f___mul__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float arg2 ; - ofVec3f result; SWIG_check_num_args("ofVec3f::operator *",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::operator *",1,"ofVec3f const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec3f::operator *",2,"float const"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f___mul",1,SWIGTYPE_p_ofVec3f); } - arg2 = (float const)lua_tonumber(L, 2); result = ((ofVec3f const *)arg1)->operator *(arg2); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f___mul(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec3f___mul__SWIG_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Vec3f___mul__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec3f___mul'\n" " Possible C/C++ prototypes are:\n" - " ofVec3f::operator *(ofVec3f const &) const\n" " ofVec3f::operator *(float const) const\n"); lua_error(L);return 0; } -static int _wrap_Vec3f___div__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; - ofVec3f result; SWIG_check_num_args("ofVec3f::operator /",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::operator /",1,"ofVec3f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec3f::operator /",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f___div",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f___div",2,SWIGTYPE_p_ofVec3f); } - result = ((ofVec3f const *)arg1)->operator /((ofVec3f const &)*arg2); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f___div__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float arg2 ; - ofVec3f result; SWIG_check_num_args("ofVec3f::operator /",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::operator /",1,"ofVec3f const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec3f::operator /",2,"float const"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f___div",1,SWIGTYPE_p_ofVec3f); } - arg2 = (float const)lua_tonumber(L, 2); result = ((ofVec3f const *)arg1)->operator /(arg2); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f___div(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec3f___div__SWIG_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Vec3f___div__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec3f___div'\n" " Possible C/C++ prototypes are:\n" - " ofVec3f::operator /(ofVec3f const &) const\n" " ofVec3f::operator /(float const) const\n"); lua_error(L);return 0; } -static int _wrap_Vec3f_getScaled(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float arg2 ; ofVec3f result; - SWIG_check_num_args("ofVec3f::getScaled",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::getScaled",1,"ofVec3f const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec3f::getScaled",2,"float const"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_getScaled",1,SWIGTYPE_p_ofVec3f); } arg2 = (float const)lua_tonumber(L, 2); - result = ((ofVec3f const *)arg1)->getScaled(arg2); { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_scale(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float arg2 ; - ofVec3f *result = 0 ; SWIG_check_num_args("ofVec3f::scale",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::scale",1,"ofVec3f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec3f::scale",2,"float const"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_scale",1,SWIGTYPE_p_ofVec3f); } - arg2 = (float const)lua_tonumber(L, 2); result = (ofVec3f *) &(arg1)->scale(arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec3f_getRotated__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float arg2 ; - ofVec3f *arg3 = 0 ; ofVec3f result; SWIG_check_num_args("ofVec3f::getRotated",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::getRotated",1,"ofVec3f const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec3f::getRotated",2,"float"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofVec3f::getRotated",3,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_getRotated",1,SWIGTYPE_p_ofVec3f); } arg2 = (float)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_getRotated",3,SWIGTYPE_p_ofVec3f); } - result = ((ofVec3f const *)arg1)->getRotated(arg2,(ofVec3f const &)*arg3); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_getRotated__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float arg2 ; - float arg3 ; float arg4 ; ofVec3f result; SWIG_check_num_args("ofVec3f::getRotated",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::getRotated",1,"ofVec3f const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec3f::getRotated",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVec3f::getRotated",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVec3f::getRotated",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_getRotated",1,SWIGTYPE_p_ofVec3f); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - result = ((ofVec3f const *)arg1)->getRotated(arg2,arg3,arg4); { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_getRotated__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float arg2 ; - ofVec3f *arg3 = 0 ; ofVec3f *arg4 = 0 ; ofVec3f result; SWIG_check_num_args("ofVec3f::getRotated",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::getRotated",1,"ofVec3f const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec3f::getRotated",2,"float"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofVec3f::getRotated",3,"ofVec3f const &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofVec3f::getRotated",4,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_getRotated",1,SWIGTYPE_p_ofVec3f); } arg2 = (float)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_getRotated",3,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_getRotated",4,SWIGTYPE_p_ofVec3f); } - result = ((ofVec3f const *)arg1)->getRotated(arg2,(ofVec3f const &)*arg3,(ofVec3f const &)*arg4); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_getRotated(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec3f_getRotated__SWIG_0(L);} } } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec3f_getRotated__SWIG_2(L);} } } } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Vec3f_getRotated__SWIG_1(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec3f_getRotated'\n" " Possible C/C++ prototypes are:\n" - " ofVec3f::getRotated(float,ofVec3f const &) const\n" " ofVec3f::getRotated(float,float,float) const\n" - " ofVec3f::getRotated(float,ofVec3f const &,ofVec3f const &) const\n"); lua_error(L);return 0; } -static int _wrap_Vec3f_getRotatedRad__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float arg2 ; - ofVec3f *arg3 = 0 ; ofVec3f result; SWIG_check_num_args("ofVec3f::getRotatedRad",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::getRotatedRad",1,"ofVec3f const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec3f::getRotatedRad",2,"float"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofVec3f::getRotatedRad",3,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_getRotatedRad",1,SWIGTYPE_p_ofVec3f); } arg2 = (float)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_getRotatedRad",3,SWIGTYPE_p_ofVec3f); } - result = ((ofVec3f const *)arg1)->getRotatedRad(arg2,(ofVec3f const &)*arg3); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_getRotatedRad__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float arg2 ; - float arg3 ; float arg4 ; ofVec3f result; SWIG_check_num_args("ofVec3f::getRotatedRad",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::getRotatedRad",1,"ofVec3f const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec3f::getRotatedRad",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVec3f::getRotatedRad",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVec3f::getRotatedRad",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_getRotatedRad",1,SWIGTYPE_p_ofVec3f); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - result = ((ofVec3f const *)arg1)->getRotatedRad(arg2,arg3,arg4); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_getRotatedRad__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float arg2 ; - ofVec3f *arg3 = 0 ; ofVec3f *arg4 = 0 ; ofVec3f result; SWIG_check_num_args("ofVec3f::getRotatedRad",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::getRotatedRad",1,"ofVec3f const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec3f::getRotatedRad",2,"float"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofVec3f::getRotatedRad",3,"ofVec3f const &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofVec3f::getRotatedRad",4,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_getRotatedRad",1,SWIGTYPE_p_ofVec3f); } arg2 = (float)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_getRotatedRad",3,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_getRotatedRad",4,SWIGTYPE_p_ofVec3f); } - result = ((ofVec3f const *)arg1)->getRotatedRad(arg2,(ofVec3f const &)*arg3,(ofVec3f const &)*arg4); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_getRotatedRad(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec3f_getRotatedRad__SWIG_0(L);} } } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec3f_getRotatedRad__SWIG_2(L);} } } } } if (argc == 4) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Vec3f_getRotatedRad__SWIG_1(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec3f_getRotatedRad'\n" - " Possible C/C++ prototypes are:\n" " ofVec3f::getRotatedRad(float,ofVec3f const &) const\n" - " ofVec3f::getRotatedRad(float,float,float) const\n" - " ofVec3f::getRotatedRad(float,ofVec3f const &,ofVec3f const &) const\n"); lua_error(L);return 0; } -static int _wrap_Vec3f_rotate__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float arg2 ; - ofVec3f *arg3 = 0 ; ofVec3f *result = 0 ; SWIG_check_num_args("ofVec3f::rotate",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::rotate",1,"ofVec3f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec3f::rotate",2,"float"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofVec3f::rotate",3,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_rotate",1,SWIGTYPE_p_ofVec3f); } - arg2 = (float)lua_tonumber(L, 2); if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_rotate",3,SWIGTYPE_p_ofVec3f); } result = (ofVec3f *) &(arg1)->rotate(arg2,(ofVec3f const &)*arg3); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec3f_rotate__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float arg2 ; - float arg3 ; float arg4 ; ofVec3f *result = 0 ; SWIG_check_num_args("ofVec3f::rotate",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::rotate",1,"ofVec3f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec3f::rotate",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVec3f::rotate",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVec3f::rotate",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_rotate",1,SWIGTYPE_p_ofVec3f); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - result = (ofVec3f *) &(arg1)->rotate(arg2,arg3,arg4); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,0); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_rotate__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float arg2 ; - ofVec3f *arg3 = 0 ; ofVec3f *arg4 = 0 ; ofVec3f *result = 0 ; SWIG_check_num_args("ofVec3f::rotate",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::rotate",1,"ofVec3f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec3f::rotate",2,"float"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofVec3f::rotate",3,"ofVec3f const &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofVec3f::rotate",4,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_rotate",1,SWIGTYPE_p_ofVec3f); } - arg2 = (float)lua_tonumber(L, 2); if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_rotate",3,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_rotate",4,SWIGTYPE_p_ofVec3f); } - result = (ofVec3f *) &(arg1)->rotate(arg2,(ofVec3f const &)*arg3,(ofVec3f const &)*arg4); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec3f_rotate(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec3f_rotate__SWIG_0(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec3f_rotate__SWIG_2(L);} } } } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Vec3f_rotate__SWIG_1(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec3f_rotate'\n" " Possible C/C++ prototypes are:\n" - " ofVec3f::rotate(float,ofVec3f const &)\n" " ofVec3f::rotate(float,float,float)\n" - " ofVec3f::rotate(float,ofVec3f const &,ofVec3f const &)\n"); lua_error(L);return 0; } -static int _wrap_Vec3f_rotateRad__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float arg2 ; - ofVec3f *arg3 = 0 ; ofVec3f *result = 0 ; SWIG_check_num_args("ofVec3f::rotateRad",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::rotateRad",1,"ofVec3f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec3f::rotateRad",2,"float"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofVec3f::rotateRad",3,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_rotateRad",1,SWIGTYPE_p_ofVec3f); } arg2 = (float)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_rotateRad",3,SWIGTYPE_p_ofVec3f); } - result = (ofVec3f *) &(arg1)->rotateRad(arg2,(ofVec3f const &)*arg3); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec3f_rotateRad__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float arg2 ; - float arg3 ; float arg4 ; ofVec3f *result = 0 ; SWIG_check_num_args("ofVec3f::rotateRad",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::rotateRad",1,"ofVec3f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec3f::rotateRad",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVec3f::rotateRad",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVec3f::rotateRad",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_rotateRad",1,SWIGTYPE_p_ofVec3f); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); result = (ofVec3f *) &(arg1)->rotateRad(arg2,arg3,arg4); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec3f_rotateRad__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float arg2 ; - ofVec3f *arg3 = 0 ; ofVec3f *arg4 = 0 ; ofVec3f *result = 0 ; SWIG_check_num_args("ofVec3f::rotateRad",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::rotateRad",1,"ofVec3f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec3f::rotateRad",2,"float"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofVec3f::rotateRad",3,"ofVec3f const &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofVec3f::rotateRad",4,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_rotateRad",1,SWIGTYPE_p_ofVec3f); } arg2 = (float)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_rotateRad",3,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_rotateRad",4,SWIGTYPE_p_ofVec3f); } - result = (ofVec3f *) &(arg1)->rotateRad(arg2,(ofVec3f const &)*arg3,(ofVec3f const &)*arg4); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec3f_rotateRad(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec3f_rotateRad__SWIG_0(L);} } } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec3f_rotateRad__SWIG_2(L);} } } } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Vec3f_rotateRad__SWIG_1(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec3f_rotateRad'\n" " Possible C/C++ prototypes are:\n" - " ofVec3f::rotateRad(float,ofVec3f const &)\n" " ofVec3f::rotateRad(float,float,float)\n" - " ofVec3f::rotateRad(float,ofVec3f const &,ofVec3f const &)\n"); lua_error(L);return 0; } -static int _wrap_Vec3f_getMapped(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; - ofVec3f *arg3 = 0 ; ofVec3f *arg4 = 0 ; ofVec3f *arg5 = 0 ; ofVec3f result; SWIG_check_num_args("ofVec3f::getMapped",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::getMapped",1,"ofVec3f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec3f::getMapped",2,"ofVec3f const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofVec3f::getMapped",3,"ofVec3f const &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofVec3f::getMapped",4,"ofVec3f const &"); - if(!lua_isuserdata(L,5)) SWIG_fail_arg("ofVec3f::getMapped",5,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_getMapped",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_getMapped",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_getMapped",3,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_getMapped",4,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_getMapped",5,SWIGTYPE_p_ofVec3f); } - result = ((ofVec3f const *)arg1)->getMapped((ofVec3f const &)*arg2,(ofVec3f const &)*arg3,(ofVec3f const &)*arg4,(ofVec3f const &)*arg5); - { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_map(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; - ofVec3f *arg3 = 0 ; ofVec3f *arg4 = 0 ; ofVec3f *arg5 = 0 ; ofVec3f *result = 0 ; SWIG_check_num_args("ofVec3f::map",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::map",1,"ofVec3f *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec3f::map",2,"ofVec3f const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofVec3f::map",3,"ofVec3f const &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofVec3f::map",4,"ofVec3f const &"); - if(!lua_isuserdata(L,5)) SWIG_fail_arg("ofVec3f::map",5,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_map",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_map",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_map",3,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_map",4,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_map",5,SWIGTYPE_p_ofVec3f); } - result = (ofVec3f *) &(arg1)->map((ofVec3f const &)*arg2,(ofVec3f const &)*arg3,(ofVec3f const &)*arg4,(ofVec3f const &)*arg5); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec3f_distance(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; - float result; SWIG_check_num_args("ofVec3f::distance",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::distance",1,"ofVec3f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec3f::distance",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_distance",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_distance",2,SWIGTYPE_p_ofVec3f); } - result = (float)((ofVec3f const *)arg1)->distance((ofVec3f const &)*arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_squareDistance(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; - float result; SWIG_check_num_args("ofVec3f::squareDistance",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::squareDistance",1,"ofVec3f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec3f::squareDistance",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_squareDistance",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_squareDistance",2,SWIGTYPE_p_ofVec3f); } - result = (float)((ofVec3f const *)arg1)->squareDistance((ofVec3f const &)*arg2); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_getInterpolated(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; - float arg3 ; ofVec3f result; SWIG_check_num_args("ofVec3f::getInterpolated",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::getInterpolated",1,"ofVec3f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec3f::getInterpolated",2,"ofVec3f const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVec3f::getInterpolated",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_getInterpolated",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_getInterpolated",2,SWIGTYPE_p_ofVec3f); } arg3 = (float)lua_tonumber(L, 3); - result = ((ofVec3f const *)arg1)->getInterpolated((ofVec3f const &)*arg2,arg3); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_interpolate(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; - float arg3 ; ofVec3f *result = 0 ; SWIG_check_num_args("ofVec3f::interpolate",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::interpolate",1,"ofVec3f *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec3f::interpolate",2,"ofVec3f const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVec3f::interpolate",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_interpolate",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_interpolate",2,SWIGTYPE_p_ofVec3f); } arg3 = (float)lua_tonumber(L, 3); - result = (ofVec3f *) &(arg1)->interpolate((ofVec3f const &)*arg2,arg3); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec3f_getMiddle(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; - ofVec3f result; SWIG_check_num_args("ofVec3f::getMiddle",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::getMiddle",1,"ofVec3f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec3f::getMiddle",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_getMiddle",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_getMiddle",2,SWIGTYPE_p_ofVec3f); } - result = ((ofVec3f const *)arg1)->getMiddle((ofVec3f const &)*arg2); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_middle(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; - ofVec3f *result = 0 ; SWIG_check_num_args("ofVec3f::middle",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::middle",1,"ofVec3f *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec3f::middle",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_middle",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_middle",2,SWIGTYPE_p_ofVec3f); } result = (ofVec3f *) &(arg1)->middle((ofVec3f const &)*arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec3f_average(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = (ofVec3f *) 0 ; - int arg3 ; ofVec3f *result = 0 ; SWIG_check_num_args("ofVec3f::average",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::average",1,"ofVec3f *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofVec3f::average",2,"ofVec3f const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVec3f::average",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_average",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_average",2,SWIGTYPE_p_ofVec3f); } arg3 = (int)lua_tonumber(L, 3); - result = (ofVec3f *) &(arg1)->average((ofVec3f const *)arg2,arg3); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec3f_getNormalized(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f result; - SWIG_check_num_args("ofVec3f::getNormalized",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::getNormalized",1,"ofVec3f const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_getNormalized",1,SWIGTYPE_p_ofVec3f); } result = ((ofVec3f const *)arg1)->getNormalized(); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_normalize(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *result = 0 ; - SWIG_check_num_args("ofVec3f::normalize",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::normalize",1,"ofVec3f *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_normalize",1,SWIGTYPE_p_ofVec3f); } result = (ofVec3f *) &(arg1)->normalize(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec3f_getLimited(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float arg2 ; ofVec3f result; - SWIG_check_num_args("ofVec3f::getLimited",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::getLimited",1,"ofVec3f const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec3f::getLimited",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_getLimited",1,SWIGTYPE_p_ofVec3f); } arg2 = (float)lua_tonumber(L, 2); - result = ((ofVec3f const *)arg1)->getLimited(arg2); { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_limit(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float arg2 ; - ofVec3f *result = 0 ; SWIG_check_num_args("ofVec3f::limit",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::limit",1,"ofVec3f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec3f::limit",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_limit",1,SWIGTYPE_p_ofVec3f); } - arg2 = (float)lua_tonumber(L, 2); result = (ofVec3f *) &(arg1)->limit(arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec3f_length(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float result; - SWIG_check_num_args("ofVec3f::length",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::length",1,"ofVec3f const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_length",1,SWIGTYPE_p_ofVec3f); } - result = (float)((ofVec3f const *)arg1)->length(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_lengthSquared(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float result; - SWIG_check_num_args("ofVec3f::lengthSquared",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::lengthSquared",1,"ofVec3f const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_lengthSquared",1,SWIGTYPE_p_ofVec3f); } result = (float)((ofVec3f const *)arg1)->lengthSquared(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_angle(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; float result; - SWIG_check_num_args("ofVec3f::angle",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::angle",1,"ofVec3f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec3f::angle",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_angle",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_angle",2,SWIGTYPE_p_ofVec3f); } - result = (float)((ofVec3f const *)arg1)->angle((ofVec3f const &)*arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_angleRad(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; - float result; SWIG_check_num_args("ofVec3f::angleRad",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::angleRad",1,"ofVec3f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec3f::angleRad",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_angleRad",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_angleRad",2,SWIGTYPE_p_ofVec3f); } - result = (float)((ofVec3f const *)arg1)->angleRad((ofVec3f const &)*arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_getPerpendicular(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; - ofVec3f result; SWIG_check_num_args("ofVec3f::getPerpendicular",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::getPerpendicular",1,"ofVec3f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec3f::getPerpendicular",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_getPerpendicular",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_getPerpendicular",2,SWIGTYPE_p_ofVec3f); } - result = ((ofVec3f const *)arg1)->getPerpendicular((ofVec3f const &)*arg2); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_perpendicular(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; - ofVec3f *result = 0 ; SWIG_check_num_args("ofVec3f::perpendicular",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::perpendicular",1,"ofVec3f *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec3f::perpendicular",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_perpendicular",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_perpendicular",2,SWIGTYPE_p_ofVec3f); } - result = (ofVec3f *) &(arg1)->perpendicular((ofVec3f const &)*arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec3f_getCrossed(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; - ofVec3f result; SWIG_check_num_args("ofVec3f::getCrossed",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::getCrossed",1,"ofVec3f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec3f::getCrossed",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_getCrossed",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_getCrossed",2,SWIGTYPE_p_ofVec3f); } - result = ((ofVec3f const *)arg1)->getCrossed((ofVec3f const &)*arg2); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_cross(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; - ofVec3f *result = 0 ; SWIG_check_num_args("ofVec3f::cross",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::cross",1,"ofVec3f *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec3f::cross",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_cross",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_cross",2,SWIGTYPE_p_ofVec3f); } - result = (ofVec3f *) &(arg1)->cross((ofVec3f const &)*arg2); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,0); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_dot(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; float result; - SWIG_check_num_args("ofVec3f::dot",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::dot",1,"ofVec3f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec3f::dot",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_dot",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_dot",2,SWIGTYPE_p_ofVec3f); } - result = (float)((ofVec3f const *)arg1)->dot((ofVec3f const &)*arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_zero(lua_State* L) { int SWIG_arg = 0; ofVec3f result; SWIG_check_num_args("ofVec3f::zero",0,0) - result = ofVec3f::zero(); { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_one(lua_State* L) { int SWIG_arg = 0; ofVec3f result; SWIG_check_num_args("ofVec3f::one",0,0) - result = ofVec3f::one(); { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f___tostring(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; char *result = 0 ; - SWIG_check_num_args("ofVec3f::__str__",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::__str__",1,"ofVec3f *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f___tostring",1,SWIGTYPE_p_ofVec3f); } result = (char *)ofVec3f___str__(arg1); - lua_pushstring(L,(const char *)result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_Vec3f(void *obj) { -ofVec3f *arg1 = (ofVec3f *) obj; -delete arg1; -} -static int _proxy__wrap_new_Vec3f(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_Vec3f); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_Vec3f_attributes[] = { - { "x", _wrap_Vec3f_x_get, _wrap_Vec3f_x_set }, - { "y", _wrap_Vec3f_y_get, _wrap_Vec3f_y_set }, - { "z", _wrap_Vec3f_z_get, _wrap_Vec3f_z_set }, - {0,0,0} -}; -static swig_lua_method swig_Vec3f_methods[]= { - { "getPtr", _wrap_Vec3f_getPtr}, - { "set", _wrap_Vec3f_set}, - { "__eq", _wrap_Vec3f___eq}, - { "match", _wrap_Vec3f_match}, - { "isAligned", _wrap_Vec3f_isAligned}, - { "isAlignedRad", _wrap_Vec3f_isAlignedRad}, - { "align", _wrap_Vec3f_align}, - { "alignRad", _wrap_Vec3f_alignRad}, - { "__add", _wrap_Vec3f___add}, - { "__sub", _wrap_Vec3f___sub}, - { "__unm", _wrap_Vec3f___unm}, - { "__mul", _wrap_Vec3f___mul}, - { "__div", _wrap_Vec3f___div}, - { "getScaled", _wrap_Vec3f_getScaled}, - { "scale", _wrap_Vec3f_scale}, - { "getRotated", _wrap_Vec3f_getRotated}, - { "getRotatedRad", _wrap_Vec3f_getRotatedRad}, - { "rotate", _wrap_Vec3f_rotate}, - { "rotateRad", _wrap_Vec3f_rotateRad}, - { "getMapped", _wrap_Vec3f_getMapped}, - { "map", _wrap_Vec3f_map}, - { "distance", _wrap_Vec3f_distance}, - { "squareDistance", _wrap_Vec3f_squareDistance}, - { "getInterpolated", _wrap_Vec3f_getInterpolated}, - { "interpolate", _wrap_Vec3f_interpolate}, - { "getMiddle", _wrap_Vec3f_getMiddle}, - { "middle", _wrap_Vec3f_middle}, - { "average", _wrap_Vec3f_average}, - { "getNormalized", _wrap_Vec3f_getNormalized}, - { "normalize", _wrap_Vec3f_normalize}, - { "getLimited", _wrap_Vec3f_getLimited}, - { "limit", _wrap_Vec3f_limit}, - { "length", _wrap_Vec3f_length}, - { "lengthSquared", _wrap_Vec3f_lengthSquared}, - { "angle", _wrap_Vec3f_angle}, - { "angleRad", _wrap_Vec3f_angleRad}, - { "getPerpendicular", _wrap_Vec3f_getPerpendicular}, - { "perpendicular", _wrap_Vec3f_perpendicular}, - { "getCrossed", _wrap_Vec3f_getCrossed}, - { "cross", _wrap_Vec3f_cross}, - { "dot", _wrap_Vec3f_dot}, - { "__tostring", _wrap_Vec3f___tostring}, - {0,0} -}; -static swig_lua_method swig_Vec3f_meta[] = { - { "__eq", _wrap_Vec3f___eq}, - { "__add", _wrap_Vec3f___add}, - { "__sub", _wrap_Vec3f___sub}, - { "__unm", _wrap_Vec3f___unm}, - { "__mul", _wrap_Vec3f___mul}, - { "__div", _wrap_Vec3f___div}, - { "__tostring", _wrap_Vec3f___tostring}, - {0,0} -}; - -static swig_lua_attribute swig_Vec3f_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_Vec3f_Sf_SwigStatic_constants[]= { - {SWIG_LUA_CONSTTAB_INT("DIM", ofVec3f::DIM)}, - {0,0,0,0,0,0} -}; -static swig_lua_method swig_Vec3f_Sf_SwigStatic_methods[]= { - { "zero", _wrap_Vec3f_zero}, - { "one", _wrap_Vec3f_one}, - {0,0} -}; -static swig_lua_class* swig_Vec3f_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_Vec3f_Sf_SwigStatic = { - "Vec3f", - swig_Vec3f_Sf_SwigStatic_methods, - swig_Vec3f_Sf_SwigStatic_attributes, - swig_Vec3f_Sf_SwigStatic_constants, - swig_Vec3f_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_Vec3f_bases[] = {0}; -static const char *swig_Vec3f_base_names[] = {0}; -static swig_lua_class _wrap_class_Vec3f = { "Vec3f", "Vec3f", &SWIGTYPE_p_ofVec3f,_proxy__wrap_new_Vec3f, swig_delete_Vec3f, swig_Vec3f_methods, swig_Vec3f_attributes, &swig_Vec3f_Sf_SwigStatic, swig_Vec3f_meta, swig_Vec3f_bases, swig_Vec3f_base_names }; - -static int _wrap_Vec4f_x_set(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; float arg2 ; - SWIG_check_num_args("ofVec4f::x",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::x",1,"ofVec4f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec4f::x",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f_x_set",1,SWIGTYPE_p_ofVec4f); } - arg2 = (float)lua_tonumber(L, 2); if (arg1) (arg1)->x = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec4f_x_get(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; float result; - SWIG_check_num_args("ofVec4f::x",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::x",1,"ofVec4f *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f_x_get",1,SWIGTYPE_p_ofVec4f); } - result = (float) ((arg1)->x); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f_y_set(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; float arg2 ; - SWIG_check_num_args("ofVec4f::y",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::y",1,"ofVec4f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec4f::y",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f_y_set",1,SWIGTYPE_p_ofVec4f); } - arg2 = (float)lua_tonumber(L, 2); if (arg1) (arg1)->y = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec4f_y_get(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; float result; - SWIG_check_num_args("ofVec4f::y",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::y",1,"ofVec4f *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f_y_get",1,SWIGTYPE_p_ofVec4f); } - result = (float) ((arg1)->y); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f_z_set(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; float arg2 ; - SWIG_check_num_args("ofVec4f::z",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::z",1,"ofVec4f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec4f::z",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f_z_set",1,SWIGTYPE_p_ofVec4f); } - arg2 = (float)lua_tonumber(L, 2); if (arg1) (arg1)->z = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec4f_z_get(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; float result; - SWIG_check_num_args("ofVec4f::z",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::z",1,"ofVec4f *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f_z_get",1,SWIGTYPE_p_ofVec4f); } - result = (float) ((arg1)->z); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f_w_set(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; float arg2 ; - SWIG_check_num_args("ofVec4f::w",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::w",1,"ofVec4f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec4f::w",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f_w_set",1,SWIGTYPE_p_ofVec4f); } - arg2 = (float)lua_tonumber(L, 2); if (arg1) (arg1)->w = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec4f_w_get(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; float result; - SWIG_check_num_args("ofVec4f::w",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::w",1,"ofVec4f *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f_w_get",1,SWIGTYPE_p_ofVec4f); } - result = (float) ((arg1)->w); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_Vec4f__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec4f *result = 0 ; - SWIG_check_num_args("ofVec4f::ofVec4f",0,0) result = (ofVec4f *)new ofVec4f(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec4f,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Vec4f__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; ofVec4f *result = 0 ; - SWIG_check_num_args("ofVec4f::ofVec4f",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofVec4f::ofVec4f",1,"float"); - arg1 = (float)lua_tonumber(L, 1); result = (ofVec4f *)new ofVec4f(arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec4f,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Vec4f__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - ofVec4f *result = 0 ; SWIG_check_num_args("ofVec4f::ofVec4f",4,4) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofVec4f::ofVec4f",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec4f::ofVec4f",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVec4f::ofVec4f",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVec4f::ofVec4f",4,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - result = (ofVec4f *)new ofVec4f(arg1,arg2,arg3,arg4); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec4f,1); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_new_Vec4f__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = 0 ; ofVec4f *result = 0 ; - SWIG_check_num_args("ofVec4f::ofVec4f",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofVec4f::ofVec4f",1,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("new_Vec4f",1,SWIGTYPE_p_ofVec2f); } - result = (ofVec4f *)new ofVec4f((ofVec2f const &)*arg1); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec4f,1); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_new_Vec4f__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = 0 ; ofVec4f *result = 0 ; - SWIG_check_num_args("ofVec4f::ofVec4f",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofVec4f::ofVec4f",1,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("new_Vec4f",1,SWIGTYPE_p_ofVec3f); } - result = (ofVec4f *)new ofVec4f((ofVec3f const &)*arg1); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec4f,1); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_new_Vec4f(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_Vec4f__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_new_Vec4f__SWIG_3(L);} } if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_new_Vec4f__SWIG_4(L);} } if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_new_Vec4f__SWIG_1(L);} } if (argc == 4) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_new_Vec4f__SWIG_2(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_Vec4f'\n" " Possible C/C++ prototypes are:\n" - " ofVec4f::ofVec4f()\n" " ofVec4f::ofVec4f(float)\n" " ofVec4f::ofVec4f(float,float,float,float)\n" - " ofVec4f::ofVec4f(ofVec2f const &)\n" " ofVec4f::ofVec4f(ofVec3f const &)\n"); lua_error(L);return 0; } -static int _wrap_Vec4f_getPtr__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; float *result = 0 ; - SWIG_check_num_args("ofVec4f::getPtr",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::getPtr",1,"ofVec4f *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f_getPtr",1,SWIGTYPE_p_ofVec4f); } - result = (float *)(arg1)->getPtr(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_float,0); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f_getPtr__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; float *result = 0 ; - SWIG_check_num_args("ofVec4f::getPtr",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::getPtr",1,"ofVec4f const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f_getPtr",1,SWIGTYPE_p_ofVec4f); } - result = (float *)((ofVec4f const *)arg1)->getPtr(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_float,0); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f_getPtr(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Vec4f_getPtr__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Vec4f_getPtr__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec4f_getPtr'\n" " Possible C/C++ prototypes are:\n" - " ofVec4f::getPtr()\n" " ofVec4f::getPtr() const\n"); lua_error(L);return 0; } -static int _wrap_Vec4f_set__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; float arg2 ; - SWIG_check_num_args("ofVec4f::set",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::set",1,"ofVec4f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec4f::set",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f_set",1,SWIGTYPE_p_ofVec4f); } - arg2 = (float)lua_tonumber(L, 2); (arg1)->set(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f_set__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; float arg2 ; float arg3 ; - float arg4 ; float arg5 ; SWIG_check_num_args("ofVec4f::set",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::set",1,"ofVec4f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec4f::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVec4f::set",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVec4f::set",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofVec4f::set",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f_set",1,SWIGTYPE_p_ofVec4f); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); (arg1)->set(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec4f_set__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; ofVec4f *arg2 = 0 ; - SWIG_check_num_args("ofVec4f::set",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::set",1,"ofVec4f *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec4f::set",2,"ofVec4f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f_set",1,SWIGTYPE_p_ofVec4f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f_set",2,SWIGTYPE_p_ofVec4f); } - (arg1)->set((ofVec4f const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f_set(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 2) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec4f_set__SWIG_2(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Vec4f_set__SWIG_0(L);} } } - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Vec4f_set__SWIG_1(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec4f_set'\n" " Possible C/C++ prototypes are:\n" - " ofVec4f::set(float)\n" " ofVec4f::set(float,float,float,float)\n" " ofVec4f::set(ofVec4f const &)\n"); - lua_error(L);return 0; } -static int _wrap_Vec4f___eq(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; ofVec4f *arg2 = 0 ; bool result; - SWIG_check_num_args("ofVec4f::operator ==",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::operator ==",1,"ofVec4f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec4f::operator ==",2,"ofVec4f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f___eq",1,SWIGTYPE_p_ofVec4f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f___eq",2,SWIGTYPE_p_ofVec4f); } - result = (bool)((ofVec4f const *)arg1)->operator ==((ofVec4f const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f_match__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; ofVec4f *arg2 = 0 ; - float arg3 ; bool result; SWIG_check_num_args("ofVec4f::match",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::match",1,"ofVec4f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec4f::match",2,"ofVec4f const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVec4f::match",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f_match",1,SWIGTYPE_p_ofVec4f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f_match",2,SWIGTYPE_p_ofVec4f); } - arg3 = (float)lua_tonumber(L, 3); result = (bool)((ofVec4f const *)arg1)->match((ofVec4f const &)*arg2,arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f_match__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; ofVec4f *arg2 = 0 ; - bool result; SWIG_check_num_args("ofVec4f::match",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::match",1,"ofVec4f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec4f::match",2,"ofVec4f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f_match",1,SWIGTYPE_p_ofVec4f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f_match",2,SWIGTYPE_p_ofVec4f); } - result = (bool)((ofVec4f const *)arg1)->match((ofVec4f const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f_match(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec4f_match__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Vec4f_match__SWIG_0(L);} } } - } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec4f_match'\n" " Possible C/C++ prototypes are:\n" - " ofVec4f::match(ofVec4f const &,float) const\n" " ofVec4f::match(ofVec4f const &) const\n"); lua_error(L);return 0; } -static int _wrap_Vec4f___add__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; ofVec4f *arg2 = 0 ; - ofVec4f result; SWIG_check_num_args("ofVec4f::operator +",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::operator +",1,"ofVec4f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec4f::operator +",2,"ofVec4f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f___add",1,SWIGTYPE_p_ofVec4f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f___add",2,SWIGTYPE_p_ofVec4f); } - result = ((ofVec4f const *)arg1)->operator +((ofVec4f const &)*arg2); { - ofVec4f * resultptr = new ofVec4f((const ofVec4f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec4f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f___add__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; float arg2 ; - ofVec4f result; SWIG_check_num_args("ofVec4f::operator +",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::operator +",1,"ofVec4f const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec4f::operator +",2,"float const"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f___add",1,SWIGTYPE_p_ofVec4f); } - arg2 = (float const)lua_tonumber(L, 2); result = ((ofVec4f const *)arg1)->operator +(arg2); { - ofVec4f * resultptr = new ofVec4f((const ofVec4f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec4f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f___add(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec4f___add__SWIG_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Vec4f___add__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec4f___add'\n" " Possible C/C++ prototypes are:\n" - " ofVec4f::operator +(ofVec4f const &) const\n" " ofVec4f::operator +(float const) const\n"); lua_error(L);return 0; } -static int _wrap_Vec4f___sub__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; float arg2 ; - ofVec4f result; SWIG_check_num_args("ofVec4f::operator -",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::operator -",1,"ofVec4f const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec4f::operator -",2,"float const"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f___sub",1,SWIGTYPE_p_ofVec4f); } - arg2 = (float const)lua_tonumber(L, 2); result = ((ofVec4f const *)arg1)->operator -(arg2); { - ofVec4f * resultptr = new ofVec4f((const ofVec4f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec4f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f___sub__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; ofVec4f *arg2 = 0 ; - ofVec4f result; SWIG_check_num_args("ofVec4f::operator -",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::operator -",1,"ofVec4f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec4f::operator -",2,"ofVec4f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f___sub",1,SWIGTYPE_p_ofVec4f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f___sub",2,SWIGTYPE_p_ofVec4f); } - result = ((ofVec4f const *)arg1)->operator -((ofVec4f const &)*arg2); { - ofVec4f * resultptr = new ofVec4f((const ofVec4f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec4f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f___sub(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec4f___sub__SWIG_1(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Vec4f___sub__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec4f___sub'\n" " Possible C/C++ prototypes are:\n" - " ofVec4f::operator -(float const) const\n" " ofVec4f::operator -(ofVec4f const &) const\n"); lua_error(L);return 0; } -static int _wrap_Vec4f___unm(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; ofVec4f result; - SWIG_check_num_args("ofVec4f::operator -",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::operator -",1,"ofVec4f const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f___unm",1,SWIGTYPE_p_ofVec4f); } - result = ((ofVec4f const *)arg1)->operator -(); { ofVec4f * resultptr = new ofVec4f((const ofVec4f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec4f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f___mul__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; ofVec4f *arg2 = 0 ; - ofVec4f result; SWIG_check_num_args("ofVec4f::operator *",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::operator *",1,"ofVec4f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec4f::operator *",2,"ofVec4f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f___mul",1,SWIGTYPE_p_ofVec4f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f___mul",2,SWIGTYPE_p_ofVec4f); } - result = ((ofVec4f const *)arg1)->operator *((ofVec4f const &)*arg2); { - ofVec4f * resultptr = new ofVec4f((const ofVec4f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec4f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f___mul__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; float arg2 ; - ofVec4f result; SWIG_check_num_args("ofVec4f::operator *",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::operator *",1,"ofVec4f const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec4f::operator *",2,"float const"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f___mul",1,SWIGTYPE_p_ofVec4f); } - arg2 = (float const)lua_tonumber(L, 2); result = ((ofVec4f const *)arg1)->operator *(arg2); { - ofVec4f * resultptr = new ofVec4f((const ofVec4f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec4f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f___mul(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec4f___mul__SWIG_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Vec4f___mul__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec4f___mul'\n" " Possible C/C++ prototypes are:\n" - " ofVec4f::operator *(ofVec4f const &) const\n" " ofVec4f::operator *(float const) const\n"); lua_error(L);return 0; } -static int _wrap_Vec4f___div__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; ofVec4f *arg2 = 0 ; - ofVec4f result; SWIG_check_num_args("ofVec4f::operator /",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::operator /",1,"ofVec4f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec4f::operator /",2,"ofVec4f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f___div",1,SWIGTYPE_p_ofVec4f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f___div",2,SWIGTYPE_p_ofVec4f); } - result = ((ofVec4f const *)arg1)->operator /((ofVec4f const &)*arg2); { - ofVec4f * resultptr = new ofVec4f((const ofVec4f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec4f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f___div__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; float arg2 ; - ofVec4f result; SWIG_check_num_args("ofVec4f::operator /",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::operator /",1,"ofVec4f const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec4f::operator /",2,"float const"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f___div",1,SWIGTYPE_p_ofVec4f); } - arg2 = (float const)lua_tonumber(L, 2); result = ((ofVec4f const *)arg1)->operator /(arg2); { - ofVec4f * resultptr = new ofVec4f((const ofVec4f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec4f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f___div(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec4f___div__SWIG_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Vec4f___div__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec4f___div'\n" " Possible C/C++ prototypes are:\n" - " ofVec4f::operator /(ofVec4f const &) const\n" " ofVec4f::operator /(float const) const\n"); lua_error(L);return 0; } -static int _wrap_Vec4f_getScaled(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; float arg2 ; ofVec4f result; - SWIG_check_num_args("ofVec4f::getScaled",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::getScaled",1,"ofVec4f const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec4f::getScaled",2,"float const"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ - SWIG_fail_ptr("Vec4f_getScaled",1,SWIGTYPE_p_ofVec4f); } arg2 = (float const)lua_tonumber(L, 2); - result = ((ofVec4f const *)arg1)->getScaled(arg2); { ofVec4f * resultptr = new ofVec4f((const ofVec4f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec4f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f_scale(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; float arg2 ; - ofVec4f *result = 0 ; SWIG_check_num_args("ofVec4f::scale",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::scale",1,"ofVec4f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec4f::scale",2,"float const"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f_scale",1,SWIGTYPE_p_ofVec4f); } - arg2 = (float const)lua_tonumber(L, 2); result = (ofVec4f *) &(arg1)->scale(arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec4f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec4f_distance(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; ofVec4f *arg2 = 0 ; - float result; SWIG_check_num_args("ofVec4f::distance",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::distance",1,"ofVec4f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec4f::distance",2,"ofVec4f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ - SWIG_fail_ptr("Vec4f_distance",1,SWIGTYPE_p_ofVec4f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec4f,0))){ - SWIG_fail_ptr("Vec4f_distance",2,SWIGTYPE_p_ofVec4f); } - result = (float)((ofVec4f const *)arg1)->distance((ofVec4f const &)*arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f_squareDistance(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; ofVec4f *arg2 = 0 ; - float result; SWIG_check_num_args("ofVec4f::squareDistance",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::squareDistance",1,"ofVec4f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec4f::squareDistance",2,"ofVec4f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ - SWIG_fail_ptr("Vec4f_squareDistance",1,SWIGTYPE_p_ofVec4f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec4f,0))){ - SWIG_fail_ptr("Vec4f_squareDistance",2,SWIGTYPE_p_ofVec4f); } - result = (float)((ofVec4f const *)arg1)->squareDistance((ofVec4f const &)*arg2); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f_getInterpolated(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; ofVec4f *arg2 = 0 ; - float arg3 ; ofVec4f result; SWIG_check_num_args("ofVec4f::getInterpolated",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::getInterpolated",1,"ofVec4f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec4f::getInterpolated",2,"ofVec4f const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVec4f::getInterpolated",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ - SWIG_fail_ptr("Vec4f_getInterpolated",1,SWIGTYPE_p_ofVec4f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec4f,0))){ - SWIG_fail_ptr("Vec4f_getInterpolated",2,SWIGTYPE_p_ofVec4f); } arg3 = (float)lua_tonumber(L, 3); - result = ((ofVec4f const *)arg1)->getInterpolated((ofVec4f const &)*arg2,arg3); { - ofVec4f * resultptr = new ofVec4f((const ofVec4f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec4f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f_interpolate(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; ofVec4f *arg2 = 0 ; - float arg3 ; ofVec4f *result = 0 ; SWIG_check_num_args("ofVec4f::interpolate",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::interpolate",1,"ofVec4f *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec4f::interpolate",2,"ofVec4f const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVec4f::interpolate",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ - SWIG_fail_ptr("Vec4f_interpolate",1,SWIGTYPE_p_ofVec4f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec4f,0))){ - SWIG_fail_ptr("Vec4f_interpolate",2,SWIGTYPE_p_ofVec4f); } arg3 = (float)lua_tonumber(L, 3); - result = (ofVec4f *) &(arg1)->interpolate((ofVec4f const &)*arg2,arg3); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec4f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec4f_getMiddle(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; ofVec4f *arg2 = 0 ; - ofVec4f result; SWIG_check_num_args("ofVec4f::getMiddle",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::getMiddle",1,"ofVec4f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec4f::getMiddle",2,"ofVec4f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ - SWIG_fail_ptr("Vec4f_getMiddle",1,SWIGTYPE_p_ofVec4f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec4f,0))){ - SWIG_fail_ptr("Vec4f_getMiddle",2,SWIGTYPE_p_ofVec4f); } - result = ((ofVec4f const *)arg1)->getMiddle((ofVec4f const &)*arg2); { - ofVec4f * resultptr = new ofVec4f((const ofVec4f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec4f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f_middle(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; ofVec4f *arg2 = 0 ; - ofVec4f *result = 0 ; SWIG_check_num_args("ofVec4f::middle",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::middle",1,"ofVec4f *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec4f::middle",2,"ofVec4f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f_middle",1,SWIGTYPE_p_ofVec4f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec4f,0))){ - SWIG_fail_ptr("Vec4f_middle",2,SWIGTYPE_p_ofVec4f); } result = (ofVec4f *) &(arg1)->middle((ofVec4f const &)*arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec4f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec4f_average(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; ofVec4f *arg2 = (ofVec4f *) 0 ; - int arg3 ; ofVec4f *result = 0 ; SWIG_check_num_args("ofVec4f::average",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::average",1,"ofVec4f *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofVec4f::average",2,"ofVec4f const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVec4f::average",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ - SWIG_fail_ptr("Vec4f_average",1,SWIGTYPE_p_ofVec4f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec4f,0))){ - SWIG_fail_ptr("Vec4f_average",2,SWIGTYPE_p_ofVec4f); } arg3 = (int)lua_tonumber(L, 3); - result = (ofVec4f *) &(arg1)->average((ofVec4f const *)arg2,arg3); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec4f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec4f_getNormalized(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; ofVec4f result; - SWIG_check_num_args("ofVec4f::getNormalized",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::getNormalized",1,"ofVec4f const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ - SWIG_fail_ptr("Vec4f_getNormalized",1,SWIGTYPE_p_ofVec4f); } result = ((ofVec4f const *)arg1)->getNormalized(); { - ofVec4f * resultptr = new ofVec4f((const ofVec4f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec4f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f_normalize(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; ofVec4f *result = 0 ; - SWIG_check_num_args("ofVec4f::normalize",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::normalize",1,"ofVec4f *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ - SWIG_fail_ptr("Vec4f_normalize",1,SWIGTYPE_p_ofVec4f); } result = (ofVec4f *) &(arg1)->normalize(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec4f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec4f_getLimited(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; float arg2 ; ofVec4f result; - SWIG_check_num_args("ofVec4f::getLimited",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::getLimited",1,"ofVec4f const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec4f::getLimited",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ - SWIG_fail_ptr("Vec4f_getLimited",1,SWIGTYPE_p_ofVec4f); } arg2 = (float)lua_tonumber(L, 2); - result = ((ofVec4f const *)arg1)->getLimited(arg2); { ofVec4f * resultptr = new ofVec4f((const ofVec4f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec4f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f_limit(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; float arg2 ; - ofVec4f *result = 0 ; SWIG_check_num_args("ofVec4f::limit",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::limit",1,"ofVec4f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec4f::limit",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f_limit",1,SWIGTYPE_p_ofVec4f); } - arg2 = (float)lua_tonumber(L, 2); result = (ofVec4f *) &(arg1)->limit(arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec4f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec4f_length(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; float result; - SWIG_check_num_args("ofVec4f::length",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::length",1,"ofVec4f const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f_length",1,SWIGTYPE_p_ofVec4f); } - result = (float)((ofVec4f const *)arg1)->length(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f_lengthSquared(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; float result; - SWIG_check_num_args("ofVec4f::lengthSquared",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::lengthSquared",1,"ofVec4f const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ - SWIG_fail_ptr("Vec4f_lengthSquared",1,SWIGTYPE_p_ofVec4f); } result = (float)((ofVec4f const *)arg1)->lengthSquared(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f_dot(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; ofVec4f *arg2 = 0 ; float result; - SWIG_check_num_args("ofVec4f::dot",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::dot",1,"ofVec4f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec4f::dot",2,"ofVec4f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f_dot",1,SWIGTYPE_p_ofVec4f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f_dot",2,SWIGTYPE_p_ofVec4f); } - result = (float)((ofVec4f const *)arg1)->dot((ofVec4f const &)*arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f_zero(lua_State* L) { int SWIG_arg = 0; ofVec4f result; SWIG_check_num_args("ofVec4f::zero",0,0) - result = ofVec4f::zero(); { ofVec4f * resultptr = new ofVec4f((const ofVec4f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec4f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f_one(lua_State* L) { int SWIG_arg = 0; ofVec4f result; SWIG_check_num_args("ofVec4f::one",0,0) - result = ofVec4f::one(); { ofVec4f * resultptr = new ofVec4f((const ofVec4f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec4f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f___tostring(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; char *result = 0 ; - SWIG_check_num_args("ofVec4f::__str__",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::__str__",1,"ofVec4f *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ - SWIG_fail_ptr("Vec4f___tostring",1,SWIGTYPE_p_ofVec4f); } result = (char *)ofVec4f___str__(arg1); - lua_pushstring(L,(const char *)result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_Vec4f(void *obj) { -ofVec4f *arg1 = (ofVec4f *) obj; -delete arg1; -} -static int _proxy__wrap_new_Vec4f(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_Vec4f); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_Vec4f_attributes[] = { - { "x", _wrap_Vec4f_x_get, _wrap_Vec4f_x_set }, - { "y", _wrap_Vec4f_y_get, _wrap_Vec4f_y_set }, - { "z", _wrap_Vec4f_z_get, _wrap_Vec4f_z_set }, - { "w", _wrap_Vec4f_w_get, _wrap_Vec4f_w_set }, - {0,0,0} -}; -static swig_lua_method swig_Vec4f_methods[]= { - { "getPtr", _wrap_Vec4f_getPtr}, - { "set", _wrap_Vec4f_set}, - { "__eq", _wrap_Vec4f___eq}, - { "match", _wrap_Vec4f_match}, - { "__add", _wrap_Vec4f___add}, - { "__sub", _wrap_Vec4f___sub}, - { "__unm", _wrap_Vec4f___unm}, - { "__mul", _wrap_Vec4f___mul}, - { "__div", _wrap_Vec4f___div}, - { "getScaled", _wrap_Vec4f_getScaled}, - { "scale", _wrap_Vec4f_scale}, - { "distance", _wrap_Vec4f_distance}, - { "squareDistance", _wrap_Vec4f_squareDistance}, - { "getInterpolated", _wrap_Vec4f_getInterpolated}, - { "interpolate", _wrap_Vec4f_interpolate}, - { "getMiddle", _wrap_Vec4f_getMiddle}, - { "middle", _wrap_Vec4f_middle}, - { "average", _wrap_Vec4f_average}, - { "getNormalized", _wrap_Vec4f_getNormalized}, - { "normalize", _wrap_Vec4f_normalize}, - { "getLimited", _wrap_Vec4f_getLimited}, - { "limit", _wrap_Vec4f_limit}, - { "length", _wrap_Vec4f_length}, - { "lengthSquared", _wrap_Vec4f_lengthSquared}, - { "dot", _wrap_Vec4f_dot}, - { "__tostring", _wrap_Vec4f___tostring}, - {0,0} -}; -static swig_lua_method swig_Vec4f_meta[] = { - { "__eq", _wrap_Vec4f___eq}, - { "__add", _wrap_Vec4f___add}, - { "__sub", _wrap_Vec4f___sub}, - { "__unm", _wrap_Vec4f___unm}, - { "__mul", _wrap_Vec4f___mul}, - { "__div", _wrap_Vec4f___div}, - { "__tostring", _wrap_Vec4f___tostring}, - {0,0} -}; - -static swig_lua_attribute swig_Vec4f_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_Vec4f_Sf_SwigStatic_constants[]= { - {SWIG_LUA_CONSTTAB_INT("DIM", ofVec4f::DIM)}, - {0,0,0,0,0,0} -}; -static swig_lua_method swig_Vec4f_Sf_SwigStatic_methods[]= { - { "zero", _wrap_Vec4f_zero}, - { "one", _wrap_Vec4f_one}, - {0,0} -}; -static swig_lua_class* swig_Vec4f_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_Vec4f_Sf_SwigStatic = { - "Vec4f", - swig_Vec4f_Sf_SwigStatic_methods, - swig_Vec4f_Sf_SwigStatic_attributes, - swig_Vec4f_Sf_SwigStatic_constants, - swig_Vec4f_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_Vec4f_bases[] = {0}; -static const char *swig_Vec4f_base_names[] = {0}; -static swig_lua_class _wrap_class_Vec4f = { "Vec4f", "Vec4f", &SWIGTYPE_p_ofVec4f,_proxy__wrap_new_Vec4f, swig_delete_Vec4f, swig_Vec4f_methods, swig_Vec4f_attributes, &swig_Vec4f_Sf_SwigStatic, swig_Vec4f_meta, swig_Vec4f_bases, swig_Vec4f_base_names }; - -static int _wrap_getMousePressed__SWIG_0(lua_State* L) { int SWIG_arg = 0; int arg1 ; bool result; - SWIG_check_num_args("ofGetMousePressed",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofGetMousePressed",1,"int"); - arg1 = (int)lua_tonumber(L, 1); result = (bool)ofGetMousePressed(arg1); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getMousePressed__SWIG_1(lua_State* L) { int SWIG_arg = 0; bool result; - SWIG_check_num_args("ofGetMousePressed",0,0) result = (bool)ofGetMousePressed(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getMousePressed(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_getMousePressed__SWIG_1(L);} if (argc == 1) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { - return _wrap_getMousePressed__SWIG_0(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'getMousePressed'\n" " Possible C/C++ prototypes are:\n" - " ofGetMousePressed(int)\n" " ofGetMousePressed()\n"); lua_error(L);return 0; } -static int _wrap_getKeyPressed__SWIG_0(lua_State* L) { int SWIG_arg = 0; int arg1 ; bool result; - SWIG_check_num_args("ofGetKeyPressed",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofGetKeyPressed",1,"int"); - arg1 = (int)lua_tonumber(L, 1); result = (bool)ofGetKeyPressed(arg1); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getKeyPressed__SWIG_1(lua_State* L) { int SWIG_arg = 0; bool result; SWIG_check_num_args("ofGetKeyPressed",0,0) - result = (bool)ofGetKeyPressed(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_getKeyPressed(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_getKeyPressed__SWIG_1(L);} if (argc == 1) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { - return _wrap_getKeyPressed__SWIG_0(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'getKeyPressed'\n" " Possible C/C++ prototypes are:\n" - " ofGetKeyPressed(int)\n" " ofGetKeyPressed()\n"); lua_error(L);return 0; } -static int _wrap_getMouseX(lua_State* L) { int SWIG_arg = 0; int result; SWIG_check_num_args("ofGetMouseX",0,0) - result = (int)ofGetMouseX(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_getMouseY(lua_State* L) { int SWIG_arg = 0; int result; SWIG_check_num_args("ofGetMouseY",0,0) - result = (int)ofGetMouseY(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_getPreviousMouseX(lua_State* L) { int SWIG_arg = 0; int result; SWIG_check_num_args("ofGetPreviousMouseX",0,0) - result = (int)ofGetPreviousMouseX(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_getPreviousMouseY(lua_State* L) { int SWIG_arg = 0; int result; SWIG_check_num_args("ofGetPreviousMouseY",0,0) - result = (int)ofGetPreviousMouseY(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_DragInfo_files_set(lua_State* L) { int SWIG_arg = 0; ofDragInfo *arg1 = (ofDragInfo *) 0 ; - std::vector< std::string > *arg2 = (std::vector< std::string > *) 0 ; SWIG_check_num_args("ofDragInfo::files",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDragInfo::files",1,"ofDragInfo *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofDragInfo::files",2,"std::vector< std::string > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDragInfo,0))){ - SWIG_fail_ptr("DragInfo_files_set",1,SWIGTYPE_p_ofDragInfo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__vectorT_std__string_t,0))){ - SWIG_fail_ptr("DragInfo_files_set",2,SWIGTYPE_p_std__vectorT_std__string_t); } if (arg1) (arg1)->files = *arg2; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_DragInfo_files_get(lua_State* L) { int SWIG_arg = 0; ofDragInfo *arg1 = (ofDragInfo *) 0 ; - std::vector< std::string > *result = 0 ; SWIG_check_num_args("ofDragInfo::files",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDragInfo::files",1,"ofDragInfo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDragInfo,0))){ - SWIG_fail_ptr("DragInfo_files_get",1,SWIGTYPE_p_ofDragInfo); } result = (std::vector< std::string > *)& ((arg1)->files); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_std__string_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_DragInfo_position_set(lua_State* L) { int SWIG_arg = 0; ofDragInfo *arg1 = (ofDragInfo *) 0 ; - ofPoint *arg2 = (ofPoint *) 0 ; SWIG_check_num_args("ofDragInfo::position",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDragInfo::position",1,"ofDragInfo *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofDragInfo::position",2,"ofPoint *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDragInfo,0))){ - SWIG_fail_ptr("DragInfo_position_set",1,SWIGTYPE_p_ofDragInfo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("DragInfo_position_set",2,SWIGTYPE_p_ofVec3f); } if (arg1) (arg1)->position = *arg2; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_DragInfo_position_get(lua_State* L) { int SWIG_arg = 0; ofDragInfo *arg1 = (ofDragInfo *) 0 ; - ofPoint *result = 0 ; SWIG_check_num_args("ofDragInfo::position",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDragInfo::position",1,"ofDragInfo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDragInfo,0))){ - SWIG_fail_ptr("DragInfo_position_get",1,SWIGTYPE_p_ofDragInfo); } result = (ofPoint *)& ((arg1)->position); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_DragInfo(lua_State* L) { int SWIG_arg = 0; ofDragInfo *result = 0 ; - SWIG_check_num_args("ofDragInfo::ofDragInfo",0,0) result = (ofDragInfo *)new ofDragInfo(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofDragInfo,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static void swig_delete_DragInfo(void *obj) { -ofDragInfo *arg1 = (ofDragInfo *) obj; -delete arg1; -} -static int _proxy__wrap_new_DragInfo(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_DragInfo); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_DragInfo_attributes[] = { - { "files", _wrap_DragInfo_files_get, _wrap_DragInfo_files_set }, - { "position", _wrap_DragInfo_position_get, _wrap_DragInfo_position_set }, - {0,0,0} -}; -static swig_lua_method swig_DragInfo_methods[]= { - {0,0} -}; -static swig_lua_method swig_DragInfo_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_DragInfo_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_DragInfo_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_DragInfo_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_DragInfo_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_DragInfo_Sf_SwigStatic = { - "DragInfo", - swig_DragInfo_Sf_SwigStatic_methods, - swig_DragInfo_Sf_SwigStatic_attributes, - swig_DragInfo_Sf_SwigStatic_constants, - swig_DragInfo_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_DragInfo_bases[] = {0}; -static const char *swig_DragInfo_base_names[] = {0}; -static swig_lua_class _wrap_class_DragInfo = { "DragInfo", "DragInfo", &SWIGTYPE_p_ofDragInfo,_proxy__wrap_new_DragInfo, swig_delete_DragInfo, swig_DragInfo_methods, swig_DragInfo_attributes, &swig_DragInfo_Sf_SwigStatic, swig_DragInfo_meta, swig_DragInfo_bases, swig_DragInfo_base_names }; - -static int _wrap_new_TouchEventArgs__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofTouchEventArgs *result = 0 ; - SWIG_check_num_args("ofTouchEventArgs::ofTouchEventArgs",0,0) result = (ofTouchEventArgs *)new ofTouchEventArgs(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTouchEventArgs,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_TouchEventArgs__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofTouchEventArgs::Type arg1 ; float arg2 ; - float arg3 ; int arg4 ; ofTouchEventArgs *result = 0 ; SWIG_check_num_args("ofTouchEventArgs::ofTouchEventArgs",4,4) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofTouchEventArgs::ofTouchEventArgs",1,"ofTouchEventArgs::Type"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTouchEventArgs::ofTouchEventArgs",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTouchEventArgs::ofTouchEventArgs",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofTouchEventArgs::ofTouchEventArgs",4,"int"); - arg1 = (ofTouchEventArgs::Type)(int)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); result = (ofTouchEventArgs *)new ofTouchEventArgs(arg1,arg2,arg3,arg4); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTouchEventArgs,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_TouchEventArgs(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_TouchEventArgs__SWIG_0(L);} if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_new_TouchEventArgs__SWIG_1(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_TouchEventArgs'\n" " Possible C/C++ prototypes are:\n" - " ofTouchEventArgs::ofTouchEventArgs()\n" - " ofTouchEventArgs::ofTouchEventArgs(ofTouchEventArgs::Type,float,float,int)\n"); lua_error(L);return 0; } -static int _wrap_TouchEventArgs_type_set(lua_State* L) { int SWIG_arg = 0; ofTouchEventArgs *arg1 = (ofTouchEventArgs *) 0 ; - ofTouchEventArgs::Type arg2 ; SWIG_check_num_args("ofTouchEventArgs::type",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTouchEventArgs::type",1,"ofTouchEventArgs *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTouchEventArgs::type",2,"ofTouchEventArgs::Type"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTouchEventArgs,0))){ - SWIG_fail_ptr("TouchEventArgs_type_set",1,SWIGTYPE_p_ofTouchEventArgs); } - arg2 = (ofTouchEventArgs::Type)(int)lua_tonumber(L, 2); if (arg1) (arg1)->type = arg2; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_TouchEventArgs_type_get(lua_State* L) { int SWIG_arg = 0; ofTouchEventArgs *arg1 = (ofTouchEventArgs *) 0 ; - ofTouchEventArgs::Type result; SWIG_check_num_args("ofTouchEventArgs::type",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTouchEventArgs::type",1,"ofTouchEventArgs *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTouchEventArgs,0))){ - SWIG_fail_ptr("TouchEventArgs_type_get",1,SWIGTYPE_p_ofTouchEventArgs); } result = (ofTouchEventArgs::Type) ((arg1)->type); - lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_TouchEventArgs_id_set(lua_State* L) { int SWIG_arg = 0; ofTouchEventArgs *arg1 = (ofTouchEventArgs *) 0 ; - int arg2 ; SWIG_check_num_args("ofTouchEventArgs::id",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTouchEventArgs::id",1,"ofTouchEventArgs *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTouchEventArgs::id",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTouchEventArgs,0))){ - SWIG_fail_ptr("TouchEventArgs_id_set",1,SWIGTYPE_p_ofTouchEventArgs); } arg2 = (int)lua_tonumber(L, 2); - if (arg1) (arg1)->id = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TouchEventArgs_id_get(lua_State* L) { int SWIG_arg = 0; ofTouchEventArgs *arg1 = (ofTouchEventArgs *) 0 ; - int result; SWIG_check_num_args("ofTouchEventArgs::id",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTouchEventArgs::id",1,"ofTouchEventArgs *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTouchEventArgs,0))){ - SWIG_fail_ptr("TouchEventArgs_id_get",1,SWIGTYPE_p_ofTouchEventArgs); } result = (int) ((arg1)->id); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TouchEventArgs_time_set(lua_State* L) { int SWIG_arg = 0; ofTouchEventArgs *arg1 = (ofTouchEventArgs *) 0 ; - int arg2 ; SWIG_check_num_args("ofTouchEventArgs::time",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTouchEventArgs::time",1,"ofTouchEventArgs *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTouchEventArgs::time",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTouchEventArgs,0))){ - SWIG_fail_ptr("TouchEventArgs_time_set",1,SWIGTYPE_p_ofTouchEventArgs); } arg2 = (int)lua_tonumber(L, 2); - if (arg1) (arg1)->time = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TouchEventArgs_time_get(lua_State* L) { int SWIG_arg = 0; ofTouchEventArgs *arg1 = (ofTouchEventArgs *) 0 ; - int result; SWIG_check_num_args("ofTouchEventArgs::time",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTouchEventArgs::time",1,"ofTouchEventArgs *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTouchEventArgs,0))){ - SWIG_fail_ptr("TouchEventArgs_time_get",1,SWIGTYPE_p_ofTouchEventArgs); } result = (int) ((arg1)->time); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TouchEventArgs_numTouches_set(lua_State* L) { int SWIG_arg = 0; - ofTouchEventArgs *arg1 = (ofTouchEventArgs *) 0 ; int arg2 ; SWIG_check_num_args("ofTouchEventArgs::numTouches",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTouchEventArgs::numTouches",1,"ofTouchEventArgs *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTouchEventArgs::numTouches",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTouchEventArgs,0))){ - SWIG_fail_ptr("TouchEventArgs_numTouches_set",1,SWIGTYPE_p_ofTouchEventArgs); } arg2 = (int)lua_tonumber(L, 2); - if (arg1) (arg1)->numTouches = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TouchEventArgs_numTouches_get(lua_State* L) { int SWIG_arg = 0; - ofTouchEventArgs *arg1 = (ofTouchEventArgs *) 0 ; int result; SWIG_check_num_args("ofTouchEventArgs::numTouches",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTouchEventArgs::numTouches",1,"ofTouchEventArgs *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTouchEventArgs,0))){ - SWIG_fail_ptr("TouchEventArgs_numTouches_get",1,SWIGTYPE_p_ofTouchEventArgs); } result = (int) ((arg1)->numTouches); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TouchEventArgs_width_set(lua_State* L) { int SWIG_arg = 0; ofTouchEventArgs *arg1 = (ofTouchEventArgs *) 0 ; - float arg2 ; SWIG_check_num_args("ofTouchEventArgs::width",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTouchEventArgs::width",1,"ofTouchEventArgs *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTouchEventArgs::width",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTouchEventArgs,0))){ - SWIG_fail_ptr("TouchEventArgs_width_set",1,SWIGTYPE_p_ofTouchEventArgs); } arg2 = (float)lua_tonumber(L, 2); - if (arg1) (arg1)->width = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TouchEventArgs_width_get(lua_State* L) { int SWIG_arg = 0; ofTouchEventArgs *arg1 = (ofTouchEventArgs *) 0 ; - float result; SWIG_check_num_args("ofTouchEventArgs::width",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTouchEventArgs::width",1,"ofTouchEventArgs *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTouchEventArgs,0))){ - SWIG_fail_ptr("TouchEventArgs_width_get",1,SWIGTYPE_p_ofTouchEventArgs); } result = (float) ((arg1)->width); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TouchEventArgs_height_set(lua_State* L) { int SWIG_arg = 0; ofTouchEventArgs *arg1 = (ofTouchEventArgs *) 0 ; - float arg2 ; SWIG_check_num_args("ofTouchEventArgs::height",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTouchEventArgs::height",1,"ofTouchEventArgs *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTouchEventArgs::height",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTouchEventArgs,0))){ - SWIG_fail_ptr("TouchEventArgs_height_set",1,SWIGTYPE_p_ofTouchEventArgs); } arg2 = (float)lua_tonumber(L, 2); - if (arg1) (arg1)->height = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TouchEventArgs_height_get(lua_State* L) { int SWIG_arg = 0; ofTouchEventArgs *arg1 = (ofTouchEventArgs *) 0 ; - float result; SWIG_check_num_args("ofTouchEventArgs::height",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTouchEventArgs::height",1,"ofTouchEventArgs *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTouchEventArgs,0))){ - SWIG_fail_ptr("TouchEventArgs_height_get",1,SWIGTYPE_p_ofTouchEventArgs); } result = (float) ((arg1)->height); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TouchEventArgs_angle_set(lua_State* L) { int SWIG_arg = 0; ofTouchEventArgs *arg1 = (ofTouchEventArgs *) 0 ; - float arg2 ; SWIG_check_num_args("ofTouchEventArgs::angle",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTouchEventArgs::angle",1,"ofTouchEventArgs *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTouchEventArgs::angle",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTouchEventArgs,0))){ - SWIG_fail_ptr("TouchEventArgs_angle_set",1,SWIGTYPE_p_ofTouchEventArgs); } arg2 = (float)lua_tonumber(L, 2); - if (arg1) (arg1)->angle = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TouchEventArgs_angle_get(lua_State* L) { int SWIG_arg = 0; ofTouchEventArgs *arg1 = (ofTouchEventArgs *) 0 ; - float result; SWIG_check_num_args("ofTouchEventArgs::angle",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTouchEventArgs::angle",1,"ofTouchEventArgs *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTouchEventArgs,0))){ - SWIG_fail_ptr("TouchEventArgs_angle_get",1,SWIGTYPE_p_ofTouchEventArgs); } result = (float) ((arg1)->angle); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TouchEventArgs_minoraxis_set(lua_State* L) { int SWIG_arg = 0; - ofTouchEventArgs *arg1 = (ofTouchEventArgs *) 0 ; float arg2 ; SWIG_check_num_args("ofTouchEventArgs::minoraxis",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTouchEventArgs::minoraxis",1,"ofTouchEventArgs *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTouchEventArgs::minoraxis",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTouchEventArgs,0))){ - SWIG_fail_ptr("TouchEventArgs_minoraxis_set",1,SWIGTYPE_p_ofTouchEventArgs); } arg2 = (float)lua_tonumber(L, 2); - if (arg1) (arg1)->minoraxis = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TouchEventArgs_minoraxis_get(lua_State* L) { int SWIG_arg = 0; - ofTouchEventArgs *arg1 = (ofTouchEventArgs *) 0 ; float result; SWIG_check_num_args("ofTouchEventArgs::minoraxis",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTouchEventArgs::minoraxis",1,"ofTouchEventArgs *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTouchEventArgs,0))){ - SWIG_fail_ptr("TouchEventArgs_minoraxis_get",1,SWIGTYPE_p_ofTouchEventArgs); } result = (float) ((arg1)->minoraxis); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TouchEventArgs_majoraxis_set(lua_State* L) { int SWIG_arg = 0; - ofTouchEventArgs *arg1 = (ofTouchEventArgs *) 0 ; float arg2 ; SWIG_check_num_args("ofTouchEventArgs::majoraxis",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTouchEventArgs::majoraxis",1,"ofTouchEventArgs *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTouchEventArgs::majoraxis",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTouchEventArgs,0))){ - SWIG_fail_ptr("TouchEventArgs_majoraxis_set",1,SWIGTYPE_p_ofTouchEventArgs); } arg2 = (float)lua_tonumber(L, 2); - if (arg1) (arg1)->majoraxis = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TouchEventArgs_majoraxis_get(lua_State* L) { int SWIG_arg = 0; - ofTouchEventArgs *arg1 = (ofTouchEventArgs *) 0 ; float result; SWIG_check_num_args("ofTouchEventArgs::majoraxis",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTouchEventArgs::majoraxis",1,"ofTouchEventArgs *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTouchEventArgs,0))){ - SWIG_fail_ptr("TouchEventArgs_majoraxis_get",1,SWIGTYPE_p_ofTouchEventArgs); } result = (float) ((arg1)->majoraxis); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TouchEventArgs_pressure_set(lua_State* L) { int SWIG_arg = 0; ofTouchEventArgs *arg1 = (ofTouchEventArgs *) 0 ; - float arg2 ; SWIG_check_num_args("ofTouchEventArgs::pressure",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTouchEventArgs::pressure",1,"ofTouchEventArgs *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTouchEventArgs::pressure",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTouchEventArgs,0))){ - SWIG_fail_ptr("TouchEventArgs_pressure_set",1,SWIGTYPE_p_ofTouchEventArgs); } arg2 = (float)lua_tonumber(L, 2); - if (arg1) (arg1)->pressure = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TouchEventArgs_pressure_get(lua_State* L) { int SWIG_arg = 0; ofTouchEventArgs *arg1 = (ofTouchEventArgs *) 0 ; - float result; SWIG_check_num_args("ofTouchEventArgs::pressure",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTouchEventArgs::pressure",1,"ofTouchEventArgs *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTouchEventArgs,0))){ - SWIG_fail_ptr("TouchEventArgs_pressure_get",1,SWIGTYPE_p_ofTouchEventArgs); } result = (float) ((arg1)->pressure); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TouchEventArgs_xspeed_set(lua_State* L) { int SWIG_arg = 0; ofTouchEventArgs *arg1 = (ofTouchEventArgs *) 0 ; - float arg2 ; SWIG_check_num_args("ofTouchEventArgs::xspeed",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTouchEventArgs::xspeed",1,"ofTouchEventArgs *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTouchEventArgs::xspeed",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTouchEventArgs,0))){ - SWIG_fail_ptr("TouchEventArgs_xspeed_set",1,SWIGTYPE_p_ofTouchEventArgs); } arg2 = (float)lua_tonumber(L, 2); - if (arg1) (arg1)->xspeed = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TouchEventArgs_xspeed_get(lua_State* L) { int SWIG_arg = 0; ofTouchEventArgs *arg1 = (ofTouchEventArgs *) 0 ; - float result; SWIG_check_num_args("ofTouchEventArgs::xspeed",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTouchEventArgs::xspeed",1,"ofTouchEventArgs *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTouchEventArgs,0))){ - SWIG_fail_ptr("TouchEventArgs_xspeed_get",1,SWIGTYPE_p_ofTouchEventArgs); } result = (float) ((arg1)->xspeed); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TouchEventArgs_yspeed_set(lua_State* L) { int SWIG_arg = 0; ofTouchEventArgs *arg1 = (ofTouchEventArgs *) 0 ; - float arg2 ; SWIG_check_num_args("ofTouchEventArgs::yspeed",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTouchEventArgs::yspeed",1,"ofTouchEventArgs *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTouchEventArgs::yspeed",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTouchEventArgs,0))){ - SWIG_fail_ptr("TouchEventArgs_yspeed_set",1,SWIGTYPE_p_ofTouchEventArgs); } arg2 = (float)lua_tonumber(L, 2); - if (arg1) (arg1)->yspeed = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TouchEventArgs_yspeed_get(lua_State* L) { int SWIG_arg = 0; ofTouchEventArgs *arg1 = (ofTouchEventArgs *) 0 ; - float result; SWIG_check_num_args("ofTouchEventArgs::yspeed",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTouchEventArgs::yspeed",1,"ofTouchEventArgs *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTouchEventArgs,0))){ - SWIG_fail_ptr("TouchEventArgs_yspeed_get",1,SWIGTYPE_p_ofTouchEventArgs); } result = (float) ((arg1)->yspeed); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TouchEventArgs_xaccel_set(lua_State* L) { int SWIG_arg = 0; ofTouchEventArgs *arg1 = (ofTouchEventArgs *) 0 ; - float arg2 ; SWIG_check_num_args("ofTouchEventArgs::xaccel",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTouchEventArgs::xaccel",1,"ofTouchEventArgs *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTouchEventArgs::xaccel",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTouchEventArgs,0))){ - SWIG_fail_ptr("TouchEventArgs_xaccel_set",1,SWIGTYPE_p_ofTouchEventArgs); } arg2 = (float)lua_tonumber(L, 2); - if (arg1) (arg1)->xaccel = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TouchEventArgs_xaccel_get(lua_State* L) { int SWIG_arg = 0; ofTouchEventArgs *arg1 = (ofTouchEventArgs *) 0 ; - float result; SWIG_check_num_args("ofTouchEventArgs::xaccel",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTouchEventArgs::xaccel",1,"ofTouchEventArgs *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTouchEventArgs,0))){ - SWIG_fail_ptr("TouchEventArgs_xaccel_get",1,SWIGTYPE_p_ofTouchEventArgs); } result = (float) ((arg1)->xaccel); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TouchEventArgs_yaccel_set(lua_State* L) { int SWIG_arg = 0; ofTouchEventArgs *arg1 = (ofTouchEventArgs *) 0 ; - float arg2 ; SWIG_check_num_args("ofTouchEventArgs::yaccel",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTouchEventArgs::yaccel",1,"ofTouchEventArgs *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTouchEventArgs::yaccel",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTouchEventArgs,0))){ - SWIG_fail_ptr("TouchEventArgs_yaccel_set",1,SWIGTYPE_p_ofTouchEventArgs); } arg2 = (float)lua_tonumber(L, 2); - if (arg1) (arg1)->yaccel = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TouchEventArgs_yaccel_get(lua_State* L) { int SWIG_arg = 0; ofTouchEventArgs *arg1 = (ofTouchEventArgs *) 0 ; - float result; SWIG_check_num_args("ofTouchEventArgs::yaccel",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTouchEventArgs::yaccel",1,"ofTouchEventArgs *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTouchEventArgs,0))){ - SWIG_fail_ptr("TouchEventArgs_yaccel_get",1,SWIGTYPE_p_ofTouchEventArgs); } result = (float) ((arg1)->yaccel); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_TouchEventArgs(void *obj) { -ofTouchEventArgs *arg1 = (ofTouchEventArgs *) obj; -delete arg1; -} -static int _proxy__wrap_new_TouchEventArgs(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_TouchEventArgs); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_TouchEventArgs_attributes[] = { - { "type", _wrap_TouchEventArgs_type_get, _wrap_TouchEventArgs_type_set }, - { "id", _wrap_TouchEventArgs_id_get, _wrap_TouchEventArgs_id_set }, - { "time", _wrap_TouchEventArgs_time_get, _wrap_TouchEventArgs_time_set }, - { "numTouches", _wrap_TouchEventArgs_numTouches_get, _wrap_TouchEventArgs_numTouches_set }, - { "width", _wrap_TouchEventArgs_width_get, _wrap_TouchEventArgs_width_set }, - { "height", _wrap_TouchEventArgs_height_get, _wrap_TouchEventArgs_height_set }, - { "angle", _wrap_TouchEventArgs_angle_get, _wrap_TouchEventArgs_angle_set }, - { "minoraxis", _wrap_TouchEventArgs_minoraxis_get, _wrap_TouchEventArgs_minoraxis_set }, - { "majoraxis", _wrap_TouchEventArgs_majoraxis_get, _wrap_TouchEventArgs_majoraxis_set }, - { "pressure", _wrap_TouchEventArgs_pressure_get, _wrap_TouchEventArgs_pressure_set }, - { "xspeed", _wrap_TouchEventArgs_xspeed_get, _wrap_TouchEventArgs_xspeed_set }, - { "yspeed", _wrap_TouchEventArgs_yspeed_get, _wrap_TouchEventArgs_yspeed_set }, - { "xaccel", _wrap_TouchEventArgs_xaccel_get, _wrap_TouchEventArgs_xaccel_set }, - { "yaccel", _wrap_TouchEventArgs_yaccel_get, _wrap_TouchEventArgs_yaccel_set }, - {0,0,0} -}; -static swig_lua_method swig_TouchEventArgs_methods[]= { - {0,0} -}; -static swig_lua_method swig_TouchEventArgs_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_TouchEventArgs_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_TouchEventArgs_Sf_SwigStatic_constants[]= { - {SWIG_LUA_CONSTTAB_INT("down", ofTouchEventArgs::down)}, - {SWIG_LUA_CONSTTAB_INT("up", ofTouchEventArgs::up)}, - {SWIG_LUA_CONSTTAB_INT("move", ofTouchEventArgs::move)}, - {SWIG_LUA_CONSTTAB_INT("doubleTap", ofTouchEventArgs::doubleTap)}, - {SWIG_LUA_CONSTTAB_INT("cancel", ofTouchEventArgs::cancel)}, - {0,0,0,0,0,0} -}; -static swig_lua_method swig_TouchEventArgs_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_TouchEventArgs_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_TouchEventArgs_Sf_SwigStatic = { - "TouchEventArgs", - swig_TouchEventArgs_Sf_SwigStatic_methods, - swig_TouchEventArgs_Sf_SwigStatic_attributes, - swig_TouchEventArgs_Sf_SwigStatic_constants, - swig_TouchEventArgs_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_TouchEventArgs_bases[] = {0,0}; -static const char *swig_TouchEventArgs_base_names[] = {"ofVec2f *",0}; -static swig_lua_class _wrap_class_TouchEventArgs = { "TouchEventArgs", "TouchEventArgs", &SWIGTYPE_p_ofTouchEventArgs,_proxy__wrap_new_TouchEventArgs, swig_delete_TouchEventArgs, swig_TouchEventArgs_methods, swig_TouchEventArgs_attributes, &swig_TouchEventArgs_Sf_SwigStatic, swig_TouchEventArgs_meta, swig_TouchEventArgs_bases, swig_TouchEventArgs_base_names }; - -static int _wrap_sendMessage(lua_State* L) { int SWIG_arg = 0; std::string arg1 ; SWIG_check_num_args("ofSendMessage",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofSendMessage",1,"std::string"); (&arg1)->assign(lua_tostring(L,1),lua_rawlen(L,1)); - ofSendMessage(arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_new_BufferObject(lua_State* L) { int SWIG_arg = 0; ofBufferObject *result = 0 ; - SWIG_check_num_args("ofBufferObject::ofBufferObject",0,0) result = (ofBufferObject *)new ofBufferObject(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofBufferObject,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_BufferObject_allocate__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofBufferObject *arg1 = (ofBufferObject *) 0 ; - SWIG_check_num_args("ofBufferObject::allocate",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBufferObject::allocate",1,"ofBufferObject *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBufferObject,0))){ - SWIG_fail_ptr("BufferObject_allocate",1,SWIGTYPE_p_ofBufferObject); } (arg1)->allocate(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_BufferObject_allocate__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofBufferObject *arg1 = (ofBufferObject *) 0 ; - GLsizeiptr arg2 ; GLenum arg3 ; GLsizeiptr *argp2 ; SWIG_check_num_args("ofBufferObject::allocate",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBufferObject::allocate",1,"ofBufferObject *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofBufferObject::allocate",2,"GLsizeiptr"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofBufferObject::allocate",3,"GLenum"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBufferObject,0))){ - SWIG_fail_ptr("BufferObject_allocate",1,SWIGTYPE_p_ofBufferObject); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_GLsizeiptr,0))){ - SWIG_fail_ptr("BufferObject_allocate",2,SWIGTYPE_p_GLsizeiptr); } arg2 = *argp2; - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (GLenum)lua_tonumber(L, 3); - (arg1)->allocate(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BufferObject_allocate__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofBufferObject *arg1 = (ofBufferObject *) 0 ; - GLsizeiptr arg2 ; void *arg3 = (void *) 0 ; GLenum arg4 ; GLsizeiptr *argp2 ; - SWIG_check_num_args("ofBufferObject::allocate",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBufferObject::allocate",1,"ofBufferObject *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofBufferObject::allocate",2,"GLsizeiptr"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofBufferObject::allocate",3,"void const *"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofBufferObject::allocate",4,"GLenum"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBufferObject,0))){ - SWIG_fail_ptr("BufferObject_allocate",1,SWIGTYPE_p_ofBufferObject); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_GLsizeiptr,0))){ - SWIG_fail_ptr("BufferObject_allocate",2,SWIGTYPE_p_GLsizeiptr); } arg2 = *argp2; - arg3=(void *)SWIG_MustGetPtr(L,3,0,0,3,"BufferObject_allocate"); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (GLenum)lua_tonumber(L, 4); - (arg1)->allocate(arg2,(void const *)arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BufferObject_allocate(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 1) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofBufferObject, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_BufferObject_allocate__SWIG_0(L);} } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofBufferObject, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_GLsizeiptr, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_BufferObject_allocate__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofBufferObject, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_GLsizeiptr, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, 0, 0)) { _v = 0; } else { _v = 1; } } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_BufferObject_allocate__SWIG_2(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'BufferObject_allocate'\n" - " Possible C/C++ prototypes are:\n" " ofBufferObject::allocate()\n" " ofBufferObject::allocate(GLsizeiptr,GLenum)\n" - " ofBufferObject::allocate(GLsizeiptr,void const *,GLenum)\n"); lua_error(L);return 0; } -static int _wrap_BufferObject_isAllocated(lua_State* L) { int SWIG_arg = 0; ofBufferObject *arg1 = (ofBufferObject *) 0 ; - bool result; SWIG_check_num_args("ofBufferObject::isAllocated",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBufferObject::isAllocated",1,"ofBufferObject const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBufferObject,0))){ - SWIG_fail_ptr("BufferObject_isAllocated",1,SWIGTYPE_p_ofBufferObject); } - result = (bool)((ofBufferObject const *)arg1)->isAllocated(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BufferObject_bind(lua_State* L) { int SWIG_arg = 0; ofBufferObject *arg1 = (ofBufferObject *) 0 ; GLenum arg2 ; - SWIG_check_num_args("ofBufferObject::bind",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBufferObject::bind",1,"ofBufferObject const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBufferObject::bind",2,"GLenum"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBufferObject,0))){ - SWIG_fail_ptr("BufferObject_bind",1,SWIGTYPE_p_ofBufferObject); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (GLenum)lua_tonumber(L, 2); - ((ofBufferObject const *)arg1)->bind(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BufferObject_unbind(lua_State* L) { int SWIG_arg = 0; ofBufferObject *arg1 = (ofBufferObject *) 0 ; - GLenum arg2 ; SWIG_check_num_args("ofBufferObject::unbind",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBufferObject::unbind",1,"ofBufferObject const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBufferObject::unbind",2,"GLenum"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBufferObject,0))){ - SWIG_fail_ptr("BufferObject_unbind",1,SWIGTYPE_p_ofBufferObject); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (GLenum)lua_tonumber(L, 2); - ((ofBufferObject const *)arg1)->unbind(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BufferObject_getId(lua_State* L) { int SWIG_arg = 0; ofBufferObject *arg1 = (ofBufferObject *) 0 ; - GLuint result; SWIG_check_num_args("ofBufferObject::getId",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBufferObject::getId",1,"ofBufferObject const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBufferObject,0))){ - SWIG_fail_ptr("BufferObject_getId",1,SWIGTYPE_p_ofBufferObject); } - result = (GLuint)((ofBufferObject const *)arg1)->getId(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BufferObject_setData(lua_State* L) { int SWIG_arg = 0; ofBufferObject *arg1 = (ofBufferObject *) 0 ; - GLsizeiptr arg2 ; void *arg3 = (void *) 0 ; GLenum arg4 ; GLsizeiptr *argp2 ; - SWIG_check_num_args("ofBufferObject::setData",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBufferObject::setData",1,"ofBufferObject *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofBufferObject::setData",2,"GLsizeiptr"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofBufferObject::setData",3,"void const *"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofBufferObject::setData",4,"GLenum"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBufferObject,0))){ - SWIG_fail_ptr("BufferObject_setData",1,SWIGTYPE_p_ofBufferObject); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_GLsizeiptr,0))){ - SWIG_fail_ptr("BufferObject_setData",2,SWIGTYPE_p_GLsizeiptr); } arg2 = *argp2; - arg3=(void *)SWIG_MustGetPtr(L,3,0,0,3,"BufferObject_setData"); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (GLenum)lua_tonumber(L, 4); - (arg1)->setData(arg2,(void const *)arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BufferObject_updateData__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofBufferObject *arg1 = (ofBufferObject *) 0 ; - GLintptr arg2 ; GLsizeiptr arg3 ; void *arg4 = (void *) 0 ; GLintptr *argp2 ; GLsizeiptr *argp3 ; - SWIG_check_num_args("ofBufferObject::updateData",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBufferObject::updateData",1,"ofBufferObject *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofBufferObject::updateData",2,"GLintptr"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofBufferObject::updateData",3,"GLsizeiptr"); - if(!SWIG_isptrtype(L,4)) SWIG_fail_arg("ofBufferObject::updateData",4,"void const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBufferObject,0))){ - SWIG_fail_ptr("BufferObject_updateData",1,SWIGTYPE_p_ofBufferObject); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_GLintptr,0))){ - SWIG_fail_ptr("BufferObject_updateData",2,SWIGTYPE_p_GLintptr); } arg2 = *argp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&argp3,SWIGTYPE_p_GLsizeiptr,0))){ - SWIG_fail_ptr("BufferObject_updateData",3,SWIGTYPE_p_GLsizeiptr); } arg3 = *argp3; - arg4=(void *)SWIG_MustGetPtr(L,4,0,0,4,"BufferObject_updateData"); (arg1)->updateData(arg2,arg3,(void const *)arg4); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BufferObject_updateData__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofBufferObject *arg1 = (ofBufferObject *) 0 ; - GLsizeiptr arg2 ; void *arg3 = (void *) 0 ; GLsizeiptr *argp2 ; SWIG_check_num_args("ofBufferObject::updateData",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBufferObject::updateData",1,"ofBufferObject *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofBufferObject::updateData",2,"GLsizeiptr"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofBufferObject::updateData",3,"void const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBufferObject,0))){ - SWIG_fail_ptr("BufferObject_updateData",1,SWIGTYPE_p_ofBufferObject); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_GLsizeiptr,0))){ - SWIG_fail_ptr("BufferObject_updateData",2,SWIGTYPE_p_GLsizeiptr); } arg2 = *argp2; - arg3=(void *)SWIG_MustGetPtr(L,3,0,0,3,"BufferObject_updateData"); (arg1)->updateData(arg2,(void const *)arg3); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BufferObject_updateData(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofBufferObject, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_GLsizeiptr, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, 0, 0)) { _v = 0; } else { _v = 1; } } - if (_v) { return _wrap_BufferObject_updateData__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofBufferObject, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_GLintptr, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_GLsizeiptr, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, 0, 0)) { _v = 0; } else { _v = 1; } - } if (_v) { return _wrap_BufferObject_updateData__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'BufferObject_updateData'\n" - " Possible C/C++ prototypes are:\n" " ofBufferObject::updateData(GLintptr,GLsizeiptr,void const *)\n" - " ofBufferObject::updateData(GLsizeiptr,void const *)\n"); lua_error(L);return 0; } -static int _wrap_BufferObject_size(lua_State* L) { int SWIG_arg = 0; ofBufferObject *arg1 = (ofBufferObject *) 0 ; - GLsizeiptr result; SWIG_check_num_args("ofBufferObject::size",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBufferObject::size",1,"ofBufferObject const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBufferObject,0))){ - SWIG_fail_ptr("BufferObject_size",1,SWIGTYPE_p_ofBufferObject); } result = ((ofBufferObject const *)arg1)->size(); { - GLsizeiptr * resultptr = new GLsizeiptr((const GLsizeiptr &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_GLsizeiptr,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static void swig_delete_BufferObject(void *obj) { -ofBufferObject *arg1 = (ofBufferObject *) obj; -delete arg1; -} -static int _proxy__wrap_new_BufferObject(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_BufferObject); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_BufferObject_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_BufferObject_methods[]= { - { "allocate", _wrap_BufferObject_allocate}, - { "isAllocated", _wrap_BufferObject_isAllocated}, - { "bind", _wrap_BufferObject_bind}, - { "unbind", _wrap_BufferObject_unbind}, - { "getId", _wrap_BufferObject_getId}, - { "setData", _wrap_BufferObject_setData}, - { "updateData", _wrap_BufferObject_updateData}, - { "size", _wrap_BufferObject_size}, - {0,0} -}; -static swig_lua_method swig_BufferObject_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_BufferObject_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_BufferObject_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_BufferObject_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_BufferObject_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_BufferObject_Sf_SwigStatic = { - "BufferObject", - swig_BufferObject_Sf_SwigStatic_methods, - swig_BufferObject_Sf_SwigStatic_attributes, - swig_BufferObject_Sf_SwigStatic_constants, - swig_BufferObject_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_BufferObject_bases[] = {0}; -static const char *swig_BufferObject_base_names[] = {0}; -static swig_lua_class _wrap_class_BufferObject = { "BufferObject", "BufferObject", &SWIGTYPE_p_ofBufferObject,_proxy__wrap_new_BufferObject, swig_delete_BufferObject, swig_BufferObject_methods, swig_BufferObject_attributes, &swig_BufferObject_Sf_SwigStatic, swig_BufferObject_meta, swig_BufferObject_bases, swig_BufferObject_base_names }; - -static int _wrap_getGlInternalFormat__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPixels *arg1 = 0 ; int result; - SWIG_check_num_args("ofGetGlInternalFormat",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofGetGlInternalFormat",1,"ofPixels const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("getGlInternalFormat",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - result = (int)ofGetGlInternalFormat((ofPixels_< unsigned char > const &)*arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getGlInternalFormat__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofShortPixels *arg1 = 0 ; int result; - SWIG_check_num_args("ofGetGlInternalFormat",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofGetGlInternalFormat",1,"ofShortPixels const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("getGlInternalFormat",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - result = (int)ofGetGlInternalFormat((ofPixels_< unsigned short > const &)*arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getGlInternalFormat__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofFloatPixels *arg1 = 0 ; int result; - SWIG_check_num_args("ofGetGlInternalFormat",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofGetGlInternalFormat",1,"ofFloatPixels const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("getGlInternalFormat",1,SWIGTYPE_p_ofPixels_T_float_t); } - result = (int)ofGetGlInternalFormat((ofPixels_< float > const &)*arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getGlInternalFormat(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_getGlInternalFormat__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_getGlInternalFormat__SWIG_1(L);} } if (argc == 1) { int _v; { - void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_getGlInternalFormat__SWIG_2(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'getGlInternalFormat'\n" - " Possible C/C++ prototypes are:\n" " ofGetGlInternalFormat(ofPixels const &)\n" - " ofGetGlInternalFormat(ofShortPixels const &)\n" " ofGetGlInternalFormat(ofFloatPixels const &)\n"); - lua_error(L);return 0; } -static int _wrap_getGlInternalFormatName(lua_State* L) { int SWIG_arg = 0; int arg1 ; std::string result; - SWIG_check_num_args("ofGetGlInternalFormatName",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofGetGlInternalFormatName",1,"int"); arg1 = (int)lua_tonumber(L, 1); - result = ofGetGlInternalFormatName(arg1); lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getGLFormatFromInternal(lua_State* L) { int SWIG_arg = 0; int arg1 ; int result; - SWIG_check_num_args("ofGetGLFormatFromInternal",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofGetGLFormatFromInternal",1,"int"); arg1 = (int)lua_tonumber(L, 1); - result = (int)ofGetGLFormatFromInternal(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getGlTypeFromInternal(lua_State* L) { int SWIG_arg = 0; int arg1 ; int result; - SWIG_check_num_args("ofGetGlTypeFromInternal",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofGetGlTypeFromInternal",1,"int"); - arg1 = (int)lua_tonumber(L, 1); result = (int)ofGetGlTypeFromInternal(arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getGlType__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPixels *arg1 = 0 ; int result; - SWIG_check_num_args("ofGetGlType",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofGetGlType",1,"ofPixels const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("getGlType",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - result = (int)ofGetGlType((ofPixels_< unsigned char > const &)*arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getGlType__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofShortPixels *arg1 = 0 ; int result; - SWIG_check_num_args("ofGetGlType",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofGetGlType",1,"ofShortPixels const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("getGlType",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - result = (int)ofGetGlType((ofPixels_< unsigned short > const &)*arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getGlType__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofFloatPixels *arg1 = 0 ; int result; - SWIG_check_num_args("ofGetGlType",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofGetGlType",1,"ofFloatPixels const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("getGlType",1,SWIGTYPE_p_ofPixels_T_float_t); } result = (int)ofGetGlType((ofPixels_< float > const &)*arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getGlType(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_getGlType__SWIG_0(L);} } if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_getGlType__SWIG_1(L);} } if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_getGlType__SWIG_2(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'getGlType'\n" " Possible C/C++ prototypes are:\n" - " ofGetGlType(ofPixels const &)\n" " ofGetGlType(ofShortPixels const &)\n" " ofGetGlType(ofFloatPixels const &)\n"); - lua_error(L);return 0; } -static int _wrap_getImageTypeFromGLType(lua_State* L) { int SWIG_arg = 0; int arg1 ; ofImageType result; - SWIG_check_num_args("ofGetImageTypeFromGLType",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofGetImageTypeFromGLType",1,"int"); - arg1 = (int)lua_tonumber(L, 1); result = (ofImageType)ofGetImageTypeFromGLType(arg1); - lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_getGLPolyMode(lua_State* L) { int SWIG_arg = 0; ofPolyRenderMode arg1 ; GLuint result; - SWIG_check_num_args("ofGetGLPolyMode",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofGetGLPolyMode",1,"ofPolyRenderMode"); - arg1 = (ofPolyRenderMode)(int)lua_tonumber(L, 1); result = (GLuint)ofGetGLPolyMode(arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getOFPolyMode(lua_State* L) { int SWIG_arg = 0; GLuint arg1 ; ofPolyRenderMode result; - SWIG_check_num_args("ofGetOFPolyMode",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofGetOFPolyMode",1,"GLuint"); - SWIG_contract_assert((lua_tonumber(L,1)>=0),"number must not be negative") arg1 = (GLuint)lua_tonumber(L, 1); - result = (ofPolyRenderMode)ofGetOFPolyMode(arg1); lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getGLPrimitiveMode(lua_State* L) { int SWIG_arg = 0; ofPrimitiveMode arg1 ; GLuint result; - SWIG_check_num_args("ofGetGLPrimitiveMode",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofGetGLPrimitiveMode",1,"ofPrimitiveMode"); - arg1 = (ofPrimitiveMode)(int)lua_tonumber(L, 1); result = (GLuint)ofGetGLPrimitiveMode(arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getOFPrimitiveMode(lua_State* L) { int SWIG_arg = 0; GLuint arg1 ; ofPrimitiveMode result; - SWIG_check_num_args("ofGetOFPrimitiveMode",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofGetOFPrimitiveMode",1,"GLuint"); - SWIG_contract_assert((lua_tonumber(L,1)>=0),"number must not be negative") arg1 = (GLuint)lua_tonumber(L, 1); - result = (ofPrimitiveMode)ofGetOFPrimitiveMode(arg1); lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getGLInternalFormatFromPixelFormat(lua_State* L) { int SWIG_arg = 0; ofPixelFormat arg1 ; int result; - SWIG_check_num_args("ofGetGLInternalFormatFromPixelFormat",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofGetGLInternalFormatFromPixelFormat",1,"ofPixelFormat"); - arg1 = (ofPixelFormat)(int)lua_tonumber(L, 1); result = (int)ofGetGLInternalFormatFromPixelFormat(arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getGLFormatFromPixelFormat(lua_State* L) { int SWIG_arg = 0; ofPixelFormat arg1 ; int result; - SWIG_check_num_args("ofGetGLFormatFromPixelFormat",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofGetGLFormatFromPixelFormat",1,"ofPixelFormat"); - arg1 = (ofPixelFormat)(int)lua_tonumber(L, 1); result = (int)ofGetGLFormatFromPixelFormat(arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getBytesPerChannelFromGLType(lua_State* L) { int SWIG_arg = 0; int arg1 ; int result; - SWIG_check_num_args("ofGetBytesPerChannelFromGLType",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofGetBytesPerChannelFromGLType",1,"int"); arg1 = (int)lua_tonumber(L, 1); - result = (int)ofGetBytesPerChannelFromGLType(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getNumChannelsFromGLFormat(lua_State* L) { int SWIG_arg = 0; int arg1 ; int result; - SWIG_check_num_args("ofGetNumChannelsFromGLFormat",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofGetNumChannelsFromGLFormat",1,"int"); arg1 = (int)lua_tonumber(L, 1); - result = (int)ofGetNumChannelsFromGLFormat(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setPixelStoreiAlignment__SWIG_0(lua_State* L) { int SWIG_arg = 0; GLenum arg1 ; int arg2 ; int arg3 ; - int arg4 ; SWIG_check_num_args("ofSetPixelStoreiAlignment",4,4) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetPixelStoreiAlignment",1,"GLenum"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSetPixelStoreiAlignment",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofSetPixelStoreiAlignment",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofSetPixelStoreiAlignment",4,"int"); - SWIG_contract_assert((lua_tonumber(L,1)>=0),"number must not be negative") arg1 = (GLenum)lua_tonumber(L, 1); - arg2 = (int)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - ofSetPixelStoreiAlignment(arg1,arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setPixelStoreiAlignment__SWIG_1(lua_State* L) { int SWIG_arg = 0; GLenum arg1 ; int arg2 ; - SWIG_check_num_args("ofSetPixelStoreiAlignment",2,2) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetPixelStoreiAlignment",1,"GLenum"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSetPixelStoreiAlignment",2,"int"); - SWIG_contract_assert((lua_tonumber(L,1)>=0),"number must not be negative") arg1 = (GLenum)lua_tonumber(L, 1); - arg2 = (int)lua_tonumber(L, 2); ofSetPixelStoreiAlignment(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_setPixelStoreiAlignment(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_setPixelStoreiAlignment__SWIG_1(L);} } } if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_setPixelStoreiAlignment__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'setPixelStoreiAlignment'\n" - " Possible C/C++ prototypes are:\n" " ofSetPixelStoreiAlignment(GLenum,int,int,int)\n" - " ofSetPixelStoreiAlignment(GLenum,int)\n"); lua_error(L);return 0; } -static int _wrap_GLSupportedExtensions(lua_State* L) { int SWIG_arg = 0; std::vector< std::string > result; - SWIG_check_num_args("ofGLSupportedExtensions",0,0) result = ofGLSupportedExtensions(); { - std::vector< std::string > * resultptr = new std::vector< std::string >((const std::vector< std::string > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_std__string_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_GLCheckExtension(lua_State* L) { int SWIG_arg = 0; std::string arg1 ; bool result; - SWIG_check_num_args("ofGLCheckExtension",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofGLCheckExtension",1,"std::string"); - (&arg1)->assign(lua_tostring(L,1),lua_rawlen(L,1)); result = (bool)ofGLCheckExtension(arg1); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_GLSupportsNPOTTextures(lua_State* L) { int SWIG_arg = 0; bool result; - SWIG_check_num_args("ofGLSupportsNPOTTextures",0,0) result = (bool)ofGLSupportsNPOTTextures(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_isGLProgrammableRenderer(lua_State* L) { int SWIG_arg = 0; bool result; - SWIG_check_num_args("ofIsGLProgrammableRenderer",0,0) result = (bool)ofIsGLProgrammableRenderer(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_GLSLVersionFromGL(lua_State* L) { int SWIG_arg = 0; int arg1 ; int arg2 ; std::string result; - SWIG_check_num_args("ofGLSLVersionFromGL",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofGLSLVersionFromGL",1,"int"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofGLSLVersionFromGL",2,"int"); arg1 = (int)lua_tonumber(L, 1); - arg2 = (int)lua_tonumber(L, 2); result = ofGLSLVersionFromGL(arg1,arg2); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_enableLighting(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofEnableLighting",0,0) - ofEnableLighting(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_disableLighting(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofDisableLighting",0,0) - ofDisableLighting(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_enableSeparateSpecularLight(lua_State* L) { int SWIG_arg = 0; - SWIG_check_num_args("ofEnableSeparateSpecularLight",0,0) ofEnableSeparateSpecularLight(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_disableSeparateSpecularLight(lua_State* L) { int SWIG_arg = 0; - SWIG_check_num_args("ofDisableSeparateSpecularLight",0,0) ofDisableSeparateSpecularLight(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_getLightingEnabled(lua_State* L) { int SWIG_arg = 0; bool result; - SWIG_check_num_args("ofGetLightingEnabled",0,0) result = (bool)ofGetLightingEnabled(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setSmoothLighting(lua_State* L) { int SWIG_arg = 0; bool arg1 ; SWIG_check_num_args("ofSetSmoothLighting",1,1) - if(!lua_isboolean(L,1)) SWIG_fail_arg("ofSetSmoothLighting",1,"bool"); arg1 = (lua_toboolean(L, 1)!=0); - ofSetSmoothLighting(arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setGlobalAmbientColor(lua_State* L) { int SWIG_arg = 0; ofFloatColor *arg1 = 0 ; - SWIG_check_num_args("ofSetGlobalAmbientColor",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofSetGlobalAmbientColor",1,"ofFloatColor const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("setGlobalAmbientColor",1,SWIGTYPE_p_ofColor_T_float_t); } - ofSetGlobalAmbientColor((ofColor_< float > const &)*arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_getGlobalAmbientColor(lua_State* L) { int SWIG_arg = 0; ofFloatColor *result = 0 ; - SWIG_check_num_args("ofGetGlobalAmbientColor",0,0) result = (ofFloatColor *) &ofGetGlobalAmbientColor(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_Light(lua_State* L) { int SWIG_arg = 0; ofLight *result = 0 ; SWIG_check_num_args("ofLight::ofLight",0,0) - result = (ofLight *)new ofLight(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofLight,1); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Light_setup(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; - SWIG_check_num_args("ofLight::setup",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::setup",1,"ofLight *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ SWIG_fail_ptr("Light_setup",1,SWIGTYPE_p_ofLight); } - (arg1)->setup(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Light_enable(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; - SWIG_check_num_args("ofLight::enable",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::enable",1,"ofLight *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ SWIG_fail_ptr("Light_enable",1,SWIGTYPE_p_ofLight); } - (arg1)->enable(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Light_disable(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; - SWIG_check_num_args("ofLight::disable",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::disable",1,"ofLight *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ - SWIG_fail_ptr("Light_disable",1,SWIGTYPE_p_ofLight); } (arg1)->disable(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Light_getIsEnabled(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; bool result; - SWIG_check_num_args("ofLight::getIsEnabled",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::getIsEnabled",1,"ofLight const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ - SWIG_fail_ptr("Light_getIsEnabled",1,SWIGTYPE_p_ofLight); } result = (bool)((ofLight const *)arg1)->getIsEnabled(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Light_setDirectional(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; - SWIG_check_num_args("ofLight::setDirectional",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::setDirectional",1,"ofLight *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ - SWIG_fail_ptr("Light_setDirectional",1,SWIGTYPE_p_ofLight); } (arg1)->setDirectional(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Light_getIsDirectional(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; bool result; - SWIG_check_num_args("ofLight::getIsDirectional",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::getIsDirectional",1,"ofLight const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ - SWIG_fail_ptr("Light_getIsDirectional",1,SWIGTYPE_p_ofLight); } result = (bool)((ofLight const *)arg1)->getIsDirectional(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Light_setSpotlight__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; float arg2 ; - float arg3 ; SWIG_check_num_args("ofLight::setSpotlight",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::setSpotlight",1,"ofLight *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofLight::setSpotlight",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofLight::setSpotlight",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ - SWIG_fail_ptr("Light_setSpotlight",1,SWIGTYPE_p_ofLight); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->setSpotlight(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Light_setSpotlight__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; float arg2 ; - SWIG_check_num_args("ofLight::setSpotlight",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::setSpotlight",1,"ofLight *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofLight::setSpotlight",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ - SWIG_fail_ptr("Light_setSpotlight",1,SWIGTYPE_p_ofLight); } arg2 = (float)lua_tonumber(L, 2); (arg1)->setSpotlight(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Light_setSpotlight__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; - SWIG_check_num_args("ofLight::setSpotlight",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::setSpotlight",1,"ofLight *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ - SWIG_fail_ptr("Light_setSpotlight",1,SWIGTYPE_p_ofLight); } (arg1)->setSpotlight(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Light_setSpotlight(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofLight, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_Light_setSpotlight__SWIG_2(L);} } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofLight, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Light_setSpotlight__SWIG_1(L);} } } - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofLight, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Light_setSpotlight__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Light_setSpotlight'\n" " Possible C/C++ prototypes are:\n" - " ofLight::setSpotlight(float,float)\n" " ofLight::setSpotlight(float)\n" " ofLight::setSpotlight()\n"); - lua_error(L);return 0; } -static int _wrap_Light_getIsSpotlight(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; bool result; - SWIG_check_num_args("ofLight::getIsSpotlight",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::getIsSpotlight",1,"ofLight const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ - SWIG_fail_ptr("Light_getIsSpotlight",1,SWIGTYPE_p_ofLight); } result = (bool)((ofLight const *)arg1)->getIsSpotlight(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Light_setSpotlightCutOff(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; float arg2 ; - SWIG_check_num_args("ofLight::setSpotlightCutOff",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::setSpotlightCutOff",1,"ofLight *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofLight::setSpotlightCutOff",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ - SWIG_fail_ptr("Light_setSpotlightCutOff",1,SWIGTYPE_p_ofLight); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setSpotlightCutOff(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Light_getSpotlightCutOff(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; float result; - SWIG_check_num_args("ofLight::getSpotlightCutOff",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::getSpotlightCutOff",1,"ofLight const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ - SWIG_fail_ptr("Light_getSpotlightCutOff",1,SWIGTYPE_p_ofLight); } - result = (float)((ofLight const *)arg1)->getSpotlightCutOff(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Light_setSpotConcentration(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; float arg2 ; - SWIG_check_num_args("ofLight::setSpotConcentration",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::setSpotConcentration",1,"ofLight *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofLight::setSpotConcentration",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ - SWIG_fail_ptr("Light_setSpotConcentration",1,SWIGTYPE_p_ofLight); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setSpotConcentration(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Light_getSpotConcentration(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; float result; - SWIG_check_num_args("ofLight::getSpotConcentration",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::getSpotConcentration",1,"ofLight const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ - SWIG_fail_ptr("Light_getSpotConcentration",1,SWIGTYPE_p_ofLight); } - result = (float)((ofLight const *)arg1)->getSpotConcentration(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Light_setPointLight(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; - SWIG_check_num_args("ofLight::setPointLight",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::setPointLight",1,"ofLight *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ - SWIG_fail_ptr("Light_setPointLight",1,SWIGTYPE_p_ofLight); } (arg1)->setPointLight(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Light_getIsPointLight(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; bool result; - SWIG_check_num_args("ofLight::getIsPointLight",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::getIsPointLight",1,"ofLight const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ - SWIG_fail_ptr("Light_getIsPointLight",1,SWIGTYPE_p_ofLight); } result = (bool)((ofLight const *)arg1)->getIsPointLight(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Light_setAttenuation__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; float arg2 ; - float arg3 ; float arg4 ; SWIG_check_num_args("ofLight::setAttenuation",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::setAttenuation",1,"ofLight *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofLight::setAttenuation",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofLight::setAttenuation",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofLight::setAttenuation",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ - SWIG_fail_ptr("Light_setAttenuation",1,SWIGTYPE_p_ofLight); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); (arg1)->setAttenuation(arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Light_setAttenuation__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; float arg2 ; - float arg3 ; SWIG_check_num_args("ofLight::setAttenuation",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::setAttenuation",1,"ofLight *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofLight::setAttenuation",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofLight::setAttenuation",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ - SWIG_fail_ptr("Light_setAttenuation",1,SWIGTYPE_p_ofLight); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->setAttenuation(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Light_setAttenuation__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; float arg2 ; - SWIG_check_num_args("ofLight::setAttenuation",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::setAttenuation",1,"ofLight *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofLight::setAttenuation",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ - SWIG_fail_ptr("Light_setAttenuation",1,SWIGTYPE_p_ofLight); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setAttenuation(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Light_setAttenuation__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; - SWIG_check_num_args("ofLight::setAttenuation",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::setAttenuation",1,"ofLight *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ - SWIG_fail_ptr("Light_setAttenuation",1,SWIGTYPE_p_ofLight); } (arg1)->setAttenuation(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Light_setAttenuation(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 1) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofLight, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_Light_setAttenuation__SWIG_3(L);} } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofLight, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Light_setAttenuation__SWIG_2(L);} } } - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofLight, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Light_setAttenuation__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofLight, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Light_setAttenuation__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Light_setAttenuation'\n" - " Possible C/C++ prototypes are:\n" " ofLight::setAttenuation(float,float,float)\n" - " ofLight::setAttenuation(float,float)\n" " ofLight::setAttenuation(float)\n" " ofLight::setAttenuation()\n"); - lua_error(L);return 0; } -static int _wrap_Light_getAttenuationConstant(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; float result; - SWIG_check_num_args("ofLight::getAttenuationConstant",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::getAttenuationConstant",1,"ofLight const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ - SWIG_fail_ptr("Light_getAttenuationConstant",1,SWIGTYPE_p_ofLight); } - result = (float)((ofLight const *)arg1)->getAttenuationConstant(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Light_getAttenuationLinear(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; float result; - SWIG_check_num_args("ofLight::getAttenuationLinear",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::getAttenuationLinear",1,"ofLight const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ - SWIG_fail_ptr("Light_getAttenuationLinear",1,SWIGTYPE_p_ofLight); } - result = (float)((ofLight const *)arg1)->getAttenuationLinear(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Light_getAttenuationQuadratic(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; float result; - SWIG_check_num_args("ofLight::getAttenuationQuadratic",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::getAttenuationQuadratic",1,"ofLight const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ - SWIG_fail_ptr("Light_getAttenuationQuadratic",1,SWIGTYPE_p_ofLight); } - result = (float)((ofLight const *)arg1)->getAttenuationQuadratic(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Light_setAreaLight(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofLight::setAreaLight",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::setAreaLight",1,"ofLight *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofLight::setAreaLight",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofLight::setAreaLight",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ - SWIG_fail_ptr("Light_setAreaLight",1,SWIGTYPE_p_ofLight); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->setAreaLight(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Light_getIsAreaLight(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; bool result; - SWIG_check_num_args("ofLight::getIsAreaLight",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::getIsAreaLight",1,"ofLight const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ - SWIG_fail_ptr("Light_getIsAreaLight",1,SWIGTYPE_p_ofLight); } result = (bool)((ofLight const *)arg1)->getIsAreaLight(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Light_getType(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; int result; - SWIG_check_num_args("ofLight::getType",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::getType",1,"ofLight const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ - SWIG_fail_ptr("Light_getType",1,SWIGTYPE_p_ofLight); } result = (int)((ofLight const *)arg1)->getType(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Light_setAmbientColor(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; - ofFloatColor *arg2 = 0 ; SWIG_check_num_args("ofLight::setAmbientColor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::setAmbientColor",1,"ofLight *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofLight::setAmbientColor",2,"ofFloatColor const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ - SWIG_fail_ptr("Light_setAmbientColor",1,SWIGTYPE_p_ofLight); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("Light_setAmbientColor",2,SWIGTYPE_p_ofColor_T_float_t); } - (arg1)->setAmbientColor((ofFloatColor const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Light_setDiffuseColor(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; - ofFloatColor *arg2 = 0 ; SWIG_check_num_args("ofLight::setDiffuseColor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::setDiffuseColor",1,"ofLight *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofLight::setDiffuseColor",2,"ofFloatColor const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ - SWIG_fail_ptr("Light_setDiffuseColor",1,SWIGTYPE_p_ofLight); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("Light_setDiffuseColor",2,SWIGTYPE_p_ofColor_T_float_t); } - (arg1)->setDiffuseColor((ofFloatColor const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Light_setSpecularColor(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; - ofFloatColor *arg2 = 0 ; SWIG_check_num_args("ofLight::setSpecularColor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::setSpecularColor",1,"ofLight *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofLight::setSpecularColor",2,"ofFloatColor const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ - SWIG_fail_ptr("Light_setSpecularColor",1,SWIGTYPE_p_ofLight); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("Light_setSpecularColor",2,SWIGTYPE_p_ofColor_T_float_t); } - (arg1)->setSpecularColor((ofFloatColor const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Light_getAmbientColor(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; ofFloatColor result; - SWIG_check_num_args("ofLight::getAmbientColor",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::getAmbientColor",1,"ofLight const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ - SWIG_fail_ptr("Light_getAmbientColor",1,SWIGTYPE_p_ofLight); } result = ((ofLight const *)arg1)->getAmbientColor(); { - ofFloatColor * resultptr = new ofFloatColor((const ofFloatColor &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Light_getDiffuseColor(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; ofFloatColor result; - SWIG_check_num_args("ofLight::getDiffuseColor",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::getDiffuseColor",1,"ofLight const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ - SWIG_fail_ptr("Light_getDiffuseColor",1,SWIGTYPE_p_ofLight); } result = ((ofLight const *)arg1)->getDiffuseColor(); { - ofFloatColor * resultptr = new ofFloatColor((const ofFloatColor &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Light_getSpecularColor(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; ofFloatColor result; - SWIG_check_num_args("ofLight::getSpecularColor",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::getSpecularColor",1,"ofLight const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ - SWIG_fail_ptr("Light_getSpecularColor",1,SWIGTYPE_p_ofLight); } result = ((ofLight const *)arg1)->getSpecularColor(); { - ofFloatColor * resultptr = new ofFloatColor((const ofFloatColor &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Light_getLightID(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; int result; - SWIG_check_num_args("ofLight::getLightID",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::getLightID",1,"ofLight const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ - SWIG_fail_ptr("Light_getLightID",1,SWIGTYPE_p_ofLight); } result = (int)((ofLight const *)arg1)->getLightID(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_Light(void *obj) { -ofLight *arg1 = (ofLight *) obj; -delete arg1; -} -static int _proxy__wrap_new_Light(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_Light); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_Light_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_Light_methods[]= { - { "setup", _wrap_Light_setup}, - { "enable", _wrap_Light_enable}, - { "disable", _wrap_Light_disable}, - { "getIsEnabled", _wrap_Light_getIsEnabled}, - { "setDirectional", _wrap_Light_setDirectional}, - { "getIsDirectional", _wrap_Light_getIsDirectional}, - { "setSpotlight", _wrap_Light_setSpotlight}, - { "getIsSpotlight", _wrap_Light_getIsSpotlight}, - { "setSpotlightCutOff", _wrap_Light_setSpotlightCutOff}, - { "getSpotlightCutOff", _wrap_Light_getSpotlightCutOff}, - { "setSpotConcentration", _wrap_Light_setSpotConcentration}, - { "getSpotConcentration", _wrap_Light_getSpotConcentration}, - { "setPointLight", _wrap_Light_setPointLight}, - { "getIsPointLight", _wrap_Light_getIsPointLight}, - { "setAttenuation", _wrap_Light_setAttenuation}, - { "getAttenuationConstant", _wrap_Light_getAttenuationConstant}, - { "getAttenuationLinear", _wrap_Light_getAttenuationLinear}, - { "getAttenuationQuadratic", _wrap_Light_getAttenuationQuadratic}, - { "setAreaLight", _wrap_Light_setAreaLight}, - { "getIsAreaLight", _wrap_Light_getIsAreaLight}, - { "getType", _wrap_Light_getType}, - { "setAmbientColor", _wrap_Light_setAmbientColor}, - { "setDiffuseColor", _wrap_Light_setDiffuseColor}, - { "setSpecularColor", _wrap_Light_setSpecularColor}, - { "getAmbientColor", _wrap_Light_getAmbientColor}, - { "getDiffuseColor", _wrap_Light_getDiffuseColor}, - { "getSpecularColor", _wrap_Light_getSpecularColor}, - { "getLightID", _wrap_Light_getLightID}, - {0,0} -}; -static swig_lua_method swig_Light_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_Light_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_Light_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_Light_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_Light_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_Light_Sf_SwigStatic = { - "Light", - swig_Light_Sf_SwigStatic_methods, - swig_Light_Sf_SwigStatic_attributes, - swig_Light_Sf_SwigStatic_constants, - swig_Light_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_Light_bases[] = {0,0}; -static const char *swig_Light_base_names[] = {"ofNode *",0}; -static swig_lua_class _wrap_class_Light = { "Light", "Light", &SWIGTYPE_p_ofLight,_proxy__wrap_new_Light, swig_delete_Light, swig_Light_methods, swig_Light_attributes, &swig_Light_Sf_SwigStatic, swig_Light_meta, swig_Light_bases, swig_Light_base_names }; - -static int _wrap_lightsData(lua_State* L) { int SWIG_arg = 0; std::vector< weak_ptr< ofLight::Data > > *result = 0 ; - SWIG_check_num_args("ofLightsData",0,0) result = (std::vector< weak_ptr< ofLight::Data > > *) &ofLightsData(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_weak_ptrT_ofLight__Data_t_t,0); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_new_Material(lua_State* L) { int SWIG_arg = 0; ofMaterial *result = 0 ; - SWIG_check_num_args("ofMaterial::ofMaterial",0,0) result = (ofMaterial *)new ofMaterial(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMaterial,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Material_setColors(lua_State* L) { int SWIG_arg = 0; ofMaterial *arg1 = (ofMaterial *) 0 ; ofFloatColor arg2 ; - ofFloatColor arg3 ; ofFloatColor arg4 ; ofFloatColor arg5 ; ofFloatColor *argp2 ; ofFloatColor *argp3 ; ofFloatColor *argp4 ; - ofFloatColor *argp5 ; SWIG_check_num_args("ofMaterial::setColors",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMaterial::setColors",1,"ofMaterial *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMaterial::setColors",2,"ofFloatColor"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofMaterial::setColors",3,"ofFloatColor"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofMaterial::setColors",4,"ofFloatColor"); - if(!lua_isuserdata(L,5)) SWIG_fail_arg("ofMaterial::setColors",5,"ofFloatColor"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMaterial,0))){ - SWIG_fail_ptr("Material_setColors",1,SWIGTYPE_p_ofMaterial); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("Material_setColors",2,SWIGTYPE_p_ofColor_T_float_t); } arg2 = *argp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&argp3,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("Material_setColors",3,SWIGTYPE_p_ofColor_T_float_t); } arg3 = *argp3; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&argp4,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("Material_setColors",4,SWIGTYPE_p_ofColor_T_float_t); } arg4 = *argp4; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&argp5,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("Material_setColors",5,SWIGTYPE_p_ofColor_T_float_t); } arg5 = *argp5; - (arg1)->setColors(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Material_setDiffuseColor(lua_State* L) { int SWIG_arg = 0; ofMaterial *arg1 = (ofMaterial *) 0 ; - ofFloatColor arg2 ; ofFloatColor *argp2 ; SWIG_check_num_args("ofMaterial::setDiffuseColor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMaterial::setDiffuseColor",1,"ofMaterial *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMaterial::setDiffuseColor",2,"ofFloatColor"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMaterial,0))){ - SWIG_fail_ptr("Material_setDiffuseColor",1,SWIGTYPE_p_ofMaterial); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("Material_setDiffuseColor",2,SWIGTYPE_p_ofColor_T_float_t); } arg2 = *argp2; (arg1)->setDiffuseColor(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Material_setAmbientColor(lua_State* L) { int SWIG_arg = 0; ofMaterial *arg1 = (ofMaterial *) 0 ; - ofFloatColor arg2 ; ofFloatColor *argp2 ; SWIG_check_num_args("ofMaterial::setAmbientColor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMaterial::setAmbientColor",1,"ofMaterial *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMaterial::setAmbientColor",2,"ofFloatColor"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMaterial,0))){ - SWIG_fail_ptr("Material_setAmbientColor",1,SWIGTYPE_p_ofMaterial); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("Material_setAmbientColor",2,SWIGTYPE_p_ofColor_T_float_t); } arg2 = *argp2; (arg1)->setAmbientColor(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Material_setSpecularColor(lua_State* L) { int SWIG_arg = 0; ofMaterial *arg1 = (ofMaterial *) 0 ; - ofFloatColor arg2 ; ofFloatColor *argp2 ; SWIG_check_num_args("ofMaterial::setSpecularColor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMaterial::setSpecularColor",1,"ofMaterial *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMaterial::setSpecularColor",2,"ofFloatColor"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMaterial,0))){ - SWIG_fail_ptr("Material_setSpecularColor",1,SWIGTYPE_p_ofMaterial); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("Material_setSpecularColor",2,SWIGTYPE_p_ofColor_T_float_t); } arg2 = *argp2; (arg1)->setSpecularColor(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Material_setEmissiveColor(lua_State* L) { int SWIG_arg = 0; ofMaterial *arg1 = (ofMaterial *) 0 ; - ofFloatColor arg2 ; ofFloatColor *argp2 ; SWIG_check_num_args("ofMaterial::setEmissiveColor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMaterial::setEmissiveColor",1,"ofMaterial *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMaterial::setEmissiveColor",2,"ofFloatColor"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMaterial,0))){ - SWIG_fail_ptr("Material_setEmissiveColor",1,SWIGTYPE_p_ofMaterial); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("Material_setEmissiveColor",2,SWIGTYPE_p_ofColor_T_float_t); } arg2 = *argp2; (arg1)->setEmissiveColor(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Material_setShininess(lua_State* L) { int SWIG_arg = 0; ofMaterial *arg1 = (ofMaterial *) 0 ; float arg2 ; - SWIG_check_num_args("ofMaterial::setShininess",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMaterial::setShininess",1,"ofMaterial *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMaterial::setShininess",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMaterial,0))){ - SWIG_fail_ptr("Material_setShininess",1,SWIGTYPE_p_ofMaterial); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setShininess(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Material_getDiffuseColor(lua_State* L) { int SWIG_arg = 0; ofMaterial *arg1 = (ofMaterial *) 0 ; - ofFloatColor result; SWIG_check_num_args("ofMaterial::getDiffuseColor",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMaterial::getDiffuseColor",1,"ofMaterial const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMaterial,0))){ - SWIG_fail_ptr("Material_getDiffuseColor",1,SWIGTYPE_p_ofMaterial); } - result = ((ofMaterial const *)arg1)->getDiffuseColor(); { - ofFloatColor * resultptr = new ofFloatColor((const ofFloatColor &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Material_getAmbientColor(lua_State* L) { int SWIG_arg = 0; ofMaterial *arg1 = (ofMaterial *) 0 ; - ofFloatColor result; SWIG_check_num_args("ofMaterial::getAmbientColor",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMaterial::getAmbientColor",1,"ofMaterial const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMaterial,0))){ - SWIG_fail_ptr("Material_getAmbientColor",1,SWIGTYPE_p_ofMaterial); } - result = ((ofMaterial const *)arg1)->getAmbientColor(); { - ofFloatColor * resultptr = new ofFloatColor((const ofFloatColor &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Material_getSpecularColor(lua_State* L) { int SWIG_arg = 0; ofMaterial *arg1 = (ofMaterial *) 0 ; - ofFloatColor result; SWIG_check_num_args("ofMaterial::getSpecularColor",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMaterial::getSpecularColor",1,"ofMaterial const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMaterial,0))){ - SWIG_fail_ptr("Material_getSpecularColor",1,SWIGTYPE_p_ofMaterial); } - result = ((ofMaterial const *)arg1)->getSpecularColor(); { - ofFloatColor * resultptr = new ofFloatColor((const ofFloatColor &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Material_getEmissiveColor(lua_State* L) { int SWIG_arg = 0; ofMaterial *arg1 = (ofMaterial *) 0 ; - ofFloatColor result; SWIG_check_num_args("ofMaterial::getEmissiveColor",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMaterial::getEmissiveColor",1,"ofMaterial const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMaterial,0))){ - SWIG_fail_ptr("Material_getEmissiveColor",1,SWIGTYPE_p_ofMaterial); } - result = ((ofMaterial const *)arg1)->getEmissiveColor(); { - ofFloatColor * resultptr = new ofFloatColor((const ofFloatColor &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Material_getShininess(lua_State* L) { int SWIG_arg = 0; ofMaterial *arg1 = (ofMaterial *) 0 ; float result; - SWIG_check_num_args("ofMaterial::getShininess",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMaterial::getShininess",1,"ofMaterial const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMaterial,0))){ - SWIG_fail_ptr("Material_getShininess",1,SWIGTYPE_p_ofMaterial); } - result = (float)((ofMaterial const *)arg1)->getShininess(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Material_beginMaterial(lua_State* L) { int SWIG_arg = 0; ofMaterial *arg1 = (ofMaterial *) 0 ; - SWIG_check_num_args("ofMaterial::begin",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMaterial::begin",1,"ofMaterial const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMaterial,0))){ - SWIG_fail_ptr("Material_beginMaterial",1,SWIGTYPE_p_ofMaterial); } ((ofMaterial const *)arg1)->begin(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Material_endMaterial(lua_State* L) { int SWIG_arg = 0; ofMaterial *arg1 = (ofMaterial *) 0 ; - SWIG_check_num_args("ofMaterial::end",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMaterial::end",1,"ofMaterial const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMaterial,0))){ - SWIG_fail_ptr("Material_endMaterial",1,SWIGTYPE_p_ofMaterial); } ((ofMaterial const *)arg1)->end(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_Material(void *obj) { -ofMaterial *arg1 = (ofMaterial *) obj; -delete arg1; -} -static int _proxy__wrap_new_Material(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_Material); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_Material_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_Material_methods[]= { - { "setColors", _wrap_Material_setColors}, - { "setDiffuseColor", _wrap_Material_setDiffuseColor}, - { "setAmbientColor", _wrap_Material_setAmbientColor}, - { "setSpecularColor", _wrap_Material_setSpecularColor}, - { "setEmissiveColor", _wrap_Material_setEmissiveColor}, - { "setShininess", _wrap_Material_setShininess}, - { "getDiffuseColor", _wrap_Material_getDiffuseColor}, - { "getAmbientColor", _wrap_Material_getAmbientColor}, - { "getSpecularColor", _wrap_Material_getSpecularColor}, - { "getEmissiveColor", _wrap_Material_getEmissiveColor}, - { "getShininess", _wrap_Material_getShininess}, - { "beginMaterial", _wrap_Material_beginMaterial}, - { "endMaterial", _wrap_Material_endMaterial}, - {0,0} -}; -static swig_lua_method swig_Material_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_Material_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_Material_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_Material_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_Material_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_Material_Sf_SwigStatic = { - "Material", - swig_Material_Sf_SwigStatic_methods, - swig_Material_Sf_SwigStatic_attributes, - swig_Material_Sf_SwigStatic_constants, - swig_Material_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_Material_bases[] = {0}; -static const char *swig_Material_base_names[] = {0}; -static swig_lua_class _wrap_class_Material = { "Material", "Material", &SWIGTYPE_p_ofMaterial,_proxy__wrap_new_Material, swig_delete_Material, swig_Material_methods, swig_Material_attributes, &swig_Material_Sf_SwigStatic, swig_Material_meta, swig_Material_bases, swig_Material_base_names }; - -static int _wrap_new_Shader__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofShader *result = 0 ; - SWIG_check_num_args("ofShader::ofShader",0,0) result = (ofShader *)new ofShader(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofShader,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Shader__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = 0 ; ofShader *result = 0 ; - SWIG_check_num_args("ofShader::ofShader",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofShader::ofShader",1,"ofShader &&"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ SWIG_fail_ptr("new_Shader",1,SWIGTYPE_p_ofShader); } - result = (ofShader *)new ofShader((ofShader &&)*arg1); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofShader,1); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_new_Shader(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_Shader__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_new_Shader__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_Shader'\n" " Possible C/C++ prototypes are:\n" - " ofShader::ofShader()\n" " ofShader::ofShader(ofShader &&)\n"); lua_error(L);return 0; } -static int _wrap_Shader_load__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; std::string arg2 ; - bool result; SWIG_check_num_args("ofShader::load",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::load",1,"ofShader *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::load",2,"std::string"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_load",1,SWIGTYPE_p_ofShader); } (&arg2)->assign(lua_tostring(L,2),lua_rawlen(L,2)); - result = (bool)(arg1)->load(arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Shader_load__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; std::string arg2 ; - std::string arg3 ; std::string arg4 ; bool result; SWIG_check_num_args("ofShader::load",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::load",1,"ofShader *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::load",2,"std::string"); - if(!lua_isstring(L,3)) SWIG_fail_arg("ofShader::load",3,"std::string"); - if(!lua_isstring(L,4)) SWIG_fail_arg("ofShader::load",4,"std::string"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_load",1,SWIGTYPE_p_ofShader); } (&arg2)->assign(lua_tostring(L,2),lua_rawlen(L,2)); - (&arg3)->assign(lua_tostring(L,3),lua_rawlen(L,3)); (&arg4)->assign(lua_tostring(L,4),lua_rawlen(L,4)); - result = (bool)(arg1)->load(arg2,arg3,arg4); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_load__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; std::string arg2 ; - std::string arg3 ; bool result; SWIG_check_num_args("ofShader::load",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::load",1,"ofShader *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::load",2,"std::string"); - if(!lua_isstring(L,3)) SWIG_fail_arg("ofShader::load",3,"std::string"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_load",1,SWIGTYPE_p_ofShader); } (&arg2)->assign(lua_tostring(L,2),lua_rawlen(L,2)); - (&arg3)->assign(lua_tostring(L,3),lua_rawlen(L,3)); result = (bool)(arg1)->load(arg2,arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_load(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { - return _wrap_Shader_load__SWIG_0(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isstring(L,argv[2]); } if (_v) { - return _wrap_Shader_load__SWIG_2(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isstring(L,argv[2]); } if (_v) { - { _v = lua_isstring(L,argv[3]); } if (_v) { return _wrap_Shader_load__SWIG_1(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Shader_load'\n" " Possible C/C++ prototypes are:\n" - " ofShader::load(std::string)\n" " ofShader::load(std::string,std::string,std::string)\n" - " ofShader::load(std::string,std::string)\n"); lua_error(L);return 0; } -static int _wrap_Shader_setGeometryInputType(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; GLenum arg2 ; - SWIG_check_num_args("ofShader::setGeometryInputType",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setGeometryInputType",1,"ofShader *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofShader::setGeometryInputType",2,"GLenum"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setGeometryInputType",1,SWIGTYPE_p_ofShader); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (GLenum)lua_tonumber(L, 2); - (arg1)->setGeometryInputType(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setGeometryOutputType(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; GLenum arg2 ; - SWIG_check_num_args("ofShader::setGeometryOutputType",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setGeometryOutputType",1,"ofShader *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofShader::setGeometryOutputType",2,"GLenum"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setGeometryOutputType",1,SWIGTYPE_p_ofShader); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (GLenum)lua_tonumber(L, 2); - (arg1)->setGeometryOutputType(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setGeometryOutputCount(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; int arg2 ; - SWIG_check_num_args("ofShader::setGeometryOutputCount",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setGeometryOutputCount",1,"ofShader *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofShader::setGeometryOutputCount",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setGeometryOutputCount",1,SWIGTYPE_p_ofShader); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->setGeometryOutputCount(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_getGeometryMaxOutputCount(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - int result; SWIG_check_num_args("ofShader::getGeometryMaxOutputCount",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::getGeometryMaxOutputCount",1,"ofShader const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_getGeometryMaxOutputCount",1,SWIGTYPE_p_ofShader); } - result = (int)((ofShader const *)arg1)->getGeometryMaxOutputCount(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_unload(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - SWIG_check_num_args("ofShader::unload",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::unload",1,"ofShader *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_unload",1,SWIGTYPE_p_ofShader); } (arg1)->unload(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Shader_isLoaded(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; bool result; - SWIG_check_num_args("ofShader::isLoaded",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::isLoaded",1,"ofShader const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_isLoaded",1,SWIGTYPE_p_ofShader); } result = (bool)((ofShader const *)arg1)->isLoaded(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_beginShader(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - SWIG_check_num_args("ofShader::begin",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::begin",1,"ofShader const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_beginShader",1,SWIGTYPE_p_ofShader); } ((ofShader const *)arg1)->begin(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_endShader(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - SWIG_check_num_args("ofShader::end",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::end",1,"ofShader const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_endShader",1,SWIGTYPE_p_ofShader); } ((ofShader const *)arg1)->end(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniformTexture__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; ofBaseHasTexture *arg3 = 0 ; int arg4 ; std::string temp2 ; - SWIG_check_num_args("ofShader::setUniformTexture",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniformTexture",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniformTexture",2,"std::string const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofShader::setUniformTexture",3,"ofBaseHasTexture const &"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofShader::setUniformTexture",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniformTexture",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofBaseHasTexture,0))){ - SWIG_fail_ptr("Shader_setUniformTexture",3,SWIGTYPE_p_ofBaseHasTexture); } arg4 = (int)lua_tonumber(L, 4); - ((ofShader const *)arg1)->setUniformTexture((std::string const &)*arg2,(ofBaseHasTexture const &)*arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniformTexture__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; ofTexture *arg3 = 0 ; int arg4 ; std::string temp2 ; - SWIG_check_num_args("ofShader::setUniformTexture",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniformTexture",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniformTexture",2,"std::string const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofShader::setUniformTexture",3,"ofTexture const &"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofShader::setUniformTexture",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniformTexture",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Shader_setUniformTexture",3,SWIGTYPE_p_ofTexture); } arg4 = (int)lua_tonumber(L, 4); - ((ofShader const *)arg1)->setUniformTexture((std::string const &)*arg2,(ofTexture const &)*arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniformTexture__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; int arg3 ; GLint arg4 ; int arg5 ; std::string temp2 ; - SWIG_check_num_args("ofShader::setUniformTexture",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniformTexture",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniformTexture",2,"std::string const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofShader::setUniformTexture",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofShader::setUniformTexture",4,"GLint"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofShader::setUniformTexture",5,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniformTexture",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; arg3 = (int)lua_tonumber(L, 3); - arg4 = (GLint)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); - ((ofShader const *)arg1)->setUniformTexture((std::string const &)*arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniformTexture(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); - if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofBaseHasTexture, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { - return _wrap_Shader_setUniformTexture__SWIG_0(L);} } } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { - return _wrap_Shader_setUniformTexture__SWIG_1(L);} } } } } if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Shader_setUniformTexture__SWIG_2(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Shader_setUniformTexture'\n" - " Possible C/C++ prototypes are:\n" - " ofShader::setUniformTexture(std::string const &,ofBaseHasTexture const &,int) const\n" - " ofShader::setUniformTexture(std::string const &,ofTexture const &,int) const\n" - " ofShader::setUniformTexture(std::string const &,int,GLint,int) const\n"); lua_error(L);return 0; } -static int _wrap_Shader_setUniform1i(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; std::string *arg2 = 0 ; - int arg3 ; std::string temp2 ; SWIG_check_num_args("ofShader::setUniform1i",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniform1i",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniform1i",2,"std::string const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofShader::setUniform1i",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniform1i",1,SWIGTYPE_p_ofShader); } temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - arg3 = (int)lua_tonumber(L, 3); ((ofShader const *)arg1)->setUniform1i((std::string const &)*arg2,arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniform2i(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; std::string *arg2 = 0 ; - int arg3 ; int arg4 ; std::string temp2 ; SWIG_check_num_args("ofShader::setUniform2i",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniform2i",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniform2i",2,"std::string const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofShader::setUniform2i",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofShader::setUniform2i",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniform2i",1,SWIGTYPE_p_ofShader); } temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - ((ofShader const *)arg1)->setUniform2i((std::string const &)*arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniform3i(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; std::string *arg2 = 0 ; - int arg3 ; int arg4 ; int arg5 ; std::string temp2 ; SWIG_check_num_args("ofShader::setUniform3i",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniform3i",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniform3i",2,"std::string const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofShader::setUniform3i",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofShader::setUniform3i",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofShader::setUniform3i",5,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniform3i",1,SWIGTYPE_p_ofShader); } temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); - ((ofShader const *)arg1)->setUniform3i((std::string const &)*arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniform4i(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; std::string *arg2 = 0 ; - int arg3 ; int arg4 ; int arg5 ; int arg6 ; std::string temp2 ; SWIG_check_num_args("ofShader::setUniform4i",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniform4i",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniform4i",2,"std::string const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofShader::setUniform4i",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofShader::setUniform4i",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofShader::setUniform4i",5,"int"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofShader::setUniform4i",6,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniform4i",1,SWIGTYPE_p_ofShader); } temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); - arg6 = (int)lua_tonumber(L, 6); ((ofShader const *)arg1)->setUniform4i((std::string const &)*arg2,arg3,arg4,arg5,arg6); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniform1f(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; std::string *arg2 = 0 ; - float arg3 ; std::string temp2 ; SWIG_check_num_args("ofShader::setUniform1f",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniform1f",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniform1f",2,"std::string const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofShader::setUniform1f",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniform1f",1,SWIGTYPE_p_ofShader); } temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - arg3 = (float)lua_tonumber(L, 3); ((ofShader const *)arg1)->setUniform1f((std::string const &)*arg2,arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniform2f__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; float arg3 ; float arg4 ; std::string temp2 ; SWIG_check_num_args("ofShader::setUniform2f",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniform2f",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniform2f",2,"std::string const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofShader::setUniform2f",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofShader::setUniform2f",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniform2f",1,SWIGTYPE_p_ofShader); } temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - ((ofShader const *)arg1)->setUniform2f((std::string const &)*arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniform3f__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; float arg3 ; float arg4 ; float arg5 ; std::string temp2 ; - SWIG_check_num_args("ofShader::setUniform3f",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniform3f",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniform3f",2,"std::string const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofShader::setUniform3f",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofShader::setUniform3f",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofShader::setUniform3f",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniform3f",1,SWIGTYPE_p_ofShader); } temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - ((ofShader const *)arg1)->setUniform3f((std::string const &)*arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniform4f__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; float arg3 ; float arg4 ; float arg5 ; float arg6 ; std::string temp2 ; - SWIG_check_num_args("ofShader::setUniform4f",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniform4f",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniform4f",2,"std::string const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofShader::setUniform4f",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofShader::setUniform4f",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofShader::setUniform4f",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofShader::setUniform4f",6,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniform4f",1,SWIGTYPE_p_ofShader); } temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); ((ofShader const *)arg1)->setUniform4f((std::string const &)*arg2,arg3,arg4,arg5,arg6); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniform2f__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; ofVec2f *arg3 = 0 ; std::string temp2 ; SWIG_check_num_args("ofShader::setUniform2f",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniform2f",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniform2f",2,"std::string const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofShader::setUniform2f",3,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniform2f",1,SWIGTYPE_p_ofShader); } temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Shader_setUniform2f",3,SWIGTYPE_p_ofVec2f); } - ((ofShader const *)arg1)->setUniform2f((std::string const &)*arg2,(ofVec2f const &)*arg3); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniform2f(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Shader_setUniform2f__SWIG_1(L);} } } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Shader_setUniform2f__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Shader_setUniform2f'\n" - " Possible C/C++ prototypes are:\n" " ofShader::setUniform2f(std::string const &,float,float) const\n" - " ofShader::setUniform2f(std::string const &,ofVec2f const &) const\n"); lua_error(L);return 0; } -static int _wrap_Shader_setUniform3f__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; ofVec3f *arg3 = 0 ; std::string temp2 ; SWIG_check_num_args("ofShader::setUniform3f",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniform3f",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniform3f",2,"std::string const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofShader::setUniform3f",3,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniform3f",1,SWIGTYPE_p_ofShader); } temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Shader_setUniform3f",3,SWIGTYPE_p_ofVec3f); } - ((ofShader const *)arg1)->setUniform3f((std::string const &)*arg2,(ofVec3f const &)*arg3); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniform3f(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Shader_setUniform3f__SWIG_1(L);} } } } if (argc == 5) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Shader_setUniform3f__SWIG_0(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Shader_setUniform3f'\n" - " Possible C/C++ prototypes are:\n" " ofShader::setUniform3f(std::string const &,float,float,float) const\n" - " ofShader::setUniform3f(std::string const &,ofVec3f const &) const\n"); lua_error(L);return 0; } -static int _wrap_Shader_setUniform4f__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; ofVec4f *arg3 = 0 ; std::string temp2 ; SWIG_check_num_args("ofShader::setUniform4f",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniform4f",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniform4f",2,"std::string const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofShader::setUniform4f",3,"ofVec4f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniform4f",1,SWIGTYPE_p_ofShader); } temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec4f,0))){ - SWIG_fail_ptr("Shader_setUniform4f",3,SWIGTYPE_p_ofVec4f); } - ((ofShader const *)arg1)->setUniform4f((std::string const &)*arg2,(ofVec4f const &)*arg3); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniform4f__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; ofFloatColor *arg3 = 0 ; std::string temp2 ; SWIG_check_num_args("ofShader::setUniform4f",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniform4f",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniform4f",2,"std::string const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofShader::setUniform4f",3,"ofFloatColor const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniform4f",1,SWIGTYPE_p_ofShader); } temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("Shader_setUniform4f",3,SWIGTYPE_p_ofColor_T_float_t); } - ((ofShader const *)arg1)->setUniform4f((std::string const &)*arg2,(ofFloatColor const &)*arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniform4f(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Shader_setUniform4f__SWIG_1(L);} } } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Shader_setUniform4f__SWIG_2(L);} } } } if (argc == 6) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { return _wrap_Shader_setUniform4f__SWIG_0(L);} } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Shader_setUniform4f'\n" - " Possible C/C++ prototypes are:\n" " ofShader::setUniform4f(std::string const &,float,float,float,float) const\n" - " ofShader::setUniform4f(std::string const &,ofVec4f const &) const\n" - " ofShader::setUniform4f(std::string const &,ofFloatColor const &) const\n"); lua_error(L);return 0; } -static int _wrap_Shader_setUniform1iv__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; int *arg3 = (int *) 0 ; int arg4 ; std::string temp2 ; - SWIG_check_num_args("ofShader::setUniform1iv",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniform1iv",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniform1iv",2,"std::string const &"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofShader::setUniform1iv",3,"int const *"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofShader::setUniform1iv",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniform1iv",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_int,0))){ SWIG_fail_ptr("Shader_setUniform1iv",3,SWIGTYPE_p_int); } - arg4 = (int)lua_tonumber(L, 4); ((ofShader const *)arg1)->setUniform1iv((std::string const &)*arg2,(int const *)arg3,arg4); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniform1iv__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; int *arg3 = (int *) 0 ; std::string temp2 ; SWIG_check_num_args("ofShader::setUniform1iv",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniform1iv",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniform1iv",2,"std::string const &"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofShader::setUniform1iv",3,"int const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniform1iv",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_int,0))){ SWIG_fail_ptr("Shader_setUniform1iv",3,SWIGTYPE_p_int); } - ((ofShader const *)arg1)->setUniform1iv((std::string const &)*arg2,(int const *)arg3); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniform1iv(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_int, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_Shader_setUniform1iv__SWIG_1(L);} } } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_int, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Shader_setUniform1iv__SWIG_0(L);} - } } } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Shader_setUniform1iv'\n" - " Possible C/C++ prototypes are:\n" " ofShader::setUniform1iv(std::string const &,int const *,int) const\n" - " ofShader::setUniform1iv(std::string const &,int const *) const\n"); lua_error(L);return 0; } -static int _wrap_Shader_setUniform2iv__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; int *arg3 = (int *) 0 ; int arg4 ; std::string temp2 ; - SWIG_check_num_args("ofShader::setUniform2iv",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniform2iv",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniform2iv",2,"std::string const &"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofShader::setUniform2iv",3,"int const *"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofShader::setUniform2iv",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniform2iv",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_int,0))){ SWIG_fail_ptr("Shader_setUniform2iv",3,SWIGTYPE_p_int); } - arg4 = (int)lua_tonumber(L, 4); ((ofShader const *)arg1)->setUniform2iv((std::string const &)*arg2,(int const *)arg3,arg4); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniform2iv__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; int *arg3 = (int *) 0 ; std::string temp2 ; SWIG_check_num_args("ofShader::setUniform2iv",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniform2iv",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniform2iv",2,"std::string const &"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofShader::setUniform2iv",3,"int const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniform2iv",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_int,0))){ SWIG_fail_ptr("Shader_setUniform2iv",3,SWIGTYPE_p_int); } - ((ofShader const *)arg1)->setUniform2iv((std::string const &)*arg2,(int const *)arg3); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniform2iv(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_int, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_Shader_setUniform2iv__SWIG_1(L);} } } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_int, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Shader_setUniform2iv__SWIG_0(L);} - } } } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Shader_setUniform2iv'\n" - " Possible C/C++ prototypes are:\n" " ofShader::setUniform2iv(std::string const &,int const *,int) const\n" - " ofShader::setUniform2iv(std::string const &,int const *) const\n"); lua_error(L);return 0; } -static int _wrap_Shader_setUniform3iv__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; int *arg3 = (int *) 0 ; int arg4 ; std::string temp2 ; - SWIG_check_num_args("ofShader::setUniform3iv",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniform3iv",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniform3iv",2,"std::string const &"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofShader::setUniform3iv",3,"int const *"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofShader::setUniform3iv",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniform3iv",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_int,0))){ SWIG_fail_ptr("Shader_setUniform3iv",3,SWIGTYPE_p_int); } - arg4 = (int)lua_tonumber(L, 4); ((ofShader const *)arg1)->setUniform3iv((std::string const &)*arg2,(int const *)arg3,arg4); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniform3iv__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; int *arg3 = (int *) 0 ; std::string temp2 ; SWIG_check_num_args("ofShader::setUniform3iv",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniform3iv",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniform3iv",2,"std::string const &"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofShader::setUniform3iv",3,"int const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniform3iv",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_int,0))){ SWIG_fail_ptr("Shader_setUniform3iv",3,SWIGTYPE_p_int); } - ((ofShader const *)arg1)->setUniform3iv((std::string const &)*arg2,(int const *)arg3); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniform3iv(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_int, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_Shader_setUniform3iv__SWIG_1(L);} } } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_int, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Shader_setUniform3iv__SWIG_0(L);} - } } } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Shader_setUniform3iv'\n" - " Possible C/C++ prototypes are:\n" " ofShader::setUniform3iv(std::string const &,int const *,int) const\n" - " ofShader::setUniform3iv(std::string const &,int const *) const\n"); lua_error(L);return 0; } -static int _wrap_Shader_setUniform4iv__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; int *arg3 = (int *) 0 ; int arg4 ; std::string temp2 ; - SWIG_check_num_args("ofShader::setUniform4iv",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniform4iv",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniform4iv",2,"std::string const &"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofShader::setUniform4iv",3,"int const *"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofShader::setUniform4iv",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniform4iv",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_int,0))){ SWIG_fail_ptr("Shader_setUniform4iv",3,SWIGTYPE_p_int); } - arg4 = (int)lua_tonumber(L, 4); ((ofShader const *)arg1)->setUniform4iv((std::string const &)*arg2,(int const *)arg3,arg4); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniform4iv__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; int *arg3 = (int *) 0 ; std::string temp2 ; SWIG_check_num_args("ofShader::setUniform4iv",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniform4iv",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniform4iv",2,"std::string const &"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofShader::setUniform4iv",3,"int const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniform4iv",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_int,0))){ SWIG_fail_ptr("Shader_setUniform4iv",3,SWIGTYPE_p_int); } - ((ofShader const *)arg1)->setUniform4iv((std::string const &)*arg2,(int const *)arg3); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniform4iv(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_int, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_Shader_setUniform4iv__SWIG_1(L);} } } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_int, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Shader_setUniform4iv__SWIG_0(L);} - } } } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Shader_setUniform4iv'\n" - " Possible C/C++ prototypes are:\n" " ofShader::setUniform4iv(std::string const &,int const *,int) const\n" - " ofShader::setUniform4iv(std::string const &,int const *) const\n"); lua_error(L);return 0; } -static int _wrap_Shader_setUniform1fv__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; float *arg3 = (float *) 0 ; int arg4 ; std::string temp2 ; - SWIG_check_num_args("ofShader::setUniform1fv",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniform1fv",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniform1fv",2,"std::string const &"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofShader::setUniform1fv",3,"float const *"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofShader::setUniform1fv",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniform1fv",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Shader_setUniform1fv",3,SWIGTYPE_p_float); } arg4 = (int)lua_tonumber(L, 4); - ((ofShader const *)arg1)->setUniform1fv((std::string const &)*arg2,(float const *)arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniform1fv__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; float *arg3 = (float *) 0 ; std::string temp2 ; SWIG_check_num_args("ofShader::setUniform1fv",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniform1fv",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniform1fv",2,"std::string const &"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofShader::setUniform1fv",3,"float const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniform1fv",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Shader_setUniform1fv",3,SWIGTYPE_p_float); } - ((ofShader const *)arg1)->setUniform1fv((std::string const &)*arg2,(float const *)arg3); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniform1fv(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Shader_setUniform1fv__SWIG_1(L);} } } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { - return _wrap_Shader_setUniform1fv__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Shader_setUniform1fv'\n" - " Possible C/C++ prototypes are:\n" " ofShader::setUniform1fv(std::string const &,float const *,int) const\n" - " ofShader::setUniform1fv(std::string const &,float const *) const\n"); lua_error(L);return 0; } -static int _wrap_Shader_setUniform2fv__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; float *arg3 = (float *) 0 ; int arg4 ; std::string temp2 ; - SWIG_check_num_args("ofShader::setUniform2fv",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniform2fv",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniform2fv",2,"std::string const &"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofShader::setUniform2fv",3,"float const *"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofShader::setUniform2fv",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniform2fv",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Shader_setUniform2fv",3,SWIGTYPE_p_float); } arg4 = (int)lua_tonumber(L, 4); - ((ofShader const *)arg1)->setUniform2fv((std::string const &)*arg2,(float const *)arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniform2fv__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; float *arg3 = (float *) 0 ; std::string temp2 ; SWIG_check_num_args("ofShader::setUniform2fv",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniform2fv",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniform2fv",2,"std::string const &"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofShader::setUniform2fv",3,"float const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniform2fv",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Shader_setUniform2fv",3,SWIGTYPE_p_float); } - ((ofShader const *)arg1)->setUniform2fv((std::string const &)*arg2,(float const *)arg3); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniform2fv(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Shader_setUniform2fv__SWIG_1(L);} } } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { - return _wrap_Shader_setUniform2fv__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Shader_setUniform2fv'\n" - " Possible C/C++ prototypes are:\n" " ofShader::setUniform2fv(std::string const &,float const *,int) const\n" - " ofShader::setUniform2fv(std::string const &,float const *) const\n"); lua_error(L);return 0; } -static int _wrap_Shader_setUniform3fv__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; float *arg3 = (float *) 0 ; int arg4 ; std::string temp2 ; - SWIG_check_num_args("ofShader::setUniform3fv",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniform3fv",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniform3fv",2,"std::string const &"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofShader::setUniform3fv",3,"float const *"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofShader::setUniform3fv",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniform3fv",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Shader_setUniform3fv",3,SWIGTYPE_p_float); } arg4 = (int)lua_tonumber(L, 4); - ((ofShader const *)arg1)->setUniform3fv((std::string const &)*arg2,(float const *)arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniform3fv__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; float *arg3 = (float *) 0 ; std::string temp2 ; SWIG_check_num_args("ofShader::setUniform3fv",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniform3fv",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniform3fv",2,"std::string const &"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofShader::setUniform3fv",3,"float const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniform3fv",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Shader_setUniform3fv",3,SWIGTYPE_p_float); } - ((ofShader const *)arg1)->setUniform3fv((std::string const &)*arg2,(float const *)arg3); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniform3fv(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Shader_setUniform3fv__SWIG_1(L);} } } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { - return _wrap_Shader_setUniform3fv__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Shader_setUniform3fv'\n" - " Possible C/C++ prototypes are:\n" " ofShader::setUniform3fv(std::string const &,float const *,int) const\n" - " ofShader::setUniform3fv(std::string const &,float const *) const\n"); lua_error(L);return 0; } -static int _wrap_Shader_setUniform4fv__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; float *arg3 = (float *) 0 ; int arg4 ; std::string temp2 ; - SWIG_check_num_args("ofShader::setUniform4fv",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniform4fv",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniform4fv",2,"std::string const &"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofShader::setUniform4fv",3,"float const *"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofShader::setUniform4fv",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniform4fv",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Shader_setUniform4fv",3,SWIGTYPE_p_float); } arg4 = (int)lua_tonumber(L, 4); - ((ofShader const *)arg1)->setUniform4fv((std::string const &)*arg2,(float const *)arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniform4fv__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; float *arg3 = (float *) 0 ; std::string temp2 ; SWIG_check_num_args("ofShader::setUniform4fv",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniform4fv",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniform4fv",2,"std::string const &"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofShader::setUniform4fv",3,"float const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniform4fv",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Shader_setUniform4fv",3,SWIGTYPE_p_float); } - ((ofShader const *)arg1)->setUniform4fv((std::string const &)*arg2,(float const *)arg3); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniform4fv(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Shader_setUniform4fv__SWIG_1(L);} } } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { - return _wrap_Shader_setUniform4fv__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Shader_setUniform4fv'\n" - " Possible C/C++ prototypes are:\n" " ofShader::setUniform4fv(std::string const &,float const *,int) const\n" - " ofShader::setUniform4fv(std::string const &,float const *) const\n"); lua_error(L);return 0; } -static int _wrap_Shader_setUniforms(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - ofParameterGroup *arg2 = 0 ; SWIG_check_num_args("ofShader::setUniforms",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniforms",1,"ofShader const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofShader::setUniforms",2,"ofParameterGroup const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniforms",1,SWIGTYPE_p_ofShader); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofParameterGroup,0))){ - SWIG_fail_ptr("Shader_setUniforms",2,SWIGTYPE_p_ofParameterGroup); } - ((ofShader const *)arg1)->setUniforms((ofParameterGroup const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Shader_setUniformMatrix3f__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; ofMatrix3x3 *arg3 = 0 ; int arg4 ; std::string temp2 ; - SWIG_check_num_args("ofShader::setUniformMatrix3f",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniformMatrix3f",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniformMatrix3f",2,"std::string const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofShader::setUniformMatrix3f",3,"ofMatrix3x3 const &"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofShader::setUniformMatrix3f",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniformMatrix3f",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Shader_setUniformMatrix3f",3,SWIGTYPE_p_ofMatrix3x3); } arg4 = (int)lua_tonumber(L, 4); - ((ofShader const *)arg1)->setUniformMatrix3f((std::string const &)*arg2,(ofMatrix3x3 const &)*arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniformMatrix3f__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; ofMatrix3x3 *arg3 = 0 ; std::string temp2 ; SWIG_check_num_args("ofShader::setUniformMatrix3f",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniformMatrix3f",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniformMatrix3f",2,"std::string const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofShader::setUniformMatrix3f",3,"ofMatrix3x3 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniformMatrix3f",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Shader_setUniformMatrix3f",3,SWIGTYPE_p_ofMatrix3x3); } - ((ofShader const *)arg1)->setUniformMatrix3f((std::string const &)*arg2,(ofMatrix3x3 const &)*arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniformMatrix3f(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofMatrix3x3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Shader_setUniformMatrix3f__SWIG_1(L);} } } } if (argc == 4) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofMatrix3x3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { - return _wrap_Shader_setUniformMatrix3f__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Shader_setUniformMatrix3f'\n" - " Possible C/C++ prototypes are:\n" " ofShader::setUniformMatrix3f(std::string const &,ofMatrix3x3 const &,int) const\n" - " ofShader::setUniformMatrix3f(std::string const &,ofMatrix3x3 const &) const\n"); lua_error(L);return 0; } -static int _wrap_Shader_setUniformMatrix4f__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; ofMatrix4x4 *arg3 = 0 ; int arg4 ; std::string temp2 ; - SWIG_check_num_args("ofShader::setUniformMatrix4f",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniformMatrix4f",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniformMatrix4f",2,"std::string const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofShader::setUniformMatrix4f",3,"ofMatrix4x4 const &"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofShader::setUniformMatrix4f",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniformMatrix4f",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Shader_setUniformMatrix4f",3,SWIGTYPE_p_ofMatrix4x4); } arg4 = (int)lua_tonumber(L, 4); - ((ofShader const *)arg1)->setUniformMatrix4f((std::string const &)*arg2,(ofMatrix4x4 const &)*arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniformMatrix4f__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; ofMatrix4x4 *arg3 = 0 ; std::string temp2 ; SWIG_check_num_args("ofShader::setUniformMatrix4f",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniformMatrix4f",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniformMatrix4f",2,"std::string const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofShader::setUniformMatrix4f",3,"ofMatrix4x4 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniformMatrix4f",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Shader_setUniformMatrix4f",3,SWIGTYPE_p_ofMatrix4x4); } - ((ofShader const *)arg1)->setUniformMatrix4f((std::string const &)*arg2,(ofMatrix4x4 const &)*arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniformMatrix4f(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Shader_setUniformMatrix4f__SWIG_1(L);} } } } if (argc == 4) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { - return _wrap_Shader_setUniformMatrix4f__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Shader_setUniformMatrix4f'\n" - " Possible C/C++ prototypes are:\n" " ofShader::setUniformMatrix4f(std::string const &,ofMatrix4x4 const &,int) const\n" - " ofShader::setUniformMatrix4f(std::string const &,ofMatrix4x4 const &) const\n"); lua_error(L);return 0; } -static int _wrap_Shader_getUniformLocation(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; std::string temp2 ; GLint result; SWIG_check_num_args("ofShader::getUniformLocation",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::getUniformLocation",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::getUniformLocation",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_getUniformLocation",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = (GLint)((ofShader const *)arg1)->getUniformLocation((std::string const &)*arg2); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_getAttributeLocation(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; std::string temp2 ; GLint result; SWIG_check_num_args("ofShader::getAttributeLocation",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::getAttributeLocation",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::getAttributeLocation",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_getAttributeLocation",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = (GLint)((ofShader const *)arg1)->getAttributeLocation((std::string const &)*arg2); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setAttribute1f(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; GLint arg2 ; - float arg3 ; SWIG_check_num_args("ofShader::setAttribute1f",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setAttribute1f",1,"ofShader const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofShader::setAttribute1f",2,"GLint"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofShader::setAttribute1f",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setAttribute1f",1,SWIGTYPE_p_ofShader); } arg2 = (GLint)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); ((ofShader const *)arg1)->setAttribute1f(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setAttribute2f(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; GLint arg2 ; - float arg3 ; float arg4 ; SWIG_check_num_args("ofShader::setAttribute2f",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setAttribute2f",1,"ofShader const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofShader::setAttribute2f",2,"GLint"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofShader::setAttribute2f",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofShader::setAttribute2f",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setAttribute2f",1,SWIGTYPE_p_ofShader); } arg2 = (GLint)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); ((ofShader const *)arg1)->setAttribute2f(arg2,arg3,arg4); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setAttribute3f(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; GLint arg2 ; - float arg3 ; float arg4 ; float arg5 ; SWIG_check_num_args("ofShader::setAttribute3f",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setAttribute3f",1,"ofShader const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofShader::setAttribute3f",2,"GLint"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofShader::setAttribute3f",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofShader::setAttribute3f",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofShader::setAttribute3f",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setAttribute3f",1,SWIGTYPE_p_ofShader); } arg2 = (GLint)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - ((ofShader const *)arg1)->setAttribute3f(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Shader_setAttribute4f(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; GLint arg2 ; - float arg3 ; float arg4 ; float arg5 ; float arg6 ; SWIG_check_num_args("ofShader::setAttribute4f",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setAttribute4f",1,"ofShader const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofShader::setAttribute4f",2,"GLint"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofShader::setAttribute4f",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofShader::setAttribute4f",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofShader::setAttribute4f",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofShader::setAttribute4f",6,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setAttribute4f",1,SWIGTYPE_p_ofShader); } arg2 = (GLint)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); ((ofShader const *)arg1)->setAttribute4f(arg2,arg3,arg4,arg5,arg6); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setAttribute1fv__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; float *arg3 = (float *) 0 ; GLsizei arg4 ; std::string temp2 ; GLsizei *argp4 ; - SWIG_check_num_args("ofShader::setAttribute1fv",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setAttribute1fv",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setAttribute1fv",2,"std::string const &"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofShader::setAttribute1fv",3,"float const *"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofShader::setAttribute1fv",4,"GLsizei"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setAttribute1fv",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Shader_setAttribute1fv",3,SWIGTYPE_p_float); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&argp4,SWIGTYPE_p_GLsizei,0))){ - SWIG_fail_ptr("Shader_setAttribute1fv",4,SWIGTYPE_p_GLsizei); } arg4 = *argp4; - ((ofShader const *)arg1)->setAttribute1fv((std::string const &)*arg2,(float const *)arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setAttribute1fv__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; float *arg3 = (float *) 0 ; std::string temp2 ; SWIG_check_num_args("ofShader::setAttribute1fv",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setAttribute1fv",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setAttribute1fv",2,"std::string const &"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofShader::setAttribute1fv",3,"float const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setAttribute1fv",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Shader_setAttribute1fv",3,SWIGTYPE_p_float); } - ((ofShader const *)arg1)->setAttribute1fv((std::string const &)*arg2,(float const *)arg3); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setAttribute1fv(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Shader_setAttribute1fv__SWIG_1(L);} } } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_GLsizei, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Shader_setAttribute1fv__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Shader_setAttribute1fv'\n" - " Possible C/C++ prototypes are:\n" " ofShader::setAttribute1fv(std::string const &,float const *,GLsizei) const\n" - " ofShader::setAttribute1fv(std::string const &,float const *) const\n"); lua_error(L);return 0; } -static int _wrap_Shader_setAttribute2fv__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; float *arg3 = (float *) 0 ; GLsizei arg4 ; std::string temp2 ; GLsizei *argp4 ; - SWIG_check_num_args("ofShader::setAttribute2fv",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setAttribute2fv",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setAttribute2fv",2,"std::string const &"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofShader::setAttribute2fv",3,"float const *"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofShader::setAttribute2fv",4,"GLsizei"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setAttribute2fv",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Shader_setAttribute2fv",3,SWIGTYPE_p_float); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&argp4,SWIGTYPE_p_GLsizei,0))){ - SWIG_fail_ptr("Shader_setAttribute2fv",4,SWIGTYPE_p_GLsizei); } arg4 = *argp4; - ((ofShader const *)arg1)->setAttribute2fv((std::string const &)*arg2,(float const *)arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setAttribute2fv__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; float *arg3 = (float *) 0 ; std::string temp2 ; SWIG_check_num_args("ofShader::setAttribute2fv",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setAttribute2fv",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setAttribute2fv",2,"std::string const &"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofShader::setAttribute2fv",3,"float const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setAttribute2fv",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Shader_setAttribute2fv",3,SWIGTYPE_p_float); } - ((ofShader const *)arg1)->setAttribute2fv((std::string const &)*arg2,(float const *)arg3); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setAttribute2fv(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Shader_setAttribute2fv__SWIG_1(L);} } } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_GLsizei, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Shader_setAttribute2fv__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Shader_setAttribute2fv'\n" - " Possible C/C++ prototypes are:\n" " ofShader::setAttribute2fv(std::string const &,float const *,GLsizei) const\n" - " ofShader::setAttribute2fv(std::string const &,float const *) const\n"); lua_error(L);return 0; } -static int _wrap_Shader_setAttribute3fv__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; float *arg3 = (float *) 0 ; GLsizei arg4 ; std::string temp2 ; GLsizei *argp4 ; - SWIG_check_num_args("ofShader::setAttribute3fv",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setAttribute3fv",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setAttribute3fv",2,"std::string const &"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofShader::setAttribute3fv",3,"float const *"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofShader::setAttribute3fv",4,"GLsizei"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setAttribute3fv",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Shader_setAttribute3fv",3,SWIGTYPE_p_float); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&argp4,SWIGTYPE_p_GLsizei,0))){ - SWIG_fail_ptr("Shader_setAttribute3fv",4,SWIGTYPE_p_GLsizei); } arg4 = *argp4; - ((ofShader const *)arg1)->setAttribute3fv((std::string const &)*arg2,(float const *)arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setAttribute3fv__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; float *arg3 = (float *) 0 ; std::string temp2 ; SWIG_check_num_args("ofShader::setAttribute3fv",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setAttribute3fv",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setAttribute3fv",2,"std::string const &"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofShader::setAttribute3fv",3,"float const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setAttribute3fv",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Shader_setAttribute3fv",3,SWIGTYPE_p_float); } - ((ofShader const *)arg1)->setAttribute3fv((std::string const &)*arg2,(float const *)arg3); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setAttribute3fv(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Shader_setAttribute3fv__SWIG_1(L);} } } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_GLsizei, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Shader_setAttribute3fv__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Shader_setAttribute3fv'\n" - " Possible C/C++ prototypes are:\n" " ofShader::setAttribute3fv(std::string const &,float const *,GLsizei) const\n" - " ofShader::setAttribute3fv(std::string const &,float const *) const\n"); lua_error(L);return 0; } -static int _wrap_Shader_setAttribute4fv__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; float *arg3 = (float *) 0 ; GLsizei arg4 ; std::string temp2 ; GLsizei *argp4 ; - SWIG_check_num_args("ofShader::setAttribute4fv",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setAttribute4fv",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setAttribute4fv",2,"std::string const &"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofShader::setAttribute4fv",3,"float const *"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofShader::setAttribute4fv",4,"GLsizei"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setAttribute4fv",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Shader_setAttribute4fv",3,SWIGTYPE_p_float); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&argp4,SWIGTYPE_p_GLsizei,0))){ - SWIG_fail_ptr("Shader_setAttribute4fv",4,SWIGTYPE_p_GLsizei); } arg4 = *argp4; - ((ofShader const *)arg1)->setAttribute4fv((std::string const &)*arg2,(float const *)arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setAttribute4fv__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; float *arg3 = (float *) 0 ; std::string temp2 ; SWIG_check_num_args("ofShader::setAttribute4fv",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setAttribute4fv",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setAttribute4fv",2,"std::string const &"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofShader::setAttribute4fv",3,"float const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setAttribute4fv",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Shader_setAttribute4fv",3,SWIGTYPE_p_float); } - ((ofShader const *)arg1)->setAttribute4fv((std::string const &)*arg2,(float const *)arg3); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setAttribute4fv(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Shader_setAttribute4fv__SWIG_1(L);} } } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_GLsizei, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Shader_setAttribute4fv__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Shader_setAttribute4fv'\n" - " Possible C/C++ prototypes are:\n" " ofShader::setAttribute4fv(std::string const &,float const *,GLsizei) const\n" - " ofShader::setAttribute4fv(std::string const &,float const *) const\n"); lua_error(L);return 0; } -static int _wrap_Shader_bindAttribute(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; GLuint arg2 ; - std::string *arg3 = 0 ; std::string temp3 ; SWIG_check_num_args("ofShader::bindAttribute",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::bindAttribute",1,"ofShader const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofShader::bindAttribute",2,"GLuint"); - if(!lua_isstring(L,3)) SWIG_fail_arg("ofShader::bindAttribute",3,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_bindAttribute",1,SWIGTYPE_p_ofShader); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (GLuint)lua_tonumber(L, 2); - temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3; - ((ofShader const *)arg1)->bindAttribute(arg2,(std::string const &)*arg3); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Shader_printActiveUniforms(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - SWIG_check_num_args("ofShader::printActiveUniforms",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::printActiveUniforms",1,"ofShader const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_printActiveUniforms",1,SWIGTYPE_p_ofShader); } ((ofShader const *)arg1)->printActiveUniforms(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_printActiveAttributes(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - SWIG_check_num_args("ofShader::printActiveAttributes",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::printActiveAttributes",1,"ofShader const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_printActiveAttributes",1,SWIGTYPE_p_ofShader); } ((ofShader const *)arg1)->printActiveAttributes(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setupShaderFromSource__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - GLenum arg2 ; std::string arg3 ; std::string arg4 ; bool result; SWIG_check_num_args("ofShader::setupShaderFromSource",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setupShaderFromSource",1,"ofShader *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofShader::setupShaderFromSource",2,"GLenum"); - if(!lua_isstring(L,3)) SWIG_fail_arg("ofShader::setupShaderFromSource",3,"std::string"); - if(!lua_isstring(L,4)) SWIG_fail_arg("ofShader::setupShaderFromSource",4,"std::string"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setupShaderFromSource",1,SWIGTYPE_p_ofShader); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (GLenum)lua_tonumber(L, 2); - (&arg3)->assign(lua_tostring(L,3),lua_rawlen(L,3)); (&arg4)->assign(lua_tostring(L,4),lua_rawlen(L,4)); - result = (bool)(arg1)->setupShaderFromSource(arg2,arg3,arg4); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setupShaderFromSource__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - GLenum arg2 ; std::string arg3 ; bool result; SWIG_check_num_args("ofShader::setupShaderFromSource",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setupShaderFromSource",1,"ofShader *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofShader::setupShaderFromSource",2,"GLenum"); - if(!lua_isstring(L,3)) SWIG_fail_arg("ofShader::setupShaderFromSource",3,"std::string"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setupShaderFromSource",1,SWIGTYPE_p_ofShader); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (GLenum)lua_tonumber(L, 2); - (&arg3)->assign(lua_tostring(L,3),lua_rawlen(L,3)); result = (bool)(arg1)->setupShaderFromSource(arg2,arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setupShaderFromSource(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isstring(L,argv[2]); } if (_v) { - return _wrap_Shader_setupShaderFromSource__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isstring(L,argv[2]); } if (_v) { - { _v = lua_isstring(L,argv[3]); } if (_v) { return _wrap_Shader_setupShaderFromSource__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Shader_setupShaderFromSource'\n" - " Possible C/C++ prototypes are:\n" " ofShader::setupShaderFromSource(GLenum,std::string,std::string)\n" - " ofShader::setupShaderFromSource(GLenum,std::string)\n"); lua_error(L);return 0; } -static int _wrap_Shader_setupShaderFromFile(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; GLenum arg2 ; - std::string arg3 ; bool result; SWIG_check_num_args("ofShader::setupShaderFromFile",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setupShaderFromFile",1,"ofShader *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofShader::setupShaderFromFile",2,"GLenum"); - if(!lua_isstring(L,3)) SWIG_fail_arg("ofShader::setupShaderFromFile",3,"std::string"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setupShaderFromFile",1,SWIGTYPE_p_ofShader); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (GLenum)lua_tonumber(L, 2); - (&arg3)->assign(lua_tostring(L,3),lua_rawlen(L,3)); result = (bool)(arg1)->setupShaderFromFile(arg2,arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_linkProgram(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; bool result; - SWIG_check_num_args("ofShader::linkProgram",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::linkProgram",1,"ofShader *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_linkProgram",1,SWIGTYPE_p_ofShader); } result = (bool)(arg1)->linkProgram(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_bindDefaults(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; bool result; - SWIG_check_num_args("ofShader::bindDefaults",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::bindDefaults",1,"ofShader const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_bindDefaults",1,SWIGTYPE_p_ofShader); } result = (bool)((ofShader const *)arg1)->bindDefaults(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_getProgram(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; GLuint result; - SWIG_check_num_args("ofShader::getProgram",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::getProgram",1,"ofShader const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_getProgram",1,SWIGTYPE_p_ofShader); } result = (GLuint)((ofShader const *)arg1)->getProgram(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_getShader(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; GLenum arg2 ; - GLuint result; SWIG_check_num_args("ofShader::getShader",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::getShader",1,"ofShader const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofShader::getShader",2,"GLenum"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_getShader",1,SWIGTYPE_p_ofShader); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (GLenum)lua_tonumber(L, 2); - result = (GLuint)((ofShader const *)arg1)->getShader(arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader___eq(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; ofShader *arg2 = 0 ; - bool result; SWIG_check_num_args("ofShader::operator ==",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::operator ==",1,"ofShader const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofShader::operator ==",2,"ofShader const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader___eq",1,SWIGTYPE_p_ofShader); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader___eq",2,SWIGTYPE_p_ofShader); } - result = (bool)((ofShader const *)arg1)->operator ==((ofShader const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_getShaderSource(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; GLenum arg2 ; - std::string result; SWIG_check_num_args("ofShader::getShaderSource",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::getShaderSource",1,"ofShader const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofShader::getShaderSource",2,"GLenum"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_getShaderSource",1,SWIGTYPE_p_ofShader); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (GLenum)lua_tonumber(L, 2); - result = ((ofShader const *)arg1)->getShaderSource(arg2); lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_Shader(void *obj) { -ofShader *arg1 = (ofShader *) obj; -delete_ofShader(arg1); -} -static int _proxy__wrap_new_Shader(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_Shader); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_Shader_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_Shader_methods[]= { - { "load", _wrap_Shader_load}, - { "setGeometryInputType", _wrap_Shader_setGeometryInputType}, - { "setGeometryOutputType", _wrap_Shader_setGeometryOutputType}, - { "setGeometryOutputCount", _wrap_Shader_setGeometryOutputCount}, - { "getGeometryMaxOutputCount", _wrap_Shader_getGeometryMaxOutputCount}, - { "unload", _wrap_Shader_unload}, - { "isLoaded", _wrap_Shader_isLoaded}, - { "beginShader", _wrap_Shader_beginShader}, - { "endShader", _wrap_Shader_endShader}, - { "setUniformTexture", _wrap_Shader_setUniformTexture}, - { "setUniform1i", _wrap_Shader_setUniform1i}, - { "setUniform2i", _wrap_Shader_setUniform2i}, - { "setUniform3i", _wrap_Shader_setUniform3i}, - { "setUniform4i", _wrap_Shader_setUniform4i}, - { "setUniform1f", _wrap_Shader_setUniform1f}, - { "setUniform2f", _wrap_Shader_setUniform2f}, - { "setUniform3f", _wrap_Shader_setUniform3f}, - { "setUniform4f", _wrap_Shader_setUniform4f}, - { "setUniform1iv", _wrap_Shader_setUniform1iv}, - { "setUniform2iv", _wrap_Shader_setUniform2iv}, - { "setUniform3iv", _wrap_Shader_setUniform3iv}, - { "setUniform4iv", _wrap_Shader_setUniform4iv}, - { "setUniform1fv", _wrap_Shader_setUniform1fv}, - { "setUniform2fv", _wrap_Shader_setUniform2fv}, - { "setUniform3fv", _wrap_Shader_setUniform3fv}, - { "setUniform4fv", _wrap_Shader_setUniform4fv}, - { "setUniforms", _wrap_Shader_setUniforms}, - { "setUniformMatrix3f", _wrap_Shader_setUniformMatrix3f}, - { "setUniformMatrix4f", _wrap_Shader_setUniformMatrix4f}, - { "getUniformLocation", _wrap_Shader_getUniformLocation}, - { "getAttributeLocation", _wrap_Shader_getAttributeLocation}, - { "setAttribute1f", _wrap_Shader_setAttribute1f}, - { "setAttribute2f", _wrap_Shader_setAttribute2f}, - { "setAttribute3f", _wrap_Shader_setAttribute3f}, - { "setAttribute4f", _wrap_Shader_setAttribute4f}, - { "setAttribute1fv", _wrap_Shader_setAttribute1fv}, - { "setAttribute2fv", _wrap_Shader_setAttribute2fv}, - { "setAttribute3fv", _wrap_Shader_setAttribute3fv}, - { "setAttribute4fv", _wrap_Shader_setAttribute4fv}, - { "bindAttribute", _wrap_Shader_bindAttribute}, - { "printActiveUniforms", _wrap_Shader_printActiveUniforms}, - { "printActiveAttributes", _wrap_Shader_printActiveAttributes}, - { "setupShaderFromSource", _wrap_Shader_setupShaderFromSource}, - { "setupShaderFromFile", _wrap_Shader_setupShaderFromFile}, - { "linkProgram", _wrap_Shader_linkProgram}, - { "bindDefaults", _wrap_Shader_bindDefaults}, - { "getProgram", _wrap_Shader_getProgram}, - { "getShader", _wrap_Shader_getShader}, - { "__eq", _wrap_Shader___eq}, - { "getShaderSource", _wrap_Shader_getShaderSource}, - {0,0} -}; -static swig_lua_method swig_Shader_meta[] = { - { "__eq", _wrap_Shader___eq}, - {0,0} -}; - -static swig_lua_attribute swig_Shader_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_Shader_Sf_SwigStatic_constants[]= { - {SWIG_LUA_CONSTTAB_INT("POSITION_ATTRIBUTE", ofShader::POSITION_ATTRIBUTE)}, - {SWIG_LUA_CONSTTAB_INT("COLOR_ATTRIBUTE", ofShader::COLOR_ATTRIBUTE)}, - {SWIG_LUA_CONSTTAB_INT("NORMAL_ATTRIBUTE", ofShader::NORMAL_ATTRIBUTE)}, - {SWIG_LUA_CONSTTAB_INT("TEXCOORD_ATTRIBUTE", ofShader::TEXCOORD_ATTRIBUTE)}, - {SWIG_LUA_CONSTTAB_INT("INDEX_ATTRIBUTE", ofShader::INDEX_ATTRIBUTE)}, - {0,0,0,0,0,0} -}; -static swig_lua_method swig_Shader_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_Shader_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_Shader_Sf_SwigStatic = { - "Shader", - swig_Shader_Sf_SwigStatic_methods, - swig_Shader_Sf_SwigStatic_attributes, - swig_Shader_Sf_SwigStatic_constants, - swig_Shader_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_Shader_bases[] = {0}; -static const char *swig_Shader_base_names[] = {0}; -static swig_lua_class _wrap_class_Shader = { "Shader", "Shader", &SWIGTYPE_p_ofShader,_proxy__wrap_new_Shader, swig_delete_Shader, swig_Shader_methods, swig_Shader_attributes, &swig_Shader_Sf_SwigStatic, swig_Shader_meta, swig_Shader_bases, swig_Shader_base_names }; - -static int _wrap_new_Vbo__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVbo *result = 0 ; SWIG_check_num_args("ofVbo::ofVbo",0,0) - result = (ofVbo *)new ofVbo(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVbo,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_new_Vbo__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = 0 ; ofVbo *result = 0 ; - SWIG_check_num_args("ofVbo::ofVbo",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofVbo::ofVbo",1,"ofVbo const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ SWIG_fail_ptr("new_Vbo",1,SWIGTYPE_p_ofVbo); } - result = (ofVbo *)new ofVbo((ofVbo const &)*arg1); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVbo,1); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_new_Vbo(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_Vbo__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_new_Vbo__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_Vbo'\n" " Possible C/C++ prototypes are:\n" - " ofVbo::ofVbo()\n" " ofVbo::ofVbo(ofVbo const &)\n"); lua_error(L);return 0; } -static int _wrap_Vbo_setMesh__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; ofMesh *arg2 = 0 ; int arg3 ; - SWIG_check_num_args("ofVbo::setMesh",3,3) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::setMesh",1,"ofVbo *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVbo::setMesh",2,"ofMesh const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::setMesh",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ SWIG_fail_ptr("Vbo_setMesh",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Vbo_setMesh",2,SWIGTYPE_p_ofMesh); } - arg3 = (int)lua_tonumber(L, 3); (arg1)->setMesh((ofMesh const &)*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_setMesh__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; ofMesh *arg2 = 0 ; int arg3 ; - bool arg4 ; bool arg5 ; bool arg6 ; SWIG_check_num_args("ofVbo::setMesh",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::setMesh",1,"ofVbo *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVbo::setMesh",2,"ofMesh const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::setMesh",3,"int"); - if(!lua_isboolean(L,4)) SWIG_fail_arg("ofVbo::setMesh",4,"bool"); - if(!lua_isboolean(L,5)) SWIG_fail_arg("ofVbo::setMesh",5,"bool"); - if(!lua_isboolean(L,6)) SWIG_fail_arg("ofVbo::setMesh",6,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ SWIG_fail_ptr("Vbo_setMesh",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Vbo_setMesh",2,SWIGTYPE_p_ofMesh); } - arg3 = (int)lua_tonumber(L, 3); arg4 = (lua_toboolean(L, 4)!=0); arg5 = (lua_toboolean(L, 5)!=0); - arg6 = (lua_toboolean(L, 6)!=0); (arg1)->setMesh((ofMesh const &)*arg2,arg3,arg4,arg5,arg6); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_setMesh(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Vbo_setMesh__SWIG_0(L);} } } - } if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isboolean(L,argv[3]); } - if (_v) { { _v = lua_isboolean(L,argv[4]); } if (_v) { { _v = lua_isboolean(L,argv[5]); } if (_v) { - return _wrap_Vbo_setMesh__SWIG_1(L);} } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_setMesh'\n" " Possible C/C++ prototypes are:\n" - " ofVbo::setMesh(ofMesh const &,int)\n" " ofVbo::setMesh(ofMesh const &,int,bool,bool,bool)\n"); lua_error(L);return 0; } -static int _wrap_Vbo_setVertexData__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - ofVec3f *arg2 = (ofVec3f *) 0 ; int arg3 ; int arg4 ; SWIG_check_num_args("ofVbo::setVertexData",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::setVertexData",1,"ofVbo *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofVbo::setVertexData",2,"ofVec3f const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::setVertexData",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVbo::setVertexData",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_setVertexData",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vbo_setVertexData",2,SWIGTYPE_p_ofVec3f); } arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - (arg1)->setVertexData((ofVec3f const *)arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vbo_setVertexData__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - ofVec2f *arg2 = (ofVec2f *) 0 ; int arg3 ; int arg4 ; SWIG_check_num_args("ofVbo::setVertexData",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::setVertexData",1,"ofVbo *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofVbo::setVertexData",2,"ofVec2f const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::setVertexData",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVbo::setVertexData",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_setVertexData",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vbo_setVertexData",2,SWIGTYPE_p_ofVec2f); } arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - (arg1)->setVertexData((ofVec2f const *)arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vbo_setColorData__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - ofFloatColor *arg2 = (ofFloatColor *) 0 ; int arg3 ; int arg4 ; SWIG_check_num_args("ofVbo::setColorData",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::setColorData",1,"ofVbo *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofVbo::setColorData",2,"ofFloatColor const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::setColorData",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVbo::setColorData",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ SWIG_fail_ptr("Vbo_setColorData",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("Vbo_setColorData",2,SWIGTYPE_p_ofColor_T_float_t); } arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); (arg1)->setColorData((ofFloatColor const *)arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_setNormalData__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - ofVec3f *arg2 = (ofVec3f *) 0 ; int arg3 ; int arg4 ; SWIG_check_num_args("ofVbo::setNormalData",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::setNormalData",1,"ofVbo *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofVbo::setNormalData",2,"ofVec3f const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::setNormalData",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVbo::setNormalData",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_setNormalData",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vbo_setNormalData",2,SWIGTYPE_p_ofVec3f); } arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - (arg1)->setNormalData((ofVec3f const *)arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vbo_setTexCoordData__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - ofVec2f *arg2 = (ofVec2f *) 0 ; int arg3 ; int arg4 ; SWIG_check_num_args("ofVbo::setTexCoordData",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::setTexCoordData",1,"ofVbo *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofVbo::setTexCoordData",2,"ofVec2f const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::setTexCoordData",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVbo::setTexCoordData",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_setTexCoordData",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vbo_setTexCoordData",2,SWIGTYPE_p_ofVec2f); } arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); (arg1)->setTexCoordData((ofVec2f const *)arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_setIndexData(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - ofIndexType *arg2 = (ofIndexType *) 0 ; int arg3 ; int arg4 ; SWIG_check_num_args("ofVbo::setIndexData",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::setIndexData",1,"ofVbo *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofVbo::setIndexData",2,"ofIndexType const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::setIndexData",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVbo::setIndexData",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ SWIG_fail_ptr("Vbo_setIndexData",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_unsigned_short,0))){ - SWIG_fail_ptr("Vbo_setIndexData",2,SWIGTYPE_p_unsigned_short); } arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); (arg1)->setIndexData((ofIndexType const *)arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_setVertexData__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - float *arg2 = (float *) 0 ; int arg3 ; int arg4 ; int arg5 ; int arg6 ; SWIG_check_num_args("ofVbo::setVertexData",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::setVertexData",1,"ofVbo *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofVbo::setVertexData",2,"float const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::setVertexData",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVbo::setVertexData",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofVbo::setVertexData",5,"int"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofVbo::setVertexData",6,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_setVertexData",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Vbo_setVertexData",2,SWIGTYPE_p_float); } arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - arg5 = (int)lua_tonumber(L, 5); arg6 = (int)lua_tonumber(L, 6); - (arg1)->setVertexData((float const *)arg2,arg3,arg4,arg5,arg6); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vbo_setVertexData__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - float *arg2 = (float *) 0 ; int arg3 ; int arg4 ; int arg5 ; SWIG_check_num_args("ofVbo::setVertexData",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::setVertexData",1,"ofVbo *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofVbo::setVertexData",2,"float const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::setVertexData",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVbo::setVertexData",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofVbo::setVertexData",5,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_setVertexData",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Vbo_setVertexData",2,SWIGTYPE_p_float); } arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - arg5 = (int)lua_tonumber(L, 5); (arg1)->setVertexData((float const *)arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_setVertexData(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); - if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Vbo_setVertexData__SWIG_0(L);} } } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Vbo_setVertexData__SWIG_1(L);} } } } } if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_Vbo_setVertexData__SWIG_3(L);} } } } } } - if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { - return _wrap_Vbo_setVertexData__SWIG_2(L);} } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_setVertexData'\n" " Possible C/C++ prototypes are:\n" - " ofVbo::setVertexData(ofVec3f const *,int,int)\n" " ofVbo::setVertexData(ofVec2f const *,int,int)\n" - " ofVbo::setVertexData(float const *,int,int,int,int)\n" " ofVbo::setVertexData(float const *,int,int,int)\n"); - lua_error(L);return 0; } -static int _wrap_Vbo_setColorData__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - float *arg2 = (float *) 0 ; int arg3 ; int arg4 ; int arg5 ; SWIG_check_num_args("ofVbo::setColorData",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::setColorData",1,"ofVbo *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofVbo::setColorData",2,"float const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::setColorData",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVbo::setColorData",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofVbo::setColorData",5,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ SWIG_fail_ptr("Vbo_setColorData",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Vbo_setColorData",2,SWIGTYPE_p_float); } arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - arg5 = (int)lua_tonumber(L, 5); (arg1)->setColorData((float const *)arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_setColorData__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - float *arg2 = (float *) 0 ; int arg3 ; int arg4 ; SWIG_check_num_args("ofVbo::setColorData",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::setColorData",1,"ofVbo *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofVbo::setColorData",2,"float const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::setColorData",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVbo::setColorData",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ SWIG_fail_ptr("Vbo_setColorData",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Vbo_setColorData",2,SWIGTYPE_p_float); } arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - (arg1)->setColorData((float const *)arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_setColorData(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 4) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Vbo_setColorData__SWIG_0(L);} } } } } if (argc == 4) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { - return _wrap_Vbo_setColorData__SWIG_2(L);} } } } } if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_Vbo_setColorData__SWIG_1(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_setColorData'\n" " Possible C/C++ prototypes are:\n" - " ofVbo::setColorData(ofFloatColor const *,int,int)\n" " ofVbo::setColorData(float const *,int,int,int)\n" - " ofVbo::setColorData(float const *,int,int)\n"); lua_error(L);return 0; } -static int _wrap_Vbo_setNormalData__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - float *arg2 = (float *) 0 ; int arg3 ; int arg4 ; int arg5 ; SWIG_check_num_args("ofVbo::setNormalData",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::setNormalData",1,"ofVbo *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofVbo::setNormalData",2,"float const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::setNormalData",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVbo::setNormalData",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofVbo::setNormalData",5,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_setNormalData",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Vbo_setNormalData",2,SWIGTYPE_p_float); } arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - arg5 = (int)lua_tonumber(L, 5); (arg1)->setNormalData((float const *)arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_setNormalData__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - float *arg2 = (float *) 0 ; int arg3 ; int arg4 ; SWIG_check_num_args("ofVbo::setNormalData",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::setNormalData",1,"ofVbo *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofVbo::setNormalData",2,"float const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::setNormalData",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVbo::setNormalData",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_setNormalData",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Vbo_setNormalData",2,SWIGTYPE_p_float); } arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - (arg1)->setNormalData((float const *)arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_setNormalData(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 4) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Vbo_setNormalData__SWIG_0(L);} } } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { - return _wrap_Vbo_setNormalData__SWIG_2(L);} } } } } if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_Vbo_setNormalData__SWIG_1(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_setNormalData'\n" " Possible C/C++ prototypes are:\n" - " ofVbo::setNormalData(ofVec3f const *,int,int)\n" " ofVbo::setNormalData(float const *,int,int,int)\n" - " ofVbo::setNormalData(float const *,int,int)\n"); lua_error(L);return 0; } -static int _wrap_Vbo_setTexCoordData__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - float *arg2 = (float *) 0 ; int arg3 ; int arg4 ; int arg5 ; SWIG_check_num_args("ofVbo::setTexCoordData",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::setTexCoordData",1,"ofVbo *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofVbo::setTexCoordData",2,"float const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::setTexCoordData",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVbo::setTexCoordData",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofVbo::setTexCoordData",5,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_setTexCoordData",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Vbo_setTexCoordData",2,SWIGTYPE_p_float); } arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - arg5 = (int)lua_tonumber(L, 5); (arg1)->setTexCoordData((float const *)arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_setTexCoordData__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - float *arg2 = (float *) 0 ; int arg3 ; int arg4 ; SWIG_check_num_args("ofVbo::setTexCoordData",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::setTexCoordData",1,"ofVbo *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofVbo::setTexCoordData",2,"float const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::setTexCoordData",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVbo::setTexCoordData",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_setTexCoordData",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Vbo_setTexCoordData",2,SWIGTYPE_p_float); } arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - (arg1)->setTexCoordData((float const *)arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vbo_setTexCoordData(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); - if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Vbo_setTexCoordData__SWIG_0(L);} } } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { - return _wrap_Vbo_setTexCoordData__SWIG_2(L);} } } } } if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_Vbo_setTexCoordData__SWIG_1(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_setTexCoordData'\n" - " Possible C/C++ prototypes are:\n" " ofVbo::setTexCoordData(ofVec2f const *,int,int)\n" - " ofVbo::setTexCoordData(float const *,int,int,int)\n" " ofVbo::setTexCoordData(float const *,int,int)\n"); - lua_error(L);return 0; } -static int _wrap_Vbo_setAttributeData__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; int arg2 ; - float *arg3 = (float *) 0 ; int arg4 ; int arg5 ; int arg6 ; int arg7 ; SWIG_check_num_args("ofVbo::setAttributeData",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::setAttributeData",1,"ofVbo *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVbo::setAttributeData",2,"int"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofVbo::setAttributeData",3,"float const *"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVbo::setAttributeData",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofVbo::setAttributeData",5,"int"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofVbo::setAttributeData",6,"int"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofVbo::setAttributeData",7,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_setAttributeData",1,SWIGTYPE_p_ofVbo); } arg2 = (int)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Vbo_setAttributeData",3,SWIGTYPE_p_float); } arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); - arg6 = (int)lua_tonumber(L, 6); arg7 = (int)lua_tonumber(L, 7); - (arg1)->setAttributeData(arg2,(float const *)arg3,arg4,arg5,arg6,arg7); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vbo_setAttributeData__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; int arg2 ; - float *arg3 = (float *) 0 ; int arg4 ; int arg5 ; int arg6 ; SWIG_check_num_args("ofVbo::setAttributeData",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::setAttributeData",1,"ofVbo *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVbo::setAttributeData",2,"int"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofVbo::setAttributeData",3,"float const *"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVbo::setAttributeData",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofVbo::setAttributeData",5,"int"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofVbo::setAttributeData",6,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_setAttributeData",1,SWIGTYPE_p_ofVbo); } arg2 = (int)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Vbo_setAttributeData",3,SWIGTYPE_p_float); } arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); - arg6 = (int)lua_tonumber(L, 6); (arg1)->setAttributeData(arg2,(float const *)arg3,arg4,arg5,arg6); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_setAttributeData(lua_State* L) { int argc; int argv[8]={ 1,2,3,4,5,6,7,8} ; argc = lua_gettop(L); - if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } - if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { return _wrap_Vbo_setAttributeData__SWIG_1(L);} } } } } } - } if (argc == 7) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } - if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { - return _wrap_Vbo_setAttributeData__SWIG_0(L);} } } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_setAttributeData'\n" - " Possible C/C++ prototypes are:\n" " ofVbo::setAttributeData(int,float const *,int,int,int,int)\n" - " ofVbo::setAttributeData(int,float const *,int,int,int)\n"); lua_error(L);return 0; } -static int _wrap_Vbo_setVertexBuffer__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - ofBufferObject *arg2 = 0 ; int arg3 ; int arg4 ; int arg5 ; SWIG_check_num_args("ofVbo::setVertexBuffer",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::setVertexBuffer",1,"ofVbo *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVbo::setVertexBuffer",2,"ofBufferObject &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::setVertexBuffer",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVbo::setVertexBuffer",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofVbo::setVertexBuffer",5,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_setVertexBuffer",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBufferObject,0))){ - SWIG_fail_ptr("Vbo_setVertexBuffer",2,SWIGTYPE_p_ofBufferObject); } arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); (arg1)->setVertexBuffer(*arg2,arg3,arg4,arg5); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_setVertexBuffer__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - ofBufferObject *arg2 = 0 ; int arg3 ; int arg4 ; SWIG_check_num_args("ofVbo::setVertexBuffer",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::setVertexBuffer",1,"ofVbo *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVbo::setVertexBuffer",2,"ofBufferObject &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::setVertexBuffer",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVbo::setVertexBuffer",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_setVertexBuffer",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBufferObject,0))){ - SWIG_fail_ptr("Vbo_setVertexBuffer",2,SWIGTYPE_p_ofBufferObject); } arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); (arg1)->setVertexBuffer(*arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_setVertexBuffer(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); - if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBufferObject, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Vbo_setVertexBuffer__SWIG_1(L);} } } } } if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBufferObject, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_Vbo_setVertexBuffer__SWIG_0(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_setVertexBuffer'\n" - " Possible C/C++ prototypes are:\n" " ofVbo::setVertexBuffer(ofBufferObject &,int,int,int)\n" - " ofVbo::setVertexBuffer(ofBufferObject &,int,int)\n"); lua_error(L);return 0; } -static int _wrap_Vbo_setColorBuffer__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - ofBufferObject *arg2 = 0 ; int arg3 ; int arg4 ; SWIG_check_num_args("ofVbo::setColorBuffer",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::setColorBuffer",1,"ofVbo *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVbo::setColorBuffer",2,"ofBufferObject &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::setColorBuffer",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVbo::setColorBuffer",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_setColorBuffer",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBufferObject,0))){ - SWIG_fail_ptr("Vbo_setColorBuffer",2,SWIGTYPE_p_ofBufferObject); } arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); (arg1)->setColorBuffer(*arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vbo_setColorBuffer__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - ofBufferObject *arg2 = 0 ; int arg3 ; SWIG_check_num_args("ofVbo::setColorBuffer",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::setColorBuffer",1,"ofVbo *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVbo::setColorBuffer",2,"ofBufferObject &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::setColorBuffer",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_setColorBuffer",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBufferObject,0))){ - SWIG_fail_ptr("Vbo_setColorBuffer",2,SWIGTYPE_p_ofBufferObject); } arg3 = (int)lua_tonumber(L, 3); - (arg1)->setColorBuffer(*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_setColorBuffer(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBufferObject, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Vbo_setColorBuffer__SWIG_1(L);} - } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBufferObject, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Vbo_setColorBuffer__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_setColorBuffer'\n" " Possible C/C++ prototypes are:\n" - " ofVbo::setColorBuffer(ofBufferObject &,int,int)\n" " ofVbo::setColorBuffer(ofBufferObject &,int)\n"); - lua_error(L);return 0; } -static int _wrap_Vbo_setNormalBuffer__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - ofBufferObject *arg2 = 0 ; int arg3 ; int arg4 ; SWIG_check_num_args("ofVbo::setNormalBuffer",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::setNormalBuffer",1,"ofVbo *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVbo::setNormalBuffer",2,"ofBufferObject &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::setNormalBuffer",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVbo::setNormalBuffer",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_setNormalBuffer",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBufferObject,0))){ - SWIG_fail_ptr("Vbo_setNormalBuffer",2,SWIGTYPE_p_ofBufferObject); } arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); (arg1)->setNormalBuffer(*arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_setNormalBuffer__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - ofBufferObject *arg2 = 0 ; int arg3 ; SWIG_check_num_args("ofVbo::setNormalBuffer",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::setNormalBuffer",1,"ofVbo *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVbo::setNormalBuffer",2,"ofBufferObject &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::setNormalBuffer",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_setNormalBuffer",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBufferObject,0))){ - SWIG_fail_ptr("Vbo_setNormalBuffer",2,SWIGTYPE_p_ofBufferObject); } arg3 = (int)lua_tonumber(L, 3); - (arg1)->setNormalBuffer(*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_setNormalBuffer(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBufferObject, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Vbo_setNormalBuffer__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBufferObject, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Vbo_setNormalBuffer__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_setNormalBuffer'\n" - " Possible C/C++ prototypes are:\n" " ofVbo::setNormalBuffer(ofBufferObject &,int,int)\n" - " ofVbo::setNormalBuffer(ofBufferObject &,int)\n"); lua_error(L);return 0; } -static int _wrap_Vbo_setTexCoordBuffer__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - ofBufferObject *arg2 = 0 ; int arg3 ; int arg4 ; SWIG_check_num_args("ofVbo::setTexCoordBuffer",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::setTexCoordBuffer",1,"ofVbo *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVbo::setTexCoordBuffer",2,"ofBufferObject &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::setTexCoordBuffer",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVbo::setTexCoordBuffer",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_setTexCoordBuffer",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBufferObject,0))){ - SWIG_fail_ptr("Vbo_setTexCoordBuffer",2,SWIGTYPE_p_ofBufferObject); } arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); (arg1)->setTexCoordBuffer(*arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_setTexCoordBuffer__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - ofBufferObject *arg2 = 0 ; int arg3 ; SWIG_check_num_args("ofVbo::setTexCoordBuffer",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::setTexCoordBuffer",1,"ofVbo *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVbo::setTexCoordBuffer",2,"ofBufferObject &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::setTexCoordBuffer",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_setTexCoordBuffer",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBufferObject,0))){ - SWIG_fail_ptr("Vbo_setTexCoordBuffer",2,SWIGTYPE_p_ofBufferObject); } arg3 = (int)lua_tonumber(L, 3); - (arg1)->setTexCoordBuffer(*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_setTexCoordBuffer(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBufferObject, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Vbo_setTexCoordBuffer__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBufferObject, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Vbo_setTexCoordBuffer__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_setTexCoordBuffer'\n" - " Possible C/C++ prototypes are:\n" " ofVbo::setTexCoordBuffer(ofBufferObject &,int,int)\n" - " ofVbo::setTexCoordBuffer(ofBufferObject &,int)\n"); lua_error(L);return 0; } -static int _wrap_Vbo_setIndexBuffer(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; ofBufferObject *arg2 = 0 ; - SWIG_check_num_args("ofVbo::setIndexBuffer",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::setIndexBuffer",1,"ofVbo *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVbo::setIndexBuffer",2,"ofBufferObject &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_setIndexBuffer",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBufferObject,0))){ - SWIG_fail_ptr("Vbo_setIndexBuffer",2,SWIGTYPE_p_ofBufferObject); } (arg1)->setIndexBuffer(*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_setAttributeBuffer__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; int arg2 ; - ofBufferObject *arg3 = 0 ; int arg4 ; int arg5 ; int arg6 ; SWIG_check_num_args("ofVbo::setAttributeBuffer",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::setAttributeBuffer",1,"ofVbo *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVbo::setAttributeBuffer",2,"int"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofVbo::setAttributeBuffer",3,"ofBufferObject &"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVbo::setAttributeBuffer",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofVbo::setAttributeBuffer",5,"int"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofVbo::setAttributeBuffer",6,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_setAttributeBuffer",1,SWIGTYPE_p_ofVbo); } arg2 = (int)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofBufferObject,0))){ - SWIG_fail_ptr("Vbo_setAttributeBuffer",3,SWIGTYPE_p_ofBufferObject); } arg4 = (int)lua_tonumber(L, 4); - arg5 = (int)lua_tonumber(L, 5); arg6 = (int)lua_tonumber(L, 6); (arg1)->setAttributeBuffer(arg2,*arg3,arg4,arg5,arg6); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_setAttributeBuffer__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; int arg2 ; - ofBufferObject *arg3 = 0 ; int arg4 ; int arg5 ; SWIG_check_num_args("ofVbo::setAttributeBuffer",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::setAttributeBuffer",1,"ofVbo *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVbo::setAttributeBuffer",2,"int"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofVbo::setAttributeBuffer",3,"ofBufferObject &"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVbo::setAttributeBuffer",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofVbo::setAttributeBuffer",5,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_setAttributeBuffer",1,SWIGTYPE_p_ofVbo); } arg2 = (int)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofBufferObject,0))){ - SWIG_fail_ptr("Vbo_setAttributeBuffer",3,SWIGTYPE_p_ofBufferObject); } arg4 = (int)lua_tonumber(L, 4); - arg5 = (int)lua_tonumber(L, 5); (arg1)->setAttributeBuffer(arg2,*arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_setAttributeBuffer(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofBufferObject, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_Vbo_setAttributeBuffer__SWIG_1(L);} } } } } } - if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofBufferObject, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { - return _wrap_Vbo_setAttributeBuffer__SWIG_0(L);} } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_setAttributeBuffer'\n" - " Possible C/C++ prototypes are:\n" " ofVbo::setAttributeBuffer(int,ofBufferObject &,int,int,int)\n" - " ofVbo::setAttributeBuffer(int,ofBufferObject &,int,int)\n"); lua_error(L);return 0; } -static int _wrap_Vbo_getVertexBuffer__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - ofBufferObject *result = 0 ; SWIG_check_num_args("ofVbo::getVertexBuffer",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::getVertexBuffer",1,"ofVbo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_getVertexBuffer",1,SWIGTYPE_p_ofVbo); } result = (ofBufferObject *) &(arg1)->getVertexBuffer(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofBufferObject,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vbo_getColorBuffer__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - ofBufferObject *result = 0 ; SWIG_check_num_args("ofVbo::getColorBuffer",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::getColorBuffer",1,"ofVbo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_getColorBuffer",1,SWIGTYPE_p_ofVbo); } result = (ofBufferObject *) &(arg1)->getColorBuffer(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofBufferObject,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vbo_getNormalBuffer__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - ofBufferObject *result = 0 ; SWIG_check_num_args("ofVbo::getNormalBuffer",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::getNormalBuffer",1,"ofVbo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_getNormalBuffer",1,SWIGTYPE_p_ofVbo); } result = (ofBufferObject *) &(arg1)->getNormalBuffer(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofBufferObject,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vbo_getTexCoordBuffer__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - ofBufferObject *result = 0 ; SWIG_check_num_args("ofVbo::getTexCoordBuffer",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::getTexCoordBuffer",1,"ofVbo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_getTexCoordBuffer",1,SWIGTYPE_p_ofVbo); } result = (ofBufferObject *) &(arg1)->getTexCoordBuffer(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofBufferObject,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vbo_getIndexBuffer__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - ofBufferObject *result = 0 ; SWIG_check_num_args("ofVbo::getIndexBuffer",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::getIndexBuffer",1,"ofVbo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_getIndexBuffer",1,SWIGTYPE_p_ofVbo); } result = (ofBufferObject *) &(arg1)->getIndexBuffer(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofBufferObject,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vbo_getAttributeBuffer__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; int arg2 ; - ofBufferObject *result = 0 ; SWIG_check_num_args("ofVbo::getAttributeBuffer",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::getAttributeBuffer",1,"ofVbo *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVbo::getAttributeBuffer",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_getAttributeBuffer",1,SWIGTYPE_p_ofVbo); } arg2 = (int)lua_tonumber(L, 2); - result = (ofBufferObject *) &(arg1)->getAttributeBuffer(arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofBufferObject,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vbo_getVertexBuffer__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - ofBufferObject *result = 0 ; SWIG_check_num_args("ofVbo::getVertexBuffer",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::getVertexBuffer",1,"ofVbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_getVertexBuffer",1,SWIGTYPE_p_ofVbo); } - result = (ofBufferObject *) &((ofVbo const *)arg1)->getVertexBuffer(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofBufferObject,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vbo_getVertexBuffer(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Vbo_getVertexBuffer__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vbo_getVertexBuffer__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_getVertexBuffer'\n" - " Possible C/C++ prototypes are:\n" " ofVbo::getVertexBuffer()\n" " ofVbo::getVertexBuffer() const\n"); - lua_error(L);return 0; } -static int _wrap_Vbo_getColorBuffer__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - ofBufferObject *result = 0 ; SWIG_check_num_args("ofVbo::getColorBuffer",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::getColorBuffer",1,"ofVbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_getColorBuffer",1,SWIGTYPE_p_ofVbo); } - result = (ofBufferObject *) &((ofVbo const *)arg1)->getColorBuffer(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofBufferObject,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vbo_getColorBuffer(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Vbo_getColorBuffer__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vbo_getColorBuffer__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_getColorBuffer'\n" " Possible C/C++ prototypes are:\n" - " ofVbo::getColorBuffer()\n" " ofVbo::getColorBuffer() const\n"); lua_error(L);return 0; } -static int _wrap_Vbo_getNormalBuffer__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - ofBufferObject *result = 0 ; SWIG_check_num_args("ofVbo::getNormalBuffer",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::getNormalBuffer",1,"ofVbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_getNormalBuffer",1,SWIGTYPE_p_ofVbo); } - result = (ofBufferObject *) &((ofVbo const *)arg1)->getNormalBuffer(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofBufferObject,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vbo_getNormalBuffer(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Vbo_getNormalBuffer__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vbo_getNormalBuffer__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_getNormalBuffer'\n" - " Possible C/C++ prototypes are:\n" " ofVbo::getNormalBuffer()\n" " ofVbo::getNormalBuffer() const\n"); - lua_error(L);return 0; } -static int _wrap_Vbo_getTexCoordBuffer__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - ofBufferObject *result = 0 ; SWIG_check_num_args("ofVbo::getTexCoordBuffer",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::getTexCoordBuffer",1,"ofVbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_getTexCoordBuffer",1,SWIGTYPE_p_ofVbo); } - result = (ofBufferObject *) &((ofVbo const *)arg1)->getTexCoordBuffer(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofBufferObject,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vbo_getTexCoordBuffer(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Vbo_getTexCoordBuffer__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vbo_getTexCoordBuffer__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_getTexCoordBuffer'\n" - " Possible C/C++ prototypes are:\n" " ofVbo::getTexCoordBuffer()\n" " ofVbo::getTexCoordBuffer() const\n"); - lua_error(L);return 0; } -static int _wrap_Vbo_getIndexBuffer__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - ofBufferObject *result = 0 ; SWIG_check_num_args("ofVbo::getIndexBuffer",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::getIndexBuffer",1,"ofVbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_getIndexBuffer",1,SWIGTYPE_p_ofVbo); } - result = (ofBufferObject *) &((ofVbo const *)arg1)->getIndexBuffer(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofBufferObject,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vbo_getIndexBuffer(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Vbo_getIndexBuffer__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vbo_getIndexBuffer__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_getIndexBuffer'\n" " Possible C/C++ prototypes are:\n" - " ofVbo::getIndexBuffer()\n" " ofVbo::getIndexBuffer() const\n"); lua_error(L);return 0; } -static int _wrap_Vbo_getAttributeBuffer__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; int arg2 ; - ofBufferObject *result = 0 ; SWIG_check_num_args("ofVbo::getAttributeBuffer",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::getAttributeBuffer",1,"ofVbo const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVbo::getAttributeBuffer",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_getAttributeBuffer",1,SWIGTYPE_p_ofVbo); } arg2 = (int)lua_tonumber(L, 2); - result = (ofBufferObject *) &((ofVbo const *)arg1)->getAttributeBuffer(arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofBufferObject,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vbo_getAttributeBuffer(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Vbo_getAttributeBuffer__SWIG_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Vbo_getAttributeBuffer__SWIG_1(L);} } - } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_getAttributeBuffer'\n" - " Possible C/C++ prototypes are:\n" " ofVbo::getAttributeBuffer(int)\n" " ofVbo::getAttributeBuffer(int) const\n"); - lua_error(L);return 0; } -static int _wrap_Vbo_updateMesh(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; ofMesh *arg2 = 0 ; - SWIG_check_num_args("ofVbo::updateMesh",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::updateMesh",1,"ofVbo *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVbo::updateMesh",2,"ofMesh const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ SWIG_fail_ptr("Vbo_updateMesh",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Vbo_updateMesh",2,SWIGTYPE_p_ofMesh); } - (arg1)->updateMesh((ofMesh const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_updateVertexData__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - ofVec3f *arg2 = (ofVec3f *) 0 ; int arg3 ; SWIG_check_num_args("ofVbo::updateVertexData",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::updateVertexData",1,"ofVbo *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofVbo::updateVertexData",2,"ofVec3f const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::updateVertexData",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_updateVertexData",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vbo_updateVertexData",2,SWIGTYPE_p_ofVec3f); } arg3 = (int)lua_tonumber(L, 3); - (arg1)->updateVertexData((ofVec3f const *)arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_updateVertexData__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - ofVec2f *arg2 = (ofVec2f *) 0 ; int arg3 ; SWIG_check_num_args("ofVbo::updateVertexData",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::updateVertexData",1,"ofVbo *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofVbo::updateVertexData",2,"ofVec2f const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::updateVertexData",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_updateVertexData",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vbo_updateVertexData",2,SWIGTYPE_p_ofVec2f); } arg3 = (int)lua_tonumber(L, 3); - (arg1)->updateVertexData((ofVec2f const *)arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_updateColorData__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - ofFloatColor *arg2 = (ofFloatColor *) 0 ; int arg3 ; SWIG_check_num_args("ofVbo::updateColorData",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::updateColorData",1,"ofVbo *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofVbo::updateColorData",2,"ofFloatColor const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::updateColorData",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_updateColorData",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("Vbo_updateColorData",2,SWIGTYPE_p_ofColor_T_float_t); } arg3 = (int)lua_tonumber(L, 3); - (arg1)->updateColorData((ofFloatColor const *)arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vbo_updateNormalData__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - ofVec3f *arg2 = (ofVec3f *) 0 ; int arg3 ; SWIG_check_num_args("ofVbo::updateNormalData",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::updateNormalData",1,"ofVbo *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofVbo::updateNormalData",2,"ofVec3f const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::updateNormalData",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_updateNormalData",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vbo_updateNormalData",2,SWIGTYPE_p_ofVec3f); } arg3 = (int)lua_tonumber(L, 3); - (arg1)->updateNormalData((ofVec3f const *)arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_updateTexCoordData__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - ofVec2f *arg2 = (ofVec2f *) 0 ; int arg3 ; SWIG_check_num_args("ofVbo::updateTexCoordData",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::updateTexCoordData",1,"ofVbo *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofVbo::updateTexCoordData",2,"ofVec2f const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::updateTexCoordData",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_updateTexCoordData",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vbo_updateTexCoordData",2,SWIGTYPE_p_ofVec2f); } arg3 = (int)lua_tonumber(L, 3); - (arg1)->updateTexCoordData((ofVec2f const *)arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vbo_updateIndexData(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - ofIndexType *arg2 = (ofIndexType *) 0 ; int arg3 ; SWIG_check_num_args("ofVbo::updateIndexData",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::updateIndexData",1,"ofVbo *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofVbo::updateIndexData",2,"ofIndexType const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::updateIndexData",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_updateIndexData",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_unsigned_short,0))){ - SWIG_fail_ptr("Vbo_updateIndexData",2,SWIGTYPE_p_unsigned_short); } arg3 = (int)lua_tonumber(L, 3); - (arg1)->updateIndexData((ofIndexType const *)arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vbo_updateVertexData__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - float *arg2 = (float *) 0 ; int arg3 ; SWIG_check_num_args("ofVbo::updateVertexData",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::updateVertexData",1,"ofVbo *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofVbo::updateVertexData",2,"float const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::updateVertexData",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_updateVertexData",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Vbo_updateVertexData",2,SWIGTYPE_p_float); } arg3 = (int)lua_tonumber(L, 3); - (arg1)->updateVertexData((float const *)arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_updateVertexData(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Vbo_updateVertexData__SWIG_0(L);} } } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Vbo_updateVertexData__SWIG_1(L);} } } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Vbo_updateVertexData__SWIG_2(L);} } - } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_updateVertexData'\n" - " Possible C/C++ prototypes are:\n" " ofVbo::updateVertexData(ofVec3f const *,int)\n" - " ofVbo::updateVertexData(ofVec2f const *,int)\n" " ofVbo::updateVertexData(float const *,int)\n"); - lua_error(L);return 0; } -static int _wrap_Vbo_updateColorData__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - float *arg2 = (float *) 0 ; int arg3 ; SWIG_check_num_args("ofVbo::updateColorData",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::updateColorData",1,"ofVbo *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofVbo::updateColorData",2,"float const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::updateColorData",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_updateColorData",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Vbo_updateColorData",2,SWIGTYPE_p_float); } arg3 = (int)lua_tonumber(L, 3); - (arg1)->updateColorData((float const *)arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_updateColorData(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Vbo_updateColorData__SWIG_0(L);} } } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Vbo_updateColorData__SWIG_1(L);} } - } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_updateColorData'\n" - " Possible C/C++ prototypes are:\n" " ofVbo::updateColorData(ofFloatColor const *,int)\n" - " ofVbo::updateColorData(float const *,int)\n"); lua_error(L);return 0; } -static int _wrap_Vbo_updateNormalData__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - float *arg2 = (float *) 0 ; int arg3 ; SWIG_check_num_args("ofVbo::updateNormalData",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::updateNormalData",1,"ofVbo *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofVbo::updateNormalData",2,"float const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::updateNormalData",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_updateNormalData",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Vbo_updateNormalData",2,SWIGTYPE_p_float); } arg3 = (int)lua_tonumber(L, 3); - (arg1)->updateNormalData((float const *)arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_updateNormalData(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Vbo_updateNormalData__SWIG_0(L);} } } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Vbo_updateNormalData__SWIG_1(L);} } - } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_updateNormalData'\n" - " Possible C/C++ prototypes are:\n" " ofVbo::updateNormalData(ofVec3f const *,int)\n" - " ofVbo::updateNormalData(float const *,int)\n"); lua_error(L);return 0; } -static int _wrap_Vbo_updateTexCoordData__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - float *arg2 = (float *) 0 ; int arg3 ; SWIG_check_num_args("ofVbo::updateTexCoordData",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::updateTexCoordData",1,"ofVbo *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofVbo::updateTexCoordData",2,"float const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::updateTexCoordData",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_updateTexCoordData",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Vbo_updateTexCoordData",2,SWIGTYPE_p_float); } arg3 = (int)lua_tonumber(L, 3); - (arg1)->updateTexCoordData((float const *)arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_updateTexCoordData(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Vbo_updateTexCoordData__SWIG_0(L);} } } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Vbo_updateTexCoordData__SWIG_1(L);} - } } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_updateTexCoordData'\n" - " Possible C/C++ prototypes are:\n" " ofVbo::updateTexCoordData(ofVec2f const *,int)\n" - " ofVbo::updateTexCoordData(float const *,int)\n"); lua_error(L);return 0; } -static int _wrap_Vbo_updateAttributeData(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; int arg2 ; - float *arg3 = (float *) 0 ; int arg4 ; SWIG_check_num_args("ofVbo::updateAttributeData",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::updateAttributeData",1,"ofVbo *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVbo::updateAttributeData",2,"int"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofVbo::updateAttributeData",3,"float const *"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVbo::updateAttributeData",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_updateAttributeData",1,SWIGTYPE_p_ofVbo); } arg2 = (int)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Vbo_updateAttributeData",3,SWIGTYPE_p_float); } arg4 = (int)lua_tonumber(L, 4); - (arg1)->updateAttributeData(arg2,(float const *)arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vbo_enableColors(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - SWIG_check_num_args("ofVbo::enableColors",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::enableColors",1,"ofVbo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ SWIG_fail_ptr("Vbo_enableColors",1,SWIGTYPE_p_ofVbo); } - (arg1)->enableColors(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_enableNormals(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - SWIG_check_num_args("ofVbo::enableNormals",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::enableNormals",1,"ofVbo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_enableNormals",1,SWIGTYPE_p_ofVbo); } (arg1)->enableNormals(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_enableTexCoords(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - SWIG_check_num_args("ofVbo::enableTexCoords",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::enableTexCoords",1,"ofVbo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_enableTexCoords",1,SWIGTYPE_p_ofVbo); } (arg1)->enableTexCoords(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_enableIndices(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - SWIG_check_num_args("ofVbo::enableIndices",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::enableIndices",1,"ofVbo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_enableIndices",1,SWIGTYPE_p_ofVbo); } (arg1)->enableIndices(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_disableColors(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - SWIG_check_num_args("ofVbo::disableColors",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::disableColors",1,"ofVbo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_disableColors",1,SWIGTYPE_p_ofVbo); } (arg1)->disableColors(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_disableNormals(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - SWIG_check_num_args("ofVbo::disableNormals",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::disableNormals",1,"ofVbo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_disableNormals",1,SWIGTYPE_p_ofVbo); } (arg1)->disableNormals(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_disableTexCoords(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - SWIG_check_num_args("ofVbo::disableTexCoords",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::disableTexCoords",1,"ofVbo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_disableTexCoords",1,SWIGTYPE_p_ofVbo); } (arg1)->disableTexCoords(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_disableIndices(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - SWIG_check_num_args("ofVbo::disableIndices",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::disableIndices",1,"ofVbo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_disableIndices",1,SWIGTYPE_p_ofVbo); } (arg1)->disableIndices(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_getVaoId(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; GLuint result; - SWIG_check_num_args("ofVbo::getVaoId",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::getVaoId",1,"ofVbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ SWIG_fail_ptr("Vbo_getVaoId",1,SWIGTYPE_p_ofVbo); } - result = (GLuint)((ofVbo const *)arg1)->getVaoId(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_getVertId(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; GLuint result; - SWIG_check_num_args("ofVbo::getVertId",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::getVertId",1,"ofVbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ SWIG_fail_ptr("Vbo_getVertId",1,SWIGTYPE_p_ofVbo); } - result = (GLuint)((ofVbo const *)arg1)->getVertId(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_getColorId(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; GLuint result; - SWIG_check_num_args("ofVbo::getColorId",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::getColorId",1,"ofVbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ SWIG_fail_ptr("Vbo_getColorId",1,SWIGTYPE_p_ofVbo); } - result = (GLuint)((ofVbo const *)arg1)->getColorId(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_getNormalId(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; GLuint result; - SWIG_check_num_args("ofVbo::getNormalId",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::getNormalId",1,"ofVbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ SWIG_fail_ptr("Vbo_getNormalId",1,SWIGTYPE_p_ofVbo); } - result = (GLuint)((ofVbo const *)arg1)->getNormalId(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_getTexCoordId(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; GLuint result; - SWIG_check_num_args("ofVbo::getTexCoordId",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::getTexCoordId",1,"ofVbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_getTexCoordId",1,SWIGTYPE_p_ofVbo); } result = (GLuint)((ofVbo const *)arg1)->getTexCoordId(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_getIndexId(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; GLuint result; - SWIG_check_num_args("ofVbo::getIndexId",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::getIndexId",1,"ofVbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ SWIG_fail_ptr("Vbo_getIndexId",1,SWIGTYPE_p_ofVbo); } - result = (GLuint)((ofVbo const *)arg1)->getIndexId(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_getAttributeId(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; int arg2 ; GLuint result; - SWIG_check_num_args("ofVbo::getAttributeId",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::getAttributeId",1,"ofVbo const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVbo::getAttributeId",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_getAttributeId",1,SWIGTYPE_p_ofVbo); } arg2 = (int)lua_tonumber(L, 2); - result = (GLuint)((ofVbo const *)arg1)->getAttributeId(arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_getIsAllocated(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; bool result; - SWIG_check_num_args("ofVbo::getIsAllocated",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::getIsAllocated",1,"ofVbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_getIsAllocated",1,SWIGTYPE_p_ofVbo); } result = (bool)((ofVbo const *)arg1)->getIsAllocated(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_getUsingVerts(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; bool result; - SWIG_check_num_args("ofVbo::getUsingVerts",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::getUsingVerts",1,"ofVbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_getUsingVerts",1,SWIGTYPE_p_ofVbo); } result = (bool)((ofVbo const *)arg1)->getUsingVerts(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_getUsingColors(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; bool result; - SWIG_check_num_args("ofVbo::getUsingColors",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::getUsingColors",1,"ofVbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_getUsingColors",1,SWIGTYPE_p_ofVbo); } result = (bool)((ofVbo const *)arg1)->getUsingColors(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_getUsingNormals(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; bool result; - SWIG_check_num_args("ofVbo::getUsingNormals",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::getUsingNormals",1,"ofVbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_getUsingNormals",1,SWIGTYPE_p_ofVbo); } result = (bool)((ofVbo const *)arg1)->getUsingNormals(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_getUsingTexCoords(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; bool result; - SWIG_check_num_args("ofVbo::getUsingTexCoords",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::getUsingTexCoords",1,"ofVbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_getUsingTexCoords",1,SWIGTYPE_p_ofVbo); } result = (bool)((ofVbo const *)arg1)->getUsingTexCoords(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_getUsingIndices(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; bool result; - SWIG_check_num_args("ofVbo::getUsingIndices",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::getUsingIndices",1,"ofVbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_getUsingIndices",1,SWIGTYPE_p_ofVbo); } result = (bool)((ofVbo const *)arg1)->getUsingIndices(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_draw(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; int arg2 ; int arg3 ; int arg4 ; - SWIG_check_num_args("ofVbo::draw",4,4) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::draw",1,"ofVbo const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVbo::draw",2,"int"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::draw",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVbo::draw",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ SWIG_fail_ptr("Vbo_draw",1,SWIGTYPE_p_ofVbo); } - arg2 = (int)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - ((ofVbo const *)arg1)->draw(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_drawElements__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; int arg2 ; int arg3 ; - int arg4 ; SWIG_check_num_args("ofVbo::drawElements",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::drawElements",1,"ofVbo const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVbo::drawElements",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::drawElements",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVbo::drawElements",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ SWIG_fail_ptr("Vbo_drawElements",1,SWIGTYPE_p_ofVbo); } - arg2 = (int)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - ((ofVbo const *)arg1)->drawElements(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_drawElements__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; int arg2 ; int arg3 ; - SWIG_check_num_args("ofVbo::drawElements",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::drawElements",1,"ofVbo const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVbo::drawElements",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::drawElements",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ SWIG_fail_ptr("Vbo_drawElements",1,SWIGTYPE_p_ofVbo); } - arg2 = (int)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); ((ofVbo const *)arg1)->drawElements(arg2,arg3); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_drawElements(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_Vbo_drawElements__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Vbo_drawElements__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_drawElements'\n" " Possible C/C++ prototypes are:\n" - " ofVbo::drawElements(int,int,int) const\n" " ofVbo::drawElements(int,int) const\n"); lua_error(L);return 0; } -static int _wrap_Vbo_drawInstanced(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; int arg2 ; int arg3 ; - int arg4 ; int arg5 ; SWIG_check_num_args("ofVbo::drawInstanced",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::drawInstanced",1,"ofVbo const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVbo::drawInstanced",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::drawInstanced",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVbo::drawInstanced",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofVbo::drawInstanced",5,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_drawInstanced",1,SWIGTYPE_p_ofVbo); } arg2 = (int)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); ((ofVbo const *)arg1)->drawInstanced(arg2,arg3,arg4,arg5); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_drawElementsInstanced(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; int arg2 ; int arg3 ; - int arg4 ; SWIG_check_num_args("ofVbo::drawElementsInstanced",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::drawElementsInstanced",1,"ofVbo const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVbo::drawElementsInstanced",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::drawElementsInstanced",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVbo::drawElementsInstanced",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_drawElementsInstanced",1,SWIGTYPE_p_ofVbo); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); ((ofVbo const *)arg1)->drawElementsInstanced(arg2,arg3,arg4); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_bind(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; SWIG_check_num_args("ofVbo::bind",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::bind",1,"ofVbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ SWIG_fail_ptr("Vbo_bind",1,SWIGTYPE_p_ofVbo); } - ((ofVbo const *)arg1)->bind(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_unbind(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - SWIG_check_num_args("ofVbo::unbind",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::unbind",1,"ofVbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ SWIG_fail_ptr("Vbo_unbind",1,SWIGTYPE_p_ofVbo); } - ((ofVbo const *)arg1)->unbind(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_clear(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; SWIG_check_num_args("ofVbo::clear",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::clear",1,"ofVbo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ SWIG_fail_ptr("Vbo_clear",1,SWIGTYPE_p_ofVbo); } - (arg1)->clear(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_clearVertices(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - SWIG_check_num_args("ofVbo::clearVertices",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::clearVertices",1,"ofVbo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_clearVertices",1,SWIGTYPE_p_ofVbo); } (arg1)->clearVertices(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_clearNormals(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - SWIG_check_num_args("ofVbo::clearNormals",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::clearNormals",1,"ofVbo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ SWIG_fail_ptr("Vbo_clearNormals",1,SWIGTYPE_p_ofVbo); } - (arg1)->clearNormals(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_clearColors(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - SWIG_check_num_args("ofVbo::clearColors",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::clearColors",1,"ofVbo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ SWIG_fail_ptr("Vbo_clearColors",1,SWIGTYPE_p_ofVbo); } - (arg1)->clearColors(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_clearTexCoords(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - SWIG_check_num_args("ofVbo::clearTexCoords",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::clearTexCoords",1,"ofVbo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_clearTexCoords",1,SWIGTYPE_p_ofVbo); } (arg1)->clearTexCoords(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_clearIndices(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - SWIG_check_num_args("ofVbo::clearIndices",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::clearIndices",1,"ofVbo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ SWIG_fail_ptr("Vbo_clearIndices",1,SWIGTYPE_p_ofVbo); } - (arg1)->clearIndices(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_clearAttribute(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; int arg2 ; - SWIG_check_num_args("ofVbo::clearAttribute",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::clearAttribute",1,"ofVbo *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVbo::clearAttribute",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_clearAttribute",1,SWIGTYPE_p_ofVbo); } arg2 = (int)lua_tonumber(L, 2); (arg1)->clearAttribute(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_getNumVertices(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; int result; - SWIG_check_num_args("ofVbo::getNumVertices",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::getNumVertices",1,"ofVbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_getNumVertices",1,SWIGTYPE_p_ofVbo); } result = (int)((ofVbo const *)arg1)->getNumVertices(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_getNumIndices(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; int result; - SWIG_check_num_args("ofVbo::getNumIndices",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::getNumIndices",1,"ofVbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_getNumIndices",1,SWIGTYPE_p_ofVbo); } result = (int)((ofVbo const *)arg1)->getNumIndices(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_hasAttribute(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; int arg2 ; bool result; - SWIG_check_num_args("ofVbo::hasAttribute",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::hasAttribute",1,"ofVbo const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVbo::hasAttribute",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ SWIG_fail_ptr("Vbo_hasAttribute",1,SWIGTYPE_p_ofVbo); } - arg2 = (int)lua_tonumber(L, 2); result = (bool)((ofVbo const *)arg1)->hasAttribute(arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_Vbo(void *obj) { -ofVbo *arg1 = (ofVbo *) obj; -delete arg1; -} -static int _proxy__wrap_new_Vbo(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_Vbo); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_Vbo_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_Vbo_methods[]= { - { "setMesh", _wrap_Vbo_setMesh}, - { "setIndexData", _wrap_Vbo_setIndexData}, - { "setVertexData", _wrap_Vbo_setVertexData}, - { "setColorData", _wrap_Vbo_setColorData}, - { "setNormalData", _wrap_Vbo_setNormalData}, - { "setTexCoordData", _wrap_Vbo_setTexCoordData}, - { "setAttributeData", _wrap_Vbo_setAttributeData}, - { "setVertexBuffer", _wrap_Vbo_setVertexBuffer}, - { "setColorBuffer", _wrap_Vbo_setColorBuffer}, - { "setNormalBuffer", _wrap_Vbo_setNormalBuffer}, - { "setTexCoordBuffer", _wrap_Vbo_setTexCoordBuffer}, - { "setIndexBuffer", _wrap_Vbo_setIndexBuffer}, - { "setAttributeBuffer", _wrap_Vbo_setAttributeBuffer}, - { "getVertexBuffer", _wrap_Vbo_getVertexBuffer}, - { "getColorBuffer", _wrap_Vbo_getColorBuffer}, - { "getNormalBuffer", _wrap_Vbo_getNormalBuffer}, - { "getTexCoordBuffer", _wrap_Vbo_getTexCoordBuffer}, - { "getIndexBuffer", _wrap_Vbo_getIndexBuffer}, - { "getAttributeBuffer", _wrap_Vbo_getAttributeBuffer}, - { "updateMesh", _wrap_Vbo_updateMesh}, - { "updateIndexData", _wrap_Vbo_updateIndexData}, - { "updateVertexData", _wrap_Vbo_updateVertexData}, - { "updateColorData", _wrap_Vbo_updateColorData}, - { "updateNormalData", _wrap_Vbo_updateNormalData}, - { "updateTexCoordData", _wrap_Vbo_updateTexCoordData}, - { "updateAttributeData", _wrap_Vbo_updateAttributeData}, - { "enableColors", _wrap_Vbo_enableColors}, - { "enableNormals", _wrap_Vbo_enableNormals}, - { "enableTexCoords", _wrap_Vbo_enableTexCoords}, - { "enableIndices", _wrap_Vbo_enableIndices}, - { "disableColors", _wrap_Vbo_disableColors}, - { "disableNormals", _wrap_Vbo_disableNormals}, - { "disableTexCoords", _wrap_Vbo_disableTexCoords}, - { "disableIndices", _wrap_Vbo_disableIndices}, - { "getVaoId", _wrap_Vbo_getVaoId}, - { "getVertId", _wrap_Vbo_getVertId}, - { "getColorId", _wrap_Vbo_getColorId}, - { "getNormalId", _wrap_Vbo_getNormalId}, - { "getTexCoordId", _wrap_Vbo_getTexCoordId}, - { "getIndexId", _wrap_Vbo_getIndexId}, - { "getAttributeId", _wrap_Vbo_getAttributeId}, - { "getIsAllocated", _wrap_Vbo_getIsAllocated}, - { "getUsingVerts", _wrap_Vbo_getUsingVerts}, - { "getUsingColors", _wrap_Vbo_getUsingColors}, - { "getUsingNormals", _wrap_Vbo_getUsingNormals}, - { "getUsingTexCoords", _wrap_Vbo_getUsingTexCoords}, - { "getUsingIndices", _wrap_Vbo_getUsingIndices}, - { "draw", _wrap_Vbo_draw}, - { "drawElements", _wrap_Vbo_drawElements}, - { "drawInstanced", _wrap_Vbo_drawInstanced}, - { "drawElementsInstanced", _wrap_Vbo_drawElementsInstanced}, - { "bind", _wrap_Vbo_bind}, - { "unbind", _wrap_Vbo_unbind}, - { "clear", _wrap_Vbo_clear}, - { "clearVertices", _wrap_Vbo_clearVertices}, - { "clearNormals", _wrap_Vbo_clearNormals}, - { "clearColors", _wrap_Vbo_clearColors}, - { "clearTexCoords", _wrap_Vbo_clearTexCoords}, - { "clearIndices", _wrap_Vbo_clearIndices}, - { "clearAttribute", _wrap_Vbo_clearAttribute}, - { "getNumVertices", _wrap_Vbo_getNumVertices}, - { "getNumIndices", _wrap_Vbo_getNumIndices}, - { "hasAttribute", _wrap_Vbo_hasAttribute}, - {0,0} -}; -static swig_lua_method swig_Vbo_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_Vbo_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_Vbo_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_Vbo_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_Vbo_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_Vbo_Sf_SwigStatic = { - "Vbo", - swig_Vbo_Sf_SwigStatic_methods, - swig_Vbo_Sf_SwigStatic_attributes, - swig_Vbo_Sf_SwigStatic_constants, - swig_Vbo_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_Vbo_bases[] = {0}; -static const char *swig_Vbo_base_names[] = {0}; -static swig_lua_class _wrap_class_Vbo = { "Vbo", "Vbo", &SWIGTYPE_p_ofVbo,_proxy__wrap_new_Vbo, swig_delete_Vbo, swig_Vbo_methods, swig_Vbo_attributes, &swig_Vbo_Sf_SwigStatic, swig_Vbo_meta, swig_Vbo_bases, swig_Vbo_base_names }; - -static int _wrap_VboMesh_draw__SWIG_0_0(lua_State* L) { int SWIG_arg = 0; ofVboMesh *arg1 = (ofVboMesh *) 0 ; - SWIG_check_num_args("draw",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("draw",1,"ofVboMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVboMesh,0))){ - SWIG_fail_ptr("VboMesh_draw",1,SWIGTYPE_p_ofVboMesh); } ((ofVboMesh const *)arg1)->draw(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_new_VboMesh__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVboMesh *result = 0 ; - SWIG_check_num_args("ofVboMesh::ofVboMesh",0,0) result = (ofVboMesh *)new ofVboMesh(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVboMesh,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_VboMesh__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = 0 ; ofVboMesh *result = 0 ; - SWIG_check_num_args("ofVboMesh::ofVboMesh",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofVboMesh::ofVboMesh",1,"ofMesh const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("new_VboMesh",1,SWIGTYPE_p_ofMesh); } - result = (ofVboMesh *)new ofVboMesh((ofMesh const &)*arg1); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVboMesh,1); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_new_VboMesh(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_VboMesh__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_new_VboMesh__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_VboMesh'\n" " Possible C/C++ prototypes are:\n" - " ofVboMesh::ofVboMesh()\n" " ofVboMesh::ofVboMesh(ofMesh const &)\n"); lua_error(L);return 0; } -static int _wrap_VboMesh_setUsage(lua_State* L) { int SWIG_arg = 0; ofVboMesh *arg1 = (ofVboMesh *) 0 ; int arg2 ; - SWIG_check_num_args("ofVboMesh::setUsage",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVboMesh::setUsage",1,"ofVboMesh *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVboMesh::setUsage",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVboMesh,0))){ - SWIG_fail_ptr("VboMesh_setUsage",1,SWIGTYPE_p_ofVboMesh); } arg2 = (int)lua_tonumber(L, 2); (arg1)->setUsage(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VboMesh_draw__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVboMesh *arg1 = (ofVboMesh *) 0 ; - ofPolyRenderMode arg2 ; SWIG_check_num_args("ofVboMesh::draw",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVboMesh::draw",1,"ofVboMesh const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVboMesh::draw",2,"ofPolyRenderMode"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVboMesh,0))){ - SWIG_fail_ptr("VboMesh_draw",1,SWIGTYPE_p_ofVboMesh); } arg2 = (ofPolyRenderMode)(int)lua_tonumber(L, 2); - ((ofVboMesh const *)arg1)->draw(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VboMesh_draw(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVboMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_VboMesh_draw__SWIG_0_0(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVboMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_VboMesh_draw__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'VboMesh_draw'\n" " Possible C/C++ prototypes are:\n" - " draw() const\n" " ofVboMesh::draw(ofPolyRenderMode) const\n"); lua_error(L);return 0; } -static int _wrap_VboMesh_drawInstanced(lua_State* L) { int SWIG_arg = 0; ofVboMesh *arg1 = (ofVboMesh *) 0 ; - ofPolyRenderMode arg2 ; int arg3 ; SWIG_check_num_args("ofVboMesh::drawInstanced",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVboMesh::drawInstanced",1,"ofVboMesh const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVboMesh::drawInstanced",2,"ofPolyRenderMode"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVboMesh::drawInstanced",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVboMesh,0))){ - SWIG_fail_ptr("VboMesh_drawInstanced",1,SWIGTYPE_p_ofVboMesh); } arg2 = (ofPolyRenderMode)(int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); ((ofVboMesh const *)arg1)->drawInstanced(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_VboMesh_getVbo__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVboMesh *arg1 = (ofVboMesh *) 0 ; - ofVbo *result = 0 ; SWIG_check_num_args("ofVboMesh::getVbo",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVboMesh::getVbo",1,"ofVboMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVboMesh,0))){ - SWIG_fail_ptr("VboMesh_getVbo",1,SWIGTYPE_p_ofVboMesh); } result = (ofVbo *) &(arg1)->getVbo(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVbo,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_VboMesh_getVbo__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVboMesh *arg1 = (ofVboMesh *) 0 ; - ofVbo *result = 0 ; SWIG_check_num_args("ofVboMesh::getVbo",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVboMesh::getVbo",1,"ofVboMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVboMesh,0))){ - SWIG_fail_ptr("VboMesh_getVbo",1,SWIGTYPE_p_ofVboMesh); } result = (ofVbo *) &((ofVboMesh const *)arg1)->getVbo(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVbo,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_VboMesh_getVbo(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVboMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_VboMesh_getVbo__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVboMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_VboMesh_getVbo__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'VboMesh_getVbo'\n" " Possible C/C++ prototypes are:\n" - " ofVboMesh::getVbo()\n" " ofVboMesh::getVbo() const\n"); lua_error(L);return 0; } -static void swig_delete_VboMesh(void *obj) { -ofVboMesh *arg1 = (ofVboMesh *) obj; -delete arg1; -} -static int _proxy__wrap_new_VboMesh(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_VboMesh); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_VboMesh_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_VboMesh_methods[]= { - { "setUsage", _wrap_VboMesh_setUsage}, - { "draw", _wrap_VboMesh_draw}, - { "drawInstanced", _wrap_VboMesh_drawInstanced}, - { "getVbo", _wrap_VboMesh_getVbo}, - {0,0} -}; -static swig_lua_method swig_VboMesh_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_VboMesh_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_VboMesh_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_VboMesh_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_VboMesh_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_VboMesh_Sf_SwigStatic = { - "VboMesh", - swig_VboMesh_Sf_SwigStatic_methods, - swig_VboMesh_Sf_SwigStatic_attributes, - swig_VboMesh_Sf_SwigStatic_constants, - swig_VboMesh_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_VboMesh_bases[] = {0,0}; -static const char *swig_VboMesh_base_names[] = {"ofMesh *",0}; -static swig_lua_class _wrap_class_VboMesh = { "VboMesh", "VboMesh", &SWIGTYPE_p_ofVboMesh,_proxy__wrap_new_VboMesh, swig_delete_VboMesh, swig_VboMesh_methods, swig_VboMesh_attributes, &swig_VboMesh_Sf_SwigStatic, swig_VboMesh_meta, swig_VboMesh_bases, swig_VboMesh_base_names }; - -static int _wrap_new_Pixels__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPixels_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofPixels_< unsigned char >::ofPixels_",0,0) - result = (ofPixels_< unsigned char > *)new ofPixels_< unsigned char >(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofPixels_T_unsigned_char_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_Pixels__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPixels_< unsigned char > *arg1 = 0 ; - ofPixels_< unsigned char > *result = 0 ; SWIG_check_num_args("ofPixels_< unsigned char >::ofPixels_",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::ofPixels_",1,"ofPixels_< unsigned char > &&"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("new_Pixels",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - result = (ofPixels_< unsigned char > *)new ofPixels_< unsigned char >((ofPixels_< unsigned char > &&)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofPixels_T_unsigned_char_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_Pixels(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_Pixels__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_new_Pixels__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_Pixels'\n" " Possible C/C++ prototypes are:\n" - " ofPixels_< unsigned char >::ofPixels_()\n" " ofPixels_< unsigned char >::ofPixels_(ofPixels_< unsigned char > &&)\n"); - lua_error(L);return 0; } -static int _wrap_Pixels_allocate(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; size_t arg2 ; size_t arg3 ; size_t arg4 ; - SWIG_check_num_args("ofPixels_< unsigned char >::allocate",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::allocate",1,"ofPixels_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::allocate",2,"size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned char >::allocate",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< unsigned char >::allocate",4,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_allocate",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (size_t)lua_tonumber(L, 4); - (arg1)->allocate(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_allocatePixelFormat(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; size_t arg2 ; size_t arg3 ; ofPixelFormat arg4 ; - SWIG_check_num_args("ofPixels_< unsigned char >::allocate",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::allocate",1,"ofPixels_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::allocate",2,"size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned char >::allocate",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< unsigned char >::allocate",4,"ofPixelFormat"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_allocatePixelFormat",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - arg4 = (ofPixelFormat)(int)lua_tonumber(L, 4); (arg1)->allocate(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_allocateImageType(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; size_t arg2 ; size_t arg3 ; ofImageType arg4 ; - SWIG_check_num_args("ofPixels_< unsigned char >::allocate",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::allocate",1,"ofPixels_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::allocate",2,"size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned char >::allocate",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< unsigned char >::allocate",4,"ofImageType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_allocateImageType",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - arg4 = (ofImageType)(int)lua_tonumber(L, 4); (arg1)->allocate(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_isAllocated(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; bool result; - SWIG_check_num_args("ofPixels_< unsigned char >::isAllocated",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::isAllocated",1,"ofPixels_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_isAllocated",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - result = (bool)((ofPixels_< unsigned char > const *)arg1)->isAllocated(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_clear(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; - SWIG_check_num_args("ofPixels_< unsigned char >::clear",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::clear",1,"ofPixels_< unsigned char > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_clear",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } (arg1)->clear(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_set__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; unsigned char arg2 ; - SWIG_check_num_args("ofPixels_< unsigned char >::set",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::set",1,"ofPixels_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::set",2,"unsigned char"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_set",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned char)lua_tonumber(L, 2); - (arg1)->set(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_set__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; size_t arg2 ; unsigned char arg3 ; - SWIG_check_num_args("ofPixels_< unsigned char >::set",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::set",1,"ofPixels_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::set",2,"size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned char >::set",3,"unsigned char"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_set",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (unsigned char)lua_tonumber(L, 3); - (arg1)->set(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_set(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Pixels_set__SWIG_0(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_Pixels_set__SWIG_1(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Pixels_set'\n" " Possible C/C++ prototypes are:\n" - " ofPixels_< unsigned char >::set(unsigned char)\n" " ofPixels_< unsigned char >::set(size_t,unsigned char)\n"); - lua_error(L);return 0; } -static int _wrap_Pixels_setFromPixels(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; unsigned char *arg2 = (unsigned char *) 0 ; - size_t arg3 ; size_t arg4 ; ofPixelFormat arg5 ; SWIG_check_num_args("ofPixels_< unsigned char >::setFromPixels",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::setFromPixels",1,"ofPixels_< unsigned char > *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::setFromPixels",2,"unsigned char const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned char >::setFromPixels",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< unsigned char >::setFromPixels",4,"size_t"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPixels_< unsigned char >::setFromPixels",5,"ofPixelFormat"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_setFromPixels",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_unsigned_char,0))){ - SWIG_fail_ptr("Pixels_setFromPixels",2,SWIGTYPE_p_unsigned_char); } - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (size_t)lua_tonumber(L, 4); - arg5 = (ofPixelFormat)(int)lua_tonumber(L, 5); (arg1)->setFromPixels((unsigned char const *)arg2,arg3,arg4,arg5); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_setFromPixelsImageType(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; unsigned char *arg2 = (unsigned char *) 0 ; - size_t arg3 ; size_t arg4 ; ofImageType arg5 ; SWIG_check_num_args("ofPixels_< unsigned char >::setFromPixels",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::setFromPixels",1,"ofPixels_< unsigned char > *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::setFromPixels",2,"unsigned char const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned char >::setFromPixels",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< unsigned char >::setFromPixels",4,"size_t"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPixels_< unsigned char >::setFromPixels",5,"ofImageType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_setFromPixelsImageType",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_unsigned_char,0))){ - SWIG_fail_ptr("Pixels_setFromPixelsImageType",2,SWIGTYPE_p_unsigned_char); } - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (size_t)lua_tonumber(L, 4); - arg5 = (ofImageType)(int)lua_tonumber(L, 5); (arg1)->setFromPixels((unsigned char const *)arg2,arg3,arg4,arg5); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_setFromExternalPixels(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; unsigned char *arg2 = (unsigned char *) 0 ; - size_t arg3 ; size_t arg4 ; ofPixelFormat arg5 ; SWIG_check_num_args("ofPixels_< unsigned char >::setFromExternalPixels",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::setFromExternalPixels",1,"ofPixels_< unsigned char > *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::setFromExternalPixels",2,"unsigned char *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned char >::setFromExternalPixels",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< unsigned char >::setFromExternalPixels",4,"size_t"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPixels_< unsigned char >::setFromExternalPixels",5,"ofPixelFormat"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_setFromExternalPixels",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_unsigned_char,0))){ - SWIG_fail_ptr("Pixels_setFromExternalPixels",2,SWIGTYPE_p_unsigned_char); } - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (size_t)lua_tonumber(L, 4); - arg5 = (ofPixelFormat)(int)lua_tonumber(L, 5); (arg1)->setFromExternalPixels(arg2,arg3,arg4,arg5); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_setFromAlignedPixels(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; unsigned char *arg2 = (unsigned char *) 0 ; - size_t arg3 ; size_t arg4 ; ofPixelFormat arg5 ; size_t arg6 ; - SWIG_check_num_args("ofPixels_< unsigned char >::setFromAlignedPixels",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::setFromAlignedPixels",1,"ofPixels_< unsigned char > *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::setFromAlignedPixels",2,"unsigned char const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned char >::setFromAlignedPixels",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< unsigned char >::setFromAlignedPixels",4,"size_t"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPixels_< unsigned char >::setFromAlignedPixels",5,"ofPixelFormat"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPixels_< unsigned char >::setFromAlignedPixels",6,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_setFromAlignedPixels",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_unsigned_char,0))){ - SWIG_fail_ptr("Pixels_setFromAlignedPixels",2,SWIGTYPE_p_unsigned_char); } - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (size_t)lua_tonumber(L, 4); - arg5 = (ofPixelFormat)(int)lua_tonumber(L, 5); SWIG_contract_assert((lua_tonumber(L,6)>=0),"number must not be negative") - arg6 = (size_t)lua_tonumber(L, 6); (arg1)->setFromAlignedPixels((unsigned char const *)arg2,arg3,arg4,arg5,arg6); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_swap(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; ofPixels_< unsigned char > *arg2 = 0 ; - SWIG_check_num_args("ofPixels_< unsigned char >::swap",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::swap",1,"ofPixels_< unsigned char > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::swap",2,"ofPixels_< unsigned char > &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_swap",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_swap",2,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } (arg1)->swap(*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_crop(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; size_t arg2 ; size_t arg3 ; size_t arg4 ; size_t arg5 ; - SWIG_check_num_args("ofPixels_< unsigned char >::crop",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::crop",1,"ofPixels_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::crop",2,"size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned char >::crop",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< unsigned char >::crop",4,"size_t"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPixels_< unsigned char >::crop",5,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_crop",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (size_t)lua_tonumber(L, 4); - SWIG_contract_assert((lua_tonumber(L,5)>=0),"number must not be negative") arg5 = (size_t)lua_tonumber(L, 5); - (arg1)->crop(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_cropTo(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; ofPixels_< unsigned char > *arg2 = 0 ; size_t arg3 ; - size_t arg4 ; size_t arg5 ; size_t arg6 ; SWIG_check_num_args("ofPixels_< unsigned char >::cropTo",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::cropTo",1,"ofPixels_< unsigned char > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::cropTo",2,"ofPixels_< unsigned char > &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned char >::cropTo",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< unsigned char >::cropTo",4,"size_t"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPixels_< unsigned char >::cropTo",5,"size_t"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPixels_< unsigned char >::cropTo",6,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_cropTo",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_cropTo",2,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (size_t)lua_tonumber(L, 4); - SWIG_contract_assert((lua_tonumber(L,5)>=0),"number must not be negative") arg5 = (size_t)lua_tonumber(L, 5); - SWIG_contract_assert((lua_tonumber(L,6)>=0),"number must not be negative") arg6 = (size_t)lua_tonumber(L, 6); - ((ofPixels_< unsigned char > const *)arg1)->cropTo(*arg2,arg3,arg4,arg5,arg6); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_rotate90(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; int arg2 ; - SWIG_check_num_args("ofPixels_< unsigned char >::rotate90",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::rotate90",1,"ofPixels_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::rotate90",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_rotate90",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->rotate90(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_rotate90To(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; ofPixels_< unsigned char > *arg2 = 0 ; int arg3 ; - SWIG_check_num_args("ofPixels_< unsigned char >::rotate90To",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::rotate90To",1,"ofPixels_< unsigned char > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::rotate90To",2,"ofPixels_< unsigned char > &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned char >::rotate90To",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_rotate90To",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_rotate90To",2,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } arg3 = (int)lua_tonumber(L, 3); - ((ofPixels_< unsigned char > const *)arg1)->rotate90To(*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Pixels_mirrorTo(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; ofPixels_< unsigned char > *arg2 = 0 ; bool arg3 ; - bool arg4 ; SWIG_check_num_args("ofPixels_< unsigned char >::mirrorTo",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::mirrorTo",1,"ofPixels_< unsigned char > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::mirrorTo",2,"ofPixels_< unsigned char > &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofPixels_< unsigned char >::mirrorTo",3,"bool"); - if(!lua_isboolean(L,4)) SWIG_fail_arg("ofPixels_< unsigned char >::mirrorTo",4,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_mirrorTo",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_mirrorTo",2,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } arg3 = (lua_toboolean(L, 3)!=0); - arg4 = (lua_toboolean(L, 4)!=0); ((ofPixels_< unsigned char > const *)arg1)->mirrorTo(*arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_mirror(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; bool arg2 ; bool arg3 ; - SWIG_check_num_args("ofPixels_< unsigned char >::mirror",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::mirror",1,"ofPixels_< unsigned char > *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::mirror",2,"bool"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofPixels_< unsigned char >::mirror",3,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_mirror",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } arg2 = (lua_toboolean(L, 2)!=0); - arg3 = (lua_toboolean(L, 3)!=0); (arg1)->mirror(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Pixels_resize__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; size_t arg2 ; size_t arg3 ; ofInterpolationMethod arg4 ; - bool result; SWIG_check_num_args("ofPixels_< unsigned char >::resize",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::resize",1,"ofPixels_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::resize",2,"size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned char >::resize",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< unsigned char >::resize",4,"ofInterpolationMethod"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_resize",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - arg4 = (ofInterpolationMethod)(int)lua_tonumber(L, 4); result = (bool)(arg1)->resize(arg2,arg3,arg4); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_resize__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; size_t arg2 ; size_t arg3 ; bool result; - SWIG_check_num_args("ofPixels_< unsigned char >::resize",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::resize",1,"ofPixels_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::resize",2,"size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned char >::resize",3,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_resize",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - result = (bool)(arg1)->resize(arg2,arg3); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_resize(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_Pixels_resize__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Pixels_resize__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Pixels_resize'\n" " Possible C/C++ prototypes are:\n" - " ofPixels_< unsigned char >::resize(size_t,size_t,ofInterpolationMethod)\n" - " ofPixels_< unsigned char >::resize(size_t,size_t)\n"); lua_error(L);return 0; } -static int _wrap_Pixels_resizeTo__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; ofPixels_< unsigned char > *arg2 = 0 ; - ofInterpolationMethod arg3 ; bool result; SWIG_check_num_args("ofPixels_< unsigned char >::resizeTo",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::resizeTo",1,"ofPixels_< unsigned char > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::resizeTo",2,"ofPixels_< unsigned char > &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned char >::resizeTo",3,"ofInterpolationMethod"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_resizeTo",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_resizeTo",2,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - arg3 = (ofInterpolationMethod)(int)lua_tonumber(L, 3); - result = (bool)((ofPixels_< unsigned char > const *)arg1)->resizeTo(*arg2,arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_resizeTo__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; ofPixels_< unsigned char > *arg2 = 0 ; bool result; - SWIG_check_num_args("ofPixels_< unsigned char >::resizeTo",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::resizeTo",1,"ofPixels_< unsigned char > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::resizeTo",2,"ofPixels_< unsigned char > &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_resizeTo",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_resizeTo",2,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - result = (bool)((ofPixels_< unsigned char > const *)arg1)->resizeTo(*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_resizeTo(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Pixels_resizeTo__SWIG_1(L);} } } if (argc == 3) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Pixels_resizeTo__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Pixels_resizeTo'\n" " Possible C/C++ prototypes are:\n" - " ofPixels_< unsigned char >::resizeTo(ofPixels_< unsigned char > &,ofInterpolationMethod) const\n" - " ofPixels_< unsigned char >::resizeTo(ofPixels_< unsigned char > &) const\n"); lua_error(L);return 0; } -static int _wrap_Pixels_pasteInto(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; ofPixels_< unsigned char > *arg2 = 0 ; size_t arg3 ; - size_t arg4 ; bool result; SWIG_check_num_args("ofPixels_< unsigned char >::pasteInto",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::pasteInto",1,"ofPixels_< unsigned char > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::pasteInto",2,"ofPixels_< unsigned char > &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned char >::pasteInto",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< unsigned char >::pasteInto",4,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_pasteInto",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_pasteInto",2,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (size_t)lua_tonumber(L, 4); - result = (bool)((ofPixels_< unsigned char > const *)arg1)->pasteInto(*arg2,arg3,arg4); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_blendInto(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; ofPixels_< unsigned char > *arg2 = 0 ; size_t arg3 ; - size_t arg4 ; bool result; SWIG_check_num_args("ofPixels_< unsigned char >::blendInto",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::blendInto",1,"ofPixels_< unsigned char > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::blendInto",2,"ofPixels_< unsigned char > &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned char >::blendInto",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< unsigned char >::blendInto",4,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_blendInto",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_blendInto",2,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (size_t)lua_tonumber(L, 4); - result = (bool)((ofPixels_< unsigned char > const *)arg1)->blendInto(*arg2,arg3,arg4); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_swapRgb(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; - SWIG_check_num_args("ofPixels_< unsigned char >::swapRgb",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::swapRgb",1,"ofPixels_< unsigned char > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_swapRgb",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } (arg1)->swapRgb(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_getData__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; unsigned char *result = 0 ; - SWIG_check_num_args("ofPixels_< unsigned char >::getData",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::getData",1,"ofPixels_< unsigned char > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_getData",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } result = (unsigned char *)(arg1)->getData(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_unsigned_char,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Pixels_getData__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; unsigned char *result = 0 ; - SWIG_check_num_args("ofPixels_< unsigned char >::getData",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::getData",1,"ofPixels_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_getData",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - result = (unsigned char *)((ofPixels_< unsigned char > const *)arg1)->getData(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_unsigned_char,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Pixels_getData(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Pixels_getData__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Pixels_getData__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Pixels_getData'\n" " Possible C/C++ prototypes are:\n" - " ofPixels_< unsigned char >::getData()\n" " ofPixels_< unsigned char >::getData() const\n"); lua_error(L);return 0; } -static int _wrap_Pixels_getPixelIndex(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; size_t arg2 ; size_t arg3 ; size_t result; - SWIG_check_num_args("ofPixels_< unsigned char >::getPixelIndex",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::getPixelIndex",1,"ofPixels_< unsigned char > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::getPixelIndex",2,"size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned char >::getPixelIndex",3,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_getPixelIndex",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - result = (size_t)((ofPixels_< unsigned char > const *)arg1)->getPixelIndex(arg2,arg3); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_getColor__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; size_t arg2 ; size_t arg3 ; - ofColor_< unsigned char > result; SWIG_check_num_args("ofPixels_< unsigned char >::getColor",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::getColor",1,"ofPixels_< unsigned char > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::getColor",2,"size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned char >::getColor",3,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_getColor",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - result = ((ofPixels_< unsigned char > const *)arg1)->getColor(arg2,arg3); { - ofColor_< unsigned char > * resultptr = new ofColor_< unsigned char >((const ofColor_< unsigned char > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_getColor__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; size_t arg2 ; ofColor_< unsigned char > result; - SWIG_check_num_args("ofPixels_< unsigned char >::getColor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::getColor",1,"ofPixels_< unsigned char > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::getColor",2,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_getColor",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - result = ((ofPixels_< unsigned char > const *)arg1)->getColor(arg2); { - ofColor_< unsigned char > * resultptr = new ofColor_< unsigned char >((const ofColor_< unsigned char > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_getColor(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Pixels_getColor__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_Pixels_getColor__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Pixels_getColor'\n" " Possible C/C++ prototypes are:\n" - " ofPixels_< unsigned char >::getColor(size_t,size_t) const\n" " ofPixels_< unsigned char >::getColor(size_t) const\n"); - lua_error(L);return 0; } -static int _wrap_Pixels_setColor__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; size_t arg2 ; size_t arg3 ; - ofColor_< unsigned char > *arg4 = 0 ; SWIG_check_num_args("ofPixels_< unsigned char >::setColor",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::setColor",1,"ofPixels_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::setColor",2,"size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned char >::setColor",3,"size_t"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofPixels_< unsigned char >::setColor",4,"ofColor_< unsigned char > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_setColor",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_setColor",4,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - (arg1)->setColor(arg2,arg3,(ofColor_< unsigned char > const &)*arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Pixels_setColor__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; size_t arg2 ; ofColor_< unsigned char > *arg3 = 0 ; - SWIG_check_num_args("ofPixels_< unsigned char >::setColor",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::setColor",1,"ofPixels_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::setColor",2,"size_t"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofPixels_< unsigned char >::setColor",3,"ofColor_< unsigned char > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_setColor",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_setColor",3,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - (arg1)->setColor(arg2,(ofColor_< unsigned char > const &)*arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Pixels_setColor__SWIG_2(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; ofColor_< unsigned char > *arg2 = 0 ; - SWIG_check_num_args("ofPixels_< unsigned char >::setColor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::setColor",1,"ofPixels_< unsigned char > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::setColor",2,"ofColor_< unsigned char > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_setColor",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_setColor",2,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - (arg1)->setColor((ofColor_< unsigned char > const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Pixels_setColor(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Pixels_setColor__SWIG_2(L);} } } if (argc == 3) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Pixels_setColor__SWIG_1(L);} } } } if (argc == 4) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Pixels_setColor__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Pixels_setColor'\n" " Possible C/C++ prototypes are:\n" - " ofPixels_< unsigned char >::setColor(size_t,size_t,ofColor_< unsigned char > const &)\n" - " ofPixels_< unsigned char >::setColor(size_t,ofColor_< unsigned char > const &)\n" - " ofPixels_< unsigned char >::setColor(ofColor_< unsigned char > const &)\n"); lua_error(L);return 0; } -static int _wrap_Pixels_getWidth(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; size_t result; - SWIG_check_num_args("ofPixels_< unsigned char >::getWidth",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::getWidth",1,"ofPixels_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_getWidth",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - result = (size_t)((ofPixels_< unsigned char > const *)arg1)->getWidth(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_getHeight(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; size_t result; - SWIG_check_num_args("ofPixels_< unsigned char >::getHeight",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::getHeight",1,"ofPixels_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_getHeight",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - result = (size_t)((ofPixels_< unsigned char > const *)arg1)->getHeight(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_getBytesPerPixel(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; size_t result; - SWIG_check_num_args("ofPixels_< unsigned char >::getBytesPerPixel",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::getBytesPerPixel",1,"ofPixels_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_getBytesPerPixel",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - result = (size_t)((ofPixels_< unsigned char > const *)arg1)->getBytesPerPixel(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_getBitsPerPixel(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; size_t result; - SWIG_check_num_args("ofPixels_< unsigned char >::getBitsPerPixel",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::getBitsPerPixel",1,"ofPixels_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_getBitsPerPixel",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - result = (size_t)((ofPixels_< unsigned char > const *)arg1)->getBitsPerPixel(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_getBytesPerChannel(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; size_t result; - SWIG_check_num_args("ofPixels_< unsigned char >::getBytesPerChannel",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::getBytesPerChannel",1,"ofPixels_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_getBytesPerChannel",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - result = (size_t)((ofPixels_< unsigned char > const *)arg1)->getBytesPerChannel(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_getBitsPerChannel(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; size_t result; - SWIG_check_num_args("ofPixels_< unsigned char >::getBitsPerChannel",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::getBitsPerChannel",1,"ofPixels_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_getBitsPerChannel",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - result = (size_t)((ofPixels_< unsigned char > const *)arg1)->getBitsPerChannel(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_getBytesStride(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; size_t result; - SWIG_check_num_args("ofPixels_< unsigned char >::getBytesStride",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::getBytesStride",1,"ofPixels_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_getBytesStride",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - result = (size_t)((ofPixels_< unsigned char > const *)arg1)->getBytesStride(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_getNumChannels(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; size_t result; - SWIG_check_num_args("ofPixels_< unsigned char >::getNumChannels",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::getNumChannels",1,"ofPixels_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_getNumChannels",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - result = (size_t)((ofPixels_< unsigned char > const *)arg1)->getNumChannels(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_getTotalBytes(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; size_t result; - SWIG_check_num_args("ofPixels_< unsigned char >::getTotalBytes",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::getTotalBytes",1,"ofPixels_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_getTotalBytes",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - result = (size_t)((ofPixels_< unsigned char > const *)arg1)->getTotalBytes(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_getNumPlanes(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; size_t result; - SWIG_check_num_args("ofPixels_< unsigned char >::getNumPlanes",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::getNumPlanes",1,"ofPixels_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_getNumPlanes",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - result = (size_t)((ofPixels_< unsigned char > const *)arg1)->getNumPlanes(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_getPlane(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; size_t arg2 ; ofPixels_< unsigned char > result; - SWIG_check_num_args("ofPixels_< unsigned char >::getPlane",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::getPlane",1,"ofPixels_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::getPlane",2,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_getPlane",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - result = (arg1)->getPlane(arg2); { - ofPixels_< unsigned char > * resultptr = new ofPixels_< unsigned char >((const ofPixels_< unsigned char > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofPixels_T_unsigned_char_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_getChannel(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; size_t arg2 ; ofPixels_< unsigned char > result; - SWIG_check_num_args("ofPixels_< unsigned char >::getChannel",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::getChannel",1,"ofPixels_< unsigned char > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::getChannel",2,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_getChannel",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - result = ((ofPixels_< unsigned char > const *)arg1)->getChannel(arg2); { - ofPixels_< unsigned char > * resultptr = new ofPixels_< unsigned char >((const ofPixels_< unsigned char > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofPixels_T_unsigned_char_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_getPixelFormat(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; ofPixelFormat result; - SWIG_check_num_args("ofPixels_< unsigned char >::getPixelFormat",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::getPixelFormat",1,"ofPixels_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_getPixelFormat",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - result = (ofPixelFormat)((ofPixels_< unsigned char > const *)arg1)->getPixelFormat(); - lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Pixels_size(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; size_t result; - SWIG_check_num_args("ofPixels_< unsigned char >::size",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::size",1,"ofPixels_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_size",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - result = (size_t)((ofPixels_< unsigned char > const *)arg1)->size(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_getImageType(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; ofImageType result; - SWIG_check_num_args("ofPixels_< unsigned char >::getImageType",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::getImageType",1,"ofPixels_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_getImageType",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - result = (ofImageType)((ofPixels_< unsigned char > const *)arg1)->getImageType(); - lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Pixels_setChannel(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; size_t arg2 ; ofPixels_< unsigned char > arg3 ; - ofPixels_< unsigned char > *argp3 ; SWIG_check_num_args("ofPixels_< unsigned char >::setChannel",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::setChannel",1,"ofPixels_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::setChannel",2,"size_t"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofPixels_< unsigned char >::setChannel",3,"ofPixels_< unsigned char > const"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_setChannel",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&argp3,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_setChannel",3,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } arg3 = *argp3; (arg1)->setChannel(arg2,arg3); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_setImageType(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; ofImageType arg2 ; - SWIG_check_num_args("ofPixels_< unsigned char >::setImageType",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::setImageType",1,"ofPixels_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::setImageType",2,"ofImageType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_setImageType",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - arg2 = (ofImageType)(int)lua_tonumber(L, 2); (arg1)->setImageType(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Pixels_setNumChannels(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; size_t arg2 ; - SWIG_check_num_args("ofPixels_< unsigned char >::setNumChannels",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::setNumChannels",1,"ofPixels_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::setNumChannels",2,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_setNumChannels",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - (arg1)->setNumChannels(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_Pixels(void *obj) { -ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) obj; -delete arg1; -} -static int _proxy__wrap_new_Pixels(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_Pixels); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_Pixels_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_Pixels_methods[]= { - { "allocate", _wrap_Pixels_allocate}, - { "allocatePixelFormat", _wrap_Pixels_allocatePixelFormat}, - { "allocateImageType", _wrap_Pixels_allocateImageType}, - { "isAllocated", _wrap_Pixels_isAllocated}, - { "clear", _wrap_Pixels_clear}, - { "set", _wrap_Pixels_set}, - { "setFromPixels", _wrap_Pixels_setFromPixels}, - { "setFromPixelsImageType", _wrap_Pixels_setFromPixelsImageType}, - { "setFromExternalPixels", _wrap_Pixels_setFromExternalPixels}, - { "setFromAlignedPixels", _wrap_Pixels_setFromAlignedPixels}, - { "swap", _wrap_Pixels_swap}, - { "crop", _wrap_Pixels_crop}, - { "cropTo", _wrap_Pixels_cropTo}, - { "rotate90", _wrap_Pixels_rotate90}, - { "rotate90To", _wrap_Pixels_rotate90To}, - { "mirrorTo", _wrap_Pixels_mirrorTo}, - { "mirror", _wrap_Pixels_mirror}, - { "resize", _wrap_Pixels_resize}, - { "resizeTo", _wrap_Pixels_resizeTo}, - { "pasteInto", _wrap_Pixels_pasteInto}, - { "blendInto", _wrap_Pixels_blendInto}, - { "swapRgb", _wrap_Pixels_swapRgb}, - { "getData", _wrap_Pixels_getData}, - { "getPixelIndex", _wrap_Pixels_getPixelIndex}, - { "getColor", _wrap_Pixels_getColor}, - { "setColor", _wrap_Pixels_setColor}, - { "getWidth", _wrap_Pixels_getWidth}, - { "getHeight", _wrap_Pixels_getHeight}, - { "getBytesPerPixel", _wrap_Pixels_getBytesPerPixel}, - { "getBitsPerPixel", _wrap_Pixels_getBitsPerPixel}, - { "getBytesPerChannel", _wrap_Pixels_getBytesPerChannel}, - { "getBitsPerChannel", _wrap_Pixels_getBitsPerChannel}, - { "getBytesStride", _wrap_Pixels_getBytesStride}, - { "getNumChannels", _wrap_Pixels_getNumChannels}, - { "getTotalBytes", _wrap_Pixels_getTotalBytes}, - { "getNumPlanes", _wrap_Pixels_getNumPlanes}, - { "getPlane", _wrap_Pixels_getPlane}, - { "getChannel", _wrap_Pixels_getChannel}, - { "getPixelFormat", _wrap_Pixels_getPixelFormat}, - { "size", _wrap_Pixels_size}, - { "getImageType", _wrap_Pixels_getImageType}, - { "setChannel", _wrap_Pixels_setChannel}, - { "setImageType", _wrap_Pixels_setImageType}, - { "setNumChannels", _wrap_Pixels_setNumChannels}, - {0,0} -}; -static swig_lua_method swig_Pixels_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_Pixels_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_Pixels_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_Pixels_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_Pixels_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_Pixels_Sf_SwigStatic = { - "Pixels", - swig_Pixels_Sf_SwigStatic_methods, - swig_Pixels_Sf_SwigStatic_attributes, - swig_Pixels_Sf_SwigStatic_constants, - swig_Pixels_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_Pixels_bases[] = {0}; -static const char *swig_Pixels_base_names[] = {0}; -static swig_lua_class _wrap_class_Pixels = { "Pixels", "Pixels", &SWIGTYPE_p_ofPixels_T_unsigned_char_t,_proxy__wrap_new_Pixels, swig_delete_Pixels, swig_Pixels_methods, swig_Pixels_attributes, &swig_Pixels_Sf_SwigStatic, swig_Pixels_meta, swig_Pixels_bases, swig_Pixels_base_names }; - -static int _wrap_new_FloatPixels__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPixels_< float > *result = 0 ; - SWIG_check_num_args("ofPixels_< float >::ofPixels_",0,0) result = (ofPixels_< float > *)new ofPixels_< float >(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofPixels_T_float_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_FloatPixels__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPixels_< float > *arg1 = 0 ; - ofPixels_< float > *result = 0 ; SWIG_check_num_args("ofPixels_< float >::ofPixels_",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofPixels_< float >::ofPixels_",1,"ofPixels_< float > &&"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("new_FloatPixels",1,SWIGTYPE_p_ofPixels_T_float_t); } - result = (ofPixels_< float > *)new ofPixels_< float >((ofPixels_< float > &&)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofPixels_T_float_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_FloatPixels(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_FloatPixels__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_new_FloatPixels__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_FloatPixels'\n" " Possible C/C++ prototypes are:\n" - " ofPixels_< float >::ofPixels_()\n" " ofPixels_< float >::ofPixels_(ofPixels_< float > &&)\n"); lua_error(L);return 0; } -static int _wrap_FloatPixels_allocate(lua_State* L) { int SWIG_arg = 0; ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; - size_t arg2 ; size_t arg3 ; size_t arg4 ; SWIG_check_num_args("ofPixels_< float >::allocate",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::allocate",1,"ofPixels_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< float >::allocate",2,"size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< float >::allocate",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< float >::allocate",4,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_allocate",1,SWIGTYPE_p_ofPixels_T_float_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (size_t)lua_tonumber(L, 4); - (arg1)->allocate(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_allocatePixelFormat(lua_State* L) { int SWIG_arg = 0; - ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; size_t arg2 ; size_t arg3 ; ofPixelFormat arg4 ; - SWIG_check_num_args("ofPixels_< float >::allocate",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::allocate",1,"ofPixels_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< float >::allocate",2,"size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< float >::allocate",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< float >::allocate",4,"ofPixelFormat"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_allocatePixelFormat",1,SWIGTYPE_p_ofPixels_T_float_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - arg4 = (ofPixelFormat)(int)lua_tonumber(L, 4); (arg1)->allocate(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_allocateImageType(lua_State* L) { int SWIG_arg = 0; - ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; size_t arg2 ; size_t arg3 ; ofImageType arg4 ; - SWIG_check_num_args("ofPixels_< float >::allocate",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::allocate",1,"ofPixels_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< float >::allocate",2,"size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< float >::allocate",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< float >::allocate",4,"ofImageType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_allocateImageType",1,SWIGTYPE_p_ofPixels_T_float_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - arg4 = (ofImageType)(int)lua_tonumber(L, 4); (arg1)->allocate(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_isAllocated(lua_State* L) { int SWIG_arg = 0; ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; - bool result; SWIG_check_num_args("ofPixels_< float >::isAllocated",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::isAllocated",1,"ofPixels_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_isAllocated",1,SWIGTYPE_p_ofPixels_T_float_t); } - result = (bool)((ofPixels_< float > const *)arg1)->isAllocated(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_clear(lua_State* L) { int SWIG_arg = 0; ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; - SWIG_check_num_args("ofPixels_< float >::clear",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::clear",1,"ofPixels_< float > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_clear",1,SWIGTYPE_p_ofPixels_T_float_t); } (arg1)->clear(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_set__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; - float arg2 ; SWIG_check_num_args("ofPixels_< float >::set",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::set",1,"ofPixels_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< float >::set",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_set",1,SWIGTYPE_p_ofPixels_T_float_t); } arg2 = (float)lua_tonumber(L, 2); (arg1)->set(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_set__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; - size_t arg2 ; float arg3 ; SWIG_check_num_args("ofPixels_< float >::set",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::set",1,"ofPixels_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< float >::set",2,"size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< float >::set",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_set",1,SWIGTYPE_p_ofPixels_T_float_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->set(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FloatPixels_set(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_FloatPixels_set__SWIG_0(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_FloatPixels_set__SWIG_1(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatPixels_set'\n" " Possible C/C++ prototypes are:\n" - " ofPixels_< float >::set(float)\n" " ofPixels_< float >::set(size_t,float)\n"); lua_error(L);return 0; } -static int _wrap_FloatPixels_setFromPixels(lua_State* L) { int SWIG_arg = 0; - ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; float *arg2 = (float *) 0 ; size_t arg3 ; size_t arg4 ; - ofPixelFormat arg5 ; SWIG_check_num_args("ofPixels_< float >::setFromPixels",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::setFromPixels",1,"ofPixels_< float > *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofPixels_< float >::setFromPixels",2,"float const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< float >::setFromPixels",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< float >::setFromPixels",4,"size_t"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPixels_< float >::setFromPixels",5,"ofPixelFormat"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_setFromPixels",1,SWIGTYPE_p_ofPixels_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("FloatPixels_setFromPixels",2,SWIGTYPE_p_float); } - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (size_t)lua_tonumber(L, 4); - arg5 = (ofPixelFormat)(int)lua_tonumber(L, 5); (arg1)->setFromPixels((float const *)arg2,arg3,arg4,arg5); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_setFromPixelsImageType(lua_State* L) { int SWIG_arg = 0; - ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; float *arg2 = (float *) 0 ; size_t arg3 ; size_t arg4 ; - ofImageType arg5 ; SWIG_check_num_args("ofPixels_< float >::setFromPixels",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::setFromPixels",1,"ofPixels_< float > *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofPixels_< float >::setFromPixels",2,"float const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< float >::setFromPixels",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< float >::setFromPixels",4,"size_t"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPixels_< float >::setFromPixels",5,"ofImageType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_setFromPixelsImageType",1,SWIGTYPE_p_ofPixels_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("FloatPixels_setFromPixelsImageType",2,SWIGTYPE_p_float); } - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (size_t)lua_tonumber(L, 4); - arg5 = (ofImageType)(int)lua_tonumber(L, 5); (arg1)->setFromPixels((float const *)arg2,arg3,arg4,arg5); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_setFromExternalPixels(lua_State* L) { int SWIG_arg = 0; - ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; float *arg2 = (float *) 0 ; size_t arg3 ; size_t arg4 ; - ofPixelFormat arg5 ; SWIG_check_num_args("ofPixels_< float >::setFromExternalPixels",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::setFromExternalPixels",1,"ofPixels_< float > *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofPixels_< float >::setFromExternalPixels",2,"float *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< float >::setFromExternalPixels",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< float >::setFromExternalPixels",4,"size_t"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPixels_< float >::setFromExternalPixels",5,"ofPixelFormat"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_setFromExternalPixels",1,SWIGTYPE_p_ofPixels_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("FloatPixels_setFromExternalPixels",2,SWIGTYPE_p_float); } - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (size_t)lua_tonumber(L, 4); - arg5 = (ofPixelFormat)(int)lua_tonumber(L, 5); (arg1)->setFromExternalPixels(arg2,arg3,arg4,arg5); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_setFromAlignedPixels(lua_State* L) { int SWIG_arg = 0; - ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; float *arg2 = (float *) 0 ; size_t arg3 ; size_t arg4 ; - ofPixelFormat arg5 ; size_t arg6 ; SWIG_check_num_args("ofPixels_< float >::setFromAlignedPixels",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::setFromAlignedPixels",1,"ofPixels_< float > *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofPixels_< float >::setFromAlignedPixels",2,"float const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< float >::setFromAlignedPixels",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< float >::setFromAlignedPixels",4,"size_t"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPixels_< float >::setFromAlignedPixels",5,"ofPixelFormat"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPixels_< float >::setFromAlignedPixels",6,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_setFromAlignedPixels",1,SWIGTYPE_p_ofPixels_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("FloatPixels_setFromAlignedPixels",2,SWIGTYPE_p_float); } - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (size_t)lua_tonumber(L, 4); - arg5 = (ofPixelFormat)(int)lua_tonumber(L, 5); SWIG_contract_assert((lua_tonumber(L,6)>=0),"number must not be negative") - arg6 = (size_t)lua_tonumber(L, 6); (arg1)->setFromAlignedPixels((float const *)arg2,arg3,arg4,arg5,arg6); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_swap(lua_State* L) { int SWIG_arg = 0; ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; - ofPixels_< float > *arg2 = 0 ; SWIG_check_num_args("ofPixels_< float >::swap",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::swap",1,"ofPixels_< float > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPixels_< float >::swap",2,"ofPixels_< float > &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_swap",1,SWIGTYPE_p_ofPixels_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_swap",2,SWIGTYPE_p_ofPixels_T_float_t); } (arg1)->swap(*arg2); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_crop(lua_State* L) { int SWIG_arg = 0; ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; - size_t arg2 ; size_t arg3 ; size_t arg4 ; size_t arg5 ; SWIG_check_num_args("ofPixels_< float >::crop",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::crop",1,"ofPixels_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< float >::crop",2,"size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< float >::crop",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< float >::crop",4,"size_t"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPixels_< float >::crop",5,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_crop",1,SWIGTYPE_p_ofPixels_T_float_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (size_t)lua_tonumber(L, 4); - SWIG_contract_assert((lua_tonumber(L,5)>=0),"number must not be negative") arg5 = (size_t)lua_tonumber(L, 5); - (arg1)->crop(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_cropTo(lua_State* L) { int SWIG_arg = 0; ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; - ofPixels_< float > *arg2 = 0 ; size_t arg3 ; size_t arg4 ; size_t arg5 ; size_t arg6 ; - SWIG_check_num_args("ofPixels_< float >::cropTo",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::cropTo",1,"ofPixels_< float > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPixels_< float >::cropTo",2,"ofPixels_< float > &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< float >::cropTo",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< float >::cropTo",4,"size_t"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPixels_< float >::cropTo",5,"size_t"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPixels_< float >::cropTo",6,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_cropTo",1,SWIGTYPE_p_ofPixels_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_cropTo",2,SWIGTYPE_p_ofPixels_T_float_t); } - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (size_t)lua_tonumber(L, 4); - SWIG_contract_assert((lua_tonumber(L,5)>=0),"number must not be negative") arg5 = (size_t)lua_tonumber(L, 5); - SWIG_contract_assert((lua_tonumber(L,6)>=0),"number must not be negative") arg6 = (size_t)lua_tonumber(L, 6); - ((ofPixels_< float > const *)arg1)->cropTo(*arg2,arg3,arg4,arg5,arg6); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FloatPixels_rotate90(lua_State* L) { int SWIG_arg = 0; ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; - int arg2 ; SWIG_check_num_args("ofPixels_< float >::rotate90",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::rotate90",1,"ofPixels_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< float >::rotate90",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_rotate90",1,SWIGTYPE_p_ofPixels_T_float_t); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->rotate90(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_rotate90To(lua_State* L) { int SWIG_arg = 0; ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; - ofPixels_< float > *arg2 = 0 ; int arg3 ; SWIG_check_num_args("ofPixels_< float >::rotate90To",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::rotate90To",1,"ofPixels_< float > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPixels_< float >::rotate90To",2,"ofPixels_< float > &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< float >::rotate90To",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_rotate90To",1,SWIGTYPE_p_ofPixels_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_rotate90To",2,SWIGTYPE_p_ofPixels_T_float_t); } arg3 = (int)lua_tonumber(L, 3); - ((ofPixels_< float > const *)arg1)->rotate90To(*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FloatPixels_mirrorTo(lua_State* L) { int SWIG_arg = 0; ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; - ofPixels_< float > *arg2 = 0 ; bool arg3 ; bool arg4 ; SWIG_check_num_args("ofPixels_< float >::mirrorTo",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::mirrorTo",1,"ofPixels_< float > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPixels_< float >::mirrorTo",2,"ofPixels_< float > &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofPixels_< float >::mirrorTo",3,"bool"); - if(!lua_isboolean(L,4)) SWIG_fail_arg("ofPixels_< float >::mirrorTo",4,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_mirrorTo",1,SWIGTYPE_p_ofPixels_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_mirrorTo",2,SWIGTYPE_p_ofPixels_T_float_t); } arg3 = (lua_toboolean(L, 3)!=0); - arg4 = (lua_toboolean(L, 4)!=0); ((ofPixels_< float > const *)arg1)->mirrorTo(*arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_mirror(lua_State* L) { int SWIG_arg = 0; ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; - bool arg2 ; bool arg3 ; SWIG_check_num_args("ofPixels_< float >::mirror",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::mirror",1,"ofPixels_< float > *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofPixels_< float >::mirror",2,"bool"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofPixels_< float >::mirror",3,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_mirror",1,SWIGTYPE_p_ofPixels_T_float_t); } arg2 = (lua_toboolean(L, 2)!=0); - arg3 = (lua_toboolean(L, 3)!=0); (arg1)->mirror(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FloatPixels_resize__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; size_t arg2 ; size_t arg3 ; ofInterpolationMethod arg4 ; bool result; - SWIG_check_num_args("ofPixels_< float >::resize",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::resize",1,"ofPixels_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< float >::resize",2,"size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< float >::resize",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< float >::resize",4,"ofInterpolationMethod"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_resize",1,SWIGTYPE_p_ofPixels_T_float_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - arg4 = (ofInterpolationMethod)(int)lua_tonumber(L, 4); result = (bool)(arg1)->resize(arg2,arg3,arg4); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_resize__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; size_t arg2 ; size_t arg3 ; bool result; - SWIG_check_num_args("ofPixels_< float >::resize",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::resize",1,"ofPixels_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< float >::resize",2,"size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< float >::resize",3,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_resize",1,SWIGTYPE_p_ofPixels_T_float_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - result = (bool)(arg1)->resize(arg2,arg3); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_resize(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_FloatPixels_resize__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_FloatPixels_resize__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatPixels_resize'\n" " Possible C/C++ prototypes are:\n" - " ofPixels_< float >::resize(size_t,size_t,ofInterpolationMethod)\n" " ofPixels_< float >::resize(size_t,size_t)\n"); - lua_error(L);return 0; } -static int _wrap_FloatPixels_resizeTo__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; ofPixels_< float > *arg2 = 0 ; ofInterpolationMethod arg3 ; bool result; - SWIG_check_num_args("ofPixels_< float >::resizeTo",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::resizeTo",1,"ofPixels_< float > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPixels_< float >::resizeTo",2,"ofPixels_< float > &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< float >::resizeTo",3,"ofInterpolationMethod"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_resizeTo",1,SWIGTYPE_p_ofPixels_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_resizeTo",2,SWIGTYPE_p_ofPixels_T_float_t); } - arg3 = (ofInterpolationMethod)(int)lua_tonumber(L, 3); - result = (bool)((ofPixels_< float > const *)arg1)->resizeTo(*arg2,arg3); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_resizeTo__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; ofPixels_< float > *arg2 = 0 ; bool result; - SWIG_check_num_args("ofPixels_< float >::resizeTo",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::resizeTo",1,"ofPixels_< float > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPixels_< float >::resizeTo",2,"ofPixels_< float > &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_resizeTo",1,SWIGTYPE_p_ofPixels_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_resizeTo",2,SWIGTYPE_p_ofPixels_T_float_t); } - result = (bool)((ofPixels_< float > const *)arg1)->resizeTo(*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_resizeTo(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_FloatPixels_resizeTo__SWIG_1(L);} } } if (argc == 3) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_FloatPixels_resizeTo__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatPixels_resizeTo'\n" - " Possible C/C++ prototypes are:\n" " ofPixels_< float >::resizeTo(ofPixels_< float > &,ofInterpolationMethod) const\n" - " ofPixels_< float >::resizeTo(ofPixels_< float > &) const\n"); lua_error(L);return 0; } -static int _wrap_FloatPixels_pasteInto(lua_State* L) { int SWIG_arg = 0; ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; - ofPixels_< float > *arg2 = 0 ; size_t arg3 ; size_t arg4 ; bool result; - SWIG_check_num_args("ofPixels_< float >::pasteInto",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::pasteInto",1,"ofPixels_< float > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPixels_< float >::pasteInto",2,"ofPixels_< float > &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< float >::pasteInto",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< float >::pasteInto",4,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_pasteInto",1,SWIGTYPE_p_ofPixels_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_pasteInto",2,SWIGTYPE_p_ofPixels_T_float_t); } - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (size_t)lua_tonumber(L, 4); - result = (bool)((ofPixels_< float > const *)arg1)->pasteInto(*arg2,arg3,arg4); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_blendInto(lua_State* L) { int SWIG_arg = 0; ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; - ofPixels_< float > *arg2 = 0 ; size_t arg3 ; size_t arg4 ; bool result; - SWIG_check_num_args("ofPixels_< float >::blendInto",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::blendInto",1,"ofPixels_< float > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPixels_< float >::blendInto",2,"ofPixels_< float > &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< float >::blendInto",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< float >::blendInto",4,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_blendInto",1,SWIGTYPE_p_ofPixels_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_blendInto",2,SWIGTYPE_p_ofPixels_T_float_t); } - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (size_t)lua_tonumber(L, 4); - result = (bool)((ofPixels_< float > const *)arg1)->blendInto(*arg2,arg3,arg4); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_swapRgb(lua_State* L) { int SWIG_arg = 0; ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; - SWIG_check_num_args("ofPixels_< float >::swapRgb",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::swapRgb",1,"ofPixels_< float > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_swapRgb",1,SWIGTYPE_p_ofPixels_T_float_t); } (arg1)->swapRgb(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_getData__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; float *result = 0 ; - SWIG_check_num_args("ofPixels_< float >::getData",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::getData",1,"ofPixels_< float > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_getData",1,SWIGTYPE_p_ofPixels_T_float_t); } result = (float *)(arg1)->getData(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_float,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FloatPixels_getData__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; float *result = 0 ; - SWIG_check_num_args("ofPixels_< float >::getData",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::getData",1,"ofPixels_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_getData",1,SWIGTYPE_p_ofPixels_T_float_t); } - result = (float *)((ofPixels_< float > const *)arg1)->getData(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_float,0); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_getData(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_FloatPixels_getData__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_FloatPixels_getData__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatPixels_getData'\n" - " Possible C/C++ prototypes are:\n" " ofPixels_< float >::getData()\n" " ofPixels_< float >::getData() const\n"); - lua_error(L);return 0; } -static int _wrap_FloatPixels_getPixelIndex(lua_State* L) { int SWIG_arg = 0; - ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; size_t arg2 ; size_t arg3 ; size_t result; - SWIG_check_num_args("ofPixels_< float >::getPixelIndex",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::getPixelIndex",1,"ofPixels_< float > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< float >::getPixelIndex",2,"size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< float >::getPixelIndex",3,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_getPixelIndex",1,SWIGTYPE_p_ofPixels_T_float_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - result = (size_t)((ofPixels_< float > const *)arg1)->getPixelIndex(arg2,arg3); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_getColor__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; size_t arg2 ; size_t arg3 ; ofColor_< float > result; - SWIG_check_num_args("ofPixels_< float >::getColor",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::getColor",1,"ofPixels_< float > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< float >::getColor",2,"size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< float >::getColor",3,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_getColor",1,SWIGTYPE_p_ofPixels_T_float_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - result = ((ofPixels_< float > const *)arg1)->getColor(arg2,arg3); { - ofColor_< float > * resultptr = new ofColor_< float >((const ofColor_< float > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_getColor__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; size_t arg2 ; ofColor_< float > result; - SWIG_check_num_args("ofPixels_< float >::getColor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::getColor",1,"ofPixels_< float > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< float >::getColor",2,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_getColor",1,SWIGTYPE_p_ofPixels_T_float_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - result = ((ofPixels_< float > const *)arg1)->getColor(arg2); { - ofColor_< float > * resultptr = new ofColor_< float >((const ofColor_< float > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_getColor(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_FloatPixels_getColor__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_FloatPixels_getColor__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatPixels_getColor'\n" - " Possible C/C++ prototypes are:\n" " ofPixels_< float >::getColor(size_t,size_t) const\n" - " ofPixels_< float >::getColor(size_t) const\n"); lua_error(L);return 0; } -static int _wrap_FloatPixels_setColor__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; size_t arg2 ; size_t arg3 ; ofColor_< float > *arg4 = 0 ; - SWIG_check_num_args("ofPixels_< float >::setColor",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::setColor",1,"ofPixels_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< float >::setColor",2,"size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< float >::setColor",3,"size_t"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofPixels_< float >::setColor",4,"ofColor_< float > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_setColor",1,SWIGTYPE_p_ofPixels_T_float_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_setColor",4,SWIGTYPE_p_ofColor_T_float_t); } - (arg1)->setColor(arg2,arg3,(ofColor_< float > const &)*arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FloatPixels_setColor__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; size_t arg2 ; ofColor_< float > *arg3 = 0 ; - SWIG_check_num_args("ofPixels_< float >::setColor",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::setColor",1,"ofPixels_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< float >::setColor",2,"size_t"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofPixels_< float >::setColor",3,"ofColor_< float > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_setColor",1,SWIGTYPE_p_ofPixels_T_float_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_setColor",3,SWIGTYPE_p_ofColor_T_float_t); } - (arg1)->setColor(arg2,(ofColor_< float > const &)*arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FloatPixels_setColor__SWIG_2(lua_State* L) { int SWIG_arg = 0; - ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; ofColor_< float > *arg2 = 0 ; - SWIG_check_num_args("ofPixels_< float >::setColor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::setColor",1,"ofPixels_< float > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPixels_< float >::setColor",2,"ofColor_< float > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_setColor",1,SWIGTYPE_p_ofPixels_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_setColor",2,SWIGTYPE_p_ofColor_T_float_t); } (arg1)->setColor((ofColor_< float > const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_setColor(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_FloatPixels_setColor__SWIG_2(L);} } } if (argc == 3) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_FloatPixels_setColor__SWIG_1(L);} } } } if (argc == 4) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_FloatPixels_setColor__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatPixels_setColor'\n" - " Possible C/C++ prototypes are:\n" " ofPixels_< float >::setColor(size_t,size_t,ofColor_< float > const &)\n" - " ofPixels_< float >::setColor(size_t,ofColor_< float > const &)\n" - " ofPixels_< float >::setColor(ofColor_< float > const &)\n"); lua_error(L);return 0; } -static int _wrap_FloatPixels_getWidth(lua_State* L) { int SWIG_arg = 0; ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; - size_t result; SWIG_check_num_args("ofPixels_< float >::getWidth",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::getWidth",1,"ofPixels_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_getWidth",1,SWIGTYPE_p_ofPixels_T_float_t); } - result = (size_t)((ofPixels_< float > const *)arg1)->getWidth(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_getHeight(lua_State* L) { int SWIG_arg = 0; ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; - size_t result; SWIG_check_num_args("ofPixels_< float >::getHeight",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::getHeight",1,"ofPixels_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_getHeight",1,SWIGTYPE_p_ofPixels_T_float_t); } - result = (size_t)((ofPixels_< float > const *)arg1)->getHeight(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_getBytesPerPixel(lua_State* L) { int SWIG_arg = 0; - ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; size_t result; - SWIG_check_num_args("ofPixels_< float >::getBytesPerPixel",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::getBytesPerPixel",1,"ofPixels_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_getBytesPerPixel",1,SWIGTYPE_p_ofPixels_T_float_t); } - result = (size_t)((ofPixels_< float > const *)arg1)->getBytesPerPixel(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_getBitsPerPixel(lua_State* L) { int SWIG_arg = 0; - ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; size_t result; - SWIG_check_num_args("ofPixels_< float >::getBitsPerPixel",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::getBitsPerPixel",1,"ofPixels_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_getBitsPerPixel",1,SWIGTYPE_p_ofPixels_T_float_t); } - result = (size_t)((ofPixels_< float > const *)arg1)->getBitsPerPixel(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_getBytesPerChannel(lua_State* L) { int SWIG_arg = 0; - ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; size_t result; - SWIG_check_num_args("ofPixels_< float >::getBytesPerChannel",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::getBytesPerChannel",1,"ofPixels_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_getBytesPerChannel",1,SWIGTYPE_p_ofPixels_T_float_t); } - result = (size_t)((ofPixels_< float > const *)arg1)->getBytesPerChannel(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_getBitsPerChannel(lua_State* L) { int SWIG_arg = 0; - ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; size_t result; - SWIG_check_num_args("ofPixels_< float >::getBitsPerChannel",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::getBitsPerChannel",1,"ofPixels_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_getBitsPerChannel",1,SWIGTYPE_p_ofPixels_T_float_t); } - result = (size_t)((ofPixels_< float > const *)arg1)->getBitsPerChannel(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_getBytesStride(lua_State* L) { int SWIG_arg = 0; - ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; size_t result; - SWIG_check_num_args("ofPixels_< float >::getBytesStride",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::getBytesStride",1,"ofPixels_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_getBytesStride",1,SWIGTYPE_p_ofPixels_T_float_t); } - result = (size_t)((ofPixels_< float > const *)arg1)->getBytesStride(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_getNumChannels(lua_State* L) { int SWIG_arg = 0; - ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; size_t result; - SWIG_check_num_args("ofPixels_< float >::getNumChannels",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::getNumChannels",1,"ofPixels_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_getNumChannels",1,SWIGTYPE_p_ofPixels_T_float_t); } - result = (size_t)((ofPixels_< float > const *)arg1)->getNumChannels(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_getTotalBytes(lua_State* L) { int SWIG_arg = 0; - ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; size_t result; - SWIG_check_num_args("ofPixels_< float >::getTotalBytes",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::getTotalBytes",1,"ofPixels_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_getTotalBytes",1,SWIGTYPE_p_ofPixels_T_float_t); } - result = (size_t)((ofPixels_< float > const *)arg1)->getTotalBytes(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_getNumPlanes(lua_State* L) { int SWIG_arg = 0; - ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; size_t result; - SWIG_check_num_args("ofPixels_< float >::getNumPlanes",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::getNumPlanes",1,"ofPixels_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_getNumPlanes",1,SWIGTYPE_p_ofPixels_T_float_t); } - result = (size_t)((ofPixels_< float > const *)arg1)->getNumPlanes(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_getPlane(lua_State* L) { int SWIG_arg = 0; ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; - size_t arg2 ; ofPixels_< float > result; SWIG_check_num_args("ofPixels_< float >::getPlane",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::getPlane",1,"ofPixels_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< float >::getPlane",2,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_getPlane",1,SWIGTYPE_p_ofPixels_T_float_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - result = (arg1)->getPlane(arg2); { - ofPixels_< float > * resultptr = new ofPixels_< float >((const ofPixels_< float > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofPixels_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_getChannel(lua_State* L) { int SWIG_arg = 0; ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; - size_t arg2 ; ofPixels_< float > result; SWIG_check_num_args("ofPixels_< float >::getChannel",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::getChannel",1,"ofPixels_< float > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< float >::getChannel",2,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_getChannel",1,SWIGTYPE_p_ofPixels_T_float_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - result = ((ofPixels_< float > const *)arg1)->getChannel(arg2); { - ofPixels_< float > * resultptr = new ofPixels_< float >((const ofPixels_< float > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofPixels_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_getPixelFormat(lua_State* L) { int SWIG_arg = 0; - ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; ofPixelFormat result; - SWIG_check_num_args("ofPixels_< float >::getPixelFormat",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::getPixelFormat",1,"ofPixels_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_getPixelFormat",1,SWIGTYPE_p_ofPixels_T_float_t); } - result = (ofPixelFormat)((ofPixels_< float > const *)arg1)->getPixelFormat(); - lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FloatPixels_size(lua_State* L) { int SWIG_arg = 0; ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; - size_t result; SWIG_check_num_args("ofPixels_< float >::size",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::size",1,"ofPixels_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_size",1,SWIGTYPE_p_ofPixels_T_float_t); } - result = (size_t)((ofPixels_< float > const *)arg1)->size(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_getImageType(lua_State* L) { int SWIG_arg = 0; - ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; ofImageType result; - SWIG_check_num_args("ofPixels_< float >::getImageType",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::getImageType",1,"ofPixels_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_getImageType",1,SWIGTYPE_p_ofPixels_T_float_t); } - result = (ofImageType)((ofPixels_< float > const *)arg1)->getImageType(); - lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FloatPixels_setChannel(lua_State* L) { int SWIG_arg = 0; ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; - size_t arg2 ; ofPixels_< float > arg3 ; ofPixels_< float > *argp3 ; SWIG_check_num_args("ofPixels_< float >::setChannel",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::setChannel",1,"ofPixels_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< float >::setChannel",2,"size_t"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofPixels_< float >::setChannel",3,"ofPixels_< float > const"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_setChannel",1,SWIGTYPE_p_ofPixels_T_float_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&argp3,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_setChannel",3,SWIGTYPE_p_ofPixels_T_float_t); } arg3 = *argp3; (arg1)->setChannel(arg2,arg3); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_setImageType(lua_State* L) { int SWIG_arg = 0; - ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; ofImageType arg2 ; - SWIG_check_num_args("ofPixels_< float >::setImageType",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::setImageType",1,"ofPixels_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< float >::setImageType",2,"ofImageType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_setImageType",1,SWIGTYPE_p_ofPixels_T_float_t); } arg2 = (ofImageType)(int)lua_tonumber(L, 2); - (arg1)->setImageType(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_setNumChannels(lua_State* L) { int SWIG_arg = 0; - ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; size_t arg2 ; - SWIG_check_num_args("ofPixels_< float >::setNumChannels",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::setNumChannels",1,"ofPixels_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< float >::setNumChannels",2,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_setNumChannels",1,SWIGTYPE_p_ofPixels_T_float_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - (arg1)->setNumChannels(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_FloatPixels(void *obj) { -ofPixels_< float > *arg1 = (ofPixels_< float > *) obj; -delete arg1; -} -static int _proxy__wrap_new_FloatPixels(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_FloatPixels); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_FloatPixels_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_FloatPixels_methods[]= { - { "allocate", _wrap_FloatPixels_allocate}, - { "allocatePixelFormat", _wrap_FloatPixels_allocatePixelFormat}, - { "allocateImageType", _wrap_FloatPixels_allocateImageType}, - { "isAllocated", _wrap_FloatPixels_isAllocated}, - { "clear", _wrap_FloatPixels_clear}, - { "set", _wrap_FloatPixels_set}, - { "setFromPixels", _wrap_FloatPixels_setFromPixels}, - { "setFromPixelsImageType", _wrap_FloatPixels_setFromPixelsImageType}, - { "setFromExternalPixels", _wrap_FloatPixels_setFromExternalPixels}, - { "setFromAlignedPixels", _wrap_FloatPixels_setFromAlignedPixels}, - { "swap", _wrap_FloatPixels_swap}, - { "crop", _wrap_FloatPixels_crop}, - { "cropTo", _wrap_FloatPixels_cropTo}, - { "rotate90", _wrap_FloatPixels_rotate90}, - { "rotate90To", _wrap_FloatPixels_rotate90To}, - { "mirrorTo", _wrap_FloatPixels_mirrorTo}, - { "mirror", _wrap_FloatPixels_mirror}, - { "resize", _wrap_FloatPixels_resize}, - { "resizeTo", _wrap_FloatPixels_resizeTo}, - { "pasteInto", _wrap_FloatPixels_pasteInto}, - { "blendInto", _wrap_FloatPixels_blendInto}, - { "swapRgb", _wrap_FloatPixels_swapRgb}, - { "getData", _wrap_FloatPixels_getData}, - { "getPixelIndex", _wrap_FloatPixels_getPixelIndex}, - { "getColor", _wrap_FloatPixels_getColor}, - { "setColor", _wrap_FloatPixels_setColor}, - { "getWidth", _wrap_FloatPixels_getWidth}, - { "getHeight", _wrap_FloatPixels_getHeight}, - { "getBytesPerPixel", _wrap_FloatPixels_getBytesPerPixel}, - { "getBitsPerPixel", _wrap_FloatPixels_getBitsPerPixel}, - { "getBytesPerChannel", _wrap_FloatPixels_getBytesPerChannel}, - { "getBitsPerChannel", _wrap_FloatPixels_getBitsPerChannel}, - { "getBytesStride", _wrap_FloatPixels_getBytesStride}, - { "getNumChannels", _wrap_FloatPixels_getNumChannels}, - { "getTotalBytes", _wrap_FloatPixels_getTotalBytes}, - { "getNumPlanes", _wrap_FloatPixels_getNumPlanes}, - { "getPlane", _wrap_FloatPixels_getPlane}, - { "getChannel", _wrap_FloatPixels_getChannel}, - { "getPixelFormat", _wrap_FloatPixels_getPixelFormat}, - { "size", _wrap_FloatPixels_size}, - { "getImageType", _wrap_FloatPixels_getImageType}, - { "setChannel", _wrap_FloatPixels_setChannel}, - { "setImageType", _wrap_FloatPixels_setImageType}, - { "setNumChannels", _wrap_FloatPixels_setNumChannels}, - {0,0} -}; -static swig_lua_method swig_FloatPixels_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_FloatPixels_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_FloatPixels_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_FloatPixels_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_FloatPixels_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_FloatPixels_Sf_SwigStatic = { - "FloatPixels", - swig_FloatPixels_Sf_SwigStatic_methods, - swig_FloatPixels_Sf_SwigStatic_attributes, - swig_FloatPixels_Sf_SwigStatic_constants, - swig_FloatPixels_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_FloatPixels_bases[] = {0}; -static const char *swig_FloatPixels_base_names[] = {0}; -static swig_lua_class _wrap_class_FloatPixels = { "FloatPixels", "FloatPixels", &SWIGTYPE_p_ofPixels_T_float_t,_proxy__wrap_new_FloatPixels, swig_delete_FloatPixels, swig_FloatPixels_methods, swig_FloatPixels_attributes, &swig_FloatPixels_Sf_SwigStatic, swig_FloatPixels_meta, swig_FloatPixels_bases, swig_FloatPixels_base_names }; - -static int _wrap_new_ShortPixels__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPixels_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofPixels_< unsigned short >::ofPixels_",0,0) - result = (ofPixels_< unsigned short > *)new ofPixels_< unsigned short >(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofPixels_T_unsigned_short_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_ShortPixels__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPixels_< unsigned short > *arg1 = 0 ; - ofPixels_< unsigned short > *result = 0 ; SWIG_check_num_args("ofPixels_< unsigned short >::ofPixels_",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::ofPixels_",1,"ofPixels_< unsigned short > &&"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("new_ShortPixels",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - result = (ofPixels_< unsigned short > *)new ofPixels_< unsigned short >((ofPixels_< unsigned short > &&)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofPixels_T_unsigned_short_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_ShortPixels(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_ShortPixels__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_new_ShortPixels__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_ShortPixels'\n" " Possible C/C++ prototypes are:\n" - " ofPixels_< unsigned short >::ofPixels_()\n" - " ofPixels_< unsigned short >::ofPixels_(ofPixels_< unsigned short > &&)\n"); lua_error(L);return 0; } -static int _wrap_ShortPixels_allocate(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; size_t arg2 ; size_t arg3 ; size_t arg4 ; - SWIG_check_num_args("ofPixels_< unsigned short >::allocate",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::allocate",1,"ofPixels_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::allocate",2,"size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned short >::allocate",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< unsigned short >::allocate",4,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_allocate",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (size_t)lua_tonumber(L, 4); - (arg1)->allocate(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_allocatePixelFormat(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; size_t arg2 ; size_t arg3 ; ofPixelFormat arg4 ; - SWIG_check_num_args("ofPixels_< unsigned short >::allocate",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::allocate",1,"ofPixels_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::allocate",2,"size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned short >::allocate",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< unsigned short >::allocate",4,"ofPixelFormat"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_allocatePixelFormat",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - arg4 = (ofPixelFormat)(int)lua_tonumber(L, 4); (arg1)->allocate(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_allocateImageType(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; size_t arg2 ; size_t arg3 ; ofImageType arg4 ; - SWIG_check_num_args("ofPixels_< unsigned short >::allocate",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::allocate",1,"ofPixels_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::allocate",2,"size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned short >::allocate",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< unsigned short >::allocate",4,"ofImageType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_allocateImageType",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - arg4 = (ofImageType)(int)lua_tonumber(L, 4); (arg1)->allocate(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_isAllocated(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; bool result; - SWIG_check_num_args("ofPixels_< unsigned short >::isAllocated",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::isAllocated",1,"ofPixels_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_isAllocated",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - result = (bool)((ofPixels_< unsigned short > const *)arg1)->isAllocated(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_clear(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; - SWIG_check_num_args("ofPixels_< unsigned short >::clear",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::clear",1,"ofPixels_< unsigned short > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_clear",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } (arg1)->clear(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_set__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; unsigned short arg2 ; - SWIG_check_num_args("ofPixels_< unsigned short >::set",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::set",1,"ofPixels_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::set",2,"unsigned short"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_set",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned short)lua_tonumber(L, 2); - (arg1)->set(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_set__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; size_t arg2 ; unsigned short arg3 ; - SWIG_check_num_args("ofPixels_< unsigned short >::set",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::set",1,"ofPixels_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::set",2,"size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned short >::set",3,"unsigned short"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_set",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (unsigned short)lua_tonumber(L, 3); - (arg1)->set(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_set(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_ShortPixels_set__SWIG_0(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_ShortPixels_set__SWIG_1(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortPixels_set'\n" " Possible C/C++ prototypes are:\n" - " ofPixels_< unsigned short >::set(unsigned short)\n" " ofPixels_< unsigned short >::set(size_t,unsigned short)\n"); - lua_error(L);return 0; } -static int _wrap_ShortPixels_setFromPixels(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; unsigned short *arg2 = (unsigned short *) 0 ; - size_t arg3 ; size_t arg4 ; ofPixelFormat arg5 ; SWIG_check_num_args("ofPixels_< unsigned short >::setFromPixels",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::setFromPixels",1,"ofPixels_< unsigned short > *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::setFromPixels",2,"unsigned short const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned short >::setFromPixels",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< unsigned short >::setFromPixels",4,"size_t"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPixels_< unsigned short >::setFromPixels",5,"ofPixelFormat"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_setFromPixels",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_unsigned_short,0))){ - SWIG_fail_ptr("ShortPixels_setFromPixels",2,SWIGTYPE_p_unsigned_short); } - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (size_t)lua_tonumber(L, 4); - arg5 = (ofPixelFormat)(int)lua_tonumber(L, 5); (arg1)->setFromPixels((unsigned short const *)arg2,arg3,arg4,arg5); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_setFromPixelsImageType(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; unsigned short *arg2 = (unsigned short *) 0 ; - size_t arg3 ; size_t arg4 ; ofImageType arg5 ; SWIG_check_num_args("ofPixels_< unsigned short >::setFromPixels",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::setFromPixels",1,"ofPixels_< unsigned short > *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::setFromPixels",2,"unsigned short const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned short >::setFromPixels",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< unsigned short >::setFromPixels",4,"size_t"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPixels_< unsigned short >::setFromPixels",5,"ofImageType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_setFromPixelsImageType",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_unsigned_short,0))){ - SWIG_fail_ptr("ShortPixels_setFromPixelsImageType",2,SWIGTYPE_p_unsigned_short); } - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (size_t)lua_tonumber(L, 4); - arg5 = (ofImageType)(int)lua_tonumber(L, 5); (arg1)->setFromPixels((unsigned short const *)arg2,arg3,arg4,arg5); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_setFromExternalPixels(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; unsigned short *arg2 = (unsigned short *) 0 ; - size_t arg3 ; size_t arg4 ; ofPixelFormat arg5 ; SWIG_check_num_args("ofPixels_< unsigned short >::setFromExternalPixels",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::setFromExternalPixels",1,"ofPixels_< unsigned short > *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::setFromExternalPixels",2,"unsigned short *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned short >::setFromExternalPixels",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< unsigned short >::setFromExternalPixels",4,"size_t"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPixels_< unsigned short >::setFromExternalPixels",5,"ofPixelFormat"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_setFromExternalPixels",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_unsigned_short,0))){ - SWIG_fail_ptr("ShortPixels_setFromExternalPixels",2,SWIGTYPE_p_unsigned_short); } - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (size_t)lua_tonumber(L, 4); - arg5 = (ofPixelFormat)(int)lua_tonumber(L, 5); (arg1)->setFromExternalPixels(arg2,arg3,arg4,arg5); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_setFromAlignedPixels(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; unsigned short *arg2 = (unsigned short *) 0 ; - size_t arg3 ; size_t arg4 ; ofPixelFormat arg5 ; size_t arg6 ; - SWIG_check_num_args("ofPixels_< unsigned short >::setFromAlignedPixels",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::setFromAlignedPixels",1,"ofPixels_< unsigned short > *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::setFromAlignedPixels",2,"unsigned short const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned short >::setFromAlignedPixels",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< unsigned short >::setFromAlignedPixels",4,"size_t"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPixels_< unsigned short >::setFromAlignedPixels",5,"ofPixelFormat"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPixels_< unsigned short >::setFromAlignedPixels",6,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_setFromAlignedPixels",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_unsigned_short,0))){ - SWIG_fail_ptr("ShortPixels_setFromAlignedPixels",2,SWIGTYPE_p_unsigned_short); } - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (size_t)lua_tonumber(L, 4); - arg5 = (ofPixelFormat)(int)lua_tonumber(L, 5); SWIG_contract_assert((lua_tonumber(L,6)>=0),"number must not be negative") - arg6 = (size_t)lua_tonumber(L, 6); (arg1)->setFromAlignedPixels((unsigned short const *)arg2,arg3,arg4,arg5,arg6); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_swap(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; ofPixels_< unsigned short > *arg2 = 0 ; - SWIG_check_num_args("ofPixels_< unsigned short >::swap",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::swap",1,"ofPixels_< unsigned short > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::swap",2,"ofPixels_< unsigned short > &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_swap",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_swap",2,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } (arg1)->swap(*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_crop(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; size_t arg2 ; size_t arg3 ; size_t arg4 ; - size_t arg5 ; SWIG_check_num_args("ofPixels_< unsigned short >::crop",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::crop",1,"ofPixels_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::crop",2,"size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned short >::crop",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< unsigned short >::crop",4,"size_t"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPixels_< unsigned short >::crop",5,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_crop",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (size_t)lua_tonumber(L, 4); - SWIG_contract_assert((lua_tonumber(L,5)>=0),"number must not be negative") arg5 = (size_t)lua_tonumber(L, 5); - (arg1)->crop(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_cropTo(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; ofPixels_< unsigned short > *arg2 = 0 ; size_t arg3 ; - size_t arg4 ; size_t arg5 ; size_t arg6 ; SWIG_check_num_args("ofPixels_< unsigned short >::cropTo",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::cropTo",1,"ofPixels_< unsigned short > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::cropTo",2,"ofPixels_< unsigned short > &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned short >::cropTo",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< unsigned short >::cropTo",4,"size_t"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPixels_< unsigned short >::cropTo",5,"size_t"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPixels_< unsigned short >::cropTo",6,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_cropTo",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_cropTo",2,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (size_t)lua_tonumber(L, 4); - SWIG_contract_assert((lua_tonumber(L,5)>=0),"number must not be negative") arg5 = (size_t)lua_tonumber(L, 5); - SWIG_contract_assert((lua_tonumber(L,6)>=0),"number must not be negative") arg6 = (size_t)lua_tonumber(L, 6); - ((ofPixels_< unsigned short > const *)arg1)->cropTo(*arg2,arg3,arg4,arg5,arg6); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_rotate90(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; int arg2 ; - SWIG_check_num_args("ofPixels_< unsigned short >::rotate90",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::rotate90",1,"ofPixels_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::rotate90",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_rotate90",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->rotate90(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_rotate90To(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; ofPixels_< unsigned short > *arg2 = 0 ; int arg3 ; - SWIG_check_num_args("ofPixels_< unsigned short >::rotate90To",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::rotate90To",1,"ofPixels_< unsigned short > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::rotate90To",2,"ofPixels_< unsigned short > &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned short >::rotate90To",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_rotate90To",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_rotate90To",2,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } arg3 = (int)lua_tonumber(L, 3); - ((ofPixels_< unsigned short > const *)arg1)->rotate90To(*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortPixels_mirrorTo(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; ofPixels_< unsigned short > *arg2 = 0 ; bool arg3 ; - bool arg4 ; SWIG_check_num_args("ofPixels_< unsigned short >::mirrorTo",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::mirrorTo",1,"ofPixels_< unsigned short > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::mirrorTo",2,"ofPixels_< unsigned short > &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofPixels_< unsigned short >::mirrorTo",3,"bool"); - if(!lua_isboolean(L,4)) SWIG_fail_arg("ofPixels_< unsigned short >::mirrorTo",4,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_mirrorTo",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_mirrorTo",2,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } arg3 = (lua_toboolean(L, 3)!=0); - arg4 = (lua_toboolean(L, 4)!=0); ((ofPixels_< unsigned short > const *)arg1)->mirrorTo(*arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_mirror(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; bool arg2 ; bool arg3 ; - SWIG_check_num_args("ofPixels_< unsigned short >::mirror",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::mirror",1,"ofPixels_< unsigned short > *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::mirror",2,"bool"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofPixels_< unsigned short >::mirror",3,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_mirror",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } arg2 = (lua_toboolean(L, 2)!=0); - arg3 = (lua_toboolean(L, 3)!=0); (arg1)->mirror(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortPixels_resize__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; size_t arg2 ; size_t arg3 ; - ofInterpolationMethod arg4 ; bool result; SWIG_check_num_args("ofPixels_< unsigned short >::resize",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::resize",1,"ofPixels_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::resize",2,"size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned short >::resize",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< unsigned short >::resize",4,"ofInterpolationMethod"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_resize",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - arg4 = (ofInterpolationMethod)(int)lua_tonumber(L, 4); result = (bool)(arg1)->resize(arg2,arg3,arg4); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_resize__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; size_t arg2 ; size_t arg3 ; bool result; - SWIG_check_num_args("ofPixels_< unsigned short >::resize",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::resize",1,"ofPixels_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::resize",2,"size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned short >::resize",3,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_resize",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - result = (bool)(arg1)->resize(arg2,arg3); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_resize(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_ShortPixels_resize__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_ShortPixels_resize__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortPixels_resize'\n" " Possible C/C++ prototypes are:\n" - " ofPixels_< unsigned short >::resize(size_t,size_t,ofInterpolationMethod)\n" - " ofPixels_< unsigned short >::resize(size_t,size_t)\n"); lua_error(L);return 0; } -static int _wrap_ShortPixels_resizeTo__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; ofPixels_< unsigned short > *arg2 = 0 ; - ofInterpolationMethod arg3 ; bool result; SWIG_check_num_args("ofPixels_< unsigned short >::resizeTo",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::resizeTo",1,"ofPixels_< unsigned short > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::resizeTo",2,"ofPixels_< unsigned short > &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned short >::resizeTo",3,"ofInterpolationMethod"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_resizeTo",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_resizeTo",2,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - arg3 = (ofInterpolationMethod)(int)lua_tonumber(L, 3); - result = (bool)((ofPixels_< unsigned short > const *)arg1)->resizeTo(*arg2,arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_resizeTo__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; ofPixels_< unsigned short > *arg2 = 0 ; bool result; - SWIG_check_num_args("ofPixels_< unsigned short >::resizeTo",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::resizeTo",1,"ofPixels_< unsigned short > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::resizeTo",2,"ofPixels_< unsigned short > &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_resizeTo",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_resizeTo",2,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - result = (bool)((ofPixels_< unsigned short > const *)arg1)->resizeTo(*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_resizeTo(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_ShortPixels_resizeTo__SWIG_1(L);} } } if (argc == 3) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_ShortPixels_resizeTo__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortPixels_resizeTo'\n" - " Possible C/C++ prototypes are:\n" - " ofPixels_< unsigned short >::resizeTo(ofPixels_< unsigned short > &,ofInterpolationMethod) const\n" - " ofPixels_< unsigned short >::resizeTo(ofPixels_< unsigned short > &) const\n"); lua_error(L);return 0; } -static int _wrap_ShortPixels_pasteInto(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; ofPixels_< unsigned short > *arg2 = 0 ; size_t arg3 ; - size_t arg4 ; bool result; SWIG_check_num_args("ofPixels_< unsigned short >::pasteInto",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::pasteInto",1,"ofPixels_< unsigned short > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::pasteInto",2,"ofPixels_< unsigned short > &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned short >::pasteInto",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< unsigned short >::pasteInto",4,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_pasteInto",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_pasteInto",2,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (size_t)lua_tonumber(L, 4); - result = (bool)((ofPixels_< unsigned short > const *)arg1)->pasteInto(*arg2,arg3,arg4); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_blendInto(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; ofPixels_< unsigned short > *arg2 = 0 ; size_t arg3 ; - size_t arg4 ; bool result; SWIG_check_num_args("ofPixels_< unsigned short >::blendInto",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::blendInto",1,"ofPixels_< unsigned short > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::blendInto",2,"ofPixels_< unsigned short > &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned short >::blendInto",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< unsigned short >::blendInto",4,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_blendInto",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_blendInto",2,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (size_t)lua_tonumber(L, 4); - result = (bool)((ofPixels_< unsigned short > const *)arg1)->blendInto(*arg2,arg3,arg4); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_swapRgb(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; - SWIG_check_num_args("ofPixels_< unsigned short >::swapRgb",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::swapRgb",1,"ofPixels_< unsigned short > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_swapRgb",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } (arg1)->swapRgb(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_getData__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; unsigned short *result = 0 ; - SWIG_check_num_args("ofPixels_< unsigned short >::getData",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::getData",1,"ofPixels_< unsigned short > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_getData",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - result = (unsigned short *)(arg1)->getData(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_unsigned_short,0); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_getData__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; unsigned short *result = 0 ; - SWIG_check_num_args("ofPixels_< unsigned short >::getData",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::getData",1,"ofPixels_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_getData",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - result = (unsigned short *)((ofPixels_< unsigned short > const *)arg1)->getData(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_unsigned_short,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortPixels_getData(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_ShortPixels_getData__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_ShortPixels_getData__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortPixels_getData'\n" - " Possible C/C++ prototypes are:\n" " ofPixels_< unsigned short >::getData()\n" - " ofPixels_< unsigned short >::getData() const\n"); lua_error(L);return 0; } -static int _wrap_ShortPixels_getPixelIndex(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; size_t arg2 ; size_t arg3 ; size_t result; - SWIG_check_num_args("ofPixels_< unsigned short >::getPixelIndex",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::getPixelIndex",1,"ofPixels_< unsigned short > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::getPixelIndex",2,"size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned short >::getPixelIndex",3,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_getPixelIndex",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - result = (size_t)((ofPixels_< unsigned short > const *)arg1)->getPixelIndex(arg2,arg3); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_getColor__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; size_t arg2 ; size_t arg3 ; - ofColor_< unsigned short > result; SWIG_check_num_args("ofPixels_< unsigned short >::getColor",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::getColor",1,"ofPixels_< unsigned short > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::getColor",2,"size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned short >::getColor",3,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_getColor",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - result = ((ofPixels_< unsigned short > const *)arg1)->getColor(arg2,arg3); { - ofColor_< unsigned short > * resultptr = new ofColor_< unsigned short >((const ofColor_< unsigned short > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_short_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_getColor__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; size_t arg2 ; ofColor_< unsigned short > result; - SWIG_check_num_args("ofPixels_< unsigned short >::getColor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::getColor",1,"ofPixels_< unsigned short > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::getColor",2,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_getColor",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - result = ((ofPixels_< unsigned short > const *)arg1)->getColor(arg2); { - ofColor_< unsigned short > * resultptr = new ofColor_< unsigned short >((const ofColor_< unsigned short > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_short_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_getColor(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_ShortPixels_getColor__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_ShortPixels_getColor__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortPixels_getColor'\n" - " Possible C/C++ prototypes are:\n" " ofPixels_< unsigned short >::getColor(size_t,size_t) const\n" - " ofPixels_< unsigned short >::getColor(size_t) const\n"); lua_error(L);return 0; } -static int _wrap_ShortPixels_setColor__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; size_t arg2 ; size_t arg3 ; - ofColor_< unsigned short > *arg4 = 0 ; SWIG_check_num_args("ofPixels_< unsigned short >::setColor",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::setColor",1,"ofPixels_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::setColor",2,"size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned short >::setColor",3,"size_t"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofPixels_< unsigned short >::setColor",4,"ofColor_< unsigned short > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_setColor",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_setColor",4,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - (arg1)->setColor(arg2,arg3,(ofColor_< unsigned short > const &)*arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortPixels_setColor__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; size_t arg2 ; ofColor_< unsigned short > *arg3 = 0 ; - SWIG_check_num_args("ofPixels_< unsigned short >::setColor",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::setColor",1,"ofPixels_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::setColor",2,"size_t"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofPixels_< unsigned short >::setColor",3,"ofColor_< unsigned short > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_setColor",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_setColor",3,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - (arg1)->setColor(arg2,(ofColor_< unsigned short > const &)*arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortPixels_setColor__SWIG_2(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; ofColor_< unsigned short > *arg2 = 0 ; - SWIG_check_num_args("ofPixels_< unsigned short >::setColor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::setColor",1,"ofPixels_< unsigned short > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::setColor",2,"ofColor_< unsigned short > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_setColor",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_setColor",2,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - (arg1)->setColor((ofColor_< unsigned short > const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortPixels_setColor(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_ShortPixels_setColor__SWIG_2(L);} } } if (argc == 3) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_ShortPixels_setColor__SWIG_1(L);} } } } if (argc == 4) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_ShortPixels_setColor__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortPixels_setColor'\n" - " Possible C/C++ prototypes are:\n" - " ofPixels_< unsigned short >::setColor(size_t,size_t,ofColor_< unsigned short > const &)\n" - " ofPixels_< unsigned short >::setColor(size_t,ofColor_< unsigned short > const &)\n" - " ofPixels_< unsigned short >::setColor(ofColor_< unsigned short > const &)\n"); lua_error(L);return 0; } -static int _wrap_ShortPixels_getWidth(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; size_t result; - SWIG_check_num_args("ofPixels_< unsigned short >::getWidth",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::getWidth",1,"ofPixels_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_getWidth",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - result = (size_t)((ofPixels_< unsigned short > const *)arg1)->getWidth(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_getHeight(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; size_t result; - SWIG_check_num_args("ofPixels_< unsigned short >::getHeight",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::getHeight",1,"ofPixels_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_getHeight",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - result = (size_t)((ofPixels_< unsigned short > const *)arg1)->getHeight(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_getBytesPerPixel(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; size_t result; - SWIG_check_num_args("ofPixels_< unsigned short >::getBytesPerPixel",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::getBytesPerPixel",1,"ofPixels_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_getBytesPerPixel",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - result = (size_t)((ofPixels_< unsigned short > const *)arg1)->getBytesPerPixel(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_getBitsPerPixel(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; size_t result; - SWIG_check_num_args("ofPixels_< unsigned short >::getBitsPerPixel",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::getBitsPerPixel",1,"ofPixels_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_getBitsPerPixel",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - result = (size_t)((ofPixels_< unsigned short > const *)arg1)->getBitsPerPixel(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_getBytesPerChannel(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; size_t result; - SWIG_check_num_args("ofPixels_< unsigned short >::getBytesPerChannel",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::getBytesPerChannel",1,"ofPixels_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_getBytesPerChannel",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - result = (size_t)((ofPixels_< unsigned short > const *)arg1)->getBytesPerChannel(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_getBitsPerChannel(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; size_t result; - SWIG_check_num_args("ofPixels_< unsigned short >::getBitsPerChannel",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::getBitsPerChannel",1,"ofPixels_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_getBitsPerChannel",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - result = (size_t)((ofPixels_< unsigned short > const *)arg1)->getBitsPerChannel(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_getBytesStride(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; size_t result; - SWIG_check_num_args("ofPixels_< unsigned short >::getBytesStride",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::getBytesStride",1,"ofPixels_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_getBytesStride",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - result = (size_t)((ofPixels_< unsigned short > const *)arg1)->getBytesStride(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_getNumChannels(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; size_t result; - SWIG_check_num_args("ofPixels_< unsigned short >::getNumChannels",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::getNumChannels",1,"ofPixels_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_getNumChannels",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - result = (size_t)((ofPixels_< unsigned short > const *)arg1)->getNumChannels(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_getTotalBytes(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; size_t result; - SWIG_check_num_args("ofPixels_< unsigned short >::getTotalBytes",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::getTotalBytes",1,"ofPixels_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_getTotalBytes",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - result = (size_t)((ofPixels_< unsigned short > const *)arg1)->getTotalBytes(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_getNumPlanes(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; size_t result; - SWIG_check_num_args("ofPixels_< unsigned short >::getNumPlanes",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::getNumPlanes",1,"ofPixels_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_getNumPlanes",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - result = (size_t)((ofPixels_< unsigned short > const *)arg1)->getNumPlanes(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_getPlane(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; size_t arg2 ; ofPixels_< unsigned short > result; - SWIG_check_num_args("ofPixels_< unsigned short >::getPlane",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::getPlane",1,"ofPixels_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::getPlane",2,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_getPlane",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - result = (arg1)->getPlane(arg2); { - ofPixels_< unsigned short > * resultptr = new ofPixels_< unsigned short >((const ofPixels_< unsigned short > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofPixels_T_unsigned_short_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_getChannel(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; size_t arg2 ; ofPixels_< unsigned short > result; - SWIG_check_num_args("ofPixels_< unsigned short >::getChannel",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::getChannel",1,"ofPixels_< unsigned short > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::getChannel",2,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_getChannel",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - result = ((ofPixels_< unsigned short > const *)arg1)->getChannel(arg2); { - ofPixels_< unsigned short > * resultptr = new ofPixels_< unsigned short >((const ofPixels_< unsigned short > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofPixels_T_unsigned_short_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_getPixelFormat(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; ofPixelFormat result; - SWIG_check_num_args("ofPixels_< unsigned short >::getPixelFormat",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::getPixelFormat",1,"ofPixels_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_getPixelFormat",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - result = (ofPixelFormat)((ofPixels_< unsigned short > const *)arg1)->getPixelFormat(); - lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortPixels_size(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; size_t result; - SWIG_check_num_args("ofPixels_< unsigned short >::size",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::size",1,"ofPixels_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_size",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - result = (size_t)((ofPixels_< unsigned short > const *)arg1)->size(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_getImageType(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; ofImageType result; - SWIG_check_num_args("ofPixels_< unsigned short >::getImageType",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::getImageType",1,"ofPixels_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_getImageType",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - result = (ofImageType)((ofPixels_< unsigned short > const *)arg1)->getImageType(); - lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortPixels_setChannel(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; size_t arg2 ; ofPixels_< unsigned short > arg3 ; - ofPixels_< unsigned short > *argp3 ; SWIG_check_num_args("ofPixels_< unsigned short >::setChannel",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::setChannel",1,"ofPixels_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::setChannel",2,"size_t"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofPixels_< unsigned short >::setChannel",3,"ofPixels_< unsigned short > const"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_setChannel",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&argp3,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_setChannel",3,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } arg3 = *argp3; - (arg1)->setChannel(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_setImageType(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; ofImageType arg2 ; - SWIG_check_num_args("ofPixels_< unsigned short >::setImageType",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::setImageType",1,"ofPixels_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::setImageType",2,"ofImageType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_setImageType",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - arg2 = (ofImageType)(int)lua_tonumber(L, 2); (arg1)->setImageType(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortPixels_setNumChannels(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; size_t arg2 ; - SWIG_check_num_args("ofPixels_< unsigned short >::setNumChannels",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::setNumChannels",1,"ofPixels_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::setNumChannels",2,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_setNumChannels",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - (arg1)->setNumChannels(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_ShortPixels(void *obj) { -ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) obj; -delete arg1; -} -static int _proxy__wrap_new_ShortPixels(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_ShortPixels); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_ShortPixels_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_ShortPixels_methods[]= { - { "allocate", _wrap_ShortPixels_allocate}, - { "allocatePixelFormat", _wrap_ShortPixels_allocatePixelFormat}, - { "allocateImageType", _wrap_ShortPixels_allocateImageType}, - { "isAllocated", _wrap_ShortPixels_isAllocated}, - { "clear", _wrap_ShortPixels_clear}, - { "set", _wrap_ShortPixels_set}, - { "setFromPixels", _wrap_ShortPixels_setFromPixels}, - { "setFromPixelsImageType", _wrap_ShortPixels_setFromPixelsImageType}, - { "setFromExternalPixels", _wrap_ShortPixels_setFromExternalPixels}, - { "setFromAlignedPixels", _wrap_ShortPixels_setFromAlignedPixels}, - { "swap", _wrap_ShortPixels_swap}, - { "crop", _wrap_ShortPixels_crop}, - { "cropTo", _wrap_ShortPixels_cropTo}, - { "rotate90", _wrap_ShortPixels_rotate90}, - { "rotate90To", _wrap_ShortPixels_rotate90To}, - { "mirrorTo", _wrap_ShortPixels_mirrorTo}, - { "mirror", _wrap_ShortPixels_mirror}, - { "resize", _wrap_ShortPixels_resize}, - { "resizeTo", _wrap_ShortPixels_resizeTo}, - { "pasteInto", _wrap_ShortPixels_pasteInto}, - { "blendInto", _wrap_ShortPixels_blendInto}, - { "swapRgb", _wrap_ShortPixels_swapRgb}, - { "getData", _wrap_ShortPixels_getData}, - { "getPixelIndex", _wrap_ShortPixels_getPixelIndex}, - { "getColor", _wrap_ShortPixels_getColor}, - { "setColor", _wrap_ShortPixels_setColor}, - { "getWidth", _wrap_ShortPixels_getWidth}, - { "getHeight", _wrap_ShortPixels_getHeight}, - { "getBytesPerPixel", _wrap_ShortPixels_getBytesPerPixel}, - { "getBitsPerPixel", _wrap_ShortPixels_getBitsPerPixel}, - { "getBytesPerChannel", _wrap_ShortPixels_getBytesPerChannel}, - { "getBitsPerChannel", _wrap_ShortPixels_getBitsPerChannel}, - { "getBytesStride", _wrap_ShortPixels_getBytesStride}, - { "getNumChannels", _wrap_ShortPixels_getNumChannels}, - { "getTotalBytes", _wrap_ShortPixels_getTotalBytes}, - { "getNumPlanes", _wrap_ShortPixels_getNumPlanes}, - { "getPlane", _wrap_ShortPixels_getPlane}, - { "getChannel", _wrap_ShortPixels_getChannel}, - { "getPixelFormat", _wrap_ShortPixels_getPixelFormat}, - { "size", _wrap_ShortPixels_size}, - { "getImageType", _wrap_ShortPixels_getImageType}, - { "setChannel", _wrap_ShortPixels_setChannel}, - { "setImageType", _wrap_ShortPixels_setImageType}, - { "setNumChannels", _wrap_ShortPixels_setNumChannels}, - {0,0} -}; -static swig_lua_method swig_ShortPixels_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_ShortPixels_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_ShortPixels_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_ShortPixels_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_ShortPixels_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_ShortPixels_Sf_SwigStatic = { - "ShortPixels", - swig_ShortPixels_Sf_SwigStatic_methods, - swig_ShortPixels_Sf_SwigStatic_attributes, - swig_ShortPixels_Sf_SwigStatic_constants, - swig_ShortPixels_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_ShortPixels_bases[] = {0}; -static const char *swig_ShortPixels_base_names[] = {0}; -static swig_lua_class _wrap_class_ShortPixels = { "ShortPixels", "ShortPixels", &SWIGTYPE_p_ofPixels_T_unsigned_short_t,_proxy__wrap_new_ShortPixels, swig_delete_ShortPixels, swig_ShortPixels_methods, swig_ShortPixels_attributes, &swig_ShortPixels_Sf_SwigStatic, swig_ShortPixels_meta, swig_ShortPixels_bases, swig_ShortPixels_base_names }; - -static int _wrap_new_Path(lua_State* L) { int SWIG_arg = 0; ofPath *result = 0 ; SWIG_check_num_args("ofPath::ofPath",0,0) - result = (ofPath *)new ofPath(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofPath,1); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_clear(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; - SWIG_check_num_args("ofPath::clear",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::clear",1,"ofPath *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_clear",1,SWIGTYPE_p_ofPath); } - (arg1)->clear(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_newSubPath(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; - SWIG_check_num_args("ofPath::newSubPath",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::newSubPath",1,"ofPath *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_newSubPath",1,SWIGTYPE_p_ofPath); } (arg1)->newSubPath(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Path_close(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; - SWIG_check_num_args("ofPath::close",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::close",1,"ofPath *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_close",1,SWIGTYPE_p_ofPath); } - (arg1)->close(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_lineTo__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; ofPoint *arg2 = 0 ; - SWIG_check_num_args("ofPath::lineTo",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::lineTo",1,"ofPath *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPath::lineTo",2,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_lineTo",1,SWIGTYPE_p_ofPath); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Path_lineTo",2,SWIGTYPE_p_ofVec3f); } - (arg1)->lineTo((ofPoint const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_lineTo__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofPath::lineTo",3,3) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::lineTo",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::lineTo",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::lineTo",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_lineTo",1,SWIGTYPE_p_ofPath); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); (arg1)->lineTo(arg2,arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_lineTo__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; float arg3 ; - float arg4 ; SWIG_check_num_args("ofPath::lineTo",4,4) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::lineTo",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::lineTo",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::lineTo",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPath::lineTo",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_lineTo",1,SWIGTYPE_p_ofPath); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - (arg1)->lineTo(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_lineTo(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Path_lineTo__SWIG_0(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Path_lineTo__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Path_lineTo__SWIG_2(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Path_lineTo'\n" " Possible C/C++ prototypes are:\n" - " ofPath::lineTo(ofPoint const &)\n" " ofPath::lineTo(float,float)\n" " ofPath::lineTo(float,float,float)\n"); - lua_error(L);return 0; } -static int _wrap_Path_moveTo__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; ofPoint *arg2 = 0 ; - SWIG_check_num_args("ofPath::moveTo",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::moveTo",1,"ofPath *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPath::moveTo",2,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_moveTo",1,SWIGTYPE_p_ofPath); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Path_moveTo",2,SWIGTYPE_p_ofVec3f); } - (arg1)->moveTo((ofPoint const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_moveTo__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; float arg3 ; - float arg4 ; SWIG_check_num_args("ofPath::moveTo",4,4) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::moveTo",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::moveTo",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::moveTo",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPath::moveTo",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_moveTo",1,SWIGTYPE_p_ofPath); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - (arg1)->moveTo(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_moveTo__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofPath::moveTo",3,3) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::moveTo",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::moveTo",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::moveTo",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_moveTo",1,SWIGTYPE_p_ofPath); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); (arg1)->moveTo(arg2,arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_moveTo(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Path_moveTo__SWIG_0(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Path_moveTo__SWIG_2(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Path_moveTo__SWIG_1(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Path_moveTo'\n" " Possible C/C++ prototypes are:\n" - " ofPath::moveTo(ofPoint const &)\n" " ofPath::moveTo(float,float,float)\n" " ofPath::moveTo(float,float)\n"); - lua_error(L);return 0; } -static int _wrap_Path_curveTo__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; ofPoint *arg2 = 0 ; - SWIG_check_num_args("ofPath::curveTo",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::curveTo",1,"ofPath *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPath::curveTo",2,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_curveTo",1,SWIGTYPE_p_ofPath); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Path_curveTo",2,SWIGTYPE_p_ofVec3f); } - (arg1)->curveTo((ofPoint const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_curveTo__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofPath::curveTo",3,3) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::curveTo",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::curveTo",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::curveTo",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_curveTo",1,SWIGTYPE_p_ofPath); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); (arg1)->curveTo(arg2,arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_curveTo__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; float arg3 ; - float arg4 ; SWIG_check_num_args("ofPath::curveTo",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::curveTo",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::curveTo",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::curveTo",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPath::curveTo",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_curveTo",1,SWIGTYPE_p_ofPath); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - (arg1)->curveTo(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_curveTo(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Path_curveTo__SWIG_0(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Path_curveTo__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Path_curveTo__SWIG_2(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Path_curveTo'\n" " Possible C/C++ prototypes are:\n" - " ofPath::curveTo(ofPoint const &)\n" " ofPath::curveTo(float,float)\n" " ofPath::curveTo(float,float,float)\n"); - lua_error(L);return 0; } -static int _wrap_Path_bezierTo__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; ofPoint *arg2 = 0 ; - ofPoint *arg3 = 0 ; ofPoint *arg4 = 0 ; SWIG_check_num_args("ofPath::bezierTo",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::bezierTo",1,"ofPath *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPath::bezierTo",2,"ofPoint const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofPath::bezierTo",3,"ofPoint const &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofPath::bezierTo",4,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_bezierTo",1,SWIGTYPE_p_ofPath); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Path_bezierTo",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Path_bezierTo",3,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Path_bezierTo",4,SWIGTYPE_p_ofVec3f); } - (arg1)->bezierTo((ofPoint const &)*arg2,(ofPoint const &)*arg3,(ofPoint const &)*arg4); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_bezierTo__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; float arg3 ; - float arg4 ; float arg5 ; float arg6 ; float arg7 ; SWIG_check_num_args("ofPath::bezierTo",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::bezierTo",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::bezierTo",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::bezierTo",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPath::bezierTo",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPath::bezierTo",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPath::bezierTo",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPath::bezierTo",7,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_bezierTo",1,SWIGTYPE_p_ofPath); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); - (arg1)->bezierTo(arg2,arg3,arg4,arg5,arg6,arg7); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_bezierTo__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; float arg3 ; - float arg4 ; float arg5 ; float arg6 ; float arg7 ; float arg8 ; float arg9 ; float arg10 ; - SWIG_check_num_args("ofPath::bezierTo",10,10) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::bezierTo",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::bezierTo",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::bezierTo",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPath::bezierTo",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPath::bezierTo",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPath::bezierTo",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPath::bezierTo",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofPath::bezierTo",8,"float"); - if(!lua_isnumber(L,9)) SWIG_fail_arg("ofPath::bezierTo",9,"float"); - if(!lua_isnumber(L,10)) SWIG_fail_arg("ofPath::bezierTo",10,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_bezierTo",1,SWIGTYPE_p_ofPath); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); - arg8 = (float)lua_tonumber(L, 8); arg9 = (float)lua_tonumber(L, 9); arg10 = (float)lua_tonumber(L, 10); - (arg1)->bezierTo(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Path_bezierTo(lua_State* L) { int argc; int argv[11]={ 1,2,3,4,5,6,7,8,9,10,11} ; argc = lua_gettop(L); - if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Path_bezierTo__SWIG_0(L);} } } } } if (argc == 7) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { - return _wrap_Path_bezierTo__SWIG_1(L);} } } } } } } } if (argc == 10) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { { _v = lua_isnumber(L,argv[8]); } if (_v) { { - _v = lua_isnumber(L,argv[9]); } if (_v) { return _wrap_Path_bezierTo__SWIG_2(L);} } } } } } } } - } } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Path_bezierTo'\n" - " Possible C/C++ prototypes are:\n" " ofPath::bezierTo(ofPoint const &,ofPoint const &,ofPoint const &)\n" - " ofPath::bezierTo(float,float,float,float,float,float)\n" - " ofPath::bezierTo(float,float,float,float,float,float,float,float,float)\n"); lua_error(L);return 0; } -static int _wrap_Path_quadBezierTo__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; ofPoint *arg2 = 0 ; - ofPoint *arg3 = 0 ; ofPoint *arg4 = 0 ; SWIG_check_num_args("ofPath::quadBezierTo",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::quadBezierTo",1,"ofPath *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPath::quadBezierTo",2,"ofPoint const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofPath::quadBezierTo",3,"ofPoint const &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofPath::quadBezierTo",4,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_quadBezierTo",1,SWIGTYPE_p_ofPath); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Path_quadBezierTo",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Path_quadBezierTo",3,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Path_quadBezierTo",4,SWIGTYPE_p_ofVec3f); } - (arg1)->quadBezierTo((ofPoint const &)*arg2,(ofPoint const &)*arg3,(ofPoint const &)*arg4); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_quadBezierTo__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; - float arg3 ; float arg4 ; float arg5 ; float arg6 ; float arg7 ; SWIG_check_num_args("ofPath::quadBezierTo",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::quadBezierTo",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::quadBezierTo",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::quadBezierTo",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPath::quadBezierTo",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPath::quadBezierTo",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPath::quadBezierTo",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPath::quadBezierTo",7,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_quadBezierTo",1,SWIGTYPE_p_ofPath); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); (arg1)->quadBezierTo(arg2,arg3,arg4,arg5,arg6,arg7); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_quadBezierTo__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; - float arg3 ; float arg4 ; float arg5 ; float arg6 ; float arg7 ; float arg8 ; float arg9 ; float arg10 ; - SWIG_check_num_args("ofPath::quadBezierTo",10,10) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::quadBezierTo",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::quadBezierTo",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::quadBezierTo",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPath::quadBezierTo",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPath::quadBezierTo",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPath::quadBezierTo",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPath::quadBezierTo",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofPath::quadBezierTo",8,"float"); - if(!lua_isnumber(L,9)) SWIG_fail_arg("ofPath::quadBezierTo",9,"float"); - if(!lua_isnumber(L,10)) SWIG_fail_arg("ofPath::quadBezierTo",10,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_quadBezierTo",1,SWIGTYPE_p_ofPath); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (float)lua_tonumber(L, 8); - arg9 = (float)lua_tonumber(L, 9); arg10 = (float)lua_tonumber(L, 10); - (arg1)->quadBezierTo(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Path_quadBezierTo(lua_State* L) { int argc; int argv[11]={ 1,2,3,4,5,6,7,8,9,10,11} ; argc = lua_gettop(L); - if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Path_quadBezierTo__SWIG_0(L);} } } } } if (argc == 7) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { - return _wrap_Path_quadBezierTo__SWIG_1(L);} } } } } } } } if (argc == 10) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { { _v = lua_isnumber(L,argv[8]); } if (_v) { { - _v = lua_isnumber(L,argv[9]); } if (_v) { return _wrap_Path_quadBezierTo__SWIG_2(L);} } } } } } } - } } } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Path_quadBezierTo'\n" - " Possible C/C++ prototypes are:\n" " ofPath::quadBezierTo(ofPoint const &,ofPoint const &,ofPoint const &)\n" - " ofPath::quadBezierTo(float,float,float,float,float,float)\n" - " ofPath::quadBezierTo(float,float,float,float,float,float,float,float,float)\n"); lua_error(L);return 0; } -static int _wrap_Path_arc__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; ofPoint *arg2 = 0 ; - float arg3 ; float arg4 ; float arg5 ; float arg6 ; SWIG_check_num_args("ofPath::arc",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::arc",1,"ofPath *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPath::arc",2,"ofPoint const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::arc",3,"float"); if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPath::arc",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPath::arc",5,"float"); if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPath::arc",6,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_arc",1,SWIGTYPE_p_ofPath); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Path_arc",2,SWIGTYPE_p_ofVec3f); } - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); (arg1)->arc((ofPoint const &)*arg2,arg3,arg4,arg5,arg6); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_arc__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; ofPoint *arg2 = 0 ; - float arg3 ; float arg4 ; float arg5 ; float arg6 ; bool arg7 ; SWIG_check_num_args("ofPath::arc",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::arc",1,"ofPath *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPath::arc",2,"ofPoint const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::arc",3,"float"); if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPath::arc",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPath::arc",5,"float"); if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPath::arc",6,"float"); - if(!lua_isboolean(L,7)) SWIG_fail_arg("ofPath::arc",7,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_arc",1,SWIGTYPE_p_ofPath); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Path_arc",2,SWIGTYPE_p_ofVec3f); } - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (lua_toboolean(L, 7)!=0); - (arg1)->arc((ofPoint const &)*arg2,arg3,arg4,arg5,arg6,arg7); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Path_arc__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; float arg3 ; - float arg4 ; float arg5 ; float arg6 ; float arg7 ; SWIG_check_num_args("ofPath::arc",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::arc",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::arc",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::arc",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPath::arc",4,"float"); if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPath::arc",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPath::arc",6,"float"); if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPath::arc",7,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_arc",1,SWIGTYPE_p_ofPath); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); - (arg1)->arc(arg2,arg3,arg4,arg5,arg6,arg7); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_arc__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; float arg3 ; - float arg4 ; float arg5 ; float arg6 ; float arg7 ; float arg8 ; SWIG_check_num_args("ofPath::arc",8,8) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::arc",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::arc",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::arc",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPath::arc",4,"float"); if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPath::arc",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPath::arc",6,"float"); if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPath::arc",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofPath::arc",8,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_arc",1,SWIGTYPE_p_ofPath); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); - arg8 = (float)lua_tonumber(L, 8); (arg1)->arc(arg2,arg3,arg4,arg5,arg6,arg7,arg8); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Path_arc(lua_State* L) { int argc; int argv[9]={ 1,2,3,4,5,6,7,8,9} ; argc = lua_gettop(L); if (argc == 6) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { - return _wrap_Path_arc__SWIG_0(L);} } } } } } } if (argc == 7) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { { - _v = lua_isboolean(L,argv[6]); } if (_v) { return _wrap_Path_arc__SWIG_1(L);} } } } } } } } - if (argc == 7) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { - return _wrap_Path_arc__SWIG_2(L);} } } } } } } } if (argc == 8) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { return _wrap_Path_arc__SWIG_3(L);} } } } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Path_arc'\n" " Possible C/C++ prototypes are:\n" - " ofPath::arc(ofPoint const &,float,float,float,float)\n" " ofPath::arc(ofPoint const &,float,float,float,float,bool)\n" - " ofPath::arc(float,float,float,float,float,float)\n" " ofPath::arc(float,float,float,float,float,float,float)\n"); - lua_error(L);return 0; } -static int _wrap_Path_arcNegative__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; ofPoint *arg2 = 0 ; - float arg3 ; float arg4 ; float arg5 ; float arg6 ; SWIG_check_num_args("ofPath::arcNegative",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::arcNegative",1,"ofPath *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPath::arcNegative",2,"ofPoint const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::arcNegative",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPath::arcNegative",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPath::arcNegative",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPath::arcNegative",6,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_arcNegative",1,SWIGTYPE_p_ofPath); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Path_arcNegative",2,SWIGTYPE_p_ofVec3f); } arg3 = (float)lua_tonumber(L, 3); - arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); - (arg1)->arcNegative((ofPoint const &)*arg2,arg3,arg4,arg5,arg6); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Path_arcNegative__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; - float arg3 ; float arg4 ; float arg5 ; float arg6 ; float arg7 ; SWIG_check_num_args("ofPath::arcNegative",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::arcNegative",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::arcNegative",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::arcNegative",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPath::arcNegative",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPath::arcNegative",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPath::arcNegative",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPath::arcNegative",7,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_arcNegative",1,SWIGTYPE_p_ofPath); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); (arg1)->arcNegative(arg2,arg3,arg4,arg5,arg6,arg7); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_arcNegative__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; - float arg3 ; float arg4 ; float arg5 ; float arg6 ; float arg7 ; float arg8 ; SWIG_check_num_args("ofPath::arcNegative",8,8) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::arcNegative",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::arcNegative",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::arcNegative",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPath::arcNegative",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPath::arcNegative",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPath::arcNegative",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPath::arcNegative",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofPath::arcNegative",8,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_arcNegative",1,SWIGTYPE_p_ofPath); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (float)lua_tonumber(L, 8); - (arg1)->arcNegative(arg2,arg3,arg4,arg5,arg6,arg7,arg8); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Path_arcNegative(lua_State* L) { int argc; int argv[9]={ 1,2,3,4,5,6,7,8,9} ; argc = lua_gettop(L); - if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { - return _wrap_Path_arcNegative__SWIG_0(L);} } } } } } } if (argc == 7) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { - return _wrap_Path_arcNegative__SWIG_1(L);} } } } } } } } if (argc == 8) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { return _wrap_Path_arcNegative__SWIG_2(L);} } } } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Path_arcNegative'\n" " Possible C/C++ prototypes are:\n" - " ofPath::arcNegative(ofPoint const &,float,float,float,float)\n" - " ofPath::arcNegative(float,float,float,float,float,float)\n" - " ofPath::arcNegative(float,float,float,float,float,float,float)\n"); lua_error(L);return 0; } -static int _wrap_Path_triangle__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; float arg3 ; - float arg4 ; float arg5 ; float arg6 ; float arg7 ; SWIG_check_num_args("ofPath::triangle",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::triangle",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::triangle",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::triangle",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPath::triangle",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPath::triangle",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPath::triangle",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPath::triangle",7,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_triangle",1,SWIGTYPE_p_ofPath); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); - (arg1)->triangle(arg2,arg3,arg4,arg5,arg6,arg7); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_triangle__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; float arg3 ; - float arg4 ; float arg5 ; float arg6 ; float arg7 ; float arg8 ; float arg9 ; float arg10 ; - SWIG_check_num_args("ofPath::triangle",10,10) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::triangle",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::triangle",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::triangle",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPath::triangle",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPath::triangle",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPath::triangle",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPath::triangle",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofPath::triangle",8,"float"); - if(!lua_isnumber(L,9)) SWIG_fail_arg("ofPath::triangle",9,"float"); - if(!lua_isnumber(L,10)) SWIG_fail_arg("ofPath::triangle",10,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_triangle",1,SWIGTYPE_p_ofPath); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); - arg8 = (float)lua_tonumber(L, 8); arg9 = (float)lua_tonumber(L, 9); arg10 = (float)lua_tonumber(L, 10); - (arg1)->triangle(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Path_triangle__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; ofPoint *arg2 = 0 ; - ofPoint *arg3 = 0 ; ofPoint *arg4 = 0 ; SWIG_check_num_args("ofPath::triangle",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::triangle",1,"ofPath *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPath::triangle",2,"ofPoint const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofPath::triangle",3,"ofPoint const &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofPath::triangle",4,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_triangle",1,SWIGTYPE_p_ofPath); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Path_triangle",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Path_triangle",3,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Path_triangle",4,SWIGTYPE_p_ofVec3f); } - (arg1)->triangle((ofPoint const &)*arg2,(ofPoint const &)*arg3,(ofPoint const &)*arg4); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_triangle(lua_State* L) { int argc; int argv[11]={ 1,2,3,4,5,6,7,8,9,10,11} ; argc = lua_gettop(L); - if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Path_triangle__SWIG_2(L);} } } } } if (argc == 7) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { - return _wrap_Path_triangle__SWIG_0(L);} } } } } } } } if (argc == 10) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { { _v = lua_isnumber(L,argv[8]); } if (_v) { { - _v = lua_isnumber(L,argv[9]); } if (_v) { return _wrap_Path_triangle__SWIG_1(L);} } } } } } } } - } } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Path_triangle'\n" - " Possible C/C++ prototypes are:\n" " ofPath::triangle(float,float,float,float,float,float)\n" - " ofPath::triangle(float,float,float,float,float,float,float,float,float)\n" - " ofPath::triangle(ofPoint const &,ofPoint const &,ofPoint const &)\n"); lua_error(L);return 0; } -static int _wrap_Path_circle__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; float arg3 ; - float arg4 ; SWIG_check_num_args("ofPath::circle",4,4) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::circle",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::circle",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::circle",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPath::circle",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_circle",1,SWIGTYPE_p_ofPath); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - (arg1)->circle(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_circle__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; float arg3 ; - float arg4 ; float arg5 ; SWIG_check_num_args("ofPath::circle",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::circle",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::circle",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::circle",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPath::circle",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPath::circle",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_circle",1,SWIGTYPE_p_ofPath); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); (arg1)->circle(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Path_circle__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; ofPoint *arg2 = 0 ; - float arg3 ; SWIG_check_num_args("ofPath::circle",3,3) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::circle",1,"ofPath *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPath::circle",2,"ofPoint const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::circle",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_circle",1,SWIGTYPE_p_ofPath); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Path_circle",2,SWIGTYPE_p_ofVec3f); } - arg3 = (float)lua_tonumber(L, 3); (arg1)->circle((ofPoint const &)*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Path_circle(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Path_circle__SWIG_2(L);} } } - } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Path_circle__SWIG_0(L);} } } } } if (argc == 5) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Path_circle__SWIG_1(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Path_circle'\n" " Possible C/C++ prototypes are:\n" - " ofPath::circle(float,float,float)\n" " ofPath::circle(float,float,float,float)\n" - " ofPath::circle(ofPoint const &,float)\n"); lua_error(L);return 0; } -static int _wrap_Path_ellipse__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; float arg3 ; - float arg4 ; float arg5 ; SWIG_check_num_args("ofPath::ellipse",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::ellipse",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::ellipse",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::ellipse",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPath::ellipse",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPath::ellipse",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_ellipse",1,SWIGTYPE_p_ofPath); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); (arg1)->ellipse(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Path_ellipse__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; float arg3 ; - float arg4 ; float arg5 ; float arg6 ; SWIG_check_num_args("ofPath::ellipse",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::ellipse",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::ellipse",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::ellipse",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPath::ellipse",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPath::ellipse",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPath::ellipse",6,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_ellipse",1,SWIGTYPE_p_ofPath); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); (arg1)->ellipse(arg2,arg3,arg4,arg5,arg6); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_ellipse__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; ofPoint *arg2 = 0 ; - float arg3 ; float arg4 ; SWIG_check_num_args("ofPath::ellipse",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::ellipse",1,"ofPath *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPath::ellipse",2,"ofPoint const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::ellipse",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPath::ellipse",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_ellipse",1,SWIGTYPE_p_ofPath); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Path_ellipse",2,SWIGTYPE_p_ofVec3f); } - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); (arg1)->ellipse((ofPoint const &)*arg2,arg3,arg4); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_ellipse(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); if (argc == 4) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Path_ellipse__SWIG_2(L);} } } } } if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Path_ellipse__SWIG_0(L);} } } } } } if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { return _wrap_Path_ellipse__SWIG_1(L);} } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Path_ellipse'\n" " Possible C/C++ prototypes are:\n" - " ofPath::ellipse(float,float,float,float)\n" " ofPath::ellipse(float,float,float,float,float)\n" - " ofPath::ellipse(ofPoint const &,float,float)\n"); lua_error(L);return 0; } -static int _wrap_Path_rectangle__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; ofRectangle *arg2 = 0 ; - SWIG_check_num_args("ofPath::rectangle",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::rectangle",1,"ofPath *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPath::rectangle",2,"ofRectangle const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_rectangle",1,SWIGTYPE_p_ofPath); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Path_rectangle",2,SWIGTYPE_p_ofRectangle); } (arg1)->rectangle((ofRectangle const &)*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_rectangle__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; ofPoint *arg2 = 0 ; - float arg3 ; float arg4 ; SWIG_check_num_args("ofPath::rectangle",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::rectangle",1,"ofPath *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPath::rectangle",2,"ofPoint const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::rectangle",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPath::rectangle",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_rectangle",1,SWIGTYPE_p_ofPath); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Path_rectangle",2,SWIGTYPE_p_ofVec3f); } arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - (arg1)->rectangle((ofPoint const &)*arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_rectangle__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; - float arg3 ; float arg4 ; float arg5 ; SWIG_check_num_args("ofPath::rectangle",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::rectangle",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::rectangle",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::rectangle",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPath::rectangle",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPath::rectangle",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_rectangle",1,SWIGTYPE_p_ofPath); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); (arg1)->rectangle(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Path_rectangle__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; - float arg3 ; float arg4 ; float arg5 ; float arg6 ; SWIG_check_num_args("ofPath::rectangle",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::rectangle",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::rectangle",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::rectangle",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPath::rectangle",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPath::rectangle",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPath::rectangle",6,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_rectangle",1,SWIGTYPE_p_ofPath); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); (arg1)->rectangle(arg2,arg3,arg4,arg5,arg6); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_rectangle(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Path_rectangle__SWIG_0(L);} } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Path_rectangle__SWIG_1(L);} } } } } if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Path_rectangle__SWIG_2(L);} } } } } } if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { return _wrap_Path_rectangle__SWIG_3(L);} } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Path_rectangle'\n" " Possible C/C++ prototypes are:\n" - " ofPath::rectangle(ofRectangle const &)\n" " ofPath::rectangle(ofPoint const &,float,float)\n" - " ofPath::rectangle(float,float,float,float)\n" " ofPath::rectangle(float,float,float,float,float)\n"); - lua_error(L);return 0; } -static int _wrap_Path_rectRounded__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; - ofRectangle *arg2 = 0 ; float arg3 ; SWIG_check_num_args("ofPath::rectRounded",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::rectRounded",1,"ofPath *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPath::rectRounded",2,"ofRectangle const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::rectRounded",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_rectRounded",1,SWIGTYPE_p_ofPath); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Path_rectRounded",2,SWIGTYPE_p_ofRectangle); } arg3 = (float)lua_tonumber(L, 3); - (arg1)->rectRounded((ofRectangle const &)*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_rectRounded__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; ofPoint *arg2 = 0 ; - float arg3 ; float arg4 ; float arg5 ; SWIG_check_num_args("ofPath::rectRounded",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::rectRounded",1,"ofPath *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPath::rectRounded",2,"ofPoint const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::rectRounded",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPath::rectRounded",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPath::rectRounded",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_rectRounded",1,SWIGTYPE_p_ofPath); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Path_rectRounded",2,SWIGTYPE_p_ofVec3f); } arg3 = (float)lua_tonumber(L, 3); - arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - (arg1)->rectRounded((ofPoint const &)*arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Path_rectRounded__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; - float arg3 ; float arg4 ; float arg5 ; float arg6 ; SWIG_check_num_args("ofPath::rectRounded",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::rectRounded",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::rectRounded",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::rectRounded",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPath::rectRounded",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPath::rectRounded",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPath::rectRounded",6,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_rectRounded",1,SWIGTYPE_p_ofPath); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); (arg1)->rectRounded(arg2,arg3,arg4,arg5,arg6); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Path_rectRounded__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; ofPoint *arg2 = 0 ; - float arg3 ; float arg4 ; float arg5 ; float arg6 ; float arg7 ; float arg8 ; SWIG_check_num_args("ofPath::rectRounded",8,8) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::rectRounded",1,"ofPath *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPath::rectRounded",2,"ofPoint const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::rectRounded",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPath::rectRounded",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPath::rectRounded",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPath::rectRounded",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPath::rectRounded",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofPath::rectRounded",8,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_rectRounded",1,SWIGTYPE_p_ofPath); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Path_rectRounded",2,SWIGTYPE_p_ofVec3f); } arg3 = (float)lua_tonumber(L, 3); - arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); - arg7 = (float)lua_tonumber(L, 7); arg8 = (float)lua_tonumber(L, 8); - (arg1)->rectRounded((ofPoint const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Path_rectRounded__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; - ofRectangle *arg2 = 0 ; float arg3 ; float arg4 ; float arg5 ; float arg6 ; SWIG_check_num_args("ofPath::rectRounded",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::rectRounded",1,"ofPath *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPath::rectRounded",2,"ofRectangle const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::rectRounded",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPath::rectRounded",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPath::rectRounded",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPath::rectRounded",6,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_rectRounded",1,SWIGTYPE_p_ofPath); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Path_rectRounded",2,SWIGTYPE_p_ofRectangle); } arg3 = (float)lua_tonumber(L, 3); - arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); - (arg1)->rectRounded((ofRectangle const &)*arg2,arg3,arg4,arg5,arg6); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Path_rectRounded__SWIG_5(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; - float arg3 ; float arg4 ; float arg5 ; float arg6 ; float arg7 ; float arg8 ; float arg9 ; float arg10 ; - SWIG_check_num_args("ofPath::rectRounded",10,10) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::rectRounded",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::rectRounded",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::rectRounded",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPath::rectRounded",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPath::rectRounded",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPath::rectRounded",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPath::rectRounded",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofPath::rectRounded",8,"float"); - if(!lua_isnumber(L,9)) SWIG_fail_arg("ofPath::rectRounded",9,"float"); - if(!lua_isnumber(L,10)) SWIG_fail_arg("ofPath::rectRounded",10,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_rectRounded",1,SWIGTYPE_p_ofPath); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (float)lua_tonumber(L, 8); - arg9 = (float)lua_tonumber(L, 9); arg10 = (float)lua_tonumber(L, 10); - (arg1)->rectRounded(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Path_rectRounded(lua_State* L) { int argc; int argv[11]={ 1,2,3,4,5,6,7,8,9,10,11} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Path_rectRounded__SWIG_0(L);} - } } } if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_Path_rectRounded__SWIG_1(L);} } } } } } - if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { - return _wrap_Path_rectRounded__SWIG_4(L);} } } } } } } if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { return _wrap_Path_rectRounded__SWIG_2(L);} } } } } } } - if (argc == 8) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { { - _v = lua_isnumber(L,argv[6]); } if (_v) { { _v = lua_isnumber(L,argv[7]); } if (_v) { - return _wrap_Path_rectRounded__SWIG_3(L);} } } } } } } } } if (argc == 10) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { { _v = lua_isnumber(L,argv[8]); } if (_v) { { - _v = lua_isnumber(L,argv[9]); } if (_v) { return _wrap_Path_rectRounded__SWIG_5(L);} } } } } } } - } } } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Path_rectRounded'\n" - " Possible C/C++ prototypes are:\n" " ofPath::rectRounded(ofRectangle const &,float)\n" - " ofPath::rectRounded(ofPoint const &,float,float,float)\n" " ofPath::rectRounded(float,float,float,float,float)\n" - " ofPath::rectRounded(ofPoint const &,float,float,float,float,float,float)\n" - " ofPath::rectRounded(ofRectangle const &,float,float,float,float)\n" - " ofPath::rectRounded(float,float,float,float,float,float,float,float,float)\n"); lua_error(L);return 0; } -static int _wrap_Path_setPolyWindingMode(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; - ofPolyWindingMode arg2 ; SWIG_check_num_args("ofPath::setPolyWindingMode",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::setPolyWindingMode",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::setPolyWindingMode",2,"ofPolyWindingMode"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_setPolyWindingMode",1,SWIGTYPE_p_ofPath); } arg2 = (ofPolyWindingMode)(int)lua_tonumber(L, 2); - (arg1)->setPolyWindingMode(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_getWindingMode(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; ofPolyWindingMode result; - SWIG_check_num_args("ofPath::getWindingMode",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::getWindingMode",1,"ofPath const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_getWindingMode",1,SWIGTYPE_p_ofPath); } - result = (ofPolyWindingMode)((ofPath const *)arg1)->getWindingMode(); - lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Path_setFilled(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; bool arg2 ; - SWIG_check_num_args("ofPath::setFilled",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::setFilled",1,"ofPath *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofPath::setFilled",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_setFilled",1,SWIGTYPE_p_ofPath); } - arg2 = (lua_toboolean(L, 2)!=0); (arg1)->setFilled(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Path_setStrokeWidth(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; - SWIG_check_num_args("ofPath::setStrokeWidth",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::setStrokeWidth",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::setStrokeWidth",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_setStrokeWidth",1,SWIGTYPE_p_ofPath); } arg2 = (float)lua_tonumber(L, 2); (arg1)->setStrokeWidth(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_setColor(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; ofColor *arg2 = 0 ; - SWIG_check_num_args("ofPath::setColor",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::setColor",1,"ofPath *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPath::setColor",2,"ofColor const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_setColor",1,SWIGTYPE_p_ofPath); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Path_setColor",2,SWIGTYPE_p_ofColor_T_unsigned_char_t); } (arg1)->setColor((ofColor const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_setHexColor(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; int arg2 ; - SWIG_check_num_args("ofPath::setHexColor",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::setHexColor",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::setHexColor",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_setHexColor",1,SWIGTYPE_p_ofPath); } arg2 = (int)lua_tonumber(L, 2); (arg1)->setHexColor(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_setFillColor(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; ofColor *arg2 = 0 ; - SWIG_check_num_args("ofPath::setFillColor",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::setFillColor",1,"ofPath *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPath::setFillColor",2,"ofColor const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_setFillColor",1,SWIGTYPE_p_ofPath); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Path_setFillColor",2,SWIGTYPE_p_ofColor_T_unsigned_char_t); } (arg1)->setFillColor((ofColor const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_setFillHexColor(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; int arg2 ; - SWIG_check_num_args("ofPath::setFillHexColor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::setFillHexColor",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::setFillHexColor",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_setFillHexColor",1,SWIGTYPE_p_ofPath); } arg2 = (int)lua_tonumber(L, 2); (arg1)->setFillHexColor(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_setStrokeColor(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; ofColor *arg2 = 0 ; - SWIG_check_num_args("ofPath::setStrokeColor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::setStrokeColor",1,"ofPath *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPath::setStrokeColor",2,"ofColor const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_setStrokeColor",1,SWIGTYPE_p_ofPath); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Path_setStrokeColor",2,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - (arg1)->setStrokeColor((ofColor const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_setStrokeHexColor(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; int arg2 ; - SWIG_check_num_args("ofPath::setStrokeHexColor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::setStrokeHexColor",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::setStrokeHexColor",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_setStrokeHexColor",1,SWIGTYPE_p_ofPath); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->setStrokeHexColor(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_isFilled(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; bool result; - SWIG_check_num_args("ofPath::isFilled",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::isFilled",1,"ofPath const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_isFilled",1,SWIGTYPE_p_ofPath); } - result = (bool)((ofPath const *)arg1)->isFilled(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_getFillColor(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; ofColor result; - SWIG_check_num_args("ofPath::getFillColor",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::getFillColor",1,"ofPath const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_getFillColor",1,SWIGTYPE_p_ofPath); } result = ((ofPath const *)arg1)->getFillColor(); { - ofColor * resultptr = new ofColor((const ofColor &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_getStrokeColor(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; ofColor result; - SWIG_check_num_args("ofPath::getStrokeColor",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::getStrokeColor",1,"ofPath const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_getStrokeColor",1,SWIGTYPE_p_ofPath); } result = ((ofPath const *)arg1)->getStrokeColor(); { - ofColor * resultptr = new ofColor((const ofColor &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_getStrokeWidth(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float result; - SWIG_check_num_args("ofPath::getStrokeWidth",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::getStrokeWidth",1,"ofPath const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_getStrokeWidth",1,SWIGTYPE_p_ofPath); } result = (float)((ofPath const *)arg1)->getStrokeWidth(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_hasOutline(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; bool result; - SWIG_check_num_args("ofPath::hasOutline",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::hasOutline",1,"ofPath const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_hasOutline",1,SWIGTYPE_p_ofPath); } result = (bool)((ofPath const *)arg1)->hasOutline(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_setCurveResolution(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; int arg2 ; - SWIG_check_num_args("ofPath::setCurveResolution",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::setCurveResolution",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::setCurveResolution",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_setCurveResolution",1,SWIGTYPE_p_ofPath); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->setCurveResolution(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_getCurveResolution(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; int result; - SWIG_check_num_args("ofPath::getCurveResolution",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::getCurveResolution",1,"ofPath const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_getCurveResolution",1,SWIGTYPE_p_ofPath); } result = (int)((ofPath const *)arg1)->getCurveResolution(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_setCircleResolution(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; int arg2 ; - SWIG_check_num_args("ofPath::setCircleResolution",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::setCircleResolution",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::setCircleResolution",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_setCircleResolution",1,SWIGTYPE_p_ofPath); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->setCircleResolution(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_getCircleResolution(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; int result; - SWIG_check_num_args("ofPath::getCircleResolution",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::getCircleResolution",1,"ofPath const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_getCircleResolution",1,SWIGTYPE_p_ofPath); } - result = (int)((ofPath const *)arg1)->getCircleResolution(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_setUseShapeColor(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; bool arg2 ; - SWIG_check_num_args("ofPath::setUseShapeColor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::setUseShapeColor",1,"ofPath *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofPath::setUseShapeColor",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_setUseShapeColor",1,SWIGTYPE_p_ofPath); } arg2 = (lua_toboolean(L, 2)!=0); - (arg1)->setUseShapeColor(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_getUseShapeColor(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; bool result; - SWIG_check_num_args("ofPath::getUseShapeColor",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::getUseShapeColor",1,"ofPath const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_getUseShapeColor",1,SWIGTYPE_p_ofPath); } result = (bool)((ofPath const *)arg1)->getUseShapeColor(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_draw__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; - SWIG_check_num_args("ofPath::draw",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::draw",1,"ofPath const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_draw",1,SWIGTYPE_p_ofPath); } - ((ofPath const *)arg1)->draw(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_draw__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofPath::draw",3,3) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::draw",1,"ofPath const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::draw",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::draw",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_draw",1,SWIGTYPE_p_ofPath); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); ((ofPath const *)arg1)->draw(arg2,arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_draw(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Path_draw__SWIG_0(L);} } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Path_draw__SWIG_1(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Path_draw'\n" " Possible C/C++ prototypes are:\n" - " ofPath::draw() const\n" " ofPath::draw(float,float) const\n"); lua_error(L);return 0; } -static int _wrap_Path_getOutline(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; - std::vector< ofPolyline > *result = 0 ; SWIG_check_num_args("ofPath::getOutline",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::getOutline",1,"ofPath const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_getOutline",1,SWIGTYPE_p_ofPath); } - result = (std::vector< ofPolyline > *) &((ofPath const *)arg1)->getOutline(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofPolyline_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Path_tessellate(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; - SWIG_check_num_args("ofPath::tessellate",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::tessellate",1,"ofPath *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_tessellate",1,SWIGTYPE_p_ofPath); } (arg1)->tessellate(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Path_getTessellation(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; ofMesh *result = 0 ; - SWIG_check_num_args("ofPath::getTessellation",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::getTessellation",1,"ofPath const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_getTessellation",1,SWIGTYPE_p_ofPath); } - result = (ofMesh *) &((ofPath const *)arg1)->getTessellation(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMesh,0); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_simplify__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; - SWIG_check_num_args("ofPath::simplify",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::simplify",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::simplify",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_simplify",1,SWIGTYPE_p_ofPath); } - arg2 = (float)lua_tonumber(L, 2); (arg1)->simplify(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Path_simplify__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; - SWIG_check_num_args("ofPath::simplify",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::simplify",1,"ofPath *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_simplify",1,SWIGTYPE_p_ofPath); } - (arg1)->simplify(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_simplify(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Path_simplify__SWIG_1(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Path_simplify__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Path_simplify'\n" " Possible C/C++ prototypes are:\n" - " ofPath::simplify(float)\n" " ofPath::simplify()\n"); lua_error(L);return 0; } -static int _wrap_Path_translate(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; ofPoint *arg2 = 0 ; - SWIG_check_num_args("ofPath::translate",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::translate",1,"ofPath *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPath::translate",2,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_translate",1,SWIGTYPE_p_ofPath); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Path_translate",2,SWIGTYPE_p_ofVec3f); } (arg1)->translate((ofPoint const &)*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_rotate(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; ofVec3f *arg3 = 0 ; - SWIG_check_num_args("ofPath::rotate",3,3) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::rotate",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::rotate",2,"float"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofPath::rotate",3,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_rotate",1,SWIGTYPE_p_ofPath); } - arg2 = (float)lua_tonumber(L, 2); if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Path_rotate",3,SWIGTYPE_p_ofVec3f); } (arg1)->rotate(arg2,(ofVec3f const &)*arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_scale(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofPath::scale",3,3) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::scale",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::scale",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::scale",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_scale",1,SWIGTYPE_p_ofPath); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); (arg1)->scale(arg2,arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_append(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; ofPath *arg2 = 0 ; - SWIG_check_num_args("ofPath::append",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::append",1,"ofPath *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPath::append",2,"ofPath const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_append",1,SWIGTYPE_p_ofPath); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_append",2,SWIGTYPE_p_ofPath); } - (arg1)->append((ofPath const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_setMode(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; ofPath::Mode arg2 ; - SWIG_check_num_args("ofPath::setMode",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::setMode",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::setMode",2,"ofPath::Mode"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_setMode",1,SWIGTYPE_p_ofPath); } - arg2 = (ofPath::Mode)(int)lua_tonumber(L, 2); (arg1)->setMode(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Path_getMode(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; ofPath::Mode result; - SWIG_check_num_args("ofPath::getMode",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::getMode",1,"ofPath *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_getMode",1,SWIGTYPE_p_ofPath); } - result = (ofPath::Mode)(arg1)->getMode(); lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_getCommands__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; - std::vector< ofPath::Command > *result = 0 ; SWIG_check_num_args("ofPath::getCommands",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::getCommands",1,"ofPath *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_getCommands",1,SWIGTYPE_p_ofPath); } - result = (std::vector< ofPath::Command > *) &(arg1)->getCommands(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofPath__Command_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Path_getCommands__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; - std::vector< ofPath::Command > *result = 0 ; SWIG_check_num_args("ofPath::getCommands",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::getCommands",1,"ofPath const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_getCommands",1,SWIGTYPE_p_ofPath); } - result = (std::vector< ofPath::Command > *) &((ofPath const *)arg1)->getCommands(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofPath__Command_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Path_getCommands(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Path_getCommands__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Path_getCommands__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Path_getCommands'\n" " Possible C/C++ prototypes are:\n" - " ofPath::getCommands()\n" " ofPath::getCommands() const\n"); lua_error(L);return 0; } -static void swig_delete_Path(void *obj) { -ofPath *arg1 = (ofPath *) obj; -delete arg1; -} -static int _proxy__wrap_new_Path(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_Path); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_Path_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_Path_methods[]= { - { "clear", _wrap_Path_clear}, - { "newSubPath", _wrap_Path_newSubPath}, - { "close", _wrap_Path_close}, - { "lineTo", _wrap_Path_lineTo}, - { "moveTo", _wrap_Path_moveTo}, - { "curveTo", _wrap_Path_curveTo}, - { "bezierTo", _wrap_Path_bezierTo}, - { "quadBezierTo", _wrap_Path_quadBezierTo}, - { "arc", _wrap_Path_arc}, - { "arcNegative", _wrap_Path_arcNegative}, - { "triangle", _wrap_Path_triangle}, - { "circle", _wrap_Path_circle}, - { "ellipse", _wrap_Path_ellipse}, - { "rectangle", _wrap_Path_rectangle}, - { "rectRounded", _wrap_Path_rectRounded}, - { "setPolyWindingMode", _wrap_Path_setPolyWindingMode}, - { "getWindingMode", _wrap_Path_getWindingMode}, - { "setFilled", _wrap_Path_setFilled}, - { "setStrokeWidth", _wrap_Path_setStrokeWidth}, - { "setColor", _wrap_Path_setColor}, - { "setHexColor", _wrap_Path_setHexColor}, - { "setFillColor", _wrap_Path_setFillColor}, - { "setFillHexColor", _wrap_Path_setFillHexColor}, - { "setStrokeColor", _wrap_Path_setStrokeColor}, - { "setStrokeHexColor", _wrap_Path_setStrokeHexColor}, - { "isFilled", _wrap_Path_isFilled}, - { "getFillColor", _wrap_Path_getFillColor}, - { "getStrokeColor", _wrap_Path_getStrokeColor}, - { "getStrokeWidth", _wrap_Path_getStrokeWidth}, - { "hasOutline", _wrap_Path_hasOutline}, - { "setCurveResolution", _wrap_Path_setCurveResolution}, - { "getCurveResolution", _wrap_Path_getCurveResolution}, - { "setCircleResolution", _wrap_Path_setCircleResolution}, - { "getCircleResolution", _wrap_Path_getCircleResolution}, - { "setUseShapeColor", _wrap_Path_setUseShapeColor}, - { "getUseShapeColor", _wrap_Path_getUseShapeColor}, - { "draw", _wrap_Path_draw}, - { "getOutline", _wrap_Path_getOutline}, - { "tessellate", _wrap_Path_tessellate}, - { "getTessellation", _wrap_Path_getTessellation}, - { "simplify", _wrap_Path_simplify}, - { "translate", _wrap_Path_translate}, - { "rotate", _wrap_Path_rotate}, - { "scale", _wrap_Path_scale}, - { "append", _wrap_Path_append}, - { "setMode", _wrap_Path_setMode}, - { "getMode", _wrap_Path_getMode}, - { "getCommands", _wrap_Path_getCommands}, - {0,0} -}; -static swig_lua_method swig_Path_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_Path_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_Path_Sf_SwigStatic_constants[]= { - {SWIG_LUA_CONSTTAB_INT("COMMANDS", ofPath::COMMANDS)}, - {SWIG_LUA_CONSTTAB_INT("POLYLINES", ofPath::POLYLINES)}, - {0,0,0,0,0,0} -}; -static swig_lua_method swig_Path_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_Path_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_Path_Sf_SwigStatic = { - "Path", - swig_Path_Sf_SwigStatic_methods, - swig_Path_Sf_SwigStatic_attributes, - swig_Path_Sf_SwigStatic_constants, - swig_Path_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_Path_bases[] = {0}; -static const char *swig_Path_base_names[] = {0}; -static swig_lua_class _wrap_class_Path = { "Path", "Path", &SWIGTYPE_p_ofPath,_proxy__wrap_new_Path, swig_delete_Path, swig_Path_methods, swig_Path_attributes, &swig_Path_Sf_SwigStatic, swig_Path_meta, swig_Path_bases, swig_Path_base_names }; - -static int _wrap_new_Polyline__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPolyline *result = 0 ; - SWIG_check_num_args("ofPolyline::ofPolyline",0,0) result = (ofPolyline *)new ofPolyline(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofPolyline,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Polyline__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::vector< ofPoint > *arg1 = 0 ; - ofPolyline *result = 0 ; SWIG_check_num_args("ofPolyline::ofPolyline",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofPolyline::ofPolyline",1,"std::vector< ofPoint > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofVec3f_t,0))){ - SWIG_fail_ptr("new_Polyline",1,SWIGTYPE_p_std__vectorT_ofVec3f_t); } - result = (ofPolyline *)new ofPolyline((std::vector< ofPoint > const &)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofPolyline,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Polyline(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_Polyline__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_std__vectorT_ofVec3f_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_new_Polyline__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_Polyline'\n" " Possible C/C++ prototypes are:\n" - " ofPolyline::ofPolyline()\n" " ofPolyline::ofPolyline(std::vector< ofPoint > const &)\n"); lua_error(L);return 0; } -static int _wrap_Polyline_fromRectangle(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = 0 ; ofPolyline result; - SWIG_check_num_args("ofPolyline::fromRectangle",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofPolyline::fromRectangle",1,"ofRectangle const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Polyline_fromRectangle",1,SWIGTYPE_p_ofRectangle); } - result = ofPolyline::fromRectangle((ofRectangle const &)*arg1); { - ofPolyline * resultptr = new ofPolyline((const ofPolyline &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofPolyline,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_clear(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - SWIG_check_num_args("ofPolyline::clear",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::clear",1,"ofPolyline *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_clear",1,SWIGTYPE_p_ofPolyline); } (arg1)->clear(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_addVertex__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - ofPoint *arg2 = 0 ; SWIG_check_num_args("ofPolyline::addVertex",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::addVertex",1,"ofPolyline *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline::addVertex",2,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_addVertex",1,SWIGTYPE_p_ofPolyline); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Polyline_addVertex",2,SWIGTYPE_p_ofVec3f); } (arg1)->addVertex((ofPoint const &)*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_addVertex__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; float arg2 ; - float arg3 ; float arg4 ; SWIG_check_num_args("ofPolyline::addVertex",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::addVertex",1,"ofPolyline *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::addVertex",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::addVertex",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPolyline::addVertex",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_addVertex",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); (arg1)->addVertex(arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_addVertex__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; float arg2 ; - float arg3 ; SWIG_check_num_args("ofPolyline::addVertex",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::addVertex",1,"ofPolyline *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::addVertex",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::addVertex",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_addVertex",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->addVertex(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Polyline_addVertex(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Polyline_addVertex__SWIG_0(L);} } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_Polyline_addVertex__SWIG_2(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Polyline_addVertex__SWIG_1(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Polyline_addVertex'\n" " Possible C/C++ prototypes are:\n" - " ofPolyline::addVertex(ofPoint const &)\n" " ofPolyline::addVertex(float,float,float)\n" - " ofPolyline::addVertex(float,float)\n"); lua_error(L);return 0; } -static int _wrap_Polyline_addVertices__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - std::vector< ofPoint > *arg2 = 0 ; SWIG_check_num_args("ofPolyline::addVertices",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::addVertices",1,"ofPolyline *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline::addVertices",2,"std::vector< ofPoint > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_addVertices",1,SWIGTYPE_p_ofPolyline); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__vectorT_ofVec3f_t,0))){ - SWIG_fail_ptr("Polyline_addVertices",2,SWIGTYPE_p_std__vectorT_ofVec3f_t); } - (arg1)->addVertices((std::vector< ofPoint > const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Polyline_addVertices__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - ofPoint *arg2 = (ofPoint *) 0 ; int arg3 ; SWIG_check_num_args("ofPolyline::addVertices",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::addVertices",1,"ofPolyline *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofPolyline::addVertices",2,"ofPoint const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::addVertices",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_addVertices",1,SWIGTYPE_p_ofPolyline); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Polyline_addVertices",2,SWIGTYPE_p_ofVec3f); } arg3 = (int)lua_tonumber(L, 3); - (arg1)->addVertices((ofPoint const *)arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_addVertices(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_std__vectorT_ofVec3f_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Polyline_addVertices__SWIG_0(L);} } } if (argc == 3) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Polyline_addVertices__SWIG_1(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Polyline_addVertices'\n" - " Possible C/C++ prototypes are:\n" " ofPolyline::addVertices(std::vector< ofPoint > const &)\n" - " ofPolyline::addVertices(ofPoint const *,int)\n"); lua_error(L);return 0; } -static int _wrap_Polyline_insertVertex__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - ofPoint *arg2 = 0 ; int arg3 ; SWIG_check_num_args("ofPolyline::insertVertex",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::insertVertex",1,"ofPolyline *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline::insertVertex",2,"ofPoint const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::insertVertex",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_insertVertex",1,SWIGTYPE_p_ofPolyline); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Polyline_insertVertex",2,SWIGTYPE_p_ofVec3f); } arg3 = (int)lua_tonumber(L, 3); - (arg1)->insertVertex((ofPoint const &)*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_insertVertex__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - float arg2 ; float arg3 ; float arg4 ; int arg5 ; SWIG_check_num_args("ofPolyline::insertVertex",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::insertVertex",1,"ofPolyline *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::insertVertex",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::insertVertex",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPolyline::insertVertex",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPolyline::insertVertex",5,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_insertVertex",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); - (arg1)->insertVertex(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_insertVertex(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Polyline_insertVertex__SWIG_0(L);} } } } if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Polyline_insertVertex__SWIG_1(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Polyline_insertVertex'\n" - " Possible C/C++ prototypes are:\n" " ofPolyline::insertVertex(ofPoint const &,int)\n" - " ofPolyline::insertVertex(float,float,float,int)\n"); lua_error(L);return 0; } -static int _wrap_Polyline_resize(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; size_t arg2 ; - SWIG_check_num_args("ofPolyline::resize",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::resize",1,"ofPolyline *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::resize",2,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_resize",1,SWIGTYPE_p_ofPolyline); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - (arg1)->resize(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_size(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; size_t result; - SWIG_check_num_args("ofPolyline::size",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::size",1,"ofPolyline const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_size",1,SWIGTYPE_p_ofPolyline); } result = (size_t)((ofPolyline const *)arg1)->size(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_getVertices__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - std::vector< ofPoint > *result = 0 ; SWIG_check_num_args("ofPolyline::getVertices",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::getVertices",1,"ofPolyline *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_getVertices",1,SWIGTYPE_p_ofPolyline); } - result = (std::vector< ofPoint > *) &(arg1)->getVertices(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofVec3f_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_getVertices__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - std::vector< ofPoint > *result = 0 ; SWIG_check_num_args("ofPolyline::getVertices",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::getVertices",1,"ofPolyline const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_getVertices",1,SWIGTYPE_p_ofPolyline); } - result = (std::vector< ofPoint > *) &((ofPolyline const *)arg1)->getVertices(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofVec3f_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_getVertices(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Polyline_getVertices__SWIG_0(L);} } if (argc == 1) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Polyline_getVertices__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Polyline_getVertices'\n" - " Possible C/C++ prototypes are:\n" " ofPolyline::getVertices()\n" " ofPolyline::getVertices() const\n"); - lua_error(L);return 0; } -static int _wrap_Polyline_lineTo__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - ofPoint *arg2 = 0 ; SWIG_check_num_args("ofPolyline::lineTo",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::lineTo",1,"ofPolyline *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline::lineTo",2,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_lineTo",1,SWIGTYPE_p_ofPolyline); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Polyline_lineTo",2,SWIGTYPE_p_ofVec3f); } (arg1)->lineTo((ofPoint const &)*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_lineTo__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; float arg2 ; - float arg3 ; float arg4 ; SWIG_check_num_args("ofPolyline::lineTo",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::lineTo",1,"ofPolyline *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::lineTo",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::lineTo",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPolyline::lineTo",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_lineTo",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); (arg1)->lineTo(arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_lineTo__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; float arg2 ; - float arg3 ; SWIG_check_num_args("ofPolyline::lineTo",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::lineTo",1,"ofPolyline *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::lineTo",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::lineTo",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_lineTo",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->lineTo(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Polyline_lineTo(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Polyline_lineTo__SWIG_0(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Polyline_lineTo__SWIG_2(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Polyline_lineTo__SWIG_1(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Polyline_lineTo'\n" " Possible C/C++ prototypes are:\n" - " ofPolyline::lineTo(ofPoint const &)\n" " ofPolyline::lineTo(float,float,float)\n" - " ofPolyline::lineTo(float,float)\n"); lua_error(L);return 0; } -static int _wrap_Polyline_arc__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - ofPoint *arg2 = 0 ; float arg3 ; float arg4 ; float arg5 ; float arg6 ; bool arg7 ; int arg8 ; - SWIG_check_num_args("ofPolyline::arc",8,8) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::arc",1,"ofPolyline *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline::arc",2,"ofPoint const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::arc",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPolyline::arc",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPolyline::arc",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPolyline::arc",6,"float"); - if(!lua_isboolean(L,7)) SWIG_fail_arg("ofPolyline::arc",7,"bool"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofPolyline::arc",8,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_arc",1,SWIGTYPE_p_ofPolyline); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Polyline_arc",2,SWIGTYPE_p_ofVec3f); } - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (lua_toboolean(L, 7)!=0); arg8 = (int)lua_tonumber(L, 8); - (arg1)->arc((ofPoint const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Polyline_arc__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - ofPoint *arg2 = 0 ; float arg3 ; float arg4 ; float arg5 ; float arg6 ; bool arg7 ; SWIG_check_num_args("ofPolyline::arc",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::arc",1,"ofPolyline *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline::arc",2,"ofPoint const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::arc",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPolyline::arc",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPolyline::arc",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPolyline::arc",6,"float"); - if(!lua_isboolean(L,7)) SWIG_fail_arg("ofPolyline::arc",7,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_arc",1,SWIGTYPE_p_ofPolyline); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Polyline_arc",2,SWIGTYPE_p_ofVec3f); } - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (lua_toboolean(L, 7)!=0); - (arg1)->arc((ofPoint const &)*arg2,arg3,arg4,arg5,arg6,arg7); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Polyline_arc__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - ofPoint *arg2 = 0 ; float arg3 ; float arg4 ; float arg5 ; float arg6 ; int arg7 ; SWIG_check_num_args("ofPolyline::arc",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::arc",1,"ofPolyline *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline::arc",2,"ofPoint const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::arc",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPolyline::arc",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPolyline::arc",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPolyline::arc",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPolyline::arc",7,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_arc",1,SWIGTYPE_p_ofPolyline); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Polyline_arc",2,SWIGTYPE_p_ofVec3f); } - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (int)lua_tonumber(L, 7); - (arg1)->arc((ofPoint const &)*arg2,arg3,arg4,arg5,arg6,arg7); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Polyline_arc__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - ofPoint *arg2 = 0 ; float arg3 ; float arg4 ; float arg5 ; float arg6 ; SWIG_check_num_args("ofPolyline::arc",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::arc",1,"ofPolyline *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline::arc",2,"ofPoint const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::arc",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPolyline::arc",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPolyline::arc",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPolyline::arc",6,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_arc",1,SWIGTYPE_p_ofPolyline); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Polyline_arc",2,SWIGTYPE_p_ofVec3f); } - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); (arg1)->arc((ofPoint const &)*arg2,arg3,arg4,arg5,arg6); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_arc__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; float arg2 ; - float arg3 ; float arg4 ; float arg5 ; float arg6 ; float arg7 ; int arg8 ; SWIG_check_num_args("ofPolyline::arc",8,8) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::arc",1,"ofPolyline *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::arc",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::arc",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPolyline::arc",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPolyline::arc",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPolyline::arc",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPolyline::arc",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofPolyline::arc",8,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_arc",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (int)lua_tonumber(L, 8); - (arg1)->arc(arg2,arg3,arg4,arg5,arg6,arg7,arg8); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_arc__SWIG_5(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; float arg2 ; - float arg3 ; float arg4 ; float arg5 ; float arg6 ; float arg7 ; SWIG_check_num_args("ofPolyline::arc",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::arc",1,"ofPolyline *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::arc",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::arc",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPolyline::arc",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPolyline::arc",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPolyline::arc",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPolyline::arc",7,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_arc",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); (arg1)->arc(arg2,arg3,arg4,arg5,arg6,arg7); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_arc__SWIG_6(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; float arg2 ; - float arg3 ; float arg4 ; float arg5 ; float arg6 ; float arg7 ; float arg8 ; int arg9 ; - SWIG_check_num_args("ofPolyline::arc",9,9) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::arc",1,"ofPolyline *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::arc",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::arc",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPolyline::arc",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPolyline::arc",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPolyline::arc",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPolyline::arc",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofPolyline::arc",8,"float"); - if(!lua_isnumber(L,9)) SWIG_fail_arg("ofPolyline::arc",9,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_arc",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (float)lua_tonumber(L, 8); - arg9 = (int)lua_tonumber(L, 9); (arg1)->arc(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_arc(lua_State* L) { int argc; int argv[10]={ 1,2,3,4,5,6,7,8,9,10} ; argc = lua_gettop(L); - if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { - return _wrap_Polyline_arc__SWIG_3(L);} } } } } } } if (argc == 7) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { { - _v = lua_isboolean(L,argv[6]); } if (_v) { return _wrap_Polyline_arc__SWIG_1(L);} } } } } } } } - if (argc == 7) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { { - _v = lua_isnumber(L,argv[6]); } if (_v) { return _wrap_Polyline_arc__SWIG_2(L);} } } } } } } } - if (argc == 7) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { - return _wrap_Polyline_arc__SWIG_5(L);} } } } } } } } if (argc == 8) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { { - _v = lua_isboolean(L,argv[6]); } if (_v) { { _v = lua_isnumber(L,argv[7]); } if (_v) { - return _wrap_Polyline_arc__SWIG_0(L);} } } } } } } } } if (argc == 8) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { return _wrap_Polyline_arc__SWIG_4(L);} } } } } } } } } - if (argc == 9) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { { _v = lua_isnumber(L,argv[8]); } if (_v) { - return _wrap_Polyline_arc__SWIG_6(L);} } } } } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Polyline_arc'\n" " Possible C/C++ prototypes are:\n" - " ofPolyline::arc(ofPoint const &,float,float,float,float,bool,int)\n" - " ofPolyline::arc(ofPoint const &,float,float,float,float,bool)\n" - " ofPolyline::arc(ofPoint const &,float,float,float,float,int)\n" - " ofPolyline::arc(ofPoint const &,float,float,float,float)\n" - " ofPolyline::arc(float,float,float,float,float,float,int)\n" " ofPolyline::arc(float,float,float,float,float,float)\n" - " ofPolyline::arc(float,float,float,float,float,float,float,int)\n"); lua_error(L);return 0; } -static int _wrap_Polyline_arcNegative__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - ofPoint *arg2 = 0 ; float arg3 ; float arg4 ; float arg5 ; float arg6 ; int arg7 ; - SWIG_check_num_args("ofPolyline::arcNegative",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::arcNegative",1,"ofPolyline *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline::arcNegative",2,"ofPoint const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::arcNegative",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPolyline::arcNegative",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPolyline::arcNegative",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPolyline::arcNegative",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPolyline::arcNegative",7,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_arcNegative",1,SWIGTYPE_p_ofPolyline); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Polyline_arcNegative",2,SWIGTYPE_p_ofVec3f); } arg3 = (float)lua_tonumber(L, 3); - arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); - arg7 = (int)lua_tonumber(L, 7); (arg1)->arcNegative((ofPoint const &)*arg2,arg3,arg4,arg5,arg6,arg7); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_arcNegative__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - ofPoint *arg2 = 0 ; float arg3 ; float arg4 ; float arg5 ; float arg6 ; SWIG_check_num_args("ofPolyline::arcNegative",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::arcNegative",1,"ofPolyline *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline::arcNegative",2,"ofPoint const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::arcNegative",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPolyline::arcNegative",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPolyline::arcNegative",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPolyline::arcNegative",6,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_arcNegative",1,SWIGTYPE_p_ofPolyline); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Polyline_arcNegative",2,SWIGTYPE_p_ofVec3f); } arg3 = (float)lua_tonumber(L, 3); - arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); - (arg1)->arcNegative((ofPoint const &)*arg2,arg3,arg4,arg5,arg6); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Polyline_arcNegative__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - float arg2 ; float arg3 ; float arg4 ; float arg5 ; float arg6 ; float arg7 ; int arg8 ; - SWIG_check_num_args("ofPolyline::arcNegative",8,8) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::arcNegative",1,"ofPolyline *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::arcNegative",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::arcNegative",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPolyline::arcNegative",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPolyline::arcNegative",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPolyline::arcNegative",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPolyline::arcNegative",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofPolyline::arcNegative",8,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_arcNegative",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (int)lua_tonumber(L, 8); - (arg1)->arcNegative(arg2,arg3,arg4,arg5,arg6,arg7,arg8); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Polyline_arcNegative__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - float arg2 ; float arg3 ; float arg4 ; float arg5 ; float arg6 ; float arg7 ; - SWIG_check_num_args("ofPolyline::arcNegative",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::arcNegative",1,"ofPolyline *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::arcNegative",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::arcNegative",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPolyline::arcNegative",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPolyline::arcNegative",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPolyline::arcNegative",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPolyline::arcNegative",7,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_arcNegative",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); (arg1)->arcNegative(arg2,arg3,arg4,arg5,arg6,arg7); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_arcNegative__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - float arg2 ; float arg3 ; float arg4 ; float arg5 ; float arg6 ; float arg7 ; float arg8 ; int arg9 ; - SWIG_check_num_args("ofPolyline::arcNegative",9,9) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::arcNegative",1,"ofPolyline *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::arcNegative",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::arcNegative",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPolyline::arcNegative",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPolyline::arcNegative",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPolyline::arcNegative",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPolyline::arcNegative",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofPolyline::arcNegative",8,"float"); - if(!lua_isnumber(L,9)) SWIG_fail_arg("ofPolyline::arcNegative",9,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_arcNegative",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (float)lua_tonumber(L, 8); - arg9 = (int)lua_tonumber(L, 9); (arg1)->arcNegative(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_arcNegative(lua_State* L) { int argc; int argv[10]={ 1,2,3,4,5,6,7,8,9,10} ; argc = lua_gettop(L); - if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { - return _wrap_Polyline_arcNegative__SWIG_1(L);} } } } } } } if (argc == 7) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { { - _v = lua_isnumber(L,argv[6]); } if (_v) { return _wrap_Polyline_arcNegative__SWIG_0(L);} } } } } } } } - if (argc == 7) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { - return _wrap_Polyline_arcNegative__SWIG_3(L);} } } } } } } } if (argc == 8) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { return _wrap_Polyline_arcNegative__SWIG_2(L);} } } } } } } - } } if (argc == 9) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { { _v = lua_isnumber(L,argv[8]); } if (_v) { - return _wrap_Polyline_arcNegative__SWIG_4(L);} } } } } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Polyline_arcNegative'\n" - " Possible C/C++ prototypes are:\n" " ofPolyline::arcNegative(ofPoint const &,float,float,float,float,int)\n" - " ofPolyline::arcNegative(ofPoint const &,float,float,float,float)\n" - " ofPolyline::arcNegative(float,float,float,float,float,float,int)\n" - " ofPolyline::arcNegative(float,float,float,float,float,float)\n" - " ofPolyline::arcNegative(float,float,float,float,float,float,float,int)\n"); lua_error(L);return 0; } -static int _wrap_Polyline_curveTo__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - ofPoint *arg2 = 0 ; int arg3 ; SWIG_check_num_args("ofPolyline::curveTo",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::curveTo",1,"ofPolyline *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline::curveTo",2,"ofPoint const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::curveTo",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_curveTo",1,SWIGTYPE_p_ofPolyline); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Polyline_curveTo",2,SWIGTYPE_p_ofVec3f); } arg3 = (int)lua_tonumber(L, 3); - (arg1)->curveTo((ofPoint const &)*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_curveTo__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - ofPoint *arg2 = 0 ; SWIG_check_num_args("ofPolyline::curveTo",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::curveTo",1,"ofPolyline *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline::curveTo",2,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_curveTo",1,SWIGTYPE_p_ofPolyline); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Polyline_curveTo",2,SWIGTYPE_p_ofVec3f); } (arg1)->curveTo((ofPoint const &)*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_curveTo__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; float arg2 ; - float arg3 ; float arg4 ; int arg5 ; SWIG_check_num_args("ofPolyline::curveTo",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::curveTo",1,"ofPolyline *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::curveTo",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::curveTo",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPolyline::curveTo",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPolyline::curveTo",5,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_curveTo",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); - (arg1)->curveTo(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_curveTo__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; float arg2 ; - float arg3 ; float arg4 ; SWIG_check_num_args("ofPolyline::curveTo",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::curveTo",1,"ofPolyline *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::curveTo",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::curveTo",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPolyline::curveTo",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_curveTo",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); (arg1)->curveTo(arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_curveTo__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; float arg2 ; - float arg3 ; SWIG_check_num_args("ofPolyline::curveTo",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::curveTo",1,"ofPolyline *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::curveTo",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::curveTo",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_curveTo",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->curveTo(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Polyline_curveTo(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Polyline_curveTo__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Polyline_curveTo__SWIG_0(L);} - } } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Polyline_curveTo__SWIG_4(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Polyline_curveTo__SWIG_3(L);} } } } } if (argc == 5) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Polyline_curveTo__SWIG_2(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Polyline_curveTo'\n" " Possible C/C++ prototypes are:\n" - " ofPolyline::curveTo(ofPoint const &,int)\n" " ofPolyline::curveTo(ofPoint const &)\n" - " ofPolyline::curveTo(float,float,float,int)\n" " ofPolyline::curveTo(float,float,float)\n" - " ofPolyline::curveTo(float,float)\n"); lua_error(L);return 0; } -static int _wrap_Polyline_bezierTo__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - ofPoint *arg2 = 0 ; ofPoint *arg3 = 0 ; ofPoint *arg4 = 0 ; int arg5 ; SWIG_check_num_args("ofPolyline::bezierTo",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::bezierTo",1,"ofPolyline *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline::bezierTo",2,"ofPoint const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofPolyline::bezierTo",3,"ofPoint const &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofPolyline::bezierTo",4,"ofPoint const &"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPolyline::bezierTo",5,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_bezierTo",1,SWIGTYPE_p_ofPolyline); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Polyline_bezierTo",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Polyline_bezierTo",3,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Polyline_bezierTo",4,SWIGTYPE_p_ofVec3f); } arg5 = (int)lua_tonumber(L, 5); - (arg1)->bezierTo((ofPoint const &)*arg2,(ofPoint const &)*arg3,(ofPoint const &)*arg4,arg5); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_bezierTo__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - ofPoint *arg2 = 0 ; ofPoint *arg3 = 0 ; ofPoint *arg4 = 0 ; SWIG_check_num_args("ofPolyline::bezierTo",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::bezierTo",1,"ofPolyline *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline::bezierTo",2,"ofPoint const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofPolyline::bezierTo",3,"ofPoint const &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofPolyline::bezierTo",4,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_bezierTo",1,SWIGTYPE_p_ofPolyline); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Polyline_bezierTo",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Polyline_bezierTo",3,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Polyline_bezierTo",4,SWIGTYPE_p_ofVec3f); } - (arg1)->bezierTo((ofPoint const &)*arg2,(ofPoint const &)*arg3,(ofPoint const &)*arg4); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_bezierTo__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; float arg2 ; - float arg3 ; float arg4 ; float arg5 ; float arg6 ; float arg7 ; int arg8 ; SWIG_check_num_args("ofPolyline::bezierTo",8,8) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::bezierTo",1,"ofPolyline *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::bezierTo",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::bezierTo",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPolyline::bezierTo",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPolyline::bezierTo",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPolyline::bezierTo",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPolyline::bezierTo",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofPolyline::bezierTo",8,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_bezierTo",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (int)lua_tonumber(L, 8); - (arg1)->bezierTo(arg2,arg3,arg4,arg5,arg6,arg7,arg8); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_bezierTo__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; float arg2 ; - float arg3 ; float arg4 ; float arg5 ; float arg6 ; float arg7 ; SWIG_check_num_args("ofPolyline::bezierTo",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::bezierTo",1,"ofPolyline *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::bezierTo",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::bezierTo",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPolyline::bezierTo",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPolyline::bezierTo",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPolyline::bezierTo",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPolyline::bezierTo",7,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_bezierTo",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); (arg1)->bezierTo(arg2,arg3,arg4,arg5,arg6,arg7); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_bezierTo__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; float arg2 ; - float arg3 ; float arg4 ; float arg5 ; float arg6 ; float arg7 ; float arg8 ; float arg9 ; float arg10 ; int arg11 ; - SWIG_check_num_args("ofPolyline::bezierTo",11,11) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::bezierTo",1,"ofPolyline *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::bezierTo",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::bezierTo",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPolyline::bezierTo",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPolyline::bezierTo",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPolyline::bezierTo",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPolyline::bezierTo",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofPolyline::bezierTo",8,"float"); - if(!lua_isnumber(L,9)) SWIG_fail_arg("ofPolyline::bezierTo",9,"float"); - if(!lua_isnumber(L,10)) SWIG_fail_arg("ofPolyline::bezierTo",10,"float"); - if(!lua_isnumber(L,11)) SWIG_fail_arg("ofPolyline::bezierTo",11,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_bezierTo",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (float)lua_tonumber(L, 8); - arg9 = (float)lua_tonumber(L, 9); arg10 = (float)lua_tonumber(L, 10); arg11 = (int)lua_tonumber(L, 11); - (arg1)->bezierTo(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Polyline_bezierTo__SWIG_5(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; float arg2 ; - float arg3 ; float arg4 ; float arg5 ; float arg6 ; float arg7 ; float arg8 ; float arg9 ; float arg10 ; - SWIG_check_num_args("ofPolyline::bezierTo",10,10) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::bezierTo",1,"ofPolyline *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::bezierTo",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::bezierTo",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPolyline::bezierTo",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPolyline::bezierTo",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPolyline::bezierTo",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPolyline::bezierTo",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofPolyline::bezierTo",8,"float"); - if(!lua_isnumber(L,9)) SWIG_fail_arg("ofPolyline::bezierTo",9,"float"); - if(!lua_isnumber(L,10)) SWIG_fail_arg("ofPolyline::bezierTo",10,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_bezierTo",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (float)lua_tonumber(L, 8); - arg9 = (float)lua_tonumber(L, 9); arg10 = (float)lua_tonumber(L, 10); - (arg1)->bezierTo(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Polyline_bezierTo(lua_State* L) { int argc; int argv[12]={ 1,2,3,4,5,6,7,8,9,10,11,12} ; argc = lua_gettop(L); - if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Polyline_bezierTo__SWIG_1(L);} } } } } if (argc == 5) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Polyline_bezierTo__SWIG_0(L);} } } } } } if (argc == 7) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { - return _wrap_Polyline_bezierTo__SWIG_3(L);} } } } } } } } if (argc == 8) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { return _wrap_Polyline_bezierTo__SWIG_2(L);} } } } } } } } - } if (argc == 10) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { { _v = lua_isnumber(L,argv[8]); } if (_v) { { - _v = lua_isnumber(L,argv[9]); } if (_v) { return _wrap_Polyline_bezierTo__SWIG_5(L);} } } } } } } - } } } } if (argc == 11) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { { _v = lua_isnumber(L,argv[8]); } if (_v) { { - _v = lua_isnumber(L,argv[9]); } if (_v) { { _v = lua_isnumber(L,argv[10]); } if (_v) { - return _wrap_Polyline_bezierTo__SWIG_4(L);} } } } } } } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Polyline_bezierTo'\n" " Possible C/C++ prototypes are:\n" - " ofPolyline::bezierTo(ofPoint const &,ofPoint const &,ofPoint const &,int)\n" - " ofPolyline::bezierTo(ofPoint const &,ofPoint const &,ofPoint const &)\n" - " ofPolyline::bezierTo(float,float,float,float,float,float,int)\n" - " ofPolyline::bezierTo(float,float,float,float,float,float)\n" - " ofPolyline::bezierTo(float,float,float,float,float,float,float,float,float,int)\n" - " ofPolyline::bezierTo(float,float,float,float,float,float,float,float,float)\n"); lua_error(L);return 0; } -static int _wrap_Polyline_quadBezierTo__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - float arg2 ; float arg3 ; float arg4 ; float arg5 ; float arg6 ; float arg7 ; float arg8 ; float arg9 ; float arg10 ; - int arg11 ; SWIG_check_num_args("ofPolyline::quadBezierTo",11,11) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::quadBezierTo",1,"ofPolyline *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::quadBezierTo",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::quadBezierTo",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPolyline::quadBezierTo",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPolyline::quadBezierTo",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPolyline::quadBezierTo",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPolyline::quadBezierTo",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofPolyline::quadBezierTo",8,"float"); - if(!lua_isnumber(L,9)) SWIG_fail_arg("ofPolyline::quadBezierTo",9,"float"); - if(!lua_isnumber(L,10)) SWIG_fail_arg("ofPolyline::quadBezierTo",10,"float"); - if(!lua_isnumber(L,11)) SWIG_fail_arg("ofPolyline::quadBezierTo",11,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_quadBezierTo",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (float)lua_tonumber(L, 8); - arg9 = (float)lua_tonumber(L, 9); arg10 = (float)lua_tonumber(L, 10); arg11 = (int)lua_tonumber(L, 11); - (arg1)->quadBezierTo(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_quadBezierTo__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - float arg2 ; float arg3 ; float arg4 ; float arg5 ; float arg6 ; float arg7 ; float arg8 ; float arg9 ; float arg10 ; - SWIG_check_num_args("ofPolyline::quadBezierTo",10,10) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::quadBezierTo",1,"ofPolyline *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::quadBezierTo",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::quadBezierTo",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPolyline::quadBezierTo",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPolyline::quadBezierTo",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPolyline::quadBezierTo",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPolyline::quadBezierTo",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofPolyline::quadBezierTo",8,"float"); - if(!lua_isnumber(L,9)) SWIG_fail_arg("ofPolyline::quadBezierTo",9,"float"); - if(!lua_isnumber(L,10)) SWIG_fail_arg("ofPolyline::quadBezierTo",10,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_quadBezierTo",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (float)lua_tonumber(L, 8); - arg9 = (float)lua_tonumber(L, 9); arg10 = (float)lua_tonumber(L, 10); - (arg1)->quadBezierTo(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Polyline_quadBezierTo__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - ofPoint *arg2 = 0 ; ofPoint *arg3 = 0 ; ofPoint *arg4 = 0 ; int arg5 ; SWIG_check_num_args("ofPolyline::quadBezierTo",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::quadBezierTo",1,"ofPolyline *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline::quadBezierTo",2,"ofPoint const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofPolyline::quadBezierTo",3,"ofPoint const &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofPolyline::quadBezierTo",4,"ofPoint const &"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPolyline::quadBezierTo",5,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_quadBezierTo",1,SWIGTYPE_p_ofPolyline); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Polyline_quadBezierTo",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Polyline_quadBezierTo",3,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Polyline_quadBezierTo",4,SWIGTYPE_p_ofVec3f); } arg5 = (int)lua_tonumber(L, 5); - (arg1)->quadBezierTo((ofPoint const &)*arg2,(ofPoint const &)*arg3,(ofPoint const &)*arg4,arg5); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_quadBezierTo__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - ofPoint *arg2 = 0 ; ofPoint *arg3 = 0 ; ofPoint *arg4 = 0 ; SWIG_check_num_args("ofPolyline::quadBezierTo",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::quadBezierTo",1,"ofPolyline *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline::quadBezierTo",2,"ofPoint const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofPolyline::quadBezierTo",3,"ofPoint const &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofPolyline::quadBezierTo",4,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_quadBezierTo",1,SWIGTYPE_p_ofPolyline); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Polyline_quadBezierTo",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Polyline_quadBezierTo",3,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Polyline_quadBezierTo",4,SWIGTYPE_p_ofVec3f); } - (arg1)->quadBezierTo((ofPoint const &)*arg2,(ofPoint const &)*arg3,(ofPoint const &)*arg4); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_quadBezierTo__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - float arg2 ; float arg3 ; float arg4 ; float arg5 ; float arg6 ; float arg7 ; int arg8 ; - SWIG_check_num_args("ofPolyline::quadBezierTo",8,8) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::quadBezierTo",1,"ofPolyline *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::quadBezierTo",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::quadBezierTo",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPolyline::quadBezierTo",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPolyline::quadBezierTo",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPolyline::quadBezierTo",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPolyline::quadBezierTo",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofPolyline::quadBezierTo",8,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_quadBezierTo",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (int)lua_tonumber(L, 8); - (arg1)->quadBezierTo(arg2,arg3,arg4,arg5,arg6,arg7,arg8); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Polyline_quadBezierTo__SWIG_5(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - float arg2 ; float arg3 ; float arg4 ; float arg5 ; float arg6 ; float arg7 ; - SWIG_check_num_args("ofPolyline::quadBezierTo",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::quadBezierTo",1,"ofPolyline *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::quadBezierTo",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::quadBezierTo",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPolyline::quadBezierTo",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPolyline::quadBezierTo",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPolyline::quadBezierTo",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPolyline::quadBezierTo",7,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_quadBezierTo",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); (arg1)->quadBezierTo(arg2,arg3,arg4,arg5,arg6,arg7); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_quadBezierTo(lua_State* L) { int argc; int argv[12]={ 1,2,3,4,5,6,7,8,9,10,11,12} ; - argc = lua_gettop(L); if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Polyline_quadBezierTo__SWIG_3(L);} } } } } if (argc == 5) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Polyline_quadBezierTo__SWIG_2(L);} } } } } } if (argc == 7) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { - return _wrap_Polyline_quadBezierTo__SWIG_5(L);} } } } } } } } if (argc == 8) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { return _wrap_Polyline_quadBezierTo__SWIG_4(L);} } } } } } } - } } if (argc == 10) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { { _v = lua_isnumber(L,argv[8]); } if (_v) { { - _v = lua_isnumber(L,argv[9]); } if (_v) { return _wrap_Polyline_quadBezierTo__SWIG_1(L);} } } } } } - } } } } } if (argc == 11) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { { _v = lua_isnumber(L,argv[8]); } if (_v) { { - _v = lua_isnumber(L,argv[9]); } if (_v) { { _v = lua_isnumber(L,argv[10]); } if (_v) { - return _wrap_Polyline_quadBezierTo__SWIG_0(L);} } } } } } } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Polyline_quadBezierTo'\n" - " Possible C/C++ prototypes are:\n" - " ofPolyline::quadBezierTo(float,float,float,float,float,float,float,float,float,int)\n" - " ofPolyline::quadBezierTo(float,float,float,float,float,float,float,float,float)\n" - " ofPolyline::quadBezierTo(ofPoint const &,ofPoint const &,ofPoint const &,int)\n" - " ofPolyline::quadBezierTo(ofPoint const &,ofPoint const &,ofPoint const &)\n" - " ofPolyline::quadBezierTo(float,float,float,float,float,float,int)\n" - " ofPolyline::quadBezierTo(float,float,float,float,float,float)\n"); lua_error(L);return 0; } -static int _wrap_Polyline_getSmoothed__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; int arg2 ; - float arg3 ; ofPolyline result; SWIG_check_num_args("ofPolyline::getSmoothed",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::getSmoothed",1,"ofPolyline const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::getSmoothed",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::getSmoothed",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_getSmoothed",1,SWIGTYPE_p_ofPolyline); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); result = ((ofPolyline const *)arg1)->getSmoothed(arg2,arg3); { - ofPolyline * resultptr = new ofPolyline((const ofPolyline &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofPolyline,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_getSmoothed__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; int arg2 ; - ofPolyline result; SWIG_check_num_args("ofPolyline::getSmoothed",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::getSmoothed",1,"ofPolyline const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::getSmoothed",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_getSmoothed",1,SWIGTYPE_p_ofPolyline); } arg2 = (int)lua_tonumber(L, 2); - result = ((ofPolyline const *)arg1)->getSmoothed(arg2); { - ofPolyline * resultptr = new ofPolyline((const ofPolyline &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofPolyline,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_getSmoothed(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Polyline_getSmoothed__SWIG_1(L);} - } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Polyline_getSmoothed__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Polyline_getSmoothed'\n" - " Possible C/C++ prototypes are:\n" " ofPolyline::getSmoothed(int,float) const\n" - " ofPolyline::getSmoothed(int) const\n"); lua_error(L);return 0; } -static int _wrap_Polyline_getResampledBySpacing(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - float arg2 ; ofPolyline result; SWIG_check_num_args("ofPolyline::getResampledBySpacing",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::getResampledBySpacing",1,"ofPolyline const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::getResampledBySpacing",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_getResampledBySpacing",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - result = ((ofPolyline const *)arg1)->getResampledBySpacing(arg2); { - ofPolyline * resultptr = new ofPolyline((const ofPolyline &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofPolyline,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_getResampledByCount(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; int arg2 ; - ofPolyline result; SWIG_check_num_args("ofPolyline::getResampledByCount",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::getResampledByCount",1,"ofPolyline const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::getResampledByCount",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_getResampledByCount",1,SWIGTYPE_p_ofPolyline); } arg2 = (int)lua_tonumber(L, 2); - result = ((ofPolyline const *)arg1)->getResampledByCount(arg2); { - ofPolyline * resultptr = new ofPolyline((const ofPolyline &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofPolyline,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_simplify__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; float arg2 ; - SWIG_check_num_args("ofPolyline::simplify",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::simplify",1,"ofPolyline *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::simplify",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_simplify",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); (arg1)->simplify(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_simplify__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - SWIG_check_num_args("ofPolyline::simplify",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::simplify",1,"ofPolyline *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_simplify",1,SWIGTYPE_p_ofPolyline); } (arg1)->simplify(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_simplify(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Polyline_simplify__SWIG_1(L);} } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Polyline_simplify__SWIG_0(L);} } - } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Polyline_simplify'\n" - " Possible C/C++ prototypes are:\n" " ofPolyline::simplify(float)\n" " ofPolyline::simplify()\n"); - lua_error(L);return 0; } -static int _wrap_Polyline_close(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - SWIG_check_num_args("ofPolyline::close",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::close",1,"ofPolyline *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_close",1,SWIGTYPE_p_ofPolyline); } (arg1)->close(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_setClosed(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; bool arg2 ; - SWIG_check_num_args("ofPolyline::setClosed",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::setClosed",1,"ofPolyline *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofPolyline::setClosed",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_setClosed",1,SWIGTYPE_p_ofPolyline); } arg2 = (lua_toboolean(L, 2)!=0); (arg1)->setClosed(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_isClosed(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; bool result; - SWIG_check_num_args("ofPolyline::isClosed",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::isClosed",1,"ofPolyline const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_isClosed",1,SWIGTYPE_p_ofPolyline); } result = (bool)((ofPolyline const *)arg1)->isClosed(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_hasChanged(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; bool result; - SWIG_check_num_args("ofPolyline::hasChanged",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::hasChanged",1,"ofPolyline *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_hasChanged",1,SWIGTYPE_p_ofPolyline); } result = (bool)(arg1)->hasChanged(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_flagHasChanged(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - SWIG_check_num_args("ofPolyline::flagHasChanged",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::flagHasChanged",1,"ofPolyline *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_flagHasChanged",1,SWIGTYPE_p_ofPolyline); } (arg1)->flagHasChanged(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_inside__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; ofPolyline *arg3 = 0 ; - bool result; SWIG_check_num_args("ofPolyline::inside",3,3) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofPolyline::inside",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::inside",2,"float"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofPolyline::inside",3,"ofPolyline const &"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_inside",3,SWIGTYPE_p_ofPolyline); } - result = (bool)ofPolyline::inside(arg1,arg2,(ofPolyline const &)*arg3); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_inside__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; float arg2 ; - float arg3 ; bool result; SWIG_check_num_args("ofPolyline::inside",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::inside",1,"ofPolyline const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::inside",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::inside",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_inside",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); result = (bool)((ofPolyline const *)arg1)->inside(arg2,arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_inside__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPoint *arg1 = 0 ; ofPolyline *arg2 = 0 ; - bool result; SWIG_check_num_args("ofPolyline::inside",2,2) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofPolyline::inside",1,"ofPoint const &"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline::inside",2,"ofPolyline const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Polyline_inside",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_inside",2,SWIGTYPE_p_ofPolyline); } - result = (bool)ofPolyline::inside((ofVec3f const &)*arg1,(ofPolyline const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_inside__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - ofPoint *arg2 = 0 ; bool result; SWIG_check_num_args("ofPolyline::inside",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::inside",1,"ofPolyline const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline::inside",2,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_inside",1,SWIGTYPE_p_ofPolyline); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Polyline_inside",2,SWIGTYPE_p_ofVec3f); } - result = (bool)((ofPolyline const *)arg1)->inside((ofPoint const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_inside(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Polyline_inside__SWIG_2(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Polyline_inside__SWIG_3(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Polyline_inside__SWIG_1(L);} } } } if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Polyline_inside__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Polyline_inside'\n" " Possible C/C++ prototypes are:\n" - " ofPolyline::inside(float,float,ofPolyline const &)\n" " ofPolyline::inside(float,float) const\n" - " ofPolyline::inside(ofPoint const &,ofPolyline const &)\n" " ofPolyline::inside(ofPoint const &) const\n"); - lua_error(L);return 0; } -static int _wrap_Polyline_getBoundingBox(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - ofRectangle result; SWIG_check_num_args("ofPolyline::getBoundingBox",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::getBoundingBox",1,"ofPolyline const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_getBoundingBox",1,SWIGTYPE_p_ofPolyline); } result = ((ofPolyline const *)arg1)->getBoundingBox(); - { ofRectangle * resultptr = new ofRectangle((const ofRectangle &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofRectangle,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_getPerimeter(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; float result; - SWIG_check_num_args("ofPolyline::getPerimeter",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::getPerimeter",1,"ofPolyline const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_getPerimeter",1,SWIGTYPE_p_ofPolyline); } - result = (float)((ofPolyline const *)arg1)->getPerimeter(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_getArea(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; float result; - SWIG_check_num_args("ofPolyline::getArea",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::getArea",1,"ofPolyline const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_getArea",1,SWIGTYPE_p_ofPolyline); } result = (float)((ofPolyline const *)arg1)->getArea(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_getCentroid2D(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; ofPoint result; - SWIG_check_num_args("ofPolyline::getCentroid2D",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::getCentroid2D",1,"ofPolyline const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_getCentroid2D",1,SWIGTYPE_p_ofPolyline); } result = ((ofPolyline const *)arg1)->getCentroid2D(); { - ofPoint * resultptr = new ofPoint((const ofPoint &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_getClosestPoint__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - ofPoint *arg2 = 0 ; unsigned int *arg3 = (unsigned int *) 0 ; ofPoint result; - SWIG_check_num_args("ofPolyline::getClosestPoint",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::getClosestPoint",1,"ofPolyline const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline::getClosestPoint",2,"ofPoint const &"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofPolyline::getClosestPoint",3,"unsigned int *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_getClosestPoint",1,SWIGTYPE_p_ofPolyline); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Polyline_getClosestPoint",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_unsigned_int,0))){ - SWIG_fail_ptr("Polyline_getClosestPoint",3,SWIGTYPE_p_unsigned_int); } - result = ((ofPolyline const *)arg1)->getClosestPoint((ofPoint const &)*arg2,arg3); { - ofPoint * resultptr = new ofPoint((const ofPoint &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_getClosestPoint__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - ofPoint *arg2 = 0 ; ofPoint result; SWIG_check_num_args("ofPolyline::getClosestPoint",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::getClosestPoint",1,"ofPolyline const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline::getClosestPoint",2,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_getClosestPoint",1,SWIGTYPE_p_ofPolyline); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Polyline_getClosestPoint",2,SWIGTYPE_p_ofVec3f); } - result = ((ofPolyline const *)arg1)->getClosestPoint((ofPoint const &)*arg2); { - ofPoint * resultptr = new ofPoint((const ofPoint &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_getClosestPoint(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Polyline_getClosestPoint__SWIG_1(L);} } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_unsigned_int, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Polyline_getClosestPoint__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Polyline_getClosestPoint'\n" - " Possible C/C++ prototypes are:\n" " ofPolyline::getClosestPoint(ofPoint const &,unsigned int *) const\n" - " ofPolyline::getClosestPoint(ofPoint const &) const\n"); lua_error(L);return 0; } -static int _wrap_Polyline_getIndexAtLength(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; float arg2 ; - float result; SWIG_check_num_args("ofPolyline::getIndexAtLength",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::getIndexAtLength",1,"ofPolyline const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::getIndexAtLength",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_getIndexAtLength",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - result = (float)((ofPolyline const *)arg1)->getIndexAtLength(arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_getIndexAtPercent(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; float arg2 ; - float result; SWIG_check_num_args("ofPolyline::getIndexAtPercent",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::getIndexAtPercent",1,"ofPolyline const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::getIndexAtPercent",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_getIndexAtPercent",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - result = (float)((ofPolyline const *)arg1)->getIndexAtPercent(arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_getLengthAtIndex(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; int arg2 ; - float result; SWIG_check_num_args("ofPolyline::getLengthAtIndex",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::getLengthAtIndex",1,"ofPolyline const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::getLengthAtIndex",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_getLengthAtIndex",1,SWIGTYPE_p_ofPolyline); } arg2 = (int)lua_tonumber(L, 2); - result = (float)((ofPolyline const *)arg1)->getLengthAtIndex(arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_getLengthAtIndexInterpolated(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - float arg2 ; float result; SWIG_check_num_args("ofPolyline::getLengthAtIndexInterpolated",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::getLengthAtIndexInterpolated",1,"ofPolyline const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::getLengthAtIndexInterpolated",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_getLengthAtIndexInterpolated",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - result = (float)((ofPolyline const *)arg1)->getLengthAtIndexInterpolated(arg2); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_getPointAtLength(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; float arg2 ; - ofPoint result; SWIG_check_num_args("ofPolyline::getPointAtLength",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::getPointAtLength",1,"ofPolyline const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::getPointAtLength",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_getPointAtLength",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - result = ((ofPolyline const *)arg1)->getPointAtLength(arg2); { ofPoint * resultptr = new ofPoint((const ofPoint &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_getPointAtPercent(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; float arg2 ; - ofPoint result; SWIG_check_num_args("ofPolyline::getPointAtPercent",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::getPointAtPercent",1,"ofPolyline const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::getPointAtPercent",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_getPointAtPercent",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - result = ((ofPolyline const *)arg1)->getPointAtPercent(arg2); { ofPoint * resultptr = new ofPoint((const ofPoint &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_getPointAtIndexInterpolated(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - float arg2 ; ofPoint result; SWIG_check_num_args("ofPolyline::getPointAtIndexInterpolated",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::getPointAtIndexInterpolated",1,"ofPolyline const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::getPointAtIndexInterpolated",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_getPointAtIndexInterpolated",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - result = ((ofPolyline const *)arg1)->getPointAtIndexInterpolated(arg2); { - ofPoint * resultptr = new ofPoint((const ofPoint &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_getAngleAtIndex(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; int arg2 ; - float result; SWIG_check_num_args("ofPolyline::getAngleAtIndex",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::getAngleAtIndex",1,"ofPolyline const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::getAngleAtIndex",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_getAngleAtIndex",1,SWIGTYPE_p_ofPolyline); } arg2 = (int)lua_tonumber(L, 2); - result = (float)((ofPolyline const *)arg1)->getAngleAtIndex(arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_getAngleAtIndexInterpolated(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - float arg2 ; float result; SWIG_check_num_args("ofPolyline::getAngleAtIndexInterpolated",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::getAngleAtIndexInterpolated",1,"ofPolyline const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::getAngleAtIndexInterpolated",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_getAngleAtIndexInterpolated",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - result = (float)((ofPolyline const *)arg1)->getAngleAtIndexInterpolated(arg2); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_getRotationAtIndex(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; int arg2 ; - ofVec3f result; SWIG_check_num_args("ofPolyline::getRotationAtIndex",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::getRotationAtIndex",1,"ofPolyline const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::getRotationAtIndex",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_getRotationAtIndex",1,SWIGTYPE_p_ofPolyline); } arg2 = (int)lua_tonumber(L, 2); - result = ((ofPolyline const *)arg1)->getRotationAtIndex(arg2); { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_getRotationAtIndexInterpolated(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - float arg2 ; ofVec3f result; SWIG_check_num_args("ofPolyline::getRotationAtIndexInterpolated",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::getRotationAtIndexInterpolated",1,"ofPolyline const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::getRotationAtIndexInterpolated",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_getRotationAtIndexInterpolated",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - result = ((ofPolyline const *)arg1)->getRotationAtIndexInterpolated(arg2); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_getTangentAtIndex(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; int arg2 ; - ofVec3f result; SWIG_check_num_args("ofPolyline::getTangentAtIndex",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::getTangentAtIndex",1,"ofPolyline const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::getTangentAtIndex",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_getTangentAtIndex",1,SWIGTYPE_p_ofPolyline); } arg2 = (int)lua_tonumber(L, 2); - result = ((ofPolyline const *)arg1)->getTangentAtIndex(arg2); { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_getTangentAtIndexInterpolated(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - float arg2 ; ofVec3f result; SWIG_check_num_args("ofPolyline::getTangentAtIndexInterpolated",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::getTangentAtIndexInterpolated",1,"ofPolyline const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::getTangentAtIndexInterpolated",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_getTangentAtIndexInterpolated",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - result = ((ofPolyline const *)arg1)->getTangentAtIndexInterpolated(arg2); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_getNormalAtIndex(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; int arg2 ; - ofVec3f result; SWIG_check_num_args("ofPolyline::getNormalAtIndex",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::getNormalAtIndex",1,"ofPolyline const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::getNormalAtIndex",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_getNormalAtIndex",1,SWIGTYPE_p_ofPolyline); } arg2 = (int)lua_tonumber(L, 2); - result = ((ofPolyline const *)arg1)->getNormalAtIndex(arg2); { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_getNormalAtIndexInterpolated(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - float arg2 ; ofVec3f result; SWIG_check_num_args("ofPolyline::getNormalAtIndexInterpolated",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::getNormalAtIndexInterpolated",1,"ofPolyline const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::getNormalAtIndexInterpolated",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_getNormalAtIndexInterpolated",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - result = ((ofPolyline const *)arg1)->getNormalAtIndexInterpolated(arg2); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_getWrappedIndex(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; int arg2 ; - int result; SWIG_check_num_args("ofPolyline::getWrappedIndex",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::getWrappedIndex",1,"ofPolyline const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::getWrappedIndex",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_getWrappedIndex",1,SWIGTYPE_p_ofPolyline); } arg2 = (int)lua_tonumber(L, 2); - result = (int)((ofPolyline const *)arg1)->getWrappedIndex(arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_setRightVector__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - ofVec3f arg2 ; ofVec3f *argp2 ; SWIG_check_num_args("ofPolyline::setRightVector",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::setRightVector",1,"ofPolyline *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline::setRightVector",2,"ofVec3f"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_setRightVector",1,SWIGTYPE_p_ofPolyline); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Polyline_setRightVector",2,SWIGTYPE_p_ofVec3f); } arg2 = *argp2; (arg1)->setRightVector(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_setRightVector__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - SWIG_check_num_args("ofPolyline::setRightVector",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::setRightVector",1,"ofPolyline *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_setRightVector",1,SWIGTYPE_p_ofPolyline); } (arg1)->setRightVector(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_setRightVector(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Polyline_setRightVector__SWIG_1(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Polyline_setRightVector__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Polyline_setRightVector'\n" - " Possible C/C++ prototypes are:\n" " ofPolyline::setRightVector(ofVec3f)\n" " ofPolyline::setRightVector()\n"); - lua_error(L);return 0; } -static int _wrap_Polyline_getRightVector(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; ofVec3f result; - SWIG_check_num_args("ofPolyline::getRightVector",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::getRightVector",1,"ofPolyline const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_getRightVector",1,SWIGTYPE_p_ofPolyline); } result = ((ofPolyline const *)arg1)->getRightVector(); - { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_draw(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - SWIG_check_num_args("ofPolyline::draw",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::draw",1,"ofPolyline const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_draw",1,SWIGTYPE_p_ofPolyline); } ((ofPolyline const *)arg1)->draw(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_Polyline(void *obj) { -ofPolyline *arg1 = (ofPolyline *) obj; -delete arg1; -} -static int _proxy__wrap_new_Polyline(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_Polyline); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_Polyline_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_Polyline_methods[]= { - { "clear", _wrap_Polyline_clear}, - { "addVertex", _wrap_Polyline_addVertex}, - { "addVertices", _wrap_Polyline_addVertices}, - { "insertVertex", _wrap_Polyline_insertVertex}, - { "resize", _wrap_Polyline_resize}, - { "size", _wrap_Polyline_size}, - { "getVertices", _wrap_Polyline_getVertices}, - { "lineTo", _wrap_Polyline_lineTo}, - { "arc", _wrap_Polyline_arc}, - { "arcNegative", _wrap_Polyline_arcNegative}, - { "curveTo", _wrap_Polyline_curveTo}, - { "bezierTo", _wrap_Polyline_bezierTo}, - { "quadBezierTo", _wrap_Polyline_quadBezierTo}, - { "getSmoothed", _wrap_Polyline_getSmoothed}, - { "getResampledBySpacing", _wrap_Polyline_getResampledBySpacing}, - { "getResampledByCount", _wrap_Polyline_getResampledByCount}, - { "simplify", _wrap_Polyline_simplify}, - { "close", _wrap_Polyline_close}, - { "setClosed", _wrap_Polyline_setClosed}, - { "isClosed", _wrap_Polyline_isClosed}, - { "hasChanged", _wrap_Polyline_hasChanged}, - { "flagHasChanged", _wrap_Polyline_flagHasChanged}, - { "inside", _wrap_Polyline_inside}, - { "getBoundingBox", _wrap_Polyline_getBoundingBox}, - { "getPerimeter", _wrap_Polyline_getPerimeter}, - { "getArea", _wrap_Polyline_getArea}, - { "getCentroid2D", _wrap_Polyline_getCentroid2D}, - { "getClosestPoint", _wrap_Polyline_getClosestPoint}, - { "getIndexAtLength", _wrap_Polyline_getIndexAtLength}, - { "getIndexAtPercent", _wrap_Polyline_getIndexAtPercent}, - { "getLengthAtIndex", _wrap_Polyline_getLengthAtIndex}, - { "getLengthAtIndexInterpolated", _wrap_Polyline_getLengthAtIndexInterpolated}, - { "getPointAtLength", _wrap_Polyline_getPointAtLength}, - { "getPointAtPercent", _wrap_Polyline_getPointAtPercent}, - { "getPointAtIndexInterpolated", _wrap_Polyline_getPointAtIndexInterpolated}, - { "getAngleAtIndex", _wrap_Polyline_getAngleAtIndex}, - { "getAngleAtIndexInterpolated", _wrap_Polyline_getAngleAtIndexInterpolated}, - { "getRotationAtIndex", _wrap_Polyline_getRotationAtIndex}, - { "getRotationAtIndexInterpolated", _wrap_Polyline_getRotationAtIndexInterpolated}, - { "getTangentAtIndex", _wrap_Polyline_getTangentAtIndex}, - { "getTangentAtIndexInterpolated", _wrap_Polyline_getTangentAtIndexInterpolated}, - { "getNormalAtIndex", _wrap_Polyline_getNormalAtIndex}, - { "getNormalAtIndexInterpolated", _wrap_Polyline_getNormalAtIndexInterpolated}, - { "getWrappedIndex", _wrap_Polyline_getWrappedIndex}, - { "setRightVector", _wrap_Polyline_setRightVector}, - { "getRightVector", _wrap_Polyline_getRightVector}, - { "draw", _wrap_Polyline_draw}, - {0,0} -}; -static swig_lua_method swig_Polyline_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_Polyline_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_Polyline_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_Polyline_Sf_SwigStatic_methods[]= { - { "fromRectangle", _wrap_Polyline_fromRectangle}, - {0,0} -}; -static swig_lua_class* swig_Polyline_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_Polyline_Sf_SwigStatic = { - "Polyline", - swig_Polyline_Sf_SwigStatic_methods, - swig_Polyline_Sf_SwigStatic_attributes, - swig_Polyline_Sf_SwigStatic_constants, - swig_Polyline_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_Polyline_bases[] = {0}; -static const char *swig_Polyline_base_names[] = {0}; -static swig_lua_class _wrap_class_Polyline = { "Polyline", "Polyline", &SWIGTYPE_p_ofPolyline,_proxy__wrap_new_Polyline, swig_delete_Polyline, swig_Polyline_methods, swig_Polyline_attributes, &swig_Polyline_Sf_SwigStatic, swig_Polyline_meta, swig_Polyline_bases, swig_Polyline_base_names }; - -static int _wrap_drawBitmapString__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; float arg2 ; float arg3 ; - std::string temp1 ; SWIG_check_num_args("ofDrawBitmapString",3,3) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofDrawBitmapString",1,"std::string const &"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawBitmapString",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawBitmapString",3,"float"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); ofDrawBitmapString((std::string const &)*arg1,arg2,arg3); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawBitmapString__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; ofPoint *arg2 = 0 ; - std::string temp1 ; SWIG_check_num_args("ofDrawBitmapString",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofDrawBitmapString",1,"std::string const &"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofDrawBitmapString",2,"ofPoint const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("drawBitmapString",2,SWIGTYPE_p_ofVec3f); } - ofDrawBitmapString((std::string const &)*arg1,(ofVec3f const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_drawBitmapString__SWIG_2(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; float arg2 ; float arg3 ; - float arg4 ; std::string temp1 ; SWIG_check_num_args("ofDrawBitmapString",4,4) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofDrawBitmapString",1,"std::string const &"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawBitmapString",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawBitmapString",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawBitmapString",4,"float"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - ofDrawBitmapString((std::string const &)*arg1,arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_drawBitmapString(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_drawBitmapString__SWIG_1(L);} } } if (argc == 3) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_drawBitmapString__SWIG_0(L);} } } } if (argc == 4) { int _v; { _v = lua_isstring(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_drawBitmapString__SWIG_2(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'drawBitmapString'\n" " Possible C/C++ prototypes are:\n" - " ofDrawBitmapString(std::string const &,float,float)\n" " ofDrawBitmapString(std::string const &,ofPoint const &)\n" - " ofDrawBitmapString(std::string const &,float,float,float)\n"); lua_error(L);return 0; } -static int _wrap_setColor__SWIG_0(lua_State* L) { int SWIG_arg = 0; int arg1 ; int arg2 ; int arg3 ; - SWIG_check_num_args("ofSetColor",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetColor",1,"int"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSetColor",2,"int"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofSetColor",3,"int"); - arg1 = (int)lua_tonumber(L, 1); arg2 = (int)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); ofSetColor(arg1,arg2,arg3); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setColor__SWIG_1(lua_State* L) { int SWIG_arg = 0; int arg1 ; int arg2 ; int arg3 ; int arg4 ; - SWIG_check_num_args("ofSetColor",4,4) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetColor",1,"int"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSetColor",2,"int"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofSetColor",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofSetColor",4,"int"); arg1 = (int)lua_tonumber(L, 1); arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); ofSetColor(arg1,arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setColor__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofColor *arg1 = 0 ; SWIG_check_num_args("ofSetColor",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofSetColor",1,"ofColor const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("setColor",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } ofSetColor((ofColor_< unsigned char > const &)*arg1); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setColor__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofColor *arg1 = 0 ; int arg2 ; - SWIG_check_num_args("ofSetColor",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofSetColor",1,"ofColor const &"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSetColor",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("setColor",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } arg2 = (int)lua_tonumber(L, 2); - ofSetColor((ofColor_< unsigned char > const &)*arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_setColor__SWIG_4(lua_State* L) { int SWIG_arg = 0; int arg1 ; SWIG_check_num_args("ofSetColor",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetColor",1,"int"); arg1 = (int)lua_tonumber(L, 1); ofSetColor(arg1); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setColor(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_setColor__SWIG_2(L);} } if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_setColor__SWIG_4(L);} } if (argc == 2) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_setColor__SWIG_3(L);} - } } if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_setColor__SWIG_0(L);} } } } if (argc == 4) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_setColor__SWIG_1(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'setColor'\n" " Possible C/C++ prototypes are:\n" - " ofSetColor(int,int,int)\n" " ofSetColor(int,int,int,int)\n" " ofSetColor(ofColor const &)\n" - " ofSetColor(ofColor const &,int)\n" " ofSetColor(int)\n"); lua_error(L);return 0; } -static int _wrap_setHexColor(lua_State* L) { int SWIG_arg = 0; int arg1 ; SWIG_check_num_args("ofSetHexColor",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetHexColor",1,"int"); arg1 = (int)lua_tonumber(L, 1); ofSetHexColor(arg1); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_noFill(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofNoFill",0,0) ofNoFill(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_fill(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofFill",0,0) ofFill(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getFill(lua_State* L) { int SWIG_arg = 0; ofFillFlag result; SWIG_check_num_args("ofGetFill",0,0) - result = (ofFillFlag)ofGetFill(); lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_getBackgroundColor(lua_State* L) { int SWIG_arg = 0; ofColor result; - SWIG_check_num_args("ofGetBackgroundColor",0,0) result = ofGetBackgroundColor(); { - ofColor * resultptr = new ofColor((const ofColor &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_background__SWIG_0(lua_State* L) { int SWIG_arg = 0; int arg1 ; int arg2 ; int arg3 ; int arg4 ; - SWIG_check_num_args("ofBackground",4,4) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofBackground",1,"int"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBackground",2,"int"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofBackground",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofBackground",4,"int"); arg1 = (int)lua_tonumber(L, 1); arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); ofBackground(arg1,arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_background__SWIG_1(lua_State* L) { int SWIG_arg = 0; int arg1 ; int arg2 ; int arg3 ; - SWIG_check_num_args("ofBackground",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofBackground",1,"int"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBackground",2,"int"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofBackground",3,"int"); - arg1 = (int)lua_tonumber(L, 1); arg2 = (int)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); ofBackground(arg1,arg2,arg3); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_background__SWIG_2(lua_State* L) { int SWIG_arg = 0; int arg1 ; int arg2 ; - SWIG_check_num_args("ofBackground",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofBackground",1,"int"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBackground",2,"int"); arg1 = (int)lua_tonumber(L, 1); arg2 = (int)lua_tonumber(L, 2); - ofBackground(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_background__SWIG_3(lua_State* L) { int SWIG_arg = 0; int arg1 ; SWIG_check_num_args("ofBackground",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofBackground",1,"int"); arg1 = (int)lua_tonumber(L, 1); ofBackground(arg1); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_background__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofColor *arg1 = 0 ; - SWIG_check_num_args("ofBackground",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofBackground",1,"ofColor const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("background",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - ofBackground((ofColor_< unsigned char > const &)*arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_background(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 1) { int _v; - { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_background__SWIG_4(L);} } if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_background__SWIG_3(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_background__SWIG_2(L);} } } if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_background__SWIG_1(L);} } } } if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_background__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'background'\n" " Possible C/C++ prototypes are:\n" - " ofBackground(int,int,int,int)\n" " ofBackground(int,int,int)\n" " ofBackground(int,int)\n" - " ofBackground(int)\n" " ofBackground(ofColor const &)\n"); lua_error(L);return 0; } -static int _wrap_backgroundHex__SWIG_0(lua_State* L) { int SWIG_arg = 0; int arg1 ; int arg2 ; - SWIG_check_num_args("ofBackgroundHex",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofBackgroundHex",1,"int"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBackgroundHex",2,"int"); arg1 = (int)lua_tonumber(L, 1); - arg2 = (int)lua_tonumber(L, 2); ofBackgroundHex(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_backgroundHex__SWIG_1(lua_State* L) { int SWIG_arg = 0; int arg1 ; SWIG_check_num_args("ofBackgroundHex",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofBackgroundHex",1,"int"); arg1 = (int)lua_tonumber(L, 1); ofBackgroundHex(arg1); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_backgroundHex(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_backgroundHex__SWIG_1(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_backgroundHex__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'backgroundHex'\n" " Possible C/C++ prototypes are:\n" - " ofBackgroundHex(int,int)\n" " ofBackgroundHex(int)\n"); lua_error(L);return 0; } -static int _wrap_backgroundGradient__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofColor *arg1 = 0 ; ofColor *arg2 = 0 ; - ofGradientMode arg3 ; SWIG_check_num_args("ofBackgroundGradient",3,3) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofBackgroundGradient",1,"ofColor const &"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofBackgroundGradient",2,"ofColor const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofBackgroundGradient",3,"ofGradientMode"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("backgroundGradient",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("backgroundGradient",2,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - arg3 = (ofGradientMode)(int)lua_tonumber(L, 3); - ofBackgroundGradient((ofColor_< unsigned char > const &)*arg1,(ofColor_< unsigned char > const &)*arg2,arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_backgroundGradient__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofColor *arg1 = 0 ; ofColor *arg2 = 0 ; - SWIG_check_num_args("ofBackgroundGradient",2,2) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofBackgroundGradient",1,"ofColor const &"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofBackgroundGradient",2,"ofColor const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("backgroundGradient",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("backgroundGradient",2,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - ofBackgroundGradient((ofColor_< unsigned char > const &)*arg1,(ofColor_< unsigned char > const &)*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_backgroundGradient(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_backgroundGradient__SWIG_1(L);} } } if (argc == 3) { int _v; - { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_backgroundGradient__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'backgroundGradient'\n" " Possible C/C++ prototypes are:\n" - " ofBackgroundGradient(ofColor const &,ofColor const &,ofGradientMode)\n" - " ofBackgroundGradient(ofColor const &,ofColor const &)\n"); lua_error(L);return 0; } -static int _wrap_setBackgroundColor__SWIG_0(lua_State* L) { int SWIG_arg = 0; int arg1 ; int arg2 ; int arg3 ; int arg4 ; - SWIG_check_num_args("ofSetBackgroundColor",4,4) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetBackgroundColor",1,"int"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSetBackgroundColor",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofSetBackgroundColor",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofSetBackgroundColor",4,"int"); arg1 = (int)lua_tonumber(L, 1); - arg2 = (int)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - ofSetBackgroundColor(arg1,arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setBackgroundColor__SWIG_1(lua_State* L) { int SWIG_arg = 0; int arg1 ; int arg2 ; int arg3 ; - SWIG_check_num_args("ofSetBackgroundColor",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetBackgroundColor",1,"int"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSetBackgroundColor",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofSetBackgroundColor",3,"int"); arg1 = (int)lua_tonumber(L, 1); - arg2 = (int)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); ofSetBackgroundColor(arg1,arg2,arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setBackgroundColor__SWIG_2(lua_State* L) { int SWIG_arg = 0; int arg1 ; int arg2 ; - SWIG_check_num_args("ofSetBackgroundColor",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetBackgroundColor",1,"int"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSetBackgroundColor",2,"int"); arg1 = (int)lua_tonumber(L, 1); - arg2 = (int)lua_tonumber(L, 2); ofSetBackgroundColor(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_setBackgroundColor__SWIG_3(lua_State* L) { int SWIG_arg = 0; int arg1 ; - SWIG_check_num_args("ofSetBackgroundColor",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetBackgroundColor",1,"int"); - arg1 = (int)lua_tonumber(L, 1); ofSetBackgroundColor(arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_setBackgroundColor__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofColor *arg1 = 0 ; - SWIG_check_num_args("ofSetBackgroundColor",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofSetBackgroundColor",1,"ofColor const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("setBackgroundColor",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - ofSetBackgroundColor((ofColor_< unsigned char > const &)*arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_setBackgroundColor(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_setBackgroundColor__SWIG_4(L);} } if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_setBackgroundColor__SWIG_3(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_setBackgroundColor__SWIG_2(L);} } } if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_setBackgroundColor__SWIG_1(L);} } } } if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_setBackgroundColor__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'setBackgroundColor'\n" " Possible C/C++ prototypes are:\n" - " ofSetBackgroundColor(int,int,int,int)\n" " ofSetBackgroundColor(int,int,int)\n" " ofSetBackgroundColor(int,int)\n" - " ofSetBackgroundColor(int)\n" " ofSetBackgroundColor(ofColor const &)\n"); lua_error(L);return 0; } -static int _wrap_setBackgroundColorHex__SWIG_0(lua_State* L) { int SWIG_arg = 0; int arg1 ; int arg2 ; - SWIG_check_num_args("ofSetBackgroundColorHex",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetBackgroundColorHex",1,"int"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSetBackgroundColorHex",2,"int"); arg1 = (int)lua_tonumber(L, 1); - arg2 = (int)lua_tonumber(L, 2); ofSetBackgroundColorHex(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_setBackgroundColorHex__SWIG_1(lua_State* L) { int SWIG_arg = 0; int arg1 ; - SWIG_check_num_args("ofSetBackgroundColorHex",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetBackgroundColorHex",1,"int"); - arg1 = (int)lua_tonumber(L, 1); ofSetBackgroundColorHex(arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_setBackgroundColorHex(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_setBackgroundColorHex__SWIG_1(L);} } if (argc == 2) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_setBackgroundColorHex__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'setBackgroundColorHex'\n" - " Possible C/C++ prototypes are:\n" " ofSetBackgroundColorHex(int,int)\n" " ofSetBackgroundColorHex(int)\n"); - lua_error(L);return 0; } -static int _wrap_setBackgroundAuto(lua_State* L) { int SWIG_arg = 0; bool arg1 ; SWIG_check_num_args("ofSetBackgroundAuto",1,1) - if(!lua_isboolean(L,1)) SWIG_fail_arg("ofSetBackgroundAuto",1,"bool"); arg1 = (lua_toboolean(L, 1)!=0); - ofSetBackgroundAuto(arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getBackgroundAuto(lua_State* L) { int SWIG_arg = 0; bool result; SWIG_check_num_args("ofGetBackgroundAuto",0,0) - result = (bool)ofGetBackgroundAuto(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_clear__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - SWIG_check_num_args("ofClear",4,4) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofClear",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofClear",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofClear",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofClear",4,"float"); arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); ofClear(arg1,arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_clear__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofClear",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofClear",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofClear",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofClear",3,"float"); - arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); ofClear(arg1,arg2,arg3); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_clear__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; SWIG_check_num_args("ofClear",2,2) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofClear",1,"float"); if(!lua_isnumber(L,2)) SWIG_fail_arg("ofClear",2,"float"); - arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); ofClear(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_clear__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; SWIG_check_num_args("ofClear",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofClear",1,"float"); arg1 = (float)lua_tonumber(L, 1); ofClear(arg1); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_clear__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofColor *arg1 = 0 ; SWIG_check_num_args("ofClear",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofClear",1,"ofColor const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("clear",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } ofClear((ofColor_< unsigned char > const &)*arg1); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_clear(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_clear__SWIG_4(L);} } if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_clear__SWIG_3(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_clear__SWIG_2(L);} } - } if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_clear__SWIG_1(L);} } } } if (argc == 4) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_clear__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'clear'\n" " Possible C/C++ prototypes are:\n" - " ofClear(float,float,float,float)\n" " ofClear(float,float,float)\n" " ofClear(float,float)\n" - " ofClear(float)\n" " ofClear(ofColor const &)\n"); lua_error(L);return 0; } -static int _wrap_clearAlpha(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofClearAlpha",0,0) ofClearAlpha(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawTriangle__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - float arg5 ; float arg6 ; SWIG_check_num_args("ofDrawTriangle",6,6) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawTriangle",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawTriangle",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawTriangle",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawTriangle",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofDrawTriangle",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofDrawTriangle",6,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); ofDrawTriangle(arg1,arg2,arg3,arg4,arg5,arg6); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawTriangle__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - float arg5 ; float arg6 ; float arg7 ; float arg8 ; float arg9 ; SWIG_check_num_args("ofDrawTriangle",9,9) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawTriangle",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawTriangle",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawTriangle",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawTriangle",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofDrawTriangle",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofDrawTriangle",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofDrawTriangle",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofDrawTriangle",8,"float"); - if(!lua_isnumber(L,9)) SWIG_fail_arg("ofDrawTriangle",9,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); - arg8 = (float)lua_tonumber(L, 8); arg9 = (float)lua_tonumber(L, 9); - ofDrawTriangle(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_drawTriangle__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPoint *arg1 = 0 ; ofPoint *arg2 = 0 ; - ofPoint *arg3 = 0 ; SWIG_check_num_args("ofDrawTriangle",3,3) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofDrawTriangle",1,"ofPoint const &"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofDrawTriangle",2,"ofPoint const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofDrawTriangle",3,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("drawTriangle",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("drawTriangle",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("drawTriangle",3,SWIGTYPE_p_ofVec3f); } - ofDrawTriangle((ofVec3f const &)*arg1,(ofVec3f const &)*arg2,(ofVec3f const &)*arg3); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_drawTriangle(lua_State* L) { int argc; int argv[10]={ 1,2,3,4,5,6,7,8,9,10} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_drawTriangle__SWIG_2(L);} } } } if (argc == 6) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { return _wrap_drawTriangle__SWIG_0(L);} } } } } } } - if (argc == 9) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { { - _v = lua_isnumber(L,argv[6]); } if (_v) { { _v = lua_isnumber(L,argv[7]); } if (_v) { { - _v = lua_isnumber(L,argv[8]); } if (_v) { return _wrap_drawTriangle__SWIG_1(L);} } } } } } } } } - } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'drawTriangle'\n" " Possible C/C++ prototypes are:\n" - " ofDrawTriangle(float,float,float,float,float,float)\n" - " ofDrawTriangle(float,float,float,float,float,float,float,float,float)\n" - " ofDrawTriangle(ofPoint const &,ofPoint const &,ofPoint const &)\n"); lua_error(L);return 0; } -static int _wrap_drawCircle__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofDrawCircle",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawCircle",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawCircle",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawCircle",3,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); ofDrawCircle(arg1,arg2,arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawCircle__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - SWIG_check_num_args("ofDrawCircle",4,4) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawCircle",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawCircle",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawCircle",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawCircle",4,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - ofDrawCircle(arg1,arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawCircle__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPoint *arg1 = 0 ; float arg2 ; - SWIG_check_num_args("ofDrawCircle",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofDrawCircle",1,"ofPoint const &"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawCircle",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("drawCircle",1,SWIGTYPE_p_ofVec3f); } - arg2 = (float)lua_tonumber(L, 2); ofDrawCircle((ofVec3f const &)*arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_drawCircle(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { int _v; - { void *ptr; if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_drawCircle__SWIG_2(L);} } } if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_drawCircle__SWIG_0(L);} } } } if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_drawCircle__SWIG_1(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'drawCircle'\n" " Possible C/C++ prototypes are:\n" - " ofDrawCircle(float,float,float)\n" " ofDrawCircle(float,float,float,float)\n" - " ofDrawCircle(ofPoint const &,float)\n"); lua_error(L);return 0; } -static int _wrap_drawEllipse__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - SWIG_check_num_args("ofDrawEllipse",4,4) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawEllipse",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawEllipse",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawEllipse",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawEllipse",4,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - ofDrawEllipse(arg1,arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawEllipse__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - float arg5 ; SWIG_check_num_args("ofDrawEllipse",5,5) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawEllipse",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawEllipse",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawEllipse",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawEllipse",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofDrawEllipse",5,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); ofDrawEllipse(arg1,arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_drawEllipse__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPoint *arg1 = 0 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofDrawEllipse",3,3) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofDrawEllipse",1,"ofPoint const &"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawEllipse",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawEllipse",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("drawEllipse",1,SWIGTYPE_p_ofVec3f); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); ofDrawEllipse((ofVec3f const &)*arg1,arg2,arg3); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawEllipse(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_drawEllipse__SWIG_2(L);} } } } if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { - { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_drawEllipse__SWIG_0(L);} } } } } if (argc == 5) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_drawEllipse__SWIG_1(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'drawEllipse'\n" " Possible C/C++ prototypes are:\n" - " ofDrawEllipse(float,float,float,float)\n" " ofDrawEllipse(float,float,float,float,float)\n" - " ofDrawEllipse(ofPoint const &,float,float)\n"); lua_error(L);return 0; } -static int _wrap_drawLine__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - SWIG_check_num_args("ofDrawLine",4,4) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawLine",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawLine",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawLine",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawLine",4,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - ofDrawLine(arg1,arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawLine__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - float arg5 ; float arg6 ; SWIG_check_num_args("ofDrawLine",6,6) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawLine",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawLine",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawLine",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawLine",4,"float"); if(!lua_isnumber(L,5)) SWIG_fail_arg("ofDrawLine",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofDrawLine",6,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); ofDrawLine(arg1,arg2,arg3,arg4,arg5,arg6); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawLine__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPoint *arg1 = 0 ; ofPoint *arg2 = 0 ; - SWIG_check_num_args("ofDrawLine",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofDrawLine",1,"ofPoint const &"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofDrawLine",2,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("drawLine",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("drawLine",2,SWIGTYPE_p_ofVec3f); } - ofDrawLine((ofVec3f const &)*arg1,(ofVec3f const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_drawLine(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_drawLine__SWIG_2(L);} } } if (argc == 4) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_drawLine__SWIG_0(L);} } } } } if (argc == 6) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { - return _wrap_drawLine__SWIG_1(L);} } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'drawLine'\n" " Possible C/C++ prototypes are:\n" - " ofDrawLine(float,float,float,float)\n" " ofDrawLine(float,float,float,float,float,float)\n" - " ofDrawLine(ofPoint const &,ofPoint const &)\n"); lua_error(L);return 0; } -static int _wrap_drawRectangle__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - SWIG_check_num_args("ofDrawRectangle",4,4) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawRectangle",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawRectangle",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawRectangle",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawRectangle",4,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - ofDrawRectangle(arg1,arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawRectangle__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = 0 ; - SWIG_check_num_args("ofDrawRectangle",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofDrawRectangle",1,"ofRectangle const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("drawRectangle",1,SWIGTYPE_p_ofRectangle); } ofDrawRectangle((ofRectangle const &)*arg1); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawRectangle__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPoint *arg1 = 0 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofDrawRectangle",3,3) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofDrawRectangle",1,"ofPoint const &"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawRectangle",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawRectangle",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("drawRectangle",1,SWIGTYPE_p_ofVec3f); } arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - ofDrawRectangle((ofVec3f const &)*arg1,arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawRectangle__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - float arg5 ; SWIG_check_num_args("ofDrawRectangle",5,5) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawRectangle",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawRectangle",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawRectangle",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawRectangle",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofDrawRectangle",5,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); ofDrawRectangle(arg1,arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_drawRectangle(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_drawRectangle__SWIG_1(L);} } if (argc == 3) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_drawRectangle__SWIG_2(L);} } } } if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_drawRectangle__SWIG_0(L);} } } } } if (argc == 5) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_drawRectangle__SWIG_3(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'drawRectangle'\n" " Possible C/C++ prototypes are:\n" - " ofDrawRectangle(float,float,float,float)\n" " ofDrawRectangle(ofRectangle const &)\n" - " ofDrawRectangle(ofPoint const &,float,float)\n" " ofDrawRectangle(float,float,float,float,float)\n"); - lua_error(L);return 0; } -static int _wrap_drawRectRounded__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = 0 ; float arg2 ; - SWIG_check_num_args("ofDrawRectRounded",2,2) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofDrawRectRounded",1,"ofRectangle const &"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawRectRounded",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("drawRectRounded",1,SWIGTYPE_p_ofRectangle); } arg2 = (float)lua_tonumber(L, 2); - ofDrawRectRounded((ofRectangle const &)*arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawRectRounded__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPoint *arg1 = 0 ; float arg2 ; float arg3 ; - float arg4 ; SWIG_check_num_args("ofDrawRectRounded",4,4) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofDrawRectRounded",1,"ofPoint const &"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawRectRounded",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawRectRounded",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawRectRounded",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("drawRectRounded",1,SWIGTYPE_p_ofVec3f); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); ofDrawRectRounded((ofVec3f const &)*arg1,arg2,arg3,arg4); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawRectRounded__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - float arg5 ; SWIG_check_num_args("ofDrawRectRounded",5,5) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawRectRounded",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawRectRounded",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawRectRounded",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawRectRounded",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofDrawRectRounded",5,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); ofDrawRectRounded(arg1,arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_drawRectRounded__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - float arg5 ; float arg6 ; SWIG_check_num_args("ofDrawRectRounded",6,6) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawRectRounded",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawRectRounded",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawRectRounded",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawRectRounded",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofDrawRectRounded",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofDrawRectRounded",6,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); ofDrawRectRounded(arg1,arg2,arg3,arg4,arg5,arg6); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawRectRounded__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofPoint *arg1 = 0 ; float arg2 ; float arg3 ; - float arg4 ; float arg5 ; float arg6 ; float arg7 ; SWIG_check_num_args("ofDrawRectRounded",7,7) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofDrawRectRounded",1,"ofPoint const &"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawRectRounded",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawRectRounded",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawRectRounded",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofDrawRectRounded",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofDrawRectRounded",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofDrawRectRounded",7,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("drawRectRounded",1,SWIGTYPE_p_ofVec3f); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); - ofDrawRectRounded((ofVec3f const &)*arg1,arg2,arg3,arg4,arg5,arg6,arg7); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_drawRectRounded__SWIG_5(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = 0 ; float arg2 ; float arg3 ; - float arg4 ; float arg5 ; SWIG_check_num_args("ofDrawRectRounded",5,5) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofDrawRectRounded",1,"ofRectangle const &"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawRectRounded",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawRectRounded",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawRectRounded",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofDrawRectRounded",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("drawRectRounded",1,SWIGTYPE_p_ofRectangle); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - ofDrawRectRounded((ofRectangle const &)*arg1,arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_drawRectRounded__SWIG_6(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - float arg5 ; float arg6 ; float arg7 ; float arg8 ; float arg9 ; SWIG_check_num_args("ofDrawRectRounded",9,9) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawRectRounded",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawRectRounded",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawRectRounded",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawRectRounded",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofDrawRectRounded",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofDrawRectRounded",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofDrawRectRounded",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofDrawRectRounded",8,"float"); - if(!lua_isnumber(L,9)) SWIG_fail_arg("ofDrawRectRounded",9,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); - arg8 = (float)lua_tonumber(L, 8); arg9 = (float)lua_tonumber(L, 9); - ofDrawRectRounded(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_drawRectRounded(lua_State* L) { int argc; int argv[10]={ 1,2,3,4,5,6,7,8,9,10} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_drawRectRounded__SWIG_0(L);} } - } if (argc == 4) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_drawRectRounded__SWIG_1(L);} } } } } if (argc == 5) { - int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_drawRectRounded__SWIG_5(L);} } } } } } if (argc == 5) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_drawRectRounded__SWIG_2(L);} } } } } } if (argc == 6) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { return _wrap_drawRectRounded__SWIG_3(L);} } } } } } } - if (argc == 7) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { - return _wrap_drawRectRounded__SWIG_4(L);} } } } } } } } if (argc == 9) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { { _v = lua_isnumber(L,argv[8]); } if (_v) { - return _wrap_drawRectRounded__SWIG_6(L);} } } } } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'drawRectRounded'\n" " Possible C/C++ prototypes are:\n" - " ofDrawRectRounded(ofRectangle const &,float)\n" " ofDrawRectRounded(ofPoint const &,float,float,float)\n" - " ofDrawRectRounded(float,float,float,float,float)\n" " ofDrawRectRounded(float,float,float,float,float,float)\n" - " ofDrawRectRounded(ofPoint const &,float,float,float,float,float,float)\n" - " ofDrawRectRounded(ofRectangle const &,float,float,float,float)\n" - " ofDrawRectRounded(float,float,float,float,float,float,float,float,float)\n"); lua_error(L);return 0; } -static int _wrap_drawCurve__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - float arg5 ; float arg6 ; float arg7 ; float arg8 ; SWIG_check_num_args("ofDrawCurve",8,8) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawCurve",1,"float"); if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawCurve",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawCurve",3,"float"); if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawCurve",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofDrawCurve",5,"float"); if(!lua_isnumber(L,6)) SWIG_fail_arg("ofDrawCurve",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofDrawCurve",7,"float"); if(!lua_isnumber(L,8)) SWIG_fail_arg("ofDrawCurve",8,"float"); - arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); - arg7 = (float)lua_tonumber(L, 7); arg8 = (float)lua_tonumber(L, 8); ofDrawCurve(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawCurve__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - float arg5 ; float arg6 ; float arg7 ; float arg8 ; float arg9 ; float arg10 ; float arg11 ; float arg12 ; - SWIG_check_num_args("ofDrawCurve",12,12) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawCurve",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawCurve",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawCurve",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawCurve",4,"float"); if(!lua_isnumber(L,5)) SWIG_fail_arg("ofDrawCurve",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofDrawCurve",6,"float"); if(!lua_isnumber(L,7)) SWIG_fail_arg("ofDrawCurve",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofDrawCurve",8,"float"); if(!lua_isnumber(L,9)) SWIG_fail_arg("ofDrawCurve",9,"float"); - if(!lua_isnumber(L,10)) SWIG_fail_arg("ofDrawCurve",10,"float"); - if(!lua_isnumber(L,11)) SWIG_fail_arg("ofDrawCurve",11,"float"); - if(!lua_isnumber(L,12)) SWIG_fail_arg("ofDrawCurve",12,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); - arg8 = (float)lua_tonumber(L, 8); arg9 = (float)lua_tonumber(L, 9); arg10 = (float)lua_tonumber(L, 10); - arg11 = (float)lua_tonumber(L, 11); arg12 = (float)lua_tonumber(L, 12); - ofDrawCurve(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_drawCurve(lua_State* L) { int argc; int argv[13]={ 1,2,3,4,5,6,7,8,9,10,11,12,13} ; argc = lua_gettop(L); - if (argc == 8) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { { - _v = lua_isnumber(L,argv[6]); } if (_v) { { _v = lua_isnumber(L,argv[7]); } if (_v) { - return _wrap_drawCurve__SWIG_0(L);} } } } } } } } } if (argc == 12) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { { _v = lua_isnumber(L,argv[8]); } if (_v) { { - _v = lua_isnumber(L,argv[9]); } if (_v) { { _v = lua_isnumber(L,argv[10]); } if (_v) { { - _v = lua_isnumber(L,argv[11]); } if (_v) { return _wrap_drawCurve__SWIG_1(L);} } } } } } } } - } } } } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'drawCurve'\n" - " Possible C/C++ prototypes are:\n" " ofDrawCurve(float,float,float,float,float,float,float,float)\n" - " ofDrawCurve(float,float,float,float,float,float,float,float,float,float,float,float)\n"); lua_error(L);return 0; } -static int _wrap_drawBezier__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - float arg5 ; float arg6 ; float arg7 ; float arg8 ; SWIG_check_num_args("ofDrawBezier",8,8) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawBezier",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawBezier",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawBezier",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawBezier",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofDrawBezier",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofDrawBezier",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofDrawBezier",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofDrawBezier",8,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); - arg8 = (float)lua_tonumber(L, 8); ofDrawBezier(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawBezier__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - float arg5 ; float arg6 ; float arg7 ; float arg8 ; float arg9 ; float arg10 ; float arg11 ; float arg12 ; - SWIG_check_num_args("ofDrawBezier",12,12) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawBezier",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawBezier",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawBezier",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawBezier",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofDrawBezier",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofDrawBezier",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofDrawBezier",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofDrawBezier",8,"float"); - if(!lua_isnumber(L,9)) SWIG_fail_arg("ofDrawBezier",9,"float"); - if(!lua_isnumber(L,10)) SWIG_fail_arg("ofDrawBezier",10,"float"); - if(!lua_isnumber(L,11)) SWIG_fail_arg("ofDrawBezier",11,"float"); - if(!lua_isnumber(L,12)) SWIG_fail_arg("ofDrawBezier",12,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); - arg8 = (float)lua_tonumber(L, 8); arg9 = (float)lua_tonumber(L, 9); arg10 = (float)lua_tonumber(L, 10); - arg11 = (float)lua_tonumber(L, 11); arg12 = (float)lua_tonumber(L, 12); - ofDrawBezier(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_drawBezier(lua_State* L) { int argc; int argv[13]={ 1,2,3,4,5,6,7,8,9,10,11,12,13} ; argc = lua_gettop(L); - if (argc == 8) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { { - _v = lua_isnumber(L,argv[6]); } if (_v) { { _v = lua_isnumber(L,argv[7]); } if (_v) { - return _wrap_drawBezier__SWIG_0(L);} } } } } } } } } if (argc == 12) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { { _v = lua_isnumber(L,argv[8]); } if (_v) { { - _v = lua_isnumber(L,argv[9]); } if (_v) { { _v = lua_isnumber(L,argv[10]); } if (_v) { { - _v = lua_isnumber(L,argv[11]); } if (_v) { return _wrap_drawBezier__SWIG_1(L);} } } } } } } } - } } } } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'drawBezier'\n" - " Possible C/C++ prototypes are:\n" " ofDrawBezier(float,float,float,float,float,float,float,float)\n" - " ofDrawBezier(float,float,float,float,float,float,float,float,float,float,float,float)\n"); lua_error(L);return 0; } -static int _wrap_beginShape(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofBeginShape",0,0) ofBeginShape(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_vertex__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; SWIG_check_num_args("ofVertex",2,2) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofVertex",1,"float"); if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVertex",2,"float"); - arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); ofVertex(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_vertex__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofVertex",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofVertex",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVertex",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVertex",3,"float"); - arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - ofVertex(arg1,arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_vertex__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPoint *arg1 = 0 ; SWIG_check_num_args("ofVertex",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofVertex",1,"ofPoint &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("vertex",1,SWIGTYPE_p_ofVec3f); } - ofVertex(*arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_vertex(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_vertex__SWIG_2(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_vertex__SWIG_0(L);} } - } if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_vertex__SWIG_1(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'vertex'\n" " Possible C/C++ prototypes are:\n" - " ofVertex(float,float)\n" " ofVertex(float,float,float)\n" " ofVertex(ofPoint &)\n"); lua_error(L);return 0; } -static int _wrap_vertices(lua_State* L) { int SWIG_arg = 0; std::vector< ofPoint > *arg1 = 0 ; - SWIG_check_num_args("ofVertices",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofVertices",1,"std::vector< ofPoint > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofVec3f_t,0))){ - SWIG_fail_ptr("vertices",1,SWIGTYPE_p_std__vectorT_ofVec3f_t); } ofVertices((std::vector< ofVec3f > const &)*arg1); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_curveVertex__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; - SWIG_check_num_args("ofCurveVertex",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofCurveVertex",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofCurveVertex",2,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); ofCurveVertex(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_curveVertex__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofCurveVertex",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofCurveVertex",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofCurveVertex",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofCurveVertex",3,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); ofCurveVertex(arg1,arg2,arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_curveVertex__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPoint *arg1 = 0 ; - SWIG_check_num_args("ofCurveVertex",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofCurveVertex",1,"ofPoint &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("curveVertex",1,SWIGTYPE_p_ofVec3f); } - ofCurveVertex(*arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_curveVertex(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_curveVertex__SWIG_2(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_curveVertex__SWIG_0(L);} } } if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_curveVertex__SWIG_1(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'curveVertex'\n" " Possible C/C++ prototypes are:\n" - " ofCurveVertex(float,float)\n" " ofCurveVertex(float,float,float)\n" " ofCurveVertex(ofPoint &)\n"); - lua_error(L);return 0; } -static int _wrap_curveVertices(lua_State* L) { int SWIG_arg = 0; std::vector< ofPoint > *arg1 = 0 ; - SWIG_check_num_args("ofCurveVertices",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofCurveVertices",1,"std::vector< ofPoint > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofVec3f_t,0))){ - SWIG_fail_ptr("curveVertices",1,SWIGTYPE_p_std__vectorT_ofVec3f_t); } - ofCurveVertices((std::vector< ofVec3f > const &)*arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_bezierVertex__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - float arg5 ; float arg6 ; SWIG_check_num_args("ofBezierVertex",6,6) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofBezierVertex",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBezierVertex",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofBezierVertex",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofBezierVertex",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofBezierVertex",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofBezierVertex",6,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); ofBezierVertex(arg1,arg2,arg3,arg4,arg5,arg6); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_bezierVertex__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPoint *arg1 = 0 ; ofPoint *arg2 = 0 ; - ofPoint *arg3 = 0 ; SWIG_check_num_args("ofBezierVertex",3,3) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofBezierVertex",1,"ofPoint const &"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofBezierVertex",2,"ofPoint const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofBezierVertex",3,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("bezierVertex",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("bezierVertex",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("bezierVertex",3,SWIGTYPE_p_ofVec3f); } - ofBezierVertex((ofVec3f const &)*arg1,(ofVec3f const &)*arg2,(ofVec3f const &)*arg3); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_bezierVertex__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - float arg5 ; float arg6 ; float arg7 ; float arg8 ; float arg9 ; SWIG_check_num_args("ofBezierVertex",9,9) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofBezierVertex",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBezierVertex",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofBezierVertex",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofBezierVertex",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofBezierVertex",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofBezierVertex",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofBezierVertex",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofBezierVertex",8,"float"); - if(!lua_isnumber(L,9)) SWIG_fail_arg("ofBezierVertex",9,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); - arg8 = (float)lua_tonumber(L, 8); arg9 = (float)lua_tonumber(L, 9); - ofBezierVertex(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_bezierVertex(lua_State* L) { int argc; int argv[10]={ 1,2,3,4,5,6,7,8,9,10} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_bezierVertex__SWIG_1(L);} } } } if (argc == 6) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { return _wrap_bezierVertex__SWIG_0(L);} } } } } } } - if (argc == 9) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { { - _v = lua_isnumber(L,argv[6]); } if (_v) { { _v = lua_isnumber(L,argv[7]); } if (_v) { { - _v = lua_isnumber(L,argv[8]); } if (_v) { return _wrap_bezierVertex__SWIG_2(L);} } } } } } } } } - } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'bezierVertex'\n" " Possible C/C++ prototypes are:\n" - " ofBezierVertex(float,float,float,float,float,float)\n" - " ofBezierVertex(ofPoint const &,ofPoint const &,ofPoint const &)\n" - " ofBezierVertex(float,float,float,float,float,float,float,float,float)\n"); lua_error(L);return 0; } -static int _wrap_endShape__SWIG_0(lua_State* L) { int SWIG_arg = 0; bool arg1 ; SWIG_check_num_args("ofEndShape",1,1) - if(!lua_isboolean(L,1)) SWIG_fail_arg("ofEndShape",1,"bool"); arg1 = (lua_toboolean(L, 1)!=0); ofEndShape(arg1); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_endShape__SWIG_1(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofEndShape",0,0) ofEndShape(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_endShape(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_endShape__SWIG_1(L);} if (argc == 1) { int _v; { _v = lua_isboolean(L,argv[0]); } if (_v) { - return _wrap_endShape__SWIG_0(L);} } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'endShape'\n" - " Possible C/C++ prototypes are:\n" " ofEndShape(bool)\n" " ofEndShape()\n"); lua_error(L);return 0; } -static int _wrap_nextContour__SWIG_0(lua_State* L) { int SWIG_arg = 0; bool arg1 ; SWIG_check_num_args("ofNextContour",1,1) - if(!lua_isboolean(L,1)) SWIG_fail_arg("ofNextContour",1,"bool"); arg1 = (lua_toboolean(L, 1)!=0); ofNextContour(arg1); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_nextContour__SWIG_1(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofNextContour",0,0) ofNextContour(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_nextContour(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_nextContour__SWIG_1(L);} if (argc == 1) { int _v; { _v = lua_isboolean(L,argv[0]); } if (_v) { - return _wrap_nextContour__SWIG_0(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'nextContour'\n" " Possible C/C++ prototypes are:\n" - " ofNextContour(bool)\n" " ofNextContour()\n"); lua_error(L);return 0; } -static int _wrap_setDrawBitmapMode(lua_State* L) { int SWIG_arg = 0; ofDrawBitmapMode arg1 ; - SWIG_check_num_args("ofSetDrawBitmapMode",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetDrawBitmapMode",1,"ofDrawBitmapMode"); - arg1 = (ofDrawBitmapMode)(int)lua_tonumber(L, 1); ofSetDrawBitmapMode(arg1); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_drawBitmapStringHighlight__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string arg1 ; ofPoint *arg2 = 0 ; - ofColor *arg3 = 0 ; ofColor *arg4 = 0 ; SWIG_check_num_args("ofDrawBitmapStringHighlight",4,4) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofDrawBitmapStringHighlight",1,"std::string"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofDrawBitmapStringHighlight",2,"ofPoint const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofDrawBitmapStringHighlight",3,"ofColor const &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofDrawBitmapStringHighlight",4,"ofColor const &"); - (&arg1)->assign(lua_tostring(L,1),lua_rawlen(L,1)); if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("drawBitmapStringHighlight",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("drawBitmapStringHighlight",3,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("drawBitmapStringHighlight",4,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - ofDrawBitmapStringHighlight(arg1,(ofVec3f const &)*arg2,(ofColor_< unsigned char > const &)*arg3,(ofColor_< unsigned char > const &)*arg4); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawBitmapStringHighlight__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string arg1 ; ofPoint *arg2 = 0 ; - ofColor *arg3 = 0 ; SWIG_check_num_args("ofDrawBitmapStringHighlight",3,3) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofDrawBitmapStringHighlight",1,"std::string"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofDrawBitmapStringHighlight",2,"ofPoint const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofDrawBitmapStringHighlight",3,"ofColor const &"); - (&arg1)->assign(lua_tostring(L,1),lua_rawlen(L,1)); if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("drawBitmapStringHighlight",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("drawBitmapStringHighlight",3,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - ofDrawBitmapStringHighlight(arg1,(ofVec3f const &)*arg2,(ofColor_< unsigned char > const &)*arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawBitmapStringHighlight__SWIG_2(lua_State* L) { int SWIG_arg = 0; std::string arg1 ; ofPoint *arg2 = 0 ; - SWIG_check_num_args("ofDrawBitmapStringHighlight",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofDrawBitmapStringHighlight",1,"std::string"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofDrawBitmapStringHighlight",2,"ofPoint const &"); - (&arg1)->assign(lua_tostring(L,1),lua_rawlen(L,1)); if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("drawBitmapStringHighlight",2,SWIGTYPE_p_ofVec3f); } - ofDrawBitmapStringHighlight(arg1,(ofVec3f const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_drawBitmapStringHighlight__SWIG_3(lua_State* L) { int SWIG_arg = 0; std::string arg1 ; int arg2 ; int arg3 ; - ofColor *arg4 = 0 ; ofColor *arg5 = 0 ; SWIG_check_num_args("ofDrawBitmapStringHighlight",5,5) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofDrawBitmapStringHighlight",1,"std::string"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawBitmapStringHighlight",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawBitmapStringHighlight",3,"int"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofDrawBitmapStringHighlight",4,"ofColor const &"); - if(!lua_isuserdata(L,5)) SWIG_fail_arg("ofDrawBitmapStringHighlight",5,"ofColor const &"); - (&arg1)->assign(lua_tostring(L,1),lua_rawlen(L,1)); arg2 = (int)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("drawBitmapStringHighlight",4,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("drawBitmapStringHighlight",5,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - ofDrawBitmapStringHighlight(arg1,arg2,arg3,(ofColor_< unsigned char > const &)*arg4,(ofColor_< unsigned char > const &)*arg5); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawBitmapStringHighlight__SWIG_4(lua_State* L) { int SWIG_arg = 0; std::string arg1 ; int arg2 ; int arg3 ; - ofColor *arg4 = 0 ; SWIG_check_num_args("ofDrawBitmapStringHighlight",4,4) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofDrawBitmapStringHighlight",1,"std::string"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawBitmapStringHighlight",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawBitmapStringHighlight",3,"int"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofDrawBitmapStringHighlight",4,"ofColor const &"); - (&arg1)->assign(lua_tostring(L,1),lua_rawlen(L,1)); arg2 = (int)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("drawBitmapStringHighlight",4,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - ofDrawBitmapStringHighlight(arg1,arg2,arg3,(ofColor_< unsigned char > const &)*arg4); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_drawBitmapStringHighlight__SWIG_5(lua_State* L) { int SWIG_arg = 0; std::string arg1 ; int arg2 ; int arg3 ; - SWIG_check_num_args("ofDrawBitmapStringHighlight",3,3) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofDrawBitmapStringHighlight",1,"std::string"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawBitmapStringHighlight",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawBitmapStringHighlight",3,"int"); - (&arg1)->assign(lua_tostring(L,1),lua_rawlen(L,1)); arg2 = (int)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); - ofDrawBitmapStringHighlight(arg1,arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawBitmapStringHighlight(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_drawBitmapStringHighlight__SWIG_2(L);} } } if (argc == 3) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_drawBitmapStringHighlight__SWIG_1(L);} } } } - if (argc == 3) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_drawBitmapStringHighlight__SWIG_5(L);} } } } - if (argc == 4) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_drawBitmapStringHighlight__SWIG_0(L);} } } } } - if (argc == 4) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_drawBitmapStringHighlight__SWIG_4(L);} } } } } - if (argc == 5) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[4])==0 || SWIG_ConvertPtr(L,argv[4], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_drawBitmapStringHighlight__SWIG_3(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'drawBitmapStringHighlight'\n" - " Possible C/C++ prototypes are:\n" - " ofDrawBitmapStringHighlight(std::string,ofPoint const &,ofColor const &,ofColor const &)\n" - " ofDrawBitmapStringHighlight(std::string,ofPoint const &,ofColor const &)\n" - " ofDrawBitmapStringHighlight(std::string,ofPoint const &)\n" - " ofDrawBitmapStringHighlight(std::string,int,int,ofColor const &,ofColor const &)\n" - " ofDrawBitmapStringHighlight(std::string,int,int,ofColor const &)\n" - " ofDrawBitmapStringHighlight(std::string,int,int)\n"); lua_error(L);return 0; } -static int _wrap_setupGraphicDefaults(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofSetupGraphicDefaults",0,0) - ofSetupGraphicDefaults(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setupScreen(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofSetupScreen",0,0) ofSetupScreen(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getRectMode(lua_State* L) { int SWIG_arg = 0; ofRectMode result; SWIG_check_num_args("ofGetRectMode",0,0) - result = (ofRectMode)ofGetRectMode(); lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setCircleResolution(lua_State* L) { int SWIG_arg = 0; int arg1 ; - SWIG_check_num_args("ofSetCircleResolution",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetCircleResolution",1,"int"); - arg1 = (int)lua_tonumber(L, 1); ofSetCircleResolution(arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_setCurveResolution(lua_State* L) { int SWIG_arg = 0; int arg1 ; SWIG_check_num_args("ofSetCurveResolution",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetCurveResolution",1,"int"); arg1 = (int)lua_tonumber(L, 1); - ofSetCurveResolution(arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setLineWidth(lua_State* L) { int SWIG_arg = 0; float arg1 ; SWIG_check_num_args("ofSetLineWidth",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetLineWidth",1,"float"); arg1 = (float)lua_tonumber(L, 1); ofSetLineWidth(arg1); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setDepthTest(lua_State* L) { int SWIG_arg = 0; bool arg1 ; SWIG_check_num_args("ofSetDepthTest",1,1) - if(!lua_isboolean(L,1)) SWIG_fail_arg("ofSetDepthTest",1,"bool"); arg1 = (lua_toboolean(L, 1)!=0); ofSetDepthTest(arg1); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_enableDepthTest(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofEnableDepthTest",0,0) - ofEnableDepthTest(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_disableDepthTest(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofDisableDepthTest",0,0) - ofDisableDepthTest(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_enableBlendMode(lua_State* L) { int SWIG_arg = 0; ofBlendMode arg1 ; - SWIG_check_num_args("ofEnableBlendMode",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofEnableBlendMode",1,"ofBlendMode"); - arg1 = (ofBlendMode)(int)lua_tonumber(L, 1); ofEnableBlendMode(arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_disableBlendMode(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofDisableBlendMode",0,0) - ofDisableBlendMode(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_enablePointSprites(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofEnablePointSprites",0,0) - ofEnablePointSprites(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_disablePointSprites(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofDisablePointSprites",0,0) - ofDisablePointSprites(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_enableAlphaBlending(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofEnableAlphaBlending",0,0) - ofEnableAlphaBlending(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_disableAlphaBlending(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofDisableAlphaBlending",0,0) - ofDisableAlphaBlending(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_enableSmoothing(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofEnableSmoothing",0,0) - ofEnableSmoothing(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_disableSmoothing(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofDisableSmoothing",0,0) - ofDisableSmoothing(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_enableAntiAliasing(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofEnableAntiAliasing",0,0) - ofEnableAntiAliasing(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_disableAntiAliasing(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofDisableAntiAliasing",0,0) - ofDisableAntiAliasing(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getStyle(lua_State* L) { int SWIG_arg = 0; ofStyle result; SWIG_check_num_args("ofGetStyle",0,0) - result = ofGetStyle(); { ofStyle * resultptr = new ofStyle((const ofStyle &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofStyle,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_setStyle(lua_State* L) { int SWIG_arg = 0; ofStyle arg1 ; ofStyle *argp1 ; - SWIG_check_num_args("ofSetStyle",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofSetStyle",1,"ofStyle"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&argp1,SWIGTYPE_p_ofStyle,0))){ SWIG_fail_ptr("setStyle",1,SWIGTYPE_p_ofStyle); } - arg1 = *argp1; ofSetStyle(arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_pushStyle(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofPushStyle",0,0) ofPushStyle(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_popStyle(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofPopStyle",0,0) ofPopStyle(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setPolyMode(lua_State* L) { int SWIG_arg = 0; ofPolyWindingMode arg1 ; SWIG_check_num_args("ofSetPolyMode",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetPolyMode",1,"ofPolyWindingMode"); - arg1 = (ofPolyWindingMode)(int)lua_tonumber(L, 1); ofSetPolyMode(arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_setRectMode(lua_State* L) { int SWIG_arg = 0; ofRectMode arg1 ; SWIG_check_num_args("ofSetRectMode",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetRectMode",1,"ofRectMode"); arg1 = (ofRectMode)(int)lua_tonumber(L, 1); - ofSetRectMode(arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_pushMatrix(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofPushMatrix",0,0) ofPushMatrix(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_popMatrix(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofPopMatrix",0,0) ofPopMatrix(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getCurrentMatrix(lua_State* L) { int SWIG_arg = 0; ofMatrixMode arg1 ; ofMatrix4x4 result; - SWIG_check_num_args("ofGetCurrentMatrix",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofGetCurrentMatrix",1,"ofMatrixMode"); - arg1 = (ofMatrixMode)(int)lua_tonumber(L, 1); result = ofGetCurrentMatrix(arg1); { - ofMatrix4x4 * resultptr = new ofMatrix4x4((const ofMatrix4x4 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_getCurrentOrientationMatrix(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 result; - SWIG_check_num_args("ofGetCurrentOrientationMatrix",0,0) result = ofGetCurrentOrientationMatrix(); { - ofMatrix4x4 * resultptr = new ofMatrix4x4((const ofMatrix4x4 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_getCurrentNormalMatrix(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 result; - SWIG_check_num_args("ofGetCurrentNormalMatrix",0,0) result = ofGetCurrentNormalMatrix(); { - ofMatrix4x4 * resultptr = new ofMatrix4x4((const ofMatrix4x4 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_translate__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofTranslate",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofTranslate",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTranslate",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTranslate",3,"float"); - arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - ofTranslate(arg1,arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_translate__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; - SWIG_check_num_args("ofTranslate",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofTranslate",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTranslate",2,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); ofTranslate(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_translate__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPoint *arg1 = 0 ; SWIG_check_num_args("ofTranslate",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofTranslate",1,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("translate",1,SWIGTYPE_p_ofVec3f); } - ofTranslate((ofVec3f const &)*arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_translate(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_translate__SWIG_2(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_translate__SWIG_1(L);} - } } if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_translate__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'translate'\n" " Possible C/C++ prototypes are:\n" - " ofTranslate(float,float,float)\n" " ofTranslate(float,float)\n" " ofTranslate(ofPoint const &)\n"); - lua_error(L);return 0; } -static int _wrap_scale__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofScale",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofScale",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofScale",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofScale",3,"float"); - arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); ofScale(arg1,arg2,arg3); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_scale__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; SWIG_check_num_args("ofScale",2,2) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofScale",1,"float"); if(!lua_isnumber(L,2)) SWIG_fail_arg("ofScale",2,"float"); - arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); ofScale(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_scale__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPoint *arg1 = 0 ; SWIG_check_num_args("ofScale",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofScale",1,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("scale",1,SWIGTYPE_p_ofVec3f); } - ofScale((ofVec3f const &)*arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_scale(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_scale__SWIG_2(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_scale__SWIG_1(L);} } - } if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_scale__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'scale'\n" " Possible C/C++ prototypes are:\n" - " ofScale(float,float,float)\n" " ofScale(float,float)\n" " ofScale(ofPoint const &)\n"); lua_error(L);return 0; } -static int _wrap_rotate__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - SWIG_check_num_args("ofRotate",4,4) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofRotate",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRotate",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofRotate",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofRotate",4,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - ofRotate(arg1,arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_rotate__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; SWIG_check_num_args("ofRotate",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofRotate",1,"float"); arg1 = (float)lua_tonumber(L, 1); ofRotate(arg1); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_rotate(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_rotate__SWIG_1(L);} } if (argc == 4) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_rotate__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'rotate'\n" " Possible C/C++ prototypes are:\n" - " ofRotate(float,float,float,float)\n" " ofRotate(float)\n"); lua_error(L);return 0; } -static int _wrap_rotateX(lua_State* L) { int SWIG_arg = 0; float arg1 ; SWIG_check_num_args("ofRotateX",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofRotateX",1,"float"); arg1 = (float)lua_tonumber(L, 1); ofRotateX(arg1); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_rotateY(lua_State* L) { int SWIG_arg = 0; float arg1 ; SWIG_check_num_args("ofRotateY",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofRotateY",1,"float"); arg1 = (float)lua_tonumber(L, 1); ofRotateY(arg1); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_rotateZ(lua_State* L) { int SWIG_arg = 0; float arg1 ; SWIG_check_num_args("ofRotateZ",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofRotateZ",1,"float"); arg1 = (float)lua_tonumber(L, 1); ofRotateZ(arg1); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_loadIdentityMatrix(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofLoadIdentityMatrix",0,0) - ofLoadIdentityMatrix(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_loadMatrix__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = 0 ; - SWIG_check_num_args("ofLoadMatrix",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofLoadMatrix",1,"ofMatrix4x4 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("loadMatrix",1,SWIGTYPE_p_ofMatrix4x4); } ofLoadMatrix((ofMatrix4x4 const &)*arg1); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_loadMatrix__SWIG_1(lua_State* L) { int SWIG_arg = 0; float *arg1 = (float *) 0 ; - SWIG_check_num_args("ofLoadMatrix",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLoadMatrix",1,"float const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_float,0))){ SWIG_fail_ptr("loadMatrix",1,SWIGTYPE_p_float); } - ofLoadMatrix((float const *)arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_loadMatrix(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_loadMatrix__SWIG_0(L);} } if (argc == 1) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_loadMatrix__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'loadMatrix'\n" " Possible C/C++ prototypes are:\n" - " ofLoadMatrix(ofMatrix4x4 const &)\n" " ofLoadMatrix(float const *)\n"); lua_error(L);return 0; } -static int _wrap_multMatrix__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = 0 ; - SWIG_check_num_args("ofMultMatrix",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofMultMatrix",1,"ofMatrix4x4 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("multMatrix",1,SWIGTYPE_p_ofMatrix4x4); } ofMultMatrix((ofMatrix4x4 const &)*arg1); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_multMatrix__SWIG_1(lua_State* L) { int SWIG_arg = 0; float *arg1 = (float *) 0 ; - SWIG_check_num_args("ofMultMatrix",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMultMatrix",1,"float const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_float,0))){ SWIG_fail_ptr("multMatrix",1,SWIGTYPE_p_float); } - ofMultMatrix((float const *)arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_multMatrix(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_multMatrix__SWIG_0(L);} } if (argc == 1) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_multMatrix__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'multMatrix'\n" " Possible C/C++ prototypes are:\n" - " ofMultMatrix(ofMatrix4x4 const &)\n" " ofMultMatrix(float const *)\n"); lua_error(L);return 0; } -static int _wrap_setMatrixMode(lua_State* L) { int SWIG_arg = 0; ofMatrixMode arg1 ; SWIG_check_num_args("ofSetMatrixMode",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetMatrixMode",1,"ofMatrixMode"); arg1 = (ofMatrixMode)(int)lua_tonumber(L, 1); - ofSetMatrixMode(arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_loadViewMatrix(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = 0 ; - SWIG_check_num_args("ofLoadViewMatrix",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofLoadViewMatrix",1,"ofMatrix4x4 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("loadViewMatrix",1,SWIGTYPE_p_ofMatrix4x4); } ofLoadViewMatrix((ofMatrix4x4 const &)*arg1); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_multViewMatrix(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = 0 ; - SWIG_check_num_args("ofMultViewMatrix",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofMultViewMatrix",1,"ofMatrix4x4 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("multViewMatrix",1,SWIGTYPE_p_ofMatrix4x4); } ofMultViewMatrix((ofMatrix4x4 const &)*arg1); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getCurrentViewMatrix(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 result; - SWIG_check_num_args("ofGetCurrentViewMatrix",0,0) result = ofGetCurrentViewMatrix(); { - ofMatrix4x4 * resultptr = new ofMatrix4x4((const ofMatrix4x4 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_pushView(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofPushView",0,0) ofPushView(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_popView(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofPopView",0,0) ofPopView(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_viewport__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofRectangle arg1 ; ofRectangle *argp1 ; - SWIG_check_num_args("ofViewport",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofViewport",1,"ofRectangle"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&argp1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("viewport",1,SWIGTYPE_p_ofRectangle); } arg1 = *argp1; ofViewport(arg1); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_viewport__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - bool arg5 ; SWIG_check_num_args("ofViewport",5,5) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofViewport",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofViewport",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofViewport",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofViewport",4,"float"); if(!lua_isboolean(L,5)) SWIG_fail_arg("ofViewport",5,"bool"); - arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - arg4 = (float)lua_tonumber(L, 4); arg5 = (lua_toboolean(L, 5)!=0); ofViewport(arg1,arg2,arg3,arg4,arg5); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_viewport__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - SWIG_check_num_args("ofViewport",4,4) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofViewport",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofViewport",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofViewport",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofViewport",4,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - ofViewport(arg1,arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_viewport__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofViewport",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofViewport",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofViewport",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofViewport",3,"float"); - arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - ofViewport(arg1,arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_viewport__SWIG_4(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; - SWIG_check_num_args("ofViewport",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofViewport",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofViewport",2,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); ofViewport(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_viewport__SWIG_5(lua_State* L) { int SWIG_arg = 0; float arg1 ; SWIG_check_num_args("ofViewport",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofViewport",1,"float"); arg1 = (float)lua_tonumber(L, 1); ofViewport(arg1); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_viewport__SWIG_6(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofViewport",0,0) ofViewport(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_viewport(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_viewport__SWIG_6(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_viewport__SWIG_0(L);} } if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_viewport__SWIG_5(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_viewport__SWIG_4(L);} - } } if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_viewport__SWIG_3(L);} } } } if (argc == 4) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_viewport__SWIG_2(L);} } } } } if (argc == 5) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isboolean(L,argv[4]); } if (_v) { return _wrap_viewport__SWIG_1(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'viewport'\n" " Possible C/C++ prototypes are:\n" - " ofViewport(ofRectangle)\n" " ofViewport(float,float,float,float,bool)\n" " ofViewport(float,float,float,float)\n" - " ofViewport(float,float,float)\n" " ofViewport(float,float)\n" " ofViewport(float)\n" " ofViewport()\n"); - lua_error(L);return 0; } -static int _wrap_getCurrentViewport(lua_State* L) { int SWIG_arg = 0; ofRectangle result; - SWIG_check_num_args("ofGetCurrentViewport",0,0) result = ofGetCurrentViewport(); { - ofRectangle * resultptr = new ofRectangle((const ofRectangle &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofRectangle,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_getNativeViewport(lua_State* L) { int SWIG_arg = 0; ofRectangle result; - SWIG_check_num_args("ofGetNativeViewport",0,0) result = ofGetNativeViewport(); { - ofRectangle * resultptr = new ofRectangle((const ofRectangle &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofRectangle,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_getViewportWidth(lua_State* L) { int SWIG_arg = 0; int result; SWIG_check_num_args("ofGetViewportWidth",0,0) - result = (int)ofGetViewportWidth(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_getViewportHeight(lua_State* L) { int SWIG_arg = 0; int result; SWIG_check_num_args("ofGetViewportHeight",0,0) - result = (int)ofGetViewportHeight(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_setupScreenPerspective__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; - float arg4 ; float arg5 ; SWIG_check_num_args("ofSetupScreenPerspective",5,5) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetupScreenPerspective",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSetupScreenPerspective",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofSetupScreenPerspective",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofSetupScreenPerspective",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofSetupScreenPerspective",5,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); ofSetupScreenPerspective(arg1,arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_setupScreenPerspective__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; - float arg4 ; SWIG_check_num_args("ofSetupScreenPerspective",4,4) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetupScreenPerspective",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSetupScreenPerspective",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofSetupScreenPerspective",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofSetupScreenPerspective",4,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - ofSetupScreenPerspective(arg1,arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setupScreenPerspective__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofSetupScreenPerspective",3,3) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetupScreenPerspective",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSetupScreenPerspective",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofSetupScreenPerspective",3,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); ofSetupScreenPerspective(arg1,arg2,arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setupScreenPerspective__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; - SWIG_check_num_args("ofSetupScreenPerspective",2,2) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetupScreenPerspective",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSetupScreenPerspective",2,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); ofSetupScreenPerspective(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_setupScreenPerspective__SWIG_4(lua_State* L) { int SWIG_arg = 0; float arg1 ; - SWIG_check_num_args("ofSetupScreenPerspective",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetupScreenPerspective",1,"float"); arg1 = (float)lua_tonumber(L, 1); - ofSetupScreenPerspective(arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setupScreenPerspective__SWIG_5(lua_State* L) { int SWIG_arg = 0; - SWIG_check_num_args("ofSetupScreenPerspective",0,0) ofSetupScreenPerspective(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_setupScreenPerspective(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); - if (argc == 0) { return _wrap_setupScreenPerspective__SWIG_5(L);} if (argc == 1) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { return _wrap_setupScreenPerspective__SWIG_4(L);} } if (argc == 2) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_setupScreenPerspective__SWIG_3(L);} } } - if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_setupScreenPerspective__SWIG_2(L);} } } } if (argc == 4) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { - return _wrap_setupScreenPerspective__SWIG_1(L);} } } } } if (argc == 5) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_setupScreenPerspective__SWIG_0(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'setupScreenPerspective'\n" - " Possible C/C++ prototypes are:\n" " ofSetupScreenPerspective(float,float,float,float,float)\n" - " ofSetupScreenPerspective(float,float,float,float)\n" " ofSetupScreenPerspective(float,float,float)\n" - " ofSetupScreenPerspective(float,float)\n" " ofSetupScreenPerspective(float)\n" " ofSetupScreenPerspective()\n"); - lua_error(L);return 0; } -static int _wrap_setupScreenOrtho__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - SWIG_check_num_args("ofSetupScreenOrtho",4,4) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetupScreenOrtho",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSetupScreenOrtho",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofSetupScreenOrtho",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofSetupScreenOrtho",4,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - ofSetupScreenOrtho(arg1,arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setupScreenOrtho__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofSetupScreenOrtho",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetupScreenOrtho",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSetupScreenOrtho",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofSetupScreenOrtho",3,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); ofSetupScreenOrtho(arg1,arg2,arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setupScreenOrtho__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; - SWIG_check_num_args("ofSetupScreenOrtho",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetupScreenOrtho",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSetupScreenOrtho",2,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); ofSetupScreenOrtho(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_setupScreenOrtho__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; - SWIG_check_num_args("ofSetupScreenOrtho",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetupScreenOrtho",1,"float"); - arg1 = (float)lua_tonumber(L, 1); ofSetupScreenOrtho(arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_setupScreenOrtho__SWIG_4(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofSetupScreenOrtho",0,0) - ofSetupScreenOrtho(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setupScreenOrtho(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_setupScreenOrtho__SWIG_4(L);} if (argc == 1) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { - return _wrap_setupScreenOrtho__SWIG_3(L);} } if (argc == 2) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_setupScreenOrtho__SWIG_2(L);} } } if (argc == 3) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_setupScreenOrtho__SWIG_1(L);} } } } if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_setupScreenOrtho__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'setupScreenOrtho'\n" " Possible C/C++ prototypes are:\n" - " ofSetupScreenOrtho(float,float,float,float)\n" " ofSetupScreenOrtho(float,float,float)\n" - " ofSetupScreenOrtho(float,float)\n" " ofSetupScreenOrtho(float)\n" " ofSetupScreenOrtho()\n"); - lua_error(L);return 0; } -static int _wrap_orientationToDegrees(lua_State* L) { int SWIG_arg = 0; ofOrientation arg1 ; int result; - SWIG_check_num_args("ofOrientationToDegrees",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofOrientationToDegrees",1,"ofOrientation"); - arg1 = (ofOrientation)(int)lua_tonumber(L, 1); result = (int)ofOrientationToDegrees(arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setCoordHandedness(lua_State* L) { int SWIG_arg = 0; ofHandednessType arg1 ; - SWIG_check_num_args("ofSetCoordHandedness",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetCoordHandedness",1,"ofHandednessType"); - arg1 = (ofHandednessType)(int)lua_tonumber(L, 1); ofSetCoordHandedness(arg1); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_getCoordHandedness(lua_State* L) { int SWIG_arg = 0; ofHandednessType result; - SWIG_check_num_args("ofGetCoordHandedness",0,0) result = (ofHandednessType)ofGetCoordHandedness(); - lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_setPlaneResolution(lua_State* L) { int SWIG_arg = 0; int arg1 ; int arg2 ; - SWIG_check_num_args("ofSetPlaneResolution",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetPlaneResolution",1,"int"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSetPlaneResolution",2,"int"); arg1 = (int)lua_tonumber(L, 1); - arg2 = (int)lua_tonumber(L, 2); ofSetPlaneResolution(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_getPlaneResolution(lua_State* L) { int SWIG_arg = 0; ofVec2f result; - SWIG_check_num_args("ofGetPlaneResolution",0,0) result = ofGetPlaneResolution(); { - ofVec2f * resultptr = new ofVec2f((const ofVec2f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_drawPlane__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - SWIG_check_num_args("ofDrawPlane",4,4) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawPlane",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawPlane",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawPlane",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawPlane",4,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - ofDrawPlane(arg1,arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawPlane__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - float arg5 ; SWIG_check_num_args("ofDrawPlane",5,5) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawPlane",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawPlane",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawPlane",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawPlane",4,"float"); if(!lua_isnumber(L,5)) SWIG_fail_arg("ofDrawPlane",5,"float"); - arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); ofDrawPlane(arg1,arg2,arg3,arg4,arg5); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawPlane__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPoint *arg1 = 0 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofDrawPlane",3,3) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofDrawPlane",1,"ofPoint &"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawPlane",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawPlane",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("drawPlane",1,SWIGTYPE_p_ofVec3f); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); ofDrawPlane(*arg1,arg2,arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawPlane__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; - SWIG_check_num_args("ofDrawPlane",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawPlane",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawPlane",2,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); ofDrawPlane(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_drawPlane(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 2) { int _v; - { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_drawPlane__SWIG_3(L);} - } } if (argc == 3) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_drawPlane__SWIG_2(L);} } } } if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_drawPlane__SWIG_0(L);} } } } } if (argc == 5) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_drawPlane__SWIG_1(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'drawPlane'\n" " Possible C/C++ prototypes are:\n" - " ofDrawPlane(float,float,float,float)\n" " ofDrawPlane(float,float,float,float,float)\n" - " ofDrawPlane(ofPoint &,float,float)\n" " ofDrawPlane(float,float)\n"); lua_error(L);return 0; } -static int _wrap_setSphereResolution(lua_State* L) { int SWIG_arg = 0; int arg1 ; - SWIG_check_num_args("ofSetSphereResolution",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetSphereResolution",1,"int"); - arg1 = (int)lua_tonumber(L, 1); ofSetSphereResolution(arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_getSphereResolution(lua_State* L) { int SWIG_arg = 0; int result; - SWIG_check_num_args("ofGetSphereResolution",0,0) result = (int)ofGetSphereResolution(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawSphere__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofDrawSphere",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawSphere",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawSphere",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawSphere",3,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); ofDrawSphere(arg1,arg2,arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawSphere__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - SWIG_check_num_args("ofDrawSphere",4,4) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawSphere",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawSphere",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawSphere",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawSphere",4,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - ofDrawSphere(arg1,arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawSphere__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPoint *arg1 = 0 ; float arg2 ; - SWIG_check_num_args("ofDrawSphere",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofDrawSphere",1,"ofPoint const &"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawSphere",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("drawSphere",1,SWIGTYPE_p_ofVec3f); } - arg2 = (float)lua_tonumber(L, 2); ofDrawSphere((ofVec3f const &)*arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_drawSphere__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; SWIG_check_num_args("ofDrawSphere",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawSphere",1,"float"); arg1 = (float)lua_tonumber(L, 1); ofDrawSphere(arg1); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawSphere(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 1) { int _v; - { _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_drawSphere__SWIG_3(L);} } if (argc == 2) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_drawSphere__SWIG_2(L);} } } - if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_drawSphere__SWIG_0(L);} } } } if (argc == 4) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_drawSphere__SWIG_1(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'drawSphere'\n" " Possible C/C++ prototypes are:\n" - " ofDrawSphere(float,float,float)\n" " ofDrawSphere(float,float,float,float)\n" - " ofDrawSphere(ofPoint const &,float)\n" " ofDrawSphere(float)\n"); lua_error(L);return 0; } -static int _wrap_setIcoSphereResolution(lua_State* L) { int SWIG_arg = 0; int arg1 ; - SWIG_check_num_args("ofSetIcoSphereResolution",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetIcoSphereResolution",1,"int"); - arg1 = (int)lua_tonumber(L, 1); ofSetIcoSphereResolution(arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_getIcoSphereResolution(lua_State* L) { int SWIG_arg = 0; int result; - SWIG_check_num_args("ofGetIcoSphereResolution",0,0) result = (int)ofGetIcoSphereResolution(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawIcoSphere__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - SWIG_check_num_args("ofDrawIcoSphere",4,4) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawIcoSphere",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawIcoSphere",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawIcoSphere",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawIcoSphere",4,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - ofDrawIcoSphere(arg1,arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawIcoSphere__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofDrawIcoSphere",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawIcoSphere",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawIcoSphere",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawIcoSphere",3,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); ofDrawIcoSphere(arg1,arg2,arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawIcoSphere__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPoint *arg1 = 0 ; float arg2 ; - SWIG_check_num_args("ofDrawIcoSphere",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofDrawIcoSphere",1,"ofPoint const &"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawIcoSphere",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("drawIcoSphere",1,SWIGTYPE_p_ofVec3f); } arg2 = (float)lua_tonumber(L, 2); - ofDrawIcoSphere((ofVec3f const &)*arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawIcoSphere__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; SWIG_check_num_args("ofDrawIcoSphere",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawIcoSphere",1,"float"); arg1 = (float)lua_tonumber(L, 1); ofDrawIcoSphere(arg1); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawIcoSphere(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_drawIcoSphere__SWIG_3(L);} } if (argc == 2) { int _v; { - void *ptr; if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_drawIcoSphere__SWIG_2(L);} } } if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_drawIcoSphere__SWIG_1(L);} } } } if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_drawIcoSphere__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'drawIcoSphere'\n" " Possible C/C++ prototypes are:\n" - " ofDrawIcoSphere(float,float,float,float)\n" " ofDrawIcoSphere(float,float,float)\n" - " ofDrawIcoSphere(ofPoint const &,float)\n" " ofDrawIcoSphere(float)\n"); lua_error(L);return 0; } -static int _wrap_setCylinderResolution__SWIG_0(lua_State* L) { int SWIG_arg = 0; int arg1 ; int arg2 ; int arg3 ; - SWIG_check_num_args("ofSetCylinderResolution",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetCylinderResolution",1,"int"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSetCylinderResolution",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofSetCylinderResolution",3,"int"); arg1 = (int)lua_tonumber(L, 1); - arg2 = (int)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); ofSetCylinderResolution(arg1,arg2,arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setCylinderResolution__SWIG_1(lua_State* L) { int SWIG_arg = 0; int arg1 ; int arg2 ; - SWIG_check_num_args("ofSetCylinderResolution",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetCylinderResolution",1,"int"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSetCylinderResolution",2,"int"); arg1 = (int)lua_tonumber(L, 1); - arg2 = (int)lua_tonumber(L, 2); ofSetCylinderResolution(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_setCylinderResolution(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_setCylinderResolution__SWIG_1(L);} } } if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_setCylinderResolution__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'setCylinderResolution'\n" - " Possible C/C++ prototypes are:\n" " ofSetCylinderResolution(int,int,int)\n" " ofSetCylinderResolution(int,int)\n"); - lua_error(L);return 0; } -static int _wrap_getCylinderResolution(lua_State* L) { int SWIG_arg = 0; ofVec3f result; - SWIG_check_num_args("ofGetCylinderResolution",0,0) result = ofGetCylinderResolution(); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_drawCylinder__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - SWIG_check_num_args("ofDrawCylinder",4,4) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawCylinder",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawCylinder",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawCylinder",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawCylinder",4,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - ofDrawCylinder(arg1,arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawCylinder__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - float arg5 ; SWIG_check_num_args("ofDrawCylinder",5,5) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawCylinder",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawCylinder",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawCylinder",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawCylinder",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofDrawCylinder",5,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); ofDrawCylinder(arg1,arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_drawCylinder__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPoint *arg1 = 0 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofDrawCylinder",3,3) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofDrawCylinder",1,"ofPoint const &"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawCylinder",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawCylinder",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("drawCylinder",1,SWIGTYPE_p_ofVec3f); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); ofDrawCylinder((ofVec3f const &)*arg1,arg2,arg3); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawCylinder__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; - SWIG_check_num_args("ofDrawCylinder",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawCylinder",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawCylinder",2,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); ofDrawCylinder(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_drawCylinder(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_drawCylinder__SWIG_3(L);} } } if (argc == 3) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_drawCylinder__SWIG_2(L);} } } } if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { - { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_drawCylinder__SWIG_0(L);} } } } } if (argc == 5) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_drawCylinder__SWIG_1(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'drawCylinder'\n" " Possible C/C++ prototypes are:\n" - " ofDrawCylinder(float,float,float,float)\n" " ofDrawCylinder(float,float,float,float,float)\n" - " ofDrawCylinder(ofPoint const &,float,float)\n" " ofDrawCylinder(float,float)\n"); lua_error(L);return 0; } -static int _wrap_setConeResolution__SWIG_0(lua_State* L) { int SWIG_arg = 0; int arg1 ; int arg2 ; int arg3 ; - SWIG_check_num_args("ofSetConeResolution",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetConeResolution",1,"int"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSetConeResolution",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofSetConeResolution",3,"int"); arg1 = (int)lua_tonumber(L, 1); - arg2 = (int)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); ofSetConeResolution(arg1,arg2,arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setConeResolution__SWIG_1(lua_State* L) { int SWIG_arg = 0; int arg1 ; int arg2 ; - SWIG_check_num_args("ofSetConeResolution",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetConeResolution",1,"int"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSetConeResolution",2,"int"); arg1 = (int)lua_tonumber(L, 1); - arg2 = (int)lua_tonumber(L, 2); ofSetConeResolution(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_setConeResolution(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_setConeResolution__SWIG_1(L);} } } if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { - { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_setConeResolution__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'setConeResolution'\n" " Possible C/C++ prototypes are:\n" - " ofSetConeResolution(int,int,int)\n" " ofSetConeResolution(int,int)\n"); lua_error(L);return 0; } -static int _wrap_getConeResolution(lua_State* L) { int SWIG_arg = 0; ofVec3f result; - SWIG_check_num_args("ofGetConeResolution",0,0) result = ofGetConeResolution(); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_drawCone__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - float arg5 ; SWIG_check_num_args("ofDrawCone",5,5) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawCone",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawCone",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawCone",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawCone",4,"float"); if(!lua_isnumber(L,5)) SWIG_fail_arg("ofDrawCone",5,"float"); - arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); ofDrawCone(arg1,arg2,arg3,arg4,arg5); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawCone__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - SWIG_check_num_args("ofDrawCone",4,4) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawCone",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawCone",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawCone",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawCone",4,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - ofDrawCone(arg1,arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawCone__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPoint *arg1 = 0 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofDrawCone",3,3) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofDrawCone",1,"ofPoint const &"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawCone",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawCone",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("drawCone",1,SWIGTYPE_p_ofVec3f); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); ofDrawCone((ofVec3f const &)*arg1,arg2,arg3); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawCone__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; - SWIG_check_num_args("ofDrawCone",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawCone",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawCone",2,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); ofDrawCone(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_drawCone(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 2) { int _v; - { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_drawCone__SWIG_3(L);} - } } if (argc == 3) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_drawCone__SWIG_2(L);} } } } if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_drawCone__SWIG_1(L);} } } } } if (argc == 5) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_drawCone__SWIG_0(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'drawCone'\n" " Possible C/C++ prototypes are:\n" - " ofDrawCone(float,float,float,float,float)\n" " ofDrawCone(float,float,float,float)\n" - " ofDrawCone(ofPoint const &,float,float)\n" " ofDrawCone(float,float)\n"); lua_error(L);return 0; } -static int _wrap_setBoxResolution__SWIG_0(lua_State* L) { int SWIG_arg = 0; int arg1 ; - SWIG_check_num_args("ofSetBoxResolution",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetBoxResolution",1,"int"); - arg1 = (int)lua_tonumber(L, 1); ofSetBoxResolution(arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_setBoxResolution__SWIG_1(lua_State* L) { int SWIG_arg = 0; int arg1 ; int arg2 ; int arg3 ; - SWIG_check_num_args("ofSetBoxResolution",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetBoxResolution",1,"int"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSetBoxResolution",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofSetBoxResolution",3,"int"); arg1 = (int)lua_tonumber(L, 1); - arg2 = (int)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); ofSetBoxResolution(arg1,arg2,arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setBoxResolution(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_setBoxResolution__SWIG_0(L);} } if (argc == 3) { int _v; - { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_setBoxResolution__SWIG_1(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'setBoxResolution'\n" " Possible C/C++ prototypes are:\n" - " ofSetBoxResolution(int)\n" " ofSetBoxResolution(int,int,int)\n"); lua_error(L);return 0; } -static int _wrap_getBoxResolution(lua_State* L) { int SWIG_arg = 0; ofVec3f result; - SWIG_check_num_args("ofGetBoxResolution",0,0) result = ofGetBoxResolution(); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_drawBox__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - float arg5 ; float arg6 ; SWIG_check_num_args("ofDrawBox",6,6) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawBox",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawBox",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawBox",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawBox",4,"float"); if(!lua_isnumber(L,5)) SWIG_fail_arg("ofDrawBox",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofDrawBox",6,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); ofDrawBox(arg1,arg2,arg3,arg4,arg5,arg6); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawBox__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - SWIG_check_num_args("ofDrawBox",4,4) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawBox",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawBox",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawBox",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawBox",4,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - ofDrawBox(arg1,arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawBox__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPoint *arg1 = 0 ; float arg2 ; float arg3 ; float arg4 ; - SWIG_check_num_args("ofDrawBox",4,4) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofDrawBox",1,"ofPoint const &"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawBox",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawBox",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawBox",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("drawBox",1,SWIGTYPE_p_ofVec3f); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - ofDrawBox((ofVec3f const &)*arg1,arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawBox__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofPoint *arg1 = 0 ; float arg2 ; - SWIG_check_num_args("ofDrawBox",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofDrawBox",1,"ofPoint const &"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawBox",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("drawBox",1,SWIGTYPE_p_ofVec3f); } - arg2 = (float)lua_tonumber(L, 2); ofDrawBox((ofVec3f const &)*arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_drawBox__SWIG_4(lua_State* L) { int SWIG_arg = 0; float arg1 ; SWIG_check_num_args("ofDrawBox",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawBox",1,"float"); arg1 = (float)lua_tonumber(L, 1); ofDrawBox(arg1); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawBox__SWIG_5(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofDrawBox",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawBox",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawBox",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawBox",3,"float"); - arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - ofDrawBox(arg1,arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawBox(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); if (argc == 1) { int _v; - { _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_drawBox__SWIG_4(L);} } if (argc == 2) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_drawBox__SWIG_3(L);} } } - if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_drawBox__SWIG_5(L);} } } } if (argc == 4) { int _v; { - void *ptr; if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_drawBox__SWIG_2(L);} } } } } if (argc == 4) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { - return _wrap_drawBox__SWIG_1(L);} } } } } if (argc == 6) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { - { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { - return _wrap_drawBox__SWIG_0(L);} } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'drawBox'\n" " Possible C/C++ prototypes are:\n" - " ofDrawBox(float,float,float,float,float,float)\n" " ofDrawBox(float,float,float,float)\n" - " ofDrawBox(ofPoint const &,float,float,float)\n" " ofDrawBox(ofPoint const &,float)\n" " ofDrawBox(float)\n" - " ofDrawBox(float,float,float)\n"); lua_error(L);return 0; } -static int _wrap_TTF_SANS_get(lua_State* L) { int SWIG_arg = 0; std::string *result = 0 ; SWIG_check_num_args("OF_TTF_SANS",0,0) - result = (std::string *) &OF_TTF_SANS; lua_pushlstring(L,result->data(),result->size()); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TTF_SERIF_get(lua_State* L) { int SWIG_arg = 0; std::string *result = 0 ; - SWIG_check_num_args("OF_TTF_SERIF",0,0) result = (std::string *) &OF_TTF_SERIF; - lua_pushlstring(L,result->data(),result->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_TTF_MONO_get(lua_State* L) { int SWIG_arg = 0; std::string *result = 0 ; SWIG_check_num_args("OF_TTF_MONO",0,0) - result = (std::string *) &OF_TTF_MONO; lua_pushlstring(L,result->data(),result->size()); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_new_TrueTypeFont__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofTrueTypeFont *result = 0 ; - SWIG_check_num_args("ofTrueTypeFont::ofTrueTypeFont",0,0) result = (ofTrueTypeFont *)new ofTrueTypeFont(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTrueTypeFont,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_TrueTypeFont__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofTrueTypeFont *arg1 = 0 ; - ofTrueTypeFont *result = 0 ; SWIG_check_num_args("ofTrueTypeFont::ofTrueTypeFont",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofTrueTypeFont::ofTrueTypeFont",1,"ofTrueTypeFont &&"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("new_TrueTypeFont",1,SWIGTYPE_p_ofTrueTypeFont); } - result = (ofTrueTypeFont *)new ofTrueTypeFont((ofTrueTypeFont &&)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTrueTypeFont,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_TrueTypeFont(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_TrueTypeFont__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTrueTypeFont, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_new_TrueTypeFont__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_TrueTypeFont'\n" " Possible C/C++ prototypes are:\n" - " ofTrueTypeFont::ofTrueTypeFont()\n" " ofTrueTypeFont::ofTrueTypeFont(ofTrueTypeFont &&)\n"); lua_error(L);return 0; } -static int _wrap_TrueTypeFont_load__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; - std::string *arg2 = 0 ; int arg3 ; bool arg4 ; bool arg5 ; bool arg6 ; float arg7 ; int arg8 ; std::string temp2 ; - bool result; SWIG_check_num_args("ofTrueTypeFont::load",8,8) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::load",1,"ofTrueTypeFont *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofTrueTypeFont::load",2,"std::string const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTrueTypeFont::load",3,"int"); - if(!lua_isboolean(L,4)) SWIG_fail_arg("ofTrueTypeFont::load",4,"bool"); - if(!lua_isboolean(L,5)) SWIG_fail_arg("ofTrueTypeFont::load",5,"bool"); - if(!lua_isboolean(L,6)) SWIG_fail_arg("ofTrueTypeFont::load",6,"bool"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofTrueTypeFont::load",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofTrueTypeFont::load",8,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_load",1,SWIGTYPE_p_ofTrueTypeFont); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; arg3 = (int)lua_tonumber(L, 3); arg4 = (lua_toboolean(L, 4)!=0); - arg5 = (lua_toboolean(L, 5)!=0); arg6 = (lua_toboolean(L, 6)!=0); arg7 = (float)lua_tonumber(L, 7); - arg8 = (int)lua_tonumber(L, 8); result = (bool)(arg1)->load((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_load__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; - std::string *arg2 = 0 ; int arg3 ; bool arg4 ; bool arg5 ; bool arg6 ; float arg7 ; std::string temp2 ; bool result; - SWIG_check_num_args("ofTrueTypeFont::load",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::load",1,"ofTrueTypeFont *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofTrueTypeFont::load",2,"std::string const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTrueTypeFont::load",3,"int"); - if(!lua_isboolean(L,4)) SWIG_fail_arg("ofTrueTypeFont::load",4,"bool"); - if(!lua_isboolean(L,5)) SWIG_fail_arg("ofTrueTypeFont::load",5,"bool"); - if(!lua_isboolean(L,6)) SWIG_fail_arg("ofTrueTypeFont::load",6,"bool"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofTrueTypeFont::load",7,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_load",1,SWIGTYPE_p_ofTrueTypeFont); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; arg3 = (int)lua_tonumber(L, 3); arg4 = (lua_toboolean(L, 4)!=0); - arg5 = (lua_toboolean(L, 5)!=0); arg6 = (lua_toboolean(L, 6)!=0); arg7 = (float)lua_tonumber(L, 7); - result = (bool)(arg1)->load((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_load__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; - std::string *arg2 = 0 ; int arg3 ; bool arg4 ; bool arg5 ; bool arg6 ; std::string temp2 ; bool result; - SWIG_check_num_args("ofTrueTypeFont::load",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::load",1,"ofTrueTypeFont *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofTrueTypeFont::load",2,"std::string const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTrueTypeFont::load",3,"int"); - if(!lua_isboolean(L,4)) SWIG_fail_arg("ofTrueTypeFont::load",4,"bool"); - if(!lua_isboolean(L,5)) SWIG_fail_arg("ofTrueTypeFont::load",5,"bool"); - if(!lua_isboolean(L,6)) SWIG_fail_arg("ofTrueTypeFont::load",6,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_load",1,SWIGTYPE_p_ofTrueTypeFont); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; arg3 = (int)lua_tonumber(L, 3); arg4 = (lua_toboolean(L, 4)!=0); - arg5 = (lua_toboolean(L, 5)!=0); arg6 = (lua_toboolean(L, 6)!=0); - result = (bool)(arg1)->load((std::string const &)*arg2,arg3,arg4,arg5,arg6); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_load__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; - std::string *arg2 = 0 ; int arg3 ; bool arg4 ; bool arg5 ; std::string temp2 ; bool result; - SWIG_check_num_args("ofTrueTypeFont::load",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::load",1,"ofTrueTypeFont *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofTrueTypeFont::load",2,"std::string const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTrueTypeFont::load",3,"int"); - if(!lua_isboolean(L,4)) SWIG_fail_arg("ofTrueTypeFont::load",4,"bool"); - if(!lua_isboolean(L,5)) SWIG_fail_arg("ofTrueTypeFont::load",5,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_load",1,SWIGTYPE_p_ofTrueTypeFont); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; arg3 = (int)lua_tonumber(L, 3); arg4 = (lua_toboolean(L, 4)!=0); - arg5 = (lua_toboolean(L, 5)!=0); result = (bool)(arg1)->load((std::string const &)*arg2,arg3,arg4,arg5); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_load__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; - std::string *arg2 = 0 ; int arg3 ; bool arg4 ; std::string temp2 ; bool result; - SWIG_check_num_args("ofTrueTypeFont::load",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::load",1,"ofTrueTypeFont *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofTrueTypeFont::load",2,"std::string const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTrueTypeFont::load",3,"int"); - if(!lua_isboolean(L,4)) SWIG_fail_arg("ofTrueTypeFont::load",4,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_load",1,SWIGTYPE_p_ofTrueTypeFont); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; arg3 = (int)lua_tonumber(L, 3); arg4 = (lua_toboolean(L, 4)!=0); - result = (bool)(arg1)->load((std::string const &)*arg2,arg3,arg4); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_load__SWIG_5(lua_State* L) { int SWIG_arg = 0; ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; - std::string *arg2 = 0 ; int arg3 ; std::string temp2 ; bool result; SWIG_check_num_args("ofTrueTypeFont::load",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::load",1,"ofTrueTypeFont *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofTrueTypeFont::load",2,"std::string const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTrueTypeFont::load",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_load",1,SWIGTYPE_p_ofTrueTypeFont); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; arg3 = (int)lua_tonumber(L, 3); - result = (bool)(arg1)->load((std::string const &)*arg2,arg3); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_load(lua_State* L) { int argc; int argv[9]={ 1,2,3,4,5,6,7,8,9} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTrueTypeFont, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_TrueTypeFont_load__SWIG_5(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTrueTypeFont, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isboolean(L,argv[3]); } if (_v) { return _wrap_TrueTypeFont_load__SWIG_4(L);} } } } } - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTrueTypeFont, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isboolean(L,argv[3]); } if (_v) { { _v = lua_isboolean(L,argv[4]); } if (_v) { - return _wrap_TrueTypeFont_load__SWIG_3(L);} } } } } } if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTrueTypeFont, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isboolean(L,argv[3]); } if (_v) { { _v = lua_isboolean(L,argv[4]); } if (_v) { { - _v = lua_isboolean(L,argv[5]); } if (_v) { return _wrap_TrueTypeFont_load__SWIG_2(L);} } } } } } } - if (argc == 7) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTrueTypeFont, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isboolean(L,argv[3]); } if (_v) { { _v = lua_isboolean(L,argv[4]); } if (_v) { { - _v = lua_isboolean(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { - return _wrap_TrueTypeFont_load__SWIG_1(L);} } } } } } } } if (argc == 8) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTrueTypeFont, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isboolean(L,argv[3]); } if (_v) { { _v = lua_isboolean(L,argv[4]); } if (_v) { { - _v = lua_isboolean(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { return _wrap_TrueTypeFont_load__SWIG_0(L);} } } } } } } } - } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'TrueTypeFont_load'\n" - " Possible C/C++ prototypes are:\n" " ofTrueTypeFont::load(std::string const &,int,bool,bool,bool,float,int)\n" - " ofTrueTypeFont::load(std::string const &,int,bool,bool,bool,float)\n" - " ofTrueTypeFont::load(std::string const &,int,bool,bool,bool)\n" - " ofTrueTypeFont::load(std::string const &,int,bool,bool)\n" " ofTrueTypeFont::load(std::string const &,int,bool)\n" - " ofTrueTypeFont::load(std::string const &,int)\n"); lua_error(L);return 0; } -static int _wrap_TrueTypeFont_isLoaded(lua_State* L) { int SWIG_arg = 0; ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; - bool result; SWIG_check_num_args("ofTrueTypeFont::isLoaded",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::isLoaded",1,"ofTrueTypeFont const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_isLoaded",1,SWIGTYPE_p_ofTrueTypeFont); } - result = (bool)((ofTrueTypeFont const *)arg1)->isLoaded(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_setGlobalDpi(lua_State* L) { int SWIG_arg = 0; int arg1 ; - SWIG_check_num_args("ofTrueTypeFont::setGlobalDpi",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofTrueTypeFont::setGlobalDpi",1,"int"); arg1 = (int)lua_tonumber(L, 1); - ofTrueTypeFont::setGlobalDpi(arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_isAntiAliased(lua_State* L) { int SWIG_arg = 0; ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; - bool result; SWIG_check_num_args("ofTrueTypeFont::isAntiAliased",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::isAntiAliased",1,"ofTrueTypeFont const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_isAntiAliased",1,SWIGTYPE_p_ofTrueTypeFont); } - result = (bool)((ofTrueTypeFont const *)arg1)->isAntiAliased(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_hasFullCharacterSet(lua_State* L) { int SWIG_arg = 0; - ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; bool result; SWIG_check_num_args("ofTrueTypeFont::hasFullCharacterSet",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::hasFullCharacterSet",1,"ofTrueTypeFont const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_hasFullCharacterSet",1,SWIGTYPE_p_ofTrueTypeFont); } - result = (bool)((ofTrueTypeFont const *)arg1)->hasFullCharacterSet(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_getNumCharacters(lua_State* L) { int SWIG_arg = 0; ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; - int result; SWIG_check_num_args("ofTrueTypeFont::getNumCharacters",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::getNumCharacters",1,"ofTrueTypeFont const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_getNumCharacters",1,SWIGTYPE_p_ofTrueTypeFont); } - result = (int)((ofTrueTypeFont const *)arg1)->getNumCharacters(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_getSize(lua_State* L) { int SWIG_arg = 0; ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; - int result; SWIG_check_num_args("ofTrueTypeFont::getSize",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::getSize",1,"ofTrueTypeFont const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_getSize",1,SWIGTYPE_p_ofTrueTypeFont); } - result = (int)((ofTrueTypeFont const *)arg1)->getSize(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_getLineHeight(lua_State* L) { int SWIG_arg = 0; ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; - float result; SWIG_check_num_args("ofTrueTypeFont::getLineHeight",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::getLineHeight",1,"ofTrueTypeFont const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_getLineHeight",1,SWIGTYPE_p_ofTrueTypeFont); } - result = (float)((ofTrueTypeFont const *)arg1)->getLineHeight(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_setLineHeight(lua_State* L) { int SWIG_arg = 0; ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; - float arg2 ; SWIG_check_num_args("ofTrueTypeFont::setLineHeight",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::setLineHeight",1,"ofTrueTypeFont *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTrueTypeFont::setLineHeight",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_setLineHeight",1,SWIGTYPE_p_ofTrueTypeFont); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setLineHeight(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_getAscenderHeight(lua_State* L) { int SWIG_arg = 0; ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; - float result; SWIG_check_num_args("ofTrueTypeFont::getAscenderHeight",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::getAscenderHeight",1,"ofTrueTypeFont const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_getAscenderHeight",1,SWIGTYPE_p_ofTrueTypeFont); } - result = (float)((ofTrueTypeFont const *)arg1)->getAscenderHeight(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_getDescenderHeight(lua_State* L) { int SWIG_arg = 0; ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; - float result; SWIG_check_num_args("ofTrueTypeFont::getDescenderHeight",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::getDescenderHeight",1,"ofTrueTypeFont const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_getDescenderHeight",1,SWIGTYPE_p_ofTrueTypeFont); } - result = (float)((ofTrueTypeFont const *)arg1)->getDescenderHeight(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_getGlyphBBox(lua_State* L) { int SWIG_arg = 0; ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; - ofRectangle *result = 0 ; SWIG_check_num_args("ofTrueTypeFont::getGlyphBBox",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::getGlyphBBox",1,"ofTrueTypeFont const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_getGlyphBBox",1,SWIGTYPE_p_ofTrueTypeFont); } - result = (ofRectangle *) &((ofTrueTypeFont const *)arg1)->getGlyphBBox(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofRectangle,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_TrueTypeFont_getLetterSpacing(lua_State* L) { int SWIG_arg = 0; ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; - float result; SWIG_check_num_args("ofTrueTypeFont::getLetterSpacing",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::getLetterSpacing",1,"ofTrueTypeFont const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_getLetterSpacing",1,SWIGTYPE_p_ofTrueTypeFont); } - result = (float)((ofTrueTypeFont const *)arg1)->getLetterSpacing(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_setLetterSpacing(lua_State* L) { int SWIG_arg = 0; ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; - float arg2 ; SWIG_check_num_args("ofTrueTypeFont::setLetterSpacing",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::setLetterSpacing",1,"ofTrueTypeFont *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTrueTypeFont::setLetterSpacing",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_setLetterSpacing",1,SWIGTYPE_p_ofTrueTypeFont); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setLetterSpacing(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_getSpaceSize(lua_State* L) { int SWIG_arg = 0; ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; - float result; SWIG_check_num_args("ofTrueTypeFont::getSpaceSize",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::getSpaceSize",1,"ofTrueTypeFont const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_getSpaceSize",1,SWIGTYPE_p_ofTrueTypeFont); } - result = (float)((ofTrueTypeFont const *)arg1)->getSpaceSize(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_setSpaceSize(lua_State* L) { int SWIG_arg = 0; ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; - float arg2 ; SWIG_check_num_args("ofTrueTypeFont::setSpaceSize",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::setSpaceSize",1,"ofTrueTypeFont *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTrueTypeFont::setSpaceSize",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_setSpaceSize",1,SWIGTYPE_p_ofTrueTypeFont); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setSpaceSize(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_stringWidth(lua_State* L) { int SWIG_arg = 0; ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; - std::string *arg2 = 0 ; std::string temp2 ; float result; SWIG_check_num_args("ofTrueTypeFont::stringWidth",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::stringWidth",1,"ofTrueTypeFont const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofTrueTypeFont::stringWidth",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_stringWidth",1,SWIGTYPE_p_ofTrueTypeFont); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = (float)((ofTrueTypeFont const *)arg1)->stringWidth((std::string const &)*arg2); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_stringHeight(lua_State* L) { int SWIG_arg = 0; ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; - std::string *arg2 = 0 ; std::string temp2 ; float result; SWIG_check_num_args("ofTrueTypeFont::stringHeight",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::stringHeight",1,"ofTrueTypeFont const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofTrueTypeFont::stringHeight",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_stringHeight",1,SWIGTYPE_p_ofTrueTypeFont); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = (float)((ofTrueTypeFont const *)arg1)->stringHeight((std::string const &)*arg2); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_getStringBoundingBox__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; std::string *arg2 = 0 ; float arg3 ; float arg4 ; bool arg5 ; - std::string temp2 ; ofRectangle result; SWIG_check_num_args("ofTrueTypeFont::getStringBoundingBox",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::getStringBoundingBox",1,"ofTrueTypeFont const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofTrueTypeFont::getStringBoundingBox",2,"std::string const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTrueTypeFont::getStringBoundingBox",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofTrueTypeFont::getStringBoundingBox",4,"float"); - if(!lua_isboolean(L,5)) SWIG_fail_arg("ofTrueTypeFont::getStringBoundingBox",5,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_getStringBoundingBox",1,SWIGTYPE_p_ofTrueTypeFont); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; arg3 = (float)lua_tonumber(L, 3); - arg4 = (float)lua_tonumber(L, 4); arg5 = (lua_toboolean(L, 5)!=0); - result = ((ofTrueTypeFont const *)arg1)->getStringBoundingBox((std::string const &)*arg2,arg3,arg4,arg5); { - ofRectangle * resultptr = new ofRectangle((const ofRectangle &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofRectangle,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_getStringBoundingBox__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; std::string *arg2 = 0 ; float arg3 ; float arg4 ; std::string temp2 ; - ofRectangle result; SWIG_check_num_args("ofTrueTypeFont::getStringBoundingBox",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::getStringBoundingBox",1,"ofTrueTypeFont const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofTrueTypeFont::getStringBoundingBox",2,"std::string const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTrueTypeFont::getStringBoundingBox",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofTrueTypeFont::getStringBoundingBox",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_getStringBoundingBox",1,SWIGTYPE_p_ofTrueTypeFont); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; arg3 = (float)lua_tonumber(L, 3); - arg4 = (float)lua_tonumber(L, 4); - result = ((ofTrueTypeFont const *)arg1)->getStringBoundingBox((std::string const &)*arg2,arg3,arg4); { - ofRectangle * resultptr = new ofRectangle((const ofRectangle &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofRectangle,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_getStringBoundingBox(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); - if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTrueTypeFont, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_TrueTypeFont_getStringBoundingBox__SWIG_1(L);} } } } } - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTrueTypeFont, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isboolean(L,argv[4]); } if (_v) { - return _wrap_TrueTypeFont_getStringBoundingBox__SWIG_0(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'TrueTypeFont_getStringBoundingBox'\n" - " Possible C/C++ prototypes are:\n" " ofTrueTypeFont::getStringBoundingBox(std::string const &,float,float,bool) const\n" - " ofTrueTypeFont::getStringBoundingBox(std::string const &,float,float) const\n"); lua_error(L);return 0; } -static int _wrap_TrueTypeFont_drawString(lua_State* L) { int SWIG_arg = 0; ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; - std::string *arg2 = 0 ; float arg3 ; float arg4 ; std::string temp2 ; SWIG_check_num_args("ofTrueTypeFont::drawString",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::drawString",1,"ofTrueTypeFont const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofTrueTypeFont::drawString",2,"std::string const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTrueTypeFont::drawString",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofTrueTypeFont::drawString",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_drawString",1,SWIGTYPE_p_ofTrueTypeFont); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; arg3 = (float)lua_tonumber(L, 3); - arg4 = (float)lua_tonumber(L, 4); ((ofTrueTypeFont const *)arg1)->drawString((std::string const &)*arg2,arg3,arg4); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_drawStringAsShapes(lua_State* L) { int SWIG_arg = 0; ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; - std::string *arg2 = 0 ; float arg3 ; float arg4 ; std::string temp2 ; - SWIG_check_num_args("ofTrueTypeFont::drawStringAsShapes",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::drawStringAsShapes",1,"ofTrueTypeFont const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofTrueTypeFont::drawStringAsShapes",2,"std::string const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTrueTypeFont::drawStringAsShapes",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofTrueTypeFont::drawStringAsShapes",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_drawStringAsShapes",1,SWIGTYPE_p_ofTrueTypeFont); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; arg3 = (float)lua_tonumber(L, 3); - arg4 = (float)lua_tonumber(L, 4); ((ofTrueTypeFont const *)arg1)->drawStringAsShapes((std::string const &)*arg2,arg3,arg4); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_getCharacterAsPoints__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; int arg2 ; bool arg3 ; bool arg4 ; ofTTFCharacter result; - SWIG_check_num_args("ofTrueTypeFont::getCharacterAsPoints",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::getCharacterAsPoints",1,"ofTrueTypeFont const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTrueTypeFont::getCharacterAsPoints",2,"int"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofTrueTypeFont::getCharacterAsPoints",3,"bool"); - if(!lua_isboolean(L,4)) SWIG_fail_arg("ofTrueTypeFont::getCharacterAsPoints",4,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_getCharacterAsPoints",1,SWIGTYPE_p_ofTrueTypeFont); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (lua_toboolean(L, 3)!=0); arg4 = (lua_toboolean(L, 4)!=0); - result = ((ofTrueTypeFont const *)arg1)->getCharacterAsPoints(arg2,arg3,arg4); { - ofTTFCharacter * resultptr = new ofTTFCharacter((const ofTTFCharacter &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofPath,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_getCharacterAsPoints__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; int arg2 ; bool arg3 ; ofTTFCharacter result; - SWIG_check_num_args("ofTrueTypeFont::getCharacterAsPoints",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::getCharacterAsPoints",1,"ofTrueTypeFont const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTrueTypeFont::getCharacterAsPoints",2,"int"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofTrueTypeFont::getCharacterAsPoints",3,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_getCharacterAsPoints",1,SWIGTYPE_p_ofTrueTypeFont); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (lua_toboolean(L, 3)!=0); result = ((ofTrueTypeFont const *)arg1)->getCharacterAsPoints(arg2,arg3); { - ofTTFCharacter * resultptr = new ofTTFCharacter((const ofTTFCharacter &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofPath,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_getCharacterAsPoints__SWIG_2(lua_State* L) { int SWIG_arg = 0; - ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; int arg2 ; ofTTFCharacter result; - SWIG_check_num_args("ofTrueTypeFont::getCharacterAsPoints",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::getCharacterAsPoints",1,"ofTrueTypeFont const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTrueTypeFont::getCharacterAsPoints",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_getCharacterAsPoints",1,SWIGTYPE_p_ofTrueTypeFont); } arg2 = (int)lua_tonumber(L, 2); - result = ((ofTrueTypeFont const *)arg1)->getCharacterAsPoints(arg2); { - ofTTFCharacter * resultptr = new ofTTFCharacter((const ofTTFCharacter &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofPath,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_getCharacterAsPoints(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTrueTypeFont, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_TrueTypeFont_getCharacterAsPoints__SWIG_2(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTrueTypeFont, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - return _wrap_TrueTypeFont_getCharacterAsPoints__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTrueTypeFont, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - { _v = lua_isboolean(L,argv[3]); } if (_v) { return _wrap_TrueTypeFont_getCharacterAsPoints__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'TrueTypeFont_getCharacterAsPoints'\n" - " Possible C/C++ prototypes are:\n" " ofTrueTypeFont::getCharacterAsPoints(int,bool,bool) const\n" - " ofTrueTypeFont::getCharacterAsPoints(int,bool) const\n" " ofTrueTypeFont::getCharacterAsPoints(int) const\n"); - lua_error(L);return 0; } -static int _wrap_TrueTypeFont_getStringAsPoints__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; std::string *arg2 = 0 ; bool arg3 ; bool arg4 ; std::string temp2 ; - SwigValueWrapper< std::vector< ofPath > > result; SWIG_check_num_args("ofTrueTypeFont::getStringAsPoints",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::getStringAsPoints",1,"ofTrueTypeFont const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofTrueTypeFont::getStringAsPoints",2,"std::string const &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofTrueTypeFont::getStringAsPoints",3,"bool"); - if(!lua_isboolean(L,4)) SWIG_fail_arg("ofTrueTypeFont::getStringAsPoints",4,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_getStringAsPoints",1,SWIGTYPE_p_ofTrueTypeFont); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; arg3 = (lua_toboolean(L, 3)!=0); - arg4 = (lua_toboolean(L, 4)!=0); - result = ((ofTrueTypeFont const *)arg1)->getStringAsPoints((std::string const &)*arg2,arg3,arg4); { - std::vector< ofTTFCharacter > * resultptr = new std::vector< ofTTFCharacter >((const std::vector< ofTTFCharacter > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_ofPath_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_getStringAsPoints__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; std::string *arg2 = 0 ; bool arg3 ; std::string temp2 ; - SwigValueWrapper< std::vector< ofPath > > result; SWIG_check_num_args("ofTrueTypeFont::getStringAsPoints",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::getStringAsPoints",1,"ofTrueTypeFont const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofTrueTypeFont::getStringAsPoints",2,"std::string const &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofTrueTypeFont::getStringAsPoints",3,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_getStringAsPoints",1,SWIGTYPE_p_ofTrueTypeFont); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; arg3 = (lua_toboolean(L, 3)!=0); - result = ((ofTrueTypeFont const *)arg1)->getStringAsPoints((std::string const &)*arg2,arg3); { - std::vector< ofTTFCharacter > * resultptr = new std::vector< ofTTFCharacter >((const std::vector< ofTTFCharacter > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_ofPath_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_getStringAsPoints__SWIG_2(lua_State* L) { int SWIG_arg = 0; - ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; std::string *arg2 = 0 ; std::string temp2 ; - SwigValueWrapper< std::vector< ofPath > > result; SWIG_check_num_args("ofTrueTypeFont::getStringAsPoints",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::getStringAsPoints",1,"ofTrueTypeFont const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofTrueTypeFont::getStringAsPoints",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_getStringAsPoints",1,SWIGTYPE_p_ofTrueTypeFont); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = ((ofTrueTypeFont const *)arg1)->getStringAsPoints((std::string const &)*arg2); { - std::vector< ofTTFCharacter > * resultptr = new std::vector< ofTTFCharacter >((const std::vector< ofTTFCharacter > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_ofPath_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_getStringAsPoints(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTrueTypeFont, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { - return _wrap_TrueTypeFont_getStringAsPoints__SWIG_2(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTrueTypeFont, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - return _wrap_TrueTypeFont_getStringAsPoints__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTrueTypeFont, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - { _v = lua_isboolean(L,argv[3]); } if (_v) { return _wrap_TrueTypeFont_getStringAsPoints__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'TrueTypeFont_getStringAsPoints'\n" - " Possible C/C++ prototypes are:\n" " ofTrueTypeFont::getStringAsPoints(std::string const &,bool,bool) const\n" - " ofTrueTypeFont::getStringAsPoints(std::string const &,bool) const\n" - " ofTrueTypeFont::getStringAsPoints(std::string const &) const\n"); lua_error(L);return 0; } -static int _wrap_TrueTypeFont_getStringMesh__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; std::string *arg2 = 0 ; float arg3 ; float arg4 ; bool arg5 ; - std::string temp2 ; ofMesh *result = 0 ; SWIG_check_num_args("ofTrueTypeFont::getStringMesh",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::getStringMesh",1,"ofTrueTypeFont const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofTrueTypeFont::getStringMesh",2,"std::string const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTrueTypeFont::getStringMesh",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofTrueTypeFont::getStringMesh",4,"float"); - if(!lua_isboolean(L,5)) SWIG_fail_arg("ofTrueTypeFont::getStringMesh",5,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_getStringMesh",1,SWIGTYPE_p_ofTrueTypeFont); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; arg3 = (float)lua_tonumber(L, 3); - arg4 = (float)lua_tonumber(L, 4); arg5 = (lua_toboolean(L, 5)!=0); - result = (ofMesh *) &((ofTrueTypeFont const *)arg1)->getStringMesh((std::string const &)*arg2,arg3,arg4,arg5); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMesh,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_TrueTypeFont_getStringMesh__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; std::string *arg2 = 0 ; float arg3 ; float arg4 ; std::string temp2 ; - ofMesh *result = 0 ; SWIG_check_num_args("ofTrueTypeFont::getStringMesh",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::getStringMesh",1,"ofTrueTypeFont const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofTrueTypeFont::getStringMesh",2,"std::string const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTrueTypeFont::getStringMesh",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofTrueTypeFont::getStringMesh",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_getStringMesh",1,SWIGTYPE_p_ofTrueTypeFont); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; arg3 = (float)lua_tonumber(L, 3); - arg4 = (float)lua_tonumber(L, 4); - result = (ofMesh *) &((ofTrueTypeFont const *)arg1)->getStringMesh((std::string const &)*arg2,arg3,arg4); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMesh,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_TrueTypeFont_getStringMesh(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); - if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTrueTypeFont, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_TrueTypeFont_getStringMesh__SWIG_1(L);} } } } } - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTrueTypeFont, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isboolean(L,argv[4]); } if (_v) { - return _wrap_TrueTypeFont_getStringMesh__SWIG_0(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'TrueTypeFont_getStringMesh'\n" - " Possible C/C++ prototypes are:\n" " ofTrueTypeFont::getStringMesh(std::string const &,float,float,bool) const\n" - " ofTrueTypeFont::getStringMesh(std::string const &,float,float) const\n"); lua_error(L);return 0; } -static int _wrap_TrueTypeFont_getFontTexture(lua_State* L) { int SWIG_arg = 0; ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; - ofTexture *result = 0 ; SWIG_check_num_args("ofTrueTypeFont::getFontTexture",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::getFontTexture",1,"ofTrueTypeFont const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_getFontTexture",1,SWIGTYPE_p_ofTrueTypeFont); } - result = (ofTexture *) &((ofTrueTypeFont const *)arg1)->getFontTexture(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTexture,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static void swig_delete_TrueTypeFont(void *obj) { -ofTrueTypeFont *arg1 = (ofTrueTypeFont *) obj; -delete arg1; -} -static int _proxy__wrap_new_TrueTypeFont(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_TrueTypeFont); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_TrueTypeFont_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_TrueTypeFont_methods[]= { - { "load", _wrap_TrueTypeFont_load}, - { "isLoaded", _wrap_TrueTypeFont_isLoaded}, - { "isAntiAliased", _wrap_TrueTypeFont_isAntiAliased}, - { "hasFullCharacterSet", _wrap_TrueTypeFont_hasFullCharacterSet}, - { "getNumCharacters", _wrap_TrueTypeFont_getNumCharacters}, - { "getSize", _wrap_TrueTypeFont_getSize}, - { "getLineHeight", _wrap_TrueTypeFont_getLineHeight}, - { "setLineHeight", _wrap_TrueTypeFont_setLineHeight}, - { "getAscenderHeight", _wrap_TrueTypeFont_getAscenderHeight}, - { "getDescenderHeight", _wrap_TrueTypeFont_getDescenderHeight}, - { "getGlyphBBox", _wrap_TrueTypeFont_getGlyphBBox}, - { "getLetterSpacing", _wrap_TrueTypeFont_getLetterSpacing}, - { "setLetterSpacing", _wrap_TrueTypeFont_setLetterSpacing}, - { "getSpaceSize", _wrap_TrueTypeFont_getSpaceSize}, - { "setSpaceSize", _wrap_TrueTypeFont_setSpaceSize}, - { "stringWidth", _wrap_TrueTypeFont_stringWidth}, - { "stringHeight", _wrap_TrueTypeFont_stringHeight}, - { "getStringBoundingBox", _wrap_TrueTypeFont_getStringBoundingBox}, - { "drawString", _wrap_TrueTypeFont_drawString}, - { "drawStringAsShapes", _wrap_TrueTypeFont_drawStringAsShapes}, - { "getCharacterAsPoints", _wrap_TrueTypeFont_getCharacterAsPoints}, - { "getStringAsPoints", _wrap_TrueTypeFont_getStringAsPoints}, - { "getStringMesh", _wrap_TrueTypeFont_getStringMesh}, - { "getFontTexture", _wrap_TrueTypeFont_getFontTexture}, - {0,0} -}; -static swig_lua_method swig_TrueTypeFont_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_TrueTypeFont_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_TrueTypeFont_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_TrueTypeFont_Sf_SwigStatic_methods[]= { - { "setGlobalDpi", _wrap_TrueTypeFont_setGlobalDpi}, - {0,0} -}; -static swig_lua_class* swig_TrueTypeFont_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_TrueTypeFont_Sf_SwigStatic = { - "TrueTypeFont", - swig_TrueTypeFont_Sf_SwigStatic_methods, - swig_TrueTypeFont_Sf_SwigStatic_attributes, - swig_TrueTypeFont_Sf_SwigStatic_constants, - swig_TrueTypeFont_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_TrueTypeFont_bases[] = {0}; -static const char *swig_TrueTypeFont_base_names[] = {0}; -static swig_lua_class _wrap_class_TrueTypeFont = { "TrueTypeFont", "TrueTypeFont", &SWIGTYPE_p_ofTrueTypeFont,_proxy__wrap_new_TrueTypeFont, swig_delete_TrueTypeFont, swig_TrueTypeFont_methods, swig_TrueTypeFont_attributes, &swig_TrueTypeFont_Sf_SwigStatic, swig_TrueTypeFont_meta, swig_TrueTypeFont_bases, swig_TrueTypeFont_base_names }; - -static int _wrap_soundStreamSetup__SWIG_0(lua_State* L) { int SWIG_arg = 0; int arg1 ; int arg2 ; - ofBaseApp *arg3 = (ofBaseApp *) 0 ; SWIG_check_num_args("ofSoundStreamSetup",3,3) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSoundStreamSetup",1,"int"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSoundStreamSetup",2,"int"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofSoundStreamSetup",3,"ofBaseApp *"); arg1 = (int)lua_tonumber(L, 1); - arg2 = (int)lua_tonumber(L, 2); if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofBaseApp,0))){ - SWIG_fail_ptr("soundStreamSetup",3,SWIGTYPE_p_ofBaseApp); } ofSoundStreamSetup(arg1,arg2,arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_soundStreamSetup__SWIG_1(lua_State* L) { int SWIG_arg = 0; int arg1 ; int arg2 ; - SWIG_check_num_args("ofSoundStreamSetup",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSoundStreamSetup",1,"int"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSoundStreamSetup",2,"int"); arg1 = (int)lua_tonumber(L, 1); - arg2 = (int)lua_tonumber(L, 2); ofSoundStreamSetup(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_soundStreamSetup__SWIG_2(lua_State* L) { int SWIG_arg = 0; int arg1 ; int arg2 ; int arg3 ; int arg4 ; - int arg5 ; SWIG_check_num_args("ofSoundStreamSetup",5,5) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSoundStreamSetup",1,"int"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSoundStreamSetup",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofSoundStreamSetup",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofSoundStreamSetup",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofSoundStreamSetup",5,"int"); arg1 = (int)lua_tonumber(L, 1); - arg2 = (int)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - arg5 = (int)lua_tonumber(L, 5); ofSoundStreamSetup(arg1,arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_soundStreamSetup__SWIG_3(lua_State* L) { int SWIG_arg = 0; int arg1 ; int arg2 ; - ofBaseApp *arg3 = (ofBaseApp *) 0 ; int arg4 ; int arg5 ; int arg6 ; SWIG_check_num_args("ofSoundStreamSetup",6,6) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSoundStreamSetup",1,"int"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSoundStreamSetup",2,"int"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofSoundStreamSetup",3,"ofBaseApp *"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofSoundStreamSetup",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofSoundStreamSetup",5,"int"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofSoundStreamSetup",6,"int"); arg1 = (int)lua_tonumber(L, 1); - arg2 = (int)lua_tonumber(L, 2); if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofBaseApp,0))){ - SWIG_fail_ptr("soundStreamSetup",3,SWIGTYPE_p_ofBaseApp); } arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); - arg6 = (int)lua_tonumber(L, 6); ofSoundStreamSetup(arg1,arg2,arg3,arg4,arg5,arg6); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_soundStreamSetup(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_soundStreamSetup__SWIG_1(L);} } } if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { - { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofBaseApp, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_soundStreamSetup__SWIG_0(L);} } } } if (argc == 5) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_soundStreamSetup__SWIG_2(L);} } } } } } if (argc == 6) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofBaseApp, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } - if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { return _wrap_soundStreamSetup__SWIG_3(L);} } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'soundStreamSetup'\n" " Possible C/C++ prototypes are:\n" - " ofSoundStreamSetup(int,int,ofBaseApp *)\n" " ofSoundStreamSetup(int,int)\n" - " ofSoundStreamSetup(int,int,int,int,int)\n" " ofSoundStreamSetup(int,int,ofBaseApp *,int,int,int)\n"); - lua_error(L);return 0; } -static int _wrap_soundStreamStop(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofSoundStreamStop",0,0) - ofSoundStreamStop(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_soundStreamStart(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofSoundStreamStart",0,0) - ofSoundStreamStart(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_soundStreamClose(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofSoundStreamClose",0,0) - ofSoundStreamClose(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_soundStreamListDevices(lua_State* L) { int SWIG_arg = 0; - SwigValueWrapper< std::vector< ofSoundDevice > > result; SWIG_check_num_args("ofSoundStreamListDevices",0,0) - result = ofSoundStreamListDevices(); { - std::vector< ofSoundDevice > * resultptr = new std::vector< ofSoundDevice >((const std::vector< ofSoundDevice > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_ofSoundDevice_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_new_SoundStream(lua_State* L) { int SWIG_arg = 0; ofSoundStream *result = 0 ; - SWIG_check_num_args("ofSoundStream::ofSoundStream",0,0) result = (ofSoundStream *)new ofSoundStream(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofSoundStream,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_SoundStream_setSoundStream(lua_State* L) { int SWIG_arg = 0; ofSoundStream *arg1 = (ofSoundStream *) 0 ; - shared_ptr< ofBaseSoundStream > arg2 ; shared_ptr< ofBaseSoundStream > *argp2 ; - SWIG_check_num_args("ofSoundStream::setSoundStream",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStream::setSoundStream",1,"ofSoundStream *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofSoundStream::setSoundStream",2,"shared_ptr< ofBaseSoundStream >"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStream,0))){ - SWIG_fail_ptr("SoundStream_setSoundStream",1,SWIGTYPE_p_ofSoundStream); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_shared_ptrT_ofBaseSoundStream_t,0))){ - SWIG_fail_ptr("SoundStream_setSoundStream",2,SWIGTYPE_p_shared_ptrT_ofBaseSoundStream_t); } arg2 = *argp2; - (arg1)->setSoundStream(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundStream_getSoundStream(lua_State* L) { int SWIG_arg = 0; ofSoundStream *arg1 = (ofSoundStream *) 0 ; - shared_ptr< ofBaseSoundStream > result; SWIG_check_num_args("ofSoundStream::getSoundStream",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStream::getSoundStream",1,"ofSoundStream *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStream,0))){ - SWIG_fail_ptr("SoundStream_getSoundStream",1,SWIGTYPE_p_ofSoundStream); } result = (arg1)->getSoundStream(); { - shared_ptr< ofBaseSoundStream > * resultptr = new shared_ptr< ofBaseSoundStream >((const shared_ptr< ofBaseSoundStream > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_shared_ptrT_ofBaseSoundStream_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundStream_printDeviceList(lua_State* L) { int SWIG_arg = 0; ofSoundStream *arg1 = (ofSoundStream *) 0 ; - SWIG_check_num_args("ofSoundStream::printDeviceList",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStream::printDeviceList",1,"ofSoundStream const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStream,0))){ - SWIG_fail_ptr("SoundStream_printDeviceList",1,SWIGTYPE_p_ofSoundStream); } - ((ofSoundStream const *)arg1)->printDeviceList(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundStream_getDeviceList(lua_State* L) { int SWIG_arg = 0; ofSoundStream *arg1 = (ofSoundStream *) 0 ; - SwigValueWrapper< std::vector< ofSoundDevice > > result; SWIG_check_num_args("ofSoundStream::getDeviceList",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStream::getDeviceList",1,"ofSoundStream const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStream,0))){ - SWIG_fail_ptr("SoundStream_getDeviceList",1,SWIGTYPE_p_ofSoundStream); } - result = ((ofSoundStream const *)arg1)->getDeviceList(); { - std::vector< ofSoundDevice > * resultptr = new std::vector< ofSoundDevice >((const std::vector< ofSoundDevice > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_ofSoundDevice_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundStream_getMatchingDevices__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofSoundStream *arg1 = (ofSoundStream *) 0 ; std::string *arg2 = 0 ; unsigned int arg3 ; unsigned int arg4 ; - std::string temp2 ; SwigValueWrapper< std::vector< ofSoundDevice > > result; - SWIG_check_num_args("ofSoundStream::getMatchingDevices",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStream::getMatchingDevices",1,"ofSoundStream const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofSoundStream::getMatchingDevices",2,"std::string const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofSoundStream::getMatchingDevices",3,"unsigned int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofSoundStream::getMatchingDevices",4,"unsigned int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStream,0))){ - SWIG_fail_ptr("SoundStream_getMatchingDevices",1,SWIGTYPE_p_ofSoundStream); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (unsigned int)lua_tonumber(L, 3); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (unsigned int)lua_tonumber(L, 4); - result = ((ofSoundStream const *)arg1)->getMatchingDevices((std::string const &)*arg2,arg3,arg4); { - std::vector< ofSoundDevice > * resultptr = new std::vector< ofSoundDevice >((const std::vector< ofSoundDevice > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_ofSoundDevice_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundStream_getMatchingDevices__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofSoundStream *arg1 = (ofSoundStream *) 0 ; std::string *arg2 = 0 ; unsigned int arg3 ; std::string temp2 ; - SwigValueWrapper< std::vector< ofSoundDevice > > result; SWIG_check_num_args("ofSoundStream::getMatchingDevices",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStream::getMatchingDevices",1,"ofSoundStream const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofSoundStream::getMatchingDevices",2,"std::string const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofSoundStream::getMatchingDevices",3,"unsigned int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStream,0))){ - SWIG_fail_ptr("SoundStream_getMatchingDevices",1,SWIGTYPE_p_ofSoundStream); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (unsigned int)lua_tonumber(L, 3); - result = ((ofSoundStream const *)arg1)->getMatchingDevices((std::string const &)*arg2,arg3); { - std::vector< ofSoundDevice > * resultptr = new std::vector< ofSoundDevice >((const std::vector< ofSoundDevice > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_ofSoundDevice_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundStream_getMatchingDevices__SWIG_2(lua_State* L) { int SWIG_arg = 0; - ofSoundStream *arg1 = (ofSoundStream *) 0 ; std::string *arg2 = 0 ; std::string temp2 ; - SwigValueWrapper< std::vector< ofSoundDevice > > result; SWIG_check_num_args("ofSoundStream::getMatchingDevices",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStream::getMatchingDevices",1,"ofSoundStream const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofSoundStream::getMatchingDevices",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStream,0))){ - SWIG_fail_ptr("SoundStream_getMatchingDevices",1,SWIGTYPE_p_ofSoundStream); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = ((ofSoundStream const *)arg1)->getMatchingDevices((std::string const &)*arg2); { - std::vector< ofSoundDevice > * resultptr = new std::vector< ofSoundDevice >((const std::vector< ofSoundDevice > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_ofSoundDevice_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundStream_getMatchingDevices(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofSoundStream, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { - return _wrap_SoundStream_getMatchingDevices__SWIG_2(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofSoundStream, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_SoundStream_getMatchingDevices__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofSoundStream, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_SoundStream_getMatchingDevices__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SoundStream_getMatchingDevices'\n" - " Possible C/C++ prototypes are:\n" - " ofSoundStream::getMatchingDevices(std::string const &,unsigned int,unsigned int) const\n" - " ofSoundStream::getMatchingDevices(std::string const &,unsigned int) const\n" - " ofSoundStream::getMatchingDevices(std::string const &) const\n"); lua_error(L);return 0; } -static int _wrap_SoundStream_setDeviceID(lua_State* L) { int SWIG_arg = 0; ofSoundStream *arg1 = (ofSoundStream *) 0 ; - int arg2 ; SWIG_check_num_args("ofSoundStream::setDeviceID",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStream::setDeviceID",1,"ofSoundStream *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSoundStream::setDeviceID",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStream,0))){ - SWIG_fail_ptr("SoundStream_setDeviceID",1,SWIGTYPE_p_ofSoundStream); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->setDeviceID(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundStream_setDevice(lua_State* L) { int SWIG_arg = 0; ofSoundStream *arg1 = (ofSoundStream *) 0 ; - ofSoundDevice *arg2 = 0 ; SWIG_check_num_args("ofSoundStream::setDevice",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStream::setDevice",1,"ofSoundStream *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofSoundStream::setDevice",2,"ofSoundDevice const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStream,0))){ - SWIG_fail_ptr("SoundStream_setDevice",1,SWIGTYPE_p_ofSoundStream); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofSoundDevice,0))){ - SWIG_fail_ptr("SoundStream_setDevice",2,SWIGTYPE_p_ofSoundDevice); } (arg1)->setDevice((ofSoundDevice const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundStream_setup__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofSoundStream *arg1 = (ofSoundStream *) 0 ; - ofBaseApp *arg2 = (ofBaseApp *) 0 ; int arg3 ; int arg4 ; int arg5 ; int arg6 ; int arg7 ; bool result; - SWIG_check_num_args("ofSoundStream::setup",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStream::setup",1,"ofSoundStream *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofSoundStream::setup",2,"ofBaseApp *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofSoundStream::setup",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofSoundStream::setup",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofSoundStream::setup",5,"int"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofSoundStream::setup",6,"int"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofSoundStream::setup",7,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStream,0))){ - SWIG_fail_ptr("SoundStream_setup",1,SWIGTYPE_p_ofSoundStream); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBaseApp,0))){ - SWIG_fail_ptr("SoundStream_setup",2,SWIGTYPE_p_ofBaseApp); } arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); arg6 = (int)lua_tonumber(L, 6); - arg7 = (int)lua_tonumber(L, 7); result = (bool)(arg1)->setup(arg2,arg3,arg4,arg5,arg6,arg7); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundStream_setup__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofSoundStream *arg1 = (ofSoundStream *) 0 ; - int arg2 ; int arg3 ; int arg4 ; int arg5 ; int arg6 ; bool result; SWIG_check_num_args("ofSoundStream::setup",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStream::setup",1,"ofSoundStream *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSoundStream::setup",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofSoundStream::setup",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofSoundStream::setup",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofSoundStream::setup",5,"int"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofSoundStream::setup",6,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStream,0))){ - SWIG_fail_ptr("SoundStream_setup",1,SWIGTYPE_p_ofSoundStream); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); - arg6 = (int)lua_tonumber(L, 6); result = (bool)(arg1)->setup(arg2,arg3,arg4,arg5,arg6); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundStream_setup(lua_State* L) { int argc; int argv[8]={ 1,2,3,4,5,6,7,8} ; argc = lua_gettop(L); - if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofSoundStream, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { return _wrap_SoundStream_setup__SWIG_1(L);} } } } } } } - if (argc == 7) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofSoundStream, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBaseApp, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { { - _v = lua_isnumber(L,argv[6]); } if (_v) { return _wrap_SoundStream_setup__SWIG_0(L);} } } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SoundStream_setup'\n" " Possible C/C++ prototypes are:\n" - " ofSoundStream::setup(ofBaseApp *,int,int,int,int,int)\n" " ofSoundStream::setup(int,int,int,int,int)\n"); - lua_error(L);return 0; } -static int _wrap_SoundStream_setInput(lua_State* L) { int SWIG_arg = 0; ofSoundStream *arg1 = (ofSoundStream *) 0 ; - ofBaseSoundInput *arg2 = (ofBaseSoundInput *) 0 ; SWIG_check_num_args("ofSoundStream::setInput",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStream::setInput",1,"ofSoundStream *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofSoundStream::setInput",2,"ofBaseSoundInput *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStream,0))){ - SWIG_fail_ptr("SoundStream_setInput",1,SWIGTYPE_p_ofSoundStream); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBaseSoundInput,0))){ - SWIG_fail_ptr("SoundStream_setInput",2,SWIGTYPE_p_ofBaseSoundInput); } (arg1)->setInput(arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundStream_setOutput(lua_State* L) { int SWIG_arg = 0; ofSoundStream *arg1 = (ofSoundStream *) 0 ; - ofBaseSoundOutput *arg2 = (ofBaseSoundOutput *) 0 ; SWIG_check_num_args("ofSoundStream::setOutput",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStream::setOutput",1,"ofSoundStream *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofSoundStream::setOutput",2,"ofBaseSoundOutput *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStream,0))){ - SWIG_fail_ptr("SoundStream_setOutput",1,SWIGTYPE_p_ofSoundStream); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBaseSoundOutput,0))){ - SWIG_fail_ptr("SoundStream_setOutput",2,SWIGTYPE_p_ofBaseSoundOutput); } (arg1)->setOutput(arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundStream_start(lua_State* L) { int SWIG_arg = 0; ofSoundStream *arg1 = (ofSoundStream *) 0 ; - SWIG_check_num_args("ofSoundStream::start",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStream::start",1,"ofSoundStream *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStream,0))){ - SWIG_fail_ptr("SoundStream_start",1,SWIGTYPE_p_ofSoundStream); } (arg1)->start(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_SoundStream_stop(lua_State* L) { int SWIG_arg = 0; ofSoundStream *arg1 = (ofSoundStream *) 0 ; - SWIG_check_num_args("ofSoundStream::stop",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStream::stop",1,"ofSoundStream *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStream,0))){ - SWIG_fail_ptr("SoundStream_stop",1,SWIGTYPE_p_ofSoundStream); } (arg1)->stop(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_SoundStream_close(lua_State* L) { int SWIG_arg = 0; ofSoundStream *arg1 = (ofSoundStream *) 0 ; - SWIG_check_num_args("ofSoundStream::close",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStream::close",1,"ofSoundStream *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStream,0))){ - SWIG_fail_ptr("SoundStream_close",1,SWIGTYPE_p_ofSoundStream); } (arg1)->close(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_SoundStream_getTickCount(lua_State* L) { int SWIG_arg = 0; ofSoundStream *arg1 = (ofSoundStream *) 0 ; - unsigned long long result; SWIG_check_num_args("ofSoundStream::getTickCount",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStream::getTickCount",1,"ofSoundStream const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStream,0))){ - SWIG_fail_ptr("SoundStream_getTickCount",1,SWIGTYPE_p_ofSoundStream); } - result = (unsigned long long)((ofSoundStream const *)arg1)->getTickCount(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundStream_getNumInputChannels(lua_State* L) { int SWIG_arg = 0; ofSoundStream *arg1 = (ofSoundStream *) 0 ; - int result; SWIG_check_num_args("ofSoundStream::getNumInputChannels",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStream::getNumInputChannels",1,"ofSoundStream const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStream,0))){ - SWIG_fail_ptr("SoundStream_getNumInputChannels",1,SWIGTYPE_p_ofSoundStream); } - result = (int)((ofSoundStream const *)arg1)->getNumInputChannels(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundStream_getNumOutputChannels(lua_State* L) { int SWIG_arg = 0; ofSoundStream *arg1 = (ofSoundStream *) 0 ; - int result; SWIG_check_num_args("ofSoundStream::getNumOutputChannels",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStream::getNumOutputChannels",1,"ofSoundStream const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStream,0))){ - SWIG_fail_ptr("SoundStream_getNumOutputChannels",1,SWIGTYPE_p_ofSoundStream); } - result = (int)((ofSoundStream const *)arg1)->getNumOutputChannels(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundStream_getSampleRate(lua_State* L) { int SWIG_arg = 0; ofSoundStream *arg1 = (ofSoundStream *) 0 ; - int result; SWIG_check_num_args("ofSoundStream::getSampleRate",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStream::getSampleRate",1,"ofSoundStream const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStream,0))){ - SWIG_fail_ptr("SoundStream_getSampleRate",1,SWIGTYPE_p_ofSoundStream); } - result = (int)((ofSoundStream const *)arg1)->getSampleRate(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundStream_getBufferSize(lua_State* L) { int SWIG_arg = 0; ofSoundStream *arg1 = (ofSoundStream *) 0 ; - int result; SWIG_check_num_args("ofSoundStream::getBufferSize",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStream::getBufferSize",1,"ofSoundStream const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStream,0))){ - SWIG_fail_ptr("SoundStream_getBufferSize",1,SWIGTYPE_p_ofSoundStream); } - result = (int)((ofSoundStream const *)arg1)->getBufferSize(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_SoundStream(void *obj) { -ofSoundStream *arg1 = (ofSoundStream *) obj; -delete arg1; -} -static int _proxy__wrap_new_SoundStream(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_SoundStream); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_SoundStream_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_SoundStream_methods[]= { - { "setSoundStream", _wrap_SoundStream_setSoundStream}, - { "getSoundStream", _wrap_SoundStream_getSoundStream}, - { "printDeviceList", _wrap_SoundStream_printDeviceList}, - { "getDeviceList", _wrap_SoundStream_getDeviceList}, - { "getMatchingDevices", _wrap_SoundStream_getMatchingDevices}, - { "setDeviceID", _wrap_SoundStream_setDeviceID}, - { "setDevice", _wrap_SoundStream_setDevice}, - { "setup", _wrap_SoundStream_setup}, - { "setInput", _wrap_SoundStream_setInput}, - { "setOutput", _wrap_SoundStream_setOutput}, - { "start", _wrap_SoundStream_start}, - { "stop", _wrap_SoundStream_stop}, - { "close", _wrap_SoundStream_close}, - { "getTickCount", _wrap_SoundStream_getTickCount}, - { "getNumInputChannels", _wrap_SoundStream_getNumInputChannels}, - { "getNumOutputChannels", _wrap_SoundStream_getNumOutputChannels}, - { "getSampleRate", _wrap_SoundStream_getSampleRate}, - { "getBufferSize", _wrap_SoundStream_getBufferSize}, - {0,0} -}; -static swig_lua_method swig_SoundStream_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_SoundStream_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_SoundStream_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_SoundStream_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_SoundStream_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_SoundStream_Sf_SwigStatic = { - "SoundStream", - swig_SoundStream_Sf_SwigStatic_methods, - swig_SoundStream_Sf_SwigStatic_attributes, - swig_SoundStream_Sf_SwigStatic_constants, - swig_SoundStream_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_SoundStream_bases[] = {0}; -static const char *swig_SoundStream_base_names[] = {0}; -static swig_lua_class _wrap_class_SoundStream = { "SoundStream", "SoundStream", &SWIGTYPE_p_ofSoundStream,_proxy__wrap_new_SoundStream, swig_delete_SoundStream, swig_SoundStream_methods, swig_SoundStream_attributes, &swig_SoundStream_Sf_SwigStatic, swig_SoundStream_meta, swig_SoundStream_bases, swig_SoundStream_base_names }; - -static int _wrap_new_SoundPlayer(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *result = 0 ; - SWIG_check_num_args("ofSoundPlayer::ofSoundPlayer",0,0) result = (ofSoundPlayer *)new ofSoundPlayer(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofSoundPlayer,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_SoundPlayer_setPlayer(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; - SwigValueWrapper< shared_ptr< ofBaseSoundPlayer > > arg2 ; shared_ptr< ofBaseSoundPlayer > *argp2 ; - SWIG_check_num_args("ofSoundPlayer::setPlayer",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::setPlayer",1,"ofSoundPlayer *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofSoundPlayer::setPlayer",2,"shared_ptr< ofBaseSoundPlayer >"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_setPlayer",1,SWIGTYPE_p_ofSoundPlayer); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_shared_ptrT_ofBaseSoundPlayer_t,0))){ - SWIG_fail_ptr("SoundPlayer_setPlayer",2,SWIGTYPE_p_shared_ptrT_ofBaseSoundPlayer_t); } arg2 = *argp2; - (arg1)->setPlayer(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundPlayer_getPlayer(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; - SwigValueWrapper< shared_ptr< ofBaseSoundPlayer > > result; SWIG_check_num_args("ofSoundPlayer::getPlayer",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::getPlayer",1,"ofSoundPlayer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_getPlayer",1,SWIGTYPE_p_ofSoundPlayer); } result = (arg1)->getPlayer(); { - shared_ptr< ofBaseSoundPlayer > * resultptr = new shared_ptr< ofBaseSoundPlayer >((const shared_ptr< ofBaseSoundPlayer > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_shared_ptrT_ofBaseSoundPlayer_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundPlayer_load__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; - std::string arg2 ; bool arg3 ; bool result; SWIG_check_num_args("ofSoundPlayer::load",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::load",1,"ofSoundPlayer *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofSoundPlayer::load",2,"std::string"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofSoundPlayer::load",3,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_load",1,SWIGTYPE_p_ofSoundPlayer); } (&arg2)->assign(lua_tostring(L,2),lua_rawlen(L,2)); - arg3 = (lua_toboolean(L, 3)!=0); result = (bool)(arg1)->load(arg2,arg3); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundPlayer_load__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; - std::string arg2 ; bool result; SWIG_check_num_args("ofSoundPlayer::load",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::load",1,"ofSoundPlayer *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofSoundPlayer::load",2,"std::string"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_load",1,SWIGTYPE_p_ofSoundPlayer); } (&arg2)->assign(lua_tostring(L,2),lua_rawlen(L,2)); - result = (bool)(arg1)->load(arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_SoundPlayer_load(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofSoundPlayer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { return _wrap_SoundPlayer_load__SWIG_1(L);} } - } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofSoundPlayer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - return _wrap_SoundPlayer_load__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SoundPlayer_load'\n" " Possible C/C++ prototypes are:\n" - " ofSoundPlayer::load(std::string,bool)\n" " ofSoundPlayer::load(std::string)\n"); lua_error(L);return 0; } -static int _wrap_SoundPlayer_unload(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; - SWIG_check_num_args("ofSoundPlayer::unload",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::unload",1,"ofSoundPlayer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_unload",1,SWIGTYPE_p_ofSoundPlayer); } (arg1)->unload(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_SoundPlayer_play(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; - SWIG_check_num_args("ofSoundPlayer::play",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::play",1,"ofSoundPlayer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_play",1,SWIGTYPE_p_ofSoundPlayer); } (arg1)->play(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_SoundPlayer_stop(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; - SWIG_check_num_args("ofSoundPlayer::stop",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::stop",1,"ofSoundPlayer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_stop",1,SWIGTYPE_p_ofSoundPlayer); } (arg1)->stop(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_SoundPlayer_setVolume(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; - float arg2 ; SWIG_check_num_args("ofSoundPlayer::setVolume",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::setVolume",1,"ofSoundPlayer *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSoundPlayer::setVolume",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_setVolume",1,SWIGTYPE_p_ofSoundPlayer); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setVolume(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundPlayer_setPan(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; float arg2 ; - SWIG_check_num_args("ofSoundPlayer::setPan",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::setPan",1,"ofSoundPlayer *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSoundPlayer::setPan",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_setPan",1,SWIGTYPE_p_ofSoundPlayer); } arg2 = (float)lua_tonumber(L, 2); (arg1)->setPan(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundPlayer_setSpeed(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; float arg2 ; - SWIG_check_num_args("ofSoundPlayer::setSpeed",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::setSpeed",1,"ofSoundPlayer *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSoundPlayer::setSpeed",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_setSpeed",1,SWIGTYPE_p_ofSoundPlayer); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setSpeed(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundPlayer_setPaused(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; bool arg2 ; - SWIG_check_num_args("ofSoundPlayer::setPaused",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::setPaused",1,"ofSoundPlayer *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofSoundPlayer::setPaused",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_setPaused",1,SWIGTYPE_p_ofSoundPlayer); } arg2 = (lua_toboolean(L, 2)!=0); - (arg1)->setPaused(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundPlayer_setLoop(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; bool arg2 ; - SWIG_check_num_args("ofSoundPlayer::setLoop",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::setLoop",1,"ofSoundPlayer *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofSoundPlayer::setLoop",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_setLoop",1,SWIGTYPE_p_ofSoundPlayer); } arg2 = (lua_toboolean(L, 2)!=0); (arg1)->setLoop(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundPlayer_setMultiPlay(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; - bool arg2 ; SWIG_check_num_args("ofSoundPlayer::setMultiPlay",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::setMultiPlay",1,"ofSoundPlayer *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofSoundPlayer::setMultiPlay",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_setMultiPlay",1,SWIGTYPE_p_ofSoundPlayer); } arg2 = (lua_toboolean(L, 2)!=0); - (arg1)->setMultiPlay(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundPlayer_setPosition(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; - float arg2 ; SWIG_check_num_args("ofSoundPlayer::setPosition",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::setPosition",1,"ofSoundPlayer *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSoundPlayer::setPosition",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_setPosition",1,SWIGTYPE_p_ofSoundPlayer); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setPosition(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundPlayer_setPositionMS(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; - int arg2 ; SWIG_check_num_args("ofSoundPlayer::setPositionMS",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::setPositionMS",1,"ofSoundPlayer *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSoundPlayer::setPositionMS",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_setPositionMS",1,SWIGTYPE_p_ofSoundPlayer); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->setPositionMS(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundPlayer_getPositionMS(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; - int result; SWIG_check_num_args("ofSoundPlayer::getPositionMS",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::getPositionMS",1,"ofSoundPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_getPositionMS",1,SWIGTYPE_p_ofSoundPlayer); } - result = (int)((ofSoundPlayer const *)arg1)->getPositionMS(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundPlayer_getPosition(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; - float result; SWIG_check_num_args("ofSoundPlayer::getPosition",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::getPosition",1,"ofSoundPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_getPosition",1,SWIGTYPE_p_ofSoundPlayer); } - result = (float)((ofSoundPlayer const *)arg1)->getPosition(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundPlayer_isPlaying(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; - bool result; SWIG_check_num_args("ofSoundPlayer::isPlaying",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::isPlaying",1,"ofSoundPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_isPlaying",1,SWIGTYPE_p_ofSoundPlayer); } - result = (bool)((ofSoundPlayer const *)arg1)->isPlaying(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundPlayer_getSpeed(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; - float result; SWIG_check_num_args("ofSoundPlayer::getSpeed",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::getSpeed",1,"ofSoundPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_getSpeed",1,SWIGTYPE_p_ofSoundPlayer); } - result = (float)((ofSoundPlayer const *)arg1)->getSpeed(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundPlayer_getPan(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; float result; - SWIG_check_num_args("ofSoundPlayer::getPan",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::getPan",1,"ofSoundPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_getPan",1,SWIGTYPE_p_ofSoundPlayer); } result = (float)((ofSoundPlayer const *)arg1)->getPan(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundPlayer_getVolume(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; - float result; SWIG_check_num_args("ofSoundPlayer::getVolume",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::getVolume",1,"ofSoundPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_getVolume",1,SWIGTYPE_p_ofSoundPlayer); } - result = (float)((ofSoundPlayer const *)arg1)->getVolume(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundPlayer_isLoaded(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; bool result; - SWIG_check_num_args("ofSoundPlayer::isLoaded",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::isLoaded",1,"ofSoundPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_isLoaded",1,SWIGTYPE_p_ofSoundPlayer); } - result = (bool)((ofSoundPlayer const *)arg1)->isLoaded(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_SoundPlayer(void *obj) { -ofSoundPlayer *arg1 = (ofSoundPlayer *) obj; -delete arg1; -} -static int _proxy__wrap_new_SoundPlayer(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_SoundPlayer); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_SoundPlayer_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_SoundPlayer_methods[]= { - { "setPlayer", _wrap_SoundPlayer_setPlayer}, - { "getPlayer", _wrap_SoundPlayer_getPlayer}, - { "load", _wrap_SoundPlayer_load}, - { "unload", _wrap_SoundPlayer_unload}, - { "play", _wrap_SoundPlayer_play}, - { "stop", _wrap_SoundPlayer_stop}, - { "setVolume", _wrap_SoundPlayer_setVolume}, - { "setPan", _wrap_SoundPlayer_setPan}, - { "setSpeed", _wrap_SoundPlayer_setSpeed}, - { "setPaused", _wrap_SoundPlayer_setPaused}, - { "setLoop", _wrap_SoundPlayer_setLoop}, - { "setMultiPlay", _wrap_SoundPlayer_setMultiPlay}, - { "setPosition", _wrap_SoundPlayer_setPosition}, - { "setPositionMS", _wrap_SoundPlayer_setPositionMS}, - { "getPositionMS", _wrap_SoundPlayer_getPositionMS}, - { "getPosition", _wrap_SoundPlayer_getPosition}, - { "isPlaying", _wrap_SoundPlayer_isPlaying}, - { "getSpeed", _wrap_SoundPlayer_getSpeed}, - { "getPan", _wrap_SoundPlayer_getPan}, - { "getVolume", _wrap_SoundPlayer_getVolume}, - { "isLoaded", _wrap_SoundPlayer_isLoaded}, - {0,0} -}; -static swig_lua_method swig_SoundPlayer_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_SoundPlayer_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_SoundPlayer_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_SoundPlayer_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_SoundPlayer_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_SoundPlayer_Sf_SwigStatic = { - "SoundPlayer", - swig_SoundPlayer_Sf_SwigStatic_methods, - swig_SoundPlayer_Sf_SwigStatic_attributes, - swig_SoundPlayer_Sf_SwigStatic_constants, - swig_SoundPlayer_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_SoundPlayer_bases[] = {0}; -static const char *swig_SoundPlayer_base_names[] = {0}; -static swig_lua_class _wrap_class_SoundPlayer = { "SoundPlayer", "SoundPlayer", &SWIGTYPE_p_ofSoundPlayer,_proxy__wrap_new_SoundPlayer, swig_delete_SoundPlayer, swig_SoundPlayer_methods, swig_SoundPlayer_attributes, &swig_SoundPlayer_Sf_SwigStatic, swig_SoundPlayer_meta, swig_SoundPlayer_bases, swig_SoundPlayer_base_names }; - -static int _wrap_new_Color__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::ofColor_",0,0) - result = (ofColor_< unsigned char > *)new ofColor_< unsigned char >(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_Color__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - ofColor_< unsigned char > *result = 0 ; SWIG_check_num_args("ofColor_< unsigned char >::ofColor_",4,4) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::ofColor_",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::ofColor_",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< unsigned char >::ofColor_",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofColor_< unsigned char >::ofColor_",4,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - result = (ofColor_< unsigned char > *)new ofColor_< unsigned char >(arg1,arg2,arg3,arg4); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_Color__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; - ofColor_< unsigned char > *result = 0 ; SWIG_check_num_args("ofColor_< unsigned char >::ofColor_",3,3) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::ofColor_",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::ofColor_",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< unsigned char >::ofColor_",3,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - result = (ofColor_< unsigned char > *)new ofColor_< unsigned char >(arg1,arg2,arg3); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_Color__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; - ofColor_< unsigned char > *result = 0 ; SWIG_check_num_args("ofColor_< unsigned char >::ofColor_",2,2) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::ofColor_",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::ofColor_",2,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); result = (ofColor_< unsigned char > *)new ofColor_< unsigned char >(arg1,arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_Color__SWIG_4(lua_State* L) { int SWIG_arg = 0; float arg1 ; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::ofColor_",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::ofColor_",1,"float"); arg1 = (float)lua_tonumber(L, 1); - result = (ofColor_< unsigned char > *)new ofColor_< unsigned char >(arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_Color__SWIG_5(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *arg1 = 0 ; float arg2 ; - ofColor_< unsigned char > *result = 0 ; SWIG_check_num_args("ofColor_< unsigned char >::ofColor_",2,2) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::ofColor_",1,"ofColor_< unsigned char > const &"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::ofColor_",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("new_Color",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } arg2 = (float)lua_tonumber(L, 2); - result = (ofColor_< unsigned char > *)new ofColor_< unsigned char >((ofColor_< unsigned char > const &)*arg1,arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_Color(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_Color__SWIG_0(L);} if (argc == 1) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { - return _wrap_new_Color__SWIG_4(L);} } if (argc == 2) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_new_Color__SWIG_5(L);} } } if (argc == 2) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_new_Color__SWIG_3(L);} } } if (argc == 3) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_new_Color__SWIG_2(L);} } } } if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_new_Color__SWIG_1(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_Color'\n" " Possible C/C++ prototypes are:\n" - " ofColor_< unsigned char >::ofColor_()\n" " ofColor_< unsigned char >::ofColor_(float,float,float,float)\n" - " ofColor_< unsigned char >::ofColor_(float,float,float)\n" " ofColor_< unsigned char >::ofColor_(float,float)\n" - " ofColor_< unsigned char >::ofColor_(float)\n" - " ofColor_< unsigned char >::ofColor_(ofColor_< unsigned char > const &,float)\n"); lua_error(L);return 0; } -static int _wrap_Color_fromHsb__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - ofColor_< unsigned char > result; SWIG_check_num_args("ofColor_< unsigned char >::fromHsb",4,4) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::fromHsb",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::fromHsb",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< unsigned char >::fromHsb",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofColor_< unsigned char >::fromHsb",4,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - result = ofColor_< unsigned char >::SWIGTEMPLATEDISAMBIGUATOR fromHsb(arg1,arg2,arg3,arg4); { - ofColor_< unsigned char > * resultptr = new ofColor_< unsigned char >((const ofColor_< unsigned char > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_fromHsb__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; - ofColor_< unsigned char > result; SWIG_check_num_args("ofColor_< unsigned char >::fromHsb",3,3) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::fromHsb",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::fromHsb",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< unsigned char >::fromHsb",3,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - result = ofColor_< unsigned char >::SWIGTEMPLATEDISAMBIGUATOR fromHsb(arg1,arg2,arg3); { - ofColor_< unsigned char > * resultptr = new ofColor_< unsigned char >((const ofColor_< unsigned char > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_fromHsb(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Color_fromHsb__SWIG_1(L);} } } } if (argc == 4) { int _v; - { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Color_fromHsb__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Color_fromHsb'\n" " Possible C/C++ prototypes are:\n" - " ofColor_< unsigned char >::fromHsb(float,float,float,float)\n" - " ofColor_< unsigned char >::fromHsb(float,float,float)\n"); lua_error(L);return 0; } -static int _wrap_Color_fromHex__SWIG_0(lua_State* L) { int SWIG_arg = 0; int arg1 ; float arg2 ; - ofColor_< unsigned char > result; SWIG_check_num_args("ofColor_< unsigned char >::fromHex",2,2) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::fromHex",1,"int"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::fromHex",2,"float"); arg1 = (int)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); result = ofColor_< unsigned char >::SWIGTEMPLATEDISAMBIGUATOR fromHex(arg1,arg2); { - ofColor_< unsigned char > * resultptr = new ofColor_< unsigned char >((const ofColor_< unsigned char > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_fromHex__SWIG_1(lua_State* L) { int SWIG_arg = 0; int arg1 ; ofColor_< unsigned char > result; - SWIG_check_num_args("ofColor_< unsigned char >::fromHex",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::fromHex",1,"int"); arg1 = (int)lua_tonumber(L, 1); - result = ofColor_< unsigned char >::SWIGTEMPLATEDISAMBIGUATOR fromHex(arg1); { - ofColor_< unsigned char > * resultptr = new ofColor_< unsigned char >((const ofColor_< unsigned char > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_fromHex(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_Color_fromHex__SWIG_1(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Color_fromHex__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Color_fromHex'\n" " Possible C/C++ prototypes are:\n" - " ofColor_< unsigned char >::fromHex(int,float)\n" " ofColor_< unsigned char >::fromHex(int)\n"); - lua_error(L);return 0; } -static int _wrap_Color_set__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; float arg2 ; float arg3 ; float arg4 ; float arg5 ; - SWIG_check_num_args("ofColor_< unsigned char >::set",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::set",1,"ofColor_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< unsigned char >::set",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofColor_< unsigned char >::set",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofColor_< unsigned char >::set",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_set",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - (arg1)->set(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_set__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; float arg2 ; float arg3 ; float arg4 ; - SWIG_check_num_args("ofColor_< unsigned char >::set",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::set",1,"ofColor_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< unsigned char >::set",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofColor_< unsigned char >::set",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_set",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); (arg1)->set(arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_set__SWIG_2(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofColor_< unsigned char >::set",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::set",1,"ofColor_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< unsigned char >::set",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_set",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->set(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Color_set__SWIG_3(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; float arg2 ; - SWIG_check_num_args("ofColor_< unsigned char >::set",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::set",1,"ofColor_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::set",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_set",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } arg2 = (float)lua_tonumber(L, 2); (arg1)->set(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_set__SWIG_4(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; ofColor_< unsigned char > *arg2 = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::set",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::set",1,"ofColor_< unsigned char > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::set",2,"ofColor_< unsigned char > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_set",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_set",2,SWIGTYPE_p_ofColor_T_unsigned_char_t); } (arg1)->set((ofColor_< unsigned char > const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_set(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 2) { int _v; - { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Color_set__SWIG_4(L);} } } if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Color_set__SWIG_3(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_Color_set__SWIG_2(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Color_set__SWIG_1(L);} } } } } - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Color_set__SWIG_0(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Color_set'\n" " Possible C/C++ prototypes are:\n" - " ofColor_< unsigned char >::set(float,float,float,float)\n" " ofColor_< unsigned char >::set(float,float,float)\n" - " ofColor_< unsigned char >::set(float,float)\n" " ofColor_< unsigned char >::set(float)\n" - " ofColor_< unsigned char >::set(ofColor_< unsigned char > const &)\n"); lua_error(L);return 0; } -static int _wrap_Color_setHex__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; int arg2 ; float arg3 ; - SWIG_check_num_args("ofColor_< unsigned char >::setHex",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::setHex",1,"ofColor_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::setHex",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< unsigned char >::setHex",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_setHex",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->setHex(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Color_setHex__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; int arg2 ; - SWIG_check_num_args("ofColor_< unsigned char >::setHex",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::setHex",1,"ofColor_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::setHex",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_setHex",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->setHex(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_setHex(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { int _v; - { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Color_setHex__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_Color_setHex__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Color_setHex'\n" " Possible C/C++ prototypes are:\n" - " ofColor_< unsigned char >::setHex(int,float)\n" " ofColor_< unsigned char >::setHex(int)\n"); lua_error(L);return 0; } -static int _wrap_Color_setHue(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; float arg2 ; - SWIG_check_num_args("ofColor_< unsigned char >::setHue",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::setHue",1,"ofColor_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::setHue",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_setHue",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setHue(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_setHueAngle(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; float arg2 ; - SWIG_check_num_args("ofColor_< unsigned char >::setHueAngle",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::setHueAngle",1,"ofColor_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::setHueAngle",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_setHueAngle",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setHueAngle(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_setSaturation(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; float arg2 ; - SWIG_check_num_args("ofColor_< unsigned char >::setSaturation",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::setSaturation",1,"ofColor_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::setSaturation",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_setSaturation",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setSaturation(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_setBrightness(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; float arg2 ; - SWIG_check_num_args("ofColor_< unsigned char >::setBrightness",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::setBrightness",1,"ofColor_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::setBrightness",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_setBrightness",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setBrightness(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_setHsb__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; float arg2 ; float arg3 ; float arg4 ; float arg5 ; - SWIG_check_num_args("ofColor_< unsigned char >::setHsb",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::setHsb",1,"ofColor_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::setHsb",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< unsigned char >::setHsb",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofColor_< unsigned char >::setHsb",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofColor_< unsigned char >::setHsb",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_setHsb",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - (arg1)->setHsb(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_setHsb__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; float arg2 ; float arg3 ; float arg4 ; - SWIG_check_num_args("ofColor_< unsigned char >::setHsb",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::setHsb",1,"ofColor_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::setHsb",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< unsigned char >::setHsb",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofColor_< unsigned char >::setHsb",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_setHsb",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); (arg1)->setHsb(arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_setHsb(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 4) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Color_setHsb__SWIG_1(L);} } } } } - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Color_setHsb__SWIG_0(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Color_setHsb'\n" " Possible C/C++ prototypes are:\n" - " ofColor_< unsigned char >::setHsb(float,float,float,float)\n" - " ofColor_< unsigned char >::setHsb(float,float,float)\n"); lua_error(L);return 0; } -static int _wrap_Color_clamp(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::clamp",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::clamp",1,"ofColor_< unsigned char > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_clamp",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - result = (ofColor_< unsigned char > *) &(arg1)->clamp(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_invert(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::invert",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::invert",1,"ofColor_< unsigned char > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_invert",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - result = (ofColor_< unsigned char > *) &(arg1)->invert(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_normalize(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::normalize",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::normalize",1,"ofColor_< unsigned char > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_normalize",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - result = (ofColor_< unsigned char > *) &(arg1)->normalize(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_lerp(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; ofColor_< unsigned char > *arg2 = 0 ; float arg3 ; - ofColor_< unsigned char > *result = 0 ; SWIG_check_num_args("ofColor_< unsigned char >::lerp",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::lerp",1,"ofColor_< unsigned char > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::lerp",2,"ofColor_< unsigned char > const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< unsigned char >::lerp",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_lerp",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_lerp",2,SWIGTYPE_p_ofColor_T_unsigned_char_t); } arg3 = (float)lua_tonumber(L, 3); - result = (ofColor_< unsigned char > *) &(arg1)->lerp((ofColor_< unsigned char > const &)*arg2,arg3); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_getClamped(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; ofColor_< unsigned char > result; - SWIG_check_num_args("ofColor_< unsigned char >::getClamped",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::getClamped",1,"ofColor_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_getClamped",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - result = ((ofColor_< unsigned char > const *)arg1)->getClamped(); { - ofColor_< unsigned char > * resultptr = new ofColor_< unsigned char >((const ofColor_< unsigned char > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_getInverted(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; ofColor_< unsigned char > result; - SWIG_check_num_args("ofColor_< unsigned char >::getInverted",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::getInverted",1,"ofColor_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_getInverted",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - result = ((ofColor_< unsigned char > const *)arg1)->getInverted(); { - ofColor_< unsigned char > * resultptr = new ofColor_< unsigned char >((const ofColor_< unsigned char > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_getNormalized(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; ofColor_< unsigned char > result; - SWIG_check_num_args("ofColor_< unsigned char >::getNormalized",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::getNormalized",1,"ofColor_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_getNormalized",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - result = ((ofColor_< unsigned char > const *)arg1)->getNormalized(); { - ofColor_< unsigned char > * resultptr = new ofColor_< unsigned char >((const ofColor_< unsigned char > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_getLerped(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; ofColor_< unsigned char > *arg2 = 0 ; float arg3 ; - ofColor_< unsigned char > result; SWIG_check_num_args("ofColor_< unsigned char >::getLerped",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::getLerped",1,"ofColor_< unsigned char > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::getLerped",2,"ofColor_< unsigned char > const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< unsigned char >::getLerped",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_getLerped",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_getLerped",2,SWIGTYPE_p_ofColor_T_unsigned_char_t); } arg3 = (float)lua_tonumber(L, 3); - result = ((ofColor_< unsigned char > const *)arg1)->getLerped((ofColor_< unsigned char > const &)*arg2,arg3); { - ofColor_< unsigned char > * resultptr = new ofColor_< unsigned char >((const ofColor_< unsigned char > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_getHex(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; int result; - SWIG_check_num_args("ofColor_< unsigned char >::getHex",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::getHex",1,"ofColor_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_getHex",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - result = (int)((ofColor_< unsigned char > const *)arg1)->getHex(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_getHue(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; float result; - SWIG_check_num_args("ofColor_< unsigned char >::getHue",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::getHue",1,"ofColor_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_getHue",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - result = (float)((ofColor_< unsigned char > const *)arg1)->getHue(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_getHueAngle(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; float result; - SWIG_check_num_args("ofColor_< unsigned char >::getHueAngle",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::getHueAngle",1,"ofColor_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_getHueAngle",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - result = (float)((ofColor_< unsigned char > const *)arg1)->getHueAngle(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_getSaturation(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; float result; - SWIG_check_num_args("ofColor_< unsigned char >::getSaturation",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::getSaturation",1,"ofColor_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_getSaturation",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - result = (float)((ofColor_< unsigned char > const *)arg1)->getSaturation(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_getBrightness(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; float result; - SWIG_check_num_args("ofColor_< unsigned char >::getBrightness",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::getBrightness",1,"ofColor_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_getBrightness",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - result = (float)((ofColor_< unsigned char > const *)arg1)->getBrightness(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_getLightness(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; float result; - SWIG_check_num_args("ofColor_< unsigned char >::getLightness",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::getLightness",1,"ofColor_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_getLightness",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - result = (float)((ofColor_< unsigned char > const *)arg1)->getLightness(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_getHsb(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; float *arg2 = 0 ; float *arg3 = 0 ; float *arg4 = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::getHsb",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::getHsb",1,"ofColor_< unsigned char > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::getHsb",2,"float &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofColor_< unsigned char >::getHsb",3,"float &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofColor_< unsigned char >::getHsb",4,"float &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_getHsb",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_float,0))){ SWIG_fail_ptr("Color_getHsb",2,SWIGTYPE_p_float); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_float,0))){ SWIG_fail_ptr("Color_getHsb",3,SWIGTYPE_p_float); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_float,0))){ SWIG_fail_ptr("Color_getHsb",4,SWIGTYPE_p_float); } - ((ofColor_< unsigned char > const *)arg1)->getHsb(*arg2,*arg3,*arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Color_limit(lua_State* L) { int SWIG_arg = 0; float result; - SWIG_check_num_args("ofColor_< unsigned char >::limit",0,0) - result = (float)ofColor_< unsigned char >::SWIGTEMPLATEDISAMBIGUATOR limit(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color___eq(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; ofColor_< unsigned char > *arg2 = 0 ; bool result; - SWIG_check_num_args("ofColor_< unsigned char >::operator ==",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::operator ==",1,"ofColor_< unsigned char > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::operator ==",2,"ofColor_< unsigned char > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color___eq",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color___eq",2,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - result = (bool)((ofColor_< unsigned char > const *)arg1)->operator ==((ofColor_< unsigned char > const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color___add__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; ofColor_< unsigned char > *arg2 = 0 ; - ofColor_< unsigned char > result; SWIG_check_num_args("ofColor_< unsigned char >::operator +",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::operator +",1,"ofColor_< unsigned char > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::operator +",2,"ofColor_< unsigned char > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color___add",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color___add",2,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - result = ((ofColor_< unsigned char > const *)arg1)->operator +((ofColor_< unsigned char > const &)*arg2); { - ofColor_< unsigned char > * resultptr = new ofColor_< unsigned char >((const ofColor_< unsigned char > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color___add__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; float *arg2 = 0 ; float temp2 ; - ofColor_< unsigned char > result; SWIG_check_num_args("ofColor_< unsigned char >::operator +",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::operator +",1,"ofColor_< unsigned char > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::operator +",2,"float const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color___add",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } temp2=(float)lua_tonumber(L,2); arg2=&temp2; - result = ((ofColor_< unsigned char > const *)arg1)->operator +((float const &)*arg2); { - ofColor_< unsigned char > * resultptr = new ofColor_< unsigned char >((const ofColor_< unsigned char > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color___add(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Color___add__SWIG_0(L);} } } if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Color___add__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Color___add'\n" " Possible C/C++ prototypes are:\n" - " ofColor_< unsigned char >::operator +(ofColor_< unsigned char > const &) const\n" - " ofColor_< unsigned char >::operator +(float const &) const\n"); lua_error(L);return 0; } -static int _wrap_Color___sub__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; ofColor_< unsigned char > *arg2 = 0 ; - ofColor_< unsigned char > result; SWIG_check_num_args("ofColor_< unsigned char >::operator -",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::operator -",1,"ofColor_< unsigned char > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::operator -",2,"ofColor_< unsigned char > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color___sub",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color___sub",2,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - result = ((ofColor_< unsigned char > const *)arg1)->operator -((ofColor_< unsigned char > const &)*arg2); { - ofColor_< unsigned char > * resultptr = new ofColor_< unsigned char >((const ofColor_< unsigned char > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color___sub__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; float *arg2 = 0 ; float temp2 ; - ofColor_< unsigned char > result; SWIG_check_num_args("ofColor_< unsigned char >::operator -",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::operator -",1,"ofColor_< unsigned char > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::operator -",2,"float const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color___sub",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } temp2=(float)lua_tonumber(L,2); arg2=&temp2; - result = ((ofColor_< unsigned char > const *)arg1)->operator -((float const &)*arg2); { - ofColor_< unsigned char > * resultptr = new ofColor_< unsigned char >((const ofColor_< unsigned char > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color___sub(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Color___sub__SWIG_0(L);} } } if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Color___sub__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Color___sub'\n" " Possible C/C++ prototypes are:\n" - " ofColor_< unsigned char >::operator -(ofColor_< unsigned char > const &) const\n" - " ofColor_< unsigned char >::operator -(float const &) const\n"); lua_error(L);return 0; } -static int _wrap_Color___mul__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; ofColor_< unsigned char > *arg2 = 0 ; - ofColor_< unsigned char > result; SWIG_check_num_args("ofColor_< unsigned char >::operator *",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::operator *",1,"ofColor_< unsigned char > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::operator *",2,"ofColor_< unsigned char > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color___mul",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color___mul",2,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - result = ((ofColor_< unsigned char > const *)arg1)->operator *((ofColor_< unsigned char > const &)*arg2); { - ofColor_< unsigned char > * resultptr = new ofColor_< unsigned char >((const ofColor_< unsigned char > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color___mul__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; float *arg2 = 0 ; float temp2 ; - ofColor_< unsigned char > result; SWIG_check_num_args("ofColor_< unsigned char >::operator *",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::operator *",1,"ofColor_< unsigned char > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::operator *",2,"float const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color___mul",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } temp2=(float)lua_tonumber(L,2); arg2=&temp2; - result = ((ofColor_< unsigned char > const *)arg1)->operator *((float const &)*arg2); { - ofColor_< unsigned char > * resultptr = new ofColor_< unsigned char >((const ofColor_< unsigned char > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color___mul(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Color___mul__SWIG_0(L);} } } if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Color___mul__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Color___mul'\n" " Possible C/C++ prototypes are:\n" - " ofColor_< unsigned char >::operator *(ofColor_< unsigned char > const &) const\n" - " ofColor_< unsigned char >::operator *(float const &) const\n"); lua_error(L);return 0; } -static int _wrap_Color___div__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; ofColor_< unsigned char > *arg2 = 0 ; - ofColor_< unsigned char > result; SWIG_check_num_args("ofColor_< unsigned char >::operator /",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::operator /",1,"ofColor_< unsigned char > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::operator /",2,"ofColor_< unsigned char > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color___div",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color___div",2,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - result = ((ofColor_< unsigned char > const *)arg1)->operator /((ofColor_< unsigned char > const &)*arg2); { - ofColor_< unsigned char > * resultptr = new ofColor_< unsigned char >((const ofColor_< unsigned char > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color___div__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; float *arg2 = 0 ; float temp2 ; - ofColor_< unsigned char > result; SWIG_check_num_args("ofColor_< unsigned char >::operator /",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::operator /",1,"ofColor_< unsigned char > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::operator /",2,"float const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color___div",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } temp2=(float)lua_tonumber(L,2); arg2=&temp2; - result = ((ofColor_< unsigned char > const *)arg1)->operator /((float const &)*arg2); { - ofColor_< unsigned char > * resultptr = new ofColor_< unsigned char >((const ofColor_< unsigned char > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color___div(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Color___div__SWIG_0(L);} } } if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Color___div__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Color___div'\n" " Possible C/C++ prototypes are:\n" - " ofColor_< unsigned char >::operator /(ofColor_< unsigned char > const &) const\n" - " ofColor_< unsigned char >::operator /(float const &) const\n"); lua_error(L);return 0; } -static int _wrap_Color_white_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::white",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::white; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_gray_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::gray",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::gray; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_black_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::black",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::black; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_red_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::red",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::red; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_green_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::green",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::green; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_blue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::blue",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::blue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_cyan_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::cyan",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::cyan; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_magenta_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::magenta",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::magenta; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_yellow_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::yellow",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::yellow; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_aliceBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::aliceBlue",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::aliceBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_antiqueWhite_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::antiqueWhite",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::antiqueWhite; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_aqua_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::aqua",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::aqua; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_aquamarine_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::aquamarine",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::aquamarine; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_azure_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::azure",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::azure; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_beige_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::beige",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::beige; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_bisque_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::bisque",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::bisque; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_blanchedAlmond_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::blanchedAlmond",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::blanchedAlmond; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_blueViolet_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::blueViolet",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::blueViolet; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_brown_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::brown",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::brown; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_burlyWood_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::burlyWood",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::burlyWood; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_cadetBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::cadetBlue",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::cadetBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_chartreuse_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::chartreuse",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::chartreuse; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_chocolate_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::chocolate",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::chocolate; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_coral_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::coral",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::coral; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_cornflowerBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::cornflowerBlue",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::cornflowerBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_cornsilk_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::cornsilk",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::cornsilk; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_crimson_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::crimson",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::crimson; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_darkBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::darkBlue",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::darkBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_darkCyan_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::darkCyan",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::darkCyan; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_darkGoldenRod_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::darkGoldenRod",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::darkGoldenRod; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_darkGray_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::darkGray",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::darkGray; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_darkGrey_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::darkGrey",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::darkGrey; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_darkGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::darkGreen",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::darkGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_darkKhaki_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::darkKhaki",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::darkKhaki; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_darkMagenta_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::darkMagenta",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::darkMagenta; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_darkOliveGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::darkOliveGreen",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::darkOliveGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_darkorange_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::darkorange",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::darkorange; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_darkOrchid_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::darkOrchid",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::darkOrchid; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_darkRed_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::darkRed",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::darkRed; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_darkSalmon_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::darkSalmon",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::darkSalmon; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_darkSeaGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::darkSeaGreen",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::darkSeaGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_darkSlateBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::darkSlateBlue",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::darkSlateBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_darkSlateGray_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::darkSlateGray",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::darkSlateGray; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_darkSlateGrey_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::darkSlateGrey",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::darkSlateGrey; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_darkTurquoise_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::darkTurquoise",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::darkTurquoise; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_darkViolet_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::darkViolet",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::darkViolet; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_deepPink_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::deepPink",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::deepPink; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_deepSkyBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::deepSkyBlue",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::deepSkyBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_dimGray_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::dimGray",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::dimGray; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_dimGrey_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::dimGrey",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::dimGrey; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_dodgerBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::dodgerBlue",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::dodgerBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_fireBrick_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::fireBrick",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::fireBrick; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_floralWhite_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::floralWhite",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::floralWhite; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_forestGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::forestGreen",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::forestGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_fuchsia_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::fuchsia",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::fuchsia; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_gainsboro_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::gainsboro",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::gainsboro; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_ghostWhite_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::ghostWhite",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::ghostWhite; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_gold_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::gold",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::gold; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_goldenRod_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::goldenRod",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::goldenRod; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_grey_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::grey",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::grey; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_greenYellow_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::greenYellow",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::greenYellow; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_honeyDew_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::honeyDew",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::honeyDew; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_hotPink_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::hotPink",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::hotPink; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_indianRed_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::indianRed",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::indianRed; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_indigo_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::indigo",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::indigo; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_ivory_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::ivory",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::ivory; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_khaki_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::khaki",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::khaki; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_lavender_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::lavender",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::lavender; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_lavenderBlush_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::lavenderBlush",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::lavenderBlush; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_lawnGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::lawnGreen",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::lawnGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_lemonChiffon_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::lemonChiffon",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::lemonChiffon; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_lightBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::lightBlue",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::lightBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_lightCoral_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::lightCoral",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::lightCoral; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_lightCyan_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::lightCyan",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::lightCyan; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_lightGoldenRodYellow_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::lightGoldenRodYellow",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::lightGoldenRodYellow; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_lightGray_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::lightGray",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::lightGray; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_lightGrey_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::lightGrey",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::lightGrey; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_lightGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::lightGreen",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::lightGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_lightPink_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::lightPink",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::lightPink; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_lightSalmon_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::lightSalmon",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::lightSalmon; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_lightSeaGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::lightSeaGreen",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::lightSeaGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_lightSkyBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::lightSkyBlue",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::lightSkyBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_lightSlateGray_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::lightSlateGray",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::lightSlateGray; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_lightSlateGrey_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::lightSlateGrey",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::lightSlateGrey; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_lightSteelBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::lightSteelBlue",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::lightSteelBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_lightYellow_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::lightYellow",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::lightYellow; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_lime_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::lime",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::lime; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_limeGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::limeGreen",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::limeGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_linen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::linen",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::linen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_maroon_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::maroon",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::maroon; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_mediumAquaMarine_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::mediumAquaMarine",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::mediumAquaMarine; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_mediumBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::mediumBlue",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::mediumBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_mediumOrchid_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::mediumOrchid",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::mediumOrchid; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_mediumPurple_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::mediumPurple",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::mediumPurple; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_mediumSeaGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::mediumSeaGreen",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::mediumSeaGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_mediumSlateBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::mediumSlateBlue",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::mediumSlateBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_mediumSpringGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::mediumSpringGreen",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::mediumSpringGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_mediumTurquoise_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::mediumTurquoise",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::mediumTurquoise; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_mediumVioletRed_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::mediumVioletRed",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::mediumVioletRed; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_midnightBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::midnightBlue",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::midnightBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_mintCream_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::mintCream",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::mintCream; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_mistyRose_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::mistyRose",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::mistyRose; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_moccasin_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::moccasin",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::moccasin; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_navajoWhite_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::navajoWhite",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::navajoWhite; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_navy_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::navy",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::navy; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_oldLace_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::oldLace",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::oldLace; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_olive_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::olive",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::olive; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_oliveDrab_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::oliveDrab",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::oliveDrab; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_orange_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::orange",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::orange; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_orangeRed_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::orangeRed",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::orangeRed; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_orchid_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::orchid",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::orchid; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_paleGoldenRod_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::paleGoldenRod",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::paleGoldenRod; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_paleGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::paleGreen",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::paleGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_paleTurquoise_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::paleTurquoise",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::paleTurquoise; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_paleVioletRed_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::paleVioletRed",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::paleVioletRed; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_papayaWhip_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::papayaWhip",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::papayaWhip; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_peachPuff_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::peachPuff",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::peachPuff; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_peru_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::peru",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::peru; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_pink_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::pink",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::pink; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_plum_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::plum",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::plum; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_powderBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::powderBlue",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::powderBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_purple_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::purple",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::purple; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_rosyBrown_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::rosyBrown",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::rosyBrown; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_royalBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::royalBlue",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::royalBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_saddleBrown_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::saddleBrown",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::saddleBrown; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_salmon_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::salmon",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::salmon; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_sandyBrown_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::sandyBrown",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::sandyBrown; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_seaGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::seaGreen",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::seaGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_seaShell_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::seaShell",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::seaShell; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_sienna_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::sienna",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::sienna; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_silver_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::silver",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::silver; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_skyBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::skyBlue",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::skyBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_slateBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::slateBlue",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::slateBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_slateGray_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::slateGray",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::slateGray; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_slateGrey_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::slateGrey",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::slateGrey; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_snow_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::snow",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::snow; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_springGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::springGreen",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::springGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_steelBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::steelBlue",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::steelBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_blueSteel_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::blueSteel",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::blueSteel; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_tan_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::tan",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::tan; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_teal_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::teal",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::teal; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_thistle_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::thistle",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::thistle; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_tomato_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::tomato",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::tomato; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_turquoise_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::turquoise",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::turquoise; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_violet_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::violet",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::violet; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_wheat_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::wheat",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::wheat; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_whiteSmoke_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::whiteSmoke",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::whiteSmoke; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_yellowGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::yellowGreen",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::yellowGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_getR(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; unsigned char result; - SWIG_check_num_args("ofColor_< unsigned char >::getR",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::getR",1,"ofColor_< unsigned char > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_getR",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - result = (unsigned char)ofColor__Sl_unsigned_SS_char_Sg__getR(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_getG(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; unsigned char result; - SWIG_check_num_args("ofColor_< unsigned char >::getG",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::getG",1,"ofColor_< unsigned char > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_getG",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - result = (unsigned char)ofColor__Sl_unsigned_SS_char_Sg__getG(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_getB(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; unsigned char result; - SWIG_check_num_args("ofColor_< unsigned char >::getB",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::getB",1,"ofColor_< unsigned char > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_getB",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - result = (unsigned char)ofColor__Sl_unsigned_SS_char_Sg__getB(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_getA(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; unsigned char result; - SWIG_check_num_args("ofColor_< unsigned char >::getA",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::getA",1,"ofColor_< unsigned char > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_getA",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - result = (unsigned char)ofColor__Sl_unsigned_SS_char_Sg__getA(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_setR(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; unsigned char arg2 ; - SWIG_check_num_args("ofColor_< unsigned char >::setR",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::setR",1,"ofColor_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::setR",2,"unsigned char"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_setR",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned char)lua_tonumber(L, 2); - ofColor__Sl_unsigned_SS_char_Sg__setR(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_setG(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; unsigned char arg2 ; - SWIG_check_num_args("ofColor_< unsigned char >::setG",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::setG",1,"ofColor_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::setG",2,"unsigned char"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_setG",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned char)lua_tonumber(L, 2); - ofColor__Sl_unsigned_SS_char_Sg__setG(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_setB(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; unsigned char arg2 ; - SWIG_check_num_args("ofColor_< unsigned char >::setB",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::setB",1,"ofColor_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::setB",2,"unsigned char"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_setB",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned char)lua_tonumber(L, 2); - ofColor__Sl_unsigned_SS_char_Sg__setB(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_setA(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; unsigned char arg2 ; - SWIG_check_num_args("ofColor_< unsigned char >::setA",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::setA",1,"ofColor_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::setA",2,"unsigned char"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_setA",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned char)lua_tonumber(L, 2); - ofColor__Sl_unsigned_SS_char_Sg__setA(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color___tostring(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; char *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::__str__",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::__str__",1,"ofColor_< unsigned char > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color___tostring",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - result = (char *)ofColor__Sl_unsigned_SS_char_Sg____str__(arg1); lua_pushstring(L,(const char *)result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_r_set(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; unsigned char arg2 ; - SWIG_check_num_args("ofColor_< unsigned char >::r",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::r",1,"ofColor_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::r",2,"unsigned char"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_r_set",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned char)lua_tonumber(L, 2); - ofColor__Sl_unsigned_SS_char_Sg__r_set(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_r_get(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; unsigned char result; - SWIG_check_num_args("ofColor_< unsigned char >::r",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::r",1,"ofColor_< unsigned char > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_r_get",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - result = (unsigned char)ofColor__Sl_unsigned_SS_char_Sg__r_get(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_g_set(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; unsigned char arg2 ; - SWIG_check_num_args("ofColor_< unsigned char >::g",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::g",1,"ofColor_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::g",2,"unsigned char"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_g_set",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned char)lua_tonumber(L, 2); - ofColor__Sl_unsigned_SS_char_Sg__g_set(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_g_get(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; unsigned char result; - SWIG_check_num_args("ofColor_< unsigned char >::g",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::g",1,"ofColor_< unsigned char > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_g_get",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - result = (unsigned char)ofColor__Sl_unsigned_SS_char_Sg__g_get(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_b_set(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; unsigned char arg2 ; - SWIG_check_num_args("ofColor_< unsigned char >::b",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::b",1,"ofColor_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::b",2,"unsigned char"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_b_set",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned char)lua_tonumber(L, 2); - ofColor__Sl_unsigned_SS_char_Sg__b_set(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_b_get(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; unsigned char result; - SWIG_check_num_args("ofColor_< unsigned char >::b",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::b",1,"ofColor_< unsigned char > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_b_get",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - result = (unsigned char)ofColor__Sl_unsigned_SS_char_Sg__b_get(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_a_set(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; unsigned char arg2 ; - SWIG_check_num_args("ofColor_< unsigned char >::a",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::a",1,"ofColor_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::a",2,"unsigned char"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_a_set",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned char)lua_tonumber(L, 2); - ofColor__Sl_unsigned_SS_char_Sg__a_set(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_a_get(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; unsigned char result; - SWIG_check_num_args("ofColor_< unsigned char >::a",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::a",1,"ofColor_< unsigned char > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_a_get",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - result = (unsigned char)ofColor__Sl_unsigned_SS_char_Sg__a_get(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_Color(void *obj) { -ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) obj; -delete arg1; -} -static int _proxy__wrap_new_Color(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_Color); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_Color_attributes[] = { - { "r", _wrap_Color_r_get, _wrap_Color_r_set }, - { "g", _wrap_Color_g_get, _wrap_Color_g_set }, - { "b", _wrap_Color_b_get, _wrap_Color_b_set }, - { "a", _wrap_Color_a_get, _wrap_Color_a_set }, - {0,0,0} -}; -static swig_lua_method swig_Color_methods[]= { - { "set", _wrap_Color_set}, - { "setHex", _wrap_Color_setHex}, - { "setHue", _wrap_Color_setHue}, - { "setHueAngle", _wrap_Color_setHueAngle}, - { "setSaturation", _wrap_Color_setSaturation}, - { "setBrightness", _wrap_Color_setBrightness}, - { "setHsb", _wrap_Color_setHsb}, - { "clamp", _wrap_Color_clamp}, - { "invert", _wrap_Color_invert}, - { "normalize", _wrap_Color_normalize}, - { "lerp", _wrap_Color_lerp}, - { "getClamped", _wrap_Color_getClamped}, - { "getInverted", _wrap_Color_getInverted}, - { "getNormalized", _wrap_Color_getNormalized}, - { "getLerped", _wrap_Color_getLerped}, - { "getHex", _wrap_Color_getHex}, - { "getHue", _wrap_Color_getHue}, - { "getHueAngle", _wrap_Color_getHueAngle}, - { "getSaturation", _wrap_Color_getSaturation}, - { "getBrightness", _wrap_Color_getBrightness}, - { "getLightness", _wrap_Color_getLightness}, - { "getHsb", _wrap_Color_getHsb}, - { "__eq", _wrap_Color___eq}, - { "__add", _wrap_Color___add}, - { "__sub", _wrap_Color___sub}, - { "__mul", _wrap_Color___mul}, - { "__div", _wrap_Color___div}, - { "getR", _wrap_Color_getR}, - { "getG", _wrap_Color_getG}, - { "getB", _wrap_Color_getB}, - { "getA", _wrap_Color_getA}, - { "setR", _wrap_Color_setR}, - { "setG", _wrap_Color_setG}, - { "setB", _wrap_Color_setB}, - { "setA", _wrap_Color_setA}, - { "__tostring", _wrap_Color___tostring}, - {0,0} -}; -static swig_lua_method swig_Color_meta[] = { - { "__eq", _wrap_Color___eq}, - { "__add", _wrap_Color___add}, - { "__sub", _wrap_Color___sub}, - { "__mul", _wrap_Color___mul}, - { "__div", _wrap_Color___div}, - { "__tostring", _wrap_Color___tostring}, - {0,0} -}; - -static swig_lua_attribute swig_Color_Sf_SwigStatic_attributes[] = { - { "white", _wrap_Color_white_get, SWIG_Lua_set_immutable }, - { "gray", _wrap_Color_gray_get, SWIG_Lua_set_immutable }, - { "black", _wrap_Color_black_get, SWIG_Lua_set_immutable }, - { "red", _wrap_Color_red_get, SWIG_Lua_set_immutable }, - { "green", _wrap_Color_green_get, SWIG_Lua_set_immutable }, - { "blue", _wrap_Color_blue_get, SWIG_Lua_set_immutable }, - { "cyan", _wrap_Color_cyan_get, SWIG_Lua_set_immutable }, - { "magenta", _wrap_Color_magenta_get, SWIG_Lua_set_immutable }, - { "yellow", _wrap_Color_yellow_get, SWIG_Lua_set_immutable }, - { "aliceBlue", _wrap_Color_aliceBlue_get, SWIG_Lua_set_immutable }, - { "antiqueWhite", _wrap_Color_antiqueWhite_get, SWIG_Lua_set_immutable }, - { "aqua", _wrap_Color_aqua_get, SWIG_Lua_set_immutable }, - { "aquamarine", _wrap_Color_aquamarine_get, SWIG_Lua_set_immutable }, - { "azure", _wrap_Color_azure_get, SWIG_Lua_set_immutable }, - { "beige", _wrap_Color_beige_get, SWIG_Lua_set_immutable }, - { "bisque", _wrap_Color_bisque_get, SWIG_Lua_set_immutable }, - { "blanchedAlmond", _wrap_Color_blanchedAlmond_get, SWIG_Lua_set_immutable }, - { "blueViolet", _wrap_Color_blueViolet_get, SWIG_Lua_set_immutable }, - { "brown", _wrap_Color_brown_get, SWIG_Lua_set_immutable }, - { "burlyWood", _wrap_Color_burlyWood_get, SWIG_Lua_set_immutable }, - { "cadetBlue", _wrap_Color_cadetBlue_get, SWIG_Lua_set_immutable }, - { "chartreuse", _wrap_Color_chartreuse_get, SWIG_Lua_set_immutable }, - { "chocolate", _wrap_Color_chocolate_get, SWIG_Lua_set_immutable }, - { "coral", _wrap_Color_coral_get, SWIG_Lua_set_immutable }, - { "cornflowerBlue", _wrap_Color_cornflowerBlue_get, SWIG_Lua_set_immutable }, - { "cornsilk", _wrap_Color_cornsilk_get, SWIG_Lua_set_immutable }, - { "crimson", _wrap_Color_crimson_get, SWIG_Lua_set_immutable }, - { "darkBlue", _wrap_Color_darkBlue_get, SWIG_Lua_set_immutable }, - { "darkCyan", _wrap_Color_darkCyan_get, SWIG_Lua_set_immutable }, - { "darkGoldenRod", _wrap_Color_darkGoldenRod_get, SWIG_Lua_set_immutable }, - { "darkGray", _wrap_Color_darkGray_get, SWIG_Lua_set_immutable }, - { "darkGrey", _wrap_Color_darkGrey_get, SWIG_Lua_set_immutable }, - { "darkGreen", _wrap_Color_darkGreen_get, SWIG_Lua_set_immutable }, - { "darkKhaki", _wrap_Color_darkKhaki_get, SWIG_Lua_set_immutable }, - { "darkMagenta", _wrap_Color_darkMagenta_get, SWIG_Lua_set_immutable }, - { "darkOliveGreen", _wrap_Color_darkOliveGreen_get, SWIG_Lua_set_immutable }, - { "darkorange", _wrap_Color_darkorange_get, SWIG_Lua_set_immutable }, - { "darkOrchid", _wrap_Color_darkOrchid_get, SWIG_Lua_set_immutable }, - { "darkRed", _wrap_Color_darkRed_get, SWIG_Lua_set_immutable }, - { "darkSalmon", _wrap_Color_darkSalmon_get, SWIG_Lua_set_immutable }, - { "darkSeaGreen", _wrap_Color_darkSeaGreen_get, SWIG_Lua_set_immutable }, - { "darkSlateBlue", _wrap_Color_darkSlateBlue_get, SWIG_Lua_set_immutable }, - { "darkSlateGray", _wrap_Color_darkSlateGray_get, SWIG_Lua_set_immutable }, - { "darkSlateGrey", _wrap_Color_darkSlateGrey_get, SWIG_Lua_set_immutable }, - { "darkTurquoise", _wrap_Color_darkTurquoise_get, SWIG_Lua_set_immutable }, - { "darkViolet", _wrap_Color_darkViolet_get, SWIG_Lua_set_immutable }, - { "deepPink", _wrap_Color_deepPink_get, SWIG_Lua_set_immutable }, - { "deepSkyBlue", _wrap_Color_deepSkyBlue_get, SWIG_Lua_set_immutable }, - { "dimGray", _wrap_Color_dimGray_get, SWIG_Lua_set_immutable }, - { "dimGrey", _wrap_Color_dimGrey_get, SWIG_Lua_set_immutable }, - { "dodgerBlue", _wrap_Color_dodgerBlue_get, SWIG_Lua_set_immutable }, - { "fireBrick", _wrap_Color_fireBrick_get, SWIG_Lua_set_immutable }, - { "floralWhite", _wrap_Color_floralWhite_get, SWIG_Lua_set_immutable }, - { "forestGreen", _wrap_Color_forestGreen_get, SWIG_Lua_set_immutable }, - { "fuchsia", _wrap_Color_fuchsia_get, SWIG_Lua_set_immutable }, - { "gainsboro", _wrap_Color_gainsboro_get, SWIG_Lua_set_immutable }, - { "ghostWhite", _wrap_Color_ghostWhite_get, SWIG_Lua_set_immutable }, - { "gold", _wrap_Color_gold_get, SWIG_Lua_set_immutable }, - { "goldenRod", _wrap_Color_goldenRod_get, SWIG_Lua_set_immutable }, - { "grey", _wrap_Color_grey_get, SWIG_Lua_set_immutable }, - { "greenYellow", _wrap_Color_greenYellow_get, SWIG_Lua_set_immutable }, - { "honeyDew", _wrap_Color_honeyDew_get, SWIG_Lua_set_immutable }, - { "hotPink", _wrap_Color_hotPink_get, SWIG_Lua_set_immutable }, - { "indianRed", _wrap_Color_indianRed_get, SWIG_Lua_set_immutable }, - { "indigo", _wrap_Color_indigo_get, SWIG_Lua_set_immutable }, - { "ivory", _wrap_Color_ivory_get, SWIG_Lua_set_immutable }, - { "khaki", _wrap_Color_khaki_get, SWIG_Lua_set_immutable }, - { "lavender", _wrap_Color_lavender_get, SWIG_Lua_set_immutable }, - { "lavenderBlush", _wrap_Color_lavenderBlush_get, SWIG_Lua_set_immutable }, - { "lawnGreen", _wrap_Color_lawnGreen_get, SWIG_Lua_set_immutable }, - { "lemonChiffon", _wrap_Color_lemonChiffon_get, SWIG_Lua_set_immutable }, - { "lightBlue", _wrap_Color_lightBlue_get, SWIG_Lua_set_immutable }, - { "lightCoral", _wrap_Color_lightCoral_get, SWIG_Lua_set_immutable }, - { "lightCyan", _wrap_Color_lightCyan_get, SWIG_Lua_set_immutable }, - { "lightGoldenRodYellow", _wrap_Color_lightGoldenRodYellow_get, SWIG_Lua_set_immutable }, - { "lightGray", _wrap_Color_lightGray_get, SWIG_Lua_set_immutable }, - { "lightGrey", _wrap_Color_lightGrey_get, SWIG_Lua_set_immutable }, - { "lightGreen", _wrap_Color_lightGreen_get, SWIG_Lua_set_immutable }, - { "lightPink", _wrap_Color_lightPink_get, SWIG_Lua_set_immutable }, - { "lightSalmon", _wrap_Color_lightSalmon_get, SWIG_Lua_set_immutable }, - { "lightSeaGreen", _wrap_Color_lightSeaGreen_get, SWIG_Lua_set_immutable }, - { "lightSkyBlue", _wrap_Color_lightSkyBlue_get, SWIG_Lua_set_immutable }, - { "lightSlateGray", _wrap_Color_lightSlateGray_get, SWIG_Lua_set_immutable }, - { "lightSlateGrey", _wrap_Color_lightSlateGrey_get, SWIG_Lua_set_immutable }, - { "lightSteelBlue", _wrap_Color_lightSteelBlue_get, SWIG_Lua_set_immutable }, - { "lightYellow", _wrap_Color_lightYellow_get, SWIG_Lua_set_immutable }, - { "lime", _wrap_Color_lime_get, SWIG_Lua_set_immutable }, - { "limeGreen", _wrap_Color_limeGreen_get, SWIG_Lua_set_immutable }, - { "linen", _wrap_Color_linen_get, SWIG_Lua_set_immutable }, - { "maroon", _wrap_Color_maroon_get, SWIG_Lua_set_immutable }, - { "mediumAquaMarine", _wrap_Color_mediumAquaMarine_get, SWIG_Lua_set_immutable }, - { "mediumBlue", _wrap_Color_mediumBlue_get, SWIG_Lua_set_immutable }, - { "mediumOrchid", _wrap_Color_mediumOrchid_get, SWIG_Lua_set_immutable }, - { "mediumPurple", _wrap_Color_mediumPurple_get, SWIG_Lua_set_immutable }, - { "mediumSeaGreen", _wrap_Color_mediumSeaGreen_get, SWIG_Lua_set_immutable }, - { "mediumSlateBlue", _wrap_Color_mediumSlateBlue_get, SWIG_Lua_set_immutable }, - { "mediumSpringGreen", _wrap_Color_mediumSpringGreen_get, SWIG_Lua_set_immutable }, - { "mediumTurquoise", _wrap_Color_mediumTurquoise_get, SWIG_Lua_set_immutable }, - { "mediumVioletRed", _wrap_Color_mediumVioletRed_get, SWIG_Lua_set_immutable }, - { "midnightBlue", _wrap_Color_midnightBlue_get, SWIG_Lua_set_immutable }, - { "mintCream", _wrap_Color_mintCream_get, SWIG_Lua_set_immutable }, - { "mistyRose", _wrap_Color_mistyRose_get, SWIG_Lua_set_immutable }, - { "moccasin", _wrap_Color_moccasin_get, SWIG_Lua_set_immutable }, - { "navajoWhite", _wrap_Color_navajoWhite_get, SWIG_Lua_set_immutable }, - { "navy", _wrap_Color_navy_get, SWIG_Lua_set_immutable }, - { "oldLace", _wrap_Color_oldLace_get, SWIG_Lua_set_immutable }, - { "olive", _wrap_Color_olive_get, SWIG_Lua_set_immutable }, - { "oliveDrab", _wrap_Color_oliveDrab_get, SWIG_Lua_set_immutable }, - { "orange", _wrap_Color_orange_get, SWIG_Lua_set_immutable }, - { "orangeRed", _wrap_Color_orangeRed_get, SWIG_Lua_set_immutable }, - { "orchid", _wrap_Color_orchid_get, SWIG_Lua_set_immutable }, - { "paleGoldenRod", _wrap_Color_paleGoldenRod_get, SWIG_Lua_set_immutable }, - { "paleGreen", _wrap_Color_paleGreen_get, SWIG_Lua_set_immutable }, - { "paleTurquoise", _wrap_Color_paleTurquoise_get, SWIG_Lua_set_immutable }, - { "paleVioletRed", _wrap_Color_paleVioletRed_get, SWIG_Lua_set_immutable }, - { "papayaWhip", _wrap_Color_papayaWhip_get, SWIG_Lua_set_immutable }, - { "peachPuff", _wrap_Color_peachPuff_get, SWIG_Lua_set_immutable }, - { "peru", _wrap_Color_peru_get, SWIG_Lua_set_immutable }, - { "pink", _wrap_Color_pink_get, SWIG_Lua_set_immutable }, - { "plum", _wrap_Color_plum_get, SWIG_Lua_set_immutable }, - { "powderBlue", _wrap_Color_powderBlue_get, SWIG_Lua_set_immutable }, - { "purple", _wrap_Color_purple_get, SWIG_Lua_set_immutable }, - { "rosyBrown", _wrap_Color_rosyBrown_get, SWIG_Lua_set_immutable }, - { "royalBlue", _wrap_Color_royalBlue_get, SWIG_Lua_set_immutable }, - { "saddleBrown", _wrap_Color_saddleBrown_get, SWIG_Lua_set_immutable }, - { "salmon", _wrap_Color_salmon_get, SWIG_Lua_set_immutable }, - { "sandyBrown", _wrap_Color_sandyBrown_get, SWIG_Lua_set_immutable }, - { "seaGreen", _wrap_Color_seaGreen_get, SWIG_Lua_set_immutable }, - { "seaShell", _wrap_Color_seaShell_get, SWIG_Lua_set_immutable }, - { "sienna", _wrap_Color_sienna_get, SWIG_Lua_set_immutable }, - { "silver", _wrap_Color_silver_get, SWIG_Lua_set_immutable }, - { "skyBlue", _wrap_Color_skyBlue_get, SWIG_Lua_set_immutable }, - { "slateBlue", _wrap_Color_slateBlue_get, SWIG_Lua_set_immutable }, - { "slateGray", _wrap_Color_slateGray_get, SWIG_Lua_set_immutable }, - { "slateGrey", _wrap_Color_slateGrey_get, SWIG_Lua_set_immutable }, - { "snow", _wrap_Color_snow_get, SWIG_Lua_set_immutable }, - { "springGreen", _wrap_Color_springGreen_get, SWIG_Lua_set_immutable }, - { "steelBlue", _wrap_Color_steelBlue_get, SWIG_Lua_set_immutable }, - { "blueSteel", _wrap_Color_blueSteel_get, SWIG_Lua_set_immutable }, - { "tan", _wrap_Color_tan_get, SWIG_Lua_set_immutable }, - { "teal", _wrap_Color_teal_get, SWIG_Lua_set_immutable }, - { "thistle", _wrap_Color_thistle_get, SWIG_Lua_set_immutable }, - { "tomato", _wrap_Color_tomato_get, SWIG_Lua_set_immutable }, - { "turquoise", _wrap_Color_turquoise_get, SWIG_Lua_set_immutable }, - { "violet", _wrap_Color_violet_get, SWIG_Lua_set_immutable }, - { "wheat", _wrap_Color_wheat_get, SWIG_Lua_set_immutable }, - { "whiteSmoke", _wrap_Color_whiteSmoke_get, SWIG_Lua_set_immutable }, - { "yellowGreen", _wrap_Color_yellowGreen_get, SWIG_Lua_set_immutable }, - {0,0,0} -}; -static swig_lua_const_info swig_Color_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_Color_Sf_SwigStatic_methods[]= { - { "fromHsb", _wrap_Color_fromHsb}, - { "fromHex", _wrap_Color_fromHex}, - { "limit", _wrap_Color_limit}, - {0,0} -}; -static swig_lua_class* swig_Color_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_Color_Sf_SwigStatic = { - "Color", - swig_Color_Sf_SwigStatic_methods, - swig_Color_Sf_SwigStatic_attributes, - swig_Color_Sf_SwigStatic_constants, - swig_Color_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_Color_bases[] = {0}; -static const char *swig_Color_base_names[] = {0}; -static swig_lua_class _wrap_class_Color = { "Color", "Color", &SWIGTYPE_p_ofColor_T_unsigned_char_t,_proxy__wrap_new_Color, swig_delete_Color, swig_Color_methods, swig_Color_attributes, &swig_Color_Sf_SwigStatic, swig_Color_meta, swig_Color_bases, swig_Color_base_names }; - -static int _wrap_new_FloatColor__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::ofColor_",0,0) result = (ofColor_< float > *)new ofColor_< float >(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_FloatColor__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - ofColor_< float > *result = 0 ; SWIG_check_num_args("ofColor_< float >::ofColor_",4,4) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofColor_< float >::ofColor_",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< float >::ofColor_",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< float >::ofColor_",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofColor_< float >::ofColor_",4,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - result = (ofColor_< float > *)new ofColor_< float >(arg1,arg2,arg3,arg4); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_FloatColor__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; - ofColor_< float > *result = 0 ; SWIG_check_num_args("ofColor_< float >::ofColor_",3,3) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofColor_< float >::ofColor_",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< float >::ofColor_",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< float >::ofColor_",3,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - result = (ofColor_< float > *)new ofColor_< float >(arg1,arg2,arg3); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_FloatColor__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; - ofColor_< float > *result = 0 ; SWIG_check_num_args("ofColor_< float >::ofColor_",2,2) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofColor_< float >::ofColor_",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< float >::ofColor_",2,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); result = (ofColor_< float > *)new ofColor_< float >(arg1,arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_FloatColor__SWIG_4(lua_State* L) { int SWIG_arg = 0; float arg1 ; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::ofColor_",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofColor_< float >::ofColor_",1,"float"); arg1 = (float)lua_tonumber(L, 1); - result = (ofColor_< float > *)new ofColor_< float >(arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_FloatColor__SWIG_5(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = 0 ; float arg2 ; - ofColor_< float > *result = 0 ; SWIG_check_num_args("ofColor_< float >::ofColor_",2,2) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofColor_< float >::ofColor_",1,"ofColor_< float > const &"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< float >::ofColor_",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("new_FloatColor",1,SWIGTYPE_p_ofColor_T_float_t); } arg2 = (float)lua_tonumber(L, 2); - result = (ofColor_< float > *)new ofColor_< float >((ofColor_< float > const &)*arg1,arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_FloatColor(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_FloatColor__SWIG_0(L);} if (argc == 1) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { - return _wrap_new_FloatColor__SWIG_4(L);} } if (argc == 2) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_new_FloatColor__SWIG_5(L);} } } if (argc == 2) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_new_FloatColor__SWIG_3(L);} } } if (argc == 3) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_new_FloatColor__SWIG_2(L);} } } } if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_new_FloatColor__SWIG_1(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_FloatColor'\n" " Possible C/C++ prototypes are:\n" - " ofColor_< float >::ofColor_()\n" " ofColor_< float >::ofColor_(float,float,float,float)\n" - " ofColor_< float >::ofColor_(float,float,float)\n" " ofColor_< float >::ofColor_(float,float)\n" - " ofColor_< float >::ofColor_(float)\n" " ofColor_< float >::ofColor_(ofColor_< float > const &,float)\n"); - lua_error(L);return 0; } -static int _wrap_FloatColor_fromHsb__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; - float arg4 ; ofColor_< float > result; SWIG_check_num_args("ofColor_< float >::fromHsb",4,4) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofColor_< float >::fromHsb",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< float >::fromHsb",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< float >::fromHsb",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofColor_< float >::fromHsb",4,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - result = ofColor_< float >::SWIGTEMPLATEDISAMBIGUATOR fromHsb(arg1,arg2,arg3,arg4); { - ofColor_< float > * resultptr = new ofColor_< float >((const ofColor_< float > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_fromHsb__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; - ofColor_< float > result; SWIG_check_num_args("ofColor_< float >::fromHsb",3,3) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofColor_< float >::fromHsb",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< float >::fromHsb",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< float >::fromHsb",3,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - result = ofColor_< float >::SWIGTEMPLATEDISAMBIGUATOR fromHsb(arg1,arg2,arg3); { - ofColor_< float > * resultptr = new ofColor_< float >((const ofColor_< float > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_fromHsb(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_FloatColor_fromHsb__SWIG_1(L);} } } } if (argc == 4) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { - return _wrap_FloatColor_fromHsb__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatColor_fromHsb'\n" " Possible C/C++ prototypes are:\n" - " ofColor_< float >::fromHsb(float,float,float,float)\n" " ofColor_< float >::fromHsb(float,float,float)\n"); - lua_error(L);return 0; } -static int _wrap_FloatColor_fromHex__SWIG_0(lua_State* L) { int SWIG_arg = 0; int arg1 ; float arg2 ; ofColor_< float > result; - SWIG_check_num_args("ofColor_< float >::fromHex",2,2) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofColor_< float >::fromHex",1,"int"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< float >::fromHex",2,"float"); arg1 = (int)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); result = ofColor_< float >::SWIGTEMPLATEDISAMBIGUATOR fromHex(arg1,arg2); { - ofColor_< float > * resultptr = new ofColor_< float >((const ofColor_< float > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_fromHex__SWIG_1(lua_State* L) { int SWIG_arg = 0; int arg1 ; ofColor_< float > result; - SWIG_check_num_args("ofColor_< float >::fromHex",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofColor_< float >::fromHex",1,"int"); arg1 = (int)lua_tonumber(L, 1); - result = ofColor_< float >::SWIGTEMPLATEDISAMBIGUATOR fromHex(arg1); { - ofColor_< float > * resultptr = new ofColor_< float >((const ofColor_< float > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_fromHex(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_FloatColor_fromHex__SWIG_1(L);} } if (argc == 2) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_FloatColor_fromHex__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatColor_fromHex'\n" " Possible C/C++ prototypes are:\n" - " ofColor_< float >::fromHex(int,float)\n" " ofColor_< float >::fromHex(int)\n"); lua_error(L);return 0; } -static int _wrap_FloatColor_set__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float arg2 ; float arg3 ; float arg4 ; float arg5 ; SWIG_check_num_args("ofColor_< float >::set",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::set",1,"ofColor_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< float >::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< float >::set",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofColor_< float >::set",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofColor_< float >::set",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_set",1,SWIGTYPE_p_ofColor_T_float_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - (arg1)->set(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_set__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float arg2 ; float arg3 ; float arg4 ; SWIG_check_num_args("ofColor_< float >::set",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::set",1,"ofColor_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< float >::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< float >::set",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofColor_< float >::set",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_set",1,SWIGTYPE_p_ofColor_T_float_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); (arg1)->set(arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_set__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float arg2 ; float arg3 ; SWIG_check_num_args("ofColor_< float >::set",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::set",1,"ofColor_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< float >::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< float >::set",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_set",1,SWIGTYPE_p_ofColor_T_float_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->set(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FloatColor_set__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float arg2 ; SWIG_check_num_args("ofColor_< float >::set",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::set",1,"ofColor_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< float >::set",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_set",1,SWIGTYPE_p_ofColor_T_float_t); } arg2 = (float)lua_tonumber(L, 2); (arg1)->set(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_set__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - ofColor_< float > *arg2 = 0 ; SWIG_check_num_args("ofColor_< float >::set",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::set",1,"ofColor_< float > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofColor_< float >::set",2,"ofColor_< float > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_set",1,SWIGTYPE_p_ofColor_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_set",2,SWIGTYPE_p_ofColor_T_float_t); } (arg1)->set((ofColor_< float > const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_set(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_FloatColor_set__SWIG_4(L);} } } if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_FloatColor_set__SWIG_3(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_FloatColor_set__SWIG_2(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_FloatColor_set__SWIG_1(L);} } } } } - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_FloatColor_set__SWIG_0(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatColor_set'\n" " Possible C/C++ prototypes are:\n" - " ofColor_< float >::set(float,float,float,float)\n" " ofColor_< float >::set(float,float,float)\n" - " ofColor_< float >::set(float,float)\n" " ofColor_< float >::set(float)\n" - " ofColor_< float >::set(ofColor_< float > const &)\n"); lua_error(L);return 0; } -static int _wrap_FloatColor_setHex__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - int arg2 ; float arg3 ; SWIG_check_num_args("ofColor_< float >::setHex",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::setHex",1,"ofColor_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< float >::setHex",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< float >::setHex",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_setHex",1,SWIGTYPE_p_ofColor_T_float_t); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->setHex(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FloatColor_setHex__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - int arg2 ; SWIG_check_num_args("ofColor_< float >::setHex",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::setHex",1,"ofColor_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< float >::setHex",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_setHex",1,SWIGTYPE_p_ofColor_T_float_t); } arg2 = (int)lua_tonumber(L, 2); (arg1)->setHex(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_setHex(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_FloatColor_setHex__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_FloatColor_setHex__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatColor_setHex'\n" " Possible C/C++ prototypes are:\n" - " ofColor_< float >::setHex(int,float)\n" " ofColor_< float >::setHex(int)\n"); lua_error(L);return 0; } -static int _wrap_FloatColor_setHue(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float arg2 ; SWIG_check_num_args("ofColor_< float >::setHue",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::setHue",1,"ofColor_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< float >::setHue",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_setHue",1,SWIGTYPE_p_ofColor_T_float_t); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setHue(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_setHueAngle(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float arg2 ; SWIG_check_num_args("ofColor_< float >::setHueAngle",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::setHueAngle",1,"ofColor_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< float >::setHueAngle",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_setHueAngle",1,SWIGTYPE_p_ofColor_T_float_t); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setHueAngle(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_setSaturation(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float arg2 ; SWIG_check_num_args("ofColor_< float >::setSaturation",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::setSaturation",1,"ofColor_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< float >::setSaturation",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_setSaturation",1,SWIGTYPE_p_ofColor_T_float_t); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setSaturation(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_setBrightness(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float arg2 ; SWIG_check_num_args("ofColor_< float >::setBrightness",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::setBrightness",1,"ofColor_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< float >::setBrightness",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_setBrightness",1,SWIGTYPE_p_ofColor_T_float_t); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setBrightness(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_setHsb__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float arg2 ; float arg3 ; float arg4 ; float arg5 ; SWIG_check_num_args("ofColor_< float >::setHsb",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::setHsb",1,"ofColor_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< float >::setHsb",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< float >::setHsb",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofColor_< float >::setHsb",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofColor_< float >::setHsb",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_setHsb",1,SWIGTYPE_p_ofColor_T_float_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - (arg1)->setHsb(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_setHsb__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float arg2 ; float arg3 ; float arg4 ; SWIG_check_num_args("ofColor_< float >::setHsb",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::setHsb",1,"ofColor_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< float >::setHsb",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< float >::setHsb",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofColor_< float >::setHsb",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_setHsb",1,SWIGTYPE_p_ofColor_T_float_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); (arg1)->setHsb(arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_setHsb(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 4) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_FloatColor_setHsb__SWIG_1(L);} } } } } - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_FloatColor_setHsb__SWIG_0(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatColor_setHsb'\n" " Possible C/C++ prototypes are:\n" - " ofColor_< float >::setHsb(float,float,float,float)\n" " ofColor_< float >::setHsb(float,float,float)\n"); - lua_error(L);return 0; } -static int _wrap_FloatColor_clamp(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - ofColor_< float > *result = 0 ; SWIG_check_num_args("ofColor_< float >::clamp",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::clamp",1,"ofColor_< float > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_clamp",1,SWIGTYPE_p_ofColor_T_float_t); } result = (ofColor_< float > *) &(arg1)->clamp(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_invert(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - ofColor_< float > *result = 0 ; SWIG_check_num_args("ofColor_< float >::invert",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::invert",1,"ofColor_< float > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_invert",1,SWIGTYPE_p_ofColor_T_float_t); } result = (ofColor_< float > *) &(arg1)->invert(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_normalize(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - ofColor_< float > *result = 0 ; SWIG_check_num_args("ofColor_< float >::normalize",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::normalize",1,"ofColor_< float > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_normalize",1,SWIGTYPE_p_ofColor_T_float_t); } - result = (ofColor_< float > *) &(arg1)->normalize(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_lerp(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - ofColor_< float > *arg2 = 0 ; float arg3 ; ofColor_< float > *result = 0 ; SWIG_check_num_args("ofColor_< float >::lerp",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::lerp",1,"ofColor_< float > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofColor_< float >::lerp",2,"ofColor_< float > const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< float >::lerp",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_lerp",1,SWIGTYPE_p_ofColor_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_lerp",2,SWIGTYPE_p_ofColor_T_float_t); } arg3 = (float)lua_tonumber(L, 3); - result = (ofColor_< float > *) &(arg1)->lerp((ofColor_< float > const &)*arg2,arg3); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_getClamped(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - ofColor_< float > result; SWIG_check_num_args("ofColor_< float >::getClamped",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::getClamped",1,"ofColor_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_getClamped",1,SWIGTYPE_p_ofColor_T_float_t); } - result = ((ofColor_< float > const *)arg1)->getClamped(); { - ofColor_< float > * resultptr = new ofColor_< float >((const ofColor_< float > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_getInverted(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - ofColor_< float > result; SWIG_check_num_args("ofColor_< float >::getInverted",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::getInverted",1,"ofColor_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_getInverted",1,SWIGTYPE_p_ofColor_T_float_t); } - result = ((ofColor_< float > const *)arg1)->getInverted(); { - ofColor_< float > * resultptr = new ofColor_< float >((const ofColor_< float > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_getNormalized(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - ofColor_< float > result; SWIG_check_num_args("ofColor_< float >::getNormalized",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::getNormalized",1,"ofColor_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_getNormalized",1,SWIGTYPE_p_ofColor_T_float_t); } - result = ((ofColor_< float > const *)arg1)->getNormalized(); { - ofColor_< float > * resultptr = new ofColor_< float >((const ofColor_< float > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_getLerped(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - ofColor_< float > *arg2 = 0 ; float arg3 ; ofColor_< float > result; SWIG_check_num_args("ofColor_< float >::getLerped",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::getLerped",1,"ofColor_< float > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofColor_< float >::getLerped",2,"ofColor_< float > const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< float >::getLerped",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_getLerped",1,SWIGTYPE_p_ofColor_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_getLerped",2,SWIGTYPE_p_ofColor_T_float_t); } arg3 = (float)lua_tonumber(L, 3); - result = ((ofColor_< float > const *)arg1)->getLerped((ofColor_< float > const &)*arg2,arg3); { - ofColor_< float > * resultptr = new ofColor_< float >((const ofColor_< float > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_getHex(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - int result; SWIG_check_num_args("ofColor_< float >::getHex",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::getHex",1,"ofColor_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_getHex",1,SWIGTYPE_p_ofColor_T_float_t); } - result = (int)((ofColor_< float > const *)arg1)->getHex(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_getHue(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float result; SWIG_check_num_args("ofColor_< float >::getHue",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::getHue",1,"ofColor_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_getHue",1,SWIGTYPE_p_ofColor_T_float_t); } - result = (float)((ofColor_< float > const *)arg1)->getHue(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_getHueAngle(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float result; SWIG_check_num_args("ofColor_< float >::getHueAngle",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::getHueAngle",1,"ofColor_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_getHueAngle",1,SWIGTYPE_p_ofColor_T_float_t); } - result = (float)((ofColor_< float > const *)arg1)->getHueAngle(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_getSaturation(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float result; SWIG_check_num_args("ofColor_< float >::getSaturation",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::getSaturation",1,"ofColor_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_getSaturation",1,SWIGTYPE_p_ofColor_T_float_t); } - result = (float)((ofColor_< float > const *)arg1)->getSaturation(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_getBrightness(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float result; SWIG_check_num_args("ofColor_< float >::getBrightness",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::getBrightness",1,"ofColor_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_getBrightness",1,SWIGTYPE_p_ofColor_T_float_t); } - result = (float)((ofColor_< float > const *)arg1)->getBrightness(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_getLightness(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float result; SWIG_check_num_args("ofColor_< float >::getLightness",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::getLightness",1,"ofColor_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_getLightness",1,SWIGTYPE_p_ofColor_T_float_t); } - result = (float)((ofColor_< float > const *)arg1)->getLightness(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_getHsb(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float *arg2 = 0 ; float *arg3 = 0 ; float *arg4 = 0 ; SWIG_check_num_args("ofColor_< float >::getHsb",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::getHsb",1,"ofColor_< float > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofColor_< float >::getHsb",2,"float &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofColor_< float >::getHsb",3,"float &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofColor_< float >::getHsb",4,"float &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_getHsb",1,SWIGTYPE_p_ofColor_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("FloatColor_getHsb",2,SWIGTYPE_p_float); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("FloatColor_getHsb",3,SWIGTYPE_p_float); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("FloatColor_getHsb",4,SWIGTYPE_p_float); } ((ofColor_< float > const *)arg1)->getHsb(*arg2,*arg3,*arg4); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_limit(lua_State* L) { int SWIG_arg = 0; float result; - SWIG_check_num_args("ofColor_< float >::limit",0,0) result = (float)ofColor_< float >::SWIGTEMPLATEDISAMBIGUATOR limit(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor___eq(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - ofColor_< float > *arg2 = 0 ; bool result; SWIG_check_num_args("ofColor_< float >::operator ==",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::operator ==",1,"ofColor_< float > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofColor_< float >::operator ==",2,"ofColor_< float > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor___eq",1,SWIGTYPE_p_ofColor_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor___eq",2,SWIGTYPE_p_ofColor_T_float_t); } - result = (bool)((ofColor_< float > const *)arg1)->operator ==((ofColor_< float > const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor___add__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - ofColor_< float > *arg2 = 0 ; ofColor_< float > result; SWIG_check_num_args("ofColor_< float >::operator +",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::operator +",1,"ofColor_< float > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofColor_< float >::operator +",2,"ofColor_< float > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor___add",1,SWIGTYPE_p_ofColor_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor___add",2,SWIGTYPE_p_ofColor_T_float_t); } - result = ((ofColor_< float > const *)arg1)->operator +((ofColor_< float > const &)*arg2); { - ofColor_< float > * resultptr = new ofColor_< float >((const ofColor_< float > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor___add__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float *arg2 = 0 ; float temp2 ; ofColor_< float > result; SWIG_check_num_args("ofColor_< float >::operator +",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::operator +",1,"ofColor_< float > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< float >::operator +",2,"float const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor___add",1,SWIGTYPE_p_ofColor_T_float_t); } temp2=(float)lua_tonumber(L,2); arg2=&temp2; - result = ((ofColor_< float > const *)arg1)->operator +((float const &)*arg2); { - ofColor_< float > * resultptr = new ofColor_< float >((const ofColor_< float > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor___add(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_FloatColor___add__SWIG_0(L);} } } if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_FloatColor___add__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatColor___add'\n" " Possible C/C++ prototypes are:\n" - " ofColor_< float >::operator +(ofColor_< float > const &) const\n" - " ofColor_< float >::operator +(float const &) const\n"); lua_error(L);return 0; } -static int _wrap_FloatColor___sub__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - ofColor_< float > *arg2 = 0 ; ofColor_< float > result; SWIG_check_num_args("ofColor_< float >::operator -",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::operator -",1,"ofColor_< float > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofColor_< float >::operator -",2,"ofColor_< float > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor___sub",1,SWIGTYPE_p_ofColor_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor___sub",2,SWIGTYPE_p_ofColor_T_float_t); } - result = ((ofColor_< float > const *)arg1)->operator -((ofColor_< float > const &)*arg2); { - ofColor_< float > * resultptr = new ofColor_< float >((const ofColor_< float > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor___sub__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float *arg2 = 0 ; float temp2 ; ofColor_< float > result; SWIG_check_num_args("ofColor_< float >::operator -",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::operator -",1,"ofColor_< float > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< float >::operator -",2,"float const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor___sub",1,SWIGTYPE_p_ofColor_T_float_t); } temp2=(float)lua_tonumber(L,2); arg2=&temp2; - result = ((ofColor_< float > const *)arg1)->operator -((float const &)*arg2); { - ofColor_< float > * resultptr = new ofColor_< float >((const ofColor_< float > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor___sub(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_FloatColor___sub__SWIG_0(L);} } } if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_FloatColor___sub__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatColor___sub'\n" " Possible C/C++ prototypes are:\n" - " ofColor_< float >::operator -(ofColor_< float > const &) const\n" - " ofColor_< float >::operator -(float const &) const\n"); lua_error(L);return 0; } -static int _wrap_FloatColor___mul__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - ofColor_< float > *arg2 = 0 ; ofColor_< float > result; SWIG_check_num_args("ofColor_< float >::operator *",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::operator *",1,"ofColor_< float > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofColor_< float >::operator *",2,"ofColor_< float > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor___mul",1,SWIGTYPE_p_ofColor_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor___mul",2,SWIGTYPE_p_ofColor_T_float_t); } - result = ((ofColor_< float > const *)arg1)->operator *((ofColor_< float > const &)*arg2); { - ofColor_< float > * resultptr = new ofColor_< float >((const ofColor_< float > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor___mul__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float *arg2 = 0 ; float temp2 ; ofColor_< float > result; SWIG_check_num_args("ofColor_< float >::operator *",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::operator *",1,"ofColor_< float > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< float >::operator *",2,"float const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor___mul",1,SWIGTYPE_p_ofColor_T_float_t); } temp2=(float)lua_tonumber(L,2); arg2=&temp2; - result = ((ofColor_< float > const *)arg1)->operator *((float const &)*arg2); { - ofColor_< float > * resultptr = new ofColor_< float >((const ofColor_< float > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor___mul(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_FloatColor___mul__SWIG_0(L);} } } if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_FloatColor___mul__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatColor___mul'\n" " Possible C/C++ prototypes are:\n" - " ofColor_< float >::operator *(ofColor_< float > const &) const\n" - " ofColor_< float >::operator *(float const &) const\n"); lua_error(L);return 0; } -static int _wrap_FloatColor___div__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - ofColor_< float > *arg2 = 0 ; ofColor_< float > result; SWIG_check_num_args("ofColor_< float >::operator /",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::operator /",1,"ofColor_< float > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofColor_< float >::operator /",2,"ofColor_< float > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor___div",1,SWIGTYPE_p_ofColor_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor___div",2,SWIGTYPE_p_ofColor_T_float_t); } - result = ((ofColor_< float > const *)arg1)->operator /((ofColor_< float > const &)*arg2); { - ofColor_< float > * resultptr = new ofColor_< float >((const ofColor_< float > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor___div__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float *arg2 = 0 ; float temp2 ; ofColor_< float > result; SWIG_check_num_args("ofColor_< float >::operator /",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::operator /",1,"ofColor_< float > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< float >::operator /",2,"float const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor___div",1,SWIGTYPE_p_ofColor_T_float_t); } temp2=(float)lua_tonumber(L,2); arg2=&temp2; - result = ((ofColor_< float > const *)arg1)->operator /((float const &)*arg2); { - ofColor_< float > * resultptr = new ofColor_< float >((const ofColor_< float > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor___div(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_FloatColor___div__SWIG_0(L);} } } if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_FloatColor___div__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatColor___div'\n" " Possible C/C++ prototypes are:\n" - " ofColor_< float >::operator /(ofColor_< float > const &) const\n" - " ofColor_< float >::operator /(float const &) const\n"); lua_error(L);return 0; } -static int _wrap_FloatColor_white_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::white",0,0) result = (ofColor_< float > *)&ofColor_< float >::white; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_gray_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::gray",0,0) result = (ofColor_< float > *)&ofColor_< float >::gray; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_black_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::black",0,0) result = (ofColor_< float > *)&ofColor_< float >::black; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_red_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::red",0,0) result = (ofColor_< float > *)&ofColor_< float >::red; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_green_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::green",0,0) result = (ofColor_< float > *)&ofColor_< float >::green; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_blue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::blue",0,0) result = (ofColor_< float > *)&ofColor_< float >::blue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_cyan_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::cyan",0,0) result = (ofColor_< float > *)&ofColor_< float >::cyan; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_magenta_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::magenta",0,0) result = (ofColor_< float > *)&ofColor_< float >::magenta; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_yellow_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::yellow",0,0) result = (ofColor_< float > *)&ofColor_< float >::yellow; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_aliceBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::aliceBlue",0,0) result = (ofColor_< float > *)&ofColor_< float >::aliceBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_antiqueWhite_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::antiqueWhite",0,0) result = (ofColor_< float > *)&ofColor_< float >::antiqueWhite; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_aqua_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::aqua",0,0) result = (ofColor_< float > *)&ofColor_< float >::aqua; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_aquamarine_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::aquamarine",0,0) result = (ofColor_< float > *)&ofColor_< float >::aquamarine; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_azure_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::azure",0,0) result = (ofColor_< float > *)&ofColor_< float >::azure; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_beige_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::beige",0,0) result = (ofColor_< float > *)&ofColor_< float >::beige; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_bisque_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::bisque",0,0) result = (ofColor_< float > *)&ofColor_< float >::bisque; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_blanchedAlmond_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::blanchedAlmond",0,0) result = (ofColor_< float > *)&ofColor_< float >::blanchedAlmond; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_blueViolet_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::blueViolet",0,0) result = (ofColor_< float > *)&ofColor_< float >::blueViolet; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_brown_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::brown",0,0) result = (ofColor_< float > *)&ofColor_< float >::brown; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_burlyWood_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::burlyWood",0,0) result = (ofColor_< float > *)&ofColor_< float >::burlyWood; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_cadetBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::cadetBlue",0,0) result = (ofColor_< float > *)&ofColor_< float >::cadetBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_chartreuse_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::chartreuse",0,0) result = (ofColor_< float > *)&ofColor_< float >::chartreuse; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_chocolate_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::chocolate",0,0) result = (ofColor_< float > *)&ofColor_< float >::chocolate; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_coral_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::coral",0,0) result = (ofColor_< float > *)&ofColor_< float >::coral; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_cornflowerBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::cornflowerBlue",0,0) result = (ofColor_< float > *)&ofColor_< float >::cornflowerBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_cornsilk_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::cornsilk",0,0) result = (ofColor_< float > *)&ofColor_< float >::cornsilk; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_crimson_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::crimson",0,0) result = (ofColor_< float > *)&ofColor_< float >::crimson; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_darkBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::darkBlue",0,0) result = (ofColor_< float > *)&ofColor_< float >::darkBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_darkCyan_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::darkCyan",0,0) result = (ofColor_< float > *)&ofColor_< float >::darkCyan; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_darkGoldenRod_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::darkGoldenRod",0,0) result = (ofColor_< float > *)&ofColor_< float >::darkGoldenRod; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_darkGray_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::darkGray",0,0) result = (ofColor_< float > *)&ofColor_< float >::darkGray; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_darkGrey_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::darkGrey",0,0) result = (ofColor_< float > *)&ofColor_< float >::darkGrey; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_darkGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::darkGreen",0,0) result = (ofColor_< float > *)&ofColor_< float >::darkGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_darkKhaki_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::darkKhaki",0,0) result = (ofColor_< float > *)&ofColor_< float >::darkKhaki; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_darkMagenta_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::darkMagenta",0,0) result = (ofColor_< float > *)&ofColor_< float >::darkMagenta; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_darkOliveGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::darkOliveGreen",0,0) result = (ofColor_< float > *)&ofColor_< float >::darkOliveGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_darkorange_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::darkorange",0,0) result = (ofColor_< float > *)&ofColor_< float >::darkorange; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_darkOrchid_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::darkOrchid",0,0) result = (ofColor_< float > *)&ofColor_< float >::darkOrchid; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_darkRed_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::darkRed",0,0) result = (ofColor_< float > *)&ofColor_< float >::darkRed; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_darkSalmon_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::darkSalmon",0,0) result = (ofColor_< float > *)&ofColor_< float >::darkSalmon; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_darkSeaGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::darkSeaGreen",0,0) result = (ofColor_< float > *)&ofColor_< float >::darkSeaGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_darkSlateBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::darkSlateBlue",0,0) result = (ofColor_< float > *)&ofColor_< float >::darkSlateBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_darkSlateGray_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::darkSlateGray",0,0) result = (ofColor_< float > *)&ofColor_< float >::darkSlateGray; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_darkSlateGrey_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::darkSlateGrey",0,0) result = (ofColor_< float > *)&ofColor_< float >::darkSlateGrey; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_darkTurquoise_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::darkTurquoise",0,0) result = (ofColor_< float > *)&ofColor_< float >::darkTurquoise; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_darkViolet_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::darkViolet",0,0) result = (ofColor_< float > *)&ofColor_< float >::darkViolet; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_deepPink_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::deepPink",0,0) result = (ofColor_< float > *)&ofColor_< float >::deepPink; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_deepSkyBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::deepSkyBlue",0,0) result = (ofColor_< float > *)&ofColor_< float >::deepSkyBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_dimGray_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::dimGray",0,0) result = (ofColor_< float > *)&ofColor_< float >::dimGray; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_dimGrey_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::dimGrey",0,0) result = (ofColor_< float > *)&ofColor_< float >::dimGrey; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_dodgerBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::dodgerBlue",0,0) result = (ofColor_< float > *)&ofColor_< float >::dodgerBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_fireBrick_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::fireBrick",0,0) result = (ofColor_< float > *)&ofColor_< float >::fireBrick; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_floralWhite_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::floralWhite",0,0) result = (ofColor_< float > *)&ofColor_< float >::floralWhite; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_forestGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::forestGreen",0,0) result = (ofColor_< float > *)&ofColor_< float >::forestGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_fuchsia_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::fuchsia",0,0) result = (ofColor_< float > *)&ofColor_< float >::fuchsia; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_gainsboro_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::gainsboro",0,0) result = (ofColor_< float > *)&ofColor_< float >::gainsboro; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_ghostWhite_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::ghostWhite",0,0) result = (ofColor_< float > *)&ofColor_< float >::ghostWhite; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_gold_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::gold",0,0) result = (ofColor_< float > *)&ofColor_< float >::gold; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_goldenRod_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::goldenRod",0,0) result = (ofColor_< float > *)&ofColor_< float >::goldenRod; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_grey_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::grey",0,0) result = (ofColor_< float > *)&ofColor_< float >::grey; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_greenYellow_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::greenYellow",0,0) result = (ofColor_< float > *)&ofColor_< float >::greenYellow; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_honeyDew_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::honeyDew",0,0) result = (ofColor_< float > *)&ofColor_< float >::honeyDew; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_hotPink_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::hotPink",0,0) result = (ofColor_< float > *)&ofColor_< float >::hotPink; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_indianRed_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::indianRed",0,0) result = (ofColor_< float > *)&ofColor_< float >::indianRed; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_indigo_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::indigo",0,0) result = (ofColor_< float > *)&ofColor_< float >::indigo; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_ivory_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::ivory",0,0) result = (ofColor_< float > *)&ofColor_< float >::ivory; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_khaki_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::khaki",0,0) result = (ofColor_< float > *)&ofColor_< float >::khaki; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_lavender_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::lavender",0,0) result = (ofColor_< float > *)&ofColor_< float >::lavender; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_lavenderBlush_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::lavenderBlush",0,0) result = (ofColor_< float > *)&ofColor_< float >::lavenderBlush; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_lawnGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::lawnGreen",0,0) result = (ofColor_< float > *)&ofColor_< float >::lawnGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_lemonChiffon_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::lemonChiffon",0,0) result = (ofColor_< float > *)&ofColor_< float >::lemonChiffon; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_lightBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::lightBlue",0,0) result = (ofColor_< float > *)&ofColor_< float >::lightBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_lightCoral_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::lightCoral",0,0) result = (ofColor_< float > *)&ofColor_< float >::lightCoral; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_lightCyan_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::lightCyan",0,0) result = (ofColor_< float > *)&ofColor_< float >::lightCyan; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_lightGoldenRodYellow_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::lightGoldenRodYellow",0,0) - result = (ofColor_< float > *)&ofColor_< float >::lightGoldenRodYellow; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_lightGray_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::lightGray",0,0) result = (ofColor_< float > *)&ofColor_< float >::lightGray; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_lightGrey_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::lightGrey",0,0) result = (ofColor_< float > *)&ofColor_< float >::lightGrey; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_lightGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::lightGreen",0,0) result = (ofColor_< float > *)&ofColor_< float >::lightGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_lightPink_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::lightPink",0,0) result = (ofColor_< float > *)&ofColor_< float >::lightPink; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_lightSalmon_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::lightSalmon",0,0) result = (ofColor_< float > *)&ofColor_< float >::lightSalmon; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_lightSeaGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::lightSeaGreen",0,0) result = (ofColor_< float > *)&ofColor_< float >::lightSeaGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_lightSkyBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::lightSkyBlue",0,0) result = (ofColor_< float > *)&ofColor_< float >::lightSkyBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_lightSlateGray_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::lightSlateGray",0,0) result = (ofColor_< float > *)&ofColor_< float >::lightSlateGray; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_lightSlateGrey_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::lightSlateGrey",0,0) result = (ofColor_< float > *)&ofColor_< float >::lightSlateGrey; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_lightSteelBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::lightSteelBlue",0,0) result = (ofColor_< float > *)&ofColor_< float >::lightSteelBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_lightYellow_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::lightYellow",0,0) result = (ofColor_< float > *)&ofColor_< float >::lightYellow; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_lime_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::lime",0,0) result = (ofColor_< float > *)&ofColor_< float >::lime; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_limeGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::limeGreen",0,0) result = (ofColor_< float > *)&ofColor_< float >::limeGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_linen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::linen",0,0) result = (ofColor_< float > *)&ofColor_< float >::linen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_maroon_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::maroon",0,0) result = (ofColor_< float > *)&ofColor_< float >::maroon; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_mediumAquaMarine_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::mediumAquaMarine",0,0) - result = (ofColor_< float > *)&ofColor_< float >::mediumAquaMarine; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_mediumBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::mediumBlue",0,0) result = (ofColor_< float > *)&ofColor_< float >::mediumBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_mediumOrchid_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::mediumOrchid",0,0) result = (ofColor_< float > *)&ofColor_< float >::mediumOrchid; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_mediumPurple_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::mediumPurple",0,0) result = (ofColor_< float > *)&ofColor_< float >::mediumPurple; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_mediumSeaGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::mediumSeaGreen",0,0) result = (ofColor_< float > *)&ofColor_< float >::mediumSeaGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_mediumSlateBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::mediumSlateBlue",0,0) - result = (ofColor_< float > *)&ofColor_< float >::mediumSlateBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_mediumSpringGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::mediumSpringGreen",0,0) - result = (ofColor_< float > *)&ofColor_< float >::mediumSpringGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_mediumTurquoise_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::mediumTurquoise",0,0) - result = (ofColor_< float > *)&ofColor_< float >::mediumTurquoise; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_mediumVioletRed_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::mediumVioletRed",0,0) - result = (ofColor_< float > *)&ofColor_< float >::mediumVioletRed; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_midnightBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::midnightBlue",0,0) result = (ofColor_< float > *)&ofColor_< float >::midnightBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_mintCream_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::mintCream",0,0) result = (ofColor_< float > *)&ofColor_< float >::mintCream; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_mistyRose_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::mistyRose",0,0) result = (ofColor_< float > *)&ofColor_< float >::mistyRose; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_moccasin_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::moccasin",0,0) result = (ofColor_< float > *)&ofColor_< float >::moccasin; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_navajoWhite_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::navajoWhite",0,0) result = (ofColor_< float > *)&ofColor_< float >::navajoWhite; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_navy_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::navy",0,0) result = (ofColor_< float > *)&ofColor_< float >::navy; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_oldLace_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::oldLace",0,0) result = (ofColor_< float > *)&ofColor_< float >::oldLace; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_olive_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::olive",0,0) result = (ofColor_< float > *)&ofColor_< float >::olive; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_oliveDrab_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::oliveDrab",0,0) result = (ofColor_< float > *)&ofColor_< float >::oliveDrab; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_orange_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::orange",0,0) result = (ofColor_< float > *)&ofColor_< float >::orange; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_orangeRed_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::orangeRed",0,0) result = (ofColor_< float > *)&ofColor_< float >::orangeRed; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_orchid_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::orchid",0,0) result = (ofColor_< float > *)&ofColor_< float >::orchid; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_paleGoldenRod_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::paleGoldenRod",0,0) result = (ofColor_< float > *)&ofColor_< float >::paleGoldenRod; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_paleGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::paleGreen",0,0) result = (ofColor_< float > *)&ofColor_< float >::paleGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_paleTurquoise_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::paleTurquoise",0,0) result = (ofColor_< float > *)&ofColor_< float >::paleTurquoise; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_paleVioletRed_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::paleVioletRed",0,0) result = (ofColor_< float > *)&ofColor_< float >::paleVioletRed; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_papayaWhip_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::papayaWhip",0,0) result = (ofColor_< float > *)&ofColor_< float >::papayaWhip; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_peachPuff_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::peachPuff",0,0) result = (ofColor_< float > *)&ofColor_< float >::peachPuff; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_peru_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::peru",0,0) result = (ofColor_< float > *)&ofColor_< float >::peru; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_pink_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::pink",0,0) result = (ofColor_< float > *)&ofColor_< float >::pink; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_plum_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::plum",0,0) result = (ofColor_< float > *)&ofColor_< float >::plum; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_powderBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::powderBlue",0,0) result = (ofColor_< float > *)&ofColor_< float >::powderBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_purple_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::purple",0,0) result = (ofColor_< float > *)&ofColor_< float >::purple; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_rosyBrown_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::rosyBrown",0,0) result = (ofColor_< float > *)&ofColor_< float >::rosyBrown; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_royalBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::royalBlue",0,0) result = (ofColor_< float > *)&ofColor_< float >::royalBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_saddleBrown_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::saddleBrown",0,0) result = (ofColor_< float > *)&ofColor_< float >::saddleBrown; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_salmon_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::salmon",0,0) result = (ofColor_< float > *)&ofColor_< float >::salmon; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_sandyBrown_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::sandyBrown",0,0) result = (ofColor_< float > *)&ofColor_< float >::sandyBrown; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_seaGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::seaGreen",0,0) result = (ofColor_< float > *)&ofColor_< float >::seaGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_seaShell_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::seaShell",0,0) result = (ofColor_< float > *)&ofColor_< float >::seaShell; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_sienna_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::sienna",0,0) result = (ofColor_< float > *)&ofColor_< float >::sienna; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_silver_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::silver",0,0) result = (ofColor_< float > *)&ofColor_< float >::silver; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_skyBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::skyBlue",0,0) result = (ofColor_< float > *)&ofColor_< float >::skyBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_slateBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::slateBlue",0,0) result = (ofColor_< float > *)&ofColor_< float >::slateBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_slateGray_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::slateGray",0,0) result = (ofColor_< float > *)&ofColor_< float >::slateGray; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_slateGrey_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::slateGrey",0,0) result = (ofColor_< float > *)&ofColor_< float >::slateGrey; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_snow_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::snow",0,0) result = (ofColor_< float > *)&ofColor_< float >::snow; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_springGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::springGreen",0,0) result = (ofColor_< float > *)&ofColor_< float >::springGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_steelBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::steelBlue",0,0) result = (ofColor_< float > *)&ofColor_< float >::steelBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_blueSteel_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::blueSteel",0,0) result = (ofColor_< float > *)&ofColor_< float >::blueSteel; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_tan_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::tan",0,0) result = (ofColor_< float > *)&ofColor_< float >::tan; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_teal_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::teal",0,0) result = (ofColor_< float > *)&ofColor_< float >::teal; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_thistle_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::thistle",0,0) result = (ofColor_< float > *)&ofColor_< float >::thistle; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_tomato_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::tomato",0,0) result = (ofColor_< float > *)&ofColor_< float >::tomato; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_turquoise_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::turquoise",0,0) result = (ofColor_< float > *)&ofColor_< float >::turquoise; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_violet_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::violet",0,0) result = (ofColor_< float > *)&ofColor_< float >::violet; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_wheat_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::wheat",0,0) result = (ofColor_< float > *)&ofColor_< float >::wheat; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_whiteSmoke_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::whiteSmoke",0,0) result = (ofColor_< float > *)&ofColor_< float >::whiteSmoke; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_yellowGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::yellowGreen",0,0) result = (ofColor_< float > *)&ofColor_< float >::yellowGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_getR(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float result; SWIG_check_num_args("ofColor_< float >::getR",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::getR",1,"ofColor_< float > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_getR",1,SWIGTYPE_p_ofColor_T_float_t); } result = (float)ofColor__Sl_float_Sg__getR(arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_getG(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float result; SWIG_check_num_args("ofColor_< float >::getG",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::getG",1,"ofColor_< float > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_getG",1,SWIGTYPE_p_ofColor_T_float_t); } result = (float)ofColor__Sl_float_Sg__getG(arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_getB(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float result; SWIG_check_num_args("ofColor_< float >::getB",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::getB",1,"ofColor_< float > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_getB",1,SWIGTYPE_p_ofColor_T_float_t); } result = (float)ofColor__Sl_float_Sg__getB(arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_getA(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float result; SWIG_check_num_args("ofColor_< float >::getA",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::getA",1,"ofColor_< float > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_getA",1,SWIGTYPE_p_ofColor_T_float_t); } result = (float)ofColor__Sl_float_Sg__getA(arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_setR(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float arg2 ; SWIG_check_num_args("ofColor_< float >::setR",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::setR",1,"ofColor_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< float >::setR",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_setR",1,SWIGTYPE_p_ofColor_T_float_t); } arg2 = (float)lua_tonumber(L, 2); - ofColor__Sl_float_Sg__setR(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_setG(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float arg2 ; SWIG_check_num_args("ofColor_< float >::setG",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::setG",1,"ofColor_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< float >::setG",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_setG",1,SWIGTYPE_p_ofColor_T_float_t); } arg2 = (float)lua_tonumber(L, 2); - ofColor__Sl_float_Sg__setG(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_setB(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float arg2 ; SWIG_check_num_args("ofColor_< float >::setB",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::setB",1,"ofColor_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< float >::setB",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_setB",1,SWIGTYPE_p_ofColor_T_float_t); } arg2 = (float)lua_tonumber(L, 2); - ofColor__Sl_float_Sg__setB(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_setA(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float arg2 ; SWIG_check_num_args("ofColor_< float >::setA",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::setA",1,"ofColor_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< float >::setA",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_setA",1,SWIGTYPE_p_ofColor_T_float_t); } arg2 = (float)lua_tonumber(L, 2); - ofColor__Sl_float_Sg__setA(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor___tostring(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - char *result = 0 ; SWIG_check_num_args("ofColor_< float >::__str__",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::__str__",1,"ofColor_< float > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor___tostring",1,SWIGTYPE_p_ofColor_T_float_t); } - result = (char *)ofColor__Sl_float_Sg____str__(arg1); lua_pushstring(L,(const char *)result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_r_set(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float arg2 ; SWIG_check_num_args("ofColor_< float >::r",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::r",1,"ofColor_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< float >::r",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_r_set",1,SWIGTYPE_p_ofColor_T_float_t); } arg2 = (float)lua_tonumber(L, 2); - ofColor__Sl_float_Sg__r_set(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_r_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float result; SWIG_check_num_args("ofColor_< float >::r",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::r",1,"ofColor_< float > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_r_get",1,SWIGTYPE_p_ofColor_T_float_t); } result = (float)ofColor__Sl_float_Sg__r_get(arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_g_set(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float arg2 ; SWIG_check_num_args("ofColor_< float >::g",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::g",1,"ofColor_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< float >::g",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_g_set",1,SWIGTYPE_p_ofColor_T_float_t); } arg2 = (float)lua_tonumber(L, 2); - ofColor__Sl_float_Sg__g_set(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_g_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float result; SWIG_check_num_args("ofColor_< float >::g",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::g",1,"ofColor_< float > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_g_get",1,SWIGTYPE_p_ofColor_T_float_t); } result = (float)ofColor__Sl_float_Sg__g_get(arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_b_set(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float arg2 ; SWIG_check_num_args("ofColor_< float >::b",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::b",1,"ofColor_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< float >::b",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_b_set",1,SWIGTYPE_p_ofColor_T_float_t); } arg2 = (float)lua_tonumber(L, 2); - ofColor__Sl_float_Sg__b_set(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_b_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float result; SWIG_check_num_args("ofColor_< float >::b",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::b",1,"ofColor_< float > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_b_get",1,SWIGTYPE_p_ofColor_T_float_t); } result = (float)ofColor__Sl_float_Sg__b_get(arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_a_set(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float arg2 ; SWIG_check_num_args("ofColor_< float >::a",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::a",1,"ofColor_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< float >::a",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_a_set",1,SWIGTYPE_p_ofColor_T_float_t); } arg2 = (float)lua_tonumber(L, 2); - ofColor__Sl_float_Sg__a_set(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_a_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float result; SWIG_check_num_args("ofColor_< float >::a",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::a",1,"ofColor_< float > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_a_get",1,SWIGTYPE_p_ofColor_T_float_t); } result = (float)ofColor__Sl_float_Sg__a_get(arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_FloatColor(void *obj) { -ofColor_< float > *arg1 = (ofColor_< float > *) obj; -delete arg1; -} -static int _proxy__wrap_new_FloatColor(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_FloatColor); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_FloatColor_attributes[] = { - { "r", _wrap_FloatColor_r_get, _wrap_FloatColor_r_set }, - { "g", _wrap_FloatColor_g_get, _wrap_FloatColor_g_set }, - { "b", _wrap_FloatColor_b_get, _wrap_FloatColor_b_set }, - { "a", _wrap_FloatColor_a_get, _wrap_FloatColor_a_set }, - {0,0,0} -}; -static swig_lua_method swig_FloatColor_methods[]= { - { "set", _wrap_FloatColor_set}, - { "setHex", _wrap_FloatColor_setHex}, - { "setHue", _wrap_FloatColor_setHue}, - { "setHueAngle", _wrap_FloatColor_setHueAngle}, - { "setSaturation", _wrap_FloatColor_setSaturation}, - { "setBrightness", _wrap_FloatColor_setBrightness}, - { "setHsb", _wrap_FloatColor_setHsb}, - { "clamp", _wrap_FloatColor_clamp}, - { "invert", _wrap_FloatColor_invert}, - { "normalize", _wrap_FloatColor_normalize}, - { "lerp", _wrap_FloatColor_lerp}, - { "getClamped", _wrap_FloatColor_getClamped}, - { "getInverted", _wrap_FloatColor_getInverted}, - { "getNormalized", _wrap_FloatColor_getNormalized}, - { "getLerped", _wrap_FloatColor_getLerped}, - { "getHex", _wrap_FloatColor_getHex}, - { "getHue", _wrap_FloatColor_getHue}, - { "getHueAngle", _wrap_FloatColor_getHueAngle}, - { "getSaturation", _wrap_FloatColor_getSaturation}, - { "getBrightness", _wrap_FloatColor_getBrightness}, - { "getLightness", _wrap_FloatColor_getLightness}, - { "getHsb", _wrap_FloatColor_getHsb}, - { "__eq", _wrap_FloatColor___eq}, - { "__add", _wrap_FloatColor___add}, - { "__sub", _wrap_FloatColor___sub}, - { "__mul", _wrap_FloatColor___mul}, - { "__div", _wrap_FloatColor___div}, - { "getR", _wrap_FloatColor_getR}, - { "getG", _wrap_FloatColor_getG}, - { "getB", _wrap_FloatColor_getB}, - { "getA", _wrap_FloatColor_getA}, - { "setR", _wrap_FloatColor_setR}, - { "setG", _wrap_FloatColor_setG}, - { "setB", _wrap_FloatColor_setB}, - { "setA", _wrap_FloatColor_setA}, - { "__tostring", _wrap_FloatColor___tostring}, - {0,0} -}; -static swig_lua_method swig_FloatColor_meta[] = { - { "__eq", _wrap_FloatColor___eq}, - { "__add", _wrap_FloatColor___add}, - { "__sub", _wrap_FloatColor___sub}, - { "__mul", _wrap_FloatColor___mul}, - { "__div", _wrap_FloatColor___div}, - { "__tostring", _wrap_FloatColor___tostring}, - {0,0} -}; - -static swig_lua_attribute swig_FloatColor_Sf_SwigStatic_attributes[] = { - { "white", _wrap_FloatColor_white_get, SWIG_Lua_set_immutable }, - { "gray", _wrap_FloatColor_gray_get, SWIG_Lua_set_immutable }, - { "black", _wrap_FloatColor_black_get, SWIG_Lua_set_immutable }, - { "red", _wrap_FloatColor_red_get, SWIG_Lua_set_immutable }, - { "green", _wrap_FloatColor_green_get, SWIG_Lua_set_immutable }, - { "blue", _wrap_FloatColor_blue_get, SWIG_Lua_set_immutable }, - { "cyan", _wrap_FloatColor_cyan_get, SWIG_Lua_set_immutable }, - { "magenta", _wrap_FloatColor_magenta_get, SWIG_Lua_set_immutable }, - { "yellow", _wrap_FloatColor_yellow_get, SWIG_Lua_set_immutable }, - { "aliceBlue", _wrap_FloatColor_aliceBlue_get, SWIG_Lua_set_immutable }, - { "antiqueWhite", _wrap_FloatColor_antiqueWhite_get, SWIG_Lua_set_immutable }, - { "aqua", _wrap_FloatColor_aqua_get, SWIG_Lua_set_immutable }, - { "aquamarine", _wrap_FloatColor_aquamarine_get, SWIG_Lua_set_immutable }, - { "azure", _wrap_FloatColor_azure_get, SWIG_Lua_set_immutable }, - { "beige", _wrap_FloatColor_beige_get, SWIG_Lua_set_immutable }, - { "bisque", _wrap_FloatColor_bisque_get, SWIG_Lua_set_immutable }, - { "blanchedAlmond", _wrap_FloatColor_blanchedAlmond_get, SWIG_Lua_set_immutable }, - { "blueViolet", _wrap_FloatColor_blueViolet_get, SWIG_Lua_set_immutable }, - { "brown", _wrap_FloatColor_brown_get, SWIG_Lua_set_immutable }, - { "burlyWood", _wrap_FloatColor_burlyWood_get, SWIG_Lua_set_immutable }, - { "cadetBlue", _wrap_FloatColor_cadetBlue_get, SWIG_Lua_set_immutable }, - { "chartreuse", _wrap_FloatColor_chartreuse_get, SWIG_Lua_set_immutable }, - { "chocolate", _wrap_FloatColor_chocolate_get, SWIG_Lua_set_immutable }, - { "coral", _wrap_FloatColor_coral_get, SWIG_Lua_set_immutable }, - { "cornflowerBlue", _wrap_FloatColor_cornflowerBlue_get, SWIG_Lua_set_immutable }, - { "cornsilk", _wrap_FloatColor_cornsilk_get, SWIG_Lua_set_immutable }, - { "crimson", _wrap_FloatColor_crimson_get, SWIG_Lua_set_immutable }, - { "darkBlue", _wrap_FloatColor_darkBlue_get, SWIG_Lua_set_immutable }, - { "darkCyan", _wrap_FloatColor_darkCyan_get, SWIG_Lua_set_immutable }, - { "darkGoldenRod", _wrap_FloatColor_darkGoldenRod_get, SWIG_Lua_set_immutable }, - { "darkGray", _wrap_FloatColor_darkGray_get, SWIG_Lua_set_immutable }, - { "darkGrey", _wrap_FloatColor_darkGrey_get, SWIG_Lua_set_immutable }, - { "darkGreen", _wrap_FloatColor_darkGreen_get, SWIG_Lua_set_immutable }, - { "darkKhaki", _wrap_FloatColor_darkKhaki_get, SWIG_Lua_set_immutable }, - { "darkMagenta", _wrap_FloatColor_darkMagenta_get, SWIG_Lua_set_immutable }, - { "darkOliveGreen", _wrap_FloatColor_darkOliveGreen_get, SWIG_Lua_set_immutable }, - { "darkorange", _wrap_FloatColor_darkorange_get, SWIG_Lua_set_immutable }, - { "darkOrchid", _wrap_FloatColor_darkOrchid_get, SWIG_Lua_set_immutable }, - { "darkRed", _wrap_FloatColor_darkRed_get, SWIG_Lua_set_immutable }, - { "darkSalmon", _wrap_FloatColor_darkSalmon_get, SWIG_Lua_set_immutable }, - { "darkSeaGreen", _wrap_FloatColor_darkSeaGreen_get, SWIG_Lua_set_immutable }, - { "darkSlateBlue", _wrap_FloatColor_darkSlateBlue_get, SWIG_Lua_set_immutable }, - { "darkSlateGray", _wrap_FloatColor_darkSlateGray_get, SWIG_Lua_set_immutable }, - { "darkSlateGrey", _wrap_FloatColor_darkSlateGrey_get, SWIG_Lua_set_immutable }, - { "darkTurquoise", _wrap_FloatColor_darkTurquoise_get, SWIG_Lua_set_immutable }, - { "darkViolet", _wrap_FloatColor_darkViolet_get, SWIG_Lua_set_immutable }, - { "deepPink", _wrap_FloatColor_deepPink_get, SWIG_Lua_set_immutable }, - { "deepSkyBlue", _wrap_FloatColor_deepSkyBlue_get, SWIG_Lua_set_immutable }, - { "dimGray", _wrap_FloatColor_dimGray_get, SWIG_Lua_set_immutable }, - { "dimGrey", _wrap_FloatColor_dimGrey_get, SWIG_Lua_set_immutable }, - { "dodgerBlue", _wrap_FloatColor_dodgerBlue_get, SWIG_Lua_set_immutable }, - { "fireBrick", _wrap_FloatColor_fireBrick_get, SWIG_Lua_set_immutable }, - { "floralWhite", _wrap_FloatColor_floralWhite_get, SWIG_Lua_set_immutable }, - { "forestGreen", _wrap_FloatColor_forestGreen_get, SWIG_Lua_set_immutable }, - { "fuchsia", _wrap_FloatColor_fuchsia_get, SWIG_Lua_set_immutable }, - { "gainsboro", _wrap_FloatColor_gainsboro_get, SWIG_Lua_set_immutable }, - { "ghostWhite", _wrap_FloatColor_ghostWhite_get, SWIG_Lua_set_immutable }, - { "gold", _wrap_FloatColor_gold_get, SWIG_Lua_set_immutable }, - { "goldenRod", _wrap_FloatColor_goldenRod_get, SWIG_Lua_set_immutable }, - { "grey", _wrap_FloatColor_grey_get, SWIG_Lua_set_immutable }, - { "greenYellow", _wrap_FloatColor_greenYellow_get, SWIG_Lua_set_immutable }, - { "honeyDew", _wrap_FloatColor_honeyDew_get, SWIG_Lua_set_immutable }, - { "hotPink", _wrap_FloatColor_hotPink_get, SWIG_Lua_set_immutable }, - { "indianRed", _wrap_FloatColor_indianRed_get, SWIG_Lua_set_immutable }, - { "indigo", _wrap_FloatColor_indigo_get, SWIG_Lua_set_immutable }, - { "ivory", _wrap_FloatColor_ivory_get, SWIG_Lua_set_immutable }, - { "khaki", _wrap_FloatColor_khaki_get, SWIG_Lua_set_immutable }, - { "lavender", _wrap_FloatColor_lavender_get, SWIG_Lua_set_immutable }, - { "lavenderBlush", _wrap_FloatColor_lavenderBlush_get, SWIG_Lua_set_immutable }, - { "lawnGreen", _wrap_FloatColor_lawnGreen_get, SWIG_Lua_set_immutable }, - { "lemonChiffon", _wrap_FloatColor_lemonChiffon_get, SWIG_Lua_set_immutable }, - { "lightBlue", _wrap_FloatColor_lightBlue_get, SWIG_Lua_set_immutable }, - { "lightCoral", _wrap_FloatColor_lightCoral_get, SWIG_Lua_set_immutable }, - { "lightCyan", _wrap_FloatColor_lightCyan_get, SWIG_Lua_set_immutable }, - { "lightGoldenRodYellow", _wrap_FloatColor_lightGoldenRodYellow_get, SWIG_Lua_set_immutable }, - { "lightGray", _wrap_FloatColor_lightGray_get, SWIG_Lua_set_immutable }, - { "lightGrey", _wrap_FloatColor_lightGrey_get, SWIG_Lua_set_immutable }, - { "lightGreen", _wrap_FloatColor_lightGreen_get, SWIG_Lua_set_immutable }, - { "lightPink", _wrap_FloatColor_lightPink_get, SWIG_Lua_set_immutable }, - { "lightSalmon", _wrap_FloatColor_lightSalmon_get, SWIG_Lua_set_immutable }, - { "lightSeaGreen", _wrap_FloatColor_lightSeaGreen_get, SWIG_Lua_set_immutable }, - { "lightSkyBlue", _wrap_FloatColor_lightSkyBlue_get, SWIG_Lua_set_immutable }, - { "lightSlateGray", _wrap_FloatColor_lightSlateGray_get, SWIG_Lua_set_immutable }, - { "lightSlateGrey", _wrap_FloatColor_lightSlateGrey_get, SWIG_Lua_set_immutable }, - { "lightSteelBlue", _wrap_FloatColor_lightSteelBlue_get, SWIG_Lua_set_immutable }, - { "lightYellow", _wrap_FloatColor_lightYellow_get, SWIG_Lua_set_immutable }, - { "lime", _wrap_FloatColor_lime_get, SWIG_Lua_set_immutable }, - { "limeGreen", _wrap_FloatColor_limeGreen_get, SWIG_Lua_set_immutable }, - { "linen", _wrap_FloatColor_linen_get, SWIG_Lua_set_immutable }, - { "maroon", _wrap_FloatColor_maroon_get, SWIG_Lua_set_immutable }, - { "mediumAquaMarine", _wrap_FloatColor_mediumAquaMarine_get, SWIG_Lua_set_immutable }, - { "mediumBlue", _wrap_FloatColor_mediumBlue_get, SWIG_Lua_set_immutable }, - { "mediumOrchid", _wrap_FloatColor_mediumOrchid_get, SWIG_Lua_set_immutable }, - { "mediumPurple", _wrap_FloatColor_mediumPurple_get, SWIG_Lua_set_immutable }, - { "mediumSeaGreen", _wrap_FloatColor_mediumSeaGreen_get, SWIG_Lua_set_immutable }, - { "mediumSlateBlue", _wrap_FloatColor_mediumSlateBlue_get, SWIG_Lua_set_immutable }, - { "mediumSpringGreen", _wrap_FloatColor_mediumSpringGreen_get, SWIG_Lua_set_immutable }, - { "mediumTurquoise", _wrap_FloatColor_mediumTurquoise_get, SWIG_Lua_set_immutable }, - { "mediumVioletRed", _wrap_FloatColor_mediumVioletRed_get, SWIG_Lua_set_immutable }, - { "midnightBlue", _wrap_FloatColor_midnightBlue_get, SWIG_Lua_set_immutable }, - { "mintCream", _wrap_FloatColor_mintCream_get, SWIG_Lua_set_immutable }, - { "mistyRose", _wrap_FloatColor_mistyRose_get, SWIG_Lua_set_immutable }, - { "moccasin", _wrap_FloatColor_moccasin_get, SWIG_Lua_set_immutable }, - { "navajoWhite", _wrap_FloatColor_navajoWhite_get, SWIG_Lua_set_immutable }, - { "navy", _wrap_FloatColor_navy_get, SWIG_Lua_set_immutable }, - { "oldLace", _wrap_FloatColor_oldLace_get, SWIG_Lua_set_immutable }, - { "olive", _wrap_FloatColor_olive_get, SWIG_Lua_set_immutable }, - { "oliveDrab", _wrap_FloatColor_oliveDrab_get, SWIG_Lua_set_immutable }, - { "orange", _wrap_FloatColor_orange_get, SWIG_Lua_set_immutable }, - { "orangeRed", _wrap_FloatColor_orangeRed_get, SWIG_Lua_set_immutable }, - { "orchid", _wrap_FloatColor_orchid_get, SWIG_Lua_set_immutable }, - { "paleGoldenRod", _wrap_FloatColor_paleGoldenRod_get, SWIG_Lua_set_immutable }, - { "paleGreen", _wrap_FloatColor_paleGreen_get, SWIG_Lua_set_immutable }, - { "paleTurquoise", _wrap_FloatColor_paleTurquoise_get, SWIG_Lua_set_immutable }, - { "paleVioletRed", _wrap_FloatColor_paleVioletRed_get, SWIG_Lua_set_immutable }, - { "papayaWhip", _wrap_FloatColor_papayaWhip_get, SWIG_Lua_set_immutable }, - { "peachPuff", _wrap_FloatColor_peachPuff_get, SWIG_Lua_set_immutable }, - { "peru", _wrap_FloatColor_peru_get, SWIG_Lua_set_immutable }, - { "pink", _wrap_FloatColor_pink_get, SWIG_Lua_set_immutable }, - { "plum", _wrap_FloatColor_plum_get, SWIG_Lua_set_immutable }, - { "powderBlue", _wrap_FloatColor_powderBlue_get, SWIG_Lua_set_immutable }, - { "purple", _wrap_FloatColor_purple_get, SWIG_Lua_set_immutable }, - { "rosyBrown", _wrap_FloatColor_rosyBrown_get, SWIG_Lua_set_immutable }, - { "royalBlue", _wrap_FloatColor_royalBlue_get, SWIG_Lua_set_immutable }, - { "saddleBrown", _wrap_FloatColor_saddleBrown_get, SWIG_Lua_set_immutable }, - { "salmon", _wrap_FloatColor_salmon_get, SWIG_Lua_set_immutable }, - { "sandyBrown", _wrap_FloatColor_sandyBrown_get, SWIG_Lua_set_immutable }, - { "seaGreen", _wrap_FloatColor_seaGreen_get, SWIG_Lua_set_immutable }, - { "seaShell", _wrap_FloatColor_seaShell_get, SWIG_Lua_set_immutable }, - { "sienna", _wrap_FloatColor_sienna_get, SWIG_Lua_set_immutable }, - { "silver", _wrap_FloatColor_silver_get, SWIG_Lua_set_immutable }, - { "skyBlue", _wrap_FloatColor_skyBlue_get, SWIG_Lua_set_immutable }, - { "slateBlue", _wrap_FloatColor_slateBlue_get, SWIG_Lua_set_immutable }, - { "slateGray", _wrap_FloatColor_slateGray_get, SWIG_Lua_set_immutable }, - { "slateGrey", _wrap_FloatColor_slateGrey_get, SWIG_Lua_set_immutable }, - { "snow", _wrap_FloatColor_snow_get, SWIG_Lua_set_immutable }, - { "springGreen", _wrap_FloatColor_springGreen_get, SWIG_Lua_set_immutable }, - { "steelBlue", _wrap_FloatColor_steelBlue_get, SWIG_Lua_set_immutable }, - { "blueSteel", _wrap_FloatColor_blueSteel_get, SWIG_Lua_set_immutable }, - { "tan", _wrap_FloatColor_tan_get, SWIG_Lua_set_immutable }, - { "teal", _wrap_FloatColor_teal_get, SWIG_Lua_set_immutable }, - { "thistle", _wrap_FloatColor_thistle_get, SWIG_Lua_set_immutable }, - { "tomato", _wrap_FloatColor_tomato_get, SWIG_Lua_set_immutable }, - { "turquoise", _wrap_FloatColor_turquoise_get, SWIG_Lua_set_immutable }, - { "violet", _wrap_FloatColor_violet_get, SWIG_Lua_set_immutable }, - { "wheat", _wrap_FloatColor_wheat_get, SWIG_Lua_set_immutable }, - { "whiteSmoke", _wrap_FloatColor_whiteSmoke_get, SWIG_Lua_set_immutable }, - { "yellowGreen", _wrap_FloatColor_yellowGreen_get, SWIG_Lua_set_immutable }, - {0,0,0} -}; -static swig_lua_const_info swig_FloatColor_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_FloatColor_Sf_SwigStatic_methods[]= { - { "fromHsb", _wrap_FloatColor_fromHsb}, - { "fromHex", _wrap_FloatColor_fromHex}, - { "limit", _wrap_FloatColor_limit}, - {0,0} -}; -static swig_lua_class* swig_FloatColor_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_FloatColor_Sf_SwigStatic = { - "FloatColor", - swig_FloatColor_Sf_SwigStatic_methods, - swig_FloatColor_Sf_SwigStatic_attributes, - swig_FloatColor_Sf_SwigStatic_constants, - swig_FloatColor_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_FloatColor_bases[] = {0}; -static const char *swig_FloatColor_base_names[] = {0}; -static swig_lua_class _wrap_class_FloatColor = { "FloatColor", "FloatColor", &SWIGTYPE_p_ofColor_T_float_t,_proxy__wrap_new_FloatColor, swig_delete_FloatColor, swig_FloatColor_methods, swig_FloatColor_attributes, &swig_FloatColor_Sf_SwigStatic, swig_FloatColor_meta, swig_FloatColor_bases, swig_FloatColor_base_names }; - -static int _wrap_new_ShortColor__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::ofColor_",0,0) - result = (ofColor_< unsigned short > *)new ofColor_< unsigned short >(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_ShortColor__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - ofColor_< unsigned short > *result = 0 ; SWIG_check_num_args("ofColor_< unsigned short >::ofColor_",4,4) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::ofColor_",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::ofColor_",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< unsigned short >::ofColor_",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofColor_< unsigned short >::ofColor_",4,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - result = (ofColor_< unsigned short > *)new ofColor_< unsigned short >(arg1,arg2,arg3,arg4); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_ShortColor__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; - ofColor_< unsigned short > *result = 0 ; SWIG_check_num_args("ofColor_< unsigned short >::ofColor_",3,3) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::ofColor_",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::ofColor_",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< unsigned short >::ofColor_",3,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - result = (ofColor_< unsigned short > *)new ofColor_< unsigned short >(arg1,arg2,arg3); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_ShortColor__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; - ofColor_< unsigned short > *result = 0 ; SWIG_check_num_args("ofColor_< unsigned short >::ofColor_",2,2) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::ofColor_",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::ofColor_",2,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); result = (ofColor_< unsigned short > *)new ofColor_< unsigned short >(arg1,arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_ShortColor__SWIG_4(lua_State* L) { int SWIG_arg = 0; float arg1 ; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::ofColor_",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::ofColor_",1,"float"); arg1 = (float)lua_tonumber(L, 1); - result = (ofColor_< unsigned short > *)new ofColor_< unsigned short >(arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_ShortColor__SWIG_5(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *arg1 = 0 ; float arg2 ; - ofColor_< unsigned short > *result = 0 ; SWIG_check_num_args("ofColor_< unsigned short >::ofColor_",2,2) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::ofColor_",1,"ofColor_< unsigned short > const &"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::ofColor_",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("new_ShortColor",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } arg2 = (float)lua_tonumber(L, 2); - result = (ofColor_< unsigned short > *)new ofColor_< unsigned short >((ofColor_< unsigned short > const &)*arg1,arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_ShortColor(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_ShortColor__SWIG_0(L);} if (argc == 1) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { - return _wrap_new_ShortColor__SWIG_4(L);} } if (argc == 2) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_new_ShortColor__SWIG_5(L);} } } if (argc == 2) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_new_ShortColor__SWIG_3(L);} } } if (argc == 3) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_new_ShortColor__SWIG_2(L);} } } } if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_new_ShortColor__SWIG_1(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_ShortColor'\n" " Possible C/C++ prototypes are:\n" - " ofColor_< unsigned short >::ofColor_()\n" " ofColor_< unsigned short >::ofColor_(float,float,float,float)\n" - " ofColor_< unsigned short >::ofColor_(float,float,float)\n" " ofColor_< unsigned short >::ofColor_(float,float)\n" - " ofColor_< unsigned short >::ofColor_(float)\n" - " ofColor_< unsigned short >::ofColor_(ofColor_< unsigned short > const &,float)\n"); lua_error(L);return 0; } -static int _wrap_ShortColor_fromHsb__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; - float arg4 ; ofColor_< unsigned short > result; SWIG_check_num_args("ofColor_< unsigned short >::fromHsb",4,4) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::fromHsb",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::fromHsb",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< unsigned short >::fromHsb",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofColor_< unsigned short >::fromHsb",4,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - result = ofColor_< unsigned short >::SWIGTEMPLATEDISAMBIGUATOR fromHsb(arg1,arg2,arg3,arg4); { - ofColor_< unsigned short > * resultptr = new ofColor_< unsigned short >((const ofColor_< unsigned short > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_short_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_fromHsb__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; - ofColor_< unsigned short > result; SWIG_check_num_args("ofColor_< unsigned short >::fromHsb",3,3) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::fromHsb",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::fromHsb",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< unsigned short >::fromHsb",3,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - result = ofColor_< unsigned short >::SWIGTEMPLATEDISAMBIGUATOR fromHsb(arg1,arg2,arg3); { - ofColor_< unsigned short > * resultptr = new ofColor_< unsigned short >((const ofColor_< unsigned short > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_short_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_fromHsb(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_ShortColor_fromHsb__SWIG_1(L);} } } } if (argc == 4) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { - return _wrap_ShortColor_fromHsb__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortColor_fromHsb'\n" " Possible C/C++ prototypes are:\n" - " ofColor_< unsigned short >::fromHsb(float,float,float,float)\n" - " ofColor_< unsigned short >::fromHsb(float,float,float)\n"); lua_error(L);return 0; } -static int _wrap_ShortColor_fromHex__SWIG_0(lua_State* L) { int SWIG_arg = 0; int arg1 ; float arg2 ; - ofColor_< unsigned short > result; SWIG_check_num_args("ofColor_< unsigned short >::fromHex",2,2) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::fromHex",1,"int"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::fromHex",2,"float"); arg1 = (int)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); result = ofColor_< unsigned short >::SWIGTEMPLATEDISAMBIGUATOR fromHex(arg1,arg2); { - ofColor_< unsigned short > * resultptr = new ofColor_< unsigned short >((const ofColor_< unsigned short > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_short_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_fromHex__SWIG_1(lua_State* L) { int SWIG_arg = 0; int arg1 ; ofColor_< unsigned short > result; - SWIG_check_num_args("ofColor_< unsigned short >::fromHex",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::fromHex",1,"int"); arg1 = (int)lua_tonumber(L, 1); - result = ofColor_< unsigned short >::SWIGTEMPLATEDISAMBIGUATOR fromHex(arg1); { - ofColor_< unsigned short > * resultptr = new ofColor_< unsigned short >((const ofColor_< unsigned short > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_short_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_fromHex(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_ShortColor_fromHex__SWIG_1(L);} } if (argc == 2) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_ShortColor_fromHex__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortColor_fromHex'\n" " Possible C/C++ prototypes are:\n" - " ofColor_< unsigned short >::fromHex(int,float)\n" " ofColor_< unsigned short >::fromHex(int)\n"); - lua_error(L);return 0; } -static int _wrap_ShortColor_set__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; float arg2 ; float arg3 ; float arg4 ; float arg5 ; - SWIG_check_num_args("ofColor_< unsigned short >::set",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::set",1,"ofColor_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< unsigned short >::set",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofColor_< unsigned short >::set",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofColor_< unsigned short >::set",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_set",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - (arg1)->set(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_set__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; float arg2 ; float arg3 ; float arg4 ; - SWIG_check_num_args("ofColor_< unsigned short >::set",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::set",1,"ofColor_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< unsigned short >::set",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofColor_< unsigned short >::set",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_set",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); (arg1)->set(arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_set__SWIG_2(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofColor_< unsigned short >::set",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::set",1,"ofColor_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< unsigned short >::set",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_set",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->set(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortColor_set__SWIG_3(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; float arg2 ; - SWIG_check_num_args("ofColor_< unsigned short >::set",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::set",1,"ofColor_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::set",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_set",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->set(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_set__SWIG_4(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; ofColor_< unsigned short > *arg2 = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::set",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::set",1,"ofColor_< unsigned short > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::set",2,"ofColor_< unsigned short > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_set",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_set",2,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - (arg1)->set((ofColor_< unsigned short > const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortColor_set(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_ShortColor_set__SWIG_4(L);} } } if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_ShortColor_set__SWIG_3(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_ShortColor_set__SWIG_2(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_ShortColor_set__SWIG_1(L);} } } } } - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_ShortColor_set__SWIG_0(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortColor_set'\n" " Possible C/C++ prototypes are:\n" - " ofColor_< unsigned short >::set(float,float,float,float)\n" " ofColor_< unsigned short >::set(float,float,float)\n" - " ofColor_< unsigned short >::set(float,float)\n" " ofColor_< unsigned short >::set(float)\n" - " ofColor_< unsigned short >::set(ofColor_< unsigned short > const &)\n"); lua_error(L);return 0; } -static int _wrap_ShortColor_setHex__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; int arg2 ; float arg3 ; - SWIG_check_num_args("ofColor_< unsigned short >::setHex",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::setHex",1,"ofColor_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::setHex",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< unsigned short >::setHex",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_setHex",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->setHex(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortColor_setHex__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; int arg2 ; - SWIG_check_num_args("ofColor_< unsigned short >::setHex",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::setHex",1,"ofColor_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::setHex",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_setHex",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->setHex(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_setHex(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_ShortColor_setHex__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_ShortColor_setHex__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortColor_setHex'\n" " Possible C/C++ prototypes are:\n" - " ofColor_< unsigned short >::setHex(int,float)\n" " ofColor_< unsigned short >::setHex(int)\n"); - lua_error(L);return 0; } -static int _wrap_ShortColor_setHue(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; float arg2 ; - SWIG_check_num_args("ofColor_< unsigned short >::setHue",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::setHue",1,"ofColor_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::setHue",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_setHue",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setHue(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_setHueAngle(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; float arg2 ; - SWIG_check_num_args("ofColor_< unsigned short >::setHueAngle",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::setHueAngle",1,"ofColor_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::setHueAngle",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_setHueAngle",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setHueAngle(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_setSaturation(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; float arg2 ; - SWIG_check_num_args("ofColor_< unsigned short >::setSaturation",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::setSaturation",1,"ofColor_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::setSaturation",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_setSaturation",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setSaturation(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_setBrightness(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; float arg2 ; - SWIG_check_num_args("ofColor_< unsigned short >::setBrightness",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::setBrightness",1,"ofColor_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::setBrightness",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_setBrightness",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setBrightness(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_setHsb__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; float arg2 ; float arg3 ; float arg4 ; float arg5 ; - SWIG_check_num_args("ofColor_< unsigned short >::setHsb",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::setHsb",1,"ofColor_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::setHsb",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< unsigned short >::setHsb",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofColor_< unsigned short >::setHsb",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofColor_< unsigned short >::setHsb",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_setHsb",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - (arg1)->setHsb(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_setHsb__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; float arg2 ; float arg3 ; float arg4 ; - SWIG_check_num_args("ofColor_< unsigned short >::setHsb",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::setHsb",1,"ofColor_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::setHsb",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< unsigned short >::setHsb",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofColor_< unsigned short >::setHsb",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_setHsb",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); (arg1)->setHsb(arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_setHsb(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 4) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_ShortColor_setHsb__SWIG_1(L);} } } } } - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_ShortColor_setHsb__SWIG_0(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortColor_setHsb'\n" " Possible C/C++ prototypes are:\n" - " ofColor_< unsigned short >::setHsb(float,float,float,float)\n" - " ofColor_< unsigned short >::setHsb(float,float,float)\n"); lua_error(L);return 0; } -static int _wrap_ShortColor_clamp(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::clamp",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::clamp",1,"ofColor_< unsigned short > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_clamp",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - result = (ofColor_< unsigned short > *) &(arg1)->clamp(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_invert(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::invert",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::invert",1,"ofColor_< unsigned short > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_invert",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - result = (ofColor_< unsigned short > *) &(arg1)->invert(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_normalize(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::normalize",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::normalize",1,"ofColor_< unsigned short > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_normalize",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - result = (ofColor_< unsigned short > *) &(arg1)->normalize(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_lerp(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; ofColor_< unsigned short > *arg2 = 0 ; float arg3 ; - ofColor_< unsigned short > *result = 0 ; SWIG_check_num_args("ofColor_< unsigned short >::lerp",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::lerp",1,"ofColor_< unsigned short > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::lerp",2,"ofColor_< unsigned short > const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< unsigned short >::lerp",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_lerp",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_lerp",2,SWIGTYPE_p_ofColor_T_unsigned_short_t); } arg3 = (float)lua_tonumber(L, 3); - result = (ofColor_< unsigned short > *) &(arg1)->lerp((ofColor_< unsigned short > const &)*arg2,arg3); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_getClamped(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; ofColor_< unsigned short > result; - SWIG_check_num_args("ofColor_< unsigned short >::getClamped",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::getClamped",1,"ofColor_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_getClamped",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - result = ((ofColor_< unsigned short > const *)arg1)->getClamped(); { - ofColor_< unsigned short > * resultptr = new ofColor_< unsigned short >((const ofColor_< unsigned short > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_short_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_getInverted(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; ofColor_< unsigned short > result; - SWIG_check_num_args("ofColor_< unsigned short >::getInverted",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::getInverted",1,"ofColor_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_getInverted",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - result = ((ofColor_< unsigned short > const *)arg1)->getInverted(); { - ofColor_< unsigned short > * resultptr = new ofColor_< unsigned short >((const ofColor_< unsigned short > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_short_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_getNormalized(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; ofColor_< unsigned short > result; - SWIG_check_num_args("ofColor_< unsigned short >::getNormalized",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::getNormalized",1,"ofColor_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_getNormalized",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - result = ((ofColor_< unsigned short > const *)arg1)->getNormalized(); { - ofColor_< unsigned short > * resultptr = new ofColor_< unsigned short >((const ofColor_< unsigned short > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_short_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_getLerped(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; ofColor_< unsigned short > *arg2 = 0 ; float arg3 ; - ofColor_< unsigned short > result; SWIG_check_num_args("ofColor_< unsigned short >::getLerped",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::getLerped",1,"ofColor_< unsigned short > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::getLerped",2,"ofColor_< unsigned short > const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< unsigned short >::getLerped",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_getLerped",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_getLerped",2,SWIGTYPE_p_ofColor_T_unsigned_short_t); } arg3 = (float)lua_tonumber(L, 3); - result = ((ofColor_< unsigned short > const *)arg1)->getLerped((ofColor_< unsigned short > const &)*arg2,arg3); { - ofColor_< unsigned short > * resultptr = new ofColor_< unsigned short >((const ofColor_< unsigned short > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_short_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_getHex(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; int result; - SWIG_check_num_args("ofColor_< unsigned short >::getHex",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::getHex",1,"ofColor_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_getHex",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - result = (int)((ofColor_< unsigned short > const *)arg1)->getHex(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_getHue(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; float result; - SWIG_check_num_args("ofColor_< unsigned short >::getHue",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::getHue",1,"ofColor_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_getHue",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - result = (float)((ofColor_< unsigned short > const *)arg1)->getHue(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_getHueAngle(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; float result; - SWIG_check_num_args("ofColor_< unsigned short >::getHueAngle",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::getHueAngle",1,"ofColor_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_getHueAngle",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - result = (float)((ofColor_< unsigned short > const *)arg1)->getHueAngle(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_getSaturation(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; float result; - SWIG_check_num_args("ofColor_< unsigned short >::getSaturation",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::getSaturation",1,"ofColor_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_getSaturation",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - result = (float)((ofColor_< unsigned short > const *)arg1)->getSaturation(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_getBrightness(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; float result; - SWIG_check_num_args("ofColor_< unsigned short >::getBrightness",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::getBrightness",1,"ofColor_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_getBrightness",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - result = (float)((ofColor_< unsigned short > const *)arg1)->getBrightness(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_getLightness(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; float result; - SWIG_check_num_args("ofColor_< unsigned short >::getLightness",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::getLightness",1,"ofColor_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_getLightness",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - result = (float)((ofColor_< unsigned short > const *)arg1)->getLightness(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_getHsb(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; float *arg2 = 0 ; float *arg3 = 0 ; float *arg4 = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::getHsb",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::getHsb",1,"ofColor_< unsigned short > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::getHsb",2,"float &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofColor_< unsigned short >::getHsb",3,"float &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofColor_< unsigned short >::getHsb",4,"float &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_getHsb",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("ShortColor_getHsb",2,SWIGTYPE_p_float); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("ShortColor_getHsb",3,SWIGTYPE_p_float); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("ShortColor_getHsb",4,SWIGTYPE_p_float); } - ((ofColor_< unsigned short > const *)arg1)->getHsb(*arg2,*arg3,*arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortColor_limit(lua_State* L) { int SWIG_arg = 0; float result; - SWIG_check_num_args("ofColor_< unsigned short >::limit",0,0) - result = (float)ofColor_< unsigned short >::SWIGTEMPLATEDISAMBIGUATOR limit(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor___eq(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; ofColor_< unsigned short > *arg2 = 0 ; bool result; - SWIG_check_num_args("ofColor_< unsigned short >::operator ==",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::operator ==",1,"ofColor_< unsigned short > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::operator ==",2,"ofColor_< unsigned short > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor___eq",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor___eq",2,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - result = (bool)((ofColor_< unsigned short > const *)arg1)->operator ==((ofColor_< unsigned short > const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor___add__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; ofColor_< unsigned short > *arg2 = 0 ; - ofColor_< unsigned short > result; SWIG_check_num_args("ofColor_< unsigned short >::operator +",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::operator +",1,"ofColor_< unsigned short > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::operator +",2,"ofColor_< unsigned short > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor___add",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor___add",2,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - result = ((ofColor_< unsigned short > const *)arg1)->operator +((ofColor_< unsigned short > const &)*arg2); { - ofColor_< unsigned short > * resultptr = new ofColor_< unsigned short >((const ofColor_< unsigned short > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_short_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor___add__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; float *arg2 = 0 ; float temp2 ; - ofColor_< unsigned short > result; SWIG_check_num_args("ofColor_< unsigned short >::operator +",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::operator +",1,"ofColor_< unsigned short > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::operator +",2,"float const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor___add",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } temp2=(float)lua_tonumber(L,2); arg2=&temp2; - result = ((ofColor_< unsigned short > const *)arg1)->operator +((float const &)*arg2); { - ofColor_< unsigned short > * resultptr = new ofColor_< unsigned short >((const ofColor_< unsigned short > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_short_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor___add(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_ShortColor___add__SWIG_0(L);} } } if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_ShortColor___add__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortColor___add'\n" " Possible C/C++ prototypes are:\n" - " ofColor_< unsigned short >::operator +(ofColor_< unsigned short > const &) const\n" - " ofColor_< unsigned short >::operator +(float const &) const\n"); lua_error(L);return 0; } -static int _wrap_ShortColor___sub__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; ofColor_< unsigned short > *arg2 = 0 ; - ofColor_< unsigned short > result; SWIG_check_num_args("ofColor_< unsigned short >::operator -",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::operator -",1,"ofColor_< unsigned short > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::operator -",2,"ofColor_< unsigned short > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor___sub",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor___sub",2,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - result = ((ofColor_< unsigned short > const *)arg1)->operator -((ofColor_< unsigned short > const &)*arg2); { - ofColor_< unsigned short > * resultptr = new ofColor_< unsigned short >((const ofColor_< unsigned short > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_short_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor___sub__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; float *arg2 = 0 ; float temp2 ; - ofColor_< unsigned short > result; SWIG_check_num_args("ofColor_< unsigned short >::operator -",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::operator -",1,"ofColor_< unsigned short > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::operator -",2,"float const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor___sub",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } temp2=(float)lua_tonumber(L,2); arg2=&temp2; - result = ((ofColor_< unsigned short > const *)arg1)->operator -((float const &)*arg2); { - ofColor_< unsigned short > * resultptr = new ofColor_< unsigned short >((const ofColor_< unsigned short > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_short_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor___sub(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_ShortColor___sub__SWIG_0(L);} } } if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_ShortColor___sub__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortColor___sub'\n" " Possible C/C++ prototypes are:\n" - " ofColor_< unsigned short >::operator -(ofColor_< unsigned short > const &) const\n" - " ofColor_< unsigned short >::operator -(float const &) const\n"); lua_error(L);return 0; } -static int _wrap_ShortColor___mul__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; ofColor_< unsigned short > *arg2 = 0 ; - ofColor_< unsigned short > result; SWIG_check_num_args("ofColor_< unsigned short >::operator *",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::operator *",1,"ofColor_< unsigned short > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::operator *",2,"ofColor_< unsigned short > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor___mul",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor___mul",2,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - result = ((ofColor_< unsigned short > const *)arg1)->operator *((ofColor_< unsigned short > const &)*arg2); { - ofColor_< unsigned short > * resultptr = new ofColor_< unsigned short >((const ofColor_< unsigned short > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_short_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor___mul__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; float *arg2 = 0 ; float temp2 ; - ofColor_< unsigned short > result; SWIG_check_num_args("ofColor_< unsigned short >::operator *",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::operator *",1,"ofColor_< unsigned short > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::operator *",2,"float const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor___mul",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } temp2=(float)lua_tonumber(L,2); arg2=&temp2; - result = ((ofColor_< unsigned short > const *)arg1)->operator *((float const &)*arg2); { - ofColor_< unsigned short > * resultptr = new ofColor_< unsigned short >((const ofColor_< unsigned short > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_short_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor___mul(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_ShortColor___mul__SWIG_0(L);} } } if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_ShortColor___mul__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortColor___mul'\n" " Possible C/C++ prototypes are:\n" - " ofColor_< unsigned short >::operator *(ofColor_< unsigned short > const &) const\n" - " ofColor_< unsigned short >::operator *(float const &) const\n"); lua_error(L);return 0; } -static int _wrap_ShortColor___div__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; ofColor_< unsigned short > *arg2 = 0 ; - ofColor_< unsigned short > result; SWIG_check_num_args("ofColor_< unsigned short >::operator /",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::operator /",1,"ofColor_< unsigned short > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::operator /",2,"ofColor_< unsigned short > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor___div",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor___div",2,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - result = ((ofColor_< unsigned short > const *)arg1)->operator /((ofColor_< unsigned short > const &)*arg2); { - ofColor_< unsigned short > * resultptr = new ofColor_< unsigned short >((const ofColor_< unsigned short > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_short_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor___div__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; float *arg2 = 0 ; float temp2 ; - ofColor_< unsigned short > result; SWIG_check_num_args("ofColor_< unsigned short >::operator /",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::operator /",1,"ofColor_< unsigned short > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::operator /",2,"float const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor___div",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } temp2=(float)lua_tonumber(L,2); arg2=&temp2; - result = ((ofColor_< unsigned short > const *)arg1)->operator /((float const &)*arg2); { - ofColor_< unsigned short > * resultptr = new ofColor_< unsigned short >((const ofColor_< unsigned short > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_short_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor___div(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_ShortColor___div__SWIG_0(L);} } } if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_ShortColor___div__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortColor___div'\n" " Possible C/C++ prototypes are:\n" - " ofColor_< unsigned short >::operator /(ofColor_< unsigned short > const &) const\n" - " ofColor_< unsigned short >::operator /(float const &) const\n"); lua_error(L);return 0; } -static int _wrap_ShortColor_white_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::white",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::white; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_gray_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::gray",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::gray; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_black_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::black",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::black; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_red_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::red",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::red; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_green_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::green",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::green; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_blue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::blue",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::blue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_cyan_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::cyan",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::cyan; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_magenta_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::magenta",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::magenta; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_yellow_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::yellow",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::yellow; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_aliceBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::aliceBlue",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::aliceBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_antiqueWhite_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::antiqueWhite",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::antiqueWhite; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_aqua_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::aqua",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::aqua; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_aquamarine_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::aquamarine",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::aquamarine; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_azure_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::azure",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::azure; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_beige_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::beige",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::beige; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_bisque_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::bisque",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::bisque; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_blanchedAlmond_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::blanchedAlmond",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::blanchedAlmond; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_blueViolet_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::blueViolet",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::blueViolet; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_brown_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::brown",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::brown; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_burlyWood_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::burlyWood",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::burlyWood; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_cadetBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::cadetBlue",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::cadetBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_chartreuse_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::chartreuse",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::chartreuse; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_chocolate_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::chocolate",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::chocolate; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_coral_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::coral",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::coral; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_cornflowerBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::cornflowerBlue",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::cornflowerBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_cornsilk_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::cornsilk",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::cornsilk; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_crimson_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::crimson",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::crimson; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_darkBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::darkBlue",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::darkBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_darkCyan_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::darkCyan",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::darkCyan; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_darkGoldenRod_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::darkGoldenRod",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::darkGoldenRod; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_darkGray_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::darkGray",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::darkGray; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_darkGrey_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::darkGrey",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::darkGrey; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_darkGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::darkGreen",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::darkGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_darkKhaki_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::darkKhaki",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::darkKhaki; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_darkMagenta_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::darkMagenta",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::darkMagenta; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_darkOliveGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::darkOliveGreen",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::darkOliveGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_darkorange_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::darkorange",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::darkorange; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_darkOrchid_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::darkOrchid",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::darkOrchid; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_darkRed_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::darkRed",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::darkRed; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_darkSalmon_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::darkSalmon",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::darkSalmon; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_darkSeaGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::darkSeaGreen",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::darkSeaGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_darkSlateBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::darkSlateBlue",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::darkSlateBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_darkSlateGray_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::darkSlateGray",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::darkSlateGray; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_darkSlateGrey_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::darkSlateGrey",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::darkSlateGrey; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_darkTurquoise_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::darkTurquoise",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::darkTurquoise; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_darkViolet_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::darkViolet",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::darkViolet; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_deepPink_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::deepPink",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::deepPink; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_deepSkyBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::deepSkyBlue",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::deepSkyBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_dimGray_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::dimGray",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::dimGray; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_dimGrey_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::dimGrey",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::dimGrey; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_dodgerBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::dodgerBlue",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::dodgerBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_fireBrick_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::fireBrick",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::fireBrick; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_floralWhite_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::floralWhite",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::floralWhite; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_forestGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::forestGreen",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::forestGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_fuchsia_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::fuchsia",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::fuchsia; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_gainsboro_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::gainsboro",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::gainsboro; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_ghostWhite_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::ghostWhite",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::ghostWhite; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_gold_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::gold",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::gold; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_goldenRod_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::goldenRod",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::goldenRod; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_grey_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::grey",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::grey; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_greenYellow_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::greenYellow",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::greenYellow; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_honeyDew_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::honeyDew",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::honeyDew; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_hotPink_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::hotPink",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::hotPink; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_indianRed_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::indianRed",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::indianRed; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_indigo_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::indigo",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::indigo; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_ivory_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::ivory",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::ivory; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_khaki_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::khaki",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::khaki; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_lavender_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::lavender",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::lavender; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_lavenderBlush_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::lavenderBlush",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::lavenderBlush; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_lawnGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::lawnGreen",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::lawnGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_lemonChiffon_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::lemonChiffon",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::lemonChiffon; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_lightBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::lightBlue",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::lightBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_lightCoral_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::lightCoral",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::lightCoral; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_lightCyan_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::lightCyan",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::lightCyan; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_lightGoldenRodYellow_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::lightGoldenRodYellow",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::lightGoldenRodYellow; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_lightGray_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::lightGray",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::lightGray; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_lightGrey_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::lightGrey",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::lightGrey; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_lightGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::lightGreen",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::lightGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_lightPink_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::lightPink",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::lightPink; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_lightSalmon_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::lightSalmon",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::lightSalmon; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_lightSeaGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::lightSeaGreen",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::lightSeaGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_lightSkyBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::lightSkyBlue",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::lightSkyBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_lightSlateGray_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::lightSlateGray",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::lightSlateGray; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_lightSlateGrey_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::lightSlateGrey",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::lightSlateGrey; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_lightSteelBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::lightSteelBlue",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::lightSteelBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_lightYellow_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::lightYellow",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::lightYellow; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_lime_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::lime",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::lime; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_limeGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::limeGreen",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::limeGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_linen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::linen",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::linen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_maroon_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::maroon",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::maroon; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_mediumAquaMarine_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::mediumAquaMarine",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::mediumAquaMarine; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_mediumBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::mediumBlue",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::mediumBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_mediumOrchid_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::mediumOrchid",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::mediumOrchid; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_mediumPurple_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::mediumPurple",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::mediumPurple; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_mediumSeaGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::mediumSeaGreen",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::mediumSeaGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_mediumSlateBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::mediumSlateBlue",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::mediumSlateBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_mediumSpringGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::mediumSpringGreen",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::mediumSpringGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_mediumTurquoise_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::mediumTurquoise",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::mediumTurquoise; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_mediumVioletRed_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::mediumVioletRed",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::mediumVioletRed; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_midnightBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::midnightBlue",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::midnightBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_mintCream_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::mintCream",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::mintCream; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_mistyRose_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::mistyRose",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::mistyRose; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_moccasin_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::moccasin",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::moccasin; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_navajoWhite_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::navajoWhite",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::navajoWhite; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_navy_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::navy",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::navy; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_oldLace_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::oldLace",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::oldLace; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_olive_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::olive",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::olive; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_oliveDrab_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::oliveDrab",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::oliveDrab; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_orange_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::orange",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::orange; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_orangeRed_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::orangeRed",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::orangeRed; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_orchid_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::orchid",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::orchid; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_paleGoldenRod_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::paleGoldenRod",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::paleGoldenRod; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_paleGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::paleGreen",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::paleGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_paleTurquoise_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::paleTurquoise",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::paleTurquoise; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_paleVioletRed_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::paleVioletRed",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::paleVioletRed; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_papayaWhip_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::papayaWhip",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::papayaWhip; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_peachPuff_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::peachPuff",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::peachPuff; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_peru_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::peru",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::peru; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_pink_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::pink",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::pink; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_plum_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::plum",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::plum; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_powderBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::powderBlue",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::powderBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_purple_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::purple",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::purple; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_rosyBrown_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::rosyBrown",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::rosyBrown; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_royalBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::royalBlue",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::royalBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_saddleBrown_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::saddleBrown",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::saddleBrown; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_salmon_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::salmon",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::salmon; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_sandyBrown_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::sandyBrown",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::sandyBrown; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_seaGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::seaGreen",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::seaGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_seaShell_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::seaShell",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::seaShell; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_sienna_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::sienna",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::sienna; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_silver_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::silver",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::silver; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_skyBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::skyBlue",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::skyBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_slateBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::slateBlue",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::slateBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_slateGray_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::slateGray",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::slateGray; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_slateGrey_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::slateGrey",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::slateGrey; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_snow_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::snow",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::snow; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_springGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::springGreen",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::springGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_steelBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::steelBlue",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::steelBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_blueSteel_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::blueSteel",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::blueSteel; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_tan_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::tan",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::tan; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_teal_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::teal",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::teal; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_thistle_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::thistle",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::thistle; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_tomato_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::tomato",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::tomato; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_turquoise_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::turquoise",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::turquoise; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_violet_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::violet",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::violet; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_wheat_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::wheat",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::wheat; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_whiteSmoke_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::whiteSmoke",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::whiteSmoke; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_yellowGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::yellowGreen",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::yellowGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_getR(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; unsigned short result; - SWIG_check_num_args("ofColor_< unsigned short >::getR",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::getR",1,"ofColor_< unsigned short > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_getR",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - result = (unsigned short)ofColor__Sl_unsigned_SS_short_Sg__getR(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_getG(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; unsigned short result; - SWIG_check_num_args("ofColor_< unsigned short >::getG",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::getG",1,"ofColor_< unsigned short > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_getG",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - result = (unsigned short)ofColor__Sl_unsigned_SS_short_Sg__getG(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_getB(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; unsigned short result; - SWIG_check_num_args("ofColor_< unsigned short >::getB",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::getB",1,"ofColor_< unsigned short > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_getB",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - result = (unsigned short)ofColor__Sl_unsigned_SS_short_Sg__getB(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_getA(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; unsigned short result; - SWIG_check_num_args("ofColor_< unsigned short >::getA",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::getA",1,"ofColor_< unsigned short > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_getA",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - result = (unsigned short)ofColor__Sl_unsigned_SS_short_Sg__getA(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_setR(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; unsigned short arg2 ; - SWIG_check_num_args("ofColor_< unsigned short >::setR",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::setR",1,"ofColor_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::setR",2,"unsigned short"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_setR",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned short)lua_tonumber(L, 2); - ofColor__Sl_unsigned_SS_short_Sg__setR(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_setG(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; unsigned short arg2 ; - SWIG_check_num_args("ofColor_< unsigned short >::setG",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::setG",1,"ofColor_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::setG",2,"unsigned short"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_setG",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned short)lua_tonumber(L, 2); - ofColor__Sl_unsigned_SS_short_Sg__setG(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_setB(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; unsigned short arg2 ; - SWIG_check_num_args("ofColor_< unsigned short >::setB",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::setB",1,"ofColor_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::setB",2,"unsigned short"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_setB",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned short)lua_tonumber(L, 2); - ofColor__Sl_unsigned_SS_short_Sg__setB(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_setA(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; unsigned short arg2 ; - SWIG_check_num_args("ofColor_< unsigned short >::setA",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::setA",1,"ofColor_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::setA",2,"unsigned short"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_setA",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned short)lua_tonumber(L, 2); - ofColor__Sl_unsigned_SS_short_Sg__setA(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor___tostring(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; char *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::__str__",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::__str__",1,"ofColor_< unsigned short > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor___tostring",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - result = (char *)ofColor__Sl_unsigned_SS_short_Sg____str__(arg1); lua_pushstring(L,(const char *)result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_r_set(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; unsigned short arg2 ; - SWIG_check_num_args("ofColor_< unsigned short >::r",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::r",1,"ofColor_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::r",2,"unsigned short"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_r_set",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned short)lua_tonumber(L, 2); - ofColor__Sl_unsigned_SS_short_Sg__r_set(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_r_get(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; unsigned short result; - SWIG_check_num_args("ofColor_< unsigned short >::r",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::r",1,"ofColor_< unsigned short > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_r_get",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - result = (unsigned short)ofColor__Sl_unsigned_SS_short_Sg__r_get(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_g_set(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; unsigned short arg2 ; - SWIG_check_num_args("ofColor_< unsigned short >::g",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::g",1,"ofColor_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::g",2,"unsigned short"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_g_set",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned short)lua_tonumber(L, 2); - ofColor__Sl_unsigned_SS_short_Sg__g_set(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_g_get(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; unsigned short result; - SWIG_check_num_args("ofColor_< unsigned short >::g",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::g",1,"ofColor_< unsigned short > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_g_get",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - result = (unsigned short)ofColor__Sl_unsigned_SS_short_Sg__g_get(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_b_set(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; unsigned short arg2 ; - SWIG_check_num_args("ofColor_< unsigned short >::b",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::b",1,"ofColor_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::b",2,"unsigned short"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_b_set",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned short)lua_tonumber(L, 2); - ofColor__Sl_unsigned_SS_short_Sg__b_set(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_b_get(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; unsigned short result; - SWIG_check_num_args("ofColor_< unsigned short >::b",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::b",1,"ofColor_< unsigned short > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_b_get",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - result = (unsigned short)ofColor__Sl_unsigned_SS_short_Sg__b_get(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_a_set(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; unsigned short arg2 ; - SWIG_check_num_args("ofColor_< unsigned short >::a",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::a",1,"ofColor_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::a",2,"unsigned short"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_a_set",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned short)lua_tonumber(L, 2); - ofColor__Sl_unsigned_SS_short_Sg__a_set(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_a_get(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; unsigned short result; - SWIG_check_num_args("ofColor_< unsigned short >::a",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::a",1,"ofColor_< unsigned short > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_a_get",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - result = (unsigned short)ofColor__Sl_unsigned_SS_short_Sg__a_get(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_ShortColor(void *obj) { -ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) obj; -delete arg1; -} -static int _proxy__wrap_new_ShortColor(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_ShortColor); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_ShortColor_attributes[] = { - { "r", _wrap_ShortColor_r_get, _wrap_ShortColor_r_set }, - { "g", _wrap_ShortColor_g_get, _wrap_ShortColor_g_set }, - { "b", _wrap_ShortColor_b_get, _wrap_ShortColor_b_set }, - { "a", _wrap_ShortColor_a_get, _wrap_ShortColor_a_set }, - {0,0,0} -}; -static swig_lua_method swig_ShortColor_methods[]= { - { "set", _wrap_ShortColor_set}, - { "setHex", _wrap_ShortColor_setHex}, - { "setHue", _wrap_ShortColor_setHue}, - { "setHueAngle", _wrap_ShortColor_setHueAngle}, - { "setSaturation", _wrap_ShortColor_setSaturation}, - { "setBrightness", _wrap_ShortColor_setBrightness}, - { "setHsb", _wrap_ShortColor_setHsb}, - { "clamp", _wrap_ShortColor_clamp}, - { "invert", _wrap_ShortColor_invert}, - { "normalize", _wrap_ShortColor_normalize}, - { "lerp", _wrap_ShortColor_lerp}, - { "getClamped", _wrap_ShortColor_getClamped}, - { "getInverted", _wrap_ShortColor_getInverted}, - { "getNormalized", _wrap_ShortColor_getNormalized}, - { "getLerped", _wrap_ShortColor_getLerped}, - { "getHex", _wrap_ShortColor_getHex}, - { "getHue", _wrap_ShortColor_getHue}, - { "getHueAngle", _wrap_ShortColor_getHueAngle}, - { "getSaturation", _wrap_ShortColor_getSaturation}, - { "getBrightness", _wrap_ShortColor_getBrightness}, - { "getLightness", _wrap_ShortColor_getLightness}, - { "getHsb", _wrap_ShortColor_getHsb}, - { "__eq", _wrap_ShortColor___eq}, - { "__add", _wrap_ShortColor___add}, - { "__sub", _wrap_ShortColor___sub}, - { "__mul", _wrap_ShortColor___mul}, - { "__div", _wrap_ShortColor___div}, - { "getR", _wrap_ShortColor_getR}, - { "getG", _wrap_ShortColor_getG}, - { "getB", _wrap_ShortColor_getB}, - { "getA", _wrap_ShortColor_getA}, - { "setR", _wrap_ShortColor_setR}, - { "setG", _wrap_ShortColor_setG}, - { "setB", _wrap_ShortColor_setB}, - { "setA", _wrap_ShortColor_setA}, - { "__tostring", _wrap_ShortColor___tostring}, - {0,0} -}; -static swig_lua_method swig_ShortColor_meta[] = { - { "__eq", _wrap_ShortColor___eq}, - { "__add", _wrap_ShortColor___add}, - { "__sub", _wrap_ShortColor___sub}, - { "__mul", _wrap_ShortColor___mul}, - { "__div", _wrap_ShortColor___div}, - { "__tostring", _wrap_ShortColor___tostring}, - {0,0} -}; - -static swig_lua_attribute swig_ShortColor_Sf_SwigStatic_attributes[] = { - { "white", _wrap_ShortColor_white_get, SWIG_Lua_set_immutable }, - { "gray", _wrap_ShortColor_gray_get, SWIG_Lua_set_immutable }, - { "black", _wrap_ShortColor_black_get, SWIG_Lua_set_immutable }, - { "red", _wrap_ShortColor_red_get, SWIG_Lua_set_immutable }, - { "green", _wrap_ShortColor_green_get, SWIG_Lua_set_immutable }, - { "blue", _wrap_ShortColor_blue_get, SWIG_Lua_set_immutable }, - { "cyan", _wrap_ShortColor_cyan_get, SWIG_Lua_set_immutable }, - { "magenta", _wrap_ShortColor_magenta_get, SWIG_Lua_set_immutable }, - { "yellow", _wrap_ShortColor_yellow_get, SWIG_Lua_set_immutable }, - { "aliceBlue", _wrap_ShortColor_aliceBlue_get, SWIG_Lua_set_immutable }, - { "antiqueWhite", _wrap_ShortColor_antiqueWhite_get, SWIG_Lua_set_immutable }, - { "aqua", _wrap_ShortColor_aqua_get, SWIG_Lua_set_immutable }, - { "aquamarine", _wrap_ShortColor_aquamarine_get, SWIG_Lua_set_immutable }, - { "azure", _wrap_ShortColor_azure_get, SWIG_Lua_set_immutable }, - { "beige", _wrap_ShortColor_beige_get, SWIG_Lua_set_immutable }, - { "bisque", _wrap_ShortColor_bisque_get, SWIG_Lua_set_immutable }, - { "blanchedAlmond", _wrap_ShortColor_blanchedAlmond_get, SWIG_Lua_set_immutable }, - { "blueViolet", _wrap_ShortColor_blueViolet_get, SWIG_Lua_set_immutable }, - { "brown", _wrap_ShortColor_brown_get, SWIG_Lua_set_immutable }, - { "burlyWood", _wrap_ShortColor_burlyWood_get, SWIG_Lua_set_immutable }, - { "cadetBlue", _wrap_ShortColor_cadetBlue_get, SWIG_Lua_set_immutable }, - { "chartreuse", _wrap_ShortColor_chartreuse_get, SWIG_Lua_set_immutable }, - { "chocolate", _wrap_ShortColor_chocolate_get, SWIG_Lua_set_immutable }, - { "coral", _wrap_ShortColor_coral_get, SWIG_Lua_set_immutable }, - { "cornflowerBlue", _wrap_ShortColor_cornflowerBlue_get, SWIG_Lua_set_immutable }, - { "cornsilk", _wrap_ShortColor_cornsilk_get, SWIG_Lua_set_immutable }, - { "crimson", _wrap_ShortColor_crimson_get, SWIG_Lua_set_immutable }, - { "darkBlue", _wrap_ShortColor_darkBlue_get, SWIG_Lua_set_immutable }, - { "darkCyan", _wrap_ShortColor_darkCyan_get, SWIG_Lua_set_immutable }, - { "darkGoldenRod", _wrap_ShortColor_darkGoldenRod_get, SWIG_Lua_set_immutable }, - { "darkGray", _wrap_ShortColor_darkGray_get, SWIG_Lua_set_immutable }, - { "darkGrey", _wrap_ShortColor_darkGrey_get, SWIG_Lua_set_immutable }, - { "darkGreen", _wrap_ShortColor_darkGreen_get, SWIG_Lua_set_immutable }, - { "darkKhaki", _wrap_ShortColor_darkKhaki_get, SWIG_Lua_set_immutable }, - { "darkMagenta", _wrap_ShortColor_darkMagenta_get, SWIG_Lua_set_immutable }, - { "darkOliveGreen", _wrap_ShortColor_darkOliveGreen_get, SWIG_Lua_set_immutable }, - { "darkorange", _wrap_ShortColor_darkorange_get, SWIG_Lua_set_immutable }, - { "darkOrchid", _wrap_ShortColor_darkOrchid_get, SWIG_Lua_set_immutable }, - { "darkRed", _wrap_ShortColor_darkRed_get, SWIG_Lua_set_immutable }, - { "darkSalmon", _wrap_ShortColor_darkSalmon_get, SWIG_Lua_set_immutable }, - { "darkSeaGreen", _wrap_ShortColor_darkSeaGreen_get, SWIG_Lua_set_immutable }, - { "darkSlateBlue", _wrap_ShortColor_darkSlateBlue_get, SWIG_Lua_set_immutable }, - { "darkSlateGray", _wrap_ShortColor_darkSlateGray_get, SWIG_Lua_set_immutable }, - { "darkSlateGrey", _wrap_ShortColor_darkSlateGrey_get, SWIG_Lua_set_immutable }, - { "darkTurquoise", _wrap_ShortColor_darkTurquoise_get, SWIG_Lua_set_immutable }, - { "darkViolet", _wrap_ShortColor_darkViolet_get, SWIG_Lua_set_immutable }, - { "deepPink", _wrap_ShortColor_deepPink_get, SWIG_Lua_set_immutable }, - { "deepSkyBlue", _wrap_ShortColor_deepSkyBlue_get, SWIG_Lua_set_immutable }, - { "dimGray", _wrap_ShortColor_dimGray_get, SWIG_Lua_set_immutable }, - { "dimGrey", _wrap_ShortColor_dimGrey_get, SWIG_Lua_set_immutable }, - { "dodgerBlue", _wrap_ShortColor_dodgerBlue_get, SWIG_Lua_set_immutable }, - { "fireBrick", _wrap_ShortColor_fireBrick_get, SWIG_Lua_set_immutable }, - { "floralWhite", _wrap_ShortColor_floralWhite_get, SWIG_Lua_set_immutable }, - { "forestGreen", _wrap_ShortColor_forestGreen_get, SWIG_Lua_set_immutable }, - { "fuchsia", _wrap_ShortColor_fuchsia_get, SWIG_Lua_set_immutable }, - { "gainsboro", _wrap_ShortColor_gainsboro_get, SWIG_Lua_set_immutable }, - { "ghostWhite", _wrap_ShortColor_ghostWhite_get, SWIG_Lua_set_immutable }, - { "gold", _wrap_ShortColor_gold_get, SWIG_Lua_set_immutable }, - { "goldenRod", _wrap_ShortColor_goldenRod_get, SWIG_Lua_set_immutable }, - { "grey", _wrap_ShortColor_grey_get, SWIG_Lua_set_immutable }, - { "greenYellow", _wrap_ShortColor_greenYellow_get, SWIG_Lua_set_immutable }, - { "honeyDew", _wrap_ShortColor_honeyDew_get, SWIG_Lua_set_immutable }, - { "hotPink", _wrap_ShortColor_hotPink_get, SWIG_Lua_set_immutable }, - { "indianRed", _wrap_ShortColor_indianRed_get, SWIG_Lua_set_immutable }, - { "indigo", _wrap_ShortColor_indigo_get, SWIG_Lua_set_immutable }, - { "ivory", _wrap_ShortColor_ivory_get, SWIG_Lua_set_immutable }, - { "khaki", _wrap_ShortColor_khaki_get, SWIG_Lua_set_immutable }, - { "lavender", _wrap_ShortColor_lavender_get, SWIG_Lua_set_immutable }, - { "lavenderBlush", _wrap_ShortColor_lavenderBlush_get, SWIG_Lua_set_immutable }, - { "lawnGreen", _wrap_ShortColor_lawnGreen_get, SWIG_Lua_set_immutable }, - { "lemonChiffon", _wrap_ShortColor_lemonChiffon_get, SWIG_Lua_set_immutable }, - { "lightBlue", _wrap_ShortColor_lightBlue_get, SWIG_Lua_set_immutable }, - { "lightCoral", _wrap_ShortColor_lightCoral_get, SWIG_Lua_set_immutable }, - { "lightCyan", _wrap_ShortColor_lightCyan_get, SWIG_Lua_set_immutable }, - { "lightGoldenRodYellow", _wrap_ShortColor_lightGoldenRodYellow_get, SWIG_Lua_set_immutable }, - { "lightGray", _wrap_ShortColor_lightGray_get, SWIG_Lua_set_immutable }, - { "lightGrey", _wrap_ShortColor_lightGrey_get, SWIG_Lua_set_immutable }, - { "lightGreen", _wrap_ShortColor_lightGreen_get, SWIG_Lua_set_immutable }, - { "lightPink", _wrap_ShortColor_lightPink_get, SWIG_Lua_set_immutable }, - { "lightSalmon", _wrap_ShortColor_lightSalmon_get, SWIG_Lua_set_immutable }, - { "lightSeaGreen", _wrap_ShortColor_lightSeaGreen_get, SWIG_Lua_set_immutable }, - { "lightSkyBlue", _wrap_ShortColor_lightSkyBlue_get, SWIG_Lua_set_immutable }, - { "lightSlateGray", _wrap_ShortColor_lightSlateGray_get, SWIG_Lua_set_immutable }, - { "lightSlateGrey", _wrap_ShortColor_lightSlateGrey_get, SWIG_Lua_set_immutable }, - { "lightSteelBlue", _wrap_ShortColor_lightSteelBlue_get, SWIG_Lua_set_immutable }, - { "lightYellow", _wrap_ShortColor_lightYellow_get, SWIG_Lua_set_immutable }, - { "lime", _wrap_ShortColor_lime_get, SWIG_Lua_set_immutable }, - { "limeGreen", _wrap_ShortColor_limeGreen_get, SWIG_Lua_set_immutable }, - { "linen", _wrap_ShortColor_linen_get, SWIG_Lua_set_immutable }, - { "maroon", _wrap_ShortColor_maroon_get, SWIG_Lua_set_immutable }, - { "mediumAquaMarine", _wrap_ShortColor_mediumAquaMarine_get, SWIG_Lua_set_immutable }, - { "mediumBlue", _wrap_ShortColor_mediumBlue_get, SWIG_Lua_set_immutable }, - { "mediumOrchid", _wrap_ShortColor_mediumOrchid_get, SWIG_Lua_set_immutable }, - { "mediumPurple", _wrap_ShortColor_mediumPurple_get, SWIG_Lua_set_immutable }, - { "mediumSeaGreen", _wrap_ShortColor_mediumSeaGreen_get, SWIG_Lua_set_immutable }, - { "mediumSlateBlue", _wrap_ShortColor_mediumSlateBlue_get, SWIG_Lua_set_immutable }, - { "mediumSpringGreen", _wrap_ShortColor_mediumSpringGreen_get, SWIG_Lua_set_immutable }, - { "mediumTurquoise", _wrap_ShortColor_mediumTurquoise_get, SWIG_Lua_set_immutable }, - { "mediumVioletRed", _wrap_ShortColor_mediumVioletRed_get, SWIG_Lua_set_immutable }, - { "midnightBlue", _wrap_ShortColor_midnightBlue_get, SWIG_Lua_set_immutable }, - { "mintCream", _wrap_ShortColor_mintCream_get, SWIG_Lua_set_immutable }, - { "mistyRose", _wrap_ShortColor_mistyRose_get, SWIG_Lua_set_immutable }, - { "moccasin", _wrap_ShortColor_moccasin_get, SWIG_Lua_set_immutable }, - { "navajoWhite", _wrap_ShortColor_navajoWhite_get, SWIG_Lua_set_immutable }, - { "navy", _wrap_ShortColor_navy_get, SWIG_Lua_set_immutable }, - { "oldLace", _wrap_ShortColor_oldLace_get, SWIG_Lua_set_immutable }, - { "olive", _wrap_ShortColor_olive_get, SWIG_Lua_set_immutable }, - { "oliveDrab", _wrap_ShortColor_oliveDrab_get, SWIG_Lua_set_immutable }, - { "orange", _wrap_ShortColor_orange_get, SWIG_Lua_set_immutable }, - { "orangeRed", _wrap_ShortColor_orangeRed_get, SWIG_Lua_set_immutable }, - { "orchid", _wrap_ShortColor_orchid_get, SWIG_Lua_set_immutable }, - { "paleGoldenRod", _wrap_ShortColor_paleGoldenRod_get, SWIG_Lua_set_immutable }, - { "paleGreen", _wrap_ShortColor_paleGreen_get, SWIG_Lua_set_immutable }, - { "paleTurquoise", _wrap_ShortColor_paleTurquoise_get, SWIG_Lua_set_immutable }, - { "paleVioletRed", _wrap_ShortColor_paleVioletRed_get, SWIG_Lua_set_immutable }, - { "papayaWhip", _wrap_ShortColor_papayaWhip_get, SWIG_Lua_set_immutable }, - { "peachPuff", _wrap_ShortColor_peachPuff_get, SWIG_Lua_set_immutable }, - { "peru", _wrap_ShortColor_peru_get, SWIG_Lua_set_immutable }, - { "pink", _wrap_ShortColor_pink_get, SWIG_Lua_set_immutable }, - { "plum", _wrap_ShortColor_plum_get, SWIG_Lua_set_immutable }, - { "powderBlue", _wrap_ShortColor_powderBlue_get, SWIG_Lua_set_immutable }, - { "purple", _wrap_ShortColor_purple_get, SWIG_Lua_set_immutable }, - { "rosyBrown", _wrap_ShortColor_rosyBrown_get, SWIG_Lua_set_immutable }, - { "royalBlue", _wrap_ShortColor_royalBlue_get, SWIG_Lua_set_immutable }, - { "saddleBrown", _wrap_ShortColor_saddleBrown_get, SWIG_Lua_set_immutable }, - { "salmon", _wrap_ShortColor_salmon_get, SWIG_Lua_set_immutable }, - { "sandyBrown", _wrap_ShortColor_sandyBrown_get, SWIG_Lua_set_immutable }, - { "seaGreen", _wrap_ShortColor_seaGreen_get, SWIG_Lua_set_immutable }, - { "seaShell", _wrap_ShortColor_seaShell_get, SWIG_Lua_set_immutable }, - { "sienna", _wrap_ShortColor_sienna_get, SWIG_Lua_set_immutable }, - { "silver", _wrap_ShortColor_silver_get, SWIG_Lua_set_immutable }, - { "skyBlue", _wrap_ShortColor_skyBlue_get, SWIG_Lua_set_immutable }, - { "slateBlue", _wrap_ShortColor_slateBlue_get, SWIG_Lua_set_immutable }, - { "slateGray", _wrap_ShortColor_slateGray_get, SWIG_Lua_set_immutable }, - { "slateGrey", _wrap_ShortColor_slateGrey_get, SWIG_Lua_set_immutable }, - { "snow", _wrap_ShortColor_snow_get, SWIG_Lua_set_immutable }, - { "springGreen", _wrap_ShortColor_springGreen_get, SWIG_Lua_set_immutable }, - { "steelBlue", _wrap_ShortColor_steelBlue_get, SWIG_Lua_set_immutable }, - { "blueSteel", _wrap_ShortColor_blueSteel_get, SWIG_Lua_set_immutable }, - { "tan", _wrap_ShortColor_tan_get, SWIG_Lua_set_immutable }, - { "teal", _wrap_ShortColor_teal_get, SWIG_Lua_set_immutable }, - { "thistle", _wrap_ShortColor_thistle_get, SWIG_Lua_set_immutable }, - { "tomato", _wrap_ShortColor_tomato_get, SWIG_Lua_set_immutable }, - { "turquoise", _wrap_ShortColor_turquoise_get, SWIG_Lua_set_immutable }, - { "violet", _wrap_ShortColor_violet_get, SWIG_Lua_set_immutable }, - { "wheat", _wrap_ShortColor_wheat_get, SWIG_Lua_set_immutable }, - { "whiteSmoke", _wrap_ShortColor_whiteSmoke_get, SWIG_Lua_set_immutable }, - { "yellowGreen", _wrap_ShortColor_yellowGreen_get, SWIG_Lua_set_immutable }, - {0,0,0} -}; -static swig_lua_const_info swig_ShortColor_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_ShortColor_Sf_SwigStatic_methods[]= { - { "fromHsb", _wrap_ShortColor_fromHsb}, - { "fromHex", _wrap_ShortColor_fromHex}, - { "limit", _wrap_ShortColor_limit}, - {0,0} -}; -static swig_lua_class* swig_ShortColor_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_ShortColor_Sf_SwigStatic = { - "ShortColor", - swig_ShortColor_Sf_SwigStatic_methods, - swig_ShortColor_Sf_SwigStatic_attributes, - swig_ShortColor_Sf_SwigStatic_constants, - swig_ShortColor_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_ShortColor_bases[] = {0}; -static const char *swig_ShortColor_base_names[] = {0}; -static swig_lua_class _wrap_class_ShortColor = { "ShortColor", "ShortColor", &SWIGTYPE_p_ofColor_T_unsigned_short_t,_proxy__wrap_new_ShortColor, swig_delete_ShortColor, swig_ShortColor_methods, swig_ShortColor_attributes, &swig_ShortColor_Sf_SwigStatic, swig_ShortColor_meta, swig_ShortColor_bases, swig_ShortColor_base_names }; - -static int _wrap_new_Rectangle__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofRectangle *result = 0 ; - SWIG_check_num_args("ofRectangle::ofRectangle",0,0) result = (ofRectangle *)new ofRectangle(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofRectangle,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Rectangle__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - ofRectangle *result = 0 ; SWIG_check_num_args("ofRectangle::ofRectangle",4,4) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofRectangle::ofRectangle",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::ofRectangle",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofRectangle::ofRectangle",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofRectangle::ofRectangle",4,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - result = (ofRectangle *)new ofRectangle(arg1,arg2,arg3,arg4); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofRectangle,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Rectangle__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPoint *arg1 = 0 ; float arg2 ; float arg3 ; - ofRectangle *result = 0 ; SWIG_check_num_args("ofRectangle::ofRectangle",3,3) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofRectangle::ofRectangle",1,"ofPoint const &"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::ofRectangle",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofRectangle::ofRectangle",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("new_Rectangle",1,SWIGTYPE_p_ofVec3f); } arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - result = (ofRectangle *)new ofRectangle((ofPoint const &)*arg1,arg2,arg3); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofRectangle,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Rectangle__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = 0 ; ofRectangle *result = 0 ; - SWIG_check_num_args("ofRectangle::ofRectangle",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofRectangle::ofRectangle",1,"ofRectangle const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("new_Rectangle",1,SWIGTYPE_p_ofRectangle); } - result = (ofRectangle *)new ofRectangle((ofRectangle const &)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofRectangle,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Rectangle__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofPoint *arg1 = 0 ; ofPoint *arg2 = 0 ; - ofRectangle *result = 0 ; SWIG_check_num_args("ofRectangle::ofRectangle",2,2) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofRectangle::ofRectangle",1,"ofPoint const &"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::ofRectangle",2,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("new_Rectangle",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("new_Rectangle",2,SWIGTYPE_p_ofVec3f); } - result = (ofRectangle *)new ofRectangle((ofPoint const &)*arg1,(ofPoint const &)*arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofRectangle,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Rectangle(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_Rectangle__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_new_Rectangle__SWIG_3(L);} } if (argc == 2) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_new_Rectangle__SWIG_4(L);} } } if (argc == 3) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_new_Rectangle__SWIG_2(L);} } } } if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_new_Rectangle__SWIG_1(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_Rectangle'\n" " Possible C/C++ prototypes are:\n" - " ofRectangle::ofRectangle()\n" " ofRectangle::ofRectangle(float,float,float,float)\n" - " ofRectangle::ofRectangle(ofPoint const &,float,float)\n" " ofRectangle::ofRectangle(ofRectangle const &)\n" - " ofRectangle::ofRectangle(ofPoint const &,ofPoint const &)\n"); lua_error(L);return 0; } -static int _wrap_Rectangle_set__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float arg2 ; - float arg3 ; float arg4 ; float arg5 ; SWIG_check_num_args("ofRectangle::set",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::set",1,"ofRectangle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofRectangle::set",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofRectangle::set",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofRectangle::set",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_set",1,SWIGTYPE_p_ofRectangle); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - (arg1)->set(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_set__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofPoint *arg2 = 0 ; float arg3 ; float arg4 ; SWIG_check_num_args("ofRectangle::set",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::set",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::set",2,"ofPoint const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofRectangle::set",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofRectangle::set",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_set",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Rectangle_set",2,SWIGTYPE_p_ofVec3f); } arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - (arg1)->set((ofPoint const &)*arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_set__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofRectangle *arg2 = 0 ; SWIG_check_num_args("ofRectangle::set",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::set",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::set",2,"ofRectangle const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_set",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_set",2,SWIGTYPE_p_ofRectangle); } (arg1)->set((ofRectangle const &)*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_set__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofPoint *arg2 = 0 ; ofPoint *arg3 = 0 ; SWIG_check_num_args("ofRectangle::set",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::set",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::set",2,"ofPoint const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofRectangle::set",3,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_set",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Rectangle_set",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Rectangle_set",3,SWIGTYPE_p_ofVec3f); } (arg1)->set((ofPoint const &)*arg2,(ofPoint const &)*arg3); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_set(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle_set__SWIG_2(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle_set__SWIG_3(L);} } } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Rectangle_set__SWIG_1(L);} } } } } if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Rectangle_set__SWIG_0(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Rectangle_set'\n" " Possible C/C++ prototypes are:\n" - " ofRectangle::set(float,float,float,float)\n" " ofRectangle::set(ofPoint const &,float,float)\n" - " ofRectangle::set(ofRectangle const &)\n" " ofRectangle::set(ofPoint const &,ofPoint const &)\n"); - lua_error(L);return 0; } -static int _wrap_Rectangle_setX(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float arg2 ; - SWIG_check_num_args("ofRectangle::setX",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::setX",1,"ofRectangle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::setX",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_setX",1,SWIGTYPE_p_ofRectangle); } arg2 = (float)lua_tonumber(L, 2); (arg1)->setX(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_setY(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float arg2 ; - SWIG_check_num_args("ofRectangle::setY",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::setY",1,"ofRectangle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::setY",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_setY",1,SWIGTYPE_p_ofRectangle); } arg2 = (float)lua_tonumber(L, 2); (arg1)->setY(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_setWidth(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float arg2 ; - SWIG_check_num_args("ofRectangle::setWidth",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::setWidth",1,"ofRectangle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::setWidth",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_setWidth",1,SWIGTYPE_p_ofRectangle); } arg2 = (float)lua_tonumber(L, 2); (arg1)->setWidth(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_setHeight(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float arg2 ; - SWIG_check_num_args("ofRectangle::setHeight",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::setHeight",1,"ofRectangle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::setHeight",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_setHeight",1,SWIGTYPE_p_ofRectangle); } arg2 = (float)lua_tonumber(L, 2); (arg1)->setHeight(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_setPosition__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - float arg2 ; float arg3 ; SWIG_check_num_args("ofRectangle::setPosition",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::setPosition",1,"ofRectangle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::setPosition",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofRectangle::setPosition",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_setPosition",1,SWIGTYPE_p_ofRectangle); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->setPosition(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Rectangle_setPosition__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofPoint *arg2 = 0 ; SWIG_check_num_args("ofRectangle::setPosition",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::setPosition",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::setPosition",2,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_setPosition",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Rectangle_setPosition",2,SWIGTYPE_p_ofVec3f); } (arg1)->setPosition((ofPoint const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_setPosition(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle_setPosition__SWIG_1(L);} } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_Rectangle_setPosition__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Rectangle_setPosition'\n" - " Possible C/C++ prototypes are:\n" " ofRectangle::setPosition(float,float)\n" - " ofRectangle::setPosition(ofPoint const &)\n"); lua_error(L);return 0; } -static int _wrap_Rectangle_setSize(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float arg2 ; - float arg3 ; SWIG_check_num_args("ofRectangle::setSize",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::setSize",1,"ofRectangle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::setSize",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofRectangle::setSize",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_setSize",1,SWIGTYPE_p_ofRectangle); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->setSize(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Rectangle_setFromCenter__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - float arg2 ; float arg3 ; float arg4 ; float arg5 ; SWIG_check_num_args("ofRectangle::setFromCenter",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::setFromCenter",1,"ofRectangle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::setFromCenter",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofRectangle::setFromCenter",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofRectangle::setFromCenter",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofRectangle::setFromCenter",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_setFromCenter",1,SWIGTYPE_p_ofRectangle); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - (arg1)->setFromCenter(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_setFromCenter__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofPoint *arg2 = 0 ; float arg3 ; float arg4 ; SWIG_check_num_args("ofRectangle::setFromCenter",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::setFromCenter",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::setFromCenter",2,"ofPoint const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofRectangle::setFromCenter",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofRectangle::setFromCenter",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_setFromCenter",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Rectangle_setFromCenter",2,SWIGTYPE_p_ofVec3f); } arg3 = (float)lua_tonumber(L, 3); - arg4 = (float)lua_tonumber(L, 4); (arg1)->setFromCenter((ofPoint const &)*arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_setFromCenter(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); - if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Rectangle_setFromCenter__SWIG_1(L);} } } } } if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Rectangle_setFromCenter__SWIG_0(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Rectangle_setFromCenter'\n" - " Possible C/C++ prototypes are:\n" " ofRectangle::setFromCenter(float,float,float,float)\n" - " ofRectangle::setFromCenter(ofPoint const &,float,float)\n"); lua_error(L);return 0; } -static int _wrap_Rectangle_translate__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - float arg2 ; float arg3 ; SWIG_check_num_args("ofRectangle::translate",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::translate",1,"ofRectangle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::translate",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofRectangle::translate",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_translate",1,SWIGTYPE_p_ofRectangle); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->translate(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Rectangle_translate__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofPoint *arg2 = 0 ; SWIG_check_num_args("ofRectangle::translate",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::translate",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::translate",2,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_translate",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Rectangle_translate",2,SWIGTYPE_p_ofVec3f); } (arg1)->translate((ofPoint const &)*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_translate(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle_translate__SWIG_1(L);} } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_Rectangle_translate__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Rectangle_translate'\n" - " Possible C/C++ prototypes are:\n" " ofRectangle::translate(float,float)\n" - " ofRectangle::translate(ofPoint const &)\n"); lua_error(L);return 0; } -static int _wrap_Rectangle_translateX(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float arg2 ; - SWIG_check_num_args("ofRectangle::translateX",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::translateX",1,"ofRectangle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::translateX",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_translateX",1,SWIGTYPE_p_ofRectangle); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->translateX(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_translateY(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float arg2 ; - SWIG_check_num_args("ofRectangle::translateY",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::translateY",1,"ofRectangle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::translateY",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_translateY",1,SWIGTYPE_p_ofRectangle); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->translateY(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_scale__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float arg2 ; - SWIG_check_num_args("ofRectangle::scale",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::scale",1,"ofRectangle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::scale",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_scale",1,SWIGTYPE_p_ofRectangle); } arg2 = (float)lua_tonumber(L, 2); (arg1)->scale(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_scale__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float arg2 ; - float arg3 ; SWIG_check_num_args("ofRectangle::scale",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::scale",1,"ofRectangle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::scale",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofRectangle::scale",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_scale",1,SWIGTYPE_p_ofRectangle); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->scale(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Rectangle_scale__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofPoint *arg2 = 0 ; SWIG_check_num_args("ofRectangle::scale",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::scale",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::scale",2,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_scale",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Rectangle_scale",2,SWIGTYPE_p_ofVec3f); } (arg1)->scale((ofPoint const &)*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_scale(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle_scale__SWIG_2(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Rectangle_scale__SWIG_0(L);} } - } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Rectangle_scale__SWIG_1(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Rectangle_scale'\n" " Possible C/C++ prototypes are:\n" - " ofRectangle::scale(float)\n" " ofRectangle::scale(float,float)\n" " ofRectangle::scale(ofPoint const &)\n"); - lua_error(L);return 0; } -static int _wrap_Rectangle_scaleWidth(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float arg2 ; - SWIG_check_num_args("ofRectangle::scaleWidth",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::scaleWidth",1,"ofRectangle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::scaleWidth",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_scaleWidth",1,SWIGTYPE_p_ofRectangle); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->scaleWidth(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_scaleHeight(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float arg2 ; - SWIG_check_num_args("ofRectangle::scaleHeight",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::scaleHeight",1,"ofRectangle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::scaleHeight",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_scaleHeight",1,SWIGTYPE_p_ofRectangle); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->scaleHeight(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_scaleFromCenter__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - float arg2 ; SWIG_check_num_args("ofRectangle::scaleFromCenter",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::scaleFromCenter",1,"ofRectangle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::scaleFromCenter",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_scaleFromCenter",1,SWIGTYPE_p_ofRectangle); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->scaleFromCenter(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_scaleFromCenter__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - float arg2 ; float arg3 ; SWIG_check_num_args("ofRectangle::scaleFromCenter",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::scaleFromCenter",1,"ofRectangle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::scaleFromCenter",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofRectangle::scaleFromCenter",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_scaleFromCenter",1,SWIGTYPE_p_ofRectangle); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->scaleFromCenter(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Rectangle_scaleFromCenter__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofPoint *arg2 = 0 ; SWIG_check_num_args("ofRectangle::scaleFromCenter",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::scaleFromCenter",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::scaleFromCenter",2,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_scaleFromCenter",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Rectangle_scaleFromCenter",2,SWIGTYPE_p_ofVec3f); } (arg1)->scaleFromCenter((ofPoint const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_scaleFromCenter(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle_scaleFromCenter__SWIG_2(L);} } } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Rectangle_scaleFromCenter__SWIG_0(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Rectangle_scaleFromCenter__SWIG_1(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Rectangle_scaleFromCenter'\n" - " Possible C/C++ prototypes are:\n" " ofRectangle::scaleFromCenter(float)\n" - " ofRectangle::scaleFromCenter(float,float)\n" " ofRectangle::scaleFromCenter(ofPoint const &)\n"); - lua_error(L);return 0; } -static int _wrap_Rectangle_scaleToScaleMode(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofRectangle *arg2 = 0 ; ofScaleMode arg3 ; SWIG_check_num_args("ofRectangle::scaleTo",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::scaleTo",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::scaleTo",2,"ofRectangle const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofRectangle::scaleTo",3,"ofScaleMode"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_scaleToScaleMode",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_scaleToScaleMode",2,SWIGTYPE_p_ofRectangle); } arg3 = (ofScaleMode)(int)lua_tonumber(L, 3); - (arg1)->scaleTo((ofRectangle const &)*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_scaleTo__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofRectangle *arg2 = 0 ; SWIG_check_num_args("ofRectangle::scaleTo",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::scaleTo",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::scaleTo",2,"ofRectangle const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_scaleTo",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_scaleTo",2,SWIGTYPE_p_ofRectangle); } (arg1)->scaleTo((ofRectangle const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_scaleTo__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofRectangle *arg2 = 0 ; ofAspectRatioMode arg3 ; ofAlignHorz arg4 ; ofAlignVert arg5 ; - SWIG_check_num_args("ofRectangle::scaleTo",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::scaleTo",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::scaleTo",2,"ofRectangle const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofRectangle::scaleTo",3,"ofAspectRatioMode"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofRectangle::scaleTo",4,"ofAlignHorz"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofRectangle::scaleTo",5,"ofAlignVert"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_scaleTo",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_scaleTo",2,SWIGTYPE_p_ofRectangle); } arg3 = (ofAspectRatioMode)(int)lua_tonumber(L, 3); - arg4 = (ofAlignHorz)(int)lua_tonumber(L, 4); arg5 = (ofAlignVert)(int)lua_tonumber(L, 5); - (arg1)->scaleTo((ofRectangle const &)*arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Rectangle_scaleTo__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofRectangle *arg2 = 0 ; ofAspectRatioMode arg3 ; ofAlignHorz arg4 ; SWIG_check_num_args("ofRectangle::scaleTo",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::scaleTo",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::scaleTo",2,"ofRectangle const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofRectangle::scaleTo",3,"ofAspectRatioMode"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofRectangle::scaleTo",4,"ofAlignHorz"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_scaleTo",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_scaleTo",2,SWIGTYPE_p_ofRectangle); } arg3 = (ofAspectRatioMode)(int)lua_tonumber(L, 3); - arg4 = (ofAlignHorz)(int)lua_tonumber(L, 4); (arg1)->scaleTo((ofRectangle const &)*arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_scaleToAspectRatio(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofRectangle *arg2 = 0 ; ofAspectRatioMode arg3 ; SWIG_check_num_args("ofRectangle::scaleTo",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::scaleTo",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::scaleTo",2,"ofRectangle const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofRectangle::scaleTo",3,"ofAspectRatioMode"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_scaleToAspectRatio",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_scaleToAspectRatio",2,SWIGTYPE_p_ofRectangle); } - arg3 = (ofAspectRatioMode)(int)lua_tonumber(L, 3); (arg1)->scaleTo((ofRectangle const &)*arg2,arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_scaleTo__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofRectangle *arg2 = 0 ; ofAspectRatioMode arg3 ; ofAlignHorz arg4 ; ofAlignVert arg5 ; ofAlignHorz arg6 ; ofAlignVert arg7 ; - SWIG_check_num_args("ofRectangle::scaleTo",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::scaleTo",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::scaleTo",2,"ofRectangle const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofRectangle::scaleTo",3,"ofAspectRatioMode"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofRectangle::scaleTo",4,"ofAlignHorz"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofRectangle::scaleTo",5,"ofAlignVert"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofRectangle::scaleTo",6,"ofAlignHorz"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofRectangle::scaleTo",7,"ofAlignVert"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_scaleTo",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_scaleTo",2,SWIGTYPE_p_ofRectangle); } arg3 = (ofAspectRatioMode)(int)lua_tonumber(L, 3); - arg4 = (ofAlignHorz)(int)lua_tonumber(L, 4); arg5 = (ofAlignVert)(int)lua_tonumber(L, 5); - arg6 = (ofAlignHorz)(int)lua_tonumber(L, 6); arg7 = (ofAlignVert)(int)lua_tonumber(L, 7); - (arg1)->scaleTo((ofRectangle const &)*arg2,arg3,arg4,arg5,arg6,arg7); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Rectangle_scaleTo(lua_State* L) { int argc; int argv[8]={ 1,2,3,4,5,6,7,8} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle_scaleTo__SWIG_0(L);} } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Rectangle_scaleTo__SWIG_2(L);} } } } } if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_Rectangle_scaleTo__SWIG_1(L);} } } } } } - if (argc == 7) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { { - _v = lua_isnumber(L,argv[6]); } if (_v) { return _wrap_Rectangle_scaleTo__SWIG_3(L);} } } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Rectangle_scaleTo'\n" " Possible C/C++ prototypes are:\n" - " ofRectangle::scaleTo(ofRectangle const &)\n" - " ofRectangle::scaleTo(ofRectangle const &,ofAspectRatioMode,ofAlignHorz,ofAlignVert)\n" - " ofRectangle::scaleTo(ofRectangle const &,ofAspectRatioMode,ofAlignHorz)\n" - " ofRectangle::scaleTo(ofRectangle const &,ofAspectRatioMode,ofAlignHorz,ofAlignVert,ofAlignHorz,ofAlignVert)\n"); - lua_error(L);return 0; } -static int _wrap_Rectangle_alignToHorz__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - float *arg2 = 0 ; ofAlignHorz arg3 ; float temp2 ; SWIG_check_num_args("ofRectangle::alignToHorz",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::alignToHorz",1,"ofRectangle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::alignToHorz",2,"float const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofRectangle::alignToHorz",3,"ofAlignHorz"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_alignToHorz",1,SWIGTYPE_p_ofRectangle); } temp2=(float)lua_tonumber(L,2); arg2=&temp2; - arg3 = (ofAlignHorz)(int)lua_tonumber(L, 3); (arg1)->alignToHorz((float const &)*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_alignToHorz__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - float *arg2 = 0 ; float temp2 ; SWIG_check_num_args("ofRectangle::alignToHorz",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::alignToHorz",1,"ofRectangle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::alignToHorz",2,"float const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_alignToHorz",1,SWIGTYPE_p_ofRectangle); } temp2=(float)lua_tonumber(L,2); arg2=&temp2; - (arg1)->alignToHorz((float const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_alignToHorz__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofRectangle *arg2 = 0 ; ofAlignHorz arg3 ; SWIG_check_num_args("ofRectangle::alignToHorz",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::alignToHorz",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::alignToHorz",2,"ofRectangle const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofRectangle::alignToHorz",3,"ofAlignHorz"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_alignToHorz",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_alignToHorz",2,SWIGTYPE_p_ofRectangle); } arg3 = (ofAlignHorz)(int)lua_tonumber(L, 3); - (arg1)->alignToHorz((ofRectangle const &)*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_alignToHorz__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofRectangle *arg2 = 0 ; SWIG_check_num_args("ofRectangle::alignToHorz",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::alignToHorz",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::alignToHorz",2,"ofRectangle const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_alignToHorz",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_alignToHorz",2,SWIGTYPE_p_ofRectangle); } (arg1)->alignToHorz((ofRectangle const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_alignToHorz__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofRectangle *arg2 = 0 ; ofAlignHorz arg3 ; ofAlignHorz arg4 ; SWIG_check_num_args("ofRectangle::alignToHorz",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::alignToHorz",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::alignToHorz",2,"ofRectangle const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofRectangle::alignToHorz",3,"ofAlignHorz"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofRectangle::alignToHorz",4,"ofAlignHorz"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_alignToHorz",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_alignToHorz",2,SWIGTYPE_p_ofRectangle); } arg3 = (ofAlignHorz)(int)lua_tonumber(L, 3); - arg4 = (ofAlignHorz)(int)lua_tonumber(L, 4); (arg1)->alignToHorz((ofRectangle const &)*arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_alignToHorz(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle_alignToHorz__SWIG_3(L);} } } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Rectangle_alignToHorz__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Rectangle_alignToHorz__SWIG_2(L);} } } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Rectangle_alignToHorz__SWIG_0(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Rectangle_alignToHorz__SWIG_4(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Rectangle_alignToHorz'\n" - " Possible C/C++ prototypes are:\n" " ofRectangle::alignToHorz(float const &,ofAlignHorz)\n" - " ofRectangle::alignToHorz(float const &)\n" " ofRectangle::alignToHorz(ofRectangle const &,ofAlignHorz)\n" - " ofRectangle::alignToHorz(ofRectangle const &)\n" - " ofRectangle::alignToHorz(ofRectangle const &,ofAlignHorz,ofAlignHorz)\n"); lua_error(L);return 0; } -static int _wrap_Rectangle_alignToVert__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - float *arg2 = 0 ; ofAlignVert arg3 ; float temp2 ; SWIG_check_num_args("ofRectangle::alignToVert",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::alignToVert",1,"ofRectangle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::alignToVert",2,"float const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofRectangle::alignToVert",3,"ofAlignVert"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_alignToVert",1,SWIGTYPE_p_ofRectangle); } temp2=(float)lua_tonumber(L,2); arg2=&temp2; - arg3 = (ofAlignVert)(int)lua_tonumber(L, 3); (arg1)->alignToVert((float const &)*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_alignToVert__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - float *arg2 = 0 ; float temp2 ; SWIG_check_num_args("ofRectangle::alignToVert",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::alignToVert",1,"ofRectangle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::alignToVert",2,"float const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_alignToVert",1,SWIGTYPE_p_ofRectangle); } temp2=(float)lua_tonumber(L,2); arg2=&temp2; - (arg1)->alignToVert((float const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_alignToVert__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofRectangle *arg2 = 0 ; ofAlignVert arg3 ; SWIG_check_num_args("ofRectangle::alignToVert",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::alignToVert",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::alignToVert",2,"ofRectangle const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofRectangle::alignToVert",3,"ofAlignVert"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_alignToVert",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_alignToVert",2,SWIGTYPE_p_ofRectangle); } arg3 = (ofAlignVert)(int)lua_tonumber(L, 3); - (arg1)->alignToVert((ofRectangle const &)*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_alignToVert__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofRectangle *arg2 = 0 ; SWIG_check_num_args("ofRectangle::alignToVert",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::alignToVert",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::alignToVert",2,"ofRectangle const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_alignToVert",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_alignToVert",2,SWIGTYPE_p_ofRectangle); } (arg1)->alignToVert((ofRectangle const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_alignToVert__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofRectangle *arg2 = 0 ; ofAlignVert arg3 ; ofAlignVert arg4 ; SWIG_check_num_args("ofRectangle::alignToVert",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::alignToVert",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::alignToVert",2,"ofRectangle const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofRectangle::alignToVert",3,"ofAlignVert"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofRectangle::alignToVert",4,"ofAlignVert"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_alignToVert",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_alignToVert",2,SWIGTYPE_p_ofRectangle); } arg3 = (ofAlignVert)(int)lua_tonumber(L, 3); - arg4 = (ofAlignVert)(int)lua_tonumber(L, 4); (arg1)->alignToVert((ofRectangle const &)*arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_alignToVert(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle_alignToVert__SWIG_3(L);} } } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Rectangle_alignToVert__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Rectangle_alignToVert__SWIG_2(L);} } } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Rectangle_alignToVert__SWIG_0(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Rectangle_alignToVert__SWIG_4(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Rectangle_alignToVert'\n" - " Possible C/C++ prototypes are:\n" " ofRectangle::alignToVert(float const &,ofAlignVert)\n" - " ofRectangle::alignToVert(float const &)\n" " ofRectangle::alignToVert(ofRectangle const &,ofAlignVert)\n" - " ofRectangle::alignToVert(ofRectangle const &)\n" - " ofRectangle::alignToVert(ofRectangle const &,ofAlignVert,ofAlignVert)\n"); lua_error(L);return 0; } -static int _wrap_Rectangle_alignTo__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofPoint *arg2 = 0 ; ofAlignHorz arg3 ; ofAlignVert arg4 ; SWIG_check_num_args("ofRectangle::alignTo",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::alignTo",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::alignTo",2,"ofPoint const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofRectangle::alignTo",3,"ofAlignHorz"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofRectangle::alignTo",4,"ofAlignVert"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_alignTo",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Rectangle_alignTo",2,SWIGTYPE_p_ofVec3f); } arg3 = (ofAlignHorz)(int)lua_tonumber(L, 3); - arg4 = (ofAlignVert)(int)lua_tonumber(L, 4); (arg1)->alignTo((ofPoint const &)*arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_alignTo__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofPoint *arg2 = 0 ; ofAlignHorz arg3 ; SWIG_check_num_args("ofRectangle::alignTo",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::alignTo",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::alignTo",2,"ofPoint const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofRectangle::alignTo",3,"ofAlignHorz"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_alignTo",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Rectangle_alignTo",2,SWIGTYPE_p_ofVec3f); } arg3 = (ofAlignHorz)(int)lua_tonumber(L, 3); - (arg1)->alignTo((ofPoint const &)*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_alignTo__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofPoint *arg2 = 0 ; SWIG_check_num_args("ofRectangle::alignTo",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::alignTo",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::alignTo",2,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_alignTo",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Rectangle_alignTo",2,SWIGTYPE_p_ofVec3f); } (arg1)->alignTo((ofPoint const &)*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_alignTo__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofRectangle *arg2 = 0 ; ofAlignHorz arg3 ; ofAlignVert arg4 ; SWIG_check_num_args("ofRectangle::alignTo",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::alignTo",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::alignTo",2,"ofRectangle const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofRectangle::alignTo",3,"ofAlignHorz"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofRectangle::alignTo",4,"ofAlignVert"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_alignTo",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_alignTo",2,SWIGTYPE_p_ofRectangle); } arg3 = (ofAlignHorz)(int)lua_tonumber(L, 3); - arg4 = (ofAlignVert)(int)lua_tonumber(L, 4); (arg1)->alignTo((ofRectangle const &)*arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_alignTo__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofRectangle *arg2 = 0 ; ofAlignHorz arg3 ; SWIG_check_num_args("ofRectangle::alignTo",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::alignTo",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::alignTo",2,"ofRectangle const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofRectangle::alignTo",3,"ofAlignHorz"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_alignTo",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_alignTo",2,SWIGTYPE_p_ofRectangle); } arg3 = (ofAlignHorz)(int)lua_tonumber(L, 3); - (arg1)->alignTo((ofRectangle const &)*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_alignTo__SWIG_5(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofRectangle *arg2 = 0 ; SWIG_check_num_args("ofRectangle::alignTo",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::alignTo",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::alignTo",2,"ofRectangle const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_alignTo",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_alignTo",2,SWIGTYPE_p_ofRectangle); } (arg1)->alignTo((ofRectangle const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_alignTo__SWIG_6(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofRectangle *arg2 = 0 ; ofAlignHorz arg3 ; ofAlignVert arg4 ; ofAlignHorz arg5 ; ofAlignVert arg6 ; - SWIG_check_num_args("ofRectangle::alignTo",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::alignTo",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::alignTo",2,"ofRectangle const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofRectangle::alignTo",3,"ofAlignHorz"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofRectangle::alignTo",4,"ofAlignVert"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofRectangle::alignTo",5,"ofAlignHorz"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofRectangle::alignTo",6,"ofAlignVert"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_alignTo",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_alignTo",2,SWIGTYPE_p_ofRectangle); } arg3 = (ofAlignHorz)(int)lua_tonumber(L, 3); - arg4 = (ofAlignVert)(int)lua_tonumber(L, 4); arg5 = (ofAlignHorz)(int)lua_tonumber(L, 5); - arg6 = (ofAlignVert)(int)lua_tonumber(L, 6); (arg1)->alignTo((ofRectangle const &)*arg2,arg3,arg4,arg5,arg6); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_alignTo(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle_alignTo__SWIG_2(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle_alignTo__SWIG_5(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Rectangle_alignTo__SWIG_4(L);} - } } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Rectangle_alignTo__SWIG_1(L);} - } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Rectangle_alignTo__SWIG_0(L);} } } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Rectangle_alignTo__SWIG_3(L);} } } } } if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { - return _wrap_Rectangle_alignTo__SWIG_6(L);} } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Rectangle_alignTo'\n" " Possible C/C++ prototypes are:\n" - " ofRectangle::alignTo(ofPoint const &,ofAlignHorz,ofAlignVert)\n" - " ofRectangle::alignTo(ofPoint const &,ofAlignHorz)\n" " ofRectangle::alignTo(ofPoint const &)\n" - " ofRectangle::alignTo(ofRectangle const &,ofAlignHorz,ofAlignVert)\n" - " ofRectangle::alignTo(ofRectangle const &,ofAlignHorz)\n" " ofRectangle::alignTo(ofRectangle const &)\n" - " ofRectangle::alignTo(ofRectangle const &,ofAlignHorz,ofAlignVert,ofAlignHorz,ofAlignVert)\n"); lua_error(L);return 0; } -static int _wrap_Rectangle_inside__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float arg2 ; - float arg3 ; bool result; SWIG_check_num_args("ofRectangle::inside",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::inside",1,"ofRectangle const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::inside",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofRectangle::inside",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_inside",1,SWIGTYPE_p_ofRectangle); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); result = (bool)((ofRectangle const *)arg1)->inside(arg2,arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_inside__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofPoint *arg2 = 0 ; bool result; SWIG_check_num_args("ofRectangle::inside",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::inside",1,"ofRectangle const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::inside",2,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_inside",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Rectangle_inside",2,SWIGTYPE_p_ofVec3f); } - result = (bool)((ofRectangle const *)arg1)->inside((ofPoint const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_inside__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofRectangle *arg2 = 0 ; bool result; SWIG_check_num_args("ofRectangle::inside",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::inside",1,"ofRectangle const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::inside",2,"ofRectangle const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_inside",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_inside",2,SWIGTYPE_p_ofRectangle); } - result = (bool)((ofRectangle const *)arg1)->inside((ofRectangle const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_inside__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofPoint *arg2 = 0 ; ofPoint *arg3 = 0 ; bool result; SWIG_check_num_args("ofRectangle::inside",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::inside",1,"ofRectangle const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::inside",2,"ofPoint const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofRectangle::inside",3,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_inside",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Rectangle_inside",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Rectangle_inside",3,SWIGTYPE_p_ofVec3f); } - result = (bool)((ofRectangle const *)arg1)->inside((ofPoint const &)*arg2,(ofPoint const &)*arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_inside(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle_inside__SWIG_1(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle_inside__SWIG_2(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle_inside__SWIG_3(L);} } } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_Rectangle_inside__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Rectangle_inside'\n" " Possible C/C++ prototypes are:\n" - " ofRectangle::inside(float,float) const\n" " ofRectangle::inside(ofPoint const &) const\n" - " ofRectangle::inside(ofRectangle const &) const\n" " ofRectangle::inside(ofPoint const &,ofPoint const &) const\n"); - lua_error(L);return 0; } -static int _wrap_Rectangle_intersects__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofRectangle *arg2 = 0 ; bool result; SWIG_check_num_args("ofRectangle::intersects",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::intersects",1,"ofRectangle const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::intersects",2,"ofRectangle const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_intersects",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_intersects",2,SWIGTYPE_p_ofRectangle); } - result = (bool)((ofRectangle const *)arg1)->intersects((ofRectangle const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_intersects__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofPoint *arg2 = 0 ; ofPoint *arg3 = 0 ; bool result; SWIG_check_num_args("ofRectangle::intersects",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::intersects",1,"ofRectangle const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::intersects",2,"ofPoint const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofRectangle::intersects",3,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_intersects",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Rectangle_intersects",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Rectangle_intersects",3,SWIGTYPE_p_ofVec3f); } - result = (bool)((ofRectangle const *)arg1)->intersects((ofPoint const &)*arg2,(ofPoint const &)*arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_intersects(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle_intersects__SWIG_0(L);} } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle_intersects__SWIG_1(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Rectangle_intersects'\n" - " Possible C/C++ prototypes are:\n" " ofRectangle::intersects(ofRectangle const &) const\n" - " ofRectangle::intersects(ofPoint const &,ofPoint const &) const\n"); lua_error(L);return 0; } -static int _wrap_Rectangle_growToInclude__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - float arg2 ; float arg3 ; SWIG_check_num_args("ofRectangle::growToInclude",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::growToInclude",1,"ofRectangle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::growToInclude",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofRectangle::growToInclude",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_growToInclude",1,SWIGTYPE_p_ofRectangle); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->growToInclude(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Rectangle_growToInclude__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofPoint *arg2 = 0 ; SWIG_check_num_args("ofRectangle::growToInclude",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::growToInclude",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::growToInclude",2,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_growToInclude",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Rectangle_growToInclude",2,SWIGTYPE_p_ofVec3f); } (arg1)->growToInclude((ofPoint const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_growToInclude__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofRectangle *arg2 = 0 ; SWIG_check_num_args("ofRectangle::growToInclude",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::growToInclude",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::growToInclude",2,"ofRectangle const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_growToInclude",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_growToInclude",2,SWIGTYPE_p_ofRectangle); } (arg1)->growToInclude((ofRectangle const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_growToInclude__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofPoint *arg2 = 0 ; ofPoint *arg3 = 0 ; SWIG_check_num_args("ofRectangle::growToInclude",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::growToInclude",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::growToInclude",2,"ofPoint const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofRectangle::growToInclude",3,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_growToInclude",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Rectangle_growToInclude",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Rectangle_growToInclude",3,SWIGTYPE_p_ofVec3f); } - (arg1)->growToInclude((ofPoint const &)*arg2,(ofPoint const &)*arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Rectangle_growToInclude(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle_growToInclude__SWIG_1(L);} } } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle_growToInclude__SWIG_2(L);} } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle_growToInclude__SWIG_3(L);} } } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_Rectangle_growToInclude__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Rectangle_growToInclude'\n" - " Possible C/C++ prototypes are:\n" " ofRectangle::growToInclude(float,float)\n" - " ofRectangle::growToInclude(ofPoint const &)\n" " ofRectangle::growToInclude(ofRectangle const &)\n" - " ofRectangle::growToInclude(ofPoint const &,ofPoint const &)\n"); lua_error(L);return 0; } -static int _wrap_Rectangle_getIntersection(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofRectangle *arg2 = 0 ; ofRectangle result; SWIG_check_num_args("ofRectangle::getIntersection",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::getIntersection",1,"ofRectangle const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::getIntersection",2,"ofRectangle const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getIntersection",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getIntersection",2,SWIGTYPE_p_ofRectangle); } - result = ((ofRectangle const *)arg1)->getIntersection((ofRectangle const &)*arg2); { - ofRectangle * resultptr = new ofRectangle((const ofRectangle &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofRectangle,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_getUnion(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofRectangle *arg2 = 0 ; ofRectangle result; SWIG_check_num_args("ofRectangle::getUnion",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::getUnion",1,"ofRectangle const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::getUnion",2,"ofRectangle const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getUnion",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getUnion",2,SWIGTYPE_p_ofRectangle); } - result = ((ofRectangle const *)arg1)->getUnion((ofRectangle const &)*arg2); { - ofRectangle * resultptr = new ofRectangle((const ofRectangle &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofRectangle,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_standardize(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - SWIG_check_num_args("ofRectangle::standardize",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::standardize",1,"ofRectangle *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_standardize",1,SWIGTYPE_p_ofRectangle); } (arg1)->standardize(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_getStandardized(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofRectangle result; SWIG_check_num_args("ofRectangle::getStandardized",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::getStandardized",1,"ofRectangle const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getStandardized",1,SWIGTYPE_p_ofRectangle); } - result = ((ofRectangle const *)arg1)->getStandardized(); { - ofRectangle * resultptr = new ofRectangle((const ofRectangle &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofRectangle,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_isStandardized(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; bool result; - SWIG_check_num_args("ofRectangle::isStandardized",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::isStandardized",1,"ofRectangle const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_isStandardized",1,SWIGTYPE_p_ofRectangle); } - result = (bool)((ofRectangle const *)arg1)->isStandardized(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_getArea(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float result; - SWIG_check_num_args("ofRectangle::getArea",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::getArea",1,"ofRectangle const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getArea",1,SWIGTYPE_p_ofRectangle); } result = (float)((ofRectangle const *)arg1)->getArea(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_getPerimeter(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float result; - SWIG_check_num_args("ofRectangle::getPerimeter",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::getPerimeter",1,"ofRectangle const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getPerimeter",1,SWIGTYPE_p_ofRectangle); } - result = (float)((ofRectangle const *)arg1)->getPerimeter(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_getAspectRatio(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - float result; SWIG_check_num_args("ofRectangle::getAspectRatio",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::getAspectRatio",1,"ofRectangle const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getAspectRatio",1,SWIGTYPE_p_ofRectangle); } - result = (float)((ofRectangle const *)arg1)->getAspectRatio(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_isEmpty(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; bool result; - SWIG_check_num_args("ofRectangle::isEmpty",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::isEmpty",1,"ofRectangle const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_isEmpty",1,SWIGTYPE_p_ofRectangle); } result = (bool)((ofRectangle const *)arg1)->isEmpty(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_getMin(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; ofPoint result; - SWIG_check_num_args("ofRectangle::getMin",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::getMin",1,"ofRectangle const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getMin",1,SWIGTYPE_p_ofRectangle); } result = ((ofRectangle const *)arg1)->getMin(); { - ofPoint * resultptr = new ofPoint((const ofPoint &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_getMax(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; ofPoint result; - SWIG_check_num_args("ofRectangle::getMax",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::getMax",1,"ofRectangle const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getMax",1,SWIGTYPE_p_ofRectangle); } result = ((ofRectangle const *)arg1)->getMax(); { - ofPoint * resultptr = new ofPoint((const ofPoint &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_getMinX(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float result; - SWIG_check_num_args("ofRectangle::getMinX",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::getMinX",1,"ofRectangle const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getMinX",1,SWIGTYPE_p_ofRectangle); } result = (float)((ofRectangle const *)arg1)->getMinX(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_getMaxX(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float result; - SWIG_check_num_args("ofRectangle::getMaxX",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::getMaxX",1,"ofRectangle const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getMaxX",1,SWIGTYPE_p_ofRectangle); } result = (float)((ofRectangle const *)arg1)->getMaxX(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_getMinY(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float result; - SWIG_check_num_args("ofRectangle::getMinY",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::getMinY",1,"ofRectangle const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getMinY",1,SWIGTYPE_p_ofRectangle); } result = (float)((ofRectangle const *)arg1)->getMinY(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_getMaxY(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float result; - SWIG_check_num_args("ofRectangle::getMaxY",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::getMaxY",1,"ofRectangle const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getMaxY",1,SWIGTYPE_p_ofRectangle); } result = (float)((ofRectangle const *)arg1)->getMaxY(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_getLeft(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float result; - SWIG_check_num_args("ofRectangle::getLeft",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::getLeft",1,"ofRectangle const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getLeft",1,SWIGTYPE_p_ofRectangle); } result = (float)((ofRectangle const *)arg1)->getLeft(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_getRight(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float result; - SWIG_check_num_args("ofRectangle::getRight",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::getRight",1,"ofRectangle const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getRight",1,SWIGTYPE_p_ofRectangle); } result = (float)((ofRectangle const *)arg1)->getRight(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_getTop(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float result; - SWIG_check_num_args("ofRectangle::getTop",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::getTop",1,"ofRectangle const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getTop",1,SWIGTYPE_p_ofRectangle); } result = (float)((ofRectangle const *)arg1)->getTop(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_getBottom(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float result; - SWIG_check_num_args("ofRectangle::getBottom",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::getBottom",1,"ofRectangle const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getBottom",1,SWIGTYPE_p_ofRectangle); } result = (float)((ofRectangle const *)arg1)->getBottom(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_getTopLeft(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; ofPoint result; - SWIG_check_num_args("ofRectangle::getTopLeft",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::getTopLeft",1,"ofRectangle const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getTopLeft",1,SWIGTYPE_p_ofRectangle); } result = ((ofRectangle const *)arg1)->getTopLeft(); { - ofPoint * resultptr = new ofPoint((const ofPoint &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_getTopRight(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; ofPoint result; - SWIG_check_num_args("ofRectangle::getTopRight",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::getTopRight",1,"ofRectangle const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getTopRight",1,SWIGTYPE_p_ofRectangle); } result = ((ofRectangle const *)arg1)->getTopRight(); { - ofPoint * resultptr = new ofPoint((const ofPoint &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_getBottomLeft(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofPoint result; SWIG_check_num_args("ofRectangle::getBottomLeft",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::getBottomLeft",1,"ofRectangle const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getBottomLeft",1,SWIGTYPE_p_ofRectangle); } result = ((ofRectangle const *)arg1)->getBottomLeft(); - { ofPoint * resultptr = new ofPoint((const ofPoint &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_getBottomRight(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofPoint result; SWIG_check_num_args("ofRectangle::getBottomRight",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::getBottomRight",1,"ofRectangle const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getBottomRight",1,SWIGTYPE_p_ofRectangle); } - result = ((ofRectangle const *)arg1)->getBottomRight(); { ofPoint * resultptr = new ofPoint((const ofPoint &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_getHorzAnchor(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofAlignHorz arg2 ; float result; SWIG_check_num_args("ofRectangle::getHorzAnchor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::getHorzAnchor",1,"ofRectangle const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::getHorzAnchor",2,"ofAlignHorz"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getHorzAnchor",1,SWIGTYPE_p_ofRectangle); } arg2 = (ofAlignHorz)(int)lua_tonumber(L, 2); - result = (float)((ofRectangle const *)arg1)->getHorzAnchor(arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_getVertAnchor(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofAlignVert arg2 ; float result; SWIG_check_num_args("ofRectangle::getVertAnchor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::getVertAnchor",1,"ofRectangle const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::getVertAnchor",2,"ofAlignVert"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getVertAnchor",1,SWIGTYPE_p_ofRectangle); } arg2 = (ofAlignVert)(int)lua_tonumber(L, 2); - result = (float)((ofRectangle const *)arg1)->getVertAnchor(arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_getPosition(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; ofPoint result; - SWIG_check_num_args("ofRectangle::getPosition",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::getPosition",1,"ofRectangle const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getPosition",1,SWIGTYPE_p_ofRectangle); } result = ((ofRectangle const *)arg1)->getPosition(); { - ofPoint * resultptr = new ofPoint((const ofPoint &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_getPositionRef(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofPoint *result = 0 ; SWIG_check_num_args("ofRectangle::getPositionRef",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::getPositionRef",1,"ofRectangle *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getPositionRef",1,SWIGTYPE_p_ofRectangle); } result = (ofPoint *) &(arg1)->getPositionRef(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Rectangle_getCenter(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; ofPoint result; - SWIG_check_num_args("ofRectangle::getCenter",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::getCenter",1,"ofRectangle const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getCenter",1,SWIGTYPE_p_ofRectangle); } result = ((ofRectangle const *)arg1)->getCenter(); { - ofPoint * resultptr = new ofPoint((const ofPoint &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_getX(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float result; - SWIG_check_num_args("ofRectangle::getX",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::getX",1,"ofRectangle const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getX",1,SWIGTYPE_p_ofRectangle); } result = (float)((ofRectangle const *)arg1)->getX(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_getY(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float result; - SWIG_check_num_args("ofRectangle::getY",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::getY",1,"ofRectangle const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getY",1,SWIGTYPE_p_ofRectangle); } result = (float)((ofRectangle const *)arg1)->getY(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_getWidth(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float result; - SWIG_check_num_args("ofRectangle::getWidth",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::getWidth",1,"ofRectangle const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getWidth",1,SWIGTYPE_p_ofRectangle); } result = (float)((ofRectangle const *)arg1)->getWidth(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_getHeight(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float result; - SWIG_check_num_args("ofRectangle::getHeight",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::getHeight",1,"ofRectangle const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getHeight",1,SWIGTYPE_p_ofRectangle); } result = (float)((ofRectangle const *)arg1)->getHeight(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle___add(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; ofPoint *arg2 = 0 ; - ofRectangle result; SWIG_check_num_args("ofRectangle::operator +",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::operator +",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::operator +",2,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle___add",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Rectangle___add",2,SWIGTYPE_p_ofVec3f); } result = (arg1)->operator +((ofPoint const &)*arg2); { - ofRectangle * resultptr = new ofRectangle((const ofRectangle &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofRectangle,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle___sub(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; ofPoint *arg2 = 0 ; - ofRectangle result; SWIG_check_num_args("ofRectangle::operator -",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::operator -",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::operator -",2,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle___sub",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Rectangle___sub",2,SWIGTYPE_p_ofVec3f); } result = (arg1)->operator -((ofPoint const &)*arg2); { - ofRectangle * resultptr = new ofRectangle((const ofRectangle &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofRectangle,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle___eq(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofRectangle *arg2 = 0 ; bool result; SWIG_check_num_args("ofRectangle::operator ==",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::operator ==",1,"ofRectangle const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::operator ==",2,"ofRectangle const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle___eq",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle___eq",2,SWIGTYPE_p_ofRectangle); } - result = (bool)((ofRectangle const *)arg1)->operator ==((ofRectangle const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_isZero(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; bool result; - SWIG_check_num_args("ofRectangle::isZero",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::isZero",1,"ofRectangle const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_isZero",1,SWIGTYPE_p_ofRectangle); } result = (bool)((ofRectangle const *)arg1)->isZero(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_position_set(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofPoint *arg2 = (ofPoint *) 0 ; SWIG_check_num_args("ofRectangle::position",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::position",1,"ofRectangle *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofRectangle::position",2,"ofPoint *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_position_set",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Rectangle_position_set",2,SWIGTYPE_p_ofVec3f); } if (arg1) (arg1)->position = *arg2; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_position_get(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofPoint *result = 0 ; SWIG_check_num_args("ofRectangle::position",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::position",1,"ofRectangle *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_position_get",1,SWIGTYPE_p_ofRectangle); } result = (ofPoint *)& ((arg1)->position); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Rectangle_width_set(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float arg2 ; - SWIG_check_num_args("ofRectangle::width",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::width",1,"ofRectangle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::width",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_width_set",1,SWIGTYPE_p_ofRectangle); } arg2 = (float)lua_tonumber(L, 2); - if (arg1) (arg1)->width = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_width_get(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float result; - SWIG_check_num_args("ofRectangle::width",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::width",1,"ofRectangle *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_width_get",1,SWIGTYPE_p_ofRectangle); } result = (float) ((arg1)->width); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_height_set(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float arg2 ; - SWIG_check_num_args("ofRectangle::height",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::height",1,"ofRectangle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::height",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_height_set",1,SWIGTYPE_p_ofRectangle); } arg2 = (float)lua_tonumber(L, 2); - if (arg1) (arg1)->height = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_height_get(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float result; - SWIG_check_num_args("ofRectangle::height",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::height",1,"ofRectangle *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_height_get",1,SWIGTYPE_p_ofRectangle); } result = (float) ((arg1)->height); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_x_set(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float arg2 ; - SWIG_check_num_args("ofRectangle::x",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::x",1,"ofRectangle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::x",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_x_set",1,SWIGTYPE_p_ofRectangle); } arg2 = (float)lua_tonumber(L, 2); - ofRectangle_x_set(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_x_get(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float result; - SWIG_check_num_args("ofRectangle::x",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::x",1,"ofRectangle *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_x_get",1,SWIGTYPE_p_ofRectangle); } result = (float)ofRectangle_x_get(arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_y_set(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float arg2 ; - SWIG_check_num_args("ofRectangle::y",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::y",1,"ofRectangle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::y",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_y_set",1,SWIGTYPE_p_ofRectangle); } arg2 = (float)lua_tonumber(L, 2); - ofRectangle_y_set(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_y_get(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float result; - SWIG_check_num_args("ofRectangle::y",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::y",1,"ofRectangle *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_y_get",1,SWIGTYPE_p_ofRectangle); } result = (float)ofRectangle_y_get(arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle___tostring(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - char *result = 0 ; SWIG_check_num_args("ofRectangle::__str__",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::__str__",1,"ofRectangle *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle___tostring",1,SWIGTYPE_p_ofRectangle); } result = (char *)ofRectangle___str__(arg1); - lua_pushstring(L,(const char *)result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_Rectangle(void *obj) { -ofRectangle *arg1 = (ofRectangle *) obj; -delete arg1; -} -static int _proxy__wrap_new_Rectangle(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_Rectangle); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_Rectangle_attributes[] = { - { "position", _wrap_Rectangle_position_get, _wrap_Rectangle_position_set }, - { "width", _wrap_Rectangle_width_get, _wrap_Rectangle_width_set }, - { "height", _wrap_Rectangle_height_get, _wrap_Rectangle_height_set }, - { "x", _wrap_Rectangle_x_get, _wrap_Rectangle_x_set }, - { "y", _wrap_Rectangle_y_get, _wrap_Rectangle_y_set }, - {0,0,0} -}; -static swig_lua_method swig_Rectangle_methods[]= { - { "set", _wrap_Rectangle_set}, - { "setX", _wrap_Rectangle_setX}, - { "setY", _wrap_Rectangle_setY}, - { "setWidth", _wrap_Rectangle_setWidth}, - { "setHeight", _wrap_Rectangle_setHeight}, - { "setPosition", _wrap_Rectangle_setPosition}, - { "setSize", _wrap_Rectangle_setSize}, - { "setFromCenter", _wrap_Rectangle_setFromCenter}, - { "translate", _wrap_Rectangle_translate}, - { "translateX", _wrap_Rectangle_translateX}, - { "translateY", _wrap_Rectangle_translateY}, - { "scale", _wrap_Rectangle_scale}, - { "scaleWidth", _wrap_Rectangle_scaleWidth}, - { "scaleHeight", _wrap_Rectangle_scaleHeight}, - { "scaleFromCenter", _wrap_Rectangle_scaleFromCenter}, - { "scaleToScaleMode", _wrap_Rectangle_scaleToScaleMode}, - { "scaleToAspectRatio", _wrap_Rectangle_scaleToAspectRatio}, - { "scaleTo", _wrap_Rectangle_scaleTo}, - { "alignToHorz", _wrap_Rectangle_alignToHorz}, - { "alignToVert", _wrap_Rectangle_alignToVert}, - { "alignTo", _wrap_Rectangle_alignTo}, - { "inside", _wrap_Rectangle_inside}, - { "intersects", _wrap_Rectangle_intersects}, - { "growToInclude", _wrap_Rectangle_growToInclude}, - { "getIntersection", _wrap_Rectangle_getIntersection}, - { "getUnion", _wrap_Rectangle_getUnion}, - { "standardize", _wrap_Rectangle_standardize}, - { "getStandardized", _wrap_Rectangle_getStandardized}, - { "isStandardized", _wrap_Rectangle_isStandardized}, - { "getArea", _wrap_Rectangle_getArea}, - { "getPerimeter", _wrap_Rectangle_getPerimeter}, - { "getAspectRatio", _wrap_Rectangle_getAspectRatio}, - { "isEmpty", _wrap_Rectangle_isEmpty}, - { "getMin", _wrap_Rectangle_getMin}, - { "getMax", _wrap_Rectangle_getMax}, - { "getMinX", _wrap_Rectangle_getMinX}, - { "getMaxX", _wrap_Rectangle_getMaxX}, - { "getMinY", _wrap_Rectangle_getMinY}, - { "getMaxY", _wrap_Rectangle_getMaxY}, - { "getLeft", _wrap_Rectangle_getLeft}, - { "getRight", _wrap_Rectangle_getRight}, - { "getTop", _wrap_Rectangle_getTop}, - { "getBottom", _wrap_Rectangle_getBottom}, - { "getTopLeft", _wrap_Rectangle_getTopLeft}, - { "getTopRight", _wrap_Rectangle_getTopRight}, - { "getBottomLeft", _wrap_Rectangle_getBottomLeft}, - { "getBottomRight", _wrap_Rectangle_getBottomRight}, - { "getHorzAnchor", _wrap_Rectangle_getHorzAnchor}, - { "getVertAnchor", _wrap_Rectangle_getVertAnchor}, - { "getPosition", _wrap_Rectangle_getPosition}, - { "getPositionRef", _wrap_Rectangle_getPositionRef}, - { "getCenter", _wrap_Rectangle_getCenter}, - { "getX", _wrap_Rectangle_getX}, - { "getY", _wrap_Rectangle_getY}, - { "getWidth", _wrap_Rectangle_getWidth}, - { "getHeight", _wrap_Rectangle_getHeight}, - { "__add", _wrap_Rectangle___add}, - { "__sub", _wrap_Rectangle___sub}, - { "__eq", _wrap_Rectangle___eq}, - { "isZero", _wrap_Rectangle_isZero}, - { "__tostring", _wrap_Rectangle___tostring}, - {0,0} -}; -static swig_lua_method swig_Rectangle_meta[] = { - { "__add", _wrap_Rectangle___add}, - { "__sub", _wrap_Rectangle___sub}, - { "__eq", _wrap_Rectangle___eq}, - { "__tostring", _wrap_Rectangle___tostring}, - {0,0} -}; - -static swig_lua_attribute swig_Rectangle_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_Rectangle_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_Rectangle_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_Rectangle_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_Rectangle_Sf_SwigStatic = { - "Rectangle", - swig_Rectangle_Sf_SwigStatic_methods, - swig_Rectangle_Sf_SwigStatic_attributes, - swig_Rectangle_Sf_SwigStatic_constants, - swig_Rectangle_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_Rectangle_bases[] = {0}; -static const char *swig_Rectangle_base_names[] = {0}; -static swig_lua_class _wrap_class_Rectangle = { "Rectangle", "Rectangle", &SWIGTYPE_p_ofRectangle,_proxy__wrap_new_Rectangle, swig_delete_Rectangle, swig_Rectangle_methods, swig_Rectangle_attributes, &swig_Rectangle_Sf_SwigStatic, swig_Rectangle_meta, swig_Rectangle_bases, swig_Rectangle_base_names }; - -static int _wrap_new_SerialDeviceInfo__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string arg1 ; std::string arg2 ; int arg3 ; - ofSerialDeviceInfo *result = 0 ; SWIG_check_num_args("ofSerialDeviceInfo::ofSerialDeviceInfo",3,3) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofSerialDeviceInfo::ofSerialDeviceInfo",1,"std::string"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofSerialDeviceInfo::ofSerialDeviceInfo",2,"std::string"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofSerialDeviceInfo::ofSerialDeviceInfo",3,"int"); - (&arg1)->assign(lua_tostring(L,1),lua_rawlen(L,1)); (&arg2)->assign(lua_tostring(L,2),lua_rawlen(L,2)); - arg3 = (int)lua_tonumber(L, 3); result = (ofSerialDeviceInfo *)new ofSerialDeviceInfo(arg1,arg2,arg3); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofSerialDeviceInfo,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_SerialDeviceInfo__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofSerialDeviceInfo *result = 0 ; - SWIG_check_num_args("ofSerialDeviceInfo::ofSerialDeviceInfo",0,0) result = (ofSerialDeviceInfo *)new ofSerialDeviceInfo(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofSerialDeviceInfo,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_SerialDeviceInfo(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_SerialDeviceInfo__SWIG_1(L);} if (argc == 3) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { { - _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_new_SerialDeviceInfo__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SerialDeviceInfo'\n" - " Possible C/C++ prototypes are:\n" " ofSerialDeviceInfo::ofSerialDeviceInfo(std::string,std::string,int)\n" - " ofSerialDeviceInfo::ofSerialDeviceInfo()\n"); lua_error(L);return 0; } -static int _wrap_SerialDeviceInfo_getDevicePath(lua_State* L) { int SWIG_arg = 0; - ofSerialDeviceInfo *arg1 = (ofSerialDeviceInfo *) 0 ; std::string result; - SWIG_check_num_args("ofSerialDeviceInfo::getDevicePath",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSerialDeviceInfo::getDevicePath",1,"ofSerialDeviceInfo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSerialDeviceInfo,0))){ - SWIG_fail_ptr("SerialDeviceInfo_getDevicePath",1,SWIGTYPE_p_ofSerialDeviceInfo); } result = (arg1)->getDevicePath(); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_SerialDeviceInfo_getDeviceName(lua_State* L) { int SWIG_arg = 0; - ofSerialDeviceInfo *arg1 = (ofSerialDeviceInfo *) 0 ; std::string result; - SWIG_check_num_args("ofSerialDeviceInfo::getDeviceName",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSerialDeviceInfo::getDeviceName",1,"ofSerialDeviceInfo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSerialDeviceInfo,0))){ - SWIG_fail_ptr("SerialDeviceInfo_getDeviceName",1,SWIGTYPE_p_ofSerialDeviceInfo); } result = (arg1)->getDeviceName(); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_SerialDeviceInfo_getDeviceID(lua_State* L) { int SWIG_arg = 0; - ofSerialDeviceInfo *arg1 = (ofSerialDeviceInfo *) 0 ; int result; SWIG_check_num_args("ofSerialDeviceInfo::getDeviceID",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSerialDeviceInfo::getDeviceID",1,"ofSerialDeviceInfo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSerialDeviceInfo,0))){ - SWIG_fail_ptr("SerialDeviceInfo_getDeviceID",1,SWIGTYPE_p_ofSerialDeviceInfo); } result = (int)(arg1)->getDeviceID(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_SerialDeviceInfo(void *obj) { -ofSerialDeviceInfo *arg1 = (ofSerialDeviceInfo *) obj; -delete arg1; -} -static int _proxy__wrap_new_SerialDeviceInfo(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_SerialDeviceInfo); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_SerialDeviceInfo_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_SerialDeviceInfo_methods[]= { - { "getDevicePath", _wrap_SerialDeviceInfo_getDevicePath}, - { "getDeviceName", _wrap_SerialDeviceInfo_getDeviceName}, - { "getDeviceID", _wrap_SerialDeviceInfo_getDeviceID}, - {0,0} -}; -static swig_lua_method swig_SerialDeviceInfo_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_SerialDeviceInfo_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_SerialDeviceInfo_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_SerialDeviceInfo_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_SerialDeviceInfo_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_SerialDeviceInfo_Sf_SwigStatic = { - "SerialDeviceInfo", - swig_SerialDeviceInfo_Sf_SwigStatic_methods, - swig_SerialDeviceInfo_Sf_SwigStatic_attributes, - swig_SerialDeviceInfo_Sf_SwigStatic_constants, - swig_SerialDeviceInfo_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_SerialDeviceInfo_bases[] = {0}; -static const char *swig_SerialDeviceInfo_base_names[] = {0}; -static swig_lua_class _wrap_class_SerialDeviceInfo = { "SerialDeviceInfo", "SerialDeviceInfo", &SWIGTYPE_p_ofSerialDeviceInfo,_proxy__wrap_new_SerialDeviceInfo, swig_delete_SerialDeviceInfo, swig_SerialDeviceInfo_methods, swig_SerialDeviceInfo_attributes, &swig_SerialDeviceInfo_Sf_SwigStatic, swig_SerialDeviceInfo_meta, swig_SerialDeviceInfo_bases, swig_SerialDeviceInfo_base_names }; - -static int _wrap_new_Style(lua_State* L) { int SWIG_arg = 0; ofStyle *result = 0 ; SWIG_check_num_args("ofStyle::ofStyle",0,0) - result = (ofStyle *)new ofStyle(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofStyle,1); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Style_color_set(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; - ofColor *arg2 = (ofColor *) 0 ; SWIG_check_num_args("ofStyle::color",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::color",1,"ofStyle *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofStyle::color",2,"ofColor *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ - SWIG_fail_ptr("Style_color_set",1,SWIGTYPE_p_ofStyle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Style_color_set",2,SWIGTYPE_p_ofColor_T_unsigned_char_t); } if (arg1) (arg1)->color = *arg2; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Style_color_get(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; ofColor *result = 0 ; - SWIG_check_num_args("ofStyle::color",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::color",1,"ofStyle *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ - SWIG_fail_ptr("Style_color_get",1,SWIGTYPE_p_ofStyle); } result = (ofColor *)& ((arg1)->color); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Style_bgColor_set(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; - ofColor *arg2 = (ofColor *) 0 ; SWIG_check_num_args("ofStyle::bgColor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::bgColor",1,"ofStyle *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofStyle::bgColor",2,"ofColor *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ - SWIG_fail_ptr("Style_bgColor_set",1,SWIGTYPE_p_ofStyle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Style_bgColor_set",2,SWIGTYPE_p_ofColor_T_unsigned_char_t); } if (arg1) (arg1)->bgColor = *arg2; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Style_bgColor_get(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; ofColor *result = 0 ; - SWIG_check_num_args("ofStyle::bgColor",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::bgColor",1,"ofStyle *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ - SWIG_fail_ptr("Style_bgColor_get",1,SWIGTYPE_p_ofStyle); } result = (ofColor *)& ((arg1)->bgColor); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Style_polyMode_set(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; ofPolyWindingMode arg2 ; - SWIG_check_num_args("ofStyle::polyMode",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::polyMode",1,"ofStyle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofStyle::polyMode",2,"ofPolyWindingMode"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ - SWIG_fail_ptr("Style_polyMode_set",1,SWIGTYPE_p_ofStyle); } arg2 = (ofPolyWindingMode)(int)lua_tonumber(L, 2); - if (arg1) (arg1)->polyMode = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Style_polyMode_get(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; ofPolyWindingMode result; - SWIG_check_num_args("ofStyle::polyMode",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::polyMode",1,"ofStyle *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ - SWIG_fail_ptr("Style_polyMode_get",1,SWIGTYPE_p_ofStyle); } result = (ofPolyWindingMode) ((arg1)->polyMode); - lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Style_rectMode_set(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; ofRectMode arg2 ; - SWIG_check_num_args("ofStyle::rectMode",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::rectMode",1,"ofStyle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofStyle::rectMode",2,"ofRectMode"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ - SWIG_fail_ptr("Style_rectMode_set",1,SWIGTYPE_p_ofStyle); } arg2 = (ofRectMode)(int)lua_tonumber(L, 2); - if (arg1) (arg1)->rectMode = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Style_rectMode_get(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; ofRectMode result; - SWIG_check_num_args("ofStyle::rectMode",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::rectMode",1,"ofStyle *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ - SWIG_fail_ptr("Style_rectMode_get",1,SWIGTYPE_p_ofStyle); } result = (ofRectMode) ((arg1)->rectMode); - lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Style_bFill_set(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; bool arg2 ; - SWIG_check_num_args("ofStyle::bFill",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::bFill",1,"ofStyle *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofStyle::bFill",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ - SWIG_fail_ptr("Style_bFill_set",1,SWIGTYPE_p_ofStyle); } arg2 = (lua_toboolean(L, 2)!=0); if (arg1) (arg1)->bFill = arg2; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Style_bFill_get(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; bool result; - SWIG_check_num_args("ofStyle::bFill",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::bFill",1,"ofStyle *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ - SWIG_fail_ptr("Style_bFill_get",1,SWIGTYPE_p_ofStyle); } result = (bool) ((arg1)->bFill); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Style_drawBitmapMode_set(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; - ofDrawBitmapMode arg2 ; SWIG_check_num_args("ofStyle::drawBitmapMode",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::drawBitmapMode",1,"ofStyle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofStyle::drawBitmapMode",2,"ofDrawBitmapMode"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ - SWIG_fail_ptr("Style_drawBitmapMode_set",1,SWIGTYPE_p_ofStyle); } arg2 = (ofDrawBitmapMode)(int)lua_tonumber(L, 2); - if (arg1) (arg1)->drawBitmapMode = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Style_drawBitmapMode_get(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; - ofDrawBitmapMode result; SWIG_check_num_args("ofStyle::drawBitmapMode",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::drawBitmapMode",1,"ofStyle *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ - SWIG_fail_ptr("Style_drawBitmapMode_get",1,SWIGTYPE_p_ofStyle); } result = (ofDrawBitmapMode) ((arg1)->drawBitmapMode); - lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Style_blendingMode_set(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; ofBlendMode arg2 ; - SWIG_check_num_args("ofStyle::blendingMode",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::blendingMode",1,"ofStyle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofStyle::blendingMode",2,"ofBlendMode"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ - SWIG_fail_ptr("Style_blendingMode_set",1,SWIGTYPE_p_ofStyle); } arg2 = (ofBlendMode)(int)lua_tonumber(L, 2); - if (arg1) (arg1)->blendingMode = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Style_blendingMode_get(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; ofBlendMode result; - SWIG_check_num_args("ofStyle::blendingMode",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::blendingMode",1,"ofStyle *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ - SWIG_fail_ptr("Style_blendingMode_get",1,SWIGTYPE_p_ofStyle); } result = (ofBlendMode) ((arg1)->blendingMode); - lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Style_smoothing_set(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; bool arg2 ; - SWIG_check_num_args("ofStyle::smoothing",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::smoothing",1,"ofStyle *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofStyle::smoothing",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ - SWIG_fail_ptr("Style_smoothing_set",1,SWIGTYPE_p_ofStyle); } arg2 = (lua_toboolean(L, 2)!=0); - if (arg1) (arg1)->smoothing = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Style_smoothing_get(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; bool result; - SWIG_check_num_args("ofStyle::smoothing",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::smoothing",1,"ofStyle *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ - SWIG_fail_ptr("Style_smoothing_get",1,SWIGTYPE_p_ofStyle); } result = (bool) ((arg1)->smoothing); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Style_circleResolution_set(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; int arg2 ; - SWIG_check_num_args("ofStyle::circleResolution",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::circleResolution",1,"ofStyle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofStyle::circleResolution",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ - SWIG_fail_ptr("Style_circleResolution_set",1,SWIGTYPE_p_ofStyle); } arg2 = (int)lua_tonumber(L, 2); - if (arg1) (arg1)->circleResolution = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Style_circleResolution_get(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; int result; - SWIG_check_num_args("ofStyle::circleResolution",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::circleResolution",1,"ofStyle *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ - SWIG_fail_ptr("Style_circleResolution_get",1,SWIGTYPE_p_ofStyle); } result = (int) ((arg1)->circleResolution); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Style_sphereResolution_set(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; int arg2 ; - SWIG_check_num_args("ofStyle::sphereResolution",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::sphereResolution",1,"ofStyle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofStyle::sphereResolution",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ - SWIG_fail_ptr("Style_sphereResolution_set",1,SWIGTYPE_p_ofStyle); } arg2 = (int)lua_tonumber(L, 2); - if (arg1) (arg1)->sphereResolution = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Style_sphereResolution_get(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; int result; - SWIG_check_num_args("ofStyle::sphereResolution",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::sphereResolution",1,"ofStyle *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ - SWIG_fail_ptr("Style_sphereResolution_get",1,SWIGTYPE_p_ofStyle); } result = (int) ((arg1)->sphereResolution); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Style_curveResolution_set(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; int arg2 ; - SWIG_check_num_args("ofStyle::curveResolution",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::curveResolution",1,"ofStyle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofStyle::curveResolution",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ - SWIG_fail_ptr("Style_curveResolution_set",1,SWIGTYPE_p_ofStyle); } arg2 = (int)lua_tonumber(L, 2); - if (arg1) (arg1)->curveResolution = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Style_curveResolution_get(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; int result; - SWIG_check_num_args("ofStyle::curveResolution",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::curveResolution",1,"ofStyle *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ - SWIG_fail_ptr("Style_curveResolution_get",1,SWIGTYPE_p_ofStyle); } result = (int) ((arg1)->curveResolution); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Style_lineWidth_set(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; float arg2 ; - SWIG_check_num_args("ofStyle::lineWidth",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::lineWidth",1,"ofStyle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofStyle::lineWidth",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ - SWIG_fail_ptr("Style_lineWidth_set",1,SWIGTYPE_p_ofStyle); } arg2 = (float)lua_tonumber(L, 2); - if (arg1) (arg1)->lineWidth = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Style_lineWidth_get(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; float result; - SWIG_check_num_args("ofStyle::lineWidth",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::lineWidth",1,"ofStyle *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ - SWIG_fail_ptr("Style_lineWidth_get",1,SWIGTYPE_p_ofStyle); } result = (float) ((arg1)->lineWidth); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_Style(void *obj) { -ofStyle *arg1 = (ofStyle *) obj; -delete arg1; -} -static int _proxy__wrap_new_Style(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_Style); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_Style_attributes[] = { - { "color", _wrap_Style_color_get, _wrap_Style_color_set }, - { "bgColor", _wrap_Style_bgColor_get, _wrap_Style_bgColor_set }, - { "polyMode", _wrap_Style_polyMode_get, _wrap_Style_polyMode_set }, - { "rectMode", _wrap_Style_rectMode_get, _wrap_Style_rectMode_set }, - { "bFill", _wrap_Style_bFill_get, _wrap_Style_bFill_set }, - { "drawBitmapMode", _wrap_Style_drawBitmapMode_get, _wrap_Style_drawBitmapMode_set }, - { "blendingMode", _wrap_Style_blendingMode_get, _wrap_Style_blendingMode_set }, - { "smoothing", _wrap_Style_smoothing_get, _wrap_Style_smoothing_set }, - { "circleResolution", _wrap_Style_circleResolution_get, _wrap_Style_circleResolution_set }, - { "sphereResolution", _wrap_Style_sphereResolution_get, _wrap_Style_sphereResolution_set }, - { "curveResolution", _wrap_Style_curveResolution_get, _wrap_Style_curveResolution_set }, - { "lineWidth", _wrap_Style_lineWidth_get, _wrap_Style_lineWidth_set }, - {0,0,0} -}; -static swig_lua_method swig_Style_methods[]= { - {0,0} -}; -static swig_lua_method swig_Style_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_Style_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_Style_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_Style_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_Style_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_Style_Sf_SwigStatic = { - "Style", - swig_Style_Sf_SwigStatic_methods, - swig_Style_Sf_SwigStatic_attributes, - swig_Style_Sf_SwigStatic_constants, - swig_Style_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_Style_bases[] = {0}; -static const char *swig_Style_base_names[] = {0}; -static swig_lua_class _wrap_class_Style = { "Style", "Style", &SWIGTYPE_p_ofStyle,_proxy__wrap_new_Style, swig_delete_Style, swig_Style_methods, swig_Style_attributes, &swig_Style_Sf_SwigStatic, swig_Style_meta, swig_Style_bases, swig_Style_base_names }; - -static int _wrap_new_FpsCounter__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofFpsCounter *result = 0 ; - SWIG_check_num_args("ofFpsCounter::ofFpsCounter",0,0) result = (ofFpsCounter *)new ofFpsCounter(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofFpsCounter,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_FpsCounter__SWIG_1(lua_State* L) { int SWIG_arg = 0; double arg1 ; ofFpsCounter *result = 0 ; - SWIG_check_num_args("ofFpsCounter::ofFpsCounter",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofFpsCounter::ofFpsCounter",1,"double"); arg1 = (double)lua_tonumber(L, 1); - result = (ofFpsCounter *)new ofFpsCounter(arg1); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofFpsCounter,1); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_new_FpsCounter(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_FpsCounter__SWIG_0(L);} if (argc == 1) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { - return _wrap_new_FpsCounter__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_FpsCounter'\n" " Possible C/C++ prototypes are:\n" - " ofFpsCounter::ofFpsCounter()\n" " ofFpsCounter::ofFpsCounter(double)\n"); lua_error(L);return 0; } -static int _wrap_FpsCounter_newFrame(lua_State* L) { int SWIG_arg = 0; ofFpsCounter *arg1 = (ofFpsCounter *) 0 ; - SWIG_check_num_args("ofFpsCounter::newFrame",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFpsCounter::newFrame",1,"ofFpsCounter *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFpsCounter,0))){ - SWIG_fail_ptr("FpsCounter_newFrame",1,SWIGTYPE_p_ofFpsCounter); } (arg1)->newFrame(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_FpsCounter_update(lua_State* L) { int SWIG_arg = 0; ofFpsCounter *arg1 = (ofFpsCounter *) 0 ; - SWIG_check_num_args("ofFpsCounter::update",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFpsCounter::update",1,"ofFpsCounter *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFpsCounter,0))){ - SWIG_fail_ptr("FpsCounter_update",1,SWIGTYPE_p_ofFpsCounter); } (arg1)->update(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FpsCounter_getFps(lua_State* L) { int SWIG_arg = 0; ofFpsCounter *arg1 = (ofFpsCounter *) 0 ; double result; - SWIG_check_num_args("ofFpsCounter::getFps",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFpsCounter::getFps",1,"ofFpsCounter const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFpsCounter,0))){ - SWIG_fail_ptr("FpsCounter_getFps",1,SWIGTYPE_p_ofFpsCounter); } result = (double)((ofFpsCounter const *)arg1)->getFps(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FpsCounter_getNumFrames(lua_State* L) { int SWIG_arg = 0; ofFpsCounter *arg1 = (ofFpsCounter *) 0 ; - uint64_t result; SWIG_check_num_args("ofFpsCounter::getNumFrames",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFpsCounter::getNumFrames",1,"ofFpsCounter const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFpsCounter,0))){ - SWIG_fail_ptr("FpsCounter_getNumFrames",1,SWIGTYPE_p_ofFpsCounter); } - result = (uint64_t)((ofFpsCounter const *)arg1)->getNumFrames(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FpsCounter_getLastFrameNanos(lua_State* L) { int SWIG_arg = 0; ofFpsCounter *arg1 = (ofFpsCounter *) 0 ; - uint64_t result; SWIG_check_num_args("ofFpsCounter::getLastFrameNanos",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFpsCounter::getLastFrameNanos",1,"ofFpsCounter const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFpsCounter,0))){ - SWIG_fail_ptr("FpsCounter_getLastFrameNanos",1,SWIGTYPE_p_ofFpsCounter); } - result = (uint64_t)((ofFpsCounter const *)arg1)->getLastFrameNanos(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FpsCounter_getLastFrameSecs(lua_State* L) { int SWIG_arg = 0; ofFpsCounter *arg1 = (ofFpsCounter *) 0 ; - double result; SWIG_check_num_args("ofFpsCounter::getLastFrameSecs",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFpsCounter::getLastFrameSecs",1,"ofFpsCounter const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFpsCounter,0))){ - SWIG_fail_ptr("FpsCounter_getLastFrameSecs",1,SWIGTYPE_p_ofFpsCounter); } - result = (double)((ofFpsCounter const *)arg1)->getLastFrameSecs(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_FpsCounter(void *obj) { -ofFpsCounter *arg1 = (ofFpsCounter *) obj; -delete arg1; -} -static int _proxy__wrap_new_FpsCounter(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_FpsCounter); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_FpsCounter_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_FpsCounter_methods[]= { - { "newFrame", _wrap_FpsCounter_newFrame}, - { "update", _wrap_FpsCounter_update}, - { "getFps", _wrap_FpsCounter_getFps}, - { "getNumFrames", _wrap_FpsCounter_getNumFrames}, - { "getLastFrameNanos", _wrap_FpsCounter_getLastFrameNanos}, - { "getLastFrameSecs", _wrap_FpsCounter_getLastFrameSecs}, - {0,0} -}; -static swig_lua_method swig_FpsCounter_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_FpsCounter_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_FpsCounter_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_FpsCounter_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_FpsCounter_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_FpsCounter_Sf_SwigStatic = { - "FpsCounter", - swig_FpsCounter_Sf_SwigStatic_methods, - swig_FpsCounter_Sf_SwigStatic_attributes, - swig_FpsCounter_Sf_SwigStatic_constants, - swig_FpsCounter_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_FpsCounter_bases[] = {0}; -static const char *swig_FpsCounter_base_names[] = {0}; -static swig_lua_class _wrap_class_FpsCounter = { "FpsCounter", "FpsCounter", &SWIGTYPE_p_ofFpsCounter,_proxy__wrap_new_FpsCounter, swig_delete_FpsCounter, swig_FpsCounter_methods, swig_FpsCounter_attributes, &swig_FpsCounter_Sf_SwigStatic, swig_FpsCounter_meta, swig_FpsCounter_bases, swig_FpsCounter_base_names }; - -static int _wrap_new_Xml__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofXml *result = 0 ; SWIG_check_num_args("ofXml::ofXml",0,0) - result = (ofXml *)new ofXml(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofXml,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_new_Xml__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - ofXml *result = 0 ; SWIG_check_num_args("ofXml::ofXml",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofXml::ofXml",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = (ofXml *)new ofXml((std::string const &)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofXml,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Xml__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = 0 ; ofXml *result = 0 ; - SWIG_check_num_args("ofXml::ofXml",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofXml::ofXml",1,"ofXml const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("new_Xml",1,SWIGTYPE_p_ofXml); } - result = (ofXml *)new ofXml((ofXml const &)*arg1); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofXml,1); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_new_Xml(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_Xml__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXml, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_new_Xml__SWIG_2(L);} } if (argc == 1) { int _v; { _v = lua_isstring(L,argv[0]); } - if (_v) { return _wrap_new_Xml__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_Xml'\n" " Possible C/C++ prototypes are:\n" - " ofXml::ofXml()\n" " ofXml::ofXml(std::string const &)\n" " ofXml::ofXml(ofXml const &)\n"); lua_error(L);return 0; } -static int _wrap_Xml_load(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; std::string *arg2 = 0 ; - std::string temp2 ; bool result; SWIG_check_num_args("ofXml::load",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::load",1,"ofXml *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofXml::load",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_load",1,SWIGTYPE_p_ofXml); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; result = (bool)(arg1)->load((std::string const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_save(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; std::string *arg2 = 0 ; - std::string temp2 ; bool result; SWIG_check_num_args("ofXml::save",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::save",1,"ofXml *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofXml::save",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_save",1,SWIGTYPE_p_ofXml); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; result = (bool)(arg1)->save((std::string const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_addChild(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; std::string *arg2 = 0 ; - std::string temp2 ; bool result; SWIG_check_num_args("ofXml::addChild",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::addChild",1,"ofXml *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofXml::addChild",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_addChild",1,SWIGTYPE_p_ofXml); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; result = (bool)(arg1)->addChild((std::string const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_addXml__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; ofXml *arg2 = 0 ; bool arg3 ; - SWIG_check_num_args("ofXml::addXml",3,3) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::addXml",1,"ofXml *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofXml::addXml",2,"ofXml &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofXml::addXml",3,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_addXml",1,SWIGTYPE_p_ofXml); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_addXml",2,SWIGTYPE_p_ofXml); } - arg3 = (lua_toboolean(L, 3)!=0); (arg1)->addXml(*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Xml_addXml__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; ofXml *arg2 = 0 ; - SWIG_check_num_args("ofXml::addXml",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::addXml",1,"ofXml *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofXml::addXml",2,"ofXml &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_addXml",1,SWIGTYPE_p_ofXml); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_addXml",2,SWIGTYPE_p_ofXml); } - (arg1)->addXml(*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_addXml(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXml, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofXml, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_Xml_addXml__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXml, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofXml, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { return _wrap_Xml_addXml__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Xml_addXml'\n" " Possible C/C++ prototypes are:\n" - " ofXml::addXml(ofXml &,bool)\n" " ofXml::addXml(ofXml &)\n"); lua_error(L);return 0; } -static int _wrap_Xml_getValue__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; std::string result; - SWIG_check_num_args("ofXml::getValue",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::getValue",1,"ofXml const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_getValue",1,SWIGTYPE_p_ofXml); } - result = ((ofXml const *)arg1)->getValue(); lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_getValue__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; std::string *arg2 = 0 ; - std::string temp2 ; std::string result; SWIG_check_num_args("ofXml::getValue",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::getValue",1,"ofXml const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofXml::getValue",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_getValue",1,SWIGTYPE_p_ofXml); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = ((ofXml const *)arg1)->getValue((std::string const &)*arg2); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Xml_getValue(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXml, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Xml_getValue__SWIG_0(L);} } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXml, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { return _wrap_Xml_getValue__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Xml_getValue'\n" " Possible C/C++ prototypes are:\n" - " ofXml::getValue() const\n" " ofXml::getValue(std::string const &) const\n"); lua_error(L);return 0; } -static int _wrap_Xml_getIntValue__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; int result; - SWIG_check_num_args("ofXml::getIntValue",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::getIntValue",1,"ofXml const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_getIntValue",1,SWIGTYPE_p_ofXml); } - result = (int)((ofXml const *)arg1)->getIntValue(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_getIntValue__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; std::string *arg2 = 0 ; - std::string temp2 ; int result; SWIG_check_num_args("ofXml::getIntValue",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::getIntValue",1,"ofXml const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofXml::getIntValue",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_getIntValue",1,SWIGTYPE_p_ofXml); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = (int)((ofXml const *)arg1)->getIntValue((std::string const &)*arg2); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_getIntValue(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXml, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Xml_getIntValue__SWIG_0(L);} } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXml, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { return _wrap_Xml_getIntValue__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Xml_getIntValue'\n" " Possible C/C++ prototypes are:\n" - " ofXml::getIntValue() const\n" " ofXml::getIntValue(std::string const &) const\n"); lua_error(L);return 0; } -static int _wrap_Xml_getInt64Value__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; int64_t result; - SWIG_check_num_args("ofXml::getInt64Value",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::getInt64Value",1,"ofXml const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ - SWIG_fail_ptr("Xml_getInt64Value",1,SWIGTYPE_p_ofXml); } result = (int64_t)((ofXml const *)arg1)->getInt64Value(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_getInt64Value__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; std::string *arg2 = 0 ; - std::string temp2 ; int64_t result; SWIG_check_num_args("ofXml::getInt64Value",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::getInt64Value",1,"ofXml const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofXml::getInt64Value",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ - SWIG_fail_ptr("Xml_getInt64Value",1,SWIGTYPE_p_ofXml); } temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = (int64_t)((ofXml const *)arg1)->getInt64Value((std::string const &)*arg2); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_getInt64Value(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXml, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Xml_getInt64Value__SWIG_0(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXml, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { return _wrap_Xml_getInt64Value__SWIG_1(L);} } - } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Xml_getInt64Value'\n" - " Possible C/C++ prototypes are:\n" " ofXml::getInt64Value() const\n" - " ofXml::getInt64Value(std::string const &) const\n"); lua_error(L);return 0; } -static int _wrap_Xml_getFloatValue__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; float result; - SWIG_check_num_args("ofXml::getFloatValue",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::getFloatValue",1,"ofXml const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ - SWIG_fail_ptr("Xml_getFloatValue",1,SWIGTYPE_p_ofXml); } result = (float)((ofXml const *)arg1)->getFloatValue(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_getFloatValue__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; std::string *arg2 = 0 ; - std::string temp2 ; float result; SWIG_check_num_args("ofXml::getFloatValue",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::getFloatValue",1,"ofXml const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofXml::getFloatValue",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ - SWIG_fail_ptr("Xml_getFloatValue",1,SWIGTYPE_p_ofXml); } temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = (float)((ofXml const *)arg1)->getFloatValue((std::string const &)*arg2); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_getFloatValue(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXml, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Xml_getFloatValue__SWIG_0(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXml, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { return _wrap_Xml_getFloatValue__SWIG_1(L);} } - } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Xml_getFloatValue'\n" - " Possible C/C++ prototypes are:\n" " ofXml::getFloatValue() const\n" - " ofXml::getFloatValue(std::string const &) const\n"); lua_error(L);return 0; } -static int _wrap_Xml_getBoolValue__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; bool result; - SWIG_check_num_args("ofXml::getBoolValue",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::getBoolValue",1,"ofXml const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_getBoolValue",1,SWIGTYPE_p_ofXml); } - result = (bool)((ofXml const *)arg1)->getBoolValue(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_getBoolValue__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; std::string *arg2 = 0 ; - std::string temp2 ; bool result; SWIG_check_num_args("ofXml::getBoolValue",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::getBoolValue",1,"ofXml const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofXml::getBoolValue",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_getBoolValue",1,SWIGTYPE_p_ofXml); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = (bool)((ofXml const *)arg1)->getBoolValue((std::string const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_getBoolValue(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXml, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Xml_getBoolValue__SWIG_0(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXml, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { return _wrap_Xml_getBoolValue__SWIG_1(L);} } - } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Xml_getBoolValue'\n" - " Possible C/C++ prototypes are:\n" " ofXml::getBoolValue() const\n" - " ofXml::getBoolValue(std::string const &) const\n"); lua_error(L);return 0; } -static int _wrap_Xml_setValue(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; std::string *arg2 = 0 ; - std::string *arg3 = 0 ; std::string temp2 ; std::string temp3 ; bool result; SWIG_check_num_args("ofXml::setValue",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::setValue",1,"ofXml *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofXml::setValue",2,"std::string const &"); - if(!lua_isstring(L,3)) SWIG_fail_arg("ofXml::setValue",3,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_setValue",1,SWIGTYPE_p_ofXml); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3; - result = (bool)(arg1)->setValue((std::string const &)*arg2,(std::string const &)*arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_getAttribute(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; std::string *arg2 = 0 ; - std::string temp2 ; std::string result; SWIG_check_num_args("ofXml::getAttribute",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::getAttribute",1,"ofXml const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofXml::getAttribute",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_getAttribute",1,SWIGTYPE_p_ofXml); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = ((ofXml const *)arg1)->getAttribute((std::string const &)*arg2); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Xml_setAttribute(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; std::string *arg2 = 0 ; - std::string *arg3 = 0 ; std::string temp2 ; std::string temp3 ; bool result; SWIG_check_num_args("ofXml::setAttribute",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::setAttribute",1,"ofXml *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofXml::setAttribute",2,"std::string const &"); - if(!lua_isstring(L,3)) SWIG_fail_arg("ofXml::setAttribute",3,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_setAttribute",1,SWIGTYPE_p_ofXml); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3; - result = (bool)(arg1)->setAttribute((std::string const &)*arg2,(std::string const &)*arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_getAttributes(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; - SwigValueWrapper< std::map< std::string,std::string > > result; SWIG_check_num_args("ofXml::getAttributes",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::getAttributes",1,"ofXml const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ - SWIG_fail_ptr("Xml_getAttributes",1,SWIGTYPE_p_ofXml); } result = ((ofXml const *)arg1)->getAttributes(); { - std::map< std::string,std::string > * resultptr = new std::map< std::string,std::string >((const std::map< std::string,std::string > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__mapT_std__string_std__string_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_getNumChildren__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; int result; - SWIG_check_num_args("ofXml::getNumChildren",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::getNumChildren",1,"ofXml const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ - SWIG_fail_ptr("Xml_getNumChildren",1,SWIGTYPE_p_ofXml); } result = (int)((ofXml const *)arg1)->getNumChildren(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_getNumChildren__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; - std::string *arg2 = 0 ; std::string temp2 ; int result; SWIG_check_num_args("ofXml::getNumChildren",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::getNumChildren",1,"ofXml const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofXml::getNumChildren",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ - SWIG_fail_ptr("Xml_getNumChildren",1,SWIGTYPE_p_ofXml); } temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = (int)((ofXml const *)arg1)->getNumChildren((std::string const &)*arg2); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_getNumChildren(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXml, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Xml_getNumChildren__SWIG_0(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXml, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { return _wrap_Xml_getNumChildren__SWIG_1(L);} - } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Xml_getNumChildren'\n" - " Possible C/C++ prototypes are:\n" " ofXml::getNumChildren() const\n" - " ofXml::getNumChildren(std::string const &) const\n"); lua_error(L);return 0; } -static int _wrap_Xml_removeAttribute(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; std::string *arg2 = 0 ; - std::string temp2 ; bool result; SWIG_check_num_args("ofXml::removeAttribute",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::removeAttribute",1,"ofXml *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofXml::removeAttribute",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ - SWIG_fail_ptr("Xml_removeAttribute",1,SWIGTYPE_p_ofXml); } temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = (bool)(arg1)->removeAttribute((std::string const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_removeAttributes__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; - std::string *arg2 = 0 ; std::string temp2 ; bool result; SWIG_check_num_args("ofXml::removeAttributes",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::removeAttributes",1,"ofXml *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofXml::removeAttributes",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ - SWIG_fail_ptr("Xml_removeAttributes",1,SWIGTYPE_p_ofXml); } temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = (bool)(arg1)->removeAttributes((std::string const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_removeAttributes__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; bool result; - SWIG_check_num_args("ofXml::removeAttributes",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::removeAttributes",1,"ofXml *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ - SWIG_fail_ptr("Xml_removeAttributes",1,SWIGTYPE_p_ofXml); } result = (bool)(arg1)->removeAttributes(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_removeAttributes(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXml, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Xml_removeAttributes__SWIG_1(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXml, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { return _wrap_Xml_removeAttributes__SWIG_0(L);} - } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Xml_removeAttributes'\n" - " Possible C/C++ prototypes are:\n" " ofXml::removeAttributes(std::string const &)\n" " ofXml::removeAttributes()\n"); - lua_error(L);return 0; } -static int _wrap_Xml_removeContents__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; - std::string *arg2 = 0 ; std::string temp2 ; bool result; SWIG_check_num_args("ofXml::removeContents",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::removeContents",1,"ofXml *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofXml::removeContents",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ - SWIG_fail_ptr("Xml_removeContents",1,SWIGTYPE_p_ofXml); } temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = (bool)(arg1)->removeContents((std::string const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_removeContents__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; bool result; - SWIG_check_num_args("ofXml::removeContents",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::removeContents",1,"ofXml *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ - SWIG_fail_ptr("Xml_removeContents",1,SWIGTYPE_p_ofXml); } result = (bool)(arg1)->removeContents(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_removeContents(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXml, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Xml_removeContents__SWIG_1(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXml, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { return _wrap_Xml_removeContents__SWIG_0(L);} - } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Xml_removeContents'\n" - " Possible C/C++ prototypes are:\n" " ofXml::removeContents(std::string const &)\n" " ofXml::removeContents()\n"); - lua_error(L);return 0; } -static int _wrap_Xml_remove__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; std::string *arg2 = 0 ; - std::string temp2 ; bool result; SWIG_check_num_args("ofXml::remove",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::remove",1,"ofXml *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofXml::remove",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_remove",1,SWIGTYPE_p_ofXml); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; result = (bool)(arg1)->remove((std::string const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_remove__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; - SWIG_check_num_args("ofXml::remove",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::remove",1,"ofXml *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_remove",1,SWIGTYPE_p_ofXml); } - (arg1)->remove(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_remove(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXml, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Xml_remove__SWIG_1(L);} } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXml, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { return _wrap_Xml_remove__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Xml_remove'\n" " Possible C/C++ prototypes are:\n" - " ofXml::remove(std::string const &)\n" " ofXml::remove()\n"); lua_error(L);return 0; } -static int _wrap_Xml_exists(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; std::string *arg2 = 0 ; - std::string temp2 ; bool result; SWIG_check_num_args("ofXml::exists",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::exists",1,"ofXml const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofXml::exists",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_exists",1,SWIGTYPE_p_ofXml); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = (bool)((ofXml const *)arg1)->exists((std::string const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_clear(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; SWIG_check_num_args("ofXml::clear",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::clear",1,"ofXml *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_clear",1,SWIGTYPE_p_ofXml); } - (arg1)->clear(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_getName(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; std::string result; - SWIG_check_num_args("ofXml::getName",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::getName",1,"ofXml const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_getName",1,SWIGTYPE_p_ofXml); } - result = ((ofXml const *)arg1)->getName(); lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_reset(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; bool result; - SWIG_check_num_args("ofXml::reset",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::reset",1,"ofXml *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_reset",1,SWIGTYPE_p_ofXml); } - result = (bool)(arg1)->reset(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Xml_setToChild(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; unsigned long arg2 ; bool result; - SWIG_check_num_args("ofXml::setToChild",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::setToChild",1,"ofXml *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofXml::setToChild",2,"unsigned long"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_setToChild",1,SWIGTYPE_p_ofXml); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned long)lua_tonumber(L, 2); - result = (bool)(arg1)->setToChild(arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_setTo(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; std::string *arg2 = 0 ; - std::string temp2 ; bool result; SWIG_check_num_args("ofXml::setTo",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::setTo",1,"ofXml *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofXml::setTo",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_setTo",1,SWIGTYPE_p_ofXml); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; result = (bool)(arg1)->setTo((std::string const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_setToParent__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; bool result; - SWIG_check_num_args("ofXml::setToParent",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::setToParent",1,"ofXml *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_setToParent",1,SWIGTYPE_p_ofXml); } - result = (bool)(arg1)->setToParent(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_setToParent__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; int arg2 ; bool result; - SWIG_check_num_args("ofXml::setToParent",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::setToParent",1,"ofXml *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofXml::setToParent",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_setToParent",1,SWIGTYPE_p_ofXml); } - arg2 = (int)lua_tonumber(L, 2); result = (bool)(arg1)->setToParent(arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_setToParent(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXml, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Xml_setToParent__SWIG_0(L);} } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXml, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Xml_setToParent__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Xml_setToParent'\n" " Possible C/C++ prototypes are:\n" - " ofXml::setToParent()\n" " ofXml::setToParent(int)\n"); lua_error(L);return 0; } -static int _wrap_Xml_setToSibling(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; bool result; - SWIG_check_num_args("ofXml::setToSibling",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::setToSibling",1,"ofXml *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_setToSibling",1,SWIGTYPE_p_ofXml); } - result = (bool)(arg1)->setToSibling(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_setToPrevSibling(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; bool result; - SWIG_check_num_args("ofXml::setToPrevSibling",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::setToPrevSibling",1,"ofXml *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ - SWIG_fail_ptr("Xml_setToPrevSibling",1,SWIGTYPE_p_ofXml); } result = (bool)(arg1)->setToPrevSibling(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_loadFromBuffer(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; std::string *arg2 = 0 ; - std::string temp2 ; bool result; SWIG_check_num_args("ofXml::loadFromBuffer",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::loadFromBuffer",1,"ofXml *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofXml::loadFromBuffer",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ - SWIG_fail_ptr("Xml_loadFromBuffer",1,SWIGTYPE_p_ofXml); } temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = (bool)(arg1)->loadFromBuffer((std::string const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_toString(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; std::string result; - SWIG_check_num_args("ofXml::toString",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::toString",1,"ofXml const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_toString",1,SWIGTYPE_p_ofXml); } - result = ((ofXml const *)arg1)->toString(); lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_serialize(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; ofAbstractParameter *arg2 = 0 ; - SWIG_check_num_args("ofXml::serialize",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::serialize",1,"ofXml *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofXml::serialize",2,"ofAbstractParameter const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_serialize",1,SWIGTYPE_p_ofXml); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofAbstractParameter,0))){ - SWIG_fail_ptr("Xml_serialize",2,SWIGTYPE_p_ofAbstractParameter); } (arg1)->serialize((ofAbstractParameter const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_deserialize(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; ofAbstractParameter *arg2 = 0 ; - SWIG_check_num_args("ofXml::deserialize",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::deserialize",1,"ofXml *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofXml::deserialize",2,"ofAbstractParameter &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_deserialize",1,SWIGTYPE_p_ofXml); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofAbstractParameter,0))){ - SWIG_fail_ptr("Xml_deserialize",2,SWIGTYPE_p_ofAbstractParameter); } (arg1)->deserialize(*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_tokenize(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; - std::string temp1 ; std::string temp2 ; std::vector< std::string > result; SWIG_check_num_args("ofXml::tokenize",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofXml::tokenize",1,"std::string const &"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofXml::tokenize",2,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = ofXml::tokenize((std::string const &)*arg1,(std::string const &)*arg2); { - std::vector< std::string > * resultptr = new std::vector< std::string >((const std::vector< std::string > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_std__string_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_Xml(void *obj) { -ofXml *arg1 = (ofXml *) obj; -delete arg1; -} -static int _proxy__wrap_new_Xml(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_Xml); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_Xml_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_Xml_methods[]= { - { "load", _wrap_Xml_load}, - { "save", _wrap_Xml_save}, - { "addChild", _wrap_Xml_addChild}, - { "addXml", _wrap_Xml_addXml}, - { "getValue", _wrap_Xml_getValue}, - { "getIntValue", _wrap_Xml_getIntValue}, - { "getInt64Value", _wrap_Xml_getInt64Value}, - { "getFloatValue", _wrap_Xml_getFloatValue}, - { "getBoolValue", _wrap_Xml_getBoolValue}, - { "setValue", _wrap_Xml_setValue}, - { "getAttribute", _wrap_Xml_getAttribute}, - { "setAttribute", _wrap_Xml_setAttribute}, - { "getAttributes", _wrap_Xml_getAttributes}, - { "getNumChildren", _wrap_Xml_getNumChildren}, - { "removeAttribute", _wrap_Xml_removeAttribute}, - { "removeAttributes", _wrap_Xml_removeAttributes}, - { "removeContents", _wrap_Xml_removeContents}, - { "remove", _wrap_Xml_remove}, - { "exists", _wrap_Xml_exists}, - { "clear", _wrap_Xml_clear}, - { "getName", _wrap_Xml_getName}, - { "reset", _wrap_Xml_reset}, - { "setToChild", _wrap_Xml_setToChild}, - { "setTo", _wrap_Xml_setTo}, - { "setToParent", _wrap_Xml_setToParent}, - { "setToSibling", _wrap_Xml_setToSibling}, - { "setToPrevSibling", _wrap_Xml_setToPrevSibling}, - { "loadFromBuffer", _wrap_Xml_loadFromBuffer}, - { "toString", _wrap_Xml_toString}, - { "serialize", _wrap_Xml_serialize}, - { "deserialize", _wrap_Xml_deserialize}, - {0,0} -}; -static swig_lua_method swig_Xml_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_Xml_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_Xml_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_Xml_Sf_SwigStatic_methods[]= { - { "tokenize", _wrap_Xml_tokenize}, - {0,0} -}; -static swig_lua_class* swig_Xml_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_Xml_Sf_SwigStatic = { - "Xml", - swig_Xml_Sf_SwigStatic_methods, - swig_Xml_Sf_SwigStatic_attributes, - swig_Xml_Sf_SwigStatic_constants, - swig_Xml_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_Xml_bases[] = {0}; -static const char *swig_Xml_base_names[] = {0}; -static swig_lua_class _wrap_class_Xml = { "Xml", "Xml", &SWIGTYPE_p_ofXml,_proxy__wrap_new_Xml, swig_delete_Xml, swig_Xml_methods, swig_Xml_attributes, &swig_Xml_Sf_SwigStatic, swig_Xml_meta, swig_Xml_bases, swig_Xml_base_names }; - -static int _wrap_new_MatrixStack(lua_State* L) { int SWIG_arg = 0; ofAppBaseWindow *arg1 = (ofAppBaseWindow *) 0 ; - ofMatrixStack *result = 0 ; SWIG_check_num_args("ofMatrixStack::ofMatrixStack",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::ofMatrixStack",1,"ofAppBaseWindow const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofAppBaseWindow,0))){ - SWIG_fail_ptr("new_MatrixStack",1,SWIGTYPE_p_ofAppBaseWindow); } - result = (ofMatrixStack *)new ofMatrixStack((ofAppBaseWindow const *)arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMatrixStack,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_MatrixStack_setRenderSurface__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; ofFbo *arg2 = 0 ; SWIG_check_num_args("ofMatrixStack::setRenderSurface",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::setRenderSurface",1,"ofMatrixStack *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrixStack::setRenderSurface",2,"ofFbo const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_setRenderSurface",1,SWIGTYPE_p_ofMatrixStack); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofFbo,0))){ - SWIG_fail_ptr("MatrixStack_setRenderSurface",2,SWIGTYPE_p_ofFbo); } (arg1)->setRenderSurface((ofFbo const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_MatrixStack_setRenderSurface__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; ofAppBaseWindow *arg2 = 0 ; - SWIG_check_num_args("ofMatrixStack::setRenderSurface",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::setRenderSurface",1,"ofMatrixStack *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrixStack::setRenderSurface",2,"ofAppBaseWindow const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_setRenderSurface",1,SWIGTYPE_p_ofMatrixStack); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofAppBaseWindow,0))){ - SWIG_fail_ptr("MatrixStack_setRenderSurface",2,SWIGTYPE_p_ofAppBaseWindow); } - (arg1)->setRenderSurface((ofAppBaseWindow const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_MatrixStack_setRenderSurface(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrixStack, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_MatrixStack_setRenderSurface__SWIG_0(L);} } } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrixStack, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofAppBaseWindow, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_MatrixStack_setRenderSurface__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'MatrixStack_setRenderSurface'\n" - " Possible C/C++ prototypes are:\n" " ofMatrixStack::setRenderSurface(ofFbo const &)\n" - " ofMatrixStack::setRenderSurface(ofAppBaseWindow const &)\n"); lua_error(L);return 0; } -static int _wrap_MatrixStack_setOrientation(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; - ofOrientation arg2 ; bool arg3 ; SWIG_check_num_args("ofMatrixStack::setOrientation",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::setOrientation",1,"ofMatrixStack *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrixStack::setOrientation",2,"ofOrientation"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofMatrixStack::setOrientation",3,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_setOrientation",1,SWIGTYPE_p_ofMatrixStack); } arg2 = (ofOrientation)(int)lua_tonumber(L, 2); - arg3 = (lua_toboolean(L, 3)!=0); (arg1)->setOrientation(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_MatrixStack_getOrientation(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; - ofOrientation result; SWIG_check_num_args("ofMatrixStack::getOrientation",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::getOrientation",1,"ofMatrixStack const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_getOrientation",1,SWIGTYPE_p_ofMatrixStack); } - result = (ofOrientation)((ofMatrixStack const *)arg1)->getOrientation(); - lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_MatrixStack_viewport(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; float arg2 ; - float arg3 ; float arg4 ; float arg5 ; bool arg6 ; SWIG_check_num_args("ofMatrixStack::viewport",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::viewport",1,"ofMatrixStack *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrixStack::viewport",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrixStack::viewport",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrixStack::viewport",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMatrixStack::viewport",5,"float"); - if(!lua_isboolean(L,6)) SWIG_fail_arg("ofMatrixStack::viewport",6,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_viewport",1,SWIGTYPE_p_ofMatrixStack); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (lua_toboolean(L, 6)!=0); (arg1)->viewport(arg2,arg3,arg4,arg5,arg6); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_MatrixStack_nativeViewport(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; - ofRectangle arg2 ; ofRectangle *argp2 ; SWIG_check_num_args("ofMatrixStack::nativeViewport",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::nativeViewport",1,"ofMatrixStack *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrixStack::nativeViewport",2,"ofRectangle"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_nativeViewport",1,SWIGTYPE_p_ofMatrixStack); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("MatrixStack_nativeViewport",2,SWIGTYPE_p_ofRectangle); } arg2 = *argp2; (arg1)->nativeViewport(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_MatrixStack_getCurrentViewport(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; - ofRectangle result; SWIG_check_num_args("ofMatrixStack::getCurrentViewport",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::getCurrentViewport",1,"ofMatrixStack const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_getCurrentViewport",1,SWIGTYPE_p_ofMatrixStack); } - result = ((ofMatrixStack const *)arg1)->getCurrentViewport(); { - ofRectangle * resultptr = new ofRectangle((const ofRectangle &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofRectangle,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_MatrixStack_getNativeViewport(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; - ofRectangle result; SWIG_check_num_args("ofMatrixStack::getNativeViewport",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::getNativeViewport",1,"ofMatrixStack const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_getNativeViewport",1,SWIGTYPE_p_ofMatrixStack); } - result = ((ofMatrixStack const *)arg1)->getNativeViewport(); { - ofRectangle * resultptr = new ofRectangle((const ofRectangle &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofRectangle,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_MatrixStack_getFullSurfaceViewport(lua_State* L) { int SWIG_arg = 0; - ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; ofRectangle result; - SWIG_check_num_args("ofMatrixStack::getFullSurfaceViewport",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::getFullSurfaceViewport",1,"ofMatrixStack const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_getFullSurfaceViewport",1,SWIGTYPE_p_ofMatrixStack); } - result = ((ofMatrixStack const *)arg1)->getFullSurfaceViewport(); { - ofRectangle * resultptr = new ofRectangle((const ofRectangle &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofRectangle,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_MatrixStack_getProjectionMatrix(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; - ofMatrix4x4 *result = 0 ; SWIG_check_num_args("ofMatrixStack::getProjectionMatrix",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::getProjectionMatrix",1,"ofMatrixStack const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_getProjectionMatrix",1,SWIGTYPE_p_ofMatrixStack); } - result = (ofMatrix4x4 *) &((ofMatrixStack const *)arg1)->getProjectionMatrix(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMatrix4x4,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_MatrixStack_getViewMatrix(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; - ofMatrix4x4 *result = 0 ; SWIG_check_num_args("ofMatrixStack::getViewMatrix",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::getViewMatrix",1,"ofMatrixStack const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_getViewMatrix",1,SWIGTYPE_p_ofMatrixStack); } - result = (ofMatrix4x4 *) &((ofMatrixStack const *)arg1)->getViewMatrix(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMatrix4x4,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_MatrixStack_getModelViewMatrix(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; - ofMatrix4x4 *result = 0 ; SWIG_check_num_args("ofMatrixStack::getModelViewMatrix",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::getModelViewMatrix",1,"ofMatrixStack const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_getModelViewMatrix",1,SWIGTYPE_p_ofMatrixStack); } - result = (ofMatrix4x4 *) &((ofMatrixStack const *)arg1)->getModelViewMatrix(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMatrix4x4,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_MatrixStack_getModelViewProjectionMatrix(lua_State* L) { int SWIG_arg = 0; - ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; ofMatrix4x4 *result = 0 ; - SWIG_check_num_args("ofMatrixStack::getModelViewProjectionMatrix",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::getModelViewProjectionMatrix",1,"ofMatrixStack const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_getModelViewProjectionMatrix",1,SWIGTYPE_p_ofMatrixStack); } - result = (ofMatrix4x4 *) &((ofMatrixStack const *)arg1)->getModelViewProjectionMatrix(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMatrix4x4,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_MatrixStack_getTextureMatrix(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; - ofMatrix4x4 *result = 0 ; SWIG_check_num_args("ofMatrixStack::getTextureMatrix",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::getTextureMatrix",1,"ofMatrixStack const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_getTextureMatrix",1,SWIGTYPE_p_ofMatrixStack); } - result = (ofMatrix4x4 *) &((ofMatrixStack const *)arg1)->getTextureMatrix(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMatrix4x4,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_MatrixStack_getCurrentMatrix(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; - ofMatrix4x4 *result = 0 ; SWIG_check_num_args("ofMatrixStack::getCurrentMatrix",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::getCurrentMatrix",1,"ofMatrixStack const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_getCurrentMatrix",1,SWIGTYPE_p_ofMatrixStack); } - result = (ofMatrix4x4 *) &((ofMatrixStack const *)arg1)->getCurrentMatrix(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMatrix4x4,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_MatrixStack_getProjectionMatrixNoOrientation(lua_State* L) { int SWIG_arg = 0; - ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; ofMatrix4x4 *result = 0 ; - SWIG_check_num_args("ofMatrixStack::getProjectionMatrixNoOrientation",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::getProjectionMatrixNoOrientation",1,"ofMatrixStack const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_getProjectionMatrixNoOrientation",1,SWIGTYPE_p_ofMatrixStack); } - result = (ofMatrix4x4 *) &((ofMatrixStack const *)arg1)->getProjectionMatrixNoOrientation(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMatrix4x4,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_MatrixStack_getOrientationMatrix(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; - ofMatrix4x4 *result = 0 ; SWIG_check_num_args("ofMatrixStack::getOrientationMatrix",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::getOrientationMatrix",1,"ofMatrixStack const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_getOrientationMatrix",1,SWIGTYPE_p_ofMatrixStack); } - result = (ofMatrix4x4 *) &((ofMatrixStack const *)arg1)->getOrientationMatrix(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMatrix4x4,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_MatrixStack_getOrientationMatrixInverse(lua_State* L) { int SWIG_arg = 0; - ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; ofMatrix4x4 *result = 0 ; - SWIG_check_num_args("ofMatrixStack::getOrientationMatrixInverse",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::getOrientationMatrixInverse",1,"ofMatrixStack const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_getOrientationMatrixInverse",1,SWIGTYPE_p_ofMatrixStack); } - result = (ofMatrix4x4 *) &((ofMatrixStack const *)arg1)->getOrientationMatrixInverse(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMatrix4x4,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_MatrixStack_getCurrentMatrixMode(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; - ofMatrixMode result; SWIG_check_num_args("ofMatrixStack::getCurrentMatrixMode",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::getCurrentMatrixMode",1,"ofMatrixStack const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_getCurrentMatrixMode",1,SWIGTYPE_p_ofMatrixStack); } - result = (ofMatrixMode)((ofMatrixStack const *)arg1)->getCurrentMatrixMode(); - lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_MatrixStack_getHandedness(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; - ofHandednessType result; SWIG_check_num_args("ofMatrixStack::getHandedness",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::getHandedness",1,"ofMatrixStack const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_getHandedness",1,SWIGTYPE_p_ofMatrixStack); } - result = (ofHandednessType)((ofMatrixStack const *)arg1)->getHandedness(); - lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_MatrixStack_isVFlipped(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; - bool result; SWIG_check_num_args("ofMatrixStack::isVFlipped",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::isVFlipped",1,"ofMatrixStack const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_isVFlipped",1,SWIGTYPE_p_ofMatrixStack); } - result = (bool)((ofMatrixStack const *)arg1)->isVFlipped(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_MatrixStack_customMatrixNeedsFlip(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; - bool result; SWIG_check_num_args("ofMatrixStack::customMatrixNeedsFlip",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::customMatrixNeedsFlip",1,"ofMatrixStack const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_customMatrixNeedsFlip",1,SWIGTYPE_p_ofMatrixStack); } - result = (bool)((ofMatrixStack const *)arg1)->customMatrixNeedsFlip(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_MatrixStack_pushView(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; - SWIG_check_num_args("ofMatrixStack::pushView",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::pushView",1,"ofMatrixStack *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_pushView",1,SWIGTYPE_p_ofMatrixStack); } (arg1)->pushView(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_MatrixStack_popView(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; - SWIG_check_num_args("ofMatrixStack::popView",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::popView",1,"ofMatrixStack *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_popView",1,SWIGTYPE_p_ofMatrixStack); } (arg1)->popView(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_MatrixStack_pushMatrix(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; - SWIG_check_num_args("ofMatrixStack::pushMatrix",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::pushMatrix",1,"ofMatrixStack *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_pushMatrix",1,SWIGTYPE_p_ofMatrixStack); } (arg1)->pushMatrix(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_MatrixStack_popMatrix(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; - SWIG_check_num_args("ofMatrixStack::popMatrix",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::popMatrix",1,"ofMatrixStack *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_popMatrix",1,SWIGTYPE_p_ofMatrixStack); } (arg1)->popMatrix(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_MatrixStack_translate__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; - float arg2 ; float arg3 ; float arg4 ; SWIG_check_num_args("ofMatrixStack::translate",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::translate",1,"ofMatrixStack *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrixStack::translate",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrixStack::translate",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrixStack::translate",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_translate",1,SWIGTYPE_p_ofMatrixStack); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); (arg1)->translate(arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_MatrixStack_translate__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; - float arg2 ; float arg3 ; SWIG_check_num_args("ofMatrixStack::translate",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::translate",1,"ofMatrixStack *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrixStack::translate",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrixStack::translate",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_translate",1,SWIGTYPE_p_ofMatrixStack); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->translate(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_MatrixStack_translate(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrixStack, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_MatrixStack_translate__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrixStack, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_MatrixStack_translate__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'MatrixStack_translate'\n" - " Possible C/C++ prototypes are:\n" " ofMatrixStack::translate(float,float,float)\n" - " ofMatrixStack::translate(float,float)\n"); lua_error(L);return 0; } -static int _wrap_MatrixStack_scale__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; - float arg2 ; float arg3 ; float arg4 ; SWIG_check_num_args("ofMatrixStack::scale",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::scale",1,"ofMatrixStack *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrixStack::scale",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrixStack::scale",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrixStack::scale",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_scale",1,SWIGTYPE_p_ofMatrixStack); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); (arg1)->scale(arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_MatrixStack_scale__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; - float arg2 ; float arg3 ; SWIG_check_num_args("ofMatrixStack::scale",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::scale",1,"ofMatrixStack *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrixStack::scale",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrixStack::scale",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_scale",1,SWIGTYPE_p_ofMatrixStack); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->scale(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_MatrixStack_scale(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrixStack, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_MatrixStack_scale__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrixStack, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_MatrixStack_scale__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'MatrixStack_scale'\n" " Possible C/C++ prototypes are:\n" - " ofMatrixStack::scale(float,float,float)\n" " ofMatrixStack::scale(float,float)\n"); lua_error(L);return 0; } -static int _wrap_MatrixStack_rotate(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; float arg2 ; - float arg3 ; float arg4 ; float arg5 ; SWIG_check_num_args("ofMatrixStack::rotate",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::rotate",1,"ofMatrixStack *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrixStack::rotate",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrixStack::rotate",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrixStack::rotate",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMatrixStack::rotate",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_rotate",1,SWIGTYPE_p_ofMatrixStack); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - (arg1)->rotate(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_MatrixStack_matrixMode(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; - ofMatrixMode arg2 ; SWIG_check_num_args("ofMatrixStack::matrixMode",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::matrixMode",1,"ofMatrixStack *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrixStack::matrixMode",2,"ofMatrixMode"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_matrixMode",1,SWIGTYPE_p_ofMatrixStack); } arg2 = (ofMatrixMode)(int)lua_tonumber(L, 2); - (arg1)->matrixMode(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_MatrixStack_loadIdentityMatrix(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; - SWIG_check_num_args("ofMatrixStack::loadIdentityMatrix",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::loadIdentityMatrix",1,"ofMatrixStack *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_loadIdentityMatrix",1,SWIGTYPE_p_ofMatrixStack); } (arg1)->loadIdentityMatrix(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_MatrixStack_loadMatrix(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; - float *arg2 = (float *) 0 ; SWIG_check_num_args("ofMatrixStack::loadMatrix",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::loadMatrix",1,"ofMatrixStack *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofMatrixStack::loadMatrix",2,"float const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_loadMatrix",1,SWIGTYPE_p_ofMatrixStack); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("MatrixStack_loadMatrix",2,SWIGTYPE_p_float); } (arg1)->loadMatrix((float const *)arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_MatrixStack_multMatrix(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; - float *arg2 = (float *) 0 ; SWIG_check_num_args("ofMatrixStack::multMatrix",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::multMatrix",1,"ofMatrixStack *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofMatrixStack::multMatrix",2,"float const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_multMatrix",1,SWIGTYPE_p_ofMatrixStack); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("MatrixStack_multMatrix",2,SWIGTYPE_p_float); } (arg1)->multMatrix((float const *)arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_MatrixStack_loadViewMatrix(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; - ofMatrix4x4 *arg2 = 0 ; SWIG_check_num_args("ofMatrixStack::loadViewMatrix",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::loadViewMatrix",1,"ofMatrixStack *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrixStack::loadViewMatrix",2,"ofMatrix4x4 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_loadViewMatrix",1,SWIGTYPE_p_ofMatrixStack); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("MatrixStack_loadViewMatrix",2,SWIGTYPE_p_ofMatrix4x4); } (arg1)->loadViewMatrix((ofMatrix4x4 const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_MatrixStack_multViewMatrix(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; - ofMatrix4x4 *arg2 = 0 ; SWIG_check_num_args("ofMatrixStack::multViewMatrix",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::multViewMatrix",1,"ofMatrixStack *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrixStack::multViewMatrix",2,"ofMatrix4x4 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_multViewMatrix",1,SWIGTYPE_p_ofMatrixStack); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("MatrixStack_multViewMatrix",2,SWIGTYPE_p_ofMatrix4x4); } (arg1)->multViewMatrix((ofMatrix4x4 const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_MatrixStack_clearStacks(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; - SWIG_check_num_args("ofMatrixStack::clearStacks",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::clearStacks",1,"ofMatrixStack *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_clearStacks",1,SWIGTYPE_p_ofMatrixStack); } (arg1)->clearStacks(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_MatrixStack_doesHardwareOrientation(lua_State* L) { int SWIG_arg = 0; - ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; bool result; SWIG_check_num_args("ofMatrixStack::doesHardwareOrientation",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::doesHardwareOrientation",1,"ofMatrixStack const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_doesHardwareOrientation",1,SWIGTYPE_p_ofMatrixStack); } - result = (bool)((ofMatrixStack const *)arg1)->doesHardwareOrientation(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_MatrixStack(void *obj) { -ofMatrixStack *arg1 = (ofMatrixStack *) obj; -delete arg1; -} -static int _proxy__wrap_new_MatrixStack(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_MatrixStack); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_MatrixStack_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_MatrixStack_methods[]= { - { "setRenderSurface", _wrap_MatrixStack_setRenderSurface}, - { "setOrientation", _wrap_MatrixStack_setOrientation}, - { "getOrientation", _wrap_MatrixStack_getOrientation}, - { "viewport", _wrap_MatrixStack_viewport}, - { "nativeViewport", _wrap_MatrixStack_nativeViewport}, - { "getCurrentViewport", _wrap_MatrixStack_getCurrentViewport}, - { "getNativeViewport", _wrap_MatrixStack_getNativeViewport}, - { "getFullSurfaceViewport", _wrap_MatrixStack_getFullSurfaceViewport}, - { "getProjectionMatrix", _wrap_MatrixStack_getProjectionMatrix}, - { "getViewMatrix", _wrap_MatrixStack_getViewMatrix}, - { "getModelViewMatrix", _wrap_MatrixStack_getModelViewMatrix}, - { "getModelViewProjectionMatrix", _wrap_MatrixStack_getModelViewProjectionMatrix}, - { "getTextureMatrix", _wrap_MatrixStack_getTextureMatrix}, - { "getCurrentMatrix", _wrap_MatrixStack_getCurrentMatrix}, - { "getProjectionMatrixNoOrientation", _wrap_MatrixStack_getProjectionMatrixNoOrientation}, - { "getOrientationMatrix", _wrap_MatrixStack_getOrientationMatrix}, - { "getOrientationMatrixInverse", _wrap_MatrixStack_getOrientationMatrixInverse}, - { "getCurrentMatrixMode", _wrap_MatrixStack_getCurrentMatrixMode}, - { "getHandedness", _wrap_MatrixStack_getHandedness}, - { "isVFlipped", _wrap_MatrixStack_isVFlipped}, - { "customMatrixNeedsFlip", _wrap_MatrixStack_customMatrixNeedsFlip}, - { "pushView", _wrap_MatrixStack_pushView}, - { "popView", _wrap_MatrixStack_popView}, - { "pushMatrix", _wrap_MatrixStack_pushMatrix}, - { "popMatrix", _wrap_MatrixStack_popMatrix}, - { "translate", _wrap_MatrixStack_translate}, - { "scale", _wrap_MatrixStack_scale}, - { "rotate", _wrap_MatrixStack_rotate}, - { "matrixMode", _wrap_MatrixStack_matrixMode}, - { "loadIdentityMatrix", _wrap_MatrixStack_loadIdentityMatrix}, - { "loadMatrix", _wrap_MatrixStack_loadMatrix}, - { "multMatrix", _wrap_MatrixStack_multMatrix}, - { "loadViewMatrix", _wrap_MatrixStack_loadViewMatrix}, - { "multViewMatrix", _wrap_MatrixStack_multViewMatrix}, - { "clearStacks", _wrap_MatrixStack_clearStacks}, - { "doesHardwareOrientation", _wrap_MatrixStack_doesHardwareOrientation}, - {0,0} -}; -static swig_lua_method swig_MatrixStack_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_MatrixStack_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_MatrixStack_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_MatrixStack_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_MatrixStack_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_MatrixStack_Sf_SwigStatic = { - "MatrixStack", - swig_MatrixStack_Sf_SwigStatic_methods, - swig_MatrixStack_Sf_SwigStatic_attributes, - swig_MatrixStack_Sf_SwigStatic_constants, - swig_MatrixStack_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_MatrixStack_bases[] = {0}; -static const char *swig_MatrixStack_base_names[] = {0}; -static swig_lua_class _wrap_class_MatrixStack = { "MatrixStack", "MatrixStack", &SWIGTYPE_p_ofMatrixStack,_proxy__wrap_new_MatrixStack, swig_delete_MatrixStack, swig_MatrixStack_methods, swig_MatrixStack_attributes, &swig_MatrixStack_Sf_SwigStatic, swig_MatrixStack_meta, swig_MatrixStack_bases, swig_MatrixStack_base_names }; - -static int _wrap_new_Buffer__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofBuffer *result = 0 ; - SWIG_check_num_args("ofBuffer::ofBuffer",0,0) result = (ofBuffer *)new ofBuffer(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofBuffer,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Buffer__SWIG_1(lua_State* L) { int SWIG_arg = 0; char *arg1 = (char *) 0 ; std::size_t arg2 ; - ofBuffer *result = 0 ; SWIG_check_num_args("ofBuffer::ofBuffer",1,1) { arg2 = (size_t)lua_tonumber(L, 1+1); - arg1 = (char *)lua_tolstring(L, 1, &arg2); } result = (ofBuffer *)new ofBuffer((char const *)arg1,arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofBuffer,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Buffer(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_Buffer__SWIG_0(L);} if (argc == 1) { int _v; { _v = SWIG_lua_isnilstring(L,argv[0]); } if (_v) { - if (argc <= 1) { return _wrap_new_Buffer__SWIG_1(L);} { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_new_Buffer__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_Buffer'\n" " Possible C/C++ prototypes are:\n" - " ofBuffer::ofBuffer()\n" " ofBuffer::ofBuffer(char const *,std::size_t)\n"); lua_error(L);return 0; } -static int _wrap_Buffer_set(lua_State* L) { int SWIG_arg = 0; ofBuffer *arg1 = (ofBuffer *) 0 ; char *arg2 = (char *) 0 ; - std::size_t arg3 ; SWIG_check_num_args("ofBuffer::set",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBuffer::set",1,"ofBuffer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBuffer,0))){ SWIG_fail_ptr("Buffer_set",1,SWIGTYPE_p_ofBuffer); } - { arg3 = (size_t)lua_tonumber(L, 2+1); arg2 = (char *)lua_tolstring(L, 2, &arg3); } (arg1)->set((char const *)arg2,arg3); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Buffer_append(lua_State* L) { int SWIG_arg = 0; ofBuffer *arg1 = (ofBuffer *) 0 ; char *arg2 = (char *) 0 ; - std::size_t arg3 ; SWIG_check_num_args("ofBuffer::append",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBuffer::append",1,"ofBuffer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBuffer,0))){ - SWIG_fail_ptr("Buffer_append",1,SWIGTYPE_p_ofBuffer); } { arg3 = (size_t)lua_tonumber(L, 2+1); - arg2 = (char *)lua_tolstring(L, 2, &arg3); } (arg1)->append((char const *)arg2,arg3); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Buffer_clear(lua_State* L) { int SWIG_arg = 0; ofBuffer *arg1 = (ofBuffer *) 0 ; - SWIG_check_num_args("ofBuffer::clear",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBuffer::clear",1,"ofBuffer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBuffer,0))){ - SWIG_fail_ptr("Buffer_clear",1,SWIGTYPE_p_ofBuffer); } (arg1)->clear(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Buffer_allocate(lua_State* L) { int SWIG_arg = 0; ofBuffer *arg1 = (ofBuffer *) 0 ; std::size_t arg2 ; - SWIG_check_num_args("ofBuffer::allocate",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBuffer::allocate",1,"ofBuffer *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBuffer::allocate",2,"std::size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBuffer,0))){ - SWIG_fail_ptr("Buffer_allocate",1,SWIGTYPE_p_ofBuffer); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (std::size_t)lua_tonumber(L, 2); - (arg1)->allocate(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Buffer_getData(lua_State* L) { int SWIG_arg = 0; ofBuffer *arg1 = (ofBuffer *) 0 ; char *result = 0 ; - SWIG_check_num_args("ofBuffer::getData",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBuffer::getData",1,"ofBuffer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBuffer,0))){ - SWIG_fail_ptr("Buffer_getData",1,SWIGTYPE_p_ofBuffer); } result = (char *)((ofBuffer const *)arg1)->getData(); - lua_pushstring(L,(const char *)result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Buffer_getText(lua_State* L) { int SWIG_arg = 0; ofBuffer *arg1 = (ofBuffer *) 0 ; std::string result; - SWIG_check_num_args("ofBuffer::getText",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBuffer::getText",1,"ofBuffer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBuffer,0))){ - SWIG_fail_ptr("Buffer_getText",1,SWIGTYPE_p_ofBuffer); } result = ((ofBuffer const *)arg1)->getText(); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Buffer_size(lua_State* L) { int SWIG_arg = 0; ofBuffer *arg1 = (ofBuffer *) 0 ; long result; - SWIG_check_num_args("ofBuffer::size",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBuffer::size",1,"ofBuffer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBuffer,0))){ - SWIG_fail_ptr("Buffer_size",1,SWIGTYPE_p_ofBuffer); } result = (long)((ofBuffer const *)arg1)->size(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_Buffer(void *obj) { -ofBuffer *arg1 = (ofBuffer *) obj; -delete arg1; -} -static int _proxy__wrap_new_Buffer(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_Buffer); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_Buffer_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_Buffer_methods[]= { - { "set", _wrap_Buffer_set}, - { "append", _wrap_Buffer_append}, - { "clear", _wrap_Buffer_clear}, - { "allocate", _wrap_Buffer_allocate}, - { "getData", _wrap_Buffer_getData}, - { "getText", _wrap_Buffer_getText}, - { "size", _wrap_Buffer_size}, - {0,0} -}; -static swig_lua_method swig_Buffer_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_Buffer_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_Buffer_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_Buffer_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_Buffer_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_Buffer_Sf_SwigStatic = { - "Buffer", - swig_Buffer_Sf_SwigStatic_methods, - swig_Buffer_Sf_SwigStatic_attributes, - swig_Buffer_Sf_SwigStatic_constants, - swig_Buffer_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_Buffer_bases[] = {0}; -static const char *swig_Buffer_base_names[] = {0}; -static swig_lua_class _wrap_class_Buffer = { "Buffer", "Buffer", &SWIGTYPE_p_ofBuffer,_proxy__wrap_new_Buffer, swig_delete_Buffer, swig_Buffer_methods, swig_Buffer_attributes, &swig_Buffer_Sf_SwigStatic, swig_Buffer_meta, swig_Buffer_bases, swig_Buffer_base_names }; - -static int _wrap_bufferFromFile__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; bool arg2 ; - std::string temp1 ; ofBuffer result; SWIG_check_num_args("ofBufferFromFile",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofBufferFromFile",1,"std::string const &"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofBufferFromFile",2,"bool"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; arg2 = (lua_toboolean(L, 2)!=0); - result = ofBufferFromFile((std::string const &)*arg1,arg2); { ofBuffer * resultptr = new ofBuffer((const ofBuffer &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofBuffer,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_bufferFromFile__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - ofBuffer result; SWIG_check_num_args("ofBufferFromFile",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofBufferFromFile",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = ofBufferFromFile((std::string const &)*arg1); { - ofBuffer * resultptr = new ofBuffer((const ofBuffer &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofBuffer,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_bufferFromFile(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; - { _v = lua_isstring(L,argv[0]); } if (_v) { return _wrap_bufferFromFile__SWIG_1(L);} } if (argc == 2) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_bufferFromFile__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'bufferFromFile'\n" " Possible C/C++ prototypes are:\n" - " ofBufferFromFile(std::string const &,bool)\n" " ofBufferFromFile(std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_bufferToFile__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; ofBuffer *arg2 = 0 ; bool arg3 ; - std::string temp1 ; bool result; SWIG_check_num_args("ofBufferToFile",3,3) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofBufferToFile",1,"std::string const &"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofBufferToFile",2,"ofBuffer &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofBufferToFile",3,"bool"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBuffer,0))){ - SWIG_fail_ptr("bufferToFile",2,SWIGTYPE_p_ofBuffer); } arg3 = (lua_toboolean(L, 3)!=0); - result = (bool)ofBufferToFile((std::string const &)*arg1,*arg2,arg3); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_bufferToFile__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; ofBuffer *arg2 = 0 ; - std::string temp1 ; bool result; SWIG_check_num_args("ofBufferToFile",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofBufferToFile",1,"std::string const &"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofBufferToFile",2,"ofBuffer &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBuffer,0))){ - SWIG_fail_ptr("bufferToFile",2,SWIGTYPE_p_ofBuffer); } result = (bool)ofBufferToFile((std::string const &)*arg1,*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_bufferToFile(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { int _v; - { _v = lua_isstring(L,argv[0]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBuffer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_bufferToFile__SWIG_1(L);} } } if (argc == 3) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBuffer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { return _wrap_bufferToFile__SWIG_0(L);} } - } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'bufferToFile'\n" - " Possible C/C++ prototypes are:\n" " ofBufferToFile(std::string const &,ofBuffer &,bool)\n" - " ofBufferToFile(std::string const &,ofBuffer &)\n"); lua_error(L);return 0; } -static int _wrap_FilePath_getFileExt(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - std::string result; SWIG_check_num_args("ofFilePath::getFileExt",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFilePath::getFileExt",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = ofFilePath::getFileExt((std::string const &)*arg1); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FilePath_removeExt(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - std::string result; SWIG_check_num_args("ofFilePath::removeExt",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFilePath::removeExt",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = ofFilePath::removeExt((std::string const &)*arg1); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FilePath_addLeadingSlash(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - std::string result; SWIG_check_num_args("ofFilePath::addLeadingSlash",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFilePath::addLeadingSlash",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; - result = ofFilePath::addLeadingSlash((std::string const &)*arg1); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FilePath_addTrailingSlash(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - std::string result; SWIG_check_num_args("ofFilePath::addTrailingSlash",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFilePath::addTrailingSlash",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; - result = ofFilePath::addTrailingSlash((std::string const &)*arg1); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FilePath_removeTrailingSlash(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - std::string result; SWIG_check_num_args("ofFilePath::removeTrailingSlash",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFilePath::removeTrailingSlash",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; - result = ofFilePath::removeTrailingSlash((std::string const &)*arg1); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FilePath_getPathForDirectory(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - std::string result; SWIG_check_num_args("ofFilePath::getPathForDirectory",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFilePath::getPathForDirectory",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; - result = ofFilePath::getPathForDirectory((std::string const &)*arg1); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FilePath_getAbsolutePath__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; bool arg2 ; - std::string temp1 ; std::string result; SWIG_check_num_args("ofFilePath::getAbsolutePath",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFilePath::getAbsolutePath",1,"std::string const &"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofFilePath::getAbsolutePath",2,"bool"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; arg2 = (lua_toboolean(L, 2)!=0); - result = ofFilePath::getAbsolutePath((std::string const &)*arg1,arg2); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FilePath_getAbsolutePath__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - std::string result; SWIG_check_num_args("ofFilePath::getAbsolutePath",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFilePath::getAbsolutePath",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; - result = ofFilePath::getAbsolutePath((std::string const &)*arg1); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FilePath_getAbsolutePath(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); - if (argc == 1) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { return _wrap_FilePath_getAbsolutePath__SWIG_1(L);} } - if (argc == 2) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_FilePath_getAbsolutePath__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FilePath_getAbsolutePath'\n" - " Possible C/C++ prototypes are:\n" " ofFilePath::getAbsolutePath(std::string const &,bool)\n" - " ofFilePath::getAbsolutePath(std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_FilePath_isAbsolute(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; bool result; - SWIG_check_num_args("ofFilePath::isAbsolute",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFilePath::isAbsolute",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; - result = (bool)ofFilePath::isAbsolute((std::string const &)*arg1); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FilePath_getFileName__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; bool arg2 ; - std::string temp1 ; std::string result; SWIG_check_num_args("ofFilePath::getFileName",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFilePath::getFileName",1,"std::string const &"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofFilePath::getFileName",2,"bool"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; arg2 = (lua_toboolean(L, 2)!=0); - result = ofFilePath::getFileName((std::string const &)*arg1,arg2); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FilePath_getFileName__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - std::string result; SWIG_check_num_args("ofFilePath::getFileName",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFilePath::getFileName",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = ofFilePath::getFileName((std::string const &)*arg1); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FilePath_getFileName(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { return _wrap_FilePath_getFileName__SWIG_1(L);} } if (argc == 2) { - int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_FilePath_getFileName__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FilePath_getFileName'\n" - " Possible C/C++ prototypes are:\n" " ofFilePath::getFileName(std::string const &,bool)\n" - " ofFilePath::getFileName(std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_FilePath_getBaseName(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - std::string result; SWIG_check_num_args("ofFilePath::getBaseName",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFilePath::getBaseName",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = ofFilePath::getBaseName((std::string const &)*arg1); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FilePath_getEnclosingDirectory__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; bool arg2 ; - std::string temp1 ; std::string result; SWIG_check_num_args("ofFilePath::getEnclosingDirectory",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFilePath::getEnclosingDirectory",1,"std::string const &"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofFilePath::getEnclosingDirectory",2,"bool"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; arg2 = (lua_toboolean(L, 2)!=0); - result = ofFilePath::getEnclosingDirectory((std::string const &)*arg1,arg2); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FilePath_getEnclosingDirectory__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; - std::string temp1 ; std::string result; SWIG_check_num_args("ofFilePath::getEnclosingDirectory",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFilePath::getEnclosingDirectory",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; - result = ofFilePath::getEnclosingDirectory((std::string const &)*arg1); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FilePath_getEnclosingDirectory(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); - if (argc == 1) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { return _wrap_FilePath_getEnclosingDirectory__SWIG_1(L);} - } if (argc == 2) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_FilePath_getEnclosingDirectory__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FilePath_getEnclosingDirectory'\n" - " Possible C/C++ prototypes are:\n" " ofFilePath::getEnclosingDirectory(std::string const &,bool)\n" - " ofFilePath::getEnclosingDirectory(std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_FilePath_createEnclosingDirectory__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; bool arg2 ; - bool arg3 ; std::string temp1 ; bool result; SWIG_check_num_args("ofFilePath::createEnclosingDirectory",3,3) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFilePath::createEnclosingDirectory",1,"std::string const &"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofFilePath::createEnclosingDirectory",2,"bool"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofFilePath::createEnclosingDirectory",3,"bool"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; arg2 = (lua_toboolean(L, 2)!=0); - arg3 = (lua_toboolean(L, 3)!=0); result = (bool)ofFilePath::createEnclosingDirectory((std::string const &)*arg1,arg2,arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FilePath_createEnclosingDirectory__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; bool arg2 ; - std::string temp1 ; bool result; SWIG_check_num_args("ofFilePath::createEnclosingDirectory",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFilePath::createEnclosingDirectory",1,"std::string const &"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofFilePath::createEnclosingDirectory",2,"bool"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; arg2 = (lua_toboolean(L, 2)!=0); - result = (bool)ofFilePath::createEnclosingDirectory((std::string const &)*arg1,arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FilePath_createEnclosingDirectory__SWIG_2(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; - std::string temp1 ; bool result; SWIG_check_num_args("ofFilePath::createEnclosingDirectory",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFilePath::createEnclosingDirectory",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; - result = (bool)ofFilePath::createEnclosingDirectory((std::string const &)*arg1); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FilePath_createEnclosingDirectory(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); - if (argc == 1) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { - return _wrap_FilePath_createEnclosingDirectory__SWIG_2(L);} } if (argc == 2) { int _v; { _v = lua_isstring(L,argv[0]); } - if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { return _wrap_FilePath_createEnclosingDirectory__SWIG_1(L);} } } - if (argc == 3) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { { - _v = lua_isboolean(L,argv[2]); } if (_v) { return _wrap_FilePath_createEnclosingDirectory__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FilePath_createEnclosingDirectory'\n" - " Possible C/C++ prototypes are:\n" " ofFilePath::createEnclosingDirectory(std::string const &,bool,bool)\n" - " ofFilePath::createEnclosingDirectory(std::string const &,bool)\n" - " ofFilePath::createEnclosingDirectory(std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_FilePath_getCurrentWorkingDirectory(lua_State* L) { int SWIG_arg = 0; std::string result; - SWIG_check_num_args("ofFilePath::getCurrentWorkingDirectory",0,0) result = ofFilePath::getCurrentWorkingDirectory(); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FilePath_join(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; - std::string temp1 ; std::string temp2 ; std::string result; SWIG_check_num_args("ofFilePath::join",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFilePath::join",1,"std::string const &"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofFilePath::join",2,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = ofFilePath::join((std::string const &)*arg1,(std::string const &)*arg2); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FilePath_getCurrentExePath(lua_State* L) { int SWIG_arg = 0; std::string result; - SWIG_check_num_args("ofFilePath::getCurrentExePath",0,0) result = ofFilePath::getCurrentExePath(); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FilePath_getCurrentExeDir(lua_State* L) { int SWIG_arg = 0; std::string result; - SWIG_check_num_args("ofFilePath::getCurrentExeDir",0,0) result = ofFilePath::getCurrentExeDir(); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FilePath_getUserHomeDir(lua_State* L) { int SWIG_arg = 0; std::string result; - SWIG_check_num_args("ofFilePath::getUserHomeDir",0,0) result = ofFilePath::getUserHomeDir(); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FilePath_makeRelative(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; - std::string temp1 ; std::string temp2 ; std::string result; SWIG_check_num_args("ofFilePath::makeRelative",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFilePath::makeRelative",1,"std::string const &"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofFilePath::makeRelative",2,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = ofFilePath::makeRelative((std::string const &)*arg1,(std::string const &)*arg2); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_FilePath(lua_State* L) { int SWIG_arg = 0; ofFilePath *result = 0 ; - SWIG_check_num_args("ofFilePath::ofFilePath",0,0) result = (ofFilePath *)new ofFilePath(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofFilePath,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static void swig_delete_FilePath(void *obj) { -ofFilePath *arg1 = (ofFilePath *) obj; -delete arg1; -} -static int _proxy__wrap_new_FilePath(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_FilePath); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_FilePath_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_FilePath_methods[]= { - {0,0} -}; -static swig_lua_method swig_FilePath_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_FilePath_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_FilePath_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_FilePath_Sf_SwigStatic_methods[]= { - { "getFileExt", _wrap_FilePath_getFileExt}, - { "removeExt", _wrap_FilePath_removeExt}, - { "addLeadingSlash", _wrap_FilePath_addLeadingSlash}, - { "addTrailingSlash", _wrap_FilePath_addTrailingSlash}, - { "removeTrailingSlash", _wrap_FilePath_removeTrailingSlash}, - { "getPathForDirectory", _wrap_FilePath_getPathForDirectory}, - { "getAbsolutePath", _wrap_FilePath_getAbsolutePath}, - { "isAbsolute", _wrap_FilePath_isAbsolute}, - { "getFileName", _wrap_FilePath_getFileName}, - { "getBaseName", _wrap_FilePath_getBaseName}, - { "getEnclosingDirectory", _wrap_FilePath_getEnclosingDirectory}, - { "createEnclosingDirectory", _wrap_FilePath_createEnclosingDirectory}, - { "getCurrentWorkingDirectory", _wrap_FilePath_getCurrentWorkingDirectory}, - { "join", _wrap_FilePath_join}, - { "getCurrentExePath", _wrap_FilePath_getCurrentExePath}, - { "getCurrentExeDir", _wrap_FilePath_getCurrentExeDir}, - { "getUserHomeDir", _wrap_FilePath_getUserHomeDir}, - { "makeRelative", _wrap_FilePath_makeRelative}, - {0,0} -}; -static swig_lua_class* swig_FilePath_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_FilePath_Sf_SwigStatic = { - "FilePath", - swig_FilePath_Sf_SwigStatic_methods, - swig_FilePath_Sf_SwigStatic_attributes, - swig_FilePath_Sf_SwigStatic_constants, - swig_FilePath_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_FilePath_bases[] = {0}; -static const char *swig_FilePath_base_names[] = {0}; -static swig_lua_class _wrap_class_FilePath = { "FilePath", "FilePath", &SWIGTYPE_p_ofFilePath,_proxy__wrap_new_FilePath, swig_delete_FilePath, swig_FilePath_methods, swig_FilePath_attributes, &swig_FilePath_Sf_SwigStatic, swig_FilePath_meta, swig_FilePath_bases, swig_FilePath_base_names }; - -static int _wrap_new_File__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofFile *result = 0 ; - SWIG_check_num_args("ofFile::ofFile",0,0) result = (ofFile *)new ofFile(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofFile,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_File__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::filesystem::path *arg1 = 0 ; ofFile::Mode arg2 ; - bool arg3 ; std::filesystem::path temp1 ; ofFile *result = 0 ; SWIG_check_num_args("ofFile::ofFile",3,3) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFile::ofFile",1,"std::filesystem::path const &"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofFile::ofFile",2,"ofFile::Mode"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofFile::ofFile",3,"bool"); { size_t len = lua_rawlen(L, 1); - temp1 = lua_tolstring(L, 1, &len); arg1 = &temp1; } arg2 = (ofFile::Mode)(int)lua_tonumber(L, 2); - arg3 = (lua_toboolean(L, 3)!=0); result = (ofFile *)new ofFile((std::filesystem::path const &)*arg1,arg2,arg3); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofFile,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_File__SWIG_2(lua_State* L) { int SWIG_arg = 0; std::filesystem::path *arg1 = 0 ; ofFile::Mode arg2 ; - std::filesystem::path temp1 ; ofFile *result = 0 ; SWIG_check_num_args("ofFile::ofFile",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFile::ofFile",1,"std::filesystem::path const &"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofFile::ofFile",2,"ofFile::Mode"); { size_t len = lua_rawlen(L, 1); - temp1 = lua_tolstring(L, 1, &len); arg1 = &temp1; } arg2 = (ofFile::Mode)(int)lua_tonumber(L, 2); - result = (ofFile *)new ofFile((std::filesystem::path const &)*arg1,arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofFile,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_File__SWIG_3(lua_State* L) { int SWIG_arg = 0; std::filesystem::path *arg1 = 0 ; - std::filesystem::path temp1 ; ofFile *result = 0 ; SWIG_check_num_args("ofFile::ofFile",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFile::ofFile",1,"std::filesystem::path const &"); { size_t len = lua_rawlen(L, 1); - temp1 = lua_tolstring(L, 1, &len); arg1 = &temp1; } result = (ofFile *)new ofFile((std::filesystem::path const &)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofFile,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_File__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = 0 ; ofFile *result = 0 ; - SWIG_check_num_args("ofFile::ofFile",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofFile::ofFile",1,"ofFile const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("new_File",1,SWIGTYPE_p_ofFile); } - result = (ofFile *)new ofFile((ofFile const &)*arg1); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofFile,1); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_new_File(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_File__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_new_File__SWIG_4(L);} } if (argc == 1) { int _v; { - _v = lua_isstring(L, argv[0]); } if (_v) { return _wrap_new_File__SWIG_3(L);} } if (argc == 2) { int _v; { - _v = lua_isstring(L, argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_new_File__SWIG_2(L);} - } } if (argc == 3) { int _v; { _v = lua_isstring(L, argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - { _v = lua_isboolean(L,argv[2]); } if (_v) { return _wrap_new_File__SWIG_1(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_File'\n" " Possible C/C++ prototypes are:\n" - " ofFile::ofFile()\n" " ofFile::ofFile(std::filesystem::path const &,ofFile::Mode,bool)\n" - " ofFile::ofFile(std::filesystem::path const &,ofFile::Mode)\n" " ofFile::ofFile(std::filesystem::path const &)\n" - " ofFile::ofFile(ofFile const &)\n"); lua_error(L);return 0; } -static int _wrap_File_open__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; - std::filesystem::path *arg2 = 0 ; ofFile::Mode arg3 ; bool arg4 ; std::filesystem::path temp2 ; bool result; - SWIG_check_num_args("ofFile::open",4,4) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::open",1,"ofFile *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofFile::open",2,"std::filesystem::path const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofFile::open",3,"ofFile::Mode"); - if(!lua_isboolean(L,4)) SWIG_fail_arg("ofFile::open",4,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File_open",1,SWIGTYPE_p_ofFile); } { - size_t len = lua_rawlen(L, 2); temp2 = lua_tolstring(L, 2, &len); arg2 = &temp2; } - arg3 = (ofFile::Mode)(int)lua_tonumber(L, 3); arg4 = (lua_toboolean(L, 4)!=0); - result = (bool)(arg1)->open((std::filesystem::path const &)*arg2,arg3,arg4); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_open__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; - std::filesystem::path *arg2 = 0 ; ofFile::Mode arg3 ; std::filesystem::path temp2 ; bool result; - SWIG_check_num_args("ofFile::open",3,3) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::open",1,"ofFile *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofFile::open",2,"std::filesystem::path const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofFile::open",3,"ofFile::Mode"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File_open",1,SWIGTYPE_p_ofFile); } { - size_t len = lua_rawlen(L, 2); temp2 = lua_tolstring(L, 2, &len); arg2 = &temp2; } - arg3 = (ofFile::Mode)(int)lua_tonumber(L, 3); result = (bool)(arg1)->open((std::filesystem::path const &)*arg2,arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_open__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; - std::filesystem::path *arg2 = 0 ; std::filesystem::path temp2 ; bool result; SWIG_check_num_args("ofFile::open",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::open",1,"ofFile *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofFile::open",2,"std::filesystem::path const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File_open",1,SWIGTYPE_p_ofFile); } { - size_t len = lua_rawlen(L, 2); temp2 = lua_tolstring(L, 2, &len); arg2 = &temp2; } - result = (bool)(arg1)->open((std::filesystem::path const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_open(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L, argv[1]); } if (_v) { - return _wrap_File_open__SWIG_2(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isstring(L, argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_File_open__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isstring(L, argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isboolean(L,argv[3]); } if (_v) { return _wrap_File_open__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'File_open'\n" " Possible C/C++ prototypes are:\n" - " ofFile::open(std::filesystem::path const &,ofFile::Mode,bool)\n" - " ofFile::open(std::filesystem::path const &,ofFile::Mode)\n" " ofFile::open(std::filesystem::path const &)\n"); - lua_error(L);return 0; } -static int _wrap_File_changeMode__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; ofFile::Mode arg2 ; - bool arg3 ; bool result; SWIG_check_num_args("ofFile::changeMode",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::changeMode",1,"ofFile *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofFile::changeMode",2,"ofFile::Mode"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofFile::changeMode",3,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ - SWIG_fail_ptr("File_changeMode",1,SWIGTYPE_p_ofFile); } arg2 = (ofFile::Mode)(int)lua_tonumber(L, 2); - arg3 = (lua_toboolean(L, 3)!=0); result = (bool)(arg1)->changeMode(arg2,arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_changeMode__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; ofFile::Mode arg2 ; - bool result; SWIG_check_num_args("ofFile::changeMode",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::changeMode",1,"ofFile *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofFile::changeMode",2,"ofFile::Mode"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ - SWIG_fail_ptr("File_changeMode",1,SWIGTYPE_p_ofFile); } arg2 = (ofFile::Mode)(int)lua_tonumber(L, 2); - result = (bool)(arg1)->changeMode(arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_changeMode(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_File_changeMode__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - return _wrap_File_changeMode__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'File_changeMode'\n" " Possible C/C++ prototypes are:\n" - " ofFile::changeMode(ofFile::Mode,bool)\n" " ofFile::changeMode(ofFile::Mode)\n"); lua_error(L);return 0; } -static int _wrap_File_close(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; - SWIG_check_num_args("ofFile::close",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::close",1,"ofFile *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File_close",1,SWIGTYPE_p_ofFile); } - (arg1)->close(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_create(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; bool result; - SWIG_check_num_args("ofFile::create",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::create",1,"ofFile *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File_create",1,SWIGTYPE_p_ofFile); } - result = (bool)(arg1)->create(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_File_exists(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; bool result; - SWIG_check_num_args("ofFile::exists",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::exists",1,"ofFile const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File_exists",1,SWIGTYPE_p_ofFile); } - result = (bool)((ofFile const *)arg1)->exists(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_path(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; std::string result; - SWIG_check_num_args("ofFile::path",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::path",1,"ofFile const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File_path",1,SWIGTYPE_p_ofFile); } - result = ((ofFile const *)arg1)->path(); lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_getExtension(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; std::string result; - SWIG_check_num_args("ofFile::getExtension",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::getExtension",1,"ofFile const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ - SWIG_fail_ptr("File_getExtension",1,SWIGTYPE_p_ofFile); } result = ((ofFile const *)arg1)->getExtension(); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_File_getFileName(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; std::string result; - SWIG_check_num_args("ofFile::getFileName",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::getFileName",1,"ofFile const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ - SWIG_fail_ptr("File_getFileName",1,SWIGTYPE_p_ofFile); } result = ((ofFile const *)arg1)->getFileName(); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_File_getBaseName(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; std::string result; - SWIG_check_num_args("ofFile::getBaseName",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::getBaseName",1,"ofFile const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ - SWIG_fail_ptr("File_getBaseName",1,SWIGTYPE_p_ofFile); } result = ((ofFile const *)arg1)->getBaseName(); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_File_getEnclosingDirectory(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; std::string result; - SWIG_check_num_args("ofFile::getEnclosingDirectory",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::getEnclosingDirectory",1,"ofFile const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ - SWIG_fail_ptr("File_getEnclosingDirectory",1,SWIGTYPE_p_ofFile); } - result = ((ofFile const *)arg1)->getEnclosingDirectory(); lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_getAbsolutePath(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; std::string result; - SWIG_check_num_args("ofFile::getAbsolutePath",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::getAbsolutePath",1,"ofFile const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ - SWIG_fail_ptr("File_getAbsolutePath",1,SWIGTYPE_p_ofFile); } result = ((ofFile const *)arg1)->getAbsolutePath(); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_File_canRead(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; bool result; - SWIG_check_num_args("ofFile::canRead",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::canRead",1,"ofFile const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File_canRead",1,SWIGTYPE_p_ofFile); } - result = (bool)((ofFile const *)arg1)->canRead(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_canWrite(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; bool result; - SWIG_check_num_args("ofFile::canWrite",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::canWrite",1,"ofFile const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File_canWrite",1,SWIGTYPE_p_ofFile); } - result = (bool)((ofFile const *)arg1)->canWrite(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_canExecute(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; bool result; - SWIG_check_num_args("ofFile::canExecute",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::canExecute",1,"ofFile const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ - SWIG_fail_ptr("File_canExecute",1,SWIGTYPE_p_ofFile); } result = (bool)((ofFile const *)arg1)->canExecute(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_isFile(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; bool result; - SWIG_check_num_args("ofFile::isFile",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::isFile",1,"ofFile const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File_isFile",1,SWIGTYPE_p_ofFile); } - result = (bool)((ofFile const *)arg1)->isFile(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_isLink(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; bool result; - SWIG_check_num_args("ofFile::isLink",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::isLink",1,"ofFile const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File_isLink",1,SWIGTYPE_p_ofFile); } - result = (bool)((ofFile const *)arg1)->isLink(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_isDirectory(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; bool result; - SWIG_check_num_args("ofFile::isDirectory",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::isDirectory",1,"ofFile const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ - SWIG_fail_ptr("File_isDirectory",1,SWIGTYPE_p_ofFile); } result = (bool)((ofFile const *)arg1)->isDirectory(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_isDevice(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; bool result; - SWIG_check_num_args("ofFile::isDevice",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::isDevice",1,"ofFile const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File_isDevice",1,SWIGTYPE_p_ofFile); } - result = (bool)((ofFile const *)arg1)->isDevice(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_isHidden(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; bool result; - SWIG_check_num_args("ofFile::isHidden",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::isHidden",1,"ofFile const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File_isHidden",1,SWIGTYPE_p_ofFile); } - result = (bool)((ofFile const *)arg1)->isHidden(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_setWriteable__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; bool arg2 ; - SWIG_check_num_args("ofFile::setWriteable",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::setWriteable",1,"ofFile *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofFile::setWriteable",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ - SWIG_fail_ptr("File_setWriteable",1,SWIGTYPE_p_ofFile); } arg2 = (lua_toboolean(L, 2)!=0); (arg1)->setWriteable(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_setWriteable__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; - SWIG_check_num_args("ofFile::setWriteable",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::setWriteable",1,"ofFile *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ - SWIG_fail_ptr("File_setWriteable",1,SWIGTYPE_p_ofFile); } (arg1)->setWriteable(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_File_setWriteable(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_File_setWriteable__SWIG_1(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_File_setWriteable__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'File_setWriteable'\n" " Possible C/C++ prototypes are:\n" - " ofFile::setWriteable(bool)\n" " ofFile::setWriteable()\n"); lua_error(L);return 0; } -static int _wrap_File_setReadOnly__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; bool arg2 ; - SWIG_check_num_args("ofFile::setReadOnly",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::setReadOnly",1,"ofFile *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofFile::setReadOnly",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ - SWIG_fail_ptr("File_setReadOnly",1,SWIGTYPE_p_ofFile); } arg2 = (lua_toboolean(L, 2)!=0); (arg1)->setReadOnly(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_setReadOnly__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; - SWIG_check_num_args("ofFile::setReadOnly",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::setReadOnly",1,"ofFile *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ - SWIG_fail_ptr("File_setReadOnly",1,SWIGTYPE_p_ofFile); } (arg1)->setReadOnly(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_File_setReadOnly(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_File_setReadOnly__SWIG_1(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_File_setReadOnly__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'File_setReadOnly'\n" " Possible C/C++ prototypes are:\n" - " ofFile::setReadOnly(bool)\n" " ofFile::setReadOnly()\n"); lua_error(L);return 0; } -static int _wrap_File_setExecutable__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; bool arg2 ; - SWIG_check_num_args("ofFile::setExecutable",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::setExecutable",1,"ofFile *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofFile::setExecutable",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ - SWIG_fail_ptr("File_setExecutable",1,SWIGTYPE_p_ofFile); } arg2 = (lua_toboolean(L, 2)!=0); (arg1)->setExecutable(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_setExecutable__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; - SWIG_check_num_args("ofFile::setExecutable",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::setExecutable",1,"ofFile *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ - SWIG_fail_ptr("File_setExecutable",1,SWIGTYPE_p_ofFile); } (arg1)->setExecutable(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_File_setExecutable(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_File_setExecutable__SWIG_1(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_File_setExecutable__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'File_setExecutable'\n" " Possible C/C++ prototypes are:\n" - " ofFile::setExecutable(bool)\n" " ofFile::setExecutable()\n"); lua_error(L);return 0; } -static int _wrap_File_copyTo__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; std::string *arg2 = 0 ; - bool arg3 ; bool arg4 ; std::string temp2 ; bool result; SWIG_check_num_args("ofFile::copyTo",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::copyTo",1,"ofFile const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofFile::copyTo",2,"std::string const &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofFile::copyTo",3,"bool"); - if(!lua_isboolean(L,4)) SWIG_fail_arg("ofFile::copyTo",4,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File_copyTo",1,SWIGTYPE_p_ofFile); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; arg3 = (lua_toboolean(L, 3)!=0); - arg4 = (lua_toboolean(L, 4)!=0); result = (bool)((ofFile const *)arg1)->copyTo((std::string const &)*arg2,arg3,arg4); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_copyTo__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; std::string *arg2 = 0 ; - bool arg3 ; std::string temp2 ; bool result; SWIG_check_num_args("ofFile::copyTo",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::copyTo",1,"ofFile const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofFile::copyTo",2,"std::string const &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofFile::copyTo",3,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File_copyTo",1,SWIGTYPE_p_ofFile); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; arg3 = (lua_toboolean(L, 3)!=0); - result = (bool)((ofFile const *)arg1)->copyTo((std::string const &)*arg2,arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_copyTo__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; std::string *arg2 = 0 ; - std::string temp2 ; bool result; SWIG_check_num_args("ofFile::copyTo",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::copyTo",1,"ofFile const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofFile::copyTo",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File_copyTo",1,SWIGTYPE_p_ofFile); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = (bool)((ofFile const *)arg1)->copyTo((std::string const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_copyTo(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { - return _wrap_File_copyTo__SWIG_2(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - return _wrap_File_copyTo__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { { - _v = lua_isboolean(L,argv[3]); } if (_v) { return _wrap_File_copyTo__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'File_copyTo'\n" " Possible C/C++ prototypes are:\n" - " ofFile::copyTo(std::string const &,bool,bool) const\n" " ofFile::copyTo(std::string const &,bool) const\n" - " ofFile::copyTo(std::string const &) const\n"); lua_error(L);return 0; } -static int _wrap_File_moveTo__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; std::string *arg2 = 0 ; - bool arg3 ; bool arg4 ; std::string temp2 ; bool result; SWIG_check_num_args("ofFile::moveTo",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::moveTo",1,"ofFile *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofFile::moveTo",2,"std::string const &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofFile::moveTo",3,"bool"); - if(!lua_isboolean(L,4)) SWIG_fail_arg("ofFile::moveTo",4,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File_moveTo",1,SWIGTYPE_p_ofFile); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; arg3 = (lua_toboolean(L, 3)!=0); - arg4 = (lua_toboolean(L, 4)!=0); result = (bool)(arg1)->moveTo((std::string const &)*arg2,arg3,arg4); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_moveTo__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; std::string *arg2 = 0 ; - bool arg3 ; std::string temp2 ; bool result; SWIG_check_num_args("ofFile::moveTo",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::moveTo",1,"ofFile *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofFile::moveTo",2,"std::string const &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofFile::moveTo",3,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File_moveTo",1,SWIGTYPE_p_ofFile); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; arg3 = (lua_toboolean(L, 3)!=0); - result = (bool)(arg1)->moveTo((std::string const &)*arg2,arg3); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_moveTo__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; std::string *arg2 = 0 ; - std::string temp2 ; bool result; SWIG_check_num_args("ofFile::moveTo",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::moveTo",1,"ofFile *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofFile::moveTo",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File_moveTo",1,SWIGTYPE_p_ofFile); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; result = (bool)(arg1)->moveTo((std::string const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_moveTo(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { - return _wrap_File_moveTo__SWIG_2(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - return _wrap_File_moveTo__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { { - _v = lua_isboolean(L,argv[3]); } if (_v) { return _wrap_File_moveTo__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'File_moveTo'\n" " Possible C/C++ prototypes are:\n" - " ofFile::moveTo(std::string const &,bool,bool)\n" " ofFile::moveTo(std::string const &,bool)\n" - " ofFile::moveTo(std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_File_renameTo__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; std::string *arg2 = 0 ; - bool arg3 ; bool arg4 ; std::string temp2 ; bool result; SWIG_check_num_args("ofFile::renameTo",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::renameTo",1,"ofFile *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofFile::renameTo",2,"std::string const &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofFile::renameTo",3,"bool"); - if(!lua_isboolean(L,4)) SWIG_fail_arg("ofFile::renameTo",4,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File_renameTo",1,SWIGTYPE_p_ofFile); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; arg3 = (lua_toboolean(L, 3)!=0); - arg4 = (lua_toboolean(L, 4)!=0); result = (bool)(arg1)->renameTo((std::string const &)*arg2,arg3,arg4); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_renameTo__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; std::string *arg2 = 0 ; - bool arg3 ; std::string temp2 ; bool result; SWIG_check_num_args("ofFile::renameTo",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::renameTo",1,"ofFile *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofFile::renameTo",2,"std::string const &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofFile::renameTo",3,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File_renameTo",1,SWIGTYPE_p_ofFile); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; arg3 = (lua_toboolean(L, 3)!=0); - result = (bool)(arg1)->renameTo((std::string const &)*arg2,arg3); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_renameTo__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; std::string *arg2 = 0 ; - std::string temp2 ; bool result; SWIG_check_num_args("ofFile::renameTo",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::renameTo",1,"ofFile *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofFile::renameTo",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File_renameTo",1,SWIGTYPE_p_ofFile); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; result = (bool)(arg1)->renameTo((std::string const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_renameTo(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { - return _wrap_File_renameTo__SWIG_2(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - return _wrap_File_renameTo__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { { - _v = lua_isboolean(L,argv[3]); } if (_v) { return _wrap_File_renameTo__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'File_renameTo'\n" " Possible C/C++ prototypes are:\n" - " ofFile::renameTo(std::string const &,bool,bool)\n" " ofFile::renameTo(std::string const &,bool)\n" - " ofFile::renameTo(std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_File_remove__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; bool arg2 ; bool result; - SWIG_check_num_args("ofFile::remove",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::remove",1,"ofFile *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofFile::remove",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File_remove",1,SWIGTYPE_p_ofFile); } - arg2 = (lua_toboolean(L, 2)!=0); result = (bool)(arg1)->remove(arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_remove__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; bool result; - SWIG_check_num_args("ofFile::remove",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::remove",1,"ofFile *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File_remove",1,SWIGTYPE_p_ofFile); } - result = (bool)(arg1)->remove(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_File_remove(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_File_remove__SWIG_1(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_File_remove__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'File_remove'\n" " Possible C/C++ prototypes are:\n" - " ofFile::remove(bool)\n" " ofFile::remove()\n"); lua_error(L);return 0; } -static int _wrap_File_getSize(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; uint64_t result; - SWIG_check_num_args("ofFile::getSize",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::getSize",1,"ofFile const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File_getSize",1,SWIGTYPE_p_ofFile); } - result = (uint64_t)((ofFile const *)arg1)->getSize(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File___eq(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; ofFile *arg2 = 0 ; bool result; - SWIG_check_num_args("ofFile::operator ==",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::operator ==",1,"ofFile const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofFile::operator ==",2,"ofFile const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File___eq",1,SWIGTYPE_p_ofFile); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File___eq",2,SWIGTYPE_p_ofFile); } - result = (bool)((ofFile const *)arg1)->operator ==((ofFile const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File___lt(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; ofFile *arg2 = 0 ; bool result; - SWIG_check_num_args("ofFile::operator <",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::operator <",1,"ofFile const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofFile::operator <",2,"ofFile const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File___lt",1,SWIGTYPE_p_ofFile); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File___lt",2,SWIGTYPE_p_ofFile); } - result = (bool)((ofFile const *)arg1)->operator <((ofFile const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File___le(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; ofFile *arg2 = 0 ; bool result; - SWIG_check_num_args("ofFile::operator <=",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::operator <=",1,"ofFile const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofFile::operator <=",2,"ofFile const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File___le",1,SWIGTYPE_p_ofFile); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File___le",2,SWIGTYPE_p_ofFile); } - result = (bool)((ofFile const *)arg1)->operator <=((ofFile const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_readToBuffer(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; ofBuffer result; - SWIG_check_num_args("ofFile::readToBuffer",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::readToBuffer",1,"ofFile *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ - SWIG_fail_ptr("File_readToBuffer",1,SWIGTYPE_p_ofFile); } result = (arg1)->readToBuffer(); { - ofBuffer * resultptr = new ofBuffer((const ofBuffer &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofBuffer,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_File_writeFromBuffer(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; ofBuffer *arg2 = 0 ; - bool result; SWIG_check_num_args("ofFile::writeFromBuffer",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::writeFromBuffer",1,"ofFile *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofFile::writeFromBuffer",2,"ofBuffer const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ - SWIG_fail_ptr("File_writeFromBuffer",1,SWIGTYPE_p_ofFile); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBuffer,0))){ - SWIG_fail_ptr("File_writeFromBuffer",2,SWIGTYPE_p_ofBuffer); } - result = (bool)(arg1)->writeFromBuffer((ofBuffer const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_copyFromTo__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; - bool arg3 ; bool arg4 ; std::string temp1 ; std::string temp2 ; bool result; SWIG_check_num_args("ofFile::copyFromTo",4,4) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFile::copyFromTo",1,"std::string const &"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofFile::copyFromTo",2,"std::string const &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofFile::copyFromTo",3,"bool"); - if(!lua_isboolean(L,4)) SWIG_fail_arg("ofFile::copyFromTo",4,"bool"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - arg3 = (lua_toboolean(L, 3)!=0); arg4 = (lua_toboolean(L, 4)!=0); - result = (bool)ofFile::copyFromTo((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_copyFromTo__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; - bool arg3 ; std::string temp1 ; std::string temp2 ; bool result; SWIG_check_num_args("ofFile::copyFromTo",3,3) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFile::copyFromTo",1,"std::string const &"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofFile::copyFromTo",2,"std::string const &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofFile::copyFromTo",3,"bool"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - arg3 = (lua_toboolean(L, 3)!=0); - result = (bool)ofFile::copyFromTo((std::string const &)*arg1,(std::string const &)*arg2,arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_copyFromTo__SWIG_2(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; - std::string temp1 ; std::string temp2 ; bool result; SWIG_check_num_args("ofFile::copyFromTo",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFile::copyFromTo",1,"std::string const &"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofFile::copyFromTo",2,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = (bool)ofFile::copyFromTo((std::string const &)*arg1,(std::string const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_copyFromTo(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { - return _wrap_File_copyFromTo__SWIG_2(L);} } } if (argc == 3) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { { - _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - return _wrap_File_copyFromTo__SWIG_1(L);} } } } if (argc == 4) { int _v; { _v = lua_isstring(L,argv[0]); } - if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { { - _v = lua_isboolean(L,argv[3]); } if (_v) { return _wrap_File_copyFromTo__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'File_copyFromTo'\n" " Possible C/C++ prototypes are:\n" - " ofFile::copyFromTo(std::string const &,std::string const &,bool,bool)\n" - " ofFile::copyFromTo(std::string const &,std::string const &,bool)\n" - " ofFile::copyFromTo(std::string const &,std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_File_moveFromTo__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; - bool arg3 ; bool arg4 ; std::string temp1 ; std::string temp2 ; bool result; SWIG_check_num_args("ofFile::moveFromTo",4,4) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFile::moveFromTo",1,"std::string const &"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofFile::moveFromTo",2,"std::string const &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofFile::moveFromTo",3,"bool"); - if(!lua_isboolean(L,4)) SWIG_fail_arg("ofFile::moveFromTo",4,"bool"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - arg3 = (lua_toboolean(L, 3)!=0); arg4 = (lua_toboolean(L, 4)!=0); - result = (bool)ofFile::moveFromTo((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_moveFromTo__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; - bool arg3 ; std::string temp1 ; std::string temp2 ; bool result; SWIG_check_num_args("ofFile::moveFromTo",3,3) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFile::moveFromTo",1,"std::string const &"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofFile::moveFromTo",2,"std::string const &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofFile::moveFromTo",3,"bool"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - arg3 = (lua_toboolean(L, 3)!=0); - result = (bool)ofFile::moveFromTo((std::string const &)*arg1,(std::string const &)*arg2,arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_moveFromTo__SWIG_2(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; - std::string temp1 ; std::string temp2 ; bool result; SWIG_check_num_args("ofFile::moveFromTo",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFile::moveFromTo",1,"std::string const &"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofFile::moveFromTo",2,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = (bool)ofFile::moveFromTo((std::string const &)*arg1,(std::string const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_moveFromTo(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { - return _wrap_File_moveFromTo__SWIG_2(L);} } } if (argc == 3) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { { - _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - return _wrap_File_moveFromTo__SWIG_1(L);} } } } if (argc == 4) { int _v; { _v = lua_isstring(L,argv[0]); } - if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { { - _v = lua_isboolean(L,argv[3]); } if (_v) { return _wrap_File_moveFromTo__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'File_moveFromTo'\n" " Possible C/C++ prototypes are:\n" - " ofFile::moveFromTo(std::string const &,std::string const &,bool,bool)\n" - " ofFile::moveFromTo(std::string const &,std::string const &,bool)\n" - " ofFile::moveFromTo(std::string const &,std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_File_doesFileExist__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; bool arg2 ; - std::string temp1 ; bool result; SWIG_check_num_args("ofFile::doesFileExist",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFile::doesFileExist",1,"std::string const &"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofFile::doesFileExist",2,"bool"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; arg2 = (lua_toboolean(L, 2)!=0); - result = (bool)ofFile::doesFileExist((std::string const &)*arg1,arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_doesFileExist__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - bool result; SWIG_check_num_args("ofFile::doesFileExist",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFile::doesFileExist",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; - result = (bool)ofFile::doesFileExist((std::string const &)*arg1); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_doesFileExist(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { return _wrap_File_doesFileExist__SWIG_1(L);} } if (argc == 2) { - int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_File_doesFileExist__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'File_doesFileExist'\n" " Possible C/C++ prototypes are:\n" - " ofFile::doesFileExist(std::string const &,bool)\n" " ofFile::doesFileExist(std::string const &)\n"); - lua_error(L);return 0; } -static int _wrap_File_removeFile__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; bool arg2 ; - std::string temp1 ; bool result; SWIG_check_num_args("ofFile::removeFile",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFile::removeFile",1,"std::string const &"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofFile::removeFile",2,"bool"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; arg2 = (lua_toboolean(L, 2)!=0); - result = (bool)ofFile::removeFile((std::string const &)*arg1,arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_removeFile__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - bool result; SWIG_check_num_args("ofFile::removeFile",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFile::removeFile",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = (bool)ofFile::removeFile((std::string const &)*arg1); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_removeFile(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; - { _v = lua_isstring(L,argv[0]); } if (_v) { return _wrap_File_removeFile__SWIG_1(L);} } if (argc == 2) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_File_removeFile__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'File_removeFile'\n" " Possible C/C++ prototypes are:\n" - " ofFile::removeFile(std::string const &,bool)\n" " ofFile::removeFile(std::string const &)\n"); lua_error(L);return 0; } -static void swig_delete_File(void *obj) { -ofFile *arg1 = (ofFile *) obj; -delete arg1; -} -static int _proxy__wrap_new_File(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_File); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_File_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_File_methods[]= { - { "open", _wrap_File_open}, - { "changeMode", _wrap_File_changeMode}, - { "close", _wrap_File_close}, - { "create", _wrap_File_create}, - { "exists", _wrap_File_exists}, - { "path", _wrap_File_path}, - { "getExtension", _wrap_File_getExtension}, - { "getFileName", _wrap_File_getFileName}, - { "getBaseName", _wrap_File_getBaseName}, - { "getEnclosingDirectory", _wrap_File_getEnclosingDirectory}, - { "getAbsolutePath", _wrap_File_getAbsolutePath}, - { "canRead", _wrap_File_canRead}, - { "canWrite", _wrap_File_canWrite}, - { "canExecute", _wrap_File_canExecute}, - { "isFile", _wrap_File_isFile}, - { "isLink", _wrap_File_isLink}, - { "isDirectory", _wrap_File_isDirectory}, - { "isDevice", _wrap_File_isDevice}, - { "isHidden", _wrap_File_isHidden}, - { "setWriteable", _wrap_File_setWriteable}, - { "setReadOnly", _wrap_File_setReadOnly}, - { "setExecutable", _wrap_File_setExecutable}, - { "copyTo", _wrap_File_copyTo}, - { "moveTo", _wrap_File_moveTo}, - { "renameTo", _wrap_File_renameTo}, - { "remove", _wrap_File_remove}, - { "getSize", _wrap_File_getSize}, - { "__eq", _wrap_File___eq}, - { "__lt", _wrap_File___lt}, - { "__le", _wrap_File___le}, - { "readToBuffer", _wrap_File_readToBuffer}, - { "writeFromBuffer", _wrap_File_writeFromBuffer}, - {0,0} -}; -static swig_lua_method swig_File_meta[] = { - { "__eq", _wrap_File___eq}, - { "__lt", _wrap_File___lt}, - { "__le", _wrap_File___le}, - {0,0} -}; - -static swig_lua_attribute swig_File_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_File_Sf_SwigStatic_constants[]= { - {SWIG_LUA_CONSTTAB_INT("Reference", ofFile::Reference)}, - {SWIG_LUA_CONSTTAB_INT("ReadOnly", ofFile::ReadOnly)}, - {SWIG_LUA_CONSTTAB_INT("WriteOnly", ofFile::WriteOnly)}, - {SWIG_LUA_CONSTTAB_INT("ReadWrite", ofFile::ReadWrite)}, - {SWIG_LUA_CONSTTAB_INT("Append", ofFile::Append)}, - {0,0,0,0,0,0} -}; -static swig_lua_method swig_File_Sf_SwigStatic_methods[]= { - { "copyFromTo", _wrap_File_copyFromTo}, - { "moveFromTo", _wrap_File_moveFromTo}, - { "doesFileExist", _wrap_File_doesFileExist}, - { "removeFile", _wrap_File_removeFile}, - {0,0} -}; -static swig_lua_class* swig_File_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_File_Sf_SwigStatic = { - "File", - swig_File_Sf_SwigStatic_methods, - swig_File_Sf_SwigStatic_attributes, - swig_File_Sf_SwigStatic_constants, - swig_File_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_File_bases[] = {0}; -static const char *swig_File_base_names[] = {0}; -static swig_lua_class _wrap_class_File = { "File", "File", &SWIGTYPE_p_ofFile,_proxy__wrap_new_File, swig_delete_File, swig_File_methods, swig_File_attributes, &swig_File_Sf_SwigStatic, swig_File_meta, swig_File_bases, swig_File_base_names }; - -static int _wrap_new_Directory__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofDirectory *result = 0 ; - SWIG_check_num_args("ofDirectory::ofDirectory",0,0) result = (ofDirectory *)new ofDirectory(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofDirectory,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Directory__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::filesystem::path *arg1 = 0 ; - std::filesystem::path temp1 ; ofDirectory *result = 0 ; SWIG_check_num_args("ofDirectory::ofDirectory",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofDirectory::ofDirectory",1,"std::filesystem::path const &"); { - size_t len = lua_rawlen(L, 1); temp1 = lua_tolstring(L, 1, &len); arg1 = &temp1; } - result = (ofDirectory *)new ofDirectory((std::filesystem::path const &)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofDirectory,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Directory(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_Directory__SWIG_0(L);} if (argc == 1) { int _v; { _v = lua_isstring(L, argv[0]); } if (_v) { - return _wrap_new_Directory__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_Directory'\n" " Possible C/C++ prototypes are:\n" - " ofDirectory::ofDirectory()\n" " ofDirectory::ofDirectory(std::filesystem::path const &)\n"); lua_error(L);return 0; } -static int _wrap_Directory_open(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - std::filesystem::path *arg2 = 0 ; std::filesystem::path temp2 ; SWIG_check_num_args("ofDirectory::open",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::open",1,"ofDirectory *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofDirectory::open",2,"std::filesystem::path const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_open",1,SWIGTYPE_p_ofDirectory); } { size_t len = lua_rawlen(L, 2); - temp2 = lua_tolstring(L, 2, &len); arg2 = &temp2; } (arg1)->open((std::filesystem::path const &)*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_close(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - SWIG_check_num_args("ofDirectory::close",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::close",1,"ofDirectory *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_close",1,SWIGTYPE_p_ofDirectory); } (arg1)->close(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Directory_create__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; bool arg2 ; - bool result; SWIG_check_num_args("ofDirectory::create",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::create",1,"ofDirectory *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofDirectory::create",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_create",1,SWIGTYPE_p_ofDirectory); } arg2 = (lua_toboolean(L, 2)!=0); - result = (bool)(arg1)->create(arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Directory_create__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; bool result; - SWIG_check_num_args("ofDirectory::create",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::create",1,"ofDirectory *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_create",1,SWIGTYPE_p_ofDirectory); } result = (bool)(arg1)->create(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_create(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofDirectory, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Directory_create__SWIG_1(L);} } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofDirectory, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { return _wrap_Directory_create__SWIG_0(L);} } - } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Directory_create'\n" - " Possible C/C++ prototypes are:\n" " ofDirectory::create(bool)\n" " ofDirectory::create()\n"); lua_error(L);return 0; } -static int _wrap_Directory_exists(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; bool result; - SWIG_check_num_args("ofDirectory::exists",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::exists",1,"ofDirectory const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_exists",1,SWIGTYPE_p_ofDirectory); } result = (bool)((ofDirectory const *)arg1)->exists(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_path(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; std::string result; - SWIG_check_num_args("ofDirectory::path",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::path",1,"ofDirectory const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_path",1,SWIGTYPE_p_ofDirectory); } result = ((ofDirectory const *)arg1)->path(); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Directory_getAbsolutePath(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - std::string result; SWIG_check_num_args("ofDirectory::getAbsolutePath",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::getAbsolutePath",1,"ofDirectory const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_getAbsolutePath",1,SWIGTYPE_p_ofDirectory); } - result = ((ofDirectory const *)arg1)->getAbsolutePath(); lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_canRead(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; bool result; - SWIG_check_num_args("ofDirectory::canRead",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::canRead",1,"ofDirectory const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_canRead",1,SWIGTYPE_p_ofDirectory); } result = (bool)((ofDirectory const *)arg1)->canRead(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_canWrite(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; bool result; - SWIG_check_num_args("ofDirectory::canWrite",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::canWrite",1,"ofDirectory const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_canWrite",1,SWIGTYPE_p_ofDirectory); } result = (bool)((ofDirectory const *)arg1)->canWrite(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_canExecute(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; bool result; - SWIG_check_num_args("ofDirectory::canExecute",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::canExecute",1,"ofDirectory const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_canExecute",1,SWIGTYPE_p_ofDirectory); } result = (bool)((ofDirectory const *)arg1)->canExecute(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_isDirectory(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; bool result; - SWIG_check_num_args("ofDirectory::isDirectory",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::isDirectory",1,"ofDirectory const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_isDirectory",1,SWIGTYPE_p_ofDirectory); } - result = (bool)((ofDirectory const *)arg1)->isDirectory(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_isHidden(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; bool result; - SWIG_check_num_args("ofDirectory::isHidden",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::isHidden",1,"ofDirectory const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_isHidden",1,SWIGTYPE_p_ofDirectory); } result = (bool)((ofDirectory const *)arg1)->isHidden(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_setWriteable__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - bool arg2 ; SWIG_check_num_args("ofDirectory::setWriteable",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::setWriteable",1,"ofDirectory *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofDirectory::setWriteable",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_setWriteable",1,SWIGTYPE_p_ofDirectory); } arg2 = (lua_toboolean(L, 2)!=0); - (arg1)->setWriteable(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_setWriteable__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - SWIG_check_num_args("ofDirectory::setWriteable",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::setWriteable",1,"ofDirectory *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_setWriteable",1,SWIGTYPE_p_ofDirectory); } (arg1)->setWriteable(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_setWriteable(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofDirectory, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Directory_setWriteable__SWIG_1(L);} } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofDirectory, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_Directory_setWriteable__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Directory_setWriteable'\n" - " Possible C/C++ prototypes are:\n" " ofDirectory::setWriteable(bool)\n" " ofDirectory::setWriteable()\n"); - lua_error(L);return 0; } -static int _wrap_Directory_setReadOnly__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - bool arg2 ; SWIG_check_num_args("ofDirectory::setReadOnly",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::setReadOnly",1,"ofDirectory *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofDirectory::setReadOnly",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_setReadOnly",1,SWIGTYPE_p_ofDirectory); } arg2 = (lua_toboolean(L, 2)!=0); - (arg1)->setReadOnly(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_setReadOnly__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - SWIG_check_num_args("ofDirectory::setReadOnly",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::setReadOnly",1,"ofDirectory *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_setReadOnly",1,SWIGTYPE_p_ofDirectory); } (arg1)->setReadOnly(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_setReadOnly(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofDirectory, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Directory_setReadOnly__SWIG_1(L);} } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofDirectory, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_Directory_setReadOnly__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Directory_setReadOnly'\n" - " Possible C/C++ prototypes are:\n" " ofDirectory::setReadOnly(bool)\n" " ofDirectory::setReadOnly()\n"); - lua_error(L);return 0; } -static int _wrap_Directory_setExecutable__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - bool arg2 ; SWIG_check_num_args("ofDirectory::setExecutable",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::setExecutable",1,"ofDirectory *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofDirectory::setExecutable",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_setExecutable",1,SWIGTYPE_p_ofDirectory); } arg2 = (lua_toboolean(L, 2)!=0); - (arg1)->setExecutable(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_setExecutable__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - SWIG_check_num_args("ofDirectory::setExecutable",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::setExecutable",1,"ofDirectory *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_setExecutable",1,SWIGTYPE_p_ofDirectory); } (arg1)->setExecutable(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_setExecutable(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofDirectory, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Directory_setExecutable__SWIG_1(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofDirectory, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_Directory_setExecutable__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Directory_setExecutable'\n" - " Possible C/C++ prototypes are:\n" " ofDirectory::setExecutable(bool)\n" " ofDirectory::setExecutable()\n"); - lua_error(L);return 0; } -static int _wrap_Directory_setShowHidden(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; bool arg2 ; - SWIG_check_num_args("ofDirectory::setShowHidden",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::setShowHidden",1,"ofDirectory *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofDirectory::setShowHidden",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_setShowHidden",1,SWIGTYPE_p_ofDirectory); } arg2 = (lua_toboolean(L, 2)!=0); - (arg1)->setShowHidden(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_copyTo__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - std::string *arg2 = 0 ; bool arg3 ; bool arg4 ; std::string temp2 ; bool result; - SWIG_check_num_args("ofDirectory::copyTo",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::copyTo",1,"ofDirectory *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofDirectory::copyTo",2,"std::string const &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofDirectory::copyTo",3,"bool"); - if(!lua_isboolean(L,4)) SWIG_fail_arg("ofDirectory::copyTo",4,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_copyTo",1,SWIGTYPE_p_ofDirectory); } temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - arg3 = (lua_toboolean(L, 3)!=0); arg4 = (lua_toboolean(L, 4)!=0); - result = (bool)(arg1)->copyTo((std::string const &)*arg2,arg3,arg4); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_copyTo__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - std::string *arg2 = 0 ; bool arg3 ; std::string temp2 ; bool result; SWIG_check_num_args("ofDirectory::copyTo",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::copyTo",1,"ofDirectory *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofDirectory::copyTo",2,"std::string const &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofDirectory::copyTo",3,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_copyTo",1,SWIGTYPE_p_ofDirectory); } temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - arg3 = (lua_toboolean(L, 3)!=0); result = (bool)(arg1)->copyTo((std::string const &)*arg2,arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_copyTo__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - std::string *arg2 = 0 ; std::string temp2 ; bool result; SWIG_check_num_args("ofDirectory::copyTo",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::copyTo",1,"ofDirectory *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofDirectory::copyTo",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_copyTo",1,SWIGTYPE_p_ofDirectory); } temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = (bool)(arg1)->copyTo((std::string const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_copyTo(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofDirectory, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { return _wrap_Directory_copyTo__SWIG_2(L);} } - } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofDirectory, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - return _wrap_Directory_copyTo__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofDirectory, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - { _v = lua_isboolean(L,argv[3]); } if (_v) { return _wrap_Directory_copyTo__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Directory_copyTo'\n" " Possible C/C++ prototypes are:\n" - " ofDirectory::copyTo(std::string const &,bool,bool)\n" " ofDirectory::copyTo(std::string const &,bool)\n" - " ofDirectory::copyTo(std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_Directory_moveTo__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - std::string *arg2 = 0 ; bool arg3 ; bool arg4 ; std::string temp2 ; bool result; - SWIG_check_num_args("ofDirectory::moveTo",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::moveTo",1,"ofDirectory *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofDirectory::moveTo",2,"std::string const &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofDirectory::moveTo",3,"bool"); - if(!lua_isboolean(L,4)) SWIG_fail_arg("ofDirectory::moveTo",4,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_moveTo",1,SWIGTYPE_p_ofDirectory); } temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - arg3 = (lua_toboolean(L, 3)!=0); arg4 = (lua_toboolean(L, 4)!=0); - result = (bool)(arg1)->moveTo((std::string const &)*arg2,arg3,arg4); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_moveTo__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - std::string *arg2 = 0 ; bool arg3 ; std::string temp2 ; bool result; SWIG_check_num_args("ofDirectory::moveTo",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::moveTo",1,"ofDirectory *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofDirectory::moveTo",2,"std::string const &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofDirectory::moveTo",3,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_moveTo",1,SWIGTYPE_p_ofDirectory); } temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - arg3 = (lua_toboolean(L, 3)!=0); result = (bool)(arg1)->moveTo((std::string const &)*arg2,arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_moveTo__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - std::string *arg2 = 0 ; std::string temp2 ; bool result; SWIG_check_num_args("ofDirectory::moveTo",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::moveTo",1,"ofDirectory *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofDirectory::moveTo",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_moveTo",1,SWIGTYPE_p_ofDirectory); } temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = (bool)(arg1)->moveTo((std::string const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_moveTo(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofDirectory, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { return _wrap_Directory_moveTo__SWIG_2(L);} } - } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofDirectory, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - return _wrap_Directory_moveTo__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofDirectory, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - { _v = lua_isboolean(L,argv[3]); } if (_v) { return _wrap_Directory_moveTo__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Directory_moveTo'\n" " Possible C/C++ prototypes are:\n" - " ofDirectory::moveTo(std::string const &,bool,bool)\n" " ofDirectory::moveTo(std::string const &,bool)\n" - " ofDirectory::moveTo(std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_Directory_renameTo__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - std::string *arg2 = 0 ; bool arg3 ; bool arg4 ; std::string temp2 ; bool result; - SWIG_check_num_args("ofDirectory::renameTo",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::renameTo",1,"ofDirectory *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofDirectory::renameTo",2,"std::string const &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofDirectory::renameTo",3,"bool"); - if(!lua_isboolean(L,4)) SWIG_fail_arg("ofDirectory::renameTo",4,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_renameTo",1,SWIGTYPE_p_ofDirectory); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; arg3 = (lua_toboolean(L, 3)!=0); - arg4 = (lua_toboolean(L, 4)!=0); result = (bool)(arg1)->renameTo((std::string const &)*arg2,arg3,arg4); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_renameTo__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - std::string *arg2 = 0 ; bool arg3 ; std::string temp2 ; bool result; SWIG_check_num_args("ofDirectory::renameTo",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::renameTo",1,"ofDirectory *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofDirectory::renameTo",2,"std::string const &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofDirectory::renameTo",3,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_renameTo",1,SWIGTYPE_p_ofDirectory); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; arg3 = (lua_toboolean(L, 3)!=0); - result = (bool)(arg1)->renameTo((std::string const &)*arg2,arg3); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_renameTo__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - std::string *arg2 = 0 ; std::string temp2 ; bool result; SWIG_check_num_args("ofDirectory::renameTo",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::renameTo",1,"ofDirectory *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofDirectory::renameTo",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_renameTo",1,SWIGTYPE_p_ofDirectory); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; result = (bool)(arg1)->renameTo((std::string const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_renameTo(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofDirectory, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { return _wrap_Directory_renameTo__SWIG_2(L);} - } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofDirectory, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - return _wrap_Directory_renameTo__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofDirectory, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - { _v = lua_isboolean(L,argv[3]); } if (_v) { return _wrap_Directory_renameTo__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Directory_renameTo'\n" " Possible C/C++ prototypes are:\n" - " ofDirectory::renameTo(std::string const &,bool,bool)\n" " ofDirectory::renameTo(std::string const &,bool)\n" - " ofDirectory::renameTo(std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_Directory_remove(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; bool arg2 ; - bool result; SWIG_check_num_args("ofDirectory::remove",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::remove",1,"ofDirectory *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofDirectory::remove",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_remove",1,SWIGTYPE_p_ofDirectory); } arg2 = (lua_toboolean(L, 2)!=0); - result = (bool)(arg1)->remove(arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Directory_allowExt(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - std::string *arg2 = 0 ; std::string temp2 ; SWIG_check_num_args("ofDirectory::allowExt",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::allowExt",1,"ofDirectory *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofDirectory::allowExt",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_allowExt",1,SWIGTYPE_p_ofDirectory); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; (arg1)->allowExt((std::string const &)*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_listDir__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - std::string *arg2 = 0 ; std::string temp2 ; std::size_t result; SWIG_check_num_args("ofDirectory::listDir",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::listDir",1,"ofDirectory *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofDirectory::listDir",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_listDir",1,SWIGTYPE_p_ofDirectory); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = (std::size_t)(arg1)->listDir((std::string const &)*arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_listDir__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - std::size_t result; SWIG_check_num_args("ofDirectory::listDir",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::listDir",1,"ofDirectory *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_listDir",1,SWIGTYPE_p_ofDirectory); } result = (std::size_t)(arg1)->listDir(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_listDir(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofDirectory, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Directory_listDir__SWIG_1(L);} } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofDirectory, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { return _wrap_Directory_listDir__SWIG_0(L);} } - } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Directory_listDir'\n" - " Possible C/C++ prototypes are:\n" " ofDirectory::listDir(std::string const &)\n" " ofDirectory::listDir()\n"); - lua_error(L);return 0; } -static int _wrap_Directory_getOriginalDirectory(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - std::string result; SWIG_check_num_args("ofDirectory::getOriginalDirectory",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::getOriginalDirectory",1,"ofDirectory const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_getOriginalDirectory",1,SWIGTYPE_p_ofDirectory); } - result = ((ofDirectory const *)arg1)->getOriginalDirectory(); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Directory_getName(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; std::size_t arg2 ; - std::string result; SWIG_check_num_args("ofDirectory::getName",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::getName",1,"ofDirectory const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDirectory::getName",2,"std::size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_getName",1,SWIGTYPE_p_ofDirectory); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (std::size_t)lua_tonumber(L, 2); - result = ((ofDirectory const *)arg1)->getName(arg2); lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_getPath(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; std::size_t arg2 ; - std::string result; SWIG_check_num_args("ofDirectory::getPath",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::getPath",1,"ofDirectory const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDirectory::getPath",2,"std::size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_getPath",1,SWIGTYPE_p_ofDirectory); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (std::size_t)lua_tonumber(L, 2); - result = ((ofDirectory const *)arg1)->getPath(arg2); lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_getFile__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - std::size_t arg2 ; ofFile::Mode arg3 ; bool arg4 ; ofFile result; SWIG_check_num_args("ofDirectory::getFile",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::getFile",1,"ofDirectory const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDirectory::getFile",2,"std::size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDirectory::getFile",3,"ofFile::Mode"); - if(!lua_isboolean(L,4)) SWIG_fail_arg("ofDirectory::getFile",4,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_getFile",1,SWIGTYPE_p_ofDirectory); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (std::size_t)lua_tonumber(L, 2); - arg3 = (ofFile::Mode)(int)lua_tonumber(L, 3); arg4 = (lua_toboolean(L, 4)!=0); - result = ((ofDirectory const *)arg1)->getFile(arg2,arg3,arg4); { ofFile * resultptr = new ofFile((const ofFile &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofFile,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Directory_getFile__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - std::size_t arg2 ; ofFile::Mode arg3 ; ofFile result; SWIG_check_num_args("ofDirectory::getFile",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::getFile",1,"ofDirectory const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDirectory::getFile",2,"std::size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDirectory::getFile",3,"ofFile::Mode"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_getFile",1,SWIGTYPE_p_ofDirectory); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (std::size_t)lua_tonumber(L, 2); - arg3 = (ofFile::Mode)(int)lua_tonumber(L, 3); result = ((ofDirectory const *)arg1)->getFile(arg2,arg3); { - ofFile * resultptr = new ofFile((const ofFile &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofFile,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Directory_getFile__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - std::size_t arg2 ; ofFile result; SWIG_check_num_args("ofDirectory::getFile",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::getFile",1,"ofDirectory const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDirectory::getFile",2,"std::size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_getFile",1,SWIGTYPE_p_ofDirectory); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (std::size_t)lua_tonumber(L, 2); - result = ((ofDirectory const *)arg1)->getFile(arg2); { ofFile * resultptr = new ofFile((const ofFile &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofFile,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Directory_getFile(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofDirectory, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Directory_getFile__SWIG_2(L);} } - } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofDirectory, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Directory_getFile__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofDirectory, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isboolean(L,argv[3]); } if (_v) { return _wrap_Directory_getFile__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Directory_getFile'\n" " Possible C/C++ prototypes are:\n" - " ofDirectory::getFile(std::size_t,ofFile::Mode,bool) const\n" " ofDirectory::getFile(std::size_t,ofFile::Mode) const\n" - " ofDirectory::getFile(std::size_t) const\n"); lua_error(L);return 0; } -static int _wrap_Directory_getFiles(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - std::vector< ofFile > *result = 0 ; SWIG_check_num_args("ofDirectory::getFiles",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::getFiles",1,"ofDirectory const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_getFiles",1,SWIGTYPE_p_ofDirectory); } - result = (std::vector< ofFile > *) &((ofDirectory const *)arg1)->getFiles(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofFile_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Directory_getShowHidden(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; bool result; - SWIG_check_num_args("ofDirectory::getShowHidden",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::getShowHidden",1,"ofDirectory const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_getShowHidden",1,SWIGTYPE_p_ofDirectory); } - result = (bool)((ofDirectory const *)arg1)->getShowHidden(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_reset(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - SWIG_check_num_args("ofDirectory::reset",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::reset",1,"ofDirectory *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_reset",1,SWIGTYPE_p_ofDirectory); } (arg1)->reset(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Directory_sort(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - SWIG_check_num_args("ofDirectory::sort",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::sort",1,"ofDirectory *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_sort",1,SWIGTYPE_p_ofDirectory); } (arg1)->sort(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Directory_getSorted(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - ofDirectory result; SWIG_check_num_args("ofDirectory::getSorted",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::getSorted",1,"ofDirectory *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_getSorted",1,SWIGTYPE_p_ofDirectory); } result = (arg1)->getSorted(); { - ofDirectory * resultptr = new ofDirectory((const ofDirectory &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofDirectory,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Directory_size(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; std::size_t result; - SWIG_check_num_args("ofDirectory::size",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::size",1,"ofDirectory const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_size",1,SWIGTYPE_p_ofDirectory); } result = (std::size_t)((ofDirectory const *)arg1)->size(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory___eq(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - ofDirectory *arg2 = 0 ; bool result; SWIG_check_num_args("ofDirectory::operator ==",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::operator ==",1,"ofDirectory const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofDirectory::operator ==",2,"ofDirectory const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory___eq",1,SWIGTYPE_p_ofDirectory); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory___eq",2,SWIGTYPE_p_ofDirectory); } - result = (bool)((ofDirectory const *)arg1)->operator ==((ofDirectory const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory___lt(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - ofDirectory *arg2 = 0 ; bool result; SWIG_check_num_args("ofDirectory::operator <",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::operator <",1,"ofDirectory const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofDirectory::operator <",2,"ofDirectory const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory___lt",1,SWIGTYPE_p_ofDirectory); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory___lt",2,SWIGTYPE_p_ofDirectory); } - result = (bool)((ofDirectory const *)arg1)->operator <((ofDirectory const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory___le(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - ofDirectory *arg2 = 0 ; bool result; SWIG_check_num_args("ofDirectory::operator <=",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::operator <=",1,"ofDirectory const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofDirectory::operator <=",2,"ofDirectory const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory___le",1,SWIGTYPE_p_ofDirectory); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory___le",2,SWIGTYPE_p_ofDirectory); } - result = (bool)((ofDirectory const *)arg1)->operator <=((ofDirectory const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_createDirectory__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; bool arg2 ; - bool arg3 ; std::string temp1 ; bool result; SWIG_check_num_args("ofDirectory::createDirectory",3,3) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofDirectory::createDirectory",1,"std::string const &"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofDirectory::createDirectory",2,"bool"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofDirectory::createDirectory",3,"bool"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; arg2 = (lua_toboolean(L, 2)!=0); - arg3 = (lua_toboolean(L, 3)!=0); result = (bool)ofDirectory::createDirectory((std::string const &)*arg1,arg2,arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_createDirectory__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; bool arg2 ; - std::string temp1 ; bool result; SWIG_check_num_args("ofDirectory::createDirectory",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofDirectory::createDirectory",1,"std::string const &"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofDirectory::createDirectory",2,"bool"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; arg2 = (lua_toboolean(L, 2)!=0); - result = (bool)ofDirectory::createDirectory((std::string const &)*arg1,arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_createDirectory__SWIG_2(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - bool result; SWIG_check_num_args("ofDirectory::createDirectory",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofDirectory::createDirectory",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; - result = (bool)ofDirectory::createDirectory((std::string const &)*arg1); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_createDirectory(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); - if (argc == 1) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { return _wrap_Directory_createDirectory__SWIG_2(L);} } - if (argc == 2) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_Directory_createDirectory__SWIG_1(L);} } } if (argc == 3) { int _v; { _v = lua_isstring(L,argv[0]); } - if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - return _wrap_Directory_createDirectory__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Directory_createDirectory'\n" - " Possible C/C++ prototypes are:\n" " ofDirectory::createDirectory(std::string const &,bool,bool)\n" - " ofDirectory::createDirectory(std::string const &,bool)\n" " ofDirectory::createDirectory(std::string const &)\n"); - lua_error(L);return 0; } -static int _wrap_Directory_isDirectoryEmpty__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; bool arg2 ; - std::string temp1 ; bool result; SWIG_check_num_args("ofDirectory::isDirectoryEmpty",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofDirectory::isDirectoryEmpty",1,"std::string const &"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofDirectory::isDirectoryEmpty",2,"bool"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; arg2 = (lua_toboolean(L, 2)!=0); - result = (bool)ofDirectory::isDirectoryEmpty((std::string const &)*arg1,arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_isDirectoryEmpty__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; - std::string temp1 ; bool result; SWIG_check_num_args("ofDirectory::isDirectoryEmpty",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofDirectory::isDirectoryEmpty",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; - result = (bool)ofDirectory::isDirectoryEmpty((std::string const &)*arg1); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_isDirectoryEmpty(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); - if (argc == 1) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { return _wrap_Directory_isDirectoryEmpty__SWIG_1(L);} } - if (argc == 2) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_Directory_isDirectoryEmpty__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Directory_isDirectoryEmpty'\n" - " Possible C/C++ prototypes are:\n" " ofDirectory::isDirectoryEmpty(std::string const &,bool)\n" - " ofDirectory::isDirectoryEmpty(std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_Directory_doesDirectoryExist__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; bool arg2 ; - std::string temp1 ; bool result; SWIG_check_num_args("ofDirectory::doesDirectoryExist",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofDirectory::doesDirectoryExist",1,"std::string const &"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofDirectory::doesDirectoryExist",2,"bool"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; arg2 = (lua_toboolean(L, 2)!=0); - result = (bool)ofDirectory::doesDirectoryExist((std::string const &)*arg1,arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_doesDirectoryExist__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; - std::string temp1 ; bool result; SWIG_check_num_args("ofDirectory::doesDirectoryExist",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofDirectory::doesDirectoryExist",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; - result = (bool)ofDirectory::doesDirectoryExist((std::string const &)*arg1); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_doesDirectoryExist(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); - if (argc == 1) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { return _wrap_Directory_doesDirectoryExist__SWIG_1(L);} } - if (argc == 2) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_Directory_doesDirectoryExist__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Directory_doesDirectoryExist'\n" - " Possible C/C++ prototypes are:\n" " ofDirectory::doesDirectoryExist(std::string const &,bool)\n" - " ofDirectory::doesDirectoryExist(std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_Directory_removeDirectory__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; bool arg2 ; - bool arg3 ; std::string temp1 ; bool result; SWIG_check_num_args("ofDirectory::removeDirectory",3,3) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofDirectory::removeDirectory",1,"std::string const &"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofDirectory::removeDirectory",2,"bool"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofDirectory::removeDirectory",3,"bool"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; arg2 = (lua_toboolean(L, 2)!=0); - arg3 = (lua_toboolean(L, 3)!=0); result = (bool)ofDirectory::removeDirectory((std::string const &)*arg1,arg2,arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_removeDirectory__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; bool arg2 ; - std::string temp1 ; bool result; SWIG_check_num_args("ofDirectory::removeDirectory",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofDirectory::removeDirectory",1,"std::string const &"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofDirectory::removeDirectory",2,"bool"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; arg2 = (lua_toboolean(L, 2)!=0); - result = (bool)ofDirectory::removeDirectory((std::string const &)*arg1,arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_removeDirectory(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_Directory_removeDirectory__SWIG_1(L);} } } if (argc == 3) { int _v; { _v = lua_isstring(L,argv[0]); } - if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - return _wrap_Directory_removeDirectory__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Directory_removeDirectory'\n" - " Possible C/C++ prototypes are:\n" " ofDirectory::removeDirectory(std::string const &,bool,bool)\n" - " ofDirectory::removeDirectory(std::string const &,bool)\n"); lua_error(L);return 0; } -static void swig_delete_Directory(void *obj) { -ofDirectory *arg1 = (ofDirectory *) obj; -delete arg1; -} -static int _proxy__wrap_new_Directory(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_Directory); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_Directory_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_Directory_methods[]= { - { "open", _wrap_Directory_open}, - { "close", _wrap_Directory_close}, - { "create", _wrap_Directory_create}, - { "exists", _wrap_Directory_exists}, - { "path", _wrap_Directory_path}, - { "getAbsolutePath", _wrap_Directory_getAbsolutePath}, - { "canRead", _wrap_Directory_canRead}, - { "canWrite", _wrap_Directory_canWrite}, - { "canExecute", _wrap_Directory_canExecute}, - { "isDirectory", _wrap_Directory_isDirectory}, - { "isHidden", _wrap_Directory_isHidden}, - { "setWriteable", _wrap_Directory_setWriteable}, - { "setReadOnly", _wrap_Directory_setReadOnly}, - { "setExecutable", _wrap_Directory_setExecutable}, - { "setShowHidden", _wrap_Directory_setShowHidden}, - { "copyTo", _wrap_Directory_copyTo}, - { "moveTo", _wrap_Directory_moveTo}, - { "renameTo", _wrap_Directory_renameTo}, - { "remove", _wrap_Directory_remove}, - { "allowExt", _wrap_Directory_allowExt}, - { "listDir", _wrap_Directory_listDir}, - { "getOriginalDirectory", _wrap_Directory_getOriginalDirectory}, - { "getName", _wrap_Directory_getName}, - { "getPath", _wrap_Directory_getPath}, - { "getFile", _wrap_Directory_getFile}, - { "getFiles", _wrap_Directory_getFiles}, - { "getShowHidden", _wrap_Directory_getShowHidden}, - { "reset", _wrap_Directory_reset}, - { "sort", _wrap_Directory_sort}, - { "getSorted", _wrap_Directory_getSorted}, - { "size", _wrap_Directory_size}, - { "__eq", _wrap_Directory___eq}, - { "__lt", _wrap_Directory___lt}, - { "__le", _wrap_Directory___le}, - {0,0} -}; -static swig_lua_method swig_Directory_meta[] = { - { "__eq", _wrap_Directory___eq}, - { "__lt", _wrap_Directory___lt}, - { "__le", _wrap_Directory___le}, - {0,0} -}; - -static swig_lua_attribute swig_Directory_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_Directory_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_Directory_Sf_SwigStatic_methods[]= { - { "createDirectory", _wrap_Directory_createDirectory}, - { "isDirectoryEmpty", _wrap_Directory_isDirectoryEmpty}, - { "doesDirectoryExist", _wrap_Directory_doesDirectoryExist}, - { "removeDirectory", _wrap_Directory_removeDirectory}, - {0,0} -}; -static swig_lua_class* swig_Directory_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_Directory_Sf_SwigStatic = { - "Directory", - swig_Directory_Sf_SwigStatic_methods, - swig_Directory_Sf_SwigStatic_attributes, - swig_Directory_Sf_SwigStatic_constants, - swig_Directory_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_Directory_bases[] = {0}; -static const char *swig_Directory_base_names[] = {0}; -static swig_lua_class _wrap_class_Directory = { "Directory", "Directory", &SWIGTYPE_p_ofDirectory,_proxy__wrap_new_Directory, swig_delete_Directory, swig_Directory_methods, swig_Directory_attributes, &swig_Directory_Sf_SwigStatic, swig_Directory_meta, swig_Directory_bases, swig_Directory_base_names }; - -static int _wrap_log(lua_State* L) { int SWIG_arg = 0; ofLogLevel arg1 ; std::string *arg2 = 0 ; std::string temp2 ; - SWIG_check_num_args("log",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("log",1,"ofLogLevel"); - if(!lua_isstring(L,2)) SWIG_fail_arg("log",2,"std::string const &"); arg1 = (ofLogLevel)(int)lua_tonumber(L, 1); - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; log(arg1,(std::string const &)*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setLogLevel__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofLogLevel arg1 ; - SWIG_check_num_args("ofSetLogLevel",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetLogLevel",1,"ofLogLevel"); - arg1 = (ofLogLevel)(int)lua_tonumber(L, 1); ofSetLogLevel(arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_setLogLevel__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string arg1 ; ofLogLevel arg2 ; - SWIG_check_num_args("ofSetLogLevel",2,2) if(!lua_isstring(L,1)) SWIG_fail_arg("ofSetLogLevel",1,"std::string"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSetLogLevel",2,"ofLogLevel"); (&arg1)->assign(lua_tostring(L,1),lua_rawlen(L,1)); - arg2 = (ofLogLevel)(int)lua_tonumber(L, 2); ofSetLogLevel(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_setLogLevel(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_setLogLevel__SWIG_0(L);} } if (argc == 2) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_setLogLevel__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'setLogLevel'\n" " Possible C/C++ prototypes are:\n" - " ofSetLogLevel(ofLogLevel)\n" " ofSetLogLevel(std::string,ofLogLevel)\n"); lua_error(L);return 0; } -static int _wrap_getLogLevel(lua_State* L) { int SWIG_arg = 0; ofLogLevel result; SWIG_check_num_args("ofGetLogLevel",0,0) - result = (ofLogLevel)ofGetLogLevel(); lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getLogLevelName__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofLogLevel arg1 ; bool arg2 ; std::string result; - SWIG_check_num_args("ofGetLogLevelName",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofGetLogLevelName",1,"ofLogLevel"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofGetLogLevelName",2,"bool"); arg1 = (ofLogLevel)(int)lua_tonumber(L, 1); - arg2 = (lua_toboolean(L, 2)!=0); result = ofGetLogLevelName(arg1,arg2); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_getLogLevelName__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofLogLevel arg1 ; std::string result; - SWIG_check_num_args("ofGetLogLevelName",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofGetLogLevelName",1,"ofLogLevel"); - arg1 = (ofLogLevel)(int)lua_tonumber(L, 1); result = ofGetLogLevelName(arg1); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_getLogLevelName(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; - { _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_getLogLevelName__SWIG_1(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_getLogLevelName__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'getLogLevelName'\n" " Possible C/C++ prototypes are:\n" - " ofGetLogLevelName(ofLogLevel,bool)\n" " ofGetLogLevelName(ofLogLevel)\n"); lua_error(L);return 0; } -static int _wrap_logToFile__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; bool arg2 ; std::string temp1 ; - SWIG_check_num_args("ofLogToFile",2,2) if(!lua_isstring(L,1)) SWIG_fail_arg("ofLogToFile",1,"std::string const &"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofLogToFile",2,"bool"); temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; - arg2 = (lua_toboolean(L, 2)!=0); ofLogToFile((std::string const &)*arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_logToFile__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - SWIG_check_num_args("ofLogToFile",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofLogToFile",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; ofLogToFile((std::string const &)*arg1); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_logToFile(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { return _wrap_logToFile__SWIG_1(L);} } if (argc == 2) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_logToFile__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'logToFile'\n" " Possible C/C++ prototypes are:\n" - " ofLogToFile(std::string const &,bool)\n" " ofLogToFile(std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_logToConsole(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofLogToConsole",0,0) ofLogToConsole(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_new_FileDialogResult(lua_State* L) { int SWIG_arg = 0; ofFileDialogResult *result = 0 ; - SWIG_check_num_args("ofFileDialogResult::ofFileDialogResult",0,0) result = (ofFileDialogResult *)new ofFileDialogResult(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofFileDialogResult,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FileDialogResult_getName(lua_State* L) { int SWIG_arg = 0; - ofFileDialogResult *arg1 = (ofFileDialogResult *) 0 ; std::string result; - SWIG_check_num_args("ofFileDialogResult::getName",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFileDialogResult::getName",1,"ofFileDialogResult *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFileDialogResult,0))){ - SWIG_fail_ptr("FileDialogResult_getName",1,SWIGTYPE_p_ofFileDialogResult); } result = (arg1)->getName(); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FileDialogResult_getPath(lua_State* L) { int SWIG_arg = 0; - ofFileDialogResult *arg1 = (ofFileDialogResult *) 0 ; std::string result; - SWIG_check_num_args("ofFileDialogResult::getPath",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFileDialogResult::getPath",1,"ofFileDialogResult *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFileDialogResult,0))){ - SWIG_fail_ptr("FileDialogResult_getPath",1,SWIGTYPE_p_ofFileDialogResult); } result = (arg1)->getPath(); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FileDialogResult_filePath_set(lua_State* L) { int SWIG_arg = 0; - ofFileDialogResult *arg1 = (ofFileDialogResult *) 0 ; std::string *arg2 = 0 ; std::string temp2 ; - SWIG_check_num_args("ofFileDialogResult::filePath",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFileDialogResult::filePath",1,"ofFileDialogResult *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofFileDialogResult::filePath",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFileDialogResult,0))){ - SWIG_fail_ptr("FileDialogResult_filePath_set",1,SWIGTYPE_p_ofFileDialogResult); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; if (arg1) (arg1)->filePath = *arg2; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FileDialogResult_filePath_get(lua_State* L) { int SWIG_arg = 0; - ofFileDialogResult *arg1 = (ofFileDialogResult *) 0 ; std::string *result = 0 ; - SWIG_check_num_args("ofFileDialogResult::filePath",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFileDialogResult::filePath",1,"ofFileDialogResult *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFileDialogResult,0))){ - SWIG_fail_ptr("FileDialogResult_filePath_get",1,SWIGTYPE_p_ofFileDialogResult); } - result = (std::string *) & ((arg1)->filePath); lua_pushlstring(L,result->data(),result->size()); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FileDialogResult_fileName_set(lua_State* L) { int SWIG_arg = 0; - ofFileDialogResult *arg1 = (ofFileDialogResult *) 0 ; std::string *arg2 = 0 ; std::string temp2 ; - SWIG_check_num_args("ofFileDialogResult::fileName",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFileDialogResult::fileName",1,"ofFileDialogResult *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofFileDialogResult::fileName",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFileDialogResult,0))){ - SWIG_fail_ptr("FileDialogResult_fileName_set",1,SWIGTYPE_p_ofFileDialogResult); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; if (arg1) (arg1)->fileName = *arg2; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FileDialogResult_fileName_get(lua_State* L) { int SWIG_arg = 0; - ofFileDialogResult *arg1 = (ofFileDialogResult *) 0 ; std::string *result = 0 ; - SWIG_check_num_args("ofFileDialogResult::fileName",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFileDialogResult::fileName",1,"ofFileDialogResult *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFileDialogResult,0))){ - SWIG_fail_ptr("FileDialogResult_fileName_get",1,SWIGTYPE_p_ofFileDialogResult); } - result = (std::string *) & ((arg1)->fileName); lua_pushlstring(L,result->data(),result->size()); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FileDialogResult_bSuccess_set(lua_State* L) { int SWIG_arg = 0; - ofFileDialogResult *arg1 = (ofFileDialogResult *) 0 ; bool arg2 ; SWIG_check_num_args("ofFileDialogResult::bSuccess",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFileDialogResult::bSuccess",1,"ofFileDialogResult *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofFileDialogResult::bSuccess",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFileDialogResult,0))){ - SWIG_fail_ptr("FileDialogResult_bSuccess_set",1,SWIGTYPE_p_ofFileDialogResult); } arg2 = (lua_toboolean(L, 2)!=0); - if (arg1) (arg1)->bSuccess = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FileDialogResult_bSuccess_get(lua_State* L) { int SWIG_arg = 0; - ofFileDialogResult *arg1 = (ofFileDialogResult *) 0 ; bool result; SWIG_check_num_args("ofFileDialogResult::bSuccess",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFileDialogResult::bSuccess",1,"ofFileDialogResult *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFileDialogResult,0))){ - SWIG_fail_ptr("FileDialogResult_bSuccess_get",1,SWIGTYPE_p_ofFileDialogResult); } result = (bool) ((arg1)->bSuccess); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_FileDialogResult(void *obj) { -ofFileDialogResult *arg1 = (ofFileDialogResult *) obj; -delete arg1; -} -static int _proxy__wrap_new_FileDialogResult(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_FileDialogResult); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_FileDialogResult_attributes[] = { - { "filePath", _wrap_FileDialogResult_filePath_get, _wrap_FileDialogResult_filePath_set }, - { "fileName", _wrap_FileDialogResult_fileName_get, _wrap_FileDialogResult_fileName_set }, - { "bSuccess", _wrap_FileDialogResult_bSuccess_get, _wrap_FileDialogResult_bSuccess_set }, - {0,0,0} -}; -static swig_lua_method swig_FileDialogResult_methods[]= { - { "getName", _wrap_FileDialogResult_getName}, - { "getPath", _wrap_FileDialogResult_getPath}, - {0,0} -}; -static swig_lua_method swig_FileDialogResult_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_FileDialogResult_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_FileDialogResult_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_FileDialogResult_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_FileDialogResult_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_FileDialogResult_Sf_SwigStatic = { - "FileDialogResult", - swig_FileDialogResult_Sf_SwigStatic_methods, - swig_FileDialogResult_Sf_SwigStatic_attributes, - swig_FileDialogResult_Sf_SwigStatic_constants, - swig_FileDialogResult_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_FileDialogResult_bases[] = {0}; -static const char *swig_FileDialogResult_base_names[] = {0}; -static swig_lua_class _wrap_class_FileDialogResult = { "FileDialogResult", "FileDialogResult", &SWIGTYPE_p_ofFileDialogResult,_proxy__wrap_new_FileDialogResult, swig_delete_FileDialogResult, swig_FileDialogResult_methods, swig_FileDialogResult_attributes, &swig_FileDialogResult_Sf_SwigStatic, swig_FileDialogResult_meta, swig_FileDialogResult_bases, swig_FileDialogResult_base_names }; - -static int _wrap_systemAlertDialog(lua_State* L) { int SWIG_arg = 0; std::string arg1 ; - SWIG_check_num_args("ofSystemAlertDialog",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofSystemAlertDialog",1,"std::string"); - (&arg1)->assign(lua_tostring(L,1),lua_rawlen(L,1)); ofSystemAlertDialog(arg1); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_systemLoadDialog__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string arg1 ; bool arg2 ; std::string arg3 ; - ofFileDialogResult result; SWIG_check_num_args("ofSystemLoadDialog",3,3) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofSystemLoadDialog",1,"std::string"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofSystemLoadDialog",2,"bool"); - if(!lua_isstring(L,3)) SWIG_fail_arg("ofSystemLoadDialog",3,"std::string"); - (&arg1)->assign(lua_tostring(L,1),lua_rawlen(L,1)); arg2 = (lua_toboolean(L, 2)!=0); - (&arg3)->assign(lua_tostring(L,3),lua_rawlen(L,3)); result = ofSystemLoadDialog(arg1,arg2,arg3); { - ofFileDialogResult * resultptr = new ofFileDialogResult((const ofFileDialogResult &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofFileDialogResult,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_systemLoadDialog__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string arg1 ; bool arg2 ; - ofFileDialogResult result; SWIG_check_num_args("ofSystemLoadDialog",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofSystemLoadDialog",1,"std::string"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofSystemLoadDialog",2,"bool"); (&arg1)->assign(lua_tostring(L,1),lua_rawlen(L,1)); - arg2 = (lua_toboolean(L, 2)!=0); result = ofSystemLoadDialog(arg1,arg2); { - ofFileDialogResult * resultptr = new ofFileDialogResult((const ofFileDialogResult &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofFileDialogResult,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_systemLoadDialog__SWIG_2(lua_State* L) { int SWIG_arg = 0; std::string arg1 ; ofFileDialogResult result; - SWIG_check_num_args("ofSystemLoadDialog",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofSystemLoadDialog",1,"std::string"); - (&arg1)->assign(lua_tostring(L,1),lua_rawlen(L,1)); result = ofSystemLoadDialog(arg1); { - ofFileDialogResult * resultptr = new ofFileDialogResult((const ofFileDialogResult &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofFileDialogResult,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_systemLoadDialog__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofFileDialogResult result; - SWIG_check_num_args("ofSystemLoadDialog",0,0) result = ofSystemLoadDialog(); { - ofFileDialogResult * resultptr = new ofFileDialogResult((const ofFileDialogResult &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofFileDialogResult,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_systemLoadDialog(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_systemLoadDialog__SWIG_3(L);} if (argc == 1) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { - return _wrap_systemLoadDialog__SWIG_2(L);} } if (argc == 2) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { { - _v = lua_isboolean(L,argv[1]); } if (_v) { return _wrap_systemLoadDialog__SWIG_1(L);} } } if (argc == 3) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { { _v = lua_isstring(L,argv[2]); } - if (_v) { return _wrap_systemLoadDialog__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'systemLoadDialog'\n" " Possible C/C++ prototypes are:\n" - " ofSystemLoadDialog(std::string,bool,std::string)\n" " ofSystemLoadDialog(std::string,bool)\n" - " ofSystemLoadDialog(std::string)\n" " ofSystemLoadDialog()\n"); lua_error(L);return 0; } -static int _wrap_systemSaveDialog(lua_State* L) { int SWIG_arg = 0; std::string arg1 ; std::string arg2 ; - ofFileDialogResult result; SWIG_check_num_args("ofSystemSaveDialog",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofSystemSaveDialog",1,"std::string"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofSystemSaveDialog",2,"std::string"); - (&arg1)->assign(lua_tostring(L,1),lua_rawlen(L,1)); (&arg2)->assign(lua_tostring(L,2),lua_rawlen(L,2)); - result = ofSystemSaveDialog(arg1,arg2); { - ofFileDialogResult * resultptr = new ofFileDialogResult((const ofFileDialogResult &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofFileDialogResult,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_systemTextBoxDialog__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string arg1 ; std::string arg2 ; - std::string result; SWIG_check_num_args("ofSystemTextBoxDialog",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofSystemTextBoxDialog",1,"std::string"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofSystemTextBoxDialog",2,"std::string"); - (&arg1)->assign(lua_tostring(L,1),lua_rawlen(L,1)); (&arg2)->assign(lua_tostring(L,2),lua_rawlen(L,2)); - result = ofSystemTextBoxDialog(arg1,arg2); lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_systemTextBoxDialog__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string arg1 ; std::string result; - SWIG_check_num_args("ofSystemTextBoxDialog",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofSystemTextBoxDialog",1,"std::string"); - (&arg1)->assign(lua_tostring(L,1),lua_rawlen(L,1)); result = ofSystemTextBoxDialog(arg1); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_systemTextBoxDialog(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { return _wrap_systemTextBoxDialog__SWIG_1(L);} } if (argc == 2) { - int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { - return _wrap_systemTextBoxDialog__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'systemTextBoxDialog'\n" - " Possible C/C++ prototypes are:\n" " ofSystemTextBoxDialog(std::string,std::string)\n" - " ofSystemTextBoxDialog(std::string)\n"); lua_error(L);return 0; } -static int _wrap_new_HttpRequest__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofHttpRequest *result = 0 ; - SWIG_check_num_args("ofHttpRequest::ofHttpRequest",0,0) result = (ofHttpRequest *)new ofHttpRequest(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofHttpRequest,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_HttpRequest__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; - bool arg3 ; std::string temp1 ; std::string temp2 ; ofHttpRequest *result = 0 ; - SWIG_check_num_args("ofHttpRequest::ofHttpRequest",3,3) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofHttpRequest::ofHttpRequest",1,"std::string const &"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofHttpRequest::ofHttpRequest",2,"std::string const &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofHttpRequest::ofHttpRequest",3,"bool"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - arg3 = (lua_toboolean(L, 3)!=0); - result = (ofHttpRequest *)new ofHttpRequest((std::string const &)*arg1,(std::string const &)*arg2,arg3); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofHttpRequest,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_HttpRequest__SWIG_2(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; - std::string temp1 ; std::string temp2 ; ofHttpRequest *result = 0 ; SWIG_check_num_args("ofHttpRequest::ofHttpRequest",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofHttpRequest::ofHttpRequest",1,"std::string const &"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofHttpRequest::ofHttpRequest",2,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = (ofHttpRequest *)new ofHttpRequest((std::string const &)*arg1,(std::string const &)*arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofHttpRequest,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_HttpRequest(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_HttpRequest__SWIG_0(L);} if (argc == 2) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { { - _v = lua_isstring(L,argv[1]); } if (_v) { return _wrap_new_HttpRequest__SWIG_2(L);} } } if (argc == 3) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } - if (_v) { return _wrap_new_HttpRequest__SWIG_1(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_HttpRequest'\n" " Possible C/C++ prototypes are:\n" - " ofHttpRequest::ofHttpRequest()\n" " ofHttpRequest::ofHttpRequest(std::string const &,std::string const &,bool)\n" - " ofHttpRequest::ofHttpRequest(std::string const &,std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_HttpRequest_url_set(lua_State* L) { int SWIG_arg = 0; ofHttpRequest *arg1 = (ofHttpRequest *) 0 ; - std::string *arg2 = 0 ; std::string temp2 ; SWIG_check_num_args("ofHttpRequest::url",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofHttpRequest::url",1,"ofHttpRequest *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofHttpRequest::url",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofHttpRequest,0))){ - SWIG_fail_ptr("HttpRequest_url_set",1,SWIGTYPE_p_ofHttpRequest); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; if (arg1) (arg1)->url = *arg2; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_HttpRequest_url_get(lua_State* L) { int SWIG_arg = 0; ofHttpRequest *arg1 = (ofHttpRequest *) 0 ; - std::string *result = 0 ; SWIG_check_num_args("ofHttpRequest::url",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofHttpRequest::url",1,"ofHttpRequest *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofHttpRequest,0))){ - SWIG_fail_ptr("HttpRequest_url_get",1,SWIGTYPE_p_ofHttpRequest); } result = (std::string *) & ((arg1)->url); - lua_pushlstring(L,result->data(),result->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_HttpRequest_name_set(lua_State* L) { int SWIG_arg = 0; ofHttpRequest *arg1 = (ofHttpRequest *) 0 ; - std::string *arg2 = 0 ; std::string temp2 ; SWIG_check_num_args("ofHttpRequest::name",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofHttpRequest::name",1,"ofHttpRequest *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofHttpRequest::name",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofHttpRequest,0))){ - SWIG_fail_ptr("HttpRequest_name_set",1,SWIGTYPE_p_ofHttpRequest); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; if (arg1) (arg1)->name = *arg2; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_HttpRequest_name_get(lua_State* L) { int SWIG_arg = 0; ofHttpRequest *arg1 = (ofHttpRequest *) 0 ; - std::string *result = 0 ; SWIG_check_num_args("ofHttpRequest::name",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofHttpRequest::name",1,"ofHttpRequest *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofHttpRequest,0))){ - SWIG_fail_ptr("HttpRequest_name_get",1,SWIGTYPE_p_ofHttpRequest); } result = (std::string *) & ((arg1)->name); - lua_pushlstring(L,result->data(),result->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_HttpRequest_saveTo_set(lua_State* L) { int SWIG_arg = 0; ofHttpRequest *arg1 = (ofHttpRequest *) 0 ; - bool arg2 ; SWIG_check_num_args("ofHttpRequest::saveTo",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofHttpRequest::saveTo",1,"ofHttpRequest *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofHttpRequest::saveTo",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofHttpRequest,0))){ - SWIG_fail_ptr("HttpRequest_saveTo_set",1,SWIGTYPE_p_ofHttpRequest); } arg2 = (lua_toboolean(L, 2)!=0); - if (arg1) (arg1)->saveTo = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_HttpRequest_saveTo_get(lua_State* L) { int SWIG_arg = 0; ofHttpRequest *arg1 = (ofHttpRequest *) 0 ; - bool result; SWIG_check_num_args("ofHttpRequest::saveTo",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofHttpRequest::saveTo",1,"ofHttpRequest *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofHttpRequest,0))){ - SWIG_fail_ptr("HttpRequest_saveTo_get",1,SWIGTYPE_p_ofHttpRequest); } result = (bool) ((arg1)->saveTo); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_HttpRequest_headers_set(lua_State* L) { int SWIG_arg = 0; ofHttpRequest *arg1 = (ofHttpRequest *) 0 ; - std::map< std::string,std::string > *arg2 = (std::map< std::string,std::string > *) 0 ; - SWIG_check_num_args("ofHttpRequest::headers",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofHttpRequest::headers",1,"ofHttpRequest *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofHttpRequest::headers",2,"std::map< std::string,std::string > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofHttpRequest,0))){ - SWIG_fail_ptr("HttpRequest_headers_set",1,SWIGTYPE_p_ofHttpRequest); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__mapT_std__string_std__string_t,0))){ - SWIG_fail_ptr("HttpRequest_headers_set",2,SWIGTYPE_p_std__mapT_std__string_std__string_t); } - if (arg1) (arg1)->headers = *arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_HttpRequest_headers_get(lua_State* L) { int SWIG_arg = 0; ofHttpRequest *arg1 = (ofHttpRequest *) 0 ; - std::map< std::string,std::string > *result = 0 ; SWIG_check_num_args("ofHttpRequest::headers",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofHttpRequest::headers",1,"ofHttpRequest *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofHttpRequest,0))){ - SWIG_fail_ptr("HttpRequest_headers_get",1,SWIGTYPE_p_ofHttpRequest); } - result = (std::map< std::string,std::string > *)& ((arg1)->headers); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__mapT_std__string_std__string_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_HttpRequest_getId(lua_State* L) { int SWIG_arg = 0; ofHttpRequest *arg1 = (ofHttpRequest *) 0 ; int result; - SWIG_check_num_args("ofHttpRequest::getId",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofHttpRequest::getId",1,"ofHttpRequest const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofHttpRequest,0))){ - SWIG_fail_ptr("HttpRequest_getId",1,SWIGTYPE_p_ofHttpRequest); } result = (int)((ofHttpRequest const *)arg1)->getId(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_HttpRequest(void *obj) { -ofHttpRequest *arg1 = (ofHttpRequest *) obj; -delete arg1; -} -static int _proxy__wrap_new_HttpRequest(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_HttpRequest); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_HttpRequest_attributes[] = { - { "url", _wrap_HttpRequest_url_get, _wrap_HttpRequest_url_set }, - { "name", _wrap_HttpRequest_name_get, _wrap_HttpRequest_name_set }, - { "saveTo", _wrap_HttpRequest_saveTo_get, _wrap_HttpRequest_saveTo_set }, - { "headers", _wrap_HttpRequest_headers_get, _wrap_HttpRequest_headers_set }, - {0,0,0} -}; -static swig_lua_method swig_HttpRequest_methods[]= { - { "getId", _wrap_HttpRequest_getId}, - {0,0} -}; -static swig_lua_method swig_HttpRequest_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_HttpRequest_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_HttpRequest_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_HttpRequest_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_HttpRequest_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_HttpRequest_Sf_SwigStatic = { - "HttpRequest", - swig_HttpRequest_Sf_SwigStatic_methods, - swig_HttpRequest_Sf_SwigStatic_attributes, - swig_HttpRequest_Sf_SwigStatic_constants, - swig_HttpRequest_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_HttpRequest_bases[] = {0}; -static const char *swig_HttpRequest_base_names[] = {0}; -static swig_lua_class _wrap_class_HttpRequest = { "HttpRequest", "HttpRequest", &SWIGTYPE_p_ofHttpRequest,_proxy__wrap_new_HttpRequest, swig_delete_HttpRequest, swig_HttpRequest_methods, swig_HttpRequest_attributes, &swig_HttpRequest_Sf_SwigStatic, swig_HttpRequest_meta, swig_HttpRequest_bases, swig_HttpRequest_base_names }; - -static int _wrap_new_HttpResponse__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofHttpResponse *result = 0 ; - SWIG_check_num_args("ofHttpResponse::ofHttpResponse",0,0) result = (ofHttpResponse *)new ofHttpResponse(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofHttpResponse,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_HttpResponse__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofHttpRequest *arg1 = 0 ; ofBuffer *arg2 = 0 ; - int arg3 ; std::string *arg4 = 0 ; std::string temp4 ; ofHttpResponse *result = 0 ; - SWIG_check_num_args("ofHttpResponse::ofHttpResponse",4,4) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofHttpResponse::ofHttpResponse",1,"ofHttpRequest const &"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofHttpResponse::ofHttpResponse",2,"ofBuffer const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofHttpResponse::ofHttpResponse",3,"int"); - if(!lua_isstring(L,4)) SWIG_fail_arg("ofHttpResponse::ofHttpResponse",4,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofHttpRequest,0))){ - SWIG_fail_ptr("new_HttpResponse",1,SWIGTYPE_p_ofHttpRequest); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBuffer,0))){ - SWIG_fail_ptr("new_HttpResponse",2,SWIGTYPE_p_ofBuffer); } arg3 = (int)lua_tonumber(L, 3); - temp4.assign(lua_tostring(L,4),lua_rawlen(L,4)); arg4=&temp4; - result = (ofHttpResponse *)new ofHttpResponse((ofHttpRequest const &)*arg1,(ofBuffer const &)*arg2,arg3,(std::string const &)*arg4); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofHttpResponse,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_HttpResponse__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofHttpRequest *arg1 = 0 ; int arg2 ; - std::string *arg3 = 0 ; std::string temp3 ; ofHttpResponse *result = 0 ; - SWIG_check_num_args("ofHttpResponse::ofHttpResponse",3,3) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofHttpResponse::ofHttpResponse",1,"ofHttpRequest const &"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofHttpResponse::ofHttpResponse",2,"int"); - if(!lua_isstring(L,3)) SWIG_fail_arg("ofHttpResponse::ofHttpResponse",3,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofHttpRequest,0))){ - SWIG_fail_ptr("new_HttpResponse",1,SWIGTYPE_p_ofHttpRequest); } arg2 = (int)lua_tonumber(L, 2); - temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3; - result = (ofHttpResponse *)new ofHttpResponse((ofHttpRequest const &)*arg1,arg2,(std::string const &)*arg3); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofHttpResponse,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_HttpResponse(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_HttpResponse__SWIG_0(L);} if (argc == 3) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofHttpRequest, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isstring(L,argv[2]); } if (_v) { - return _wrap_new_HttpResponse__SWIG_2(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofHttpRequest, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBuffer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isstring(L,argv[3]); } - if (_v) { return _wrap_new_HttpResponse__SWIG_1(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_HttpResponse'\n" " Possible C/C++ prototypes are:\n" - " ofHttpResponse::ofHttpResponse()\n" - " ofHttpResponse::ofHttpResponse(ofHttpRequest const &,ofBuffer const &,int,std::string const &)\n" - " ofHttpResponse::ofHttpResponse(ofHttpRequest const &,int,std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_HttpResponse_request_set(lua_State* L) { int SWIG_arg = 0; ofHttpResponse *arg1 = (ofHttpResponse *) 0 ; - ofHttpRequest *arg2 = (ofHttpRequest *) 0 ; SWIG_check_num_args("ofHttpResponse::request",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofHttpResponse::request",1,"ofHttpResponse *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofHttpResponse::request",2,"ofHttpRequest *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofHttpResponse,0))){ - SWIG_fail_ptr("HttpResponse_request_set",1,SWIGTYPE_p_ofHttpResponse); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofHttpRequest,0))){ - SWIG_fail_ptr("HttpResponse_request_set",2,SWIGTYPE_p_ofHttpRequest); } if (arg1) (arg1)->request = *arg2; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_HttpResponse_request_get(lua_State* L) { int SWIG_arg = 0; ofHttpResponse *arg1 = (ofHttpResponse *) 0 ; - ofHttpRequest *result = 0 ; SWIG_check_num_args("ofHttpResponse::request",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofHttpResponse::request",1,"ofHttpResponse *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofHttpResponse,0))){ - SWIG_fail_ptr("HttpResponse_request_get",1,SWIGTYPE_p_ofHttpResponse); } result = (ofHttpRequest *)& ((arg1)->request); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofHttpRequest,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_HttpResponse_data_set(lua_State* L) { int SWIG_arg = 0; ofHttpResponse *arg1 = (ofHttpResponse *) 0 ; - ofBuffer *arg2 = (ofBuffer *) 0 ; SWIG_check_num_args("ofHttpResponse::data",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofHttpResponse::data",1,"ofHttpResponse *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofHttpResponse::data",2,"ofBuffer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofHttpResponse,0))){ - SWIG_fail_ptr("HttpResponse_data_set",1,SWIGTYPE_p_ofHttpResponse); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBuffer,0))){ - SWIG_fail_ptr("HttpResponse_data_set",2,SWIGTYPE_p_ofBuffer); } if (arg1) (arg1)->data = *arg2; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_HttpResponse_data_get(lua_State* L) { int SWIG_arg = 0; ofHttpResponse *arg1 = (ofHttpResponse *) 0 ; - ofBuffer *result = 0 ; SWIG_check_num_args("ofHttpResponse::data",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofHttpResponse::data",1,"ofHttpResponse *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofHttpResponse,0))){ - SWIG_fail_ptr("HttpResponse_data_get",1,SWIGTYPE_p_ofHttpResponse); } result = (ofBuffer *)& ((arg1)->data); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofBuffer,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_HttpResponse_status_set(lua_State* L) { int SWIG_arg = 0; ofHttpResponse *arg1 = (ofHttpResponse *) 0 ; - int arg2 ; SWIG_check_num_args("ofHttpResponse::status",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofHttpResponse::status",1,"ofHttpResponse *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofHttpResponse::status",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofHttpResponse,0))){ - SWIG_fail_ptr("HttpResponse_status_set",1,SWIGTYPE_p_ofHttpResponse); } arg2 = (int)lua_tonumber(L, 2); - if (arg1) (arg1)->status = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_HttpResponse_status_get(lua_State* L) { int SWIG_arg = 0; ofHttpResponse *arg1 = (ofHttpResponse *) 0 ; - int result; SWIG_check_num_args("ofHttpResponse::status",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofHttpResponse::status",1,"ofHttpResponse *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofHttpResponse,0))){ - SWIG_fail_ptr("HttpResponse_status_get",1,SWIGTYPE_p_ofHttpResponse); } result = (int) ((arg1)->status); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_HttpResponse_error_set(lua_State* L) { int SWIG_arg = 0; ofHttpResponse *arg1 = (ofHttpResponse *) 0 ; - std::string *arg2 = 0 ; std::string temp2 ; SWIG_check_num_args("ofHttpResponse::error",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofHttpResponse::error",1,"ofHttpResponse *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofHttpResponse::error",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofHttpResponse,0))){ - SWIG_fail_ptr("HttpResponse_error_set",1,SWIGTYPE_p_ofHttpResponse); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; if (arg1) (arg1)->error = *arg2; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_HttpResponse_error_get(lua_State* L) { int SWIG_arg = 0; ofHttpResponse *arg1 = (ofHttpResponse *) 0 ; - std::string *result = 0 ; SWIG_check_num_args("ofHttpResponse::error",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofHttpResponse::error",1,"ofHttpResponse *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofHttpResponse,0))){ - SWIG_fail_ptr("HttpResponse_error_get",1,SWIGTYPE_p_ofHttpResponse); } result = (std::string *) & ((arg1)->error); - lua_pushlstring(L,result->data(),result->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static void swig_delete_HttpResponse(void *obj) { -ofHttpResponse *arg1 = (ofHttpResponse *) obj; -delete arg1; -} -static int _proxy__wrap_new_HttpResponse(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_HttpResponse); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_HttpResponse_attributes[] = { - { "request", _wrap_HttpResponse_request_get, _wrap_HttpResponse_request_set }, - { "data", _wrap_HttpResponse_data_get, _wrap_HttpResponse_data_set }, - { "status", _wrap_HttpResponse_status_get, _wrap_HttpResponse_status_set }, - { "error", _wrap_HttpResponse_error_get, _wrap_HttpResponse_error_set }, - {0,0,0} -}; -static swig_lua_method swig_HttpResponse_methods[]= { - {0,0} -}; -static swig_lua_method swig_HttpResponse_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_HttpResponse_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_HttpResponse_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_HttpResponse_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_HttpResponse_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_HttpResponse_Sf_SwigStatic = { - "HttpResponse", - swig_HttpResponse_Sf_SwigStatic_methods, - swig_HttpResponse_Sf_SwigStatic_attributes, - swig_HttpResponse_Sf_SwigStatic_constants, - swig_HttpResponse_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_HttpResponse_bases[] = {0}; -static const char *swig_HttpResponse_base_names[] = {0}; -static swig_lua_class _wrap_class_HttpResponse = { "HttpResponse", "HttpResponse", &SWIGTYPE_p_ofHttpResponse,_proxy__wrap_new_HttpResponse, swig_delete_HttpResponse, swig_HttpResponse_methods, swig_HttpResponse_attributes, &swig_HttpResponse_Sf_SwigStatic, swig_HttpResponse_meta, swig_HttpResponse_bases, swig_HttpResponse_base_names }; - -static int _wrap_loadURL(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; ofHttpResponse result; - SWIG_check_num_args("ofLoadURL",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofLoadURL",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = ofLoadURL((std::string const &)*arg1); { - ofHttpResponse * resultptr = new ofHttpResponse((const ofHttpResponse &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofHttpResponse,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_loadURLAsync__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; - std::string temp1 ; std::string temp2 ; int result; SWIG_check_num_args("ofLoadURLAsync",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofLoadURLAsync",1,"std::string const &"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofLoadURLAsync",2,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = (int)ofLoadURLAsync((std::string const &)*arg1,(std::string const &)*arg2); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_loadURLAsync__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; int result; - SWIG_check_num_args("ofLoadURLAsync",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofLoadURLAsync",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = (int)ofLoadURLAsync((std::string const &)*arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_loadURLAsync(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { return _wrap_loadURLAsync__SWIG_1(L);} } if (argc == 2) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { - return _wrap_loadURLAsync__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'loadURLAsync'\n" " Possible C/C++ prototypes are:\n" - " ofLoadURLAsync(std::string const &,std::string const &)\n" " ofLoadURLAsync(std::string const &)\n"); - lua_error(L);return 0; } -static int _wrap_saveURLTo(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; std::string temp1 ; - std::string temp2 ; ofHttpResponse result; SWIG_check_num_args("ofSaveURLTo",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofSaveURLTo",1,"std::string const &"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofSaveURLTo",2,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = ofSaveURLTo((std::string const &)*arg1,(std::string const &)*arg2); { - ofHttpResponse * resultptr = new ofHttpResponse((const ofHttpResponse &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofHttpResponse,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_saveURLAsync(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; - std::string temp1 ; std::string temp2 ; int result; SWIG_check_num_args("ofSaveURLAsync",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofSaveURLAsync",1,"std::string const &"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofSaveURLAsync",2,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = (int)ofSaveURLAsync((std::string const &)*arg1,(std::string const &)*arg2); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_removeURLRequest(lua_State* L) { int SWIG_arg = 0; int arg1 ; SWIG_check_num_args("ofRemoveURLRequest",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofRemoveURLRequest",1,"int"); arg1 = (int)lua_tonumber(L, 1); ofRemoveURLRequest(arg1); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_removeAllURLRequests(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofRemoveAllURLRequests",0,0) - ofRemoveAllURLRequests(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_stopURLLoader(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofStopURLLoader",0,0) ofStopURLLoader(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_uRLResponseEvent(lua_State* L) { int SWIG_arg = 0; ofEvent< ofHttpResponse > *result = 0 ; - SWIG_check_num_args("ofURLResponseEvent",0,0) result = (ofEvent< ofHttpResponse > *) &ofURLResponseEvent(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofEventT_ofHttpResponse_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_URLFileLoader(lua_State* L) { int SWIG_arg = 0; ofURLFileLoader *result = 0 ; - SWIG_check_num_args("ofURLFileLoader::ofURLFileLoader",0,0) result = (ofURLFileLoader *)new ofURLFileLoader(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofURLFileLoader,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_URLFileLoader_get(lua_State* L) { int SWIG_arg = 0; ofURLFileLoader *arg1 = (ofURLFileLoader *) 0 ; - std::string *arg2 = 0 ; std::string temp2 ; ofHttpResponse result; SWIG_check_num_args("ofURLFileLoader::get",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofURLFileLoader::get",1,"ofURLFileLoader *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofURLFileLoader::get",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofURLFileLoader,0))){ - SWIG_fail_ptr("URLFileLoader_get",1,SWIGTYPE_p_ofURLFileLoader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; result = (arg1)->get((std::string const &)*arg2); { - ofHttpResponse * resultptr = new ofHttpResponse((const ofHttpResponse &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofHttpResponse,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_URLFileLoader_getAsync__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofURLFileLoader *arg1 = (ofURLFileLoader *) 0 ; std::string *arg2 = 0 ; std::string *arg3 = 0 ; std::string temp2 ; - std::string temp3 ; int result; SWIG_check_num_args("ofURLFileLoader::getAsync",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofURLFileLoader::getAsync",1,"ofURLFileLoader *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofURLFileLoader::getAsync",2,"std::string const &"); - if(!lua_isstring(L,3)) SWIG_fail_arg("ofURLFileLoader::getAsync",3,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofURLFileLoader,0))){ - SWIG_fail_ptr("URLFileLoader_getAsync",1,SWIGTYPE_p_ofURLFileLoader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3; - result = (int)(arg1)->getAsync((std::string const &)*arg2,(std::string const &)*arg3); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_URLFileLoader_getAsync__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofURLFileLoader *arg1 = (ofURLFileLoader *) 0 ; std::string *arg2 = 0 ; std::string temp2 ; int result; - SWIG_check_num_args("ofURLFileLoader::getAsync",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofURLFileLoader::getAsync",1,"ofURLFileLoader *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofURLFileLoader::getAsync",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofURLFileLoader,0))){ - SWIG_fail_ptr("URLFileLoader_getAsync",1,SWIGTYPE_p_ofURLFileLoader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; result = (int)(arg1)->getAsync((std::string const &)*arg2); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_URLFileLoader_getAsync(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofURLFileLoader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { - return _wrap_URLFileLoader_getAsync__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofURLFileLoader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isstring(L,argv[2]); } if (_v) { - return _wrap_URLFileLoader_getAsync__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'URLFileLoader_getAsync'\n" - " Possible C/C++ prototypes are:\n" " ofURLFileLoader::getAsync(std::string const &,std::string const &)\n" - " ofURLFileLoader::getAsync(std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_URLFileLoader_saveTo(lua_State* L) { int SWIG_arg = 0; ofURLFileLoader *arg1 = (ofURLFileLoader *) 0 ; - std::string *arg2 = 0 ; std::string *arg3 = 0 ; std::string temp2 ; std::string temp3 ; ofHttpResponse result; - SWIG_check_num_args("ofURLFileLoader::saveTo",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofURLFileLoader::saveTo",1,"ofURLFileLoader *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofURLFileLoader::saveTo",2,"std::string const &"); - if(!lua_isstring(L,3)) SWIG_fail_arg("ofURLFileLoader::saveTo",3,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofURLFileLoader,0))){ - SWIG_fail_ptr("URLFileLoader_saveTo",1,SWIGTYPE_p_ofURLFileLoader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3; - result = (arg1)->saveTo((std::string const &)*arg2,(std::string const &)*arg3); { - ofHttpResponse * resultptr = new ofHttpResponse((const ofHttpResponse &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofHttpResponse,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_URLFileLoader_saveAsync(lua_State* L) { int SWIG_arg = 0; ofURLFileLoader *arg1 = (ofURLFileLoader *) 0 ; - std::string *arg2 = 0 ; std::string *arg3 = 0 ; std::string temp2 ; std::string temp3 ; int result; - SWIG_check_num_args("ofURLFileLoader::saveAsync",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofURLFileLoader::saveAsync",1,"ofURLFileLoader *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofURLFileLoader::saveAsync",2,"std::string const &"); - if(!lua_isstring(L,3)) SWIG_fail_arg("ofURLFileLoader::saveAsync",3,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofURLFileLoader,0))){ - SWIG_fail_ptr("URLFileLoader_saveAsync",1,SWIGTYPE_p_ofURLFileLoader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3; - result = (int)(arg1)->saveAsync((std::string const &)*arg2,(std::string const &)*arg3); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_URLFileLoader_remove(lua_State* L) { int SWIG_arg = 0; ofURLFileLoader *arg1 = (ofURLFileLoader *) 0 ; - int arg2 ; SWIG_check_num_args("ofURLFileLoader::remove",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofURLFileLoader::remove",1,"ofURLFileLoader *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofURLFileLoader::remove",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofURLFileLoader,0))){ - SWIG_fail_ptr("URLFileLoader_remove",1,SWIGTYPE_p_ofURLFileLoader); } arg2 = (int)lua_tonumber(L, 2); (arg1)->remove(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_URLFileLoader_clear(lua_State* L) { int SWIG_arg = 0; ofURLFileLoader *arg1 = (ofURLFileLoader *) 0 ; - SWIG_check_num_args("ofURLFileLoader::clear",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofURLFileLoader::clear",1,"ofURLFileLoader *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofURLFileLoader,0))){ - SWIG_fail_ptr("URLFileLoader_clear",1,SWIGTYPE_p_ofURLFileLoader); } (arg1)->clear(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_URLFileLoader_stop(lua_State* L) { int SWIG_arg = 0; ofURLFileLoader *arg1 = (ofURLFileLoader *) 0 ; - SWIG_check_num_args("ofURLFileLoader::stop",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofURLFileLoader::stop",1,"ofURLFileLoader *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofURLFileLoader,0))){ - SWIG_fail_ptr("URLFileLoader_stop",1,SWIGTYPE_p_ofURLFileLoader); } (arg1)->stop(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_URLFileLoader_handleRequest(lua_State* L) { int SWIG_arg = 0; ofURLFileLoader *arg1 = (ofURLFileLoader *) 0 ; - ofHttpRequest *arg2 = 0 ; ofHttpResponse result; SWIG_check_num_args("ofURLFileLoader::handleRequest",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofURLFileLoader::handleRequest",1,"ofURLFileLoader *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofURLFileLoader::handleRequest",2,"ofHttpRequest &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofURLFileLoader,0))){ - SWIG_fail_ptr("URLFileLoader_handleRequest",1,SWIGTYPE_p_ofURLFileLoader); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofHttpRequest,0))){ - SWIG_fail_ptr("URLFileLoader_handleRequest",2,SWIGTYPE_p_ofHttpRequest); } result = (arg1)->handleRequest(*arg2); { - ofHttpResponse * resultptr = new ofHttpResponse((const ofHttpResponse &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofHttpResponse,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static void swig_delete_URLFileLoader(void *obj) { -ofURLFileLoader *arg1 = (ofURLFileLoader *) obj; -delete arg1; -} -static int _proxy__wrap_new_URLFileLoader(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_URLFileLoader); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_URLFileLoader_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_URLFileLoader_methods[]= { - { "get", _wrap_URLFileLoader_get}, - { "getAsync", _wrap_URLFileLoader_getAsync}, - { "saveTo", _wrap_URLFileLoader_saveTo}, - { "saveAsync", _wrap_URLFileLoader_saveAsync}, - { "remove", _wrap_URLFileLoader_remove}, - { "clear", _wrap_URLFileLoader_clear}, - { "stop", _wrap_URLFileLoader_stop}, - { "handleRequest", _wrap_URLFileLoader_handleRequest}, - {0,0} -}; -static swig_lua_method swig_URLFileLoader_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_URLFileLoader_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_URLFileLoader_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_URLFileLoader_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_URLFileLoader_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_URLFileLoader_Sf_SwigStatic = { - "URLFileLoader", - swig_URLFileLoader_Sf_SwigStatic_methods, - swig_URLFileLoader_Sf_SwigStatic_attributes, - swig_URLFileLoader_Sf_SwigStatic_constants, - swig_URLFileLoader_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_URLFileLoader_bases[] = {0}; -static const char *swig_URLFileLoader_base_names[] = {0}; -static swig_lua_class _wrap_class_URLFileLoader = { "URLFileLoader", "URLFileLoader", &SWIGTYPE_p_ofURLFileLoader,_proxy__wrap_new_URLFileLoader, swig_delete_URLFileLoader, swig_URLFileLoader_methods, swig_URLFileLoader_attributes, &swig_URLFileLoader_Sf_SwigStatic, swig_URLFileLoader_meta, swig_URLFileLoader_bases, swig_URLFileLoader_base_names }; - -static int _wrap_resetElapsedTimeCounter(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofResetElapsedTimeCounter",0,0) - ofResetElapsedTimeCounter(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getElapsedTimef(lua_State* L) { int SWIG_arg = 0; float result; SWIG_check_num_args("ofGetElapsedTimef",0,0) - result = (float)ofGetElapsedTimef(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_getElapsedTimeMillis(lua_State* L) { int SWIG_arg = 0; uint64_t result; - SWIG_check_num_args("ofGetElapsedTimeMillis",0,0) result = (uint64_t)ofGetElapsedTimeMillis(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getElapsedTimeMicros(lua_State* L) { int SWIG_arg = 0; uint64_t result; - SWIG_check_num_args("ofGetElapsedTimeMicros",0,0) result = (uint64_t)ofGetElapsedTimeMicros(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getSeconds(lua_State* L) { int SWIG_arg = 0; int result; SWIG_check_num_args("ofGetSeconds",0,0) - result = (int)ofGetSeconds(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_getMinutes(lua_State* L) { int SWIG_arg = 0; int result; SWIG_check_num_args("ofGetMinutes",0,0) - result = (int)ofGetMinutes(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_getHours(lua_State* L) { int SWIG_arg = 0; int result; SWIG_check_num_args("ofGetHours",0,0) - result = (int)ofGetHours(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_getUnixTime(lua_State* L) { int SWIG_arg = 0; unsigned int result; SWIG_check_num_args("ofGetUnixTime",0,0) - result = (unsigned int)ofGetUnixTime(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_getSystemTime(lua_State* L) { int SWIG_arg = 0; uint64_t result; SWIG_check_num_args("ofGetSystemTime",0,0) - result = (uint64_t)ofGetSystemTime(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_getSystemTimeMicros(lua_State* L) { int SWIG_arg = 0; uint64_t result; - SWIG_check_num_args("ofGetSystemTimeMicros",0,0) result = (uint64_t)ofGetSystemTimeMicros(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_sleepMillis(lua_State* L) { int SWIG_arg = 0; int arg1 ; SWIG_check_num_args("ofSleepMillis",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSleepMillis",1,"int"); arg1 = (int)lua_tonumber(L, 1); ofSleepMillis(arg1); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getTimestampString__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string result; - SWIG_check_num_args("ofGetTimestampString",0,0) result = ofGetTimestampString(); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_getTimestampString__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - std::string result; SWIG_check_num_args("ofGetTimestampString",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofGetTimestampString",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = ofGetTimestampString((std::string const &)*arg1); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_getTimestampString(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_getTimestampString__SWIG_0(L);} if (argc == 1) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { - return _wrap_getTimestampString__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'getTimestampString'\n" " Possible C/C++ prototypes are:\n" - " ofGetTimestampString()\n" " ofGetTimestampString(std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_getYear(lua_State* L) { int SWIG_arg = 0; int result; SWIG_check_num_args("ofGetYear",0,0) - result = (int)ofGetYear(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_getMonth(lua_State* L) { int SWIG_arg = 0; int result; SWIG_check_num_args("ofGetMonth",0,0) - result = (int)ofGetMonth(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_getDay(lua_State* L) { int SWIG_arg = 0; int result; SWIG_check_num_args("ofGetDay",0,0) - result = (int)ofGetDay(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_getWeekday(lua_State* L) { int SWIG_arg = 0; int result; SWIG_check_num_args("ofGetWeekday",0,0) - result = (int)ofGetWeekday(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_enableDataPath(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofEnableDataPath",0,0) - ofEnableDataPath(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_disableDataPath(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofDisableDataPath",0,0) - ofDisableDataPath(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_toDataPath__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; bool arg2 ; std::string temp1 ; - std::string result; SWIG_check_num_args("ofToDataPath",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofToDataPath",1,"std::string const &"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofToDataPath",2,"bool"); temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; - arg2 = (lua_toboolean(L, 2)!=0); result = ofToDataPath((std::string const &)*arg1,arg2); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_toDataPath__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - std::string result; SWIG_check_num_args("ofToDataPath",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofToDataPath",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = ofToDataPath((std::string const &)*arg1); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_toDataPath(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { return _wrap_toDataPath__SWIG_1(L);} } if (argc == 2) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_toDataPath__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'toDataPath'\n" " Possible C/C++ prototypes are:\n" - " ofToDataPath(std::string const &,bool)\n" " ofToDataPath(std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_restoreWorkingDirectoryToDefault(lua_State* L) { int SWIG_arg = 0; bool result; - SWIG_check_num_args("ofRestoreWorkingDirectoryToDefault",0,0) result = (bool)ofRestoreWorkingDirectoryToDefault(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setDataPathRoot(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - SWIG_check_num_args("ofSetDataPathRoot",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofSetDataPathRoot",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; ofSetDataPathRoot((std::string const &)*arg1); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_splitString__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; - bool arg3 ; bool arg4 ; std::string temp1 ; std::string temp2 ; std::vector< std::string > result; - SWIG_check_num_args("ofSplitString",4,4) if(!lua_isstring(L,1)) SWIG_fail_arg("ofSplitString",1,"std::string const &"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofSplitString",2,"std::string const &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofSplitString",3,"bool"); - if(!lua_isboolean(L,4)) SWIG_fail_arg("ofSplitString",4,"bool"); temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; arg3 = (lua_toboolean(L, 3)!=0); - arg4 = (lua_toboolean(L, 4)!=0); result = ofSplitString((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4); { - std::vector< std::string > * resultptr = new std::vector< std::string >((const std::vector< std::string > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_std__string_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_splitString__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; - bool arg3 ; std::string temp1 ; std::string temp2 ; std::vector< std::string > result; - SWIG_check_num_args("ofSplitString",3,3) if(!lua_isstring(L,1)) SWIG_fail_arg("ofSplitString",1,"std::string const &"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofSplitString",2,"std::string const &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofSplitString",3,"bool"); temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; arg3 = (lua_toboolean(L, 3)!=0); - result = ofSplitString((std::string const &)*arg1,(std::string const &)*arg2,arg3); { - std::vector< std::string > * resultptr = new std::vector< std::string >((const std::vector< std::string > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_std__string_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_splitString__SWIG_2(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; - std::string temp1 ; std::string temp2 ; std::vector< std::string > result; SWIG_check_num_args("ofSplitString",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofSplitString",1,"std::string const &"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofSplitString",2,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = ofSplitString((std::string const &)*arg1,(std::string const &)*arg2); { - std::vector< std::string > * resultptr = new std::vector< std::string >((const std::vector< std::string > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_std__string_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_splitString(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { int _v; - { _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { - return _wrap_splitString__SWIG_2(L);} } } if (argc == 3) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { { - _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - return _wrap_splitString__SWIG_1(L);} } } } if (argc == 4) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { - { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { { - _v = lua_isboolean(L,argv[3]); } if (_v) { return _wrap_splitString__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'splitString'\n" " Possible C/C++ prototypes are:\n" - " ofSplitString(std::string const &,std::string const &,bool,bool)\n" - " ofSplitString(std::string const &,std::string const &,bool)\n" - " ofSplitString(std::string const &,std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_joinString(lua_State* L) { int SWIG_arg = 0; std::vector< std::string > *arg1 = 0 ; std::string *arg2 = 0 ; - std::string temp2 ; std::string result; SWIG_check_num_args("ofJoinString",2,2) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofJoinString",1,"std::vector< std::string > const &"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofJoinString",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_std__string_t,0))){ - SWIG_fail_ptr("joinString",1,SWIGTYPE_p_std__vectorT_std__string_t); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = ofJoinString((std::vector< std::string > const &)*arg1,(std::string const &)*arg2); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_stringReplace(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; - std::string *arg3 = 0 ; std::string temp2 ; std::string temp3 ; SWIG_check_num_args("ofStringReplace",3,3) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofStringReplace",1,"std::string &"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofStringReplace",2,"std::string const &"); - if(!lua_isstring(L,3)) SWIG_fail_arg("ofStringReplace",3,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__string,0))){ - SWIG_fail_ptr("stringReplace",1,SWIGTYPE_p_std__string); } temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3; - ofStringReplace(*arg1,(std::string const &)*arg2,(std::string const &)*arg3); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_isStringInString(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; - std::string temp1 ; std::string temp2 ; bool result; SWIG_check_num_args("ofIsStringInString",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofIsStringInString",1,"std::string const &"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofIsStringInString",2,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = (bool)ofIsStringInString((std::string const &)*arg1,(std::string const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_stringTimesInString(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; - std::string temp1 ; std::string temp2 ; std::size_t result; SWIG_check_num_args("ofStringTimesInString",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofStringTimesInString",1,"std::string const &"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofStringTimesInString",2,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = (std::size_t)ofStringTimesInString((std::string const &)*arg1,(std::string const &)*arg2); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_toLower__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; - std::string temp1 ; std::string temp2 ; std::string result; SWIG_check_num_args("ofToLower",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofToLower",1,"std::string const &"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofToLower",2,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = ofToLower((std::string const &)*arg1,(std::string const &)*arg2); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_toLower__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - std::string result; SWIG_check_num_args("ofToLower",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofToLower",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = ofToLower((std::string const &)*arg1); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_toLower(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { return _wrap_toLower__SWIG_1(L);} } if (argc == 2) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { return _wrap_toLower__SWIG_0(L);} - } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'toLower'\n" " Possible C/C++ prototypes are:\n" - " ofToLower(std::string const &,std::string const &)\n" " ofToLower(std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_toUpper__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; - std::string temp1 ; std::string temp2 ; std::string result; SWIG_check_num_args("ofToUpper",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofToUpper",1,"std::string const &"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofToUpper",2,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = ofToUpper((std::string const &)*arg1,(std::string const &)*arg2); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_toUpper__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - std::string result; SWIG_check_num_args("ofToUpper",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofToUpper",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = ofToUpper((std::string const &)*arg1); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_toUpper(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { return _wrap_toUpper__SWIG_1(L);} } if (argc == 2) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { return _wrap_toUpper__SWIG_0(L);} - } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'toUpper'\n" " Possible C/C++ prototypes are:\n" - " ofToUpper(std::string const &,std::string const &)\n" " ofToUpper(std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_trimFront__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; - std::string temp1 ; std::string temp2 ; std::string result; SWIG_check_num_args("ofTrimFront",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofTrimFront",1,"std::string const &"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofTrimFront",2,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = ofTrimFront((std::string const &)*arg1,(std::string const &)*arg2); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_trimFront__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - std::string result; SWIG_check_num_args("ofTrimFront",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofTrimFront",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = ofTrimFront((std::string const &)*arg1); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_trimFront(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { return _wrap_trimFront__SWIG_1(L);} } if (argc == 2) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { return _wrap_trimFront__SWIG_0(L);} - } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'trimFront'\n" - " Possible C/C++ prototypes are:\n" " ofTrimFront(std::string const &,std::string const &)\n" - " ofTrimFront(std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_trimBack__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; - std::string temp1 ; std::string temp2 ; std::string result; SWIG_check_num_args("ofTrimBack",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofTrimBack",1,"std::string const &"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofTrimBack",2,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = ofTrimBack((std::string const &)*arg1,(std::string const &)*arg2); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_trimBack__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - std::string result; SWIG_check_num_args("ofTrimBack",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofTrimBack",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = ofTrimBack((std::string const &)*arg1); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_trimBack(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { return _wrap_trimBack__SWIG_1(L);} } if (argc == 2) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { return _wrap_trimBack__SWIG_0(L);} - } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'trimBack'\n" - " Possible C/C++ prototypes are:\n" " ofTrimBack(std::string const &,std::string const &)\n" - " ofTrimBack(std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_trim__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; - std::string temp1 ; std::string temp2 ; std::string result; SWIG_check_num_args("ofTrim",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofTrim",1,"std::string const &"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofTrim",2,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = ofTrim((std::string const &)*arg1,(std::string const &)*arg2); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_trim__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; std::string result; - SWIG_check_num_args("ofTrim",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofTrim",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = ofTrim((std::string const &)*arg1); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_trim(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { return _wrap_trim__SWIG_1(L);} } if (argc == 2) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { return _wrap_trim__SWIG_0(L);} } - } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'trim'\n" " Possible C/C++ prototypes are:\n" - " ofTrim(std::string const &,std::string const &)\n" " ofTrim(std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_appendUTF8(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; int arg2 ; - SWIG_check_num_args("ofAppendUTF8",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofAppendUTF8",1,"std::string &"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofAppendUTF8",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__string,0))){ - SWIG_fail_ptr("appendUTF8",1,SWIGTYPE_p_std__string); } arg2 = (int)lua_tonumber(L, 2); ofAppendUTF8(*arg1,arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_toInt(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; int result; - SWIG_check_num_args("ofToInt",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofToInt",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = (int)ofToInt((std::string const &)*arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_toInt64(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; int64_t result; - SWIG_check_num_args("ofToInt64",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofToInt64",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = (int64_t)ofToInt64((std::string const &)*arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_toFloat(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; float result; - SWIG_check_num_args("ofToFloat",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofToFloat",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = (float)ofToFloat((std::string const &)*arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_toDouble(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; double result; - SWIG_check_num_args("ofToDouble",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofToDouble",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = (double)ofToDouble((std::string const &)*arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_toBool(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; bool result; - SWIG_check_num_args("ofToBool",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofToBool",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = (bool)ofToBool((std::string const &)*arg1); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_toHex(lua_State* L) { int SWIG_arg = 0; char *arg1 = (char *) 0 ; std::string result; - SWIG_check_num_args("ofToHex",1,1) if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("ofToHex",1,"char const *"); - arg1 = (char *)lua_tostring(L, 1); result = ofToHex((char const *)arg1); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_hexToInt(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; int result; - SWIG_check_num_args("ofHexToInt",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofHexToInt",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = (int)ofHexToInt((std::string const &)*arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_hexToChar(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; char result; - SWIG_check_num_args("ofHexToChar",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofHexToChar",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = (char)ofHexToChar((std::string const &)*arg1); - lua_pushlstring(L, &result, 1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_hexToFloat(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; float result; - SWIG_check_num_args("ofHexToFloat",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofHexToFloat",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = (float)ofHexToFloat((std::string const &)*arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_hexToString(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; std::string result; - SWIG_check_num_args("ofHexToString",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofHexToString",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = ofHexToString((std::string const &)*arg1); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_toChar(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; char result; - SWIG_check_num_args("ofToChar",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofToChar",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = (char)ofToChar((std::string const &)*arg1); - lua_pushlstring(L, &result, 1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_toBinary(lua_State* L) { int SWIG_arg = 0; char *arg1 = (char *) 0 ; std::string result; - SWIG_check_num_args("ofToBinary",1,1) if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("ofToBinary",1,"char const *"); - arg1 = (char *)lua_tostring(L, 1); result = ofToBinary((char const *)arg1); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_binaryToInt(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; int result; - SWIG_check_num_args("ofBinaryToInt",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofBinaryToInt",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = (int)ofBinaryToInt((std::string const &)*arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_binaryToChar(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; char result; - SWIG_check_num_args("ofBinaryToChar",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofBinaryToChar",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = (char)ofBinaryToChar((std::string const &)*arg1); - lua_pushlstring(L, &result, 1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_binaryToFloat(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; float result; - SWIG_check_num_args("ofBinaryToFloat",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofBinaryToFloat",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = (float)ofBinaryToFloat((std::string const &)*arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_binaryToString(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - std::string result; SWIG_check_num_args("ofBinaryToString",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofBinaryToString",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = ofBinaryToString((std::string const &)*arg1); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_getVersionInfo(lua_State* L) { int SWIG_arg = 0; std::string result; - SWIG_check_num_args("ofGetVersionInfo",0,0) result = ofGetVersionInfo(); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_getVersionMajor(lua_State* L) { int SWIG_arg = 0; unsigned int result; - SWIG_check_num_args("ofGetVersionMajor",0,0) result = (unsigned int)ofGetVersionMajor(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getVersionMinor(lua_State* L) { int SWIG_arg = 0; unsigned int result; - SWIG_check_num_args("ofGetVersionMinor",0,0) result = (unsigned int)ofGetVersionMinor(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getVersionPatch(lua_State* L) { int SWIG_arg = 0; unsigned int result; - SWIG_check_num_args("ofGetVersionPatch",0,0) result = (unsigned int)ofGetVersionPatch(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getVersionPreRelease(lua_State* L) { int SWIG_arg = 0; std::string result; - SWIG_check_num_args("ofGetVersionPreRelease",0,0) result = ofGetVersionPreRelease(); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_saveScreen(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - SWIG_check_num_args("ofSaveScreen",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofSaveScreen",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; ofSaveScreen((std::string const &)*arg1); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_saveFrame__SWIG_0(lua_State* L) { int SWIG_arg = 0; bool arg1 ; SWIG_check_num_args("ofSaveFrame",1,1) - if(!lua_isboolean(L,1)) SWIG_fail_arg("ofSaveFrame",1,"bool"); arg1 = (lua_toboolean(L, 1)!=0); ofSaveFrame(arg1); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_saveFrame__SWIG_1(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofSaveFrame",0,0) ofSaveFrame(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_saveFrame(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_saveFrame__SWIG_1(L);} if (argc == 1) { int _v; { _v = lua_isboolean(L,argv[0]); } if (_v) { - return _wrap_saveFrame__SWIG_0(L);} } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'saveFrame'\n" - " Possible C/C++ prototypes are:\n" " ofSaveFrame(bool)\n" " ofSaveFrame()\n"); lua_error(L);return 0; } -static int _wrap_saveViewport(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - SWIG_check_num_args("ofSaveViewport",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofSaveViewport",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; ofSaveViewport((std::string const &)*arg1); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_launchBrowser__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; bool arg2 ; std::string temp1 ; - SWIG_check_num_args("ofLaunchBrowser",2,2) if(!lua_isstring(L,1)) SWIG_fail_arg("ofLaunchBrowser",1,"std::string const &"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofLaunchBrowser",2,"bool"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; arg2 = (lua_toboolean(L, 2)!=0); - ofLaunchBrowser((std::string const &)*arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_launchBrowser__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - SWIG_check_num_args("ofLaunchBrowser",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofLaunchBrowser",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; ofLaunchBrowser((std::string const &)*arg1); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_launchBrowser(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { return _wrap_launchBrowser__SWIG_1(L);} } if (argc == 2) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_launchBrowser__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'launchBrowser'\n" " Possible C/C++ prototypes are:\n" - " ofLaunchBrowser(std::string const &,bool)\n" " ofLaunchBrowser(std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_system(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; std::string result; - SWIG_check_num_args("ofSystem",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofSystem",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = ofSystem((std::string const &)*arg1); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_getTargetPlatform(lua_State* L) { int SWIG_arg = 0; ofTargetPlatform result; - SWIG_check_num_args("ofGetTargetPlatform",0,0) result = (ofTargetPlatform)ofGetTargetPlatform(); - lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_getEnv(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; std::string result; - SWIG_check_num_args("ofGetEnv",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofGetEnv",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = ofGetEnv((std::string const &)*arg1); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_VideoGrabber(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *result = 0 ; - SWIG_check_num_args("ofVideoGrabber::ofVideoGrabber",0,0) result = (ofVideoGrabber *)new ofVideoGrabber(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVideoGrabber,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_VideoGrabber_listDevices(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - std::vector< ofVideoDevice > result; SWIG_check_num_args("ofVideoGrabber::listDevices",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::listDevices",1,"ofVideoGrabber const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_listDevices",1,SWIGTYPE_p_ofVideoGrabber); } - result = ((ofVideoGrabber const *)arg1)->listDevices(); { - std::vector< ofVideoDevice > * resultptr = new std::vector< ofVideoDevice >((const std::vector< ofVideoDevice > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_ofVideoDevice_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoGrabber_isFrameNew(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - bool result; SWIG_check_num_args("ofVideoGrabber::isFrameNew",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::isFrameNew",1,"ofVideoGrabber const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_isFrameNew",1,SWIGTYPE_p_ofVideoGrabber); } - result = (bool)((ofVideoGrabber const *)arg1)->isFrameNew(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoGrabber_update(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - SWIG_check_num_args("ofVideoGrabber::update",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::update",1,"ofVideoGrabber *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_update",1,SWIGTYPE_p_ofVideoGrabber); } (arg1)->update(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoGrabber_close(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - SWIG_check_num_args("ofVideoGrabber::close",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::close",1,"ofVideoGrabber *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_close",1,SWIGTYPE_p_ofVideoGrabber); } (arg1)->close(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_VideoGrabber_setup__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - int arg2 ; int arg3 ; bool result; SWIG_check_num_args("ofVideoGrabber::setup",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::setup",1,"ofVideoGrabber *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVideoGrabber::setup",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVideoGrabber::setup",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_setup",1,SWIGTYPE_p_ofVideoGrabber); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); result = (bool)(arg1)->setup(arg2,arg3); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoGrabber_setup__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - int arg2 ; int arg3 ; bool arg4 ; bool result; SWIG_check_num_args("ofVideoGrabber::setup",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::setup",1,"ofVideoGrabber *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVideoGrabber::setup",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVideoGrabber::setup",3,"int"); - if(!lua_isboolean(L,4)) SWIG_fail_arg("ofVideoGrabber::setup",4,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_setup",1,SWIGTYPE_p_ofVideoGrabber); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); arg4 = (lua_toboolean(L, 4)!=0); result = (bool)(arg1)->setup(arg2,arg3,arg4); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoGrabber_setup(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVideoGrabber, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_VideoGrabber_setup__SWIG_0(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVideoGrabber, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isboolean(L,argv[3]); } if (_v) { return _wrap_VideoGrabber_setup__SWIG_1(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'VideoGrabber_setup'\n" " Possible C/C++ prototypes are:\n" - " ofVideoGrabber::setup(int,int)\n" " ofVideoGrabber::setup(int,int,bool)\n"); lua_error(L);return 0; } -static int _wrap_VideoGrabber_setPixelFormat(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - ofPixelFormat arg2 ; bool result; SWIG_check_num_args("ofVideoGrabber::setPixelFormat",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::setPixelFormat",1,"ofVideoGrabber *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVideoGrabber::setPixelFormat",2,"ofPixelFormat"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_setPixelFormat",1,SWIGTYPE_p_ofVideoGrabber); } arg2 = (ofPixelFormat)(int)lua_tonumber(L, 2); - result = (bool)(arg1)->setPixelFormat(arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoGrabber_getPixelFormat(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - ofPixelFormat result; SWIG_check_num_args("ofVideoGrabber::getPixelFormat",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::getPixelFormat",1,"ofVideoGrabber const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_getPixelFormat",1,SWIGTYPE_p_ofVideoGrabber); } - result = (ofPixelFormat)((ofVideoGrabber const *)arg1)->getPixelFormat(); - lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_VideoGrabber_videoSettings(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - SWIG_check_num_args("ofVideoGrabber::videoSettings",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::videoSettings",1,"ofVideoGrabber *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_videoSettings",1,SWIGTYPE_p_ofVideoGrabber); } (arg1)->videoSettings(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoGrabber_getPixels__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - ofPixels *result = 0 ; SWIG_check_num_args("ofVideoGrabber::getPixels",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::getPixels",1,"ofVideoGrabber *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_getPixels",1,SWIGTYPE_p_ofVideoGrabber); } result = (ofPixels *) &(arg1)->getPixels(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_VideoGrabber_getPixels__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - ofPixels *result = 0 ; SWIG_check_num_args("ofVideoGrabber::getPixels",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::getPixels",1,"ofVideoGrabber const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_getPixels",1,SWIGTYPE_p_ofVideoGrabber); } - result = (ofPixels *) &((ofVideoGrabber const *)arg1)->getPixels(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_VideoGrabber_getPixels(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVideoGrabber, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_VideoGrabber_getPixels__SWIG_0(L);} } if (argc == 1) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVideoGrabber, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_VideoGrabber_getPixels__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'VideoGrabber_getPixels'\n" - " Possible C/C++ prototypes are:\n" " ofVideoGrabber::getPixels()\n" " ofVideoGrabber::getPixels() const\n"); - lua_error(L);return 0; } -static int _wrap_VideoGrabber_getTexture__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - ofTexture *result = 0 ; SWIG_check_num_args("ofVideoGrabber::getTexture",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::getTexture",1,"ofVideoGrabber *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_getTexture",1,SWIGTYPE_p_ofVideoGrabber); } result = (ofTexture *) &(arg1)->getTexture(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTexture,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_VideoGrabber_getTexture__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - ofTexture *result = 0 ; SWIG_check_num_args("ofVideoGrabber::getTexture",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::getTexture",1,"ofVideoGrabber const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_getTexture",1,SWIGTYPE_p_ofVideoGrabber); } - result = (ofTexture *) &((ofVideoGrabber const *)arg1)->getTexture(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTexture,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_VideoGrabber_getTexture(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVideoGrabber, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_VideoGrabber_getTexture__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVideoGrabber, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_VideoGrabber_getTexture__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'VideoGrabber_getTexture'\n" - " Possible C/C++ prototypes are:\n" " ofVideoGrabber::getTexture()\n" " ofVideoGrabber::getTexture() const\n"); - lua_error(L);return 0; } -static int _wrap_VideoGrabber_getTexturePlanes__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; std::vector< ofTexture > *result = 0 ; - SWIG_check_num_args("ofVideoGrabber::getTexturePlanes",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::getTexturePlanes",1,"ofVideoGrabber *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_getTexturePlanes",1,SWIGTYPE_p_ofVideoGrabber); } - result = (std::vector< ofTexture > *) &(arg1)->getTexturePlanes(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofTexture_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_VideoGrabber_getTexturePlanes__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; std::vector< ofTexture > *result = 0 ; - SWIG_check_num_args("ofVideoGrabber::getTexturePlanes",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::getTexturePlanes",1,"ofVideoGrabber const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_getTexturePlanes",1,SWIGTYPE_p_ofVideoGrabber); } - result = (std::vector< ofTexture > *) &((ofVideoGrabber const *)arg1)->getTexturePlanes(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofTexture_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_VideoGrabber_getTexturePlanes(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); - if (argc == 1) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVideoGrabber, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_VideoGrabber_getTexturePlanes__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVideoGrabber, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_VideoGrabber_getTexturePlanes__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'VideoGrabber_getTexturePlanes'\n" - " Possible C/C++ prototypes are:\n" " ofVideoGrabber::getTexturePlanes()\n" - " ofVideoGrabber::getTexturePlanes() const\n"); lua_error(L);return 0; } -static int _wrap_VideoGrabber_setVerbose(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - bool arg2 ; SWIG_check_num_args("ofVideoGrabber::setVerbose",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::setVerbose",1,"ofVideoGrabber *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofVideoGrabber::setVerbose",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_setVerbose",1,SWIGTYPE_p_ofVideoGrabber); } arg2 = (lua_toboolean(L, 2)!=0); - (arg1)->setVerbose(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoGrabber_setDeviceID(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - int arg2 ; SWIG_check_num_args("ofVideoGrabber::setDeviceID",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::setDeviceID",1,"ofVideoGrabber *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVideoGrabber::setDeviceID",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_setDeviceID",1,SWIGTYPE_p_ofVideoGrabber); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->setDeviceID(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoGrabber_setDesiredFrameRate(lua_State* L) { int SWIG_arg = 0; - ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; int arg2 ; SWIG_check_num_args("ofVideoGrabber::setDesiredFrameRate",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::setDesiredFrameRate",1,"ofVideoGrabber *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVideoGrabber::setDesiredFrameRate",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_setDesiredFrameRate",1,SWIGTYPE_p_ofVideoGrabber); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->setDesiredFrameRate(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoGrabber_setUseTexture(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - bool arg2 ; SWIG_check_num_args("ofVideoGrabber::setUseTexture",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::setUseTexture",1,"ofVideoGrabber *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofVideoGrabber::setUseTexture",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_setUseTexture",1,SWIGTYPE_p_ofVideoGrabber); } arg2 = (lua_toboolean(L, 2)!=0); - (arg1)->setUseTexture(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoGrabber_isUsingTexture(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - bool result; SWIG_check_num_args("ofVideoGrabber::isUsingTexture",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::isUsingTexture",1,"ofVideoGrabber const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_isUsingTexture",1,SWIGTYPE_p_ofVideoGrabber); } - result = (bool)((ofVideoGrabber const *)arg1)->isUsingTexture(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoGrabber_draw__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - float arg2 ; float arg3 ; float arg4 ; float arg5 ; SWIG_check_num_args("ofVideoGrabber::draw",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::draw",1,"ofVideoGrabber const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVideoGrabber::draw",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVideoGrabber::draw",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVideoGrabber::draw",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofVideoGrabber::draw",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_draw",1,SWIGTYPE_p_ofVideoGrabber); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - ((ofVideoGrabber const *)arg1)->draw(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_VideoGrabber_draw__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - float arg2 ; float arg3 ; SWIG_check_num_args("ofVideoGrabber::draw",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::draw",1,"ofVideoGrabber const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVideoGrabber::draw",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVideoGrabber::draw",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_draw",1,SWIGTYPE_p_ofVideoGrabber); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); ((ofVideoGrabber const *)arg1)->draw(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_VideoGrabber_draw__SWIG_2_0(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - ofPoint *arg2 = 0 ; SWIG_check_num_args("draw",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("draw",1,"ofVideoGrabber const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("draw",2,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_draw",1,SWIGTYPE_p_ofVideoGrabber); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("VideoGrabber_draw",2,SWIGTYPE_p_ofVec3f); } ((ofVideoGrabber const *)arg1)->draw((ofPoint const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoGrabber_draw__SWIG_2_1(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - ofRectangle *arg2 = 0 ; SWIG_check_num_args("draw",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("draw",1,"ofVideoGrabber const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("draw",2,"ofRectangle const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_draw",1,SWIGTYPE_p_ofVideoGrabber); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("VideoGrabber_draw",2,SWIGTYPE_p_ofRectangle); } - ((ofVideoGrabber const *)arg1)->draw((ofRectangle const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_VideoGrabber_draw__SWIG_2_2(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - ofPoint *arg2 = 0 ; float arg3 ; float arg4 ; SWIG_check_num_args("draw",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("draw",1,"ofVideoGrabber const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("draw",2,"ofPoint const &"); if(!lua_isnumber(L,3)) SWIG_fail_arg("draw",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("draw",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_draw",1,SWIGTYPE_p_ofVideoGrabber); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("VideoGrabber_draw",2,SWIGTYPE_p_ofVec3f); } arg3 = (float)lua_tonumber(L, 3); - arg4 = (float)lua_tonumber(L, 4); ((ofVideoGrabber const *)arg1)->draw((ofPoint const &)*arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoGrabber_draw(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVideoGrabber, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_VideoGrabber_draw__SWIG_2_0(L);} } } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVideoGrabber, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_VideoGrabber_draw__SWIG_2_1(L);} } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVideoGrabber, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_VideoGrabber_draw__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVideoGrabber, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_VideoGrabber_draw__SWIG_2_2(L);} } } } } if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVideoGrabber, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_VideoGrabber_draw__SWIG_0(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'VideoGrabber_draw'\n" " Possible C/C++ prototypes are:\n" - " ofVideoGrabber::draw(float,float,float,float) const\n" " ofVideoGrabber::draw(float,float) const\n" - " draw(ofPoint const &) const\n" " draw(ofRectangle const &) const\n" " draw(ofPoint const &,float,float) const\n"); - lua_error(L);return 0; } -static int _wrap_VideoGrabber_bind(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - SWIG_check_num_args("ofVideoGrabber::bind",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::bind",1,"ofVideoGrabber const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_bind",1,SWIGTYPE_p_ofVideoGrabber); } ((ofVideoGrabber const *)arg1)->bind(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoGrabber_unbind(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - SWIG_check_num_args("ofVideoGrabber::unbind",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::unbind",1,"ofVideoGrabber const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_unbind",1,SWIGTYPE_p_ofVideoGrabber); } ((ofVideoGrabber const *)arg1)->unbind(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoGrabber_setAnchorPercent(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - float arg2 ; float arg3 ; SWIG_check_num_args("ofVideoGrabber::setAnchorPercent",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::setAnchorPercent",1,"ofVideoGrabber *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVideoGrabber::setAnchorPercent",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVideoGrabber::setAnchorPercent",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_setAnchorPercent",1,SWIGTYPE_p_ofVideoGrabber); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->setAnchorPercent(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_VideoGrabber_setAnchorPoint(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - float arg2 ; float arg3 ; SWIG_check_num_args("ofVideoGrabber::setAnchorPoint",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::setAnchorPoint",1,"ofVideoGrabber *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVideoGrabber::setAnchorPoint",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVideoGrabber::setAnchorPoint",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_setAnchorPoint",1,SWIGTYPE_p_ofVideoGrabber); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->setAnchorPoint(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_VideoGrabber_resetAnchor(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - SWIG_check_num_args("ofVideoGrabber::resetAnchor",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::resetAnchor",1,"ofVideoGrabber *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_resetAnchor",1,SWIGTYPE_p_ofVideoGrabber); } (arg1)->resetAnchor(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoGrabber_getHeight(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - float result; SWIG_check_num_args("ofVideoGrabber::getHeight",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::getHeight",1,"ofVideoGrabber const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_getHeight",1,SWIGTYPE_p_ofVideoGrabber); } - result = (float)((ofVideoGrabber const *)arg1)->getHeight(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoGrabber_getWidth(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - float result; SWIG_check_num_args("ofVideoGrabber::getWidth",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::getWidth",1,"ofVideoGrabber const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_getWidth",1,SWIGTYPE_p_ofVideoGrabber); } - result = (float)((ofVideoGrabber const *)arg1)->getWidth(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoGrabber_isInitialized(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - bool result; SWIG_check_num_args("ofVideoGrabber::isInitialized",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::isInitialized",1,"ofVideoGrabber const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_isInitialized",1,SWIGTYPE_p_ofVideoGrabber); } - result = (bool)((ofVideoGrabber const *)arg1)->isInitialized(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoGrabber_setGrabber(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - SwigValueWrapper< shared_ptr< ofBaseVideoGrabber > > arg2 ; shared_ptr< ofBaseVideoGrabber > *argp2 ; - SWIG_check_num_args("ofVideoGrabber::setGrabber",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::setGrabber",1,"ofVideoGrabber *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVideoGrabber::setGrabber",2,"shared_ptr< ofBaseVideoGrabber >"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_setGrabber",1,SWIGTYPE_p_ofVideoGrabber); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_shared_ptrT_ofBaseVideoGrabber_t,0))){ - SWIG_fail_ptr("VideoGrabber_setGrabber",2,SWIGTYPE_p_shared_ptrT_ofBaseVideoGrabber_t); } arg2 = *argp2; - (arg1)->setGrabber(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_VideoGrabber(void *obj) { -ofVideoGrabber *arg1 = (ofVideoGrabber *) obj; -delete arg1; -} -static int _proxy__wrap_new_VideoGrabber(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_VideoGrabber); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_VideoGrabber_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_VideoGrabber_methods[]= { - { "listDevices", _wrap_VideoGrabber_listDevices}, - { "isFrameNew", _wrap_VideoGrabber_isFrameNew}, - { "update", _wrap_VideoGrabber_update}, - { "close", _wrap_VideoGrabber_close}, - { "setup", _wrap_VideoGrabber_setup}, - { "setPixelFormat", _wrap_VideoGrabber_setPixelFormat}, - { "getPixelFormat", _wrap_VideoGrabber_getPixelFormat}, - { "videoSettings", _wrap_VideoGrabber_videoSettings}, - { "getPixels", _wrap_VideoGrabber_getPixels}, - { "getTexture", _wrap_VideoGrabber_getTexture}, - { "getTexturePlanes", _wrap_VideoGrabber_getTexturePlanes}, - { "setVerbose", _wrap_VideoGrabber_setVerbose}, - { "setDeviceID", _wrap_VideoGrabber_setDeviceID}, - { "setDesiredFrameRate", _wrap_VideoGrabber_setDesiredFrameRate}, - { "setUseTexture", _wrap_VideoGrabber_setUseTexture}, - { "isUsingTexture", _wrap_VideoGrabber_isUsingTexture}, - { "draw", _wrap_VideoGrabber_draw}, - { "bind", _wrap_VideoGrabber_bind}, - { "unbind", _wrap_VideoGrabber_unbind}, - { "setAnchorPercent", _wrap_VideoGrabber_setAnchorPercent}, - { "setAnchorPoint", _wrap_VideoGrabber_setAnchorPoint}, - { "resetAnchor", _wrap_VideoGrabber_resetAnchor}, - { "getHeight", _wrap_VideoGrabber_getHeight}, - { "getWidth", _wrap_VideoGrabber_getWidth}, - { "isInitialized", _wrap_VideoGrabber_isInitialized}, - { "setGrabber", _wrap_VideoGrabber_setGrabber}, - {0,0} -}; -static swig_lua_method swig_VideoGrabber_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_VideoGrabber_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_VideoGrabber_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_VideoGrabber_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_VideoGrabber_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_VideoGrabber_Sf_SwigStatic = { - "VideoGrabber", - swig_VideoGrabber_Sf_SwigStatic_methods, - swig_VideoGrabber_Sf_SwigStatic_attributes, - swig_VideoGrabber_Sf_SwigStatic_constants, - swig_VideoGrabber_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_VideoGrabber_bases[] = {0}; -static const char *swig_VideoGrabber_base_names[] = {0}; -static swig_lua_class _wrap_class_VideoGrabber = { "VideoGrabber", "VideoGrabber", &SWIGTYPE_p_ofVideoGrabber,_proxy__wrap_new_VideoGrabber, swig_delete_VideoGrabber, swig_VideoGrabber_methods, swig_VideoGrabber_attributes, &swig_VideoGrabber_Sf_SwigStatic, swig_VideoGrabber_meta, swig_VideoGrabber_bases, swig_VideoGrabber_base_names }; - -static int _wrap_new_VideoPlayer(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *result = 0 ; - SWIG_check_num_args("ofVideoPlayer::ofVideoPlayer",0,0) result = (ofVideoPlayer *)new ofVideoPlayer(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVideoPlayer,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_VideoPlayer_load(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - std::string arg2 ; bool result; SWIG_check_num_args("ofVideoPlayer::load",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::load",1,"ofVideoPlayer *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofVideoPlayer::load",2,"std::string"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_load",1,SWIGTYPE_p_ofVideoPlayer); } (&arg2)->assign(lua_tostring(L,2),lua_rawlen(L,2)); - result = (bool)(arg1)->load(arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_loadAsync(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - std::string arg2 ; SWIG_check_num_args("ofVideoPlayer::loadAsync",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::loadAsync",1,"ofVideoPlayer *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofVideoPlayer::loadAsync",2,"std::string"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_loadAsync",1,SWIGTYPE_p_ofVideoPlayer); } (&arg2)->assign(lua_tostring(L,2),lua_rawlen(L,2)); - (arg1)->loadAsync(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_getMoviePath(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - std::string result; SWIG_check_num_args("ofVideoPlayer::getMoviePath",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::getMoviePath",1,"ofVideoPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_getMoviePath",1,SWIGTYPE_p_ofVideoPlayer); } - result = ((ofVideoPlayer const *)arg1)->getMoviePath(); lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_setPixelFormat(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - ofPixelFormat arg2 ; bool result; SWIG_check_num_args("ofVideoPlayer::setPixelFormat",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::setPixelFormat",1,"ofVideoPlayer *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVideoPlayer::setPixelFormat",2,"ofPixelFormat"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_setPixelFormat",1,SWIGTYPE_p_ofVideoPlayer); } arg2 = (ofPixelFormat)(int)lua_tonumber(L, 2); - result = (bool)(arg1)->setPixelFormat(arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_getPixelFormat(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - ofPixelFormat result; SWIG_check_num_args("ofVideoPlayer::getPixelFormat",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::getPixelFormat",1,"ofVideoPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_getPixelFormat",1,SWIGTYPE_p_ofVideoPlayer); } - result = (ofPixelFormat)((ofVideoPlayer const *)arg1)->getPixelFormat(); - lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_VideoPlayer_closeMovie(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - SWIG_check_num_args("ofVideoPlayer::closeMovie",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::closeMovie",1,"ofVideoPlayer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_closeMovie",1,SWIGTYPE_p_ofVideoPlayer); } (arg1)->closeMovie(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_close(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - SWIG_check_num_args("ofVideoPlayer::close",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::close",1,"ofVideoPlayer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_close",1,SWIGTYPE_p_ofVideoPlayer); } (arg1)->close(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_update(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - SWIG_check_num_args("ofVideoPlayer::update",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::update",1,"ofVideoPlayer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_update",1,SWIGTYPE_p_ofVideoPlayer); } (arg1)->update(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_play(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - SWIG_check_num_args("ofVideoPlayer::play",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::play",1,"ofVideoPlayer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_play",1,SWIGTYPE_p_ofVideoPlayer); } (arg1)->play(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_stop(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - SWIG_check_num_args("ofVideoPlayer::stop",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::stop",1,"ofVideoPlayer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_stop",1,SWIGTYPE_p_ofVideoPlayer); } (arg1)->stop(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_isFrameNew(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - bool result; SWIG_check_num_args("ofVideoPlayer::isFrameNew",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::isFrameNew",1,"ofVideoPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_isFrameNew",1,SWIGTYPE_p_ofVideoPlayer); } - result = (bool)((ofVideoPlayer const *)arg1)->isFrameNew(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_getPixels__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - ofPixels *result = 0 ; SWIG_check_num_args("ofVideoPlayer::getPixels",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::getPixels",1,"ofVideoPlayer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_getPixels",1,SWIGTYPE_p_ofVideoPlayer); } result = (ofPixels *) &(arg1)->getPixels(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_getPixels__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - ofPixels *result = 0 ; SWIG_check_num_args("ofVideoPlayer::getPixels",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::getPixels",1,"ofVideoPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_getPixels",1,SWIGTYPE_p_ofVideoPlayer); } - result = (ofPixels *) &((ofVideoPlayer const *)arg1)->getPixels(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_getPixels(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVideoPlayer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_VideoPlayer_getPixels__SWIG_0(L);} } if (argc == 1) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVideoPlayer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_VideoPlayer_getPixels__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'VideoPlayer_getPixels'\n" - " Possible C/C++ prototypes are:\n" " ofVideoPlayer::getPixels()\n" " ofVideoPlayer::getPixels() const\n"); - lua_error(L);return 0; } -static int _wrap_VideoPlayer_getPosition(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - float result; SWIG_check_num_args("ofVideoPlayer::getPosition",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::getPosition",1,"ofVideoPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_getPosition",1,SWIGTYPE_p_ofVideoPlayer); } - result = (float)((ofVideoPlayer const *)arg1)->getPosition(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_getSpeed(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - float result; SWIG_check_num_args("ofVideoPlayer::getSpeed",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::getSpeed",1,"ofVideoPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_getSpeed",1,SWIGTYPE_p_ofVideoPlayer); } - result = (float)((ofVideoPlayer const *)arg1)->getSpeed(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_getDuration(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - float result; SWIG_check_num_args("ofVideoPlayer::getDuration",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::getDuration",1,"ofVideoPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_getDuration",1,SWIGTYPE_p_ofVideoPlayer); } - result = (float)((ofVideoPlayer const *)arg1)->getDuration(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_getIsMovieDone(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - bool result; SWIG_check_num_args("ofVideoPlayer::getIsMovieDone",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::getIsMovieDone",1,"ofVideoPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_getIsMovieDone",1,SWIGTYPE_p_ofVideoPlayer); } - result = (bool)((ofVideoPlayer const *)arg1)->getIsMovieDone(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_setPosition(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - float arg2 ; SWIG_check_num_args("ofVideoPlayer::setPosition",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::setPosition",1,"ofVideoPlayer *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVideoPlayer::setPosition",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_setPosition",1,SWIGTYPE_p_ofVideoPlayer); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setPosition(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_setVolume(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - float arg2 ; SWIG_check_num_args("ofVideoPlayer::setVolume",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::setVolume",1,"ofVideoPlayer *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVideoPlayer::setVolume",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_setVolume",1,SWIGTYPE_p_ofVideoPlayer); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setVolume(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_setLoopState(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - ofLoopType arg2 ; SWIG_check_num_args("ofVideoPlayer::setLoopState",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::setLoopState",1,"ofVideoPlayer *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVideoPlayer::setLoopState",2,"ofLoopType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_setLoopState",1,SWIGTYPE_p_ofVideoPlayer); } arg2 = (ofLoopType)(int)lua_tonumber(L, 2); - (arg1)->setLoopState(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_getLoopState(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - ofLoopType result; SWIG_check_num_args("ofVideoPlayer::getLoopState",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::getLoopState",1,"ofVideoPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_getLoopState",1,SWIGTYPE_p_ofVideoPlayer); } - result = (ofLoopType)((ofVideoPlayer const *)arg1)->getLoopState(); lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_setSpeed(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; float arg2 ; - SWIG_check_num_args("ofVideoPlayer::setSpeed",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::setSpeed",1,"ofVideoPlayer *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVideoPlayer::setSpeed",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_setSpeed",1,SWIGTYPE_p_ofVideoPlayer); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setSpeed(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_setFrame(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; int arg2 ; - SWIG_check_num_args("ofVideoPlayer::setFrame",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::setFrame",1,"ofVideoPlayer *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVideoPlayer::setFrame",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_setFrame",1,SWIGTYPE_p_ofVideoPlayer); } arg2 = (int)lua_tonumber(L, 2); (arg1)->setFrame(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_setUseTexture(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - bool arg2 ; SWIG_check_num_args("ofVideoPlayer::setUseTexture",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::setUseTexture",1,"ofVideoPlayer *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofVideoPlayer::setUseTexture",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_setUseTexture",1,SWIGTYPE_p_ofVideoPlayer); } arg2 = (lua_toboolean(L, 2)!=0); - (arg1)->setUseTexture(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_isUsingTexture(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - bool result; SWIG_check_num_args("ofVideoPlayer::isUsingTexture",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::isUsingTexture",1,"ofVideoPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_isUsingTexture",1,SWIGTYPE_p_ofVideoPlayer); } - result = (bool)((ofVideoPlayer const *)arg1)->isUsingTexture(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_getTexture__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - ofTexture *result = 0 ; SWIG_check_num_args("ofVideoPlayer::getTexture",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::getTexture",1,"ofVideoPlayer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_getTexture",1,SWIGTYPE_p_ofVideoPlayer); } result = (ofTexture *) &(arg1)->getTexture(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTexture,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_VideoPlayer_getTexture__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - ofTexture *result = 0 ; SWIG_check_num_args("ofVideoPlayer::getTexture",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::getTexture",1,"ofVideoPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_getTexture",1,SWIGTYPE_p_ofVideoPlayer); } - result = (ofTexture *) &((ofVideoPlayer const *)arg1)->getTexture(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTexture,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_VideoPlayer_getTexture(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVideoPlayer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_VideoPlayer_getTexture__SWIG_0(L);} } if (argc == 1) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVideoPlayer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_VideoPlayer_getTexture__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'VideoPlayer_getTexture'\n" - " Possible C/C++ prototypes are:\n" " ofVideoPlayer::getTexture()\n" " ofVideoPlayer::getTexture() const\n"); - lua_error(L);return 0; } -static int _wrap_VideoPlayer_getTexturePlanes__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; std::vector< ofTexture > *result = 0 ; - SWIG_check_num_args("ofVideoPlayer::getTexturePlanes",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::getTexturePlanes",1,"ofVideoPlayer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_getTexturePlanes",1,SWIGTYPE_p_ofVideoPlayer); } - result = (std::vector< ofTexture > *) &(arg1)->getTexturePlanes(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofTexture_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_getTexturePlanes__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; std::vector< ofTexture > *result = 0 ; - SWIG_check_num_args("ofVideoPlayer::getTexturePlanes",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::getTexturePlanes",1,"ofVideoPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_getTexturePlanes",1,SWIGTYPE_p_ofVideoPlayer); } - result = (std::vector< ofTexture > *) &((ofVideoPlayer const *)arg1)->getTexturePlanes(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofTexture_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_getTexturePlanes(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); - if (argc == 1) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVideoPlayer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_VideoPlayer_getTexturePlanes__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVideoPlayer, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_VideoPlayer_getTexturePlanes__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'VideoPlayer_getTexturePlanes'\n" - " Possible C/C++ prototypes are:\n" " ofVideoPlayer::getTexturePlanes()\n" - " ofVideoPlayer::getTexturePlanes() const\n"); lua_error(L);return 0; } -static int _wrap_VideoPlayer_draw__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - float arg2 ; float arg3 ; float arg4 ; float arg5 ; SWIG_check_num_args("ofVideoPlayer::draw",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::draw",1,"ofVideoPlayer const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVideoPlayer::draw",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVideoPlayer::draw",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVideoPlayer::draw",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofVideoPlayer::draw",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_draw",1,SWIGTYPE_p_ofVideoPlayer); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - ((ofVideoPlayer const *)arg1)->draw(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_VideoPlayer_draw__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - float arg2 ; float arg3 ; SWIG_check_num_args("ofVideoPlayer::draw",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::draw",1,"ofVideoPlayer const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVideoPlayer::draw",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVideoPlayer::draw",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_draw",1,SWIGTYPE_p_ofVideoPlayer); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); ((ofVideoPlayer const *)arg1)->draw(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_draw__SWIG_2_0(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - ofPoint *arg2 = 0 ; SWIG_check_num_args("draw",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("draw",1,"ofVideoPlayer const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("draw",2,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_draw",1,SWIGTYPE_p_ofVideoPlayer); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("VideoPlayer_draw",2,SWIGTYPE_p_ofVec3f); } ((ofVideoPlayer const *)arg1)->draw((ofPoint const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_draw__SWIG_2_1(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - ofRectangle *arg2 = 0 ; SWIG_check_num_args("draw",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("draw",1,"ofVideoPlayer const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("draw",2,"ofRectangle const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_draw",1,SWIGTYPE_p_ofVideoPlayer); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("VideoPlayer_draw",2,SWIGTYPE_p_ofRectangle); } - ((ofVideoPlayer const *)arg1)->draw((ofRectangle const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_VideoPlayer_draw__SWIG_2_2(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - ofPoint *arg2 = 0 ; float arg3 ; float arg4 ; SWIG_check_num_args("draw",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("draw",1,"ofVideoPlayer const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("draw",2,"ofPoint const &"); if(!lua_isnumber(L,3)) SWIG_fail_arg("draw",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("draw",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_draw",1,SWIGTYPE_p_ofVideoPlayer); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("VideoPlayer_draw",2,SWIGTYPE_p_ofVec3f); } arg3 = (float)lua_tonumber(L, 3); - arg4 = (float)lua_tonumber(L, 4); ((ofVideoPlayer const *)arg1)->draw((ofPoint const &)*arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_draw(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVideoPlayer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_VideoPlayer_draw__SWIG_2_0(L);} } } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVideoPlayer, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_VideoPlayer_draw__SWIG_2_1(L);} } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVideoPlayer, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_VideoPlayer_draw__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVideoPlayer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_VideoPlayer_draw__SWIG_2_2(L);} } } } } if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVideoPlayer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_VideoPlayer_draw__SWIG_0(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'VideoPlayer_draw'\n" " Possible C/C++ prototypes are:\n" - " ofVideoPlayer::draw(float,float,float,float) const\n" " ofVideoPlayer::draw(float,float) const\n" - " draw(ofPoint const &) const\n" " draw(ofRectangle const &) const\n" " draw(ofPoint const &,float,float) const\n"); - lua_error(L);return 0; } -static int _wrap_VideoPlayer_bind(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - SWIG_check_num_args("ofVideoPlayer::bind",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::bind",1,"ofVideoPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_bind",1,SWIGTYPE_p_ofVideoPlayer); } ((ofVideoPlayer const *)arg1)->bind(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_unbind(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - SWIG_check_num_args("ofVideoPlayer::unbind",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::unbind",1,"ofVideoPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_unbind",1,SWIGTYPE_p_ofVideoPlayer); } ((ofVideoPlayer const *)arg1)->unbind(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_setAnchorPercent(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - float arg2 ; float arg3 ; SWIG_check_num_args("ofVideoPlayer::setAnchorPercent",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::setAnchorPercent",1,"ofVideoPlayer *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVideoPlayer::setAnchorPercent",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVideoPlayer::setAnchorPercent",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_setAnchorPercent",1,SWIGTYPE_p_ofVideoPlayer); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->setAnchorPercent(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_VideoPlayer_setAnchorPoint(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - float arg2 ; float arg3 ; SWIG_check_num_args("ofVideoPlayer::setAnchorPoint",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::setAnchorPoint",1,"ofVideoPlayer *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVideoPlayer::setAnchorPoint",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVideoPlayer::setAnchorPoint",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_setAnchorPoint",1,SWIGTYPE_p_ofVideoPlayer); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->setAnchorPoint(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_VideoPlayer_resetAnchor(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - SWIG_check_num_args("ofVideoPlayer::resetAnchor",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::resetAnchor",1,"ofVideoPlayer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_resetAnchor",1,SWIGTYPE_p_ofVideoPlayer); } (arg1)->resetAnchor(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_setPaused(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; bool arg2 ; - SWIG_check_num_args("ofVideoPlayer::setPaused",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::setPaused",1,"ofVideoPlayer *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofVideoPlayer::setPaused",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_setPaused",1,SWIGTYPE_p_ofVideoPlayer); } arg2 = (lua_toboolean(L, 2)!=0); - (arg1)->setPaused(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_getCurrentFrame(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - int result; SWIG_check_num_args("ofVideoPlayer::getCurrentFrame",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::getCurrentFrame",1,"ofVideoPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_getCurrentFrame",1,SWIGTYPE_p_ofVideoPlayer); } - result = (int)((ofVideoPlayer const *)arg1)->getCurrentFrame(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_getTotalNumFrames(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - int result; SWIG_check_num_args("ofVideoPlayer::getTotalNumFrames",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::getTotalNumFrames",1,"ofVideoPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_getTotalNumFrames",1,SWIGTYPE_p_ofVideoPlayer); } - result = (int)((ofVideoPlayer const *)arg1)->getTotalNumFrames(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_firstFrame(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - SWIG_check_num_args("ofVideoPlayer::firstFrame",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::firstFrame",1,"ofVideoPlayer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_firstFrame",1,SWIGTYPE_p_ofVideoPlayer); } (arg1)->firstFrame(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_nextFrame(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - SWIG_check_num_args("ofVideoPlayer::nextFrame",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::nextFrame",1,"ofVideoPlayer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_nextFrame",1,SWIGTYPE_p_ofVideoPlayer); } (arg1)->nextFrame(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_previousFrame(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - SWIG_check_num_args("ofVideoPlayer::previousFrame",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::previousFrame",1,"ofVideoPlayer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_previousFrame",1,SWIGTYPE_p_ofVideoPlayer); } (arg1)->previousFrame(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_getHeight(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - float result; SWIG_check_num_args("ofVideoPlayer::getHeight",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::getHeight",1,"ofVideoPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_getHeight",1,SWIGTYPE_p_ofVideoPlayer); } - result = (float)((ofVideoPlayer const *)arg1)->getHeight(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_getWidth(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - float result; SWIG_check_num_args("ofVideoPlayer::getWidth",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::getWidth",1,"ofVideoPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_getWidth",1,SWIGTYPE_p_ofVideoPlayer); } - result = (float)((ofVideoPlayer const *)arg1)->getWidth(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_isPaused(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; bool result; - SWIG_check_num_args("ofVideoPlayer::isPaused",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::isPaused",1,"ofVideoPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_isPaused",1,SWIGTYPE_p_ofVideoPlayer); } - result = (bool)((ofVideoPlayer const *)arg1)->isPaused(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_isLoaded(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; bool result; - SWIG_check_num_args("ofVideoPlayer::isLoaded",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::isLoaded",1,"ofVideoPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_isLoaded",1,SWIGTYPE_p_ofVideoPlayer); } - result = (bool)((ofVideoPlayer const *)arg1)->isLoaded(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_isPlaying(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - bool result; SWIG_check_num_args("ofVideoPlayer::isPlaying",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::isPlaying",1,"ofVideoPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_isPlaying",1,SWIGTYPE_p_ofVideoPlayer); } - result = (bool)((ofVideoPlayer const *)arg1)->isPlaying(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_isInitialized(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - bool result; SWIG_check_num_args("ofVideoPlayer::isInitialized",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::isInitialized",1,"ofVideoPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_isInitialized",1,SWIGTYPE_p_ofVideoPlayer); } - result = (bool)((ofVideoPlayer const *)arg1)->isInitialized(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_VideoPlayer(void *obj) { -ofVideoPlayer *arg1 = (ofVideoPlayer *) obj; -delete arg1; -} -static int _proxy__wrap_new_VideoPlayer(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_VideoPlayer); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_VideoPlayer_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_VideoPlayer_methods[]= { - { "load", _wrap_VideoPlayer_load}, - { "loadAsync", _wrap_VideoPlayer_loadAsync}, - { "getMoviePath", _wrap_VideoPlayer_getMoviePath}, - { "setPixelFormat", _wrap_VideoPlayer_setPixelFormat}, - { "getPixelFormat", _wrap_VideoPlayer_getPixelFormat}, - { "closeMovie", _wrap_VideoPlayer_closeMovie}, - { "close", _wrap_VideoPlayer_close}, - { "update", _wrap_VideoPlayer_update}, - { "play", _wrap_VideoPlayer_play}, - { "stop", _wrap_VideoPlayer_stop}, - { "isFrameNew", _wrap_VideoPlayer_isFrameNew}, - { "getPixels", _wrap_VideoPlayer_getPixels}, - { "getPosition", _wrap_VideoPlayer_getPosition}, - { "getSpeed", _wrap_VideoPlayer_getSpeed}, - { "getDuration", _wrap_VideoPlayer_getDuration}, - { "getIsMovieDone", _wrap_VideoPlayer_getIsMovieDone}, - { "setPosition", _wrap_VideoPlayer_setPosition}, - { "setVolume", _wrap_VideoPlayer_setVolume}, - { "setLoopState", _wrap_VideoPlayer_setLoopState}, - { "getLoopState", _wrap_VideoPlayer_getLoopState}, - { "setSpeed", _wrap_VideoPlayer_setSpeed}, - { "setFrame", _wrap_VideoPlayer_setFrame}, - { "setUseTexture", _wrap_VideoPlayer_setUseTexture}, - { "isUsingTexture", _wrap_VideoPlayer_isUsingTexture}, - { "getTexture", _wrap_VideoPlayer_getTexture}, - { "getTexturePlanes", _wrap_VideoPlayer_getTexturePlanes}, - { "draw", _wrap_VideoPlayer_draw}, - { "bind", _wrap_VideoPlayer_bind}, - { "unbind", _wrap_VideoPlayer_unbind}, - { "setAnchorPercent", _wrap_VideoPlayer_setAnchorPercent}, - { "setAnchorPoint", _wrap_VideoPlayer_setAnchorPoint}, - { "resetAnchor", _wrap_VideoPlayer_resetAnchor}, - { "setPaused", _wrap_VideoPlayer_setPaused}, - { "getCurrentFrame", _wrap_VideoPlayer_getCurrentFrame}, - { "getTotalNumFrames", _wrap_VideoPlayer_getTotalNumFrames}, - { "firstFrame", _wrap_VideoPlayer_firstFrame}, - { "nextFrame", _wrap_VideoPlayer_nextFrame}, - { "previousFrame", _wrap_VideoPlayer_previousFrame}, - { "getHeight", _wrap_VideoPlayer_getHeight}, - { "getWidth", _wrap_VideoPlayer_getWidth}, - { "isPaused", _wrap_VideoPlayer_isPaused}, - { "isLoaded", _wrap_VideoPlayer_isLoaded}, - { "isPlaying", _wrap_VideoPlayer_isPlaying}, - { "isInitialized", _wrap_VideoPlayer_isInitialized}, - {0,0} -}; -static swig_lua_method swig_VideoPlayer_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_VideoPlayer_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_VideoPlayer_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_VideoPlayer_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_VideoPlayer_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_VideoPlayer_Sf_SwigStatic = { - "VideoPlayer", - swig_VideoPlayer_Sf_SwigStatic_methods, - swig_VideoPlayer_Sf_SwigStatic_attributes, - swig_VideoPlayer_Sf_SwigStatic_constants, - swig_VideoPlayer_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_VideoPlayer_bases[] = {0}; -static const char *swig_VideoPlayer_base_names[] = {0}; -static swig_lua_class _wrap_class_VideoPlayer = { "VideoPlayer", "VideoPlayer", &SWIGTYPE_p_ofVideoPlayer,_proxy__wrap_new_VideoPlayer, swig_delete_VideoPlayer, swig_VideoPlayer_methods, swig_VideoPlayer_attributes, &swig_VideoPlayer_Sf_SwigStatic, swig_VideoPlayer_meta, swig_VideoPlayer_bases, swig_VideoPlayer_base_names }; - -static swig_lua_attribute swig_SwigModule_attributes[] = { - { "TTF_SANS", _wrap_TTF_SANS_get, SWIG_Lua_set_immutable }, - { "TTF_SERIF", _wrap_TTF_SERIF_get, SWIG_Lua_set_immutable }, - { "TTF_MONO", _wrap_TTF_MONO_get, SWIG_Lua_set_immutable }, - { "Color_white", _wrap_Color_white_get, SWIG_Lua_set_immutable }, - { "Color_gray", _wrap_Color_gray_get, SWIG_Lua_set_immutable }, - { "Color_black", _wrap_Color_black_get, SWIG_Lua_set_immutable }, - { "Color_red", _wrap_Color_red_get, SWIG_Lua_set_immutable }, - { "Color_green", _wrap_Color_green_get, SWIG_Lua_set_immutable }, - { "Color_blue", _wrap_Color_blue_get, SWIG_Lua_set_immutable }, - { "Color_cyan", _wrap_Color_cyan_get, SWIG_Lua_set_immutable }, - { "Color_magenta", _wrap_Color_magenta_get, SWIG_Lua_set_immutable }, - { "Color_yellow", _wrap_Color_yellow_get, SWIG_Lua_set_immutable }, - { "Color_aliceBlue", _wrap_Color_aliceBlue_get, SWIG_Lua_set_immutable }, - { "Color_antiqueWhite", _wrap_Color_antiqueWhite_get, SWIG_Lua_set_immutable }, - { "Color_aqua", _wrap_Color_aqua_get, SWIG_Lua_set_immutable }, - { "Color_aquamarine", _wrap_Color_aquamarine_get, SWIG_Lua_set_immutable }, - { "Color_azure", _wrap_Color_azure_get, SWIG_Lua_set_immutable }, - { "Color_beige", _wrap_Color_beige_get, SWIG_Lua_set_immutable }, - { "Color_bisque", _wrap_Color_bisque_get, SWIG_Lua_set_immutable }, - { "Color_blanchedAlmond", _wrap_Color_blanchedAlmond_get, SWIG_Lua_set_immutable }, - { "Color_blueViolet", _wrap_Color_blueViolet_get, SWIG_Lua_set_immutable }, - { "Color_brown", _wrap_Color_brown_get, SWIG_Lua_set_immutable }, - { "Color_burlyWood", _wrap_Color_burlyWood_get, SWIG_Lua_set_immutable }, - { "Color_cadetBlue", _wrap_Color_cadetBlue_get, SWIG_Lua_set_immutable }, - { "Color_chartreuse", _wrap_Color_chartreuse_get, SWIG_Lua_set_immutable }, - { "Color_chocolate", _wrap_Color_chocolate_get, SWIG_Lua_set_immutable }, - { "Color_coral", _wrap_Color_coral_get, SWIG_Lua_set_immutable }, - { "Color_cornflowerBlue", _wrap_Color_cornflowerBlue_get, SWIG_Lua_set_immutable }, - { "Color_cornsilk", _wrap_Color_cornsilk_get, SWIG_Lua_set_immutable }, - { "Color_crimson", _wrap_Color_crimson_get, SWIG_Lua_set_immutable }, - { "Color_darkBlue", _wrap_Color_darkBlue_get, SWIG_Lua_set_immutable }, - { "Color_darkCyan", _wrap_Color_darkCyan_get, SWIG_Lua_set_immutable }, - { "Color_darkGoldenRod", _wrap_Color_darkGoldenRod_get, SWIG_Lua_set_immutable }, - { "Color_darkGray", _wrap_Color_darkGray_get, SWIG_Lua_set_immutable }, - { "Color_darkGrey", _wrap_Color_darkGrey_get, SWIG_Lua_set_immutable }, - { "Color_darkGreen", _wrap_Color_darkGreen_get, SWIG_Lua_set_immutable }, - { "Color_darkKhaki", _wrap_Color_darkKhaki_get, SWIG_Lua_set_immutable }, - { "Color_darkMagenta", _wrap_Color_darkMagenta_get, SWIG_Lua_set_immutable }, - { "Color_darkOliveGreen", _wrap_Color_darkOliveGreen_get, SWIG_Lua_set_immutable }, - { "Color_darkorange", _wrap_Color_darkorange_get, SWIG_Lua_set_immutable }, - { "Color_darkOrchid", _wrap_Color_darkOrchid_get, SWIG_Lua_set_immutable }, - { "Color_darkRed", _wrap_Color_darkRed_get, SWIG_Lua_set_immutable }, - { "Color_darkSalmon", _wrap_Color_darkSalmon_get, SWIG_Lua_set_immutable }, - { "Color_darkSeaGreen", _wrap_Color_darkSeaGreen_get, SWIG_Lua_set_immutable }, - { "Color_darkSlateBlue", _wrap_Color_darkSlateBlue_get, SWIG_Lua_set_immutable }, - { "Color_darkSlateGray", _wrap_Color_darkSlateGray_get, SWIG_Lua_set_immutable }, - { "Color_darkSlateGrey", _wrap_Color_darkSlateGrey_get, SWIG_Lua_set_immutable }, - { "Color_darkTurquoise", _wrap_Color_darkTurquoise_get, SWIG_Lua_set_immutable }, - { "Color_darkViolet", _wrap_Color_darkViolet_get, SWIG_Lua_set_immutable }, - { "Color_deepPink", _wrap_Color_deepPink_get, SWIG_Lua_set_immutable }, - { "Color_deepSkyBlue", _wrap_Color_deepSkyBlue_get, SWIG_Lua_set_immutable }, - { "Color_dimGray", _wrap_Color_dimGray_get, SWIG_Lua_set_immutable }, - { "Color_dimGrey", _wrap_Color_dimGrey_get, SWIG_Lua_set_immutable }, - { "Color_dodgerBlue", _wrap_Color_dodgerBlue_get, SWIG_Lua_set_immutable }, - { "Color_fireBrick", _wrap_Color_fireBrick_get, SWIG_Lua_set_immutable }, - { "Color_floralWhite", _wrap_Color_floralWhite_get, SWIG_Lua_set_immutable }, - { "Color_forestGreen", _wrap_Color_forestGreen_get, SWIG_Lua_set_immutable }, - { "Color_fuchsia", _wrap_Color_fuchsia_get, SWIG_Lua_set_immutable }, - { "Color_gainsboro", _wrap_Color_gainsboro_get, SWIG_Lua_set_immutable }, - { "Color_ghostWhite", _wrap_Color_ghostWhite_get, SWIG_Lua_set_immutable }, - { "Color_gold", _wrap_Color_gold_get, SWIG_Lua_set_immutable }, - { "Color_goldenRod", _wrap_Color_goldenRod_get, SWIG_Lua_set_immutable }, - { "Color_grey", _wrap_Color_grey_get, SWIG_Lua_set_immutable }, - { "Color_greenYellow", _wrap_Color_greenYellow_get, SWIG_Lua_set_immutable }, - { "Color_honeyDew", _wrap_Color_honeyDew_get, SWIG_Lua_set_immutable }, - { "Color_hotPink", _wrap_Color_hotPink_get, SWIG_Lua_set_immutable }, - { "Color_indianRed", _wrap_Color_indianRed_get, SWIG_Lua_set_immutable }, - { "Color_indigo", _wrap_Color_indigo_get, SWIG_Lua_set_immutable }, - { "Color_ivory", _wrap_Color_ivory_get, SWIG_Lua_set_immutable }, - { "Color_khaki", _wrap_Color_khaki_get, SWIG_Lua_set_immutable }, - { "Color_lavender", _wrap_Color_lavender_get, SWIG_Lua_set_immutable }, - { "Color_lavenderBlush", _wrap_Color_lavenderBlush_get, SWIG_Lua_set_immutable }, - { "Color_lawnGreen", _wrap_Color_lawnGreen_get, SWIG_Lua_set_immutable }, - { "Color_lemonChiffon", _wrap_Color_lemonChiffon_get, SWIG_Lua_set_immutable }, - { "Color_lightBlue", _wrap_Color_lightBlue_get, SWIG_Lua_set_immutable }, - { "Color_lightCoral", _wrap_Color_lightCoral_get, SWIG_Lua_set_immutable }, - { "Color_lightCyan", _wrap_Color_lightCyan_get, SWIG_Lua_set_immutable }, - { "Color_lightGoldenRodYellow", _wrap_Color_lightGoldenRodYellow_get, SWIG_Lua_set_immutable }, - { "Color_lightGray", _wrap_Color_lightGray_get, SWIG_Lua_set_immutable }, - { "Color_lightGrey", _wrap_Color_lightGrey_get, SWIG_Lua_set_immutable }, - { "Color_lightGreen", _wrap_Color_lightGreen_get, SWIG_Lua_set_immutable }, - { "Color_lightPink", _wrap_Color_lightPink_get, SWIG_Lua_set_immutable }, - { "Color_lightSalmon", _wrap_Color_lightSalmon_get, SWIG_Lua_set_immutable }, - { "Color_lightSeaGreen", _wrap_Color_lightSeaGreen_get, SWIG_Lua_set_immutable }, - { "Color_lightSkyBlue", _wrap_Color_lightSkyBlue_get, SWIG_Lua_set_immutable }, - { "Color_lightSlateGray", _wrap_Color_lightSlateGray_get, SWIG_Lua_set_immutable }, - { "Color_lightSlateGrey", _wrap_Color_lightSlateGrey_get, SWIG_Lua_set_immutable }, - { "Color_lightSteelBlue", _wrap_Color_lightSteelBlue_get, SWIG_Lua_set_immutable }, - { "Color_lightYellow", _wrap_Color_lightYellow_get, SWIG_Lua_set_immutable }, - { "Color_lime", _wrap_Color_lime_get, SWIG_Lua_set_immutable }, - { "Color_limeGreen", _wrap_Color_limeGreen_get, SWIG_Lua_set_immutable }, - { "Color_linen", _wrap_Color_linen_get, SWIG_Lua_set_immutable }, - { "Color_maroon", _wrap_Color_maroon_get, SWIG_Lua_set_immutable }, - { "Color_mediumAquaMarine", _wrap_Color_mediumAquaMarine_get, SWIG_Lua_set_immutable }, - { "Color_mediumBlue", _wrap_Color_mediumBlue_get, SWIG_Lua_set_immutable }, - { "Color_mediumOrchid", _wrap_Color_mediumOrchid_get, SWIG_Lua_set_immutable }, - { "Color_mediumPurple", _wrap_Color_mediumPurple_get, SWIG_Lua_set_immutable }, - { "Color_mediumSeaGreen", _wrap_Color_mediumSeaGreen_get, SWIG_Lua_set_immutable }, - { "Color_mediumSlateBlue", _wrap_Color_mediumSlateBlue_get, SWIG_Lua_set_immutable }, - { "Color_mediumSpringGreen", _wrap_Color_mediumSpringGreen_get, SWIG_Lua_set_immutable }, - { "Color_mediumTurquoise", _wrap_Color_mediumTurquoise_get, SWIG_Lua_set_immutable }, - { "Color_mediumVioletRed", _wrap_Color_mediumVioletRed_get, SWIG_Lua_set_immutable }, - { "Color_midnightBlue", _wrap_Color_midnightBlue_get, SWIG_Lua_set_immutable }, - { "Color_mintCream", _wrap_Color_mintCream_get, SWIG_Lua_set_immutable }, - { "Color_mistyRose", _wrap_Color_mistyRose_get, SWIG_Lua_set_immutable }, - { "Color_moccasin", _wrap_Color_moccasin_get, SWIG_Lua_set_immutable }, - { "Color_navajoWhite", _wrap_Color_navajoWhite_get, SWIG_Lua_set_immutable }, - { "Color_navy", _wrap_Color_navy_get, SWIG_Lua_set_immutable }, - { "Color_oldLace", _wrap_Color_oldLace_get, SWIG_Lua_set_immutable }, - { "Color_olive", _wrap_Color_olive_get, SWIG_Lua_set_immutable }, - { "Color_oliveDrab", _wrap_Color_oliveDrab_get, SWIG_Lua_set_immutable }, - { "Color_orange", _wrap_Color_orange_get, SWIG_Lua_set_immutable }, - { "Color_orangeRed", _wrap_Color_orangeRed_get, SWIG_Lua_set_immutable }, - { "Color_orchid", _wrap_Color_orchid_get, SWIG_Lua_set_immutable }, - { "Color_paleGoldenRod", _wrap_Color_paleGoldenRod_get, SWIG_Lua_set_immutable }, - { "Color_paleGreen", _wrap_Color_paleGreen_get, SWIG_Lua_set_immutable }, - { "Color_paleTurquoise", _wrap_Color_paleTurquoise_get, SWIG_Lua_set_immutable }, - { "Color_paleVioletRed", _wrap_Color_paleVioletRed_get, SWIG_Lua_set_immutable }, - { "Color_papayaWhip", _wrap_Color_papayaWhip_get, SWIG_Lua_set_immutable }, - { "Color_peachPuff", _wrap_Color_peachPuff_get, SWIG_Lua_set_immutable }, - { "Color_peru", _wrap_Color_peru_get, SWIG_Lua_set_immutable }, - { "Color_pink", _wrap_Color_pink_get, SWIG_Lua_set_immutable }, - { "Color_plum", _wrap_Color_plum_get, SWIG_Lua_set_immutable }, - { "Color_powderBlue", _wrap_Color_powderBlue_get, SWIG_Lua_set_immutable }, - { "Color_purple", _wrap_Color_purple_get, SWIG_Lua_set_immutable }, - { "Color_rosyBrown", _wrap_Color_rosyBrown_get, SWIG_Lua_set_immutable }, - { "Color_royalBlue", _wrap_Color_royalBlue_get, SWIG_Lua_set_immutable }, - { "Color_saddleBrown", _wrap_Color_saddleBrown_get, SWIG_Lua_set_immutable }, - { "Color_salmon", _wrap_Color_salmon_get, SWIG_Lua_set_immutable }, - { "Color_sandyBrown", _wrap_Color_sandyBrown_get, SWIG_Lua_set_immutable }, - { "Color_seaGreen", _wrap_Color_seaGreen_get, SWIG_Lua_set_immutable }, - { "Color_seaShell", _wrap_Color_seaShell_get, SWIG_Lua_set_immutable }, - { "Color_sienna", _wrap_Color_sienna_get, SWIG_Lua_set_immutable }, - { "Color_silver", _wrap_Color_silver_get, SWIG_Lua_set_immutable }, - { "Color_skyBlue", _wrap_Color_skyBlue_get, SWIG_Lua_set_immutable }, - { "Color_slateBlue", _wrap_Color_slateBlue_get, SWIG_Lua_set_immutable }, - { "Color_slateGray", _wrap_Color_slateGray_get, SWIG_Lua_set_immutable }, - { "Color_slateGrey", _wrap_Color_slateGrey_get, SWIG_Lua_set_immutable }, - { "Color_snow", _wrap_Color_snow_get, SWIG_Lua_set_immutable }, - { "Color_springGreen", _wrap_Color_springGreen_get, SWIG_Lua_set_immutable }, - { "Color_steelBlue", _wrap_Color_steelBlue_get, SWIG_Lua_set_immutable }, - { "Color_blueSteel", _wrap_Color_blueSteel_get, SWIG_Lua_set_immutable }, - { "Color_tan", _wrap_Color_tan_get, SWIG_Lua_set_immutable }, - { "Color_teal", _wrap_Color_teal_get, SWIG_Lua_set_immutable }, - { "Color_thistle", _wrap_Color_thistle_get, SWIG_Lua_set_immutable }, - { "Color_tomato", _wrap_Color_tomato_get, SWIG_Lua_set_immutable }, - { "Color_turquoise", _wrap_Color_turquoise_get, SWIG_Lua_set_immutable }, - { "Color_violet", _wrap_Color_violet_get, SWIG_Lua_set_immutable }, - { "Color_wheat", _wrap_Color_wheat_get, SWIG_Lua_set_immutable }, - { "Color_whiteSmoke", _wrap_Color_whiteSmoke_get, SWIG_Lua_set_immutable }, - { "Color_yellowGreen", _wrap_Color_yellowGreen_get, SWIG_Lua_set_immutable }, - { "FloatColor_white", _wrap_FloatColor_white_get, SWIG_Lua_set_immutable }, - { "FloatColor_gray", _wrap_FloatColor_gray_get, SWIG_Lua_set_immutable }, - { "FloatColor_black", _wrap_FloatColor_black_get, SWIG_Lua_set_immutable }, - { "FloatColor_red", _wrap_FloatColor_red_get, SWIG_Lua_set_immutable }, - { "FloatColor_green", _wrap_FloatColor_green_get, SWIG_Lua_set_immutable }, - { "FloatColor_blue", _wrap_FloatColor_blue_get, SWIG_Lua_set_immutable }, - { "FloatColor_cyan", _wrap_FloatColor_cyan_get, SWIG_Lua_set_immutable }, - { "FloatColor_magenta", _wrap_FloatColor_magenta_get, SWIG_Lua_set_immutable }, - { "FloatColor_yellow", _wrap_FloatColor_yellow_get, SWIG_Lua_set_immutable }, - { "FloatColor_aliceBlue", _wrap_FloatColor_aliceBlue_get, SWIG_Lua_set_immutable }, - { "FloatColor_antiqueWhite", _wrap_FloatColor_antiqueWhite_get, SWIG_Lua_set_immutable }, - { "FloatColor_aqua", _wrap_FloatColor_aqua_get, SWIG_Lua_set_immutable }, - { "FloatColor_aquamarine", _wrap_FloatColor_aquamarine_get, SWIG_Lua_set_immutable }, - { "FloatColor_azure", _wrap_FloatColor_azure_get, SWIG_Lua_set_immutable }, - { "FloatColor_beige", _wrap_FloatColor_beige_get, SWIG_Lua_set_immutable }, - { "FloatColor_bisque", _wrap_FloatColor_bisque_get, SWIG_Lua_set_immutable }, - { "FloatColor_blanchedAlmond", _wrap_FloatColor_blanchedAlmond_get, SWIG_Lua_set_immutable }, - { "FloatColor_blueViolet", _wrap_FloatColor_blueViolet_get, SWIG_Lua_set_immutable }, - { "FloatColor_brown", _wrap_FloatColor_brown_get, SWIG_Lua_set_immutable }, - { "FloatColor_burlyWood", _wrap_FloatColor_burlyWood_get, SWIG_Lua_set_immutable }, - { "FloatColor_cadetBlue", _wrap_FloatColor_cadetBlue_get, SWIG_Lua_set_immutable }, - { "FloatColor_chartreuse", _wrap_FloatColor_chartreuse_get, SWIG_Lua_set_immutable }, - { "FloatColor_chocolate", _wrap_FloatColor_chocolate_get, SWIG_Lua_set_immutable }, - { "FloatColor_coral", _wrap_FloatColor_coral_get, SWIG_Lua_set_immutable }, - { "FloatColor_cornflowerBlue", _wrap_FloatColor_cornflowerBlue_get, SWIG_Lua_set_immutable }, - { "FloatColor_cornsilk", _wrap_FloatColor_cornsilk_get, SWIG_Lua_set_immutable }, - { "FloatColor_crimson", _wrap_FloatColor_crimson_get, SWIG_Lua_set_immutable }, - { "FloatColor_darkBlue", _wrap_FloatColor_darkBlue_get, SWIG_Lua_set_immutable }, - { "FloatColor_darkCyan", _wrap_FloatColor_darkCyan_get, SWIG_Lua_set_immutable }, - { "FloatColor_darkGoldenRod", _wrap_FloatColor_darkGoldenRod_get, SWIG_Lua_set_immutable }, - { "FloatColor_darkGray", _wrap_FloatColor_darkGray_get, SWIG_Lua_set_immutable }, - { "FloatColor_darkGrey", _wrap_FloatColor_darkGrey_get, SWIG_Lua_set_immutable }, - { "FloatColor_darkGreen", _wrap_FloatColor_darkGreen_get, SWIG_Lua_set_immutable }, - { "FloatColor_darkKhaki", _wrap_FloatColor_darkKhaki_get, SWIG_Lua_set_immutable }, - { "FloatColor_darkMagenta", _wrap_FloatColor_darkMagenta_get, SWIG_Lua_set_immutable }, - { "FloatColor_darkOliveGreen", _wrap_FloatColor_darkOliveGreen_get, SWIG_Lua_set_immutable }, - { "FloatColor_darkorange", _wrap_FloatColor_darkorange_get, SWIG_Lua_set_immutable }, - { "FloatColor_darkOrchid", _wrap_FloatColor_darkOrchid_get, SWIG_Lua_set_immutable }, - { "FloatColor_darkRed", _wrap_FloatColor_darkRed_get, SWIG_Lua_set_immutable }, - { "FloatColor_darkSalmon", _wrap_FloatColor_darkSalmon_get, SWIG_Lua_set_immutable }, - { "FloatColor_darkSeaGreen", _wrap_FloatColor_darkSeaGreen_get, SWIG_Lua_set_immutable }, - { "FloatColor_darkSlateBlue", _wrap_FloatColor_darkSlateBlue_get, SWIG_Lua_set_immutable }, - { "FloatColor_darkSlateGray", _wrap_FloatColor_darkSlateGray_get, SWIG_Lua_set_immutable }, - { "FloatColor_darkSlateGrey", _wrap_FloatColor_darkSlateGrey_get, SWIG_Lua_set_immutable }, - { "FloatColor_darkTurquoise", _wrap_FloatColor_darkTurquoise_get, SWIG_Lua_set_immutable }, - { "FloatColor_darkViolet", _wrap_FloatColor_darkViolet_get, SWIG_Lua_set_immutable }, - { "FloatColor_deepPink", _wrap_FloatColor_deepPink_get, SWIG_Lua_set_immutable }, - { "FloatColor_deepSkyBlue", _wrap_FloatColor_deepSkyBlue_get, SWIG_Lua_set_immutable }, - { "FloatColor_dimGray", _wrap_FloatColor_dimGray_get, SWIG_Lua_set_immutable }, - { "FloatColor_dimGrey", _wrap_FloatColor_dimGrey_get, SWIG_Lua_set_immutable }, - { "FloatColor_dodgerBlue", _wrap_FloatColor_dodgerBlue_get, SWIG_Lua_set_immutable }, - { "FloatColor_fireBrick", _wrap_FloatColor_fireBrick_get, SWIG_Lua_set_immutable }, - { "FloatColor_floralWhite", _wrap_FloatColor_floralWhite_get, SWIG_Lua_set_immutable }, - { "FloatColor_forestGreen", _wrap_FloatColor_forestGreen_get, SWIG_Lua_set_immutable }, - { "FloatColor_fuchsia", _wrap_FloatColor_fuchsia_get, SWIG_Lua_set_immutable }, - { "FloatColor_gainsboro", _wrap_FloatColor_gainsboro_get, SWIG_Lua_set_immutable }, - { "FloatColor_ghostWhite", _wrap_FloatColor_ghostWhite_get, SWIG_Lua_set_immutable }, - { "FloatColor_gold", _wrap_FloatColor_gold_get, SWIG_Lua_set_immutable }, - { "FloatColor_goldenRod", _wrap_FloatColor_goldenRod_get, SWIG_Lua_set_immutable }, - { "FloatColor_grey", _wrap_FloatColor_grey_get, SWIG_Lua_set_immutable }, - { "FloatColor_greenYellow", _wrap_FloatColor_greenYellow_get, SWIG_Lua_set_immutable }, - { "FloatColor_honeyDew", _wrap_FloatColor_honeyDew_get, SWIG_Lua_set_immutable }, - { "FloatColor_hotPink", _wrap_FloatColor_hotPink_get, SWIG_Lua_set_immutable }, - { "FloatColor_indianRed", _wrap_FloatColor_indianRed_get, SWIG_Lua_set_immutable }, - { "FloatColor_indigo", _wrap_FloatColor_indigo_get, SWIG_Lua_set_immutable }, - { "FloatColor_ivory", _wrap_FloatColor_ivory_get, SWIG_Lua_set_immutable }, - { "FloatColor_khaki", _wrap_FloatColor_khaki_get, SWIG_Lua_set_immutable }, - { "FloatColor_lavender", _wrap_FloatColor_lavender_get, SWIG_Lua_set_immutable }, - { "FloatColor_lavenderBlush", _wrap_FloatColor_lavenderBlush_get, SWIG_Lua_set_immutable }, - { "FloatColor_lawnGreen", _wrap_FloatColor_lawnGreen_get, SWIG_Lua_set_immutable }, - { "FloatColor_lemonChiffon", _wrap_FloatColor_lemonChiffon_get, SWIG_Lua_set_immutable }, - { "FloatColor_lightBlue", _wrap_FloatColor_lightBlue_get, SWIG_Lua_set_immutable }, - { "FloatColor_lightCoral", _wrap_FloatColor_lightCoral_get, SWIG_Lua_set_immutable }, - { "FloatColor_lightCyan", _wrap_FloatColor_lightCyan_get, SWIG_Lua_set_immutable }, - { "FloatColor_lightGoldenRodYellow", _wrap_FloatColor_lightGoldenRodYellow_get, SWIG_Lua_set_immutable }, - { "FloatColor_lightGray", _wrap_FloatColor_lightGray_get, SWIG_Lua_set_immutable }, - { "FloatColor_lightGrey", _wrap_FloatColor_lightGrey_get, SWIG_Lua_set_immutable }, - { "FloatColor_lightGreen", _wrap_FloatColor_lightGreen_get, SWIG_Lua_set_immutable }, - { "FloatColor_lightPink", _wrap_FloatColor_lightPink_get, SWIG_Lua_set_immutable }, - { "FloatColor_lightSalmon", _wrap_FloatColor_lightSalmon_get, SWIG_Lua_set_immutable }, - { "FloatColor_lightSeaGreen", _wrap_FloatColor_lightSeaGreen_get, SWIG_Lua_set_immutable }, - { "FloatColor_lightSkyBlue", _wrap_FloatColor_lightSkyBlue_get, SWIG_Lua_set_immutable }, - { "FloatColor_lightSlateGray", _wrap_FloatColor_lightSlateGray_get, SWIG_Lua_set_immutable }, - { "FloatColor_lightSlateGrey", _wrap_FloatColor_lightSlateGrey_get, SWIG_Lua_set_immutable }, - { "FloatColor_lightSteelBlue", _wrap_FloatColor_lightSteelBlue_get, SWIG_Lua_set_immutable }, - { "FloatColor_lightYellow", _wrap_FloatColor_lightYellow_get, SWIG_Lua_set_immutable }, - { "FloatColor_lime", _wrap_FloatColor_lime_get, SWIG_Lua_set_immutable }, - { "FloatColor_limeGreen", _wrap_FloatColor_limeGreen_get, SWIG_Lua_set_immutable }, - { "FloatColor_linen", _wrap_FloatColor_linen_get, SWIG_Lua_set_immutable }, - { "FloatColor_maroon", _wrap_FloatColor_maroon_get, SWIG_Lua_set_immutable }, - { "FloatColor_mediumAquaMarine", _wrap_FloatColor_mediumAquaMarine_get, SWIG_Lua_set_immutable }, - { "FloatColor_mediumBlue", _wrap_FloatColor_mediumBlue_get, SWIG_Lua_set_immutable }, - { "FloatColor_mediumOrchid", _wrap_FloatColor_mediumOrchid_get, SWIG_Lua_set_immutable }, - { "FloatColor_mediumPurple", _wrap_FloatColor_mediumPurple_get, SWIG_Lua_set_immutable }, - { "FloatColor_mediumSeaGreen", _wrap_FloatColor_mediumSeaGreen_get, SWIG_Lua_set_immutable }, - { "FloatColor_mediumSlateBlue", _wrap_FloatColor_mediumSlateBlue_get, SWIG_Lua_set_immutable }, - { "FloatColor_mediumSpringGreen", _wrap_FloatColor_mediumSpringGreen_get, SWIG_Lua_set_immutable }, - { "FloatColor_mediumTurquoise", _wrap_FloatColor_mediumTurquoise_get, SWIG_Lua_set_immutable }, - { "FloatColor_mediumVioletRed", _wrap_FloatColor_mediumVioletRed_get, SWIG_Lua_set_immutable }, - { "FloatColor_midnightBlue", _wrap_FloatColor_midnightBlue_get, SWIG_Lua_set_immutable }, - { "FloatColor_mintCream", _wrap_FloatColor_mintCream_get, SWIG_Lua_set_immutable }, - { "FloatColor_mistyRose", _wrap_FloatColor_mistyRose_get, SWIG_Lua_set_immutable }, - { "FloatColor_moccasin", _wrap_FloatColor_moccasin_get, SWIG_Lua_set_immutable }, - { "FloatColor_navajoWhite", _wrap_FloatColor_navajoWhite_get, SWIG_Lua_set_immutable }, - { "FloatColor_navy", _wrap_FloatColor_navy_get, SWIG_Lua_set_immutable }, - { "FloatColor_oldLace", _wrap_FloatColor_oldLace_get, SWIG_Lua_set_immutable }, - { "FloatColor_olive", _wrap_FloatColor_olive_get, SWIG_Lua_set_immutable }, - { "FloatColor_oliveDrab", _wrap_FloatColor_oliveDrab_get, SWIG_Lua_set_immutable }, - { "FloatColor_orange", _wrap_FloatColor_orange_get, SWIG_Lua_set_immutable }, - { "FloatColor_orangeRed", _wrap_FloatColor_orangeRed_get, SWIG_Lua_set_immutable }, - { "FloatColor_orchid", _wrap_FloatColor_orchid_get, SWIG_Lua_set_immutable }, - { "FloatColor_paleGoldenRod", _wrap_FloatColor_paleGoldenRod_get, SWIG_Lua_set_immutable }, - { "FloatColor_paleGreen", _wrap_FloatColor_paleGreen_get, SWIG_Lua_set_immutable }, - { "FloatColor_paleTurquoise", _wrap_FloatColor_paleTurquoise_get, SWIG_Lua_set_immutable }, - { "FloatColor_paleVioletRed", _wrap_FloatColor_paleVioletRed_get, SWIG_Lua_set_immutable }, - { "FloatColor_papayaWhip", _wrap_FloatColor_papayaWhip_get, SWIG_Lua_set_immutable }, - { "FloatColor_peachPuff", _wrap_FloatColor_peachPuff_get, SWIG_Lua_set_immutable }, - { "FloatColor_peru", _wrap_FloatColor_peru_get, SWIG_Lua_set_immutable }, - { "FloatColor_pink", _wrap_FloatColor_pink_get, SWIG_Lua_set_immutable }, - { "FloatColor_plum", _wrap_FloatColor_plum_get, SWIG_Lua_set_immutable }, - { "FloatColor_powderBlue", _wrap_FloatColor_powderBlue_get, SWIG_Lua_set_immutable }, - { "FloatColor_purple", _wrap_FloatColor_purple_get, SWIG_Lua_set_immutable }, - { "FloatColor_rosyBrown", _wrap_FloatColor_rosyBrown_get, SWIG_Lua_set_immutable }, - { "FloatColor_royalBlue", _wrap_FloatColor_royalBlue_get, SWIG_Lua_set_immutable }, - { "FloatColor_saddleBrown", _wrap_FloatColor_saddleBrown_get, SWIG_Lua_set_immutable }, - { "FloatColor_salmon", _wrap_FloatColor_salmon_get, SWIG_Lua_set_immutable }, - { "FloatColor_sandyBrown", _wrap_FloatColor_sandyBrown_get, SWIG_Lua_set_immutable }, - { "FloatColor_seaGreen", _wrap_FloatColor_seaGreen_get, SWIG_Lua_set_immutable }, - { "FloatColor_seaShell", _wrap_FloatColor_seaShell_get, SWIG_Lua_set_immutable }, - { "FloatColor_sienna", _wrap_FloatColor_sienna_get, SWIG_Lua_set_immutable }, - { "FloatColor_silver", _wrap_FloatColor_silver_get, SWIG_Lua_set_immutable }, - { "FloatColor_skyBlue", _wrap_FloatColor_skyBlue_get, SWIG_Lua_set_immutable }, - { "FloatColor_slateBlue", _wrap_FloatColor_slateBlue_get, SWIG_Lua_set_immutable }, - { "FloatColor_slateGray", _wrap_FloatColor_slateGray_get, SWIG_Lua_set_immutable }, - { "FloatColor_slateGrey", _wrap_FloatColor_slateGrey_get, SWIG_Lua_set_immutable }, - { "FloatColor_snow", _wrap_FloatColor_snow_get, SWIG_Lua_set_immutable }, - { "FloatColor_springGreen", _wrap_FloatColor_springGreen_get, SWIG_Lua_set_immutable }, - { "FloatColor_steelBlue", _wrap_FloatColor_steelBlue_get, SWIG_Lua_set_immutable }, - { "FloatColor_blueSteel", _wrap_FloatColor_blueSteel_get, SWIG_Lua_set_immutable }, - { "FloatColor_tan", _wrap_FloatColor_tan_get, SWIG_Lua_set_immutable }, - { "FloatColor_teal", _wrap_FloatColor_teal_get, SWIG_Lua_set_immutable }, - { "FloatColor_thistle", _wrap_FloatColor_thistle_get, SWIG_Lua_set_immutable }, - { "FloatColor_tomato", _wrap_FloatColor_tomato_get, SWIG_Lua_set_immutable }, - { "FloatColor_turquoise", _wrap_FloatColor_turquoise_get, SWIG_Lua_set_immutable }, - { "FloatColor_violet", _wrap_FloatColor_violet_get, SWIG_Lua_set_immutable }, - { "FloatColor_wheat", _wrap_FloatColor_wheat_get, SWIG_Lua_set_immutable }, - { "FloatColor_whiteSmoke", _wrap_FloatColor_whiteSmoke_get, SWIG_Lua_set_immutable }, - { "FloatColor_yellowGreen", _wrap_FloatColor_yellowGreen_get, SWIG_Lua_set_immutable }, - { "ShortColor_white", _wrap_ShortColor_white_get, SWIG_Lua_set_immutable }, - { "ShortColor_gray", _wrap_ShortColor_gray_get, SWIG_Lua_set_immutable }, - { "ShortColor_black", _wrap_ShortColor_black_get, SWIG_Lua_set_immutable }, - { "ShortColor_red", _wrap_ShortColor_red_get, SWIG_Lua_set_immutable }, - { "ShortColor_green", _wrap_ShortColor_green_get, SWIG_Lua_set_immutable }, - { "ShortColor_blue", _wrap_ShortColor_blue_get, SWIG_Lua_set_immutable }, - { "ShortColor_cyan", _wrap_ShortColor_cyan_get, SWIG_Lua_set_immutable }, - { "ShortColor_magenta", _wrap_ShortColor_magenta_get, SWIG_Lua_set_immutable }, - { "ShortColor_yellow", _wrap_ShortColor_yellow_get, SWIG_Lua_set_immutable }, - { "ShortColor_aliceBlue", _wrap_ShortColor_aliceBlue_get, SWIG_Lua_set_immutable }, - { "ShortColor_antiqueWhite", _wrap_ShortColor_antiqueWhite_get, SWIG_Lua_set_immutable }, - { "ShortColor_aqua", _wrap_ShortColor_aqua_get, SWIG_Lua_set_immutable }, - { "ShortColor_aquamarine", _wrap_ShortColor_aquamarine_get, SWIG_Lua_set_immutable }, - { "ShortColor_azure", _wrap_ShortColor_azure_get, SWIG_Lua_set_immutable }, - { "ShortColor_beige", _wrap_ShortColor_beige_get, SWIG_Lua_set_immutable }, - { "ShortColor_bisque", _wrap_ShortColor_bisque_get, SWIG_Lua_set_immutable }, - { "ShortColor_blanchedAlmond", _wrap_ShortColor_blanchedAlmond_get, SWIG_Lua_set_immutable }, - { "ShortColor_blueViolet", _wrap_ShortColor_blueViolet_get, SWIG_Lua_set_immutable }, - { "ShortColor_brown", _wrap_ShortColor_brown_get, SWIG_Lua_set_immutable }, - { "ShortColor_burlyWood", _wrap_ShortColor_burlyWood_get, SWIG_Lua_set_immutable }, - { "ShortColor_cadetBlue", _wrap_ShortColor_cadetBlue_get, SWIG_Lua_set_immutable }, - { "ShortColor_chartreuse", _wrap_ShortColor_chartreuse_get, SWIG_Lua_set_immutable }, - { "ShortColor_chocolate", _wrap_ShortColor_chocolate_get, SWIG_Lua_set_immutable }, - { "ShortColor_coral", _wrap_ShortColor_coral_get, SWIG_Lua_set_immutable }, - { "ShortColor_cornflowerBlue", _wrap_ShortColor_cornflowerBlue_get, SWIG_Lua_set_immutable }, - { "ShortColor_cornsilk", _wrap_ShortColor_cornsilk_get, SWIG_Lua_set_immutable }, - { "ShortColor_crimson", _wrap_ShortColor_crimson_get, SWIG_Lua_set_immutable }, - { "ShortColor_darkBlue", _wrap_ShortColor_darkBlue_get, SWIG_Lua_set_immutable }, - { "ShortColor_darkCyan", _wrap_ShortColor_darkCyan_get, SWIG_Lua_set_immutable }, - { "ShortColor_darkGoldenRod", _wrap_ShortColor_darkGoldenRod_get, SWIG_Lua_set_immutable }, - { "ShortColor_darkGray", _wrap_ShortColor_darkGray_get, SWIG_Lua_set_immutable }, - { "ShortColor_darkGrey", _wrap_ShortColor_darkGrey_get, SWIG_Lua_set_immutable }, - { "ShortColor_darkGreen", _wrap_ShortColor_darkGreen_get, SWIG_Lua_set_immutable }, - { "ShortColor_darkKhaki", _wrap_ShortColor_darkKhaki_get, SWIG_Lua_set_immutable }, - { "ShortColor_darkMagenta", _wrap_ShortColor_darkMagenta_get, SWIG_Lua_set_immutable }, - { "ShortColor_darkOliveGreen", _wrap_ShortColor_darkOliveGreen_get, SWIG_Lua_set_immutable }, - { "ShortColor_darkorange", _wrap_ShortColor_darkorange_get, SWIG_Lua_set_immutable }, - { "ShortColor_darkOrchid", _wrap_ShortColor_darkOrchid_get, SWIG_Lua_set_immutable }, - { "ShortColor_darkRed", _wrap_ShortColor_darkRed_get, SWIG_Lua_set_immutable }, - { "ShortColor_darkSalmon", _wrap_ShortColor_darkSalmon_get, SWIG_Lua_set_immutable }, - { "ShortColor_darkSeaGreen", _wrap_ShortColor_darkSeaGreen_get, SWIG_Lua_set_immutable }, - { "ShortColor_darkSlateBlue", _wrap_ShortColor_darkSlateBlue_get, SWIG_Lua_set_immutable }, - { "ShortColor_darkSlateGray", _wrap_ShortColor_darkSlateGray_get, SWIG_Lua_set_immutable }, - { "ShortColor_darkSlateGrey", _wrap_ShortColor_darkSlateGrey_get, SWIG_Lua_set_immutable }, - { "ShortColor_darkTurquoise", _wrap_ShortColor_darkTurquoise_get, SWIG_Lua_set_immutable }, - { "ShortColor_darkViolet", _wrap_ShortColor_darkViolet_get, SWIG_Lua_set_immutable }, - { "ShortColor_deepPink", _wrap_ShortColor_deepPink_get, SWIG_Lua_set_immutable }, - { "ShortColor_deepSkyBlue", _wrap_ShortColor_deepSkyBlue_get, SWIG_Lua_set_immutable }, - { "ShortColor_dimGray", _wrap_ShortColor_dimGray_get, SWIG_Lua_set_immutable }, - { "ShortColor_dimGrey", _wrap_ShortColor_dimGrey_get, SWIG_Lua_set_immutable }, - { "ShortColor_dodgerBlue", _wrap_ShortColor_dodgerBlue_get, SWIG_Lua_set_immutable }, - { "ShortColor_fireBrick", _wrap_ShortColor_fireBrick_get, SWIG_Lua_set_immutable }, - { "ShortColor_floralWhite", _wrap_ShortColor_floralWhite_get, SWIG_Lua_set_immutable }, - { "ShortColor_forestGreen", _wrap_ShortColor_forestGreen_get, SWIG_Lua_set_immutable }, - { "ShortColor_fuchsia", _wrap_ShortColor_fuchsia_get, SWIG_Lua_set_immutable }, - { "ShortColor_gainsboro", _wrap_ShortColor_gainsboro_get, SWIG_Lua_set_immutable }, - { "ShortColor_ghostWhite", _wrap_ShortColor_ghostWhite_get, SWIG_Lua_set_immutable }, - { "ShortColor_gold", _wrap_ShortColor_gold_get, SWIG_Lua_set_immutable }, - { "ShortColor_goldenRod", _wrap_ShortColor_goldenRod_get, SWIG_Lua_set_immutable }, - { "ShortColor_grey", _wrap_ShortColor_grey_get, SWIG_Lua_set_immutable }, - { "ShortColor_greenYellow", _wrap_ShortColor_greenYellow_get, SWIG_Lua_set_immutable }, - { "ShortColor_honeyDew", _wrap_ShortColor_honeyDew_get, SWIG_Lua_set_immutable }, - { "ShortColor_hotPink", _wrap_ShortColor_hotPink_get, SWIG_Lua_set_immutable }, - { "ShortColor_indianRed", _wrap_ShortColor_indianRed_get, SWIG_Lua_set_immutable }, - { "ShortColor_indigo", _wrap_ShortColor_indigo_get, SWIG_Lua_set_immutable }, - { "ShortColor_ivory", _wrap_ShortColor_ivory_get, SWIG_Lua_set_immutable }, - { "ShortColor_khaki", _wrap_ShortColor_khaki_get, SWIG_Lua_set_immutable }, - { "ShortColor_lavender", _wrap_ShortColor_lavender_get, SWIG_Lua_set_immutable }, - { "ShortColor_lavenderBlush", _wrap_ShortColor_lavenderBlush_get, SWIG_Lua_set_immutable }, - { "ShortColor_lawnGreen", _wrap_ShortColor_lawnGreen_get, SWIG_Lua_set_immutable }, - { "ShortColor_lemonChiffon", _wrap_ShortColor_lemonChiffon_get, SWIG_Lua_set_immutable }, - { "ShortColor_lightBlue", _wrap_ShortColor_lightBlue_get, SWIG_Lua_set_immutable }, - { "ShortColor_lightCoral", _wrap_ShortColor_lightCoral_get, SWIG_Lua_set_immutable }, - { "ShortColor_lightCyan", _wrap_ShortColor_lightCyan_get, SWIG_Lua_set_immutable }, - { "ShortColor_lightGoldenRodYellow", _wrap_ShortColor_lightGoldenRodYellow_get, SWIG_Lua_set_immutable }, - { "ShortColor_lightGray", _wrap_ShortColor_lightGray_get, SWIG_Lua_set_immutable }, - { "ShortColor_lightGrey", _wrap_ShortColor_lightGrey_get, SWIG_Lua_set_immutable }, - { "ShortColor_lightGreen", _wrap_ShortColor_lightGreen_get, SWIG_Lua_set_immutable }, - { "ShortColor_lightPink", _wrap_ShortColor_lightPink_get, SWIG_Lua_set_immutable }, - { "ShortColor_lightSalmon", _wrap_ShortColor_lightSalmon_get, SWIG_Lua_set_immutable }, - { "ShortColor_lightSeaGreen", _wrap_ShortColor_lightSeaGreen_get, SWIG_Lua_set_immutable }, - { "ShortColor_lightSkyBlue", _wrap_ShortColor_lightSkyBlue_get, SWIG_Lua_set_immutable }, - { "ShortColor_lightSlateGray", _wrap_ShortColor_lightSlateGray_get, SWIG_Lua_set_immutable }, - { "ShortColor_lightSlateGrey", _wrap_ShortColor_lightSlateGrey_get, SWIG_Lua_set_immutable }, - { "ShortColor_lightSteelBlue", _wrap_ShortColor_lightSteelBlue_get, SWIG_Lua_set_immutable }, - { "ShortColor_lightYellow", _wrap_ShortColor_lightYellow_get, SWIG_Lua_set_immutable }, - { "ShortColor_lime", _wrap_ShortColor_lime_get, SWIG_Lua_set_immutable }, - { "ShortColor_limeGreen", _wrap_ShortColor_limeGreen_get, SWIG_Lua_set_immutable }, - { "ShortColor_linen", _wrap_ShortColor_linen_get, SWIG_Lua_set_immutable }, - { "ShortColor_maroon", _wrap_ShortColor_maroon_get, SWIG_Lua_set_immutable }, - { "ShortColor_mediumAquaMarine", _wrap_ShortColor_mediumAquaMarine_get, SWIG_Lua_set_immutable }, - { "ShortColor_mediumBlue", _wrap_ShortColor_mediumBlue_get, SWIG_Lua_set_immutable }, - { "ShortColor_mediumOrchid", _wrap_ShortColor_mediumOrchid_get, SWIG_Lua_set_immutable }, - { "ShortColor_mediumPurple", _wrap_ShortColor_mediumPurple_get, SWIG_Lua_set_immutable }, - { "ShortColor_mediumSeaGreen", _wrap_ShortColor_mediumSeaGreen_get, SWIG_Lua_set_immutable }, - { "ShortColor_mediumSlateBlue", _wrap_ShortColor_mediumSlateBlue_get, SWIG_Lua_set_immutable }, - { "ShortColor_mediumSpringGreen", _wrap_ShortColor_mediumSpringGreen_get, SWIG_Lua_set_immutable }, - { "ShortColor_mediumTurquoise", _wrap_ShortColor_mediumTurquoise_get, SWIG_Lua_set_immutable }, - { "ShortColor_mediumVioletRed", _wrap_ShortColor_mediumVioletRed_get, SWIG_Lua_set_immutable }, - { "ShortColor_midnightBlue", _wrap_ShortColor_midnightBlue_get, SWIG_Lua_set_immutable }, - { "ShortColor_mintCream", _wrap_ShortColor_mintCream_get, SWIG_Lua_set_immutable }, - { "ShortColor_mistyRose", _wrap_ShortColor_mistyRose_get, SWIG_Lua_set_immutable }, - { "ShortColor_moccasin", _wrap_ShortColor_moccasin_get, SWIG_Lua_set_immutable }, - { "ShortColor_navajoWhite", _wrap_ShortColor_navajoWhite_get, SWIG_Lua_set_immutable }, - { "ShortColor_navy", _wrap_ShortColor_navy_get, SWIG_Lua_set_immutable }, - { "ShortColor_oldLace", _wrap_ShortColor_oldLace_get, SWIG_Lua_set_immutable }, - { "ShortColor_olive", _wrap_ShortColor_olive_get, SWIG_Lua_set_immutable }, - { "ShortColor_oliveDrab", _wrap_ShortColor_oliveDrab_get, SWIG_Lua_set_immutable }, - { "ShortColor_orange", _wrap_ShortColor_orange_get, SWIG_Lua_set_immutable }, - { "ShortColor_orangeRed", _wrap_ShortColor_orangeRed_get, SWIG_Lua_set_immutable }, - { "ShortColor_orchid", _wrap_ShortColor_orchid_get, SWIG_Lua_set_immutable }, - { "ShortColor_paleGoldenRod", _wrap_ShortColor_paleGoldenRod_get, SWIG_Lua_set_immutable }, - { "ShortColor_paleGreen", _wrap_ShortColor_paleGreen_get, SWIG_Lua_set_immutable }, - { "ShortColor_paleTurquoise", _wrap_ShortColor_paleTurquoise_get, SWIG_Lua_set_immutable }, - { "ShortColor_paleVioletRed", _wrap_ShortColor_paleVioletRed_get, SWIG_Lua_set_immutable }, - { "ShortColor_papayaWhip", _wrap_ShortColor_papayaWhip_get, SWIG_Lua_set_immutable }, - { "ShortColor_peachPuff", _wrap_ShortColor_peachPuff_get, SWIG_Lua_set_immutable }, - { "ShortColor_peru", _wrap_ShortColor_peru_get, SWIG_Lua_set_immutable }, - { "ShortColor_pink", _wrap_ShortColor_pink_get, SWIG_Lua_set_immutable }, - { "ShortColor_plum", _wrap_ShortColor_plum_get, SWIG_Lua_set_immutable }, - { "ShortColor_powderBlue", _wrap_ShortColor_powderBlue_get, SWIG_Lua_set_immutable }, - { "ShortColor_purple", _wrap_ShortColor_purple_get, SWIG_Lua_set_immutable }, - { "ShortColor_rosyBrown", _wrap_ShortColor_rosyBrown_get, SWIG_Lua_set_immutable }, - { "ShortColor_royalBlue", _wrap_ShortColor_royalBlue_get, SWIG_Lua_set_immutable }, - { "ShortColor_saddleBrown", _wrap_ShortColor_saddleBrown_get, SWIG_Lua_set_immutable }, - { "ShortColor_salmon", _wrap_ShortColor_salmon_get, SWIG_Lua_set_immutable }, - { "ShortColor_sandyBrown", _wrap_ShortColor_sandyBrown_get, SWIG_Lua_set_immutable }, - { "ShortColor_seaGreen", _wrap_ShortColor_seaGreen_get, SWIG_Lua_set_immutable }, - { "ShortColor_seaShell", _wrap_ShortColor_seaShell_get, SWIG_Lua_set_immutable }, - { "ShortColor_sienna", _wrap_ShortColor_sienna_get, SWIG_Lua_set_immutable }, - { "ShortColor_silver", _wrap_ShortColor_silver_get, SWIG_Lua_set_immutable }, - { "ShortColor_skyBlue", _wrap_ShortColor_skyBlue_get, SWIG_Lua_set_immutable }, - { "ShortColor_slateBlue", _wrap_ShortColor_slateBlue_get, SWIG_Lua_set_immutable }, - { "ShortColor_slateGray", _wrap_ShortColor_slateGray_get, SWIG_Lua_set_immutable }, - { "ShortColor_slateGrey", _wrap_ShortColor_slateGrey_get, SWIG_Lua_set_immutable }, - { "ShortColor_snow", _wrap_ShortColor_snow_get, SWIG_Lua_set_immutable }, - { "ShortColor_springGreen", _wrap_ShortColor_springGreen_get, SWIG_Lua_set_immutable }, - { "ShortColor_steelBlue", _wrap_ShortColor_steelBlue_get, SWIG_Lua_set_immutable }, - { "ShortColor_blueSteel", _wrap_ShortColor_blueSteel_get, SWIG_Lua_set_immutable }, - { "ShortColor_tan", _wrap_ShortColor_tan_get, SWIG_Lua_set_immutable }, - { "ShortColor_teal", _wrap_ShortColor_teal_get, SWIG_Lua_set_immutable }, - { "ShortColor_thistle", _wrap_ShortColor_thistle_get, SWIG_Lua_set_immutable }, - { "ShortColor_tomato", _wrap_ShortColor_tomato_get, SWIG_Lua_set_immutable }, - { "ShortColor_turquoise", _wrap_ShortColor_turquoise_get, SWIG_Lua_set_immutable }, - { "ShortColor_violet", _wrap_ShortColor_violet_get, SWIG_Lua_set_immutable }, - { "ShortColor_wheat", _wrap_ShortColor_wheat_get, SWIG_Lua_set_immutable }, - { "ShortColor_whiteSmoke", _wrap_ShortColor_whiteSmoke_get, SWIG_Lua_set_immutable }, - { "ShortColor_yellowGreen", _wrap_ShortColor_yellowGreen_get, SWIG_Lua_set_immutable }, - {0,0,0} -}; -static swig_lua_const_info swig_SwigModule_constants[]= { - {SWIG_LUA_CONSTTAB_INT("VERSION_MAJOR", 0)}, - {SWIG_LUA_CONSTTAB_INT("VERSION_MINOR", 9)}, - {SWIG_LUA_CONSTTAB_INT("VERSION_PATCH", 6)}, - {SWIG_LUA_CONSTTAB_STRING("VERSION_PRE_RELEASE", "stable")}, - {SWIG_LUA_CONSTTAB_INT("LOOP_NONE", OF_LOOP_NONE)}, - {SWIG_LUA_CONSTTAB_INT("LOOP_PALINDROME", OF_LOOP_PALINDROME)}, - {SWIG_LUA_CONSTTAB_INT("LOOP_NORMAL", OF_LOOP_NORMAL)}, - {SWIG_LUA_CONSTTAB_INT("TARGET_OSX", OF_TARGET_OSX)}, - {SWIG_LUA_CONSTTAB_INT("TARGET_MINGW", OF_TARGET_MINGW)}, - {SWIG_LUA_CONSTTAB_INT("TARGET_WINVS", OF_TARGET_WINVS)}, - {SWIG_LUA_CONSTTAB_INT("TARGET_IOS", OF_TARGET_IOS)}, - {SWIG_LUA_CONSTTAB_INT("TARGET_ANDROID", OF_TARGET_ANDROID)}, - {SWIG_LUA_CONSTTAB_INT("TARGET_LINUX", OF_TARGET_LINUX)}, - {SWIG_LUA_CONSTTAB_INT("TARGET_LINUX64", OF_TARGET_LINUX64)}, - {SWIG_LUA_CONSTTAB_INT("TARGET_LINUXARMV6L", OF_TARGET_LINUXARMV6L)}, - {SWIG_LUA_CONSTTAB_INT("TARGET_LINUXARMV7L", OF_TARGET_LINUXARMV7L)}, - {SWIG_LUA_CONSTTAB_INT("TARGET_EMSCRIPTEN", OF_TARGET_EMSCRIPTEN)}, - {SWIG_LUA_CONSTTAB_INT("B14400", 14400)}, - {SWIG_LUA_CONSTTAB_INT("B28800", 28800)}, - {SWIG_LUA_CONSTTAB_INT("HAS_TLS", 1)}, - {SWIG_LUA_CONSTTAB_INT("SERIAL_NO_DATA", -2)}, - {SWIG_LUA_CONSTTAB_INT("SERIAL_ERROR", -1)}, - {SWIG_LUA_CONSTTAB_FLOAT("PI", 3.14159265358979323846)}, - {SWIG_LUA_CONSTTAB_FLOAT("TWO_PI", 6.28318530717958647693)}, - {SWIG_LUA_CONSTTAB_FLOAT("M_TWO_PI", 6.28318530717958647693)}, - {SWIG_LUA_CONSTTAB_FLOAT("FOUR_PI", 12.56637061435917295385)}, - {SWIG_LUA_CONSTTAB_FLOAT("HALF_PI", 1.57079632679489661923)}, - {SWIG_LUA_CONSTTAB_FLOAT("DEG_TO_RAD", (3.14159265358979323846/180.0))}, - {SWIG_LUA_CONSTTAB_FLOAT("RAD_TO_DEG", (180.0/3.14159265358979323846))}, - {SWIG_LUA_CONSTTAB_INT("OUTLINE", OF_OUTLINE)}, - {SWIG_LUA_CONSTTAB_INT("FILLED", OF_FILLED)}, - {SWIG_LUA_CONSTTAB_INT("WINDOW", OF_WINDOW)}, - {SWIG_LUA_CONSTTAB_INT("FULLSCREEN", OF_FULLSCREEN)}, - {SWIG_LUA_CONSTTAB_INT("GAME_MODE", OF_GAME_MODE)}, - {SWIG_LUA_CONSTTAB_INT("ASPECT_RATIO_IGNORE", OF_ASPECT_RATIO_IGNORE)}, - {SWIG_LUA_CONSTTAB_INT("ASPECT_RATIO_KEEP", OF_ASPECT_RATIO_KEEP)}, - {SWIG_LUA_CONSTTAB_INT("ASPECT_RATIO_KEEP_BY_EXPANDING", OF_ASPECT_RATIO_KEEP_BY_EXPANDING)}, - {SWIG_LUA_CONSTTAB_INT("ALIGN_VERT_IGNORE", OF_ALIGN_VERT_IGNORE)}, - {SWIG_LUA_CONSTTAB_INT("ALIGN_VERT_TOP", OF_ALIGN_VERT_TOP)}, - {SWIG_LUA_CONSTTAB_INT("ALIGN_VERT_BOTTOM", OF_ALIGN_VERT_BOTTOM)}, - {SWIG_LUA_CONSTTAB_INT("ALIGN_VERT_CENTER", OF_ALIGN_VERT_CENTER)}, - {SWIG_LUA_CONSTTAB_INT("ALIGN_HORZ_IGNORE", OF_ALIGN_HORZ_IGNORE)}, - {SWIG_LUA_CONSTTAB_INT("ALIGN_HORZ_LEFT", OF_ALIGN_HORZ_LEFT)}, - {SWIG_LUA_CONSTTAB_INT("ALIGN_HORZ_RIGHT", OF_ALIGN_HORZ_RIGHT)}, - {SWIG_LUA_CONSTTAB_INT("ALIGN_HORZ_CENTER", OF_ALIGN_HORZ_CENTER)}, - {SWIG_LUA_CONSTTAB_INT("RECTMODE_CORNER", OF_RECTMODE_CORNER)}, - {SWIG_LUA_CONSTTAB_INT("RECTMODE_CENTER", OF_RECTMODE_CENTER)}, - {SWIG_LUA_CONSTTAB_INT("SCALEMODE_FIT", OF_SCALEMODE_FIT)}, - {SWIG_LUA_CONSTTAB_INT("SCALEMODE_FILL", OF_SCALEMODE_FILL)}, - {SWIG_LUA_CONSTTAB_INT("SCALEMODE_CENTER", OF_SCALEMODE_CENTER)}, - {SWIG_LUA_CONSTTAB_INT("SCALEMODE_STRETCH_TO_FILL", OF_SCALEMODE_STRETCH_TO_FILL)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_GRAYSCALE", OF_IMAGE_GRAYSCALE)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_COLOR", OF_IMAGE_COLOR)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_COLOR_ALPHA", OF_IMAGE_COLOR_ALPHA)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_UNDEFINED", OF_IMAGE_UNDEFINED)}, - {SWIG_LUA_CONSTTAB_INT("MAX_STYLE_HISTORY", 32)}, - {SWIG_LUA_CONSTTAB_INT("MAX_VIEWPORT_HISTORY", 32)}, - {SWIG_LUA_CONSTTAB_INT("MAX_CIRCLE_PTS", 1024)}, - {SWIG_LUA_CONSTTAB_INT("BLENDMODE_DISABLED", OF_BLENDMODE_DISABLED)}, - {SWIG_LUA_CONSTTAB_INT("BLENDMODE_ALPHA", OF_BLENDMODE_ALPHA)}, - {SWIG_LUA_CONSTTAB_INT("BLENDMODE_ADD", OF_BLENDMODE_ADD)}, - {SWIG_LUA_CONSTTAB_INT("BLENDMODE_SUBTRACT", OF_BLENDMODE_SUBTRACT)}, - {SWIG_LUA_CONSTTAB_INT("BLENDMODE_MULTIPLY", OF_BLENDMODE_MULTIPLY)}, - {SWIG_LUA_CONSTTAB_INT("BLENDMODE_SCREEN", OF_BLENDMODE_SCREEN)}, - {SWIG_LUA_CONSTTAB_INT("ORIENTATION_DEFAULT", OF_ORIENTATION_DEFAULT)}, - {SWIG_LUA_CONSTTAB_INT("ORIENTATION_180", OF_ORIENTATION_180)}, - {SWIG_LUA_CONSTTAB_INT("ORIENTATION_90_LEFT", OF_ORIENTATION_90_LEFT)}, - {SWIG_LUA_CONSTTAB_INT("ORIENTATION_90_RIGHT", OF_ORIENTATION_90_RIGHT)}, - {SWIG_LUA_CONSTTAB_INT("ORIENTATION_UNKNOWN", OF_ORIENTATION_UNKNOWN)}, - {SWIG_LUA_CONSTTAB_INT("GRADIENT_LINEAR", OF_GRADIENT_LINEAR)}, - {SWIG_LUA_CONSTTAB_INT("GRADIENT_CIRCULAR", OF_GRADIENT_CIRCULAR)}, - {SWIG_LUA_CONSTTAB_INT("GRADIENT_BAR", OF_GRADIENT_BAR)}, - {SWIG_LUA_CONSTTAB_INT("POLY_WINDING_ODD", OF_POLY_WINDING_ODD)}, - {SWIG_LUA_CONSTTAB_INT("POLY_WINDING_NONZERO", OF_POLY_WINDING_NONZERO)}, - {SWIG_LUA_CONSTTAB_INT("POLY_WINDING_POSITIVE", OF_POLY_WINDING_POSITIVE)}, - {SWIG_LUA_CONSTTAB_INT("POLY_WINDING_NEGATIVE", OF_POLY_WINDING_NEGATIVE)}, - {SWIG_LUA_CONSTTAB_INT("POLY_WINDING_ABS_GEQ_TWO", OF_POLY_WINDING_ABS_GEQ_TWO)}, - {SWIG_LUA_CONSTTAB_INT("CLOSE", (true))}, - {SWIG_LUA_CONSTTAB_INT("LEFT_HANDED", OF_LEFT_HANDED)}, - {SWIG_LUA_CONSTTAB_INT("RIGHT_HANDED", OF_RIGHT_HANDED)}, - {SWIG_LUA_CONSTTAB_INT("MATRIX_MODELVIEW", OF_MATRIX_MODELVIEW)}, - {SWIG_LUA_CONSTTAB_INT("MATRIX_PROJECTION", OF_MATRIX_PROJECTION)}, - {SWIG_LUA_CONSTTAB_INT("MATRIX_TEXTURE", OF_MATRIX_TEXTURE)}, - {SWIG_LUA_CONSTTAB_INT("KEY_MODIFIER", 0x0100)}, - {SWIG_LUA_CONSTTAB_INT("KEY_RETURN", 13)}, - {SWIG_LUA_CONSTTAB_INT("KEY_ESC", 27)}, - {SWIG_LUA_CONSTTAB_INT("KEY_TAB", 9)}, - {SWIG_LUA_CONSTTAB_INT("KEY_BACKSPACE", 8)}, - {SWIG_LUA_CONSTTAB_INT("KEY_DEL", 127)}, - {SWIG_LUA_CONSTTAB_INT("KEY_F1", (1|0x0100))}, - {SWIG_LUA_CONSTTAB_INT("KEY_F2", (2|0x0100))}, - {SWIG_LUA_CONSTTAB_INT("KEY_F3", (3|0x0100))}, - {SWIG_LUA_CONSTTAB_INT("KEY_F4", (4|0x0100))}, - {SWIG_LUA_CONSTTAB_INT("KEY_F5", (5|0x0100))}, - {SWIG_LUA_CONSTTAB_INT("KEY_F6", (6|0x0100))}, - {SWIG_LUA_CONSTTAB_INT("KEY_F7", (7|0x0100))}, - {SWIG_LUA_CONSTTAB_INT("KEY_F8", (8|0x0100))}, - {SWIG_LUA_CONSTTAB_INT("KEY_F9", (9|0x0100))}, - {SWIG_LUA_CONSTTAB_INT("KEY_F10", (10|0x0100))}, - {SWIG_LUA_CONSTTAB_INT("KEY_F11", (11|0x0100))}, - {SWIG_LUA_CONSTTAB_INT("KEY_F12", (12|0x0100))}, - {SWIG_LUA_CONSTTAB_INT("KEY_LEFT", (100|0x0100))}, - {SWIG_LUA_CONSTTAB_INT("KEY_UP", (101|0x0100))}, - {SWIG_LUA_CONSTTAB_INT("KEY_RIGHT", (102|0x0100))}, - {SWIG_LUA_CONSTTAB_INT("KEY_DOWN", (103|0x0100))}, - {SWIG_LUA_CONSTTAB_INT("KEY_PAGE_UP", (104|0x0100))}, - {SWIG_LUA_CONSTTAB_INT("KEY_PAGE_DOWN", (105|0x0100))}, - {SWIG_LUA_CONSTTAB_INT("KEY_HOME", (106|0x0100))}, - {SWIG_LUA_CONSTTAB_INT("KEY_END", (107|0x0100))}, - {SWIG_LUA_CONSTTAB_INT("KEY_INSERT", (108|0x0100))}, - {SWIG_LUA_CONSTTAB_INT("KEY_CONTROL", (0x200|0x0100))}, - {SWIG_LUA_CONSTTAB_INT("KEY_ALT", (0x400|0x0100))}, - {SWIG_LUA_CONSTTAB_INT("KEY_SHIFT", (0x800|0x0100))}, - {SWIG_LUA_CONSTTAB_INT("KEY_SUPER", (0x1000|0x0100))}, - {SWIG_LUA_CONSTTAB_INT("KEY_LEFT_SHIFT", (0x1|(0x800|0x0100)))}, - {SWIG_LUA_CONSTTAB_INT("KEY_RIGHT_SHIFT", (0x2|(0x800|0x0100)))}, - {SWIG_LUA_CONSTTAB_INT("KEY_LEFT_CONTROL", (0x1|(0x200|0x0100)))}, - {SWIG_LUA_CONSTTAB_INT("KEY_RIGHT_CONTROL", (0x2|(0x200|0x0100)))}, - {SWIG_LUA_CONSTTAB_INT("KEY_LEFT_ALT", (0x1|(0x400|0x0100)))}, - {SWIG_LUA_CONSTTAB_INT("KEY_RIGHT_ALT", (0x2|(0x400|0x0100)))}, - {SWIG_LUA_CONSTTAB_INT("KEY_LEFT_SUPER", (0x1|(0x1000|0x0100)))}, - {SWIG_LUA_CONSTTAB_INT("KEY_RIGHT_SUPER", (0x2|(0x1000|0x0100)))}, - {SWIG_LUA_CONSTTAB_INT("KEY_LEFT_COMMAND", (0x1|(0x1000|0x0100)))}, - {SWIG_LUA_CONSTTAB_INT("KEY_RIGHT_COMMAND", (0x2|(0x1000|0x0100)))}, - {SWIG_LUA_CONSTTAB_INT("MOUSE_BUTTON_1", 0)}, - {SWIG_LUA_CONSTTAB_INT("MOUSE_BUTTON_2", 1)}, - {SWIG_LUA_CONSTTAB_INT("MOUSE_BUTTON_3", 2)}, - {SWIG_LUA_CONSTTAB_INT("MOUSE_BUTTON_4", 3)}, - {SWIG_LUA_CONSTTAB_INT("MOUSE_BUTTON_5", 4)}, - {SWIG_LUA_CONSTTAB_INT("MOUSE_BUTTON_6", 5)}, - {SWIG_LUA_CONSTTAB_INT("MOUSE_BUTTON_7", 6)}, - {SWIG_LUA_CONSTTAB_INT("MOUSE_BUTTON_8", 7)}, - {SWIG_LUA_CONSTTAB_INT("MOUSE_BUTTON_LAST", 7)}, - {SWIG_LUA_CONSTTAB_INT("MOUSE_BUTTON_LEFT", 0)}, - {SWIG_LUA_CONSTTAB_INT("MOUSE_BUTTON_MIDDLE", 1)}, - {SWIG_LUA_CONSTTAB_INT("MOUSE_BUTTON_RIGHT", 2)}, - {SWIG_LUA_CONSTTAB_INT("CONSOLE_COLOR_RESTORE", (0))}, - {SWIG_LUA_CONSTTAB_INT("CONSOLE_COLOR_BLACK", (30))}, - {SWIG_LUA_CONSTTAB_INT("CONSOLE_COLOR_RED", (31))}, - {SWIG_LUA_CONSTTAB_INT("CONSOLE_COLOR_GREEN", (32))}, - {SWIG_LUA_CONSTTAB_INT("CONSOLE_COLOR_YELLOW", (33))}, - {SWIG_LUA_CONSTTAB_INT("CONSOLE_COLOR_BLUE", (34))}, - {SWIG_LUA_CONSTTAB_INT("CONSOLE_COLOR_PURPLE", (35))}, - {SWIG_LUA_CONSTTAB_INT("CONSOLE_COLOR_CYAN", (36))}, - {SWIG_LUA_CONSTTAB_INT("CONSOLE_COLOR_WHITE", (37))}, - {SWIG_LUA_CONSTTAB_INT("PIXELS_GRAY", OF_PIXELS_GRAY)}, - {SWIG_LUA_CONSTTAB_INT("PIXELS_GRAY_ALPHA", OF_PIXELS_GRAY_ALPHA)}, - {SWIG_LUA_CONSTTAB_INT("PIXELS_RGB", OF_PIXELS_RGB)}, - {SWIG_LUA_CONSTTAB_INT("PIXELS_BGR", OF_PIXELS_BGR)}, - {SWIG_LUA_CONSTTAB_INT("PIXELS_RGBA", OF_PIXELS_RGBA)}, - {SWIG_LUA_CONSTTAB_INT("PIXELS_BGRA", OF_PIXELS_BGRA)}, - {SWIG_LUA_CONSTTAB_INT("PIXELS_RGB565", OF_PIXELS_RGB565)}, - {SWIG_LUA_CONSTTAB_INT("PIXELS_NV12", OF_PIXELS_NV12)}, - {SWIG_LUA_CONSTTAB_INT("PIXELS_NV21", OF_PIXELS_NV21)}, - {SWIG_LUA_CONSTTAB_INT("PIXELS_YV12", OF_PIXELS_YV12)}, - {SWIG_LUA_CONSTTAB_INT("PIXELS_I420", OF_PIXELS_I420)}, - {SWIG_LUA_CONSTTAB_INT("PIXELS_YUY2", OF_PIXELS_YUY2)}, - {SWIG_LUA_CONSTTAB_INT("PIXELS_UYVY", OF_PIXELS_UYVY)}, - {SWIG_LUA_CONSTTAB_INT("PIXELS_Y", OF_PIXELS_Y)}, - {SWIG_LUA_CONSTTAB_INT("PIXELS_U", OF_PIXELS_U)}, - {SWIG_LUA_CONSTTAB_INT("PIXELS_V", OF_PIXELS_V)}, - {SWIG_LUA_CONSTTAB_INT("PIXELS_UV", OF_PIXELS_UV)}, - {SWIG_LUA_CONSTTAB_INT("PIXELS_VU", OF_PIXELS_VU)}, - {SWIG_LUA_CONSTTAB_INT("PIXELS_NUM_FORMATS", OF_PIXELS_NUM_FORMATS)}, - {SWIG_LUA_CONSTTAB_INT("PIXELS_UNKNOWN", OF_PIXELS_UNKNOWN)}, - {SWIG_LUA_CONSTTAB_INT("PIXELS_NATIVE", OF_PIXELS_NATIVE)}, - {SWIG_LUA_CONSTTAB_INT("BITMAPMODE_SIMPLE", OF_BITMAPMODE_SIMPLE)}, - {SWIG_LUA_CONSTTAB_INT("BITMAPMODE_SCREEN", OF_BITMAPMODE_SCREEN)}, - {SWIG_LUA_CONSTTAB_INT("BITMAPMODE_VIEWPORT", OF_BITMAPMODE_VIEWPORT)}, - {SWIG_LUA_CONSTTAB_INT("BITMAPMODE_MODEL", OF_BITMAPMODE_MODEL)}, - {SWIG_LUA_CONSTTAB_INT("BITMAPMODE_MODEL_BILLBOARD", OF_BITMAPMODE_MODEL_BILLBOARD)}, - {SWIG_LUA_CONSTTAB_INT("ENCODING_UTF8", OF_ENCODING_UTF8)}, - {SWIG_LUA_CONSTTAB_INT("ENCODING_ISO_8859_15", OF_ENCODING_ISO_8859_15)}, - {SWIG_LUA_CONSTTAB_INT("COMPRESS_NONE", OF_COMPRESS_NONE)}, - {SWIG_LUA_CONSTTAB_INT("COMPRESS_SRGB", OF_COMPRESS_SRGB)}, - {SWIG_LUA_CONSTTAB_INT("COMPRESS_ARB", OF_COMPRESS_ARB)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_QUALITY_BEST", OF_IMAGE_QUALITY_BEST)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_QUALITY_HIGH", OF_IMAGE_QUALITY_HIGH)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_QUALITY_MEDIUM", OF_IMAGE_QUALITY_MEDIUM)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_QUALITY_LOW", OF_IMAGE_QUALITY_LOW)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_QUALITY_WORST", OF_IMAGE_QUALITY_WORST)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_BMP", OF_IMAGE_FORMAT_BMP)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_ICO", OF_IMAGE_FORMAT_ICO)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_JPEG", OF_IMAGE_FORMAT_JPEG)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_JNG", OF_IMAGE_FORMAT_JNG)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_KOALA", OF_IMAGE_FORMAT_KOALA)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_LBM", OF_IMAGE_FORMAT_LBM)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_IFF", OF_IMAGE_FORMAT_IFF)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_MNG", OF_IMAGE_FORMAT_MNG)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_PBM", OF_IMAGE_FORMAT_PBM)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_PBMRAW", OF_IMAGE_FORMAT_PBMRAW)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_PCD", OF_IMAGE_FORMAT_PCD)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_PCX", OF_IMAGE_FORMAT_PCX)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_PGM", OF_IMAGE_FORMAT_PGM)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_PGMRAW", OF_IMAGE_FORMAT_PGMRAW)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_PNG", OF_IMAGE_FORMAT_PNG)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_PPM", OF_IMAGE_FORMAT_PPM)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_PPMRAW", OF_IMAGE_FORMAT_PPMRAW)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_RAS", OF_IMAGE_FORMAT_RAS)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_TARGA", OF_IMAGE_FORMAT_TARGA)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_TIFF", OF_IMAGE_FORMAT_TIFF)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_WBMP", OF_IMAGE_FORMAT_WBMP)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_PSD", OF_IMAGE_FORMAT_PSD)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_CUT", OF_IMAGE_FORMAT_CUT)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_XBM", OF_IMAGE_FORMAT_XBM)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_XPM", OF_IMAGE_FORMAT_XPM)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_DDS", OF_IMAGE_FORMAT_DDS)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_GIF", OF_IMAGE_FORMAT_GIF)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_HDR", OF_IMAGE_FORMAT_HDR)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_FAXG3", OF_IMAGE_FORMAT_FAXG3)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_SGI", OF_IMAGE_FORMAT_SGI)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_EXR", OF_IMAGE_FORMAT_EXR)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_J2K", OF_IMAGE_FORMAT_J2K)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_JP2", OF_IMAGE_FORMAT_JP2)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_PFM", OF_IMAGE_FORMAT_PFM)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_PICT", OF_IMAGE_FORMAT_PICT)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_RAW", OF_IMAGE_FORMAT_RAW)}, - {SWIG_LUA_CONSTTAB_INT("BoxPrimitive_SIDE_FRONT", ofBoxPrimitive::SIDE_FRONT)}, - {SWIG_LUA_CONSTTAB_INT("BoxPrimitive_SIDE_RIGHT", ofBoxPrimitive::SIDE_RIGHT)}, - {SWIG_LUA_CONSTTAB_INT("BoxPrimitive_SIDE_LEFT", ofBoxPrimitive::SIDE_LEFT)}, - {SWIG_LUA_CONSTTAB_INT("BoxPrimitive_SIDE_BACK", ofBoxPrimitive::SIDE_BACK)}, - {SWIG_LUA_CONSTTAB_INT("BoxPrimitive_SIDE_TOP", ofBoxPrimitive::SIDE_TOP)}, - {SWIG_LUA_CONSTTAB_INT("BoxPrimitive_SIDE_BOTTOM", ofBoxPrimitive::SIDE_BOTTOM)}, - {SWIG_LUA_CONSTTAB_INT("BoxPrimitive_SIDES_TOTAL", ofBoxPrimitive::SIDES_TOTAL)}, - {SWIG_LUA_CONSTTAB_INT("Vec2f_DIM", ofVec2f::DIM)}, - {SWIG_LUA_CONSTTAB_INT("Vec3f_DIM", ofVec3f::DIM)}, - {SWIG_LUA_CONSTTAB_INT("Vec4f_DIM", ofVec4f::DIM)}, - {SWIG_LUA_CONSTTAB_INT("TouchEventArgs_down", ofTouchEventArgs::down)}, - {SWIG_LUA_CONSTTAB_INT("TouchEventArgs_up", ofTouchEventArgs::up)}, - {SWIG_LUA_CONSTTAB_INT("TouchEventArgs_move", ofTouchEventArgs::move)}, - {SWIG_LUA_CONSTTAB_INT("TouchEventArgs_doubleTap", ofTouchEventArgs::doubleTap)}, - {SWIG_LUA_CONSTTAB_INT("TouchEventArgs_cancel", ofTouchEventArgs::cancel)}, - {SWIG_LUA_CONSTTAB_INT("TEXTURE_LUMINANCE", 6409)}, - {SWIG_LUA_CONSTTAB_INT("TEXTURE_RGB", 6407)}, - {SWIG_LUA_CONSTTAB_INT("TEXTURE_RGBA", 6408)}, - {SWIG_LUA_CONSTTAB_INT("NEAREST", 9728)}, - {SWIG_LUA_CONSTTAB_INT("LINEAR", 9729)}, - {SWIG_LUA_CONSTTAB_INT("FRAGMENT_SHADER", 35632)}, - {SWIG_LUA_CONSTTAB_INT("VERTEX_SHADER", 35633)}, - {SWIG_LUA_CONSTTAB_INT("CLAMP_TO_EDGE", 33071)}, - {SWIG_LUA_CONSTTAB_INT("REPEAT", 10497)}, - {SWIG_LUA_CONSTTAB_INT("MIRRORED_REPEAT", 33648)}, - {SWIG_LUA_CONSTTAB_INT("PRIMITIVE_TRIANGLES", OF_PRIMITIVE_TRIANGLES)}, - {SWIG_LUA_CONSTTAB_INT("PRIMITIVE_TRIANGLE_STRIP", OF_PRIMITIVE_TRIANGLE_STRIP)}, - {SWIG_LUA_CONSTTAB_INT("PRIMITIVE_TRIANGLE_FAN", OF_PRIMITIVE_TRIANGLE_FAN)}, - {SWIG_LUA_CONSTTAB_INT("PRIMITIVE_LINES", OF_PRIMITIVE_LINES)}, - {SWIG_LUA_CONSTTAB_INT("PRIMITIVE_LINE_STRIP", OF_PRIMITIVE_LINE_STRIP)}, - {SWIG_LUA_CONSTTAB_INT("PRIMITIVE_LINE_LOOP", OF_PRIMITIVE_LINE_LOOP)}, - {SWIG_LUA_CONSTTAB_INT("PRIMITIVE_POINTS", OF_PRIMITIVE_POINTS)}, - {SWIG_LUA_CONSTTAB_INT("MESH_POINTS", OF_MESH_POINTS)}, - {SWIG_LUA_CONSTTAB_INT("MESH_WIREFRAME", OF_MESH_WIREFRAME)}, - {SWIG_LUA_CONSTTAB_INT("MESH_FILL", OF_MESH_FILL)}, - {SWIG_LUA_CONSTTAB_INT("LIGHT_POINT", OF_LIGHT_POINT)}, - {SWIG_LUA_CONSTTAB_INT("LIGHT_DIRECTIONAL", OF_LIGHT_DIRECTIONAL)}, - {SWIG_LUA_CONSTTAB_INT("LIGHT_SPOT", OF_LIGHT_SPOT)}, - {SWIG_LUA_CONSTTAB_INT("LIGHT_AREA", OF_LIGHT_AREA)}, - {SWIG_LUA_CONSTTAB_INT("Shader_POSITION_ATTRIBUTE", ofShader::POSITION_ATTRIBUTE)}, - {SWIG_LUA_CONSTTAB_INT("Shader_COLOR_ATTRIBUTE", ofShader::COLOR_ATTRIBUTE)}, - {SWIG_LUA_CONSTTAB_INT("Shader_NORMAL_ATTRIBUTE", ofShader::NORMAL_ATTRIBUTE)}, - {SWIG_LUA_CONSTTAB_INT("Shader_TEXCOORD_ATTRIBUTE", ofShader::TEXCOORD_ATTRIBUTE)}, - {SWIG_LUA_CONSTTAB_INT("Shader_INDEX_ATTRIBUTE", ofShader::INDEX_ATTRIBUTE)}, - {SWIG_LUA_CONSTTAB_INT("INTERPOLATE_NEAREST_NEIGHBOR", OF_INTERPOLATE_NEAREST_NEIGHBOR)}, - {SWIG_LUA_CONSTTAB_INT("INTERPOLATE_BILINEAR", OF_INTERPOLATE_BILINEAR)}, - {SWIG_LUA_CONSTTAB_INT("INTERPOLATE_BICUBIC", OF_INTERPOLATE_BICUBIC)}, - {SWIG_LUA_CONSTTAB_INT("Path_COMMANDS", ofPath::COMMANDS)}, - {SWIG_LUA_CONSTTAB_INT("Path_POLYLINES", ofPath::POLYLINES)}, - {SWIG_LUA_CONSTTAB_INT("CIRC_RESOLUTION", 22)}, - {SWIG_LUA_CONSTTAB_INT("NUM_CHARACTER_TO_START", 32)}, - {SWIG_LUA_CONSTTAB_INT("File_Reference", ofFile::Reference)}, - {SWIG_LUA_CONSTTAB_INT("File_ReadOnly", ofFile::ReadOnly)}, - {SWIG_LUA_CONSTTAB_INT("File_WriteOnly", ofFile::WriteOnly)}, - {SWIG_LUA_CONSTTAB_INT("File_ReadWrite", ofFile::ReadWrite)}, - {SWIG_LUA_CONSTTAB_INT("File_Append", ofFile::Append)}, - {SWIG_LUA_CONSTTAB_INT("LOG_VERBOSE", OF_LOG_VERBOSE)}, - {SWIG_LUA_CONSTTAB_INT("LOG_NOTICE", OF_LOG_NOTICE)}, - {SWIG_LUA_CONSTTAB_INT("LOG_WARNING", OF_LOG_WARNING)}, - {SWIG_LUA_CONSTTAB_INT("LOG_ERROR", OF_LOG_ERROR)}, - {SWIG_LUA_CONSTTAB_INT("LOG_FATAL_ERROR", OF_LOG_FATAL_ERROR)}, - {SWIG_LUA_CONSTTAB_INT("LOG_SILENT", OF_LOG_SILENT)}, - {0,0,0,0,0,0} -}; -static swig_lua_method swig_SwigModule_methods[]= { - { "Fbo_checkGLSupport", _wrap_Fbo_checkGLSupport}, - { "Fbo_maxColorAttachments", _wrap_Fbo_maxColorAttachments}, - { "Fbo_maxDrawBuffers", _wrap_Fbo_maxDrawBuffers}, - { "Fbo_maxSamples", _wrap_Fbo_maxSamples}, - { "getUsingArbTex", _wrap_getUsingArbTex}, - { "enableArbTex", _wrap_enableArbTex}, - { "disableArbTex", _wrap_disableArbTex}, - { "getUsingNormalizedTexCoords", _wrap_getUsingNormalizedTexCoords}, - { "enableNormalizedTexCoords", _wrap_enableNormalizedTexCoords}, - { "disableNormalizedTexCoords", _wrap_disableNormalizedTexCoords}, - { "enableTextureEdgeHack", _wrap_enableTextureEdgeHack}, - { "disableTextureEdgeHack", _wrap_disableTextureEdgeHack}, - { "isTextureEdgeHackEnabled", _wrap_isTextureEdgeHackEnabled}, - { "isVFlipped", _wrap_isVFlipped}, - { "drawAxis", _wrap_drawAxis}, - { "drawGrid", _wrap_drawGrid}, - { "drawGridPlane", _wrap_drawGridPlane}, - { "drawArrow", _wrap_drawArrow}, - { "drawRotationAxes", _wrap_drawRotationAxes}, - { "Mesh_plane", _wrap_Mesh_plane}, - { "Mesh_sphere", _wrap_Mesh_sphere}, - { "Mesh_icosahedron", _wrap_Mesh_icosahedron}, - { "Mesh_icosphere", _wrap_Mesh_icosphere}, - { "Mesh_cylinder", _wrap_Mesh_cylinder}, - { "Mesh_cone", _wrap_Mesh_cone}, - { "Mesh_box", _wrap_Mesh_box}, - { "Mesh_axis", _wrap_Mesh_axis}, - { "getAppPtr", _wrap_getAppPtr}, - { "exit", _wrap_exit}, - { "getFrameRate", _wrap_getFrameRate}, - { "getTargetFrameRate", _wrap_getTargetFrameRate}, - { "getFrameNum", _wrap_getFrameNum}, - { "setFrameRate", _wrap_setFrameRate}, - { "getLastFrameTime", _wrap_getLastFrameTime}, - { "setOrientation", _wrap_setOrientation}, - { "getOrientation", _wrap_getOrientation}, - { "hideCursor", _wrap_hideCursor}, - { "showCursor", _wrap_showCursor}, - { "getWindowPositionX", _wrap_getWindowPositionX}, - { "getWindowPositionY", _wrap_getWindowPositionY}, - { "getScreenWidth", _wrap_getScreenWidth}, - { "getScreenHeight", _wrap_getScreenHeight}, - { "getWindowMode", _wrap_getWindowMode}, - { "getWidth", _wrap_getWidth}, - { "getHeight", _wrap_getHeight}, - { "getWindowWidth", _wrap_getWindowWidth}, - { "getWindowHeight", _wrap_getWindowHeight}, - { "randomWidth", _wrap_randomWidth}, - { "randomHeight", _wrap_randomHeight}, - { "doesHWOrientation", _wrap_doesHWOrientation}, - { "getWindowSize", _wrap_getWindowSize}, - { "getWindowRect", _wrap_getWindowRect}, - { "setWindowPosition", _wrap_setWindowPosition}, - { "setWindowShape", _wrap_setWindowShape}, - { "setWindowTitle", _wrap_setWindowTitle}, - { "enableSetupScreen", _wrap_enableSetupScreen}, - { "disableSetupScreen", _wrap_disableSetupScreen}, - { "setFullscreen", _wrap_setFullscreen}, - { "toggleFullscreen", _wrap_toggleFullscreen}, - { "setVerticalSync", _wrap_setVerticalSync}, - { "events", _wrap_events}, - { "setEscapeQuitsApp", _wrap_setEscapeQuitsApp}, - { "random", _wrap_random}, - { "randomf", _wrap_randomf}, - { "randomuf", _wrap_randomuf}, - { "seedRandom", _wrap_seedRandom}, - { "normalize", _wrap_normalize}, - { "map", _wrap_map}, - { "clamp", _wrap_clamp}, - { "inRange", _wrap_inRange}, - { "lerp", _wrap_lerp}, - { "dist", _wrap_dist}, - { "distSquared", _wrap_distSquared}, - { "radToDeg", _wrap_radToDeg}, - { "degToRad", _wrap_degToRad}, - { "lerpDegrees", _wrap_lerpDegrees}, - { "lerpRadians", _wrap_lerpRadians}, - { "angleDifferenceDegrees", _wrap_angleDifferenceDegrees}, - { "angleDifferenceRadians", _wrap_angleDifferenceRadians}, - { "wrap", _wrap_wrap}, - { "wrapRadians", _wrap_wrapRadians}, - { "wrapDegrees", _wrap_wrapDegrees}, - { "noise", _wrap_noise}, - { "signedNoise", _wrap_signedNoise}, - { "insidePoly", _wrap_insidePoly}, - { "lineSegmentIntersection", _wrap_lineSegmentIntersection}, - { "bezierPoint", _wrap_bezierPoint}, - { "curvePoint", _wrap_curvePoint}, - { "bezierTangent", _wrap_bezierTangent}, - { "curveTangent", _wrap_curveTangent}, - { "nextPow2", _wrap_nextPow2}, - { "sign", _wrap_sign}, - { "Matrix4x4_newIdentityMatrix", _wrap_Matrix4x4_newIdentityMatrix}, - { "Matrix4x4_newScaleMatrix", _wrap_Matrix4x4_newScaleMatrix}, - { "Matrix4x4_newTranslationMatrix", _wrap_Matrix4x4_newTranslationMatrix}, - { "Matrix4x4_newRotationMatrix", _wrap_Matrix4x4_newRotationMatrix}, - { "Matrix4x4_newOrthoMatrix", _wrap_Matrix4x4_newOrthoMatrix}, - { "Matrix4x4_newOrtho2DMatrix", _wrap_Matrix4x4_newOrtho2DMatrix}, - { "Matrix4x4_newFrustumMatrix", _wrap_Matrix4x4_newFrustumMatrix}, - { "Matrix4x4_newPerspectiveMatrix", _wrap_Matrix4x4_newPerspectiveMatrix}, - { "Matrix4x4_newLookAtMatrix", _wrap_Matrix4x4_newLookAtMatrix}, - { "Matrix4x4_getInverseOf", _wrap_Matrix4x4_getInverseOf}, - { "Matrix4x4_getTransposedOf", _wrap_Matrix4x4_getTransposedOf}, - { "Matrix4x4_getOrthoNormalOf", _wrap_Matrix4x4_getOrthoNormalOf}, - { "Matrix4x4_transform3x3", _wrap_Matrix4x4_transform3x3}, - { "Vec2f_zero", _wrap_Vec2f_zero}, - { "Vec2f_one", _wrap_Vec2f_one}, - { "Vec3f_zero", _wrap_Vec3f_zero}, - { "Vec3f_one", _wrap_Vec3f_one}, - { "Vec4f_zero", _wrap_Vec4f_zero}, - { "Vec4f_one", _wrap_Vec4f_one}, - { "getMousePressed", _wrap_getMousePressed}, - { "getKeyPressed", _wrap_getKeyPressed}, - { "getMouseX", _wrap_getMouseX}, - { "getMouseY", _wrap_getMouseY}, - { "getPreviousMouseX", _wrap_getPreviousMouseX}, - { "getPreviousMouseY", _wrap_getPreviousMouseY}, - { "sendMessage", _wrap_sendMessage}, - { "getGlInternalFormat", _wrap_getGlInternalFormat}, - { "getGlInternalFormatName", _wrap_getGlInternalFormatName}, - { "getGLFormatFromInternal", _wrap_getGLFormatFromInternal}, - { "getGlTypeFromInternal", _wrap_getGlTypeFromInternal}, - { "getGlType", _wrap_getGlType}, - { "getImageTypeFromGLType", _wrap_getImageTypeFromGLType}, - { "getGLPolyMode", _wrap_getGLPolyMode}, - { "getOFPolyMode", _wrap_getOFPolyMode}, - { "getGLPrimitiveMode", _wrap_getGLPrimitiveMode}, - { "getOFPrimitiveMode", _wrap_getOFPrimitiveMode}, - { "getGLInternalFormatFromPixelFormat", _wrap_getGLInternalFormatFromPixelFormat}, - { "getGLFormatFromPixelFormat", _wrap_getGLFormatFromPixelFormat}, - { "getBytesPerChannelFromGLType", _wrap_getBytesPerChannelFromGLType}, - { "getNumChannelsFromGLFormat", _wrap_getNumChannelsFromGLFormat}, - { "setPixelStoreiAlignment", _wrap_setPixelStoreiAlignment}, - { "GLSupportedExtensions", _wrap_GLSupportedExtensions}, - { "GLCheckExtension", _wrap_GLCheckExtension}, - { "GLSupportsNPOTTextures", _wrap_GLSupportsNPOTTextures}, - { "isGLProgrammableRenderer", _wrap_isGLProgrammableRenderer}, - { "GLSLVersionFromGL", _wrap_GLSLVersionFromGL}, - { "enableLighting", _wrap_enableLighting}, - { "disableLighting", _wrap_disableLighting}, - { "enableSeparateSpecularLight", _wrap_enableSeparateSpecularLight}, - { "disableSeparateSpecularLight", _wrap_disableSeparateSpecularLight}, - { "getLightingEnabled", _wrap_getLightingEnabled}, - { "setSmoothLighting", _wrap_setSmoothLighting}, - { "setGlobalAmbientColor", _wrap_setGlobalAmbientColor}, - { "getGlobalAmbientColor", _wrap_getGlobalAmbientColor}, - { "lightsData", _wrap_lightsData}, - { "Polyline_fromRectangle", _wrap_Polyline_fromRectangle}, - { "drawBitmapString", _wrap_drawBitmapString}, - { "setColor", _wrap_setColor}, - { "setHexColor", _wrap_setHexColor}, - { "noFill", _wrap_noFill}, - { "fill", _wrap_fill}, - { "getFill", _wrap_getFill}, - { "getBackgroundColor", _wrap_getBackgroundColor}, - { "background", _wrap_background}, - { "backgroundHex", _wrap_backgroundHex}, - { "backgroundGradient", _wrap_backgroundGradient}, - { "setBackgroundColor", _wrap_setBackgroundColor}, - { "setBackgroundColorHex", _wrap_setBackgroundColorHex}, - { "setBackgroundAuto", _wrap_setBackgroundAuto}, - { "getBackgroundAuto", _wrap_getBackgroundAuto}, - { "clear", _wrap_clear}, - { "clearAlpha", _wrap_clearAlpha}, - { "drawTriangle", _wrap_drawTriangle}, - { "drawCircle", _wrap_drawCircle}, - { "drawEllipse", _wrap_drawEllipse}, - { "drawLine", _wrap_drawLine}, - { "drawRectangle", _wrap_drawRectangle}, - { "drawRectRounded", _wrap_drawRectRounded}, - { "drawCurve", _wrap_drawCurve}, - { "drawBezier", _wrap_drawBezier}, - { "beginShape", _wrap_beginShape}, - { "vertex", _wrap_vertex}, - { "vertices", _wrap_vertices}, - { "curveVertex", _wrap_curveVertex}, - { "curveVertices", _wrap_curveVertices}, - { "bezierVertex", _wrap_bezierVertex}, - { "endShape", _wrap_endShape}, - { "nextContour", _wrap_nextContour}, - { "setDrawBitmapMode", _wrap_setDrawBitmapMode}, - { "drawBitmapStringHighlight", _wrap_drawBitmapStringHighlight}, - { "setupGraphicDefaults", _wrap_setupGraphicDefaults}, - { "setupScreen", _wrap_setupScreen}, - { "getRectMode", _wrap_getRectMode}, - { "setCircleResolution", _wrap_setCircleResolution}, - { "setCurveResolution", _wrap_setCurveResolution}, - { "setLineWidth", _wrap_setLineWidth}, - { "setDepthTest", _wrap_setDepthTest}, - { "enableDepthTest", _wrap_enableDepthTest}, - { "disableDepthTest", _wrap_disableDepthTest}, - { "enableBlendMode", _wrap_enableBlendMode}, - { "disableBlendMode", _wrap_disableBlendMode}, - { "enablePointSprites", _wrap_enablePointSprites}, - { "disablePointSprites", _wrap_disablePointSprites}, - { "enableAlphaBlending", _wrap_enableAlphaBlending}, - { "disableAlphaBlending", _wrap_disableAlphaBlending}, - { "enableSmoothing", _wrap_enableSmoothing}, - { "disableSmoothing", _wrap_disableSmoothing}, - { "enableAntiAliasing", _wrap_enableAntiAliasing}, - { "disableAntiAliasing", _wrap_disableAntiAliasing}, - { "getStyle", _wrap_getStyle}, - { "setStyle", _wrap_setStyle}, - { "pushStyle", _wrap_pushStyle}, - { "popStyle", _wrap_popStyle}, - { "setPolyMode", _wrap_setPolyMode}, - { "setRectMode", _wrap_setRectMode}, - { "pushMatrix", _wrap_pushMatrix}, - { "popMatrix", _wrap_popMatrix}, - { "getCurrentMatrix", _wrap_getCurrentMatrix}, - { "getCurrentOrientationMatrix", _wrap_getCurrentOrientationMatrix}, - { "getCurrentNormalMatrix", _wrap_getCurrentNormalMatrix}, - { "translate", _wrap_translate}, - { "scale", _wrap_scale}, - { "rotate", _wrap_rotate}, - { "rotateX", _wrap_rotateX}, - { "rotateY", _wrap_rotateY}, - { "rotateZ", _wrap_rotateZ}, - { "loadIdentityMatrix", _wrap_loadIdentityMatrix}, - { "loadMatrix", _wrap_loadMatrix}, - { "multMatrix", _wrap_multMatrix}, - { "setMatrixMode", _wrap_setMatrixMode}, - { "loadViewMatrix", _wrap_loadViewMatrix}, - { "multViewMatrix", _wrap_multViewMatrix}, - { "getCurrentViewMatrix", _wrap_getCurrentViewMatrix}, - { "pushView", _wrap_pushView}, - { "popView", _wrap_popView}, - { "viewport", _wrap_viewport}, - { "getCurrentViewport", _wrap_getCurrentViewport}, - { "getNativeViewport", _wrap_getNativeViewport}, - { "getViewportWidth", _wrap_getViewportWidth}, - { "getViewportHeight", _wrap_getViewportHeight}, - { "setupScreenPerspective", _wrap_setupScreenPerspective}, - { "setupScreenOrtho", _wrap_setupScreenOrtho}, - { "orientationToDegrees", _wrap_orientationToDegrees}, - { "setCoordHandedness", _wrap_setCoordHandedness}, - { "getCoordHandedness", _wrap_getCoordHandedness}, - { "setPlaneResolution", _wrap_setPlaneResolution}, - { "getPlaneResolution", _wrap_getPlaneResolution}, - { "drawPlane", _wrap_drawPlane}, - { "setSphereResolution", _wrap_setSphereResolution}, - { "getSphereResolution", _wrap_getSphereResolution}, - { "drawSphere", _wrap_drawSphere}, - { "setIcoSphereResolution", _wrap_setIcoSphereResolution}, - { "getIcoSphereResolution", _wrap_getIcoSphereResolution}, - { "drawIcoSphere", _wrap_drawIcoSphere}, - { "setCylinderResolution", _wrap_setCylinderResolution}, - { "getCylinderResolution", _wrap_getCylinderResolution}, - { "drawCylinder", _wrap_drawCylinder}, - { "setConeResolution", _wrap_setConeResolution}, - { "getConeResolution", _wrap_getConeResolution}, - { "drawCone", _wrap_drawCone}, - { "setBoxResolution", _wrap_setBoxResolution}, - { "getBoxResolution", _wrap_getBoxResolution}, - { "drawBox", _wrap_drawBox}, - { "TrueTypeFont_setGlobalDpi", _wrap_TrueTypeFont_setGlobalDpi}, - { "soundStreamSetup", _wrap_soundStreamSetup}, - { "soundStreamStop", _wrap_soundStreamStop}, - { "soundStreamStart", _wrap_soundStreamStart}, - { "soundStreamClose", _wrap_soundStreamClose}, - { "soundStreamListDevices", _wrap_soundStreamListDevices}, - { "Color_fromHsb", _wrap_Color_fromHsb}, - { "Color_fromHex", _wrap_Color_fromHex}, - { "Color_limit", _wrap_Color_limit}, - { "FloatColor_fromHsb", _wrap_FloatColor_fromHsb}, - { "FloatColor_fromHex", _wrap_FloatColor_fromHex}, - { "FloatColor_limit", _wrap_FloatColor_limit}, - { "ShortColor_fromHsb", _wrap_ShortColor_fromHsb}, - { "ShortColor_fromHex", _wrap_ShortColor_fromHex}, - { "ShortColor_limit", _wrap_ShortColor_limit}, - { "Xml_tokenize", _wrap_Xml_tokenize}, - { "bufferFromFile", _wrap_bufferFromFile}, - { "bufferToFile", _wrap_bufferToFile}, - { "FilePath_getFileExt", _wrap_FilePath_getFileExt}, - { "FilePath_removeExt", _wrap_FilePath_removeExt}, - { "FilePath_addLeadingSlash", _wrap_FilePath_addLeadingSlash}, - { "FilePath_addTrailingSlash", _wrap_FilePath_addTrailingSlash}, - { "FilePath_removeTrailingSlash", _wrap_FilePath_removeTrailingSlash}, - { "FilePath_getPathForDirectory", _wrap_FilePath_getPathForDirectory}, - { "FilePath_getAbsolutePath", _wrap_FilePath_getAbsolutePath}, - { "FilePath_isAbsolute", _wrap_FilePath_isAbsolute}, - { "FilePath_getFileName", _wrap_FilePath_getFileName}, - { "FilePath_getBaseName", _wrap_FilePath_getBaseName}, - { "FilePath_getEnclosingDirectory", _wrap_FilePath_getEnclosingDirectory}, - { "FilePath_createEnclosingDirectory", _wrap_FilePath_createEnclosingDirectory}, - { "FilePath_getCurrentWorkingDirectory", _wrap_FilePath_getCurrentWorkingDirectory}, - { "FilePath_join", _wrap_FilePath_join}, - { "FilePath_getCurrentExePath", _wrap_FilePath_getCurrentExePath}, - { "FilePath_getCurrentExeDir", _wrap_FilePath_getCurrentExeDir}, - { "FilePath_getUserHomeDir", _wrap_FilePath_getUserHomeDir}, - { "FilePath_makeRelative", _wrap_FilePath_makeRelative}, - { "File_copyFromTo", _wrap_File_copyFromTo}, - { "File_moveFromTo", _wrap_File_moveFromTo}, - { "File_doesFileExist", _wrap_File_doesFileExist}, - { "File_removeFile", _wrap_File_removeFile}, - { "Directory_createDirectory", _wrap_Directory_createDirectory}, - { "Directory_isDirectoryEmpty", _wrap_Directory_isDirectoryEmpty}, - { "Directory_doesDirectoryExist", _wrap_Directory_doesDirectoryExist}, - { "Directory_removeDirectory", _wrap_Directory_removeDirectory}, - { "log", _wrap_log}, - { "setLogLevel", _wrap_setLogLevel}, - { "getLogLevel", _wrap_getLogLevel}, - { "getLogLevelName", _wrap_getLogLevelName}, - { "logToFile", _wrap_logToFile}, - { "logToConsole", _wrap_logToConsole}, - { "systemAlertDialog", _wrap_systemAlertDialog}, - { "systemLoadDialog", _wrap_systemLoadDialog}, - { "systemSaveDialog", _wrap_systemSaveDialog}, - { "systemTextBoxDialog", _wrap_systemTextBoxDialog}, - { "loadURL", _wrap_loadURL}, - { "loadURLAsync", _wrap_loadURLAsync}, - { "saveURLTo", _wrap_saveURLTo}, - { "saveURLAsync", _wrap_saveURLAsync}, - { "removeURLRequest", _wrap_removeURLRequest}, - { "removeAllURLRequests", _wrap_removeAllURLRequests}, - { "stopURLLoader", _wrap_stopURLLoader}, - { "uRLResponseEvent", _wrap_uRLResponseEvent}, - { "resetElapsedTimeCounter", _wrap_resetElapsedTimeCounter}, - { "getElapsedTimef", _wrap_getElapsedTimef}, - { "getElapsedTimeMillis", _wrap_getElapsedTimeMillis}, - { "getElapsedTimeMicros", _wrap_getElapsedTimeMicros}, - { "getSeconds", _wrap_getSeconds}, - { "getMinutes", _wrap_getMinutes}, - { "getHours", _wrap_getHours}, - { "getUnixTime", _wrap_getUnixTime}, - { "getSystemTime", _wrap_getSystemTime}, - { "getSystemTimeMicros", _wrap_getSystemTimeMicros}, - { "sleepMillis", _wrap_sleepMillis}, - { "getTimestampString", _wrap_getTimestampString}, - { "getYear", _wrap_getYear}, - { "getMonth", _wrap_getMonth}, - { "getDay", _wrap_getDay}, - { "getWeekday", _wrap_getWeekday}, - { "enableDataPath", _wrap_enableDataPath}, - { "disableDataPath", _wrap_disableDataPath}, - { "toDataPath", _wrap_toDataPath}, - { "restoreWorkingDirectoryToDefault", _wrap_restoreWorkingDirectoryToDefault}, - { "setDataPathRoot", _wrap_setDataPathRoot}, - { "splitString", _wrap_splitString}, - { "joinString", _wrap_joinString}, - { "stringReplace", _wrap_stringReplace}, - { "isStringInString", _wrap_isStringInString}, - { "stringTimesInString", _wrap_stringTimesInString}, - { "toLower", _wrap_toLower}, - { "toUpper", _wrap_toUpper}, - { "trimFront", _wrap_trimFront}, - { "trimBack", _wrap_trimBack}, - { "trim", _wrap_trim}, - { "appendUTF8", _wrap_appendUTF8}, - { "toInt", _wrap_toInt}, - { "toInt64", _wrap_toInt64}, - { "toFloat", _wrap_toFloat}, - { "toDouble", _wrap_toDouble}, - { "toBool", _wrap_toBool}, - { "toHex", _wrap_toHex}, - { "hexToInt", _wrap_hexToInt}, - { "hexToChar", _wrap_hexToChar}, - { "hexToFloat", _wrap_hexToFloat}, - { "hexToString", _wrap_hexToString}, - { "toChar", _wrap_toChar}, - { "toBinary", _wrap_toBinary}, - { "binaryToInt", _wrap_binaryToInt}, - { "binaryToChar", _wrap_binaryToChar}, - { "binaryToFloat", _wrap_binaryToFloat}, - { "binaryToString", _wrap_binaryToString}, - { "getVersionInfo", _wrap_getVersionInfo}, - { "getVersionMajor", _wrap_getVersionMajor}, - { "getVersionMinor", _wrap_getVersionMinor}, - { "getVersionPatch", _wrap_getVersionPatch}, - { "getVersionPreRelease", _wrap_getVersionPreRelease}, - { "saveScreen", _wrap_saveScreen}, - { "saveFrame", _wrap_saveFrame}, - { "saveViewport", _wrap_saveViewport}, - { "launchBrowser", _wrap_launchBrowser}, - { "system", _wrap_system}, - { "getTargetPlatform", _wrap_getTargetPlatform}, - { "getEnv", _wrap_getEnv}, - {0,0} -}; -static swig_lua_class* swig_SwigModule_classes[]= { -&_wrap_class_string, -&_wrap_class_path, -&_wrap_class_IntVector, -&_wrap_class_FloatVector, -&_wrap_class_StringVector, -&_wrap_class_UCharVector, -&_wrap_class_VideoDeviceVector, -&_wrap_class_TextureVector, -&_wrap_class_Fbo, -&_wrap_class_TextureData, -&_wrap_class_Texture, -&_wrap_class_Image, -&_wrap_class_FloatImage, -&_wrap_class_ShortImage, -&_wrap_class_Node, -&_wrap_class_Camera, -&_wrap_class_EasyCam, -&_wrap_class_Mesh, -&_wrap_class_MeshFace, -&_wrap_class_3dPrimitive, -&_wrap_class_PlanePrimitive, -&_wrap_class_SpherePrimitive, -&_wrap_class_IcoSpherePrimitive, -&_wrap_class_CylinderPrimitive, -&_wrap_class_ConePrimitive, -&_wrap_class_BoxPrimitive, -&_wrap_class_Matrix3x3, -&_wrap_class_Matrix4x4, -&_wrap_class_Quaternion, -&_wrap_class_Vec2f, -&_wrap_class_Vec3f, -&_wrap_class_Vec4f, -&_wrap_class_DragInfo, -&_wrap_class_TouchEventArgs, -&_wrap_class_BufferObject, -&_wrap_class_Light, -&_wrap_class_Material, -&_wrap_class_Shader, -&_wrap_class_Vbo, -&_wrap_class_VboMesh, -&_wrap_class_Pixels, -&_wrap_class_FloatPixels, -&_wrap_class_ShortPixels, -&_wrap_class_Path, -&_wrap_class_Polyline, -&_wrap_class_TrueTypeFont, -&_wrap_class_SoundStream, -&_wrap_class_SoundPlayer, -&_wrap_class_Color, -&_wrap_class_FloatColor, -&_wrap_class_ShortColor, -&_wrap_class_Rectangle, -&_wrap_class_SerialDeviceInfo, -&_wrap_class_Style, -&_wrap_class_FpsCounter, -&_wrap_class_Xml, -&_wrap_class_MatrixStack, -&_wrap_class_Buffer, -&_wrap_class_FilePath, -&_wrap_class_File, -&_wrap_class_Directory, -&_wrap_class_FileDialogResult, -&_wrap_class_HttpRequest, -&_wrap_class_HttpResponse, -&_wrap_class_URLFileLoader, -&_wrap_class_VideoGrabber, -&_wrap_class_VideoPlayer, - 0 -}; -static swig_lua_namespace* swig_SwigModule_namespaces[] = { - 0 -}; - -static swig_lua_namespace swig_SwigModule = { - "of", - swig_SwigModule_methods, - swig_SwigModule_attributes, - swig_SwigModule_constants, - swig_SwigModule_classes, - swig_SwigModule_namespaces -}; -#ifdef __cplusplus -} -#endif - -/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */ - -static void *_p_ofImage_T_unsigned_char_tTo_p_ofBaseImage_T_unsigned_char_t(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseImage_< unsigned char > *) ((ofImage_< unsigned char > *) x)); -} -static void *_p_ofImage_T_float_tTo_p_ofBaseImage_T_float_t(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseImage_< float > *) ((ofImage_< float > *) x)); -} -static void *_p_ofMaterialTo_p_ofBaseMaterial(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseMaterial *) ((ofMaterial *) x)); -} -static void *_p_ofSoundPlayerTo_p_ofBaseSoundPlayer(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseSoundPlayer *) ((ofSoundPlayer *) x)); -} -static void *_p_ofEasyCamTo_p_ofCamera(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofCamera *) ((ofEasyCam *) x)); -} -static void *_p_ofBaseVideoDrawsTo_p_ofBaseHasTexturePlanes(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseHasTexturePlanes *) ((ofBaseVideoDraws *) x)); -} -static void *_p_ofVideoGrabberTo_p_ofBaseHasTexturePlanes(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseHasTexturePlanes *) (ofBaseVideoDraws *) ((ofVideoGrabber *) x)); -} -static void *_p_ofVideoPlayerTo_p_ofBaseHasTexturePlanes(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseHasTexturePlanes *) (ofBaseVideoDraws *) ((ofVideoPlayer *) x)); -} -static void *_p_ofMouseEventArgsTo_p_ofVec2f(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofVec2f *) ((ofMouseEventArgs *) x)); -} -static void *_p_ofTouchEventArgsTo_p_ofVec2f(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofVec2f *) ((ofTouchEventArgs *) x)); -} -static void *_p_ofPlanePrimitiveTo_p_of3dPrimitive(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((of3dPrimitive *) ((ofPlanePrimitive *) x)); -} -static void *_p_ofSpherePrimitiveTo_p_of3dPrimitive(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((of3dPrimitive *) ((ofSpherePrimitive *) x)); -} -static void *_p_ofIcoSpherePrimitiveTo_p_of3dPrimitive(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((of3dPrimitive *) ((ofIcoSpherePrimitive *) x)); -} -static void *_p_ofCylinderPrimitiveTo_p_of3dPrimitive(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((of3dPrimitive *) ((ofCylinderPrimitive *) x)); -} -static void *_p_ofConePrimitiveTo_p_of3dPrimitive(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((of3dPrimitive *) ((ofConePrimitive *) x)); -} -static void *_p_ofBoxPrimitiveTo_p_of3dPrimitive(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((of3dPrimitive *) ((ofBoxPrimitive *) x)); -} -static void *_p_ofVideoPlayerTo_p_ofBaseVideoPlayer(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseVideoPlayer *) ((ofVideoPlayer *) x)); -} -static void *_p_of3dPrimitiveTo_p_ofNode(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofNode *) ((of3dPrimitive *) x)); -} -static void *_p_ofPlanePrimitiveTo_p_ofNode(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofNode *) (of3dPrimitive *) ((ofPlanePrimitive *) x)); -} -static void *_p_ofSpherePrimitiveTo_p_ofNode(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofNode *) (of3dPrimitive *) ((ofSpherePrimitive *) x)); -} -static void *_p_ofIcoSpherePrimitiveTo_p_ofNode(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofNode *) (of3dPrimitive *) ((ofIcoSpherePrimitive *) x)); -} -static void *_p_ofCylinderPrimitiveTo_p_ofNode(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofNode *) (of3dPrimitive *) ((ofCylinderPrimitive *) x)); -} -static void *_p_ofConePrimitiveTo_p_ofNode(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofNode *) (of3dPrimitive *) ((ofConePrimitive *) x)); -} -static void *_p_ofBoxPrimitiveTo_p_ofNode(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofNode *) (of3dPrimitive *) ((ofBoxPrimitive *) x)); -} -static void *_p_ofEasyCamTo_p_ofNode(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofNode *) (ofCamera *) ((ofEasyCam *) x)); -} -static void *_p_ofLightTo_p_ofNode(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofNode *) ((ofLight *) x)); -} -static void *_p_ofCameraTo_p_ofNode(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofNode *) ((ofCamera *) x)); -} -static void *_p_ofConsoleLoggerChannelTo_p_ofBaseLoggerChannel(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseLoggerChannel *) ((ofConsoleLoggerChannel *) x)); -} -static void *_p_ofFileLoggerChannelTo_p_ofBaseLoggerChannel(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseLoggerChannel *) ((ofFileLoggerChannel *) x)); -} -static void *_p_ofBaseVideoDrawsTo_p_ofBaseVideo(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseVideo *) ((ofBaseVideoDraws *) x)); -} -static void *_p_ofBaseVideoGrabberTo_p_ofBaseVideo(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseVideo *) ((ofBaseVideoGrabber *) x)); -} -static void *_p_ofVideoGrabberTo_p_ofBaseVideo(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseVideo *) (ofBaseVideoGrabber *) ((ofVideoGrabber *) x)); -} -static void *_p_ofBaseVideoPlayerTo_p_ofBaseVideo(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseVideo *) ((ofBaseVideoPlayer *) x)); -} -static void *_p_ofVideoPlayerTo_p_ofBaseVideo(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseVideo *) (ofBaseVideoPlayer *) ((ofVideoPlayer *) x)); -} -static void *_p_ofVboMeshTo_p_ofMesh(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofMesh *) ((ofVboMesh *) x)); -} -static void *_p_ofFileTo_p_fstream(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((fstream *) ((ofFile *) x)); -} -static void *_p_ofAbstractImageTo_p_ofBaseHasTexture(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseHasTexture *) ((ofAbstractImage *) x)); -} -static void *_p_ofBaseVideoDrawsTo_p_ofBaseHasTexture(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseHasTexture *) (ofBaseHasTexturePlanes *) ((ofBaseVideoDraws *) x)); -} -static void *_p_ofVideoGrabberTo_p_ofBaseHasTexture(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseHasTexture *) (ofBaseHasTexturePlanes *)(ofBaseVideoDraws *) ((ofVideoGrabber *) x)); -} -static void *_p_ofFboTo_p_ofBaseHasTexture(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseHasTexture *) ((ofFbo *) x)); -} -static void *_p_ofBaseHasTexturePlanesTo_p_ofBaseHasTexture(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseHasTexture *) ((ofBaseHasTexturePlanes *) x)); -} -static void *_p_ofVideoPlayerTo_p_ofBaseHasTexture(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseHasTexture *) (ofBaseHasTexturePlanes *)(ofBaseVideoDraws *) ((ofVideoPlayer *) x)); -} -static void *_p_ofXmlTo_p_ofBaseFileSerializer(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseFileSerializer *) ((ofXml *) x)); -} -static void *_p_ofBaseFileSerializerTo_p_ofBaseSerializer(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseSerializer *) ((ofBaseFileSerializer *) x)); -} -static void *_p_ofXmlTo_p_ofBaseSerializer(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseSerializer *) (ofBaseFileSerializer *) ((ofXml *) x)); -} -static void *_p_ofBaseGLRendererTo_p_ofBaseRenderer(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseRenderer *) ((ofBaseGLRenderer *) x)); -} -static void *_p_ofKeyEventArgsTo_p_ofEventArgs(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofEventArgs *) ((ofKeyEventArgs *) x)); -} -static void *_p_ofMouseEventArgsTo_p_ofEventArgs(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofEventArgs *) ((ofMouseEventArgs *) x)); -} -static void *_p_ofTouchEventArgsTo_p_ofEventArgs(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofEventArgs *) ((ofTouchEventArgs *) x)); -} -static void *_p_ofResizeEventArgsTo_p_ofEventArgs(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofEventArgs *) ((ofResizeEventArgs *) x)); -} -static void *_p_ofMessageTo_p_ofEventArgs(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofEventArgs *) ((ofMessage *) x)); -} -static void *_p_ofAbstractImageTo_p_ofBaseDraws(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseDraws *) ((ofAbstractImage *) x)); -} -static void *_p_ofBaseVideoDrawsTo_p_ofBaseDraws(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseDraws *) ((ofBaseVideoDraws *) x)); -} -static void *_p_ofVideoGrabberTo_p_ofBaseDraws(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseDraws *) (ofBaseVideoDraws *) ((ofVideoGrabber *) x)); -} -static void *_p_ofTextureTo_p_ofBaseDraws(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseDraws *) ((ofTexture *) x)); -} -static void *_p_ofFboTo_p_ofBaseDraws(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseDraws *) ((ofFbo *) x)); -} -static void *_p_ofVideoPlayerTo_p_ofBaseDraws(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseDraws *) (ofBaseVideoDraws *) ((ofVideoPlayer *) x)); -} -static void *_p_ofVideoGrabberTo_p_ofBaseVideoGrabber(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseVideoGrabber *) ((ofVideoGrabber *) x)); -} -static void *_p_ofVideoGrabberTo_p_ofBaseVideoDraws(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseVideoDraws *) ((ofVideoGrabber *) x)); -} -static void *_p_ofVideoPlayerTo_p_ofBaseVideoDraws(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseVideoDraws *) ((ofVideoPlayer *) x)); -} -static void *_p_ofLogErrorTo_p_ofLog(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofLog *) ((ofLogError *) x)); -} -static void *_p_ofLogNoticeTo_p_ofLog(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofLog *) ((ofLogNotice *) x)); -} -static void *_p_ofLogFatalErrorTo_p_ofLog(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofLog *) ((ofLogFatalError *) x)); -} -static void *_p_ofLogVerboseTo_p_ofLog(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofLog *) ((ofLogVerbose *) x)); -} -static void *_p_ofLogWarningTo_p_ofLog(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofLog *) ((ofLogWarning *) x)); -} -static void *_p_ofBaseVideoDrawsTo_p_ofBaseHasPixels(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseHasPixels *) (ofBaseVideo *) ((ofBaseVideoDraws *) x)); -} -static void *_p_ofBaseVideoGrabberTo_p_ofBaseHasPixels(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseHasPixels *) (ofBaseVideo *) ((ofBaseVideoGrabber *) x)); -} -static void *_p_ofVideoGrabberTo_p_ofBaseHasPixels(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseHasPixels *) (ofBaseVideo *)(ofBaseVideoGrabber *) ((ofVideoGrabber *) x)); -} -static void *_p_ofBaseVideoTo_p_ofBaseHasPixels(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseHasPixels *) ((ofBaseVideo *) x)); -} -static void *_p_ofBaseVideoPlayerTo_p_ofBaseHasPixels(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseHasPixels *) (ofBaseVideo *) ((ofBaseVideoPlayer *) x)); -} -static void *_p_ofVideoPlayerTo_p_ofBaseHasPixels(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseHasPixels *) (ofBaseVideo *)(ofBaseVideoPlayer *) ((ofVideoPlayer *) x)); -} -static void *_p_ofImage_T_unsigned_short_tTo_p_ofBaseImage_T_unsigned_short_t(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseImage_< unsigned short > *) ((ofImage_< unsigned short > *) x)); -} -static void *_p_ofBaseVideoDrawsTo_p_ofBaseUpdates(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseUpdates *) (ofBaseVideo *) ((ofBaseVideoDraws *) x)); -} -static void *_p_ofBaseVideoGrabberTo_p_ofBaseUpdates(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseUpdates *) (ofBaseVideo *) ((ofBaseVideoGrabber *) x)); -} -static void *_p_ofVideoGrabberTo_p_ofBaseUpdates(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseUpdates *) (ofBaseVideo *)(ofBaseVideoGrabber *) ((ofVideoGrabber *) x)); -} -static void *_p_ofBaseVideoTo_p_ofBaseUpdates(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseUpdates *) ((ofBaseVideo *) x)); -} -static void *_p_ofBaseVideoPlayerTo_p_ofBaseUpdates(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseUpdates *) (ofBaseVideo *) ((ofBaseVideoPlayer *) x)); -} -static void *_p_ofVideoPlayerTo_p_ofBaseUpdates(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseUpdates *) (ofBaseVideo *)(ofBaseVideoPlayer *) ((ofVideoPlayer *) x)); -} -static swig_type_info _swigt__p_GLintptr = {"_p_GLintptr", "GLintptr *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_GLsizei = {"_p_GLsizei", "GLsizei *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_GLsizeiptr = {"_p_GLsizeiptr", "GLsizeiptr *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_double = {"_p_double", "double *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_float = {"_p_float", "float *|GLfloat *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_fstream = {"_p_fstream", "fstream *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_int = {"_p_int", "int *|GLint *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_long_long = {"_p_long_long", "int64_t *|long long *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_of3dPrimitive = {"_p_of3dPrimitive", "of3dPrimitive *", 0, 0, (void*)&_wrap_class_3dPrimitive, 0}; -static swig_type_info _swigt__p_ofAbstractParameter = {"_p_ofAbstractParameter", "ofAbstractParameter *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofAppBaseWindow = {"_p_ofAppBaseWindow", "ofAppBaseWindow *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofBaseApp = {"_p_ofBaseApp", "ofSimpleApp *|ofBaseApp *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofBaseDraws = {"_p_ofBaseDraws", "ofBaseDraws *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofAbstractImage = {"_p_ofAbstractImage", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_ofBaseFileSerializer = {"_p_ofBaseFileSerializer", "ofBaseFileSerializer *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofBaseHasPixels = {"_p_ofBaseHasPixels", "ofBaseHasPixels *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofBaseHasTexture = {"_p_ofBaseHasTexture", "ofBaseHasTexture *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofBaseHasTexturePlanes = {"_p_ofBaseHasTexturePlanes", "ofBaseHasTexturePlanes *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofBaseImage_T_float_t = {"_p_ofBaseImage_T_float_t", "ofBaseImage_< float > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofBaseImage_T_unsigned_char_t = {"_p_ofBaseImage_T_unsigned_char_t", "ofBaseImage_< unsigned char > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofBaseImage_T_unsigned_short_t = {"_p_ofBaseImage_T_unsigned_short_t", "ofBaseImage_< unsigned short > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofBaseLoggerChannel = {"_p_ofBaseLoggerChannel", "ofBaseLoggerChannel *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofConsoleLoggerChannel = {"_p_ofConsoleLoggerChannel", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_ofFileLoggerChannel = {"_p_ofFileLoggerChannel", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_ofBaseMaterial = {"_p_ofBaseMaterial", "ofBaseMaterial *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofBaseRenderer = {"_p_ofBaseRenderer", "ofBaseRenderer *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofBaseGLRenderer = {"_p_ofBaseGLRenderer", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_ofBaseSerializer = {"_p_ofBaseSerializer", "ofBaseSerializer *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofBaseSoundInput = {"_p_ofBaseSoundInput", "ofBaseSoundInput *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofBaseSoundOutput = {"_p_ofBaseSoundOutput", "ofBaseSoundOutput *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofBaseSoundPlayer = {"_p_ofBaseSoundPlayer", "ofBaseSoundPlayer *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofBaseUpdates = {"_p_ofBaseUpdates", "ofBaseUpdates *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofBaseVideo = {"_p_ofBaseVideo", "ofBaseVideo *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofBaseVideoDraws = {"_p_ofBaseVideoDraws", "ofBaseVideoDraws *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofBaseVideoGrabber = {"_p_ofBaseVideoGrabber", "ofBaseVideoGrabber *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofBaseVideoPlayer = {"_p_ofBaseVideoPlayer", "ofBaseVideoPlayer *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofBoxPrimitive = {"_p_ofBoxPrimitive", "ofBoxPrimitive *", 0, 0, (void*)&_wrap_class_BoxPrimitive, 0}; -static swig_type_info _swigt__p_ofBuffer = {"_p_ofBuffer", "ofBuffer *", 0, 0, (void*)&_wrap_class_Buffer, 0}; -static swig_type_info _swigt__p_ofBufferObject = {"_p_ofBufferObject", "ofBufferObject *", 0, 0, (void*)&_wrap_class_BufferObject, 0}; -static swig_type_info _swigt__p_ofCamera = {"_p_ofCamera", "ofCamera *", 0, 0, (void*)&_wrap_class_Camera, 0}; -static swig_type_info _swigt__p_ofColor_T_float_t = {"_p_ofColor_T_float_t", "ofColor_< float > *|ofFloatColor *", 0, 0, (void*)&_wrap_class_FloatColor, 0}; -static swig_type_info _swigt__p_ofColor_T_unsigned_char_t = {"_p_ofColor_T_unsigned_char_t", "ofColor_< unsigned char > *|ofColor *", 0, 0, (void*)&_wrap_class_Color, 0}; -static swig_type_info _swigt__p_ofColor_T_unsigned_short_t = {"_p_ofColor_T_unsigned_short_t", "ofColor_< unsigned short > *|ofShortColor *", 0, 0, (void*)&_wrap_class_ShortColor, 0}; -static swig_type_info _swigt__p_ofConePrimitive = {"_p_ofConePrimitive", "ofConePrimitive *", 0, 0, (void*)&_wrap_class_ConePrimitive, 0}; -static swig_type_info _swigt__p_ofCoreEvents = {"_p_ofCoreEvents", "ofCoreEvents *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofCylinderPrimitive = {"_p_ofCylinderPrimitive", "ofCylinderPrimitive *", 0, 0, (void*)&_wrap_class_CylinderPrimitive, 0}; -static swig_type_info _swigt__p_ofDirectory = {"_p_ofDirectory", "ofDirectory *", 0, 0, (void*)&_wrap_class_Directory, 0}; -static swig_type_info _swigt__p_ofDragInfo = {"_p_ofDragInfo", "ofDragInfo *", 0, 0, (void*)&_wrap_class_DragInfo, 0}; -static swig_type_info _swigt__p_ofEasyCam = {"_p_ofEasyCam", "ofEasyCam *", 0, 0, (void*)&_wrap_class_EasyCam, 0}; -static swig_type_info _swigt__p_ofEventArgs = {"_p_ofEventArgs", "ofEventArgs *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofKeyEventArgs = {"_p_ofKeyEventArgs", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_ofMouseEventArgs = {"_p_ofMouseEventArgs", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_ofResizeEventArgs = {"_p_ofResizeEventArgs", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_ofMessage = {"_p_ofMessage", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_ofEventT_ofHttpResponse_t = {"_p_ofEventT_ofHttpResponse_t", "ofEvent< ofHttpResponse > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofFbo = {"_p_ofFbo", "ofFbo *", 0, 0, (void*)&_wrap_class_Fbo, 0}; -static swig_type_info _swigt__p_ofFbo__Settings = {"_p_ofFbo__Settings", "ofFbo::Settings *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofFile = {"_p_ofFile", "ofFile *", 0, 0, (void*)&_wrap_class_File, 0}; -static swig_type_info _swigt__p_ofFileDialogResult = {"_p_ofFileDialogResult", "ofFileDialogResult *", 0, 0, (void*)&_wrap_class_FileDialogResult, 0}; -static swig_type_info _swigt__p_ofFilePath = {"_p_ofFilePath", "ofFilePath *", 0, 0, (void*)&_wrap_class_FilePath, 0}; -static swig_type_info _swigt__p_ofFpsCounter = {"_p_ofFpsCounter", "ofFpsCounter *", 0, 0, (void*)&_wrap_class_FpsCounter, 0}; -static swig_type_info _swigt__p_ofHttpRequest = {"_p_ofHttpRequest", "ofHttpRequest *", 0, 0, (void*)&_wrap_class_HttpRequest, 0}; -static swig_type_info _swigt__p_ofHttpResponse = {"_p_ofHttpResponse", "ofHttpResponse *", 0, 0, (void*)&_wrap_class_HttpResponse, 0}; -static swig_type_info _swigt__p_ofIcoSpherePrimitive = {"_p_ofIcoSpherePrimitive", "ofIcoSpherePrimitive *", 0, 0, (void*)&_wrap_class_IcoSpherePrimitive, 0}; -static swig_type_info _swigt__p_ofImage_T_float_t = {"_p_ofImage_T_float_t", "ofFloatImage *|ofImage_< float > *", 0, 0, (void*)&_wrap_class_FloatImage, 0}; -static swig_type_info _swigt__p_ofImage_T_unsigned_char_t = {"_p_ofImage_T_unsigned_char_t", "ofImage *|ofImage_< unsigned char > *", 0, 0, (void*)&_wrap_class_Image, 0}; -static swig_type_info _swigt__p_ofImage_T_unsigned_short_t = {"_p_ofImage_T_unsigned_short_t", "ofImage_< unsigned short > *|ofShortImage *", 0, 0, (void*)&_wrap_class_ShortImage, 0}; -static swig_type_info _swigt__p_ofLight = {"_p_ofLight", "ofLight *", 0, 0, (void*)&_wrap_class_Light, 0}; -static swig_type_info _swigt__p_ofLog = {"_p_ofLog", "ofLog *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofLogError = {"_p_ofLogError", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_ofLogNotice = {"_p_ofLogNotice", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_ofLogFatalError = {"_p_ofLogFatalError", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_ofLogVerbose = {"_p_ofLogVerbose", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_ofLogWarning = {"_p_ofLogWarning", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_ofMaterial = {"_p_ofMaterial", "ofMaterial *", 0, 0, (void*)&_wrap_class_Material, 0}; -static swig_type_info _swigt__p_ofMatrix3x3 = {"_p_ofMatrix3x3", "ofMatrix3x3 *", 0, 0, (void*)&_wrap_class_Matrix3x3, 0}; -static swig_type_info _swigt__p_ofMatrix4x4 = {"_p_ofMatrix4x4", "ofMatrix4x4 *", 0, 0, (void*)&_wrap_class_Matrix4x4, 0}; -static swig_type_info _swigt__p_ofMatrixStack = {"_p_ofMatrixStack", "ofMatrixStack *", 0, 0, (void*)&_wrap_class_MatrixStack, 0}; -static swig_type_info _swigt__p_ofMesh = {"_p_ofMesh", "ofMesh *", 0, 0, (void*)&_wrap_class_Mesh, 0}; -static swig_type_info _swigt__p_ofMeshFace = {"_p_ofMeshFace", "ofMeshFace *", 0, 0, (void*)&_wrap_class_MeshFace, 0}; -static swig_type_info _swigt__p_ofNode = {"_p_ofNode", "ofNode *", 0, 0, (void*)&_wrap_class_Node, 0}; -static swig_type_info _swigt__p_ofParameterGroup = {"_p_ofParameterGroup", "ofParameterGroup *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofPath = {"_p_ofPath", "ofTTFCharacter *|ofPath *", 0, 0, (void*)&_wrap_class_Path, 0}; -static swig_type_info _swigt__p_ofPixels_T_float_t = {"_p_ofPixels_T_float_t", "ofPixels_< float > *|ofFloatPixels *", 0, 0, (void*)&_wrap_class_FloatPixels, 0}; -static swig_type_info _swigt__p_ofPixels_T_unsigned_char_t = {"_p_ofPixels_T_unsigned_char_t", "ofPixels_< unsigned char > *|ofPixels *", 0, 0, (void*)&_wrap_class_Pixels, 0}; -static swig_type_info _swigt__p_ofPixels_T_unsigned_short_t = {"_p_ofPixels_T_unsigned_short_t", "ofPixels_< unsigned short > *|ofShortPixels *", 0, 0, (void*)&_wrap_class_ShortPixels, 0}; -static swig_type_info _swigt__p_ofPlanePrimitive = {"_p_ofPlanePrimitive", "ofPlanePrimitive *", 0, 0, (void*)&_wrap_class_PlanePrimitive, 0}; -static swig_type_info _swigt__p_ofPolyline = {"_p_ofPolyline", "ofPolyline *", 0, 0, (void*)&_wrap_class_Polyline, 0}; -static swig_type_info _swigt__p_ofQuaternion = {"_p_ofQuaternion", "ofQuaternion *", 0, 0, (void*)&_wrap_class_Quaternion, 0}; -static swig_type_info _swigt__p_ofRectangle = {"_p_ofRectangle", "ofRectangle *", 0, 0, (void*)&_wrap_class_Rectangle, 0}; -static swig_type_info _swigt__p_ofSerialDeviceInfo = {"_p_ofSerialDeviceInfo", "ofSerialDeviceInfo *", 0, 0, (void*)&_wrap_class_SerialDeviceInfo, 0}; -static swig_type_info _swigt__p_ofShader = {"_p_ofShader", "ofShader *", 0, 0, (void*)&_wrap_class_Shader, 0}; -static swig_type_info _swigt__p_ofSoundDevice = {"_p_ofSoundDevice", "ofSoundDevice *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofSoundPlayer = {"_p_ofSoundPlayer", "ofSoundPlayer *", 0, 0, (void*)&_wrap_class_SoundPlayer, 0}; -static swig_type_info _swigt__p_ofSoundStream = {"_p_ofSoundStream", "ofSoundStream *", 0, 0, (void*)&_wrap_class_SoundStream, 0}; -static swig_type_info _swigt__p_ofSpherePrimitive = {"_p_ofSpherePrimitive", "ofSpherePrimitive *", 0, 0, (void*)&_wrap_class_SpherePrimitive, 0}; -static swig_type_info _swigt__p_ofStyle = {"_p_ofStyle", "ofStyle *", 0, 0, (void*)&_wrap_class_Style, 0}; -static swig_type_info _swigt__p_ofTexture = {"_p_ofTexture", "ofTexture *", 0, 0, (void*)&_wrap_class_Texture, 0}; -static swig_type_info _swigt__p_ofTextureData = {"_p_ofTextureData", "ofTextureData *", 0, 0, (void*)&_wrap_class_TextureData, 0}; -static swig_type_info _swigt__p_ofTouchEventArgs = {"_p_ofTouchEventArgs", "ofTouchEventArgs *", 0, 0, (void*)&_wrap_class_TouchEventArgs, 0}; -static swig_type_info _swigt__p_ofTrueTypeFont = {"_p_ofTrueTypeFont", "ofTrueTypeFont *", 0, 0, (void*)&_wrap_class_TrueTypeFont, 0}; -static swig_type_info _swigt__p_ofURLFileLoader = {"_p_ofURLFileLoader", "ofURLFileLoader *", 0, 0, (void*)&_wrap_class_URLFileLoader, 0}; -static swig_type_info _swigt__p_ofVbo = {"_p_ofVbo", "ofVbo *", 0, 0, (void*)&_wrap_class_Vbo, 0}; -static swig_type_info _swigt__p_ofVboMesh = {"_p_ofVboMesh", "ofVboMesh *", 0, 0, (void*)&_wrap_class_VboMesh, 0}; -static swig_type_info _swigt__p_ofVec2f = {"_p_ofVec2f", "ofVec2f *", 0, 0, (void*)&_wrap_class_Vec2f, 0}; -static swig_type_info _swigt__p_ofVec3f = {"_p_ofVec3f", "ofPoint *|ofVec3f *", 0, 0, (void*)&_wrap_class_Vec3f, 0}; -static swig_type_info _swigt__p_ofVec4f = {"_p_ofVec4f", "ofVec4f *", 0, 0, (void*)&_wrap_class_Vec4f, 0}; -static swig_type_info _swigt__p_ofVideoDevice = {"_p_ofVideoDevice", "ofVideoDevice *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofVideoGrabber = {"_p_ofVideoGrabber", "ofVideoGrabber *", 0, 0, (void*)&_wrap_class_VideoGrabber, 0}; -static swig_type_info _swigt__p_ofVideoPlayer = {"_p_ofVideoPlayer", "ofVideoPlayer *", 0, 0, (void*)&_wrap_class_VideoPlayer, 0}; -static swig_type_info _swigt__p_ofXml = {"_p_ofXml", "ofXml *", 0, 0, (void*)&_wrap_class_Xml, 0}; -static swig_type_info _swigt__p_shared_ptrT_ofBaseRenderer_t = {"_p_shared_ptrT_ofBaseRenderer_t", "shared_ptr< ofBaseRenderer > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_shared_ptrT_ofBaseSoundPlayer_t = {"_p_shared_ptrT_ofBaseSoundPlayer_t", "shared_ptr< ofBaseSoundPlayer > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_shared_ptrT_ofBaseSoundStream_t = {"_p_shared_ptrT_ofBaseSoundStream_t", "shared_ptr< ofBaseSoundStream > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_shared_ptrT_ofBaseVideoGrabber_t = {"_p_shared_ptrT_ofBaseVideoGrabber_t", "shared_ptr< ofBaseVideoGrabber > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_std__filesystem__path = {"_p_std__filesystem__path", "std::filesystem::path *", 0, 0, (void*)&_wrap_class_path, 0}; -static swig_type_info _swigt__p_std__mapT_std__string_std__string_t = {"_p_std__mapT_std__string_std__string_t", "std::map< std::string,std::string > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_std__string = {"_p_std__string", "std::string *", 0, 0, (void*)&_wrap_class_string, 0}; -static swig_type_info _swigt__p_std__vectorT_float_t = {"_p_std__vectorT_float_t", "std::vector< float > *", 0, 0, (void*)&_wrap_class_FloatVector, 0}; -static swig_type_info _swigt__p_std__vectorT_int_t = {"_p_std__vectorT_int_t", "std::vector< int > *", 0, 0, (void*)&_wrap_class_IntVector, 0}; -static swig_type_info _swigt__p_std__vectorT_ofColor_T_float_t_t = {"_p_std__vectorT_ofColor_T_float_t_t", "std::vector< ofColor_< float > > *|std::vector< ofFloatColor > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_std__vectorT_ofFile_t = {"_p_std__vectorT_ofFile_t", "std::vector< ofFile > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_std__vectorT_ofMeshFace_t = {"_p_std__vectorT_ofMeshFace_t", "std::vector< ofMeshFace > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_std__vectorT_ofPath__Command_t = {"_p_std__vectorT_ofPath__Command_t", "std::vector< ofPath::Command > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_std__vectorT_ofPath_t = {"_p_std__vectorT_ofPath_t", "std::vector< ofTTFCharacter > *|std::vector< ofPath > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_std__vectorT_ofPolyline_t = {"_p_std__vectorT_ofPolyline_t", "std::vector< ofPolyline > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_std__vectorT_ofSoundDevice_t = {"_p_std__vectorT_ofSoundDevice_t", "std::vector< ofSoundDevice > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_std__vectorT_ofTexture_t = {"_p_std__vectorT_ofTexture_t", "std::vector< ofTexture > *", 0, 0, (void*)&_wrap_class_TextureVector, 0}; -static swig_type_info _swigt__p_std__vectorT_ofVec2f_t = {"_p_std__vectorT_ofVec2f_t", "std::vector< ofVec2f > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_std__vectorT_ofVec3f_t = {"_p_std__vectorT_ofVec3f_t", "std::vector< ofVec3f > *|std::vector< ofPoint > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_std__vectorT_ofVideoDevice_t = {"_p_std__vectorT_ofVideoDevice_t", "std::vector< ofVideoDevice > *", 0, 0, (void*)&_wrap_class_VideoDeviceVector, 0}; -static swig_type_info _swigt__p_std__vectorT_std__string_t = {"_p_std__vectorT_std__string_t", "std::vector< std::string > *", 0, 0, (void*)&_wrap_class_StringVector, 0}; -static swig_type_info _swigt__p_std__vectorT_unsigned_char_t = {"_p_std__vectorT_unsigned_char_t", "std::vector< unsigned char > *", 0, 0, (void*)&_wrap_class_UCharVector, 0}; -static swig_type_info _swigt__p_std__vectorT_unsigned_short_t = {"_p_std__vectorT_unsigned_short_t", "std::vector< unsigned short > *|std::vector< ofIndexType > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_std__vectorT_weak_ptrT_ofLight__Data_t_t = {"_p_std__vectorT_weak_ptrT_ofLight__Data_t_t", "std::vector< weak_ptr< ofLight::Data > > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "size_t *|unsigned int *|GLuint *|GLenum *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_unsigned_long_long = {"_p_unsigned_long_long", "uint64_t *|unsigned long long *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_unsigned_short = {"_p_unsigned_short", "ofIndexType *|TESSindex *|unsigned short *", 0, 0, (void*)0, 0}; - -static swig_type_info *swig_type_initial[] = { - &_swigt__p_GLintptr, - &_swigt__p_GLsizei, - &_swigt__p_GLsizeiptr, - &_swigt__p_double, - &_swigt__p_float, - &_swigt__p_fstream, - &_swigt__p_int, - &_swigt__p_long_long, - &_swigt__p_of3dPrimitive, - &_swigt__p_ofAbstractImage, - &_swigt__p_ofAbstractParameter, - &_swigt__p_ofAppBaseWindow, - &_swigt__p_ofBaseApp, - &_swigt__p_ofBaseDraws, - &_swigt__p_ofBaseFileSerializer, - &_swigt__p_ofBaseGLRenderer, - &_swigt__p_ofBaseHasPixels, - &_swigt__p_ofBaseHasTexture, - &_swigt__p_ofBaseHasTexturePlanes, - &_swigt__p_ofBaseImage_T_float_t, - &_swigt__p_ofBaseImage_T_unsigned_char_t, - &_swigt__p_ofBaseImage_T_unsigned_short_t, - &_swigt__p_ofBaseLoggerChannel, - &_swigt__p_ofBaseMaterial, - &_swigt__p_ofBaseRenderer, - &_swigt__p_ofBaseSerializer, - &_swigt__p_ofBaseSoundInput, - &_swigt__p_ofBaseSoundOutput, - &_swigt__p_ofBaseSoundPlayer, - &_swigt__p_ofBaseUpdates, - &_swigt__p_ofBaseVideo, - &_swigt__p_ofBaseVideoDraws, - &_swigt__p_ofBaseVideoGrabber, - &_swigt__p_ofBaseVideoPlayer, - &_swigt__p_ofBoxPrimitive, - &_swigt__p_ofBuffer, - &_swigt__p_ofBufferObject, - &_swigt__p_ofCamera, - &_swigt__p_ofColor_T_float_t, - &_swigt__p_ofColor_T_unsigned_char_t, - &_swigt__p_ofColor_T_unsigned_short_t, - &_swigt__p_ofConePrimitive, - &_swigt__p_ofConsoleLoggerChannel, - &_swigt__p_ofCoreEvents, - &_swigt__p_ofCylinderPrimitive, - &_swigt__p_ofDirectory, - &_swigt__p_ofDragInfo, - &_swigt__p_ofEasyCam, - &_swigt__p_ofEventArgs, - &_swigt__p_ofEventT_ofHttpResponse_t, - &_swigt__p_ofFbo, - &_swigt__p_ofFbo__Settings, - &_swigt__p_ofFile, - &_swigt__p_ofFileDialogResult, - &_swigt__p_ofFileLoggerChannel, - &_swigt__p_ofFilePath, - &_swigt__p_ofFpsCounter, - &_swigt__p_ofHttpRequest, - &_swigt__p_ofHttpResponse, - &_swigt__p_ofIcoSpherePrimitive, - &_swigt__p_ofImage_T_float_t, - &_swigt__p_ofImage_T_unsigned_char_t, - &_swigt__p_ofImage_T_unsigned_short_t, - &_swigt__p_ofKeyEventArgs, - &_swigt__p_ofLight, - &_swigt__p_ofLog, - &_swigt__p_ofLogError, - &_swigt__p_ofLogFatalError, - &_swigt__p_ofLogNotice, - &_swigt__p_ofLogVerbose, - &_swigt__p_ofLogWarning, - &_swigt__p_ofMaterial, - &_swigt__p_ofMatrix3x3, - &_swigt__p_ofMatrix4x4, - &_swigt__p_ofMatrixStack, - &_swigt__p_ofMesh, - &_swigt__p_ofMeshFace, - &_swigt__p_ofMessage, - &_swigt__p_ofMouseEventArgs, - &_swigt__p_ofNode, - &_swigt__p_ofParameterGroup, - &_swigt__p_ofPath, - &_swigt__p_ofPixels_T_float_t, - &_swigt__p_ofPixels_T_unsigned_char_t, - &_swigt__p_ofPixels_T_unsigned_short_t, - &_swigt__p_ofPlanePrimitive, - &_swigt__p_ofPolyline, - &_swigt__p_ofQuaternion, - &_swigt__p_ofRectangle, - &_swigt__p_ofResizeEventArgs, - &_swigt__p_ofSerialDeviceInfo, - &_swigt__p_ofShader, - &_swigt__p_ofSoundDevice, - &_swigt__p_ofSoundPlayer, - &_swigt__p_ofSoundStream, - &_swigt__p_ofSpherePrimitive, - &_swigt__p_ofStyle, - &_swigt__p_ofTexture, - &_swigt__p_ofTextureData, - &_swigt__p_ofTouchEventArgs, - &_swigt__p_ofTrueTypeFont, - &_swigt__p_ofURLFileLoader, - &_swigt__p_ofVbo, - &_swigt__p_ofVboMesh, - &_swigt__p_ofVec2f, - &_swigt__p_ofVec3f, - &_swigt__p_ofVec4f, - &_swigt__p_ofVideoDevice, - &_swigt__p_ofVideoGrabber, - &_swigt__p_ofVideoPlayer, - &_swigt__p_ofXml, - &_swigt__p_shared_ptrT_ofBaseRenderer_t, - &_swigt__p_shared_ptrT_ofBaseSoundPlayer_t, - &_swigt__p_shared_ptrT_ofBaseSoundStream_t, - &_swigt__p_shared_ptrT_ofBaseVideoGrabber_t, - &_swigt__p_std__filesystem__path, - &_swigt__p_std__mapT_std__string_std__string_t, - &_swigt__p_std__string, - &_swigt__p_std__vectorT_float_t, - &_swigt__p_std__vectorT_int_t, - &_swigt__p_std__vectorT_ofColor_T_float_t_t, - &_swigt__p_std__vectorT_ofFile_t, - &_swigt__p_std__vectorT_ofMeshFace_t, - &_swigt__p_std__vectorT_ofPath__Command_t, - &_swigt__p_std__vectorT_ofPath_t, - &_swigt__p_std__vectorT_ofPolyline_t, - &_swigt__p_std__vectorT_ofSoundDevice_t, - &_swigt__p_std__vectorT_ofTexture_t, - &_swigt__p_std__vectorT_ofVec2f_t, - &_swigt__p_std__vectorT_ofVec3f_t, - &_swigt__p_std__vectorT_ofVideoDevice_t, - &_swigt__p_std__vectorT_std__string_t, - &_swigt__p_std__vectorT_unsigned_char_t, - &_swigt__p_std__vectorT_unsigned_short_t, - &_swigt__p_std__vectorT_weak_ptrT_ofLight__Data_t_t, - &_swigt__p_unsigned_char, - &_swigt__p_unsigned_int, - &_swigt__p_unsigned_long_long, - &_swigt__p_unsigned_short, -}; - -static swig_cast_info _swigc__p_GLintptr[] = { {&_swigt__p_GLintptr, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_GLsizei[] = { {&_swigt__p_GLsizei, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_GLsizeiptr[] = { {&_swigt__p_GLsizeiptr, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_float[] = { {&_swigt__p_float, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_fstream[] = { {&_swigt__p_fstream, 0, 0, 0}, {&_swigt__p_ofFile, _p_ofFileTo_p_fstream, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_long_long[] = { {&_swigt__p_long_long, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_of3dPrimitive[] = { {&_swigt__p_of3dPrimitive, 0, 0, 0}, {&_swigt__p_ofPlanePrimitive, _p_ofPlanePrimitiveTo_p_of3dPrimitive, 0, 0}, {&_swigt__p_ofSpherePrimitive, _p_ofSpherePrimitiveTo_p_of3dPrimitive, 0, 0}, {&_swigt__p_ofIcoSpherePrimitive, _p_ofIcoSpherePrimitiveTo_p_of3dPrimitive, 0, 0}, {&_swigt__p_ofCylinderPrimitive, _p_ofCylinderPrimitiveTo_p_of3dPrimitive, 0, 0}, {&_swigt__p_ofConePrimitive, _p_ofConePrimitiveTo_p_of3dPrimitive, 0, 0}, {&_swigt__p_ofBoxPrimitive, _p_ofBoxPrimitiveTo_p_of3dPrimitive, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofAbstractParameter[] = { {&_swigt__p_ofAbstractParameter, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofAppBaseWindow[] = { {&_swigt__p_ofAppBaseWindow, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofBaseApp[] = { {&_swigt__p_ofBaseApp, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofAbstractImage[] = {{&_swigt__p_ofAbstractImage, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofBaseDraws[] = { {&_swigt__p_ofAbstractImage, _p_ofAbstractImageTo_p_ofBaseDraws, 0, 0}, {&_swigt__p_ofBaseVideoDraws, _p_ofBaseVideoDrawsTo_p_ofBaseDraws, 0, 0}, {&_swigt__p_ofVideoGrabber, _p_ofVideoGrabberTo_p_ofBaseDraws, 0, 0}, {&_swigt__p_ofBaseDraws, 0, 0, 0}, {&_swigt__p_ofTexture, _p_ofTextureTo_p_ofBaseDraws, 0, 0}, {&_swigt__p_ofFbo, _p_ofFboTo_p_ofBaseDraws, 0, 0}, {&_swigt__p_ofVideoPlayer, _p_ofVideoPlayerTo_p_ofBaseDraws, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofBaseFileSerializer[] = { {&_swigt__p_ofXml, _p_ofXmlTo_p_ofBaseFileSerializer, 0, 0}, {&_swigt__p_ofBaseFileSerializer, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofBaseHasPixels[] = { {&_swigt__p_ofBaseVideoDraws, _p_ofBaseVideoDrawsTo_p_ofBaseHasPixels, 0, 0}, {&_swigt__p_ofVideoGrabber, _p_ofVideoGrabberTo_p_ofBaseHasPixels, 0, 0}, {&_swigt__p_ofBaseVideoGrabber, _p_ofBaseVideoGrabberTo_p_ofBaseHasPixels, 0, 0}, {&_swigt__p_ofBaseVideo, _p_ofBaseVideoTo_p_ofBaseHasPixels, 0, 0}, {&_swigt__p_ofBaseHasPixels, 0, 0, 0}, {&_swigt__p_ofVideoPlayer, _p_ofVideoPlayerTo_p_ofBaseHasPixels, 0, 0}, {&_swigt__p_ofBaseVideoPlayer, _p_ofBaseVideoPlayerTo_p_ofBaseHasPixels, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofBaseHasTexture[] = { {&_swigt__p_ofAbstractImage, _p_ofAbstractImageTo_p_ofBaseHasTexture, 0, 0}, {&_swigt__p_ofBaseVideoDraws, _p_ofBaseVideoDrawsTo_p_ofBaseHasTexture, 0, 0}, {&_swigt__p_ofVideoGrabber, _p_ofVideoGrabberTo_p_ofBaseHasTexture, 0, 0}, {&_swigt__p_ofBaseHasTexture, 0, 0, 0}, {&_swigt__p_ofFbo, _p_ofFboTo_p_ofBaseHasTexture, 0, 0}, {&_swigt__p_ofVideoPlayer, _p_ofVideoPlayerTo_p_ofBaseHasTexture, 0, 0}, {&_swigt__p_ofBaseHasTexturePlanes, _p_ofBaseHasTexturePlanesTo_p_ofBaseHasTexture, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofBaseHasTexturePlanes[] = { {&_swigt__p_ofBaseVideoDraws, _p_ofBaseVideoDrawsTo_p_ofBaseHasTexturePlanes, 0, 0}, {&_swigt__p_ofVideoGrabber, _p_ofVideoGrabberTo_p_ofBaseHasTexturePlanes, 0, 0}, {&_swigt__p_ofBaseHasTexturePlanes, 0, 0, 0}, {&_swigt__p_ofVideoPlayer, _p_ofVideoPlayerTo_p_ofBaseHasTexturePlanes, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofBaseImage_T_float_t[] = { {&_swigt__p_ofBaseImage_T_float_t, 0, 0, 0}, {&_swigt__p_ofImage_T_float_t, _p_ofImage_T_float_tTo_p_ofBaseImage_T_float_t, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofBaseImage_T_unsigned_char_t[] = { {&_swigt__p_ofBaseImage_T_unsigned_char_t, 0, 0, 0}, {&_swigt__p_ofImage_T_unsigned_char_t, _p_ofImage_T_unsigned_char_tTo_p_ofBaseImage_T_unsigned_char_t, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofBaseImage_T_unsigned_short_t[] = { {&_swigt__p_ofBaseImage_T_unsigned_short_t, 0, 0, 0}, {&_swigt__p_ofImage_T_unsigned_short_t, _p_ofImage_T_unsigned_short_tTo_p_ofBaseImage_T_unsigned_short_t, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofConsoleLoggerChannel[] = {{&_swigt__p_ofConsoleLoggerChannel, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofFileLoggerChannel[] = {{&_swigt__p_ofFileLoggerChannel, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofBaseLoggerChannel[] = { {&_swigt__p_ofBaseLoggerChannel, 0, 0, 0}, {&_swigt__p_ofConsoleLoggerChannel, _p_ofConsoleLoggerChannelTo_p_ofBaseLoggerChannel, 0, 0}, {&_swigt__p_ofFileLoggerChannel, _p_ofFileLoggerChannelTo_p_ofBaseLoggerChannel, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofBaseMaterial[] = { {&_swigt__p_ofBaseMaterial, 0, 0, 0}, {&_swigt__p_ofMaterial, _p_ofMaterialTo_p_ofBaseMaterial, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofBaseGLRenderer[] = {{&_swigt__p_ofBaseGLRenderer, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofBaseRenderer[] = { {&_swigt__p_ofBaseRenderer, 0, 0, 0}, {&_swigt__p_ofBaseGLRenderer, _p_ofBaseGLRendererTo_p_ofBaseRenderer, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofBaseSerializer[] = { {&_swigt__p_ofXml, _p_ofXmlTo_p_ofBaseSerializer, 0, 0}, {&_swigt__p_ofBaseSerializer, 0, 0, 0}, {&_swigt__p_ofBaseFileSerializer, _p_ofBaseFileSerializerTo_p_ofBaseSerializer, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofBaseSoundInput[] = { {&_swigt__p_ofBaseSoundInput, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofBaseSoundOutput[] = { {&_swigt__p_ofBaseSoundOutput, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofBaseSoundPlayer[] = { {&_swigt__p_ofBaseSoundPlayer, 0, 0, 0}, {&_swigt__p_ofSoundPlayer, _p_ofSoundPlayerTo_p_ofBaseSoundPlayer, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofBaseUpdates[] = { {&_swigt__p_ofBaseVideoDraws, _p_ofBaseVideoDrawsTo_p_ofBaseUpdates, 0, 0}, {&_swigt__p_ofVideoGrabber, _p_ofVideoGrabberTo_p_ofBaseUpdates, 0, 0}, {&_swigt__p_ofBaseVideoGrabber, _p_ofBaseVideoGrabberTo_p_ofBaseUpdates, 0, 0}, {&_swigt__p_ofBaseVideo, _p_ofBaseVideoTo_p_ofBaseUpdates, 0, 0}, {&_swigt__p_ofBaseUpdates, 0, 0, 0}, {&_swigt__p_ofVideoPlayer, _p_ofVideoPlayerTo_p_ofBaseUpdates, 0, 0}, {&_swigt__p_ofBaseVideoPlayer, _p_ofBaseVideoPlayerTo_p_ofBaseUpdates, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofBaseVideo[] = { {&_swigt__p_ofBaseVideoDraws, _p_ofBaseVideoDrawsTo_p_ofBaseVideo, 0, 0}, {&_swigt__p_ofVideoGrabber, _p_ofVideoGrabberTo_p_ofBaseVideo, 0, 0}, {&_swigt__p_ofBaseVideoGrabber, _p_ofBaseVideoGrabberTo_p_ofBaseVideo, 0, 0}, {&_swigt__p_ofBaseVideo, 0, 0, 0}, {&_swigt__p_ofVideoPlayer, _p_ofVideoPlayerTo_p_ofBaseVideo, 0, 0}, {&_swigt__p_ofBaseVideoPlayer, _p_ofBaseVideoPlayerTo_p_ofBaseVideo, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofBaseVideoDraws[] = { {&_swigt__p_ofBaseVideoDraws, 0, 0, 0}, {&_swigt__p_ofVideoGrabber, _p_ofVideoGrabberTo_p_ofBaseVideoDraws, 0, 0}, {&_swigt__p_ofVideoPlayer, _p_ofVideoPlayerTo_p_ofBaseVideoDraws, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofBaseVideoGrabber[] = { {&_swigt__p_ofBaseVideoGrabber, 0, 0, 0}, {&_swigt__p_ofVideoGrabber, _p_ofVideoGrabberTo_p_ofBaseVideoGrabber, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofBaseVideoPlayer[] = { {&_swigt__p_ofBaseVideoPlayer, 0, 0, 0}, {&_swigt__p_ofVideoPlayer, _p_ofVideoPlayerTo_p_ofBaseVideoPlayer, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofBoxPrimitive[] = { {&_swigt__p_ofBoxPrimitive, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofBuffer[] = { {&_swigt__p_ofBuffer, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofBufferObject[] = { {&_swigt__p_ofBufferObject, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofCamera[] = { {&_swigt__p_ofEasyCam, _p_ofEasyCamTo_p_ofCamera, 0, 0}, {&_swigt__p_ofCamera, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofColor_T_float_t[] = { {&_swigt__p_ofColor_T_float_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofColor_T_unsigned_char_t[] = { {&_swigt__p_ofColor_T_unsigned_char_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofColor_T_unsigned_short_t[] = { {&_swigt__p_ofColor_T_unsigned_short_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofConePrimitive[] = { {&_swigt__p_ofConePrimitive, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofCoreEvents[] = { {&_swigt__p_ofCoreEvents, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofCylinderPrimitive[] = { {&_swigt__p_ofCylinderPrimitive, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofDirectory[] = { {&_swigt__p_ofDirectory, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofDragInfo[] = { {&_swigt__p_ofDragInfo, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofEasyCam[] = { {&_swigt__p_ofEasyCam, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofKeyEventArgs[] = {{&_swigt__p_ofKeyEventArgs, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofMouseEventArgs[] = {{&_swigt__p_ofMouseEventArgs, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofResizeEventArgs[] = {{&_swigt__p_ofResizeEventArgs, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofMessage[] = {{&_swigt__p_ofMessage, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofEventArgs[] = { {&_swigt__p_ofEventArgs, 0, 0, 0}, {&_swigt__p_ofKeyEventArgs, _p_ofKeyEventArgsTo_p_ofEventArgs, 0, 0}, {&_swigt__p_ofMouseEventArgs, _p_ofMouseEventArgsTo_p_ofEventArgs, 0, 0}, {&_swigt__p_ofTouchEventArgs, _p_ofTouchEventArgsTo_p_ofEventArgs, 0, 0}, {&_swigt__p_ofResizeEventArgs, _p_ofResizeEventArgsTo_p_ofEventArgs, 0, 0}, {&_swigt__p_ofMessage, _p_ofMessageTo_p_ofEventArgs, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofEventT_ofHttpResponse_t[] = { {&_swigt__p_ofEventT_ofHttpResponse_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofFbo[] = { {&_swigt__p_ofFbo, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofFbo__Settings[] = { {&_swigt__p_ofFbo__Settings, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofFile[] = { {&_swigt__p_ofFile, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofFileDialogResult[] = { {&_swigt__p_ofFileDialogResult, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofFilePath[] = { {&_swigt__p_ofFilePath, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofFpsCounter[] = { {&_swigt__p_ofFpsCounter, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofHttpRequest[] = { {&_swigt__p_ofHttpRequest, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofHttpResponse[] = { {&_swigt__p_ofHttpResponse, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofIcoSpherePrimitive[] = { {&_swigt__p_ofIcoSpherePrimitive, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofImage_T_float_t[] = { {&_swigt__p_ofImage_T_float_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofImage_T_unsigned_char_t[] = { {&_swigt__p_ofImage_T_unsigned_char_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofImage_T_unsigned_short_t[] = { {&_swigt__p_ofImage_T_unsigned_short_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofLight[] = { {&_swigt__p_ofLight, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofLogError[] = {{&_swigt__p_ofLogError, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofLogNotice[] = {{&_swigt__p_ofLogNotice, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofLogFatalError[] = {{&_swigt__p_ofLogFatalError, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofLogVerbose[] = {{&_swigt__p_ofLogVerbose, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofLogWarning[] = {{&_swigt__p_ofLogWarning, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofLog[] = { {&_swigt__p_ofLogError, _p_ofLogErrorTo_p_ofLog, 0, 0}, {&_swigt__p_ofLogNotice, _p_ofLogNoticeTo_p_ofLog, 0, 0}, {&_swigt__p_ofLogFatalError, _p_ofLogFatalErrorTo_p_ofLog, 0, 0}, {&_swigt__p_ofLogVerbose, _p_ofLogVerboseTo_p_ofLog, 0, 0}, {&_swigt__p_ofLog, 0, 0, 0}, {&_swigt__p_ofLogWarning, _p_ofLogWarningTo_p_ofLog, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofMaterial[] = { {&_swigt__p_ofMaterial, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofMatrix3x3[] = { {&_swigt__p_ofMatrix3x3, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofMatrix4x4[] = { {&_swigt__p_ofMatrix4x4, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofMatrixStack[] = { {&_swigt__p_ofMatrixStack, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofMesh[] = { {&_swigt__p_ofMesh, 0, 0, 0}, {&_swigt__p_ofVboMesh, _p_ofVboMeshTo_p_ofMesh, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofMeshFace[] = { {&_swigt__p_ofMeshFace, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofNode[] = { {&_swigt__p_ofNode, 0, 0, 0}, {&_swigt__p_of3dPrimitive, _p_of3dPrimitiveTo_p_ofNode, 0, 0}, {&_swigt__p_ofPlanePrimitive, _p_ofPlanePrimitiveTo_p_ofNode, 0, 0}, {&_swigt__p_ofSpherePrimitive, _p_ofSpherePrimitiveTo_p_ofNode, 0, 0}, {&_swigt__p_ofIcoSpherePrimitive, _p_ofIcoSpherePrimitiveTo_p_ofNode, 0, 0}, {&_swigt__p_ofCylinderPrimitive, _p_ofCylinderPrimitiveTo_p_ofNode, 0, 0}, {&_swigt__p_ofConePrimitive, _p_ofConePrimitiveTo_p_ofNode, 0, 0}, {&_swigt__p_ofBoxPrimitive, _p_ofBoxPrimitiveTo_p_ofNode, 0, 0}, {&_swigt__p_ofEasyCam, _p_ofEasyCamTo_p_ofNode, 0, 0}, {&_swigt__p_ofLight, _p_ofLightTo_p_ofNode, 0, 0}, {&_swigt__p_ofCamera, _p_ofCameraTo_p_ofNode, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofParameterGroup[] = { {&_swigt__p_ofParameterGroup, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofPath[] = { {&_swigt__p_ofPath, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofPixels_T_float_t[] = { {&_swigt__p_ofPixels_T_float_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofPixels_T_unsigned_char_t[] = { {&_swigt__p_ofPixels_T_unsigned_char_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofPixels_T_unsigned_short_t[] = { {&_swigt__p_ofPixels_T_unsigned_short_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofPlanePrimitive[] = { {&_swigt__p_ofPlanePrimitive, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofPolyline[] = { {&_swigt__p_ofPolyline, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofQuaternion[] = { {&_swigt__p_ofQuaternion, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofRectangle[] = { {&_swigt__p_ofRectangle, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofSerialDeviceInfo[] = { {&_swigt__p_ofSerialDeviceInfo, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofShader[] = { {&_swigt__p_ofShader, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofSoundDevice[] = { {&_swigt__p_ofSoundDevice, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofSoundPlayer[] = { {&_swigt__p_ofSoundPlayer, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofSoundStream[] = { {&_swigt__p_ofSoundStream, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofSpherePrimitive[] = { {&_swigt__p_ofSpherePrimitive, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofStyle[] = { {&_swigt__p_ofStyle, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofTexture[] = { {&_swigt__p_ofTexture, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofTextureData[] = { {&_swigt__p_ofTextureData, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofTouchEventArgs[] = { {&_swigt__p_ofTouchEventArgs, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofTrueTypeFont[] = { {&_swigt__p_ofTrueTypeFont, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofURLFileLoader[] = { {&_swigt__p_ofURLFileLoader, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofVbo[] = { {&_swigt__p_ofVbo, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofVboMesh[] = { {&_swigt__p_ofVboMesh, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofVec2f[] = { {&_swigt__p_ofMouseEventArgs, _p_ofMouseEventArgsTo_p_ofVec2f, 0, 0}, {&_swigt__p_ofTouchEventArgs, _p_ofTouchEventArgsTo_p_ofVec2f, 0, 0}, {&_swigt__p_ofVec2f, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofVec3f[] = { {&_swigt__p_ofVec3f, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofVec4f[] = { {&_swigt__p_ofVec4f, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofVideoDevice[] = { {&_swigt__p_ofVideoDevice, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofVideoGrabber[] = { {&_swigt__p_ofVideoGrabber, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofVideoPlayer[] = { {&_swigt__p_ofVideoPlayer, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofXml[] = { {&_swigt__p_ofXml, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_shared_ptrT_ofBaseRenderer_t[] = { {&_swigt__p_shared_ptrT_ofBaseRenderer_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_shared_ptrT_ofBaseSoundPlayer_t[] = { {&_swigt__p_shared_ptrT_ofBaseSoundPlayer_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_shared_ptrT_ofBaseSoundStream_t[] = { {&_swigt__p_shared_ptrT_ofBaseSoundStream_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_shared_ptrT_ofBaseVideoGrabber_t[] = { {&_swigt__p_shared_ptrT_ofBaseVideoGrabber_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__filesystem__path[] = { {&_swigt__p_std__filesystem__path, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__mapT_std__string_std__string_t[] = { {&_swigt__p_std__mapT_std__string_std__string_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__string[] = { {&_swigt__p_std__string, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__vectorT_float_t[] = { {&_swigt__p_std__vectorT_float_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__vectorT_int_t[] = { {&_swigt__p_std__vectorT_int_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__vectorT_ofColor_T_float_t_t[] = { {&_swigt__p_std__vectorT_ofColor_T_float_t_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__vectorT_ofFile_t[] = { {&_swigt__p_std__vectorT_ofFile_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__vectorT_ofMeshFace_t[] = { {&_swigt__p_std__vectorT_ofMeshFace_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__vectorT_ofPath__Command_t[] = { {&_swigt__p_std__vectorT_ofPath__Command_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__vectorT_ofPath_t[] = { {&_swigt__p_std__vectorT_ofPath_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__vectorT_ofPolyline_t[] = { {&_swigt__p_std__vectorT_ofPolyline_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__vectorT_ofSoundDevice_t[] = { {&_swigt__p_std__vectorT_ofSoundDevice_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__vectorT_ofTexture_t[] = { {&_swigt__p_std__vectorT_ofTexture_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__vectorT_ofVec2f_t[] = { {&_swigt__p_std__vectorT_ofVec2f_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__vectorT_ofVec3f_t[] = { {&_swigt__p_std__vectorT_ofVec3f_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__vectorT_ofVideoDevice_t[] = { {&_swigt__p_std__vectorT_ofVideoDevice_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__vectorT_std__string_t[] = { {&_swigt__p_std__vectorT_std__string_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__vectorT_unsigned_char_t[] = { {&_swigt__p_std__vectorT_unsigned_char_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__vectorT_unsigned_short_t[] = { {&_swigt__p_std__vectorT_unsigned_short_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__vectorT_weak_ptrT_ofLight__Data_t_t[] = { {&_swigt__p_std__vectorT_weak_ptrT_ofLight__Data_t_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_unsigned_long_long[] = { {&_swigt__p_unsigned_long_long, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_unsigned_short[] = { {&_swigt__p_unsigned_short, 0, 0, 0},{0, 0, 0, 0}}; - -static swig_cast_info *swig_cast_initial[] = { - _swigc__p_GLintptr, - _swigc__p_GLsizei, - _swigc__p_GLsizeiptr, - _swigc__p_double, - _swigc__p_float, - _swigc__p_fstream, - _swigc__p_int, - _swigc__p_long_long, - _swigc__p_of3dPrimitive, - _swigc__p_ofAbstractImage, - _swigc__p_ofAbstractParameter, - _swigc__p_ofAppBaseWindow, - _swigc__p_ofBaseApp, - _swigc__p_ofBaseDraws, - _swigc__p_ofBaseFileSerializer, - _swigc__p_ofBaseGLRenderer, - _swigc__p_ofBaseHasPixels, - _swigc__p_ofBaseHasTexture, - _swigc__p_ofBaseHasTexturePlanes, - _swigc__p_ofBaseImage_T_float_t, - _swigc__p_ofBaseImage_T_unsigned_char_t, - _swigc__p_ofBaseImage_T_unsigned_short_t, - _swigc__p_ofBaseLoggerChannel, - _swigc__p_ofBaseMaterial, - _swigc__p_ofBaseRenderer, - _swigc__p_ofBaseSerializer, - _swigc__p_ofBaseSoundInput, - _swigc__p_ofBaseSoundOutput, - _swigc__p_ofBaseSoundPlayer, - _swigc__p_ofBaseUpdates, - _swigc__p_ofBaseVideo, - _swigc__p_ofBaseVideoDraws, - _swigc__p_ofBaseVideoGrabber, - _swigc__p_ofBaseVideoPlayer, - _swigc__p_ofBoxPrimitive, - _swigc__p_ofBuffer, - _swigc__p_ofBufferObject, - _swigc__p_ofCamera, - _swigc__p_ofColor_T_float_t, - _swigc__p_ofColor_T_unsigned_char_t, - _swigc__p_ofColor_T_unsigned_short_t, - _swigc__p_ofConePrimitive, - _swigc__p_ofConsoleLoggerChannel, - _swigc__p_ofCoreEvents, - _swigc__p_ofCylinderPrimitive, - _swigc__p_ofDirectory, - _swigc__p_ofDragInfo, - _swigc__p_ofEasyCam, - _swigc__p_ofEventArgs, - _swigc__p_ofEventT_ofHttpResponse_t, - _swigc__p_ofFbo, - _swigc__p_ofFbo__Settings, - _swigc__p_ofFile, - _swigc__p_ofFileDialogResult, - _swigc__p_ofFileLoggerChannel, - _swigc__p_ofFilePath, - _swigc__p_ofFpsCounter, - _swigc__p_ofHttpRequest, - _swigc__p_ofHttpResponse, - _swigc__p_ofIcoSpherePrimitive, - _swigc__p_ofImage_T_float_t, - _swigc__p_ofImage_T_unsigned_char_t, - _swigc__p_ofImage_T_unsigned_short_t, - _swigc__p_ofKeyEventArgs, - _swigc__p_ofLight, - _swigc__p_ofLog, - _swigc__p_ofLogError, - _swigc__p_ofLogFatalError, - _swigc__p_ofLogNotice, - _swigc__p_ofLogVerbose, - _swigc__p_ofLogWarning, - _swigc__p_ofMaterial, - _swigc__p_ofMatrix3x3, - _swigc__p_ofMatrix4x4, - _swigc__p_ofMatrixStack, - _swigc__p_ofMesh, - _swigc__p_ofMeshFace, - _swigc__p_ofMessage, - _swigc__p_ofMouseEventArgs, - _swigc__p_ofNode, - _swigc__p_ofParameterGroup, - _swigc__p_ofPath, - _swigc__p_ofPixels_T_float_t, - _swigc__p_ofPixels_T_unsigned_char_t, - _swigc__p_ofPixels_T_unsigned_short_t, - _swigc__p_ofPlanePrimitive, - _swigc__p_ofPolyline, - _swigc__p_ofQuaternion, - _swigc__p_ofRectangle, - _swigc__p_ofResizeEventArgs, - _swigc__p_ofSerialDeviceInfo, - _swigc__p_ofShader, - _swigc__p_ofSoundDevice, - _swigc__p_ofSoundPlayer, - _swigc__p_ofSoundStream, - _swigc__p_ofSpherePrimitive, - _swigc__p_ofStyle, - _swigc__p_ofTexture, - _swigc__p_ofTextureData, - _swigc__p_ofTouchEventArgs, - _swigc__p_ofTrueTypeFont, - _swigc__p_ofURLFileLoader, - _swigc__p_ofVbo, - _swigc__p_ofVboMesh, - _swigc__p_ofVec2f, - _swigc__p_ofVec3f, - _swigc__p_ofVec4f, - _swigc__p_ofVideoDevice, - _swigc__p_ofVideoGrabber, - _swigc__p_ofVideoPlayer, - _swigc__p_ofXml, - _swigc__p_shared_ptrT_ofBaseRenderer_t, - _swigc__p_shared_ptrT_ofBaseSoundPlayer_t, - _swigc__p_shared_ptrT_ofBaseSoundStream_t, - _swigc__p_shared_ptrT_ofBaseVideoGrabber_t, - _swigc__p_std__filesystem__path, - _swigc__p_std__mapT_std__string_std__string_t, - _swigc__p_std__string, - _swigc__p_std__vectorT_float_t, - _swigc__p_std__vectorT_int_t, - _swigc__p_std__vectorT_ofColor_T_float_t_t, - _swigc__p_std__vectorT_ofFile_t, - _swigc__p_std__vectorT_ofMeshFace_t, - _swigc__p_std__vectorT_ofPath__Command_t, - _swigc__p_std__vectorT_ofPath_t, - _swigc__p_std__vectorT_ofPolyline_t, - _swigc__p_std__vectorT_ofSoundDevice_t, - _swigc__p_std__vectorT_ofTexture_t, - _swigc__p_std__vectorT_ofVec2f_t, - _swigc__p_std__vectorT_ofVec3f_t, - _swigc__p_std__vectorT_ofVideoDevice_t, - _swigc__p_std__vectorT_std__string_t, - _swigc__p_std__vectorT_unsigned_char_t, - _swigc__p_std__vectorT_unsigned_short_t, - _swigc__p_std__vectorT_weak_ptrT_ofLight__Data_t_t, - _swigc__p_unsigned_char, - _swigc__p_unsigned_int, - _swigc__p_unsigned_long_long, - _swigc__p_unsigned_short, -}; - - -/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */ - -/* ----------------------------------------------------------------------------- - * Type initialization: - * This problem is tough by the requirement that no dynamic - * memory is used. Also, since swig_type_info structures store pointers to - * swig_cast_info structures and swig_cast_info structures store pointers back - * to swig_type_info structures, we need some lookup code at initialization. - * The idea is that swig generates all the structures that are needed. - * The runtime then collects these partially filled structures. - * The SWIG_InitializeModule function takes these initial arrays out of - * swig_module, and does all the lookup, filling in the swig_module.types - * array with the correct data and linking the correct swig_cast_info - * structures together. - * - * The generated swig_type_info structures are assigned statically to an initial - * array. We just loop through that array, and handle each type individually. - * First we lookup if this type has been already loaded, and if so, use the - * loaded structure instead of the generated one. Then we have to fill in the - * cast linked list. The cast data is initially stored in something like a - * two-dimensional array. Each row corresponds to a type (there are the same - * number of rows as there are in the swig_type_initial array). Each entry in - * a column is one of the swig_cast_info structures for that type. - * The cast_initial array is actually an array of arrays, because each row has - * a variable number of columns. So to actually build the cast linked list, - * we find the array of casts associated with the type, and loop through it - * adding the casts to the list. The one last trick we need to do is making - * sure the type pointer in the swig_cast_info struct is correct. - * - * First off, we lookup the cast->type name to see if it is already loaded. - * There are three cases to handle: - * 1) If the cast->type has already been loaded AND the type we are adding - * casting info to has not been loaded (it is in this module), THEN we - * replace the cast->type pointer with the type pointer that has already - * been loaded. - * 2) If BOTH types (the one we are adding casting info to, and the - * cast->type) are loaded, THEN the cast info has already been loaded by - * the previous module so we just ignore it. - * 3) Finally, if cast->type has not already been loaded, then we add that - * swig_cast_info to the linked list (because the cast->type) pointer will - * be correct. - * ----------------------------------------------------------------------------- */ - -#ifdef __cplusplus -extern "C" { -#if 0 -} /* c-mode */ -#endif -#endif - -#if 0 -#define SWIGRUNTIME_DEBUG -#endif - - -SWIGRUNTIME void -SWIG_InitializeModule(void *clientdata) { - size_t i; - swig_module_info *module_head, *iter; - int init; - - /* check to see if the circular list has been setup, if not, set it up */ - if (swig_module.next==0) { - /* Initialize the swig_module */ - swig_module.type_initial = swig_type_initial; - swig_module.cast_initial = swig_cast_initial; - swig_module.next = &swig_module; - init = 1; - } else { - init = 0; - } - - /* Try and load any already created modules */ - module_head = SWIG_GetModule(clientdata); - if (!module_head) { - /* This is the first module loaded for this interpreter */ - /* so set the swig module into the interpreter */ - SWIG_SetModule(clientdata, &swig_module); - } else { - /* the interpreter has loaded a SWIG module, but has it loaded this one? */ - iter=module_head; - do { - if (iter==&swig_module) { - /* Our module is already in the list, so there's nothing more to do. */ - return; - } - iter=iter->next; - } while (iter!= module_head); - - /* otherwise we must add our module into the list */ - swig_module.next = module_head->next; - module_head->next = &swig_module; - } - - /* When multiple interpreters are used, a module could have already been initialized in - a different interpreter, but not yet have a pointer in this interpreter. - In this case, we do not want to continue adding types... everything should be - set up already */ - if (init == 0) return; - - /* Now work on filling in swig_module.types */ -#ifdef SWIGRUNTIME_DEBUG - printf("SWIG_InitializeModule: size %d\n", swig_module.size); -#endif - for (i = 0; i < swig_module.size; ++i) { - swig_type_info *type = 0; - swig_type_info *ret; - swig_cast_info *cast; - -#ifdef SWIGRUNTIME_DEBUG - printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name); -#endif - - /* if there is another module already loaded */ - if (swig_module.next != &swig_module) { - type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name); - } - if (type) { - /* Overwrite clientdata field */ -#ifdef SWIGRUNTIME_DEBUG - printf("SWIG_InitializeModule: found type %s\n", type->name); -#endif - if (swig_module.type_initial[i]->clientdata) { - type->clientdata = swig_module.type_initial[i]->clientdata; -#ifdef SWIGRUNTIME_DEBUG - printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name); -#endif - } - } else { - type = swig_module.type_initial[i]; - } - - /* Insert casting types */ - cast = swig_module.cast_initial[i]; - while (cast->type) { - - /* Don't need to add information already in the list */ - ret = 0; -#ifdef SWIGRUNTIME_DEBUG - printf("SWIG_InitializeModule: look cast %s\n", cast->type->name); -#endif - if (swig_module.next != &swig_module) { - ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name); -#ifdef SWIGRUNTIME_DEBUG - if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name); -#endif - } - if (ret) { - if (type == swig_module.type_initial[i]) { -#ifdef SWIGRUNTIME_DEBUG - printf("SWIG_InitializeModule: skip old type %s\n", ret->name); -#endif - cast->type = ret; - ret = 0; - } else { - /* Check for casting already in the list */ - swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type); -#ifdef SWIGRUNTIME_DEBUG - if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name); -#endif - if (!ocast) ret = 0; - } - } - - if (!ret) { -#ifdef SWIGRUNTIME_DEBUG - printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name); -#endif - if (type->cast) { - type->cast->prev = cast; - cast->next = type->cast; - } - type->cast = cast; - } - cast++; - } - /* Set entry in modules->types array equal to the type */ - swig_module.types[i] = type; - } - swig_module.types[i] = 0; - -#ifdef SWIGRUNTIME_DEBUG - printf("**** SWIG_InitializeModule: Cast List ******\n"); - for (i = 0; i < swig_module.size; ++i) { - int j = 0; - swig_cast_info *cast = swig_module.cast_initial[i]; - printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name); - while (cast->type) { - printf("SWIG_InitializeModule: cast type %s\n", cast->type->name); - cast++; - ++j; - } - printf("---- Total casts: %d\n",j); - } - printf("**** SWIG_InitializeModule: Cast List ******\n"); -#endif -} - -/* This function will propagate the clientdata field of type to -* any new swig_type_info structures that have been added into the list -* of equivalent types. It is like calling -* SWIG_TypeClientData(type, clientdata) a second time. -*/ -SWIGRUNTIME void -SWIG_PropagateClientData(void) { - size_t i; - swig_cast_info *equiv; - static int init_run = 0; - - if (init_run) return; - init_run = 1; - - for (i = 0; i < swig_module.size; i++) { - if (swig_module.types[i]->clientdata) { - equiv = swig_module.types[i]->cast; - while (equiv) { - if (!equiv->converter) { - if (equiv->type && !equiv->type->clientdata) - SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata); - } - equiv = equiv->next; - } - } - } -} - -#ifdef __cplusplus -#if 0 -{ /* c-mode */ -#endif -} -#endif - - - -/* Forward declaration of where the user's %init{} gets inserted */ -void SWIG_init_user(lua_State* L ); - -#ifdef __cplusplus -extern "C" { -#endif -/* this is the initialization function - added at the very end of the code - the function is always called SWIG_init, but an earlier #define will rename it -*/ -#if ((SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC)) -LUALIB_API int SWIG_init(lua_State* L) -#else -SWIGEXPORT int SWIG_init(lua_State* L) /* default Lua action */ -#endif -{ -#if (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC) /* valid for both Lua and eLua */ - int i; - int globalRegister = 0; - /* start with global table */ - lua_pushglobaltable (L); - /* SWIG's internal initialisation */ - SWIG_InitializeModule((void*)L); - SWIG_PropagateClientData(); -#endif - -#if ((SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUA) && (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC)) || defined(SWIG_LUA_ELUA_EMULATE) - /* add a global fn */ - SWIG_Lua_add_function(L,"swig_type",SWIG_Lua_type); - SWIG_Lua_add_function(L,"swig_equals",SWIG_Lua_class_equal); -#endif - -#if (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC) - /* set up base class pointers (the hierarchy) */ - for (i = 0; swig_types[i]; i++){ - if (swig_types[i]->clientdata){ - SWIG_Lua_init_base_class(L,(swig_lua_class*)(swig_types[i]->clientdata)); - } - } -#ifdef SWIG_LUA_MODULE_GLOBAL - globalRegister = 1; -#endif - - -#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA) - SWIG_Lua_namespace_register(L,&swig_SwigModule, globalRegister); -#endif - -#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC) - for (i = 0; swig_types[i]; i++){ - if (swig_types[i]->clientdata){ - SWIG_Lua_elua_class_register_instance(L,(swig_lua_class*)(swig_types[i]->clientdata)); - } - } -#endif - -#if defined(SWIG_LUA_ELUA_EMULATE) - lua_newtable(L); - SWIG_Lua_elua_emulate_register(L,swig_SwigModule.ns_methods); - SWIG_Lua_elua_emulate_register_clear(L); - if(globalRegister) { - lua_pushstring(L,swig_SwigModule.name); - lua_pushvalue(L,-2); - lua_rawset(L,-4); - } -#endif - -#endif - -#if (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC) - /* invoke user-specific initialization */ - SWIG_init_user(L); - /* end module */ - /* Note: We do not clean up the stack here (Lua will do this for us). At this - point, we have the globals table and out module table on the stack. Returning - one value makes the module table the result of the require command. */ - return 1; -#else - return 0; -#endif -} - -#ifdef __cplusplus -} -#endif - - -const char* SWIG_LUACODE= - "\n" - "\n" - "-- this isn't wrapped correctly, so set it here\n" - "of.CLOSE = true\n" - "\n" - "-- handle typedefs which swig doesn't wrap\n" - "of.Point = of.Vec3f\n" - "\n" - "-- class.lua\n" - "-- Compatible with Lua 5.1 (not 5.0).\n" - "function class(base, __init)\n" - " local c = {} -- a new class instance\n" - " if not __init and type(base) == 'function' then\n" - " __init = base\n" - " base = nil\n" - " elseif type(base) == 'table' then\n" - " -- our new class is a shallow copy of the base class!\n" - " for i,v in pairs(base) do\n" - " c[i] = v\n" - " end\n" - " c._base = base\n" - " end\n" - " -- the class will be the metatable for all its objects,\n" - " -- and they will look up their methods in it.\n" - " c.__index = c\n" - "\n" - " -- expose a constructor which can be called by ()\n" - " local mt = {}\n" - " mt.__call = function(class_tbl, ...)\n" - " local obj = {}\n" - " setmetatable(obj,c)\n" - " if class_tbl.__init then\n" - " class_tbl.__init(obj,...)\n" - " else\n" - " -- make sure that any stuff from the base class is initialized!\n" - " if base and base.__init then\n" - " base.__init(obj, ...)\n" - " end\n" - " end\n" - " return obj\n" - " end\n" - " c.__init = __init\n" - " c.is_a = function(self, klass)\n" - " local m = getmetatable(self)\n" - " while m do\n" - " if m == klass then return true end\n" - " m = m._base\n" - " end\n" - " return false\n" - " end\n" - " setmetatable(c, mt)\n" - " return c\n" - "end"; - -void SWIG_init_user(lua_State* L) -{ - /* exec Lua code if applicable */ - SWIG_Lua_dostring(L,SWIG_LUACODE); -} - diff --git a/addons/ofxLua/src/bindings/linuxarm/ofxLuaBindings.cpp b/addons/ofxLua/src/bindings/linuxarm/ofxLuaBindings.cpp deleted file mode 100644 index d056b78..0000000 --- a/addons/ofxLua/src/bindings/linuxarm/ofxLuaBindings.cpp +++ /dev/null @@ -1,46580 +0,0 @@ -/* ---------------------------------------------------------------------------- - * This file was automatically generated by SWIG (http://www.swig.org). - * Version 3.0.12 - * - * This file is not intended to be easily readable and contains a number of - * coding conventions designed to improve portability and efficiency. Do not make - * changes to this file unless you know what you are doing--modify the SWIG - * interface file instead. - * ----------------------------------------------------------------------------- */ - -#if defined( __WIN32__ ) || defined( _WIN32 ) - #include -#endif - - - -#ifndef SWIGLUA -#define SWIGLUA -#endif - -#define SWIG_LUA_TARGET SWIG_LUA_FLAVOR_LUA -#define SWIG_LUA_MODULE_GLOBAL - - -#ifdef __cplusplus -/* SwigValueWrapper is described in swig.swg */ -template class SwigValueWrapper { - struct SwigMovePointer { - T *ptr; - SwigMovePointer(T *p) : ptr(p) { } - ~SwigMovePointer() { delete ptr; } - SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; } - } pointer; - SwigValueWrapper& operator=(const SwigValueWrapper& rhs); - SwigValueWrapper(const SwigValueWrapper& rhs); -public: - SwigValueWrapper() : pointer(0) { } - SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; } - operator T&() const { return *pointer.ptr; } - T *operator&() { return pointer.ptr; } -}; - -template T SwigValueInit() { - return T(); -} -#endif - -/* ----------------------------------------------------------------------------- - * This section contains generic SWIG labels for method/variable - * declarations/attributes, and other compiler dependent labels. - * ----------------------------------------------------------------------------- */ - -/* template workaround for compilers that cannot correctly implement the C++ standard */ -#ifndef SWIGTEMPLATEDISAMBIGUATOR -# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560) -# define SWIGTEMPLATEDISAMBIGUATOR template -# elif defined(__HP_aCC) -/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */ -/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */ -# define SWIGTEMPLATEDISAMBIGUATOR template -# else -# define SWIGTEMPLATEDISAMBIGUATOR -# endif -#endif - -/* inline attribute */ -#ifndef SWIGINLINE -# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__)) -# define SWIGINLINE inline -# else -# define SWIGINLINE -# endif -#endif - -/* attribute recognised by some compilers to avoid 'unused' warnings */ -#ifndef SWIGUNUSED -# if defined(__GNUC__) -# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) -# define SWIGUNUSED __attribute__ ((__unused__)) -# else -# define SWIGUNUSED -# endif -# elif defined(__ICC) -# define SWIGUNUSED __attribute__ ((__unused__)) -# else -# define SWIGUNUSED -# endif -#endif - -#ifndef SWIG_MSC_UNSUPPRESS_4505 -# if defined(_MSC_VER) -# pragma warning(disable : 4505) /* unreferenced local function has been removed */ -# endif -#endif - -#ifndef SWIGUNUSEDPARM -# ifdef __cplusplus -# define SWIGUNUSEDPARM(p) -# else -# define SWIGUNUSEDPARM(p) p SWIGUNUSED -# endif -#endif - -/* internal SWIG method */ -#ifndef SWIGINTERN -# define SWIGINTERN static SWIGUNUSED -#endif - -/* internal inline SWIG method */ -#ifndef SWIGINTERNINLINE -# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE -#endif - -/* exporting methods */ -#if defined(__GNUC__) -# if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) -# ifndef GCC_HASCLASSVISIBILITY -# define GCC_HASCLASSVISIBILITY -# endif -# endif -#endif - -#ifndef SWIGEXPORT -# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) -# if defined(STATIC_LINKED) -# define SWIGEXPORT -# else -# define SWIGEXPORT __declspec(dllexport) -# endif -# else -# if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY) -# define SWIGEXPORT __attribute__ ((visibility("default"))) -# else -# define SWIGEXPORT -# endif -# endif -#endif - -/* calling conventions for Windows */ -#ifndef SWIGSTDCALL -# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) -# define SWIGSTDCALL __stdcall -# else -# define SWIGSTDCALL -# endif -#endif - -/* Deal with Microsoft's attempt at deprecating C standard runtime functions */ -#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE) -# define _CRT_SECURE_NO_DEPRECATE -#endif - -/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */ -#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE) -# define _SCL_SECURE_NO_DEPRECATE -#endif - -/* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */ -#if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES) -# define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0 -#endif - -/* Intel's compiler complains if a variable which was never initialised is - * cast to void, which is a common idiom which we use to indicate that we - * are aware a variable isn't used. So we just silence that warning. - * See: https://github.com/swig/swig/issues/192 for more discussion. - */ -#ifdef __INTEL_COMPILER -# pragma warning disable 592 -#endif - -/* ----------------------------------------------------------------------------- - * swigrun.swg - * - * This file contains generic C API SWIG runtime support for pointer - * type checking. - * ----------------------------------------------------------------------------- */ - -/* This should only be incremented when either the layout of swig_type_info changes, - or for whatever reason, the runtime changes incompatibly */ -#define SWIG_RUNTIME_VERSION "4" - -/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */ -#ifdef SWIG_TYPE_TABLE -# define SWIG_QUOTE_STRING(x) #x -# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x) -# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE) -#else -# define SWIG_TYPE_TABLE_NAME -#endif - -/* - You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for - creating a static or dynamic library from the SWIG runtime code. - In 99.9% of the cases, SWIG just needs to declare them as 'static'. - - But only do this if strictly necessary, ie, if you have problems - with your compiler or suchlike. -*/ - -#ifndef SWIGRUNTIME -# define SWIGRUNTIME SWIGINTERN -#endif - -#ifndef SWIGRUNTIMEINLINE -# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE -#endif - -/* Generic buffer size */ -#ifndef SWIG_BUFFER_SIZE -# define SWIG_BUFFER_SIZE 1024 -#endif - -/* Flags for pointer conversions */ -#define SWIG_POINTER_DISOWN 0x1 -#define SWIG_CAST_NEW_MEMORY 0x2 - -/* Flags for new pointer objects */ -#define SWIG_POINTER_OWN 0x1 - - -/* - Flags/methods for returning states. - - The SWIG conversion methods, as ConvertPtr, return an integer - that tells if the conversion was successful or not. And if not, - an error code can be returned (see swigerrors.swg for the codes). - - Use the following macros/flags to set or process the returning - states. - - In old versions of SWIG, code such as the following was usually written: - - if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) { - // success code - } else { - //fail code - } - - Now you can be more explicit: - - int res = SWIG_ConvertPtr(obj,vptr,ty.flags); - if (SWIG_IsOK(res)) { - // success code - } else { - // fail code - } - - which is the same really, but now you can also do - - Type *ptr; - int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags); - if (SWIG_IsOK(res)) { - // success code - if (SWIG_IsNewObj(res) { - ... - delete *ptr; - } else { - ... - } - } else { - // fail code - } - - I.e., now SWIG_ConvertPtr can return new objects and you can - identify the case and take care of the deallocation. Of course that - also requires SWIG_ConvertPtr to return new result values, such as - - int SWIG_ConvertPtr(obj, ptr,...) { - if () { - if () { - *ptr = ; - return SWIG_NEWOBJ; - } else { - *ptr = ; - return SWIG_OLDOBJ; - } - } else { - return SWIG_BADOBJ; - } - } - - Of course, returning the plain '0(success)/-1(fail)' still works, but you can be - more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the - SWIG errors code. - - Finally, if the SWIG_CASTRANK_MODE is enabled, the result code - allows to return the 'cast rank', for example, if you have this - - int food(double) - int fooi(int); - - and you call - - food(1) // cast rank '1' (1 -> 1.0) - fooi(1) // cast rank '0' - - just use the SWIG_AddCast()/SWIG_CheckState() -*/ - -#define SWIG_OK (0) -#define SWIG_ERROR (-1) -#define SWIG_IsOK(r) (r >= 0) -#define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError) - -/* The CastRankLimit says how many bits are used for the cast rank */ -#define SWIG_CASTRANKLIMIT (1 << 8) -/* The NewMask denotes the object was created (using new/malloc) */ -#define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1) -/* The TmpMask is for in/out typemaps that use temporal objects */ -#define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1) -/* Simple returning values */ -#define SWIG_BADOBJ (SWIG_ERROR) -#define SWIG_OLDOBJ (SWIG_OK) -#define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK) -#define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK) -/* Check, add and del mask methods */ -#define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r) -#define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r) -#define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK)) -#define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r) -#define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r) -#define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK)) - -/* Cast-Rank Mode */ -#if defined(SWIG_CASTRANK_MODE) -# ifndef SWIG_TypeRank -# define SWIG_TypeRank unsigned long -# endif -# ifndef SWIG_MAXCASTRANK /* Default cast allowed */ -# define SWIG_MAXCASTRANK (2) -# endif -# define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1) -# define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK) -SWIGINTERNINLINE int SWIG_AddCast(int r) { - return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r; -} -SWIGINTERNINLINE int SWIG_CheckState(int r) { - return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0; -} -#else /* no cast-rank mode */ -# define SWIG_AddCast(r) (r) -# define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0) -#endif - - -#include - -#ifdef __cplusplus -extern "C" { -#endif - -typedef void *(*swig_converter_func)(void *, int *); -typedef struct swig_type_info *(*swig_dycast_func)(void **); - -/* Structure to store information on one type */ -typedef struct swig_type_info { - const char *name; /* mangled name of this type */ - const char *str; /* human readable name of this type */ - swig_dycast_func dcast; /* dynamic cast function down a hierarchy */ - struct swig_cast_info *cast; /* linked list of types that can cast into this type */ - void *clientdata; /* language specific type data */ - int owndata; /* flag if the structure owns the clientdata */ -} swig_type_info; - -/* Structure to store a type and conversion function used for casting */ -typedef struct swig_cast_info { - swig_type_info *type; /* pointer to type that is equivalent to this type */ - swig_converter_func converter; /* function to cast the void pointers */ - struct swig_cast_info *next; /* pointer to next cast in linked list */ - struct swig_cast_info *prev; /* pointer to the previous cast */ -} swig_cast_info; - -/* Structure used to store module information - * Each module generates one structure like this, and the runtime collects - * all of these structures and stores them in a circularly linked list.*/ -typedef struct swig_module_info { - swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */ - size_t size; /* Number of types in this module */ - struct swig_module_info *next; /* Pointer to next element in circularly linked list */ - swig_type_info **type_initial; /* Array of initially generated type structures */ - swig_cast_info **cast_initial; /* Array of initially generated casting structures */ - void *clientdata; /* Language specific module data */ -} swig_module_info; - -/* - Compare two type names skipping the space characters, therefore - "char*" == "char *" and "Class" == "Class", etc. - - Return 0 when the two name types are equivalent, as in - strncmp, but skipping ' '. -*/ -SWIGRUNTIME int -SWIG_TypeNameComp(const char *f1, const char *l1, - const char *f2, const char *l2) { - for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) { - while ((*f1 == ' ') && (f1 != l1)) ++f1; - while ((*f2 == ' ') && (f2 != l2)) ++f2; - if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1; - } - return (int)((l1 - f1) - (l2 - f2)); -} - -/* - Check type equivalence in a name list like ||... - Return 0 if equal, -1 if nb < tb, 1 if nb > tb -*/ -SWIGRUNTIME int -SWIG_TypeCmp(const char *nb, const char *tb) { - int equiv = 1; - const char* te = tb + strlen(tb); - const char* ne = nb; - while (equiv != 0 && *ne) { - for (nb = ne; *ne; ++ne) { - if (*ne == '|') break; - } - equiv = SWIG_TypeNameComp(nb, ne, tb, te); - if (*ne) ++ne; - } - return equiv; -} - -/* - Check type equivalence in a name list like ||... - Return 0 if not equal, 1 if equal -*/ -SWIGRUNTIME int -SWIG_TypeEquiv(const char *nb, const char *tb) { - return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0; -} - -/* - Check the typename -*/ -SWIGRUNTIME swig_cast_info * -SWIG_TypeCheck(const char *c, swig_type_info *ty) { - if (ty) { - swig_cast_info *iter = ty->cast; - while (iter) { - if (strcmp(iter->type->name, c) == 0) { - if (iter == ty->cast) - return iter; - /* Move iter to the top of the linked list */ - iter->prev->next = iter->next; - if (iter->next) - iter->next->prev = iter->prev; - iter->next = ty->cast; - iter->prev = 0; - if (ty->cast) ty->cast->prev = iter; - ty->cast = iter; - return iter; - } - iter = iter->next; - } - } - return 0; -} - -/* - Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison -*/ -SWIGRUNTIME swig_cast_info * -SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) { - if (ty) { - swig_cast_info *iter = ty->cast; - while (iter) { - if (iter->type == from) { - if (iter == ty->cast) - return iter; - /* Move iter to the top of the linked list */ - iter->prev->next = iter->next; - if (iter->next) - iter->next->prev = iter->prev; - iter->next = ty->cast; - iter->prev = 0; - if (ty->cast) ty->cast->prev = iter; - ty->cast = iter; - return iter; - } - iter = iter->next; - } - } - return 0; -} - -/* - Cast a pointer up an inheritance hierarchy -*/ -SWIGRUNTIMEINLINE void * -SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) { - return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory); -} - -/* - Dynamic pointer casting. Down an inheritance hierarchy -*/ -SWIGRUNTIME swig_type_info * -SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) { - swig_type_info *lastty = ty; - if (!ty || !ty->dcast) return ty; - while (ty && (ty->dcast)) { - ty = (*ty->dcast)(ptr); - if (ty) lastty = ty; - } - return lastty; -} - -/* - Return the name associated with this type -*/ -SWIGRUNTIMEINLINE const char * -SWIG_TypeName(const swig_type_info *ty) { - return ty->name; -} - -/* - Return the pretty name associated with this type, - that is an unmangled type name in a form presentable to the user. -*/ -SWIGRUNTIME const char * -SWIG_TypePrettyName(const swig_type_info *type) { - /* The "str" field contains the equivalent pretty names of the - type, separated by vertical-bar characters. We choose - to print the last name, as it is often (?) the most - specific. */ - if (!type) return NULL; - if (type->str != NULL) { - const char *last_name = type->str; - const char *s; - for (s = type->str; *s; s++) - if (*s == '|') last_name = s+1; - return last_name; - } - else - return type->name; -} - -/* - Set the clientdata field for a type -*/ -SWIGRUNTIME void -SWIG_TypeClientData(swig_type_info *ti, void *clientdata) { - swig_cast_info *cast = ti->cast; - /* if (ti->clientdata == clientdata) return; */ - ti->clientdata = clientdata; - - while (cast) { - if (!cast->converter) { - swig_type_info *tc = cast->type; - if (!tc->clientdata) { - SWIG_TypeClientData(tc, clientdata); - } - } - cast = cast->next; - } -} -SWIGRUNTIME void -SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) { - SWIG_TypeClientData(ti, clientdata); - ti->owndata = 1; -} - -/* - Search for a swig_type_info structure only by mangled name - Search is a O(log #types) - - We start searching at module start, and finish searching when start == end. - Note: if start == end at the beginning of the function, we go all the way around - the circular list. -*/ -SWIGRUNTIME swig_type_info * -SWIG_MangledTypeQueryModule(swig_module_info *start, - swig_module_info *end, - const char *name) { - swig_module_info *iter = start; - do { - if (iter->size) { - size_t l = 0; - size_t r = iter->size - 1; - do { - /* since l+r >= 0, we can (>> 1) instead (/ 2) */ - size_t i = (l + r) >> 1; - const char *iname = iter->types[i]->name; - if (iname) { - int compare = strcmp(name, iname); - if (compare == 0) { - return iter->types[i]; - } else if (compare < 0) { - if (i) { - r = i - 1; - } else { - break; - } - } else if (compare > 0) { - l = i + 1; - } - } else { - break; /* should never happen */ - } - } while (l <= r); - } - iter = iter->next; - } while (iter != end); - return 0; -} - -/* - Search for a swig_type_info structure for either a mangled name or a human readable name. - It first searches the mangled names of the types, which is a O(log #types) - If a type is not found it then searches the human readable names, which is O(#types). - - We start searching at module start, and finish searching when start == end. - Note: if start == end at the beginning of the function, we go all the way around - the circular list. -*/ -SWIGRUNTIME swig_type_info * -SWIG_TypeQueryModule(swig_module_info *start, - swig_module_info *end, - const char *name) { - /* STEP 1: Search the name field using binary search */ - swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name); - if (ret) { - return ret; - } else { - /* STEP 2: If the type hasn't been found, do a complete search - of the str field (the human readable name) */ - swig_module_info *iter = start; - do { - size_t i = 0; - for (; i < iter->size; ++i) { - if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name))) - return iter->types[i]; - } - iter = iter->next; - } while (iter != end); - } - - /* neither found a match */ - return 0; -} - -/* - Pack binary data into a string -*/ -SWIGRUNTIME char * -SWIG_PackData(char *c, void *ptr, size_t sz) { - static const char hex[17] = "0123456789abcdef"; - const unsigned char *u = (unsigned char *) ptr; - const unsigned char *eu = u + sz; - for (; u != eu; ++u) { - unsigned char uu = *u; - *(c++) = hex[(uu & 0xf0) >> 4]; - *(c++) = hex[uu & 0xf]; - } - return c; -} - -/* - Unpack binary data from a string -*/ -SWIGRUNTIME const char * -SWIG_UnpackData(const char *c, void *ptr, size_t sz) { - unsigned char *u = (unsigned char *) ptr; - const unsigned char *eu = u + sz; - for (; u != eu; ++u) { - char d = *(c++); - unsigned char uu; - if ((d >= '0') && (d <= '9')) - uu = (unsigned char)((d - '0') << 4); - else if ((d >= 'a') && (d <= 'f')) - uu = (unsigned char)((d - ('a'-10)) << 4); - else - return (char *) 0; - d = *(c++); - if ((d >= '0') && (d <= '9')) - uu |= (unsigned char)(d - '0'); - else if ((d >= 'a') && (d <= 'f')) - uu |= (unsigned char)(d - ('a'-10)); - else - return (char *) 0; - *u = uu; - } - return c; -} - -/* - Pack 'void *' into a string buffer. -*/ -SWIGRUNTIME char * -SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) { - char *r = buff; - if ((2*sizeof(void *) + 2) > bsz) return 0; - *(r++) = '_'; - r = SWIG_PackData(r,&ptr,sizeof(void *)); - if (strlen(name) + 1 > (bsz - (r - buff))) return 0; - strcpy(r,name); - return buff; -} - -SWIGRUNTIME const char * -SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) { - if (*c != '_') { - if (strcmp(c,"NULL") == 0) { - *ptr = (void *) 0; - return name; - } else { - return 0; - } - } - return SWIG_UnpackData(++c,ptr,sizeof(void *)); -} - -SWIGRUNTIME char * -SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) { - char *r = buff; - size_t lname = (name ? strlen(name) : 0); - if ((2*sz + 2 + lname) > bsz) return 0; - *(r++) = '_'; - r = SWIG_PackData(r,ptr,sz); - if (lname) { - strncpy(r,name,lname+1); - } else { - *r = 0; - } - return buff; -} - -SWIGRUNTIME const char * -SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) { - if (*c != '_') { - if (strcmp(c,"NULL") == 0) { - memset(ptr,0,sz); - return name; - } else { - return 0; - } - } - return SWIG_UnpackData(++c,ptr,sz); -} - -#ifdef __cplusplus -} -#endif - -/* ----------------------------------------------------------------------------- - * luarun.swg - * - * This file contains the runtime support for Lua modules - * and includes code for managing global variables and pointer - * type checking. - * ----------------------------------------------------------------------------- */ - -#ifdef __cplusplus -extern "C" { -#endif - -#include "lua.h" -#include "lauxlib.h" -#include /* for malloc */ -#include /* for a few sanity tests */ - -/* ----------------------------------------------------------------------------- - * Lua flavors - * ----------------------------------------------------------------------------- */ - -#define SWIG_LUA_FLAVOR_LUA 1 -#define SWIG_LUA_FLAVOR_ELUA 2 -#define SWIG_LUA_FLAVOR_ELUAC 3 - -#if !defined(SWIG_LUA_TARGET) -# error SWIG_LUA_TARGET not defined -#endif - -#if defined(SWIG_LUA_ELUA_EMULATE) - -struct swig_elua_entry; - -typedef struct swig_elua_key { - int type; - union { - const char* strkey; - lua_Number numkey; - } key; -} swig_elua_key; - -typedef struct swig_elua_val { - int type; - union { - lua_Number number; - const struct swig_elua_entry *table; - const char *string; - lua_CFunction function; - struct { - char member; - long lvalue; - void *pvalue; - swig_type_info **ptype; - } userdata; - } value; -} swig_elua_val; - -typedef struct swig_elua_entry { - swig_elua_key key; - swig_elua_val value; -} swig_elua_entry; - -#define LSTRKEY(x) {LUA_TSTRING, {.strkey = x} } -#define LNUMKEY(x) {LUA_TNUMBER, {.numkey = x} } -#define LNILKEY {LUA_TNIL, {.strkey = 0} } - -#define LNUMVAL(x) {LUA_TNUMBER, {.number = x} } -#define LFUNCVAL(x) {LUA_TFUNCTION, {.function = x} } -#define LROVAL(x) {LUA_TTABLE, {.table = x} } -#define LNILVAL {LUA_TNIL, {.string = 0} } -#define LSTRVAL(x) {LUA_TSTRING, {.string = x} } - -#define LUA_REG_TYPE swig_elua_entry - -#define SWIG_LUA_ELUA_EMUL_METATABLE_KEY "__metatable" - -#define lua_pushrotable(L,p)\ - lua_newtable(L);\ - assert(p);\ - SWIG_Lua_elua_emulate_register(L,(swig_elua_entry*)(p)); - -#define SWIG_LUA_CONSTTAB_POINTER(B,C,D)\ - LSTRKEY(B), {LUA_TUSERDATA, { .userdata={0,0,(void*)(C),&D} } } - -#define SWIG_LUA_CONSTTAB_BINARY(B,S,C,D)\ - LSTRKEY(B), {LUA_TUSERDATA, { .userdata={1,S,(void*)(C),&D} } } -#endif - -#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC) -# define SWIG_LUA_CONSTTAB_INT(B, C) LSTRKEY(B), LNUMVAL(C) -# define SWIG_LUA_CONSTTAB_FLOAT(B, C) LSTRKEY(B), LNUMVAL(C) -# define SWIG_LUA_CONSTTAB_STRING(B, C) LSTRKEY(B), LSTRVAL(C) -# define SWIG_LUA_CONSTTAB_CHAR(B, C) LSTRKEY(B), LNUMVAL(C) - /* Those two types of constants are not supported in elua */ - -#ifndef SWIG_LUA_CONSTTAB_POINTER -#warning eLua does not support pointers as constants. By default, nil will be used as value -#define SWIG_LUA_CONSTTAB_POINTER(B,C,D) LSTRKEY(B), LNILVAL -#endif - -#ifndef SWIG_LUA_CONSTTAB_BINARY -#warning eLua does not support pointers to member as constants. By default, nil will be used as value -#define SWIG_LUA_CONSTTAB_BINARY(B, S, C, D) LSTRKEY(B), LNILVAL -#endif -#else /* SWIG_LUA_FLAVOR_LUA */ -# define SWIG_LUA_CONSTTAB_INT(B, C) SWIG_LUA_INT, (char *)B, (long)C, 0, 0, 0 -# define SWIG_LUA_CONSTTAB_FLOAT(B, C) SWIG_LUA_FLOAT, (char *)B, 0, (double)C, 0, 0 -# define SWIG_LUA_CONSTTAB_STRING(B, C) SWIG_LUA_STRING, (char *)B, 0, 0, (void *)C, 0 -# define SWIG_LUA_CONSTTAB_CHAR(B, C) SWIG_LUA_CHAR, (char *)B, (long)C, 0, 0, 0 -# define SWIG_LUA_CONSTTAB_POINTER(B,C,D)\ - SWIG_LUA_POINTER, (char *)B, 0, 0, (void *)C, &D -# define SWIG_LUA_CONSTTAB_BINARY(B, S, C, D)\ - SWIG_LUA_BINARY, (char *)B, S, 0, (void *)C, &D -#endif - -#ifndef SWIG_LUA_ELUA_EMULATE -#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC) -# define LRO_STRVAL(v) {{.p = (char *) v}, LUA_TSTRING} -# define LSTRVAL LRO_STRVAL -#endif -#endif /* SWIG_LUA_ELUA_EMULATE*/ - -#ifndef SWIG_LUA_ELUA_EMULATE -#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC) - -#ifndef MIN_OPT_LEVEL -#define MIN_OPT_LEVEL 2 -#endif - -#include "lrodefs.h" -#include "lrotable.h" -#endif -#endif /* SWIG_LUA_ELUA_EMULATE*/ -/* ----------------------------------------------------------------------------- - * compatibility defines - * ----------------------------------------------------------------------------- */ - -/* History of Lua C API length functions: In Lua 5.0 (and before?) - there was "lua_strlen". In Lua 5.1, this was renamed "lua_objlen", - but a compatibility define of "lua_strlen" was added. In Lua 5.2, - this function was again renamed, to "lua_rawlen" (to emphasize that - it doesn't call the "__len" metamethod), and the compatibility - define of lua_strlen was removed. All SWIG uses have been updated - to "lua_rawlen", and we add our own defines of that here for older - versions of Lua. */ -#if !defined(LUA_VERSION_NUM) || LUA_VERSION_NUM < 501 -# define lua_rawlen lua_strlen -#elif LUA_VERSION_NUM == 501 -# define lua_rawlen lua_objlen -#endif - - -/* lua_pushglobaltable is the recommended "future-proof" way to get - the global table for Lua 5.2 and later. Here we define - lua_pushglobaltable ourselves for Lua versions before 5.2. */ -#if !defined(LUA_VERSION_NUM) || LUA_VERSION_NUM < 502 -# define lua_pushglobaltable(L) lua_pushvalue(L, LUA_GLOBALSINDEX) -#endif - -/* lua_absindex was introduced in Lua 5.2 */ -#if !defined(LUA_VERSION_NUM) || LUA_VERSION_NUM < 502 -# define lua_absindex(L,i) ((i)>0 || (i) <= LUA_REGISTRYINDEX ? (i) : lua_gettop(L) + (i) + 1) -#endif - -/* lua_rawsetp was introduced in Lua 5.2 */ -#if !defined(LUA_VERSION_NUM) || LUA_VERSION_NUM < 502 -#define lua_rawsetp(L,index,ptr)\ - lua_pushlightuserdata(L,(void*)(ptr));\ - lua_insert(L,-2);\ - lua_rawset(L,index); - -#define lua_rawgetp(L,index,ptr)\ - lua_pushlightuserdata(L,(void*)(ptr));\ - lua_rawget(L,index); - -#endif - -/* -------------------------------------------------------------------------- - * Helper functions for error handling - * -------------------------------------------------------------------------- */ - -/* Push the string STR on the Lua stack, like lua_pushstring, but - prefixed with the the location of the innermost Lua call-point - (as formated by luaL_where). */ -SWIGRUNTIME void -SWIG_Lua_pusherrstring (lua_State *L, const char *str) -{ - luaL_where (L, 1); - lua_pushstring (L, str); - lua_concat (L, 2); -} - -/* Push a formatted string generated from FMT and following args on - the Lua stack, like lua_pushfstring, but prefixed with the the - location of the innermost Lua call-point (as formated by luaL_where). */ -SWIGRUNTIME void -SWIG_Lua_pushferrstring (lua_State *L, const char *fmt, ...) -{ - va_list argp; - va_start(argp, fmt); - luaL_where(L, 1); - lua_pushvfstring(L, fmt, argp); - va_end(argp); - lua_concat(L, 2); -} - - -/* ----------------------------------------------------------------------------- - * global swig types - * ----------------------------------------------------------------------------- */ -/* Constant table */ -#define SWIG_LUA_INT 1 -#define SWIG_LUA_FLOAT 2 -#define SWIG_LUA_STRING 3 -#define SWIG_LUA_POINTER 4 -#define SWIG_LUA_BINARY 5 -#define SWIG_LUA_CHAR 6 - -/* Structure for variable linking table */ -typedef struct { - const char *name; - lua_CFunction get; - lua_CFunction set; -} swig_lua_var_info; - -#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC) -typedef const LUA_REG_TYPE swig_lua_method; -typedef const LUA_REG_TYPE swig_lua_const_info; -#else /* Normal lua */ -typedef luaL_Reg swig_lua_method; - -/* Constant information structure */ -typedef struct { - int type; - char *name; - long lvalue; - double dvalue; - void *pvalue; - swig_type_info **ptype; -} swig_lua_const_info; - -#endif - -typedef struct { - const char *name; - lua_CFunction getmethod; - lua_CFunction setmethod; -} swig_lua_attribute; - - -struct swig_lua_class; -/* Can be used to create namespaces. Currently used to wrap class static methods/variables/constants */ -typedef struct swig_lua_namespace { - const char *name; - swig_lua_method *ns_methods; - swig_lua_attribute *ns_attributes; - swig_lua_const_info *ns_constants; - struct swig_lua_class **ns_classes; - struct swig_lua_namespace **ns_namespaces; -} swig_lua_namespace; - -typedef struct swig_lua_class { - const char *name; /* Name that this class has in Lua */ - const char *fqname; /* Fully qualified name - Scope + class name */ - swig_type_info **type; - lua_CFunction constructor; - void (*destructor)(void *); - swig_lua_method *methods; - swig_lua_attribute *attributes; - swig_lua_namespace *cls_static; - swig_lua_method *metatable; /* 0 for -eluac */ - struct swig_lua_class **bases; - const char **base_names; -} swig_lua_class; - -/* this is the struct for wrapping all pointers in SwigLua -*/ -typedef struct { - swig_type_info *type; - int own; /* 1 if owned & must be destroyed */ - void *ptr; -} swig_lua_userdata; - -/* this is the struct for wrapping arbitrary packed binary data -(currently it is only used for member function pointers) -the data ordering is similar to swig_lua_userdata, but it is currently not possible -to tell the two structures apart within SWIG, other than by looking at the type -*/ -typedef struct { - swig_type_info *type; - int own; /* 1 if owned & must be destroyed */ - char data[1]; /* arbitary amount of data */ -} swig_lua_rawdata; - -/* Common SWIG API */ -#define SWIG_NewPointerObj(L, ptr, type, owner) SWIG_Lua_NewPointerObj(L, (void *)ptr, type, owner) -#define SWIG_ConvertPtr(L,idx, ptr, type, flags) SWIG_Lua_ConvertPtr(L,idx,ptr,type,flags) -#define SWIG_MustGetPtr(L,idx, type,flags, argnum,fnname) SWIG_Lua_MustGetPtr(L,idx, type,flags, argnum,fnname) -/* for C++ member pointers, ie, member methods */ -#define SWIG_ConvertMember(L, idx, ptr, sz, ty) SWIG_Lua_ConvertPacked(L, idx, ptr, sz, ty) -#define SWIG_NewMemberObj(L, ptr, sz, type) SWIG_Lua_NewPackedObj(L, ptr, sz, type) - -/* Runtime API */ -#define SWIG_GetModule(clientdata) SWIG_Lua_GetModule((lua_State*)(clientdata)) -#define SWIG_SetModule(clientdata, pointer) SWIG_Lua_SetModule((lua_State*) (clientdata), pointer) -#define SWIG_MODULE_CLIENTDATA_TYPE lua_State* - -/* Contract support */ -#define SWIG_contract_assert(expr, msg) \ - if (!(expr)) { SWIG_Lua_pusherrstring(L, (char *) msg); goto fail; } else - - -/* helper #defines */ -#define SWIG_fail {goto fail;} -#define SWIG_fail_arg(func_name,argnum,type) \ - {SWIG_Lua_pushferrstring(L,"Error in %s (arg %d), expected '%s' got '%s'",\ - func_name,argnum,type,SWIG_Lua_typename(L,argnum));\ - goto fail;} -#define SWIG_fail_ptr(func_name,argnum,type) \ - SWIG_fail_arg(func_name,argnum,(type && type->str)?type->str:"void*") -#define SWIG_check_num_args(func_name,a,b) \ - if (lua_gettop(L)b) \ - {SWIG_Lua_pushferrstring(L,"Error in %s expected %d..%d args, got %d",func_name,a,b,lua_gettop(L));\ - goto fail;} - - -#define SWIG_Lua_get_table(L,n) \ - (lua_pushstring(L, n), lua_rawget(L,-2)) - -#define SWIG_Lua_add_function(L,n,f) \ - (lua_pushstring(L, n), \ - lua_pushcfunction(L, f), \ - lua_rawset(L,-3)) - -#define SWIG_Lua_add_boolean(L,n,b) \ - (lua_pushstring(L, n), \ - lua_pushboolean(L, b), \ - lua_rawset(L,-3)) - -/* special helper for allowing 'nil' for usertypes */ -#define SWIG_isptrtype(L,I) (lua_isuserdata(L,I) || lua_isnil(L,I)) - -#ifdef __cplusplus -/* Special helper for member function pointers -it gets the address, casts it, then dereferences it */ -/*#define SWIG_mem_fn_as_voidptr(a) (*((char**)&(a))) */ -#endif - -/* storing/access of swig_module_info */ -SWIGRUNTIME swig_module_info * -SWIG_Lua_GetModule(lua_State *L) { - swig_module_info *ret = 0; - lua_pushstring(L,"swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME); - lua_rawget(L,LUA_REGISTRYINDEX); - if (lua_islightuserdata(L,-1)) - ret=(swig_module_info*)lua_touserdata(L,-1); - lua_pop(L,1); /* tidy */ - return ret; -} - -SWIGRUNTIME void -SWIG_Lua_SetModule(lua_State *L, swig_module_info *module) { - /* add this all into the Lua registry: */ - lua_pushstring(L,"swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME); - lua_pushlightuserdata(L,(void*)module); - lua_rawset(L,LUA_REGISTRYINDEX); -} - -/* ----------------------------------------------------------------------------- - * global variable support code: modules - * ----------------------------------------------------------------------------- */ - -/* this function is called when trying to set an immutable. -default action is to print an error. -This can removed with a compile flag SWIGLUA_IGNORE_SET_IMMUTABLE */ -SWIGINTERN int SWIG_Lua_set_immutable(lua_State *L) -{ -/* there should be 1 param passed in: the new value */ -#ifndef SWIGLUA_IGNORE_SET_IMMUTABLE - lua_pop(L,1); /* remove it */ - luaL_error(L,"This variable is immutable"); -#endif - return 0; /* should not return anything */ -} - -#ifdef SWIG_LUA_ELUA_EMULATE - -SWIGRUNTIME void SWIG_Lua_NewPointerObj(lua_State *L,void *ptr,swig_type_info *type, int own); -SWIGRUNTIME void SWIG_Lua_NewPackedObj(lua_State *L,void *ptr,size_t size,swig_type_info *type); -static int swig_lua_elua_emulate_unique_key; - -/* This function emulates eLua rotables behaviour. It loads a rotable definition into the usual lua table. */ -SWIGINTERN void SWIG_Lua_elua_emulate_register(lua_State *L, const swig_elua_entry *table) -{ - int i, table_parsed, parsed_tables_array, target_table; - assert(lua_istable(L,-1)); - target_table = lua_gettop(L); - /* Get the registry where we put all parsed tables to avoid loops */ - lua_rawgetp(L, LUA_REGISTRYINDEX, &swig_lua_elua_emulate_unique_key); - if(lua_isnil(L,-1)) { - lua_pop(L,1); - lua_newtable(L); - lua_pushvalue(L,-1); - lua_rawsetp(L,LUA_REGISTRYINDEX,(void*)(&swig_lua_elua_emulate_unique_key)); - } - parsed_tables_array = lua_gettop(L); - lua_pushvalue(L,target_table); - lua_rawsetp(L, parsed_tables_array, table); - table_parsed = 0; - const int SWIGUNUSED pairs_start = lua_gettop(L); - for(i = 0;table[i].key.type != LUA_TNIL || table[i].value.type != LUA_TNIL;i++) - { - const swig_elua_entry *entry = table + i; - int is_metatable = 0; - switch(entry->key.type) { - case LUA_TSTRING: - lua_pushstring(L,entry->key.key.strkey); - if(strcmp(entry->key.key.strkey, SWIG_LUA_ELUA_EMUL_METATABLE_KEY) == 0) - is_metatable = 1; - break; - case LUA_TNUMBER: - lua_pushnumber(L,entry->key.key.numkey); - break; - case LUA_TNIL: - lua_pushnil(L); - break; - default: - assert(0); - } - switch(entry->value.type) { - case LUA_TSTRING: - lua_pushstring(L,entry->value.value.string); - break; - case LUA_TNUMBER: - lua_pushnumber(L,entry->value.value.number); - break; - case LUA_TFUNCTION: - lua_pushcfunction(L,entry->value.value.function); - break; - case LUA_TTABLE: - lua_rawgetp(L,parsed_tables_array, entry->value.value.table); - table_parsed = !lua_isnil(L,-1); - if(!table_parsed) { - lua_pop(L,1); /*remove nil */ - lua_newtable(L); - SWIG_Lua_elua_emulate_register(L,entry->value.value.table); - } - if(is_metatable) { - assert(lua_istable(L,-1)); - lua_pushvalue(L,-1); - lua_setmetatable(L,target_table); - } - - break; - case LUA_TUSERDATA: - if(entry->value.value.userdata.member) - SWIG_NewMemberObj(L,entry->value.value.userdata.pvalue, - entry->value.value.userdata.lvalue, - *(entry->value.value.userdata.ptype)); - else - SWIG_NewPointerObj(L,entry->value.value.userdata.pvalue, - *(entry->value.value.userdata.ptype),0); - break; - case LUA_TNIL: - lua_pushnil(L); - break; - default: - assert(0); - } - assert(lua_gettop(L) == pairs_start + 2); - lua_rawset(L,target_table); - } - lua_pop(L,1); /* Removing parsed tables storage */ - assert(lua_gettop(L) == target_table); -} - -SWIGINTERN void SWIG_Lua_elua_emulate_register_clear(lua_State *L) -{ - lua_pushnil(L); - lua_rawsetp(L, LUA_REGISTRYINDEX, &swig_lua_elua_emulate_unique_key); -} - -SWIGINTERN void SWIG_Lua_get_class_registry(lua_State *L); - -SWIGINTERN int SWIG_Lua_emulate_elua_getmetatable(lua_State *L) -{ - SWIG_check_num_args("getmetatable(SWIG eLua emulation)", 1, 1); - SWIG_Lua_get_class_registry(L); - lua_getfield(L,-1,"lua_getmetatable"); - lua_remove(L,-2); /* remove the registry*/ - assert(!lua_isnil(L,-1)); - lua_pushvalue(L,1); - assert(lua_gettop(L) == 3); /* object | function | object again */ - lua_call(L,1,1); - if(!lua_isnil(L,-1)) /*There is an ordinary metatable */ - return 1; - /*if it is a table, then emulate elua behaviour - check for __metatable attribute of a table*/ - assert(lua_gettop(L) == 2); - if(lua_istable(L,-2)) { - lua_pop(L,1); /*remove the nil*/ - lua_getfield(L,-1, SWIG_LUA_ELUA_EMUL_METATABLE_KEY); - } - assert(lua_gettop(L) == 2); - return 1; - -fail: - lua_error(L); - return 0; -} - -SWIGINTERN void SWIG_Lua_emulate_elua_swap_getmetatable(lua_State *L) -{ - SWIG_Lua_get_class_registry(L); - lua_pushglobaltable(L); - lua_pushstring(L,"lua_getmetatable"); - lua_getfield(L,-2,"getmetatable"); - assert(!lua_isnil(L,-1)); - lua_rawset(L,-4); - lua_pushstring(L, "getmetatable"); - lua_pushcfunction(L, SWIG_Lua_emulate_elua_getmetatable); - lua_rawset(L,-3); - lua_pop(L,2); - -} -/* END OF REMOVE */ - -#endif -/* ----------------------------------------------------------------------------- - * global variable support code: namespaces and modules (which are the same thing) - * ----------------------------------------------------------------------------- */ - -SWIGINTERN int SWIG_Lua_namespace_get(lua_State *L) -{ -/* there should be 2 params passed in - (1) table (not the meta table) - (2) string name of the attribute -*/ - assert(lua_istable(L,-2)); /* just in case */ - lua_getmetatable(L,-2); - assert(lua_istable(L,-1)); - SWIG_Lua_get_table(L,".get"); /* find the .get table */ - assert(lua_istable(L,-1)); - /* look for the key in the .get table */ - lua_pushvalue(L,2); /* key */ - lua_rawget(L,-2); - lua_remove(L,-2); /* stack tidy, remove .get table */ - if (lua_iscfunction(L,-1)) - { /* found it so call the fn & return its value */ - lua_call(L,0,1); /* 1 value in (userdata),1 out (result) */ - lua_remove(L,-2); /* stack tidy, remove metatable */ - return 1; - } - lua_pop(L,1); /* remove whatever was there */ - /* ok, so try the .fn table */ - SWIG_Lua_get_table(L,".fn"); /* find the .get table */ - assert(lua_istable(L,-1)); /* just in case */ - lua_pushvalue(L,2); /* key */ - lua_rawget(L,-2); /* look for the fn */ - lua_remove(L,-2); /* stack tidy, remove .fn table */ - if (lua_isfunction(L,-1)) /* note: whether it's a C function or lua function */ - { /* found it so return the fn & let lua call it */ - lua_remove(L,-2); /* stack tidy, remove metatable */ - return 1; - } - lua_pop(L,1); /* remove whatever was there */ - return 0; -} - -SWIGINTERN int SWIG_Lua_namespace_set(lua_State *L) -{ -/* there should be 3 params passed in - (1) table (not the meta table) - (2) string name of the attribute - (3) any for the new value -*/ - - assert(lua_istable(L,1)); - lua_getmetatable(L,1); /* get the meta table */ - assert(lua_istable(L,-1)); - - SWIG_Lua_get_table(L,".set"); /* find the .set table */ - if (lua_istable(L,-1)) - { - /* look for the key in the .set table */ - lua_pushvalue(L,2); /* key */ - lua_rawget(L,-2); - if (lua_iscfunction(L,-1)) - { /* found it so call the fn & return its value */ - lua_pushvalue(L,3); /* value */ - lua_call(L,1,0); - return 0; - } - lua_pop(L,1); /* remove the value */ - } - lua_pop(L,1); /* remove the value .set table */ - lua_pop(L,1); /* remote metatable */ - lua_rawset(L,-3); - return 0; -} - -#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA) /* In elua this is useless */ -SWIGINTERN void SWIG_Lua_InstallConstants(lua_State *L, swig_lua_const_info constants[]); /* forward declaration */ -SWIGINTERN void SWIG_Lua_add_variable(lua_State *L,const char *name,lua_CFunction getFn,lua_CFunction setFn); /* forward declaration */ -SWIGINTERN void SWIG_Lua_class_register(lua_State *L,swig_lua_class *clss); - -/* helper function - register namespace methods and attributes into namespace */ -SWIGINTERN int SWIG_Lua_add_namespace_details(lua_State *L, swig_lua_namespace *ns) -{ - int i; - /* There must be namespace table (not metatable) at the top of the stack */ - assert(lua_istable(L,-1)); - SWIG_Lua_InstallConstants(L, ns->ns_constants); - - /* add methods to the namespace/module table */ - for(i=0;ns->ns_methods[i].name;i++){ - SWIG_Lua_add_function(L,ns->ns_methods[i].name,ns->ns_methods[i].func); - } - lua_getmetatable(L,-1); - - /* add fns */ - for(i=0;ns->ns_attributes[i].name;i++){ - SWIG_Lua_add_variable(L,ns->ns_attributes[i].name,ns->ns_attributes[i].getmethod,ns->ns_attributes[i].setmethod); - } - - /* clear stack - remove metatble */ - lua_pop(L,1); - return 0; -} - -/* Register all classes in the namespace */ -SWIGINTERN void SWIG_Lua_add_namespace_classes(lua_State *L, swig_lua_namespace *ns) -{ - swig_lua_class **classes; - - /* There must be a module/namespace table at the top of the stack */ - assert(lua_istable(L,-1)); - - classes = ns->ns_classes; - - if( classes != 0 ) { - while(*classes != 0) { - SWIG_Lua_class_register(L, *classes); - classes++; - } - } -} - -/* Helper function. Creates namespace table and adds it to module table - if 'reg' is true, then will register namespace table to parent one (must be on top of the stack - when function is called). - Function always returns newly registered table on top of the stack. -*/ -SWIGINTERN void SWIG_Lua_namespace_register(lua_State *L, swig_lua_namespace *ns, int reg) -{ - swig_lua_namespace **sub_namespace; - /* 1 argument - table on the top of the stack */ - const int SWIGUNUSED begin = lua_gettop(L); - assert(lua_istable(L,-1)); /* just in case. This is supposed to be module table or parent namespace table */ - lua_checkstack(L,5); - lua_newtable(L); /* namespace itself */ - lua_newtable(L); /* metatable for namespace */ - - /* add a table called ".get" */ - lua_pushstring(L,".get"); - lua_newtable(L); - lua_rawset(L,-3); - /* add a table called ".set" */ - lua_pushstring(L,".set"); - lua_newtable(L); - lua_rawset(L,-3); - /* add a table called ".fn" */ - lua_pushstring(L,".fn"); - lua_newtable(L); - lua_rawset(L,-3); - - /* add accessor fns for using the .get,.set&.fn */ - SWIG_Lua_add_function(L,"__index",SWIG_Lua_namespace_get); - SWIG_Lua_add_function(L,"__newindex",SWIG_Lua_namespace_set); - - lua_setmetatable(L,-2); /* set metatable */ - - /* Register all functions, variables etc */ - SWIG_Lua_add_namespace_details(L,ns); - /* Register classes */ - SWIG_Lua_add_namespace_classes(L,ns); - - sub_namespace = ns->ns_namespaces; - if( sub_namespace != 0) { - while(*sub_namespace != 0) { - SWIG_Lua_namespace_register(L, *sub_namespace, 1); - lua_pop(L,1); /* removing sub-namespace table */ - sub_namespace++; - } - } - - if (reg) { - lua_pushstring(L,ns->name); - lua_pushvalue(L,-2); - lua_rawset(L,-4); /* add namespace to module table */ - } - assert(lua_gettop(L) == begin+1); -} -#endif /* SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA */ - -/* ----------------------------------------------------------------------------- - * global variable support code: classes - * ----------------------------------------------------------------------------- */ - -SWIGINTERN void SWIG_Lua_get_class_metatable(lua_State *L,const char *cname); - -typedef int (*swig_lua_base_iterator_func)(lua_State*,swig_type_info*, int, int *ret); - -SWIGINTERN int SWIG_Lua_iterate_bases(lua_State *L, swig_type_info * SWIGUNUSED swig_type, - int first_arg, swig_lua_base_iterator_func func, int *const ret) -{ - /* first_arg - position of the object in stack. Everything that is above are arguments - * and is passed to every evocation of the func */ - int last_arg = lua_gettop(L);/* position of last argument */ - int original_metatable = last_arg + 1; - size_t bases_count; - int result = SWIG_ERROR; - int bases_table; - (void)swig_type; - lua_getmetatable(L,first_arg); - - /* initialise base search */ -#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA) - SWIG_Lua_get_table(L,".bases"); - assert(lua_istable(L,-1)); - bases_count = lua_rawlen(L,-1); - bases_table = lua_gettop(L); -#else - /* In elua .bases table doesn't exist. Use table from swig_lua_class */ - (void)bases_table; - assert(swig_type!=0); - swig_module_info *module=SWIG_GetModule(L); - swig_lua_class **bases= ((swig_lua_class*)(swig_type->clientdata))->bases; - const char **base_names= ((swig_lua_class*)(swig_type->clientdata))->base_names; - bases_count = 0; - for(;base_names[bases_count]; - bases_count++);/* get length of bases */ -#endif - - if(ret) - *ret = 0; - if(bases_count>0) - { - int to_remove; - size_t i; - int j; - int subcall_last_arg; - int subcall_first_arg = lua_gettop(L) + 1;/* Here a copy of first_arg and arguments begin */ - int valid = 1; - swig_type_info *base_swig_type = 0; - for(j=first_arg;j<=last_arg;j++) - lua_pushvalue(L,j); - subcall_last_arg = lua_gettop(L); - - /* Trick: temporarily replacing original metatable with metatable for base class and call getter */ - for(i=0;ifqname); - base_swig_type = SWIG_TypeQueryModule(module,module,base_names[i]); - assert(base_swig_type != 0); - } -#endif - - if(!valid) - continue; - assert(lua_isuserdata(L, subcall_first_arg)); - assert(lua_istable(L,-1)); - lua_setmetatable(L,subcall_first_arg); /* Set new metatable */ - assert(lua_gettop(L) == subcall_last_arg); - result = func(L, base_swig_type,subcall_first_arg, ret); /* Forward call */ - if(result != SWIG_ERROR) { - break; - } - } - /* Restore original metatable */ - lua_pushvalue(L,original_metatable); - lua_setmetatable(L,first_arg); - /* Clear - remove everything between last_arg and subcall_last_arg including */ - to_remove = subcall_last_arg - last_arg; - for(j=0;jtype; - result = SWIG_Lua_class_do_get(L,type,1,&ret); - if(result == SWIG_OK) - return ret; - - result = SWIG_Lua_class_do_get_item(L,type,1,&ret); - if(result == SWIG_OK) - return ret; - - return 0; -} - -/* helper for the class.set method, performs the lookup of class attributes - * It returns error code. Number of function return values is passed inside 'ret' - */ -SWIGINTERN int SWIG_Lua_class_do_set(lua_State *L, swig_type_info *type, int first_arg, int *ret) -{ -/* there should be 3 params passed in - (1) table (not the meta table) - (2) string name of the attribute - (3) any for the new value - */ - - int bases_search_result; - int substack_start = lua_gettop(L) - 3; - lua_checkstack(L,5); - assert(lua_isuserdata(L,substack_start+1)); /* just in case */ - lua_getmetatable(L,substack_start+1); /* get the meta table */ - assert(lua_istable(L,-1)); /* just in case */ - if(ret) - *ret = 0; /* it is setter - number of return values is always 0 */ - - SWIG_Lua_get_table(L,".set"); /* find the .set table */ - if (lua_istable(L,-1)) - { - /* look for the key in the .set table */ - lua_pushvalue(L,substack_start+2); /* key */ - lua_rawget(L,-2); - lua_remove(L,-2); /* tidy stack, remove .set table */ - if (lua_iscfunction(L,-1)) - { /* found it so call the fn & return its value */ - lua_pushvalue(L,substack_start+1); /* userdata */ - lua_pushvalue(L,substack_start+3); /* value */ - lua_call(L,2,0); - lua_remove(L,substack_start+4); /*remove metatable*/ - return SWIG_OK; - } - lua_pop(L,1); /* remove the value */ - } else { - lua_pop(L,1); /* remove the answer for .set table request*/ - } - /* NEW: looks for the __setitem() fn - this is a user provided set fn */ - SWIG_Lua_get_table(L,"__setitem"); /* find the fn */ - if (lua_iscfunction(L,-1)) /* if its there */ - { /* found it so call the fn & return its value */ - lua_pushvalue(L,substack_start+1); /* the userdata */ - lua_pushvalue(L,substack_start+2); /* the parameter */ - lua_pushvalue(L,substack_start+3); /* the value */ - lua_call(L,3,0); /* 3 values in ,0 out */ - lua_remove(L,-2); /* stack tidy, remove metatable */ - return SWIG_OK; - } - lua_pop(L,1); /* remove value */ - - lua_pop(L,1); /* remove metatable */ - /* Search among bases */ - bases_search_result = SWIG_Lua_iterate_bases(L,type,first_arg,SWIG_Lua_class_do_set,ret); - if(ret) - assert(*ret == 0); - assert(lua_gettop(L) == substack_start + 3); - return bases_search_result; -} - -/* This is the actual method exported to Lua. It calls SWIG_Lua_class_do_set and correctly - * handles return values. - */ -SWIGINTERN int SWIG_Lua_class_set(lua_State *L) -{ -/* There should be 3 params passed in - (1) table (not the meta table) - (2) string name of the attribute - (3) any for the new value - */ - int ret = 0; - int result; - swig_lua_userdata *usr; - swig_type_info *type; - assert(lua_isuserdata(L,1)); - usr=(swig_lua_userdata*)lua_touserdata(L,1); /* get data */ - type = usr->type; - result = SWIG_Lua_class_do_set(L,type,1,&ret); - if(result != SWIG_OK) { - SWIG_Lua_pushferrstring(L,"Assignment not possible. No setter/member with this name. For custom assignments implement __setitem method."); - lua_error(L); - } else { - assert(ret==0); - } - return 0; -} - -/* the class.destruct method called by the interpreter */ -SWIGINTERN int SWIG_Lua_class_destruct(lua_State *L) -{ -/* there should be 1 params passed in - (1) userdata (not the meta table) */ - swig_lua_userdata *usr; - swig_lua_class *clss; - assert(lua_isuserdata(L,-1)); /* just in case */ - usr=(swig_lua_userdata*)lua_touserdata(L,-1); /* get it */ - /* if must be destroyed & has a destructor */ - if (usr->own) /* if must be destroyed */ - { - clss=(swig_lua_class*)usr->type->clientdata; /* get the class */ - if (clss && clss->destructor) /* there is a destroy fn */ - { - clss->destructor(usr->ptr); /* bye bye */ - } - } - return 0; -} - -/* the class.__tostring method called by the interpreter and print */ -SWIGINTERN int SWIG_Lua_class_tostring(lua_State *L) -{ -/* there should be 1 param passed in - (1) userdata (not the metatable) */ - const char *className; - void* userData; - assert(lua_isuserdata(L,1)); /* just in case */ - userData = lua_touserdata(L,1); /* get the userdata address for later */ - lua_getmetatable(L,1); /* get the meta table */ - assert(lua_istable(L,-1)); /* just in case */ - - lua_getfield(L, -1, ".type"); - className = lua_tostring(L, -1); - - lua_pushfstring(L, "<%s userdata: %p>", className, userData); - return 1; -} - -/* to manually disown some userdata */ -SWIGINTERN int SWIG_Lua_class_disown(lua_State *L) -{ -/* there should be 1 params passed in - (1) userdata (not the meta table) */ - swig_lua_userdata *usr; - assert(lua_isuserdata(L,-1)); /* just in case */ - usr=(swig_lua_userdata*)lua_touserdata(L,-1); /* get it */ - - usr->own = 0; /* clear our ownership */ - return 0; -} - -/* lua callable function to compare userdata's value -the issue is that two userdata may point to the same thing -but to lua, they are different objects */ -SWIGRUNTIME int SWIG_Lua_class_equal(lua_State *L) -{ - int result; - swig_lua_userdata *usr1,*usr2; - if (!lua_isuserdata(L,1) || !lua_isuserdata(L,2)) /* just in case */ - return 0; /* nil reply */ - usr1=(swig_lua_userdata*)lua_touserdata(L,1); /* get data */ - usr2=(swig_lua_userdata*)lua_touserdata(L,2); /* get data */ - /*result=(usr1->ptr==usr2->ptr && usr1->type==usr2->type); only works if type is the same*/ - result=(usr1->ptr==usr2->ptr); - lua_pushboolean(L,result); - return 1; -} - -/* populate table at the top of the stack with metamethods that ought to be inherited */ -SWIGINTERN void SWIG_Lua_populate_inheritable_metamethods(lua_State *L) -{ - SWIG_Lua_add_boolean(L, "__add", 1); - SWIG_Lua_add_boolean(L, "__sub", 1); - SWIG_Lua_add_boolean(L, "__mul", 1); - SWIG_Lua_add_boolean(L, "__div", 1); - SWIG_Lua_add_boolean(L, "__mod", 1); - SWIG_Lua_add_boolean(L, "__pow", 1); - SWIG_Lua_add_boolean(L, "__unm", 1); - SWIG_Lua_add_boolean(L, "__len", 1 ); - SWIG_Lua_add_boolean(L, "__concat", 1 ); - SWIG_Lua_add_boolean(L, "__eq", 1); - SWIG_Lua_add_boolean(L, "__lt", 1); - SWIG_Lua_add_boolean(L, "__le", 1); - SWIG_Lua_add_boolean(L, "__call", 1); - SWIG_Lua_add_boolean(L, "__tostring", 1); - SWIG_Lua_add_boolean(L, "__gc", 0); -} - -/* creates the swig registry */ -SWIGINTERN void SWIG_Lua_create_class_registry(lua_State *L) -{ - /* create main SWIG registry table */ - lua_pushstring(L,"SWIG"); - lua_newtable(L); - /* populate it with some predefined data */ - - /* .library table. Placeholder */ - lua_pushstring(L,".library"); - lua_newtable(L); - { - /* list of metamethods that class inherits from its bases */ - lua_pushstring(L,"inheritable_metamethods"); - lua_newtable(L); - /* populate with list of metamethods */ - SWIG_Lua_populate_inheritable_metamethods(L); - lua_rawset(L,-3); - } - lua_rawset(L,-3); - - lua_rawset(L,LUA_REGISTRYINDEX); -} - -/* gets the swig registry (or creates it) */ -SWIGINTERN void SWIG_Lua_get_class_registry(lua_State *L) -{ - /* add this all into the swig registry: */ - lua_pushstring(L,"SWIG"); - lua_rawget(L,LUA_REGISTRYINDEX); /* get the registry */ - if (!lua_istable(L,-1)) /* not there */ - { /* must be first time, so add it */ - lua_pop(L,1); /* remove the result */ - SWIG_Lua_create_class_registry(L); - /* then get it */ - lua_pushstring(L,"SWIG"); - lua_rawget(L,LUA_REGISTRYINDEX); - } -} - -SWIGINTERN void SWIG_Lua_get_inheritable_metamethods(lua_State *L) -{ - SWIG_Lua_get_class_registry(L); - lua_pushstring(L, ".library"); - lua_rawget(L,-2); - assert( !lua_isnil(L,-1) ); - lua_pushstring(L, "inheritable_metamethods"); - lua_rawget(L,-2); - - /* Remove class registry and library table */ - lua_remove(L,-2); - lua_remove(L,-2); -} - -/* Helper function to get the classes metatable from the register */ -SWIGINTERN void SWIG_Lua_get_class_metatable(lua_State *L,const char *cname) -{ - SWIG_Lua_get_class_registry(L); /* get the registry */ - lua_pushstring(L,cname); /* get the name */ - lua_rawget(L,-2); /* get it */ - lua_remove(L,-2); /* tidy up (remove registry) */ -} - -/* Set up the base classes pointers. -Each class structure has a list of pointers to the base class structures. -This function fills them. -It cannot be done at compile time, as this will not work with hireachies -spread over more than one swig file. -Therefore it must be done at runtime, querying the SWIG type system. -*/ -SWIGINTERN void SWIG_Lua_init_base_class(lua_State *L,swig_lua_class *clss) -{ - int i=0; - swig_module_info *module=SWIG_GetModule(L); - for(i=0;clss->base_names[i];i++) - { - if (clss->bases[i]==0) /* not found yet */ - { - /* lookup and cache the base class */ - swig_type_info *info = SWIG_TypeQueryModule(module,module,clss->base_names[i]); - if (info) clss->bases[i] = (swig_lua_class *) info->clientdata; - } - } -} - -#if defined(SWIG_LUA_SQUASH_BASES) && (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA) -/* Merges two tables */ -SWIGINTERN void SWIG_Lua_merge_tables_by_index(lua_State *L, int target, int source) -{ - /* iterating */ - lua_pushnil(L); - while (lua_next(L,source) != 0) { - /* -1 - value, -2 - index */ - /* have to copy to assign */ - lua_pushvalue(L,-2); /* copy of index */ - lua_pushvalue(L,-2); /* copy of value */ - lua_rawset(L, target); - lua_pop(L,1); - /* only key is left */ - } -} - -/* Merges two tables with given name. original - index of target metatable, base - index of source metatable */ -SWIGINTERN void SWIG_Lua_merge_tables(lua_State *L, const char* name, int original, int base) -{ - /* push original[name], then base[name] */ - lua_pushstring(L,name); - lua_rawget(L,original); - int original_table = lua_gettop(L); - lua_pushstring(L,name); - lua_rawget(L,base); - int base_table = lua_gettop(L); - SWIG_Lua_merge_tables_by_index(L, original_table, base_table); - /* clearing stack */ - lua_pop(L,2); -} - -/* Function takes all symbols from base and adds it to derived class. It's just a helper. */ -SWIGINTERN void SWIG_Lua_class_squash_base(lua_State *L, swig_lua_class *base_cls) -{ - /* There is one parameter - original, i.e. 'derived' class metatable */ - assert(lua_istable(L,-1)); - int original = lua_gettop(L); - SWIG_Lua_get_class_metatable(L,base_cls->fqname); - int base = lua_gettop(L); - SWIG_Lua_merge_tables(L, ".fn", original, base ); - SWIG_Lua_merge_tables(L, ".set", original, base ); - SWIG_Lua_merge_tables(L, ".get", original, base ); - lua_pop(L,1); -} - -/* Function squashes all symbols from 'clss' bases into itself */ -SWIGINTERN void SWIG_Lua_class_squash_bases(lua_State *L, swig_lua_class *clss) -{ - int i; - SWIG_Lua_get_class_metatable(L,clss->fqname); - for(i=0;clss->base_names[i];i++) - { - if (clss->bases[i]==0) /* Somehow it's not found. Skip it */ - continue; - /* Thing is: all bases are already registered. Thus they have already executed - * this function. So we just need to squash them into us, because their bases - * are already squashed into them. No need for recursion here! - */ - SWIG_Lua_class_squash_base(L, clss->bases[i]); - } - lua_pop(L,1); /*tidy stack*/ -} -#endif - -#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA) /* In elua this is useless */ -/* helper add a variable to a registered class */ -SWIGINTERN void SWIG_Lua_add_variable(lua_State *L,const char *name,lua_CFunction getFn,lua_CFunction setFn) -{ - assert(lua_istable(L,-1)); /* just in case */ - SWIG_Lua_get_table(L,".get"); /* find the .get table */ - assert(lua_istable(L,-1)); /* just in case */ - SWIG_Lua_add_function(L,name,getFn); - lua_pop(L,1); /* tidy stack (remove table) */ - if (setFn) - { - SWIG_Lua_get_table(L,".set"); /* find the .set table */ - assert(lua_istable(L,-1)); /* just in case */ - SWIG_Lua_add_function(L,name,setFn); - lua_pop(L,1); /* tidy stack (remove table) */ - } -} - -/* helper to recursively add class static details (static attributes, operations and constants) */ -SWIGINTERN void SWIG_Lua_add_class_static_details(lua_State *L, swig_lua_class *clss) -{ - int i = 0; - /* The class namespace table must be on the top of the stack */ - assert(lua_istable(L,-1)); - /* call all the base classes first: we can then override these later: */ - for(i=0;clss->bases[i];i++) - { - SWIG_Lua_add_class_static_details(L,clss->bases[i]); - } - - SWIG_Lua_add_namespace_details(L, clss->cls_static); -} - -SWIGINTERN void SWIG_Lua_add_class_user_metamethods(lua_State *L, swig_lua_class *clss); /* forward declaration */ - -/* helper to recursively add class details (attributes & operations) */ -SWIGINTERN void SWIG_Lua_add_class_instance_details(lua_State *L, swig_lua_class *clss) -{ - int i; - size_t bases_count = 0; - /* Add bases to .bases table */ - SWIG_Lua_get_table(L,".bases"); - assert(lua_istable(L,-1)); /* just in case */ - for(i=0;clss->bases[i];i++) - { - SWIG_Lua_get_class_metatable(L,clss->bases[i]->fqname); - /* Base class must be already registered */ - assert(lua_istable(L,-1)); - lua_rawseti(L,-2,i+1); /* In lua indexing starts from 1 */ - bases_count++; - } - assert(lua_rawlen(L,-1) == bases_count); - lua_pop(L,1); /* remove .bases table */ - /* add attributes */ - for(i=0;clss->attributes[i].name;i++){ - SWIG_Lua_add_variable(L,clss->attributes[i].name,clss->attributes[i].getmethod,clss->attributes[i].setmethod); - } - /* add methods to the metatable */ - SWIG_Lua_get_table(L,".fn"); /* find the .fn table */ - assert(lua_istable(L,-1)); /* just in case */ - for(i=0;clss->methods[i].name;i++){ - SWIG_Lua_add_function(L,clss->methods[i].name,clss->methods[i].func); - } - lua_pop(L,1); /* tidy stack (remove table) */ - /* add operator overloads - This adds methods from metatable array to metatable. Can mess up garbage - collectind if someone defines __gc method - */ - if(clss->metatable) { - for(i=0;clss->metatable[i].name;i++) { - SWIG_Lua_add_function(L,clss->metatable[i].name,clss->metatable[i].func); - } - } - -#if !defined(SWIG_LUA_SQUASH_BASES) - /* Adding metamethods that are defined in base classes. If bases were squashed - * then it is obviously unnecessary - */ - SWIG_Lua_add_class_user_metamethods(L, clss); -#endif -} - -/* Helpers to add user defined class metamedhods - __add, __sub etc. The helpers are needed - for the following issue: Lua runtime checks for metamethod existence with rawget function - ignoring our SWIG-provided __index and __newindex functions. Thus our inheritance-aware method - search algorithm doesn't work in such case. (Not to say that Lua runtime queries metamethod directly - in metatable and not in object). - Current solution is this: if somewhere in hierarchy metamethod __x is defined, then all descendants - are automatically given a special proxy __x that calls the real __x method. - Obvious idea - to copy __x instead of creating __x-proxy is wrong because if someone changes __x in runtime, - those changes must be reflected in all descendants. -*/ - -SWIGRUNTIME int SWIG_Lua_resolve_metamethod(lua_State *L); /*forward declaration*/ - -/* The real function that resolves a metamethod. - * Function searches given class and all it's bases(recursively) for first instance of something that is - * not equal to SWIG_Lua_resolve_metatmethod. (Almost always this 'something' is actual metamethod implementation - * and it is a SWIG-generated C function.). It returns value on the top of the L and there is no garbage below the - * answer. - * Returns 1 if found, 0 otherwise. - * clss is class which metatable we will search for method - * metamethod_name_idx is index in L where metamethod name (as string) lies - * skip_check allows to skip searching metamethod in givel clss and immideatelly go to searching in bases. skip_check - * is not caried to subsequent recursive calls - false is always passed. It is set to true only at first call from - * SWIG_Lua_resolve_metamethod - * */ -SWIGINTERN int SWIG_Lua_do_resolve_metamethod(lua_State *L, const swig_lua_class *clss, int metamethod_name_idx, - int skip_check) -{ - /* This function is called recursively */ - int result = 0; - int i = 0; - - if (!skip_check) { - SWIG_Lua_get_class_metatable(L, clss->fqname); - lua_pushvalue(L, metamethod_name_idx); - lua_rawget(L,-2); - /* If this is cfunction and it is equal to SWIG_Lua_resolve_metamethod then - * this isn't the function we are looking for :) - * lua_tocfunction will return NULL if not cfunction - */ - if (!lua_isnil(L,-1) && lua_tocfunction(L,-1) != SWIG_Lua_resolve_metamethod ) { - lua_remove(L,-2); /* removing class metatable */ - return 1; - } - lua_pop(L,2); /* remove class metatable and query result */ - } - - /* Forwarding calls to bases */ - for(i=0;clss->bases[i];i++) - { - result = SWIG_Lua_do_resolve_metamethod(L, clss->bases[i], metamethod_name_idx, 0); - if (result) - break; - } - - return result; -} - -/* The proxy function for metamethod. All parameters are passed as cclosure. Searches for actual method - * and calls it */ -SWIGRUNTIME int SWIG_Lua_resolve_metamethod(lua_State *L) -{ - int numargs; - int metamethod_name_idx; - const swig_lua_class* clss; - int result; - - lua_checkstack(L,5); - numargs = lua_gettop(L); /* number of arguments to pass to actual metamethod */ - - /* Get upvalues from closure */ - lua_pushvalue(L, lua_upvalueindex(1)); /*Get function name*/ - metamethod_name_idx = lua_gettop(L); - - lua_pushvalue(L, lua_upvalueindex(2)); - clss = (const swig_lua_class*)(lua_touserdata(L,-1)); - lua_pop(L,1); /* remove lightuserdata with clss from stack */ - - /* Actual work */ - result = SWIG_Lua_do_resolve_metamethod(L, clss, metamethod_name_idx, 1); - if (!result) { - SWIG_Lua_pushferrstring(L,"The metamethod proxy is set, but it failed to find actual metamethod. Memory corruption is most likely explanation."); - lua_error(L); - return 0; - } - - lua_remove(L,-2); /* remove metamethod key */ - lua_insert(L,1); /* move function to correct position */ - lua_call(L, numargs, LUA_MULTRET); - return lua_gettop(L); /* return all results */ -} - - -/* If given metamethod must be present in given class, then creates appropriate proxy - * Returns 1 if successfully added, 0 if not added because no base class has it, -1 - * if method is defined in the class metatable itself - */ -SWIGINTERN int SWIG_Lua_add_class_user_metamethod(lua_State *L, swig_lua_class *clss, const int metatable_index) -{ - int key_index; - int success = 0; - int i = 0; - - /* metamethod name - on the top of the stack */ - assert(lua_isstring(L,-1)); - - key_index = lua_gettop(L); - - /* Check whether method is already defined in metatable */ - lua_pushvalue(L,key_index); /* copy of the key */ - lua_gettable(L,metatable_index); - if( !lua_isnil(L,-1) ) { - lua_pop(L,1); - return -1; - } - lua_pop(L,1); - - /* Iterating over immediate bases */ - for(i=0;clss->bases[i];i++) - { - const swig_lua_class *base = clss->bases[i]; - SWIG_Lua_get_class_metatable(L, base->fqname); - lua_pushvalue(L, key_index); - lua_rawget(L, -2); - if( !lua_isnil(L,-1) ) { - lua_pushvalue(L, key_index); - - /* Add proxy function */ - lua_pushvalue(L, key_index); /* first closure value is function name */ - lua_pushlightuserdata(L, clss); /* second closure value is swig_lua_class structure */ - lua_pushcclosure(L, SWIG_Lua_resolve_metamethod, 2); - - lua_rawset(L, metatable_index); - success = 1; - } - lua_pop(L,1); /* remove function or nil */ - lua_pop(L,1); /* remove base class metatable */ - - if( success ) - break; - } - - return success; -} - -SWIGINTERN void SWIG_Lua_add_class_user_metamethods(lua_State *L, swig_lua_class *clss) -{ - int metatable_index; - int metamethods_info_index; - int tostring_undefined; - int eq_undefined = 0; - - SWIG_Lua_get_class_metatable(L, clss->fqname); - metatable_index = lua_gettop(L); - SWIG_Lua_get_inheritable_metamethods(L); - assert(lua_istable(L,-1)); - metamethods_info_index = lua_gettop(L); - lua_pushnil(L); /* first key */ - while(lua_next(L, metamethods_info_index) != 0 ) { - /* key at index -2, value at index -1 */ - const int is_inheritable = lua_toboolean(L,-2); - lua_pop(L,1); /* remove value - we don't need it anymore */ - - if(is_inheritable) { /* if metamethod is inheritable */ - SWIG_Lua_add_class_user_metamethod(L,clss,metatable_index); - } - } - - lua_pop(L,1); /* remove inheritable metatmethods table */ - - /* Special handling for __tostring method */ - lua_pushstring(L, "__tostring"); - lua_pushvalue(L,-1); - lua_rawget(L,metatable_index); - tostring_undefined = lua_isnil(L,-1); - lua_pop(L,1); - if( tostring_undefined ) { - lua_pushcfunction(L, SWIG_Lua_class_tostring); - lua_rawset(L, metatable_index); - } else { - lua_pop(L,1); /* remove copy of the key */ - } - - /* Special handling for __eq method */ - lua_pushstring(L, "__eq"); - lua_pushvalue(L,-1); - lua_rawget(L,metatable_index); - eq_undefined = lua_isnil(L,-1); - lua_pop(L,1); - if( eq_undefined ) { - lua_pushcfunction(L, SWIG_Lua_class_equal); - lua_rawset(L, metatable_index); - } else { - lua_pop(L,1); /* remove copy of the key */ - } - /* Warning: __index and __newindex are SWIG-defined. For user-defined operator[] - * a __getitem/__setitem method should be defined - */ - lua_pop(L,1); /* pop class metatable */ -} - -/* Register class static methods,attributes etc as well as constructor proxy */ -SWIGINTERN void SWIG_Lua_class_register_static(lua_State *L, swig_lua_class *clss) -{ - const int SWIGUNUSED begin = lua_gettop(L); - lua_checkstack(L,5); /* just in case */ - assert(lua_istable(L,-1)); /* just in case */ - assert(strcmp(clss->name, clss->cls_static->name) == 0); /* in class those 2 must be equal */ - - SWIG_Lua_namespace_register(L,clss->cls_static, 1); - - assert(lua_istable(L,-1)); /* just in case */ - - /* add its constructor to module with the name of the class - so you can do MyClass(...) as well as new_MyClass(...) - BUT only if a constructor is defined - (this overcomes the problem of pure virtual classes without constructors)*/ - if (clss->constructor) - { - lua_getmetatable(L,-1); - assert(lua_istable(L,-1)); /* just in case */ - SWIG_Lua_add_function(L,"__call", clss->constructor); - lua_pop(L,1); - } - - assert(lua_istable(L,-1)); /* just in case */ - SWIG_Lua_add_class_static_details(L, clss); - - /* clear stack */ - lua_pop(L,1); - assert( lua_gettop(L) == begin ); -} - -/* Performs the instance (non-static) class registration process. Metatable for class is created - * and added to the class registry. - */ -SWIGINTERN void SWIG_Lua_class_register_instance(lua_State *L,swig_lua_class *clss) -{ - const int SWIGUNUSED begin = lua_gettop(L); - int i; - /* if name already there (class is already registered) then do nothing */ - SWIG_Lua_get_class_registry(L); /* get the registry */ - lua_pushstring(L,clss->fqname); /* get the name */ - lua_rawget(L,-2); - if(!lua_isnil(L,-1)) { - lua_pop(L,2); - assert(lua_gettop(L)==begin); - return; - } - lua_pop(L,2); /* tidy stack */ - /* Recursively initialize all bases */ - for(i=0;clss->bases[i];i++) - { - SWIG_Lua_class_register_instance(L,clss->bases[i]); - } - /* Again, get registry and push name */ - SWIG_Lua_get_class_registry(L); /* get the registry */ - lua_pushstring(L,clss->fqname); /* get the name */ - lua_newtable(L); /* create the metatable */ -#if defined(SWIG_LUA_SQUASH_BASES) && (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA) - /* If squashing is requested, then merges all bases metatable into this one. - * It would get us all special methods: __getitem, __add etc. - * This would set .fn, .type, and other .xxx incorrectly, but we will overwrite it right away - */ - { - int new_metatable_index = lua_absindex(L,-1); - for(i=0;clss->bases[i];i++) - { - int base_metatable; - SWIG_Lua_get_class_metatable(L,clss->bases[i]->fqname); - base_metatable = lua_absindex(L,-1); - SWIG_Lua_merge_tables_by_index(L,new_metatable_index, base_metatable); - lua_pop(L,1); - } - } - /* And now we will overwrite all incorrectly set data */ -#endif - /* add string of class name called ".type" */ - lua_pushstring(L,".type"); - lua_pushstring(L,clss->fqname); - lua_rawset(L,-3); - /* add a table called bases */ - lua_pushstring(L,".bases"); - lua_newtable(L); - lua_rawset(L,-3); - /* add a table called ".get" */ - lua_pushstring(L,".get"); - lua_newtable(L); - lua_rawset(L,-3); - /* add a table called ".set" */ - lua_pushstring(L,".set"); - lua_newtable(L); - lua_rawset(L,-3); - /* add a table called ".fn" */ - lua_pushstring(L,".fn"); - lua_newtable(L); - /* add manual disown method */ - SWIG_Lua_add_function(L,"__disown",SWIG_Lua_class_disown); - lua_rawset(L,-3); - /* add accessor fns for using the .get,.set&.fn */ - SWIG_Lua_add_function(L,"__index",SWIG_Lua_class_get); - SWIG_Lua_add_function(L,"__newindex",SWIG_Lua_class_set); - SWIG_Lua_add_function(L,"__gc",SWIG_Lua_class_destruct); - /* add it */ - lua_rawset(L,-3); /* metatable into registry */ - lua_pop(L,1); /* tidy stack (remove registry) */ - assert(lua_gettop(L) == begin); - -#if defined(SWIG_LUA_SQUASH_BASES) && (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA) - /* Now merge all symbols from .fn, .set, .get etc from bases to our tables */ - SWIG_Lua_class_squash_bases(L,clss); -#endif - SWIG_Lua_get_class_metatable(L,clss->fqname); - SWIG_Lua_add_class_instance_details(L,clss); /* recursive adding of details (atts & ops) */ - lua_pop(L,1); /* tidy stack (remove class metatable) */ - assert( lua_gettop(L) == begin ); -} - -SWIGINTERN void SWIG_Lua_class_register(lua_State *L,swig_lua_class *clss) -{ - int SWIGUNUSED begin; - assert(lua_istable(L,-1)); /* This is a table (module or namespace) where classes will be added */ - SWIG_Lua_class_register_instance(L,clss); - SWIG_Lua_class_register_static(L,clss); - - /* Add links from static part to instance part and vice versa */ - /* [SWIG registry] [Module] - * "MyClass" ----> [MyClass metatable] <===== "MyClass" -+> [static part] - * ".get" ----> ... | | getmetatable()----| - * ".set" ----> ... | | | - * ".static" --------------)----------------/ [static part metatable] - * | ".get" --> ... - * | ".set" --> .... - * |=============================== ".instance" - */ - begin = lua_gettop(L); - lua_pushstring(L,clss->cls_static->name); - lua_rawget(L,-2); /* get class static table */ - assert(lua_istable(L,-1)); - lua_getmetatable(L,-1); - assert(lua_istable(L,-1)); /* get class static metatable */ - lua_pushstring(L,".instance"); /* prepare key */ - - SWIG_Lua_get_class_metatable(L,clss->fqname); /* get class metatable */ - assert(lua_istable(L,-1)); - lua_pushstring(L,".static"); /* prepare key */ - lua_pushvalue(L, -4); /* push static class TABLE */ - assert(lua_istable(L,-1)); - lua_rawset(L,-3); /* assign static class table(!NOT metatable) as ".static" member of class metatable */ - lua_rawset(L,-3); /* assign class metatable as ".instance" member of class static METATABLE */ - lua_pop(L,2); - assert(lua_gettop(L) == begin); -} -#endif /* SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA */ - -#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC) -SWIGINTERN void SWIG_Lua_elua_class_register_instance(lua_State *L, swig_lua_class *clss) -{ - const int SWIGUNUSED begin = lua_gettop(L); - int i; - /* if name already there (class is already registered) then do nothing */ - SWIG_Lua_get_class_registry(L); /* get the registry */ - lua_pushstring(L,clss->fqname); /* get the name */ - lua_rawget(L,-2); - if(!lua_isnil(L,-1)) { - lua_pop(L,2); - assert(lua_gettop(L)==begin); - return; - } - lua_pop(L,2); /* tidy stack */ - /* Recursively initialize all bases */ - for(i=0;clss->bases[i];i++) - { - SWIG_Lua_elua_class_register_instance(L,clss->bases[i]); - } - /* Again, get registry and push name */ - SWIG_Lua_get_class_registry(L); /* get the registry */ - lua_pushstring(L,clss->fqname); /* get the name */ - assert(clss->metatable); - lua_pushrotable(L, (void*)(clss->metatable)); /* create the metatable */ - lua_rawset(L,-3); - lua_pop(L,1); - assert(lua_gettop(L) == begin); -} -#endif /* elua && eluac */ - -/* ----------------------------------------------------------------------------- - * Class/structure conversion fns - * ----------------------------------------------------------------------------- */ - -/* helper to add metatable to new lua object */ -SWIGINTERN void SWIG_Lua_AddMetatable(lua_State *L,swig_type_info *type) -{ - if (type->clientdata) /* there is clientdata: so add the metatable */ - { - SWIG_Lua_get_class_metatable(L,((swig_lua_class*)(type->clientdata))->fqname); - if (lua_istable(L,-1)) - { - lua_setmetatable(L,-2); - } - else - { - lua_pop(L,1); - } - } -} - -/* pushes a new object into the lua stack */ -SWIGRUNTIME void SWIG_Lua_NewPointerObj(lua_State *L,void *ptr,swig_type_info *type, int own) -{ - swig_lua_userdata *usr; - if (!ptr){ - lua_pushnil(L); - return; - } - usr=(swig_lua_userdata*)lua_newuserdata(L,sizeof(swig_lua_userdata)); /* get data */ - usr->ptr=ptr; /* set the ptr */ - usr->type=type; - usr->own=own; -#if (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC) - SWIG_Lua_AddMetatable(L,type); /* add metatable */ -#endif -} - -/* takes a object from the lua stack & converts it into an object of the correct type - (if possible) */ -SWIGRUNTIME int SWIG_Lua_ConvertPtr(lua_State *L,int index,void **ptr,swig_type_info *type,int flags) -{ - swig_lua_userdata *usr; - swig_cast_info *cast; - if (lua_isnil(L,index)){*ptr=0; return SWIG_OK;} /* special case: lua nil => NULL pointer */ - usr=(swig_lua_userdata*)lua_touserdata(L,index); /* get data */ - if (usr) - { - if (flags & SWIG_POINTER_DISOWN) /* must disown the object */ - { - usr->own=0; - } - if (!type) /* special cast void*, no casting fn */ - { - *ptr=usr->ptr; - return SWIG_OK; /* ok */ - } - cast=SWIG_TypeCheckStruct(usr->type,type); /* performs normal type checking */ - if (cast) - { - int newmemory = 0; - *ptr=SWIG_TypeCast(cast,usr->ptr,&newmemory); - assert(!newmemory); /* newmemory handling not yet implemented */ - return SWIG_OK; /* ok */ - } - } - return SWIG_ERROR; /* error */ -} - -SWIGRUNTIME void* SWIG_Lua_MustGetPtr(lua_State *L,int index,swig_type_info *type,int flags, - int argnum,const char *func_name){ - void *result; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,index,&result,type,flags))){ - luaL_error (L,"Error in %s, expected a %s at argument number %d\n", - func_name,(type && type->str)?type->str:"void*",argnum); - } - return result; -} - -/* pushes a packed userdata. user for member fn pointers only */ -SWIGRUNTIME void SWIG_Lua_NewPackedObj(lua_State *L,void *ptr,size_t size,swig_type_info *type) -{ - swig_lua_rawdata *raw; - assert(ptr); /* not acceptable to pass in a NULL value */ - raw=(swig_lua_rawdata*)lua_newuserdata(L,sizeof(swig_lua_rawdata)-1+size); /* alloc data */ - raw->type=type; - raw->own=0; - memcpy(raw->data,ptr,size); /* copy the data */ - SWIG_Lua_AddMetatable(L,type); /* add metatable */ -} - -/* converts a packed userdata. user for member fn pointers only */ -SWIGRUNTIME int SWIG_Lua_ConvertPacked(lua_State *L,int index,void *ptr,size_t size,swig_type_info *type) -{ - swig_lua_rawdata *raw; - raw=(swig_lua_rawdata*)lua_touserdata(L,index); /* get data */ - if (!raw) return SWIG_ERROR; /* error */ - if (type==0 || type==raw->type) /* void* or identical type */ - { - memcpy(ptr,raw->data,size); /* copy it */ - return SWIG_OK; /* ok */ - } - return SWIG_ERROR; /* error */ -} - -/* a function to get the typestring of a piece of data */ -SWIGRUNTIME const char *SWIG_Lua_typename(lua_State *L, int tp) -{ - swig_lua_userdata *usr; - if (lua_isuserdata(L,tp)) - { - usr=(swig_lua_userdata*)lua_touserdata(L,tp); /* get data */ - if (usr && usr->type && usr->type->str) - return usr->type->str; - return "userdata (unknown type)"; - } - return lua_typename(L,lua_type(L,tp)); -} - -/* lua callable function to get the userdata's type */ -SWIGRUNTIME int SWIG_Lua_type(lua_State *L) -{ - lua_pushstring(L,SWIG_Lua_typename(L,1)); - return 1; -} - -/* ----------------------------------------------------------------------------- - * global variable support code: class/struct typemap functions - * ----------------------------------------------------------------------------- */ - -#if ((SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUA) && (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC)) -/* Install Constants */ -SWIGINTERN void -SWIG_Lua_InstallConstants(lua_State *L, swig_lua_const_info constants[]) { - int i; - for (i = 0; constants[i].type; i++) { - switch(constants[i].type) { - case SWIG_LUA_INT: - lua_pushstring(L,constants[i].name); - lua_pushinteger(L,(lua_Number)constants[i].lvalue); - lua_rawset(L,-3); - break; - case SWIG_LUA_FLOAT: - lua_pushstring(L,constants[i].name); - lua_pushnumber(L,(lua_Number)constants[i].dvalue); - lua_rawset(L,-3); - break; - case SWIG_LUA_CHAR: - lua_pushstring(L,constants[i].name); - { - char c = constants[i].lvalue; - lua_pushlstring(L,&c,1); - } - lua_rawset(L,-3); - break; - case SWIG_LUA_STRING: - lua_pushstring(L,constants[i].name); - lua_pushstring(L,(char *) constants[i].pvalue); - lua_rawset(L,-3); - break; - case SWIG_LUA_POINTER: - lua_pushstring(L,constants[i].name); - SWIG_NewPointerObj(L,constants[i].pvalue, *(constants[i]).ptype,0); - lua_rawset(L,-3); - break; - case SWIG_LUA_BINARY: - lua_pushstring(L,constants[i].name); - SWIG_NewMemberObj(L,constants[i].pvalue,constants[i].lvalue,*(constants[i]).ptype); - lua_rawset(L,-3); - break; - default: - break; - } - } -} -#endif - -/* ----------------------------------------------------------------------------- - * executing lua code from within the wrapper - * ----------------------------------------------------------------------------- */ - -#ifndef SWIG_DOSTRING_FAIL /* Allows redefining of error function */ -#define SWIG_DOSTRING_FAIL(S) fprintf(stderr,"%s\n",S) -#endif -/* Executes a C string in Lua which is a really simple way of calling lua from C -Unfortunately lua keeps changing its APIs, so we need a conditional compile -In lua 5.0.X it's lua_dostring() -In lua 5.1.X it's luaL_dostring() -*/ -SWIGINTERN int -SWIG_Lua_dostring(lua_State *L, const char *str) { - int ok,top; - if (str==0 || str[0]==0) return 0; /* nothing to do */ - top=lua_gettop(L); /* save stack */ -#if (defined(LUA_VERSION_NUM) && (LUA_VERSION_NUM>=501)) - ok=luaL_dostring(L,str); /* looks like this is lua 5.1.X or later, good */ -#else - ok=lua_dostring(L,str); /* might be lua 5.0.x, using lua_dostring */ -#endif - if (ok!=0) { - SWIG_DOSTRING_FAIL(lua_tostring(L,-1)); - } - lua_settop(L,top); /* restore the stack */ - return ok; -} - -#ifdef __cplusplus -} -#endif - -/* ------------------------------ end luarun.swg ------------------------------ */ - -/* Errors in SWIG */ -#define SWIG_UnknownError -1 -#define SWIG_IOError -2 -#define SWIG_RuntimeError -3 -#define SWIG_IndexError -4 -#define SWIG_TypeError -5 -#define SWIG_DivisionByZero -6 -#define SWIG_OverflowError -7 -#define SWIG_SyntaxError -8 -#define SWIG_ValueError -9 -#define SWIG_SystemError -10 -#define SWIG_AttributeError -11 -#define SWIG_MemoryError -12 -#define SWIG_NullReferenceError -13 - - - - -/* -------- TYPES TABLE (BEGIN) -------- */ - -#define SWIGTYPE_p_GLintptr swig_types[0] -#define SWIGTYPE_p_GLsizei swig_types[1] -#define SWIGTYPE_p_GLsizeiptr swig_types[2] -#define SWIGTYPE_p_double swig_types[3] -#define SWIGTYPE_p_float swig_types[4] -#define SWIGTYPE_p_fstream swig_types[5] -#define SWIGTYPE_p_int swig_types[6] -#define SWIGTYPE_p_long_long swig_types[7] -#define SWIGTYPE_p_of3dPrimitive swig_types[8] -#define SWIGTYPE_p_ofAbstractImage swig_types[9] -#define SWIGTYPE_p_ofAbstractParameter swig_types[10] -#define SWIGTYPE_p_ofAppBaseWindow swig_types[11] -#define SWIGTYPE_p_ofArduino swig_types[12] -#define SWIGTYPE_p_ofBaseApp swig_types[13] -#define SWIGTYPE_p_ofBaseDraws swig_types[14] -#define SWIGTYPE_p_ofBaseFileSerializer swig_types[15] -#define SWIGTYPE_p_ofBaseGLRenderer swig_types[16] -#define SWIGTYPE_p_ofBaseHasPixels swig_types[17] -#define SWIGTYPE_p_ofBaseHasTexture swig_types[18] -#define SWIGTYPE_p_ofBaseHasTexturePlanes swig_types[19] -#define SWIGTYPE_p_ofBaseImage_T_float_t swig_types[20] -#define SWIGTYPE_p_ofBaseImage_T_unsigned_char_t swig_types[21] -#define SWIGTYPE_p_ofBaseImage_T_unsigned_short_t swig_types[22] -#define SWIGTYPE_p_ofBaseLoggerChannel swig_types[23] -#define SWIGTYPE_p_ofBaseMaterial swig_types[24] -#define SWIGTYPE_p_ofBaseRenderer swig_types[25] -#define SWIGTYPE_p_ofBaseSerializer swig_types[26] -#define SWIGTYPE_p_ofBaseSoundInput swig_types[27] -#define SWIGTYPE_p_ofBaseSoundOutput swig_types[28] -#define SWIGTYPE_p_ofBaseSoundPlayer swig_types[29] -#define SWIGTYPE_p_ofBaseUpdates swig_types[30] -#define SWIGTYPE_p_ofBaseVideo swig_types[31] -#define SWIGTYPE_p_ofBaseVideoDraws swig_types[32] -#define SWIGTYPE_p_ofBaseVideoGrabber swig_types[33] -#define SWIGTYPE_p_ofBaseVideoPlayer swig_types[34] -#define SWIGTYPE_p_ofBoxPrimitive swig_types[35] -#define SWIGTYPE_p_ofBuffer swig_types[36] -#define SWIGTYPE_p_ofBufferObject swig_types[37] -#define SWIGTYPE_p_ofCamera swig_types[38] -#define SWIGTYPE_p_ofColor_T_float_t swig_types[39] -#define SWIGTYPE_p_ofColor_T_unsigned_char_t swig_types[40] -#define SWIGTYPE_p_ofColor_T_unsigned_short_t swig_types[41] -#define SWIGTYPE_p_ofConePrimitive swig_types[42] -#define SWIGTYPE_p_ofConsoleLoggerChannel swig_types[43] -#define SWIGTYPE_p_ofCoreEvents swig_types[44] -#define SWIGTYPE_p_ofCylinderPrimitive swig_types[45] -#define SWIGTYPE_p_ofDirectory swig_types[46] -#define SWIGTYPE_p_ofDragInfo swig_types[47] -#define SWIGTYPE_p_ofEasyCam swig_types[48] -#define SWIGTYPE_p_ofEventArgs swig_types[49] -#define SWIGTYPE_p_ofEventT_int_const_t swig_types[50] -#define SWIGTYPE_p_ofEventT_ofHttpResponse_t swig_types[51] -#define SWIGTYPE_p_ofEventT_std__string_const_t swig_types[52] -#define SWIGTYPE_p_ofEventT_std__vectorT_unsigned_char_t_const_t swig_types[53] -#define SWIGTYPE_p_ofFbo swig_types[54] -#define SWIGTYPE_p_ofFbo__Settings swig_types[55] -#define SWIGTYPE_p_ofFile swig_types[56] -#define SWIGTYPE_p_ofFileDialogResult swig_types[57] -#define SWIGTYPE_p_ofFileLoggerChannel swig_types[58] -#define SWIGTYPE_p_ofFilePath swig_types[59] -#define SWIGTYPE_p_ofFpsCounter swig_types[60] -#define SWIGTYPE_p_ofHttpRequest swig_types[61] -#define SWIGTYPE_p_ofHttpResponse swig_types[62] -#define SWIGTYPE_p_ofIcoSpherePrimitive swig_types[63] -#define SWIGTYPE_p_ofImage_T_float_t swig_types[64] -#define SWIGTYPE_p_ofImage_T_unsigned_char_t swig_types[65] -#define SWIGTYPE_p_ofImage_T_unsigned_short_t swig_types[66] -#define SWIGTYPE_p_ofKeyEventArgs swig_types[67] -#define SWIGTYPE_p_ofLight swig_types[68] -#define SWIGTYPE_p_ofLog swig_types[69] -#define SWIGTYPE_p_ofLogError swig_types[70] -#define SWIGTYPE_p_ofLogFatalError swig_types[71] -#define SWIGTYPE_p_ofLogNotice swig_types[72] -#define SWIGTYPE_p_ofLogVerbose swig_types[73] -#define SWIGTYPE_p_ofLogWarning swig_types[74] -#define SWIGTYPE_p_ofMaterial swig_types[75] -#define SWIGTYPE_p_ofMatrix3x3 swig_types[76] -#define SWIGTYPE_p_ofMatrix4x4 swig_types[77] -#define SWIGTYPE_p_ofMatrixStack swig_types[78] -#define SWIGTYPE_p_ofMesh swig_types[79] -#define SWIGTYPE_p_ofMeshFace swig_types[80] -#define SWIGTYPE_p_ofMessage swig_types[81] -#define SWIGTYPE_p_ofMouseEventArgs swig_types[82] -#define SWIGTYPE_p_ofNode swig_types[83] -#define SWIGTYPE_p_ofParameterGroup swig_types[84] -#define SWIGTYPE_p_ofPath swig_types[85] -#define SWIGTYPE_p_ofPixels_T_float_t swig_types[86] -#define SWIGTYPE_p_ofPixels_T_unsigned_char_t swig_types[87] -#define SWIGTYPE_p_ofPixels_T_unsigned_short_t swig_types[88] -#define SWIGTYPE_p_ofPlanePrimitive swig_types[89] -#define SWIGTYPE_p_ofPolyline swig_types[90] -#define SWIGTYPE_p_ofQuaternion swig_types[91] -#define SWIGTYPE_p_ofRectangle swig_types[92] -#define SWIGTYPE_p_ofResizeEventArgs swig_types[93] -#define SWIGTYPE_p_ofSerial swig_types[94] -#define SWIGTYPE_p_ofSerialDeviceInfo swig_types[95] -#define SWIGTYPE_p_ofShader swig_types[96] -#define SWIGTYPE_p_ofSoundDevice swig_types[97] -#define SWIGTYPE_p_ofSoundPlayer swig_types[98] -#define SWIGTYPE_p_ofSoundStream swig_types[99] -#define SWIGTYPE_p_ofSpherePrimitive swig_types[100] -#define SWIGTYPE_p_ofStyle swig_types[101] -#define SWIGTYPE_p_ofTexture swig_types[102] -#define SWIGTYPE_p_ofTextureData swig_types[103] -#define SWIGTYPE_p_ofTouchEventArgs swig_types[104] -#define SWIGTYPE_p_ofTrueTypeFont swig_types[105] -#define SWIGTYPE_p_ofURLFileLoader swig_types[106] -#define SWIGTYPE_p_ofVbo swig_types[107] -#define SWIGTYPE_p_ofVboMesh swig_types[108] -#define SWIGTYPE_p_ofVec2f swig_types[109] -#define SWIGTYPE_p_ofVec3f swig_types[110] -#define SWIGTYPE_p_ofVec4f swig_types[111] -#define SWIGTYPE_p_ofVideoDevice swig_types[112] -#define SWIGTYPE_p_ofVideoGrabber swig_types[113] -#define SWIGTYPE_p_ofVideoPlayer swig_types[114] -#define SWIGTYPE_p_ofXml swig_types[115] -#define SWIGTYPE_p_shared_ptrT_ofBaseRenderer_t swig_types[116] -#define SWIGTYPE_p_shared_ptrT_ofBaseSoundPlayer_t swig_types[117] -#define SWIGTYPE_p_shared_ptrT_ofBaseSoundStream_t swig_types[118] -#define SWIGTYPE_p_shared_ptrT_ofBaseVideoGrabber_t swig_types[119] -#define SWIGTYPE_p_std__filesystem__path swig_types[120] -#define SWIGTYPE_p_std__mapT_std__string_std__string_t swig_types[121] -#define SWIGTYPE_p_std__string swig_types[122] -#define SWIGTYPE_p_std__vectorT_float_t swig_types[123] -#define SWIGTYPE_p_std__vectorT_int_t swig_types[124] -#define SWIGTYPE_p_std__vectorT_ofColor_T_float_t_t swig_types[125] -#define SWIGTYPE_p_std__vectorT_ofFile_t swig_types[126] -#define SWIGTYPE_p_std__vectorT_ofMeshFace_t swig_types[127] -#define SWIGTYPE_p_std__vectorT_ofPath__Command_t swig_types[128] -#define SWIGTYPE_p_std__vectorT_ofPath_t swig_types[129] -#define SWIGTYPE_p_std__vectorT_ofPolyline_t swig_types[130] -#define SWIGTYPE_p_std__vectorT_ofSerialDeviceInfo_t swig_types[131] -#define SWIGTYPE_p_std__vectorT_ofSoundDevice_t swig_types[132] -#define SWIGTYPE_p_std__vectorT_ofTexture_t swig_types[133] -#define SWIGTYPE_p_std__vectorT_ofVec2f_t swig_types[134] -#define SWIGTYPE_p_std__vectorT_ofVec3f_t swig_types[135] -#define SWIGTYPE_p_std__vectorT_ofVideoDevice_t swig_types[136] -#define SWIGTYPE_p_std__vectorT_std__string_t swig_types[137] -#define SWIGTYPE_p_std__vectorT_unsigned_char_t swig_types[138] -#define SWIGTYPE_p_std__vectorT_unsigned_short_t swig_types[139] -#define SWIGTYPE_p_std__vectorT_weak_ptrT_ofLight__Data_t_t swig_types[140] -#define SWIGTYPE_p_unsigned_char swig_types[141] -#define SWIGTYPE_p_unsigned_int swig_types[142] -#define SWIGTYPE_p_unsigned_long_long swig_types[143] -#define SWIGTYPE_p_unsigned_short swig_types[144] -static swig_type_info *swig_types[146]; -static swig_module_info swig_module = {swig_types, 145, 0, 0, 0, 0}; -#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) -#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) - -/* -------- TYPES TABLE (END) -------- */ - -#define SWIG_name "of" -#define SWIG_init luaopen_of -#define SWIG_init_user luaopen_of_user - -#define SWIG_LUACODE luaopen_of_luacode - -namespace swig { -typedef struct{} LANGUAGE_OBJ; -} - - - #include "ofMain.h" - #undef check - - -#include - - -#ifdef __cplusplus /* generic alloc/dealloc fns*/ -#define SWIG_ALLOC_ARRAY(TYPE,LEN) new TYPE[LEN] -#define SWIG_FREE_ARRAY(PTR) delete[] PTR -#else -#define SWIG_ALLOC_ARRAY(TYPE,LEN) (TYPE *)malloc(LEN*sizeof(TYPE)) -#define SWIG_FREE_ARRAY(PTR) free(PTR) -#endif -/* counting the size of arrays:*/ -SWIGINTERN int SWIG_itable_size(lua_State* L, int index) -{ - int n=0; - while(1){ - lua_rawgeti(L,index,n+1); - if (lua_isnil(L,-1))break; - ++n; - lua_pop(L,1); - } - lua_pop(L,1); - return n; -} - -SWIGINTERN int SWIG_table_size(lua_State* L, int index) -{ - int n=0; - lua_pushnil(L); /* first key*/ - while (lua_next(L, index) != 0) { - ++n; - lua_pop(L, 1); /* removes `value'; keeps `key' for next iteration*/ - } - return n; -} - -/* super macro to declare array typemap helper fns */ -#define SWIG_DECLARE_TYPEMAP_ARR_FN(NAME,TYPE)\ - SWIGINTERN int SWIG_read_##NAME##_num_array(lua_State* L,int index,TYPE *array,int size){\ - int i;\ - for (i = 0; i < size; i++) {\ - lua_rawgeti(L,index,i+1);\ - if (lua_isnumber(L,-1)){\ - array[i] = (TYPE)lua_tonumber(L,-1);\ - } else {\ - lua_pop(L,1);\ - return 0;\ - }\ - lua_pop(L,1);\ - }\ - return 1;\ - }\ - SWIGINTERN TYPE* SWIG_get_##NAME##_num_array_fixed(lua_State* L, int index, int size){\ - TYPE *array;\ - if (!lua_istable(L,index) || SWIG_itable_size(L,index) != size) {\ - SWIG_Lua_pushferrstring(L,"expected a table of size %d",size);\ - return 0;\ - }\ - array=SWIG_ALLOC_ARRAY(TYPE,size);\ - if (!SWIG_read_##NAME##_num_array(L,index,array,size)){\ - SWIG_Lua_pusherrstring(L,"table must contain numbers");\ - SWIG_FREE_ARRAY(array);\ - return 0;\ - }\ - return array;\ - }\ - SWIGINTERN TYPE* SWIG_get_##NAME##_num_array_var(lua_State* L, int index, int* size)\ - {\ - TYPE *array;\ - if (!lua_istable(L,index)) {\ - SWIG_Lua_pusherrstring(L,"expected a table");\ - return 0;\ - }\ - *size=SWIG_itable_size(L,index);\ - if (*size<1){\ - SWIG_Lua_pusherrstring(L,"table appears to be empty");\ - return 0;\ - }\ - array=SWIG_ALLOC_ARRAY(TYPE,*size);\ - if (!SWIG_read_##NAME##_num_array(L,index,array,*size)){\ - SWIG_Lua_pusherrstring(L,"table must contain numbers");\ - SWIG_FREE_ARRAY(array);\ - return 0;\ - }\ - return array;\ - }\ - SWIGINTERN void SWIG_write_##NAME##_num_array(lua_State* L,TYPE *array,int size){\ - int i;\ - lua_newtable(L);\ - for (i = 0; i < size; i++){\ - lua_pushnumber(L,(lua_Number)array[i]);\ - lua_rawseti(L,-2,i+1);/* -1 is the number, -2 is the table*/ \ - }\ - } - -SWIG_DECLARE_TYPEMAP_ARR_FN(schar,signed char) -SWIG_DECLARE_TYPEMAP_ARR_FN(uchar,unsigned char) -SWIG_DECLARE_TYPEMAP_ARR_FN(int,int) -SWIG_DECLARE_TYPEMAP_ARR_FN(uint,unsigned int) -SWIG_DECLARE_TYPEMAP_ARR_FN(short,short) -SWIG_DECLARE_TYPEMAP_ARR_FN(ushort,unsigned short) -SWIG_DECLARE_TYPEMAP_ARR_FN(long,long) -SWIG_DECLARE_TYPEMAP_ARR_FN(ulong,unsigned long) -SWIG_DECLARE_TYPEMAP_ARR_FN(float,float) -SWIG_DECLARE_TYPEMAP_ARR_FN(double,double) - -SWIGINTERN int SWIG_read_ptr_array(lua_State* L,int index,void **array,int size,swig_type_info *type){ - int i; - for (i = 0; i < size; i++) { - lua_rawgeti(L,index,i+1); - if (!lua_isuserdata(L,-1) || SWIG_ConvertPtr(L,-1,&array[i],type,0)==-1){ - lua_pop(L,1); - return 0; - } - lua_pop(L,1); - } - return 1; -} -SWIGINTERN void** SWIG_get_ptr_array_fixed(lua_State* L, int index, int size,swig_type_info *type){ - void **array; - if (!lua_istable(L,index) || SWIG_itable_size(L,index) != size) { - SWIG_Lua_pushferrstring(L,"expected a table of size %d",size); - return 0; - } - array=SWIG_ALLOC_ARRAY(void*,size); - if (!SWIG_read_ptr_array(L,index,array,size,type)){ - SWIG_Lua_pushferrstring(L,"table must contain pointers of type %s",type->name); - SWIG_FREE_ARRAY(array); - return 0; - } - return array; -} -SWIGINTERN void** SWIG_get_ptr_array_var(lua_State* L, int index, int* size,swig_type_info *type){ - void **array; - if (!lua_istable(L,index)) { - SWIG_Lua_pusherrstring(L,"expected a table"); - return 0; - } - *size=SWIG_itable_size(L,index); - if (*size<1){ - SWIG_Lua_pusherrstring(L,"table appears to be empty"); - return 0; - } - array=SWIG_ALLOC_ARRAY(void*,*size); - if (!SWIG_read_ptr_array(L,index,array,*size,type)){ - SWIG_Lua_pushferrstring(L,"table must contain pointers of type %s",type->name); - SWIG_FREE_ARRAY(array); - return 0; - } - return array; -} -SWIGINTERN void SWIG_write_ptr_array(lua_State* L,void **array,int size,swig_type_info *type,int own){ - int i; - lua_newtable(L); - for (i = 0; i < size; i++){ - SWIG_NewPointerObj(L,array[i],type,own); - lua_rawseti(L,-2,i+1);/* -1 is the number, -2 is the table*/ - } -} - - -#include -#include - - -#define SWIG_exception(a,b)\ -{ lua_pushfstring(L,"%s:%s",#a,b);SWIG_fail; } - - -#include -#include - - -#include - - -SWIGINTERN int SWIG_lua_isnilstring(lua_State *L, int idx) { - int ret = lua_isstring(L, idx); - if (!ret) - ret = lua_isnil(L, idx); - return ret; -} - - -#include - - -#include -#include -#include - - -#include - - -#include - -SWIGINTERN int std_vector_Sl_int_Sg____getitem__(std::vector< int > *self,unsigned int idx){ - if (idx>=self->size()) - throw std::out_of_range("in vector::__getitem__()"); - return (*self)[idx]; - } -SWIGINTERN void std_vector_Sl_int_Sg____setitem__(std::vector< int > *self,unsigned int idx,int val){ - if (idx>=self->size()) - throw std::out_of_range("in vector::__setitem__()"); - (*self)[idx]=val; - } -SWIGINTERN float std_vector_Sl_float_Sg____getitem__(std::vector< float > *self,unsigned int idx){ - if (idx>=self->size()) - throw std::out_of_range("in vector::__getitem__()"); - return (*self)[idx]; - } -SWIGINTERN void std_vector_Sl_float_Sg____setitem__(std::vector< float > *self,unsigned int idx,float val){ - if (idx>=self->size()) - throw std::out_of_range("in vector::__setitem__()"); - (*self)[idx]=val; - } -SWIGINTERN std::string std_vector_Sl_std_string_Sg____getitem__(std::vector< std::string > *self,unsigned int idx){ - if (idx>=self->size()) - throw std::out_of_range("in vector::__getitem__()"); - return (*self)[idx]; - } -SWIGINTERN void std_vector_Sl_std_string_Sg____setitem__(std::vector< std::string > *self,unsigned int idx,std::string val){ - if (idx>=self->size()) - throw std::out_of_range("in vector::__setitem__()"); - (*self)[idx]=val; - } -SWIGINTERN unsigned char std_vector_Sl_unsigned_SS_char_Sg____getitem__(std::vector< unsigned char > *self,unsigned int idx){ - if (idx>=self->size()) - throw std::out_of_range("in vector::__getitem__()"); - return (*self)[idx]; - } -SWIGINTERN void std_vector_Sl_unsigned_SS_char_Sg____setitem__(std::vector< unsigned char > *self,unsigned int idx,unsigned char val){ - if (idx>=self->size()) - throw std::out_of_range("in vector::__setitem__()"); - (*self)[idx]=val; - } -SWIGINTERN ofVideoDevice std_vector_Sl_ofVideoDevice_Sg____getitem__(std::vector< ofVideoDevice > *self,unsigned int idx){ - if (idx>=self->size()) - throw std::out_of_range("in vector::__getitem__()"); - return (*self)[idx]; - } -SWIGINTERN void std_vector_Sl_ofVideoDevice_Sg____setitem__(std::vector< ofVideoDevice > *self,unsigned int idx,ofVideoDevice val){ - if (idx>=self->size()) - throw std::out_of_range("in vector::__setitem__()"); - (*self)[idx]=val; - } -SWIGINTERN ofTexture std_vector_Sl_ofTexture_Sg____getitem__(std::vector< ofTexture > *self,unsigned int idx){ - if (idx>=self->size()) - throw std::out_of_range("in vector::__getitem__()"); - return (*self)[idx]; - } -SWIGINTERN void std_vector_Sl_ofTexture_Sg____setitem__(std::vector< ofTexture > *self,unsigned int idx,ofTexture val){ - if (idx>=self->size()) - throw std::out_of_range("in vector::__setitem__()"); - (*self)[idx]=val; - } -SWIGINTERN void delete_ofMesh(ofMesh *self){ - self->clear(); - delete self; - } -SWIGINTERN char const *ofMatrix3x3___str__(ofMatrix3x3 *self){ - stringstream str; - str << (*self); - return str.str().c_str(); - } -SWIGINTERN char const *ofMatrix4x4___str__(ofMatrix4x4 *self){ - stringstream str; - str << (*self); - return str.str().c_str(); - } -SWIGINTERN char const *ofQuaternion___str__(ofQuaternion *self){ - stringstream str; - str << (*self); - return str.str().c_str(); - } -SWIGINTERN char const *ofVec2f___str__(ofVec2f *self){ - stringstream str; - str << (*self); - return str.str().c_str(); - } -SWIGINTERN char const *ofVec3f___str__(ofVec3f *self){ - stringstream str; - str << (*self); - return str.str().c_str(); - } -SWIGINTERN char const *ofVec4f___str__(ofVec4f *self){ - stringstream str; - str << (*self); - return str.str().c_str(); - } -SWIGINTERN void delete_ofShader(ofShader *self){ - self->end(); - delete self; - } - -#define ofColor__Sl_unsigned_SS_char_Sg__r_get(self_) self_->r -#define ofColor__Sl_unsigned_SS_char_Sg__r_set(self_, val_) self_->r = val_ - - -#define ofColor__Sl_unsigned_SS_char_Sg__g_get(self_) self_->g -#define ofColor__Sl_unsigned_SS_char_Sg__g_set(self_, val_) self_->g = val_ - - -#define ofColor__Sl_unsigned_SS_char_Sg__b_get(self_) self_->b -#define ofColor__Sl_unsigned_SS_char_Sg__b_set(self_, val_) self_->b = val_ - - -#define ofColor__Sl_unsigned_SS_char_Sg__a_get(self_) self_->a -#define ofColor__Sl_unsigned_SS_char_Sg__a_set(self_, val_) self_->a = val_ - - -#define ofColor__Sl_float_Sg__r_get(self_) self_->r -#define ofColor__Sl_float_Sg__r_set(self_, val_) self_->r = val_ - - -#define ofColor__Sl_float_Sg__g_get(self_) self_->g -#define ofColor__Sl_float_Sg__g_set(self_, val_) self_->g = val_ - - -#define ofColor__Sl_float_Sg__b_get(self_) self_->b -#define ofColor__Sl_float_Sg__b_set(self_, val_) self_->b = val_ - - -#define ofColor__Sl_float_Sg__a_get(self_) self_->a -#define ofColor__Sl_float_Sg__a_set(self_, val_) self_->a = val_ - - -#define ofColor__Sl_unsigned_SS_short_Sg__r_get(self_) self_->r -#define ofColor__Sl_unsigned_SS_short_Sg__r_set(self_, val_) self_->r = val_ - - -#define ofColor__Sl_unsigned_SS_short_Sg__g_get(self_) self_->g -#define ofColor__Sl_unsigned_SS_short_Sg__g_set(self_, val_) self_->g = val_ - - -#define ofColor__Sl_unsigned_SS_short_Sg__b_get(self_) self_->b -#define ofColor__Sl_unsigned_SS_short_Sg__b_set(self_, val_) self_->b = val_ - - -#define ofColor__Sl_unsigned_SS_short_Sg__a_get(self_) self_->a -#define ofColor__Sl_unsigned_SS_short_Sg__a_set(self_, val_) self_->a = val_ - -SWIGINTERN unsigned char ofColor__Sl_unsigned_SS_char_Sg__getR(ofColor_< unsigned char > *self){return self->r;} -SWIGINTERN unsigned char ofColor__Sl_unsigned_SS_char_Sg__getG(ofColor_< unsigned char > *self){return self->g;} -SWIGINTERN unsigned char ofColor__Sl_unsigned_SS_char_Sg__getB(ofColor_< unsigned char > *self){return self->b;} -SWIGINTERN unsigned char ofColor__Sl_unsigned_SS_char_Sg__getA(ofColor_< unsigned char > *self){return self->a;} -SWIGINTERN void ofColor__Sl_unsigned_SS_char_Sg__setR(ofColor_< unsigned char > *self,unsigned char r){self->r = r;} -SWIGINTERN void ofColor__Sl_unsigned_SS_char_Sg__setG(ofColor_< unsigned char > *self,unsigned char g){self->g = g;} -SWIGINTERN void ofColor__Sl_unsigned_SS_char_Sg__setB(ofColor_< unsigned char > *self,unsigned char b){self->b = b;} -SWIGINTERN void ofColor__Sl_unsigned_SS_char_Sg__setA(ofColor_< unsigned char > *self,unsigned char a){self->a = a;} -SWIGINTERN char const *ofColor__Sl_unsigned_SS_char_Sg____str__(ofColor_< unsigned char > *self){ - stringstream str; - str << (*self); - return str.str().c_str(); - } -SWIGINTERN float ofColor__Sl_float_Sg__getR(ofColor_< float > *self){return self->r;} -SWIGINTERN float ofColor__Sl_float_Sg__getG(ofColor_< float > *self){return self->g;} -SWIGINTERN float ofColor__Sl_float_Sg__getB(ofColor_< float > *self){return self->b;} -SWIGINTERN float ofColor__Sl_float_Sg__getA(ofColor_< float > *self){return self->a;} -SWIGINTERN void ofColor__Sl_float_Sg__setR(ofColor_< float > *self,float r){self->r = r;} -SWIGINTERN void ofColor__Sl_float_Sg__setG(ofColor_< float > *self,float g){self->g = g;} -SWIGINTERN void ofColor__Sl_float_Sg__setB(ofColor_< float > *self,float b){self->b = b;} -SWIGINTERN void ofColor__Sl_float_Sg__setA(ofColor_< float > *self,float a){self->a = a;} -SWIGINTERN char const *ofColor__Sl_float_Sg____str__(ofColor_< float > *self){ - stringstream str; - str << (*self); - return str.str().c_str(); - } -SWIGINTERN unsigned short ofColor__Sl_unsigned_SS_short_Sg__getR(ofColor_< unsigned short > *self){return self->r;} -SWIGINTERN unsigned short ofColor__Sl_unsigned_SS_short_Sg__getG(ofColor_< unsigned short > *self){return self->g;} -SWIGINTERN unsigned short ofColor__Sl_unsigned_SS_short_Sg__getB(ofColor_< unsigned short > *self){return self->b;} -SWIGINTERN unsigned short ofColor__Sl_unsigned_SS_short_Sg__getA(ofColor_< unsigned short > *self){return self->a;} -SWIGINTERN void ofColor__Sl_unsigned_SS_short_Sg__setR(ofColor_< unsigned short > *self,unsigned short r){self->r = r;} -SWIGINTERN void ofColor__Sl_unsigned_SS_short_Sg__setG(ofColor_< unsigned short > *self,unsigned short g){self->g = g;} -SWIGINTERN void ofColor__Sl_unsigned_SS_short_Sg__setB(ofColor_< unsigned short > *self,unsigned short b){self->b = b;} -SWIGINTERN void ofColor__Sl_unsigned_SS_short_Sg__setA(ofColor_< unsigned short > *self,unsigned short a){self->a = a;} -SWIGINTERN char const *ofColor__Sl_unsigned_SS_short_Sg____str__(ofColor_< unsigned short > *self){ - stringstream str; - str << (*self); - return str.str().c_str(); - } -SWIGINTERN char const *ofRectangle___str__(ofRectangle *self){ - stringstream str; - str << (*self); - return str.str().c_str(); - } - -#define ofRectangle_x_get(self_) self_->getX() -#define ofRectangle_x_set(self_, val_) self_->setX(val_) - - -#define ofRectangle_y_get(self_) self_->getY() -#define ofRectangle_y_set(self_, val_) self_->setY(val_) - - - void log(ofLogLevel level, const string & message) { - ofLog(level, message); - } - -#ifdef __cplusplus -extern "C" { -#endif -static int _wrap_new_string__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *result = 0 ; - SWIG_check_num_args("std::string::string",0,0) result = (std::string *)new std::string(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__string,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_string__SWIG_1(lua_State* L) { int SWIG_arg = 0; char *arg1 = (char *) 0 ; std::string *result = 0 ; - SWIG_check_num_args("std::string::string",1,1) - if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("std::string::string",1,"char const *"); arg1 = (char *)lua_tostring(L, 1); - result = (std::string *)new std::string((char const *)arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__string,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_string(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_string__SWIG_0(L);} if (argc == 1) { int _v; { _v = SWIG_lua_isnilstring(L,argv[0]); } if (_v) { - return _wrap_new_string__SWIG_1(L);} } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_string'\n" - " Possible C/C++ prototypes are:\n" " std::string::string()\n" " std::string::string(char const *)\n"); - lua_error(L);return 0; } -static int _wrap_string_size(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = (std::string *) 0 ; unsigned int result; - SWIG_check_num_args("std::string::size",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::string::size",1,"std::string const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__string,0))){ - SWIG_fail_ptr("string_size",1,SWIGTYPE_p_std__string); } result = (unsigned int)((std::string const *)arg1)->size(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_string_length(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = (std::string *) 0 ; unsigned int result; - SWIG_check_num_args("std::string::length",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::string::length",1,"std::string const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__string,0))){ - SWIG_fail_ptr("string_length",1,SWIGTYPE_p_std__string); } result = (unsigned int)((std::string const *)arg1)->length(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_string_empty(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = (std::string *) 0 ; bool result; - SWIG_check_num_args("std::string::empty",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::string::empty",1,"std::string const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__string,0))){ - SWIG_fail_ptr("string_empty",1,SWIGTYPE_p_std__string); } result = (bool)((std::string const *)arg1)->empty(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_string_c_str(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = (std::string *) 0 ; char *result = 0 ; - SWIG_check_num_args("std::string::c_str",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::string::c_str",1,"std::string const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__string,0))){ - SWIG_fail_ptr("string_c_str",1,SWIGTYPE_p_std__string); } result = (char *)((std::string const *)arg1)->c_str(); - lua_pushstring(L,(const char *)result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_string_data(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = (std::string *) 0 ; char *result = 0 ; - SWIG_check_num_args("std::string::data",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::string::data",1,"std::string const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__string,0))){ - SWIG_fail_ptr("string_data",1,SWIGTYPE_p_std__string); } result = (char *)((std::string const *)arg1)->data(); - lua_pushstring(L,(const char *)result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_string_assign(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = (std::string *) 0 ; - char *arg2 = (char *) 0 ; SWIG_check_num_args("std::string::assign",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::string::assign",1,"std::string *"); - if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("std::string::assign",2,"char const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__string,0))){ - SWIG_fail_ptr("string_assign",1,SWIGTYPE_p_std__string); } arg2 = (char *)lua_tostring(L, 2); - (arg1)->assign((char const *)arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_string(void *obj) { -std::string *arg1 = (std::string *) obj; -delete arg1; -} -static int _proxy__wrap_new_string(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_string); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_string_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_string_methods[]= { - { "size", _wrap_string_size}, - { "length", _wrap_string_length}, - { "empty", _wrap_string_empty}, - { "c_str", _wrap_string_c_str}, - { "data", _wrap_string_data}, - { "assign", _wrap_string_assign}, - {0,0} -}; -static swig_lua_method swig_string_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_string_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_string_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_string_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_string_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_string_Sf_SwigStatic = { - "string", - swig_string_Sf_SwigStatic_methods, - swig_string_Sf_SwigStatic_attributes, - swig_string_Sf_SwigStatic_constants, - swig_string_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_string_bases[] = {0}; -static const char *swig_string_base_names[] = {0}; -static swig_lua_class _wrap_class_string = { "string", "string", &SWIGTYPE_p_std__string,_proxy__wrap_new_string, swig_delete_string, swig_string_methods, swig_string_attributes, &swig_string_Sf_SwigStatic, swig_string_meta, swig_string_bases, swig_string_base_names }; - -static int _wrap_new_path__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::filesystem::path *result = 0 ; - SWIG_check_num_args("std::filesystem::path::path",0,0) result = (std::filesystem::path *)new std::filesystem::path(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__filesystem__path,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_path__SWIG_1(lua_State* L) { int SWIG_arg = 0; char *arg1 = (char *) 0 ; - std::filesystem::path *result = 0 ; SWIG_check_num_args("std::filesystem::path::path",1,1) - if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("std::filesystem::path::path",1,"char const *"); - arg1 = (char *)lua_tostring(L, 1); result = (std::filesystem::path *)new std::filesystem::path((char const *)arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__filesystem__path,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_path(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_path__SWIG_0(L);} if (argc == 1) { int _v; { _v = SWIG_lua_isnilstring(L,argv[0]); } if (_v) { - return _wrap_new_path__SWIG_1(L);} } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_path'\n" - " Possible C/C++ prototypes are:\n" " std::filesystem::path::path()\n" " std::filesystem::path::path(char const *)\n"); - lua_error(L);return 0; } -static int _wrap_path_string(lua_State* L) { int SWIG_arg = 0; std::filesystem::path *arg1 = (std::filesystem::path *) 0 ; - std::string result; SWIG_check_num_args("std::filesystem::path::string",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::filesystem::path::string",1,"std::filesystem::path const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__filesystem__path,0))){ - SWIG_fail_ptr("path_string",1,SWIGTYPE_p_std__filesystem__path); } - result = ((std::filesystem::path const *)arg1)->string(); lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_path(void *obj) { -std::filesystem::path *arg1 = (std::filesystem::path *) obj; -delete arg1; -} -static int _proxy__wrap_new_path(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_path); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_path_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_path_methods[]= { - { "string", _wrap_path_string}, - {0,0} -}; -static swig_lua_method swig_path_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_path_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_path_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_path_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_path_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_path_Sf_SwigStatic = { - "path", - swig_path_Sf_SwigStatic_methods, - swig_path_Sf_SwigStatic_attributes, - swig_path_Sf_SwigStatic_constants, - swig_path_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_path_bases[] = {0}; -static const char *swig_path_base_names[] = {0}; -static swig_lua_class _wrap_class_path = { "path", "path", &SWIGTYPE_p_std__filesystem__path,_proxy__wrap_new_path, swig_delete_path, swig_path_methods, swig_path_attributes, &swig_path_Sf_SwigStatic, swig_path_meta, swig_path_bases, swig_path_base_names }; - -static int _wrap_new_IntVector__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::vector< int > *result = 0 ; - SWIG_check_num_args("std::vector< int >::vector",0,0) result = (std::vector< int > *)new std::vector< int >(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_int_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_IntVector__SWIG_1(lua_State* L) { int SWIG_arg = 0; unsigned int arg1 ; std::vector< int > *result = 0 ; - SWIG_check_num_args("std::vector< int >::vector",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("std::vector< int >::vector",1,"unsigned int"); - SWIG_contract_assert((lua_tonumber(L,1)>=0),"number must not be negative") arg1 = (unsigned int)lua_tonumber(L, 1); - result = (std::vector< int > *)new std::vector< int >(arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_int_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_IntVector__SWIG_2(lua_State* L) { int SWIG_arg = 0; std::vector< int > *arg1 = 0 ; - std::vector< int > *result = 0 ; SWIG_check_num_args("std::vector< int >::vector",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("std::vector< int >::vector",1,"std::vector< int > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_int_t,0))){ - SWIG_fail_ptr("new_IntVector",1,SWIGTYPE_p_std__vectorT_int_t); } - result = (std::vector< int > *)new std::vector< int >((std::vector< int > const &)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_int_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_IntVector__SWIG_3(lua_State* L) { int SWIG_arg = 0; unsigned int arg1 ; int arg2 ; - std::vector< int > *result = 0 ; SWIG_check_num_args("std::vector< int >::vector",2,2) - if(!lua_isnumber(L,1)) SWIG_fail_arg("std::vector< int >::vector",1,"unsigned int"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("std::vector< int >::vector",2,"int"); - SWIG_contract_assert((lua_tonumber(L,1)>=0),"number must not be negative") arg1 = (unsigned int)lua_tonumber(L, 1); - arg2 = (int)lua_tonumber(L, 2); result = (std::vector< int > *)new std::vector< int >(arg1,arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_int_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_IntVector(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_IntVector__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_std__vectorT_int_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_new_IntVector__SWIG_2(L);} } if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_new_IntVector__SWIG_1(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_new_IntVector__SWIG_3(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_IntVector'\n" " Possible C/C++ prototypes are:\n" - " std::vector< int >::vector()\n" " std::vector< int >::vector(unsigned int)\n" - " std::vector< int >::vector(std::vector< int > const &)\n" " std::vector< int >::vector(unsigned int,int)\n"); - lua_error(L);return 0; } -static int _wrap_IntVector_size(lua_State* L) { int SWIG_arg = 0; std::vector< int > *arg1 = (std::vector< int > *) 0 ; - unsigned int result; SWIG_check_num_args("std::vector< int >::size",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< int >::size",1,"std::vector< int > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_int_t,0))){ - SWIG_fail_ptr("IntVector_size",1,SWIGTYPE_p_std__vectorT_int_t); } - result = (unsigned int)((std::vector< int > const *)arg1)->size(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_IntVector_max_size(lua_State* L) { int SWIG_arg = 0; std::vector< int > *arg1 = (std::vector< int > *) 0 ; - unsigned int result; SWIG_check_num_args("std::vector< int >::max_size",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< int >::max_size",1,"std::vector< int > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_int_t,0))){ - SWIG_fail_ptr("IntVector_max_size",1,SWIGTYPE_p_std__vectorT_int_t); } - result = (unsigned int)((std::vector< int > const *)arg1)->max_size(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_IntVector_empty(lua_State* L) { int SWIG_arg = 0; std::vector< int > *arg1 = (std::vector< int > *) 0 ; - bool result; SWIG_check_num_args("std::vector< int >::empty",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< int >::empty",1,"std::vector< int > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_int_t,0))){ - SWIG_fail_ptr("IntVector_empty",1,SWIGTYPE_p_std__vectorT_int_t); } - result = (bool)((std::vector< int > const *)arg1)->empty(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_IntVector_clear(lua_State* L) { int SWIG_arg = 0; std::vector< int > *arg1 = (std::vector< int > *) 0 ; - SWIG_check_num_args("std::vector< int >::clear",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< int >::clear",1,"std::vector< int > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_int_t,0))){ - SWIG_fail_ptr("IntVector_clear",1,SWIGTYPE_p_std__vectorT_int_t); } (arg1)->clear(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_IntVector_push_back(lua_State* L) { int SWIG_arg = 0; std::vector< int > *arg1 = (std::vector< int > *) 0 ; - int arg2 ; SWIG_check_num_args("std::vector< int >::push_back",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< int >::push_back",1,"std::vector< int > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("std::vector< int >::push_back",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_int_t,0))){ - SWIG_fail_ptr("IntVector_push_back",1,SWIGTYPE_p_std__vectorT_int_t); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->push_back(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_IntVector_pop_back(lua_State* L) { int SWIG_arg = 0; std::vector< int > *arg1 = (std::vector< int > *) 0 ; - SWIG_check_num_args("std::vector< int >::pop_back",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< int >::pop_back",1,"std::vector< int > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_int_t,0))){ - SWIG_fail_ptr("IntVector_pop_back",1,SWIGTYPE_p_std__vectorT_int_t); } (arg1)->pop_back(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_IntVector_front(lua_State* L) { int SWIG_arg = 0; std::vector< int > *arg1 = (std::vector< int > *) 0 ; - int result; SWIG_check_num_args("std::vector< int >::front",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< int >::front",1,"std::vector< int > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_int_t,0))){ - SWIG_fail_ptr("IntVector_front",1,SWIGTYPE_p_std__vectorT_int_t); } - result = (int)((std::vector< int > const *)arg1)->front(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_IntVector_back(lua_State* L) { int SWIG_arg = 0; std::vector< int > *arg1 = (std::vector< int > *) 0 ; - int result; SWIG_check_num_args("std::vector< int >::back",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< int >::back",1,"std::vector< int > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_int_t,0))){ - SWIG_fail_ptr("IntVector_back",1,SWIGTYPE_p_std__vectorT_int_t); } - result = (int)((std::vector< int > const *)arg1)->back(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_IntVector___getitem(lua_State* L) { int SWIG_arg = 0; std::vector< int > *arg1 = (std::vector< int > *) 0 ; - unsigned int arg2 ; int result; SWIG_check_num_args("std::vector< int >::__getitem__",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< int >::__getitem__",1,"std::vector< int > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("std::vector< int >::__getitem__",2,"unsigned int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_int_t,0))){ - SWIG_fail_ptr("IntVector___getitem",1,SWIGTYPE_p_std__vectorT_int_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned int)lua_tonumber(L, 2); try { - result = (int)std_vector_Sl_int_Sg____getitem__(arg1,arg2);} catch(std::out_of_range &_e) { - SWIG_exception(SWIG_IndexError, (&_e)->what()); } lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_IntVector___setitem(lua_State* L) { int SWIG_arg = 0; std::vector< int > *arg1 = (std::vector< int > *) 0 ; - unsigned int arg2 ; int arg3 ; SWIG_check_num_args("std::vector< int >::__setitem__",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< int >::__setitem__",1,"std::vector< int > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("std::vector< int >::__setitem__",2,"unsigned int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("std::vector< int >::__setitem__",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_int_t,0))){ - SWIG_fail_ptr("IntVector___setitem",1,SWIGTYPE_p_std__vectorT_int_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); try { std_vector_Sl_int_Sg____setitem__(arg1,arg2,arg3);} catch(std::out_of_range &_e) { - SWIG_exception(SWIG_IndexError, (&_e)->what()); } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_IntVector(void *obj) { -std::vector< int > *arg1 = (std::vector< int > *) obj; -delete arg1; -} -static int _proxy__wrap_new_IntVector(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_IntVector); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_IntVector_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_IntVector_methods[]= { - { "size", _wrap_IntVector_size}, - { "max_size", _wrap_IntVector_max_size}, - { "empty", _wrap_IntVector_empty}, - { "clear", _wrap_IntVector_clear}, - { "push_back", _wrap_IntVector_push_back}, - { "pop_back", _wrap_IntVector_pop_back}, - { "front", _wrap_IntVector_front}, - { "back", _wrap_IntVector_back}, - { "__getitem", _wrap_IntVector___getitem}, - { "__setitem", _wrap_IntVector___setitem}, - {0,0} -}; -static swig_lua_method swig_IntVector_meta[] = { - { "__getitem", _wrap_IntVector___getitem}, - { "__setitem", _wrap_IntVector___setitem}, - {0,0} -}; - -static swig_lua_attribute swig_IntVector_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_IntVector_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_IntVector_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_IntVector_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_IntVector_Sf_SwigStatic = { - "IntVector", - swig_IntVector_Sf_SwigStatic_methods, - swig_IntVector_Sf_SwigStatic_attributes, - swig_IntVector_Sf_SwigStatic_constants, - swig_IntVector_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_IntVector_bases[] = {0}; -static const char *swig_IntVector_base_names[] = {0}; -static swig_lua_class _wrap_class_IntVector = { "IntVector", "IntVector", &SWIGTYPE_p_std__vectorT_int_t,_proxy__wrap_new_IntVector, swig_delete_IntVector, swig_IntVector_methods, swig_IntVector_attributes, &swig_IntVector_Sf_SwigStatic, swig_IntVector_meta, swig_IntVector_bases, swig_IntVector_base_names }; - -static int _wrap_new_FloatVector__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::vector< float > *result = 0 ; - SWIG_check_num_args("std::vector< float >::vector",0,0) result = (std::vector< float > *)new std::vector< float >(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_float_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_FloatVector__SWIG_1(lua_State* L) { int SWIG_arg = 0; unsigned int arg1 ; - std::vector< float > *result = 0 ; SWIG_check_num_args("std::vector< float >::vector",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("std::vector< float >::vector",1,"unsigned int"); - SWIG_contract_assert((lua_tonumber(L,1)>=0),"number must not be negative") arg1 = (unsigned int)lua_tonumber(L, 1); - result = (std::vector< float > *)new std::vector< float >(arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_float_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_FloatVector__SWIG_2(lua_State* L) { int SWIG_arg = 0; std::vector< float > *arg1 = 0 ; - std::vector< float > *result = 0 ; SWIG_check_num_args("std::vector< float >::vector",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("std::vector< float >::vector",1,"std::vector< float > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_float_t,0))){ - SWIG_fail_ptr("new_FloatVector",1,SWIGTYPE_p_std__vectorT_float_t); } - result = (std::vector< float > *)new std::vector< float >((std::vector< float > const &)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_float_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_FloatVector__SWIG_3(lua_State* L) { int SWIG_arg = 0; unsigned int arg1 ; float arg2 ; - std::vector< float > *result = 0 ; SWIG_check_num_args("std::vector< float >::vector",2,2) - if(!lua_isnumber(L,1)) SWIG_fail_arg("std::vector< float >::vector",1,"unsigned int"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("std::vector< float >::vector",2,"float"); - SWIG_contract_assert((lua_tonumber(L,1)>=0),"number must not be negative") arg1 = (unsigned int)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); result = (std::vector< float > *)new std::vector< float >(arg1,arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_float_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_FloatVector(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_FloatVector__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_std__vectorT_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_new_FloatVector__SWIG_2(L);} } if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_new_FloatVector__SWIG_1(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_new_FloatVector__SWIG_3(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_FloatVector'\n" " Possible C/C++ prototypes are:\n" - " std::vector< float >::vector()\n" " std::vector< float >::vector(unsigned int)\n" - " std::vector< float >::vector(std::vector< float > const &)\n" " std::vector< float >::vector(unsigned int,float)\n"); - lua_error(L);return 0; } -static int _wrap_FloatVector_size(lua_State* L) { int SWIG_arg = 0; std::vector< float > *arg1 = (std::vector< float > *) 0 ; - unsigned int result; SWIG_check_num_args("std::vector< float >::size",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< float >::size",1,"std::vector< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_float_t,0))){ - SWIG_fail_ptr("FloatVector_size",1,SWIGTYPE_p_std__vectorT_float_t); } - result = (unsigned int)((std::vector< float > const *)arg1)->size(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatVector_max_size(lua_State* L) { int SWIG_arg = 0; - std::vector< float > *arg1 = (std::vector< float > *) 0 ; unsigned int result; - SWIG_check_num_args("std::vector< float >::max_size",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< float >::max_size",1,"std::vector< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_float_t,0))){ - SWIG_fail_ptr("FloatVector_max_size",1,SWIGTYPE_p_std__vectorT_float_t); } - result = (unsigned int)((std::vector< float > const *)arg1)->max_size(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatVector_empty(lua_State* L) { int SWIG_arg = 0; std::vector< float > *arg1 = (std::vector< float > *) 0 ; - bool result; SWIG_check_num_args("std::vector< float >::empty",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< float >::empty",1,"std::vector< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_float_t,0))){ - SWIG_fail_ptr("FloatVector_empty",1,SWIGTYPE_p_std__vectorT_float_t); } - result = (bool)((std::vector< float > const *)arg1)->empty(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatVector_clear(lua_State* L) { int SWIG_arg = 0; std::vector< float > *arg1 = (std::vector< float > *) 0 ; - SWIG_check_num_args("std::vector< float >::clear",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< float >::clear",1,"std::vector< float > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_float_t,0))){ - SWIG_fail_ptr("FloatVector_clear",1,SWIGTYPE_p_std__vectorT_float_t); } (arg1)->clear(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatVector_push_back(lua_State* L) { int SWIG_arg = 0; - std::vector< float > *arg1 = (std::vector< float > *) 0 ; float arg2 ; - SWIG_check_num_args("std::vector< float >::push_back",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< float >::push_back",1,"std::vector< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("std::vector< float >::push_back",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_float_t,0))){ - SWIG_fail_ptr("FloatVector_push_back",1,SWIGTYPE_p_std__vectorT_float_t); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->push_back(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatVector_pop_back(lua_State* L) { int SWIG_arg = 0; - std::vector< float > *arg1 = (std::vector< float > *) 0 ; SWIG_check_num_args("std::vector< float >::pop_back",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< float >::pop_back",1,"std::vector< float > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_float_t,0))){ - SWIG_fail_ptr("FloatVector_pop_back",1,SWIGTYPE_p_std__vectorT_float_t); } (arg1)->pop_back(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatVector_front(lua_State* L) { int SWIG_arg = 0; std::vector< float > *arg1 = (std::vector< float > *) 0 ; - float result; SWIG_check_num_args("std::vector< float >::front",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< float >::front",1,"std::vector< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_float_t,0))){ - SWIG_fail_ptr("FloatVector_front",1,SWIGTYPE_p_std__vectorT_float_t); } - result = (float)((std::vector< float > const *)arg1)->front(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatVector_back(lua_State* L) { int SWIG_arg = 0; std::vector< float > *arg1 = (std::vector< float > *) 0 ; - float result; SWIG_check_num_args("std::vector< float >::back",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< float >::back",1,"std::vector< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_float_t,0))){ - SWIG_fail_ptr("FloatVector_back",1,SWIGTYPE_p_std__vectorT_float_t); } - result = (float)((std::vector< float > const *)arg1)->back(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatVector___getitem(lua_State* L) { int SWIG_arg = 0; - std::vector< float > *arg1 = (std::vector< float > *) 0 ; unsigned int arg2 ; float result; - SWIG_check_num_args("std::vector< float >::__getitem__",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< float >::__getitem__",1,"std::vector< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("std::vector< float >::__getitem__",2,"unsigned int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_float_t,0))){ - SWIG_fail_ptr("FloatVector___getitem",1,SWIGTYPE_p_std__vectorT_float_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned int)lua_tonumber(L, 2); try { - result = (float)std_vector_Sl_float_Sg____getitem__(arg1,arg2);} catch(std::out_of_range &_e) { - SWIG_exception(SWIG_IndexError, (&_e)->what()); } lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatVector___setitem(lua_State* L) { int SWIG_arg = 0; - std::vector< float > *arg1 = (std::vector< float > *) 0 ; unsigned int arg2 ; float arg3 ; - SWIG_check_num_args("std::vector< float >::__setitem__",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< float >::__setitem__",1,"std::vector< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("std::vector< float >::__setitem__",2,"unsigned int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("std::vector< float >::__setitem__",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_float_t,0))){ - SWIG_fail_ptr("FloatVector___setitem",1,SWIGTYPE_p_std__vectorT_float_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned int)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); try { std_vector_Sl_float_Sg____setitem__(arg1,arg2,arg3);} catch(std::out_of_range &_e) { - SWIG_exception(SWIG_IndexError, (&_e)->what()); } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_FloatVector(void *obj) { -std::vector< float > *arg1 = (std::vector< float > *) obj; -delete arg1; -} -static int _proxy__wrap_new_FloatVector(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_FloatVector); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_FloatVector_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_FloatVector_methods[]= { - { "size", _wrap_FloatVector_size}, - { "max_size", _wrap_FloatVector_max_size}, - { "empty", _wrap_FloatVector_empty}, - { "clear", _wrap_FloatVector_clear}, - { "push_back", _wrap_FloatVector_push_back}, - { "pop_back", _wrap_FloatVector_pop_back}, - { "front", _wrap_FloatVector_front}, - { "back", _wrap_FloatVector_back}, - { "__getitem", _wrap_FloatVector___getitem}, - { "__setitem", _wrap_FloatVector___setitem}, - {0,0} -}; -static swig_lua_method swig_FloatVector_meta[] = { - { "__getitem", _wrap_FloatVector___getitem}, - { "__setitem", _wrap_FloatVector___setitem}, - {0,0} -}; - -static swig_lua_attribute swig_FloatVector_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_FloatVector_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_FloatVector_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_FloatVector_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_FloatVector_Sf_SwigStatic = { - "FloatVector", - swig_FloatVector_Sf_SwigStatic_methods, - swig_FloatVector_Sf_SwigStatic_attributes, - swig_FloatVector_Sf_SwigStatic_constants, - swig_FloatVector_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_FloatVector_bases[] = {0}; -static const char *swig_FloatVector_base_names[] = {0}; -static swig_lua_class _wrap_class_FloatVector = { "FloatVector", "FloatVector", &SWIGTYPE_p_std__vectorT_float_t,_proxy__wrap_new_FloatVector, swig_delete_FloatVector, swig_FloatVector_methods, swig_FloatVector_attributes, &swig_FloatVector_Sf_SwigStatic, swig_FloatVector_meta, swig_FloatVector_bases, swig_FloatVector_base_names }; - -static int _wrap_new_StringVector__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::vector< std::string > *result = 0 ; - SWIG_check_num_args("std::vector< std::string >::vector",0,0) - result = (std::vector< std::string > *)new std::vector< std::string >(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_std__string_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_StringVector__SWIG_1(lua_State* L) { int SWIG_arg = 0; unsigned int arg1 ; - std::vector< std::string > *result = 0 ; SWIG_check_num_args("std::vector< std::string >::vector",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("std::vector< std::string >::vector",1,"unsigned int"); - SWIG_contract_assert((lua_tonumber(L,1)>=0),"number must not be negative") arg1 = (unsigned int)lua_tonumber(L, 1); - result = (std::vector< std::string > *)new std::vector< std::string >(arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_std__string_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_StringVector__SWIG_2(lua_State* L) { int SWIG_arg = 0; std::vector< std::string > *arg1 = 0 ; - std::vector< std::string > *result = 0 ; SWIG_check_num_args("std::vector< std::string >::vector",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("std::vector< std::string >::vector",1,"std::vector< std::string > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_std__string_t,0))){ - SWIG_fail_ptr("new_StringVector",1,SWIGTYPE_p_std__vectorT_std__string_t); } - result = (std::vector< std::string > *)new std::vector< std::string >((std::vector< std::string > const &)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_std__string_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_StringVector__SWIG_3(lua_State* L) { int SWIG_arg = 0; unsigned int arg1 ; std::string arg2 ; - std::vector< std::string > *result = 0 ; SWIG_check_num_args("std::vector< std::string >::vector",2,2) - if(!lua_isnumber(L,1)) SWIG_fail_arg("std::vector< std::string >::vector",1,"unsigned int"); - if(!lua_isstring(L,2)) SWIG_fail_arg("std::vector< std::string >::vector",2,"std::string"); - SWIG_contract_assert((lua_tonumber(L,1)>=0),"number must not be negative") arg1 = (unsigned int)lua_tonumber(L, 1); - (&arg2)->assign(lua_tostring(L,2),lua_rawlen(L,2)); - result = (std::vector< std::string > *)new std::vector< std::string >(arg1,arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_std__string_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_StringVector(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_StringVector__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_std__vectorT_std__string_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_new_StringVector__SWIG_2(L);} } if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_new_StringVector__SWIG_1(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { - return _wrap_new_StringVector__SWIG_3(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_StringVector'\n" " Possible C/C++ prototypes are:\n" - " std::vector< std::string >::vector()\n" " std::vector< std::string >::vector(unsigned int)\n" - " std::vector< std::string >::vector(std::vector< std::string > const &)\n" - " std::vector< std::string >::vector(unsigned int,std::string)\n"); lua_error(L);return 0; } -static int _wrap_StringVector_size(lua_State* L) { int SWIG_arg = 0; - std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ; unsigned int result; - SWIG_check_num_args("std::vector< std::string >::size",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< std::string >::size",1,"std::vector< std::string > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_std__string_t,0))){ - SWIG_fail_ptr("StringVector_size",1,SWIGTYPE_p_std__vectorT_std__string_t); } - result = (unsigned int)((std::vector< std::string > const *)arg1)->size(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_StringVector_max_size(lua_State* L) { int SWIG_arg = 0; - std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ; unsigned int result; - SWIG_check_num_args("std::vector< std::string >::max_size",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< std::string >::max_size",1,"std::vector< std::string > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_std__string_t,0))){ - SWIG_fail_ptr("StringVector_max_size",1,SWIGTYPE_p_std__vectorT_std__string_t); } - result = (unsigned int)((std::vector< std::string > const *)arg1)->max_size(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_StringVector_empty(lua_State* L) { int SWIG_arg = 0; - std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ; bool result; - SWIG_check_num_args("std::vector< std::string >::empty",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< std::string >::empty",1,"std::vector< std::string > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_std__string_t,0))){ - SWIG_fail_ptr("StringVector_empty",1,SWIGTYPE_p_std__vectorT_std__string_t); } - result = (bool)((std::vector< std::string > const *)arg1)->empty(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_StringVector_clear(lua_State* L) { int SWIG_arg = 0; - std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ; - SWIG_check_num_args("std::vector< std::string >::clear",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< std::string >::clear",1,"std::vector< std::string > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_std__string_t,0))){ - SWIG_fail_ptr("StringVector_clear",1,SWIGTYPE_p_std__vectorT_std__string_t); } (arg1)->clear(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_StringVector_push_back(lua_State* L) { int SWIG_arg = 0; - std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ; std::string arg2 ; - SWIG_check_num_args("std::vector< std::string >::push_back",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< std::string >::push_back",1,"std::vector< std::string > *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("std::vector< std::string >::push_back",2,"std::string"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_std__string_t,0))){ - SWIG_fail_ptr("StringVector_push_back",1,SWIGTYPE_p_std__vectorT_std__string_t); } - (&arg2)->assign(lua_tostring(L,2),lua_rawlen(L,2)); (arg1)->push_back(arg2); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_StringVector_pop_back(lua_State* L) { int SWIG_arg = 0; - std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ; - SWIG_check_num_args("std::vector< std::string >::pop_back",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< std::string >::pop_back",1,"std::vector< std::string > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_std__string_t,0))){ - SWIG_fail_ptr("StringVector_pop_back",1,SWIGTYPE_p_std__vectorT_std__string_t); } (arg1)->pop_back(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_StringVector_front(lua_State* L) { int SWIG_arg = 0; - std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ; std::string result; - SWIG_check_num_args("std::vector< std::string >::front",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< std::string >::front",1,"std::vector< std::string > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_std__string_t,0))){ - SWIG_fail_ptr("StringVector_front",1,SWIGTYPE_p_std__vectorT_std__string_t); } - result = ((std::vector< std::string > const *)arg1)->front(); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_StringVector_back(lua_State* L) { int SWIG_arg = 0; - std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ; std::string result; - SWIG_check_num_args("std::vector< std::string >::back",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< std::string >::back",1,"std::vector< std::string > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_std__string_t,0))){ - SWIG_fail_ptr("StringVector_back",1,SWIGTYPE_p_std__vectorT_std__string_t); } - result = ((std::vector< std::string > const *)arg1)->back(); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_StringVector___getitem(lua_State* L) { int SWIG_arg = 0; - std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ; unsigned int arg2 ; std::string result; - SWIG_check_num_args("std::vector< std::string >::__getitem__",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< std::string >::__getitem__",1,"std::vector< std::string > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("std::vector< std::string >::__getitem__",2,"unsigned int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_std__string_t,0))){ - SWIG_fail_ptr("StringVector___getitem",1,SWIGTYPE_p_std__vectorT_std__string_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned int)lua_tonumber(L, 2); try { - result = std_vector_Sl_std_string_Sg____getitem__(arg1,arg2);} catch(std::out_of_range &_e) { - SWIG_exception(SWIG_IndexError, (&_e)->what()); } lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_StringVector___setitem(lua_State* L) { int SWIG_arg = 0; - std::vector< std::string > *arg1 = (std::vector< std::string > *) 0 ; unsigned int arg2 ; std::string arg3 ; - SWIG_check_num_args("std::vector< std::string >::__setitem__",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< std::string >::__setitem__",1,"std::vector< std::string > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("std::vector< std::string >::__setitem__",2,"unsigned int"); - if(!lua_isstring(L,3)) SWIG_fail_arg("std::vector< std::string >::__setitem__",3,"std::string"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_std__string_t,0))){ - SWIG_fail_ptr("StringVector___setitem",1,SWIGTYPE_p_std__vectorT_std__string_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned int)lua_tonumber(L, 2); - (&arg3)->assign(lua_tostring(L,3),lua_rawlen(L,3)); try { std_vector_Sl_std_string_Sg____setitem__(arg1,arg2,arg3);} - catch(std::out_of_range &_e) { SWIG_exception(SWIG_IndexError, (&_e)->what()); } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static void swig_delete_StringVector(void *obj) { -std::vector< std::string > *arg1 = (std::vector< std::string > *) obj; -delete arg1; -} -static int _proxy__wrap_new_StringVector(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_StringVector); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_StringVector_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_StringVector_methods[]= { - { "size", _wrap_StringVector_size}, - { "max_size", _wrap_StringVector_max_size}, - { "empty", _wrap_StringVector_empty}, - { "clear", _wrap_StringVector_clear}, - { "push_back", _wrap_StringVector_push_back}, - { "pop_back", _wrap_StringVector_pop_back}, - { "front", _wrap_StringVector_front}, - { "back", _wrap_StringVector_back}, - { "__getitem", _wrap_StringVector___getitem}, - { "__setitem", _wrap_StringVector___setitem}, - {0,0} -}; -static swig_lua_method swig_StringVector_meta[] = { - { "__getitem", _wrap_StringVector___getitem}, - { "__setitem", _wrap_StringVector___setitem}, - {0,0} -}; - -static swig_lua_attribute swig_StringVector_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_StringVector_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_StringVector_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_StringVector_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_StringVector_Sf_SwigStatic = { - "StringVector", - swig_StringVector_Sf_SwigStatic_methods, - swig_StringVector_Sf_SwigStatic_attributes, - swig_StringVector_Sf_SwigStatic_constants, - swig_StringVector_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_StringVector_bases[] = {0}; -static const char *swig_StringVector_base_names[] = {0}; -static swig_lua_class _wrap_class_StringVector = { "StringVector", "StringVector", &SWIGTYPE_p_std__vectorT_std__string_t,_proxy__wrap_new_StringVector, swig_delete_StringVector, swig_StringVector_methods, swig_StringVector_attributes, &swig_StringVector_Sf_SwigStatic, swig_StringVector_meta, swig_StringVector_bases, swig_StringVector_base_names }; - -static int _wrap_new_UCharVector__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::vector< unsigned char > *result = 0 ; - SWIG_check_num_args("std::vector< unsigned char >::vector",0,0) - result = (std::vector< unsigned char > *)new std::vector< unsigned char >(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_unsigned_char_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_UCharVector__SWIG_1(lua_State* L) { int SWIG_arg = 0; unsigned int arg1 ; - std::vector< unsigned char > *result = 0 ; SWIG_check_num_args("std::vector< unsigned char >::vector",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("std::vector< unsigned char >::vector",1,"unsigned int"); - SWIG_contract_assert((lua_tonumber(L,1)>=0),"number must not be negative") arg1 = (unsigned int)lua_tonumber(L, 1); - result = (std::vector< unsigned char > *)new std::vector< unsigned char >(arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_unsigned_char_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_UCharVector__SWIG_2(lua_State* L) { int SWIG_arg = 0; std::vector< unsigned char > *arg1 = 0 ; - std::vector< unsigned char > *result = 0 ; SWIG_check_num_args("std::vector< unsigned char >::vector",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("std::vector< unsigned char >::vector",1,"std::vector< unsigned char > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_unsigned_char_t,0))){ - SWIG_fail_ptr("new_UCharVector",1,SWIGTYPE_p_std__vectorT_unsigned_char_t); } - result = (std::vector< unsigned char > *)new std::vector< unsigned char >((std::vector< unsigned char > const &)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_unsigned_char_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_UCharVector__SWIG_3(lua_State* L) { int SWIG_arg = 0; unsigned int arg1 ; unsigned char arg2 ; - std::vector< unsigned char > *result = 0 ; SWIG_check_num_args("std::vector< unsigned char >::vector",2,2) - if(!lua_isnumber(L,1)) SWIG_fail_arg("std::vector< unsigned char >::vector",1,"unsigned int"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("std::vector< unsigned char >::vector",2,"unsigned char"); - SWIG_contract_assert((lua_tonumber(L,1)>=0),"number must not be negative") arg1 = (unsigned int)lua_tonumber(L, 1); - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned char)lua_tonumber(L, 2); - result = (std::vector< unsigned char > *)new std::vector< unsigned char >(arg1,arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_unsigned_char_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_UCharVector(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_UCharVector__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_std__vectorT_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_new_UCharVector__SWIG_2(L);} } if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_new_UCharVector__SWIG_1(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_new_UCharVector__SWIG_3(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_UCharVector'\n" " Possible C/C++ prototypes are:\n" - " std::vector< unsigned char >::vector()\n" " std::vector< unsigned char >::vector(unsigned int)\n" - " std::vector< unsigned char >::vector(std::vector< unsigned char > const &)\n" - " std::vector< unsigned char >::vector(unsigned int,unsigned char)\n"); lua_error(L);return 0; } -static int _wrap_UCharVector_size(lua_State* L) { int SWIG_arg = 0; - std::vector< unsigned char > *arg1 = (std::vector< unsigned char > *) 0 ; unsigned int result; - SWIG_check_num_args("std::vector< unsigned char >::size",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< unsigned char >::size",1,"std::vector< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_unsigned_char_t,0))){ - SWIG_fail_ptr("UCharVector_size",1,SWIGTYPE_p_std__vectorT_unsigned_char_t); } - result = (unsigned int)((std::vector< unsigned char > const *)arg1)->size(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_UCharVector_max_size(lua_State* L) { int SWIG_arg = 0; - std::vector< unsigned char > *arg1 = (std::vector< unsigned char > *) 0 ; unsigned int result; - SWIG_check_num_args("std::vector< unsigned char >::max_size",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< unsigned char >::max_size",1,"std::vector< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_unsigned_char_t,0))){ - SWIG_fail_ptr("UCharVector_max_size",1,SWIGTYPE_p_std__vectorT_unsigned_char_t); } - result = (unsigned int)((std::vector< unsigned char > const *)arg1)->max_size(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_UCharVector_empty(lua_State* L) { int SWIG_arg = 0; - std::vector< unsigned char > *arg1 = (std::vector< unsigned char > *) 0 ; bool result; - SWIG_check_num_args("std::vector< unsigned char >::empty",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< unsigned char >::empty",1,"std::vector< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_unsigned_char_t,0))){ - SWIG_fail_ptr("UCharVector_empty",1,SWIGTYPE_p_std__vectorT_unsigned_char_t); } - result = (bool)((std::vector< unsigned char > const *)arg1)->empty(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_UCharVector_clear(lua_State* L) { int SWIG_arg = 0; - std::vector< unsigned char > *arg1 = (std::vector< unsigned char > *) 0 ; - SWIG_check_num_args("std::vector< unsigned char >::clear",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< unsigned char >::clear",1,"std::vector< unsigned char > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_unsigned_char_t,0))){ - SWIG_fail_ptr("UCharVector_clear",1,SWIGTYPE_p_std__vectorT_unsigned_char_t); } (arg1)->clear(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_UCharVector_push_back(lua_State* L) { int SWIG_arg = 0; - std::vector< unsigned char > *arg1 = (std::vector< unsigned char > *) 0 ; unsigned char arg2 ; - SWIG_check_num_args("std::vector< unsigned char >::push_back",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< unsigned char >::push_back",1,"std::vector< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("std::vector< unsigned char >::push_back",2,"unsigned char"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_unsigned_char_t,0))){ - SWIG_fail_ptr("UCharVector_push_back",1,SWIGTYPE_p_std__vectorT_unsigned_char_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned char)lua_tonumber(L, 2); - (arg1)->push_back(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_UCharVector_pop_back(lua_State* L) { int SWIG_arg = 0; - std::vector< unsigned char > *arg1 = (std::vector< unsigned char > *) 0 ; - SWIG_check_num_args("std::vector< unsigned char >::pop_back",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< unsigned char >::pop_back",1,"std::vector< unsigned char > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_unsigned_char_t,0))){ - SWIG_fail_ptr("UCharVector_pop_back",1,SWIGTYPE_p_std__vectorT_unsigned_char_t); } (arg1)->pop_back(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_UCharVector_front(lua_State* L) { int SWIG_arg = 0; - std::vector< unsigned char > *arg1 = (std::vector< unsigned char > *) 0 ; unsigned char result; - SWIG_check_num_args("std::vector< unsigned char >::front",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< unsigned char >::front",1,"std::vector< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_unsigned_char_t,0))){ - SWIG_fail_ptr("UCharVector_front",1,SWIGTYPE_p_std__vectorT_unsigned_char_t); } - result = (unsigned char)((std::vector< unsigned char > const *)arg1)->front(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_UCharVector_back(lua_State* L) { int SWIG_arg = 0; - std::vector< unsigned char > *arg1 = (std::vector< unsigned char > *) 0 ; unsigned char result; - SWIG_check_num_args("std::vector< unsigned char >::back",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< unsigned char >::back",1,"std::vector< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_unsigned_char_t,0))){ - SWIG_fail_ptr("UCharVector_back",1,SWIGTYPE_p_std__vectorT_unsigned_char_t); } - result = (unsigned char)((std::vector< unsigned char > const *)arg1)->back(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_UCharVector___getitem(lua_State* L) { int SWIG_arg = 0; - std::vector< unsigned char > *arg1 = (std::vector< unsigned char > *) 0 ; unsigned int arg2 ; unsigned char result; - SWIG_check_num_args("std::vector< unsigned char >::__getitem__",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< unsigned char >::__getitem__",1,"std::vector< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("std::vector< unsigned char >::__getitem__",2,"unsigned int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_unsigned_char_t,0))){ - SWIG_fail_ptr("UCharVector___getitem",1,SWIGTYPE_p_std__vectorT_unsigned_char_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned int)lua_tonumber(L, 2); try { - result = (unsigned char)std_vector_Sl_unsigned_SS_char_Sg____getitem__(arg1,arg2);} catch(std::out_of_range &_e) { - SWIG_exception(SWIG_IndexError, (&_e)->what()); } lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_UCharVector___setitem(lua_State* L) { int SWIG_arg = 0; - std::vector< unsigned char > *arg1 = (std::vector< unsigned char > *) 0 ; unsigned int arg2 ; unsigned char arg3 ; - SWIG_check_num_args("std::vector< unsigned char >::__setitem__",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< unsigned char >::__setitem__",1,"std::vector< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("std::vector< unsigned char >::__setitem__",2,"unsigned int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("std::vector< unsigned char >::__setitem__",3,"unsigned char"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_unsigned_char_t,0))){ - SWIG_fail_ptr("UCharVector___setitem",1,SWIGTYPE_p_std__vectorT_unsigned_char_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned int)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (unsigned char)lua_tonumber(L, 3); try { - std_vector_Sl_unsigned_SS_char_Sg____setitem__(arg1,arg2,arg3);} catch(std::out_of_range &_e) { - SWIG_exception(SWIG_IndexError, (&_e)->what()); } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_UCharVector(void *obj) { -std::vector< unsigned char > *arg1 = (std::vector< unsigned char > *) obj; -delete arg1; -} -static int _proxy__wrap_new_UCharVector(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_UCharVector); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_UCharVector_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_UCharVector_methods[]= { - { "size", _wrap_UCharVector_size}, - { "max_size", _wrap_UCharVector_max_size}, - { "empty", _wrap_UCharVector_empty}, - { "clear", _wrap_UCharVector_clear}, - { "push_back", _wrap_UCharVector_push_back}, - { "pop_back", _wrap_UCharVector_pop_back}, - { "front", _wrap_UCharVector_front}, - { "back", _wrap_UCharVector_back}, - { "__getitem", _wrap_UCharVector___getitem}, - { "__setitem", _wrap_UCharVector___setitem}, - {0,0} -}; -static swig_lua_method swig_UCharVector_meta[] = { - { "__getitem", _wrap_UCharVector___getitem}, - { "__setitem", _wrap_UCharVector___setitem}, - {0,0} -}; - -static swig_lua_attribute swig_UCharVector_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_UCharVector_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_UCharVector_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_UCharVector_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_UCharVector_Sf_SwigStatic = { - "UCharVector", - swig_UCharVector_Sf_SwigStatic_methods, - swig_UCharVector_Sf_SwigStatic_attributes, - swig_UCharVector_Sf_SwigStatic_constants, - swig_UCharVector_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_UCharVector_bases[] = {0}; -static const char *swig_UCharVector_base_names[] = {0}; -static swig_lua_class _wrap_class_UCharVector = { "UCharVector", "UCharVector", &SWIGTYPE_p_std__vectorT_unsigned_char_t,_proxy__wrap_new_UCharVector, swig_delete_UCharVector, swig_UCharVector_methods, swig_UCharVector_attributes, &swig_UCharVector_Sf_SwigStatic, swig_UCharVector_meta, swig_UCharVector_bases, swig_UCharVector_base_names }; - -static int _wrap_new_VideoDeviceVector__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::vector< ofVideoDevice > *result = 0 ; - SWIG_check_num_args("std::vector< ofVideoDevice >::vector",0,0) - result = (std::vector< ofVideoDevice > *)new std::vector< ofVideoDevice >(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofVideoDevice_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_VideoDeviceVector__SWIG_1(lua_State* L) { int SWIG_arg = 0; unsigned int arg1 ; - std::vector< ofVideoDevice > *result = 0 ; SWIG_check_num_args("std::vector< ofVideoDevice >::vector",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("std::vector< ofVideoDevice >::vector",1,"unsigned int"); - SWIG_contract_assert((lua_tonumber(L,1)>=0),"number must not be negative") arg1 = (unsigned int)lua_tonumber(L, 1); - result = (std::vector< ofVideoDevice > *)new std::vector< ofVideoDevice >(arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofVideoDevice_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_VideoDeviceVector__SWIG_2(lua_State* L) { int SWIG_arg = 0; std::vector< ofVideoDevice > *arg1 = 0 ; - std::vector< ofVideoDevice > *result = 0 ; SWIG_check_num_args("std::vector< ofVideoDevice >::vector",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("std::vector< ofVideoDevice >::vector",1,"std::vector< ofVideoDevice > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofVideoDevice_t,0))){ - SWIG_fail_ptr("new_VideoDeviceVector",1,SWIGTYPE_p_std__vectorT_ofVideoDevice_t); } - result = (std::vector< ofVideoDevice > *)new std::vector< ofVideoDevice >((std::vector< ofVideoDevice > const &)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofVideoDevice_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_VideoDeviceVector__SWIG_3(lua_State* L) { int SWIG_arg = 0; unsigned int arg1 ; ofVideoDevice arg2 ; - ofVideoDevice *argp2 ; std::vector< ofVideoDevice > *result = 0 ; - SWIG_check_num_args("std::vector< ofVideoDevice >::vector",2,2) - if(!lua_isnumber(L,1)) SWIG_fail_arg("std::vector< ofVideoDevice >::vector",1,"unsigned int"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("std::vector< ofVideoDevice >::vector",2,"ofVideoDevice"); - SWIG_contract_assert((lua_tonumber(L,1)>=0),"number must not be negative") arg1 = (unsigned int)lua_tonumber(L, 1); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofVideoDevice,0))){ - SWIG_fail_ptr("new_VideoDeviceVector",2,SWIGTYPE_p_ofVideoDevice); } arg2 = *argp2; - result = (std::vector< ofVideoDevice > *)new std::vector< ofVideoDevice >(arg1,arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofVideoDevice_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_VideoDeviceVector(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_VideoDeviceVector__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_std__vectorT_ofVideoDevice_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_new_VideoDeviceVector__SWIG_2(L);} } if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_new_VideoDeviceVector__SWIG_1(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVideoDevice, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_new_VideoDeviceVector__SWIG_3(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_VideoDeviceVector'\n" - " Possible C/C++ prototypes are:\n" " std::vector< ofVideoDevice >::vector()\n" - " std::vector< ofVideoDevice >::vector(unsigned int)\n" - " std::vector< ofVideoDevice >::vector(std::vector< ofVideoDevice > const &)\n" - " std::vector< ofVideoDevice >::vector(unsigned int,ofVideoDevice)\n"); lua_error(L);return 0; } -static int _wrap_VideoDeviceVector_size(lua_State* L) { int SWIG_arg = 0; - std::vector< ofVideoDevice > *arg1 = (std::vector< ofVideoDevice > *) 0 ; unsigned int result; - SWIG_check_num_args("std::vector< ofVideoDevice >::size",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< ofVideoDevice >::size",1,"std::vector< ofVideoDevice > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofVideoDevice_t,0))){ - SWIG_fail_ptr("VideoDeviceVector_size",1,SWIGTYPE_p_std__vectorT_ofVideoDevice_t); } - result = (unsigned int)((std::vector< ofVideoDevice > const *)arg1)->size(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoDeviceVector_max_size(lua_State* L) { int SWIG_arg = 0; - std::vector< ofVideoDevice > *arg1 = (std::vector< ofVideoDevice > *) 0 ; unsigned int result; - SWIG_check_num_args("std::vector< ofVideoDevice >::max_size",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< ofVideoDevice >::max_size",1,"std::vector< ofVideoDevice > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofVideoDevice_t,0))){ - SWIG_fail_ptr("VideoDeviceVector_max_size",1,SWIGTYPE_p_std__vectorT_ofVideoDevice_t); } - result = (unsigned int)((std::vector< ofVideoDevice > const *)arg1)->max_size(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoDeviceVector_empty(lua_State* L) { int SWIG_arg = 0; - std::vector< ofVideoDevice > *arg1 = (std::vector< ofVideoDevice > *) 0 ; bool result; - SWIG_check_num_args("std::vector< ofVideoDevice >::empty",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< ofVideoDevice >::empty",1,"std::vector< ofVideoDevice > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofVideoDevice_t,0))){ - SWIG_fail_ptr("VideoDeviceVector_empty",1,SWIGTYPE_p_std__vectorT_ofVideoDevice_t); } - result = (bool)((std::vector< ofVideoDevice > const *)arg1)->empty(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoDeviceVector_clear(lua_State* L) { int SWIG_arg = 0; - std::vector< ofVideoDevice > *arg1 = (std::vector< ofVideoDevice > *) 0 ; - SWIG_check_num_args("std::vector< ofVideoDevice >::clear",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< ofVideoDevice >::clear",1,"std::vector< ofVideoDevice > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofVideoDevice_t,0))){ - SWIG_fail_ptr("VideoDeviceVector_clear",1,SWIGTYPE_p_std__vectorT_ofVideoDevice_t); } (arg1)->clear(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoDeviceVector_push_back(lua_State* L) { int SWIG_arg = 0; - std::vector< ofVideoDevice > *arg1 = (std::vector< ofVideoDevice > *) 0 ; ofVideoDevice arg2 ; ofVideoDevice *argp2 ; - SWIG_check_num_args("std::vector< ofVideoDevice >::push_back",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< ofVideoDevice >::push_back",1,"std::vector< ofVideoDevice > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("std::vector< ofVideoDevice >::push_back",2,"ofVideoDevice"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofVideoDevice_t,0))){ - SWIG_fail_ptr("VideoDeviceVector_push_back",1,SWIGTYPE_p_std__vectorT_ofVideoDevice_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofVideoDevice,0))){ - SWIG_fail_ptr("VideoDeviceVector_push_back",2,SWIGTYPE_p_ofVideoDevice); } arg2 = *argp2; (arg1)->push_back(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoDeviceVector_pop_back(lua_State* L) { int SWIG_arg = 0; - std::vector< ofVideoDevice > *arg1 = (std::vector< ofVideoDevice > *) 0 ; - SWIG_check_num_args("std::vector< ofVideoDevice >::pop_back",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< ofVideoDevice >::pop_back",1,"std::vector< ofVideoDevice > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofVideoDevice_t,0))){ - SWIG_fail_ptr("VideoDeviceVector_pop_back",1,SWIGTYPE_p_std__vectorT_ofVideoDevice_t); } (arg1)->pop_back(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoDeviceVector_front(lua_State* L) { int SWIG_arg = 0; - std::vector< ofVideoDevice > *arg1 = (std::vector< ofVideoDevice > *) 0 ; ofVideoDevice result; - SWIG_check_num_args("std::vector< ofVideoDevice >::front",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< ofVideoDevice >::front",1,"std::vector< ofVideoDevice > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofVideoDevice_t,0))){ - SWIG_fail_ptr("VideoDeviceVector_front",1,SWIGTYPE_p_std__vectorT_ofVideoDevice_t); } - result = ((std::vector< ofVideoDevice > const *)arg1)->front(); { - ofVideoDevice * resultptr = new ofVideoDevice((const ofVideoDevice &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVideoDevice,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_VideoDeviceVector_back(lua_State* L) { int SWIG_arg = 0; - std::vector< ofVideoDevice > *arg1 = (std::vector< ofVideoDevice > *) 0 ; ofVideoDevice result; - SWIG_check_num_args("std::vector< ofVideoDevice >::back",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< ofVideoDevice >::back",1,"std::vector< ofVideoDevice > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofVideoDevice_t,0))){ - SWIG_fail_ptr("VideoDeviceVector_back",1,SWIGTYPE_p_std__vectorT_ofVideoDevice_t); } - result = ((std::vector< ofVideoDevice > const *)arg1)->back(); { - ofVideoDevice * resultptr = new ofVideoDevice((const ofVideoDevice &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVideoDevice,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_VideoDeviceVector___getitem(lua_State* L) { int SWIG_arg = 0; - std::vector< ofVideoDevice > *arg1 = (std::vector< ofVideoDevice > *) 0 ; unsigned int arg2 ; ofVideoDevice result; - SWIG_check_num_args("std::vector< ofVideoDevice >::__getitem__",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< ofVideoDevice >::__getitem__",1,"std::vector< ofVideoDevice > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("std::vector< ofVideoDevice >::__getitem__",2,"unsigned int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofVideoDevice_t,0))){ - SWIG_fail_ptr("VideoDeviceVector___getitem",1,SWIGTYPE_p_std__vectorT_ofVideoDevice_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned int)lua_tonumber(L, 2); try { - result = std_vector_Sl_ofVideoDevice_Sg____getitem__(arg1,arg2);} catch(std::out_of_range &_e) { - SWIG_exception(SWIG_IndexError, (&_e)->what()); } { - ofVideoDevice * resultptr = new ofVideoDevice((const ofVideoDevice &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVideoDevice,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_VideoDeviceVector___setitem(lua_State* L) { int SWIG_arg = 0; - std::vector< ofVideoDevice > *arg1 = (std::vector< ofVideoDevice > *) 0 ; unsigned int arg2 ; ofVideoDevice arg3 ; - ofVideoDevice *argp3 ; SWIG_check_num_args("std::vector< ofVideoDevice >::__setitem__",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< ofVideoDevice >::__setitem__",1,"std::vector< ofVideoDevice > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("std::vector< ofVideoDevice >::__setitem__",2,"unsigned int"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("std::vector< ofVideoDevice >::__setitem__",3,"ofVideoDevice"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofVideoDevice_t,0))){ - SWIG_fail_ptr("VideoDeviceVector___setitem",1,SWIGTYPE_p_std__vectorT_ofVideoDevice_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned int)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&argp3,SWIGTYPE_p_ofVideoDevice,0))){ - SWIG_fail_ptr("VideoDeviceVector___setitem",3,SWIGTYPE_p_ofVideoDevice); } arg3 = *argp3; try { - std_vector_Sl_ofVideoDevice_Sg____setitem__(arg1,arg2,arg3);} catch(std::out_of_range &_e) { - SWIG_exception(SWIG_IndexError, (&_e)->what()); } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_VideoDeviceVector(void *obj) { -std::vector< ofVideoDevice > *arg1 = (std::vector< ofVideoDevice > *) obj; -delete arg1; -} -static int _proxy__wrap_new_VideoDeviceVector(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_VideoDeviceVector); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_VideoDeviceVector_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_VideoDeviceVector_methods[]= { - { "size", _wrap_VideoDeviceVector_size}, - { "max_size", _wrap_VideoDeviceVector_max_size}, - { "empty", _wrap_VideoDeviceVector_empty}, - { "clear", _wrap_VideoDeviceVector_clear}, - { "push_back", _wrap_VideoDeviceVector_push_back}, - { "pop_back", _wrap_VideoDeviceVector_pop_back}, - { "front", _wrap_VideoDeviceVector_front}, - { "back", _wrap_VideoDeviceVector_back}, - { "__getitem", _wrap_VideoDeviceVector___getitem}, - { "__setitem", _wrap_VideoDeviceVector___setitem}, - {0,0} -}; -static swig_lua_method swig_VideoDeviceVector_meta[] = { - { "__getitem", _wrap_VideoDeviceVector___getitem}, - { "__setitem", _wrap_VideoDeviceVector___setitem}, - {0,0} -}; - -static swig_lua_attribute swig_VideoDeviceVector_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_VideoDeviceVector_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_VideoDeviceVector_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_VideoDeviceVector_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_VideoDeviceVector_Sf_SwigStatic = { - "VideoDeviceVector", - swig_VideoDeviceVector_Sf_SwigStatic_methods, - swig_VideoDeviceVector_Sf_SwigStatic_attributes, - swig_VideoDeviceVector_Sf_SwigStatic_constants, - swig_VideoDeviceVector_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_VideoDeviceVector_bases[] = {0}; -static const char *swig_VideoDeviceVector_base_names[] = {0}; -static swig_lua_class _wrap_class_VideoDeviceVector = { "VideoDeviceVector", "VideoDeviceVector", &SWIGTYPE_p_std__vectorT_ofVideoDevice_t,_proxy__wrap_new_VideoDeviceVector, swig_delete_VideoDeviceVector, swig_VideoDeviceVector_methods, swig_VideoDeviceVector_attributes, &swig_VideoDeviceVector_Sf_SwigStatic, swig_VideoDeviceVector_meta, swig_VideoDeviceVector_bases, swig_VideoDeviceVector_base_names }; - -static int _wrap_new_TextureVector__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::vector< ofTexture > *result = 0 ; - SWIG_check_num_args("std::vector< ofTexture >::vector",0,0) - result = (std::vector< ofTexture > *)new std::vector< ofTexture >(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofTexture_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_TextureVector__SWIG_1(lua_State* L) { int SWIG_arg = 0; unsigned int arg1 ; - std::vector< ofTexture > *result = 0 ; SWIG_check_num_args("std::vector< ofTexture >::vector",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("std::vector< ofTexture >::vector",1,"unsigned int"); - SWIG_contract_assert((lua_tonumber(L,1)>=0),"number must not be negative") arg1 = (unsigned int)lua_tonumber(L, 1); - result = (std::vector< ofTexture > *)new std::vector< ofTexture >(arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofTexture_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_TextureVector__SWIG_2(lua_State* L) { int SWIG_arg = 0; std::vector< ofTexture > *arg1 = 0 ; - std::vector< ofTexture > *result = 0 ; SWIG_check_num_args("std::vector< ofTexture >::vector",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("std::vector< ofTexture >::vector",1,"std::vector< ofTexture > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofTexture_t,0))){ - SWIG_fail_ptr("new_TextureVector",1,SWIGTYPE_p_std__vectorT_ofTexture_t); } - result = (std::vector< ofTexture > *)new std::vector< ofTexture >((std::vector< ofTexture > const &)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofTexture_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_TextureVector__SWIG_3(lua_State* L) { int SWIG_arg = 0; unsigned int arg1 ; ofTexture arg2 ; - ofTexture *argp2 ; std::vector< ofTexture > *result = 0 ; SWIG_check_num_args("std::vector< ofTexture >::vector",2,2) - if(!lua_isnumber(L,1)) SWIG_fail_arg("std::vector< ofTexture >::vector",1,"unsigned int"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("std::vector< ofTexture >::vector",2,"ofTexture"); - SWIG_contract_assert((lua_tonumber(L,1)>=0),"number must not be negative") arg1 = (unsigned int)lua_tonumber(L, 1); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("new_TextureVector",2,SWIGTYPE_p_ofTexture); } arg2 = *argp2; - result = (std::vector< ofTexture > *)new std::vector< ofTexture >(arg1,arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofTexture_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_TextureVector(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_TextureVector__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_std__vectorT_ofTexture_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_new_TextureVector__SWIG_2(L);} } if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_new_TextureVector__SWIG_1(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_new_TextureVector__SWIG_3(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_TextureVector'\n" " Possible C/C++ prototypes are:\n" - " std::vector< ofTexture >::vector()\n" " std::vector< ofTexture >::vector(unsigned int)\n" - " std::vector< ofTexture >::vector(std::vector< ofTexture > const &)\n" - " std::vector< ofTexture >::vector(unsigned int,ofTexture)\n"); lua_error(L);return 0; } -static int _wrap_TextureVector_size(lua_State* L) { int SWIG_arg = 0; - std::vector< ofTexture > *arg1 = (std::vector< ofTexture > *) 0 ; unsigned int result; - SWIG_check_num_args("std::vector< ofTexture >::size",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< ofTexture >::size",1,"std::vector< ofTexture > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofTexture_t,0))){ - SWIG_fail_ptr("TextureVector_size",1,SWIGTYPE_p_std__vectorT_ofTexture_t); } - result = (unsigned int)((std::vector< ofTexture > const *)arg1)->size(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureVector_max_size(lua_State* L) { int SWIG_arg = 0; - std::vector< ofTexture > *arg1 = (std::vector< ofTexture > *) 0 ; unsigned int result; - SWIG_check_num_args("std::vector< ofTexture >::max_size",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< ofTexture >::max_size",1,"std::vector< ofTexture > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofTexture_t,0))){ - SWIG_fail_ptr("TextureVector_max_size",1,SWIGTYPE_p_std__vectorT_ofTexture_t); } - result = (unsigned int)((std::vector< ofTexture > const *)arg1)->max_size(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureVector_empty(lua_State* L) { int SWIG_arg = 0; - std::vector< ofTexture > *arg1 = (std::vector< ofTexture > *) 0 ; bool result; - SWIG_check_num_args("std::vector< ofTexture >::empty",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< ofTexture >::empty",1,"std::vector< ofTexture > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofTexture_t,0))){ - SWIG_fail_ptr("TextureVector_empty",1,SWIGTYPE_p_std__vectorT_ofTexture_t); } - result = (bool)((std::vector< ofTexture > const *)arg1)->empty(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureVector_clear(lua_State* L) { int SWIG_arg = 0; - std::vector< ofTexture > *arg1 = (std::vector< ofTexture > *) 0 ; SWIG_check_num_args("std::vector< ofTexture >::clear",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< ofTexture >::clear",1,"std::vector< ofTexture > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofTexture_t,0))){ - SWIG_fail_ptr("TextureVector_clear",1,SWIGTYPE_p_std__vectorT_ofTexture_t); } (arg1)->clear(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureVector_push_back(lua_State* L) { int SWIG_arg = 0; - std::vector< ofTexture > *arg1 = (std::vector< ofTexture > *) 0 ; ofTexture arg2 ; ofTexture *argp2 ; - SWIG_check_num_args("std::vector< ofTexture >::push_back",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< ofTexture >::push_back",1,"std::vector< ofTexture > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("std::vector< ofTexture >::push_back",2,"ofTexture"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofTexture_t,0))){ - SWIG_fail_ptr("TextureVector_push_back",1,SWIGTYPE_p_std__vectorT_ofTexture_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("TextureVector_push_back",2,SWIGTYPE_p_ofTexture); } arg2 = *argp2; (arg1)->push_back(arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureVector_pop_back(lua_State* L) { int SWIG_arg = 0; - std::vector< ofTexture > *arg1 = (std::vector< ofTexture > *) 0 ; - SWIG_check_num_args("std::vector< ofTexture >::pop_back",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< ofTexture >::pop_back",1,"std::vector< ofTexture > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofTexture_t,0))){ - SWIG_fail_ptr("TextureVector_pop_back",1,SWIGTYPE_p_std__vectorT_ofTexture_t); } (arg1)->pop_back(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureVector_front(lua_State* L) { int SWIG_arg = 0; - std::vector< ofTexture > *arg1 = (std::vector< ofTexture > *) 0 ; ofTexture result; - SWIG_check_num_args("std::vector< ofTexture >::front",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< ofTexture >::front",1,"std::vector< ofTexture > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofTexture_t,0))){ - SWIG_fail_ptr("TextureVector_front",1,SWIGTYPE_p_std__vectorT_ofTexture_t); } - result = ((std::vector< ofTexture > const *)arg1)->front(); { - ofTexture * resultptr = new ofTexture((const ofTexture &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofTexture,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_TextureVector_back(lua_State* L) { int SWIG_arg = 0; - std::vector< ofTexture > *arg1 = (std::vector< ofTexture > *) 0 ; ofTexture result; - SWIG_check_num_args("std::vector< ofTexture >::back",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< ofTexture >::back",1,"std::vector< ofTexture > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofTexture_t,0))){ - SWIG_fail_ptr("TextureVector_back",1,SWIGTYPE_p_std__vectorT_ofTexture_t); } - result = ((std::vector< ofTexture > const *)arg1)->back(); { - ofTexture * resultptr = new ofTexture((const ofTexture &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofTexture,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_TextureVector___getitem(lua_State* L) { int SWIG_arg = 0; - std::vector< ofTexture > *arg1 = (std::vector< ofTexture > *) 0 ; unsigned int arg2 ; ofTexture result; - SWIG_check_num_args("std::vector< ofTexture >::__getitem__",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< ofTexture >::__getitem__",1,"std::vector< ofTexture > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("std::vector< ofTexture >::__getitem__",2,"unsigned int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofTexture_t,0))){ - SWIG_fail_ptr("TextureVector___getitem",1,SWIGTYPE_p_std__vectorT_ofTexture_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned int)lua_tonumber(L, 2); try { - result = std_vector_Sl_ofTexture_Sg____getitem__(arg1,arg2);} catch(std::out_of_range &_e) { - SWIG_exception(SWIG_IndexError, (&_e)->what()); } { ofTexture * resultptr = new ofTexture((const ofTexture &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofTexture,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_TextureVector___setitem(lua_State* L) { int SWIG_arg = 0; - std::vector< ofTexture > *arg1 = (std::vector< ofTexture > *) 0 ; unsigned int arg2 ; ofTexture arg3 ; ofTexture *argp3 ; - SWIG_check_num_args("std::vector< ofTexture >::__setitem__",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("std::vector< ofTexture >::__setitem__",1,"std::vector< ofTexture > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("std::vector< ofTexture >::__setitem__",2,"unsigned int"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("std::vector< ofTexture >::__setitem__",3,"ofTexture"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofTexture_t,0))){ - SWIG_fail_ptr("TextureVector___setitem",1,SWIGTYPE_p_std__vectorT_ofTexture_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned int)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&argp3,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("TextureVector___setitem",3,SWIGTYPE_p_ofTexture); } arg3 = *argp3; try { - std_vector_Sl_ofTexture_Sg____setitem__(arg1,arg2,arg3);} catch(std::out_of_range &_e) { - SWIG_exception(SWIG_IndexError, (&_e)->what()); } return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_TextureVector(void *obj) { -std::vector< ofTexture > *arg1 = (std::vector< ofTexture > *) obj; -delete arg1; -} -static int _proxy__wrap_new_TextureVector(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_TextureVector); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_TextureVector_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_TextureVector_methods[]= { - { "size", _wrap_TextureVector_size}, - { "max_size", _wrap_TextureVector_max_size}, - { "empty", _wrap_TextureVector_empty}, - { "clear", _wrap_TextureVector_clear}, - { "push_back", _wrap_TextureVector_push_back}, - { "pop_back", _wrap_TextureVector_pop_back}, - { "front", _wrap_TextureVector_front}, - { "back", _wrap_TextureVector_back}, - { "__getitem", _wrap_TextureVector___getitem}, - { "__setitem", _wrap_TextureVector___setitem}, - {0,0} -}; -static swig_lua_method swig_TextureVector_meta[] = { - { "__getitem", _wrap_TextureVector___getitem}, - { "__setitem", _wrap_TextureVector___setitem}, - {0,0} -}; - -static swig_lua_attribute swig_TextureVector_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_TextureVector_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_TextureVector_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_TextureVector_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_TextureVector_Sf_SwigStatic = { - "TextureVector", - swig_TextureVector_Sf_SwigStatic_methods, - swig_TextureVector_Sf_SwigStatic_attributes, - swig_TextureVector_Sf_SwigStatic_constants, - swig_TextureVector_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_TextureVector_bases[] = {0}; -static const char *swig_TextureVector_base_names[] = {0}; -static swig_lua_class _wrap_class_TextureVector = { "TextureVector", "TextureVector", &SWIGTYPE_p_std__vectorT_ofTexture_t,_proxy__wrap_new_TextureVector, swig_delete_TextureVector, swig_TextureVector_methods, swig_TextureVector_attributes, &swig_TextureVector_Sf_SwigStatic, swig_TextureVector_meta, swig_TextureVector_bases, swig_TextureVector_base_names }; - -static int _wrap_new_Fbo__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofFbo *result = 0 ; SWIG_check_num_args("ofFbo::ofFbo",0,0) - result = (ofFbo *)new ofFbo(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofFbo,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_new_Fbo__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = 0 ; ofFbo *result = 0 ; - SWIG_check_num_args("ofFbo::ofFbo",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofFbo::ofFbo",1,"ofFbo &&"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("new_Fbo",1,SWIGTYPE_p_ofFbo); } - result = (ofFbo *)new ofFbo((ofFbo &&)*arg1); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofFbo,1); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_new_Fbo(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_Fbo__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_new_Fbo__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_Fbo'\n" " Possible C/C++ prototypes are:\n" - " ofFbo::ofFbo()\n" " ofFbo::ofFbo(ofFbo &&)\n"); lua_error(L);return 0; } -static int _wrap_Fbo_allocate__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; int arg2 ; int arg3 ; - int arg4 ; int arg5 ; SWIG_check_num_args("ofFbo::allocate",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::allocate",1,"ofFbo *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofFbo::allocate",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofFbo::allocate",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofFbo::allocate",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofFbo::allocate",5,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_allocate",1,SWIGTYPE_p_ofFbo); } - arg2 = (int)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - arg5 = (int)lua_tonumber(L, 5); (arg1)->allocate(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Fbo_allocate__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; int arg2 ; int arg3 ; - int arg4 ; SWIG_check_num_args("ofFbo::allocate",4,4) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::allocate",1,"ofFbo *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofFbo::allocate",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofFbo::allocate",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofFbo::allocate",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_allocate",1,SWIGTYPE_p_ofFbo); } - arg2 = (int)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - (arg1)->allocate(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_allocate__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; int arg2 ; int arg3 ; - SWIG_check_num_args("ofFbo::allocate",3,3) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::allocate",1,"ofFbo *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofFbo::allocate",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofFbo::allocate",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_allocate",1,SWIGTYPE_p_ofFbo); } - arg2 = (int)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); (arg1)->allocate(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_allocate__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; ofFbo::Settings arg2 ; - ofFbo::Settings *argp2 ; SWIG_check_num_args("ofFbo::allocate",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::allocate",1,"ofFbo *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofFbo::allocate",2,"ofFbo::Settings"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_allocate",1,SWIGTYPE_p_ofFbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofFbo__Settings,0))){ - SWIG_fail_ptr("Fbo_allocate",2,SWIGTYPE_p_ofFbo__Settings); } arg2 = *argp2; (arg1)->allocate(arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_allocate__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; - SWIG_check_num_args("ofFbo::allocate",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::allocate",1,"ofFbo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_allocate",1,SWIGTYPE_p_ofFbo); } - (arg1)->allocate(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_allocate(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Fbo_allocate__SWIG_4(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofFbo__Settings, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Fbo_allocate__SWIG_3(L);} } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Fbo_allocate__SWIG_2(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Fbo_allocate__SWIG_1(L);} } } } } if (argc == 5) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Fbo_allocate__SWIG_0(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Fbo_allocate'\n" " Possible C/C++ prototypes are:\n" - " ofFbo::allocate(int,int,int,int)\n" " ofFbo::allocate(int,int,int)\n" " ofFbo::allocate(int,int)\n" - " ofFbo::allocate(ofFbo::Settings)\n" " ofFbo::allocate()\n"); lua_error(L);return 0; } -static int _wrap_Fbo_isAllocated(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; bool result; - SWIG_check_num_args("ofFbo::isAllocated",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::isAllocated",1,"ofFbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_isAllocated",1,SWIGTYPE_p_ofFbo); } - result = (bool)((ofFbo const *)arg1)->isAllocated(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_clear(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; SWIG_check_num_args("ofFbo::clear",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::clear",1,"ofFbo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_clear",1,SWIGTYPE_p_ofFbo); } - (arg1)->clear(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_draw__SWIG_0_0(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; ofPoint *arg2 = 0 ; - SWIG_check_num_args("draw",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("draw",1,"ofFbo const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("draw",2,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_draw",1,SWIGTYPE_p_ofFbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Fbo_draw",2,SWIGTYPE_p_ofVec3f); } - ((ofFbo const *)arg1)->draw((ofPoint const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_draw__SWIG_0_1(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; ofRectangle *arg2 = 0 ; - SWIG_check_num_args("draw",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("draw",1,"ofFbo const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("draw",2,"ofRectangle const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_draw",1,SWIGTYPE_p_ofFbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Fbo_draw",2,SWIGTYPE_p_ofRectangle); } ((ofFbo const *)arg1)->draw((ofRectangle const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_draw__SWIG_0_2(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; ofPoint *arg2 = 0 ; - float arg3 ; float arg4 ; SWIG_check_num_args("draw",4,4) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("draw",1,"ofFbo const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("draw",2,"ofPoint const &"); if(!lua_isnumber(L,3)) SWIG_fail_arg("draw",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("draw",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_draw",1,SWIGTYPE_p_ofFbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Fbo_draw",2,SWIGTYPE_p_ofVec3f); } - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - ((ofFbo const *)arg1)->draw((ofPoint const &)*arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Fbo_draw__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofFbo::draw",3,3) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::draw",1,"ofFbo const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofFbo::draw",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofFbo::draw",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_draw",1,SWIGTYPE_p_ofFbo); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); ((ofFbo const *)arg1)->draw(arg2,arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_draw__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; float arg2 ; float arg3 ; - float arg4 ; float arg5 ; SWIG_check_num_args("ofFbo::draw",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::draw",1,"ofFbo const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofFbo::draw",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofFbo::draw",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofFbo::draw",4,"float"); if(!lua_isnumber(L,5)) SWIG_fail_arg("ofFbo::draw",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_draw",1,SWIGTYPE_p_ofFbo); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); ((ofFbo const *)arg1)->draw(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_draw(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 2) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Fbo_draw__SWIG_0_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Fbo_draw__SWIG_0_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Fbo_draw__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Fbo_draw__SWIG_0_2(L);} } } } } if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Fbo_draw__SWIG_2(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Fbo_draw'\n" " Possible C/C++ prototypes are:\n" - " draw(ofPoint const &) const\n" " draw(ofRectangle const &) const\n" " draw(ofPoint const &,float,float) const\n" - " ofFbo::draw(float,float) const\n" " ofFbo::draw(float,float,float,float) const\n"); lua_error(L);return 0; } -static int _wrap_Fbo_setAnchorPercent(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofFbo::setAnchorPercent",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::setAnchorPercent",1,"ofFbo *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofFbo::setAnchorPercent",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofFbo::setAnchorPercent",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ - SWIG_fail_ptr("Fbo_setAnchorPercent",1,SWIGTYPE_p_ofFbo); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->setAnchorPercent(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Fbo_setAnchorPoint(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofFbo::setAnchorPoint",3,3) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::setAnchorPoint",1,"ofFbo *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofFbo::setAnchorPoint",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofFbo::setAnchorPoint",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ - SWIG_fail_ptr("Fbo_setAnchorPoint",1,SWIGTYPE_p_ofFbo); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->setAnchorPoint(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Fbo_resetAnchor(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; - SWIG_check_num_args("ofFbo::resetAnchor",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::resetAnchor",1,"ofFbo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_resetAnchor",1,SWIGTYPE_p_ofFbo); } - (arg1)->resetAnchor(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_setDefaultTextureIndex(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; int arg2 ; - SWIG_check_num_args("ofFbo::setDefaultTextureIndex",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::setDefaultTextureIndex",1,"ofFbo *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofFbo::setDefaultTextureIndex",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ - SWIG_fail_ptr("Fbo_setDefaultTextureIndex",1,SWIGTYPE_p_ofFbo); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->setDefaultTextureIndex(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_getDefaultTextureIndex(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; int result; - SWIG_check_num_args("ofFbo::getDefaultTextureIndex",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::getDefaultTextureIndex",1,"ofFbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ - SWIG_fail_ptr("Fbo_getDefaultTextureIndex",1,SWIGTYPE_p_ofFbo); } - result = (int)((ofFbo const *)arg1)->getDefaultTextureIndex(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_getTexture__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; ofTexture *result = 0 ; - SWIG_check_num_args("ofFbo::getTexture",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::getTexture",1,"ofFbo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_getTexture",1,SWIGTYPE_p_ofFbo); } - result = (ofTexture *) &(arg1)->getTexture(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTexture,0); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_getTexture__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; int arg2 ; - ofTexture *result = 0 ; SWIG_check_num_args("ofFbo::getTexture",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::getTexture",1,"ofFbo *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofFbo::getTexture",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_getTexture",1,SWIGTYPE_p_ofFbo); } - arg2 = (int)lua_tonumber(L, 2); result = (ofTexture *) &(arg1)->getTexture(arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTexture,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Fbo_getDepthTexture__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; - ofTexture *result = 0 ; SWIG_check_num_args("ofFbo::getDepthTexture",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::getDepthTexture",1,"ofFbo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ - SWIG_fail_ptr("Fbo_getDepthTexture",1,SWIGTYPE_p_ofFbo); } result = (ofTexture *) &(arg1)->getDepthTexture(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTexture,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Fbo_getTexture__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; ofTexture *result = 0 ; - SWIG_check_num_args("ofFbo::getTexture",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::getTexture",1,"ofFbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_getTexture",1,SWIGTYPE_p_ofFbo); } - result = (ofTexture *) &((ofFbo const *)arg1)->getTexture(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTexture,0); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_getTexture__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; int arg2 ; - ofTexture *result = 0 ; SWIG_check_num_args("ofFbo::getTexture",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::getTexture",1,"ofFbo const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofFbo::getTexture",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_getTexture",1,SWIGTYPE_p_ofFbo); } - arg2 = (int)lua_tonumber(L, 2); result = (ofTexture *) &((ofFbo const *)arg1)->getTexture(arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTexture,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Fbo_getTexture(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Fbo_getTexture__SWIG_0(L);} } if (argc == 1) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_Fbo_getTexture__SWIG_2(L);} } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Fbo_getTexture__SWIG_1(L);} } } - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Fbo_getTexture__SWIG_3(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Fbo_getTexture'\n" " Possible C/C++ prototypes are:\n" - " ofFbo::getTexture()\n" " ofFbo::getTexture(int)\n" " ofFbo::getTexture() const\n" - " ofFbo::getTexture(int) const\n"); lua_error(L);return 0; } -static int _wrap_Fbo_getDepthTexture__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; - ofTexture *result = 0 ; SWIG_check_num_args("ofFbo::getDepthTexture",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::getDepthTexture",1,"ofFbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ - SWIG_fail_ptr("Fbo_getDepthTexture",1,SWIGTYPE_p_ofFbo); } - result = (ofTexture *) &((ofFbo const *)arg1)->getDepthTexture(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTexture,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Fbo_getDepthTexture(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Fbo_getDepthTexture__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Fbo_getDepthTexture__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Fbo_getDepthTexture'\n" - " Possible C/C++ prototypes are:\n" " ofFbo::getDepthTexture()\n" " ofFbo::getDepthTexture() const\n"); - lua_error(L);return 0; } -static int _wrap_Fbo_beginFbo__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; bool arg2 ; - SWIG_check_num_args("ofFbo::begin",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::begin",1,"ofFbo const *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofFbo::begin",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_beginFbo",1,SWIGTYPE_p_ofFbo); } - arg2 = (lua_toboolean(L, 2)!=0); ((ofFbo const *)arg1)->begin(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Fbo_beginFbo__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; - SWIG_check_num_args("ofFbo::begin",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::begin",1,"ofFbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_beginFbo",1,SWIGTYPE_p_ofFbo); } - ((ofFbo const *)arg1)->begin(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_beginFbo(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Fbo_beginFbo__SWIG_1(L);} } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { return _wrap_Fbo_beginFbo__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Fbo_beginFbo'\n" " Possible C/C++ prototypes are:\n" - " ofFbo::begin(bool) const\n" " ofFbo::begin() const\n"); lua_error(L);return 0; } -static int _wrap_Fbo_endFbo(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; SWIG_check_num_args("ofFbo::end",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::end",1,"ofFbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_endFbo",1,SWIGTYPE_p_ofFbo); } - ((ofFbo const *)arg1)->end(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_readToPixels__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; ofPixels *arg2 = 0 ; - int arg3 ; SWIG_check_num_args("ofFbo::readToPixels",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::readToPixels",1,"ofFbo const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofFbo::readToPixels",2,"ofPixels &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofFbo::readToPixels",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_readToPixels",1,SWIGTYPE_p_ofFbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Fbo_readToPixels",2,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } arg3 = (int)lua_tonumber(L, 3); - ((ofFbo const *)arg1)->readToPixels(*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_readToPixels__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; ofPixels *arg2 = 0 ; - SWIG_check_num_args("ofFbo::readToPixels",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::readToPixels",1,"ofFbo const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofFbo::readToPixels",2,"ofPixels &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_readToPixels",1,SWIGTYPE_p_ofFbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Fbo_readToPixels",2,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } ((ofFbo const *)arg1)->readToPixels(*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_readToPixels__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; - ofShortPixels *arg2 = 0 ; int arg3 ; SWIG_check_num_args("ofFbo::readToPixels",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::readToPixels",1,"ofFbo const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofFbo::readToPixels",2,"ofShortPixels &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofFbo::readToPixels",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_readToPixels",1,SWIGTYPE_p_ofFbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("Fbo_readToPixels",2,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } arg3 = (int)lua_tonumber(L, 3); - ((ofFbo const *)arg1)->readToPixels(*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_readToPixels__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; - ofShortPixels *arg2 = 0 ; SWIG_check_num_args("ofFbo::readToPixels",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::readToPixels",1,"ofFbo const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofFbo::readToPixels",2,"ofShortPixels &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_readToPixels",1,SWIGTYPE_p_ofFbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("Fbo_readToPixels",2,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } ((ofFbo const *)arg1)->readToPixels(*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_readToPixels__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; - ofFloatPixels *arg2 = 0 ; int arg3 ; SWIG_check_num_args("ofFbo::readToPixels",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::readToPixels",1,"ofFbo const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofFbo::readToPixels",2,"ofFloatPixels &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofFbo::readToPixels",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_readToPixels",1,SWIGTYPE_p_ofFbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("Fbo_readToPixels",2,SWIGTYPE_p_ofPixels_T_float_t); } arg3 = (int)lua_tonumber(L, 3); - ((ofFbo const *)arg1)->readToPixels(*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_readToPixels__SWIG_5(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; - ofFloatPixels *arg2 = 0 ; SWIG_check_num_args("ofFbo::readToPixels",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::readToPixels",1,"ofFbo const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofFbo::readToPixels",2,"ofFloatPixels &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_readToPixels",1,SWIGTYPE_p_ofFbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("Fbo_readToPixels",2,SWIGTYPE_p_ofPixels_T_float_t); } ((ofFbo const *)arg1)->readToPixels(*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_readToPixels(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Fbo_readToPixels__SWIG_1(L);} } } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Fbo_readToPixels__SWIG_3(L);} } } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Fbo_readToPixels__SWIG_5(L);} } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Fbo_readToPixels__SWIG_0(L);} } } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Fbo_readToPixels__SWIG_4(L);} } } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Fbo_readToPixels__SWIG_2(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Fbo_readToPixels'\n" " Possible C/C++ prototypes are:\n" - " ofFbo::readToPixels(ofPixels &,int) const\n" " ofFbo::readToPixels(ofPixels &) const\n" - " ofFbo::readToPixels(ofShortPixels &,int) const\n" " ofFbo::readToPixels(ofShortPixels &) const\n" - " ofFbo::readToPixels(ofFloatPixels &,int) const\n" " ofFbo::readToPixels(ofFloatPixels &) const\n"); - lua_error(L);return 0; } -static int _wrap_Fbo_getWidth(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; float result; - SWIG_check_num_args("ofFbo::getWidth",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::getWidth",1,"ofFbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_getWidth",1,SWIGTYPE_p_ofFbo); } - result = (float)((ofFbo const *)arg1)->getWidth(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_getHeight(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; float result; - SWIG_check_num_args("ofFbo::getHeight",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::getHeight",1,"ofFbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_getHeight",1,SWIGTYPE_p_ofFbo); } - result = (float)((ofFbo const *)arg1)->getHeight(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_bind(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; SWIG_check_num_args("ofFbo::bind",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::bind",1,"ofFbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_bind",1,SWIGTYPE_p_ofFbo); } - ((ofFbo const *)arg1)->bind(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_unbind(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; - SWIG_check_num_args("ofFbo::unbind",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::unbind",1,"ofFbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_unbind",1,SWIGTYPE_p_ofFbo); } - ((ofFbo const *)arg1)->unbind(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_flagDirty(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; - SWIG_check_num_args("ofFbo::flagDirty",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::flagDirty",1,"ofFbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_flagDirty",1,SWIGTYPE_p_ofFbo); } - ((ofFbo const *)arg1)->flagDirty(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_updateTexture(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; int arg2 ; - SWIG_check_num_args("ofFbo::updateTexture",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::updateTexture",1,"ofFbo *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofFbo::updateTexture",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ - SWIG_fail_ptr("Fbo_updateTexture",1,SWIGTYPE_p_ofFbo); } arg2 = (int)lua_tonumber(L, 2); (arg1)->updateTexture(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_checkStatus(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; bool result; - SWIG_check_num_args("ofFbo::checkStatus",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::checkStatus",1,"ofFbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_checkStatus",1,SWIGTYPE_p_ofFbo); } - result = (bool)((ofFbo const *)arg1)->checkStatus(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_createAndAttachTexture(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; GLenum arg2 ; - GLenum arg3 ; SWIG_check_num_args("ofFbo::createAndAttachTexture",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::createAndAttachTexture",1,"ofFbo *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofFbo::createAndAttachTexture",2,"GLenum"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofFbo::createAndAttachTexture",3,"GLenum"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ - SWIG_fail_ptr("Fbo_createAndAttachTexture",1,SWIGTYPE_p_ofFbo); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (GLenum)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (GLenum)lua_tonumber(L, 3); - (arg1)->createAndAttachTexture(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_attachTexture(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; ofTexture *arg2 = 0 ; - GLenum arg3 ; GLenum arg4 ; SWIG_check_num_args("ofFbo::attachTexture",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::attachTexture",1,"ofFbo *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofFbo::attachTexture",2,"ofTexture &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofFbo::attachTexture",3,"GLenum"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofFbo::attachTexture",4,"GLenum"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ - SWIG_fail_ptr("Fbo_attachTexture",1,SWIGTYPE_p_ofFbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Fbo_attachTexture",2,SWIGTYPE_p_ofTexture); } - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (GLenum)lua_tonumber(L, 3); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (GLenum)lua_tonumber(L, 4); - (arg1)->attachTexture(*arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_createAndAttachRenderbuffer(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; GLenum arg2 ; - GLenum arg3 ; GLuint result; SWIG_check_num_args("ofFbo::createAndAttachRenderbuffer",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::createAndAttachRenderbuffer",1,"ofFbo *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofFbo::createAndAttachRenderbuffer",2,"GLenum"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofFbo::createAndAttachRenderbuffer",3,"GLenum"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ - SWIG_fail_ptr("Fbo_createAndAttachRenderbuffer",1,SWIGTYPE_p_ofFbo); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (GLenum)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (GLenum)lua_tonumber(L, 3); - result = (GLuint)(arg1)->createAndAttachRenderbuffer(arg2,arg3); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_createAndAttachDepthStencilTexture__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; - GLenum arg2 ; GLint arg3 ; GLenum arg4 ; SWIG_check_num_args("ofFbo::createAndAttachDepthStencilTexture",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::createAndAttachDepthStencilTexture",1,"ofFbo *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofFbo::createAndAttachDepthStencilTexture",2,"GLenum"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofFbo::createAndAttachDepthStencilTexture",3,"GLint"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofFbo::createAndAttachDepthStencilTexture",4,"GLenum"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ - SWIG_fail_ptr("Fbo_createAndAttachDepthStencilTexture",1,SWIGTYPE_p_ofFbo); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (GLenum)lua_tonumber(L, 2); - arg3 = (GLint)lua_tonumber(L, 3); SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") - arg4 = (GLenum)lua_tonumber(L, 4); (arg1)->createAndAttachDepthStencilTexture(arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_createAndAttachDepthStencilTexture__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; - GLenum arg2 ; GLint arg3 ; GLenum arg4 ; GLenum arg5 ; GLenum arg6 ; - SWIG_check_num_args("ofFbo::createAndAttachDepthStencilTexture",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::createAndAttachDepthStencilTexture",1,"ofFbo *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofFbo::createAndAttachDepthStencilTexture",2,"GLenum"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofFbo::createAndAttachDepthStencilTexture",3,"GLint"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofFbo::createAndAttachDepthStencilTexture",4,"GLenum"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofFbo::createAndAttachDepthStencilTexture",5,"GLenum"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofFbo::createAndAttachDepthStencilTexture",6,"GLenum"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ - SWIG_fail_ptr("Fbo_createAndAttachDepthStencilTexture",1,SWIGTYPE_p_ofFbo); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (GLenum)lua_tonumber(L, 2); - arg3 = (GLint)lua_tonumber(L, 3); SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") - arg4 = (GLenum)lua_tonumber(L, 4); SWIG_contract_assert((lua_tonumber(L,5)>=0),"number must not be negative") - arg5 = (GLenum)lua_tonumber(L, 5); SWIG_contract_assert((lua_tonumber(L,6)>=0),"number must not be negative") - arg6 = (GLenum)lua_tonumber(L, 6); (arg1)->createAndAttachDepthStencilTexture(arg2,arg3,arg4,arg5,arg6); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_createAndAttachDepthStencilTexture(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; - argc = lua_gettop(L); if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Fbo_createAndAttachDepthStencilTexture__SWIG_0(L);} } } } - } if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { return _wrap_Fbo_createAndAttachDepthStencilTexture__SWIG_1(L);} } } - } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Fbo_createAndAttachDepthStencilTexture'\n" - " Possible C/C++ prototypes are:\n" " ofFbo::createAndAttachDepthStencilTexture(GLenum,GLint,GLenum)\n" - " ofFbo::createAndAttachDepthStencilTexture(GLenum,GLint,GLenum,GLenum,GLenum)\n"); lua_error(L);return 0; } -static int _wrap_Fbo_getNumTextures(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; int result; - SWIG_check_num_args("ofFbo::getNumTextures",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::getNumTextures",1,"ofFbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ - SWIG_fail_ptr("Fbo_getNumTextures",1,SWIGTYPE_p_ofFbo); } result = (int)((ofFbo const *)arg1)->getNumTextures(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_setActiveDrawBuffer(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; int arg2 ; - SWIG_check_num_args("ofFbo::setActiveDrawBuffer",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::setActiveDrawBuffer",1,"ofFbo *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofFbo::setActiveDrawBuffer",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ - SWIG_fail_ptr("Fbo_setActiveDrawBuffer",1,SWIGTYPE_p_ofFbo); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->setActiveDrawBuffer(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_activateAllDrawBuffers(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; - SWIG_check_num_args("ofFbo::activateAllDrawBuffers",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::activateAllDrawBuffers",1,"ofFbo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ - SWIG_fail_ptr("Fbo_activateAllDrawBuffers",1,SWIGTYPE_p_ofFbo); } (arg1)->activateAllDrawBuffers(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_getId(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; GLuint result; - SWIG_check_num_args("ofFbo::getId",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::getId",1,"ofFbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ SWIG_fail_ptr("Fbo_getId",1,SWIGTYPE_p_ofFbo); } - result = (GLuint)((ofFbo const *)arg1)->getId(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_getIdDrawBuffer(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; GLuint result; - SWIG_check_num_args("ofFbo::getIdDrawBuffer",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::getIdDrawBuffer",1,"ofFbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ - SWIG_fail_ptr("Fbo_getIdDrawBuffer",1,SWIGTYPE_p_ofFbo); } result = (GLuint)((ofFbo const *)arg1)->getIdDrawBuffer(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_checkGLSupport(lua_State* L) { int SWIG_arg = 0; bool result; - SWIG_check_num_args("ofFbo::checkGLSupport",0,0) result = (bool)ofFbo::checkGLSupport(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_maxColorAttachments(lua_State* L) { int SWIG_arg = 0; int result; - SWIG_check_num_args("ofFbo::maxColorAttachments",0,0) result = (int)ofFbo::maxColorAttachments(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_maxDrawBuffers(lua_State* L) { int SWIG_arg = 0; int result; - SWIG_check_num_args("ofFbo::maxDrawBuffers",0,0) result = (int)ofFbo::maxDrawBuffers(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_maxSamples(lua_State* L) { int SWIG_arg = 0; int result; SWIG_check_num_args("ofFbo::maxSamples",0,0) - result = (int)ofFbo::maxSamples(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_getDepthBuffer(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; GLuint result; - SWIG_check_num_args("ofFbo::getDepthBuffer",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::getDepthBuffer",1,"ofFbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ - SWIG_fail_ptr("Fbo_getDepthBuffer",1,SWIGTYPE_p_ofFbo); } result = (GLuint)((ofFbo const *)arg1)->getDepthBuffer(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Fbo_getStencilBuffer(lua_State* L) { int SWIG_arg = 0; ofFbo *arg1 = (ofFbo *) 0 ; GLuint result; - SWIG_check_num_args("ofFbo::getStencilBuffer",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFbo::getStencilBuffer",1,"ofFbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFbo,0))){ - SWIG_fail_ptr("Fbo_getStencilBuffer",1,SWIGTYPE_p_ofFbo); } result = (GLuint)((ofFbo const *)arg1)->getStencilBuffer(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_Fbo(void *obj) { -ofFbo *arg1 = (ofFbo *) obj; -delete arg1; -} -static int _proxy__wrap_new_Fbo(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_Fbo); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_Fbo_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_Fbo_methods[]= { - { "allocate", _wrap_Fbo_allocate}, - { "isAllocated", _wrap_Fbo_isAllocated}, - { "clear", _wrap_Fbo_clear}, - { "draw", _wrap_Fbo_draw}, - { "setAnchorPercent", _wrap_Fbo_setAnchorPercent}, - { "setAnchorPoint", _wrap_Fbo_setAnchorPoint}, - { "resetAnchor", _wrap_Fbo_resetAnchor}, - { "setDefaultTextureIndex", _wrap_Fbo_setDefaultTextureIndex}, - { "getDefaultTextureIndex", _wrap_Fbo_getDefaultTextureIndex}, - { "getTexture", _wrap_Fbo_getTexture}, - { "getDepthTexture", _wrap_Fbo_getDepthTexture}, - { "beginFbo", _wrap_Fbo_beginFbo}, - { "endFbo", _wrap_Fbo_endFbo}, - { "readToPixels", _wrap_Fbo_readToPixels}, - { "getWidth", _wrap_Fbo_getWidth}, - { "getHeight", _wrap_Fbo_getHeight}, - { "bind", _wrap_Fbo_bind}, - { "unbind", _wrap_Fbo_unbind}, - { "flagDirty", _wrap_Fbo_flagDirty}, - { "updateTexture", _wrap_Fbo_updateTexture}, - { "checkStatus", _wrap_Fbo_checkStatus}, - { "createAndAttachTexture", _wrap_Fbo_createAndAttachTexture}, - { "attachTexture", _wrap_Fbo_attachTexture}, - { "createAndAttachRenderbuffer", _wrap_Fbo_createAndAttachRenderbuffer}, - { "createAndAttachDepthStencilTexture", _wrap_Fbo_createAndAttachDepthStencilTexture}, - { "getNumTextures", _wrap_Fbo_getNumTextures}, - { "setActiveDrawBuffer", _wrap_Fbo_setActiveDrawBuffer}, - { "activateAllDrawBuffers", _wrap_Fbo_activateAllDrawBuffers}, - { "getId", _wrap_Fbo_getId}, - { "getIdDrawBuffer", _wrap_Fbo_getIdDrawBuffer}, - { "getDepthBuffer", _wrap_Fbo_getDepthBuffer}, - { "getStencilBuffer", _wrap_Fbo_getStencilBuffer}, - {0,0} -}; -static swig_lua_method swig_Fbo_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_Fbo_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_Fbo_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_Fbo_Sf_SwigStatic_methods[]= { - { "checkGLSupport", _wrap_Fbo_checkGLSupport}, - { "maxColorAttachments", _wrap_Fbo_maxColorAttachments}, - { "maxDrawBuffers", _wrap_Fbo_maxDrawBuffers}, - { "maxSamples", _wrap_Fbo_maxSamples}, - {0,0} -}; -static swig_lua_class* swig_Fbo_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_Fbo_Sf_SwigStatic = { - "Fbo", - swig_Fbo_Sf_SwigStatic_methods, - swig_Fbo_Sf_SwigStatic_attributes, - swig_Fbo_Sf_SwigStatic_constants, - swig_Fbo_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_Fbo_bases[] = {0}; -static const char *swig_Fbo_base_names[] = {0}; -static swig_lua_class _wrap_class_Fbo = { "Fbo", "Fbo", &SWIGTYPE_p_ofFbo,_proxy__wrap_new_Fbo, swig_delete_Fbo, swig_Fbo_methods, swig_Fbo_attributes, &swig_Fbo_Sf_SwigStatic, swig_Fbo_meta, swig_Fbo_bases, swig_Fbo_base_names }; - -static int _wrap_getUsingArbTex(lua_State* L) { int SWIG_arg = 0; bool result; SWIG_check_num_args("ofGetUsingArbTex",0,0) - result = (bool)ofGetUsingArbTex(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_enableArbTex(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofEnableArbTex",0,0) ofEnableArbTex(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_disableArbTex(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofDisableArbTex",0,0) ofDisableArbTex(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getUsingNormalizedTexCoords(lua_State* L) { int SWIG_arg = 0; bool result; - SWIG_check_num_args("ofGetUsingNormalizedTexCoords",0,0) result = (bool)ofGetUsingNormalizedTexCoords(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_enableNormalizedTexCoords(lua_State* L) { int SWIG_arg = 0; - SWIG_check_num_args("ofEnableNormalizedTexCoords",0,0) ofEnableNormalizedTexCoords(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_disableNormalizedTexCoords(lua_State* L) { int SWIG_arg = 0; - SWIG_check_num_args("ofDisableNormalizedTexCoords",0,0) ofDisableNormalizedTexCoords(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_new_TextureData(lua_State* L) { int SWIG_arg = 0; ofTextureData *result = 0 ; - SWIG_check_num_args("ofTextureData::ofTextureData",0,0) result = (ofTextureData *)new ofTextureData(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTextureData,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_TextureData_textureID_set(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - unsigned int arg2 ; SWIG_check_num_args("ofTextureData::textureID",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::textureID",1,"ofTextureData *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTextureData::textureID",2,"unsigned int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_textureID_set",1,SWIGTYPE_p_ofTextureData); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned int)lua_tonumber(L, 2); - if (arg1) (arg1)->textureID = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_textureID_get(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - unsigned int result; SWIG_check_num_args("ofTextureData::textureID",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::textureID",1,"ofTextureData *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_textureID_get",1,SWIGTYPE_p_ofTextureData); } result = (unsigned int) ((arg1)->textureID); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_textureTarget_set(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - int arg2 ; SWIG_check_num_args("ofTextureData::textureTarget",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::textureTarget",1,"ofTextureData *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTextureData::textureTarget",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_textureTarget_set",1,SWIGTYPE_p_ofTextureData); } arg2 = (int)lua_tonumber(L, 2); - if (arg1) (arg1)->textureTarget = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_textureTarget_get(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - int result; SWIG_check_num_args("ofTextureData::textureTarget",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::textureTarget",1,"ofTextureData *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_textureTarget_get",1,SWIGTYPE_p_ofTextureData); } result = (int) ((arg1)->textureTarget); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_glInternalFormat_set(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - int arg2 ; SWIG_check_num_args("ofTextureData::glInternalFormat",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::glInternalFormat",1,"ofTextureData *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTextureData::glInternalFormat",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_glInternalFormat_set",1,SWIGTYPE_p_ofTextureData); } arg2 = (int)lua_tonumber(L, 2); - if (arg1) (arg1)->glInternalFormat = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_glInternalFormat_get(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - int result; SWIG_check_num_args("ofTextureData::glInternalFormat",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::glInternalFormat",1,"ofTextureData *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_glInternalFormat_get",1,SWIGTYPE_p_ofTextureData); } result = (int) ((arg1)->glInternalFormat); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_tex_t_set(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - float arg2 ; SWIG_check_num_args("ofTextureData::tex_t",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::tex_t",1,"ofTextureData *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTextureData::tex_t",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_tex_t_set",1,SWIGTYPE_p_ofTextureData); } arg2 = (float)lua_tonumber(L, 2); - if (arg1) (arg1)->tex_t = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_tex_t_get(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - float result; SWIG_check_num_args("ofTextureData::tex_t",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::tex_t",1,"ofTextureData *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_tex_t_get",1,SWIGTYPE_p_ofTextureData); } result = (float) ((arg1)->tex_t); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_tex_u_set(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - float arg2 ; SWIG_check_num_args("ofTextureData::tex_u",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::tex_u",1,"ofTextureData *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTextureData::tex_u",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_tex_u_set",1,SWIGTYPE_p_ofTextureData); } arg2 = (float)lua_tonumber(L, 2); - if (arg1) (arg1)->tex_u = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_tex_u_get(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - float result; SWIG_check_num_args("ofTextureData::tex_u",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::tex_u",1,"ofTextureData *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_tex_u_get",1,SWIGTYPE_p_ofTextureData); } result = (float) ((arg1)->tex_u); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_tex_w_set(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - float arg2 ; SWIG_check_num_args("ofTextureData::tex_w",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::tex_w",1,"ofTextureData *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTextureData::tex_w",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_tex_w_set",1,SWIGTYPE_p_ofTextureData); } arg2 = (float)lua_tonumber(L, 2); - if (arg1) (arg1)->tex_w = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_tex_w_get(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - float result; SWIG_check_num_args("ofTextureData::tex_w",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::tex_w",1,"ofTextureData *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_tex_w_get",1,SWIGTYPE_p_ofTextureData); } result = (float) ((arg1)->tex_w); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_tex_h_set(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - float arg2 ; SWIG_check_num_args("ofTextureData::tex_h",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::tex_h",1,"ofTextureData *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTextureData::tex_h",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_tex_h_set",1,SWIGTYPE_p_ofTextureData); } arg2 = (float)lua_tonumber(L, 2); - if (arg1) (arg1)->tex_h = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_tex_h_get(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - float result; SWIG_check_num_args("ofTextureData::tex_h",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::tex_h",1,"ofTextureData *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_tex_h_get",1,SWIGTYPE_p_ofTextureData); } result = (float) ((arg1)->tex_h); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_width_set(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - float arg2 ; SWIG_check_num_args("ofTextureData::width",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::width",1,"ofTextureData *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTextureData::width",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_width_set",1,SWIGTYPE_p_ofTextureData); } arg2 = (float)lua_tonumber(L, 2); - if (arg1) (arg1)->width = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_width_get(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - float result; SWIG_check_num_args("ofTextureData::width",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::width",1,"ofTextureData *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_width_get",1,SWIGTYPE_p_ofTextureData); } result = (float) ((arg1)->width); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_height_set(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - float arg2 ; SWIG_check_num_args("ofTextureData::height",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::height",1,"ofTextureData *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTextureData::height",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_height_set",1,SWIGTYPE_p_ofTextureData); } arg2 = (float)lua_tonumber(L, 2); - if (arg1) (arg1)->height = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_height_get(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - float result; SWIG_check_num_args("ofTextureData::height",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::height",1,"ofTextureData *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_height_get",1,SWIGTYPE_p_ofTextureData); } result = (float) ((arg1)->height); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_bFlipTexture_set(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - bool arg2 ; SWIG_check_num_args("ofTextureData::bFlipTexture",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::bFlipTexture",1,"ofTextureData *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofTextureData::bFlipTexture",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_bFlipTexture_set",1,SWIGTYPE_p_ofTextureData); } arg2 = (lua_toboolean(L, 2)!=0); - if (arg1) (arg1)->bFlipTexture = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_bFlipTexture_get(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - bool result; SWIG_check_num_args("ofTextureData::bFlipTexture",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::bFlipTexture",1,"ofTextureData *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_bFlipTexture_get",1,SWIGTYPE_p_ofTextureData); } result = (bool) ((arg1)->bFlipTexture); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_compressionType_set(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - ofTexCompression arg2 ; SWIG_check_num_args("ofTextureData::compressionType",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::compressionType",1,"ofTextureData *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTextureData::compressionType",2,"ofTexCompression"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_compressionType_set",1,SWIGTYPE_p_ofTextureData); } - arg2 = (ofTexCompression)(int)lua_tonumber(L, 2); if (arg1) (arg1)->compressionType = arg2; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_compressionType_get(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - ofTexCompression result; SWIG_check_num_args("ofTextureData::compressionType",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::compressionType",1,"ofTextureData *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_compressionType_get",1,SWIGTYPE_p_ofTextureData); } - result = (ofTexCompression) ((arg1)->compressionType); lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_bAllocated_set(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - bool arg2 ; SWIG_check_num_args("ofTextureData::bAllocated",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::bAllocated",1,"ofTextureData *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofTextureData::bAllocated",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_bAllocated_set",1,SWIGTYPE_p_ofTextureData); } arg2 = (lua_toboolean(L, 2)!=0); - if (arg1) (arg1)->bAllocated = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_bAllocated_get(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - bool result; SWIG_check_num_args("ofTextureData::bAllocated",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::bAllocated",1,"ofTextureData *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_bAllocated_get",1,SWIGTYPE_p_ofTextureData); } result = (bool) ((arg1)->bAllocated); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_minFilter_set(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - GLint arg2 ; SWIG_check_num_args("ofTextureData::minFilter",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::minFilter",1,"ofTextureData *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTextureData::minFilter",2,"GLint"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_minFilter_set",1,SWIGTYPE_p_ofTextureData); } arg2 = (GLint)lua_tonumber(L, 2); - if (arg1) (arg1)->minFilter = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_minFilter_get(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - GLint result; SWIG_check_num_args("ofTextureData::minFilter",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::minFilter",1,"ofTextureData *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_minFilter_get",1,SWIGTYPE_p_ofTextureData); } result = (GLint) ((arg1)->minFilter); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_magFilter_set(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - GLint arg2 ; SWIG_check_num_args("ofTextureData::magFilter",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::magFilter",1,"ofTextureData *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTextureData::magFilter",2,"GLint"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_magFilter_set",1,SWIGTYPE_p_ofTextureData); } arg2 = (GLint)lua_tonumber(L, 2); - if (arg1) (arg1)->magFilter = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_magFilter_get(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - GLint result; SWIG_check_num_args("ofTextureData::magFilter",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::magFilter",1,"ofTextureData *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_magFilter_get",1,SWIGTYPE_p_ofTextureData); } result = (GLint) ((arg1)->magFilter); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_wrapModeHorizontal_set(lua_State* L) { int SWIG_arg = 0; - ofTextureData *arg1 = (ofTextureData *) 0 ; GLint arg2 ; SWIG_check_num_args("ofTextureData::wrapModeHorizontal",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::wrapModeHorizontal",1,"ofTextureData *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTextureData::wrapModeHorizontal",2,"GLint"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_wrapModeHorizontal_set",1,SWIGTYPE_p_ofTextureData); } arg2 = (GLint)lua_tonumber(L, 2); - if (arg1) (arg1)->wrapModeHorizontal = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_wrapModeHorizontal_get(lua_State* L) { int SWIG_arg = 0; - ofTextureData *arg1 = (ofTextureData *) 0 ; GLint result; SWIG_check_num_args("ofTextureData::wrapModeHorizontal",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::wrapModeHorizontal",1,"ofTextureData *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_wrapModeHorizontal_get",1,SWIGTYPE_p_ofTextureData); } - result = (GLint) ((arg1)->wrapModeHorizontal); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_wrapModeVertical_set(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - GLint arg2 ; SWIG_check_num_args("ofTextureData::wrapModeVertical",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::wrapModeVertical",1,"ofTextureData *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTextureData::wrapModeVertical",2,"GLint"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_wrapModeVertical_set",1,SWIGTYPE_p_ofTextureData); } arg2 = (GLint)lua_tonumber(L, 2); - if (arg1) (arg1)->wrapModeVertical = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_wrapModeVertical_get(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - GLint result; SWIG_check_num_args("ofTextureData::wrapModeVertical",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::wrapModeVertical",1,"ofTextureData *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_wrapModeVertical_get",1,SWIGTYPE_p_ofTextureData); } - result = (GLint) ((arg1)->wrapModeVertical); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_bufferId_set(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - unsigned int arg2 ; SWIG_check_num_args("ofTextureData::bufferId",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::bufferId",1,"ofTextureData *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTextureData::bufferId",2,"unsigned int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_bufferId_set",1,SWIGTYPE_p_ofTextureData); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned int)lua_tonumber(L, 2); - if (arg1) (arg1)->bufferId = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TextureData_bufferId_get(lua_State* L) { int SWIG_arg = 0; ofTextureData *arg1 = (ofTextureData *) 0 ; - unsigned int result; SWIG_check_num_args("ofTextureData::bufferId",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTextureData::bufferId",1,"ofTextureData *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("TextureData_bufferId_get",1,SWIGTYPE_p_ofTextureData); } result = (unsigned int) ((arg1)->bufferId); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_TextureData(void *obj) { -ofTextureData *arg1 = (ofTextureData *) obj; -delete arg1; -} -static int _proxy__wrap_new_TextureData(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_TextureData); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_TextureData_attributes[] = { - { "textureID", _wrap_TextureData_textureID_get, _wrap_TextureData_textureID_set }, - { "textureTarget", _wrap_TextureData_textureTarget_get, _wrap_TextureData_textureTarget_set }, - { "glInternalFormat", _wrap_TextureData_glInternalFormat_get, _wrap_TextureData_glInternalFormat_set }, - { "tex_t", _wrap_TextureData_tex_t_get, _wrap_TextureData_tex_t_set }, - { "tex_u", _wrap_TextureData_tex_u_get, _wrap_TextureData_tex_u_set }, - { "tex_w", _wrap_TextureData_tex_w_get, _wrap_TextureData_tex_w_set }, - { "tex_h", _wrap_TextureData_tex_h_get, _wrap_TextureData_tex_h_set }, - { "width", _wrap_TextureData_width_get, _wrap_TextureData_width_set }, - { "height", _wrap_TextureData_height_get, _wrap_TextureData_height_set }, - { "bFlipTexture", _wrap_TextureData_bFlipTexture_get, _wrap_TextureData_bFlipTexture_set }, - { "compressionType", _wrap_TextureData_compressionType_get, _wrap_TextureData_compressionType_set }, - { "bAllocated", _wrap_TextureData_bAllocated_get, _wrap_TextureData_bAllocated_set }, - { "minFilter", _wrap_TextureData_minFilter_get, _wrap_TextureData_minFilter_set }, - { "magFilter", _wrap_TextureData_magFilter_get, _wrap_TextureData_magFilter_set }, - { "wrapModeHorizontal", _wrap_TextureData_wrapModeHorizontal_get, _wrap_TextureData_wrapModeHorizontal_set }, - { "wrapModeVertical", _wrap_TextureData_wrapModeVertical_get, _wrap_TextureData_wrapModeVertical_set }, - { "bufferId", _wrap_TextureData_bufferId_get, _wrap_TextureData_bufferId_set }, - {0,0,0} -}; -static swig_lua_method swig_TextureData_methods[]= { - {0,0} -}; -static swig_lua_method swig_TextureData_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_TextureData_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_TextureData_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_TextureData_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_TextureData_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_TextureData_Sf_SwigStatic = { - "TextureData", - swig_TextureData_Sf_SwigStatic_methods, - swig_TextureData_Sf_SwigStatic_attributes, - swig_TextureData_Sf_SwigStatic_constants, - swig_TextureData_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_TextureData_bases[] = {0}; -static const char *swig_TextureData_base_names[] = {0}; -static swig_lua_class _wrap_class_TextureData = { "TextureData", "TextureData", &SWIGTYPE_p_ofTextureData,_proxy__wrap_new_TextureData, swig_delete_TextureData, swig_TextureData_methods, swig_TextureData_attributes, &swig_TextureData_Sf_SwigStatic, swig_TextureData_meta, swig_TextureData_bases, swig_TextureData_base_names }; - -static int _wrap_enableTextureEdgeHack(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofEnableTextureEdgeHack",0,0) - ofEnableTextureEdgeHack(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_disableTextureEdgeHack(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofDisableTextureEdgeHack",0,0) - ofDisableTextureEdgeHack(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_isTextureEdgeHackEnabled(lua_State* L) { int SWIG_arg = 0; bool result; - SWIG_check_num_args("ofIsTextureEdgeHackEnabled",0,0) result = (bool)ofIsTextureEdgeHackEnabled(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_new_Texture__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofTexture *result = 0 ; - SWIG_check_num_args("ofTexture::ofTexture",0,0) result = (ofTexture *)new ofTexture(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTexture,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Texture__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = 0 ; ofTexture *result = 0 ; - SWIG_check_num_args("ofTexture::ofTexture",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofTexture::ofTexture",1,"ofTexture &&"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("new_Texture",1,SWIGTYPE_p_ofTexture); } result = (ofTexture *)new ofTexture((ofTexture &&)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTexture,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Texture(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_Texture__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_new_Texture__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_Texture'\n" " Possible C/C++ prototypes are:\n" - " ofTexture::ofTexture()\n" " ofTexture::ofTexture(ofTexture &&)\n"); lua_error(L);return 0; } -static int _wrap_Texture_allocate__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - ofTextureData *arg2 = 0 ; SWIG_check_num_args("ofTexture::allocate",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::allocate",1,"ofTexture *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofTexture::allocate",2,"ofTextureData const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_allocate",1,SWIGTYPE_p_ofTexture); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("Texture_allocate",2,SWIGTYPE_p_ofTextureData); } (arg1)->allocate((ofTextureData const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_allocate__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - ofTextureData *arg2 = 0 ; int arg3 ; int arg4 ; SWIG_check_num_args("ofTexture::allocate",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::allocate",1,"ofTexture *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofTexture::allocate",2,"ofTextureData const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTexture::allocate",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofTexture::allocate",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_allocate",1,SWIGTYPE_p_ofTexture); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofTextureData,0))){ - SWIG_fail_ptr("Texture_allocate",2,SWIGTYPE_p_ofTextureData); } arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); (arg1)->allocate((ofTextureData const &)*arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_allocate__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; int arg2 ; - int arg3 ; int arg4 ; SWIG_check_num_args("ofTexture::allocate",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::allocate",1,"ofTexture *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTexture::allocate",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTexture::allocate",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofTexture::allocate",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_allocate",1,SWIGTYPE_p_ofTexture); } arg2 = (int)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); (arg1)->allocate(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Texture_allocate__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; int arg2 ; - int arg3 ; int arg4 ; int arg5 ; int arg6 ; SWIG_check_num_args("ofTexture::allocate",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::allocate",1,"ofTexture *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTexture::allocate",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTexture::allocate",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofTexture::allocate",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofTexture::allocate",5,"int"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofTexture::allocate",6,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_allocate",1,SWIGTYPE_p_ofTexture); } arg2 = (int)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); arg6 = (int)lua_tonumber(L, 6); - (arg1)->allocate(arg2,arg3,arg4,arg5,arg6); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_allocate__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; int arg2 ; - int arg3 ; int arg4 ; bool arg5 ; SWIG_check_num_args("ofTexture::allocate",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::allocate",1,"ofTexture *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTexture::allocate",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTexture::allocate",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofTexture::allocate",4,"int"); - if(!lua_isboolean(L,5)) SWIG_fail_arg("ofTexture::allocate",5,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_allocate",1,SWIGTYPE_p_ofTexture); } arg2 = (int)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); arg5 = (lua_toboolean(L, 5)!=0); (arg1)->allocate(arg2,arg3,arg4,arg5); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_allocate__SWIG_5(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; int arg2 ; - int arg3 ; int arg4 ; bool arg5 ; int arg6 ; int arg7 ; SWIG_check_num_args("ofTexture::allocate",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::allocate",1,"ofTexture *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTexture::allocate",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTexture::allocate",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofTexture::allocate",4,"int"); - if(!lua_isboolean(L,5)) SWIG_fail_arg("ofTexture::allocate",5,"bool"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofTexture::allocate",6,"int"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofTexture::allocate",7,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_allocate",1,SWIGTYPE_p_ofTexture); } arg2 = (int)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); arg5 = (lua_toboolean(L, 5)!=0); arg6 = (int)lua_tonumber(L, 6); - arg7 = (int)lua_tonumber(L, 7); (arg1)->allocate(arg2,arg3,arg4,arg5,arg6,arg7); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Texture_allocate__SWIG_6(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - ofPixels *arg2 = 0 ; SWIG_check_num_args("ofTexture::allocate",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::allocate",1,"ofTexture *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofTexture::allocate",2,"ofPixels const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_allocate",1,SWIGTYPE_p_ofTexture); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Texture_allocate",2,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } (arg1)->allocate((ofPixels const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_allocate__SWIG_7(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - ofPixels *arg2 = 0 ; bool arg3 ; SWIG_check_num_args("ofTexture::allocate",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::allocate",1,"ofTexture *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofTexture::allocate",2,"ofPixels const &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofTexture::allocate",3,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_allocate",1,SWIGTYPE_p_ofTexture); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Texture_allocate",2,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } arg3 = (lua_toboolean(L, 3)!=0); - (arg1)->allocate((ofPixels const &)*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_allocate__SWIG_8(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - ofShortPixels *arg2 = 0 ; SWIG_check_num_args("ofTexture::allocate",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::allocate",1,"ofTexture *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofTexture::allocate",2,"ofShortPixels const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_allocate",1,SWIGTYPE_p_ofTexture); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("Texture_allocate",2,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - (arg1)->allocate((ofShortPixels const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_allocate__SWIG_9(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - ofShortPixels *arg2 = 0 ; bool arg3 ; SWIG_check_num_args("ofTexture::allocate",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::allocate",1,"ofTexture *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofTexture::allocate",2,"ofShortPixels const &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofTexture::allocate",3,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_allocate",1,SWIGTYPE_p_ofTexture); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("Texture_allocate",2,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } arg3 = (lua_toboolean(L, 3)!=0); - (arg1)->allocate((ofShortPixels const &)*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_allocate__SWIG_10(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - ofFloatPixels *arg2 = 0 ; SWIG_check_num_args("ofTexture::allocate",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::allocate",1,"ofTexture *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofTexture::allocate",2,"ofFloatPixels const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_allocate",1,SWIGTYPE_p_ofTexture); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("Texture_allocate",2,SWIGTYPE_p_ofPixels_T_float_t); } (arg1)->allocate((ofFloatPixels const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_allocate__SWIG_11(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - ofFloatPixels *arg2 = 0 ; bool arg3 ; SWIG_check_num_args("ofTexture::allocate",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::allocate",1,"ofTexture *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofTexture::allocate",2,"ofFloatPixels const &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofTexture::allocate",3,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_allocate",1,SWIGTYPE_p_ofTexture); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("Texture_allocate",2,SWIGTYPE_p_ofPixels_T_float_t); } arg3 = (lua_toboolean(L, 3)!=0); - (arg1)->allocate((ofFloatPixels const &)*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_allocate(lua_State* L) { int argc; int argv[8]={ 1,2,3,4,5,6,7,8} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofTextureData, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Texture_allocate__SWIG_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Texture_allocate__SWIG_6(L);} } } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Texture_allocate__SWIG_8(L);} } } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Texture_allocate__SWIG_10(L);} } } if (argc == 3) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - return _wrap_Texture_allocate__SWIG_9(L);} } } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - return _wrap_Texture_allocate__SWIG_7(L);} } } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - return _wrap_Texture_allocate__SWIG_11(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofTextureData, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Texture_allocate__SWIG_1(L);} } } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Texture_allocate__SWIG_2(L);} } } } } if (argc == 5) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isboolean(L,argv[4]); } if (_v) { - return _wrap_Texture_allocate__SWIG_4(L);} } } } } } if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { return _wrap_Texture_allocate__SWIG_3(L);} } } } } } } - if (argc == 7) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isboolean(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { - return _wrap_Texture_allocate__SWIG_5(L);} } } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Texture_allocate'\n" " Possible C/C++ prototypes are:\n" - " ofTexture::allocate(ofTextureData const &)\n" " ofTexture::allocate(ofTextureData const &,int,int)\n" - " ofTexture::allocate(int,int,int)\n" " ofTexture::allocate(int,int,int,int,int)\n" - " ofTexture::allocate(int,int,int,bool)\n" " ofTexture::allocate(int,int,int,bool,int,int)\n" - " ofTexture::allocate(ofPixels const &)\n" " ofTexture::allocate(ofPixels const &,bool)\n" - " ofTexture::allocate(ofShortPixels const &)\n" " ofTexture::allocate(ofShortPixels const &,bool)\n" - " ofTexture::allocate(ofFloatPixels const &)\n" " ofTexture::allocate(ofFloatPixels const &,bool)\n"); - lua_error(L);return 0; } -static int _wrap_Texture_isAllocated(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; bool result; - SWIG_check_num_args("ofTexture::isAllocated",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::isAllocated",1,"ofTexture const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_isAllocated",1,SWIGTYPE_p_ofTexture); } result = (bool)((ofTexture const *)arg1)->isAllocated(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_clear(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - SWIG_check_num_args("ofTexture::clear",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::clear",1,"ofTexture *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_clear",1,SWIGTYPE_p_ofTexture); } (arg1)->clear(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Texture_setUseExternalTextureID(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - GLuint arg2 ; SWIG_check_num_args("ofTexture::setUseExternalTextureID",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::setUseExternalTextureID",1,"ofTexture *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTexture::setUseExternalTextureID",2,"GLuint"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_setUseExternalTextureID",1,SWIGTYPE_p_ofTexture); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (GLuint)lua_tonumber(L, 2); - (arg1)->setUseExternalTextureID(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_loadData__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - unsigned char *arg2 = (unsigned char *) (unsigned char *)0 ; int arg3 ; int arg4 ; int arg5 ; - SWIG_check_num_args("ofTexture::loadData",5,5) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::loadData",1,"ofTexture *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofTexture::loadData",2,"unsigned char const *const"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTexture::loadData",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofTexture::loadData",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofTexture::loadData",5,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_loadData",1,SWIGTYPE_p_ofTexture); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_unsigned_char,0))){ - SWIG_fail_ptr("Texture_loadData",2,SWIGTYPE_p_unsigned_char); } arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); (arg1)->loadData((unsigned char const *)arg2,arg3,arg4,arg5); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_loadData__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - unsigned short *arg2 = (unsigned short *) 0 ; int arg3 ; int arg4 ; int arg5 ; SWIG_check_num_args("ofTexture::loadData",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::loadData",1,"ofTexture *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofTexture::loadData",2,"unsigned short const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTexture::loadData",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofTexture::loadData",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofTexture::loadData",5,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_loadData",1,SWIGTYPE_p_ofTexture); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_unsigned_short,0))){ - SWIG_fail_ptr("Texture_loadData",2,SWIGTYPE_p_unsigned_short); } arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); (arg1)->loadData((unsigned short const *)arg2,arg3,arg4,arg5); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_loadData__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - float *arg2 = (float *) 0 ; int arg3 ; int arg4 ; int arg5 ; SWIG_check_num_args("ofTexture::loadData",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::loadData",1,"ofTexture *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofTexture::loadData",2,"float const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTexture::loadData",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofTexture::loadData",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofTexture::loadData",5,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_loadData",1,SWIGTYPE_p_ofTexture); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_float,0))){ SWIG_fail_ptr("Texture_loadData",2,SWIGTYPE_p_float); } - arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); - (arg1)->loadData((float const *)arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_loadData__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - ofPixels *arg2 = 0 ; SWIG_check_num_args("ofTexture::loadData",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::loadData",1,"ofTexture *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofTexture::loadData",2,"ofPixels const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_loadData",1,SWIGTYPE_p_ofTexture); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Texture_loadData",2,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } (arg1)->loadData((ofPixels const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_loadData__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - ofShortPixels *arg2 = 0 ; SWIG_check_num_args("ofTexture::loadData",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::loadData",1,"ofTexture *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofTexture::loadData",2,"ofShortPixels const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_loadData",1,SWIGTYPE_p_ofTexture); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("Texture_loadData",2,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - (arg1)->loadData((ofShortPixels const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_loadData__SWIG_5(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - ofFloatPixels *arg2 = 0 ; SWIG_check_num_args("ofTexture::loadData",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::loadData",1,"ofTexture *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofTexture::loadData",2,"ofFloatPixels const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_loadData",1,SWIGTYPE_p_ofTexture); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("Texture_loadData",2,SWIGTYPE_p_ofPixels_T_float_t); } (arg1)->loadData((ofFloatPixels const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_loadData__SWIG_6(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - ofPixels *arg2 = 0 ; int arg3 ; SWIG_check_num_args("ofTexture::loadData",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::loadData",1,"ofTexture *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofTexture::loadData",2,"ofPixels const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTexture::loadData",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_loadData",1,SWIGTYPE_p_ofTexture); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Texture_loadData",2,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } arg3 = (int)lua_tonumber(L, 3); - (arg1)->loadData((ofPixels const &)*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_loadData__SWIG_7(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - ofShortPixels *arg2 = 0 ; int arg3 ; SWIG_check_num_args("ofTexture::loadData",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::loadData",1,"ofTexture *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofTexture::loadData",2,"ofShortPixels const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTexture::loadData",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_loadData",1,SWIGTYPE_p_ofTexture); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("Texture_loadData",2,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } arg3 = (int)lua_tonumber(L, 3); - (arg1)->loadData((ofShortPixels const &)*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_loadData__SWIG_8(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - ofFloatPixels *arg2 = 0 ; int arg3 ; SWIG_check_num_args("ofTexture::loadData",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::loadData",1,"ofTexture *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofTexture::loadData",2,"ofFloatPixels const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTexture::loadData",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_loadData",1,SWIGTYPE_p_ofTexture); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("Texture_loadData",2,SWIGTYPE_p_ofPixels_T_float_t); } arg3 = (int)lua_tonumber(L, 3); - (arg1)->loadData((ofFloatPixels const &)*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_loadData(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Texture_loadData__SWIG_3(L);} } } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Texture_loadData__SWIG_4(L);} } } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Texture_loadData__SWIG_5(L);} } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Texture_loadData__SWIG_6(L);} } } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Texture_loadData__SWIG_7(L);} } } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Texture_loadData__SWIG_8(L);} } } } if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_unsigned_char, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_Texture_loadData__SWIG_0(L);} } } } } } - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_unsigned_short, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_Texture_loadData__SWIG_1(L);} } } } } } - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_Texture_loadData__SWIG_2(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Texture_loadData'\n" " Possible C/C++ prototypes are:\n" - " ofTexture::loadData(unsigned char const *const,int,int,int)\n" - " ofTexture::loadData(unsigned short const *,int,int,int)\n" " ofTexture::loadData(float const *,int,int,int)\n" - " ofTexture::loadData(ofPixels const &)\n" " ofTexture::loadData(ofShortPixels const &)\n" - " ofTexture::loadData(ofFloatPixels const &)\n" " ofTexture::loadData(ofPixels const &,int)\n" - " ofTexture::loadData(ofShortPixels const &,int)\n" " ofTexture::loadData(ofFloatPixels const &,int)\n"); - lua_error(L);return 0; } -static int _wrap_Texture_loadScreenData(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; int arg2 ; - int arg3 ; int arg4 ; int arg5 ; SWIG_check_num_args("ofTexture::loadScreenData",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::loadScreenData",1,"ofTexture *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTexture::loadScreenData",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTexture::loadScreenData",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofTexture::loadScreenData",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofTexture::loadScreenData",5,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_loadScreenData",1,SWIGTYPE_p_ofTexture); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); - (arg1)->loadScreenData(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_draw__SWIG_0_0(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - ofPoint *arg2 = 0 ; SWIG_check_num_args("draw",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("draw",1,"ofTexture const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("draw",2,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_draw",1,SWIGTYPE_p_ofTexture); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Texture_draw",2,SWIGTYPE_p_ofVec3f); } - ((ofTexture const *)arg1)->draw((ofPoint const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Texture_draw__SWIG_0_1(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - ofRectangle *arg2 = 0 ; SWIG_check_num_args("draw",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("draw",1,"ofTexture const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("draw",2,"ofRectangle const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_draw",1,SWIGTYPE_p_ofTexture); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Texture_draw",2,SWIGTYPE_p_ofRectangle); } ((ofTexture const *)arg1)->draw((ofRectangle const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_draw__SWIG_0_2(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - ofPoint *arg2 = 0 ; float arg3 ; float arg4 ; SWIG_check_num_args("draw",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("draw",1,"ofTexture const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("draw",2,"ofPoint const &"); if(!lua_isnumber(L,3)) SWIG_fail_arg("draw",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("draw",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_draw",1,SWIGTYPE_p_ofTexture); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Texture_draw",2,SWIGTYPE_p_ofVec3f); } - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - ((ofTexture const *)arg1)->draw((ofPoint const &)*arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Texture_draw__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; float arg2 ; - float arg3 ; SWIG_check_num_args("ofTexture::draw",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::draw",1,"ofTexture const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTexture::draw",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTexture::draw",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_draw",1,SWIGTYPE_p_ofTexture); } arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - ((ofTexture const *)arg1)->draw(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_draw__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; float arg2 ; - float arg3 ; float arg4 ; SWIG_check_num_args("ofTexture::draw",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::draw",1,"ofTexture const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTexture::draw",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTexture::draw",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofTexture::draw",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_draw",1,SWIGTYPE_p_ofTexture); } arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - arg4 = (float)lua_tonumber(L, 4); ((ofTexture const *)arg1)->draw(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Texture_draw__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; float arg2 ; - float arg3 ; float arg4 ; float arg5 ; SWIG_check_num_args("ofTexture::draw",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::draw",1,"ofTexture const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTexture::draw",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTexture::draw",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofTexture::draw",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofTexture::draw",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_draw",1,SWIGTYPE_p_ofTexture); } arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); ((ofTexture const *)arg1)->draw(arg2,arg3,arg4,arg5); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_draw__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; float arg2 ; - float arg3 ; float arg4 ; float arg5 ; float arg6 ; SWIG_check_num_args("ofTexture::draw",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::draw",1,"ofTexture const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTexture::draw",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTexture::draw",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofTexture::draw",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofTexture::draw",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofTexture::draw",6,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_draw",1,SWIGTYPE_p_ofTexture); } arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); - ((ofTexture const *)arg1)->draw(arg2,arg3,arg4,arg5,arg6); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Texture_draw__SWIG_5(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; ofPoint *arg2 = 0 ; - ofPoint *arg3 = 0 ; ofPoint *arg4 = 0 ; ofPoint *arg5 = 0 ; SWIG_check_num_args("ofTexture::draw",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::draw",1,"ofTexture const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofTexture::draw",2,"ofPoint const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofTexture::draw",3,"ofPoint const &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofTexture::draw",4,"ofPoint const &"); - if(!lua_isuserdata(L,5)) SWIG_fail_arg("ofTexture::draw",5,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_draw",1,SWIGTYPE_p_ofTexture); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Texture_draw",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Texture_draw",3,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Texture_draw",4,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Texture_draw",5,SWIGTYPE_p_ofVec3f); } - ((ofTexture const *)arg1)->draw((ofPoint const &)*arg2,(ofPoint const &)*arg3,(ofPoint const &)*arg4,(ofPoint const &)*arg5); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_draw(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Texture_draw__SWIG_0_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Texture_draw__SWIG_0_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Texture_draw__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Texture_draw__SWIG_0_2(L);} } } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Texture_draw__SWIG_2(L);} } } } } if (argc == 5) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[4])==0 || SWIG_ConvertPtr(L,argv[4], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Texture_draw__SWIG_5(L);} } } } } } if (argc == 5) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Texture_draw__SWIG_3(L);} } } } } } if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { return _wrap_Texture_draw__SWIG_4(L);} } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Texture_draw'\n" " Possible C/C++ prototypes are:\n" - " draw(ofPoint const &) const\n" " draw(ofRectangle const &) const\n" " draw(ofPoint const &,float,float) const\n" - " ofTexture::draw(float,float) const\n" " ofTexture::draw(float,float,float) const\n" - " ofTexture::draw(float,float,float,float) const\n" " ofTexture::draw(float,float,float,float,float) const\n" - " ofTexture::draw(ofPoint const &,ofPoint const &,ofPoint const &,ofPoint const &) const\n"); lua_error(L);return 0; } -static int _wrap_Texture_drawSubsection__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - float arg2 ; float arg3 ; float arg4 ; float arg5 ; float arg6 ; float arg7 ; - SWIG_check_num_args("ofTexture::drawSubsection",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::drawSubsection",1,"ofTexture const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTexture::drawSubsection",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTexture::drawSubsection",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofTexture::drawSubsection",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofTexture::drawSubsection",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofTexture::drawSubsection",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofTexture::drawSubsection",7,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_drawSubsection",1,SWIGTYPE_p_ofTexture); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); - ((ofTexture const *)arg1)->drawSubsection(arg2,arg3,arg4,arg5,arg6,arg7); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Texture_drawSubsection__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - float arg2 ; float arg3 ; float arg4 ; float arg5 ; float arg6 ; float arg7 ; float arg8 ; - SWIG_check_num_args("ofTexture::drawSubsection",8,8) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::drawSubsection",1,"ofTexture const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTexture::drawSubsection",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTexture::drawSubsection",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofTexture::drawSubsection",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofTexture::drawSubsection",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofTexture::drawSubsection",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofTexture::drawSubsection",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofTexture::drawSubsection",8,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_drawSubsection",1,SWIGTYPE_p_ofTexture); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (float)lua_tonumber(L, 8); - ((ofTexture const *)arg1)->drawSubsection(arg2,arg3,arg4,arg5,arg6,arg7,arg8); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Texture_drawSubsection__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - float arg2 ; float arg3 ; float arg4 ; float arg5 ; float arg6 ; float arg7 ; float arg8 ; float arg9 ; - SWIG_check_num_args("ofTexture::drawSubsection",9,9) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::drawSubsection",1,"ofTexture const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTexture::drawSubsection",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTexture::drawSubsection",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofTexture::drawSubsection",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofTexture::drawSubsection",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofTexture::drawSubsection",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofTexture::drawSubsection",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofTexture::drawSubsection",8,"float"); - if(!lua_isnumber(L,9)) SWIG_fail_arg("ofTexture::drawSubsection",9,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_drawSubsection",1,SWIGTYPE_p_ofTexture); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (float)lua_tonumber(L, 8); - arg9 = (float)lua_tonumber(L, 9); ((ofTexture const *)arg1)->drawSubsection(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_drawSubsection__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - float arg2 ; float arg3 ; float arg4 ; float arg5 ; float arg6 ; float arg7 ; float arg8 ; float arg9 ; float arg10 ; - SWIG_check_num_args("ofTexture::drawSubsection",10,10) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::drawSubsection",1,"ofTexture const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTexture::drawSubsection",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTexture::drawSubsection",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofTexture::drawSubsection",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofTexture::drawSubsection",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofTexture::drawSubsection",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofTexture::drawSubsection",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofTexture::drawSubsection",8,"float"); - if(!lua_isnumber(L,9)) SWIG_fail_arg("ofTexture::drawSubsection",9,"float"); - if(!lua_isnumber(L,10)) SWIG_fail_arg("ofTexture::drawSubsection",10,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_drawSubsection",1,SWIGTYPE_p_ofTexture); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (float)lua_tonumber(L, 8); - arg9 = (float)lua_tonumber(L, 9); arg10 = (float)lua_tonumber(L, 10); - ((ofTexture const *)arg1)->drawSubsection(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_drawSubsection(lua_State* L) { int argc; int argv[11]={ 1,2,3,4,5,6,7,8,9,10,11} ; - argc = lua_gettop(L); if (argc == 7) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { - return _wrap_Texture_drawSubsection__SWIG_0(L);} } } } } } } } if (argc == 8) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { return _wrap_Texture_drawSubsection__SWIG_1(L);} } } } } } } - } } if (argc == 9) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { { _v = lua_isnumber(L,argv[8]); } if (_v) { - return _wrap_Texture_drawSubsection__SWIG_2(L);} } } } } } } } } } if (argc == 10) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { { _v = lua_isnumber(L,argv[8]); } if (_v) { { - _v = lua_isnumber(L,argv[9]); } if (_v) { return _wrap_Texture_drawSubsection__SWIG_3(L);} } } } } - } } } } } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Texture_drawSubsection'\n" - " Possible C/C++ prototypes are:\n" " ofTexture::drawSubsection(float,float,float,float,float,float) const\n" - " ofTexture::drawSubsection(float,float,float,float,float,float,float) const\n" - " ofTexture::drawSubsection(float,float,float,float,float,float,float,float) const\n" - " ofTexture::drawSubsection(float,float,float,float,float,float,float,float,float) const\n"); lua_error(L);return 0; } -static int _wrap_Texture_getQuad(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; ofPoint *arg2 = 0 ; - ofPoint *arg3 = 0 ; ofPoint *arg4 = 0 ; ofPoint *arg5 = 0 ; ofMesh result; SWIG_check_num_args("ofTexture::getQuad",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::getQuad",1,"ofTexture const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofTexture::getQuad",2,"ofPoint const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofTexture::getQuad",3,"ofPoint const &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofTexture::getQuad",4,"ofPoint const &"); - if(!lua_isuserdata(L,5)) SWIG_fail_arg("ofTexture::getQuad",5,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_getQuad",1,SWIGTYPE_p_ofTexture); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Texture_getQuad",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Texture_getQuad",3,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Texture_getQuad",4,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Texture_getQuad",5,SWIGTYPE_p_ofVec3f); } - result = ((ofTexture const *)arg1)->getQuad((ofPoint const &)*arg2,(ofPoint const &)*arg3,(ofPoint const &)*arg4,(ofPoint const &)*arg5); - { ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Texture_getMeshForSubsection(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; float arg2 ; - float arg3 ; float arg4 ; float arg5 ; float arg6 ; float arg7 ; float arg8 ; float arg9 ; float arg10 ; bool arg11 ; - ofRectMode arg12 ; ofMesh result; SWIG_check_num_args("ofTexture::getMeshForSubsection",12,12) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::getMeshForSubsection",1,"ofTexture const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTexture::getMeshForSubsection",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTexture::getMeshForSubsection",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofTexture::getMeshForSubsection",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofTexture::getMeshForSubsection",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofTexture::getMeshForSubsection",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofTexture::getMeshForSubsection",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofTexture::getMeshForSubsection",8,"float"); - if(!lua_isnumber(L,9)) SWIG_fail_arg("ofTexture::getMeshForSubsection",9,"float"); - if(!lua_isnumber(L,10)) SWIG_fail_arg("ofTexture::getMeshForSubsection",10,"float"); - if(!lua_isboolean(L,11)) SWIG_fail_arg("ofTexture::getMeshForSubsection",11,"bool"); - if(!lua_isnumber(L,12)) SWIG_fail_arg("ofTexture::getMeshForSubsection",12,"ofRectMode"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_getMeshForSubsection",1,SWIGTYPE_p_ofTexture); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (float)lua_tonumber(L, 8); - arg9 = (float)lua_tonumber(L, 9); arg10 = (float)lua_tonumber(L, 10); arg11 = (lua_toboolean(L, 11)!=0); - arg12 = (ofRectMode)(int)lua_tonumber(L, 12); - result = ((ofTexture const *)arg1)->getMeshForSubsection(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12); { - ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Texture_bind__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; int arg2 ; - SWIG_check_num_args("ofTexture::bind",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::bind",1,"ofTexture const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTexture::bind",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_bind",1,SWIGTYPE_p_ofTexture); } arg2 = (int)lua_tonumber(L, 2); - ((ofTexture const *)arg1)->bind(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_bind__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - SWIG_check_num_args("ofTexture::bind",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::bind",1,"ofTexture const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_bind",1,SWIGTYPE_p_ofTexture); } ((ofTexture const *)arg1)->bind(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_bind(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Texture_bind__SWIG_1(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Texture_bind__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Texture_bind'\n" " Possible C/C++ prototypes are:\n" - " ofTexture::bind(int) const\n" " ofTexture::bind() const\n"); lua_error(L);return 0; } -static int _wrap_Texture_unbind__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; int arg2 ; - SWIG_check_num_args("ofTexture::unbind",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::unbind",1,"ofTexture const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTexture::unbind",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_unbind",1,SWIGTYPE_p_ofTexture); } arg2 = (int)lua_tonumber(L, 2); - ((ofTexture const *)arg1)->unbind(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_unbind__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - SWIG_check_num_args("ofTexture::unbind",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::unbind",1,"ofTexture const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_unbind",1,SWIGTYPE_p_ofTexture); } ((ofTexture const *)arg1)->unbind(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_unbind(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Texture_unbind__SWIG_1(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Texture_unbind__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Texture_unbind'\n" " Possible C/C++ prototypes are:\n" - " ofTexture::unbind(int) const\n" " ofTexture::unbind() const\n"); lua_error(L);return 0; } -static int _wrap_Texture_getAlphaMask(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - ofTexture *result = 0 ; SWIG_check_num_args("ofTexture::getAlphaMask",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::getAlphaMask",1,"ofTexture const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_getAlphaMask",1,SWIGTYPE_p_ofTexture); } - result = (ofTexture *)((ofTexture const *)arg1)->getAlphaMask(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTexture,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Texture_getHeight(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; float result; - SWIG_check_num_args("ofTexture::getHeight",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::getHeight",1,"ofTexture const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_getHeight",1,SWIGTYPE_p_ofTexture); } result = (float)((ofTexture const *)arg1)->getHeight(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_getWidth(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; float result; - SWIG_check_num_args("ofTexture::getWidth",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::getWidth",1,"ofTexture const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_getWidth",1,SWIGTYPE_p_ofTexture); } result = (float)((ofTexture const *)arg1)->getWidth(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_setAnchorPercent(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; float arg2 ; - float arg3 ; SWIG_check_num_args("ofTexture::setAnchorPercent",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::setAnchorPercent",1,"ofTexture *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTexture::setAnchorPercent",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTexture::setAnchorPercent",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_setAnchorPercent",1,SWIGTYPE_p_ofTexture); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->setAnchorPercent(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Texture_setAnchorPoint(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; float arg2 ; - float arg3 ; SWIG_check_num_args("ofTexture::setAnchorPoint",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::setAnchorPoint",1,"ofTexture *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTexture::setAnchorPoint",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTexture::setAnchorPoint",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_setAnchorPoint",1,SWIGTYPE_p_ofTexture); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->setAnchorPoint(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Texture_resetAnchor(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - SWIG_check_num_args("ofTexture::resetAnchor",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::resetAnchor",1,"ofTexture *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_resetAnchor",1,SWIGTYPE_p_ofTexture); } (arg1)->resetAnchor(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_getCoordFromPoint(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; float arg2 ; - float arg3 ; ofPoint result; SWIG_check_num_args("ofTexture::getCoordFromPoint",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::getCoordFromPoint",1,"ofTexture const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTexture::getCoordFromPoint",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTexture::getCoordFromPoint",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_getCoordFromPoint",1,SWIGTYPE_p_ofTexture); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); result = ((ofTexture const *)arg1)->getCoordFromPoint(arg2,arg3); { - ofPoint * resultptr = new ofPoint((const ofPoint &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Texture_getCoordFromPercent(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; float arg2 ; - float arg3 ; ofPoint result; SWIG_check_num_args("ofTexture::getCoordFromPercent",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::getCoordFromPercent",1,"ofTexture const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTexture::getCoordFromPercent",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTexture::getCoordFromPercent",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_getCoordFromPercent",1,SWIGTYPE_p_ofTexture); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); result = ((ofTexture const *)arg1)->getCoordFromPercent(arg2,arg3); { - ofPoint * resultptr = new ofPoint((const ofPoint &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Texture_setAlphaMask(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - ofTexture *arg2 = 0 ; SWIG_check_num_args("ofTexture::setAlphaMask",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::setAlphaMask",1,"ofTexture *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofTexture::setAlphaMask",2,"ofTexture &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_setAlphaMask",1,SWIGTYPE_p_ofTexture); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_setAlphaMask",2,SWIGTYPE_p_ofTexture); } (arg1)->setAlphaMask(*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_disableAlphaMask(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - SWIG_check_num_args("ofTexture::disableAlphaMask",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::disableAlphaMask",1,"ofTexture *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_disableAlphaMask",1,SWIGTYPE_p_ofTexture); } (arg1)->disableAlphaMask(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_setTextureWrap(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; GLint arg2 ; - GLint arg3 ; SWIG_check_num_args("ofTexture::setTextureWrap",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::setTextureWrap",1,"ofTexture *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTexture::setTextureWrap",2,"GLint"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTexture::setTextureWrap",3,"GLint"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_setTextureWrap",1,SWIGTYPE_p_ofTexture); } arg2 = (GLint)lua_tonumber(L, 2); - arg3 = (GLint)lua_tonumber(L, 3); (arg1)->setTextureWrap(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Texture_setTextureMinMagFilter(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - GLint arg2 ; GLint arg3 ; SWIG_check_num_args("ofTexture::setTextureMinMagFilter",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::setTextureMinMagFilter",1,"ofTexture *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTexture::setTextureMinMagFilter",2,"GLint"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTexture::setTextureMinMagFilter",3,"GLint"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_setTextureMinMagFilter",1,SWIGTYPE_p_ofTexture); } arg2 = (GLint)lua_tonumber(L, 2); - arg3 = (GLint)lua_tonumber(L, 3); (arg1)->setTextureMinMagFilter(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Texture_setTextureMatrix(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - ofMatrix4x4 *arg2 = 0 ; SWIG_check_num_args("ofTexture::setTextureMatrix",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::setTextureMatrix",1,"ofTexture *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofTexture::setTextureMatrix",2,"ofMatrix4x4 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_setTextureMatrix",1,SWIGTYPE_p_ofTexture); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Texture_setTextureMatrix",2,SWIGTYPE_p_ofMatrix4x4); } (arg1)->setTextureMatrix((ofMatrix4x4 const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_getTextureMatrix(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - ofMatrix4x4 *result = 0 ; SWIG_check_num_args("ofTexture::getTextureMatrix",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::getTextureMatrix",1,"ofTexture const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_getTextureMatrix",1,SWIGTYPE_p_ofTexture); } - result = (ofMatrix4x4 *) &((ofTexture const *)arg1)->getTextureMatrix(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMatrix4x4,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Texture_isUsingTextureMatrix(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; bool result; - SWIG_check_num_args("ofTexture::isUsingTextureMatrix",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::isUsingTextureMatrix",1,"ofTexture const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_isUsingTextureMatrix",1,SWIGTYPE_p_ofTexture); } - result = (bool)((ofTexture const *)arg1)->isUsingTextureMatrix(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_disableTextureMatrix(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - SWIG_check_num_args("ofTexture::disableTextureMatrix",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::disableTextureMatrix",1,"ofTexture *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_disableTextureMatrix",1,SWIGTYPE_p_ofTexture); } (arg1)->disableTextureMatrix(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_setCompression(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - ofTexCompression arg2 ; SWIG_check_num_args("ofTexture::setCompression",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::setCompression",1,"ofTexture *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTexture::setCompression",2,"ofTexCompression"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_setCompression",1,SWIGTYPE_p_ofTexture); } arg2 = (ofTexCompression)(int)lua_tonumber(L, 2); - (arg1)->setCompression(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_setRGToRGBASwizzles(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; bool arg2 ; - SWIG_check_num_args("ofTexture::setRGToRGBASwizzles",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::setRGToRGBASwizzles",1,"ofTexture *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofTexture::setRGToRGBASwizzles",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_setRGToRGBASwizzles",1,SWIGTYPE_p_ofTexture); } arg2 = (lua_toboolean(L, 2)!=0); - (arg1)->setRGToRGBASwizzles(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_setSwizzle(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; GLenum arg2 ; - GLenum arg3 ; SWIG_check_num_args("ofTexture::setSwizzle",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::setSwizzle",1,"ofTexture *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTexture::setSwizzle",2,"GLenum"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTexture::setSwizzle",3,"GLenum"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_setSwizzle",1,SWIGTYPE_p_ofTexture); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (GLenum)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (GLenum)lua_tonumber(L, 3); - (arg1)->setSwizzle(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_readToPixels__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - ofPixels *arg2 = 0 ; SWIG_check_num_args("ofTexture::readToPixels",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::readToPixels",1,"ofTexture const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofTexture::readToPixels",2,"ofPixels &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_readToPixels",1,SWIGTYPE_p_ofTexture); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Texture_readToPixels",2,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - ((ofTexture const *)arg1)->readToPixels(*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_readToPixels__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - ofShortPixels *arg2 = 0 ; SWIG_check_num_args("ofTexture::readToPixels",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::readToPixels",1,"ofTexture const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofTexture::readToPixels",2,"ofShortPixels &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_readToPixels",1,SWIGTYPE_p_ofTexture); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("Texture_readToPixels",2,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - ((ofTexture const *)arg1)->readToPixels(*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_readToPixels__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - ofFloatPixels *arg2 = 0 ; SWIG_check_num_args("ofTexture::readToPixels",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::readToPixels",1,"ofTexture const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofTexture::readToPixels",2,"ofFloatPixels &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_readToPixels",1,SWIGTYPE_p_ofTexture); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("Texture_readToPixels",2,SWIGTYPE_p_ofPixels_T_float_t); } ((ofTexture const *)arg1)->readToPixels(*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_readToPixels(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Texture_readToPixels__SWIG_0(L);} } } if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Texture_readToPixels__SWIG_1(L);} } } if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Texture_readToPixels__SWIG_2(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Texture_readToPixels'\n" - " Possible C/C++ prototypes are:\n" " ofTexture::readToPixels(ofPixels &) const\n" - " ofTexture::readToPixels(ofShortPixels &) const\n" " ofTexture::readToPixels(ofFloatPixels &) const\n"); - lua_error(L);return 0; } -static int _wrap_Texture_getTextureData__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - ofTextureData *result = 0 ; SWIG_check_num_args("ofTexture::getTextureData",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::getTextureData",1,"ofTexture *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_getTextureData",1,SWIGTYPE_p_ofTexture); } result = (ofTextureData *) &(arg1)->getTextureData(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTextureData,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Texture_getTextureData__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - ofTextureData *result = 0 ; SWIG_check_num_args("ofTexture::getTextureData",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::getTextureData",1,"ofTexture const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_getTextureData",1,SWIGTYPE_p_ofTexture); } - result = (ofTextureData *) &((ofTexture const *)arg1)->getTextureData(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTextureData,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Texture_getTextureData(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Texture_getTextureData__SWIG_0(L);} } if (argc == 1) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Texture_getTextureData__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Texture_getTextureData'\n" - " Possible C/C++ prototypes are:\n" " ofTexture::getTextureData()\n" " ofTexture::getTextureData() const\n"); - lua_error(L);return 0; } -static int _wrap_Texture_enableMipmap(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - SWIG_check_num_args("ofTexture::enableMipmap",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::enableMipmap",1,"ofTexture *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_enableMipmap",1,SWIGTYPE_p_ofTexture); } (arg1)->enableMipmap(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_disableMipmap(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - SWIG_check_num_args("ofTexture::disableMipmap",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::disableMipmap",1,"ofTexture *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_disableMipmap",1,SWIGTYPE_p_ofTexture); } (arg1)->disableMipmap(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_generateMipmap(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; - SWIG_check_num_args("ofTexture::generateMipmap",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::generateMipmap",1,"ofTexture *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_generateMipmap",1,SWIGTYPE_p_ofTexture); } (arg1)->generateMipmap(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Texture_hasMipmap(lua_State* L) { int SWIG_arg = 0; ofTexture *arg1 = (ofTexture *) 0 ; bool result; - SWIG_check_num_args("ofTexture::hasMipmap",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTexture::hasMipmap",1,"ofTexture const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Texture_hasMipmap",1,SWIGTYPE_p_ofTexture); } result = (bool)((ofTexture const *)arg1)->hasMipmap(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_Texture(void *obj) { -ofTexture *arg1 = (ofTexture *) obj; -delete arg1; -} -static int _proxy__wrap_new_Texture(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_Texture); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_Texture_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_Texture_methods[]= { - { "allocate", _wrap_Texture_allocate}, - { "isAllocated", _wrap_Texture_isAllocated}, - { "clear", _wrap_Texture_clear}, - { "setUseExternalTextureID", _wrap_Texture_setUseExternalTextureID}, - { "loadData", _wrap_Texture_loadData}, - { "loadScreenData", _wrap_Texture_loadScreenData}, - { "draw", _wrap_Texture_draw}, - { "drawSubsection", _wrap_Texture_drawSubsection}, - { "getQuad", _wrap_Texture_getQuad}, - { "getMeshForSubsection", _wrap_Texture_getMeshForSubsection}, - { "bind", _wrap_Texture_bind}, - { "unbind", _wrap_Texture_unbind}, - { "getAlphaMask", _wrap_Texture_getAlphaMask}, - { "getHeight", _wrap_Texture_getHeight}, - { "getWidth", _wrap_Texture_getWidth}, - { "setAnchorPercent", _wrap_Texture_setAnchorPercent}, - { "setAnchorPoint", _wrap_Texture_setAnchorPoint}, - { "resetAnchor", _wrap_Texture_resetAnchor}, - { "getCoordFromPoint", _wrap_Texture_getCoordFromPoint}, - { "getCoordFromPercent", _wrap_Texture_getCoordFromPercent}, - { "setAlphaMask", _wrap_Texture_setAlphaMask}, - { "disableAlphaMask", _wrap_Texture_disableAlphaMask}, - { "setTextureWrap", _wrap_Texture_setTextureWrap}, - { "setTextureMinMagFilter", _wrap_Texture_setTextureMinMagFilter}, - { "setTextureMatrix", _wrap_Texture_setTextureMatrix}, - { "getTextureMatrix", _wrap_Texture_getTextureMatrix}, - { "isUsingTextureMatrix", _wrap_Texture_isUsingTextureMatrix}, - { "disableTextureMatrix", _wrap_Texture_disableTextureMatrix}, - { "setCompression", _wrap_Texture_setCompression}, - { "setRGToRGBASwizzles", _wrap_Texture_setRGToRGBASwizzles}, - { "setSwizzle", _wrap_Texture_setSwizzle}, - { "readToPixels", _wrap_Texture_readToPixels}, - { "getTextureData", _wrap_Texture_getTextureData}, - { "enableMipmap", _wrap_Texture_enableMipmap}, - { "disableMipmap", _wrap_Texture_disableMipmap}, - { "generateMipmap", _wrap_Texture_generateMipmap}, - { "hasMipmap", _wrap_Texture_hasMipmap}, - {0,0} -}; -static swig_lua_method swig_Texture_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_Texture_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_Texture_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_Texture_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_Texture_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_Texture_Sf_SwigStatic = { - "Texture", - swig_Texture_Sf_SwigStatic_methods, - swig_Texture_Sf_SwigStatic_attributes, - swig_Texture_Sf_SwigStatic_constants, - swig_Texture_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_Texture_bases[] = {0}; -static const char *swig_Texture_base_names[] = {0}; -static swig_lua_class _wrap_class_Texture = { "Texture", "Texture", &SWIGTYPE_p_ofTexture,_proxy__wrap_new_Texture, swig_delete_Texture, swig_Texture_methods, swig_Texture_attributes, &swig_Texture_Sf_SwigStatic, swig_Texture_meta, swig_Texture_bases, swig_Texture_base_names }; - -static int _wrap_new_Image__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofImage_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofImage_< unsigned char >::ofImage_",0,0) - result = (ofImage_< unsigned char > *)new ofImage_< unsigned char >(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofImage_T_unsigned_char_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_Image__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPixels_< unsigned char > *arg1 = 0 ; - ofImage_< unsigned char > *result = 0 ; SWIG_check_num_args("ofImage_< unsigned char >::ofImage_",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::ofImage_",1,"ofPixels_< unsigned char > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("new_Image",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - result = (ofImage_< unsigned char > *)new ofImage_< unsigned char >((ofPixels_< unsigned char > const &)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofImage_T_unsigned_char_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_Image__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = 0 ; ofImage_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofImage_< unsigned char >::ofImage_",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::ofImage_",1,"ofFile const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("new_Image",1,SWIGTYPE_p_ofFile); } - result = (ofImage_< unsigned char > *)new ofImage_< unsigned char >((ofFile const &)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofImage_T_unsigned_char_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_Image__SWIG_3(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - ofImage_< unsigned char > *result = 0 ; SWIG_check_num_args("ofImage_< unsigned char >::ofImage_",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::ofImage_",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; - result = (ofImage_< unsigned char > *)new ofImage_< unsigned char >((std::string const &)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofImage_T_unsigned_char_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_Image__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofImage_< unsigned char > *arg1 = 0 ; - ofImage_< unsigned char > *result = 0 ; SWIG_check_num_args("ofImage_< unsigned char >::ofImage_",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::ofImage_",1,"ofImage_< unsigned char > &&"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("new_Image",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } - result = (ofImage_< unsigned char > *)new ofImage_< unsigned char >((ofImage_< unsigned char > &&)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofImage_T_unsigned_char_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_Image(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_Image__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_new_Image__SWIG_1(L);} } if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_new_Image__SWIG_2(L);} } if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_new_Image__SWIG_4(L);} } if (argc == 1) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { return _wrap_new_Image__SWIG_3(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_Image'\n" " Possible C/C++ prototypes are:\n" - " ofImage_< unsigned char >::ofImage_()\n" " ofImage_< unsigned char >::ofImage_(ofPixels_< unsigned char > const &)\n" - " ofImage_< unsigned char >::ofImage_(ofFile const &)\n" " ofImage_< unsigned char >::ofImage_(std::string const &)\n" - " ofImage_< unsigned char >::ofImage_(ofImage_< unsigned char > &&)\n"); lua_error(L);return 0; } -static int _wrap_Image_allocate(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; int arg2 ; int arg3 ; ofImageType arg4 ; - SWIG_check_num_args("ofImage_< unsigned char >::allocate",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::allocate",1,"ofImage_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::allocate",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned char >::allocate",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< unsigned char >::allocate",4,"ofImageType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_allocate",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); arg4 = (ofImageType)(int)lua_tonumber(L, 4); (arg1)->allocate(arg2,arg3,arg4); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_isAllocated(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; bool result; - SWIG_check_num_args("ofImage_< unsigned char >::isAllocated",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::isAllocated",1,"ofImage_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_isAllocated",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } - result = (bool)((ofImage_< unsigned char > const *)arg1)->isAllocated(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_clear(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; - SWIG_check_num_args("ofImage_< unsigned char >::clear",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::clear",1,"ofImage_< unsigned char > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_clear",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } (arg1)->clear(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_load__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; std::string *arg2 = 0 ; std::string temp2 ; bool result; - SWIG_check_num_args("ofImage_< unsigned char >::load",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::load",1,"ofImage_< unsigned char > *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::load",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_load",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; result = (bool)(arg1)->load((std::string const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_load__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; ofBuffer *arg2 = 0 ; bool result; - SWIG_check_num_args("ofImage_< unsigned char >::load",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::load",1,"ofImage_< unsigned char > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::load",2,"ofBuffer const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_load",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBuffer,0))){ SWIG_fail_ptr("Image_load",2,SWIGTYPE_p_ofBuffer); } - result = (bool)(arg1)->load((ofBuffer const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_load__SWIG_2(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; ofFile *arg2 = 0 ; bool result; - SWIG_check_num_args("ofImage_< unsigned char >::load",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::load",1,"ofImage_< unsigned char > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::load",2,"ofFile const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_load",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("Image_load",2,SWIGTYPE_p_ofFile); } - result = (bool)(arg1)->load((ofFile const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_load(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBuffer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Image_load__SWIG_1(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Image_load__SWIG_2(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { - return _wrap_Image_load__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Image_load'\n" " Possible C/C++ prototypes are:\n" - " ofImage_< unsigned char >::load(std::string const &)\n" " ofImage_< unsigned char >::load(ofBuffer const &)\n" - " ofImage_< unsigned char >::load(ofFile const &)\n"); lua_error(L);return 0; } -static int _wrap_Image_draw__SWIG_0_0(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; ofPoint *arg2 = 0 ; SWIG_check_num_args("draw",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("draw",1,"ofImage_< unsigned char > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("draw",2,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_draw",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Image_draw",2,SWIGTYPE_p_ofVec3f); } - ((ofImage_< unsigned char > const *)arg1)->draw((ofPoint const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Image_draw__SWIG_0_1(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; ofRectangle *arg2 = 0 ; SWIG_check_num_args("draw",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("draw",1,"ofImage_< unsigned char > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("draw",2,"ofRectangle const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_draw",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Image_draw",2,SWIGTYPE_p_ofRectangle); } - ((ofImage_< unsigned char > const *)arg1)->draw((ofRectangle const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Image_draw__SWIG_0_2(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; ofPoint *arg2 = 0 ; float arg3 ; float arg4 ; - SWIG_check_num_args("draw",4,4) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("draw",1,"ofImage_< unsigned char > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("draw",2,"ofPoint const &"); if(!lua_isnumber(L,3)) SWIG_fail_arg("draw",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("draw",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_draw",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Image_draw",2,SWIGTYPE_p_ofVec3f); } - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - ((ofImage_< unsigned char > const *)arg1)->draw((ofPoint const &)*arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Image_draw__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofImage_< unsigned char >::draw",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::draw",1,"ofImage_< unsigned char > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::draw",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned char >::draw",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_draw",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); ((ofImage_< unsigned char > const *)arg1)->draw(arg2,arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_draw__SWIG_2(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; float arg2 ; float arg3 ; float arg4 ; - SWIG_check_num_args("ofImage_< unsigned char >::draw",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::draw",1,"ofImage_< unsigned char > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::draw",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned char >::draw",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< unsigned char >::draw",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_draw",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - ((ofImage_< unsigned char > const *)arg1)->draw(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Image_draw__SWIG_3(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; float arg2 ; float arg3 ; float arg4 ; float arg5 ; - SWIG_check_num_args("ofImage_< unsigned char >::draw",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::draw",1,"ofImage_< unsigned char > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::draw",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned char >::draw",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< unsigned char >::draw",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< unsigned char >::draw",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_draw",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - ((ofImage_< unsigned char > const *)arg1)->draw(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Image_draw__SWIG_4(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; float arg2 ; float arg3 ; float arg4 ; float arg5 ; - float arg6 ; SWIG_check_num_args("ofImage_< unsigned char >::draw",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::draw",1,"ofImage_< unsigned char > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::draw",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned char >::draw",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< unsigned char >::draw",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< unsigned char >::draw",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofImage_< unsigned char >::draw",6,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_draw",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); ((ofImage_< unsigned char > const *)arg1)->draw(arg2,arg3,arg4,arg5,arg6); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_draw(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Image_draw__SWIG_0_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Image_draw__SWIG_0_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_Image_draw__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Image_draw__SWIG_0_2(L);} } } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Image_draw__SWIG_2(L);} } } } } - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Image_draw__SWIG_3(L);} } } } } } if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { return _wrap_Image_draw__SWIG_4(L);} } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Image_draw'\n" " Possible C/C++ prototypes are:\n" - " draw(ofPoint const &) const\n" " draw(ofRectangle const &) const\n" " draw(ofPoint const &,float,float) const\n" - " ofImage_< unsigned char >::draw(float,float) const\n" " ofImage_< unsigned char >::draw(float,float,float) const\n" - " ofImage_< unsigned char >::draw(float,float,float,float) const\n" - " ofImage_< unsigned char >::draw(float,float,float,float,float) const\n"); lua_error(L);return 0; } -static int _wrap_Image_drawSubsection__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; float arg2 ; float arg3 ; float arg4 ; float arg5 ; - float arg6 ; float arg7 ; SWIG_check_num_args("ofImage_< unsigned char >::drawSubsection",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",1,"ofImage_< unsigned char > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",7,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_drawSubsection",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); - ((ofImage_< unsigned char > const *)arg1)->drawSubsection(arg2,arg3,arg4,arg5,arg6,arg7); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_drawSubsection__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; float arg2 ; float arg3 ; float arg4 ; float arg5 ; - float arg6 ; float arg7 ; float arg8 ; SWIG_check_num_args("ofImage_< unsigned char >::drawSubsection",8,8) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",1,"ofImage_< unsigned char > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",8,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_drawSubsection",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (float)lua_tonumber(L, 8); - ((ofImage_< unsigned char > const *)arg1)->drawSubsection(arg2,arg3,arg4,arg5,arg6,arg7,arg8); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_drawSubsection__SWIG_2(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; float arg2 ; float arg3 ; float arg4 ; float arg5 ; - float arg6 ; float arg7 ; float arg8 ; float arg9 ; SWIG_check_num_args("ofImage_< unsigned char >::drawSubsection",9,9) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",1,"ofImage_< unsigned char > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",8,"float"); - if(!lua_isnumber(L,9)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",9,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_drawSubsection",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (float)lua_tonumber(L, 8); - arg9 = (float)lua_tonumber(L, 9); - ((ofImage_< unsigned char > const *)arg1)->drawSubsection(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_drawSubsection__SWIG_3(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; float arg2 ; float arg3 ; float arg4 ; float arg5 ; - float arg6 ; float arg7 ; float arg8 ; float arg9 ; float arg10 ; - SWIG_check_num_args("ofImage_< unsigned char >::drawSubsection",10,10) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",1,"ofImage_< unsigned char > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",8,"float"); - if(!lua_isnumber(L,9)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",9,"float"); - if(!lua_isnumber(L,10)) SWIG_fail_arg("ofImage_< unsigned char >::drawSubsection",10,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_drawSubsection",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (float)lua_tonumber(L, 8); - arg9 = (float)lua_tonumber(L, 9); arg10 = (float)lua_tonumber(L, 10); - ((ofImage_< unsigned char > const *)arg1)->drawSubsection(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_drawSubsection(lua_State* L) { int argc; int argv[11]={ 1,2,3,4,5,6,7,8,9,10,11} ; argc = lua_gettop(L); - if (argc == 7) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { - return _wrap_Image_drawSubsection__SWIG_0(L);} } } } } } } } if (argc == 8) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { return _wrap_Image_drawSubsection__SWIG_1(L);} } } } } } } - } } if (argc == 9) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { { _v = lua_isnumber(L,argv[8]); } if (_v) { - return _wrap_Image_drawSubsection__SWIG_2(L);} } } } } } } } } } if (argc == 10) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { { _v = lua_isnumber(L,argv[8]); } if (_v) { { - _v = lua_isnumber(L,argv[9]); } if (_v) { return _wrap_Image_drawSubsection__SWIG_3(L);} } } } } } - } } } } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Image_drawSubsection'\n" - " Possible C/C++ prototypes are:\n" - " ofImage_< unsigned char >::drawSubsection(float,float,float,float,float,float) const\n" - " ofImage_< unsigned char >::drawSubsection(float,float,float,float,float,float,float) const\n" - " ofImage_< unsigned char >::drawSubsection(float,float,float,float,float,float,float,float) const\n" - " ofImage_< unsigned char >::drawSubsection(float,float,float,float,float,float,float,float,float) const\n"); - lua_error(L);return 0; } -static int _wrap_Image_update(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; - SWIG_check_num_args("ofImage_< unsigned char >::update",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::update",1,"ofImage_< unsigned char > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_update",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } (arg1)->update(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_setUseTexture(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; bool arg2 ; - SWIG_check_num_args("ofImage_< unsigned char >::setUseTexture",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::setUseTexture",1,"ofImage_< unsigned char > *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::setUseTexture",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_setUseTexture",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } arg2 = (lua_toboolean(L, 2)!=0); - (arg1)->setUseTexture(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_isUsingTexture(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; bool result; - SWIG_check_num_args("ofImage_< unsigned char >::isUsingTexture",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::isUsingTexture",1,"ofImage_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_isUsingTexture",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } - result = (bool)((ofImage_< unsigned char > const *)arg1)->isUsingTexture(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_getTexture__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; ofTexture *result = 0 ; - SWIG_check_num_args("ofImage_< unsigned char >::getTexture",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::getTexture",1,"ofImage_< unsigned char > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_getTexture",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } result = (ofTexture *) &(arg1)->getTexture(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTexture,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Image_getTexture__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; ofTexture *result = 0 ; - SWIG_check_num_args("ofImage_< unsigned char >::getTexture",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::getTexture",1,"ofImage_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_getTexture",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } - result = (ofTexture *) &((ofImage_< unsigned char > const *)arg1)->getTexture(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTexture,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Image_getTexture(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v; - { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Image_getTexture__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Image_getTexture__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Image_getTexture'\n" " Possible C/C++ prototypes are:\n" - " ofImage_< unsigned char >::getTexture()\n" " ofImage_< unsigned char >::getTexture() const\n"); - lua_error(L);return 0; } -static int _wrap_Image_bind__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; int arg2 ; - SWIG_check_num_args("ofImage_< unsigned char >::bind",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::bind",1,"ofImage_< unsigned char > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::bind",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_bind",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } arg2 = (int)lua_tonumber(L, 2); - ((ofImage_< unsigned char > const *)arg1)->bind(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_bind__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; SWIG_check_num_args("ofImage_< unsigned char >::bind",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::bind",1,"ofImage_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_bind",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } ((ofImage_< unsigned char > const *)arg1)->bind(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_bind(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Image_bind__SWIG_1(L);} } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Image_bind__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Image_bind'\n" " Possible C/C++ prototypes are:\n" - " ofImage_< unsigned char >::bind(int) const\n" " ofImage_< unsigned char >::bind() const\n"); lua_error(L);return 0; } -static int _wrap_Image_unbind__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; int arg2 ; - SWIG_check_num_args("ofImage_< unsigned char >::unbind",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::unbind",1,"ofImage_< unsigned char > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::unbind",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_unbind",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } arg2 = (int)lua_tonumber(L, 2); - ((ofImage_< unsigned char > const *)arg1)->unbind(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Image_unbind__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; - SWIG_check_num_args("ofImage_< unsigned char >::unbind",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::unbind",1,"ofImage_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_unbind",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } - ((ofImage_< unsigned char > const *)arg1)->unbind(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_unbind(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Image_unbind__SWIG_1(L);} } if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Image_unbind__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Image_unbind'\n" " Possible C/C++ prototypes are:\n" - " ofImage_< unsigned char >::unbind(int) const\n" " ofImage_< unsigned char >::unbind() const\n"); - lua_error(L);return 0; } -static int _wrap_Image_setCompression(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; ofTexCompression arg2 ; - SWIG_check_num_args("ofImage_< unsigned char >::setCompression",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::setCompression",1,"ofImage_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::setCompression",2,"ofTexCompression"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_setCompression",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } - arg2 = (ofTexCompression)(int)lua_tonumber(L, 2); (arg1)->setCompression(arg2); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Image_getColor__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; int arg2 ; int arg3 ; ofColor_< unsigned char > result; - SWIG_check_num_args("ofImage_< unsigned char >::getColor",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::getColor",1,"ofImage_< unsigned char > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::getColor",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned char >::getColor",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_getColor",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); result = ((ofImage_< unsigned char > const *)arg1)->getColor(arg2,arg3); { - ofColor_< unsigned char > * resultptr = new ofColor_< unsigned char >((const ofColor_< unsigned char > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_getColor__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; int arg2 ; ofColor_< unsigned char > result; - SWIG_check_num_args("ofImage_< unsigned char >::getColor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::getColor",1,"ofImage_< unsigned char > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::getColor",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_getColor",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } arg2 = (int)lua_tonumber(L, 2); - result = ((ofImage_< unsigned char > const *)arg1)->getColor(arg2); { - ofColor_< unsigned char > * resultptr = new ofColor_< unsigned char >((const ofColor_< unsigned char > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_getColor(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Image_getColor__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_Image_getColor__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Image_getColor'\n" " Possible C/C++ prototypes are:\n" - " ofImage_< unsigned char >::getColor(int,int) const\n" " ofImage_< unsigned char >::getColor(int) const\n"); - lua_error(L);return 0; } -static int _wrap_Image_getHeight(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; float result; - SWIG_check_num_args("ofImage_< unsigned char >::getHeight",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::getHeight",1,"ofImage_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_getHeight",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } - result = (float)((ofImage_< unsigned char > const *)arg1)->getHeight(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_getWidth(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; float result; - SWIG_check_num_args("ofImage_< unsigned char >::getWidth",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::getWidth",1,"ofImage_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_getWidth",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } - result = (float)((ofImage_< unsigned char > const *)arg1)->getWidth(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_setColor__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; int arg2 ; int arg3 ; - ofColor_< unsigned char > *arg4 = 0 ; SWIG_check_num_args("ofImage_< unsigned char >::setColor",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::setColor",1,"ofImage_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::setColor",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned char >::setColor",3,"int"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofImage_< unsigned char >::setColor",4,"ofColor_< unsigned char > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_setColor",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_setColor",4,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - (arg1)->setColor(arg2,arg3,(ofColor_< unsigned char > const &)*arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Image_setColor__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; int arg2 ; ofColor_< unsigned char > *arg3 = 0 ; - SWIG_check_num_args("ofImage_< unsigned char >::setColor",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::setColor",1,"ofImage_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::setColor",2,"int"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofImage_< unsigned char >::setColor",3,"ofColor_< unsigned char > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_setColor",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } arg2 = (int)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_setColor",3,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - (arg1)->setColor(arg2,(ofColor_< unsigned char > const &)*arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Image_setColor__SWIG_2(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; ofColor_< unsigned char > *arg2 = 0 ; - SWIG_check_num_args("ofImage_< unsigned char >::setColor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::setColor",1,"ofImage_< unsigned char > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::setColor",2,"ofColor_< unsigned char > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_setColor",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_setColor",2,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - (arg1)->setColor((ofColor_< unsigned char > const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Image_setColor(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Image_setColor__SWIG_2(L);} } } if (argc == 3) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Image_setColor__SWIG_1(L);} } } } if (argc == 4) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Image_setColor__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Image_setColor'\n" " Possible C/C++ prototypes are:\n" - " ofImage_< unsigned char >::setColor(int,int,ofColor_< unsigned char > const &)\n" - " ofImage_< unsigned char >::setColor(int,ofColor_< unsigned char > const &)\n" - " ofImage_< unsigned char >::setColor(ofColor_< unsigned char > const &)\n"); lua_error(L);return 0; } -static int _wrap_Image_setFromPixels__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; unsigned char *arg2 = (unsigned char *) 0 ; int arg3 ; - int arg4 ; ofImageType arg5 ; bool arg6 ; SWIG_check_num_args("ofImage_< unsigned char >::setFromPixels",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::setFromPixels",1,"ofImage_< unsigned char > *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::setFromPixels",2,"unsigned char const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned char >::setFromPixels",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< unsigned char >::setFromPixels",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< unsigned char >::setFromPixels",5,"ofImageType"); - if(!lua_isboolean(L,6)) SWIG_fail_arg("ofImage_< unsigned char >::setFromPixels",6,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_setFromPixels",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_unsigned_char,0))){ - SWIG_fail_ptr("Image_setFromPixels",2,SWIGTYPE_p_unsigned_char); } arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); arg5 = (ofImageType)(int)lua_tonumber(L, 5); arg6 = (lua_toboolean(L, 6)!=0); - (arg1)->setFromPixels((unsigned char const *)arg2,arg3,arg4,arg5,arg6); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Image_setFromPixels__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; unsigned char *arg2 = (unsigned char *) 0 ; int arg3 ; - int arg4 ; ofImageType arg5 ; SWIG_check_num_args("ofImage_< unsigned char >::setFromPixels",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::setFromPixels",1,"ofImage_< unsigned char > *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::setFromPixels",2,"unsigned char const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned char >::setFromPixels",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< unsigned char >::setFromPixels",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< unsigned char >::setFromPixels",5,"ofImageType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_setFromPixels",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_unsigned_char,0))){ - SWIG_fail_ptr("Image_setFromPixels",2,SWIGTYPE_p_unsigned_char); } arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); arg5 = (ofImageType)(int)lua_tonumber(L, 5); - (arg1)->setFromPixels((unsigned char const *)arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Image_setFromPixels__SWIG_2(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; ofPixels_< unsigned char > *arg2 = 0 ; - SWIG_check_num_args("ofImage_< unsigned char >::setFromPixels",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::setFromPixels",1,"ofImage_< unsigned char > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::setFromPixels",2,"ofPixels_< unsigned char > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_setFromPixels",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_setFromPixels",2,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - (arg1)->setFromPixels((ofPixels_< unsigned char > const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Image_setFromPixels(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Image_setFromPixels__SWIG_2(L);} } } if (argc == 5) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_unsigned_char, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_Image_setFromPixels__SWIG_1(L);} } } } } } - if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_unsigned_char, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isboolean(L,argv[5]); } if (_v) { - return _wrap_Image_setFromPixels__SWIG_0(L);} } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Image_setFromPixels'\n" - " Possible C/C++ prototypes are:\n" - " ofImage_< unsigned char >::setFromPixels(unsigned char const *,int,int,ofImageType,bool)\n" - " ofImage_< unsigned char >::setFromPixels(unsigned char const *,int,int,ofImageType)\n" - " ofImage_< unsigned char >::setFromPixels(ofPixels_< unsigned char > const &)\n"); lua_error(L);return 0; } -static int _wrap_Image_grabScreen(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; int arg2 ; int arg3 ; int arg4 ; int arg5 ; - SWIG_check_num_args("ofImage_< unsigned char >::grabScreen",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::grabScreen",1,"ofImage_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::grabScreen",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned char >::grabScreen",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< unsigned char >::grabScreen",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< unsigned char >::grabScreen",5,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_grabScreen",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); - (arg1)->grabScreen(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_setImageType(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; ofImageType arg2 ; - SWIG_check_num_args("ofImage_< unsigned char >::setImageType",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::setImageType",1,"ofImage_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::setImageType",2,"ofImageType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_setImageType",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } arg2 = (ofImageType)(int)lua_tonumber(L, 2); - (arg1)->setImageType(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_getImageType(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; ofImageType result; - SWIG_check_num_args("ofImage_< unsigned char >::getImageType",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::getImageType",1,"ofImage_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_getImageType",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } - result = (ofImageType)((ofImage_< unsigned char > const *)arg1)->getImageType(); - lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Image_resize(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; int arg2 ; int arg3 ; - SWIG_check_num_args("ofImage_< unsigned char >::resize",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::resize",1,"ofImage_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::resize",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned char >::resize",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_resize",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); (arg1)->resize(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Image_crop(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; int arg2 ; int arg3 ; int arg4 ; int arg5 ; - SWIG_check_num_args("ofImage_< unsigned char >::crop",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::crop",1,"ofImage_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::crop",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned char >::crop",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< unsigned char >::crop",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< unsigned char >::crop",5,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_crop",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); - (arg1)->crop(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_cropFrom(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; ofImage_< unsigned char > *arg2 = 0 ; int arg3 ; - int arg4 ; int arg5 ; int arg6 ; SWIG_check_num_args("ofImage_< unsigned char >::cropFrom",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::cropFrom",1,"ofImage_< unsigned char > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::cropFrom",2,"ofImage_< unsigned char > &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned char >::cropFrom",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< unsigned char >::cropFrom",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< unsigned char >::cropFrom",5,"int"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofImage_< unsigned char >::cropFrom",6,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_cropFrom",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_cropFrom",2,SWIGTYPE_p_ofImage_T_unsigned_char_t); } arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); arg6 = (int)lua_tonumber(L, 6); - (arg1)->cropFrom(*arg2,arg3,arg4,arg5,arg6); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_rotate90(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; int arg2 ; - SWIG_check_num_args("ofImage_< unsigned char >::rotate90",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::rotate90",1,"ofImage_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::rotate90",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_rotate90",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->rotate90(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_mirror(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; bool arg2 ; bool arg3 ; - SWIG_check_num_args("ofImage_< unsigned char >::mirror",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::mirror",1,"ofImage_< unsigned char > *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::mirror",2,"bool"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofImage_< unsigned char >::mirror",3,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_mirror",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } arg2 = (lua_toboolean(L, 2)!=0); - arg3 = (lua_toboolean(L, 3)!=0); (arg1)->mirror(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Image_setAnchorPercent(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofImage_< unsigned char >::setAnchorPercent",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::setAnchorPercent",1,"ofImage_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::setAnchorPercent",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned char >::setAnchorPercent",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_setAnchorPercent",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->setAnchorPercent(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Image_setAnchorPoint(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofImage_< unsigned char >::setAnchorPoint",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::setAnchorPoint",1,"ofImage_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::setAnchorPoint",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned char >::setAnchorPoint",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_setAnchorPoint",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->setAnchorPoint(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Image_resetAnchor(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; - SWIG_check_num_args("ofImage_< unsigned char >::resetAnchor",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::resetAnchor",1,"ofImage_< unsigned char > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_resetAnchor",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } (arg1)->resetAnchor(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_save__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; std::string arg2 ; ofImageQualityType arg3 ; - SWIG_check_num_args("ofImage_< unsigned char >::save",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::save",1,"ofImage_< unsigned char > *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::save",2,"std::string"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned char >::save",3,"ofImageQualityType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_save",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } (&arg2)->assign(lua_tostring(L,2),lua_rawlen(L,2)); - arg3 = (ofImageQualityType)(int)lua_tonumber(L, 3); (arg1)->save(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Image_save__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; std::string arg2 ; - SWIG_check_num_args("ofImage_< unsigned char >::save",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::save",1,"ofImage_< unsigned char > *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::save",2,"std::string"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_save",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } (&arg2)->assign(lua_tostring(L,2),lua_rawlen(L,2)); - (arg1)->save(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_save__SWIG_2(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; ofBuffer *arg2 = 0 ; ofImageQualityType arg3 ; - SWIG_check_num_args("ofImage_< unsigned char >::save",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::save",1,"ofImage_< unsigned char > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::save",2,"ofBuffer &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned char >::save",3,"ofImageQualityType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_save",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBuffer,0))){ SWIG_fail_ptr("Image_save",2,SWIGTYPE_p_ofBuffer); } - arg3 = (ofImageQualityType)(int)lua_tonumber(L, 3); (arg1)->save(*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Image_save__SWIG_3(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; ofBuffer *arg2 = 0 ; - SWIG_check_num_args("ofImage_< unsigned char >::save",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::save",1,"ofImage_< unsigned char > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::save",2,"ofBuffer &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_save",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBuffer,0))){ SWIG_fail_ptr("Image_save",2,SWIGTYPE_p_ofBuffer); } - (arg1)->save(*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_save__SWIG_4(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; ofFile *arg2 = 0 ; ofImageQualityType arg3 ; - SWIG_check_num_args("ofImage_< unsigned char >::save",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::save",1,"ofImage_< unsigned char > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::save",2,"ofFile const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned char >::save",3,"ofImageQualityType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_save",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("Image_save",2,SWIGTYPE_p_ofFile); } - arg3 = (ofImageQualityType)(int)lua_tonumber(L, 3); (arg1)->save((ofFile const &)*arg2,arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_save__SWIG_5(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) 0 ; ofFile *arg2 = 0 ; - SWIG_check_num_args("ofImage_< unsigned char >::save",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned char >::save",1,"ofImage_< unsigned char > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofImage_< unsigned char >::save",2,"ofFile const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Image_save",1,SWIGTYPE_p_ofImage_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("Image_save",2,SWIGTYPE_p_ofFile); } - (arg1)->save((ofFile const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Image_save(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBuffer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Image_save__SWIG_3(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Image_save__SWIG_5(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { - return _wrap_Image_save__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Image_save__SWIG_4(L);} } } - } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBuffer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Image_save__SWIG_2(L);} } } - } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_Image_save__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Image_save'\n" " Possible C/C++ prototypes are:\n" - " ofImage_< unsigned char >::save(std::string,ofImageQualityType)\n" " ofImage_< unsigned char >::save(std::string)\n" - " ofImage_< unsigned char >::save(ofBuffer &,ofImageQualityType)\n" " ofImage_< unsigned char >::save(ofBuffer &)\n" - " ofImage_< unsigned char >::save(ofFile const &,ofImageQualityType)\n" - " ofImage_< unsigned char >::save(ofFile const &)\n"); lua_error(L);return 0; } -static void swig_delete_Image(void *obj) { -ofImage_< unsigned char > *arg1 = (ofImage_< unsigned char > *) obj; -delete arg1; -} -static int _proxy__wrap_new_Image(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_Image); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_Image_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_Image_methods[]= { - { "allocate", _wrap_Image_allocate}, - { "isAllocated", _wrap_Image_isAllocated}, - { "clear", _wrap_Image_clear}, - { "load", _wrap_Image_load}, - { "draw", _wrap_Image_draw}, - { "drawSubsection", _wrap_Image_drawSubsection}, - { "update", _wrap_Image_update}, - { "setUseTexture", _wrap_Image_setUseTexture}, - { "isUsingTexture", _wrap_Image_isUsingTexture}, - { "getTexture", _wrap_Image_getTexture}, - { "bind", _wrap_Image_bind}, - { "unbind", _wrap_Image_unbind}, - { "setCompression", _wrap_Image_setCompression}, - { "getColor", _wrap_Image_getColor}, - { "getHeight", _wrap_Image_getHeight}, - { "getWidth", _wrap_Image_getWidth}, - { "setColor", _wrap_Image_setColor}, - { "setFromPixels", _wrap_Image_setFromPixels}, - { "grabScreen", _wrap_Image_grabScreen}, - { "setImageType", _wrap_Image_setImageType}, - { "getImageType", _wrap_Image_getImageType}, - { "resize", _wrap_Image_resize}, - { "crop", _wrap_Image_crop}, - { "cropFrom", _wrap_Image_cropFrom}, - { "rotate90", _wrap_Image_rotate90}, - { "mirror", _wrap_Image_mirror}, - { "setAnchorPercent", _wrap_Image_setAnchorPercent}, - { "setAnchorPoint", _wrap_Image_setAnchorPoint}, - { "resetAnchor", _wrap_Image_resetAnchor}, - { "save", _wrap_Image_save}, - {0,0} -}; -static swig_lua_method swig_Image_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_Image_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_Image_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_Image_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_Image_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_Image_Sf_SwigStatic = { - "Image", - swig_Image_Sf_SwigStatic_methods, - swig_Image_Sf_SwigStatic_attributes, - swig_Image_Sf_SwigStatic_constants, - swig_Image_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_Image_bases[] = {0}; -static const char *swig_Image_base_names[] = {0}; -static swig_lua_class _wrap_class_Image = { "Image", "Image", &SWIGTYPE_p_ofImage_T_unsigned_char_t,_proxy__wrap_new_Image, swig_delete_Image, swig_Image_methods, swig_Image_attributes, &swig_Image_Sf_SwigStatic, swig_Image_meta, swig_Image_bases, swig_Image_base_names }; - -static int _wrap_new_FloatImage__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *result = 0 ; - SWIG_check_num_args("ofImage_< float >::ofImage_",0,0) result = (ofImage_< float > *)new ofImage_< float >(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofImage_T_float_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_FloatImage__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPixels_< float > *arg1 = 0 ; - ofImage_< float > *result = 0 ; SWIG_check_num_args("ofImage_< float >::ofImage_",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofImage_< float >::ofImage_",1,"ofPixels_< float > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("new_FloatImage",1,SWIGTYPE_p_ofPixels_T_float_t); } - result = (ofImage_< float > *)new ofImage_< float >((ofPixels_< float > const &)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofImage_T_float_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_FloatImage__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = 0 ; ofImage_< float > *result = 0 ; - SWIG_check_num_args("ofImage_< float >::ofImage_",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofImage_< float >::ofImage_",1,"ofFile const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("new_FloatImage",1,SWIGTYPE_p_ofFile); } - result = (ofImage_< float > *)new ofImage_< float >((ofFile const &)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofImage_T_float_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_FloatImage__SWIG_3(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - ofImage_< float > *result = 0 ; SWIG_check_num_args("ofImage_< float >::ofImage_",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofImage_< float >::ofImage_",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; - result = (ofImage_< float > *)new ofImage_< float >((std::string const &)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofImage_T_float_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_FloatImage__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = 0 ; - ofImage_< float > *result = 0 ; SWIG_check_num_args("ofImage_< float >::ofImage_",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofImage_< float >::ofImage_",1,"ofImage_< float > &&"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("new_FloatImage",1,SWIGTYPE_p_ofImage_T_float_t); } - result = (ofImage_< float > *)new ofImage_< float >((ofImage_< float > &&)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofImage_T_float_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_FloatImage(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_FloatImage__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_new_FloatImage__SWIG_1(L);} } if (argc == 1) { int _v; { - void *ptr; if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_new_FloatImage__SWIG_2(L);} } if (argc == 1) { int _v; { - void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_new_FloatImage__SWIG_4(L);} } if (argc == 1) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { return _wrap_new_FloatImage__SWIG_3(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_FloatImage'\n" " Possible C/C++ prototypes are:\n" - " ofImage_< float >::ofImage_()\n" " ofImage_< float >::ofImage_(ofPixels_< float > const &)\n" - " ofImage_< float >::ofImage_(ofFile const &)\n" " ofImage_< float >::ofImage_(std::string const &)\n" - " ofImage_< float >::ofImage_(ofImage_< float > &&)\n"); lua_error(L);return 0; } -static int _wrap_FloatImage_allocate(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - int arg2 ; int arg3 ; ofImageType arg4 ; SWIG_check_num_args("ofImage_< float >::allocate",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::allocate",1,"ofImage_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< float >::allocate",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< float >::allocate",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< float >::allocate",4,"ofImageType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_allocate",1,SWIGTYPE_p_ofImage_T_float_t); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); arg4 = (ofImageType)(int)lua_tonumber(L, 4); (arg1)->allocate(arg2,arg3,arg4); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_isAllocated(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - bool result; SWIG_check_num_args("ofImage_< float >::isAllocated",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::isAllocated",1,"ofImage_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_isAllocated",1,SWIGTYPE_p_ofImage_T_float_t); } - result = (bool)((ofImage_< float > const *)arg1)->isAllocated(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_clear(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - SWIG_check_num_args("ofImage_< float >::clear",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::clear",1,"ofImage_< float > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_clear",1,SWIGTYPE_p_ofImage_T_float_t); } (arg1)->clear(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_load__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - std::string *arg2 = 0 ; std::string temp2 ; bool result; SWIG_check_num_args("ofImage_< float >::load",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::load",1,"ofImage_< float > *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofImage_< float >::load",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_load",1,SWIGTYPE_p_ofImage_T_float_t); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; result = (bool)(arg1)->load((std::string const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_load__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - ofBuffer *arg2 = 0 ; bool result; SWIG_check_num_args("ofImage_< float >::load",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::load",1,"ofImage_< float > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofImage_< float >::load",2,"ofBuffer const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_load",1,SWIGTYPE_p_ofImage_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBuffer,0))){ - SWIG_fail_ptr("FloatImage_load",2,SWIGTYPE_p_ofBuffer); } result = (bool)(arg1)->load((ofBuffer const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_load__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - ofFile *arg2 = 0 ; bool result; SWIG_check_num_args("ofImage_< float >::load",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::load",1,"ofImage_< float > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofImage_< float >::load",2,"ofFile const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_load",1,SWIGTYPE_p_ofImage_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofFile,0))){ - SWIG_fail_ptr("FloatImage_load",2,SWIGTYPE_p_ofFile); } result = (bool)(arg1)->load((ofFile const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_load(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v; - { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBuffer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_FloatImage_load__SWIG_1(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_FloatImage_load__SWIG_2(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { - return _wrap_FloatImage_load__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatImage_load'\n" " Possible C/C++ prototypes are:\n" - " ofImage_< float >::load(std::string const &)\n" " ofImage_< float >::load(ofBuffer const &)\n" - " ofImage_< float >::load(ofFile const &)\n"); lua_error(L);return 0; } -static int _wrap_FloatImage_draw__SWIG_0_0(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - ofPoint *arg2 = 0 ; SWIG_check_num_args("draw",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("draw",1,"ofImage_< float > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("draw",2,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_draw",1,SWIGTYPE_p_ofImage_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("FloatImage_draw",2,SWIGTYPE_p_ofVec3f); } ((ofImage_< float > const *)arg1)->draw((ofPoint const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_draw__SWIG_0_1(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - ofRectangle *arg2 = 0 ; SWIG_check_num_args("draw",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("draw",1,"ofImage_< float > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("draw",2,"ofRectangle const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_draw",1,SWIGTYPE_p_ofImage_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("FloatImage_draw",2,SWIGTYPE_p_ofRectangle); } - ((ofImage_< float > const *)arg1)->draw((ofRectangle const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FloatImage_draw__SWIG_0_2(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - ofPoint *arg2 = 0 ; float arg3 ; float arg4 ; SWIG_check_num_args("draw",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("draw",1,"ofImage_< float > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("draw",2,"ofPoint const &"); if(!lua_isnumber(L,3)) SWIG_fail_arg("draw",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("draw",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_draw",1,SWIGTYPE_p_ofImage_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("FloatImage_draw",2,SWIGTYPE_p_ofVec3f); } arg3 = (float)lua_tonumber(L, 3); - arg4 = (float)lua_tonumber(L, 4); ((ofImage_< float > const *)arg1)->draw((ofPoint const &)*arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_draw__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - float arg2 ; float arg3 ; SWIG_check_num_args("ofImage_< float >::draw",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::draw",1,"ofImage_< float > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< float >::draw",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< float >::draw",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_draw",1,SWIGTYPE_p_ofImage_T_float_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); ((ofImage_< float > const *)arg1)->draw(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_draw__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - float arg2 ; float arg3 ; float arg4 ; SWIG_check_num_args("ofImage_< float >::draw",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::draw",1,"ofImage_< float > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< float >::draw",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< float >::draw",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< float >::draw",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_draw",1,SWIGTYPE_p_ofImage_T_float_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); ((ofImage_< float > const *)arg1)->draw(arg2,arg3,arg4); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_draw__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - float arg2 ; float arg3 ; float arg4 ; float arg5 ; SWIG_check_num_args("ofImage_< float >::draw",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::draw",1,"ofImage_< float > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< float >::draw",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< float >::draw",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< float >::draw",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< float >::draw",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_draw",1,SWIGTYPE_p_ofImage_T_float_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - ((ofImage_< float > const *)arg1)->draw(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FloatImage_draw__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - float arg2 ; float arg3 ; float arg4 ; float arg5 ; float arg6 ; SWIG_check_num_args("ofImage_< float >::draw",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::draw",1,"ofImage_< float > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< float >::draw",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< float >::draw",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< float >::draw",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< float >::draw",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofImage_< float >::draw",6,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_draw",1,SWIGTYPE_p_ofImage_T_float_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); ((ofImage_< float > const *)arg1)->draw(arg2,arg3,arg4,arg5,arg6); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_draw(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_FloatImage_draw__SWIG_0_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_FloatImage_draw__SWIG_0_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_FloatImage_draw__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_FloatImage_draw__SWIG_0_2(L);} } } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_FloatImage_draw__SWIG_2(L);} } } } } - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_FloatImage_draw__SWIG_3(L);} } } } } } if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { return _wrap_FloatImage_draw__SWIG_4(L);} } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatImage_draw'\n" " Possible C/C++ prototypes are:\n" - " draw(ofPoint const &) const\n" " draw(ofRectangle const &) const\n" " draw(ofPoint const &,float,float) const\n" - " ofImage_< float >::draw(float,float) const\n" " ofImage_< float >::draw(float,float,float) const\n" - " ofImage_< float >::draw(float,float,float,float) const\n" - " ofImage_< float >::draw(float,float,float,float,float) const\n"); lua_error(L);return 0; } -static int _wrap_FloatImage_drawSubsection__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; float arg2 ; float arg3 ; float arg4 ; float arg5 ; float arg6 ; - float arg7 ; SWIG_check_num_args("ofImage_< float >::drawSubsection",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::drawSubsection",1,"ofImage_< float > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< float >::drawSubsection",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< float >::drawSubsection",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< float >::drawSubsection",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< float >::drawSubsection",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofImage_< float >::drawSubsection",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofImage_< float >::drawSubsection",7,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_drawSubsection",1,SWIGTYPE_p_ofImage_T_float_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); - ((ofImage_< float > const *)arg1)->drawSubsection(arg2,arg3,arg4,arg5,arg6,arg7); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_drawSubsection__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; float arg2 ; float arg3 ; float arg4 ; float arg5 ; float arg6 ; - float arg7 ; float arg8 ; SWIG_check_num_args("ofImage_< float >::drawSubsection",8,8) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::drawSubsection",1,"ofImage_< float > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< float >::drawSubsection",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< float >::drawSubsection",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< float >::drawSubsection",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< float >::drawSubsection",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofImage_< float >::drawSubsection",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofImage_< float >::drawSubsection",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofImage_< float >::drawSubsection",8,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_drawSubsection",1,SWIGTYPE_p_ofImage_T_float_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (float)lua_tonumber(L, 8); - ((ofImage_< float > const *)arg1)->drawSubsection(arg2,arg3,arg4,arg5,arg6,arg7,arg8); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_drawSubsection__SWIG_2(lua_State* L) { int SWIG_arg = 0; - ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; float arg2 ; float arg3 ; float arg4 ; float arg5 ; float arg6 ; - float arg7 ; float arg8 ; float arg9 ; SWIG_check_num_args("ofImage_< float >::drawSubsection",9,9) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::drawSubsection",1,"ofImage_< float > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< float >::drawSubsection",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< float >::drawSubsection",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< float >::drawSubsection",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< float >::drawSubsection",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofImage_< float >::drawSubsection",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofImage_< float >::drawSubsection",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofImage_< float >::drawSubsection",8,"float"); - if(!lua_isnumber(L,9)) SWIG_fail_arg("ofImage_< float >::drawSubsection",9,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_drawSubsection",1,SWIGTYPE_p_ofImage_T_float_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (float)lua_tonumber(L, 8); - arg9 = (float)lua_tonumber(L, 9); ((ofImage_< float > const *)arg1)->drawSubsection(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_drawSubsection__SWIG_3(lua_State* L) { int SWIG_arg = 0; - ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; float arg2 ; float arg3 ; float arg4 ; float arg5 ; float arg6 ; - float arg7 ; float arg8 ; float arg9 ; float arg10 ; SWIG_check_num_args("ofImage_< float >::drawSubsection",10,10) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::drawSubsection",1,"ofImage_< float > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< float >::drawSubsection",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< float >::drawSubsection",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< float >::drawSubsection",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< float >::drawSubsection",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofImage_< float >::drawSubsection",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofImage_< float >::drawSubsection",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofImage_< float >::drawSubsection",8,"float"); - if(!lua_isnumber(L,9)) SWIG_fail_arg("ofImage_< float >::drawSubsection",9,"float"); - if(!lua_isnumber(L,10)) SWIG_fail_arg("ofImage_< float >::drawSubsection",10,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_drawSubsection",1,SWIGTYPE_p_ofImage_T_float_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (float)lua_tonumber(L, 8); - arg9 = (float)lua_tonumber(L, 9); arg10 = (float)lua_tonumber(L, 10); - ((ofImage_< float > const *)arg1)->drawSubsection(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_drawSubsection(lua_State* L) { int argc; int argv[11]={ 1,2,3,4,5,6,7,8,9,10,11} ; - argc = lua_gettop(L); if (argc == 7) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { - return _wrap_FloatImage_drawSubsection__SWIG_0(L);} } } } } } } } if (argc == 8) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { return _wrap_FloatImage_drawSubsection__SWIG_1(L);} } } } } } - } } } if (argc == 9) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { { _v = lua_isnumber(L,argv[8]); } if (_v) { - return _wrap_FloatImage_drawSubsection__SWIG_2(L);} } } } } } } } } } if (argc == 10) { int _v; - { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { { _v = lua_isnumber(L,argv[8]); } if (_v) { { - _v = lua_isnumber(L,argv[9]); } if (_v) { return _wrap_FloatImage_drawSubsection__SWIG_3(L);} } } } - } } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatImage_drawSubsection'\n" - " Possible C/C++ prototypes are:\n" " ofImage_< float >::drawSubsection(float,float,float,float,float,float) const\n" - " ofImage_< float >::drawSubsection(float,float,float,float,float,float,float) const\n" - " ofImage_< float >::drawSubsection(float,float,float,float,float,float,float,float) const\n" - " ofImage_< float >::drawSubsection(float,float,float,float,float,float,float,float,float) const\n"); - lua_error(L);return 0; } -static int _wrap_FloatImage_update(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - SWIG_check_num_args("ofImage_< float >::update",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::update",1,"ofImage_< float > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_update",1,SWIGTYPE_p_ofImage_T_float_t); } (arg1)->update(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_setUseTexture(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - bool arg2 ; SWIG_check_num_args("ofImage_< float >::setUseTexture",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::setUseTexture",1,"ofImage_< float > *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofImage_< float >::setUseTexture",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_setUseTexture",1,SWIGTYPE_p_ofImage_T_float_t); } arg2 = (lua_toboolean(L, 2)!=0); - (arg1)->setUseTexture(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_isUsingTexture(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - bool result; SWIG_check_num_args("ofImage_< float >::isUsingTexture",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::isUsingTexture",1,"ofImage_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_isUsingTexture",1,SWIGTYPE_p_ofImage_T_float_t); } - result = (bool)((ofImage_< float > const *)arg1)->isUsingTexture(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_getTexture__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; ofTexture *result = 0 ; - SWIG_check_num_args("ofImage_< float >::getTexture",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::getTexture",1,"ofImage_< float > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_getTexture",1,SWIGTYPE_p_ofImage_T_float_t); } result = (ofTexture *) &(arg1)->getTexture(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTexture,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FloatImage_getTexture__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; ofTexture *result = 0 ; - SWIG_check_num_args("ofImage_< float >::getTexture",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::getTexture",1,"ofImage_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_getTexture",1,SWIGTYPE_p_ofImage_T_float_t); } - result = (ofTexture *) &((ofImage_< float > const *)arg1)->getTexture(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTexture,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FloatImage_getTexture(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_FloatImage_getTexture__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_FloatImage_getTexture__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatImage_getTexture'\n" - " Possible C/C++ prototypes are:\n" " ofImage_< float >::getTexture()\n" " ofImage_< float >::getTexture() const\n"); - lua_error(L);return 0; } -static int _wrap_FloatImage_bind__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - int arg2 ; SWIG_check_num_args("ofImage_< float >::bind",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::bind",1,"ofImage_< float > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< float >::bind",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_bind",1,SWIGTYPE_p_ofImage_T_float_t); } arg2 = (int)lua_tonumber(L, 2); - ((ofImage_< float > const *)arg1)->bind(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_bind__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - SWIG_check_num_args("ofImage_< float >::bind",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::bind",1,"ofImage_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_bind",1,SWIGTYPE_p_ofImage_T_float_t); } ((ofImage_< float > const *)arg1)->bind(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_bind(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; - { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_FloatImage_bind__SWIG_1(L);} } if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_FloatImage_bind__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatImage_bind'\n" " Possible C/C++ prototypes are:\n" - " ofImage_< float >::bind(int) const\n" " ofImage_< float >::bind() const\n"); lua_error(L);return 0; } -static int _wrap_FloatImage_unbind__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - int arg2 ; SWIG_check_num_args("ofImage_< float >::unbind",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::unbind",1,"ofImage_< float > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< float >::unbind",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_unbind",1,SWIGTYPE_p_ofImage_T_float_t); } arg2 = (int)lua_tonumber(L, 2); - ((ofImage_< float > const *)arg1)->unbind(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_unbind__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - SWIG_check_num_args("ofImage_< float >::unbind",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::unbind",1,"ofImage_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_unbind",1,SWIGTYPE_p_ofImage_T_float_t); } ((ofImage_< float > const *)arg1)->unbind(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_unbind(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_FloatImage_unbind__SWIG_1(L);} } if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_FloatImage_unbind__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatImage_unbind'\n" " Possible C/C++ prototypes are:\n" - " ofImage_< float >::unbind(int) const\n" " ofImage_< float >::unbind() const\n"); lua_error(L);return 0; } -static int _wrap_FloatImage_setCompression(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - ofTexCompression arg2 ; SWIG_check_num_args("ofImage_< float >::setCompression",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::setCompression",1,"ofImage_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< float >::setCompression",2,"ofTexCompression"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_setCompression",1,SWIGTYPE_p_ofImage_T_float_t); } - arg2 = (ofTexCompression)(int)lua_tonumber(L, 2); (arg1)->setCompression(arg2); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_getColor__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; int arg2 ; int arg3 ; ofColor_< float > result; - SWIG_check_num_args("ofImage_< float >::getColor",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::getColor",1,"ofImage_< float > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< float >::getColor",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< float >::getColor",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_getColor",1,SWIGTYPE_p_ofImage_T_float_t); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); result = ((ofImage_< float > const *)arg1)->getColor(arg2,arg3); { - ofColor_< float > * resultptr = new ofColor_< float >((const ofColor_< float > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_getColor__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; int arg2 ; ofColor_< float > result; - SWIG_check_num_args("ofImage_< float >::getColor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::getColor",1,"ofImage_< float > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< float >::getColor",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_getColor",1,SWIGTYPE_p_ofImage_T_float_t); } arg2 = (int)lua_tonumber(L, 2); - result = ((ofImage_< float > const *)arg1)->getColor(arg2); { - ofColor_< float > * resultptr = new ofColor_< float >((const ofColor_< float > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_getColor(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_FloatImage_getColor__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_FloatImage_getColor__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatImage_getColor'\n" - " Possible C/C++ prototypes are:\n" " ofImage_< float >::getColor(int,int) const\n" - " ofImage_< float >::getColor(int) const\n"); lua_error(L);return 0; } -static int _wrap_FloatImage_getHeight(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - float result; SWIG_check_num_args("ofImage_< float >::getHeight",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::getHeight",1,"ofImage_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_getHeight",1,SWIGTYPE_p_ofImage_T_float_t); } - result = (float)((ofImage_< float > const *)arg1)->getHeight(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_getWidth(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - float result; SWIG_check_num_args("ofImage_< float >::getWidth",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::getWidth",1,"ofImage_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_getWidth",1,SWIGTYPE_p_ofImage_T_float_t); } - result = (float)((ofImage_< float > const *)arg1)->getWidth(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_setColor__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; int arg2 ; int arg3 ; ofColor_< float > *arg4 = 0 ; - SWIG_check_num_args("ofImage_< float >::setColor",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::setColor",1,"ofImage_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< float >::setColor",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< float >::setColor",3,"int"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofImage_< float >::setColor",4,"ofColor_< float > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_setColor",1,SWIGTYPE_p_ofImage_T_float_t); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_setColor",4,SWIGTYPE_p_ofColor_T_float_t); } - (arg1)->setColor(arg2,arg3,(ofColor_< float > const &)*arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FloatImage_setColor__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; int arg2 ; ofColor_< float > *arg3 = 0 ; - SWIG_check_num_args("ofImage_< float >::setColor",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::setColor",1,"ofImage_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< float >::setColor",2,"int"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofImage_< float >::setColor",3,"ofColor_< float > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_setColor",1,SWIGTYPE_p_ofImage_T_float_t); } arg2 = (int)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_setColor",3,SWIGTYPE_p_ofColor_T_float_t); } - (arg1)->setColor(arg2,(ofColor_< float > const &)*arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FloatImage_setColor__SWIG_2(lua_State* L) { int SWIG_arg = 0; - ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; ofColor_< float > *arg2 = 0 ; - SWIG_check_num_args("ofImage_< float >::setColor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::setColor",1,"ofImage_< float > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofImage_< float >::setColor",2,"ofColor_< float > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_setColor",1,SWIGTYPE_p_ofImage_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_setColor",2,SWIGTYPE_p_ofColor_T_float_t); } (arg1)->setColor((ofColor_< float > const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_setColor(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_FloatImage_setColor__SWIG_2(L);} } } if (argc == 3) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_FloatImage_setColor__SWIG_1(L);} } } } if (argc == 4) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_FloatImage_setColor__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatImage_setColor'\n" - " Possible C/C++ prototypes are:\n" " ofImage_< float >::setColor(int,int,ofColor_< float > const &)\n" - " ofImage_< float >::setColor(int,ofColor_< float > const &)\n" - " ofImage_< float >::setColor(ofColor_< float > const &)\n"); lua_error(L);return 0; } -static int _wrap_FloatImage_setFromPixels__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; float *arg2 = (float *) 0 ; int arg3 ; int arg4 ; ofImageType arg5 ; - bool arg6 ; SWIG_check_num_args("ofImage_< float >::setFromPixels",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::setFromPixels",1,"ofImage_< float > *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofImage_< float >::setFromPixels",2,"float const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< float >::setFromPixels",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< float >::setFromPixels",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< float >::setFromPixels",5,"ofImageType"); - if(!lua_isboolean(L,6)) SWIG_fail_arg("ofImage_< float >::setFromPixels",6,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_setFromPixels",1,SWIGTYPE_p_ofImage_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("FloatImage_setFromPixels",2,SWIGTYPE_p_float); } arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); arg5 = (ofImageType)(int)lua_tonumber(L, 5); arg6 = (lua_toboolean(L, 6)!=0); - (arg1)->setFromPixels((float const *)arg2,arg3,arg4,arg5,arg6); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FloatImage_setFromPixels__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; float *arg2 = (float *) 0 ; int arg3 ; int arg4 ; ofImageType arg5 ; - SWIG_check_num_args("ofImage_< float >::setFromPixels",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::setFromPixels",1,"ofImage_< float > *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofImage_< float >::setFromPixels",2,"float const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< float >::setFromPixels",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< float >::setFromPixels",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< float >::setFromPixels",5,"ofImageType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_setFromPixels",1,SWIGTYPE_p_ofImage_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("FloatImage_setFromPixels",2,SWIGTYPE_p_float); } arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); arg5 = (ofImageType)(int)lua_tonumber(L, 5); - (arg1)->setFromPixels((float const *)arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FloatImage_setFromPixels__SWIG_2(lua_State* L) { int SWIG_arg = 0; - ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; ofPixels_< float > *arg2 = 0 ; - SWIG_check_num_args("ofImage_< float >::setFromPixels",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::setFromPixels",1,"ofImage_< float > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofImage_< float >::setFromPixels",2,"ofPixels_< float > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_setFromPixels",1,SWIGTYPE_p_ofImage_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_setFromPixels",2,SWIGTYPE_p_ofPixels_T_float_t); } - (arg1)->setFromPixels((ofPixels_< float > const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FloatImage_setFromPixels(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_FloatImage_setFromPixels__SWIG_2(L);} } } if (argc == 5) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_FloatImage_setFromPixels__SWIG_1(L);} } } } } } - if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isboolean(L,argv[5]); } if (_v) { - return _wrap_FloatImage_setFromPixels__SWIG_0(L);} } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatImage_setFromPixels'\n" - " Possible C/C++ prototypes are:\n" " ofImage_< float >::setFromPixels(float const *,int,int,ofImageType,bool)\n" - " ofImage_< float >::setFromPixels(float const *,int,int,ofImageType)\n" - " ofImage_< float >::setFromPixels(ofPixels_< float > const &)\n"); lua_error(L);return 0; } -static int _wrap_FloatImage_grabScreen(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - int arg2 ; int arg3 ; int arg4 ; int arg5 ; SWIG_check_num_args("ofImage_< float >::grabScreen",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::grabScreen",1,"ofImage_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< float >::grabScreen",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< float >::grabScreen",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< float >::grabScreen",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< float >::grabScreen",5,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_grabScreen",1,SWIGTYPE_p_ofImage_T_float_t); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); - (arg1)->grabScreen(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_setImageType(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - ofImageType arg2 ; SWIG_check_num_args("ofImage_< float >::setImageType",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::setImageType",1,"ofImage_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< float >::setImageType",2,"ofImageType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_setImageType",1,SWIGTYPE_p_ofImage_T_float_t); } arg2 = (ofImageType)(int)lua_tonumber(L, 2); - (arg1)->setImageType(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_getImageType(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - ofImageType result; SWIG_check_num_args("ofImage_< float >::getImageType",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::getImageType",1,"ofImage_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_getImageType",1,SWIGTYPE_p_ofImage_T_float_t); } - result = (ofImageType)((ofImage_< float > const *)arg1)->getImageType(); - lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FloatImage_resize(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - int arg2 ; int arg3 ; SWIG_check_num_args("ofImage_< float >::resize",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::resize",1,"ofImage_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< float >::resize",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< float >::resize",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_resize",1,SWIGTYPE_p_ofImage_T_float_t); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); (arg1)->resize(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FloatImage_crop(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - int arg2 ; int arg3 ; int arg4 ; int arg5 ; SWIG_check_num_args("ofImage_< float >::crop",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::crop",1,"ofImage_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< float >::crop",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< float >::crop",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< float >::crop",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< float >::crop",5,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_crop",1,SWIGTYPE_p_ofImage_T_float_t); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); - (arg1)->crop(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_cropFrom(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - ofImage_< float > *arg2 = 0 ; int arg3 ; int arg4 ; int arg5 ; int arg6 ; - SWIG_check_num_args("ofImage_< float >::cropFrom",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::cropFrom",1,"ofImage_< float > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofImage_< float >::cropFrom",2,"ofImage_< float > &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< float >::cropFrom",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< float >::cropFrom",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< float >::cropFrom",5,"int"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofImage_< float >::cropFrom",6,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_cropFrom",1,SWIGTYPE_p_ofImage_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_cropFrom",2,SWIGTYPE_p_ofImage_T_float_t); } arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); arg6 = (int)lua_tonumber(L, 6); - (arg1)->cropFrom(*arg2,arg3,arg4,arg5,arg6); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_rotate90(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - int arg2 ; SWIG_check_num_args("ofImage_< float >::rotate90",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::rotate90",1,"ofImage_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< float >::rotate90",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_rotate90",1,SWIGTYPE_p_ofImage_T_float_t); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->rotate90(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_mirror(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - bool arg2 ; bool arg3 ; SWIG_check_num_args("ofImage_< float >::mirror",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::mirror",1,"ofImage_< float > *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofImage_< float >::mirror",2,"bool"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofImage_< float >::mirror",3,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_mirror",1,SWIGTYPE_p_ofImage_T_float_t); } arg2 = (lua_toboolean(L, 2)!=0); - arg3 = (lua_toboolean(L, 3)!=0); (arg1)->mirror(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FloatImage_setAnchorPercent(lua_State* L) { int SWIG_arg = 0; - ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofImage_< float >::setAnchorPercent",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::setAnchorPercent",1,"ofImage_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< float >::setAnchorPercent",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< float >::setAnchorPercent",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_setAnchorPercent",1,SWIGTYPE_p_ofImage_T_float_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->setAnchorPercent(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FloatImage_setAnchorPoint(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - float arg2 ; float arg3 ; SWIG_check_num_args("ofImage_< float >::setAnchorPoint",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::setAnchorPoint",1,"ofImage_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< float >::setAnchorPoint",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< float >::setAnchorPoint",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_setAnchorPoint",1,SWIGTYPE_p_ofImage_T_float_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->setAnchorPoint(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FloatImage_resetAnchor(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - SWIG_check_num_args("ofImage_< float >::resetAnchor",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::resetAnchor",1,"ofImage_< float > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_resetAnchor",1,SWIGTYPE_p_ofImage_T_float_t); } (arg1)->resetAnchor(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_save__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - std::string arg2 ; ofImageQualityType arg3 ; SWIG_check_num_args("ofImage_< float >::save",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::save",1,"ofImage_< float > *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofImage_< float >::save",2,"std::string"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< float >::save",3,"ofImageQualityType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_save",1,SWIGTYPE_p_ofImage_T_float_t); } (&arg2)->assign(lua_tostring(L,2),lua_rawlen(L,2)); - arg3 = (ofImageQualityType)(int)lua_tonumber(L, 3); (arg1)->save(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_save__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - std::string arg2 ; SWIG_check_num_args("ofImage_< float >::save",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::save",1,"ofImage_< float > *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofImage_< float >::save",2,"std::string"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_save",1,SWIGTYPE_p_ofImage_T_float_t); } (&arg2)->assign(lua_tostring(L,2),lua_rawlen(L,2)); - (arg1)->save(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_save__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - ofBuffer *arg2 = 0 ; ofImageQualityType arg3 ; SWIG_check_num_args("ofImage_< float >::save",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::save",1,"ofImage_< float > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofImage_< float >::save",2,"ofBuffer &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< float >::save",3,"ofImageQualityType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_save",1,SWIGTYPE_p_ofImage_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBuffer,0))){ - SWIG_fail_ptr("FloatImage_save",2,SWIGTYPE_p_ofBuffer); } arg3 = (ofImageQualityType)(int)lua_tonumber(L, 3); - (arg1)->save(*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_save__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - ofBuffer *arg2 = 0 ; SWIG_check_num_args("ofImage_< float >::save",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::save",1,"ofImage_< float > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofImage_< float >::save",2,"ofBuffer &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_save",1,SWIGTYPE_p_ofImage_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBuffer,0))){ - SWIG_fail_ptr("FloatImage_save",2,SWIGTYPE_p_ofBuffer); } (arg1)->save(*arg2); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_save__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - ofFile *arg2 = 0 ; ofImageQualityType arg3 ; SWIG_check_num_args("ofImage_< float >::save",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::save",1,"ofImage_< float > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofImage_< float >::save",2,"ofFile const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< float >::save",3,"ofImageQualityType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_save",1,SWIGTYPE_p_ofImage_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofFile,0))){ - SWIG_fail_ptr("FloatImage_save",2,SWIGTYPE_p_ofFile); } arg3 = (ofImageQualityType)(int)lua_tonumber(L, 3); - (arg1)->save((ofFile const &)*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_save__SWIG_5(lua_State* L) { int SWIG_arg = 0; ofImage_< float > *arg1 = (ofImage_< float > *) 0 ; - ofFile *arg2 = 0 ; SWIG_check_num_args("ofImage_< float >::save",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< float >::save",1,"ofImage_< float > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofImage_< float >::save",2,"ofFile const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_float_t,0))){ - SWIG_fail_ptr("FloatImage_save",1,SWIGTYPE_p_ofImage_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofFile,0))){ - SWIG_fail_ptr("FloatImage_save",2,SWIGTYPE_p_ofFile); } (arg1)->save((ofFile const &)*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatImage_save(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBuffer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_FloatImage_save__SWIG_3(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_FloatImage_save__SWIG_5(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { - return _wrap_FloatImage_save__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_FloatImage_save__SWIG_4(L);} } - } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBuffer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_FloatImage_save__SWIG_2(L);} } - } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_FloatImage_save__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatImage_save'\n" " Possible C/C++ prototypes are:\n" - " ofImage_< float >::save(std::string,ofImageQualityType)\n" " ofImage_< float >::save(std::string)\n" - " ofImage_< float >::save(ofBuffer &,ofImageQualityType)\n" " ofImage_< float >::save(ofBuffer &)\n" - " ofImage_< float >::save(ofFile const &,ofImageQualityType)\n" " ofImage_< float >::save(ofFile const &)\n"); - lua_error(L);return 0; } -static void swig_delete_FloatImage(void *obj) { -ofImage_< float > *arg1 = (ofImage_< float > *) obj; -delete arg1; -} -static int _proxy__wrap_new_FloatImage(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_FloatImage); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_FloatImage_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_FloatImage_methods[]= { - { "allocate", _wrap_FloatImage_allocate}, - { "isAllocated", _wrap_FloatImage_isAllocated}, - { "clear", _wrap_FloatImage_clear}, - { "load", _wrap_FloatImage_load}, - { "draw", _wrap_FloatImage_draw}, - { "drawSubsection", _wrap_FloatImage_drawSubsection}, - { "update", _wrap_FloatImage_update}, - { "setUseTexture", _wrap_FloatImage_setUseTexture}, - { "isUsingTexture", _wrap_FloatImage_isUsingTexture}, - { "getTexture", _wrap_FloatImage_getTexture}, - { "bind", _wrap_FloatImage_bind}, - { "unbind", _wrap_FloatImage_unbind}, - { "setCompression", _wrap_FloatImage_setCompression}, - { "getColor", _wrap_FloatImage_getColor}, - { "getHeight", _wrap_FloatImage_getHeight}, - { "getWidth", _wrap_FloatImage_getWidth}, - { "setColor", _wrap_FloatImage_setColor}, - { "setFromPixels", _wrap_FloatImage_setFromPixels}, - { "grabScreen", _wrap_FloatImage_grabScreen}, - { "setImageType", _wrap_FloatImage_setImageType}, - { "getImageType", _wrap_FloatImage_getImageType}, - { "resize", _wrap_FloatImage_resize}, - { "crop", _wrap_FloatImage_crop}, - { "cropFrom", _wrap_FloatImage_cropFrom}, - { "rotate90", _wrap_FloatImage_rotate90}, - { "mirror", _wrap_FloatImage_mirror}, - { "setAnchorPercent", _wrap_FloatImage_setAnchorPercent}, - { "setAnchorPoint", _wrap_FloatImage_setAnchorPoint}, - { "resetAnchor", _wrap_FloatImage_resetAnchor}, - { "save", _wrap_FloatImage_save}, - {0,0} -}; -static swig_lua_method swig_FloatImage_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_FloatImage_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_FloatImage_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_FloatImage_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_FloatImage_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_FloatImage_Sf_SwigStatic = { - "FloatImage", - swig_FloatImage_Sf_SwigStatic_methods, - swig_FloatImage_Sf_SwigStatic_attributes, - swig_FloatImage_Sf_SwigStatic_constants, - swig_FloatImage_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_FloatImage_bases[] = {0}; -static const char *swig_FloatImage_base_names[] = {0}; -static swig_lua_class _wrap_class_FloatImage = { "FloatImage", "FloatImage", &SWIGTYPE_p_ofImage_T_float_t,_proxy__wrap_new_FloatImage, swig_delete_FloatImage, swig_FloatImage_methods, swig_FloatImage_attributes, &swig_FloatImage_Sf_SwigStatic, swig_FloatImage_meta, swig_FloatImage_bases, swig_FloatImage_base_names }; - -static int _wrap_new_ShortImage__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofImage_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofImage_< unsigned short >::ofImage_",0,0) - result = (ofImage_< unsigned short > *)new ofImage_< unsigned short >(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofImage_T_unsigned_short_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_ShortImage__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPixels_< unsigned short > *arg1 = 0 ; - ofImage_< unsigned short > *result = 0 ; SWIG_check_num_args("ofImage_< unsigned short >::ofImage_",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::ofImage_",1,"ofPixels_< unsigned short > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("new_ShortImage",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - result = (ofImage_< unsigned short > *)new ofImage_< unsigned short >((ofPixels_< unsigned short > const &)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofImage_T_unsigned_short_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_ShortImage__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = 0 ; - ofImage_< unsigned short > *result = 0 ; SWIG_check_num_args("ofImage_< unsigned short >::ofImage_",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::ofImage_",1,"ofFile const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("new_ShortImage",1,SWIGTYPE_p_ofFile); } - result = (ofImage_< unsigned short > *)new ofImage_< unsigned short >((ofFile const &)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofImage_T_unsigned_short_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_ShortImage__SWIG_3(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - ofImage_< unsigned short > *result = 0 ; SWIG_check_num_args("ofImage_< unsigned short >::ofImage_",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::ofImage_",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; - result = (ofImage_< unsigned short > *)new ofImage_< unsigned short >((std::string const &)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofImage_T_unsigned_short_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_ShortImage__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofImage_< unsigned short > *arg1 = 0 ; - ofImage_< unsigned short > *result = 0 ; SWIG_check_num_args("ofImage_< unsigned short >::ofImage_",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::ofImage_",1,"ofImage_< unsigned short > &&"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("new_ShortImage",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - result = (ofImage_< unsigned short > *)new ofImage_< unsigned short >((ofImage_< unsigned short > &&)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofImage_T_unsigned_short_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_ShortImage(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_ShortImage__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_new_ShortImage__SWIG_1(L);} } if (argc == 1) { int _v; { - void *ptr; if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_new_ShortImage__SWIG_2(L);} } if (argc == 1) { int _v; { - void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_new_ShortImage__SWIG_4(L);} } if (argc == 1) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { return _wrap_new_ShortImage__SWIG_3(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_ShortImage'\n" " Possible C/C++ prototypes are:\n" - " ofImage_< unsigned short >::ofImage_()\n" - " ofImage_< unsigned short >::ofImage_(ofPixels_< unsigned short > const &)\n" - " ofImage_< unsigned short >::ofImage_(ofFile const &)\n" " ofImage_< unsigned short >::ofImage_(std::string const &)\n" - " ofImage_< unsigned short >::ofImage_(ofImage_< unsigned short > &&)\n"); lua_error(L);return 0; } -static int _wrap_ShortImage_allocate(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; int arg2 ; int arg3 ; ofImageType arg4 ; - SWIG_check_num_args("ofImage_< unsigned short >::allocate",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::allocate",1,"ofImage_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::allocate",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned short >::allocate",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< unsigned short >::allocate",4,"ofImageType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_allocate",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); arg4 = (ofImageType)(int)lua_tonumber(L, 4); (arg1)->allocate(arg2,arg3,arg4); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_isAllocated(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; bool result; - SWIG_check_num_args("ofImage_< unsigned short >::isAllocated",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::isAllocated",1,"ofImage_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_isAllocated",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - result = (bool)((ofImage_< unsigned short > const *)arg1)->isAllocated(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_clear(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; - SWIG_check_num_args("ofImage_< unsigned short >::clear",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::clear",1,"ofImage_< unsigned short > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_clear",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } (arg1)->clear(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_load__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; std::string *arg2 = 0 ; std::string temp2 ; bool result; - SWIG_check_num_args("ofImage_< unsigned short >::load",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::load",1,"ofImage_< unsigned short > *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::load",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_load",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; result = (bool)(arg1)->load((std::string const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_load__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; ofBuffer *arg2 = 0 ; bool result; - SWIG_check_num_args("ofImage_< unsigned short >::load",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::load",1,"ofImage_< unsigned short > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::load",2,"ofBuffer const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_load",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBuffer,0))){ - SWIG_fail_ptr("ShortImage_load",2,SWIGTYPE_p_ofBuffer); } result = (bool)(arg1)->load((ofBuffer const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_load__SWIG_2(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; ofFile *arg2 = 0 ; bool result; - SWIG_check_num_args("ofImage_< unsigned short >::load",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::load",1,"ofImage_< unsigned short > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::load",2,"ofFile const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_load",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofFile,0))){ - SWIG_fail_ptr("ShortImage_load",2,SWIGTYPE_p_ofFile); } result = (bool)(arg1)->load((ofFile const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_load(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v; - { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBuffer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_ShortImage_load__SWIG_1(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_ShortImage_load__SWIG_2(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { - return _wrap_ShortImage_load__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortImage_load'\n" " Possible C/C++ prototypes are:\n" - " ofImage_< unsigned short >::load(std::string const &)\n" " ofImage_< unsigned short >::load(ofBuffer const &)\n" - " ofImage_< unsigned short >::load(ofFile const &)\n"); lua_error(L);return 0; } -static int _wrap_ShortImage_draw__SWIG_0_0(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; ofPoint *arg2 = 0 ; SWIG_check_num_args("draw",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("draw",1,"ofImage_< unsigned short > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("draw",2,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_draw",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("ShortImage_draw",2,SWIGTYPE_p_ofVec3f); } - ((ofImage_< unsigned short > const *)arg1)->draw((ofPoint const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_draw__SWIG_0_1(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; ofRectangle *arg2 = 0 ; SWIG_check_num_args("draw",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("draw",1,"ofImage_< unsigned short > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("draw",2,"ofRectangle const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_draw",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("ShortImage_draw",2,SWIGTYPE_p_ofRectangle); } - ((ofImage_< unsigned short > const *)arg1)->draw((ofRectangle const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_draw__SWIG_0_2(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; ofPoint *arg2 = 0 ; float arg3 ; float arg4 ; - SWIG_check_num_args("draw",4,4) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("draw",1,"ofImage_< unsigned short > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("draw",2,"ofPoint const &"); if(!lua_isnumber(L,3)) SWIG_fail_arg("draw",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("draw",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_draw",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("ShortImage_draw",2,SWIGTYPE_p_ofVec3f); } arg3 = (float)lua_tonumber(L, 3); - arg4 = (float)lua_tonumber(L, 4); ((ofImage_< unsigned short > const *)arg1)->draw((ofPoint const &)*arg2,arg3,arg4); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_draw__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofImage_< unsigned short >::draw",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::draw",1,"ofImage_< unsigned short > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::draw",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned short >::draw",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_draw",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); ((ofImage_< unsigned short > const *)arg1)->draw(arg2,arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_draw__SWIG_2(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; float arg2 ; float arg3 ; float arg4 ; - SWIG_check_num_args("ofImage_< unsigned short >::draw",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::draw",1,"ofImage_< unsigned short > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::draw",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned short >::draw",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< unsigned short >::draw",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_draw",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - ((ofImage_< unsigned short > const *)arg1)->draw(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortImage_draw__SWIG_3(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; float arg2 ; float arg3 ; float arg4 ; float arg5 ; - SWIG_check_num_args("ofImage_< unsigned short >::draw",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::draw",1,"ofImage_< unsigned short > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::draw",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned short >::draw",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< unsigned short >::draw",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< unsigned short >::draw",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_draw",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - ((ofImage_< unsigned short > const *)arg1)->draw(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortImage_draw__SWIG_4(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; float arg2 ; float arg3 ; float arg4 ; float arg5 ; - float arg6 ; SWIG_check_num_args("ofImage_< unsigned short >::draw",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::draw",1,"ofImage_< unsigned short > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::draw",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned short >::draw",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< unsigned short >::draw",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< unsigned short >::draw",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofImage_< unsigned short >::draw",6,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_draw",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); ((ofImage_< unsigned short > const *)arg1)->draw(arg2,arg3,arg4,arg5,arg6); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_draw(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_ShortImage_draw__SWIG_0_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_ShortImage_draw__SWIG_0_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_ShortImage_draw__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_ShortImage_draw__SWIG_0_2(L);} } } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_ShortImage_draw__SWIG_2(L);} } } } } - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_ShortImage_draw__SWIG_3(L);} } } } } } if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { return _wrap_ShortImage_draw__SWIG_4(L);} } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortImage_draw'\n" " Possible C/C++ prototypes are:\n" - " draw(ofPoint const &) const\n" " draw(ofRectangle const &) const\n" " draw(ofPoint const &,float,float) const\n" - " ofImage_< unsigned short >::draw(float,float) const\n" " ofImage_< unsigned short >::draw(float,float,float) const\n" - " ofImage_< unsigned short >::draw(float,float,float,float) const\n" - " ofImage_< unsigned short >::draw(float,float,float,float,float) const\n"); lua_error(L);return 0; } -static int _wrap_ShortImage_drawSubsection__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; float arg2 ; float arg3 ; float arg4 ; float arg5 ; - float arg6 ; float arg7 ; SWIG_check_num_args("ofImage_< unsigned short >::drawSubsection",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",1,"ofImage_< unsigned short > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",7,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_drawSubsection",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); - ((ofImage_< unsigned short > const *)arg1)->drawSubsection(arg2,arg3,arg4,arg5,arg6,arg7); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_drawSubsection__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; float arg2 ; float arg3 ; float arg4 ; float arg5 ; - float arg6 ; float arg7 ; float arg8 ; SWIG_check_num_args("ofImage_< unsigned short >::drawSubsection",8,8) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",1,"ofImage_< unsigned short > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",8,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_drawSubsection",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (float)lua_tonumber(L, 8); - ((ofImage_< unsigned short > const *)arg1)->drawSubsection(arg2,arg3,arg4,arg5,arg6,arg7,arg8); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_drawSubsection__SWIG_2(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; float arg2 ; float arg3 ; float arg4 ; float arg5 ; - float arg6 ; float arg7 ; float arg8 ; float arg9 ; SWIG_check_num_args("ofImage_< unsigned short >::drawSubsection",9,9) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",1,"ofImage_< unsigned short > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",8,"float"); - if(!lua_isnumber(L,9)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",9,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_drawSubsection",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (float)lua_tonumber(L, 8); - arg9 = (float)lua_tonumber(L, 9); - ((ofImage_< unsigned short > const *)arg1)->drawSubsection(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_drawSubsection__SWIG_3(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; float arg2 ; float arg3 ; float arg4 ; float arg5 ; - float arg6 ; float arg7 ; float arg8 ; float arg9 ; float arg10 ; - SWIG_check_num_args("ofImage_< unsigned short >::drawSubsection",10,10) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",1,"ofImage_< unsigned short > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",8,"float"); - if(!lua_isnumber(L,9)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",9,"float"); - if(!lua_isnumber(L,10)) SWIG_fail_arg("ofImage_< unsigned short >::drawSubsection",10,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_drawSubsection",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (float)lua_tonumber(L, 8); - arg9 = (float)lua_tonumber(L, 9); arg10 = (float)lua_tonumber(L, 10); - ((ofImage_< unsigned short > const *)arg1)->drawSubsection(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_drawSubsection(lua_State* L) { int argc; int argv[11]={ 1,2,3,4,5,6,7,8,9,10,11} ; - argc = lua_gettop(L); if (argc == 7) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { - return _wrap_ShortImage_drawSubsection__SWIG_0(L);} } } } } } } } if (argc == 8) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { return _wrap_ShortImage_drawSubsection__SWIG_1(L);} } } } } } - } } } if (argc == 9) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { { _v = lua_isnumber(L,argv[8]); } if (_v) { - return _wrap_ShortImage_drawSubsection__SWIG_2(L);} } } } } } } } } } if (argc == 10) { int _v; - { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { { _v = lua_isnumber(L,argv[8]); } if (_v) { { - _v = lua_isnumber(L,argv[9]); } if (_v) { return _wrap_ShortImage_drawSubsection__SWIG_3(L);} } } } - } } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortImage_drawSubsection'\n" - " Possible C/C++ prototypes are:\n" - " ofImage_< unsigned short >::drawSubsection(float,float,float,float,float,float) const\n" - " ofImage_< unsigned short >::drawSubsection(float,float,float,float,float,float,float) const\n" - " ofImage_< unsigned short >::drawSubsection(float,float,float,float,float,float,float,float) const\n" - " ofImage_< unsigned short >::drawSubsection(float,float,float,float,float,float,float,float,float) const\n"); - lua_error(L);return 0; } -static int _wrap_ShortImage_update(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; - SWIG_check_num_args("ofImage_< unsigned short >::update",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::update",1,"ofImage_< unsigned short > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_update",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } (arg1)->update(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_setUseTexture(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; bool arg2 ; - SWIG_check_num_args("ofImage_< unsigned short >::setUseTexture",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::setUseTexture",1,"ofImage_< unsigned short > *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::setUseTexture",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_setUseTexture",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } arg2 = (lua_toboolean(L, 2)!=0); - (arg1)->setUseTexture(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_isUsingTexture(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; bool result; - SWIG_check_num_args("ofImage_< unsigned short >::isUsingTexture",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::isUsingTexture",1,"ofImage_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_isUsingTexture",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - result = (bool)((ofImage_< unsigned short > const *)arg1)->isUsingTexture(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_getTexture__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; ofTexture *result = 0 ; - SWIG_check_num_args("ofImage_< unsigned short >::getTexture",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::getTexture",1,"ofImage_< unsigned short > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_getTexture",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - result = (ofTexture *) &(arg1)->getTexture(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTexture,0); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_getTexture__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; ofTexture *result = 0 ; - SWIG_check_num_args("ofImage_< unsigned short >::getTexture",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::getTexture",1,"ofImage_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_getTexture",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - result = (ofTexture *) &((ofImage_< unsigned short > const *)arg1)->getTexture(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTexture,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortImage_getTexture(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_ShortImage_getTexture__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_ShortImage_getTexture__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortImage_getTexture'\n" - " Possible C/C++ prototypes are:\n" " ofImage_< unsigned short >::getTexture()\n" - " ofImage_< unsigned short >::getTexture() const\n"); lua_error(L);return 0; } -static int _wrap_ShortImage_bind__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; int arg2 ; - SWIG_check_num_args("ofImage_< unsigned short >::bind",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::bind",1,"ofImage_< unsigned short > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::bind",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_bind",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } arg2 = (int)lua_tonumber(L, 2); - ((ofImage_< unsigned short > const *)arg1)->bind(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortImage_bind__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; - SWIG_check_num_args("ofImage_< unsigned short >::bind",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::bind",1,"ofImage_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_bind",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - ((ofImage_< unsigned short > const *)arg1)->bind(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_bind(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; - { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_ShortImage_bind__SWIG_1(L);} } if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_ShortImage_bind__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortImage_bind'\n" " Possible C/C++ prototypes are:\n" - " ofImage_< unsigned short >::bind(int) const\n" " ofImage_< unsigned short >::bind() const\n"); lua_error(L);return 0; } -static int _wrap_ShortImage_unbind__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; int arg2 ; - SWIG_check_num_args("ofImage_< unsigned short >::unbind",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::unbind",1,"ofImage_< unsigned short > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::unbind",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_unbind",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } arg2 = (int)lua_tonumber(L, 2); - ((ofImage_< unsigned short > const *)arg1)->unbind(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortImage_unbind__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; - SWIG_check_num_args("ofImage_< unsigned short >::unbind",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::unbind",1,"ofImage_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_unbind",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - ((ofImage_< unsigned short > const *)arg1)->unbind(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_unbind(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_ShortImage_unbind__SWIG_1(L);} } if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_ShortImage_unbind__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortImage_unbind'\n" " Possible C/C++ prototypes are:\n" - " ofImage_< unsigned short >::unbind(int) const\n" " ofImage_< unsigned short >::unbind() const\n"); - lua_error(L);return 0; } -static int _wrap_ShortImage_setCompression(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; ofTexCompression arg2 ; - SWIG_check_num_args("ofImage_< unsigned short >::setCompression",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::setCompression",1,"ofImage_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::setCompression",2,"ofTexCompression"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_setCompression",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - arg2 = (ofTexCompression)(int)lua_tonumber(L, 2); (arg1)->setCompression(arg2); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_getColor__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; int arg2 ; int arg3 ; ofColor_< unsigned short > result; - SWIG_check_num_args("ofImage_< unsigned short >::getColor",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::getColor",1,"ofImage_< unsigned short > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::getColor",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned short >::getColor",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_getColor",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); result = ((ofImage_< unsigned short > const *)arg1)->getColor(arg2,arg3); { - ofColor_< unsigned short > * resultptr = new ofColor_< unsigned short >((const ofColor_< unsigned short > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_short_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_getColor__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; int arg2 ; ofColor_< unsigned short > result; - SWIG_check_num_args("ofImage_< unsigned short >::getColor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::getColor",1,"ofImage_< unsigned short > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::getColor",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_getColor",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } arg2 = (int)lua_tonumber(L, 2); - result = ((ofImage_< unsigned short > const *)arg1)->getColor(arg2); { - ofColor_< unsigned short > * resultptr = new ofColor_< unsigned short >((const ofColor_< unsigned short > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_short_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_getColor(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_ShortImage_getColor__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_ShortImage_getColor__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortImage_getColor'\n" - " Possible C/C++ prototypes are:\n" " ofImage_< unsigned short >::getColor(int,int) const\n" - " ofImage_< unsigned short >::getColor(int) const\n"); lua_error(L);return 0; } -static int _wrap_ShortImage_getHeight(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; float result; - SWIG_check_num_args("ofImage_< unsigned short >::getHeight",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::getHeight",1,"ofImage_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_getHeight",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - result = (float)((ofImage_< unsigned short > const *)arg1)->getHeight(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_getWidth(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; float result; - SWIG_check_num_args("ofImage_< unsigned short >::getWidth",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::getWidth",1,"ofImage_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_getWidth",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - result = (float)((ofImage_< unsigned short > const *)arg1)->getWidth(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_setColor__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; int arg2 ; int arg3 ; - ofColor_< unsigned short > *arg4 = 0 ; SWIG_check_num_args("ofImage_< unsigned short >::setColor",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::setColor",1,"ofImage_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::setColor",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned short >::setColor",3,"int"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofImage_< unsigned short >::setColor",4,"ofColor_< unsigned short > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_setColor",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_setColor",4,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - (arg1)->setColor(arg2,arg3,(ofColor_< unsigned short > const &)*arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortImage_setColor__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; int arg2 ; ofColor_< unsigned short > *arg3 = 0 ; - SWIG_check_num_args("ofImage_< unsigned short >::setColor",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::setColor",1,"ofImage_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::setColor",2,"int"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofImage_< unsigned short >::setColor",3,"ofColor_< unsigned short > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_setColor",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } arg2 = (int)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_setColor",3,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - (arg1)->setColor(arg2,(ofColor_< unsigned short > const &)*arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortImage_setColor__SWIG_2(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; ofColor_< unsigned short > *arg2 = 0 ; - SWIG_check_num_args("ofImage_< unsigned short >::setColor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::setColor",1,"ofImage_< unsigned short > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::setColor",2,"ofColor_< unsigned short > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_setColor",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_setColor",2,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - (arg1)->setColor((ofColor_< unsigned short > const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortImage_setColor(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_ShortImage_setColor__SWIG_2(L);} } } if (argc == 3) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_ShortImage_setColor__SWIG_1(L);} } } } if (argc == 4) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_ShortImage_setColor__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortImage_setColor'\n" - " Possible C/C++ prototypes are:\n" " ofImage_< unsigned short >::setColor(int,int,ofColor_< unsigned short > const &)\n" - " ofImage_< unsigned short >::setColor(int,ofColor_< unsigned short > const &)\n" - " ofImage_< unsigned short >::setColor(ofColor_< unsigned short > const &)\n"); lua_error(L);return 0; } -static int _wrap_ShortImage_setFromPixels__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; unsigned short *arg2 = (unsigned short *) 0 ; int arg3 ; - int arg4 ; ofImageType arg5 ; bool arg6 ; SWIG_check_num_args("ofImage_< unsigned short >::setFromPixels",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::setFromPixels",1,"ofImage_< unsigned short > *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::setFromPixels",2,"unsigned short const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned short >::setFromPixels",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< unsigned short >::setFromPixels",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< unsigned short >::setFromPixels",5,"ofImageType"); - if(!lua_isboolean(L,6)) SWIG_fail_arg("ofImage_< unsigned short >::setFromPixels",6,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_setFromPixels",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_unsigned_short,0))){ - SWIG_fail_ptr("ShortImage_setFromPixels",2,SWIGTYPE_p_unsigned_short); } arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); arg5 = (ofImageType)(int)lua_tonumber(L, 5); arg6 = (lua_toboolean(L, 6)!=0); - (arg1)->setFromPixels((unsigned short const *)arg2,arg3,arg4,arg5,arg6); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortImage_setFromPixels__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; unsigned short *arg2 = (unsigned short *) 0 ; int arg3 ; - int arg4 ; ofImageType arg5 ; SWIG_check_num_args("ofImage_< unsigned short >::setFromPixels",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::setFromPixels",1,"ofImage_< unsigned short > *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::setFromPixels",2,"unsigned short const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned short >::setFromPixels",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< unsigned short >::setFromPixels",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< unsigned short >::setFromPixels",5,"ofImageType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_setFromPixels",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_unsigned_short,0))){ - SWIG_fail_ptr("ShortImage_setFromPixels",2,SWIGTYPE_p_unsigned_short); } arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); arg5 = (ofImageType)(int)lua_tonumber(L, 5); - (arg1)->setFromPixels((unsigned short const *)arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortImage_setFromPixels__SWIG_2(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; ofPixels_< unsigned short > *arg2 = 0 ; - SWIG_check_num_args("ofImage_< unsigned short >::setFromPixels",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::setFromPixels",1,"ofImage_< unsigned short > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::setFromPixels",2,"ofPixels_< unsigned short > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_setFromPixels",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_setFromPixels",2,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - (arg1)->setFromPixels((ofPixels_< unsigned short > const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortImage_setFromPixels(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_ShortImage_setFromPixels__SWIG_2(L);} } } if (argc == 5) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_unsigned_short, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_ShortImage_setFromPixels__SWIG_1(L);} } } } } - } if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_unsigned_short, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isboolean(L,argv[5]); } if (_v) { - return _wrap_ShortImage_setFromPixels__SWIG_0(L);} } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortImage_setFromPixels'\n" - " Possible C/C++ prototypes are:\n" - " ofImage_< unsigned short >::setFromPixels(unsigned short const *,int,int,ofImageType,bool)\n" - " ofImage_< unsigned short >::setFromPixels(unsigned short const *,int,int,ofImageType)\n" - " ofImage_< unsigned short >::setFromPixels(ofPixels_< unsigned short > const &)\n"); lua_error(L);return 0; } -static int _wrap_ShortImage_grabScreen(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; int arg2 ; int arg3 ; int arg4 ; int arg5 ; - SWIG_check_num_args("ofImage_< unsigned short >::grabScreen",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::grabScreen",1,"ofImage_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::grabScreen",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned short >::grabScreen",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< unsigned short >::grabScreen",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< unsigned short >::grabScreen",5,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_grabScreen",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); - (arg1)->grabScreen(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_setImageType(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; ofImageType arg2 ; - SWIG_check_num_args("ofImage_< unsigned short >::setImageType",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::setImageType",1,"ofImage_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::setImageType",2,"ofImageType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_setImageType",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - arg2 = (ofImageType)(int)lua_tonumber(L, 2); (arg1)->setImageType(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortImage_getImageType(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; ofImageType result; - SWIG_check_num_args("ofImage_< unsigned short >::getImageType",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::getImageType",1,"ofImage_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_getImageType",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - result = (ofImageType)((ofImage_< unsigned short > const *)arg1)->getImageType(); - lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortImage_resize(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; int arg2 ; int arg3 ; - SWIG_check_num_args("ofImage_< unsigned short >::resize",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::resize",1,"ofImage_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::resize",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned short >::resize",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_resize",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); (arg1)->resize(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortImage_crop(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; int arg2 ; int arg3 ; int arg4 ; int arg5 ; - SWIG_check_num_args("ofImage_< unsigned short >::crop",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::crop",1,"ofImage_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::crop",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned short >::crop",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< unsigned short >::crop",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< unsigned short >::crop",5,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_crop",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); - (arg1)->crop(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_cropFrom(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; ofImage_< unsigned short > *arg2 = 0 ; int arg3 ; - int arg4 ; int arg5 ; int arg6 ; SWIG_check_num_args("ofImage_< unsigned short >::cropFrom",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::cropFrom",1,"ofImage_< unsigned short > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::cropFrom",2,"ofImage_< unsigned short > &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned short >::cropFrom",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofImage_< unsigned short >::cropFrom",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofImage_< unsigned short >::cropFrom",5,"int"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofImage_< unsigned short >::cropFrom",6,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_cropFrom",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_cropFrom",2,SWIGTYPE_p_ofImage_T_unsigned_short_t); } arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); arg6 = (int)lua_tonumber(L, 6); - (arg1)->cropFrom(*arg2,arg3,arg4,arg5,arg6); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_rotate90(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; int arg2 ; - SWIG_check_num_args("ofImage_< unsigned short >::rotate90",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::rotate90",1,"ofImage_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::rotate90",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_rotate90",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->rotate90(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_mirror(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; bool arg2 ; bool arg3 ; - SWIG_check_num_args("ofImage_< unsigned short >::mirror",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::mirror",1,"ofImage_< unsigned short > *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::mirror",2,"bool"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofImage_< unsigned short >::mirror",3,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_mirror",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } arg2 = (lua_toboolean(L, 2)!=0); - arg3 = (lua_toboolean(L, 3)!=0); (arg1)->mirror(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortImage_setAnchorPercent(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofImage_< unsigned short >::setAnchorPercent",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::setAnchorPercent",1,"ofImage_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::setAnchorPercent",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned short >::setAnchorPercent",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_setAnchorPercent",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->setAnchorPercent(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortImage_setAnchorPoint(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofImage_< unsigned short >::setAnchorPoint",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::setAnchorPoint",1,"ofImage_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::setAnchorPoint",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned short >::setAnchorPoint",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_setAnchorPoint",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->setAnchorPoint(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortImage_resetAnchor(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; - SWIG_check_num_args("ofImage_< unsigned short >::resetAnchor",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::resetAnchor",1,"ofImage_< unsigned short > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_resetAnchor",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } (arg1)->resetAnchor(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_save__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; std::string arg2 ; ofImageQualityType arg3 ; - SWIG_check_num_args("ofImage_< unsigned short >::save",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::save",1,"ofImage_< unsigned short > *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::save",2,"std::string"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned short >::save",3,"ofImageQualityType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_save",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - (&arg2)->assign(lua_tostring(L,2),lua_rawlen(L,2)); arg3 = (ofImageQualityType)(int)lua_tonumber(L, 3); - (arg1)->save(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_save__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; std::string arg2 ; - SWIG_check_num_args("ofImage_< unsigned short >::save",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::save",1,"ofImage_< unsigned short > *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::save",2,"std::string"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_save",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - (&arg2)->assign(lua_tostring(L,2),lua_rawlen(L,2)); (arg1)->save(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortImage_save__SWIG_2(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; ofBuffer *arg2 = 0 ; ofImageQualityType arg3 ; - SWIG_check_num_args("ofImage_< unsigned short >::save",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::save",1,"ofImage_< unsigned short > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::save",2,"ofBuffer &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned short >::save",3,"ofImageQualityType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_save",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBuffer,0))){ - SWIG_fail_ptr("ShortImage_save",2,SWIGTYPE_p_ofBuffer); } arg3 = (ofImageQualityType)(int)lua_tonumber(L, 3); - (arg1)->save(*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_save__SWIG_3(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; ofBuffer *arg2 = 0 ; - SWIG_check_num_args("ofImage_< unsigned short >::save",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::save",1,"ofImage_< unsigned short > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::save",2,"ofBuffer &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_save",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBuffer,0))){ - SWIG_fail_ptr("ShortImage_save",2,SWIGTYPE_p_ofBuffer); } (arg1)->save(*arg2); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_save__SWIG_4(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; ofFile *arg2 = 0 ; ofImageQualityType arg3 ; - SWIG_check_num_args("ofImage_< unsigned short >::save",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::save",1,"ofImage_< unsigned short > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::save",2,"ofFile const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofImage_< unsigned short >::save",3,"ofImageQualityType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_save",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofFile,0))){ - SWIG_fail_ptr("ShortImage_save",2,SWIGTYPE_p_ofFile); } arg3 = (ofImageQualityType)(int)lua_tonumber(L, 3); - (arg1)->save((ofFile const &)*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_save__SWIG_5(lua_State* L) { int SWIG_arg = 0; - ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) 0 ; ofFile *arg2 = 0 ; - SWIG_check_num_args("ofImage_< unsigned short >::save",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofImage_< unsigned short >::save",1,"ofImage_< unsigned short > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofImage_< unsigned short >::save",2,"ofFile const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofImage_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortImage_save",1,SWIGTYPE_p_ofImage_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofFile,0))){ - SWIG_fail_ptr("ShortImage_save",2,SWIGTYPE_p_ofFile); } (arg1)->save((ofFile const &)*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortImage_save(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBuffer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_ShortImage_save__SWIG_3(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_ShortImage_save__SWIG_5(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { - return _wrap_ShortImage_save__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_ShortImage_save__SWIG_4(L);} } - } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBuffer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_ShortImage_save__SWIG_2(L);} } - } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofImage_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_ShortImage_save__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortImage_save'\n" " Possible C/C++ prototypes are:\n" - " ofImage_< unsigned short >::save(std::string,ofImageQualityType)\n" " ofImage_< unsigned short >::save(std::string)\n" - " ofImage_< unsigned short >::save(ofBuffer &,ofImageQualityType)\n" " ofImage_< unsigned short >::save(ofBuffer &)\n" - " ofImage_< unsigned short >::save(ofFile const &,ofImageQualityType)\n" - " ofImage_< unsigned short >::save(ofFile const &)\n"); lua_error(L);return 0; } -static void swig_delete_ShortImage(void *obj) { -ofImage_< unsigned short > *arg1 = (ofImage_< unsigned short > *) obj; -delete arg1; -} -static int _proxy__wrap_new_ShortImage(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_ShortImage); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_ShortImage_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_ShortImage_methods[]= { - { "allocate", _wrap_ShortImage_allocate}, - { "isAllocated", _wrap_ShortImage_isAllocated}, - { "clear", _wrap_ShortImage_clear}, - { "load", _wrap_ShortImage_load}, - { "draw", _wrap_ShortImage_draw}, - { "drawSubsection", _wrap_ShortImage_drawSubsection}, - { "update", _wrap_ShortImage_update}, - { "setUseTexture", _wrap_ShortImage_setUseTexture}, - { "isUsingTexture", _wrap_ShortImage_isUsingTexture}, - { "getTexture", _wrap_ShortImage_getTexture}, - { "bind", _wrap_ShortImage_bind}, - { "unbind", _wrap_ShortImage_unbind}, - { "setCompression", _wrap_ShortImage_setCompression}, - { "getColor", _wrap_ShortImage_getColor}, - { "getHeight", _wrap_ShortImage_getHeight}, - { "getWidth", _wrap_ShortImage_getWidth}, - { "setColor", _wrap_ShortImage_setColor}, - { "setFromPixels", _wrap_ShortImage_setFromPixels}, - { "grabScreen", _wrap_ShortImage_grabScreen}, - { "setImageType", _wrap_ShortImage_setImageType}, - { "getImageType", _wrap_ShortImage_getImageType}, - { "resize", _wrap_ShortImage_resize}, - { "crop", _wrap_ShortImage_crop}, - { "cropFrom", _wrap_ShortImage_cropFrom}, - { "rotate90", _wrap_ShortImage_rotate90}, - { "mirror", _wrap_ShortImage_mirror}, - { "setAnchorPercent", _wrap_ShortImage_setAnchorPercent}, - { "setAnchorPoint", _wrap_ShortImage_setAnchorPoint}, - { "resetAnchor", _wrap_ShortImage_resetAnchor}, - { "save", _wrap_ShortImage_save}, - {0,0} -}; -static swig_lua_method swig_ShortImage_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_ShortImage_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_ShortImage_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_ShortImage_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_ShortImage_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_ShortImage_Sf_SwigStatic = { - "ShortImage", - swig_ShortImage_Sf_SwigStatic_methods, - swig_ShortImage_Sf_SwigStatic_attributes, - swig_ShortImage_Sf_SwigStatic_constants, - swig_ShortImage_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_ShortImage_bases[] = {0}; -static const char *swig_ShortImage_base_names[] = {0}; -static swig_lua_class _wrap_class_ShortImage = { "ShortImage", "ShortImage", &SWIGTYPE_p_ofImage_T_unsigned_short_t,_proxy__wrap_new_ShortImage, swig_delete_ShortImage, swig_ShortImage_methods, swig_ShortImage_attributes, &swig_ShortImage_Sf_SwigStatic, swig_ShortImage_meta, swig_ShortImage_bases, swig_ShortImage_base_names }; - -static int _wrap_isVFlipped(lua_State* L) { int SWIG_arg = 0; bool result; SWIG_check_num_args("ofIsVFlipped",0,0) - result = (bool)ofIsVFlipped(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_Node__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofNode *result = 0 ; - SWIG_check_num_args("ofNode::ofNode",0,0) result = (ofNode *)new ofNode(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofNode,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Node__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = 0 ; ofNode *result = 0 ; - SWIG_check_num_args("ofNode::ofNode",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofNode::ofNode",1,"ofNode &&"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("new_Node",1,SWIGTYPE_p_ofNode); } - result = (ofNode *)new ofNode((ofNode &&)*arg1); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofNode,1); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_new_Node(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_Node__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_new_Node__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_Node'\n" " Possible C/C++ prototypes are:\n" - " ofNode::ofNode()\n" " ofNode::ofNode(ofNode &&)\n"); lua_error(L);return 0; } -static int _wrap_Node_setParent__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; ofNode *arg2 = 0 ; - bool arg3 ; SWIG_check_num_args("ofNode::setParent",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::setParent",1,"ofNode *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofNode::setParent",2,"ofNode &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofNode::setParent",3,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_setParent",1,SWIGTYPE_p_ofNode); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_setParent",2,SWIGTYPE_p_ofNode); } arg3 = (lua_toboolean(L, 3)!=0); (arg1)->setParent(*arg2,arg3); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_setParent__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; ofNode *arg2 = 0 ; - SWIG_check_num_args("ofNode::setParent",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::setParent",1,"ofNode *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofNode::setParent",2,"ofNode &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_setParent",1,SWIGTYPE_p_ofNode); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_setParent",2,SWIGTYPE_p_ofNode); } (arg1)->setParent(*arg2); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Node_setParent(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Node_setParent__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { return _wrap_Node_setParent__SWIG_0(L);} } - } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Node_setParent'\n" - " Possible C/C++ prototypes are:\n" " ofNode::setParent(ofNode &,bool)\n" " ofNode::setParent(ofNode &)\n"); - lua_error(L);return 0; } -static int _wrap_Node_clearParent__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; bool arg2 ; - SWIG_check_num_args("ofNode::clearParent",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::clearParent",1,"ofNode *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofNode::clearParent",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_clearParent",1,SWIGTYPE_p_ofNode); } arg2 = (lua_toboolean(L, 2)!=0); (arg1)->clearParent(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_clearParent__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; - SWIG_check_num_args("ofNode::clearParent",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::clearParent",1,"ofNode *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_clearParent",1,SWIGTYPE_p_ofNode); } (arg1)->clearParent(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Node_clearParent(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Node_clearParent__SWIG_1(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_Node_clearParent__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Node_clearParent'\n" " Possible C/C++ prototypes are:\n" - " ofNode::clearParent(bool)\n" " ofNode::clearParent()\n"); lua_error(L);return 0; } -static int _wrap_Node_getParent(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; ofNode *result = 0 ; - SWIG_check_num_args("ofNode::getParent",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::getParent",1,"ofNode const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_getParent",1,SWIGTYPE_p_ofNode); } - result = (ofNode *)((ofNode const *)arg1)->getParent(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofNode,0); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_getPosition(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; ofVec3f result; - SWIG_check_num_args("ofNode::getPosition",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::getPosition",1,"ofNode const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_getPosition",1,SWIGTYPE_p_ofNode); } result = ((ofNode const *)arg1)->getPosition(); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Node_getX(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; float result; - SWIG_check_num_args("ofNode::getX",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::getX",1,"ofNode const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_getX",1,SWIGTYPE_p_ofNode); } - result = (float)((ofNode const *)arg1)->getX(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_getY(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; float result; - SWIG_check_num_args("ofNode::getY",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::getY",1,"ofNode const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_getY",1,SWIGTYPE_p_ofNode); } - result = (float)((ofNode const *)arg1)->getY(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_getZ(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; float result; - SWIG_check_num_args("ofNode::getZ",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::getZ",1,"ofNode const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_getZ",1,SWIGTYPE_p_ofNode); } - result = (float)((ofNode const *)arg1)->getZ(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_getXAxis(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; ofVec3f result; - SWIG_check_num_args("ofNode::getXAxis",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::getXAxis",1,"ofNode const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_getXAxis",1,SWIGTYPE_p_ofNode); } - result = ((ofNode const *)arg1)->getXAxis(); { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Node_getYAxis(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; ofVec3f result; - SWIG_check_num_args("ofNode::getYAxis",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::getYAxis",1,"ofNode const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_getYAxis",1,SWIGTYPE_p_ofNode); } - result = ((ofNode const *)arg1)->getYAxis(); { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Node_getZAxis(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; ofVec3f result; - SWIG_check_num_args("ofNode::getZAxis",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::getZAxis",1,"ofNode const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_getZAxis",1,SWIGTYPE_p_ofNode); } - result = ((ofNode const *)arg1)->getZAxis(); { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Node_getSideDir(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; ofVec3f result; - SWIG_check_num_args("ofNode::getSideDir",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::getSideDir",1,"ofNode const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_getSideDir",1,SWIGTYPE_p_ofNode); } result = ((ofNode const *)arg1)->getSideDir(); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Node_getLookAtDir(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; ofVec3f result; - SWIG_check_num_args("ofNode::getLookAtDir",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::getLookAtDir",1,"ofNode const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_getLookAtDir",1,SWIGTYPE_p_ofNode); } result = ((ofNode const *)arg1)->getLookAtDir(); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Node_getUpDir(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; ofVec3f result; - SWIG_check_num_args("ofNode::getUpDir",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::getUpDir",1,"ofNode const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_getUpDir",1,SWIGTYPE_p_ofNode); } - result = ((ofNode const *)arg1)->getUpDir(); { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Node_getPitch(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; float result; - SWIG_check_num_args("ofNode::getPitch",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::getPitch",1,"ofNode const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_getPitch",1,SWIGTYPE_p_ofNode); } - result = (float)((ofNode const *)arg1)->getPitch(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_getHeading(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; float result; - SWIG_check_num_args("ofNode::getHeading",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::getHeading",1,"ofNode const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_getHeading",1,SWIGTYPE_p_ofNode); } result = (float)((ofNode const *)arg1)->getHeading(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_getRoll(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; float result; - SWIG_check_num_args("ofNode::getRoll",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::getRoll",1,"ofNode const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_getRoll",1,SWIGTYPE_p_ofNode); } - result = (float)((ofNode const *)arg1)->getRoll(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_getOrientationQuat(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; ofQuaternion result; - SWIG_check_num_args("ofNode::getOrientationQuat",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::getOrientationQuat",1,"ofNode const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_getOrientationQuat",1,SWIGTYPE_p_ofNode); } result = ((ofNode const *)arg1)->getOrientationQuat(); { - ofQuaternion * resultptr = new ofQuaternion((const ofQuaternion &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofQuaternion,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Node_getOrientationEuler(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; ofVec3f result; - SWIG_check_num_args("ofNode::getOrientationEuler",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::getOrientationEuler",1,"ofNode const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_getOrientationEuler",1,SWIGTYPE_p_ofNode); } result = ((ofNode const *)arg1)->getOrientationEuler(); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Node_getScale(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; ofVec3f result; - SWIG_check_num_args("ofNode::getScale",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::getScale",1,"ofNode const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_getScale",1,SWIGTYPE_p_ofNode); } - result = ((ofNode const *)arg1)->getScale(); { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Node_getLocalTransformMatrix(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; - ofMatrix4x4 *result = 0 ; SWIG_check_num_args("ofNode::getLocalTransformMatrix",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::getLocalTransformMatrix",1,"ofNode const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_getLocalTransformMatrix",1,SWIGTYPE_p_ofNode); } - result = (ofMatrix4x4 *) &((ofNode const *)arg1)->getLocalTransformMatrix(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMatrix4x4,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Node_getGlobalTransformMatrix(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; - ofMatrix4x4 result; SWIG_check_num_args("ofNode::getGlobalTransformMatrix",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::getGlobalTransformMatrix",1,"ofNode const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_getGlobalTransformMatrix",1,SWIGTYPE_p_ofNode); } - result = ((ofNode const *)arg1)->getGlobalTransformMatrix(); { - ofMatrix4x4 * resultptr = new ofMatrix4x4((const ofMatrix4x4 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Node_getGlobalPosition(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; ofVec3f result; - SWIG_check_num_args("ofNode::getGlobalPosition",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::getGlobalPosition",1,"ofNode const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_getGlobalPosition",1,SWIGTYPE_p_ofNode); } result = ((ofNode const *)arg1)->getGlobalPosition(); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Node_getGlobalOrientation(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; ofQuaternion result; - SWIG_check_num_args("ofNode::getGlobalOrientation",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::getGlobalOrientation",1,"ofNode const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_getGlobalOrientation",1,SWIGTYPE_p_ofNode); } result = ((ofNode const *)arg1)->getGlobalOrientation(); - { ofQuaternion * resultptr = new ofQuaternion((const ofQuaternion &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofQuaternion,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Node_getGlobalScale(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; ofVec3f result; - SWIG_check_num_args("ofNode::getGlobalScale",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::getGlobalScale",1,"ofNode const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_getGlobalScale",1,SWIGTYPE_p_ofNode); } result = ((ofNode const *)arg1)->getGlobalScale(); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Node_setTransformMatrix(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; ofMatrix4x4 *arg2 = 0 ; - SWIG_check_num_args("ofNode::setTransformMatrix",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::setTransformMatrix",1,"ofNode *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofNode::setTransformMatrix",2,"ofMatrix4x4 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_setTransformMatrix",1,SWIGTYPE_p_ofNode); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Node_setTransformMatrix",2,SWIGTYPE_p_ofMatrix4x4); } - (arg1)->setTransformMatrix((ofMatrix4x4 const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Node_setPosition__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; float arg2 ; - float arg3 ; float arg4 ; SWIG_check_num_args("ofNode::setPosition",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::setPosition",1,"ofNode *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofNode::setPosition",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofNode::setPosition",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofNode::setPosition",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_setPosition",1,SWIGTYPE_p_ofNode); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); (arg1)->setPosition(arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_setPosition__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; ofVec3f *arg2 = 0 ; - SWIG_check_num_args("ofNode::setPosition",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::setPosition",1,"ofNode *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofNode::setPosition",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_setPosition",1,SWIGTYPE_p_ofNode); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Node_setPosition",2,SWIGTYPE_p_ofVec3f); } (arg1)->setPosition((ofVec3f const &)*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_setPosition(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Node_setPosition__SWIG_1(L);} } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Node_setPosition__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Node_setPosition'\n" " Possible C/C++ prototypes are:\n" - " ofNode::setPosition(float,float,float)\n" " ofNode::setPosition(ofVec3f const &)\n"); lua_error(L);return 0; } -static int _wrap_Node_setGlobalPosition__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; float arg2 ; - float arg3 ; float arg4 ; SWIG_check_num_args("ofNode::setGlobalPosition",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::setGlobalPosition",1,"ofNode *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofNode::setGlobalPosition",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofNode::setGlobalPosition",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofNode::setGlobalPosition",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_setGlobalPosition",1,SWIGTYPE_p_ofNode); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); (arg1)->setGlobalPosition(arg2,arg3,arg4); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_setGlobalPosition__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; - ofVec3f *arg2 = 0 ; SWIG_check_num_args("ofNode::setGlobalPosition",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::setGlobalPosition",1,"ofNode *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofNode::setGlobalPosition",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_setGlobalPosition",1,SWIGTYPE_p_ofNode); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Node_setGlobalPosition",2,SWIGTYPE_p_ofVec3f); } (arg1)->setGlobalPosition((ofVec3f const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_setGlobalPosition(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Node_setGlobalPosition__SWIG_1(L);} } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Node_setGlobalPosition__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Node_setGlobalPosition'\n" - " Possible C/C++ prototypes are:\n" " ofNode::setGlobalPosition(float,float,float)\n" - " ofNode::setGlobalPosition(ofVec3f const &)\n"); lua_error(L);return 0; } -static int _wrap_Node_setOrientation__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; - ofQuaternion *arg2 = 0 ; SWIG_check_num_args("ofNode::setOrientation",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::setOrientation",1,"ofNode *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofNode::setOrientation",2,"ofQuaternion const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_setOrientation",1,SWIGTYPE_p_ofNode); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Node_setOrientation",2,SWIGTYPE_p_ofQuaternion); } (arg1)->setOrientation((ofQuaternion const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_setOrientation__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; ofVec3f *arg2 = 0 ; - SWIG_check_num_args("ofNode::setOrientation",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::setOrientation",1,"ofNode *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofNode::setOrientation",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_setOrientation",1,SWIGTYPE_p_ofNode); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Node_setOrientation",2,SWIGTYPE_p_ofVec3f); } (arg1)->setOrientation((ofVec3f const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_setOrientation(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Node_setOrientation__SWIG_0(L);} } } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Node_setOrientation__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Node_setOrientation'\n" - " Possible C/C++ prototypes are:\n" " ofNode::setOrientation(ofQuaternion const &)\n" - " ofNode::setOrientation(ofVec3f const &)\n"); lua_error(L);return 0; } -static int _wrap_Node_setGlobalOrientation(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; - ofQuaternion *arg2 = 0 ; SWIG_check_num_args("ofNode::setGlobalOrientation",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::setGlobalOrientation",1,"ofNode *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofNode::setGlobalOrientation",2,"ofQuaternion const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_setGlobalOrientation",1,SWIGTYPE_p_ofNode); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Node_setGlobalOrientation",2,SWIGTYPE_p_ofQuaternion); } - (arg1)->setGlobalOrientation((ofQuaternion const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Node_setScale__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; float arg2 ; - SWIG_check_num_args("ofNode::setScale",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::setScale",1,"ofNode *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofNode::setScale",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_setScale",1,SWIGTYPE_p_ofNode); } - arg2 = (float)lua_tonumber(L, 2); (arg1)->setScale(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Node_setScale__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; float arg2 ; float arg3 ; - float arg4 ; SWIG_check_num_args("ofNode::setScale",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::setScale",1,"ofNode *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofNode::setScale",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofNode::setScale",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofNode::setScale",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_setScale",1,SWIGTYPE_p_ofNode); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - (arg1)->setScale(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_setScale__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; ofVec3f *arg2 = 0 ; - SWIG_check_num_args("ofNode::setScale",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::setScale",1,"ofNode *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofNode::setScale",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_setScale",1,SWIGTYPE_p_ofNode); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Node_setScale",2,SWIGTYPE_p_ofVec3f); } (arg1)->setScale((ofVec3f const &)*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_setScale(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Node_setScale__SWIG_2(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Node_setScale__SWIG_0(L);} } } - if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Node_setScale__SWIG_1(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Node_setScale'\n" " Possible C/C++ prototypes are:\n" - " ofNode::setScale(float)\n" " ofNode::setScale(float,float,float)\n" " ofNode::setScale(ofVec3f const &)\n"); - lua_error(L);return 0; } -static int _wrap_Node_move__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; float arg2 ; float arg3 ; - float arg4 ; SWIG_check_num_args("ofNode::move",4,4) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::move",1,"ofNode *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofNode::move",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofNode::move",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofNode::move",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_move",1,SWIGTYPE_p_ofNode); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - (arg1)->move(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_move__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; ofVec3f *arg2 = 0 ; - SWIG_check_num_args("ofNode::move",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::move",1,"ofNode *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofNode::move",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_move",1,SWIGTYPE_p_ofNode); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Node_move",2,SWIGTYPE_p_ofVec3f); } - (arg1)->move((ofVec3f const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_move(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Node_move__SWIG_1(L);} } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Node_move__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Node_move'\n" " Possible C/C++ prototypes are:\n" - " ofNode::move(float,float,float)\n" " ofNode::move(ofVec3f const &)\n"); lua_error(L);return 0; } -static int _wrap_Node_truck(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; float arg2 ; - SWIG_check_num_args("ofNode::truck",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::truck",1,"ofNode *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofNode::truck",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_truck",1,SWIGTYPE_p_ofNode); } - arg2 = (float)lua_tonumber(L, 2); (arg1)->truck(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_boom(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; float arg2 ; - SWIG_check_num_args("ofNode::boom",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::boom",1,"ofNode *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofNode::boom",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_boom",1,SWIGTYPE_p_ofNode); } - arg2 = (float)lua_tonumber(L, 2); (arg1)->boom(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_dolly(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; float arg2 ; - SWIG_check_num_args("ofNode::dolly",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::dolly",1,"ofNode *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofNode::dolly",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_dolly",1,SWIGTYPE_p_ofNode); } - arg2 = (float)lua_tonumber(L, 2); (arg1)->dolly(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_tilt(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; float arg2 ; - SWIG_check_num_args("ofNode::tilt",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::tilt",1,"ofNode *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofNode::tilt",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_tilt",1,SWIGTYPE_p_ofNode); } - arg2 = (float)lua_tonumber(L, 2); (arg1)->tilt(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_pan(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; float arg2 ; - SWIG_check_num_args("ofNode::pan",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::pan",1,"ofNode *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofNode::pan",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_pan",1,SWIGTYPE_p_ofNode); } - arg2 = (float)lua_tonumber(L, 2); (arg1)->pan(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_roll(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; float arg2 ; - SWIG_check_num_args("ofNode::roll",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::roll",1,"ofNode *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofNode::roll",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_roll",1,SWIGTYPE_p_ofNode); } - arg2 = (float)lua_tonumber(L, 2); (arg1)->roll(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_rotate__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; ofQuaternion *arg2 = 0 ; - SWIG_check_num_args("ofNode::rotate",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::rotate",1,"ofNode *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofNode::rotate",2,"ofQuaternion const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_rotate",1,SWIGTYPE_p_ofNode); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Node_rotate",2,SWIGTYPE_p_ofQuaternion); } (arg1)->rotate((ofQuaternion const &)*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_rotate__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; float arg2 ; - ofVec3f *arg3 = 0 ; SWIG_check_num_args("ofNode::rotate",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::rotate",1,"ofNode *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofNode::rotate",2,"float"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofNode::rotate",3,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_rotate",1,SWIGTYPE_p_ofNode); } - arg2 = (float)lua_tonumber(L, 2); if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Node_rotate",3,SWIGTYPE_p_ofVec3f); } (arg1)->rotate(arg2,(ofVec3f const &)*arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_rotate__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; float arg2 ; float arg3 ; - float arg4 ; float arg5 ; SWIG_check_num_args("ofNode::rotate",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::rotate",1,"ofNode *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofNode::rotate",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofNode::rotate",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofNode::rotate",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofNode::rotate",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_rotate",1,SWIGTYPE_p_ofNode); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); (arg1)->rotate(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Node_rotate(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Node_rotate__SWIG_0(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Node_rotate__SWIG_1(L);} } } } if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Node_rotate__SWIG_2(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Node_rotate'\n" " Possible C/C++ prototypes are:\n" - " ofNode::rotate(ofQuaternion const &)\n" " ofNode::rotate(float,ofVec3f const &)\n" - " ofNode::rotate(float,float,float,float)\n"); lua_error(L);return 0; } -static int _wrap_Node_rotateAround__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; - ofQuaternion *arg2 = 0 ; ofVec3f *arg3 = 0 ; SWIG_check_num_args("ofNode::rotateAround",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::rotateAround",1,"ofNode *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofNode::rotateAround",2,"ofQuaternion const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofNode::rotateAround",3,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_rotateAround",1,SWIGTYPE_p_ofNode); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Node_rotateAround",2,SWIGTYPE_p_ofQuaternion); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Node_rotateAround",3,SWIGTYPE_p_ofVec3f); } - (arg1)->rotateAround((ofQuaternion const &)*arg2,(ofVec3f const &)*arg3); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Node_rotateAround__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; float arg2 ; - ofVec3f *arg3 = 0 ; ofVec3f *arg4 = 0 ; SWIG_check_num_args("ofNode::rotateAround",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::rotateAround",1,"ofNode *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofNode::rotateAround",2,"float"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofNode::rotateAround",3,"ofVec3f const &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofNode::rotateAround",4,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_rotateAround",1,SWIGTYPE_p_ofNode); } arg2 = (float)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Node_rotateAround",3,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Node_rotateAround",4,SWIGTYPE_p_ofVec3f); } - (arg1)->rotateAround(arg2,(ofVec3f const &)*arg3,(ofVec3f const &)*arg4); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Node_rotateAround(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Node_rotateAround__SWIG_0(L);} } } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Node_rotateAround__SWIG_1(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Node_rotateAround'\n" " Possible C/C++ prototypes are:\n" - " ofNode::rotateAround(ofQuaternion const &,ofVec3f const &)\n" - " ofNode::rotateAround(float,ofVec3f const &,ofVec3f const &)\n"); lua_error(L);return 0; } -static int _wrap_Node_lookAt__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; ofVec3f *arg2 = 0 ; - SWIG_check_num_args("ofNode::lookAt",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::lookAt",1,"ofNode *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofNode::lookAt",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_lookAt",1,SWIGTYPE_p_ofNode); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Node_lookAt",2,SWIGTYPE_p_ofVec3f); } - (arg1)->lookAt((ofVec3f const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_lookAt__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; ofVec3f *arg2 = 0 ; - ofVec3f arg3 ; ofVec3f *argp3 ; SWIG_check_num_args("ofNode::lookAt",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::lookAt",1,"ofNode *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofNode::lookAt",2,"ofVec3f const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofNode::lookAt",3,"ofVec3f"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_lookAt",1,SWIGTYPE_p_ofNode); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Node_lookAt",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&argp3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Node_lookAt",3,SWIGTYPE_p_ofVec3f); } arg3 = *argp3; (arg1)->lookAt((ofVec3f const &)*arg2,arg3); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_lookAt__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; ofNode *arg2 = 0 ; - SWIG_check_num_args("ofNode::lookAt",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::lookAt",1,"ofNode *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofNode::lookAt",2,"ofNode const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_lookAt",1,SWIGTYPE_p_ofNode); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_lookAt",2,SWIGTYPE_p_ofNode); } - (arg1)->lookAt((ofNode const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_lookAt__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; ofNode *arg2 = 0 ; - ofVec3f *arg3 = 0 ; SWIG_check_num_args("ofNode::lookAt",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::lookAt",1,"ofNode *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofNode::lookAt",2,"ofNode const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofNode::lookAt",3,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_lookAt",1,SWIGTYPE_p_ofNode); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_lookAt",2,SWIGTYPE_p_ofNode); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Node_lookAt",3,SWIGTYPE_p_ofVec3f); } - (arg1)->lookAt((ofNode const &)*arg2,(ofVec3f const &)*arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Node_lookAt(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Node_lookAt__SWIG_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Node_lookAt__SWIG_2(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Node_lookAt__SWIG_1(L);} } } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Node_lookAt__SWIG_3(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Node_lookAt'\n" " Possible C/C++ prototypes are:\n" - " ofNode::lookAt(ofVec3f const &)\n" " ofNode::lookAt(ofVec3f const &,ofVec3f)\n" " ofNode::lookAt(ofNode const &)\n" - " ofNode::lookAt(ofNode const &,ofVec3f const &)\n"); lua_error(L);return 0; } -static int _wrap_Node_orbit__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; float arg2 ; float arg3 ; - float arg4 ; ofVec3f *arg5 = 0 ; SWIG_check_num_args("ofNode::orbit",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::orbit",1,"ofNode *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofNode::orbit",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofNode::orbit",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofNode::orbit",4,"float"); - if(!lua_isuserdata(L,5)) SWIG_fail_arg("ofNode::orbit",5,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_orbit",1,SWIGTYPE_p_ofNode); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Node_orbit",5,SWIGTYPE_p_ofVec3f); } - (arg1)->orbit(arg2,arg3,arg4,(ofVec3f const &)*arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_orbit__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; float arg2 ; float arg3 ; - float arg4 ; SWIG_check_num_args("ofNode::orbit",4,4) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::orbit",1,"ofNode *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofNode::orbit",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofNode::orbit",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofNode::orbit",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_orbit",1,SWIGTYPE_p_ofNode); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - (arg1)->orbit(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_orbit__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; float arg2 ; float arg3 ; - float arg4 ; ofNode *arg5 = 0 ; SWIG_check_num_args("ofNode::orbit",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::orbit",1,"ofNode *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofNode::orbit",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofNode::orbit",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofNode::orbit",4,"float"); - if(!lua_isuserdata(L,5)) SWIG_fail_arg("ofNode::orbit",5,"ofNode &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_orbit",1,SWIGTYPE_p_ofNode); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_orbit",5,SWIGTYPE_p_ofNode); } - (arg1)->orbit(arg2,arg3,arg4,*arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_orbit(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 4) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Node_orbit__SWIG_1(L);} } } } } - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[4])==0 || SWIG_ConvertPtr(L,argv[4], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Node_orbit__SWIG_0(L);} } } } } } if (argc == 5) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[4])==0 || SWIG_ConvertPtr(L,argv[4], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Node_orbit__SWIG_2(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Node_orbit'\n" " Possible C/C++ prototypes are:\n" - " ofNode::orbit(float,float,float,ofVec3f const &)\n" " ofNode::orbit(float,float,float)\n" - " ofNode::orbit(float,float,float,ofNode &)\n"); lua_error(L);return 0; } -static int _wrap_Node_transformGL__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; - ofBaseRenderer *arg2 = (ofBaseRenderer *) 0 ; SWIG_check_num_args("ofNode::transformGL",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::transformGL",1,"ofNode const *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofNode::transformGL",2,"ofBaseRenderer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_transformGL",1,SWIGTYPE_p_ofNode); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBaseRenderer,0))){ - SWIG_fail_ptr("Node_transformGL",2,SWIGTYPE_p_ofBaseRenderer); } ((ofNode const *)arg1)->transformGL(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_transformGL__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; - SWIG_check_num_args("ofNode::transformGL",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::transformGL",1,"ofNode const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_transformGL",1,SWIGTYPE_p_ofNode); } ((ofNode const *)arg1)->transformGL(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_transformGL(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Node_transformGL__SWIG_1(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBaseRenderer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Node_transformGL__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Node_transformGL'\n" " Possible C/C++ prototypes are:\n" - " ofNode::transformGL(ofBaseRenderer *) const\n" " ofNode::transformGL() const\n"); lua_error(L);return 0; } -static int _wrap_Node_restoreTransformGL__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; - ofBaseRenderer *arg2 = (ofBaseRenderer *) 0 ; SWIG_check_num_args("ofNode::restoreTransformGL",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::restoreTransformGL",1,"ofNode const *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofNode::restoreTransformGL",2,"ofBaseRenderer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_restoreTransformGL",1,SWIGTYPE_p_ofNode); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBaseRenderer,0))){ - SWIG_fail_ptr("Node_restoreTransformGL",2,SWIGTYPE_p_ofBaseRenderer); } ((ofNode const *)arg1)->restoreTransformGL(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_restoreTransformGL__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; - SWIG_check_num_args("ofNode::restoreTransformGL",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::restoreTransformGL",1,"ofNode const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_restoreTransformGL",1,SWIGTYPE_p_ofNode); } ((ofNode const *)arg1)->restoreTransformGL(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_restoreTransformGL(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Node_restoreTransformGL__SWIG_1(L);} } if (argc == 2) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBaseRenderer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Node_restoreTransformGL__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Node_restoreTransformGL'\n" - " Possible C/C++ prototypes are:\n" " ofNode::restoreTransformGL(ofBaseRenderer *) const\n" - " ofNode::restoreTransformGL() const\n"); lua_error(L);return 0; } -static int _wrap_Node_resetTransform(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; - SWIG_check_num_args("ofNode::resetTransform",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::resetTransform",1,"ofNode *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_resetTransform",1,SWIGTYPE_p_ofNode); } (arg1)->resetTransform(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Node_customDraw__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; - ofBaseRenderer *arg2 = (ofBaseRenderer *) 0 ; SWIG_check_num_args("ofNode::customDraw",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::customDraw",1,"ofNode const *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofNode::customDraw",2,"ofBaseRenderer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_customDraw",1,SWIGTYPE_p_ofNode); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBaseRenderer,0))){ - SWIG_fail_ptr("Node_customDraw",2,SWIGTYPE_p_ofBaseRenderer); } - ((ofNode const *)arg1)->customDraw((ofBaseRenderer const *)arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Node_customDraw__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; - SWIG_check_num_args("ofNode::customDraw",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::customDraw",1,"ofNode *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("Node_customDraw",1,SWIGTYPE_p_ofNode); } (arg1)->customDraw(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Node_customDraw(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Node_customDraw__SWIG_1(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBaseRenderer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Node_customDraw__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Node_customDraw'\n" " Possible C/C++ prototypes are:\n" - " ofNode::customDraw(ofBaseRenderer const *) const\n" " ofNode::customDraw()\n"); lua_error(L);return 0; } -static int _wrap_Node_draw(lua_State* L) { int SWIG_arg = 0; ofNode *arg1 = (ofNode *) 0 ; - SWIG_check_num_args("ofNode::draw",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofNode::draw",1,"ofNode const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofNode,0))){ SWIG_fail_ptr("Node_draw",1,SWIGTYPE_p_ofNode); } - ((ofNode const *)arg1)->draw(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_Node(void *obj) { -ofNode *arg1 = (ofNode *) obj; -delete arg1; -} -static int _proxy__wrap_new_Node(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_Node); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_Node_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_Node_methods[]= { - { "setParent", _wrap_Node_setParent}, - { "clearParent", _wrap_Node_clearParent}, - { "getParent", _wrap_Node_getParent}, - { "getPosition", _wrap_Node_getPosition}, - { "getX", _wrap_Node_getX}, - { "getY", _wrap_Node_getY}, - { "getZ", _wrap_Node_getZ}, - { "getXAxis", _wrap_Node_getXAxis}, - { "getYAxis", _wrap_Node_getYAxis}, - { "getZAxis", _wrap_Node_getZAxis}, - { "getSideDir", _wrap_Node_getSideDir}, - { "getLookAtDir", _wrap_Node_getLookAtDir}, - { "getUpDir", _wrap_Node_getUpDir}, - { "getPitch", _wrap_Node_getPitch}, - { "getHeading", _wrap_Node_getHeading}, - { "getRoll", _wrap_Node_getRoll}, - { "getOrientationQuat", _wrap_Node_getOrientationQuat}, - { "getOrientationEuler", _wrap_Node_getOrientationEuler}, - { "getScale", _wrap_Node_getScale}, - { "getLocalTransformMatrix", _wrap_Node_getLocalTransformMatrix}, - { "getGlobalTransformMatrix", _wrap_Node_getGlobalTransformMatrix}, - { "getGlobalPosition", _wrap_Node_getGlobalPosition}, - { "getGlobalOrientation", _wrap_Node_getGlobalOrientation}, - { "getGlobalScale", _wrap_Node_getGlobalScale}, - { "setTransformMatrix", _wrap_Node_setTransformMatrix}, - { "setPosition", _wrap_Node_setPosition}, - { "setGlobalPosition", _wrap_Node_setGlobalPosition}, - { "setOrientation", _wrap_Node_setOrientation}, - { "setGlobalOrientation", _wrap_Node_setGlobalOrientation}, - { "setScale", _wrap_Node_setScale}, - { "move", _wrap_Node_move}, - { "truck", _wrap_Node_truck}, - { "boom", _wrap_Node_boom}, - { "dolly", _wrap_Node_dolly}, - { "tilt", _wrap_Node_tilt}, - { "pan", _wrap_Node_pan}, - { "roll", _wrap_Node_roll}, - { "rotate", _wrap_Node_rotate}, - { "rotateAround", _wrap_Node_rotateAround}, - { "lookAt", _wrap_Node_lookAt}, - { "orbit", _wrap_Node_orbit}, - { "transformGL", _wrap_Node_transformGL}, - { "restoreTransformGL", _wrap_Node_restoreTransformGL}, - { "resetTransform", _wrap_Node_resetTransform}, - { "customDraw", _wrap_Node_customDraw}, - { "draw", _wrap_Node_draw}, - {0,0} -}; -static swig_lua_method swig_Node_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_Node_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_Node_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_Node_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_Node_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_Node_Sf_SwigStatic = { - "Node", - swig_Node_Sf_SwigStatic_methods, - swig_Node_Sf_SwigStatic_attributes, - swig_Node_Sf_SwigStatic_constants, - swig_Node_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_Node_bases[] = {0}; -static const char *swig_Node_base_names[] = {0}; -static swig_lua_class _wrap_class_Node = { "Node", "Node", &SWIGTYPE_p_ofNode,_proxy__wrap_new_Node, swig_delete_Node, swig_Node_methods, swig_Node_attributes, &swig_Node_Sf_SwigStatic, swig_Node_meta, swig_Node_bases, swig_Node_base_names }; - -static int _wrap_drawAxis(lua_State* L) { int SWIG_arg = 0; float arg1 ; SWIG_check_num_args("ofDrawAxis",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawAxis",1,"float"); arg1 = (float)lua_tonumber(L, 1); ofDrawAxis(arg1); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawGrid__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; size_t arg2 ; bool arg3 ; bool arg4 ; - bool arg5 ; bool arg6 ; SWIG_check_num_args("ofDrawGrid",6,6) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawGrid",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawGrid",2,"size_t"); if(!lua_isboolean(L,3)) SWIG_fail_arg("ofDrawGrid",3,"bool"); - if(!lua_isboolean(L,4)) SWIG_fail_arg("ofDrawGrid",4,"bool"); if(!lua_isboolean(L,5)) SWIG_fail_arg("ofDrawGrid",5,"bool"); - if(!lua_isboolean(L,6)) SWIG_fail_arg("ofDrawGrid",6,"bool"); arg1 = (float)lua_tonumber(L, 1); - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - arg3 = (lua_toboolean(L, 3)!=0); arg4 = (lua_toboolean(L, 4)!=0); arg5 = (lua_toboolean(L, 5)!=0); - arg6 = (lua_toboolean(L, 6)!=0); ofDrawGrid(arg1,arg2,arg3,arg4,arg5,arg6); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_drawGrid__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; size_t arg2 ; bool arg3 ; bool arg4 ; - bool arg5 ; SWIG_check_num_args("ofDrawGrid",5,5) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawGrid",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawGrid",2,"size_t"); if(!lua_isboolean(L,3)) SWIG_fail_arg("ofDrawGrid",3,"bool"); - if(!lua_isboolean(L,4)) SWIG_fail_arg("ofDrawGrid",4,"bool"); if(!lua_isboolean(L,5)) SWIG_fail_arg("ofDrawGrid",5,"bool"); - arg1 = (float)lua_tonumber(L, 1); SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") - arg2 = (size_t)lua_tonumber(L, 2); arg3 = (lua_toboolean(L, 3)!=0); arg4 = (lua_toboolean(L, 4)!=0); - arg5 = (lua_toboolean(L, 5)!=0); ofDrawGrid(arg1,arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_drawGrid__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; size_t arg2 ; bool arg3 ; bool arg4 ; - SWIG_check_num_args("ofDrawGrid",4,4) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawGrid",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawGrid",2,"size_t"); if(!lua_isboolean(L,3)) SWIG_fail_arg("ofDrawGrid",3,"bool"); - if(!lua_isboolean(L,4)) SWIG_fail_arg("ofDrawGrid",4,"bool"); arg1 = (float)lua_tonumber(L, 1); - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - arg3 = (lua_toboolean(L, 3)!=0); arg4 = (lua_toboolean(L, 4)!=0); ofDrawGrid(arg1,arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawGrid__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; size_t arg2 ; bool arg3 ; - SWIG_check_num_args("ofDrawGrid",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawGrid",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawGrid",2,"size_t"); if(!lua_isboolean(L,3)) SWIG_fail_arg("ofDrawGrid",3,"bool"); - arg1 = (float)lua_tonumber(L, 1); SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") - arg2 = (size_t)lua_tonumber(L, 2); arg3 = (lua_toboolean(L, 3)!=0); ofDrawGrid(arg1,arg2,arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawGrid__SWIG_4(lua_State* L) { int SWIG_arg = 0; float arg1 ; size_t arg2 ; - SWIG_check_num_args("ofDrawGrid",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawGrid",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawGrid",2,"size_t"); arg1 = (float)lua_tonumber(L, 1); - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - ofDrawGrid(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawGrid__SWIG_5(lua_State* L) { int SWIG_arg = 0; float arg1 ; SWIG_check_num_args("ofDrawGrid",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawGrid",1,"float"); arg1 = (float)lua_tonumber(L, 1); ofDrawGrid(arg1); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawGrid__SWIG_6(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofDrawGrid",0,0) ofDrawGrid(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawGrid(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_drawGrid__SWIG_6(L);} if (argc == 1) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { - return _wrap_drawGrid__SWIG_5(L);} } if (argc == 2) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_drawGrid__SWIG_4(L);} } } if (argc == 3) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } - if (_v) { return _wrap_drawGrid__SWIG_3(L);} } } } if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { { - _v = lua_isboolean(L,argv[3]); } if (_v) { return _wrap_drawGrid__SWIG_2(L);} } } } } if (argc == 5) { int _v; - { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } - if (_v) { { _v = lua_isboolean(L,argv[3]); } if (_v) { { _v = lua_isboolean(L,argv[4]); } if (_v) { - return _wrap_drawGrid__SWIG_1(L);} } } } } } if (argc == 6) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { { - _v = lua_isboolean(L,argv[3]); } if (_v) { { _v = lua_isboolean(L,argv[4]); } if (_v) { { - _v = lua_isboolean(L,argv[5]); } if (_v) { return _wrap_drawGrid__SWIG_0(L);} } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'drawGrid'\n" " Possible C/C++ prototypes are:\n" - " ofDrawGrid(float,size_t,bool,bool,bool,bool)\n" " ofDrawGrid(float,size_t,bool,bool,bool)\n" - " ofDrawGrid(float,size_t,bool,bool)\n" " ofDrawGrid(float,size_t,bool)\n" " ofDrawGrid(float,size_t)\n" - " ofDrawGrid(float)\n" " ofDrawGrid()\n"); lua_error(L);return 0; } -static int _wrap_drawGridPlane__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; size_t arg2 ; bool arg3 ; - SWIG_check_num_args("ofDrawGridPlane",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawGridPlane",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawGridPlane",2,"size_t"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofDrawGridPlane",3,"bool"); arg1 = (float)lua_tonumber(L, 1); - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - arg3 = (lua_toboolean(L, 3)!=0); ofDrawGridPlane(arg1,arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_drawGridPlane__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; size_t arg2 ; - SWIG_check_num_args("ofDrawGridPlane",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawGridPlane",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawGridPlane",2,"size_t"); arg1 = (float)lua_tonumber(L, 1); - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - ofDrawGridPlane(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawGridPlane__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; SWIG_check_num_args("ofDrawGridPlane",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawGridPlane",1,"float"); arg1 = (float)lua_tonumber(L, 1); ofDrawGridPlane(arg1); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawGridPlane__SWIG_3(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofDrawGridPlane",0,0) - ofDrawGridPlane(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawGridPlane(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_drawGridPlane__SWIG_3(L);} if (argc == 1) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { - return _wrap_drawGridPlane__SWIG_2(L);} } if (argc == 2) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_drawGridPlane__SWIG_1(L);} } } if (argc == 3) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } - if (_v) { return _wrap_drawGridPlane__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'drawGridPlane'\n" " Possible C/C++ prototypes are:\n" - " ofDrawGridPlane(float,size_t,bool)\n" " ofDrawGridPlane(float,size_t)\n" " ofDrawGridPlane(float)\n" - " ofDrawGridPlane()\n"); lua_error(L);return 0; } -static int _wrap_drawArrow__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = 0 ; ofVec3f *arg2 = 0 ; float arg3 ; - SWIG_check_num_args("ofDrawArrow",3,3) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofDrawArrow",1,"ofVec3f const &"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofDrawArrow",2,"ofVec3f const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawArrow",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("drawArrow",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("drawArrow",2,SWIGTYPE_p_ofVec3f); } - arg3 = (float)lua_tonumber(L, 3); ofDrawArrow((ofVec3f const &)*arg1,(ofVec3f const &)*arg2,arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawArrow__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = 0 ; ofVec3f *arg2 = 0 ; - SWIG_check_num_args("ofDrawArrow",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofDrawArrow",1,"ofVec3f const &"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofDrawArrow",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("drawArrow",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("drawArrow",2,SWIGTYPE_p_ofVec3f); } - ofDrawArrow((ofVec3f const &)*arg1,(ofVec3f const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_drawArrow(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_drawArrow__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_drawArrow__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'drawArrow'\n" " Possible C/C++ prototypes are:\n" - " ofDrawArrow(ofVec3f const &,ofVec3f const &,float)\n" " ofDrawArrow(ofVec3f const &,ofVec3f const &)\n"); - lua_error(L);return 0; } -static int _wrap_drawRotationAxes__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; int arg3 ; - SWIG_check_num_args("ofDrawRotationAxes",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawRotationAxes",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawRotationAxes",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawRotationAxes",3,"int"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); ofDrawRotationAxes(arg1,arg2,arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawRotationAxes__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; - SWIG_check_num_args("ofDrawRotationAxes",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawRotationAxes",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawRotationAxes",2,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); ofDrawRotationAxes(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_drawRotationAxes__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; - SWIG_check_num_args("ofDrawRotationAxes",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawRotationAxes",1,"float"); - arg1 = (float)lua_tonumber(L, 1); ofDrawRotationAxes(arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_drawRotationAxes(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_drawRotationAxes__SWIG_2(L);} } if (argc == 2) { int _v; - { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_drawRotationAxes__SWIG_1(L);} } } if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { - { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_drawRotationAxes__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'drawRotationAxes'\n" " Possible C/C++ prototypes are:\n" - " ofDrawRotationAxes(float,float,int)\n" " ofDrawRotationAxes(float,float)\n" " ofDrawRotationAxes(float)\n"); - lua_error(L);return 0; } -static int _wrap_new_Camera(lua_State* L) { int SWIG_arg = 0; ofCamera *result = 0 ; - SWIG_check_num_args("ofCamera::ofCamera",0,0) result = (ofCamera *)new ofCamera(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofCamera,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Camera_setFov(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; float arg2 ; - SWIG_check_num_args("ofCamera::setFov",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::setFov",1,"ofCamera *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofCamera::setFov",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_setFov",1,SWIGTYPE_p_ofCamera); } arg2 = (float)lua_tonumber(L, 2); (arg1)->setFov(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Camera_setNearClip(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; float arg2 ; - SWIG_check_num_args("ofCamera::setNearClip",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::setNearClip",1,"ofCamera *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofCamera::setNearClip",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_setNearClip",1,SWIGTYPE_p_ofCamera); } arg2 = (float)lua_tonumber(L, 2); (arg1)->setNearClip(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Camera_setFarClip(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; float arg2 ; - SWIG_check_num_args("ofCamera::setFarClip",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::setFarClip",1,"ofCamera *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofCamera::setFarClip",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_setFarClip",1,SWIGTYPE_p_ofCamera); } arg2 = (float)lua_tonumber(L, 2); (arg1)->setFarClip(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Camera_setLensOffset(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; ofVec2f *arg2 = 0 ; - SWIG_check_num_args("ofCamera::setLensOffset",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::setLensOffset",1,"ofCamera *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofCamera::setLensOffset",2,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_setLensOffset",1,SWIGTYPE_p_ofCamera); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Camera_setLensOffset",2,SWIGTYPE_p_ofVec2f); } (arg1)->setLensOffset((ofVec2f const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Camera_setAspectRatio(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; float arg2 ; - SWIG_check_num_args("ofCamera::setAspectRatio",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::setAspectRatio",1,"ofCamera *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofCamera::setAspectRatio",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_setAspectRatio",1,SWIGTYPE_p_ofCamera); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setAspectRatio(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Camera_setForceAspectRatio(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; bool arg2 ; - SWIG_check_num_args("ofCamera::setForceAspectRatio",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::setForceAspectRatio",1,"ofCamera *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofCamera::setForceAspectRatio",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_setForceAspectRatio",1,SWIGTYPE_p_ofCamera); } arg2 = (lua_toboolean(L, 2)!=0); - (arg1)->setForceAspectRatio(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Camera_getFov(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; float result; - SWIG_check_num_args("ofCamera::getFov",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::getFov",1,"ofCamera const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_getFov",1,SWIGTYPE_p_ofCamera); } result = (float)((ofCamera const *)arg1)->getFov(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Camera_getNearClip(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; float result; - SWIG_check_num_args("ofCamera::getNearClip",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::getNearClip",1,"ofCamera const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_getNearClip",1,SWIGTYPE_p_ofCamera); } result = (float)((ofCamera const *)arg1)->getNearClip(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Camera_getFarClip(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; float result; - SWIG_check_num_args("ofCamera::getFarClip",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::getFarClip",1,"ofCamera const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_getFarClip",1,SWIGTYPE_p_ofCamera); } result = (float)((ofCamera const *)arg1)->getFarClip(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Camera_getLensOffset(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; ofVec2f result; - SWIG_check_num_args("ofCamera::getLensOffset",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::getLensOffset",1,"ofCamera const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_getLensOffset",1,SWIGTYPE_p_ofCamera); } result = ((ofCamera const *)arg1)->getLensOffset(); { - ofVec2f * resultptr = new ofVec2f((const ofVec2f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Camera_getForceAspectRatio(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; bool result; - SWIG_check_num_args("ofCamera::getForceAspectRatio",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::getForceAspectRatio",1,"ofCamera const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_getForceAspectRatio",1,SWIGTYPE_p_ofCamera); } - result = (bool)((ofCamera const *)arg1)->getForceAspectRatio(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Camera_getAspectRatio(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; float result; - SWIG_check_num_args("ofCamera::getAspectRatio",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::getAspectRatio",1,"ofCamera const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_getAspectRatio",1,SWIGTYPE_p_ofCamera); } result = (float)((ofCamera const *)arg1)->getAspectRatio(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Camera_setupPerspective__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; bool arg2 ; - float arg3 ; float arg4 ; float arg5 ; ofVec2f *arg6 = 0 ; SWIG_check_num_args("ofCamera::setupPerspective",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::setupPerspective",1,"ofCamera *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofCamera::setupPerspective",2,"bool"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofCamera::setupPerspective",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofCamera::setupPerspective",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofCamera::setupPerspective",5,"float"); - if(!lua_isuserdata(L,6)) SWIG_fail_arg("ofCamera::setupPerspective",6,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_setupPerspective",1,SWIGTYPE_p_ofCamera); } arg2 = (lua_toboolean(L, 2)!=0); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,6,(void**)&arg6,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Camera_setupPerspective",6,SWIGTYPE_p_ofVec2f); } - (arg1)->setupPerspective(arg2,arg3,arg4,arg5,(ofVec2f const &)*arg6); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Camera_setupPerspective__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; bool arg2 ; - float arg3 ; float arg4 ; float arg5 ; SWIG_check_num_args("ofCamera::setupPerspective",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::setupPerspective",1,"ofCamera *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofCamera::setupPerspective",2,"bool"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofCamera::setupPerspective",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofCamera::setupPerspective",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofCamera::setupPerspective",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_setupPerspective",1,SWIGTYPE_p_ofCamera); } arg2 = (lua_toboolean(L, 2)!=0); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - (arg1)->setupPerspective(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Camera_setupPerspective__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; bool arg2 ; - float arg3 ; float arg4 ; SWIG_check_num_args("ofCamera::setupPerspective",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::setupPerspective",1,"ofCamera *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofCamera::setupPerspective",2,"bool"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofCamera::setupPerspective",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofCamera::setupPerspective",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_setupPerspective",1,SWIGTYPE_p_ofCamera); } arg2 = (lua_toboolean(L, 2)!=0); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); (arg1)->setupPerspective(arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Camera_setupPerspective__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; bool arg2 ; - float arg3 ; SWIG_check_num_args("ofCamera::setupPerspective",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::setupPerspective",1,"ofCamera *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofCamera::setupPerspective",2,"bool"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofCamera::setupPerspective",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_setupPerspective",1,SWIGTYPE_p_ofCamera); } arg2 = (lua_toboolean(L, 2)!=0); - arg3 = (float)lua_tonumber(L, 3); (arg1)->setupPerspective(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Camera_setupPerspective__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; bool arg2 ; - SWIG_check_num_args("ofCamera::setupPerspective",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::setupPerspective",1,"ofCamera *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofCamera::setupPerspective",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_setupPerspective",1,SWIGTYPE_p_ofCamera); } arg2 = (lua_toboolean(L, 2)!=0); - (arg1)->setupPerspective(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Camera_setupPerspective__SWIG_5(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; - SWIG_check_num_args("ofCamera::setupPerspective",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::setupPerspective",1,"ofCamera *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_setupPerspective",1,SWIGTYPE_p_ofCamera); } (arg1)->setupPerspective(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Camera_setupPerspective(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); - if (argc == 1) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCamera, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Camera_setupPerspective__SWIG_5(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCamera, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_Camera_setupPerspective__SWIG_4(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCamera, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Camera_setupPerspective__SWIG_3(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCamera, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Camera_setupPerspective__SWIG_2(L);} } } } } - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCamera, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Camera_setupPerspective__SWIG_1(L);} } } } } } if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCamera, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[5])==0 || SWIG_ConvertPtr(L,argv[5], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Camera_setupPerspective__SWIG_0(L);} } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Camera_setupPerspective'\n" - " Possible C/C++ prototypes are:\n" " ofCamera::setupPerspective(bool,float,float,float,ofVec2f const &)\n" - " ofCamera::setupPerspective(bool,float,float,float)\n" " ofCamera::setupPerspective(bool,float,float)\n" - " ofCamera::setupPerspective(bool,float)\n" " ofCamera::setupPerspective(bool)\n" " ofCamera::setupPerspective()\n"); - lua_error(L);return 0; } -static int _wrap_Camera_setupOffAxisViewPortal(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; - ofVec3f *arg2 = 0 ; ofVec3f *arg3 = 0 ; ofVec3f *arg4 = 0 ; SWIG_check_num_args("ofCamera::setupOffAxisViewPortal",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::setupOffAxisViewPortal",1,"ofCamera *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofCamera::setupOffAxisViewPortal",2,"ofVec3f const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofCamera::setupOffAxisViewPortal",3,"ofVec3f const &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofCamera::setupOffAxisViewPortal",4,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_setupOffAxisViewPortal",1,SWIGTYPE_p_ofCamera); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Camera_setupOffAxisViewPortal",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Camera_setupOffAxisViewPortal",3,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Camera_setupOffAxisViewPortal",4,SWIGTYPE_p_ofVec3f); } - (arg1)->setupOffAxisViewPortal((ofVec3f const &)*arg2,(ofVec3f const &)*arg3,(ofVec3f const &)*arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Camera_setVFlip(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; bool arg2 ; - SWIG_check_num_args("ofCamera::setVFlip",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::setVFlip",1,"ofCamera *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofCamera::setVFlip",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_setVFlip",1,SWIGTYPE_p_ofCamera); } arg2 = (lua_toboolean(L, 2)!=0); (arg1)->setVFlip(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Camera_isVFlipped(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; bool result; - SWIG_check_num_args("ofCamera::isVFlipped",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::isVFlipped",1,"ofCamera const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_isVFlipped",1,SWIGTYPE_p_ofCamera); } result = (bool)((ofCamera const *)arg1)->isVFlipped(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Camera_enableOrtho(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; - SWIG_check_num_args("ofCamera::enableOrtho",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::enableOrtho",1,"ofCamera *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_enableOrtho",1,SWIGTYPE_p_ofCamera); } (arg1)->enableOrtho(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Camera_disableOrtho(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; - SWIG_check_num_args("ofCamera::disableOrtho",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::disableOrtho",1,"ofCamera *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_disableOrtho",1,SWIGTYPE_p_ofCamera); } (arg1)->disableOrtho(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Camera_getOrtho(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; bool result; - SWIG_check_num_args("ofCamera::getOrtho",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::getOrtho",1,"ofCamera const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_getOrtho",1,SWIGTYPE_p_ofCamera); } result = (bool)((ofCamera const *)arg1)->getOrtho(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Camera_getImagePlaneDistance__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; - ofRectangle arg2 ; ofRectangle *argp2 ; float result; SWIG_check_num_args("ofCamera::getImagePlaneDistance",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::getImagePlaneDistance",1,"ofCamera const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofCamera::getImagePlaneDistance",2,"ofRectangle"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_getImagePlaneDistance",1,SWIGTYPE_p_ofCamera); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Camera_getImagePlaneDistance",2,SWIGTYPE_p_ofRectangle); } arg2 = *argp2; - result = (float)((ofCamera const *)arg1)->getImagePlaneDistance(arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Camera_getImagePlaneDistance__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; - float result; SWIG_check_num_args("ofCamera::getImagePlaneDistance",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::getImagePlaneDistance",1,"ofCamera const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_getImagePlaneDistance",1,SWIGTYPE_p_ofCamera); } - result = (float)((ofCamera const *)arg1)->getImagePlaneDistance(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Camera_getImagePlaneDistance(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); - if (argc == 1) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCamera, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Camera_getImagePlaneDistance__SWIG_1(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCamera, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Camera_getImagePlaneDistance__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Camera_getImagePlaneDistance'\n" - " Possible C/C++ prototypes are:\n" " ofCamera::getImagePlaneDistance(ofRectangle) const\n" - " ofCamera::getImagePlaneDistance() const\n"); lua_error(L);return 0; } -static int _wrap_Camera_beginCamera__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; - ofRectangle arg2 ; ofRectangle *argp2 ; SWIG_check_num_args("ofCamera::begin",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::begin",1,"ofCamera *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofCamera::begin",2,"ofRectangle"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_beginCamera",1,SWIGTYPE_p_ofCamera); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Camera_beginCamera",2,SWIGTYPE_p_ofRectangle); } arg2 = *argp2; (arg1)->begin(arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Camera_beginCamera__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; - SWIG_check_num_args("ofCamera::begin",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::begin",1,"ofCamera *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_beginCamera",1,SWIGTYPE_p_ofCamera); } (arg1)->begin(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Camera_beginCamera(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCamera, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Camera_beginCamera__SWIG_1(L);} } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCamera, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Camera_beginCamera__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Camera_beginCamera'\n" " Possible C/C++ prototypes are:\n" - " ofCamera::begin(ofRectangle)\n" " ofCamera::begin()\n"); lua_error(L);return 0; } -static int _wrap_Camera_endCamera(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; - SWIG_check_num_args("ofCamera::end",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::end",1,"ofCamera *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_endCamera",1,SWIGTYPE_p_ofCamera); } (arg1)->end(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Camera_getProjectionMatrix__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; - ofRectangle arg2 ; ofRectangle *argp2 ; ofMatrix4x4 result; SWIG_check_num_args("ofCamera::getProjectionMatrix",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::getProjectionMatrix",1,"ofCamera const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofCamera::getProjectionMatrix",2,"ofRectangle"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_getProjectionMatrix",1,SWIGTYPE_p_ofCamera); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Camera_getProjectionMatrix",2,SWIGTYPE_p_ofRectangle); } arg2 = *argp2; - result = ((ofCamera const *)arg1)->getProjectionMatrix(arg2); { - ofMatrix4x4 * resultptr = new ofMatrix4x4((const ofMatrix4x4 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Camera_getProjectionMatrix__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; - ofMatrix4x4 result; SWIG_check_num_args("ofCamera::getProjectionMatrix",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::getProjectionMatrix",1,"ofCamera const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_getProjectionMatrix",1,SWIGTYPE_p_ofCamera); } - result = ((ofCamera const *)arg1)->getProjectionMatrix(); { - ofMatrix4x4 * resultptr = new ofMatrix4x4((const ofMatrix4x4 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Camera_getProjectionMatrix(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); - if (argc == 1) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCamera, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Camera_getProjectionMatrix__SWIG_1(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCamera, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Camera_getProjectionMatrix__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Camera_getProjectionMatrix'\n" - " Possible C/C++ prototypes are:\n" " ofCamera::getProjectionMatrix(ofRectangle) const\n" - " ofCamera::getProjectionMatrix() const\n"); lua_error(L);return 0; } -static int _wrap_Camera_getModelViewMatrix(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; - ofMatrix4x4 result; SWIG_check_num_args("ofCamera::getModelViewMatrix",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::getModelViewMatrix",1,"ofCamera const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_getModelViewMatrix",1,SWIGTYPE_p_ofCamera); } - result = ((ofCamera const *)arg1)->getModelViewMatrix(); { - ofMatrix4x4 * resultptr = new ofMatrix4x4((const ofMatrix4x4 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Camera_getModelViewProjectionMatrix__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; - ofRectangle arg2 ; ofRectangle *argp2 ; ofMatrix4x4 result; SWIG_check_num_args("ofCamera::getModelViewProjectionMatrix",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::getModelViewProjectionMatrix",1,"ofCamera const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofCamera::getModelViewProjectionMatrix",2,"ofRectangle"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_getModelViewProjectionMatrix",1,SWIGTYPE_p_ofCamera); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Camera_getModelViewProjectionMatrix",2,SWIGTYPE_p_ofRectangle); } arg2 = *argp2; - result = ((ofCamera const *)arg1)->getModelViewProjectionMatrix(arg2); { - ofMatrix4x4 * resultptr = new ofMatrix4x4((const ofMatrix4x4 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Camera_getModelViewProjectionMatrix__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; - ofMatrix4x4 result; SWIG_check_num_args("ofCamera::getModelViewProjectionMatrix",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::getModelViewProjectionMatrix",1,"ofCamera const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_getModelViewProjectionMatrix",1,SWIGTYPE_p_ofCamera); } - result = ((ofCamera const *)arg1)->getModelViewProjectionMatrix(); { - ofMatrix4x4 * resultptr = new ofMatrix4x4((const ofMatrix4x4 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Camera_getModelViewProjectionMatrix(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); - if (argc == 1) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCamera, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Camera_getModelViewProjectionMatrix__SWIG_1(L);} } if (argc == 2) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCamera, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Camera_getModelViewProjectionMatrix__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Camera_getModelViewProjectionMatrix'\n" - " Possible C/C++ prototypes are:\n" " ofCamera::getModelViewProjectionMatrix(ofRectangle) const\n" - " ofCamera::getModelViewProjectionMatrix() const\n"); lua_error(L);return 0; } -static int _wrap_Camera_worldToScreen__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; ofVec3f arg2 ; - ofRectangle arg3 ; ofVec3f *argp2 ; ofRectangle *argp3 ; ofVec3f result; SWIG_check_num_args("ofCamera::worldToScreen",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::worldToScreen",1,"ofCamera const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofCamera::worldToScreen",2,"ofVec3f"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofCamera::worldToScreen",3,"ofRectangle"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_worldToScreen",1,SWIGTYPE_p_ofCamera); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Camera_worldToScreen",2,SWIGTYPE_p_ofVec3f); } arg2 = *argp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&argp3,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Camera_worldToScreen",3,SWIGTYPE_p_ofRectangle); } arg3 = *argp3; - result = ((ofCamera const *)arg1)->worldToScreen(arg2,arg3); { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Camera_worldToScreen__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; ofVec3f arg2 ; - ofVec3f *argp2 ; ofVec3f result; SWIG_check_num_args("ofCamera::worldToScreen",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::worldToScreen",1,"ofCamera const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofCamera::worldToScreen",2,"ofVec3f"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_worldToScreen",1,SWIGTYPE_p_ofCamera); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Camera_worldToScreen",2,SWIGTYPE_p_ofVec3f); } arg2 = *argp2; - result = ((ofCamera const *)arg1)->worldToScreen(arg2); { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Camera_worldToScreen(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCamera, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Camera_worldToScreen__SWIG_1(L);} } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCamera, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Camera_worldToScreen__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Camera_worldToScreen'\n" - " Possible C/C++ prototypes are:\n" " ofCamera::worldToScreen(ofVec3f,ofRectangle) const\n" - " ofCamera::worldToScreen(ofVec3f) const\n"); lua_error(L);return 0; } -static int _wrap_Camera_screenToWorld__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; ofVec3f arg2 ; - ofRectangle arg3 ; ofVec3f *argp2 ; ofRectangle *argp3 ; ofVec3f result; SWIG_check_num_args("ofCamera::screenToWorld",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::screenToWorld",1,"ofCamera const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofCamera::screenToWorld",2,"ofVec3f"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofCamera::screenToWorld",3,"ofRectangle"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_screenToWorld",1,SWIGTYPE_p_ofCamera); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Camera_screenToWorld",2,SWIGTYPE_p_ofVec3f); } arg2 = *argp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&argp3,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Camera_screenToWorld",3,SWIGTYPE_p_ofRectangle); } arg3 = *argp3; - result = ((ofCamera const *)arg1)->screenToWorld(arg2,arg3); { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Camera_screenToWorld__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; ofVec3f arg2 ; - ofVec3f *argp2 ; ofVec3f result; SWIG_check_num_args("ofCamera::screenToWorld",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::screenToWorld",1,"ofCamera const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofCamera::screenToWorld",2,"ofVec3f"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_screenToWorld",1,SWIGTYPE_p_ofCamera); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Camera_screenToWorld",2,SWIGTYPE_p_ofVec3f); } arg2 = *argp2; - result = ((ofCamera const *)arg1)->screenToWorld(arg2); { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Camera_screenToWorld(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCamera, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Camera_screenToWorld__SWIG_1(L);} } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCamera, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Camera_screenToWorld__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Camera_screenToWorld'\n" - " Possible C/C++ prototypes are:\n" " ofCamera::screenToWorld(ofVec3f,ofRectangle) const\n" - " ofCamera::screenToWorld(ofVec3f) const\n"); lua_error(L);return 0; } -static int _wrap_Camera_worldToCamera__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; ofVec3f arg2 ; - ofRectangle arg3 ; ofVec3f *argp2 ; ofRectangle *argp3 ; ofVec3f result; SWIG_check_num_args("ofCamera::worldToCamera",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::worldToCamera",1,"ofCamera const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofCamera::worldToCamera",2,"ofVec3f"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofCamera::worldToCamera",3,"ofRectangle"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_worldToCamera",1,SWIGTYPE_p_ofCamera); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Camera_worldToCamera",2,SWIGTYPE_p_ofVec3f); } arg2 = *argp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&argp3,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Camera_worldToCamera",3,SWIGTYPE_p_ofRectangle); } arg3 = *argp3; - result = ((ofCamera const *)arg1)->worldToCamera(arg2,arg3); { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Camera_worldToCamera__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; ofVec3f arg2 ; - ofVec3f *argp2 ; ofVec3f result; SWIG_check_num_args("ofCamera::worldToCamera",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::worldToCamera",1,"ofCamera const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofCamera::worldToCamera",2,"ofVec3f"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_worldToCamera",1,SWIGTYPE_p_ofCamera); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Camera_worldToCamera",2,SWIGTYPE_p_ofVec3f); } arg2 = *argp2; - result = ((ofCamera const *)arg1)->worldToCamera(arg2); { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Camera_worldToCamera(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCamera, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Camera_worldToCamera__SWIG_1(L);} } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCamera, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Camera_worldToCamera__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Camera_worldToCamera'\n" - " Possible C/C++ prototypes are:\n" " ofCamera::worldToCamera(ofVec3f,ofRectangle) const\n" - " ofCamera::worldToCamera(ofVec3f) const\n"); lua_error(L);return 0; } -static int _wrap_Camera_cameraToWorld__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; ofVec3f arg2 ; - ofRectangle arg3 ; ofVec3f *argp2 ; ofRectangle *argp3 ; ofVec3f result; SWIG_check_num_args("ofCamera::cameraToWorld",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::cameraToWorld",1,"ofCamera const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofCamera::cameraToWorld",2,"ofVec3f"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofCamera::cameraToWorld",3,"ofRectangle"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_cameraToWorld",1,SWIGTYPE_p_ofCamera); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Camera_cameraToWorld",2,SWIGTYPE_p_ofVec3f); } arg2 = *argp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&argp3,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Camera_cameraToWorld",3,SWIGTYPE_p_ofRectangle); } arg3 = *argp3; - result = ((ofCamera const *)arg1)->cameraToWorld(arg2,arg3); { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Camera_cameraToWorld__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; ofVec3f arg2 ; - ofVec3f *argp2 ; ofVec3f result; SWIG_check_num_args("ofCamera::cameraToWorld",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::cameraToWorld",1,"ofCamera const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofCamera::cameraToWorld",2,"ofVec3f"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_cameraToWorld",1,SWIGTYPE_p_ofCamera); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Camera_cameraToWorld",2,SWIGTYPE_p_ofVec3f); } arg2 = *argp2; - result = ((ofCamera const *)arg1)->cameraToWorld(arg2); { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Camera_cameraToWorld(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCamera, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Camera_cameraToWorld__SWIG_1(L);} } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCamera, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Camera_cameraToWorld__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Camera_cameraToWorld'\n" - " Possible C/C++ prototypes are:\n" " ofCamera::cameraToWorld(ofVec3f,ofRectangle) const\n" - " ofCamera::cameraToWorld(ofVec3f) const\n"); lua_error(L);return 0; } -static int _wrap_Camera_setRenderer(lua_State* L) { int SWIG_arg = 0; ofCamera *arg1 = (ofCamera *) 0 ; - SwigValueWrapper< shared_ptr< ofBaseRenderer > > arg2 ; shared_ptr< ofBaseRenderer > *argp2 ; - SWIG_check_num_args("ofCamera::setRenderer",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCamera::setRenderer",1,"ofCamera *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofCamera::setRenderer",2,"shared_ptr< ofBaseRenderer >"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCamera,0))){ - SWIG_fail_ptr("Camera_setRenderer",1,SWIGTYPE_p_ofCamera); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_shared_ptrT_ofBaseRenderer_t,0))){ - SWIG_fail_ptr("Camera_setRenderer",2,SWIGTYPE_p_shared_ptrT_ofBaseRenderer_t); } arg2 = *argp2; (arg1)->setRenderer(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_Camera(void *obj) { -ofCamera *arg1 = (ofCamera *) obj; -delete arg1; -} -static int _proxy__wrap_new_Camera(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_Camera); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_Camera_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_Camera_methods[]= { - { "setFov", _wrap_Camera_setFov}, - { "setNearClip", _wrap_Camera_setNearClip}, - { "setFarClip", _wrap_Camera_setFarClip}, - { "setLensOffset", _wrap_Camera_setLensOffset}, - { "setAspectRatio", _wrap_Camera_setAspectRatio}, - { "setForceAspectRatio", _wrap_Camera_setForceAspectRatio}, - { "getFov", _wrap_Camera_getFov}, - { "getNearClip", _wrap_Camera_getNearClip}, - { "getFarClip", _wrap_Camera_getFarClip}, - { "getLensOffset", _wrap_Camera_getLensOffset}, - { "getForceAspectRatio", _wrap_Camera_getForceAspectRatio}, - { "getAspectRatio", _wrap_Camera_getAspectRatio}, - { "setupPerspective", _wrap_Camera_setupPerspective}, - { "setupOffAxisViewPortal", _wrap_Camera_setupOffAxisViewPortal}, - { "setVFlip", _wrap_Camera_setVFlip}, - { "isVFlipped", _wrap_Camera_isVFlipped}, - { "enableOrtho", _wrap_Camera_enableOrtho}, - { "disableOrtho", _wrap_Camera_disableOrtho}, - { "getOrtho", _wrap_Camera_getOrtho}, - { "getImagePlaneDistance", _wrap_Camera_getImagePlaneDistance}, - { "beginCamera", _wrap_Camera_beginCamera}, - { "endCamera", _wrap_Camera_endCamera}, - { "getProjectionMatrix", _wrap_Camera_getProjectionMatrix}, - { "getModelViewMatrix", _wrap_Camera_getModelViewMatrix}, - { "getModelViewProjectionMatrix", _wrap_Camera_getModelViewProjectionMatrix}, - { "worldToScreen", _wrap_Camera_worldToScreen}, - { "screenToWorld", _wrap_Camera_screenToWorld}, - { "worldToCamera", _wrap_Camera_worldToCamera}, - { "cameraToWorld", _wrap_Camera_cameraToWorld}, - { "setRenderer", _wrap_Camera_setRenderer}, - {0,0} -}; -static swig_lua_method swig_Camera_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_Camera_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_Camera_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_Camera_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_Camera_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_Camera_Sf_SwigStatic = { - "Camera", - swig_Camera_Sf_SwigStatic_methods, - swig_Camera_Sf_SwigStatic_attributes, - swig_Camera_Sf_SwigStatic_constants, - swig_Camera_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_Camera_bases[] = {0,0}; -static const char *swig_Camera_base_names[] = {"ofNode *",0}; -static swig_lua_class _wrap_class_Camera = { "Camera", "Camera", &SWIGTYPE_p_ofCamera,_proxy__wrap_new_Camera, swig_delete_Camera, swig_Camera_methods, swig_Camera_attributes, &swig_Camera_Sf_SwigStatic, swig_Camera_meta, swig_Camera_bases, swig_Camera_base_names }; - -static int _wrap_new_EasyCam(lua_State* L) { int SWIG_arg = 0; ofEasyCam *result = 0 ; - SWIG_check_num_args("ofEasyCam::ofEasyCam",0,0) result = (ofEasyCam *)new ofEasyCam(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofEasyCam,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_EasyCam_beginCamera__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofEasyCam *arg1 = (ofEasyCam *) 0 ; - ofRectangle arg2 ; ofRectangle *argp2 ; SWIG_check_num_args("ofEasyCam::begin",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofEasyCam::begin",1,"ofEasyCam *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofEasyCam::begin",2,"ofRectangle"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofEasyCam,0))){ - SWIG_fail_ptr("EasyCam_beginCamera",1,SWIGTYPE_p_ofEasyCam); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("EasyCam_beginCamera",2,SWIGTYPE_p_ofRectangle); } arg2 = *argp2; (arg1)->begin(arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_EasyCam_beginCamera__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofEasyCam *arg1 = (ofEasyCam *) 0 ; - SWIG_check_num_args("ofEasyCam::begin",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofEasyCam::begin",1,"ofEasyCam *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofEasyCam,0))){ - SWIG_fail_ptr("EasyCam_beginCamera",1,SWIGTYPE_p_ofEasyCam); } (arg1)->begin(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_EasyCam_beginCamera(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofEasyCam, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_EasyCam_beginCamera__SWIG_1(L);} } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofEasyCam, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_EasyCam_beginCamera__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'EasyCam_beginCamera'\n" - " Possible C/C++ prototypes are:\n" " ofEasyCam::begin(ofRectangle)\n" " ofEasyCam::begin()\n"); - lua_error(L);return 0; } -static int _wrap_EasyCam_reset(lua_State* L) { int SWIG_arg = 0; ofEasyCam *arg1 = (ofEasyCam *) 0 ; - SWIG_check_num_args("ofEasyCam::reset",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofEasyCam::reset",1,"ofEasyCam *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofEasyCam,0))){ - SWIG_fail_ptr("EasyCam_reset",1,SWIGTYPE_p_ofEasyCam); } (arg1)->reset(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_EasyCam_setTarget__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofEasyCam *arg1 = (ofEasyCam *) 0 ; - ofVec3f *arg2 = 0 ; SWIG_check_num_args("ofEasyCam::setTarget",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofEasyCam::setTarget",1,"ofEasyCam *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofEasyCam::setTarget",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofEasyCam,0))){ - SWIG_fail_ptr("EasyCam_setTarget",1,SWIGTYPE_p_ofEasyCam); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("EasyCam_setTarget",2,SWIGTYPE_p_ofVec3f); } (arg1)->setTarget((ofVec3f const &)*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_EasyCam_setTarget__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofEasyCam *arg1 = (ofEasyCam *) 0 ; - ofNode *arg2 = 0 ; SWIG_check_num_args("ofEasyCam::setTarget",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofEasyCam::setTarget",1,"ofEasyCam *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofEasyCam::setTarget",2,"ofNode &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofEasyCam,0))){ - SWIG_fail_ptr("EasyCam_setTarget",1,SWIGTYPE_p_ofEasyCam); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofNode,0))){ - SWIG_fail_ptr("EasyCam_setTarget",2,SWIGTYPE_p_ofNode); } (arg1)->setTarget(*arg2); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_EasyCam_setTarget(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofEasyCam, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_EasyCam_setTarget__SWIG_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofEasyCam, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofNode, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_EasyCam_setTarget__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'EasyCam_setTarget'\n" " Possible C/C++ prototypes are:\n" - " ofEasyCam::setTarget(ofVec3f const &)\n" " ofEasyCam::setTarget(ofNode &)\n"); lua_error(L);return 0; } -static int _wrap_EasyCam_getTarget(lua_State* L) { int SWIG_arg = 0; ofEasyCam *arg1 = (ofEasyCam *) 0 ; ofNode *result = 0 ; - SWIG_check_num_args("ofEasyCam::getTarget",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofEasyCam::getTarget",1,"ofEasyCam *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofEasyCam,0))){ - SWIG_fail_ptr("EasyCam_getTarget",1,SWIGTYPE_p_ofEasyCam); } result = (ofNode *) &(arg1)->getTarget(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofNode,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_EasyCam_setDistance(lua_State* L) { int SWIG_arg = 0; ofEasyCam *arg1 = (ofEasyCam *) 0 ; float arg2 ; - SWIG_check_num_args("ofEasyCam::setDistance",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofEasyCam::setDistance",1,"ofEasyCam *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofEasyCam::setDistance",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofEasyCam,0))){ - SWIG_fail_ptr("EasyCam_setDistance",1,SWIGTYPE_p_ofEasyCam); } arg2 = (float)lua_tonumber(L, 2); (arg1)->setDistance(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_EasyCam_getDistance(lua_State* L) { int SWIG_arg = 0; ofEasyCam *arg1 = (ofEasyCam *) 0 ; float result; - SWIG_check_num_args("ofEasyCam::getDistance",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofEasyCam::getDistance",1,"ofEasyCam const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofEasyCam,0))){ - SWIG_fail_ptr("EasyCam_getDistance",1,SWIGTYPE_p_ofEasyCam); } result = (float)((ofEasyCam const *)arg1)->getDistance(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_EasyCam_setDrag(lua_State* L) { int SWIG_arg = 0; ofEasyCam *arg1 = (ofEasyCam *) 0 ; float arg2 ; - SWIG_check_num_args("ofEasyCam::setDrag",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofEasyCam::setDrag",1,"ofEasyCam *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofEasyCam::setDrag",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofEasyCam,0))){ - SWIG_fail_ptr("EasyCam_setDrag",1,SWIGTYPE_p_ofEasyCam); } arg2 = (float)lua_tonumber(L, 2); (arg1)->setDrag(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_EasyCam_getDrag(lua_State* L) { int SWIG_arg = 0; ofEasyCam *arg1 = (ofEasyCam *) 0 ; float result; - SWIG_check_num_args("ofEasyCam::getDrag",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofEasyCam::getDrag",1,"ofEasyCam const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofEasyCam,0))){ - SWIG_fail_ptr("EasyCam_getDrag",1,SWIGTYPE_p_ofEasyCam); } result = (float)((ofEasyCam const *)arg1)->getDrag(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_EasyCam_setAutoDistance(lua_State* L) { int SWIG_arg = 0; ofEasyCam *arg1 = (ofEasyCam *) 0 ; bool arg2 ; - SWIG_check_num_args("ofEasyCam::setAutoDistance",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofEasyCam::setAutoDistance",1,"ofEasyCam *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofEasyCam::setAutoDistance",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofEasyCam,0))){ - SWIG_fail_ptr("EasyCam_setAutoDistance",1,SWIGTYPE_p_ofEasyCam); } arg2 = (lua_toboolean(L, 2)!=0); - (arg1)->setAutoDistance(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_EasyCam_setEvents(lua_State* L) { int SWIG_arg = 0; ofEasyCam *arg1 = (ofEasyCam *) 0 ; - ofCoreEvents *arg2 = 0 ; SWIG_check_num_args("ofEasyCam::setEvents",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofEasyCam::setEvents",1,"ofEasyCam *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofEasyCam::setEvents",2,"ofCoreEvents &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofEasyCam,0))){ - SWIG_fail_ptr("EasyCam_setEvents",1,SWIGTYPE_p_ofEasyCam); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofCoreEvents,0))){ - SWIG_fail_ptr("EasyCam_setEvents",2,SWIGTYPE_p_ofCoreEvents); } (arg1)->setEvents(*arg2); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_EasyCam_setTranslationKey(lua_State* L) { int SWIG_arg = 0; ofEasyCam *arg1 = (ofEasyCam *) 0 ; char arg2 ; - SWIG_check_num_args("ofEasyCam::setTranslationKey",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofEasyCam::setTranslationKey",1,"ofEasyCam *"); - if(!SWIG_lua_isnilstring(L,2)) SWIG_fail_arg("ofEasyCam::setTranslationKey",2,"char"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofEasyCam,0))){ - SWIG_fail_ptr("EasyCam_setTranslationKey",1,SWIGTYPE_p_ofEasyCam); } arg2 = (lua_tostring(L, 2))[0]; - (arg1)->setTranslationKey(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_EasyCam_getTranslationKey(lua_State* L) { int SWIG_arg = 0; ofEasyCam *arg1 = (ofEasyCam *) 0 ; char result; - SWIG_check_num_args("ofEasyCam::getTranslationKey",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofEasyCam::getTranslationKey",1,"ofEasyCam *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofEasyCam,0))){ - SWIG_fail_ptr("EasyCam_getTranslationKey",1,SWIGTYPE_p_ofEasyCam); } result = (char)(arg1)->getTranslationKey(); - lua_pushlstring(L, &result, 1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_EasyCam_enableMouseInput(lua_State* L) { int SWIG_arg = 0; ofEasyCam *arg1 = (ofEasyCam *) 0 ; - SWIG_check_num_args("ofEasyCam::enableMouseInput",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofEasyCam::enableMouseInput",1,"ofEasyCam *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofEasyCam,0))){ - SWIG_fail_ptr("EasyCam_enableMouseInput",1,SWIGTYPE_p_ofEasyCam); } (arg1)->enableMouseInput(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_EasyCam_disableMouseInput(lua_State* L) { int SWIG_arg = 0; ofEasyCam *arg1 = (ofEasyCam *) 0 ; - SWIG_check_num_args("ofEasyCam::disableMouseInput",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofEasyCam::disableMouseInput",1,"ofEasyCam *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofEasyCam,0))){ - SWIG_fail_ptr("EasyCam_disableMouseInput",1,SWIGTYPE_p_ofEasyCam); } (arg1)->disableMouseInput(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_EasyCam_getMouseInputEnabled(lua_State* L) { int SWIG_arg = 0; ofEasyCam *arg1 = (ofEasyCam *) 0 ; bool result; - SWIG_check_num_args("ofEasyCam::getMouseInputEnabled",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofEasyCam::getMouseInputEnabled",1,"ofEasyCam *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofEasyCam,0))){ - SWIG_fail_ptr("EasyCam_getMouseInputEnabled",1,SWIGTYPE_p_ofEasyCam); } result = (bool)(arg1)->getMouseInputEnabled(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_EasyCam_enableMouseMiddleButton(lua_State* L) { int SWIG_arg = 0; ofEasyCam *arg1 = (ofEasyCam *) 0 ; - SWIG_check_num_args("ofEasyCam::enableMouseMiddleButton",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofEasyCam::enableMouseMiddleButton",1,"ofEasyCam *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofEasyCam,0))){ - SWIG_fail_ptr("EasyCam_enableMouseMiddleButton",1,SWIGTYPE_p_ofEasyCam); } (arg1)->enableMouseMiddleButton(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_EasyCam_disableMouseMiddleButton(lua_State* L) { int SWIG_arg = 0; ofEasyCam *arg1 = (ofEasyCam *) 0 ; - SWIG_check_num_args("ofEasyCam::disableMouseMiddleButton",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofEasyCam::disableMouseMiddleButton",1,"ofEasyCam *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofEasyCam,0))){ - SWIG_fail_ptr("EasyCam_disableMouseMiddleButton",1,SWIGTYPE_p_ofEasyCam); } (arg1)->disableMouseMiddleButton(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_EasyCam_getMouseMiddleButtonEnabled(lua_State* L) { int SWIG_arg = 0; ofEasyCam *arg1 = (ofEasyCam *) 0 ; - bool result; SWIG_check_num_args("ofEasyCam::getMouseMiddleButtonEnabled",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofEasyCam::getMouseMiddleButtonEnabled",1,"ofEasyCam *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofEasyCam,0))){ - SWIG_fail_ptr("EasyCam_getMouseMiddleButtonEnabled",1,SWIGTYPE_p_ofEasyCam); } - result = (bool)(arg1)->getMouseMiddleButtonEnabled(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_EasyCam(void *obj) { -ofEasyCam *arg1 = (ofEasyCam *) obj; -delete arg1; -} -static int _proxy__wrap_new_EasyCam(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_EasyCam); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_EasyCam_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_EasyCam_methods[]= { - { "beginCamera", _wrap_EasyCam_beginCamera}, - { "reset", _wrap_EasyCam_reset}, - { "setTarget", _wrap_EasyCam_setTarget}, - { "getTarget", _wrap_EasyCam_getTarget}, - { "setDistance", _wrap_EasyCam_setDistance}, - { "getDistance", _wrap_EasyCam_getDistance}, - { "setDrag", _wrap_EasyCam_setDrag}, - { "getDrag", _wrap_EasyCam_getDrag}, - { "setAutoDistance", _wrap_EasyCam_setAutoDistance}, - { "setEvents", _wrap_EasyCam_setEvents}, - { "setTranslationKey", _wrap_EasyCam_setTranslationKey}, - { "getTranslationKey", _wrap_EasyCam_getTranslationKey}, - { "enableMouseInput", _wrap_EasyCam_enableMouseInput}, - { "disableMouseInput", _wrap_EasyCam_disableMouseInput}, - { "getMouseInputEnabled", _wrap_EasyCam_getMouseInputEnabled}, - { "enableMouseMiddleButton", _wrap_EasyCam_enableMouseMiddleButton}, - { "disableMouseMiddleButton", _wrap_EasyCam_disableMouseMiddleButton}, - { "getMouseMiddleButtonEnabled", _wrap_EasyCam_getMouseMiddleButtonEnabled}, - {0,0} -}; -static swig_lua_method swig_EasyCam_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_EasyCam_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_EasyCam_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_EasyCam_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_EasyCam_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_EasyCam_Sf_SwigStatic = { - "EasyCam", - swig_EasyCam_Sf_SwigStatic_methods, - swig_EasyCam_Sf_SwigStatic_attributes, - swig_EasyCam_Sf_SwigStatic_constants, - swig_EasyCam_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_EasyCam_bases[] = {0,0}; -static const char *swig_EasyCam_base_names[] = {"ofCamera *",0}; -static swig_lua_class _wrap_class_EasyCam = { "EasyCam", "EasyCam", &SWIGTYPE_p_ofEasyCam,_proxy__wrap_new_EasyCam, swig_delete_EasyCam, swig_EasyCam_methods, swig_EasyCam_attributes, &swig_EasyCam_Sf_SwigStatic, swig_EasyCam_meta, swig_EasyCam_bases, swig_EasyCam_base_names }; - -static int _wrap_new_Mesh__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMesh *result = 0 ; - SWIG_check_num_args("ofMesh::ofMesh",0,0) result = (ofMesh *)new ofMesh(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMesh,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Mesh__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPrimitiveMode arg1 ; std::vector< ofVec3f > *arg2 = 0 ; - ofMesh *result = 0 ; SWIG_check_num_args("ofMesh::ofMesh",2,2) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh::ofMesh",1,"ofPrimitiveMode"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMesh::ofMesh",2,"std::vector< ofVec3f > const &"); - arg1 = (ofPrimitiveMode)(int)lua_tonumber(L, 1); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__vectorT_ofVec3f_t,0))){ - SWIG_fail_ptr("new_Mesh",2,SWIGTYPE_p_std__vectorT_ofVec3f_t); } - result = (ofMesh *)new ofMesh(arg1,(std::vector< ofVec3f > const &)*arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMesh,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Mesh(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_Mesh__SWIG_0(L);} if (argc == 2) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_std__vectorT_ofVec3f_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_new_Mesh__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_Mesh'\n" " Possible C/C++ prototypes are:\n" - " ofMesh::ofMesh()\n" " ofMesh::ofMesh(ofPrimitiveMode,std::vector< ofVec3f > const &)\n"); lua_error(L);return 0; } -static int _wrap_Mesh_setFromTriangles__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - std::vector< ofMeshFace > *arg2 = 0 ; bool arg3 ; SWIG_check_num_args("ofMesh::setFromTriangles",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::setFromTriangles",1,"ofMesh *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMesh::setFromTriangles",2,"std::vector< ofMeshFace > const &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofMesh::setFromTriangles",3,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_setFromTriangles",1,SWIGTYPE_p_ofMesh); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__vectorT_ofMeshFace_t,0))){ - SWIG_fail_ptr("Mesh_setFromTriangles",2,SWIGTYPE_p_std__vectorT_ofMeshFace_t); } arg3 = (lua_toboolean(L, 3)!=0); - (arg1)->setFromTriangles((std::vector< ofMeshFace > const &)*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Mesh_setFromTriangles__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - std::vector< ofMeshFace > *arg2 = 0 ; SWIG_check_num_args("ofMesh::setFromTriangles",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::setFromTriangles",1,"ofMesh *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMesh::setFromTriangles",2,"std::vector< ofMeshFace > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_setFromTriangles",1,SWIGTYPE_p_ofMesh); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__vectorT_ofMeshFace_t,0))){ - SWIG_fail_ptr("Mesh_setFromTriangles",2,SWIGTYPE_p_std__vectorT_ofMeshFace_t); } - (arg1)->setFromTriangles((std::vector< ofMeshFace > const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Mesh_setFromTriangles(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_std__vectorT_ofMeshFace_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Mesh_setFromTriangles__SWIG_1(L);} } } if (argc == 3) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_std__vectorT_ofMeshFace_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - return _wrap_Mesh_setFromTriangles__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_setFromTriangles'\n" - " Possible C/C++ prototypes are:\n" " ofMesh::setFromTriangles(std::vector< ofMeshFace > const &,bool)\n" - " ofMesh::setFromTriangles(std::vector< ofMeshFace > const &)\n"); lua_error(L);return 0; } -static int _wrap_Mesh_setMode(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; ofPrimitiveMode arg2 ; - SWIG_check_num_args("ofMesh::setMode",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::setMode",1,"ofMesh *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::setMode",2,"ofPrimitiveMode"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Mesh_setMode",1,SWIGTYPE_p_ofMesh); } - arg2 = (ofPrimitiveMode)(int)lua_tonumber(L, 2); (arg1)->setMode(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Mesh_getMode(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; ofPrimitiveMode result; - SWIG_check_num_args("ofMesh::getMode",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getMode",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Mesh_getMode",1,SWIGTYPE_p_ofMesh); } - result = (ofPrimitiveMode)((ofMesh const *)arg1)->getMode(); lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_plane__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; int arg3 ; int arg4 ; - ofPrimitiveMode arg5 ; ofMesh result; SWIG_check_num_args("ofMesh::plane",5,5) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh::plane",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::plane",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh::plane",3,"int"); if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMesh::plane",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMesh::plane",5,"ofPrimitiveMode"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - arg5 = (ofPrimitiveMode)(int)lua_tonumber(L, 5); result = ofMesh::plane(arg1,arg2,arg3,arg4,arg5); { - ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_plane__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; int arg3 ; int arg4 ; - ofMesh result; SWIG_check_num_args("ofMesh::plane",4,4) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh::plane",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::plane",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh::plane",3,"int"); if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMesh::plane",4,"int"); - arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); result = ofMesh::plane(arg1,arg2,arg3,arg4); { - ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_plane__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; int arg3 ; ofMesh result; - SWIG_check_num_args("ofMesh::plane",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh::plane",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::plane",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh::plane",3,"int"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); result = ofMesh::plane(arg1,arg2,arg3); { - ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_plane__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; ofMesh result; - SWIG_check_num_args("ofMesh::plane",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh::plane",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::plane",2,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); result = ofMesh::plane(arg1,arg2); { - ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_plane(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Mesh_plane__SWIG_3(L);} } } if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Mesh_plane__SWIG_2(L);} } } } if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Mesh_plane__SWIG_1(L);} } } } } if (argc == 5) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Mesh_plane__SWIG_0(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_plane'\n" " Possible C/C++ prototypes are:\n" - " ofMesh::plane(float,float,int,int,ofPrimitiveMode)\n" " ofMesh::plane(float,float,int,int)\n" - " ofMesh::plane(float,float,int)\n" " ofMesh::plane(float,float)\n"); lua_error(L);return 0; } -static int _wrap_Mesh_sphere__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; int arg2 ; ofPrimitiveMode arg3 ; - ofMesh result; SWIG_check_num_args("ofMesh::sphere",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh::sphere",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::sphere",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh::sphere",3,"ofPrimitiveMode"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (int)lua_tonumber(L, 2); arg3 = (ofPrimitiveMode)(int)lua_tonumber(L, 3); result = ofMesh::sphere(arg1,arg2,arg3); { - ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_sphere__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; int arg2 ; ofMesh result; - SWIG_check_num_args("ofMesh::sphere",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh::sphere",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::sphere",2,"int"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (int)lua_tonumber(L, 2); result = ofMesh::sphere(arg1,arg2); { - ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_sphere__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; ofMesh result; - SWIG_check_num_args("ofMesh::sphere",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh::sphere",1,"float"); - arg1 = (float)lua_tonumber(L, 1); result = ofMesh::sphere(arg1); { ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_sphere(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_Mesh_sphere__SWIG_2(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Mesh_sphere__SWIG_1(L);} } } if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Mesh_sphere__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_sphere'\n" " Possible C/C++ prototypes are:\n" - " ofMesh::sphere(float,int,ofPrimitiveMode)\n" " ofMesh::sphere(float,int)\n" " ofMesh::sphere(float)\n"); - lua_error(L);return 0; } -static int _wrap_Mesh_icosahedron(lua_State* L) { int SWIG_arg = 0; float arg1 ; ofMesh result; - SWIG_check_num_args("ofMesh::icosahedron",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh::icosahedron",1,"float"); - arg1 = (float)lua_tonumber(L, 1); result = ofMesh::icosahedron(arg1); { - ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_icosphere__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; std::size_t arg2 ; ofMesh result; - SWIG_check_num_args("ofMesh::icosphere",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh::icosphere",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::icosphere",2,"std::size_t"); arg1 = (float)lua_tonumber(L, 1); - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (std::size_t)lua_tonumber(L, 2); - result = ofMesh::icosphere(arg1,arg2); { ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_icosphere__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; ofMesh result; - SWIG_check_num_args("ofMesh::icosphere",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh::icosphere",1,"float"); - arg1 = (float)lua_tonumber(L, 1); result = ofMesh::icosphere(arg1); { - ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_icosphere(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; - { _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_Mesh_icosphere__SWIG_1(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Mesh_icosphere__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_icosphere'\n" " Possible C/C++ prototypes are:\n" - " ofMesh::icosphere(float,std::size_t)\n" " ofMesh::icosphere(float)\n"); lua_error(L);return 0; } -static int _wrap_Mesh_cylinder__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; int arg3 ; int arg4 ; - int arg5 ; bool arg6 ; ofPrimitiveMode arg7 ; ofMesh result; SWIG_check_num_args("ofMesh::cylinder",7,7) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh::cylinder",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::cylinder",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh::cylinder",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMesh::cylinder",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMesh::cylinder",5,"int"); - if(!lua_isboolean(L,6)) SWIG_fail_arg("ofMesh::cylinder",6,"bool"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofMesh::cylinder",7,"ofPrimitiveMode"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - arg5 = (int)lua_tonumber(L, 5); arg6 = (lua_toboolean(L, 6)!=0); arg7 = (ofPrimitiveMode)(int)lua_tonumber(L, 7); - result = ofMesh::cylinder(arg1,arg2,arg3,arg4,arg5,arg6,arg7); { ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_cylinder__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; int arg3 ; int arg4 ; - int arg5 ; bool arg6 ; ofMesh result; SWIG_check_num_args("ofMesh::cylinder",6,6) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh::cylinder",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::cylinder",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh::cylinder",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMesh::cylinder",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMesh::cylinder",5,"int"); - if(!lua_isboolean(L,6)) SWIG_fail_arg("ofMesh::cylinder",6,"bool"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - arg5 = (int)lua_tonumber(L, 5); arg6 = (lua_toboolean(L, 6)!=0); result = ofMesh::cylinder(arg1,arg2,arg3,arg4,arg5,arg6); { - ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_cylinder__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; int arg3 ; int arg4 ; - int arg5 ; ofMesh result; SWIG_check_num_args("ofMesh::cylinder",5,5) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh::cylinder",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::cylinder",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh::cylinder",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMesh::cylinder",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMesh::cylinder",5,"int"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - arg5 = (int)lua_tonumber(L, 5); result = ofMesh::cylinder(arg1,arg2,arg3,arg4,arg5); { - ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_cylinder__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; int arg3 ; int arg4 ; - ofMesh result; SWIG_check_num_args("ofMesh::cylinder",4,4) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh::cylinder",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::cylinder",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh::cylinder",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMesh::cylinder",4,"int"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - result = ofMesh::cylinder(arg1,arg2,arg3,arg4); { ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_cylinder__SWIG_4(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; int arg3 ; ofMesh result; - SWIG_check_num_args("ofMesh::cylinder",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh::cylinder",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::cylinder",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh::cylinder",3,"int"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); result = ofMesh::cylinder(arg1,arg2,arg3); { - ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_cylinder__SWIG_5(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; ofMesh result; - SWIG_check_num_args("ofMesh::cylinder",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh::cylinder",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::cylinder",2,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); result = ofMesh::cylinder(arg1,arg2); { - ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_cylinder(lua_State* L) { int argc; int argv[8]={ 1,2,3,4,5,6,7,8} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Mesh_cylinder__SWIG_5(L);} } } if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Mesh_cylinder__SWIG_4(L);} } } } if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Mesh_cylinder__SWIG_3(L);} } } } } if (argc == 5) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_Mesh_cylinder__SWIG_2(L);} } } } } } - if (argc == 6) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isboolean(L,argv[5]); } if (_v) { - return _wrap_Mesh_cylinder__SWIG_1(L);} } } } } } } if (argc == 7) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isboolean(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { - return _wrap_Mesh_cylinder__SWIG_0(L);} } } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_cylinder'\n" " Possible C/C++ prototypes are:\n" - " ofMesh::cylinder(float,float,int,int,int,bool,ofPrimitiveMode)\n" " ofMesh::cylinder(float,float,int,int,int,bool)\n" - " ofMesh::cylinder(float,float,int,int,int)\n" " ofMesh::cylinder(float,float,int,int)\n" - " ofMesh::cylinder(float,float,int)\n" " ofMesh::cylinder(float,float)\n"); lua_error(L);return 0; } -static int _wrap_Mesh_cone__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; int arg3 ; int arg4 ; int arg5 ; - ofPrimitiveMode arg6 ; ofMesh result; SWIG_check_num_args("ofMesh::cone",6,6) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh::cone",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::cone",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh::cone",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMesh::cone",4,"int"); if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMesh::cone",5,"int"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofMesh::cone",6,"ofPrimitiveMode"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - arg5 = (int)lua_tonumber(L, 5); arg6 = (ofPrimitiveMode)(int)lua_tonumber(L, 6); - result = ofMesh::cone(arg1,arg2,arg3,arg4,arg5,arg6); { ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_cone__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; int arg3 ; int arg4 ; int arg5 ; - ofMesh result; SWIG_check_num_args("ofMesh::cone",5,5) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh::cone",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::cone",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh::cone",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMesh::cone",4,"int"); if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMesh::cone",5,"int"); - arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); result = ofMesh::cone(arg1,arg2,arg3,arg4,arg5); { - ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_cone__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; int arg3 ; int arg4 ; - ofMesh result; SWIG_check_num_args("ofMesh::cone",4,4) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh::cone",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::cone",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh::cone",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMesh::cone",4,"int"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - result = ofMesh::cone(arg1,arg2,arg3,arg4); { ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_cone__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; int arg3 ; ofMesh result; - SWIG_check_num_args("ofMesh::cone",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh::cone",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::cone",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh::cone",3,"int"); - arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); - result = ofMesh::cone(arg1,arg2,arg3); { ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_cone__SWIG_4(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; ofMesh result; - SWIG_check_num_args("ofMesh::cone",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh::cone",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::cone",2,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); result = ofMesh::cone(arg1,arg2); { - ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_cone(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Mesh_cone__SWIG_4(L);} } } if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Mesh_cone__SWIG_3(L);} } } } if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Mesh_cone__SWIG_2(L);} } } } } if (argc == 5) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Mesh_cone__SWIG_1(L);} } } } } } if (argc == 6) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { return _wrap_Mesh_cone__SWIG_0(L);} } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_cone'\n" " Possible C/C++ prototypes are:\n" - " ofMesh::cone(float,float,int,int,int,ofPrimitiveMode)\n" " ofMesh::cone(float,float,int,int,int)\n" - " ofMesh::cone(float,float,int,int)\n" " ofMesh::cone(float,float,int)\n" " ofMesh::cone(float,float)\n"); - lua_error(L);return 0; } -static int _wrap_Mesh_box__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; int arg4 ; int arg5 ; - int arg6 ; ofMesh result; SWIG_check_num_args("ofMesh::box",6,6) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh::box",1,"float"); if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::box",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh::box",3,"float"); if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMesh::box",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMesh::box",5,"int"); if(!lua_isnumber(L,6)) SWIG_fail_arg("ofMesh::box",6,"int"); - arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); arg6 = (int)lua_tonumber(L, 6); - result = ofMesh::box(arg1,arg2,arg3,arg4,arg5,arg6); { ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_box__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; int arg4 ; int arg5 ; - ofMesh result; SWIG_check_num_args("ofMesh::box",5,5) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh::box",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::box",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh::box",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMesh::box",4,"int"); if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMesh::box",5,"int"); - arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); result = ofMesh::box(arg1,arg2,arg3,arg4,arg5); { - ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_box__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; int arg4 ; - ofMesh result; SWIG_check_num_args("ofMesh::box",4,4) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh::box",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::box",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh::box",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMesh::box",4,"int"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - result = ofMesh::box(arg1,arg2,arg3,arg4); { ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_box__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; ofMesh result; - SWIG_check_num_args("ofMesh::box",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh::box",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::box",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh::box",3,"float"); - arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - result = ofMesh::box(arg1,arg2,arg3); { ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_box(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Mesh_box__SWIG_3(L);} } } } if (argc == 4) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Mesh_box__SWIG_2(L);} } } } } if (argc == 5) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_Mesh_box__SWIG_1(L);} } } } } } if (argc == 6) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { - return _wrap_Mesh_box__SWIG_0(L);} } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_box'\n" " Possible C/C++ prototypes are:\n" - " ofMesh::box(float,float,float,int,int,int)\n" " ofMesh::box(float,float,float,int,int)\n" - " ofMesh::box(float,float,float,int)\n" " ofMesh::box(float,float,float)\n"); lua_error(L);return 0; } -static int _wrap_Mesh_axis__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; ofMesh result; - SWIG_check_num_args("ofMesh::axis",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMesh::axis",1,"float"); - arg1 = (float)lua_tonumber(L, 1); result = ofMesh::axis(arg1); { ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_axis__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMesh result; SWIG_check_num_args("ofMesh::axis",0,0) - result = ofMesh::axis(); { ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_axis(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_Mesh_axis__SWIG_1(L);} if (argc == 1) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { - return _wrap_Mesh_axis__SWIG_0(L);} } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_axis'\n" - " Possible C/C++ prototypes are:\n" " ofMesh::axis(float)\n" " ofMesh::axis()\n"); lua_error(L);return 0; } -static int _wrap_Mesh_addVertex(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; ofVec3f *arg2 = 0 ; - SWIG_check_num_args("ofMesh::addVertex",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::addVertex",1,"ofMesh *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMesh::addVertex",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Mesh_addVertex",1,SWIGTYPE_p_ofMesh); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Mesh_addVertex",2,SWIGTYPE_p_ofVec3f); } (arg1)->addVertex((ofVec3f const &)*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_addVertices__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - std::vector< ofVec3f > *arg2 = 0 ; SWIG_check_num_args("ofMesh::addVertices",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::addVertices",1,"ofMesh *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMesh::addVertices",2,"std::vector< ofVec3f > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_addVertices",1,SWIGTYPE_p_ofMesh); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__vectorT_ofVec3f_t,0))){ - SWIG_fail_ptr("Mesh_addVertices",2,SWIGTYPE_p_std__vectorT_ofVec3f_t); } - (arg1)->addVertices((std::vector< ofVec3f > const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Mesh_addVertices__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - ofVec3f *arg2 = (ofVec3f *) 0 ; std::size_t arg3 ; SWIG_check_num_args("ofMesh::addVertices",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::addVertices",1,"ofMesh *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofMesh::addVertices",2,"ofVec3f const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh::addVertices",3,"std::size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_addVertices",1,SWIGTYPE_p_ofMesh); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Mesh_addVertices",2,SWIGTYPE_p_ofVec3f); } - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (std::size_t)lua_tonumber(L, 3); - (arg1)->addVertices((ofVec3f const *)arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_addVertices(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_std__vectorT_ofVec3f_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Mesh_addVertices__SWIG_0(L);} } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Mesh_addVertices__SWIG_1(L);} - } } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_addVertices'\n" - " Possible C/C++ prototypes are:\n" " ofMesh::addVertices(std::vector< ofVec3f > const &)\n" - " ofMesh::addVertices(ofVec3f const *,std::size_t)\n"); lua_error(L);return 0; } -static int _wrap_Mesh_removeVertex(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; ofIndexType arg2 ; - SWIG_check_num_args("ofMesh::removeVertex",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::removeVertex",1,"ofMesh *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::removeVertex",2,"ofIndexType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_removeVertex",1,SWIGTYPE_p_ofMesh); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); - (arg1)->removeVertex(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_setVertex(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; ofIndexType arg2 ; - ofVec3f *arg3 = 0 ; SWIG_check_num_args("ofMesh::setVertex",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::setVertex",1,"ofMesh *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::setVertex",2,"ofIndexType"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofMesh::setVertex",3,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Mesh_setVertex",1,SWIGTYPE_p_ofMesh); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Mesh_setVertex",3,SWIGTYPE_p_ofVec3f); } (arg1)->setVertex(arg2,(ofVec3f const &)*arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_clearVertices(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - SWIG_check_num_args("ofMesh::clearVertices",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::clearVertices",1,"ofMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_clearVertices",1,SWIGTYPE_p_ofMesh); } (arg1)->clearVertices(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_clear(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - SWIG_check_num_args("ofMesh::clear",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::clear",1,"ofMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Mesh_clear",1,SWIGTYPE_p_ofMesh); } - (arg1)->clear(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getNumVertices(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; std::size_t result; - SWIG_check_num_args("ofMesh::getNumVertices",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getNumVertices",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_getNumVertices",1,SWIGTYPE_p_ofMesh); } result = (std::size_t)((ofMesh const *)arg1)->getNumVertices(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getVerticesPointer__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - ofVec3f *result = 0 ; SWIG_check_num_args("ofMesh::getVerticesPointer",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getVerticesPointer",1,"ofMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_getVerticesPointer",1,SWIGTYPE_p_ofMesh); } result = (ofVec3f *)(arg1)->getVerticesPointer(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Mesh_getVerticesPointer__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - ofVec3f *result = 0 ; SWIG_check_num_args("ofMesh::getVerticesPointer",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getVerticesPointer",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_getVerticesPointer",1,SWIGTYPE_p_ofMesh); } - result = (ofVec3f *)((ofMesh const *)arg1)->getVerticesPointer(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Mesh_getVerticesPointer(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Mesh_getVerticesPointer__SWIG_0(L);} } if (argc == 1) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Mesh_getVerticesPointer__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_getVerticesPointer'\n" - " Possible C/C++ prototypes are:\n" " ofMesh::getVerticesPointer()\n" " ofMesh::getVerticesPointer() const\n"); - lua_error(L);return 0; } -static int _wrap_Mesh_getVertex(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; ofIndexType arg2 ; - ofVec3f result; SWIG_check_num_args("ofMesh::getVertex",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getVertex",1,"ofMesh const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::getVertex",2,"ofIndexType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Mesh_getVertex",1,SWIGTYPE_p_ofMesh); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); - result = ((ofMesh const *)arg1)->getVertex(arg2); { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getVertices__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - std::vector< ofVec3f > *result = 0 ; SWIG_check_num_args("ofMesh::getVertices",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getVertices",1,"ofMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_getVertices",1,SWIGTYPE_p_ofMesh); } result = (std::vector< ofVec3f > *) &(arg1)->getVertices(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofVec3f_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getVertices__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - std::vector< ofVec3f > *result = 0 ; SWIG_check_num_args("ofMesh::getVertices",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getVertices",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_getVertices",1,SWIGTYPE_p_ofMesh); } - result = (std::vector< ofVec3f > *) &((ofMesh const *)arg1)->getVertices(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofVec3f_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getVertices(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Mesh_getVertices__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Mesh_getVertices__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_getVertices'\n" " Possible C/C++ prototypes are:\n" - " ofMesh::getVertices()\n" " ofMesh::getVertices() const\n"); lua_error(L);return 0; } -static int _wrap_Mesh_haveVertsChanged(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; bool result; - SWIG_check_num_args("ofMesh::haveVertsChanged",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::haveVertsChanged",1,"ofMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_haveVertsChanged",1,SWIGTYPE_p_ofMesh); } result = (bool)(arg1)->haveVertsChanged(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_hasVertices(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; bool result; - SWIG_check_num_args("ofMesh::hasVertices",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::hasVertices",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_hasVertices",1,SWIGTYPE_p_ofMesh); } result = (bool)((ofMesh const *)arg1)->hasVertices(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_append(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; ofMesh *arg2 = 0 ; - SWIG_check_num_args("ofMesh::append",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::append",1,"ofMesh *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMesh::append",2,"ofMesh const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Mesh_append",1,SWIGTYPE_p_ofMesh); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Mesh_append",2,SWIGTYPE_p_ofMesh); } - (arg1)->append((ofMesh const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_mergeDuplicateVertices(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - SWIG_check_num_args("ofMesh::mergeDuplicateVertices",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::mergeDuplicateVertices",1,"ofMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_mergeDuplicateVertices",1,SWIGTYPE_p_ofMesh); } (arg1)->mergeDuplicateVertices(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getCentroid(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; ofVec3f result; - SWIG_check_num_args("ofMesh::getCentroid",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getCentroid",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_getCentroid",1,SWIGTYPE_p_ofMesh); } result = ((ofMesh const *)arg1)->getCentroid(); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getNormal(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; ofIndexType arg2 ; - ofVec3f result; SWIG_check_num_args("ofMesh::getNormal",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getNormal",1,"ofMesh const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::getNormal",2,"ofIndexType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Mesh_getNormal",1,SWIGTYPE_p_ofMesh); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); - result = ((ofMesh const *)arg1)->getNormal(arg2); { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_addNormal(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; ofVec3f *arg2 = 0 ; - SWIG_check_num_args("ofMesh::addNormal",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::addNormal",1,"ofMesh *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMesh::addNormal",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Mesh_addNormal",1,SWIGTYPE_p_ofMesh); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Mesh_addNormal",2,SWIGTYPE_p_ofVec3f); } (arg1)->addNormal((ofVec3f const &)*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_addNormals__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - std::vector< ofVec3f > *arg2 = 0 ; SWIG_check_num_args("ofMesh::addNormals",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::addNormals",1,"ofMesh *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMesh::addNormals",2,"std::vector< ofVec3f > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_addNormals",1,SWIGTYPE_p_ofMesh); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__vectorT_ofVec3f_t,0))){ - SWIG_fail_ptr("Mesh_addNormals",2,SWIGTYPE_p_std__vectorT_ofVec3f_t); } - (arg1)->addNormals((std::vector< ofVec3f > const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Mesh_addNormals__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - ofVec3f *arg2 = (ofVec3f *) 0 ; std::size_t arg3 ; SWIG_check_num_args("ofMesh::addNormals",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::addNormals",1,"ofMesh *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofMesh::addNormals",2,"ofVec3f const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh::addNormals",3,"std::size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_addNormals",1,SWIGTYPE_p_ofMesh); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Mesh_addNormals",2,SWIGTYPE_p_ofVec3f); } - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (std::size_t)lua_tonumber(L, 3); - (arg1)->addNormals((ofVec3f const *)arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_addNormals(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_std__vectorT_ofVec3f_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Mesh_addNormals__SWIG_0(L);} } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Mesh_addNormals__SWIG_1(L);} } - } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_addNormals'\n" - " Possible C/C++ prototypes are:\n" " ofMesh::addNormals(std::vector< ofVec3f > const &)\n" - " ofMesh::addNormals(ofVec3f const *,std::size_t)\n"); lua_error(L);return 0; } -static int _wrap_Mesh_removeNormal(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; ofIndexType arg2 ; - SWIG_check_num_args("ofMesh::removeNormal",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::removeNormal",1,"ofMesh *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::removeNormal",2,"ofIndexType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_removeNormal",1,SWIGTYPE_p_ofMesh); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); - (arg1)->removeNormal(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_setNormal(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; ofIndexType arg2 ; - ofVec3f *arg3 = 0 ; SWIG_check_num_args("ofMesh::setNormal",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::setNormal",1,"ofMesh *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::setNormal",2,"ofIndexType"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofMesh::setNormal",3,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Mesh_setNormal",1,SWIGTYPE_p_ofMesh); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Mesh_setNormal",3,SWIGTYPE_p_ofVec3f); } (arg1)->setNormal(arg2,(ofVec3f const &)*arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_clearNormals(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - SWIG_check_num_args("ofMesh::clearNormals",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::clearNormals",1,"ofMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_clearNormals",1,SWIGTYPE_p_ofMesh); } (arg1)->clearNormals(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getNumNormals(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; std::size_t result; - SWIG_check_num_args("ofMesh::getNumNormals",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getNumNormals",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_getNumNormals",1,SWIGTYPE_p_ofMesh); } result = (std::size_t)((ofMesh const *)arg1)->getNumNormals(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getNormalsPointer__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - ofVec3f *result = 0 ; SWIG_check_num_args("ofMesh::getNormalsPointer",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getNormalsPointer",1,"ofMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_getNormalsPointer",1,SWIGTYPE_p_ofMesh); } result = (ofVec3f *)(arg1)->getNormalsPointer(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Mesh_getNormalsPointer__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - ofVec3f *result = 0 ; SWIG_check_num_args("ofMesh::getNormalsPointer",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getNormalsPointer",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_getNormalsPointer",1,SWIGTYPE_p_ofMesh); } - result = (ofVec3f *)((ofMesh const *)arg1)->getNormalsPointer(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Mesh_getNormalsPointer(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Mesh_getNormalsPointer__SWIG_0(L);} } if (argc == 1) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Mesh_getNormalsPointer__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_getNormalsPointer'\n" - " Possible C/C++ prototypes are:\n" " ofMesh::getNormalsPointer()\n" " ofMesh::getNormalsPointer() const\n"); - lua_error(L);return 0; } -static int _wrap_Mesh_getNormals__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - std::vector< ofVec3f > *result = 0 ; SWIG_check_num_args("ofMesh::getNormals",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getNormals",1,"ofMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_getNormals",1,SWIGTYPE_p_ofMesh); } result = (std::vector< ofVec3f > *) &(arg1)->getNormals(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofVec3f_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getNormals__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - std::vector< ofVec3f > *result = 0 ; SWIG_check_num_args("ofMesh::getNormals",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getNormals",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_getNormals",1,SWIGTYPE_p_ofMesh); } - result = (std::vector< ofVec3f > *) &((ofMesh const *)arg1)->getNormals(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofVec3f_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getNormals(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Mesh_getNormals__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Mesh_getNormals__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_getNormals'\n" " Possible C/C++ prototypes are:\n" - " ofMesh::getNormals()\n" " ofMesh::getNormals() const\n"); lua_error(L);return 0; } -static int _wrap_Mesh_haveNormalsChanged(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; bool result; - SWIG_check_num_args("ofMesh::haveNormalsChanged",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::haveNormalsChanged",1,"ofMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_haveNormalsChanged",1,SWIGTYPE_p_ofMesh); } result = (bool)(arg1)->haveNormalsChanged(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_hasNormals(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; bool result; - SWIG_check_num_args("ofMesh::hasNormals",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::hasNormals",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_hasNormals",1,SWIGTYPE_p_ofMesh); } result = (bool)((ofMesh const *)arg1)->hasNormals(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_enableNormals(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - SWIG_check_num_args("ofMesh::enableNormals",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::enableNormals",1,"ofMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_enableNormals",1,SWIGTYPE_p_ofMesh); } (arg1)->enableNormals(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_disableNormals(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - SWIG_check_num_args("ofMesh::disableNormals",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::disableNormals",1,"ofMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_disableNormals",1,SWIGTYPE_p_ofMesh); } (arg1)->disableNormals(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_usingNormals(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; bool result; - SWIG_check_num_args("ofMesh::usingNormals",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::usingNormals",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_usingNormals",1,SWIGTYPE_p_ofMesh); } result = (bool)((ofMesh const *)arg1)->usingNormals(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_smoothNormals(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; float arg2 ; - SWIG_check_num_args("ofMesh::smoothNormals",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::smoothNormals",1,"ofMesh *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::smoothNormals",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_smoothNormals",1,SWIGTYPE_p_ofMesh); } arg2 = (float)lua_tonumber(L, 2); (arg1)->smoothNormals(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getFace(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; ofIndexType arg2 ; - ofMeshFace result; SWIG_check_num_args("ofMesh::getFace",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getFace",1,"ofMesh const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::getFace",2,"ofIndexType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Mesh_getFace",1,SWIGTYPE_p_ofMesh); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); - result = ((ofMesh const *)arg1)->getFace(arg2); { ofMeshFace * resultptr = new ofMeshFace((const ofMeshFace &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMeshFace,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getFaceNormals__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; bool arg2 ; - SwigValueWrapper< std::vector< ofVec3f > > result; SWIG_check_num_args("ofMesh::getFaceNormals",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getFaceNormals",1,"ofMesh const *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofMesh::getFaceNormals",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_getFaceNormals",1,SWIGTYPE_p_ofMesh); } arg2 = (lua_toboolean(L, 2)!=0); - result = ((ofMesh const *)arg1)->getFaceNormals(arg2); { - std::vector< ofVec3f > * resultptr = new std::vector< ofVec3f >((const std::vector< ofVec3f > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_ofVec3f_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getFaceNormals__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - SwigValueWrapper< std::vector< ofVec3f > > result; SWIG_check_num_args("ofMesh::getFaceNormals",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getFaceNormals",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_getFaceNormals",1,SWIGTYPE_p_ofMesh); } result = ((ofMesh const *)arg1)->getFaceNormals(); { - std::vector< ofVec3f > * resultptr = new std::vector< ofVec3f >((const std::vector< ofVec3f > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_ofVec3f_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getFaceNormals(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Mesh_getFaceNormals__SWIG_1(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_Mesh_getFaceNormals__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_getFaceNormals'\n" - " Possible C/C++ prototypes are:\n" " ofMesh::getFaceNormals(bool) const\n" " ofMesh::getFaceNormals() const\n"); - lua_error(L);return 0; } -static int _wrap_Mesh_getUniqueFaces(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - std::vector< ofMeshFace > *result = 0 ; SWIG_check_num_args("ofMesh::getUniqueFaces",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getUniqueFaces",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_getUniqueFaces",1,SWIGTYPE_p_ofMesh); } - result = (std::vector< ofMeshFace > *) &((ofMesh const *)arg1)->getUniqueFaces(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofMeshFace_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getColor(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; ofIndexType arg2 ; - ofFloatColor result; SWIG_check_num_args("ofMesh::getColor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getColor",1,"ofMesh const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::getColor",2,"ofIndexType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Mesh_getColor",1,SWIGTYPE_p_ofMesh); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); - result = ((ofMesh const *)arg1)->getColor(arg2); { ofFloatColor * resultptr = new ofFloatColor((const ofFloatColor &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_addColor(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; ofFloatColor *arg2 = 0 ; - SWIG_check_num_args("ofMesh::addColor",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::addColor",1,"ofMesh *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMesh::addColor",2,"ofFloatColor const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Mesh_addColor",1,SWIGTYPE_p_ofMesh); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("Mesh_addColor",2,SWIGTYPE_p_ofColor_T_float_t); } (arg1)->addColor((ofFloatColor const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_addColors__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - std::vector< ofFloatColor > *arg2 = 0 ; SWIG_check_num_args("ofMesh::addColors",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::addColors",1,"ofMesh *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMesh::addColors",2,"std::vector< ofFloatColor > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Mesh_addColors",1,SWIGTYPE_p_ofMesh); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__vectorT_ofColor_T_float_t_t,0))){ - SWIG_fail_ptr("Mesh_addColors",2,SWIGTYPE_p_std__vectorT_ofColor_T_float_t_t); } - (arg1)->addColors((std::vector< ofFloatColor > const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Mesh_addColors__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - ofFloatColor *arg2 = (ofFloatColor *) 0 ; std::size_t arg3 ; SWIG_check_num_args("ofMesh::addColors",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::addColors",1,"ofMesh *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofMesh::addColors",2,"ofFloatColor const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh::addColors",3,"std::size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Mesh_addColors",1,SWIGTYPE_p_ofMesh); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("Mesh_addColors",2,SWIGTYPE_p_ofColor_T_float_t); } - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (std::size_t)lua_tonumber(L, 3); - (arg1)->addColors((ofFloatColor const *)arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_addColors(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_std__vectorT_ofColor_T_float_t_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Mesh_addColors__SWIG_0(L);} } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Mesh_addColors__SWIG_1(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_addColors'\n" " Possible C/C++ prototypes are:\n" - " ofMesh::addColors(std::vector< ofFloatColor > const &)\n" " ofMesh::addColors(ofFloatColor const *,std::size_t)\n"); - lua_error(L);return 0; } -static int _wrap_Mesh_removeColor(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; ofIndexType arg2 ; - SWIG_check_num_args("ofMesh::removeColor",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::removeColor",1,"ofMesh *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::removeColor",2,"ofIndexType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_removeColor",1,SWIGTYPE_p_ofMesh); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); - (arg1)->removeColor(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_setColor(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; ofIndexType arg2 ; - ofFloatColor *arg3 = 0 ; SWIG_check_num_args("ofMesh::setColor",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::setColor",1,"ofMesh *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::setColor",2,"ofIndexType"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofMesh::setColor",3,"ofFloatColor const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Mesh_setColor",1,SWIGTYPE_p_ofMesh); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("Mesh_setColor",3,SWIGTYPE_p_ofColor_T_float_t); } (arg1)->setColor(arg2,(ofFloatColor const &)*arg3); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_clearColors(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - SWIG_check_num_args("ofMesh::clearColors",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::clearColors",1,"ofMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_clearColors",1,SWIGTYPE_p_ofMesh); } (arg1)->clearColors(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getNumColors(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; std::size_t result; - SWIG_check_num_args("ofMesh::getNumColors",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getNumColors",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_getNumColors",1,SWIGTYPE_p_ofMesh); } result = (std::size_t)((ofMesh const *)arg1)->getNumColors(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getColorsPointer__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - ofFloatColor *result = 0 ; SWIG_check_num_args("ofMesh::getColorsPointer",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getColorsPointer",1,"ofMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_getColorsPointer",1,SWIGTYPE_p_ofMesh); } result = (ofFloatColor *)(arg1)->getColorsPointer(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getColorsPointer__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - ofFloatColor *result = 0 ; SWIG_check_num_args("ofMesh::getColorsPointer",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getColorsPointer",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_getColorsPointer",1,SWIGTYPE_p_ofMesh); } - result = (ofFloatColor *)((ofMesh const *)arg1)->getColorsPointer(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getColorsPointer(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Mesh_getColorsPointer__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Mesh_getColorsPointer__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_getColorsPointer'\n" - " Possible C/C++ prototypes are:\n" " ofMesh::getColorsPointer()\n" " ofMesh::getColorsPointer() const\n"); - lua_error(L);return 0; } -static int _wrap_Mesh_getColors__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - std::vector< ofFloatColor > *result = 0 ; SWIG_check_num_args("ofMesh::getColors",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getColors",1,"ofMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Mesh_getColors",1,SWIGTYPE_p_ofMesh); } - result = (std::vector< ofFloatColor > *) &(arg1)->getColors(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofColor_T_float_t_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getColors__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - std::vector< ofFloatColor > *result = 0 ; SWIG_check_num_args("ofMesh::getColors",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getColors",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Mesh_getColors",1,SWIGTYPE_p_ofMesh); } - result = (std::vector< ofFloatColor > *) &((ofMesh const *)arg1)->getColors(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofColor_T_float_t_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getColors(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Mesh_getColors__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Mesh_getColors__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_getColors'\n" " Possible C/C++ prototypes are:\n" - " ofMesh::getColors()\n" " ofMesh::getColors() const\n"); lua_error(L);return 0; } -static int _wrap_Mesh_haveColorsChanged(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; bool result; - SWIG_check_num_args("ofMesh::haveColorsChanged",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::haveColorsChanged",1,"ofMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_haveColorsChanged",1,SWIGTYPE_p_ofMesh); } result = (bool)(arg1)->haveColorsChanged(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_hasColors(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; bool result; - SWIG_check_num_args("ofMesh::hasColors",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::hasColors",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Mesh_hasColors",1,SWIGTYPE_p_ofMesh); } - result = (bool)((ofMesh const *)arg1)->hasColors(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_enableColors(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - SWIG_check_num_args("ofMesh::enableColors",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::enableColors",1,"ofMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_enableColors",1,SWIGTYPE_p_ofMesh); } (arg1)->enableColors(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_disableColors(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - SWIG_check_num_args("ofMesh::disableColors",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::disableColors",1,"ofMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_disableColors",1,SWIGTYPE_p_ofMesh); } (arg1)->disableColors(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_usingColors(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; bool result; - SWIG_check_num_args("ofMesh::usingColors",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::usingColors",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_usingColors",1,SWIGTYPE_p_ofMesh); } result = (bool)((ofMesh const *)arg1)->usingColors(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getTexCoord(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; ofIndexType arg2 ; - ofVec2f result; SWIG_check_num_args("ofMesh::getTexCoord",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getTexCoord",1,"ofMesh const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::getTexCoord",2,"ofIndexType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_getTexCoord",1,SWIGTYPE_p_ofMesh); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); - result = ((ofMesh const *)arg1)->getTexCoord(arg2); { ofVec2f * resultptr = new ofVec2f((const ofVec2f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_addTexCoord(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; ofVec2f *arg2 = 0 ; - SWIG_check_num_args("ofMesh::addTexCoord",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::addTexCoord",1,"ofMesh *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMesh::addTexCoord",2,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_addTexCoord",1,SWIGTYPE_p_ofMesh); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Mesh_addTexCoord",2,SWIGTYPE_p_ofVec2f); } (arg1)->addTexCoord((ofVec2f const &)*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_addTexCoords__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - std::vector< ofVec2f > *arg2 = 0 ; SWIG_check_num_args("ofMesh::addTexCoords",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::addTexCoords",1,"ofMesh *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMesh::addTexCoords",2,"std::vector< ofVec2f > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_addTexCoords",1,SWIGTYPE_p_ofMesh); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__vectorT_ofVec2f_t,0))){ - SWIG_fail_ptr("Mesh_addTexCoords",2,SWIGTYPE_p_std__vectorT_ofVec2f_t); } - (arg1)->addTexCoords((std::vector< ofVec2f > const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Mesh_addTexCoords__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - ofVec2f *arg2 = (ofVec2f *) 0 ; std::size_t arg3 ; SWIG_check_num_args("ofMesh::addTexCoords",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::addTexCoords",1,"ofMesh *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofMesh::addTexCoords",2,"ofVec2f const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh::addTexCoords",3,"std::size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_addTexCoords",1,SWIGTYPE_p_ofMesh); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Mesh_addTexCoords",2,SWIGTYPE_p_ofVec2f); } - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (std::size_t)lua_tonumber(L, 3); - (arg1)->addTexCoords((ofVec2f const *)arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_addTexCoords(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_std__vectorT_ofVec2f_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Mesh_addTexCoords__SWIG_0(L);} } } if (argc == 3) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Mesh_addTexCoords__SWIG_1(L);} - } } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_addTexCoords'\n" - " Possible C/C++ prototypes are:\n" " ofMesh::addTexCoords(std::vector< ofVec2f > const &)\n" - " ofMesh::addTexCoords(ofVec2f const *,std::size_t)\n"); lua_error(L);return 0; } -static int _wrap_Mesh_removeTexCoord(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; ofIndexType arg2 ; - SWIG_check_num_args("ofMesh::removeTexCoord",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::removeTexCoord",1,"ofMesh *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::removeTexCoord",2,"ofIndexType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_removeTexCoord",1,SWIGTYPE_p_ofMesh); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); - (arg1)->removeTexCoord(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_setTexCoord(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; ofIndexType arg2 ; - ofVec2f *arg3 = 0 ; SWIG_check_num_args("ofMesh::setTexCoord",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::setTexCoord",1,"ofMesh *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::setTexCoord",2,"ofIndexType"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofMesh::setTexCoord",3,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_setTexCoord",1,SWIGTYPE_p_ofMesh); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Mesh_setTexCoord",3,SWIGTYPE_p_ofVec2f); } (arg1)->setTexCoord(arg2,(ofVec2f const &)*arg3); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_clearTexCoords(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - SWIG_check_num_args("ofMesh::clearTexCoords",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::clearTexCoords",1,"ofMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_clearTexCoords",1,SWIGTYPE_p_ofMesh); } (arg1)->clearTexCoords(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getNumTexCoords(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; std::size_t result; - SWIG_check_num_args("ofMesh::getNumTexCoords",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getNumTexCoords",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_getNumTexCoords",1,SWIGTYPE_p_ofMesh); } - result = (std::size_t)((ofMesh const *)arg1)->getNumTexCoords(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getTexCoordsPointer__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - ofVec2f *result = 0 ; SWIG_check_num_args("ofMesh::getTexCoordsPointer",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getTexCoordsPointer",1,"ofMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_getTexCoordsPointer",1,SWIGTYPE_p_ofMesh); } result = (ofVec2f *)(arg1)->getTexCoordsPointer(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec2f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Mesh_getTexCoordsPointer__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - ofVec2f *result = 0 ; SWIG_check_num_args("ofMesh::getTexCoordsPointer",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getTexCoordsPointer",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_getTexCoordsPointer",1,SWIGTYPE_p_ofMesh); } - result = (ofVec2f *)((ofMesh const *)arg1)->getTexCoordsPointer(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec2f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Mesh_getTexCoordsPointer(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Mesh_getTexCoordsPointer__SWIG_0(L);} } if (argc == 1) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Mesh_getTexCoordsPointer__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_getTexCoordsPointer'\n" - " Possible C/C++ prototypes are:\n" " ofMesh::getTexCoordsPointer()\n" " ofMesh::getTexCoordsPointer() const\n"); - lua_error(L);return 0; } -static int _wrap_Mesh_getTexCoords__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - std::vector< ofVec2f > *result = 0 ; SWIG_check_num_args("ofMesh::getTexCoords",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getTexCoords",1,"ofMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_getTexCoords",1,SWIGTYPE_p_ofMesh); } result = (std::vector< ofVec2f > *) &(arg1)->getTexCoords(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofVec2f_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getTexCoords__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - std::vector< ofVec2f > *result = 0 ; SWIG_check_num_args("ofMesh::getTexCoords",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getTexCoords",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_getTexCoords",1,SWIGTYPE_p_ofMesh); } - result = (std::vector< ofVec2f > *) &((ofMesh const *)arg1)->getTexCoords(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofVec2f_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getTexCoords(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Mesh_getTexCoords__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Mesh_getTexCoords__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_getTexCoords'\n" " Possible C/C++ prototypes are:\n" - " ofMesh::getTexCoords()\n" " ofMesh::getTexCoords() const\n"); lua_error(L);return 0; } -static int _wrap_Mesh_haveTexCoordsChanged(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; bool result; - SWIG_check_num_args("ofMesh::haveTexCoordsChanged",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::haveTexCoordsChanged",1,"ofMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_haveTexCoordsChanged",1,SWIGTYPE_p_ofMesh); } result = (bool)(arg1)->haveTexCoordsChanged(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_hasTexCoords(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; bool result; - SWIG_check_num_args("ofMesh::hasTexCoords",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::hasTexCoords",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_hasTexCoords",1,SWIGTYPE_p_ofMesh); } result = (bool)((ofMesh const *)arg1)->hasTexCoords(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_enableTextures(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - SWIG_check_num_args("ofMesh::enableTextures",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::enableTextures",1,"ofMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_enableTextures",1,SWIGTYPE_p_ofMesh); } (arg1)->enableTextures(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_disableTextures(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - SWIG_check_num_args("ofMesh::disableTextures",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::disableTextures",1,"ofMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_disableTextures",1,SWIGTYPE_p_ofMesh); } (arg1)->disableTextures(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_usingTextures(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; bool result; - SWIG_check_num_args("ofMesh::usingTextures",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::usingTextures",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_usingTextures",1,SWIGTYPE_p_ofMesh); } result = (bool)((ofMesh const *)arg1)->usingTextures(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_setupIndicesAuto(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - SWIG_check_num_args("ofMesh::setupIndicesAuto",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::setupIndicesAuto",1,"ofMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_setupIndicesAuto",1,SWIGTYPE_p_ofMesh); } (arg1)->setupIndicesAuto(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getIndices__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - std::vector< ofIndexType > *result = 0 ; SWIG_check_num_args("ofMesh::getIndices",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getIndices",1,"ofMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_getIndices",1,SWIGTYPE_p_ofMesh); } result = (std::vector< ofIndexType > *) &(arg1)->getIndices(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getIndex(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; ofIndexType arg2 ; - ofIndexType result; SWIG_check_num_args("ofMesh::getIndex",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getIndex",1,"ofMesh const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::getIndex",2,"ofIndexType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Mesh_getIndex",1,SWIGTYPE_p_ofMesh); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); - result = (ofIndexType)((ofMesh const *)arg1)->getIndex(arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_addIndex(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; ofIndexType arg2 ; - SWIG_check_num_args("ofMesh::addIndex",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::addIndex",1,"ofMesh *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::addIndex",2,"ofIndexType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Mesh_addIndex",1,SWIGTYPE_p_ofMesh); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); - (arg1)->addIndex(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_addIndices__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - std::vector< ofIndexType > *arg2 = 0 ; SWIG_check_num_args("ofMesh::addIndices",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::addIndices",1,"ofMesh *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMesh::addIndices",2,"std::vector< ofIndexType > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_addIndices",1,SWIGTYPE_p_ofMesh); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__vectorT_unsigned_short_t,0))){ - SWIG_fail_ptr("Mesh_addIndices",2,SWIGTYPE_p_std__vectorT_unsigned_short_t); } - (arg1)->addIndices((std::vector< ofIndexType > const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Mesh_addIndices__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - ofIndexType *arg2 = (ofIndexType *) 0 ; std::size_t arg3 ; SWIG_check_num_args("ofMesh::addIndices",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::addIndices",1,"ofMesh *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofMesh::addIndices",2,"ofIndexType const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh::addIndices",3,"std::size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_addIndices",1,SWIGTYPE_p_ofMesh); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_unsigned_short,0))){ - SWIG_fail_ptr("Mesh_addIndices",2,SWIGTYPE_p_unsigned_short); } - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (std::size_t)lua_tonumber(L, 3); - (arg1)->addIndices((ofIndexType const *)arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_addIndices(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_std__vectorT_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Mesh_addIndices__SWIG_0(L);} } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_unsigned_short, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Mesh_addIndices__SWIG_1(L);} } - } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_addIndices'\n" - " Possible C/C++ prototypes are:\n" " ofMesh::addIndices(std::vector< ofIndexType > const &)\n" - " ofMesh::addIndices(ofIndexType const *,std::size_t)\n"); lua_error(L);return 0; } -static int _wrap_Mesh_removeIndex(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; ofIndexType arg2 ; - SWIG_check_num_args("ofMesh::removeIndex",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::removeIndex",1,"ofMesh *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::removeIndex",2,"ofIndexType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_removeIndex",1,SWIGTYPE_p_ofMesh); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); - (arg1)->removeIndex(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_setIndex(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; ofIndexType arg2 ; - ofIndexType arg3 ; SWIG_check_num_args("ofMesh::setIndex",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::setIndex",1,"ofMesh *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::setIndex",2,"ofIndexType"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh::setIndex",3,"ofIndexType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Mesh_setIndex",1,SWIGTYPE_p_ofMesh); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (ofIndexType)lua_tonumber(L, 3); - (arg1)->setIndex(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_clearIndices(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - SWIG_check_num_args("ofMesh::clearIndices",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::clearIndices",1,"ofMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_clearIndices",1,SWIGTYPE_p_ofMesh); } (arg1)->clearIndices(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getNumIndices(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; std::size_t result; - SWIG_check_num_args("ofMesh::getNumIndices",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getNumIndices",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_getNumIndices",1,SWIGTYPE_p_ofMesh); } result = (std::size_t)((ofMesh const *)arg1)->getNumIndices(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getIndexPointer__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - ofIndexType *result = 0 ; SWIG_check_num_args("ofMesh::getIndexPointer",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getIndexPointer",1,"ofMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_getIndexPointer",1,SWIGTYPE_p_ofMesh); } result = (ofIndexType *)(arg1)->getIndexPointer(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_unsigned_short,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Mesh_getIndexPointer__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - ofIndexType *result = 0 ; SWIG_check_num_args("ofMesh::getIndexPointer",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getIndexPointer",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_getIndexPointer",1,SWIGTYPE_p_ofMesh); } - result = (ofIndexType *)((ofMesh const *)arg1)->getIndexPointer(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_unsigned_short,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Mesh_getIndexPointer(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Mesh_getIndexPointer__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Mesh_getIndexPointer__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_getIndexPointer'\n" - " Possible C/C++ prototypes are:\n" " ofMesh::getIndexPointer()\n" " ofMesh::getIndexPointer() const\n"); - lua_error(L);return 0; } -static int _wrap_Mesh_getIndices__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - std::vector< ofIndexType > *result = 0 ; SWIG_check_num_args("ofMesh::getIndices",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getIndices",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_getIndices",1,SWIGTYPE_p_ofMesh); } - result = (std::vector< ofIndexType > *) &((ofMesh const *)arg1)->getIndices(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getIndices(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Mesh_getIndices__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Mesh_getIndices__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_getIndices'\n" " Possible C/C++ prototypes are:\n" - " ofMesh::getIndices()\n" " ofMesh::getIndices() const\n"); lua_error(L);return 0; } -static int _wrap_Mesh_haveIndicesChanged(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; bool result; - SWIG_check_num_args("ofMesh::haveIndicesChanged",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::haveIndicesChanged",1,"ofMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_haveIndicesChanged",1,SWIGTYPE_p_ofMesh); } result = (bool)(arg1)->haveIndicesChanged(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_hasIndices(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; bool result; - SWIG_check_num_args("ofMesh::hasIndices",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::hasIndices",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_hasIndices",1,SWIGTYPE_p_ofMesh); } result = (bool)((ofMesh const *)arg1)->hasIndices(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_addTriangle(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; ofIndexType arg2 ; - ofIndexType arg3 ; ofIndexType arg4 ; SWIG_check_num_args("ofMesh::addTriangle",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::addTriangle",1,"ofMesh *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::addTriangle",2,"ofIndexType"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh::addTriangle",3,"ofIndexType"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMesh::addTriangle",4,"ofIndexType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_addTriangle",1,SWIGTYPE_p_ofMesh); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (ofIndexType)lua_tonumber(L, 3); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (ofIndexType)lua_tonumber(L, 4); - (arg1)->addTriangle(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_enableIndices(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - SWIG_check_num_args("ofMesh::enableIndices",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::enableIndices",1,"ofMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_enableIndices",1,SWIGTYPE_p_ofMesh); } (arg1)->enableIndices(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_disableIndices(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - SWIG_check_num_args("ofMesh::disableIndices",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::disableIndices",1,"ofMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_disableIndices",1,SWIGTYPE_p_ofMesh); } (arg1)->disableIndices(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_usingIndices(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; bool result; - SWIG_check_num_args("ofMesh::usingIndices",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::usingIndices",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_usingIndices",1,SWIGTYPE_p_ofMesh); } result = (bool)((ofMesh const *)arg1)->usingIndices(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_setColorForIndices(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; ofIndexType arg2 ; - ofIndexType arg3 ; ofColor arg4 ; ofColor *argp4 ; SWIG_check_num_args("ofMesh::setColorForIndices",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::setColorForIndices",1,"ofMesh *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::setColorForIndices",2,"ofIndexType"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh::setColorForIndices",3,"ofIndexType"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofMesh::setColorForIndices",4,"ofColor"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_setColorForIndices",1,SWIGTYPE_p_ofMesh); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (ofIndexType)lua_tonumber(L, 3); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&argp4,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Mesh_setColorForIndices",4,SWIGTYPE_p_ofColor_T_unsigned_char_t); } arg4 = *argp4; - (arg1)->setColorForIndices(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getMeshForIndices__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - ofIndexType arg2 ; ofIndexType arg3 ; ofMesh result; SWIG_check_num_args("ofMesh::getMeshForIndices",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getMeshForIndices",1,"ofMesh const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::getMeshForIndices",2,"ofIndexType"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh::getMeshForIndices",3,"ofIndexType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_getMeshForIndices",1,SWIGTYPE_p_ofMesh); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (ofIndexType)lua_tonumber(L, 3); - result = ((ofMesh const *)arg1)->getMeshForIndices(arg2,arg3); { ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getMeshForIndices__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - ofIndexType arg2 ; ofIndexType arg3 ; ofIndexType arg4 ; ofIndexType arg5 ; ofMesh result; - SWIG_check_num_args("ofMesh::getMeshForIndices",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::getMeshForIndices",1,"ofMesh const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::getMeshForIndices",2,"ofIndexType"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMesh::getMeshForIndices",3,"ofIndexType"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMesh::getMeshForIndices",4,"ofIndexType"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMesh::getMeshForIndices",5,"ofIndexType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_getMeshForIndices",1,SWIGTYPE_p_ofMesh); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (ofIndexType)lua_tonumber(L, 3); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (ofIndexType)lua_tonumber(L, 4); - SWIG_contract_assert((lua_tonumber(L,5)>=0),"number must not be negative") arg5 = (ofIndexType)lua_tonumber(L, 5); - result = ((ofMesh const *)arg1)->getMeshForIndices(arg2,arg3,arg4,arg5); { - ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_getMeshForIndices(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Mesh_getMeshForIndices__SWIG_0(L);} } } } if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Mesh_getMeshForIndices__SWIG_1(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_getMeshForIndices'\n" - " Possible C/C++ prototypes are:\n" " ofMesh::getMeshForIndices(ofIndexType,ofIndexType) const\n" - " ofMesh::getMeshForIndices(ofIndexType,ofIndexType,ofIndexType,ofIndexType) const\n"); lua_error(L);return 0; } -static int _wrap_Mesh_drawVertices(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - SWIG_check_num_args("ofMesh::drawVertices",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::drawVertices",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_drawVertices",1,SWIGTYPE_p_ofMesh); } ((ofMesh const *)arg1)->drawVertices(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_drawWireframe(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - SWIG_check_num_args("ofMesh::drawWireframe",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::drawWireframe",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("Mesh_drawWireframe",1,SWIGTYPE_p_ofMesh); } ((ofMesh const *)arg1)->drawWireframe(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_drawFaces(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - SWIG_check_num_args("ofMesh::drawFaces",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::drawFaces",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Mesh_drawFaces",1,SWIGTYPE_p_ofMesh); } - ((ofMesh const *)arg1)->drawFaces(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_draw__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; - SWIG_check_num_args("ofMesh::draw",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::draw",1,"ofMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Mesh_draw",1,SWIGTYPE_p_ofMesh); } - ((ofMesh const *)arg1)->draw(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_draw__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; ofPolyRenderMode arg2 ; - SWIG_check_num_args("ofMesh::draw",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::draw",1,"ofMesh const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMesh::draw",2,"ofPolyRenderMode"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Mesh_draw",1,SWIGTYPE_p_ofMesh); } - arg2 = (ofPolyRenderMode)(int)lua_tonumber(L, 2); ((ofMesh const *)arg1)->draw(arg2); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_draw(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Mesh_draw__SWIG_0(L);} } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Mesh_draw__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_draw'\n" " Possible C/C++ prototypes are:\n" - " ofMesh::draw() const\n" " ofMesh::draw(ofPolyRenderMode) const\n"); lua_error(L);return 0; } -static int _wrap_Mesh_load(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; std::string arg2 ; - SWIG_check_num_args("ofMesh::load",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::load",1,"ofMesh *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofMesh::load",2,"std::string"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Mesh_load",1,SWIGTYPE_p_ofMesh); } - (&arg2)->assign(lua_tostring(L,2),lua_rawlen(L,2)); (arg1)->load(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Mesh_save__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; std::string arg2 ; - bool arg3 ; SWIG_check_num_args("ofMesh::save",3,3) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::save",1,"ofMesh const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofMesh::save",2,"std::string"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofMesh::save",3,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Mesh_save",1,SWIGTYPE_p_ofMesh); } - (&arg2)->assign(lua_tostring(L,2),lua_rawlen(L,2)); arg3 = (lua_toboolean(L, 3)!=0); ((ofMesh const *)arg1)->save(arg2,arg3); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_save__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = (ofMesh *) 0 ; std::string arg2 ; - SWIG_check_num_args("ofMesh::save",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMesh::save",1,"ofMesh const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofMesh::save",2,"std::string"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Mesh_save",1,SWIGTYPE_p_ofMesh); } - (&arg2)->assign(lua_tostring(L,2),lua_rawlen(L,2)); ((ofMesh const *)arg1)->save(arg2); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Mesh_save(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { - return _wrap_Mesh_save__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - return _wrap_Mesh_save__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Mesh_save'\n" " Possible C/C++ prototypes are:\n" - " ofMesh::save(std::string,bool) const\n" " ofMesh::save(std::string) const\n"); lua_error(L);return 0; } -static void swig_delete_Mesh(void *obj) { -ofMesh *arg1 = (ofMesh *) obj; -delete_ofMesh(arg1); -} -static int _proxy__wrap_new_Mesh(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_Mesh); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_Mesh_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_Mesh_methods[]= { - { "setFromTriangles", _wrap_Mesh_setFromTriangles}, - { "setMode", _wrap_Mesh_setMode}, - { "getMode", _wrap_Mesh_getMode}, - { "addVertex", _wrap_Mesh_addVertex}, - { "addVertices", _wrap_Mesh_addVertices}, - { "removeVertex", _wrap_Mesh_removeVertex}, - { "setVertex", _wrap_Mesh_setVertex}, - { "clearVertices", _wrap_Mesh_clearVertices}, - { "clear", _wrap_Mesh_clear}, - { "getNumVertices", _wrap_Mesh_getNumVertices}, - { "getVerticesPointer", _wrap_Mesh_getVerticesPointer}, - { "getVertex", _wrap_Mesh_getVertex}, - { "getVertices", _wrap_Mesh_getVertices}, - { "haveVertsChanged", _wrap_Mesh_haveVertsChanged}, - { "hasVertices", _wrap_Mesh_hasVertices}, - { "append", _wrap_Mesh_append}, - { "mergeDuplicateVertices", _wrap_Mesh_mergeDuplicateVertices}, - { "getCentroid", _wrap_Mesh_getCentroid}, - { "getNormal", _wrap_Mesh_getNormal}, - { "addNormal", _wrap_Mesh_addNormal}, - { "addNormals", _wrap_Mesh_addNormals}, - { "removeNormal", _wrap_Mesh_removeNormal}, - { "setNormal", _wrap_Mesh_setNormal}, - { "clearNormals", _wrap_Mesh_clearNormals}, - { "getNumNormals", _wrap_Mesh_getNumNormals}, - { "getNormalsPointer", _wrap_Mesh_getNormalsPointer}, - { "getNormals", _wrap_Mesh_getNormals}, - { "haveNormalsChanged", _wrap_Mesh_haveNormalsChanged}, - { "hasNormals", _wrap_Mesh_hasNormals}, - { "enableNormals", _wrap_Mesh_enableNormals}, - { "disableNormals", _wrap_Mesh_disableNormals}, - { "usingNormals", _wrap_Mesh_usingNormals}, - { "smoothNormals", _wrap_Mesh_smoothNormals}, - { "getFace", _wrap_Mesh_getFace}, - { "getFaceNormals", _wrap_Mesh_getFaceNormals}, - { "getUniqueFaces", _wrap_Mesh_getUniqueFaces}, - { "getColor", _wrap_Mesh_getColor}, - { "addColor", _wrap_Mesh_addColor}, - { "addColors", _wrap_Mesh_addColors}, - { "removeColor", _wrap_Mesh_removeColor}, - { "setColor", _wrap_Mesh_setColor}, - { "clearColors", _wrap_Mesh_clearColors}, - { "getNumColors", _wrap_Mesh_getNumColors}, - { "getColorsPointer", _wrap_Mesh_getColorsPointer}, - { "getColors", _wrap_Mesh_getColors}, - { "haveColorsChanged", _wrap_Mesh_haveColorsChanged}, - { "hasColors", _wrap_Mesh_hasColors}, - { "enableColors", _wrap_Mesh_enableColors}, - { "disableColors", _wrap_Mesh_disableColors}, - { "usingColors", _wrap_Mesh_usingColors}, - { "getTexCoord", _wrap_Mesh_getTexCoord}, - { "addTexCoord", _wrap_Mesh_addTexCoord}, - { "addTexCoords", _wrap_Mesh_addTexCoords}, - { "removeTexCoord", _wrap_Mesh_removeTexCoord}, - { "setTexCoord", _wrap_Mesh_setTexCoord}, - { "clearTexCoords", _wrap_Mesh_clearTexCoords}, - { "getNumTexCoords", _wrap_Mesh_getNumTexCoords}, - { "getTexCoordsPointer", _wrap_Mesh_getTexCoordsPointer}, - { "getTexCoords", _wrap_Mesh_getTexCoords}, - { "haveTexCoordsChanged", _wrap_Mesh_haveTexCoordsChanged}, - { "hasTexCoords", _wrap_Mesh_hasTexCoords}, - { "enableTextures", _wrap_Mesh_enableTextures}, - { "disableTextures", _wrap_Mesh_disableTextures}, - { "usingTextures", _wrap_Mesh_usingTextures}, - { "setupIndicesAuto", _wrap_Mesh_setupIndicesAuto}, - { "getIndex", _wrap_Mesh_getIndex}, - { "addIndex", _wrap_Mesh_addIndex}, - { "addIndices", _wrap_Mesh_addIndices}, - { "removeIndex", _wrap_Mesh_removeIndex}, - { "setIndex", _wrap_Mesh_setIndex}, - { "clearIndices", _wrap_Mesh_clearIndices}, - { "getNumIndices", _wrap_Mesh_getNumIndices}, - { "getIndexPointer", _wrap_Mesh_getIndexPointer}, - { "getIndices", _wrap_Mesh_getIndices}, - { "haveIndicesChanged", _wrap_Mesh_haveIndicesChanged}, - { "hasIndices", _wrap_Mesh_hasIndices}, - { "addTriangle", _wrap_Mesh_addTriangle}, - { "enableIndices", _wrap_Mesh_enableIndices}, - { "disableIndices", _wrap_Mesh_disableIndices}, - { "usingIndices", _wrap_Mesh_usingIndices}, - { "setColorForIndices", _wrap_Mesh_setColorForIndices}, - { "getMeshForIndices", _wrap_Mesh_getMeshForIndices}, - { "drawVertices", _wrap_Mesh_drawVertices}, - { "drawWireframe", _wrap_Mesh_drawWireframe}, - { "drawFaces", _wrap_Mesh_drawFaces}, - { "draw", _wrap_Mesh_draw}, - { "load", _wrap_Mesh_load}, - { "save", _wrap_Mesh_save}, - {0,0} -}; -static swig_lua_method swig_Mesh_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_Mesh_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_Mesh_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_Mesh_Sf_SwigStatic_methods[]= { - { "plane", _wrap_Mesh_plane}, - { "sphere", _wrap_Mesh_sphere}, - { "icosahedron", _wrap_Mesh_icosahedron}, - { "icosphere", _wrap_Mesh_icosphere}, - { "cylinder", _wrap_Mesh_cylinder}, - { "cone", _wrap_Mesh_cone}, - { "box", _wrap_Mesh_box}, - { "axis", _wrap_Mesh_axis}, - {0,0} -}; -static swig_lua_class* swig_Mesh_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_Mesh_Sf_SwigStatic = { - "Mesh", - swig_Mesh_Sf_SwigStatic_methods, - swig_Mesh_Sf_SwigStatic_attributes, - swig_Mesh_Sf_SwigStatic_constants, - swig_Mesh_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_Mesh_bases[] = {0}; -static const char *swig_Mesh_base_names[] = {0}; -static swig_lua_class _wrap_class_Mesh = { "Mesh", "Mesh", &SWIGTYPE_p_ofMesh,_proxy__wrap_new_Mesh, swig_delete_Mesh, swig_Mesh_methods, swig_Mesh_attributes, &swig_Mesh_Sf_SwigStatic, swig_Mesh_meta, swig_Mesh_bases, swig_Mesh_base_names }; - -static int _wrap_new_MeshFace(lua_State* L) { int SWIG_arg = 0; ofMeshFace *result = 0 ; - SWIG_check_num_args("ofMeshFace::ofMeshFace",0,0) result = (ofMeshFace *)new ofMeshFace(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMeshFace,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_MeshFace_getFaceNormal(lua_State* L) { int SWIG_arg = 0; ofMeshFace *arg1 = (ofMeshFace *) 0 ; - ofVec3f *result = 0 ; SWIG_check_num_args("ofMeshFace::getFaceNormal",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMeshFace::getFaceNormal",1,"ofMeshFace const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMeshFace,0))){ - SWIG_fail_ptr("MeshFace_getFaceNormal",1,SWIGTYPE_p_ofMeshFace); } - result = (ofVec3f *) &((ofMeshFace const *)arg1)->getFaceNormal(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_MeshFace_setVertex(lua_State* L) { int SWIG_arg = 0; ofMeshFace *arg1 = (ofMeshFace *) 0 ; ofIndexType arg2 ; - ofVec3f *arg3 = 0 ; SWIG_check_num_args("ofMeshFace::setVertex",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMeshFace::setVertex",1,"ofMeshFace *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMeshFace::setVertex",2,"ofIndexType"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofMeshFace::setVertex",3,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMeshFace,0))){ - SWIG_fail_ptr("MeshFace_setVertex",1,SWIGTYPE_p_ofMeshFace); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("MeshFace_setVertex",3,SWIGTYPE_p_ofVec3f); } (arg1)->setVertex(arg2,(ofVec3f const &)*arg3); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_MeshFace_getVertex(lua_State* L) { int SWIG_arg = 0; ofMeshFace *arg1 = (ofMeshFace *) 0 ; ofIndexType arg2 ; - ofVec3f *result = 0 ; SWIG_check_num_args("ofMeshFace::getVertex",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMeshFace::getVertex",1,"ofMeshFace const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMeshFace::getVertex",2,"ofIndexType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMeshFace,0))){ - SWIG_fail_ptr("MeshFace_getVertex",1,SWIGTYPE_p_ofMeshFace); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); - result = (ofVec3f *) &((ofMeshFace const *)arg1)->getVertex(arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_MeshFace_setNormal(lua_State* L) { int SWIG_arg = 0; ofMeshFace *arg1 = (ofMeshFace *) 0 ; ofIndexType arg2 ; - ofVec3f *arg3 = 0 ; SWIG_check_num_args("ofMeshFace::setNormal",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMeshFace::setNormal",1,"ofMeshFace *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMeshFace::setNormal",2,"ofIndexType"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofMeshFace::setNormal",3,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMeshFace,0))){ - SWIG_fail_ptr("MeshFace_setNormal",1,SWIGTYPE_p_ofMeshFace); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("MeshFace_setNormal",3,SWIGTYPE_p_ofVec3f); } (arg1)->setNormal(arg2,(ofVec3f const &)*arg3); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_MeshFace_getNormal(lua_State* L) { int SWIG_arg = 0; ofMeshFace *arg1 = (ofMeshFace *) 0 ; ofIndexType arg2 ; - ofVec3f *result = 0 ; SWIG_check_num_args("ofMeshFace::getNormal",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMeshFace::getNormal",1,"ofMeshFace const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMeshFace::getNormal",2,"ofIndexType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMeshFace,0))){ - SWIG_fail_ptr("MeshFace_getNormal",1,SWIGTYPE_p_ofMeshFace); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); - result = (ofVec3f *) &((ofMeshFace const *)arg1)->getNormal(arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_MeshFace_setColor(lua_State* L) { int SWIG_arg = 0; ofMeshFace *arg1 = (ofMeshFace *) 0 ; ofIndexType arg2 ; - ofFloatColor *arg3 = 0 ; SWIG_check_num_args("ofMeshFace::setColor",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMeshFace::setColor",1,"ofMeshFace *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMeshFace::setColor",2,"ofIndexType"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofMeshFace::setColor",3,"ofFloatColor const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMeshFace,0))){ - SWIG_fail_ptr("MeshFace_setColor",1,SWIGTYPE_p_ofMeshFace); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("MeshFace_setColor",3,SWIGTYPE_p_ofColor_T_float_t); } (arg1)->setColor(arg2,(ofFloatColor const &)*arg3); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_MeshFace_getColor(lua_State* L) { int SWIG_arg = 0; ofMeshFace *arg1 = (ofMeshFace *) 0 ; ofIndexType arg2 ; - ofFloatColor *result = 0 ; SWIG_check_num_args("ofMeshFace::getColor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMeshFace::getColor",1,"ofMeshFace const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMeshFace::getColor",2,"ofIndexType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMeshFace,0))){ - SWIG_fail_ptr("MeshFace_getColor",1,SWIGTYPE_p_ofMeshFace); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); - result = (ofFloatColor *) &((ofMeshFace const *)arg1)->getColor(arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_MeshFace_setTexCoord(lua_State* L) { int SWIG_arg = 0; ofMeshFace *arg1 = (ofMeshFace *) 0 ; ofIndexType arg2 ; - ofVec2f *arg3 = 0 ; SWIG_check_num_args("ofMeshFace::setTexCoord",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMeshFace::setTexCoord",1,"ofMeshFace *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMeshFace::setTexCoord",2,"ofIndexType"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofMeshFace::setTexCoord",3,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMeshFace,0))){ - SWIG_fail_ptr("MeshFace_setTexCoord",1,SWIGTYPE_p_ofMeshFace); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("MeshFace_setTexCoord",3,SWIGTYPE_p_ofVec2f); } (arg1)->setTexCoord(arg2,(ofVec2f const &)*arg3); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_MeshFace_getTexCoord(lua_State* L) { int SWIG_arg = 0; ofMeshFace *arg1 = (ofMeshFace *) 0 ; ofIndexType arg2 ; - ofVec2f *result = 0 ; SWIG_check_num_args("ofMeshFace::getTexCoord",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMeshFace::getTexCoord",1,"ofMeshFace const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMeshFace::getTexCoord",2,"ofIndexType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMeshFace,0))){ - SWIG_fail_ptr("MeshFace_getTexCoord",1,SWIGTYPE_p_ofMeshFace); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (ofIndexType)lua_tonumber(L, 2); - result = (ofVec2f *) &((ofMeshFace const *)arg1)->getTexCoord(arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec2f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_MeshFace_setHasColors(lua_State* L) { int SWIG_arg = 0; ofMeshFace *arg1 = (ofMeshFace *) 0 ; bool arg2 ; - SWIG_check_num_args("ofMeshFace::setHasColors",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMeshFace::setHasColors",1,"ofMeshFace *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofMeshFace::setHasColors",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMeshFace,0))){ - SWIG_fail_ptr("MeshFace_setHasColors",1,SWIGTYPE_p_ofMeshFace); } arg2 = (lua_toboolean(L, 2)!=0); - (arg1)->setHasColors(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_MeshFace_setHasNormals(lua_State* L) { int SWIG_arg = 0; ofMeshFace *arg1 = (ofMeshFace *) 0 ; bool arg2 ; - SWIG_check_num_args("ofMeshFace::setHasNormals",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMeshFace::setHasNormals",1,"ofMeshFace *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofMeshFace::setHasNormals",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMeshFace,0))){ - SWIG_fail_ptr("MeshFace_setHasNormals",1,SWIGTYPE_p_ofMeshFace); } arg2 = (lua_toboolean(L, 2)!=0); - (arg1)->setHasNormals(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_MeshFace_setHasTexcoords(lua_State* L) { int SWIG_arg = 0; ofMeshFace *arg1 = (ofMeshFace *) 0 ; bool arg2 ; - SWIG_check_num_args("ofMeshFace::setHasTexcoords",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMeshFace::setHasTexcoords",1,"ofMeshFace *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofMeshFace::setHasTexcoords",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMeshFace,0))){ - SWIG_fail_ptr("MeshFace_setHasTexcoords",1,SWIGTYPE_p_ofMeshFace); } arg2 = (lua_toboolean(L, 2)!=0); - (arg1)->setHasTexcoords(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_MeshFace_hasColors(lua_State* L) { int SWIG_arg = 0; ofMeshFace *arg1 = (ofMeshFace *) 0 ; bool result; - SWIG_check_num_args("ofMeshFace::hasColors",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMeshFace::hasColors",1,"ofMeshFace const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMeshFace,0))){ - SWIG_fail_ptr("MeshFace_hasColors",1,SWIGTYPE_p_ofMeshFace); } result = (bool)((ofMeshFace const *)arg1)->hasColors(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_MeshFace_hasNormals(lua_State* L) { int SWIG_arg = 0; ofMeshFace *arg1 = (ofMeshFace *) 0 ; bool result; - SWIG_check_num_args("ofMeshFace::hasNormals",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMeshFace::hasNormals",1,"ofMeshFace const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMeshFace,0))){ - SWIG_fail_ptr("MeshFace_hasNormals",1,SWIGTYPE_p_ofMeshFace); } result = (bool)((ofMeshFace const *)arg1)->hasNormals(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_MeshFace_hasTexcoords(lua_State* L) { int SWIG_arg = 0; ofMeshFace *arg1 = (ofMeshFace *) 0 ; bool result; - SWIG_check_num_args("ofMeshFace::hasTexcoords",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMeshFace::hasTexcoords",1,"ofMeshFace const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMeshFace,0))){ - SWIG_fail_ptr("MeshFace_hasTexcoords",1,SWIGTYPE_p_ofMeshFace); } - result = (bool)((ofMeshFace const *)arg1)->hasTexcoords(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_MeshFace(void *obj) { -ofMeshFace *arg1 = (ofMeshFace *) obj; -delete arg1; -} -static int _proxy__wrap_new_MeshFace(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_MeshFace); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_MeshFace_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_MeshFace_methods[]= { - { "getFaceNormal", _wrap_MeshFace_getFaceNormal}, - { "setVertex", _wrap_MeshFace_setVertex}, - { "getVertex", _wrap_MeshFace_getVertex}, - { "setNormal", _wrap_MeshFace_setNormal}, - { "getNormal", _wrap_MeshFace_getNormal}, - { "setColor", _wrap_MeshFace_setColor}, - { "getColor", _wrap_MeshFace_getColor}, - { "setTexCoord", _wrap_MeshFace_setTexCoord}, - { "getTexCoord", _wrap_MeshFace_getTexCoord}, - { "setHasColors", _wrap_MeshFace_setHasColors}, - { "setHasNormals", _wrap_MeshFace_setHasNormals}, - { "setHasTexcoords", _wrap_MeshFace_setHasTexcoords}, - { "hasColors", _wrap_MeshFace_hasColors}, - { "hasNormals", _wrap_MeshFace_hasNormals}, - { "hasTexcoords", _wrap_MeshFace_hasTexcoords}, - {0,0} -}; -static swig_lua_method swig_MeshFace_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_MeshFace_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_MeshFace_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_MeshFace_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_MeshFace_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_MeshFace_Sf_SwigStatic = { - "MeshFace", - swig_MeshFace_Sf_SwigStatic_methods, - swig_MeshFace_Sf_SwigStatic_attributes, - swig_MeshFace_Sf_SwigStatic_constants, - swig_MeshFace_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_MeshFace_bases[] = {0}; -static const char *swig_MeshFace_base_names[] = {0}; -static swig_lua_class _wrap_class_MeshFace = { "MeshFace", "MeshFace", &SWIGTYPE_p_ofMeshFace,_proxy__wrap_new_MeshFace, swig_delete_MeshFace, swig_MeshFace_methods, swig_MeshFace_attributes, &swig_MeshFace_Sf_SwigStatic, swig_MeshFace_meta, swig_MeshFace_bases, swig_MeshFace_base_names }; - -static int _wrap_new_3dPrimitive__SWIG_0(lua_State* L) { int SWIG_arg = 0; of3dPrimitive *result = 0 ; - SWIG_check_num_args("of3dPrimitive::of3dPrimitive",0,0) result = (of3dPrimitive *)new of3dPrimitive(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_of3dPrimitive,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_3dPrimitive__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = 0 ; of3dPrimitive *result = 0 ; - SWIG_check_num_args("of3dPrimitive::of3dPrimitive",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("of3dPrimitive::of3dPrimitive",1,"ofMesh const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ - SWIG_fail_ptr("new_3dPrimitive",1,SWIGTYPE_p_ofMesh); } result = (of3dPrimitive *)new of3dPrimitive((ofMesh const &)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_of3dPrimitive,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_3dPrimitive__SWIG_2(lua_State* L) { int SWIG_arg = 0; of3dPrimitive *arg1 = 0 ; of3dPrimitive *result = 0 ; - SWIG_check_num_args("of3dPrimitive::of3dPrimitive",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("of3dPrimitive::of3dPrimitive",1,"of3dPrimitive const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_of3dPrimitive,0))){ - SWIG_fail_ptr("new_3dPrimitive",1,SWIGTYPE_p_of3dPrimitive); } - result = (of3dPrimitive *)new of3dPrimitive((of3dPrimitive const &)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_of3dPrimitive,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_3dPrimitive(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_3dPrimitive__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_new_3dPrimitive__SWIG_1(L);} } if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_of3dPrimitive, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_new_3dPrimitive__SWIG_2(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_3dPrimitive'\n" " Possible C/C++ prototypes are:\n" - " of3dPrimitive::of3dPrimitive()\n" " of3dPrimitive::of3dPrimitive(ofMesh const &)\n" - " of3dPrimitive::of3dPrimitive(of3dPrimitive const &)\n"); lua_error(L);return 0; } -static int _wrap_3dPrimitive_mapTexCoords(lua_State* L) { int SWIG_arg = 0; of3dPrimitive *arg1 = (of3dPrimitive *) 0 ; - float arg2 ; float arg3 ; float arg4 ; float arg5 ; SWIG_check_num_args("of3dPrimitive::mapTexCoords",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("of3dPrimitive::mapTexCoords",1,"of3dPrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("of3dPrimitive::mapTexCoords",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("of3dPrimitive::mapTexCoords",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("of3dPrimitive::mapTexCoords",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("of3dPrimitive::mapTexCoords",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_of3dPrimitive,0))){ - SWIG_fail_ptr("3dPrimitive_mapTexCoords",1,SWIGTYPE_p_of3dPrimitive); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - (arg1)->mapTexCoords(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_3dPrimitive_mapTexCoordsFromTexture(lua_State* L) { int SWIG_arg = 0; - of3dPrimitive *arg1 = (of3dPrimitive *) 0 ; ofTexture *arg2 = 0 ; - SWIG_check_num_args("of3dPrimitive::mapTexCoordsFromTexture",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("of3dPrimitive::mapTexCoordsFromTexture",1,"of3dPrimitive *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("of3dPrimitive::mapTexCoordsFromTexture",2,"ofTexture &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_of3dPrimitive,0))){ - SWIG_fail_ptr("3dPrimitive_mapTexCoordsFromTexture",1,SWIGTYPE_p_of3dPrimitive); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("3dPrimitive_mapTexCoordsFromTexture",2,SWIGTYPE_p_ofTexture); } (arg1)->mapTexCoordsFromTexture(*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_3dPrimitive_getMeshPtr__SWIG_0(lua_State* L) { int SWIG_arg = 0; of3dPrimitive *arg1 = (of3dPrimitive *) 0 ; - ofMesh *result = 0 ; SWIG_check_num_args("of3dPrimitive::getMeshPtr",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("of3dPrimitive::getMeshPtr",1,"of3dPrimitive *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_of3dPrimitive,0))){ - SWIG_fail_ptr("3dPrimitive_getMeshPtr",1,SWIGTYPE_p_of3dPrimitive); } result = (ofMesh *)(arg1)->getMeshPtr(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMesh,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_3dPrimitive_getMesh__SWIG_0(lua_State* L) { int SWIG_arg = 0; of3dPrimitive *arg1 = (of3dPrimitive *) 0 ; - ofMesh *result = 0 ; SWIG_check_num_args("of3dPrimitive::getMesh",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("of3dPrimitive::getMesh",1,"of3dPrimitive *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_of3dPrimitive,0))){ - SWIG_fail_ptr("3dPrimitive_getMesh",1,SWIGTYPE_p_of3dPrimitive); } result = (ofMesh *) &(arg1)->getMesh(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMesh,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_3dPrimitive_getMeshPtr__SWIG_1(lua_State* L) { int SWIG_arg = 0; of3dPrimitive *arg1 = (of3dPrimitive *) 0 ; - ofMesh *result = 0 ; SWIG_check_num_args("of3dPrimitive::getMeshPtr",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("of3dPrimitive::getMeshPtr",1,"of3dPrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_of3dPrimitive,0))){ - SWIG_fail_ptr("3dPrimitive_getMeshPtr",1,SWIGTYPE_p_of3dPrimitive); } - result = (ofMesh *)((of3dPrimitive const *)arg1)->getMeshPtr(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMesh,0); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_3dPrimitive_getMeshPtr(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_of3dPrimitive, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_3dPrimitive_getMeshPtr__SWIG_0(L);} } if (argc == 1) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_of3dPrimitive, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_3dPrimitive_getMeshPtr__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function '3dPrimitive_getMeshPtr'\n" - " Possible C/C++ prototypes are:\n" " of3dPrimitive::getMeshPtr()\n" " of3dPrimitive::getMeshPtr() const\n"); - lua_error(L);return 0; } -static int _wrap_3dPrimitive_getMesh__SWIG_1(lua_State* L) { int SWIG_arg = 0; of3dPrimitive *arg1 = (of3dPrimitive *) 0 ; - ofMesh *result = 0 ; SWIG_check_num_args("of3dPrimitive::getMesh",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("of3dPrimitive::getMesh",1,"of3dPrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_of3dPrimitive,0))){ - SWIG_fail_ptr("3dPrimitive_getMesh",1,SWIGTYPE_p_of3dPrimitive); } - result = (ofMesh *) &((of3dPrimitive const *)arg1)->getMesh(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMesh,0); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_3dPrimitive_getMesh(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_of3dPrimitive, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_3dPrimitive_getMesh__SWIG_0(L);} } if (argc == 1) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_of3dPrimitive, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_3dPrimitive_getMesh__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function '3dPrimitive_getMesh'\n" - " Possible C/C++ prototypes are:\n" " of3dPrimitive::getMesh()\n" " of3dPrimitive::getMesh() const\n"); - lua_error(L);return 0; } -static int _wrap_3dPrimitive_getTexCoordsPtr__SWIG_0(lua_State* L) { int SWIG_arg = 0; - of3dPrimitive *arg1 = (of3dPrimitive *) 0 ; ofVec4f *result = 0 ; SWIG_check_num_args("of3dPrimitive::getTexCoordsPtr",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("of3dPrimitive::getTexCoordsPtr",1,"of3dPrimitive *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_of3dPrimitive,0))){ - SWIG_fail_ptr("3dPrimitive_getTexCoordsPtr",1,SWIGTYPE_p_of3dPrimitive); } result = (ofVec4f *)(arg1)->getTexCoordsPtr(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec4f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_3dPrimitive_getTexCoords__SWIG_0(lua_State* L) { int SWIG_arg = 0; of3dPrimitive *arg1 = (of3dPrimitive *) 0 ; - ofVec4f *result = 0 ; SWIG_check_num_args("of3dPrimitive::getTexCoords",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("of3dPrimitive::getTexCoords",1,"of3dPrimitive *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_of3dPrimitive,0))){ - SWIG_fail_ptr("3dPrimitive_getTexCoords",1,SWIGTYPE_p_of3dPrimitive); } result = (ofVec4f *) &(arg1)->getTexCoords(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec4f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_3dPrimitive_getTexCoordsPtr__SWIG_1(lua_State* L) { int SWIG_arg = 0; - of3dPrimitive *arg1 = (of3dPrimitive *) 0 ; ofVec4f *result = 0 ; SWIG_check_num_args("of3dPrimitive::getTexCoordsPtr",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("of3dPrimitive::getTexCoordsPtr",1,"of3dPrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_of3dPrimitive,0))){ - SWIG_fail_ptr("3dPrimitive_getTexCoordsPtr",1,SWIGTYPE_p_of3dPrimitive); } - result = (ofVec4f *)((of3dPrimitive const *)arg1)->getTexCoordsPtr(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec4f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_3dPrimitive_getTexCoordsPtr(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); - if (argc == 1) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_of3dPrimitive, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_3dPrimitive_getTexCoordsPtr__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_of3dPrimitive, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_3dPrimitive_getTexCoordsPtr__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function '3dPrimitive_getTexCoordsPtr'\n" - " Possible C/C++ prototypes are:\n" " of3dPrimitive::getTexCoordsPtr()\n" " of3dPrimitive::getTexCoordsPtr() const\n"); - lua_error(L);return 0; } -static int _wrap_3dPrimitive_getTexCoords__SWIG_1(lua_State* L) { int SWIG_arg = 0; of3dPrimitive *arg1 = (of3dPrimitive *) 0 ; - ofVec4f *result = 0 ; SWIG_check_num_args("of3dPrimitive::getTexCoords",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("of3dPrimitive::getTexCoords",1,"of3dPrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_of3dPrimitive,0))){ - SWIG_fail_ptr("3dPrimitive_getTexCoords",1,SWIGTYPE_p_of3dPrimitive); } - result = (ofVec4f *) &((of3dPrimitive const *)arg1)->getTexCoords(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec4f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_3dPrimitive_getTexCoords(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_of3dPrimitive, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_3dPrimitive_getTexCoords__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_of3dPrimitive, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_3dPrimitive_getTexCoords__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function '3dPrimitive_getTexCoords'\n" - " Possible C/C++ prototypes are:\n" " of3dPrimitive::getTexCoords()\n" " of3dPrimitive::getTexCoords() const\n"); - lua_error(L);return 0; } -static int _wrap_3dPrimitive_hasScaling(lua_State* L) { int SWIG_arg = 0; of3dPrimitive *arg1 = (of3dPrimitive *) 0 ; - bool result; SWIG_check_num_args("of3dPrimitive::hasScaling",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("of3dPrimitive::hasScaling",1,"of3dPrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_of3dPrimitive,0))){ - SWIG_fail_ptr("3dPrimitive_hasScaling",1,SWIGTYPE_p_of3dPrimitive); } - result = (bool)((of3dPrimitive const *)arg1)->hasScaling(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_3dPrimitive_hasNormalsEnabled(lua_State* L) { int SWIG_arg = 0; of3dPrimitive *arg1 = (of3dPrimitive *) 0 ; - bool result; SWIG_check_num_args("of3dPrimitive::hasNormalsEnabled",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("of3dPrimitive::hasNormalsEnabled",1,"of3dPrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_of3dPrimitive,0))){ - SWIG_fail_ptr("3dPrimitive_hasNormalsEnabled",1,SWIGTYPE_p_of3dPrimitive); } - result = (bool)((of3dPrimitive const *)arg1)->hasNormalsEnabled(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_3dPrimitive_enableNormals(lua_State* L) { int SWIG_arg = 0; of3dPrimitive *arg1 = (of3dPrimitive *) 0 ; - SWIG_check_num_args("of3dPrimitive::enableNormals",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("of3dPrimitive::enableNormals",1,"of3dPrimitive *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_of3dPrimitive,0))){ - SWIG_fail_ptr("3dPrimitive_enableNormals",1,SWIGTYPE_p_of3dPrimitive); } (arg1)->enableNormals(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_3dPrimitive_enableTextures(lua_State* L) { int SWIG_arg = 0; of3dPrimitive *arg1 = (of3dPrimitive *) 0 ; - SWIG_check_num_args("of3dPrimitive::enableTextures",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("of3dPrimitive::enableTextures",1,"of3dPrimitive *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_of3dPrimitive,0))){ - SWIG_fail_ptr("3dPrimitive_enableTextures",1,SWIGTYPE_p_of3dPrimitive); } (arg1)->enableTextures(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_3dPrimitive_enableColors(lua_State* L) { int SWIG_arg = 0; of3dPrimitive *arg1 = (of3dPrimitive *) 0 ; - SWIG_check_num_args("of3dPrimitive::enableColors",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("of3dPrimitive::enableColors",1,"of3dPrimitive *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_of3dPrimitive,0))){ - SWIG_fail_ptr("3dPrimitive_enableColors",1,SWIGTYPE_p_of3dPrimitive); } (arg1)->enableColors(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_3dPrimitive_disableNormals(lua_State* L) { int SWIG_arg = 0; of3dPrimitive *arg1 = (of3dPrimitive *) 0 ; - SWIG_check_num_args("of3dPrimitive::disableNormals",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("of3dPrimitive::disableNormals",1,"of3dPrimitive *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_of3dPrimitive,0))){ - SWIG_fail_ptr("3dPrimitive_disableNormals",1,SWIGTYPE_p_of3dPrimitive); } (arg1)->disableNormals(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_3dPrimitive_disableTextures(lua_State* L) { int SWIG_arg = 0; of3dPrimitive *arg1 = (of3dPrimitive *) 0 ; - SWIG_check_num_args("of3dPrimitive::disableTextures",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("of3dPrimitive::disableTextures",1,"of3dPrimitive *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_of3dPrimitive,0))){ - SWIG_fail_ptr("3dPrimitive_disableTextures",1,SWIGTYPE_p_of3dPrimitive); } (arg1)->disableTextures(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_3dPrimitive_disableColors(lua_State* L) { int SWIG_arg = 0; of3dPrimitive *arg1 = (of3dPrimitive *) 0 ; - SWIG_check_num_args("of3dPrimitive::disableColors",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("of3dPrimitive::disableColors",1,"of3dPrimitive *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_of3dPrimitive,0))){ - SWIG_fail_ptr("3dPrimitive_disableColors",1,SWIGTYPE_p_of3dPrimitive); } (arg1)->disableColors(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_3dPrimitive_drawVertices(lua_State* L) { int SWIG_arg = 0; of3dPrimitive *arg1 = (of3dPrimitive *) 0 ; - SWIG_check_num_args("of3dPrimitive::drawVertices",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("of3dPrimitive::drawVertices",1,"of3dPrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_of3dPrimitive,0))){ - SWIG_fail_ptr("3dPrimitive_drawVertices",1,SWIGTYPE_p_of3dPrimitive); } ((of3dPrimitive const *)arg1)->drawVertices(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_3dPrimitive_drawWireframe(lua_State* L) { int SWIG_arg = 0; of3dPrimitive *arg1 = (of3dPrimitive *) 0 ; - SWIG_check_num_args("of3dPrimitive::drawWireframe",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("of3dPrimitive::drawWireframe",1,"of3dPrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_of3dPrimitive,0))){ - SWIG_fail_ptr("3dPrimitive_drawWireframe",1,SWIGTYPE_p_of3dPrimitive); } ((of3dPrimitive const *)arg1)->drawWireframe(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_3dPrimitive_drawFaces(lua_State* L) { int SWIG_arg = 0; of3dPrimitive *arg1 = (of3dPrimitive *) 0 ; - SWIG_check_num_args("of3dPrimitive::drawFaces",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("of3dPrimitive::drawFaces",1,"of3dPrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_of3dPrimitive,0))){ - SWIG_fail_ptr("3dPrimitive_drawFaces",1,SWIGTYPE_p_of3dPrimitive); } ((of3dPrimitive const *)arg1)->drawFaces(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_3dPrimitive_draw(lua_State* L) { int SWIG_arg = 0; of3dPrimitive *arg1 = (of3dPrimitive *) 0 ; - ofPolyRenderMode arg2 ; SWIG_check_num_args("of3dPrimitive::draw",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("of3dPrimitive::draw",1,"of3dPrimitive const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("of3dPrimitive::draw",2,"ofPolyRenderMode"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_of3dPrimitive,0))){ - SWIG_fail_ptr("3dPrimitive_draw",1,SWIGTYPE_p_of3dPrimitive); } arg2 = (ofPolyRenderMode)(int)lua_tonumber(L, 2); - ((of3dPrimitive const *)arg1)->draw(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_3dPrimitive_drawNormals__SWIG_0(lua_State* L) { int SWIG_arg = 0; of3dPrimitive *arg1 = (of3dPrimitive *) 0 ; - float arg2 ; bool arg3 ; SWIG_check_num_args("of3dPrimitive::drawNormals",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("of3dPrimitive::drawNormals",1,"of3dPrimitive const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("of3dPrimitive::drawNormals",2,"float"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("of3dPrimitive::drawNormals",3,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_of3dPrimitive,0))){ - SWIG_fail_ptr("3dPrimitive_drawNormals",1,SWIGTYPE_p_of3dPrimitive); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (lua_toboolean(L, 3)!=0); ((of3dPrimitive const *)arg1)->drawNormals(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_3dPrimitive_drawNormals__SWIG_1(lua_State* L) { int SWIG_arg = 0; of3dPrimitive *arg1 = (of3dPrimitive *) 0 ; - float arg2 ; SWIG_check_num_args("of3dPrimitive::drawNormals",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("of3dPrimitive::drawNormals",1,"of3dPrimitive const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("of3dPrimitive::drawNormals",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_of3dPrimitive,0))){ - SWIG_fail_ptr("3dPrimitive_drawNormals",1,SWIGTYPE_p_of3dPrimitive); } arg2 = (float)lua_tonumber(L, 2); - ((of3dPrimitive const *)arg1)->drawNormals(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_3dPrimitive_drawNormals(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_of3dPrimitive, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_3dPrimitive_drawNormals__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_of3dPrimitive, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - return _wrap_3dPrimitive_drawNormals__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function '3dPrimitive_drawNormals'\n" - " Possible C/C++ prototypes are:\n" " of3dPrimitive::drawNormals(float,bool) const\n" - " of3dPrimitive::drawNormals(float) const\n"); lua_error(L);return 0; } -static int _wrap_3dPrimitive_drawAxes(lua_State* L) { int SWIG_arg = 0; of3dPrimitive *arg1 = (of3dPrimitive *) 0 ; float arg2 ; - SWIG_check_num_args("of3dPrimitive::drawAxes",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("of3dPrimitive::drawAxes",1,"of3dPrimitive const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("of3dPrimitive::drawAxes",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_of3dPrimitive,0))){ - SWIG_fail_ptr("3dPrimitive_drawAxes",1,SWIGTYPE_p_of3dPrimitive); } arg2 = (float)lua_tonumber(L, 2); - ((of3dPrimitive const *)arg1)->drawAxes(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_3dPrimitive_setUseVbo(lua_State* L) { int SWIG_arg = 0; of3dPrimitive *arg1 = (of3dPrimitive *) 0 ; bool arg2 ; - SWIG_check_num_args("of3dPrimitive::setUseVbo",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("of3dPrimitive::setUseVbo",1,"of3dPrimitive *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("of3dPrimitive::setUseVbo",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_of3dPrimitive,0))){ - SWIG_fail_ptr("3dPrimitive_setUseVbo",1,SWIGTYPE_p_of3dPrimitive); } arg2 = (lua_toboolean(L, 2)!=0); - (arg1)->setUseVbo(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_3dPrimitive_isUsingVbo(lua_State* L) { int SWIG_arg = 0; of3dPrimitive *arg1 = (of3dPrimitive *) 0 ; - bool result; SWIG_check_num_args("of3dPrimitive::isUsingVbo",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("of3dPrimitive::isUsingVbo",1,"of3dPrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_of3dPrimitive,0))){ - SWIG_fail_ptr("3dPrimitive_isUsingVbo",1,SWIGTYPE_p_of3dPrimitive); } - result = (bool)((of3dPrimitive const *)arg1)->isUsingVbo(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_3dPrimitive(void *obj) { -of3dPrimitive *arg1 = (of3dPrimitive *) obj; -delete arg1; -} -static int _proxy__wrap_new_3dPrimitive(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_3dPrimitive); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_3dPrimitive_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_3dPrimitive_methods[]= { - { "mapTexCoords", _wrap_3dPrimitive_mapTexCoords}, - { "mapTexCoordsFromTexture", _wrap_3dPrimitive_mapTexCoordsFromTexture}, - { "getMeshPtr", _wrap_3dPrimitive_getMeshPtr}, - { "getMesh", _wrap_3dPrimitive_getMesh}, - { "getTexCoordsPtr", _wrap_3dPrimitive_getTexCoordsPtr}, - { "getTexCoords", _wrap_3dPrimitive_getTexCoords}, - { "hasScaling", _wrap_3dPrimitive_hasScaling}, - { "hasNormalsEnabled", _wrap_3dPrimitive_hasNormalsEnabled}, - { "enableNormals", _wrap_3dPrimitive_enableNormals}, - { "enableTextures", _wrap_3dPrimitive_enableTextures}, - { "enableColors", _wrap_3dPrimitive_enableColors}, - { "disableNormals", _wrap_3dPrimitive_disableNormals}, - { "disableTextures", _wrap_3dPrimitive_disableTextures}, - { "disableColors", _wrap_3dPrimitive_disableColors}, - { "drawVertices", _wrap_3dPrimitive_drawVertices}, - { "drawWireframe", _wrap_3dPrimitive_drawWireframe}, - { "drawFaces", _wrap_3dPrimitive_drawFaces}, - { "drawNormals", _wrap_3dPrimitive_drawNormals}, - { "drawAxes", _wrap_3dPrimitive_drawAxes}, - { "setUseVbo", _wrap_3dPrimitive_setUseVbo}, - { "isUsingVbo", _wrap_3dPrimitive_isUsingVbo}, - {0,0} -}; -static swig_lua_method swig_3dPrimitive_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_3dPrimitive_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_3dPrimitive_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_3dPrimitive_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_3dPrimitive_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_3dPrimitive_Sf_SwigStatic = { - "3dPrimitive", - swig_3dPrimitive_Sf_SwigStatic_methods, - swig_3dPrimitive_Sf_SwigStatic_attributes, - swig_3dPrimitive_Sf_SwigStatic_constants, - swig_3dPrimitive_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_3dPrimitive_bases[] = {0,0}; -static const char *swig_3dPrimitive_base_names[] = {"ofNode *",0}; -static swig_lua_class _wrap_class_3dPrimitive = { "3dPrimitive", "3dPrimitive", &SWIGTYPE_p_of3dPrimitive,_proxy__wrap_new_3dPrimitive, swig_delete_3dPrimitive, swig_3dPrimitive_methods, swig_3dPrimitive_attributes, &swig_3dPrimitive_Sf_SwigStatic, swig_3dPrimitive_meta, swig_3dPrimitive_bases, swig_3dPrimitive_base_names }; - -static int _wrap_new_PlanePrimitive__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPlanePrimitive *result = 0 ; - SWIG_check_num_args("ofPlanePrimitive::ofPlanePrimitive",0,0) result = (ofPlanePrimitive *)new ofPlanePrimitive(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofPlanePrimitive,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_PlanePrimitive__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; int arg3 ; int arg4 ; - ofPrimitiveMode arg5 ; ofPlanePrimitive *result = 0 ; SWIG_check_num_args("ofPlanePrimitive::ofPlanePrimitive",5,5) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofPlanePrimitive::ofPlanePrimitive",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPlanePrimitive::ofPlanePrimitive",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPlanePrimitive::ofPlanePrimitive",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPlanePrimitive::ofPlanePrimitive",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPlanePrimitive::ofPlanePrimitive",5,"ofPrimitiveMode"); - arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); arg5 = (ofPrimitiveMode)(int)lua_tonumber(L, 5); - result = (ofPlanePrimitive *)new ofPlanePrimitive(arg1,arg2,arg3,arg4,arg5); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofPlanePrimitive,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_PlanePrimitive__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; int arg3 ; int arg4 ; - ofPlanePrimitive *result = 0 ; SWIG_check_num_args("ofPlanePrimitive::ofPlanePrimitive",4,4) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofPlanePrimitive::ofPlanePrimitive",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPlanePrimitive::ofPlanePrimitive",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPlanePrimitive::ofPlanePrimitive",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPlanePrimitive::ofPlanePrimitive",4,"int"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - result = (ofPlanePrimitive *)new ofPlanePrimitive(arg1,arg2,arg3,arg4); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofPlanePrimitive,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_PlanePrimitive(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); - if (argc == 0) { return _wrap_new_PlanePrimitive__SWIG_0(L);} if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_new_PlanePrimitive__SWIG_2(L);} } } } } - if (argc == 5) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_new_PlanePrimitive__SWIG_1(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_PlanePrimitive'\n" " Possible C/C++ prototypes are:\n" - " ofPlanePrimitive::ofPlanePrimitive()\n" " ofPlanePrimitive::ofPlanePrimitive(float,float,int,int,ofPrimitiveMode)\n" - " ofPlanePrimitive::ofPlanePrimitive(float,float,int,int)\n"); lua_error(L);return 0; } -static int _wrap_PlanePrimitive_set__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPlanePrimitive *arg1 = (ofPlanePrimitive *) 0 ; - float arg2 ; float arg3 ; int arg4 ; int arg5 ; ofPrimitiveMode arg6 ; SWIG_check_num_args("ofPlanePrimitive::set",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPlanePrimitive::set",1,"ofPlanePrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPlanePrimitive::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPlanePrimitive::set",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPlanePrimitive::set",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPlanePrimitive::set",5,"int"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPlanePrimitive::set",6,"ofPrimitiveMode"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPlanePrimitive,0))){ - SWIG_fail_ptr("PlanePrimitive_set",1,SWIGTYPE_p_ofPlanePrimitive); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); - arg6 = (ofPrimitiveMode)(int)lua_tonumber(L, 6); (arg1)->set(arg2,arg3,arg4,arg5,arg6); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_PlanePrimitive_set__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPlanePrimitive *arg1 = (ofPlanePrimitive *) 0 ; - float arg2 ; float arg3 ; int arg4 ; int arg5 ; SWIG_check_num_args("ofPlanePrimitive::set",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPlanePrimitive::set",1,"ofPlanePrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPlanePrimitive::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPlanePrimitive::set",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPlanePrimitive::set",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPlanePrimitive::set",5,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPlanePrimitive,0))){ - SWIG_fail_ptr("PlanePrimitive_set",1,SWIGTYPE_p_ofPlanePrimitive); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); - (arg1)->set(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_PlanePrimitive_set__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPlanePrimitive *arg1 = (ofPlanePrimitive *) 0 ; - float arg2 ; float arg3 ; SWIG_check_num_args("ofPlanePrimitive::set",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPlanePrimitive::set",1,"ofPlanePrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPlanePrimitive::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPlanePrimitive::set",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPlanePrimitive,0))){ - SWIG_fail_ptr("PlanePrimitive_set",1,SWIGTYPE_p_ofPlanePrimitive); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->set(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_PlanePrimitive_set(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPlanePrimitive, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_PlanePrimitive_set__SWIG_2(L);} } } } if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPlanePrimitive, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_PlanePrimitive_set__SWIG_1(L);} } } } } } if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPlanePrimitive, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { return _wrap_PlanePrimitive_set__SWIG_0(L);} } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'PlanePrimitive_set'\n" " Possible C/C++ prototypes are:\n" - " ofPlanePrimitive::set(float,float,int,int,ofPrimitiveMode)\n" " ofPlanePrimitive::set(float,float,int,int)\n" - " ofPlanePrimitive::set(float,float)\n"); lua_error(L);return 0; } -static int _wrap_PlanePrimitive_resizeToTexture__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofPlanePrimitive *arg1 = (ofPlanePrimitive *) 0 ; ofTexture *arg2 = 0 ; float arg3 ; - SWIG_check_num_args("ofPlanePrimitive::resizeToTexture",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPlanePrimitive::resizeToTexture",1,"ofPlanePrimitive *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPlanePrimitive::resizeToTexture",2,"ofTexture &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPlanePrimitive::resizeToTexture",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPlanePrimitive,0))){ - SWIG_fail_ptr("PlanePrimitive_resizeToTexture",1,SWIGTYPE_p_ofPlanePrimitive); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("PlanePrimitive_resizeToTexture",2,SWIGTYPE_p_ofTexture); } arg3 = (float)lua_tonumber(L, 3); - (arg1)->resizeToTexture(*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_PlanePrimitive_resizeToTexture__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofPlanePrimitive *arg1 = (ofPlanePrimitive *) 0 ; ofTexture *arg2 = 0 ; - SWIG_check_num_args("ofPlanePrimitive::resizeToTexture",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPlanePrimitive::resizeToTexture",1,"ofPlanePrimitive *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPlanePrimitive::resizeToTexture",2,"ofTexture &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPlanePrimitive,0))){ - SWIG_fail_ptr("PlanePrimitive_resizeToTexture",1,SWIGTYPE_p_ofPlanePrimitive); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("PlanePrimitive_resizeToTexture",2,SWIGTYPE_p_ofTexture); } (arg1)->resizeToTexture(*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_PlanePrimitive_resizeToTexture(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPlanePrimitive, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_PlanePrimitive_resizeToTexture__SWIG_1(L);} } } if (argc == 3) { int _v; - { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPlanePrimitive, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_PlanePrimitive_resizeToTexture__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'PlanePrimitive_resizeToTexture'\n" - " Possible C/C++ prototypes are:\n" " ofPlanePrimitive::resizeToTexture(ofTexture &,float)\n" - " ofPlanePrimitive::resizeToTexture(ofTexture &)\n"); lua_error(L);return 0; } -static int _wrap_PlanePrimitive_setWidth(lua_State* L) { int SWIG_arg = 0; ofPlanePrimitive *arg1 = (ofPlanePrimitive *) 0 ; - float arg2 ; SWIG_check_num_args("ofPlanePrimitive::setWidth",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPlanePrimitive::setWidth",1,"ofPlanePrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPlanePrimitive::setWidth",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPlanePrimitive,0))){ - SWIG_fail_ptr("PlanePrimitive_setWidth",1,SWIGTYPE_p_ofPlanePrimitive); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setWidth(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_PlanePrimitive_setHeight(lua_State* L) { int SWIG_arg = 0; ofPlanePrimitive *arg1 = (ofPlanePrimitive *) 0 ; - float arg2 ; SWIG_check_num_args("ofPlanePrimitive::setHeight",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPlanePrimitive::setHeight",1,"ofPlanePrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPlanePrimitive::setHeight",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPlanePrimitive,0))){ - SWIG_fail_ptr("PlanePrimitive_setHeight",1,SWIGTYPE_p_ofPlanePrimitive); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setHeight(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_PlanePrimitive_setColumns(lua_State* L) { int SWIG_arg = 0; ofPlanePrimitive *arg1 = (ofPlanePrimitive *) 0 ; - int arg2 ; SWIG_check_num_args("ofPlanePrimitive::setColumns",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPlanePrimitive::setColumns",1,"ofPlanePrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPlanePrimitive::setColumns",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPlanePrimitive,0))){ - SWIG_fail_ptr("PlanePrimitive_setColumns",1,SWIGTYPE_p_ofPlanePrimitive); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->setColumns(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_PlanePrimitive_setRows(lua_State* L) { int SWIG_arg = 0; ofPlanePrimitive *arg1 = (ofPlanePrimitive *) 0 ; - int arg2 ; SWIG_check_num_args("ofPlanePrimitive::setRows",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPlanePrimitive::setRows",1,"ofPlanePrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPlanePrimitive::setRows",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPlanePrimitive,0))){ - SWIG_fail_ptr("PlanePrimitive_setRows",1,SWIGTYPE_p_ofPlanePrimitive); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->setRows(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_PlanePrimitive_setResolution(lua_State* L) { int SWIG_arg = 0; - ofPlanePrimitive *arg1 = (ofPlanePrimitive *) 0 ; int arg2 ; int arg3 ; - SWIG_check_num_args("ofPlanePrimitive::setResolution",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPlanePrimitive::setResolution",1,"ofPlanePrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPlanePrimitive::setResolution",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPlanePrimitive::setResolution",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPlanePrimitive,0))){ - SWIG_fail_ptr("PlanePrimitive_setResolution",1,SWIGTYPE_p_ofPlanePrimitive); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); (arg1)->setResolution(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_PlanePrimitive_setMode(lua_State* L) { int SWIG_arg = 0; ofPlanePrimitive *arg1 = (ofPlanePrimitive *) 0 ; - ofPrimitiveMode arg2 ; SWIG_check_num_args("ofPlanePrimitive::setMode",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPlanePrimitive::setMode",1,"ofPlanePrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPlanePrimitive::setMode",2,"ofPrimitiveMode"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPlanePrimitive,0))){ - SWIG_fail_ptr("PlanePrimitive_setMode",1,SWIGTYPE_p_ofPlanePrimitive); } arg2 = (ofPrimitiveMode)(int)lua_tonumber(L, 2); - (arg1)->setMode(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_PlanePrimitive_getNumColumns(lua_State* L) { int SWIG_arg = 0; - ofPlanePrimitive *arg1 = (ofPlanePrimitive *) 0 ; int result; SWIG_check_num_args("ofPlanePrimitive::getNumColumns",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPlanePrimitive::getNumColumns",1,"ofPlanePrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPlanePrimitive,0))){ - SWIG_fail_ptr("PlanePrimitive_getNumColumns",1,SWIGTYPE_p_ofPlanePrimitive); } - result = (int)((ofPlanePrimitive const *)arg1)->getNumColumns(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_PlanePrimitive_getNumRows(lua_State* L) { int SWIG_arg = 0; ofPlanePrimitive *arg1 = (ofPlanePrimitive *) 0 ; - int result; SWIG_check_num_args("ofPlanePrimitive::getNumRows",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPlanePrimitive::getNumRows",1,"ofPlanePrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPlanePrimitive,0))){ - SWIG_fail_ptr("PlanePrimitive_getNumRows",1,SWIGTYPE_p_ofPlanePrimitive); } - result = (int)((ofPlanePrimitive const *)arg1)->getNumRows(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_PlanePrimitive_getResolution(lua_State* L) { int SWIG_arg = 0; - ofPlanePrimitive *arg1 = (ofPlanePrimitive *) 0 ; ofVec2f result; SWIG_check_num_args("ofPlanePrimitive::getResolution",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPlanePrimitive::getResolution",1,"ofPlanePrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPlanePrimitive,0))){ - SWIG_fail_ptr("PlanePrimitive_getResolution",1,SWIGTYPE_p_ofPlanePrimitive); } - result = ((ofPlanePrimitive const *)arg1)->getResolution(); { ofVec2f * resultptr = new ofVec2f((const ofVec2f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_PlanePrimitive_getWidth(lua_State* L) { int SWIG_arg = 0; ofPlanePrimitive *arg1 = (ofPlanePrimitive *) 0 ; - float result; SWIG_check_num_args("ofPlanePrimitive::getWidth",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPlanePrimitive::getWidth",1,"ofPlanePrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPlanePrimitive,0))){ - SWIG_fail_ptr("PlanePrimitive_getWidth",1,SWIGTYPE_p_ofPlanePrimitive); } - result = (float)((ofPlanePrimitive const *)arg1)->getWidth(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_PlanePrimitive_getHeight(lua_State* L) { int SWIG_arg = 0; ofPlanePrimitive *arg1 = (ofPlanePrimitive *) 0 ; - float result; SWIG_check_num_args("ofPlanePrimitive::getHeight",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPlanePrimitive::getHeight",1,"ofPlanePrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPlanePrimitive,0))){ - SWIG_fail_ptr("PlanePrimitive_getHeight",1,SWIGTYPE_p_ofPlanePrimitive); } - result = (float)((ofPlanePrimitive const *)arg1)->getHeight(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_PlanePrimitive(void *obj) { -ofPlanePrimitive *arg1 = (ofPlanePrimitive *) obj; -delete arg1; -} -static int _proxy__wrap_new_PlanePrimitive(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_PlanePrimitive); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_PlanePrimitive_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_PlanePrimitive_methods[]= { - { "set", _wrap_PlanePrimitive_set}, - { "resizeToTexture", _wrap_PlanePrimitive_resizeToTexture}, - { "setWidth", _wrap_PlanePrimitive_setWidth}, - { "setHeight", _wrap_PlanePrimitive_setHeight}, - { "setColumns", _wrap_PlanePrimitive_setColumns}, - { "setRows", _wrap_PlanePrimitive_setRows}, - { "setResolution", _wrap_PlanePrimitive_setResolution}, - { "setMode", _wrap_PlanePrimitive_setMode}, - { "getNumColumns", _wrap_PlanePrimitive_getNumColumns}, - { "getNumRows", _wrap_PlanePrimitive_getNumRows}, - { "getResolution", _wrap_PlanePrimitive_getResolution}, - { "getWidth", _wrap_PlanePrimitive_getWidth}, - { "getHeight", _wrap_PlanePrimitive_getHeight}, - {0,0} -}; -static swig_lua_method swig_PlanePrimitive_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_PlanePrimitive_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_PlanePrimitive_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_PlanePrimitive_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_PlanePrimitive_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_PlanePrimitive_Sf_SwigStatic = { - "PlanePrimitive", - swig_PlanePrimitive_Sf_SwigStatic_methods, - swig_PlanePrimitive_Sf_SwigStatic_attributes, - swig_PlanePrimitive_Sf_SwigStatic_constants, - swig_PlanePrimitive_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_PlanePrimitive_bases[] = {0,0}; -static const char *swig_PlanePrimitive_base_names[] = {"of3dPrimitive *",0}; -static swig_lua_class _wrap_class_PlanePrimitive = { "PlanePrimitive", "PlanePrimitive", &SWIGTYPE_p_ofPlanePrimitive,_proxy__wrap_new_PlanePrimitive, swig_delete_PlanePrimitive, swig_PlanePrimitive_methods, swig_PlanePrimitive_attributes, &swig_PlanePrimitive_Sf_SwigStatic, swig_PlanePrimitive_meta, swig_PlanePrimitive_bases, swig_PlanePrimitive_base_names }; - -static int _wrap_new_SpherePrimitive__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofSpherePrimitive *result = 0 ; - SWIG_check_num_args("ofSpherePrimitive::ofSpherePrimitive",0,0) result = (ofSpherePrimitive *)new ofSpherePrimitive(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofSpherePrimitive,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_SpherePrimitive__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; int arg2 ; ofPrimitiveMode arg3 ; - ofSpherePrimitive *result = 0 ; SWIG_check_num_args("ofSpherePrimitive::ofSpherePrimitive",3,3) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSpherePrimitive::ofSpherePrimitive",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSpherePrimitive::ofSpherePrimitive",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofSpherePrimitive::ofSpherePrimitive",3,"ofPrimitiveMode"); - arg1 = (float)lua_tonumber(L, 1); arg2 = (int)lua_tonumber(L, 2); arg3 = (ofPrimitiveMode)(int)lua_tonumber(L, 3); - result = (ofSpherePrimitive *)new ofSpherePrimitive(arg1,arg2,arg3); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofSpherePrimitive,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_SpherePrimitive__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; int arg2 ; - ofSpherePrimitive *result = 0 ; SWIG_check_num_args("ofSpherePrimitive::ofSpherePrimitive",2,2) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSpherePrimitive::ofSpherePrimitive",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSpherePrimitive::ofSpherePrimitive",2,"int"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (int)lua_tonumber(L, 2); result = (ofSpherePrimitive *)new ofSpherePrimitive(arg1,arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofSpherePrimitive,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_SpherePrimitive(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_SpherePrimitive__SWIG_0(L);} if (argc == 2) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_new_SpherePrimitive__SWIG_2(L);} } } if (argc == 3) { int _v; - { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_new_SpherePrimitive__SWIG_1(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SpherePrimitive'\n" - " Possible C/C++ prototypes are:\n" " ofSpherePrimitive::ofSpherePrimitive()\n" - " ofSpherePrimitive::ofSpherePrimitive(float,int,ofPrimitiveMode)\n" - " ofSpherePrimitive::ofSpherePrimitive(float,int)\n"); lua_error(L);return 0; } -static int _wrap_SpherePrimitive_set__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofSpherePrimitive *arg1 = (ofSpherePrimitive *) 0 ; float arg2 ; int arg3 ; ofPrimitiveMode arg4 ; - SWIG_check_num_args("ofSpherePrimitive::set",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSpherePrimitive::set",1,"ofSpherePrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSpherePrimitive::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofSpherePrimitive::set",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofSpherePrimitive::set",4,"ofPrimitiveMode"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSpherePrimitive,0))){ - SWIG_fail_ptr("SpherePrimitive_set",1,SWIGTYPE_p_ofSpherePrimitive); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); arg4 = (ofPrimitiveMode)(int)lua_tonumber(L, 4); (arg1)->set(arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SpherePrimitive_set__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofSpherePrimitive *arg1 = (ofSpherePrimitive *) 0 ; float arg2 ; int arg3 ; SWIG_check_num_args("ofSpherePrimitive::set",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSpherePrimitive::set",1,"ofSpherePrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSpherePrimitive::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofSpherePrimitive::set",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSpherePrimitive,0))){ - SWIG_fail_ptr("SpherePrimitive_set",1,SWIGTYPE_p_ofSpherePrimitive); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); (arg1)->set(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_SpherePrimitive_set(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofSpherePrimitive, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_SpherePrimitive_set__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofSpherePrimitive, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_SpherePrimitive_set__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SpherePrimitive_set'\n" - " Possible C/C++ prototypes are:\n" " ofSpherePrimitive::set(float,int,ofPrimitiveMode)\n" - " ofSpherePrimitive::set(float,int)\n"); lua_error(L);return 0; } -static int _wrap_SpherePrimitive_setResolution(lua_State* L) { int SWIG_arg = 0; - ofSpherePrimitive *arg1 = (ofSpherePrimitive *) 0 ; int arg2 ; SWIG_check_num_args("ofSpherePrimitive::setResolution",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSpherePrimitive::setResolution",1,"ofSpherePrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSpherePrimitive::setResolution",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSpherePrimitive,0))){ - SWIG_fail_ptr("SpherePrimitive_setResolution",1,SWIGTYPE_p_ofSpherePrimitive); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->setResolution(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SpherePrimitive_setRadius(lua_State* L) { int SWIG_arg = 0; ofSpherePrimitive *arg1 = (ofSpherePrimitive *) 0 ; - float arg2 ; SWIG_check_num_args("ofSpherePrimitive::setRadius",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSpherePrimitive::setRadius",1,"ofSpherePrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSpherePrimitive::setRadius",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSpherePrimitive,0))){ - SWIG_fail_ptr("SpherePrimitive_setRadius",1,SWIGTYPE_p_ofSpherePrimitive); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setRadius(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SpherePrimitive_setMode(lua_State* L) { int SWIG_arg = 0; ofSpherePrimitive *arg1 = (ofSpherePrimitive *) 0 ; - ofPrimitiveMode arg2 ; SWIG_check_num_args("ofSpherePrimitive::setMode",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSpherePrimitive::setMode",1,"ofSpherePrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSpherePrimitive::setMode",2,"ofPrimitiveMode"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSpherePrimitive,0))){ - SWIG_fail_ptr("SpherePrimitive_setMode",1,SWIGTYPE_p_ofSpherePrimitive); } arg2 = (ofPrimitiveMode)(int)lua_tonumber(L, 2); - (arg1)->setMode(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SpherePrimitive_getRadius(lua_State* L) { int SWIG_arg = 0; ofSpherePrimitive *arg1 = (ofSpherePrimitive *) 0 ; - float result; SWIG_check_num_args("ofSpherePrimitive::getRadius",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSpherePrimitive::getRadius",1,"ofSpherePrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSpherePrimitive,0))){ - SWIG_fail_ptr("SpherePrimitive_getRadius",1,SWIGTYPE_p_ofSpherePrimitive); } - result = (float)((ofSpherePrimitive const *)arg1)->getRadius(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SpherePrimitive_getResolution(lua_State* L) { int SWIG_arg = 0; - ofSpherePrimitive *arg1 = (ofSpherePrimitive *) 0 ; int result; SWIG_check_num_args("ofSpherePrimitive::getResolution",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSpherePrimitive::getResolution",1,"ofSpherePrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSpherePrimitive,0))){ - SWIG_fail_ptr("SpherePrimitive_getResolution",1,SWIGTYPE_p_ofSpherePrimitive); } - result = (int)((ofSpherePrimitive const *)arg1)->getResolution(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_SpherePrimitive(void *obj) { -ofSpherePrimitive *arg1 = (ofSpherePrimitive *) obj; -delete arg1; -} -static int _proxy__wrap_new_SpherePrimitive(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_SpherePrimitive); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_SpherePrimitive_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_SpherePrimitive_methods[]= { - { "set", _wrap_SpherePrimitive_set}, - { "setResolution", _wrap_SpherePrimitive_setResolution}, - { "setRadius", _wrap_SpherePrimitive_setRadius}, - { "setMode", _wrap_SpherePrimitive_setMode}, - { "getRadius", _wrap_SpherePrimitive_getRadius}, - { "getResolution", _wrap_SpherePrimitive_getResolution}, - {0,0} -}; -static swig_lua_method swig_SpherePrimitive_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_SpherePrimitive_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_SpherePrimitive_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_SpherePrimitive_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_SpherePrimitive_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_SpherePrimitive_Sf_SwigStatic = { - "SpherePrimitive", - swig_SpherePrimitive_Sf_SwigStatic_methods, - swig_SpherePrimitive_Sf_SwigStatic_attributes, - swig_SpherePrimitive_Sf_SwigStatic_constants, - swig_SpherePrimitive_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_SpherePrimitive_bases[] = {0,0}; -static const char *swig_SpherePrimitive_base_names[] = {"of3dPrimitive *",0}; -static swig_lua_class _wrap_class_SpherePrimitive = { "SpherePrimitive", "SpherePrimitive", &SWIGTYPE_p_ofSpherePrimitive,_proxy__wrap_new_SpherePrimitive, swig_delete_SpherePrimitive, swig_SpherePrimitive_methods, swig_SpherePrimitive_attributes, &swig_SpherePrimitive_Sf_SwigStatic, swig_SpherePrimitive_meta, swig_SpherePrimitive_bases, swig_SpherePrimitive_base_names }; - -static int _wrap_new_IcoSpherePrimitive__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofIcoSpherePrimitive *result = 0 ; - SWIG_check_num_args("ofIcoSpherePrimitive::ofIcoSpherePrimitive",0,0) - result = (ofIcoSpherePrimitive *)new ofIcoSpherePrimitive(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofIcoSpherePrimitive,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_IcoSpherePrimitive__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; int arg2 ; - ofIcoSpherePrimitive *result = 0 ; SWIG_check_num_args("ofIcoSpherePrimitive::ofIcoSpherePrimitive",2,2) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofIcoSpherePrimitive::ofIcoSpherePrimitive",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofIcoSpherePrimitive::ofIcoSpherePrimitive",2,"int"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (int)lua_tonumber(L, 2); result = (ofIcoSpherePrimitive *)new ofIcoSpherePrimitive(arg1,arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofIcoSpherePrimitive,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_IcoSpherePrimitive(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_IcoSpherePrimitive__SWIG_0(L);} if (argc == 2) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_new_IcoSpherePrimitive__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_IcoSpherePrimitive'\n" - " Possible C/C++ prototypes are:\n" " ofIcoSpherePrimitive::ofIcoSpherePrimitive()\n" - " ofIcoSpherePrimitive::ofIcoSpherePrimitive(float,int)\n"); lua_error(L);return 0; } -static int _wrap_IcoSpherePrimitive_set(lua_State* L) { int SWIG_arg = 0; - ofIcoSpherePrimitive *arg1 = (ofIcoSpherePrimitive *) 0 ; float arg2 ; int arg3 ; - SWIG_check_num_args("ofIcoSpherePrimitive::set",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofIcoSpherePrimitive::set",1,"ofIcoSpherePrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofIcoSpherePrimitive::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofIcoSpherePrimitive::set",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofIcoSpherePrimitive,0))){ - SWIG_fail_ptr("IcoSpherePrimitive_set",1,SWIGTYPE_p_ofIcoSpherePrimitive); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); (arg1)->set(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_IcoSpherePrimitive_setResolution(lua_State* L) { int SWIG_arg = 0; - ofIcoSpherePrimitive *arg1 = (ofIcoSpherePrimitive *) 0 ; int arg2 ; - SWIG_check_num_args("ofIcoSpherePrimitive::setResolution",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofIcoSpherePrimitive::setResolution",1,"ofIcoSpherePrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofIcoSpherePrimitive::setResolution",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofIcoSpherePrimitive,0))){ - SWIG_fail_ptr("IcoSpherePrimitive_setResolution",1,SWIGTYPE_p_ofIcoSpherePrimitive); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->setResolution(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_IcoSpherePrimitive_setRadius(lua_State* L) { int SWIG_arg = 0; - ofIcoSpherePrimitive *arg1 = (ofIcoSpherePrimitive *) 0 ; float arg2 ; - SWIG_check_num_args("ofIcoSpherePrimitive::setRadius",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofIcoSpherePrimitive::setRadius",1,"ofIcoSpherePrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofIcoSpherePrimitive::setRadius",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofIcoSpherePrimitive,0))){ - SWIG_fail_ptr("IcoSpherePrimitive_setRadius",1,SWIGTYPE_p_ofIcoSpherePrimitive); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setRadius(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_IcoSpherePrimitive_setMode(lua_State* L) { int SWIG_arg = 0; - ofIcoSpherePrimitive *arg1 = (ofIcoSpherePrimitive *) 0 ; ofPrimitiveMode arg2 ; - SWIG_check_num_args("ofIcoSpherePrimitive::setMode",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofIcoSpherePrimitive::setMode",1,"ofIcoSpherePrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofIcoSpherePrimitive::setMode",2,"ofPrimitiveMode"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofIcoSpherePrimitive,0))){ - SWIG_fail_ptr("IcoSpherePrimitive_setMode",1,SWIGTYPE_p_ofIcoSpherePrimitive); } - arg2 = (ofPrimitiveMode)(int)lua_tonumber(L, 2); (arg1)->setMode(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_IcoSpherePrimitive_getRadius(lua_State* L) { int SWIG_arg = 0; - ofIcoSpherePrimitive *arg1 = (ofIcoSpherePrimitive *) 0 ; float result; - SWIG_check_num_args("ofIcoSpherePrimitive::getRadius",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofIcoSpherePrimitive::getRadius",1,"ofIcoSpherePrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofIcoSpherePrimitive,0))){ - SWIG_fail_ptr("IcoSpherePrimitive_getRadius",1,SWIGTYPE_p_ofIcoSpherePrimitive); } - result = (float)((ofIcoSpherePrimitive const *)arg1)->getRadius(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_IcoSpherePrimitive_getResolution(lua_State* L) { int SWIG_arg = 0; - ofIcoSpherePrimitive *arg1 = (ofIcoSpherePrimitive *) 0 ; int result; - SWIG_check_num_args("ofIcoSpherePrimitive::getResolution",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofIcoSpherePrimitive::getResolution",1,"ofIcoSpherePrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofIcoSpherePrimitive,0))){ - SWIG_fail_ptr("IcoSpherePrimitive_getResolution",1,SWIGTYPE_p_ofIcoSpherePrimitive); } - result = (int)((ofIcoSpherePrimitive const *)arg1)->getResolution(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_IcoSpherePrimitive(void *obj) { -ofIcoSpherePrimitive *arg1 = (ofIcoSpherePrimitive *) obj; -delete arg1; -} -static int _proxy__wrap_new_IcoSpherePrimitive(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_IcoSpherePrimitive); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_IcoSpherePrimitive_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_IcoSpherePrimitive_methods[]= { - { "set", _wrap_IcoSpherePrimitive_set}, - { "setResolution", _wrap_IcoSpherePrimitive_setResolution}, - { "setRadius", _wrap_IcoSpherePrimitive_setRadius}, - { "setMode", _wrap_IcoSpherePrimitive_setMode}, - { "getRadius", _wrap_IcoSpherePrimitive_getRadius}, - { "getResolution", _wrap_IcoSpherePrimitive_getResolution}, - {0,0} -}; -static swig_lua_method swig_IcoSpherePrimitive_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_IcoSpherePrimitive_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_IcoSpherePrimitive_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_IcoSpherePrimitive_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_IcoSpherePrimitive_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_IcoSpherePrimitive_Sf_SwigStatic = { - "IcoSpherePrimitive", - swig_IcoSpherePrimitive_Sf_SwigStatic_methods, - swig_IcoSpherePrimitive_Sf_SwigStatic_attributes, - swig_IcoSpherePrimitive_Sf_SwigStatic_constants, - swig_IcoSpherePrimitive_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_IcoSpherePrimitive_bases[] = {0,0}; -static const char *swig_IcoSpherePrimitive_base_names[] = {"of3dPrimitive *",0}; -static swig_lua_class _wrap_class_IcoSpherePrimitive = { "IcoSpherePrimitive", "IcoSpherePrimitive", &SWIGTYPE_p_ofIcoSpherePrimitive,_proxy__wrap_new_IcoSpherePrimitive, swig_delete_IcoSpherePrimitive, swig_IcoSpherePrimitive_methods, swig_IcoSpherePrimitive_attributes, &swig_IcoSpherePrimitive_Sf_SwigStatic, swig_IcoSpherePrimitive_meta, swig_IcoSpherePrimitive_bases, swig_IcoSpherePrimitive_base_names }; - -static int _wrap_new_CylinderPrimitive__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofCylinderPrimitive *result = 0 ; - SWIG_check_num_args("ofCylinderPrimitive::ofCylinderPrimitive",0,0) result = (ofCylinderPrimitive *)new ofCylinderPrimitive(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofCylinderPrimitive,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_CylinderPrimitive__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; int arg3 ; int arg4 ; - int arg5 ; bool arg6 ; ofPrimitiveMode arg7 ; ofCylinderPrimitive *result = 0 ; - SWIG_check_num_args("ofCylinderPrimitive::ofCylinderPrimitive",7,7) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofCylinderPrimitive::ofCylinderPrimitive",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofCylinderPrimitive::ofCylinderPrimitive",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofCylinderPrimitive::ofCylinderPrimitive",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofCylinderPrimitive::ofCylinderPrimitive",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofCylinderPrimitive::ofCylinderPrimitive",5,"int"); - if(!lua_isboolean(L,6)) SWIG_fail_arg("ofCylinderPrimitive::ofCylinderPrimitive",6,"bool"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofCylinderPrimitive::ofCylinderPrimitive",7,"ofPrimitiveMode"); - arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); arg6 = (lua_toboolean(L, 6)!=0); - arg7 = (ofPrimitiveMode)(int)lua_tonumber(L, 7); - result = (ofCylinderPrimitive *)new ofCylinderPrimitive(arg1,arg2,arg3,arg4,arg5,arg6,arg7); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofCylinderPrimitive,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_CylinderPrimitive__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; int arg3 ; int arg4 ; - int arg5 ; bool arg6 ; ofCylinderPrimitive *result = 0 ; SWIG_check_num_args("ofCylinderPrimitive::ofCylinderPrimitive",6,6) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofCylinderPrimitive::ofCylinderPrimitive",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofCylinderPrimitive::ofCylinderPrimitive",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofCylinderPrimitive::ofCylinderPrimitive",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofCylinderPrimitive::ofCylinderPrimitive",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofCylinderPrimitive::ofCylinderPrimitive",5,"int"); - if(!lua_isboolean(L,6)) SWIG_fail_arg("ofCylinderPrimitive::ofCylinderPrimitive",6,"bool"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - arg5 = (int)lua_tonumber(L, 5); arg6 = (lua_toboolean(L, 6)!=0); - result = (ofCylinderPrimitive *)new ofCylinderPrimitive(arg1,arg2,arg3,arg4,arg5,arg6); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofCylinderPrimitive,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_CylinderPrimitive__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; int arg3 ; int arg4 ; - int arg5 ; ofCylinderPrimitive *result = 0 ; SWIG_check_num_args("ofCylinderPrimitive::ofCylinderPrimitive",5,5) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofCylinderPrimitive::ofCylinderPrimitive",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofCylinderPrimitive::ofCylinderPrimitive",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofCylinderPrimitive::ofCylinderPrimitive",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofCylinderPrimitive::ofCylinderPrimitive",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofCylinderPrimitive::ofCylinderPrimitive",5,"int"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - arg5 = (int)lua_tonumber(L, 5); result = (ofCylinderPrimitive *)new ofCylinderPrimitive(arg1,arg2,arg3,arg4,arg5); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofCylinderPrimitive,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_CylinderPrimitive__SWIG_4(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; int arg3 ; int arg4 ; - ofCylinderPrimitive *result = 0 ; SWIG_check_num_args("ofCylinderPrimitive::ofCylinderPrimitive",4,4) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofCylinderPrimitive::ofCylinderPrimitive",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofCylinderPrimitive::ofCylinderPrimitive",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofCylinderPrimitive::ofCylinderPrimitive",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofCylinderPrimitive::ofCylinderPrimitive",4,"int"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - result = (ofCylinderPrimitive *)new ofCylinderPrimitive(arg1,arg2,arg3,arg4); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofCylinderPrimitive,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_CylinderPrimitive(lua_State* L) { int argc; int argv[8]={ 1,2,3,4,5,6,7,8} ; argc = lua_gettop(L); - if (argc == 0) { return _wrap_new_CylinderPrimitive__SWIG_0(L);} if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_new_CylinderPrimitive__SWIG_4(L);} } } } } - if (argc == 5) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_new_CylinderPrimitive__SWIG_3(L);} } } } } } - if (argc == 6) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isboolean(L,argv[5]); } if (_v) { - return _wrap_new_CylinderPrimitive__SWIG_2(L);} } } } } } } if (argc == 7) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isboolean(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { - return _wrap_new_CylinderPrimitive__SWIG_1(L);} } } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_CylinderPrimitive'\n" - " Possible C/C++ prototypes are:\n" " ofCylinderPrimitive::ofCylinderPrimitive()\n" - " ofCylinderPrimitive::ofCylinderPrimitive(float,float,int,int,int,bool,ofPrimitiveMode)\n" - " ofCylinderPrimitive::ofCylinderPrimitive(float,float,int,int,int,bool)\n" - " ofCylinderPrimitive::ofCylinderPrimitive(float,float,int,int,int)\n" - " ofCylinderPrimitive::ofCylinderPrimitive(float,float,int,int)\n"); lua_error(L);return 0; } -static int _wrap_CylinderPrimitive_set__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; float arg2 ; float arg3 ; int arg4 ; int arg5 ; int arg6 ; bool arg7 ; - ofPrimitiveMode arg8 ; SWIG_check_num_args("ofCylinderPrimitive::set",8,8) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::set",1,"ofCylinderPrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofCylinderPrimitive::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofCylinderPrimitive::set",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofCylinderPrimitive::set",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofCylinderPrimitive::set",5,"int"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofCylinderPrimitive::set",6,"int"); - if(!lua_isboolean(L,7)) SWIG_fail_arg("ofCylinderPrimitive::set",7,"bool"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofCylinderPrimitive::set",8,"ofPrimitiveMode"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ - SWIG_fail_ptr("CylinderPrimitive_set",1,SWIGTYPE_p_ofCylinderPrimitive); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); - arg6 = (int)lua_tonumber(L, 6); arg7 = (lua_toboolean(L, 7)!=0); arg8 = (ofPrimitiveMode)(int)lua_tonumber(L, 8); - (arg1)->set(arg2,arg3,arg4,arg5,arg6,arg7,arg8); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_CylinderPrimitive_set__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; float arg2 ; float arg3 ; int arg4 ; int arg5 ; int arg6 ; bool arg7 ; - SWIG_check_num_args("ofCylinderPrimitive::set",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::set",1,"ofCylinderPrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofCylinderPrimitive::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofCylinderPrimitive::set",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofCylinderPrimitive::set",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofCylinderPrimitive::set",5,"int"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofCylinderPrimitive::set",6,"int"); - if(!lua_isboolean(L,7)) SWIG_fail_arg("ofCylinderPrimitive::set",7,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ - SWIG_fail_ptr("CylinderPrimitive_set",1,SWIGTYPE_p_ofCylinderPrimitive); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); - arg6 = (int)lua_tonumber(L, 6); arg7 = (lua_toboolean(L, 7)!=0); (arg1)->set(arg2,arg3,arg4,arg5,arg6,arg7); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_CylinderPrimitive_set__SWIG_2(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; float arg2 ; float arg3 ; int arg4 ; int arg5 ; int arg6 ; - SWIG_check_num_args("ofCylinderPrimitive::set",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::set",1,"ofCylinderPrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofCylinderPrimitive::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofCylinderPrimitive::set",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofCylinderPrimitive::set",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofCylinderPrimitive::set",5,"int"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofCylinderPrimitive::set",6,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ - SWIG_fail_ptr("CylinderPrimitive_set",1,SWIGTYPE_p_ofCylinderPrimitive); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); - arg6 = (int)lua_tonumber(L, 6); (arg1)->set(arg2,arg3,arg4,arg5,arg6); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_CylinderPrimitive_set__SWIG_3(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; float arg2 ; float arg3 ; int arg4 ; int arg5 ; - SWIG_check_num_args("ofCylinderPrimitive::set",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::set",1,"ofCylinderPrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofCylinderPrimitive::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofCylinderPrimitive::set",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofCylinderPrimitive::set",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofCylinderPrimitive::set",5,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ - SWIG_fail_ptr("CylinderPrimitive_set",1,SWIGTYPE_p_ofCylinderPrimitive); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); - (arg1)->set(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_CylinderPrimitive_set__SWIG_4(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; float arg2 ; float arg3 ; bool arg4 ; - SWIG_check_num_args("ofCylinderPrimitive::set",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::set",1,"ofCylinderPrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofCylinderPrimitive::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofCylinderPrimitive::set",3,"float"); - if(!lua_isboolean(L,4)) SWIG_fail_arg("ofCylinderPrimitive::set",4,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ - SWIG_fail_ptr("CylinderPrimitive_set",1,SWIGTYPE_p_ofCylinderPrimitive); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (lua_toboolean(L, 4)!=0); (arg1)->set(arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_CylinderPrimitive_set__SWIG_5(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofCylinderPrimitive::set",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::set",1,"ofCylinderPrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofCylinderPrimitive::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofCylinderPrimitive::set",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ - SWIG_fail_ptr("CylinderPrimitive_set",1,SWIGTYPE_p_ofCylinderPrimitive); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->set(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_CylinderPrimitive_set(lua_State* L) { int argc; int argv[9]={ 1,2,3,4,5,6,7,8,9} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCylinderPrimitive, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_CylinderPrimitive_set__SWIG_5(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCylinderPrimitive, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isboolean(L,argv[3]); } if (_v) { return _wrap_CylinderPrimitive_set__SWIG_4(L);} } } } } - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCylinderPrimitive, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_CylinderPrimitive_set__SWIG_3(L);} } } } } } if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCylinderPrimitive, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { return _wrap_CylinderPrimitive_set__SWIG_2(L);} } } } } } } - if (argc == 7) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCylinderPrimitive, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isboolean(L,argv[6]); } if (_v) { - return _wrap_CylinderPrimitive_set__SWIG_1(L);} } } } } } } } if (argc == 8) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCylinderPrimitive, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isboolean(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { return _wrap_CylinderPrimitive_set__SWIG_0(L);} } } } } } } - } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'CylinderPrimitive_set'\n" - " Possible C/C++ prototypes are:\n" " ofCylinderPrimitive::set(float,float,int,int,int,bool,ofPrimitiveMode)\n" - " ofCylinderPrimitive::set(float,float,int,int,int,bool)\n" " ofCylinderPrimitive::set(float,float,int,int,int)\n" - " ofCylinderPrimitive::set(float,float,int,int)\n" " ofCylinderPrimitive::set(float,float,bool)\n" - " ofCylinderPrimitive::set(float,float)\n"); lua_error(L);return 0; } -static int _wrap_CylinderPrimitive_setRadius(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; float arg2 ; SWIG_check_num_args("ofCylinderPrimitive::setRadius",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::setRadius",1,"ofCylinderPrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofCylinderPrimitive::setRadius",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ - SWIG_fail_ptr("CylinderPrimitive_setRadius",1,SWIGTYPE_p_ofCylinderPrimitive); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setRadius(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_CylinderPrimitive_setHeight(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; float arg2 ; SWIG_check_num_args("ofCylinderPrimitive::setHeight",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::setHeight",1,"ofCylinderPrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofCylinderPrimitive::setHeight",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ - SWIG_fail_ptr("CylinderPrimitive_setHeight",1,SWIGTYPE_p_ofCylinderPrimitive); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setHeight(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_CylinderPrimitive_setCapped(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; bool arg2 ; SWIG_check_num_args("ofCylinderPrimitive::setCapped",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::setCapped",1,"ofCylinderPrimitive *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofCylinderPrimitive::setCapped",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ - SWIG_fail_ptr("CylinderPrimitive_setCapped",1,SWIGTYPE_p_ofCylinderPrimitive); } arg2 = (lua_toboolean(L, 2)!=0); - (arg1)->setCapped(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_CylinderPrimitive_setResolutionRadius(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; int arg2 ; - SWIG_check_num_args("ofCylinderPrimitive::setResolutionRadius",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::setResolutionRadius",1,"ofCylinderPrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofCylinderPrimitive::setResolutionRadius",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ - SWIG_fail_ptr("CylinderPrimitive_setResolutionRadius",1,SWIGTYPE_p_ofCylinderPrimitive); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->setResolutionRadius(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_CylinderPrimitive_setResolutionHeight(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; int arg2 ; - SWIG_check_num_args("ofCylinderPrimitive::setResolutionHeight",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::setResolutionHeight",1,"ofCylinderPrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofCylinderPrimitive::setResolutionHeight",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ - SWIG_fail_ptr("CylinderPrimitive_setResolutionHeight",1,SWIGTYPE_p_ofCylinderPrimitive); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->setResolutionHeight(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_CylinderPrimitive_setResolutionCap(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; int arg2 ; - SWIG_check_num_args("ofCylinderPrimitive::setResolutionCap",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::setResolutionCap",1,"ofCylinderPrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofCylinderPrimitive::setResolutionCap",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ - SWIG_fail_ptr("CylinderPrimitive_setResolutionCap",1,SWIGTYPE_p_ofCylinderPrimitive); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->setResolutionCap(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_CylinderPrimitive_setResolution__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; int arg2 ; int arg3 ; int arg4 ; - SWIG_check_num_args("ofCylinderPrimitive::setResolution",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::setResolution",1,"ofCylinderPrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofCylinderPrimitive::setResolution",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofCylinderPrimitive::setResolution",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofCylinderPrimitive::setResolution",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ - SWIG_fail_ptr("CylinderPrimitive_setResolution",1,SWIGTYPE_p_ofCylinderPrimitive); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); (arg1)->setResolution(arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_CylinderPrimitive_setResolution__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; int arg2 ; int arg3 ; - SWIG_check_num_args("ofCylinderPrimitive::setResolution",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::setResolution",1,"ofCylinderPrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofCylinderPrimitive::setResolution",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofCylinderPrimitive::setResolution",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ - SWIG_fail_ptr("CylinderPrimitive_setResolution",1,SWIGTYPE_p_ofCylinderPrimitive); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); (arg1)->setResolution(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_CylinderPrimitive_setResolution(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCylinderPrimitive, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_CylinderPrimitive_setResolution__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofCylinderPrimitive, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_CylinderPrimitive_setResolution__SWIG_0(L);} } } - } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'CylinderPrimitive_setResolution'\n" - " Possible C/C++ prototypes are:\n" " ofCylinderPrimitive::setResolution(int,int,int)\n" - " ofCylinderPrimitive::setResolution(int,int)\n"); lua_error(L);return 0; } -static int _wrap_CylinderPrimitive_setMode(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; ofPrimitiveMode arg2 ; - SWIG_check_num_args("ofCylinderPrimitive::setMode",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::setMode",1,"ofCylinderPrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofCylinderPrimitive::setMode",2,"ofPrimitiveMode"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ - SWIG_fail_ptr("CylinderPrimitive_setMode",1,SWIGTYPE_p_ofCylinderPrimitive); } - arg2 = (ofPrimitiveMode)(int)lua_tonumber(L, 2); (arg1)->setMode(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_CylinderPrimitive_setTopCapColor(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; ofColor arg2 ; ofColor *argp2 ; - SWIG_check_num_args("ofCylinderPrimitive::setTopCapColor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::setTopCapColor",1,"ofCylinderPrimitive *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofCylinderPrimitive::setTopCapColor",2,"ofColor"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ - SWIG_fail_ptr("CylinderPrimitive_setTopCapColor",1,SWIGTYPE_p_ofCylinderPrimitive); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("CylinderPrimitive_setTopCapColor",2,SWIGTYPE_p_ofColor_T_unsigned_char_t); } arg2 = *argp2; - (arg1)->setTopCapColor(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_CylinderPrimitive_setCylinderColor(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; ofColor arg2 ; ofColor *argp2 ; - SWIG_check_num_args("ofCylinderPrimitive::setCylinderColor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::setCylinderColor",1,"ofCylinderPrimitive *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofCylinderPrimitive::setCylinderColor",2,"ofColor"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ - SWIG_fail_ptr("CylinderPrimitive_setCylinderColor",1,SWIGTYPE_p_ofCylinderPrimitive); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("CylinderPrimitive_setCylinderColor",2,SWIGTYPE_p_ofColor_T_unsigned_char_t); } arg2 = *argp2; - (arg1)->setCylinderColor(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_CylinderPrimitive_setBottomCapColor(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; ofColor arg2 ; ofColor *argp2 ; - SWIG_check_num_args("ofCylinderPrimitive::setBottomCapColor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::setBottomCapColor",1,"ofCylinderPrimitive *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofCylinderPrimitive::setBottomCapColor",2,"ofColor"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ - SWIG_fail_ptr("CylinderPrimitive_setBottomCapColor",1,SWIGTYPE_p_ofCylinderPrimitive); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("CylinderPrimitive_setBottomCapColor",2,SWIGTYPE_p_ofColor_T_unsigned_char_t); } arg2 = *argp2; - (arg1)->setBottomCapColor(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_CylinderPrimitive_getTopCapIndices(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; SwigValueWrapper< std::vector< unsigned short > > result; - SWIG_check_num_args("ofCylinderPrimitive::getTopCapIndices",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::getTopCapIndices",1,"ofCylinderPrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ - SWIG_fail_ptr("CylinderPrimitive_getTopCapIndices",1,SWIGTYPE_p_ofCylinderPrimitive); } - result = ((ofCylinderPrimitive const *)arg1)->getTopCapIndices(); { - std::vector< ofIndexType > * resultptr = new std::vector< ofIndexType >((const std::vector< ofIndexType > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_unsigned_short_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_CylinderPrimitive_getTopCapMesh(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; ofMesh result; - SWIG_check_num_args("ofCylinderPrimitive::getTopCapMesh",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::getTopCapMesh",1,"ofCylinderPrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ - SWIG_fail_ptr("CylinderPrimitive_getTopCapMesh",1,SWIGTYPE_p_ofCylinderPrimitive); } - result = ((ofCylinderPrimitive const *)arg1)->getTopCapMesh(); { ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_CylinderPrimitive_getCylinderIndices(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; SwigValueWrapper< std::vector< unsigned short > > result; - SWIG_check_num_args("ofCylinderPrimitive::getCylinderIndices",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::getCylinderIndices",1,"ofCylinderPrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ - SWIG_fail_ptr("CylinderPrimitive_getCylinderIndices",1,SWIGTYPE_p_ofCylinderPrimitive); } - result = ((ofCylinderPrimitive const *)arg1)->getCylinderIndices(); { - std::vector< ofIndexType > * resultptr = new std::vector< ofIndexType >((const std::vector< ofIndexType > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_unsigned_short_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_CylinderPrimitive_getCylinderMesh(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; ofMesh result; - SWIG_check_num_args("ofCylinderPrimitive::getCylinderMesh",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::getCylinderMesh",1,"ofCylinderPrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ - SWIG_fail_ptr("CylinderPrimitive_getCylinderMesh",1,SWIGTYPE_p_ofCylinderPrimitive); } - result = ((ofCylinderPrimitive const *)arg1)->getCylinderMesh(); { ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_CylinderPrimitive_getBottomCapIndices(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; SwigValueWrapper< std::vector< unsigned short > > result; - SWIG_check_num_args("ofCylinderPrimitive::getBottomCapIndices",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::getBottomCapIndices",1,"ofCylinderPrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ - SWIG_fail_ptr("CylinderPrimitive_getBottomCapIndices",1,SWIGTYPE_p_ofCylinderPrimitive); } - result = ((ofCylinderPrimitive const *)arg1)->getBottomCapIndices(); { - std::vector< ofIndexType > * resultptr = new std::vector< ofIndexType >((const std::vector< ofIndexType > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_unsigned_short_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_CylinderPrimitive_getBottomCapMesh(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; ofMesh result; - SWIG_check_num_args("ofCylinderPrimitive::getBottomCapMesh",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::getBottomCapMesh",1,"ofCylinderPrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ - SWIG_fail_ptr("CylinderPrimitive_getBottomCapMesh",1,SWIGTYPE_p_ofCylinderPrimitive); } - result = ((ofCylinderPrimitive const *)arg1)->getBottomCapMesh(); { ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_CylinderPrimitive_getResolutionRadius(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; int result; - SWIG_check_num_args("ofCylinderPrimitive::getResolutionRadius",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::getResolutionRadius",1,"ofCylinderPrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ - SWIG_fail_ptr("CylinderPrimitive_getResolutionRadius",1,SWIGTYPE_p_ofCylinderPrimitive); } - result = (int)((ofCylinderPrimitive const *)arg1)->getResolutionRadius(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_CylinderPrimitive_getResolutionHeight(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; int result; - SWIG_check_num_args("ofCylinderPrimitive::getResolutionHeight",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::getResolutionHeight",1,"ofCylinderPrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ - SWIG_fail_ptr("CylinderPrimitive_getResolutionHeight",1,SWIGTYPE_p_ofCylinderPrimitive); } - result = (int)((ofCylinderPrimitive const *)arg1)->getResolutionHeight(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_CylinderPrimitive_getResolutionCap(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; int result; - SWIG_check_num_args("ofCylinderPrimitive::getResolutionCap",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::getResolutionCap",1,"ofCylinderPrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ - SWIG_fail_ptr("CylinderPrimitive_getResolutionCap",1,SWIGTYPE_p_ofCylinderPrimitive); } - result = (int)((ofCylinderPrimitive const *)arg1)->getResolutionCap(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_CylinderPrimitive_getResolution(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; ofVec3f result; - SWIG_check_num_args("ofCylinderPrimitive::getResolution",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::getResolution",1,"ofCylinderPrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ - SWIG_fail_ptr("CylinderPrimitive_getResolution",1,SWIGTYPE_p_ofCylinderPrimitive); } - result = ((ofCylinderPrimitive const *)arg1)->getResolution(); { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_CylinderPrimitive_getHeight(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; float result; - SWIG_check_num_args("ofCylinderPrimitive::getHeight",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::getHeight",1,"ofCylinderPrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ - SWIG_fail_ptr("CylinderPrimitive_getHeight",1,SWIGTYPE_p_ofCylinderPrimitive); } - result = (float)((ofCylinderPrimitive const *)arg1)->getHeight(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_CylinderPrimitive_getRadius(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; float result; - SWIG_check_num_args("ofCylinderPrimitive::getRadius",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::getRadius",1,"ofCylinderPrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ - SWIG_fail_ptr("CylinderPrimitive_getRadius",1,SWIGTYPE_p_ofCylinderPrimitive); } - result = (float)((ofCylinderPrimitive const *)arg1)->getRadius(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_CylinderPrimitive_getCapped(lua_State* L) { int SWIG_arg = 0; - ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) 0 ; bool result; SWIG_check_num_args("ofCylinderPrimitive::getCapped",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofCylinderPrimitive::getCapped",1,"ofCylinderPrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofCylinderPrimitive,0))){ - SWIG_fail_ptr("CylinderPrimitive_getCapped",1,SWIGTYPE_p_ofCylinderPrimitive); } - result = (bool)((ofCylinderPrimitive const *)arg1)->getCapped(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_CylinderPrimitive(void *obj) { -ofCylinderPrimitive *arg1 = (ofCylinderPrimitive *) obj; -delete arg1; -} -static int _proxy__wrap_new_CylinderPrimitive(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_CylinderPrimitive); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_CylinderPrimitive_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_CylinderPrimitive_methods[]= { - { "set", _wrap_CylinderPrimitive_set}, - { "setRadius", _wrap_CylinderPrimitive_setRadius}, - { "setHeight", _wrap_CylinderPrimitive_setHeight}, - { "setCapped", _wrap_CylinderPrimitive_setCapped}, - { "setResolutionRadius", _wrap_CylinderPrimitive_setResolutionRadius}, - { "setResolutionHeight", _wrap_CylinderPrimitive_setResolutionHeight}, - { "setResolutionCap", _wrap_CylinderPrimitive_setResolutionCap}, - { "setResolution", _wrap_CylinderPrimitive_setResolution}, - { "setMode", _wrap_CylinderPrimitive_setMode}, - { "setTopCapColor", _wrap_CylinderPrimitive_setTopCapColor}, - { "setCylinderColor", _wrap_CylinderPrimitive_setCylinderColor}, - { "setBottomCapColor", _wrap_CylinderPrimitive_setBottomCapColor}, - { "getTopCapIndices", _wrap_CylinderPrimitive_getTopCapIndices}, - { "getTopCapMesh", _wrap_CylinderPrimitive_getTopCapMesh}, - { "getCylinderIndices", _wrap_CylinderPrimitive_getCylinderIndices}, - { "getCylinderMesh", _wrap_CylinderPrimitive_getCylinderMesh}, - { "getBottomCapIndices", _wrap_CylinderPrimitive_getBottomCapIndices}, - { "getBottomCapMesh", _wrap_CylinderPrimitive_getBottomCapMesh}, - { "getResolutionRadius", _wrap_CylinderPrimitive_getResolutionRadius}, - { "getResolutionHeight", _wrap_CylinderPrimitive_getResolutionHeight}, - { "getResolutionCap", _wrap_CylinderPrimitive_getResolutionCap}, - { "getResolution", _wrap_CylinderPrimitive_getResolution}, - { "getHeight", _wrap_CylinderPrimitive_getHeight}, - { "getRadius", _wrap_CylinderPrimitive_getRadius}, - { "getCapped", _wrap_CylinderPrimitive_getCapped}, - {0,0} -}; -static swig_lua_method swig_CylinderPrimitive_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_CylinderPrimitive_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_CylinderPrimitive_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_CylinderPrimitive_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_CylinderPrimitive_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_CylinderPrimitive_Sf_SwigStatic = { - "CylinderPrimitive", - swig_CylinderPrimitive_Sf_SwigStatic_methods, - swig_CylinderPrimitive_Sf_SwigStatic_attributes, - swig_CylinderPrimitive_Sf_SwigStatic_constants, - swig_CylinderPrimitive_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_CylinderPrimitive_bases[] = {0,0}; -static const char *swig_CylinderPrimitive_base_names[] = {"of3dPrimitive *",0}; -static swig_lua_class _wrap_class_CylinderPrimitive = { "CylinderPrimitive", "CylinderPrimitive", &SWIGTYPE_p_ofCylinderPrimitive,_proxy__wrap_new_CylinderPrimitive, swig_delete_CylinderPrimitive, swig_CylinderPrimitive_methods, swig_CylinderPrimitive_attributes, &swig_CylinderPrimitive_Sf_SwigStatic, swig_CylinderPrimitive_meta, swig_CylinderPrimitive_bases, swig_CylinderPrimitive_base_names }; - -static int _wrap_new_ConePrimitive__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofConePrimitive *result = 0 ; - SWIG_check_num_args("ofConePrimitive::ofConePrimitive",0,0) result = (ofConePrimitive *)new ofConePrimitive(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofConePrimitive,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_ConePrimitive__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; int arg3 ; int arg4 ; - int arg5 ; ofPrimitiveMode arg6 ; ofConePrimitive *result = 0 ; SWIG_check_num_args("ofConePrimitive::ofConePrimitive",6,6) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofConePrimitive::ofConePrimitive",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofConePrimitive::ofConePrimitive",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofConePrimitive::ofConePrimitive",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofConePrimitive::ofConePrimitive",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofConePrimitive::ofConePrimitive",5,"int"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofConePrimitive::ofConePrimitive",6,"ofPrimitiveMode"); - arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); arg6 = (ofPrimitiveMode)(int)lua_tonumber(L, 6); - result = (ofConePrimitive *)new ofConePrimitive(arg1,arg2,arg3,arg4,arg5,arg6); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofConePrimitive,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_ConePrimitive__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; int arg3 ; int arg4 ; - int arg5 ; ofConePrimitive *result = 0 ; SWIG_check_num_args("ofConePrimitive::ofConePrimitive",5,5) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofConePrimitive::ofConePrimitive",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofConePrimitive::ofConePrimitive",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofConePrimitive::ofConePrimitive",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofConePrimitive::ofConePrimitive",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofConePrimitive::ofConePrimitive",5,"int"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - arg5 = (int)lua_tonumber(L, 5); result = (ofConePrimitive *)new ofConePrimitive(arg1,arg2,arg3,arg4,arg5); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofConePrimitive,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_ConePrimitive__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; int arg3 ; int arg4 ; - ofConePrimitive *result = 0 ; SWIG_check_num_args("ofConePrimitive::ofConePrimitive",4,4) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofConePrimitive::ofConePrimitive",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofConePrimitive::ofConePrimitive",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofConePrimitive::ofConePrimitive",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofConePrimitive::ofConePrimitive",4,"int"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - result = (ofConePrimitive *)new ofConePrimitive(arg1,arg2,arg3,arg4); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofConePrimitive,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_ConePrimitive(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); - if (argc == 0) { return _wrap_new_ConePrimitive__SWIG_0(L);} if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_new_ConePrimitive__SWIG_3(L);} } } } } if (argc == 5) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_new_ConePrimitive__SWIG_2(L);} } } } } } - if (argc == 6) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { - return _wrap_new_ConePrimitive__SWIG_1(L);} } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_ConePrimitive'\n" " Possible C/C++ prototypes are:\n" - " ofConePrimitive::ofConePrimitive()\n" " ofConePrimitive::ofConePrimitive(float,float,int,int,int,ofPrimitiveMode)\n" - " ofConePrimitive::ofConePrimitive(float,float,int,int,int)\n" - " ofConePrimitive::ofConePrimitive(float,float,int,int)\n"); lua_error(L);return 0; } -static int _wrap_ConePrimitive_set__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofConePrimitive *arg1 = (ofConePrimitive *) 0 ; - float arg2 ; float arg3 ; int arg4 ; int arg5 ; int arg6 ; ofPrimitiveMode arg7 ; - SWIG_check_num_args("ofConePrimitive::set",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofConePrimitive::set",1,"ofConePrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofConePrimitive::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofConePrimitive::set",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofConePrimitive::set",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofConePrimitive::set",5,"int"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofConePrimitive::set",6,"int"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofConePrimitive::set",7,"ofPrimitiveMode"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofConePrimitive,0))){ - SWIG_fail_ptr("ConePrimitive_set",1,SWIGTYPE_p_ofConePrimitive); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); - arg6 = (int)lua_tonumber(L, 6); arg7 = (ofPrimitiveMode)(int)lua_tonumber(L, 7); (arg1)->set(arg2,arg3,arg4,arg5,arg6,arg7); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ConePrimitive_set__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofConePrimitive *arg1 = (ofConePrimitive *) 0 ; - float arg2 ; float arg3 ; int arg4 ; int arg5 ; int arg6 ; SWIG_check_num_args("ofConePrimitive::set",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofConePrimitive::set",1,"ofConePrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofConePrimitive::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofConePrimitive::set",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofConePrimitive::set",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofConePrimitive::set",5,"int"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofConePrimitive::set",6,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofConePrimitive,0))){ - SWIG_fail_ptr("ConePrimitive_set",1,SWIGTYPE_p_ofConePrimitive); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); - arg6 = (int)lua_tonumber(L, 6); (arg1)->set(arg2,arg3,arg4,arg5,arg6); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ConePrimitive_set__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofConePrimitive *arg1 = (ofConePrimitive *) 0 ; - float arg2 ; float arg3 ; int arg4 ; int arg5 ; SWIG_check_num_args("ofConePrimitive::set",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofConePrimitive::set",1,"ofConePrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofConePrimitive::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofConePrimitive::set",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofConePrimitive::set",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofConePrimitive::set",5,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofConePrimitive,0))){ - SWIG_fail_ptr("ConePrimitive_set",1,SWIGTYPE_p_ofConePrimitive); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); - (arg1)->set(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ConePrimitive_set__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofConePrimitive *arg1 = (ofConePrimitive *) 0 ; - float arg2 ; float arg3 ; SWIG_check_num_args("ofConePrimitive::set",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofConePrimitive::set",1,"ofConePrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofConePrimitive::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofConePrimitive::set",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofConePrimitive,0))){ - SWIG_fail_ptr("ConePrimitive_set",1,SWIGTYPE_p_ofConePrimitive); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->set(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ConePrimitive_set(lua_State* L) { int argc; int argv[8]={ 1,2,3,4,5,6,7,8} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofConePrimitive, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_ConePrimitive_set__SWIG_3(L);} } } } if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofConePrimitive, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_ConePrimitive_set__SWIG_2(L);} } } } } } if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofConePrimitive, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { return _wrap_ConePrimitive_set__SWIG_1(L);} } } } } } } - if (argc == 7) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofConePrimitive, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { - return _wrap_ConePrimitive_set__SWIG_0(L);} } } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ConePrimitive_set'\n" " Possible C/C++ prototypes are:\n" - " ofConePrimitive::set(float,float,int,int,int,ofPrimitiveMode)\n" " ofConePrimitive::set(float,float,int,int,int)\n" - " ofConePrimitive::set(float,float,int,int)\n" " ofConePrimitive::set(float,float)\n"); lua_error(L);return 0; } -static int _wrap_ConePrimitive_setResolutionRadius(lua_State* L) { int SWIG_arg = 0; - ofConePrimitive *arg1 = (ofConePrimitive *) 0 ; int arg2 ; SWIG_check_num_args("ofConePrimitive::setResolutionRadius",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofConePrimitive::setResolutionRadius",1,"ofConePrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofConePrimitive::setResolutionRadius",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofConePrimitive,0))){ - SWIG_fail_ptr("ConePrimitive_setResolutionRadius",1,SWIGTYPE_p_ofConePrimitive); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->setResolutionRadius(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ConePrimitive_setResolutionHeight(lua_State* L) { int SWIG_arg = 0; - ofConePrimitive *arg1 = (ofConePrimitive *) 0 ; int arg2 ; SWIG_check_num_args("ofConePrimitive::setResolutionHeight",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofConePrimitive::setResolutionHeight",1,"ofConePrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofConePrimitive::setResolutionHeight",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofConePrimitive,0))){ - SWIG_fail_ptr("ConePrimitive_setResolutionHeight",1,SWIGTYPE_p_ofConePrimitive); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->setResolutionHeight(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ConePrimitive_setResolutionCap(lua_State* L) { int SWIG_arg = 0; - ofConePrimitive *arg1 = (ofConePrimitive *) 0 ; int arg2 ; SWIG_check_num_args("ofConePrimitive::setResolutionCap",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofConePrimitive::setResolutionCap",1,"ofConePrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofConePrimitive::setResolutionCap",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofConePrimitive,0))){ - SWIG_fail_ptr("ConePrimitive_setResolutionCap",1,SWIGTYPE_p_ofConePrimitive); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->setResolutionCap(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ConePrimitive_setResolution(lua_State* L) { int SWIG_arg = 0; ofConePrimitive *arg1 = (ofConePrimitive *) 0 ; - int arg2 ; int arg3 ; int arg4 ; SWIG_check_num_args("ofConePrimitive::setResolution",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofConePrimitive::setResolution",1,"ofConePrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofConePrimitive::setResolution",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofConePrimitive::setResolution",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofConePrimitive::setResolution",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofConePrimitive,0))){ - SWIG_fail_ptr("ConePrimitive_setResolution",1,SWIGTYPE_p_ofConePrimitive); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); (arg1)->setResolution(arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ConePrimitive_setMode(lua_State* L) { int SWIG_arg = 0; ofConePrimitive *arg1 = (ofConePrimitive *) 0 ; - ofPrimitiveMode arg2 ; SWIG_check_num_args("ofConePrimitive::setMode",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofConePrimitive::setMode",1,"ofConePrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofConePrimitive::setMode",2,"ofPrimitiveMode"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofConePrimitive,0))){ - SWIG_fail_ptr("ConePrimitive_setMode",1,SWIGTYPE_p_ofConePrimitive); } arg2 = (ofPrimitiveMode)(int)lua_tonumber(L, 2); - (arg1)->setMode(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ConePrimitive_setRadius(lua_State* L) { int SWIG_arg = 0; ofConePrimitive *arg1 = (ofConePrimitive *) 0 ; - float arg2 ; SWIG_check_num_args("ofConePrimitive::setRadius",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofConePrimitive::setRadius",1,"ofConePrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofConePrimitive::setRadius",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofConePrimitive,0))){ - SWIG_fail_ptr("ConePrimitive_setRadius",1,SWIGTYPE_p_ofConePrimitive); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setRadius(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ConePrimitive_setHeight(lua_State* L) { int SWIG_arg = 0; ofConePrimitive *arg1 = (ofConePrimitive *) 0 ; - float arg2 ; SWIG_check_num_args("ofConePrimitive::setHeight",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofConePrimitive::setHeight",1,"ofConePrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofConePrimitive::setHeight",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofConePrimitive,0))){ - SWIG_fail_ptr("ConePrimitive_setHeight",1,SWIGTYPE_p_ofConePrimitive); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setHeight(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ConePrimitive_setTopColor(lua_State* L) { int SWIG_arg = 0; ofConePrimitive *arg1 = (ofConePrimitive *) 0 ; - ofColor arg2 ; ofColor *argp2 ; SWIG_check_num_args("ofConePrimitive::setTopColor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofConePrimitive::setTopColor",1,"ofConePrimitive *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofConePrimitive::setTopColor",2,"ofColor"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofConePrimitive,0))){ - SWIG_fail_ptr("ConePrimitive_setTopColor",1,SWIGTYPE_p_ofConePrimitive); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("ConePrimitive_setTopColor",2,SWIGTYPE_p_ofColor_T_unsigned_char_t); } arg2 = *argp2; - (arg1)->setTopColor(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ConePrimitive_setCapColor(lua_State* L) { int SWIG_arg = 0; ofConePrimitive *arg1 = (ofConePrimitive *) 0 ; - ofColor arg2 ; ofColor *argp2 ; SWIG_check_num_args("ofConePrimitive::setCapColor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofConePrimitive::setCapColor",1,"ofConePrimitive *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofConePrimitive::setCapColor",2,"ofColor"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofConePrimitive,0))){ - SWIG_fail_ptr("ConePrimitive_setCapColor",1,SWIGTYPE_p_ofConePrimitive); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("ConePrimitive_setCapColor",2,SWIGTYPE_p_ofColor_T_unsigned_char_t); } arg2 = *argp2; - (arg1)->setCapColor(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ConePrimitive_getConeIndices(lua_State* L) { int SWIG_arg = 0; ofConePrimitive *arg1 = (ofConePrimitive *) 0 ; - SwigValueWrapper< std::vector< unsigned short > > result; SWIG_check_num_args("ofConePrimitive::getConeIndices",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofConePrimitive::getConeIndices",1,"ofConePrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofConePrimitive,0))){ - SWIG_fail_ptr("ConePrimitive_getConeIndices",1,SWIGTYPE_p_ofConePrimitive); } - result = ((ofConePrimitive const *)arg1)->getConeIndices(); { - std::vector< ofIndexType > * resultptr = new std::vector< ofIndexType >((const std::vector< ofIndexType > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_unsigned_short_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ConePrimitive_getConeMesh(lua_State* L) { int SWIG_arg = 0; ofConePrimitive *arg1 = (ofConePrimitive *) 0 ; - ofMesh result; SWIG_check_num_args("ofConePrimitive::getConeMesh",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofConePrimitive::getConeMesh",1,"ofConePrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofConePrimitive,0))){ - SWIG_fail_ptr("ConePrimitive_getConeMesh",1,SWIGTYPE_p_ofConePrimitive); } - result = ((ofConePrimitive const *)arg1)->getConeMesh(); { ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ConePrimitive_getCapIndices(lua_State* L) { int SWIG_arg = 0; ofConePrimitive *arg1 = (ofConePrimitive *) 0 ; - SwigValueWrapper< std::vector< unsigned short > > result; SWIG_check_num_args("ofConePrimitive::getCapIndices",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofConePrimitive::getCapIndices",1,"ofConePrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofConePrimitive,0))){ - SWIG_fail_ptr("ConePrimitive_getCapIndices",1,SWIGTYPE_p_ofConePrimitive); } - result = ((ofConePrimitive const *)arg1)->getCapIndices(); { - std::vector< ofIndexType > * resultptr = new std::vector< ofIndexType >((const std::vector< ofIndexType > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_unsigned_short_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ConePrimitive_getCapMesh(lua_State* L) { int SWIG_arg = 0; ofConePrimitive *arg1 = (ofConePrimitive *) 0 ; - ofMesh result; SWIG_check_num_args("ofConePrimitive::getCapMesh",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofConePrimitive::getCapMesh",1,"ofConePrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofConePrimitive,0))){ - SWIG_fail_ptr("ConePrimitive_getCapMesh",1,SWIGTYPE_p_ofConePrimitive); } - result = ((ofConePrimitive const *)arg1)->getCapMesh(); { ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ConePrimitive_getResolutionRadius(lua_State* L) { int SWIG_arg = 0; - ofConePrimitive *arg1 = (ofConePrimitive *) 0 ; int result; SWIG_check_num_args("ofConePrimitive::getResolutionRadius",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofConePrimitive::getResolutionRadius",1,"ofConePrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofConePrimitive,0))){ - SWIG_fail_ptr("ConePrimitive_getResolutionRadius",1,SWIGTYPE_p_ofConePrimitive); } - result = (int)((ofConePrimitive const *)arg1)->getResolutionRadius(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ConePrimitive_getResolutionHeight(lua_State* L) { int SWIG_arg = 0; - ofConePrimitive *arg1 = (ofConePrimitive *) 0 ; int result; SWIG_check_num_args("ofConePrimitive::getResolutionHeight",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofConePrimitive::getResolutionHeight",1,"ofConePrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofConePrimitive,0))){ - SWIG_fail_ptr("ConePrimitive_getResolutionHeight",1,SWIGTYPE_p_ofConePrimitive); } - result = (int)((ofConePrimitive const *)arg1)->getResolutionHeight(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ConePrimitive_getResolutionCap(lua_State* L) { int SWIG_arg = 0; - ofConePrimitive *arg1 = (ofConePrimitive *) 0 ; int result; SWIG_check_num_args("ofConePrimitive::getResolutionCap",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofConePrimitive::getResolutionCap",1,"ofConePrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofConePrimitive,0))){ - SWIG_fail_ptr("ConePrimitive_getResolutionCap",1,SWIGTYPE_p_ofConePrimitive); } - result = (int)((ofConePrimitive const *)arg1)->getResolutionCap(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ConePrimitive_getResolution(lua_State* L) { int SWIG_arg = 0; ofConePrimitive *arg1 = (ofConePrimitive *) 0 ; - ofVec3f result; SWIG_check_num_args("ofConePrimitive::getResolution",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofConePrimitive::getResolution",1,"ofConePrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofConePrimitive,0))){ - SWIG_fail_ptr("ConePrimitive_getResolution",1,SWIGTYPE_p_ofConePrimitive); } - result = ((ofConePrimitive const *)arg1)->getResolution(); { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ConePrimitive_getRadius(lua_State* L) { int SWIG_arg = 0; ofConePrimitive *arg1 = (ofConePrimitive *) 0 ; - float result; SWIG_check_num_args("ofConePrimitive::getRadius",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofConePrimitive::getRadius",1,"ofConePrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofConePrimitive,0))){ - SWIG_fail_ptr("ConePrimitive_getRadius",1,SWIGTYPE_p_ofConePrimitive); } - result = (float)((ofConePrimitive const *)arg1)->getRadius(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ConePrimitive_getHeight(lua_State* L) { int SWIG_arg = 0; ofConePrimitive *arg1 = (ofConePrimitive *) 0 ; - float result; SWIG_check_num_args("ofConePrimitive::getHeight",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofConePrimitive::getHeight",1,"ofConePrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofConePrimitive,0))){ - SWIG_fail_ptr("ConePrimitive_getHeight",1,SWIGTYPE_p_ofConePrimitive); } - result = (float)((ofConePrimitive const *)arg1)->getHeight(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_ConePrimitive(void *obj) { -ofConePrimitive *arg1 = (ofConePrimitive *) obj; -delete arg1; -} -static int _proxy__wrap_new_ConePrimitive(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_ConePrimitive); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_ConePrimitive_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_ConePrimitive_methods[]= { - { "set", _wrap_ConePrimitive_set}, - { "setResolutionRadius", _wrap_ConePrimitive_setResolutionRadius}, - { "setResolutionHeight", _wrap_ConePrimitive_setResolutionHeight}, - { "setResolutionCap", _wrap_ConePrimitive_setResolutionCap}, - { "setResolution", _wrap_ConePrimitive_setResolution}, - { "setMode", _wrap_ConePrimitive_setMode}, - { "setRadius", _wrap_ConePrimitive_setRadius}, - { "setHeight", _wrap_ConePrimitive_setHeight}, - { "setTopColor", _wrap_ConePrimitive_setTopColor}, - { "setCapColor", _wrap_ConePrimitive_setCapColor}, - { "getConeIndices", _wrap_ConePrimitive_getConeIndices}, - { "getConeMesh", _wrap_ConePrimitive_getConeMesh}, - { "getCapIndices", _wrap_ConePrimitive_getCapIndices}, - { "getCapMesh", _wrap_ConePrimitive_getCapMesh}, - { "getResolutionRadius", _wrap_ConePrimitive_getResolutionRadius}, - { "getResolutionHeight", _wrap_ConePrimitive_getResolutionHeight}, - { "getResolutionCap", _wrap_ConePrimitive_getResolutionCap}, - { "getResolution", _wrap_ConePrimitive_getResolution}, - { "getRadius", _wrap_ConePrimitive_getRadius}, - { "getHeight", _wrap_ConePrimitive_getHeight}, - {0,0} -}; -static swig_lua_method swig_ConePrimitive_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_ConePrimitive_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_ConePrimitive_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_ConePrimitive_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_ConePrimitive_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_ConePrimitive_Sf_SwigStatic = { - "ConePrimitive", - swig_ConePrimitive_Sf_SwigStatic_methods, - swig_ConePrimitive_Sf_SwigStatic_attributes, - swig_ConePrimitive_Sf_SwigStatic_constants, - swig_ConePrimitive_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_ConePrimitive_bases[] = {0,0}; -static const char *swig_ConePrimitive_base_names[] = {"of3dPrimitive *",0}; -static swig_lua_class _wrap_class_ConePrimitive = { "ConePrimitive", "ConePrimitive", &SWIGTYPE_p_ofConePrimitive,_proxy__wrap_new_ConePrimitive, swig_delete_ConePrimitive, swig_ConePrimitive_methods, swig_ConePrimitive_attributes, &swig_ConePrimitive_Sf_SwigStatic, swig_ConePrimitive_meta, swig_ConePrimitive_bases, swig_ConePrimitive_base_names }; - -static int _wrap_new_BoxPrimitive__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofBoxPrimitive *result = 0 ; - SWIG_check_num_args("ofBoxPrimitive::ofBoxPrimitive",0,0) result = (ofBoxPrimitive *)new ofBoxPrimitive(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofBoxPrimitive,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_BoxPrimitive__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; int arg4 ; - int arg5 ; int arg6 ; ofBoxPrimitive *result = 0 ; SWIG_check_num_args("ofBoxPrimitive::ofBoxPrimitive",6,6) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofBoxPrimitive::ofBoxPrimitive",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBoxPrimitive::ofBoxPrimitive",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofBoxPrimitive::ofBoxPrimitive",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofBoxPrimitive::ofBoxPrimitive",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofBoxPrimitive::ofBoxPrimitive",5,"int"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofBoxPrimitive::ofBoxPrimitive",6,"int"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - arg5 = (int)lua_tonumber(L, 5); arg6 = (int)lua_tonumber(L, 6); - result = (ofBoxPrimitive *)new ofBoxPrimitive(arg1,arg2,arg3,arg4,arg5,arg6); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofBoxPrimitive,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_BoxPrimitive__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; int arg4 ; - int arg5 ; ofBoxPrimitive *result = 0 ; SWIG_check_num_args("ofBoxPrimitive::ofBoxPrimitive",5,5) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofBoxPrimitive::ofBoxPrimitive",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBoxPrimitive::ofBoxPrimitive",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofBoxPrimitive::ofBoxPrimitive",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofBoxPrimitive::ofBoxPrimitive",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofBoxPrimitive::ofBoxPrimitive",5,"int"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - arg5 = (int)lua_tonumber(L, 5); result = (ofBoxPrimitive *)new ofBoxPrimitive(arg1,arg2,arg3,arg4,arg5); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofBoxPrimitive,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_BoxPrimitive__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; int arg4 ; - ofBoxPrimitive *result = 0 ; SWIG_check_num_args("ofBoxPrimitive::ofBoxPrimitive",4,4) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofBoxPrimitive::ofBoxPrimitive",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBoxPrimitive::ofBoxPrimitive",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofBoxPrimitive::ofBoxPrimitive",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofBoxPrimitive::ofBoxPrimitive",4,"int"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - result = (ofBoxPrimitive *)new ofBoxPrimitive(arg1,arg2,arg3,arg4); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofBoxPrimitive,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_BoxPrimitive__SWIG_4(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; - ofBoxPrimitive *result = 0 ; SWIG_check_num_args("ofBoxPrimitive::ofBoxPrimitive",3,3) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofBoxPrimitive::ofBoxPrimitive",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBoxPrimitive::ofBoxPrimitive",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofBoxPrimitive::ofBoxPrimitive",3,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - result = (ofBoxPrimitive *)new ofBoxPrimitive(arg1,arg2,arg3); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofBoxPrimitive,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_BoxPrimitive(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); - if (argc == 0) { return _wrap_new_BoxPrimitive__SWIG_0(L);} if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_new_BoxPrimitive__SWIG_4(L);} } } } if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_new_BoxPrimitive__SWIG_3(L);} } } } } if (argc == 5) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_new_BoxPrimitive__SWIG_2(L);} } } } } } - if (argc == 6) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { - return _wrap_new_BoxPrimitive__SWIG_1(L);} } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_BoxPrimitive'\n" " Possible C/C++ prototypes are:\n" - " ofBoxPrimitive::ofBoxPrimitive()\n" " ofBoxPrimitive::ofBoxPrimitive(float,float,float,int,int,int)\n" - " ofBoxPrimitive::ofBoxPrimitive(float,float,float,int,int)\n" - " ofBoxPrimitive::ofBoxPrimitive(float,float,float,int)\n" " ofBoxPrimitive::ofBoxPrimitive(float,float,float)\n"); - lua_error(L);return 0; } -static int _wrap_BoxPrimitive_set__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofBoxPrimitive *arg1 = (ofBoxPrimitive *) 0 ; - float arg2 ; float arg3 ; float arg4 ; int arg5 ; int arg6 ; int arg7 ; SWIG_check_num_args("ofBoxPrimitive::set",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBoxPrimitive::set",1,"ofBoxPrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBoxPrimitive::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofBoxPrimitive::set",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofBoxPrimitive::set",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofBoxPrimitive::set",5,"int"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofBoxPrimitive::set",6,"int"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofBoxPrimitive::set",7,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBoxPrimitive,0))){ - SWIG_fail_ptr("BoxPrimitive_set",1,SWIGTYPE_p_ofBoxPrimitive); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); - arg6 = (int)lua_tonumber(L, 6); arg7 = (int)lua_tonumber(L, 7); (arg1)->set(arg2,arg3,arg4,arg5,arg6,arg7); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BoxPrimitive_set__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofBoxPrimitive *arg1 = (ofBoxPrimitive *) 0 ; - float arg2 ; float arg3 ; float arg4 ; SWIG_check_num_args("ofBoxPrimitive::set",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBoxPrimitive::set",1,"ofBoxPrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBoxPrimitive::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofBoxPrimitive::set",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofBoxPrimitive::set",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBoxPrimitive,0))){ - SWIG_fail_ptr("BoxPrimitive_set",1,SWIGTYPE_p_ofBoxPrimitive); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); (arg1)->set(arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BoxPrimitive_set__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofBoxPrimitive *arg1 = (ofBoxPrimitive *) 0 ; - float arg2 ; SWIG_check_num_args("ofBoxPrimitive::set",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBoxPrimitive::set",1,"ofBoxPrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBoxPrimitive::set",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBoxPrimitive,0))){ - SWIG_fail_ptr("BoxPrimitive_set",1,SWIGTYPE_p_ofBoxPrimitive); } arg2 = (float)lua_tonumber(L, 2); (arg1)->set(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BoxPrimitive_set(lua_State* L) { int argc; int argv[8]={ 1,2,3,4,5,6,7,8} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofBoxPrimitive, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_BoxPrimitive_set__SWIG_2(L);} } - } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofBoxPrimitive, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_BoxPrimitive_set__SWIG_1(L);} } } } } if (argc == 7) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofBoxPrimitive, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { - return _wrap_BoxPrimitive_set__SWIG_0(L);} } } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'BoxPrimitive_set'\n" " Possible C/C++ prototypes are:\n" - " ofBoxPrimitive::set(float,float,float,int,int,int)\n" " ofBoxPrimitive::set(float,float,float)\n" - " ofBoxPrimitive::set(float)\n"); lua_error(L);return 0; } -static int _wrap_BoxPrimitive_setWidth(lua_State* L) { int SWIG_arg = 0; ofBoxPrimitive *arg1 = (ofBoxPrimitive *) 0 ; - float arg2 ; SWIG_check_num_args("ofBoxPrimitive::setWidth",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBoxPrimitive::setWidth",1,"ofBoxPrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBoxPrimitive::setWidth",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBoxPrimitive,0))){ - SWIG_fail_ptr("BoxPrimitive_setWidth",1,SWIGTYPE_p_ofBoxPrimitive); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setWidth(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BoxPrimitive_setHeight(lua_State* L) { int SWIG_arg = 0; ofBoxPrimitive *arg1 = (ofBoxPrimitive *) 0 ; - float arg2 ; SWIG_check_num_args("ofBoxPrimitive::setHeight",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBoxPrimitive::setHeight",1,"ofBoxPrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBoxPrimitive::setHeight",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBoxPrimitive,0))){ - SWIG_fail_ptr("BoxPrimitive_setHeight",1,SWIGTYPE_p_ofBoxPrimitive); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setHeight(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BoxPrimitive_setDepth(lua_State* L) { int SWIG_arg = 0; ofBoxPrimitive *arg1 = (ofBoxPrimitive *) 0 ; - float arg2 ; SWIG_check_num_args("ofBoxPrimitive::setDepth",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBoxPrimitive::setDepth",1,"ofBoxPrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBoxPrimitive::setDepth",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBoxPrimitive,0))){ - SWIG_fail_ptr("BoxPrimitive_setDepth",1,SWIGTYPE_p_ofBoxPrimitive); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setDepth(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BoxPrimitive_resizeToTexture(lua_State* L) { int SWIG_arg = 0; ofBoxPrimitive *arg1 = (ofBoxPrimitive *) 0 ; - ofTexture *arg2 = 0 ; SWIG_check_num_args("ofBoxPrimitive::resizeToTexture",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBoxPrimitive::resizeToTexture",1,"ofBoxPrimitive *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofBoxPrimitive::resizeToTexture",2,"ofTexture &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBoxPrimitive,0))){ - SWIG_fail_ptr("BoxPrimitive_resizeToTexture",1,SWIGTYPE_p_ofBoxPrimitive); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("BoxPrimitive_resizeToTexture",2,SWIGTYPE_p_ofTexture); } (arg1)->resizeToTexture(*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BoxPrimitive_getSideIndices(lua_State* L) { int SWIG_arg = 0; ofBoxPrimitive *arg1 = (ofBoxPrimitive *) 0 ; - int arg2 ; SwigValueWrapper< std::vector< unsigned short > > result; SWIG_check_num_args("ofBoxPrimitive::getSideIndices",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBoxPrimitive::getSideIndices",1,"ofBoxPrimitive const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBoxPrimitive::getSideIndices",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBoxPrimitive,0))){ - SWIG_fail_ptr("BoxPrimitive_getSideIndices",1,SWIGTYPE_p_ofBoxPrimitive); } arg2 = (int)lua_tonumber(L, 2); - result = ((ofBoxPrimitive const *)arg1)->getSideIndices(arg2); { - std::vector< ofIndexType > * resultptr = new std::vector< ofIndexType >((const std::vector< ofIndexType > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_unsigned_short_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BoxPrimitive_getSideMesh(lua_State* L) { int SWIG_arg = 0; ofBoxPrimitive *arg1 = (ofBoxPrimitive *) 0 ; - int arg2 ; ofMesh result; SWIG_check_num_args("ofBoxPrimitive::getSideMesh",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBoxPrimitive::getSideMesh",1,"ofBoxPrimitive const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBoxPrimitive::getSideMesh",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBoxPrimitive,0))){ - SWIG_fail_ptr("BoxPrimitive_getSideMesh",1,SWIGTYPE_p_ofBoxPrimitive); } arg2 = (int)lua_tonumber(L, 2); - result = ((ofBoxPrimitive const *)arg1)->getSideMesh(arg2); { ofMesh * resultptr = new ofMesh((const ofMesh &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMesh,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_BoxPrimitive_setResolution__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofBoxPrimitive *arg1 = (ofBoxPrimitive *) 0 ; int arg2 ; SWIG_check_num_args("ofBoxPrimitive::setResolution",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBoxPrimitive::setResolution",1,"ofBoxPrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBoxPrimitive::setResolution",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBoxPrimitive,0))){ - SWIG_fail_ptr("BoxPrimitive_setResolution",1,SWIGTYPE_p_ofBoxPrimitive); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->setResolution(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BoxPrimitive_setResolutionWidth(lua_State* L) { int SWIG_arg = 0; ofBoxPrimitive *arg1 = (ofBoxPrimitive *) 0 ; - int arg2 ; SWIG_check_num_args("ofBoxPrimitive::setResolutionWidth",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBoxPrimitive::setResolutionWidth",1,"ofBoxPrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBoxPrimitive::setResolutionWidth",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBoxPrimitive,0))){ - SWIG_fail_ptr("BoxPrimitive_setResolutionWidth",1,SWIGTYPE_p_ofBoxPrimitive); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->setResolutionWidth(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BoxPrimitive_setResolutionHeight(lua_State* L) { int SWIG_arg = 0; - ofBoxPrimitive *arg1 = (ofBoxPrimitive *) 0 ; int arg2 ; SWIG_check_num_args("ofBoxPrimitive::setResolutionHeight",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBoxPrimitive::setResolutionHeight",1,"ofBoxPrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBoxPrimitive::setResolutionHeight",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBoxPrimitive,0))){ - SWIG_fail_ptr("BoxPrimitive_setResolutionHeight",1,SWIGTYPE_p_ofBoxPrimitive); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->setResolutionHeight(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BoxPrimitive_setResolutionDepth(lua_State* L) { int SWIG_arg = 0; ofBoxPrimitive *arg1 = (ofBoxPrimitive *) 0 ; - int arg2 ; SWIG_check_num_args("ofBoxPrimitive::setResolutionDepth",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBoxPrimitive::setResolutionDepth",1,"ofBoxPrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBoxPrimitive::setResolutionDepth",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBoxPrimitive,0))){ - SWIG_fail_ptr("BoxPrimitive_setResolutionDepth",1,SWIGTYPE_p_ofBoxPrimitive); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->setResolutionDepth(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BoxPrimitive_setResolution__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofBoxPrimitive *arg1 = (ofBoxPrimitive *) 0 ; int arg2 ; int arg3 ; int arg4 ; - SWIG_check_num_args("ofBoxPrimitive::setResolution",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBoxPrimitive::setResolution",1,"ofBoxPrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBoxPrimitive::setResolution",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofBoxPrimitive::setResolution",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofBoxPrimitive::setResolution",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBoxPrimitive,0))){ - SWIG_fail_ptr("BoxPrimitive_setResolution",1,SWIGTYPE_p_ofBoxPrimitive); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); (arg1)->setResolution(arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BoxPrimitive_setResolution(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofBoxPrimitive, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_BoxPrimitive_setResolution__SWIG_0(L);} } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofBoxPrimitive, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_BoxPrimitive_setResolution__SWIG_1(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'BoxPrimitive_setResolution'\n" - " Possible C/C++ prototypes are:\n" " ofBoxPrimitive::setResolution(int)\n" - " ofBoxPrimitive::setResolution(int,int,int)\n"); lua_error(L);return 0; } -static int _wrap_BoxPrimitive_setMode(lua_State* L) { int SWIG_arg = 0; ofBoxPrimitive *arg1 = (ofBoxPrimitive *) 0 ; - ofPrimitiveMode arg2 ; SWIG_check_num_args("ofBoxPrimitive::setMode",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBoxPrimitive::setMode",1,"ofBoxPrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBoxPrimitive::setMode",2,"ofPrimitiveMode"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBoxPrimitive,0))){ - SWIG_fail_ptr("BoxPrimitive_setMode",1,SWIGTYPE_p_ofBoxPrimitive); } arg2 = (ofPrimitiveMode)(int)lua_tonumber(L, 2); - (arg1)->setMode(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BoxPrimitive_setSideColor(lua_State* L) { int SWIG_arg = 0; ofBoxPrimitive *arg1 = (ofBoxPrimitive *) 0 ; - int arg2 ; ofColor arg3 ; ofColor *argp3 ; SWIG_check_num_args("ofBoxPrimitive::setSideColor",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBoxPrimitive::setSideColor",1,"ofBoxPrimitive *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBoxPrimitive::setSideColor",2,"int"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofBoxPrimitive::setSideColor",3,"ofColor"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBoxPrimitive,0))){ - SWIG_fail_ptr("BoxPrimitive_setSideColor",1,SWIGTYPE_p_ofBoxPrimitive); } arg2 = (int)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&argp3,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("BoxPrimitive_setSideColor",3,SWIGTYPE_p_ofColor_T_unsigned_char_t); } arg3 = *argp3; - (arg1)->setSideColor(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BoxPrimitive_getResolutionWidth(lua_State* L) { int SWIG_arg = 0; ofBoxPrimitive *arg1 = (ofBoxPrimitive *) 0 ; - int result; SWIG_check_num_args("ofBoxPrimitive::getResolutionWidth",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBoxPrimitive::getResolutionWidth",1,"ofBoxPrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBoxPrimitive,0))){ - SWIG_fail_ptr("BoxPrimitive_getResolutionWidth",1,SWIGTYPE_p_ofBoxPrimitive); } - result = (int)((ofBoxPrimitive const *)arg1)->getResolutionWidth(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BoxPrimitive_getResolutionHeight(lua_State* L) { int SWIG_arg = 0; - ofBoxPrimitive *arg1 = (ofBoxPrimitive *) 0 ; int result; SWIG_check_num_args("ofBoxPrimitive::getResolutionHeight",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBoxPrimitive::getResolutionHeight",1,"ofBoxPrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBoxPrimitive,0))){ - SWIG_fail_ptr("BoxPrimitive_getResolutionHeight",1,SWIGTYPE_p_ofBoxPrimitive); } - result = (int)((ofBoxPrimitive const *)arg1)->getResolutionHeight(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BoxPrimitive_getResolutionDepth(lua_State* L) { int SWIG_arg = 0; ofBoxPrimitive *arg1 = (ofBoxPrimitive *) 0 ; - int result; SWIG_check_num_args("ofBoxPrimitive::getResolutionDepth",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBoxPrimitive::getResolutionDepth",1,"ofBoxPrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBoxPrimitive,0))){ - SWIG_fail_ptr("BoxPrimitive_getResolutionDepth",1,SWIGTYPE_p_ofBoxPrimitive); } - result = (int)((ofBoxPrimitive const *)arg1)->getResolutionDepth(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BoxPrimitive_getResolution(lua_State* L) { int SWIG_arg = 0; ofBoxPrimitive *arg1 = (ofBoxPrimitive *) 0 ; - ofVec3f result; SWIG_check_num_args("ofBoxPrimitive::getResolution",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBoxPrimitive::getResolution",1,"ofBoxPrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBoxPrimitive,0))){ - SWIG_fail_ptr("BoxPrimitive_getResolution",1,SWIGTYPE_p_ofBoxPrimitive); } - result = ((ofBoxPrimitive const *)arg1)->getResolution(); { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_BoxPrimitive_getWidth(lua_State* L) { int SWIG_arg = 0; ofBoxPrimitive *arg1 = (ofBoxPrimitive *) 0 ; - float result; SWIG_check_num_args("ofBoxPrimitive::getWidth",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBoxPrimitive::getWidth",1,"ofBoxPrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBoxPrimitive,0))){ - SWIG_fail_ptr("BoxPrimitive_getWidth",1,SWIGTYPE_p_ofBoxPrimitive); } - result = (float)((ofBoxPrimitive const *)arg1)->getWidth(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BoxPrimitive_getHeight(lua_State* L) { int SWIG_arg = 0; ofBoxPrimitive *arg1 = (ofBoxPrimitive *) 0 ; - float result; SWIG_check_num_args("ofBoxPrimitive::getHeight",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBoxPrimitive::getHeight",1,"ofBoxPrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBoxPrimitive,0))){ - SWIG_fail_ptr("BoxPrimitive_getHeight",1,SWIGTYPE_p_ofBoxPrimitive); } - result = (float)((ofBoxPrimitive const *)arg1)->getHeight(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BoxPrimitive_getDepth(lua_State* L) { int SWIG_arg = 0; ofBoxPrimitive *arg1 = (ofBoxPrimitive *) 0 ; - float result; SWIG_check_num_args("ofBoxPrimitive::getDepth",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBoxPrimitive::getDepth",1,"ofBoxPrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBoxPrimitive,0))){ - SWIG_fail_ptr("BoxPrimitive_getDepth",1,SWIGTYPE_p_ofBoxPrimitive); } - result = (float)((ofBoxPrimitive const *)arg1)->getDepth(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BoxPrimitive_getSize(lua_State* L) { int SWIG_arg = 0; ofBoxPrimitive *arg1 = (ofBoxPrimitive *) 0 ; - ofVec3f result; SWIG_check_num_args("ofBoxPrimitive::getSize",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBoxPrimitive::getSize",1,"ofBoxPrimitive const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBoxPrimitive,0))){ - SWIG_fail_ptr("BoxPrimitive_getSize",1,SWIGTYPE_p_ofBoxPrimitive); } result = ((ofBoxPrimitive const *)arg1)->getSize(); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static void swig_delete_BoxPrimitive(void *obj) { -ofBoxPrimitive *arg1 = (ofBoxPrimitive *) obj; -delete arg1; -} -static int _proxy__wrap_new_BoxPrimitive(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_BoxPrimitive); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_BoxPrimitive_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_BoxPrimitive_methods[]= { - { "set", _wrap_BoxPrimitive_set}, - { "setWidth", _wrap_BoxPrimitive_setWidth}, - { "setHeight", _wrap_BoxPrimitive_setHeight}, - { "setDepth", _wrap_BoxPrimitive_setDepth}, - { "resizeToTexture", _wrap_BoxPrimitive_resizeToTexture}, - { "getSideIndices", _wrap_BoxPrimitive_getSideIndices}, - { "getSideMesh", _wrap_BoxPrimitive_getSideMesh}, - { "setResolutionWidth", _wrap_BoxPrimitive_setResolutionWidth}, - { "setResolutionHeight", _wrap_BoxPrimitive_setResolutionHeight}, - { "setResolutionDepth", _wrap_BoxPrimitive_setResolutionDepth}, - { "setResolution", _wrap_BoxPrimitive_setResolution}, - { "setMode", _wrap_BoxPrimitive_setMode}, - { "setSideColor", _wrap_BoxPrimitive_setSideColor}, - { "getResolutionWidth", _wrap_BoxPrimitive_getResolutionWidth}, - { "getResolutionHeight", _wrap_BoxPrimitive_getResolutionHeight}, - { "getResolutionDepth", _wrap_BoxPrimitive_getResolutionDepth}, - { "getResolution", _wrap_BoxPrimitive_getResolution}, - { "getWidth", _wrap_BoxPrimitive_getWidth}, - { "getHeight", _wrap_BoxPrimitive_getHeight}, - { "getDepth", _wrap_BoxPrimitive_getDepth}, - { "getSize", _wrap_BoxPrimitive_getSize}, - {0,0} -}; -static swig_lua_method swig_BoxPrimitive_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_BoxPrimitive_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_BoxPrimitive_Sf_SwigStatic_constants[]= { - {SWIG_LUA_CONSTTAB_INT("SIDE_FRONT", ofBoxPrimitive::SIDE_FRONT)}, - {SWIG_LUA_CONSTTAB_INT("SIDE_RIGHT", ofBoxPrimitive::SIDE_RIGHT)}, - {SWIG_LUA_CONSTTAB_INT("SIDE_LEFT", ofBoxPrimitive::SIDE_LEFT)}, - {SWIG_LUA_CONSTTAB_INT("SIDE_BACK", ofBoxPrimitive::SIDE_BACK)}, - {SWIG_LUA_CONSTTAB_INT("SIDE_TOP", ofBoxPrimitive::SIDE_TOP)}, - {SWIG_LUA_CONSTTAB_INT("SIDE_BOTTOM", ofBoxPrimitive::SIDE_BOTTOM)}, - {SWIG_LUA_CONSTTAB_INT("SIDES_TOTAL", ofBoxPrimitive::SIDES_TOTAL)}, - {0,0,0,0,0,0} -}; -static swig_lua_method swig_BoxPrimitive_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_BoxPrimitive_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_BoxPrimitive_Sf_SwigStatic = { - "BoxPrimitive", - swig_BoxPrimitive_Sf_SwigStatic_methods, - swig_BoxPrimitive_Sf_SwigStatic_attributes, - swig_BoxPrimitive_Sf_SwigStatic_constants, - swig_BoxPrimitive_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_BoxPrimitive_bases[] = {0,0}; -static const char *swig_BoxPrimitive_base_names[] = {"of3dPrimitive *",0}; -static swig_lua_class _wrap_class_BoxPrimitive = { "BoxPrimitive", "BoxPrimitive", &SWIGTYPE_p_ofBoxPrimitive,_proxy__wrap_new_BoxPrimitive, swig_delete_BoxPrimitive, swig_BoxPrimitive_methods, swig_BoxPrimitive_attributes, &swig_BoxPrimitive_Sf_SwigStatic, swig_BoxPrimitive_meta, swig_BoxPrimitive_bases, swig_BoxPrimitive_base_names }; - -static int _wrap_getAppPtr(lua_State* L) { int SWIG_arg = 0; ofBaseApp *result = 0 ; SWIG_check_num_args("ofGetAppPtr",0,0) - result = (ofBaseApp *)ofGetAppPtr(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofBaseApp,0); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_exit__SWIG_0(lua_State* L) { int SWIG_arg = 0; int arg1 ; SWIG_check_num_args("ofExit",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofExit",1,"int"); arg1 = (int)lua_tonumber(L, 1); ofExit(arg1); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_exit__SWIG_1(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofExit",0,0) ofExit(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_exit(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_exit__SWIG_1(L);} if (argc == 1) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { - return _wrap_exit__SWIG_0(L);} } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'exit'\n" - " Possible C/C++ prototypes are:\n" " ofExit(int)\n" " ofExit()\n"); lua_error(L);return 0; } -static int _wrap_getFrameRate(lua_State* L) { int SWIG_arg = 0; float result; SWIG_check_num_args("ofGetFrameRate",0,0) - result = (float)ofGetFrameRate(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_getTargetFrameRate(lua_State* L) { int SWIG_arg = 0; float result; - SWIG_check_num_args("ofGetTargetFrameRate",0,0) result = (float)ofGetTargetFrameRate(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getFrameNum(lua_State* L) { int SWIG_arg = 0; uint64_t result; SWIG_check_num_args("ofGetFrameNum",0,0) - result = (uint64_t)ofGetFrameNum(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_setFrameRate(lua_State* L) { int SWIG_arg = 0; int arg1 ; SWIG_check_num_args("ofSetFrameRate",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetFrameRate",1,"int"); arg1 = (int)lua_tonumber(L, 1); ofSetFrameRate(arg1); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getLastFrameTime(lua_State* L) { int SWIG_arg = 0; double result; SWIG_check_num_args("ofGetLastFrameTime",0,0) - result = (double)ofGetLastFrameTime(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_setOrientation__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofOrientation arg1 ; bool arg2 ; - SWIG_check_num_args("ofSetOrientation",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetOrientation",1,"ofOrientation"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofSetOrientation",2,"bool"); arg1 = (ofOrientation)(int)lua_tonumber(L, 1); - arg2 = (lua_toboolean(L, 2)!=0); ofSetOrientation(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_setOrientation__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofOrientation arg1 ; - SWIG_check_num_args("ofSetOrientation",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetOrientation",1,"ofOrientation"); - arg1 = (ofOrientation)(int)lua_tonumber(L, 1); ofSetOrientation(arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_setOrientation(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; - { _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_setOrientation__SWIG_1(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_setOrientation__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'setOrientation'\n" " Possible C/C++ prototypes are:\n" - " ofSetOrientation(ofOrientation,bool)\n" " ofSetOrientation(ofOrientation)\n"); lua_error(L);return 0; } -static int _wrap_getOrientation(lua_State* L) { int SWIG_arg = 0; ofOrientation result; - SWIG_check_num_args("ofGetOrientation",0,0) result = (ofOrientation)ofGetOrientation(); - lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_hideCursor(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofHideCursor",0,0) ofHideCursor(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_showCursor(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofShowCursor",0,0) ofShowCursor(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getWindowPositionX(lua_State* L) { int SWIG_arg = 0; int result; - SWIG_check_num_args("ofGetWindowPositionX",0,0) result = (int)ofGetWindowPositionX(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getWindowPositionY(lua_State* L) { int SWIG_arg = 0; int result; - SWIG_check_num_args("ofGetWindowPositionY",0,0) result = (int)ofGetWindowPositionY(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getScreenWidth(lua_State* L) { int SWIG_arg = 0; int result; SWIG_check_num_args("ofGetScreenWidth",0,0) - result = (int)ofGetScreenWidth(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_getScreenHeight(lua_State* L) { int SWIG_arg = 0; int result; SWIG_check_num_args("ofGetScreenHeight",0,0) - result = (int)ofGetScreenHeight(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_getWindowMode(lua_State* L) { int SWIG_arg = 0; int result; SWIG_check_num_args("ofGetWindowMode",0,0) - result = (int)ofGetWindowMode(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_getWidth(lua_State* L) { int SWIG_arg = 0; int result; SWIG_check_num_args("ofGetWidth",0,0) - result = (int)ofGetWidth(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_getHeight(lua_State* L) { int SWIG_arg = 0; int result; SWIG_check_num_args("ofGetHeight",0,0) - result = (int)ofGetHeight(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_getWindowWidth(lua_State* L) { int SWIG_arg = 0; int result; SWIG_check_num_args("ofGetWindowWidth",0,0) - result = (int)ofGetWindowWidth(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_getWindowHeight(lua_State* L) { int SWIG_arg = 0; int result; SWIG_check_num_args("ofGetWindowHeight",0,0) - result = (int)ofGetWindowHeight(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_randomWidth(lua_State* L) { int SWIG_arg = 0; float result; SWIG_check_num_args("ofRandomWidth",0,0) - result = (float)ofRandomWidth(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_randomHeight(lua_State* L) { int SWIG_arg = 0; float result; SWIG_check_num_args("ofRandomHeight",0,0) - result = (float)ofRandomHeight(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_doesHWOrientation(lua_State* L) { int SWIG_arg = 0; bool result; SWIG_check_num_args("ofDoesHWOrientation",0,0) - result = (bool)ofDoesHWOrientation(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_getWindowSize(lua_State* L) { int SWIG_arg = 0; ofPoint result; SWIG_check_num_args("ofGetWindowSize",0,0) - result = ofGetWindowSize(); { ofPoint * resultptr = new ofPoint((const ofPoint &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_getWindowRect(lua_State* L) { int SWIG_arg = 0; ofRectangle result; SWIG_check_num_args("ofGetWindowRect",0,0) - result = ofGetWindowRect(); { ofRectangle * resultptr = new ofRectangle((const ofRectangle &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofRectangle,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_setWindowPosition(lua_State* L) { int SWIG_arg = 0; int arg1 ; int arg2 ; - SWIG_check_num_args("ofSetWindowPosition",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetWindowPosition",1,"int"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSetWindowPosition",2,"int"); arg1 = (int)lua_tonumber(L, 1); - arg2 = (int)lua_tonumber(L, 2); ofSetWindowPosition(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_setWindowShape(lua_State* L) { int SWIG_arg = 0; int arg1 ; int arg2 ; - SWIG_check_num_args("ofSetWindowShape",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetWindowShape",1,"int"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSetWindowShape",2,"int"); arg1 = (int)lua_tonumber(L, 1); - arg2 = (int)lua_tonumber(L, 2); ofSetWindowShape(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_setWindowTitle(lua_State* L) { int SWIG_arg = 0; std::string arg1 ; SWIG_check_num_args("ofSetWindowTitle",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofSetWindowTitle",1,"std::string"); (&arg1)->assign(lua_tostring(L,1),lua_rawlen(L,1)); - ofSetWindowTitle(arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_enableSetupScreen(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofEnableSetupScreen",0,0) - ofEnableSetupScreen(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_disableSetupScreen(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofDisableSetupScreen",0,0) - ofDisableSetupScreen(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setFullscreen(lua_State* L) { int SWIG_arg = 0; bool arg1 ; SWIG_check_num_args("ofSetFullscreen",1,1) - if(!lua_isboolean(L,1)) SWIG_fail_arg("ofSetFullscreen",1,"bool"); arg1 = (lua_toboolean(L, 1)!=0); ofSetFullscreen(arg1); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_toggleFullscreen(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofToggleFullscreen",0,0) - ofToggleFullscreen(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setVerticalSync(lua_State* L) { int SWIG_arg = 0; bool arg1 ; SWIG_check_num_args("ofSetVerticalSync",1,1) - if(!lua_isboolean(L,1)) SWIG_fail_arg("ofSetVerticalSync",1,"bool"); arg1 = (lua_toboolean(L, 1)!=0); ofSetVerticalSync(arg1); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_events(lua_State* L) { int SWIG_arg = 0; ofCoreEvents *result = 0 ; SWIG_check_num_args("ofEvents",0,0) - result = (ofCoreEvents *) &ofEvents(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofCoreEvents,0); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setEscapeQuitsApp(lua_State* L) { int SWIG_arg = 0; bool arg1 ; SWIG_check_num_args("ofSetEscapeQuitsApp",1,1) - if(!lua_isboolean(L,1)) SWIG_fail_arg("ofSetEscapeQuitsApp",1,"bool"); arg1 = (lua_toboolean(L, 1)!=0); - ofSetEscapeQuitsApp(arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_new_Arduino(lua_State* L) { int SWIG_arg = 0; ofArduino *result = 0 ; - SWIG_check_num_args("ofArduino::ofArduino",0,0) result = (ofArduino *)new ofArduino(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofArduino,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Arduino_connect__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; - std::string *arg2 = 0 ; int arg3 ; std::string temp2 ; bool result; SWIG_check_num_args("ofArduino::connect",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::connect",1,"ofArduino *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofArduino::connect",2,"std::string const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofArduino::connect",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_connect",1,SWIGTYPE_p_ofArduino); } temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - arg3 = (int)lua_tonumber(L, 3); result = (bool)(arg1)->connect((std::string const &)*arg2,arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_connect__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; - std::string *arg2 = 0 ; std::string temp2 ; bool result; SWIG_check_num_args("ofArduino::connect",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::connect",1,"ofArduino *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofArduino::connect",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_connect",1,SWIGTYPE_p_ofArduino); } temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = (bool)(arg1)->connect((std::string const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_connect(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofArduino, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { return _wrap_Arduino_connect__SWIG_1(L);} } - } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofArduino, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Arduino_connect__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Arduino_connect'\n" " Possible C/C++ prototypes are:\n" - " ofArduino::connect(std::string const &,int)\n" " ofArduino::connect(std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_Arduino_isInitialized(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; bool result; - SWIG_check_num_args("ofArduino::isInitialized",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::isInitialized",1,"ofArduino const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_isInitialized",1,SWIGTYPE_p_ofArduino); } result = (bool)((ofArduino const *)arg1)->isInitialized(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_isArduinoReady(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; bool result; - SWIG_check_num_args("ofArduino::isArduinoReady",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::isArduinoReady",1,"ofArduino const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_isArduinoReady",1,SWIGTYPE_p_ofArduino); } - result = (bool)((ofArduino const *)arg1)->isArduinoReady(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_disconnect(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; - SWIG_check_num_args("ofArduino::disconnect",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::disconnect",1,"ofArduino *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_disconnect",1,SWIGTYPE_p_ofArduino); } (arg1)->disconnect(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_update(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; - SWIG_check_num_args("ofArduino::update",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::update",1,"ofArduino *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_update",1,SWIGTYPE_p_ofArduino); } (arg1)->update(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_sendDigitalPinMode(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; int arg2 ; - int arg3 ; SWIG_check_num_args("ofArduino::sendDigitalPinMode",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::sendDigitalPinMode",1,"ofArduino *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofArduino::sendDigitalPinMode",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofArduino::sendDigitalPinMode",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_sendDigitalPinMode",1,SWIGTYPE_p_ofArduino); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); (arg1)->sendDigitalPinMode(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Arduino_sendAnalogPinReporting(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; int arg2 ; - int arg3 ; SWIG_check_num_args("ofArduino::sendAnalogPinReporting",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::sendAnalogPinReporting",1,"ofArduino *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofArduino::sendAnalogPinReporting",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofArduino::sendAnalogPinReporting",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_sendAnalogPinReporting",1,SWIGTYPE_p_ofArduino); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); (arg1)->sendAnalogPinReporting(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_setUseDelay(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; bool arg2 ; - SWIG_check_num_args("ofArduino::setUseDelay",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::setUseDelay",1,"ofArduino *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofArduino::setUseDelay",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_setUseDelay",1,SWIGTYPE_p_ofArduino); } arg2 = (lua_toboolean(L, 2)!=0); (arg1)->setUseDelay(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_setDigitalHistoryLength(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; - int arg2 ; SWIG_check_num_args("ofArduino::setDigitalHistoryLength",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::setDigitalHistoryLength",1,"ofArduino *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofArduino::setDigitalHistoryLength",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_setDigitalHistoryLength",1,SWIGTYPE_p_ofArduino); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->setDigitalHistoryLength(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_setAnalogHistoryLength(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; int arg2 ; - SWIG_check_num_args("ofArduino::setAnalogHistoryLength",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::setAnalogHistoryLength",1,"ofArduino *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofArduino::setAnalogHistoryLength",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_setAnalogHistoryLength",1,SWIGTYPE_p_ofArduino); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->setAnalogHistoryLength(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_setStringHistoryLength(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; int arg2 ; - SWIG_check_num_args("ofArduino::setStringHistoryLength",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::setStringHistoryLength",1,"ofArduino *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofArduino::setStringHistoryLength",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_setStringHistoryLength",1,SWIGTYPE_p_ofArduino); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->setStringHistoryLength(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_setSysExHistoryLength(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; int arg2 ; - SWIG_check_num_args("ofArduino::setSysExHistoryLength",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::setSysExHistoryLength",1,"ofArduino *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofArduino::setSysExHistoryLength",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_setSysExHistoryLength",1,SWIGTYPE_p_ofArduino); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->setSysExHistoryLength(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_sendDigital__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; int arg2 ; - int arg3 ; bool arg4 ; SWIG_check_num_args("ofArduino::sendDigital",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::sendDigital",1,"ofArduino *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofArduino::sendDigital",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofArduino::sendDigital",3,"int"); - if(!lua_isboolean(L,4)) SWIG_fail_arg("ofArduino::sendDigital",4,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_sendDigital",1,SWIGTYPE_p_ofArduino); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); arg4 = (lua_toboolean(L, 4)!=0); (arg1)->sendDigital(arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_sendDigital__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; int arg2 ; - int arg3 ; SWIG_check_num_args("ofArduino::sendDigital",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::sendDigital",1,"ofArduino *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofArduino::sendDigital",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofArduino::sendDigital",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_sendDigital",1,SWIGTYPE_p_ofArduino); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); (arg1)->sendDigital(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Arduino_sendDigital(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofArduino, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Arduino_sendDigital__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofArduino, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isboolean(L,argv[3]); } if (_v) { return _wrap_Arduino_sendDigital__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Arduino_sendDigital'\n" - " Possible C/C++ prototypes are:\n" " ofArduino::sendDigital(int,int,bool)\n" " ofArduino::sendDigital(int,int)\n"); - lua_error(L);return 0; } -static int _wrap_Arduino_sendPwm__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; int arg2 ; - int arg3 ; bool arg4 ; SWIG_check_num_args("ofArduino::sendPwm",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::sendPwm",1,"ofArduino *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofArduino::sendPwm",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofArduino::sendPwm",3,"int"); - if(!lua_isboolean(L,4)) SWIG_fail_arg("ofArduino::sendPwm",4,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_sendPwm",1,SWIGTYPE_p_ofArduino); } arg2 = (int)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); - arg4 = (lua_toboolean(L, 4)!=0); (arg1)->sendPwm(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Arduino_sendPwm__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; int arg2 ; - int arg3 ; SWIG_check_num_args("ofArduino::sendPwm",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::sendPwm",1,"ofArduino *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofArduino::sendPwm",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofArduino::sendPwm",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_sendPwm",1,SWIGTYPE_p_ofArduino); } arg2 = (int)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); - (arg1)->sendPwm(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_sendPwm(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofArduino, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Arduino_sendPwm__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofArduino, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isboolean(L,argv[3]); } if (_v) { return _wrap_Arduino_sendPwm__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Arduino_sendPwm'\n" " Possible C/C++ prototypes are:\n" - " ofArduino::sendPwm(int,int,bool)\n" " ofArduino::sendPwm(int,int)\n"); lua_error(L);return 0; } -static int _wrap_Arduino_sendSysEx(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; int arg2 ; - std::vector< unsigned char > arg3 ; std::vector< unsigned char > *argp3 ; SWIG_check_num_args("ofArduino::sendSysEx",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::sendSysEx",1,"ofArduino *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofArduino::sendSysEx",2,"int"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofArduino::sendSysEx",3,"std::vector< unsigned char >"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_sendSysEx",1,SWIGTYPE_p_ofArduino); } arg2 = (int)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&argp3,SWIGTYPE_p_std__vectorT_unsigned_char_t,0))){ - SWIG_fail_ptr("Arduino_sendSysEx",3,SWIGTYPE_p_std__vectorT_unsigned_char_t); } arg3 = *argp3; - (arg1)->sendSysEx(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_sendString(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; std::string arg2 ; - SWIG_check_num_args("ofArduino::sendString",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::sendString",1,"ofArduino *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofArduino::sendString",2,"std::string"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_sendString",1,SWIGTYPE_p_ofArduino); } (&arg2)->assign(lua_tostring(L,2),lua_rawlen(L,2)); - (arg1)->sendString(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_sendProtocolVersionRequest(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; - SWIG_check_num_args("ofArduino::sendProtocolVersionRequest",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::sendProtocolVersionRequest",1,"ofArduino *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_sendProtocolVersionRequest",1,SWIGTYPE_p_ofArduino); } (arg1)->sendProtocolVersionRequest(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_sendFirmwareVersionRequest(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; - SWIG_check_num_args("ofArduino::sendFirmwareVersionRequest",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::sendFirmwareVersionRequest",1,"ofArduino *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_sendFirmwareVersionRequest",1,SWIGTYPE_p_ofArduino); } (arg1)->sendFirmwareVersionRequest(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_sendReset(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; - SWIG_check_num_args("ofArduino::sendReset",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::sendReset",1,"ofArduino *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_sendReset",1,SWIGTYPE_p_ofArduino); } (arg1)->sendReset(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_sendSysExBegin(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; - SWIG_check_num_args("ofArduino::sendSysExBegin",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::sendSysExBegin",1,"ofArduino *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_sendSysExBegin",1,SWIGTYPE_p_ofArduino); } (arg1)->sendSysExBegin(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_sendSysExEnd(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; - SWIG_check_num_args("ofArduino::sendSysExEnd",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::sendSysExEnd",1,"ofArduino *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_sendSysExEnd",1,SWIGTYPE_p_ofArduino); } (arg1)->sendSysExEnd(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_sendByte(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; unsigned char arg2 ; - SWIG_check_num_args("ofArduino::sendByte",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::sendByte",1,"ofArduino *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofArduino::sendByte",2,"unsigned char"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_sendByte",1,SWIGTYPE_p_ofArduino); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned char)lua_tonumber(L, 2); - (arg1)->sendByte(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_sendValueAsTwo7bitBytes(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; - int arg2 ; SWIG_check_num_args("ofArduino::sendValueAsTwo7bitBytes",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::sendValueAsTwo7bitBytes",1,"ofArduino *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofArduino::sendValueAsTwo7bitBytes",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_sendValueAsTwo7bitBytes",1,SWIGTYPE_p_ofArduino); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->sendValueAsTwo7bitBytes(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_getPwm(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; int arg2 ; int result; - SWIG_check_num_args("ofArduino::getPwm",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::getPwm",1,"ofArduino const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofArduino::getPwm",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_getPwm",1,SWIGTYPE_p_ofArduino); } arg2 = (int)lua_tonumber(L, 2); - result = (int)((ofArduino const *)arg1)->getPwm(arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_getDigital(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; int arg2 ; int result; - SWIG_check_num_args("ofArduino::getDigital",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::getDigital",1,"ofArduino const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofArduino::getDigital",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_getDigital",1,SWIGTYPE_p_ofArduino); } arg2 = (int)lua_tonumber(L, 2); - result = (int)((ofArduino const *)arg1)->getDigital(arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_getAnalog(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; int arg2 ; int result; - SWIG_check_num_args("ofArduino::getAnalog",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::getAnalog",1,"ofArduino const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofArduino::getAnalog",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_getAnalog",1,SWIGTYPE_p_ofArduino); } arg2 = (int)lua_tonumber(L, 2); - result = (int)((ofArduino const *)arg1)->getAnalog(arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_getSysEx(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; - std::vector< unsigned char > result; SWIG_check_num_args("ofArduino::getSysEx",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::getSysEx",1,"ofArduino const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_getSysEx",1,SWIGTYPE_p_ofArduino); } result = ((ofArduino const *)arg1)->getSysEx(); { - std::vector< unsigned char > * resultptr = new std::vector< unsigned char >((const std::vector< unsigned char > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_unsigned_char_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_getString(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; std::string result; - SWIG_check_num_args("ofArduino::getString",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::getString",1,"ofArduino const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_getString",1,SWIGTYPE_p_ofArduino); } result = ((ofArduino const *)arg1)->getString(); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Arduino_getMajorProtocolVersion(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; - int result; SWIG_check_num_args("ofArduino::getMajorProtocolVersion",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::getMajorProtocolVersion",1,"ofArduino const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_getMajorProtocolVersion",1,SWIGTYPE_p_ofArduino); } - result = (int)((ofArduino const *)arg1)->getMajorProtocolVersion(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_getMinorProtocolVersion(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; - int result; SWIG_check_num_args("ofArduino::getMinorProtocolVersion",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::getMinorProtocolVersion",1,"ofArduino const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_getMinorProtocolVersion",1,SWIGTYPE_p_ofArduino); } - result = (int)((ofArduino const *)arg1)->getMinorProtocolVersion(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_getMajorFirmwareVersion(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; - int result; SWIG_check_num_args("ofArduino::getMajorFirmwareVersion",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::getMajorFirmwareVersion",1,"ofArduino const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_getMajorFirmwareVersion",1,SWIGTYPE_p_ofArduino); } - result = (int)((ofArduino const *)arg1)->getMajorFirmwareVersion(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_getMinorFirmwareVersion(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; - int result; SWIG_check_num_args("ofArduino::getMinorFirmwareVersion",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::getMinorFirmwareVersion",1,"ofArduino const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_getMinorFirmwareVersion",1,SWIGTYPE_p_ofArduino); } - result = (int)((ofArduino const *)arg1)->getMinorFirmwareVersion(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_getFirmwareName(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; - std::string result; SWIG_check_num_args("ofArduino::getFirmwareName",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::getFirmwareName",1,"ofArduino const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_getFirmwareName",1,SWIGTYPE_p_ofArduino); } result = ((ofArduino const *)arg1)->getFirmwareName(); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Arduino_getDigitalPinMode(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; int arg2 ; - int result; SWIG_check_num_args("ofArduino::getDigitalPinMode",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::getDigitalPinMode",1,"ofArduino const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofArduino::getDigitalPinMode",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_getDigitalPinMode",1,SWIGTYPE_p_ofArduino); } arg2 = (int)lua_tonumber(L, 2); - result = (int)((ofArduino const *)arg1)->getDigitalPinMode(arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_getAnalogPinReporting(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; int arg2 ; - int result; SWIG_check_num_args("ofArduino::getAnalogPinReporting",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::getAnalogPinReporting",1,"ofArduino const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofArduino::getAnalogPinReporting",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_getAnalogPinReporting",1,SWIGTYPE_p_ofArduino); } arg2 = (int)lua_tonumber(L, 2); - result = (int)((ofArduino const *)arg1)->getAnalogPinReporting(arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_getValueFromTwo7bitBytes(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; - unsigned char arg2 ; unsigned char arg3 ; int result; SWIG_check_num_args("ofArduino::getValueFromTwo7bitBytes",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::getValueFromTwo7bitBytes",1,"ofArduino *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofArduino::getValueFromTwo7bitBytes",2,"unsigned char"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofArduino::getValueFromTwo7bitBytes",3,"unsigned char"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_getValueFromTwo7bitBytes",1,SWIGTYPE_p_ofArduino); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned char)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (unsigned char)lua_tonumber(L, 3); - result = (int)(arg1)->getValueFromTwo7bitBytes(arg2,arg3); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_EDigitalPinChanged_set(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; - ofEvent< int const > arg2 ; ofEvent< int const > *argp2 ; SWIG_check_num_args("ofArduino::EDigitalPinChanged",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::EDigitalPinChanged",1,"ofArduino *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofArduino::EDigitalPinChanged",2,"ofEvent< int const >"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_EDigitalPinChanged_set",1,SWIGTYPE_p_ofArduino); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofEventT_int_const_t,0))){ - SWIG_fail_ptr("Arduino_EDigitalPinChanged_set",2,SWIGTYPE_p_ofEventT_int_const_t); } arg2 = *argp2; - if (arg1) (arg1)->EDigitalPinChanged = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_EDigitalPinChanged_get(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; - ofEvent< int const > result; SWIG_check_num_args("ofArduino::EDigitalPinChanged",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::EDigitalPinChanged",1,"ofArduino *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_EDigitalPinChanged_get",1,SWIGTYPE_p_ofArduino); } result = ((arg1)->EDigitalPinChanged); { - ofEvent< int const > * resultptr = new ofEvent< int const >((const ofEvent< int const > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofEventT_int_const_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_EAnalogPinChanged_set(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; - ofEvent< int const > arg2 ; ofEvent< int const > *argp2 ; SWIG_check_num_args("ofArduino::EAnalogPinChanged",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::EAnalogPinChanged",1,"ofArduino *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofArduino::EAnalogPinChanged",2,"ofEvent< int const >"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_EAnalogPinChanged_set",1,SWIGTYPE_p_ofArduino); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofEventT_int_const_t,0))){ - SWIG_fail_ptr("Arduino_EAnalogPinChanged_set",2,SWIGTYPE_p_ofEventT_int_const_t); } arg2 = *argp2; - if (arg1) (arg1)->EAnalogPinChanged = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_EAnalogPinChanged_get(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; - ofEvent< int const > result; SWIG_check_num_args("ofArduino::EAnalogPinChanged",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::EAnalogPinChanged",1,"ofArduino *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_EAnalogPinChanged_get",1,SWIGTYPE_p_ofArduino); } result = ((arg1)->EAnalogPinChanged); { - ofEvent< int const > * resultptr = new ofEvent< int const >((const ofEvent< int const > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofEventT_int_const_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_ESysExReceived_set(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; - ofEvent< std::vector< unsigned char > const > *arg2 = (ofEvent< std::vector< unsigned char > const > *) 0 ; - SWIG_check_num_args("ofArduino::ESysExReceived",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::ESysExReceived",1,"ofArduino *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofArduino::ESysExReceived",2,"ofEvent< std::vector< unsigned char > const > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_ESysExReceived_set",1,SWIGTYPE_p_ofArduino); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofEventT_std__vectorT_unsigned_char_t_const_t,0))){ - SWIG_fail_ptr("Arduino_ESysExReceived_set",2,SWIGTYPE_p_ofEventT_std__vectorT_unsigned_char_t_const_t); } - if (arg1) (arg1)->ESysExReceived = *arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_ESysExReceived_get(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; - ofEvent< std::vector< unsigned char > const > *result = 0 ; SWIG_check_num_args("ofArduino::ESysExReceived",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::ESysExReceived",1,"ofArduino *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_ESysExReceived_get",1,SWIGTYPE_p_ofArduino); } - result = (ofEvent< std::vector< unsigned char > const > *)& ((arg1)->ESysExReceived); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofEventT_std__vectorT_unsigned_char_t_const_t,0); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_EProtocolVersionReceived_set(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; - ofEvent< int const > arg2 ; ofEvent< int const > *argp2 ; SWIG_check_num_args("ofArduino::EProtocolVersionReceived",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::EProtocolVersionReceived",1,"ofArduino *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofArduino::EProtocolVersionReceived",2,"ofEvent< int const >"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_EProtocolVersionReceived_set",1,SWIGTYPE_p_ofArduino); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofEventT_int_const_t,0))){ - SWIG_fail_ptr("Arduino_EProtocolVersionReceived_set",2,SWIGTYPE_p_ofEventT_int_const_t); } arg2 = *argp2; - if (arg1) (arg1)->EProtocolVersionReceived = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_EProtocolVersionReceived_get(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; - ofEvent< int const > result; SWIG_check_num_args("ofArduino::EProtocolVersionReceived",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::EProtocolVersionReceived",1,"ofArduino *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_EProtocolVersionReceived_get",1,SWIGTYPE_p_ofArduino); } - result = ((arg1)->EProtocolVersionReceived); { - ofEvent< int const > * resultptr = new ofEvent< int const >((const ofEvent< int const > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofEventT_int_const_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_EFirmwareVersionReceived_set(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; - ofEvent< int const > arg2 ; ofEvent< int const > *argp2 ; SWIG_check_num_args("ofArduino::EFirmwareVersionReceived",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::EFirmwareVersionReceived",1,"ofArduino *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofArduino::EFirmwareVersionReceived",2,"ofEvent< int const >"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_EFirmwareVersionReceived_set",1,SWIGTYPE_p_ofArduino); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofEventT_int_const_t,0))){ - SWIG_fail_ptr("Arduino_EFirmwareVersionReceived_set",2,SWIGTYPE_p_ofEventT_int_const_t); } arg2 = *argp2; - if (arg1) (arg1)->EFirmwareVersionReceived = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_EFirmwareVersionReceived_get(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; - ofEvent< int const > result; SWIG_check_num_args("ofArduino::EFirmwareVersionReceived",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::EFirmwareVersionReceived",1,"ofArduino *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_EFirmwareVersionReceived_get",1,SWIGTYPE_p_ofArduino); } - result = ((arg1)->EFirmwareVersionReceived); { - ofEvent< int const > * resultptr = new ofEvent< int const >((const ofEvent< int const > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofEventT_int_const_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_EInitialized_set(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; - ofEvent< int const > arg2 ; ofEvent< int const > *argp2 ; SWIG_check_num_args("ofArduino::EInitialized",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::EInitialized",1,"ofArduino *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofArduino::EInitialized",2,"ofEvent< int const >"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_EInitialized_set",1,SWIGTYPE_p_ofArduino); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofEventT_int_const_t,0))){ - SWIG_fail_ptr("Arduino_EInitialized_set",2,SWIGTYPE_p_ofEventT_int_const_t); } arg2 = *argp2; - if (arg1) (arg1)->EInitialized = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_EInitialized_get(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; - ofEvent< int const > result; SWIG_check_num_args("ofArduino::EInitialized",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::EInitialized",1,"ofArduino *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_EInitialized_get",1,SWIGTYPE_p_ofArduino); } result = ((arg1)->EInitialized); { - ofEvent< int const > * resultptr = new ofEvent< int const >((const ofEvent< int const > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofEventT_int_const_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_EStringReceived_set(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; - ofEvent< std::string const > *arg2 = (ofEvent< std::string const > *) 0 ; - SWIG_check_num_args("ofArduino::EStringReceived",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::EStringReceived",1,"ofArduino *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofArduino::EStringReceived",2,"ofEvent< std::string const > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_EStringReceived_set",1,SWIGTYPE_p_ofArduino); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofEventT_std__string_const_t,0))){ - SWIG_fail_ptr("Arduino_EStringReceived_set",2,SWIGTYPE_p_ofEventT_std__string_const_t); } - if (arg1) (arg1)->EStringReceived = *arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_EStringReceived_get(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; - ofEvent< std::string const > *result = 0 ; SWIG_check_num_args("ofArduino::EStringReceived",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::EStringReceived",1,"ofArduino *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_EStringReceived_get",1,SWIGTYPE_p_ofArduino); } - result = (ofEvent< std::string const > *)& ((arg1)->EStringReceived); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofEventT_std__string_const_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_sendServo__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; int arg2 ; - int arg3 ; bool arg4 ; SWIG_check_num_args("ofArduino::sendServo",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::sendServo",1,"ofArduino *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofArduino::sendServo",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofArduino::sendServo",3,"int"); - if(!lua_isboolean(L,4)) SWIG_fail_arg("ofArduino::sendServo",4,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_sendServo",1,SWIGTYPE_p_ofArduino); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); arg4 = (lua_toboolean(L, 4)!=0); (arg1)->sendServo(arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_sendServo__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; int arg2 ; - int arg3 ; SWIG_check_num_args("ofArduino::sendServo",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::sendServo",1,"ofArduino *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofArduino::sendServo",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofArduino::sendServo",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_sendServo",1,SWIGTYPE_p_ofArduino); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); (arg1)->sendServo(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Arduino_sendServo(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofArduino, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Arduino_sendServo__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofArduino, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isboolean(L,argv[3]); } if (_v) { return _wrap_Arduino_sendServo__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Arduino_sendServo'\n" " Possible C/C++ prototypes are:\n" - " ofArduino::sendServo(int,int,bool)\n" " ofArduino::sendServo(int,int)\n"); lua_error(L);return 0; } -static int _wrap_Arduino_sendServoAttach__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; - int arg2 ; int arg3 ; int arg4 ; int arg5 ; SWIG_check_num_args("ofArduino::sendServoAttach",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::sendServoAttach",1,"ofArduino *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofArduino::sendServoAttach",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofArduino::sendServoAttach",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofArduino::sendServoAttach",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofArduino::sendServoAttach",5,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_sendServoAttach",1,SWIGTYPE_p_ofArduino); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); - (arg1)->sendServoAttach(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_sendServoAttach__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; - int arg2 ; int arg3 ; int arg4 ; SWIG_check_num_args("ofArduino::sendServoAttach",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::sendServoAttach",1,"ofArduino *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofArduino::sendServoAttach",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofArduino::sendServoAttach",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofArduino::sendServoAttach",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_sendServoAttach",1,SWIGTYPE_p_ofArduino); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); (arg1)->sendServoAttach(arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_sendServoAttach__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; - int arg2 ; int arg3 ; SWIG_check_num_args("ofArduino::sendServoAttach",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::sendServoAttach",1,"ofArduino *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofArduino::sendServoAttach",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofArduino::sendServoAttach",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_sendServoAttach",1,SWIGTYPE_p_ofArduino); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); (arg1)->sendServoAttach(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Arduino_sendServoAttach__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; - int arg2 ; SWIG_check_num_args("ofArduino::sendServoAttach",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::sendServoAttach",1,"ofArduino *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofArduino::sendServoAttach",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_sendServoAttach",1,SWIGTYPE_p_ofArduino); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->sendServoAttach(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_sendServoAttach(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofArduino, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Arduino_sendServoAttach__SWIG_3(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofArduino, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Arduino_sendServoAttach__SWIG_2(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofArduino, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Arduino_sendServoAttach__SWIG_1(L);} } } } } - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofArduino, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Arduino_sendServoAttach__SWIG_0(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Arduino_sendServoAttach'\n" - " Possible C/C++ prototypes are:\n" " ofArduino::sendServoAttach(int,int,int,int)\n" - " ofArduino::sendServoAttach(int,int,int)\n" " ofArduino::sendServoAttach(int,int)\n" - " ofArduino::sendServoAttach(int)\n"); lua_error(L);return 0; } -static int _wrap_Arduino_sendServoDetach(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; int arg2 ; - SWIG_check_num_args("ofArduino::sendServoDetach",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::sendServoDetach",1,"ofArduino *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofArduino::sendServoDetach",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_sendServoDetach",1,SWIGTYPE_p_ofArduino); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->sendServoDetach(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Arduino_getServo(lua_State* L) { int SWIG_arg = 0; ofArduino *arg1 = (ofArduino *) 0 ; int arg2 ; int result; - SWIG_check_num_args("ofArduino::getServo",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofArduino::getServo",1,"ofArduino const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofArduino::getServo",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofArduino,0))){ - SWIG_fail_ptr("Arduino_getServo",1,SWIGTYPE_p_ofArduino); } arg2 = (int)lua_tonumber(L, 2); - result = (int)((ofArduino const *)arg1)->getServo(arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_Arduino(void *obj) { -ofArduino *arg1 = (ofArduino *) obj; -delete arg1; -} -static int _proxy__wrap_new_Arduino(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_Arduino); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_Arduino_attributes[] = { - { "EDigitalPinChanged", _wrap_Arduino_EDigitalPinChanged_get, _wrap_Arduino_EDigitalPinChanged_set }, - { "EAnalogPinChanged", _wrap_Arduino_EAnalogPinChanged_get, _wrap_Arduino_EAnalogPinChanged_set }, - { "ESysExReceived", _wrap_Arduino_ESysExReceived_get, _wrap_Arduino_ESysExReceived_set }, - { "EProtocolVersionReceived", _wrap_Arduino_EProtocolVersionReceived_get, _wrap_Arduino_EProtocolVersionReceived_set }, - { "EFirmwareVersionReceived", _wrap_Arduino_EFirmwareVersionReceived_get, _wrap_Arduino_EFirmwareVersionReceived_set }, - { "EInitialized", _wrap_Arduino_EInitialized_get, _wrap_Arduino_EInitialized_set }, - { "EStringReceived", _wrap_Arduino_EStringReceived_get, _wrap_Arduino_EStringReceived_set }, - {0,0,0} -}; -static swig_lua_method swig_Arduino_methods[]= { - { "connect", _wrap_Arduino_connect}, - { "isInitialized", _wrap_Arduino_isInitialized}, - { "isArduinoReady", _wrap_Arduino_isArduinoReady}, - { "disconnect", _wrap_Arduino_disconnect}, - { "update", _wrap_Arduino_update}, - { "sendDigitalPinMode", _wrap_Arduino_sendDigitalPinMode}, - { "sendAnalogPinReporting", _wrap_Arduino_sendAnalogPinReporting}, - { "setUseDelay", _wrap_Arduino_setUseDelay}, - { "setDigitalHistoryLength", _wrap_Arduino_setDigitalHistoryLength}, - { "setAnalogHistoryLength", _wrap_Arduino_setAnalogHistoryLength}, - { "setStringHistoryLength", _wrap_Arduino_setStringHistoryLength}, - { "setSysExHistoryLength", _wrap_Arduino_setSysExHistoryLength}, - { "sendDigital", _wrap_Arduino_sendDigital}, - { "sendPwm", _wrap_Arduino_sendPwm}, - { "sendSysEx", _wrap_Arduino_sendSysEx}, - { "sendString", _wrap_Arduino_sendString}, - { "sendProtocolVersionRequest", _wrap_Arduino_sendProtocolVersionRequest}, - { "sendFirmwareVersionRequest", _wrap_Arduino_sendFirmwareVersionRequest}, - { "sendReset", _wrap_Arduino_sendReset}, - { "sendSysExBegin", _wrap_Arduino_sendSysExBegin}, - { "sendSysExEnd", _wrap_Arduino_sendSysExEnd}, - { "sendByte", _wrap_Arduino_sendByte}, - { "sendValueAsTwo7bitBytes", _wrap_Arduino_sendValueAsTwo7bitBytes}, - { "getPwm", _wrap_Arduino_getPwm}, - { "getDigital", _wrap_Arduino_getDigital}, - { "getAnalog", _wrap_Arduino_getAnalog}, - { "getSysEx", _wrap_Arduino_getSysEx}, - { "getString", _wrap_Arduino_getString}, - { "getMajorProtocolVersion", _wrap_Arduino_getMajorProtocolVersion}, - { "getMinorProtocolVersion", _wrap_Arduino_getMinorProtocolVersion}, - { "getMajorFirmwareVersion", _wrap_Arduino_getMajorFirmwareVersion}, - { "getMinorFirmwareVersion", _wrap_Arduino_getMinorFirmwareVersion}, - { "getFirmwareName", _wrap_Arduino_getFirmwareName}, - { "getDigitalPinMode", _wrap_Arduino_getDigitalPinMode}, - { "getAnalogPinReporting", _wrap_Arduino_getAnalogPinReporting}, - { "getValueFromTwo7bitBytes", _wrap_Arduino_getValueFromTwo7bitBytes}, - { "sendServo", _wrap_Arduino_sendServo}, - { "sendServoAttach", _wrap_Arduino_sendServoAttach}, - { "sendServoDetach", _wrap_Arduino_sendServoDetach}, - { "getServo", _wrap_Arduino_getServo}, - {0,0} -}; -static swig_lua_method swig_Arduino_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_Arduino_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_Arduino_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_Arduino_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_Arduino_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_Arduino_Sf_SwigStatic = { - "Arduino", - swig_Arduino_Sf_SwigStatic_methods, - swig_Arduino_Sf_SwigStatic_attributes, - swig_Arduino_Sf_SwigStatic_constants, - swig_Arduino_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_Arduino_bases[] = {0}; -static const char *swig_Arduino_base_names[] = {0}; -static swig_lua_class _wrap_class_Arduino = { "Arduino", "Arduino", &SWIGTYPE_p_ofArduino,_proxy__wrap_new_Arduino, swig_delete_Arduino, swig_Arduino_methods, swig_Arduino_attributes, &swig_Arduino_Sf_SwigStatic, swig_Arduino_meta, swig_Arduino_bases, swig_Arduino_base_names }; - -static int _wrap_new_Serial(lua_State* L) { int SWIG_arg = 0; ofSerial *result = 0 ; - SWIG_check_num_args("ofSerial::ofSerial",0,0) result = (ofSerial *)new ofSerial(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofSerial,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Serial_listDevices(lua_State* L) { int SWIG_arg = 0; ofSerial *arg1 = (ofSerial *) 0 ; - SWIG_check_num_args("ofSerial::listDevices",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSerial::listDevices",1,"ofSerial *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSerial,0))){ - SWIG_fail_ptr("Serial_listDevices",1,SWIGTYPE_p_ofSerial); } (arg1)->listDevices(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Serial_getDeviceList(lua_State* L) { int SWIG_arg = 0; ofSerial *arg1 = (ofSerial *) 0 ; - SwigValueWrapper< std::vector< ofSerialDeviceInfo > > result; SWIG_check_num_args("ofSerial::getDeviceList",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSerial::getDeviceList",1,"ofSerial *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSerial,0))){ - SWIG_fail_ptr("Serial_getDeviceList",1,SWIGTYPE_p_ofSerial); } result = (arg1)->getDeviceList(); { - std::vector< ofSerialDeviceInfo > * resultptr = new std::vector< ofSerialDeviceInfo >((const std::vector< ofSerialDeviceInfo > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_ofSerialDeviceInfo_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Serial_setup__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofSerial *arg1 = (ofSerial *) 0 ; bool result; - SWIG_check_num_args("ofSerial::setup",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSerial::setup",1,"ofSerial *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSerial,0))){ - SWIG_fail_ptr("Serial_setup",1,SWIGTYPE_p_ofSerial); } result = (bool)(arg1)->setup(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Serial_setup__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofSerial *arg1 = (ofSerial *) 0 ; std::string arg2 ; - int arg3 ; bool result; SWIG_check_num_args("ofSerial::setup",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSerial::setup",1,"ofSerial *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofSerial::setup",2,"std::string"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofSerial::setup",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSerial,0))){ - SWIG_fail_ptr("Serial_setup",1,SWIGTYPE_p_ofSerial); } (&arg2)->assign(lua_tostring(L,2),lua_rawlen(L,2)); - arg3 = (int)lua_tonumber(L, 3); result = (bool)(arg1)->setup(arg2,arg3); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Serial_setup__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofSerial *arg1 = (ofSerial *) 0 ; int arg2 ; int arg3 ; - bool result; SWIG_check_num_args("ofSerial::setup",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSerial::setup",1,"ofSerial *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSerial::setup",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofSerial::setup",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSerial,0))){ - SWIG_fail_ptr("Serial_setup",1,SWIGTYPE_p_ofSerial); } arg2 = (int)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); - result = (bool)(arg1)->setup(arg2,arg3); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Serial_setup(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 1) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofSerial, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Serial_setup__SWIG_0(L);} } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofSerial, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_Serial_setup__SWIG_2(L);} } } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofSerial, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Serial_setup__SWIG_1(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Serial_setup'\n" " Possible C/C++ prototypes are:\n" - " ofSerial::setup()\n" " ofSerial::setup(std::string,int)\n" " ofSerial::setup(int,int)\n"); lua_error(L);return 0; } -static int _wrap_Serial_isInitialized(lua_State* L) { int SWIG_arg = 0; ofSerial *arg1 = (ofSerial *) 0 ; bool result; - SWIG_check_num_args("ofSerial::isInitialized",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSerial::isInitialized",1,"ofSerial const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSerial,0))){ - SWIG_fail_ptr("Serial_isInitialized",1,SWIGTYPE_p_ofSerial); } result = (bool)((ofSerial const *)arg1)->isInitialized(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Serial_close(lua_State* L) { int SWIG_arg = 0; ofSerial *arg1 = (ofSerial *) 0 ; - SWIG_check_num_args("ofSerial::close",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSerial::close",1,"ofSerial *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSerial,0))){ - SWIG_fail_ptr("Serial_close",1,SWIGTYPE_p_ofSerial); } (arg1)->close(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Serial_available(lua_State* L) { int SWIG_arg = 0; ofSerial *arg1 = (ofSerial *) 0 ; int result; - SWIG_check_num_args("ofSerial::available",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSerial::available",1,"ofSerial *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSerial,0))){ - SWIG_fail_ptr("Serial_available",1,SWIGTYPE_p_ofSerial); } result = (int)(arg1)->available(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Serial_readBytes(lua_State* L) { int SWIG_arg = 0; ofSerial *arg1 = (ofSerial *) 0 ; - unsigned char *arg2 = (unsigned char *) 0 ; int arg3 ; int result; SWIG_check_num_args("ofSerial::readBytes",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSerial::readBytes",1,"ofSerial *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSerial,0))){ - SWIG_fail_ptr("Serial_readBytes",1,SWIGTYPE_p_ofSerial); } { arg3 = (int)lua_tonumber(L, 2+1); - arg2 = (unsigned char *)lua_tolstring(L, 2, (size_t *)&arg3); } result = (int)(arg1)->readBytes(arg2,arg3); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Serial_readByte(lua_State* L) { int SWIG_arg = 0; ofSerial *arg1 = (ofSerial *) 0 ; int result; - SWIG_check_num_args("ofSerial::readByte",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSerial::readByte",1,"ofSerial *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSerial,0))){ - SWIG_fail_ptr("Serial_readByte",1,SWIGTYPE_p_ofSerial); } result = (int)(arg1)->readByte(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Serial_writeBytes(lua_State* L) { int SWIG_arg = 0; ofSerial *arg1 = (ofSerial *) 0 ; - unsigned char *arg2 = (unsigned char *) 0 ; int arg3 ; int result; SWIG_check_num_args("ofSerial::writeBytes",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSerial::writeBytes",1,"ofSerial *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSerial,0))){ - SWIG_fail_ptr("Serial_writeBytes",1,SWIGTYPE_p_ofSerial); } { arg3 = (int)lua_tonumber(L, 2+1); - arg2 = (unsigned char *)lua_tolstring(L, 2, (size_t *)&arg3); } result = (int)(arg1)->writeBytes(arg2,arg3); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Serial_writeByte(lua_State* L) { int SWIG_arg = 0; ofSerial *arg1 = (ofSerial *) 0 ; unsigned char arg2 ; - bool result; SWIG_check_num_args("ofSerial::writeByte",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSerial::writeByte",1,"ofSerial *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSerial::writeByte",2,"unsigned char"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSerial,0))){ - SWIG_fail_ptr("Serial_writeByte",1,SWIGTYPE_p_ofSerial); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned char)lua_tonumber(L, 2); - result = (bool)(arg1)->writeByte(arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Serial_flush__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofSerial *arg1 = (ofSerial *) 0 ; bool arg2 ; - bool arg3 ; SWIG_check_num_args("ofSerial::flush",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSerial::flush",1,"ofSerial *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofSerial::flush",2,"bool"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofSerial::flush",3,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSerial,0))){ - SWIG_fail_ptr("Serial_flush",1,SWIGTYPE_p_ofSerial); } arg2 = (lua_toboolean(L, 2)!=0); arg3 = (lua_toboolean(L, 3)!=0); - (arg1)->flush(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Serial_flush__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofSerial *arg1 = (ofSerial *) 0 ; bool arg2 ; - SWIG_check_num_args("ofSerial::flush",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSerial::flush",1,"ofSerial *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofSerial::flush",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSerial,0))){ - SWIG_fail_ptr("Serial_flush",1,SWIGTYPE_p_ofSerial); } arg2 = (lua_toboolean(L, 2)!=0); (arg1)->flush(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Serial_flush__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofSerial *arg1 = (ofSerial *) 0 ; - SWIG_check_num_args("ofSerial::flush",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSerial::flush",1,"ofSerial *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSerial,0))){ - SWIG_fail_ptr("Serial_flush",1,SWIGTYPE_p_ofSerial); } (arg1)->flush(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Serial_flush(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 1) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofSerial, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Serial_flush__SWIG_2(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofSerial, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_Serial_flush__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofSerial, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } - if (_v) { return _wrap_Serial_flush__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Serial_flush'\n" " Possible C/C++ prototypes are:\n" - " ofSerial::flush(bool,bool)\n" " ofSerial::flush(bool)\n" " ofSerial::flush()\n"); lua_error(L);return 0; } -static int _wrap_Serial_drain(lua_State* L) { int SWIG_arg = 0; ofSerial *arg1 = (ofSerial *) 0 ; - SWIG_check_num_args("ofSerial::drain",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSerial::drain",1,"ofSerial *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSerial,0))){ - SWIG_fail_ptr("Serial_drain",1,SWIGTYPE_p_ofSerial); } (arg1)->drain(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static void swig_delete_Serial(void *obj) { -ofSerial *arg1 = (ofSerial *) obj; -delete arg1; -} -static int _proxy__wrap_new_Serial(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_Serial); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_Serial_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_Serial_methods[]= { - { "listDevices", _wrap_Serial_listDevices}, - { "getDeviceList", _wrap_Serial_getDeviceList}, - { "setup", _wrap_Serial_setup}, - { "isInitialized", _wrap_Serial_isInitialized}, - { "close", _wrap_Serial_close}, - { "available", _wrap_Serial_available}, - { "readBytes", _wrap_Serial_readBytes}, - { "readByte", _wrap_Serial_readByte}, - { "writeBytes", _wrap_Serial_writeBytes}, - { "writeByte", _wrap_Serial_writeByte}, - { "flush", _wrap_Serial_flush}, - { "drain", _wrap_Serial_drain}, - {0,0} -}; -static swig_lua_method swig_Serial_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_Serial_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_Serial_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_Serial_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_Serial_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_Serial_Sf_SwigStatic = { - "Serial", - swig_Serial_Sf_SwigStatic_methods, - swig_Serial_Sf_SwigStatic_attributes, - swig_Serial_Sf_SwigStatic_constants, - swig_Serial_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_Serial_bases[] = {0}; -static const char *swig_Serial_base_names[] = {0}; -static swig_lua_class _wrap_class_Serial = { "Serial", "Serial", &SWIGTYPE_p_ofSerial,_proxy__wrap_new_Serial, swig_delete_Serial, swig_Serial_methods, swig_Serial_attributes, &swig_Serial_Sf_SwigStatic, swig_Serial_meta, swig_Serial_bases, swig_Serial_base_names }; - -static int _wrap_random__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float result; SWIG_check_num_args("ofRandom",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofRandom",1,"float"); arg1 = (float)lua_tonumber(L, 1); result = (float)ofRandom(arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_random__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float result; - SWIG_check_num_args("ofRandom",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofRandom",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRandom",2,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); result = (float)ofRandom(arg1,arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_random(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_random__SWIG_0(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_random__SWIG_1(L);} } - } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'random'\n" " Possible C/C++ prototypes are:\n" - " ofRandom(float)\n" " ofRandom(float,float)\n"); lua_error(L);return 0; } -static int _wrap_randomf(lua_State* L) { int SWIG_arg = 0; float result; SWIG_check_num_args("ofRandomf",0,0) - result = (float)ofRandomf(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_randomuf(lua_State* L) { int SWIG_arg = 0; float result; SWIG_check_num_args("ofRandomuf",0,0) - result = (float)ofRandomuf(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_seedRandom__SWIG_0(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofSeedRandom",0,0) ofSeedRandom(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_seedRandom__SWIG_1(lua_State* L) { int SWIG_arg = 0; int arg1 ; SWIG_check_num_args("ofSeedRandom",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSeedRandom",1,"int"); arg1 = (int)lua_tonumber(L, 1); ofSeedRandom(arg1); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_seedRandom(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_seedRandom__SWIG_0(L);} if (argc == 1) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { - return _wrap_seedRandom__SWIG_1(L);} } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'seedRandom'\n" - " Possible C/C++ prototypes are:\n" " ofSeedRandom()\n" " ofSeedRandom(int)\n"); lua_error(L);return 0; } -static int _wrap_normalize(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float result; - SWIG_check_num_args("ofNormalize",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofNormalize",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofNormalize",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofNormalize",3,"float"); - arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - result = (float)ofNormalize(arg1,arg2,arg3); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_map__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; float arg5 ; - bool arg6 ; float result; SWIG_check_num_args("ofMap",6,6) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMap",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMap",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMap",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMap",4,"float"); if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMap",5,"float"); - if(!lua_isboolean(L,6)) SWIG_fail_arg("ofMap",6,"bool"); arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (lua_toboolean(L, 6)!=0); result = (float)ofMap(arg1,arg2,arg3,arg4,arg5,arg6); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_map__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; float arg5 ; - float result; SWIG_check_num_args("ofMap",5,5) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMap",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMap",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMap",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMap",4,"float"); if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMap",5,"float"); - arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); result = (float)ofMap(arg1,arg2,arg3,arg4,arg5); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_map(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); if (argc == 5) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_map__SWIG_1(L);} } } } } } if (argc == 6) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isboolean(L,argv[5]); } if (_v) { return _wrap_map__SWIG_0(L);} } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'map'\n" " Possible C/C++ prototypes are:\n" - " ofMap(float,float,float,float,float,bool)\n" " ofMap(float,float,float,float,float)\n"); lua_error(L);return 0; } -static int _wrap_clamp(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float result; - SWIG_check_num_args("ofClamp",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofClamp",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofClamp",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofClamp",3,"float"); - arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - result = (float)ofClamp(arg1,arg2,arg3); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_inRange(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; bool result; - SWIG_check_num_args("ofInRange",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofInRange",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofInRange",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofInRange",3,"float"); - arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - result = (bool)ofInRange(arg1,arg2,arg3); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_lerp(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float result; - SWIG_check_num_args("ofLerp",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofLerp",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofLerp",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofLerp",3,"float"); - arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - result = (float)ofLerp(arg1,arg2,arg3); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_dist__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - float result; SWIG_check_num_args("ofDist",4,4) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDist",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDist",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDist",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDist",4,"float"); arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); result = (float)ofDist(arg1,arg2,arg3,arg4); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_dist__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; float arg5 ; - float arg6 ; float result; SWIG_check_num_args("ofDist",6,6) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDist",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDist",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDist",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDist",4,"float"); if(!lua_isnumber(L,5)) SWIG_fail_arg("ofDist",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofDist",6,"float"); arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); result = (float)ofDist(arg1,arg2,arg3,arg4,arg5,arg6); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_dist(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); if (argc == 4) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_dist__SWIG_0(L);} } } } } if (argc == 6) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { - return _wrap_dist__SWIG_1(L);} } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'dist'\n" " Possible C/C++ prototypes are:\n" - " ofDist(float,float,float,float)\n" " ofDist(float,float,float,float,float,float)\n"); lua_error(L);return 0; } -static int _wrap_distSquared__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - float result; SWIG_check_num_args("ofDistSquared",4,4) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDistSquared",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDistSquared",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDistSquared",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDistSquared",4,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - result = (float)ofDistSquared(arg1,arg2,arg3,arg4); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_distSquared__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - float arg5 ; float arg6 ; float result; SWIG_check_num_args("ofDistSquared",6,6) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDistSquared",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDistSquared",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDistSquared",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDistSquared",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofDistSquared",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofDistSquared",6,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); - result = (float)ofDistSquared(arg1,arg2,arg3,arg4,arg5,arg6); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_distSquared(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); if (argc == 4) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { - return _wrap_distSquared__SWIG_0(L);} } } } } if (argc == 6) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { return _wrap_distSquared__SWIG_1(L);} } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'distSquared'\n" " Possible C/C++ prototypes are:\n" - " ofDistSquared(float,float,float,float)\n" " ofDistSquared(float,float,float,float,float,float)\n"); - lua_error(L);return 0; } -static int _wrap_radToDeg(lua_State* L) { int SWIG_arg = 0; float arg1 ; float result; SWIG_check_num_args("ofRadToDeg",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofRadToDeg",1,"float"); arg1 = (float)lua_tonumber(L, 1); - result = (float)ofRadToDeg(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_degToRad(lua_State* L) { int SWIG_arg = 0; float arg1 ; float result; SWIG_check_num_args("ofDegToRad",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDegToRad",1,"float"); arg1 = (float)lua_tonumber(L, 1); - result = (float)ofDegToRad(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_lerpDegrees(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float result; - SWIG_check_num_args("ofLerpDegrees",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofLerpDegrees",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofLerpDegrees",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofLerpDegrees",3,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); result = (float)ofLerpDegrees(arg1,arg2,arg3); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_lerpRadians(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float result; - SWIG_check_num_args("ofLerpRadians",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofLerpRadians",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofLerpRadians",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofLerpRadians",3,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); result = (float)ofLerpRadians(arg1,arg2,arg3); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_angleDifferenceDegrees(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float result; - SWIG_check_num_args("ofAngleDifferenceDegrees",2,2) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofAngleDifferenceDegrees",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofAngleDifferenceDegrees",2,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); result = (float)ofAngleDifferenceDegrees(arg1,arg2); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_angleDifferenceRadians(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float result; - SWIG_check_num_args("ofAngleDifferenceRadians",2,2) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofAngleDifferenceRadians",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofAngleDifferenceRadians",2,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); result = (float)ofAngleDifferenceRadians(arg1,arg2); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_wrap(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float result; - SWIG_check_num_args("ofWrap",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofWrap",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofWrap",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofWrap",3,"float"); - arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - result = (float)ofWrap(arg1,arg2,arg3); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_wrapRadians__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float result; - SWIG_check_num_args("ofWrapRadians",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofWrapRadians",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofWrapRadians",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofWrapRadians",3,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); result = (float)ofWrapRadians(arg1,arg2,arg3); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_wrapRadians__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float result; - SWIG_check_num_args("ofWrapRadians",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofWrapRadians",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofWrapRadians",2,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); result = (float)ofWrapRadians(arg1,arg2); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_wrapRadians__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; float result; - SWIG_check_num_args("ofWrapRadians",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofWrapRadians",1,"float"); - arg1 = (float)lua_tonumber(L, 1); result = (float)ofWrapRadians(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_wrapRadians(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_wrapRadians__SWIG_2(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_wrapRadians__SWIG_1(L);} } } if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_wrapRadians__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'wrapRadians'\n" " Possible C/C++ prototypes are:\n" - " ofWrapRadians(float,float,float)\n" " ofWrapRadians(float,float)\n" " ofWrapRadians(float)\n"); - lua_error(L);return 0; } -static int _wrap_wrapDegrees__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float result; - SWIG_check_num_args("ofWrapDegrees",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofWrapDegrees",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofWrapDegrees",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofWrapDegrees",3,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); result = (float)ofWrapDegrees(arg1,arg2,arg3); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_wrapDegrees__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float result; - SWIG_check_num_args("ofWrapDegrees",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofWrapDegrees",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofWrapDegrees",2,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); result = (float)ofWrapDegrees(arg1,arg2); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_wrapDegrees__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; float result; - SWIG_check_num_args("ofWrapDegrees",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofWrapDegrees",1,"float"); - arg1 = (float)lua_tonumber(L, 1); result = (float)ofWrapDegrees(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_wrapDegrees(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_wrapDegrees__SWIG_2(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_wrapDegrees__SWIG_1(L);} } } if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_wrapDegrees__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'wrapDegrees'\n" " Possible C/C++ prototypes are:\n" - " ofWrapDegrees(float,float,float)\n" " ofWrapDegrees(float,float)\n" " ofWrapDegrees(float)\n"); - lua_error(L);return 0; } -static int _wrap_noise__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float result; SWIG_check_num_args("ofNoise",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofNoise",1,"float"); arg1 = (float)lua_tonumber(L, 1); result = (float)ofNoise(arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_noise__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float result; - SWIG_check_num_args("ofNoise",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofNoise",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofNoise",2,"float"); arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); - result = (float)ofNoise(arg1,arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_noise__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = 0 ; float result; - SWIG_check_num_args("ofNoise",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofNoise",1,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("noise",1,SWIGTYPE_p_ofVec2f); } - result = (float)ofNoise((ofVec2f const &)*arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_noise__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float result; - SWIG_check_num_args("ofNoise",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofNoise",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofNoise",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofNoise",3,"float"); - arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - result = (float)ofNoise(arg1,arg2,arg3); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_noise__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = 0 ; float result; - SWIG_check_num_args("ofNoise",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofNoise",1,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("noise",1,SWIGTYPE_p_ofVec3f); } - result = (float)ofNoise((ofVec3f const &)*arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_noise__SWIG_5(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - float result; SWIG_check_num_args("ofNoise",4,4) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofNoise",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofNoise",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofNoise",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofNoise",4,"float"); arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); result = (float)ofNoise(arg1,arg2,arg3,arg4); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_noise__SWIG_6(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = 0 ; float result; - SWIG_check_num_args("ofNoise",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofNoise",1,"ofVec4f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("noise",1,SWIGTYPE_p_ofVec4f); } - result = (float)ofNoise((ofVec4f const &)*arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_noise(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_noise__SWIG_2(L);} } if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_noise__SWIG_4(L);} } if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_noise__SWIG_6(L);} } if (argc == 1) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { return _wrap_noise__SWIG_0(L);} } if (argc == 2) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_noise__SWIG_1(L);} } } if (argc == 3) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_noise__SWIG_3(L);} } } } if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_noise__SWIG_5(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'noise'\n" " Possible C/C++ prototypes are:\n" - " ofNoise(float)\n" " ofNoise(float,float)\n" " ofNoise(ofVec2f const &)\n" " ofNoise(float,float,float)\n" - " ofNoise(ofVec3f const &)\n" " ofNoise(float,float,float,float)\n" " ofNoise(ofVec4f const &)\n"); - lua_error(L);return 0; } -static int _wrap_signedNoise__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float result; - SWIG_check_num_args("ofSignedNoise",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSignedNoise",1,"float"); - arg1 = (float)lua_tonumber(L, 1); result = (float)ofSignedNoise(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_signedNoise__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float result; - SWIG_check_num_args("ofSignedNoise",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSignedNoise",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSignedNoise",2,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); result = (float)ofSignedNoise(arg1,arg2); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_signedNoise__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = 0 ; float result; - SWIG_check_num_args("ofSignedNoise",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofSignedNoise",1,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("signedNoise",1,SWIGTYPE_p_ofVec2f); } - result = (float)ofSignedNoise((ofVec2f const &)*arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_signedNoise__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float result; - SWIG_check_num_args("ofSignedNoise",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSignedNoise",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSignedNoise",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofSignedNoise",3,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); result = (float)ofSignedNoise(arg1,arg2,arg3); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_signedNoise__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = 0 ; float result; - SWIG_check_num_args("ofSignedNoise",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofSignedNoise",1,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("signedNoise",1,SWIGTYPE_p_ofVec3f); } - result = (float)ofSignedNoise((ofVec3f const &)*arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_signedNoise__SWIG_5(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - float result; SWIG_check_num_args("ofSignedNoise",4,4) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSignedNoise",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSignedNoise",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofSignedNoise",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofSignedNoise",4,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - result = (float)ofSignedNoise(arg1,arg2,arg3,arg4); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_signedNoise__SWIG_6(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = 0 ; float result; - SWIG_check_num_args("ofSignedNoise",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofSignedNoise",1,"ofVec4f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("signedNoise",1,SWIGTYPE_p_ofVec4f); } - result = (float)ofSignedNoise((ofVec4f const &)*arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_signedNoise(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 1) { int _v; - { void *ptr; if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_signedNoise__SWIG_2(L);} } if (argc == 1) { int _v; { - void *ptr; if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_signedNoise__SWIG_4(L);} } if (argc == 1) { int _v; { - void *ptr; if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_signedNoise__SWIG_6(L);} } if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_signedNoise__SWIG_0(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_signedNoise__SWIG_1(L);} } } if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_signedNoise__SWIG_3(L);} } } } if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { - { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_signedNoise__SWIG_5(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'signedNoise'\n" " Possible C/C++ prototypes are:\n" - " ofSignedNoise(float)\n" " ofSignedNoise(float,float)\n" " ofSignedNoise(ofVec2f const &)\n" - " ofSignedNoise(float,float,float)\n" " ofSignedNoise(ofVec3f const &)\n" " ofSignedNoise(float,float,float,float)\n" - " ofSignedNoise(ofVec4f const &)\n"); lua_error(L);return 0; } -static int _wrap_insidePoly__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; - std::vector< ofPoint > *arg3 = 0 ; bool result; SWIG_check_num_args("ofInsidePoly",3,3) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofInsidePoly",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofInsidePoly",2,"float"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofInsidePoly",3,"std::vector< ofPoint > const &"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_std__vectorT_ofVec3f_t,0))){ - SWIG_fail_ptr("insidePoly",3,SWIGTYPE_p_std__vectorT_ofVec3f_t); } - result = (bool)ofInsidePoly(arg1,arg2,(std::vector< ofVec3f > const &)*arg3); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_insidePoly__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPoint *arg1 = 0 ; std::vector< ofPoint > *arg2 = 0 ; - bool result; SWIG_check_num_args("ofInsidePoly",2,2) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofInsidePoly",1,"ofPoint const &"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofInsidePoly",2,"std::vector< ofPoint > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("insidePoly",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__vectorT_ofVec3f_t,0))){ - SWIG_fail_ptr("insidePoly",2,SWIGTYPE_p_std__vectorT_ofVec3f_t); } - result = (bool)ofInsidePoly((ofVec3f const &)*arg1,(std::vector< ofVec3f > const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_insidePoly(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_std__vectorT_ofVec3f_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_insidePoly__SWIG_1(L);} } } if (argc == 3) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_std__vectorT_ofVec3f_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_insidePoly__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'insidePoly'\n" " Possible C/C++ prototypes are:\n" - " ofInsidePoly(float,float,std::vector< ofPoint > const &)\n" - " ofInsidePoly(ofPoint const &,std::vector< ofPoint > const &)\n"); lua_error(L);return 0; } -static int _wrap_lineSegmentIntersection(lua_State* L) { int SWIG_arg = 0; ofPoint *arg1 = 0 ; ofPoint *arg2 = 0 ; - ofPoint *arg3 = 0 ; ofPoint *arg4 = 0 ; ofPoint *arg5 = 0 ; bool result; SWIG_check_num_args("ofLineSegmentIntersection",5,5) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofLineSegmentIntersection",1,"ofPoint const &"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofLineSegmentIntersection",2,"ofPoint const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofLineSegmentIntersection",3,"ofPoint const &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofLineSegmentIntersection",4,"ofPoint const &"); - if(!lua_isuserdata(L,5)) SWIG_fail_arg("ofLineSegmentIntersection",5,"ofPoint &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("lineSegmentIntersection",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("lineSegmentIntersection",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("lineSegmentIntersection",3,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("lineSegmentIntersection",4,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("lineSegmentIntersection",5,SWIGTYPE_p_ofVec3f); } - result = (bool)ofLineSegmentIntersection((ofVec3f const &)*arg1,(ofVec3f const &)*arg2,(ofVec3f const &)*arg3,(ofVec3f const &)*arg4,*arg5); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_bezierPoint(lua_State* L) { int SWIG_arg = 0; ofPoint *arg1 = 0 ; ofPoint *arg2 = 0 ; ofPoint *arg3 = 0 ; - ofPoint *arg4 = 0 ; float arg5 ; ofPoint result; SWIG_check_num_args("ofBezierPoint",5,5) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofBezierPoint",1,"ofPoint const &"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofBezierPoint",2,"ofPoint const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofBezierPoint",3,"ofPoint const &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofBezierPoint",4,"ofPoint const &"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofBezierPoint",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("bezierPoint",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("bezierPoint",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("bezierPoint",3,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("bezierPoint",4,SWIGTYPE_p_ofVec3f); } - arg5 = (float)lua_tonumber(L, 5); - result = ofBezierPoint((ofVec3f const &)*arg1,(ofVec3f const &)*arg2,(ofVec3f const &)*arg3,(ofVec3f const &)*arg4,arg5); { - ofPoint * resultptr = new ofPoint((const ofPoint &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_curvePoint(lua_State* L) { int SWIG_arg = 0; ofPoint *arg1 = 0 ; ofPoint *arg2 = 0 ; ofPoint *arg3 = 0 ; - ofPoint *arg4 = 0 ; float arg5 ; ofPoint result; SWIG_check_num_args("ofCurvePoint",5,5) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofCurvePoint",1,"ofPoint const &"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofCurvePoint",2,"ofPoint const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofCurvePoint",3,"ofPoint const &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofCurvePoint",4,"ofPoint const &"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofCurvePoint",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("curvePoint",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("curvePoint",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("curvePoint",3,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("curvePoint",4,SWIGTYPE_p_ofVec3f); } - arg5 = (float)lua_tonumber(L, 5); - result = ofCurvePoint((ofVec3f const &)*arg1,(ofVec3f const &)*arg2,(ofVec3f const &)*arg3,(ofVec3f const &)*arg4,arg5); { - ofPoint * resultptr = new ofPoint((const ofPoint &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_bezierTangent(lua_State* L) { int SWIG_arg = 0; ofPoint *arg1 = 0 ; ofPoint *arg2 = 0 ; ofPoint *arg3 = 0 ; - ofPoint *arg4 = 0 ; float arg5 ; ofPoint result; SWIG_check_num_args("ofBezierTangent",5,5) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofBezierTangent",1,"ofPoint const &"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofBezierTangent",2,"ofPoint const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofBezierTangent",3,"ofPoint const &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofBezierTangent",4,"ofPoint const &"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofBezierTangent",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("bezierTangent",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("bezierTangent",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("bezierTangent",3,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("bezierTangent",4,SWIGTYPE_p_ofVec3f); } arg5 = (float)lua_tonumber(L, 5); - result = ofBezierTangent((ofVec3f const &)*arg1,(ofVec3f const &)*arg2,(ofVec3f const &)*arg3,(ofVec3f const &)*arg4,arg5); { - ofPoint * resultptr = new ofPoint((const ofPoint &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_curveTangent(lua_State* L) { int SWIG_arg = 0; ofPoint *arg1 = 0 ; ofPoint *arg2 = 0 ; ofPoint *arg3 = 0 ; - ofPoint *arg4 = 0 ; float arg5 ; ofPoint result; SWIG_check_num_args("ofCurveTangent",5,5) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofCurveTangent",1,"ofPoint const &"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofCurveTangent",2,"ofPoint const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofCurveTangent",3,"ofPoint const &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofCurveTangent",4,"ofPoint const &"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofCurveTangent",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("curveTangent",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("curveTangent",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("curveTangent",3,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("curveTangent",4,SWIGTYPE_p_ofVec3f); } arg5 = (float)lua_tonumber(L, 5); - result = ofCurveTangent((ofVec3f const &)*arg1,(ofVec3f const &)*arg2,(ofVec3f const &)*arg3,(ofVec3f const &)*arg4,arg5); { - ofPoint * resultptr = new ofPoint((const ofPoint &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_nextPow2(lua_State* L) { int SWIG_arg = 0; int arg1 ; int result; SWIG_check_num_args("ofNextPow2",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofNextPow2",1,"int"); arg1 = (int)lua_tonumber(L, 1); result = (int)ofNextPow2(arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_sign(lua_State* L) { int SWIG_arg = 0; float arg1 ; int result; SWIG_check_num_args("ofSign",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSign",1,"float"); arg1 = (float)lua_tonumber(L, 1); result = (int)ofSign(arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix3x3_a_set(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; float arg2 ; - SWIG_check_num_args("ofMatrix3x3::a",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::a",1,"ofMatrix3x3 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix3x3::a",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3_a_set",1,SWIGTYPE_p_ofMatrix3x3); } arg2 = (float)lua_tonumber(L, 2); if (arg1) (arg1)->a = arg2; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix3x3_a_get(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; float result; - SWIG_check_num_args("ofMatrix3x3::a",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::a",1,"ofMatrix3x3 *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3_a_get",1,SWIGTYPE_p_ofMatrix3x3); } result = (float) ((arg1)->a); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix3x3_b_set(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; float arg2 ; - SWIG_check_num_args("ofMatrix3x3::b",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::b",1,"ofMatrix3x3 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix3x3::b",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3_b_set",1,SWIGTYPE_p_ofMatrix3x3); } arg2 = (float)lua_tonumber(L, 2); if (arg1) (arg1)->b = arg2; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix3x3_b_get(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; float result; - SWIG_check_num_args("ofMatrix3x3::b",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::b",1,"ofMatrix3x3 *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3_b_get",1,SWIGTYPE_p_ofMatrix3x3); } result = (float) ((arg1)->b); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix3x3_c_set(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; float arg2 ; - SWIG_check_num_args("ofMatrix3x3::c",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::c",1,"ofMatrix3x3 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix3x3::c",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3_c_set",1,SWIGTYPE_p_ofMatrix3x3); } arg2 = (float)lua_tonumber(L, 2); if (arg1) (arg1)->c = arg2; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix3x3_c_get(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; float result; - SWIG_check_num_args("ofMatrix3x3::c",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::c",1,"ofMatrix3x3 *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3_c_get",1,SWIGTYPE_p_ofMatrix3x3); } result = (float) ((arg1)->c); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix3x3_d_set(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; float arg2 ; - SWIG_check_num_args("ofMatrix3x3::d",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::d",1,"ofMatrix3x3 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix3x3::d",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3_d_set",1,SWIGTYPE_p_ofMatrix3x3); } arg2 = (float)lua_tonumber(L, 2); if (arg1) (arg1)->d = arg2; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix3x3_d_get(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; float result; - SWIG_check_num_args("ofMatrix3x3::d",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::d",1,"ofMatrix3x3 *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3_d_get",1,SWIGTYPE_p_ofMatrix3x3); } result = (float) ((arg1)->d); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix3x3_e_set(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; float arg2 ; - SWIG_check_num_args("ofMatrix3x3::e",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::e",1,"ofMatrix3x3 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix3x3::e",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3_e_set",1,SWIGTYPE_p_ofMatrix3x3); } arg2 = (float)lua_tonumber(L, 2); if (arg1) (arg1)->e = arg2; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix3x3_e_get(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; float result; - SWIG_check_num_args("ofMatrix3x3::e",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::e",1,"ofMatrix3x3 *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3_e_get",1,SWIGTYPE_p_ofMatrix3x3); } result = (float) ((arg1)->e); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix3x3_f_set(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; float arg2 ; - SWIG_check_num_args("ofMatrix3x3::f",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::f",1,"ofMatrix3x3 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix3x3::f",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3_f_set",1,SWIGTYPE_p_ofMatrix3x3); } arg2 = (float)lua_tonumber(L, 2); if (arg1) (arg1)->f = arg2; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix3x3_f_get(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; float result; - SWIG_check_num_args("ofMatrix3x3::f",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::f",1,"ofMatrix3x3 *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3_f_get",1,SWIGTYPE_p_ofMatrix3x3); } result = (float) ((arg1)->f); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix3x3_g_set(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; float arg2 ; - SWIG_check_num_args("ofMatrix3x3::g",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::g",1,"ofMatrix3x3 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix3x3::g",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3_g_set",1,SWIGTYPE_p_ofMatrix3x3); } arg2 = (float)lua_tonumber(L, 2); if (arg1) (arg1)->g = arg2; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix3x3_g_get(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; float result; - SWIG_check_num_args("ofMatrix3x3::g",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::g",1,"ofMatrix3x3 *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3_g_get",1,SWIGTYPE_p_ofMatrix3x3); } result = (float) ((arg1)->g); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix3x3_h_set(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; float arg2 ; - SWIG_check_num_args("ofMatrix3x3::h",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::h",1,"ofMatrix3x3 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix3x3::h",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3_h_set",1,SWIGTYPE_p_ofMatrix3x3); } arg2 = (float)lua_tonumber(L, 2); if (arg1) (arg1)->h = arg2; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix3x3_h_get(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; float result; - SWIG_check_num_args("ofMatrix3x3::h",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::h",1,"ofMatrix3x3 *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3_h_get",1,SWIGTYPE_p_ofMatrix3x3); } result = (float) ((arg1)->h); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix3x3_i_set(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; float arg2 ; - SWIG_check_num_args("ofMatrix3x3::i",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::i",1,"ofMatrix3x3 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix3x3::i",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3_i_set",1,SWIGTYPE_p_ofMatrix3x3); } arg2 = (float)lua_tonumber(L, 2); if (arg1) (arg1)->i = arg2; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix3x3_i_get(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; float result; - SWIG_check_num_args("ofMatrix3x3::i",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::i",1,"ofMatrix3x3 *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3_i_get",1,SWIGTYPE_p_ofMatrix3x3); } result = (float) ((arg1)->i); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_new_Matrix3x3__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - float arg5 ; float arg6 ; float arg7 ; float arg8 ; float arg9 ; ofMatrix3x3 *result = 0 ; - SWIG_check_num_args("ofMatrix3x3::ofMatrix3x3",9,9) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",8,"float"); - if(!lua_isnumber(L,9)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",9,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); - arg8 = (float)lua_tonumber(L, 8); arg9 = (float)lua_tonumber(L, 9); - result = (ofMatrix3x3 *)new ofMatrix3x3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMatrix3x3,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Matrix3x3__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - float arg5 ; float arg6 ; float arg7 ; float arg8 ; ofMatrix3x3 *result = 0 ; - SWIG_check_num_args("ofMatrix3x3::ofMatrix3x3",8,8) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",8,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); - arg8 = (float)lua_tonumber(L, 8); result = (ofMatrix3x3 *)new ofMatrix3x3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMatrix3x3,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Matrix3x3__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - float arg5 ; float arg6 ; float arg7 ; ofMatrix3x3 *result = 0 ; SWIG_check_num_args("ofMatrix3x3::ofMatrix3x3",7,7) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",7,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); - result = (ofMatrix3x3 *)new ofMatrix3x3(arg1,arg2,arg3,arg4,arg5,arg6,arg7); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMatrix3x3,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Matrix3x3__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - float arg5 ; float arg6 ; ofMatrix3x3 *result = 0 ; SWIG_check_num_args("ofMatrix3x3::ofMatrix3x3",6,6) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",6,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); - result = (ofMatrix3x3 *)new ofMatrix3x3(arg1,arg2,arg3,arg4,arg5,arg6); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMatrix3x3,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Matrix3x3__SWIG_4(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - float arg5 ; ofMatrix3x3 *result = 0 ; SWIG_check_num_args("ofMatrix3x3::ofMatrix3x3",5,5) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",5,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); result = (ofMatrix3x3 *)new ofMatrix3x3(arg1,arg2,arg3,arg4,arg5); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMatrix3x3,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Matrix3x3__SWIG_5(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - ofMatrix3x3 *result = 0 ; SWIG_check_num_args("ofMatrix3x3::ofMatrix3x3",4,4) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",4,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - result = (ofMatrix3x3 *)new ofMatrix3x3(arg1,arg2,arg3,arg4); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMatrix3x3,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Matrix3x3__SWIG_6(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; - ofMatrix3x3 *result = 0 ; SWIG_check_num_args("ofMatrix3x3::ofMatrix3x3",3,3) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",3,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); result = (ofMatrix3x3 *)new ofMatrix3x3(arg1,arg2,arg3); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMatrix3x3,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Matrix3x3__SWIG_7(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; ofMatrix3x3 *result = 0 ; - SWIG_check_num_args("ofMatrix3x3::ofMatrix3x3",2,2) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",2,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); result = (ofMatrix3x3 *)new ofMatrix3x3(arg1,arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMatrix3x3,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Matrix3x3__SWIG_8(lua_State* L) { int SWIG_arg = 0; float arg1 ; ofMatrix3x3 *result = 0 ; - SWIG_check_num_args("ofMatrix3x3::ofMatrix3x3",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMatrix3x3::ofMatrix3x3",1,"float"); arg1 = (float)lua_tonumber(L, 1); - result = (ofMatrix3x3 *)new ofMatrix3x3(arg1); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMatrix3x3,1); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_new_Matrix3x3__SWIG_9(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *result = 0 ; - SWIG_check_num_args("ofMatrix3x3::ofMatrix3x3",0,0) result = (ofMatrix3x3 *)new ofMatrix3x3(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMatrix3x3,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Matrix3x3(lua_State* L) { int argc; int argv[10]={ 1,2,3,4,5,6,7,8,9,10} ; argc = lua_gettop(L); - if (argc == 0) { return _wrap_new_Matrix3x3__SWIG_9(L);} if (argc == 1) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { return _wrap_new_Matrix3x3__SWIG_8(L);} } if (argc == 2) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { - { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_new_Matrix3x3__SWIG_7(L);} } } if (argc == 3) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_new_Matrix3x3__SWIG_6(L);} } } } if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_new_Matrix3x3__SWIG_5(L);} } } } } if (argc == 5) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_new_Matrix3x3__SWIG_4(L);} } } } } } - if (argc == 6) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { - return _wrap_new_Matrix3x3__SWIG_3(L);} } } } } } } if (argc == 7) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { - return _wrap_new_Matrix3x3__SWIG_2(L);} } } } } } } } if (argc == 8) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { return _wrap_new_Matrix3x3__SWIG_1(L);} } } } } } } } } - if (argc == 9) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { { - _v = lua_isnumber(L,argv[6]); } if (_v) { { _v = lua_isnumber(L,argv[7]); } if (_v) { { - _v = lua_isnumber(L,argv[8]); } if (_v) { return _wrap_new_Matrix3x3__SWIG_0(L);} } } } } } } } } - } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_Matrix3x3'\n" - " Possible C/C++ prototypes are:\n" " ofMatrix3x3::ofMatrix3x3(float,float,float,float,float,float,float,float,float)\n" - " ofMatrix3x3::ofMatrix3x3(float,float,float,float,float,float,float,float)\n" - " ofMatrix3x3::ofMatrix3x3(float,float,float,float,float,float,float)\n" - " ofMatrix3x3::ofMatrix3x3(float,float,float,float,float,float)\n" - " ofMatrix3x3::ofMatrix3x3(float,float,float,float,float)\n" " ofMatrix3x3::ofMatrix3x3(float,float,float,float)\n" - " ofMatrix3x3::ofMatrix3x3(float,float,float)\n" " ofMatrix3x3::ofMatrix3x3(float,float)\n" - " ofMatrix3x3::ofMatrix3x3(float)\n" " ofMatrix3x3::ofMatrix3x3()\n"); lua_error(L);return 0; } -static int _wrap_Matrix3x3_set(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; float arg2 ; - float arg3 ; float arg4 ; float arg5 ; float arg6 ; float arg7 ; float arg8 ; float arg9 ; float arg10 ; - SWIG_check_num_args("ofMatrix3x3::set",10,10) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::set",1,"ofMatrix3x3 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix3x3::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix3x3::set",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix3x3::set",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMatrix3x3::set",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofMatrix3x3::set",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofMatrix3x3::set",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofMatrix3x3::set",8,"float"); - if(!lua_isnumber(L,9)) SWIG_fail_arg("ofMatrix3x3::set",9,"float"); - if(!lua_isnumber(L,10)) SWIG_fail_arg("ofMatrix3x3::set",10,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3_set",1,SWIGTYPE_p_ofMatrix3x3); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (float)lua_tonumber(L, 8); - arg9 = (float)lua_tonumber(L, 9); arg10 = (float)lua_tonumber(L, 10); - (arg1)->set(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Matrix3x3_transpose__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; - SWIG_check_num_args("ofMatrix3x3::transpose",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::transpose",1,"ofMatrix3x3 *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3_transpose",1,SWIGTYPE_p_ofMatrix3x3); } (arg1)->transpose(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix3x3_transpose__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; - ofMatrix3x3 *arg2 = 0 ; ofMatrix3x3 result; SWIG_check_num_args("ofMatrix3x3::transpose",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::transpose",1,"ofMatrix3x3 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix3x3::transpose",2,"ofMatrix3x3 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3_transpose",1,SWIGTYPE_p_ofMatrix3x3); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3_transpose",2,SWIGTYPE_p_ofMatrix3x3); } result = (arg1)->transpose((ofMatrix3x3 const &)*arg2); { - ofMatrix3x3 * resultptr = new ofMatrix3x3((const ofMatrix3x3 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix3x3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix3x3_transpose(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix3x3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix3x3_transpose__SWIG_0(L);} } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix3x3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofMatrix3x3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix3x3_transpose__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix3x3_transpose'\n" - " Possible C/C++ prototypes are:\n" " ofMatrix3x3::transpose()\n" " ofMatrix3x3::transpose(ofMatrix3x3 const &)\n"); - lua_error(L);return 0; } -static int _wrap_Matrix3x3_determinant__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; - float result; SWIG_check_num_args("ofMatrix3x3::determinant",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::determinant",1,"ofMatrix3x3 const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3_determinant",1,SWIGTYPE_p_ofMatrix3x3); } - result = (float)((ofMatrix3x3 const *)arg1)->determinant(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix3x3_determinant__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; - ofMatrix3x3 *arg2 = 0 ; float result; SWIG_check_num_args("ofMatrix3x3::determinant",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::determinant",1,"ofMatrix3x3 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix3x3::determinant",2,"ofMatrix3x3 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3_determinant",1,SWIGTYPE_p_ofMatrix3x3); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3_determinant",2,SWIGTYPE_p_ofMatrix3x3); } - result = (float)(arg1)->determinant((ofMatrix3x3 const &)*arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix3x3_determinant(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix3x3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix3x3_determinant__SWIG_0(L);} } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix3x3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofMatrix3x3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix3x3_determinant__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix3x3_determinant'\n" - " Possible C/C++ prototypes are:\n" " ofMatrix3x3::determinant() const\n" - " ofMatrix3x3::determinant(ofMatrix3x3 const &)\n"); lua_error(L);return 0; } -static int _wrap_Matrix3x3_inverse(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; - ofMatrix3x3 *arg2 = 0 ; ofMatrix3x3 result; SWIG_check_num_args("ofMatrix3x3::inverse",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::inverse",1,"ofMatrix3x3 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix3x3::inverse",2,"ofMatrix3x3 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3_inverse",1,SWIGTYPE_p_ofMatrix3x3); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3_inverse",2,SWIGTYPE_p_ofMatrix3x3); } result = (arg1)->inverse((ofMatrix3x3 const &)*arg2); { - ofMatrix3x3 * resultptr = new ofMatrix3x3((const ofMatrix3x3 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix3x3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix3x3_invert(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; - SWIG_check_num_args("ofMatrix3x3::invert",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::invert",1,"ofMatrix3x3 *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3_invert",1,SWIGTYPE_p_ofMatrix3x3); } (arg1)->invert(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix3x3_entrywiseTimes(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; - ofMatrix3x3 *arg2 = 0 ; ofMatrix3x3 result; SWIG_check_num_args("ofMatrix3x3::entrywiseTimes",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::entrywiseTimes",1,"ofMatrix3x3 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix3x3::entrywiseTimes",2,"ofMatrix3x3 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3_entrywiseTimes",1,SWIGTYPE_p_ofMatrix3x3); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3_entrywiseTimes",2,SWIGTYPE_p_ofMatrix3x3); } - result = (arg1)->entrywiseTimes((ofMatrix3x3 const &)*arg2); { - ofMatrix3x3 * resultptr = new ofMatrix3x3((const ofMatrix3x3 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix3x3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix3x3___add(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; - ofMatrix3x3 *arg2 = 0 ; ofMatrix3x3 result; SWIG_check_num_args("ofMatrix3x3::operator +",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::operator +",1,"ofMatrix3x3 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix3x3::operator +",2,"ofMatrix3x3 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3___add",1,SWIGTYPE_p_ofMatrix3x3); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3___add",2,SWIGTYPE_p_ofMatrix3x3); } result = (arg1)->operator +((ofMatrix3x3 const &)*arg2); { - ofMatrix3x3 * resultptr = new ofMatrix3x3((const ofMatrix3x3 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix3x3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix3x3___sub(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; - ofMatrix3x3 *arg2 = 0 ; ofMatrix3x3 result; SWIG_check_num_args("ofMatrix3x3::operator -",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::operator -",1,"ofMatrix3x3 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix3x3::operator -",2,"ofMatrix3x3 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3___sub",1,SWIGTYPE_p_ofMatrix3x3); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3___sub",2,SWIGTYPE_p_ofMatrix3x3); } result = (arg1)->operator -((ofMatrix3x3 const &)*arg2); { - ofMatrix3x3 * resultptr = new ofMatrix3x3((const ofMatrix3x3 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix3x3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix3x3___mul__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; float arg2 ; - ofMatrix3x3 result; SWIG_check_num_args("ofMatrix3x3::operator *",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::operator *",1,"ofMatrix3x3 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix3x3::operator *",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3___mul",1,SWIGTYPE_p_ofMatrix3x3); } arg2 = (float)lua_tonumber(L, 2); - result = (arg1)->operator *(arg2); { ofMatrix3x3 * resultptr = new ofMatrix3x3((const ofMatrix3x3 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix3x3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix3x3___mul__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; - ofMatrix3x3 *arg2 = 0 ; ofMatrix3x3 result; SWIG_check_num_args("ofMatrix3x3::operator *",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::operator *",1,"ofMatrix3x3 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix3x3::operator *",2,"ofMatrix3x3 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3___mul",1,SWIGTYPE_p_ofMatrix3x3); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3___mul",2,SWIGTYPE_p_ofMatrix3x3); } result = (arg1)->operator *((ofMatrix3x3 const &)*arg2); { - ofMatrix3x3 * resultptr = new ofMatrix3x3((const ofMatrix3x3 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix3x3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix3x3___mul(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix3x3, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofMatrix3x3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix3x3___mul__SWIG_1(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix3x3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Matrix3x3___mul__SWIG_0(L);} } - } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix3x3___mul'\n" - " Possible C/C++ prototypes are:\n" " ofMatrix3x3::operator *(float)\n" - " ofMatrix3x3::operator *(ofMatrix3x3 const &)\n"); lua_error(L);return 0; } -static int _wrap_Matrix3x3___div(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; float arg2 ; - ofMatrix3x3 result; SWIG_check_num_args("ofMatrix3x3::operator /",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::operator /",1,"ofMatrix3x3 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix3x3::operator /",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3___div",1,SWIGTYPE_p_ofMatrix3x3); } arg2 = (float)lua_tonumber(L, 2); - result = (arg1)->operator /(arg2); { ofMatrix3x3 * resultptr = new ofMatrix3x3((const ofMatrix3x3 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix3x3,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix3x3___tostring(lua_State* L) { int SWIG_arg = 0; ofMatrix3x3 *arg1 = (ofMatrix3x3 *) 0 ; - char *result = 0 ; SWIG_check_num_args("ofMatrix3x3::__str__",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix3x3::__str__",1,"ofMatrix3x3 *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Matrix3x3___tostring",1,SWIGTYPE_p_ofMatrix3x3); } result = (char *)ofMatrix3x3___str__(arg1); - lua_pushstring(L,(const char *)result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_Matrix3x3(void *obj) { -ofMatrix3x3 *arg1 = (ofMatrix3x3 *) obj; -delete arg1; -} -static int _proxy__wrap_new_Matrix3x3(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_Matrix3x3); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_Matrix3x3_attributes[] = { - { "a", _wrap_Matrix3x3_a_get, _wrap_Matrix3x3_a_set }, - { "b", _wrap_Matrix3x3_b_get, _wrap_Matrix3x3_b_set }, - { "c", _wrap_Matrix3x3_c_get, _wrap_Matrix3x3_c_set }, - { "d", _wrap_Matrix3x3_d_get, _wrap_Matrix3x3_d_set }, - { "e", _wrap_Matrix3x3_e_get, _wrap_Matrix3x3_e_set }, - { "f", _wrap_Matrix3x3_f_get, _wrap_Matrix3x3_f_set }, - { "g", _wrap_Matrix3x3_g_get, _wrap_Matrix3x3_g_set }, - { "h", _wrap_Matrix3x3_h_get, _wrap_Matrix3x3_h_set }, - { "i", _wrap_Matrix3x3_i_get, _wrap_Matrix3x3_i_set }, - {0,0,0} -}; -static swig_lua_method swig_Matrix3x3_methods[]= { - { "set", _wrap_Matrix3x3_set}, - { "transpose", _wrap_Matrix3x3_transpose}, - { "determinant", _wrap_Matrix3x3_determinant}, - { "inverse", _wrap_Matrix3x3_inverse}, - { "invert", _wrap_Matrix3x3_invert}, - { "entrywiseTimes", _wrap_Matrix3x3_entrywiseTimes}, - { "__add", _wrap_Matrix3x3___add}, - { "__sub", _wrap_Matrix3x3___sub}, - { "__mul", _wrap_Matrix3x3___mul}, - { "__div", _wrap_Matrix3x3___div}, - { "__tostring", _wrap_Matrix3x3___tostring}, - {0,0} -}; -static swig_lua_method swig_Matrix3x3_meta[] = { - { "__add", _wrap_Matrix3x3___add}, - { "__sub", _wrap_Matrix3x3___sub}, - { "__mul", _wrap_Matrix3x3___mul}, - { "__div", _wrap_Matrix3x3___div}, - { "__tostring", _wrap_Matrix3x3___tostring}, - {0,0} -}; - -static swig_lua_attribute swig_Matrix3x3_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_Matrix3x3_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_Matrix3x3_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_Matrix3x3_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_Matrix3x3_Sf_SwigStatic = { - "Matrix3x3", - swig_Matrix3x3_Sf_SwigStatic_methods, - swig_Matrix3x3_Sf_SwigStatic_attributes, - swig_Matrix3x3_Sf_SwigStatic_constants, - swig_Matrix3x3_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_Matrix3x3_bases[] = {0}; -static const char *swig_Matrix3x3_base_names[] = {0}; -static swig_lua_class _wrap_class_Matrix3x3 = { "Matrix3x3", "Matrix3x3", &SWIGTYPE_p_ofMatrix3x3,_proxy__wrap_new_Matrix3x3, swig_delete_Matrix3x3, swig_Matrix3x3_methods, swig_Matrix3x3_attributes, &swig_Matrix3x3_Sf_SwigStatic, swig_Matrix3x3_meta, swig_Matrix3x3_bases, swig_Matrix3x3_base_names }; - -static int _wrap_Matrix4x4__mat_set(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; ofVec4f *arg2 ; - SWIG_check_num_args("ofMatrix4x4::_mat",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::_mat",1,"ofMatrix4x4 *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofMatrix4x4::_mat",2,"ofVec4f [4]"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4__mat_set",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec4f,0))){ - SWIG_fail_ptr("Matrix4x4__mat_set",2,SWIGTYPE_p_ofVec4f); } { size_t ii; ofVec4f *b = (ofVec4f *) arg1->_mat; - for (ii = 0; ii < (size_t)4; ii++) b[ii] = *((ofVec4f *) arg2 + ii); } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4__mat_get(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofVec4f *result = 0 ; SWIG_check_num_args("ofMatrix4x4::_mat",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::_mat",1,"ofMatrix4x4 *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4__mat_get",1,SWIGTYPE_p_ofMatrix4x4); } result = (ofVec4f *)(ofVec4f *) ((arg1)->_mat); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec4f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Matrix4x4__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *result = 0 ; - SWIG_check_num_args("ofMatrix4x4::ofMatrix4x4",0,0) result = (ofMatrix4x4 *)new ofMatrix4x4(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Matrix4x4__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = 0 ; ofMatrix4x4 *result = 0 ; - SWIG_check_num_args("ofMatrix4x4::ofMatrix4x4",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofMatrix4x4::ofMatrix4x4",1,"ofMatrix4x4 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("new_Matrix4x4",1,SWIGTYPE_p_ofMatrix4x4); } - result = (ofMatrix4x4 *)new ofMatrix4x4((ofMatrix4x4 const &)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Matrix4x4__SWIG_2(lua_State* L) { int SWIG_arg = 0; float *arg1 = (float *) (float *)0 ; - ofMatrix4x4 *result = 0 ; SWIG_check_num_args("ofMatrix4x4::ofMatrix4x4",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::ofMatrix4x4",1,"float const *const"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_float,0))){ SWIG_fail_ptr("new_Matrix4x4",1,SWIGTYPE_p_float); } - result = (ofMatrix4x4 *)new ofMatrix4x4((float const *)arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Matrix4x4__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = 0 ; ofMatrix4x4 *result = 0 ; - SWIG_check_num_args("ofMatrix4x4::ofMatrix4x4",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofMatrix4x4::ofMatrix4x4",1,"ofQuaternion const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("new_Matrix4x4",1,SWIGTYPE_p_ofQuaternion); } - result = (ofMatrix4x4 *)new ofMatrix4x4((ofQuaternion const &)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Matrix4x4__SWIG_4(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - float arg5 ; float arg6 ; float arg7 ; float arg8 ; float arg9 ; float arg10 ; float arg11 ; float arg12 ; float arg13 ; - float arg14 ; float arg15 ; float arg16 ; ofMatrix4x4 *result = 0 ; SWIG_check_num_args("ofMatrix4x4::ofMatrix4x4",16,16) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMatrix4x4::ofMatrix4x4",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::ofMatrix4x4",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix4x4::ofMatrix4x4",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix4x4::ofMatrix4x4",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMatrix4x4::ofMatrix4x4",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofMatrix4x4::ofMatrix4x4",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofMatrix4x4::ofMatrix4x4",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofMatrix4x4::ofMatrix4x4",8,"float"); - if(!lua_isnumber(L,9)) SWIG_fail_arg("ofMatrix4x4::ofMatrix4x4",9,"float"); - if(!lua_isnumber(L,10)) SWIG_fail_arg("ofMatrix4x4::ofMatrix4x4",10,"float"); - if(!lua_isnumber(L,11)) SWIG_fail_arg("ofMatrix4x4::ofMatrix4x4",11,"float"); - if(!lua_isnumber(L,12)) SWIG_fail_arg("ofMatrix4x4::ofMatrix4x4",12,"float"); - if(!lua_isnumber(L,13)) SWIG_fail_arg("ofMatrix4x4::ofMatrix4x4",13,"float"); - if(!lua_isnumber(L,14)) SWIG_fail_arg("ofMatrix4x4::ofMatrix4x4",14,"float"); - if(!lua_isnumber(L,15)) SWIG_fail_arg("ofMatrix4x4::ofMatrix4x4",15,"float"); - if(!lua_isnumber(L,16)) SWIG_fail_arg("ofMatrix4x4::ofMatrix4x4",16,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); - arg8 = (float)lua_tonumber(L, 8); arg9 = (float)lua_tonumber(L, 9); arg10 = (float)lua_tonumber(L, 10); - arg11 = (float)lua_tonumber(L, 11); arg12 = (float)lua_tonumber(L, 12); arg13 = (float)lua_tonumber(L, 13); - arg14 = (float)lua_tonumber(L, 14); arg15 = (float)lua_tonumber(L, 15); arg16 = (float)lua_tonumber(L, 16); - result = (ofMatrix4x4 *)new ofMatrix4x4(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Matrix4x4(lua_State* L) { int argc; int argv[17]={ 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17} ; - argc = lua_gettop(L); if (argc == 0) { return _wrap_new_Matrix4x4__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_new_Matrix4x4__SWIG_1(L);} } if (argc == 1) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_new_Matrix4x4__SWIG_2(L);} } if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_new_Matrix4x4__SWIG_3(L);} } if (argc == 16) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { { _v = lua_isnumber(L,argv[8]); } if (_v) { { - _v = lua_isnumber(L,argv[9]); } if (_v) { { _v = lua_isnumber(L,argv[10]); } if (_v) { { - _v = lua_isnumber(L,argv[11]); } if (_v) { { _v = lua_isnumber(L,argv[12]); } if (_v) { { - _v = lua_isnumber(L,argv[13]); } if (_v) { { _v = lua_isnumber(L,argv[14]); } if (_v) { { - _v = lua_isnumber(L,argv[15]); } if (_v) { return _wrap_new_Matrix4x4__SWIG_4(L);} } } } - } } } } } } } } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_Matrix4x4'\n" " Possible C/C++ prototypes are:\n" - " ofMatrix4x4::ofMatrix4x4()\n" " ofMatrix4x4::ofMatrix4x4(ofMatrix4x4 const &)\n" - " ofMatrix4x4::ofMatrix4x4(float const *const)\n" " ofMatrix4x4::ofMatrix4x4(ofQuaternion const &)\n" - " ofMatrix4x4::ofMatrix4x4(float,float,float,float,float,float,float,float,float,float,float,float,float,float,float,float)\n"); - lua_error(L);return 0; } -static int _wrap_Matrix4x4_makeIdentityMatrix(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - SWIG_check_num_args("ofMatrix4x4::makeIdentityMatrix",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::makeIdentityMatrix",1,"ofMatrix4x4 *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_makeIdentityMatrix",1,SWIGTYPE_p_ofMatrix4x4); } (arg1)->makeIdentityMatrix(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_makeScaleMatrix__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofVec3f *arg2 = 0 ; SWIG_check_num_args("ofMatrix4x4::makeScaleMatrix",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::makeScaleMatrix",1,"ofMatrix4x4 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::makeScaleMatrix",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_makeScaleMatrix",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_makeScaleMatrix",2,SWIGTYPE_p_ofVec3f); } (arg1)->makeScaleMatrix((ofVec3f const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_makeScaleMatrix__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - float arg2 ; float arg3 ; float arg4 ; SWIG_check_num_args("ofMatrix4x4::makeScaleMatrix",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::makeScaleMatrix",1,"ofMatrix4x4 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::makeScaleMatrix",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix4x4::makeScaleMatrix",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix4x4::makeScaleMatrix",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_makeScaleMatrix",1,SWIGTYPE_p_ofMatrix4x4); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); (arg1)->makeScaleMatrix(arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_makeScaleMatrix(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_makeScaleMatrix__SWIG_0(L);} } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Matrix4x4_makeScaleMatrix__SWIG_1(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4_makeScaleMatrix'\n" - " Possible C/C++ prototypes are:\n" " ofMatrix4x4::makeScaleMatrix(ofVec3f const &)\n" - " ofMatrix4x4::makeScaleMatrix(float,float,float)\n"); lua_error(L);return 0; } -static int _wrap_Matrix4x4_makeTranslationMatrix__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; ofVec3f *arg2 = 0 ; SWIG_check_num_args("ofMatrix4x4::makeTranslationMatrix",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::makeTranslationMatrix",1,"ofMatrix4x4 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::makeTranslationMatrix",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_makeTranslationMatrix",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_makeTranslationMatrix",2,SWIGTYPE_p_ofVec3f); } - (arg1)->makeTranslationMatrix((ofVec3f const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_makeTranslationMatrix__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; float arg2 ; float arg3 ; float arg4 ; - SWIG_check_num_args("ofMatrix4x4::makeTranslationMatrix",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::makeTranslationMatrix",1,"ofMatrix4x4 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::makeTranslationMatrix",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix4x4::makeTranslationMatrix",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix4x4::makeTranslationMatrix",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_makeTranslationMatrix",1,SWIGTYPE_p_ofMatrix4x4); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); (arg1)->makeTranslationMatrix(arg2,arg3,arg4); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_makeTranslationMatrix(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_makeTranslationMatrix__SWIG_0(L);} } } if (argc == 4) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Matrix4x4_makeTranslationMatrix__SWIG_1(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4_makeTranslationMatrix'\n" - " Possible C/C++ prototypes are:\n" " ofMatrix4x4::makeTranslationMatrix(ofVec3f const &)\n" - " ofMatrix4x4::makeTranslationMatrix(float,float,float)\n"); lua_error(L);return 0; } -static int _wrap_Matrix4x4_makeRotationMatrix__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofVec3f *arg2 = 0 ; ofVec3f *arg3 = 0 ; SWIG_check_num_args("ofMatrix4x4::makeRotationMatrix",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::makeRotationMatrix",1,"ofMatrix4x4 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::makeRotationMatrix",2,"ofVec3f const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofMatrix4x4::makeRotationMatrix",3,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_makeRotationMatrix",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_makeRotationMatrix",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_makeRotationMatrix",3,SWIGTYPE_p_ofVec3f); } - (arg1)->makeRotationMatrix((ofVec3f const &)*arg2,(ofVec3f const &)*arg3); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_makeRotationMatrix__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - float arg2 ; ofVec3f *arg3 = 0 ; SWIG_check_num_args("ofMatrix4x4::makeRotationMatrix",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::makeRotationMatrix",1,"ofMatrix4x4 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::makeRotationMatrix",2,"float"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofMatrix4x4::makeRotationMatrix",3,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_makeRotationMatrix",1,SWIGTYPE_p_ofMatrix4x4); } arg2 = (float)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_makeRotationMatrix",3,SWIGTYPE_p_ofVec3f); } - (arg1)->makeRotationMatrix(arg2,(ofVec3f const &)*arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Matrix4x4_makeRotationMatrix__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - float arg2 ; float arg3 ; float arg4 ; float arg5 ; SWIG_check_num_args("ofMatrix4x4::makeRotationMatrix",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::makeRotationMatrix",1,"ofMatrix4x4 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::makeRotationMatrix",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix4x4::makeRotationMatrix",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix4x4::makeRotationMatrix",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMatrix4x4::makeRotationMatrix",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_makeRotationMatrix",1,SWIGTYPE_p_ofMatrix4x4); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - (arg1)->makeRotationMatrix(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_makeRotationMatrix__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofQuaternion *arg2 = 0 ; SWIG_check_num_args("ofMatrix4x4::makeRotationMatrix",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::makeRotationMatrix",1,"ofMatrix4x4 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::makeRotationMatrix",2,"ofQuaternion const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_makeRotationMatrix",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Matrix4x4_makeRotationMatrix",2,SWIGTYPE_p_ofQuaternion); } - (arg1)->makeRotationMatrix((ofQuaternion const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Matrix4x4_makeRotationMatrix__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - float arg2 ; ofVec3f *arg3 = 0 ; float arg4 ; ofVec3f *arg5 = 0 ; float arg6 ; ofVec3f *arg7 = 0 ; - SWIG_check_num_args("ofMatrix4x4::makeRotationMatrix",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::makeRotationMatrix",1,"ofMatrix4x4 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::makeRotationMatrix",2,"float"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofMatrix4x4::makeRotationMatrix",3,"ofVec3f const &"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix4x4::makeRotationMatrix",4,"float"); - if(!lua_isuserdata(L,5)) SWIG_fail_arg("ofMatrix4x4::makeRotationMatrix",5,"ofVec3f const &"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofMatrix4x4::makeRotationMatrix",6,"float"); - if(!lua_isuserdata(L,7)) SWIG_fail_arg("ofMatrix4x4::makeRotationMatrix",7,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_makeRotationMatrix",1,SWIGTYPE_p_ofMatrix4x4); } arg2 = (float)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_makeRotationMatrix",3,SWIGTYPE_p_ofVec3f); } arg4 = (float)lua_tonumber(L, 4); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_makeRotationMatrix",5,SWIGTYPE_p_ofVec3f); } arg6 = (float)lua_tonumber(L, 6); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,7,(void**)&arg7,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_makeRotationMatrix",7,SWIGTYPE_p_ofVec3f); } - (arg1)->makeRotationMatrix(arg2,(ofVec3f const &)*arg3,arg4,(ofVec3f const &)*arg5,arg6,(ofVec3f const &)*arg7); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_makeRotationMatrix(lua_State* L) { int argc; int argv[8]={ 1,2,3,4,5,6,7,8} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_makeRotationMatrix__SWIG_3(L);} } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_makeRotationMatrix__SWIG_0(L);} } } } if (argc == 3) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_makeRotationMatrix__SWIG_1(L);} } } } if (argc == 5) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Matrix4x4_makeRotationMatrix__SWIG_2(L);} } } } } } if (argc == 7) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[4])==0 || SWIG_ConvertPtr(L,argv[4], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[6])==0 || SWIG_ConvertPtr(L,argv[6], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_makeRotationMatrix__SWIG_4(L);} } } } } - } } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4_makeRotationMatrix'\n" - " Possible C/C++ prototypes are:\n" " ofMatrix4x4::makeRotationMatrix(ofVec3f const &,ofVec3f const &)\n" - " ofMatrix4x4::makeRotationMatrix(float,ofVec3f const &)\n" - " ofMatrix4x4::makeRotationMatrix(float,float,float,float)\n" " ofMatrix4x4::makeRotationMatrix(ofQuaternion const &)\n" - " ofMatrix4x4::makeRotationMatrix(float,ofVec3f const &,float,ofVec3f const &,float,ofVec3f const &)\n"); - lua_error(L);return 0; } -static int _wrap_Matrix4x4_makeInvertOf(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofMatrix4x4 *arg2 = 0 ; bool result; SWIG_check_num_args("ofMatrix4x4::makeInvertOf",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::makeInvertOf",1,"ofMatrix4x4 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::makeInvertOf",2,"ofMatrix4x4 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_makeInvertOf",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_makeInvertOf",2,SWIGTYPE_p_ofMatrix4x4); } - result = (bool)(arg1)->makeInvertOf((ofMatrix4x4 const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_makeOrthoNormalOf(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofMatrix4x4 *arg2 = 0 ; SWIG_check_num_args("ofMatrix4x4::makeOrthoNormalOf",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::makeOrthoNormalOf",1,"ofMatrix4x4 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::makeOrthoNormalOf",2,"ofMatrix4x4 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_makeOrthoNormalOf",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_makeOrthoNormalOf",2,SWIGTYPE_p_ofMatrix4x4); } - (arg1)->makeOrthoNormalOf((ofMatrix4x4 const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_makeFromMultiplicationOf(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofMatrix4x4 *arg2 = 0 ; ofMatrix4x4 *arg3 = 0 ; SWIG_check_num_args("ofMatrix4x4::makeFromMultiplicationOf",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::makeFromMultiplicationOf",1,"ofMatrix4x4 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::makeFromMultiplicationOf",2,"ofMatrix4x4 const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofMatrix4x4::makeFromMultiplicationOf",3,"ofMatrix4x4 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_makeFromMultiplicationOf",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_makeFromMultiplicationOf",2,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_makeFromMultiplicationOf",3,SWIGTYPE_p_ofMatrix4x4); } - (arg1)->makeFromMultiplicationOf((ofMatrix4x4 const &)*arg2,(ofMatrix4x4 const &)*arg3); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_makeOrthoMatrix(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - double arg2 ; double arg3 ; double arg4 ; double arg5 ; double arg6 ; double arg7 ; - SWIG_check_num_args("ofMatrix4x4::makeOrthoMatrix",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::makeOrthoMatrix",1,"ofMatrix4x4 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::makeOrthoMatrix",2,"double"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix4x4::makeOrthoMatrix",3,"double"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix4x4::makeOrthoMatrix",4,"double"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMatrix4x4::makeOrthoMatrix",5,"double"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofMatrix4x4::makeOrthoMatrix",6,"double"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofMatrix4x4::makeOrthoMatrix",7,"double"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_makeOrthoMatrix",1,SWIGTYPE_p_ofMatrix4x4); } arg2 = (double)lua_tonumber(L, 2); - arg3 = (double)lua_tonumber(L, 3); arg4 = (double)lua_tonumber(L, 4); arg5 = (double)lua_tonumber(L, 5); - arg6 = (double)lua_tonumber(L, 6); arg7 = (double)lua_tonumber(L, 7); (arg1)->makeOrthoMatrix(arg2,arg3,arg4,arg5,arg6,arg7); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_makeOrtho2DMatrix(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - double arg2 ; double arg3 ; double arg4 ; double arg5 ; SWIG_check_num_args("ofMatrix4x4::makeOrtho2DMatrix",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::makeOrtho2DMatrix",1,"ofMatrix4x4 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::makeOrtho2DMatrix",2,"double"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix4x4::makeOrtho2DMatrix",3,"double"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix4x4::makeOrtho2DMatrix",4,"double"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMatrix4x4::makeOrtho2DMatrix",5,"double"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_makeOrtho2DMatrix",1,SWIGTYPE_p_ofMatrix4x4); } arg2 = (double)lua_tonumber(L, 2); - arg3 = (double)lua_tonumber(L, 3); arg4 = (double)lua_tonumber(L, 4); arg5 = (double)lua_tonumber(L, 5); - (arg1)->makeOrtho2DMatrix(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_makeFrustumMatrix(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - double arg2 ; double arg3 ; double arg4 ; double arg5 ; double arg6 ; double arg7 ; - SWIG_check_num_args("ofMatrix4x4::makeFrustumMatrix",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::makeFrustumMatrix",1,"ofMatrix4x4 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::makeFrustumMatrix",2,"double"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix4x4::makeFrustumMatrix",3,"double"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix4x4::makeFrustumMatrix",4,"double"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMatrix4x4::makeFrustumMatrix",5,"double"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofMatrix4x4::makeFrustumMatrix",6,"double"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofMatrix4x4::makeFrustumMatrix",7,"double"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_makeFrustumMatrix",1,SWIGTYPE_p_ofMatrix4x4); } arg2 = (double)lua_tonumber(L, 2); - arg3 = (double)lua_tonumber(L, 3); arg4 = (double)lua_tonumber(L, 4); arg5 = (double)lua_tonumber(L, 5); - arg6 = (double)lua_tonumber(L, 6); arg7 = (double)lua_tonumber(L, 7); - (arg1)->makeFrustumMatrix(arg2,arg3,arg4,arg5,arg6,arg7); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Matrix4x4_makePerspectiveMatrix(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - double arg2 ; double arg3 ; double arg4 ; double arg5 ; SWIG_check_num_args("ofMatrix4x4::makePerspectiveMatrix",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::makePerspectiveMatrix",1,"ofMatrix4x4 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::makePerspectiveMatrix",2,"double"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix4x4::makePerspectiveMatrix",3,"double"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix4x4::makePerspectiveMatrix",4,"double"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMatrix4x4::makePerspectiveMatrix",5,"double"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_makePerspectiveMatrix",1,SWIGTYPE_p_ofMatrix4x4); } arg2 = (double)lua_tonumber(L, 2); - arg3 = (double)lua_tonumber(L, 3); arg4 = (double)lua_tonumber(L, 4); arg5 = (double)lua_tonumber(L, 5); - (arg1)->makePerspectiveMatrix(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_makeLookAtMatrix(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofVec3f *arg2 = 0 ; ofVec3f *arg3 = 0 ; ofVec3f *arg4 = 0 ; SWIG_check_num_args("ofMatrix4x4::makeLookAtMatrix",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::makeLookAtMatrix",1,"ofMatrix4x4 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::makeLookAtMatrix",2,"ofVec3f const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofMatrix4x4::makeLookAtMatrix",3,"ofVec3f const &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofMatrix4x4::makeLookAtMatrix",4,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_makeLookAtMatrix",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_makeLookAtMatrix",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_makeLookAtMatrix",3,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_makeLookAtMatrix",4,SWIGTYPE_p_ofVec3f); } - (arg1)->makeLookAtMatrix((ofVec3f const &)*arg2,(ofVec3f const &)*arg3,(ofVec3f const &)*arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_makeLookAtViewMatrix(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofVec3f *arg2 = 0 ; ofVec3f *arg3 = 0 ; ofVec3f *arg4 = 0 ; SWIG_check_num_args("ofMatrix4x4::makeLookAtViewMatrix",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::makeLookAtViewMatrix",1,"ofMatrix4x4 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::makeLookAtViewMatrix",2,"ofVec3f const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofMatrix4x4::makeLookAtViewMatrix",3,"ofVec3f const &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofMatrix4x4::makeLookAtViewMatrix",4,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_makeLookAtViewMatrix",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_makeLookAtViewMatrix",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_makeLookAtViewMatrix",3,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_makeLookAtViewMatrix",4,SWIGTYPE_p_ofVec3f); } - (arg1)->makeLookAtViewMatrix((ofVec3f const &)*arg2,(ofVec3f const &)*arg3,(ofVec3f const &)*arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_newIdentityMatrix(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 result; - SWIG_check_num_args("ofMatrix4x4::newIdentityMatrix",0,0) result = ofMatrix4x4::newIdentityMatrix(); { - ofMatrix4x4 * resultptr = new ofMatrix4x4((const ofMatrix4x4 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_newScaleMatrix__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = 0 ; ofMatrix4x4 result; - SWIG_check_num_args("ofMatrix4x4::newScaleMatrix",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofMatrix4x4::newScaleMatrix",1,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_newScaleMatrix",1,SWIGTYPE_p_ofVec3f); } - result = ofMatrix4x4::newScaleMatrix((ofVec3f const &)*arg1); { - ofMatrix4x4 * resultptr = new ofMatrix4x4((const ofMatrix4x4 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_newScaleMatrix__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; - ofMatrix4x4 result; SWIG_check_num_args("ofMatrix4x4::newScaleMatrix",3,3) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMatrix4x4::newScaleMatrix",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::newScaleMatrix",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix4x4::newScaleMatrix",3,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); result = ofMatrix4x4::newScaleMatrix(arg1,arg2,arg3); { - ofMatrix4x4 * resultptr = new ofMatrix4x4((const ofMatrix4x4 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_newScaleMatrix(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); - if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_Matrix4x4_newScaleMatrix__SWIG_0(L);} } if (argc == 3) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_Matrix4x4_newScaleMatrix__SWIG_1(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4_newScaleMatrix'\n" - " Possible C/C++ prototypes are:\n" " ofMatrix4x4::newScaleMatrix(ofVec3f const &)\n" - " ofMatrix4x4::newScaleMatrix(float,float,float)\n"); lua_error(L);return 0; } -static int _wrap_Matrix4x4_newTranslationMatrix__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = 0 ; - ofMatrix4x4 result; SWIG_check_num_args("ofMatrix4x4::newTranslationMatrix",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofMatrix4x4::newTranslationMatrix",1,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_newTranslationMatrix",1,SWIGTYPE_p_ofVec3f); } - result = ofMatrix4x4::newTranslationMatrix((ofVec3f const &)*arg1); { - ofMatrix4x4 * resultptr = new ofMatrix4x4((const ofMatrix4x4 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_newTranslationMatrix__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; - ofMatrix4x4 result; SWIG_check_num_args("ofMatrix4x4::newTranslationMatrix",3,3) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMatrix4x4::newTranslationMatrix",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::newTranslationMatrix",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix4x4::newTranslationMatrix",3,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - result = ofMatrix4x4::newTranslationMatrix(arg1,arg2,arg3); { - ofMatrix4x4 * resultptr = new ofMatrix4x4((const ofMatrix4x4 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_newTranslationMatrix(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); - if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_Matrix4x4_newTranslationMatrix__SWIG_0(L);} } if (argc == 3) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_Matrix4x4_newTranslationMatrix__SWIG_1(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4_newTranslationMatrix'\n" - " Possible C/C++ prototypes are:\n" " ofMatrix4x4::newTranslationMatrix(ofVec3f const &)\n" - " ofMatrix4x4::newTranslationMatrix(float,float,float)\n"); lua_error(L);return 0; } -static int _wrap_Matrix4x4_newRotationMatrix__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = 0 ; ofVec3f *arg2 = 0 ; - ofMatrix4x4 result; SWIG_check_num_args("ofMatrix4x4::newRotationMatrix",2,2) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofMatrix4x4::newRotationMatrix",1,"ofVec3f const &"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::newRotationMatrix",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_newRotationMatrix",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_newRotationMatrix",2,SWIGTYPE_p_ofVec3f); } - result = ofMatrix4x4::newRotationMatrix((ofVec3f const &)*arg1,(ofVec3f const &)*arg2); { - ofMatrix4x4 * resultptr = new ofMatrix4x4((const ofMatrix4x4 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_newRotationMatrix__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; - float arg4 ; ofMatrix4x4 result; SWIG_check_num_args("ofMatrix4x4::newRotationMatrix",4,4) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMatrix4x4::newRotationMatrix",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::newRotationMatrix",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix4x4::newRotationMatrix",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix4x4::newRotationMatrix",4,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - result = ofMatrix4x4::newRotationMatrix(arg1,arg2,arg3,arg4); { - ofMatrix4x4 * resultptr = new ofMatrix4x4((const ofMatrix4x4 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_newRotationMatrix__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; ofVec3f *arg2 = 0 ; - ofMatrix4x4 result; SWIG_check_num_args("ofMatrix4x4::newRotationMatrix",2,2) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMatrix4x4::newRotationMatrix",1,"float"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::newRotationMatrix",2,"ofVec3f const &"); - arg1 = (float)lua_tonumber(L, 1); if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_newRotationMatrix",2,SWIGTYPE_p_ofVec3f); } - result = ofMatrix4x4::newRotationMatrix(arg1,(ofVec3f const &)*arg2); { - ofMatrix4x4 * resultptr = new ofMatrix4x4((const ofMatrix4x4 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_newRotationMatrix__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; ofVec3f *arg2 = 0 ; - float arg3 ; ofVec3f *arg4 = 0 ; float arg5 ; ofVec3f *arg6 = 0 ; ofMatrix4x4 result; - SWIG_check_num_args("ofMatrix4x4::newRotationMatrix",6,6) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMatrix4x4::newRotationMatrix",1,"float"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::newRotationMatrix",2,"ofVec3f const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix4x4::newRotationMatrix",3,"float"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofMatrix4x4::newRotationMatrix",4,"ofVec3f const &"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMatrix4x4::newRotationMatrix",5,"float"); - if(!lua_isuserdata(L,6)) SWIG_fail_arg("ofMatrix4x4::newRotationMatrix",6,"ofVec3f const &"); - arg1 = (float)lua_tonumber(L, 1); if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_newRotationMatrix",2,SWIGTYPE_p_ofVec3f); } arg3 = (float)lua_tonumber(L, 3); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_newRotationMatrix",4,SWIGTYPE_p_ofVec3f); } arg5 = (float)lua_tonumber(L, 5); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,6,(void**)&arg6,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_newRotationMatrix",6,SWIGTYPE_p_ofVec3f); } - result = ofMatrix4x4::newRotationMatrix(arg1,(ofVec3f const &)*arg2,arg3,(ofVec3f const &)*arg4,arg5,(ofVec3f const &)*arg6); - { ofMatrix4x4 * resultptr = new ofMatrix4x4((const ofMatrix4x4 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_newRotationMatrix__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = 0 ; - ofMatrix4x4 result; SWIG_check_num_args("ofMatrix4x4::newRotationMatrix",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofMatrix4x4::newRotationMatrix",1,"ofQuaternion const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Matrix4x4_newRotationMatrix",1,SWIGTYPE_p_ofQuaternion); } - result = ofMatrix4x4::newRotationMatrix((ofQuaternion const &)*arg1); { - ofMatrix4x4 * resultptr = new ofMatrix4x4((const ofMatrix4x4 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_newRotationMatrix(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); - if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_newRotationMatrix__SWIG_4(L);} } if (argc == 2) { int _v; { - void *ptr; if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_newRotationMatrix__SWIG_0(L);} } } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_newRotationMatrix__SWIG_2(L);} } } if (argc == 4) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Matrix4x4_newRotationMatrix__SWIG_1(L);} } } } } - if (argc == 6) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[5])==0 || SWIG_ConvertPtr(L,argv[5], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_newRotationMatrix__SWIG_3(L);} } } } } } - } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4_newRotationMatrix'\n" - " Possible C/C++ prototypes are:\n" " ofMatrix4x4::newRotationMatrix(ofVec3f const &,ofVec3f const &)\n" - " ofMatrix4x4::newRotationMatrix(float,float,float,float)\n" " ofMatrix4x4::newRotationMatrix(float,ofVec3f const &)\n" - " ofMatrix4x4::newRotationMatrix(float,ofVec3f const &,float,ofVec3f const &,float,ofVec3f const &)\n" - " ofMatrix4x4::newRotationMatrix(ofQuaternion const &)\n"); lua_error(L);return 0; } -static int _wrap_Matrix4x4_newOrthoMatrix(lua_State* L) { int SWIG_arg = 0; double arg1 ; double arg2 ; double arg3 ; - double arg4 ; double arg5 ; double arg6 ; ofMatrix4x4 result; SWIG_check_num_args("ofMatrix4x4::newOrthoMatrix",6,6) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMatrix4x4::newOrthoMatrix",1,"double"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::newOrthoMatrix",2,"double"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix4x4::newOrthoMatrix",3,"double"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix4x4::newOrthoMatrix",4,"double"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMatrix4x4::newOrthoMatrix",5,"double"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofMatrix4x4::newOrthoMatrix",6,"double"); arg1 = (double)lua_tonumber(L, 1); - arg2 = (double)lua_tonumber(L, 2); arg3 = (double)lua_tonumber(L, 3); arg4 = (double)lua_tonumber(L, 4); - arg5 = (double)lua_tonumber(L, 5); arg6 = (double)lua_tonumber(L, 6); - result = ofMatrix4x4::newOrthoMatrix(arg1,arg2,arg3,arg4,arg5,arg6); { - ofMatrix4x4 * resultptr = new ofMatrix4x4((const ofMatrix4x4 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_newOrtho2DMatrix(lua_State* L) { int SWIG_arg = 0; double arg1 ; double arg2 ; double arg3 ; - double arg4 ; ofMatrix4x4 result; SWIG_check_num_args("ofMatrix4x4::newOrtho2DMatrix",4,4) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMatrix4x4::newOrtho2DMatrix",1,"double"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::newOrtho2DMatrix",2,"double"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix4x4::newOrtho2DMatrix",3,"double"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix4x4::newOrtho2DMatrix",4,"double"); arg1 = (double)lua_tonumber(L, 1); - arg2 = (double)lua_tonumber(L, 2); arg3 = (double)lua_tonumber(L, 3); arg4 = (double)lua_tonumber(L, 4); - result = ofMatrix4x4::newOrtho2DMatrix(arg1,arg2,arg3,arg4); { - ofMatrix4x4 * resultptr = new ofMatrix4x4((const ofMatrix4x4 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_newFrustumMatrix(lua_State* L) { int SWIG_arg = 0; double arg1 ; double arg2 ; double arg3 ; - double arg4 ; double arg5 ; double arg6 ; ofMatrix4x4 result; SWIG_check_num_args("ofMatrix4x4::newFrustumMatrix",6,6) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMatrix4x4::newFrustumMatrix",1,"double"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::newFrustumMatrix",2,"double"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix4x4::newFrustumMatrix",3,"double"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix4x4::newFrustumMatrix",4,"double"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMatrix4x4::newFrustumMatrix",5,"double"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofMatrix4x4::newFrustumMatrix",6,"double"); arg1 = (double)lua_tonumber(L, 1); - arg2 = (double)lua_tonumber(L, 2); arg3 = (double)lua_tonumber(L, 3); arg4 = (double)lua_tonumber(L, 4); - arg5 = (double)lua_tonumber(L, 5); arg6 = (double)lua_tonumber(L, 6); - result = ofMatrix4x4::newFrustumMatrix(arg1,arg2,arg3,arg4,arg5,arg6); { - ofMatrix4x4 * resultptr = new ofMatrix4x4((const ofMatrix4x4 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_newPerspectiveMatrix(lua_State* L) { int SWIG_arg = 0; double arg1 ; double arg2 ; double arg3 ; - double arg4 ; ofMatrix4x4 result; SWIG_check_num_args("ofMatrix4x4::newPerspectiveMatrix",4,4) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofMatrix4x4::newPerspectiveMatrix",1,"double"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::newPerspectiveMatrix",2,"double"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix4x4::newPerspectiveMatrix",3,"double"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix4x4::newPerspectiveMatrix",4,"double"); arg1 = (double)lua_tonumber(L, 1); - arg2 = (double)lua_tonumber(L, 2); arg3 = (double)lua_tonumber(L, 3); arg4 = (double)lua_tonumber(L, 4); - result = ofMatrix4x4::newPerspectiveMatrix(arg1,arg2,arg3,arg4); { - ofMatrix4x4 * resultptr = new ofMatrix4x4((const ofMatrix4x4 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_newLookAtMatrix(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = 0 ; ofVec3f *arg2 = 0 ; - ofVec3f *arg3 = 0 ; ofMatrix4x4 result; SWIG_check_num_args("ofMatrix4x4::newLookAtMatrix",3,3) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofMatrix4x4::newLookAtMatrix",1,"ofVec3f const &"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::newLookAtMatrix",2,"ofVec3f const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofMatrix4x4::newLookAtMatrix",3,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_newLookAtMatrix",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_newLookAtMatrix",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_newLookAtMatrix",3,SWIGTYPE_p_ofVec3f); } - result = ofMatrix4x4::newLookAtMatrix((ofVec3f const &)*arg1,(ofVec3f const &)*arg2,(ofVec3f const &)*arg3); { - ofMatrix4x4 * resultptr = new ofMatrix4x4((const ofMatrix4x4 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4___call(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; std::size_t arg2 ; - std::size_t arg3 ; float *result = 0 ; SWIG_check_num_args("ofMatrix4x4::operator ()",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::operator ()",1,"ofMatrix4x4 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::operator ()",2,"std::size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix4x4::operator ()",3,"std::size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4___call",1,SWIGTYPE_p_ofMatrix4x4); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (std::size_t)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (std::size_t)lua_tonumber(L, 3); - result = (float *) &(arg1)->operator ()(arg2,arg3); SWIG_NewPointerObj(L,result,SWIGTYPE_p_float,0); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_getRowAsVec3f(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - std::size_t arg2 ; ofVec3f result; SWIG_check_num_args("ofMatrix4x4::getRowAsVec3f",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::getRowAsVec3f",1,"ofMatrix4x4 const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::getRowAsVec3f",2,"std::size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_getRowAsVec3f",1,SWIGTYPE_p_ofMatrix4x4); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (std::size_t)lua_tonumber(L, 2); - result = ((ofMatrix4x4 const *)arg1)->getRowAsVec3f(arg2); { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_getRowAsVec4f(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - std::size_t arg2 ; ofVec4f result; SWIG_check_num_args("ofMatrix4x4::getRowAsVec4f",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::getRowAsVec4f",1,"ofMatrix4x4 const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::getRowAsVec4f",2,"std::size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_getRowAsVec4f",1,SWIGTYPE_p_ofMatrix4x4); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (std::size_t)lua_tonumber(L, 2); - result = ((ofMatrix4x4 const *)arg1)->getRowAsVec4f(arg2); { ofVec4f * resultptr = new ofVec4f((const ofVec4f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec4f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_getPtr__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - float *result = 0 ; SWIG_check_num_args("ofMatrix4x4::getPtr",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::getPtr",1,"ofMatrix4x4 *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_getPtr",1,SWIGTYPE_p_ofMatrix4x4); } result = (float *)(arg1)->getPtr(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_float,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Matrix4x4_getPtr__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - float *result = 0 ; SWIG_check_num_args("ofMatrix4x4::getPtr",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::getPtr",1,"ofMatrix4x4 const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_getPtr",1,SWIGTYPE_p_ofMatrix4x4); } result = (float *)((ofMatrix4x4 const *)arg1)->getPtr(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_float,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Matrix4x4_getPtr(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_getPtr__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_getPtr__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4_getPtr'\n" " Possible C/C++ prototypes are:\n" - " ofMatrix4x4::getPtr()\n" " ofMatrix4x4::getPtr() const\n"); lua_error(L);return 0; } -static int _wrap_Matrix4x4_isValid(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; bool result; - SWIG_check_num_args("ofMatrix4x4::isValid",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::isValid",1,"ofMatrix4x4 const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_isValid",1,SWIGTYPE_p_ofMatrix4x4); } result = (bool)((ofMatrix4x4 const *)arg1)->isValid(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_isNaN(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; bool result; - SWIG_check_num_args("ofMatrix4x4::isNaN",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::isNaN",1,"ofMatrix4x4 const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_isNaN",1,SWIGTYPE_p_ofMatrix4x4); } result = (bool)((ofMatrix4x4 const *)arg1)->isNaN(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_isIdentity(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; bool result; - SWIG_check_num_args("ofMatrix4x4::isIdentity",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::isIdentity",1,"ofMatrix4x4 const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_isIdentity",1,SWIGTYPE_p_ofMatrix4x4); } result = (bool)((ofMatrix4x4 const *)arg1)->isIdentity(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_set__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofMatrix4x4 *arg2 = 0 ; SWIG_check_num_args("ofMatrix4x4::set",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::set",1,"ofMatrix4x4 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::set",2,"ofMatrix4x4 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_set",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_set",2,SWIGTYPE_p_ofMatrix4x4); } (arg1)->set((ofMatrix4x4 const &)*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_set__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - float *arg2 = (float *) (float *)0 ; SWIG_check_num_args("ofMatrix4x4::set",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::set",1,"ofMatrix4x4 *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofMatrix4x4::set",2,"float const *const"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_set",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_float,0))){ SWIG_fail_ptr("Matrix4x4_set",2,SWIGTYPE_p_float); } - (arg1)->set((float const *)arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_set__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - double *arg2 = (double *) (double *)0 ; SWIG_check_num_args("ofMatrix4x4::set",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::set",1,"ofMatrix4x4 *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofMatrix4x4::set",2,"double const *const"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_set",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_double,0))){ SWIG_fail_ptr("Matrix4x4_set",2,SWIGTYPE_p_double); } - (arg1)->set((double const *)arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_set__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; float arg2 ; - float arg3 ; float arg4 ; float arg5 ; float arg6 ; float arg7 ; float arg8 ; float arg9 ; float arg10 ; float arg11 ; - float arg12 ; float arg13 ; float arg14 ; float arg15 ; float arg16 ; float arg17 ; - SWIG_check_num_args("ofMatrix4x4::set",17,17) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::set",1,"ofMatrix4x4 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix4x4::set",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix4x4::set",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMatrix4x4::set",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofMatrix4x4::set",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofMatrix4x4::set",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofMatrix4x4::set",8,"float"); - if(!lua_isnumber(L,9)) SWIG_fail_arg("ofMatrix4x4::set",9,"float"); - if(!lua_isnumber(L,10)) SWIG_fail_arg("ofMatrix4x4::set",10,"float"); - if(!lua_isnumber(L,11)) SWIG_fail_arg("ofMatrix4x4::set",11,"float"); - if(!lua_isnumber(L,12)) SWIG_fail_arg("ofMatrix4x4::set",12,"float"); - if(!lua_isnumber(L,13)) SWIG_fail_arg("ofMatrix4x4::set",13,"float"); - if(!lua_isnumber(L,14)) SWIG_fail_arg("ofMatrix4x4::set",14,"float"); - if(!lua_isnumber(L,15)) SWIG_fail_arg("ofMatrix4x4::set",15,"float"); - if(!lua_isnumber(L,16)) SWIG_fail_arg("ofMatrix4x4::set",16,"float"); - if(!lua_isnumber(L,17)) SWIG_fail_arg("ofMatrix4x4::set",17,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_set",1,SWIGTYPE_p_ofMatrix4x4); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (float)lua_tonumber(L, 8); - arg9 = (float)lua_tonumber(L, 9); arg10 = (float)lua_tonumber(L, 10); arg11 = (float)lua_tonumber(L, 11); - arg12 = (float)lua_tonumber(L, 12); arg13 = (float)lua_tonumber(L, 13); arg14 = (float)lua_tonumber(L, 14); - arg15 = (float)lua_tonumber(L, 15); arg16 = (float)lua_tonumber(L, 16); arg17 = (float)lua_tonumber(L, 17); - (arg1)->set(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16,arg17); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_set(lua_State* L) { int argc; int argv[18]={ 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18} ; - argc = lua_gettop(L); if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_set__SWIG_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_Matrix4x4_set__SWIG_1(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_double, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_set__SWIG_2(L);} } } if (argc == 17) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { { _v = lua_isnumber(L,argv[8]); } if (_v) { { - _v = lua_isnumber(L,argv[9]); } if (_v) { { _v = lua_isnumber(L,argv[10]); } if (_v) { { - _v = lua_isnumber(L,argv[11]); } if (_v) { { _v = lua_isnumber(L,argv[12]); } if (_v) { { - _v = lua_isnumber(L,argv[13]); } if (_v) { { _v = lua_isnumber(L,argv[14]); } if (_v) { { - _v = lua_isnumber(L,argv[15]); } if (_v) { { _v = lua_isnumber(L,argv[16]); } if (_v) { - return _wrap_Matrix4x4_set__SWIG_3(L);} } } } } } } } } } } } } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4_set'\n" " Possible C/C++ prototypes are:\n" - " ofMatrix4x4::set(ofMatrix4x4 const &)\n" " ofMatrix4x4::set(float const *const)\n" - " ofMatrix4x4::set(double const *const)\n" - " ofMatrix4x4::set(float,float,float,float,float,float,float,float,float,float,float,float,float,float,float,float)\n"); - lua_error(L);return 0; } -static int _wrap_Matrix4x4_getInverse(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofMatrix4x4 result; SWIG_check_num_args("ofMatrix4x4::getInverse",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::getInverse",1,"ofMatrix4x4 const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_getInverse",1,SWIGTYPE_p_ofMatrix4x4); } result = ((ofMatrix4x4 const *)arg1)->getInverse(); { - ofMatrix4x4 * resultptr = new ofMatrix4x4((const ofMatrix4x4 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_getOrtho(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; double *arg2 = 0 ; - double *arg3 = 0 ; double *arg4 = 0 ; double *arg5 = 0 ; double *arg6 = 0 ; double *arg7 = 0 ; bool result; - SWIG_check_num_args("ofMatrix4x4::getOrtho",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::getOrtho",1,"ofMatrix4x4 const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::getOrtho",2,"double &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofMatrix4x4::getOrtho",3,"double &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofMatrix4x4::getOrtho",4,"double &"); - if(!lua_isuserdata(L,5)) SWIG_fail_arg("ofMatrix4x4::getOrtho",5,"double &"); - if(!lua_isuserdata(L,6)) SWIG_fail_arg("ofMatrix4x4::getOrtho",6,"double &"); - if(!lua_isuserdata(L,7)) SWIG_fail_arg("ofMatrix4x4::getOrtho",7,"double &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_getOrtho",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_double,0))){ - SWIG_fail_ptr("Matrix4x4_getOrtho",2,SWIGTYPE_p_double); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_double,0))){ - SWIG_fail_ptr("Matrix4x4_getOrtho",3,SWIGTYPE_p_double); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_double,0))){ - SWIG_fail_ptr("Matrix4x4_getOrtho",4,SWIGTYPE_p_double); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_double,0))){ - SWIG_fail_ptr("Matrix4x4_getOrtho",5,SWIGTYPE_p_double); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,6,(void**)&arg6,SWIGTYPE_p_double,0))){ - SWIG_fail_ptr("Matrix4x4_getOrtho",6,SWIGTYPE_p_double); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,7,(void**)&arg7,SWIGTYPE_p_double,0))){ - SWIG_fail_ptr("Matrix4x4_getOrtho",7,SWIGTYPE_p_double); } - result = (bool)((ofMatrix4x4 const *)arg1)->getOrtho(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_getFrustum(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - double *arg2 = 0 ; double *arg3 = 0 ; double *arg4 = 0 ; double *arg5 = 0 ; double *arg6 = 0 ; double *arg7 = 0 ; bool result; - SWIG_check_num_args("ofMatrix4x4::getFrustum",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::getFrustum",1,"ofMatrix4x4 const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::getFrustum",2,"double &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofMatrix4x4::getFrustum",3,"double &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofMatrix4x4::getFrustum",4,"double &"); - if(!lua_isuserdata(L,5)) SWIG_fail_arg("ofMatrix4x4::getFrustum",5,"double &"); - if(!lua_isuserdata(L,6)) SWIG_fail_arg("ofMatrix4x4::getFrustum",6,"double &"); - if(!lua_isuserdata(L,7)) SWIG_fail_arg("ofMatrix4x4::getFrustum",7,"double &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_getFrustum",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_double,0))){ - SWIG_fail_ptr("Matrix4x4_getFrustum",2,SWIGTYPE_p_double); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_double,0))){ - SWIG_fail_ptr("Matrix4x4_getFrustum",3,SWIGTYPE_p_double); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_double,0))){ - SWIG_fail_ptr("Matrix4x4_getFrustum",4,SWIGTYPE_p_double); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_double,0))){ - SWIG_fail_ptr("Matrix4x4_getFrustum",5,SWIGTYPE_p_double); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,6,(void**)&arg6,SWIGTYPE_p_double,0))){ - SWIG_fail_ptr("Matrix4x4_getFrustum",6,SWIGTYPE_p_double); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,7,(void**)&arg7,SWIGTYPE_p_double,0))){ - SWIG_fail_ptr("Matrix4x4_getFrustum",7,SWIGTYPE_p_double); } - result = (bool)((ofMatrix4x4 const *)arg1)->getFrustum(*arg2,*arg3,*arg4,*arg5,*arg6,*arg7); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_getPerspective(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - double *arg2 = 0 ; double *arg3 = 0 ; double *arg4 = 0 ; double *arg5 = 0 ; bool result; - SWIG_check_num_args("ofMatrix4x4::getPerspective",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::getPerspective",1,"ofMatrix4x4 const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::getPerspective",2,"double &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofMatrix4x4::getPerspective",3,"double &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofMatrix4x4::getPerspective",4,"double &"); - if(!lua_isuserdata(L,5)) SWIG_fail_arg("ofMatrix4x4::getPerspective",5,"double &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_getPerspective",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_double,0))){ - SWIG_fail_ptr("Matrix4x4_getPerspective",2,SWIGTYPE_p_double); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_double,0))){ - SWIG_fail_ptr("Matrix4x4_getPerspective",3,SWIGTYPE_p_double); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_double,0))){ - SWIG_fail_ptr("Matrix4x4_getPerspective",4,SWIGTYPE_p_double); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_double,0))){ - SWIG_fail_ptr("Matrix4x4_getPerspective",5,SWIGTYPE_p_double); } - result = (bool)((ofMatrix4x4 const *)arg1)->getPerspective(*arg2,*arg3,*arg4,*arg5); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_getLookAt__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofVec3f *arg2 = 0 ; ofVec3f *arg3 = 0 ; ofVec3f *arg4 = 0 ; float arg5 ; SWIG_check_num_args("ofMatrix4x4::getLookAt",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::getLookAt",1,"ofMatrix4x4 const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::getLookAt",2,"ofVec3f &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofMatrix4x4::getLookAt",3,"ofVec3f &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofMatrix4x4::getLookAt",4,"ofVec3f &"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMatrix4x4::getLookAt",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_getLookAt",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_getLookAt",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_getLookAt",3,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_getLookAt",4,SWIGTYPE_p_ofVec3f); } arg5 = (float)lua_tonumber(L, 5); - ((ofMatrix4x4 const *)arg1)->getLookAt(*arg2,*arg3,*arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Matrix4x4_getLookAt__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofVec3f *arg2 = 0 ; ofVec3f *arg3 = 0 ; ofVec3f *arg4 = 0 ; SWIG_check_num_args("ofMatrix4x4::getLookAt",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::getLookAt",1,"ofMatrix4x4 const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::getLookAt",2,"ofVec3f &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofMatrix4x4::getLookAt",3,"ofVec3f &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofMatrix4x4::getLookAt",4,"ofVec3f &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_getLookAt",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_getLookAt",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_getLookAt",3,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_getLookAt",4,SWIGTYPE_p_ofVec3f); } ((ofMatrix4x4 const *)arg1)->getLookAt(*arg2,*arg3,*arg4); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_getLookAt(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); - if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_getLookAt__SWIG_1(L);} } } } } if (argc == 5) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Matrix4x4_getLookAt__SWIG_0(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4_getLookAt'\n" - " Possible C/C++ prototypes are:\n" " ofMatrix4x4::getLookAt(ofVec3f &,ofVec3f &,ofVec3f &,float) const\n" - " ofMatrix4x4::getLookAt(ofVec3f &,ofVec3f &,ofVec3f &) const\n"); lua_error(L);return 0; } -static int _wrap_Matrix4x4_decompose(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofVec3f *arg2 = 0 ; ofQuaternion *arg3 = 0 ; ofVec3f *arg4 = 0 ; ofQuaternion *arg5 = 0 ; - SWIG_check_num_args("ofMatrix4x4::decompose",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::decompose",1,"ofMatrix4x4 const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::decompose",2,"ofVec3f &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofMatrix4x4::decompose",3,"ofQuaternion &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofMatrix4x4::decompose",4,"ofVec3f &"); - if(!lua_isuserdata(L,5)) SWIG_fail_arg("ofMatrix4x4::decompose",5,"ofQuaternion &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_decompose",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_decompose",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Matrix4x4_decompose",3,SWIGTYPE_p_ofQuaternion); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_decompose",4,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Matrix4x4_decompose",5,SWIGTYPE_p_ofQuaternion); } - ((ofMatrix4x4 const *)arg1)->decompose(*arg2,*arg3,*arg4,*arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Matrix4x4_getInverseOf(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = 0 ; ofMatrix4x4 result; - SWIG_check_num_args("ofMatrix4x4::getInverseOf",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofMatrix4x4::getInverseOf",1,"ofMatrix4x4 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_getInverseOf",1,SWIGTYPE_p_ofMatrix4x4); } - result = ofMatrix4x4::getInverseOf((ofMatrix4x4 const &)*arg1); { - ofMatrix4x4 * resultptr = new ofMatrix4x4((const ofMatrix4x4 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_getTransposedOf(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = 0 ; ofMatrix4x4 result; - SWIG_check_num_args("ofMatrix4x4::getTransposedOf",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofMatrix4x4::getTransposedOf",1,"ofMatrix4x4 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_getTransposedOf",1,SWIGTYPE_p_ofMatrix4x4); } - result = ofMatrix4x4::getTransposedOf((ofMatrix4x4 const &)*arg1); { - ofMatrix4x4 * resultptr = new ofMatrix4x4((const ofMatrix4x4 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_getOrthoNormalOf(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = 0 ; ofMatrix4x4 result; - SWIG_check_num_args("ofMatrix4x4::getOrthoNormalOf",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofMatrix4x4::getOrthoNormalOf",1,"ofMatrix4x4 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_getOrthoNormalOf",1,SWIGTYPE_p_ofMatrix4x4); } - result = ofMatrix4x4::getOrthoNormalOf((ofMatrix4x4 const &)*arg1); { - ofMatrix4x4 * resultptr = new ofMatrix4x4((const ofMatrix4x4 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_postMult__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofVec3f *arg2 = 0 ; ofVec3f result; SWIG_check_num_args("ofMatrix4x4::postMult",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::postMult",1,"ofMatrix4x4 const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::postMult",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_postMult",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_postMult",2,SWIGTYPE_p_ofVec3f); } - result = ((ofMatrix4x4 const *)arg1)->postMult((ofVec3f const &)*arg2); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_postMult__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofVec4f *arg2 = 0 ; ofVec4f result; SWIG_check_num_args("ofMatrix4x4::postMult",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::postMult",1,"ofMatrix4x4 const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::postMult",2,"ofVec4f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_postMult",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec4f,0))){ - SWIG_fail_ptr("Matrix4x4_postMult",2,SWIGTYPE_p_ofVec4f); } - result = ((ofMatrix4x4 const *)arg1)->postMult((ofVec4f const &)*arg2); { - ofVec4f * resultptr = new ofVec4f((const ofVec4f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec4f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_postMult__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofMatrix4x4 *arg2 = 0 ; SWIG_check_num_args("ofMatrix4x4::postMult",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::postMult",1,"ofMatrix4x4 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::postMult",2,"ofMatrix4x4 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_postMult",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_postMult",2,SWIGTYPE_p_ofMatrix4x4); } (arg1)->postMult((ofMatrix4x4 const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_postMult(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_postMult__SWIG_0(L);} } } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_postMult__SWIG_1(L);} } } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_postMult__SWIG_2(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4_postMult'\n" " Possible C/C++ prototypes are:\n" - " ofMatrix4x4::postMult(ofVec3f const &) const\n" " ofMatrix4x4::postMult(ofVec4f const &) const\n" - " ofMatrix4x4::postMult(ofMatrix4x4 const &)\n"); lua_error(L);return 0; } -static int _wrap_Matrix4x4_preMult__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofVec3f *arg2 = 0 ; ofVec3f result; SWIG_check_num_args("ofMatrix4x4::preMult",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::preMult",1,"ofMatrix4x4 const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::preMult",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_preMult",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_preMult",2,SWIGTYPE_p_ofVec3f); } - result = ((ofMatrix4x4 const *)arg1)->preMult((ofVec3f const &)*arg2); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_preMult__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofVec4f *arg2 = 0 ; ofVec4f result; SWIG_check_num_args("ofMatrix4x4::preMult",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::preMult",1,"ofMatrix4x4 const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::preMult",2,"ofVec4f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_preMult",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec4f,0))){ - SWIG_fail_ptr("Matrix4x4_preMult",2,SWIGTYPE_p_ofVec4f); } - result = ((ofMatrix4x4 const *)arg1)->preMult((ofVec4f const &)*arg2); { - ofVec4f * resultptr = new ofVec4f((const ofVec4f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec4f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_preMult__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofMatrix4x4 *arg2 = 0 ; SWIG_check_num_args("ofMatrix4x4::preMult",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::preMult",1,"ofMatrix4x4 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::preMult",2,"ofMatrix4x4 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_preMult",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_preMult",2,SWIGTYPE_p_ofMatrix4x4); } (arg1)->preMult((ofMatrix4x4 const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_preMult(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_preMult__SWIG_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_preMult__SWIG_1(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_preMult__SWIG_2(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4_preMult'\n" " Possible C/C++ prototypes are:\n" - " ofMatrix4x4::preMult(ofVec3f const &) const\n" " ofMatrix4x4::preMult(ofVec4f const &) const\n" - " ofMatrix4x4::preMult(ofMatrix4x4 const &)\n"); lua_error(L);return 0; } -static int _wrap_Matrix4x4___mul__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofMatrix4x4 *arg2 = 0 ; ofMatrix4x4 result; SWIG_check_num_args("ofMatrix4x4::operator *",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::operator *",1,"ofMatrix4x4 const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::operator *",2,"ofMatrix4x4 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4___mul",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4___mul",2,SWIGTYPE_p_ofMatrix4x4); } - result = ((ofMatrix4x4 const *)arg1)->operator *((ofMatrix4x4 const &)*arg2); { - ofMatrix4x4 * resultptr = new ofMatrix4x4((const ofMatrix4x4 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4___mul__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofVec3f *arg2 = 0 ; ofVec3f result; SWIG_check_num_args("ofMatrix4x4::operator *",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::operator *",1,"ofMatrix4x4 const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::operator *",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4___mul",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4___mul",2,SWIGTYPE_p_ofVec3f); } - result = ((ofMatrix4x4 const *)arg1)->operator *((ofVec3f const &)*arg2); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4___mul__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofVec4f *arg2 = 0 ; ofVec4f result; SWIG_check_num_args("ofMatrix4x4::operator *",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::operator *",1,"ofMatrix4x4 const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::operator *",2,"ofVec4f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4___mul",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec4f,0))){ - SWIG_fail_ptr("Matrix4x4___mul",2,SWIGTYPE_p_ofVec4f); } - result = ((ofMatrix4x4 const *)arg1)->operator *((ofVec4f const &)*arg2); { - ofVec4f * resultptr = new ofVec4f((const ofVec4f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec4f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4___mul(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4___mul__SWIG_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4___mul__SWIG_1(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4___mul__SWIG_2(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4___mul'\n" " Possible C/C++ prototypes are:\n" - " ofMatrix4x4::operator *(ofMatrix4x4 const &) const\n" " ofMatrix4x4::operator *(ofVec3f const &) const\n" - " ofMatrix4x4::operator *(ofVec4f const &) const\n"); lua_error(L);return 0; } -static int _wrap_Matrix4x4_postMultTranslate__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofVec3f *arg2 = 0 ; SWIG_check_num_args("ofMatrix4x4::postMultTranslate",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::postMultTranslate",1,"ofMatrix4x4 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::postMultTranslate",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_postMultTranslate",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_postMultTranslate",2,SWIGTYPE_p_ofVec3f); } (arg1)->postMultTranslate((ofVec3f const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_postMultScale__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofVec3f *arg2 = 0 ; SWIG_check_num_args("ofMatrix4x4::postMultScale",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::postMultScale",1,"ofMatrix4x4 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::postMultScale",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_postMultScale",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_postMultScale",2,SWIGTYPE_p_ofVec3f); } (arg1)->postMultScale((ofVec3f const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_postMultRotate__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofQuaternion *arg2 = 0 ; SWIG_check_num_args("ofMatrix4x4::postMultRotate",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::postMultRotate",1,"ofMatrix4x4 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::postMultRotate",2,"ofQuaternion const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_postMultRotate",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Matrix4x4_postMultRotate",2,SWIGTYPE_p_ofQuaternion); } (arg1)->postMultRotate((ofQuaternion const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_postMultTranslate__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - float arg2 ; float arg3 ; float arg4 ; SWIG_check_num_args("ofMatrix4x4::postMultTranslate",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::postMultTranslate",1,"ofMatrix4x4 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::postMultTranslate",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix4x4::postMultTranslate",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix4x4::postMultTranslate",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_postMultTranslate",1,SWIGTYPE_p_ofMatrix4x4); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); (arg1)->postMultTranslate(arg2,arg3,arg4); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_postMultTranslate(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_postMultTranslate__SWIG_0(L);} } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Matrix4x4_postMultTranslate__SWIG_1(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4_postMultTranslate'\n" - " Possible C/C++ prototypes are:\n" " ofMatrix4x4::postMultTranslate(ofVec3f const &)\n" - " ofMatrix4x4::postMultTranslate(float,float,float)\n"); lua_error(L);return 0; } -static int _wrap_Matrix4x4_postMultRotate__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - float arg2 ; float arg3 ; float arg4 ; float arg5 ; SWIG_check_num_args("ofMatrix4x4::postMultRotate",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::postMultRotate",1,"ofMatrix4x4 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::postMultRotate",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix4x4::postMultRotate",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix4x4::postMultRotate",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMatrix4x4::postMultRotate",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_postMultRotate",1,SWIGTYPE_p_ofMatrix4x4); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - (arg1)->postMultRotate(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_postMultRotate(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_postMultRotate__SWIG_0(L);} } } if (argc == 5) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Matrix4x4_postMultRotate__SWIG_1(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4_postMultRotate'\n" - " Possible C/C++ prototypes are:\n" " ofMatrix4x4::postMultRotate(ofQuaternion const &)\n" - " ofMatrix4x4::postMultRotate(float,float,float,float)\n"); lua_error(L);return 0; } -static int _wrap_Matrix4x4_postMultScale__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - float arg2 ; float arg3 ; float arg4 ; SWIG_check_num_args("ofMatrix4x4::postMultScale",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::postMultScale",1,"ofMatrix4x4 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::postMultScale",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix4x4::postMultScale",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix4x4::postMultScale",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_postMultScale",1,SWIGTYPE_p_ofMatrix4x4); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); (arg1)->postMultScale(arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_postMultScale(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_postMultScale__SWIG_0(L);} } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Matrix4x4_postMultScale__SWIG_1(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4_postMultScale'\n" - " Possible C/C++ prototypes are:\n" " ofMatrix4x4::postMultScale(ofVec3f const &)\n" - " ofMatrix4x4::postMultScale(float,float,float)\n"); lua_error(L);return 0; } -static int _wrap_Matrix4x4_preMultScale(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofVec3f *arg2 = 0 ; SWIG_check_num_args("ofMatrix4x4::preMultScale",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::preMultScale",1,"ofMatrix4x4 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::preMultScale",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_preMultScale",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_preMultScale",2,SWIGTYPE_p_ofVec3f); } (arg1)->preMultScale((ofVec3f const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_preMultTranslate(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofVec3f *arg2 = 0 ; SWIG_check_num_args("ofMatrix4x4::preMultTranslate",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::preMultTranslate",1,"ofMatrix4x4 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::preMultTranslate",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_preMultTranslate",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_preMultTranslate",2,SWIGTYPE_p_ofVec3f); } (arg1)->preMultTranslate((ofVec3f const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_preMultRotate(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofQuaternion *arg2 = 0 ; SWIG_check_num_args("ofMatrix4x4::preMultRotate",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::preMultRotate",1,"ofMatrix4x4 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::preMultRotate",2,"ofQuaternion const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_preMultRotate",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Matrix4x4_preMultRotate",2,SWIGTYPE_p_ofQuaternion); } (arg1)->preMultRotate((ofQuaternion const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_setRotate(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofQuaternion *arg2 = 0 ; SWIG_check_num_args("ofMatrix4x4::setRotate",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::setRotate",1,"ofMatrix4x4 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::setRotate",2,"ofQuaternion const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_setRotate",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Matrix4x4_setRotate",2,SWIGTYPE_p_ofQuaternion); } (arg1)->setRotate((ofQuaternion const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_setTranslation__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - float arg2 ; float arg3 ; float arg4 ; SWIG_check_num_args("ofMatrix4x4::setTranslation",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::setTranslation",1,"ofMatrix4x4 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::setTranslation",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix4x4::setTranslation",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix4x4::setTranslation",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_setTranslation",1,SWIGTYPE_p_ofMatrix4x4); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); (arg1)->setTranslation(arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_setTranslation__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofVec3f *arg2 = 0 ; SWIG_check_num_args("ofMatrix4x4::setTranslation",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::setTranslation",1,"ofMatrix4x4 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::setTranslation",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_setTranslation",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_setTranslation",2,SWIGTYPE_p_ofVec3f); } (arg1)->setTranslation((ofVec3f const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_setTranslation(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_setTranslation__SWIG_1(L);} } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Matrix4x4_setTranslation__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4_setTranslation'\n" - " Possible C/C++ prototypes are:\n" " ofMatrix4x4::setTranslation(float,float,float)\n" - " ofMatrix4x4::setTranslation(ofVec3f const &)\n"); lua_error(L);return 0; } -static int _wrap_Matrix4x4_rotate__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; float arg2 ; - float arg3 ; float arg4 ; float arg5 ; SWIG_check_num_args("ofMatrix4x4::rotate",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::rotate",1,"ofMatrix4x4 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::rotate",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix4x4::rotate",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix4x4::rotate",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMatrix4x4::rotate",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_rotate",1,SWIGTYPE_p_ofMatrix4x4); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - (arg1)->rotate(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_rotateRad(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; float arg2 ; - float arg3 ; float arg4 ; float arg5 ; SWIG_check_num_args("ofMatrix4x4::rotateRad",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::rotateRad",1,"ofMatrix4x4 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::rotateRad",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix4x4::rotateRad",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix4x4::rotateRad",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMatrix4x4::rotateRad",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_rotateRad",1,SWIGTYPE_p_ofMatrix4x4); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - (arg1)->rotateRad(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_rotate__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofQuaternion *arg2 = 0 ; SWIG_check_num_args("ofMatrix4x4::rotate",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::rotate",1,"ofMatrix4x4 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::rotate",2,"ofQuaternion const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_rotate",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Matrix4x4_rotate",2,SWIGTYPE_p_ofQuaternion); } (arg1)->rotate((ofQuaternion const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_rotate(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_rotate__SWIG_1(L);} } } if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Matrix4x4_rotate__SWIG_0(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4_rotate'\n" " Possible C/C++ prototypes are:\n" - " ofMatrix4x4::rotate(float,float,float,float)\n" " ofMatrix4x4::rotate(ofQuaternion const &)\n"); - lua_error(L);return 0; } -static int _wrap_Matrix4x4_translate__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - float arg2 ; float arg3 ; float arg4 ; SWIG_check_num_args("ofMatrix4x4::translate",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::translate",1,"ofMatrix4x4 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::translate",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix4x4::translate",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix4x4::translate",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_translate",1,SWIGTYPE_p_ofMatrix4x4); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); (arg1)->translate(arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_translate__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofVec3f *arg2 = 0 ; SWIG_check_num_args("ofMatrix4x4::translate",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::translate",1,"ofMatrix4x4 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::translate",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_translate",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_translate",2,SWIGTYPE_p_ofVec3f); } (arg1)->translate((ofVec3f const &)*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_translate(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_translate__SWIG_1(L);} } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Matrix4x4_translate__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4_translate'\n" - " Possible C/C++ prototypes are:\n" " ofMatrix4x4::translate(float,float,float)\n" - " ofMatrix4x4::translate(ofVec3f const &)\n"); lua_error(L);return 0; } -static int _wrap_Matrix4x4_scale__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; float arg2 ; - float arg3 ; float arg4 ; SWIG_check_num_args("ofMatrix4x4::scale",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::scale",1,"ofMatrix4x4 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::scale",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix4x4::scale",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix4x4::scale",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_scale",1,SWIGTYPE_p_ofMatrix4x4); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); (arg1)->scale(arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_scale__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofVec3f *arg2 = 0 ; SWIG_check_num_args("ofMatrix4x4::scale",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::scale",1,"ofMatrix4x4 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::scale",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_scale",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_scale",2,SWIGTYPE_p_ofVec3f); } (arg1)->scale((ofVec3f const &)*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_scale(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_scale__SWIG_1(L);} } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Matrix4x4_scale__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4_scale'\n" " Possible C/C++ prototypes are:\n" - " ofMatrix4x4::scale(float,float,float)\n" " ofMatrix4x4::scale(ofVec3f const &)\n"); lua_error(L);return 0; } -static int _wrap_Matrix4x4_glRotate__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - float arg2 ; float arg3 ; float arg4 ; float arg5 ; SWIG_check_num_args("ofMatrix4x4::glRotate",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::glRotate",1,"ofMatrix4x4 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::glRotate",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix4x4::glRotate",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix4x4::glRotate",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMatrix4x4::glRotate",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_glRotate",1,SWIGTYPE_p_ofMatrix4x4); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - (arg1)->glRotate(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_glRotateRad(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; float arg2 ; - float arg3 ; float arg4 ; float arg5 ; SWIG_check_num_args("ofMatrix4x4::glRotateRad",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::glRotateRad",1,"ofMatrix4x4 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::glRotateRad",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix4x4::glRotateRad",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix4x4::glRotateRad",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMatrix4x4::glRotateRad",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_glRotateRad",1,SWIGTYPE_p_ofMatrix4x4); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - (arg1)->glRotateRad(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_glRotate__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofQuaternion *arg2 = 0 ; SWIG_check_num_args("ofMatrix4x4::glRotate",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::glRotate",1,"ofMatrix4x4 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::glRotate",2,"ofQuaternion const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_glRotate",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Matrix4x4_glRotate",2,SWIGTYPE_p_ofQuaternion); } (arg1)->glRotate((ofQuaternion const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_glRotate(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_glRotate__SWIG_1(L);} } } if (argc == 5) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Matrix4x4_glRotate__SWIG_0(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4_glRotate'\n" " Possible C/C++ prototypes are:\n" - " ofMatrix4x4::glRotate(float,float,float,float)\n" " ofMatrix4x4::glRotate(ofQuaternion const &)\n"); - lua_error(L);return 0; } -static int _wrap_Matrix4x4_glTranslate__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - float arg2 ; float arg3 ; float arg4 ; SWIG_check_num_args("ofMatrix4x4::glTranslate",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::glTranslate",1,"ofMatrix4x4 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::glTranslate",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix4x4::glTranslate",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix4x4::glTranslate",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_glTranslate",1,SWIGTYPE_p_ofMatrix4x4); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); (arg1)->glTranslate(arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_glTranslate__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofVec3f *arg2 = 0 ; SWIG_check_num_args("ofMatrix4x4::glTranslate",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::glTranslate",1,"ofMatrix4x4 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::glTranslate",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_glTranslate",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_glTranslate",2,SWIGTYPE_p_ofVec3f); } (arg1)->glTranslate((ofVec3f const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_glTranslate(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_glTranslate__SWIG_1(L);} } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Matrix4x4_glTranslate__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4_glTranslate'\n" - " Possible C/C++ prototypes are:\n" " ofMatrix4x4::glTranslate(float,float,float)\n" - " ofMatrix4x4::glTranslate(ofVec3f const &)\n"); lua_error(L);return 0; } -static int _wrap_Matrix4x4_glScale__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - float arg2 ; float arg3 ; float arg4 ; SWIG_check_num_args("ofMatrix4x4::glScale",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::glScale",1,"ofMatrix4x4 *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrix4x4::glScale",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrix4x4::glScale",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrix4x4::glScale",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_glScale",1,SWIGTYPE_p_ofMatrix4x4); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); (arg1)->glScale(arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_glScale__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofVec3f *arg2 = 0 ; SWIG_check_num_args("ofMatrix4x4::glScale",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::glScale",1,"ofMatrix4x4 *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::glScale",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_glScale",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_glScale",2,SWIGTYPE_p_ofVec3f); } (arg1)->glScale((ofVec3f const &)*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_glScale(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_glScale__SWIG_1(L);} } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Matrix4x4_glScale__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4_glScale'\n" " Possible C/C++ prototypes are:\n" - " ofMatrix4x4::glScale(float,float,float)\n" " ofMatrix4x4::glScale(ofVec3f const &)\n"); lua_error(L);return 0; } -static int _wrap_Matrix4x4_getRotate(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofQuaternion result; SWIG_check_num_args("ofMatrix4x4::getRotate",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::getRotate",1,"ofMatrix4x4 const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_getRotate",1,SWIGTYPE_p_ofMatrix4x4); } result = ((ofMatrix4x4 const *)arg1)->getRotate(); { - ofQuaternion * resultptr = new ofQuaternion((const ofQuaternion &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofQuaternion,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_getTranslation(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - ofVec3f result; SWIG_check_num_args("ofMatrix4x4::getTranslation",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::getTranslation",1,"ofMatrix4x4 const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_getTranslation",1,SWIGTYPE_p_ofMatrix4x4); } - result = ((ofMatrix4x4 const *)arg1)->getTranslation(); { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_getScale(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; ofVec3f result; - SWIG_check_num_args("ofMatrix4x4::getScale",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::getScale",1,"ofMatrix4x4 const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_getScale",1,SWIGTYPE_p_ofMatrix4x4); } result = ((ofMatrix4x4 const *)arg1)->getScale(); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_transform3x3__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = 0 ; ofMatrix4x4 *arg2 = 0 ; - ofVec3f result; SWIG_check_num_args("ofMatrix4x4::transform3x3",2,2) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofMatrix4x4::transform3x3",1,"ofVec3f const &"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::transform3x3",2,"ofMatrix4x4 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_transform3x3",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_transform3x3",2,SWIGTYPE_p_ofMatrix4x4); } - result = ofMatrix4x4::transform3x3((ofVec3f const &)*arg1,(ofMatrix4x4 const &)*arg2); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_transform3x3__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = 0 ; ofVec3f *arg2 = 0 ; - ofVec3f result; SWIG_check_num_args("ofMatrix4x4::transform3x3",2,2) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofMatrix4x4::transform3x3",1,"ofMatrix4x4 const &"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrix4x4::transform3x3",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4_transform3x3",1,SWIGTYPE_p_ofMatrix4x4); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Matrix4x4_transform3x3",2,SWIGTYPE_p_ofVec3f); } - result = ofMatrix4x4::transform3x3((ofMatrix4x4 const &)*arg1,(ofVec3f const &)*arg2); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Matrix4x4_transform3x3(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_transform3x3__SWIG_0(L);} } } if (argc == 2) { int _v; { - void *ptr; if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Matrix4x4_transform3x3__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Matrix4x4_transform3x3'\n" - " Possible C/C++ prototypes are:\n" " ofMatrix4x4::transform3x3(ofVec3f const &,ofMatrix4x4 const &)\n" - " ofMatrix4x4::transform3x3(ofMatrix4x4 const &,ofVec3f const &)\n"); lua_error(L);return 0; } -static int _wrap_Matrix4x4___tostring(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = (ofMatrix4x4 *) 0 ; - char *result = 0 ; SWIG_check_num_args("ofMatrix4x4::__str__",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrix4x4::__str__",1,"ofMatrix4x4 *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Matrix4x4___tostring",1,SWIGTYPE_p_ofMatrix4x4); } result = (char *)ofMatrix4x4___str__(arg1); - lua_pushstring(L,(const char *)result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_Matrix4x4(void *obj) { -ofMatrix4x4 *arg1 = (ofMatrix4x4 *) obj; -delete arg1; -} -static int _proxy__wrap_new_Matrix4x4(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_Matrix4x4); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_Matrix4x4_attributes[] = { - { "_mat", _wrap_Matrix4x4__mat_get, _wrap_Matrix4x4__mat_set }, - {0,0,0} -}; -static swig_lua_method swig_Matrix4x4_methods[]= { - { "makeIdentityMatrix", _wrap_Matrix4x4_makeIdentityMatrix}, - { "makeScaleMatrix", _wrap_Matrix4x4_makeScaleMatrix}, - { "makeTranslationMatrix", _wrap_Matrix4x4_makeTranslationMatrix}, - { "makeRotationMatrix", _wrap_Matrix4x4_makeRotationMatrix}, - { "makeInvertOf", _wrap_Matrix4x4_makeInvertOf}, - { "makeOrthoNormalOf", _wrap_Matrix4x4_makeOrthoNormalOf}, - { "makeFromMultiplicationOf", _wrap_Matrix4x4_makeFromMultiplicationOf}, - { "makeOrthoMatrix", _wrap_Matrix4x4_makeOrthoMatrix}, - { "makeOrtho2DMatrix", _wrap_Matrix4x4_makeOrtho2DMatrix}, - { "makeFrustumMatrix", _wrap_Matrix4x4_makeFrustumMatrix}, - { "makePerspectiveMatrix", _wrap_Matrix4x4_makePerspectiveMatrix}, - { "makeLookAtMatrix", _wrap_Matrix4x4_makeLookAtMatrix}, - { "makeLookAtViewMatrix", _wrap_Matrix4x4_makeLookAtViewMatrix}, - { "__call", _wrap_Matrix4x4___call}, - { "getRowAsVec3f", _wrap_Matrix4x4_getRowAsVec3f}, - { "getRowAsVec4f", _wrap_Matrix4x4_getRowAsVec4f}, - { "getPtr", _wrap_Matrix4x4_getPtr}, - { "isValid", _wrap_Matrix4x4_isValid}, - { "isNaN", _wrap_Matrix4x4_isNaN}, - { "isIdentity", _wrap_Matrix4x4_isIdentity}, - { "set", _wrap_Matrix4x4_set}, - { "getInverse", _wrap_Matrix4x4_getInverse}, - { "getOrtho", _wrap_Matrix4x4_getOrtho}, - { "getFrustum", _wrap_Matrix4x4_getFrustum}, - { "getPerspective", _wrap_Matrix4x4_getPerspective}, - { "getLookAt", _wrap_Matrix4x4_getLookAt}, - { "decompose", _wrap_Matrix4x4_decompose}, - { "postMult", _wrap_Matrix4x4_postMult}, - { "preMult", _wrap_Matrix4x4_preMult}, - { "__mul", _wrap_Matrix4x4___mul}, - { "postMultTranslate", _wrap_Matrix4x4_postMultTranslate}, - { "postMultRotate", _wrap_Matrix4x4_postMultRotate}, - { "postMultScale", _wrap_Matrix4x4_postMultScale}, - { "preMultScale", _wrap_Matrix4x4_preMultScale}, - { "preMultTranslate", _wrap_Matrix4x4_preMultTranslate}, - { "preMultRotate", _wrap_Matrix4x4_preMultRotate}, - { "setRotate", _wrap_Matrix4x4_setRotate}, - { "setTranslation", _wrap_Matrix4x4_setTranslation}, - { "rotateRad", _wrap_Matrix4x4_rotateRad}, - { "rotate", _wrap_Matrix4x4_rotate}, - { "translate", _wrap_Matrix4x4_translate}, - { "scale", _wrap_Matrix4x4_scale}, - { "glRotateRad", _wrap_Matrix4x4_glRotateRad}, - { "glRotate", _wrap_Matrix4x4_glRotate}, - { "glTranslate", _wrap_Matrix4x4_glTranslate}, - { "glScale", _wrap_Matrix4x4_glScale}, - { "getRotate", _wrap_Matrix4x4_getRotate}, - { "getTranslation", _wrap_Matrix4x4_getTranslation}, - { "getScale", _wrap_Matrix4x4_getScale}, - { "__tostring", _wrap_Matrix4x4___tostring}, - {0,0} -}; -static swig_lua_method swig_Matrix4x4_meta[] = { - { "__call", _wrap_Matrix4x4___call}, - { "__mul", _wrap_Matrix4x4___mul}, - { "__tostring", _wrap_Matrix4x4___tostring}, - {0,0} -}; - -static swig_lua_attribute swig_Matrix4x4_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_Matrix4x4_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_Matrix4x4_Sf_SwigStatic_methods[]= { - { "newIdentityMatrix", _wrap_Matrix4x4_newIdentityMatrix}, - { "newScaleMatrix", _wrap_Matrix4x4_newScaleMatrix}, - { "newTranslationMatrix", _wrap_Matrix4x4_newTranslationMatrix}, - { "newRotationMatrix", _wrap_Matrix4x4_newRotationMatrix}, - { "newOrthoMatrix", _wrap_Matrix4x4_newOrthoMatrix}, - { "newOrtho2DMatrix", _wrap_Matrix4x4_newOrtho2DMatrix}, - { "newFrustumMatrix", _wrap_Matrix4x4_newFrustumMatrix}, - { "newPerspectiveMatrix", _wrap_Matrix4x4_newPerspectiveMatrix}, - { "newLookAtMatrix", _wrap_Matrix4x4_newLookAtMatrix}, - { "getInverseOf", _wrap_Matrix4x4_getInverseOf}, - { "getTransposedOf", _wrap_Matrix4x4_getTransposedOf}, - { "getOrthoNormalOf", _wrap_Matrix4x4_getOrthoNormalOf}, - { "transform3x3", _wrap_Matrix4x4_transform3x3}, - {0,0} -}; -static swig_lua_class* swig_Matrix4x4_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_Matrix4x4_Sf_SwigStatic = { - "Matrix4x4", - swig_Matrix4x4_Sf_SwigStatic_methods, - swig_Matrix4x4_Sf_SwigStatic_attributes, - swig_Matrix4x4_Sf_SwigStatic_constants, - swig_Matrix4x4_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_Matrix4x4_bases[] = {0}; -static const char *swig_Matrix4x4_base_names[] = {0}; -static swig_lua_class _wrap_class_Matrix4x4 = { "Matrix4x4", "Matrix4x4", &SWIGTYPE_p_ofMatrix4x4,_proxy__wrap_new_Matrix4x4, swig_delete_Matrix4x4, swig_Matrix4x4_methods, swig_Matrix4x4_attributes, &swig_Matrix4x4_Sf_SwigStatic, swig_Matrix4x4_meta, swig_Matrix4x4_bases, swig_Matrix4x4_base_names }; - -static int _wrap_Quaternion__v_set(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; - ofVec4f *arg2 = (ofVec4f *) 0 ; SWIG_check_num_args("ofQuaternion::_v",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::_v",1,"ofQuaternion *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofQuaternion::_v",2,"ofVec4f *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion__v_set",1,SWIGTYPE_p_ofQuaternion); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec4f,0))){ - SWIG_fail_ptr("Quaternion__v_set",2,SWIGTYPE_p_ofVec4f); } if (arg1) (arg1)->_v = *arg2; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Quaternion__v_get(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; - ofVec4f *result = 0 ; SWIG_check_num_args("ofQuaternion::_v",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::_v",1,"ofQuaternion *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion__v_get",1,SWIGTYPE_p_ofQuaternion); } result = (ofVec4f *)& ((arg1)->_v); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec4f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Quaternion__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofQuaternion *result = 0 ; - SWIG_check_num_args("ofQuaternion::ofQuaternion",0,0) result = (ofQuaternion *)new ofQuaternion(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofQuaternion,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Quaternion__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - ofQuaternion *result = 0 ; SWIG_check_num_args("ofQuaternion::ofQuaternion",4,4) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofQuaternion::ofQuaternion",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofQuaternion::ofQuaternion",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofQuaternion::ofQuaternion",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofQuaternion::ofQuaternion",4,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - result = (ofQuaternion *)new ofQuaternion(arg1,arg2,arg3,arg4); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofQuaternion,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Quaternion__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = 0 ; ofQuaternion *result = 0 ; - SWIG_check_num_args("ofQuaternion::ofQuaternion",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofQuaternion::ofQuaternion",1,"ofVec4f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ - SWIG_fail_ptr("new_Quaternion",1,SWIGTYPE_p_ofVec4f); } result = (ofQuaternion *)new ofQuaternion((ofVec4f const &)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofQuaternion,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Quaternion__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; ofVec3f *arg2 = 0 ; - ofQuaternion *result = 0 ; SWIG_check_num_args("ofQuaternion::ofQuaternion",2,2) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofQuaternion::ofQuaternion",1,"float"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofQuaternion::ofQuaternion",2,"ofVec3f const &"); arg1 = (float)lua_tonumber(L, 1); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("new_Quaternion",2,SWIGTYPE_p_ofVec3f); } - result = (ofQuaternion *)new ofQuaternion(arg1,(ofVec3f const &)*arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofQuaternion,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Quaternion__SWIG_4(lua_State* L) { int SWIG_arg = 0; float arg1 ; ofVec3f *arg2 = 0 ; float arg3 ; - ofVec3f *arg4 = 0 ; float arg5 ; ofVec3f *arg6 = 0 ; ofQuaternion *result = 0 ; - SWIG_check_num_args("ofQuaternion::ofQuaternion",6,6) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofQuaternion::ofQuaternion",1,"float"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofQuaternion::ofQuaternion",2,"ofVec3f const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofQuaternion::ofQuaternion",3,"float"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofQuaternion::ofQuaternion",4,"ofVec3f const &"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofQuaternion::ofQuaternion",5,"float"); - if(!lua_isuserdata(L,6)) SWIG_fail_arg("ofQuaternion::ofQuaternion",6,"ofVec3f const &"); arg1 = (float)lua_tonumber(L, 1); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("new_Quaternion",2,SWIGTYPE_p_ofVec3f); } arg3 = (float)lua_tonumber(L, 3); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("new_Quaternion",4,SWIGTYPE_p_ofVec3f); } arg5 = (float)lua_tonumber(L, 5); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,6,(void**)&arg6,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("new_Quaternion",6,SWIGTYPE_p_ofVec3f); } - result = (ofQuaternion *)new ofQuaternion(arg1,(ofVec3f const &)*arg2,arg3,(ofVec3f const &)*arg4,arg5,(ofVec3f const &)*arg6); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofQuaternion,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Quaternion(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_Quaternion__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_new_Quaternion__SWIG_2(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_new_Quaternion__SWIG_3(L);} } } if (argc == 4) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_new_Quaternion__SWIG_1(L);} } } } } - if (argc == 6) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[5])==0 || SWIG_ConvertPtr(L,argv[5], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_new_Quaternion__SWIG_4(L);} } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_Quaternion'\n" " Possible C/C++ prototypes are:\n" - " ofQuaternion::ofQuaternion()\n" " ofQuaternion::ofQuaternion(float,float,float,float)\n" - " ofQuaternion::ofQuaternion(ofVec4f const &)\n" " ofQuaternion::ofQuaternion(float,ofVec3f const &)\n" - " ofQuaternion::ofQuaternion(float,ofVec3f const &,float,ofVec3f const &,float,ofVec3f const &)\n"); - lua_error(L);return 0; } -static int _wrap_Quaternion_set__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; float arg2 ; - float arg3 ; float arg4 ; float arg5 ; SWIG_check_num_args("ofQuaternion::set",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::set",1,"ofQuaternion *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofQuaternion::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofQuaternion::set",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofQuaternion::set",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofQuaternion::set",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion_set",1,SWIGTYPE_p_ofQuaternion); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - (arg1)->set(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Quaternion_set__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; - ofVec4f *arg2 = 0 ; SWIG_check_num_args("ofQuaternion::set",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::set",1,"ofQuaternion *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofQuaternion::set",2,"ofVec4f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion_set",1,SWIGTYPE_p_ofQuaternion); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec4f,0))){ - SWIG_fail_ptr("Quaternion_set",2,SWIGTYPE_p_ofVec4f); } (arg1)->set((ofVec4f const &)*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Quaternion_set__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; - ofMatrix4x4 *arg2 = 0 ; SWIG_check_num_args("ofQuaternion::set",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::set",1,"ofQuaternion *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofQuaternion::set",2,"ofMatrix4x4 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion_set",1,SWIGTYPE_p_ofQuaternion); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Quaternion_set",2,SWIGTYPE_p_ofMatrix4x4); } (arg1)->set((ofMatrix4x4 const &)*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Quaternion_set(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Quaternion_set__SWIG_1(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Quaternion_set__SWIG_2(L);} } } if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Quaternion_set__SWIG_0(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Quaternion_set'\n" " Possible C/C++ prototypes are:\n" - " ofQuaternion::set(float,float,float,float)\n" " ofQuaternion::set(ofVec4f const &)\n" - " ofQuaternion::set(ofMatrix4x4 const &)\n"); lua_error(L);return 0; } -static int _wrap_Quaternion_get(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; - ofMatrix4x4 *arg2 = 0 ; SWIG_check_num_args("ofQuaternion::get",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::get",1,"ofQuaternion const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofQuaternion::get",2,"ofMatrix4x4 &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion_get",1,SWIGTYPE_p_ofQuaternion); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Quaternion_get",2,SWIGTYPE_p_ofMatrix4x4); } ((ofQuaternion const *)arg1)->get(*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Quaternion_x(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; float *result = 0 ; - SWIG_check_num_args("ofQuaternion::x",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::x",1,"ofQuaternion *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion_x",1,SWIGTYPE_p_ofQuaternion); } result = (float *) &(arg1)->x(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_float,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Quaternion_y(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; float *result = 0 ; - SWIG_check_num_args("ofQuaternion::y",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::y",1,"ofQuaternion *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion_y",1,SWIGTYPE_p_ofQuaternion); } result = (float *) &(arg1)->y(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_float,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Quaternion_z(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; float *result = 0 ; - SWIG_check_num_args("ofQuaternion::z",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::z",1,"ofQuaternion *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion_z",1,SWIGTYPE_p_ofQuaternion); } result = (float *) &(arg1)->z(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_float,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Quaternion_w(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; float *result = 0 ; - SWIG_check_num_args("ofQuaternion::w",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::w",1,"ofQuaternion *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion_w",1,SWIGTYPE_p_ofQuaternion); } result = (float *) &(arg1)->w(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_float,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Quaternion_asVec4(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; ofVec4f result; - SWIG_check_num_args("ofQuaternion::asVec4",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::asVec4",1,"ofQuaternion const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion_asVec4",1,SWIGTYPE_p_ofQuaternion); } result = ((ofQuaternion const *)arg1)->asVec4(); { - ofVec4f * resultptr = new ofVec4f((const ofVec4f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec4f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Quaternion_asVec3(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; ofVec3f result; - SWIG_check_num_args("ofQuaternion::asVec3",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::asVec3",1,"ofQuaternion const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion_asVec3",1,SWIGTYPE_p_ofQuaternion); } result = ((ofQuaternion const *)arg1)->asVec3(); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Quaternion_zeroRotation(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; - bool result; SWIG_check_num_args("ofQuaternion::zeroRotation",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::zeroRotation",1,"ofQuaternion const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion_zeroRotation",1,SWIGTYPE_p_ofQuaternion); } - result = (bool)((ofQuaternion const *)arg1)->zeroRotation(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Quaternion_length(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; float result; - SWIG_check_num_args("ofQuaternion::length",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::length",1,"ofQuaternion const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion_length",1,SWIGTYPE_p_ofQuaternion); } result = (float)((ofQuaternion const *)arg1)->length(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Quaternion_length2(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; float result; - SWIG_check_num_args("ofQuaternion::length2",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::length2",1,"ofQuaternion const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion_length2",1,SWIGTYPE_p_ofQuaternion); } result = (float)((ofQuaternion const *)arg1)->length2(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Quaternion_conj(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; - ofQuaternion result; SWIG_check_num_args("ofQuaternion::conj",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::conj",1,"ofQuaternion const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion_conj",1,SWIGTYPE_p_ofQuaternion); } result = ((ofQuaternion const *)arg1)->conj(); { - ofQuaternion * resultptr = new ofQuaternion((const ofQuaternion &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofQuaternion,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Quaternion_inverse(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; - ofQuaternion result; SWIG_check_num_args("ofQuaternion::inverse",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::inverse",1,"ofQuaternion const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion_inverse",1,SWIGTYPE_p_ofQuaternion); } result = ((ofQuaternion const *)arg1)->inverse(); { - ofQuaternion * resultptr = new ofQuaternion((const ofQuaternion &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofQuaternion,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Quaternion_makeRotate__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; - float arg2 ; float arg3 ; float arg4 ; float arg5 ; SWIG_check_num_args("ofQuaternion::makeRotate",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::makeRotate",1,"ofQuaternion *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofQuaternion::makeRotate",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofQuaternion::makeRotate",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofQuaternion::makeRotate",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofQuaternion::makeRotate",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion_makeRotate",1,SWIGTYPE_p_ofQuaternion); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - (arg1)->makeRotate(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Quaternion_makeRotate__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; - float arg2 ; ofVec3f *arg3 = 0 ; SWIG_check_num_args("ofQuaternion::makeRotate",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::makeRotate",1,"ofQuaternion *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofQuaternion::makeRotate",2,"float"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofQuaternion::makeRotate",3,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion_makeRotate",1,SWIGTYPE_p_ofQuaternion); } arg2 = (float)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Quaternion_makeRotate",3,SWIGTYPE_p_ofVec3f); } (arg1)->makeRotate(arg2,(ofVec3f const &)*arg3); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Quaternion_makeRotate__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; - float arg2 ; ofVec3f *arg3 = 0 ; float arg4 ; ofVec3f *arg5 = 0 ; float arg6 ; ofVec3f *arg7 = 0 ; - SWIG_check_num_args("ofQuaternion::makeRotate",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::makeRotate",1,"ofQuaternion *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofQuaternion::makeRotate",2,"float"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofQuaternion::makeRotate",3,"ofVec3f const &"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofQuaternion::makeRotate",4,"float"); - if(!lua_isuserdata(L,5)) SWIG_fail_arg("ofQuaternion::makeRotate",5,"ofVec3f const &"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofQuaternion::makeRotate",6,"float"); - if(!lua_isuserdata(L,7)) SWIG_fail_arg("ofQuaternion::makeRotate",7,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion_makeRotate",1,SWIGTYPE_p_ofQuaternion); } arg2 = (float)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Quaternion_makeRotate",3,SWIGTYPE_p_ofVec3f); } arg4 = (float)lua_tonumber(L, 4); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Quaternion_makeRotate",5,SWIGTYPE_p_ofVec3f); } arg6 = (float)lua_tonumber(L, 6); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,7,(void**)&arg7,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Quaternion_makeRotate",7,SWIGTYPE_p_ofVec3f); } - (arg1)->makeRotate(arg2,(ofVec3f const &)*arg3,arg4,(ofVec3f const &)*arg5,arg6,(ofVec3f const &)*arg7); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Quaternion_makeRotate__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; - ofVec3f *arg2 = 0 ; ofVec3f *arg3 = 0 ; SWIG_check_num_args("ofQuaternion::makeRotate",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::makeRotate",1,"ofQuaternion *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofQuaternion::makeRotate",2,"ofVec3f const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofQuaternion::makeRotate",3,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion_makeRotate",1,SWIGTYPE_p_ofQuaternion); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Quaternion_makeRotate",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Quaternion_makeRotate",3,SWIGTYPE_p_ofVec3f); } - (arg1)->makeRotate((ofVec3f const &)*arg2,(ofVec3f const &)*arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Quaternion_makeRotate(lua_State* L) { int argc; int argv[8]={ 1,2,3,4,5,6,7,8} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Quaternion_makeRotate__SWIG_3(L);} } } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Quaternion_makeRotate__SWIG_1(L);} } } } if (argc == 5) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Quaternion_makeRotate__SWIG_0(L);} } } } } } if (argc == 7) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[4])==0 || SWIG_ConvertPtr(L,argv[4], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[6])==0 || SWIG_ConvertPtr(L,argv[6], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Quaternion_makeRotate__SWIG_2(L);} } } } } } } - } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Quaternion_makeRotate'\n" - " Possible C/C++ prototypes are:\n" " ofQuaternion::makeRotate(float,float,float,float)\n" - " ofQuaternion::makeRotate(float,ofVec3f const &)\n" - " ofQuaternion::makeRotate(float,ofVec3f const &,float,ofVec3f const &,float,ofVec3f const &)\n" - " ofQuaternion::makeRotate(ofVec3f const &,ofVec3f const &)\n"); lua_error(L);return 0; } -static int _wrap_Quaternion_makeRotate_original(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; - ofVec3f *arg2 = 0 ; ofVec3f *arg3 = 0 ; SWIG_check_num_args("ofQuaternion::makeRotate_original",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::makeRotate_original",1,"ofQuaternion *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofQuaternion::makeRotate_original",2,"ofVec3f const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofQuaternion::makeRotate_original",3,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion_makeRotate_original",1,SWIGTYPE_p_ofQuaternion); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Quaternion_makeRotate_original",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Quaternion_makeRotate_original",3,SWIGTYPE_p_ofVec3f); } - (arg1)->makeRotate_original((ofVec3f const &)*arg2,(ofVec3f const &)*arg3); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Quaternion_getRotate__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; - float *arg2 = 0 ; float *arg3 = 0 ; float *arg4 = 0 ; float *arg5 = 0 ; SWIG_check_num_args("ofQuaternion::getRotate",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::getRotate",1,"ofQuaternion const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofQuaternion::getRotate",2,"float &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofQuaternion::getRotate",3,"float &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofQuaternion::getRotate",4,"float &"); - if(!lua_isuserdata(L,5)) SWIG_fail_arg("ofQuaternion::getRotate",5,"float &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion_getRotate",1,SWIGTYPE_p_ofQuaternion); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Quaternion_getRotate",2,SWIGTYPE_p_float); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Quaternion_getRotate",3,SWIGTYPE_p_float); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Quaternion_getRotate",4,SWIGTYPE_p_float); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Quaternion_getRotate",5,SWIGTYPE_p_float); } - ((ofQuaternion const *)arg1)->getRotate(*arg2,*arg3,*arg4,*arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Quaternion_getRotate__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; - float *arg2 = 0 ; ofVec3f *arg3 = 0 ; SWIG_check_num_args("ofQuaternion::getRotate",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::getRotate",1,"ofQuaternion const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofQuaternion::getRotate",2,"float &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofQuaternion::getRotate",3,"ofVec3f &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion_getRotate",1,SWIGTYPE_p_ofQuaternion); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Quaternion_getRotate",2,SWIGTYPE_p_float); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Quaternion_getRotate",3,SWIGTYPE_p_ofVec3f); } ((ofQuaternion const *)arg1)->getRotate(*arg2,*arg3); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Quaternion_getRotate(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Quaternion_getRotate__SWIG_1(L);} } } } if (argc == 5) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[4])==0 || SWIG_ConvertPtr(L,argv[4], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Quaternion_getRotate__SWIG_0(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Quaternion_getRotate'\n" - " Possible C/C++ prototypes are:\n" " ofQuaternion::getRotate(float &,float &,float &,float &) const\n" - " ofQuaternion::getRotate(float &,ofVec3f &) const\n"); lua_error(L);return 0; } -static int _wrap_Quaternion_getEuler(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; ofVec3f result; - SWIG_check_num_args("ofQuaternion::getEuler",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::getEuler",1,"ofQuaternion const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion_getEuler",1,SWIGTYPE_p_ofQuaternion); } result = ((ofQuaternion const *)arg1)->getEuler(); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Quaternion_slerp(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; float arg2 ; - ofQuaternion *arg3 = 0 ; ofQuaternion *arg4 = 0 ; SWIG_check_num_args("ofQuaternion::slerp",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::slerp",1,"ofQuaternion *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofQuaternion::slerp",2,"float"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofQuaternion::slerp",3,"ofQuaternion const &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofQuaternion::slerp",4,"ofQuaternion const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion_slerp",1,SWIGTYPE_p_ofQuaternion); } arg2 = (float)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion_slerp",3,SWIGTYPE_p_ofQuaternion); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion_slerp",4,SWIGTYPE_p_ofQuaternion); } - (arg1)->slerp(arg2,(ofQuaternion const &)*arg3,(ofQuaternion const &)*arg4); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Quaternion_normalize(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; - SWIG_check_num_args("ofQuaternion::normalize",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::normalize",1,"ofQuaternion *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion_normalize",1,SWIGTYPE_p_ofQuaternion); } (arg1)->normalize(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Quaternion___eq(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; - ofQuaternion *arg2 = 0 ; bool result; SWIG_check_num_args("ofQuaternion::operator ==",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::operator ==",1,"ofQuaternion const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofQuaternion::operator ==",2,"ofQuaternion const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion___eq",1,SWIGTYPE_p_ofQuaternion); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion___eq",2,SWIGTYPE_p_ofQuaternion); } - result = (bool)((ofQuaternion const *)arg1)->operator ==((ofQuaternion const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Quaternion___mul__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; - float arg2 ; ofQuaternion result; SWIG_check_num_args("ofQuaternion::operator *",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::operator *",1,"ofQuaternion const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofQuaternion::operator *",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion___mul",1,SWIGTYPE_p_ofQuaternion); } arg2 = (float)lua_tonumber(L, 2); - result = ((ofQuaternion const *)arg1)->operator *(arg2); { - ofQuaternion * resultptr = new ofQuaternion((const ofQuaternion &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofQuaternion,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Quaternion___mul__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; - ofQuaternion *arg2 = 0 ; ofQuaternion result; SWIG_check_num_args("ofQuaternion::operator *",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::operator *",1,"ofQuaternion const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofQuaternion::operator *",2,"ofQuaternion const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion___mul",1,SWIGTYPE_p_ofQuaternion); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion___mul",2,SWIGTYPE_p_ofQuaternion); } - result = ((ofQuaternion const *)arg1)->operator *((ofQuaternion const &)*arg2); { - ofQuaternion * resultptr = new ofQuaternion((const ofQuaternion &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofQuaternion,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Quaternion___mul__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; - ofVec3f *arg2 = 0 ; ofVec3f result; SWIG_check_num_args("ofQuaternion::operator *",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::operator *",1,"ofQuaternion const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofQuaternion::operator *",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion___mul",1,SWIGTYPE_p_ofQuaternion); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Quaternion___mul",2,SWIGTYPE_p_ofVec3f); } - result = ((ofQuaternion const *)arg1)->operator *((ofVec3f const &)*arg2); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Quaternion___mul(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Quaternion___mul__SWIG_1(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Quaternion___mul__SWIG_2(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Quaternion___mul__SWIG_0(L);} } - } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Quaternion___mul'\n" - " Possible C/C++ prototypes are:\n" " ofQuaternion::operator *(float) const\n" - " ofQuaternion::operator *(ofQuaternion const &) const\n" " ofQuaternion::operator *(ofVec3f const &) const\n"); - lua_error(L);return 0; } -static int _wrap_Quaternion___div__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; - float arg2 ; ofQuaternion result; SWIG_check_num_args("ofQuaternion::operator /",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::operator /",1,"ofQuaternion const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofQuaternion::operator /",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion___div",1,SWIGTYPE_p_ofQuaternion); } arg2 = (float)lua_tonumber(L, 2); - result = ((ofQuaternion const *)arg1)->operator /(arg2); { - ofQuaternion * resultptr = new ofQuaternion((const ofQuaternion &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofQuaternion,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Quaternion___div__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; - ofQuaternion *arg2 = 0 ; ofQuaternion result; SWIG_check_num_args("ofQuaternion::operator /",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::operator /",1,"ofQuaternion const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofQuaternion::operator /",2,"ofQuaternion const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion___div",1,SWIGTYPE_p_ofQuaternion); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion___div",2,SWIGTYPE_p_ofQuaternion); } - result = ((ofQuaternion const *)arg1)->operator /((ofQuaternion const &)*arg2); { - ofQuaternion * resultptr = new ofQuaternion((const ofQuaternion &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofQuaternion,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Quaternion___div(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Quaternion___div__SWIG_1(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofQuaternion, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Quaternion___div__SWIG_0(L);} } - } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Quaternion___div'\n" - " Possible C/C++ prototypes are:\n" " ofQuaternion::operator /(float) const\n" - " ofQuaternion::operator /(ofQuaternion const &) const\n"); lua_error(L);return 0; } -static int _wrap_Quaternion___add(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; - ofQuaternion *arg2 = 0 ; ofQuaternion result; SWIG_check_num_args("ofQuaternion::operator +",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::operator +",1,"ofQuaternion const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofQuaternion::operator +",2,"ofQuaternion const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion___add",1,SWIGTYPE_p_ofQuaternion); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion___add",2,SWIGTYPE_p_ofQuaternion); } - result = ((ofQuaternion const *)arg1)->operator +((ofQuaternion const &)*arg2); { - ofQuaternion * resultptr = new ofQuaternion((const ofQuaternion &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofQuaternion,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Quaternion___sub(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; - ofQuaternion *arg2 = 0 ; ofQuaternion result; SWIG_check_num_args("ofQuaternion::operator -",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::operator -",1,"ofQuaternion const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofQuaternion::operator -",2,"ofQuaternion const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion___sub",1,SWIGTYPE_p_ofQuaternion); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion___sub",2,SWIGTYPE_p_ofQuaternion); } - result = ((ofQuaternion const *)arg1)->operator -((ofQuaternion const &)*arg2); { - ofQuaternion * resultptr = new ofQuaternion((const ofQuaternion &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofQuaternion,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Quaternion___unm(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; - ofQuaternion result; SWIG_check_num_args("ofQuaternion::operator -",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::operator -",1,"ofQuaternion const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion___unm",1,SWIGTYPE_p_ofQuaternion); } result = ((ofQuaternion const *)arg1)->operator -(); { - ofQuaternion * resultptr = new ofQuaternion((const ofQuaternion &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofQuaternion,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Quaternion___tostring(lua_State* L) { int SWIG_arg = 0; ofQuaternion *arg1 = (ofQuaternion *) 0 ; - char *result = 0 ; SWIG_check_num_args("ofQuaternion::__str__",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofQuaternion::__str__",1,"ofQuaternion *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofQuaternion,0))){ - SWIG_fail_ptr("Quaternion___tostring",1,SWIGTYPE_p_ofQuaternion); } result = (char *)ofQuaternion___str__(arg1); - lua_pushstring(L,(const char *)result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_Quaternion(void *obj) { -ofQuaternion *arg1 = (ofQuaternion *) obj; -delete arg1; -} -static int _proxy__wrap_new_Quaternion(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_Quaternion); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_Quaternion_attributes[] = { - { "_v", _wrap_Quaternion__v_get, _wrap_Quaternion__v_set }, - {0,0,0} -}; -static swig_lua_method swig_Quaternion_methods[]= { - { "set", _wrap_Quaternion_set}, - { "get", _wrap_Quaternion_get}, - { "x", _wrap_Quaternion_x}, - { "y", _wrap_Quaternion_y}, - { "z", _wrap_Quaternion_z}, - { "w", _wrap_Quaternion_w}, - { "asVec4", _wrap_Quaternion_asVec4}, - { "asVec3", _wrap_Quaternion_asVec3}, - { "zeroRotation", _wrap_Quaternion_zeroRotation}, - { "length", _wrap_Quaternion_length}, - { "length2", _wrap_Quaternion_length2}, - { "conj", _wrap_Quaternion_conj}, - { "inverse", _wrap_Quaternion_inverse}, - { "makeRotate", _wrap_Quaternion_makeRotate}, - { "makeRotate_original", _wrap_Quaternion_makeRotate_original}, - { "getRotate", _wrap_Quaternion_getRotate}, - { "getEuler", _wrap_Quaternion_getEuler}, - { "slerp", _wrap_Quaternion_slerp}, - { "normalize", _wrap_Quaternion_normalize}, - { "__eq", _wrap_Quaternion___eq}, - { "__mul", _wrap_Quaternion___mul}, - { "__div", _wrap_Quaternion___div}, - { "__add", _wrap_Quaternion___add}, - { "__sub", _wrap_Quaternion___sub}, - { "__unm", _wrap_Quaternion___unm}, - { "__tostring", _wrap_Quaternion___tostring}, - {0,0} -}; -static swig_lua_method swig_Quaternion_meta[] = { - { "__eq", _wrap_Quaternion___eq}, - { "__mul", _wrap_Quaternion___mul}, - { "__div", _wrap_Quaternion___div}, - { "__add", _wrap_Quaternion___add}, - { "__sub", _wrap_Quaternion___sub}, - { "__unm", _wrap_Quaternion___unm}, - { "__tostring", _wrap_Quaternion___tostring}, - {0,0} -}; - -static swig_lua_attribute swig_Quaternion_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_Quaternion_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_Quaternion_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_Quaternion_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_Quaternion_Sf_SwigStatic = { - "Quaternion", - swig_Quaternion_Sf_SwigStatic_methods, - swig_Quaternion_Sf_SwigStatic_attributes, - swig_Quaternion_Sf_SwigStatic_constants, - swig_Quaternion_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_Quaternion_bases[] = {0}; -static const char *swig_Quaternion_base_names[] = {0}; -static swig_lua_class _wrap_class_Quaternion = { "Quaternion", "Quaternion", &SWIGTYPE_p_ofQuaternion,_proxy__wrap_new_Quaternion, swig_delete_Quaternion, swig_Quaternion_methods, swig_Quaternion_attributes, &swig_Quaternion_Sf_SwigStatic, swig_Quaternion_meta, swig_Quaternion_bases, swig_Quaternion_base_names }; - -static int _wrap_Vec2f_x_set(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; float arg2 ; - SWIG_check_num_args("ofVec2f::x",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::x",1,"ofVec2f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec2f::x",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_x_set",1,SWIGTYPE_p_ofVec2f); } - arg2 = (float)lua_tonumber(L, 2); if (arg1) (arg1)->x = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec2f_x_get(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; float result; - SWIG_check_num_args("ofVec2f::x",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::x",1,"ofVec2f *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_x_get",1,SWIGTYPE_p_ofVec2f); } - result = (float) ((arg1)->x); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_y_set(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; float arg2 ; - SWIG_check_num_args("ofVec2f::y",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::y",1,"ofVec2f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec2f::y",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_y_set",1,SWIGTYPE_p_ofVec2f); } - arg2 = (float)lua_tonumber(L, 2); if (arg1) (arg1)->y = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec2f_y_get(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; float result; - SWIG_check_num_args("ofVec2f::y",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::y",1,"ofVec2f *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_y_get",1,SWIGTYPE_p_ofVec2f); } - result = (float) ((arg1)->y); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_Vec2f__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec2f *result = 0 ; - SWIG_check_num_args("ofVec2f::ofVec2f",0,0) result = (ofVec2f *)new ofVec2f(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Vec2f__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; ofVec2f *result = 0 ; - SWIG_check_num_args("ofVec2f::ofVec2f",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofVec2f::ofVec2f",1,"float"); - arg1 = (float)lua_tonumber(L, 1); result = (ofVec2f *)new ofVec2f(arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Vec2f__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; ofVec2f *result = 0 ; - SWIG_check_num_args("ofVec2f::ofVec2f",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofVec2f::ofVec2f",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec2f::ofVec2f",2,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); result = (ofVec2f *)new ofVec2f(arg1,arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Vec2f__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = 0 ; ofVec2f *result = 0 ; - SWIG_check_num_args("ofVec2f::ofVec2f",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofVec2f::ofVec2f",1,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("new_Vec2f",1,SWIGTYPE_p_ofVec3f); } - result = (ofVec2f *)new ofVec2f((ofVec3f const &)*arg1); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_new_Vec2f__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = 0 ; ofVec2f *result = 0 ; - SWIG_check_num_args("ofVec2f::ofVec2f",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofVec2f::ofVec2f",1,"ofVec4f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("new_Vec2f",1,SWIGTYPE_p_ofVec4f); } - result = (ofVec2f *)new ofVec2f((ofVec4f const &)*arg1); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_new_Vec2f(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_Vec2f__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_new_Vec2f__SWIG_3(L);} } if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_new_Vec2f__SWIG_4(L);} } if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_new_Vec2f__SWIG_1(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_new_Vec2f__SWIG_2(L);} - } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_Vec2f'\n" - " Possible C/C++ prototypes are:\n" " ofVec2f::ofVec2f()\n" " ofVec2f::ofVec2f(float)\n" - " ofVec2f::ofVec2f(float,float)\n" " ofVec2f::ofVec2f(ofVec3f const &)\n" " ofVec2f::ofVec2f(ofVec4f const &)\n"); - lua_error(L);return 0; } -static int _wrap_Vec2f_getPtr__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; float *result = 0 ; - SWIG_check_num_args("ofVec2f::getPtr",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::getPtr",1,"ofVec2f *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_getPtr",1,SWIGTYPE_p_ofVec2f); } - result = (float *)(arg1)->getPtr(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_float,0); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_getPtr__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; float *result = 0 ; - SWIG_check_num_args("ofVec2f::getPtr",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::getPtr",1,"ofVec2f const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_getPtr",1,SWIGTYPE_p_ofVec2f); } - result = (float *)((ofVec2f const *)arg1)->getPtr(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_float,0); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_getPtr(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Vec2f_getPtr__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Vec2f_getPtr__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec2f_getPtr'\n" " Possible C/C++ prototypes are:\n" - " ofVec2f::getPtr()\n" " ofVec2f::getPtr() const\n"); lua_error(L);return 0; } -static int _wrap_Vec2f_set__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofVec2f::set",3,3) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::set",1,"ofVec2f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec2f::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVec2f::set",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_set",1,SWIGTYPE_p_ofVec2f); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); (arg1)->set(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_set__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f *arg2 = 0 ; - SWIG_check_num_args("ofVec2f::set",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::set",1,"ofVec2f *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec2f::set",2,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_set",1,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_set",2,SWIGTYPE_p_ofVec2f); } - (arg1)->set((ofVec2f const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_set__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; float arg2 ; - SWIG_check_num_args("ofVec2f::set",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::set",1,"ofVec2f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec2f::set",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_set",1,SWIGTYPE_p_ofVec2f); } - arg2 = (float)lua_tonumber(L, 2); (arg1)->set(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_set(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec2f_set__SWIG_1(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Vec2f_set__SWIG_2(L);} } } - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Vec2f_set__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec2f_set'\n" " Possible C/C++ prototypes are:\n" - " ofVec2f::set(float,float)\n" " ofVec2f::set(ofVec2f const &)\n" " ofVec2f::set(float)\n"); lua_error(L);return 0; } -static int _wrap_Vec2f___eq(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f *arg2 = 0 ; bool result; - SWIG_check_num_args("ofVec2f::operator ==",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::operator ==",1,"ofVec2f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec2f::operator ==",2,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f___eq",1,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f___eq",2,SWIGTYPE_p_ofVec2f); } - result = (bool)((ofVec2f const *)arg1)->operator ==((ofVec2f const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_match__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f *arg2 = 0 ; - float arg3 ; bool result; SWIG_check_num_args("ofVec2f::match",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::match",1,"ofVec2f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec2f::match",2,"ofVec2f const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVec2f::match",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_match",1,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_match",2,SWIGTYPE_p_ofVec2f); } - arg3 = (float)lua_tonumber(L, 3); result = (bool)((ofVec2f const *)arg1)->match((ofVec2f const &)*arg2,arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_match__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f *arg2 = 0 ; - bool result; SWIG_check_num_args("ofVec2f::match",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::match",1,"ofVec2f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec2f::match",2,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_match",1,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_match",2,SWIGTYPE_p_ofVec2f); } - result = (bool)((ofVec2f const *)arg1)->match((ofVec2f const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_match(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec2f_match__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Vec2f_match__SWIG_0(L);} } } - } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec2f_match'\n" " Possible C/C++ prototypes are:\n" - " ofVec2f::match(ofVec2f const &,float) const\n" " ofVec2f::match(ofVec2f const &) const\n"); lua_error(L);return 0; } -static int _wrap_Vec2f_isAligned__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f *arg2 = 0 ; - float arg3 ; bool result; SWIG_check_num_args("ofVec2f::isAligned",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::isAligned",1,"ofVec2f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec2f::isAligned",2,"ofVec2f const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVec2f::isAligned",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_isAligned",1,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_isAligned",2,SWIGTYPE_p_ofVec2f); } arg3 = (float)lua_tonumber(L, 3); - result = (bool)((ofVec2f const *)arg1)->isAligned((ofVec2f const &)*arg2,arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_isAligned__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f *arg2 = 0 ; - bool result; SWIG_check_num_args("ofVec2f::isAligned",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::isAligned",1,"ofVec2f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec2f::isAligned",2,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_isAligned",1,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_isAligned",2,SWIGTYPE_p_ofVec2f); } - result = (bool)((ofVec2f const *)arg1)->isAligned((ofVec2f const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_isAligned(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec2f_isAligned__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Vec2f_isAligned__SWIG_0(L);} } - } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec2f_isAligned'\n" - " Possible C/C++ prototypes are:\n" " ofVec2f::isAligned(ofVec2f const &,float) const\n" - " ofVec2f::isAligned(ofVec2f const &) const\n"); lua_error(L);return 0; } -static int _wrap_Vec2f_isAlignedRad__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; - ofVec2f *arg2 = 0 ; float arg3 ; bool result; SWIG_check_num_args("ofVec2f::isAlignedRad",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::isAlignedRad",1,"ofVec2f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec2f::isAlignedRad",2,"ofVec2f const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVec2f::isAlignedRad",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_isAlignedRad",1,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_isAlignedRad",2,SWIGTYPE_p_ofVec2f); } arg3 = (float)lua_tonumber(L, 3); - result = (bool)((ofVec2f const *)arg1)->isAlignedRad((ofVec2f const &)*arg2,arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_isAlignedRad__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; - ofVec2f *arg2 = 0 ; bool result; SWIG_check_num_args("ofVec2f::isAlignedRad",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::isAlignedRad",1,"ofVec2f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec2f::isAlignedRad",2,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_isAlignedRad",1,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_isAlignedRad",2,SWIGTYPE_p_ofVec2f); } - result = (bool)((ofVec2f const *)arg1)->isAlignedRad((ofVec2f const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_isAlignedRad(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec2f_isAlignedRad__SWIG_1(L);} } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Vec2f_isAlignedRad__SWIG_0(L);} - } } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec2f_isAlignedRad'\n" - " Possible C/C++ prototypes are:\n" " ofVec2f::isAlignedRad(ofVec2f const &,float) const\n" - " ofVec2f::isAlignedRad(ofVec2f const &) const\n"); lua_error(L);return 0; } -static int _wrap_Vec2f_align__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f *arg2 = 0 ; - float arg3 ; bool result; SWIG_check_num_args("ofVec2f::align",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::align",1,"ofVec2f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec2f::align",2,"ofVec2f const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVec2f::align",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_align",1,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_align",2,SWIGTYPE_p_ofVec2f); } - arg3 = (float)lua_tonumber(L, 3); result = (bool)((ofVec2f const *)arg1)->align((ofVec2f const &)*arg2,arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_align__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f *arg2 = 0 ; - bool result; SWIG_check_num_args("ofVec2f::align",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::align",1,"ofVec2f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec2f::align",2,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_align",1,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_align",2,SWIGTYPE_p_ofVec2f); } - result = (bool)((ofVec2f const *)arg1)->align((ofVec2f const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_align(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec2f_align__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Vec2f_align__SWIG_0(L);} } } - } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec2f_align'\n" " Possible C/C++ prototypes are:\n" - " ofVec2f::align(ofVec2f const &,float) const\n" " ofVec2f::align(ofVec2f const &) const\n"); lua_error(L);return 0; } -static int _wrap_Vec2f_alignRad__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f *arg2 = 0 ; - float arg3 ; bool result; SWIG_check_num_args("ofVec2f::alignRad",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::alignRad",1,"ofVec2f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec2f::alignRad",2,"ofVec2f const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVec2f::alignRad",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_alignRad",1,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_alignRad",2,SWIGTYPE_p_ofVec2f); } arg3 = (float)lua_tonumber(L, 3); - result = (bool)((ofVec2f const *)arg1)->alignRad((ofVec2f const &)*arg2,arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_alignRad__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f *arg2 = 0 ; - bool result; SWIG_check_num_args("ofVec2f::alignRad",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::alignRad",1,"ofVec2f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec2f::alignRad",2,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_alignRad",1,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_alignRad",2,SWIGTYPE_p_ofVec2f); } - result = (bool)((ofVec2f const *)arg1)->alignRad((ofVec2f const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_alignRad(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec2f_alignRad__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Vec2f_alignRad__SWIG_0(L);} } - } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec2f_alignRad'\n" - " Possible C/C++ prototypes are:\n" " ofVec2f::alignRad(ofVec2f const &,float) const\n" - " ofVec2f::alignRad(ofVec2f const &) const\n"); lua_error(L);return 0; } -static int _wrap_Vec2f___add__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f *arg2 = 0 ; - ofVec2f result; SWIG_check_num_args("ofVec2f::operator +",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::operator +",1,"ofVec2f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec2f::operator +",2,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f___add",1,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f___add",2,SWIGTYPE_p_ofVec2f); } - result = ((ofVec2f const *)arg1)->operator +((ofVec2f const &)*arg2); { - ofVec2f * resultptr = new ofVec2f((const ofVec2f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f___add__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; float arg2 ; - ofVec2f result; SWIG_check_num_args("ofVec2f::operator +",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::operator +",1,"ofVec2f const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec2f::operator +",2,"float const"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f___add",1,SWIGTYPE_p_ofVec2f); } - arg2 = (float const)lua_tonumber(L, 2); result = ((ofVec2f const *)arg1)->operator +(arg2); { - ofVec2f * resultptr = new ofVec2f((const ofVec2f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f___add(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec2f___add__SWIG_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Vec2f___add__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec2f___add'\n" " Possible C/C++ prototypes are:\n" - " ofVec2f::operator +(ofVec2f const &) const\n" " ofVec2f::operator +(float const) const\n"); lua_error(L);return 0; } -static int _wrap_Vec2f___sub__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f *arg2 = 0 ; - ofVec2f result; SWIG_check_num_args("ofVec2f::operator -",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::operator -",1,"ofVec2f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec2f::operator -",2,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f___sub",1,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f___sub",2,SWIGTYPE_p_ofVec2f); } - result = ((ofVec2f const *)arg1)->operator -((ofVec2f const &)*arg2); { - ofVec2f * resultptr = new ofVec2f((const ofVec2f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f___sub__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; float arg2 ; - ofVec2f result; SWIG_check_num_args("ofVec2f::operator -",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::operator -",1,"ofVec2f const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec2f::operator -",2,"float const"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f___sub",1,SWIGTYPE_p_ofVec2f); } - arg2 = (float const)lua_tonumber(L, 2); result = ((ofVec2f const *)arg1)->operator -(arg2); { - ofVec2f * resultptr = new ofVec2f((const ofVec2f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f___sub(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec2f___sub__SWIG_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Vec2f___sub__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec2f___sub'\n" " Possible C/C++ prototypes are:\n" - " ofVec2f::operator -(ofVec2f const &) const\n" " ofVec2f::operator -(float const) const\n"); lua_error(L);return 0; } -static int _wrap_Vec2f___unm(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f result; - SWIG_check_num_args("ofVec2f::operator -",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::operator -",1,"ofVec2f const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f___unm",1,SWIGTYPE_p_ofVec2f); } - result = ((ofVec2f const *)arg1)->operator -(); { ofVec2f * resultptr = new ofVec2f((const ofVec2f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f___mul__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f *arg2 = 0 ; - ofVec2f result; SWIG_check_num_args("ofVec2f::operator *",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::operator *",1,"ofVec2f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec2f::operator *",2,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f___mul",1,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f___mul",2,SWIGTYPE_p_ofVec2f); } - result = ((ofVec2f const *)arg1)->operator *((ofVec2f const &)*arg2); { - ofVec2f * resultptr = new ofVec2f((const ofVec2f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f___mul__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; float arg2 ; - ofVec2f result; SWIG_check_num_args("ofVec2f::operator *",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::operator *",1,"ofVec2f const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec2f::operator *",2,"float const"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f___mul",1,SWIGTYPE_p_ofVec2f); } - arg2 = (float const)lua_tonumber(L, 2); result = ((ofVec2f const *)arg1)->operator *(arg2); { - ofVec2f * resultptr = new ofVec2f((const ofVec2f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f___mul(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec2f___mul__SWIG_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Vec2f___mul__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec2f___mul'\n" " Possible C/C++ prototypes are:\n" - " ofVec2f::operator *(ofVec2f const &) const\n" " ofVec2f::operator *(float const) const\n"); lua_error(L);return 0; } -static int _wrap_Vec2f___div__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f *arg2 = 0 ; - ofVec2f result; SWIG_check_num_args("ofVec2f::operator /",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::operator /",1,"ofVec2f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec2f::operator /",2,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f___div",1,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f___div",2,SWIGTYPE_p_ofVec2f); } - result = ((ofVec2f const *)arg1)->operator /((ofVec2f const &)*arg2); { - ofVec2f * resultptr = new ofVec2f((const ofVec2f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f___div__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; float arg2 ; - ofVec2f result; SWIG_check_num_args("ofVec2f::operator /",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::operator /",1,"ofVec2f const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec2f::operator /",2,"float const"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f___div",1,SWIGTYPE_p_ofVec2f); } - arg2 = (float const)lua_tonumber(L, 2); result = ((ofVec2f const *)arg1)->operator /(arg2); { - ofVec2f * resultptr = new ofVec2f((const ofVec2f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f___div(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec2f___div__SWIG_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Vec2f___div__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec2f___div'\n" " Possible C/C++ prototypes are:\n" - " ofVec2f::operator /(ofVec2f const &) const\n" " ofVec2f::operator /(float const) const\n"); lua_error(L);return 0; } -static int _wrap_Vec2f_getScaled(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; float arg2 ; ofVec2f result; - SWIG_check_num_args("ofVec2f::getScaled",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::getScaled",1,"ofVec2f const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec2f::getScaled",2,"float const"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_getScaled",1,SWIGTYPE_p_ofVec2f); } arg2 = (float const)lua_tonumber(L, 2); - result = ((ofVec2f const *)arg1)->getScaled(arg2); { ofVec2f * resultptr = new ofVec2f((const ofVec2f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_scale(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; float arg2 ; - ofVec2f *result = 0 ; SWIG_check_num_args("ofVec2f::scale",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::scale",1,"ofVec2f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec2f::scale",2,"float const"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_scale",1,SWIGTYPE_p_ofVec2f); } - arg2 = (float const)lua_tonumber(L, 2); result = (ofVec2f *) &(arg1)->scale(arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec2f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec2f_getRotated__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; float arg2 ; - ofVec2f result; SWIG_check_num_args("ofVec2f::getRotated",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::getRotated",1,"ofVec2f const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec2f::getRotated",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_getRotated",1,SWIGTYPE_p_ofVec2f); } arg2 = (float)lua_tonumber(L, 2); - result = ((ofVec2f const *)arg1)->getRotated(arg2); { ofVec2f * resultptr = new ofVec2f((const ofVec2f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_getRotated__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; float arg2 ; - ofVec2f *arg3 = 0 ; ofVec2f result; SWIG_check_num_args("ofVec2f::getRotated",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::getRotated",1,"ofVec2f const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec2f::getRotated",2,"float"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofVec2f::getRotated",3,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_getRotated",1,SWIGTYPE_p_ofVec2f); } arg2 = (float)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_getRotated",3,SWIGTYPE_p_ofVec2f); } - result = ((ofVec2f const *)arg1)->getRotated(arg2,(ofVec2f const &)*arg3); { - ofVec2f * resultptr = new ofVec2f((const ofVec2f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_getRotated(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Vec2f_getRotated__SWIG_0(L);} } } - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec2f_getRotated__SWIG_1(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec2f_getRotated'\n" " Possible C/C++ prototypes are:\n" - " ofVec2f::getRotated(float) const\n" " ofVec2f::getRotated(float,ofVec2f const &) const\n"); lua_error(L);return 0; } -static int _wrap_Vec2f_getRotatedRad__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; float arg2 ; - ofVec2f result; SWIG_check_num_args("ofVec2f::getRotatedRad",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::getRotatedRad",1,"ofVec2f const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec2f::getRotatedRad",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_getRotatedRad",1,SWIGTYPE_p_ofVec2f); } arg2 = (float)lua_tonumber(L, 2); - result = ((ofVec2f const *)arg1)->getRotatedRad(arg2); { ofVec2f * resultptr = new ofVec2f((const ofVec2f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_getRotatedRad__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; float arg2 ; - ofVec2f *arg3 = 0 ; ofVec2f result; SWIG_check_num_args("ofVec2f::getRotatedRad",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::getRotatedRad",1,"ofVec2f const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec2f::getRotatedRad",2,"float"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofVec2f::getRotatedRad",3,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_getRotatedRad",1,SWIGTYPE_p_ofVec2f); } arg2 = (float)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_getRotatedRad",3,SWIGTYPE_p_ofVec2f); } - result = ((ofVec2f const *)arg1)->getRotatedRad(arg2,(ofVec2f const &)*arg3); { - ofVec2f * resultptr = new ofVec2f((const ofVec2f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_getRotatedRad(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Vec2f_getRotatedRad__SWIG_0(L);} } } - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec2f_getRotatedRad__SWIG_1(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec2f_getRotatedRad'\n" - " Possible C/C++ prototypes are:\n" " ofVec2f::getRotatedRad(float) const\n" - " ofVec2f::getRotatedRad(float,ofVec2f const &) const\n"); lua_error(L);return 0; } -static int _wrap_Vec2f_rotate__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; float arg2 ; - ofVec2f *result = 0 ; SWIG_check_num_args("ofVec2f::rotate",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::rotate",1,"ofVec2f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec2f::rotate",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_rotate",1,SWIGTYPE_p_ofVec2f); } - arg2 = (float)lua_tonumber(L, 2); result = (ofVec2f *) &(arg1)->rotate(arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec2f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec2f_rotate__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; float arg2 ; - ofVec2f *arg3 = 0 ; ofVec2f *result = 0 ; SWIG_check_num_args("ofVec2f::rotate",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::rotate",1,"ofVec2f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec2f::rotate",2,"float"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofVec2f::rotate",3,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_rotate",1,SWIGTYPE_p_ofVec2f); } - arg2 = (float)lua_tonumber(L, 2); if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_rotate",3,SWIGTYPE_p_ofVec2f); } result = (ofVec2f *) &(arg1)->rotate(arg2,(ofVec2f const &)*arg3); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec2f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec2f_rotate(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Vec2f_rotate__SWIG_0(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec2f_rotate__SWIG_1(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec2f_rotate'\n" " Possible C/C++ prototypes are:\n" - " ofVec2f::rotate(float)\n" " ofVec2f::rotate(float,ofVec2f const &)\n"); lua_error(L);return 0; } -static int _wrap_Vec2f_rotateRad__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; float arg2 ; - ofVec2f *result = 0 ; SWIG_check_num_args("ofVec2f::rotateRad",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::rotateRad",1,"ofVec2f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec2f::rotateRad",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_rotateRad",1,SWIGTYPE_p_ofVec2f); } arg2 = (float)lua_tonumber(L, 2); - result = (ofVec2f *) &(arg1)->rotateRad(arg2); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec2f,0); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_rotateRad__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; float arg2 ; - ofVec2f *arg3 = 0 ; ofVec2f *result = 0 ; SWIG_check_num_args("ofVec2f::rotateRad",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::rotateRad",1,"ofVec2f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec2f::rotateRad",2,"float"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofVec2f::rotateRad",3,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_rotateRad",1,SWIGTYPE_p_ofVec2f); } arg2 = (float)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_rotateRad",3,SWIGTYPE_p_ofVec2f); } - result = (ofVec2f *) &(arg1)->rotateRad(arg2,(ofVec2f const &)*arg3); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec2f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec2f_rotateRad(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Vec2f_rotateRad__SWIG_0(L);} } } - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec2f_rotateRad__SWIG_1(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec2f_rotateRad'\n" " Possible C/C++ prototypes are:\n" - " ofVec2f::rotateRad(float)\n" " ofVec2f::rotateRad(float,ofVec2f const &)\n"); lua_error(L);return 0; } -static int _wrap_Vec2f_getMapped(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f *arg2 = 0 ; - ofVec2f *arg3 = 0 ; ofVec2f *arg4 = 0 ; ofVec2f result; SWIG_check_num_args("ofVec2f::getMapped",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::getMapped",1,"ofVec2f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec2f::getMapped",2,"ofVec2f const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofVec2f::getMapped",3,"ofVec2f const &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofVec2f::getMapped",4,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_getMapped",1,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_getMapped",2,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_getMapped",3,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_getMapped",4,SWIGTYPE_p_ofVec2f); } - result = ((ofVec2f const *)arg1)->getMapped((ofVec2f const &)*arg2,(ofVec2f const &)*arg3,(ofVec2f const &)*arg4); { - ofVec2f * resultptr = new ofVec2f((const ofVec2f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_map(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f *arg2 = 0 ; - ofVec2f *arg3 = 0 ; ofVec2f *arg4 = 0 ; ofVec2f *result = 0 ; SWIG_check_num_args("ofVec2f::map",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::map",1,"ofVec2f *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec2f::map",2,"ofVec2f const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofVec2f::map",3,"ofVec2f const &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofVec2f::map",4,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_map",1,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_map",2,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_map",3,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_map",4,SWIGTYPE_p_ofVec2f); } - result = (ofVec2f *) &(arg1)->map((ofVec2f const &)*arg2,(ofVec2f const &)*arg3,(ofVec2f const &)*arg4); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec2f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec2f_distance(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f *arg2 = 0 ; - float result; SWIG_check_num_args("ofVec2f::distance",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::distance",1,"ofVec2f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec2f::distance",2,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_distance",1,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_distance",2,SWIGTYPE_p_ofVec2f); } - result = (float)((ofVec2f const *)arg1)->distance((ofVec2f const &)*arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_squareDistance(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f *arg2 = 0 ; - float result; SWIG_check_num_args("ofVec2f::squareDistance",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::squareDistance",1,"ofVec2f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec2f::squareDistance",2,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_squareDistance",1,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_squareDistance",2,SWIGTYPE_p_ofVec2f); } - result = (float)((ofVec2f const *)arg1)->squareDistance((ofVec2f const &)*arg2); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_getInterpolated(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f *arg2 = 0 ; - float arg3 ; ofVec2f result; SWIG_check_num_args("ofVec2f::getInterpolated",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::getInterpolated",1,"ofVec2f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec2f::getInterpolated",2,"ofVec2f const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVec2f::getInterpolated",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_getInterpolated",1,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_getInterpolated",2,SWIGTYPE_p_ofVec2f); } arg3 = (float)lua_tonumber(L, 3); - result = ((ofVec2f const *)arg1)->getInterpolated((ofVec2f const &)*arg2,arg3); { - ofVec2f * resultptr = new ofVec2f((const ofVec2f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_interpolate(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f *arg2 = 0 ; - float arg3 ; ofVec2f *result = 0 ; SWIG_check_num_args("ofVec2f::interpolate",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::interpolate",1,"ofVec2f *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec2f::interpolate",2,"ofVec2f const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVec2f::interpolate",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_interpolate",1,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_interpolate",2,SWIGTYPE_p_ofVec2f); } arg3 = (float)lua_tonumber(L, 3); - result = (ofVec2f *) &(arg1)->interpolate((ofVec2f const &)*arg2,arg3); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec2f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec2f_getMiddle(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f *arg2 = 0 ; - ofVec2f result; SWIG_check_num_args("ofVec2f::getMiddle",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::getMiddle",1,"ofVec2f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec2f::getMiddle",2,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_getMiddle",1,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_getMiddle",2,SWIGTYPE_p_ofVec2f); } - result = ((ofVec2f const *)arg1)->getMiddle((ofVec2f const &)*arg2); { - ofVec2f * resultptr = new ofVec2f((const ofVec2f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_middle(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f *arg2 = 0 ; - ofVec2f *result = 0 ; SWIG_check_num_args("ofVec2f::middle",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::middle",1,"ofVec2f *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec2f::middle",2,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_middle",1,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_middle",2,SWIGTYPE_p_ofVec2f); } result = (ofVec2f *) &(arg1)->middle((ofVec2f const &)*arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec2f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec2f_average(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f *arg2 = (ofVec2f *) 0 ; - std::size_t arg3 ; ofVec2f *result = 0 ; SWIG_check_num_args("ofVec2f::average",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::average",1,"ofVec2f *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofVec2f::average",2,"ofVec2f const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVec2f::average",3,"std::size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_average",1,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_average",2,SWIGTYPE_p_ofVec2f); } - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (std::size_t)lua_tonumber(L, 3); - result = (ofVec2f *) &(arg1)->average((ofVec2f const *)arg2,arg3); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec2f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec2f_getNormalized(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f result; - SWIG_check_num_args("ofVec2f::getNormalized",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::getNormalized",1,"ofVec2f const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_getNormalized",1,SWIGTYPE_p_ofVec2f); } result = ((ofVec2f const *)arg1)->getNormalized(); { - ofVec2f * resultptr = new ofVec2f((const ofVec2f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_normalize(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f *result = 0 ; - SWIG_check_num_args("ofVec2f::normalize",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::normalize",1,"ofVec2f *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_normalize",1,SWIGTYPE_p_ofVec2f); } result = (ofVec2f *) &(arg1)->normalize(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec2f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec2f_getLimited(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; float arg2 ; ofVec2f result; - SWIG_check_num_args("ofVec2f::getLimited",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::getLimited",1,"ofVec2f const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec2f::getLimited",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_getLimited",1,SWIGTYPE_p_ofVec2f); } arg2 = (float)lua_tonumber(L, 2); - result = ((ofVec2f const *)arg1)->getLimited(arg2); { ofVec2f * resultptr = new ofVec2f((const ofVec2f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_limit(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; float arg2 ; - ofVec2f *result = 0 ; SWIG_check_num_args("ofVec2f::limit",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::limit",1,"ofVec2f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec2f::limit",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_limit",1,SWIGTYPE_p_ofVec2f); } - arg2 = (float)lua_tonumber(L, 2); result = (ofVec2f *) &(arg1)->limit(arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec2f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec2f_length(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; float result; - SWIG_check_num_args("ofVec2f::length",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::length",1,"ofVec2f const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_length",1,SWIGTYPE_p_ofVec2f); } - result = (float)((ofVec2f const *)arg1)->length(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_lengthSquared(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; float result; - SWIG_check_num_args("ofVec2f::lengthSquared",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::lengthSquared",1,"ofVec2f const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_lengthSquared",1,SWIGTYPE_p_ofVec2f); } result = (float)((ofVec2f const *)arg1)->lengthSquared(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_angle(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f *arg2 = 0 ; float result; - SWIG_check_num_args("ofVec2f::angle",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::angle",1,"ofVec2f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec2f::angle",2,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_angle",1,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_angle",2,SWIGTYPE_p_ofVec2f); } - result = (float)((ofVec2f const *)arg1)->angle((ofVec2f const &)*arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_angleRad(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f *arg2 = 0 ; - float result; SWIG_check_num_args("ofVec2f::angleRad",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::angleRad",1,"ofVec2f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec2f::angleRad",2,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_angleRad",1,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_angleRad",2,SWIGTYPE_p_ofVec2f); } - result = (float)((ofVec2f const *)arg1)->angleRad((ofVec2f const &)*arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_getPerpendicular(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f result; - SWIG_check_num_args("ofVec2f::getPerpendicular",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::getPerpendicular",1,"ofVec2f const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_getPerpendicular",1,SWIGTYPE_p_ofVec2f); } result = ((ofVec2f const *)arg1)->getPerpendicular(); { - ofVec2f * resultptr = new ofVec2f((const ofVec2f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_perpendicular(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f *result = 0 ; - SWIG_check_num_args("ofVec2f::perpendicular",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::perpendicular",1,"ofVec2f *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f_perpendicular",1,SWIGTYPE_p_ofVec2f); } result = (ofVec2f *) &(arg1)->perpendicular(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec2f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec2f_dot(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; ofVec2f *arg2 = 0 ; float result; - SWIG_check_num_args("ofVec2f::dot",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::dot",1,"ofVec2f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec2f::dot",2,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_dot",1,SWIGTYPE_p_ofVec2f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("Vec2f_dot",2,SWIGTYPE_p_ofVec2f); } - result = (float)((ofVec2f const *)arg1)->dot((ofVec2f const &)*arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_zero(lua_State* L) { int SWIG_arg = 0; ofVec2f result; SWIG_check_num_args("ofVec2f::zero",0,0) - result = ofVec2f::zero(); { ofVec2f * resultptr = new ofVec2f((const ofVec2f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f_one(lua_State* L) { int SWIG_arg = 0; ofVec2f result; SWIG_check_num_args("ofVec2f::one",0,0) - result = ofVec2f::one(); { ofVec2f * resultptr = new ofVec2f((const ofVec2f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec2f___tostring(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = (ofVec2f *) 0 ; char *result = 0 ; - SWIG_check_num_args("ofVec2f::__str__",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec2f::__str__",1,"ofVec2f *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vec2f___tostring",1,SWIGTYPE_p_ofVec2f); } result = (char *)ofVec2f___str__(arg1); - lua_pushstring(L,(const char *)result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_Vec2f(void *obj) { -ofVec2f *arg1 = (ofVec2f *) obj; -delete arg1; -} -static int _proxy__wrap_new_Vec2f(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_Vec2f); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_Vec2f_attributes[] = { - { "x", _wrap_Vec2f_x_get, _wrap_Vec2f_x_set }, - { "y", _wrap_Vec2f_y_get, _wrap_Vec2f_y_set }, - {0,0,0} -}; -static swig_lua_method swig_Vec2f_methods[]= { - { "getPtr", _wrap_Vec2f_getPtr}, - { "set", _wrap_Vec2f_set}, - { "__eq", _wrap_Vec2f___eq}, - { "match", _wrap_Vec2f_match}, - { "isAligned", _wrap_Vec2f_isAligned}, - { "isAlignedRad", _wrap_Vec2f_isAlignedRad}, - { "align", _wrap_Vec2f_align}, - { "alignRad", _wrap_Vec2f_alignRad}, - { "__add", _wrap_Vec2f___add}, - { "__sub", _wrap_Vec2f___sub}, - { "__unm", _wrap_Vec2f___unm}, - { "__mul", _wrap_Vec2f___mul}, - { "__div", _wrap_Vec2f___div}, - { "getScaled", _wrap_Vec2f_getScaled}, - { "scale", _wrap_Vec2f_scale}, - { "getRotated", _wrap_Vec2f_getRotated}, - { "getRotatedRad", _wrap_Vec2f_getRotatedRad}, - { "rotate", _wrap_Vec2f_rotate}, - { "rotateRad", _wrap_Vec2f_rotateRad}, - { "getMapped", _wrap_Vec2f_getMapped}, - { "map", _wrap_Vec2f_map}, - { "distance", _wrap_Vec2f_distance}, - { "squareDistance", _wrap_Vec2f_squareDistance}, - { "getInterpolated", _wrap_Vec2f_getInterpolated}, - { "interpolate", _wrap_Vec2f_interpolate}, - { "getMiddle", _wrap_Vec2f_getMiddle}, - { "middle", _wrap_Vec2f_middle}, - { "average", _wrap_Vec2f_average}, - { "getNormalized", _wrap_Vec2f_getNormalized}, - { "normalize", _wrap_Vec2f_normalize}, - { "getLimited", _wrap_Vec2f_getLimited}, - { "limit", _wrap_Vec2f_limit}, - { "length", _wrap_Vec2f_length}, - { "lengthSquared", _wrap_Vec2f_lengthSquared}, - { "angle", _wrap_Vec2f_angle}, - { "angleRad", _wrap_Vec2f_angleRad}, - { "getPerpendicular", _wrap_Vec2f_getPerpendicular}, - { "perpendicular", _wrap_Vec2f_perpendicular}, - { "dot", _wrap_Vec2f_dot}, - { "__tostring", _wrap_Vec2f___tostring}, - {0,0} -}; -static swig_lua_method swig_Vec2f_meta[] = { - { "__eq", _wrap_Vec2f___eq}, - { "__add", _wrap_Vec2f___add}, - { "__sub", _wrap_Vec2f___sub}, - { "__unm", _wrap_Vec2f___unm}, - { "__mul", _wrap_Vec2f___mul}, - { "__div", _wrap_Vec2f___div}, - { "__tostring", _wrap_Vec2f___tostring}, - {0,0} -}; - -static swig_lua_attribute swig_Vec2f_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_Vec2f_Sf_SwigStatic_constants[]= { - {SWIG_LUA_CONSTTAB_INT("DIM", ofVec2f::DIM)}, - {0,0,0,0,0,0} -}; -static swig_lua_method swig_Vec2f_Sf_SwigStatic_methods[]= { - { "zero", _wrap_Vec2f_zero}, - { "one", _wrap_Vec2f_one}, - {0,0} -}; -static swig_lua_class* swig_Vec2f_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_Vec2f_Sf_SwigStatic = { - "Vec2f", - swig_Vec2f_Sf_SwigStatic_methods, - swig_Vec2f_Sf_SwigStatic_attributes, - swig_Vec2f_Sf_SwigStatic_constants, - swig_Vec2f_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_Vec2f_bases[] = {0}; -static const char *swig_Vec2f_base_names[] = {0}; -static swig_lua_class _wrap_class_Vec2f = { "Vec2f", "Vec2f", &SWIGTYPE_p_ofVec2f,_proxy__wrap_new_Vec2f, swig_delete_Vec2f, swig_Vec2f_methods, swig_Vec2f_attributes, &swig_Vec2f_Sf_SwigStatic, swig_Vec2f_meta, swig_Vec2f_bases, swig_Vec2f_base_names }; - -static int _wrap_Vec3f_x_set(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float arg2 ; - SWIG_check_num_args("ofVec3f::x",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::x",1,"ofVec3f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec3f::x",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_x_set",1,SWIGTYPE_p_ofVec3f); } - arg2 = (float)lua_tonumber(L, 2); if (arg1) (arg1)->x = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec3f_x_get(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float result; - SWIG_check_num_args("ofVec3f::x",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::x",1,"ofVec3f *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_x_get",1,SWIGTYPE_p_ofVec3f); } - result = (float) ((arg1)->x); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_y_set(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float arg2 ; - SWIG_check_num_args("ofVec3f::y",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::y",1,"ofVec3f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec3f::y",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_y_set",1,SWIGTYPE_p_ofVec3f); } - arg2 = (float)lua_tonumber(L, 2); if (arg1) (arg1)->y = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec3f_y_get(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float result; - SWIG_check_num_args("ofVec3f::y",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::y",1,"ofVec3f *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_y_get",1,SWIGTYPE_p_ofVec3f); } - result = (float) ((arg1)->y); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_z_set(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float arg2 ; - SWIG_check_num_args("ofVec3f::z",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::z",1,"ofVec3f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec3f::z",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_z_set",1,SWIGTYPE_p_ofVec3f); } - arg2 = (float)lua_tonumber(L, 2); if (arg1) (arg1)->z = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec3f_z_get(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float result; - SWIG_check_num_args("ofVec3f::z",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::z",1,"ofVec3f *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_z_get",1,SWIGTYPE_p_ofVec3f); } - result = (float) ((arg1)->z); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_Vec3f__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec3f *result = 0 ; - SWIG_check_num_args("ofVec3f::ofVec3f",0,0) result = (ofVec3f *)new ofVec3f(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Vec3f__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; - ofVec3f *result = 0 ; SWIG_check_num_args("ofVec3f::ofVec3f",3,3) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofVec3f::ofVec3f",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec3f::ofVec3f",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVec3f::ofVec3f",3,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); result = (ofVec3f *)new ofVec3f(arg1,arg2,arg3); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Vec3f__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; ofVec3f *result = 0 ; - SWIG_check_num_args("ofVec3f::ofVec3f",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofVec3f::ofVec3f",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec3f::ofVec3f",2,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); result = (ofVec3f *)new ofVec3f(arg1,arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Vec3f__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; ofVec3f *result = 0 ; - SWIG_check_num_args("ofVec3f::ofVec3f",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofVec3f::ofVec3f",1,"float"); - arg1 = (float)lua_tonumber(L, 1); result = (ofVec3f *)new ofVec3f(arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Vec3f__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = 0 ; ofVec3f *result = 0 ; - SWIG_check_num_args("ofVec3f::ofVec3f",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofVec3f::ofVec3f",1,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("new_Vec3f",1,SWIGTYPE_p_ofVec2f); } - result = (ofVec3f *)new ofVec3f((ofVec2f const &)*arg1); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_new_Vec3f__SWIG_5(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = 0 ; ofVec3f *result = 0 ; - SWIG_check_num_args("ofVec3f::ofVec3f",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofVec3f::ofVec3f",1,"ofVec4f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("new_Vec3f",1,SWIGTYPE_p_ofVec4f); } - result = (ofVec3f *)new ofVec3f((ofVec4f const &)*arg1); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_new_Vec3f(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_Vec3f__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_new_Vec3f__SWIG_4(L);} } if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_new_Vec3f__SWIG_5(L);} } if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_new_Vec3f__SWIG_3(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_new_Vec3f__SWIG_2(L);} - } } if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_new_Vec3f__SWIG_1(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_Vec3f'\n" " Possible C/C++ prototypes are:\n" - " ofVec3f::ofVec3f()\n" " ofVec3f::ofVec3f(float,float,float)\n" " ofVec3f::ofVec3f(float,float)\n" - " ofVec3f::ofVec3f(float)\n" " ofVec3f::ofVec3f(ofVec2f const &)\n" " ofVec3f::ofVec3f(ofVec4f const &)\n"); - lua_error(L);return 0; } -static int _wrap_Vec3f_getPtr__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float *result = 0 ; - SWIG_check_num_args("ofVec3f::getPtr",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::getPtr",1,"ofVec3f *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_getPtr",1,SWIGTYPE_p_ofVec3f); } - result = (float *)(arg1)->getPtr(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_float,0); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_getPtr__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float *result = 0 ; - SWIG_check_num_args("ofVec3f::getPtr",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::getPtr",1,"ofVec3f const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_getPtr",1,SWIGTYPE_p_ofVec3f); } - result = (float *)((ofVec3f const *)arg1)->getPtr(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_float,0); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_getPtr(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Vec3f_getPtr__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Vec3f_getPtr__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec3f_getPtr'\n" " Possible C/C++ prototypes are:\n" - " ofVec3f::getPtr()\n" " ofVec3f::getPtr() const\n"); lua_error(L);return 0; } -static int _wrap_Vec3f_set__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float arg2 ; float arg3 ; - float arg4 ; SWIG_check_num_args("ofVec3f::set",4,4) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::set",1,"ofVec3f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec3f::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVec3f::set",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVec3f::set",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_set",1,SWIGTYPE_p_ofVec3f); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - (arg1)->set(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_set__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofVec3f::set",3,3) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::set",1,"ofVec3f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec3f::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVec3f::set",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_set",1,SWIGTYPE_p_ofVec3f); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); (arg1)->set(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_set__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; - SWIG_check_num_args("ofVec3f::set",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::set",1,"ofVec3f *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec3f::set",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_set",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_set",2,SWIGTYPE_p_ofVec3f); } - (arg1)->set((ofVec3f const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_set__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float arg2 ; - SWIG_check_num_args("ofVec3f::set",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::set",1,"ofVec3f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec3f::set",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_set",1,SWIGTYPE_p_ofVec3f); } - arg2 = (float)lua_tonumber(L, 2); (arg1)->set(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_set(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec3f_set__SWIG_2(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Vec3f_set__SWIG_3(L);} } } - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Vec3f_set__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Vec3f_set__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec3f_set'\n" " Possible C/C++ prototypes are:\n" - " ofVec3f::set(float,float,float)\n" " ofVec3f::set(float,float)\n" " ofVec3f::set(ofVec3f const &)\n" - " ofVec3f::set(float)\n"); lua_error(L);return 0; } -static int _wrap_Vec3f___eq(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; bool result; - SWIG_check_num_args("ofVec3f::operator ==",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::operator ==",1,"ofVec3f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec3f::operator ==",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f___eq",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f___eq",2,SWIGTYPE_p_ofVec3f); } - result = (bool)((ofVec3f const *)arg1)->operator ==((ofVec3f const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_match__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; - float arg3 ; bool result; SWIG_check_num_args("ofVec3f::match",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::match",1,"ofVec3f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec3f::match",2,"ofVec3f const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVec3f::match",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_match",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_match",2,SWIGTYPE_p_ofVec3f); } - arg3 = (float)lua_tonumber(L, 3); result = (bool)((ofVec3f const *)arg1)->match((ofVec3f const &)*arg2,arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_match__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; - bool result; SWIG_check_num_args("ofVec3f::match",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::match",1,"ofVec3f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec3f::match",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_match",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_match",2,SWIGTYPE_p_ofVec3f); } - result = (bool)((ofVec3f const *)arg1)->match((ofVec3f const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_match(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec3f_match__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Vec3f_match__SWIG_0(L);} } } - } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec3f_match'\n" " Possible C/C++ prototypes are:\n" - " ofVec3f::match(ofVec3f const &,float) const\n" " ofVec3f::match(ofVec3f const &) const\n"); lua_error(L);return 0; } -static int _wrap_Vec3f_isAligned__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; - float arg3 ; bool result; SWIG_check_num_args("ofVec3f::isAligned",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::isAligned",1,"ofVec3f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec3f::isAligned",2,"ofVec3f const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVec3f::isAligned",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_isAligned",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_isAligned",2,SWIGTYPE_p_ofVec3f); } arg3 = (float)lua_tonumber(L, 3); - result = (bool)((ofVec3f const *)arg1)->isAligned((ofVec3f const &)*arg2,arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_isAligned__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; - bool result; SWIG_check_num_args("ofVec3f::isAligned",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::isAligned",1,"ofVec3f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec3f::isAligned",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_isAligned",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_isAligned",2,SWIGTYPE_p_ofVec3f); } - result = (bool)((ofVec3f const *)arg1)->isAligned((ofVec3f const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_isAligned(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec3f_isAligned__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Vec3f_isAligned__SWIG_0(L);} } - } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec3f_isAligned'\n" - " Possible C/C++ prototypes are:\n" " ofVec3f::isAligned(ofVec3f const &,float) const\n" - " ofVec3f::isAligned(ofVec3f const &) const\n"); lua_error(L);return 0; } -static int _wrap_Vec3f_isAlignedRad__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; - ofVec3f *arg2 = 0 ; float arg3 ; bool result; SWIG_check_num_args("ofVec3f::isAlignedRad",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::isAlignedRad",1,"ofVec3f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec3f::isAlignedRad",2,"ofVec3f const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVec3f::isAlignedRad",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_isAlignedRad",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_isAlignedRad",2,SWIGTYPE_p_ofVec3f); } arg3 = (float)lua_tonumber(L, 3); - result = (bool)((ofVec3f const *)arg1)->isAlignedRad((ofVec3f const &)*arg2,arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_isAlignedRad__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; - ofVec3f *arg2 = 0 ; bool result; SWIG_check_num_args("ofVec3f::isAlignedRad",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::isAlignedRad",1,"ofVec3f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec3f::isAlignedRad",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_isAlignedRad",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_isAlignedRad",2,SWIGTYPE_p_ofVec3f); } - result = (bool)((ofVec3f const *)arg1)->isAlignedRad((ofVec3f const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_isAlignedRad(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec3f_isAlignedRad__SWIG_1(L);} } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Vec3f_isAlignedRad__SWIG_0(L);} - } } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec3f_isAlignedRad'\n" - " Possible C/C++ prototypes are:\n" " ofVec3f::isAlignedRad(ofVec3f const &,float) const\n" - " ofVec3f::isAlignedRad(ofVec3f const &) const\n"); lua_error(L);return 0; } -static int _wrap_Vec3f_align__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; - float arg3 ; bool result; SWIG_check_num_args("ofVec3f::align",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::align",1,"ofVec3f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec3f::align",2,"ofVec3f const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVec3f::align",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_align",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_align",2,SWIGTYPE_p_ofVec3f); } - arg3 = (float)lua_tonumber(L, 3); result = (bool)((ofVec3f const *)arg1)->align((ofVec3f const &)*arg2,arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_align__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; - bool result; SWIG_check_num_args("ofVec3f::align",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::align",1,"ofVec3f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec3f::align",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_align",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_align",2,SWIGTYPE_p_ofVec3f); } - result = (bool)((ofVec3f const *)arg1)->align((ofVec3f const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_align(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec3f_align__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Vec3f_align__SWIG_0(L);} } } - } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec3f_align'\n" " Possible C/C++ prototypes are:\n" - " ofVec3f::align(ofVec3f const &,float) const\n" " ofVec3f::align(ofVec3f const &) const\n"); lua_error(L);return 0; } -static int _wrap_Vec3f_alignRad__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; - float arg3 ; bool result; SWIG_check_num_args("ofVec3f::alignRad",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::alignRad",1,"ofVec3f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec3f::alignRad",2,"ofVec3f const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVec3f::alignRad",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_alignRad",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_alignRad",2,SWIGTYPE_p_ofVec3f); } arg3 = (float)lua_tonumber(L, 3); - result = (bool)((ofVec3f const *)arg1)->alignRad((ofVec3f const &)*arg2,arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_alignRad__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; - bool result; SWIG_check_num_args("ofVec3f::alignRad",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::alignRad",1,"ofVec3f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec3f::alignRad",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_alignRad",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_alignRad",2,SWIGTYPE_p_ofVec3f); } - result = (bool)((ofVec3f const *)arg1)->alignRad((ofVec3f const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_alignRad(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec3f_alignRad__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Vec3f_alignRad__SWIG_0(L);} } - } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec3f_alignRad'\n" - " Possible C/C++ prototypes are:\n" " ofVec3f::alignRad(ofVec3f const &,float) const\n" - " ofVec3f::alignRad(ofVec3f const &) const\n"); lua_error(L);return 0; } -static int _wrap_Vec3f___add__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; - ofVec3f result; SWIG_check_num_args("ofVec3f::operator +",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::operator +",1,"ofVec3f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec3f::operator +",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f___add",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f___add",2,SWIGTYPE_p_ofVec3f); } - result = ((ofVec3f const *)arg1)->operator +((ofVec3f const &)*arg2); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f___add__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float arg2 ; - ofVec3f result; SWIG_check_num_args("ofVec3f::operator +",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::operator +",1,"ofVec3f const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec3f::operator +",2,"float const"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f___add",1,SWIGTYPE_p_ofVec3f); } - arg2 = (float const)lua_tonumber(L, 2); result = ((ofVec3f const *)arg1)->operator +(arg2); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f___add(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec3f___add__SWIG_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Vec3f___add__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec3f___add'\n" " Possible C/C++ prototypes are:\n" - " ofVec3f::operator +(ofVec3f const &) const\n" " ofVec3f::operator +(float const) const\n"); lua_error(L);return 0; } -static int _wrap_Vec3f___sub__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; - ofVec3f result; SWIG_check_num_args("ofVec3f::operator -",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::operator -",1,"ofVec3f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec3f::operator -",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f___sub",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f___sub",2,SWIGTYPE_p_ofVec3f); } - result = ((ofVec3f const *)arg1)->operator -((ofVec3f const &)*arg2); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f___sub__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float arg2 ; - ofVec3f result; SWIG_check_num_args("ofVec3f::operator -",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::operator -",1,"ofVec3f const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec3f::operator -",2,"float const"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f___sub",1,SWIGTYPE_p_ofVec3f); } - arg2 = (float const)lua_tonumber(L, 2); result = ((ofVec3f const *)arg1)->operator -(arg2); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f___sub(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec3f___sub__SWIG_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Vec3f___sub__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec3f___sub'\n" " Possible C/C++ prototypes are:\n" - " ofVec3f::operator -(ofVec3f const &) const\n" " ofVec3f::operator -(float const) const\n"); lua_error(L);return 0; } -static int _wrap_Vec3f___unm(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f result; - SWIG_check_num_args("ofVec3f::operator -",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::operator -",1,"ofVec3f const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f___unm",1,SWIGTYPE_p_ofVec3f); } - result = ((ofVec3f const *)arg1)->operator -(); { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f___mul__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; - ofVec3f result; SWIG_check_num_args("ofVec3f::operator *",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::operator *",1,"ofVec3f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec3f::operator *",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f___mul",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f___mul",2,SWIGTYPE_p_ofVec3f); } - result = ((ofVec3f const *)arg1)->operator *((ofVec3f const &)*arg2); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f___mul__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float arg2 ; - ofVec3f result; SWIG_check_num_args("ofVec3f::operator *",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::operator *",1,"ofVec3f const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec3f::operator *",2,"float const"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f___mul",1,SWIGTYPE_p_ofVec3f); } - arg2 = (float const)lua_tonumber(L, 2); result = ((ofVec3f const *)arg1)->operator *(arg2); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f___mul(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec3f___mul__SWIG_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Vec3f___mul__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec3f___mul'\n" " Possible C/C++ prototypes are:\n" - " ofVec3f::operator *(ofVec3f const &) const\n" " ofVec3f::operator *(float const) const\n"); lua_error(L);return 0; } -static int _wrap_Vec3f___div__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; - ofVec3f result; SWIG_check_num_args("ofVec3f::operator /",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::operator /",1,"ofVec3f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec3f::operator /",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f___div",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f___div",2,SWIGTYPE_p_ofVec3f); } - result = ((ofVec3f const *)arg1)->operator /((ofVec3f const &)*arg2); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f___div__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float arg2 ; - ofVec3f result; SWIG_check_num_args("ofVec3f::operator /",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::operator /",1,"ofVec3f const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec3f::operator /",2,"float const"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f___div",1,SWIGTYPE_p_ofVec3f); } - arg2 = (float const)lua_tonumber(L, 2); result = ((ofVec3f const *)arg1)->operator /(arg2); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f___div(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec3f___div__SWIG_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Vec3f___div__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec3f___div'\n" " Possible C/C++ prototypes are:\n" - " ofVec3f::operator /(ofVec3f const &) const\n" " ofVec3f::operator /(float const) const\n"); lua_error(L);return 0; } -static int _wrap_Vec3f_getScaled(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float arg2 ; ofVec3f result; - SWIG_check_num_args("ofVec3f::getScaled",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::getScaled",1,"ofVec3f const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec3f::getScaled",2,"float const"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_getScaled",1,SWIGTYPE_p_ofVec3f); } arg2 = (float const)lua_tonumber(L, 2); - result = ((ofVec3f const *)arg1)->getScaled(arg2); { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_scale(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float arg2 ; - ofVec3f *result = 0 ; SWIG_check_num_args("ofVec3f::scale",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::scale",1,"ofVec3f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec3f::scale",2,"float const"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_scale",1,SWIGTYPE_p_ofVec3f); } - arg2 = (float const)lua_tonumber(L, 2); result = (ofVec3f *) &(arg1)->scale(arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec3f_getRotated__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float arg2 ; - ofVec3f *arg3 = 0 ; ofVec3f result; SWIG_check_num_args("ofVec3f::getRotated",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::getRotated",1,"ofVec3f const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec3f::getRotated",2,"float"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofVec3f::getRotated",3,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_getRotated",1,SWIGTYPE_p_ofVec3f); } arg2 = (float)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_getRotated",3,SWIGTYPE_p_ofVec3f); } - result = ((ofVec3f const *)arg1)->getRotated(arg2,(ofVec3f const &)*arg3); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_getRotated__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float arg2 ; - float arg3 ; float arg4 ; ofVec3f result; SWIG_check_num_args("ofVec3f::getRotated",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::getRotated",1,"ofVec3f const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec3f::getRotated",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVec3f::getRotated",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVec3f::getRotated",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_getRotated",1,SWIGTYPE_p_ofVec3f); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - result = ((ofVec3f const *)arg1)->getRotated(arg2,arg3,arg4); { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_getRotated__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float arg2 ; - ofVec3f *arg3 = 0 ; ofVec3f *arg4 = 0 ; ofVec3f result; SWIG_check_num_args("ofVec3f::getRotated",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::getRotated",1,"ofVec3f const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec3f::getRotated",2,"float"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofVec3f::getRotated",3,"ofVec3f const &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofVec3f::getRotated",4,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_getRotated",1,SWIGTYPE_p_ofVec3f); } arg2 = (float)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_getRotated",3,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_getRotated",4,SWIGTYPE_p_ofVec3f); } - result = ((ofVec3f const *)arg1)->getRotated(arg2,(ofVec3f const &)*arg3,(ofVec3f const &)*arg4); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_getRotated(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec3f_getRotated__SWIG_0(L);} } } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec3f_getRotated__SWIG_2(L);} } } } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Vec3f_getRotated__SWIG_1(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec3f_getRotated'\n" " Possible C/C++ prototypes are:\n" - " ofVec3f::getRotated(float,ofVec3f const &) const\n" " ofVec3f::getRotated(float,float,float) const\n" - " ofVec3f::getRotated(float,ofVec3f const &,ofVec3f const &) const\n"); lua_error(L);return 0; } -static int _wrap_Vec3f_getRotatedRad__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float arg2 ; - ofVec3f *arg3 = 0 ; ofVec3f result; SWIG_check_num_args("ofVec3f::getRotatedRad",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::getRotatedRad",1,"ofVec3f const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec3f::getRotatedRad",2,"float"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofVec3f::getRotatedRad",3,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_getRotatedRad",1,SWIGTYPE_p_ofVec3f); } arg2 = (float)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_getRotatedRad",3,SWIGTYPE_p_ofVec3f); } - result = ((ofVec3f const *)arg1)->getRotatedRad(arg2,(ofVec3f const &)*arg3); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_getRotatedRad__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float arg2 ; - float arg3 ; float arg4 ; ofVec3f result; SWIG_check_num_args("ofVec3f::getRotatedRad",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::getRotatedRad",1,"ofVec3f const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec3f::getRotatedRad",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVec3f::getRotatedRad",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVec3f::getRotatedRad",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_getRotatedRad",1,SWIGTYPE_p_ofVec3f); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - result = ((ofVec3f const *)arg1)->getRotatedRad(arg2,arg3,arg4); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_getRotatedRad__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float arg2 ; - ofVec3f *arg3 = 0 ; ofVec3f *arg4 = 0 ; ofVec3f result; SWIG_check_num_args("ofVec3f::getRotatedRad",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::getRotatedRad",1,"ofVec3f const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec3f::getRotatedRad",2,"float"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofVec3f::getRotatedRad",3,"ofVec3f const &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofVec3f::getRotatedRad",4,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_getRotatedRad",1,SWIGTYPE_p_ofVec3f); } arg2 = (float)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_getRotatedRad",3,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_getRotatedRad",4,SWIGTYPE_p_ofVec3f); } - result = ((ofVec3f const *)arg1)->getRotatedRad(arg2,(ofVec3f const &)*arg3,(ofVec3f const &)*arg4); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_getRotatedRad(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec3f_getRotatedRad__SWIG_0(L);} } } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec3f_getRotatedRad__SWIG_2(L);} } } } } if (argc == 4) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Vec3f_getRotatedRad__SWIG_1(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec3f_getRotatedRad'\n" - " Possible C/C++ prototypes are:\n" " ofVec3f::getRotatedRad(float,ofVec3f const &) const\n" - " ofVec3f::getRotatedRad(float,float,float) const\n" - " ofVec3f::getRotatedRad(float,ofVec3f const &,ofVec3f const &) const\n"); lua_error(L);return 0; } -static int _wrap_Vec3f_rotate__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float arg2 ; - ofVec3f *arg3 = 0 ; ofVec3f *result = 0 ; SWIG_check_num_args("ofVec3f::rotate",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::rotate",1,"ofVec3f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec3f::rotate",2,"float"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofVec3f::rotate",3,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_rotate",1,SWIGTYPE_p_ofVec3f); } - arg2 = (float)lua_tonumber(L, 2); if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_rotate",3,SWIGTYPE_p_ofVec3f); } result = (ofVec3f *) &(arg1)->rotate(arg2,(ofVec3f const &)*arg3); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec3f_rotate__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float arg2 ; - float arg3 ; float arg4 ; ofVec3f *result = 0 ; SWIG_check_num_args("ofVec3f::rotate",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::rotate",1,"ofVec3f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec3f::rotate",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVec3f::rotate",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVec3f::rotate",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_rotate",1,SWIGTYPE_p_ofVec3f); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - result = (ofVec3f *) &(arg1)->rotate(arg2,arg3,arg4); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,0); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_rotate__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float arg2 ; - ofVec3f *arg3 = 0 ; ofVec3f *arg4 = 0 ; ofVec3f *result = 0 ; SWIG_check_num_args("ofVec3f::rotate",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::rotate",1,"ofVec3f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec3f::rotate",2,"float"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofVec3f::rotate",3,"ofVec3f const &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofVec3f::rotate",4,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_rotate",1,SWIGTYPE_p_ofVec3f); } - arg2 = (float)lua_tonumber(L, 2); if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_rotate",3,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_rotate",4,SWIGTYPE_p_ofVec3f); } - result = (ofVec3f *) &(arg1)->rotate(arg2,(ofVec3f const &)*arg3,(ofVec3f const &)*arg4); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec3f_rotate(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec3f_rotate__SWIG_0(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec3f_rotate__SWIG_2(L);} } } } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Vec3f_rotate__SWIG_1(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec3f_rotate'\n" " Possible C/C++ prototypes are:\n" - " ofVec3f::rotate(float,ofVec3f const &)\n" " ofVec3f::rotate(float,float,float)\n" - " ofVec3f::rotate(float,ofVec3f const &,ofVec3f const &)\n"); lua_error(L);return 0; } -static int _wrap_Vec3f_rotateRad__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float arg2 ; - ofVec3f *arg3 = 0 ; ofVec3f *result = 0 ; SWIG_check_num_args("ofVec3f::rotateRad",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::rotateRad",1,"ofVec3f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec3f::rotateRad",2,"float"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofVec3f::rotateRad",3,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_rotateRad",1,SWIGTYPE_p_ofVec3f); } arg2 = (float)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_rotateRad",3,SWIGTYPE_p_ofVec3f); } - result = (ofVec3f *) &(arg1)->rotateRad(arg2,(ofVec3f const &)*arg3); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec3f_rotateRad__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float arg2 ; - float arg3 ; float arg4 ; ofVec3f *result = 0 ; SWIG_check_num_args("ofVec3f::rotateRad",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::rotateRad",1,"ofVec3f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec3f::rotateRad",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVec3f::rotateRad",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVec3f::rotateRad",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_rotateRad",1,SWIGTYPE_p_ofVec3f); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); result = (ofVec3f *) &(arg1)->rotateRad(arg2,arg3,arg4); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec3f_rotateRad__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float arg2 ; - ofVec3f *arg3 = 0 ; ofVec3f *arg4 = 0 ; ofVec3f *result = 0 ; SWIG_check_num_args("ofVec3f::rotateRad",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::rotateRad",1,"ofVec3f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec3f::rotateRad",2,"float"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofVec3f::rotateRad",3,"ofVec3f const &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofVec3f::rotateRad",4,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_rotateRad",1,SWIGTYPE_p_ofVec3f); } arg2 = (float)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_rotateRad",3,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_rotateRad",4,SWIGTYPE_p_ofVec3f); } - result = (ofVec3f *) &(arg1)->rotateRad(arg2,(ofVec3f const &)*arg3,(ofVec3f const &)*arg4); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec3f_rotateRad(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec3f_rotateRad__SWIG_0(L);} } } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec3f_rotateRad__SWIG_2(L);} } } } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Vec3f_rotateRad__SWIG_1(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec3f_rotateRad'\n" " Possible C/C++ prototypes are:\n" - " ofVec3f::rotateRad(float,ofVec3f const &)\n" " ofVec3f::rotateRad(float,float,float)\n" - " ofVec3f::rotateRad(float,ofVec3f const &,ofVec3f const &)\n"); lua_error(L);return 0; } -static int _wrap_Vec3f_getMapped(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; - ofVec3f *arg3 = 0 ; ofVec3f *arg4 = 0 ; ofVec3f *arg5 = 0 ; ofVec3f result; SWIG_check_num_args("ofVec3f::getMapped",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::getMapped",1,"ofVec3f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec3f::getMapped",2,"ofVec3f const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofVec3f::getMapped",3,"ofVec3f const &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofVec3f::getMapped",4,"ofVec3f const &"); - if(!lua_isuserdata(L,5)) SWIG_fail_arg("ofVec3f::getMapped",5,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_getMapped",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_getMapped",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_getMapped",3,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_getMapped",4,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_getMapped",5,SWIGTYPE_p_ofVec3f); } - result = ((ofVec3f const *)arg1)->getMapped((ofVec3f const &)*arg2,(ofVec3f const &)*arg3,(ofVec3f const &)*arg4,(ofVec3f const &)*arg5); - { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_map(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; - ofVec3f *arg3 = 0 ; ofVec3f *arg4 = 0 ; ofVec3f *arg5 = 0 ; ofVec3f *result = 0 ; SWIG_check_num_args("ofVec3f::map",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::map",1,"ofVec3f *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec3f::map",2,"ofVec3f const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofVec3f::map",3,"ofVec3f const &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofVec3f::map",4,"ofVec3f const &"); - if(!lua_isuserdata(L,5)) SWIG_fail_arg("ofVec3f::map",5,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_map",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_map",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_map",3,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_map",4,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_map",5,SWIGTYPE_p_ofVec3f); } - result = (ofVec3f *) &(arg1)->map((ofVec3f const &)*arg2,(ofVec3f const &)*arg3,(ofVec3f const &)*arg4,(ofVec3f const &)*arg5); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec3f_distance(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; - float result; SWIG_check_num_args("ofVec3f::distance",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::distance",1,"ofVec3f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec3f::distance",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_distance",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_distance",2,SWIGTYPE_p_ofVec3f); } - result = (float)((ofVec3f const *)arg1)->distance((ofVec3f const &)*arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_squareDistance(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; - float result; SWIG_check_num_args("ofVec3f::squareDistance",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::squareDistance",1,"ofVec3f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec3f::squareDistance",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_squareDistance",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_squareDistance",2,SWIGTYPE_p_ofVec3f); } - result = (float)((ofVec3f const *)arg1)->squareDistance((ofVec3f const &)*arg2); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_getInterpolated(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; - float arg3 ; ofVec3f result; SWIG_check_num_args("ofVec3f::getInterpolated",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::getInterpolated",1,"ofVec3f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec3f::getInterpolated",2,"ofVec3f const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVec3f::getInterpolated",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_getInterpolated",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_getInterpolated",2,SWIGTYPE_p_ofVec3f); } arg3 = (float)lua_tonumber(L, 3); - result = ((ofVec3f const *)arg1)->getInterpolated((ofVec3f const &)*arg2,arg3); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_interpolate(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; - float arg3 ; ofVec3f *result = 0 ; SWIG_check_num_args("ofVec3f::interpolate",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::interpolate",1,"ofVec3f *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec3f::interpolate",2,"ofVec3f const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVec3f::interpolate",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_interpolate",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_interpolate",2,SWIGTYPE_p_ofVec3f); } arg3 = (float)lua_tonumber(L, 3); - result = (ofVec3f *) &(arg1)->interpolate((ofVec3f const &)*arg2,arg3); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec3f_getMiddle(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; - ofVec3f result; SWIG_check_num_args("ofVec3f::getMiddle",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::getMiddle",1,"ofVec3f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec3f::getMiddle",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_getMiddle",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_getMiddle",2,SWIGTYPE_p_ofVec3f); } - result = ((ofVec3f const *)arg1)->getMiddle((ofVec3f const &)*arg2); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_middle(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; - ofVec3f *result = 0 ; SWIG_check_num_args("ofVec3f::middle",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::middle",1,"ofVec3f *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec3f::middle",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_middle",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_middle",2,SWIGTYPE_p_ofVec3f); } result = (ofVec3f *) &(arg1)->middle((ofVec3f const &)*arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec3f_average(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = (ofVec3f *) 0 ; - int arg3 ; ofVec3f *result = 0 ; SWIG_check_num_args("ofVec3f::average",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::average",1,"ofVec3f *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofVec3f::average",2,"ofVec3f const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVec3f::average",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_average",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_average",2,SWIGTYPE_p_ofVec3f); } arg3 = (int)lua_tonumber(L, 3); - result = (ofVec3f *) &(arg1)->average((ofVec3f const *)arg2,arg3); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec3f_getNormalized(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f result; - SWIG_check_num_args("ofVec3f::getNormalized",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::getNormalized",1,"ofVec3f const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_getNormalized",1,SWIGTYPE_p_ofVec3f); } result = ((ofVec3f const *)arg1)->getNormalized(); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_normalize(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *result = 0 ; - SWIG_check_num_args("ofVec3f::normalize",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::normalize",1,"ofVec3f *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_normalize",1,SWIGTYPE_p_ofVec3f); } result = (ofVec3f *) &(arg1)->normalize(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec3f_getLimited(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float arg2 ; ofVec3f result; - SWIG_check_num_args("ofVec3f::getLimited",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::getLimited",1,"ofVec3f const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec3f::getLimited",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_getLimited",1,SWIGTYPE_p_ofVec3f); } arg2 = (float)lua_tonumber(L, 2); - result = ((ofVec3f const *)arg1)->getLimited(arg2); { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_limit(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float arg2 ; - ofVec3f *result = 0 ; SWIG_check_num_args("ofVec3f::limit",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::limit",1,"ofVec3f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec3f::limit",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_limit",1,SWIGTYPE_p_ofVec3f); } - arg2 = (float)lua_tonumber(L, 2); result = (ofVec3f *) &(arg1)->limit(arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec3f_length(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float result; - SWIG_check_num_args("ofVec3f::length",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::length",1,"ofVec3f const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_length",1,SWIGTYPE_p_ofVec3f); } - result = (float)((ofVec3f const *)arg1)->length(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_lengthSquared(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; float result; - SWIG_check_num_args("ofVec3f::lengthSquared",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::lengthSquared",1,"ofVec3f const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_lengthSquared",1,SWIGTYPE_p_ofVec3f); } result = (float)((ofVec3f const *)arg1)->lengthSquared(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_angle(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; float result; - SWIG_check_num_args("ofVec3f::angle",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::angle",1,"ofVec3f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec3f::angle",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_angle",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_angle",2,SWIGTYPE_p_ofVec3f); } - result = (float)((ofVec3f const *)arg1)->angle((ofVec3f const &)*arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_angleRad(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; - float result; SWIG_check_num_args("ofVec3f::angleRad",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::angleRad",1,"ofVec3f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec3f::angleRad",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_angleRad",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_angleRad",2,SWIGTYPE_p_ofVec3f); } - result = (float)((ofVec3f const *)arg1)->angleRad((ofVec3f const &)*arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_getPerpendicular(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; - ofVec3f result; SWIG_check_num_args("ofVec3f::getPerpendicular",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::getPerpendicular",1,"ofVec3f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec3f::getPerpendicular",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_getPerpendicular",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_getPerpendicular",2,SWIGTYPE_p_ofVec3f); } - result = ((ofVec3f const *)arg1)->getPerpendicular((ofVec3f const &)*arg2); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_perpendicular(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; - ofVec3f *result = 0 ; SWIG_check_num_args("ofVec3f::perpendicular",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::perpendicular",1,"ofVec3f *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec3f::perpendicular",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_perpendicular",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_perpendicular",2,SWIGTYPE_p_ofVec3f); } - result = (ofVec3f *) &(arg1)->perpendicular((ofVec3f const &)*arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec3f_getCrossed(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; - ofVec3f result; SWIG_check_num_args("ofVec3f::getCrossed",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::getCrossed",1,"ofVec3f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec3f::getCrossed",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_getCrossed",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f_getCrossed",2,SWIGTYPE_p_ofVec3f); } - result = ((ofVec3f const *)arg1)->getCrossed((ofVec3f const &)*arg2); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_cross(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; - ofVec3f *result = 0 ; SWIG_check_num_args("ofVec3f::cross",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::cross",1,"ofVec3f *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec3f::cross",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_cross",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_cross",2,SWIGTYPE_p_ofVec3f); } - result = (ofVec3f *) &(arg1)->cross((ofVec3f const &)*arg2); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,0); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_dot(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; ofVec3f *arg2 = 0 ; float result; - SWIG_check_num_args("ofVec3f::dot",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::dot",1,"ofVec3f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec3f::dot",2,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_dot",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Vec3f_dot",2,SWIGTYPE_p_ofVec3f); } - result = (float)((ofVec3f const *)arg1)->dot((ofVec3f const &)*arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_zero(lua_State* L) { int SWIG_arg = 0; ofVec3f result; SWIG_check_num_args("ofVec3f::zero",0,0) - result = ofVec3f::zero(); { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f_one(lua_State* L) { int SWIG_arg = 0; ofVec3f result; SWIG_check_num_args("ofVec3f::one",0,0) - result = ofVec3f::one(); { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec3f___tostring(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = (ofVec3f *) 0 ; char *result = 0 ; - SWIG_check_num_args("ofVec3f::__str__",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec3f::__str__",1,"ofVec3f *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vec3f___tostring",1,SWIGTYPE_p_ofVec3f); } result = (char *)ofVec3f___str__(arg1); - lua_pushstring(L,(const char *)result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_Vec3f(void *obj) { -ofVec3f *arg1 = (ofVec3f *) obj; -delete arg1; -} -static int _proxy__wrap_new_Vec3f(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_Vec3f); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_Vec3f_attributes[] = { - { "x", _wrap_Vec3f_x_get, _wrap_Vec3f_x_set }, - { "y", _wrap_Vec3f_y_get, _wrap_Vec3f_y_set }, - { "z", _wrap_Vec3f_z_get, _wrap_Vec3f_z_set }, - {0,0,0} -}; -static swig_lua_method swig_Vec3f_methods[]= { - { "getPtr", _wrap_Vec3f_getPtr}, - { "set", _wrap_Vec3f_set}, - { "__eq", _wrap_Vec3f___eq}, - { "match", _wrap_Vec3f_match}, - { "isAligned", _wrap_Vec3f_isAligned}, - { "isAlignedRad", _wrap_Vec3f_isAlignedRad}, - { "align", _wrap_Vec3f_align}, - { "alignRad", _wrap_Vec3f_alignRad}, - { "__add", _wrap_Vec3f___add}, - { "__sub", _wrap_Vec3f___sub}, - { "__unm", _wrap_Vec3f___unm}, - { "__mul", _wrap_Vec3f___mul}, - { "__div", _wrap_Vec3f___div}, - { "getScaled", _wrap_Vec3f_getScaled}, - { "scale", _wrap_Vec3f_scale}, - { "getRotated", _wrap_Vec3f_getRotated}, - { "getRotatedRad", _wrap_Vec3f_getRotatedRad}, - { "rotate", _wrap_Vec3f_rotate}, - { "rotateRad", _wrap_Vec3f_rotateRad}, - { "getMapped", _wrap_Vec3f_getMapped}, - { "map", _wrap_Vec3f_map}, - { "distance", _wrap_Vec3f_distance}, - { "squareDistance", _wrap_Vec3f_squareDistance}, - { "getInterpolated", _wrap_Vec3f_getInterpolated}, - { "interpolate", _wrap_Vec3f_interpolate}, - { "getMiddle", _wrap_Vec3f_getMiddle}, - { "middle", _wrap_Vec3f_middle}, - { "average", _wrap_Vec3f_average}, - { "getNormalized", _wrap_Vec3f_getNormalized}, - { "normalize", _wrap_Vec3f_normalize}, - { "getLimited", _wrap_Vec3f_getLimited}, - { "limit", _wrap_Vec3f_limit}, - { "length", _wrap_Vec3f_length}, - { "lengthSquared", _wrap_Vec3f_lengthSquared}, - { "angle", _wrap_Vec3f_angle}, - { "angleRad", _wrap_Vec3f_angleRad}, - { "getPerpendicular", _wrap_Vec3f_getPerpendicular}, - { "perpendicular", _wrap_Vec3f_perpendicular}, - { "getCrossed", _wrap_Vec3f_getCrossed}, - { "cross", _wrap_Vec3f_cross}, - { "dot", _wrap_Vec3f_dot}, - { "__tostring", _wrap_Vec3f___tostring}, - {0,0} -}; -static swig_lua_method swig_Vec3f_meta[] = { - { "__eq", _wrap_Vec3f___eq}, - { "__add", _wrap_Vec3f___add}, - { "__sub", _wrap_Vec3f___sub}, - { "__unm", _wrap_Vec3f___unm}, - { "__mul", _wrap_Vec3f___mul}, - { "__div", _wrap_Vec3f___div}, - { "__tostring", _wrap_Vec3f___tostring}, - {0,0} -}; - -static swig_lua_attribute swig_Vec3f_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_Vec3f_Sf_SwigStatic_constants[]= { - {SWIG_LUA_CONSTTAB_INT("DIM", ofVec3f::DIM)}, - {0,0,0,0,0,0} -}; -static swig_lua_method swig_Vec3f_Sf_SwigStatic_methods[]= { - { "zero", _wrap_Vec3f_zero}, - { "one", _wrap_Vec3f_one}, - {0,0} -}; -static swig_lua_class* swig_Vec3f_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_Vec3f_Sf_SwigStatic = { - "Vec3f", - swig_Vec3f_Sf_SwigStatic_methods, - swig_Vec3f_Sf_SwigStatic_attributes, - swig_Vec3f_Sf_SwigStatic_constants, - swig_Vec3f_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_Vec3f_bases[] = {0}; -static const char *swig_Vec3f_base_names[] = {0}; -static swig_lua_class _wrap_class_Vec3f = { "Vec3f", "Vec3f", &SWIGTYPE_p_ofVec3f,_proxy__wrap_new_Vec3f, swig_delete_Vec3f, swig_Vec3f_methods, swig_Vec3f_attributes, &swig_Vec3f_Sf_SwigStatic, swig_Vec3f_meta, swig_Vec3f_bases, swig_Vec3f_base_names }; - -static int _wrap_Vec4f_x_set(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; float arg2 ; - SWIG_check_num_args("ofVec4f::x",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::x",1,"ofVec4f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec4f::x",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f_x_set",1,SWIGTYPE_p_ofVec4f); } - arg2 = (float)lua_tonumber(L, 2); if (arg1) (arg1)->x = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec4f_x_get(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; float result; - SWIG_check_num_args("ofVec4f::x",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::x",1,"ofVec4f *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f_x_get",1,SWIGTYPE_p_ofVec4f); } - result = (float) ((arg1)->x); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f_y_set(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; float arg2 ; - SWIG_check_num_args("ofVec4f::y",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::y",1,"ofVec4f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec4f::y",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f_y_set",1,SWIGTYPE_p_ofVec4f); } - arg2 = (float)lua_tonumber(L, 2); if (arg1) (arg1)->y = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec4f_y_get(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; float result; - SWIG_check_num_args("ofVec4f::y",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::y",1,"ofVec4f *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f_y_get",1,SWIGTYPE_p_ofVec4f); } - result = (float) ((arg1)->y); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f_z_set(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; float arg2 ; - SWIG_check_num_args("ofVec4f::z",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::z",1,"ofVec4f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec4f::z",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f_z_set",1,SWIGTYPE_p_ofVec4f); } - arg2 = (float)lua_tonumber(L, 2); if (arg1) (arg1)->z = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec4f_z_get(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; float result; - SWIG_check_num_args("ofVec4f::z",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::z",1,"ofVec4f *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f_z_get",1,SWIGTYPE_p_ofVec4f); } - result = (float) ((arg1)->z); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f_w_set(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; float arg2 ; - SWIG_check_num_args("ofVec4f::w",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::w",1,"ofVec4f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec4f::w",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f_w_set",1,SWIGTYPE_p_ofVec4f); } - arg2 = (float)lua_tonumber(L, 2); if (arg1) (arg1)->w = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec4f_w_get(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; float result; - SWIG_check_num_args("ofVec4f::w",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::w",1,"ofVec4f *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f_w_get",1,SWIGTYPE_p_ofVec4f); } - result = (float) ((arg1)->w); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_Vec4f__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec4f *result = 0 ; - SWIG_check_num_args("ofVec4f::ofVec4f",0,0) result = (ofVec4f *)new ofVec4f(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec4f,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Vec4f__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; ofVec4f *result = 0 ; - SWIG_check_num_args("ofVec4f::ofVec4f",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofVec4f::ofVec4f",1,"float"); - arg1 = (float)lua_tonumber(L, 1); result = (ofVec4f *)new ofVec4f(arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec4f,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Vec4f__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - ofVec4f *result = 0 ; SWIG_check_num_args("ofVec4f::ofVec4f",4,4) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofVec4f::ofVec4f",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec4f::ofVec4f",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVec4f::ofVec4f",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVec4f::ofVec4f",4,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - result = (ofVec4f *)new ofVec4f(arg1,arg2,arg3,arg4); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec4f,1); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_new_Vec4f__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofVec2f *arg1 = 0 ; ofVec4f *result = 0 ; - SWIG_check_num_args("ofVec4f::ofVec4f",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofVec4f::ofVec4f",1,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec2f,0))){ SWIG_fail_ptr("new_Vec4f",1,SWIGTYPE_p_ofVec2f); } - result = (ofVec4f *)new ofVec4f((ofVec2f const &)*arg1); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec4f,1); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_new_Vec4f__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofVec3f *arg1 = 0 ; ofVec4f *result = 0 ; - SWIG_check_num_args("ofVec4f::ofVec4f",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofVec4f::ofVec4f",1,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("new_Vec4f",1,SWIGTYPE_p_ofVec3f); } - result = (ofVec4f *)new ofVec4f((ofVec3f const &)*arg1); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec4f,1); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_new_Vec4f(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_Vec4f__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_new_Vec4f__SWIG_3(L);} } if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_new_Vec4f__SWIG_4(L);} } if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_new_Vec4f__SWIG_1(L);} } if (argc == 4) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_new_Vec4f__SWIG_2(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_Vec4f'\n" " Possible C/C++ prototypes are:\n" - " ofVec4f::ofVec4f()\n" " ofVec4f::ofVec4f(float)\n" " ofVec4f::ofVec4f(float,float,float,float)\n" - " ofVec4f::ofVec4f(ofVec2f const &)\n" " ofVec4f::ofVec4f(ofVec3f const &)\n"); lua_error(L);return 0; } -static int _wrap_Vec4f_getPtr__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; float *result = 0 ; - SWIG_check_num_args("ofVec4f::getPtr",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::getPtr",1,"ofVec4f *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f_getPtr",1,SWIGTYPE_p_ofVec4f); } - result = (float *)(arg1)->getPtr(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_float,0); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f_getPtr__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; float *result = 0 ; - SWIG_check_num_args("ofVec4f::getPtr",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::getPtr",1,"ofVec4f const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f_getPtr",1,SWIGTYPE_p_ofVec4f); } - result = (float *)((ofVec4f const *)arg1)->getPtr(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_float,0); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f_getPtr(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Vec4f_getPtr__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Vec4f_getPtr__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec4f_getPtr'\n" " Possible C/C++ prototypes are:\n" - " ofVec4f::getPtr()\n" " ofVec4f::getPtr() const\n"); lua_error(L);return 0; } -static int _wrap_Vec4f_set__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; float arg2 ; - SWIG_check_num_args("ofVec4f::set",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::set",1,"ofVec4f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec4f::set",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f_set",1,SWIGTYPE_p_ofVec4f); } - arg2 = (float)lua_tonumber(L, 2); (arg1)->set(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f_set__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; float arg2 ; float arg3 ; - float arg4 ; float arg5 ; SWIG_check_num_args("ofVec4f::set",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::set",1,"ofVec4f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec4f::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVec4f::set",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVec4f::set",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofVec4f::set",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f_set",1,SWIGTYPE_p_ofVec4f); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); (arg1)->set(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec4f_set__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; ofVec4f *arg2 = 0 ; - SWIG_check_num_args("ofVec4f::set",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::set",1,"ofVec4f *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec4f::set",2,"ofVec4f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f_set",1,SWIGTYPE_p_ofVec4f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f_set",2,SWIGTYPE_p_ofVec4f); } - (arg1)->set((ofVec4f const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f_set(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 2) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec4f_set__SWIG_2(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Vec4f_set__SWIG_0(L);} } } - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Vec4f_set__SWIG_1(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec4f_set'\n" " Possible C/C++ prototypes are:\n" - " ofVec4f::set(float)\n" " ofVec4f::set(float,float,float,float)\n" " ofVec4f::set(ofVec4f const &)\n"); - lua_error(L);return 0; } -static int _wrap_Vec4f___eq(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; ofVec4f *arg2 = 0 ; bool result; - SWIG_check_num_args("ofVec4f::operator ==",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::operator ==",1,"ofVec4f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec4f::operator ==",2,"ofVec4f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f___eq",1,SWIGTYPE_p_ofVec4f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f___eq",2,SWIGTYPE_p_ofVec4f); } - result = (bool)((ofVec4f const *)arg1)->operator ==((ofVec4f const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f_match__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; ofVec4f *arg2 = 0 ; - float arg3 ; bool result; SWIG_check_num_args("ofVec4f::match",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::match",1,"ofVec4f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec4f::match",2,"ofVec4f const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVec4f::match",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f_match",1,SWIGTYPE_p_ofVec4f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f_match",2,SWIGTYPE_p_ofVec4f); } - arg3 = (float)lua_tonumber(L, 3); result = (bool)((ofVec4f const *)arg1)->match((ofVec4f const &)*arg2,arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f_match__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; ofVec4f *arg2 = 0 ; - bool result; SWIG_check_num_args("ofVec4f::match",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::match",1,"ofVec4f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec4f::match",2,"ofVec4f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f_match",1,SWIGTYPE_p_ofVec4f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f_match",2,SWIGTYPE_p_ofVec4f); } - result = (bool)((ofVec4f const *)arg1)->match((ofVec4f const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f_match(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec4f_match__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Vec4f_match__SWIG_0(L);} } } - } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec4f_match'\n" " Possible C/C++ prototypes are:\n" - " ofVec4f::match(ofVec4f const &,float) const\n" " ofVec4f::match(ofVec4f const &) const\n"); lua_error(L);return 0; } -static int _wrap_Vec4f___add__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; ofVec4f *arg2 = 0 ; - ofVec4f result; SWIG_check_num_args("ofVec4f::operator +",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::operator +",1,"ofVec4f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec4f::operator +",2,"ofVec4f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f___add",1,SWIGTYPE_p_ofVec4f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f___add",2,SWIGTYPE_p_ofVec4f); } - result = ((ofVec4f const *)arg1)->operator +((ofVec4f const &)*arg2); { - ofVec4f * resultptr = new ofVec4f((const ofVec4f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec4f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f___add__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; float arg2 ; - ofVec4f result; SWIG_check_num_args("ofVec4f::operator +",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::operator +",1,"ofVec4f const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec4f::operator +",2,"float const"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f___add",1,SWIGTYPE_p_ofVec4f); } - arg2 = (float const)lua_tonumber(L, 2); result = ((ofVec4f const *)arg1)->operator +(arg2); { - ofVec4f * resultptr = new ofVec4f((const ofVec4f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec4f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f___add(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec4f___add__SWIG_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Vec4f___add__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec4f___add'\n" " Possible C/C++ prototypes are:\n" - " ofVec4f::operator +(ofVec4f const &) const\n" " ofVec4f::operator +(float const) const\n"); lua_error(L);return 0; } -static int _wrap_Vec4f___sub__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; float arg2 ; - ofVec4f result; SWIG_check_num_args("ofVec4f::operator -",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::operator -",1,"ofVec4f const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec4f::operator -",2,"float const"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f___sub",1,SWIGTYPE_p_ofVec4f); } - arg2 = (float const)lua_tonumber(L, 2); result = ((ofVec4f const *)arg1)->operator -(arg2); { - ofVec4f * resultptr = new ofVec4f((const ofVec4f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec4f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f___sub__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; ofVec4f *arg2 = 0 ; - ofVec4f result; SWIG_check_num_args("ofVec4f::operator -",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::operator -",1,"ofVec4f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec4f::operator -",2,"ofVec4f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f___sub",1,SWIGTYPE_p_ofVec4f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f___sub",2,SWIGTYPE_p_ofVec4f); } - result = ((ofVec4f const *)arg1)->operator -((ofVec4f const &)*arg2); { - ofVec4f * resultptr = new ofVec4f((const ofVec4f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec4f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f___sub(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec4f___sub__SWIG_1(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Vec4f___sub__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec4f___sub'\n" " Possible C/C++ prototypes are:\n" - " ofVec4f::operator -(float const) const\n" " ofVec4f::operator -(ofVec4f const &) const\n"); lua_error(L);return 0; } -static int _wrap_Vec4f___unm(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; ofVec4f result; - SWIG_check_num_args("ofVec4f::operator -",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::operator -",1,"ofVec4f const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f___unm",1,SWIGTYPE_p_ofVec4f); } - result = ((ofVec4f const *)arg1)->operator -(); { ofVec4f * resultptr = new ofVec4f((const ofVec4f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec4f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f___mul__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; ofVec4f *arg2 = 0 ; - ofVec4f result; SWIG_check_num_args("ofVec4f::operator *",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::operator *",1,"ofVec4f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec4f::operator *",2,"ofVec4f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f___mul",1,SWIGTYPE_p_ofVec4f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f___mul",2,SWIGTYPE_p_ofVec4f); } - result = ((ofVec4f const *)arg1)->operator *((ofVec4f const &)*arg2); { - ofVec4f * resultptr = new ofVec4f((const ofVec4f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec4f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f___mul__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; float arg2 ; - ofVec4f result; SWIG_check_num_args("ofVec4f::operator *",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::operator *",1,"ofVec4f const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec4f::operator *",2,"float const"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f___mul",1,SWIGTYPE_p_ofVec4f); } - arg2 = (float const)lua_tonumber(L, 2); result = ((ofVec4f const *)arg1)->operator *(arg2); { - ofVec4f * resultptr = new ofVec4f((const ofVec4f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec4f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f___mul(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec4f___mul__SWIG_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Vec4f___mul__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec4f___mul'\n" " Possible C/C++ prototypes are:\n" - " ofVec4f::operator *(ofVec4f const &) const\n" " ofVec4f::operator *(float const) const\n"); lua_error(L);return 0; } -static int _wrap_Vec4f___div__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; ofVec4f *arg2 = 0 ; - ofVec4f result; SWIG_check_num_args("ofVec4f::operator /",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::operator /",1,"ofVec4f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec4f::operator /",2,"ofVec4f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f___div",1,SWIGTYPE_p_ofVec4f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f___div",2,SWIGTYPE_p_ofVec4f); } - result = ((ofVec4f const *)arg1)->operator /((ofVec4f const &)*arg2); { - ofVec4f * resultptr = new ofVec4f((const ofVec4f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec4f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f___div__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; float arg2 ; - ofVec4f result; SWIG_check_num_args("ofVec4f::operator /",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::operator /",1,"ofVec4f const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec4f::operator /",2,"float const"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f___div",1,SWIGTYPE_p_ofVec4f); } - arg2 = (float const)lua_tonumber(L, 2); result = ((ofVec4f const *)arg1)->operator /(arg2); { - ofVec4f * resultptr = new ofVec4f((const ofVec4f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec4f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f___div(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vec4f___div__SWIG_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Vec4f___div__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vec4f___div'\n" " Possible C/C++ prototypes are:\n" - " ofVec4f::operator /(ofVec4f const &) const\n" " ofVec4f::operator /(float const) const\n"); lua_error(L);return 0; } -static int _wrap_Vec4f_getScaled(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; float arg2 ; ofVec4f result; - SWIG_check_num_args("ofVec4f::getScaled",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::getScaled",1,"ofVec4f const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec4f::getScaled",2,"float const"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ - SWIG_fail_ptr("Vec4f_getScaled",1,SWIGTYPE_p_ofVec4f); } arg2 = (float const)lua_tonumber(L, 2); - result = ((ofVec4f const *)arg1)->getScaled(arg2); { ofVec4f * resultptr = new ofVec4f((const ofVec4f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec4f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f_scale(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; float arg2 ; - ofVec4f *result = 0 ; SWIG_check_num_args("ofVec4f::scale",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::scale",1,"ofVec4f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec4f::scale",2,"float const"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f_scale",1,SWIGTYPE_p_ofVec4f); } - arg2 = (float const)lua_tonumber(L, 2); result = (ofVec4f *) &(arg1)->scale(arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec4f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec4f_distance(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; ofVec4f *arg2 = 0 ; - float result; SWIG_check_num_args("ofVec4f::distance",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::distance",1,"ofVec4f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec4f::distance",2,"ofVec4f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ - SWIG_fail_ptr("Vec4f_distance",1,SWIGTYPE_p_ofVec4f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec4f,0))){ - SWIG_fail_ptr("Vec4f_distance",2,SWIGTYPE_p_ofVec4f); } - result = (float)((ofVec4f const *)arg1)->distance((ofVec4f const &)*arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f_squareDistance(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; ofVec4f *arg2 = 0 ; - float result; SWIG_check_num_args("ofVec4f::squareDistance",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::squareDistance",1,"ofVec4f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec4f::squareDistance",2,"ofVec4f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ - SWIG_fail_ptr("Vec4f_squareDistance",1,SWIGTYPE_p_ofVec4f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec4f,0))){ - SWIG_fail_ptr("Vec4f_squareDistance",2,SWIGTYPE_p_ofVec4f); } - result = (float)((ofVec4f const *)arg1)->squareDistance((ofVec4f const &)*arg2); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f_getInterpolated(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; ofVec4f *arg2 = 0 ; - float arg3 ; ofVec4f result; SWIG_check_num_args("ofVec4f::getInterpolated",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::getInterpolated",1,"ofVec4f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec4f::getInterpolated",2,"ofVec4f const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVec4f::getInterpolated",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ - SWIG_fail_ptr("Vec4f_getInterpolated",1,SWIGTYPE_p_ofVec4f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec4f,0))){ - SWIG_fail_ptr("Vec4f_getInterpolated",2,SWIGTYPE_p_ofVec4f); } arg3 = (float)lua_tonumber(L, 3); - result = ((ofVec4f const *)arg1)->getInterpolated((ofVec4f const &)*arg2,arg3); { - ofVec4f * resultptr = new ofVec4f((const ofVec4f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec4f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f_interpolate(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; ofVec4f *arg2 = 0 ; - float arg3 ; ofVec4f *result = 0 ; SWIG_check_num_args("ofVec4f::interpolate",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::interpolate",1,"ofVec4f *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec4f::interpolate",2,"ofVec4f const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVec4f::interpolate",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ - SWIG_fail_ptr("Vec4f_interpolate",1,SWIGTYPE_p_ofVec4f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec4f,0))){ - SWIG_fail_ptr("Vec4f_interpolate",2,SWIGTYPE_p_ofVec4f); } arg3 = (float)lua_tonumber(L, 3); - result = (ofVec4f *) &(arg1)->interpolate((ofVec4f const &)*arg2,arg3); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec4f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec4f_getMiddle(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; ofVec4f *arg2 = 0 ; - ofVec4f result; SWIG_check_num_args("ofVec4f::getMiddle",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::getMiddle",1,"ofVec4f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec4f::getMiddle",2,"ofVec4f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ - SWIG_fail_ptr("Vec4f_getMiddle",1,SWIGTYPE_p_ofVec4f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec4f,0))){ - SWIG_fail_ptr("Vec4f_getMiddle",2,SWIGTYPE_p_ofVec4f); } - result = ((ofVec4f const *)arg1)->getMiddle((ofVec4f const &)*arg2); { - ofVec4f * resultptr = new ofVec4f((const ofVec4f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec4f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f_middle(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; ofVec4f *arg2 = 0 ; - ofVec4f *result = 0 ; SWIG_check_num_args("ofVec4f::middle",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::middle",1,"ofVec4f *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec4f::middle",2,"ofVec4f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f_middle",1,SWIGTYPE_p_ofVec4f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec4f,0))){ - SWIG_fail_ptr("Vec4f_middle",2,SWIGTYPE_p_ofVec4f); } result = (ofVec4f *) &(arg1)->middle((ofVec4f const &)*arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec4f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec4f_average(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; ofVec4f *arg2 = (ofVec4f *) 0 ; - int arg3 ; ofVec4f *result = 0 ; SWIG_check_num_args("ofVec4f::average",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::average",1,"ofVec4f *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofVec4f::average",2,"ofVec4f const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVec4f::average",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ - SWIG_fail_ptr("Vec4f_average",1,SWIGTYPE_p_ofVec4f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec4f,0))){ - SWIG_fail_ptr("Vec4f_average",2,SWIGTYPE_p_ofVec4f); } arg3 = (int)lua_tonumber(L, 3); - result = (ofVec4f *) &(arg1)->average((ofVec4f const *)arg2,arg3); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec4f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec4f_getNormalized(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; ofVec4f result; - SWIG_check_num_args("ofVec4f::getNormalized",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::getNormalized",1,"ofVec4f const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ - SWIG_fail_ptr("Vec4f_getNormalized",1,SWIGTYPE_p_ofVec4f); } result = ((ofVec4f const *)arg1)->getNormalized(); { - ofVec4f * resultptr = new ofVec4f((const ofVec4f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec4f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f_normalize(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; ofVec4f *result = 0 ; - SWIG_check_num_args("ofVec4f::normalize",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::normalize",1,"ofVec4f *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ - SWIG_fail_ptr("Vec4f_normalize",1,SWIGTYPE_p_ofVec4f); } result = (ofVec4f *) &(arg1)->normalize(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec4f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec4f_getLimited(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; float arg2 ; ofVec4f result; - SWIG_check_num_args("ofVec4f::getLimited",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::getLimited",1,"ofVec4f const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec4f::getLimited",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ - SWIG_fail_ptr("Vec4f_getLimited",1,SWIGTYPE_p_ofVec4f); } arg2 = (float)lua_tonumber(L, 2); - result = ((ofVec4f const *)arg1)->getLimited(arg2); { ofVec4f * resultptr = new ofVec4f((const ofVec4f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec4f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f_limit(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; float arg2 ; - ofVec4f *result = 0 ; SWIG_check_num_args("ofVec4f::limit",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::limit",1,"ofVec4f *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVec4f::limit",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f_limit",1,SWIGTYPE_p_ofVec4f); } - arg2 = (float)lua_tonumber(L, 2); result = (ofVec4f *) &(arg1)->limit(arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec4f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vec4f_length(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; float result; - SWIG_check_num_args("ofVec4f::length",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::length",1,"ofVec4f const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f_length",1,SWIGTYPE_p_ofVec4f); } - result = (float)((ofVec4f const *)arg1)->length(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f_lengthSquared(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; float result; - SWIG_check_num_args("ofVec4f::lengthSquared",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::lengthSquared",1,"ofVec4f const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ - SWIG_fail_ptr("Vec4f_lengthSquared",1,SWIGTYPE_p_ofVec4f); } result = (float)((ofVec4f const *)arg1)->lengthSquared(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f_dot(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; ofVec4f *arg2 = 0 ; float result; - SWIG_check_num_args("ofVec4f::dot",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::dot",1,"ofVec4f const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVec4f::dot",2,"ofVec4f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f_dot",1,SWIGTYPE_p_ofVec4f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec4f,0))){ SWIG_fail_ptr("Vec4f_dot",2,SWIGTYPE_p_ofVec4f); } - result = (float)((ofVec4f const *)arg1)->dot((ofVec4f const &)*arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f_zero(lua_State* L) { int SWIG_arg = 0; ofVec4f result; SWIG_check_num_args("ofVec4f::zero",0,0) - result = ofVec4f::zero(); { ofVec4f * resultptr = new ofVec4f((const ofVec4f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec4f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f_one(lua_State* L) { int SWIG_arg = 0; ofVec4f result; SWIG_check_num_args("ofVec4f::one",0,0) - result = ofVec4f::one(); { ofVec4f * resultptr = new ofVec4f((const ofVec4f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec4f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vec4f___tostring(lua_State* L) { int SWIG_arg = 0; ofVec4f *arg1 = (ofVec4f *) 0 ; char *result = 0 ; - SWIG_check_num_args("ofVec4f::__str__",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVec4f::__str__",1,"ofVec4f *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec4f,0))){ - SWIG_fail_ptr("Vec4f___tostring",1,SWIGTYPE_p_ofVec4f); } result = (char *)ofVec4f___str__(arg1); - lua_pushstring(L,(const char *)result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_Vec4f(void *obj) { -ofVec4f *arg1 = (ofVec4f *) obj; -delete arg1; -} -static int _proxy__wrap_new_Vec4f(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_Vec4f); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_Vec4f_attributes[] = { - { "x", _wrap_Vec4f_x_get, _wrap_Vec4f_x_set }, - { "y", _wrap_Vec4f_y_get, _wrap_Vec4f_y_set }, - { "z", _wrap_Vec4f_z_get, _wrap_Vec4f_z_set }, - { "w", _wrap_Vec4f_w_get, _wrap_Vec4f_w_set }, - {0,0,0} -}; -static swig_lua_method swig_Vec4f_methods[]= { - { "getPtr", _wrap_Vec4f_getPtr}, - { "set", _wrap_Vec4f_set}, - { "__eq", _wrap_Vec4f___eq}, - { "match", _wrap_Vec4f_match}, - { "__add", _wrap_Vec4f___add}, - { "__sub", _wrap_Vec4f___sub}, - { "__unm", _wrap_Vec4f___unm}, - { "__mul", _wrap_Vec4f___mul}, - { "__div", _wrap_Vec4f___div}, - { "getScaled", _wrap_Vec4f_getScaled}, - { "scale", _wrap_Vec4f_scale}, - { "distance", _wrap_Vec4f_distance}, - { "squareDistance", _wrap_Vec4f_squareDistance}, - { "getInterpolated", _wrap_Vec4f_getInterpolated}, - { "interpolate", _wrap_Vec4f_interpolate}, - { "getMiddle", _wrap_Vec4f_getMiddle}, - { "middle", _wrap_Vec4f_middle}, - { "average", _wrap_Vec4f_average}, - { "getNormalized", _wrap_Vec4f_getNormalized}, - { "normalize", _wrap_Vec4f_normalize}, - { "getLimited", _wrap_Vec4f_getLimited}, - { "limit", _wrap_Vec4f_limit}, - { "length", _wrap_Vec4f_length}, - { "lengthSquared", _wrap_Vec4f_lengthSquared}, - { "dot", _wrap_Vec4f_dot}, - { "__tostring", _wrap_Vec4f___tostring}, - {0,0} -}; -static swig_lua_method swig_Vec4f_meta[] = { - { "__eq", _wrap_Vec4f___eq}, - { "__add", _wrap_Vec4f___add}, - { "__sub", _wrap_Vec4f___sub}, - { "__unm", _wrap_Vec4f___unm}, - { "__mul", _wrap_Vec4f___mul}, - { "__div", _wrap_Vec4f___div}, - { "__tostring", _wrap_Vec4f___tostring}, - {0,0} -}; - -static swig_lua_attribute swig_Vec4f_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_Vec4f_Sf_SwigStatic_constants[]= { - {SWIG_LUA_CONSTTAB_INT("DIM", ofVec4f::DIM)}, - {0,0,0,0,0,0} -}; -static swig_lua_method swig_Vec4f_Sf_SwigStatic_methods[]= { - { "zero", _wrap_Vec4f_zero}, - { "one", _wrap_Vec4f_one}, - {0,0} -}; -static swig_lua_class* swig_Vec4f_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_Vec4f_Sf_SwigStatic = { - "Vec4f", - swig_Vec4f_Sf_SwigStatic_methods, - swig_Vec4f_Sf_SwigStatic_attributes, - swig_Vec4f_Sf_SwigStatic_constants, - swig_Vec4f_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_Vec4f_bases[] = {0}; -static const char *swig_Vec4f_base_names[] = {0}; -static swig_lua_class _wrap_class_Vec4f = { "Vec4f", "Vec4f", &SWIGTYPE_p_ofVec4f,_proxy__wrap_new_Vec4f, swig_delete_Vec4f, swig_Vec4f_methods, swig_Vec4f_attributes, &swig_Vec4f_Sf_SwigStatic, swig_Vec4f_meta, swig_Vec4f_bases, swig_Vec4f_base_names }; - -static int _wrap_getMousePressed__SWIG_0(lua_State* L) { int SWIG_arg = 0; int arg1 ; bool result; - SWIG_check_num_args("ofGetMousePressed",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofGetMousePressed",1,"int"); - arg1 = (int)lua_tonumber(L, 1); result = (bool)ofGetMousePressed(arg1); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getMousePressed__SWIG_1(lua_State* L) { int SWIG_arg = 0; bool result; - SWIG_check_num_args("ofGetMousePressed",0,0) result = (bool)ofGetMousePressed(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getMousePressed(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_getMousePressed__SWIG_1(L);} if (argc == 1) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { - return _wrap_getMousePressed__SWIG_0(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'getMousePressed'\n" " Possible C/C++ prototypes are:\n" - " ofGetMousePressed(int)\n" " ofGetMousePressed()\n"); lua_error(L);return 0; } -static int _wrap_getKeyPressed__SWIG_0(lua_State* L) { int SWIG_arg = 0; int arg1 ; bool result; - SWIG_check_num_args("ofGetKeyPressed",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofGetKeyPressed",1,"int"); - arg1 = (int)lua_tonumber(L, 1); result = (bool)ofGetKeyPressed(arg1); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getKeyPressed__SWIG_1(lua_State* L) { int SWIG_arg = 0; bool result; SWIG_check_num_args("ofGetKeyPressed",0,0) - result = (bool)ofGetKeyPressed(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_getKeyPressed(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_getKeyPressed__SWIG_1(L);} if (argc == 1) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { - return _wrap_getKeyPressed__SWIG_0(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'getKeyPressed'\n" " Possible C/C++ prototypes are:\n" - " ofGetKeyPressed(int)\n" " ofGetKeyPressed()\n"); lua_error(L);return 0; } -static int _wrap_getMouseX(lua_State* L) { int SWIG_arg = 0; int result; SWIG_check_num_args("ofGetMouseX",0,0) - result = (int)ofGetMouseX(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_getMouseY(lua_State* L) { int SWIG_arg = 0; int result; SWIG_check_num_args("ofGetMouseY",0,0) - result = (int)ofGetMouseY(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_getPreviousMouseX(lua_State* L) { int SWIG_arg = 0; int result; SWIG_check_num_args("ofGetPreviousMouseX",0,0) - result = (int)ofGetPreviousMouseX(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_getPreviousMouseY(lua_State* L) { int SWIG_arg = 0; int result; SWIG_check_num_args("ofGetPreviousMouseY",0,0) - result = (int)ofGetPreviousMouseY(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_DragInfo_files_set(lua_State* L) { int SWIG_arg = 0; ofDragInfo *arg1 = (ofDragInfo *) 0 ; - std::vector< std::string > *arg2 = (std::vector< std::string > *) 0 ; SWIG_check_num_args("ofDragInfo::files",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDragInfo::files",1,"ofDragInfo *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofDragInfo::files",2,"std::vector< std::string > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDragInfo,0))){ - SWIG_fail_ptr("DragInfo_files_set",1,SWIGTYPE_p_ofDragInfo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__vectorT_std__string_t,0))){ - SWIG_fail_ptr("DragInfo_files_set",2,SWIGTYPE_p_std__vectorT_std__string_t); } if (arg1) (arg1)->files = *arg2; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_DragInfo_files_get(lua_State* L) { int SWIG_arg = 0; ofDragInfo *arg1 = (ofDragInfo *) 0 ; - std::vector< std::string > *result = 0 ; SWIG_check_num_args("ofDragInfo::files",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDragInfo::files",1,"ofDragInfo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDragInfo,0))){ - SWIG_fail_ptr("DragInfo_files_get",1,SWIGTYPE_p_ofDragInfo); } result = (std::vector< std::string > *)& ((arg1)->files); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_std__string_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_DragInfo_position_set(lua_State* L) { int SWIG_arg = 0; ofDragInfo *arg1 = (ofDragInfo *) 0 ; - ofPoint *arg2 = (ofPoint *) 0 ; SWIG_check_num_args("ofDragInfo::position",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDragInfo::position",1,"ofDragInfo *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofDragInfo::position",2,"ofPoint *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDragInfo,0))){ - SWIG_fail_ptr("DragInfo_position_set",1,SWIGTYPE_p_ofDragInfo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("DragInfo_position_set",2,SWIGTYPE_p_ofVec3f); } if (arg1) (arg1)->position = *arg2; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_DragInfo_position_get(lua_State* L) { int SWIG_arg = 0; ofDragInfo *arg1 = (ofDragInfo *) 0 ; - ofPoint *result = 0 ; SWIG_check_num_args("ofDragInfo::position",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDragInfo::position",1,"ofDragInfo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDragInfo,0))){ - SWIG_fail_ptr("DragInfo_position_get",1,SWIGTYPE_p_ofDragInfo); } result = (ofPoint *)& ((arg1)->position); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_DragInfo(lua_State* L) { int SWIG_arg = 0; ofDragInfo *result = 0 ; - SWIG_check_num_args("ofDragInfo::ofDragInfo",0,0) result = (ofDragInfo *)new ofDragInfo(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofDragInfo,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static void swig_delete_DragInfo(void *obj) { -ofDragInfo *arg1 = (ofDragInfo *) obj; -delete arg1; -} -static int _proxy__wrap_new_DragInfo(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_DragInfo); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_DragInfo_attributes[] = { - { "files", _wrap_DragInfo_files_get, _wrap_DragInfo_files_set }, - { "position", _wrap_DragInfo_position_get, _wrap_DragInfo_position_set }, - {0,0,0} -}; -static swig_lua_method swig_DragInfo_methods[]= { - {0,0} -}; -static swig_lua_method swig_DragInfo_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_DragInfo_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_DragInfo_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_DragInfo_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_DragInfo_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_DragInfo_Sf_SwigStatic = { - "DragInfo", - swig_DragInfo_Sf_SwigStatic_methods, - swig_DragInfo_Sf_SwigStatic_attributes, - swig_DragInfo_Sf_SwigStatic_constants, - swig_DragInfo_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_DragInfo_bases[] = {0}; -static const char *swig_DragInfo_base_names[] = {0}; -static swig_lua_class _wrap_class_DragInfo = { "DragInfo", "DragInfo", &SWIGTYPE_p_ofDragInfo,_proxy__wrap_new_DragInfo, swig_delete_DragInfo, swig_DragInfo_methods, swig_DragInfo_attributes, &swig_DragInfo_Sf_SwigStatic, swig_DragInfo_meta, swig_DragInfo_bases, swig_DragInfo_base_names }; - -static int _wrap_new_TouchEventArgs__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofTouchEventArgs *result = 0 ; - SWIG_check_num_args("ofTouchEventArgs::ofTouchEventArgs",0,0) result = (ofTouchEventArgs *)new ofTouchEventArgs(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTouchEventArgs,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_TouchEventArgs__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofTouchEventArgs::Type arg1 ; float arg2 ; - float arg3 ; int arg4 ; ofTouchEventArgs *result = 0 ; SWIG_check_num_args("ofTouchEventArgs::ofTouchEventArgs",4,4) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofTouchEventArgs::ofTouchEventArgs",1,"ofTouchEventArgs::Type"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTouchEventArgs::ofTouchEventArgs",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTouchEventArgs::ofTouchEventArgs",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofTouchEventArgs::ofTouchEventArgs",4,"int"); - arg1 = (ofTouchEventArgs::Type)(int)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); result = (ofTouchEventArgs *)new ofTouchEventArgs(arg1,arg2,arg3,arg4); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTouchEventArgs,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_TouchEventArgs(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_TouchEventArgs__SWIG_0(L);} if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_new_TouchEventArgs__SWIG_1(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_TouchEventArgs'\n" " Possible C/C++ prototypes are:\n" - " ofTouchEventArgs::ofTouchEventArgs()\n" - " ofTouchEventArgs::ofTouchEventArgs(ofTouchEventArgs::Type,float,float,int)\n"); lua_error(L);return 0; } -static int _wrap_TouchEventArgs_type_set(lua_State* L) { int SWIG_arg = 0; ofTouchEventArgs *arg1 = (ofTouchEventArgs *) 0 ; - ofTouchEventArgs::Type arg2 ; SWIG_check_num_args("ofTouchEventArgs::type",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTouchEventArgs::type",1,"ofTouchEventArgs *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTouchEventArgs::type",2,"ofTouchEventArgs::Type"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTouchEventArgs,0))){ - SWIG_fail_ptr("TouchEventArgs_type_set",1,SWIGTYPE_p_ofTouchEventArgs); } - arg2 = (ofTouchEventArgs::Type)(int)lua_tonumber(L, 2); if (arg1) (arg1)->type = arg2; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_TouchEventArgs_type_get(lua_State* L) { int SWIG_arg = 0; ofTouchEventArgs *arg1 = (ofTouchEventArgs *) 0 ; - ofTouchEventArgs::Type result; SWIG_check_num_args("ofTouchEventArgs::type",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTouchEventArgs::type",1,"ofTouchEventArgs *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTouchEventArgs,0))){ - SWIG_fail_ptr("TouchEventArgs_type_get",1,SWIGTYPE_p_ofTouchEventArgs); } result = (ofTouchEventArgs::Type) ((arg1)->type); - lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_TouchEventArgs_id_set(lua_State* L) { int SWIG_arg = 0; ofTouchEventArgs *arg1 = (ofTouchEventArgs *) 0 ; - int arg2 ; SWIG_check_num_args("ofTouchEventArgs::id",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTouchEventArgs::id",1,"ofTouchEventArgs *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTouchEventArgs::id",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTouchEventArgs,0))){ - SWIG_fail_ptr("TouchEventArgs_id_set",1,SWIGTYPE_p_ofTouchEventArgs); } arg2 = (int)lua_tonumber(L, 2); - if (arg1) (arg1)->id = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TouchEventArgs_id_get(lua_State* L) { int SWIG_arg = 0; ofTouchEventArgs *arg1 = (ofTouchEventArgs *) 0 ; - int result; SWIG_check_num_args("ofTouchEventArgs::id",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTouchEventArgs::id",1,"ofTouchEventArgs *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTouchEventArgs,0))){ - SWIG_fail_ptr("TouchEventArgs_id_get",1,SWIGTYPE_p_ofTouchEventArgs); } result = (int) ((arg1)->id); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TouchEventArgs_time_set(lua_State* L) { int SWIG_arg = 0; ofTouchEventArgs *arg1 = (ofTouchEventArgs *) 0 ; - int arg2 ; SWIG_check_num_args("ofTouchEventArgs::time",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTouchEventArgs::time",1,"ofTouchEventArgs *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTouchEventArgs::time",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTouchEventArgs,0))){ - SWIG_fail_ptr("TouchEventArgs_time_set",1,SWIGTYPE_p_ofTouchEventArgs); } arg2 = (int)lua_tonumber(L, 2); - if (arg1) (arg1)->time = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TouchEventArgs_time_get(lua_State* L) { int SWIG_arg = 0; ofTouchEventArgs *arg1 = (ofTouchEventArgs *) 0 ; - int result; SWIG_check_num_args("ofTouchEventArgs::time",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTouchEventArgs::time",1,"ofTouchEventArgs *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTouchEventArgs,0))){ - SWIG_fail_ptr("TouchEventArgs_time_get",1,SWIGTYPE_p_ofTouchEventArgs); } result = (int) ((arg1)->time); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TouchEventArgs_numTouches_set(lua_State* L) { int SWIG_arg = 0; - ofTouchEventArgs *arg1 = (ofTouchEventArgs *) 0 ; int arg2 ; SWIG_check_num_args("ofTouchEventArgs::numTouches",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTouchEventArgs::numTouches",1,"ofTouchEventArgs *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTouchEventArgs::numTouches",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTouchEventArgs,0))){ - SWIG_fail_ptr("TouchEventArgs_numTouches_set",1,SWIGTYPE_p_ofTouchEventArgs); } arg2 = (int)lua_tonumber(L, 2); - if (arg1) (arg1)->numTouches = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TouchEventArgs_numTouches_get(lua_State* L) { int SWIG_arg = 0; - ofTouchEventArgs *arg1 = (ofTouchEventArgs *) 0 ; int result; SWIG_check_num_args("ofTouchEventArgs::numTouches",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTouchEventArgs::numTouches",1,"ofTouchEventArgs *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTouchEventArgs,0))){ - SWIG_fail_ptr("TouchEventArgs_numTouches_get",1,SWIGTYPE_p_ofTouchEventArgs); } result = (int) ((arg1)->numTouches); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TouchEventArgs_width_set(lua_State* L) { int SWIG_arg = 0; ofTouchEventArgs *arg1 = (ofTouchEventArgs *) 0 ; - float arg2 ; SWIG_check_num_args("ofTouchEventArgs::width",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTouchEventArgs::width",1,"ofTouchEventArgs *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTouchEventArgs::width",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTouchEventArgs,0))){ - SWIG_fail_ptr("TouchEventArgs_width_set",1,SWIGTYPE_p_ofTouchEventArgs); } arg2 = (float)lua_tonumber(L, 2); - if (arg1) (arg1)->width = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TouchEventArgs_width_get(lua_State* L) { int SWIG_arg = 0; ofTouchEventArgs *arg1 = (ofTouchEventArgs *) 0 ; - float result; SWIG_check_num_args("ofTouchEventArgs::width",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTouchEventArgs::width",1,"ofTouchEventArgs *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTouchEventArgs,0))){ - SWIG_fail_ptr("TouchEventArgs_width_get",1,SWIGTYPE_p_ofTouchEventArgs); } result = (float) ((arg1)->width); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TouchEventArgs_height_set(lua_State* L) { int SWIG_arg = 0; ofTouchEventArgs *arg1 = (ofTouchEventArgs *) 0 ; - float arg2 ; SWIG_check_num_args("ofTouchEventArgs::height",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTouchEventArgs::height",1,"ofTouchEventArgs *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTouchEventArgs::height",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTouchEventArgs,0))){ - SWIG_fail_ptr("TouchEventArgs_height_set",1,SWIGTYPE_p_ofTouchEventArgs); } arg2 = (float)lua_tonumber(L, 2); - if (arg1) (arg1)->height = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TouchEventArgs_height_get(lua_State* L) { int SWIG_arg = 0; ofTouchEventArgs *arg1 = (ofTouchEventArgs *) 0 ; - float result; SWIG_check_num_args("ofTouchEventArgs::height",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTouchEventArgs::height",1,"ofTouchEventArgs *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTouchEventArgs,0))){ - SWIG_fail_ptr("TouchEventArgs_height_get",1,SWIGTYPE_p_ofTouchEventArgs); } result = (float) ((arg1)->height); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TouchEventArgs_angle_set(lua_State* L) { int SWIG_arg = 0; ofTouchEventArgs *arg1 = (ofTouchEventArgs *) 0 ; - float arg2 ; SWIG_check_num_args("ofTouchEventArgs::angle",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTouchEventArgs::angle",1,"ofTouchEventArgs *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTouchEventArgs::angle",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTouchEventArgs,0))){ - SWIG_fail_ptr("TouchEventArgs_angle_set",1,SWIGTYPE_p_ofTouchEventArgs); } arg2 = (float)lua_tonumber(L, 2); - if (arg1) (arg1)->angle = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TouchEventArgs_angle_get(lua_State* L) { int SWIG_arg = 0; ofTouchEventArgs *arg1 = (ofTouchEventArgs *) 0 ; - float result; SWIG_check_num_args("ofTouchEventArgs::angle",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTouchEventArgs::angle",1,"ofTouchEventArgs *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTouchEventArgs,0))){ - SWIG_fail_ptr("TouchEventArgs_angle_get",1,SWIGTYPE_p_ofTouchEventArgs); } result = (float) ((arg1)->angle); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TouchEventArgs_minoraxis_set(lua_State* L) { int SWIG_arg = 0; - ofTouchEventArgs *arg1 = (ofTouchEventArgs *) 0 ; float arg2 ; SWIG_check_num_args("ofTouchEventArgs::minoraxis",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTouchEventArgs::minoraxis",1,"ofTouchEventArgs *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTouchEventArgs::minoraxis",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTouchEventArgs,0))){ - SWIG_fail_ptr("TouchEventArgs_minoraxis_set",1,SWIGTYPE_p_ofTouchEventArgs); } arg2 = (float)lua_tonumber(L, 2); - if (arg1) (arg1)->minoraxis = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TouchEventArgs_minoraxis_get(lua_State* L) { int SWIG_arg = 0; - ofTouchEventArgs *arg1 = (ofTouchEventArgs *) 0 ; float result; SWIG_check_num_args("ofTouchEventArgs::minoraxis",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTouchEventArgs::minoraxis",1,"ofTouchEventArgs *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTouchEventArgs,0))){ - SWIG_fail_ptr("TouchEventArgs_minoraxis_get",1,SWIGTYPE_p_ofTouchEventArgs); } result = (float) ((arg1)->minoraxis); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TouchEventArgs_majoraxis_set(lua_State* L) { int SWIG_arg = 0; - ofTouchEventArgs *arg1 = (ofTouchEventArgs *) 0 ; float arg2 ; SWIG_check_num_args("ofTouchEventArgs::majoraxis",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTouchEventArgs::majoraxis",1,"ofTouchEventArgs *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTouchEventArgs::majoraxis",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTouchEventArgs,0))){ - SWIG_fail_ptr("TouchEventArgs_majoraxis_set",1,SWIGTYPE_p_ofTouchEventArgs); } arg2 = (float)lua_tonumber(L, 2); - if (arg1) (arg1)->majoraxis = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TouchEventArgs_majoraxis_get(lua_State* L) { int SWIG_arg = 0; - ofTouchEventArgs *arg1 = (ofTouchEventArgs *) 0 ; float result; SWIG_check_num_args("ofTouchEventArgs::majoraxis",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTouchEventArgs::majoraxis",1,"ofTouchEventArgs *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTouchEventArgs,0))){ - SWIG_fail_ptr("TouchEventArgs_majoraxis_get",1,SWIGTYPE_p_ofTouchEventArgs); } result = (float) ((arg1)->majoraxis); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TouchEventArgs_pressure_set(lua_State* L) { int SWIG_arg = 0; ofTouchEventArgs *arg1 = (ofTouchEventArgs *) 0 ; - float arg2 ; SWIG_check_num_args("ofTouchEventArgs::pressure",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTouchEventArgs::pressure",1,"ofTouchEventArgs *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTouchEventArgs::pressure",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTouchEventArgs,0))){ - SWIG_fail_ptr("TouchEventArgs_pressure_set",1,SWIGTYPE_p_ofTouchEventArgs); } arg2 = (float)lua_tonumber(L, 2); - if (arg1) (arg1)->pressure = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TouchEventArgs_pressure_get(lua_State* L) { int SWIG_arg = 0; ofTouchEventArgs *arg1 = (ofTouchEventArgs *) 0 ; - float result; SWIG_check_num_args("ofTouchEventArgs::pressure",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTouchEventArgs::pressure",1,"ofTouchEventArgs *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTouchEventArgs,0))){ - SWIG_fail_ptr("TouchEventArgs_pressure_get",1,SWIGTYPE_p_ofTouchEventArgs); } result = (float) ((arg1)->pressure); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TouchEventArgs_xspeed_set(lua_State* L) { int SWIG_arg = 0; ofTouchEventArgs *arg1 = (ofTouchEventArgs *) 0 ; - float arg2 ; SWIG_check_num_args("ofTouchEventArgs::xspeed",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTouchEventArgs::xspeed",1,"ofTouchEventArgs *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTouchEventArgs::xspeed",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTouchEventArgs,0))){ - SWIG_fail_ptr("TouchEventArgs_xspeed_set",1,SWIGTYPE_p_ofTouchEventArgs); } arg2 = (float)lua_tonumber(L, 2); - if (arg1) (arg1)->xspeed = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TouchEventArgs_xspeed_get(lua_State* L) { int SWIG_arg = 0; ofTouchEventArgs *arg1 = (ofTouchEventArgs *) 0 ; - float result; SWIG_check_num_args("ofTouchEventArgs::xspeed",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTouchEventArgs::xspeed",1,"ofTouchEventArgs *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTouchEventArgs,0))){ - SWIG_fail_ptr("TouchEventArgs_xspeed_get",1,SWIGTYPE_p_ofTouchEventArgs); } result = (float) ((arg1)->xspeed); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TouchEventArgs_yspeed_set(lua_State* L) { int SWIG_arg = 0; ofTouchEventArgs *arg1 = (ofTouchEventArgs *) 0 ; - float arg2 ; SWIG_check_num_args("ofTouchEventArgs::yspeed",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTouchEventArgs::yspeed",1,"ofTouchEventArgs *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTouchEventArgs::yspeed",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTouchEventArgs,0))){ - SWIG_fail_ptr("TouchEventArgs_yspeed_set",1,SWIGTYPE_p_ofTouchEventArgs); } arg2 = (float)lua_tonumber(L, 2); - if (arg1) (arg1)->yspeed = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TouchEventArgs_yspeed_get(lua_State* L) { int SWIG_arg = 0; ofTouchEventArgs *arg1 = (ofTouchEventArgs *) 0 ; - float result; SWIG_check_num_args("ofTouchEventArgs::yspeed",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTouchEventArgs::yspeed",1,"ofTouchEventArgs *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTouchEventArgs,0))){ - SWIG_fail_ptr("TouchEventArgs_yspeed_get",1,SWIGTYPE_p_ofTouchEventArgs); } result = (float) ((arg1)->yspeed); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TouchEventArgs_xaccel_set(lua_State* L) { int SWIG_arg = 0; ofTouchEventArgs *arg1 = (ofTouchEventArgs *) 0 ; - float arg2 ; SWIG_check_num_args("ofTouchEventArgs::xaccel",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTouchEventArgs::xaccel",1,"ofTouchEventArgs *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTouchEventArgs::xaccel",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTouchEventArgs,0))){ - SWIG_fail_ptr("TouchEventArgs_xaccel_set",1,SWIGTYPE_p_ofTouchEventArgs); } arg2 = (float)lua_tonumber(L, 2); - if (arg1) (arg1)->xaccel = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TouchEventArgs_xaccel_get(lua_State* L) { int SWIG_arg = 0; ofTouchEventArgs *arg1 = (ofTouchEventArgs *) 0 ; - float result; SWIG_check_num_args("ofTouchEventArgs::xaccel",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTouchEventArgs::xaccel",1,"ofTouchEventArgs *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTouchEventArgs,0))){ - SWIG_fail_ptr("TouchEventArgs_xaccel_get",1,SWIGTYPE_p_ofTouchEventArgs); } result = (float) ((arg1)->xaccel); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TouchEventArgs_yaccel_set(lua_State* L) { int SWIG_arg = 0; ofTouchEventArgs *arg1 = (ofTouchEventArgs *) 0 ; - float arg2 ; SWIG_check_num_args("ofTouchEventArgs::yaccel",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTouchEventArgs::yaccel",1,"ofTouchEventArgs *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTouchEventArgs::yaccel",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTouchEventArgs,0))){ - SWIG_fail_ptr("TouchEventArgs_yaccel_set",1,SWIGTYPE_p_ofTouchEventArgs); } arg2 = (float)lua_tonumber(L, 2); - if (arg1) (arg1)->yaccel = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TouchEventArgs_yaccel_get(lua_State* L) { int SWIG_arg = 0; ofTouchEventArgs *arg1 = (ofTouchEventArgs *) 0 ; - float result; SWIG_check_num_args("ofTouchEventArgs::yaccel",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTouchEventArgs::yaccel",1,"ofTouchEventArgs *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTouchEventArgs,0))){ - SWIG_fail_ptr("TouchEventArgs_yaccel_get",1,SWIGTYPE_p_ofTouchEventArgs); } result = (float) ((arg1)->yaccel); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_TouchEventArgs(void *obj) { -ofTouchEventArgs *arg1 = (ofTouchEventArgs *) obj; -delete arg1; -} -static int _proxy__wrap_new_TouchEventArgs(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_TouchEventArgs); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_TouchEventArgs_attributes[] = { - { "type", _wrap_TouchEventArgs_type_get, _wrap_TouchEventArgs_type_set }, - { "id", _wrap_TouchEventArgs_id_get, _wrap_TouchEventArgs_id_set }, - { "time", _wrap_TouchEventArgs_time_get, _wrap_TouchEventArgs_time_set }, - { "numTouches", _wrap_TouchEventArgs_numTouches_get, _wrap_TouchEventArgs_numTouches_set }, - { "width", _wrap_TouchEventArgs_width_get, _wrap_TouchEventArgs_width_set }, - { "height", _wrap_TouchEventArgs_height_get, _wrap_TouchEventArgs_height_set }, - { "angle", _wrap_TouchEventArgs_angle_get, _wrap_TouchEventArgs_angle_set }, - { "minoraxis", _wrap_TouchEventArgs_minoraxis_get, _wrap_TouchEventArgs_minoraxis_set }, - { "majoraxis", _wrap_TouchEventArgs_majoraxis_get, _wrap_TouchEventArgs_majoraxis_set }, - { "pressure", _wrap_TouchEventArgs_pressure_get, _wrap_TouchEventArgs_pressure_set }, - { "xspeed", _wrap_TouchEventArgs_xspeed_get, _wrap_TouchEventArgs_xspeed_set }, - { "yspeed", _wrap_TouchEventArgs_yspeed_get, _wrap_TouchEventArgs_yspeed_set }, - { "xaccel", _wrap_TouchEventArgs_xaccel_get, _wrap_TouchEventArgs_xaccel_set }, - { "yaccel", _wrap_TouchEventArgs_yaccel_get, _wrap_TouchEventArgs_yaccel_set }, - {0,0,0} -}; -static swig_lua_method swig_TouchEventArgs_methods[]= { - {0,0} -}; -static swig_lua_method swig_TouchEventArgs_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_TouchEventArgs_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_TouchEventArgs_Sf_SwigStatic_constants[]= { - {SWIG_LUA_CONSTTAB_INT("down", ofTouchEventArgs::down)}, - {SWIG_LUA_CONSTTAB_INT("up", ofTouchEventArgs::up)}, - {SWIG_LUA_CONSTTAB_INT("move", ofTouchEventArgs::move)}, - {SWIG_LUA_CONSTTAB_INT("doubleTap", ofTouchEventArgs::doubleTap)}, - {SWIG_LUA_CONSTTAB_INT("cancel", ofTouchEventArgs::cancel)}, - {0,0,0,0,0,0} -}; -static swig_lua_method swig_TouchEventArgs_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_TouchEventArgs_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_TouchEventArgs_Sf_SwigStatic = { - "TouchEventArgs", - swig_TouchEventArgs_Sf_SwigStatic_methods, - swig_TouchEventArgs_Sf_SwigStatic_attributes, - swig_TouchEventArgs_Sf_SwigStatic_constants, - swig_TouchEventArgs_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_TouchEventArgs_bases[] = {0,0}; -static const char *swig_TouchEventArgs_base_names[] = {"ofVec2f *",0}; -static swig_lua_class _wrap_class_TouchEventArgs = { "TouchEventArgs", "TouchEventArgs", &SWIGTYPE_p_ofTouchEventArgs,_proxy__wrap_new_TouchEventArgs, swig_delete_TouchEventArgs, swig_TouchEventArgs_methods, swig_TouchEventArgs_attributes, &swig_TouchEventArgs_Sf_SwigStatic, swig_TouchEventArgs_meta, swig_TouchEventArgs_bases, swig_TouchEventArgs_base_names }; - -static int _wrap_sendMessage(lua_State* L) { int SWIG_arg = 0; std::string arg1 ; SWIG_check_num_args("ofSendMessage",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofSendMessage",1,"std::string"); (&arg1)->assign(lua_tostring(L,1),lua_rawlen(L,1)); - ofSendMessage(arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_new_BufferObject(lua_State* L) { int SWIG_arg = 0; ofBufferObject *result = 0 ; - SWIG_check_num_args("ofBufferObject::ofBufferObject",0,0) result = (ofBufferObject *)new ofBufferObject(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofBufferObject,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_BufferObject_allocate__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofBufferObject *arg1 = (ofBufferObject *) 0 ; - SWIG_check_num_args("ofBufferObject::allocate",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBufferObject::allocate",1,"ofBufferObject *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBufferObject,0))){ - SWIG_fail_ptr("BufferObject_allocate",1,SWIGTYPE_p_ofBufferObject); } (arg1)->allocate(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_BufferObject_allocate__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofBufferObject *arg1 = (ofBufferObject *) 0 ; - GLsizeiptr arg2 ; GLenum arg3 ; GLsizeiptr *argp2 ; SWIG_check_num_args("ofBufferObject::allocate",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBufferObject::allocate",1,"ofBufferObject *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofBufferObject::allocate",2,"GLsizeiptr"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofBufferObject::allocate",3,"GLenum"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBufferObject,0))){ - SWIG_fail_ptr("BufferObject_allocate",1,SWIGTYPE_p_ofBufferObject); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_GLsizeiptr,0))){ - SWIG_fail_ptr("BufferObject_allocate",2,SWIGTYPE_p_GLsizeiptr); } arg2 = *argp2; - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (GLenum)lua_tonumber(L, 3); - (arg1)->allocate(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BufferObject_allocate__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofBufferObject *arg1 = (ofBufferObject *) 0 ; - GLsizeiptr arg2 ; void *arg3 = (void *) 0 ; GLenum arg4 ; GLsizeiptr *argp2 ; - SWIG_check_num_args("ofBufferObject::allocate",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBufferObject::allocate",1,"ofBufferObject *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofBufferObject::allocate",2,"GLsizeiptr"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofBufferObject::allocate",3,"void const *"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofBufferObject::allocate",4,"GLenum"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBufferObject,0))){ - SWIG_fail_ptr("BufferObject_allocate",1,SWIGTYPE_p_ofBufferObject); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_GLsizeiptr,0))){ - SWIG_fail_ptr("BufferObject_allocate",2,SWIGTYPE_p_GLsizeiptr); } arg2 = *argp2; - arg3=(void *)SWIG_MustGetPtr(L,3,0,0,3,"BufferObject_allocate"); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (GLenum)lua_tonumber(L, 4); - (arg1)->allocate(arg2,(void const *)arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BufferObject_allocate(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 1) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofBufferObject, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_BufferObject_allocate__SWIG_0(L);} } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofBufferObject, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_GLsizeiptr, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_BufferObject_allocate__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofBufferObject, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_GLsizeiptr, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, 0, 0)) { _v = 0; } else { _v = 1; } } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_BufferObject_allocate__SWIG_2(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'BufferObject_allocate'\n" - " Possible C/C++ prototypes are:\n" " ofBufferObject::allocate()\n" " ofBufferObject::allocate(GLsizeiptr,GLenum)\n" - " ofBufferObject::allocate(GLsizeiptr,void const *,GLenum)\n"); lua_error(L);return 0; } -static int _wrap_BufferObject_isAllocated(lua_State* L) { int SWIG_arg = 0; ofBufferObject *arg1 = (ofBufferObject *) 0 ; - bool result; SWIG_check_num_args("ofBufferObject::isAllocated",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBufferObject::isAllocated",1,"ofBufferObject const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBufferObject,0))){ - SWIG_fail_ptr("BufferObject_isAllocated",1,SWIGTYPE_p_ofBufferObject); } - result = (bool)((ofBufferObject const *)arg1)->isAllocated(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BufferObject_bind(lua_State* L) { int SWIG_arg = 0; ofBufferObject *arg1 = (ofBufferObject *) 0 ; GLenum arg2 ; - SWIG_check_num_args("ofBufferObject::bind",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBufferObject::bind",1,"ofBufferObject const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBufferObject::bind",2,"GLenum"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBufferObject,0))){ - SWIG_fail_ptr("BufferObject_bind",1,SWIGTYPE_p_ofBufferObject); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (GLenum)lua_tonumber(L, 2); - ((ofBufferObject const *)arg1)->bind(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BufferObject_unbind(lua_State* L) { int SWIG_arg = 0; ofBufferObject *arg1 = (ofBufferObject *) 0 ; - GLenum arg2 ; SWIG_check_num_args("ofBufferObject::unbind",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBufferObject::unbind",1,"ofBufferObject const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBufferObject::unbind",2,"GLenum"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBufferObject,0))){ - SWIG_fail_ptr("BufferObject_unbind",1,SWIGTYPE_p_ofBufferObject); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (GLenum)lua_tonumber(L, 2); - ((ofBufferObject const *)arg1)->unbind(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BufferObject_getId(lua_State* L) { int SWIG_arg = 0; ofBufferObject *arg1 = (ofBufferObject *) 0 ; - GLuint result; SWIG_check_num_args("ofBufferObject::getId",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBufferObject::getId",1,"ofBufferObject const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBufferObject,0))){ - SWIG_fail_ptr("BufferObject_getId",1,SWIGTYPE_p_ofBufferObject); } - result = (GLuint)((ofBufferObject const *)arg1)->getId(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BufferObject_setData(lua_State* L) { int SWIG_arg = 0; ofBufferObject *arg1 = (ofBufferObject *) 0 ; - GLsizeiptr arg2 ; void *arg3 = (void *) 0 ; GLenum arg4 ; GLsizeiptr *argp2 ; - SWIG_check_num_args("ofBufferObject::setData",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBufferObject::setData",1,"ofBufferObject *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofBufferObject::setData",2,"GLsizeiptr"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofBufferObject::setData",3,"void const *"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofBufferObject::setData",4,"GLenum"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBufferObject,0))){ - SWIG_fail_ptr("BufferObject_setData",1,SWIGTYPE_p_ofBufferObject); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_GLsizeiptr,0))){ - SWIG_fail_ptr("BufferObject_setData",2,SWIGTYPE_p_GLsizeiptr); } arg2 = *argp2; - arg3=(void *)SWIG_MustGetPtr(L,3,0,0,3,"BufferObject_setData"); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (GLenum)lua_tonumber(L, 4); - (arg1)->setData(arg2,(void const *)arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BufferObject_updateData__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofBufferObject *arg1 = (ofBufferObject *) 0 ; - GLintptr arg2 ; GLsizeiptr arg3 ; void *arg4 = (void *) 0 ; GLintptr *argp2 ; GLsizeiptr *argp3 ; - SWIG_check_num_args("ofBufferObject::updateData",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBufferObject::updateData",1,"ofBufferObject *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofBufferObject::updateData",2,"GLintptr"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofBufferObject::updateData",3,"GLsizeiptr"); - if(!SWIG_isptrtype(L,4)) SWIG_fail_arg("ofBufferObject::updateData",4,"void const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBufferObject,0))){ - SWIG_fail_ptr("BufferObject_updateData",1,SWIGTYPE_p_ofBufferObject); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_GLintptr,0))){ - SWIG_fail_ptr("BufferObject_updateData",2,SWIGTYPE_p_GLintptr); } arg2 = *argp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&argp3,SWIGTYPE_p_GLsizeiptr,0))){ - SWIG_fail_ptr("BufferObject_updateData",3,SWIGTYPE_p_GLsizeiptr); } arg3 = *argp3; - arg4=(void *)SWIG_MustGetPtr(L,4,0,0,4,"BufferObject_updateData"); (arg1)->updateData(arg2,arg3,(void const *)arg4); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BufferObject_updateData__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofBufferObject *arg1 = (ofBufferObject *) 0 ; - GLsizeiptr arg2 ; void *arg3 = (void *) 0 ; GLsizeiptr *argp2 ; SWIG_check_num_args("ofBufferObject::updateData",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBufferObject::updateData",1,"ofBufferObject *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofBufferObject::updateData",2,"GLsizeiptr"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofBufferObject::updateData",3,"void const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBufferObject,0))){ - SWIG_fail_ptr("BufferObject_updateData",1,SWIGTYPE_p_ofBufferObject); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_GLsizeiptr,0))){ - SWIG_fail_ptr("BufferObject_updateData",2,SWIGTYPE_p_GLsizeiptr); } arg2 = *argp2; - arg3=(void *)SWIG_MustGetPtr(L,3,0,0,3,"BufferObject_updateData"); (arg1)->updateData(arg2,(void const *)arg3); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_BufferObject_updateData(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofBufferObject, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_GLsizeiptr, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, 0, 0)) { _v = 0; } else { _v = 1; } } - if (_v) { return _wrap_BufferObject_updateData__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofBufferObject, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_GLintptr, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_GLsizeiptr, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, 0, 0)) { _v = 0; } else { _v = 1; } - } if (_v) { return _wrap_BufferObject_updateData__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'BufferObject_updateData'\n" - " Possible C/C++ prototypes are:\n" " ofBufferObject::updateData(GLintptr,GLsizeiptr,void const *)\n" - " ofBufferObject::updateData(GLsizeiptr,void const *)\n"); lua_error(L);return 0; } -static int _wrap_BufferObject_size(lua_State* L) { int SWIG_arg = 0; ofBufferObject *arg1 = (ofBufferObject *) 0 ; - GLsizeiptr result; SWIG_check_num_args("ofBufferObject::size",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBufferObject::size",1,"ofBufferObject const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBufferObject,0))){ - SWIG_fail_ptr("BufferObject_size",1,SWIGTYPE_p_ofBufferObject); } result = ((ofBufferObject const *)arg1)->size(); { - GLsizeiptr * resultptr = new GLsizeiptr((const GLsizeiptr &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_GLsizeiptr,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static void swig_delete_BufferObject(void *obj) { -ofBufferObject *arg1 = (ofBufferObject *) obj; -delete arg1; -} -static int _proxy__wrap_new_BufferObject(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_BufferObject); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_BufferObject_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_BufferObject_methods[]= { - { "allocate", _wrap_BufferObject_allocate}, - { "isAllocated", _wrap_BufferObject_isAllocated}, - { "bind", _wrap_BufferObject_bind}, - { "unbind", _wrap_BufferObject_unbind}, - { "getId", _wrap_BufferObject_getId}, - { "setData", _wrap_BufferObject_setData}, - { "updateData", _wrap_BufferObject_updateData}, - { "size", _wrap_BufferObject_size}, - {0,0} -}; -static swig_lua_method swig_BufferObject_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_BufferObject_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_BufferObject_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_BufferObject_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_BufferObject_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_BufferObject_Sf_SwigStatic = { - "BufferObject", - swig_BufferObject_Sf_SwigStatic_methods, - swig_BufferObject_Sf_SwigStatic_attributes, - swig_BufferObject_Sf_SwigStatic_constants, - swig_BufferObject_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_BufferObject_bases[] = {0}; -static const char *swig_BufferObject_base_names[] = {0}; -static swig_lua_class _wrap_class_BufferObject = { "BufferObject", "BufferObject", &SWIGTYPE_p_ofBufferObject,_proxy__wrap_new_BufferObject, swig_delete_BufferObject, swig_BufferObject_methods, swig_BufferObject_attributes, &swig_BufferObject_Sf_SwigStatic, swig_BufferObject_meta, swig_BufferObject_bases, swig_BufferObject_base_names }; - -static int _wrap_getGlInternalFormat__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPixels *arg1 = 0 ; int result; - SWIG_check_num_args("ofGetGlInternalFormat",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofGetGlInternalFormat",1,"ofPixels const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("getGlInternalFormat",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - result = (int)ofGetGlInternalFormat((ofPixels_< unsigned char > const &)*arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getGlInternalFormat__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofShortPixels *arg1 = 0 ; int result; - SWIG_check_num_args("ofGetGlInternalFormat",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofGetGlInternalFormat",1,"ofShortPixels const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("getGlInternalFormat",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - result = (int)ofGetGlInternalFormat((ofPixels_< unsigned short > const &)*arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getGlInternalFormat__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofFloatPixels *arg1 = 0 ; int result; - SWIG_check_num_args("ofGetGlInternalFormat",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofGetGlInternalFormat",1,"ofFloatPixels const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("getGlInternalFormat",1,SWIGTYPE_p_ofPixels_T_float_t); } - result = (int)ofGetGlInternalFormat((ofPixels_< float > const &)*arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getGlInternalFormat(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_getGlInternalFormat__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_getGlInternalFormat__SWIG_1(L);} } if (argc == 1) { int _v; { - void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_getGlInternalFormat__SWIG_2(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'getGlInternalFormat'\n" - " Possible C/C++ prototypes are:\n" " ofGetGlInternalFormat(ofPixels const &)\n" - " ofGetGlInternalFormat(ofShortPixels const &)\n" " ofGetGlInternalFormat(ofFloatPixels const &)\n"); - lua_error(L);return 0; } -static int _wrap_getGlInternalFormatName(lua_State* L) { int SWIG_arg = 0; int arg1 ; std::string result; - SWIG_check_num_args("ofGetGlInternalFormatName",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofGetGlInternalFormatName",1,"int"); arg1 = (int)lua_tonumber(L, 1); - result = ofGetGlInternalFormatName(arg1); lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getGLFormatFromInternal(lua_State* L) { int SWIG_arg = 0; int arg1 ; int result; - SWIG_check_num_args("ofGetGLFormatFromInternal",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofGetGLFormatFromInternal",1,"int"); arg1 = (int)lua_tonumber(L, 1); - result = (int)ofGetGLFormatFromInternal(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getGlTypeFromInternal(lua_State* L) { int SWIG_arg = 0; int arg1 ; int result; - SWIG_check_num_args("ofGetGlTypeFromInternal",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofGetGlTypeFromInternal",1,"int"); - arg1 = (int)lua_tonumber(L, 1); result = (int)ofGetGlTypeFromInternal(arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getGlType__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPixels *arg1 = 0 ; int result; - SWIG_check_num_args("ofGetGlType",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofGetGlType",1,"ofPixels const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("getGlType",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - result = (int)ofGetGlType((ofPixels_< unsigned char > const &)*arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getGlType__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofShortPixels *arg1 = 0 ; int result; - SWIG_check_num_args("ofGetGlType",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofGetGlType",1,"ofShortPixels const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("getGlType",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - result = (int)ofGetGlType((ofPixels_< unsigned short > const &)*arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getGlType__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofFloatPixels *arg1 = 0 ; int result; - SWIG_check_num_args("ofGetGlType",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofGetGlType",1,"ofFloatPixels const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("getGlType",1,SWIGTYPE_p_ofPixels_T_float_t); } result = (int)ofGetGlType((ofPixels_< float > const &)*arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getGlType(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_getGlType__SWIG_0(L);} } if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_getGlType__SWIG_1(L);} } if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_getGlType__SWIG_2(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'getGlType'\n" " Possible C/C++ prototypes are:\n" - " ofGetGlType(ofPixels const &)\n" " ofGetGlType(ofShortPixels const &)\n" " ofGetGlType(ofFloatPixels const &)\n"); - lua_error(L);return 0; } -static int _wrap_getImageTypeFromGLType(lua_State* L) { int SWIG_arg = 0; int arg1 ; ofImageType result; - SWIG_check_num_args("ofGetImageTypeFromGLType",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofGetImageTypeFromGLType",1,"int"); - arg1 = (int)lua_tonumber(L, 1); result = (ofImageType)ofGetImageTypeFromGLType(arg1); - lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_getGLPolyMode(lua_State* L) { int SWIG_arg = 0; ofPolyRenderMode arg1 ; GLuint result; - SWIG_check_num_args("ofGetGLPolyMode",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofGetGLPolyMode",1,"ofPolyRenderMode"); - arg1 = (ofPolyRenderMode)(int)lua_tonumber(L, 1); result = (GLuint)ofGetGLPolyMode(arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getOFPolyMode(lua_State* L) { int SWIG_arg = 0; GLuint arg1 ; ofPolyRenderMode result; - SWIG_check_num_args("ofGetOFPolyMode",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofGetOFPolyMode",1,"GLuint"); - SWIG_contract_assert((lua_tonumber(L,1)>=0),"number must not be negative") arg1 = (GLuint)lua_tonumber(L, 1); - result = (ofPolyRenderMode)ofGetOFPolyMode(arg1); lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getGLPrimitiveMode(lua_State* L) { int SWIG_arg = 0; ofPrimitiveMode arg1 ; GLuint result; - SWIG_check_num_args("ofGetGLPrimitiveMode",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofGetGLPrimitiveMode",1,"ofPrimitiveMode"); - arg1 = (ofPrimitiveMode)(int)lua_tonumber(L, 1); result = (GLuint)ofGetGLPrimitiveMode(arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getOFPrimitiveMode(lua_State* L) { int SWIG_arg = 0; GLuint arg1 ; ofPrimitiveMode result; - SWIG_check_num_args("ofGetOFPrimitiveMode",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofGetOFPrimitiveMode",1,"GLuint"); - SWIG_contract_assert((lua_tonumber(L,1)>=0),"number must not be negative") arg1 = (GLuint)lua_tonumber(L, 1); - result = (ofPrimitiveMode)ofGetOFPrimitiveMode(arg1); lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getGLInternalFormatFromPixelFormat(lua_State* L) { int SWIG_arg = 0; ofPixelFormat arg1 ; int result; - SWIG_check_num_args("ofGetGLInternalFormatFromPixelFormat",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofGetGLInternalFormatFromPixelFormat",1,"ofPixelFormat"); - arg1 = (ofPixelFormat)(int)lua_tonumber(L, 1); result = (int)ofGetGLInternalFormatFromPixelFormat(arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getGLFormatFromPixelFormat(lua_State* L) { int SWIG_arg = 0; ofPixelFormat arg1 ; int result; - SWIG_check_num_args("ofGetGLFormatFromPixelFormat",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofGetGLFormatFromPixelFormat",1,"ofPixelFormat"); - arg1 = (ofPixelFormat)(int)lua_tonumber(L, 1); result = (int)ofGetGLFormatFromPixelFormat(arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getBytesPerChannelFromGLType(lua_State* L) { int SWIG_arg = 0; int arg1 ; int result; - SWIG_check_num_args("ofGetBytesPerChannelFromGLType",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofGetBytesPerChannelFromGLType",1,"int"); arg1 = (int)lua_tonumber(L, 1); - result = (int)ofGetBytesPerChannelFromGLType(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getNumChannelsFromGLFormat(lua_State* L) { int SWIG_arg = 0; int arg1 ; int result; - SWIG_check_num_args("ofGetNumChannelsFromGLFormat",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofGetNumChannelsFromGLFormat",1,"int"); arg1 = (int)lua_tonumber(L, 1); - result = (int)ofGetNumChannelsFromGLFormat(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setPixelStoreiAlignment__SWIG_0(lua_State* L) { int SWIG_arg = 0; GLenum arg1 ; int arg2 ; int arg3 ; - int arg4 ; SWIG_check_num_args("ofSetPixelStoreiAlignment",4,4) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetPixelStoreiAlignment",1,"GLenum"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSetPixelStoreiAlignment",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofSetPixelStoreiAlignment",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofSetPixelStoreiAlignment",4,"int"); - SWIG_contract_assert((lua_tonumber(L,1)>=0),"number must not be negative") arg1 = (GLenum)lua_tonumber(L, 1); - arg2 = (int)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - ofSetPixelStoreiAlignment(arg1,arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setPixelStoreiAlignment__SWIG_1(lua_State* L) { int SWIG_arg = 0; GLenum arg1 ; int arg2 ; - SWIG_check_num_args("ofSetPixelStoreiAlignment",2,2) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetPixelStoreiAlignment",1,"GLenum"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSetPixelStoreiAlignment",2,"int"); - SWIG_contract_assert((lua_tonumber(L,1)>=0),"number must not be negative") arg1 = (GLenum)lua_tonumber(L, 1); - arg2 = (int)lua_tonumber(L, 2); ofSetPixelStoreiAlignment(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_setPixelStoreiAlignment(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_setPixelStoreiAlignment__SWIG_1(L);} } } if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_setPixelStoreiAlignment__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'setPixelStoreiAlignment'\n" - " Possible C/C++ prototypes are:\n" " ofSetPixelStoreiAlignment(GLenum,int,int,int)\n" - " ofSetPixelStoreiAlignment(GLenum,int)\n"); lua_error(L);return 0; } -static int _wrap_GLSupportedExtensions(lua_State* L) { int SWIG_arg = 0; std::vector< std::string > result; - SWIG_check_num_args("ofGLSupportedExtensions",0,0) result = ofGLSupportedExtensions(); { - std::vector< std::string > * resultptr = new std::vector< std::string >((const std::vector< std::string > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_std__string_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_GLCheckExtension(lua_State* L) { int SWIG_arg = 0; std::string arg1 ; bool result; - SWIG_check_num_args("ofGLCheckExtension",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofGLCheckExtension",1,"std::string"); - (&arg1)->assign(lua_tostring(L,1),lua_rawlen(L,1)); result = (bool)ofGLCheckExtension(arg1); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_GLSupportsNPOTTextures(lua_State* L) { int SWIG_arg = 0; bool result; - SWIG_check_num_args("ofGLSupportsNPOTTextures",0,0) result = (bool)ofGLSupportsNPOTTextures(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_isGLProgrammableRenderer(lua_State* L) { int SWIG_arg = 0; bool result; - SWIG_check_num_args("ofIsGLProgrammableRenderer",0,0) result = (bool)ofIsGLProgrammableRenderer(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_GLSLVersionFromGL(lua_State* L) { int SWIG_arg = 0; int arg1 ; int arg2 ; std::string result; - SWIG_check_num_args("ofGLSLVersionFromGL",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofGLSLVersionFromGL",1,"int"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofGLSLVersionFromGL",2,"int"); arg1 = (int)lua_tonumber(L, 1); - arg2 = (int)lua_tonumber(L, 2); result = ofGLSLVersionFromGL(arg1,arg2); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_enableLighting(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofEnableLighting",0,0) - ofEnableLighting(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_disableLighting(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofDisableLighting",0,0) - ofDisableLighting(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_enableSeparateSpecularLight(lua_State* L) { int SWIG_arg = 0; - SWIG_check_num_args("ofEnableSeparateSpecularLight",0,0) ofEnableSeparateSpecularLight(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_disableSeparateSpecularLight(lua_State* L) { int SWIG_arg = 0; - SWIG_check_num_args("ofDisableSeparateSpecularLight",0,0) ofDisableSeparateSpecularLight(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_getLightingEnabled(lua_State* L) { int SWIG_arg = 0; bool result; - SWIG_check_num_args("ofGetLightingEnabled",0,0) result = (bool)ofGetLightingEnabled(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setSmoothLighting(lua_State* L) { int SWIG_arg = 0; bool arg1 ; SWIG_check_num_args("ofSetSmoothLighting",1,1) - if(!lua_isboolean(L,1)) SWIG_fail_arg("ofSetSmoothLighting",1,"bool"); arg1 = (lua_toboolean(L, 1)!=0); - ofSetSmoothLighting(arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setGlobalAmbientColor(lua_State* L) { int SWIG_arg = 0; ofFloatColor *arg1 = 0 ; - SWIG_check_num_args("ofSetGlobalAmbientColor",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofSetGlobalAmbientColor",1,"ofFloatColor const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("setGlobalAmbientColor",1,SWIGTYPE_p_ofColor_T_float_t); } - ofSetGlobalAmbientColor((ofColor_< float > const &)*arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_getGlobalAmbientColor(lua_State* L) { int SWIG_arg = 0; ofFloatColor *result = 0 ; - SWIG_check_num_args("ofGetGlobalAmbientColor",0,0) result = (ofFloatColor *) &ofGetGlobalAmbientColor(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_Light(lua_State* L) { int SWIG_arg = 0; ofLight *result = 0 ; SWIG_check_num_args("ofLight::ofLight",0,0) - result = (ofLight *)new ofLight(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofLight,1); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Light_setup(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; - SWIG_check_num_args("ofLight::setup",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::setup",1,"ofLight *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ SWIG_fail_ptr("Light_setup",1,SWIGTYPE_p_ofLight); } - (arg1)->setup(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Light_enable(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; - SWIG_check_num_args("ofLight::enable",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::enable",1,"ofLight *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ SWIG_fail_ptr("Light_enable",1,SWIGTYPE_p_ofLight); } - (arg1)->enable(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Light_disable(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; - SWIG_check_num_args("ofLight::disable",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::disable",1,"ofLight *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ - SWIG_fail_ptr("Light_disable",1,SWIGTYPE_p_ofLight); } (arg1)->disable(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Light_getIsEnabled(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; bool result; - SWIG_check_num_args("ofLight::getIsEnabled",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::getIsEnabled",1,"ofLight const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ - SWIG_fail_ptr("Light_getIsEnabled",1,SWIGTYPE_p_ofLight); } result = (bool)((ofLight const *)arg1)->getIsEnabled(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Light_setDirectional(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; - SWIG_check_num_args("ofLight::setDirectional",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::setDirectional",1,"ofLight *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ - SWIG_fail_ptr("Light_setDirectional",1,SWIGTYPE_p_ofLight); } (arg1)->setDirectional(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Light_getIsDirectional(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; bool result; - SWIG_check_num_args("ofLight::getIsDirectional",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::getIsDirectional",1,"ofLight const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ - SWIG_fail_ptr("Light_getIsDirectional",1,SWIGTYPE_p_ofLight); } result = (bool)((ofLight const *)arg1)->getIsDirectional(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Light_setSpotlight__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; float arg2 ; - float arg3 ; SWIG_check_num_args("ofLight::setSpotlight",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::setSpotlight",1,"ofLight *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofLight::setSpotlight",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofLight::setSpotlight",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ - SWIG_fail_ptr("Light_setSpotlight",1,SWIGTYPE_p_ofLight); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->setSpotlight(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Light_setSpotlight__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; float arg2 ; - SWIG_check_num_args("ofLight::setSpotlight",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::setSpotlight",1,"ofLight *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofLight::setSpotlight",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ - SWIG_fail_ptr("Light_setSpotlight",1,SWIGTYPE_p_ofLight); } arg2 = (float)lua_tonumber(L, 2); (arg1)->setSpotlight(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Light_setSpotlight__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; - SWIG_check_num_args("ofLight::setSpotlight",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::setSpotlight",1,"ofLight *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ - SWIG_fail_ptr("Light_setSpotlight",1,SWIGTYPE_p_ofLight); } (arg1)->setSpotlight(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Light_setSpotlight(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofLight, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_Light_setSpotlight__SWIG_2(L);} } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofLight, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Light_setSpotlight__SWIG_1(L);} } } - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofLight, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Light_setSpotlight__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Light_setSpotlight'\n" " Possible C/C++ prototypes are:\n" - " ofLight::setSpotlight(float,float)\n" " ofLight::setSpotlight(float)\n" " ofLight::setSpotlight()\n"); - lua_error(L);return 0; } -static int _wrap_Light_getIsSpotlight(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; bool result; - SWIG_check_num_args("ofLight::getIsSpotlight",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::getIsSpotlight",1,"ofLight const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ - SWIG_fail_ptr("Light_getIsSpotlight",1,SWIGTYPE_p_ofLight); } result = (bool)((ofLight const *)arg1)->getIsSpotlight(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Light_setSpotlightCutOff(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; float arg2 ; - SWIG_check_num_args("ofLight::setSpotlightCutOff",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::setSpotlightCutOff",1,"ofLight *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofLight::setSpotlightCutOff",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ - SWIG_fail_ptr("Light_setSpotlightCutOff",1,SWIGTYPE_p_ofLight); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setSpotlightCutOff(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Light_getSpotlightCutOff(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; float result; - SWIG_check_num_args("ofLight::getSpotlightCutOff",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::getSpotlightCutOff",1,"ofLight const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ - SWIG_fail_ptr("Light_getSpotlightCutOff",1,SWIGTYPE_p_ofLight); } - result = (float)((ofLight const *)arg1)->getSpotlightCutOff(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Light_setSpotConcentration(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; float arg2 ; - SWIG_check_num_args("ofLight::setSpotConcentration",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::setSpotConcentration",1,"ofLight *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofLight::setSpotConcentration",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ - SWIG_fail_ptr("Light_setSpotConcentration",1,SWIGTYPE_p_ofLight); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setSpotConcentration(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Light_getSpotConcentration(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; float result; - SWIG_check_num_args("ofLight::getSpotConcentration",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::getSpotConcentration",1,"ofLight const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ - SWIG_fail_ptr("Light_getSpotConcentration",1,SWIGTYPE_p_ofLight); } - result = (float)((ofLight const *)arg1)->getSpotConcentration(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Light_setPointLight(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; - SWIG_check_num_args("ofLight::setPointLight",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::setPointLight",1,"ofLight *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ - SWIG_fail_ptr("Light_setPointLight",1,SWIGTYPE_p_ofLight); } (arg1)->setPointLight(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Light_getIsPointLight(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; bool result; - SWIG_check_num_args("ofLight::getIsPointLight",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::getIsPointLight",1,"ofLight const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ - SWIG_fail_ptr("Light_getIsPointLight",1,SWIGTYPE_p_ofLight); } result = (bool)((ofLight const *)arg1)->getIsPointLight(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Light_setAttenuation__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; float arg2 ; - float arg3 ; float arg4 ; SWIG_check_num_args("ofLight::setAttenuation",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::setAttenuation",1,"ofLight *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofLight::setAttenuation",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofLight::setAttenuation",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofLight::setAttenuation",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ - SWIG_fail_ptr("Light_setAttenuation",1,SWIGTYPE_p_ofLight); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); (arg1)->setAttenuation(arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Light_setAttenuation__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; float arg2 ; - float arg3 ; SWIG_check_num_args("ofLight::setAttenuation",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::setAttenuation",1,"ofLight *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofLight::setAttenuation",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofLight::setAttenuation",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ - SWIG_fail_ptr("Light_setAttenuation",1,SWIGTYPE_p_ofLight); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->setAttenuation(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Light_setAttenuation__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; float arg2 ; - SWIG_check_num_args("ofLight::setAttenuation",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::setAttenuation",1,"ofLight *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofLight::setAttenuation",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ - SWIG_fail_ptr("Light_setAttenuation",1,SWIGTYPE_p_ofLight); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setAttenuation(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Light_setAttenuation__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; - SWIG_check_num_args("ofLight::setAttenuation",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::setAttenuation",1,"ofLight *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ - SWIG_fail_ptr("Light_setAttenuation",1,SWIGTYPE_p_ofLight); } (arg1)->setAttenuation(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Light_setAttenuation(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 1) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofLight, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_Light_setAttenuation__SWIG_3(L);} } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofLight, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Light_setAttenuation__SWIG_2(L);} } } - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofLight, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Light_setAttenuation__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofLight, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Light_setAttenuation__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Light_setAttenuation'\n" - " Possible C/C++ prototypes are:\n" " ofLight::setAttenuation(float,float,float)\n" - " ofLight::setAttenuation(float,float)\n" " ofLight::setAttenuation(float)\n" " ofLight::setAttenuation()\n"); - lua_error(L);return 0; } -static int _wrap_Light_getAttenuationConstant(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; float result; - SWIG_check_num_args("ofLight::getAttenuationConstant",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::getAttenuationConstant",1,"ofLight const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ - SWIG_fail_ptr("Light_getAttenuationConstant",1,SWIGTYPE_p_ofLight); } - result = (float)((ofLight const *)arg1)->getAttenuationConstant(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Light_getAttenuationLinear(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; float result; - SWIG_check_num_args("ofLight::getAttenuationLinear",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::getAttenuationLinear",1,"ofLight const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ - SWIG_fail_ptr("Light_getAttenuationLinear",1,SWIGTYPE_p_ofLight); } - result = (float)((ofLight const *)arg1)->getAttenuationLinear(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Light_getAttenuationQuadratic(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; float result; - SWIG_check_num_args("ofLight::getAttenuationQuadratic",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::getAttenuationQuadratic",1,"ofLight const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ - SWIG_fail_ptr("Light_getAttenuationQuadratic",1,SWIGTYPE_p_ofLight); } - result = (float)((ofLight const *)arg1)->getAttenuationQuadratic(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Light_setAreaLight(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofLight::setAreaLight",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::setAreaLight",1,"ofLight *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofLight::setAreaLight",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofLight::setAreaLight",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ - SWIG_fail_ptr("Light_setAreaLight",1,SWIGTYPE_p_ofLight); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->setAreaLight(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Light_getIsAreaLight(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; bool result; - SWIG_check_num_args("ofLight::getIsAreaLight",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::getIsAreaLight",1,"ofLight const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ - SWIG_fail_ptr("Light_getIsAreaLight",1,SWIGTYPE_p_ofLight); } result = (bool)((ofLight const *)arg1)->getIsAreaLight(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Light_getType(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; int result; - SWIG_check_num_args("ofLight::getType",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::getType",1,"ofLight const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ - SWIG_fail_ptr("Light_getType",1,SWIGTYPE_p_ofLight); } result = (int)((ofLight const *)arg1)->getType(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Light_setAmbientColor(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; - ofFloatColor *arg2 = 0 ; SWIG_check_num_args("ofLight::setAmbientColor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::setAmbientColor",1,"ofLight *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofLight::setAmbientColor",2,"ofFloatColor const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ - SWIG_fail_ptr("Light_setAmbientColor",1,SWIGTYPE_p_ofLight); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("Light_setAmbientColor",2,SWIGTYPE_p_ofColor_T_float_t); } - (arg1)->setAmbientColor((ofFloatColor const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Light_setDiffuseColor(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; - ofFloatColor *arg2 = 0 ; SWIG_check_num_args("ofLight::setDiffuseColor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::setDiffuseColor",1,"ofLight *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofLight::setDiffuseColor",2,"ofFloatColor const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ - SWIG_fail_ptr("Light_setDiffuseColor",1,SWIGTYPE_p_ofLight); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("Light_setDiffuseColor",2,SWIGTYPE_p_ofColor_T_float_t); } - (arg1)->setDiffuseColor((ofFloatColor const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Light_setSpecularColor(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; - ofFloatColor *arg2 = 0 ; SWIG_check_num_args("ofLight::setSpecularColor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::setSpecularColor",1,"ofLight *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofLight::setSpecularColor",2,"ofFloatColor const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ - SWIG_fail_ptr("Light_setSpecularColor",1,SWIGTYPE_p_ofLight); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("Light_setSpecularColor",2,SWIGTYPE_p_ofColor_T_float_t); } - (arg1)->setSpecularColor((ofFloatColor const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Light_getAmbientColor(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; ofFloatColor result; - SWIG_check_num_args("ofLight::getAmbientColor",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::getAmbientColor",1,"ofLight const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ - SWIG_fail_ptr("Light_getAmbientColor",1,SWIGTYPE_p_ofLight); } result = ((ofLight const *)arg1)->getAmbientColor(); { - ofFloatColor * resultptr = new ofFloatColor((const ofFloatColor &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Light_getDiffuseColor(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; ofFloatColor result; - SWIG_check_num_args("ofLight::getDiffuseColor",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::getDiffuseColor",1,"ofLight const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ - SWIG_fail_ptr("Light_getDiffuseColor",1,SWIGTYPE_p_ofLight); } result = ((ofLight const *)arg1)->getDiffuseColor(); { - ofFloatColor * resultptr = new ofFloatColor((const ofFloatColor &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Light_getSpecularColor(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; ofFloatColor result; - SWIG_check_num_args("ofLight::getSpecularColor",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::getSpecularColor",1,"ofLight const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ - SWIG_fail_ptr("Light_getSpecularColor",1,SWIGTYPE_p_ofLight); } result = ((ofLight const *)arg1)->getSpecularColor(); { - ofFloatColor * resultptr = new ofFloatColor((const ofFloatColor &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Light_getLightID(lua_State* L) { int SWIG_arg = 0; ofLight *arg1 = (ofLight *) 0 ; int result; - SWIG_check_num_args("ofLight::getLightID",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLight::getLightID",1,"ofLight const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofLight,0))){ - SWIG_fail_ptr("Light_getLightID",1,SWIGTYPE_p_ofLight); } result = (int)((ofLight const *)arg1)->getLightID(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_Light(void *obj) { -ofLight *arg1 = (ofLight *) obj; -delete arg1; -} -static int _proxy__wrap_new_Light(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_Light); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_Light_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_Light_methods[]= { - { "setup", _wrap_Light_setup}, - { "enable", _wrap_Light_enable}, - { "disable", _wrap_Light_disable}, - { "getIsEnabled", _wrap_Light_getIsEnabled}, - { "setDirectional", _wrap_Light_setDirectional}, - { "getIsDirectional", _wrap_Light_getIsDirectional}, - { "setSpotlight", _wrap_Light_setSpotlight}, - { "getIsSpotlight", _wrap_Light_getIsSpotlight}, - { "setSpotlightCutOff", _wrap_Light_setSpotlightCutOff}, - { "getSpotlightCutOff", _wrap_Light_getSpotlightCutOff}, - { "setSpotConcentration", _wrap_Light_setSpotConcentration}, - { "getSpotConcentration", _wrap_Light_getSpotConcentration}, - { "setPointLight", _wrap_Light_setPointLight}, - { "getIsPointLight", _wrap_Light_getIsPointLight}, - { "setAttenuation", _wrap_Light_setAttenuation}, - { "getAttenuationConstant", _wrap_Light_getAttenuationConstant}, - { "getAttenuationLinear", _wrap_Light_getAttenuationLinear}, - { "getAttenuationQuadratic", _wrap_Light_getAttenuationQuadratic}, - { "setAreaLight", _wrap_Light_setAreaLight}, - { "getIsAreaLight", _wrap_Light_getIsAreaLight}, - { "getType", _wrap_Light_getType}, - { "setAmbientColor", _wrap_Light_setAmbientColor}, - { "setDiffuseColor", _wrap_Light_setDiffuseColor}, - { "setSpecularColor", _wrap_Light_setSpecularColor}, - { "getAmbientColor", _wrap_Light_getAmbientColor}, - { "getDiffuseColor", _wrap_Light_getDiffuseColor}, - { "getSpecularColor", _wrap_Light_getSpecularColor}, - { "getLightID", _wrap_Light_getLightID}, - {0,0} -}; -static swig_lua_method swig_Light_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_Light_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_Light_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_Light_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_Light_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_Light_Sf_SwigStatic = { - "Light", - swig_Light_Sf_SwigStatic_methods, - swig_Light_Sf_SwigStatic_attributes, - swig_Light_Sf_SwigStatic_constants, - swig_Light_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_Light_bases[] = {0,0}; -static const char *swig_Light_base_names[] = {"ofNode *",0}; -static swig_lua_class _wrap_class_Light = { "Light", "Light", &SWIGTYPE_p_ofLight,_proxy__wrap_new_Light, swig_delete_Light, swig_Light_methods, swig_Light_attributes, &swig_Light_Sf_SwigStatic, swig_Light_meta, swig_Light_bases, swig_Light_base_names }; - -static int _wrap_lightsData(lua_State* L) { int SWIG_arg = 0; std::vector< weak_ptr< ofLight::Data > > *result = 0 ; - SWIG_check_num_args("ofLightsData",0,0) result = (std::vector< weak_ptr< ofLight::Data > > *) &ofLightsData(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_weak_ptrT_ofLight__Data_t_t,0); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_new_Material(lua_State* L) { int SWIG_arg = 0; ofMaterial *result = 0 ; - SWIG_check_num_args("ofMaterial::ofMaterial",0,0) result = (ofMaterial *)new ofMaterial(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMaterial,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Material_setColors(lua_State* L) { int SWIG_arg = 0; ofMaterial *arg1 = (ofMaterial *) 0 ; ofFloatColor arg2 ; - ofFloatColor arg3 ; ofFloatColor arg4 ; ofFloatColor arg5 ; ofFloatColor *argp2 ; ofFloatColor *argp3 ; ofFloatColor *argp4 ; - ofFloatColor *argp5 ; SWIG_check_num_args("ofMaterial::setColors",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMaterial::setColors",1,"ofMaterial *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMaterial::setColors",2,"ofFloatColor"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofMaterial::setColors",3,"ofFloatColor"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofMaterial::setColors",4,"ofFloatColor"); - if(!lua_isuserdata(L,5)) SWIG_fail_arg("ofMaterial::setColors",5,"ofFloatColor"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMaterial,0))){ - SWIG_fail_ptr("Material_setColors",1,SWIGTYPE_p_ofMaterial); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("Material_setColors",2,SWIGTYPE_p_ofColor_T_float_t); } arg2 = *argp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&argp3,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("Material_setColors",3,SWIGTYPE_p_ofColor_T_float_t); } arg3 = *argp3; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&argp4,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("Material_setColors",4,SWIGTYPE_p_ofColor_T_float_t); } arg4 = *argp4; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&argp5,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("Material_setColors",5,SWIGTYPE_p_ofColor_T_float_t); } arg5 = *argp5; - (arg1)->setColors(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Material_setDiffuseColor(lua_State* L) { int SWIG_arg = 0; ofMaterial *arg1 = (ofMaterial *) 0 ; - ofFloatColor arg2 ; ofFloatColor *argp2 ; SWIG_check_num_args("ofMaterial::setDiffuseColor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMaterial::setDiffuseColor",1,"ofMaterial *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMaterial::setDiffuseColor",2,"ofFloatColor"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMaterial,0))){ - SWIG_fail_ptr("Material_setDiffuseColor",1,SWIGTYPE_p_ofMaterial); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("Material_setDiffuseColor",2,SWIGTYPE_p_ofColor_T_float_t); } arg2 = *argp2; (arg1)->setDiffuseColor(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Material_setAmbientColor(lua_State* L) { int SWIG_arg = 0; ofMaterial *arg1 = (ofMaterial *) 0 ; - ofFloatColor arg2 ; ofFloatColor *argp2 ; SWIG_check_num_args("ofMaterial::setAmbientColor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMaterial::setAmbientColor",1,"ofMaterial *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMaterial::setAmbientColor",2,"ofFloatColor"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMaterial,0))){ - SWIG_fail_ptr("Material_setAmbientColor",1,SWIGTYPE_p_ofMaterial); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("Material_setAmbientColor",2,SWIGTYPE_p_ofColor_T_float_t); } arg2 = *argp2; (arg1)->setAmbientColor(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Material_setSpecularColor(lua_State* L) { int SWIG_arg = 0; ofMaterial *arg1 = (ofMaterial *) 0 ; - ofFloatColor arg2 ; ofFloatColor *argp2 ; SWIG_check_num_args("ofMaterial::setSpecularColor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMaterial::setSpecularColor",1,"ofMaterial *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMaterial::setSpecularColor",2,"ofFloatColor"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMaterial,0))){ - SWIG_fail_ptr("Material_setSpecularColor",1,SWIGTYPE_p_ofMaterial); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("Material_setSpecularColor",2,SWIGTYPE_p_ofColor_T_float_t); } arg2 = *argp2; (arg1)->setSpecularColor(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Material_setEmissiveColor(lua_State* L) { int SWIG_arg = 0; ofMaterial *arg1 = (ofMaterial *) 0 ; - ofFloatColor arg2 ; ofFloatColor *argp2 ; SWIG_check_num_args("ofMaterial::setEmissiveColor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMaterial::setEmissiveColor",1,"ofMaterial *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMaterial::setEmissiveColor",2,"ofFloatColor"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMaterial,0))){ - SWIG_fail_ptr("Material_setEmissiveColor",1,SWIGTYPE_p_ofMaterial); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("Material_setEmissiveColor",2,SWIGTYPE_p_ofColor_T_float_t); } arg2 = *argp2; (arg1)->setEmissiveColor(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Material_setShininess(lua_State* L) { int SWIG_arg = 0; ofMaterial *arg1 = (ofMaterial *) 0 ; float arg2 ; - SWIG_check_num_args("ofMaterial::setShininess",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMaterial::setShininess",1,"ofMaterial *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMaterial::setShininess",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMaterial,0))){ - SWIG_fail_ptr("Material_setShininess",1,SWIGTYPE_p_ofMaterial); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setShininess(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Material_getDiffuseColor(lua_State* L) { int SWIG_arg = 0; ofMaterial *arg1 = (ofMaterial *) 0 ; - ofFloatColor result; SWIG_check_num_args("ofMaterial::getDiffuseColor",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMaterial::getDiffuseColor",1,"ofMaterial const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMaterial,0))){ - SWIG_fail_ptr("Material_getDiffuseColor",1,SWIGTYPE_p_ofMaterial); } - result = ((ofMaterial const *)arg1)->getDiffuseColor(); { - ofFloatColor * resultptr = new ofFloatColor((const ofFloatColor &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Material_getAmbientColor(lua_State* L) { int SWIG_arg = 0; ofMaterial *arg1 = (ofMaterial *) 0 ; - ofFloatColor result; SWIG_check_num_args("ofMaterial::getAmbientColor",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMaterial::getAmbientColor",1,"ofMaterial const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMaterial,0))){ - SWIG_fail_ptr("Material_getAmbientColor",1,SWIGTYPE_p_ofMaterial); } - result = ((ofMaterial const *)arg1)->getAmbientColor(); { - ofFloatColor * resultptr = new ofFloatColor((const ofFloatColor &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Material_getSpecularColor(lua_State* L) { int SWIG_arg = 0; ofMaterial *arg1 = (ofMaterial *) 0 ; - ofFloatColor result; SWIG_check_num_args("ofMaterial::getSpecularColor",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMaterial::getSpecularColor",1,"ofMaterial const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMaterial,0))){ - SWIG_fail_ptr("Material_getSpecularColor",1,SWIGTYPE_p_ofMaterial); } - result = ((ofMaterial const *)arg1)->getSpecularColor(); { - ofFloatColor * resultptr = new ofFloatColor((const ofFloatColor &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Material_getEmissiveColor(lua_State* L) { int SWIG_arg = 0; ofMaterial *arg1 = (ofMaterial *) 0 ; - ofFloatColor result; SWIG_check_num_args("ofMaterial::getEmissiveColor",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMaterial::getEmissiveColor",1,"ofMaterial const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMaterial,0))){ - SWIG_fail_ptr("Material_getEmissiveColor",1,SWIGTYPE_p_ofMaterial); } - result = ((ofMaterial const *)arg1)->getEmissiveColor(); { - ofFloatColor * resultptr = new ofFloatColor((const ofFloatColor &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Material_getShininess(lua_State* L) { int SWIG_arg = 0; ofMaterial *arg1 = (ofMaterial *) 0 ; float result; - SWIG_check_num_args("ofMaterial::getShininess",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMaterial::getShininess",1,"ofMaterial const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMaterial,0))){ - SWIG_fail_ptr("Material_getShininess",1,SWIGTYPE_p_ofMaterial); } - result = (float)((ofMaterial const *)arg1)->getShininess(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Material_beginMaterial(lua_State* L) { int SWIG_arg = 0; ofMaterial *arg1 = (ofMaterial *) 0 ; - SWIG_check_num_args("ofMaterial::begin",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMaterial::begin",1,"ofMaterial const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMaterial,0))){ - SWIG_fail_ptr("Material_beginMaterial",1,SWIGTYPE_p_ofMaterial); } ((ofMaterial const *)arg1)->begin(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Material_endMaterial(lua_State* L) { int SWIG_arg = 0; ofMaterial *arg1 = (ofMaterial *) 0 ; - SWIG_check_num_args("ofMaterial::end",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMaterial::end",1,"ofMaterial const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMaterial,0))){ - SWIG_fail_ptr("Material_endMaterial",1,SWIGTYPE_p_ofMaterial); } ((ofMaterial const *)arg1)->end(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_Material(void *obj) { -ofMaterial *arg1 = (ofMaterial *) obj; -delete arg1; -} -static int _proxy__wrap_new_Material(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_Material); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_Material_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_Material_methods[]= { - { "setColors", _wrap_Material_setColors}, - { "setDiffuseColor", _wrap_Material_setDiffuseColor}, - { "setAmbientColor", _wrap_Material_setAmbientColor}, - { "setSpecularColor", _wrap_Material_setSpecularColor}, - { "setEmissiveColor", _wrap_Material_setEmissiveColor}, - { "setShininess", _wrap_Material_setShininess}, - { "getDiffuseColor", _wrap_Material_getDiffuseColor}, - { "getAmbientColor", _wrap_Material_getAmbientColor}, - { "getSpecularColor", _wrap_Material_getSpecularColor}, - { "getEmissiveColor", _wrap_Material_getEmissiveColor}, - { "getShininess", _wrap_Material_getShininess}, - { "beginMaterial", _wrap_Material_beginMaterial}, - { "endMaterial", _wrap_Material_endMaterial}, - {0,0} -}; -static swig_lua_method swig_Material_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_Material_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_Material_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_Material_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_Material_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_Material_Sf_SwigStatic = { - "Material", - swig_Material_Sf_SwigStatic_methods, - swig_Material_Sf_SwigStatic_attributes, - swig_Material_Sf_SwigStatic_constants, - swig_Material_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_Material_bases[] = {0}; -static const char *swig_Material_base_names[] = {0}; -static swig_lua_class _wrap_class_Material = { "Material", "Material", &SWIGTYPE_p_ofMaterial,_proxy__wrap_new_Material, swig_delete_Material, swig_Material_methods, swig_Material_attributes, &swig_Material_Sf_SwigStatic, swig_Material_meta, swig_Material_bases, swig_Material_base_names }; - -static int _wrap_new_Shader__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofShader *result = 0 ; - SWIG_check_num_args("ofShader::ofShader",0,0) result = (ofShader *)new ofShader(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofShader,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Shader__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = 0 ; ofShader *result = 0 ; - SWIG_check_num_args("ofShader::ofShader",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofShader::ofShader",1,"ofShader &&"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ SWIG_fail_ptr("new_Shader",1,SWIGTYPE_p_ofShader); } - result = (ofShader *)new ofShader((ofShader &&)*arg1); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofShader,1); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_new_Shader(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_Shader__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_new_Shader__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_Shader'\n" " Possible C/C++ prototypes are:\n" - " ofShader::ofShader()\n" " ofShader::ofShader(ofShader &&)\n"); lua_error(L);return 0; } -static int _wrap_Shader_load__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; std::string arg2 ; - bool result; SWIG_check_num_args("ofShader::load",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::load",1,"ofShader *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::load",2,"std::string"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_load",1,SWIGTYPE_p_ofShader); } (&arg2)->assign(lua_tostring(L,2),lua_rawlen(L,2)); - result = (bool)(arg1)->load(arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Shader_load__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; std::string arg2 ; - std::string arg3 ; std::string arg4 ; bool result; SWIG_check_num_args("ofShader::load",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::load",1,"ofShader *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::load",2,"std::string"); - if(!lua_isstring(L,3)) SWIG_fail_arg("ofShader::load",3,"std::string"); - if(!lua_isstring(L,4)) SWIG_fail_arg("ofShader::load",4,"std::string"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_load",1,SWIGTYPE_p_ofShader); } (&arg2)->assign(lua_tostring(L,2),lua_rawlen(L,2)); - (&arg3)->assign(lua_tostring(L,3),lua_rawlen(L,3)); (&arg4)->assign(lua_tostring(L,4),lua_rawlen(L,4)); - result = (bool)(arg1)->load(arg2,arg3,arg4); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_load__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; std::string arg2 ; - std::string arg3 ; bool result; SWIG_check_num_args("ofShader::load",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::load",1,"ofShader *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::load",2,"std::string"); - if(!lua_isstring(L,3)) SWIG_fail_arg("ofShader::load",3,"std::string"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_load",1,SWIGTYPE_p_ofShader); } (&arg2)->assign(lua_tostring(L,2),lua_rawlen(L,2)); - (&arg3)->assign(lua_tostring(L,3),lua_rawlen(L,3)); result = (bool)(arg1)->load(arg2,arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_load(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { - return _wrap_Shader_load__SWIG_0(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isstring(L,argv[2]); } if (_v) { - return _wrap_Shader_load__SWIG_2(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isstring(L,argv[2]); } if (_v) { - { _v = lua_isstring(L,argv[3]); } if (_v) { return _wrap_Shader_load__SWIG_1(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Shader_load'\n" " Possible C/C++ prototypes are:\n" - " ofShader::load(std::string)\n" " ofShader::load(std::string,std::string,std::string)\n" - " ofShader::load(std::string,std::string)\n"); lua_error(L);return 0; } -static int _wrap_Shader_setGeometryInputType(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; GLenum arg2 ; - SWIG_check_num_args("ofShader::setGeometryInputType",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setGeometryInputType",1,"ofShader *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofShader::setGeometryInputType",2,"GLenum"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setGeometryInputType",1,SWIGTYPE_p_ofShader); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (GLenum)lua_tonumber(L, 2); - (arg1)->setGeometryInputType(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setGeometryOutputType(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; GLenum arg2 ; - SWIG_check_num_args("ofShader::setGeometryOutputType",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setGeometryOutputType",1,"ofShader *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofShader::setGeometryOutputType",2,"GLenum"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setGeometryOutputType",1,SWIGTYPE_p_ofShader); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (GLenum)lua_tonumber(L, 2); - (arg1)->setGeometryOutputType(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setGeometryOutputCount(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; int arg2 ; - SWIG_check_num_args("ofShader::setGeometryOutputCount",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setGeometryOutputCount",1,"ofShader *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofShader::setGeometryOutputCount",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setGeometryOutputCount",1,SWIGTYPE_p_ofShader); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->setGeometryOutputCount(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_getGeometryMaxOutputCount(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - int result; SWIG_check_num_args("ofShader::getGeometryMaxOutputCount",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::getGeometryMaxOutputCount",1,"ofShader const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_getGeometryMaxOutputCount",1,SWIGTYPE_p_ofShader); } - result = (int)((ofShader const *)arg1)->getGeometryMaxOutputCount(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_unload(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - SWIG_check_num_args("ofShader::unload",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::unload",1,"ofShader *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_unload",1,SWIGTYPE_p_ofShader); } (arg1)->unload(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Shader_isLoaded(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; bool result; - SWIG_check_num_args("ofShader::isLoaded",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::isLoaded",1,"ofShader const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_isLoaded",1,SWIGTYPE_p_ofShader); } result = (bool)((ofShader const *)arg1)->isLoaded(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_beginShader(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - SWIG_check_num_args("ofShader::begin",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::begin",1,"ofShader const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_beginShader",1,SWIGTYPE_p_ofShader); } ((ofShader const *)arg1)->begin(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_endShader(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - SWIG_check_num_args("ofShader::end",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::end",1,"ofShader const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_endShader",1,SWIGTYPE_p_ofShader); } ((ofShader const *)arg1)->end(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniformTexture__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; ofBaseHasTexture *arg3 = 0 ; int arg4 ; std::string temp2 ; - SWIG_check_num_args("ofShader::setUniformTexture",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniformTexture",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniformTexture",2,"std::string const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofShader::setUniformTexture",3,"ofBaseHasTexture const &"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofShader::setUniformTexture",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniformTexture",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofBaseHasTexture,0))){ - SWIG_fail_ptr("Shader_setUniformTexture",3,SWIGTYPE_p_ofBaseHasTexture); } arg4 = (int)lua_tonumber(L, 4); - ((ofShader const *)arg1)->setUniformTexture((std::string const &)*arg2,(ofBaseHasTexture const &)*arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniformTexture__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; ofTexture *arg3 = 0 ; int arg4 ; std::string temp2 ; - SWIG_check_num_args("ofShader::setUniformTexture",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniformTexture",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniformTexture",2,"std::string const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofShader::setUniformTexture",3,"ofTexture const &"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofShader::setUniformTexture",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniformTexture",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofTexture,0))){ - SWIG_fail_ptr("Shader_setUniformTexture",3,SWIGTYPE_p_ofTexture); } arg4 = (int)lua_tonumber(L, 4); - ((ofShader const *)arg1)->setUniformTexture((std::string const &)*arg2,(ofTexture const &)*arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniformTexture__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; int arg3 ; GLint arg4 ; int arg5 ; std::string temp2 ; - SWIG_check_num_args("ofShader::setUniformTexture",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniformTexture",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniformTexture",2,"std::string const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofShader::setUniformTexture",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofShader::setUniformTexture",4,"GLint"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofShader::setUniformTexture",5,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniformTexture",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; arg3 = (int)lua_tonumber(L, 3); - arg4 = (GLint)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); - ((ofShader const *)arg1)->setUniformTexture((std::string const &)*arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniformTexture(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); - if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofBaseHasTexture, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { - return _wrap_Shader_setUniformTexture__SWIG_0(L);} } } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofTexture, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { - return _wrap_Shader_setUniformTexture__SWIG_1(L);} } } } } if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Shader_setUniformTexture__SWIG_2(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Shader_setUniformTexture'\n" - " Possible C/C++ prototypes are:\n" - " ofShader::setUniformTexture(std::string const &,ofBaseHasTexture const &,int) const\n" - " ofShader::setUniformTexture(std::string const &,ofTexture const &,int) const\n" - " ofShader::setUniformTexture(std::string const &,int,GLint,int) const\n"); lua_error(L);return 0; } -static int _wrap_Shader_setUniform1i(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; std::string *arg2 = 0 ; - int arg3 ; std::string temp2 ; SWIG_check_num_args("ofShader::setUniform1i",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniform1i",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniform1i",2,"std::string const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofShader::setUniform1i",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniform1i",1,SWIGTYPE_p_ofShader); } temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - arg3 = (int)lua_tonumber(L, 3); ((ofShader const *)arg1)->setUniform1i((std::string const &)*arg2,arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniform2i(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; std::string *arg2 = 0 ; - int arg3 ; int arg4 ; std::string temp2 ; SWIG_check_num_args("ofShader::setUniform2i",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniform2i",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniform2i",2,"std::string const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofShader::setUniform2i",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofShader::setUniform2i",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniform2i",1,SWIGTYPE_p_ofShader); } temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - ((ofShader const *)arg1)->setUniform2i((std::string const &)*arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniform3i(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; std::string *arg2 = 0 ; - int arg3 ; int arg4 ; int arg5 ; std::string temp2 ; SWIG_check_num_args("ofShader::setUniform3i",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniform3i",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniform3i",2,"std::string const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofShader::setUniform3i",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofShader::setUniform3i",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofShader::setUniform3i",5,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniform3i",1,SWIGTYPE_p_ofShader); } temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); - ((ofShader const *)arg1)->setUniform3i((std::string const &)*arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniform4i(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; std::string *arg2 = 0 ; - int arg3 ; int arg4 ; int arg5 ; int arg6 ; std::string temp2 ; SWIG_check_num_args("ofShader::setUniform4i",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniform4i",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniform4i",2,"std::string const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofShader::setUniform4i",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofShader::setUniform4i",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofShader::setUniform4i",5,"int"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofShader::setUniform4i",6,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniform4i",1,SWIGTYPE_p_ofShader); } temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); - arg6 = (int)lua_tonumber(L, 6); ((ofShader const *)arg1)->setUniform4i((std::string const &)*arg2,arg3,arg4,arg5,arg6); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniform1f(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; std::string *arg2 = 0 ; - float arg3 ; std::string temp2 ; SWIG_check_num_args("ofShader::setUniform1f",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniform1f",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniform1f",2,"std::string const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofShader::setUniform1f",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniform1f",1,SWIGTYPE_p_ofShader); } temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - arg3 = (float)lua_tonumber(L, 3); ((ofShader const *)arg1)->setUniform1f((std::string const &)*arg2,arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniform2f__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; float arg3 ; float arg4 ; std::string temp2 ; SWIG_check_num_args("ofShader::setUniform2f",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniform2f",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniform2f",2,"std::string const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofShader::setUniform2f",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofShader::setUniform2f",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniform2f",1,SWIGTYPE_p_ofShader); } temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - ((ofShader const *)arg1)->setUniform2f((std::string const &)*arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniform3f__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; float arg3 ; float arg4 ; float arg5 ; std::string temp2 ; - SWIG_check_num_args("ofShader::setUniform3f",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniform3f",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniform3f",2,"std::string const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofShader::setUniform3f",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofShader::setUniform3f",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofShader::setUniform3f",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniform3f",1,SWIGTYPE_p_ofShader); } temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - ((ofShader const *)arg1)->setUniform3f((std::string const &)*arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniform4f__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; float arg3 ; float arg4 ; float arg5 ; float arg6 ; std::string temp2 ; - SWIG_check_num_args("ofShader::setUniform4f",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniform4f",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniform4f",2,"std::string const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofShader::setUniform4f",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofShader::setUniform4f",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofShader::setUniform4f",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofShader::setUniform4f",6,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniform4f",1,SWIGTYPE_p_ofShader); } temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); ((ofShader const *)arg1)->setUniform4f((std::string const &)*arg2,arg3,arg4,arg5,arg6); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniform2f__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; ofVec2f *arg3 = 0 ; std::string temp2 ; SWIG_check_num_args("ofShader::setUniform2f",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniform2f",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniform2f",2,"std::string const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofShader::setUniform2f",3,"ofVec2f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniform2f",1,SWIGTYPE_p_ofShader); } temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Shader_setUniform2f",3,SWIGTYPE_p_ofVec2f); } - ((ofShader const *)arg1)->setUniform2f((std::string const &)*arg2,(ofVec2f const &)*arg3); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniform2f(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Shader_setUniform2f__SWIG_1(L);} } } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Shader_setUniform2f__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Shader_setUniform2f'\n" - " Possible C/C++ prototypes are:\n" " ofShader::setUniform2f(std::string const &,float,float) const\n" - " ofShader::setUniform2f(std::string const &,ofVec2f const &) const\n"); lua_error(L);return 0; } -static int _wrap_Shader_setUniform3f__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; ofVec3f *arg3 = 0 ; std::string temp2 ; SWIG_check_num_args("ofShader::setUniform3f",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniform3f",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniform3f",2,"std::string const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofShader::setUniform3f",3,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniform3f",1,SWIGTYPE_p_ofShader); } temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Shader_setUniform3f",3,SWIGTYPE_p_ofVec3f); } - ((ofShader const *)arg1)->setUniform3f((std::string const &)*arg2,(ofVec3f const &)*arg3); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniform3f(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Shader_setUniform3f__SWIG_1(L);} } } } if (argc == 5) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Shader_setUniform3f__SWIG_0(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Shader_setUniform3f'\n" - " Possible C/C++ prototypes are:\n" " ofShader::setUniform3f(std::string const &,float,float,float) const\n" - " ofShader::setUniform3f(std::string const &,ofVec3f const &) const\n"); lua_error(L);return 0; } -static int _wrap_Shader_setUniform4f__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; ofVec4f *arg3 = 0 ; std::string temp2 ; SWIG_check_num_args("ofShader::setUniform4f",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniform4f",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniform4f",2,"std::string const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofShader::setUniform4f",3,"ofVec4f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniform4f",1,SWIGTYPE_p_ofShader); } temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec4f,0))){ - SWIG_fail_ptr("Shader_setUniform4f",3,SWIGTYPE_p_ofVec4f); } - ((ofShader const *)arg1)->setUniform4f((std::string const &)*arg2,(ofVec4f const &)*arg3); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniform4f__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; ofFloatColor *arg3 = 0 ; std::string temp2 ; SWIG_check_num_args("ofShader::setUniform4f",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniform4f",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniform4f",2,"std::string const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofShader::setUniform4f",3,"ofFloatColor const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniform4f",1,SWIGTYPE_p_ofShader); } temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("Shader_setUniform4f",3,SWIGTYPE_p_ofColor_T_float_t); } - ((ofShader const *)arg1)->setUniform4f((std::string const &)*arg2,(ofFloatColor const &)*arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniform4f(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec4f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Shader_setUniform4f__SWIG_1(L);} } } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Shader_setUniform4f__SWIG_2(L);} } } } if (argc == 6) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { return _wrap_Shader_setUniform4f__SWIG_0(L);} } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Shader_setUniform4f'\n" - " Possible C/C++ prototypes are:\n" " ofShader::setUniform4f(std::string const &,float,float,float,float) const\n" - " ofShader::setUniform4f(std::string const &,ofVec4f const &) const\n" - " ofShader::setUniform4f(std::string const &,ofFloatColor const &) const\n"); lua_error(L);return 0; } -static int _wrap_Shader_setUniform1iv__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; int *arg3 = (int *) 0 ; int arg4 ; std::string temp2 ; - SWIG_check_num_args("ofShader::setUniform1iv",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniform1iv",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniform1iv",2,"std::string const &"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofShader::setUniform1iv",3,"int const *"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofShader::setUniform1iv",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniform1iv",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_int,0))){ SWIG_fail_ptr("Shader_setUniform1iv",3,SWIGTYPE_p_int); } - arg4 = (int)lua_tonumber(L, 4); ((ofShader const *)arg1)->setUniform1iv((std::string const &)*arg2,(int const *)arg3,arg4); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniform1iv__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; int *arg3 = (int *) 0 ; std::string temp2 ; SWIG_check_num_args("ofShader::setUniform1iv",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniform1iv",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniform1iv",2,"std::string const &"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofShader::setUniform1iv",3,"int const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniform1iv",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_int,0))){ SWIG_fail_ptr("Shader_setUniform1iv",3,SWIGTYPE_p_int); } - ((ofShader const *)arg1)->setUniform1iv((std::string const &)*arg2,(int const *)arg3); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniform1iv(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_int, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_Shader_setUniform1iv__SWIG_1(L);} } } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_int, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Shader_setUniform1iv__SWIG_0(L);} - } } } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Shader_setUniform1iv'\n" - " Possible C/C++ prototypes are:\n" " ofShader::setUniform1iv(std::string const &,int const *,int) const\n" - " ofShader::setUniform1iv(std::string const &,int const *) const\n"); lua_error(L);return 0; } -static int _wrap_Shader_setUniform2iv__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; int *arg3 = (int *) 0 ; int arg4 ; std::string temp2 ; - SWIG_check_num_args("ofShader::setUniform2iv",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniform2iv",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniform2iv",2,"std::string const &"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofShader::setUniform2iv",3,"int const *"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofShader::setUniform2iv",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniform2iv",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_int,0))){ SWIG_fail_ptr("Shader_setUniform2iv",3,SWIGTYPE_p_int); } - arg4 = (int)lua_tonumber(L, 4); ((ofShader const *)arg1)->setUniform2iv((std::string const &)*arg2,(int const *)arg3,arg4); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniform2iv__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; int *arg3 = (int *) 0 ; std::string temp2 ; SWIG_check_num_args("ofShader::setUniform2iv",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniform2iv",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniform2iv",2,"std::string const &"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofShader::setUniform2iv",3,"int const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniform2iv",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_int,0))){ SWIG_fail_ptr("Shader_setUniform2iv",3,SWIGTYPE_p_int); } - ((ofShader const *)arg1)->setUniform2iv((std::string const &)*arg2,(int const *)arg3); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniform2iv(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_int, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_Shader_setUniform2iv__SWIG_1(L);} } } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_int, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Shader_setUniform2iv__SWIG_0(L);} - } } } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Shader_setUniform2iv'\n" - " Possible C/C++ prototypes are:\n" " ofShader::setUniform2iv(std::string const &,int const *,int) const\n" - " ofShader::setUniform2iv(std::string const &,int const *) const\n"); lua_error(L);return 0; } -static int _wrap_Shader_setUniform3iv__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; int *arg3 = (int *) 0 ; int arg4 ; std::string temp2 ; - SWIG_check_num_args("ofShader::setUniform3iv",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniform3iv",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniform3iv",2,"std::string const &"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofShader::setUniform3iv",3,"int const *"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofShader::setUniform3iv",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniform3iv",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_int,0))){ SWIG_fail_ptr("Shader_setUniform3iv",3,SWIGTYPE_p_int); } - arg4 = (int)lua_tonumber(L, 4); ((ofShader const *)arg1)->setUniform3iv((std::string const &)*arg2,(int const *)arg3,arg4); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniform3iv__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; int *arg3 = (int *) 0 ; std::string temp2 ; SWIG_check_num_args("ofShader::setUniform3iv",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniform3iv",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniform3iv",2,"std::string const &"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofShader::setUniform3iv",3,"int const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniform3iv",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_int,0))){ SWIG_fail_ptr("Shader_setUniform3iv",3,SWIGTYPE_p_int); } - ((ofShader const *)arg1)->setUniform3iv((std::string const &)*arg2,(int const *)arg3); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniform3iv(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_int, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_Shader_setUniform3iv__SWIG_1(L);} } } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_int, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Shader_setUniform3iv__SWIG_0(L);} - } } } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Shader_setUniform3iv'\n" - " Possible C/C++ prototypes are:\n" " ofShader::setUniform3iv(std::string const &,int const *,int) const\n" - " ofShader::setUniform3iv(std::string const &,int const *) const\n"); lua_error(L);return 0; } -static int _wrap_Shader_setUniform4iv__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; int *arg3 = (int *) 0 ; int arg4 ; std::string temp2 ; - SWIG_check_num_args("ofShader::setUniform4iv",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniform4iv",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniform4iv",2,"std::string const &"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofShader::setUniform4iv",3,"int const *"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofShader::setUniform4iv",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniform4iv",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_int,0))){ SWIG_fail_ptr("Shader_setUniform4iv",3,SWIGTYPE_p_int); } - arg4 = (int)lua_tonumber(L, 4); ((ofShader const *)arg1)->setUniform4iv((std::string const &)*arg2,(int const *)arg3,arg4); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniform4iv__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; int *arg3 = (int *) 0 ; std::string temp2 ; SWIG_check_num_args("ofShader::setUniform4iv",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniform4iv",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniform4iv",2,"std::string const &"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofShader::setUniform4iv",3,"int const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniform4iv",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_int,0))){ SWIG_fail_ptr("Shader_setUniform4iv",3,SWIGTYPE_p_int); } - ((ofShader const *)arg1)->setUniform4iv((std::string const &)*arg2,(int const *)arg3); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniform4iv(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_int, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_Shader_setUniform4iv__SWIG_1(L);} } } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_int, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Shader_setUniform4iv__SWIG_0(L);} - } } } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Shader_setUniform4iv'\n" - " Possible C/C++ prototypes are:\n" " ofShader::setUniform4iv(std::string const &,int const *,int) const\n" - " ofShader::setUniform4iv(std::string const &,int const *) const\n"); lua_error(L);return 0; } -static int _wrap_Shader_setUniform1fv__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; float *arg3 = (float *) 0 ; int arg4 ; std::string temp2 ; - SWIG_check_num_args("ofShader::setUniform1fv",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniform1fv",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniform1fv",2,"std::string const &"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofShader::setUniform1fv",3,"float const *"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofShader::setUniform1fv",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniform1fv",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Shader_setUniform1fv",3,SWIGTYPE_p_float); } arg4 = (int)lua_tonumber(L, 4); - ((ofShader const *)arg1)->setUniform1fv((std::string const &)*arg2,(float const *)arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniform1fv__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; float *arg3 = (float *) 0 ; std::string temp2 ; SWIG_check_num_args("ofShader::setUniform1fv",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniform1fv",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniform1fv",2,"std::string const &"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofShader::setUniform1fv",3,"float const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniform1fv",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Shader_setUniform1fv",3,SWIGTYPE_p_float); } - ((ofShader const *)arg1)->setUniform1fv((std::string const &)*arg2,(float const *)arg3); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniform1fv(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Shader_setUniform1fv__SWIG_1(L);} } } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { - return _wrap_Shader_setUniform1fv__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Shader_setUniform1fv'\n" - " Possible C/C++ prototypes are:\n" " ofShader::setUniform1fv(std::string const &,float const *,int) const\n" - " ofShader::setUniform1fv(std::string const &,float const *) const\n"); lua_error(L);return 0; } -static int _wrap_Shader_setUniform2fv__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; float *arg3 = (float *) 0 ; int arg4 ; std::string temp2 ; - SWIG_check_num_args("ofShader::setUniform2fv",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniform2fv",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniform2fv",2,"std::string const &"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofShader::setUniform2fv",3,"float const *"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofShader::setUniform2fv",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniform2fv",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Shader_setUniform2fv",3,SWIGTYPE_p_float); } arg4 = (int)lua_tonumber(L, 4); - ((ofShader const *)arg1)->setUniform2fv((std::string const &)*arg2,(float const *)arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniform2fv__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; float *arg3 = (float *) 0 ; std::string temp2 ; SWIG_check_num_args("ofShader::setUniform2fv",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniform2fv",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniform2fv",2,"std::string const &"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofShader::setUniform2fv",3,"float const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniform2fv",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Shader_setUniform2fv",3,SWIGTYPE_p_float); } - ((ofShader const *)arg1)->setUniform2fv((std::string const &)*arg2,(float const *)arg3); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniform2fv(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Shader_setUniform2fv__SWIG_1(L);} } } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { - return _wrap_Shader_setUniform2fv__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Shader_setUniform2fv'\n" - " Possible C/C++ prototypes are:\n" " ofShader::setUniform2fv(std::string const &,float const *,int) const\n" - " ofShader::setUniform2fv(std::string const &,float const *) const\n"); lua_error(L);return 0; } -static int _wrap_Shader_setUniform3fv__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; float *arg3 = (float *) 0 ; int arg4 ; std::string temp2 ; - SWIG_check_num_args("ofShader::setUniform3fv",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniform3fv",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniform3fv",2,"std::string const &"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofShader::setUniform3fv",3,"float const *"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofShader::setUniform3fv",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniform3fv",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Shader_setUniform3fv",3,SWIGTYPE_p_float); } arg4 = (int)lua_tonumber(L, 4); - ((ofShader const *)arg1)->setUniform3fv((std::string const &)*arg2,(float const *)arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniform3fv__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; float *arg3 = (float *) 0 ; std::string temp2 ; SWIG_check_num_args("ofShader::setUniform3fv",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniform3fv",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniform3fv",2,"std::string const &"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofShader::setUniform3fv",3,"float const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniform3fv",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Shader_setUniform3fv",3,SWIGTYPE_p_float); } - ((ofShader const *)arg1)->setUniform3fv((std::string const &)*arg2,(float const *)arg3); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniform3fv(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Shader_setUniform3fv__SWIG_1(L);} } } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { - return _wrap_Shader_setUniform3fv__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Shader_setUniform3fv'\n" - " Possible C/C++ prototypes are:\n" " ofShader::setUniform3fv(std::string const &,float const *,int) const\n" - " ofShader::setUniform3fv(std::string const &,float const *) const\n"); lua_error(L);return 0; } -static int _wrap_Shader_setUniform4fv__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; float *arg3 = (float *) 0 ; int arg4 ; std::string temp2 ; - SWIG_check_num_args("ofShader::setUniform4fv",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniform4fv",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniform4fv",2,"std::string const &"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofShader::setUniform4fv",3,"float const *"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofShader::setUniform4fv",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniform4fv",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Shader_setUniform4fv",3,SWIGTYPE_p_float); } arg4 = (int)lua_tonumber(L, 4); - ((ofShader const *)arg1)->setUniform4fv((std::string const &)*arg2,(float const *)arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniform4fv__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; float *arg3 = (float *) 0 ; std::string temp2 ; SWIG_check_num_args("ofShader::setUniform4fv",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniform4fv",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniform4fv",2,"std::string const &"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofShader::setUniform4fv",3,"float const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniform4fv",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Shader_setUniform4fv",3,SWIGTYPE_p_float); } - ((ofShader const *)arg1)->setUniform4fv((std::string const &)*arg2,(float const *)arg3); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniform4fv(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Shader_setUniform4fv__SWIG_1(L);} } } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { - return _wrap_Shader_setUniform4fv__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Shader_setUniform4fv'\n" - " Possible C/C++ prototypes are:\n" " ofShader::setUniform4fv(std::string const &,float const *,int) const\n" - " ofShader::setUniform4fv(std::string const &,float const *) const\n"); lua_error(L);return 0; } -static int _wrap_Shader_setUniforms(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - ofParameterGroup *arg2 = 0 ; SWIG_check_num_args("ofShader::setUniforms",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniforms",1,"ofShader const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofShader::setUniforms",2,"ofParameterGroup const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniforms",1,SWIGTYPE_p_ofShader); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofParameterGroup,0))){ - SWIG_fail_ptr("Shader_setUniforms",2,SWIGTYPE_p_ofParameterGroup); } - ((ofShader const *)arg1)->setUniforms((ofParameterGroup const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Shader_setUniformMatrix3f__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; ofMatrix3x3 *arg3 = 0 ; int arg4 ; std::string temp2 ; - SWIG_check_num_args("ofShader::setUniformMatrix3f",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniformMatrix3f",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniformMatrix3f",2,"std::string const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofShader::setUniformMatrix3f",3,"ofMatrix3x3 const &"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofShader::setUniformMatrix3f",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniformMatrix3f",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Shader_setUniformMatrix3f",3,SWIGTYPE_p_ofMatrix3x3); } arg4 = (int)lua_tonumber(L, 4); - ((ofShader const *)arg1)->setUniformMatrix3f((std::string const &)*arg2,(ofMatrix3x3 const &)*arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniformMatrix3f__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; ofMatrix3x3 *arg3 = 0 ; std::string temp2 ; SWIG_check_num_args("ofShader::setUniformMatrix3f",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniformMatrix3f",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniformMatrix3f",2,"std::string const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofShader::setUniformMatrix3f",3,"ofMatrix3x3 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniformMatrix3f",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofMatrix3x3,0))){ - SWIG_fail_ptr("Shader_setUniformMatrix3f",3,SWIGTYPE_p_ofMatrix3x3); } - ((ofShader const *)arg1)->setUniformMatrix3f((std::string const &)*arg2,(ofMatrix3x3 const &)*arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniformMatrix3f(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofMatrix3x3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Shader_setUniformMatrix3f__SWIG_1(L);} } } } if (argc == 4) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofMatrix3x3, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { - return _wrap_Shader_setUniformMatrix3f__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Shader_setUniformMatrix3f'\n" - " Possible C/C++ prototypes are:\n" " ofShader::setUniformMatrix3f(std::string const &,ofMatrix3x3 const &,int) const\n" - " ofShader::setUniformMatrix3f(std::string const &,ofMatrix3x3 const &) const\n"); lua_error(L);return 0; } -static int _wrap_Shader_setUniformMatrix4f__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; ofMatrix4x4 *arg3 = 0 ; int arg4 ; std::string temp2 ; - SWIG_check_num_args("ofShader::setUniformMatrix4f",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniformMatrix4f",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniformMatrix4f",2,"std::string const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofShader::setUniformMatrix4f",3,"ofMatrix4x4 const &"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofShader::setUniformMatrix4f",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniformMatrix4f",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Shader_setUniformMatrix4f",3,SWIGTYPE_p_ofMatrix4x4); } arg4 = (int)lua_tonumber(L, 4); - ((ofShader const *)arg1)->setUniformMatrix4f((std::string const &)*arg2,(ofMatrix4x4 const &)*arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniformMatrix4f__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; ofMatrix4x4 *arg3 = 0 ; std::string temp2 ; SWIG_check_num_args("ofShader::setUniformMatrix4f",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setUniformMatrix4f",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setUniformMatrix4f",2,"std::string const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofShader::setUniformMatrix4f",3,"ofMatrix4x4 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setUniformMatrix4f",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("Shader_setUniformMatrix4f",3,SWIGTYPE_p_ofMatrix4x4); } - ((ofShader const *)arg1)->setUniformMatrix4f((std::string const &)*arg2,(ofMatrix4x4 const &)*arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setUniformMatrix4f(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Shader_setUniformMatrix4f__SWIG_1(L);} } } } if (argc == 4) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { - return _wrap_Shader_setUniformMatrix4f__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Shader_setUniformMatrix4f'\n" - " Possible C/C++ prototypes are:\n" " ofShader::setUniformMatrix4f(std::string const &,ofMatrix4x4 const &,int) const\n" - " ofShader::setUniformMatrix4f(std::string const &,ofMatrix4x4 const &) const\n"); lua_error(L);return 0; } -static int _wrap_Shader_getUniformLocation(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; std::string temp2 ; GLint result; SWIG_check_num_args("ofShader::getUniformLocation",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::getUniformLocation",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::getUniformLocation",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_getUniformLocation",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = (GLint)((ofShader const *)arg1)->getUniformLocation((std::string const &)*arg2); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_getAttributeLocation(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; std::string temp2 ; GLint result; SWIG_check_num_args("ofShader::getAttributeLocation",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::getAttributeLocation",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::getAttributeLocation",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_getAttributeLocation",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = (GLint)((ofShader const *)arg1)->getAttributeLocation((std::string const &)*arg2); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setAttribute1f(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; GLint arg2 ; - float arg3 ; SWIG_check_num_args("ofShader::setAttribute1f",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setAttribute1f",1,"ofShader const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofShader::setAttribute1f",2,"GLint"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofShader::setAttribute1f",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setAttribute1f",1,SWIGTYPE_p_ofShader); } arg2 = (GLint)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); ((ofShader const *)arg1)->setAttribute1f(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setAttribute2f(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; GLint arg2 ; - float arg3 ; float arg4 ; SWIG_check_num_args("ofShader::setAttribute2f",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setAttribute2f",1,"ofShader const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofShader::setAttribute2f",2,"GLint"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofShader::setAttribute2f",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofShader::setAttribute2f",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setAttribute2f",1,SWIGTYPE_p_ofShader); } arg2 = (GLint)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); ((ofShader const *)arg1)->setAttribute2f(arg2,arg3,arg4); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setAttribute3f(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; GLint arg2 ; - float arg3 ; float arg4 ; float arg5 ; SWIG_check_num_args("ofShader::setAttribute3f",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setAttribute3f",1,"ofShader const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofShader::setAttribute3f",2,"GLint"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofShader::setAttribute3f",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofShader::setAttribute3f",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofShader::setAttribute3f",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setAttribute3f",1,SWIGTYPE_p_ofShader); } arg2 = (GLint)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - ((ofShader const *)arg1)->setAttribute3f(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Shader_setAttribute4f(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; GLint arg2 ; - float arg3 ; float arg4 ; float arg5 ; float arg6 ; SWIG_check_num_args("ofShader::setAttribute4f",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setAttribute4f",1,"ofShader const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofShader::setAttribute4f",2,"GLint"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofShader::setAttribute4f",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofShader::setAttribute4f",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofShader::setAttribute4f",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofShader::setAttribute4f",6,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setAttribute4f",1,SWIGTYPE_p_ofShader); } arg2 = (GLint)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); ((ofShader const *)arg1)->setAttribute4f(arg2,arg3,arg4,arg5,arg6); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setAttribute1fv__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; float *arg3 = (float *) 0 ; GLsizei arg4 ; std::string temp2 ; GLsizei *argp4 ; - SWIG_check_num_args("ofShader::setAttribute1fv",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setAttribute1fv",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setAttribute1fv",2,"std::string const &"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofShader::setAttribute1fv",3,"float const *"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofShader::setAttribute1fv",4,"GLsizei"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setAttribute1fv",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Shader_setAttribute1fv",3,SWIGTYPE_p_float); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&argp4,SWIGTYPE_p_GLsizei,0))){ - SWIG_fail_ptr("Shader_setAttribute1fv",4,SWIGTYPE_p_GLsizei); } arg4 = *argp4; - ((ofShader const *)arg1)->setAttribute1fv((std::string const &)*arg2,(float const *)arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setAttribute1fv__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; float *arg3 = (float *) 0 ; std::string temp2 ; SWIG_check_num_args("ofShader::setAttribute1fv",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setAttribute1fv",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setAttribute1fv",2,"std::string const &"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofShader::setAttribute1fv",3,"float const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setAttribute1fv",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Shader_setAttribute1fv",3,SWIGTYPE_p_float); } - ((ofShader const *)arg1)->setAttribute1fv((std::string const &)*arg2,(float const *)arg3); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setAttribute1fv(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Shader_setAttribute1fv__SWIG_1(L);} } } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_GLsizei, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Shader_setAttribute1fv__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Shader_setAttribute1fv'\n" - " Possible C/C++ prototypes are:\n" " ofShader::setAttribute1fv(std::string const &,float const *,GLsizei) const\n" - " ofShader::setAttribute1fv(std::string const &,float const *) const\n"); lua_error(L);return 0; } -static int _wrap_Shader_setAttribute2fv__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; float *arg3 = (float *) 0 ; GLsizei arg4 ; std::string temp2 ; GLsizei *argp4 ; - SWIG_check_num_args("ofShader::setAttribute2fv",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setAttribute2fv",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setAttribute2fv",2,"std::string const &"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofShader::setAttribute2fv",3,"float const *"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofShader::setAttribute2fv",4,"GLsizei"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setAttribute2fv",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Shader_setAttribute2fv",3,SWIGTYPE_p_float); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&argp4,SWIGTYPE_p_GLsizei,0))){ - SWIG_fail_ptr("Shader_setAttribute2fv",4,SWIGTYPE_p_GLsizei); } arg4 = *argp4; - ((ofShader const *)arg1)->setAttribute2fv((std::string const &)*arg2,(float const *)arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setAttribute2fv__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; float *arg3 = (float *) 0 ; std::string temp2 ; SWIG_check_num_args("ofShader::setAttribute2fv",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setAttribute2fv",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setAttribute2fv",2,"std::string const &"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofShader::setAttribute2fv",3,"float const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setAttribute2fv",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Shader_setAttribute2fv",3,SWIGTYPE_p_float); } - ((ofShader const *)arg1)->setAttribute2fv((std::string const &)*arg2,(float const *)arg3); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setAttribute2fv(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Shader_setAttribute2fv__SWIG_1(L);} } } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_GLsizei, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Shader_setAttribute2fv__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Shader_setAttribute2fv'\n" - " Possible C/C++ prototypes are:\n" " ofShader::setAttribute2fv(std::string const &,float const *,GLsizei) const\n" - " ofShader::setAttribute2fv(std::string const &,float const *) const\n"); lua_error(L);return 0; } -static int _wrap_Shader_setAttribute3fv__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; float *arg3 = (float *) 0 ; GLsizei arg4 ; std::string temp2 ; GLsizei *argp4 ; - SWIG_check_num_args("ofShader::setAttribute3fv",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setAttribute3fv",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setAttribute3fv",2,"std::string const &"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofShader::setAttribute3fv",3,"float const *"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofShader::setAttribute3fv",4,"GLsizei"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setAttribute3fv",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Shader_setAttribute3fv",3,SWIGTYPE_p_float); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&argp4,SWIGTYPE_p_GLsizei,0))){ - SWIG_fail_ptr("Shader_setAttribute3fv",4,SWIGTYPE_p_GLsizei); } arg4 = *argp4; - ((ofShader const *)arg1)->setAttribute3fv((std::string const &)*arg2,(float const *)arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setAttribute3fv__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; float *arg3 = (float *) 0 ; std::string temp2 ; SWIG_check_num_args("ofShader::setAttribute3fv",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setAttribute3fv",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setAttribute3fv",2,"std::string const &"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofShader::setAttribute3fv",3,"float const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setAttribute3fv",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Shader_setAttribute3fv",3,SWIGTYPE_p_float); } - ((ofShader const *)arg1)->setAttribute3fv((std::string const &)*arg2,(float const *)arg3); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setAttribute3fv(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Shader_setAttribute3fv__SWIG_1(L);} } } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_GLsizei, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Shader_setAttribute3fv__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Shader_setAttribute3fv'\n" - " Possible C/C++ prototypes are:\n" " ofShader::setAttribute3fv(std::string const &,float const *,GLsizei) const\n" - " ofShader::setAttribute3fv(std::string const &,float const *) const\n"); lua_error(L);return 0; } -static int _wrap_Shader_setAttribute4fv__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; float *arg3 = (float *) 0 ; GLsizei arg4 ; std::string temp2 ; GLsizei *argp4 ; - SWIG_check_num_args("ofShader::setAttribute4fv",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setAttribute4fv",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setAttribute4fv",2,"std::string const &"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofShader::setAttribute4fv",3,"float const *"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofShader::setAttribute4fv",4,"GLsizei"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setAttribute4fv",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Shader_setAttribute4fv",3,SWIGTYPE_p_float); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&argp4,SWIGTYPE_p_GLsizei,0))){ - SWIG_fail_ptr("Shader_setAttribute4fv",4,SWIGTYPE_p_GLsizei); } arg4 = *argp4; - ((ofShader const *)arg1)->setAttribute4fv((std::string const &)*arg2,(float const *)arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setAttribute4fv__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - std::string *arg2 = 0 ; float *arg3 = (float *) 0 ; std::string temp2 ; SWIG_check_num_args("ofShader::setAttribute4fv",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setAttribute4fv",1,"ofShader const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofShader::setAttribute4fv",2,"std::string const &"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofShader::setAttribute4fv",3,"float const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setAttribute4fv",1,SWIGTYPE_p_ofShader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Shader_setAttribute4fv",3,SWIGTYPE_p_float); } - ((ofShader const *)arg1)->setAttribute4fv((std::string const &)*arg2,(float const *)arg3); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setAttribute4fv(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Shader_setAttribute4fv__SWIG_1(L);} } } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_GLsizei, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Shader_setAttribute4fv__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Shader_setAttribute4fv'\n" - " Possible C/C++ prototypes are:\n" " ofShader::setAttribute4fv(std::string const &,float const *,GLsizei) const\n" - " ofShader::setAttribute4fv(std::string const &,float const *) const\n"); lua_error(L);return 0; } -static int _wrap_Shader_bindAttribute(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; GLuint arg2 ; - std::string *arg3 = 0 ; std::string temp3 ; SWIG_check_num_args("ofShader::bindAttribute",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::bindAttribute",1,"ofShader const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofShader::bindAttribute",2,"GLuint"); - if(!lua_isstring(L,3)) SWIG_fail_arg("ofShader::bindAttribute",3,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_bindAttribute",1,SWIGTYPE_p_ofShader); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (GLuint)lua_tonumber(L, 2); - temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3; - ((ofShader const *)arg1)->bindAttribute(arg2,(std::string const &)*arg3); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Shader_printActiveUniforms(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - SWIG_check_num_args("ofShader::printActiveUniforms",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::printActiveUniforms",1,"ofShader const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_printActiveUniforms",1,SWIGTYPE_p_ofShader); } ((ofShader const *)arg1)->printActiveUniforms(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_printActiveAttributes(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - SWIG_check_num_args("ofShader::printActiveAttributes",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::printActiveAttributes",1,"ofShader const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_printActiveAttributes",1,SWIGTYPE_p_ofShader); } ((ofShader const *)arg1)->printActiveAttributes(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setupShaderFromSource__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - GLenum arg2 ; std::string arg3 ; std::string arg4 ; bool result; SWIG_check_num_args("ofShader::setupShaderFromSource",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setupShaderFromSource",1,"ofShader *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofShader::setupShaderFromSource",2,"GLenum"); - if(!lua_isstring(L,3)) SWIG_fail_arg("ofShader::setupShaderFromSource",3,"std::string"); - if(!lua_isstring(L,4)) SWIG_fail_arg("ofShader::setupShaderFromSource",4,"std::string"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setupShaderFromSource",1,SWIGTYPE_p_ofShader); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (GLenum)lua_tonumber(L, 2); - (&arg3)->assign(lua_tostring(L,3),lua_rawlen(L,3)); (&arg4)->assign(lua_tostring(L,4),lua_rawlen(L,4)); - result = (bool)(arg1)->setupShaderFromSource(arg2,arg3,arg4); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setupShaderFromSource__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; - GLenum arg2 ; std::string arg3 ; bool result; SWIG_check_num_args("ofShader::setupShaderFromSource",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setupShaderFromSource",1,"ofShader *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofShader::setupShaderFromSource",2,"GLenum"); - if(!lua_isstring(L,3)) SWIG_fail_arg("ofShader::setupShaderFromSource",3,"std::string"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setupShaderFromSource",1,SWIGTYPE_p_ofShader); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (GLenum)lua_tonumber(L, 2); - (&arg3)->assign(lua_tostring(L,3),lua_rawlen(L,3)); result = (bool)(arg1)->setupShaderFromSource(arg2,arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_setupShaderFromSource(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isstring(L,argv[2]); } if (_v) { - return _wrap_Shader_setupShaderFromSource__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofShader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isstring(L,argv[2]); } if (_v) { - { _v = lua_isstring(L,argv[3]); } if (_v) { return _wrap_Shader_setupShaderFromSource__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Shader_setupShaderFromSource'\n" - " Possible C/C++ prototypes are:\n" " ofShader::setupShaderFromSource(GLenum,std::string,std::string)\n" - " ofShader::setupShaderFromSource(GLenum,std::string)\n"); lua_error(L);return 0; } -static int _wrap_Shader_setupShaderFromFile(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; GLenum arg2 ; - std::string arg3 ; bool result; SWIG_check_num_args("ofShader::setupShaderFromFile",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::setupShaderFromFile",1,"ofShader *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofShader::setupShaderFromFile",2,"GLenum"); - if(!lua_isstring(L,3)) SWIG_fail_arg("ofShader::setupShaderFromFile",3,"std::string"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_setupShaderFromFile",1,SWIGTYPE_p_ofShader); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (GLenum)lua_tonumber(L, 2); - (&arg3)->assign(lua_tostring(L,3),lua_rawlen(L,3)); result = (bool)(arg1)->setupShaderFromFile(arg2,arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_linkProgram(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; bool result; - SWIG_check_num_args("ofShader::linkProgram",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::linkProgram",1,"ofShader *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_linkProgram",1,SWIGTYPE_p_ofShader); } result = (bool)(arg1)->linkProgram(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_bindDefaults(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; bool result; - SWIG_check_num_args("ofShader::bindDefaults",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::bindDefaults",1,"ofShader const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_bindDefaults",1,SWIGTYPE_p_ofShader); } result = (bool)((ofShader const *)arg1)->bindDefaults(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_getProgram(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; GLuint result; - SWIG_check_num_args("ofShader::getProgram",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::getProgram",1,"ofShader const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_getProgram",1,SWIGTYPE_p_ofShader); } result = (GLuint)((ofShader const *)arg1)->getProgram(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_getShader(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; GLenum arg2 ; - GLuint result; SWIG_check_num_args("ofShader::getShader",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::getShader",1,"ofShader const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofShader::getShader",2,"GLenum"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_getShader",1,SWIGTYPE_p_ofShader); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (GLenum)lua_tonumber(L, 2); - result = (GLuint)((ofShader const *)arg1)->getShader(arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader___eq(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; ofShader *arg2 = 0 ; - bool result; SWIG_check_num_args("ofShader::operator ==",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::operator ==",1,"ofShader const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofShader::operator ==",2,"ofShader const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader___eq",1,SWIGTYPE_p_ofShader); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader___eq",2,SWIGTYPE_p_ofShader); } - result = (bool)((ofShader const *)arg1)->operator ==((ofShader const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Shader_getShaderSource(lua_State* L) { int SWIG_arg = 0; ofShader *arg1 = (ofShader *) 0 ; GLenum arg2 ; - std::string result; SWIG_check_num_args("ofShader::getShaderSource",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofShader::getShaderSource",1,"ofShader const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofShader::getShaderSource",2,"GLenum"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofShader,0))){ - SWIG_fail_ptr("Shader_getShaderSource",1,SWIGTYPE_p_ofShader); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (GLenum)lua_tonumber(L, 2); - result = ((ofShader const *)arg1)->getShaderSource(arg2); lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_Shader(void *obj) { -ofShader *arg1 = (ofShader *) obj; -delete_ofShader(arg1); -} -static int _proxy__wrap_new_Shader(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_Shader); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_Shader_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_Shader_methods[]= { - { "load", _wrap_Shader_load}, - { "setGeometryInputType", _wrap_Shader_setGeometryInputType}, - { "setGeometryOutputType", _wrap_Shader_setGeometryOutputType}, - { "setGeometryOutputCount", _wrap_Shader_setGeometryOutputCount}, - { "getGeometryMaxOutputCount", _wrap_Shader_getGeometryMaxOutputCount}, - { "unload", _wrap_Shader_unload}, - { "isLoaded", _wrap_Shader_isLoaded}, - { "beginShader", _wrap_Shader_beginShader}, - { "endShader", _wrap_Shader_endShader}, - { "setUniformTexture", _wrap_Shader_setUniformTexture}, - { "setUniform1i", _wrap_Shader_setUniform1i}, - { "setUniform2i", _wrap_Shader_setUniform2i}, - { "setUniform3i", _wrap_Shader_setUniform3i}, - { "setUniform4i", _wrap_Shader_setUniform4i}, - { "setUniform1f", _wrap_Shader_setUniform1f}, - { "setUniform2f", _wrap_Shader_setUniform2f}, - { "setUniform3f", _wrap_Shader_setUniform3f}, - { "setUniform4f", _wrap_Shader_setUniform4f}, - { "setUniform1iv", _wrap_Shader_setUniform1iv}, - { "setUniform2iv", _wrap_Shader_setUniform2iv}, - { "setUniform3iv", _wrap_Shader_setUniform3iv}, - { "setUniform4iv", _wrap_Shader_setUniform4iv}, - { "setUniform1fv", _wrap_Shader_setUniform1fv}, - { "setUniform2fv", _wrap_Shader_setUniform2fv}, - { "setUniform3fv", _wrap_Shader_setUniform3fv}, - { "setUniform4fv", _wrap_Shader_setUniform4fv}, - { "setUniforms", _wrap_Shader_setUniforms}, - { "setUniformMatrix3f", _wrap_Shader_setUniformMatrix3f}, - { "setUniformMatrix4f", _wrap_Shader_setUniformMatrix4f}, - { "getUniformLocation", _wrap_Shader_getUniformLocation}, - { "getAttributeLocation", _wrap_Shader_getAttributeLocation}, - { "setAttribute1f", _wrap_Shader_setAttribute1f}, - { "setAttribute2f", _wrap_Shader_setAttribute2f}, - { "setAttribute3f", _wrap_Shader_setAttribute3f}, - { "setAttribute4f", _wrap_Shader_setAttribute4f}, - { "setAttribute1fv", _wrap_Shader_setAttribute1fv}, - { "setAttribute2fv", _wrap_Shader_setAttribute2fv}, - { "setAttribute3fv", _wrap_Shader_setAttribute3fv}, - { "setAttribute4fv", _wrap_Shader_setAttribute4fv}, - { "bindAttribute", _wrap_Shader_bindAttribute}, - { "printActiveUniforms", _wrap_Shader_printActiveUniforms}, - { "printActiveAttributes", _wrap_Shader_printActiveAttributes}, - { "setupShaderFromSource", _wrap_Shader_setupShaderFromSource}, - { "setupShaderFromFile", _wrap_Shader_setupShaderFromFile}, - { "linkProgram", _wrap_Shader_linkProgram}, - { "bindDefaults", _wrap_Shader_bindDefaults}, - { "getProgram", _wrap_Shader_getProgram}, - { "getShader", _wrap_Shader_getShader}, - { "__eq", _wrap_Shader___eq}, - { "getShaderSource", _wrap_Shader_getShaderSource}, - {0,0} -}; -static swig_lua_method swig_Shader_meta[] = { - { "__eq", _wrap_Shader___eq}, - {0,0} -}; - -static swig_lua_attribute swig_Shader_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_Shader_Sf_SwigStatic_constants[]= { - {SWIG_LUA_CONSTTAB_INT("POSITION_ATTRIBUTE", ofShader::POSITION_ATTRIBUTE)}, - {SWIG_LUA_CONSTTAB_INT("COLOR_ATTRIBUTE", ofShader::COLOR_ATTRIBUTE)}, - {SWIG_LUA_CONSTTAB_INT("NORMAL_ATTRIBUTE", ofShader::NORMAL_ATTRIBUTE)}, - {SWIG_LUA_CONSTTAB_INT("TEXCOORD_ATTRIBUTE", ofShader::TEXCOORD_ATTRIBUTE)}, - {SWIG_LUA_CONSTTAB_INT("INDEX_ATTRIBUTE", ofShader::INDEX_ATTRIBUTE)}, - {0,0,0,0,0,0} -}; -static swig_lua_method swig_Shader_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_Shader_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_Shader_Sf_SwigStatic = { - "Shader", - swig_Shader_Sf_SwigStatic_methods, - swig_Shader_Sf_SwigStatic_attributes, - swig_Shader_Sf_SwigStatic_constants, - swig_Shader_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_Shader_bases[] = {0}; -static const char *swig_Shader_base_names[] = {0}; -static swig_lua_class _wrap_class_Shader = { "Shader", "Shader", &SWIGTYPE_p_ofShader,_proxy__wrap_new_Shader, swig_delete_Shader, swig_Shader_methods, swig_Shader_attributes, &swig_Shader_Sf_SwigStatic, swig_Shader_meta, swig_Shader_bases, swig_Shader_base_names }; - -static int _wrap_new_Vbo__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVbo *result = 0 ; SWIG_check_num_args("ofVbo::ofVbo",0,0) - result = (ofVbo *)new ofVbo(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVbo,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_new_Vbo__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = 0 ; ofVbo *result = 0 ; - SWIG_check_num_args("ofVbo::ofVbo",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofVbo::ofVbo",1,"ofVbo const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ SWIG_fail_ptr("new_Vbo",1,SWIGTYPE_p_ofVbo); } - result = (ofVbo *)new ofVbo((ofVbo const &)*arg1); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVbo,1); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_new_Vbo(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_Vbo__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_new_Vbo__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_Vbo'\n" " Possible C/C++ prototypes are:\n" - " ofVbo::ofVbo()\n" " ofVbo::ofVbo(ofVbo const &)\n"); lua_error(L);return 0; } -static int _wrap_Vbo_setMesh__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; ofMesh *arg2 = 0 ; int arg3 ; - SWIG_check_num_args("ofVbo::setMesh",3,3) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::setMesh",1,"ofVbo *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVbo::setMesh",2,"ofMesh const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::setMesh",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ SWIG_fail_ptr("Vbo_setMesh",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Vbo_setMesh",2,SWIGTYPE_p_ofMesh); } - arg3 = (int)lua_tonumber(L, 3); (arg1)->setMesh((ofMesh const &)*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_setMesh__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; ofMesh *arg2 = 0 ; int arg3 ; - bool arg4 ; bool arg5 ; bool arg6 ; SWIG_check_num_args("ofVbo::setMesh",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::setMesh",1,"ofVbo *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVbo::setMesh",2,"ofMesh const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::setMesh",3,"int"); - if(!lua_isboolean(L,4)) SWIG_fail_arg("ofVbo::setMesh",4,"bool"); - if(!lua_isboolean(L,5)) SWIG_fail_arg("ofVbo::setMesh",5,"bool"); - if(!lua_isboolean(L,6)) SWIG_fail_arg("ofVbo::setMesh",6,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ SWIG_fail_ptr("Vbo_setMesh",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Vbo_setMesh",2,SWIGTYPE_p_ofMesh); } - arg3 = (int)lua_tonumber(L, 3); arg4 = (lua_toboolean(L, 4)!=0); arg5 = (lua_toboolean(L, 5)!=0); - arg6 = (lua_toboolean(L, 6)!=0); (arg1)->setMesh((ofMesh const &)*arg2,arg3,arg4,arg5,arg6); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_setMesh(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Vbo_setMesh__SWIG_0(L);} } } - } if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isboolean(L,argv[3]); } - if (_v) { { _v = lua_isboolean(L,argv[4]); } if (_v) { { _v = lua_isboolean(L,argv[5]); } if (_v) { - return _wrap_Vbo_setMesh__SWIG_1(L);} } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_setMesh'\n" " Possible C/C++ prototypes are:\n" - " ofVbo::setMesh(ofMesh const &,int)\n" " ofVbo::setMesh(ofMesh const &,int,bool,bool,bool)\n"); lua_error(L);return 0; } -static int _wrap_Vbo_setVertexData__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - ofVec3f *arg2 = (ofVec3f *) 0 ; int arg3 ; int arg4 ; SWIG_check_num_args("ofVbo::setVertexData",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::setVertexData",1,"ofVbo *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofVbo::setVertexData",2,"ofVec3f const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::setVertexData",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVbo::setVertexData",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_setVertexData",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vbo_setVertexData",2,SWIGTYPE_p_ofVec3f); } arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - (arg1)->setVertexData((ofVec3f const *)arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vbo_setVertexData__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - ofVec2f *arg2 = (ofVec2f *) 0 ; int arg3 ; int arg4 ; SWIG_check_num_args("ofVbo::setVertexData",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::setVertexData",1,"ofVbo *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofVbo::setVertexData",2,"ofVec2f const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::setVertexData",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVbo::setVertexData",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_setVertexData",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vbo_setVertexData",2,SWIGTYPE_p_ofVec2f); } arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - (arg1)->setVertexData((ofVec2f const *)arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vbo_setColorData__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - ofFloatColor *arg2 = (ofFloatColor *) 0 ; int arg3 ; int arg4 ; SWIG_check_num_args("ofVbo::setColorData",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::setColorData",1,"ofVbo *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofVbo::setColorData",2,"ofFloatColor const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::setColorData",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVbo::setColorData",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ SWIG_fail_ptr("Vbo_setColorData",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("Vbo_setColorData",2,SWIGTYPE_p_ofColor_T_float_t); } arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); (arg1)->setColorData((ofFloatColor const *)arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_setNormalData__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - ofVec3f *arg2 = (ofVec3f *) 0 ; int arg3 ; int arg4 ; SWIG_check_num_args("ofVbo::setNormalData",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::setNormalData",1,"ofVbo *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofVbo::setNormalData",2,"ofVec3f const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::setNormalData",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVbo::setNormalData",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_setNormalData",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vbo_setNormalData",2,SWIGTYPE_p_ofVec3f); } arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - (arg1)->setNormalData((ofVec3f const *)arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vbo_setTexCoordData__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - ofVec2f *arg2 = (ofVec2f *) 0 ; int arg3 ; int arg4 ; SWIG_check_num_args("ofVbo::setTexCoordData",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::setTexCoordData",1,"ofVbo *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofVbo::setTexCoordData",2,"ofVec2f const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::setTexCoordData",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVbo::setTexCoordData",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_setTexCoordData",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vbo_setTexCoordData",2,SWIGTYPE_p_ofVec2f); } arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); (arg1)->setTexCoordData((ofVec2f const *)arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_setIndexData(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - ofIndexType *arg2 = (ofIndexType *) 0 ; int arg3 ; int arg4 ; SWIG_check_num_args("ofVbo::setIndexData",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::setIndexData",1,"ofVbo *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofVbo::setIndexData",2,"ofIndexType const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::setIndexData",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVbo::setIndexData",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ SWIG_fail_ptr("Vbo_setIndexData",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_unsigned_short,0))){ - SWIG_fail_ptr("Vbo_setIndexData",2,SWIGTYPE_p_unsigned_short); } arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); (arg1)->setIndexData((ofIndexType const *)arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_setVertexData__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - float *arg2 = (float *) 0 ; int arg3 ; int arg4 ; int arg5 ; int arg6 ; SWIG_check_num_args("ofVbo::setVertexData",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::setVertexData",1,"ofVbo *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofVbo::setVertexData",2,"float const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::setVertexData",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVbo::setVertexData",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofVbo::setVertexData",5,"int"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofVbo::setVertexData",6,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_setVertexData",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Vbo_setVertexData",2,SWIGTYPE_p_float); } arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - arg5 = (int)lua_tonumber(L, 5); arg6 = (int)lua_tonumber(L, 6); - (arg1)->setVertexData((float const *)arg2,arg3,arg4,arg5,arg6); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vbo_setVertexData__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - float *arg2 = (float *) 0 ; int arg3 ; int arg4 ; int arg5 ; SWIG_check_num_args("ofVbo::setVertexData",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::setVertexData",1,"ofVbo *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofVbo::setVertexData",2,"float const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::setVertexData",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVbo::setVertexData",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofVbo::setVertexData",5,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_setVertexData",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Vbo_setVertexData",2,SWIGTYPE_p_float); } arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - arg5 = (int)lua_tonumber(L, 5); (arg1)->setVertexData((float const *)arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_setVertexData(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); - if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Vbo_setVertexData__SWIG_0(L);} } } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Vbo_setVertexData__SWIG_1(L);} } } } } if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_Vbo_setVertexData__SWIG_3(L);} } } } } } - if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { - return _wrap_Vbo_setVertexData__SWIG_2(L);} } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_setVertexData'\n" " Possible C/C++ prototypes are:\n" - " ofVbo::setVertexData(ofVec3f const *,int,int)\n" " ofVbo::setVertexData(ofVec2f const *,int,int)\n" - " ofVbo::setVertexData(float const *,int,int,int,int)\n" " ofVbo::setVertexData(float const *,int,int,int)\n"); - lua_error(L);return 0; } -static int _wrap_Vbo_setColorData__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - float *arg2 = (float *) 0 ; int arg3 ; int arg4 ; int arg5 ; SWIG_check_num_args("ofVbo::setColorData",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::setColorData",1,"ofVbo *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofVbo::setColorData",2,"float const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::setColorData",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVbo::setColorData",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofVbo::setColorData",5,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ SWIG_fail_ptr("Vbo_setColorData",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Vbo_setColorData",2,SWIGTYPE_p_float); } arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - arg5 = (int)lua_tonumber(L, 5); (arg1)->setColorData((float const *)arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_setColorData__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - float *arg2 = (float *) 0 ; int arg3 ; int arg4 ; SWIG_check_num_args("ofVbo::setColorData",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::setColorData",1,"ofVbo *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofVbo::setColorData",2,"float const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::setColorData",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVbo::setColorData",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ SWIG_fail_ptr("Vbo_setColorData",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Vbo_setColorData",2,SWIGTYPE_p_float); } arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - (arg1)->setColorData((float const *)arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_setColorData(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 4) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Vbo_setColorData__SWIG_0(L);} } } } } if (argc == 4) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { - return _wrap_Vbo_setColorData__SWIG_2(L);} } } } } if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_Vbo_setColorData__SWIG_1(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_setColorData'\n" " Possible C/C++ prototypes are:\n" - " ofVbo::setColorData(ofFloatColor const *,int,int)\n" " ofVbo::setColorData(float const *,int,int,int)\n" - " ofVbo::setColorData(float const *,int,int)\n"); lua_error(L);return 0; } -static int _wrap_Vbo_setNormalData__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - float *arg2 = (float *) 0 ; int arg3 ; int arg4 ; int arg5 ; SWIG_check_num_args("ofVbo::setNormalData",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::setNormalData",1,"ofVbo *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofVbo::setNormalData",2,"float const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::setNormalData",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVbo::setNormalData",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofVbo::setNormalData",5,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_setNormalData",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Vbo_setNormalData",2,SWIGTYPE_p_float); } arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - arg5 = (int)lua_tonumber(L, 5); (arg1)->setNormalData((float const *)arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_setNormalData__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - float *arg2 = (float *) 0 ; int arg3 ; int arg4 ; SWIG_check_num_args("ofVbo::setNormalData",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::setNormalData",1,"ofVbo *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofVbo::setNormalData",2,"float const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::setNormalData",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVbo::setNormalData",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_setNormalData",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Vbo_setNormalData",2,SWIGTYPE_p_float); } arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - (arg1)->setNormalData((float const *)arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_setNormalData(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 4) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Vbo_setNormalData__SWIG_0(L);} } } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { - return _wrap_Vbo_setNormalData__SWIG_2(L);} } } } } if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_Vbo_setNormalData__SWIG_1(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_setNormalData'\n" " Possible C/C++ prototypes are:\n" - " ofVbo::setNormalData(ofVec3f const *,int,int)\n" " ofVbo::setNormalData(float const *,int,int,int)\n" - " ofVbo::setNormalData(float const *,int,int)\n"); lua_error(L);return 0; } -static int _wrap_Vbo_setTexCoordData__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - float *arg2 = (float *) 0 ; int arg3 ; int arg4 ; int arg5 ; SWIG_check_num_args("ofVbo::setTexCoordData",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::setTexCoordData",1,"ofVbo *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofVbo::setTexCoordData",2,"float const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::setTexCoordData",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVbo::setTexCoordData",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofVbo::setTexCoordData",5,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_setTexCoordData",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Vbo_setTexCoordData",2,SWIGTYPE_p_float); } arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - arg5 = (int)lua_tonumber(L, 5); (arg1)->setTexCoordData((float const *)arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_setTexCoordData__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - float *arg2 = (float *) 0 ; int arg3 ; int arg4 ; SWIG_check_num_args("ofVbo::setTexCoordData",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::setTexCoordData",1,"ofVbo *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofVbo::setTexCoordData",2,"float const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::setTexCoordData",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVbo::setTexCoordData",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_setTexCoordData",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Vbo_setTexCoordData",2,SWIGTYPE_p_float); } arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - (arg1)->setTexCoordData((float const *)arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vbo_setTexCoordData(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); - if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Vbo_setTexCoordData__SWIG_0(L);} } } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { - return _wrap_Vbo_setTexCoordData__SWIG_2(L);} } } } } if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_Vbo_setTexCoordData__SWIG_1(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_setTexCoordData'\n" - " Possible C/C++ prototypes are:\n" " ofVbo::setTexCoordData(ofVec2f const *,int,int)\n" - " ofVbo::setTexCoordData(float const *,int,int,int)\n" " ofVbo::setTexCoordData(float const *,int,int)\n"); - lua_error(L);return 0; } -static int _wrap_Vbo_setAttributeData__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; int arg2 ; - float *arg3 = (float *) 0 ; int arg4 ; int arg5 ; int arg6 ; int arg7 ; SWIG_check_num_args("ofVbo::setAttributeData",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::setAttributeData",1,"ofVbo *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVbo::setAttributeData",2,"int"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofVbo::setAttributeData",3,"float const *"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVbo::setAttributeData",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofVbo::setAttributeData",5,"int"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofVbo::setAttributeData",6,"int"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofVbo::setAttributeData",7,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_setAttributeData",1,SWIGTYPE_p_ofVbo); } arg2 = (int)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Vbo_setAttributeData",3,SWIGTYPE_p_float); } arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); - arg6 = (int)lua_tonumber(L, 6); arg7 = (int)lua_tonumber(L, 7); - (arg1)->setAttributeData(arg2,(float const *)arg3,arg4,arg5,arg6,arg7); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vbo_setAttributeData__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; int arg2 ; - float *arg3 = (float *) 0 ; int arg4 ; int arg5 ; int arg6 ; SWIG_check_num_args("ofVbo::setAttributeData",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::setAttributeData",1,"ofVbo *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVbo::setAttributeData",2,"int"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofVbo::setAttributeData",3,"float const *"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVbo::setAttributeData",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofVbo::setAttributeData",5,"int"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofVbo::setAttributeData",6,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_setAttributeData",1,SWIGTYPE_p_ofVbo); } arg2 = (int)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Vbo_setAttributeData",3,SWIGTYPE_p_float); } arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); - arg6 = (int)lua_tonumber(L, 6); (arg1)->setAttributeData(arg2,(float const *)arg3,arg4,arg5,arg6); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_setAttributeData(lua_State* L) { int argc; int argv[8]={ 1,2,3,4,5,6,7,8} ; argc = lua_gettop(L); - if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } - if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { return _wrap_Vbo_setAttributeData__SWIG_1(L);} } } } } } - } if (argc == 7) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } - if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { - return _wrap_Vbo_setAttributeData__SWIG_0(L);} } } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_setAttributeData'\n" - " Possible C/C++ prototypes are:\n" " ofVbo::setAttributeData(int,float const *,int,int,int,int)\n" - " ofVbo::setAttributeData(int,float const *,int,int,int)\n"); lua_error(L);return 0; } -static int _wrap_Vbo_setVertexBuffer__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - ofBufferObject *arg2 = 0 ; int arg3 ; int arg4 ; int arg5 ; SWIG_check_num_args("ofVbo::setVertexBuffer",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::setVertexBuffer",1,"ofVbo *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVbo::setVertexBuffer",2,"ofBufferObject &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::setVertexBuffer",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVbo::setVertexBuffer",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofVbo::setVertexBuffer",5,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_setVertexBuffer",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBufferObject,0))){ - SWIG_fail_ptr("Vbo_setVertexBuffer",2,SWIGTYPE_p_ofBufferObject); } arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); (arg1)->setVertexBuffer(*arg2,arg3,arg4,arg5); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_setVertexBuffer__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - ofBufferObject *arg2 = 0 ; int arg3 ; int arg4 ; SWIG_check_num_args("ofVbo::setVertexBuffer",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::setVertexBuffer",1,"ofVbo *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVbo::setVertexBuffer",2,"ofBufferObject &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::setVertexBuffer",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVbo::setVertexBuffer",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_setVertexBuffer",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBufferObject,0))){ - SWIG_fail_ptr("Vbo_setVertexBuffer",2,SWIGTYPE_p_ofBufferObject); } arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); (arg1)->setVertexBuffer(*arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_setVertexBuffer(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); - if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBufferObject, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Vbo_setVertexBuffer__SWIG_1(L);} } } } } if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBufferObject, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_Vbo_setVertexBuffer__SWIG_0(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_setVertexBuffer'\n" - " Possible C/C++ prototypes are:\n" " ofVbo::setVertexBuffer(ofBufferObject &,int,int,int)\n" - " ofVbo::setVertexBuffer(ofBufferObject &,int,int)\n"); lua_error(L);return 0; } -static int _wrap_Vbo_setColorBuffer__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - ofBufferObject *arg2 = 0 ; int arg3 ; int arg4 ; SWIG_check_num_args("ofVbo::setColorBuffer",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::setColorBuffer",1,"ofVbo *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVbo::setColorBuffer",2,"ofBufferObject &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::setColorBuffer",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVbo::setColorBuffer",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_setColorBuffer",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBufferObject,0))){ - SWIG_fail_ptr("Vbo_setColorBuffer",2,SWIGTYPE_p_ofBufferObject); } arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); (arg1)->setColorBuffer(*arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vbo_setColorBuffer__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - ofBufferObject *arg2 = 0 ; int arg3 ; SWIG_check_num_args("ofVbo::setColorBuffer",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::setColorBuffer",1,"ofVbo *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVbo::setColorBuffer",2,"ofBufferObject &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::setColorBuffer",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_setColorBuffer",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBufferObject,0))){ - SWIG_fail_ptr("Vbo_setColorBuffer",2,SWIGTYPE_p_ofBufferObject); } arg3 = (int)lua_tonumber(L, 3); - (arg1)->setColorBuffer(*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_setColorBuffer(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBufferObject, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Vbo_setColorBuffer__SWIG_1(L);} - } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBufferObject, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Vbo_setColorBuffer__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_setColorBuffer'\n" " Possible C/C++ prototypes are:\n" - " ofVbo::setColorBuffer(ofBufferObject &,int,int)\n" " ofVbo::setColorBuffer(ofBufferObject &,int)\n"); - lua_error(L);return 0; } -static int _wrap_Vbo_setNormalBuffer__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - ofBufferObject *arg2 = 0 ; int arg3 ; int arg4 ; SWIG_check_num_args("ofVbo::setNormalBuffer",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::setNormalBuffer",1,"ofVbo *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVbo::setNormalBuffer",2,"ofBufferObject &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::setNormalBuffer",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVbo::setNormalBuffer",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_setNormalBuffer",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBufferObject,0))){ - SWIG_fail_ptr("Vbo_setNormalBuffer",2,SWIGTYPE_p_ofBufferObject); } arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); (arg1)->setNormalBuffer(*arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_setNormalBuffer__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - ofBufferObject *arg2 = 0 ; int arg3 ; SWIG_check_num_args("ofVbo::setNormalBuffer",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::setNormalBuffer",1,"ofVbo *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVbo::setNormalBuffer",2,"ofBufferObject &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::setNormalBuffer",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_setNormalBuffer",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBufferObject,0))){ - SWIG_fail_ptr("Vbo_setNormalBuffer",2,SWIGTYPE_p_ofBufferObject); } arg3 = (int)lua_tonumber(L, 3); - (arg1)->setNormalBuffer(*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_setNormalBuffer(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBufferObject, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Vbo_setNormalBuffer__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBufferObject, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Vbo_setNormalBuffer__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_setNormalBuffer'\n" - " Possible C/C++ prototypes are:\n" " ofVbo::setNormalBuffer(ofBufferObject &,int,int)\n" - " ofVbo::setNormalBuffer(ofBufferObject &,int)\n"); lua_error(L);return 0; } -static int _wrap_Vbo_setTexCoordBuffer__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - ofBufferObject *arg2 = 0 ; int arg3 ; int arg4 ; SWIG_check_num_args("ofVbo::setTexCoordBuffer",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::setTexCoordBuffer",1,"ofVbo *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVbo::setTexCoordBuffer",2,"ofBufferObject &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::setTexCoordBuffer",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVbo::setTexCoordBuffer",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_setTexCoordBuffer",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBufferObject,0))){ - SWIG_fail_ptr("Vbo_setTexCoordBuffer",2,SWIGTYPE_p_ofBufferObject); } arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); (arg1)->setTexCoordBuffer(*arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_setTexCoordBuffer__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - ofBufferObject *arg2 = 0 ; int arg3 ; SWIG_check_num_args("ofVbo::setTexCoordBuffer",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::setTexCoordBuffer",1,"ofVbo *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVbo::setTexCoordBuffer",2,"ofBufferObject &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::setTexCoordBuffer",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_setTexCoordBuffer",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBufferObject,0))){ - SWIG_fail_ptr("Vbo_setTexCoordBuffer",2,SWIGTYPE_p_ofBufferObject); } arg3 = (int)lua_tonumber(L, 3); - (arg1)->setTexCoordBuffer(*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_setTexCoordBuffer(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBufferObject, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Vbo_setTexCoordBuffer__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBufferObject, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Vbo_setTexCoordBuffer__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_setTexCoordBuffer'\n" - " Possible C/C++ prototypes are:\n" " ofVbo::setTexCoordBuffer(ofBufferObject &,int,int)\n" - " ofVbo::setTexCoordBuffer(ofBufferObject &,int)\n"); lua_error(L);return 0; } -static int _wrap_Vbo_setIndexBuffer(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; ofBufferObject *arg2 = 0 ; - SWIG_check_num_args("ofVbo::setIndexBuffer",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::setIndexBuffer",1,"ofVbo *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVbo::setIndexBuffer",2,"ofBufferObject &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_setIndexBuffer",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBufferObject,0))){ - SWIG_fail_ptr("Vbo_setIndexBuffer",2,SWIGTYPE_p_ofBufferObject); } (arg1)->setIndexBuffer(*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_setAttributeBuffer__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; int arg2 ; - ofBufferObject *arg3 = 0 ; int arg4 ; int arg5 ; int arg6 ; SWIG_check_num_args("ofVbo::setAttributeBuffer",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::setAttributeBuffer",1,"ofVbo *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVbo::setAttributeBuffer",2,"int"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofVbo::setAttributeBuffer",3,"ofBufferObject &"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVbo::setAttributeBuffer",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofVbo::setAttributeBuffer",5,"int"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofVbo::setAttributeBuffer",6,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_setAttributeBuffer",1,SWIGTYPE_p_ofVbo); } arg2 = (int)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofBufferObject,0))){ - SWIG_fail_ptr("Vbo_setAttributeBuffer",3,SWIGTYPE_p_ofBufferObject); } arg4 = (int)lua_tonumber(L, 4); - arg5 = (int)lua_tonumber(L, 5); arg6 = (int)lua_tonumber(L, 6); (arg1)->setAttributeBuffer(arg2,*arg3,arg4,arg5,arg6); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_setAttributeBuffer__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; int arg2 ; - ofBufferObject *arg3 = 0 ; int arg4 ; int arg5 ; SWIG_check_num_args("ofVbo::setAttributeBuffer",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::setAttributeBuffer",1,"ofVbo *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVbo::setAttributeBuffer",2,"int"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofVbo::setAttributeBuffer",3,"ofBufferObject &"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVbo::setAttributeBuffer",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofVbo::setAttributeBuffer",5,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_setAttributeBuffer",1,SWIGTYPE_p_ofVbo); } arg2 = (int)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofBufferObject,0))){ - SWIG_fail_ptr("Vbo_setAttributeBuffer",3,SWIGTYPE_p_ofBufferObject); } arg4 = (int)lua_tonumber(L, 4); - arg5 = (int)lua_tonumber(L, 5); (arg1)->setAttributeBuffer(arg2,*arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_setAttributeBuffer(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofBufferObject, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_Vbo_setAttributeBuffer__SWIG_1(L);} } } } } } - if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofBufferObject, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { - return _wrap_Vbo_setAttributeBuffer__SWIG_0(L);} } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_setAttributeBuffer'\n" - " Possible C/C++ prototypes are:\n" " ofVbo::setAttributeBuffer(int,ofBufferObject &,int,int,int)\n" - " ofVbo::setAttributeBuffer(int,ofBufferObject &,int,int)\n"); lua_error(L);return 0; } -static int _wrap_Vbo_getVertexBuffer__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - ofBufferObject *result = 0 ; SWIG_check_num_args("ofVbo::getVertexBuffer",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::getVertexBuffer",1,"ofVbo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_getVertexBuffer",1,SWIGTYPE_p_ofVbo); } result = (ofBufferObject *) &(arg1)->getVertexBuffer(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofBufferObject,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vbo_getColorBuffer__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - ofBufferObject *result = 0 ; SWIG_check_num_args("ofVbo::getColorBuffer",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::getColorBuffer",1,"ofVbo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_getColorBuffer",1,SWIGTYPE_p_ofVbo); } result = (ofBufferObject *) &(arg1)->getColorBuffer(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofBufferObject,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vbo_getNormalBuffer__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - ofBufferObject *result = 0 ; SWIG_check_num_args("ofVbo::getNormalBuffer",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::getNormalBuffer",1,"ofVbo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_getNormalBuffer",1,SWIGTYPE_p_ofVbo); } result = (ofBufferObject *) &(arg1)->getNormalBuffer(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofBufferObject,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vbo_getTexCoordBuffer__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - ofBufferObject *result = 0 ; SWIG_check_num_args("ofVbo::getTexCoordBuffer",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::getTexCoordBuffer",1,"ofVbo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_getTexCoordBuffer",1,SWIGTYPE_p_ofVbo); } result = (ofBufferObject *) &(arg1)->getTexCoordBuffer(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofBufferObject,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vbo_getIndexBuffer__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - ofBufferObject *result = 0 ; SWIG_check_num_args("ofVbo::getIndexBuffer",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::getIndexBuffer",1,"ofVbo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_getIndexBuffer",1,SWIGTYPE_p_ofVbo); } result = (ofBufferObject *) &(arg1)->getIndexBuffer(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofBufferObject,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vbo_getAttributeBuffer__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; int arg2 ; - ofBufferObject *result = 0 ; SWIG_check_num_args("ofVbo::getAttributeBuffer",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::getAttributeBuffer",1,"ofVbo *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVbo::getAttributeBuffer",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_getAttributeBuffer",1,SWIGTYPE_p_ofVbo); } arg2 = (int)lua_tonumber(L, 2); - result = (ofBufferObject *) &(arg1)->getAttributeBuffer(arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofBufferObject,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vbo_getVertexBuffer__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - ofBufferObject *result = 0 ; SWIG_check_num_args("ofVbo::getVertexBuffer",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::getVertexBuffer",1,"ofVbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_getVertexBuffer",1,SWIGTYPE_p_ofVbo); } - result = (ofBufferObject *) &((ofVbo const *)arg1)->getVertexBuffer(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofBufferObject,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vbo_getVertexBuffer(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Vbo_getVertexBuffer__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vbo_getVertexBuffer__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_getVertexBuffer'\n" - " Possible C/C++ prototypes are:\n" " ofVbo::getVertexBuffer()\n" " ofVbo::getVertexBuffer() const\n"); - lua_error(L);return 0; } -static int _wrap_Vbo_getColorBuffer__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - ofBufferObject *result = 0 ; SWIG_check_num_args("ofVbo::getColorBuffer",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::getColorBuffer",1,"ofVbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_getColorBuffer",1,SWIGTYPE_p_ofVbo); } - result = (ofBufferObject *) &((ofVbo const *)arg1)->getColorBuffer(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofBufferObject,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vbo_getColorBuffer(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Vbo_getColorBuffer__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vbo_getColorBuffer__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_getColorBuffer'\n" " Possible C/C++ prototypes are:\n" - " ofVbo::getColorBuffer()\n" " ofVbo::getColorBuffer() const\n"); lua_error(L);return 0; } -static int _wrap_Vbo_getNormalBuffer__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - ofBufferObject *result = 0 ; SWIG_check_num_args("ofVbo::getNormalBuffer",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::getNormalBuffer",1,"ofVbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_getNormalBuffer",1,SWIGTYPE_p_ofVbo); } - result = (ofBufferObject *) &((ofVbo const *)arg1)->getNormalBuffer(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofBufferObject,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vbo_getNormalBuffer(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Vbo_getNormalBuffer__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vbo_getNormalBuffer__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_getNormalBuffer'\n" - " Possible C/C++ prototypes are:\n" " ofVbo::getNormalBuffer()\n" " ofVbo::getNormalBuffer() const\n"); - lua_error(L);return 0; } -static int _wrap_Vbo_getTexCoordBuffer__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - ofBufferObject *result = 0 ; SWIG_check_num_args("ofVbo::getTexCoordBuffer",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::getTexCoordBuffer",1,"ofVbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_getTexCoordBuffer",1,SWIGTYPE_p_ofVbo); } - result = (ofBufferObject *) &((ofVbo const *)arg1)->getTexCoordBuffer(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofBufferObject,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vbo_getTexCoordBuffer(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Vbo_getTexCoordBuffer__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vbo_getTexCoordBuffer__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_getTexCoordBuffer'\n" - " Possible C/C++ prototypes are:\n" " ofVbo::getTexCoordBuffer()\n" " ofVbo::getTexCoordBuffer() const\n"); - lua_error(L);return 0; } -static int _wrap_Vbo_getIndexBuffer__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - ofBufferObject *result = 0 ; SWIG_check_num_args("ofVbo::getIndexBuffer",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::getIndexBuffer",1,"ofVbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_getIndexBuffer",1,SWIGTYPE_p_ofVbo); } - result = (ofBufferObject *) &((ofVbo const *)arg1)->getIndexBuffer(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofBufferObject,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vbo_getIndexBuffer(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Vbo_getIndexBuffer__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Vbo_getIndexBuffer__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_getIndexBuffer'\n" " Possible C/C++ prototypes are:\n" - " ofVbo::getIndexBuffer()\n" " ofVbo::getIndexBuffer() const\n"); lua_error(L);return 0; } -static int _wrap_Vbo_getAttributeBuffer__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; int arg2 ; - ofBufferObject *result = 0 ; SWIG_check_num_args("ofVbo::getAttributeBuffer",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::getAttributeBuffer",1,"ofVbo const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVbo::getAttributeBuffer",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_getAttributeBuffer",1,SWIGTYPE_p_ofVbo); } arg2 = (int)lua_tonumber(L, 2); - result = (ofBufferObject *) &((ofVbo const *)arg1)->getAttributeBuffer(arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofBufferObject,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vbo_getAttributeBuffer(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Vbo_getAttributeBuffer__SWIG_0(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Vbo_getAttributeBuffer__SWIG_1(L);} } - } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_getAttributeBuffer'\n" - " Possible C/C++ prototypes are:\n" " ofVbo::getAttributeBuffer(int)\n" " ofVbo::getAttributeBuffer(int) const\n"); - lua_error(L);return 0; } -static int _wrap_Vbo_updateMesh(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; ofMesh *arg2 = 0 ; - SWIG_check_num_args("ofVbo::updateMesh",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::updateMesh",1,"ofVbo *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVbo::updateMesh",2,"ofMesh const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ SWIG_fail_ptr("Vbo_updateMesh",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("Vbo_updateMesh",2,SWIGTYPE_p_ofMesh); } - (arg1)->updateMesh((ofMesh const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_updateVertexData__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - ofVec3f *arg2 = (ofVec3f *) 0 ; int arg3 ; SWIG_check_num_args("ofVbo::updateVertexData",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::updateVertexData",1,"ofVbo *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofVbo::updateVertexData",2,"ofVec3f const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::updateVertexData",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_updateVertexData",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vbo_updateVertexData",2,SWIGTYPE_p_ofVec3f); } arg3 = (int)lua_tonumber(L, 3); - (arg1)->updateVertexData((ofVec3f const *)arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_updateVertexData__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - ofVec2f *arg2 = (ofVec2f *) 0 ; int arg3 ; SWIG_check_num_args("ofVbo::updateVertexData",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::updateVertexData",1,"ofVbo *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofVbo::updateVertexData",2,"ofVec2f const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::updateVertexData",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_updateVertexData",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vbo_updateVertexData",2,SWIGTYPE_p_ofVec2f); } arg3 = (int)lua_tonumber(L, 3); - (arg1)->updateVertexData((ofVec2f const *)arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_updateColorData__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - ofFloatColor *arg2 = (ofFloatColor *) 0 ; int arg3 ; SWIG_check_num_args("ofVbo::updateColorData",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::updateColorData",1,"ofVbo *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofVbo::updateColorData",2,"ofFloatColor const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::updateColorData",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_updateColorData",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("Vbo_updateColorData",2,SWIGTYPE_p_ofColor_T_float_t); } arg3 = (int)lua_tonumber(L, 3); - (arg1)->updateColorData((ofFloatColor const *)arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vbo_updateNormalData__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - ofVec3f *arg2 = (ofVec3f *) 0 ; int arg3 ; SWIG_check_num_args("ofVbo::updateNormalData",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::updateNormalData",1,"ofVbo *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofVbo::updateNormalData",2,"ofVec3f const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::updateNormalData",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_updateNormalData",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Vbo_updateNormalData",2,SWIGTYPE_p_ofVec3f); } arg3 = (int)lua_tonumber(L, 3); - (arg1)->updateNormalData((ofVec3f const *)arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_updateTexCoordData__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - ofVec2f *arg2 = (ofVec2f *) 0 ; int arg3 ; SWIG_check_num_args("ofVbo::updateTexCoordData",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::updateTexCoordData",1,"ofVbo *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofVbo::updateTexCoordData",2,"ofVec2f const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::updateTexCoordData",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_updateTexCoordData",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec2f,0))){ - SWIG_fail_ptr("Vbo_updateTexCoordData",2,SWIGTYPE_p_ofVec2f); } arg3 = (int)lua_tonumber(L, 3); - (arg1)->updateTexCoordData((ofVec2f const *)arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vbo_updateIndexData(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - ofIndexType *arg2 = (ofIndexType *) 0 ; int arg3 ; SWIG_check_num_args("ofVbo::updateIndexData",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::updateIndexData",1,"ofVbo *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofVbo::updateIndexData",2,"ofIndexType const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::updateIndexData",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_updateIndexData",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_unsigned_short,0))){ - SWIG_fail_ptr("Vbo_updateIndexData",2,SWIGTYPE_p_unsigned_short); } arg3 = (int)lua_tonumber(L, 3); - (arg1)->updateIndexData((ofIndexType const *)arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vbo_updateVertexData__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - float *arg2 = (float *) 0 ; int arg3 ; SWIG_check_num_args("ofVbo::updateVertexData",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::updateVertexData",1,"ofVbo *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofVbo::updateVertexData",2,"float const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::updateVertexData",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_updateVertexData",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Vbo_updateVertexData",2,SWIGTYPE_p_float); } arg3 = (int)lua_tonumber(L, 3); - (arg1)->updateVertexData((float const *)arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_updateVertexData(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Vbo_updateVertexData__SWIG_0(L);} } } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Vbo_updateVertexData__SWIG_1(L);} } } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Vbo_updateVertexData__SWIG_2(L);} } - } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_updateVertexData'\n" - " Possible C/C++ prototypes are:\n" " ofVbo::updateVertexData(ofVec3f const *,int)\n" - " ofVbo::updateVertexData(ofVec2f const *,int)\n" " ofVbo::updateVertexData(float const *,int)\n"); - lua_error(L);return 0; } -static int _wrap_Vbo_updateColorData__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - float *arg2 = (float *) 0 ; int arg3 ; SWIG_check_num_args("ofVbo::updateColorData",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::updateColorData",1,"ofVbo *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofVbo::updateColorData",2,"float const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::updateColorData",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_updateColorData",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Vbo_updateColorData",2,SWIGTYPE_p_float); } arg3 = (int)lua_tonumber(L, 3); - (arg1)->updateColorData((float const *)arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_updateColorData(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Vbo_updateColorData__SWIG_0(L);} } } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Vbo_updateColorData__SWIG_1(L);} } - } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_updateColorData'\n" - " Possible C/C++ prototypes are:\n" " ofVbo::updateColorData(ofFloatColor const *,int)\n" - " ofVbo::updateColorData(float const *,int)\n"); lua_error(L);return 0; } -static int _wrap_Vbo_updateNormalData__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - float *arg2 = (float *) 0 ; int arg3 ; SWIG_check_num_args("ofVbo::updateNormalData",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::updateNormalData",1,"ofVbo *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofVbo::updateNormalData",2,"float const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::updateNormalData",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_updateNormalData",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Vbo_updateNormalData",2,SWIGTYPE_p_float); } arg3 = (int)lua_tonumber(L, 3); - (arg1)->updateNormalData((float const *)arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_updateNormalData(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Vbo_updateNormalData__SWIG_0(L);} } } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Vbo_updateNormalData__SWIG_1(L);} } - } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_updateNormalData'\n" - " Possible C/C++ prototypes are:\n" " ofVbo::updateNormalData(ofVec3f const *,int)\n" - " ofVbo::updateNormalData(float const *,int)\n"); lua_error(L);return 0; } -static int _wrap_Vbo_updateTexCoordData__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - float *arg2 = (float *) 0 ; int arg3 ; SWIG_check_num_args("ofVbo::updateTexCoordData",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::updateTexCoordData",1,"ofVbo *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofVbo::updateTexCoordData",2,"float const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::updateTexCoordData",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_updateTexCoordData",1,SWIGTYPE_p_ofVbo); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Vbo_updateTexCoordData",2,SWIGTYPE_p_float); } arg3 = (int)lua_tonumber(L, 3); - (arg1)->updateTexCoordData((float const *)arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_updateTexCoordData(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec2f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Vbo_updateTexCoordData__SWIG_0(L);} } } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Vbo_updateTexCoordData__SWIG_1(L);} - } } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_updateTexCoordData'\n" - " Possible C/C++ prototypes are:\n" " ofVbo::updateTexCoordData(ofVec2f const *,int)\n" - " ofVbo::updateTexCoordData(float const *,int)\n"); lua_error(L);return 0; } -static int _wrap_Vbo_updateAttributeData(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; int arg2 ; - float *arg3 = (float *) 0 ; int arg4 ; SWIG_check_num_args("ofVbo::updateAttributeData",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::updateAttributeData",1,"ofVbo *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVbo::updateAttributeData",2,"int"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofVbo::updateAttributeData",3,"float const *"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVbo::updateAttributeData",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_updateAttributeData",1,SWIGTYPE_p_ofVbo); } arg2 = (int)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("Vbo_updateAttributeData",3,SWIGTYPE_p_float); } arg4 = (int)lua_tonumber(L, 4); - (arg1)->updateAttributeData(arg2,(float const *)arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Vbo_enableColors(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - SWIG_check_num_args("ofVbo::enableColors",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::enableColors",1,"ofVbo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ SWIG_fail_ptr("Vbo_enableColors",1,SWIGTYPE_p_ofVbo); } - (arg1)->enableColors(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_enableNormals(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - SWIG_check_num_args("ofVbo::enableNormals",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::enableNormals",1,"ofVbo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_enableNormals",1,SWIGTYPE_p_ofVbo); } (arg1)->enableNormals(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_enableTexCoords(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - SWIG_check_num_args("ofVbo::enableTexCoords",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::enableTexCoords",1,"ofVbo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_enableTexCoords",1,SWIGTYPE_p_ofVbo); } (arg1)->enableTexCoords(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_enableIndices(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - SWIG_check_num_args("ofVbo::enableIndices",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::enableIndices",1,"ofVbo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_enableIndices",1,SWIGTYPE_p_ofVbo); } (arg1)->enableIndices(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_disableColors(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - SWIG_check_num_args("ofVbo::disableColors",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::disableColors",1,"ofVbo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_disableColors",1,SWIGTYPE_p_ofVbo); } (arg1)->disableColors(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_disableNormals(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - SWIG_check_num_args("ofVbo::disableNormals",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::disableNormals",1,"ofVbo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_disableNormals",1,SWIGTYPE_p_ofVbo); } (arg1)->disableNormals(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_disableTexCoords(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - SWIG_check_num_args("ofVbo::disableTexCoords",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::disableTexCoords",1,"ofVbo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_disableTexCoords",1,SWIGTYPE_p_ofVbo); } (arg1)->disableTexCoords(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_disableIndices(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - SWIG_check_num_args("ofVbo::disableIndices",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::disableIndices",1,"ofVbo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_disableIndices",1,SWIGTYPE_p_ofVbo); } (arg1)->disableIndices(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_getVaoId(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; GLuint result; - SWIG_check_num_args("ofVbo::getVaoId",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::getVaoId",1,"ofVbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ SWIG_fail_ptr("Vbo_getVaoId",1,SWIGTYPE_p_ofVbo); } - result = (GLuint)((ofVbo const *)arg1)->getVaoId(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_getVertId(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; GLuint result; - SWIG_check_num_args("ofVbo::getVertId",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::getVertId",1,"ofVbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ SWIG_fail_ptr("Vbo_getVertId",1,SWIGTYPE_p_ofVbo); } - result = (GLuint)((ofVbo const *)arg1)->getVertId(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_getColorId(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; GLuint result; - SWIG_check_num_args("ofVbo::getColorId",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::getColorId",1,"ofVbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ SWIG_fail_ptr("Vbo_getColorId",1,SWIGTYPE_p_ofVbo); } - result = (GLuint)((ofVbo const *)arg1)->getColorId(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_getNormalId(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; GLuint result; - SWIG_check_num_args("ofVbo::getNormalId",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::getNormalId",1,"ofVbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ SWIG_fail_ptr("Vbo_getNormalId",1,SWIGTYPE_p_ofVbo); } - result = (GLuint)((ofVbo const *)arg1)->getNormalId(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_getTexCoordId(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; GLuint result; - SWIG_check_num_args("ofVbo::getTexCoordId",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::getTexCoordId",1,"ofVbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_getTexCoordId",1,SWIGTYPE_p_ofVbo); } result = (GLuint)((ofVbo const *)arg1)->getTexCoordId(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_getIndexId(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; GLuint result; - SWIG_check_num_args("ofVbo::getIndexId",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::getIndexId",1,"ofVbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ SWIG_fail_ptr("Vbo_getIndexId",1,SWIGTYPE_p_ofVbo); } - result = (GLuint)((ofVbo const *)arg1)->getIndexId(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_getAttributeId(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; int arg2 ; GLuint result; - SWIG_check_num_args("ofVbo::getAttributeId",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::getAttributeId",1,"ofVbo const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVbo::getAttributeId",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_getAttributeId",1,SWIGTYPE_p_ofVbo); } arg2 = (int)lua_tonumber(L, 2); - result = (GLuint)((ofVbo const *)arg1)->getAttributeId(arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_getIsAllocated(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; bool result; - SWIG_check_num_args("ofVbo::getIsAllocated",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::getIsAllocated",1,"ofVbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_getIsAllocated",1,SWIGTYPE_p_ofVbo); } result = (bool)((ofVbo const *)arg1)->getIsAllocated(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_getUsingVerts(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; bool result; - SWIG_check_num_args("ofVbo::getUsingVerts",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::getUsingVerts",1,"ofVbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_getUsingVerts",1,SWIGTYPE_p_ofVbo); } result = (bool)((ofVbo const *)arg1)->getUsingVerts(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_getUsingColors(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; bool result; - SWIG_check_num_args("ofVbo::getUsingColors",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::getUsingColors",1,"ofVbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_getUsingColors",1,SWIGTYPE_p_ofVbo); } result = (bool)((ofVbo const *)arg1)->getUsingColors(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_getUsingNormals(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; bool result; - SWIG_check_num_args("ofVbo::getUsingNormals",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::getUsingNormals",1,"ofVbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_getUsingNormals",1,SWIGTYPE_p_ofVbo); } result = (bool)((ofVbo const *)arg1)->getUsingNormals(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_getUsingTexCoords(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; bool result; - SWIG_check_num_args("ofVbo::getUsingTexCoords",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::getUsingTexCoords",1,"ofVbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_getUsingTexCoords",1,SWIGTYPE_p_ofVbo); } result = (bool)((ofVbo const *)arg1)->getUsingTexCoords(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_getUsingIndices(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; bool result; - SWIG_check_num_args("ofVbo::getUsingIndices",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::getUsingIndices",1,"ofVbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_getUsingIndices",1,SWIGTYPE_p_ofVbo); } result = (bool)((ofVbo const *)arg1)->getUsingIndices(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_draw(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; int arg2 ; int arg3 ; int arg4 ; - SWIG_check_num_args("ofVbo::draw",4,4) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::draw",1,"ofVbo const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVbo::draw",2,"int"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::draw",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVbo::draw",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ SWIG_fail_ptr("Vbo_draw",1,SWIGTYPE_p_ofVbo); } - arg2 = (int)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - ((ofVbo const *)arg1)->draw(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_drawElements__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; int arg2 ; int arg3 ; - int arg4 ; SWIG_check_num_args("ofVbo::drawElements",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::drawElements",1,"ofVbo const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVbo::drawElements",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::drawElements",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVbo::drawElements",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ SWIG_fail_ptr("Vbo_drawElements",1,SWIGTYPE_p_ofVbo); } - arg2 = (int)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - ((ofVbo const *)arg1)->drawElements(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_drawElements__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; int arg2 ; int arg3 ; - SWIG_check_num_args("ofVbo::drawElements",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::drawElements",1,"ofVbo const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVbo::drawElements",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::drawElements",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ SWIG_fail_ptr("Vbo_drawElements",1,SWIGTYPE_p_ofVbo); } - arg2 = (int)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); ((ofVbo const *)arg1)->drawElements(arg2,arg3); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_drawElements(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_Vbo_drawElements__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Vbo_drawElements__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Vbo_drawElements'\n" " Possible C/C++ prototypes are:\n" - " ofVbo::drawElements(int,int,int) const\n" " ofVbo::drawElements(int,int) const\n"); lua_error(L);return 0; } -static int _wrap_Vbo_drawInstanced(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; int arg2 ; int arg3 ; - int arg4 ; int arg5 ; SWIG_check_num_args("ofVbo::drawInstanced",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::drawInstanced",1,"ofVbo const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVbo::drawInstanced",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::drawInstanced",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVbo::drawInstanced",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofVbo::drawInstanced",5,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_drawInstanced",1,SWIGTYPE_p_ofVbo); } arg2 = (int)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); ((ofVbo const *)arg1)->drawInstanced(arg2,arg3,arg4,arg5); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_drawElementsInstanced(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; int arg2 ; int arg3 ; - int arg4 ; SWIG_check_num_args("ofVbo::drawElementsInstanced",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::drawElementsInstanced",1,"ofVbo const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVbo::drawElementsInstanced",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVbo::drawElementsInstanced",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVbo::drawElementsInstanced",4,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_drawElementsInstanced",1,SWIGTYPE_p_ofVbo); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); ((ofVbo const *)arg1)->drawElementsInstanced(arg2,arg3,arg4); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_bind(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; SWIG_check_num_args("ofVbo::bind",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::bind",1,"ofVbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ SWIG_fail_ptr("Vbo_bind",1,SWIGTYPE_p_ofVbo); } - ((ofVbo const *)arg1)->bind(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_unbind(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - SWIG_check_num_args("ofVbo::unbind",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::unbind",1,"ofVbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ SWIG_fail_ptr("Vbo_unbind",1,SWIGTYPE_p_ofVbo); } - ((ofVbo const *)arg1)->unbind(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_clear(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; SWIG_check_num_args("ofVbo::clear",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::clear",1,"ofVbo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ SWIG_fail_ptr("Vbo_clear",1,SWIGTYPE_p_ofVbo); } - (arg1)->clear(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_clearVertices(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - SWIG_check_num_args("ofVbo::clearVertices",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::clearVertices",1,"ofVbo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_clearVertices",1,SWIGTYPE_p_ofVbo); } (arg1)->clearVertices(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_clearNormals(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - SWIG_check_num_args("ofVbo::clearNormals",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::clearNormals",1,"ofVbo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ SWIG_fail_ptr("Vbo_clearNormals",1,SWIGTYPE_p_ofVbo); } - (arg1)->clearNormals(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_clearColors(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - SWIG_check_num_args("ofVbo::clearColors",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::clearColors",1,"ofVbo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ SWIG_fail_ptr("Vbo_clearColors",1,SWIGTYPE_p_ofVbo); } - (arg1)->clearColors(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_clearTexCoords(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - SWIG_check_num_args("ofVbo::clearTexCoords",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::clearTexCoords",1,"ofVbo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_clearTexCoords",1,SWIGTYPE_p_ofVbo); } (arg1)->clearTexCoords(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_clearIndices(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; - SWIG_check_num_args("ofVbo::clearIndices",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::clearIndices",1,"ofVbo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ SWIG_fail_ptr("Vbo_clearIndices",1,SWIGTYPE_p_ofVbo); } - (arg1)->clearIndices(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_clearAttribute(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; int arg2 ; - SWIG_check_num_args("ofVbo::clearAttribute",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::clearAttribute",1,"ofVbo *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVbo::clearAttribute",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_clearAttribute",1,SWIGTYPE_p_ofVbo); } arg2 = (int)lua_tonumber(L, 2); (arg1)->clearAttribute(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_getNumVertices(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; int result; - SWIG_check_num_args("ofVbo::getNumVertices",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::getNumVertices",1,"ofVbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_getNumVertices",1,SWIGTYPE_p_ofVbo); } result = (int)((ofVbo const *)arg1)->getNumVertices(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_getNumIndices(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; int result; - SWIG_check_num_args("ofVbo::getNumIndices",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::getNumIndices",1,"ofVbo const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ - SWIG_fail_ptr("Vbo_getNumIndices",1,SWIGTYPE_p_ofVbo); } result = (int)((ofVbo const *)arg1)->getNumIndices(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Vbo_hasAttribute(lua_State* L) { int SWIG_arg = 0; ofVbo *arg1 = (ofVbo *) 0 ; int arg2 ; bool result; - SWIG_check_num_args("ofVbo::hasAttribute",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVbo::hasAttribute",1,"ofVbo const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVbo::hasAttribute",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVbo,0))){ SWIG_fail_ptr("Vbo_hasAttribute",1,SWIGTYPE_p_ofVbo); } - arg2 = (int)lua_tonumber(L, 2); result = (bool)((ofVbo const *)arg1)->hasAttribute(arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_Vbo(void *obj) { -ofVbo *arg1 = (ofVbo *) obj; -delete arg1; -} -static int _proxy__wrap_new_Vbo(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_Vbo); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_Vbo_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_Vbo_methods[]= { - { "setMesh", _wrap_Vbo_setMesh}, - { "setIndexData", _wrap_Vbo_setIndexData}, - { "setVertexData", _wrap_Vbo_setVertexData}, - { "setColorData", _wrap_Vbo_setColorData}, - { "setNormalData", _wrap_Vbo_setNormalData}, - { "setTexCoordData", _wrap_Vbo_setTexCoordData}, - { "setAttributeData", _wrap_Vbo_setAttributeData}, - { "setVertexBuffer", _wrap_Vbo_setVertexBuffer}, - { "setColorBuffer", _wrap_Vbo_setColorBuffer}, - { "setNormalBuffer", _wrap_Vbo_setNormalBuffer}, - { "setTexCoordBuffer", _wrap_Vbo_setTexCoordBuffer}, - { "setIndexBuffer", _wrap_Vbo_setIndexBuffer}, - { "setAttributeBuffer", _wrap_Vbo_setAttributeBuffer}, - { "getVertexBuffer", _wrap_Vbo_getVertexBuffer}, - { "getColorBuffer", _wrap_Vbo_getColorBuffer}, - { "getNormalBuffer", _wrap_Vbo_getNormalBuffer}, - { "getTexCoordBuffer", _wrap_Vbo_getTexCoordBuffer}, - { "getIndexBuffer", _wrap_Vbo_getIndexBuffer}, - { "getAttributeBuffer", _wrap_Vbo_getAttributeBuffer}, - { "updateMesh", _wrap_Vbo_updateMesh}, - { "updateIndexData", _wrap_Vbo_updateIndexData}, - { "updateVertexData", _wrap_Vbo_updateVertexData}, - { "updateColorData", _wrap_Vbo_updateColorData}, - { "updateNormalData", _wrap_Vbo_updateNormalData}, - { "updateTexCoordData", _wrap_Vbo_updateTexCoordData}, - { "updateAttributeData", _wrap_Vbo_updateAttributeData}, - { "enableColors", _wrap_Vbo_enableColors}, - { "enableNormals", _wrap_Vbo_enableNormals}, - { "enableTexCoords", _wrap_Vbo_enableTexCoords}, - { "enableIndices", _wrap_Vbo_enableIndices}, - { "disableColors", _wrap_Vbo_disableColors}, - { "disableNormals", _wrap_Vbo_disableNormals}, - { "disableTexCoords", _wrap_Vbo_disableTexCoords}, - { "disableIndices", _wrap_Vbo_disableIndices}, - { "getVaoId", _wrap_Vbo_getVaoId}, - { "getVertId", _wrap_Vbo_getVertId}, - { "getColorId", _wrap_Vbo_getColorId}, - { "getNormalId", _wrap_Vbo_getNormalId}, - { "getTexCoordId", _wrap_Vbo_getTexCoordId}, - { "getIndexId", _wrap_Vbo_getIndexId}, - { "getAttributeId", _wrap_Vbo_getAttributeId}, - { "getIsAllocated", _wrap_Vbo_getIsAllocated}, - { "getUsingVerts", _wrap_Vbo_getUsingVerts}, - { "getUsingColors", _wrap_Vbo_getUsingColors}, - { "getUsingNormals", _wrap_Vbo_getUsingNormals}, - { "getUsingTexCoords", _wrap_Vbo_getUsingTexCoords}, - { "getUsingIndices", _wrap_Vbo_getUsingIndices}, - { "draw", _wrap_Vbo_draw}, - { "drawElements", _wrap_Vbo_drawElements}, - { "drawInstanced", _wrap_Vbo_drawInstanced}, - { "drawElementsInstanced", _wrap_Vbo_drawElementsInstanced}, - { "bind", _wrap_Vbo_bind}, - { "unbind", _wrap_Vbo_unbind}, - { "clear", _wrap_Vbo_clear}, - { "clearVertices", _wrap_Vbo_clearVertices}, - { "clearNormals", _wrap_Vbo_clearNormals}, - { "clearColors", _wrap_Vbo_clearColors}, - { "clearTexCoords", _wrap_Vbo_clearTexCoords}, - { "clearIndices", _wrap_Vbo_clearIndices}, - { "clearAttribute", _wrap_Vbo_clearAttribute}, - { "getNumVertices", _wrap_Vbo_getNumVertices}, - { "getNumIndices", _wrap_Vbo_getNumIndices}, - { "hasAttribute", _wrap_Vbo_hasAttribute}, - {0,0} -}; -static swig_lua_method swig_Vbo_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_Vbo_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_Vbo_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_Vbo_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_Vbo_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_Vbo_Sf_SwigStatic = { - "Vbo", - swig_Vbo_Sf_SwigStatic_methods, - swig_Vbo_Sf_SwigStatic_attributes, - swig_Vbo_Sf_SwigStatic_constants, - swig_Vbo_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_Vbo_bases[] = {0}; -static const char *swig_Vbo_base_names[] = {0}; -static swig_lua_class _wrap_class_Vbo = { "Vbo", "Vbo", &SWIGTYPE_p_ofVbo,_proxy__wrap_new_Vbo, swig_delete_Vbo, swig_Vbo_methods, swig_Vbo_attributes, &swig_Vbo_Sf_SwigStatic, swig_Vbo_meta, swig_Vbo_bases, swig_Vbo_base_names }; - -static int _wrap_VboMesh_draw__SWIG_0_0(lua_State* L) { int SWIG_arg = 0; ofVboMesh *arg1 = (ofVboMesh *) 0 ; - SWIG_check_num_args("draw",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("draw",1,"ofVboMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVboMesh,0))){ - SWIG_fail_ptr("VboMesh_draw",1,SWIGTYPE_p_ofVboMesh); } ((ofVboMesh const *)arg1)->draw(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_new_VboMesh__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVboMesh *result = 0 ; - SWIG_check_num_args("ofVboMesh::ofVboMesh",0,0) result = (ofVboMesh *)new ofVboMesh(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVboMesh,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_VboMesh__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMesh *arg1 = 0 ; ofVboMesh *result = 0 ; - SWIG_check_num_args("ofVboMesh::ofVboMesh",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofVboMesh::ofVboMesh",1,"ofMesh const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMesh,0))){ SWIG_fail_ptr("new_VboMesh",1,SWIGTYPE_p_ofMesh); } - result = (ofVboMesh *)new ofVboMesh((ofMesh const &)*arg1); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVboMesh,1); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_new_VboMesh(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_VboMesh__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMesh, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_new_VboMesh__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_VboMesh'\n" " Possible C/C++ prototypes are:\n" - " ofVboMesh::ofVboMesh()\n" " ofVboMesh::ofVboMesh(ofMesh const &)\n"); lua_error(L);return 0; } -static int _wrap_VboMesh_setUsage(lua_State* L) { int SWIG_arg = 0; ofVboMesh *arg1 = (ofVboMesh *) 0 ; int arg2 ; - SWIG_check_num_args("ofVboMesh::setUsage",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVboMesh::setUsage",1,"ofVboMesh *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVboMesh::setUsage",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVboMesh,0))){ - SWIG_fail_ptr("VboMesh_setUsage",1,SWIGTYPE_p_ofVboMesh); } arg2 = (int)lua_tonumber(L, 2); (arg1)->setUsage(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VboMesh_draw__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVboMesh *arg1 = (ofVboMesh *) 0 ; - ofPolyRenderMode arg2 ; SWIG_check_num_args("ofVboMesh::draw",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVboMesh::draw",1,"ofVboMesh const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVboMesh::draw",2,"ofPolyRenderMode"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVboMesh,0))){ - SWIG_fail_ptr("VboMesh_draw",1,SWIGTYPE_p_ofVboMesh); } arg2 = (ofPolyRenderMode)(int)lua_tonumber(L, 2); - ((ofVboMesh const *)arg1)->draw(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VboMesh_draw(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVboMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_VboMesh_draw__SWIG_0_0(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVboMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_VboMesh_draw__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'VboMesh_draw'\n" " Possible C/C++ prototypes are:\n" - " draw() const\n" " ofVboMesh::draw(ofPolyRenderMode) const\n"); lua_error(L);return 0; } -static int _wrap_VboMesh_drawInstanced(lua_State* L) { int SWIG_arg = 0; ofVboMesh *arg1 = (ofVboMesh *) 0 ; - ofPolyRenderMode arg2 ; int arg3 ; SWIG_check_num_args("ofVboMesh::drawInstanced",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVboMesh::drawInstanced",1,"ofVboMesh const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVboMesh::drawInstanced",2,"ofPolyRenderMode"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVboMesh::drawInstanced",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVboMesh,0))){ - SWIG_fail_ptr("VboMesh_drawInstanced",1,SWIGTYPE_p_ofVboMesh); } arg2 = (ofPolyRenderMode)(int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); ((ofVboMesh const *)arg1)->drawInstanced(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_VboMesh_getVbo__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVboMesh *arg1 = (ofVboMesh *) 0 ; - ofVbo *result = 0 ; SWIG_check_num_args("ofVboMesh::getVbo",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVboMesh::getVbo",1,"ofVboMesh *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVboMesh,0))){ - SWIG_fail_ptr("VboMesh_getVbo",1,SWIGTYPE_p_ofVboMesh); } result = (ofVbo *) &(arg1)->getVbo(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVbo,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_VboMesh_getVbo__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVboMesh *arg1 = (ofVboMesh *) 0 ; - ofVbo *result = 0 ; SWIG_check_num_args("ofVboMesh::getVbo",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVboMesh::getVbo",1,"ofVboMesh const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVboMesh,0))){ - SWIG_fail_ptr("VboMesh_getVbo",1,SWIGTYPE_p_ofVboMesh); } result = (ofVbo *) &((ofVboMesh const *)arg1)->getVbo(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVbo,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_VboMesh_getVbo(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVboMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_VboMesh_getVbo__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVboMesh, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_VboMesh_getVbo__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'VboMesh_getVbo'\n" " Possible C/C++ prototypes are:\n" - " ofVboMesh::getVbo()\n" " ofVboMesh::getVbo() const\n"); lua_error(L);return 0; } -static void swig_delete_VboMesh(void *obj) { -ofVboMesh *arg1 = (ofVboMesh *) obj; -delete arg1; -} -static int _proxy__wrap_new_VboMesh(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_VboMesh); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_VboMesh_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_VboMesh_methods[]= { - { "setUsage", _wrap_VboMesh_setUsage}, - { "draw", _wrap_VboMesh_draw}, - { "drawInstanced", _wrap_VboMesh_drawInstanced}, - { "getVbo", _wrap_VboMesh_getVbo}, - {0,0} -}; -static swig_lua_method swig_VboMesh_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_VboMesh_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_VboMesh_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_VboMesh_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_VboMesh_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_VboMesh_Sf_SwigStatic = { - "VboMesh", - swig_VboMesh_Sf_SwigStatic_methods, - swig_VboMesh_Sf_SwigStatic_attributes, - swig_VboMesh_Sf_SwigStatic_constants, - swig_VboMesh_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_VboMesh_bases[] = {0,0}; -static const char *swig_VboMesh_base_names[] = {"ofMesh *",0}; -static swig_lua_class _wrap_class_VboMesh = { "VboMesh", "VboMesh", &SWIGTYPE_p_ofVboMesh,_proxy__wrap_new_VboMesh, swig_delete_VboMesh, swig_VboMesh_methods, swig_VboMesh_attributes, &swig_VboMesh_Sf_SwigStatic, swig_VboMesh_meta, swig_VboMesh_bases, swig_VboMesh_base_names }; - -static int _wrap_new_Pixels__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPixels_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofPixels_< unsigned char >::ofPixels_",0,0) - result = (ofPixels_< unsigned char > *)new ofPixels_< unsigned char >(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofPixels_T_unsigned_char_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_Pixels__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPixels_< unsigned char > *arg1 = 0 ; - ofPixels_< unsigned char > *result = 0 ; SWIG_check_num_args("ofPixels_< unsigned char >::ofPixels_",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::ofPixels_",1,"ofPixels_< unsigned char > &&"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("new_Pixels",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - result = (ofPixels_< unsigned char > *)new ofPixels_< unsigned char >((ofPixels_< unsigned char > &&)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofPixels_T_unsigned_char_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_Pixels(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_Pixels__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_new_Pixels__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_Pixels'\n" " Possible C/C++ prototypes are:\n" - " ofPixels_< unsigned char >::ofPixels_()\n" " ofPixels_< unsigned char >::ofPixels_(ofPixels_< unsigned char > &&)\n"); - lua_error(L);return 0; } -static int _wrap_Pixels_allocate(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; size_t arg2 ; size_t arg3 ; size_t arg4 ; - SWIG_check_num_args("ofPixels_< unsigned char >::allocate",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::allocate",1,"ofPixels_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::allocate",2,"size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned char >::allocate",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< unsigned char >::allocate",4,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_allocate",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (size_t)lua_tonumber(L, 4); - (arg1)->allocate(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_allocatePixelFormat(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; size_t arg2 ; size_t arg3 ; ofPixelFormat arg4 ; - SWIG_check_num_args("ofPixels_< unsigned char >::allocate",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::allocate",1,"ofPixels_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::allocate",2,"size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned char >::allocate",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< unsigned char >::allocate",4,"ofPixelFormat"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_allocatePixelFormat",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - arg4 = (ofPixelFormat)(int)lua_tonumber(L, 4); (arg1)->allocate(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_allocateImageType(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; size_t arg2 ; size_t arg3 ; ofImageType arg4 ; - SWIG_check_num_args("ofPixels_< unsigned char >::allocate",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::allocate",1,"ofPixels_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::allocate",2,"size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned char >::allocate",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< unsigned char >::allocate",4,"ofImageType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_allocateImageType",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - arg4 = (ofImageType)(int)lua_tonumber(L, 4); (arg1)->allocate(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_isAllocated(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; bool result; - SWIG_check_num_args("ofPixels_< unsigned char >::isAllocated",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::isAllocated",1,"ofPixels_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_isAllocated",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - result = (bool)((ofPixels_< unsigned char > const *)arg1)->isAllocated(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_clear(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; - SWIG_check_num_args("ofPixels_< unsigned char >::clear",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::clear",1,"ofPixels_< unsigned char > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_clear",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } (arg1)->clear(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_set__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; unsigned char arg2 ; - SWIG_check_num_args("ofPixels_< unsigned char >::set",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::set",1,"ofPixels_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::set",2,"unsigned char"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_set",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned char)lua_tonumber(L, 2); - (arg1)->set(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_set__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; size_t arg2 ; unsigned char arg3 ; - SWIG_check_num_args("ofPixels_< unsigned char >::set",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::set",1,"ofPixels_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::set",2,"size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned char >::set",3,"unsigned char"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_set",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (unsigned char)lua_tonumber(L, 3); - (arg1)->set(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_set(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Pixels_set__SWIG_0(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_Pixels_set__SWIG_1(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Pixels_set'\n" " Possible C/C++ prototypes are:\n" - " ofPixels_< unsigned char >::set(unsigned char)\n" " ofPixels_< unsigned char >::set(size_t,unsigned char)\n"); - lua_error(L);return 0; } -static int _wrap_Pixels_setFromPixels(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; unsigned char *arg2 = (unsigned char *) 0 ; - size_t arg3 ; size_t arg4 ; ofPixelFormat arg5 ; SWIG_check_num_args("ofPixels_< unsigned char >::setFromPixels",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::setFromPixels",1,"ofPixels_< unsigned char > *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::setFromPixels",2,"unsigned char const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned char >::setFromPixels",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< unsigned char >::setFromPixels",4,"size_t"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPixels_< unsigned char >::setFromPixels",5,"ofPixelFormat"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_setFromPixels",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_unsigned_char,0))){ - SWIG_fail_ptr("Pixels_setFromPixels",2,SWIGTYPE_p_unsigned_char); } - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (size_t)lua_tonumber(L, 4); - arg5 = (ofPixelFormat)(int)lua_tonumber(L, 5); (arg1)->setFromPixels((unsigned char const *)arg2,arg3,arg4,arg5); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_setFromPixelsImageType(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; unsigned char *arg2 = (unsigned char *) 0 ; - size_t arg3 ; size_t arg4 ; ofImageType arg5 ; SWIG_check_num_args("ofPixels_< unsigned char >::setFromPixels",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::setFromPixels",1,"ofPixels_< unsigned char > *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::setFromPixels",2,"unsigned char const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned char >::setFromPixels",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< unsigned char >::setFromPixels",4,"size_t"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPixels_< unsigned char >::setFromPixels",5,"ofImageType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_setFromPixelsImageType",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_unsigned_char,0))){ - SWIG_fail_ptr("Pixels_setFromPixelsImageType",2,SWIGTYPE_p_unsigned_char); } - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (size_t)lua_tonumber(L, 4); - arg5 = (ofImageType)(int)lua_tonumber(L, 5); (arg1)->setFromPixels((unsigned char const *)arg2,arg3,arg4,arg5); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_setFromExternalPixels(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; unsigned char *arg2 = (unsigned char *) 0 ; - size_t arg3 ; size_t arg4 ; ofPixelFormat arg5 ; SWIG_check_num_args("ofPixels_< unsigned char >::setFromExternalPixels",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::setFromExternalPixels",1,"ofPixels_< unsigned char > *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::setFromExternalPixels",2,"unsigned char *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned char >::setFromExternalPixels",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< unsigned char >::setFromExternalPixels",4,"size_t"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPixels_< unsigned char >::setFromExternalPixels",5,"ofPixelFormat"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_setFromExternalPixels",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_unsigned_char,0))){ - SWIG_fail_ptr("Pixels_setFromExternalPixels",2,SWIGTYPE_p_unsigned_char); } - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (size_t)lua_tonumber(L, 4); - arg5 = (ofPixelFormat)(int)lua_tonumber(L, 5); (arg1)->setFromExternalPixels(arg2,arg3,arg4,arg5); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_setFromAlignedPixels(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; unsigned char *arg2 = (unsigned char *) 0 ; - size_t arg3 ; size_t arg4 ; ofPixelFormat arg5 ; size_t arg6 ; - SWIG_check_num_args("ofPixels_< unsigned char >::setFromAlignedPixels",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::setFromAlignedPixels",1,"ofPixels_< unsigned char > *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::setFromAlignedPixels",2,"unsigned char const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned char >::setFromAlignedPixels",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< unsigned char >::setFromAlignedPixels",4,"size_t"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPixels_< unsigned char >::setFromAlignedPixels",5,"ofPixelFormat"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPixels_< unsigned char >::setFromAlignedPixels",6,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_setFromAlignedPixels",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_unsigned_char,0))){ - SWIG_fail_ptr("Pixels_setFromAlignedPixels",2,SWIGTYPE_p_unsigned_char); } - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (size_t)lua_tonumber(L, 4); - arg5 = (ofPixelFormat)(int)lua_tonumber(L, 5); SWIG_contract_assert((lua_tonumber(L,6)>=0),"number must not be negative") - arg6 = (size_t)lua_tonumber(L, 6); (arg1)->setFromAlignedPixels((unsigned char const *)arg2,arg3,arg4,arg5,arg6); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_swap(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; ofPixels_< unsigned char > *arg2 = 0 ; - SWIG_check_num_args("ofPixels_< unsigned char >::swap",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::swap",1,"ofPixels_< unsigned char > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::swap",2,"ofPixels_< unsigned char > &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_swap",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_swap",2,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } (arg1)->swap(*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_crop(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; size_t arg2 ; size_t arg3 ; size_t arg4 ; size_t arg5 ; - SWIG_check_num_args("ofPixels_< unsigned char >::crop",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::crop",1,"ofPixels_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::crop",2,"size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned char >::crop",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< unsigned char >::crop",4,"size_t"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPixels_< unsigned char >::crop",5,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_crop",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (size_t)lua_tonumber(L, 4); - SWIG_contract_assert((lua_tonumber(L,5)>=0),"number must not be negative") arg5 = (size_t)lua_tonumber(L, 5); - (arg1)->crop(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_cropTo(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; ofPixels_< unsigned char > *arg2 = 0 ; size_t arg3 ; - size_t arg4 ; size_t arg5 ; size_t arg6 ; SWIG_check_num_args("ofPixels_< unsigned char >::cropTo",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::cropTo",1,"ofPixels_< unsigned char > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::cropTo",2,"ofPixels_< unsigned char > &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned char >::cropTo",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< unsigned char >::cropTo",4,"size_t"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPixels_< unsigned char >::cropTo",5,"size_t"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPixels_< unsigned char >::cropTo",6,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_cropTo",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_cropTo",2,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (size_t)lua_tonumber(L, 4); - SWIG_contract_assert((lua_tonumber(L,5)>=0),"number must not be negative") arg5 = (size_t)lua_tonumber(L, 5); - SWIG_contract_assert((lua_tonumber(L,6)>=0),"number must not be negative") arg6 = (size_t)lua_tonumber(L, 6); - ((ofPixels_< unsigned char > const *)arg1)->cropTo(*arg2,arg3,arg4,arg5,arg6); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_rotate90(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; int arg2 ; - SWIG_check_num_args("ofPixels_< unsigned char >::rotate90",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::rotate90",1,"ofPixels_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::rotate90",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_rotate90",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->rotate90(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_rotate90To(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; ofPixels_< unsigned char > *arg2 = 0 ; int arg3 ; - SWIG_check_num_args("ofPixels_< unsigned char >::rotate90To",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::rotate90To",1,"ofPixels_< unsigned char > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::rotate90To",2,"ofPixels_< unsigned char > &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned char >::rotate90To",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_rotate90To",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_rotate90To",2,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } arg3 = (int)lua_tonumber(L, 3); - ((ofPixels_< unsigned char > const *)arg1)->rotate90To(*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Pixels_mirrorTo(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; ofPixels_< unsigned char > *arg2 = 0 ; bool arg3 ; - bool arg4 ; SWIG_check_num_args("ofPixels_< unsigned char >::mirrorTo",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::mirrorTo",1,"ofPixels_< unsigned char > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::mirrorTo",2,"ofPixels_< unsigned char > &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofPixels_< unsigned char >::mirrorTo",3,"bool"); - if(!lua_isboolean(L,4)) SWIG_fail_arg("ofPixels_< unsigned char >::mirrorTo",4,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_mirrorTo",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_mirrorTo",2,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } arg3 = (lua_toboolean(L, 3)!=0); - arg4 = (lua_toboolean(L, 4)!=0); ((ofPixels_< unsigned char > const *)arg1)->mirrorTo(*arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_mirror(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; bool arg2 ; bool arg3 ; - SWIG_check_num_args("ofPixels_< unsigned char >::mirror",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::mirror",1,"ofPixels_< unsigned char > *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::mirror",2,"bool"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofPixels_< unsigned char >::mirror",3,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_mirror",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } arg2 = (lua_toboolean(L, 2)!=0); - arg3 = (lua_toboolean(L, 3)!=0); (arg1)->mirror(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Pixels_resize__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; size_t arg2 ; size_t arg3 ; ofInterpolationMethod arg4 ; - bool result; SWIG_check_num_args("ofPixels_< unsigned char >::resize",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::resize",1,"ofPixels_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::resize",2,"size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned char >::resize",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< unsigned char >::resize",4,"ofInterpolationMethod"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_resize",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - arg4 = (ofInterpolationMethod)(int)lua_tonumber(L, 4); result = (bool)(arg1)->resize(arg2,arg3,arg4); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_resize__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; size_t arg2 ; size_t arg3 ; bool result; - SWIG_check_num_args("ofPixels_< unsigned char >::resize",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::resize",1,"ofPixels_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::resize",2,"size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned char >::resize",3,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_resize",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - result = (bool)(arg1)->resize(arg2,arg3); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_resize(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_Pixels_resize__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Pixels_resize__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Pixels_resize'\n" " Possible C/C++ prototypes are:\n" - " ofPixels_< unsigned char >::resize(size_t,size_t,ofInterpolationMethod)\n" - " ofPixels_< unsigned char >::resize(size_t,size_t)\n"); lua_error(L);return 0; } -static int _wrap_Pixels_resizeTo__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; ofPixels_< unsigned char > *arg2 = 0 ; - ofInterpolationMethod arg3 ; bool result; SWIG_check_num_args("ofPixels_< unsigned char >::resizeTo",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::resizeTo",1,"ofPixels_< unsigned char > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::resizeTo",2,"ofPixels_< unsigned char > &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned char >::resizeTo",3,"ofInterpolationMethod"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_resizeTo",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_resizeTo",2,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - arg3 = (ofInterpolationMethod)(int)lua_tonumber(L, 3); - result = (bool)((ofPixels_< unsigned char > const *)arg1)->resizeTo(*arg2,arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_resizeTo__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; ofPixels_< unsigned char > *arg2 = 0 ; bool result; - SWIG_check_num_args("ofPixels_< unsigned char >::resizeTo",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::resizeTo",1,"ofPixels_< unsigned char > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::resizeTo",2,"ofPixels_< unsigned char > &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_resizeTo",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_resizeTo",2,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - result = (bool)((ofPixels_< unsigned char > const *)arg1)->resizeTo(*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_resizeTo(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Pixels_resizeTo__SWIG_1(L);} } } if (argc == 3) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Pixels_resizeTo__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Pixels_resizeTo'\n" " Possible C/C++ prototypes are:\n" - " ofPixels_< unsigned char >::resizeTo(ofPixels_< unsigned char > &,ofInterpolationMethod) const\n" - " ofPixels_< unsigned char >::resizeTo(ofPixels_< unsigned char > &) const\n"); lua_error(L);return 0; } -static int _wrap_Pixels_pasteInto(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; ofPixels_< unsigned char > *arg2 = 0 ; size_t arg3 ; - size_t arg4 ; bool result; SWIG_check_num_args("ofPixels_< unsigned char >::pasteInto",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::pasteInto",1,"ofPixels_< unsigned char > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::pasteInto",2,"ofPixels_< unsigned char > &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned char >::pasteInto",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< unsigned char >::pasteInto",4,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_pasteInto",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_pasteInto",2,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (size_t)lua_tonumber(L, 4); - result = (bool)((ofPixels_< unsigned char > const *)arg1)->pasteInto(*arg2,arg3,arg4); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_blendInto(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; ofPixels_< unsigned char > *arg2 = 0 ; size_t arg3 ; - size_t arg4 ; bool result; SWIG_check_num_args("ofPixels_< unsigned char >::blendInto",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::blendInto",1,"ofPixels_< unsigned char > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::blendInto",2,"ofPixels_< unsigned char > &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned char >::blendInto",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< unsigned char >::blendInto",4,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_blendInto",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_blendInto",2,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (size_t)lua_tonumber(L, 4); - result = (bool)((ofPixels_< unsigned char > const *)arg1)->blendInto(*arg2,arg3,arg4); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_swapRgb(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; - SWIG_check_num_args("ofPixels_< unsigned char >::swapRgb",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::swapRgb",1,"ofPixels_< unsigned char > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_swapRgb",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } (arg1)->swapRgb(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_getData__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; unsigned char *result = 0 ; - SWIG_check_num_args("ofPixels_< unsigned char >::getData",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::getData",1,"ofPixels_< unsigned char > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_getData",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } result = (unsigned char *)(arg1)->getData(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_unsigned_char,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Pixels_getData__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; unsigned char *result = 0 ; - SWIG_check_num_args("ofPixels_< unsigned char >::getData",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::getData",1,"ofPixels_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_getData",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - result = (unsigned char *)((ofPixels_< unsigned char > const *)arg1)->getData(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_unsigned_char,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Pixels_getData(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Pixels_getData__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Pixels_getData__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Pixels_getData'\n" " Possible C/C++ prototypes are:\n" - " ofPixels_< unsigned char >::getData()\n" " ofPixels_< unsigned char >::getData() const\n"); lua_error(L);return 0; } -static int _wrap_Pixels_getPixelIndex(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; size_t arg2 ; size_t arg3 ; size_t result; - SWIG_check_num_args("ofPixels_< unsigned char >::getPixelIndex",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::getPixelIndex",1,"ofPixels_< unsigned char > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::getPixelIndex",2,"size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned char >::getPixelIndex",3,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_getPixelIndex",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - result = (size_t)((ofPixels_< unsigned char > const *)arg1)->getPixelIndex(arg2,arg3); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_getColor__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; size_t arg2 ; size_t arg3 ; - ofColor_< unsigned char > result; SWIG_check_num_args("ofPixels_< unsigned char >::getColor",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::getColor",1,"ofPixels_< unsigned char > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::getColor",2,"size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned char >::getColor",3,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_getColor",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - result = ((ofPixels_< unsigned char > const *)arg1)->getColor(arg2,arg3); { - ofColor_< unsigned char > * resultptr = new ofColor_< unsigned char >((const ofColor_< unsigned char > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_getColor__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; size_t arg2 ; ofColor_< unsigned char > result; - SWIG_check_num_args("ofPixels_< unsigned char >::getColor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::getColor",1,"ofPixels_< unsigned char > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::getColor",2,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_getColor",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - result = ((ofPixels_< unsigned char > const *)arg1)->getColor(arg2); { - ofColor_< unsigned char > * resultptr = new ofColor_< unsigned char >((const ofColor_< unsigned char > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_getColor(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Pixels_getColor__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_Pixels_getColor__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Pixels_getColor'\n" " Possible C/C++ prototypes are:\n" - " ofPixels_< unsigned char >::getColor(size_t,size_t) const\n" " ofPixels_< unsigned char >::getColor(size_t) const\n"); - lua_error(L);return 0; } -static int _wrap_Pixels_setColor__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; size_t arg2 ; size_t arg3 ; - ofColor_< unsigned char > *arg4 = 0 ; SWIG_check_num_args("ofPixels_< unsigned char >::setColor",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::setColor",1,"ofPixels_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::setColor",2,"size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned char >::setColor",3,"size_t"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofPixels_< unsigned char >::setColor",4,"ofColor_< unsigned char > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_setColor",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_setColor",4,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - (arg1)->setColor(arg2,arg3,(ofColor_< unsigned char > const &)*arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Pixels_setColor__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; size_t arg2 ; ofColor_< unsigned char > *arg3 = 0 ; - SWIG_check_num_args("ofPixels_< unsigned char >::setColor",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::setColor",1,"ofPixels_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::setColor",2,"size_t"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofPixels_< unsigned char >::setColor",3,"ofColor_< unsigned char > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_setColor",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_setColor",3,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - (arg1)->setColor(arg2,(ofColor_< unsigned char > const &)*arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Pixels_setColor__SWIG_2(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; ofColor_< unsigned char > *arg2 = 0 ; - SWIG_check_num_args("ofPixels_< unsigned char >::setColor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::setColor",1,"ofPixels_< unsigned char > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::setColor",2,"ofColor_< unsigned char > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_setColor",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_setColor",2,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - (arg1)->setColor((ofColor_< unsigned char > const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Pixels_setColor(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Pixels_setColor__SWIG_2(L);} } } if (argc == 3) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Pixels_setColor__SWIG_1(L);} } } } if (argc == 4) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Pixels_setColor__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Pixels_setColor'\n" " Possible C/C++ prototypes are:\n" - " ofPixels_< unsigned char >::setColor(size_t,size_t,ofColor_< unsigned char > const &)\n" - " ofPixels_< unsigned char >::setColor(size_t,ofColor_< unsigned char > const &)\n" - " ofPixels_< unsigned char >::setColor(ofColor_< unsigned char > const &)\n"); lua_error(L);return 0; } -static int _wrap_Pixels_getWidth(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; size_t result; - SWIG_check_num_args("ofPixels_< unsigned char >::getWidth",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::getWidth",1,"ofPixels_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_getWidth",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - result = (size_t)((ofPixels_< unsigned char > const *)arg1)->getWidth(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_getHeight(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; size_t result; - SWIG_check_num_args("ofPixels_< unsigned char >::getHeight",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::getHeight",1,"ofPixels_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_getHeight",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - result = (size_t)((ofPixels_< unsigned char > const *)arg1)->getHeight(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_getBytesPerPixel(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; size_t result; - SWIG_check_num_args("ofPixels_< unsigned char >::getBytesPerPixel",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::getBytesPerPixel",1,"ofPixels_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_getBytesPerPixel",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - result = (size_t)((ofPixels_< unsigned char > const *)arg1)->getBytesPerPixel(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_getBitsPerPixel(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; size_t result; - SWIG_check_num_args("ofPixels_< unsigned char >::getBitsPerPixel",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::getBitsPerPixel",1,"ofPixels_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_getBitsPerPixel",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - result = (size_t)((ofPixels_< unsigned char > const *)arg1)->getBitsPerPixel(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_getBytesPerChannel(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; size_t result; - SWIG_check_num_args("ofPixels_< unsigned char >::getBytesPerChannel",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::getBytesPerChannel",1,"ofPixels_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_getBytesPerChannel",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - result = (size_t)((ofPixels_< unsigned char > const *)arg1)->getBytesPerChannel(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_getBitsPerChannel(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; size_t result; - SWIG_check_num_args("ofPixels_< unsigned char >::getBitsPerChannel",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::getBitsPerChannel",1,"ofPixels_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_getBitsPerChannel",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - result = (size_t)((ofPixels_< unsigned char > const *)arg1)->getBitsPerChannel(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_getBytesStride(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; size_t result; - SWIG_check_num_args("ofPixels_< unsigned char >::getBytesStride",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::getBytesStride",1,"ofPixels_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_getBytesStride",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - result = (size_t)((ofPixels_< unsigned char > const *)arg1)->getBytesStride(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_getNumChannels(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; size_t result; - SWIG_check_num_args("ofPixels_< unsigned char >::getNumChannels",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::getNumChannels",1,"ofPixels_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_getNumChannels",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - result = (size_t)((ofPixels_< unsigned char > const *)arg1)->getNumChannels(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_getTotalBytes(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; size_t result; - SWIG_check_num_args("ofPixels_< unsigned char >::getTotalBytes",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::getTotalBytes",1,"ofPixels_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_getTotalBytes",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - result = (size_t)((ofPixels_< unsigned char > const *)arg1)->getTotalBytes(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_getNumPlanes(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; size_t result; - SWIG_check_num_args("ofPixels_< unsigned char >::getNumPlanes",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::getNumPlanes",1,"ofPixels_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_getNumPlanes",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - result = (size_t)((ofPixels_< unsigned char > const *)arg1)->getNumPlanes(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_getPlane(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; size_t arg2 ; ofPixels_< unsigned char > result; - SWIG_check_num_args("ofPixels_< unsigned char >::getPlane",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::getPlane",1,"ofPixels_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::getPlane",2,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_getPlane",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - result = (arg1)->getPlane(arg2); { - ofPixels_< unsigned char > * resultptr = new ofPixels_< unsigned char >((const ofPixels_< unsigned char > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofPixels_T_unsigned_char_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_getChannel(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; size_t arg2 ; ofPixels_< unsigned char > result; - SWIG_check_num_args("ofPixels_< unsigned char >::getChannel",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::getChannel",1,"ofPixels_< unsigned char > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::getChannel",2,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_getChannel",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - result = ((ofPixels_< unsigned char > const *)arg1)->getChannel(arg2); { - ofPixels_< unsigned char > * resultptr = new ofPixels_< unsigned char >((const ofPixels_< unsigned char > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofPixels_T_unsigned_char_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_getPixelFormat(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; ofPixelFormat result; - SWIG_check_num_args("ofPixels_< unsigned char >::getPixelFormat",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::getPixelFormat",1,"ofPixels_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_getPixelFormat",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - result = (ofPixelFormat)((ofPixels_< unsigned char > const *)arg1)->getPixelFormat(); - lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Pixels_size(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; size_t result; - SWIG_check_num_args("ofPixels_< unsigned char >::size",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::size",1,"ofPixels_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_size",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - result = (size_t)((ofPixels_< unsigned char > const *)arg1)->size(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_getImageType(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; ofImageType result; - SWIG_check_num_args("ofPixels_< unsigned char >::getImageType",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::getImageType",1,"ofPixels_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_getImageType",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - result = (ofImageType)((ofPixels_< unsigned char > const *)arg1)->getImageType(); - lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Pixels_setChannel(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; size_t arg2 ; ofPixels_< unsigned char > arg3 ; - ofPixels_< unsigned char > *argp3 ; SWIG_check_num_args("ofPixels_< unsigned char >::setChannel",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::setChannel",1,"ofPixels_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::setChannel",2,"size_t"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofPixels_< unsigned char >::setChannel",3,"ofPixels_< unsigned char > const"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_setChannel",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&argp3,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_setChannel",3,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } arg3 = *argp3; (arg1)->setChannel(arg2,arg3); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Pixels_setImageType(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; ofImageType arg2 ; - SWIG_check_num_args("ofPixels_< unsigned char >::setImageType",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::setImageType",1,"ofPixels_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::setImageType",2,"ofImageType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_setImageType",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - arg2 = (ofImageType)(int)lua_tonumber(L, 2); (arg1)->setImageType(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Pixels_setNumChannels(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) 0 ; size_t arg2 ; - SWIG_check_num_args("ofPixels_< unsigned char >::setNumChannels",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned char >::setNumChannels",1,"ofPixels_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned char >::setNumChannels",2,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Pixels_setNumChannels",1,SWIGTYPE_p_ofPixels_T_unsigned_char_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - (arg1)->setNumChannels(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_Pixels(void *obj) { -ofPixels_< unsigned char > *arg1 = (ofPixels_< unsigned char > *) obj; -delete arg1; -} -static int _proxy__wrap_new_Pixels(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_Pixels); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_Pixels_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_Pixels_methods[]= { - { "allocate", _wrap_Pixels_allocate}, - { "allocatePixelFormat", _wrap_Pixels_allocatePixelFormat}, - { "allocateImageType", _wrap_Pixels_allocateImageType}, - { "isAllocated", _wrap_Pixels_isAllocated}, - { "clear", _wrap_Pixels_clear}, - { "set", _wrap_Pixels_set}, - { "setFromPixels", _wrap_Pixels_setFromPixels}, - { "setFromPixelsImageType", _wrap_Pixels_setFromPixelsImageType}, - { "setFromExternalPixels", _wrap_Pixels_setFromExternalPixels}, - { "setFromAlignedPixels", _wrap_Pixels_setFromAlignedPixels}, - { "swap", _wrap_Pixels_swap}, - { "crop", _wrap_Pixels_crop}, - { "cropTo", _wrap_Pixels_cropTo}, - { "rotate90", _wrap_Pixels_rotate90}, - { "rotate90To", _wrap_Pixels_rotate90To}, - { "mirrorTo", _wrap_Pixels_mirrorTo}, - { "mirror", _wrap_Pixels_mirror}, - { "resize", _wrap_Pixels_resize}, - { "resizeTo", _wrap_Pixels_resizeTo}, - { "pasteInto", _wrap_Pixels_pasteInto}, - { "blendInto", _wrap_Pixels_blendInto}, - { "swapRgb", _wrap_Pixels_swapRgb}, - { "getData", _wrap_Pixels_getData}, - { "getPixelIndex", _wrap_Pixels_getPixelIndex}, - { "getColor", _wrap_Pixels_getColor}, - { "setColor", _wrap_Pixels_setColor}, - { "getWidth", _wrap_Pixels_getWidth}, - { "getHeight", _wrap_Pixels_getHeight}, - { "getBytesPerPixel", _wrap_Pixels_getBytesPerPixel}, - { "getBitsPerPixel", _wrap_Pixels_getBitsPerPixel}, - { "getBytesPerChannel", _wrap_Pixels_getBytesPerChannel}, - { "getBitsPerChannel", _wrap_Pixels_getBitsPerChannel}, - { "getBytesStride", _wrap_Pixels_getBytesStride}, - { "getNumChannels", _wrap_Pixels_getNumChannels}, - { "getTotalBytes", _wrap_Pixels_getTotalBytes}, - { "getNumPlanes", _wrap_Pixels_getNumPlanes}, - { "getPlane", _wrap_Pixels_getPlane}, - { "getChannel", _wrap_Pixels_getChannel}, - { "getPixelFormat", _wrap_Pixels_getPixelFormat}, - { "size", _wrap_Pixels_size}, - { "getImageType", _wrap_Pixels_getImageType}, - { "setChannel", _wrap_Pixels_setChannel}, - { "setImageType", _wrap_Pixels_setImageType}, - { "setNumChannels", _wrap_Pixels_setNumChannels}, - {0,0} -}; -static swig_lua_method swig_Pixels_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_Pixels_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_Pixels_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_Pixels_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_Pixels_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_Pixels_Sf_SwigStatic = { - "Pixels", - swig_Pixels_Sf_SwigStatic_methods, - swig_Pixels_Sf_SwigStatic_attributes, - swig_Pixels_Sf_SwigStatic_constants, - swig_Pixels_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_Pixels_bases[] = {0}; -static const char *swig_Pixels_base_names[] = {0}; -static swig_lua_class _wrap_class_Pixels = { "Pixels", "Pixels", &SWIGTYPE_p_ofPixels_T_unsigned_char_t,_proxy__wrap_new_Pixels, swig_delete_Pixels, swig_Pixels_methods, swig_Pixels_attributes, &swig_Pixels_Sf_SwigStatic, swig_Pixels_meta, swig_Pixels_bases, swig_Pixels_base_names }; - -static int _wrap_new_FloatPixels__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPixels_< float > *result = 0 ; - SWIG_check_num_args("ofPixels_< float >::ofPixels_",0,0) result = (ofPixels_< float > *)new ofPixels_< float >(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofPixels_T_float_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_FloatPixels__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPixels_< float > *arg1 = 0 ; - ofPixels_< float > *result = 0 ; SWIG_check_num_args("ofPixels_< float >::ofPixels_",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofPixels_< float >::ofPixels_",1,"ofPixels_< float > &&"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("new_FloatPixels",1,SWIGTYPE_p_ofPixels_T_float_t); } - result = (ofPixels_< float > *)new ofPixels_< float >((ofPixels_< float > &&)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofPixels_T_float_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_FloatPixels(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_FloatPixels__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_new_FloatPixels__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_FloatPixels'\n" " Possible C/C++ prototypes are:\n" - " ofPixels_< float >::ofPixels_()\n" " ofPixels_< float >::ofPixels_(ofPixels_< float > &&)\n"); lua_error(L);return 0; } -static int _wrap_FloatPixels_allocate(lua_State* L) { int SWIG_arg = 0; ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; - size_t arg2 ; size_t arg3 ; size_t arg4 ; SWIG_check_num_args("ofPixels_< float >::allocate",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::allocate",1,"ofPixels_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< float >::allocate",2,"size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< float >::allocate",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< float >::allocate",4,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_allocate",1,SWIGTYPE_p_ofPixels_T_float_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (size_t)lua_tonumber(L, 4); - (arg1)->allocate(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_allocatePixelFormat(lua_State* L) { int SWIG_arg = 0; - ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; size_t arg2 ; size_t arg3 ; ofPixelFormat arg4 ; - SWIG_check_num_args("ofPixels_< float >::allocate",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::allocate",1,"ofPixels_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< float >::allocate",2,"size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< float >::allocate",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< float >::allocate",4,"ofPixelFormat"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_allocatePixelFormat",1,SWIGTYPE_p_ofPixels_T_float_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - arg4 = (ofPixelFormat)(int)lua_tonumber(L, 4); (arg1)->allocate(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_allocateImageType(lua_State* L) { int SWIG_arg = 0; - ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; size_t arg2 ; size_t arg3 ; ofImageType arg4 ; - SWIG_check_num_args("ofPixels_< float >::allocate",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::allocate",1,"ofPixels_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< float >::allocate",2,"size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< float >::allocate",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< float >::allocate",4,"ofImageType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_allocateImageType",1,SWIGTYPE_p_ofPixels_T_float_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - arg4 = (ofImageType)(int)lua_tonumber(L, 4); (arg1)->allocate(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_isAllocated(lua_State* L) { int SWIG_arg = 0; ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; - bool result; SWIG_check_num_args("ofPixels_< float >::isAllocated",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::isAllocated",1,"ofPixels_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_isAllocated",1,SWIGTYPE_p_ofPixels_T_float_t); } - result = (bool)((ofPixels_< float > const *)arg1)->isAllocated(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_clear(lua_State* L) { int SWIG_arg = 0; ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; - SWIG_check_num_args("ofPixels_< float >::clear",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::clear",1,"ofPixels_< float > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_clear",1,SWIGTYPE_p_ofPixels_T_float_t); } (arg1)->clear(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_set__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; - float arg2 ; SWIG_check_num_args("ofPixels_< float >::set",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::set",1,"ofPixels_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< float >::set",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_set",1,SWIGTYPE_p_ofPixels_T_float_t); } arg2 = (float)lua_tonumber(L, 2); (arg1)->set(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_set__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; - size_t arg2 ; float arg3 ; SWIG_check_num_args("ofPixels_< float >::set",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::set",1,"ofPixels_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< float >::set",2,"size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< float >::set",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_set",1,SWIGTYPE_p_ofPixels_T_float_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->set(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FloatPixels_set(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_FloatPixels_set__SWIG_0(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_FloatPixels_set__SWIG_1(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatPixels_set'\n" " Possible C/C++ prototypes are:\n" - " ofPixels_< float >::set(float)\n" " ofPixels_< float >::set(size_t,float)\n"); lua_error(L);return 0; } -static int _wrap_FloatPixels_setFromPixels(lua_State* L) { int SWIG_arg = 0; - ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; float *arg2 = (float *) 0 ; size_t arg3 ; size_t arg4 ; - ofPixelFormat arg5 ; SWIG_check_num_args("ofPixels_< float >::setFromPixels",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::setFromPixels",1,"ofPixels_< float > *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofPixels_< float >::setFromPixels",2,"float const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< float >::setFromPixels",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< float >::setFromPixels",4,"size_t"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPixels_< float >::setFromPixels",5,"ofPixelFormat"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_setFromPixels",1,SWIGTYPE_p_ofPixels_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("FloatPixels_setFromPixels",2,SWIGTYPE_p_float); } - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (size_t)lua_tonumber(L, 4); - arg5 = (ofPixelFormat)(int)lua_tonumber(L, 5); (arg1)->setFromPixels((float const *)arg2,arg3,arg4,arg5); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_setFromPixelsImageType(lua_State* L) { int SWIG_arg = 0; - ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; float *arg2 = (float *) 0 ; size_t arg3 ; size_t arg4 ; - ofImageType arg5 ; SWIG_check_num_args("ofPixels_< float >::setFromPixels",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::setFromPixels",1,"ofPixels_< float > *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofPixels_< float >::setFromPixels",2,"float const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< float >::setFromPixels",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< float >::setFromPixels",4,"size_t"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPixels_< float >::setFromPixels",5,"ofImageType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_setFromPixelsImageType",1,SWIGTYPE_p_ofPixels_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("FloatPixels_setFromPixelsImageType",2,SWIGTYPE_p_float); } - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (size_t)lua_tonumber(L, 4); - arg5 = (ofImageType)(int)lua_tonumber(L, 5); (arg1)->setFromPixels((float const *)arg2,arg3,arg4,arg5); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_setFromExternalPixels(lua_State* L) { int SWIG_arg = 0; - ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; float *arg2 = (float *) 0 ; size_t arg3 ; size_t arg4 ; - ofPixelFormat arg5 ; SWIG_check_num_args("ofPixels_< float >::setFromExternalPixels",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::setFromExternalPixels",1,"ofPixels_< float > *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofPixels_< float >::setFromExternalPixels",2,"float *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< float >::setFromExternalPixels",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< float >::setFromExternalPixels",4,"size_t"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPixels_< float >::setFromExternalPixels",5,"ofPixelFormat"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_setFromExternalPixels",1,SWIGTYPE_p_ofPixels_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("FloatPixels_setFromExternalPixels",2,SWIGTYPE_p_float); } - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (size_t)lua_tonumber(L, 4); - arg5 = (ofPixelFormat)(int)lua_tonumber(L, 5); (arg1)->setFromExternalPixels(arg2,arg3,arg4,arg5); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_setFromAlignedPixels(lua_State* L) { int SWIG_arg = 0; - ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; float *arg2 = (float *) 0 ; size_t arg3 ; size_t arg4 ; - ofPixelFormat arg5 ; size_t arg6 ; SWIG_check_num_args("ofPixels_< float >::setFromAlignedPixels",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::setFromAlignedPixels",1,"ofPixels_< float > *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofPixels_< float >::setFromAlignedPixels",2,"float const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< float >::setFromAlignedPixels",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< float >::setFromAlignedPixels",4,"size_t"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPixels_< float >::setFromAlignedPixels",5,"ofPixelFormat"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPixels_< float >::setFromAlignedPixels",6,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_setFromAlignedPixels",1,SWIGTYPE_p_ofPixels_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("FloatPixels_setFromAlignedPixels",2,SWIGTYPE_p_float); } - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (size_t)lua_tonumber(L, 4); - arg5 = (ofPixelFormat)(int)lua_tonumber(L, 5); SWIG_contract_assert((lua_tonumber(L,6)>=0),"number must not be negative") - arg6 = (size_t)lua_tonumber(L, 6); (arg1)->setFromAlignedPixels((float const *)arg2,arg3,arg4,arg5,arg6); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_swap(lua_State* L) { int SWIG_arg = 0; ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; - ofPixels_< float > *arg2 = 0 ; SWIG_check_num_args("ofPixels_< float >::swap",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::swap",1,"ofPixels_< float > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPixels_< float >::swap",2,"ofPixels_< float > &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_swap",1,SWIGTYPE_p_ofPixels_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_swap",2,SWIGTYPE_p_ofPixels_T_float_t); } (arg1)->swap(*arg2); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_crop(lua_State* L) { int SWIG_arg = 0; ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; - size_t arg2 ; size_t arg3 ; size_t arg4 ; size_t arg5 ; SWIG_check_num_args("ofPixels_< float >::crop",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::crop",1,"ofPixels_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< float >::crop",2,"size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< float >::crop",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< float >::crop",4,"size_t"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPixels_< float >::crop",5,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_crop",1,SWIGTYPE_p_ofPixels_T_float_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (size_t)lua_tonumber(L, 4); - SWIG_contract_assert((lua_tonumber(L,5)>=0),"number must not be negative") arg5 = (size_t)lua_tonumber(L, 5); - (arg1)->crop(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_cropTo(lua_State* L) { int SWIG_arg = 0; ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; - ofPixels_< float > *arg2 = 0 ; size_t arg3 ; size_t arg4 ; size_t arg5 ; size_t arg6 ; - SWIG_check_num_args("ofPixels_< float >::cropTo",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::cropTo",1,"ofPixels_< float > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPixels_< float >::cropTo",2,"ofPixels_< float > &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< float >::cropTo",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< float >::cropTo",4,"size_t"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPixels_< float >::cropTo",5,"size_t"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPixels_< float >::cropTo",6,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_cropTo",1,SWIGTYPE_p_ofPixels_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_cropTo",2,SWIGTYPE_p_ofPixels_T_float_t); } - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (size_t)lua_tonumber(L, 4); - SWIG_contract_assert((lua_tonumber(L,5)>=0),"number must not be negative") arg5 = (size_t)lua_tonumber(L, 5); - SWIG_contract_assert((lua_tonumber(L,6)>=0),"number must not be negative") arg6 = (size_t)lua_tonumber(L, 6); - ((ofPixels_< float > const *)arg1)->cropTo(*arg2,arg3,arg4,arg5,arg6); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FloatPixels_rotate90(lua_State* L) { int SWIG_arg = 0; ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; - int arg2 ; SWIG_check_num_args("ofPixels_< float >::rotate90",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::rotate90",1,"ofPixels_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< float >::rotate90",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_rotate90",1,SWIGTYPE_p_ofPixels_T_float_t); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->rotate90(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_rotate90To(lua_State* L) { int SWIG_arg = 0; ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; - ofPixels_< float > *arg2 = 0 ; int arg3 ; SWIG_check_num_args("ofPixels_< float >::rotate90To",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::rotate90To",1,"ofPixels_< float > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPixels_< float >::rotate90To",2,"ofPixels_< float > &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< float >::rotate90To",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_rotate90To",1,SWIGTYPE_p_ofPixels_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_rotate90To",2,SWIGTYPE_p_ofPixels_T_float_t); } arg3 = (int)lua_tonumber(L, 3); - ((ofPixels_< float > const *)arg1)->rotate90To(*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FloatPixels_mirrorTo(lua_State* L) { int SWIG_arg = 0; ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; - ofPixels_< float > *arg2 = 0 ; bool arg3 ; bool arg4 ; SWIG_check_num_args("ofPixels_< float >::mirrorTo",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::mirrorTo",1,"ofPixels_< float > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPixels_< float >::mirrorTo",2,"ofPixels_< float > &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofPixels_< float >::mirrorTo",3,"bool"); - if(!lua_isboolean(L,4)) SWIG_fail_arg("ofPixels_< float >::mirrorTo",4,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_mirrorTo",1,SWIGTYPE_p_ofPixels_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_mirrorTo",2,SWIGTYPE_p_ofPixels_T_float_t); } arg3 = (lua_toboolean(L, 3)!=0); - arg4 = (lua_toboolean(L, 4)!=0); ((ofPixels_< float > const *)arg1)->mirrorTo(*arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_mirror(lua_State* L) { int SWIG_arg = 0; ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; - bool arg2 ; bool arg3 ; SWIG_check_num_args("ofPixels_< float >::mirror",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::mirror",1,"ofPixels_< float > *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofPixels_< float >::mirror",2,"bool"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofPixels_< float >::mirror",3,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_mirror",1,SWIGTYPE_p_ofPixels_T_float_t); } arg2 = (lua_toboolean(L, 2)!=0); - arg3 = (lua_toboolean(L, 3)!=0); (arg1)->mirror(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FloatPixels_resize__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; size_t arg2 ; size_t arg3 ; ofInterpolationMethod arg4 ; bool result; - SWIG_check_num_args("ofPixels_< float >::resize",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::resize",1,"ofPixels_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< float >::resize",2,"size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< float >::resize",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< float >::resize",4,"ofInterpolationMethod"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_resize",1,SWIGTYPE_p_ofPixels_T_float_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - arg4 = (ofInterpolationMethod)(int)lua_tonumber(L, 4); result = (bool)(arg1)->resize(arg2,arg3,arg4); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_resize__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; size_t arg2 ; size_t arg3 ; bool result; - SWIG_check_num_args("ofPixels_< float >::resize",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::resize",1,"ofPixels_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< float >::resize",2,"size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< float >::resize",3,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_resize",1,SWIGTYPE_p_ofPixels_T_float_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - result = (bool)(arg1)->resize(arg2,arg3); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_resize(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_FloatPixels_resize__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_FloatPixels_resize__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatPixels_resize'\n" " Possible C/C++ prototypes are:\n" - " ofPixels_< float >::resize(size_t,size_t,ofInterpolationMethod)\n" " ofPixels_< float >::resize(size_t,size_t)\n"); - lua_error(L);return 0; } -static int _wrap_FloatPixels_resizeTo__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; ofPixels_< float > *arg2 = 0 ; ofInterpolationMethod arg3 ; bool result; - SWIG_check_num_args("ofPixels_< float >::resizeTo",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::resizeTo",1,"ofPixels_< float > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPixels_< float >::resizeTo",2,"ofPixels_< float > &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< float >::resizeTo",3,"ofInterpolationMethod"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_resizeTo",1,SWIGTYPE_p_ofPixels_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_resizeTo",2,SWIGTYPE_p_ofPixels_T_float_t); } - arg3 = (ofInterpolationMethod)(int)lua_tonumber(L, 3); - result = (bool)((ofPixels_< float > const *)arg1)->resizeTo(*arg2,arg3); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_resizeTo__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; ofPixels_< float > *arg2 = 0 ; bool result; - SWIG_check_num_args("ofPixels_< float >::resizeTo",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::resizeTo",1,"ofPixels_< float > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPixels_< float >::resizeTo",2,"ofPixels_< float > &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_resizeTo",1,SWIGTYPE_p_ofPixels_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_resizeTo",2,SWIGTYPE_p_ofPixels_T_float_t); } - result = (bool)((ofPixels_< float > const *)arg1)->resizeTo(*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_resizeTo(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_FloatPixels_resizeTo__SWIG_1(L);} } } if (argc == 3) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_FloatPixels_resizeTo__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatPixels_resizeTo'\n" - " Possible C/C++ prototypes are:\n" " ofPixels_< float >::resizeTo(ofPixels_< float > &,ofInterpolationMethod) const\n" - " ofPixels_< float >::resizeTo(ofPixels_< float > &) const\n"); lua_error(L);return 0; } -static int _wrap_FloatPixels_pasteInto(lua_State* L) { int SWIG_arg = 0; ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; - ofPixels_< float > *arg2 = 0 ; size_t arg3 ; size_t arg4 ; bool result; - SWIG_check_num_args("ofPixels_< float >::pasteInto",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::pasteInto",1,"ofPixels_< float > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPixels_< float >::pasteInto",2,"ofPixels_< float > &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< float >::pasteInto",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< float >::pasteInto",4,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_pasteInto",1,SWIGTYPE_p_ofPixels_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_pasteInto",2,SWIGTYPE_p_ofPixels_T_float_t); } - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (size_t)lua_tonumber(L, 4); - result = (bool)((ofPixels_< float > const *)arg1)->pasteInto(*arg2,arg3,arg4); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_blendInto(lua_State* L) { int SWIG_arg = 0; ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; - ofPixels_< float > *arg2 = 0 ; size_t arg3 ; size_t arg4 ; bool result; - SWIG_check_num_args("ofPixels_< float >::blendInto",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::blendInto",1,"ofPixels_< float > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPixels_< float >::blendInto",2,"ofPixels_< float > &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< float >::blendInto",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< float >::blendInto",4,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_blendInto",1,SWIGTYPE_p_ofPixels_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_blendInto",2,SWIGTYPE_p_ofPixels_T_float_t); } - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (size_t)lua_tonumber(L, 4); - result = (bool)((ofPixels_< float > const *)arg1)->blendInto(*arg2,arg3,arg4); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_swapRgb(lua_State* L) { int SWIG_arg = 0; ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; - SWIG_check_num_args("ofPixels_< float >::swapRgb",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::swapRgb",1,"ofPixels_< float > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_swapRgb",1,SWIGTYPE_p_ofPixels_T_float_t); } (arg1)->swapRgb(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_getData__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; float *result = 0 ; - SWIG_check_num_args("ofPixels_< float >::getData",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::getData",1,"ofPixels_< float > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_getData",1,SWIGTYPE_p_ofPixels_T_float_t); } result = (float *)(arg1)->getData(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_float,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FloatPixels_getData__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; float *result = 0 ; - SWIG_check_num_args("ofPixels_< float >::getData",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::getData",1,"ofPixels_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_getData",1,SWIGTYPE_p_ofPixels_T_float_t); } - result = (float *)((ofPixels_< float > const *)arg1)->getData(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_float,0); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_getData(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_FloatPixels_getData__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_FloatPixels_getData__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatPixels_getData'\n" - " Possible C/C++ prototypes are:\n" " ofPixels_< float >::getData()\n" " ofPixels_< float >::getData() const\n"); - lua_error(L);return 0; } -static int _wrap_FloatPixels_getPixelIndex(lua_State* L) { int SWIG_arg = 0; - ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; size_t arg2 ; size_t arg3 ; size_t result; - SWIG_check_num_args("ofPixels_< float >::getPixelIndex",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::getPixelIndex",1,"ofPixels_< float > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< float >::getPixelIndex",2,"size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< float >::getPixelIndex",3,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_getPixelIndex",1,SWIGTYPE_p_ofPixels_T_float_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - result = (size_t)((ofPixels_< float > const *)arg1)->getPixelIndex(arg2,arg3); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_getColor__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; size_t arg2 ; size_t arg3 ; ofColor_< float > result; - SWIG_check_num_args("ofPixels_< float >::getColor",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::getColor",1,"ofPixels_< float > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< float >::getColor",2,"size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< float >::getColor",3,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_getColor",1,SWIGTYPE_p_ofPixels_T_float_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - result = ((ofPixels_< float > const *)arg1)->getColor(arg2,arg3); { - ofColor_< float > * resultptr = new ofColor_< float >((const ofColor_< float > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_getColor__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; size_t arg2 ; ofColor_< float > result; - SWIG_check_num_args("ofPixels_< float >::getColor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::getColor",1,"ofPixels_< float > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< float >::getColor",2,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_getColor",1,SWIGTYPE_p_ofPixels_T_float_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - result = ((ofPixels_< float > const *)arg1)->getColor(arg2); { - ofColor_< float > * resultptr = new ofColor_< float >((const ofColor_< float > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_getColor(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_FloatPixels_getColor__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_FloatPixels_getColor__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatPixels_getColor'\n" - " Possible C/C++ prototypes are:\n" " ofPixels_< float >::getColor(size_t,size_t) const\n" - " ofPixels_< float >::getColor(size_t) const\n"); lua_error(L);return 0; } -static int _wrap_FloatPixels_setColor__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; size_t arg2 ; size_t arg3 ; ofColor_< float > *arg4 = 0 ; - SWIG_check_num_args("ofPixels_< float >::setColor",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::setColor",1,"ofPixels_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< float >::setColor",2,"size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< float >::setColor",3,"size_t"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofPixels_< float >::setColor",4,"ofColor_< float > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_setColor",1,SWIGTYPE_p_ofPixels_T_float_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_setColor",4,SWIGTYPE_p_ofColor_T_float_t); } - (arg1)->setColor(arg2,arg3,(ofColor_< float > const &)*arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FloatPixels_setColor__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; size_t arg2 ; ofColor_< float > *arg3 = 0 ; - SWIG_check_num_args("ofPixels_< float >::setColor",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::setColor",1,"ofPixels_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< float >::setColor",2,"size_t"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofPixels_< float >::setColor",3,"ofColor_< float > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_setColor",1,SWIGTYPE_p_ofPixels_T_float_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_setColor",3,SWIGTYPE_p_ofColor_T_float_t); } - (arg1)->setColor(arg2,(ofColor_< float > const &)*arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FloatPixels_setColor__SWIG_2(lua_State* L) { int SWIG_arg = 0; - ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; ofColor_< float > *arg2 = 0 ; - SWIG_check_num_args("ofPixels_< float >::setColor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::setColor",1,"ofPixels_< float > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPixels_< float >::setColor",2,"ofColor_< float > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_setColor",1,SWIGTYPE_p_ofPixels_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_setColor",2,SWIGTYPE_p_ofColor_T_float_t); } (arg1)->setColor((ofColor_< float > const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_setColor(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_FloatPixels_setColor__SWIG_2(L);} } } if (argc == 3) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_FloatPixels_setColor__SWIG_1(L);} } } } if (argc == 4) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_FloatPixels_setColor__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatPixels_setColor'\n" - " Possible C/C++ prototypes are:\n" " ofPixels_< float >::setColor(size_t,size_t,ofColor_< float > const &)\n" - " ofPixels_< float >::setColor(size_t,ofColor_< float > const &)\n" - " ofPixels_< float >::setColor(ofColor_< float > const &)\n"); lua_error(L);return 0; } -static int _wrap_FloatPixels_getWidth(lua_State* L) { int SWIG_arg = 0; ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; - size_t result; SWIG_check_num_args("ofPixels_< float >::getWidth",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::getWidth",1,"ofPixels_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_getWidth",1,SWIGTYPE_p_ofPixels_T_float_t); } - result = (size_t)((ofPixels_< float > const *)arg1)->getWidth(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_getHeight(lua_State* L) { int SWIG_arg = 0; ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; - size_t result; SWIG_check_num_args("ofPixels_< float >::getHeight",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::getHeight",1,"ofPixels_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_getHeight",1,SWIGTYPE_p_ofPixels_T_float_t); } - result = (size_t)((ofPixels_< float > const *)arg1)->getHeight(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_getBytesPerPixel(lua_State* L) { int SWIG_arg = 0; - ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; size_t result; - SWIG_check_num_args("ofPixels_< float >::getBytesPerPixel",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::getBytesPerPixel",1,"ofPixels_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_getBytesPerPixel",1,SWIGTYPE_p_ofPixels_T_float_t); } - result = (size_t)((ofPixels_< float > const *)arg1)->getBytesPerPixel(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_getBitsPerPixel(lua_State* L) { int SWIG_arg = 0; - ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; size_t result; - SWIG_check_num_args("ofPixels_< float >::getBitsPerPixel",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::getBitsPerPixel",1,"ofPixels_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_getBitsPerPixel",1,SWIGTYPE_p_ofPixels_T_float_t); } - result = (size_t)((ofPixels_< float > const *)arg1)->getBitsPerPixel(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_getBytesPerChannel(lua_State* L) { int SWIG_arg = 0; - ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; size_t result; - SWIG_check_num_args("ofPixels_< float >::getBytesPerChannel",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::getBytesPerChannel",1,"ofPixels_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_getBytesPerChannel",1,SWIGTYPE_p_ofPixels_T_float_t); } - result = (size_t)((ofPixels_< float > const *)arg1)->getBytesPerChannel(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_getBitsPerChannel(lua_State* L) { int SWIG_arg = 0; - ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; size_t result; - SWIG_check_num_args("ofPixels_< float >::getBitsPerChannel",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::getBitsPerChannel",1,"ofPixels_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_getBitsPerChannel",1,SWIGTYPE_p_ofPixels_T_float_t); } - result = (size_t)((ofPixels_< float > const *)arg1)->getBitsPerChannel(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_getBytesStride(lua_State* L) { int SWIG_arg = 0; - ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; size_t result; - SWIG_check_num_args("ofPixels_< float >::getBytesStride",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::getBytesStride",1,"ofPixels_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_getBytesStride",1,SWIGTYPE_p_ofPixels_T_float_t); } - result = (size_t)((ofPixels_< float > const *)arg1)->getBytesStride(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_getNumChannels(lua_State* L) { int SWIG_arg = 0; - ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; size_t result; - SWIG_check_num_args("ofPixels_< float >::getNumChannels",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::getNumChannels",1,"ofPixels_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_getNumChannels",1,SWIGTYPE_p_ofPixels_T_float_t); } - result = (size_t)((ofPixels_< float > const *)arg1)->getNumChannels(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_getTotalBytes(lua_State* L) { int SWIG_arg = 0; - ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; size_t result; - SWIG_check_num_args("ofPixels_< float >::getTotalBytes",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::getTotalBytes",1,"ofPixels_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_getTotalBytes",1,SWIGTYPE_p_ofPixels_T_float_t); } - result = (size_t)((ofPixels_< float > const *)arg1)->getTotalBytes(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_getNumPlanes(lua_State* L) { int SWIG_arg = 0; - ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; size_t result; - SWIG_check_num_args("ofPixels_< float >::getNumPlanes",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::getNumPlanes",1,"ofPixels_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_getNumPlanes",1,SWIGTYPE_p_ofPixels_T_float_t); } - result = (size_t)((ofPixels_< float > const *)arg1)->getNumPlanes(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_getPlane(lua_State* L) { int SWIG_arg = 0; ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; - size_t arg2 ; ofPixels_< float > result; SWIG_check_num_args("ofPixels_< float >::getPlane",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::getPlane",1,"ofPixels_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< float >::getPlane",2,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_getPlane",1,SWIGTYPE_p_ofPixels_T_float_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - result = (arg1)->getPlane(arg2); { - ofPixels_< float > * resultptr = new ofPixels_< float >((const ofPixels_< float > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofPixels_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_getChannel(lua_State* L) { int SWIG_arg = 0; ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; - size_t arg2 ; ofPixels_< float > result; SWIG_check_num_args("ofPixels_< float >::getChannel",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::getChannel",1,"ofPixels_< float > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< float >::getChannel",2,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_getChannel",1,SWIGTYPE_p_ofPixels_T_float_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - result = ((ofPixels_< float > const *)arg1)->getChannel(arg2); { - ofPixels_< float > * resultptr = new ofPixels_< float >((const ofPixels_< float > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofPixels_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_getPixelFormat(lua_State* L) { int SWIG_arg = 0; - ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; ofPixelFormat result; - SWIG_check_num_args("ofPixels_< float >::getPixelFormat",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::getPixelFormat",1,"ofPixels_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_getPixelFormat",1,SWIGTYPE_p_ofPixels_T_float_t); } - result = (ofPixelFormat)((ofPixels_< float > const *)arg1)->getPixelFormat(); - lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FloatPixels_size(lua_State* L) { int SWIG_arg = 0; ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; - size_t result; SWIG_check_num_args("ofPixels_< float >::size",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::size",1,"ofPixels_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_size",1,SWIGTYPE_p_ofPixels_T_float_t); } - result = (size_t)((ofPixels_< float > const *)arg1)->size(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_getImageType(lua_State* L) { int SWIG_arg = 0; - ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; ofImageType result; - SWIG_check_num_args("ofPixels_< float >::getImageType",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::getImageType",1,"ofPixels_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_getImageType",1,SWIGTYPE_p_ofPixels_T_float_t); } - result = (ofImageType)((ofPixels_< float > const *)arg1)->getImageType(); - lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FloatPixels_setChannel(lua_State* L) { int SWIG_arg = 0; ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; - size_t arg2 ; ofPixels_< float > arg3 ; ofPixels_< float > *argp3 ; SWIG_check_num_args("ofPixels_< float >::setChannel",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::setChannel",1,"ofPixels_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< float >::setChannel",2,"size_t"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofPixels_< float >::setChannel",3,"ofPixels_< float > const"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_setChannel",1,SWIGTYPE_p_ofPixels_T_float_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&argp3,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_setChannel",3,SWIGTYPE_p_ofPixels_T_float_t); } arg3 = *argp3; (arg1)->setChannel(arg2,arg3); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_setImageType(lua_State* L) { int SWIG_arg = 0; - ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; ofImageType arg2 ; - SWIG_check_num_args("ofPixels_< float >::setImageType",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::setImageType",1,"ofPixels_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< float >::setImageType",2,"ofImageType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_setImageType",1,SWIGTYPE_p_ofPixels_T_float_t); } arg2 = (ofImageType)(int)lua_tonumber(L, 2); - (arg1)->setImageType(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatPixels_setNumChannels(lua_State* L) { int SWIG_arg = 0; - ofPixels_< float > *arg1 = (ofPixels_< float > *) 0 ; size_t arg2 ; - SWIG_check_num_args("ofPixels_< float >::setNumChannels",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< float >::setNumChannels",1,"ofPixels_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< float >::setNumChannels",2,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_float_t,0))){ - SWIG_fail_ptr("FloatPixels_setNumChannels",1,SWIGTYPE_p_ofPixels_T_float_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - (arg1)->setNumChannels(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_FloatPixels(void *obj) { -ofPixels_< float > *arg1 = (ofPixels_< float > *) obj; -delete arg1; -} -static int _proxy__wrap_new_FloatPixels(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_FloatPixels); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_FloatPixels_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_FloatPixels_methods[]= { - { "allocate", _wrap_FloatPixels_allocate}, - { "allocatePixelFormat", _wrap_FloatPixels_allocatePixelFormat}, - { "allocateImageType", _wrap_FloatPixels_allocateImageType}, - { "isAllocated", _wrap_FloatPixels_isAllocated}, - { "clear", _wrap_FloatPixels_clear}, - { "set", _wrap_FloatPixels_set}, - { "setFromPixels", _wrap_FloatPixels_setFromPixels}, - { "setFromPixelsImageType", _wrap_FloatPixels_setFromPixelsImageType}, - { "setFromExternalPixels", _wrap_FloatPixels_setFromExternalPixels}, - { "setFromAlignedPixels", _wrap_FloatPixels_setFromAlignedPixels}, - { "swap", _wrap_FloatPixels_swap}, - { "crop", _wrap_FloatPixels_crop}, - { "cropTo", _wrap_FloatPixels_cropTo}, - { "rotate90", _wrap_FloatPixels_rotate90}, - { "rotate90To", _wrap_FloatPixels_rotate90To}, - { "mirrorTo", _wrap_FloatPixels_mirrorTo}, - { "mirror", _wrap_FloatPixels_mirror}, - { "resize", _wrap_FloatPixels_resize}, - { "resizeTo", _wrap_FloatPixels_resizeTo}, - { "pasteInto", _wrap_FloatPixels_pasteInto}, - { "blendInto", _wrap_FloatPixels_blendInto}, - { "swapRgb", _wrap_FloatPixels_swapRgb}, - { "getData", _wrap_FloatPixels_getData}, - { "getPixelIndex", _wrap_FloatPixels_getPixelIndex}, - { "getColor", _wrap_FloatPixels_getColor}, - { "setColor", _wrap_FloatPixels_setColor}, - { "getWidth", _wrap_FloatPixels_getWidth}, - { "getHeight", _wrap_FloatPixels_getHeight}, - { "getBytesPerPixel", _wrap_FloatPixels_getBytesPerPixel}, - { "getBitsPerPixel", _wrap_FloatPixels_getBitsPerPixel}, - { "getBytesPerChannel", _wrap_FloatPixels_getBytesPerChannel}, - { "getBitsPerChannel", _wrap_FloatPixels_getBitsPerChannel}, - { "getBytesStride", _wrap_FloatPixels_getBytesStride}, - { "getNumChannels", _wrap_FloatPixels_getNumChannels}, - { "getTotalBytes", _wrap_FloatPixels_getTotalBytes}, - { "getNumPlanes", _wrap_FloatPixels_getNumPlanes}, - { "getPlane", _wrap_FloatPixels_getPlane}, - { "getChannel", _wrap_FloatPixels_getChannel}, - { "getPixelFormat", _wrap_FloatPixels_getPixelFormat}, - { "size", _wrap_FloatPixels_size}, - { "getImageType", _wrap_FloatPixels_getImageType}, - { "setChannel", _wrap_FloatPixels_setChannel}, - { "setImageType", _wrap_FloatPixels_setImageType}, - { "setNumChannels", _wrap_FloatPixels_setNumChannels}, - {0,0} -}; -static swig_lua_method swig_FloatPixels_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_FloatPixels_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_FloatPixels_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_FloatPixels_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_FloatPixels_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_FloatPixels_Sf_SwigStatic = { - "FloatPixels", - swig_FloatPixels_Sf_SwigStatic_methods, - swig_FloatPixels_Sf_SwigStatic_attributes, - swig_FloatPixels_Sf_SwigStatic_constants, - swig_FloatPixels_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_FloatPixels_bases[] = {0}; -static const char *swig_FloatPixels_base_names[] = {0}; -static swig_lua_class _wrap_class_FloatPixels = { "FloatPixels", "FloatPixels", &SWIGTYPE_p_ofPixels_T_float_t,_proxy__wrap_new_FloatPixels, swig_delete_FloatPixels, swig_FloatPixels_methods, swig_FloatPixels_attributes, &swig_FloatPixels_Sf_SwigStatic, swig_FloatPixels_meta, swig_FloatPixels_bases, swig_FloatPixels_base_names }; - -static int _wrap_new_ShortPixels__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPixels_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofPixels_< unsigned short >::ofPixels_",0,0) - result = (ofPixels_< unsigned short > *)new ofPixels_< unsigned short >(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofPixels_T_unsigned_short_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_ShortPixels__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPixels_< unsigned short > *arg1 = 0 ; - ofPixels_< unsigned short > *result = 0 ; SWIG_check_num_args("ofPixels_< unsigned short >::ofPixels_",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::ofPixels_",1,"ofPixels_< unsigned short > &&"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("new_ShortPixels",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - result = (ofPixels_< unsigned short > *)new ofPixels_< unsigned short >((ofPixels_< unsigned short > &&)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofPixels_T_unsigned_short_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_ShortPixels(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_ShortPixels__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_new_ShortPixels__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_ShortPixels'\n" " Possible C/C++ prototypes are:\n" - " ofPixels_< unsigned short >::ofPixels_()\n" - " ofPixels_< unsigned short >::ofPixels_(ofPixels_< unsigned short > &&)\n"); lua_error(L);return 0; } -static int _wrap_ShortPixels_allocate(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; size_t arg2 ; size_t arg3 ; size_t arg4 ; - SWIG_check_num_args("ofPixels_< unsigned short >::allocate",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::allocate",1,"ofPixels_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::allocate",2,"size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned short >::allocate",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< unsigned short >::allocate",4,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_allocate",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (size_t)lua_tonumber(L, 4); - (arg1)->allocate(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_allocatePixelFormat(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; size_t arg2 ; size_t arg3 ; ofPixelFormat arg4 ; - SWIG_check_num_args("ofPixels_< unsigned short >::allocate",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::allocate",1,"ofPixels_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::allocate",2,"size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned short >::allocate",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< unsigned short >::allocate",4,"ofPixelFormat"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_allocatePixelFormat",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - arg4 = (ofPixelFormat)(int)lua_tonumber(L, 4); (arg1)->allocate(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_allocateImageType(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; size_t arg2 ; size_t arg3 ; ofImageType arg4 ; - SWIG_check_num_args("ofPixels_< unsigned short >::allocate",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::allocate",1,"ofPixels_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::allocate",2,"size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned short >::allocate",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< unsigned short >::allocate",4,"ofImageType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_allocateImageType",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - arg4 = (ofImageType)(int)lua_tonumber(L, 4); (arg1)->allocate(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_isAllocated(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; bool result; - SWIG_check_num_args("ofPixels_< unsigned short >::isAllocated",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::isAllocated",1,"ofPixels_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_isAllocated",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - result = (bool)((ofPixels_< unsigned short > const *)arg1)->isAllocated(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_clear(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; - SWIG_check_num_args("ofPixels_< unsigned short >::clear",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::clear",1,"ofPixels_< unsigned short > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_clear",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } (arg1)->clear(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_set__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; unsigned short arg2 ; - SWIG_check_num_args("ofPixels_< unsigned short >::set",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::set",1,"ofPixels_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::set",2,"unsigned short"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_set",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned short)lua_tonumber(L, 2); - (arg1)->set(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_set__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; size_t arg2 ; unsigned short arg3 ; - SWIG_check_num_args("ofPixels_< unsigned short >::set",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::set",1,"ofPixels_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::set",2,"size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned short >::set",3,"unsigned short"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_set",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (unsigned short)lua_tonumber(L, 3); - (arg1)->set(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_set(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_ShortPixels_set__SWIG_0(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_ShortPixels_set__SWIG_1(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortPixels_set'\n" " Possible C/C++ prototypes are:\n" - " ofPixels_< unsigned short >::set(unsigned short)\n" " ofPixels_< unsigned short >::set(size_t,unsigned short)\n"); - lua_error(L);return 0; } -static int _wrap_ShortPixels_setFromPixels(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; unsigned short *arg2 = (unsigned short *) 0 ; - size_t arg3 ; size_t arg4 ; ofPixelFormat arg5 ; SWIG_check_num_args("ofPixels_< unsigned short >::setFromPixels",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::setFromPixels",1,"ofPixels_< unsigned short > *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::setFromPixels",2,"unsigned short const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned short >::setFromPixels",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< unsigned short >::setFromPixels",4,"size_t"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPixels_< unsigned short >::setFromPixels",5,"ofPixelFormat"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_setFromPixels",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_unsigned_short,0))){ - SWIG_fail_ptr("ShortPixels_setFromPixels",2,SWIGTYPE_p_unsigned_short); } - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (size_t)lua_tonumber(L, 4); - arg5 = (ofPixelFormat)(int)lua_tonumber(L, 5); (arg1)->setFromPixels((unsigned short const *)arg2,arg3,arg4,arg5); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_setFromPixelsImageType(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; unsigned short *arg2 = (unsigned short *) 0 ; - size_t arg3 ; size_t arg4 ; ofImageType arg5 ; SWIG_check_num_args("ofPixels_< unsigned short >::setFromPixels",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::setFromPixels",1,"ofPixels_< unsigned short > *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::setFromPixels",2,"unsigned short const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned short >::setFromPixels",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< unsigned short >::setFromPixels",4,"size_t"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPixels_< unsigned short >::setFromPixels",5,"ofImageType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_setFromPixelsImageType",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_unsigned_short,0))){ - SWIG_fail_ptr("ShortPixels_setFromPixelsImageType",2,SWIGTYPE_p_unsigned_short); } - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (size_t)lua_tonumber(L, 4); - arg5 = (ofImageType)(int)lua_tonumber(L, 5); (arg1)->setFromPixels((unsigned short const *)arg2,arg3,arg4,arg5); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_setFromExternalPixels(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; unsigned short *arg2 = (unsigned short *) 0 ; - size_t arg3 ; size_t arg4 ; ofPixelFormat arg5 ; SWIG_check_num_args("ofPixels_< unsigned short >::setFromExternalPixels",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::setFromExternalPixels",1,"ofPixels_< unsigned short > *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::setFromExternalPixels",2,"unsigned short *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned short >::setFromExternalPixels",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< unsigned short >::setFromExternalPixels",4,"size_t"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPixels_< unsigned short >::setFromExternalPixels",5,"ofPixelFormat"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_setFromExternalPixels",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_unsigned_short,0))){ - SWIG_fail_ptr("ShortPixels_setFromExternalPixels",2,SWIGTYPE_p_unsigned_short); } - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (size_t)lua_tonumber(L, 4); - arg5 = (ofPixelFormat)(int)lua_tonumber(L, 5); (arg1)->setFromExternalPixels(arg2,arg3,arg4,arg5); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_setFromAlignedPixels(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; unsigned short *arg2 = (unsigned short *) 0 ; - size_t arg3 ; size_t arg4 ; ofPixelFormat arg5 ; size_t arg6 ; - SWIG_check_num_args("ofPixels_< unsigned short >::setFromAlignedPixels",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::setFromAlignedPixels",1,"ofPixels_< unsigned short > *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::setFromAlignedPixels",2,"unsigned short const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned short >::setFromAlignedPixels",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< unsigned short >::setFromAlignedPixels",4,"size_t"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPixels_< unsigned short >::setFromAlignedPixels",5,"ofPixelFormat"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPixels_< unsigned short >::setFromAlignedPixels",6,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_setFromAlignedPixels",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_unsigned_short,0))){ - SWIG_fail_ptr("ShortPixels_setFromAlignedPixels",2,SWIGTYPE_p_unsigned_short); } - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (size_t)lua_tonumber(L, 4); - arg5 = (ofPixelFormat)(int)lua_tonumber(L, 5); SWIG_contract_assert((lua_tonumber(L,6)>=0),"number must not be negative") - arg6 = (size_t)lua_tonumber(L, 6); (arg1)->setFromAlignedPixels((unsigned short const *)arg2,arg3,arg4,arg5,arg6); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_swap(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; ofPixels_< unsigned short > *arg2 = 0 ; - SWIG_check_num_args("ofPixels_< unsigned short >::swap",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::swap",1,"ofPixels_< unsigned short > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::swap",2,"ofPixels_< unsigned short > &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_swap",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_swap",2,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } (arg1)->swap(*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_crop(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; size_t arg2 ; size_t arg3 ; size_t arg4 ; - size_t arg5 ; SWIG_check_num_args("ofPixels_< unsigned short >::crop",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::crop",1,"ofPixels_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::crop",2,"size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned short >::crop",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< unsigned short >::crop",4,"size_t"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPixels_< unsigned short >::crop",5,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_crop",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (size_t)lua_tonumber(L, 4); - SWIG_contract_assert((lua_tonumber(L,5)>=0),"number must not be negative") arg5 = (size_t)lua_tonumber(L, 5); - (arg1)->crop(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_cropTo(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; ofPixels_< unsigned short > *arg2 = 0 ; size_t arg3 ; - size_t arg4 ; size_t arg5 ; size_t arg6 ; SWIG_check_num_args("ofPixels_< unsigned short >::cropTo",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::cropTo",1,"ofPixels_< unsigned short > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::cropTo",2,"ofPixels_< unsigned short > &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned short >::cropTo",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< unsigned short >::cropTo",4,"size_t"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPixels_< unsigned short >::cropTo",5,"size_t"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPixels_< unsigned short >::cropTo",6,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_cropTo",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_cropTo",2,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (size_t)lua_tonumber(L, 4); - SWIG_contract_assert((lua_tonumber(L,5)>=0),"number must not be negative") arg5 = (size_t)lua_tonumber(L, 5); - SWIG_contract_assert((lua_tonumber(L,6)>=0),"number must not be negative") arg6 = (size_t)lua_tonumber(L, 6); - ((ofPixels_< unsigned short > const *)arg1)->cropTo(*arg2,arg3,arg4,arg5,arg6); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_rotate90(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; int arg2 ; - SWIG_check_num_args("ofPixels_< unsigned short >::rotate90",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::rotate90",1,"ofPixels_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::rotate90",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_rotate90",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->rotate90(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_rotate90To(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; ofPixels_< unsigned short > *arg2 = 0 ; int arg3 ; - SWIG_check_num_args("ofPixels_< unsigned short >::rotate90To",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::rotate90To",1,"ofPixels_< unsigned short > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::rotate90To",2,"ofPixels_< unsigned short > &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned short >::rotate90To",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_rotate90To",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_rotate90To",2,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } arg3 = (int)lua_tonumber(L, 3); - ((ofPixels_< unsigned short > const *)arg1)->rotate90To(*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortPixels_mirrorTo(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; ofPixels_< unsigned short > *arg2 = 0 ; bool arg3 ; - bool arg4 ; SWIG_check_num_args("ofPixels_< unsigned short >::mirrorTo",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::mirrorTo",1,"ofPixels_< unsigned short > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::mirrorTo",2,"ofPixels_< unsigned short > &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofPixels_< unsigned short >::mirrorTo",3,"bool"); - if(!lua_isboolean(L,4)) SWIG_fail_arg("ofPixels_< unsigned short >::mirrorTo",4,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_mirrorTo",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_mirrorTo",2,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } arg3 = (lua_toboolean(L, 3)!=0); - arg4 = (lua_toboolean(L, 4)!=0); ((ofPixels_< unsigned short > const *)arg1)->mirrorTo(*arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_mirror(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; bool arg2 ; bool arg3 ; - SWIG_check_num_args("ofPixels_< unsigned short >::mirror",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::mirror",1,"ofPixels_< unsigned short > *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::mirror",2,"bool"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofPixels_< unsigned short >::mirror",3,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_mirror",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } arg2 = (lua_toboolean(L, 2)!=0); - arg3 = (lua_toboolean(L, 3)!=0); (arg1)->mirror(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortPixels_resize__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; size_t arg2 ; size_t arg3 ; - ofInterpolationMethod arg4 ; bool result; SWIG_check_num_args("ofPixels_< unsigned short >::resize",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::resize",1,"ofPixels_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::resize",2,"size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned short >::resize",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< unsigned short >::resize",4,"ofInterpolationMethod"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_resize",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - arg4 = (ofInterpolationMethod)(int)lua_tonumber(L, 4); result = (bool)(arg1)->resize(arg2,arg3,arg4); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_resize__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; size_t arg2 ; size_t arg3 ; bool result; - SWIG_check_num_args("ofPixels_< unsigned short >::resize",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::resize",1,"ofPixels_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::resize",2,"size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned short >::resize",3,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_resize",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - result = (bool)(arg1)->resize(arg2,arg3); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_resize(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_ShortPixels_resize__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_ShortPixels_resize__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortPixels_resize'\n" " Possible C/C++ prototypes are:\n" - " ofPixels_< unsigned short >::resize(size_t,size_t,ofInterpolationMethod)\n" - " ofPixels_< unsigned short >::resize(size_t,size_t)\n"); lua_error(L);return 0; } -static int _wrap_ShortPixels_resizeTo__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; ofPixels_< unsigned short > *arg2 = 0 ; - ofInterpolationMethod arg3 ; bool result; SWIG_check_num_args("ofPixels_< unsigned short >::resizeTo",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::resizeTo",1,"ofPixels_< unsigned short > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::resizeTo",2,"ofPixels_< unsigned short > &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned short >::resizeTo",3,"ofInterpolationMethod"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_resizeTo",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_resizeTo",2,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - arg3 = (ofInterpolationMethod)(int)lua_tonumber(L, 3); - result = (bool)((ofPixels_< unsigned short > const *)arg1)->resizeTo(*arg2,arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_resizeTo__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; ofPixels_< unsigned short > *arg2 = 0 ; bool result; - SWIG_check_num_args("ofPixels_< unsigned short >::resizeTo",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::resizeTo",1,"ofPixels_< unsigned short > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::resizeTo",2,"ofPixels_< unsigned short > &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_resizeTo",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_resizeTo",2,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - result = (bool)((ofPixels_< unsigned short > const *)arg1)->resizeTo(*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_resizeTo(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_ShortPixels_resizeTo__SWIG_1(L);} } } if (argc == 3) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_ShortPixels_resizeTo__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortPixels_resizeTo'\n" - " Possible C/C++ prototypes are:\n" - " ofPixels_< unsigned short >::resizeTo(ofPixels_< unsigned short > &,ofInterpolationMethod) const\n" - " ofPixels_< unsigned short >::resizeTo(ofPixels_< unsigned short > &) const\n"); lua_error(L);return 0; } -static int _wrap_ShortPixels_pasteInto(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; ofPixels_< unsigned short > *arg2 = 0 ; size_t arg3 ; - size_t arg4 ; bool result; SWIG_check_num_args("ofPixels_< unsigned short >::pasteInto",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::pasteInto",1,"ofPixels_< unsigned short > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::pasteInto",2,"ofPixels_< unsigned short > &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned short >::pasteInto",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< unsigned short >::pasteInto",4,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_pasteInto",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_pasteInto",2,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (size_t)lua_tonumber(L, 4); - result = (bool)((ofPixels_< unsigned short > const *)arg1)->pasteInto(*arg2,arg3,arg4); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_blendInto(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; ofPixels_< unsigned short > *arg2 = 0 ; size_t arg3 ; - size_t arg4 ; bool result; SWIG_check_num_args("ofPixels_< unsigned short >::blendInto",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::blendInto",1,"ofPixels_< unsigned short > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::blendInto",2,"ofPixels_< unsigned short > &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned short >::blendInto",3,"size_t"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPixels_< unsigned short >::blendInto",4,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_blendInto",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_blendInto",2,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (size_t)lua_tonumber(L, 4); - result = (bool)((ofPixels_< unsigned short > const *)arg1)->blendInto(*arg2,arg3,arg4); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_swapRgb(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; - SWIG_check_num_args("ofPixels_< unsigned short >::swapRgb",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::swapRgb",1,"ofPixels_< unsigned short > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_swapRgb",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } (arg1)->swapRgb(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_getData__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; unsigned short *result = 0 ; - SWIG_check_num_args("ofPixels_< unsigned short >::getData",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::getData",1,"ofPixels_< unsigned short > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_getData",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - result = (unsigned short *)(arg1)->getData(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_unsigned_short,0); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_getData__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; unsigned short *result = 0 ; - SWIG_check_num_args("ofPixels_< unsigned short >::getData",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::getData",1,"ofPixels_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_getData",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - result = (unsigned short *)((ofPixels_< unsigned short > const *)arg1)->getData(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_unsigned_short,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortPixels_getData(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_ShortPixels_getData__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_ShortPixels_getData__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortPixels_getData'\n" - " Possible C/C++ prototypes are:\n" " ofPixels_< unsigned short >::getData()\n" - " ofPixels_< unsigned short >::getData() const\n"); lua_error(L);return 0; } -static int _wrap_ShortPixels_getPixelIndex(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; size_t arg2 ; size_t arg3 ; size_t result; - SWIG_check_num_args("ofPixels_< unsigned short >::getPixelIndex",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::getPixelIndex",1,"ofPixels_< unsigned short > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::getPixelIndex",2,"size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned short >::getPixelIndex",3,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_getPixelIndex",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - result = (size_t)((ofPixels_< unsigned short > const *)arg1)->getPixelIndex(arg2,arg3); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_getColor__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; size_t arg2 ; size_t arg3 ; - ofColor_< unsigned short > result; SWIG_check_num_args("ofPixels_< unsigned short >::getColor",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::getColor",1,"ofPixels_< unsigned short > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::getColor",2,"size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned short >::getColor",3,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_getColor",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - result = ((ofPixels_< unsigned short > const *)arg1)->getColor(arg2,arg3); { - ofColor_< unsigned short > * resultptr = new ofColor_< unsigned short >((const ofColor_< unsigned short > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_short_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_getColor__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; size_t arg2 ; ofColor_< unsigned short > result; - SWIG_check_num_args("ofPixels_< unsigned short >::getColor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::getColor",1,"ofPixels_< unsigned short > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::getColor",2,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_getColor",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - result = ((ofPixels_< unsigned short > const *)arg1)->getColor(arg2); { - ofColor_< unsigned short > * resultptr = new ofColor_< unsigned short >((const ofColor_< unsigned short > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_short_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_getColor(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_ShortPixels_getColor__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_ShortPixels_getColor__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortPixels_getColor'\n" - " Possible C/C++ prototypes are:\n" " ofPixels_< unsigned short >::getColor(size_t,size_t) const\n" - " ofPixels_< unsigned short >::getColor(size_t) const\n"); lua_error(L);return 0; } -static int _wrap_ShortPixels_setColor__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; size_t arg2 ; size_t arg3 ; - ofColor_< unsigned short > *arg4 = 0 ; SWIG_check_num_args("ofPixels_< unsigned short >::setColor",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::setColor",1,"ofPixels_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::setColor",2,"size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPixels_< unsigned short >::setColor",3,"size_t"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofPixels_< unsigned short >::setColor",4,"ofColor_< unsigned short > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_setColor",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (size_t)lua_tonumber(L, 3); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_setColor",4,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - (arg1)->setColor(arg2,arg3,(ofColor_< unsigned short > const &)*arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortPixels_setColor__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; size_t arg2 ; ofColor_< unsigned short > *arg3 = 0 ; - SWIG_check_num_args("ofPixels_< unsigned short >::setColor",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::setColor",1,"ofPixels_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::setColor",2,"size_t"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofPixels_< unsigned short >::setColor",3,"ofColor_< unsigned short > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_setColor",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_setColor",3,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - (arg1)->setColor(arg2,(ofColor_< unsigned short > const &)*arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortPixels_setColor__SWIG_2(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; ofColor_< unsigned short > *arg2 = 0 ; - SWIG_check_num_args("ofPixels_< unsigned short >::setColor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::setColor",1,"ofPixels_< unsigned short > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::setColor",2,"ofColor_< unsigned short > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_setColor",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_setColor",2,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - (arg1)->setColor((ofColor_< unsigned short > const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortPixels_setColor(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_ShortPixels_setColor__SWIG_2(L);} } } if (argc == 3) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_ShortPixels_setColor__SWIG_1(L);} } } } if (argc == 4) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPixels_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_ShortPixels_setColor__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortPixels_setColor'\n" - " Possible C/C++ prototypes are:\n" - " ofPixels_< unsigned short >::setColor(size_t,size_t,ofColor_< unsigned short > const &)\n" - " ofPixels_< unsigned short >::setColor(size_t,ofColor_< unsigned short > const &)\n" - " ofPixels_< unsigned short >::setColor(ofColor_< unsigned short > const &)\n"); lua_error(L);return 0; } -static int _wrap_ShortPixels_getWidth(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; size_t result; - SWIG_check_num_args("ofPixels_< unsigned short >::getWidth",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::getWidth",1,"ofPixels_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_getWidth",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - result = (size_t)((ofPixels_< unsigned short > const *)arg1)->getWidth(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_getHeight(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; size_t result; - SWIG_check_num_args("ofPixels_< unsigned short >::getHeight",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::getHeight",1,"ofPixels_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_getHeight",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - result = (size_t)((ofPixels_< unsigned short > const *)arg1)->getHeight(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_getBytesPerPixel(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; size_t result; - SWIG_check_num_args("ofPixels_< unsigned short >::getBytesPerPixel",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::getBytesPerPixel",1,"ofPixels_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_getBytesPerPixel",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - result = (size_t)((ofPixels_< unsigned short > const *)arg1)->getBytesPerPixel(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_getBitsPerPixel(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; size_t result; - SWIG_check_num_args("ofPixels_< unsigned short >::getBitsPerPixel",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::getBitsPerPixel",1,"ofPixels_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_getBitsPerPixel",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - result = (size_t)((ofPixels_< unsigned short > const *)arg1)->getBitsPerPixel(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_getBytesPerChannel(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; size_t result; - SWIG_check_num_args("ofPixels_< unsigned short >::getBytesPerChannel",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::getBytesPerChannel",1,"ofPixels_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_getBytesPerChannel",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - result = (size_t)((ofPixels_< unsigned short > const *)arg1)->getBytesPerChannel(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_getBitsPerChannel(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; size_t result; - SWIG_check_num_args("ofPixels_< unsigned short >::getBitsPerChannel",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::getBitsPerChannel",1,"ofPixels_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_getBitsPerChannel",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - result = (size_t)((ofPixels_< unsigned short > const *)arg1)->getBitsPerChannel(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_getBytesStride(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; size_t result; - SWIG_check_num_args("ofPixels_< unsigned short >::getBytesStride",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::getBytesStride",1,"ofPixels_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_getBytesStride",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - result = (size_t)((ofPixels_< unsigned short > const *)arg1)->getBytesStride(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_getNumChannels(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; size_t result; - SWIG_check_num_args("ofPixels_< unsigned short >::getNumChannels",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::getNumChannels",1,"ofPixels_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_getNumChannels",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - result = (size_t)((ofPixels_< unsigned short > const *)arg1)->getNumChannels(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_getTotalBytes(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; size_t result; - SWIG_check_num_args("ofPixels_< unsigned short >::getTotalBytes",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::getTotalBytes",1,"ofPixels_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_getTotalBytes",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - result = (size_t)((ofPixels_< unsigned short > const *)arg1)->getTotalBytes(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_getNumPlanes(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; size_t result; - SWIG_check_num_args("ofPixels_< unsigned short >::getNumPlanes",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::getNumPlanes",1,"ofPixels_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_getNumPlanes",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - result = (size_t)((ofPixels_< unsigned short > const *)arg1)->getNumPlanes(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_getPlane(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; size_t arg2 ; ofPixels_< unsigned short > result; - SWIG_check_num_args("ofPixels_< unsigned short >::getPlane",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::getPlane",1,"ofPixels_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::getPlane",2,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_getPlane",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - result = (arg1)->getPlane(arg2); { - ofPixels_< unsigned short > * resultptr = new ofPixels_< unsigned short >((const ofPixels_< unsigned short > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofPixels_T_unsigned_short_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_getChannel(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; size_t arg2 ; ofPixels_< unsigned short > result; - SWIG_check_num_args("ofPixels_< unsigned short >::getChannel",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::getChannel",1,"ofPixels_< unsigned short > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::getChannel",2,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_getChannel",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - result = ((ofPixels_< unsigned short > const *)arg1)->getChannel(arg2); { - ofPixels_< unsigned short > * resultptr = new ofPixels_< unsigned short >((const ofPixels_< unsigned short > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofPixels_T_unsigned_short_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_getPixelFormat(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; ofPixelFormat result; - SWIG_check_num_args("ofPixels_< unsigned short >::getPixelFormat",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::getPixelFormat",1,"ofPixels_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_getPixelFormat",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - result = (ofPixelFormat)((ofPixels_< unsigned short > const *)arg1)->getPixelFormat(); - lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortPixels_size(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; size_t result; - SWIG_check_num_args("ofPixels_< unsigned short >::size",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::size",1,"ofPixels_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_size",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - result = (size_t)((ofPixels_< unsigned short > const *)arg1)->size(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_getImageType(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; ofImageType result; - SWIG_check_num_args("ofPixels_< unsigned short >::getImageType",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::getImageType",1,"ofPixels_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_getImageType",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - result = (ofImageType)((ofPixels_< unsigned short > const *)arg1)->getImageType(); - lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortPixels_setChannel(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; size_t arg2 ; ofPixels_< unsigned short > arg3 ; - ofPixels_< unsigned short > *argp3 ; SWIG_check_num_args("ofPixels_< unsigned short >::setChannel",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::setChannel",1,"ofPixels_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::setChannel",2,"size_t"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofPixels_< unsigned short >::setChannel",3,"ofPixels_< unsigned short > const"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_setChannel",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&argp3,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_setChannel",3,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } arg3 = *argp3; - (arg1)->setChannel(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortPixels_setImageType(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; ofImageType arg2 ; - SWIG_check_num_args("ofPixels_< unsigned short >::setImageType",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::setImageType",1,"ofPixels_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::setImageType",2,"ofImageType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_setImageType",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - arg2 = (ofImageType)(int)lua_tonumber(L, 2); (arg1)->setImageType(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortPixels_setNumChannels(lua_State* L) { int SWIG_arg = 0; - ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) 0 ; size_t arg2 ; - SWIG_check_num_args("ofPixels_< unsigned short >::setNumChannels",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPixels_< unsigned short >::setNumChannels",1,"ofPixels_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPixels_< unsigned short >::setNumChannels",2,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPixels_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortPixels_setNumChannels",1,SWIGTYPE_p_ofPixels_T_unsigned_short_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - (arg1)->setNumChannels(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_ShortPixels(void *obj) { -ofPixels_< unsigned short > *arg1 = (ofPixels_< unsigned short > *) obj; -delete arg1; -} -static int _proxy__wrap_new_ShortPixels(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_ShortPixels); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_ShortPixels_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_ShortPixels_methods[]= { - { "allocate", _wrap_ShortPixels_allocate}, - { "allocatePixelFormat", _wrap_ShortPixels_allocatePixelFormat}, - { "allocateImageType", _wrap_ShortPixels_allocateImageType}, - { "isAllocated", _wrap_ShortPixels_isAllocated}, - { "clear", _wrap_ShortPixels_clear}, - { "set", _wrap_ShortPixels_set}, - { "setFromPixels", _wrap_ShortPixels_setFromPixels}, - { "setFromPixelsImageType", _wrap_ShortPixels_setFromPixelsImageType}, - { "setFromExternalPixels", _wrap_ShortPixels_setFromExternalPixels}, - { "setFromAlignedPixels", _wrap_ShortPixels_setFromAlignedPixels}, - { "swap", _wrap_ShortPixels_swap}, - { "crop", _wrap_ShortPixels_crop}, - { "cropTo", _wrap_ShortPixels_cropTo}, - { "rotate90", _wrap_ShortPixels_rotate90}, - { "rotate90To", _wrap_ShortPixels_rotate90To}, - { "mirrorTo", _wrap_ShortPixels_mirrorTo}, - { "mirror", _wrap_ShortPixels_mirror}, - { "resize", _wrap_ShortPixels_resize}, - { "resizeTo", _wrap_ShortPixels_resizeTo}, - { "pasteInto", _wrap_ShortPixels_pasteInto}, - { "blendInto", _wrap_ShortPixels_blendInto}, - { "swapRgb", _wrap_ShortPixels_swapRgb}, - { "getData", _wrap_ShortPixels_getData}, - { "getPixelIndex", _wrap_ShortPixels_getPixelIndex}, - { "getColor", _wrap_ShortPixels_getColor}, - { "setColor", _wrap_ShortPixels_setColor}, - { "getWidth", _wrap_ShortPixels_getWidth}, - { "getHeight", _wrap_ShortPixels_getHeight}, - { "getBytesPerPixel", _wrap_ShortPixels_getBytesPerPixel}, - { "getBitsPerPixel", _wrap_ShortPixels_getBitsPerPixel}, - { "getBytesPerChannel", _wrap_ShortPixels_getBytesPerChannel}, - { "getBitsPerChannel", _wrap_ShortPixels_getBitsPerChannel}, - { "getBytesStride", _wrap_ShortPixels_getBytesStride}, - { "getNumChannels", _wrap_ShortPixels_getNumChannels}, - { "getTotalBytes", _wrap_ShortPixels_getTotalBytes}, - { "getNumPlanes", _wrap_ShortPixels_getNumPlanes}, - { "getPlane", _wrap_ShortPixels_getPlane}, - { "getChannel", _wrap_ShortPixels_getChannel}, - { "getPixelFormat", _wrap_ShortPixels_getPixelFormat}, - { "size", _wrap_ShortPixels_size}, - { "getImageType", _wrap_ShortPixels_getImageType}, - { "setChannel", _wrap_ShortPixels_setChannel}, - { "setImageType", _wrap_ShortPixels_setImageType}, - { "setNumChannels", _wrap_ShortPixels_setNumChannels}, - {0,0} -}; -static swig_lua_method swig_ShortPixels_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_ShortPixels_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_ShortPixels_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_ShortPixels_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_ShortPixels_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_ShortPixels_Sf_SwigStatic = { - "ShortPixels", - swig_ShortPixels_Sf_SwigStatic_methods, - swig_ShortPixels_Sf_SwigStatic_attributes, - swig_ShortPixels_Sf_SwigStatic_constants, - swig_ShortPixels_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_ShortPixels_bases[] = {0}; -static const char *swig_ShortPixels_base_names[] = {0}; -static swig_lua_class _wrap_class_ShortPixels = { "ShortPixels", "ShortPixels", &SWIGTYPE_p_ofPixels_T_unsigned_short_t,_proxy__wrap_new_ShortPixels, swig_delete_ShortPixels, swig_ShortPixels_methods, swig_ShortPixels_attributes, &swig_ShortPixels_Sf_SwigStatic, swig_ShortPixels_meta, swig_ShortPixels_bases, swig_ShortPixels_base_names }; - -static int _wrap_new_Path(lua_State* L) { int SWIG_arg = 0; ofPath *result = 0 ; SWIG_check_num_args("ofPath::ofPath",0,0) - result = (ofPath *)new ofPath(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofPath,1); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_clear(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; - SWIG_check_num_args("ofPath::clear",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::clear",1,"ofPath *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_clear",1,SWIGTYPE_p_ofPath); } - (arg1)->clear(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_newSubPath(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; - SWIG_check_num_args("ofPath::newSubPath",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::newSubPath",1,"ofPath *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_newSubPath",1,SWIGTYPE_p_ofPath); } (arg1)->newSubPath(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Path_close(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; - SWIG_check_num_args("ofPath::close",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::close",1,"ofPath *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_close",1,SWIGTYPE_p_ofPath); } - (arg1)->close(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_lineTo__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; ofPoint *arg2 = 0 ; - SWIG_check_num_args("ofPath::lineTo",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::lineTo",1,"ofPath *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPath::lineTo",2,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_lineTo",1,SWIGTYPE_p_ofPath); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Path_lineTo",2,SWIGTYPE_p_ofVec3f); } - (arg1)->lineTo((ofPoint const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_lineTo__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofPath::lineTo",3,3) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::lineTo",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::lineTo",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::lineTo",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_lineTo",1,SWIGTYPE_p_ofPath); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); (arg1)->lineTo(arg2,arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_lineTo__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; float arg3 ; - float arg4 ; SWIG_check_num_args("ofPath::lineTo",4,4) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::lineTo",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::lineTo",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::lineTo",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPath::lineTo",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_lineTo",1,SWIGTYPE_p_ofPath); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - (arg1)->lineTo(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_lineTo(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Path_lineTo__SWIG_0(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Path_lineTo__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Path_lineTo__SWIG_2(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Path_lineTo'\n" " Possible C/C++ prototypes are:\n" - " ofPath::lineTo(ofPoint const &)\n" " ofPath::lineTo(float,float)\n" " ofPath::lineTo(float,float,float)\n"); - lua_error(L);return 0; } -static int _wrap_Path_moveTo__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; ofPoint *arg2 = 0 ; - SWIG_check_num_args("ofPath::moveTo",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::moveTo",1,"ofPath *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPath::moveTo",2,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_moveTo",1,SWIGTYPE_p_ofPath); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Path_moveTo",2,SWIGTYPE_p_ofVec3f); } - (arg1)->moveTo((ofPoint const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_moveTo__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; float arg3 ; - float arg4 ; SWIG_check_num_args("ofPath::moveTo",4,4) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::moveTo",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::moveTo",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::moveTo",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPath::moveTo",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_moveTo",1,SWIGTYPE_p_ofPath); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - (arg1)->moveTo(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_moveTo__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofPath::moveTo",3,3) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::moveTo",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::moveTo",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::moveTo",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_moveTo",1,SWIGTYPE_p_ofPath); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); (arg1)->moveTo(arg2,arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_moveTo(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Path_moveTo__SWIG_0(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Path_moveTo__SWIG_2(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Path_moveTo__SWIG_1(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Path_moveTo'\n" " Possible C/C++ prototypes are:\n" - " ofPath::moveTo(ofPoint const &)\n" " ofPath::moveTo(float,float,float)\n" " ofPath::moveTo(float,float)\n"); - lua_error(L);return 0; } -static int _wrap_Path_curveTo__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; ofPoint *arg2 = 0 ; - SWIG_check_num_args("ofPath::curveTo",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::curveTo",1,"ofPath *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPath::curveTo",2,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_curveTo",1,SWIGTYPE_p_ofPath); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Path_curveTo",2,SWIGTYPE_p_ofVec3f); } - (arg1)->curveTo((ofPoint const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_curveTo__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofPath::curveTo",3,3) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::curveTo",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::curveTo",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::curveTo",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_curveTo",1,SWIGTYPE_p_ofPath); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); (arg1)->curveTo(arg2,arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_curveTo__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; float arg3 ; - float arg4 ; SWIG_check_num_args("ofPath::curveTo",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::curveTo",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::curveTo",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::curveTo",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPath::curveTo",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_curveTo",1,SWIGTYPE_p_ofPath); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - (arg1)->curveTo(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_curveTo(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Path_curveTo__SWIG_0(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Path_curveTo__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Path_curveTo__SWIG_2(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Path_curveTo'\n" " Possible C/C++ prototypes are:\n" - " ofPath::curveTo(ofPoint const &)\n" " ofPath::curveTo(float,float)\n" " ofPath::curveTo(float,float,float)\n"); - lua_error(L);return 0; } -static int _wrap_Path_bezierTo__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; ofPoint *arg2 = 0 ; - ofPoint *arg3 = 0 ; ofPoint *arg4 = 0 ; SWIG_check_num_args("ofPath::bezierTo",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::bezierTo",1,"ofPath *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPath::bezierTo",2,"ofPoint const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofPath::bezierTo",3,"ofPoint const &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofPath::bezierTo",4,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_bezierTo",1,SWIGTYPE_p_ofPath); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Path_bezierTo",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Path_bezierTo",3,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Path_bezierTo",4,SWIGTYPE_p_ofVec3f); } - (arg1)->bezierTo((ofPoint const &)*arg2,(ofPoint const &)*arg3,(ofPoint const &)*arg4); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_bezierTo__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; float arg3 ; - float arg4 ; float arg5 ; float arg6 ; float arg7 ; SWIG_check_num_args("ofPath::bezierTo",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::bezierTo",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::bezierTo",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::bezierTo",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPath::bezierTo",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPath::bezierTo",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPath::bezierTo",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPath::bezierTo",7,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_bezierTo",1,SWIGTYPE_p_ofPath); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); - (arg1)->bezierTo(arg2,arg3,arg4,arg5,arg6,arg7); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_bezierTo__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; float arg3 ; - float arg4 ; float arg5 ; float arg6 ; float arg7 ; float arg8 ; float arg9 ; float arg10 ; - SWIG_check_num_args("ofPath::bezierTo",10,10) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::bezierTo",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::bezierTo",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::bezierTo",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPath::bezierTo",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPath::bezierTo",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPath::bezierTo",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPath::bezierTo",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofPath::bezierTo",8,"float"); - if(!lua_isnumber(L,9)) SWIG_fail_arg("ofPath::bezierTo",9,"float"); - if(!lua_isnumber(L,10)) SWIG_fail_arg("ofPath::bezierTo",10,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_bezierTo",1,SWIGTYPE_p_ofPath); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); - arg8 = (float)lua_tonumber(L, 8); arg9 = (float)lua_tonumber(L, 9); arg10 = (float)lua_tonumber(L, 10); - (arg1)->bezierTo(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Path_bezierTo(lua_State* L) { int argc; int argv[11]={ 1,2,3,4,5,6,7,8,9,10,11} ; argc = lua_gettop(L); - if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Path_bezierTo__SWIG_0(L);} } } } } if (argc == 7) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { - return _wrap_Path_bezierTo__SWIG_1(L);} } } } } } } } if (argc == 10) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { { _v = lua_isnumber(L,argv[8]); } if (_v) { { - _v = lua_isnumber(L,argv[9]); } if (_v) { return _wrap_Path_bezierTo__SWIG_2(L);} } } } } } } } - } } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Path_bezierTo'\n" - " Possible C/C++ prototypes are:\n" " ofPath::bezierTo(ofPoint const &,ofPoint const &,ofPoint const &)\n" - " ofPath::bezierTo(float,float,float,float,float,float)\n" - " ofPath::bezierTo(float,float,float,float,float,float,float,float,float)\n"); lua_error(L);return 0; } -static int _wrap_Path_quadBezierTo__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; ofPoint *arg2 = 0 ; - ofPoint *arg3 = 0 ; ofPoint *arg4 = 0 ; SWIG_check_num_args("ofPath::quadBezierTo",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::quadBezierTo",1,"ofPath *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPath::quadBezierTo",2,"ofPoint const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofPath::quadBezierTo",3,"ofPoint const &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofPath::quadBezierTo",4,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_quadBezierTo",1,SWIGTYPE_p_ofPath); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Path_quadBezierTo",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Path_quadBezierTo",3,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Path_quadBezierTo",4,SWIGTYPE_p_ofVec3f); } - (arg1)->quadBezierTo((ofPoint const &)*arg2,(ofPoint const &)*arg3,(ofPoint const &)*arg4); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_quadBezierTo__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; - float arg3 ; float arg4 ; float arg5 ; float arg6 ; float arg7 ; SWIG_check_num_args("ofPath::quadBezierTo",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::quadBezierTo",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::quadBezierTo",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::quadBezierTo",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPath::quadBezierTo",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPath::quadBezierTo",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPath::quadBezierTo",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPath::quadBezierTo",7,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_quadBezierTo",1,SWIGTYPE_p_ofPath); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); (arg1)->quadBezierTo(arg2,arg3,arg4,arg5,arg6,arg7); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_quadBezierTo__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; - float arg3 ; float arg4 ; float arg5 ; float arg6 ; float arg7 ; float arg8 ; float arg9 ; float arg10 ; - SWIG_check_num_args("ofPath::quadBezierTo",10,10) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::quadBezierTo",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::quadBezierTo",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::quadBezierTo",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPath::quadBezierTo",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPath::quadBezierTo",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPath::quadBezierTo",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPath::quadBezierTo",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofPath::quadBezierTo",8,"float"); - if(!lua_isnumber(L,9)) SWIG_fail_arg("ofPath::quadBezierTo",9,"float"); - if(!lua_isnumber(L,10)) SWIG_fail_arg("ofPath::quadBezierTo",10,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_quadBezierTo",1,SWIGTYPE_p_ofPath); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (float)lua_tonumber(L, 8); - arg9 = (float)lua_tonumber(L, 9); arg10 = (float)lua_tonumber(L, 10); - (arg1)->quadBezierTo(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Path_quadBezierTo(lua_State* L) { int argc; int argv[11]={ 1,2,3,4,5,6,7,8,9,10,11} ; argc = lua_gettop(L); - if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Path_quadBezierTo__SWIG_0(L);} } } } } if (argc == 7) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { - return _wrap_Path_quadBezierTo__SWIG_1(L);} } } } } } } } if (argc == 10) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { { _v = lua_isnumber(L,argv[8]); } if (_v) { { - _v = lua_isnumber(L,argv[9]); } if (_v) { return _wrap_Path_quadBezierTo__SWIG_2(L);} } } } } } } - } } } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Path_quadBezierTo'\n" - " Possible C/C++ prototypes are:\n" " ofPath::quadBezierTo(ofPoint const &,ofPoint const &,ofPoint const &)\n" - " ofPath::quadBezierTo(float,float,float,float,float,float)\n" - " ofPath::quadBezierTo(float,float,float,float,float,float,float,float,float)\n"); lua_error(L);return 0; } -static int _wrap_Path_arc__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; ofPoint *arg2 = 0 ; - float arg3 ; float arg4 ; float arg5 ; float arg6 ; SWIG_check_num_args("ofPath::arc",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::arc",1,"ofPath *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPath::arc",2,"ofPoint const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::arc",3,"float"); if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPath::arc",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPath::arc",5,"float"); if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPath::arc",6,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_arc",1,SWIGTYPE_p_ofPath); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Path_arc",2,SWIGTYPE_p_ofVec3f); } - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); (arg1)->arc((ofPoint const &)*arg2,arg3,arg4,arg5,arg6); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_arc__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; ofPoint *arg2 = 0 ; - float arg3 ; float arg4 ; float arg5 ; float arg6 ; bool arg7 ; SWIG_check_num_args("ofPath::arc",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::arc",1,"ofPath *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPath::arc",2,"ofPoint const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::arc",3,"float"); if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPath::arc",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPath::arc",5,"float"); if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPath::arc",6,"float"); - if(!lua_isboolean(L,7)) SWIG_fail_arg("ofPath::arc",7,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_arc",1,SWIGTYPE_p_ofPath); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Path_arc",2,SWIGTYPE_p_ofVec3f); } - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (lua_toboolean(L, 7)!=0); - (arg1)->arc((ofPoint const &)*arg2,arg3,arg4,arg5,arg6,arg7); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Path_arc__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; float arg3 ; - float arg4 ; float arg5 ; float arg6 ; float arg7 ; SWIG_check_num_args("ofPath::arc",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::arc",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::arc",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::arc",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPath::arc",4,"float"); if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPath::arc",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPath::arc",6,"float"); if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPath::arc",7,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_arc",1,SWIGTYPE_p_ofPath); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); - (arg1)->arc(arg2,arg3,arg4,arg5,arg6,arg7); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_arc__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; float arg3 ; - float arg4 ; float arg5 ; float arg6 ; float arg7 ; float arg8 ; SWIG_check_num_args("ofPath::arc",8,8) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::arc",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::arc",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::arc",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPath::arc",4,"float"); if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPath::arc",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPath::arc",6,"float"); if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPath::arc",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofPath::arc",8,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_arc",1,SWIGTYPE_p_ofPath); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); - arg8 = (float)lua_tonumber(L, 8); (arg1)->arc(arg2,arg3,arg4,arg5,arg6,arg7,arg8); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Path_arc(lua_State* L) { int argc; int argv[9]={ 1,2,3,4,5,6,7,8,9} ; argc = lua_gettop(L); if (argc == 6) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { - return _wrap_Path_arc__SWIG_0(L);} } } } } } } if (argc == 7) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { { - _v = lua_isboolean(L,argv[6]); } if (_v) { return _wrap_Path_arc__SWIG_1(L);} } } } } } } } - if (argc == 7) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { - return _wrap_Path_arc__SWIG_2(L);} } } } } } } } if (argc == 8) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { return _wrap_Path_arc__SWIG_3(L);} } } } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Path_arc'\n" " Possible C/C++ prototypes are:\n" - " ofPath::arc(ofPoint const &,float,float,float,float)\n" " ofPath::arc(ofPoint const &,float,float,float,float,bool)\n" - " ofPath::arc(float,float,float,float,float,float)\n" " ofPath::arc(float,float,float,float,float,float,float)\n"); - lua_error(L);return 0; } -static int _wrap_Path_arcNegative__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; ofPoint *arg2 = 0 ; - float arg3 ; float arg4 ; float arg5 ; float arg6 ; SWIG_check_num_args("ofPath::arcNegative",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::arcNegative",1,"ofPath *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPath::arcNegative",2,"ofPoint const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::arcNegative",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPath::arcNegative",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPath::arcNegative",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPath::arcNegative",6,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_arcNegative",1,SWIGTYPE_p_ofPath); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Path_arcNegative",2,SWIGTYPE_p_ofVec3f); } arg3 = (float)lua_tonumber(L, 3); - arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); - (arg1)->arcNegative((ofPoint const &)*arg2,arg3,arg4,arg5,arg6); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Path_arcNegative__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; - float arg3 ; float arg4 ; float arg5 ; float arg6 ; float arg7 ; SWIG_check_num_args("ofPath::arcNegative",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::arcNegative",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::arcNegative",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::arcNegative",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPath::arcNegative",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPath::arcNegative",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPath::arcNegative",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPath::arcNegative",7,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_arcNegative",1,SWIGTYPE_p_ofPath); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); (arg1)->arcNegative(arg2,arg3,arg4,arg5,arg6,arg7); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_arcNegative__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; - float arg3 ; float arg4 ; float arg5 ; float arg6 ; float arg7 ; float arg8 ; SWIG_check_num_args("ofPath::arcNegative",8,8) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::arcNegative",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::arcNegative",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::arcNegative",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPath::arcNegative",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPath::arcNegative",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPath::arcNegative",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPath::arcNegative",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofPath::arcNegative",8,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_arcNegative",1,SWIGTYPE_p_ofPath); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (float)lua_tonumber(L, 8); - (arg1)->arcNegative(arg2,arg3,arg4,arg5,arg6,arg7,arg8); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Path_arcNegative(lua_State* L) { int argc; int argv[9]={ 1,2,3,4,5,6,7,8,9} ; argc = lua_gettop(L); - if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { - return _wrap_Path_arcNegative__SWIG_0(L);} } } } } } } if (argc == 7) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { - return _wrap_Path_arcNegative__SWIG_1(L);} } } } } } } } if (argc == 8) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { return _wrap_Path_arcNegative__SWIG_2(L);} } } } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Path_arcNegative'\n" " Possible C/C++ prototypes are:\n" - " ofPath::arcNegative(ofPoint const &,float,float,float,float)\n" - " ofPath::arcNegative(float,float,float,float,float,float)\n" - " ofPath::arcNegative(float,float,float,float,float,float,float)\n"); lua_error(L);return 0; } -static int _wrap_Path_triangle__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; float arg3 ; - float arg4 ; float arg5 ; float arg6 ; float arg7 ; SWIG_check_num_args("ofPath::triangle",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::triangle",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::triangle",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::triangle",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPath::triangle",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPath::triangle",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPath::triangle",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPath::triangle",7,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_triangle",1,SWIGTYPE_p_ofPath); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); - (arg1)->triangle(arg2,arg3,arg4,arg5,arg6,arg7); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_triangle__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; float arg3 ; - float arg4 ; float arg5 ; float arg6 ; float arg7 ; float arg8 ; float arg9 ; float arg10 ; - SWIG_check_num_args("ofPath::triangle",10,10) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::triangle",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::triangle",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::triangle",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPath::triangle",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPath::triangle",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPath::triangle",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPath::triangle",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofPath::triangle",8,"float"); - if(!lua_isnumber(L,9)) SWIG_fail_arg("ofPath::triangle",9,"float"); - if(!lua_isnumber(L,10)) SWIG_fail_arg("ofPath::triangle",10,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_triangle",1,SWIGTYPE_p_ofPath); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); - arg8 = (float)lua_tonumber(L, 8); arg9 = (float)lua_tonumber(L, 9); arg10 = (float)lua_tonumber(L, 10); - (arg1)->triangle(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Path_triangle__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; ofPoint *arg2 = 0 ; - ofPoint *arg3 = 0 ; ofPoint *arg4 = 0 ; SWIG_check_num_args("ofPath::triangle",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::triangle",1,"ofPath *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPath::triangle",2,"ofPoint const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofPath::triangle",3,"ofPoint const &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofPath::triangle",4,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_triangle",1,SWIGTYPE_p_ofPath); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Path_triangle",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Path_triangle",3,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Path_triangle",4,SWIGTYPE_p_ofVec3f); } - (arg1)->triangle((ofPoint const &)*arg2,(ofPoint const &)*arg3,(ofPoint const &)*arg4); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_triangle(lua_State* L) { int argc; int argv[11]={ 1,2,3,4,5,6,7,8,9,10,11} ; argc = lua_gettop(L); - if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Path_triangle__SWIG_2(L);} } } } } if (argc == 7) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { - return _wrap_Path_triangle__SWIG_0(L);} } } } } } } } if (argc == 10) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { { _v = lua_isnumber(L,argv[8]); } if (_v) { { - _v = lua_isnumber(L,argv[9]); } if (_v) { return _wrap_Path_triangle__SWIG_1(L);} } } } } } } } - } } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Path_triangle'\n" - " Possible C/C++ prototypes are:\n" " ofPath::triangle(float,float,float,float,float,float)\n" - " ofPath::triangle(float,float,float,float,float,float,float,float,float)\n" - " ofPath::triangle(ofPoint const &,ofPoint const &,ofPoint const &)\n"); lua_error(L);return 0; } -static int _wrap_Path_circle__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; float arg3 ; - float arg4 ; SWIG_check_num_args("ofPath::circle",4,4) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::circle",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::circle",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::circle",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPath::circle",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_circle",1,SWIGTYPE_p_ofPath); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - (arg1)->circle(arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_circle__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; float arg3 ; - float arg4 ; float arg5 ; SWIG_check_num_args("ofPath::circle",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::circle",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::circle",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::circle",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPath::circle",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPath::circle",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_circle",1,SWIGTYPE_p_ofPath); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); (arg1)->circle(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Path_circle__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; ofPoint *arg2 = 0 ; - float arg3 ; SWIG_check_num_args("ofPath::circle",3,3) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::circle",1,"ofPath *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPath::circle",2,"ofPoint const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::circle",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_circle",1,SWIGTYPE_p_ofPath); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Path_circle",2,SWIGTYPE_p_ofVec3f); } - arg3 = (float)lua_tonumber(L, 3); (arg1)->circle((ofPoint const &)*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Path_circle(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Path_circle__SWIG_2(L);} } } - } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Path_circle__SWIG_0(L);} } } } } if (argc == 5) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Path_circle__SWIG_1(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Path_circle'\n" " Possible C/C++ prototypes are:\n" - " ofPath::circle(float,float,float)\n" " ofPath::circle(float,float,float,float)\n" - " ofPath::circle(ofPoint const &,float)\n"); lua_error(L);return 0; } -static int _wrap_Path_ellipse__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; float arg3 ; - float arg4 ; float arg5 ; SWIG_check_num_args("ofPath::ellipse",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::ellipse",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::ellipse",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::ellipse",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPath::ellipse",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPath::ellipse",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_ellipse",1,SWIGTYPE_p_ofPath); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); (arg1)->ellipse(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Path_ellipse__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; float arg3 ; - float arg4 ; float arg5 ; float arg6 ; SWIG_check_num_args("ofPath::ellipse",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::ellipse",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::ellipse",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::ellipse",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPath::ellipse",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPath::ellipse",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPath::ellipse",6,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_ellipse",1,SWIGTYPE_p_ofPath); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); (arg1)->ellipse(arg2,arg3,arg4,arg5,arg6); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_ellipse__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; ofPoint *arg2 = 0 ; - float arg3 ; float arg4 ; SWIG_check_num_args("ofPath::ellipse",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::ellipse",1,"ofPath *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPath::ellipse",2,"ofPoint const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::ellipse",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPath::ellipse",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_ellipse",1,SWIGTYPE_p_ofPath); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Path_ellipse",2,SWIGTYPE_p_ofVec3f); } - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); (arg1)->ellipse((ofPoint const &)*arg2,arg3,arg4); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_ellipse(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); if (argc == 4) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Path_ellipse__SWIG_2(L);} } } } } if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Path_ellipse__SWIG_0(L);} } } } } } if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { return _wrap_Path_ellipse__SWIG_1(L);} } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Path_ellipse'\n" " Possible C/C++ prototypes are:\n" - " ofPath::ellipse(float,float,float,float)\n" " ofPath::ellipse(float,float,float,float,float)\n" - " ofPath::ellipse(ofPoint const &,float,float)\n"); lua_error(L);return 0; } -static int _wrap_Path_rectangle__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; ofRectangle *arg2 = 0 ; - SWIG_check_num_args("ofPath::rectangle",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::rectangle",1,"ofPath *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPath::rectangle",2,"ofRectangle const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_rectangle",1,SWIGTYPE_p_ofPath); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Path_rectangle",2,SWIGTYPE_p_ofRectangle); } (arg1)->rectangle((ofRectangle const &)*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_rectangle__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; ofPoint *arg2 = 0 ; - float arg3 ; float arg4 ; SWIG_check_num_args("ofPath::rectangle",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::rectangle",1,"ofPath *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPath::rectangle",2,"ofPoint const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::rectangle",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPath::rectangle",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_rectangle",1,SWIGTYPE_p_ofPath); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Path_rectangle",2,SWIGTYPE_p_ofVec3f); } arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - (arg1)->rectangle((ofPoint const &)*arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_rectangle__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; - float arg3 ; float arg4 ; float arg5 ; SWIG_check_num_args("ofPath::rectangle",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::rectangle",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::rectangle",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::rectangle",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPath::rectangle",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPath::rectangle",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_rectangle",1,SWIGTYPE_p_ofPath); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); (arg1)->rectangle(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Path_rectangle__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; - float arg3 ; float arg4 ; float arg5 ; float arg6 ; SWIG_check_num_args("ofPath::rectangle",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::rectangle",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::rectangle",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::rectangle",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPath::rectangle",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPath::rectangle",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPath::rectangle",6,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_rectangle",1,SWIGTYPE_p_ofPath); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); (arg1)->rectangle(arg2,arg3,arg4,arg5,arg6); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_rectangle(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Path_rectangle__SWIG_0(L);} } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Path_rectangle__SWIG_1(L);} } } } } if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Path_rectangle__SWIG_2(L);} } } } } } if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { return _wrap_Path_rectangle__SWIG_3(L);} } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Path_rectangle'\n" " Possible C/C++ prototypes are:\n" - " ofPath::rectangle(ofRectangle const &)\n" " ofPath::rectangle(ofPoint const &,float,float)\n" - " ofPath::rectangle(float,float,float,float)\n" " ofPath::rectangle(float,float,float,float,float)\n"); - lua_error(L);return 0; } -static int _wrap_Path_rectRounded__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; - ofRectangle *arg2 = 0 ; float arg3 ; SWIG_check_num_args("ofPath::rectRounded",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::rectRounded",1,"ofPath *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPath::rectRounded",2,"ofRectangle const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::rectRounded",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_rectRounded",1,SWIGTYPE_p_ofPath); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Path_rectRounded",2,SWIGTYPE_p_ofRectangle); } arg3 = (float)lua_tonumber(L, 3); - (arg1)->rectRounded((ofRectangle const &)*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_rectRounded__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; ofPoint *arg2 = 0 ; - float arg3 ; float arg4 ; float arg5 ; SWIG_check_num_args("ofPath::rectRounded",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::rectRounded",1,"ofPath *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPath::rectRounded",2,"ofPoint const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::rectRounded",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPath::rectRounded",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPath::rectRounded",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_rectRounded",1,SWIGTYPE_p_ofPath); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Path_rectRounded",2,SWIGTYPE_p_ofVec3f); } arg3 = (float)lua_tonumber(L, 3); - arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - (arg1)->rectRounded((ofPoint const &)*arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Path_rectRounded__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; - float arg3 ; float arg4 ; float arg5 ; float arg6 ; SWIG_check_num_args("ofPath::rectRounded",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::rectRounded",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::rectRounded",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::rectRounded",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPath::rectRounded",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPath::rectRounded",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPath::rectRounded",6,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_rectRounded",1,SWIGTYPE_p_ofPath); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); (arg1)->rectRounded(arg2,arg3,arg4,arg5,arg6); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Path_rectRounded__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; ofPoint *arg2 = 0 ; - float arg3 ; float arg4 ; float arg5 ; float arg6 ; float arg7 ; float arg8 ; SWIG_check_num_args("ofPath::rectRounded",8,8) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::rectRounded",1,"ofPath *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPath::rectRounded",2,"ofPoint const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::rectRounded",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPath::rectRounded",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPath::rectRounded",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPath::rectRounded",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPath::rectRounded",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofPath::rectRounded",8,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_rectRounded",1,SWIGTYPE_p_ofPath); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Path_rectRounded",2,SWIGTYPE_p_ofVec3f); } arg3 = (float)lua_tonumber(L, 3); - arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); - arg7 = (float)lua_tonumber(L, 7); arg8 = (float)lua_tonumber(L, 8); - (arg1)->rectRounded((ofPoint const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Path_rectRounded__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; - ofRectangle *arg2 = 0 ; float arg3 ; float arg4 ; float arg5 ; float arg6 ; SWIG_check_num_args("ofPath::rectRounded",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::rectRounded",1,"ofPath *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPath::rectRounded",2,"ofRectangle const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::rectRounded",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPath::rectRounded",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPath::rectRounded",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPath::rectRounded",6,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_rectRounded",1,SWIGTYPE_p_ofPath); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Path_rectRounded",2,SWIGTYPE_p_ofRectangle); } arg3 = (float)lua_tonumber(L, 3); - arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); - (arg1)->rectRounded((ofRectangle const &)*arg2,arg3,arg4,arg5,arg6); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Path_rectRounded__SWIG_5(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; - float arg3 ; float arg4 ; float arg5 ; float arg6 ; float arg7 ; float arg8 ; float arg9 ; float arg10 ; - SWIG_check_num_args("ofPath::rectRounded",10,10) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::rectRounded",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::rectRounded",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::rectRounded",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPath::rectRounded",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPath::rectRounded",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPath::rectRounded",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPath::rectRounded",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofPath::rectRounded",8,"float"); - if(!lua_isnumber(L,9)) SWIG_fail_arg("ofPath::rectRounded",9,"float"); - if(!lua_isnumber(L,10)) SWIG_fail_arg("ofPath::rectRounded",10,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_rectRounded",1,SWIGTYPE_p_ofPath); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (float)lua_tonumber(L, 8); - arg9 = (float)lua_tonumber(L, 9); arg10 = (float)lua_tonumber(L, 10); - (arg1)->rectRounded(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Path_rectRounded(lua_State* L) { int argc; int argv[11]={ 1,2,3,4,5,6,7,8,9,10,11} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Path_rectRounded__SWIG_0(L);} - } } } if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_Path_rectRounded__SWIG_1(L);} } } } } } - if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { - return _wrap_Path_rectRounded__SWIG_4(L);} } } } } } } if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { return _wrap_Path_rectRounded__SWIG_2(L);} } } } } } } - if (argc == 8) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { { - _v = lua_isnumber(L,argv[6]); } if (_v) { { _v = lua_isnumber(L,argv[7]); } if (_v) { - return _wrap_Path_rectRounded__SWIG_3(L);} } } } } } } } } if (argc == 10) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { { _v = lua_isnumber(L,argv[8]); } if (_v) { { - _v = lua_isnumber(L,argv[9]); } if (_v) { return _wrap_Path_rectRounded__SWIG_5(L);} } } } } } } - } } } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Path_rectRounded'\n" - " Possible C/C++ prototypes are:\n" " ofPath::rectRounded(ofRectangle const &,float)\n" - " ofPath::rectRounded(ofPoint const &,float,float,float)\n" " ofPath::rectRounded(float,float,float,float,float)\n" - " ofPath::rectRounded(ofPoint const &,float,float,float,float,float,float)\n" - " ofPath::rectRounded(ofRectangle const &,float,float,float,float)\n" - " ofPath::rectRounded(float,float,float,float,float,float,float,float,float)\n"); lua_error(L);return 0; } -static int _wrap_Path_setPolyWindingMode(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; - ofPolyWindingMode arg2 ; SWIG_check_num_args("ofPath::setPolyWindingMode",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::setPolyWindingMode",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::setPolyWindingMode",2,"ofPolyWindingMode"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_setPolyWindingMode",1,SWIGTYPE_p_ofPath); } arg2 = (ofPolyWindingMode)(int)lua_tonumber(L, 2); - (arg1)->setPolyWindingMode(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_getWindingMode(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; ofPolyWindingMode result; - SWIG_check_num_args("ofPath::getWindingMode",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::getWindingMode",1,"ofPath const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_getWindingMode",1,SWIGTYPE_p_ofPath); } - result = (ofPolyWindingMode)((ofPath const *)arg1)->getWindingMode(); - lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Path_setFilled(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; bool arg2 ; - SWIG_check_num_args("ofPath::setFilled",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::setFilled",1,"ofPath *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofPath::setFilled",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_setFilled",1,SWIGTYPE_p_ofPath); } - arg2 = (lua_toboolean(L, 2)!=0); (arg1)->setFilled(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Path_setStrokeWidth(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; - SWIG_check_num_args("ofPath::setStrokeWidth",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::setStrokeWidth",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::setStrokeWidth",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_setStrokeWidth",1,SWIGTYPE_p_ofPath); } arg2 = (float)lua_tonumber(L, 2); (arg1)->setStrokeWidth(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_setColor(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; ofColor *arg2 = 0 ; - SWIG_check_num_args("ofPath::setColor",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::setColor",1,"ofPath *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPath::setColor",2,"ofColor const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_setColor",1,SWIGTYPE_p_ofPath); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Path_setColor",2,SWIGTYPE_p_ofColor_T_unsigned_char_t); } (arg1)->setColor((ofColor const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_setHexColor(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; int arg2 ; - SWIG_check_num_args("ofPath::setHexColor",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::setHexColor",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::setHexColor",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_setHexColor",1,SWIGTYPE_p_ofPath); } arg2 = (int)lua_tonumber(L, 2); (arg1)->setHexColor(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_setFillColor(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; ofColor *arg2 = 0 ; - SWIG_check_num_args("ofPath::setFillColor",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::setFillColor",1,"ofPath *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPath::setFillColor",2,"ofColor const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_setFillColor",1,SWIGTYPE_p_ofPath); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Path_setFillColor",2,SWIGTYPE_p_ofColor_T_unsigned_char_t); } (arg1)->setFillColor((ofColor const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_setFillHexColor(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; int arg2 ; - SWIG_check_num_args("ofPath::setFillHexColor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::setFillHexColor",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::setFillHexColor",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_setFillHexColor",1,SWIGTYPE_p_ofPath); } arg2 = (int)lua_tonumber(L, 2); (arg1)->setFillHexColor(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_setStrokeColor(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; ofColor *arg2 = 0 ; - SWIG_check_num_args("ofPath::setStrokeColor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::setStrokeColor",1,"ofPath *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPath::setStrokeColor",2,"ofColor const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_setStrokeColor",1,SWIGTYPE_p_ofPath); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Path_setStrokeColor",2,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - (arg1)->setStrokeColor((ofColor const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_setStrokeHexColor(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; int arg2 ; - SWIG_check_num_args("ofPath::setStrokeHexColor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::setStrokeHexColor",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::setStrokeHexColor",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_setStrokeHexColor",1,SWIGTYPE_p_ofPath); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->setStrokeHexColor(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_isFilled(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; bool result; - SWIG_check_num_args("ofPath::isFilled",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::isFilled",1,"ofPath const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_isFilled",1,SWIGTYPE_p_ofPath); } - result = (bool)((ofPath const *)arg1)->isFilled(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_getFillColor(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; ofColor result; - SWIG_check_num_args("ofPath::getFillColor",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::getFillColor",1,"ofPath const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_getFillColor",1,SWIGTYPE_p_ofPath); } result = ((ofPath const *)arg1)->getFillColor(); { - ofColor * resultptr = new ofColor((const ofColor &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_getStrokeColor(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; ofColor result; - SWIG_check_num_args("ofPath::getStrokeColor",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::getStrokeColor",1,"ofPath const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_getStrokeColor",1,SWIGTYPE_p_ofPath); } result = ((ofPath const *)arg1)->getStrokeColor(); { - ofColor * resultptr = new ofColor((const ofColor &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_getStrokeWidth(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float result; - SWIG_check_num_args("ofPath::getStrokeWidth",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::getStrokeWidth",1,"ofPath const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_getStrokeWidth",1,SWIGTYPE_p_ofPath); } result = (float)((ofPath const *)arg1)->getStrokeWidth(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_hasOutline(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; bool result; - SWIG_check_num_args("ofPath::hasOutline",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::hasOutline",1,"ofPath const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_hasOutline",1,SWIGTYPE_p_ofPath); } result = (bool)((ofPath const *)arg1)->hasOutline(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_setCurveResolution(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; int arg2 ; - SWIG_check_num_args("ofPath::setCurveResolution",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::setCurveResolution",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::setCurveResolution",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_setCurveResolution",1,SWIGTYPE_p_ofPath); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->setCurveResolution(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_getCurveResolution(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; int result; - SWIG_check_num_args("ofPath::getCurveResolution",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::getCurveResolution",1,"ofPath const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_getCurveResolution",1,SWIGTYPE_p_ofPath); } result = (int)((ofPath const *)arg1)->getCurveResolution(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_setCircleResolution(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; int arg2 ; - SWIG_check_num_args("ofPath::setCircleResolution",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::setCircleResolution",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::setCircleResolution",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_setCircleResolution",1,SWIGTYPE_p_ofPath); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->setCircleResolution(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_getCircleResolution(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; int result; - SWIG_check_num_args("ofPath::getCircleResolution",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::getCircleResolution",1,"ofPath const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_getCircleResolution",1,SWIGTYPE_p_ofPath); } - result = (int)((ofPath const *)arg1)->getCircleResolution(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_setUseShapeColor(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; bool arg2 ; - SWIG_check_num_args("ofPath::setUseShapeColor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::setUseShapeColor",1,"ofPath *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofPath::setUseShapeColor",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_setUseShapeColor",1,SWIGTYPE_p_ofPath); } arg2 = (lua_toboolean(L, 2)!=0); - (arg1)->setUseShapeColor(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_getUseShapeColor(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; bool result; - SWIG_check_num_args("ofPath::getUseShapeColor",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::getUseShapeColor",1,"ofPath const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_getUseShapeColor",1,SWIGTYPE_p_ofPath); } result = (bool)((ofPath const *)arg1)->getUseShapeColor(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_draw__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; - SWIG_check_num_args("ofPath::draw",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::draw",1,"ofPath const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_draw",1,SWIGTYPE_p_ofPath); } - ((ofPath const *)arg1)->draw(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_draw__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofPath::draw",3,3) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::draw",1,"ofPath const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::draw",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::draw",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_draw",1,SWIGTYPE_p_ofPath); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); ((ofPath const *)arg1)->draw(arg2,arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_draw(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Path_draw__SWIG_0(L);} } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Path_draw__SWIG_1(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Path_draw'\n" " Possible C/C++ prototypes are:\n" - " ofPath::draw() const\n" " ofPath::draw(float,float) const\n"); lua_error(L);return 0; } -static int _wrap_Path_getOutline(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; - std::vector< ofPolyline > *result = 0 ; SWIG_check_num_args("ofPath::getOutline",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::getOutline",1,"ofPath const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_getOutline",1,SWIGTYPE_p_ofPath); } - result = (std::vector< ofPolyline > *) &((ofPath const *)arg1)->getOutline(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofPolyline_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Path_tessellate(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; - SWIG_check_num_args("ofPath::tessellate",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::tessellate",1,"ofPath *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_tessellate",1,SWIGTYPE_p_ofPath); } (arg1)->tessellate(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Path_getTessellation(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; ofMesh *result = 0 ; - SWIG_check_num_args("ofPath::getTessellation",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::getTessellation",1,"ofPath const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_getTessellation",1,SWIGTYPE_p_ofPath); } - result = (ofMesh *) &((ofPath const *)arg1)->getTessellation(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMesh,0); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_simplify__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; - SWIG_check_num_args("ofPath::simplify",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::simplify",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::simplify",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_simplify",1,SWIGTYPE_p_ofPath); } - arg2 = (float)lua_tonumber(L, 2); (arg1)->simplify(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Path_simplify__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; - SWIG_check_num_args("ofPath::simplify",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::simplify",1,"ofPath *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_simplify",1,SWIGTYPE_p_ofPath); } - (arg1)->simplify(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_simplify(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Path_simplify__SWIG_1(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Path_simplify__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Path_simplify'\n" " Possible C/C++ prototypes are:\n" - " ofPath::simplify(float)\n" " ofPath::simplify()\n"); lua_error(L);return 0; } -static int _wrap_Path_translate(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; ofPoint *arg2 = 0 ; - SWIG_check_num_args("ofPath::translate",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::translate",1,"ofPath *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPath::translate",2,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_translate",1,SWIGTYPE_p_ofPath); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Path_translate",2,SWIGTYPE_p_ofVec3f); } (arg1)->translate((ofPoint const &)*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_rotate(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; ofVec3f *arg3 = 0 ; - SWIG_check_num_args("ofPath::rotate",3,3) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::rotate",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::rotate",2,"float"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofPath::rotate",3,"ofVec3f const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_rotate",1,SWIGTYPE_p_ofPath); } - arg2 = (float)lua_tonumber(L, 2); if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Path_rotate",3,SWIGTYPE_p_ofVec3f); } (arg1)->rotate(arg2,(ofVec3f const &)*arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_scale(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofPath::scale",3,3) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::scale",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::scale",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPath::scale",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_scale",1,SWIGTYPE_p_ofPath); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); (arg1)->scale(arg2,arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_append(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; ofPath *arg2 = 0 ; - SWIG_check_num_args("ofPath::append",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::append",1,"ofPath *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPath::append",2,"ofPath const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_append",1,SWIGTYPE_p_ofPath); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_append",2,SWIGTYPE_p_ofPath); } - (arg1)->append((ofPath const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_setMode(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; ofPath::Mode arg2 ; - SWIG_check_num_args("ofPath::setMode",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::setMode",1,"ofPath *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPath::setMode",2,"ofPath::Mode"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_setMode",1,SWIGTYPE_p_ofPath); } - arg2 = (ofPath::Mode)(int)lua_tonumber(L, 2); (arg1)->setMode(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Path_getMode(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; ofPath::Mode result; - SWIG_check_num_args("ofPath::getMode",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::getMode",1,"ofPath *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ SWIG_fail_ptr("Path_getMode",1,SWIGTYPE_p_ofPath); } - result = (ofPath::Mode)(arg1)->getMode(); lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Path_getCommands__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; - std::vector< ofPath::Command > *result = 0 ; SWIG_check_num_args("ofPath::getCommands",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::getCommands",1,"ofPath *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_getCommands",1,SWIGTYPE_p_ofPath); } - result = (std::vector< ofPath::Command > *) &(arg1)->getCommands(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofPath__Command_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Path_getCommands__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPath *arg1 = (ofPath *) 0 ; - std::vector< ofPath::Command > *result = 0 ; SWIG_check_num_args("ofPath::getCommands",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPath::getCommands",1,"ofPath const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPath,0))){ - SWIG_fail_ptr("Path_getCommands",1,SWIGTYPE_p_ofPath); } - result = (std::vector< ofPath::Command > *) &((ofPath const *)arg1)->getCommands(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofPath__Command_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Path_getCommands(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Path_getCommands__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPath, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Path_getCommands__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Path_getCommands'\n" " Possible C/C++ prototypes are:\n" - " ofPath::getCommands()\n" " ofPath::getCommands() const\n"); lua_error(L);return 0; } -static void swig_delete_Path(void *obj) { -ofPath *arg1 = (ofPath *) obj; -delete arg1; -} -static int _proxy__wrap_new_Path(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_Path); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_Path_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_Path_methods[]= { - { "clear", _wrap_Path_clear}, - { "newSubPath", _wrap_Path_newSubPath}, - { "close", _wrap_Path_close}, - { "lineTo", _wrap_Path_lineTo}, - { "moveTo", _wrap_Path_moveTo}, - { "curveTo", _wrap_Path_curveTo}, - { "bezierTo", _wrap_Path_bezierTo}, - { "quadBezierTo", _wrap_Path_quadBezierTo}, - { "arc", _wrap_Path_arc}, - { "arcNegative", _wrap_Path_arcNegative}, - { "triangle", _wrap_Path_triangle}, - { "circle", _wrap_Path_circle}, - { "ellipse", _wrap_Path_ellipse}, - { "rectangle", _wrap_Path_rectangle}, - { "rectRounded", _wrap_Path_rectRounded}, - { "setPolyWindingMode", _wrap_Path_setPolyWindingMode}, - { "getWindingMode", _wrap_Path_getWindingMode}, - { "setFilled", _wrap_Path_setFilled}, - { "setStrokeWidth", _wrap_Path_setStrokeWidth}, - { "setColor", _wrap_Path_setColor}, - { "setHexColor", _wrap_Path_setHexColor}, - { "setFillColor", _wrap_Path_setFillColor}, - { "setFillHexColor", _wrap_Path_setFillHexColor}, - { "setStrokeColor", _wrap_Path_setStrokeColor}, - { "setStrokeHexColor", _wrap_Path_setStrokeHexColor}, - { "isFilled", _wrap_Path_isFilled}, - { "getFillColor", _wrap_Path_getFillColor}, - { "getStrokeColor", _wrap_Path_getStrokeColor}, - { "getStrokeWidth", _wrap_Path_getStrokeWidth}, - { "hasOutline", _wrap_Path_hasOutline}, - { "setCurveResolution", _wrap_Path_setCurveResolution}, - { "getCurveResolution", _wrap_Path_getCurveResolution}, - { "setCircleResolution", _wrap_Path_setCircleResolution}, - { "getCircleResolution", _wrap_Path_getCircleResolution}, - { "setUseShapeColor", _wrap_Path_setUseShapeColor}, - { "getUseShapeColor", _wrap_Path_getUseShapeColor}, - { "draw", _wrap_Path_draw}, - { "getOutline", _wrap_Path_getOutline}, - { "tessellate", _wrap_Path_tessellate}, - { "getTessellation", _wrap_Path_getTessellation}, - { "simplify", _wrap_Path_simplify}, - { "translate", _wrap_Path_translate}, - { "rotate", _wrap_Path_rotate}, - { "scale", _wrap_Path_scale}, - { "append", _wrap_Path_append}, - { "setMode", _wrap_Path_setMode}, - { "getMode", _wrap_Path_getMode}, - { "getCommands", _wrap_Path_getCommands}, - {0,0} -}; -static swig_lua_method swig_Path_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_Path_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_Path_Sf_SwigStatic_constants[]= { - {SWIG_LUA_CONSTTAB_INT("COMMANDS", ofPath::COMMANDS)}, - {SWIG_LUA_CONSTTAB_INT("POLYLINES", ofPath::POLYLINES)}, - {0,0,0,0,0,0} -}; -static swig_lua_method swig_Path_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_Path_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_Path_Sf_SwigStatic = { - "Path", - swig_Path_Sf_SwigStatic_methods, - swig_Path_Sf_SwigStatic_attributes, - swig_Path_Sf_SwigStatic_constants, - swig_Path_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_Path_bases[] = {0}; -static const char *swig_Path_base_names[] = {0}; -static swig_lua_class _wrap_class_Path = { "Path", "Path", &SWIGTYPE_p_ofPath,_proxy__wrap_new_Path, swig_delete_Path, swig_Path_methods, swig_Path_attributes, &swig_Path_Sf_SwigStatic, swig_Path_meta, swig_Path_bases, swig_Path_base_names }; - -static int _wrap_new_Polyline__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPolyline *result = 0 ; - SWIG_check_num_args("ofPolyline::ofPolyline",0,0) result = (ofPolyline *)new ofPolyline(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofPolyline,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Polyline__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::vector< ofPoint > *arg1 = 0 ; - ofPolyline *result = 0 ; SWIG_check_num_args("ofPolyline::ofPolyline",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofPolyline::ofPolyline",1,"std::vector< ofPoint > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofVec3f_t,0))){ - SWIG_fail_ptr("new_Polyline",1,SWIGTYPE_p_std__vectorT_ofVec3f_t); } - result = (ofPolyline *)new ofPolyline((std::vector< ofPoint > const &)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofPolyline,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Polyline(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_Polyline__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_std__vectorT_ofVec3f_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_new_Polyline__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_Polyline'\n" " Possible C/C++ prototypes are:\n" - " ofPolyline::ofPolyline()\n" " ofPolyline::ofPolyline(std::vector< ofPoint > const &)\n"); lua_error(L);return 0; } -static int _wrap_Polyline_fromRectangle(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = 0 ; ofPolyline result; - SWIG_check_num_args("ofPolyline::fromRectangle",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofPolyline::fromRectangle",1,"ofRectangle const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Polyline_fromRectangle",1,SWIGTYPE_p_ofRectangle); } - result = ofPolyline::fromRectangle((ofRectangle const &)*arg1); { - ofPolyline * resultptr = new ofPolyline((const ofPolyline &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofPolyline,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_clear(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - SWIG_check_num_args("ofPolyline::clear",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::clear",1,"ofPolyline *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_clear",1,SWIGTYPE_p_ofPolyline); } (arg1)->clear(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_addVertex__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - ofPoint *arg2 = 0 ; SWIG_check_num_args("ofPolyline::addVertex",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::addVertex",1,"ofPolyline *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline::addVertex",2,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_addVertex",1,SWIGTYPE_p_ofPolyline); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Polyline_addVertex",2,SWIGTYPE_p_ofVec3f); } (arg1)->addVertex((ofPoint const &)*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_addVertex__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; float arg2 ; - float arg3 ; float arg4 ; SWIG_check_num_args("ofPolyline::addVertex",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::addVertex",1,"ofPolyline *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::addVertex",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::addVertex",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPolyline::addVertex",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_addVertex",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); (arg1)->addVertex(arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_addVertex__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; float arg2 ; - float arg3 ; SWIG_check_num_args("ofPolyline::addVertex",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::addVertex",1,"ofPolyline *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::addVertex",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::addVertex",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_addVertex",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->addVertex(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Polyline_addVertex(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Polyline_addVertex__SWIG_0(L);} } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_Polyline_addVertex__SWIG_2(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Polyline_addVertex__SWIG_1(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Polyline_addVertex'\n" " Possible C/C++ prototypes are:\n" - " ofPolyline::addVertex(ofPoint const &)\n" " ofPolyline::addVertex(float,float,float)\n" - " ofPolyline::addVertex(float,float)\n"); lua_error(L);return 0; } -static int _wrap_Polyline_addVertices__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - std::vector< ofPoint > *arg2 = 0 ; SWIG_check_num_args("ofPolyline::addVertices",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::addVertices",1,"ofPolyline *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline::addVertices",2,"std::vector< ofPoint > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_addVertices",1,SWIGTYPE_p_ofPolyline); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__vectorT_ofVec3f_t,0))){ - SWIG_fail_ptr("Polyline_addVertices",2,SWIGTYPE_p_std__vectorT_ofVec3f_t); } - (arg1)->addVertices((std::vector< ofPoint > const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Polyline_addVertices__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - ofPoint *arg2 = (ofPoint *) 0 ; int arg3 ; SWIG_check_num_args("ofPolyline::addVertices",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::addVertices",1,"ofPolyline *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofPolyline::addVertices",2,"ofPoint const *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::addVertices",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_addVertices",1,SWIGTYPE_p_ofPolyline); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Polyline_addVertices",2,SWIGTYPE_p_ofVec3f); } arg3 = (int)lua_tonumber(L, 3); - (arg1)->addVertices((ofPoint const *)arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_addVertices(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_std__vectorT_ofVec3f_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Polyline_addVertices__SWIG_0(L);} } } if (argc == 3) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Polyline_addVertices__SWIG_1(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Polyline_addVertices'\n" - " Possible C/C++ prototypes are:\n" " ofPolyline::addVertices(std::vector< ofPoint > const &)\n" - " ofPolyline::addVertices(ofPoint const *,int)\n"); lua_error(L);return 0; } -static int _wrap_Polyline_insertVertex__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - ofPoint *arg2 = 0 ; int arg3 ; SWIG_check_num_args("ofPolyline::insertVertex",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::insertVertex",1,"ofPolyline *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline::insertVertex",2,"ofPoint const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::insertVertex",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_insertVertex",1,SWIGTYPE_p_ofPolyline); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Polyline_insertVertex",2,SWIGTYPE_p_ofVec3f); } arg3 = (int)lua_tonumber(L, 3); - (arg1)->insertVertex((ofPoint const &)*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_insertVertex__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - float arg2 ; float arg3 ; float arg4 ; int arg5 ; SWIG_check_num_args("ofPolyline::insertVertex",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::insertVertex",1,"ofPolyline *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::insertVertex",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::insertVertex",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPolyline::insertVertex",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPolyline::insertVertex",5,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_insertVertex",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); - (arg1)->insertVertex(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_insertVertex(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Polyline_insertVertex__SWIG_0(L);} } } } if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Polyline_insertVertex__SWIG_1(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Polyline_insertVertex'\n" - " Possible C/C++ prototypes are:\n" " ofPolyline::insertVertex(ofPoint const &,int)\n" - " ofPolyline::insertVertex(float,float,float,int)\n"); lua_error(L);return 0; } -static int _wrap_Polyline_resize(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; size_t arg2 ; - SWIG_check_num_args("ofPolyline::resize",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::resize",1,"ofPolyline *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::resize",2,"size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_resize",1,SWIGTYPE_p_ofPolyline); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (size_t)lua_tonumber(L, 2); - (arg1)->resize(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_size(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; size_t result; - SWIG_check_num_args("ofPolyline::size",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::size",1,"ofPolyline const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_size",1,SWIGTYPE_p_ofPolyline); } result = (size_t)((ofPolyline const *)arg1)->size(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_getVertices__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - std::vector< ofPoint > *result = 0 ; SWIG_check_num_args("ofPolyline::getVertices",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::getVertices",1,"ofPolyline *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_getVertices",1,SWIGTYPE_p_ofPolyline); } - result = (std::vector< ofPoint > *) &(arg1)->getVertices(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofVec3f_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_getVertices__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - std::vector< ofPoint > *result = 0 ; SWIG_check_num_args("ofPolyline::getVertices",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::getVertices",1,"ofPolyline const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_getVertices",1,SWIGTYPE_p_ofPolyline); } - result = (std::vector< ofPoint > *) &((ofPolyline const *)arg1)->getVertices(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofVec3f_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_getVertices(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Polyline_getVertices__SWIG_0(L);} } if (argc == 1) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Polyline_getVertices__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Polyline_getVertices'\n" - " Possible C/C++ prototypes are:\n" " ofPolyline::getVertices()\n" " ofPolyline::getVertices() const\n"); - lua_error(L);return 0; } -static int _wrap_Polyline_lineTo__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - ofPoint *arg2 = 0 ; SWIG_check_num_args("ofPolyline::lineTo",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::lineTo",1,"ofPolyline *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline::lineTo",2,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_lineTo",1,SWIGTYPE_p_ofPolyline); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Polyline_lineTo",2,SWIGTYPE_p_ofVec3f); } (arg1)->lineTo((ofPoint const &)*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_lineTo__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; float arg2 ; - float arg3 ; float arg4 ; SWIG_check_num_args("ofPolyline::lineTo",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::lineTo",1,"ofPolyline *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::lineTo",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::lineTo",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPolyline::lineTo",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_lineTo",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); (arg1)->lineTo(arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_lineTo__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; float arg2 ; - float arg3 ; SWIG_check_num_args("ofPolyline::lineTo",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::lineTo",1,"ofPolyline *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::lineTo",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::lineTo",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_lineTo",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->lineTo(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Polyline_lineTo(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Polyline_lineTo__SWIG_0(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Polyline_lineTo__SWIG_2(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Polyline_lineTo__SWIG_1(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Polyline_lineTo'\n" " Possible C/C++ prototypes are:\n" - " ofPolyline::lineTo(ofPoint const &)\n" " ofPolyline::lineTo(float,float,float)\n" - " ofPolyline::lineTo(float,float)\n"); lua_error(L);return 0; } -static int _wrap_Polyline_arc__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - ofPoint *arg2 = 0 ; float arg3 ; float arg4 ; float arg5 ; float arg6 ; bool arg7 ; int arg8 ; - SWIG_check_num_args("ofPolyline::arc",8,8) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::arc",1,"ofPolyline *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline::arc",2,"ofPoint const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::arc",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPolyline::arc",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPolyline::arc",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPolyline::arc",6,"float"); - if(!lua_isboolean(L,7)) SWIG_fail_arg("ofPolyline::arc",7,"bool"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofPolyline::arc",8,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_arc",1,SWIGTYPE_p_ofPolyline); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Polyline_arc",2,SWIGTYPE_p_ofVec3f); } - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (lua_toboolean(L, 7)!=0); arg8 = (int)lua_tonumber(L, 8); - (arg1)->arc((ofPoint const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Polyline_arc__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - ofPoint *arg2 = 0 ; float arg3 ; float arg4 ; float arg5 ; float arg6 ; bool arg7 ; SWIG_check_num_args("ofPolyline::arc",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::arc",1,"ofPolyline *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline::arc",2,"ofPoint const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::arc",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPolyline::arc",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPolyline::arc",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPolyline::arc",6,"float"); - if(!lua_isboolean(L,7)) SWIG_fail_arg("ofPolyline::arc",7,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_arc",1,SWIGTYPE_p_ofPolyline); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Polyline_arc",2,SWIGTYPE_p_ofVec3f); } - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (lua_toboolean(L, 7)!=0); - (arg1)->arc((ofPoint const &)*arg2,arg3,arg4,arg5,arg6,arg7); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Polyline_arc__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - ofPoint *arg2 = 0 ; float arg3 ; float arg4 ; float arg5 ; float arg6 ; int arg7 ; SWIG_check_num_args("ofPolyline::arc",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::arc",1,"ofPolyline *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline::arc",2,"ofPoint const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::arc",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPolyline::arc",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPolyline::arc",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPolyline::arc",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPolyline::arc",7,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_arc",1,SWIGTYPE_p_ofPolyline); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Polyline_arc",2,SWIGTYPE_p_ofVec3f); } - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (int)lua_tonumber(L, 7); - (arg1)->arc((ofPoint const &)*arg2,arg3,arg4,arg5,arg6,arg7); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Polyline_arc__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - ofPoint *arg2 = 0 ; float arg3 ; float arg4 ; float arg5 ; float arg6 ; SWIG_check_num_args("ofPolyline::arc",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::arc",1,"ofPolyline *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline::arc",2,"ofPoint const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::arc",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPolyline::arc",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPolyline::arc",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPolyline::arc",6,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_arc",1,SWIGTYPE_p_ofPolyline); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("Polyline_arc",2,SWIGTYPE_p_ofVec3f); } - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); (arg1)->arc((ofPoint const &)*arg2,arg3,arg4,arg5,arg6); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_arc__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; float arg2 ; - float arg3 ; float arg4 ; float arg5 ; float arg6 ; float arg7 ; int arg8 ; SWIG_check_num_args("ofPolyline::arc",8,8) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::arc",1,"ofPolyline *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::arc",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::arc",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPolyline::arc",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPolyline::arc",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPolyline::arc",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPolyline::arc",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofPolyline::arc",8,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_arc",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (int)lua_tonumber(L, 8); - (arg1)->arc(arg2,arg3,arg4,arg5,arg6,arg7,arg8); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_arc__SWIG_5(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; float arg2 ; - float arg3 ; float arg4 ; float arg5 ; float arg6 ; float arg7 ; SWIG_check_num_args("ofPolyline::arc",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::arc",1,"ofPolyline *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::arc",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::arc",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPolyline::arc",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPolyline::arc",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPolyline::arc",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPolyline::arc",7,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_arc",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); (arg1)->arc(arg2,arg3,arg4,arg5,arg6,arg7); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_arc__SWIG_6(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; float arg2 ; - float arg3 ; float arg4 ; float arg5 ; float arg6 ; float arg7 ; float arg8 ; int arg9 ; - SWIG_check_num_args("ofPolyline::arc",9,9) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::arc",1,"ofPolyline *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::arc",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::arc",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPolyline::arc",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPolyline::arc",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPolyline::arc",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPolyline::arc",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofPolyline::arc",8,"float"); - if(!lua_isnumber(L,9)) SWIG_fail_arg("ofPolyline::arc",9,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_arc",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (float)lua_tonumber(L, 8); - arg9 = (int)lua_tonumber(L, 9); (arg1)->arc(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_arc(lua_State* L) { int argc; int argv[10]={ 1,2,3,4,5,6,7,8,9,10} ; argc = lua_gettop(L); - if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { - return _wrap_Polyline_arc__SWIG_3(L);} } } } } } } if (argc == 7) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { { - _v = lua_isboolean(L,argv[6]); } if (_v) { return _wrap_Polyline_arc__SWIG_1(L);} } } } } } } } - if (argc == 7) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { { - _v = lua_isnumber(L,argv[6]); } if (_v) { return _wrap_Polyline_arc__SWIG_2(L);} } } } } } } } - if (argc == 7) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { - return _wrap_Polyline_arc__SWIG_5(L);} } } } } } } } if (argc == 8) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { { - _v = lua_isboolean(L,argv[6]); } if (_v) { { _v = lua_isnumber(L,argv[7]); } if (_v) { - return _wrap_Polyline_arc__SWIG_0(L);} } } } } } } } } if (argc == 8) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { return _wrap_Polyline_arc__SWIG_4(L);} } } } } } } } } - if (argc == 9) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { { _v = lua_isnumber(L,argv[8]); } if (_v) { - return _wrap_Polyline_arc__SWIG_6(L);} } } } } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Polyline_arc'\n" " Possible C/C++ prototypes are:\n" - " ofPolyline::arc(ofPoint const &,float,float,float,float,bool,int)\n" - " ofPolyline::arc(ofPoint const &,float,float,float,float,bool)\n" - " ofPolyline::arc(ofPoint const &,float,float,float,float,int)\n" - " ofPolyline::arc(ofPoint const &,float,float,float,float)\n" - " ofPolyline::arc(float,float,float,float,float,float,int)\n" " ofPolyline::arc(float,float,float,float,float,float)\n" - " ofPolyline::arc(float,float,float,float,float,float,float,int)\n"); lua_error(L);return 0; } -static int _wrap_Polyline_arcNegative__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - ofPoint *arg2 = 0 ; float arg3 ; float arg4 ; float arg5 ; float arg6 ; int arg7 ; - SWIG_check_num_args("ofPolyline::arcNegative",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::arcNegative",1,"ofPolyline *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline::arcNegative",2,"ofPoint const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::arcNegative",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPolyline::arcNegative",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPolyline::arcNegative",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPolyline::arcNegative",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPolyline::arcNegative",7,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_arcNegative",1,SWIGTYPE_p_ofPolyline); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Polyline_arcNegative",2,SWIGTYPE_p_ofVec3f); } arg3 = (float)lua_tonumber(L, 3); - arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); - arg7 = (int)lua_tonumber(L, 7); (arg1)->arcNegative((ofPoint const &)*arg2,arg3,arg4,arg5,arg6,arg7); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_arcNegative__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - ofPoint *arg2 = 0 ; float arg3 ; float arg4 ; float arg5 ; float arg6 ; SWIG_check_num_args("ofPolyline::arcNegative",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::arcNegative",1,"ofPolyline *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline::arcNegative",2,"ofPoint const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::arcNegative",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPolyline::arcNegative",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPolyline::arcNegative",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPolyline::arcNegative",6,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_arcNegative",1,SWIGTYPE_p_ofPolyline); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Polyline_arcNegative",2,SWIGTYPE_p_ofVec3f); } arg3 = (float)lua_tonumber(L, 3); - arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); - (arg1)->arcNegative((ofPoint const &)*arg2,arg3,arg4,arg5,arg6); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Polyline_arcNegative__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - float arg2 ; float arg3 ; float arg4 ; float arg5 ; float arg6 ; float arg7 ; int arg8 ; - SWIG_check_num_args("ofPolyline::arcNegative",8,8) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::arcNegative",1,"ofPolyline *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::arcNegative",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::arcNegative",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPolyline::arcNegative",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPolyline::arcNegative",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPolyline::arcNegative",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPolyline::arcNegative",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofPolyline::arcNegative",8,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_arcNegative",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (int)lua_tonumber(L, 8); - (arg1)->arcNegative(arg2,arg3,arg4,arg5,arg6,arg7,arg8); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Polyline_arcNegative__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - float arg2 ; float arg3 ; float arg4 ; float arg5 ; float arg6 ; float arg7 ; - SWIG_check_num_args("ofPolyline::arcNegative",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::arcNegative",1,"ofPolyline *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::arcNegative",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::arcNegative",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPolyline::arcNegative",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPolyline::arcNegative",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPolyline::arcNegative",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPolyline::arcNegative",7,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_arcNegative",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); (arg1)->arcNegative(arg2,arg3,arg4,arg5,arg6,arg7); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_arcNegative__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - float arg2 ; float arg3 ; float arg4 ; float arg5 ; float arg6 ; float arg7 ; float arg8 ; int arg9 ; - SWIG_check_num_args("ofPolyline::arcNegative",9,9) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::arcNegative",1,"ofPolyline *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::arcNegative",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::arcNegative",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPolyline::arcNegative",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPolyline::arcNegative",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPolyline::arcNegative",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPolyline::arcNegative",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofPolyline::arcNegative",8,"float"); - if(!lua_isnumber(L,9)) SWIG_fail_arg("ofPolyline::arcNegative",9,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_arcNegative",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (float)lua_tonumber(L, 8); - arg9 = (int)lua_tonumber(L, 9); (arg1)->arcNegative(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_arcNegative(lua_State* L) { int argc; int argv[10]={ 1,2,3,4,5,6,7,8,9,10} ; argc = lua_gettop(L); - if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { - return _wrap_Polyline_arcNegative__SWIG_1(L);} } } } } } } if (argc == 7) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { { - _v = lua_isnumber(L,argv[6]); } if (_v) { return _wrap_Polyline_arcNegative__SWIG_0(L);} } } } } } } } - if (argc == 7) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { - return _wrap_Polyline_arcNegative__SWIG_3(L);} } } } } } } } if (argc == 8) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { return _wrap_Polyline_arcNegative__SWIG_2(L);} } } } } } } - } } if (argc == 9) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { { _v = lua_isnumber(L,argv[8]); } if (_v) { - return _wrap_Polyline_arcNegative__SWIG_4(L);} } } } } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Polyline_arcNegative'\n" - " Possible C/C++ prototypes are:\n" " ofPolyline::arcNegative(ofPoint const &,float,float,float,float,int)\n" - " ofPolyline::arcNegative(ofPoint const &,float,float,float,float)\n" - " ofPolyline::arcNegative(float,float,float,float,float,float,int)\n" - " ofPolyline::arcNegative(float,float,float,float,float,float)\n" - " ofPolyline::arcNegative(float,float,float,float,float,float,float,int)\n"); lua_error(L);return 0; } -static int _wrap_Polyline_curveTo__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - ofPoint *arg2 = 0 ; int arg3 ; SWIG_check_num_args("ofPolyline::curveTo",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::curveTo",1,"ofPolyline *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline::curveTo",2,"ofPoint const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::curveTo",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_curveTo",1,SWIGTYPE_p_ofPolyline); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Polyline_curveTo",2,SWIGTYPE_p_ofVec3f); } arg3 = (int)lua_tonumber(L, 3); - (arg1)->curveTo((ofPoint const &)*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_curveTo__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - ofPoint *arg2 = 0 ; SWIG_check_num_args("ofPolyline::curveTo",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::curveTo",1,"ofPolyline *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline::curveTo",2,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_curveTo",1,SWIGTYPE_p_ofPolyline); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Polyline_curveTo",2,SWIGTYPE_p_ofVec3f); } (arg1)->curveTo((ofPoint const &)*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_curveTo__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; float arg2 ; - float arg3 ; float arg4 ; int arg5 ; SWIG_check_num_args("ofPolyline::curveTo",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::curveTo",1,"ofPolyline *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::curveTo",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::curveTo",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPolyline::curveTo",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPolyline::curveTo",5,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_curveTo",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); - (arg1)->curveTo(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_curveTo__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; float arg2 ; - float arg3 ; float arg4 ; SWIG_check_num_args("ofPolyline::curveTo",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::curveTo",1,"ofPolyline *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::curveTo",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::curveTo",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPolyline::curveTo",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_curveTo",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); (arg1)->curveTo(arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_curveTo__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; float arg2 ; - float arg3 ; SWIG_check_num_args("ofPolyline::curveTo",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::curveTo",1,"ofPolyline *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::curveTo",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::curveTo",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_curveTo",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->curveTo(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Polyline_curveTo(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Polyline_curveTo__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Polyline_curveTo__SWIG_0(L);} - } } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Polyline_curveTo__SWIG_4(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Polyline_curveTo__SWIG_3(L);} } } } } if (argc == 5) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Polyline_curveTo__SWIG_2(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Polyline_curveTo'\n" " Possible C/C++ prototypes are:\n" - " ofPolyline::curveTo(ofPoint const &,int)\n" " ofPolyline::curveTo(ofPoint const &)\n" - " ofPolyline::curveTo(float,float,float,int)\n" " ofPolyline::curveTo(float,float,float)\n" - " ofPolyline::curveTo(float,float)\n"); lua_error(L);return 0; } -static int _wrap_Polyline_bezierTo__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - ofPoint *arg2 = 0 ; ofPoint *arg3 = 0 ; ofPoint *arg4 = 0 ; int arg5 ; SWIG_check_num_args("ofPolyline::bezierTo",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::bezierTo",1,"ofPolyline *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline::bezierTo",2,"ofPoint const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofPolyline::bezierTo",3,"ofPoint const &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofPolyline::bezierTo",4,"ofPoint const &"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPolyline::bezierTo",5,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_bezierTo",1,SWIGTYPE_p_ofPolyline); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Polyline_bezierTo",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Polyline_bezierTo",3,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Polyline_bezierTo",4,SWIGTYPE_p_ofVec3f); } arg5 = (int)lua_tonumber(L, 5); - (arg1)->bezierTo((ofPoint const &)*arg2,(ofPoint const &)*arg3,(ofPoint const &)*arg4,arg5); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_bezierTo__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - ofPoint *arg2 = 0 ; ofPoint *arg3 = 0 ; ofPoint *arg4 = 0 ; SWIG_check_num_args("ofPolyline::bezierTo",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::bezierTo",1,"ofPolyline *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline::bezierTo",2,"ofPoint const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofPolyline::bezierTo",3,"ofPoint const &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofPolyline::bezierTo",4,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_bezierTo",1,SWIGTYPE_p_ofPolyline); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Polyline_bezierTo",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Polyline_bezierTo",3,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Polyline_bezierTo",4,SWIGTYPE_p_ofVec3f); } - (arg1)->bezierTo((ofPoint const &)*arg2,(ofPoint const &)*arg3,(ofPoint const &)*arg4); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_bezierTo__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; float arg2 ; - float arg3 ; float arg4 ; float arg5 ; float arg6 ; float arg7 ; int arg8 ; SWIG_check_num_args("ofPolyline::bezierTo",8,8) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::bezierTo",1,"ofPolyline *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::bezierTo",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::bezierTo",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPolyline::bezierTo",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPolyline::bezierTo",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPolyline::bezierTo",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPolyline::bezierTo",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofPolyline::bezierTo",8,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_bezierTo",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (int)lua_tonumber(L, 8); - (arg1)->bezierTo(arg2,arg3,arg4,arg5,arg6,arg7,arg8); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_bezierTo__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; float arg2 ; - float arg3 ; float arg4 ; float arg5 ; float arg6 ; float arg7 ; SWIG_check_num_args("ofPolyline::bezierTo",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::bezierTo",1,"ofPolyline *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::bezierTo",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::bezierTo",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPolyline::bezierTo",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPolyline::bezierTo",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPolyline::bezierTo",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPolyline::bezierTo",7,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_bezierTo",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); (arg1)->bezierTo(arg2,arg3,arg4,arg5,arg6,arg7); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_bezierTo__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; float arg2 ; - float arg3 ; float arg4 ; float arg5 ; float arg6 ; float arg7 ; float arg8 ; float arg9 ; float arg10 ; int arg11 ; - SWIG_check_num_args("ofPolyline::bezierTo",11,11) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::bezierTo",1,"ofPolyline *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::bezierTo",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::bezierTo",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPolyline::bezierTo",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPolyline::bezierTo",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPolyline::bezierTo",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPolyline::bezierTo",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofPolyline::bezierTo",8,"float"); - if(!lua_isnumber(L,9)) SWIG_fail_arg("ofPolyline::bezierTo",9,"float"); - if(!lua_isnumber(L,10)) SWIG_fail_arg("ofPolyline::bezierTo",10,"float"); - if(!lua_isnumber(L,11)) SWIG_fail_arg("ofPolyline::bezierTo",11,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_bezierTo",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (float)lua_tonumber(L, 8); - arg9 = (float)lua_tonumber(L, 9); arg10 = (float)lua_tonumber(L, 10); arg11 = (int)lua_tonumber(L, 11); - (arg1)->bezierTo(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Polyline_bezierTo__SWIG_5(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; float arg2 ; - float arg3 ; float arg4 ; float arg5 ; float arg6 ; float arg7 ; float arg8 ; float arg9 ; float arg10 ; - SWIG_check_num_args("ofPolyline::bezierTo",10,10) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::bezierTo",1,"ofPolyline *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::bezierTo",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::bezierTo",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPolyline::bezierTo",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPolyline::bezierTo",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPolyline::bezierTo",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPolyline::bezierTo",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofPolyline::bezierTo",8,"float"); - if(!lua_isnumber(L,9)) SWIG_fail_arg("ofPolyline::bezierTo",9,"float"); - if(!lua_isnumber(L,10)) SWIG_fail_arg("ofPolyline::bezierTo",10,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_bezierTo",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (float)lua_tonumber(L, 8); - arg9 = (float)lua_tonumber(L, 9); arg10 = (float)lua_tonumber(L, 10); - (arg1)->bezierTo(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Polyline_bezierTo(lua_State* L) { int argc; int argv[12]={ 1,2,3,4,5,6,7,8,9,10,11,12} ; argc = lua_gettop(L); - if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Polyline_bezierTo__SWIG_1(L);} } } } } if (argc == 5) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Polyline_bezierTo__SWIG_0(L);} } } } } } if (argc == 7) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { - return _wrap_Polyline_bezierTo__SWIG_3(L);} } } } } } } } if (argc == 8) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { return _wrap_Polyline_bezierTo__SWIG_2(L);} } } } } } } } - } if (argc == 10) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { { _v = lua_isnumber(L,argv[8]); } if (_v) { { - _v = lua_isnumber(L,argv[9]); } if (_v) { return _wrap_Polyline_bezierTo__SWIG_5(L);} } } } } } } - } } } } if (argc == 11) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { { _v = lua_isnumber(L,argv[8]); } if (_v) { { - _v = lua_isnumber(L,argv[9]); } if (_v) { { _v = lua_isnumber(L,argv[10]); } if (_v) { - return _wrap_Polyline_bezierTo__SWIG_4(L);} } } } } } } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Polyline_bezierTo'\n" " Possible C/C++ prototypes are:\n" - " ofPolyline::bezierTo(ofPoint const &,ofPoint const &,ofPoint const &,int)\n" - " ofPolyline::bezierTo(ofPoint const &,ofPoint const &,ofPoint const &)\n" - " ofPolyline::bezierTo(float,float,float,float,float,float,int)\n" - " ofPolyline::bezierTo(float,float,float,float,float,float)\n" - " ofPolyline::bezierTo(float,float,float,float,float,float,float,float,float,int)\n" - " ofPolyline::bezierTo(float,float,float,float,float,float,float,float,float)\n"); lua_error(L);return 0; } -static int _wrap_Polyline_quadBezierTo__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - float arg2 ; float arg3 ; float arg4 ; float arg5 ; float arg6 ; float arg7 ; float arg8 ; float arg9 ; float arg10 ; - int arg11 ; SWIG_check_num_args("ofPolyline::quadBezierTo",11,11) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::quadBezierTo",1,"ofPolyline *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::quadBezierTo",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::quadBezierTo",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPolyline::quadBezierTo",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPolyline::quadBezierTo",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPolyline::quadBezierTo",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPolyline::quadBezierTo",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofPolyline::quadBezierTo",8,"float"); - if(!lua_isnumber(L,9)) SWIG_fail_arg("ofPolyline::quadBezierTo",9,"float"); - if(!lua_isnumber(L,10)) SWIG_fail_arg("ofPolyline::quadBezierTo",10,"float"); - if(!lua_isnumber(L,11)) SWIG_fail_arg("ofPolyline::quadBezierTo",11,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_quadBezierTo",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (float)lua_tonumber(L, 8); - arg9 = (float)lua_tonumber(L, 9); arg10 = (float)lua_tonumber(L, 10); arg11 = (int)lua_tonumber(L, 11); - (arg1)->quadBezierTo(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_quadBezierTo__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - float arg2 ; float arg3 ; float arg4 ; float arg5 ; float arg6 ; float arg7 ; float arg8 ; float arg9 ; float arg10 ; - SWIG_check_num_args("ofPolyline::quadBezierTo",10,10) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::quadBezierTo",1,"ofPolyline *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::quadBezierTo",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::quadBezierTo",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPolyline::quadBezierTo",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPolyline::quadBezierTo",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPolyline::quadBezierTo",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPolyline::quadBezierTo",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofPolyline::quadBezierTo",8,"float"); - if(!lua_isnumber(L,9)) SWIG_fail_arg("ofPolyline::quadBezierTo",9,"float"); - if(!lua_isnumber(L,10)) SWIG_fail_arg("ofPolyline::quadBezierTo",10,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_quadBezierTo",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (float)lua_tonumber(L, 8); - arg9 = (float)lua_tonumber(L, 9); arg10 = (float)lua_tonumber(L, 10); - (arg1)->quadBezierTo(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Polyline_quadBezierTo__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - ofPoint *arg2 = 0 ; ofPoint *arg3 = 0 ; ofPoint *arg4 = 0 ; int arg5 ; SWIG_check_num_args("ofPolyline::quadBezierTo",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::quadBezierTo",1,"ofPolyline *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline::quadBezierTo",2,"ofPoint const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofPolyline::quadBezierTo",3,"ofPoint const &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofPolyline::quadBezierTo",4,"ofPoint const &"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPolyline::quadBezierTo",5,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_quadBezierTo",1,SWIGTYPE_p_ofPolyline); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Polyline_quadBezierTo",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Polyline_quadBezierTo",3,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Polyline_quadBezierTo",4,SWIGTYPE_p_ofVec3f); } arg5 = (int)lua_tonumber(L, 5); - (arg1)->quadBezierTo((ofPoint const &)*arg2,(ofPoint const &)*arg3,(ofPoint const &)*arg4,arg5); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_quadBezierTo__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - ofPoint *arg2 = 0 ; ofPoint *arg3 = 0 ; ofPoint *arg4 = 0 ; SWIG_check_num_args("ofPolyline::quadBezierTo",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::quadBezierTo",1,"ofPolyline *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline::quadBezierTo",2,"ofPoint const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofPolyline::quadBezierTo",3,"ofPoint const &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofPolyline::quadBezierTo",4,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_quadBezierTo",1,SWIGTYPE_p_ofPolyline); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Polyline_quadBezierTo",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Polyline_quadBezierTo",3,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Polyline_quadBezierTo",4,SWIGTYPE_p_ofVec3f); } - (arg1)->quadBezierTo((ofPoint const &)*arg2,(ofPoint const &)*arg3,(ofPoint const &)*arg4); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_quadBezierTo__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - float arg2 ; float arg3 ; float arg4 ; float arg5 ; float arg6 ; float arg7 ; int arg8 ; - SWIG_check_num_args("ofPolyline::quadBezierTo",8,8) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::quadBezierTo",1,"ofPolyline *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::quadBezierTo",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::quadBezierTo",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPolyline::quadBezierTo",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPolyline::quadBezierTo",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPolyline::quadBezierTo",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPolyline::quadBezierTo",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofPolyline::quadBezierTo",8,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_quadBezierTo",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); arg8 = (int)lua_tonumber(L, 8); - (arg1)->quadBezierTo(arg2,arg3,arg4,arg5,arg6,arg7,arg8); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Polyline_quadBezierTo__SWIG_5(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - float arg2 ; float arg3 ; float arg4 ; float arg5 ; float arg6 ; float arg7 ; - SWIG_check_num_args("ofPolyline::quadBezierTo",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::quadBezierTo",1,"ofPolyline *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::quadBezierTo",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::quadBezierTo",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofPolyline::quadBezierTo",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofPolyline::quadBezierTo",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofPolyline::quadBezierTo",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofPolyline::quadBezierTo",7,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_quadBezierTo",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); (arg1)->quadBezierTo(arg2,arg3,arg4,arg5,arg6,arg7); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_quadBezierTo(lua_State* L) { int argc; int argv[12]={ 1,2,3,4,5,6,7,8,9,10,11,12} ; - argc = lua_gettop(L); if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Polyline_quadBezierTo__SWIG_3(L);} } } } } if (argc == 5) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Polyline_quadBezierTo__SWIG_2(L);} } } } } } if (argc == 7) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { - return _wrap_Polyline_quadBezierTo__SWIG_5(L);} } } } } } } } if (argc == 8) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { return _wrap_Polyline_quadBezierTo__SWIG_4(L);} } } } } } } - } } if (argc == 10) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { { _v = lua_isnumber(L,argv[8]); } if (_v) { { - _v = lua_isnumber(L,argv[9]); } if (_v) { return _wrap_Polyline_quadBezierTo__SWIG_1(L);} } } } } } - } } } } } if (argc == 11) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { { _v = lua_isnumber(L,argv[8]); } if (_v) { { - _v = lua_isnumber(L,argv[9]); } if (_v) { { _v = lua_isnumber(L,argv[10]); } if (_v) { - return _wrap_Polyline_quadBezierTo__SWIG_0(L);} } } } } } } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Polyline_quadBezierTo'\n" - " Possible C/C++ prototypes are:\n" - " ofPolyline::quadBezierTo(float,float,float,float,float,float,float,float,float,int)\n" - " ofPolyline::quadBezierTo(float,float,float,float,float,float,float,float,float)\n" - " ofPolyline::quadBezierTo(ofPoint const &,ofPoint const &,ofPoint const &,int)\n" - " ofPolyline::quadBezierTo(ofPoint const &,ofPoint const &,ofPoint const &)\n" - " ofPolyline::quadBezierTo(float,float,float,float,float,float,int)\n" - " ofPolyline::quadBezierTo(float,float,float,float,float,float)\n"); lua_error(L);return 0; } -static int _wrap_Polyline_getSmoothed__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; int arg2 ; - float arg3 ; ofPolyline result; SWIG_check_num_args("ofPolyline::getSmoothed",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::getSmoothed",1,"ofPolyline const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::getSmoothed",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::getSmoothed",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_getSmoothed",1,SWIGTYPE_p_ofPolyline); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); result = ((ofPolyline const *)arg1)->getSmoothed(arg2,arg3); { - ofPolyline * resultptr = new ofPolyline((const ofPolyline &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofPolyline,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_getSmoothed__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; int arg2 ; - ofPolyline result; SWIG_check_num_args("ofPolyline::getSmoothed",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::getSmoothed",1,"ofPolyline const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::getSmoothed",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_getSmoothed",1,SWIGTYPE_p_ofPolyline); } arg2 = (int)lua_tonumber(L, 2); - result = ((ofPolyline const *)arg1)->getSmoothed(arg2); { - ofPolyline * resultptr = new ofPolyline((const ofPolyline &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofPolyline,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_getSmoothed(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Polyline_getSmoothed__SWIG_1(L);} - } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Polyline_getSmoothed__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Polyline_getSmoothed'\n" - " Possible C/C++ prototypes are:\n" " ofPolyline::getSmoothed(int,float) const\n" - " ofPolyline::getSmoothed(int) const\n"); lua_error(L);return 0; } -static int _wrap_Polyline_getResampledBySpacing(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - float arg2 ; ofPolyline result; SWIG_check_num_args("ofPolyline::getResampledBySpacing",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::getResampledBySpacing",1,"ofPolyline const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::getResampledBySpacing",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_getResampledBySpacing",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - result = ((ofPolyline const *)arg1)->getResampledBySpacing(arg2); { - ofPolyline * resultptr = new ofPolyline((const ofPolyline &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofPolyline,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_getResampledByCount(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; int arg2 ; - ofPolyline result; SWIG_check_num_args("ofPolyline::getResampledByCount",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::getResampledByCount",1,"ofPolyline const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::getResampledByCount",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_getResampledByCount",1,SWIGTYPE_p_ofPolyline); } arg2 = (int)lua_tonumber(L, 2); - result = ((ofPolyline const *)arg1)->getResampledByCount(arg2); { - ofPolyline * resultptr = new ofPolyline((const ofPolyline &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofPolyline,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_simplify__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; float arg2 ; - SWIG_check_num_args("ofPolyline::simplify",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::simplify",1,"ofPolyline *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::simplify",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_simplify",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); (arg1)->simplify(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_simplify__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - SWIG_check_num_args("ofPolyline::simplify",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::simplify",1,"ofPolyline *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_simplify",1,SWIGTYPE_p_ofPolyline); } (arg1)->simplify(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_simplify(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Polyline_simplify__SWIG_1(L);} } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Polyline_simplify__SWIG_0(L);} } - } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Polyline_simplify'\n" - " Possible C/C++ prototypes are:\n" " ofPolyline::simplify(float)\n" " ofPolyline::simplify()\n"); - lua_error(L);return 0; } -static int _wrap_Polyline_close(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - SWIG_check_num_args("ofPolyline::close",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::close",1,"ofPolyline *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_close",1,SWIGTYPE_p_ofPolyline); } (arg1)->close(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_setClosed(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; bool arg2 ; - SWIG_check_num_args("ofPolyline::setClosed",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::setClosed",1,"ofPolyline *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofPolyline::setClosed",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_setClosed",1,SWIGTYPE_p_ofPolyline); } arg2 = (lua_toboolean(L, 2)!=0); (arg1)->setClosed(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_isClosed(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; bool result; - SWIG_check_num_args("ofPolyline::isClosed",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::isClosed",1,"ofPolyline const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_isClosed",1,SWIGTYPE_p_ofPolyline); } result = (bool)((ofPolyline const *)arg1)->isClosed(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_hasChanged(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; bool result; - SWIG_check_num_args("ofPolyline::hasChanged",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::hasChanged",1,"ofPolyline *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_hasChanged",1,SWIGTYPE_p_ofPolyline); } result = (bool)(arg1)->hasChanged(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_flagHasChanged(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - SWIG_check_num_args("ofPolyline::flagHasChanged",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::flagHasChanged",1,"ofPolyline *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_flagHasChanged",1,SWIGTYPE_p_ofPolyline); } (arg1)->flagHasChanged(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_inside__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; ofPolyline *arg3 = 0 ; - bool result; SWIG_check_num_args("ofPolyline::inside",3,3) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofPolyline::inside",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::inside",2,"float"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofPolyline::inside",3,"ofPolyline const &"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_inside",3,SWIGTYPE_p_ofPolyline); } - result = (bool)ofPolyline::inside(arg1,arg2,(ofPolyline const &)*arg3); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_inside__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; float arg2 ; - float arg3 ; bool result; SWIG_check_num_args("ofPolyline::inside",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::inside",1,"ofPolyline const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::inside",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofPolyline::inside",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_inside",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); result = (bool)((ofPolyline const *)arg1)->inside(arg2,arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_inside__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPoint *arg1 = 0 ; ofPolyline *arg2 = 0 ; - bool result; SWIG_check_num_args("ofPolyline::inside",2,2) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofPolyline::inside",1,"ofPoint const &"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline::inside",2,"ofPolyline const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Polyline_inside",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_inside",2,SWIGTYPE_p_ofPolyline); } - result = (bool)ofPolyline::inside((ofVec3f const &)*arg1,(ofPolyline const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_inside__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - ofPoint *arg2 = 0 ; bool result; SWIG_check_num_args("ofPolyline::inside",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::inside",1,"ofPolyline const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline::inside",2,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_inside",1,SWIGTYPE_p_ofPolyline); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Polyline_inside",2,SWIGTYPE_p_ofVec3f); } - result = (bool)((ofPolyline const *)arg1)->inside((ofPoint const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_inside(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Polyline_inside__SWIG_2(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Polyline_inside__SWIG_3(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Polyline_inside__SWIG_1(L);} } } } if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Polyline_inside__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Polyline_inside'\n" " Possible C/C++ prototypes are:\n" - " ofPolyline::inside(float,float,ofPolyline const &)\n" " ofPolyline::inside(float,float) const\n" - " ofPolyline::inside(ofPoint const &,ofPolyline const &)\n" " ofPolyline::inside(ofPoint const &) const\n"); - lua_error(L);return 0; } -static int _wrap_Polyline_getBoundingBox(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - ofRectangle result; SWIG_check_num_args("ofPolyline::getBoundingBox",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::getBoundingBox",1,"ofPolyline const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_getBoundingBox",1,SWIGTYPE_p_ofPolyline); } result = ((ofPolyline const *)arg1)->getBoundingBox(); - { ofRectangle * resultptr = new ofRectangle((const ofRectangle &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofRectangle,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_getPerimeter(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; float result; - SWIG_check_num_args("ofPolyline::getPerimeter",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::getPerimeter",1,"ofPolyline const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_getPerimeter",1,SWIGTYPE_p_ofPolyline); } - result = (float)((ofPolyline const *)arg1)->getPerimeter(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_getArea(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; float result; - SWIG_check_num_args("ofPolyline::getArea",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::getArea",1,"ofPolyline const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_getArea",1,SWIGTYPE_p_ofPolyline); } result = (float)((ofPolyline const *)arg1)->getArea(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_getCentroid2D(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; ofPoint result; - SWIG_check_num_args("ofPolyline::getCentroid2D",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::getCentroid2D",1,"ofPolyline const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_getCentroid2D",1,SWIGTYPE_p_ofPolyline); } result = ((ofPolyline const *)arg1)->getCentroid2D(); { - ofPoint * resultptr = new ofPoint((const ofPoint &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_getClosestPoint__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - ofPoint *arg2 = 0 ; unsigned int *arg3 = (unsigned int *) 0 ; ofPoint result; - SWIG_check_num_args("ofPolyline::getClosestPoint",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::getClosestPoint",1,"ofPolyline const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline::getClosestPoint",2,"ofPoint const &"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofPolyline::getClosestPoint",3,"unsigned int *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_getClosestPoint",1,SWIGTYPE_p_ofPolyline); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Polyline_getClosestPoint",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_unsigned_int,0))){ - SWIG_fail_ptr("Polyline_getClosestPoint",3,SWIGTYPE_p_unsigned_int); } - result = ((ofPolyline const *)arg1)->getClosestPoint((ofPoint const &)*arg2,arg3); { - ofPoint * resultptr = new ofPoint((const ofPoint &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_getClosestPoint__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - ofPoint *arg2 = 0 ; ofPoint result; SWIG_check_num_args("ofPolyline::getClosestPoint",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::getClosestPoint",1,"ofPolyline const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline::getClosestPoint",2,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_getClosestPoint",1,SWIGTYPE_p_ofPolyline); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Polyline_getClosestPoint",2,SWIGTYPE_p_ofVec3f); } - result = ((ofPolyline const *)arg1)->getClosestPoint((ofPoint const &)*arg2); { - ofPoint * resultptr = new ofPoint((const ofPoint &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_getClosestPoint(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Polyline_getClosestPoint__SWIG_1(L);} } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_unsigned_int, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Polyline_getClosestPoint__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Polyline_getClosestPoint'\n" - " Possible C/C++ prototypes are:\n" " ofPolyline::getClosestPoint(ofPoint const &,unsigned int *) const\n" - " ofPolyline::getClosestPoint(ofPoint const &) const\n"); lua_error(L);return 0; } -static int _wrap_Polyline_getIndexAtLength(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; float arg2 ; - float result; SWIG_check_num_args("ofPolyline::getIndexAtLength",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::getIndexAtLength",1,"ofPolyline const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::getIndexAtLength",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_getIndexAtLength",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - result = (float)((ofPolyline const *)arg1)->getIndexAtLength(arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_getIndexAtPercent(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; float arg2 ; - float result; SWIG_check_num_args("ofPolyline::getIndexAtPercent",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::getIndexAtPercent",1,"ofPolyline const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::getIndexAtPercent",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_getIndexAtPercent",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - result = (float)((ofPolyline const *)arg1)->getIndexAtPercent(arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_getLengthAtIndex(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; int arg2 ; - float result; SWIG_check_num_args("ofPolyline::getLengthAtIndex",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::getLengthAtIndex",1,"ofPolyline const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::getLengthAtIndex",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_getLengthAtIndex",1,SWIGTYPE_p_ofPolyline); } arg2 = (int)lua_tonumber(L, 2); - result = (float)((ofPolyline const *)arg1)->getLengthAtIndex(arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_getLengthAtIndexInterpolated(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - float arg2 ; float result; SWIG_check_num_args("ofPolyline::getLengthAtIndexInterpolated",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::getLengthAtIndexInterpolated",1,"ofPolyline const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::getLengthAtIndexInterpolated",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_getLengthAtIndexInterpolated",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - result = (float)((ofPolyline const *)arg1)->getLengthAtIndexInterpolated(arg2); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_getPointAtLength(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; float arg2 ; - ofPoint result; SWIG_check_num_args("ofPolyline::getPointAtLength",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::getPointAtLength",1,"ofPolyline const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::getPointAtLength",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_getPointAtLength",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - result = ((ofPolyline const *)arg1)->getPointAtLength(arg2); { ofPoint * resultptr = new ofPoint((const ofPoint &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_getPointAtPercent(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; float arg2 ; - ofPoint result; SWIG_check_num_args("ofPolyline::getPointAtPercent",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::getPointAtPercent",1,"ofPolyline const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::getPointAtPercent",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_getPointAtPercent",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - result = ((ofPolyline const *)arg1)->getPointAtPercent(arg2); { ofPoint * resultptr = new ofPoint((const ofPoint &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_getPointAtIndexInterpolated(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - float arg2 ; ofPoint result; SWIG_check_num_args("ofPolyline::getPointAtIndexInterpolated",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::getPointAtIndexInterpolated",1,"ofPolyline const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::getPointAtIndexInterpolated",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_getPointAtIndexInterpolated",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - result = ((ofPolyline const *)arg1)->getPointAtIndexInterpolated(arg2); { - ofPoint * resultptr = new ofPoint((const ofPoint &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_getAngleAtIndex(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; int arg2 ; - float result; SWIG_check_num_args("ofPolyline::getAngleAtIndex",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::getAngleAtIndex",1,"ofPolyline const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::getAngleAtIndex",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_getAngleAtIndex",1,SWIGTYPE_p_ofPolyline); } arg2 = (int)lua_tonumber(L, 2); - result = (float)((ofPolyline const *)arg1)->getAngleAtIndex(arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_getAngleAtIndexInterpolated(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - float arg2 ; float result; SWIG_check_num_args("ofPolyline::getAngleAtIndexInterpolated",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::getAngleAtIndexInterpolated",1,"ofPolyline const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::getAngleAtIndexInterpolated",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_getAngleAtIndexInterpolated",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - result = (float)((ofPolyline const *)arg1)->getAngleAtIndexInterpolated(arg2); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_getRotationAtIndex(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; int arg2 ; - ofVec3f result; SWIG_check_num_args("ofPolyline::getRotationAtIndex",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::getRotationAtIndex",1,"ofPolyline const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::getRotationAtIndex",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_getRotationAtIndex",1,SWIGTYPE_p_ofPolyline); } arg2 = (int)lua_tonumber(L, 2); - result = ((ofPolyline const *)arg1)->getRotationAtIndex(arg2); { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_getRotationAtIndexInterpolated(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - float arg2 ; ofVec3f result; SWIG_check_num_args("ofPolyline::getRotationAtIndexInterpolated",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::getRotationAtIndexInterpolated",1,"ofPolyline const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::getRotationAtIndexInterpolated",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_getRotationAtIndexInterpolated",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - result = ((ofPolyline const *)arg1)->getRotationAtIndexInterpolated(arg2); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_getTangentAtIndex(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; int arg2 ; - ofVec3f result; SWIG_check_num_args("ofPolyline::getTangentAtIndex",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::getTangentAtIndex",1,"ofPolyline const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::getTangentAtIndex",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_getTangentAtIndex",1,SWIGTYPE_p_ofPolyline); } arg2 = (int)lua_tonumber(L, 2); - result = ((ofPolyline const *)arg1)->getTangentAtIndex(arg2); { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_getTangentAtIndexInterpolated(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - float arg2 ; ofVec3f result; SWIG_check_num_args("ofPolyline::getTangentAtIndexInterpolated",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::getTangentAtIndexInterpolated",1,"ofPolyline const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::getTangentAtIndexInterpolated",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_getTangentAtIndexInterpolated",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - result = ((ofPolyline const *)arg1)->getTangentAtIndexInterpolated(arg2); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_getNormalAtIndex(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; int arg2 ; - ofVec3f result; SWIG_check_num_args("ofPolyline::getNormalAtIndex",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::getNormalAtIndex",1,"ofPolyline const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::getNormalAtIndex",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_getNormalAtIndex",1,SWIGTYPE_p_ofPolyline); } arg2 = (int)lua_tonumber(L, 2); - result = ((ofPolyline const *)arg1)->getNormalAtIndex(arg2); { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_getNormalAtIndexInterpolated(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - float arg2 ; ofVec3f result; SWIG_check_num_args("ofPolyline::getNormalAtIndexInterpolated",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::getNormalAtIndexInterpolated",1,"ofPolyline const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::getNormalAtIndexInterpolated",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_getNormalAtIndexInterpolated",1,SWIGTYPE_p_ofPolyline); } arg2 = (float)lua_tonumber(L, 2); - result = ((ofPolyline const *)arg1)->getNormalAtIndexInterpolated(arg2); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_getWrappedIndex(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; int arg2 ; - int result; SWIG_check_num_args("ofPolyline::getWrappedIndex",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::getWrappedIndex",1,"ofPolyline const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofPolyline::getWrappedIndex",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_getWrappedIndex",1,SWIGTYPE_p_ofPolyline); } arg2 = (int)lua_tonumber(L, 2); - result = (int)((ofPolyline const *)arg1)->getWrappedIndex(arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_setRightVector__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - ofVec3f arg2 ; ofVec3f *argp2 ; SWIG_check_num_args("ofPolyline::setRightVector",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::setRightVector",1,"ofPolyline *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofPolyline::setRightVector",2,"ofVec3f"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_setRightVector",1,SWIGTYPE_p_ofPolyline); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Polyline_setRightVector",2,SWIGTYPE_p_ofVec3f); } arg2 = *argp2; (arg1)->setRightVector(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_setRightVector__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - SWIG_check_num_args("ofPolyline::setRightVector",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::setRightVector",1,"ofPolyline *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_setRightVector",1,SWIGTYPE_p_ofPolyline); } (arg1)->setRightVector(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_setRightVector(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Polyline_setRightVector__SWIG_1(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofPolyline, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Polyline_setRightVector__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Polyline_setRightVector'\n" - " Possible C/C++ prototypes are:\n" " ofPolyline::setRightVector(ofVec3f)\n" " ofPolyline::setRightVector()\n"); - lua_error(L);return 0; } -static int _wrap_Polyline_getRightVector(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; ofVec3f result; - SWIG_check_num_args("ofPolyline::getRightVector",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::getRightVector",1,"ofPolyline const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_getRightVector",1,SWIGTYPE_p_ofPolyline); } result = ((ofPolyline const *)arg1)->getRightVector(); - { ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Polyline_draw(lua_State* L) { int SWIG_arg = 0; ofPolyline *arg1 = (ofPolyline *) 0 ; - SWIG_check_num_args("ofPolyline::draw",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofPolyline::draw",1,"ofPolyline const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofPolyline,0))){ - SWIG_fail_ptr("Polyline_draw",1,SWIGTYPE_p_ofPolyline); } ((ofPolyline const *)arg1)->draw(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_Polyline(void *obj) { -ofPolyline *arg1 = (ofPolyline *) obj; -delete arg1; -} -static int _proxy__wrap_new_Polyline(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_Polyline); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_Polyline_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_Polyline_methods[]= { - { "clear", _wrap_Polyline_clear}, - { "addVertex", _wrap_Polyline_addVertex}, - { "addVertices", _wrap_Polyline_addVertices}, - { "insertVertex", _wrap_Polyline_insertVertex}, - { "resize", _wrap_Polyline_resize}, - { "size", _wrap_Polyline_size}, - { "getVertices", _wrap_Polyline_getVertices}, - { "lineTo", _wrap_Polyline_lineTo}, - { "arc", _wrap_Polyline_arc}, - { "arcNegative", _wrap_Polyline_arcNegative}, - { "curveTo", _wrap_Polyline_curveTo}, - { "bezierTo", _wrap_Polyline_bezierTo}, - { "quadBezierTo", _wrap_Polyline_quadBezierTo}, - { "getSmoothed", _wrap_Polyline_getSmoothed}, - { "getResampledBySpacing", _wrap_Polyline_getResampledBySpacing}, - { "getResampledByCount", _wrap_Polyline_getResampledByCount}, - { "simplify", _wrap_Polyline_simplify}, - { "close", _wrap_Polyline_close}, - { "setClosed", _wrap_Polyline_setClosed}, - { "isClosed", _wrap_Polyline_isClosed}, - { "hasChanged", _wrap_Polyline_hasChanged}, - { "flagHasChanged", _wrap_Polyline_flagHasChanged}, - { "inside", _wrap_Polyline_inside}, - { "getBoundingBox", _wrap_Polyline_getBoundingBox}, - { "getPerimeter", _wrap_Polyline_getPerimeter}, - { "getArea", _wrap_Polyline_getArea}, - { "getCentroid2D", _wrap_Polyline_getCentroid2D}, - { "getClosestPoint", _wrap_Polyline_getClosestPoint}, - { "getIndexAtLength", _wrap_Polyline_getIndexAtLength}, - { "getIndexAtPercent", _wrap_Polyline_getIndexAtPercent}, - { "getLengthAtIndex", _wrap_Polyline_getLengthAtIndex}, - { "getLengthAtIndexInterpolated", _wrap_Polyline_getLengthAtIndexInterpolated}, - { "getPointAtLength", _wrap_Polyline_getPointAtLength}, - { "getPointAtPercent", _wrap_Polyline_getPointAtPercent}, - { "getPointAtIndexInterpolated", _wrap_Polyline_getPointAtIndexInterpolated}, - { "getAngleAtIndex", _wrap_Polyline_getAngleAtIndex}, - { "getAngleAtIndexInterpolated", _wrap_Polyline_getAngleAtIndexInterpolated}, - { "getRotationAtIndex", _wrap_Polyline_getRotationAtIndex}, - { "getRotationAtIndexInterpolated", _wrap_Polyline_getRotationAtIndexInterpolated}, - { "getTangentAtIndex", _wrap_Polyline_getTangentAtIndex}, - { "getTangentAtIndexInterpolated", _wrap_Polyline_getTangentAtIndexInterpolated}, - { "getNormalAtIndex", _wrap_Polyline_getNormalAtIndex}, - { "getNormalAtIndexInterpolated", _wrap_Polyline_getNormalAtIndexInterpolated}, - { "getWrappedIndex", _wrap_Polyline_getWrappedIndex}, - { "setRightVector", _wrap_Polyline_setRightVector}, - { "getRightVector", _wrap_Polyline_getRightVector}, - { "draw", _wrap_Polyline_draw}, - {0,0} -}; -static swig_lua_method swig_Polyline_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_Polyline_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_Polyline_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_Polyline_Sf_SwigStatic_methods[]= { - { "fromRectangle", _wrap_Polyline_fromRectangle}, - {0,0} -}; -static swig_lua_class* swig_Polyline_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_Polyline_Sf_SwigStatic = { - "Polyline", - swig_Polyline_Sf_SwigStatic_methods, - swig_Polyline_Sf_SwigStatic_attributes, - swig_Polyline_Sf_SwigStatic_constants, - swig_Polyline_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_Polyline_bases[] = {0}; -static const char *swig_Polyline_base_names[] = {0}; -static swig_lua_class _wrap_class_Polyline = { "Polyline", "Polyline", &SWIGTYPE_p_ofPolyline,_proxy__wrap_new_Polyline, swig_delete_Polyline, swig_Polyline_methods, swig_Polyline_attributes, &swig_Polyline_Sf_SwigStatic, swig_Polyline_meta, swig_Polyline_bases, swig_Polyline_base_names }; - -static int _wrap_drawBitmapString__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; float arg2 ; float arg3 ; - std::string temp1 ; SWIG_check_num_args("ofDrawBitmapString",3,3) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofDrawBitmapString",1,"std::string const &"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawBitmapString",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawBitmapString",3,"float"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); ofDrawBitmapString((std::string const &)*arg1,arg2,arg3); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawBitmapString__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; ofPoint *arg2 = 0 ; - std::string temp1 ; SWIG_check_num_args("ofDrawBitmapString",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofDrawBitmapString",1,"std::string const &"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofDrawBitmapString",2,"ofPoint const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("drawBitmapString",2,SWIGTYPE_p_ofVec3f); } - ofDrawBitmapString((std::string const &)*arg1,(ofVec3f const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_drawBitmapString__SWIG_2(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; float arg2 ; float arg3 ; - float arg4 ; std::string temp1 ; SWIG_check_num_args("ofDrawBitmapString",4,4) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofDrawBitmapString",1,"std::string const &"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawBitmapString",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawBitmapString",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawBitmapString",4,"float"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - ofDrawBitmapString((std::string const &)*arg1,arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_drawBitmapString(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_drawBitmapString__SWIG_1(L);} } } if (argc == 3) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_drawBitmapString__SWIG_0(L);} } } } if (argc == 4) { int _v; { _v = lua_isstring(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_drawBitmapString__SWIG_2(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'drawBitmapString'\n" " Possible C/C++ prototypes are:\n" - " ofDrawBitmapString(std::string const &,float,float)\n" " ofDrawBitmapString(std::string const &,ofPoint const &)\n" - " ofDrawBitmapString(std::string const &,float,float,float)\n"); lua_error(L);return 0; } -static int _wrap_setColor__SWIG_0(lua_State* L) { int SWIG_arg = 0; int arg1 ; int arg2 ; int arg3 ; - SWIG_check_num_args("ofSetColor",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetColor",1,"int"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSetColor",2,"int"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofSetColor",3,"int"); - arg1 = (int)lua_tonumber(L, 1); arg2 = (int)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); ofSetColor(arg1,arg2,arg3); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setColor__SWIG_1(lua_State* L) { int SWIG_arg = 0; int arg1 ; int arg2 ; int arg3 ; int arg4 ; - SWIG_check_num_args("ofSetColor",4,4) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetColor",1,"int"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSetColor",2,"int"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofSetColor",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofSetColor",4,"int"); arg1 = (int)lua_tonumber(L, 1); arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); ofSetColor(arg1,arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setColor__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofColor *arg1 = 0 ; SWIG_check_num_args("ofSetColor",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofSetColor",1,"ofColor const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("setColor",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } ofSetColor((ofColor_< unsigned char > const &)*arg1); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setColor__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofColor *arg1 = 0 ; int arg2 ; - SWIG_check_num_args("ofSetColor",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofSetColor",1,"ofColor const &"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSetColor",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("setColor",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } arg2 = (int)lua_tonumber(L, 2); - ofSetColor((ofColor_< unsigned char > const &)*arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_setColor__SWIG_4(lua_State* L) { int SWIG_arg = 0; int arg1 ; SWIG_check_num_args("ofSetColor",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetColor",1,"int"); arg1 = (int)lua_tonumber(L, 1); ofSetColor(arg1); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setColor(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_setColor__SWIG_2(L);} } if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_setColor__SWIG_4(L);} } if (argc == 2) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_setColor__SWIG_3(L);} - } } if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_setColor__SWIG_0(L);} } } } if (argc == 4) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_setColor__SWIG_1(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'setColor'\n" " Possible C/C++ prototypes are:\n" - " ofSetColor(int,int,int)\n" " ofSetColor(int,int,int,int)\n" " ofSetColor(ofColor const &)\n" - " ofSetColor(ofColor const &,int)\n" " ofSetColor(int)\n"); lua_error(L);return 0; } -static int _wrap_setHexColor(lua_State* L) { int SWIG_arg = 0; int arg1 ; SWIG_check_num_args("ofSetHexColor",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetHexColor",1,"int"); arg1 = (int)lua_tonumber(L, 1); ofSetHexColor(arg1); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_noFill(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofNoFill",0,0) ofNoFill(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_fill(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofFill",0,0) ofFill(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getFill(lua_State* L) { int SWIG_arg = 0; ofFillFlag result; SWIG_check_num_args("ofGetFill",0,0) - result = (ofFillFlag)ofGetFill(); lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_getBackgroundColor(lua_State* L) { int SWIG_arg = 0; ofColor result; - SWIG_check_num_args("ofGetBackgroundColor",0,0) result = ofGetBackgroundColor(); { - ofColor * resultptr = new ofColor((const ofColor &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_background__SWIG_0(lua_State* L) { int SWIG_arg = 0; int arg1 ; int arg2 ; int arg3 ; int arg4 ; - SWIG_check_num_args("ofBackground",4,4) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofBackground",1,"int"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBackground",2,"int"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofBackground",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofBackground",4,"int"); arg1 = (int)lua_tonumber(L, 1); arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); ofBackground(arg1,arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_background__SWIG_1(lua_State* L) { int SWIG_arg = 0; int arg1 ; int arg2 ; int arg3 ; - SWIG_check_num_args("ofBackground",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofBackground",1,"int"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBackground",2,"int"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofBackground",3,"int"); - arg1 = (int)lua_tonumber(L, 1); arg2 = (int)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); ofBackground(arg1,arg2,arg3); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_background__SWIG_2(lua_State* L) { int SWIG_arg = 0; int arg1 ; int arg2 ; - SWIG_check_num_args("ofBackground",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofBackground",1,"int"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBackground",2,"int"); arg1 = (int)lua_tonumber(L, 1); arg2 = (int)lua_tonumber(L, 2); - ofBackground(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_background__SWIG_3(lua_State* L) { int SWIG_arg = 0; int arg1 ; SWIG_check_num_args("ofBackground",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofBackground",1,"int"); arg1 = (int)lua_tonumber(L, 1); ofBackground(arg1); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_background__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofColor *arg1 = 0 ; - SWIG_check_num_args("ofBackground",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofBackground",1,"ofColor const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("background",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - ofBackground((ofColor_< unsigned char > const &)*arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_background(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 1) { int _v; - { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_background__SWIG_4(L);} } if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_background__SWIG_3(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_background__SWIG_2(L);} } } if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_background__SWIG_1(L);} } } } if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_background__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'background'\n" " Possible C/C++ prototypes are:\n" - " ofBackground(int,int,int,int)\n" " ofBackground(int,int,int)\n" " ofBackground(int,int)\n" - " ofBackground(int)\n" " ofBackground(ofColor const &)\n"); lua_error(L);return 0; } -static int _wrap_backgroundHex__SWIG_0(lua_State* L) { int SWIG_arg = 0; int arg1 ; int arg2 ; - SWIG_check_num_args("ofBackgroundHex",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofBackgroundHex",1,"int"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBackgroundHex",2,"int"); arg1 = (int)lua_tonumber(L, 1); - arg2 = (int)lua_tonumber(L, 2); ofBackgroundHex(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_backgroundHex__SWIG_1(lua_State* L) { int SWIG_arg = 0; int arg1 ; SWIG_check_num_args("ofBackgroundHex",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofBackgroundHex",1,"int"); arg1 = (int)lua_tonumber(L, 1); ofBackgroundHex(arg1); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_backgroundHex(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_backgroundHex__SWIG_1(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_backgroundHex__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'backgroundHex'\n" " Possible C/C++ prototypes are:\n" - " ofBackgroundHex(int,int)\n" " ofBackgroundHex(int)\n"); lua_error(L);return 0; } -static int _wrap_backgroundGradient__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofColor *arg1 = 0 ; ofColor *arg2 = 0 ; - ofGradientMode arg3 ; SWIG_check_num_args("ofBackgroundGradient",3,3) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofBackgroundGradient",1,"ofColor const &"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofBackgroundGradient",2,"ofColor const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofBackgroundGradient",3,"ofGradientMode"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("backgroundGradient",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("backgroundGradient",2,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - arg3 = (ofGradientMode)(int)lua_tonumber(L, 3); - ofBackgroundGradient((ofColor_< unsigned char > const &)*arg1,(ofColor_< unsigned char > const &)*arg2,arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_backgroundGradient__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofColor *arg1 = 0 ; ofColor *arg2 = 0 ; - SWIG_check_num_args("ofBackgroundGradient",2,2) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofBackgroundGradient",1,"ofColor const &"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofBackgroundGradient",2,"ofColor const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("backgroundGradient",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("backgroundGradient",2,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - ofBackgroundGradient((ofColor_< unsigned char > const &)*arg1,(ofColor_< unsigned char > const &)*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_backgroundGradient(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_backgroundGradient__SWIG_1(L);} } } if (argc == 3) { int _v; - { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_backgroundGradient__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'backgroundGradient'\n" " Possible C/C++ prototypes are:\n" - " ofBackgroundGradient(ofColor const &,ofColor const &,ofGradientMode)\n" - " ofBackgroundGradient(ofColor const &,ofColor const &)\n"); lua_error(L);return 0; } -static int _wrap_setBackgroundColor__SWIG_0(lua_State* L) { int SWIG_arg = 0; int arg1 ; int arg2 ; int arg3 ; int arg4 ; - SWIG_check_num_args("ofSetBackgroundColor",4,4) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetBackgroundColor",1,"int"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSetBackgroundColor",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofSetBackgroundColor",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofSetBackgroundColor",4,"int"); arg1 = (int)lua_tonumber(L, 1); - arg2 = (int)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - ofSetBackgroundColor(arg1,arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setBackgroundColor__SWIG_1(lua_State* L) { int SWIG_arg = 0; int arg1 ; int arg2 ; int arg3 ; - SWIG_check_num_args("ofSetBackgroundColor",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetBackgroundColor",1,"int"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSetBackgroundColor",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofSetBackgroundColor",3,"int"); arg1 = (int)lua_tonumber(L, 1); - arg2 = (int)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); ofSetBackgroundColor(arg1,arg2,arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setBackgroundColor__SWIG_2(lua_State* L) { int SWIG_arg = 0; int arg1 ; int arg2 ; - SWIG_check_num_args("ofSetBackgroundColor",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetBackgroundColor",1,"int"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSetBackgroundColor",2,"int"); arg1 = (int)lua_tonumber(L, 1); - arg2 = (int)lua_tonumber(L, 2); ofSetBackgroundColor(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_setBackgroundColor__SWIG_3(lua_State* L) { int SWIG_arg = 0; int arg1 ; - SWIG_check_num_args("ofSetBackgroundColor",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetBackgroundColor",1,"int"); - arg1 = (int)lua_tonumber(L, 1); ofSetBackgroundColor(arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_setBackgroundColor__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofColor *arg1 = 0 ; - SWIG_check_num_args("ofSetBackgroundColor",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofSetBackgroundColor",1,"ofColor const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("setBackgroundColor",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - ofSetBackgroundColor((ofColor_< unsigned char > const &)*arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_setBackgroundColor(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_setBackgroundColor__SWIG_4(L);} } if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_setBackgroundColor__SWIG_3(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_setBackgroundColor__SWIG_2(L);} } } if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_setBackgroundColor__SWIG_1(L);} } } } if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_setBackgroundColor__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'setBackgroundColor'\n" " Possible C/C++ prototypes are:\n" - " ofSetBackgroundColor(int,int,int,int)\n" " ofSetBackgroundColor(int,int,int)\n" " ofSetBackgroundColor(int,int)\n" - " ofSetBackgroundColor(int)\n" " ofSetBackgroundColor(ofColor const &)\n"); lua_error(L);return 0; } -static int _wrap_setBackgroundColorHex__SWIG_0(lua_State* L) { int SWIG_arg = 0; int arg1 ; int arg2 ; - SWIG_check_num_args("ofSetBackgroundColorHex",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetBackgroundColorHex",1,"int"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSetBackgroundColorHex",2,"int"); arg1 = (int)lua_tonumber(L, 1); - arg2 = (int)lua_tonumber(L, 2); ofSetBackgroundColorHex(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_setBackgroundColorHex__SWIG_1(lua_State* L) { int SWIG_arg = 0; int arg1 ; - SWIG_check_num_args("ofSetBackgroundColorHex",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetBackgroundColorHex",1,"int"); - arg1 = (int)lua_tonumber(L, 1); ofSetBackgroundColorHex(arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_setBackgroundColorHex(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_setBackgroundColorHex__SWIG_1(L);} } if (argc == 2) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_setBackgroundColorHex__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'setBackgroundColorHex'\n" - " Possible C/C++ prototypes are:\n" " ofSetBackgroundColorHex(int,int)\n" " ofSetBackgroundColorHex(int)\n"); - lua_error(L);return 0; } -static int _wrap_setBackgroundAuto(lua_State* L) { int SWIG_arg = 0; bool arg1 ; SWIG_check_num_args("ofSetBackgroundAuto",1,1) - if(!lua_isboolean(L,1)) SWIG_fail_arg("ofSetBackgroundAuto",1,"bool"); arg1 = (lua_toboolean(L, 1)!=0); - ofSetBackgroundAuto(arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getBackgroundAuto(lua_State* L) { int SWIG_arg = 0; bool result; SWIG_check_num_args("ofGetBackgroundAuto",0,0) - result = (bool)ofGetBackgroundAuto(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_clear__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - SWIG_check_num_args("ofClear",4,4) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofClear",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofClear",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofClear",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofClear",4,"float"); arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); ofClear(arg1,arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_clear__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofClear",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofClear",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofClear",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofClear",3,"float"); - arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); ofClear(arg1,arg2,arg3); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_clear__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; SWIG_check_num_args("ofClear",2,2) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofClear",1,"float"); if(!lua_isnumber(L,2)) SWIG_fail_arg("ofClear",2,"float"); - arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); ofClear(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_clear__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; SWIG_check_num_args("ofClear",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofClear",1,"float"); arg1 = (float)lua_tonumber(L, 1); ofClear(arg1); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_clear__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofColor *arg1 = 0 ; SWIG_check_num_args("ofClear",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofClear",1,"ofColor const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("clear",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } ofClear((ofColor_< unsigned char > const &)*arg1); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_clear(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_clear__SWIG_4(L);} } if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_clear__SWIG_3(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_clear__SWIG_2(L);} } - } if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_clear__SWIG_1(L);} } } } if (argc == 4) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_clear__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'clear'\n" " Possible C/C++ prototypes are:\n" - " ofClear(float,float,float,float)\n" " ofClear(float,float,float)\n" " ofClear(float,float)\n" - " ofClear(float)\n" " ofClear(ofColor const &)\n"); lua_error(L);return 0; } -static int _wrap_clearAlpha(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofClearAlpha",0,0) ofClearAlpha(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawTriangle__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - float arg5 ; float arg6 ; SWIG_check_num_args("ofDrawTriangle",6,6) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawTriangle",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawTriangle",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawTriangle",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawTriangle",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofDrawTriangle",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofDrawTriangle",6,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); ofDrawTriangle(arg1,arg2,arg3,arg4,arg5,arg6); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawTriangle__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - float arg5 ; float arg6 ; float arg7 ; float arg8 ; float arg9 ; SWIG_check_num_args("ofDrawTriangle",9,9) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawTriangle",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawTriangle",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawTriangle",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawTriangle",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofDrawTriangle",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofDrawTriangle",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofDrawTriangle",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofDrawTriangle",8,"float"); - if(!lua_isnumber(L,9)) SWIG_fail_arg("ofDrawTriangle",9,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); - arg8 = (float)lua_tonumber(L, 8); arg9 = (float)lua_tonumber(L, 9); - ofDrawTriangle(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_drawTriangle__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPoint *arg1 = 0 ; ofPoint *arg2 = 0 ; - ofPoint *arg3 = 0 ; SWIG_check_num_args("ofDrawTriangle",3,3) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofDrawTriangle",1,"ofPoint const &"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofDrawTriangle",2,"ofPoint const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofDrawTriangle",3,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("drawTriangle",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("drawTriangle",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("drawTriangle",3,SWIGTYPE_p_ofVec3f); } - ofDrawTriangle((ofVec3f const &)*arg1,(ofVec3f const &)*arg2,(ofVec3f const &)*arg3); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_drawTriangle(lua_State* L) { int argc; int argv[10]={ 1,2,3,4,5,6,7,8,9,10} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_drawTriangle__SWIG_2(L);} } } } if (argc == 6) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { return _wrap_drawTriangle__SWIG_0(L);} } } } } } } - if (argc == 9) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { { - _v = lua_isnumber(L,argv[6]); } if (_v) { { _v = lua_isnumber(L,argv[7]); } if (_v) { { - _v = lua_isnumber(L,argv[8]); } if (_v) { return _wrap_drawTriangle__SWIG_1(L);} } } } } } } } } - } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'drawTriangle'\n" " Possible C/C++ prototypes are:\n" - " ofDrawTriangle(float,float,float,float,float,float)\n" - " ofDrawTriangle(float,float,float,float,float,float,float,float,float)\n" - " ofDrawTriangle(ofPoint const &,ofPoint const &,ofPoint const &)\n"); lua_error(L);return 0; } -static int _wrap_drawCircle__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofDrawCircle",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawCircle",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawCircle",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawCircle",3,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); ofDrawCircle(arg1,arg2,arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawCircle__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - SWIG_check_num_args("ofDrawCircle",4,4) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawCircle",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawCircle",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawCircle",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawCircle",4,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - ofDrawCircle(arg1,arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawCircle__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPoint *arg1 = 0 ; float arg2 ; - SWIG_check_num_args("ofDrawCircle",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofDrawCircle",1,"ofPoint const &"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawCircle",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("drawCircle",1,SWIGTYPE_p_ofVec3f); } - arg2 = (float)lua_tonumber(L, 2); ofDrawCircle((ofVec3f const &)*arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_drawCircle(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { int _v; - { void *ptr; if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_drawCircle__SWIG_2(L);} } } if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_drawCircle__SWIG_0(L);} } } } if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_drawCircle__SWIG_1(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'drawCircle'\n" " Possible C/C++ prototypes are:\n" - " ofDrawCircle(float,float,float)\n" " ofDrawCircle(float,float,float,float)\n" - " ofDrawCircle(ofPoint const &,float)\n"); lua_error(L);return 0; } -static int _wrap_drawEllipse__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - SWIG_check_num_args("ofDrawEllipse",4,4) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawEllipse",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawEllipse",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawEllipse",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawEllipse",4,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - ofDrawEllipse(arg1,arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawEllipse__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - float arg5 ; SWIG_check_num_args("ofDrawEllipse",5,5) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawEllipse",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawEllipse",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawEllipse",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawEllipse",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofDrawEllipse",5,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); ofDrawEllipse(arg1,arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_drawEllipse__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPoint *arg1 = 0 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofDrawEllipse",3,3) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofDrawEllipse",1,"ofPoint const &"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawEllipse",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawEllipse",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("drawEllipse",1,SWIGTYPE_p_ofVec3f); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); ofDrawEllipse((ofVec3f const &)*arg1,arg2,arg3); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawEllipse(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_drawEllipse__SWIG_2(L);} } } } if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { - { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_drawEllipse__SWIG_0(L);} } } } } if (argc == 5) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_drawEllipse__SWIG_1(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'drawEllipse'\n" " Possible C/C++ prototypes are:\n" - " ofDrawEllipse(float,float,float,float)\n" " ofDrawEllipse(float,float,float,float,float)\n" - " ofDrawEllipse(ofPoint const &,float,float)\n"); lua_error(L);return 0; } -static int _wrap_drawLine__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - SWIG_check_num_args("ofDrawLine",4,4) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawLine",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawLine",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawLine",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawLine",4,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - ofDrawLine(arg1,arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawLine__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - float arg5 ; float arg6 ; SWIG_check_num_args("ofDrawLine",6,6) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawLine",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawLine",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawLine",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawLine",4,"float"); if(!lua_isnumber(L,5)) SWIG_fail_arg("ofDrawLine",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofDrawLine",6,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); ofDrawLine(arg1,arg2,arg3,arg4,arg5,arg6); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawLine__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPoint *arg1 = 0 ; ofPoint *arg2 = 0 ; - SWIG_check_num_args("ofDrawLine",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofDrawLine",1,"ofPoint const &"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofDrawLine",2,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("drawLine",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("drawLine",2,SWIGTYPE_p_ofVec3f); } - ofDrawLine((ofVec3f const &)*arg1,(ofVec3f const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_drawLine(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_drawLine__SWIG_2(L);} } } if (argc == 4) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_drawLine__SWIG_0(L);} } } } } if (argc == 6) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { - return _wrap_drawLine__SWIG_1(L);} } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'drawLine'\n" " Possible C/C++ prototypes are:\n" - " ofDrawLine(float,float,float,float)\n" " ofDrawLine(float,float,float,float,float,float)\n" - " ofDrawLine(ofPoint const &,ofPoint const &)\n"); lua_error(L);return 0; } -static int _wrap_drawRectangle__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - SWIG_check_num_args("ofDrawRectangle",4,4) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawRectangle",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawRectangle",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawRectangle",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawRectangle",4,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - ofDrawRectangle(arg1,arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawRectangle__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = 0 ; - SWIG_check_num_args("ofDrawRectangle",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofDrawRectangle",1,"ofRectangle const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("drawRectangle",1,SWIGTYPE_p_ofRectangle); } ofDrawRectangle((ofRectangle const &)*arg1); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawRectangle__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPoint *arg1 = 0 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofDrawRectangle",3,3) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofDrawRectangle",1,"ofPoint const &"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawRectangle",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawRectangle",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("drawRectangle",1,SWIGTYPE_p_ofVec3f); } arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - ofDrawRectangle((ofVec3f const &)*arg1,arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawRectangle__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - float arg5 ; SWIG_check_num_args("ofDrawRectangle",5,5) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawRectangle",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawRectangle",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawRectangle",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawRectangle",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofDrawRectangle",5,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); ofDrawRectangle(arg1,arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_drawRectangle(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_drawRectangle__SWIG_1(L);} } if (argc == 3) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_drawRectangle__SWIG_2(L);} } } } if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_drawRectangle__SWIG_0(L);} } } } } if (argc == 5) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_drawRectangle__SWIG_3(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'drawRectangle'\n" " Possible C/C++ prototypes are:\n" - " ofDrawRectangle(float,float,float,float)\n" " ofDrawRectangle(ofRectangle const &)\n" - " ofDrawRectangle(ofPoint const &,float,float)\n" " ofDrawRectangle(float,float,float,float,float)\n"); - lua_error(L);return 0; } -static int _wrap_drawRectRounded__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = 0 ; float arg2 ; - SWIG_check_num_args("ofDrawRectRounded",2,2) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofDrawRectRounded",1,"ofRectangle const &"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawRectRounded",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("drawRectRounded",1,SWIGTYPE_p_ofRectangle); } arg2 = (float)lua_tonumber(L, 2); - ofDrawRectRounded((ofRectangle const &)*arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawRectRounded__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPoint *arg1 = 0 ; float arg2 ; float arg3 ; - float arg4 ; SWIG_check_num_args("ofDrawRectRounded",4,4) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofDrawRectRounded",1,"ofPoint const &"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawRectRounded",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawRectRounded",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawRectRounded",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("drawRectRounded",1,SWIGTYPE_p_ofVec3f); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); ofDrawRectRounded((ofVec3f const &)*arg1,arg2,arg3,arg4); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawRectRounded__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - float arg5 ; SWIG_check_num_args("ofDrawRectRounded",5,5) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawRectRounded",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawRectRounded",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawRectRounded",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawRectRounded",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofDrawRectRounded",5,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); ofDrawRectRounded(arg1,arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_drawRectRounded__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - float arg5 ; float arg6 ; SWIG_check_num_args("ofDrawRectRounded",6,6) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawRectRounded",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawRectRounded",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawRectRounded",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawRectRounded",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofDrawRectRounded",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofDrawRectRounded",6,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); ofDrawRectRounded(arg1,arg2,arg3,arg4,arg5,arg6); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawRectRounded__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofPoint *arg1 = 0 ; float arg2 ; float arg3 ; - float arg4 ; float arg5 ; float arg6 ; float arg7 ; SWIG_check_num_args("ofDrawRectRounded",7,7) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofDrawRectRounded",1,"ofPoint const &"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawRectRounded",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawRectRounded",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawRectRounded",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofDrawRectRounded",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofDrawRectRounded",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofDrawRectRounded",7,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("drawRectRounded",1,SWIGTYPE_p_ofVec3f); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); - ofDrawRectRounded((ofVec3f const &)*arg1,arg2,arg3,arg4,arg5,arg6,arg7); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_drawRectRounded__SWIG_5(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = 0 ; float arg2 ; float arg3 ; - float arg4 ; float arg5 ; SWIG_check_num_args("ofDrawRectRounded",5,5) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofDrawRectRounded",1,"ofRectangle const &"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawRectRounded",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawRectRounded",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawRectRounded",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofDrawRectRounded",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("drawRectRounded",1,SWIGTYPE_p_ofRectangle); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - ofDrawRectRounded((ofRectangle const &)*arg1,arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_drawRectRounded__SWIG_6(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - float arg5 ; float arg6 ; float arg7 ; float arg8 ; float arg9 ; SWIG_check_num_args("ofDrawRectRounded",9,9) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawRectRounded",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawRectRounded",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawRectRounded",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawRectRounded",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofDrawRectRounded",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofDrawRectRounded",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofDrawRectRounded",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofDrawRectRounded",8,"float"); - if(!lua_isnumber(L,9)) SWIG_fail_arg("ofDrawRectRounded",9,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); - arg8 = (float)lua_tonumber(L, 8); arg9 = (float)lua_tonumber(L, 9); - ofDrawRectRounded(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_drawRectRounded(lua_State* L) { int argc; int argv[10]={ 1,2,3,4,5,6,7,8,9,10} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_drawRectRounded__SWIG_0(L);} } - } if (argc == 4) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_drawRectRounded__SWIG_1(L);} } } } } if (argc == 5) { - int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_drawRectRounded__SWIG_5(L);} } } } } } if (argc == 5) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_drawRectRounded__SWIG_2(L);} } } } } } if (argc == 6) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { return _wrap_drawRectRounded__SWIG_3(L);} } } } } } } - if (argc == 7) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { - return _wrap_drawRectRounded__SWIG_4(L);} } } } } } } } if (argc == 9) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { { _v = lua_isnumber(L,argv[8]); } if (_v) { - return _wrap_drawRectRounded__SWIG_6(L);} } } } } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'drawRectRounded'\n" " Possible C/C++ prototypes are:\n" - " ofDrawRectRounded(ofRectangle const &,float)\n" " ofDrawRectRounded(ofPoint const &,float,float,float)\n" - " ofDrawRectRounded(float,float,float,float,float)\n" " ofDrawRectRounded(float,float,float,float,float,float)\n" - " ofDrawRectRounded(ofPoint const &,float,float,float,float,float,float)\n" - " ofDrawRectRounded(ofRectangle const &,float,float,float,float)\n" - " ofDrawRectRounded(float,float,float,float,float,float,float,float,float)\n"); lua_error(L);return 0; } -static int _wrap_drawCurve__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - float arg5 ; float arg6 ; float arg7 ; float arg8 ; SWIG_check_num_args("ofDrawCurve",8,8) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawCurve",1,"float"); if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawCurve",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawCurve",3,"float"); if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawCurve",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofDrawCurve",5,"float"); if(!lua_isnumber(L,6)) SWIG_fail_arg("ofDrawCurve",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofDrawCurve",7,"float"); if(!lua_isnumber(L,8)) SWIG_fail_arg("ofDrawCurve",8,"float"); - arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); - arg7 = (float)lua_tonumber(L, 7); arg8 = (float)lua_tonumber(L, 8); ofDrawCurve(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawCurve__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - float arg5 ; float arg6 ; float arg7 ; float arg8 ; float arg9 ; float arg10 ; float arg11 ; float arg12 ; - SWIG_check_num_args("ofDrawCurve",12,12) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawCurve",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawCurve",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawCurve",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawCurve",4,"float"); if(!lua_isnumber(L,5)) SWIG_fail_arg("ofDrawCurve",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofDrawCurve",6,"float"); if(!lua_isnumber(L,7)) SWIG_fail_arg("ofDrawCurve",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofDrawCurve",8,"float"); if(!lua_isnumber(L,9)) SWIG_fail_arg("ofDrawCurve",9,"float"); - if(!lua_isnumber(L,10)) SWIG_fail_arg("ofDrawCurve",10,"float"); - if(!lua_isnumber(L,11)) SWIG_fail_arg("ofDrawCurve",11,"float"); - if(!lua_isnumber(L,12)) SWIG_fail_arg("ofDrawCurve",12,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); - arg8 = (float)lua_tonumber(L, 8); arg9 = (float)lua_tonumber(L, 9); arg10 = (float)lua_tonumber(L, 10); - arg11 = (float)lua_tonumber(L, 11); arg12 = (float)lua_tonumber(L, 12); - ofDrawCurve(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_drawCurve(lua_State* L) { int argc; int argv[13]={ 1,2,3,4,5,6,7,8,9,10,11,12,13} ; argc = lua_gettop(L); - if (argc == 8) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { { - _v = lua_isnumber(L,argv[6]); } if (_v) { { _v = lua_isnumber(L,argv[7]); } if (_v) { - return _wrap_drawCurve__SWIG_0(L);} } } } } } } } } if (argc == 12) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { { _v = lua_isnumber(L,argv[8]); } if (_v) { { - _v = lua_isnumber(L,argv[9]); } if (_v) { { _v = lua_isnumber(L,argv[10]); } if (_v) { { - _v = lua_isnumber(L,argv[11]); } if (_v) { return _wrap_drawCurve__SWIG_1(L);} } } } } } } } - } } } } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'drawCurve'\n" - " Possible C/C++ prototypes are:\n" " ofDrawCurve(float,float,float,float,float,float,float,float)\n" - " ofDrawCurve(float,float,float,float,float,float,float,float,float,float,float,float)\n"); lua_error(L);return 0; } -static int _wrap_drawBezier__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - float arg5 ; float arg6 ; float arg7 ; float arg8 ; SWIG_check_num_args("ofDrawBezier",8,8) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawBezier",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawBezier",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawBezier",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawBezier",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofDrawBezier",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofDrawBezier",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofDrawBezier",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofDrawBezier",8,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); - arg8 = (float)lua_tonumber(L, 8); ofDrawBezier(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawBezier__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - float arg5 ; float arg6 ; float arg7 ; float arg8 ; float arg9 ; float arg10 ; float arg11 ; float arg12 ; - SWIG_check_num_args("ofDrawBezier",12,12) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawBezier",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawBezier",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawBezier",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawBezier",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofDrawBezier",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofDrawBezier",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofDrawBezier",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofDrawBezier",8,"float"); - if(!lua_isnumber(L,9)) SWIG_fail_arg("ofDrawBezier",9,"float"); - if(!lua_isnumber(L,10)) SWIG_fail_arg("ofDrawBezier",10,"float"); - if(!lua_isnumber(L,11)) SWIG_fail_arg("ofDrawBezier",11,"float"); - if(!lua_isnumber(L,12)) SWIG_fail_arg("ofDrawBezier",12,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); - arg8 = (float)lua_tonumber(L, 8); arg9 = (float)lua_tonumber(L, 9); arg10 = (float)lua_tonumber(L, 10); - arg11 = (float)lua_tonumber(L, 11); arg12 = (float)lua_tonumber(L, 12); - ofDrawBezier(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_drawBezier(lua_State* L) { int argc; int argv[13]={ 1,2,3,4,5,6,7,8,9,10,11,12,13} ; argc = lua_gettop(L); - if (argc == 8) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { { - _v = lua_isnumber(L,argv[6]); } if (_v) { { _v = lua_isnumber(L,argv[7]); } if (_v) { - return _wrap_drawBezier__SWIG_0(L);} } } } } } } } } if (argc == 12) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { { _v = lua_isnumber(L,argv[8]); } if (_v) { { - _v = lua_isnumber(L,argv[9]); } if (_v) { { _v = lua_isnumber(L,argv[10]); } if (_v) { { - _v = lua_isnumber(L,argv[11]); } if (_v) { return _wrap_drawBezier__SWIG_1(L);} } } } } } } } - } } } } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'drawBezier'\n" - " Possible C/C++ prototypes are:\n" " ofDrawBezier(float,float,float,float,float,float,float,float)\n" - " ofDrawBezier(float,float,float,float,float,float,float,float,float,float,float,float)\n"); lua_error(L);return 0; } -static int _wrap_beginShape(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofBeginShape",0,0) ofBeginShape(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_vertex__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; SWIG_check_num_args("ofVertex",2,2) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofVertex",1,"float"); if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVertex",2,"float"); - arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); ofVertex(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_vertex__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofVertex",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofVertex",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVertex",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVertex",3,"float"); - arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - ofVertex(arg1,arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_vertex__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPoint *arg1 = 0 ; SWIG_check_num_args("ofVertex",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofVertex",1,"ofPoint &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("vertex",1,SWIGTYPE_p_ofVec3f); } - ofVertex(*arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_vertex(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_vertex__SWIG_2(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_vertex__SWIG_0(L);} } - } if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_vertex__SWIG_1(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'vertex'\n" " Possible C/C++ prototypes are:\n" - " ofVertex(float,float)\n" " ofVertex(float,float,float)\n" " ofVertex(ofPoint &)\n"); lua_error(L);return 0; } -static int _wrap_vertices(lua_State* L) { int SWIG_arg = 0; std::vector< ofPoint > *arg1 = 0 ; - SWIG_check_num_args("ofVertices",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofVertices",1,"std::vector< ofPoint > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofVec3f_t,0))){ - SWIG_fail_ptr("vertices",1,SWIGTYPE_p_std__vectorT_ofVec3f_t); } ofVertices((std::vector< ofVec3f > const &)*arg1); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_curveVertex__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; - SWIG_check_num_args("ofCurveVertex",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofCurveVertex",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofCurveVertex",2,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); ofCurveVertex(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_curveVertex__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofCurveVertex",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofCurveVertex",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofCurveVertex",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofCurveVertex",3,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); ofCurveVertex(arg1,arg2,arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_curveVertex__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPoint *arg1 = 0 ; - SWIG_check_num_args("ofCurveVertex",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofCurveVertex",1,"ofPoint &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("curveVertex",1,SWIGTYPE_p_ofVec3f); } - ofCurveVertex(*arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_curveVertex(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_curveVertex__SWIG_2(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_curveVertex__SWIG_0(L);} } } if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_curveVertex__SWIG_1(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'curveVertex'\n" " Possible C/C++ prototypes are:\n" - " ofCurveVertex(float,float)\n" " ofCurveVertex(float,float,float)\n" " ofCurveVertex(ofPoint &)\n"); - lua_error(L);return 0; } -static int _wrap_curveVertices(lua_State* L) { int SWIG_arg = 0; std::vector< ofPoint > *arg1 = 0 ; - SWIG_check_num_args("ofCurveVertices",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofCurveVertices",1,"std::vector< ofPoint > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_ofVec3f_t,0))){ - SWIG_fail_ptr("curveVertices",1,SWIGTYPE_p_std__vectorT_ofVec3f_t); } - ofCurveVertices((std::vector< ofVec3f > const &)*arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_bezierVertex__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - float arg5 ; float arg6 ; SWIG_check_num_args("ofBezierVertex",6,6) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofBezierVertex",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBezierVertex",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofBezierVertex",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofBezierVertex",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofBezierVertex",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofBezierVertex",6,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); ofBezierVertex(arg1,arg2,arg3,arg4,arg5,arg6); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_bezierVertex__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofPoint *arg1 = 0 ; ofPoint *arg2 = 0 ; - ofPoint *arg3 = 0 ; SWIG_check_num_args("ofBezierVertex",3,3) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofBezierVertex",1,"ofPoint const &"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofBezierVertex",2,"ofPoint const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofBezierVertex",3,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("bezierVertex",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("bezierVertex",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("bezierVertex",3,SWIGTYPE_p_ofVec3f); } - ofBezierVertex((ofVec3f const &)*arg1,(ofVec3f const &)*arg2,(ofVec3f const &)*arg3); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_bezierVertex__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - float arg5 ; float arg6 ; float arg7 ; float arg8 ; float arg9 ; SWIG_check_num_args("ofBezierVertex",9,9) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofBezierVertex",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBezierVertex",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofBezierVertex",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofBezierVertex",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofBezierVertex",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofBezierVertex",6,"float"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofBezierVertex",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofBezierVertex",8,"float"); - if(!lua_isnumber(L,9)) SWIG_fail_arg("ofBezierVertex",9,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); arg7 = (float)lua_tonumber(L, 7); - arg8 = (float)lua_tonumber(L, 8); arg9 = (float)lua_tonumber(L, 9); - ofBezierVertex(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_bezierVertex(lua_State* L) { int argc; int argv[10]={ 1,2,3,4,5,6,7,8,9,10} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_bezierVertex__SWIG_1(L);} } } } if (argc == 6) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { return _wrap_bezierVertex__SWIG_0(L);} } } } } } } - if (argc == 9) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { { - _v = lua_isnumber(L,argv[6]); } if (_v) { { _v = lua_isnumber(L,argv[7]); } if (_v) { { - _v = lua_isnumber(L,argv[8]); } if (_v) { return _wrap_bezierVertex__SWIG_2(L);} } } } } } } } } - } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'bezierVertex'\n" " Possible C/C++ prototypes are:\n" - " ofBezierVertex(float,float,float,float,float,float)\n" - " ofBezierVertex(ofPoint const &,ofPoint const &,ofPoint const &)\n" - " ofBezierVertex(float,float,float,float,float,float,float,float,float)\n"); lua_error(L);return 0; } -static int _wrap_endShape__SWIG_0(lua_State* L) { int SWIG_arg = 0; bool arg1 ; SWIG_check_num_args("ofEndShape",1,1) - if(!lua_isboolean(L,1)) SWIG_fail_arg("ofEndShape",1,"bool"); arg1 = (lua_toboolean(L, 1)!=0); ofEndShape(arg1); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_endShape__SWIG_1(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofEndShape",0,0) ofEndShape(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_endShape(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_endShape__SWIG_1(L);} if (argc == 1) { int _v; { _v = lua_isboolean(L,argv[0]); } if (_v) { - return _wrap_endShape__SWIG_0(L);} } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'endShape'\n" - " Possible C/C++ prototypes are:\n" " ofEndShape(bool)\n" " ofEndShape()\n"); lua_error(L);return 0; } -static int _wrap_nextContour__SWIG_0(lua_State* L) { int SWIG_arg = 0; bool arg1 ; SWIG_check_num_args("ofNextContour",1,1) - if(!lua_isboolean(L,1)) SWIG_fail_arg("ofNextContour",1,"bool"); arg1 = (lua_toboolean(L, 1)!=0); ofNextContour(arg1); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_nextContour__SWIG_1(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofNextContour",0,0) ofNextContour(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_nextContour(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_nextContour__SWIG_1(L);} if (argc == 1) { int _v; { _v = lua_isboolean(L,argv[0]); } if (_v) { - return _wrap_nextContour__SWIG_0(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'nextContour'\n" " Possible C/C++ prototypes are:\n" - " ofNextContour(bool)\n" " ofNextContour()\n"); lua_error(L);return 0; } -static int _wrap_setDrawBitmapMode(lua_State* L) { int SWIG_arg = 0; ofDrawBitmapMode arg1 ; - SWIG_check_num_args("ofSetDrawBitmapMode",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetDrawBitmapMode",1,"ofDrawBitmapMode"); - arg1 = (ofDrawBitmapMode)(int)lua_tonumber(L, 1); ofSetDrawBitmapMode(arg1); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_drawBitmapStringHighlight__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string arg1 ; ofPoint *arg2 = 0 ; - ofColor *arg3 = 0 ; ofColor *arg4 = 0 ; SWIG_check_num_args("ofDrawBitmapStringHighlight",4,4) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofDrawBitmapStringHighlight",1,"std::string"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofDrawBitmapStringHighlight",2,"ofPoint const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofDrawBitmapStringHighlight",3,"ofColor const &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofDrawBitmapStringHighlight",4,"ofColor const &"); - (&arg1)->assign(lua_tostring(L,1),lua_rawlen(L,1)); if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("drawBitmapStringHighlight",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("drawBitmapStringHighlight",3,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("drawBitmapStringHighlight",4,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - ofDrawBitmapStringHighlight(arg1,(ofVec3f const &)*arg2,(ofColor_< unsigned char > const &)*arg3,(ofColor_< unsigned char > const &)*arg4); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawBitmapStringHighlight__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string arg1 ; ofPoint *arg2 = 0 ; - ofColor *arg3 = 0 ; SWIG_check_num_args("ofDrawBitmapStringHighlight",3,3) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofDrawBitmapStringHighlight",1,"std::string"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofDrawBitmapStringHighlight",2,"ofPoint const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofDrawBitmapStringHighlight",3,"ofColor const &"); - (&arg1)->assign(lua_tostring(L,1),lua_rawlen(L,1)); if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("drawBitmapStringHighlight",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("drawBitmapStringHighlight",3,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - ofDrawBitmapStringHighlight(arg1,(ofVec3f const &)*arg2,(ofColor_< unsigned char > const &)*arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawBitmapStringHighlight__SWIG_2(lua_State* L) { int SWIG_arg = 0; std::string arg1 ; ofPoint *arg2 = 0 ; - SWIG_check_num_args("ofDrawBitmapStringHighlight",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofDrawBitmapStringHighlight",1,"std::string"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofDrawBitmapStringHighlight",2,"ofPoint const &"); - (&arg1)->assign(lua_tostring(L,1),lua_rawlen(L,1)); if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("drawBitmapStringHighlight",2,SWIGTYPE_p_ofVec3f); } - ofDrawBitmapStringHighlight(arg1,(ofVec3f const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_drawBitmapStringHighlight__SWIG_3(lua_State* L) { int SWIG_arg = 0; std::string arg1 ; int arg2 ; int arg3 ; - ofColor *arg4 = 0 ; ofColor *arg5 = 0 ; SWIG_check_num_args("ofDrawBitmapStringHighlight",5,5) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofDrawBitmapStringHighlight",1,"std::string"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawBitmapStringHighlight",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawBitmapStringHighlight",3,"int"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofDrawBitmapStringHighlight",4,"ofColor const &"); - if(!lua_isuserdata(L,5)) SWIG_fail_arg("ofDrawBitmapStringHighlight",5,"ofColor const &"); - (&arg1)->assign(lua_tostring(L,1),lua_rawlen(L,1)); arg2 = (int)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("drawBitmapStringHighlight",4,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,5,(void**)&arg5,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("drawBitmapStringHighlight",5,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - ofDrawBitmapStringHighlight(arg1,arg2,arg3,(ofColor_< unsigned char > const &)*arg4,(ofColor_< unsigned char > const &)*arg5); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawBitmapStringHighlight__SWIG_4(lua_State* L) { int SWIG_arg = 0; std::string arg1 ; int arg2 ; int arg3 ; - ofColor *arg4 = 0 ; SWIG_check_num_args("ofDrawBitmapStringHighlight",4,4) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofDrawBitmapStringHighlight",1,"std::string"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawBitmapStringHighlight",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawBitmapStringHighlight",3,"int"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofDrawBitmapStringHighlight",4,"ofColor const &"); - (&arg1)->assign(lua_tostring(L,1),lua_rawlen(L,1)); arg2 = (int)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("drawBitmapStringHighlight",4,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - ofDrawBitmapStringHighlight(arg1,arg2,arg3,(ofColor_< unsigned char > const &)*arg4); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_drawBitmapStringHighlight__SWIG_5(lua_State* L) { int SWIG_arg = 0; std::string arg1 ; int arg2 ; int arg3 ; - SWIG_check_num_args("ofDrawBitmapStringHighlight",3,3) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofDrawBitmapStringHighlight",1,"std::string"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawBitmapStringHighlight",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawBitmapStringHighlight",3,"int"); - (&arg1)->assign(lua_tostring(L,1),lua_rawlen(L,1)); arg2 = (int)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); - ofDrawBitmapStringHighlight(arg1,arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawBitmapStringHighlight(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_drawBitmapStringHighlight__SWIG_2(L);} } } if (argc == 3) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_drawBitmapStringHighlight__SWIG_1(L);} } } } - if (argc == 3) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_drawBitmapStringHighlight__SWIG_5(L);} } } } - if (argc == 4) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_drawBitmapStringHighlight__SWIG_0(L);} } } } } - if (argc == 4) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_drawBitmapStringHighlight__SWIG_4(L);} } } } } - if (argc == 5) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[4])==0 || SWIG_ConvertPtr(L,argv[4], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_drawBitmapStringHighlight__SWIG_3(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'drawBitmapStringHighlight'\n" - " Possible C/C++ prototypes are:\n" - " ofDrawBitmapStringHighlight(std::string,ofPoint const &,ofColor const &,ofColor const &)\n" - " ofDrawBitmapStringHighlight(std::string,ofPoint const &,ofColor const &)\n" - " ofDrawBitmapStringHighlight(std::string,ofPoint const &)\n" - " ofDrawBitmapStringHighlight(std::string,int,int,ofColor const &,ofColor const &)\n" - " ofDrawBitmapStringHighlight(std::string,int,int,ofColor const &)\n" - " ofDrawBitmapStringHighlight(std::string,int,int)\n"); lua_error(L);return 0; } -static int _wrap_setupGraphicDefaults(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofSetupGraphicDefaults",0,0) - ofSetupGraphicDefaults(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setupScreen(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofSetupScreen",0,0) ofSetupScreen(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getRectMode(lua_State* L) { int SWIG_arg = 0; ofRectMode result; SWIG_check_num_args("ofGetRectMode",0,0) - result = (ofRectMode)ofGetRectMode(); lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setCircleResolution(lua_State* L) { int SWIG_arg = 0; int arg1 ; - SWIG_check_num_args("ofSetCircleResolution",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetCircleResolution",1,"int"); - arg1 = (int)lua_tonumber(L, 1); ofSetCircleResolution(arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_setCurveResolution(lua_State* L) { int SWIG_arg = 0; int arg1 ; SWIG_check_num_args("ofSetCurveResolution",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetCurveResolution",1,"int"); arg1 = (int)lua_tonumber(L, 1); - ofSetCurveResolution(arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setLineWidth(lua_State* L) { int SWIG_arg = 0; float arg1 ; SWIG_check_num_args("ofSetLineWidth",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetLineWidth",1,"float"); arg1 = (float)lua_tonumber(L, 1); ofSetLineWidth(arg1); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setDepthTest(lua_State* L) { int SWIG_arg = 0; bool arg1 ; SWIG_check_num_args("ofSetDepthTest",1,1) - if(!lua_isboolean(L,1)) SWIG_fail_arg("ofSetDepthTest",1,"bool"); arg1 = (lua_toboolean(L, 1)!=0); ofSetDepthTest(arg1); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_enableDepthTest(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofEnableDepthTest",0,0) - ofEnableDepthTest(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_disableDepthTest(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofDisableDepthTest",0,0) - ofDisableDepthTest(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_enableBlendMode(lua_State* L) { int SWIG_arg = 0; ofBlendMode arg1 ; - SWIG_check_num_args("ofEnableBlendMode",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofEnableBlendMode",1,"ofBlendMode"); - arg1 = (ofBlendMode)(int)lua_tonumber(L, 1); ofEnableBlendMode(arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_disableBlendMode(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofDisableBlendMode",0,0) - ofDisableBlendMode(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_enablePointSprites(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofEnablePointSprites",0,0) - ofEnablePointSprites(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_disablePointSprites(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofDisablePointSprites",0,0) - ofDisablePointSprites(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_enableAlphaBlending(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofEnableAlphaBlending",0,0) - ofEnableAlphaBlending(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_disableAlphaBlending(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofDisableAlphaBlending",0,0) - ofDisableAlphaBlending(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_enableSmoothing(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofEnableSmoothing",0,0) - ofEnableSmoothing(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_disableSmoothing(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofDisableSmoothing",0,0) - ofDisableSmoothing(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_enableAntiAliasing(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofEnableAntiAliasing",0,0) - ofEnableAntiAliasing(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_disableAntiAliasing(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofDisableAntiAliasing",0,0) - ofDisableAntiAliasing(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getStyle(lua_State* L) { int SWIG_arg = 0; ofStyle result; SWIG_check_num_args("ofGetStyle",0,0) - result = ofGetStyle(); { ofStyle * resultptr = new ofStyle((const ofStyle &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofStyle,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_setStyle(lua_State* L) { int SWIG_arg = 0; ofStyle arg1 ; ofStyle *argp1 ; - SWIG_check_num_args("ofSetStyle",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofSetStyle",1,"ofStyle"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&argp1,SWIGTYPE_p_ofStyle,0))){ SWIG_fail_ptr("setStyle",1,SWIGTYPE_p_ofStyle); } - arg1 = *argp1; ofSetStyle(arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_pushStyle(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofPushStyle",0,0) ofPushStyle(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_popStyle(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofPopStyle",0,0) ofPopStyle(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setPolyMode(lua_State* L) { int SWIG_arg = 0; ofPolyWindingMode arg1 ; SWIG_check_num_args("ofSetPolyMode",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetPolyMode",1,"ofPolyWindingMode"); - arg1 = (ofPolyWindingMode)(int)lua_tonumber(L, 1); ofSetPolyMode(arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_setRectMode(lua_State* L) { int SWIG_arg = 0; ofRectMode arg1 ; SWIG_check_num_args("ofSetRectMode",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetRectMode",1,"ofRectMode"); arg1 = (ofRectMode)(int)lua_tonumber(L, 1); - ofSetRectMode(arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_pushMatrix(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofPushMatrix",0,0) ofPushMatrix(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_popMatrix(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofPopMatrix",0,0) ofPopMatrix(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getCurrentMatrix(lua_State* L) { int SWIG_arg = 0; ofMatrixMode arg1 ; ofMatrix4x4 result; - SWIG_check_num_args("ofGetCurrentMatrix",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofGetCurrentMatrix",1,"ofMatrixMode"); - arg1 = (ofMatrixMode)(int)lua_tonumber(L, 1); result = ofGetCurrentMatrix(arg1); { - ofMatrix4x4 * resultptr = new ofMatrix4x4((const ofMatrix4x4 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_getCurrentOrientationMatrix(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 result; - SWIG_check_num_args("ofGetCurrentOrientationMatrix",0,0) result = ofGetCurrentOrientationMatrix(); { - ofMatrix4x4 * resultptr = new ofMatrix4x4((const ofMatrix4x4 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_getCurrentNormalMatrix(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 result; - SWIG_check_num_args("ofGetCurrentNormalMatrix",0,0) result = ofGetCurrentNormalMatrix(); { - ofMatrix4x4 * resultptr = new ofMatrix4x4((const ofMatrix4x4 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_translate__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofTranslate",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofTranslate",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTranslate",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTranslate",3,"float"); - arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - ofTranslate(arg1,arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_translate__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; - SWIG_check_num_args("ofTranslate",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofTranslate",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTranslate",2,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); ofTranslate(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_translate__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPoint *arg1 = 0 ; SWIG_check_num_args("ofTranslate",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofTranslate",1,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("translate",1,SWIGTYPE_p_ofVec3f); } - ofTranslate((ofVec3f const &)*arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_translate(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_translate__SWIG_2(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_translate__SWIG_1(L);} - } } if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_translate__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'translate'\n" " Possible C/C++ prototypes are:\n" - " ofTranslate(float,float,float)\n" " ofTranslate(float,float)\n" " ofTranslate(ofPoint const &)\n"); - lua_error(L);return 0; } -static int _wrap_scale__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofScale",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofScale",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofScale",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofScale",3,"float"); - arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); ofScale(arg1,arg2,arg3); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_scale__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; SWIG_check_num_args("ofScale",2,2) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofScale",1,"float"); if(!lua_isnumber(L,2)) SWIG_fail_arg("ofScale",2,"float"); - arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); ofScale(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_scale__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPoint *arg1 = 0 ; SWIG_check_num_args("ofScale",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofScale",1,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("scale",1,SWIGTYPE_p_ofVec3f); } - ofScale((ofVec3f const &)*arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_scale(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_scale__SWIG_2(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_scale__SWIG_1(L);} } - } if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_scale__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'scale'\n" " Possible C/C++ prototypes are:\n" - " ofScale(float,float,float)\n" " ofScale(float,float)\n" " ofScale(ofPoint const &)\n"); lua_error(L);return 0; } -static int _wrap_rotate__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - SWIG_check_num_args("ofRotate",4,4) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofRotate",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRotate",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofRotate",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofRotate",4,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - ofRotate(arg1,arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_rotate__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; SWIG_check_num_args("ofRotate",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofRotate",1,"float"); arg1 = (float)lua_tonumber(L, 1); ofRotate(arg1); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_rotate(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_rotate__SWIG_1(L);} } if (argc == 4) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_rotate__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'rotate'\n" " Possible C/C++ prototypes are:\n" - " ofRotate(float,float,float,float)\n" " ofRotate(float)\n"); lua_error(L);return 0; } -static int _wrap_rotateX(lua_State* L) { int SWIG_arg = 0; float arg1 ; SWIG_check_num_args("ofRotateX",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofRotateX",1,"float"); arg1 = (float)lua_tonumber(L, 1); ofRotateX(arg1); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_rotateY(lua_State* L) { int SWIG_arg = 0; float arg1 ; SWIG_check_num_args("ofRotateY",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofRotateY",1,"float"); arg1 = (float)lua_tonumber(L, 1); ofRotateY(arg1); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_rotateZ(lua_State* L) { int SWIG_arg = 0; float arg1 ; SWIG_check_num_args("ofRotateZ",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofRotateZ",1,"float"); arg1 = (float)lua_tonumber(L, 1); ofRotateZ(arg1); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_loadIdentityMatrix(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofLoadIdentityMatrix",0,0) - ofLoadIdentityMatrix(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_loadMatrix__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = 0 ; - SWIG_check_num_args("ofLoadMatrix",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofLoadMatrix",1,"ofMatrix4x4 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("loadMatrix",1,SWIGTYPE_p_ofMatrix4x4); } ofLoadMatrix((ofMatrix4x4 const &)*arg1); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_loadMatrix__SWIG_1(lua_State* L) { int SWIG_arg = 0; float *arg1 = (float *) 0 ; - SWIG_check_num_args("ofLoadMatrix",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofLoadMatrix",1,"float const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_float,0))){ SWIG_fail_ptr("loadMatrix",1,SWIGTYPE_p_float); } - ofLoadMatrix((float const *)arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_loadMatrix(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_loadMatrix__SWIG_0(L);} } if (argc == 1) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_loadMatrix__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'loadMatrix'\n" " Possible C/C++ prototypes are:\n" - " ofLoadMatrix(ofMatrix4x4 const &)\n" " ofLoadMatrix(float const *)\n"); lua_error(L);return 0; } -static int _wrap_multMatrix__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = 0 ; - SWIG_check_num_args("ofMultMatrix",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofMultMatrix",1,"ofMatrix4x4 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("multMatrix",1,SWIGTYPE_p_ofMatrix4x4); } ofMultMatrix((ofMatrix4x4 const &)*arg1); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_multMatrix__SWIG_1(lua_State* L) { int SWIG_arg = 0; float *arg1 = (float *) 0 ; - SWIG_check_num_args("ofMultMatrix",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMultMatrix",1,"float const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_float,0))){ SWIG_fail_ptr("multMatrix",1,SWIGTYPE_p_float); } - ofMultMatrix((float const *)arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_multMatrix(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrix4x4, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_multMatrix__SWIG_0(L);} } if (argc == 1) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_float, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_multMatrix__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'multMatrix'\n" " Possible C/C++ prototypes are:\n" - " ofMultMatrix(ofMatrix4x4 const &)\n" " ofMultMatrix(float const *)\n"); lua_error(L);return 0; } -static int _wrap_setMatrixMode(lua_State* L) { int SWIG_arg = 0; ofMatrixMode arg1 ; SWIG_check_num_args("ofSetMatrixMode",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetMatrixMode",1,"ofMatrixMode"); arg1 = (ofMatrixMode)(int)lua_tonumber(L, 1); - ofSetMatrixMode(arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_loadViewMatrix(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = 0 ; - SWIG_check_num_args("ofLoadViewMatrix",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofLoadViewMatrix",1,"ofMatrix4x4 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("loadViewMatrix",1,SWIGTYPE_p_ofMatrix4x4); } ofLoadViewMatrix((ofMatrix4x4 const &)*arg1); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_multViewMatrix(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 *arg1 = 0 ; - SWIG_check_num_args("ofMultViewMatrix",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofMultViewMatrix",1,"ofMatrix4x4 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("multViewMatrix",1,SWIGTYPE_p_ofMatrix4x4); } ofMultViewMatrix((ofMatrix4x4 const &)*arg1); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getCurrentViewMatrix(lua_State* L) { int SWIG_arg = 0; ofMatrix4x4 result; - SWIG_check_num_args("ofGetCurrentViewMatrix",0,0) result = ofGetCurrentViewMatrix(); { - ofMatrix4x4 * resultptr = new ofMatrix4x4((const ofMatrix4x4 &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofMatrix4x4,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_pushView(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofPushView",0,0) ofPushView(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_popView(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofPopView",0,0) ofPopView(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_viewport__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofRectangle arg1 ; ofRectangle *argp1 ; - SWIG_check_num_args("ofViewport",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofViewport",1,"ofRectangle"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&argp1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("viewport",1,SWIGTYPE_p_ofRectangle); } arg1 = *argp1; ofViewport(arg1); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_viewport__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - bool arg5 ; SWIG_check_num_args("ofViewport",5,5) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofViewport",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofViewport",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofViewport",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofViewport",4,"float"); if(!lua_isboolean(L,5)) SWIG_fail_arg("ofViewport",5,"bool"); - arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - arg4 = (float)lua_tonumber(L, 4); arg5 = (lua_toboolean(L, 5)!=0); ofViewport(arg1,arg2,arg3,arg4,arg5); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_viewport__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - SWIG_check_num_args("ofViewport",4,4) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofViewport",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofViewport",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofViewport",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofViewport",4,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - ofViewport(arg1,arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_viewport__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofViewport",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofViewport",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofViewport",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofViewport",3,"float"); - arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - ofViewport(arg1,arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_viewport__SWIG_4(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; - SWIG_check_num_args("ofViewport",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofViewport",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofViewport",2,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); ofViewport(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_viewport__SWIG_5(lua_State* L) { int SWIG_arg = 0; float arg1 ; SWIG_check_num_args("ofViewport",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofViewport",1,"float"); arg1 = (float)lua_tonumber(L, 1); ofViewport(arg1); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_viewport__SWIG_6(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofViewport",0,0) ofViewport(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_viewport(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_viewport__SWIG_6(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_viewport__SWIG_0(L);} } if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_viewport__SWIG_5(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_viewport__SWIG_4(L);} - } } if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_viewport__SWIG_3(L);} } } } if (argc == 4) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_viewport__SWIG_2(L);} } } } } if (argc == 5) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { - _v = lua_isboolean(L,argv[4]); } if (_v) { return _wrap_viewport__SWIG_1(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'viewport'\n" " Possible C/C++ prototypes are:\n" - " ofViewport(ofRectangle)\n" " ofViewport(float,float,float,float,bool)\n" " ofViewport(float,float,float,float)\n" - " ofViewport(float,float,float)\n" " ofViewport(float,float)\n" " ofViewport(float)\n" " ofViewport()\n"); - lua_error(L);return 0; } -static int _wrap_getCurrentViewport(lua_State* L) { int SWIG_arg = 0; ofRectangle result; - SWIG_check_num_args("ofGetCurrentViewport",0,0) result = ofGetCurrentViewport(); { - ofRectangle * resultptr = new ofRectangle((const ofRectangle &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofRectangle,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_getNativeViewport(lua_State* L) { int SWIG_arg = 0; ofRectangle result; - SWIG_check_num_args("ofGetNativeViewport",0,0) result = ofGetNativeViewport(); { - ofRectangle * resultptr = new ofRectangle((const ofRectangle &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofRectangle,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_getViewportWidth(lua_State* L) { int SWIG_arg = 0; int result; SWIG_check_num_args("ofGetViewportWidth",0,0) - result = (int)ofGetViewportWidth(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_getViewportHeight(lua_State* L) { int SWIG_arg = 0; int result; SWIG_check_num_args("ofGetViewportHeight",0,0) - result = (int)ofGetViewportHeight(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_setupScreenPerspective__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; - float arg4 ; float arg5 ; SWIG_check_num_args("ofSetupScreenPerspective",5,5) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetupScreenPerspective",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSetupScreenPerspective",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofSetupScreenPerspective",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofSetupScreenPerspective",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofSetupScreenPerspective",5,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); ofSetupScreenPerspective(arg1,arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_setupScreenPerspective__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; - float arg4 ; SWIG_check_num_args("ofSetupScreenPerspective",4,4) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetupScreenPerspective",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSetupScreenPerspective",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofSetupScreenPerspective",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofSetupScreenPerspective",4,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - ofSetupScreenPerspective(arg1,arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setupScreenPerspective__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofSetupScreenPerspective",3,3) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetupScreenPerspective",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSetupScreenPerspective",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofSetupScreenPerspective",3,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); ofSetupScreenPerspective(arg1,arg2,arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setupScreenPerspective__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; - SWIG_check_num_args("ofSetupScreenPerspective",2,2) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetupScreenPerspective",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSetupScreenPerspective",2,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); ofSetupScreenPerspective(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_setupScreenPerspective__SWIG_4(lua_State* L) { int SWIG_arg = 0; float arg1 ; - SWIG_check_num_args("ofSetupScreenPerspective",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetupScreenPerspective",1,"float"); arg1 = (float)lua_tonumber(L, 1); - ofSetupScreenPerspective(arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setupScreenPerspective__SWIG_5(lua_State* L) { int SWIG_arg = 0; - SWIG_check_num_args("ofSetupScreenPerspective",0,0) ofSetupScreenPerspective(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_setupScreenPerspective(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); - if (argc == 0) { return _wrap_setupScreenPerspective__SWIG_5(L);} if (argc == 1) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { return _wrap_setupScreenPerspective__SWIG_4(L);} } if (argc == 2) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_setupScreenPerspective__SWIG_3(L);} } } - if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_setupScreenPerspective__SWIG_2(L);} } } } if (argc == 4) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { - return _wrap_setupScreenPerspective__SWIG_1(L);} } } } } if (argc == 5) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_setupScreenPerspective__SWIG_0(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'setupScreenPerspective'\n" - " Possible C/C++ prototypes are:\n" " ofSetupScreenPerspective(float,float,float,float,float)\n" - " ofSetupScreenPerspective(float,float,float,float)\n" " ofSetupScreenPerspective(float,float,float)\n" - " ofSetupScreenPerspective(float,float)\n" " ofSetupScreenPerspective(float)\n" " ofSetupScreenPerspective()\n"); - lua_error(L);return 0; } -static int _wrap_setupScreenOrtho__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - SWIG_check_num_args("ofSetupScreenOrtho",4,4) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetupScreenOrtho",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSetupScreenOrtho",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofSetupScreenOrtho",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofSetupScreenOrtho",4,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - ofSetupScreenOrtho(arg1,arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setupScreenOrtho__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofSetupScreenOrtho",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetupScreenOrtho",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSetupScreenOrtho",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofSetupScreenOrtho",3,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); ofSetupScreenOrtho(arg1,arg2,arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setupScreenOrtho__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; - SWIG_check_num_args("ofSetupScreenOrtho",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetupScreenOrtho",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSetupScreenOrtho",2,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); ofSetupScreenOrtho(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_setupScreenOrtho__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; - SWIG_check_num_args("ofSetupScreenOrtho",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetupScreenOrtho",1,"float"); - arg1 = (float)lua_tonumber(L, 1); ofSetupScreenOrtho(arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_setupScreenOrtho__SWIG_4(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofSetupScreenOrtho",0,0) - ofSetupScreenOrtho(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setupScreenOrtho(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_setupScreenOrtho__SWIG_4(L);} if (argc == 1) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { - return _wrap_setupScreenOrtho__SWIG_3(L);} } if (argc == 2) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_setupScreenOrtho__SWIG_2(L);} } } if (argc == 3) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_setupScreenOrtho__SWIG_1(L);} } } } if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_setupScreenOrtho__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'setupScreenOrtho'\n" " Possible C/C++ prototypes are:\n" - " ofSetupScreenOrtho(float,float,float,float)\n" " ofSetupScreenOrtho(float,float,float)\n" - " ofSetupScreenOrtho(float,float)\n" " ofSetupScreenOrtho(float)\n" " ofSetupScreenOrtho()\n"); - lua_error(L);return 0; } -static int _wrap_orientationToDegrees(lua_State* L) { int SWIG_arg = 0; ofOrientation arg1 ; int result; - SWIG_check_num_args("ofOrientationToDegrees",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofOrientationToDegrees",1,"ofOrientation"); - arg1 = (ofOrientation)(int)lua_tonumber(L, 1); result = (int)ofOrientationToDegrees(arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setCoordHandedness(lua_State* L) { int SWIG_arg = 0; ofHandednessType arg1 ; - SWIG_check_num_args("ofSetCoordHandedness",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetCoordHandedness",1,"ofHandednessType"); - arg1 = (ofHandednessType)(int)lua_tonumber(L, 1); ofSetCoordHandedness(arg1); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_getCoordHandedness(lua_State* L) { int SWIG_arg = 0; ofHandednessType result; - SWIG_check_num_args("ofGetCoordHandedness",0,0) result = (ofHandednessType)ofGetCoordHandedness(); - lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_beginSaveScreenAsPDF__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string arg1 ; bool arg2 ; bool arg3 ; - ofRectangle arg4 ; ofRectangle *argp4 ; SWIG_check_num_args("ofBeginSaveScreenAsPDF",4,4) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofBeginSaveScreenAsPDF",1,"std::string"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofBeginSaveScreenAsPDF",2,"bool"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofBeginSaveScreenAsPDF",3,"bool"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofBeginSaveScreenAsPDF",4,"ofRectangle"); - (&arg1)->assign(lua_tostring(L,1),lua_rawlen(L,1)); arg2 = (lua_toboolean(L, 2)!=0); arg3 = (lua_toboolean(L, 3)!=0); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&argp4,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("beginSaveScreenAsPDF",4,SWIGTYPE_p_ofRectangle); } arg4 = *argp4; - ofBeginSaveScreenAsPDF(arg1,arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_beginSaveScreenAsPDF__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string arg1 ; bool arg2 ; bool arg3 ; - SWIG_check_num_args("ofBeginSaveScreenAsPDF",3,3) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofBeginSaveScreenAsPDF",1,"std::string"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofBeginSaveScreenAsPDF",2,"bool"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofBeginSaveScreenAsPDF",3,"bool"); (&arg1)->assign(lua_tostring(L,1),lua_rawlen(L,1)); - arg2 = (lua_toboolean(L, 2)!=0); arg3 = (lua_toboolean(L, 3)!=0); ofBeginSaveScreenAsPDF(arg1,arg2,arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_beginSaveScreenAsPDF__SWIG_2(lua_State* L) { int SWIG_arg = 0; std::string arg1 ; bool arg2 ; - SWIG_check_num_args("ofBeginSaveScreenAsPDF",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofBeginSaveScreenAsPDF",1,"std::string"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofBeginSaveScreenAsPDF",2,"bool"); (&arg1)->assign(lua_tostring(L,1),lua_rawlen(L,1)); - arg2 = (lua_toboolean(L, 2)!=0); ofBeginSaveScreenAsPDF(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_beginSaveScreenAsPDF__SWIG_3(lua_State* L) { int SWIG_arg = 0; std::string arg1 ; - SWIG_check_num_args("ofBeginSaveScreenAsPDF",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofBeginSaveScreenAsPDF",1,"std::string"); - (&arg1)->assign(lua_tostring(L,1),lua_rawlen(L,1)); ofBeginSaveScreenAsPDF(arg1); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_beginSaveScreenAsPDF(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 1) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { return _wrap_beginSaveScreenAsPDF__SWIG_3(L);} } - if (argc == 2) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_beginSaveScreenAsPDF__SWIG_2(L);} } } if (argc == 3) { int _v; { _v = lua_isstring(L,argv[0]); } - if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - return _wrap_beginSaveScreenAsPDF__SWIG_1(L);} } } } if (argc == 4) { int _v; { _v = lua_isstring(L,argv[0]); } - if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_beginSaveScreenAsPDF__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'beginSaveScreenAsPDF'\n" - " Possible C/C++ prototypes are:\n" " ofBeginSaveScreenAsPDF(std::string,bool,bool,ofRectangle)\n" - " ofBeginSaveScreenAsPDF(std::string,bool,bool)\n" " ofBeginSaveScreenAsPDF(std::string,bool)\n" - " ofBeginSaveScreenAsPDF(std::string)\n"); lua_error(L);return 0; } -static int _wrap_endSaveScreenAsPDF(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofEndSaveScreenAsPDF",0,0) - ofEndSaveScreenAsPDF(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_beginSaveScreenAsSVG__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string arg1 ; bool arg2 ; bool arg3 ; - ofRectangle arg4 ; ofRectangle *argp4 ; SWIG_check_num_args("ofBeginSaveScreenAsSVG",4,4) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofBeginSaveScreenAsSVG",1,"std::string"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofBeginSaveScreenAsSVG",2,"bool"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofBeginSaveScreenAsSVG",3,"bool"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofBeginSaveScreenAsSVG",4,"ofRectangle"); - (&arg1)->assign(lua_tostring(L,1),lua_rawlen(L,1)); arg2 = (lua_toboolean(L, 2)!=0); arg3 = (lua_toboolean(L, 3)!=0); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&argp4,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("beginSaveScreenAsSVG",4,SWIGTYPE_p_ofRectangle); } arg4 = *argp4; - ofBeginSaveScreenAsSVG(arg1,arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_beginSaveScreenAsSVG__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string arg1 ; bool arg2 ; bool arg3 ; - SWIG_check_num_args("ofBeginSaveScreenAsSVG",3,3) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofBeginSaveScreenAsSVG",1,"std::string"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofBeginSaveScreenAsSVG",2,"bool"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofBeginSaveScreenAsSVG",3,"bool"); (&arg1)->assign(lua_tostring(L,1),lua_rawlen(L,1)); - arg2 = (lua_toboolean(L, 2)!=0); arg3 = (lua_toboolean(L, 3)!=0); ofBeginSaveScreenAsSVG(arg1,arg2,arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_beginSaveScreenAsSVG__SWIG_2(lua_State* L) { int SWIG_arg = 0; std::string arg1 ; bool arg2 ; - SWIG_check_num_args("ofBeginSaveScreenAsSVG",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofBeginSaveScreenAsSVG",1,"std::string"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofBeginSaveScreenAsSVG",2,"bool"); (&arg1)->assign(lua_tostring(L,1),lua_rawlen(L,1)); - arg2 = (lua_toboolean(L, 2)!=0); ofBeginSaveScreenAsSVG(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_beginSaveScreenAsSVG__SWIG_3(lua_State* L) { int SWIG_arg = 0; std::string arg1 ; - SWIG_check_num_args("ofBeginSaveScreenAsSVG",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofBeginSaveScreenAsSVG",1,"std::string"); - (&arg1)->assign(lua_tostring(L,1),lua_rawlen(L,1)); ofBeginSaveScreenAsSVG(arg1); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_beginSaveScreenAsSVG(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 1) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { return _wrap_beginSaveScreenAsSVG__SWIG_3(L);} } - if (argc == 2) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_beginSaveScreenAsSVG__SWIG_2(L);} } } if (argc == 3) { int _v; { _v = lua_isstring(L,argv[0]); } - if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - return _wrap_beginSaveScreenAsSVG__SWIG_1(L);} } } } if (argc == 4) { int _v; { _v = lua_isstring(L,argv[0]); } - if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[3])==0 || SWIG_ConvertPtr(L,argv[3], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_beginSaveScreenAsSVG__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'beginSaveScreenAsSVG'\n" - " Possible C/C++ prototypes are:\n" " ofBeginSaveScreenAsSVG(std::string,bool,bool,ofRectangle)\n" - " ofBeginSaveScreenAsSVG(std::string,bool,bool)\n" " ofBeginSaveScreenAsSVG(std::string,bool)\n" - " ofBeginSaveScreenAsSVG(std::string)\n"); lua_error(L);return 0; } -static int _wrap_endSaveScreenAsSVG(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofEndSaveScreenAsSVG",0,0) - ofEndSaveScreenAsSVG(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setPlaneResolution(lua_State* L) { int SWIG_arg = 0; int arg1 ; int arg2 ; - SWIG_check_num_args("ofSetPlaneResolution",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetPlaneResolution",1,"int"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSetPlaneResolution",2,"int"); arg1 = (int)lua_tonumber(L, 1); - arg2 = (int)lua_tonumber(L, 2); ofSetPlaneResolution(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_getPlaneResolution(lua_State* L) { int SWIG_arg = 0; ofVec2f result; - SWIG_check_num_args("ofGetPlaneResolution",0,0) result = ofGetPlaneResolution(); { - ofVec2f * resultptr = new ofVec2f((const ofVec2f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec2f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_drawPlane__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - SWIG_check_num_args("ofDrawPlane",4,4) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawPlane",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawPlane",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawPlane",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawPlane",4,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - ofDrawPlane(arg1,arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawPlane__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - float arg5 ; SWIG_check_num_args("ofDrawPlane",5,5) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawPlane",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawPlane",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawPlane",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawPlane",4,"float"); if(!lua_isnumber(L,5)) SWIG_fail_arg("ofDrawPlane",5,"float"); - arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); ofDrawPlane(arg1,arg2,arg3,arg4,arg5); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawPlane__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPoint *arg1 = 0 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofDrawPlane",3,3) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofDrawPlane",1,"ofPoint &"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawPlane",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawPlane",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("drawPlane",1,SWIGTYPE_p_ofVec3f); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); ofDrawPlane(*arg1,arg2,arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawPlane__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; - SWIG_check_num_args("ofDrawPlane",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawPlane",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawPlane",2,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); ofDrawPlane(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_drawPlane(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 2) { int _v; - { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_drawPlane__SWIG_3(L);} - } } if (argc == 3) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_drawPlane__SWIG_2(L);} } } } if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_drawPlane__SWIG_0(L);} } } } } if (argc == 5) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_drawPlane__SWIG_1(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'drawPlane'\n" " Possible C/C++ prototypes are:\n" - " ofDrawPlane(float,float,float,float)\n" " ofDrawPlane(float,float,float,float,float)\n" - " ofDrawPlane(ofPoint &,float,float)\n" " ofDrawPlane(float,float)\n"); lua_error(L);return 0; } -static int _wrap_setSphereResolution(lua_State* L) { int SWIG_arg = 0; int arg1 ; - SWIG_check_num_args("ofSetSphereResolution",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetSphereResolution",1,"int"); - arg1 = (int)lua_tonumber(L, 1); ofSetSphereResolution(arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_getSphereResolution(lua_State* L) { int SWIG_arg = 0; int result; - SWIG_check_num_args("ofGetSphereResolution",0,0) result = (int)ofGetSphereResolution(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawSphere__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofDrawSphere",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawSphere",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawSphere",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawSphere",3,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); ofDrawSphere(arg1,arg2,arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawSphere__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - SWIG_check_num_args("ofDrawSphere",4,4) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawSphere",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawSphere",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawSphere",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawSphere",4,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - ofDrawSphere(arg1,arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawSphere__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPoint *arg1 = 0 ; float arg2 ; - SWIG_check_num_args("ofDrawSphere",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofDrawSphere",1,"ofPoint const &"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawSphere",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("drawSphere",1,SWIGTYPE_p_ofVec3f); } - arg2 = (float)lua_tonumber(L, 2); ofDrawSphere((ofVec3f const &)*arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_drawSphere__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; SWIG_check_num_args("ofDrawSphere",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawSphere",1,"float"); arg1 = (float)lua_tonumber(L, 1); ofDrawSphere(arg1); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawSphere(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 1) { int _v; - { _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_drawSphere__SWIG_3(L);} } if (argc == 2) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_drawSphere__SWIG_2(L);} } } - if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_drawSphere__SWIG_0(L);} } } } if (argc == 4) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_drawSphere__SWIG_1(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'drawSphere'\n" " Possible C/C++ prototypes are:\n" - " ofDrawSphere(float,float,float)\n" " ofDrawSphere(float,float,float,float)\n" - " ofDrawSphere(ofPoint const &,float)\n" " ofDrawSphere(float)\n"); lua_error(L);return 0; } -static int _wrap_setIcoSphereResolution(lua_State* L) { int SWIG_arg = 0; int arg1 ; - SWIG_check_num_args("ofSetIcoSphereResolution",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetIcoSphereResolution",1,"int"); - arg1 = (int)lua_tonumber(L, 1); ofSetIcoSphereResolution(arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_getIcoSphereResolution(lua_State* L) { int SWIG_arg = 0; int result; - SWIG_check_num_args("ofGetIcoSphereResolution",0,0) result = (int)ofGetIcoSphereResolution(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawIcoSphere__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - SWIG_check_num_args("ofDrawIcoSphere",4,4) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawIcoSphere",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawIcoSphere",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawIcoSphere",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawIcoSphere",4,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - ofDrawIcoSphere(arg1,arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawIcoSphere__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofDrawIcoSphere",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawIcoSphere",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawIcoSphere",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawIcoSphere",3,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); ofDrawIcoSphere(arg1,arg2,arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawIcoSphere__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPoint *arg1 = 0 ; float arg2 ; - SWIG_check_num_args("ofDrawIcoSphere",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofDrawIcoSphere",1,"ofPoint const &"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawIcoSphere",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("drawIcoSphere",1,SWIGTYPE_p_ofVec3f); } arg2 = (float)lua_tonumber(L, 2); - ofDrawIcoSphere((ofVec3f const &)*arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawIcoSphere__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; SWIG_check_num_args("ofDrawIcoSphere",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawIcoSphere",1,"float"); arg1 = (float)lua_tonumber(L, 1); ofDrawIcoSphere(arg1); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawIcoSphere(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_drawIcoSphere__SWIG_3(L);} } if (argc == 2) { int _v; { - void *ptr; if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_drawIcoSphere__SWIG_2(L);} } } if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_drawIcoSphere__SWIG_1(L);} } } } if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_drawIcoSphere__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'drawIcoSphere'\n" " Possible C/C++ prototypes are:\n" - " ofDrawIcoSphere(float,float,float,float)\n" " ofDrawIcoSphere(float,float,float)\n" - " ofDrawIcoSphere(ofPoint const &,float)\n" " ofDrawIcoSphere(float)\n"); lua_error(L);return 0; } -static int _wrap_setCylinderResolution__SWIG_0(lua_State* L) { int SWIG_arg = 0; int arg1 ; int arg2 ; int arg3 ; - SWIG_check_num_args("ofSetCylinderResolution",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetCylinderResolution",1,"int"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSetCylinderResolution",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofSetCylinderResolution",3,"int"); arg1 = (int)lua_tonumber(L, 1); - arg2 = (int)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); ofSetCylinderResolution(arg1,arg2,arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setCylinderResolution__SWIG_1(lua_State* L) { int SWIG_arg = 0; int arg1 ; int arg2 ; - SWIG_check_num_args("ofSetCylinderResolution",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetCylinderResolution",1,"int"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSetCylinderResolution",2,"int"); arg1 = (int)lua_tonumber(L, 1); - arg2 = (int)lua_tonumber(L, 2); ofSetCylinderResolution(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_setCylinderResolution(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_setCylinderResolution__SWIG_1(L);} } } if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_setCylinderResolution__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'setCylinderResolution'\n" - " Possible C/C++ prototypes are:\n" " ofSetCylinderResolution(int,int,int)\n" " ofSetCylinderResolution(int,int)\n"); - lua_error(L);return 0; } -static int _wrap_getCylinderResolution(lua_State* L) { int SWIG_arg = 0; ofVec3f result; - SWIG_check_num_args("ofGetCylinderResolution",0,0) result = ofGetCylinderResolution(); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_drawCylinder__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - SWIG_check_num_args("ofDrawCylinder",4,4) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawCylinder",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawCylinder",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawCylinder",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawCylinder",4,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - ofDrawCylinder(arg1,arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawCylinder__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - float arg5 ; SWIG_check_num_args("ofDrawCylinder",5,5) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawCylinder",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawCylinder",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawCylinder",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawCylinder",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofDrawCylinder",5,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); ofDrawCylinder(arg1,arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_drawCylinder__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPoint *arg1 = 0 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofDrawCylinder",3,3) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofDrawCylinder",1,"ofPoint const &"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawCylinder",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawCylinder",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("drawCylinder",1,SWIGTYPE_p_ofVec3f); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); ofDrawCylinder((ofVec3f const &)*arg1,arg2,arg3); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawCylinder__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; - SWIG_check_num_args("ofDrawCylinder",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawCylinder",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawCylinder",2,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); ofDrawCylinder(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_drawCylinder(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_drawCylinder__SWIG_3(L);} } } if (argc == 3) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_drawCylinder__SWIG_2(L);} } } } if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { - { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_drawCylinder__SWIG_0(L);} } } } } if (argc == 5) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_drawCylinder__SWIG_1(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'drawCylinder'\n" " Possible C/C++ prototypes are:\n" - " ofDrawCylinder(float,float,float,float)\n" " ofDrawCylinder(float,float,float,float,float)\n" - " ofDrawCylinder(ofPoint const &,float,float)\n" " ofDrawCylinder(float,float)\n"); lua_error(L);return 0; } -static int _wrap_setConeResolution__SWIG_0(lua_State* L) { int SWIG_arg = 0; int arg1 ; int arg2 ; int arg3 ; - SWIG_check_num_args("ofSetConeResolution",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetConeResolution",1,"int"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSetConeResolution",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofSetConeResolution",3,"int"); arg1 = (int)lua_tonumber(L, 1); - arg2 = (int)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); ofSetConeResolution(arg1,arg2,arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setConeResolution__SWIG_1(lua_State* L) { int SWIG_arg = 0; int arg1 ; int arg2 ; - SWIG_check_num_args("ofSetConeResolution",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetConeResolution",1,"int"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSetConeResolution",2,"int"); arg1 = (int)lua_tonumber(L, 1); - arg2 = (int)lua_tonumber(L, 2); ofSetConeResolution(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_setConeResolution(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_setConeResolution__SWIG_1(L);} } } if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { - { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_setConeResolution__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'setConeResolution'\n" " Possible C/C++ prototypes are:\n" - " ofSetConeResolution(int,int,int)\n" " ofSetConeResolution(int,int)\n"); lua_error(L);return 0; } -static int _wrap_getConeResolution(lua_State* L) { int SWIG_arg = 0; ofVec3f result; - SWIG_check_num_args("ofGetConeResolution",0,0) result = ofGetConeResolution(); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_drawCone__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - float arg5 ; SWIG_check_num_args("ofDrawCone",5,5) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawCone",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawCone",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawCone",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawCone",4,"float"); if(!lua_isnumber(L,5)) SWIG_fail_arg("ofDrawCone",5,"float"); - arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); ofDrawCone(arg1,arg2,arg3,arg4,arg5); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawCone__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - SWIG_check_num_args("ofDrawCone",4,4) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawCone",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawCone",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawCone",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawCone",4,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - ofDrawCone(arg1,arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawCone__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPoint *arg1 = 0 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofDrawCone",3,3) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofDrawCone",1,"ofPoint const &"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawCone",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawCone",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("drawCone",1,SWIGTYPE_p_ofVec3f); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); ofDrawCone((ofVec3f const &)*arg1,arg2,arg3); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawCone__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; - SWIG_check_num_args("ofDrawCone",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawCone",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawCone",2,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); ofDrawCone(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_drawCone(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 2) { int _v; - { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_drawCone__SWIG_3(L);} - } } if (argc == 3) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_drawCone__SWIG_2(L);} } } } if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_drawCone__SWIG_1(L);} } } } } if (argc == 5) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_drawCone__SWIG_0(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'drawCone'\n" " Possible C/C++ prototypes are:\n" - " ofDrawCone(float,float,float,float,float)\n" " ofDrawCone(float,float,float,float)\n" - " ofDrawCone(ofPoint const &,float,float)\n" " ofDrawCone(float,float)\n"); lua_error(L);return 0; } -static int _wrap_setBoxResolution__SWIG_0(lua_State* L) { int SWIG_arg = 0; int arg1 ; - SWIG_check_num_args("ofSetBoxResolution",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetBoxResolution",1,"int"); - arg1 = (int)lua_tonumber(L, 1); ofSetBoxResolution(arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_setBoxResolution__SWIG_1(lua_State* L) { int SWIG_arg = 0; int arg1 ; int arg2 ; int arg3 ; - SWIG_check_num_args("ofSetBoxResolution",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetBoxResolution",1,"int"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSetBoxResolution",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofSetBoxResolution",3,"int"); arg1 = (int)lua_tonumber(L, 1); - arg2 = (int)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); ofSetBoxResolution(arg1,arg2,arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setBoxResolution(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_setBoxResolution__SWIG_0(L);} } if (argc == 3) { int _v; - { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_setBoxResolution__SWIG_1(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'setBoxResolution'\n" " Possible C/C++ prototypes are:\n" - " ofSetBoxResolution(int)\n" " ofSetBoxResolution(int,int,int)\n"); lua_error(L);return 0; } -static int _wrap_getBoxResolution(lua_State* L) { int SWIG_arg = 0; ofVec3f result; - SWIG_check_num_args("ofGetBoxResolution",0,0) result = ofGetBoxResolution(); { - ofVec3f * resultptr = new ofVec3f((const ofVec3f &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_drawBox__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - float arg5 ; float arg6 ; SWIG_check_num_args("ofDrawBox",6,6) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawBox",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawBox",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawBox",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawBox",4,"float"); if(!lua_isnumber(L,5)) SWIG_fail_arg("ofDrawBox",5,"float"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofDrawBox",6,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - arg5 = (float)lua_tonumber(L, 5); arg6 = (float)lua_tonumber(L, 6); ofDrawBox(arg1,arg2,arg3,arg4,arg5,arg6); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawBox__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - SWIG_check_num_args("ofDrawBox",4,4) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawBox",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawBox",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawBox",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawBox",4,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - ofDrawBox(arg1,arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawBox__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPoint *arg1 = 0 ; float arg2 ; float arg3 ; float arg4 ; - SWIG_check_num_args("ofDrawBox",4,4) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofDrawBox",1,"ofPoint const &"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawBox",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawBox",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofDrawBox",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("drawBox",1,SWIGTYPE_p_ofVec3f); } - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - ofDrawBox((ofVec3f const &)*arg1,arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawBox__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofPoint *arg1 = 0 ; float arg2 ; - SWIG_check_num_args("ofDrawBox",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofDrawBox",1,"ofPoint const &"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawBox",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ SWIG_fail_ptr("drawBox",1,SWIGTYPE_p_ofVec3f); } - arg2 = (float)lua_tonumber(L, 2); ofDrawBox((ofVec3f const &)*arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_drawBox__SWIG_4(lua_State* L) { int SWIG_arg = 0; float arg1 ; SWIG_check_num_args("ofDrawBox",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawBox",1,"float"); arg1 = (float)lua_tonumber(L, 1); ofDrawBox(arg1); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawBox__SWIG_5(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofDrawBox",3,3) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofDrawBox",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDrawBox",2,"float"); if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDrawBox",3,"float"); - arg1 = (float)lua_tonumber(L, 1); arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - ofDrawBox(arg1,arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_drawBox(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); if (argc == 1) { int _v; - { _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_drawBox__SWIG_4(L);} } if (argc == 2) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_drawBox__SWIG_3(L);} } } - if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_drawBox__SWIG_5(L);} } } } if (argc == 4) { int _v; { - void *ptr; if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_drawBox__SWIG_2(L);} } } } } if (argc == 4) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { - return _wrap_drawBox__SWIG_1(L);} } } } } if (argc == 6) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { - { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { - return _wrap_drawBox__SWIG_0(L);} } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'drawBox'\n" " Possible C/C++ prototypes are:\n" - " ofDrawBox(float,float,float,float,float,float)\n" " ofDrawBox(float,float,float,float)\n" - " ofDrawBox(ofPoint const &,float,float,float)\n" " ofDrawBox(ofPoint const &,float)\n" " ofDrawBox(float)\n" - " ofDrawBox(float,float,float)\n"); lua_error(L);return 0; } -static int _wrap_TTF_SANS_get(lua_State* L) { int SWIG_arg = 0; std::string *result = 0 ; SWIG_check_num_args("OF_TTF_SANS",0,0) - result = (std::string *) &OF_TTF_SANS; lua_pushlstring(L,result->data(),result->size()); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TTF_SERIF_get(lua_State* L) { int SWIG_arg = 0; std::string *result = 0 ; - SWIG_check_num_args("OF_TTF_SERIF",0,0) result = (std::string *) &OF_TTF_SERIF; - lua_pushlstring(L,result->data(),result->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_TTF_MONO_get(lua_State* L) { int SWIG_arg = 0; std::string *result = 0 ; SWIG_check_num_args("OF_TTF_MONO",0,0) - result = (std::string *) &OF_TTF_MONO; lua_pushlstring(L,result->data(),result->size()); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_new_TrueTypeFont__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofTrueTypeFont *result = 0 ; - SWIG_check_num_args("ofTrueTypeFont::ofTrueTypeFont",0,0) result = (ofTrueTypeFont *)new ofTrueTypeFont(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTrueTypeFont,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_TrueTypeFont__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofTrueTypeFont *arg1 = 0 ; - ofTrueTypeFont *result = 0 ; SWIG_check_num_args("ofTrueTypeFont::ofTrueTypeFont",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofTrueTypeFont::ofTrueTypeFont",1,"ofTrueTypeFont &&"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("new_TrueTypeFont",1,SWIGTYPE_p_ofTrueTypeFont); } - result = (ofTrueTypeFont *)new ofTrueTypeFont((ofTrueTypeFont &&)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTrueTypeFont,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_TrueTypeFont(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_TrueTypeFont__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTrueTypeFont, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_new_TrueTypeFont__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_TrueTypeFont'\n" " Possible C/C++ prototypes are:\n" - " ofTrueTypeFont::ofTrueTypeFont()\n" " ofTrueTypeFont::ofTrueTypeFont(ofTrueTypeFont &&)\n"); lua_error(L);return 0; } -static int _wrap_TrueTypeFont_load__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; - std::string *arg2 = 0 ; int arg3 ; bool arg4 ; bool arg5 ; bool arg6 ; float arg7 ; int arg8 ; std::string temp2 ; - bool result; SWIG_check_num_args("ofTrueTypeFont::load",8,8) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::load",1,"ofTrueTypeFont *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofTrueTypeFont::load",2,"std::string const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTrueTypeFont::load",3,"int"); - if(!lua_isboolean(L,4)) SWIG_fail_arg("ofTrueTypeFont::load",4,"bool"); - if(!lua_isboolean(L,5)) SWIG_fail_arg("ofTrueTypeFont::load",5,"bool"); - if(!lua_isboolean(L,6)) SWIG_fail_arg("ofTrueTypeFont::load",6,"bool"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofTrueTypeFont::load",7,"float"); - if(!lua_isnumber(L,8)) SWIG_fail_arg("ofTrueTypeFont::load",8,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_load",1,SWIGTYPE_p_ofTrueTypeFont); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; arg3 = (int)lua_tonumber(L, 3); arg4 = (lua_toboolean(L, 4)!=0); - arg5 = (lua_toboolean(L, 5)!=0); arg6 = (lua_toboolean(L, 6)!=0); arg7 = (float)lua_tonumber(L, 7); - arg8 = (int)lua_tonumber(L, 8); result = (bool)(arg1)->load((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7,arg8); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_load__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; - std::string *arg2 = 0 ; int arg3 ; bool arg4 ; bool arg5 ; bool arg6 ; float arg7 ; std::string temp2 ; bool result; - SWIG_check_num_args("ofTrueTypeFont::load",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::load",1,"ofTrueTypeFont *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofTrueTypeFont::load",2,"std::string const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTrueTypeFont::load",3,"int"); - if(!lua_isboolean(L,4)) SWIG_fail_arg("ofTrueTypeFont::load",4,"bool"); - if(!lua_isboolean(L,5)) SWIG_fail_arg("ofTrueTypeFont::load",5,"bool"); - if(!lua_isboolean(L,6)) SWIG_fail_arg("ofTrueTypeFont::load",6,"bool"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofTrueTypeFont::load",7,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_load",1,SWIGTYPE_p_ofTrueTypeFont); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; arg3 = (int)lua_tonumber(L, 3); arg4 = (lua_toboolean(L, 4)!=0); - arg5 = (lua_toboolean(L, 5)!=0); arg6 = (lua_toboolean(L, 6)!=0); arg7 = (float)lua_tonumber(L, 7); - result = (bool)(arg1)->load((std::string const &)*arg2,arg3,arg4,arg5,arg6,arg7); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_load__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; - std::string *arg2 = 0 ; int arg3 ; bool arg4 ; bool arg5 ; bool arg6 ; std::string temp2 ; bool result; - SWIG_check_num_args("ofTrueTypeFont::load",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::load",1,"ofTrueTypeFont *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofTrueTypeFont::load",2,"std::string const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTrueTypeFont::load",3,"int"); - if(!lua_isboolean(L,4)) SWIG_fail_arg("ofTrueTypeFont::load",4,"bool"); - if(!lua_isboolean(L,5)) SWIG_fail_arg("ofTrueTypeFont::load",5,"bool"); - if(!lua_isboolean(L,6)) SWIG_fail_arg("ofTrueTypeFont::load",6,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_load",1,SWIGTYPE_p_ofTrueTypeFont); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; arg3 = (int)lua_tonumber(L, 3); arg4 = (lua_toboolean(L, 4)!=0); - arg5 = (lua_toboolean(L, 5)!=0); arg6 = (lua_toboolean(L, 6)!=0); - result = (bool)(arg1)->load((std::string const &)*arg2,arg3,arg4,arg5,arg6); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_load__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; - std::string *arg2 = 0 ; int arg3 ; bool arg4 ; bool arg5 ; std::string temp2 ; bool result; - SWIG_check_num_args("ofTrueTypeFont::load",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::load",1,"ofTrueTypeFont *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofTrueTypeFont::load",2,"std::string const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTrueTypeFont::load",3,"int"); - if(!lua_isboolean(L,4)) SWIG_fail_arg("ofTrueTypeFont::load",4,"bool"); - if(!lua_isboolean(L,5)) SWIG_fail_arg("ofTrueTypeFont::load",5,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_load",1,SWIGTYPE_p_ofTrueTypeFont); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; arg3 = (int)lua_tonumber(L, 3); arg4 = (lua_toboolean(L, 4)!=0); - arg5 = (lua_toboolean(L, 5)!=0); result = (bool)(arg1)->load((std::string const &)*arg2,arg3,arg4,arg5); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_load__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; - std::string *arg2 = 0 ; int arg3 ; bool arg4 ; std::string temp2 ; bool result; - SWIG_check_num_args("ofTrueTypeFont::load",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::load",1,"ofTrueTypeFont *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofTrueTypeFont::load",2,"std::string const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTrueTypeFont::load",3,"int"); - if(!lua_isboolean(L,4)) SWIG_fail_arg("ofTrueTypeFont::load",4,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_load",1,SWIGTYPE_p_ofTrueTypeFont); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; arg3 = (int)lua_tonumber(L, 3); arg4 = (lua_toboolean(L, 4)!=0); - result = (bool)(arg1)->load((std::string const &)*arg2,arg3,arg4); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_load__SWIG_5(lua_State* L) { int SWIG_arg = 0; ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; - std::string *arg2 = 0 ; int arg3 ; std::string temp2 ; bool result; SWIG_check_num_args("ofTrueTypeFont::load",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::load",1,"ofTrueTypeFont *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofTrueTypeFont::load",2,"std::string const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTrueTypeFont::load",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_load",1,SWIGTYPE_p_ofTrueTypeFont); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; arg3 = (int)lua_tonumber(L, 3); - result = (bool)(arg1)->load((std::string const &)*arg2,arg3); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_load(lua_State* L) { int argc; int argv[9]={ 1,2,3,4,5,6,7,8,9} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTrueTypeFont, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_TrueTypeFont_load__SWIG_5(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTrueTypeFont, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isboolean(L,argv[3]); } if (_v) { return _wrap_TrueTypeFont_load__SWIG_4(L);} } } } } - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTrueTypeFont, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isboolean(L,argv[3]); } if (_v) { { _v = lua_isboolean(L,argv[4]); } if (_v) { - return _wrap_TrueTypeFont_load__SWIG_3(L);} } } } } } if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTrueTypeFont, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isboolean(L,argv[3]); } if (_v) { { _v = lua_isboolean(L,argv[4]); } if (_v) { { - _v = lua_isboolean(L,argv[5]); } if (_v) { return _wrap_TrueTypeFont_load__SWIG_2(L);} } } } } } } - if (argc == 7) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTrueTypeFont, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isboolean(L,argv[3]); } if (_v) { { _v = lua_isboolean(L,argv[4]); } if (_v) { { - _v = lua_isboolean(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { - return _wrap_TrueTypeFont_load__SWIG_1(L);} } } } } } } } if (argc == 8) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTrueTypeFont, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isboolean(L,argv[3]); } if (_v) { { _v = lua_isboolean(L,argv[4]); } if (_v) { { - _v = lua_isboolean(L,argv[5]); } if (_v) { { _v = lua_isnumber(L,argv[6]); } if (_v) { { - _v = lua_isnumber(L,argv[7]); } if (_v) { return _wrap_TrueTypeFont_load__SWIG_0(L);} } } } } } } } - } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'TrueTypeFont_load'\n" - " Possible C/C++ prototypes are:\n" " ofTrueTypeFont::load(std::string const &,int,bool,bool,bool,float,int)\n" - " ofTrueTypeFont::load(std::string const &,int,bool,bool,bool,float)\n" - " ofTrueTypeFont::load(std::string const &,int,bool,bool,bool)\n" - " ofTrueTypeFont::load(std::string const &,int,bool,bool)\n" " ofTrueTypeFont::load(std::string const &,int,bool)\n" - " ofTrueTypeFont::load(std::string const &,int)\n"); lua_error(L);return 0; } -static int _wrap_TrueTypeFont_isLoaded(lua_State* L) { int SWIG_arg = 0; ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; - bool result; SWIG_check_num_args("ofTrueTypeFont::isLoaded",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::isLoaded",1,"ofTrueTypeFont const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_isLoaded",1,SWIGTYPE_p_ofTrueTypeFont); } - result = (bool)((ofTrueTypeFont const *)arg1)->isLoaded(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_setGlobalDpi(lua_State* L) { int SWIG_arg = 0; int arg1 ; - SWIG_check_num_args("ofTrueTypeFont::setGlobalDpi",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofTrueTypeFont::setGlobalDpi",1,"int"); arg1 = (int)lua_tonumber(L, 1); - ofTrueTypeFont::setGlobalDpi(arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_isAntiAliased(lua_State* L) { int SWIG_arg = 0; ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; - bool result; SWIG_check_num_args("ofTrueTypeFont::isAntiAliased",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::isAntiAliased",1,"ofTrueTypeFont const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_isAntiAliased",1,SWIGTYPE_p_ofTrueTypeFont); } - result = (bool)((ofTrueTypeFont const *)arg1)->isAntiAliased(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_hasFullCharacterSet(lua_State* L) { int SWIG_arg = 0; - ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; bool result; SWIG_check_num_args("ofTrueTypeFont::hasFullCharacterSet",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::hasFullCharacterSet",1,"ofTrueTypeFont const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_hasFullCharacterSet",1,SWIGTYPE_p_ofTrueTypeFont); } - result = (bool)((ofTrueTypeFont const *)arg1)->hasFullCharacterSet(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_getNumCharacters(lua_State* L) { int SWIG_arg = 0; ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; - int result; SWIG_check_num_args("ofTrueTypeFont::getNumCharacters",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::getNumCharacters",1,"ofTrueTypeFont const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_getNumCharacters",1,SWIGTYPE_p_ofTrueTypeFont); } - result = (int)((ofTrueTypeFont const *)arg1)->getNumCharacters(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_getSize(lua_State* L) { int SWIG_arg = 0; ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; - int result; SWIG_check_num_args("ofTrueTypeFont::getSize",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::getSize",1,"ofTrueTypeFont const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_getSize",1,SWIGTYPE_p_ofTrueTypeFont); } - result = (int)((ofTrueTypeFont const *)arg1)->getSize(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_getLineHeight(lua_State* L) { int SWIG_arg = 0; ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; - float result; SWIG_check_num_args("ofTrueTypeFont::getLineHeight",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::getLineHeight",1,"ofTrueTypeFont const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_getLineHeight",1,SWIGTYPE_p_ofTrueTypeFont); } - result = (float)((ofTrueTypeFont const *)arg1)->getLineHeight(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_setLineHeight(lua_State* L) { int SWIG_arg = 0; ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; - float arg2 ; SWIG_check_num_args("ofTrueTypeFont::setLineHeight",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::setLineHeight",1,"ofTrueTypeFont *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTrueTypeFont::setLineHeight",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_setLineHeight",1,SWIGTYPE_p_ofTrueTypeFont); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setLineHeight(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_getAscenderHeight(lua_State* L) { int SWIG_arg = 0; ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; - float result; SWIG_check_num_args("ofTrueTypeFont::getAscenderHeight",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::getAscenderHeight",1,"ofTrueTypeFont const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_getAscenderHeight",1,SWIGTYPE_p_ofTrueTypeFont); } - result = (float)((ofTrueTypeFont const *)arg1)->getAscenderHeight(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_getDescenderHeight(lua_State* L) { int SWIG_arg = 0; ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; - float result; SWIG_check_num_args("ofTrueTypeFont::getDescenderHeight",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::getDescenderHeight",1,"ofTrueTypeFont const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_getDescenderHeight",1,SWIGTYPE_p_ofTrueTypeFont); } - result = (float)((ofTrueTypeFont const *)arg1)->getDescenderHeight(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_getGlyphBBox(lua_State* L) { int SWIG_arg = 0; ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; - ofRectangle *result = 0 ; SWIG_check_num_args("ofTrueTypeFont::getGlyphBBox",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::getGlyphBBox",1,"ofTrueTypeFont const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_getGlyphBBox",1,SWIGTYPE_p_ofTrueTypeFont); } - result = (ofRectangle *) &((ofTrueTypeFont const *)arg1)->getGlyphBBox(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofRectangle,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_TrueTypeFont_getLetterSpacing(lua_State* L) { int SWIG_arg = 0; ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; - float result; SWIG_check_num_args("ofTrueTypeFont::getLetterSpacing",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::getLetterSpacing",1,"ofTrueTypeFont const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_getLetterSpacing",1,SWIGTYPE_p_ofTrueTypeFont); } - result = (float)((ofTrueTypeFont const *)arg1)->getLetterSpacing(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_setLetterSpacing(lua_State* L) { int SWIG_arg = 0; ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; - float arg2 ; SWIG_check_num_args("ofTrueTypeFont::setLetterSpacing",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::setLetterSpacing",1,"ofTrueTypeFont *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTrueTypeFont::setLetterSpacing",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_setLetterSpacing",1,SWIGTYPE_p_ofTrueTypeFont); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setLetterSpacing(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_getSpaceSize(lua_State* L) { int SWIG_arg = 0; ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; - float result; SWIG_check_num_args("ofTrueTypeFont::getSpaceSize",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::getSpaceSize",1,"ofTrueTypeFont const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_getSpaceSize",1,SWIGTYPE_p_ofTrueTypeFont); } - result = (float)((ofTrueTypeFont const *)arg1)->getSpaceSize(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_setSpaceSize(lua_State* L) { int SWIG_arg = 0; ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; - float arg2 ; SWIG_check_num_args("ofTrueTypeFont::setSpaceSize",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::setSpaceSize",1,"ofTrueTypeFont *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTrueTypeFont::setSpaceSize",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_setSpaceSize",1,SWIGTYPE_p_ofTrueTypeFont); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setSpaceSize(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_stringWidth(lua_State* L) { int SWIG_arg = 0; ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; - std::string *arg2 = 0 ; std::string temp2 ; float result; SWIG_check_num_args("ofTrueTypeFont::stringWidth",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::stringWidth",1,"ofTrueTypeFont const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofTrueTypeFont::stringWidth",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_stringWidth",1,SWIGTYPE_p_ofTrueTypeFont); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = (float)((ofTrueTypeFont const *)arg1)->stringWidth((std::string const &)*arg2); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_stringHeight(lua_State* L) { int SWIG_arg = 0; ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; - std::string *arg2 = 0 ; std::string temp2 ; float result; SWIG_check_num_args("ofTrueTypeFont::stringHeight",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::stringHeight",1,"ofTrueTypeFont const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofTrueTypeFont::stringHeight",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_stringHeight",1,SWIGTYPE_p_ofTrueTypeFont); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = (float)((ofTrueTypeFont const *)arg1)->stringHeight((std::string const &)*arg2); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_getStringBoundingBox__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; std::string *arg2 = 0 ; float arg3 ; float arg4 ; bool arg5 ; - std::string temp2 ; ofRectangle result; SWIG_check_num_args("ofTrueTypeFont::getStringBoundingBox",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::getStringBoundingBox",1,"ofTrueTypeFont const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofTrueTypeFont::getStringBoundingBox",2,"std::string const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTrueTypeFont::getStringBoundingBox",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofTrueTypeFont::getStringBoundingBox",4,"float"); - if(!lua_isboolean(L,5)) SWIG_fail_arg("ofTrueTypeFont::getStringBoundingBox",5,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_getStringBoundingBox",1,SWIGTYPE_p_ofTrueTypeFont); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; arg3 = (float)lua_tonumber(L, 3); - arg4 = (float)lua_tonumber(L, 4); arg5 = (lua_toboolean(L, 5)!=0); - result = ((ofTrueTypeFont const *)arg1)->getStringBoundingBox((std::string const &)*arg2,arg3,arg4,arg5); { - ofRectangle * resultptr = new ofRectangle((const ofRectangle &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofRectangle,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_getStringBoundingBox__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; std::string *arg2 = 0 ; float arg3 ; float arg4 ; std::string temp2 ; - ofRectangle result; SWIG_check_num_args("ofTrueTypeFont::getStringBoundingBox",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::getStringBoundingBox",1,"ofTrueTypeFont const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofTrueTypeFont::getStringBoundingBox",2,"std::string const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTrueTypeFont::getStringBoundingBox",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofTrueTypeFont::getStringBoundingBox",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_getStringBoundingBox",1,SWIGTYPE_p_ofTrueTypeFont); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; arg3 = (float)lua_tonumber(L, 3); - arg4 = (float)lua_tonumber(L, 4); - result = ((ofTrueTypeFont const *)arg1)->getStringBoundingBox((std::string const &)*arg2,arg3,arg4); { - ofRectangle * resultptr = new ofRectangle((const ofRectangle &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofRectangle,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_getStringBoundingBox(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); - if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTrueTypeFont, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_TrueTypeFont_getStringBoundingBox__SWIG_1(L);} } } } } - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTrueTypeFont, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isboolean(L,argv[4]); } if (_v) { - return _wrap_TrueTypeFont_getStringBoundingBox__SWIG_0(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'TrueTypeFont_getStringBoundingBox'\n" - " Possible C/C++ prototypes are:\n" " ofTrueTypeFont::getStringBoundingBox(std::string const &,float,float,bool) const\n" - " ofTrueTypeFont::getStringBoundingBox(std::string const &,float,float) const\n"); lua_error(L);return 0; } -static int _wrap_TrueTypeFont_drawString(lua_State* L) { int SWIG_arg = 0; ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; - std::string *arg2 = 0 ; float arg3 ; float arg4 ; std::string temp2 ; SWIG_check_num_args("ofTrueTypeFont::drawString",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::drawString",1,"ofTrueTypeFont const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofTrueTypeFont::drawString",2,"std::string const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTrueTypeFont::drawString",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofTrueTypeFont::drawString",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_drawString",1,SWIGTYPE_p_ofTrueTypeFont); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; arg3 = (float)lua_tonumber(L, 3); - arg4 = (float)lua_tonumber(L, 4); ((ofTrueTypeFont const *)arg1)->drawString((std::string const &)*arg2,arg3,arg4); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_drawStringAsShapes(lua_State* L) { int SWIG_arg = 0; ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; - std::string *arg2 = 0 ; float arg3 ; float arg4 ; std::string temp2 ; - SWIG_check_num_args("ofTrueTypeFont::drawStringAsShapes",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::drawStringAsShapes",1,"ofTrueTypeFont const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofTrueTypeFont::drawStringAsShapes",2,"std::string const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTrueTypeFont::drawStringAsShapes",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofTrueTypeFont::drawStringAsShapes",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_drawStringAsShapes",1,SWIGTYPE_p_ofTrueTypeFont); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; arg3 = (float)lua_tonumber(L, 3); - arg4 = (float)lua_tonumber(L, 4); ((ofTrueTypeFont const *)arg1)->drawStringAsShapes((std::string const &)*arg2,arg3,arg4); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_getCharacterAsPoints__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; int arg2 ; bool arg3 ; bool arg4 ; ofTTFCharacter result; - SWIG_check_num_args("ofTrueTypeFont::getCharacterAsPoints",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::getCharacterAsPoints",1,"ofTrueTypeFont const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTrueTypeFont::getCharacterAsPoints",2,"int"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofTrueTypeFont::getCharacterAsPoints",3,"bool"); - if(!lua_isboolean(L,4)) SWIG_fail_arg("ofTrueTypeFont::getCharacterAsPoints",4,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_getCharacterAsPoints",1,SWIGTYPE_p_ofTrueTypeFont); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (lua_toboolean(L, 3)!=0); arg4 = (lua_toboolean(L, 4)!=0); - result = ((ofTrueTypeFont const *)arg1)->getCharacterAsPoints(arg2,arg3,arg4); { - ofTTFCharacter * resultptr = new ofTTFCharacter((const ofTTFCharacter &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofPath,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_getCharacterAsPoints__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; int arg2 ; bool arg3 ; ofTTFCharacter result; - SWIG_check_num_args("ofTrueTypeFont::getCharacterAsPoints",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::getCharacterAsPoints",1,"ofTrueTypeFont const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTrueTypeFont::getCharacterAsPoints",2,"int"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofTrueTypeFont::getCharacterAsPoints",3,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_getCharacterAsPoints",1,SWIGTYPE_p_ofTrueTypeFont); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (lua_toboolean(L, 3)!=0); result = ((ofTrueTypeFont const *)arg1)->getCharacterAsPoints(arg2,arg3); { - ofTTFCharacter * resultptr = new ofTTFCharacter((const ofTTFCharacter &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofPath,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_getCharacterAsPoints__SWIG_2(lua_State* L) { int SWIG_arg = 0; - ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; int arg2 ; ofTTFCharacter result; - SWIG_check_num_args("ofTrueTypeFont::getCharacterAsPoints",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::getCharacterAsPoints",1,"ofTrueTypeFont const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofTrueTypeFont::getCharacterAsPoints",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_getCharacterAsPoints",1,SWIGTYPE_p_ofTrueTypeFont); } arg2 = (int)lua_tonumber(L, 2); - result = ((ofTrueTypeFont const *)arg1)->getCharacterAsPoints(arg2); { - ofTTFCharacter * resultptr = new ofTTFCharacter((const ofTTFCharacter &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofPath,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_getCharacterAsPoints(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTrueTypeFont, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_TrueTypeFont_getCharacterAsPoints__SWIG_2(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTrueTypeFont, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - return _wrap_TrueTypeFont_getCharacterAsPoints__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTrueTypeFont, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - { _v = lua_isboolean(L,argv[3]); } if (_v) { return _wrap_TrueTypeFont_getCharacterAsPoints__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'TrueTypeFont_getCharacterAsPoints'\n" - " Possible C/C++ prototypes are:\n" " ofTrueTypeFont::getCharacterAsPoints(int,bool,bool) const\n" - " ofTrueTypeFont::getCharacterAsPoints(int,bool) const\n" " ofTrueTypeFont::getCharacterAsPoints(int) const\n"); - lua_error(L);return 0; } -static int _wrap_TrueTypeFont_getStringAsPoints__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; std::string *arg2 = 0 ; bool arg3 ; bool arg4 ; std::string temp2 ; - SwigValueWrapper< std::vector< ofPath > > result; SWIG_check_num_args("ofTrueTypeFont::getStringAsPoints",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::getStringAsPoints",1,"ofTrueTypeFont const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofTrueTypeFont::getStringAsPoints",2,"std::string const &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofTrueTypeFont::getStringAsPoints",3,"bool"); - if(!lua_isboolean(L,4)) SWIG_fail_arg("ofTrueTypeFont::getStringAsPoints",4,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_getStringAsPoints",1,SWIGTYPE_p_ofTrueTypeFont); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; arg3 = (lua_toboolean(L, 3)!=0); - arg4 = (lua_toboolean(L, 4)!=0); - result = ((ofTrueTypeFont const *)arg1)->getStringAsPoints((std::string const &)*arg2,arg3,arg4); { - std::vector< ofTTFCharacter > * resultptr = new std::vector< ofTTFCharacter >((const std::vector< ofTTFCharacter > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_ofPath_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_getStringAsPoints__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; std::string *arg2 = 0 ; bool arg3 ; std::string temp2 ; - SwigValueWrapper< std::vector< ofPath > > result; SWIG_check_num_args("ofTrueTypeFont::getStringAsPoints",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::getStringAsPoints",1,"ofTrueTypeFont const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofTrueTypeFont::getStringAsPoints",2,"std::string const &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofTrueTypeFont::getStringAsPoints",3,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_getStringAsPoints",1,SWIGTYPE_p_ofTrueTypeFont); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; arg3 = (lua_toboolean(L, 3)!=0); - result = ((ofTrueTypeFont const *)arg1)->getStringAsPoints((std::string const &)*arg2,arg3); { - std::vector< ofTTFCharacter > * resultptr = new std::vector< ofTTFCharacter >((const std::vector< ofTTFCharacter > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_ofPath_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_getStringAsPoints__SWIG_2(lua_State* L) { int SWIG_arg = 0; - ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; std::string *arg2 = 0 ; std::string temp2 ; - SwigValueWrapper< std::vector< ofPath > > result; SWIG_check_num_args("ofTrueTypeFont::getStringAsPoints",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::getStringAsPoints",1,"ofTrueTypeFont const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofTrueTypeFont::getStringAsPoints",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_getStringAsPoints",1,SWIGTYPE_p_ofTrueTypeFont); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = ((ofTrueTypeFont const *)arg1)->getStringAsPoints((std::string const &)*arg2); { - std::vector< ofTTFCharacter > * resultptr = new std::vector< ofTTFCharacter >((const std::vector< ofTTFCharacter > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_ofPath_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_TrueTypeFont_getStringAsPoints(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTrueTypeFont, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { - return _wrap_TrueTypeFont_getStringAsPoints__SWIG_2(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTrueTypeFont, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - return _wrap_TrueTypeFont_getStringAsPoints__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTrueTypeFont, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - { _v = lua_isboolean(L,argv[3]); } if (_v) { return _wrap_TrueTypeFont_getStringAsPoints__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'TrueTypeFont_getStringAsPoints'\n" - " Possible C/C++ prototypes are:\n" " ofTrueTypeFont::getStringAsPoints(std::string const &,bool,bool) const\n" - " ofTrueTypeFont::getStringAsPoints(std::string const &,bool) const\n" - " ofTrueTypeFont::getStringAsPoints(std::string const &) const\n"); lua_error(L);return 0; } -static int _wrap_TrueTypeFont_getStringMesh__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; std::string *arg2 = 0 ; float arg3 ; float arg4 ; bool arg5 ; - std::string temp2 ; ofMesh *result = 0 ; SWIG_check_num_args("ofTrueTypeFont::getStringMesh",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::getStringMesh",1,"ofTrueTypeFont const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofTrueTypeFont::getStringMesh",2,"std::string const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTrueTypeFont::getStringMesh",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofTrueTypeFont::getStringMesh",4,"float"); - if(!lua_isboolean(L,5)) SWIG_fail_arg("ofTrueTypeFont::getStringMesh",5,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_getStringMesh",1,SWIGTYPE_p_ofTrueTypeFont); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; arg3 = (float)lua_tonumber(L, 3); - arg4 = (float)lua_tonumber(L, 4); arg5 = (lua_toboolean(L, 5)!=0); - result = (ofMesh *) &((ofTrueTypeFont const *)arg1)->getStringMesh((std::string const &)*arg2,arg3,arg4,arg5); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMesh,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_TrueTypeFont_getStringMesh__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; std::string *arg2 = 0 ; float arg3 ; float arg4 ; std::string temp2 ; - ofMesh *result = 0 ; SWIG_check_num_args("ofTrueTypeFont::getStringMesh",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::getStringMesh",1,"ofTrueTypeFont const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofTrueTypeFont::getStringMesh",2,"std::string const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofTrueTypeFont::getStringMesh",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofTrueTypeFont::getStringMesh",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_getStringMesh",1,SWIGTYPE_p_ofTrueTypeFont); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; arg3 = (float)lua_tonumber(L, 3); - arg4 = (float)lua_tonumber(L, 4); - result = (ofMesh *) &((ofTrueTypeFont const *)arg1)->getStringMesh((std::string const &)*arg2,arg3,arg4); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMesh,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_TrueTypeFont_getStringMesh(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); - if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTrueTypeFont, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_TrueTypeFont_getStringMesh__SWIG_1(L);} } } } } - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofTrueTypeFont, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isboolean(L,argv[4]); } if (_v) { - return _wrap_TrueTypeFont_getStringMesh__SWIG_0(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'TrueTypeFont_getStringMesh'\n" - " Possible C/C++ prototypes are:\n" " ofTrueTypeFont::getStringMesh(std::string const &,float,float,bool) const\n" - " ofTrueTypeFont::getStringMesh(std::string const &,float,float) const\n"); lua_error(L);return 0; } -static int _wrap_TrueTypeFont_getFontTexture(lua_State* L) { int SWIG_arg = 0; ofTrueTypeFont *arg1 = (ofTrueTypeFont *) 0 ; - ofTexture *result = 0 ; SWIG_check_num_args("ofTrueTypeFont::getFontTexture",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofTrueTypeFont::getFontTexture",1,"ofTrueTypeFont const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofTrueTypeFont,0))){ - SWIG_fail_ptr("TrueTypeFont_getFontTexture",1,SWIGTYPE_p_ofTrueTypeFont); } - result = (ofTexture *) &((ofTrueTypeFont const *)arg1)->getFontTexture(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTexture,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static void swig_delete_TrueTypeFont(void *obj) { -ofTrueTypeFont *arg1 = (ofTrueTypeFont *) obj; -delete arg1; -} -static int _proxy__wrap_new_TrueTypeFont(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_TrueTypeFont); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_TrueTypeFont_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_TrueTypeFont_methods[]= { - { "load", _wrap_TrueTypeFont_load}, - { "isLoaded", _wrap_TrueTypeFont_isLoaded}, - { "isAntiAliased", _wrap_TrueTypeFont_isAntiAliased}, - { "hasFullCharacterSet", _wrap_TrueTypeFont_hasFullCharacterSet}, - { "getNumCharacters", _wrap_TrueTypeFont_getNumCharacters}, - { "getSize", _wrap_TrueTypeFont_getSize}, - { "getLineHeight", _wrap_TrueTypeFont_getLineHeight}, - { "setLineHeight", _wrap_TrueTypeFont_setLineHeight}, - { "getAscenderHeight", _wrap_TrueTypeFont_getAscenderHeight}, - { "getDescenderHeight", _wrap_TrueTypeFont_getDescenderHeight}, - { "getGlyphBBox", _wrap_TrueTypeFont_getGlyphBBox}, - { "getLetterSpacing", _wrap_TrueTypeFont_getLetterSpacing}, - { "setLetterSpacing", _wrap_TrueTypeFont_setLetterSpacing}, - { "getSpaceSize", _wrap_TrueTypeFont_getSpaceSize}, - { "setSpaceSize", _wrap_TrueTypeFont_setSpaceSize}, - { "stringWidth", _wrap_TrueTypeFont_stringWidth}, - { "stringHeight", _wrap_TrueTypeFont_stringHeight}, - { "getStringBoundingBox", _wrap_TrueTypeFont_getStringBoundingBox}, - { "drawString", _wrap_TrueTypeFont_drawString}, - { "drawStringAsShapes", _wrap_TrueTypeFont_drawStringAsShapes}, - { "getCharacterAsPoints", _wrap_TrueTypeFont_getCharacterAsPoints}, - { "getStringAsPoints", _wrap_TrueTypeFont_getStringAsPoints}, - { "getStringMesh", _wrap_TrueTypeFont_getStringMesh}, - { "getFontTexture", _wrap_TrueTypeFont_getFontTexture}, - {0,0} -}; -static swig_lua_method swig_TrueTypeFont_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_TrueTypeFont_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_TrueTypeFont_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_TrueTypeFont_Sf_SwigStatic_methods[]= { - { "setGlobalDpi", _wrap_TrueTypeFont_setGlobalDpi}, - {0,0} -}; -static swig_lua_class* swig_TrueTypeFont_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_TrueTypeFont_Sf_SwigStatic = { - "TrueTypeFont", - swig_TrueTypeFont_Sf_SwigStatic_methods, - swig_TrueTypeFont_Sf_SwigStatic_attributes, - swig_TrueTypeFont_Sf_SwigStatic_constants, - swig_TrueTypeFont_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_TrueTypeFont_bases[] = {0}; -static const char *swig_TrueTypeFont_base_names[] = {0}; -static swig_lua_class _wrap_class_TrueTypeFont = { "TrueTypeFont", "TrueTypeFont", &SWIGTYPE_p_ofTrueTypeFont,_proxy__wrap_new_TrueTypeFont, swig_delete_TrueTypeFont, swig_TrueTypeFont_methods, swig_TrueTypeFont_attributes, &swig_TrueTypeFont_Sf_SwigStatic, swig_TrueTypeFont_meta, swig_TrueTypeFont_bases, swig_TrueTypeFont_base_names }; - -static int _wrap_soundStreamSetup__SWIG_0(lua_State* L) { int SWIG_arg = 0; int arg1 ; int arg2 ; - ofBaseApp *arg3 = (ofBaseApp *) 0 ; SWIG_check_num_args("ofSoundStreamSetup",3,3) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSoundStreamSetup",1,"int"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSoundStreamSetup",2,"int"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofSoundStreamSetup",3,"ofBaseApp *"); arg1 = (int)lua_tonumber(L, 1); - arg2 = (int)lua_tonumber(L, 2); if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofBaseApp,0))){ - SWIG_fail_ptr("soundStreamSetup",3,SWIGTYPE_p_ofBaseApp); } ofSoundStreamSetup(arg1,arg2,arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_soundStreamSetup__SWIG_1(lua_State* L) { int SWIG_arg = 0; int arg1 ; int arg2 ; - SWIG_check_num_args("ofSoundStreamSetup",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSoundStreamSetup",1,"int"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSoundStreamSetup",2,"int"); arg1 = (int)lua_tonumber(L, 1); - arg2 = (int)lua_tonumber(L, 2); ofSoundStreamSetup(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_soundStreamSetup__SWIG_2(lua_State* L) { int SWIG_arg = 0; int arg1 ; int arg2 ; int arg3 ; int arg4 ; - int arg5 ; SWIG_check_num_args("ofSoundStreamSetup",5,5) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSoundStreamSetup",1,"int"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSoundStreamSetup",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofSoundStreamSetup",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofSoundStreamSetup",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofSoundStreamSetup",5,"int"); arg1 = (int)lua_tonumber(L, 1); - arg2 = (int)lua_tonumber(L, 2); arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); - arg5 = (int)lua_tonumber(L, 5); ofSoundStreamSetup(arg1,arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_soundStreamSetup__SWIG_3(lua_State* L) { int SWIG_arg = 0; int arg1 ; int arg2 ; - ofBaseApp *arg3 = (ofBaseApp *) 0 ; int arg4 ; int arg5 ; int arg6 ; SWIG_check_num_args("ofSoundStreamSetup",6,6) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSoundStreamSetup",1,"int"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSoundStreamSetup",2,"int"); - if(!SWIG_isptrtype(L,3)) SWIG_fail_arg("ofSoundStreamSetup",3,"ofBaseApp *"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofSoundStreamSetup",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofSoundStreamSetup",5,"int"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofSoundStreamSetup",6,"int"); arg1 = (int)lua_tonumber(L, 1); - arg2 = (int)lua_tonumber(L, 2); if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofBaseApp,0))){ - SWIG_fail_ptr("soundStreamSetup",3,SWIGTYPE_p_ofBaseApp); } arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); - arg6 = (int)lua_tonumber(L, 6); ofSoundStreamSetup(arg1,arg2,arg3,arg4,arg5,arg6); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_soundStreamSetup(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_soundStreamSetup__SWIG_1(L);} } } if (argc == 3) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { - { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofBaseApp, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_soundStreamSetup__SWIG_0(L);} } } } if (argc == 5) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_soundStreamSetup__SWIG_2(L);} } } } } } if (argc == 6) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofBaseApp, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } - if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { return _wrap_soundStreamSetup__SWIG_3(L);} } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'soundStreamSetup'\n" " Possible C/C++ prototypes are:\n" - " ofSoundStreamSetup(int,int,ofBaseApp *)\n" " ofSoundStreamSetup(int,int)\n" - " ofSoundStreamSetup(int,int,int,int,int)\n" " ofSoundStreamSetup(int,int,ofBaseApp *,int,int,int)\n"); - lua_error(L);return 0; } -static int _wrap_soundStreamStop(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofSoundStreamStop",0,0) - ofSoundStreamStop(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_soundStreamStart(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofSoundStreamStart",0,0) - ofSoundStreamStart(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_soundStreamClose(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofSoundStreamClose",0,0) - ofSoundStreamClose(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_soundStreamListDevices(lua_State* L) { int SWIG_arg = 0; - SwigValueWrapper< std::vector< ofSoundDevice > > result; SWIG_check_num_args("ofSoundStreamListDevices",0,0) - result = ofSoundStreamListDevices(); { - std::vector< ofSoundDevice > * resultptr = new std::vector< ofSoundDevice >((const std::vector< ofSoundDevice > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_ofSoundDevice_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_new_SoundStream(lua_State* L) { int SWIG_arg = 0; ofSoundStream *result = 0 ; - SWIG_check_num_args("ofSoundStream::ofSoundStream",0,0) result = (ofSoundStream *)new ofSoundStream(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofSoundStream,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_SoundStream_setSoundStream(lua_State* L) { int SWIG_arg = 0; ofSoundStream *arg1 = (ofSoundStream *) 0 ; - shared_ptr< ofBaseSoundStream > arg2 ; shared_ptr< ofBaseSoundStream > *argp2 ; - SWIG_check_num_args("ofSoundStream::setSoundStream",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStream::setSoundStream",1,"ofSoundStream *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofSoundStream::setSoundStream",2,"shared_ptr< ofBaseSoundStream >"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStream,0))){ - SWIG_fail_ptr("SoundStream_setSoundStream",1,SWIGTYPE_p_ofSoundStream); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_shared_ptrT_ofBaseSoundStream_t,0))){ - SWIG_fail_ptr("SoundStream_setSoundStream",2,SWIGTYPE_p_shared_ptrT_ofBaseSoundStream_t); } arg2 = *argp2; - (arg1)->setSoundStream(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundStream_getSoundStream(lua_State* L) { int SWIG_arg = 0; ofSoundStream *arg1 = (ofSoundStream *) 0 ; - shared_ptr< ofBaseSoundStream > result; SWIG_check_num_args("ofSoundStream::getSoundStream",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStream::getSoundStream",1,"ofSoundStream *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStream,0))){ - SWIG_fail_ptr("SoundStream_getSoundStream",1,SWIGTYPE_p_ofSoundStream); } result = (arg1)->getSoundStream(); { - shared_ptr< ofBaseSoundStream > * resultptr = new shared_ptr< ofBaseSoundStream >((const shared_ptr< ofBaseSoundStream > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_shared_ptrT_ofBaseSoundStream_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundStream_printDeviceList(lua_State* L) { int SWIG_arg = 0; ofSoundStream *arg1 = (ofSoundStream *) 0 ; - SWIG_check_num_args("ofSoundStream::printDeviceList",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStream::printDeviceList",1,"ofSoundStream const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStream,0))){ - SWIG_fail_ptr("SoundStream_printDeviceList",1,SWIGTYPE_p_ofSoundStream); } - ((ofSoundStream const *)arg1)->printDeviceList(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundStream_getDeviceList(lua_State* L) { int SWIG_arg = 0; ofSoundStream *arg1 = (ofSoundStream *) 0 ; - SwigValueWrapper< std::vector< ofSoundDevice > > result; SWIG_check_num_args("ofSoundStream::getDeviceList",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStream::getDeviceList",1,"ofSoundStream const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStream,0))){ - SWIG_fail_ptr("SoundStream_getDeviceList",1,SWIGTYPE_p_ofSoundStream); } - result = ((ofSoundStream const *)arg1)->getDeviceList(); { - std::vector< ofSoundDevice > * resultptr = new std::vector< ofSoundDevice >((const std::vector< ofSoundDevice > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_ofSoundDevice_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundStream_getMatchingDevices__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofSoundStream *arg1 = (ofSoundStream *) 0 ; std::string *arg2 = 0 ; unsigned int arg3 ; unsigned int arg4 ; - std::string temp2 ; SwigValueWrapper< std::vector< ofSoundDevice > > result; - SWIG_check_num_args("ofSoundStream::getMatchingDevices",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStream::getMatchingDevices",1,"ofSoundStream const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofSoundStream::getMatchingDevices",2,"std::string const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofSoundStream::getMatchingDevices",3,"unsigned int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofSoundStream::getMatchingDevices",4,"unsigned int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStream,0))){ - SWIG_fail_ptr("SoundStream_getMatchingDevices",1,SWIGTYPE_p_ofSoundStream); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (unsigned int)lua_tonumber(L, 3); - SWIG_contract_assert((lua_tonumber(L,4)>=0),"number must not be negative") arg4 = (unsigned int)lua_tonumber(L, 4); - result = ((ofSoundStream const *)arg1)->getMatchingDevices((std::string const &)*arg2,arg3,arg4); { - std::vector< ofSoundDevice > * resultptr = new std::vector< ofSoundDevice >((const std::vector< ofSoundDevice > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_ofSoundDevice_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundStream_getMatchingDevices__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofSoundStream *arg1 = (ofSoundStream *) 0 ; std::string *arg2 = 0 ; unsigned int arg3 ; std::string temp2 ; - SwigValueWrapper< std::vector< ofSoundDevice > > result; SWIG_check_num_args("ofSoundStream::getMatchingDevices",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStream::getMatchingDevices",1,"ofSoundStream const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofSoundStream::getMatchingDevices",2,"std::string const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofSoundStream::getMatchingDevices",3,"unsigned int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStream,0))){ - SWIG_fail_ptr("SoundStream_getMatchingDevices",1,SWIGTYPE_p_ofSoundStream); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - SWIG_contract_assert((lua_tonumber(L,3)>=0),"number must not be negative") arg3 = (unsigned int)lua_tonumber(L, 3); - result = ((ofSoundStream const *)arg1)->getMatchingDevices((std::string const &)*arg2,arg3); { - std::vector< ofSoundDevice > * resultptr = new std::vector< ofSoundDevice >((const std::vector< ofSoundDevice > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_ofSoundDevice_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundStream_getMatchingDevices__SWIG_2(lua_State* L) { int SWIG_arg = 0; - ofSoundStream *arg1 = (ofSoundStream *) 0 ; std::string *arg2 = 0 ; std::string temp2 ; - SwigValueWrapper< std::vector< ofSoundDevice > > result; SWIG_check_num_args("ofSoundStream::getMatchingDevices",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStream::getMatchingDevices",1,"ofSoundStream const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofSoundStream::getMatchingDevices",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStream,0))){ - SWIG_fail_ptr("SoundStream_getMatchingDevices",1,SWIGTYPE_p_ofSoundStream); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = ((ofSoundStream const *)arg1)->getMatchingDevices((std::string const &)*arg2); { - std::vector< ofSoundDevice > * resultptr = new std::vector< ofSoundDevice >((const std::vector< ofSoundDevice > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_ofSoundDevice_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundStream_getMatchingDevices(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofSoundStream, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { - return _wrap_SoundStream_getMatchingDevices__SWIG_2(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofSoundStream, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_SoundStream_getMatchingDevices__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofSoundStream, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_SoundStream_getMatchingDevices__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SoundStream_getMatchingDevices'\n" - " Possible C/C++ prototypes are:\n" - " ofSoundStream::getMatchingDevices(std::string const &,unsigned int,unsigned int) const\n" - " ofSoundStream::getMatchingDevices(std::string const &,unsigned int) const\n" - " ofSoundStream::getMatchingDevices(std::string const &) const\n"); lua_error(L);return 0; } -static int _wrap_SoundStream_setDeviceID(lua_State* L) { int SWIG_arg = 0; ofSoundStream *arg1 = (ofSoundStream *) 0 ; - int arg2 ; SWIG_check_num_args("ofSoundStream::setDeviceID",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStream::setDeviceID",1,"ofSoundStream *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSoundStream::setDeviceID",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStream,0))){ - SWIG_fail_ptr("SoundStream_setDeviceID",1,SWIGTYPE_p_ofSoundStream); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->setDeviceID(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundStream_setDevice(lua_State* L) { int SWIG_arg = 0; ofSoundStream *arg1 = (ofSoundStream *) 0 ; - ofSoundDevice *arg2 = 0 ; SWIG_check_num_args("ofSoundStream::setDevice",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStream::setDevice",1,"ofSoundStream *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofSoundStream::setDevice",2,"ofSoundDevice const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStream,0))){ - SWIG_fail_ptr("SoundStream_setDevice",1,SWIGTYPE_p_ofSoundStream); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofSoundDevice,0))){ - SWIG_fail_ptr("SoundStream_setDevice",2,SWIGTYPE_p_ofSoundDevice); } (arg1)->setDevice((ofSoundDevice const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundStream_setup__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofSoundStream *arg1 = (ofSoundStream *) 0 ; - ofBaseApp *arg2 = (ofBaseApp *) 0 ; int arg3 ; int arg4 ; int arg5 ; int arg6 ; int arg7 ; bool result; - SWIG_check_num_args("ofSoundStream::setup",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStream::setup",1,"ofSoundStream *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofSoundStream::setup",2,"ofBaseApp *"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofSoundStream::setup",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofSoundStream::setup",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofSoundStream::setup",5,"int"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofSoundStream::setup",6,"int"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofSoundStream::setup",7,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStream,0))){ - SWIG_fail_ptr("SoundStream_setup",1,SWIGTYPE_p_ofSoundStream); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBaseApp,0))){ - SWIG_fail_ptr("SoundStream_setup",2,SWIGTYPE_p_ofBaseApp); } arg3 = (int)lua_tonumber(L, 3); - arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); arg6 = (int)lua_tonumber(L, 6); - arg7 = (int)lua_tonumber(L, 7); result = (bool)(arg1)->setup(arg2,arg3,arg4,arg5,arg6,arg7); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundStream_setup__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofSoundStream *arg1 = (ofSoundStream *) 0 ; - int arg2 ; int arg3 ; int arg4 ; int arg5 ; int arg6 ; bool result; SWIG_check_num_args("ofSoundStream::setup",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStream::setup",1,"ofSoundStream *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSoundStream::setup",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofSoundStream::setup",3,"int"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofSoundStream::setup",4,"int"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofSoundStream::setup",5,"int"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofSoundStream::setup",6,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStream,0))){ - SWIG_fail_ptr("SoundStream_setup",1,SWIGTYPE_p_ofSoundStream); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); arg4 = (int)lua_tonumber(L, 4); arg5 = (int)lua_tonumber(L, 5); - arg6 = (int)lua_tonumber(L, 6); result = (bool)(arg1)->setup(arg2,arg3,arg4,arg5,arg6); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundStream_setup(lua_State* L) { int argc; int argv[8]={ 1,2,3,4,5,6,7,8} ; argc = lua_gettop(L); - if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofSoundStream, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { - _v = lua_isnumber(L,argv[5]); } if (_v) { return _wrap_SoundStream_setup__SWIG_1(L);} } } } } } } - if (argc == 7) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofSoundStream, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (SWIG_isptrtype(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBaseApp, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { { - _v = lua_isnumber(L,argv[6]); } if (_v) { return _wrap_SoundStream_setup__SWIG_0(L);} } } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SoundStream_setup'\n" " Possible C/C++ prototypes are:\n" - " ofSoundStream::setup(ofBaseApp *,int,int,int,int,int)\n" " ofSoundStream::setup(int,int,int,int,int)\n"); - lua_error(L);return 0; } -static int _wrap_SoundStream_setInput(lua_State* L) { int SWIG_arg = 0; ofSoundStream *arg1 = (ofSoundStream *) 0 ; - ofBaseSoundInput *arg2 = (ofBaseSoundInput *) 0 ; SWIG_check_num_args("ofSoundStream::setInput",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStream::setInput",1,"ofSoundStream *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofSoundStream::setInput",2,"ofBaseSoundInput *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStream,0))){ - SWIG_fail_ptr("SoundStream_setInput",1,SWIGTYPE_p_ofSoundStream); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBaseSoundInput,0))){ - SWIG_fail_ptr("SoundStream_setInput",2,SWIGTYPE_p_ofBaseSoundInput); } (arg1)->setInput(arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundStream_setOutput(lua_State* L) { int SWIG_arg = 0; ofSoundStream *arg1 = (ofSoundStream *) 0 ; - ofBaseSoundOutput *arg2 = (ofBaseSoundOutput *) 0 ; SWIG_check_num_args("ofSoundStream::setOutput",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStream::setOutput",1,"ofSoundStream *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofSoundStream::setOutput",2,"ofBaseSoundOutput *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStream,0))){ - SWIG_fail_ptr("SoundStream_setOutput",1,SWIGTYPE_p_ofSoundStream); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBaseSoundOutput,0))){ - SWIG_fail_ptr("SoundStream_setOutput",2,SWIGTYPE_p_ofBaseSoundOutput); } (arg1)->setOutput(arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundStream_start(lua_State* L) { int SWIG_arg = 0; ofSoundStream *arg1 = (ofSoundStream *) 0 ; - SWIG_check_num_args("ofSoundStream::start",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStream::start",1,"ofSoundStream *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStream,0))){ - SWIG_fail_ptr("SoundStream_start",1,SWIGTYPE_p_ofSoundStream); } (arg1)->start(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_SoundStream_stop(lua_State* L) { int SWIG_arg = 0; ofSoundStream *arg1 = (ofSoundStream *) 0 ; - SWIG_check_num_args("ofSoundStream::stop",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStream::stop",1,"ofSoundStream *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStream,0))){ - SWIG_fail_ptr("SoundStream_stop",1,SWIGTYPE_p_ofSoundStream); } (arg1)->stop(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_SoundStream_close(lua_State* L) { int SWIG_arg = 0; ofSoundStream *arg1 = (ofSoundStream *) 0 ; - SWIG_check_num_args("ofSoundStream::close",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStream::close",1,"ofSoundStream *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStream,0))){ - SWIG_fail_ptr("SoundStream_close",1,SWIGTYPE_p_ofSoundStream); } (arg1)->close(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_SoundStream_getTickCount(lua_State* L) { int SWIG_arg = 0; ofSoundStream *arg1 = (ofSoundStream *) 0 ; - unsigned long long result; SWIG_check_num_args("ofSoundStream::getTickCount",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStream::getTickCount",1,"ofSoundStream const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStream,0))){ - SWIG_fail_ptr("SoundStream_getTickCount",1,SWIGTYPE_p_ofSoundStream); } - result = (unsigned long long)((ofSoundStream const *)arg1)->getTickCount(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundStream_getNumInputChannels(lua_State* L) { int SWIG_arg = 0; ofSoundStream *arg1 = (ofSoundStream *) 0 ; - int result; SWIG_check_num_args("ofSoundStream::getNumInputChannels",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStream::getNumInputChannels",1,"ofSoundStream const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStream,0))){ - SWIG_fail_ptr("SoundStream_getNumInputChannels",1,SWIGTYPE_p_ofSoundStream); } - result = (int)((ofSoundStream const *)arg1)->getNumInputChannels(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundStream_getNumOutputChannels(lua_State* L) { int SWIG_arg = 0; ofSoundStream *arg1 = (ofSoundStream *) 0 ; - int result; SWIG_check_num_args("ofSoundStream::getNumOutputChannels",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStream::getNumOutputChannels",1,"ofSoundStream const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStream,0))){ - SWIG_fail_ptr("SoundStream_getNumOutputChannels",1,SWIGTYPE_p_ofSoundStream); } - result = (int)((ofSoundStream const *)arg1)->getNumOutputChannels(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundStream_getSampleRate(lua_State* L) { int SWIG_arg = 0; ofSoundStream *arg1 = (ofSoundStream *) 0 ; - int result; SWIG_check_num_args("ofSoundStream::getSampleRate",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStream::getSampleRate",1,"ofSoundStream const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStream,0))){ - SWIG_fail_ptr("SoundStream_getSampleRate",1,SWIGTYPE_p_ofSoundStream); } - result = (int)((ofSoundStream const *)arg1)->getSampleRate(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundStream_getBufferSize(lua_State* L) { int SWIG_arg = 0; ofSoundStream *arg1 = (ofSoundStream *) 0 ; - int result; SWIG_check_num_args("ofSoundStream::getBufferSize",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundStream::getBufferSize",1,"ofSoundStream const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundStream,0))){ - SWIG_fail_ptr("SoundStream_getBufferSize",1,SWIGTYPE_p_ofSoundStream); } - result = (int)((ofSoundStream const *)arg1)->getBufferSize(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_SoundStream(void *obj) { -ofSoundStream *arg1 = (ofSoundStream *) obj; -delete arg1; -} -static int _proxy__wrap_new_SoundStream(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_SoundStream); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_SoundStream_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_SoundStream_methods[]= { - { "setSoundStream", _wrap_SoundStream_setSoundStream}, - { "getSoundStream", _wrap_SoundStream_getSoundStream}, - { "printDeviceList", _wrap_SoundStream_printDeviceList}, - { "getDeviceList", _wrap_SoundStream_getDeviceList}, - { "getMatchingDevices", _wrap_SoundStream_getMatchingDevices}, - { "setDeviceID", _wrap_SoundStream_setDeviceID}, - { "setDevice", _wrap_SoundStream_setDevice}, - { "setup", _wrap_SoundStream_setup}, - { "setInput", _wrap_SoundStream_setInput}, - { "setOutput", _wrap_SoundStream_setOutput}, - { "start", _wrap_SoundStream_start}, - { "stop", _wrap_SoundStream_stop}, - { "close", _wrap_SoundStream_close}, - { "getTickCount", _wrap_SoundStream_getTickCount}, - { "getNumInputChannels", _wrap_SoundStream_getNumInputChannels}, - { "getNumOutputChannels", _wrap_SoundStream_getNumOutputChannels}, - { "getSampleRate", _wrap_SoundStream_getSampleRate}, - { "getBufferSize", _wrap_SoundStream_getBufferSize}, - {0,0} -}; -static swig_lua_method swig_SoundStream_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_SoundStream_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_SoundStream_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_SoundStream_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_SoundStream_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_SoundStream_Sf_SwigStatic = { - "SoundStream", - swig_SoundStream_Sf_SwigStatic_methods, - swig_SoundStream_Sf_SwigStatic_attributes, - swig_SoundStream_Sf_SwigStatic_constants, - swig_SoundStream_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_SoundStream_bases[] = {0}; -static const char *swig_SoundStream_base_names[] = {0}; -static swig_lua_class _wrap_class_SoundStream = { "SoundStream", "SoundStream", &SWIGTYPE_p_ofSoundStream,_proxy__wrap_new_SoundStream, swig_delete_SoundStream, swig_SoundStream_methods, swig_SoundStream_attributes, &swig_SoundStream_Sf_SwigStatic, swig_SoundStream_meta, swig_SoundStream_bases, swig_SoundStream_base_names }; - -static int _wrap_new_SoundPlayer(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *result = 0 ; - SWIG_check_num_args("ofSoundPlayer::ofSoundPlayer",0,0) result = (ofSoundPlayer *)new ofSoundPlayer(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofSoundPlayer,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_SoundPlayer_setPlayer(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; - SwigValueWrapper< shared_ptr< ofBaseSoundPlayer > > arg2 ; shared_ptr< ofBaseSoundPlayer > *argp2 ; - SWIG_check_num_args("ofSoundPlayer::setPlayer",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::setPlayer",1,"ofSoundPlayer *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofSoundPlayer::setPlayer",2,"shared_ptr< ofBaseSoundPlayer >"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_setPlayer",1,SWIGTYPE_p_ofSoundPlayer); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_shared_ptrT_ofBaseSoundPlayer_t,0))){ - SWIG_fail_ptr("SoundPlayer_setPlayer",2,SWIGTYPE_p_shared_ptrT_ofBaseSoundPlayer_t); } arg2 = *argp2; - (arg1)->setPlayer(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundPlayer_getPlayer(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; - SwigValueWrapper< shared_ptr< ofBaseSoundPlayer > > result; SWIG_check_num_args("ofSoundPlayer::getPlayer",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::getPlayer",1,"ofSoundPlayer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_getPlayer",1,SWIGTYPE_p_ofSoundPlayer); } result = (arg1)->getPlayer(); { - shared_ptr< ofBaseSoundPlayer > * resultptr = new shared_ptr< ofBaseSoundPlayer >((const shared_ptr< ofBaseSoundPlayer > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_shared_ptrT_ofBaseSoundPlayer_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundPlayer_load__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; - std::string arg2 ; bool arg3 ; bool result; SWIG_check_num_args("ofSoundPlayer::load",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::load",1,"ofSoundPlayer *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofSoundPlayer::load",2,"std::string"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofSoundPlayer::load",3,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_load",1,SWIGTYPE_p_ofSoundPlayer); } (&arg2)->assign(lua_tostring(L,2),lua_rawlen(L,2)); - arg3 = (lua_toboolean(L, 3)!=0); result = (bool)(arg1)->load(arg2,arg3); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundPlayer_load__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; - std::string arg2 ; bool result; SWIG_check_num_args("ofSoundPlayer::load",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::load",1,"ofSoundPlayer *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofSoundPlayer::load",2,"std::string"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_load",1,SWIGTYPE_p_ofSoundPlayer); } (&arg2)->assign(lua_tostring(L,2),lua_rawlen(L,2)); - result = (bool)(arg1)->load(arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_SoundPlayer_load(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofSoundPlayer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { return _wrap_SoundPlayer_load__SWIG_1(L);} } - } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofSoundPlayer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - return _wrap_SoundPlayer_load__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'SoundPlayer_load'\n" " Possible C/C++ prototypes are:\n" - " ofSoundPlayer::load(std::string,bool)\n" " ofSoundPlayer::load(std::string)\n"); lua_error(L);return 0; } -static int _wrap_SoundPlayer_unload(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; - SWIG_check_num_args("ofSoundPlayer::unload",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::unload",1,"ofSoundPlayer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_unload",1,SWIGTYPE_p_ofSoundPlayer); } (arg1)->unload(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_SoundPlayer_play(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; - SWIG_check_num_args("ofSoundPlayer::play",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::play",1,"ofSoundPlayer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_play",1,SWIGTYPE_p_ofSoundPlayer); } (arg1)->play(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_SoundPlayer_stop(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; - SWIG_check_num_args("ofSoundPlayer::stop",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::stop",1,"ofSoundPlayer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_stop",1,SWIGTYPE_p_ofSoundPlayer); } (arg1)->stop(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_SoundPlayer_setVolume(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; - float arg2 ; SWIG_check_num_args("ofSoundPlayer::setVolume",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::setVolume",1,"ofSoundPlayer *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSoundPlayer::setVolume",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_setVolume",1,SWIGTYPE_p_ofSoundPlayer); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setVolume(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundPlayer_setPan(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; float arg2 ; - SWIG_check_num_args("ofSoundPlayer::setPan",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::setPan",1,"ofSoundPlayer *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSoundPlayer::setPan",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_setPan",1,SWIGTYPE_p_ofSoundPlayer); } arg2 = (float)lua_tonumber(L, 2); (arg1)->setPan(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundPlayer_setSpeed(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; float arg2 ; - SWIG_check_num_args("ofSoundPlayer::setSpeed",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::setSpeed",1,"ofSoundPlayer *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSoundPlayer::setSpeed",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_setSpeed",1,SWIGTYPE_p_ofSoundPlayer); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setSpeed(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundPlayer_setPaused(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; bool arg2 ; - SWIG_check_num_args("ofSoundPlayer::setPaused",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::setPaused",1,"ofSoundPlayer *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofSoundPlayer::setPaused",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_setPaused",1,SWIGTYPE_p_ofSoundPlayer); } arg2 = (lua_toboolean(L, 2)!=0); - (arg1)->setPaused(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundPlayer_setLoop(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; bool arg2 ; - SWIG_check_num_args("ofSoundPlayer::setLoop",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::setLoop",1,"ofSoundPlayer *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofSoundPlayer::setLoop",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_setLoop",1,SWIGTYPE_p_ofSoundPlayer); } arg2 = (lua_toboolean(L, 2)!=0); (arg1)->setLoop(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundPlayer_setMultiPlay(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; - bool arg2 ; SWIG_check_num_args("ofSoundPlayer::setMultiPlay",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::setMultiPlay",1,"ofSoundPlayer *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofSoundPlayer::setMultiPlay",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_setMultiPlay",1,SWIGTYPE_p_ofSoundPlayer); } arg2 = (lua_toboolean(L, 2)!=0); - (arg1)->setMultiPlay(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundPlayer_setPosition(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; - float arg2 ; SWIG_check_num_args("ofSoundPlayer::setPosition",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::setPosition",1,"ofSoundPlayer *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSoundPlayer::setPosition",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_setPosition",1,SWIGTYPE_p_ofSoundPlayer); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setPosition(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundPlayer_setPositionMS(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; - int arg2 ; SWIG_check_num_args("ofSoundPlayer::setPositionMS",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::setPositionMS",1,"ofSoundPlayer *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSoundPlayer::setPositionMS",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_setPositionMS",1,SWIGTYPE_p_ofSoundPlayer); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->setPositionMS(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundPlayer_getPositionMS(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; - int result; SWIG_check_num_args("ofSoundPlayer::getPositionMS",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::getPositionMS",1,"ofSoundPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_getPositionMS",1,SWIGTYPE_p_ofSoundPlayer); } - result = (int)((ofSoundPlayer const *)arg1)->getPositionMS(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundPlayer_getPosition(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; - float result; SWIG_check_num_args("ofSoundPlayer::getPosition",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::getPosition",1,"ofSoundPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_getPosition",1,SWIGTYPE_p_ofSoundPlayer); } - result = (float)((ofSoundPlayer const *)arg1)->getPosition(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundPlayer_isPlaying(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; - bool result; SWIG_check_num_args("ofSoundPlayer::isPlaying",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::isPlaying",1,"ofSoundPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_isPlaying",1,SWIGTYPE_p_ofSoundPlayer); } - result = (bool)((ofSoundPlayer const *)arg1)->isPlaying(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundPlayer_getSpeed(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; - float result; SWIG_check_num_args("ofSoundPlayer::getSpeed",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::getSpeed",1,"ofSoundPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_getSpeed",1,SWIGTYPE_p_ofSoundPlayer); } - result = (float)((ofSoundPlayer const *)arg1)->getSpeed(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundPlayer_getPan(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; float result; - SWIG_check_num_args("ofSoundPlayer::getPan",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::getPan",1,"ofSoundPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_getPan",1,SWIGTYPE_p_ofSoundPlayer); } result = (float)((ofSoundPlayer const *)arg1)->getPan(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundPlayer_getVolume(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; - float result; SWIG_check_num_args("ofSoundPlayer::getVolume",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::getVolume",1,"ofSoundPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_getVolume",1,SWIGTYPE_p_ofSoundPlayer); } - result = (float)((ofSoundPlayer const *)arg1)->getVolume(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_SoundPlayer_isLoaded(lua_State* L) { int SWIG_arg = 0; ofSoundPlayer *arg1 = (ofSoundPlayer *) 0 ; bool result; - SWIG_check_num_args("ofSoundPlayer::isLoaded",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSoundPlayer::isLoaded",1,"ofSoundPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSoundPlayer,0))){ - SWIG_fail_ptr("SoundPlayer_isLoaded",1,SWIGTYPE_p_ofSoundPlayer); } - result = (bool)((ofSoundPlayer const *)arg1)->isLoaded(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_SoundPlayer(void *obj) { -ofSoundPlayer *arg1 = (ofSoundPlayer *) obj; -delete arg1; -} -static int _proxy__wrap_new_SoundPlayer(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_SoundPlayer); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_SoundPlayer_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_SoundPlayer_methods[]= { - { "setPlayer", _wrap_SoundPlayer_setPlayer}, - { "getPlayer", _wrap_SoundPlayer_getPlayer}, - { "load", _wrap_SoundPlayer_load}, - { "unload", _wrap_SoundPlayer_unload}, - { "play", _wrap_SoundPlayer_play}, - { "stop", _wrap_SoundPlayer_stop}, - { "setVolume", _wrap_SoundPlayer_setVolume}, - { "setPan", _wrap_SoundPlayer_setPan}, - { "setSpeed", _wrap_SoundPlayer_setSpeed}, - { "setPaused", _wrap_SoundPlayer_setPaused}, - { "setLoop", _wrap_SoundPlayer_setLoop}, - { "setMultiPlay", _wrap_SoundPlayer_setMultiPlay}, - { "setPosition", _wrap_SoundPlayer_setPosition}, - { "setPositionMS", _wrap_SoundPlayer_setPositionMS}, - { "getPositionMS", _wrap_SoundPlayer_getPositionMS}, - { "getPosition", _wrap_SoundPlayer_getPosition}, - { "isPlaying", _wrap_SoundPlayer_isPlaying}, - { "getSpeed", _wrap_SoundPlayer_getSpeed}, - { "getPan", _wrap_SoundPlayer_getPan}, - { "getVolume", _wrap_SoundPlayer_getVolume}, - { "isLoaded", _wrap_SoundPlayer_isLoaded}, - {0,0} -}; -static swig_lua_method swig_SoundPlayer_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_SoundPlayer_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_SoundPlayer_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_SoundPlayer_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_SoundPlayer_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_SoundPlayer_Sf_SwigStatic = { - "SoundPlayer", - swig_SoundPlayer_Sf_SwigStatic_methods, - swig_SoundPlayer_Sf_SwigStatic_attributes, - swig_SoundPlayer_Sf_SwigStatic_constants, - swig_SoundPlayer_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_SoundPlayer_bases[] = {0}; -static const char *swig_SoundPlayer_base_names[] = {0}; -static swig_lua_class _wrap_class_SoundPlayer = { "SoundPlayer", "SoundPlayer", &SWIGTYPE_p_ofSoundPlayer,_proxy__wrap_new_SoundPlayer, swig_delete_SoundPlayer, swig_SoundPlayer_methods, swig_SoundPlayer_attributes, &swig_SoundPlayer_Sf_SwigStatic, swig_SoundPlayer_meta, swig_SoundPlayer_bases, swig_SoundPlayer_base_names }; - -static int _wrap_new_Color__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::ofColor_",0,0) - result = (ofColor_< unsigned char > *)new ofColor_< unsigned char >(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_Color__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - ofColor_< unsigned char > *result = 0 ; SWIG_check_num_args("ofColor_< unsigned char >::ofColor_",4,4) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::ofColor_",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::ofColor_",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< unsigned char >::ofColor_",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofColor_< unsigned char >::ofColor_",4,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - result = (ofColor_< unsigned char > *)new ofColor_< unsigned char >(arg1,arg2,arg3,arg4); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_Color__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; - ofColor_< unsigned char > *result = 0 ; SWIG_check_num_args("ofColor_< unsigned char >::ofColor_",3,3) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::ofColor_",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::ofColor_",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< unsigned char >::ofColor_",3,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - result = (ofColor_< unsigned char > *)new ofColor_< unsigned char >(arg1,arg2,arg3); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_Color__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; - ofColor_< unsigned char > *result = 0 ; SWIG_check_num_args("ofColor_< unsigned char >::ofColor_",2,2) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::ofColor_",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::ofColor_",2,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); result = (ofColor_< unsigned char > *)new ofColor_< unsigned char >(arg1,arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_Color__SWIG_4(lua_State* L) { int SWIG_arg = 0; float arg1 ; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::ofColor_",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::ofColor_",1,"float"); arg1 = (float)lua_tonumber(L, 1); - result = (ofColor_< unsigned char > *)new ofColor_< unsigned char >(arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_Color__SWIG_5(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *arg1 = 0 ; float arg2 ; - ofColor_< unsigned char > *result = 0 ; SWIG_check_num_args("ofColor_< unsigned char >::ofColor_",2,2) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::ofColor_",1,"ofColor_< unsigned char > const &"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::ofColor_",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("new_Color",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } arg2 = (float)lua_tonumber(L, 2); - result = (ofColor_< unsigned char > *)new ofColor_< unsigned char >((ofColor_< unsigned char > const &)*arg1,arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_Color(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_Color__SWIG_0(L);} if (argc == 1) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { - return _wrap_new_Color__SWIG_4(L);} } if (argc == 2) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_new_Color__SWIG_5(L);} } } if (argc == 2) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_new_Color__SWIG_3(L);} } } if (argc == 3) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_new_Color__SWIG_2(L);} } } } if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_new_Color__SWIG_1(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_Color'\n" " Possible C/C++ prototypes are:\n" - " ofColor_< unsigned char >::ofColor_()\n" " ofColor_< unsigned char >::ofColor_(float,float,float,float)\n" - " ofColor_< unsigned char >::ofColor_(float,float,float)\n" " ofColor_< unsigned char >::ofColor_(float,float)\n" - " ofColor_< unsigned char >::ofColor_(float)\n" - " ofColor_< unsigned char >::ofColor_(ofColor_< unsigned char > const &,float)\n"); lua_error(L);return 0; } -static int _wrap_Color_fromHsb__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - ofColor_< unsigned char > result; SWIG_check_num_args("ofColor_< unsigned char >::fromHsb",4,4) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::fromHsb",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::fromHsb",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< unsigned char >::fromHsb",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofColor_< unsigned char >::fromHsb",4,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - result = ofColor_< unsigned char >::SWIGTEMPLATEDISAMBIGUATOR fromHsb(arg1,arg2,arg3,arg4); { - ofColor_< unsigned char > * resultptr = new ofColor_< unsigned char >((const ofColor_< unsigned char > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_fromHsb__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; - ofColor_< unsigned char > result; SWIG_check_num_args("ofColor_< unsigned char >::fromHsb",3,3) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::fromHsb",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::fromHsb",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< unsigned char >::fromHsb",3,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - result = ofColor_< unsigned char >::SWIGTEMPLATEDISAMBIGUATOR fromHsb(arg1,arg2,arg3); { - ofColor_< unsigned char > * resultptr = new ofColor_< unsigned char >((const ofColor_< unsigned char > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_fromHsb(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Color_fromHsb__SWIG_1(L);} } } } if (argc == 4) { int _v; - { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Color_fromHsb__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Color_fromHsb'\n" " Possible C/C++ prototypes are:\n" - " ofColor_< unsigned char >::fromHsb(float,float,float,float)\n" - " ofColor_< unsigned char >::fromHsb(float,float,float)\n"); lua_error(L);return 0; } -static int _wrap_Color_fromHex__SWIG_0(lua_State* L) { int SWIG_arg = 0; int arg1 ; float arg2 ; - ofColor_< unsigned char > result; SWIG_check_num_args("ofColor_< unsigned char >::fromHex",2,2) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::fromHex",1,"int"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::fromHex",2,"float"); arg1 = (int)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); result = ofColor_< unsigned char >::SWIGTEMPLATEDISAMBIGUATOR fromHex(arg1,arg2); { - ofColor_< unsigned char > * resultptr = new ofColor_< unsigned char >((const ofColor_< unsigned char > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_fromHex__SWIG_1(lua_State* L) { int SWIG_arg = 0; int arg1 ; ofColor_< unsigned char > result; - SWIG_check_num_args("ofColor_< unsigned char >::fromHex",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::fromHex",1,"int"); arg1 = (int)lua_tonumber(L, 1); - result = ofColor_< unsigned char >::SWIGTEMPLATEDISAMBIGUATOR fromHex(arg1); { - ofColor_< unsigned char > * resultptr = new ofColor_< unsigned char >((const ofColor_< unsigned char > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_fromHex(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_Color_fromHex__SWIG_1(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Color_fromHex__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Color_fromHex'\n" " Possible C/C++ prototypes are:\n" - " ofColor_< unsigned char >::fromHex(int,float)\n" " ofColor_< unsigned char >::fromHex(int)\n"); - lua_error(L);return 0; } -static int _wrap_Color_set__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; float arg2 ; float arg3 ; float arg4 ; float arg5 ; - SWIG_check_num_args("ofColor_< unsigned char >::set",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::set",1,"ofColor_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< unsigned char >::set",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofColor_< unsigned char >::set",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofColor_< unsigned char >::set",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_set",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - (arg1)->set(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_set__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; float arg2 ; float arg3 ; float arg4 ; - SWIG_check_num_args("ofColor_< unsigned char >::set",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::set",1,"ofColor_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< unsigned char >::set",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofColor_< unsigned char >::set",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_set",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); (arg1)->set(arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_set__SWIG_2(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofColor_< unsigned char >::set",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::set",1,"ofColor_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< unsigned char >::set",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_set",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->set(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Color_set__SWIG_3(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; float arg2 ; - SWIG_check_num_args("ofColor_< unsigned char >::set",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::set",1,"ofColor_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::set",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_set",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } arg2 = (float)lua_tonumber(L, 2); (arg1)->set(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_set__SWIG_4(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; ofColor_< unsigned char > *arg2 = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::set",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::set",1,"ofColor_< unsigned char > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::set",2,"ofColor_< unsigned char > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_set",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_set",2,SWIGTYPE_p_ofColor_T_unsigned_char_t); } (arg1)->set((ofColor_< unsigned char > const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_set(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 2) { int _v; - { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Color_set__SWIG_4(L);} } } if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Color_set__SWIG_3(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_Color_set__SWIG_2(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Color_set__SWIG_1(L);} } } } } - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Color_set__SWIG_0(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Color_set'\n" " Possible C/C++ prototypes are:\n" - " ofColor_< unsigned char >::set(float,float,float,float)\n" " ofColor_< unsigned char >::set(float,float,float)\n" - " ofColor_< unsigned char >::set(float,float)\n" " ofColor_< unsigned char >::set(float)\n" - " ofColor_< unsigned char >::set(ofColor_< unsigned char > const &)\n"); lua_error(L);return 0; } -static int _wrap_Color_setHex__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; int arg2 ; float arg3 ; - SWIG_check_num_args("ofColor_< unsigned char >::setHex",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::setHex",1,"ofColor_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::setHex",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< unsigned char >::setHex",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_setHex",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->setHex(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Color_setHex__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; int arg2 ; - SWIG_check_num_args("ofColor_< unsigned char >::setHex",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::setHex",1,"ofColor_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::setHex",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_setHex",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->setHex(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_setHex(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { int _v; - { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Color_setHex__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_Color_setHex__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Color_setHex'\n" " Possible C/C++ prototypes are:\n" - " ofColor_< unsigned char >::setHex(int,float)\n" " ofColor_< unsigned char >::setHex(int)\n"); lua_error(L);return 0; } -static int _wrap_Color_setHue(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; float arg2 ; - SWIG_check_num_args("ofColor_< unsigned char >::setHue",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::setHue",1,"ofColor_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::setHue",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_setHue",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setHue(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_setHueAngle(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; float arg2 ; - SWIG_check_num_args("ofColor_< unsigned char >::setHueAngle",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::setHueAngle",1,"ofColor_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::setHueAngle",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_setHueAngle",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setHueAngle(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_setSaturation(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; float arg2 ; - SWIG_check_num_args("ofColor_< unsigned char >::setSaturation",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::setSaturation",1,"ofColor_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::setSaturation",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_setSaturation",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setSaturation(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_setBrightness(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; float arg2 ; - SWIG_check_num_args("ofColor_< unsigned char >::setBrightness",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::setBrightness",1,"ofColor_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::setBrightness",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_setBrightness",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setBrightness(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_setHsb__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; float arg2 ; float arg3 ; float arg4 ; float arg5 ; - SWIG_check_num_args("ofColor_< unsigned char >::setHsb",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::setHsb",1,"ofColor_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::setHsb",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< unsigned char >::setHsb",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofColor_< unsigned char >::setHsb",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofColor_< unsigned char >::setHsb",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_setHsb",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - (arg1)->setHsb(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_setHsb__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; float arg2 ; float arg3 ; float arg4 ; - SWIG_check_num_args("ofColor_< unsigned char >::setHsb",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::setHsb",1,"ofColor_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::setHsb",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< unsigned char >::setHsb",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofColor_< unsigned char >::setHsb",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_setHsb",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); (arg1)->setHsb(arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_setHsb(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 4) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_Color_setHsb__SWIG_1(L);} } } } } - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Color_setHsb__SWIG_0(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Color_setHsb'\n" " Possible C/C++ prototypes are:\n" - " ofColor_< unsigned char >::setHsb(float,float,float,float)\n" - " ofColor_< unsigned char >::setHsb(float,float,float)\n"); lua_error(L);return 0; } -static int _wrap_Color_clamp(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::clamp",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::clamp",1,"ofColor_< unsigned char > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_clamp",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - result = (ofColor_< unsigned char > *) &(arg1)->clamp(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_invert(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::invert",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::invert",1,"ofColor_< unsigned char > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_invert",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - result = (ofColor_< unsigned char > *) &(arg1)->invert(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_normalize(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::normalize",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::normalize",1,"ofColor_< unsigned char > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_normalize",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - result = (ofColor_< unsigned char > *) &(arg1)->normalize(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_lerp(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; ofColor_< unsigned char > *arg2 = 0 ; float arg3 ; - ofColor_< unsigned char > *result = 0 ; SWIG_check_num_args("ofColor_< unsigned char >::lerp",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::lerp",1,"ofColor_< unsigned char > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::lerp",2,"ofColor_< unsigned char > const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< unsigned char >::lerp",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_lerp",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_lerp",2,SWIGTYPE_p_ofColor_T_unsigned_char_t); } arg3 = (float)lua_tonumber(L, 3); - result = (ofColor_< unsigned char > *) &(arg1)->lerp((ofColor_< unsigned char > const &)*arg2,arg3); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_getClamped(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; ofColor_< unsigned char > result; - SWIG_check_num_args("ofColor_< unsigned char >::getClamped",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::getClamped",1,"ofColor_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_getClamped",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - result = ((ofColor_< unsigned char > const *)arg1)->getClamped(); { - ofColor_< unsigned char > * resultptr = new ofColor_< unsigned char >((const ofColor_< unsigned char > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_getInverted(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; ofColor_< unsigned char > result; - SWIG_check_num_args("ofColor_< unsigned char >::getInverted",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::getInverted",1,"ofColor_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_getInverted",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - result = ((ofColor_< unsigned char > const *)arg1)->getInverted(); { - ofColor_< unsigned char > * resultptr = new ofColor_< unsigned char >((const ofColor_< unsigned char > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_getNormalized(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; ofColor_< unsigned char > result; - SWIG_check_num_args("ofColor_< unsigned char >::getNormalized",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::getNormalized",1,"ofColor_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_getNormalized",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - result = ((ofColor_< unsigned char > const *)arg1)->getNormalized(); { - ofColor_< unsigned char > * resultptr = new ofColor_< unsigned char >((const ofColor_< unsigned char > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_getLerped(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; ofColor_< unsigned char > *arg2 = 0 ; float arg3 ; - ofColor_< unsigned char > result; SWIG_check_num_args("ofColor_< unsigned char >::getLerped",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::getLerped",1,"ofColor_< unsigned char > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::getLerped",2,"ofColor_< unsigned char > const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< unsigned char >::getLerped",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_getLerped",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_getLerped",2,SWIGTYPE_p_ofColor_T_unsigned_char_t); } arg3 = (float)lua_tonumber(L, 3); - result = ((ofColor_< unsigned char > const *)arg1)->getLerped((ofColor_< unsigned char > const &)*arg2,arg3); { - ofColor_< unsigned char > * resultptr = new ofColor_< unsigned char >((const ofColor_< unsigned char > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_getHex(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; int result; - SWIG_check_num_args("ofColor_< unsigned char >::getHex",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::getHex",1,"ofColor_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_getHex",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - result = (int)((ofColor_< unsigned char > const *)arg1)->getHex(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_getHue(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; float result; - SWIG_check_num_args("ofColor_< unsigned char >::getHue",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::getHue",1,"ofColor_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_getHue",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - result = (float)((ofColor_< unsigned char > const *)arg1)->getHue(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_getHueAngle(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; float result; - SWIG_check_num_args("ofColor_< unsigned char >::getHueAngle",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::getHueAngle",1,"ofColor_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_getHueAngle",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - result = (float)((ofColor_< unsigned char > const *)arg1)->getHueAngle(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_getSaturation(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; float result; - SWIG_check_num_args("ofColor_< unsigned char >::getSaturation",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::getSaturation",1,"ofColor_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_getSaturation",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - result = (float)((ofColor_< unsigned char > const *)arg1)->getSaturation(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_getBrightness(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; float result; - SWIG_check_num_args("ofColor_< unsigned char >::getBrightness",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::getBrightness",1,"ofColor_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_getBrightness",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - result = (float)((ofColor_< unsigned char > const *)arg1)->getBrightness(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_getLightness(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; float result; - SWIG_check_num_args("ofColor_< unsigned char >::getLightness",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::getLightness",1,"ofColor_< unsigned char > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_getLightness",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - result = (float)((ofColor_< unsigned char > const *)arg1)->getLightness(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_getHsb(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; float *arg2 = 0 ; float *arg3 = 0 ; float *arg4 = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::getHsb",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::getHsb",1,"ofColor_< unsigned char > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::getHsb",2,"float &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofColor_< unsigned char >::getHsb",3,"float &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofColor_< unsigned char >::getHsb",4,"float &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_getHsb",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_float,0))){ SWIG_fail_ptr("Color_getHsb",2,SWIGTYPE_p_float); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_float,0))){ SWIG_fail_ptr("Color_getHsb",3,SWIGTYPE_p_float); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_float,0))){ SWIG_fail_ptr("Color_getHsb",4,SWIGTYPE_p_float); } - ((ofColor_< unsigned char > const *)arg1)->getHsb(*arg2,*arg3,*arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Color_limit(lua_State* L) { int SWIG_arg = 0; float result; - SWIG_check_num_args("ofColor_< unsigned char >::limit",0,0) - result = (float)ofColor_< unsigned char >::SWIGTEMPLATEDISAMBIGUATOR limit(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color___eq(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; ofColor_< unsigned char > *arg2 = 0 ; bool result; - SWIG_check_num_args("ofColor_< unsigned char >::operator ==",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::operator ==",1,"ofColor_< unsigned char > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::operator ==",2,"ofColor_< unsigned char > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color___eq",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color___eq",2,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - result = (bool)((ofColor_< unsigned char > const *)arg1)->operator ==((ofColor_< unsigned char > const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color___add__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; ofColor_< unsigned char > *arg2 = 0 ; - ofColor_< unsigned char > result; SWIG_check_num_args("ofColor_< unsigned char >::operator +",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::operator +",1,"ofColor_< unsigned char > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::operator +",2,"ofColor_< unsigned char > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color___add",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color___add",2,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - result = ((ofColor_< unsigned char > const *)arg1)->operator +((ofColor_< unsigned char > const &)*arg2); { - ofColor_< unsigned char > * resultptr = new ofColor_< unsigned char >((const ofColor_< unsigned char > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color___add__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; float *arg2 = 0 ; float temp2 ; - ofColor_< unsigned char > result; SWIG_check_num_args("ofColor_< unsigned char >::operator +",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::operator +",1,"ofColor_< unsigned char > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::operator +",2,"float const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color___add",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } temp2=(float)lua_tonumber(L,2); arg2=&temp2; - result = ((ofColor_< unsigned char > const *)arg1)->operator +((float const &)*arg2); { - ofColor_< unsigned char > * resultptr = new ofColor_< unsigned char >((const ofColor_< unsigned char > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color___add(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Color___add__SWIG_0(L);} } } if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Color___add__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Color___add'\n" " Possible C/C++ prototypes are:\n" - " ofColor_< unsigned char >::operator +(ofColor_< unsigned char > const &) const\n" - " ofColor_< unsigned char >::operator +(float const &) const\n"); lua_error(L);return 0; } -static int _wrap_Color___sub__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; ofColor_< unsigned char > *arg2 = 0 ; - ofColor_< unsigned char > result; SWIG_check_num_args("ofColor_< unsigned char >::operator -",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::operator -",1,"ofColor_< unsigned char > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::operator -",2,"ofColor_< unsigned char > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color___sub",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color___sub",2,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - result = ((ofColor_< unsigned char > const *)arg1)->operator -((ofColor_< unsigned char > const &)*arg2); { - ofColor_< unsigned char > * resultptr = new ofColor_< unsigned char >((const ofColor_< unsigned char > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color___sub__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; float *arg2 = 0 ; float temp2 ; - ofColor_< unsigned char > result; SWIG_check_num_args("ofColor_< unsigned char >::operator -",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::operator -",1,"ofColor_< unsigned char > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::operator -",2,"float const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color___sub",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } temp2=(float)lua_tonumber(L,2); arg2=&temp2; - result = ((ofColor_< unsigned char > const *)arg1)->operator -((float const &)*arg2); { - ofColor_< unsigned char > * resultptr = new ofColor_< unsigned char >((const ofColor_< unsigned char > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color___sub(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Color___sub__SWIG_0(L);} } } if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Color___sub__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Color___sub'\n" " Possible C/C++ prototypes are:\n" - " ofColor_< unsigned char >::operator -(ofColor_< unsigned char > const &) const\n" - " ofColor_< unsigned char >::operator -(float const &) const\n"); lua_error(L);return 0; } -static int _wrap_Color___mul__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; ofColor_< unsigned char > *arg2 = 0 ; - ofColor_< unsigned char > result; SWIG_check_num_args("ofColor_< unsigned char >::operator *",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::operator *",1,"ofColor_< unsigned char > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::operator *",2,"ofColor_< unsigned char > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color___mul",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color___mul",2,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - result = ((ofColor_< unsigned char > const *)arg1)->operator *((ofColor_< unsigned char > const &)*arg2); { - ofColor_< unsigned char > * resultptr = new ofColor_< unsigned char >((const ofColor_< unsigned char > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color___mul__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; float *arg2 = 0 ; float temp2 ; - ofColor_< unsigned char > result; SWIG_check_num_args("ofColor_< unsigned char >::operator *",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::operator *",1,"ofColor_< unsigned char > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::operator *",2,"float const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color___mul",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } temp2=(float)lua_tonumber(L,2); arg2=&temp2; - result = ((ofColor_< unsigned char > const *)arg1)->operator *((float const &)*arg2); { - ofColor_< unsigned char > * resultptr = new ofColor_< unsigned char >((const ofColor_< unsigned char > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color___mul(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Color___mul__SWIG_0(L);} } } if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Color___mul__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Color___mul'\n" " Possible C/C++ prototypes are:\n" - " ofColor_< unsigned char >::operator *(ofColor_< unsigned char > const &) const\n" - " ofColor_< unsigned char >::operator *(float const &) const\n"); lua_error(L);return 0; } -static int _wrap_Color___div__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; ofColor_< unsigned char > *arg2 = 0 ; - ofColor_< unsigned char > result; SWIG_check_num_args("ofColor_< unsigned char >::operator /",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::operator /",1,"ofColor_< unsigned char > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::operator /",2,"ofColor_< unsigned char > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color___div",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color___div",2,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - result = ((ofColor_< unsigned char > const *)arg1)->operator /((ofColor_< unsigned char > const &)*arg2); { - ofColor_< unsigned char > * resultptr = new ofColor_< unsigned char >((const ofColor_< unsigned char > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color___div__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; float *arg2 = 0 ; float temp2 ; - ofColor_< unsigned char > result; SWIG_check_num_args("ofColor_< unsigned char >::operator /",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::operator /",1,"ofColor_< unsigned char > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::operator /",2,"float const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color___div",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } temp2=(float)lua_tonumber(L,2); arg2=&temp2; - result = ((ofColor_< unsigned char > const *)arg1)->operator /((float const &)*arg2); { - ofColor_< unsigned char > * resultptr = new ofColor_< unsigned char >((const ofColor_< unsigned char > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_char_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color___div(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Color___div__SWIG_0(L);} } } if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_char_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Color___div__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Color___div'\n" " Possible C/C++ prototypes are:\n" - " ofColor_< unsigned char >::operator /(ofColor_< unsigned char > const &) const\n" - " ofColor_< unsigned char >::operator /(float const &) const\n"); lua_error(L);return 0; } -static int _wrap_Color_white_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::white",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::white; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_gray_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::gray",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::gray; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_black_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::black",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::black; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_red_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::red",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::red; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_green_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::green",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::green; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_blue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::blue",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::blue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_cyan_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::cyan",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::cyan; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_magenta_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::magenta",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::magenta; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_yellow_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::yellow",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::yellow; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_aliceBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::aliceBlue",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::aliceBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_antiqueWhite_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::antiqueWhite",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::antiqueWhite; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_aqua_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::aqua",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::aqua; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_aquamarine_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::aquamarine",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::aquamarine; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_azure_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::azure",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::azure; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_beige_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::beige",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::beige; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_bisque_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::bisque",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::bisque; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_blanchedAlmond_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::blanchedAlmond",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::blanchedAlmond; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_blueViolet_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::blueViolet",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::blueViolet; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_brown_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::brown",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::brown; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_burlyWood_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::burlyWood",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::burlyWood; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_cadetBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::cadetBlue",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::cadetBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_chartreuse_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::chartreuse",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::chartreuse; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_chocolate_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::chocolate",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::chocolate; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_coral_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::coral",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::coral; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_cornflowerBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::cornflowerBlue",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::cornflowerBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_cornsilk_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::cornsilk",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::cornsilk; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_crimson_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::crimson",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::crimson; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_darkBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::darkBlue",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::darkBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_darkCyan_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::darkCyan",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::darkCyan; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_darkGoldenRod_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::darkGoldenRod",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::darkGoldenRod; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_darkGray_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::darkGray",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::darkGray; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_darkGrey_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::darkGrey",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::darkGrey; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_darkGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::darkGreen",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::darkGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_darkKhaki_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::darkKhaki",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::darkKhaki; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_darkMagenta_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::darkMagenta",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::darkMagenta; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_darkOliveGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::darkOliveGreen",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::darkOliveGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_darkorange_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::darkorange",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::darkorange; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_darkOrchid_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::darkOrchid",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::darkOrchid; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_darkRed_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::darkRed",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::darkRed; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_darkSalmon_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::darkSalmon",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::darkSalmon; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_darkSeaGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::darkSeaGreen",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::darkSeaGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_darkSlateBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::darkSlateBlue",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::darkSlateBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_darkSlateGray_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::darkSlateGray",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::darkSlateGray; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_darkSlateGrey_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::darkSlateGrey",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::darkSlateGrey; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_darkTurquoise_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::darkTurquoise",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::darkTurquoise; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_darkViolet_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::darkViolet",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::darkViolet; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_deepPink_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::deepPink",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::deepPink; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_deepSkyBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::deepSkyBlue",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::deepSkyBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_dimGray_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::dimGray",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::dimGray; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_dimGrey_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::dimGrey",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::dimGrey; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_dodgerBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::dodgerBlue",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::dodgerBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_fireBrick_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::fireBrick",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::fireBrick; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_floralWhite_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::floralWhite",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::floralWhite; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_forestGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::forestGreen",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::forestGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_fuchsia_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::fuchsia",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::fuchsia; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_gainsboro_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::gainsboro",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::gainsboro; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_ghostWhite_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::ghostWhite",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::ghostWhite; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_gold_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::gold",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::gold; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_goldenRod_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::goldenRod",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::goldenRod; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_grey_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::grey",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::grey; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_greenYellow_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::greenYellow",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::greenYellow; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_honeyDew_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::honeyDew",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::honeyDew; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_hotPink_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::hotPink",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::hotPink; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_indianRed_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::indianRed",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::indianRed; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_indigo_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::indigo",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::indigo; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_ivory_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::ivory",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::ivory; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_khaki_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::khaki",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::khaki; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_lavender_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::lavender",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::lavender; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_lavenderBlush_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::lavenderBlush",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::lavenderBlush; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_lawnGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::lawnGreen",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::lawnGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_lemonChiffon_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::lemonChiffon",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::lemonChiffon; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_lightBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::lightBlue",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::lightBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_lightCoral_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::lightCoral",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::lightCoral; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_lightCyan_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::lightCyan",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::lightCyan; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_lightGoldenRodYellow_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::lightGoldenRodYellow",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::lightGoldenRodYellow; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_lightGray_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::lightGray",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::lightGray; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_lightGrey_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::lightGrey",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::lightGrey; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_lightGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::lightGreen",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::lightGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_lightPink_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::lightPink",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::lightPink; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_lightSalmon_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::lightSalmon",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::lightSalmon; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_lightSeaGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::lightSeaGreen",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::lightSeaGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_lightSkyBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::lightSkyBlue",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::lightSkyBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_lightSlateGray_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::lightSlateGray",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::lightSlateGray; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_lightSlateGrey_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::lightSlateGrey",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::lightSlateGrey; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_lightSteelBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::lightSteelBlue",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::lightSteelBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_lightYellow_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::lightYellow",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::lightYellow; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_lime_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::lime",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::lime; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_limeGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::limeGreen",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::limeGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_linen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::linen",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::linen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_maroon_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::maroon",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::maroon; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_mediumAquaMarine_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::mediumAquaMarine",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::mediumAquaMarine; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_mediumBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::mediumBlue",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::mediumBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_mediumOrchid_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::mediumOrchid",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::mediumOrchid; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_mediumPurple_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::mediumPurple",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::mediumPurple; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_mediumSeaGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::mediumSeaGreen",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::mediumSeaGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_mediumSlateBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::mediumSlateBlue",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::mediumSlateBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_mediumSpringGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::mediumSpringGreen",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::mediumSpringGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_mediumTurquoise_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::mediumTurquoise",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::mediumTurquoise; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_mediumVioletRed_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::mediumVioletRed",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::mediumVioletRed; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_midnightBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::midnightBlue",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::midnightBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_mintCream_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::mintCream",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::mintCream; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_mistyRose_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::mistyRose",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::mistyRose; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_moccasin_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::moccasin",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::moccasin; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_navajoWhite_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::navajoWhite",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::navajoWhite; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_navy_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::navy",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::navy; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_oldLace_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::oldLace",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::oldLace; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_olive_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::olive",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::olive; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_oliveDrab_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::oliveDrab",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::oliveDrab; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_orange_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::orange",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::orange; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_orangeRed_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::orangeRed",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::orangeRed; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_orchid_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::orchid",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::orchid; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_paleGoldenRod_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::paleGoldenRod",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::paleGoldenRod; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_paleGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::paleGreen",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::paleGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_paleTurquoise_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::paleTurquoise",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::paleTurquoise; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_paleVioletRed_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::paleVioletRed",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::paleVioletRed; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_papayaWhip_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::papayaWhip",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::papayaWhip; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_peachPuff_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::peachPuff",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::peachPuff; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_peru_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::peru",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::peru; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_pink_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::pink",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::pink; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_plum_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::plum",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::plum; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_powderBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::powderBlue",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::powderBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_purple_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::purple",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::purple; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_rosyBrown_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::rosyBrown",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::rosyBrown; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_royalBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::royalBlue",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::royalBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_saddleBrown_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::saddleBrown",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::saddleBrown; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_salmon_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::salmon",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::salmon; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_sandyBrown_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::sandyBrown",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::sandyBrown; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_seaGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::seaGreen",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::seaGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_seaShell_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::seaShell",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::seaShell; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_sienna_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::sienna",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::sienna; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_silver_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::silver",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::silver; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_skyBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::skyBlue",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::skyBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_slateBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::slateBlue",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::slateBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_slateGray_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::slateGray",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::slateGray; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_slateGrey_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::slateGrey",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::slateGrey; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_snow_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::snow",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::snow; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_springGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::springGreen",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::springGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_steelBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::steelBlue",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::steelBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_blueSteel_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::blueSteel",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::blueSteel; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_tan_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::tan",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::tan; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_teal_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::teal",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::teal; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_thistle_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::thistle",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::thistle; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_tomato_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::tomato",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::tomato; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_turquoise_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::turquoise",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::turquoise; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_violet_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::violet",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::violet; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_wheat_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::wheat",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::wheat; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_whiteSmoke_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::whiteSmoke",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::whiteSmoke; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_yellowGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned char > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::yellowGreen",0,0) - result = (ofColor_< unsigned char > *)&ofColor_< unsigned char >::yellowGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Color_getR(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; unsigned char result; - SWIG_check_num_args("ofColor_< unsigned char >::getR",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::getR",1,"ofColor_< unsigned char > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_getR",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - result = (unsigned char)ofColor__Sl_unsigned_SS_char_Sg__getR(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_getG(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; unsigned char result; - SWIG_check_num_args("ofColor_< unsigned char >::getG",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::getG",1,"ofColor_< unsigned char > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_getG",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - result = (unsigned char)ofColor__Sl_unsigned_SS_char_Sg__getG(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_getB(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; unsigned char result; - SWIG_check_num_args("ofColor_< unsigned char >::getB",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::getB",1,"ofColor_< unsigned char > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_getB",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - result = (unsigned char)ofColor__Sl_unsigned_SS_char_Sg__getB(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_getA(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; unsigned char result; - SWIG_check_num_args("ofColor_< unsigned char >::getA",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::getA",1,"ofColor_< unsigned char > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_getA",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - result = (unsigned char)ofColor__Sl_unsigned_SS_char_Sg__getA(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_setR(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; unsigned char arg2 ; - SWIG_check_num_args("ofColor_< unsigned char >::setR",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::setR",1,"ofColor_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::setR",2,"unsigned char"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_setR",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned char)lua_tonumber(L, 2); - ofColor__Sl_unsigned_SS_char_Sg__setR(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_setG(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; unsigned char arg2 ; - SWIG_check_num_args("ofColor_< unsigned char >::setG",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::setG",1,"ofColor_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::setG",2,"unsigned char"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_setG",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned char)lua_tonumber(L, 2); - ofColor__Sl_unsigned_SS_char_Sg__setG(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_setB(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; unsigned char arg2 ; - SWIG_check_num_args("ofColor_< unsigned char >::setB",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::setB",1,"ofColor_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::setB",2,"unsigned char"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_setB",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned char)lua_tonumber(L, 2); - ofColor__Sl_unsigned_SS_char_Sg__setB(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_setA(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; unsigned char arg2 ; - SWIG_check_num_args("ofColor_< unsigned char >::setA",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::setA",1,"ofColor_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::setA",2,"unsigned char"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_setA",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned char)lua_tonumber(L, 2); - ofColor__Sl_unsigned_SS_char_Sg__setA(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color___tostring(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; char *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned char >::__str__",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::__str__",1,"ofColor_< unsigned char > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color___tostring",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - result = (char *)ofColor__Sl_unsigned_SS_char_Sg____str__(arg1); lua_pushstring(L,(const char *)result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_r_set(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; unsigned char arg2 ; - SWIG_check_num_args("ofColor_< unsigned char >::r",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::r",1,"ofColor_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::r",2,"unsigned char"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_r_set",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned char)lua_tonumber(L, 2); - ofColor__Sl_unsigned_SS_char_Sg__r_set(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_r_get(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; unsigned char result; - SWIG_check_num_args("ofColor_< unsigned char >::r",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::r",1,"ofColor_< unsigned char > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_r_get",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - result = (unsigned char)ofColor__Sl_unsigned_SS_char_Sg__r_get(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_g_set(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; unsigned char arg2 ; - SWIG_check_num_args("ofColor_< unsigned char >::g",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::g",1,"ofColor_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::g",2,"unsigned char"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_g_set",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned char)lua_tonumber(L, 2); - ofColor__Sl_unsigned_SS_char_Sg__g_set(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_g_get(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; unsigned char result; - SWIG_check_num_args("ofColor_< unsigned char >::g",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::g",1,"ofColor_< unsigned char > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_g_get",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - result = (unsigned char)ofColor__Sl_unsigned_SS_char_Sg__g_get(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_b_set(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; unsigned char arg2 ; - SWIG_check_num_args("ofColor_< unsigned char >::b",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::b",1,"ofColor_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::b",2,"unsigned char"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_b_set",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned char)lua_tonumber(L, 2); - ofColor__Sl_unsigned_SS_char_Sg__b_set(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_b_get(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; unsigned char result; - SWIG_check_num_args("ofColor_< unsigned char >::b",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::b",1,"ofColor_< unsigned char > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_b_get",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - result = (unsigned char)ofColor__Sl_unsigned_SS_char_Sg__b_get(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_a_set(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; unsigned char arg2 ; - SWIG_check_num_args("ofColor_< unsigned char >::a",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::a",1,"ofColor_< unsigned char > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned char >::a",2,"unsigned char"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_a_set",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned char)lua_tonumber(L, 2); - ofColor__Sl_unsigned_SS_char_Sg__a_set(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Color_a_get(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) 0 ; unsigned char result; - SWIG_check_num_args("ofColor_< unsigned char >::a",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned char >::a",1,"ofColor_< unsigned char > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Color_a_get",1,SWIGTYPE_p_ofColor_T_unsigned_char_t); } - result = (unsigned char)ofColor__Sl_unsigned_SS_char_Sg__a_get(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_Color(void *obj) { -ofColor_< unsigned char > *arg1 = (ofColor_< unsigned char > *) obj; -delete arg1; -} -static int _proxy__wrap_new_Color(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_Color); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_Color_attributes[] = { - { "r", _wrap_Color_r_get, _wrap_Color_r_set }, - { "g", _wrap_Color_g_get, _wrap_Color_g_set }, - { "b", _wrap_Color_b_get, _wrap_Color_b_set }, - { "a", _wrap_Color_a_get, _wrap_Color_a_set }, - {0,0,0} -}; -static swig_lua_method swig_Color_methods[]= { - { "set", _wrap_Color_set}, - { "setHex", _wrap_Color_setHex}, - { "setHue", _wrap_Color_setHue}, - { "setHueAngle", _wrap_Color_setHueAngle}, - { "setSaturation", _wrap_Color_setSaturation}, - { "setBrightness", _wrap_Color_setBrightness}, - { "setHsb", _wrap_Color_setHsb}, - { "clamp", _wrap_Color_clamp}, - { "invert", _wrap_Color_invert}, - { "normalize", _wrap_Color_normalize}, - { "lerp", _wrap_Color_lerp}, - { "getClamped", _wrap_Color_getClamped}, - { "getInverted", _wrap_Color_getInverted}, - { "getNormalized", _wrap_Color_getNormalized}, - { "getLerped", _wrap_Color_getLerped}, - { "getHex", _wrap_Color_getHex}, - { "getHue", _wrap_Color_getHue}, - { "getHueAngle", _wrap_Color_getHueAngle}, - { "getSaturation", _wrap_Color_getSaturation}, - { "getBrightness", _wrap_Color_getBrightness}, - { "getLightness", _wrap_Color_getLightness}, - { "getHsb", _wrap_Color_getHsb}, - { "__eq", _wrap_Color___eq}, - { "__add", _wrap_Color___add}, - { "__sub", _wrap_Color___sub}, - { "__mul", _wrap_Color___mul}, - { "__div", _wrap_Color___div}, - { "getR", _wrap_Color_getR}, - { "getG", _wrap_Color_getG}, - { "getB", _wrap_Color_getB}, - { "getA", _wrap_Color_getA}, - { "setR", _wrap_Color_setR}, - { "setG", _wrap_Color_setG}, - { "setB", _wrap_Color_setB}, - { "setA", _wrap_Color_setA}, - { "__tostring", _wrap_Color___tostring}, - {0,0} -}; -static swig_lua_method swig_Color_meta[] = { - { "__eq", _wrap_Color___eq}, - { "__add", _wrap_Color___add}, - { "__sub", _wrap_Color___sub}, - { "__mul", _wrap_Color___mul}, - { "__div", _wrap_Color___div}, - { "__tostring", _wrap_Color___tostring}, - {0,0} -}; - -static swig_lua_attribute swig_Color_Sf_SwigStatic_attributes[] = { - { "white", _wrap_Color_white_get, SWIG_Lua_set_immutable }, - { "gray", _wrap_Color_gray_get, SWIG_Lua_set_immutable }, - { "black", _wrap_Color_black_get, SWIG_Lua_set_immutable }, - { "red", _wrap_Color_red_get, SWIG_Lua_set_immutable }, - { "green", _wrap_Color_green_get, SWIG_Lua_set_immutable }, - { "blue", _wrap_Color_blue_get, SWIG_Lua_set_immutable }, - { "cyan", _wrap_Color_cyan_get, SWIG_Lua_set_immutable }, - { "magenta", _wrap_Color_magenta_get, SWIG_Lua_set_immutable }, - { "yellow", _wrap_Color_yellow_get, SWIG_Lua_set_immutable }, - { "aliceBlue", _wrap_Color_aliceBlue_get, SWIG_Lua_set_immutable }, - { "antiqueWhite", _wrap_Color_antiqueWhite_get, SWIG_Lua_set_immutable }, - { "aqua", _wrap_Color_aqua_get, SWIG_Lua_set_immutable }, - { "aquamarine", _wrap_Color_aquamarine_get, SWIG_Lua_set_immutable }, - { "azure", _wrap_Color_azure_get, SWIG_Lua_set_immutable }, - { "beige", _wrap_Color_beige_get, SWIG_Lua_set_immutable }, - { "bisque", _wrap_Color_bisque_get, SWIG_Lua_set_immutable }, - { "blanchedAlmond", _wrap_Color_blanchedAlmond_get, SWIG_Lua_set_immutable }, - { "blueViolet", _wrap_Color_blueViolet_get, SWIG_Lua_set_immutable }, - { "brown", _wrap_Color_brown_get, SWIG_Lua_set_immutable }, - { "burlyWood", _wrap_Color_burlyWood_get, SWIG_Lua_set_immutable }, - { "cadetBlue", _wrap_Color_cadetBlue_get, SWIG_Lua_set_immutable }, - { "chartreuse", _wrap_Color_chartreuse_get, SWIG_Lua_set_immutable }, - { "chocolate", _wrap_Color_chocolate_get, SWIG_Lua_set_immutable }, - { "coral", _wrap_Color_coral_get, SWIG_Lua_set_immutable }, - { "cornflowerBlue", _wrap_Color_cornflowerBlue_get, SWIG_Lua_set_immutable }, - { "cornsilk", _wrap_Color_cornsilk_get, SWIG_Lua_set_immutable }, - { "crimson", _wrap_Color_crimson_get, SWIG_Lua_set_immutable }, - { "darkBlue", _wrap_Color_darkBlue_get, SWIG_Lua_set_immutable }, - { "darkCyan", _wrap_Color_darkCyan_get, SWIG_Lua_set_immutable }, - { "darkGoldenRod", _wrap_Color_darkGoldenRod_get, SWIG_Lua_set_immutable }, - { "darkGray", _wrap_Color_darkGray_get, SWIG_Lua_set_immutable }, - { "darkGrey", _wrap_Color_darkGrey_get, SWIG_Lua_set_immutable }, - { "darkGreen", _wrap_Color_darkGreen_get, SWIG_Lua_set_immutable }, - { "darkKhaki", _wrap_Color_darkKhaki_get, SWIG_Lua_set_immutable }, - { "darkMagenta", _wrap_Color_darkMagenta_get, SWIG_Lua_set_immutable }, - { "darkOliveGreen", _wrap_Color_darkOliveGreen_get, SWIG_Lua_set_immutable }, - { "darkorange", _wrap_Color_darkorange_get, SWIG_Lua_set_immutable }, - { "darkOrchid", _wrap_Color_darkOrchid_get, SWIG_Lua_set_immutable }, - { "darkRed", _wrap_Color_darkRed_get, SWIG_Lua_set_immutable }, - { "darkSalmon", _wrap_Color_darkSalmon_get, SWIG_Lua_set_immutable }, - { "darkSeaGreen", _wrap_Color_darkSeaGreen_get, SWIG_Lua_set_immutable }, - { "darkSlateBlue", _wrap_Color_darkSlateBlue_get, SWIG_Lua_set_immutable }, - { "darkSlateGray", _wrap_Color_darkSlateGray_get, SWIG_Lua_set_immutable }, - { "darkSlateGrey", _wrap_Color_darkSlateGrey_get, SWIG_Lua_set_immutable }, - { "darkTurquoise", _wrap_Color_darkTurquoise_get, SWIG_Lua_set_immutable }, - { "darkViolet", _wrap_Color_darkViolet_get, SWIG_Lua_set_immutable }, - { "deepPink", _wrap_Color_deepPink_get, SWIG_Lua_set_immutable }, - { "deepSkyBlue", _wrap_Color_deepSkyBlue_get, SWIG_Lua_set_immutable }, - { "dimGray", _wrap_Color_dimGray_get, SWIG_Lua_set_immutable }, - { "dimGrey", _wrap_Color_dimGrey_get, SWIG_Lua_set_immutable }, - { "dodgerBlue", _wrap_Color_dodgerBlue_get, SWIG_Lua_set_immutable }, - { "fireBrick", _wrap_Color_fireBrick_get, SWIG_Lua_set_immutable }, - { "floralWhite", _wrap_Color_floralWhite_get, SWIG_Lua_set_immutable }, - { "forestGreen", _wrap_Color_forestGreen_get, SWIG_Lua_set_immutable }, - { "fuchsia", _wrap_Color_fuchsia_get, SWIG_Lua_set_immutable }, - { "gainsboro", _wrap_Color_gainsboro_get, SWIG_Lua_set_immutable }, - { "ghostWhite", _wrap_Color_ghostWhite_get, SWIG_Lua_set_immutable }, - { "gold", _wrap_Color_gold_get, SWIG_Lua_set_immutable }, - { "goldenRod", _wrap_Color_goldenRod_get, SWIG_Lua_set_immutable }, - { "grey", _wrap_Color_grey_get, SWIG_Lua_set_immutable }, - { "greenYellow", _wrap_Color_greenYellow_get, SWIG_Lua_set_immutable }, - { "honeyDew", _wrap_Color_honeyDew_get, SWIG_Lua_set_immutable }, - { "hotPink", _wrap_Color_hotPink_get, SWIG_Lua_set_immutable }, - { "indianRed", _wrap_Color_indianRed_get, SWIG_Lua_set_immutable }, - { "indigo", _wrap_Color_indigo_get, SWIG_Lua_set_immutable }, - { "ivory", _wrap_Color_ivory_get, SWIG_Lua_set_immutable }, - { "khaki", _wrap_Color_khaki_get, SWIG_Lua_set_immutable }, - { "lavender", _wrap_Color_lavender_get, SWIG_Lua_set_immutable }, - { "lavenderBlush", _wrap_Color_lavenderBlush_get, SWIG_Lua_set_immutable }, - { "lawnGreen", _wrap_Color_lawnGreen_get, SWIG_Lua_set_immutable }, - { "lemonChiffon", _wrap_Color_lemonChiffon_get, SWIG_Lua_set_immutable }, - { "lightBlue", _wrap_Color_lightBlue_get, SWIG_Lua_set_immutable }, - { "lightCoral", _wrap_Color_lightCoral_get, SWIG_Lua_set_immutable }, - { "lightCyan", _wrap_Color_lightCyan_get, SWIG_Lua_set_immutable }, - { "lightGoldenRodYellow", _wrap_Color_lightGoldenRodYellow_get, SWIG_Lua_set_immutable }, - { "lightGray", _wrap_Color_lightGray_get, SWIG_Lua_set_immutable }, - { "lightGrey", _wrap_Color_lightGrey_get, SWIG_Lua_set_immutable }, - { "lightGreen", _wrap_Color_lightGreen_get, SWIG_Lua_set_immutable }, - { "lightPink", _wrap_Color_lightPink_get, SWIG_Lua_set_immutable }, - { "lightSalmon", _wrap_Color_lightSalmon_get, SWIG_Lua_set_immutable }, - { "lightSeaGreen", _wrap_Color_lightSeaGreen_get, SWIG_Lua_set_immutable }, - { "lightSkyBlue", _wrap_Color_lightSkyBlue_get, SWIG_Lua_set_immutable }, - { "lightSlateGray", _wrap_Color_lightSlateGray_get, SWIG_Lua_set_immutable }, - { "lightSlateGrey", _wrap_Color_lightSlateGrey_get, SWIG_Lua_set_immutable }, - { "lightSteelBlue", _wrap_Color_lightSteelBlue_get, SWIG_Lua_set_immutable }, - { "lightYellow", _wrap_Color_lightYellow_get, SWIG_Lua_set_immutable }, - { "lime", _wrap_Color_lime_get, SWIG_Lua_set_immutable }, - { "limeGreen", _wrap_Color_limeGreen_get, SWIG_Lua_set_immutable }, - { "linen", _wrap_Color_linen_get, SWIG_Lua_set_immutable }, - { "maroon", _wrap_Color_maroon_get, SWIG_Lua_set_immutable }, - { "mediumAquaMarine", _wrap_Color_mediumAquaMarine_get, SWIG_Lua_set_immutable }, - { "mediumBlue", _wrap_Color_mediumBlue_get, SWIG_Lua_set_immutable }, - { "mediumOrchid", _wrap_Color_mediumOrchid_get, SWIG_Lua_set_immutable }, - { "mediumPurple", _wrap_Color_mediumPurple_get, SWIG_Lua_set_immutable }, - { "mediumSeaGreen", _wrap_Color_mediumSeaGreen_get, SWIG_Lua_set_immutable }, - { "mediumSlateBlue", _wrap_Color_mediumSlateBlue_get, SWIG_Lua_set_immutable }, - { "mediumSpringGreen", _wrap_Color_mediumSpringGreen_get, SWIG_Lua_set_immutable }, - { "mediumTurquoise", _wrap_Color_mediumTurquoise_get, SWIG_Lua_set_immutable }, - { "mediumVioletRed", _wrap_Color_mediumVioletRed_get, SWIG_Lua_set_immutable }, - { "midnightBlue", _wrap_Color_midnightBlue_get, SWIG_Lua_set_immutable }, - { "mintCream", _wrap_Color_mintCream_get, SWIG_Lua_set_immutable }, - { "mistyRose", _wrap_Color_mistyRose_get, SWIG_Lua_set_immutable }, - { "moccasin", _wrap_Color_moccasin_get, SWIG_Lua_set_immutable }, - { "navajoWhite", _wrap_Color_navajoWhite_get, SWIG_Lua_set_immutable }, - { "navy", _wrap_Color_navy_get, SWIG_Lua_set_immutable }, - { "oldLace", _wrap_Color_oldLace_get, SWIG_Lua_set_immutable }, - { "olive", _wrap_Color_olive_get, SWIG_Lua_set_immutable }, - { "oliveDrab", _wrap_Color_oliveDrab_get, SWIG_Lua_set_immutable }, - { "orange", _wrap_Color_orange_get, SWIG_Lua_set_immutable }, - { "orangeRed", _wrap_Color_orangeRed_get, SWIG_Lua_set_immutable }, - { "orchid", _wrap_Color_orchid_get, SWIG_Lua_set_immutable }, - { "paleGoldenRod", _wrap_Color_paleGoldenRod_get, SWIG_Lua_set_immutable }, - { "paleGreen", _wrap_Color_paleGreen_get, SWIG_Lua_set_immutable }, - { "paleTurquoise", _wrap_Color_paleTurquoise_get, SWIG_Lua_set_immutable }, - { "paleVioletRed", _wrap_Color_paleVioletRed_get, SWIG_Lua_set_immutable }, - { "papayaWhip", _wrap_Color_papayaWhip_get, SWIG_Lua_set_immutable }, - { "peachPuff", _wrap_Color_peachPuff_get, SWIG_Lua_set_immutable }, - { "peru", _wrap_Color_peru_get, SWIG_Lua_set_immutable }, - { "pink", _wrap_Color_pink_get, SWIG_Lua_set_immutable }, - { "plum", _wrap_Color_plum_get, SWIG_Lua_set_immutable }, - { "powderBlue", _wrap_Color_powderBlue_get, SWIG_Lua_set_immutable }, - { "purple", _wrap_Color_purple_get, SWIG_Lua_set_immutable }, - { "rosyBrown", _wrap_Color_rosyBrown_get, SWIG_Lua_set_immutable }, - { "royalBlue", _wrap_Color_royalBlue_get, SWIG_Lua_set_immutable }, - { "saddleBrown", _wrap_Color_saddleBrown_get, SWIG_Lua_set_immutable }, - { "salmon", _wrap_Color_salmon_get, SWIG_Lua_set_immutable }, - { "sandyBrown", _wrap_Color_sandyBrown_get, SWIG_Lua_set_immutable }, - { "seaGreen", _wrap_Color_seaGreen_get, SWIG_Lua_set_immutable }, - { "seaShell", _wrap_Color_seaShell_get, SWIG_Lua_set_immutable }, - { "sienna", _wrap_Color_sienna_get, SWIG_Lua_set_immutable }, - { "silver", _wrap_Color_silver_get, SWIG_Lua_set_immutable }, - { "skyBlue", _wrap_Color_skyBlue_get, SWIG_Lua_set_immutable }, - { "slateBlue", _wrap_Color_slateBlue_get, SWIG_Lua_set_immutable }, - { "slateGray", _wrap_Color_slateGray_get, SWIG_Lua_set_immutable }, - { "slateGrey", _wrap_Color_slateGrey_get, SWIG_Lua_set_immutable }, - { "snow", _wrap_Color_snow_get, SWIG_Lua_set_immutable }, - { "springGreen", _wrap_Color_springGreen_get, SWIG_Lua_set_immutable }, - { "steelBlue", _wrap_Color_steelBlue_get, SWIG_Lua_set_immutable }, - { "blueSteel", _wrap_Color_blueSteel_get, SWIG_Lua_set_immutable }, - { "tan", _wrap_Color_tan_get, SWIG_Lua_set_immutable }, - { "teal", _wrap_Color_teal_get, SWIG_Lua_set_immutable }, - { "thistle", _wrap_Color_thistle_get, SWIG_Lua_set_immutable }, - { "tomato", _wrap_Color_tomato_get, SWIG_Lua_set_immutable }, - { "turquoise", _wrap_Color_turquoise_get, SWIG_Lua_set_immutable }, - { "violet", _wrap_Color_violet_get, SWIG_Lua_set_immutable }, - { "wheat", _wrap_Color_wheat_get, SWIG_Lua_set_immutable }, - { "whiteSmoke", _wrap_Color_whiteSmoke_get, SWIG_Lua_set_immutable }, - { "yellowGreen", _wrap_Color_yellowGreen_get, SWIG_Lua_set_immutable }, - {0,0,0} -}; -static swig_lua_const_info swig_Color_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_Color_Sf_SwigStatic_methods[]= { - { "fromHsb", _wrap_Color_fromHsb}, - { "fromHex", _wrap_Color_fromHex}, - { "limit", _wrap_Color_limit}, - {0,0} -}; -static swig_lua_class* swig_Color_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_Color_Sf_SwigStatic = { - "Color", - swig_Color_Sf_SwigStatic_methods, - swig_Color_Sf_SwigStatic_attributes, - swig_Color_Sf_SwigStatic_constants, - swig_Color_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_Color_bases[] = {0}; -static const char *swig_Color_base_names[] = {0}; -static swig_lua_class _wrap_class_Color = { "Color", "Color", &SWIGTYPE_p_ofColor_T_unsigned_char_t,_proxy__wrap_new_Color, swig_delete_Color, swig_Color_methods, swig_Color_attributes, &swig_Color_Sf_SwigStatic, swig_Color_meta, swig_Color_bases, swig_Color_base_names }; - -static int _wrap_new_FloatColor__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::ofColor_",0,0) result = (ofColor_< float > *)new ofColor_< float >(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_FloatColor__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - ofColor_< float > *result = 0 ; SWIG_check_num_args("ofColor_< float >::ofColor_",4,4) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofColor_< float >::ofColor_",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< float >::ofColor_",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< float >::ofColor_",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofColor_< float >::ofColor_",4,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - result = (ofColor_< float > *)new ofColor_< float >(arg1,arg2,arg3,arg4); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_FloatColor__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; - ofColor_< float > *result = 0 ; SWIG_check_num_args("ofColor_< float >::ofColor_",3,3) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofColor_< float >::ofColor_",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< float >::ofColor_",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< float >::ofColor_",3,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - result = (ofColor_< float > *)new ofColor_< float >(arg1,arg2,arg3); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_FloatColor__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; - ofColor_< float > *result = 0 ; SWIG_check_num_args("ofColor_< float >::ofColor_",2,2) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofColor_< float >::ofColor_",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< float >::ofColor_",2,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); result = (ofColor_< float > *)new ofColor_< float >(arg1,arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_FloatColor__SWIG_4(lua_State* L) { int SWIG_arg = 0; float arg1 ; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::ofColor_",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofColor_< float >::ofColor_",1,"float"); arg1 = (float)lua_tonumber(L, 1); - result = (ofColor_< float > *)new ofColor_< float >(arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_FloatColor__SWIG_5(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = 0 ; float arg2 ; - ofColor_< float > *result = 0 ; SWIG_check_num_args("ofColor_< float >::ofColor_",2,2) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofColor_< float >::ofColor_",1,"ofColor_< float > const &"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< float >::ofColor_",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("new_FloatColor",1,SWIGTYPE_p_ofColor_T_float_t); } arg2 = (float)lua_tonumber(L, 2); - result = (ofColor_< float > *)new ofColor_< float >((ofColor_< float > const &)*arg1,arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_FloatColor(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_FloatColor__SWIG_0(L);} if (argc == 1) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { - return _wrap_new_FloatColor__SWIG_4(L);} } if (argc == 2) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_new_FloatColor__SWIG_5(L);} } } if (argc == 2) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_new_FloatColor__SWIG_3(L);} } } if (argc == 3) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_new_FloatColor__SWIG_2(L);} } } } if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_new_FloatColor__SWIG_1(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_FloatColor'\n" " Possible C/C++ prototypes are:\n" - " ofColor_< float >::ofColor_()\n" " ofColor_< float >::ofColor_(float,float,float,float)\n" - " ofColor_< float >::ofColor_(float,float,float)\n" " ofColor_< float >::ofColor_(float,float)\n" - " ofColor_< float >::ofColor_(float)\n" " ofColor_< float >::ofColor_(ofColor_< float > const &,float)\n"); - lua_error(L);return 0; } -static int _wrap_FloatColor_fromHsb__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; - float arg4 ; ofColor_< float > result; SWIG_check_num_args("ofColor_< float >::fromHsb",4,4) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofColor_< float >::fromHsb",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< float >::fromHsb",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< float >::fromHsb",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofColor_< float >::fromHsb",4,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - result = ofColor_< float >::SWIGTEMPLATEDISAMBIGUATOR fromHsb(arg1,arg2,arg3,arg4); { - ofColor_< float > * resultptr = new ofColor_< float >((const ofColor_< float > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_fromHsb__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; - ofColor_< float > result; SWIG_check_num_args("ofColor_< float >::fromHsb",3,3) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofColor_< float >::fromHsb",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< float >::fromHsb",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< float >::fromHsb",3,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - result = ofColor_< float >::SWIGTEMPLATEDISAMBIGUATOR fromHsb(arg1,arg2,arg3); { - ofColor_< float > * resultptr = new ofColor_< float >((const ofColor_< float > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_fromHsb(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_FloatColor_fromHsb__SWIG_1(L);} } } } if (argc == 4) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { - return _wrap_FloatColor_fromHsb__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatColor_fromHsb'\n" " Possible C/C++ prototypes are:\n" - " ofColor_< float >::fromHsb(float,float,float,float)\n" " ofColor_< float >::fromHsb(float,float,float)\n"); - lua_error(L);return 0; } -static int _wrap_FloatColor_fromHex__SWIG_0(lua_State* L) { int SWIG_arg = 0; int arg1 ; float arg2 ; ofColor_< float > result; - SWIG_check_num_args("ofColor_< float >::fromHex",2,2) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofColor_< float >::fromHex",1,"int"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< float >::fromHex",2,"float"); arg1 = (int)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); result = ofColor_< float >::SWIGTEMPLATEDISAMBIGUATOR fromHex(arg1,arg2); { - ofColor_< float > * resultptr = new ofColor_< float >((const ofColor_< float > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_fromHex__SWIG_1(lua_State* L) { int SWIG_arg = 0; int arg1 ; ofColor_< float > result; - SWIG_check_num_args("ofColor_< float >::fromHex",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofColor_< float >::fromHex",1,"int"); arg1 = (int)lua_tonumber(L, 1); - result = ofColor_< float >::SWIGTEMPLATEDISAMBIGUATOR fromHex(arg1); { - ofColor_< float > * resultptr = new ofColor_< float >((const ofColor_< float > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_fromHex(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_FloatColor_fromHex__SWIG_1(L);} } if (argc == 2) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_FloatColor_fromHex__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatColor_fromHex'\n" " Possible C/C++ prototypes are:\n" - " ofColor_< float >::fromHex(int,float)\n" " ofColor_< float >::fromHex(int)\n"); lua_error(L);return 0; } -static int _wrap_FloatColor_set__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float arg2 ; float arg3 ; float arg4 ; float arg5 ; SWIG_check_num_args("ofColor_< float >::set",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::set",1,"ofColor_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< float >::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< float >::set",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofColor_< float >::set",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofColor_< float >::set",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_set",1,SWIGTYPE_p_ofColor_T_float_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - (arg1)->set(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_set__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float arg2 ; float arg3 ; float arg4 ; SWIG_check_num_args("ofColor_< float >::set",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::set",1,"ofColor_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< float >::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< float >::set",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofColor_< float >::set",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_set",1,SWIGTYPE_p_ofColor_T_float_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); (arg1)->set(arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_set__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float arg2 ; float arg3 ; SWIG_check_num_args("ofColor_< float >::set",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::set",1,"ofColor_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< float >::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< float >::set",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_set",1,SWIGTYPE_p_ofColor_T_float_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->set(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FloatColor_set__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float arg2 ; SWIG_check_num_args("ofColor_< float >::set",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::set",1,"ofColor_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< float >::set",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_set",1,SWIGTYPE_p_ofColor_T_float_t); } arg2 = (float)lua_tonumber(L, 2); (arg1)->set(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_set__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - ofColor_< float > *arg2 = 0 ; SWIG_check_num_args("ofColor_< float >::set",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::set",1,"ofColor_< float > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofColor_< float >::set",2,"ofColor_< float > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_set",1,SWIGTYPE_p_ofColor_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_set",2,SWIGTYPE_p_ofColor_T_float_t); } (arg1)->set((ofColor_< float > const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_set(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_FloatColor_set__SWIG_4(L);} } } if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_FloatColor_set__SWIG_3(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_FloatColor_set__SWIG_2(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_FloatColor_set__SWIG_1(L);} } } } } - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_FloatColor_set__SWIG_0(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatColor_set'\n" " Possible C/C++ prototypes are:\n" - " ofColor_< float >::set(float,float,float,float)\n" " ofColor_< float >::set(float,float,float)\n" - " ofColor_< float >::set(float,float)\n" " ofColor_< float >::set(float)\n" - " ofColor_< float >::set(ofColor_< float > const &)\n"); lua_error(L);return 0; } -static int _wrap_FloatColor_setHex__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - int arg2 ; float arg3 ; SWIG_check_num_args("ofColor_< float >::setHex",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::setHex",1,"ofColor_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< float >::setHex",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< float >::setHex",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_setHex",1,SWIGTYPE_p_ofColor_T_float_t); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->setHex(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FloatColor_setHex__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - int arg2 ; SWIG_check_num_args("ofColor_< float >::setHex",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::setHex",1,"ofColor_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< float >::setHex",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_setHex",1,SWIGTYPE_p_ofColor_T_float_t); } arg2 = (int)lua_tonumber(L, 2); (arg1)->setHex(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_setHex(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_FloatColor_setHex__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_FloatColor_setHex__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatColor_setHex'\n" " Possible C/C++ prototypes are:\n" - " ofColor_< float >::setHex(int,float)\n" " ofColor_< float >::setHex(int)\n"); lua_error(L);return 0; } -static int _wrap_FloatColor_setHue(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float arg2 ; SWIG_check_num_args("ofColor_< float >::setHue",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::setHue",1,"ofColor_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< float >::setHue",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_setHue",1,SWIGTYPE_p_ofColor_T_float_t); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setHue(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_setHueAngle(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float arg2 ; SWIG_check_num_args("ofColor_< float >::setHueAngle",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::setHueAngle",1,"ofColor_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< float >::setHueAngle",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_setHueAngle",1,SWIGTYPE_p_ofColor_T_float_t); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setHueAngle(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_setSaturation(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float arg2 ; SWIG_check_num_args("ofColor_< float >::setSaturation",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::setSaturation",1,"ofColor_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< float >::setSaturation",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_setSaturation",1,SWIGTYPE_p_ofColor_T_float_t); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setSaturation(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_setBrightness(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float arg2 ; SWIG_check_num_args("ofColor_< float >::setBrightness",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::setBrightness",1,"ofColor_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< float >::setBrightness",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_setBrightness",1,SWIGTYPE_p_ofColor_T_float_t); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setBrightness(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_setHsb__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float arg2 ; float arg3 ; float arg4 ; float arg5 ; SWIG_check_num_args("ofColor_< float >::setHsb",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::setHsb",1,"ofColor_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< float >::setHsb",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< float >::setHsb",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofColor_< float >::setHsb",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofColor_< float >::setHsb",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_setHsb",1,SWIGTYPE_p_ofColor_T_float_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - (arg1)->setHsb(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_setHsb__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float arg2 ; float arg3 ; float arg4 ; SWIG_check_num_args("ofColor_< float >::setHsb",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::setHsb",1,"ofColor_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< float >::setHsb",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< float >::setHsb",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofColor_< float >::setHsb",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_setHsb",1,SWIGTYPE_p_ofColor_T_float_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); (arg1)->setHsb(arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_setHsb(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 4) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_FloatColor_setHsb__SWIG_1(L);} } } } } - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_FloatColor_setHsb__SWIG_0(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatColor_setHsb'\n" " Possible C/C++ prototypes are:\n" - " ofColor_< float >::setHsb(float,float,float,float)\n" " ofColor_< float >::setHsb(float,float,float)\n"); - lua_error(L);return 0; } -static int _wrap_FloatColor_clamp(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - ofColor_< float > *result = 0 ; SWIG_check_num_args("ofColor_< float >::clamp",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::clamp",1,"ofColor_< float > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_clamp",1,SWIGTYPE_p_ofColor_T_float_t); } result = (ofColor_< float > *) &(arg1)->clamp(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_invert(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - ofColor_< float > *result = 0 ; SWIG_check_num_args("ofColor_< float >::invert",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::invert",1,"ofColor_< float > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_invert",1,SWIGTYPE_p_ofColor_T_float_t); } result = (ofColor_< float > *) &(arg1)->invert(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_normalize(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - ofColor_< float > *result = 0 ; SWIG_check_num_args("ofColor_< float >::normalize",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::normalize",1,"ofColor_< float > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_normalize",1,SWIGTYPE_p_ofColor_T_float_t); } - result = (ofColor_< float > *) &(arg1)->normalize(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_lerp(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - ofColor_< float > *arg2 = 0 ; float arg3 ; ofColor_< float > *result = 0 ; SWIG_check_num_args("ofColor_< float >::lerp",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::lerp",1,"ofColor_< float > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofColor_< float >::lerp",2,"ofColor_< float > const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< float >::lerp",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_lerp",1,SWIGTYPE_p_ofColor_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_lerp",2,SWIGTYPE_p_ofColor_T_float_t); } arg3 = (float)lua_tonumber(L, 3); - result = (ofColor_< float > *) &(arg1)->lerp((ofColor_< float > const &)*arg2,arg3); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_getClamped(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - ofColor_< float > result; SWIG_check_num_args("ofColor_< float >::getClamped",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::getClamped",1,"ofColor_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_getClamped",1,SWIGTYPE_p_ofColor_T_float_t); } - result = ((ofColor_< float > const *)arg1)->getClamped(); { - ofColor_< float > * resultptr = new ofColor_< float >((const ofColor_< float > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_getInverted(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - ofColor_< float > result; SWIG_check_num_args("ofColor_< float >::getInverted",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::getInverted",1,"ofColor_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_getInverted",1,SWIGTYPE_p_ofColor_T_float_t); } - result = ((ofColor_< float > const *)arg1)->getInverted(); { - ofColor_< float > * resultptr = new ofColor_< float >((const ofColor_< float > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_getNormalized(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - ofColor_< float > result; SWIG_check_num_args("ofColor_< float >::getNormalized",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::getNormalized",1,"ofColor_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_getNormalized",1,SWIGTYPE_p_ofColor_T_float_t); } - result = ((ofColor_< float > const *)arg1)->getNormalized(); { - ofColor_< float > * resultptr = new ofColor_< float >((const ofColor_< float > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_getLerped(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - ofColor_< float > *arg2 = 0 ; float arg3 ; ofColor_< float > result; SWIG_check_num_args("ofColor_< float >::getLerped",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::getLerped",1,"ofColor_< float > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofColor_< float >::getLerped",2,"ofColor_< float > const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< float >::getLerped",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_getLerped",1,SWIGTYPE_p_ofColor_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_getLerped",2,SWIGTYPE_p_ofColor_T_float_t); } arg3 = (float)lua_tonumber(L, 3); - result = ((ofColor_< float > const *)arg1)->getLerped((ofColor_< float > const &)*arg2,arg3); { - ofColor_< float > * resultptr = new ofColor_< float >((const ofColor_< float > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_getHex(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - int result; SWIG_check_num_args("ofColor_< float >::getHex",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::getHex",1,"ofColor_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_getHex",1,SWIGTYPE_p_ofColor_T_float_t); } - result = (int)((ofColor_< float > const *)arg1)->getHex(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_getHue(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float result; SWIG_check_num_args("ofColor_< float >::getHue",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::getHue",1,"ofColor_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_getHue",1,SWIGTYPE_p_ofColor_T_float_t); } - result = (float)((ofColor_< float > const *)arg1)->getHue(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_getHueAngle(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float result; SWIG_check_num_args("ofColor_< float >::getHueAngle",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::getHueAngle",1,"ofColor_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_getHueAngle",1,SWIGTYPE_p_ofColor_T_float_t); } - result = (float)((ofColor_< float > const *)arg1)->getHueAngle(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_getSaturation(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float result; SWIG_check_num_args("ofColor_< float >::getSaturation",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::getSaturation",1,"ofColor_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_getSaturation",1,SWIGTYPE_p_ofColor_T_float_t); } - result = (float)((ofColor_< float > const *)arg1)->getSaturation(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_getBrightness(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float result; SWIG_check_num_args("ofColor_< float >::getBrightness",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::getBrightness",1,"ofColor_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_getBrightness",1,SWIGTYPE_p_ofColor_T_float_t); } - result = (float)((ofColor_< float > const *)arg1)->getBrightness(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_getLightness(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float result; SWIG_check_num_args("ofColor_< float >::getLightness",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::getLightness",1,"ofColor_< float > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_getLightness",1,SWIGTYPE_p_ofColor_T_float_t); } - result = (float)((ofColor_< float > const *)arg1)->getLightness(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_getHsb(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float *arg2 = 0 ; float *arg3 = 0 ; float *arg4 = 0 ; SWIG_check_num_args("ofColor_< float >::getHsb",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::getHsb",1,"ofColor_< float > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofColor_< float >::getHsb",2,"float &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofColor_< float >::getHsb",3,"float &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofColor_< float >::getHsb",4,"float &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_getHsb",1,SWIGTYPE_p_ofColor_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("FloatColor_getHsb",2,SWIGTYPE_p_float); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("FloatColor_getHsb",3,SWIGTYPE_p_float); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("FloatColor_getHsb",4,SWIGTYPE_p_float); } ((ofColor_< float > const *)arg1)->getHsb(*arg2,*arg3,*arg4); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_limit(lua_State* L) { int SWIG_arg = 0; float result; - SWIG_check_num_args("ofColor_< float >::limit",0,0) result = (float)ofColor_< float >::SWIGTEMPLATEDISAMBIGUATOR limit(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor___eq(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - ofColor_< float > *arg2 = 0 ; bool result; SWIG_check_num_args("ofColor_< float >::operator ==",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::operator ==",1,"ofColor_< float > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofColor_< float >::operator ==",2,"ofColor_< float > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor___eq",1,SWIGTYPE_p_ofColor_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor___eq",2,SWIGTYPE_p_ofColor_T_float_t); } - result = (bool)((ofColor_< float > const *)arg1)->operator ==((ofColor_< float > const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor___add__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - ofColor_< float > *arg2 = 0 ; ofColor_< float > result; SWIG_check_num_args("ofColor_< float >::operator +",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::operator +",1,"ofColor_< float > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofColor_< float >::operator +",2,"ofColor_< float > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor___add",1,SWIGTYPE_p_ofColor_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor___add",2,SWIGTYPE_p_ofColor_T_float_t); } - result = ((ofColor_< float > const *)arg1)->operator +((ofColor_< float > const &)*arg2); { - ofColor_< float > * resultptr = new ofColor_< float >((const ofColor_< float > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor___add__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float *arg2 = 0 ; float temp2 ; ofColor_< float > result; SWIG_check_num_args("ofColor_< float >::operator +",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::operator +",1,"ofColor_< float > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< float >::operator +",2,"float const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor___add",1,SWIGTYPE_p_ofColor_T_float_t); } temp2=(float)lua_tonumber(L,2); arg2=&temp2; - result = ((ofColor_< float > const *)arg1)->operator +((float const &)*arg2); { - ofColor_< float > * resultptr = new ofColor_< float >((const ofColor_< float > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor___add(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_FloatColor___add__SWIG_0(L);} } } if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_FloatColor___add__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatColor___add'\n" " Possible C/C++ prototypes are:\n" - " ofColor_< float >::operator +(ofColor_< float > const &) const\n" - " ofColor_< float >::operator +(float const &) const\n"); lua_error(L);return 0; } -static int _wrap_FloatColor___sub__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - ofColor_< float > *arg2 = 0 ; ofColor_< float > result; SWIG_check_num_args("ofColor_< float >::operator -",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::operator -",1,"ofColor_< float > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofColor_< float >::operator -",2,"ofColor_< float > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor___sub",1,SWIGTYPE_p_ofColor_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor___sub",2,SWIGTYPE_p_ofColor_T_float_t); } - result = ((ofColor_< float > const *)arg1)->operator -((ofColor_< float > const &)*arg2); { - ofColor_< float > * resultptr = new ofColor_< float >((const ofColor_< float > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor___sub__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float *arg2 = 0 ; float temp2 ; ofColor_< float > result; SWIG_check_num_args("ofColor_< float >::operator -",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::operator -",1,"ofColor_< float > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< float >::operator -",2,"float const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor___sub",1,SWIGTYPE_p_ofColor_T_float_t); } temp2=(float)lua_tonumber(L,2); arg2=&temp2; - result = ((ofColor_< float > const *)arg1)->operator -((float const &)*arg2); { - ofColor_< float > * resultptr = new ofColor_< float >((const ofColor_< float > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor___sub(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_FloatColor___sub__SWIG_0(L);} } } if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_FloatColor___sub__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatColor___sub'\n" " Possible C/C++ prototypes are:\n" - " ofColor_< float >::operator -(ofColor_< float > const &) const\n" - " ofColor_< float >::operator -(float const &) const\n"); lua_error(L);return 0; } -static int _wrap_FloatColor___mul__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - ofColor_< float > *arg2 = 0 ; ofColor_< float > result; SWIG_check_num_args("ofColor_< float >::operator *",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::operator *",1,"ofColor_< float > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofColor_< float >::operator *",2,"ofColor_< float > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor___mul",1,SWIGTYPE_p_ofColor_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor___mul",2,SWIGTYPE_p_ofColor_T_float_t); } - result = ((ofColor_< float > const *)arg1)->operator *((ofColor_< float > const &)*arg2); { - ofColor_< float > * resultptr = new ofColor_< float >((const ofColor_< float > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor___mul__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float *arg2 = 0 ; float temp2 ; ofColor_< float > result; SWIG_check_num_args("ofColor_< float >::operator *",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::operator *",1,"ofColor_< float > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< float >::operator *",2,"float const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor___mul",1,SWIGTYPE_p_ofColor_T_float_t); } temp2=(float)lua_tonumber(L,2); arg2=&temp2; - result = ((ofColor_< float > const *)arg1)->operator *((float const &)*arg2); { - ofColor_< float > * resultptr = new ofColor_< float >((const ofColor_< float > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor___mul(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_FloatColor___mul__SWIG_0(L);} } } if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_FloatColor___mul__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatColor___mul'\n" " Possible C/C++ prototypes are:\n" - " ofColor_< float >::operator *(ofColor_< float > const &) const\n" - " ofColor_< float >::operator *(float const &) const\n"); lua_error(L);return 0; } -static int _wrap_FloatColor___div__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - ofColor_< float > *arg2 = 0 ; ofColor_< float > result; SWIG_check_num_args("ofColor_< float >::operator /",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::operator /",1,"ofColor_< float > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofColor_< float >::operator /",2,"ofColor_< float > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor___div",1,SWIGTYPE_p_ofColor_T_float_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor___div",2,SWIGTYPE_p_ofColor_T_float_t); } - result = ((ofColor_< float > const *)arg1)->operator /((ofColor_< float > const &)*arg2); { - ofColor_< float > * resultptr = new ofColor_< float >((const ofColor_< float > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor___div__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float *arg2 = 0 ; float temp2 ; ofColor_< float > result; SWIG_check_num_args("ofColor_< float >::operator /",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::operator /",1,"ofColor_< float > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< float >::operator /",2,"float const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor___div",1,SWIGTYPE_p_ofColor_T_float_t); } temp2=(float)lua_tonumber(L,2); arg2=&temp2; - result = ((ofColor_< float > const *)arg1)->operator /((float const &)*arg2); { - ofColor_< float > * resultptr = new ofColor_< float >((const ofColor_< float > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_float_t,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor___div(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_FloatColor___div__SWIG_0(L);} } } if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_float_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_FloatColor___div__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FloatColor___div'\n" " Possible C/C++ prototypes are:\n" - " ofColor_< float >::operator /(ofColor_< float > const &) const\n" - " ofColor_< float >::operator /(float const &) const\n"); lua_error(L);return 0; } -static int _wrap_FloatColor_white_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::white",0,0) result = (ofColor_< float > *)&ofColor_< float >::white; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_gray_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::gray",0,0) result = (ofColor_< float > *)&ofColor_< float >::gray; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_black_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::black",0,0) result = (ofColor_< float > *)&ofColor_< float >::black; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_red_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::red",0,0) result = (ofColor_< float > *)&ofColor_< float >::red; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_green_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::green",0,0) result = (ofColor_< float > *)&ofColor_< float >::green; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_blue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::blue",0,0) result = (ofColor_< float > *)&ofColor_< float >::blue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_cyan_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::cyan",0,0) result = (ofColor_< float > *)&ofColor_< float >::cyan; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_magenta_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::magenta",0,0) result = (ofColor_< float > *)&ofColor_< float >::magenta; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_yellow_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::yellow",0,0) result = (ofColor_< float > *)&ofColor_< float >::yellow; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_aliceBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::aliceBlue",0,0) result = (ofColor_< float > *)&ofColor_< float >::aliceBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_antiqueWhite_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::antiqueWhite",0,0) result = (ofColor_< float > *)&ofColor_< float >::antiqueWhite; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_aqua_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::aqua",0,0) result = (ofColor_< float > *)&ofColor_< float >::aqua; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_aquamarine_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::aquamarine",0,0) result = (ofColor_< float > *)&ofColor_< float >::aquamarine; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_azure_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::azure",0,0) result = (ofColor_< float > *)&ofColor_< float >::azure; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_beige_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::beige",0,0) result = (ofColor_< float > *)&ofColor_< float >::beige; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_bisque_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::bisque",0,0) result = (ofColor_< float > *)&ofColor_< float >::bisque; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_blanchedAlmond_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::blanchedAlmond",0,0) result = (ofColor_< float > *)&ofColor_< float >::blanchedAlmond; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_blueViolet_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::blueViolet",0,0) result = (ofColor_< float > *)&ofColor_< float >::blueViolet; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_brown_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::brown",0,0) result = (ofColor_< float > *)&ofColor_< float >::brown; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_burlyWood_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::burlyWood",0,0) result = (ofColor_< float > *)&ofColor_< float >::burlyWood; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_cadetBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::cadetBlue",0,0) result = (ofColor_< float > *)&ofColor_< float >::cadetBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_chartreuse_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::chartreuse",0,0) result = (ofColor_< float > *)&ofColor_< float >::chartreuse; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_chocolate_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::chocolate",0,0) result = (ofColor_< float > *)&ofColor_< float >::chocolate; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_coral_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::coral",0,0) result = (ofColor_< float > *)&ofColor_< float >::coral; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_cornflowerBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::cornflowerBlue",0,0) result = (ofColor_< float > *)&ofColor_< float >::cornflowerBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_cornsilk_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::cornsilk",0,0) result = (ofColor_< float > *)&ofColor_< float >::cornsilk; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_crimson_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::crimson",0,0) result = (ofColor_< float > *)&ofColor_< float >::crimson; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_darkBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::darkBlue",0,0) result = (ofColor_< float > *)&ofColor_< float >::darkBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_darkCyan_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::darkCyan",0,0) result = (ofColor_< float > *)&ofColor_< float >::darkCyan; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_darkGoldenRod_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::darkGoldenRod",0,0) result = (ofColor_< float > *)&ofColor_< float >::darkGoldenRod; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_darkGray_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::darkGray",0,0) result = (ofColor_< float > *)&ofColor_< float >::darkGray; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_darkGrey_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::darkGrey",0,0) result = (ofColor_< float > *)&ofColor_< float >::darkGrey; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_darkGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::darkGreen",0,0) result = (ofColor_< float > *)&ofColor_< float >::darkGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_darkKhaki_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::darkKhaki",0,0) result = (ofColor_< float > *)&ofColor_< float >::darkKhaki; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_darkMagenta_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::darkMagenta",0,0) result = (ofColor_< float > *)&ofColor_< float >::darkMagenta; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_darkOliveGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::darkOliveGreen",0,0) result = (ofColor_< float > *)&ofColor_< float >::darkOliveGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_darkorange_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::darkorange",0,0) result = (ofColor_< float > *)&ofColor_< float >::darkorange; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_darkOrchid_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::darkOrchid",0,0) result = (ofColor_< float > *)&ofColor_< float >::darkOrchid; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_darkRed_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::darkRed",0,0) result = (ofColor_< float > *)&ofColor_< float >::darkRed; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_darkSalmon_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::darkSalmon",0,0) result = (ofColor_< float > *)&ofColor_< float >::darkSalmon; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_darkSeaGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::darkSeaGreen",0,0) result = (ofColor_< float > *)&ofColor_< float >::darkSeaGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_darkSlateBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::darkSlateBlue",0,0) result = (ofColor_< float > *)&ofColor_< float >::darkSlateBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_darkSlateGray_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::darkSlateGray",0,0) result = (ofColor_< float > *)&ofColor_< float >::darkSlateGray; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_darkSlateGrey_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::darkSlateGrey",0,0) result = (ofColor_< float > *)&ofColor_< float >::darkSlateGrey; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_darkTurquoise_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::darkTurquoise",0,0) result = (ofColor_< float > *)&ofColor_< float >::darkTurquoise; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_darkViolet_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::darkViolet",0,0) result = (ofColor_< float > *)&ofColor_< float >::darkViolet; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_deepPink_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::deepPink",0,0) result = (ofColor_< float > *)&ofColor_< float >::deepPink; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_deepSkyBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::deepSkyBlue",0,0) result = (ofColor_< float > *)&ofColor_< float >::deepSkyBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_dimGray_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::dimGray",0,0) result = (ofColor_< float > *)&ofColor_< float >::dimGray; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_dimGrey_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::dimGrey",0,0) result = (ofColor_< float > *)&ofColor_< float >::dimGrey; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_dodgerBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::dodgerBlue",0,0) result = (ofColor_< float > *)&ofColor_< float >::dodgerBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_fireBrick_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::fireBrick",0,0) result = (ofColor_< float > *)&ofColor_< float >::fireBrick; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_floralWhite_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::floralWhite",0,0) result = (ofColor_< float > *)&ofColor_< float >::floralWhite; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_forestGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::forestGreen",0,0) result = (ofColor_< float > *)&ofColor_< float >::forestGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_fuchsia_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::fuchsia",0,0) result = (ofColor_< float > *)&ofColor_< float >::fuchsia; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_gainsboro_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::gainsboro",0,0) result = (ofColor_< float > *)&ofColor_< float >::gainsboro; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_ghostWhite_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::ghostWhite",0,0) result = (ofColor_< float > *)&ofColor_< float >::ghostWhite; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_gold_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::gold",0,0) result = (ofColor_< float > *)&ofColor_< float >::gold; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_goldenRod_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::goldenRod",0,0) result = (ofColor_< float > *)&ofColor_< float >::goldenRod; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_grey_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::grey",0,0) result = (ofColor_< float > *)&ofColor_< float >::grey; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_greenYellow_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::greenYellow",0,0) result = (ofColor_< float > *)&ofColor_< float >::greenYellow; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_honeyDew_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::honeyDew",0,0) result = (ofColor_< float > *)&ofColor_< float >::honeyDew; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_hotPink_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::hotPink",0,0) result = (ofColor_< float > *)&ofColor_< float >::hotPink; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_indianRed_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::indianRed",0,0) result = (ofColor_< float > *)&ofColor_< float >::indianRed; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_indigo_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::indigo",0,0) result = (ofColor_< float > *)&ofColor_< float >::indigo; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_ivory_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::ivory",0,0) result = (ofColor_< float > *)&ofColor_< float >::ivory; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_khaki_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::khaki",0,0) result = (ofColor_< float > *)&ofColor_< float >::khaki; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_lavender_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::lavender",0,0) result = (ofColor_< float > *)&ofColor_< float >::lavender; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_lavenderBlush_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::lavenderBlush",0,0) result = (ofColor_< float > *)&ofColor_< float >::lavenderBlush; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_lawnGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::lawnGreen",0,0) result = (ofColor_< float > *)&ofColor_< float >::lawnGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_lemonChiffon_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::lemonChiffon",0,0) result = (ofColor_< float > *)&ofColor_< float >::lemonChiffon; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_lightBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::lightBlue",0,0) result = (ofColor_< float > *)&ofColor_< float >::lightBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_lightCoral_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::lightCoral",0,0) result = (ofColor_< float > *)&ofColor_< float >::lightCoral; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_lightCyan_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::lightCyan",0,0) result = (ofColor_< float > *)&ofColor_< float >::lightCyan; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_lightGoldenRodYellow_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::lightGoldenRodYellow",0,0) - result = (ofColor_< float > *)&ofColor_< float >::lightGoldenRodYellow; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_lightGray_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::lightGray",0,0) result = (ofColor_< float > *)&ofColor_< float >::lightGray; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_lightGrey_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::lightGrey",0,0) result = (ofColor_< float > *)&ofColor_< float >::lightGrey; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_lightGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::lightGreen",0,0) result = (ofColor_< float > *)&ofColor_< float >::lightGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_lightPink_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::lightPink",0,0) result = (ofColor_< float > *)&ofColor_< float >::lightPink; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_lightSalmon_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::lightSalmon",0,0) result = (ofColor_< float > *)&ofColor_< float >::lightSalmon; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_lightSeaGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::lightSeaGreen",0,0) result = (ofColor_< float > *)&ofColor_< float >::lightSeaGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_lightSkyBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::lightSkyBlue",0,0) result = (ofColor_< float > *)&ofColor_< float >::lightSkyBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_lightSlateGray_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::lightSlateGray",0,0) result = (ofColor_< float > *)&ofColor_< float >::lightSlateGray; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_lightSlateGrey_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::lightSlateGrey",0,0) result = (ofColor_< float > *)&ofColor_< float >::lightSlateGrey; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_lightSteelBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::lightSteelBlue",0,0) result = (ofColor_< float > *)&ofColor_< float >::lightSteelBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_lightYellow_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::lightYellow",0,0) result = (ofColor_< float > *)&ofColor_< float >::lightYellow; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_lime_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::lime",0,0) result = (ofColor_< float > *)&ofColor_< float >::lime; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_limeGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::limeGreen",0,0) result = (ofColor_< float > *)&ofColor_< float >::limeGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_linen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::linen",0,0) result = (ofColor_< float > *)&ofColor_< float >::linen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_maroon_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::maroon",0,0) result = (ofColor_< float > *)&ofColor_< float >::maroon; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_mediumAquaMarine_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::mediumAquaMarine",0,0) - result = (ofColor_< float > *)&ofColor_< float >::mediumAquaMarine; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_mediumBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::mediumBlue",0,0) result = (ofColor_< float > *)&ofColor_< float >::mediumBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_mediumOrchid_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::mediumOrchid",0,0) result = (ofColor_< float > *)&ofColor_< float >::mediumOrchid; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_mediumPurple_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::mediumPurple",0,0) result = (ofColor_< float > *)&ofColor_< float >::mediumPurple; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_mediumSeaGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::mediumSeaGreen",0,0) result = (ofColor_< float > *)&ofColor_< float >::mediumSeaGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_mediumSlateBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::mediumSlateBlue",0,0) - result = (ofColor_< float > *)&ofColor_< float >::mediumSlateBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_mediumSpringGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::mediumSpringGreen",0,0) - result = (ofColor_< float > *)&ofColor_< float >::mediumSpringGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_mediumTurquoise_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::mediumTurquoise",0,0) - result = (ofColor_< float > *)&ofColor_< float >::mediumTurquoise; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_mediumVioletRed_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::mediumVioletRed",0,0) - result = (ofColor_< float > *)&ofColor_< float >::mediumVioletRed; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_midnightBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::midnightBlue",0,0) result = (ofColor_< float > *)&ofColor_< float >::midnightBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_mintCream_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::mintCream",0,0) result = (ofColor_< float > *)&ofColor_< float >::mintCream; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_mistyRose_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::mistyRose",0,0) result = (ofColor_< float > *)&ofColor_< float >::mistyRose; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_moccasin_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::moccasin",0,0) result = (ofColor_< float > *)&ofColor_< float >::moccasin; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_navajoWhite_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::navajoWhite",0,0) result = (ofColor_< float > *)&ofColor_< float >::navajoWhite; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_navy_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::navy",0,0) result = (ofColor_< float > *)&ofColor_< float >::navy; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_oldLace_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::oldLace",0,0) result = (ofColor_< float > *)&ofColor_< float >::oldLace; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_olive_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::olive",0,0) result = (ofColor_< float > *)&ofColor_< float >::olive; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_oliveDrab_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::oliveDrab",0,0) result = (ofColor_< float > *)&ofColor_< float >::oliveDrab; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_orange_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::orange",0,0) result = (ofColor_< float > *)&ofColor_< float >::orange; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_orangeRed_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::orangeRed",0,0) result = (ofColor_< float > *)&ofColor_< float >::orangeRed; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_orchid_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::orchid",0,0) result = (ofColor_< float > *)&ofColor_< float >::orchid; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_paleGoldenRod_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::paleGoldenRod",0,0) result = (ofColor_< float > *)&ofColor_< float >::paleGoldenRod; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_paleGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::paleGreen",0,0) result = (ofColor_< float > *)&ofColor_< float >::paleGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_paleTurquoise_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::paleTurquoise",0,0) result = (ofColor_< float > *)&ofColor_< float >::paleTurquoise; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_paleVioletRed_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::paleVioletRed",0,0) result = (ofColor_< float > *)&ofColor_< float >::paleVioletRed; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_papayaWhip_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::papayaWhip",0,0) result = (ofColor_< float > *)&ofColor_< float >::papayaWhip; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_peachPuff_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::peachPuff",0,0) result = (ofColor_< float > *)&ofColor_< float >::peachPuff; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_peru_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::peru",0,0) result = (ofColor_< float > *)&ofColor_< float >::peru; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_pink_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::pink",0,0) result = (ofColor_< float > *)&ofColor_< float >::pink; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_plum_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::plum",0,0) result = (ofColor_< float > *)&ofColor_< float >::plum; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_powderBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::powderBlue",0,0) result = (ofColor_< float > *)&ofColor_< float >::powderBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_purple_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::purple",0,0) result = (ofColor_< float > *)&ofColor_< float >::purple; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_rosyBrown_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::rosyBrown",0,0) result = (ofColor_< float > *)&ofColor_< float >::rosyBrown; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_royalBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::royalBlue",0,0) result = (ofColor_< float > *)&ofColor_< float >::royalBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_saddleBrown_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::saddleBrown",0,0) result = (ofColor_< float > *)&ofColor_< float >::saddleBrown; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_salmon_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::salmon",0,0) result = (ofColor_< float > *)&ofColor_< float >::salmon; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_sandyBrown_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::sandyBrown",0,0) result = (ofColor_< float > *)&ofColor_< float >::sandyBrown; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_seaGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::seaGreen",0,0) result = (ofColor_< float > *)&ofColor_< float >::seaGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_seaShell_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::seaShell",0,0) result = (ofColor_< float > *)&ofColor_< float >::seaShell; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_sienna_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::sienna",0,0) result = (ofColor_< float > *)&ofColor_< float >::sienna; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_silver_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::silver",0,0) result = (ofColor_< float > *)&ofColor_< float >::silver; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_skyBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::skyBlue",0,0) result = (ofColor_< float > *)&ofColor_< float >::skyBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_slateBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::slateBlue",0,0) result = (ofColor_< float > *)&ofColor_< float >::slateBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_slateGray_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::slateGray",0,0) result = (ofColor_< float > *)&ofColor_< float >::slateGray; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_slateGrey_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::slateGrey",0,0) result = (ofColor_< float > *)&ofColor_< float >::slateGrey; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_snow_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::snow",0,0) result = (ofColor_< float > *)&ofColor_< float >::snow; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_springGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::springGreen",0,0) result = (ofColor_< float > *)&ofColor_< float >::springGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_steelBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::steelBlue",0,0) result = (ofColor_< float > *)&ofColor_< float >::steelBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_blueSteel_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::blueSteel",0,0) result = (ofColor_< float > *)&ofColor_< float >::blueSteel; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_tan_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::tan",0,0) result = (ofColor_< float > *)&ofColor_< float >::tan; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_teal_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::teal",0,0) result = (ofColor_< float > *)&ofColor_< float >::teal; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_thistle_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::thistle",0,0) result = (ofColor_< float > *)&ofColor_< float >::thistle; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_tomato_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::tomato",0,0) result = (ofColor_< float > *)&ofColor_< float >::tomato; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_turquoise_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::turquoise",0,0) result = (ofColor_< float > *)&ofColor_< float >::turquoise; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_violet_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::violet",0,0) result = (ofColor_< float > *)&ofColor_< float >::violet; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_wheat_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::wheat",0,0) result = (ofColor_< float > *)&ofColor_< float >::wheat; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_whiteSmoke_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::whiteSmoke",0,0) result = (ofColor_< float > *)&ofColor_< float >::whiteSmoke; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_yellowGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *result = 0 ; - SWIG_check_num_args("ofColor_< float >::yellowGreen",0,0) result = (ofColor_< float > *)&ofColor_< float >::yellowGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_float_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_getR(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float result; SWIG_check_num_args("ofColor_< float >::getR",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::getR",1,"ofColor_< float > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_getR",1,SWIGTYPE_p_ofColor_T_float_t); } result = (float)ofColor__Sl_float_Sg__getR(arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_getG(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float result; SWIG_check_num_args("ofColor_< float >::getG",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::getG",1,"ofColor_< float > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_getG",1,SWIGTYPE_p_ofColor_T_float_t); } result = (float)ofColor__Sl_float_Sg__getG(arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_getB(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float result; SWIG_check_num_args("ofColor_< float >::getB",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::getB",1,"ofColor_< float > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_getB",1,SWIGTYPE_p_ofColor_T_float_t); } result = (float)ofColor__Sl_float_Sg__getB(arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_getA(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float result; SWIG_check_num_args("ofColor_< float >::getA",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::getA",1,"ofColor_< float > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_getA",1,SWIGTYPE_p_ofColor_T_float_t); } result = (float)ofColor__Sl_float_Sg__getA(arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_setR(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float arg2 ; SWIG_check_num_args("ofColor_< float >::setR",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::setR",1,"ofColor_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< float >::setR",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_setR",1,SWIGTYPE_p_ofColor_T_float_t); } arg2 = (float)lua_tonumber(L, 2); - ofColor__Sl_float_Sg__setR(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_setG(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float arg2 ; SWIG_check_num_args("ofColor_< float >::setG",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::setG",1,"ofColor_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< float >::setG",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_setG",1,SWIGTYPE_p_ofColor_T_float_t); } arg2 = (float)lua_tonumber(L, 2); - ofColor__Sl_float_Sg__setG(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_setB(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float arg2 ; SWIG_check_num_args("ofColor_< float >::setB",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::setB",1,"ofColor_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< float >::setB",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_setB",1,SWIGTYPE_p_ofColor_T_float_t); } arg2 = (float)lua_tonumber(L, 2); - ofColor__Sl_float_Sg__setB(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_setA(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float arg2 ; SWIG_check_num_args("ofColor_< float >::setA",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::setA",1,"ofColor_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< float >::setA",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_setA",1,SWIGTYPE_p_ofColor_T_float_t); } arg2 = (float)lua_tonumber(L, 2); - ofColor__Sl_float_Sg__setA(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor___tostring(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - char *result = 0 ; SWIG_check_num_args("ofColor_< float >::__str__",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::__str__",1,"ofColor_< float > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor___tostring",1,SWIGTYPE_p_ofColor_T_float_t); } - result = (char *)ofColor__Sl_float_Sg____str__(arg1); lua_pushstring(L,(const char *)result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_r_set(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float arg2 ; SWIG_check_num_args("ofColor_< float >::r",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::r",1,"ofColor_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< float >::r",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_r_set",1,SWIGTYPE_p_ofColor_T_float_t); } arg2 = (float)lua_tonumber(L, 2); - ofColor__Sl_float_Sg__r_set(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_r_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float result; SWIG_check_num_args("ofColor_< float >::r",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::r",1,"ofColor_< float > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_r_get",1,SWIGTYPE_p_ofColor_T_float_t); } result = (float)ofColor__Sl_float_Sg__r_get(arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_g_set(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float arg2 ; SWIG_check_num_args("ofColor_< float >::g",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::g",1,"ofColor_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< float >::g",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_g_set",1,SWIGTYPE_p_ofColor_T_float_t); } arg2 = (float)lua_tonumber(L, 2); - ofColor__Sl_float_Sg__g_set(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_g_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float result; SWIG_check_num_args("ofColor_< float >::g",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::g",1,"ofColor_< float > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_g_get",1,SWIGTYPE_p_ofColor_T_float_t); } result = (float)ofColor__Sl_float_Sg__g_get(arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_b_set(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float arg2 ; SWIG_check_num_args("ofColor_< float >::b",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::b",1,"ofColor_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< float >::b",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_b_set",1,SWIGTYPE_p_ofColor_T_float_t); } arg2 = (float)lua_tonumber(L, 2); - ofColor__Sl_float_Sg__b_set(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_b_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float result; SWIG_check_num_args("ofColor_< float >::b",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::b",1,"ofColor_< float > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_b_get",1,SWIGTYPE_p_ofColor_T_float_t); } result = (float)ofColor__Sl_float_Sg__b_get(arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_a_set(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float arg2 ; SWIG_check_num_args("ofColor_< float >::a",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::a",1,"ofColor_< float > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< float >::a",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_a_set",1,SWIGTYPE_p_ofColor_T_float_t); } arg2 = (float)lua_tonumber(L, 2); - ofColor__Sl_float_Sg__a_set(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FloatColor_a_get(lua_State* L) { int SWIG_arg = 0; ofColor_< float > *arg1 = (ofColor_< float > *) 0 ; - float result; SWIG_check_num_args("ofColor_< float >::a",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< float >::a",1,"ofColor_< float > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_float_t,0))){ - SWIG_fail_ptr("FloatColor_a_get",1,SWIGTYPE_p_ofColor_T_float_t); } result = (float)ofColor__Sl_float_Sg__a_get(arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_FloatColor(void *obj) { -ofColor_< float > *arg1 = (ofColor_< float > *) obj; -delete arg1; -} -static int _proxy__wrap_new_FloatColor(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_FloatColor); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_FloatColor_attributes[] = { - { "r", _wrap_FloatColor_r_get, _wrap_FloatColor_r_set }, - { "g", _wrap_FloatColor_g_get, _wrap_FloatColor_g_set }, - { "b", _wrap_FloatColor_b_get, _wrap_FloatColor_b_set }, - { "a", _wrap_FloatColor_a_get, _wrap_FloatColor_a_set }, - {0,0,0} -}; -static swig_lua_method swig_FloatColor_methods[]= { - { "set", _wrap_FloatColor_set}, - { "setHex", _wrap_FloatColor_setHex}, - { "setHue", _wrap_FloatColor_setHue}, - { "setHueAngle", _wrap_FloatColor_setHueAngle}, - { "setSaturation", _wrap_FloatColor_setSaturation}, - { "setBrightness", _wrap_FloatColor_setBrightness}, - { "setHsb", _wrap_FloatColor_setHsb}, - { "clamp", _wrap_FloatColor_clamp}, - { "invert", _wrap_FloatColor_invert}, - { "normalize", _wrap_FloatColor_normalize}, - { "lerp", _wrap_FloatColor_lerp}, - { "getClamped", _wrap_FloatColor_getClamped}, - { "getInverted", _wrap_FloatColor_getInverted}, - { "getNormalized", _wrap_FloatColor_getNormalized}, - { "getLerped", _wrap_FloatColor_getLerped}, - { "getHex", _wrap_FloatColor_getHex}, - { "getHue", _wrap_FloatColor_getHue}, - { "getHueAngle", _wrap_FloatColor_getHueAngle}, - { "getSaturation", _wrap_FloatColor_getSaturation}, - { "getBrightness", _wrap_FloatColor_getBrightness}, - { "getLightness", _wrap_FloatColor_getLightness}, - { "getHsb", _wrap_FloatColor_getHsb}, - { "__eq", _wrap_FloatColor___eq}, - { "__add", _wrap_FloatColor___add}, - { "__sub", _wrap_FloatColor___sub}, - { "__mul", _wrap_FloatColor___mul}, - { "__div", _wrap_FloatColor___div}, - { "getR", _wrap_FloatColor_getR}, - { "getG", _wrap_FloatColor_getG}, - { "getB", _wrap_FloatColor_getB}, - { "getA", _wrap_FloatColor_getA}, - { "setR", _wrap_FloatColor_setR}, - { "setG", _wrap_FloatColor_setG}, - { "setB", _wrap_FloatColor_setB}, - { "setA", _wrap_FloatColor_setA}, - { "__tostring", _wrap_FloatColor___tostring}, - {0,0} -}; -static swig_lua_method swig_FloatColor_meta[] = { - { "__eq", _wrap_FloatColor___eq}, - { "__add", _wrap_FloatColor___add}, - { "__sub", _wrap_FloatColor___sub}, - { "__mul", _wrap_FloatColor___mul}, - { "__div", _wrap_FloatColor___div}, - { "__tostring", _wrap_FloatColor___tostring}, - {0,0} -}; - -static swig_lua_attribute swig_FloatColor_Sf_SwigStatic_attributes[] = { - { "white", _wrap_FloatColor_white_get, SWIG_Lua_set_immutable }, - { "gray", _wrap_FloatColor_gray_get, SWIG_Lua_set_immutable }, - { "black", _wrap_FloatColor_black_get, SWIG_Lua_set_immutable }, - { "red", _wrap_FloatColor_red_get, SWIG_Lua_set_immutable }, - { "green", _wrap_FloatColor_green_get, SWIG_Lua_set_immutable }, - { "blue", _wrap_FloatColor_blue_get, SWIG_Lua_set_immutable }, - { "cyan", _wrap_FloatColor_cyan_get, SWIG_Lua_set_immutable }, - { "magenta", _wrap_FloatColor_magenta_get, SWIG_Lua_set_immutable }, - { "yellow", _wrap_FloatColor_yellow_get, SWIG_Lua_set_immutable }, - { "aliceBlue", _wrap_FloatColor_aliceBlue_get, SWIG_Lua_set_immutable }, - { "antiqueWhite", _wrap_FloatColor_antiqueWhite_get, SWIG_Lua_set_immutable }, - { "aqua", _wrap_FloatColor_aqua_get, SWIG_Lua_set_immutable }, - { "aquamarine", _wrap_FloatColor_aquamarine_get, SWIG_Lua_set_immutable }, - { "azure", _wrap_FloatColor_azure_get, SWIG_Lua_set_immutable }, - { "beige", _wrap_FloatColor_beige_get, SWIG_Lua_set_immutable }, - { "bisque", _wrap_FloatColor_bisque_get, SWIG_Lua_set_immutable }, - { "blanchedAlmond", _wrap_FloatColor_blanchedAlmond_get, SWIG_Lua_set_immutable }, - { "blueViolet", _wrap_FloatColor_blueViolet_get, SWIG_Lua_set_immutable }, - { "brown", _wrap_FloatColor_brown_get, SWIG_Lua_set_immutable }, - { "burlyWood", _wrap_FloatColor_burlyWood_get, SWIG_Lua_set_immutable }, - { "cadetBlue", _wrap_FloatColor_cadetBlue_get, SWIG_Lua_set_immutable }, - { "chartreuse", _wrap_FloatColor_chartreuse_get, SWIG_Lua_set_immutable }, - { "chocolate", _wrap_FloatColor_chocolate_get, SWIG_Lua_set_immutable }, - { "coral", _wrap_FloatColor_coral_get, SWIG_Lua_set_immutable }, - { "cornflowerBlue", _wrap_FloatColor_cornflowerBlue_get, SWIG_Lua_set_immutable }, - { "cornsilk", _wrap_FloatColor_cornsilk_get, SWIG_Lua_set_immutable }, - { "crimson", _wrap_FloatColor_crimson_get, SWIG_Lua_set_immutable }, - { "darkBlue", _wrap_FloatColor_darkBlue_get, SWIG_Lua_set_immutable }, - { "darkCyan", _wrap_FloatColor_darkCyan_get, SWIG_Lua_set_immutable }, - { "darkGoldenRod", _wrap_FloatColor_darkGoldenRod_get, SWIG_Lua_set_immutable }, - { "darkGray", _wrap_FloatColor_darkGray_get, SWIG_Lua_set_immutable }, - { "darkGrey", _wrap_FloatColor_darkGrey_get, SWIG_Lua_set_immutable }, - { "darkGreen", _wrap_FloatColor_darkGreen_get, SWIG_Lua_set_immutable }, - { "darkKhaki", _wrap_FloatColor_darkKhaki_get, SWIG_Lua_set_immutable }, - { "darkMagenta", _wrap_FloatColor_darkMagenta_get, SWIG_Lua_set_immutable }, - { "darkOliveGreen", _wrap_FloatColor_darkOliveGreen_get, SWIG_Lua_set_immutable }, - { "darkorange", _wrap_FloatColor_darkorange_get, SWIG_Lua_set_immutable }, - { "darkOrchid", _wrap_FloatColor_darkOrchid_get, SWIG_Lua_set_immutable }, - { "darkRed", _wrap_FloatColor_darkRed_get, SWIG_Lua_set_immutable }, - { "darkSalmon", _wrap_FloatColor_darkSalmon_get, SWIG_Lua_set_immutable }, - { "darkSeaGreen", _wrap_FloatColor_darkSeaGreen_get, SWIG_Lua_set_immutable }, - { "darkSlateBlue", _wrap_FloatColor_darkSlateBlue_get, SWIG_Lua_set_immutable }, - { "darkSlateGray", _wrap_FloatColor_darkSlateGray_get, SWIG_Lua_set_immutable }, - { "darkSlateGrey", _wrap_FloatColor_darkSlateGrey_get, SWIG_Lua_set_immutable }, - { "darkTurquoise", _wrap_FloatColor_darkTurquoise_get, SWIG_Lua_set_immutable }, - { "darkViolet", _wrap_FloatColor_darkViolet_get, SWIG_Lua_set_immutable }, - { "deepPink", _wrap_FloatColor_deepPink_get, SWIG_Lua_set_immutable }, - { "deepSkyBlue", _wrap_FloatColor_deepSkyBlue_get, SWIG_Lua_set_immutable }, - { "dimGray", _wrap_FloatColor_dimGray_get, SWIG_Lua_set_immutable }, - { "dimGrey", _wrap_FloatColor_dimGrey_get, SWIG_Lua_set_immutable }, - { "dodgerBlue", _wrap_FloatColor_dodgerBlue_get, SWIG_Lua_set_immutable }, - { "fireBrick", _wrap_FloatColor_fireBrick_get, SWIG_Lua_set_immutable }, - { "floralWhite", _wrap_FloatColor_floralWhite_get, SWIG_Lua_set_immutable }, - { "forestGreen", _wrap_FloatColor_forestGreen_get, SWIG_Lua_set_immutable }, - { "fuchsia", _wrap_FloatColor_fuchsia_get, SWIG_Lua_set_immutable }, - { "gainsboro", _wrap_FloatColor_gainsboro_get, SWIG_Lua_set_immutable }, - { "ghostWhite", _wrap_FloatColor_ghostWhite_get, SWIG_Lua_set_immutable }, - { "gold", _wrap_FloatColor_gold_get, SWIG_Lua_set_immutable }, - { "goldenRod", _wrap_FloatColor_goldenRod_get, SWIG_Lua_set_immutable }, - { "grey", _wrap_FloatColor_grey_get, SWIG_Lua_set_immutable }, - { "greenYellow", _wrap_FloatColor_greenYellow_get, SWIG_Lua_set_immutable }, - { "honeyDew", _wrap_FloatColor_honeyDew_get, SWIG_Lua_set_immutable }, - { "hotPink", _wrap_FloatColor_hotPink_get, SWIG_Lua_set_immutable }, - { "indianRed", _wrap_FloatColor_indianRed_get, SWIG_Lua_set_immutable }, - { "indigo", _wrap_FloatColor_indigo_get, SWIG_Lua_set_immutable }, - { "ivory", _wrap_FloatColor_ivory_get, SWIG_Lua_set_immutable }, - { "khaki", _wrap_FloatColor_khaki_get, SWIG_Lua_set_immutable }, - { "lavender", _wrap_FloatColor_lavender_get, SWIG_Lua_set_immutable }, - { "lavenderBlush", _wrap_FloatColor_lavenderBlush_get, SWIG_Lua_set_immutable }, - { "lawnGreen", _wrap_FloatColor_lawnGreen_get, SWIG_Lua_set_immutable }, - { "lemonChiffon", _wrap_FloatColor_lemonChiffon_get, SWIG_Lua_set_immutable }, - { "lightBlue", _wrap_FloatColor_lightBlue_get, SWIG_Lua_set_immutable }, - { "lightCoral", _wrap_FloatColor_lightCoral_get, SWIG_Lua_set_immutable }, - { "lightCyan", _wrap_FloatColor_lightCyan_get, SWIG_Lua_set_immutable }, - { "lightGoldenRodYellow", _wrap_FloatColor_lightGoldenRodYellow_get, SWIG_Lua_set_immutable }, - { "lightGray", _wrap_FloatColor_lightGray_get, SWIG_Lua_set_immutable }, - { "lightGrey", _wrap_FloatColor_lightGrey_get, SWIG_Lua_set_immutable }, - { "lightGreen", _wrap_FloatColor_lightGreen_get, SWIG_Lua_set_immutable }, - { "lightPink", _wrap_FloatColor_lightPink_get, SWIG_Lua_set_immutable }, - { "lightSalmon", _wrap_FloatColor_lightSalmon_get, SWIG_Lua_set_immutable }, - { "lightSeaGreen", _wrap_FloatColor_lightSeaGreen_get, SWIG_Lua_set_immutable }, - { "lightSkyBlue", _wrap_FloatColor_lightSkyBlue_get, SWIG_Lua_set_immutable }, - { "lightSlateGray", _wrap_FloatColor_lightSlateGray_get, SWIG_Lua_set_immutable }, - { "lightSlateGrey", _wrap_FloatColor_lightSlateGrey_get, SWIG_Lua_set_immutable }, - { "lightSteelBlue", _wrap_FloatColor_lightSteelBlue_get, SWIG_Lua_set_immutable }, - { "lightYellow", _wrap_FloatColor_lightYellow_get, SWIG_Lua_set_immutable }, - { "lime", _wrap_FloatColor_lime_get, SWIG_Lua_set_immutable }, - { "limeGreen", _wrap_FloatColor_limeGreen_get, SWIG_Lua_set_immutable }, - { "linen", _wrap_FloatColor_linen_get, SWIG_Lua_set_immutable }, - { "maroon", _wrap_FloatColor_maroon_get, SWIG_Lua_set_immutable }, - { "mediumAquaMarine", _wrap_FloatColor_mediumAquaMarine_get, SWIG_Lua_set_immutable }, - { "mediumBlue", _wrap_FloatColor_mediumBlue_get, SWIG_Lua_set_immutable }, - { "mediumOrchid", _wrap_FloatColor_mediumOrchid_get, SWIG_Lua_set_immutable }, - { "mediumPurple", _wrap_FloatColor_mediumPurple_get, SWIG_Lua_set_immutable }, - { "mediumSeaGreen", _wrap_FloatColor_mediumSeaGreen_get, SWIG_Lua_set_immutable }, - { "mediumSlateBlue", _wrap_FloatColor_mediumSlateBlue_get, SWIG_Lua_set_immutable }, - { "mediumSpringGreen", _wrap_FloatColor_mediumSpringGreen_get, SWIG_Lua_set_immutable }, - { "mediumTurquoise", _wrap_FloatColor_mediumTurquoise_get, SWIG_Lua_set_immutable }, - { "mediumVioletRed", _wrap_FloatColor_mediumVioletRed_get, SWIG_Lua_set_immutable }, - { "midnightBlue", _wrap_FloatColor_midnightBlue_get, SWIG_Lua_set_immutable }, - { "mintCream", _wrap_FloatColor_mintCream_get, SWIG_Lua_set_immutable }, - { "mistyRose", _wrap_FloatColor_mistyRose_get, SWIG_Lua_set_immutable }, - { "moccasin", _wrap_FloatColor_moccasin_get, SWIG_Lua_set_immutable }, - { "navajoWhite", _wrap_FloatColor_navajoWhite_get, SWIG_Lua_set_immutable }, - { "navy", _wrap_FloatColor_navy_get, SWIG_Lua_set_immutable }, - { "oldLace", _wrap_FloatColor_oldLace_get, SWIG_Lua_set_immutable }, - { "olive", _wrap_FloatColor_olive_get, SWIG_Lua_set_immutable }, - { "oliveDrab", _wrap_FloatColor_oliveDrab_get, SWIG_Lua_set_immutable }, - { "orange", _wrap_FloatColor_orange_get, SWIG_Lua_set_immutable }, - { "orangeRed", _wrap_FloatColor_orangeRed_get, SWIG_Lua_set_immutable }, - { "orchid", _wrap_FloatColor_orchid_get, SWIG_Lua_set_immutable }, - { "paleGoldenRod", _wrap_FloatColor_paleGoldenRod_get, SWIG_Lua_set_immutable }, - { "paleGreen", _wrap_FloatColor_paleGreen_get, SWIG_Lua_set_immutable }, - { "paleTurquoise", _wrap_FloatColor_paleTurquoise_get, SWIG_Lua_set_immutable }, - { "paleVioletRed", _wrap_FloatColor_paleVioletRed_get, SWIG_Lua_set_immutable }, - { "papayaWhip", _wrap_FloatColor_papayaWhip_get, SWIG_Lua_set_immutable }, - { "peachPuff", _wrap_FloatColor_peachPuff_get, SWIG_Lua_set_immutable }, - { "peru", _wrap_FloatColor_peru_get, SWIG_Lua_set_immutable }, - { "pink", _wrap_FloatColor_pink_get, SWIG_Lua_set_immutable }, - { "plum", _wrap_FloatColor_plum_get, SWIG_Lua_set_immutable }, - { "powderBlue", _wrap_FloatColor_powderBlue_get, SWIG_Lua_set_immutable }, - { "purple", _wrap_FloatColor_purple_get, SWIG_Lua_set_immutable }, - { "rosyBrown", _wrap_FloatColor_rosyBrown_get, SWIG_Lua_set_immutable }, - { "royalBlue", _wrap_FloatColor_royalBlue_get, SWIG_Lua_set_immutable }, - { "saddleBrown", _wrap_FloatColor_saddleBrown_get, SWIG_Lua_set_immutable }, - { "salmon", _wrap_FloatColor_salmon_get, SWIG_Lua_set_immutable }, - { "sandyBrown", _wrap_FloatColor_sandyBrown_get, SWIG_Lua_set_immutable }, - { "seaGreen", _wrap_FloatColor_seaGreen_get, SWIG_Lua_set_immutable }, - { "seaShell", _wrap_FloatColor_seaShell_get, SWIG_Lua_set_immutable }, - { "sienna", _wrap_FloatColor_sienna_get, SWIG_Lua_set_immutable }, - { "silver", _wrap_FloatColor_silver_get, SWIG_Lua_set_immutable }, - { "skyBlue", _wrap_FloatColor_skyBlue_get, SWIG_Lua_set_immutable }, - { "slateBlue", _wrap_FloatColor_slateBlue_get, SWIG_Lua_set_immutable }, - { "slateGray", _wrap_FloatColor_slateGray_get, SWIG_Lua_set_immutable }, - { "slateGrey", _wrap_FloatColor_slateGrey_get, SWIG_Lua_set_immutable }, - { "snow", _wrap_FloatColor_snow_get, SWIG_Lua_set_immutable }, - { "springGreen", _wrap_FloatColor_springGreen_get, SWIG_Lua_set_immutable }, - { "steelBlue", _wrap_FloatColor_steelBlue_get, SWIG_Lua_set_immutable }, - { "blueSteel", _wrap_FloatColor_blueSteel_get, SWIG_Lua_set_immutable }, - { "tan", _wrap_FloatColor_tan_get, SWIG_Lua_set_immutable }, - { "teal", _wrap_FloatColor_teal_get, SWIG_Lua_set_immutable }, - { "thistle", _wrap_FloatColor_thistle_get, SWIG_Lua_set_immutable }, - { "tomato", _wrap_FloatColor_tomato_get, SWIG_Lua_set_immutable }, - { "turquoise", _wrap_FloatColor_turquoise_get, SWIG_Lua_set_immutable }, - { "violet", _wrap_FloatColor_violet_get, SWIG_Lua_set_immutable }, - { "wheat", _wrap_FloatColor_wheat_get, SWIG_Lua_set_immutable }, - { "whiteSmoke", _wrap_FloatColor_whiteSmoke_get, SWIG_Lua_set_immutable }, - { "yellowGreen", _wrap_FloatColor_yellowGreen_get, SWIG_Lua_set_immutable }, - {0,0,0} -}; -static swig_lua_const_info swig_FloatColor_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_FloatColor_Sf_SwigStatic_methods[]= { - { "fromHsb", _wrap_FloatColor_fromHsb}, - { "fromHex", _wrap_FloatColor_fromHex}, - { "limit", _wrap_FloatColor_limit}, - {0,0} -}; -static swig_lua_class* swig_FloatColor_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_FloatColor_Sf_SwigStatic = { - "FloatColor", - swig_FloatColor_Sf_SwigStatic_methods, - swig_FloatColor_Sf_SwigStatic_attributes, - swig_FloatColor_Sf_SwigStatic_constants, - swig_FloatColor_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_FloatColor_bases[] = {0}; -static const char *swig_FloatColor_base_names[] = {0}; -static swig_lua_class _wrap_class_FloatColor = { "FloatColor", "FloatColor", &SWIGTYPE_p_ofColor_T_float_t,_proxy__wrap_new_FloatColor, swig_delete_FloatColor, swig_FloatColor_methods, swig_FloatColor_attributes, &swig_FloatColor_Sf_SwigStatic, swig_FloatColor_meta, swig_FloatColor_bases, swig_FloatColor_base_names }; - -static int _wrap_new_ShortColor__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::ofColor_",0,0) - result = (ofColor_< unsigned short > *)new ofColor_< unsigned short >(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_ShortColor__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - ofColor_< unsigned short > *result = 0 ; SWIG_check_num_args("ofColor_< unsigned short >::ofColor_",4,4) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::ofColor_",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::ofColor_",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< unsigned short >::ofColor_",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofColor_< unsigned short >::ofColor_",4,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - result = (ofColor_< unsigned short > *)new ofColor_< unsigned short >(arg1,arg2,arg3,arg4); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_ShortColor__SWIG_2(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; - ofColor_< unsigned short > *result = 0 ; SWIG_check_num_args("ofColor_< unsigned short >::ofColor_",3,3) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::ofColor_",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::ofColor_",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< unsigned short >::ofColor_",3,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - result = (ofColor_< unsigned short > *)new ofColor_< unsigned short >(arg1,arg2,arg3); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_ShortColor__SWIG_3(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; - ofColor_< unsigned short > *result = 0 ; SWIG_check_num_args("ofColor_< unsigned short >::ofColor_",2,2) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::ofColor_",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::ofColor_",2,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); result = (ofColor_< unsigned short > *)new ofColor_< unsigned short >(arg1,arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_ShortColor__SWIG_4(lua_State* L) { int SWIG_arg = 0; float arg1 ; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::ofColor_",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::ofColor_",1,"float"); arg1 = (float)lua_tonumber(L, 1); - result = (ofColor_< unsigned short > *)new ofColor_< unsigned short >(arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_ShortColor__SWIG_5(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *arg1 = 0 ; float arg2 ; - ofColor_< unsigned short > *result = 0 ; SWIG_check_num_args("ofColor_< unsigned short >::ofColor_",2,2) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::ofColor_",1,"ofColor_< unsigned short > const &"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::ofColor_",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("new_ShortColor",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } arg2 = (float)lua_tonumber(L, 2); - result = (ofColor_< unsigned short > *)new ofColor_< unsigned short >((ofColor_< unsigned short > const &)*arg1,arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_ShortColor(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_ShortColor__SWIG_0(L);} if (argc == 1) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { - return _wrap_new_ShortColor__SWIG_4(L);} } if (argc == 2) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_new_ShortColor__SWIG_5(L);} } } if (argc == 2) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { - _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_new_ShortColor__SWIG_3(L);} } } if (argc == 3) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_new_ShortColor__SWIG_2(L);} } } } if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_new_ShortColor__SWIG_1(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_ShortColor'\n" " Possible C/C++ prototypes are:\n" - " ofColor_< unsigned short >::ofColor_()\n" " ofColor_< unsigned short >::ofColor_(float,float,float,float)\n" - " ofColor_< unsigned short >::ofColor_(float,float,float)\n" " ofColor_< unsigned short >::ofColor_(float,float)\n" - " ofColor_< unsigned short >::ofColor_(float)\n" - " ofColor_< unsigned short >::ofColor_(ofColor_< unsigned short > const &,float)\n"); lua_error(L);return 0; } -static int _wrap_ShortColor_fromHsb__SWIG_0(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; - float arg4 ; ofColor_< unsigned short > result; SWIG_check_num_args("ofColor_< unsigned short >::fromHsb",4,4) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::fromHsb",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::fromHsb",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< unsigned short >::fromHsb",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofColor_< unsigned short >::fromHsb",4,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - result = ofColor_< unsigned short >::SWIGTEMPLATEDISAMBIGUATOR fromHsb(arg1,arg2,arg3,arg4); { - ofColor_< unsigned short > * resultptr = new ofColor_< unsigned short >((const ofColor_< unsigned short > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_short_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_fromHsb__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; - ofColor_< unsigned short > result; SWIG_check_num_args("ofColor_< unsigned short >::fromHsb",3,3) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::fromHsb",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::fromHsb",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< unsigned short >::fromHsb",3,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - result = ofColor_< unsigned short >::SWIGTEMPLATEDISAMBIGUATOR fromHsb(arg1,arg2,arg3); { - ofColor_< unsigned short > * resultptr = new ofColor_< unsigned short >((const ofColor_< unsigned short > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_short_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_fromHsb(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_ShortColor_fromHsb__SWIG_1(L);} } } } if (argc == 4) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { - _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { - return _wrap_ShortColor_fromHsb__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortColor_fromHsb'\n" " Possible C/C++ prototypes are:\n" - " ofColor_< unsigned short >::fromHsb(float,float,float,float)\n" - " ofColor_< unsigned short >::fromHsb(float,float,float)\n"); lua_error(L);return 0; } -static int _wrap_ShortColor_fromHex__SWIG_0(lua_State* L) { int SWIG_arg = 0; int arg1 ; float arg2 ; - ofColor_< unsigned short > result; SWIG_check_num_args("ofColor_< unsigned short >::fromHex",2,2) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::fromHex",1,"int"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::fromHex",2,"float"); arg1 = (int)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); result = ofColor_< unsigned short >::SWIGTEMPLATEDISAMBIGUATOR fromHex(arg1,arg2); { - ofColor_< unsigned short > * resultptr = new ofColor_< unsigned short >((const ofColor_< unsigned short > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_short_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_fromHex__SWIG_1(lua_State* L) { int SWIG_arg = 0; int arg1 ; ofColor_< unsigned short > result; - SWIG_check_num_args("ofColor_< unsigned short >::fromHex",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::fromHex",1,"int"); arg1 = (int)lua_tonumber(L, 1); - result = ofColor_< unsigned short >::SWIGTEMPLATEDISAMBIGUATOR fromHex(arg1); { - ofColor_< unsigned short > * resultptr = new ofColor_< unsigned short >((const ofColor_< unsigned short > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_short_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_fromHex(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_ShortColor_fromHex__SWIG_1(L);} } if (argc == 2) { - int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_ShortColor_fromHex__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortColor_fromHex'\n" " Possible C/C++ prototypes are:\n" - " ofColor_< unsigned short >::fromHex(int,float)\n" " ofColor_< unsigned short >::fromHex(int)\n"); - lua_error(L);return 0; } -static int _wrap_ShortColor_set__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; float arg2 ; float arg3 ; float arg4 ; float arg5 ; - SWIG_check_num_args("ofColor_< unsigned short >::set",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::set",1,"ofColor_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< unsigned short >::set",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofColor_< unsigned short >::set",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofColor_< unsigned short >::set",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_set",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - (arg1)->set(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_set__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; float arg2 ; float arg3 ; float arg4 ; - SWIG_check_num_args("ofColor_< unsigned short >::set",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::set",1,"ofColor_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< unsigned short >::set",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofColor_< unsigned short >::set",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_set",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); (arg1)->set(arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_set__SWIG_2(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; float arg2 ; float arg3 ; - SWIG_check_num_args("ofColor_< unsigned short >::set",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::set",1,"ofColor_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< unsigned short >::set",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_set",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->set(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortColor_set__SWIG_3(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; float arg2 ; - SWIG_check_num_args("ofColor_< unsigned short >::set",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::set",1,"ofColor_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::set",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_set",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->set(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_set__SWIG_4(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; ofColor_< unsigned short > *arg2 = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::set",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::set",1,"ofColor_< unsigned short > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::set",2,"ofColor_< unsigned short > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_set",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_set",2,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - (arg1)->set((ofColor_< unsigned short > const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortColor_set(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_ShortColor_set__SWIG_4(L);} } } if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_ShortColor_set__SWIG_3(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_ShortColor_set__SWIG_2(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_ShortColor_set__SWIG_1(L);} } } } } - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_ShortColor_set__SWIG_0(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortColor_set'\n" " Possible C/C++ prototypes are:\n" - " ofColor_< unsigned short >::set(float,float,float,float)\n" " ofColor_< unsigned short >::set(float,float,float)\n" - " ofColor_< unsigned short >::set(float,float)\n" " ofColor_< unsigned short >::set(float)\n" - " ofColor_< unsigned short >::set(ofColor_< unsigned short > const &)\n"); lua_error(L);return 0; } -static int _wrap_ShortColor_setHex__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; int arg2 ; float arg3 ; - SWIG_check_num_args("ofColor_< unsigned short >::setHex",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::setHex",1,"ofColor_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::setHex",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< unsigned short >::setHex",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_setHex",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->setHex(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortColor_setHex__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; int arg2 ; - SWIG_check_num_args("ofColor_< unsigned short >::setHex",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::setHex",1,"ofColor_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::setHex",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_setHex",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->setHex(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_setHex(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_ShortColor_setHex__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_ShortColor_setHex__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortColor_setHex'\n" " Possible C/C++ prototypes are:\n" - " ofColor_< unsigned short >::setHex(int,float)\n" " ofColor_< unsigned short >::setHex(int)\n"); - lua_error(L);return 0; } -static int _wrap_ShortColor_setHue(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; float arg2 ; - SWIG_check_num_args("ofColor_< unsigned short >::setHue",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::setHue",1,"ofColor_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::setHue",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_setHue",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setHue(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_setHueAngle(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; float arg2 ; - SWIG_check_num_args("ofColor_< unsigned short >::setHueAngle",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::setHueAngle",1,"ofColor_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::setHueAngle",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_setHueAngle",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setHueAngle(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_setSaturation(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; float arg2 ; - SWIG_check_num_args("ofColor_< unsigned short >::setSaturation",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::setSaturation",1,"ofColor_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::setSaturation",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_setSaturation",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setSaturation(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_setBrightness(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; float arg2 ; - SWIG_check_num_args("ofColor_< unsigned short >::setBrightness",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::setBrightness",1,"ofColor_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::setBrightness",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_setBrightness",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setBrightness(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_setHsb__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; float arg2 ; float arg3 ; float arg4 ; float arg5 ; - SWIG_check_num_args("ofColor_< unsigned short >::setHsb",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::setHsb",1,"ofColor_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::setHsb",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< unsigned short >::setHsb",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofColor_< unsigned short >::setHsb",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofColor_< unsigned short >::setHsb",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_setHsb",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - (arg1)->setHsb(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_setHsb__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; float arg2 ; float arg3 ; float arg4 ; - SWIG_check_num_args("ofColor_< unsigned short >::setHsb",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::setHsb",1,"ofColor_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::setHsb",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< unsigned short >::setHsb",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofColor_< unsigned short >::setHsb",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_setHsb",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); (arg1)->setHsb(arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_setHsb(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 4) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_ShortColor_setHsb__SWIG_1(L);} } } } } - if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_ShortColor_setHsb__SWIG_0(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortColor_setHsb'\n" " Possible C/C++ prototypes are:\n" - " ofColor_< unsigned short >::setHsb(float,float,float,float)\n" - " ofColor_< unsigned short >::setHsb(float,float,float)\n"); lua_error(L);return 0; } -static int _wrap_ShortColor_clamp(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::clamp",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::clamp",1,"ofColor_< unsigned short > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_clamp",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - result = (ofColor_< unsigned short > *) &(arg1)->clamp(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_invert(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::invert",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::invert",1,"ofColor_< unsigned short > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_invert",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - result = (ofColor_< unsigned short > *) &(arg1)->invert(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_normalize(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::normalize",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::normalize",1,"ofColor_< unsigned short > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_normalize",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - result = (ofColor_< unsigned short > *) &(arg1)->normalize(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_lerp(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; ofColor_< unsigned short > *arg2 = 0 ; float arg3 ; - ofColor_< unsigned short > *result = 0 ; SWIG_check_num_args("ofColor_< unsigned short >::lerp",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::lerp",1,"ofColor_< unsigned short > *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::lerp",2,"ofColor_< unsigned short > const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< unsigned short >::lerp",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_lerp",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_lerp",2,SWIGTYPE_p_ofColor_T_unsigned_short_t); } arg3 = (float)lua_tonumber(L, 3); - result = (ofColor_< unsigned short > *) &(arg1)->lerp((ofColor_< unsigned short > const &)*arg2,arg3); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_getClamped(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; ofColor_< unsigned short > result; - SWIG_check_num_args("ofColor_< unsigned short >::getClamped",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::getClamped",1,"ofColor_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_getClamped",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - result = ((ofColor_< unsigned short > const *)arg1)->getClamped(); { - ofColor_< unsigned short > * resultptr = new ofColor_< unsigned short >((const ofColor_< unsigned short > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_short_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_getInverted(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; ofColor_< unsigned short > result; - SWIG_check_num_args("ofColor_< unsigned short >::getInverted",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::getInverted",1,"ofColor_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_getInverted",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - result = ((ofColor_< unsigned short > const *)arg1)->getInverted(); { - ofColor_< unsigned short > * resultptr = new ofColor_< unsigned short >((const ofColor_< unsigned short > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_short_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_getNormalized(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; ofColor_< unsigned short > result; - SWIG_check_num_args("ofColor_< unsigned short >::getNormalized",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::getNormalized",1,"ofColor_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_getNormalized",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - result = ((ofColor_< unsigned short > const *)arg1)->getNormalized(); { - ofColor_< unsigned short > * resultptr = new ofColor_< unsigned short >((const ofColor_< unsigned short > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_short_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_getLerped(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; ofColor_< unsigned short > *arg2 = 0 ; float arg3 ; - ofColor_< unsigned short > result; SWIG_check_num_args("ofColor_< unsigned short >::getLerped",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::getLerped",1,"ofColor_< unsigned short > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::getLerped",2,"ofColor_< unsigned short > const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofColor_< unsigned short >::getLerped",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_getLerped",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_getLerped",2,SWIGTYPE_p_ofColor_T_unsigned_short_t); } arg3 = (float)lua_tonumber(L, 3); - result = ((ofColor_< unsigned short > const *)arg1)->getLerped((ofColor_< unsigned short > const &)*arg2,arg3); { - ofColor_< unsigned short > * resultptr = new ofColor_< unsigned short >((const ofColor_< unsigned short > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_short_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_getHex(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; int result; - SWIG_check_num_args("ofColor_< unsigned short >::getHex",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::getHex",1,"ofColor_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_getHex",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - result = (int)((ofColor_< unsigned short > const *)arg1)->getHex(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_getHue(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; float result; - SWIG_check_num_args("ofColor_< unsigned short >::getHue",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::getHue",1,"ofColor_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_getHue",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - result = (float)((ofColor_< unsigned short > const *)arg1)->getHue(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_getHueAngle(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; float result; - SWIG_check_num_args("ofColor_< unsigned short >::getHueAngle",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::getHueAngle",1,"ofColor_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_getHueAngle",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - result = (float)((ofColor_< unsigned short > const *)arg1)->getHueAngle(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_getSaturation(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; float result; - SWIG_check_num_args("ofColor_< unsigned short >::getSaturation",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::getSaturation",1,"ofColor_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_getSaturation",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - result = (float)((ofColor_< unsigned short > const *)arg1)->getSaturation(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_getBrightness(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; float result; - SWIG_check_num_args("ofColor_< unsigned short >::getBrightness",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::getBrightness",1,"ofColor_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_getBrightness",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - result = (float)((ofColor_< unsigned short > const *)arg1)->getBrightness(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_getLightness(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; float result; - SWIG_check_num_args("ofColor_< unsigned short >::getLightness",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::getLightness",1,"ofColor_< unsigned short > const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_getLightness",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - result = (float)((ofColor_< unsigned short > const *)arg1)->getLightness(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_getHsb(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; float *arg2 = 0 ; float *arg3 = 0 ; float *arg4 = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::getHsb",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::getHsb",1,"ofColor_< unsigned short > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::getHsb",2,"float &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofColor_< unsigned short >::getHsb",3,"float &"); - if(!lua_isuserdata(L,4)) SWIG_fail_arg("ofColor_< unsigned short >::getHsb",4,"float &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_getHsb",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("ShortColor_getHsb",2,SWIGTYPE_p_float); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("ShortColor_getHsb",3,SWIGTYPE_p_float); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,4,(void**)&arg4,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("ShortColor_getHsb",4,SWIGTYPE_p_float); } - ((ofColor_< unsigned short > const *)arg1)->getHsb(*arg2,*arg3,*arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_ShortColor_limit(lua_State* L) { int SWIG_arg = 0; float result; - SWIG_check_num_args("ofColor_< unsigned short >::limit",0,0) - result = (float)ofColor_< unsigned short >::SWIGTEMPLATEDISAMBIGUATOR limit(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor___eq(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; ofColor_< unsigned short > *arg2 = 0 ; bool result; - SWIG_check_num_args("ofColor_< unsigned short >::operator ==",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::operator ==",1,"ofColor_< unsigned short > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::operator ==",2,"ofColor_< unsigned short > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor___eq",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor___eq",2,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - result = (bool)((ofColor_< unsigned short > const *)arg1)->operator ==((ofColor_< unsigned short > const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor___add__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; ofColor_< unsigned short > *arg2 = 0 ; - ofColor_< unsigned short > result; SWIG_check_num_args("ofColor_< unsigned short >::operator +",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::operator +",1,"ofColor_< unsigned short > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::operator +",2,"ofColor_< unsigned short > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor___add",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor___add",2,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - result = ((ofColor_< unsigned short > const *)arg1)->operator +((ofColor_< unsigned short > const &)*arg2); { - ofColor_< unsigned short > * resultptr = new ofColor_< unsigned short >((const ofColor_< unsigned short > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_short_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor___add__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; float *arg2 = 0 ; float temp2 ; - ofColor_< unsigned short > result; SWIG_check_num_args("ofColor_< unsigned short >::operator +",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::operator +",1,"ofColor_< unsigned short > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::operator +",2,"float const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor___add",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } temp2=(float)lua_tonumber(L,2); arg2=&temp2; - result = ((ofColor_< unsigned short > const *)arg1)->operator +((float const &)*arg2); { - ofColor_< unsigned short > * resultptr = new ofColor_< unsigned short >((const ofColor_< unsigned short > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_short_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor___add(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_ShortColor___add__SWIG_0(L);} } } if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_ShortColor___add__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortColor___add'\n" " Possible C/C++ prototypes are:\n" - " ofColor_< unsigned short >::operator +(ofColor_< unsigned short > const &) const\n" - " ofColor_< unsigned short >::operator +(float const &) const\n"); lua_error(L);return 0; } -static int _wrap_ShortColor___sub__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; ofColor_< unsigned short > *arg2 = 0 ; - ofColor_< unsigned short > result; SWIG_check_num_args("ofColor_< unsigned short >::operator -",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::operator -",1,"ofColor_< unsigned short > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::operator -",2,"ofColor_< unsigned short > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor___sub",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor___sub",2,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - result = ((ofColor_< unsigned short > const *)arg1)->operator -((ofColor_< unsigned short > const &)*arg2); { - ofColor_< unsigned short > * resultptr = new ofColor_< unsigned short >((const ofColor_< unsigned short > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_short_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor___sub__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; float *arg2 = 0 ; float temp2 ; - ofColor_< unsigned short > result; SWIG_check_num_args("ofColor_< unsigned short >::operator -",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::operator -",1,"ofColor_< unsigned short > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::operator -",2,"float const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor___sub",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } temp2=(float)lua_tonumber(L,2); arg2=&temp2; - result = ((ofColor_< unsigned short > const *)arg1)->operator -((float const &)*arg2); { - ofColor_< unsigned short > * resultptr = new ofColor_< unsigned short >((const ofColor_< unsigned short > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_short_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor___sub(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_ShortColor___sub__SWIG_0(L);} } } if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_ShortColor___sub__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortColor___sub'\n" " Possible C/C++ prototypes are:\n" - " ofColor_< unsigned short >::operator -(ofColor_< unsigned short > const &) const\n" - " ofColor_< unsigned short >::operator -(float const &) const\n"); lua_error(L);return 0; } -static int _wrap_ShortColor___mul__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; ofColor_< unsigned short > *arg2 = 0 ; - ofColor_< unsigned short > result; SWIG_check_num_args("ofColor_< unsigned short >::operator *",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::operator *",1,"ofColor_< unsigned short > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::operator *",2,"ofColor_< unsigned short > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor___mul",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor___mul",2,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - result = ((ofColor_< unsigned short > const *)arg1)->operator *((ofColor_< unsigned short > const &)*arg2); { - ofColor_< unsigned short > * resultptr = new ofColor_< unsigned short >((const ofColor_< unsigned short > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_short_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor___mul__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; float *arg2 = 0 ; float temp2 ; - ofColor_< unsigned short > result; SWIG_check_num_args("ofColor_< unsigned short >::operator *",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::operator *",1,"ofColor_< unsigned short > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::operator *",2,"float const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor___mul",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } temp2=(float)lua_tonumber(L,2); arg2=&temp2; - result = ((ofColor_< unsigned short > const *)arg1)->operator *((float const &)*arg2); { - ofColor_< unsigned short > * resultptr = new ofColor_< unsigned short >((const ofColor_< unsigned short > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_short_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor___mul(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_ShortColor___mul__SWIG_0(L);} } } if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_ShortColor___mul__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortColor___mul'\n" " Possible C/C++ prototypes are:\n" - " ofColor_< unsigned short >::operator *(ofColor_< unsigned short > const &) const\n" - " ofColor_< unsigned short >::operator *(float const &) const\n"); lua_error(L);return 0; } -static int _wrap_ShortColor___div__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; ofColor_< unsigned short > *arg2 = 0 ; - ofColor_< unsigned short > result; SWIG_check_num_args("ofColor_< unsigned short >::operator /",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::operator /",1,"ofColor_< unsigned short > const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::operator /",2,"ofColor_< unsigned short > const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor___div",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor___div",2,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - result = ((ofColor_< unsigned short > const *)arg1)->operator /((ofColor_< unsigned short > const &)*arg2); { - ofColor_< unsigned short > * resultptr = new ofColor_< unsigned short >((const ofColor_< unsigned short > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_short_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor___div__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; float *arg2 = 0 ; float temp2 ; - ofColor_< unsigned short > result; SWIG_check_num_args("ofColor_< unsigned short >::operator /",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::operator /",1,"ofColor_< unsigned short > const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::operator /",2,"float const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor___div",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } temp2=(float)lua_tonumber(L,2); arg2=&temp2; - result = ((ofColor_< unsigned short > const *)arg1)->operator /((float const &)*arg2); { - ofColor_< unsigned short > * resultptr = new ofColor_< unsigned short >((const ofColor_< unsigned short > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofColor_T_unsigned_short_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor___div(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_ShortColor___div__SWIG_0(L);} } } if (argc == 2) { int _v; { - void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofColor_T_unsigned_short_t, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_ShortColor___div__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'ShortColor___div'\n" " Possible C/C++ prototypes are:\n" - " ofColor_< unsigned short >::operator /(ofColor_< unsigned short > const &) const\n" - " ofColor_< unsigned short >::operator /(float const &) const\n"); lua_error(L);return 0; } -static int _wrap_ShortColor_white_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::white",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::white; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_gray_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::gray",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::gray; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_black_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::black",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::black; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_red_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::red",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::red; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_green_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::green",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::green; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_blue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::blue",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::blue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_cyan_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::cyan",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::cyan; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_magenta_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::magenta",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::magenta; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_yellow_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::yellow",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::yellow; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_aliceBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::aliceBlue",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::aliceBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_antiqueWhite_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::antiqueWhite",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::antiqueWhite; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_aqua_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::aqua",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::aqua; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_aquamarine_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::aquamarine",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::aquamarine; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_azure_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::azure",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::azure; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_beige_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::beige",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::beige; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_bisque_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::bisque",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::bisque; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_blanchedAlmond_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::blanchedAlmond",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::blanchedAlmond; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_blueViolet_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::blueViolet",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::blueViolet; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_brown_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::brown",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::brown; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_burlyWood_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::burlyWood",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::burlyWood; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_cadetBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::cadetBlue",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::cadetBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_chartreuse_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::chartreuse",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::chartreuse; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_chocolate_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::chocolate",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::chocolate; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_coral_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::coral",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::coral; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_cornflowerBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::cornflowerBlue",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::cornflowerBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_cornsilk_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::cornsilk",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::cornsilk; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_crimson_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::crimson",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::crimson; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_darkBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::darkBlue",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::darkBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_darkCyan_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::darkCyan",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::darkCyan; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_darkGoldenRod_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::darkGoldenRod",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::darkGoldenRod; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_darkGray_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::darkGray",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::darkGray; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_darkGrey_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::darkGrey",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::darkGrey; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_darkGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::darkGreen",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::darkGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_darkKhaki_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::darkKhaki",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::darkKhaki; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_darkMagenta_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::darkMagenta",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::darkMagenta; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_darkOliveGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::darkOliveGreen",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::darkOliveGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_darkorange_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::darkorange",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::darkorange; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_darkOrchid_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::darkOrchid",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::darkOrchid; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_darkRed_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::darkRed",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::darkRed; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_darkSalmon_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::darkSalmon",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::darkSalmon; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_darkSeaGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::darkSeaGreen",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::darkSeaGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_darkSlateBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::darkSlateBlue",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::darkSlateBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_darkSlateGray_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::darkSlateGray",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::darkSlateGray; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_darkSlateGrey_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::darkSlateGrey",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::darkSlateGrey; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_darkTurquoise_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::darkTurquoise",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::darkTurquoise; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_darkViolet_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::darkViolet",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::darkViolet; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_deepPink_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::deepPink",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::deepPink; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_deepSkyBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::deepSkyBlue",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::deepSkyBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_dimGray_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::dimGray",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::dimGray; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_dimGrey_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::dimGrey",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::dimGrey; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_dodgerBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::dodgerBlue",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::dodgerBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_fireBrick_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::fireBrick",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::fireBrick; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_floralWhite_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::floralWhite",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::floralWhite; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_forestGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::forestGreen",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::forestGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_fuchsia_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::fuchsia",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::fuchsia; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_gainsboro_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::gainsboro",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::gainsboro; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_ghostWhite_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::ghostWhite",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::ghostWhite; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_gold_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::gold",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::gold; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_goldenRod_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::goldenRod",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::goldenRod; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_grey_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::grey",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::grey; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_greenYellow_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::greenYellow",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::greenYellow; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_honeyDew_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::honeyDew",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::honeyDew; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_hotPink_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::hotPink",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::hotPink; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_indianRed_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::indianRed",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::indianRed; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_indigo_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::indigo",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::indigo; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_ivory_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::ivory",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::ivory; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_khaki_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::khaki",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::khaki; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_lavender_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::lavender",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::lavender; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_lavenderBlush_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::lavenderBlush",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::lavenderBlush; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_lawnGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::lawnGreen",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::lawnGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_lemonChiffon_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::lemonChiffon",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::lemonChiffon; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_lightBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::lightBlue",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::lightBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_lightCoral_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::lightCoral",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::lightCoral; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_lightCyan_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::lightCyan",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::lightCyan; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_lightGoldenRodYellow_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::lightGoldenRodYellow",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::lightGoldenRodYellow; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_lightGray_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::lightGray",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::lightGray; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_lightGrey_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::lightGrey",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::lightGrey; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_lightGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::lightGreen",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::lightGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_lightPink_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::lightPink",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::lightPink; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_lightSalmon_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::lightSalmon",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::lightSalmon; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_lightSeaGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::lightSeaGreen",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::lightSeaGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_lightSkyBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::lightSkyBlue",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::lightSkyBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_lightSlateGray_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::lightSlateGray",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::lightSlateGray; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_lightSlateGrey_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::lightSlateGrey",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::lightSlateGrey; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_lightSteelBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::lightSteelBlue",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::lightSteelBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_lightYellow_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::lightYellow",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::lightYellow; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_lime_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::lime",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::lime; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_limeGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::limeGreen",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::limeGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_linen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::linen",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::linen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_maroon_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::maroon",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::maroon; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_mediumAquaMarine_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::mediumAquaMarine",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::mediumAquaMarine; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_mediumBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::mediumBlue",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::mediumBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_mediumOrchid_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::mediumOrchid",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::mediumOrchid; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_mediumPurple_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::mediumPurple",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::mediumPurple; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_mediumSeaGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::mediumSeaGreen",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::mediumSeaGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_mediumSlateBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::mediumSlateBlue",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::mediumSlateBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_mediumSpringGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::mediumSpringGreen",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::mediumSpringGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_mediumTurquoise_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::mediumTurquoise",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::mediumTurquoise; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_mediumVioletRed_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::mediumVioletRed",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::mediumVioletRed; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_midnightBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::midnightBlue",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::midnightBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_mintCream_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::mintCream",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::mintCream; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_mistyRose_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::mistyRose",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::mistyRose; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_moccasin_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::moccasin",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::moccasin; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_navajoWhite_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::navajoWhite",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::navajoWhite; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_navy_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::navy",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::navy; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_oldLace_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::oldLace",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::oldLace; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_olive_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::olive",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::olive; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_oliveDrab_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::oliveDrab",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::oliveDrab; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_orange_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::orange",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::orange; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_orangeRed_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::orangeRed",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::orangeRed; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_orchid_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::orchid",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::orchid; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_paleGoldenRod_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::paleGoldenRod",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::paleGoldenRod; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_paleGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::paleGreen",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::paleGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_paleTurquoise_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::paleTurquoise",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::paleTurquoise; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_paleVioletRed_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::paleVioletRed",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::paleVioletRed; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_papayaWhip_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::papayaWhip",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::papayaWhip; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_peachPuff_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::peachPuff",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::peachPuff; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_peru_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::peru",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::peru; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_pink_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::pink",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::pink; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_plum_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::plum",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::plum; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_powderBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::powderBlue",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::powderBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_purple_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::purple",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::purple; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_rosyBrown_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::rosyBrown",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::rosyBrown; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_royalBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::royalBlue",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::royalBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_saddleBrown_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::saddleBrown",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::saddleBrown; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_salmon_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::salmon",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::salmon; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_sandyBrown_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::sandyBrown",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::sandyBrown; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_seaGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::seaGreen",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::seaGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_seaShell_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::seaShell",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::seaShell; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_sienna_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::sienna",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::sienna; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_silver_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::silver",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::silver; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_skyBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::skyBlue",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::skyBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_slateBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::slateBlue",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::slateBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_slateGray_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::slateGray",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::slateGray; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_slateGrey_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::slateGrey",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::slateGrey; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_snow_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::snow",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::snow; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_springGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::springGreen",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::springGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_steelBlue_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::steelBlue",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::steelBlue; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_blueSteel_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::blueSteel",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::blueSteel; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_tan_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::tan",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::tan; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_teal_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::teal",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::teal; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_thistle_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::thistle",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::thistle; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_tomato_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::tomato",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::tomato; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_turquoise_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::turquoise",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::turquoise; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_violet_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::violet",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::violet; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_wheat_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::wheat",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::wheat; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_whiteSmoke_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::whiteSmoke",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::whiteSmoke; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_yellowGreen_get(lua_State* L) { int SWIG_arg = 0; ofColor_< unsigned short > *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::yellowGreen",0,0) - result = (ofColor_< unsigned short > *)&ofColor_< unsigned short >::yellowGreen; - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_short_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_getR(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; unsigned short result; - SWIG_check_num_args("ofColor_< unsigned short >::getR",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::getR",1,"ofColor_< unsigned short > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_getR",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - result = (unsigned short)ofColor__Sl_unsigned_SS_short_Sg__getR(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_getG(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; unsigned short result; - SWIG_check_num_args("ofColor_< unsigned short >::getG",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::getG",1,"ofColor_< unsigned short > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_getG",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - result = (unsigned short)ofColor__Sl_unsigned_SS_short_Sg__getG(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_getB(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; unsigned short result; - SWIG_check_num_args("ofColor_< unsigned short >::getB",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::getB",1,"ofColor_< unsigned short > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_getB",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - result = (unsigned short)ofColor__Sl_unsigned_SS_short_Sg__getB(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_getA(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; unsigned short result; - SWIG_check_num_args("ofColor_< unsigned short >::getA",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::getA",1,"ofColor_< unsigned short > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_getA",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - result = (unsigned short)ofColor__Sl_unsigned_SS_short_Sg__getA(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_setR(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; unsigned short arg2 ; - SWIG_check_num_args("ofColor_< unsigned short >::setR",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::setR",1,"ofColor_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::setR",2,"unsigned short"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_setR",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned short)lua_tonumber(L, 2); - ofColor__Sl_unsigned_SS_short_Sg__setR(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_setG(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; unsigned short arg2 ; - SWIG_check_num_args("ofColor_< unsigned short >::setG",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::setG",1,"ofColor_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::setG",2,"unsigned short"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_setG",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned short)lua_tonumber(L, 2); - ofColor__Sl_unsigned_SS_short_Sg__setG(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_setB(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; unsigned short arg2 ; - SWIG_check_num_args("ofColor_< unsigned short >::setB",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::setB",1,"ofColor_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::setB",2,"unsigned short"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_setB",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned short)lua_tonumber(L, 2); - ofColor__Sl_unsigned_SS_short_Sg__setB(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_setA(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; unsigned short arg2 ; - SWIG_check_num_args("ofColor_< unsigned short >::setA",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::setA",1,"ofColor_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::setA",2,"unsigned short"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_setA",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned short)lua_tonumber(L, 2); - ofColor__Sl_unsigned_SS_short_Sg__setA(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor___tostring(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; char *result = 0 ; - SWIG_check_num_args("ofColor_< unsigned short >::__str__",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::__str__",1,"ofColor_< unsigned short > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor___tostring",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - result = (char *)ofColor__Sl_unsigned_SS_short_Sg____str__(arg1); lua_pushstring(L,(const char *)result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_r_set(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; unsigned short arg2 ; - SWIG_check_num_args("ofColor_< unsigned short >::r",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::r",1,"ofColor_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::r",2,"unsigned short"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_r_set",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned short)lua_tonumber(L, 2); - ofColor__Sl_unsigned_SS_short_Sg__r_set(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_r_get(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; unsigned short result; - SWIG_check_num_args("ofColor_< unsigned short >::r",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::r",1,"ofColor_< unsigned short > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_r_get",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - result = (unsigned short)ofColor__Sl_unsigned_SS_short_Sg__r_get(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_g_set(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; unsigned short arg2 ; - SWIG_check_num_args("ofColor_< unsigned short >::g",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::g",1,"ofColor_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::g",2,"unsigned short"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_g_set",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned short)lua_tonumber(L, 2); - ofColor__Sl_unsigned_SS_short_Sg__g_set(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_g_get(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; unsigned short result; - SWIG_check_num_args("ofColor_< unsigned short >::g",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::g",1,"ofColor_< unsigned short > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_g_get",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - result = (unsigned short)ofColor__Sl_unsigned_SS_short_Sg__g_get(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_b_set(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; unsigned short arg2 ; - SWIG_check_num_args("ofColor_< unsigned short >::b",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::b",1,"ofColor_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::b",2,"unsigned short"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_b_set",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned short)lua_tonumber(L, 2); - ofColor__Sl_unsigned_SS_short_Sg__b_set(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_b_get(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; unsigned short result; - SWIG_check_num_args("ofColor_< unsigned short >::b",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::b",1,"ofColor_< unsigned short > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_b_get",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - result = (unsigned short)ofColor__Sl_unsigned_SS_short_Sg__b_get(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_a_set(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; unsigned short arg2 ; - SWIG_check_num_args("ofColor_< unsigned short >::a",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::a",1,"ofColor_< unsigned short > *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofColor_< unsigned short >::a",2,"unsigned short"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_a_set",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned short)lua_tonumber(L, 2); - ofColor__Sl_unsigned_SS_short_Sg__a_set(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_ShortColor_a_get(lua_State* L) { int SWIG_arg = 0; - ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) 0 ; unsigned short result; - SWIG_check_num_args("ofColor_< unsigned short >::a",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofColor_< unsigned short >::a",1,"ofColor_< unsigned short > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofColor_T_unsigned_short_t,0))){ - SWIG_fail_ptr("ShortColor_a_get",1,SWIGTYPE_p_ofColor_T_unsigned_short_t); } - result = (unsigned short)ofColor__Sl_unsigned_SS_short_Sg__a_get(arg1); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_ShortColor(void *obj) { -ofColor_< unsigned short > *arg1 = (ofColor_< unsigned short > *) obj; -delete arg1; -} -static int _proxy__wrap_new_ShortColor(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_ShortColor); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_ShortColor_attributes[] = { - { "r", _wrap_ShortColor_r_get, _wrap_ShortColor_r_set }, - { "g", _wrap_ShortColor_g_get, _wrap_ShortColor_g_set }, - { "b", _wrap_ShortColor_b_get, _wrap_ShortColor_b_set }, - { "a", _wrap_ShortColor_a_get, _wrap_ShortColor_a_set }, - {0,0,0} -}; -static swig_lua_method swig_ShortColor_methods[]= { - { "set", _wrap_ShortColor_set}, - { "setHex", _wrap_ShortColor_setHex}, - { "setHue", _wrap_ShortColor_setHue}, - { "setHueAngle", _wrap_ShortColor_setHueAngle}, - { "setSaturation", _wrap_ShortColor_setSaturation}, - { "setBrightness", _wrap_ShortColor_setBrightness}, - { "setHsb", _wrap_ShortColor_setHsb}, - { "clamp", _wrap_ShortColor_clamp}, - { "invert", _wrap_ShortColor_invert}, - { "normalize", _wrap_ShortColor_normalize}, - { "lerp", _wrap_ShortColor_lerp}, - { "getClamped", _wrap_ShortColor_getClamped}, - { "getInverted", _wrap_ShortColor_getInverted}, - { "getNormalized", _wrap_ShortColor_getNormalized}, - { "getLerped", _wrap_ShortColor_getLerped}, - { "getHex", _wrap_ShortColor_getHex}, - { "getHue", _wrap_ShortColor_getHue}, - { "getHueAngle", _wrap_ShortColor_getHueAngle}, - { "getSaturation", _wrap_ShortColor_getSaturation}, - { "getBrightness", _wrap_ShortColor_getBrightness}, - { "getLightness", _wrap_ShortColor_getLightness}, - { "getHsb", _wrap_ShortColor_getHsb}, - { "__eq", _wrap_ShortColor___eq}, - { "__add", _wrap_ShortColor___add}, - { "__sub", _wrap_ShortColor___sub}, - { "__mul", _wrap_ShortColor___mul}, - { "__div", _wrap_ShortColor___div}, - { "getR", _wrap_ShortColor_getR}, - { "getG", _wrap_ShortColor_getG}, - { "getB", _wrap_ShortColor_getB}, - { "getA", _wrap_ShortColor_getA}, - { "setR", _wrap_ShortColor_setR}, - { "setG", _wrap_ShortColor_setG}, - { "setB", _wrap_ShortColor_setB}, - { "setA", _wrap_ShortColor_setA}, - { "__tostring", _wrap_ShortColor___tostring}, - {0,0} -}; -static swig_lua_method swig_ShortColor_meta[] = { - { "__eq", _wrap_ShortColor___eq}, - { "__add", _wrap_ShortColor___add}, - { "__sub", _wrap_ShortColor___sub}, - { "__mul", _wrap_ShortColor___mul}, - { "__div", _wrap_ShortColor___div}, - { "__tostring", _wrap_ShortColor___tostring}, - {0,0} -}; - -static swig_lua_attribute swig_ShortColor_Sf_SwigStatic_attributes[] = { - { "white", _wrap_ShortColor_white_get, SWIG_Lua_set_immutable }, - { "gray", _wrap_ShortColor_gray_get, SWIG_Lua_set_immutable }, - { "black", _wrap_ShortColor_black_get, SWIG_Lua_set_immutable }, - { "red", _wrap_ShortColor_red_get, SWIG_Lua_set_immutable }, - { "green", _wrap_ShortColor_green_get, SWIG_Lua_set_immutable }, - { "blue", _wrap_ShortColor_blue_get, SWIG_Lua_set_immutable }, - { "cyan", _wrap_ShortColor_cyan_get, SWIG_Lua_set_immutable }, - { "magenta", _wrap_ShortColor_magenta_get, SWIG_Lua_set_immutable }, - { "yellow", _wrap_ShortColor_yellow_get, SWIG_Lua_set_immutable }, - { "aliceBlue", _wrap_ShortColor_aliceBlue_get, SWIG_Lua_set_immutable }, - { "antiqueWhite", _wrap_ShortColor_antiqueWhite_get, SWIG_Lua_set_immutable }, - { "aqua", _wrap_ShortColor_aqua_get, SWIG_Lua_set_immutable }, - { "aquamarine", _wrap_ShortColor_aquamarine_get, SWIG_Lua_set_immutable }, - { "azure", _wrap_ShortColor_azure_get, SWIG_Lua_set_immutable }, - { "beige", _wrap_ShortColor_beige_get, SWIG_Lua_set_immutable }, - { "bisque", _wrap_ShortColor_bisque_get, SWIG_Lua_set_immutable }, - { "blanchedAlmond", _wrap_ShortColor_blanchedAlmond_get, SWIG_Lua_set_immutable }, - { "blueViolet", _wrap_ShortColor_blueViolet_get, SWIG_Lua_set_immutable }, - { "brown", _wrap_ShortColor_brown_get, SWIG_Lua_set_immutable }, - { "burlyWood", _wrap_ShortColor_burlyWood_get, SWIG_Lua_set_immutable }, - { "cadetBlue", _wrap_ShortColor_cadetBlue_get, SWIG_Lua_set_immutable }, - { "chartreuse", _wrap_ShortColor_chartreuse_get, SWIG_Lua_set_immutable }, - { "chocolate", _wrap_ShortColor_chocolate_get, SWIG_Lua_set_immutable }, - { "coral", _wrap_ShortColor_coral_get, SWIG_Lua_set_immutable }, - { "cornflowerBlue", _wrap_ShortColor_cornflowerBlue_get, SWIG_Lua_set_immutable }, - { "cornsilk", _wrap_ShortColor_cornsilk_get, SWIG_Lua_set_immutable }, - { "crimson", _wrap_ShortColor_crimson_get, SWIG_Lua_set_immutable }, - { "darkBlue", _wrap_ShortColor_darkBlue_get, SWIG_Lua_set_immutable }, - { "darkCyan", _wrap_ShortColor_darkCyan_get, SWIG_Lua_set_immutable }, - { "darkGoldenRod", _wrap_ShortColor_darkGoldenRod_get, SWIG_Lua_set_immutable }, - { "darkGray", _wrap_ShortColor_darkGray_get, SWIG_Lua_set_immutable }, - { "darkGrey", _wrap_ShortColor_darkGrey_get, SWIG_Lua_set_immutable }, - { "darkGreen", _wrap_ShortColor_darkGreen_get, SWIG_Lua_set_immutable }, - { "darkKhaki", _wrap_ShortColor_darkKhaki_get, SWIG_Lua_set_immutable }, - { "darkMagenta", _wrap_ShortColor_darkMagenta_get, SWIG_Lua_set_immutable }, - { "darkOliveGreen", _wrap_ShortColor_darkOliveGreen_get, SWIG_Lua_set_immutable }, - { "darkorange", _wrap_ShortColor_darkorange_get, SWIG_Lua_set_immutable }, - { "darkOrchid", _wrap_ShortColor_darkOrchid_get, SWIG_Lua_set_immutable }, - { "darkRed", _wrap_ShortColor_darkRed_get, SWIG_Lua_set_immutable }, - { "darkSalmon", _wrap_ShortColor_darkSalmon_get, SWIG_Lua_set_immutable }, - { "darkSeaGreen", _wrap_ShortColor_darkSeaGreen_get, SWIG_Lua_set_immutable }, - { "darkSlateBlue", _wrap_ShortColor_darkSlateBlue_get, SWIG_Lua_set_immutable }, - { "darkSlateGray", _wrap_ShortColor_darkSlateGray_get, SWIG_Lua_set_immutable }, - { "darkSlateGrey", _wrap_ShortColor_darkSlateGrey_get, SWIG_Lua_set_immutable }, - { "darkTurquoise", _wrap_ShortColor_darkTurquoise_get, SWIG_Lua_set_immutable }, - { "darkViolet", _wrap_ShortColor_darkViolet_get, SWIG_Lua_set_immutable }, - { "deepPink", _wrap_ShortColor_deepPink_get, SWIG_Lua_set_immutable }, - { "deepSkyBlue", _wrap_ShortColor_deepSkyBlue_get, SWIG_Lua_set_immutable }, - { "dimGray", _wrap_ShortColor_dimGray_get, SWIG_Lua_set_immutable }, - { "dimGrey", _wrap_ShortColor_dimGrey_get, SWIG_Lua_set_immutable }, - { "dodgerBlue", _wrap_ShortColor_dodgerBlue_get, SWIG_Lua_set_immutable }, - { "fireBrick", _wrap_ShortColor_fireBrick_get, SWIG_Lua_set_immutable }, - { "floralWhite", _wrap_ShortColor_floralWhite_get, SWIG_Lua_set_immutable }, - { "forestGreen", _wrap_ShortColor_forestGreen_get, SWIG_Lua_set_immutable }, - { "fuchsia", _wrap_ShortColor_fuchsia_get, SWIG_Lua_set_immutable }, - { "gainsboro", _wrap_ShortColor_gainsboro_get, SWIG_Lua_set_immutable }, - { "ghostWhite", _wrap_ShortColor_ghostWhite_get, SWIG_Lua_set_immutable }, - { "gold", _wrap_ShortColor_gold_get, SWIG_Lua_set_immutable }, - { "goldenRod", _wrap_ShortColor_goldenRod_get, SWIG_Lua_set_immutable }, - { "grey", _wrap_ShortColor_grey_get, SWIG_Lua_set_immutable }, - { "greenYellow", _wrap_ShortColor_greenYellow_get, SWIG_Lua_set_immutable }, - { "honeyDew", _wrap_ShortColor_honeyDew_get, SWIG_Lua_set_immutable }, - { "hotPink", _wrap_ShortColor_hotPink_get, SWIG_Lua_set_immutable }, - { "indianRed", _wrap_ShortColor_indianRed_get, SWIG_Lua_set_immutable }, - { "indigo", _wrap_ShortColor_indigo_get, SWIG_Lua_set_immutable }, - { "ivory", _wrap_ShortColor_ivory_get, SWIG_Lua_set_immutable }, - { "khaki", _wrap_ShortColor_khaki_get, SWIG_Lua_set_immutable }, - { "lavender", _wrap_ShortColor_lavender_get, SWIG_Lua_set_immutable }, - { "lavenderBlush", _wrap_ShortColor_lavenderBlush_get, SWIG_Lua_set_immutable }, - { "lawnGreen", _wrap_ShortColor_lawnGreen_get, SWIG_Lua_set_immutable }, - { "lemonChiffon", _wrap_ShortColor_lemonChiffon_get, SWIG_Lua_set_immutable }, - { "lightBlue", _wrap_ShortColor_lightBlue_get, SWIG_Lua_set_immutable }, - { "lightCoral", _wrap_ShortColor_lightCoral_get, SWIG_Lua_set_immutable }, - { "lightCyan", _wrap_ShortColor_lightCyan_get, SWIG_Lua_set_immutable }, - { "lightGoldenRodYellow", _wrap_ShortColor_lightGoldenRodYellow_get, SWIG_Lua_set_immutable }, - { "lightGray", _wrap_ShortColor_lightGray_get, SWIG_Lua_set_immutable }, - { "lightGrey", _wrap_ShortColor_lightGrey_get, SWIG_Lua_set_immutable }, - { "lightGreen", _wrap_ShortColor_lightGreen_get, SWIG_Lua_set_immutable }, - { "lightPink", _wrap_ShortColor_lightPink_get, SWIG_Lua_set_immutable }, - { "lightSalmon", _wrap_ShortColor_lightSalmon_get, SWIG_Lua_set_immutable }, - { "lightSeaGreen", _wrap_ShortColor_lightSeaGreen_get, SWIG_Lua_set_immutable }, - { "lightSkyBlue", _wrap_ShortColor_lightSkyBlue_get, SWIG_Lua_set_immutable }, - { "lightSlateGray", _wrap_ShortColor_lightSlateGray_get, SWIG_Lua_set_immutable }, - { "lightSlateGrey", _wrap_ShortColor_lightSlateGrey_get, SWIG_Lua_set_immutable }, - { "lightSteelBlue", _wrap_ShortColor_lightSteelBlue_get, SWIG_Lua_set_immutable }, - { "lightYellow", _wrap_ShortColor_lightYellow_get, SWIG_Lua_set_immutable }, - { "lime", _wrap_ShortColor_lime_get, SWIG_Lua_set_immutable }, - { "limeGreen", _wrap_ShortColor_limeGreen_get, SWIG_Lua_set_immutable }, - { "linen", _wrap_ShortColor_linen_get, SWIG_Lua_set_immutable }, - { "maroon", _wrap_ShortColor_maroon_get, SWIG_Lua_set_immutable }, - { "mediumAquaMarine", _wrap_ShortColor_mediumAquaMarine_get, SWIG_Lua_set_immutable }, - { "mediumBlue", _wrap_ShortColor_mediumBlue_get, SWIG_Lua_set_immutable }, - { "mediumOrchid", _wrap_ShortColor_mediumOrchid_get, SWIG_Lua_set_immutable }, - { "mediumPurple", _wrap_ShortColor_mediumPurple_get, SWIG_Lua_set_immutable }, - { "mediumSeaGreen", _wrap_ShortColor_mediumSeaGreen_get, SWIG_Lua_set_immutable }, - { "mediumSlateBlue", _wrap_ShortColor_mediumSlateBlue_get, SWIG_Lua_set_immutable }, - { "mediumSpringGreen", _wrap_ShortColor_mediumSpringGreen_get, SWIG_Lua_set_immutable }, - { "mediumTurquoise", _wrap_ShortColor_mediumTurquoise_get, SWIG_Lua_set_immutable }, - { "mediumVioletRed", _wrap_ShortColor_mediumVioletRed_get, SWIG_Lua_set_immutable }, - { "midnightBlue", _wrap_ShortColor_midnightBlue_get, SWIG_Lua_set_immutable }, - { "mintCream", _wrap_ShortColor_mintCream_get, SWIG_Lua_set_immutable }, - { "mistyRose", _wrap_ShortColor_mistyRose_get, SWIG_Lua_set_immutable }, - { "moccasin", _wrap_ShortColor_moccasin_get, SWIG_Lua_set_immutable }, - { "navajoWhite", _wrap_ShortColor_navajoWhite_get, SWIG_Lua_set_immutable }, - { "navy", _wrap_ShortColor_navy_get, SWIG_Lua_set_immutable }, - { "oldLace", _wrap_ShortColor_oldLace_get, SWIG_Lua_set_immutable }, - { "olive", _wrap_ShortColor_olive_get, SWIG_Lua_set_immutable }, - { "oliveDrab", _wrap_ShortColor_oliveDrab_get, SWIG_Lua_set_immutable }, - { "orange", _wrap_ShortColor_orange_get, SWIG_Lua_set_immutable }, - { "orangeRed", _wrap_ShortColor_orangeRed_get, SWIG_Lua_set_immutable }, - { "orchid", _wrap_ShortColor_orchid_get, SWIG_Lua_set_immutable }, - { "paleGoldenRod", _wrap_ShortColor_paleGoldenRod_get, SWIG_Lua_set_immutable }, - { "paleGreen", _wrap_ShortColor_paleGreen_get, SWIG_Lua_set_immutable }, - { "paleTurquoise", _wrap_ShortColor_paleTurquoise_get, SWIG_Lua_set_immutable }, - { "paleVioletRed", _wrap_ShortColor_paleVioletRed_get, SWIG_Lua_set_immutable }, - { "papayaWhip", _wrap_ShortColor_papayaWhip_get, SWIG_Lua_set_immutable }, - { "peachPuff", _wrap_ShortColor_peachPuff_get, SWIG_Lua_set_immutable }, - { "peru", _wrap_ShortColor_peru_get, SWIG_Lua_set_immutable }, - { "pink", _wrap_ShortColor_pink_get, SWIG_Lua_set_immutable }, - { "plum", _wrap_ShortColor_plum_get, SWIG_Lua_set_immutable }, - { "powderBlue", _wrap_ShortColor_powderBlue_get, SWIG_Lua_set_immutable }, - { "purple", _wrap_ShortColor_purple_get, SWIG_Lua_set_immutable }, - { "rosyBrown", _wrap_ShortColor_rosyBrown_get, SWIG_Lua_set_immutable }, - { "royalBlue", _wrap_ShortColor_royalBlue_get, SWIG_Lua_set_immutable }, - { "saddleBrown", _wrap_ShortColor_saddleBrown_get, SWIG_Lua_set_immutable }, - { "salmon", _wrap_ShortColor_salmon_get, SWIG_Lua_set_immutable }, - { "sandyBrown", _wrap_ShortColor_sandyBrown_get, SWIG_Lua_set_immutable }, - { "seaGreen", _wrap_ShortColor_seaGreen_get, SWIG_Lua_set_immutable }, - { "seaShell", _wrap_ShortColor_seaShell_get, SWIG_Lua_set_immutable }, - { "sienna", _wrap_ShortColor_sienna_get, SWIG_Lua_set_immutable }, - { "silver", _wrap_ShortColor_silver_get, SWIG_Lua_set_immutable }, - { "skyBlue", _wrap_ShortColor_skyBlue_get, SWIG_Lua_set_immutable }, - { "slateBlue", _wrap_ShortColor_slateBlue_get, SWIG_Lua_set_immutable }, - { "slateGray", _wrap_ShortColor_slateGray_get, SWIG_Lua_set_immutable }, - { "slateGrey", _wrap_ShortColor_slateGrey_get, SWIG_Lua_set_immutable }, - { "snow", _wrap_ShortColor_snow_get, SWIG_Lua_set_immutable }, - { "springGreen", _wrap_ShortColor_springGreen_get, SWIG_Lua_set_immutable }, - { "steelBlue", _wrap_ShortColor_steelBlue_get, SWIG_Lua_set_immutable }, - { "blueSteel", _wrap_ShortColor_blueSteel_get, SWIG_Lua_set_immutable }, - { "tan", _wrap_ShortColor_tan_get, SWIG_Lua_set_immutable }, - { "teal", _wrap_ShortColor_teal_get, SWIG_Lua_set_immutable }, - { "thistle", _wrap_ShortColor_thistle_get, SWIG_Lua_set_immutable }, - { "tomato", _wrap_ShortColor_tomato_get, SWIG_Lua_set_immutable }, - { "turquoise", _wrap_ShortColor_turquoise_get, SWIG_Lua_set_immutable }, - { "violet", _wrap_ShortColor_violet_get, SWIG_Lua_set_immutable }, - { "wheat", _wrap_ShortColor_wheat_get, SWIG_Lua_set_immutable }, - { "whiteSmoke", _wrap_ShortColor_whiteSmoke_get, SWIG_Lua_set_immutable }, - { "yellowGreen", _wrap_ShortColor_yellowGreen_get, SWIG_Lua_set_immutable }, - {0,0,0} -}; -static swig_lua_const_info swig_ShortColor_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_ShortColor_Sf_SwigStatic_methods[]= { - { "fromHsb", _wrap_ShortColor_fromHsb}, - { "fromHex", _wrap_ShortColor_fromHex}, - { "limit", _wrap_ShortColor_limit}, - {0,0} -}; -static swig_lua_class* swig_ShortColor_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_ShortColor_Sf_SwigStatic = { - "ShortColor", - swig_ShortColor_Sf_SwigStatic_methods, - swig_ShortColor_Sf_SwigStatic_attributes, - swig_ShortColor_Sf_SwigStatic_constants, - swig_ShortColor_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_ShortColor_bases[] = {0}; -static const char *swig_ShortColor_base_names[] = {0}; -static swig_lua_class _wrap_class_ShortColor = { "ShortColor", "ShortColor", &SWIGTYPE_p_ofColor_T_unsigned_short_t,_proxy__wrap_new_ShortColor, swig_delete_ShortColor, swig_ShortColor_methods, swig_ShortColor_attributes, &swig_ShortColor_Sf_SwigStatic, swig_ShortColor_meta, swig_ShortColor_bases, swig_ShortColor_base_names }; - -static int _wrap_new_Rectangle__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofRectangle *result = 0 ; - SWIG_check_num_args("ofRectangle::ofRectangle",0,0) result = (ofRectangle *)new ofRectangle(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofRectangle,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Rectangle__SWIG_1(lua_State* L) { int SWIG_arg = 0; float arg1 ; float arg2 ; float arg3 ; float arg4 ; - ofRectangle *result = 0 ; SWIG_check_num_args("ofRectangle::ofRectangle",4,4) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofRectangle::ofRectangle",1,"float"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::ofRectangle",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofRectangle::ofRectangle",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofRectangle::ofRectangle",4,"float"); arg1 = (float)lua_tonumber(L, 1); - arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - result = (ofRectangle *)new ofRectangle(arg1,arg2,arg3,arg4); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofRectangle,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Rectangle__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofPoint *arg1 = 0 ; float arg2 ; float arg3 ; - ofRectangle *result = 0 ; SWIG_check_num_args("ofRectangle::ofRectangle",3,3) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofRectangle::ofRectangle",1,"ofPoint const &"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::ofRectangle",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofRectangle::ofRectangle",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("new_Rectangle",1,SWIGTYPE_p_ofVec3f); } arg2 = (float)lua_tonumber(L, 2); arg3 = (float)lua_tonumber(L, 3); - result = (ofRectangle *)new ofRectangle((ofPoint const &)*arg1,arg2,arg3); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofRectangle,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Rectangle__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = 0 ; ofRectangle *result = 0 ; - SWIG_check_num_args("ofRectangle::ofRectangle",1,1) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofRectangle::ofRectangle",1,"ofRectangle const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("new_Rectangle",1,SWIGTYPE_p_ofRectangle); } - result = (ofRectangle *)new ofRectangle((ofRectangle const &)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofRectangle,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Rectangle__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofPoint *arg1 = 0 ; ofPoint *arg2 = 0 ; - ofRectangle *result = 0 ; SWIG_check_num_args("ofRectangle::ofRectangle",2,2) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofRectangle::ofRectangle",1,"ofPoint const &"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::ofRectangle",2,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("new_Rectangle",1,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("new_Rectangle",2,SWIGTYPE_p_ofVec3f); } - result = (ofRectangle *)new ofRectangle((ofPoint const &)*arg1,(ofPoint const &)*arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofRectangle,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Rectangle(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_Rectangle__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_new_Rectangle__SWIG_3(L);} } if (argc == 2) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_new_Rectangle__SWIG_4(L);} } } if (argc == 3) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_new_Rectangle__SWIG_2(L);} } } } if (argc == 4) { int _v; { _v = lua_isnumber(L,argv[0]); } - if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_new_Rectangle__SWIG_1(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_Rectangle'\n" " Possible C/C++ prototypes are:\n" - " ofRectangle::ofRectangle()\n" " ofRectangle::ofRectangle(float,float,float,float)\n" - " ofRectangle::ofRectangle(ofPoint const &,float,float)\n" " ofRectangle::ofRectangle(ofRectangle const &)\n" - " ofRectangle::ofRectangle(ofPoint const &,ofPoint const &)\n"); lua_error(L);return 0; } -static int _wrap_Rectangle_set__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float arg2 ; - float arg3 ; float arg4 ; float arg5 ; SWIG_check_num_args("ofRectangle::set",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::set",1,"ofRectangle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::set",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofRectangle::set",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofRectangle::set",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofRectangle::set",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_set",1,SWIGTYPE_p_ofRectangle); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - (arg1)->set(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_set__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofPoint *arg2 = 0 ; float arg3 ; float arg4 ; SWIG_check_num_args("ofRectangle::set",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::set",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::set",2,"ofPoint const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofRectangle::set",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofRectangle::set",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_set",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Rectangle_set",2,SWIGTYPE_p_ofVec3f); } arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); - (arg1)->set((ofPoint const &)*arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_set__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofRectangle *arg2 = 0 ; SWIG_check_num_args("ofRectangle::set",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::set",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::set",2,"ofRectangle const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_set",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_set",2,SWIGTYPE_p_ofRectangle); } (arg1)->set((ofRectangle const &)*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_set__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofPoint *arg2 = 0 ; ofPoint *arg3 = 0 ; SWIG_check_num_args("ofRectangle::set",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::set",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::set",2,"ofPoint const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofRectangle::set",3,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_set",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Rectangle_set",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Rectangle_set",3,SWIGTYPE_p_ofVec3f); } (arg1)->set((ofPoint const &)*arg2,(ofPoint const &)*arg3); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_set(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle_set__SWIG_2(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle_set__SWIG_3(L);} } } } if (argc == 4) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Rectangle_set__SWIG_1(L);} } } } } if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Rectangle_set__SWIG_0(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Rectangle_set'\n" " Possible C/C++ prototypes are:\n" - " ofRectangle::set(float,float,float,float)\n" " ofRectangle::set(ofPoint const &,float,float)\n" - " ofRectangle::set(ofRectangle const &)\n" " ofRectangle::set(ofPoint const &,ofPoint const &)\n"); - lua_error(L);return 0; } -static int _wrap_Rectangle_setX(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float arg2 ; - SWIG_check_num_args("ofRectangle::setX",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::setX",1,"ofRectangle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::setX",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_setX",1,SWIGTYPE_p_ofRectangle); } arg2 = (float)lua_tonumber(L, 2); (arg1)->setX(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_setY(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float arg2 ; - SWIG_check_num_args("ofRectangle::setY",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::setY",1,"ofRectangle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::setY",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_setY",1,SWIGTYPE_p_ofRectangle); } arg2 = (float)lua_tonumber(L, 2); (arg1)->setY(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_setWidth(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float arg2 ; - SWIG_check_num_args("ofRectangle::setWidth",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::setWidth",1,"ofRectangle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::setWidth",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_setWidth",1,SWIGTYPE_p_ofRectangle); } arg2 = (float)lua_tonumber(L, 2); (arg1)->setWidth(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_setHeight(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float arg2 ; - SWIG_check_num_args("ofRectangle::setHeight",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::setHeight",1,"ofRectangle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::setHeight",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_setHeight",1,SWIGTYPE_p_ofRectangle); } arg2 = (float)lua_tonumber(L, 2); (arg1)->setHeight(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_setPosition__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - float arg2 ; float arg3 ; SWIG_check_num_args("ofRectangle::setPosition",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::setPosition",1,"ofRectangle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::setPosition",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofRectangle::setPosition",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_setPosition",1,SWIGTYPE_p_ofRectangle); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->setPosition(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Rectangle_setPosition__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofPoint *arg2 = 0 ; SWIG_check_num_args("ofRectangle::setPosition",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::setPosition",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::setPosition",2,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_setPosition",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Rectangle_setPosition",2,SWIGTYPE_p_ofVec3f); } (arg1)->setPosition((ofPoint const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_setPosition(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle_setPosition__SWIG_1(L);} } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_Rectangle_setPosition__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Rectangle_setPosition'\n" - " Possible C/C++ prototypes are:\n" " ofRectangle::setPosition(float,float)\n" - " ofRectangle::setPosition(ofPoint const &)\n"); lua_error(L);return 0; } -static int _wrap_Rectangle_setSize(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float arg2 ; - float arg3 ; SWIG_check_num_args("ofRectangle::setSize",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::setSize",1,"ofRectangle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::setSize",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofRectangle::setSize",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_setSize",1,SWIGTYPE_p_ofRectangle); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->setSize(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Rectangle_setFromCenter__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - float arg2 ; float arg3 ; float arg4 ; float arg5 ; SWIG_check_num_args("ofRectangle::setFromCenter",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::setFromCenter",1,"ofRectangle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::setFromCenter",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofRectangle::setFromCenter",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofRectangle::setFromCenter",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofRectangle::setFromCenter",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_setFromCenter",1,SWIGTYPE_p_ofRectangle); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - (arg1)->setFromCenter(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_setFromCenter__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofPoint *arg2 = 0 ; float arg3 ; float arg4 ; SWIG_check_num_args("ofRectangle::setFromCenter",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::setFromCenter",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::setFromCenter",2,"ofPoint const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofRectangle::setFromCenter",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofRectangle::setFromCenter",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_setFromCenter",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Rectangle_setFromCenter",2,SWIGTYPE_p_ofVec3f); } arg3 = (float)lua_tonumber(L, 3); - arg4 = (float)lua_tonumber(L, 4); (arg1)->setFromCenter((ofPoint const &)*arg2,arg3,arg4); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_setFromCenter(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); - if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Rectangle_setFromCenter__SWIG_1(L);} } } } } if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_Rectangle_setFromCenter__SWIG_0(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Rectangle_setFromCenter'\n" - " Possible C/C++ prototypes are:\n" " ofRectangle::setFromCenter(float,float,float,float)\n" - " ofRectangle::setFromCenter(ofPoint const &,float,float)\n"); lua_error(L);return 0; } -static int _wrap_Rectangle_translate__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - float arg2 ; float arg3 ; SWIG_check_num_args("ofRectangle::translate",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::translate",1,"ofRectangle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::translate",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofRectangle::translate",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_translate",1,SWIGTYPE_p_ofRectangle); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->translate(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Rectangle_translate__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofPoint *arg2 = 0 ; SWIG_check_num_args("ofRectangle::translate",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::translate",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::translate",2,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_translate",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Rectangle_translate",2,SWIGTYPE_p_ofVec3f); } (arg1)->translate((ofPoint const &)*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_translate(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle_translate__SWIG_1(L);} } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_Rectangle_translate__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Rectangle_translate'\n" - " Possible C/C++ prototypes are:\n" " ofRectangle::translate(float,float)\n" - " ofRectangle::translate(ofPoint const &)\n"); lua_error(L);return 0; } -static int _wrap_Rectangle_translateX(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float arg2 ; - SWIG_check_num_args("ofRectangle::translateX",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::translateX",1,"ofRectangle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::translateX",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_translateX",1,SWIGTYPE_p_ofRectangle); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->translateX(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_translateY(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float arg2 ; - SWIG_check_num_args("ofRectangle::translateY",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::translateY",1,"ofRectangle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::translateY",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_translateY",1,SWIGTYPE_p_ofRectangle); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->translateY(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_scale__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float arg2 ; - SWIG_check_num_args("ofRectangle::scale",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::scale",1,"ofRectangle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::scale",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_scale",1,SWIGTYPE_p_ofRectangle); } arg2 = (float)lua_tonumber(L, 2); (arg1)->scale(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_scale__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float arg2 ; - float arg3 ; SWIG_check_num_args("ofRectangle::scale",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::scale",1,"ofRectangle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::scale",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofRectangle::scale",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_scale",1,SWIGTYPE_p_ofRectangle); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->scale(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Rectangle_scale__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofPoint *arg2 = 0 ; SWIG_check_num_args("ofRectangle::scale",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::scale",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::scale",2,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_scale",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Rectangle_scale",2,SWIGTYPE_p_ofVec3f); } (arg1)->scale((ofPoint const &)*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_scale(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle_scale__SWIG_2(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Rectangle_scale__SWIG_0(L);} } - } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Rectangle_scale__SWIG_1(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Rectangle_scale'\n" " Possible C/C++ prototypes are:\n" - " ofRectangle::scale(float)\n" " ofRectangle::scale(float,float)\n" " ofRectangle::scale(ofPoint const &)\n"); - lua_error(L);return 0; } -static int _wrap_Rectangle_scaleWidth(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float arg2 ; - SWIG_check_num_args("ofRectangle::scaleWidth",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::scaleWidth",1,"ofRectangle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::scaleWidth",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_scaleWidth",1,SWIGTYPE_p_ofRectangle); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->scaleWidth(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_scaleHeight(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float arg2 ; - SWIG_check_num_args("ofRectangle::scaleHeight",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::scaleHeight",1,"ofRectangle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::scaleHeight",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_scaleHeight",1,SWIGTYPE_p_ofRectangle); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->scaleHeight(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_scaleFromCenter__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - float arg2 ; SWIG_check_num_args("ofRectangle::scaleFromCenter",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::scaleFromCenter",1,"ofRectangle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::scaleFromCenter",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_scaleFromCenter",1,SWIGTYPE_p_ofRectangle); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->scaleFromCenter(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_scaleFromCenter__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - float arg2 ; float arg3 ; SWIG_check_num_args("ofRectangle::scaleFromCenter",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::scaleFromCenter",1,"ofRectangle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::scaleFromCenter",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofRectangle::scaleFromCenter",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_scaleFromCenter",1,SWIGTYPE_p_ofRectangle); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->scaleFromCenter(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Rectangle_scaleFromCenter__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofPoint *arg2 = 0 ; SWIG_check_num_args("ofRectangle::scaleFromCenter",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::scaleFromCenter",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::scaleFromCenter",2,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_scaleFromCenter",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Rectangle_scaleFromCenter",2,SWIGTYPE_p_ofVec3f); } (arg1)->scaleFromCenter((ofPoint const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_scaleFromCenter(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle_scaleFromCenter__SWIG_2(L);} } } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Rectangle_scaleFromCenter__SWIG_0(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Rectangle_scaleFromCenter__SWIG_1(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Rectangle_scaleFromCenter'\n" - " Possible C/C++ prototypes are:\n" " ofRectangle::scaleFromCenter(float)\n" - " ofRectangle::scaleFromCenter(float,float)\n" " ofRectangle::scaleFromCenter(ofPoint const &)\n"); - lua_error(L);return 0; } -static int _wrap_Rectangle_scaleToScaleMode(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofRectangle *arg2 = 0 ; ofScaleMode arg3 ; SWIG_check_num_args("ofRectangle::scaleTo",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::scaleTo",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::scaleTo",2,"ofRectangle const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofRectangle::scaleTo",3,"ofScaleMode"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_scaleToScaleMode",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_scaleToScaleMode",2,SWIGTYPE_p_ofRectangle); } arg3 = (ofScaleMode)(int)lua_tonumber(L, 3); - (arg1)->scaleTo((ofRectangle const &)*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_scaleTo__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofRectangle *arg2 = 0 ; SWIG_check_num_args("ofRectangle::scaleTo",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::scaleTo",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::scaleTo",2,"ofRectangle const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_scaleTo",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_scaleTo",2,SWIGTYPE_p_ofRectangle); } (arg1)->scaleTo((ofRectangle const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_scaleTo__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofRectangle *arg2 = 0 ; ofAspectRatioMode arg3 ; ofAlignHorz arg4 ; ofAlignVert arg5 ; - SWIG_check_num_args("ofRectangle::scaleTo",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::scaleTo",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::scaleTo",2,"ofRectangle const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofRectangle::scaleTo",3,"ofAspectRatioMode"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofRectangle::scaleTo",4,"ofAlignHorz"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofRectangle::scaleTo",5,"ofAlignVert"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_scaleTo",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_scaleTo",2,SWIGTYPE_p_ofRectangle); } arg3 = (ofAspectRatioMode)(int)lua_tonumber(L, 3); - arg4 = (ofAlignHorz)(int)lua_tonumber(L, 4); arg5 = (ofAlignVert)(int)lua_tonumber(L, 5); - (arg1)->scaleTo((ofRectangle const &)*arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Rectangle_scaleTo__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofRectangle *arg2 = 0 ; ofAspectRatioMode arg3 ; ofAlignHorz arg4 ; SWIG_check_num_args("ofRectangle::scaleTo",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::scaleTo",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::scaleTo",2,"ofRectangle const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofRectangle::scaleTo",3,"ofAspectRatioMode"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofRectangle::scaleTo",4,"ofAlignHorz"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_scaleTo",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_scaleTo",2,SWIGTYPE_p_ofRectangle); } arg3 = (ofAspectRatioMode)(int)lua_tonumber(L, 3); - arg4 = (ofAlignHorz)(int)lua_tonumber(L, 4); (arg1)->scaleTo((ofRectangle const &)*arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_scaleToAspectRatio(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofRectangle *arg2 = 0 ; ofAspectRatioMode arg3 ; SWIG_check_num_args("ofRectangle::scaleTo",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::scaleTo",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::scaleTo",2,"ofRectangle const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofRectangle::scaleTo",3,"ofAspectRatioMode"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_scaleToAspectRatio",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_scaleToAspectRatio",2,SWIGTYPE_p_ofRectangle); } - arg3 = (ofAspectRatioMode)(int)lua_tonumber(L, 3); (arg1)->scaleTo((ofRectangle const &)*arg2,arg3); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_scaleTo__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofRectangle *arg2 = 0 ; ofAspectRatioMode arg3 ; ofAlignHorz arg4 ; ofAlignVert arg5 ; ofAlignHorz arg6 ; ofAlignVert arg7 ; - SWIG_check_num_args("ofRectangle::scaleTo",7,7) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::scaleTo",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::scaleTo",2,"ofRectangle const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofRectangle::scaleTo",3,"ofAspectRatioMode"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofRectangle::scaleTo",4,"ofAlignHorz"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofRectangle::scaleTo",5,"ofAlignVert"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofRectangle::scaleTo",6,"ofAlignHorz"); - if(!lua_isnumber(L,7)) SWIG_fail_arg("ofRectangle::scaleTo",7,"ofAlignVert"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_scaleTo",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_scaleTo",2,SWIGTYPE_p_ofRectangle); } arg3 = (ofAspectRatioMode)(int)lua_tonumber(L, 3); - arg4 = (ofAlignHorz)(int)lua_tonumber(L, 4); arg5 = (ofAlignVert)(int)lua_tonumber(L, 5); - arg6 = (ofAlignHorz)(int)lua_tonumber(L, 6); arg7 = (ofAlignVert)(int)lua_tonumber(L, 7); - (arg1)->scaleTo((ofRectangle const &)*arg2,arg3,arg4,arg5,arg6,arg7); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Rectangle_scaleTo(lua_State* L) { int argc; int argv[8]={ 1,2,3,4,5,6,7,8} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle_scaleTo__SWIG_0(L);} } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Rectangle_scaleTo__SWIG_2(L);} } } } } if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { return _wrap_Rectangle_scaleTo__SWIG_1(L);} } } } } } - if (argc == 7) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { { - _v = lua_isnumber(L,argv[6]); } if (_v) { return _wrap_Rectangle_scaleTo__SWIG_3(L);} } } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Rectangle_scaleTo'\n" " Possible C/C++ prototypes are:\n" - " ofRectangle::scaleTo(ofRectangle const &)\n" - " ofRectangle::scaleTo(ofRectangle const &,ofAspectRatioMode,ofAlignHorz,ofAlignVert)\n" - " ofRectangle::scaleTo(ofRectangle const &,ofAspectRatioMode,ofAlignHorz)\n" - " ofRectangle::scaleTo(ofRectangle const &,ofAspectRatioMode,ofAlignHorz,ofAlignVert,ofAlignHorz,ofAlignVert)\n"); - lua_error(L);return 0; } -static int _wrap_Rectangle_alignToHorz__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - float *arg2 = 0 ; ofAlignHorz arg3 ; float temp2 ; SWIG_check_num_args("ofRectangle::alignToHorz",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::alignToHorz",1,"ofRectangle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::alignToHorz",2,"float const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofRectangle::alignToHorz",3,"ofAlignHorz"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_alignToHorz",1,SWIGTYPE_p_ofRectangle); } temp2=(float)lua_tonumber(L,2); arg2=&temp2; - arg3 = (ofAlignHorz)(int)lua_tonumber(L, 3); (arg1)->alignToHorz((float const &)*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_alignToHorz__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - float *arg2 = 0 ; float temp2 ; SWIG_check_num_args("ofRectangle::alignToHorz",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::alignToHorz",1,"ofRectangle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::alignToHorz",2,"float const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_alignToHorz",1,SWIGTYPE_p_ofRectangle); } temp2=(float)lua_tonumber(L,2); arg2=&temp2; - (arg1)->alignToHorz((float const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_alignToHorz__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofRectangle *arg2 = 0 ; ofAlignHorz arg3 ; SWIG_check_num_args("ofRectangle::alignToHorz",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::alignToHorz",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::alignToHorz",2,"ofRectangle const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofRectangle::alignToHorz",3,"ofAlignHorz"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_alignToHorz",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_alignToHorz",2,SWIGTYPE_p_ofRectangle); } arg3 = (ofAlignHorz)(int)lua_tonumber(L, 3); - (arg1)->alignToHorz((ofRectangle const &)*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_alignToHorz__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofRectangle *arg2 = 0 ; SWIG_check_num_args("ofRectangle::alignToHorz",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::alignToHorz",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::alignToHorz",2,"ofRectangle const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_alignToHorz",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_alignToHorz",2,SWIGTYPE_p_ofRectangle); } (arg1)->alignToHorz((ofRectangle const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_alignToHorz__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofRectangle *arg2 = 0 ; ofAlignHorz arg3 ; ofAlignHorz arg4 ; SWIG_check_num_args("ofRectangle::alignToHorz",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::alignToHorz",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::alignToHorz",2,"ofRectangle const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofRectangle::alignToHorz",3,"ofAlignHorz"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofRectangle::alignToHorz",4,"ofAlignHorz"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_alignToHorz",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_alignToHorz",2,SWIGTYPE_p_ofRectangle); } arg3 = (ofAlignHorz)(int)lua_tonumber(L, 3); - arg4 = (ofAlignHorz)(int)lua_tonumber(L, 4); (arg1)->alignToHorz((ofRectangle const &)*arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_alignToHorz(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle_alignToHorz__SWIG_3(L);} } } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Rectangle_alignToHorz__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Rectangle_alignToHorz__SWIG_2(L);} } } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Rectangle_alignToHorz__SWIG_0(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Rectangle_alignToHorz__SWIG_4(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Rectangle_alignToHorz'\n" - " Possible C/C++ prototypes are:\n" " ofRectangle::alignToHorz(float const &,ofAlignHorz)\n" - " ofRectangle::alignToHorz(float const &)\n" " ofRectangle::alignToHorz(ofRectangle const &,ofAlignHorz)\n" - " ofRectangle::alignToHorz(ofRectangle const &)\n" - " ofRectangle::alignToHorz(ofRectangle const &,ofAlignHorz,ofAlignHorz)\n"); lua_error(L);return 0; } -static int _wrap_Rectangle_alignToVert__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - float *arg2 = 0 ; ofAlignVert arg3 ; float temp2 ; SWIG_check_num_args("ofRectangle::alignToVert",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::alignToVert",1,"ofRectangle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::alignToVert",2,"float const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofRectangle::alignToVert",3,"ofAlignVert"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_alignToVert",1,SWIGTYPE_p_ofRectangle); } temp2=(float)lua_tonumber(L,2); arg2=&temp2; - arg3 = (ofAlignVert)(int)lua_tonumber(L, 3); (arg1)->alignToVert((float const &)*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_alignToVert__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - float *arg2 = 0 ; float temp2 ; SWIG_check_num_args("ofRectangle::alignToVert",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::alignToVert",1,"ofRectangle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::alignToVert",2,"float const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_alignToVert",1,SWIGTYPE_p_ofRectangle); } temp2=(float)lua_tonumber(L,2); arg2=&temp2; - (arg1)->alignToVert((float const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_alignToVert__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofRectangle *arg2 = 0 ; ofAlignVert arg3 ; SWIG_check_num_args("ofRectangle::alignToVert",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::alignToVert",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::alignToVert",2,"ofRectangle const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofRectangle::alignToVert",3,"ofAlignVert"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_alignToVert",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_alignToVert",2,SWIGTYPE_p_ofRectangle); } arg3 = (ofAlignVert)(int)lua_tonumber(L, 3); - (arg1)->alignToVert((ofRectangle const &)*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_alignToVert__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofRectangle *arg2 = 0 ; SWIG_check_num_args("ofRectangle::alignToVert",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::alignToVert",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::alignToVert",2,"ofRectangle const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_alignToVert",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_alignToVert",2,SWIGTYPE_p_ofRectangle); } (arg1)->alignToVert((ofRectangle const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_alignToVert__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofRectangle *arg2 = 0 ; ofAlignVert arg3 ; ofAlignVert arg4 ; SWIG_check_num_args("ofRectangle::alignToVert",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::alignToVert",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::alignToVert",2,"ofRectangle const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofRectangle::alignToVert",3,"ofAlignVert"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofRectangle::alignToVert",4,"ofAlignVert"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_alignToVert",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_alignToVert",2,SWIGTYPE_p_ofRectangle); } arg3 = (ofAlignVert)(int)lua_tonumber(L, 3); - arg4 = (ofAlignVert)(int)lua_tonumber(L, 4); (arg1)->alignToVert((ofRectangle const &)*arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_alignToVert(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle_alignToVert__SWIG_3(L);} } } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_Rectangle_alignToVert__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Rectangle_alignToVert__SWIG_2(L);} } } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Rectangle_alignToVert__SWIG_0(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Rectangle_alignToVert__SWIG_4(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Rectangle_alignToVert'\n" - " Possible C/C++ prototypes are:\n" " ofRectangle::alignToVert(float const &,ofAlignVert)\n" - " ofRectangle::alignToVert(float const &)\n" " ofRectangle::alignToVert(ofRectangle const &,ofAlignVert)\n" - " ofRectangle::alignToVert(ofRectangle const &)\n" - " ofRectangle::alignToVert(ofRectangle const &,ofAlignVert,ofAlignVert)\n"); lua_error(L);return 0; } -static int _wrap_Rectangle_alignTo__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofPoint *arg2 = 0 ; ofAlignHorz arg3 ; ofAlignVert arg4 ; SWIG_check_num_args("ofRectangle::alignTo",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::alignTo",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::alignTo",2,"ofPoint const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofRectangle::alignTo",3,"ofAlignHorz"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofRectangle::alignTo",4,"ofAlignVert"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_alignTo",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Rectangle_alignTo",2,SWIGTYPE_p_ofVec3f); } arg3 = (ofAlignHorz)(int)lua_tonumber(L, 3); - arg4 = (ofAlignVert)(int)lua_tonumber(L, 4); (arg1)->alignTo((ofPoint const &)*arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_alignTo__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofPoint *arg2 = 0 ; ofAlignHorz arg3 ; SWIG_check_num_args("ofRectangle::alignTo",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::alignTo",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::alignTo",2,"ofPoint const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofRectangle::alignTo",3,"ofAlignHorz"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_alignTo",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Rectangle_alignTo",2,SWIGTYPE_p_ofVec3f); } arg3 = (ofAlignHorz)(int)lua_tonumber(L, 3); - (arg1)->alignTo((ofPoint const &)*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_alignTo__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofPoint *arg2 = 0 ; SWIG_check_num_args("ofRectangle::alignTo",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::alignTo",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::alignTo",2,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_alignTo",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Rectangle_alignTo",2,SWIGTYPE_p_ofVec3f); } (arg1)->alignTo((ofPoint const &)*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_alignTo__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofRectangle *arg2 = 0 ; ofAlignHorz arg3 ; ofAlignVert arg4 ; SWIG_check_num_args("ofRectangle::alignTo",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::alignTo",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::alignTo",2,"ofRectangle const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofRectangle::alignTo",3,"ofAlignHorz"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofRectangle::alignTo",4,"ofAlignVert"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_alignTo",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_alignTo",2,SWIGTYPE_p_ofRectangle); } arg3 = (ofAlignHorz)(int)lua_tonumber(L, 3); - arg4 = (ofAlignVert)(int)lua_tonumber(L, 4); (arg1)->alignTo((ofRectangle const &)*arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_alignTo__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofRectangle *arg2 = 0 ; ofAlignHorz arg3 ; SWIG_check_num_args("ofRectangle::alignTo",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::alignTo",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::alignTo",2,"ofRectangle const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofRectangle::alignTo",3,"ofAlignHorz"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_alignTo",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_alignTo",2,SWIGTYPE_p_ofRectangle); } arg3 = (ofAlignHorz)(int)lua_tonumber(L, 3); - (arg1)->alignTo((ofRectangle const &)*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_alignTo__SWIG_5(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofRectangle *arg2 = 0 ; SWIG_check_num_args("ofRectangle::alignTo",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::alignTo",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::alignTo",2,"ofRectangle const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_alignTo",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_alignTo",2,SWIGTYPE_p_ofRectangle); } (arg1)->alignTo((ofRectangle const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_alignTo__SWIG_6(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofRectangle *arg2 = 0 ; ofAlignHorz arg3 ; ofAlignVert arg4 ; ofAlignHorz arg5 ; ofAlignVert arg6 ; - SWIG_check_num_args("ofRectangle::alignTo",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::alignTo",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::alignTo",2,"ofRectangle const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofRectangle::alignTo",3,"ofAlignHorz"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofRectangle::alignTo",4,"ofAlignVert"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofRectangle::alignTo",5,"ofAlignHorz"); - if(!lua_isnumber(L,6)) SWIG_fail_arg("ofRectangle::alignTo",6,"ofAlignVert"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_alignTo",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_alignTo",2,SWIGTYPE_p_ofRectangle); } arg3 = (ofAlignHorz)(int)lua_tonumber(L, 3); - arg4 = (ofAlignVert)(int)lua_tonumber(L, 4); arg5 = (ofAlignHorz)(int)lua_tonumber(L, 5); - arg6 = (ofAlignVert)(int)lua_tonumber(L, 6); (arg1)->alignTo((ofRectangle const &)*arg2,arg3,arg4,arg5,arg6); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_alignTo(lua_State* L) { int argc; int argv[7]={ 1,2,3,4,5,6,7} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle_alignTo__SWIG_2(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle_alignTo__SWIG_5(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Rectangle_alignTo__SWIG_4(L);} - } } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { return _wrap_Rectangle_alignTo__SWIG_1(L);} - } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Rectangle_alignTo__SWIG_0(L);} } } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_Rectangle_alignTo__SWIG_3(L);} } } } } if (argc == 6) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { { _v = lua_isnumber(L,argv[5]); } if (_v) { - return _wrap_Rectangle_alignTo__SWIG_6(L);} } } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Rectangle_alignTo'\n" " Possible C/C++ prototypes are:\n" - " ofRectangle::alignTo(ofPoint const &,ofAlignHorz,ofAlignVert)\n" - " ofRectangle::alignTo(ofPoint const &,ofAlignHorz)\n" " ofRectangle::alignTo(ofPoint const &)\n" - " ofRectangle::alignTo(ofRectangle const &,ofAlignHorz,ofAlignVert)\n" - " ofRectangle::alignTo(ofRectangle const &,ofAlignHorz)\n" " ofRectangle::alignTo(ofRectangle const &)\n" - " ofRectangle::alignTo(ofRectangle const &,ofAlignHorz,ofAlignVert,ofAlignHorz,ofAlignVert)\n"); lua_error(L);return 0; } -static int _wrap_Rectangle_inside__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float arg2 ; - float arg3 ; bool result; SWIG_check_num_args("ofRectangle::inside",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::inside",1,"ofRectangle const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::inside",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofRectangle::inside",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_inside",1,SWIGTYPE_p_ofRectangle); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); result = (bool)((ofRectangle const *)arg1)->inside(arg2,arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_inside__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofPoint *arg2 = 0 ; bool result; SWIG_check_num_args("ofRectangle::inside",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::inside",1,"ofRectangle const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::inside",2,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_inside",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Rectangle_inside",2,SWIGTYPE_p_ofVec3f); } - result = (bool)((ofRectangle const *)arg1)->inside((ofPoint const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_inside__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofRectangle *arg2 = 0 ; bool result; SWIG_check_num_args("ofRectangle::inside",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::inside",1,"ofRectangle const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::inside",2,"ofRectangle const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_inside",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_inside",2,SWIGTYPE_p_ofRectangle); } - result = (bool)((ofRectangle const *)arg1)->inside((ofRectangle const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_inside__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofPoint *arg2 = 0 ; ofPoint *arg3 = 0 ; bool result; SWIG_check_num_args("ofRectangle::inside",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::inside",1,"ofRectangle const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::inside",2,"ofPoint const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofRectangle::inside",3,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_inside",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Rectangle_inside",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Rectangle_inside",3,SWIGTYPE_p_ofVec3f); } - result = (bool)((ofRectangle const *)arg1)->inside((ofPoint const &)*arg2,(ofPoint const &)*arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_inside(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle_inside__SWIG_1(L);} } } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle_inside__SWIG_2(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle_inside__SWIG_3(L);} } } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_Rectangle_inside__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Rectangle_inside'\n" " Possible C/C++ prototypes are:\n" - " ofRectangle::inside(float,float) const\n" " ofRectangle::inside(ofPoint const &) const\n" - " ofRectangle::inside(ofRectangle const &) const\n" " ofRectangle::inside(ofPoint const &,ofPoint const &) const\n"); - lua_error(L);return 0; } -static int _wrap_Rectangle_intersects__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofRectangle *arg2 = 0 ; bool result; SWIG_check_num_args("ofRectangle::intersects",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::intersects",1,"ofRectangle const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::intersects",2,"ofRectangle const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_intersects",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_intersects",2,SWIGTYPE_p_ofRectangle); } - result = (bool)((ofRectangle const *)arg1)->intersects((ofRectangle const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_intersects__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofPoint *arg2 = 0 ; ofPoint *arg3 = 0 ; bool result; SWIG_check_num_args("ofRectangle::intersects",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::intersects",1,"ofRectangle const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::intersects",2,"ofPoint const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofRectangle::intersects",3,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_intersects",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Rectangle_intersects",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Rectangle_intersects",3,SWIGTYPE_p_ofVec3f); } - result = (bool)((ofRectangle const *)arg1)->intersects((ofPoint const &)*arg2,(ofPoint const &)*arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_intersects(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle_intersects__SWIG_0(L);} } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle_intersects__SWIG_1(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Rectangle_intersects'\n" - " Possible C/C++ prototypes are:\n" " ofRectangle::intersects(ofRectangle const &) const\n" - " ofRectangle::intersects(ofPoint const &,ofPoint const &) const\n"); lua_error(L);return 0; } -static int _wrap_Rectangle_growToInclude__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - float arg2 ; float arg3 ; SWIG_check_num_args("ofRectangle::growToInclude",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::growToInclude",1,"ofRectangle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::growToInclude",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofRectangle::growToInclude",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_growToInclude",1,SWIGTYPE_p_ofRectangle); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->growToInclude(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Rectangle_growToInclude__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofPoint *arg2 = 0 ; SWIG_check_num_args("ofRectangle::growToInclude",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::growToInclude",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::growToInclude",2,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_growToInclude",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Rectangle_growToInclude",2,SWIGTYPE_p_ofVec3f); } (arg1)->growToInclude((ofPoint const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_growToInclude__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofRectangle *arg2 = 0 ; SWIG_check_num_args("ofRectangle::growToInclude",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::growToInclude",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::growToInclude",2,"ofRectangle const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_growToInclude",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_growToInclude",2,SWIGTYPE_p_ofRectangle); } (arg1)->growToInclude((ofRectangle const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_growToInclude__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofPoint *arg2 = 0 ; ofPoint *arg3 = 0 ; SWIG_check_num_args("ofRectangle::growToInclude",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::growToInclude",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::growToInclude",2,"ofPoint const &"); - if(!lua_isuserdata(L,3)) SWIG_fail_arg("ofRectangle::growToInclude",3,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_growToInclude",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Rectangle_growToInclude",2,SWIGTYPE_p_ofVec3f); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,3,(void**)&arg3,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Rectangle_growToInclude",3,SWIGTYPE_p_ofVec3f); } - (arg1)->growToInclude((ofPoint const &)*arg2,(ofPoint const &)*arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Rectangle_growToInclude(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle_growToInclude__SWIG_1(L);} } } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle_growToInclude__SWIG_2(L);} } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[2])==0 || SWIG_ConvertPtr(L,argv[2], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Rectangle_growToInclude__SWIG_3(L);} } } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_Rectangle_growToInclude__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Rectangle_growToInclude'\n" - " Possible C/C++ prototypes are:\n" " ofRectangle::growToInclude(float,float)\n" - " ofRectangle::growToInclude(ofPoint const &)\n" " ofRectangle::growToInclude(ofRectangle const &)\n" - " ofRectangle::growToInclude(ofPoint const &,ofPoint const &)\n"); lua_error(L);return 0; } -static int _wrap_Rectangle_getIntersection(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofRectangle *arg2 = 0 ; ofRectangle result; SWIG_check_num_args("ofRectangle::getIntersection",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::getIntersection",1,"ofRectangle const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::getIntersection",2,"ofRectangle const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getIntersection",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getIntersection",2,SWIGTYPE_p_ofRectangle); } - result = ((ofRectangle const *)arg1)->getIntersection((ofRectangle const &)*arg2); { - ofRectangle * resultptr = new ofRectangle((const ofRectangle &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofRectangle,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_getUnion(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofRectangle *arg2 = 0 ; ofRectangle result; SWIG_check_num_args("ofRectangle::getUnion",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::getUnion",1,"ofRectangle const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::getUnion",2,"ofRectangle const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getUnion",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getUnion",2,SWIGTYPE_p_ofRectangle); } - result = ((ofRectangle const *)arg1)->getUnion((ofRectangle const &)*arg2); { - ofRectangle * resultptr = new ofRectangle((const ofRectangle &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofRectangle,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_standardize(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - SWIG_check_num_args("ofRectangle::standardize",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::standardize",1,"ofRectangle *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_standardize",1,SWIGTYPE_p_ofRectangle); } (arg1)->standardize(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_getStandardized(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofRectangle result; SWIG_check_num_args("ofRectangle::getStandardized",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::getStandardized",1,"ofRectangle const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getStandardized",1,SWIGTYPE_p_ofRectangle); } - result = ((ofRectangle const *)arg1)->getStandardized(); { - ofRectangle * resultptr = new ofRectangle((const ofRectangle &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofRectangle,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_isStandardized(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; bool result; - SWIG_check_num_args("ofRectangle::isStandardized",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::isStandardized",1,"ofRectangle const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_isStandardized",1,SWIGTYPE_p_ofRectangle); } - result = (bool)((ofRectangle const *)arg1)->isStandardized(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_getArea(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float result; - SWIG_check_num_args("ofRectangle::getArea",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::getArea",1,"ofRectangle const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getArea",1,SWIGTYPE_p_ofRectangle); } result = (float)((ofRectangle const *)arg1)->getArea(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_getPerimeter(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float result; - SWIG_check_num_args("ofRectangle::getPerimeter",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::getPerimeter",1,"ofRectangle const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getPerimeter",1,SWIGTYPE_p_ofRectangle); } - result = (float)((ofRectangle const *)arg1)->getPerimeter(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_getAspectRatio(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - float result; SWIG_check_num_args("ofRectangle::getAspectRatio",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::getAspectRatio",1,"ofRectangle const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getAspectRatio",1,SWIGTYPE_p_ofRectangle); } - result = (float)((ofRectangle const *)arg1)->getAspectRatio(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_isEmpty(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; bool result; - SWIG_check_num_args("ofRectangle::isEmpty",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::isEmpty",1,"ofRectangle const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_isEmpty",1,SWIGTYPE_p_ofRectangle); } result = (bool)((ofRectangle const *)arg1)->isEmpty(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_getMin(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; ofPoint result; - SWIG_check_num_args("ofRectangle::getMin",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::getMin",1,"ofRectangle const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getMin",1,SWIGTYPE_p_ofRectangle); } result = ((ofRectangle const *)arg1)->getMin(); { - ofPoint * resultptr = new ofPoint((const ofPoint &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_getMax(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; ofPoint result; - SWIG_check_num_args("ofRectangle::getMax",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::getMax",1,"ofRectangle const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getMax",1,SWIGTYPE_p_ofRectangle); } result = ((ofRectangle const *)arg1)->getMax(); { - ofPoint * resultptr = new ofPoint((const ofPoint &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_getMinX(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float result; - SWIG_check_num_args("ofRectangle::getMinX",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::getMinX",1,"ofRectangle const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getMinX",1,SWIGTYPE_p_ofRectangle); } result = (float)((ofRectangle const *)arg1)->getMinX(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_getMaxX(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float result; - SWIG_check_num_args("ofRectangle::getMaxX",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::getMaxX",1,"ofRectangle const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getMaxX",1,SWIGTYPE_p_ofRectangle); } result = (float)((ofRectangle const *)arg1)->getMaxX(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_getMinY(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float result; - SWIG_check_num_args("ofRectangle::getMinY",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::getMinY",1,"ofRectangle const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getMinY",1,SWIGTYPE_p_ofRectangle); } result = (float)((ofRectangle const *)arg1)->getMinY(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_getMaxY(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float result; - SWIG_check_num_args("ofRectangle::getMaxY",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::getMaxY",1,"ofRectangle const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getMaxY",1,SWIGTYPE_p_ofRectangle); } result = (float)((ofRectangle const *)arg1)->getMaxY(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_getLeft(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float result; - SWIG_check_num_args("ofRectangle::getLeft",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::getLeft",1,"ofRectangle const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getLeft",1,SWIGTYPE_p_ofRectangle); } result = (float)((ofRectangle const *)arg1)->getLeft(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_getRight(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float result; - SWIG_check_num_args("ofRectangle::getRight",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::getRight",1,"ofRectangle const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getRight",1,SWIGTYPE_p_ofRectangle); } result = (float)((ofRectangle const *)arg1)->getRight(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_getTop(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float result; - SWIG_check_num_args("ofRectangle::getTop",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::getTop",1,"ofRectangle const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getTop",1,SWIGTYPE_p_ofRectangle); } result = (float)((ofRectangle const *)arg1)->getTop(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_getBottom(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float result; - SWIG_check_num_args("ofRectangle::getBottom",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::getBottom",1,"ofRectangle const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getBottom",1,SWIGTYPE_p_ofRectangle); } result = (float)((ofRectangle const *)arg1)->getBottom(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_getTopLeft(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; ofPoint result; - SWIG_check_num_args("ofRectangle::getTopLeft",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::getTopLeft",1,"ofRectangle const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getTopLeft",1,SWIGTYPE_p_ofRectangle); } result = ((ofRectangle const *)arg1)->getTopLeft(); { - ofPoint * resultptr = new ofPoint((const ofPoint &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_getTopRight(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; ofPoint result; - SWIG_check_num_args("ofRectangle::getTopRight",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::getTopRight",1,"ofRectangle const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getTopRight",1,SWIGTYPE_p_ofRectangle); } result = ((ofRectangle const *)arg1)->getTopRight(); { - ofPoint * resultptr = new ofPoint((const ofPoint &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_getBottomLeft(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofPoint result; SWIG_check_num_args("ofRectangle::getBottomLeft",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::getBottomLeft",1,"ofRectangle const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getBottomLeft",1,SWIGTYPE_p_ofRectangle); } result = ((ofRectangle const *)arg1)->getBottomLeft(); - { ofPoint * resultptr = new ofPoint((const ofPoint &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_getBottomRight(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofPoint result; SWIG_check_num_args("ofRectangle::getBottomRight",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::getBottomRight",1,"ofRectangle const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getBottomRight",1,SWIGTYPE_p_ofRectangle); } - result = ((ofRectangle const *)arg1)->getBottomRight(); { ofPoint * resultptr = new ofPoint((const ofPoint &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_getHorzAnchor(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofAlignHorz arg2 ; float result; SWIG_check_num_args("ofRectangle::getHorzAnchor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::getHorzAnchor",1,"ofRectangle const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::getHorzAnchor",2,"ofAlignHorz"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getHorzAnchor",1,SWIGTYPE_p_ofRectangle); } arg2 = (ofAlignHorz)(int)lua_tonumber(L, 2); - result = (float)((ofRectangle const *)arg1)->getHorzAnchor(arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_getVertAnchor(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofAlignVert arg2 ; float result; SWIG_check_num_args("ofRectangle::getVertAnchor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::getVertAnchor",1,"ofRectangle const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::getVertAnchor",2,"ofAlignVert"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getVertAnchor",1,SWIGTYPE_p_ofRectangle); } arg2 = (ofAlignVert)(int)lua_tonumber(L, 2); - result = (float)((ofRectangle const *)arg1)->getVertAnchor(arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_getPosition(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; ofPoint result; - SWIG_check_num_args("ofRectangle::getPosition",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::getPosition",1,"ofRectangle const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getPosition",1,SWIGTYPE_p_ofRectangle); } result = ((ofRectangle const *)arg1)->getPosition(); { - ofPoint * resultptr = new ofPoint((const ofPoint &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_getPositionRef(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofPoint *result = 0 ; SWIG_check_num_args("ofRectangle::getPositionRef",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::getPositionRef",1,"ofRectangle *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getPositionRef",1,SWIGTYPE_p_ofRectangle); } result = (ofPoint *) &(arg1)->getPositionRef(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Rectangle_getCenter(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; ofPoint result; - SWIG_check_num_args("ofRectangle::getCenter",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::getCenter",1,"ofRectangle const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getCenter",1,SWIGTYPE_p_ofRectangle); } result = ((ofRectangle const *)arg1)->getCenter(); { - ofPoint * resultptr = new ofPoint((const ofPoint &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofVec3f,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_getX(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float result; - SWIG_check_num_args("ofRectangle::getX",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::getX",1,"ofRectangle const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getX",1,SWIGTYPE_p_ofRectangle); } result = (float)((ofRectangle const *)arg1)->getX(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_getY(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float result; - SWIG_check_num_args("ofRectangle::getY",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::getY",1,"ofRectangle const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getY",1,SWIGTYPE_p_ofRectangle); } result = (float)((ofRectangle const *)arg1)->getY(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_getWidth(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float result; - SWIG_check_num_args("ofRectangle::getWidth",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::getWidth",1,"ofRectangle const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getWidth",1,SWIGTYPE_p_ofRectangle); } result = (float)((ofRectangle const *)arg1)->getWidth(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_getHeight(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float result; - SWIG_check_num_args("ofRectangle::getHeight",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::getHeight",1,"ofRectangle const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_getHeight",1,SWIGTYPE_p_ofRectangle); } result = (float)((ofRectangle const *)arg1)->getHeight(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle___add(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; ofPoint *arg2 = 0 ; - ofRectangle result; SWIG_check_num_args("ofRectangle::operator +",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::operator +",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::operator +",2,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle___add",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Rectangle___add",2,SWIGTYPE_p_ofVec3f); } result = (arg1)->operator +((ofPoint const &)*arg2); { - ofRectangle * resultptr = new ofRectangle((const ofRectangle &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofRectangle,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle___sub(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; ofPoint *arg2 = 0 ; - ofRectangle result; SWIG_check_num_args("ofRectangle::operator -",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::operator -",1,"ofRectangle *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::operator -",2,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle___sub",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Rectangle___sub",2,SWIGTYPE_p_ofVec3f); } result = (arg1)->operator -((ofPoint const &)*arg2); { - ofRectangle * resultptr = new ofRectangle((const ofRectangle &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofRectangle,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle___eq(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofRectangle *arg2 = 0 ; bool result; SWIG_check_num_args("ofRectangle::operator ==",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::operator ==",1,"ofRectangle const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofRectangle::operator ==",2,"ofRectangle const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle___eq",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle___eq",2,SWIGTYPE_p_ofRectangle); } - result = (bool)((ofRectangle const *)arg1)->operator ==((ofRectangle const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_isZero(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; bool result; - SWIG_check_num_args("ofRectangle::isZero",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::isZero",1,"ofRectangle const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_isZero",1,SWIGTYPE_p_ofRectangle); } result = (bool)((ofRectangle const *)arg1)->isZero(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_position_set(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofPoint *arg2 = (ofPoint *) 0 ; SWIG_check_num_args("ofRectangle::position",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::position",1,"ofRectangle *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofRectangle::position",2,"ofPoint *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_position_set",1,SWIGTYPE_p_ofRectangle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("Rectangle_position_set",2,SWIGTYPE_p_ofVec3f); } if (arg1) (arg1)->position = *arg2; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_position_get(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - ofPoint *result = 0 ; SWIG_check_num_args("ofRectangle::position",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::position",1,"ofRectangle *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_position_get",1,SWIGTYPE_p_ofRectangle); } result = (ofPoint *)& ((arg1)->position); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVec3f,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Rectangle_width_set(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float arg2 ; - SWIG_check_num_args("ofRectangle::width",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::width",1,"ofRectangle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::width",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_width_set",1,SWIGTYPE_p_ofRectangle); } arg2 = (float)lua_tonumber(L, 2); - if (arg1) (arg1)->width = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_width_get(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float result; - SWIG_check_num_args("ofRectangle::width",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::width",1,"ofRectangle *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_width_get",1,SWIGTYPE_p_ofRectangle); } result = (float) ((arg1)->width); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_height_set(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float arg2 ; - SWIG_check_num_args("ofRectangle::height",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::height",1,"ofRectangle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::height",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_height_set",1,SWIGTYPE_p_ofRectangle); } arg2 = (float)lua_tonumber(L, 2); - if (arg1) (arg1)->height = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_height_get(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float result; - SWIG_check_num_args("ofRectangle::height",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::height",1,"ofRectangle *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_height_get",1,SWIGTYPE_p_ofRectangle); } result = (float) ((arg1)->height); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_x_set(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float arg2 ; - SWIG_check_num_args("ofRectangle::x",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::x",1,"ofRectangle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::x",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_x_set",1,SWIGTYPE_p_ofRectangle); } arg2 = (float)lua_tonumber(L, 2); - ofRectangle_x_set(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_x_get(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float result; - SWIG_check_num_args("ofRectangle::x",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::x",1,"ofRectangle *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_x_get",1,SWIGTYPE_p_ofRectangle); } result = (float)ofRectangle_x_get(arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_y_set(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float arg2 ; - SWIG_check_num_args("ofRectangle::y",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::y",1,"ofRectangle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofRectangle::y",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_y_set",1,SWIGTYPE_p_ofRectangle); } arg2 = (float)lua_tonumber(L, 2); - ofRectangle_y_set(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle_y_get(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; float result; - SWIG_check_num_args("ofRectangle::y",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::y",1,"ofRectangle *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle_y_get",1,SWIGTYPE_p_ofRectangle); } result = (float)ofRectangle_y_get(arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Rectangle___tostring(lua_State* L) { int SWIG_arg = 0; ofRectangle *arg1 = (ofRectangle *) 0 ; - char *result = 0 ; SWIG_check_num_args("ofRectangle::__str__",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofRectangle::__str__",1,"ofRectangle *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("Rectangle___tostring",1,SWIGTYPE_p_ofRectangle); } result = (char *)ofRectangle___str__(arg1); - lua_pushstring(L,(const char *)result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_Rectangle(void *obj) { -ofRectangle *arg1 = (ofRectangle *) obj; -delete arg1; -} -static int _proxy__wrap_new_Rectangle(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_Rectangle); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_Rectangle_attributes[] = { - { "position", _wrap_Rectangle_position_get, _wrap_Rectangle_position_set }, - { "width", _wrap_Rectangle_width_get, _wrap_Rectangle_width_set }, - { "height", _wrap_Rectangle_height_get, _wrap_Rectangle_height_set }, - { "x", _wrap_Rectangle_x_get, _wrap_Rectangle_x_set }, - { "y", _wrap_Rectangle_y_get, _wrap_Rectangle_y_set }, - {0,0,0} -}; -static swig_lua_method swig_Rectangle_methods[]= { - { "set", _wrap_Rectangle_set}, - { "setX", _wrap_Rectangle_setX}, - { "setY", _wrap_Rectangle_setY}, - { "setWidth", _wrap_Rectangle_setWidth}, - { "setHeight", _wrap_Rectangle_setHeight}, - { "setPosition", _wrap_Rectangle_setPosition}, - { "setSize", _wrap_Rectangle_setSize}, - { "setFromCenter", _wrap_Rectangle_setFromCenter}, - { "translate", _wrap_Rectangle_translate}, - { "translateX", _wrap_Rectangle_translateX}, - { "translateY", _wrap_Rectangle_translateY}, - { "scale", _wrap_Rectangle_scale}, - { "scaleWidth", _wrap_Rectangle_scaleWidth}, - { "scaleHeight", _wrap_Rectangle_scaleHeight}, - { "scaleFromCenter", _wrap_Rectangle_scaleFromCenter}, - { "scaleToScaleMode", _wrap_Rectangle_scaleToScaleMode}, - { "scaleToAspectRatio", _wrap_Rectangle_scaleToAspectRatio}, - { "scaleTo", _wrap_Rectangle_scaleTo}, - { "alignToHorz", _wrap_Rectangle_alignToHorz}, - { "alignToVert", _wrap_Rectangle_alignToVert}, - { "alignTo", _wrap_Rectangle_alignTo}, - { "inside", _wrap_Rectangle_inside}, - { "intersects", _wrap_Rectangle_intersects}, - { "growToInclude", _wrap_Rectangle_growToInclude}, - { "getIntersection", _wrap_Rectangle_getIntersection}, - { "getUnion", _wrap_Rectangle_getUnion}, - { "standardize", _wrap_Rectangle_standardize}, - { "getStandardized", _wrap_Rectangle_getStandardized}, - { "isStandardized", _wrap_Rectangle_isStandardized}, - { "getArea", _wrap_Rectangle_getArea}, - { "getPerimeter", _wrap_Rectangle_getPerimeter}, - { "getAspectRatio", _wrap_Rectangle_getAspectRatio}, - { "isEmpty", _wrap_Rectangle_isEmpty}, - { "getMin", _wrap_Rectangle_getMin}, - { "getMax", _wrap_Rectangle_getMax}, - { "getMinX", _wrap_Rectangle_getMinX}, - { "getMaxX", _wrap_Rectangle_getMaxX}, - { "getMinY", _wrap_Rectangle_getMinY}, - { "getMaxY", _wrap_Rectangle_getMaxY}, - { "getLeft", _wrap_Rectangle_getLeft}, - { "getRight", _wrap_Rectangle_getRight}, - { "getTop", _wrap_Rectangle_getTop}, - { "getBottom", _wrap_Rectangle_getBottom}, - { "getTopLeft", _wrap_Rectangle_getTopLeft}, - { "getTopRight", _wrap_Rectangle_getTopRight}, - { "getBottomLeft", _wrap_Rectangle_getBottomLeft}, - { "getBottomRight", _wrap_Rectangle_getBottomRight}, - { "getHorzAnchor", _wrap_Rectangle_getHorzAnchor}, - { "getVertAnchor", _wrap_Rectangle_getVertAnchor}, - { "getPosition", _wrap_Rectangle_getPosition}, - { "getPositionRef", _wrap_Rectangle_getPositionRef}, - { "getCenter", _wrap_Rectangle_getCenter}, - { "getX", _wrap_Rectangle_getX}, - { "getY", _wrap_Rectangle_getY}, - { "getWidth", _wrap_Rectangle_getWidth}, - { "getHeight", _wrap_Rectangle_getHeight}, - { "__add", _wrap_Rectangle___add}, - { "__sub", _wrap_Rectangle___sub}, - { "__eq", _wrap_Rectangle___eq}, - { "isZero", _wrap_Rectangle_isZero}, - { "__tostring", _wrap_Rectangle___tostring}, - {0,0} -}; -static swig_lua_method swig_Rectangle_meta[] = { - { "__add", _wrap_Rectangle___add}, - { "__sub", _wrap_Rectangle___sub}, - { "__eq", _wrap_Rectangle___eq}, - { "__tostring", _wrap_Rectangle___tostring}, - {0,0} -}; - -static swig_lua_attribute swig_Rectangle_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_Rectangle_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_Rectangle_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_Rectangle_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_Rectangle_Sf_SwigStatic = { - "Rectangle", - swig_Rectangle_Sf_SwigStatic_methods, - swig_Rectangle_Sf_SwigStatic_attributes, - swig_Rectangle_Sf_SwigStatic_constants, - swig_Rectangle_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_Rectangle_bases[] = {0}; -static const char *swig_Rectangle_base_names[] = {0}; -static swig_lua_class _wrap_class_Rectangle = { "Rectangle", "Rectangle", &SWIGTYPE_p_ofRectangle,_proxy__wrap_new_Rectangle, swig_delete_Rectangle, swig_Rectangle_methods, swig_Rectangle_attributes, &swig_Rectangle_Sf_SwigStatic, swig_Rectangle_meta, swig_Rectangle_bases, swig_Rectangle_base_names }; - -static int _wrap_new_SerialDeviceInfo__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string arg1 ; std::string arg2 ; int arg3 ; - ofSerialDeviceInfo *result = 0 ; SWIG_check_num_args("ofSerialDeviceInfo::ofSerialDeviceInfo",3,3) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofSerialDeviceInfo::ofSerialDeviceInfo",1,"std::string"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofSerialDeviceInfo::ofSerialDeviceInfo",2,"std::string"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofSerialDeviceInfo::ofSerialDeviceInfo",3,"int"); - (&arg1)->assign(lua_tostring(L,1),lua_rawlen(L,1)); (&arg2)->assign(lua_tostring(L,2),lua_rawlen(L,2)); - arg3 = (int)lua_tonumber(L, 3); result = (ofSerialDeviceInfo *)new ofSerialDeviceInfo(arg1,arg2,arg3); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofSerialDeviceInfo,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_SerialDeviceInfo__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofSerialDeviceInfo *result = 0 ; - SWIG_check_num_args("ofSerialDeviceInfo::ofSerialDeviceInfo",0,0) result = (ofSerialDeviceInfo *)new ofSerialDeviceInfo(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofSerialDeviceInfo,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_SerialDeviceInfo(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_SerialDeviceInfo__SWIG_1(L);} if (argc == 3) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { { - _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_new_SerialDeviceInfo__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_SerialDeviceInfo'\n" - " Possible C/C++ prototypes are:\n" " ofSerialDeviceInfo::ofSerialDeviceInfo(std::string,std::string,int)\n" - " ofSerialDeviceInfo::ofSerialDeviceInfo()\n"); lua_error(L);return 0; } -static int _wrap_SerialDeviceInfo_getDevicePath(lua_State* L) { int SWIG_arg = 0; - ofSerialDeviceInfo *arg1 = (ofSerialDeviceInfo *) 0 ; std::string result; - SWIG_check_num_args("ofSerialDeviceInfo::getDevicePath",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSerialDeviceInfo::getDevicePath",1,"ofSerialDeviceInfo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSerialDeviceInfo,0))){ - SWIG_fail_ptr("SerialDeviceInfo_getDevicePath",1,SWIGTYPE_p_ofSerialDeviceInfo); } result = (arg1)->getDevicePath(); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_SerialDeviceInfo_getDeviceName(lua_State* L) { int SWIG_arg = 0; - ofSerialDeviceInfo *arg1 = (ofSerialDeviceInfo *) 0 ; std::string result; - SWIG_check_num_args("ofSerialDeviceInfo::getDeviceName",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSerialDeviceInfo::getDeviceName",1,"ofSerialDeviceInfo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSerialDeviceInfo,0))){ - SWIG_fail_ptr("SerialDeviceInfo_getDeviceName",1,SWIGTYPE_p_ofSerialDeviceInfo); } result = (arg1)->getDeviceName(); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_SerialDeviceInfo_getDeviceID(lua_State* L) { int SWIG_arg = 0; - ofSerialDeviceInfo *arg1 = (ofSerialDeviceInfo *) 0 ; int result; SWIG_check_num_args("ofSerialDeviceInfo::getDeviceID",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofSerialDeviceInfo::getDeviceID",1,"ofSerialDeviceInfo *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofSerialDeviceInfo,0))){ - SWIG_fail_ptr("SerialDeviceInfo_getDeviceID",1,SWIGTYPE_p_ofSerialDeviceInfo); } result = (int)(arg1)->getDeviceID(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_SerialDeviceInfo(void *obj) { -ofSerialDeviceInfo *arg1 = (ofSerialDeviceInfo *) obj; -delete arg1; -} -static int _proxy__wrap_new_SerialDeviceInfo(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_SerialDeviceInfo); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_SerialDeviceInfo_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_SerialDeviceInfo_methods[]= { - { "getDevicePath", _wrap_SerialDeviceInfo_getDevicePath}, - { "getDeviceName", _wrap_SerialDeviceInfo_getDeviceName}, - { "getDeviceID", _wrap_SerialDeviceInfo_getDeviceID}, - {0,0} -}; -static swig_lua_method swig_SerialDeviceInfo_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_SerialDeviceInfo_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_SerialDeviceInfo_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_SerialDeviceInfo_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_SerialDeviceInfo_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_SerialDeviceInfo_Sf_SwigStatic = { - "SerialDeviceInfo", - swig_SerialDeviceInfo_Sf_SwigStatic_methods, - swig_SerialDeviceInfo_Sf_SwigStatic_attributes, - swig_SerialDeviceInfo_Sf_SwigStatic_constants, - swig_SerialDeviceInfo_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_SerialDeviceInfo_bases[] = {0}; -static const char *swig_SerialDeviceInfo_base_names[] = {0}; -static swig_lua_class _wrap_class_SerialDeviceInfo = { "SerialDeviceInfo", "SerialDeviceInfo", &SWIGTYPE_p_ofSerialDeviceInfo,_proxy__wrap_new_SerialDeviceInfo, swig_delete_SerialDeviceInfo, swig_SerialDeviceInfo_methods, swig_SerialDeviceInfo_attributes, &swig_SerialDeviceInfo_Sf_SwigStatic, swig_SerialDeviceInfo_meta, swig_SerialDeviceInfo_bases, swig_SerialDeviceInfo_base_names }; - -static int _wrap_new_Style(lua_State* L) { int SWIG_arg = 0; ofStyle *result = 0 ; SWIG_check_num_args("ofStyle::ofStyle",0,0) - result = (ofStyle *)new ofStyle(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofStyle,1); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Style_color_set(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; - ofColor *arg2 = (ofColor *) 0 ; SWIG_check_num_args("ofStyle::color",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::color",1,"ofStyle *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofStyle::color",2,"ofColor *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ - SWIG_fail_ptr("Style_color_set",1,SWIGTYPE_p_ofStyle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Style_color_set",2,SWIGTYPE_p_ofColor_T_unsigned_char_t); } if (arg1) (arg1)->color = *arg2; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Style_color_get(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; ofColor *result = 0 ; - SWIG_check_num_args("ofStyle::color",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::color",1,"ofStyle *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ - SWIG_fail_ptr("Style_color_get",1,SWIGTYPE_p_ofStyle); } result = (ofColor *)& ((arg1)->color); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Style_bgColor_set(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; - ofColor *arg2 = (ofColor *) 0 ; SWIG_check_num_args("ofStyle::bgColor",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::bgColor",1,"ofStyle *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofStyle::bgColor",2,"ofColor *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ - SWIG_fail_ptr("Style_bgColor_set",1,SWIGTYPE_p_ofStyle); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofColor_T_unsigned_char_t,0))){ - SWIG_fail_ptr("Style_bgColor_set",2,SWIGTYPE_p_ofColor_T_unsigned_char_t); } if (arg1) (arg1)->bgColor = *arg2; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Style_bgColor_get(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; ofColor *result = 0 ; - SWIG_check_num_args("ofStyle::bgColor",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::bgColor",1,"ofStyle *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ - SWIG_fail_ptr("Style_bgColor_get",1,SWIGTYPE_p_ofStyle); } result = (ofColor *)& ((arg1)->bgColor); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofColor_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Style_polyMode_set(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; ofPolyWindingMode arg2 ; - SWIG_check_num_args("ofStyle::polyMode",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::polyMode",1,"ofStyle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofStyle::polyMode",2,"ofPolyWindingMode"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ - SWIG_fail_ptr("Style_polyMode_set",1,SWIGTYPE_p_ofStyle); } arg2 = (ofPolyWindingMode)(int)lua_tonumber(L, 2); - if (arg1) (arg1)->polyMode = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Style_polyMode_get(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; ofPolyWindingMode result; - SWIG_check_num_args("ofStyle::polyMode",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::polyMode",1,"ofStyle *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ - SWIG_fail_ptr("Style_polyMode_get",1,SWIGTYPE_p_ofStyle); } result = (ofPolyWindingMode) ((arg1)->polyMode); - lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Style_rectMode_set(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; ofRectMode arg2 ; - SWIG_check_num_args("ofStyle::rectMode",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::rectMode",1,"ofStyle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofStyle::rectMode",2,"ofRectMode"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ - SWIG_fail_ptr("Style_rectMode_set",1,SWIGTYPE_p_ofStyle); } arg2 = (ofRectMode)(int)lua_tonumber(L, 2); - if (arg1) (arg1)->rectMode = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Style_rectMode_get(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; ofRectMode result; - SWIG_check_num_args("ofStyle::rectMode",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::rectMode",1,"ofStyle *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ - SWIG_fail_ptr("Style_rectMode_get",1,SWIGTYPE_p_ofStyle); } result = (ofRectMode) ((arg1)->rectMode); - lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Style_bFill_set(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; bool arg2 ; - SWIG_check_num_args("ofStyle::bFill",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::bFill",1,"ofStyle *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofStyle::bFill",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ - SWIG_fail_ptr("Style_bFill_set",1,SWIGTYPE_p_ofStyle); } arg2 = (lua_toboolean(L, 2)!=0); if (arg1) (arg1)->bFill = arg2; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Style_bFill_get(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; bool result; - SWIG_check_num_args("ofStyle::bFill",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::bFill",1,"ofStyle *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ - SWIG_fail_ptr("Style_bFill_get",1,SWIGTYPE_p_ofStyle); } result = (bool) ((arg1)->bFill); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Style_drawBitmapMode_set(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; - ofDrawBitmapMode arg2 ; SWIG_check_num_args("ofStyle::drawBitmapMode",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::drawBitmapMode",1,"ofStyle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofStyle::drawBitmapMode",2,"ofDrawBitmapMode"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ - SWIG_fail_ptr("Style_drawBitmapMode_set",1,SWIGTYPE_p_ofStyle); } arg2 = (ofDrawBitmapMode)(int)lua_tonumber(L, 2); - if (arg1) (arg1)->drawBitmapMode = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Style_drawBitmapMode_get(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; - ofDrawBitmapMode result; SWIG_check_num_args("ofStyle::drawBitmapMode",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::drawBitmapMode",1,"ofStyle *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ - SWIG_fail_ptr("Style_drawBitmapMode_get",1,SWIGTYPE_p_ofStyle); } result = (ofDrawBitmapMode) ((arg1)->drawBitmapMode); - lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Style_blendingMode_set(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; ofBlendMode arg2 ; - SWIG_check_num_args("ofStyle::blendingMode",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::blendingMode",1,"ofStyle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofStyle::blendingMode",2,"ofBlendMode"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ - SWIG_fail_ptr("Style_blendingMode_set",1,SWIGTYPE_p_ofStyle); } arg2 = (ofBlendMode)(int)lua_tonumber(L, 2); - if (arg1) (arg1)->blendingMode = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Style_blendingMode_get(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; ofBlendMode result; - SWIG_check_num_args("ofStyle::blendingMode",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::blendingMode",1,"ofStyle *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ - SWIG_fail_ptr("Style_blendingMode_get",1,SWIGTYPE_p_ofStyle); } result = (ofBlendMode) ((arg1)->blendingMode); - lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Style_smoothing_set(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; bool arg2 ; - SWIG_check_num_args("ofStyle::smoothing",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::smoothing",1,"ofStyle *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofStyle::smoothing",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ - SWIG_fail_ptr("Style_smoothing_set",1,SWIGTYPE_p_ofStyle); } arg2 = (lua_toboolean(L, 2)!=0); - if (arg1) (arg1)->smoothing = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Style_smoothing_get(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; bool result; - SWIG_check_num_args("ofStyle::smoothing",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::smoothing",1,"ofStyle *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ - SWIG_fail_ptr("Style_smoothing_get",1,SWIGTYPE_p_ofStyle); } result = (bool) ((arg1)->smoothing); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Style_circleResolution_set(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; int arg2 ; - SWIG_check_num_args("ofStyle::circleResolution",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::circleResolution",1,"ofStyle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofStyle::circleResolution",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ - SWIG_fail_ptr("Style_circleResolution_set",1,SWIGTYPE_p_ofStyle); } arg2 = (int)lua_tonumber(L, 2); - if (arg1) (arg1)->circleResolution = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Style_circleResolution_get(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; int result; - SWIG_check_num_args("ofStyle::circleResolution",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::circleResolution",1,"ofStyle *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ - SWIG_fail_ptr("Style_circleResolution_get",1,SWIGTYPE_p_ofStyle); } result = (int) ((arg1)->circleResolution); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Style_sphereResolution_set(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; int arg2 ; - SWIG_check_num_args("ofStyle::sphereResolution",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::sphereResolution",1,"ofStyle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofStyle::sphereResolution",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ - SWIG_fail_ptr("Style_sphereResolution_set",1,SWIGTYPE_p_ofStyle); } arg2 = (int)lua_tonumber(L, 2); - if (arg1) (arg1)->sphereResolution = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Style_sphereResolution_get(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; int result; - SWIG_check_num_args("ofStyle::sphereResolution",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::sphereResolution",1,"ofStyle *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ - SWIG_fail_ptr("Style_sphereResolution_get",1,SWIGTYPE_p_ofStyle); } result = (int) ((arg1)->sphereResolution); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Style_curveResolution_set(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; int arg2 ; - SWIG_check_num_args("ofStyle::curveResolution",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::curveResolution",1,"ofStyle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofStyle::curveResolution",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ - SWIG_fail_ptr("Style_curveResolution_set",1,SWIGTYPE_p_ofStyle); } arg2 = (int)lua_tonumber(L, 2); - if (arg1) (arg1)->curveResolution = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Style_curveResolution_get(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; int result; - SWIG_check_num_args("ofStyle::curveResolution",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::curveResolution",1,"ofStyle *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ - SWIG_fail_ptr("Style_curveResolution_get",1,SWIGTYPE_p_ofStyle); } result = (int) ((arg1)->curveResolution); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Style_lineWidth_set(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; float arg2 ; - SWIG_check_num_args("ofStyle::lineWidth",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::lineWidth",1,"ofStyle *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofStyle::lineWidth",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ - SWIG_fail_ptr("Style_lineWidth_set",1,SWIGTYPE_p_ofStyle); } arg2 = (float)lua_tonumber(L, 2); - if (arg1) (arg1)->lineWidth = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Style_lineWidth_get(lua_State* L) { int SWIG_arg = 0; ofStyle *arg1 = (ofStyle *) 0 ; float result; - SWIG_check_num_args("ofStyle::lineWidth",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofStyle::lineWidth",1,"ofStyle *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofStyle,0))){ - SWIG_fail_ptr("Style_lineWidth_get",1,SWIGTYPE_p_ofStyle); } result = (float) ((arg1)->lineWidth); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_Style(void *obj) { -ofStyle *arg1 = (ofStyle *) obj; -delete arg1; -} -static int _proxy__wrap_new_Style(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_Style); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_Style_attributes[] = { - { "color", _wrap_Style_color_get, _wrap_Style_color_set }, - { "bgColor", _wrap_Style_bgColor_get, _wrap_Style_bgColor_set }, - { "polyMode", _wrap_Style_polyMode_get, _wrap_Style_polyMode_set }, - { "rectMode", _wrap_Style_rectMode_get, _wrap_Style_rectMode_set }, - { "bFill", _wrap_Style_bFill_get, _wrap_Style_bFill_set }, - { "drawBitmapMode", _wrap_Style_drawBitmapMode_get, _wrap_Style_drawBitmapMode_set }, - { "blendingMode", _wrap_Style_blendingMode_get, _wrap_Style_blendingMode_set }, - { "smoothing", _wrap_Style_smoothing_get, _wrap_Style_smoothing_set }, - { "circleResolution", _wrap_Style_circleResolution_get, _wrap_Style_circleResolution_set }, - { "sphereResolution", _wrap_Style_sphereResolution_get, _wrap_Style_sphereResolution_set }, - { "curveResolution", _wrap_Style_curveResolution_get, _wrap_Style_curveResolution_set }, - { "lineWidth", _wrap_Style_lineWidth_get, _wrap_Style_lineWidth_set }, - {0,0,0} -}; -static swig_lua_method swig_Style_methods[]= { - {0,0} -}; -static swig_lua_method swig_Style_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_Style_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_Style_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_Style_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_Style_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_Style_Sf_SwigStatic = { - "Style", - swig_Style_Sf_SwigStatic_methods, - swig_Style_Sf_SwigStatic_attributes, - swig_Style_Sf_SwigStatic_constants, - swig_Style_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_Style_bases[] = {0}; -static const char *swig_Style_base_names[] = {0}; -static swig_lua_class _wrap_class_Style = { "Style", "Style", &SWIGTYPE_p_ofStyle,_proxy__wrap_new_Style, swig_delete_Style, swig_Style_methods, swig_Style_attributes, &swig_Style_Sf_SwigStatic, swig_Style_meta, swig_Style_bases, swig_Style_base_names }; - -static int _wrap_new_FpsCounter__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofFpsCounter *result = 0 ; - SWIG_check_num_args("ofFpsCounter::ofFpsCounter",0,0) result = (ofFpsCounter *)new ofFpsCounter(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofFpsCounter,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_FpsCounter__SWIG_1(lua_State* L) { int SWIG_arg = 0; double arg1 ; ofFpsCounter *result = 0 ; - SWIG_check_num_args("ofFpsCounter::ofFpsCounter",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofFpsCounter::ofFpsCounter",1,"double"); arg1 = (double)lua_tonumber(L, 1); - result = (ofFpsCounter *)new ofFpsCounter(arg1); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofFpsCounter,1); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_new_FpsCounter(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_FpsCounter__SWIG_0(L);} if (argc == 1) { int _v; { _v = lua_isnumber(L,argv[0]); } if (_v) { - return _wrap_new_FpsCounter__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_FpsCounter'\n" " Possible C/C++ prototypes are:\n" - " ofFpsCounter::ofFpsCounter()\n" " ofFpsCounter::ofFpsCounter(double)\n"); lua_error(L);return 0; } -static int _wrap_FpsCounter_newFrame(lua_State* L) { int SWIG_arg = 0; ofFpsCounter *arg1 = (ofFpsCounter *) 0 ; - SWIG_check_num_args("ofFpsCounter::newFrame",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFpsCounter::newFrame",1,"ofFpsCounter *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFpsCounter,0))){ - SWIG_fail_ptr("FpsCounter_newFrame",1,SWIGTYPE_p_ofFpsCounter); } (arg1)->newFrame(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_FpsCounter_update(lua_State* L) { int SWIG_arg = 0; ofFpsCounter *arg1 = (ofFpsCounter *) 0 ; - SWIG_check_num_args("ofFpsCounter::update",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFpsCounter::update",1,"ofFpsCounter *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFpsCounter,0))){ - SWIG_fail_ptr("FpsCounter_update",1,SWIGTYPE_p_ofFpsCounter); } (arg1)->update(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FpsCounter_getFps(lua_State* L) { int SWIG_arg = 0; ofFpsCounter *arg1 = (ofFpsCounter *) 0 ; double result; - SWIG_check_num_args("ofFpsCounter::getFps",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFpsCounter::getFps",1,"ofFpsCounter const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFpsCounter,0))){ - SWIG_fail_ptr("FpsCounter_getFps",1,SWIGTYPE_p_ofFpsCounter); } result = (double)((ofFpsCounter const *)arg1)->getFps(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FpsCounter_getNumFrames(lua_State* L) { int SWIG_arg = 0; ofFpsCounter *arg1 = (ofFpsCounter *) 0 ; - uint64_t result; SWIG_check_num_args("ofFpsCounter::getNumFrames",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFpsCounter::getNumFrames",1,"ofFpsCounter const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFpsCounter,0))){ - SWIG_fail_ptr("FpsCounter_getNumFrames",1,SWIGTYPE_p_ofFpsCounter); } - result = (uint64_t)((ofFpsCounter const *)arg1)->getNumFrames(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FpsCounter_getLastFrameNanos(lua_State* L) { int SWIG_arg = 0; ofFpsCounter *arg1 = (ofFpsCounter *) 0 ; - uint64_t result; SWIG_check_num_args("ofFpsCounter::getLastFrameNanos",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFpsCounter::getLastFrameNanos",1,"ofFpsCounter const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFpsCounter,0))){ - SWIG_fail_ptr("FpsCounter_getLastFrameNanos",1,SWIGTYPE_p_ofFpsCounter); } - result = (uint64_t)((ofFpsCounter const *)arg1)->getLastFrameNanos(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FpsCounter_getLastFrameSecs(lua_State* L) { int SWIG_arg = 0; ofFpsCounter *arg1 = (ofFpsCounter *) 0 ; - double result; SWIG_check_num_args("ofFpsCounter::getLastFrameSecs",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFpsCounter::getLastFrameSecs",1,"ofFpsCounter const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFpsCounter,0))){ - SWIG_fail_ptr("FpsCounter_getLastFrameSecs",1,SWIGTYPE_p_ofFpsCounter); } - result = (double)((ofFpsCounter const *)arg1)->getLastFrameSecs(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_FpsCounter(void *obj) { -ofFpsCounter *arg1 = (ofFpsCounter *) obj; -delete arg1; -} -static int _proxy__wrap_new_FpsCounter(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_FpsCounter); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_FpsCounter_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_FpsCounter_methods[]= { - { "newFrame", _wrap_FpsCounter_newFrame}, - { "update", _wrap_FpsCounter_update}, - { "getFps", _wrap_FpsCounter_getFps}, - { "getNumFrames", _wrap_FpsCounter_getNumFrames}, - { "getLastFrameNanos", _wrap_FpsCounter_getLastFrameNanos}, - { "getLastFrameSecs", _wrap_FpsCounter_getLastFrameSecs}, - {0,0} -}; -static swig_lua_method swig_FpsCounter_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_FpsCounter_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_FpsCounter_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_FpsCounter_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_FpsCounter_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_FpsCounter_Sf_SwigStatic = { - "FpsCounter", - swig_FpsCounter_Sf_SwigStatic_methods, - swig_FpsCounter_Sf_SwigStatic_attributes, - swig_FpsCounter_Sf_SwigStatic_constants, - swig_FpsCounter_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_FpsCounter_bases[] = {0}; -static const char *swig_FpsCounter_base_names[] = {0}; -static swig_lua_class _wrap_class_FpsCounter = { "FpsCounter", "FpsCounter", &SWIGTYPE_p_ofFpsCounter,_proxy__wrap_new_FpsCounter, swig_delete_FpsCounter, swig_FpsCounter_methods, swig_FpsCounter_attributes, &swig_FpsCounter_Sf_SwigStatic, swig_FpsCounter_meta, swig_FpsCounter_bases, swig_FpsCounter_base_names }; - -static int _wrap_new_Xml__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofXml *result = 0 ; SWIG_check_num_args("ofXml::ofXml",0,0) - result = (ofXml *)new ofXml(); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofXml,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_new_Xml__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - ofXml *result = 0 ; SWIG_check_num_args("ofXml::ofXml",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofXml::ofXml",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = (ofXml *)new ofXml((std::string const &)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofXml,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Xml__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = 0 ; ofXml *result = 0 ; - SWIG_check_num_args("ofXml::ofXml",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofXml::ofXml",1,"ofXml const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("new_Xml",1,SWIGTYPE_p_ofXml); } - result = (ofXml *)new ofXml((ofXml const &)*arg1); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofXml,1); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_new_Xml(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_Xml__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXml, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_new_Xml__SWIG_2(L);} } if (argc == 1) { int _v; { _v = lua_isstring(L,argv[0]); } - if (_v) { return _wrap_new_Xml__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_Xml'\n" " Possible C/C++ prototypes are:\n" - " ofXml::ofXml()\n" " ofXml::ofXml(std::string const &)\n" " ofXml::ofXml(ofXml const &)\n"); lua_error(L);return 0; } -static int _wrap_Xml_load(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; std::string *arg2 = 0 ; - std::string temp2 ; bool result; SWIG_check_num_args("ofXml::load",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::load",1,"ofXml *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofXml::load",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_load",1,SWIGTYPE_p_ofXml); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; result = (bool)(arg1)->load((std::string const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_save(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; std::string *arg2 = 0 ; - std::string temp2 ; bool result; SWIG_check_num_args("ofXml::save",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::save",1,"ofXml *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofXml::save",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_save",1,SWIGTYPE_p_ofXml); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; result = (bool)(arg1)->save((std::string const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_addChild(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; std::string *arg2 = 0 ; - std::string temp2 ; bool result; SWIG_check_num_args("ofXml::addChild",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::addChild",1,"ofXml *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofXml::addChild",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_addChild",1,SWIGTYPE_p_ofXml); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; result = (bool)(arg1)->addChild((std::string const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_addXml__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; ofXml *arg2 = 0 ; bool arg3 ; - SWIG_check_num_args("ofXml::addXml",3,3) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::addXml",1,"ofXml *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofXml::addXml",2,"ofXml &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofXml::addXml",3,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_addXml",1,SWIGTYPE_p_ofXml); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_addXml",2,SWIGTYPE_p_ofXml); } - arg3 = (lua_toboolean(L, 3)!=0); (arg1)->addXml(*arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Xml_addXml__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; ofXml *arg2 = 0 ; - SWIG_check_num_args("ofXml::addXml",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::addXml",1,"ofXml *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofXml::addXml",2,"ofXml &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_addXml",1,SWIGTYPE_p_ofXml); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_addXml",2,SWIGTYPE_p_ofXml); } - (arg1)->addXml(*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_addXml(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXml, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofXml, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_Xml_addXml__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXml, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofXml, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { return _wrap_Xml_addXml__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Xml_addXml'\n" " Possible C/C++ prototypes are:\n" - " ofXml::addXml(ofXml &,bool)\n" " ofXml::addXml(ofXml &)\n"); lua_error(L);return 0; } -static int _wrap_Xml_getValue__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; std::string result; - SWIG_check_num_args("ofXml::getValue",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::getValue",1,"ofXml const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_getValue",1,SWIGTYPE_p_ofXml); } - result = ((ofXml const *)arg1)->getValue(); lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_getValue__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; std::string *arg2 = 0 ; - std::string temp2 ; std::string result; SWIG_check_num_args("ofXml::getValue",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::getValue",1,"ofXml const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofXml::getValue",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_getValue",1,SWIGTYPE_p_ofXml); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = ((ofXml const *)arg1)->getValue((std::string const &)*arg2); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Xml_getValue(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXml, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Xml_getValue__SWIG_0(L);} } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXml, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { return _wrap_Xml_getValue__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Xml_getValue'\n" " Possible C/C++ prototypes are:\n" - " ofXml::getValue() const\n" " ofXml::getValue(std::string const &) const\n"); lua_error(L);return 0; } -static int _wrap_Xml_getIntValue__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; int result; - SWIG_check_num_args("ofXml::getIntValue",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::getIntValue",1,"ofXml const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_getIntValue",1,SWIGTYPE_p_ofXml); } - result = (int)((ofXml const *)arg1)->getIntValue(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_getIntValue__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; std::string *arg2 = 0 ; - std::string temp2 ; int result; SWIG_check_num_args("ofXml::getIntValue",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::getIntValue",1,"ofXml const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofXml::getIntValue",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_getIntValue",1,SWIGTYPE_p_ofXml); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = (int)((ofXml const *)arg1)->getIntValue((std::string const &)*arg2); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_getIntValue(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXml, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Xml_getIntValue__SWIG_0(L);} } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXml, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { return _wrap_Xml_getIntValue__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Xml_getIntValue'\n" " Possible C/C++ prototypes are:\n" - " ofXml::getIntValue() const\n" " ofXml::getIntValue(std::string const &) const\n"); lua_error(L);return 0; } -static int _wrap_Xml_getInt64Value__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; int64_t result; - SWIG_check_num_args("ofXml::getInt64Value",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::getInt64Value",1,"ofXml const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ - SWIG_fail_ptr("Xml_getInt64Value",1,SWIGTYPE_p_ofXml); } result = (int64_t)((ofXml const *)arg1)->getInt64Value(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_getInt64Value__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; std::string *arg2 = 0 ; - std::string temp2 ; int64_t result; SWIG_check_num_args("ofXml::getInt64Value",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::getInt64Value",1,"ofXml const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofXml::getInt64Value",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ - SWIG_fail_ptr("Xml_getInt64Value",1,SWIGTYPE_p_ofXml); } temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = (int64_t)((ofXml const *)arg1)->getInt64Value((std::string const &)*arg2); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_getInt64Value(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXml, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Xml_getInt64Value__SWIG_0(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXml, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { return _wrap_Xml_getInt64Value__SWIG_1(L);} } - } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Xml_getInt64Value'\n" - " Possible C/C++ prototypes are:\n" " ofXml::getInt64Value() const\n" - " ofXml::getInt64Value(std::string const &) const\n"); lua_error(L);return 0; } -static int _wrap_Xml_getFloatValue__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; float result; - SWIG_check_num_args("ofXml::getFloatValue",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::getFloatValue",1,"ofXml const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ - SWIG_fail_ptr("Xml_getFloatValue",1,SWIGTYPE_p_ofXml); } result = (float)((ofXml const *)arg1)->getFloatValue(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_getFloatValue__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; std::string *arg2 = 0 ; - std::string temp2 ; float result; SWIG_check_num_args("ofXml::getFloatValue",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::getFloatValue",1,"ofXml const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofXml::getFloatValue",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ - SWIG_fail_ptr("Xml_getFloatValue",1,SWIGTYPE_p_ofXml); } temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = (float)((ofXml const *)arg1)->getFloatValue((std::string const &)*arg2); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_getFloatValue(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXml, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Xml_getFloatValue__SWIG_0(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXml, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { return _wrap_Xml_getFloatValue__SWIG_1(L);} } - } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Xml_getFloatValue'\n" - " Possible C/C++ prototypes are:\n" " ofXml::getFloatValue() const\n" - " ofXml::getFloatValue(std::string const &) const\n"); lua_error(L);return 0; } -static int _wrap_Xml_getBoolValue__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; bool result; - SWIG_check_num_args("ofXml::getBoolValue",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::getBoolValue",1,"ofXml const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_getBoolValue",1,SWIGTYPE_p_ofXml); } - result = (bool)((ofXml const *)arg1)->getBoolValue(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_getBoolValue__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; std::string *arg2 = 0 ; - std::string temp2 ; bool result; SWIG_check_num_args("ofXml::getBoolValue",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::getBoolValue",1,"ofXml const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofXml::getBoolValue",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_getBoolValue",1,SWIGTYPE_p_ofXml); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = (bool)((ofXml const *)arg1)->getBoolValue((std::string const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_getBoolValue(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXml, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Xml_getBoolValue__SWIG_0(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXml, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { return _wrap_Xml_getBoolValue__SWIG_1(L);} } - } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Xml_getBoolValue'\n" - " Possible C/C++ prototypes are:\n" " ofXml::getBoolValue() const\n" - " ofXml::getBoolValue(std::string const &) const\n"); lua_error(L);return 0; } -static int _wrap_Xml_setValue(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; std::string *arg2 = 0 ; - std::string *arg3 = 0 ; std::string temp2 ; std::string temp3 ; bool result; SWIG_check_num_args("ofXml::setValue",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::setValue",1,"ofXml *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofXml::setValue",2,"std::string const &"); - if(!lua_isstring(L,3)) SWIG_fail_arg("ofXml::setValue",3,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_setValue",1,SWIGTYPE_p_ofXml); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3; - result = (bool)(arg1)->setValue((std::string const &)*arg2,(std::string const &)*arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_getAttribute(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; std::string *arg2 = 0 ; - std::string temp2 ; std::string result; SWIG_check_num_args("ofXml::getAttribute",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::getAttribute",1,"ofXml const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofXml::getAttribute",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_getAttribute",1,SWIGTYPE_p_ofXml); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = ((ofXml const *)arg1)->getAttribute((std::string const &)*arg2); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Xml_setAttribute(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; std::string *arg2 = 0 ; - std::string *arg3 = 0 ; std::string temp2 ; std::string temp3 ; bool result; SWIG_check_num_args("ofXml::setAttribute",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::setAttribute",1,"ofXml *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofXml::setAttribute",2,"std::string const &"); - if(!lua_isstring(L,3)) SWIG_fail_arg("ofXml::setAttribute",3,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_setAttribute",1,SWIGTYPE_p_ofXml); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3; - result = (bool)(arg1)->setAttribute((std::string const &)*arg2,(std::string const &)*arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_getAttributes(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; - SwigValueWrapper< std::map< std::string,std::string > > result; SWIG_check_num_args("ofXml::getAttributes",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::getAttributes",1,"ofXml const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ - SWIG_fail_ptr("Xml_getAttributes",1,SWIGTYPE_p_ofXml); } result = ((ofXml const *)arg1)->getAttributes(); { - std::map< std::string,std::string > * resultptr = new std::map< std::string,std::string >((const std::map< std::string,std::string > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__mapT_std__string_std__string_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_getNumChildren__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; int result; - SWIG_check_num_args("ofXml::getNumChildren",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::getNumChildren",1,"ofXml const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ - SWIG_fail_ptr("Xml_getNumChildren",1,SWIGTYPE_p_ofXml); } result = (int)((ofXml const *)arg1)->getNumChildren(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_getNumChildren__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; - std::string *arg2 = 0 ; std::string temp2 ; int result; SWIG_check_num_args("ofXml::getNumChildren",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::getNumChildren",1,"ofXml const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofXml::getNumChildren",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ - SWIG_fail_ptr("Xml_getNumChildren",1,SWIGTYPE_p_ofXml); } temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = (int)((ofXml const *)arg1)->getNumChildren((std::string const &)*arg2); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_getNumChildren(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXml, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Xml_getNumChildren__SWIG_0(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXml, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { return _wrap_Xml_getNumChildren__SWIG_1(L);} - } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Xml_getNumChildren'\n" - " Possible C/C++ prototypes are:\n" " ofXml::getNumChildren() const\n" - " ofXml::getNumChildren(std::string const &) const\n"); lua_error(L);return 0; } -static int _wrap_Xml_removeAttribute(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; std::string *arg2 = 0 ; - std::string temp2 ; bool result; SWIG_check_num_args("ofXml::removeAttribute",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::removeAttribute",1,"ofXml *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofXml::removeAttribute",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ - SWIG_fail_ptr("Xml_removeAttribute",1,SWIGTYPE_p_ofXml); } temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = (bool)(arg1)->removeAttribute((std::string const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_removeAttributes__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; - std::string *arg2 = 0 ; std::string temp2 ; bool result; SWIG_check_num_args("ofXml::removeAttributes",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::removeAttributes",1,"ofXml *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofXml::removeAttributes",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ - SWIG_fail_ptr("Xml_removeAttributes",1,SWIGTYPE_p_ofXml); } temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = (bool)(arg1)->removeAttributes((std::string const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_removeAttributes__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; bool result; - SWIG_check_num_args("ofXml::removeAttributes",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::removeAttributes",1,"ofXml *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ - SWIG_fail_ptr("Xml_removeAttributes",1,SWIGTYPE_p_ofXml); } result = (bool)(arg1)->removeAttributes(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_removeAttributes(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXml, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Xml_removeAttributes__SWIG_1(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXml, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { return _wrap_Xml_removeAttributes__SWIG_0(L);} - } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Xml_removeAttributes'\n" - " Possible C/C++ prototypes are:\n" " ofXml::removeAttributes(std::string const &)\n" " ofXml::removeAttributes()\n"); - lua_error(L);return 0; } -static int _wrap_Xml_removeContents__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; - std::string *arg2 = 0 ; std::string temp2 ; bool result; SWIG_check_num_args("ofXml::removeContents",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::removeContents",1,"ofXml *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofXml::removeContents",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ - SWIG_fail_ptr("Xml_removeContents",1,SWIGTYPE_p_ofXml); } temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = (bool)(arg1)->removeContents((std::string const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_removeContents__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; bool result; - SWIG_check_num_args("ofXml::removeContents",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::removeContents",1,"ofXml *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ - SWIG_fail_ptr("Xml_removeContents",1,SWIGTYPE_p_ofXml); } result = (bool)(arg1)->removeContents(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_removeContents(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXml, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_Xml_removeContents__SWIG_1(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXml, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { return _wrap_Xml_removeContents__SWIG_0(L);} - } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Xml_removeContents'\n" - " Possible C/C++ prototypes are:\n" " ofXml::removeContents(std::string const &)\n" " ofXml::removeContents()\n"); - lua_error(L);return 0; } -static int _wrap_Xml_remove__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; std::string *arg2 = 0 ; - std::string temp2 ; bool result; SWIG_check_num_args("ofXml::remove",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::remove",1,"ofXml *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofXml::remove",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_remove",1,SWIGTYPE_p_ofXml); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; result = (bool)(arg1)->remove((std::string const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_remove__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; - SWIG_check_num_args("ofXml::remove",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::remove",1,"ofXml *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_remove",1,SWIGTYPE_p_ofXml); } - (arg1)->remove(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_remove(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXml, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Xml_remove__SWIG_1(L);} } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXml, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { return _wrap_Xml_remove__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Xml_remove'\n" " Possible C/C++ prototypes are:\n" - " ofXml::remove(std::string const &)\n" " ofXml::remove()\n"); lua_error(L);return 0; } -static int _wrap_Xml_exists(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; std::string *arg2 = 0 ; - std::string temp2 ; bool result; SWIG_check_num_args("ofXml::exists",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::exists",1,"ofXml const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofXml::exists",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_exists",1,SWIGTYPE_p_ofXml); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = (bool)((ofXml const *)arg1)->exists((std::string const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_clear(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; SWIG_check_num_args("ofXml::clear",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::clear",1,"ofXml *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_clear",1,SWIGTYPE_p_ofXml); } - (arg1)->clear(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_getName(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; std::string result; - SWIG_check_num_args("ofXml::getName",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::getName",1,"ofXml const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_getName",1,SWIGTYPE_p_ofXml); } - result = ((ofXml const *)arg1)->getName(); lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_reset(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; bool result; - SWIG_check_num_args("ofXml::reset",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::reset",1,"ofXml *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_reset",1,SWIGTYPE_p_ofXml); } - result = (bool)(arg1)->reset(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Xml_setToChild(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; unsigned long arg2 ; bool result; - SWIG_check_num_args("ofXml::setToChild",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::setToChild",1,"ofXml *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofXml::setToChild",2,"unsigned long"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_setToChild",1,SWIGTYPE_p_ofXml); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (unsigned long)lua_tonumber(L, 2); - result = (bool)(arg1)->setToChild(arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_setTo(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; std::string *arg2 = 0 ; - std::string temp2 ; bool result; SWIG_check_num_args("ofXml::setTo",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::setTo",1,"ofXml *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofXml::setTo",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_setTo",1,SWIGTYPE_p_ofXml); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; result = (bool)(arg1)->setTo((std::string const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_setToParent__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; bool result; - SWIG_check_num_args("ofXml::setToParent",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::setToParent",1,"ofXml *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_setToParent",1,SWIGTYPE_p_ofXml); } - result = (bool)(arg1)->setToParent(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_setToParent__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; int arg2 ; bool result; - SWIG_check_num_args("ofXml::setToParent",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::setToParent",1,"ofXml *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofXml::setToParent",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_setToParent",1,SWIGTYPE_p_ofXml); } - arg2 = (int)lua_tonumber(L, 2); result = (bool)(arg1)->setToParent(arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_setToParent(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXml, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Xml_setToParent__SWIG_0(L);} } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofXml, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Xml_setToParent__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Xml_setToParent'\n" " Possible C/C++ prototypes are:\n" - " ofXml::setToParent()\n" " ofXml::setToParent(int)\n"); lua_error(L);return 0; } -static int _wrap_Xml_setToSibling(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; bool result; - SWIG_check_num_args("ofXml::setToSibling",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::setToSibling",1,"ofXml *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_setToSibling",1,SWIGTYPE_p_ofXml); } - result = (bool)(arg1)->setToSibling(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_setToPrevSibling(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; bool result; - SWIG_check_num_args("ofXml::setToPrevSibling",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::setToPrevSibling",1,"ofXml *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ - SWIG_fail_ptr("Xml_setToPrevSibling",1,SWIGTYPE_p_ofXml); } result = (bool)(arg1)->setToPrevSibling(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_loadFromBuffer(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; std::string *arg2 = 0 ; - std::string temp2 ; bool result; SWIG_check_num_args("ofXml::loadFromBuffer",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::loadFromBuffer",1,"ofXml *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofXml::loadFromBuffer",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ - SWIG_fail_ptr("Xml_loadFromBuffer",1,SWIGTYPE_p_ofXml); } temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = (bool)(arg1)->loadFromBuffer((std::string const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_toString(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; std::string result; - SWIG_check_num_args("ofXml::toString",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::toString",1,"ofXml const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_toString",1,SWIGTYPE_p_ofXml); } - result = ((ofXml const *)arg1)->toString(); lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_serialize(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; ofAbstractParameter *arg2 = 0 ; - SWIG_check_num_args("ofXml::serialize",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::serialize",1,"ofXml *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofXml::serialize",2,"ofAbstractParameter const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_serialize",1,SWIGTYPE_p_ofXml); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofAbstractParameter,0))){ - SWIG_fail_ptr("Xml_serialize",2,SWIGTYPE_p_ofAbstractParameter); } (arg1)->serialize((ofAbstractParameter const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_deserialize(lua_State* L) { int SWIG_arg = 0; ofXml *arg1 = (ofXml *) 0 ; ofAbstractParameter *arg2 = 0 ; - SWIG_check_num_args("ofXml::deserialize",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofXml::deserialize",1,"ofXml *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofXml::deserialize",2,"ofAbstractParameter &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofXml,0))){ SWIG_fail_ptr("Xml_deserialize",1,SWIGTYPE_p_ofXml); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofAbstractParameter,0))){ - SWIG_fail_ptr("Xml_deserialize",2,SWIGTYPE_p_ofAbstractParameter); } (arg1)->deserialize(*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Xml_tokenize(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; - std::string temp1 ; std::string temp2 ; std::vector< std::string > result; SWIG_check_num_args("ofXml::tokenize",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofXml::tokenize",1,"std::string const &"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofXml::tokenize",2,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = ofXml::tokenize((std::string const &)*arg1,(std::string const &)*arg2); { - std::vector< std::string > * resultptr = new std::vector< std::string >((const std::vector< std::string > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_std__string_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_Xml(void *obj) { -ofXml *arg1 = (ofXml *) obj; -delete arg1; -} -static int _proxy__wrap_new_Xml(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_Xml); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_Xml_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_Xml_methods[]= { - { "load", _wrap_Xml_load}, - { "save", _wrap_Xml_save}, - { "addChild", _wrap_Xml_addChild}, - { "addXml", _wrap_Xml_addXml}, - { "getValue", _wrap_Xml_getValue}, - { "getIntValue", _wrap_Xml_getIntValue}, - { "getInt64Value", _wrap_Xml_getInt64Value}, - { "getFloatValue", _wrap_Xml_getFloatValue}, - { "getBoolValue", _wrap_Xml_getBoolValue}, - { "setValue", _wrap_Xml_setValue}, - { "getAttribute", _wrap_Xml_getAttribute}, - { "setAttribute", _wrap_Xml_setAttribute}, - { "getAttributes", _wrap_Xml_getAttributes}, - { "getNumChildren", _wrap_Xml_getNumChildren}, - { "removeAttribute", _wrap_Xml_removeAttribute}, - { "removeAttributes", _wrap_Xml_removeAttributes}, - { "removeContents", _wrap_Xml_removeContents}, - { "remove", _wrap_Xml_remove}, - { "exists", _wrap_Xml_exists}, - { "clear", _wrap_Xml_clear}, - { "getName", _wrap_Xml_getName}, - { "reset", _wrap_Xml_reset}, - { "setToChild", _wrap_Xml_setToChild}, - { "setTo", _wrap_Xml_setTo}, - { "setToParent", _wrap_Xml_setToParent}, - { "setToSibling", _wrap_Xml_setToSibling}, - { "setToPrevSibling", _wrap_Xml_setToPrevSibling}, - { "loadFromBuffer", _wrap_Xml_loadFromBuffer}, - { "toString", _wrap_Xml_toString}, - { "serialize", _wrap_Xml_serialize}, - { "deserialize", _wrap_Xml_deserialize}, - {0,0} -}; -static swig_lua_method swig_Xml_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_Xml_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_Xml_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_Xml_Sf_SwigStatic_methods[]= { - { "tokenize", _wrap_Xml_tokenize}, - {0,0} -}; -static swig_lua_class* swig_Xml_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_Xml_Sf_SwigStatic = { - "Xml", - swig_Xml_Sf_SwigStatic_methods, - swig_Xml_Sf_SwigStatic_attributes, - swig_Xml_Sf_SwigStatic_constants, - swig_Xml_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_Xml_bases[] = {0}; -static const char *swig_Xml_base_names[] = {0}; -static swig_lua_class _wrap_class_Xml = { "Xml", "Xml", &SWIGTYPE_p_ofXml,_proxy__wrap_new_Xml, swig_delete_Xml, swig_Xml_methods, swig_Xml_attributes, &swig_Xml_Sf_SwigStatic, swig_Xml_meta, swig_Xml_bases, swig_Xml_base_names }; - -static int _wrap_new_MatrixStack(lua_State* L) { int SWIG_arg = 0; ofAppBaseWindow *arg1 = (ofAppBaseWindow *) 0 ; - ofMatrixStack *result = 0 ; SWIG_check_num_args("ofMatrixStack::ofMatrixStack",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::ofMatrixStack",1,"ofAppBaseWindow const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofAppBaseWindow,0))){ - SWIG_fail_ptr("new_MatrixStack",1,SWIGTYPE_p_ofAppBaseWindow); } - result = (ofMatrixStack *)new ofMatrixStack((ofAppBaseWindow const *)arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMatrixStack,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_MatrixStack_setRenderSurface__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; ofFbo *arg2 = 0 ; SWIG_check_num_args("ofMatrixStack::setRenderSurface",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::setRenderSurface",1,"ofMatrixStack *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrixStack::setRenderSurface",2,"ofFbo const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_setRenderSurface",1,SWIGTYPE_p_ofMatrixStack); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofFbo,0))){ - SWIG_fail_ptr("MatrixStack_setRenderSurface",2,SWIGTYPE_p_ofFbo); } (arg1)->setRenderSurface((ofFbo const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_MatrixStack_setRenderSurface__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; ofAppBaseWindow *arg2 = 0 ; - SWIG_check_num_args("ofMatrixStack::setRenderSurface",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::setRenderSurface",1,"ofMatrixStack *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrixStack::setRenderSurface",2,"ofAppBaseWindow const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_setRenderSurface",1,SWIGTYPE_p_ofMatrixStack); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofAppBaseWindow,0))){ - SWIG_fail_ptr("MatrixStack_setRenderSurface",2,SWIGTYPE_p_ofAppBaseWindow); } - (arg1)->setRenderSurface((ofAppBaseWindow const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_MatrixStack_setRenderSurface(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrixStack, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofFbo, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_MatrixStack_setRenderSurface__SWIG_0(L);} } } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrixStack, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofAppBaseWindow, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_MatrixStack_setRenderSurface__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'MatrixStack_setRenderSurface'\n" - " Possible C/C++ prototypes are:\n" " ofMatrixStack::setRenderSurface(ofFbo const &)\n" - " ofMatrixStack::setRenderSurface(ofAppBaseWindow const &)\n"); lua_error(L);return 0; } -static int _wrap_MatrixStack_setOrientation(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; - ofOrientation arg2 ; bool arg3 ; SWIG_check_num_args("ofMatrixStack::setOrientation",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::setOrientation",1,"ofMatrixStack *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrixStack::setOrientation",2,"ofOrientation"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofMatrixStack::setOrientation",3,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_setOrientation",1,SWIGTYPE_p_ofMatrixStack); } arg2 = (ofOrientation)(int)lua_tonumber(L, 2); - arg3 = (lua_toboolean(L, 3)!=0); (arg1)->setOrientation(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_MatrixStack_getOrientation(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; - ofOrientation result; SWIG_check_num_args("ofMatrixStack::getOrientation",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::getOrientation",1,"ofMatrixStack const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_getOrientation",1,SWIGTYPE_p_ofMatrixStack); } - result = (ofOrientation)((ofMatrixStack const *)arg1)->getOrientation(); - lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_MatrixStack_viewport(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; float arg2 ; - float arg3 ; float arg4 ; float arg5 ; bool arg6 ; SWIG_check_num_args("ofMatrixStack::viewport",6,6) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::viewport",1,"ofMatrixStack *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrixStack::viewport",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrixStack::viewport",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrixStack::viewport",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMatrixStack::viewport",5,"float"); - if(!lua_isboolean(L,6)) SWIG_fail_arg("ofMatrixStack::viewport",6,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_viewport",1,SWIGTYPE_p_ofMatrixStack); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - arg6 = (lua_toboolean(L, 6)!=0); (arg1)->viewport(arg2,arg3,arg4,arg5,arg6); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_MatrixStack_nativeViewport(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; - ofRectangle arg2 ; ofRectangle *argp2 ; SWIG_check_num_args("ofMatrixStack::nativeViewport",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::nativeViewport",1,"ofMatrixStack *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrixStack::nativeViewport",2,"ofRectangle"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_nativeViewport",1,SWIGTYPE_p_ofMatrixStack); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("MatrixStack_nativeViewport",2,SWIGTYPE_p_ofRectangle); } arg2 = *argp2; (arg1)->nativeViewport(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_MatrixStack_getCurrentViewport(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; - ofRectangle result; SWIG_check_num_args("ofMatrixStack::getCurrentViewport",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::getCurrentViewport",1,"ofMatrixStack const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_getCurrentViewport",1,SWIGTYPE_p_ofMatrixStack); } - result = ((ofMatrixStack const *)arg1)->getCurrentViewport(); { - ofRectangle * resultptr = new ofRectangle((const ofRectangle &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofRectangle,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_MatrixStack_getNativeViewport(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; - ofRectangle result; SWIG_check_num_args("ofMatrixStack::getNativeViewport",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::getNativeViewport",1,"ofMatrixStack const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_getNativeViewport",1,SWIGTYPE_p_ofMatrixStack); } - result = ((ofMatrixStack const *)arg1)->getNativeViewport(); { - ofRectangle * resultptr = new ofRectangle((const ofRectangle &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofRectangle,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_MatrixStack_getFullSurfaceViewport(lua_State* L) { int SWIG_arg = 0; - ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; ofRectangle result; - SWIG_check_num_args("ofMatrixStack::getFullSurfaceViewport",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::getFullSurfaceViewport",1,"ofMatrixStack const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_getFullSurfaceViewport",1,SWIGTYPE_p_ofMatrixStack); } - result = ((ofMatrixStack const *)arg1)->getFullSurfaceViewport(); { - ofRectangle * resultptr = new ofRectangle((const ofRectangle &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofRectangle,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_MatrixStack_getProjectionMatrix(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; - ofMatrix4x4 *result = 0 ; SWIG_check_num_args("ofMatrixStack::getProjectionMatrix",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::getProjectionMatrix",1,"ofMatrixStack const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_getProjectionMatrix",1,SWIGTYPE_p_ofMatrixStack); } - result = (ofMatrix4x4 *) &((ofMatrixStack const *)arg1)->getProjectionMatrix(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMatrix4x4,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_MatrixStack_getViewMatrix(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; - ofMatrix4x4 *result = 0 ; SWIG_check_num_args("ofMatrixStack::getViewMatrix",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::getViewMatrix",1,"ofMatrixStack const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_getViewMatrix",1,SWIGTYPE_p_ofMatrixStack); } - result = (ofMatrix4x4 *) &((ofMatrixStack const *)arg1)->getViewMatrix(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMatrix4x4,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_MatrixStack_getModelViewMatrix(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; - ofMatrix4x4 *result = 0 ; SWIG_check_num_args("ofMatrixStack::getModelViewMatrix",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::getModelViewMatrix",1,"ofMatrixStack const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_getModelViewMatrix",1,SWIGTYPE_p_ofMatrixStack); } - result = (ofMatrix4x4 *) &((ofMatrixStack const *)arg1)->getModelViewMatrix(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMatrix4x4,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_MatrixStack_getModelViewProjectionMatrix(lua_State* L) { int SWIG_arg = 0; - ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; ofMatrix4x4 *result = 0 ; - SWIG_check_num_args("ofMatrixStack::getModelViewProjectionMatrix",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::getModelViewProjectionMatrix",1,"ofMatrixStack const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_getModelViewProjectionMatrix",1,SWIGTYPE_p_ofMatrixStack); } - result = (ofMatrix4x4 *) &((ofMatrixStack const *)arg1)->getModelViewProjectionMatrix(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMatrix4x4,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_MatrixStack_getTextureMatrix(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; - ofMatrix4x4 *result = 0 ; SWIG_check_num_args("ofMatrixStack::getTextureMatrix",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::getTextureMatrix",1,"ofMatrixStack const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_getTextureMatrix",1,SWIGTYPE_p_ofMatrixStack); } - result = (ofMatrix4x4 *) &((ofMatrixStack const *)arg1)->getTextureMatrix(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMatrix4x4,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_MatrixStack_getCurrentMatrix(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; - ofMatrix4x4 *result = 0 ; SWIG_check_num_args("ofMatrixStack::getCurrentMatrix",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::getCurrentMatrix",1,"ofMatrixStack const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_getCurrentMatrix",1,SWIGTYPE_p_ofMatrixStack); } - result = (ofMatrix4x4 *) &((ofMatrixStack const *)arg1)->getCurrentMatrix(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMatrix4x4,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_MatrixStack_getProjectionMatrixNoOrientation(lua_State* L) { int SWIG_arg = 0; - ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; ofMatrix4x4 *result = 0 ; - SWIG_check_num_args("ofMatrixStack::getProjectionMatrixNoOrientation",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::getProjectionMatrixNoOrientation",1,"ofMatrixStack const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_getProjectionMatrixNoOrientation",1,SWIGTYPE_p_ofMatrixStack); } - result = (ofMatrix4x4 *) &((ofMatrixStack const *)arg1)->getProjectionMatrixNoOrientation(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMatrix4x4,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_MatrixStack_getOrientationMatrix(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; - ofMatrix4x4 *result = 0 ; SWIG_check_num_args("ofMatrixStack::getOrientationMatrix",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::getOrientationMatrix",1,"ofMatrixStack const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_getOrientationMatrix",1,SWIGTYPE_p_ofMatrixStack); } - result = (ofMatrix4x4 *) &((ofMatrixStack const *)arg1)->getOrientationMatrix(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMatrix4x4,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_MatrixStack_getOrientationMatrixInverse(lua_State* L) { int SWIG_arg = 0; - ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; ofMatrix4x4 *result = 0 ; - SWIG_check_num_args("ofMatrixStack::getOrientationMatrixInverse",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::getOrientationMatrixInverse",1,"ofMatrixStack const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_getOrientationMatrixInverse",1,SWIGTYPE_p_ofMatrixStack); } - result = (ofMatrix4x4 *) &((ofMatrixStack const *)arg1)->getOrientationMatrixInverse(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofMatrix4x4,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_MatrixStack_getCurrentMatrixMode(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; - ofMatrixMode result; SWIG_check_num_args("ofMatrixStack::getCurrentMatrixMode",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::getCurrentMatrixMode",1,"ofMatrixStack const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_getCurrentMatrixMode",1,SWIGTYPE_p_ofMatrixStack); } - result = (ofMatrixMode)((ofMatrixStack const *)arg1)->getCurrentMatrixMode(); - lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_MatrixStack_getHandedness(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; - ofHandednessType result; SWIG_check_num_args("ofMatrixStack::getHandedness",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::getHandedness",1,"ofMatrixStack const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_getHandedness",1,SWIGTYPE_p_ofMatrixStack); } - result = (ofHandednessType)((ofMatrixStack const *)arg1)->getHandedness(); - lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_MatrixStack_isVFlipped(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; - bool result; SWIG_check_num_args("ofMatrixStack::isVFlipped",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::isVFlipped",1,"ofMatrixStack const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_isVFlipped",1,SWIGTYPE_p_ofMatrixStack); } - result = (bool)((ofMatrixStack const *)arg1)->isVFlipped(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_MatrixStack_customMatrixNeedsFlip(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; - bool result; SWIG_check_num_args("ofMatrixStack::customMatrixNeedsFlip",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::customMatrixNeedsFlip",1,"ofMatrixStack const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_customMatrixNeedsFlip",1,SWIGTYPE_p_ofMatrixStack); } - result = (bool)((ofMatrixStack const *)arg1)->customMatrixNeedsFlip(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_MatrixStack_pushView(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; - SWIG_check_num_args("ofMatrixStack::pushView",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::pushView",1,"ofMatrixStack *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_pushView",1,SWIGTYPE_p_ofMatrixStack); } (arg1)->pushView(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_MatrixStack_popView(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; - SWIG_check_num_args("ofMatrixStack::popView",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::popView",1,"ofMatrixStack *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_popView",1,SWIGTYPE_p_ofMatrixStack); } (arg1)->popView(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_MatrixStack_pushMatrix(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; - SWIG_check_num_args("ofMatrixStack::pushMatrix",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::pushMatrix",1,"ofMatrixStack *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_pushMatrix",1,SWIGTYPE_p_ofMatrixStack); } (arg1)->pushMatrix(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_MatrixStack_popMatrix(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; - SWIG_check_num_args("ofMatrixStack::popMatrix",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::popMatrix",1,"ofMatrixStack *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_popMatrix",1,SWIGTYPE_p_ofMatrixStack); } (arg1)->popMatrix(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_MatrixStack_translate__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; - float arg2 ; float arg3 ; float arg4 ; SWIG_check_num_args("ofMatrixStack::translate",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::translate",1,"ofMatrixStack *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrixStack::translate",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrixStack::translate",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrixStack::translate",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_translate",1,SWIGTYPE_p_ofMatrixStack); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); (arg1)->translate(arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_MatrixStack_translate__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; - float arg2 ; float arg3 ; SWIG_check_num_args("ofMatrixStack::translate",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::translate",1,"ofMatrixStack *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrixStack::translate",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrixStack::translate",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_translate",1,SWIGTYPE_p_ofMatrixStack); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->translate(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_MatrixStack_translate(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); - if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrixStack, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_MatrixStack_translate__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrixStack, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_MatrixStack_translate__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'MatrixStack_translate'\n" - " Possible C/C++ prototypes are:\n" " ofMatrixStack::translate(float,float,float)\n" - " ofMatrixStack::translate(float,float)\n"); lua_error(L);return 0; } -static int _wrap_MatrixStack_scale__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; - float arg2 ; float arg3 ; float arg4 ; SWIG_check_num_args("ofMatrixStack::scale",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::scale",1,"ofMatrixStack *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrixStack::scale",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrixStack::scale",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrixStack::scale",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_scale",1,SWIGTYPE_p_ofMatrixStack); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); (arg1)->scale(arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_MatrixStack_scale__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; - float arg2 ; float arg3 ; SWIG_check_num_args("ofMatrixStack::scale",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::scale",1,"ofMatrixStack *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrixStack::scale",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrixStack::scale",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_scale",1,SWIGTYPE_p_ofMatrixStack); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->scale(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_MatrixStack_scale(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrixStack, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_MatrixStack_scale__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofMatrixStack, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { return _wrap_MatrixStack_scale__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'MatrixStack_scale'\n" " Possible C/C++ prototypes are:\n" - " ofMatrixStack::scale(float,float,float)\n" " ofMatrixStack::scale(float,float)\n"); lua_error(L);return 0; } -static int _wrap_MatrixStack_rotate(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; float arg2 ; - float arg3 ; float arg4 ; float arg5 ; SWIG_check_num_args("ofMatrixStack::rotate",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::rotate",1,"ofMatrixStack *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrixStack::rotate",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofMatrixStack::rotate",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofMatrixStack::rotate",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofMatrixStack::rotate",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_rotate",1,SWIGTYPE_p_ofMatrixStack); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - (arg1)->rotate(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_MatrixStack_matrixMode(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; - ofMatrixMode arg2 ; SWIG_check_num_args("ofMatrixStack::matrixMode",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::matrixMode",1,"ofMatrixStack *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofMatrixStack::matrixMode",2,"ofMatrixMode"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_matrixMode",1,SWIGTYPE_p_ofMatrixStack); } arg2 = (ofMatrixMode)(int)lua_tonumber(L, 2); - (arg1)->matrixMode(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_MatrixStack_loadIdentityMatrix(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; - SWIG_check_num_args("ofMatrixStack::loadIdentityMatrix",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::loadIdentityMatrix",1,"ofMatrixStack *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_loadIdentityMatrix",1,SWIGTYPE_p_ofMatrixStack); } (arg1)->loadIdentityMatrix(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_MatrixStack_loadMatrix(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; - float *arg2 = (float *) 0 ; SWIG_check_num_args("ofMatrixStack::loadMatrix",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::loadMatrix",1,"ofMatrixStack *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofMatrixStack::loadMatrix",2,"float const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_loadMatrix",1,SWIGTYPE_p_ofMatrixStack); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("MatrixStack_loadMatrix",2,SWIGTYPE_p_float); } (arg1)->loadMatrix((float const *)arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_MatrixStack_multMatrix(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; - float *arg2 = (float *) 0 ; SWIG_check_num_args("ofMatrixStack::multMatrix",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::multMatrix",1,"ofMatrixStack *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofMatrixStack::multMatrix",2,"float const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_multMatrix",1,SWIGTYPE_p_ofMatrixStack); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_float,0))){ - SWIG_fail_ptr("MatrixStack_multMatrix",2,SWIGTYPE_p_float); } (arg1)->multMatrix((float const *)arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_MatrixStack_loadViewMatrix(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; - ofMatrix4x4 *arg2 = 0 ; SWIG_check_num_args("ofMatrixStack::loadViewMatrix",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::loadViewMatrix",1,"ofMatrixStack *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrixStack::loadViewMatrix",2,"ofMatrix4x4 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_loadViewMatrix",1,SWIGTYPE_p_ofMatrixStack); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("MatrixStack_loadViewMatrix",2,SWIGTYPE_p_ofMatrix4x4); } (arg1)->loadViewMatrix((ofMatrix4x4 const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_MatrixStack_multViewMatrix(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; - ofMatrix4x4 *arg2 = 0 ; SWIG_check_num_args("ofMatrixStack::multViewMatrix",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::multViewMatrix",1,"ofMatrixStack *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofMatrixStack::multViewMatrix",2,"ofMatrix4x4 const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_multViewMatrix",1,SWIGTYPE_p_ofMatrixStack); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofMatrix4x4,0))){ - SWIG_fail_ptr("MatrixStack_multViewMatrix",2,SWIGTYPE_p_ofMatrix4x4); } (arg1)->multViewMatrix((ofMatrix4x4 const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_MatrixStack_clearStacks(lua_State* L) { int SWIG_arg = 0; ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; - SWIG_check_num_args("ofMatrixStack::clearStacks",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::clearStacks",1,"ofMatrixStack *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_clearStacks",1,SWIGTYPE_p_ofMatrixStack); } (arg1)->clearStacks(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_MatrixStack_doesHardwareOrientation(lua_State* L) { int SWIG_arg = 0; - ofMatrixStack *arg1 = (ofMatrixStack *) 0 ; bool result; SWIG_check_num_args("ofMatrixStack::doesHardwareOrientation",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofMatrixStack::doesHardwareOrientation",1,"ofMatrixStack const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofMatrixStack,0))){ - SWIG_fail_ptr("MatrixStack_doesHardwareOrientation",1,SWIGTYPE_p_ofMatrixStack); } - result = (bool)((ofMatrixStack const *)arg1)->doesHardwareOrientation(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_MatrixStack(void *obj) { -ofMatrixStack *arg1 = (ofMatrixStack *) obj; -delete arg1; -} -static int _proxy__wrap_new_MatrixStack(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_MatrixStack); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_MatrixStack_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_MatrixStack_methods[]= { - { "setRenderSurface", _wrap_MatrixStack_setRenderSurface}, - { "setOrientation", _wrap_MatrixStack_setOrientation}, - { "getOrientation", _wrap_MatrixStack_getOrientation}, - { "viewport", _wrap_MatrixStack_viewport}, - { "nativeViewport", _wrap_MatrixStack_nativeViewport}, - { "getCurrentViewport", _wrap_MatrixStack_getCurrentViewport}, - { "getNativeViewport", _wrap_MatrixStack_getNativeViewport}, - { "getFullSurfaceViewport", _wrap_MatrixStack_getFullSurfaceViewport}, - { "getProjectionMatrix", _wrap_MatrixStack_getProjectionMatrix}, - { "getViewMatrix", _wrap_MatrixStack_getViewMatrix}, - { "getModelViewMatrix", _wrap_MatrixStack_getModelViewMatrix}, - { "getModelViewProjectionMatrix", _wrap_MatrixStack_getModelViewProjectionMatrix}, - { "getTextureMatrix", _wrap_MatrixStack_getTextureMatrix}, - { "getCurrentMatrix", _wrap_MatrixStack_getCurrentMatrix}, - { "getProjectionMatrixNoOrientation", _wrap_MatrixStack_getProjectionMatrixNoOrientation}, - { "getOrientationMatrix", _wrap_MatrixStack_getOrientationMatrix}, - { "getOrientationMatrixInverse", _wrap_MatrixStack_getOrientationMatrixInverse}, - { "getCurrentMatrixMode", _wrap_MatrixStack_getCurrentMatrixMode}, - { "getHandedness", _wrap_MatrixStack_getHandedness}, - { "isVFlipped", _wrap_MatrixStack_isVFlipped}, - { "customMatrixNeedsFlip", _wrap_MatrixStack_customMatrixNeedsFlip}, - { "pushView", _wrap_MatrixStack_pushView}, - { "popView", _wrap_MatrixStack_popView}, - { "pushMatrix", _wrap_MatrixStack_pushMatrix}, - { "popMatrix", _wrap_MatrixStack_popMatrix}, - { "translate", _wrap_MatrixStack_translate}, - { "scale", _wrap_MatrixStack_scale}, - { "rotate", _wrap_MatrixStack_rotate}, - { "matrixMode", _wrap_MatrixStack_matrixMode}, - { "loadIdentityMatrix", _wrap_MatrixStack_loadIdentityMatrix}, - { "loadMatrix", _wrap_MatrixStack_loadMatrix}, - { "multMatrix", _wrap_MatrixStack_multMatrix}, - { "loadViewMatrix", _wrap_MatrixStack_loadViewMatrix}, - { "multViewMatrix", _wrap_MatrixStack_multViewMatrix}, - { "clearStacks", _wrap_MatrixStack_clearStacks}, - { "doesHardwareOrientation", _wrap_MatrixStack_doesHardwareOrientation}, - {0,0} -}; -static swig_lua_method swig_MatrixStack_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_MatrixStack_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_MatrixStack_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_MatrixStack_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_MatrixStack_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_MatrixStack_Sf_SwigStatic = { - "MatrixStack", - swig_MatrixStack_Sf_SwigStatic_methods, - swig_MatrixStack_Sf_SwigStatic_attributes, - swig_MatrixStack_Sf_SwigStatic_constants, - swig_MatrixStack_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_MatrixStack_bases[] = {0}; -static const char *swig_MatrixStack_base_names[] = {0}; -static swig_lua_class _wrap_class_MatrixStack = { "MatrixStack", "MatrixStack", &SWIGTYPE_p_ofMatrixStack,_proxy__wrap_new_MatrixStack, swig_delete_MatrixStack, swig_MatrixStack_methods, swig_MatrixStack_attributes, &swig_MatrixStack_Sf_SwigStatic, swig_MatrixStack_meta, swig_MatrixStack_bases, swig_MatrixStack_base_names }; - -static int _wrap_new_Buffer__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofBuffer *result = 0 ; - SWIG_check_num_args("ofBuffer::ofBuffer",0,0) result = (ofBuffer *)new ofBuffer(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofBuffer,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Buffer__SWIG_1(lua_State* L) { int SWIG_arg = 0; char *arg1 = (char *) 0 ; std::size_t arg2 ; - ofBuffer *result = 0 ; SWIG_check_num_args("ofBuffer::ofBuffer",1,1) { arg2 = (size_t)lua_tonumber(L, 1+1); - arg1 = (char *)lua_tolstring(L, 1, &arg2); } result = (ofBuffer *)new ofBuffer((char const *)arg1,arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofBuffer,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Buffer(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_Buffer__SWIG_0(L);} if (argc == 1) { int _v; { _v = SWIG_lua_isnilstring(L,argv[0]); } if (_v) { - if (argc <= 1) { return _wrap_new_Buffer__SWIG_1(L);} { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_new_Buffer__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_Buffer'\n" " Possible C/C++ prototypes are:\n" - " ofBuffer::ofBuffer()\n" " ofBuffer::ofBuffer(char const *,std::size_t)\n"); lua_error(L);return 0; } -static int _wrap_Buffer_set(lua_State* L) { int SWIG_arg = 0; ofBuffer *arg1 = (ofBuffer *) 0 ; char *arg2 = (char *) 0 ; - std::size_t arg3 ; SWIG_check_num_args("ofBuffer::set",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBuffer::set",1,"ofBuffer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBuffer,0))){ SWIG_fail_ptr("Buffer_set",1,SWIGTYPE_p_ofBuffer); } - { arg3 = (size_t)lua_tonumber(L, 2+1); arg2 = (char *)lua_tolstring(L, 2, &arg3); } (arg1)->set((char const *)arg2,arg3); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Buffer_append(lua_State* L) { int SWIG_arg = 0; ofBuffer *arg1 = (ofBuffer *) 0 ; char *arg2 = (char *) 0 ; - std::size_t arg3 ; SWIG_check_num_args("ofBuffer::append",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBuffer::append",1,"ofBuffer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBuffer,0))){ - SWIG_fail_ptr("Buffer_append",1,SWIGTYPE_p_ofBuffer); } { arg3 = (size_t)lua_tonumber(L, 2+1); - arg2 = (char *)lua_tolstring(L, 2, &arg3); } (arg1)->append((char const *)arg2,arg3); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Buffer_clear(lua_State* L) { int SWIG_arg = 0; ofBuffer *arg1 = (ofBuffer *) 0 ; - SWIG_check_num_args("ofBuffer::clear",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBuffer::clear",1,"ofBuffer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBuffer,0))){ - SWIG_fail_ptr("Buffer_clear",1,SWIGTYPE_p_ofBuffer); } (arg1)->clear(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Buffer_allocate(lua_State* L) { int SWIG_arg = 0; ofBuffer *arg1 = (ofBuffer *) 0 ; std::size_t arg2 ; - SWIG_check_num_args("ofBuffer::allocate",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBuffer::allocate",1,"ofBuffer *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofBuffer::allocate",2,"std::size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBuffer,0))){ - SWIG_fail_ptr("Buffer_allocate",1,SWIGTYPE_p_ofBuffer); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (std::size_t)lua_tonumber(L, 2); - (arg1)->allocate(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Buffer_getData(lua_State* L) { int SWIG_arg = 0; ofBuffer *arg1 = (ofBuffer *) 0 ; char *result = 0 ; - SWIG_check_num_args("ofBuffer::getData",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBuffer::getData",1,"ofBuffer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBuffer,0))){ - SWIG_fail_ptr("Buffer_getData",1,SWIGTYPE_p_ofBuffer); } result = (char *)((ofBuffer const *)arg1)->getData(); - lua_pushstring(L,(const char *)result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Buffer_getText(lua_State* L) { int SWIG_arg = 0; ofBuffer *arg1 = (ofBuffer *) 0 ; std::string result; - SWIG_check_num_args("ofBuffer::getText",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBuffer::getText",1,"ofBuffer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBuffer,0))){ - SWIG_fail_ptr("Buffer_getText",1,SWIGTYPE_p_ofBuffer); } result = ((ofBuffer const *)arg1)->getText(); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Buffer_size(lua_State* L) { int SWIG_arg = 0; ofBuffer *arg1 = (ofBuffer *) 0 ; long result; - SWIG_check_num_args("ofBuffer::size",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofBuffer::size",1,"ofBuffer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofBuffer,0))){ - SWIG_fail_ptr("Buffer_size",1,SWIGTYPE_p_ofBuffer); } result = (long)((ofBuffer const *)arg1)->size(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_Buffer(void *obj) { -ofBuffer *arg1 = (ofBuffer *) obj; -delete arg1; -} -static int _proxy__wrap_new_Buffer(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_Buffer); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_Buffer_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_Buffer_methods[]= { - { "set", _wrap_Buffer_set}, - { "append", _wrap_Buffer_append}, - { "clear", _wrap_Buffer_clear}, - { "allocate", _wrap_Buffer_allocate}, - { "getData", _wrap_Buffer_getData}, - { "getText", _wrap_Buffer_getText}, - { "size", _wrap_Buffer_size}, - {0,0} -}; -static swig_lua_method swig_Buffer_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_Buffer_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_Buffer_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_Buffer_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_Buffer_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_Buffer_Sf_SwigStatic = { - "Buffer", - swig_Buffer_Sf_SwigStatic_methods, - swig_Buffer_Sf_SwigStatic_attributes, - swig_Buffer_Sf_SwigStatic_constants, - swig_Buffer_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_Buffer_bases[] = {0}; -static const char *swig_Buffer_base_names[] = {0}; -static swig_lua_class _wrap_class_Buffer = { "Buffer", "Buffer", &SWIGTYPE_p_ofBuffer,_proxy__wrap_new_Buffer, swig_delete_Buffer, swig_Buffer_methods, swig_Buffer_attributes, &swig_Buffer_Sf_SwigStatic, swig_Buffer_meta, swig_Buffer_bases, swig_Buffer_base_names }; - -static int _wrap_bufferFromFile__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; bool arg2 ; - std::string temp1 ; ofBuffer result; SWIG_check_num_args("ofBufferFromFile",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofBufferFromFile",1,"std::string const &"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofBufferFromFile",2,"bool"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; arg2 = (lua_toboolean(L, 2)!=0); - result = ofBufferFromFile((std::string const &)*arg1,arg2); { ofBuffer * resultptr = new ofBuffer((const ofBuffer &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofBuffer,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_bufferFromFile__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - ofBuffer result; SWIG_check_num_args("ofBufferFromFile",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofBufferFromFile",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = ofBufferFromFile((std::string const &)*arg1); { - ofBuffer * resultptr = new ofBuffer((const ofBuffer &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofBuffer,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_bufferFromFile(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; - { _v = lua_isstring(L,argv[0]); } if (_v) { return _wrap_bufferFromFile__SWIG_1(L);} } if (argc == 2) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_bufferFromFile__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'bufferFromFile'\n" " Possible C/C++ prototypes are:\n" - " ofBufferFromFile(std::string const &,bool)\n" " ofBufferFromFile(std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_bufferToFile__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; ofBuffer *arg2 = 0 ; bool arg3 ; - std::string temp1 ; bool result; SWIG_check_num_args("ofBufferToFile",3,3) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofBufferToFile",1,"std::string const &"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofBufferToFile",2,"ofBuffer &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofBufferToFile",3,"bool"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBuffer,0))){ - SWIG_fail_ptr("bufferToFile",2,SWIGTYPE_p_ofBuffer); } arg3 = (lua_toboolean(L, 3)!=0); - result = (bool)ofBufferToFile((std::string const &)*arg1,*arg2,arg3); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_bufferToFile__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; ofBuffer *arg2 = 0 ; - std::string temp1 ; bool result; SWIG_check_num_args("ofBufferToFile",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofBufferToFile",1,"std::string const &"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofBufferToFile",2,"ofBuffer &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBuffer,0))){ - SWIG_fail_ptr("bufferToFile",2,SWIGTYPE_p_ofBuffer); } result = (bool)ofBufferToFile((std::string const &)*arg1,*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_bufferToFile(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { int _v; - { _v = lua_isstring(L,argv[0]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBuffer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_bufferToFile__SWIG_1(L);} } } if (argc == 3) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBuffer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { return _wrap_bufferToFile__SWIG_0(L);} } - } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'bufferToFile'\n" - " Possible C/C++ prototypes are:\n" " ofBufferToFile(std::string const &,ofBuffer &,bool)\n" - " ofBufferToFile(std::string const &,ofBuffer &)\n"); lua_error(L);return 0; } -static int _wrap_FilePath_getFileExt(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - std::string result; SWIG_check_num_args("ofFilePath::getFileExt",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFilePath::getFileExt",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = ofFilePath::getFileExt((std::string const &)*arg1); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FilePath_removeExt(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - std::string result; SWIG_check_num_args("ofFilePath::removeExt",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFilePath::removeExt",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = ofFilePath::removeExt((std::string const &)*arg1); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FilePath_addLeadingSlash(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - std::string result; SWIG_check_num_args("ofFilePath::addLeadingSlash",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFilePath::addLeadingSlash",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; - result = ofFilePath::addLeadingSlash((std::string const &)*arg1); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FilePath_addTrailingSlash(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - std::string result; SWIG_check_num_args("ofFilePath::addTrailingSlash",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFilePath::addTrailingSlash",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; - result = ofFilePath::addTrailingSlash((std::string const &)*arg1); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FilePath_removeTrailingSlash(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - std::string result; SWIG_check_num_args("ofFilePath::removeTrailingSlash",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFilePath::removeTrailingSlash",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; - result = ofFilePath::removeTrailingSlash((std::string const &)*arg1); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FilePath_getPathForDirectory(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - std::string result; SWIG_check_num_args("ofFilePath::getPathForDirectory",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFilePath::getPathForDirectory",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; - result = ofFilePath::getPathForDirectory((std::string const &)*arg1); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FilePath_getAbsolutePath__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; bool arg2 ; - std::string temp1 ; std::string result; SWIG_check_num_args("ofFilePath::getAbsolutePath",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFilePath::getAbsolutePath",1,"std::string const &"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofFilePath::getAbsolutePath",2,"bool"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; arg2 = (lua_toboolean(L, 2)!=0); - result = ofFilePath::getAbsolutePath((std::string const &)*arg1,arg2); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FilePath_getAbsolutePath__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - std::string result; SWIG_check_num_args("ofFilePath::getAbsolutePath",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFilePath::getAbsolutePath",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; - result = ofFilePath::getAbsolutePath((std::string const &)*arg1); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FilePath_getAbsolutePath(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); - if (argc == 1) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { return _wrap_FilePath_getAbsolutePath__SWIG_1(L);} } - if (argc == 2) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_FilePath_getAbsolutePath__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FilePath_getAbsolutePath'\n" - " Possible C/C++ prototypes are:\n" " ofFilePath::getAbsolutePath(std::string const &,bool)\n" - " ofFilePath::getAbsolutePath(std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_FilePath_isAbsolute(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; bool result; - SWIG_check_num_args("ofFilePath::isAbsolute",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFilePath::isAbsolute",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; - result = (bool)ofFilePath::isAbsolute((std::string const &)*arg1); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FilePath_getFileName__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; bool arg2 ; - std::string temp1 ; std::string result; SWIG_check_num_args("ofFilePath::getFileName",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFilePath::getFileName",1,"std::string const &"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofFilePath::getFileName",2,"bool"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; arg2 = (lua_toboolean(L, 2)!=0); - result = ofFilePath::getFileName((std::string const &)*arg1,arg2); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FilePath_getFileName__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - std::string result; SWIG_check_num_args("ofFilePath::getFileName",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFilePath::getFileName",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = ofFilePath::getFileName((std::string const &)*arg1); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FilePath_getFileName(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { return _wrap_FilePath_getFileName__SWIG_1(L);} } if (argc == 2) { - int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_FilePath_getFileName__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FilePath_getFileName'\n" - " Possible C/C++ prototypes are:\n" " ofFilePath::getFileName(std::string const &,bool)\n" - " ofFilePath::getFileName(std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_FilePath_getBaseName(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - std::string result; SWIG_check_num_args("ofFilePath::getBaseName",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFilePath::getBaseName",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = ofFilePath::getBaseName((std::string const &)*arg1); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FilePath_getEnclosingDirectory__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; bool arg2 ; - std::string temp1 ; std::string result; SWIG_check_num_args("ofFilePath::getEnclosingDirectory",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFilePath::getEnclosingDirectory",1,"std::string const &"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofFilePath::getEnclosingDirectory",2,"bool"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; arg2 = (lua_toboolean(L, 2)!=0); - result = ofFilePath::getEnclosingDirectory((std::string const &)*arg1,arg2); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FilePath_getEnclosingDirectory__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; - std::string temp1 ; std::string result; SWIG_check_num_args("ofFilePath::getEnclosingDirectory",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFilePath::getEnclosingDirectory",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; - result = ofFilePath::getEnclosingDirectory((std::string const &)*arg1); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FilePath_getEnclosingDirectory(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); - if (argc == 1) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { return _wrap_FilePath_getEnclosingDirectory__SWIG_1(L);} - } if (argc == 2) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_FilePath_getEnclosingDirectory__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FilePath_getEnclosingDirectory'\n" - " Possible C/C++ prototypes are:\n" " ofFilePath::getEnclosingDirectory(std::string const &,bool)\n" - " ofFilePath::getEnclosingDirectory(std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_FilePath_createEnclosingDirectory__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; bool arg2 ; - bool arg3 ; std::string temp1 ; bool result; SWIG_check_num_args("ofFilePath::createEnclosingDirectory",3,3) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFilePath::createEnclosingDirectory",1,"std::string const &"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofFilePath::createEnclosingDirectory",2,"bool"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofFilePath::createEnclosingDirectory",3,"bool"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; arg2 = (lua_toboolean(L, 2)!=0); - arg3 = (lua_toboolean(L, 3)!=0); result = (bool)ofFilePath::createEnclosingDirectory((std::string const &)*arg1,arg2,arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FilePath_createEnclosingDirectory__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; bool arg2 ; - std::string temp1 ; bool result; SWIG_check_num_args("ofFilePath::createEnclosingDirectory",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFilePath::createEnclosingDirectory",1,"std::string const &"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofFilePath::createEnclosingDirectory",2,"bool"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; arg2 = (lua_toboolean(L, 2)!=0); - result = (bool)ofFilePath::createEnclosingDirectory((std::string const &)*arg1,arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FilePath_createEnclosingDirectory__SWIG_2(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; - std::string temp1 ; bool result; SWIG_check_num_args("ofFilePath::createEnclosingDirectory",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFilePath::createEnclosingDirectory",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; - result = (bool)ofFilePath::createEnclosingDirectory((std::string const &)*arg1); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FilePath_createEnclosingDirectory(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); - if (argc == 1) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { - return _wrap_FilePath_createEnclosingDirectory__SWIG_2(L);} } if (argc == 2) { int _v; { _v = lua_isstring(L,argv[0]); } - if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { return _wrap_FilePath_createEnclosingDirectory__SWIG_1(L);} } } - if (argc == 3) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { { - _v = lua_isboolean(L,argv[2]); } if (_v) { return _wrap_FilePath_createEnclosingDirectory__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'FilePath_createEnclosingDirectory'\n" - " Possible C/C++ prototypes are:\n" " ofFilePath::createEnclosingDirectory(std::string const &,bool,bool)\n" - " ofFilePath::createEnclosingDirectory(std::string const &,bool)\n" - " ofFilePath::createEnclosingDirectory(std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_FilePath_getCurrentWorkingDirectory(lua_State* L) { int SWIG_arg = 0; std::string result; - SWIG_check_num_args("ofFilePath::getCurrentWorkingDirectory",0,0) result = ofFilePath::getCurrentWorkingDirectory(); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FilePath_join(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; - std::string temp1 ; std::string temp2 ; std::string result; SWIG_check_num_args("ofFilePath::join",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFilePath::join",1,"std::string const &"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofFilePath::join",2,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = ofFilePath::join((std::string const &)*arg1,(std::string const &)*arg2); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FilePath_getCurrentExePath(lua_State* L) { int SWIG_arg = 0; std::string result; - SWIG_check_num_args("ofFilePath::getCurrentExePath",0,0) result = ofFilePath::getCurrentExePath(); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FilePath_getCurrentExeDir(lua_State* L) { int SWIG_arg = 0; std::string result; - SWIG_check_num_args("ofFilePath::getCurrentExeDir",0,0) result = ofFilePath::getCurrentExeDir(); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FilePath_getUserHomeDir(lua_State* L) { int SWIG_arg = 0; std::string result; - SWIG_check_num_args("ofFilePath::getUserHomeDir",0,0) result = ofFilePath::getUserHomeDir(); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FilePath_makeRelative(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; - std::string temp1 ; std::string temp2 ; std::string result; SWIG_check_num_args("ofFilePath::makeRelative",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFilePath::makeRelative",1,"std::string const &"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofFilePath::makeRelative",2,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = ofFilePath::makeRelative((std::string const &)*arg1,(std::string const &)*arg2); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_FilePath(lua_State* L) { int SWIG_arg = 0; ofFilePath *result = 0 ; - SWIG_check_num_args("ofFilePath::ofFilePath",0,0) result = (ofFilePath *)new ofFilePath(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofFilePath,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static void swig_delete_FilePath(void *obj) { -ofFilePath *arg1 = (ofFilePath *) obj; -delete arg1; -} -static int _proxy__wrap_new_FilePath(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_FilePath); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_FilePath_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_FilePath_methods[]= { - {0,0} -}; -static swig_lua_method swig_FilePath_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_FilePath_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_FilePath_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_FilePath_Sf_SwigStatic_methods[]= { - { "getFileExt", _wrap_FilePath_getFileExt}, - { "removeExt", _wrap_FilePath_removeExt}, - { "addLeadingSlash", _wrap_FilePath_addLeadingSlash}, - { "addTrailingSlash", _wrap_FilePath_addTrailingSlash}, - { "removeTrailingSlash", _wrap_FilePath_removeTrailingSlash}, - { "getPathForDirectory", _wrap_FilePath_getPathForDirectory}, - { "getAbsolutePath", _wrap_FilePath_getAbsolutePath}, - { "isAbsolute", _wrap_FilePath_isAbsolute}, - { "getFileName", _wrap_FilePath_getFileName}, - { "getBaseName", _wrap_FilePath_getBaseName}, - { "getEnclosingDirectory", _wrap_FilePath_getEnclosingDirectory}, - { "createEnclosingDirectory", _wrap_FilePath_createEnclosingDirectory}, - { "getCurrentWorkingDirectory", _wrap_FilePath_getCurrentWorkingDirectory}, - { "join", _wrap_FilePath_join}, - { "getCurrentExePath", _wrap_FilePath_getCurrentExePath}, - { "getCurrentExeDir", _wrap_FilePath_getCurrentExeDir}, - { "getUserHomeDir", _wrap_FilePath_getUserHomeDir}, - { "makeRelative", _wrap_FilePath_makeRelative}, - {0,0} -}; -static swig_lua_class* swig_FilePath_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_FilePath_Sf_SwigStatic = { - "FilePath", - swig_FilePath_Sf_SwigStatic_methods, - swig_FilePath_Sf_SwigStatic_attributes, - swig_FilePath_Sf_SwigStatic_constants, - swig_FilePath_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_FilePath_bases[] = {0}; -static const char *swig_FilePath_base_names[] = {0}; -static swig_lua_class _wrap_class_FilePath = { "FilePath", "FilePath", &SWIGTYPE_p_ofFilePath,_proxy__wrap_new_FilePath, swig_delete_FilePath, swig_FilePath_methods, swig_FilePath_attributes, &swig_FilePath_Sf_SwigStatic, swig_FilePath_meta, swig_FilePath_bases, swig_FilePath_base_names }; - -static int _wrap_new_File__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofFile *result = 0 ; - SWIG_check_num_args("ofFile::ofFile",0,0) result = (ofFile *)new ofFile(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofFile,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_File__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::filesystem::path *arg1 = 0 ; ofFile::Mode arg2 ; - bool arg3 ; std::filesystem::path temp1 ; ofFile *result = 0 ; SWIG_check_num_args("ofFile::ofFile",3,3) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFile::ofFile",1,"std::filesystem::path const &"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofFile::ofFile",2,"ofFile::Mode"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofFile::ofFile",3,"bool"); { size_t len = lua_rawlen(L, 1); - temp1 = lua_tolstring(L, 1, &len); arg1 = &temp1; } arg2 = (ofFile::Mode)(int)lua_tonumber(L, 2); - arg3 = (lua_toboolean(L, 3)!=0); result = (ofFile *)new ofFile((std::filesystem::path const &)*arg1,arg2,arg3); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofFile,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_File__SWIG_2(lua_State* L) { int SWIG_arg = 0; std::filesystem::path *arg1 = 0 ; ofFile::Mode arg2 ; - std::filesystem::path temp1 ; ofFile *result = 0 ; SWIG_check_num_args("ofFile::ofFile",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFile::ofFile",1,"std::filesystem::path const &"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofFile::ofFile",2,"ofFile::Mode"); { size_t len = lua_rawlen(L, 1); - temp1 = lua_tolstring(L, 1, &len); arg1 = &temp1; } arg2 = (ofFile::Mode)(int)lua_tonumber(L, 2); - result = (ofFile *)new ofFile((std::filesystem::path const &)*arg1,arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofFile,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_File__SWIG_3(lua_State* L) { int SWIG_arg = 0; std::filesystem::path *arg1 = 0 ; - std::filesystem::path temp1 ; ofFile *result = 0 ; SWIG_check_num_args("ofFile::ofFile",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFile::ofFile",1,"std::filesystem::path const &"); { size_t len = lua_rawlen(L, 1); - temp1 = lua_tolstring(L, 1, &len); arg1 = &temp1; } result = (ofFile *)new ofFile((std::filesystem::path const &)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofFile,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_File__SWIG_4(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = 0 ; ofFile *result = 0 ; - SWIG_check_num_args("ofFile::ofFile",1,1) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofFile::ofFile",1,"ofFile const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("new_File",1,SWIGTYPE_p_ofFile); } - result = (ofFile *)new ofFile((ofFile const &)*arg1); SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofFile,1); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_new_File(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_File__SWIG_0(L);} if (argc == 1) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { return _wrap_new_File__SWIG_4(L);} } if (argc == 1) { int _v; { - _v = lua_isstring(L, argv[0]); } if (_v) { return _wrap_new_File__SWIG_3(L);} } if (argc == 2) { int _v; { - _v = lua_isstring(L, argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_new_File__SWIG_2(L);} - } } if (argc == 3) { int _v; { _v = lua_isstring(L, argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - { _v = lua_isboolean(L,argv[2]); } if (_v) { return _wrap_new_File__SWIG_1(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_File'\n" " Possible C/C++ prototypes are:\n" - " ofFile::ofFile()\n" " ofFile::ofFile(std::filesystem::path const &,ofFile::Mode,bool)\n" - " ofFile::ofFile(std::filesystem::path const &,ofFile::Mode)\n" " ofFile::ofFile(std::filesystem::path const &)\n" - " ofFile::ofFile(ofFile const &)\n"); lua_error(L);return 0; } -static int _wrap_File_open__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; - std::filesystem::path *arg2 = 0 ; ofFile::Mode arg3 ; bool arg4 ; std::filesystem::path temp2 ; bool result; - SWIG_check_num_args("ofFile::open",4,4) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::open",1,"ofFile *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofFile::open",2,"std::filesystem::path const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofFile::open",3,"ofFile::Mode"); - if(!lua_isboolean(L,4)) SWIG_fail_arg("ofFile::open",4,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File_open",1,SWIGTYPE_p_ofFile); } { - size_t len = lua_rawlen(L, 2); temp2 = lua_tolstring(L, 2, &len); arg2 = &temp2; } - arg3 = (ofFile::Mode)(int)lua_tonumber(L, 3); arg4 = (lua_toboolean(L, 4)!=0); - result = (bool)(arg1)->open((std::filesystem::path const &)*arg2,arg3,arg4); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_open__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; - std::filesystem::path *arg2 = 0 ; ofFile::Mode arg3 ; std::filesystem::path temp2 ; bool result; - SWIG_check_num_args("ofFile::open",3,3) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::open",1,"ofFile *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofFile::open",2,"std::filesystem::path const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofFile::open",3,"ofFile::Mode"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File_open",1,SWIGTYPE_p_ofFile); } { - size_t len = lua_rawlen(L, 2); temp2 = lua_tolstring(L, 2, &len); arg2 = &temp2; } - arg3 = (ofFile::Mode)(int)lua_tonumber(L, 3); result = (bool)(arg1)->open((std::filesystem::path const &)*arg2,arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_open__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; - std::filesystem::path *arg2 = 0 ; std::filesystem::path temp2 ; bool result; SWIG_check_num_args("ofFile::open",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::open",1,"ofFile *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofFile::open",2,"std::filesystem::path const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File_open",1,SWIGTYPE_p_ofFile); } { - size_t len = lua_rawlen(L, 2); temp2 = lua_tolstring(L, 2, &len); arg2 = &temp2; } - result = (bool)(arg1)->open((std::filesystem::path const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_open(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L, argv[1]); } if (_v) { - return _wrap_File_open__SWIG_2(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isstring(L, argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_File_open__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isstring(L, argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { - _v = lua_isboolean(L,argv[3]); } if (_v) { return _wrap_File_open__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'File_open'\n" " Possible C/C++ prototypes are:\n" - " ofFile::open(std::filesystem::path const &,ofFile::Mode,bool)\n" - " ofFile::open(std::filesystem::path const &,ofFile::Mode)\n" " ofFile::open(std::filesystem::path const &)\n"); - lua_error(L);return 0; } -static int _wrap_File_changeMode__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; ofFile::Mode arg2 ; - bool arg3 ; bool result; SWIG_check_num_args("ofFile::changeMode",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::changeMode",1,"ofFile *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofFile::changeMode",2,"ofFile::Mode"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofFile::changeMode",3,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ - SWIG_fail_ptr("File_changeMode",1,SWIGTYPE_p_ofFile); } arg2 = (ofFile::Mode)(int)lua_tonumber(L, 2); - arg3 = (lua_toboolean(L, 3)!=0); result = (bool)(arg1)->changeMode(arg2,arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_changeMode__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; ofFile::Mode arg2 ; - bool result; SWIG_check_num_args("ofFile::changeMode",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::changeMode",1,"ofFile *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofFile::changeMode",2,"ofFile::Mode"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ - SWIG_fail_ptr("File_changeMode",1,SWIGTYPE_p_ofFile); } arg2 = (ofFile::Mode)(int)lua_tonumber(L, 2); - result = (bool)(arg1)->changeMode(arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_changeMode(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_File_changeMode__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - return _wrap_File_changeMode__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'File_changeMode'\n" " Possible C/C++ prototypes are:\n" - " ofFile::changeMode(ofFile::Mode,bool)\n" " ofFile::changeMode(ofFile::Mode)\n"); lua_error(L);return 0; } -static int _wrap_File_close(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; - SWIG_check_num_args("ofFile::close",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::close",1,"ofFile *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File_close",1,SWIGTYPE_p_ofFile); } - (arg1)->close(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_create(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; bool result; - SWIG_check_num_args("ofFile::create",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::create",1,"ofFile *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File_create",1,SWIGTYPE_p_ofFile); } - result = (bool)(arg1)->create(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_File_exists(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; bool result; - SWIG_check_num_args("ofFile::exists",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::exists",1,"ofFile const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File_exists",1,SWIGTYPE_p_ofFile); } - result = (bool)((ofFile const *)arg1)->exists(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_path(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; std::string result; - SWIG_check_num_args("ofFile::path",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::path",1,"ofFile const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File_path",1,SWIGTYPE_p_ofFile); } - result = ((ofFile const *)arg1)->path(); lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_getExtension(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; std::string result; - SWIG_check_num_args("ofFile::getExtension",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::getExtension",1,"ofFile const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ - SWIG_fail_ptr("File_getExtension",1,SWIGTYPE_p_ofFile); } result = ((ofFile const *)arg1)->getExtension(); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_File_getFileName(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; std::string result; - SWIG_check_num_args("ofFile::getFileName",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::getFileName",1,"ofFile const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ - SWIG_fail_ptr("File_getFileName",1,SWIGTYPE_p_ofFile); } result = ((ofFile const *)arg1)->getFileName(); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_File_getBaseName(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; std::string result; - SWIG_check_num_args("ofFile::getBaseName",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::getBaseName",1,"ofFile const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ - SWIG_fail_ptr("File_getBaseName",1,SWIGTYPE_p_ofFile); } result = ((ofFile const *)arg1)->getBaseName(); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_File_getEnclosingDirectory(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; std::string result; - SWIG_check_num_args("ofFile::getEnclosingDirectory",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::getEnclosingDirectory",1,"ofFile const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ - SWIG_fail_ptr("File_getEnclosingDirectory",1,SWIGTYPE_p_ofFile); } - result = ((ofFile const *)arg1)->getEnclosingDirectory(); lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_getAbsolutePath(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; std::string result; - SWIG_check_num_args("ofFile::getAbsolutePath",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::getAbsolutePath",1,"ofFile const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ - SWIG_fail_ptr("File_getAbsolutePath",1,SWIGTYPE_p_ofFile); } result = ((ofFile const *)arg1)->getAbsolutePath(); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_File_canRead(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; bool result; - SWIG_check_num_args("ofFile::canRead",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::canRead",1,"ofFile const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File_canRead",1,SWIGTYPE_p_ofFile); } - result = (bool)((ofFile const *)arg1)->canRead(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_canWrite(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; bool result; - SWIG_check_num_args("ofFile::canWrite",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::canWrite",1,"ofFile const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File_canWrite",1,SWIGTYPE_p_ofFile); } - result = (bool)((ofFile const *)arg1)->canWrite(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_canExecute(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; bool result; - SWIG_check_num_args("ofFile::canExecute",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::canExecute",1,"ofFile const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ - SWIG_fail_ptr("File_canExecute",1,SWIGTYPE_p_ofFile); } result = (bool)((ofFile const *)arg1)->canExecute(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_isFile(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; bool result; - SWIG_check_num_args("ofFile::isFile",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::isFile",1,"ofFile const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File_isFile",1,SWIGTYPE_p_ofFile); } - result = (bool)((ofFile const *)arg1)->isFile(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_isLink(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; bool result; - SWIG_check_num_args("ofFile::isLink",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::isLink",1,"ofFile const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File_isLink",1,SWIGTYPE_p_ofFile); } - result = (bool)((ofFile const *)arg1)->isLink(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_isDirectory(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; bool result; - SWIG_check_num_args("ofFile::isDirectory",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::isDirectory",1,"ofFile const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ - SWIG_fail_ptr("File_isDirectory",1,SWIGTYPE_p_ofFile); } result = (bool)((ofFile const *)arg1)->isDirectory(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_isDevice(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; bool result; - SWIG_check_num_args("ofFile::isDevice",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::isDevice",1,"ofFile const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File_isDevice",1,SWIGTYPE_p_ofFile); } - result = (bool)((ofFile const *)arg1)->isDevice(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_isHidden(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; bool result; - SWIG_check_num_args("ofFile::isHidden",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::isHidden",1,"ofFile const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File_isHidden",1,SWIGTYPE_p_ofFile); } - result = (bool)((ofFile const *)arg1)->isHidden(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_setWriteable__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; bool arg2 ; - SWIG_check_num_args("ofFile::setWriteable",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::setWriteable",1,"ofFile *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofFile::setWriteable",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ - SWIG_fail_ptr("File_setWriteable",1,SWIGTYPE_p_ofFile); } arg2 = (lua_toboolean(L, 2)!=0); (arg1)->setWriteable(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_setWriteable__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; - SWIG_check_num_args("ofFile::setWriteable",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::setWriteable",1,"ofFile *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ - SWIG_fail_ptr("File_setWriteable",1,SWIGTYPE_p_ofFile); } (arg1)->setWriteable(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_File_setWriteable(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_File_setWriteable__SWIG_1(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_File_setWriteable__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'File_setWriteable'\n" " Possible C/C++ prototypes are:\n" - " ofFile::setWriteable(bool)\n" " ofFile::setWriteable()\n"); lua_error(L);return 0; } -static int _wrap_File_setReadOnly__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; bool arg2 ; - SWIG_check_num_args("ofFile::setReadOnly",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::setReadOnly",1,"ofFile *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofFile::setReadOnly",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ - SWIG_fail_ptr("File_setReadOnly",1,SWIGTYPE_p_ofFile); } arg2 = (lua_toboolean(L, 2)!=0); (arg1)->setReadOnly(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_setReadOnly__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; - SWIG_check_num_args("ofFile::setReadOnly",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::setReadOnly",1,"ofFile *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ - SWIG_fail_ptr("File_setReadOnly",1,SWIGTYPE_p_ofFile); } (arg1)->setReadOnly(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_File_setReadOnly(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_File_setReadOnly__SWIG_1(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_File_setReadOnly__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'File_setReadOnly'\n" " Possible C/C++ prototypes are:\n" - " ofFile::setReadOnly(bool)\n" " ofFile::setReadOnly()\n"); lua_error(L);return 0; } -static int _wrap_File_setExecutable__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; bool arg2 ; - SWIG_check_num_args("ofFile::setExecutable",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::setExecutable",1,"ofFile *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofFile::setExecutable",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ - SWIG_fail_ptr("File_setExecutable",1,SWIGTYPE_p_ofFile); } arg2 = (lua_toboolean(L, 2)!=0); (arg1)->setExecutable(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_setExecutable__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; - SWIG_check_num_args("ofFile::setExecutable",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::setExecutable",1,"ofFile *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ - SWIG_fail_ptr("File_setExecutable",1,SWIGTYPE_p_ofFile); } (arg1)->setExecutable(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_File_setExecutable(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_File_setExecutable__SWIG_1(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_File_setExecutable__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'File_setExecutable'\n" " Possible C/C++ prototypes are:\n" - " ofFile::setExecutable(bool)\n" " ofFile::setExecutable()\n"); lua_error(L);return 0; } -static int _wrap_File_copyTo__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; std::string *arg2 = 0 ; - bool arg3 ; bool arg4 ; std::string temp2 ; bool result; SWIG_check_num_args("ofFile::copyTo",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::copyTo",1,"ofFile const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofFile::copyTo",2,"std::string const &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofFile::copyTo",3,"bool"); - if(!lua_isboolean(L,4)) SWIG_fail_arg("ofFile::copyTo",4,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File_copyTo",1,SWIGTYPE_p_ofFile); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; arg3 = (lua_toboolean(L, 3)!=0); - arg4 = (lua_toboolean(L, 4)!=0); result = (bool)((ofFile const *)arg1)->copyTo((std::string const &)*arg2,arg3,arg4); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_copyTo__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; std::string *arg2 = 0 ; - bool arg3 ; std::string temp2 ; bool result; SWIG_check_num_args("ofFile::copyTo",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::copyTo",1,"ofFile const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofFile::copyTo",2,"std::string const &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofFile::copyTo",3,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File_copyTo",1,SWIGTYPE_p_ofFile); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; arg3 = (lua_toboolean(L, 3)!=0); - result = (bool)((ofFile const *)arg1)->copyTo((std::string const &)*arg2,arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_copyTo__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; std::string *arg2 = 0 ; - std::string temp2 ; bool result; SWIG_check_num_args("ofFile::copyTo",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::copyTo",1,"ofFile const *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofFile::copyTo",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File_copyTo",1,SWIGTYPE_p_ofFile); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = (bool)((ofFile const *)arg1)->copyTo((std::string const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_copyTo(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { - return _wrap_File_copyTo__SWIG_2(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - return _wrap_File_copyTo__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { { - _v = lua_isboolean(L,argv[3]); } if (_v) { return _wrap_File_copyTo__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'File_copyTo'\n" " Possible C/C++ prototypes are:\n" - " ofFile::copyTo(std::string const &,bool,bool) const\n" " ofFile::copyTo(std::string const &,bool) const\n" - " ofFile::copyTo(std::string const &) const\n"); lua_error(L);return 0; } -static int _wrap_File_moveTo__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; std::string *arg2 = 0 ; - bool arg3 ; bool arg4 ; std::string temp2 ; bool result; SWIG_check_num_args("ofFile::moveTo",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::moveTo",1,"ofFile *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofFile::moveTo",2,"std::string const &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofFile::moveTo",3,"bool"); - if(!lua_isboolean(L,4)) SWIG_fail_arg("ofFile::moveTo",4,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File_moveTo",1,SWIGTYPE_p_ofFile); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; arg3 = (lua_toboolean(L, 3)!=0); - arg4 = (lua_toboolean(L, 4)!=0); result = (bool)(arg1)->moveTo((std::string const &)*arg2,arg3,arg4); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_moveTo__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; std::string *arg2 = 0 ; - bool arg3 ; std::string temp2 ; bool result; SWIG_check_num_args("ofFile::moveTo",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::moveTo",1,"ofFile *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofFile::moveTo",2,"std::string const &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofFile::moveTo",3,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File_moveTo",1,SWIGTYPE_p_ofFile); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; arg3 = (lua_toboolean(L, 3)!=0); - result = (bool)(arg1)->moveTo((std::string const &)*arg2,arg3); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_moveTo__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; std::string *arg2 = 0 ; - std::string temp2 ; bool result; SWIG_check_num_args("ofFile::moveTo",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::moveTo",1,"ofFile *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofFile::moveTo",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File_moveTo",1,SWIGTYPE_p_ofFile); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; result = (bool)(arg1)->moveTo((std::string const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_moveTo(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { int _v; - { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { - return _wrap_File_moveTo__SWIG_2(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - return _wrap_File_moveTo__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { { - _v = lua_isboolean(L,argv[3]); } if (_v) { return _wrap_File_moveTo__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'File_moveTo'\n" " Possible C/C++ prototypes are:\n" - " ofFile::moveTo(std::string const &,bool,bool)\n" " ofFile::moveTo(std::string const &,bool)\n" - " ofFile::moveTo(std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_File_renameTo__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; std::string *arg2 = 0 ; - bool arg3 ; bool arg4 ; std::string temp2 ; bool result; SWIG_check_num_args("ofFile::renameTo",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::renameTo",1,"ofFile *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofFile::renameTo",2,"std::string const &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofFile::renameTo",3,"bool"); - if(!lua_isboolean(L,4)) SWIG_fail_arg("ofFile::renameTo",4,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File_renameTo",1,SWIGTYPE_p_ofFile); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; arg3 = (lua_toboolean(L, 3)!=0); - arg4 = (lua_toboolean(L, 4)!=0); result = (bool)(arg1)->renameTo((std::string const &)*arg2,arg3,arg4); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_renameTo__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; std::string *arg2 = 0 ; - bool arg3 ; std::string temp2 ; bool result; SWIG_check_num_args("ofFile::renameTo",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::renameTo",1,"ofFile *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofFile::renameTo",2,"std::string const &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofFile::renameTo",3,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File_renameTo",1,SWIGTYPE_p_ofFile); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; arg3 = (lua_toboolean(L, 3)!=0); - result = (bool)(arg1)->renameTo((std::string const &)*arg2,arg3); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_renameTo__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; std::string *arg2 = 0 ; - std::string temp2 ; bool result; SWIG_check_num_args("ofFile::renameTo",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::renameTo",1,"ofFile *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofFile::renameTo",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File_renameTo",1,SWIGTYPE_p_ofFile); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; result = (bool)(arg1)->renameTo((std::string const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_renameTo(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { - return _wrap_File_renameTo__SWIG_2(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - return _wrap_File_renameTo__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { _v = 0; } else { - _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { { - _v = lua_isboolean(L,argv[3]); } if (_v) { return _wrap_File_renameTo__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'File_renameTo'\n" " Possible C/C++ prototypes are:\n" - " ofFile::renameTo(std::string const &,bool,bool)\n" " ofFile::renameTo(std::string const &,bool)\n" - " ofFile::renameTo(std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_File_remove__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; bool arg2 ; bool result; - SWIG_check_num_args("ofFile::remove",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::remove",1,"ofFile *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofFile::remove",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File_remove",1,SWIGTYPE_p_ofFile); } - arg2 = (lua_toboolean(L, 2)!=0); result = (bool)(arg1)->remove(arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_remove__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; bool result; - SWIG_check_num_args("ofFile::remove",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::remove",1,"ofFile *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File_remove",1,SWIGTYPE_p_ofFile); } - result = (bool)(arg1)->remove(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_File_remove(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_File_remove__SWIG_1(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofFile, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_File_remove__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'File_remove'\n" " Possible C/C++ prototypes are:\n" - " ofFile::remove(bool)\n" " ofFile::remove()\n"); lua_error(L);return 0; } -static int _wrap_File_getSize(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; uint64_t result; - SWIG_check_num_args("ofFile::getSize",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::getSize",1,"ofFile const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File_getSize",1,SWIGTYPE_p_ofFile); } - result = (uint64_t)((ofFile const *)arg1)->getSize(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File___eq(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; ofFile *arg2 = 0 ; bool result; - SWIG_check_num_args("ofFile::operator ==",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::operator ==",1,"ofFile const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofFile::operator ==",2,"ofFile const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File___eq",1,SWIGTYPE_p_ofFile); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File___eq",2,SWIGTYPE_p_ofFile); } - result = (bool)((ofFile const *)arg1)->operator ==((ofFile const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File___lt(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; ofFile *arg2 = 0 ; bool result; - SWIG_check_num_args("ofFile::operator <",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::operator <",1,"ofFile const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofFile::operator <",2,"ofFile const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File___lt",1,SWIGTYPE_p_ofFile); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File___lt",2,SWIGTYPE_p_ofFile); } - result = (bool)((ofFile const *)arg1)->operator <((ofFile const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File___le(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; ofFile *arg2 = 0 ; bool result; - SWIG_check_num_args("ofFile::operator <=",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::operator <=",1,"ofFile const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofFile::operator <=",2,"ofFile const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File___le",1,SWIGTYPE_p_ofFile); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofFile,0))){ SWIG_fail_ptr("File___le",2,SWIGTYPE_p_ofFile); } - result = (bool)((ofFile const *)arg1)->operator <=((ofFile const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_readToBuffer(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; ofBuffer result; - SWIG_check_num_args("ofFile::readToBuffer",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::readToBuffer",1,"ofFile *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ - SWIG_fail_ptr("File_readToBuffer",1,SWIGTYPE_p_ofFile); } result = (arg1)->readToBuffer(); { - ofBuffer * resultptr = new ofBuffer((const ofBuffer &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofBuffer,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_File_writeFromBuffer(lua_State* L) { int SWIG_arg = 0; ofFile *arg1 = (ofFile *) 0 ; ofBuffer *arg2 = 0 ; - bool result; SWIG_check_num_args("ofFile::writeFromBuffer",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFile::writeFromBuffer",1,"ofFile *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofFile::writeFromBuffer",2,"ofBuffer const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFile,0))){ - SWIG_fail_ptr("File_writeFromBuffer",1,SWIGTYPE_p_ofFile); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBuffer,0))){ - SWIG_fail_ptr("File_writeFromBuffer",2,SWIGTYPE_p_ofBuffer); } - result = (bool)(arg1)->writeFromBuffer((ofBuffer const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_copyFromTo__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; - bool arg3 ; bool arg4 ; std::string temp1 ; std::string temp2 ; bool result; SWIG_check_num_args("ofFile::copyFromTo",4,4) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFile::copyFromTo",1,"std::string const &"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofFile::copyFromTo",2,"std::string const &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofFile::copyFromTo",3,"bool"); - if(!lua_isboolean(L,4)) SWIG_fail_arg("ofFile::copyFromTo",4,"bool"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - arg3 = (lua_toboolean(L, 3)!=0); arg4 = (lua_toboolean(L, 4)!=0); - result = (bool)ofFile::copyFromTo((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_copyFromTo__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; - bool arg3 ; std::string temp1 ; std::string temp2 ; bool result; SWIG_check_num_args("ofFile::copyFromTo",3,3) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFile::copyFromTo",1,"std::string const &"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofFile::copyFromTo",2,"std::string const &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofFile::copyFromTo",3,"bool"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - arg3 = (lua_toboolean(L, 3)!=0); - result = (bool)ofFile::copyFromTo((std::string const &)*arg1,(std::string const &)*arg2,arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_copyFromTo__SWIG_2(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; - std::string temp1 ; std::string temp2 ; bool result; SWIG_check_num_args("ofFile::copyFromTo",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFile::copyFromTo",1,"std::string const &"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofFile::copyFromTo",2,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = (bool)ofFile::copyFromTo((std::string const &)*arg1,(std::string const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_copyFromTo(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { - return _wrap_File_copyFromTo__SWIG_2(L);} } } if (argc == 3) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { { - _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - return _wrap_File_copyFromTo__SWIG_1(L);} } } } if (argc == 4) { int _v; { _v = lua_isstring(L,argv[0]); } - if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { { - _v = lua_isboolean(L,argv[3]); } if (_v) { return _wrap_File_copyFromTo__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'File_copyFromTo'\n" " Possible C/C++ prototypes are:\n" - " ofFile::copyFromTo(std::string const &,std::string const &,bool,bool)\n" - " ofFile::copyFromTo(std::string const &,std::string const &,bool)\n" - " ofFile::copyFromTo(std::string const &,std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_File_moveFromTo__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; - bool arg3 ; bool arg4 ; std::string temp1 ; std::string temp2 ; bool result; SWIG_check_num_args("ofFile::moveFromTo",4,4) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFile::moveFromTo",1,"std::string const &"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofFile::moveFromTo",2,"std::string const &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofFile::moveFromTo",3,"bool"); - if(!lua_isboolean(L,4)) SWIG_fail_arg("ofFile::moveFromTo",4,"bool"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - arg3 = (lua_toboolean(L, 3)!=0); arg4 = (lua_toboolean(L, 4)!=0); - result = (bool)ofFile::moveFromTo((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_moveFromTo__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; - bool arg3 ; std::string temp1 ; std::string temp2 ; bool result; SWIG_check_num_args("ofFile::moveFromTo",3,3) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFile::moveFromTo",1,"std::string const &"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofFile::moveFromTo",2,"std::string const &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofFile::moveFromTo",3,"bool"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - arg3 = (lua_toboolean(L, 3)!=0); - result = (bool)ofFile::moveFromTo((std::string const &)*arg1,(std::string const &)*arg2,arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_moveFromTo__SWIG_2(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; - std::string temp1 ; std::string temp2 ; bool result; SWIG_check_num_args("ofFile::moveFromTo",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFile::moveFromTo",1,"std::string const &"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofFile::moveFromTo",2,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = (bool)ofFile::moveFromTo((std::string const &)*arg1,(std::string const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_moveFromTo(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { - return _wrap_File_moveFromTo__SWIG_2(L);} } } if (argc == 3) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { { - _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - return _wrap_File_moveFromTo__SWIG_1(L);} } } } if (argc == 4) { int _v; { _v = lua_isstring(L,argv[0]); } - if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { { - _v = lua_isboolean(L,argv[3]); } if (_v) { return _wrap_File_moveFromTo__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'File_moveFromTo'\n" " Possible C/C++ prototypes are:\n" - " ofFile::moveFromTo(std::string const &,std::string const &,bool,bool)\n" - " ofFile::moveFromTo(std::string const &,std::string const &,bool)\n" - " ofFile::moveFromTo(std::string const &,std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_File_doesFileExist__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; bool arg2 ; - std::string temp1 ; bool result; SWIG_check_num_args("ofFile::doesFileExist",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFile::doesFileExist",1,"std::string const &"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofFile::doesFileExist",2,"bool"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; arg2 = (lua_toboolean(L, 2)!=0); - result = (bool)ofFile::doesFileExist((std::string const &)*arg1,arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_doesFileExist__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - bool result; SWIG_check_num_args("ofFile::doesFileExist",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFile::doesFileExist",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; - result = (bool)ofFile::doesFileExist((std::string const &)*arg1); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_doesFileExist(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { return _wrap_File_doesFileExist__SWIG_1(L);} } if (argc == 2) { - int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_File_doesFileExist__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'File_doesFileExist'\n" " Possible C/C++ prototypes are:\n" - " ofFile::doesFileExist(std::string const &,bool)\n" " ofFile::doesFileExist(std::string const &)\n"); - lua_error(L);return 0; } -static int _wrap_File_removeFile__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; bool arg2 ; - std::string temp1 ; bool result; SWIG_check_num_args("ofFile::removeFile",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFile::removeFile",1,"std::string const &"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofFile::removeFile",2,"bool"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; arg2 = (lua_toboolean(L, 2)!=0); - result = (bool)ofFile::removeFile((std::string const &)*arg1,arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_removeFile__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - bool result; SWIG_check_num_args("ofFile::removeFile",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofFile::removeFile",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = (bool)ofFile::removeFile((std::string const &)*arg1); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_File_removeFile(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; - { _v = lua_isstring(L,argv[0]); } if (_v) { return _wrap_File_removeFile__SWIG_1(L);} } if (argc == 2) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_File_removeFile__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'File_removeFile'\n" " Possible C/C++ prototypes are:\n" - " ofFile::removeFile(std::string const &,bool)\n" " ofFile::removeFile(std::string const &)\n"); lua_error(L);return 0; } -static void swig_delete_File(void *obj) { -ofFile *arg1 = (ofFile *) obj; -delete arg1; -} -static int _proxy__wrap_new_File(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_File); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_File_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_File_methods[]= { - { "open", _wrap_File_open}, - { "changeMode", _wrap_File_changeMode}, - { "close", _wrap_File_close}, - { "create", _wrap_File_create}, - { "exists", _wrap_File_exists}, - { "path", _wrap_File_path}, - { "getExtension", _wrap_File_getExtension}, - { "getFileName", _wrap_File_getFileName}, - { "getBaseName", _wrap_File_getBaseName}, - { "getEnclosingDirectory", _wrap_File_getEnclosingDirectory}, - { "getAbsolutePath", _wrap_File_getAbsolutePath}, - { "canRead", _wrap_File_canRead}, - { "canWrite", _wrap_File_canWrite}, - { "canExecute", _wrap_File_canExecute}, - { "isFile", _wrap_File_isFile}, - { "isLink", _wrap_File_isLink}, - { "isDirectory", _wrap_File_isDirectory}, - { "isDevice", _wrap_File_isDevice}, - { "isHidden", _wrap_File_isHidden}, - { "setWriteable", _wrap_File_setWriteable}, - { "setReadOnly", _wrap_File_setReadOnly}, - { "setExecutable", _wrap_File_setExecutable}, - { "copyTo", _wrap_File_copyTo}, - { "moveTo", _wrap_File_moveTo}, - { "renameTo", _wrap_File_renameTo}, - { "remove", _wrap_File_remove}, - { "getSize", _wrap_File_getSize}, - { "__eq", _wrap_File___eq}, - { "__lt", _wrap_File___lt}, - { "__le", _wrap_File___le}, - { "readToBuffer", _wrap_File_readToBuffer}, - { "writeFromBuffer", _wrap_File_writeFromBuffer}, - {0,0} -}; -static swig_lua_method swig_File_meta[] = { - { "__eq", _wrap_File___eq}, - { "__lt", _wrap_File___lt}, - { "__le", _wrap_File___le}, - {0,0} -}; - -static swig_lua_attribute swig_File_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_File_Sf_SwigStatic_constants[]= { - {SWIG_LUA_CONSTTAB_INT("Reference", ofFile::Reference)}, - {SWIG_LUA_CONSTTAB_INT("ReadOnly", ofFile::ReadOnly)}, - {SWIG_LUA_CONSTTAB_INT("WriteOnly", ofFile::WriteOnly)}, - {SWIG_LUA_CONSTTAB_INT("ReadWrite", ofFile::ReadWrite)}, - {SWIG_LUA_CONSTTAB_INT("Append", ofFile::Append)}, - {0,0,0,0,0,0} -}; -static swig_lua_method swig_File_Sf_SwigStatic_methods[]= { - { "copyFromTo", _wrap_File_copyFromTo}, - { "moveFromTo", _wrap_File_moveFromTo}, - { "doesFileExist", _wrap_File_doesFileExist}, - { "removeFile", _wrap_File_removeFile}, - {0,0} -}; -static swig_lua_class* swig_File_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_File_Sf_SwigStatic = { - "File", - swig_File_Sf_SwigStatic_methods, - swig_File_Sf_SwigStatic_attributes, - swig_File_Sf_SwigStatic_constants, - swig_File_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_File_bases[] = {0}; -static const char *swig_File_base_names[] = {0}; -static swig_lua_class _wrap_class_File = { "File", "File", &SWIGTYPE_p_ofFile,_proxy__wrap_new_File, swig_delete_File, swig_File_methods, swig_File_attributes, &swig_File_Sf_SwigStatic, swig_File_meta, swig_File_bases, swig_File_base_names }; - -static int _wrap_new_Directory__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofDirectory *result = 0 ; - SWIG_check_num_args("ofDirectory::ofDirectory",0,0) result = (ofDirectory *)new ofDirectory(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofDirectory,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Directory__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::filesystem::path *arg1 = 0 ; - std::filesystem::path temp1 ; ofDirectory *result = 0 ; SWIG_check_num_args("ofDirectory::ofDirectory",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofDirectory::ofDirectory",1,"std::filesystem::path const &"); { - size_t len = lua_rawlen(L, 1); temp1 = lua_tolstring(L, 1, &len); arg1 = &temp1; } - result = (ofDirectory *)new ofDirectory((std::filesystem::path const &)*arg1); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofDirectory,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_Directory(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_Directory__SWIG_0(L);} if (argc == 1) { int _v; { _v = lua_isstring(L, argv[0]); } if (_v) { - return _wrap_new_Directory__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_Directory'\n" " Possible C/C++ prototypes are:\n" - " ofDirectory::ofDirectory()\n" " ofDirectory::ofDirectory(std::filesystem::path const &)\n"); lua_error(L);return 0; } -static int _wrap_Directory_open(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - std::filesystem::path *arg2 = 0 ; std::filesystem::path temp2 ; SWIG_check_num_args("ofDirectory::open",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::open",1,"ofDirectory *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofDirectory::open",2,"std::filesystem::path const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_open",1,SWIGTYPE_p_ofDirectory); } { size_t len = lua_rawlen(L, 2); - temp2 = lua_tolstring(L, 2, &len); arg2 = &temp2; } (arg1)->open((std::filesystem::path const &)*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_close(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - SWIG_check_num_args("ofDirectory::close",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::close",1,"ofDirectory *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_close",1,SWIGTYPE_p_ofDirectory); } (arg1)->close(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Directory_create__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; bool arg2 ; - bool result; SWIG_check_num_args("ofDirectory::create",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::create",1,"ofDirectory *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofDirectory::create",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_create",1,SWIGTYPE_p_ofDirectory); } arg2 = (lua_toboolean(L, 2)!=0); - result = (bool)(arg1)->create(arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Directory_create__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; bool result; - SWIG_check_num_args("ofDirectory::create",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::create",1,"ofDirectory *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_create",1,SWIGTYPE_p_ofDirectory); } result = (bool)(arg1)->create(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_create(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofDirectory, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Directory_create__SWIG_1(L);} } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofDirectory, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { return _wrap_Directory_create__SWIG_0(L);} } - } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Directory_create'\n" - " Possible C/C++ prototypes are:\n" " ofDirectory::create(bool)\n" " ofDirectory::create()\n"); lua_error(L);return 0; } -static int _wrap_Directory_exists(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; bool result; - SWIG_check_num_args("ofDirectory::exists",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::exists",1,"ofDirectory const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_exists",1,SWIGTYPE_p_ofDirectory); } result = (bool)((ofDirectory const *)arg1)->exists(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_path(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; std::string result; - SWIG_check_num_args("ofDirectory::path",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::path",1,"ofDirectory const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_path",1,SWIGTYPE_p_ofDirectory); } result = ((ofDirectory const *)arg1)->path(); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Directory_getAbsolutePath(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - std::string result; SWIG_check_num_args("ofDirectory::getAbsolutePath",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::getAbsolutePath",1,"ofDirectory const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_getAbsolutePath",1,SWIGTYPE_p_ofDirectory); } - result = ((ofDirectory const *)arg1)->getAbsolutePath(); lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_canRead(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; bool result; - SWIG_check_num_args("ofDirectory::canRead",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::canRead",1,"ofDirectory const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_canRead",1,SWIGTYPE_p_ofDirectory); } result = (bool)((ofDirectory const *)arg1)->canRead(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_canWrite(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; bool result; - SWIG_check_num_args("ofDirectory::canWrite",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::canWrite",1,"ofDirectory const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_canWrite",1,SWIGTYPE_p_ofDirectory); } result = (bool)((ofDirectory const *)arg1)->canWrite(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_canExecute(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; bool result; - SWIG_check_num_args("ofDirectory::canExecute",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::canExecute",1,"ofDirectory const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_canExecute",1,SWIGTYPE_p_ofDirectory); } result = (bool)((ofDirectory const *)arg1)->canExecute(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_isDirectory(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; bool result; - SWIG_check_num_args("ofDirectory::isDirectory",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::isDirectory",1,"ofDirectory const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_isDirectory",1,SWIGTYPE_p_ofDirectory); } - result = (bool)((ofDirectory const *)arg1)->isDirectory(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_isHidden(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; bool result; - SWIG_check_num_args("ofDirectory::isHidden",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::isHidden",1,"ofDirectory const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_isHidden",1,SWIGTYPE_p_ofDirectory); } result = (bool)((ofDirectory const *)arg1)->isHidden(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_setWriteable__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - bool arg2 ; SWIG_check_num_args("ofDirectory::setWriteable",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::setWriteable",1,"ofDirectory *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofDirectory::setWriteable",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_setWriteable",1,SWIGTYPE_p_ofDirectory); } arg2 = (lua_toboolean(L, 2)!=0); - (arg1)->setWriteable(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_setWriteable__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - SWIG_check_num_args("ofDirectory::setWriteable",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::setWriteable",1,"ofDirectory *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_setWriteable",1,SWIGTYPE_p_ofDirectory); } (arg1)->setWriteable(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_setWriteable(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofDirectory, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Directory_setWriteable__SWIG_1(L);} } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofDirectory, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_Directory_setWriteable__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Directory_setWriteable'\n" - " Possible C/C++ prototypes are:\n" " ofDirectory::setWriteable(bool)\n" " ofDirectory::setWriteable()\n"); - lua_error(L);return 0; } -static int _wrap_Directory_setReadOnly__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - bool arg2 ; SWIG_check_num_args("ofDirectory::setReadOnly",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::setReadOnly",1,"ofDirectory *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofDirectory::setReadOnly",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_setReadOnly",1,SWIGTYPE_p_ofDirectory); } arg2 = (lua_toboolean(L, 2)!=0); - (arg1)->setReadOnly(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_setReadOnly__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - SWIG_check_num_args("ofDirectory::setReadOnly",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::setReadOnly",1,"ofDirectory *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_setReadOnly",1,SWIGTYPE_p_ofDirectory); } (arg1)->setReadOnly(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_setReadOnly(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofDirectory, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Directory_setReadOnly__SWIG_1(L);} } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofDirectory, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_Directory_setReadOnly__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Directory_setReadOnly'\n" - " Possible C/C++ prototypes are:\n" " ofDirectory::setReadOnly(bool)\n" " ofDirectory::setReadOnly()\n"); - lua_error(L);return 0; } -static int _wrap_Directory_setExecutable__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - bool arg2 ; SWIG_check_num_args("ofDirectory::setExecutable",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::setExecutable",1,"ofDirectory *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofDirectory::setExecutable",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_setExecutable",1,SWIGTYPE_p_ofDirectory); } arg2 = (lua_toboolean(L, 2)!=0); - (arg1)->setExecutable(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_setExecutable__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - SWIG_check_num_args("ofDirectory::setExecutable",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::setExecutable",1,"ofDirectory *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_setExecutable",1,SWIGTYPE_p_ofDirectory); } (arg1)->setExecutable(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_setExecutable(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofDirectory, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Directory_setExecutable__SWIG_1(L);} } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofDirectory, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_Directory_setExecutable__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Directory_setExecutable'\n" - " Possible C/C++ prototypes are:\n" " ofDirectory::setExecutable(bool)\n" " ofDirectory::setExecutable()\n"); - lua_error(L);return 0; } -static int _wrap_Directory_setShowHidden(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; bool arg2 ; - SWIG_check_num_args("ofDirectory::setShowHidden",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::setShowHidden",1,"ofDirectory *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofDirectory::setShowHidden",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_setShowHidden",1,SWIGTYPE_p_ofDirectory); } arg2 = (lua_toboolean(L, 2)!=0); - (arg1)->setShowHidden(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_copyTo__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - std::string *arg2 = 0 ; bool arg3 ; bool arg4 ; std::string temp2 ; bool result; - SWIG_check_num_args("ofDirectory::copyTo",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::copyTo",1,"ofDirectory *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofDirectory::copyTo",2,"std::string const &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofDirectory::copyTo",3,"bool"); - if(!lua_isboolean(L,4)) SWIG_fail_arg("ofDirectory::copyTo",4,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_copyTo",1,SWIGTYPE_p_ofDirectory); } temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - arg3 = (lua_toboolean(L, 3)!=0); arg4 = (lua_toboolean(L, 4)!=0); - result = (bool)(arg1)->copyTo((std::string const &)*arg2,arg3,arg4); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_copyTo__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - std::string *arg2 = 0 ; bool arg3 ; std::string temp2 ; bool result; SWIG_check_num_args("ofDirectory::copyTo",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::copyTo",1,"ofDirectory *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofDirectory::copyTo",2,"std::string const &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofDirectory::copyTo",3,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_copyTo",1,SWIGTYPE_p_ofDirectory); } temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - arg3 = (lua_toboolean(L, 3)!=0); result = (bool)(arg1)->copyTo((std::string const &)*arg2,arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_copyTo__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - std::string *arg2 = 0 ; std::string temp2 ; bool result; SWIG_check_num_args("ofDirectory::copyTo",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::copyTo",1,"ofDirectory *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofDirectory::copyTo",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_copyTo",1,SWIGTYPE_p_ofDirectory); } temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = (bool)(arg1)->copyTo((std::string const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_copyTo(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofDirectory, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { return _wrap_Directory_copyTo__SWIG_2(L);} } - } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofDirectory, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - return _wrap_Directory_copyTo__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofDirectory, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - { _v = lua_isboolean(L,argv[3]); } if (_v) { return _wrap_Directory_copyTo__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Directory_copyTo'\n" " Possible C/C++ prototypes are:\n" - " ofDirectory::copyTo(std::string const &,bool,bool)\n" " ofDirectory::copyTo(std::string const &,bool)\n" - " ofDirectory::copyTo(std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_Directory_moveTo__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - std::string *arg2 = 0 ; bool arg3 ; bool arg4 ; std::string temp2 ; bool result; - SWIG_check_num_args("ofDirectory::moveTo",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::moveTo",1,"ofDirectory *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofDirectory::moveTo",2,"std::string const &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofDirectory::moveTo",3,"bool"); - if(!lua_isboolean(L,4)) SWIG_fail_arg("ofDirectory::moveTo",4,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_moveTo",1,SWIGTYPE_p_ofDirectory); } temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - arg3 = (lua_toboolean(L, 3)!=0); arg4 = (lua_toboolean(L, 4)!=0); - result = (bool)(arg1)->moveTo((std::string const &)*arg2,arg3,arg4); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_moveTo__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - std::string *arg2 = 0 ; bool arg3 ; std::string temp2 ; bool result; SWIG_check_num_args("ofDirectory::moveTo",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::moveTo",1,"ofDirectory *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofDirectory::moveTo",2,"std::string const &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofDirectory::moveTo",3,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_moveTo",1,SWIGTYPE_p_ofDirectory); } temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - arg3 = (lua_toboolean(L, 3)!=0); result = (bool)(arg1)->moveTo((std::string const &)*arg2,arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_moveTo__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - std::string *arg2 = 0 ; std::string temp2 ; bool result; SWIG_check_num_args("ofDirectory::moveTo",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::moveTo",1,"ofDirectory *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofDirectory::moveTo",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_moveTo",1,SWIGTYPE_p_ofDirectory); } temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = (bool)(arg1)->moveTo((std::string const &)*arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_moveTo(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofDirectory, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { return _wrap_Directory_moveTo__SWIG_2(L);} } - } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofDirectory, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - return _wrap_Directory_moveTo__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofDirectory, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - { _v = lua_isboolean(L,argv[3]); } if (_v) { return _wrap_Directory_moveTo__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Directory_moveTo'\n" " Possible C/C++ prototypes are:\n" - " ofDirectory::moveTo(std::string const &,bool,bool)\n" " ofDirectory::moveTo(std::string const &,bool)\n" - " ofDirectory::moveTo(std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_Directory_renameTo__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - std::string *arg2 = 0 ; bool arg3 ; bool arg4 ; std::string temp2 ; bool result; - SWIG_check_num_args("ofDirectory::renameTo",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::renameTo",1,"ofDirectory *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofDirectory::renameTo",2,"std::string const &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofDirectory::renameTo",3,"bool"); - if(!lua_isboolean(L,4)) SWIG_fail_arg("ofDirectory::renameTo",4,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_renameTo",1,SWIGTYPE_p_ofDirectory); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; arg3 = (lua_toboolean(L, 3)!=0); - arg4 = (lua_toboolean(L, 4)!=0); result = (bool)(arg1)->renameTo((std::string const &)*arg2,arg3,arg4); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_renameTo__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - std::string *arg2 = 0 ; bool arg3 ; std::string temp2 ; bool result; SWIG_check_num_args("ofDirectory::renameTo",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::renameTo",1,"ofDirectory *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofDirectory::renameTo",2,"std::string const &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofDirectory::renameTo",3,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_renameTo",1,SWIGTYPE_p_ofDirectory); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; arg3 = (lua_toboolean(L, 3)!=0); - result = (bool)(arg1)->renameTo((std::string const &)*arg2,arg3); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_renameTo__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - std::string *arg2 = 0 ; std::string temp2 ; bool result; SWIG_check_num_args("ofDirectory::renameTo",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::renameTo",1,"ofDirectory *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofDirectory::renameTo",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_renameTo",1,SWIGTYPE_p_ofDirectory); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; result = (bool)(arg1)->renameTo((std::string const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_renameTo(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofDirectory, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { return _wrap_Directory_renameTo__SWIG_2(L);} - } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofDirectory, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - return _wrap_Directory_renameTo__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofDirectory, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - { _v = lua_isboolean(L,argv[3]); } if (_v) { return _wrap_Directory_renameTo__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Directory_renameTo'\n" " Possible C/C++ prototypes are:\n" - " ofDirectory::renameTo(std::string const &,bool,bool)\n" " ofDirectory::renameTo(std::string const &,bool)\n" - " ofDirectory::renameTo(std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_Directory_remove(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; bool arg2 ; - bool result; SWIG_check_num_args("ofDirectory::remove",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::remove",1,"ofDirectory *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofDirectory::remove",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_remove",1,SWIGTYPE_p_ofDirectory); } arg2 = (lua_toboolean(L, 2)!=0); - result = (bool)(arg1)->remove(arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Directory_allowExt(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - std::string *arg2 = 0 ; std::string temp2 ; SWIG_check_num_args("ofDirectory::allowExt",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::allowExt",1,"ofDirectory *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofDirectory::allowExt",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_allowExt",1,SWIGTYPE_p_ofDirectory); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; (arg1)->allowExt((std::string const &)*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_listDir__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - std::string *arg2 = 0 ; std::string temp2 ; std::size_t result; SWIG_check_num_args("ofDirectory::listDir",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::listDir",1,"ofDirectory *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofDirectory::listDir",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_listDir",1,SWIGTYPE_p_ofDirectory); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = (std::size_t)(arg1)->listDir((std::string const &)*arg2); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_listDir__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - std::size_t result; SWIG_check_num_args("ofDirectory::listDir",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::listDir",1,"ofDirectory *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_listDir",1,SWIGTYPE_p_ofDirectory); } result = (std::size_t)(arg1)->listDir(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_listDir(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofDirectory, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_Directory_listDir__SWIG_1(L);} } if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofDirectory, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { return _wrap_Directory_listDir__SWIG_0(L);} } - } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Directory_listDir'\n" - " Possible C/C++ prototypes are:\n" " ofDirectory::listDir(std::string const &)\n" " ofDirectory::listDir()\n"); - lua_error(L);return 0; } -static int _wrap_Directory_getOriginalDirectory(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - std::string result; SWIG_check_num_args("ofDirectory::getOriginalDirectory",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::getOriginalDirectory",1,"ofDirectory const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_getOriginalDirectory",1,SWIGTYPE_p_ofDirectory); } - result = ((ofDirectory const *)arg1)->getOriginalDirectory(); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_Directory_getName(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; std::size_t arg2 ; - std::string result; SWIG_check_num_args("ofDirectory::getName",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::getName",1,"ofDirectory const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDirectory::getName",2,"std::size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_getName",1,SWIGTYPE_p_ofDirectory); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (std::size_t)lua_tonumber(L, 2); - result = ((ofDirectory const *)arg1)->getName(arg2); lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_getPath(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; std::size_t arg2 ; - std::string result; SWIG_check_num_args("ofDirectory::getPath",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::getPath",1,"ofDirectory const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDirectory::getPath",2,"std::size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_getPath",1,SWIGTYPE_p_ofDirectory); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (std::size_t)lua_tonumber(L, 2); - result = ((ofDirectory const *)arg1)->getPath(arg2); lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_getFile__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - std::size_t arg2 ; ofFile::Mode arg3 ; bool arg4 ; ofFile result; SWIG_check_num_args("ofDirectory::getFile",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::getFile",1,"ofDirectory const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDirectory::getFile",2,"std::size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDirectory::getFile",3,"ofFile::Mode"); - if(!lua_isboolean(L,4)) SWIG_fail_arg("ofDirectory::getFile",4,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_getFile",1,SWIGTYPE_p_ofDirectory); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (std::size_t)lua_tonumber(L, 2); - arg3 = (ofFile::Mode)(int)lua_tonumber(L, 3); arg4 = (lua_toboolean(L, 4)!=0); - result = ((ofDirectory const *)arg1)->getFile(arg2,arg3,arg4); { ofFile * resultptr = new ofFile((const ofFile &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofFile,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Directory_getFile__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - std::size_t arg2 ; ofFile::Mode arg3 ; ofFile result; SWIG_check_num_args("ofDirectory::getFile",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::getFile",1,"ofDirectory const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDirectory::getFile",2,"std::size_t"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofDirectory::getFile",3,"ofFile::Mode"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_getFile",1,SWIGTYPE_p_ofDirectory); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (std::size_t)lua_tonumber(L, 2); - arg3 = (ofFile::Mode)(int)lua_tonumber(L, 3); result = ((ofDirectory const *)arg1)->getFile(arg2,arg3); { - ofFile * resultptr = new ofFile((const ofFile &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofFile,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Directory_getFile__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - std::size_t arg2 ; ofFile result; SWIG_check_num_args("ofDirectory::getFile",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::getFile",1,"ofDirectory const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofDirectory::getFile",2,"std::size_t"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_getFile",1,SWIGTYPE_p_ofDirectory); } - SWIG_contract_assert((lua_tonumber(L,2)>=0),"number must not be negative") arg2 = (std::size_t)lua_tonumber(L, 2); - result = ((ofDirectory const *)arg1)->getFile(arg2); { ofFile * resultptr = new ofFile((const ofFile &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofFile,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Directory_getFile(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofDirectory, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { return _wrap_Directory_getFile__SWIG_2(L);} } - } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofDirectory, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_Directory_getFile__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofDirectory, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isboolean(L,argv[3]); } if (_v) { return _wrap_Directory_getFile__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Directory_getFile'\n" " Possible C/C++ prototypes are:\n" - " ofDirectory::getFile(std::size_t,ofFile::Mode,bool) const\n" " ofDirectory::getFile(std::size_t,ofFile::Mode) const\n" - " ofDirectory::getFile(std::size_t) const\n"); lua_error(L);return 0; } -static int _wrap_Directory_getFiles(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - std::vector< ofFile > *result = 0 ; SWIG_check_num_args("ofDirectory::getFiles",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::getFiles",1,"ofDirectory const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_getFiles",1,SWIGTYPE_p_ofDirectory); } - result = (std::vector< ofFile > *) &((ofDirectory const *)arg1)->getFiles(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofFile_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Directory_getShowHidden(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; bool result; - SWIG_check_num_args("ofDirectory::getShowHidden",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::getShowHidden",1,"ofDirectory const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_getShowHidden",1,SWIGTYPE_p_ofDirectory); } - result = (bool)((ofDirectory const *)arg1)->getShowHidden(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_reset(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - SWIG_check_num_args("ofDirectory::reset",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::reset",1,"ofDirectory *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_reset",1,SWIGTYPE_p_ofDirectory); } (arg1)->reset(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Directory_sort(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - SWIG_check_num_args("ofDirectory::sort",1,1) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::sort",1,"ofDirectory *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_sort",1,SWIGTYPE_p_ofDirectory); } (arg1)->sort(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Directory_getSorted(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - ofDirectory result; SWIG_check_num_args("ofDirectory::getSorted",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::getSorted",1,"ofDirectory *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_getSorted",1,SWIGTYPE_p_ofDirectory); } result = (arg1)->getSorted(); { - ofDirectory * resultptr = new ofDirectory((const ofDirectory &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofDirectory,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_Directory_size(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; std::size_t result; - SWIG_check_num_args("ofDirectory::size",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::size",1,"ofDirectory const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory_size",1,SWIGTYPE_p_ofDirectory); } result = (std::size_t)((ofDirectory const *)arg1)->size(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory___eq(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - ofDirectory *arg2 = 0 ; bool result; SWIG_check_num_args("ofDirectory::operator ==",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::operator ==",1,"ofDirectory const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofDirectory::operator ==",2,"ofDirectory const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory___eq",1,SWIGTYPE_p_ofDirectory); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory___eq",2,SWIGTYPE_p_ofDirectory); } - result = (bool)((ofDirectory const *)arg1)->operator ==((ofDirectory const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory___lt(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - ofDirectory *arg2 = 0 ; bool result; SWIG_check_num_args("ofDirectory::operator <",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::operator <",1,"ofDirectory const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofDirectory::operator <",2,"ofDirectory const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory___lt",1,SWIGTYPE_p_ofDirectory); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory___lt",2,SWIGTYPE_p_ofDirectory); } - result = (bool)((ofDirectory const *)arg1)->operator <((ofDirectory const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory___le(lua_State* L) { int SWIG_arg = 0; ofDirectory *arg1 = (ofDirectory *) 0 ; - ofDirectory *arg2 = 0 ; bool result; SWIG_check_num_args("ofDirectory::operator <=",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofDirectory::operator <=",1,"ofDirectory const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofDirectory::operator <=",2,"ofDirectory const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory___le",1,SWIGTYPE_p_ofDirectory); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofDirectory,0))){ - SWIG_fail_ptr("Directory___le",2,SWIGTYPE_p_ofDirectory); } - result = (bool)((ofDirectory const *)arg1)->operator <=((ofDirectory const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_createDirectory__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; bool arg2 ; - bool arg3 ; std::string temp1 ; bool result; SWIG_check_num_args("ofDirectory::createDirectory",3,3) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofDirectory::createDirectory",1,"std::string const &"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofDirectory::createDirectory",2,"bool"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofDirectory::createDirectory",3,"bool"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; arg2 = (lua_toboolean(L, 2)!=0); - arg3 = (lua_toboolean(L, 3)!=0); result = (bool)ofDirectory::createDirectory((std::string const &)*arg1,arg2,arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_createDirectory__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; bool arg2 ; - std::string temp1 ; bool result; SWIG_check_num_args("ofDirectory::createDirectory",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofDirectory::createDirectory",1,"std::string const &"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofDirectory::createDirectory",2,"bool"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; arg2 = (lua_toboolean(L, 2)!=0); - result = (bool)ofDirectory::createDirectory((std::string const &)*arg1,arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_createDirectory__SWIG_2(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - bool result; SWIG_check_num_args("ofDirectory::createDirectory",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofDirectory::createDirectory",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; - result = (bool)ofDirectory::createDirectory((std::string const &)*arg1); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_createDirectory(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); - if (argc == 1) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { return _wrap_Directory_createDirectory__SWIG_2(L);} } - if (argc == 2) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_Directory_createDirectory__SWIG_1(L);} } } if (argc == 3) { int _v; { _v = lua_isstring(L,argv[0]); } - if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - return _wrap_Directory_createDirectory__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Directory_createDirectory'\n" - " Possible C/C++ prototypes are:\n" " ofDirectory::createDirectory(std::string const &,bool,bool)\n" - " ofDirectory::createDirectory(std::string const &,bool)\n" " ofDirectory::createDirectory(std::string const &)\n"); - lua_error(L);return 0; } -static int _wrap_Directory_isDirectoryEmpty__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; bool arg2 ; - std::string temp1 ; bool result; SWIG_check_num_args("ofDirectory::isDirectoryEmpty",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofDirectory::isDirectoryEmpty",1,"std::string const &"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofDirectory::isDirectoryEmpty",2,"bool"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; arg2 = (lua_toboolean(L, 2)!=0); - result = (bool)ofDirectory::isDirectoryEmpty((std::string const &)*arg1,arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_isDirectoryEmpty__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; - std::string temp1 ; bool result; SWIG_check_num_args("ofDirectory::isDirectoryEmpty",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofDirectory::isDirectoryEmpty",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; - result = (bool)ofDirectory::isDirectoryEmpty((std::string const &)*arg1); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_isDirectoryEmpty(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); - if (argc == 1) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { return _wrap_Directory_isDirectoryEmpty__SWIG_1(L);} } - if (argc == 2) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_Directory_isDirectoryEmpty__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Directory_isDirectoryEmpty'\n" - " Possible C/C++ prototypes are:\n" " ofDirectory::isDirectoryEmpty(std::string const &,bool)\n" - " ofDirectory::isDirectoryEmpty(std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_Directory_doesDirectoryExist__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; bool arg2 ; - std::string temp1 ; bool result; SWIG_check_num_args("ofDirectory::doesDirectoryExist",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofDirectory::doesDirectoryExist",1,"std::string const &"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofDirectory::doesDirectoryExist",2,"bool"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; arg2 = (lua_toboolean(L, 2)!=0); - result = (bool)ofDirectory::doesDirectoryExist((std::string const &)*arg1,arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_doesDirectoryExist__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; - std::string temp1 ; bool result; SWIG_check_num_args("ofDirectory::doesDirectoryExist",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofDirectory::doesDirectoryExist",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; - result = (bool)ofDirectory::doesDirectoryExist((std::string const &)*arg1); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_doesDirectoryExist(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); - if (argc == 1) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { return _wrap_Directory_doesDirectoryExist__SWIG_1(L);} } - if (argc == 2) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_Directory_doesDirectoryExist__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Directory_doesDirectoryExist'\n" - " Possible C/C++ prototypes are:\n" " ofDirectory::doesDirectoryExist(std::string const &,bool)\n" - " ofDirectory::doesDirectoryExist(std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_Directory_removeDirectory__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; bool arg2 ; - bool arg3 ; std::string temp1 ; bool result; SWIG_check_num_args("ofDirectory::removeDirectory",3,3) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofDirectory::removeDirectory",1,"std::string const &"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofDirectory::removeDirectory",2,"bool"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofDirectory::removeDirectory",3,"bool"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; arg2 = (lua_toboolean(L, 2)!=0); - arg3 = (lua_toboolean(L, 3)!=0); result = (bool)ofDirectory::removeDirectory((std::string const &)*arg1,arg2,arg3); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_removeDirectory__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; bool arg2 ; - std::string temp1 ; bool result; SWIG_check_num_args("ofDirectory::removeDirectory",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofDirectory::removeDirectory",1,"std::string const &"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofDirectory::removeDirectory",2,"bool"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; arg2 = (lua_toboolean(L, 2)!=0); - result = (bool)ofDirectory::removeDirectory((std::string const &)*arg1,arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_Directory_removeDirectory(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_Directory_removeDirectory__SWIG_1(L);} } } if (argc == 3) { int _v; { _v = lua_isstring(L,argv[0]); } - if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - return _wrap_Directory_removeDirectory__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'Directory_removeDirectory'\n" - " Possible C/C++ prototypes are:\n" " ofDirectory::removeDirectory(std::string const &,bool,bool)\n" - " ofDirectory::removeDirectory(std::string const &,bool)\n"); lua_error(L);return 0; } -static void swig_delete_Directory(void *obj) { -ofDirectory *arg1 = (ofDirectory *) obj; -delete arg1; -} -static int _proxy__wrap_new_Directory(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_Directory); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_Directory_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_Directory_methods[]= { - { "open", _wrap_Directory_open}, - { "close", _wrap_Directory_close}, - { "create", _wrap_Directory_create}, - { "exists", _wrap_Directory_exists}, - { "path", _wrap_Directory_path}, - { "getAbsolutePath", _wrap_Directory_getAbsolutePath}, - { "canRead", _wrap_Directory_canRead}, - { "canWrite", _wrap_Directory_canWrite}, - { "canExecute", _wrap_Directory_canExecute}, - { "isDirectory", _wrap_Directory_isDirectory}, - { "isHidden", _wrap_Directory_isHidden}, - { "setWriteable", _wrap_Directory_setWriteable}, - { "setReadOnly", _wrap_Directory_setReadOnly}, - { "setExecutable", _wrap_Directory_setExecutable}, - { "setShowHidden", _wrap_Directory_setShowHidden}, - { "copyTo", _wrap_Directory_copyTo}, - { "moveTo", _wrap_Directory_moveTo}, - { "renameTo", _wrap_Directory_renameTo}, - { "remove", _wrap_Directory_remove}, - { "allowExt", _wrap_Directory_allowExt}, - { "listDir", _wrap_Directory_listDir}, - { "getOriginalDirectory", _wrap_Directory_getOriginalDirectory}, - { "getName", _wrap_Directory_getName}, - { "getPath", _wrap_Directory_getPath}, - { "getFile", _wrap_Directory_getFile}, - { "getFiles", _wrap_Directory_getFiles}, - { "getShowHidden", _wrap_Directory_getShowHidden}, - { "reset", _wrap_Directory_reset}, - { "sort", _wrap_Directory_sort}, - { "getSorted", _wrap_Directory_getSorted}, - { "size", _wrap_Directory_size}, - { "__eq", _wrap_Directory___eq}, - { "__lt", _wrap_Directory___lt}, - { "__le", _wrap_Directory___le}, - {0,0} -}; -static swig_lua_method swig_Directory_meta[] = { - { "__eq", _wrap_Directory___eq}, - { "__lt", _wrap_Directory___lt}, - { "__le", _wrap_Directory___le}, - {0,0} -}; - -static swig_lua_attribute swig_Directory_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_Directory_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_Directory_Sf_SwigStatic_methods[]= { - { "createDirectory", _wrap_Directory_createDirectory}, - { "isDirectoryEmpty", _wrap_Directory_isDirectoryEmpty}, - { "doesDirectoryExist", _wrap_Directory_doesDirectoryExist}, - { "removeDirectory", _wrap_Directory_removeDirectory}, - {0,0} -}; -static swig_lua_class* swig_Directory_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_Directory_Sf_SwigStatic = { - "Directory", - swig_Directory_Sf_SwigStatic_methods, - swig_Directory_Sf_SwigStatic_attributes, - swig_Directory_Sf_SwigStatic_constants, - swig_Directory_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_Directory_bases[] = {0}; -static const char *swig_Directory_base_names[] = {0}; -static swig_lua_class _wrap_class_Directory = { "Directory", "Directory", &SWIGTYPE_p_ofDirectory,_proxy__wrap_new_Directory, swig_delete_Directory, swig_Directory_methods, swig_Directory_attributes, &swig_Directory_Sf_SwigStatic, swig_Directory_meta, swig_Directory_bases, swig_Directory_base_names }; - -static int _wrap_log(lua_State* L) { int SWIG_arg = 0; ofLogLevel arg1 ; std::string *arg2 = 0 ; std::string temp2 ; - SWIG_check_num_args("log",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("log",1,"ofLogLevel"); - if(!lua_isstring(L,2)) SWIG_fail_arg("log",2,"std::string const &"); arg1 = (ofLogLevel)(int)lua_tonumber(L, 1); - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; log(arg1,(std::string const &)*arg2); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setLogLevel__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofLogLevel arg1 ; - SWIG_check_num_args("ofSetLogLevel",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSetLogLevel",1,"ofLogLevel"); - arg1 = (ofLogLevel)(int)lua_tonumber(L, 1); ofSetLogLevel(arg1); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_setLogLevel__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string arg1 ; ofLogLevel arg2 ; - SWIG_check_num_args("ofSetLogLevel",2,2) if(!lua_isstring(L,1)) SWIG_fail_arg("ofSetLogLevel",1,"std::string"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofSetLogLevel",2,"ofLogLevel"); (&arg1)->assign(lua_tostring(L,1),lua_rawlen(L,1)); - arg2 = (ofLogLevel)(int)lua_tonumber(L, 2); ofSetLogLevel(arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_setLogLevel(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_setLogLevel__SWIG_0(L);} } if (argc == 2) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { - return _wrap_setLogLevel__SWIG_1(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'setLogLevel'\n" " Possible C/C++ prototypes are:\n" - " ofSetLogLevel(ofLogLevel)\n" " ofSetLogLevel(std::string,ofLogLevel)\n"); lua_error(L);return 0; } -static int _wrap_getLogLevel(lua_State* L) { int SWIG_arg = 0; ofLogLevel result; SWIG_check_num_args("ofGetLogLevel",0,0) - result = (ofLogLevel)ofGetLogLevel(); lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getLogLevelName__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofLogLevel arg1 ; bool arg2 ; std::string result; - SWIG_check_num_args("ofGetLogLevelName",2,2) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofGetLogLevelName",1,"ofLogLevel"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofGetLogLevelName",2,"bool"); arg1 = (ofLogLevel)(int)lua_tonumber(L, 1); - arg2 = (lua_toboolean(L, 2)!=0); result = ofGetLogLevelName(arg1,arg2); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_getLogLevelName__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofLogLevel arg1 ; std::string result; - SWIG_check_num_args("ofGetLogLevelName",1,1) if(!lua_isnumber(L,1)) SWIG_fail_arg("ofGetLogLevelName",1,"ofLogLevel"); - arg1 = (ofLogLevel)(int)lua_tonumber(L, 1); result = ofGetLogLevelName(arg1); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_getLogLevelName(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; - { _v = lua_isnumber(L,argv[0]); } if (_v) { return _wrap_getLogLevelName__SWIG_1(L);} } if (argc == 2) { int _v; { - _v = lua_isnumber(L,argv[0]); } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_getLogLevelName__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'getLogLevelName'\n" " Possible C/C++ prototypes are:\n" - " ofGetLogLevelName(ofLogLevel,bool)\n" " ofGetLogLevelName(ofLogLevel)\n"); lua_error(L);return 0; } -static int _wrap_logToFile__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; bool arg2 ; std::string temp1 ; - SWIG_check_num_args("ofLogToFile",2,2) if(!lua_isstring(L,1)) SWIG_fail_arg("ofLogToFile",1,"std::string const &"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofLogToFile",2,"bool"); temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; - arg2 = (lua_toboolean(L, 2)!=0); ofLogToFile((std::string const &)*arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_logToFile__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - SWIG_check_num_args("ofLogToFile",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofLogToFile",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; ofLogToFile((std::string const &)*arg1); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_logToFile(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { return _wrap_logToFile__SWIG_1(L);} } if (argc == 2) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_logToFile__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'logToFile'\n" " Possible C/C++ prototypes are:\n" - " ofLogToFile(std::string const &,bool)\n" " ofLogToFile(std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_logToConsole(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofLogToConsole",0,0) ofLogToConsole(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_new_FileDialogResult(lua_State* L) { int SWIG_arg = 0; ofFileDialogResult *result = 0 ; - SWIG_check_num_args("ofFileDialogResult::ofFileDialogResult",0,0) result = (ofFileDialogResult *)new ofFileDialogResult(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofFileDialogResult,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_FileDialogResult_getName(lua_State* L) { int SWIG_arg = 0; - ofFileDialogResult *arg1 = (ofFileDialogResult *) 0 ; std::string result; - SWIG_check_num_args("ofFileDialogResult::getName",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFileDialogResult::getName",1,"ofFileDialogResult *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFileDialogResult,0))){ - SWIG_fail_ptr("FileDialogResult_getName",1,SWIGTYPE_p_ofFileDialogResult); } result = (arg1)->getName(); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FileDialogResult_getPath(lua_State* L) { int SWIG_arg = 0; - ofFileDialogResult *arg1 = (ofFileDialogResult *) 0 ; std::string result; - SWIG_check_num_args("ofFileDialogResult::getPath",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFileDialogResult::getPath",1,"ofFileDialogResult *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFileDialogResult,0))){ - SWIG_fail_ptr("FileDialogResult_getPath",1,SWIGTYPE_p_ofFileDialogResult); } result = (arg1)->getPath(); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_FileDialogResult_filePath_set(lua_State* L) { int SWIG_arg = 0; - ofFileDialogResult *arg1 = (ofFileDialogResult *) 0 ; std::string *arg2 = 0 ; std::string temp2 ; - SWIG_check_num_args("ofFileDialogResult::filePath",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFileDialogResult::filePath",1,"ofFileDialogResult *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofFileDialogResult::filePath",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFileDialogResult,0))){ - SWIG_fail_ptr("FileDialogResult_filePath_set",1,SWIGTYPE_p_ofFileDialogResult); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; if (arg1) (arg1)->filePath = *arg2; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FileDialogResult_filePath_get(lua_State* L) { int SWIG_arg = 0; - ofFileDialogResult *arg1 = (ofFileDialogResult *) 0 ; std::string *result = 0 ; - SWIG_check_num_args("ofFileDialogResult::filePath",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFileDialogResult::filePath",1,"ofFileDialogResult *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFileDialogResult,0))){ - SWIG_fail_ptr("FileDialogResult_filePath_get",1,SWIGTYPE_p_ofFileDialogResult); } - result = (std::string *) & ((arg1)->filePath); lua_pushlstring(L,result->data(),result->size()); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FileDialogResult_fileName_set(lua_State* L) { int SWIG_arg = 0; - ofFileDialogResult *arg1 = (ofFileDialogResult *) 0 ; std::string *arg2 = 0 ; std::string temp2 ; - SWIG_check_num_args("ofFileDialogResult::fileName",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFileDialogResult::fileName",1,"ofFileDialogResult *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofFileDialogResult::fileName",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFileDialogResult,0))){ - SWIG_fail_ptr("FileDialogResult_fileName_set",1,SWIGTYPE_p_ofFileDialogResult); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; if (arg1) (arg1)->fileName = *arg2; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FileDialogResult_fileName_get(lua_State* L) { int SWIG_arg = 0; - ofFileDialogResult *arg1 = (ofFileDialogResult *) 0 ; std::string *result = 0 ; - SWIG_check_num_args("ofFileDialogResult::fileName",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFileDialogResult::fileName",1,"ofFileDialogResult *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFileDialogResult,0))){ - SWIG_fail_ptr("FileDialogResult_fileName_get",1,SWIGTYPE_p_ofFileDialogResult); } - result = (std::string *) & ((arg1)->fileName); lua_pushlstring(L,result->data(),result->size()); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FileDialogResult_bSuccess_set(lua_State* L) { int SWIG_arg = 0; - ofFileDialogResult *arg1 = (ofFileDialogResult *) 0 ; bool arg2 ; SWIG_check_num_args("ofFileDialogResult::bSuccess",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFileDialogResult::bSuccess",1,"ofFileDialogResult *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofFileDialogResult::bSuccess",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFileDialogResult,0))){ - SWIG_fail_ptr("FileDialogResult_bSuccess_set",1,SWIGTYPE_p_ofFileDialogResult); } arg2 = (lua_toboolean(L, 2)!=0); - if (arg1) (arg1)->bSuccess = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_FileDialogResult_bSuccess_get(lua_State* L) { int SWIG_arg = 0; - ofFileDialogResult *arg1 = (ofFileDialogResult *) 0 ; bool result; SWIG_check_num_args("ofFileDialogResult::bSuccess",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofFileDialogResult::bSuccess",1,"ofFileDialogResult *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofFileDialogResult,0))){ - SWIG_fail_ptr("FileDialogResult_bSuccess_get",1,SWIGTYPE_p_ofFileDialogResult); } result = (bool) ((arg1)->bSuccess); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_FileDialogResult(void *obj) { -ofFileDialogResult *arg1 = (ofFileDialogResult *) obj; -delete arg1; -} -static int _proxy__wrap_new_FileDialogResult(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_FileDialogResult); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_FileDialogResult_attributes[] = { - { "filePath", _wrap_FileDialogResult_filePath_get, _wrap_FileDialogResult_filePath_set }, - { "fileName", _wrap_FileDialogResult_fileName_get, _wrap_FileDialogResult_fileName_set }, - { "bSuccess", _wrap_FileDialogResult_bSuccess_get, _wrap_FileDialogResult_bSuccess_set }, - {0,0,0} -}; -static swig_lua_method swig_FileDialogResult_methods[]= { - { "getName", _wrap_FileDialogResult_getName}, - { "getPath", _wrap_FileDialogResult_getPath}, - {0,0} -}; -static swig_lua_method swig_FileDialogResult_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_FileDialogResult_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_FileDialogResult_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_FileDialogResult_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_FileDialogResult_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_FileDialogResult_Sf_SwigStatic = { - "FileDialogResult", - swig_FileDialogResult_Sf_SwigStatic_methods, - swig_FileDialogResult_Sf_SwigStatic_attributes, - swig_FileDialogResult_Sf_SwigStatic_constants, - swig_FileDialogResult_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_FileDialogResult_bases[] = {0}; -static const char *swig_FileDialogResult_base_names[] = {0}; -static swig_lua_class _wrap_class_FileDialogResult = { "FileDialogResult", "FileDialogResult", &SWIGTYPE_p_ofFileDialogResult,_proxy__wrap_new_FileDialogResult, swig_delete_FileDialogResult, swig_FileDialogResult_methods, swig_FileDialogResult_attributes, &swig_FileDialogResult_Sf_SwigStatic, swig_FileDialogResult_meta, swig_FileDialogResult_bases, swig_FileDialogResult_base_names }; - -static int _wrap_systemAlertDialog(lua_State* L) { int SWIG_arg = 0; std::string arg1 ; - SWIG_check_num_args("ofSystemAlertDialog",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofSystemAlertDialog",1,"std::string"); - (&arg1)->assign(lua_tostring(L,1),lua_rawlen(L,1)); ofSystemAlertDialog(arg1); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_systemLoadDialog__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string arg1 ; bool arg2 ; std::string arg3 ; - ofFileDialogResult result; SWIG_check_num_args("ofSystemLoadDialog",3,3) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofSystemLoadDialog",1,"std::string"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofSystemLoadDialog",2,"bool"); - if(!lua_isstring(L,3)) SWIG_fail_arg("ofSystemLoadDialog",3,"std::string"); - (&arg1)->assign(lua_tostring(L,1),lua_rawlen(L,1)); arg2 = (lua_toboolean(L, 2)!=0); - (&arg3)->assign(lua_tostring(L,3),lua_rawlen(L,3)); result = ofSystemLoadDialog(arg1,arg2,arg3); { - ofFileDialogResult * resultptr = new ofFileDialogResult((const ofFileDialogResult &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofFileDialogResult,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_systemLoadDialog__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string arg1 ; bool arg2 ; - ofFileDialogResult result; SWIG_check_num_args("ofSystemLoadDialog",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofSystemLoadDialog",1,"std::string"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofSystemLoadDialog",2,"bool"); (&arg1)->assign(lua_tostring(L,1),lua_rawlen(L,1)); - arg2 = (lua_toboolean(L, 2)!=0); result = ofSystemLoadDialog(arg1,arg2); { - ofFileDialogResult * resultptr = new ofFileDialogResult((const ofFileDialogResult &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofFileDialogResult,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_systemLoadDialog__SWIG_2(lua_State* L) { int SWIG_arg = 0; std::string arg1 ; ofFileDialogResult result; - SWIG_check_num_args("ofSystemLoadDialog",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofSystemLoadDialog",1,"std::string"); - (&arg1)->assign(lua_tostring(L,1),lua_rawlen(L,1)); result = ofSystemLoadDialog(arg1); { - ofFileDialogResult * resultptr = new ofFileDialogResult((const ofFileDialogResult &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofFileDialogResult,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_systemLoadDialog__SWIG_3(lua_State* L) { int SWIG_arg = 0; ofFileDialogResult result; - SWIG_check_num_args("ofSystemLoadDialog",0,0) result = ofSystemLoadDialog(); { - ofFileDialogResult * resultptr = new ofFileDialogResult((const ofFileDialogResult &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofFileDialogResult,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_systemLoadDialog(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_systemLoadDialog__SWIG_3(L);} if (argc == 1) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { - return _wrap_systemLoadDialog__SWIG_2(L);} } if (argc == 2) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { { - _v = lua_isboolean(L,argv[1]); } if (_v) { return _wrap_systemLoadDialog__SWIG_1(L);} } } if (argc == 3) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { { _v = lua_isstring(L,argv[2]); } - if (_v) { return _wrap_systemLoadDialog__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'systemLoadDialog'\n" " Possible C/C++ prototypes are:\n" - " ofSystemLoadDialog(std::string,bool,std::string)\n" " ofSystemLoadDialog(std::string,bool)\n" - " ofSystemLoadDialog(std::string)\n" " ofSystemLoadDialog()\n"); lua_error(L);return 0; } -static int _wrap_systemSaveDialog(lua_State* L) { int SWIG_arg = 0; std::string arg1 ; std::string arg2 ; - ofFileDialogResult result; SWIG_check_num_args("ofSystemSaveDialog",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofSystemSaveDialog",1,"std::string"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofSystemSaveDialog",2,"std::string"); - (&arg1)->assign(lua_tostring(L,1),lua_rawlen(L,1)); (&arg2)->assign(lua_tostring(L,2),lua_rawlen(L,2)); - result = ofSystemSaveDialog(arg1,arg2); { - ofFileDialogResult * resultptr = new ofFileDialogResult((const ofFileDialogResult &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofFileDialogResult,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_systemTextBoxDialog__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string arg1 ; std::string arg2 ; - std::string result; SWIG_check_num_args("ofSystemTextBoxDialog",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofSystemTextBoxDialog",1,"std::string"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofSystemTextBoxDialog",2,"std::string"); - (&arg1)->assign(lua_tostring(L,1),lua_rawlen(L,1)); (&arg2)->assign(lua_tostring(L,2),lua_rawlen(L,2)); - result = ofSystemTextBoxDialog(arg1,arg2); lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_systemTextBoxDialog__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string arg1 ; std::string result; - SWIG_check_num_args("ofSystemTextBoxDialog",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofSystemTextBoxDialog",1,"std::string"); - (&arg1)->assign(lua_tostring(L,1),lua_rawlen(L,1)); result = ofSystemTextBoxDialog(arg1); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_systemTextBoxDialog(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { return _wrap_systemTextBoxDialog__SWIG_1(L);} } if (argc == 2) { - int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { - return _wrap_systemTextBoxDialog__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'systemTextBoxDialog'\n" - " Possible C/C++ prototypes are:\n" " ofSystemTextBoxDialog(std::string,std::string)\n" - " ofSystemTextBoxDialog(std::string)\n"); lua_error(L);return 0; } -static int _wrap_new_HttpRequest__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofHttpRequest *result = 0 ; - SWIG_check_num_args("ofHttpRequest::ofHttpRequest",0,0) result = (ofHttpRequest *)new ofHttpRequest(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofHttpRequest,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_HttpRequest__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; - bool arg3 ; std::string temp1 ; std::string temp2 ; ofHttpRequest *result = 0 ; - SWIG_check_num_args("ofHttpRequest::ofHttpRequest",3,3) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofHttpRequest::ofHttpRequest",1,"std::string const &"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofHttpRequest::ofHttpRequest",2,"std::string const &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofHttpRequest::ofHttpRequest",3,"bool"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - arg3 = (lua_toboolean(L, 3)!=0); - result = (ofHttpRequest *)new ofHttpRequest((std::string const &)*arg1,(std::string const &)*arg2,arg3); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofHttpRequest,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_HttpRequest__SWIG_2(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; - std::string temp1 ; std::string temp2 ; ofHttpRequest *result = 0 ; SWIG_check_num_args("ofHttpRequest::ofHttpRequest",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofHttpRequest::ofHttpRequest",1,"std::string const &"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofHttpRequest::ofHttpRequest",2,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = (ofHttpRequest *)new ofHttpRequest((std::string const &)*arg1,(std::string const &)*arg2); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofHttpRequest,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_HttpRequest(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_HttpRequest__SWIG_0(L);} if (argc == 2) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { { - _v = lua_isstring(L,argv[1]); } if (_v) { return _wrap_new_HttpRequest__SWIG_2(L);} } } if (argc == 3) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } - if (_v) { return _wrap_new_HttpRequest__SWIG_1(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_HttpRequest'\n" " Possible C/C++ prototypes are:\n" - " ofHttpRequest::ofHttpRequest()\n" " ofHttpRequest::ofHttpRequest(std::string const &,std::string const &,bool)\n" - " ofHttpRequest::ofHttpRequest(std::string const &,std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_HttpRequest_url_set(lua_State* L) { int SWIG_arg = 0; ofHttpRequest *arg1 = (ofHttpRequest *) 0 ; - std::string *arg2 = 0 ; std::string temp2 ; SWIG_check_num_args("ofHttpRequest::url",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofHttpRequest::url",1,"ofHttpRequest *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofHttpRequest::url",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofHttpRequest,0))){ - SWIG_fail_ptr("HttpRequest_url_set",1,SWIGTYPE_p_ofHttpRequest); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; if (arg1) (arg1)->url = *arg2; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_HttpRequest_url_get(lua_State* L) { int SWIG_arg = 0; ofHttpRequest *arg1 = (ofHttpRequest *) 0 ; - std::string *result = 0 ; SWIG_check_num_args("ofHttpRequest::url",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofHttpRequest::url",1,"ofHttpRequest *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofHttpRequest,0))){ - SWIG_fail_ptr("HttpRequest_url_get",1,SWIGTYPE_p_ofHttpRequest); } result = (std::string *) & ((arg1)->url); - lua_pushlstring(L,result->data(),result->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_HttpRequest_name_set(lua_State* L) { int SWIG_arg = 0; ofHttpRequest *arg1 = (ofHttpRequest *) 0 ; - std::string *arg2 = 0 ; std::string temp2 ; SWIG_check_num_args("ofHttpRequest::name",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofHttpRequest::name",1,"ofHttpRequest *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofHttpRequest::name",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofHttpRequest,0))){ - SWIG_fail_ptr("HttpRequest_name_set",1,SWIGTYPE_p_ofHttpRequest); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; if (arg1) (arg1)->name = *arg2; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_HttpRequest_name_get(lua_State* L) { int SWIG_arg = 0; ofHttpRequest *arg1 = (ofHttpRequest *) 0 ; - std::string *result = 0 ; SWIG_check_num_args("ofHttpRequest::name",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofHttpRequest::name",1,"ofHttpRequest *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofHttpRequest,0))){ - SWIG_fail_ptr("HttpRequest_name_get",1,SWIGTYPE_p_ofHttpRequest); } result = (std::string *) & ((arg1)->name); - lua_pushlstring(L,result->data(),result->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_HttpRequest_saveTo_set(lua_State* L) { int SWIG_arg = 0; ofHttpRequest *arg1 = (ofHttpRequest *) 0 ; - bool arg2 ; SWIG_check_num_args("ofHttpRequest::saveTo",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofHttpRequest::saveTo",1,"ofHttpRequest *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofHttpRequest::saveTo",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofHttpRequest,0))){ - SWIG_fail_ptr("HttpRequest_saveTo_set",1,SWIGTYPE_p_ofHttpRequest); } arg2 = (lua_toboolean(L, 2)!=0); - if (arg1) (arg1)->saveTo = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_HttpRequest_saveTo_get(lua_State* L) { int SWIG_arg = 0; ofHttpRequest *arg1 = (ofHttpRequest *) 0 ; - bool result; SWIG_check_num_args("ofHttpRequest::saveTo",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofHttpRequest::saveTo",1,"ofHttpRequest *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofHttpRequest,0))){ - SWIG_fail_ptr("HttpRequest_saveTo_get",1,SWIGTYPE_p_ofHttpRequest); } result = (bool) ((arg1)->saveTo); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_HttpRequest_headers_set(lua_State* L) { int SWIG_arg = 0; ofHttpRequest *arg1 = (ofHttpRequest *) 0 ; - std::map< std::string,std::string > *arg2 = (std::map< std::string,std::string > *) 0 ; - SWIG_check_num_args("ofHttpRequest::headers",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofHttpRequest::headers",1,"ofHttpRequest *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofHttpRequest::headers",2,"std::map< std::string,std::string > *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofHttpRequest,0))){ - SWIG_fail_ptr("HttpRequest_headers_set",1,SWIGTYPE_p_ofHttpRequest); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_std__mapT_std__string_std__string_t,0))){ - SWIG_fail_ptr("HttpRequest_headers_set",2,SWIGTYPE_p_std__mapT_std__string_std__string_t); } - if (arg1) (arg1)->headers = *arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_HttpRequest_headers_get(lua_State* L) { int SWIG_arg = 0; ofHttpRequest *arg1 = (ofHttpRequest *) 0 ; - std::map< std::string,std::string > *result = 0 ; SWIG_check_num_args("ofHttpRequest::headers",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofHttpRequest::headers",1,"ofHttpRequest *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofHttpRequest,0))){ - SWIG_fail_ptr("HttpRequest_headers_get",1,SWIGTYPE_p_ofHttpRequest); } - result = (std::map< std::string,std::string > *)& ((arg1)->headers); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__mapT_std__string_std__string_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_HttpRequest_getId(lua_State* L) { int SWIG_arg = 0; ofHttpRequest *arg1 = (ofHttpRequest *) 0 ; int result; - SWIG_check_num_args("ofHttpRequest::getId",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofHttpRequest::getId",1,"ofHttpRequest const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofHttpRequest,0))){ - SWIG_fail_ptr("HttpRequest_getId",1,SWIGTYPE_p_ofHttpRequest); } result = (int)((ofHttpRequest const *)arg1)->getId(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_HttpRequest(void *obj) { -ofHttpRequest *arg1 = (ofHttpRequest *) obj; -delete arg1; -} -static int _proxy__wrap_new_HttpRequest(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_HttpRequest); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_HttpRequest_attributes[] = { - { "url", _wrap_HttpRequest_url_get, _wrap_HttpRequest_url_set }, - { "name", _wrap_HttpRequest_name_get, _wrap_HttpRequest_name_set }, - { "saveTo", _wrap_HttpRequest_saveTo_get, _wrap_HttpRequest_saveTo_set }, - { "headers", _wrap_HttpRequest_headers_get, _wrap_HttpRequest_headers_set }, - {0,0,0} -}; -static swig_lua_method swig_HttpRequest_methods[]= { - { "getId", _wrap_HttpRequest_getId}, - {0,0} -}; -static swig_lua_method swig_HttpRequest_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_HttpRequest_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_HttpRequest_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_HttpRequest_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_HttpRequest_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_HttpRequest_Sf_SwigStatic = { - "HttpRequest", - swig_HttpRequest_Sf_SwigStatic_methods, - swig_HttpRequest_Sf_SwigStatic_attributes, - swig_HttpRequest_Sf_SwigStatic_constants, - swig_HttpRequest_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_HttpRequest_bases[] = {0}; -static const char *swig_HttpRequest_base_names[] = {0}; -static swig_lua_class _wrap_class_HttpRequest = { "HttpRequest", "HttpRequest", &SWIGTYPE_p_ofHttpRequest,_proxy__wrap_new_HttpRequest, swig_delete_HttpRequest, swig_HttpRequest_methods, swig_HttpRequest_attributes, &swig_HttpRequest_Sf_SwigStatic, swig_HttpRequest_meta, swig_HttpRequest_bases, swig_HttpRequest_base_names }; - -static int _wrap_new_HttpResponse__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofHttpResponse *result = 0 ; - SWIG_check_num_args("ofHttpResponse::ofHttpResponse",0,0) result = (ofHttpResponse *)new ofHttpResponse(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofHttpResponse,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_HttpResponse__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofHttpRequest *arg1 = 0 ; ofBuffer *arg2 = 0 ; - int arg3 ; std::string *arg4 = 0 ; std::string temp4 ; ofHttpResponse *result = 0 ; - SWIG_check_num_args("ofHttpResponse::ofHttpResponse",4,4) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofHttpResponse::ofHttpResponse",1,"ofHttpRequest const &"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofHttpResponse::ofHttpResponse",2,"ofBuffer const &"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofHttpResponse::ofHttpResponse",3,"int"); - if(!lua_isstring(L,4)) SWIG_fail_arg("ofHttpResponse::ofHttpResponse",4,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofHttpRequest,0))){ - SWIG_fail_ptr("new_HttpResponse",1,SWIGTYPE_p_ofHttpRequest); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBuffer,0))){ - SWIG_fail_ptr("new_HttpResponse",2,SWIGTYPE_p_ofBuffer); } arg3 = (int)lua_tonumber(L, 3); - temp4.assign(lua_tostring(L,4),lua_rawlen(L,4)); arg4=&temp4; - result = (ofHttpResponse *)new ofHttpResponse((ofHttpRequest const &)*arg1,(ofBuffer const &)*arg2,arg3,(std::string const &)*arg4); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofHttpResponse,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_HttpResponse__SWIG_2(lua_State* L) { int SWIG_arg = 0; ofHttpRequest *arg1 = 0 ; int arg2 ; - std::string *arg3 = 0 ; std::string temp3 ; ofHttpResponse *result = 0 ; - SWIG_check_num_args("ofHttpResponse::ofHttpResponse",3,3) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofHttpResponse::ofHttpResponse",1,"ofHttpRequest const &"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofHttpResponse::ofHttpResponse",2,"int"); - if(!lua_isstring(L,3)) SWIG_fail_arg("ofHttpResponse::ofHttpResponse",3,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofHttpRequest,0))){ - SWIG_fail_ptr("new_HttpResponse",1,SWIGTYPE_p_ofHttpRequest); } arg2 = (int)lua_tonumber(L, 2); - temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3; - result = (ofHttpResponse *)new ofHttpResponse((ofHttpRequest const &)*arg1,arg2,(std::string const &)*arg3); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofHttpResponse,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_HttpResponse(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_new_HttpResponse__SWIG_0(L);} if (argc == 3) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofHttpRequest, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isstring(L,argv[2]); } if (_v) { - return _wrap_new_HttpResponse__SWIG_2(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (lua_isuserdata(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofHttpRequest, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofBuffer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isstring(L,argv[3]); } - if (_v) { return _wrap_new_HttpResponse__SWIG_1(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'new_HttpResponse'\n" " Possible C/C++ prototypes are:\n" - " ofHttpResponse::ofHttpResponse()\n" - " ofHttpResponse::ofHttpResponse(ofHttpRequest const &,ofBuffer const &,int,std::string const &)\n" - " ofHttpResponse::ofHttpResponse(ofHttpRequest const &,int,std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_HttpResponse_request_set(lua_State* L) { int SWIG_arg = 0; ofHttpResponse *arg1 = (ofHttpResponse *) 0 ; - ofHttpRequest *arg2 = (ofHttpRequest *) 0 ; SWIG_check_num_args("ofHttpResponse::request",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofHttpResponse::request",1,"ofHttpResponse *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofHttpResponse::request",2,"ofHttpRequest *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofHttpResponse,0))){ - SWIG_fail_ptr("HttpResponse_request_set",1,SWIGTYPE_p_ofHttpResponse); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofHttpRequest,0))){ - SWIG_fail_ptr("HttpResponse_request_set",2,SWIGTYPE_p_ofHttpRequest); } if (arg1) (arg1)->request = *arg2; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_HttpResponse_request_get(lua_State* L) { int SWIG_arg = 0; ofHttpResponse *arg1 = (ofHttpResponse *) 0 ; - ofHttpRequest *result = 0 ; SWIG_check_num_args("ofHttpResponse::request",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofHttpResponse::request",1,"ofHttpResponse *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofHttpResponse,0))){ - SWIG_fail_ptr("HttpResponse_request_get",1,SWIGTYPE_p_ofHttpResponse); } result = (ofHttpRequest *)& ((arg1)->request); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofHttpRequest,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_HttpResponse_data_set(lua_State* L) { int SWIG_arg = 0; ofHttpResponse *arg1 = (ofHttpResponse *) 0 ; - ofBuffer *arg2 = (ofBuffer *) 0 ; SWIG_check_num_args("ofHttpResponse::data",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofHttpResponse::data",1,"ofHttpResponse *"); - if(!SWIG_isptrtype(L,2)) SWIG_fail_arg("ofHttpResponse::data",2,"ofBuffer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofHttpResponse,0))){ - SWIG_fail_ptr("HttpResponse_data_set",1,SWIGTYPE_p_ofHttpResponse); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofBuffer,0))){ - SWIG_fail_ptr("HttpResponse_data_set",2,SWIGTYPE_p_ofBuffer); } if (arg1) (arg1)->data = *arg2; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_HttpResponse_data_get(lua_State* L) { int SWIG_arg = 0; ofHttpResponse *arg1 = (ofHttpResponse *) 0 ; - ofBuffer *result = 0 ; SWIG_check_num_args("ofHttpResponse::data",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofHttpResponse::data",1,"ofHttpResponse *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofHttpResponse,0))){ - SWIG_fail_ptr("HttpResponse_data_get",1,SWIGTYPE_p_ofHttpResponse); } result = (ofBuffer *)& ((arg1)->data); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofBuffer,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_HttpResponse_status_set(lua_State* L) { int SWIG_arg = 0; ofHttpResponse *arg1 = (ofHttpResponse *) 0 ; - int arg2 ; SWIG_check_num_args("ofHttpResponse::status",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofHttpResponse::status",1,"ofHttpResponse *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofHttpResponse::status",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofHttpResponse,0))){ - SWIG_fail_ptr("HttpResponse_status_set",1,SWIGTYPE_p_ofHttpResponse); } arg2 = (int)lua_tonumber(L, 2); - if (arg1) (arg1)->status = arg2; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_HttpResponse_status_get(lua_State* L) { int SWIG_arg = 0; ofHttpResponse *arg1 = (ofHttpResponse *) 0 ; - int result; SWIG_check_num_args("ofHttpResponse::status",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofHttpResponse::status",1,"ofHttpResponse *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofHttpResponse,0))){ - SWIG_fail_ptr("HttpResponse_status_get",1,SWIGTYPE_p_ofHttpResponse); } result = (int) ((arg1)->status); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_HttpResponse_error_set(lua_State* L) { int SWIG_arg = 0; ofHttpResponse *arg1 = (ofHttpResponse *) 0 ; - std::string *arg2 = 0 ; std::string temp2 ; SWIG_check_num_args("ofHttpResponse::error",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofHttpResponse::error",1,"ofHttpResponse *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofHttpResponse::error",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofHttpResponse,0))){ - SWIG_fail_ptr("HttpResponse_error_set",1,SWIGTYPE_p_ofHttpResponse); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; if (arg1) (arg1)->error = *arg2; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_HttpResponse_error_get(lua_State* L) { int SWIG_arg = 0; ofHttpResponse *arg1 = (ofHttpResponse *) 0 ; - std::string *result = 0 ; SWIG_check_num_args("ofHttpResponse::error",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofHttpResponse::error",1,"ofHttpResponse *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofHttpResponse,0))){ - SWIG_fail_ptr("HttpResponse_error_get",1,SWIGTYPE_p_ofHttpResponse); } result = (std::string *) & ((arg1)->error); - lua_pushlstring(L,result->data(),result->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static void swig_delete_HttpResponse(void *obj) { -ofHttpResponse *arg1 = (ofHttpResponse *) obj; -delete arg1; -} -static int _proxy__wrap_new_HttpResponse(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_HttpResponse); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_HttpResponse_attributes[] = { - { "request", _wrap_HttpResponse_request_get, _wrap_HttpResponse_request_set }, - { "data", _wrap_HttpResponse_data_get, _wrap_HttpResponse_data_set }, - { "status", _wrap_HttpResponse_status_get, _wrap_HttpResponse_status_set }, - { "error", _wrap_HttpResponse_error_get, _wrap_HttpResponse_error_set }, - {0,0,0} -}; -static swig_lua_method swig_HttpResponse_methods[]= { - {0,0} -}; -static swig_lua_method swig_HttpResponse_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_HttpResponse_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_HttpResponse_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_HttpResponse_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_HttpResponse_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_HttpResponse_Sf_SwigStatic = { - "HttpResponse", - swig_HttpResponse_Sf_SwigStatic_methods, - swig_HttpResponse_Sf_SwigStatic_attributes, - swig_HttpResponse_Sf_SwigStatic_constants, - swig_HttpResponse_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_HttpResponse_bases[] = {0}; -static const char *swig_HttpResponse_base_names[] = {0}; -static swig_lua_class _wrap_class_HttpResponse = { "HttpResponse", "HttpResponse", &SWIGTYPE_p_ofHttpResponse,_proxy__wrap_new_HttpResponse, swig_delete_HttpResponse, swig_HttpResponse_methods, swig_HttpResponse_attributes, &swig_HttpResponse_Sf_SwigStatic, swig_HttpResponse_meta, swig_HttpResponse_bases, swig_HttpResponse_base_names }; - -static int _wrap_loadURL(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; ofHttpResponse result; - SWIG_check_num_args("ofLoadURL",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofLoadURL",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = ofLoadURL((std::string const &)*arg1); { - ofHttpResponse * resultptr = new ofHttpResponse((const ofHttpResponse &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofHttpResponse,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_loadURLAsync__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; - std::string temp1 ; std::string temp2 ; int result; SWIG_check_num_args("ofLoadURLAsync",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofLoadURLAsync",1,"std::string const &"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofLoadURLAsync",2,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = (int)ofLoadURLAsync((std::string const &)*arg1,(std::string const &)*arg2); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_loadURLAsync__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; int result; - SWIG_check_num_args("ofLoadURLAsync",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofLoadURLAsync",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = (int)ofLoadURLAsync((std::string const &)*arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_loadURLAsync(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { return _wrap_loadURLAsync__SWIG_1(L);} } if (argc == 2) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { - return _wrap_loadURLAsync__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'loadURLAsync'\n" " Possible C/C++ prototypes are:\n" - " ofLoadURLAsync(std::string const &,std::string const &)\n" " ofLoadURLAsync(std::string const &)\n"); - lua_error(L);return 0; } -static int _wrap_saveURLTo(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; std::string temp1 ; - std::string temp2 ; ofHttpResponse result; SWIG_check_num_args("ofSaveURLTo",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofSaveURLTo",1,"std::string const &"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofSaveURLTo",2,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = ofSaveURLTo((std::string const &)*arg1,(std::string const &)*arg2); { - ofHttpResponse * resultptr = new ofHttpResponse((const ofHttpResponse &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofHttpResponse,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_saveURLAsync(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; - std::string temp1 ; std::string temp2 ; int result; SWIG_check_num_args("ofSaveURLAsync",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofSaveURLAsync",1,"std::string const &"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofSaveURLAsync",2,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = (int)ofSaveURLAsync((std::string const &)*arg1,(std::string const &)*arg2); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_removeURLRequest(lua_State* L) { int SWIG_arg = 0; int arg1 ; SWIG_check_num_args("ofRemoveURLRequest",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofRemoveURLRequest",1,"int"); arg1 = (int)lua_tonumber(L, 1); ofRemoveURLRequest(arg1); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_removeAllURLRequests(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofRemoveAllURLRequests",0,0) - ofRemoveAllURLRequests(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_stopURLLoader(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofStopURLLoader",0,0) ofStopURLLoader(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_uRLResponseEvent(lua_State* L) { int SWIG_arg = 0; ofEvent< ofHttpResponse > *result = 0 ; - SWIG_check_num_args("ofURLResponseEvent",0,0) result = (ofEvent< ofHttpResponse > *) &ofURLResponseEvent(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofEventT_ofHttpResponse_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_new_URLFileLoader(lua_State* L) { int SWIG_arg = 0; ofURLFileLoader *result = 0 ; - SWIG_check_num_args("ofURLFileLoader::ofURLFileLoader",0,0) result = (ofURLFileLoader *)new ofURLFileLoader(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofURLFileLoader,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_URLFileLoader_get(lua_State* L) { int SWIG_arg = 0; ofURLFileLoader *arg1 = (ofURLFileLoader *) 0 ; - std::string *arg2 = 0 ; std::string temp2 ; ofHttpResponse result; SWIG_check_num_args("ofURLFileLoader::get",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofURLFileLoader::get",1,"ofURLFileLoader *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofURLFileLoader::get",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofURLFileLoader,0))){ - SWIG_fail_ptr("URLFileLoader_get",1,SWIGTYPE_p_ofURLFileLoader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; result = (arg1)->get((std::string const &)*arg2); { - ofHttpResponse * resultptr = new ofHttpResponse((const ofHttpResponse &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofHttpResponse,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_URLFileLoader_getAsync__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofURLFileLoader *arg1 = (ofURLFileLoader *) 0 ; std::string *arg2 = 0 ; std::string *arg3 = 0 ; std::string temp2 ; - std::string temp3 ; int result; SWIG_check_num_args("ofURLFileLoader::getAsync",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofURLFileLoader::getAsync",1,"ofURLFileLoader *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofURLFileLoader::getAsync",2,"std::string const &"); - if(!lua_isstring(L,3)) SWIG_fail_arg("ofURLFileLoader::getAsync",3,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofURLFileLoader,0))){ - SWIG_fail_ptr("URLFileLoader_getAsync",1,SWIGTYPE_p_ofURLFileLoader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3; - result = (int)(arg1)->getAsync((std::string const &)*arg2,(std::string const &)*arg3); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_URLFileLoader_getAsync__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofURLFileLoader *arg1 = (ofURLFileLoader *) 0 ; std::string *arg2 = 0 ; std::string temp2 ; int result; - SWIG_check_num_args("ofURLFileLoader::getAsync",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofURLFileLoader::getAsync",1,"ofURLFileLoader *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofURLFileLoader::getAsync",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofURLFileLoader,0))){ - SWIG_fail_ptr("URLFileLoader_getAsync",1,SWIGTYPE_p_ofURLFileLoader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; result = (int)(arg1)->getAsync((std::string const &)*arg2); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_URLFileLoader_getAsync(lua_State* L) { int argc; int argv[4]={ 1,2,3,4} ; argc = lua_gettop(L); - if (argc == 2) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofURLFileLoader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { - return _wrap_URLFileLoader_getAsync__SWIG_1(L);} } } if (argc == 3) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofURLFileLoader, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isstring(L,argv[2]); } if (_v) { - return _wrap_URLFileLoader_getAsync__SWIG_0(L);} } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'URLFileLoader_getAsync'\n" - " Possible C/C++ prototypes are:\n" " ofURLFileLoader::getAsync(std::string const &,std::string const &)\n" - " ofURLFileLoader::getAsync(std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_URLFileLoader_saveTo(lua_State* L) { int SWIG_arg = 0; ofURLFileLoader *arg1 = (ofURLFileLoader *) 0 ; - std::string *arg2 = 0 ; std::string *arg3 = 0 ; std::string temp2 ; std::string temp3 ; ofHttpResponse result; - SWIG_check_num_args("ofURLFileLoader::saveTo",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofURLFileLoader::saveTo",1,"ofURLFileLoader *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofURLFileLoader::saveTo",2,"std::string const &"); - if(!lua_isstring(L,3)) SWIG_fail_arg("ofURLFileLoader::saveTo",3,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofURLFileLoader,0))){ - SWIG_fail_ptr("URLFileLoader_saveTo",1,SWIGTYPE_p_ofURLFileLoader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3; - result = (arg1)->saveTo((std::string const &)*arg2,(std::string const &)*arg3); { - ofHttpResponse * resultptr = new ofHttpResponse((const ofHttpResponse &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofHttpResponse,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_URLFileLoader_saveAsync(lua_State* L) { int SWIG_arg = 0; ofURLFileLoader *arg1 = (ofURLFileLoader *) 0 ; - std::string *arg2 = 0 ; std::string *arg3 = 0 ; std::string temp2 ; std::string temp3 ; int result; - SWIG_check_num_args("ofURLFileLoader::saveAsync",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofURLFileLoader::saveAsync",1,"ofURLFileLoader *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofURLFileLoader::saveAsync",2,"std::string const &"); - if(!lua_isstring(L,3)) SWIG_fail_arg("ofURLFileLoader::saveAsync",3,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofURLFileLoader,0))){ - SWIG_fail_ptr("URLFileLoader_saveAsync",1,SWIGTYPE_p_ofURLFileLoader); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3; - result = (int)(arg1)->saveAsync((std::string const &)*arg2,(std::string const &)*arg3); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_URLFileLoader_remove(lua_State* L) { int SWIG_arg = 0; ofURLFileLoader *arg1 = (ofURLFileLoader *) 0 ; - int arg2 ; SWIG_check_num_args("ofURLFileLoader::remove",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofURLFileLoader::remove",1,"ofURLFileLoader *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofURLFileLoader::remove",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofURLFileLoader,0))){ - SWIG_fail_ptr("URLFileLoader_remove",1,SWIGTYPE_p_ofURLFileLoader); } arg2 = (int)lua_tonumber(L, 2); (arg1)->remove(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_URLFileLoader_clear(lua_State* L) { int SWIG_arg = 0; ofURLFileLoader *arg1 = (ofURLFileLoader *) 0 ; - SWIG_check_num_args("ofURLFileLoader::clear",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofURLFileLoader::clear",1,"ofURLFileLoader *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofURLFileLoader,0))){ - SWIG_fail_ptr("URLFileLoader_clear",1,SWIGTYPE_p_ofURLFileLoader); } (arg1)->clear(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_URLFileLoader_stop(lua_State* L) { int SWIG_arg = 0; ofURLFileLoader *arg1 = (ofURLFileLoader *) 0 ; - SWIG_check_num_args("ofURLFileLoader::stop",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofURLFileLoader::stop",1,"ofURLFileLoader *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofURLFileLoader,0))){ - SWIG_fail_ptr("URLFileLoader_stop",1,SWIGTYPE_p_ofURLFileLoader); } (arg1)->stop(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_URLFileLoader_handleRequest(lua_State* L) { int SWIG_arg = 0; ofURLFileLoader *arg1 = (ofURLFileLoader *) 0 ; - ofHttpRequest *arg2 = 0 ; ofHttpResponse result; SWIG_check_num_args("ofURLFileLoader::handleRequest",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofURLFileLoader::handleRequest",1,"ofURLFileLoader *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofURLFileLoader::handleRequest",2,"ofHttpRequest &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofURLFileLoader,0))){ - SWIG_fail_ptr("URLFileLoader_handleRequest",1,SWIGTYPE_p_ofURLFileLoader); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofHttpRequest,0))){ - SWIG_fail_ptr("URLFileLoader_handleRequest",2,SWIGTYPE_p_ofHttpRequest); } result = (arg1)->handleRequest(*arg2); { - ofHttpResponse * resultptr = new ofHttpResponse((const ofHttpResponse &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_ofHttpResponse,1); SWIG_arg++; } return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static void swig_delete_URLFileLoader(void *obj) { -ofURLFileLoader *arg1 = (ofURLFileLoader *) obj; -delete arg1; -} -static int _proxy__wrap_new_URLFileLoader(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_URLFileLoader); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_URLFileLoader_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_URLFileLoader_methods[]= { - { "get", _wrap_URLFileLoader_get}, - { "getAsync", _wrap_URLFileLoader_getAsync}, - { "saveTo", _wrap_URLFileLoader_saveTo}, - { "saveAsync", _wrap_URLFileLoader_saveAsync}, - { "remove", _wrap_URLFileLoader_remove}, - { "clear", _wrap_URLFileLoader_clear}, - { "stop", _wrap_URLFileLoader_stop}, - { "handleRequest", _wrap_URLFileLoader_handleRequest}, - {0,0} -}; -static swig_lua_method swig_URLFileLoader_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_URLFileLoader_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_URLFileLoader_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_URLFileLoader_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_URLFileLoader_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_URLFileLoader_Sf_SwigStatic = { - "URLFileLoader", - swig_URLFileLoader_Sf_SwigStatic_methods, - swig_URLFileLoader_Sf_SwigStatic_attributes, - swig_URLFileLoader_Sf_SwigStatic_constants, - swig_URLFileLoader_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_URLFileLoader_bases[] = {0}; -static const char *swig_URLFileLoader_base_names[] = {0}; -static swig_lua_class _wrap_class_URLFileLoader = { "URLFileLoader", "URLFileLoader", &SWIGTYPE_p_ofURLFileLoader,_proxy__wrap_new_URLFileLoader, swig_delete_URLFileLoader, swig_URLFileLoader_methods, swig_URLFileLoader_attributes, &swig_URLFileLoader_Sf_SwigStatic, swig_URLFileLoader_meta, swig_URLFileLoader_bases, swig_URLFileLoader_base_names }; - -static int _wrap_resetElapsedTimeCounter(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofResetElapsedTimeCounter",0,0) - ofResetElapsedTimeCounter(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getElapsedTimef(lua_State* L) { int SWIG_arg = 0; float result; SWIG_check_num_args("ofGetElapsedTimef",0,0) - result = (float)ofGetElapsedTimef(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_getElapsedTimeMillis(lua_State* L) { int SWIG_arg = 0; uint64_t result; - SWIG_check_num_args("ofGetElapsedTimeMillis",0,0) result = (uint64_t)ofGetElapsedTimeMillis(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getElapsedTimeMicros(lua_State* L) { int SWIG_arg = 0; uint64_t result; - SWIG_check_num_args("ofGetElapsedTimeMicros",0,0) result = (uint64_t)ofGetElapsedTimeMicros(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getSeconds(lua_State* L) { int SWIG_arg = 0; int result; SWIG_check_num_args("ofGetSeconds",0,0) - result = (int)ofGetSeconds(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_getMinutes(lua_State* L) { int SWIG_arg = 0; int result; SWIG_check_num_args("ofGetMinutes",0,0) - result = (int)ofGetMinutes(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_getHours(lua_State* L) { int SWIG_arg = 0; int result; SWIG_check_num_args("ofGetHours",0,0) - result = (int)ofGetHours(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_getUnixTime(lua_State* L) { int SWIG_arg = 0; unsigned int result; SWIG_check_num_args("ofGetUnixTime",0,0) - result = (unsigned int)ofGetUnixTime(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_getSystemTime(lua_State* L) { int SWIG_arg = 0; uint64_t result; SWIG_check_num_args("ofGetSystemTime",0,0) - result = (uint64_t)ofGetSystemTime(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_getSystemTimeMicros(lua_State* L) { int SWIG_arg = 0; uint64_t result; - SWIG_check_num_args("ofGetSystemTimeMicros",0,0) result = (uint64_t)ofGetSystemTimeMicros(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_sleepMillis(lua_State* L) { int SWIG_arg = 0; int arg1 ; SWIG_check_num_args("ofSleepMillis",1,1) - if(!lua_isnumber(L,1)) SWIG_fail_arg("ofSleepMillis",1,"int"); arg1 = (int)lua_tonumber(L, 1); ofSleepMillis(arg1); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getTimestampString__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string result; - SWIG_check_num_args("ofGetTimestampString",0,0) result = ofGetTimestampString(); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_getTimestampString__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - std::string result; SWIG_check_num_args("ofGetTimestampString",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofGetTimestampString",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = ofGetTimestampString((std::string const &)*arg1); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_getTimestampString(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_getTimestampString__SWIG_0(L);} if (argc == 1) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { - return _wrap_getTimestampString__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'getTimestampString'\n" " Possible C/C++ prototypes are:\n" - " ofGetTimestampString()\n" " ofGetTimestampString(std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_getYear(lua_State* L) { int SWIG_arg = 0; int result; SWIG_check_num_args("ofGetYear",0,0) - result = (int)ofGetYear(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_getMonth(lua_State* L) { int SWIG_arg = 0; int result; SWIG_check_num_args("ofGetMonth",0,0) - result = (int)ofGetMonth(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_getDay(lua_State* L) { int SWIG_arg = 0; int result; SWIG_check_num_args("ofGetDay",0,0) - result = (int)ofGetDay(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_getWeekday(lua_State* L) { int SWIG_arg = 0; int result; SWIG_check_num_args("ofGetWeekday",0,0) - result = (int)ofGetWeekday(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_enableDataPath(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofEnableDataPath",0,0) - ofEnableDataPath(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_disableDataPath(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofDisableDataPath",0,0) - ofDisableDataPath(); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_toDataPath__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; bool arg2 ; std::string temp1 ; - std::string result; SWIG_check_num_args("ofToDataPath",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofToDataPath",1,"std::string const &"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofToDataPath",2,"bool"); temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; - arg2 = (lua_toboolean(L, 2)!=0); result = ofToDataPath((std::string const &)*arg1,arg2); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_toDataPath__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - std::string result; SWIG_check_num_args("ofToDataPath",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofToDataPath",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = ofToDataPath((std::string const &)*arg1); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_toDataPath(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { return _wrap_toDataPath__SWIG_1(L);} } if (argc == 2) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_toDataPath__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'toDataPath'\n" " Possible C/C++ prototypes are:\n" - " ofToDataPath(std::string const &,bool)\n" " ofToDataPath(std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_restoreWorkingDirectoryToDefault(lua_State* L) { int SWIG_arg = 0; bool result; - SWIG_check_num_args("ofRestoreWorkingDirectoryToDefault",0,0) result = (bool)ofRestoreWorkingDirectoryToDefault(); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_setDataPathRoot(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - SWIG_check_num_args("ofSetDataPathRoot",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofSetDataPathRoot",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; ofSetDataPathRoot((std::string const &)*arg1); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_splitString__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; - bool arg3 ; bool arg4 ; std::string temp1 ; std::string temp2 ; std::vector< std::string > result; - SWIG_check_num_args("ofSplitString",4,4) if(!lua_isstring(L,1)) SWIG_fail_arg("ofSplitString",1,"std::string const &"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofSplitString",2,"std::string const &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofSplitString",3,"bool"); - if(!lua_isboolean(L,4)) SWIG_fail_arg("ofSplitString",4,"bool"); temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; arg3 = (lua_toboolean(L, 3)!=0); - arg4 = (lua_toboolean(L, 4)!=0); result = ofSplitString((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4); { - std::vector< std::string > * resultptr = new std::vector< std::string >((const std::vector< std::string > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_std__string_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_splitString__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; - bool arg3 ; std::string temp1 ; std::string temp2 ; std::vector< std::string > result; - SWIG_check_num_args("ofSplitString",3,3) if(!lua_isstring(L,1)) SWIG_fail_arg("ofSplitString",1,"std::string const &"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofSplitString",2,"std::string const &"); - if(!lua_isboolean(L,3)) SWIG_fail_arg("ofSplitString",3,"bool"); temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; arg3 = (lua_toboolean(L, 3)!=0); - result = ofSplitString((std::string const &)*arg1,(std::string const &)*arg2,arg3); { - std::vector< std::string > * resultptr = new std::vector< std::string >((const std::vector< std::string > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_std__string_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_splitString__SWIG_2(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; - std::string temp1 ; std::string temp2 ; std::vector< std::string > result; SWIG_check_num_args("ofSplitString",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofSplitString",1,"std::string const &"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofSplitString",2,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = ofSplitString((std::string const &)*arg1,(std::string const &)*arg2); { - std::vector< std::string > * resultptr = new std::vector< std::string >((const std::vector< std::string > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_std__string_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_splitString(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 2) { int _v; - { _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { - return _wrap_splitString__SWIG_2(L);} } } if (argc == 3) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { { - _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { - return _wrap_splitString__SWIG_1(L);} } } } if (argc == 4) { int _v; { _v = lua_isstring(L,argv[0]); } if (_v) { - { _v = lua_isstring(L,argv[1]); } if (_v) { { _v = lua_isboolean(L,argv[2]); } if (_v) { { - _v = lua_isboolean(L,argv[3]); } if (_v) { return _wrap_splitString__SWIG_0(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'splitString'\n" " Possible C/C++ prototypes are:\n" - " ofSplitString(std::string const &,std::string const &,bool,bool)\n" - " ofSplitString(std::string const &,std::string const &,bool)\n" - " ofSplitString(std::string const &,std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_joinString(lua_State* L) { int SWIG_arg = 0; std::vector< std::string > *arg1 = 0 ; std::string *arg2 = 0 ; - std::string temp2 ; std::string result; SWIG_check_num_args("ofJoinString",2,2) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofJoinString",1,"std::vector< std::string > const &"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofJoinString",2,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__vectorT_std__string_t,0))){ - SWIG_fail_ptr("joinString",1,SWIGTYPE_p_std__vectorT_std__string_t); } - temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = ofJoinString((std::vector< std::string > const &)*arg1,(std::string const &)*arg2); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_stringReplace(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; - std::string *arg3 = 0 ; std::string temp2 ; std::string temp3 ; SWIG_check_num_args("ofStringReplace",3,3) - if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofStringReplace",1,"std::string &"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofStringReplace",2,"std::string const &"); - if(!lua_isstring(L,3)) SWIG_fail_arg("ofStringReplace",3,"std::string const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__string,0))){ - SWIG_fail_ptr("stringReplace",1,SWIGTYPE_p_std__string); } temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - temp3.assign(lua_tostring(L,3),lua_rawlen(L,3)); arg3=&temp3; - ofStringReplace(*arg1,(std::string const &)*arg2,(std::string const &)*arg3); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_isStringInString(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; - std::string temp1 ; std::string temp2 ; bool result; SWIG_check_num_args("ofIsStringInString",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofIsStringInString",1,"std::string const &"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofIsStringInString",2,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = (bool)ofIsStringInString((std::string const &)*arg1,(std::string const &)*arg2); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_stringTimesInString(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; - std::string temp1 ; std::string temp2 ; std::size_t result; SWIG_check_num_args("ofStringTimesInString",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofStringTimesInString",1,"std::string const &"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofStringTimesInString",2,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = (std::size_t)ofStringTimesInString((std::string const &)*arg1,(std::string const &)*arg2); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_toLower__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; - std::string temp1 ; std::string temp2 ; std::string result; SWIG_check_num_args("ofToLower",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofToLower",1,"std::string const &"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofToLower",2,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = ofToLower((std::string const &)*arg1,(std::string const &)*arg2); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_toLower__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - std::string result; SWIG_check_num_args("ofToLower",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofToLower",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = ofToLower((std::string const &)*arg1); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_toLower(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { return _wrap_toLower__SWIG_1(L);} } if (argc == 2) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { return _wrap_toLower__SWIG_0(L);} - } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'toLower'\n" " Possible C/C++ prototypes are:\n" - " ofToLower(std::string const &,std::string const &)\n" " ofToLower(std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_toUpper__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; - std::string temp1 ; std::string temp2 ; std::string result; SWIG_check_num_args("ofToUpper",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofToUpper",1,"std::string const &"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofToUpper",2,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = ofToUpper((std::string const &)*arg1,(std::string const &)*arg2); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_toUpper__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - std::string result; SWIG_check_num_args("ofToUpper",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofToUpper",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = ofToUpper((std::string const &)*arg1); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_toUpper(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { return _wrap_toUpper__SWIG_1(L);} } if (argc == 2) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { return _wrap_toUpper__SWIG_0(L);} - } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'toUpper'\n" " Possible C/C++ prototypes are:\n" - " ofToUpper(std::string const &,std::string const &)\n" " ofToUpper(std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_trimFront__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; - std::string temp1 ; std::string temp2 ; std::string result; SWIG_check_num_args("ofTrimFront",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofTrimFront",1,"std::string const &"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofTrimFront",2,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = ofTrimFront((std::string const &)*arg1,(std::string const &)*arg2); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_trimFront__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - std::string result; SWIG_check_num_args("ofTrimFront",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofTrimFront",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = ofTrimFront((std::string const &)*arg1); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_trimFront(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { return _wrap_trimFront__SWIG_1(L);} } if (argc == 2) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { return _wrap_trimFront__SWIG_0(L);} - } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'trimFront'\n" - " Possible C/C++ prototypes are:\n" " ofTrimFront(std::string const &,std::string const &)\n" - " ofTrimFront(std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_trimBack__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; - std::string temp1 ; std::string temp2 ; std::string result; SWIG_check_num_args("ofTrimBack",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofTrimBack",1,"std::string const &"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofTrimBack",2,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = ofTrimBack((std::string const &)*arg1,(std::string const &)*arg2); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_trimBack__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - std::string result; SWIG_check_num_args("ofTrimBack",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofTrimBack",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = ofTrimBack((std::string const &)*arg1); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_trimBack(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { return _wrap_trimBack__SWIG_1(L);} } if (argc == 2) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { return _wrap_trimBack__SWIG_0(L);} - } } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'trimBack'\n" - " Possible C/C++ prototypes are:\n" " ofTrimBack(std::string const &,std::string const &)\n" - " ofTrimBack(std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_trim__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string *arg2 = 0 ; - std::string temp1 ; std::string temp2 ; std::string result; SWIG_check_num_args("ofTrim",2,2) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofTrim",1,"std::string const &"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofTrim",2,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; temp2.assign(lua_tostring(L,2),lua_rawlen(L,2)); arg2=&temp2; - result = ofTrim((std::string const &)*arg1,(std::string const &)*arg2); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_trim__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; std::string result; - SWIG_check_num_args("ofTrim",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofTrim",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = ofTrim((std::string const &)*arg1); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_trim(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { return _wrap_trim__SWIG_1(L);} } if (argc == 2) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isstring(L,argv[1]); } if (_v) { return _wrap_trim__SWIG_0(L);} } - } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'trim'\n" " Possible C/C++ prototypes are:\n" - " ofTrim(std::string const &,std::string const &)\n" " ofTrim(std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_appendUTF8(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; int arg2 ; - SWIG_check_num_args("ofAppendUTF8",2,2) if(!lua_isuserdata(L,1)) SWIG_fail_arg("ofAppendUTF8",1,"std::string &"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofAppendUTF8",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_std__string,0))){ - SWIG_fail_ptr("appendUTF8",1,SWIGTYPE_p_std__string); } arg2 = (int)lua_tonumber(L, 2); ofAppendUTF8(*arg1,arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_toInt(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; int result; - SWIG_check_num_args("ofToInt",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofToInt",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = (int)ofToInt((std::string const &)*arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_toInt64(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; int64_t result; - SWIG_check_num_args("ofToInt64",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofToInt64",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = (int64_t)ofToInt64((std::string const &)*arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_toFloat(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; float result; - SWIG_check_num_args("ofToFloat",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofToFloat",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = (float)ofToFloat((std::string const &)*arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_toDouble(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; double result; - SWIG_check_num_args("ofToDouble",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofToDouble",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = (double)ofToDouble((std::string const &)*arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_toBool(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; bool result; - SWIG_check_num_args("ofToBool",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofToBool",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = (bool)ofToBool((std::string const &)*arg1); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_toHex(lua_State* L) { int SWIG_arg = 0; char *arg1 = (char *) 0 ; std::string result; - SWIG_check_num_args("ofToHex",1,1) if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("ofToHex",1,"char const *"); - arg1 = (char *)lua_tostring(L, 1); result = ofToHex((char const *)arg1); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_hexToInt(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; int result; - SWIG_check_num_args("ofHexToInt",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofHexToInt",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = (int)ofHexToInt((std::string const &)*arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_hexToChar(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; char result; - SWIG_check_num_args("ofHexToChar",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofHexToChar",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = (char)ofHexToChar((std::string const &)*arg1); - lua_pushlstring(L, &result, 1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_hexToFloat(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; float result; - SWIG_check_num_args("ofHexToFloat",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofHexToFloat",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = (float)ofHexToFloat((std::string const &)*arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_hexToString(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; std::string result; - SWIG_check_num_args("ofHexToString",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofHexToString",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = ofHexToString((std::string const &)*arg1); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_toChar(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; char result; - SWIG_check_num_args("ofToChar",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofToChar",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = (char)ofToChar((std::string const &)*arg1); - lua_pushlstring(L, &result, 1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_toBinary(lua_State* L) { int SWIG_arg = 0; char *arg1 = (char *) 0 ; std::string result; - SWIG_check_num_args("ofToBinary",1,1) if(!SWIG_lua_isnilstring(L,1)) SWIG_fail_arg("ofToBinary",1,"char const *"); - arg1 = (char *)lua_tostring(L, 1); result = ofToBinary((char const *)arg1); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_binaryToInt(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; int result; - SWIG_check_num_args("ofBinaryToInt",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofBinaryToInt",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = (int)ofBinaryToInt((std::string const &)*arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_binaryToChar(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; char result; - SWIG_check_num_args("ofBinaryToChar",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofBinaryToChar",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = (char)ofBinaryToChar((std::string const &)*arg1); - lua_pushlstring(L, &result, 1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_binaryToFloat(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; float result; - SWIG_check_num_args("ofBinaryToFloat",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofBinaryToFloat",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = (float)ofBinaryToFloat((std::string const &)*arg1); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_binaryToString(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - std::string result; SWIG_check_num_args("ofBinaryToString",1,1) - if(!lua_isstring(L,1)) SWIG_fail_arg("ofBinaryToString",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = ofBinaryToString((std::string const &)*arg1); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_getVersionInfo(lua_State* L) { int SWIG_arg = 0; std::string result; - SWIG_check_num_args("ofGetVersionInfo",0,0) result = ofGetVersionInfo(); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_getVersionMajor(lua_State* L) { int SWIG_arg = 0; unsigned int result; - SWIG_check_num_args("ofGetVersionMajor",0,0) result = (unsigned int)ofGetVersionMajor(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getVersionMinor(lua_State* L) { int SWIG_arg = 0; unsigned int result; - SWIG_check_num_args("ofGetVersionMinor",0,0) result = (unsigned int)ofGetVersionMinor(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getVersionPatch(lua_State* L) { int SWIG_arg = 0; unsigned int result; - SWIG_check_num_args("ofGetVersionPatch",0,0) result = (unsigned int)ofGetVersionPatch(); - lua_pushnumber(L, (lua_Number) result); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_getVersionPreRelease(lua_State* L) { int SWIG_arg = 0; std::string result; - SWIG_check_num_args("ofGetVersionPreRelease",0,0) result = ofGetVersionPreRelease(); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_saveScreen(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - SWIG_check_num_args("ofSaveScreen",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofSaveScreen",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; ofSaveScreen((std::string const &)*arg1); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_saveFrame__SWIG_0(lua_State* L) { int SWIG_arg = 0; bool arg1 ; SWIG_check_num_args("ofSaveFrame",1,1) - if(!lua_isboolean(L,1)) SWIG_fail_arg("ofSaveFrame",1,"bool"); arg1 = (lua_toboolean(L, 1)!=0); ofSaveFrame(arg1); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_saveFrame__SWIG_1(lua_State* L) { int SWIG_arg = 0; SWIG_check_num_args("ofSaveFrame",0,0) ofSaveFrame(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_saveFrame(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 0) { - return _wrap_saveFrame__SWIG_1(L);} if (argc == 1) { int _v; { _v = lua_isboolean(L,argv[0]); } if (_v) { - return _wrap_saveFrame__SWIG_0(L);} } SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'saveFrame'\n" - " Possible C/C++ prototypes are:\n" " ofSaveFrame(bool)\n" " ofSaveFrame()\n"); lua_error(L);return 0; } -static int _wrap_saveViewport(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - SWIG_check_num_args("ofSaveViewport",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofSaveViewport",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; ofSaveViewport((std::string const &)*arg1); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_launchBrowser__SWIG_0(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; bool arg2 ; std::string temp1 ; - SWIG_check_num_args("ofLaunchBrowser",2,2) if(!lua_isstring(L,1)) SWIG_fail_arg("ofLaunchBrowser",1,"std::string const &"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofLaunchBrowser",2,"bool"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; arg2 = (lua_toboolean(L, 2)!=0); - ofLaunchBrowser((std::string const &)*arg1,arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_launchBrowser__SWIG_1(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; - SWIG_check_num_args("ofLaunchBrowser",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofLaunchBrowser",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; ofLaunchBrowser((std::string const &)*arg1); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_launchBrowser(lua_State* L) { int argc; int argv[3]={ 1,2,3} ; argc = lua_gettop(L); if (argc == 1) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { return _wrap_launchBrowser__SWIG_1(L);} } if (argc == 2) { int _v; { - _v = lua_isstring(L,argv[0]); } if (_v) { { _v = lua_isboolean(L,argv[1]); } if (_v) { - return _wrap_launchBrowser__SWIG_0(L);} } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'launchBrowser'\n" " Possible C/C++ prototypes are:\n" - " ofLaunchBrowser(std::string const &,bool)\n" " ofLaunchBrowser(std::string const &)\n"); lua_error(L);return 0; } -static int _wrap_system(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; std::string result; - SWIG_check_num_args("ofSystem",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofSystem",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = ofSystem((std::string const &)*arg1); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_getTargetPlatform(lua_State* L) { int SWIG_arg = 0; ofTargetPlatform result; - SWIG_check_num_args("ofGetTargetPlatform",0,0) result = (ofTargetPlatform)ofGetTargetPlatform(); - lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_getEnv(lua_State* L) { int SWIG_arg = 0; std::string *arg1 = 0 ; std::string temp1 ; std::string result; - SWIG_check_num_args("ofGetEnv",1,1) if(!lua_isstring(L,1)) SWIG_fail_arg("ofGetEnv",1,"std::string const &"); - temp1.assign(lua_tostring(L,1),lua_rawlen(L,1)); arg1=&temp1; result = ofGetEnv((std::string const &)*arg1); - lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_new_VideoGrabber(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *result = 0 ; - SWIG_check_num_args("ofVideoGrabber::ofVideoGrabber",0,0) result = (ofVideoGrabber *)new ofVideoGrabber(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVideoGrabber,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_VideoGrabber_listDevices(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - std::vector< ofVideoDevice > result; SWIG_check_num_args("ofVideoGrabber::listDevices",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::listDevices",1,"ofVideoGrabber const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_listDevices",1,SWIGTYPE_p_ofVideoGrabber); } - result = ((ofVideoGrabber const *)arg1)->listDevices(); { - std::vector< ofVideoDevice > * resultptr = new std::vector< ofVideoDevice >((const std::vector< ofVideoDevice > &) result); - SWIG_NewPointerObj(L,(void *) resultptr,SWIGTYPE_p_std__vectorT_ofVideoDevice_t,1); SWIG_arg++; } return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoGrabber_isFrameNew(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - bool result; SWIG_check_num_args("ofVideoGrabber::isFrameNew",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::isFrameNew",1,"ofVideoGrabber const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_isFrameNew",1,SWIGTYPE_p_ofVideoGrabber); } - result = (bool)((ofVideoGrabber const *)arg1)->isFrameNew(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoGrabber_update(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - SWIG_check_num_args("ofVideoGrabber::update",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::update",1,"ofVideoGrabber *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_update",1,SWIGTYPE_p_ofVideoGrabber); } (arg1)->update(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoGrabber_close(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - SWIG_check_num_args("ofVideoGrabber::close",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::close",1,"ofVideoGrabber *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_close",1,SWIGTYPE_p_ofVideoGrabber); } (arg1)->close(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_VideoGrabber_setup__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - int arg2 ; int arg3 ; bool result; SWIG_check_num_args("ofVideoGrabber::setup",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::setup",1,"ofVideoGrabber *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVideoGrabber::setup",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVideoGrabber::setup",3,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_setup",1,SWIGTYPE_p_ofVideoGrabber); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); result = (bool)(arg1)->setup(arg2,arg3); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoGrabber_setup__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - int arg2 ; int arg3 ; bool arg4 ; bool result; SWIG_check_num_args("ofVideoGrabber::setup",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::setup",1,"ofVideoGrabber *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVideoGrabber::setup",2,"int"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVideoGrabber::setup",3,"int"); - if(!lua_isboolean(L,4)) SWIG_fail_arg("ofVideoGrabber::setup",4,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_setup",1,SWIGTYPE_p_ofVideoGrabber); } arg2 = (int)lua_tonumber(L, 2); - arg3 = (int)lua_tonumber(L, 3); arg4 = (lua_toboolean(L, 4)!=0); result = (bool)(arg1)->setup(arg2,arg3,arg4); - lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoGrabber_setup(lua_State* L) { int argc; int argv[5]={ 1,2,3,4,5} ; argc = lua_gettop(L); if (argc == 3) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVideoGrabber, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - return _wrap_VideoGrabber_setup__SWIG_0(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVideoGrabber, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isboolean(L,argv[3]); } if (_v) { return _wrap_VideoGrabber_setup__SWIG_1(L);} } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'VideoGrabber_setup'\n" " Possible C/C++ prototypes are:\n" - " ofVideoGrabber::setup(int,int)\n" " ofVideoGrabber::setup(int,int,bool)\n"); lua_error(L);return 0; } -static int _wrap_VideoGrabber_setPixelFormat(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - ofPixelFormat arg2 ; bool result; SWIG_check_num_args("ofVideoGrabber::setPixelFormat",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::setPixelFormat",1,"ofVideoGrabber *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVideoGrabber::setPixelFormat",2,"ofPixelFormat"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_setPixelFormat",1,SWIGTYPE_p_ofVideoGrabber); } arg2 = (ofPixelFormat)(int)lua_tonumber(L, 2); - result = (bool)(arg1)->setPixelFormat(arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoGrabber_getPixelFormat(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - ofPixelFormat result; SWIG_check_num_args("ofVideoGrabber::getPixelFormat",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::getPixelFormat",1,"ofVideoGrabber const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_getPixelFormat",1,SWIGTYPE_p_ofVideoGrabber); } - result = (ofPixelFormat)((ofVideoGrabber const *)arg1)->getPixelFormat(); - lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_VideoGrabber_videoSettings(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - SWIG_check_num_args("ofVideoGrabber::videoSettings",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::videoSettings",1,"ofVideoGrabber *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_videoSettings",1,SWIGTYPE_p_ofVideoGrabber); } (arg1)->videoSettings(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoGrabber_getPixels__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - ofPixels *result = 0 ; SWIG_check_num_args("ofVideoGrabber::getPixels",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::getPixels",1,"ofVideoGrabber *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_getPixels",1,SWIGTYPE_p_ofVideoGrabber); } result = (ofPixels *) &(arg1)->getPixels(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_VideoGrabber_getPixels__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - ofPixels *result = 0 ; SWIG_check_num_args("ofVideoGrabber::getPixels",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::getPixels",1,"ofVideoGrabber const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_getPixels",1,SWIGTYPE_p_ofVideoGrabber); } - result = (ofPixels *) &((ofVideoGrabber const *)arg1)->getPixels(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_VideoGrabber_getPixels(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVideoGrabber, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_VideoGrabber_getPixels__SWIG_0(L);} } if (argc == 1) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVideoGrabber, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_VideoGrabber_getPixels__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'VideoGrabber_getPixels'\n" - " Possible C/C++ prototypes are:\n" " ofVideoGrabber::getPixels()\n" " ofVideoGrabber::getPixels() const\n"); - lua_error(L);return 0; } -static int _wrap_VideoGrabber_getTexture__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - ofTexture *result = 0 ; SWIG_check_num_args("ofVideoGrabber::getTexture",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::getTexture",1,"ofVideoGrabber *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_getTexture",1,SWIGTYPE_p_ofVideoGrabber); } result = (ofTexture *) &(arg1)->getTexture(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTexture,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_VideoGrabber_getTexture__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - ofTexture *result = 0 ; SWIG_check_num_args("ofVideoGrabber::getTexture",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::getTexture",1,"ofVideoGrabber const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_getTexture",1,SWIGTYPE_p_ofVideoGrabber); } - result = (ofTexture *) &((ofVideoGrabber const *)arg1)->getTexture(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTexture,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_VideoGrabber_getTexture(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVideoGrabber, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_VideoGrabber_getTexture__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVideoGrabber, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_VideoGrabber_getTexture__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'VideoGrabber_getTexture'\n" - " Possible C/C++ prototypes are:\n" " ofVideoGrabber::getTexture()\n" " ofVideoGrabber::getTexture() const\n"); - lua_error(L);return 0; } -static int _wrap_VideoGrabber_getTexturePlanes__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; std::vector< ofTexture > *result = 0 ; - SWIG_check_num_args("ofVideoGrabber::getTexturePlanes",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::getTexturePlanes",1,"ofVideoGrabber *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_getTexturePlanes",1,SWIGTYPE_p_ofVideoGrabber); } - result = (std::vector< ofTexture > *) &(arg1)->getTexturePlanes(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofTexture_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_VideoGrabber_getTexturePlanes__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; std::vector< ofTexture > *result = 0 ; - SWIG_check_num_args("ofVideoGrabber::getTexturePlanes",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::getTexturePlanes",1,"ofVideoGrabber const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_getTexturePlanes",1,SWIGTYPE_p_ofVideoGrabber); } - result = (std::vector< ofTexture > *) &((ofVideoGrabber const *)arg1)->getTexturePlanes(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofTexture_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_VideoGrabber_getTexturePlanes(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); - if (argc == 1) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVideoGrabber, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_VideoGrabber_getTexturePlanes__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVideoGrabber, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_VideoGrabber_getTexturePlanes__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'VideoGrabber_getTexturePlanes'\n" - " Possible C/C++ prototypes are:\n" " ofVideoGrabber::getTexturePlanes()\n" - " ofVideoGrabber::getTexturePlanes() const\n"); lua_error(L);return 0; } -static int _wrap_VideoGrabber_setVerbose(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - bool arg2 ; SWIG_check_num_args("ofVideoGrabber::setVerbose",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::setVerbose",1,"ofVideoGrabber *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofVideoGrabber::setVerbose",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_setVerbose",1,SWIGTYPE_p_ofVideoGrabber); } arg2 = (lua_toboolean(L, 2)!=0); - (arg1)->setVerbose(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoGrabber_setDeviceID(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - int arg2 ; SWIG_check_num_args("ofVideoGrabber::setDeviceID",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::setDeviceID",1,"ofVideoGrabber *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVideoGrabber::setDeviceID",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_setDeviceID",1,SWIGTYPE_p_ofVideoGrabber); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->setDeviceID(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoGrabber_setDesiredFrameRate(lua_State* L) { int SWIG_arg = 0; - ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; int arg2 ; SWIG_check_num_args("ofVideoGrabber::setDesiredFrameRate",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::setDesiredFrameRate",1,"ofVideoGrabber *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVideoGrabber::setDesiredFrameRate",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_setDesiredFrameRate",1,SWIGTYPE_p_ofVideoGrabber); } arg2 = (int)lua_tonumber(L, 2); - (arg1)->setDesiredFrameRate(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoGrabber_setUseTexture(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - bool arg2 ; SWIG_check_num_args("ofVideoGrabber::setUseTexture",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::setUseTexture",1,"ofVideoGrabber *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofVideoGrabber::setUseTexture",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_setUseTexture",1,SWIGTYPE_p_ofVideoGrabber); } arg2 = (lua_toboolean(L, 2)!=0); - (arg1)->setUseTexture(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoGrabber_isUsingTexture(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - bool result; SWIG_check_num_args("ofVideoGrabber::isUsingTexture",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::isUsingTexture",1,"ofVideoGrabber const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_isUsingTexture",1,SWIGTYPE_p_ofVideoGrabber); } - result = (bool)((ofVideoGrabber const *)arg1)->isUsingTexture(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoGrabber_draw__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - float arg2 ; float arg3 ; float arg4 ; float arg5 ; SWIG_check_num_args("ofVideoGrabber::draw",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::draw",1,"ofVideoGrabber const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVideoGrabber::draw",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVideoGrabber::draw",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVideoGrabber::draw",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofVideoGrabber::draw",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_draw",1,SWIGTYPE_p_ofVideoGrabber); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - ((ofVideoGrabber const *)arg1)->draw(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_VideoGrabber_draw__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - float arg2 ; float arg3 ; SWIG_check_num_args("ofVideoGrabber::draw",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::draw",1,"ofVideoGrabber const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVideoGrabber::draw",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVideoGrabber::draw",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_draw",1,SWIGTYPE_p_ofVideoGrabber); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); ((ofVideoGrabber const *)arg1)->draw(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_VideoGrabber_draw__SWIG_2_0(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - ofPoint *arg2 = 0 ; SWIG_check_num_args("draw",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("draw",1,"ofVideoGrabber const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("draw",2,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_draw",1,SWIGTYPE_p_ofVideoGrabber); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("VideoGrabber_draw",2,SWIGTYPE_p_ofVec3f); } ((ofVideoGrabber const *)arg1)->draw((ofPoint const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoGrabber_draw__SWIG_2_1(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - ofRectangle *arg2 = 0 ; SWIG_check_num_args("draw",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("draw",1,"ofVideoGrabber const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("draw",2,"ofRectangle const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_draw",1,SWIGTYPE_p_ofVideoGrabber); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("VideoGrabber_draw",2,SWIGTYPE_p_ofRectangle); } - ((ofVideoGrabber const *)arg1)->draw((ofRectangle const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_VideoGrabber_draw__SWIG_2_2(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - ofPoint *arg2 = 0 ; float arg3 ; float arg4 ; SWIG_check_num_args("draw",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("draw",1,"ofVideoGrabber const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("draw",2,"ofPoint const &"); if(!lua_isnumber(L,3)) SWIG_fail_arg("draw",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("draw",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_draw",1,SWIGTYPE_p_ofVideoGrabber); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("VideoGrabber_draw",2,SWIGTYPE_p_ofVec3f); } arg3 = (float)lua_tonumber(L, 3); - arg4 = (float)lua_tonumber(L, 4); ((ofVideoGrabber const *)arg1)->draw((ofPoint const &)*arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoGrabber_draw(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVideoGrabber, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_VideoGrabber_draw__SWIG_2_0(L);} } } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVideoGrabber, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_VideoGrabber_draw__SWIG_2_1(L);} } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVideoGrabber, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_VideoGrabber_draw__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVideoGrabber, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_VideoGrabber_draw__SWIG_2_2(L);} } } } } if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVideoGrabber, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_VideoGrabber_draw__SWIG_0(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'VideoGrabber_draw'\n" " Possible C/C++ prototypes are:\n" - " ofVideoGrabber::draw(float,float,float,float) const\n" " ofVideoGrabber::draw(float,float) const\n" - " draw(ofPoint const &) const\n" " draw(ofRectangle const &) const\n" " draw(ofPoint const &,float,float) const\n"); - lua_error(L);return 0; } -static int _wrap_VideoGrabber_bind(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - SWIG_check_num_args("ofVideoGrabber::bind",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::bind",1,"ofVideoGrabber const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_bind",1,SWIGTYPE_p_ofVideoGrabber); } ((ofVideoGrabber const *)arg1)->bind(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoGrabber_unbind(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - SWIG_check_num_args("ofVideoGrabber::unbind",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::unbind",1,"ofVideoGrabber const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_unbind",1,SWIGTYPE_p_ofVideoGrabber); } ((ofVideoGrabber const *)arg1)->unbind(); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoGrabber_setAnchorPercent(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - float arg2 ; float arg3 ; SWIG_check_num_args("ofVideoGrabber::setAnchorPercent",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::setAnchorPercent",1,"ofVideoGrabber *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVideoGrabber::setAnchorPercent",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVideoGrabber::setAnchorPercent",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_setAnchorPercent",1,SWIGTYPE_p_ofVideoGrabber); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->setAnchorPercent(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_VideoGrabber_setAnchorPoint(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - float arg2 ; float arg3 ; SWIG_check_num_args("ofVideoGrabber::setAnchorPoint",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::setAnchorPoint",1,"ofVideoGrabber *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVideoGrabber::setAnchorPoint",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVideoGrabber::setAnchorPoint",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_setAnchorPoint",1,SWIGTYPE_p_ofVideoGrabber); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->setAnchorPoint(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_VideoGrabber_resetAnchor(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - SWIG_check_num_args("ofVideoGrabber::resetAnchor",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::resetAnchor",1,"ofVideoGrabber *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_resetAnchor",1,SWIGTYPE_p_ofVideoGrabber); } (arg1)->resetAnchor(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoGrabber_getHeight(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - float result; SWIG_check_num_args("ofVideoGrabber::getHeight",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::getHeight",1,"ofVideoGrabber const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_getHeight",1,SWIGTYPE_p_ofVideoGrabber); } - result = (float)((ofVideoGrabber const *)arg1)->getHeight(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoGrabber_getWidth(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - float result; SWIG_check_num_args("ofVideoGrabber::getWidth",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::getWidth",1,"ofVideoGrabber const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_getWidth",1,SWIGTYPE_p_ofVideoGrabber); } - result = (float)((ofVideoGrabber const *)arg1)->getWidth(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoGrabber_isInitialized(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - bool result; SWIG_check_num_args("ofVideoGrabber::isInitialized",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::isInitialized",1,"ofVideoGrabber const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_isInitialized",1,SWIGTYPE_p_ofVideoGrabber); } - result = (bool)((ofVideoGrabber const *)arg1)->isInitialized(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoGrabber_setGrabber(lua_State* L) { int SWIG_arg = 0; ofVideoGrabber *arg1 = (ofVideoGrabber *) 0 ; - SwigValueWrapper< shared_ptr< ofBaseVideoGrabber > > arg2 ; shared_ptr< ofBaseVideoGrabber > *argp2 ; - SWIG_check_num_args("ofVideoGrabber::setGrabber",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoGrabber::setGrabber",1,"ofVideoGrabber *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("ofVideoGrabber::setGrabber",2,"shared_ptr< ofBaseVideoGrabber >"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoGrabber,0))){ - SWIG_fail_ptr("VideoGrabber_setGrabber",1,SWIGTYPE_p_ofVideoGrabber); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&argp2,SWIGTYPE_p_shared_ptrT_ofBaseVideoGrabber_t,0))){ - SWIG_fail_ptr("VideoGrabber_setGrabber",2,SWIGTYPE_p_shared_ptrT_ofBaseVideoGrabber_t); } arg2 = *argp2; - (arg1)->setGrabber(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_VideoGrabber(void *obj) { -ofVideoGrabber *arg1 = (ofVideoGrabber *) obj; -delete arg1; -} -static int _proxy__wrap_new_VideoGrabber(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_VideoGrabber); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_VideoGrabber_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_VideoGrabber_methods[]= { - { "listDevices", _wrap_VideoGrabber_listDevices}, - { "isFrameNew", _wrap_VideoGrabber_isFrameNew}, - { "update", _wrap_VideoGrabber_update}, - { "close", _wrap_VideoGrabber_close}, - { "setup", _wrap_VideoGrabber_setup}, - { "setPixelFormat", _wrap_VideoGrabber_setPixelFormat}, - { "getPixelFormat", _wrap_VideoGrabber_getPixelFormat}, - { "videoSettings", _wrap_VideoGrabber_videoSettings}, - { "getPixels", _wrap_VideoGrabber_getPixels}, - { "getTexture", _wrap_VideoGrabber_getTexture}, - { "getTexturePlanes", _wrap_VideoGrabber_getTexturePlanes}, - { "setVerbose", _wrap_VideoGrabber_setVerbose}, - { "setDeviceID", _wrap_VideoGrabber_setDeviceID}, - { "setDesiredFrameRate", _wrap_VideoGrabber_setDesiredFrameRate}, - { "setUseTexture", _wrap_VideoGrabber_setUseTexture}, - { "isUsingTexture", _wrap_VideoGrabber_isUsingTexture}, - { "draw", _wrap_VideoGrabber_draw}, - { "bind", _wrap_VideoGrabber_bind}, - { "unbind", _wrap_VideoGrabber_unbind}, - { "setAnchorPercent", _wrap_VideoGrabber_setAnchorPercent}, - { "setAnchorPoint", _wrap_VideoGrabber_setAnchorPoint}, - { "resetAnchor", _wrap_VideoGrabber_resetAnchor}, - { "getHeight", _wrap_VideoGrabber_getHeight}, - { "getWidth", _wrap_VideoGrabber_getWidth}, - { "isInitialized", _wrap_VideoGrabber_isInitialized}, - { "setGrabber", _wrap_VideoGrabber_setGrabber}, - {0,0} -}; -static swig_lua_method swig_VideoGrabber_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_VideoGrabber_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_VideoGrabber_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_VideoGrabber_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_VideoGrabber_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_VideoGrabber_Sf_SwigStatic = { - "VideoGrabber", - swig_VideoGrabber_Sf_SwigStatic_methods, - swig_VideoGrabber_Sf_SwigStatic_attributes, - swig_VideoGrabber_Sf_SwigStatic_constants, - swig_VideoGrabber_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_VideoGrabber_bases[] = {0}; -static const char *swig_VideoGrabber_base_names[] = {0}; -static swig_lua_class _wrap_class_VideoGrabber = { "VideoGrabber", "VideoGrabber", &SWIGTYPE_p_ofVideoGrabber,_proxy__wrap_new_VideoGrabber, swig_delete_VideoGrabber, swig_VideoGrabber_methods, swig_VideoGrabber_attributes, &swig_VideoGrabber_Sf_SwigStatic, swig_VideoGrabber_meta, swig_VideoGrabber_bases, swig_VideoGrabber_base_names }; - -static int _wrap_new_VideoPlayer(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *result = 0 ; - SWIG_check_num_args("ofVideoPlayer::ofVideoPlayer",0,0) result = (ofVideoPlayer *)new ofVideoPlayer(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofVideoPlayer,1); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_VideoPlayer_load(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - std::string arg2 ; bool result; SWIG_check_num_args("ofVideoPlayer::load",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::load",1,"ofVideoPlayer *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofVideoPlayer::load",2,"std::string"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_load",1,SWIGTYPE_p_ofVideoPlayer); } (&arg2)->assign(lua_tostring(L,2),lua_rawlen(L,2)); - result = (bool)(arg1)->load(arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_loadAsync(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - std::string arg2 ; SWIG_check_num_args("ofVideoPlayer::loadAsync",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::loadAsync",1,"ofVideoPlayer *"); - if(!lua_isstring(L,2)) SWIG_fail_arg("ofVideoPlayer::loadAsync",2,"std::string"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_loadAsync",1,SWIGTYPE_p_ofVideoPlayer); } (&arg2)->assign(lua_tostring(L,2),lua_rawlen(L,2)); - (arg1)->loadAsync(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_getMoviePath(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - std::string result; SWIG_check_num_args("ofVideoPlayer::getMoviePath",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::getMoviePath",1,"ofVideoPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_getMoviePath",1,SWIGTYPE_p_ofVideoPlayer); } - result = ((ofVideoPlayer const *)arg1)->getMoviePath(); lua_pushlstring(L,(&result)->data(),(&result)->size()); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_setPixelFormat(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - ofPixelFormat arg2 ; bool result; SWIG_check_num_args("ofVideoPlayer::setPixelFormat",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::setPixelFormat",1,"ofVideoPlayer *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVideoPlayer::setPixelFormat",2,"ofPixelFormat"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_setPixelFormat",1,SWIGTYPE_p_ofVideoPlayer); } arg2 = (ofPixelFormat)(int)lua_tonumber(L, 2); - result = (bool)(arg1)->setPixelFormat(arg2); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_getPixelFormat(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - ofPixelFormat result; SWIG_check_num_args("ofVideoPlayer::getPixelFormat",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::getPixelFormat",1,"ofVideoPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_getPixelFormat",1,SWIGTYPE_p_ofVideoPlayer); } - result = (ofPixelFormat)((ofVideoPlayer const *)arg1)->getPixelFormat(); - lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_VideoPlayer_closeMovie(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - SWIG_check_num_args("ofVideoPlayer::closeMovie",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::closeMovie",1,"ofVideoPlayer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_closeMovie",1,SWIGTYPE_p_ofVideoPlayer); } (arg1)->closeMovie(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_close(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - SWIG_check_num_args("ofVideoPlayer::close",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::close",1,"ofVideoPlayer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_close",1,SWIGTYPE_p_ofVideoPlayer); } (arg1)->close(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_update(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - SWIG_check_num_args("ofVideoPlayer::update",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::update",1,"ofVideoPlayer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_update",1,SWIGTYPE_p_ofVideoPlayer); } (arg1)->update(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_play(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - SWIG_check_num_args("ofVideoPlayer::play",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::play",1,"ofVideoPlayer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_play",1,SWIGTYPE_p_ofVideoPlayer); } (arg1)->play(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_stop(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - SWIG_check_num_args("ofVideoPlayer::stop",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::stop",1,"ofVideoPlayer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_stop",1,SWIGTYPE_p_ofVideoPlayer); } (arg1)->stop(); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_isFrameNew(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - bool result; SWIG_check_num_args("ofVideoPlayer::isFrameNew",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::isFrameNew",1,"ofVideoPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_isFrameNew",1,SWIGTYPE_p_ofVideoPlayer); } - result = (bool)((ofVideoPlayer const *)arg1)->isFrameNew(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_getPixels__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - ofPixels *result = 0 ; SWIG_check_num_args("ofVideoPlayer::getPixels",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::getPixels",1,"ofVideoPlayer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_getPixels",1,SWIGTYPE_p_ofVideoPlayer); } result = (ofPixels *) &(arg1)->getPixels(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_getPixels__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - ofPixels *result = 0 ; SWIG_check_num_args("ofVideoPlayer::getPixels",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::getPixels",1,"ofVideoPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_getPixels",1,SWIGTYPE_p_ofVideoPlayer); } - result = (ofPixels *) &((ofVideoPlayer const *)arg1)->getPixels(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofPixels_T_unsigned_char_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_getPixels(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVideoPlayer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_VideoPlayer_getPixels__SWIG_0(L);} } if (argc == 1) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVideoPlayer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_VideoPlayer_getPixels__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'VideoPlayer_getPixels'\n" - " Possible C/C++ prototypes are:\n" " ofVideoPlayer::getPixels()\n" " ofVideoPlayer::getPixels() const\n"); - lua_error(L);return 0; } -static int _wrap_VideoPlayer_getPosition(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - float result; SWIG_check_num_args("ofVideoPlayer::getPosition",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::getPosition",1,"ofVideoPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_getPosition",1,SWIGTYPE_p_ofVideoPlayer); } - result = (float)((ofVideoPlayer const *)arg1)->getPosition(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_getSpeed(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - float result; SWIG_check_num_args("ofVideoPlayer::getSpeed",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::getSpeed",1,"ofVideoPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_getSpeed",1,SWIGTYPE_p_ofVideoPlayer); } - result = (float)((ofVideoPlayer const *)arg1)->getSpeed(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_getDuration(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - float result; SWIG_check_num_args("ofVideoPlayer::getDuration",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::getDuration",1,"ofVideoPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_getDuration",1,SWIGTYPE_p_ofVideoPlayer); } - result = (float)((ofVideoPlayer const *)arg1)->getDuration(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_getIsMovieDone(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - bool result; SWIG_check_num_args("ofVideoPlayer::getIsMovieDone",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::getIsMovieDone",1,"ofVideoPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_getIsMovieDone",1,SWIGTYPE_p_ofVideoPlayer); } - result = (bool)((ofVideoPlayer const *)arg1)->getIsMovieDone(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_setPosition(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - float arg2 ; SWIG_check_num_args("ofVideoPlayer::setPosition",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::setPosition",1,"ofVideoPlayer *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVideoPlayer::setPosition",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_setPosition",1,SWIGTYPE_p_ofVideoPlayer); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setPosition(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_setVolume(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - float arg2 ; SWIG_check_num_args("ofVideoPlayer::setVolume",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::setVolume",1,"ofVideoPlayer *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVideoPlayer::setVolume",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_setVolume",1,SWIGTYPE_p_ofVideoPlayer); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setVolume(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_setLoopState(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - ofLoopType arg2 ; SWIG_check_num_args("ofVideoPlayer::setLoopState",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::setLoopState",1,"ofVideoPlayer *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVideoPlayer::setLoopState",2,"ofLoopType"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_setLoopState",1,SWIGTYPE_p_ofVideoPlayer); } arg2 = (ofLoopType)(int)lua_tonumber(L, 2); - (arg1)->setLoopState(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_getLoopState(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - ofLoopType result; SWIG_check_num_args("ofVideoPlayer::getLoopState",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::getLoopState",1,"ofVideoPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_getLoopState",1,SWIGTYPE_p_ofVideoPlayer); } - result = (ofLoopType)((ofVideoPlayer const *)arg1)->getLoopState(); lua_pushnumber(L, (lua_Number)(int)(result)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_setSpeed(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; float arg2 ; - SWIG_check_num_args("ofVideoPlayer::setSpeed",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::setSpeed",1,"ofVideoPlayer *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVideoPlayer::setSpeed",2,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_setSpeed",1,SWIGTYPE_p_ofVideoPlayer); } arg2 = (float)lua_tonumber(L, 2); - (arg1)->setSpeed(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_setFrame(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; int arg2 ; - SWIG_check_num_args("ofVideoPlayer::setFrame",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::setFrame",1,"ofVideoPlayer *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVideoPlayer::setFrame",2,"int"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_setFrame",1,SWIGTYPE_p_ofVideoPlayer); } arg2 = (int)lua_tonumber(L, 2); (arg1)->setFrame(arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_setUseTexture(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - bool arg2 ; SWIG_check_num_args("ofVideoPlayer::setUseTexture",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::setUseTexture",1,"ofVideoPlayer *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofVideoPlayer::setUseTexture",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_setUseTexture",1,SWIGTYPE_p_ofVideoPlayer); } arg2 = (lua_toboolean(L, 2)!=0); - (arg1)->setUseTexture(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_isUsingTexture(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - bool result; SWIG_check_num_args("ofVideoPlayer::isUsingTexture",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::isUsingTexture",1,"ofVideoPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_isUsingTexture",1,SWIGTYPE_p_ofVideoPlayer); } - result = (bool)((ofVideoPlayer const *)arg1)->isUsingTexture(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_getTexture__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - ofTexture *result = 0 ; SWIG_check_num_args("ofVideoPlayer::getTexture",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::getTexture",1,"ofVideoPlayer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_getTexture",1,SWIGTYPE_p_ofVideoPlayer); } result = (ofTexture *) &(arg1)->getTexture(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTexture,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_VideoPlayer_getTexture__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - ofTexture *result = 0 ; SWIG_check_num_args("ofVideoPlayer::getTexture",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::getTexture",1,"ofVideoPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_getTexture",1,SWIGTYPE_p_ofVideoPlayer); } - result = (ofTexture *) &((ofVideoPlayer const *)arg1)->getTexture(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_ofTexture,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_VideoPlayer_getTexture(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); if (argc == 1) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVideoPlayer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_VideoPlayer_getTexture__SWIG_0(L);} } if (argc == 1) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVideoPlayer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_VideoPlayer_getTexture__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'VideoPlayer_getTexture'\n" - " Possible C/C++ prototypes are:\n" " ofVideoPlayer::getTexture()\n" " ofVideoPlayer::getTexture() const\n"); - lua_error(L);return 0; } -static int _wrap_VideoPlayer_getTexturePlanes__SWIG_0(lua_State* L) { int SWIG_arg = 0; - ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; std::vector< ofTexture > *result = 0 ; - SWIG_check_num_args("ofVideoPlayer::getTexturePlanes",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::getTexturePlanes",1,"ofVideoPlayer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_getTexturePlanes",1,SWIGTYPE_p_ofVideoPlayer); } - result = (std::vector< ofTexture > *) &(arg1)->getTexturePlanes(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofTexture_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_getTexturePlanes__SWIG_1(lua_State* L) { int SWIG_arg = 0; - ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; std::vector< ofTexture > *result = 0 ; - SWIG_check_num_args("ofVideoPlayer::getTexturePlanes",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::getTexturePlanes",1,"ofVideoPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_getTexturePlanes",1,SWIGTYPE_p_ofVideoPlayer); } - result = (std::vector< ofTexture > *) &((ofVideoPlayer const *)arg1)->getTexturePlanes(); - SWIG_NewPointerObj(L,result,SWIGTYPE_p_std__vectorT_ofTexture_t,0); SWIG_arg++; return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_getTexturePlanes(lua_State* L) { int argc; int argv[2]={ 1,2} ; argc = lua_gettop(L); - if (argc == 1) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVideoPlayer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_VideoPlayer_getTexturePlanes__SWIG_0(L);} } if (argc == 1) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVideoPlayer, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { return _wrap_VideoPlayer_getTexturePlanes__SWIG_1(L);} } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'VideoPlayer_getTexturePlanes'\n" - " Possible C/C++ prototypes are:\n" " ofVideoPlayer::getTexturePlanes()\n" - " ofVideoPlayer::getTexturePlanes() const\n"); lua_error(L);return 0; } -static int _wrap_VideoPlayer_draw__SWIG_0(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - float arg2 ; float arg3 ; float arg4 ; float arg5 ; SWIG_check_num_args("ofVideoPlayer::draw",5,5) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::draw",1,"ofVideoPlayer const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVideoPlayer::draw",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVideoPlayer::draw",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("ofVideoPlayer::draw",4,"float"); - if(!lua_isnumber(L,5)) SWIG_fail_arg("ofVideoPlayer::draw",5,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_draw",1,SWIGTYPE_p_ofVideoPlayer); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); arg4 = (float)lua_tonumber(L, 4); arg5 = (float)lua_tonumber(L, 5); - ((ofVideoPlayer const *)arg1)->draw(arg2,arg3,arg4,arg5); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_VideoPlayer_draw__SWIG_1(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - float arg2 ; float arg3 ; SWIG_check_num_args("ofVideoPlayer::draw",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::draw",1,"ofVideoPlayer const *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVideoPlayer::draw",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVideoPlayer::draw",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_draw",1,SWIGTYPE_p_ofVideoPlayer); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); ((ofVideoPlayer const *)arg1)->draw(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: - lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_draw__SWIG_2_0(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - ofPoint *arg2 = 0 ; SWIG_check_num_args("draw",2,2) if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("draw",1,"ofVideoPlayer const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("draw",2,"ofPoint const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_draw",1,SWIGTYPE_p_ofVideoPlayer); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("VideoPlayer_draw",2,SWIGTYPE_p_ofVec3f); } ((ofVideoPlayer const *)arg1)->draw((ofPoint const &)*arg2); - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_draw__SWIG_2_1(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - ofRectangle *arg2 = 0 ; SWIG_check_num_args("draw",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("draw",1,"ofVideoPlayer const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("draw",2,"ofRectangle const &"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_draw",1,SWIGTYPE_p_ofVideoPlayer); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofRectangle,0))){ - SWIG_fail_ptr("VideoPlayer_draw",2,SWIGTYPE_p_ofRectangle); } - ((ofVideoPlayer const *)arg1)->draw((ofRectangle const &)*arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_VideoPlayer_draw__SWIG_2_2(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - ofPoint *arg2 = 0 ; float arg3 ; float arg4 ; SWIG_check_num_args("draw",4,4) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("draw",1,"ofVideoPlayer const *"); - if(!lua_isuserdata(L,2)) SWIG_fail_arg("draw",2,"ofPoint const &"); if(!lua_isnumber(L,3)) SWIG_fail_arg("draw",3,"float"); - if(!lua_isnumber(L,4)) SWIG_fail_arg("draw",4,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_draw",1,SWIGTYPE_p_ofVideoPlayer); } - if (!SWIG_IsOK(SWIG_ConvertPtr(L,2,(void**)&arg2,SWIGTYPE_p_ofVec3f,0))){ - SWIG_fail_ptr("VideoPlayer_draw",2,SWIGTYPE_p_ofVec3f); } arg3 = (float)lua_tonumber(L, 3); - arg4 = (float)lua_tonumber(L, 4); ((ofVideoPlayer const *)arg1)->draw((ofPoint const &)*arg2,arg3,arg4); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_draw(lua_State* L) { int argc; int argv[6]={ 1,2,3,4,5,6} ; argc = lua_gettop(L); if (argc == 2) { - int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVideoPlayer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_VideoPlayer_draw__SWIG_2_0(L);} } } if (argc == 2) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVideoPlayer, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofRectangle, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { return _wrap_VideoPlayer_draw__SWIG_2_1(L);} } } if (argc == 3) { int _v; { - void *ptr; if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVideoPlayer, 0)) { - _v = 0; } else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } - if (_v) { return _wrap_VideoPlayer_draw__SWIG_1(L);} } } } if (argc == 4) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVideoPlayer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { void *ptr; - if (lua_isuserdata(L,argv[1])==0 || SWIG_ConvertPtr(L,argv[1], (void **) &ptr, SWIGTYPE_p_ofVec3f, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { { _v = lua_isnumber(L,argv[3]); } - if (_v) { return _wrap_VideoPlayer_draw__SWIG_2_2(L);} } } } } if (argc == 5) { int _v; { void *ptr; - if (SWIG_isptrtype(L,argv[0])==0 || SWIG_ConvertPtr(L,argv[0], (void **) &ptr, SWIGTYPE_p_ofVideoPlayer, 0)) { _v = 0; } - else { _v = 1; } } if (_v) { { _v = lua_isnumber(L,argv[1]); } if (_v) { { _v = lua_isnumber(L,argv[2]); } if (_v) { - { _v = lua_isnumber(L,argv[3]); } if (_v) { { _v = lua_isnumber(L,argv[4]); } if (_v) { - return _wrap_VideoPlayer_draw__SWIG_0(L);} } } } } } - SWIG_Lua_pusherrstring(L,"Wrong arguments for overloaded function 'VideoPlayer_draw'\n" " Possible C/C++ prototypes are:\n" - " ofVideoPlayer::draw(float,float,float,float) const\n" " ofVideoPlayer::draw(float,float) const\n" - " draw(ofPoint const &) const\n" " draw(ofRectangle const &) const\n" " draw(ofPoint const &,float,float) const\n"); - lua_error(L);return 0; } -static int _wrap_VideoPlayer_bind(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - SWIG_check_num_args("ofVideoPlayer::bind",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::bind",1,"ofVideoPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_bind",1,SWIGTYPE_p_ofVideoPlayer); } ((ofVideoPlayer const *)arg1)->bind(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_unbind(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - SWIG_check_num_args("ofVideoPlayer::unbind",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::unbind",1,"ofVideoPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_unbind",1,SWIGTYPE_p_ofVideoPlayer); } ((ofVideoPlayer const *)arg1)->unbind(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_setAnchorPercent(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - float arg2 ; float arg3 ; SWIG_check_num_args("ofVideoPlayer::setAnchorPercent",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::setAnchorPercent",1,"ofVideoPlayer *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVideoPlayer::setAnchorPercent",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVideoPlayer::setAnchorPercent",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_setAnchorPercent",1,SWIGTYPE_p_ofVideoPlayer); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->setAnchorPercent(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_VideoPlayer_setAnchorPoint(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - float arg2 ; float arg3 ; SWIG_check_num_args("ofVideoPlayer::setAnchorPoint",3,3) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::setAnchorPoint",1,"ofVideoPlayer *"); - if(!lua_isnumber(L,2)) SWIG_fail_arg("ofVideoPlayer::setAnchorPoint",2,"float"); - if(!lua_isnumber(L,3)) SWIG_fail_arg("ofVideoPlayer::setAnchorPoint",3,"float"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_setAnchorPoint",1,SWIGTYPE_p_ofVideoPlayer); } arg2 = (float)lua_tonumber(L, 2); - arg3 = (float)lua_tonumber(L, 3); (arg1)->setAnchorPoint(arg2,arg3); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); - return SWIG_arg; } -static int _wrap_VideoPlayer_resetAnchor(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - SWIG_check_num_args("ofVideoPlayer::resetAnchor",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::resetAnchor",1,"ofVideoPlayer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_resetAnchor",1,SWIGTYPE_p_ofVideoPlayer); } (arg1)->resetAnchor(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_setPaused(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; bool arg2 ; - SWIG_check_num_args("ofVideoPlayer::setPaused",2,2) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::setPaused",1,"ofVideoPlayer *"); - if(!lua_isboolean(L,2)) SWIG_fail_arg("ofVideoPlayer::setPaused",2,"bool"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_setPaused",1,SWIGTYPE_p_ofVideoPlayer); } arg2 = (lua_toboolean(L, 2)!=0); - (arg1)->setPaused(arg2); return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_getCurrentFrame(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - int result; SWIG_check_num_args("ofVideoPlayer::getCurrentFrame",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::getCurrentFrame",1,"ofVideoPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_getCurrentFrame",1,SWIGTYPE_p_ofVideoPlayer); } - result = (int)((ofVideoPlayer const *)arg1)->getCurrentFrame(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_getTotalNumFrames(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - int result; SWIG_check_num_args("ofVideoPlayer::getTotalNumFrames",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::getTotalNumFrames",1,"ofVideoPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_getTotalNumFrames",1,SWIGTYPE_p_ofVideoPlayer); } - result = (int)((ofVideoPlayer const *)arg1)->getTotalNumFrames(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_firstFrame(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - SWIG_check_num_args("ofVideoPlayer::firstFrame",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::firstFrame",1,"ofVideoPlayer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_firstFrame",1,SWIGTYPE_p_ofVideoPlayer); } (arg1)->firstFrame(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_nextFrame(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - SWIG_check_num_args("ofVideoPlayer::nextFrame",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::nextFrame",1,"ofVideoPlayer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_nextFrame",1,SWIGTYPE_p_ofVideoPlayer); } (arg1)->nextFrame(); return SWIG_arg; if(0) SWIG_fail; - fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_previousFrame(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - SWIG_check_num_args("ofVideoPlayer::previousFrame",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::previousFrame",1,"ofVideoPlayer *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_previousFrame",1,SWIGTYPE_p_ofVideoPlayer); } (arg1)->previousFrame(); return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_getHeight(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - float result; SWIG_check_num_args("ofVideoPlayer::getHeight",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::getHeight",1,"ofVideoPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_getHeight",1,SWIGTYPE_p_ofVideoPlayer); } - result = (float)((ofVideoPlayer const *)arg1)->getHeight(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_getWidth(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - float result; SWIG_check_num_args("ofVideoPlayer::getWidth",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::getWidth",1,"ofVideoPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_getWidth",1,SWIGTYPE_p_ofVideoPlayer); } - result = (float)((ofVideoPlayer const *)arg1)->getWidth(); lua_pushnumber(L, (lua_Number) result); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_isPaused(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; bool result; - SWIG_check_num_args("ofVideoPlayer::isPaused",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::isPaused",1,"ofVideoPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_isPaused",1,SWIGTYPE_p_ofVideoPlayer); } - result = (bool)((ofVideoPlayer const *)arg1)->isPaused(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_isLoaded(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; bool result; - SWIG_check_num_args("ofVideoPlayer::isLoaded",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::isLoaded",1,"ofVideoPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_isLoaded",1,SWIGTYPE_p_ofVideoPlayer); } - result = (bool)((ofVideoPlayer const *)arg1)->isLoaded(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_isPlaying(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - bool result; SWIG_check_num_args("ofVideoPlayer::isPlaying",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::isPlaying",1,"ofVideoPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_isPlaying",1,SWIGTYPE_p_ofVideoPlayer); } - result = (bool)((ofVideoPlayer const *)arg1)->isPlaying(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; return SWIG_arg; - if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static int _wrap_VideoPlayer_isInitialized(lua_State* L) { int SWIG_arg = 0; ofVideoPlayer *arg1 = (ofVideoPlayer *) 0 ; - bool result; SWIG_check_num_args("ofVideoPlayer::isInitialized",1,1) - if(!SWIG_isptrtype(L,1)) SWIG_fail_arg("ofVideoPlayer::isInitialized",1,"ofVideoPlayer const *"); - if (!SWIG_IsOK(SWIG_ConvertPtr(L,1,(void**)&arg1,SWIGTYPE_p_ofVideoPlayer,0))){ - SWIG_fail_ptr("VideoPlayer_isInitialized",1,SWIGTYPE_p_ofVideoPlayer); } - result = (bool)((ofVideoPlayer const *)arg1)->isInitialized(); lua_pushboolean(L,(int)(result!=0)); SWIG_arg++; - return SWIG_arg; if(0) SWIG_fail; fail: lua_error(L); return SWIG_arg; } -static void swig_delete_VideoPlayer(void *obj) { -ofVideoPlayer *arg1 = (ofVideoPlayer *) obj; -delete arg1; -} -static int _proxy__wrap_new_VideoPlayer(lua_State *L) { - assert(lua_istable(L,1)); - lua_pushcfunction(L,_wrap_new_VideoPlayer); - assert(!lua_isnil(L,-1)); - lua_replace(L,1); /* replace our table with real constructor */ - lua_call(L,lua_gettop(L)-1,1); - return 1; -} -static swig_lua_attribute swig_VideoPlayer_attributes[] = { - {0,0,0} -}; -static swig_lua_method swig_VideoPlayer_methods[]= { - { "load", _wrap_VideoPlayer_load}, - { "loadAsync", _wrap_VideoPlayer_loadAsync}, - { "getMoviePath", _wrap_VideoPlayer_getMoviePath}, - { "setPixelFormat", _wrap_VideoPlayer_setPixelFormat}, - { "getPixelFormat", _wrap_VideoPlayer_getPixelFormat}, - { "closeMovie", _wrap_VideoPlayer_closeMovie}, - { "close", _wrap_VideoPlayer_close}, - { "update", _wrap_VideoPlayer_update}, - { "play", _wrap_VideoPlayer_play}, - { "stop", _wrap_VideoPlayer_stop}, - { "isFrameNew", _wrap_VideoPlayer_isFrameNew}, - { "getPixels", _wrap_VideoPlayer_getPixels}, - { "getPosition", _wrap_VideoPlayer_getPosition}, - { "getSpeed", _wrap_VideoPlayer_getSpeed}, - { "getDuration", _wrap_VideoPlayer_getDuration}, - { "getIsMovieDone", _wrap_VideoPlayer_getIsMovieDone}, - { "setPosition", _wrap_VideoPlayer_setPosition}, - { "setVolume", _wrap_VideoPlayer_setVolume}, - { "setLoopState", _wrap_VideoPlayer_setLoopState}, - { "getLoopState", _wrap_VideoPlayer_getLoopState}, - { "setSpeed", _wrap_VideoPlayer_setSpeed}, - { "setFrame", _wrap_VideoPlayer_setFrame}, - { "setUseTexture", _wrap_VideoPlayer_setUseTexture}, - { "isUsingTexture", _wrap_VideoPlayer_isUsingTexture}, - { "getTexture", _wrap_VideoPlayer_getTexture}, - { "getTexturePlanes", _wrap_VideoPlayer_getTexturePlanes}, - { "draw", _wrap_VideoPlayer_draw}, - { "bind", _wrap_VideoPlayer_bind}, - { "unbind", _wrap_VideoPlayer_unbind}, - { "setAnchorPercent", _wrap_VideoPlayer_setAnchorPercent}, - { "setAnchorPoint", _wrap_VideoPlayer_setAnchorPoint}, - { "resetAnchor", _wrap_VideoPlayer_resetAnchor}, - { "setPaused", _wrap_VideoPlayer_setPaused}, - { "getCurrentFrame", _wrap_VideoPlayer_getCurrentFrame}, - { "getTotalNumFrames", _wrap_VideoPlayer_getTotalNumFrames}, - { "firstFrame", _wrap_VideoPlayer_firstFrame}, - { "nextFrame", _wrap_VideoPlayer_nextFrame}, - { "previousFrame", _wrap_VideoPlayer_previousFrame}, - { "getHeight", _wrap_VideoPlayer_getHeight}, - { "getWidth", _wrap_VideoPlayer_getWidth}, - { "isPaused", _wrap_VideoPlayer_isPaused}, - { "isLoaded", _wrap_VideoPlayer_isLoaded}, - { "isPlaying", _wrap_VideoPlayer_isPlaying}, - { "isInitialized", _wrap_VideoPlayer_isInitialized}, - {0,0} -}; -static swig_lua_method swig_VideoPlayer_meta[] = { - {0,0} -}; - -static swig_lua_attribute swig_VideoPlayer_Sf_SwigStatic_attributes[] = { - {0,0,0} -}; -static swig_lua_const_info swig_VideoPlayer_Sf_SwigStatic_constants[]= { - {0,0,0,0,0,0} -}; -static swig_lua_method swig_VideoPlayer_Sf_SwigStatic_methods[]= { - {0,0} -}; -static swig_lua_class* swig_VideoPlayer_Sf_SwigStatic_classes[]= { - 0 -}; - -static swig_lua_namespace swig_VideoPlayer_Sf_SwigStatic = { - "VideoPlayer", - swig_VideoPlayer_Sf_SwigStatic_methods, - swig_VideoPlayer_Sf_SwigStatic_attributes, - swig_VideoPlayer_Sf_SwigStatic_constants, - swig_VideoPlayer_Sf_SwigStatic_classes, - 0 -}; -static swig_lua_class *swig_VideoPlayer_bases[] = {0}; -static const char *swig_VideoPlayer_base_names[] = {0}; -static swig_lua_class _wrap_class_VideoPlayer = { "VideoPlayer", "VideoPlayer", &SWIGTYPE_p_ofVideoPlayer,_proxy__wrap_new_VideoPlayer, swig_delete_VideoPlayer, swig_VideoPlayer_methods, swig_VideoPlayer_attributes, &swig_VideoPlayer_Sf_SwigStatic, swig_VideoPlayer_meta, swig_VideoPlayer_bases, swig_VideoPlayer_base_names }; - -static swig_lua_attribute swig_SwigModule_attributes[] = { - { "TTF_SANS", _wrap_TTF_SANS_get, SWIG_Lua_set_immutable }, - { "TTF_SERIF", _wrap_TTF_SERIF_get, SWIG_Lua_set_immutable }, - { "TTF_MONO", _wrap_TTF_MONO_get, SWIG_Lua_set_immutable }, - { "Color_white", _wrap_Color_white_get, SWIG_Lua_set_immutable }, - { "Color_gray", _wrap_Color_gray_get, SWIG_Lua_set_immutable }, - { "Color_black", _wrap_Color_black_get, SWIG_Lua_set_immutable }, - { "Color_red", _wrap_Color_red_get, SWIG_Lua_set_immutable }, - { "Color_green", _wrap_Color_green_get, SWIG_Lua_set_immutable }, - { "Color_blue", _wrap_Color_blue_get, SWIG_Lua_set_immutable }, - { "Color_cyan", _wrap_Color_cyan_get, SWIG_Lua_set_immutable }, - { "Color_magenta", _wrap_Color_magenta_get, SWIG_Lua_set_immutable }, - { "Color_yellow", _wrap_Color_yellow_get, SWIG_Lua_set_immutable }, - { "Color_aliceBlue", _wrap_Color_aliceBlue_get, SWIG_Lua_set_immutable }, - { "Color_antiqueWhite", _wrap_Color_antiqueWhite_get, SWIG_Lua_set_immutable }, - { "Color_aqua", _wrap_Color_aqua_get, SWIG_Lua_set_immutable }, - { "Color_aquamarine", _wrap_Color_aquamarine_get, SWIG_Lua_set_immutable }, - { "Color_azure", _wrap_Color_azure_get, SWIG_Lua_set_immutable }, - { "Color_beige", _wrap_Color_beige_get, SWIG_Lua_set_immutable }, - { "Color_bisque", _wrap_Color_bisque_get, SWIG_Lua_set_immutable }, - { "Color_blanchedAlmond", _wrap_Color_blanchedAlmond_get, SWIG_Lua_set_immutable }, - { "Color_blueViolet", _wrap_Color_blueViolet_get, SWIG_Lua_set_immutable }, - { "Color_brown", _wrap_Color_brown_get, SWIG_Lua_set_immutable }, - { "Color_burlyWood", _wrap_Color_burlyWood_get, SWIG_Lua_set_immutable }, - { "Color_cadetBlue", _wrap_Color_cadetBlue_get, SWIG_Lua_set_immutable }, - { "Color_chartreuse", _wrap_Color_chartreuse_get, SWIG_Lua_set_immutable }, - { "Color_chocolate", _wrap_Color_chocolate_get, SWIG_Lua_set_immutable }, - { "Color_coral", _wrap_Color_coral_get, SWIG_Lua_set_immutable }, - { "Color_cornflowerBlue", _wrap_Color_cornflowerBlue_get, SWIG_Lua_set_immutable }, - { "Color_cornsilk", _wrap_Color_cornsilk_get, SWIG_Lua_set_immutable }, - { "Color_crimson", _wrap_Color_crimson_get, SWIG_Lua_set_immutable }, - { "Color_darkBlue", _wrap_Color_darkBlue_get, SWIG_Lua_set_immutable }, - { "Color_darkCyan", _wrap_Color_darkCyan_get, SWIG_Lua_set_immutable }, - { "Color_darkGoldenRod", _wrap_Color_darkGoldenRod_get, SWIG_Lua_set_immutable }, - { "Color_darkGray", _wrap_Color_darkGray_get, SWIG_Lua_set_immutable }, - { "Color_darkGrey", _wrap_Color_darkGrey_get, SWIG_Lua_set_immutable }, - { "Color_darkGreen", _wrap_Color_darkGreen_get, SWIG_Lua_set_immutable }, - { "Color_darkKhaki", _wrap_Color_darkKhaki_get, SWIG_Lua_set_immutable }, - { "Color_darkMagenta", _wrap_Color_darkMagenta_get, SWIG_Lua_set_immutable }, - { "Color_darkOliveGreen", _wrap_Color_darkOliveGreen_get, SWIG_Lua_set_immutable }, - { "Color_darkorange", _wrap_Color_darkorange_get, SWIG_Lua_set_immutable }, - { "Color_darkOrchid", _wrap_Color_darkOrchid_get, SWIG_Lua_set_immutable }, - { "Color_darkRed", _wrap_Color_darkRed_get, SWIG_Lua_set_immutable }, - { "Color_darkSalmon", _wrap_Color_darkSalmon_get, SWIG_Lua_set_immutable }, - { "Color_darkSeaGreen", _wrap_Color_darkSeaGreen_get, SWIG_Lua_set_immutable }, - { "Color_darkSlateBlue", _wrap_Color_darkSlateBlue_get, SWIG_Lua_set_immutable }, - { "Color_darkSlateGray", _wrap_Color_darkSlateGray_get, SWIG_Lua_set_immutable }, - { "Color_darkSlateGrey", _wrap_Color_darkSlateGrey_get, SWIG_Lua_set_immutable }, - { "Color_darkTurquoise", _wrap_Color_darkTurquoise_get, SWIG_Lua_set_immutable }, - { "Color_darkViolet", _wrap_Color_darkViolet_get, SWIG_Lua_set_immutable }, - { "Color_deepPink", _wrap_Color_deepPink_get, SWIG_Lua_set_immutable }, - { "Color_deepSkyBlue", _wrap_Color_deepSkyBlue_get, SWIG_Lua_set_immutable }, - { "Color_dimGray", _wrap_Color_dimGray_get, SWIG_Lua_set_immutable }, - { "Color_dimGrey", _wrap_Color_dimGrey_get, SWIG_Lua_set_immutable }, - { "Color_dodgerBlue", _wrap_Color_dodgerBlue_get, SWIG_Lua_set_immutable }, - { "Color_fireBrick", _wrap_Color_fireBrick_get, SWIG_Lua_set_immutable }, - { "Color_floralWhite", _wrap_Color_floralWhite_get, SWIG_Lua_set_immutable }, - { "Color_forestGreen", _wrap_Color_forestGreen_get, SWIG_Lua_set_immutable }, - { "Color_fuchsia", _wrap_Color_fuchsia_get, SWIG_Lua_set_immutable }, - { "Color_gainsboro", _wrap_Color_gainsboro_get, SWIG_Lua_set_immutable }, - { "Color_ghostWhite", _wrap_Color_ghostWhite_get, SWIG_Lua_set_immutable }, - { "Color_gold", _wrap_Color_gold_get, SWIG_Lua_set_immutable }, - { "Color_goldenRod", _wrap_Color_goldenRod_get, SWIG_Lua_set_immutable }, - { "Color_grey", _wrap_Color_grey_get, SWIG_Lua_set_immutable }, - { "Color_greenYellow", _wrap_Color_greenYellow_get, SWIG_Lua_set_immutable }, - { "Color_honeyDew", _wrap_Color_honeyDew_get, SWIG_Lua_set_immutable }, - { "Color_hotPink", _wrap_Color_hotPink_get, SWIG_Lua_set_immutable }, - { "Color_indianRed", _wrap_Color_indianRed_get, SWIG_Lua_set_immutable }, - { "Color_indigo", _wrap_Color_indigo_get, SWIG_Lua_set_immutable }, - { "Color_ivory", _wrap_Color_ivory_get, SWIG_Lua_set_immutable }, - { "Color_khaki", _wrap_Color_khaki_get, SWIG_Lua_set_immutable }, - { "Color_lavender", _wrap_Color_lavender_get, SWIG_Lua_set_immutable }, - { "Color_lavenderBlush", _wrap_Color_lavenderBlush_get, SWIG_Lua_set_immutable }, - { "Color_lawnGreen", _wrap_Color_lawnGreen_get, SWIG_Lua_set_immutable }, - { "Color_lemonChiffon", _wrap_Color_lemonChiffon_get, SWIG_Lua_set_immutable }, - { "Color_lightBlue", _wrap_Color_lightBlue_get, SWIG_Lua_set_immutable }, - { "Color_lightCoral", _wrap_Color_lightCoral_get, SWIG_Lua_set_immutable }, - { "Color_lightCyan", _wrap_Color_lightCyan_get, SWIG_Lua_set_immutable }, - { "Color_lightGoldenRodYellow", _wrap_Color_lightGoldenRodYellow_get, SWIG_Lua_set_immutable }, - { "Color_lightGray", _wrap_Color_lightGray_get, SWIG_Lua_set_immutable }, - { "Color_lightGrey", _wrap_Color_lightGrey_get, SWIG_Lua_set_immutable }, - { "Color_lightGreen", _wrap_Color_lightGreen_get, SWIG_Lua_set_immutable }, - { "Color_lightPink", _wrap_Color_lightPink_get, SWIG_Lua_set_immutable }, - { "Color_lightSalmon", _wrap_Color_lightSalmon_get, SWIG_Lua_set_immutable }, - { "Color_lightSeaGreen", _wrap_Color_lightSeaGreen_get, SWIG_Lua_set_immutable }, - { "Color_lightSkyBlue", _wrap_Color_lightSkyBlue_get, SWIG_Lua_set_immutable }, - { "Color_lightSlateGray", _wrap_Color_lightSlateGray_get, SWIG_Lua_set_immutable }, - { "Color_lightSlateGrey", _wrap_Color_lightSlateGrey_get, SWIG_Lua_set_immutable }, - { "Color_lightSteelBlue", _wrap_Color_lightSteelBlue_get, SWIG_Lua_set_immutable }, - { "Color_lightYellow", _wrap_Color_lightYellow_get, SWIG_Lua_set_immutable }, - { "Color_lime", _wrap_Color_lime_get, SWIG_Lua_set_immutable }, - { "Color_limeGreen", _wrap_Color_limeGreen_get, SWIG_Lua_set_immutable }, - { "Color_linen", _wrap_Color_linen_get, SWIG_Lua_set_immutable }, - { "Color_maroon", _wrap_Color_maroon_get, SWIG_Lua_set_immutable }, - { "Color_mediumAquaMarine", _wrap_Color_mediumAquaMarine_get, SWIG_Lua_set_immutable }, - { "Color_mediumBlue", _wrap_Color_mediumBlue_get, SWIG_Lua_set_immutable }, - { "Color_mediumOrchid", _wrap_Color_mediumOrchid_get, SWIG_Lua_set_immutable }, - { "Color_mediumPurple", _wrap_Color_mediumPurple_get, SWIG_Lua_set_immutable }, - { "Color_mediumSeaGreen", _wrap_Color_mediumSeaGreen_get, SWIG_Lua_set_immutable }, - { "Color_mediumSlateBlue", _wrap_Color_mediumSlateBlue_get, SWIG_Lua_set_immutable }, - { "Color_mediumSpringGreen", _wrap_Color_mediumSpringGreen_get, SWIG_Lua_set_immutable }, - { "Color_mediumTurquoise", _wrap_Color_mediumTurquoise_get, SWIG_Lua_set_immutable }, - { "Color_mediumVioletRed", _wrap_Color_mediumVioletRed_get, SWIG_Lua_set_immutable }, - { "Color_midnightBlue", _wrap_Color_midnightBlue_get, SWIG_Lua_set_immutable }, - { "Color_mintCream", _wrap_Color_mintCream_get, SWIG_Lua_set_immutable }, - { "Color_mistyRose", _wrap_Color_mistyRose_get, SWIG_Lua_set_immutable }, - { "Color_moccasin", _wrap_Color_moccasin_get, SWIG_Lua_set_immutable }, - { "Color_navajoWhite", _wrap_Color_navajoWhite_get, SWIG_Lua_set_immutable }, - { "Color_navy", _wrap_Color_navy_get, SWIG_Lua_set_immutable }, - { "Color_oldLace", _wrap_Color_oldLace_get, SWIG_Lua_set_immutable }, - { "Color_olive", _wrap_Color_olive_get, SWIG_Lua_set_immutable }, - { "Color_oliveDrab", _wrap_Color_oliveDrab_get, SWIG_Lua_set_immutable }, - { "Color_orange", _wrap_Color_orange_get, SWIG_Lua_set_immutable }, - { "Color_orangeRed", _wrap_Color_orangeRed_get, SWIG_Lua_set_immutable }, - { "Color_orchid", _wrap_Color_orchid_get, SWIG_Lua_set_immutable }, - { "Color_paleGoldenRod", _wrap_Color_paleGoldenRod_get, SWIG_Lua_set_immutable }, - { "Color_paleGreen", _wrap_Color_paleGreen_get, SWIG_Lua_set_immutable }, - { "Color_paleTurquoise", _wrap_Color_paleTurquoise_get, SWIG_Lua_set_immutable }, - { "Color_paleVioletRed", _wrap_Color_paleVioletRed_get, SWIG_Lua_set_immutable }, - { "Color_papayaWhip", _wrap_Color_papayaWhip_get, SWIG_Lua_set_immutable }, - { "Color_peachPuff", _wrap_Color_peachPuff_get, SWIG_Lua_set_immutable }, - { "Color_peru", _wrap_Color_peru_get, SWIG_Lua_set_immutable }, - { "Color_pink", _wrap_Color_pink_get, SWIG_Lua_set_immutable }, - { "Color_plum", _wrap_Color_plum_get, SWIG_Lua_set_immutable }, - { "Color_powderBlue", _wrap_Color_powderBlue_get, SWIG_Lua_set_immutable }, - { "Color_purple", _wrap_Color_purple_get, SWIG_Lua_set_immutable }, - { "Color_rosyBrown", _wrap_Color_rosyBrown_get, SWIG_Lua_set_immutable }, - { "Color_royalBlue", _wrap_Color_royalBlue_get, SWIG_Lua_set_immutable }, - { "Color_saddleBrown", _wrap_Color_saddleBrown_get, SWIG_Lua_set_immutable }, - { "Color_salmon", _wrap_Color_salmon_get, SWIG_Lua_set_immutable }, - { "Color_sandyBrown", _wrap_Color_sandyBrown_get, SWIG_Lua_set_immutable }, - { "Color_seaGreen", _wrap_Color_seaGreen_get, SWIG_Lua_set_immutable }, - { "Color_seaShell", _wrap_Color_seaShell_get, SWIG_Lua_set_immutable }, - { "Color_sienna", _wrap_Color_sienna_get, SWIG_Lua_set_immutable }, - { "Color_silver", _wrap_Color_silver_get, SWIG_Lua_set_immutable }, - { "Color_skyBlue", _wrap_Color_skyBlue_get, SWIG_Lua_set_immutable }, - { "Color_slateBlue", _wrap_Color_slateBlue_get, SWIG_Lua_set_immutable }, - { "Color_slateGray", _wrap_Color_slateGray_get, SWIG_Lua_set_immutable }, - { "Color_slateGrey", _wrap_Color_slateGrey_get, SWIG_Lua_set_immutable }, - { "Color_snow", _wrap_Color_snow_get, SWIG_Lua_set_immutable }, - { "Color_springGreen", _wrap_Color_springGreen_get, SWIG_Lua_set_immutable }, - { "Color_steelBlue", _wrap_Color_steelBlue_get, SWIG_Lua_set_immutable }, - { "Color_blueSteel", _wrap_Color_blueSteel_get, SWIG_Lua_set_immutable }, - { "Color_tan", _wrap_Color_tan_get, SWIG_Lua_set_immutable }, - { "Color_teal", _wrap_Color_teal_get, SWIG_Lua_set_immutable }, - { "Color_thistle", _wrap_Color_thistle_get, SWIG_Lua_set_immutable }, - { "Color_tomato", _wrap_Color_tomato_get, SWIG_Lua_set_immutable }, - { "Color_turquoise", _wrap_Color_turquoise_get, SWIG_Lua_set_immutable }, - { "Color_violet", _wrap_Color_violet_get, SWIG_Lua_set_immutable }, - { "Color_wheat", _wrap_Color_wheat_get, SWIG_Lua_set_immutable }, - { "Color_whiteSmoke", _wrap_Color_whiteSmoke_get, SWIG_Lua_set_immutable }, - { "Color_yellowGreen", _wrap_Color_yellowGreen_get, SWIG_Lua_set_immutable }, - { "FloatColor_white", _wrap_FloatColor_white_get, SWIG_Lua_set_immutable }, - { "FloatColor_gray", _wrap_FloatColor_gray_get, SWIG_Lua_set_immutable }, - { "FloatColor_black", _wrap_FloatColor_black_get, SWIG_Lua_set_immutable }, - { "FloatColor_red", _wrap_FloatColor_red_get, SWIG_Lua_set_immutable }, - { "FloatColor_green", _wrap_FloatColor_green_get, SWIG_Lua_set_immutable }, - { "FloatColor_blue", _wrap_FloatColor_blue_get, SWIG_Lua_set_immutable }, - { "FloatColor_cyan", _wrap_FloatColor_cyan_get, SWIG_Lua_set_immutable }, - { "FloatColor_magenta", _wrap_FloatColor_magenta_get, SWIG_Lua_set_immutable }, - { "FloatColor_yellow", _wrap_FloatColor_yellow_get, SWIG_Lua_set_immutable }, - { "FloatColor_aliceBlue", _wrap_FloatColor_aliceBlue_get, SWIG_Lua_set_immutable }, - { "FloatColor_antiqueWhite", _wrap_FloatColor_antiqueWhite_get, SWIG_Lua_set_immutable }, - { "FloatColor_aqua", _wrap_FloatColor_aqua_get, SWIG_Lua_set_immutable }, - { "FloatColor_aquamarine", _wrap_FloatColor_aquamarine_get, SWIG_Lua_set_immutable }, - { "FloatColor_azure", _wrap_FloatColor_azure_get, SWIG_Lua_set_immutable }, - { "FloatColor_beige", _wrap_FloatColor_beige_get, SWIG_Lua_set_immutable }, - { "FloatColor_bisque", _wrap_FloatColor_bisque_get, SWIG_Lua_set_immutable }, - { "FloatColor_blanchedAlmond", _wrap_FloatColor_blanchedAlmond_get, SWIG_Lua_set_immutable }, - { "FloatColor_blueViolet", _wrap_FloatColor_blueViolet_get, SWIG_Lua_set_immutable }, - { "FloatColor_brown", _wrap_FloatColor_brown_get, SWIG_Lua_set_immutable }, - { "FloatColor_burlyWood", _wrap_FloatColor_burlyWood_get, SWIG_Lua_set_immutable }, - { "FloatColor_cadetBlue", _wrap_FloatColor_cadetBlue_get, SWIG_Lua_set_immutable }, - { "FloatColor_chartreuse", _wrap_FloatColor_chartreuse_get, SWIG_Lua_set_immutable }, - { "FloatColor_chocolate", _wrap_FloatColor_chocolate_get, SWIG_Lua_set_immutable }, - { "FloatColor_coral", _wrap_FloatColor_coral_get, SWIG_Lua_set_immutable }, - { "FloatColor_cornflowerBlue", _wrap_FloatColor_cornflowerBlue_get, SWIG_Lua_set_immutable }, - { "FloatColor_cornsilk", _wrap_FloatColor_cornsilk_get, SWIG_Lua_set_immutable }, - { "FloatColor_crimson", _wrap_FloatColor_crimson_get, SWIG_Lua_set_immutable }, - { "FloatColor_darkBlue", _wrap_FloatColor_darkBlue_get, SWIG_Lua_set_immutable }, - { "FloatColor_darkCyan", _wrap_FloatColor_darkCyan_get, SWIG_Lua_set_immutable }, - { "FloatColor_darkGoldenRod", _wrap_FloatColor_darkGoldenRod_get, SWIG_Lua_set_immutable }, - { "FloatColor_darkGray", _wrap_FloatColor_darkGray_get, SWIG_Lua_set_immutable }, - { "FloatColor_darkGrey", _wrap_FloatColor_darkGrey_get, SWIG_Lua_set_immutable }, - { "FloatColor_darkGreen", _wrap_FloatColor_darkGreen_get, SWIG_Lua_set_immutable }, - { "FloatColor_darkKhaki", _wrap_FloatColor_darkKhaki_get, SWIG_Lua_set_immutable }, - { "FloatColor_darkMagenta", _wrap_FloatColor_darkMagenta_get, SWIG_Lua_set_immutable }, - { "FloatColor_darkOliveGreen", _wrap_FloatColor_darkOliveGreen_get, SWIG_Lua_set_immutable }, - { "FloatColor_darkorange", _wrap_FloatColor_darkorange_get, SWIG_Lua_set_immutable }, - { "FloatColor_darkOrchid", _wrap_FloatColor_darkOrchid_get, SWIG_Lua_set_immutable }, - { "FloatColor_darkRed", _wrap_FloatColor_darkRed_get, SWIG_Lua_set_immutable }, - { "FloatColor_darkSalmon", _wrap_FloatColor_darkSalmon_get, SWIG_Lua_set_immutable }, - { "FloatColor_darkSeaGreen", _wrap_FloatColor_darkSeaGreen_get, SWIG_Lua_set_immutable }, - { "FloatColor_darkSlateBlue", _wrap_FloatColor_darkSlateBlue_get, SWIG_Lua_set_immutable }, - { "FloatColor_darkSlateGray", _wrap_FloatColor_darkSlateGray_get, SWIG_Lua_set_immutable }, - { "FloatColor_darkSlateGrey", _wrap_FloatColor_darkSlateGrey_get, SWIG_Lua_set_immutable }, - { "FloatColor_darkTurquoise", _wrap_FloatColor_darkTurquoise_get, SWIG_Lua_set_immutable }, - { "FloatColor_darkViolet", _wrap_FloatColor_darkViolet_get, SWIG_Lua_set_immutable }, - { "FloatColor_deepPink", _wrap_FloatColor_deepPink_get, SWIG_Lua_set_immutable }, - { "FloatColor_deepSkyBlue", _wrap_FloatColor_deepSkyBlue_get, SWIG_Lua_set_immutable }, - { "FloatColor_dimGray", _wrap_FloatColor_dimGray_get, SWIG_Lua_set_immutable }, - { "FloatColor_dimGrey", _wrap_FloatColor_dimGrey_get, SWIG_Lua_set_immutable }, - { "FloatColor_dodgerBlue", _wrap_FloatColor_dodgerBlue_get, SWIG_Lua_set_immutable }, - { "FloatColor_fireBrick", _wrap_FloatColor_fireBrick_get, SWIG_Lua_set_immutable }, - { "FloatColor_floralWhite", _wrap_FloatColor_floralWhite_get, SWIG_Lua_set_immutable }, - { "FloatColor_forestGreen", _wrap_FloatColor_forestGreen_get, SWIG_Lua_set_immutable }, - { "FloatColor_fuchsia", _wrap_FloatColor_fuchsia_get, SWIG_Lua_set_immutable }, - { "FloatColor_gainsboro", _wrap_FloatColor_gainsboro_get, SWIG_Lua_set_immutable }, - { "FloatColor_ghostWhite", _wrap_FloatColor_ghostWhite_get, SWIG_Lua_set_immutable }, - { "FloatColor_gold", _wrap_FloatColor_gold_get, SWIG_Lua_set_immutable }, - { "FloatColor_goldenRod", _wrap_FloatColor_goldenRod_get, SWIG_Lua_set_immutable }, - { "FloatColor_grey", _wrap_FloatColor_grey_get, SWIG_Lua_set_immutable }, - { "FloatColor_greenYellow", _wrap_FloatColor_greenYellow_get, SWIG_Lua_set_immutable }, - { "FloatColor_honeyDew", _wrap_FloatColor_honeyDew_get, SWIG_Lua_set_immutable }, - { "FloatColor_hotPink", _wrap_FloatColor_hotPink_get, SWIG_Lua_set_immutable }, - { "FloatColor_indianRed", _wrap_FloatColor_indianRed_get, SWIG_Lua_set_immutable }, - { "FloatColor_indigo", _wrap_FloatColor_indigo_get, SWIG_Lua_set_immutable }, - { "FloatColor_ivory", _wrap_FloatColor_ivory_get, SWIG_Lua_set_immutable }, - { "FloatColor_khaki", _wrap_FloatColor_khaki_get, SWIG_Lua_set_immutable }, - { "FloatColor_lavender", _wrap_FloatColor_lavender_get, SWIG_Lua_set_immutable }, - { "FloatColor_lavenderBlush", _wrap_FloatColor_lavenderBlush_get, SWIG_Lua_set_immutable }, - { "FloatColor_lawnGreen", _wrap_FloatColor_lawnGreen_get, SWIG_Lua_set_immutable }, - { "FloatColor_lemonChiffon", _wrap_FloatColor_lemonChiffon_get, SWIG_Lua_set_immutable }, - { "FloatColor_lightBlue", _wrap_FloatColor_lightBlue_get, SWIG_Lua_set_immutable }, - { "FloatColor_lightCoral", _wrap_FloatColor_lightCoral_get, SWIG_Lua_set_immutable }, - { "FloatColor_lightCyan", _wrap_FloatColor_lightCyan_get, SWIG_Lua_set_immutable }, - { "FloatColor_lightGoldenRodYellow", _wrap_FloatColor_lightGoldenRodYellow_get, SWIG_Lua_set_immutable }, - { "FloatColor_lightGray", _wrap_FloatColor_lightGray_get, SWIG_Lua_set_immutable }, - { "FloatColor_lightGrey", _wrap_FloatColor_lightGrey_get, SWIG_Lua_set_immutable }, - { "FloatColor_lightGreen", _wrap_FloatColor_lightGreen_get, SWIG_Lua_set_immutable }, - { "FloatColor_lightPink", _wrap_FloatColor_lightPink_get, SWIG_Lua_set_immutable }, - { "FloatColor_lightSalmon", _wrap_FloatColor_lightSalmon_get, SWIG_Lua_set_immutable }, - { "FloatColor_lightSeaGreen", _wrap_FloatColor_lightSeaGreen_get, SWIG_Lua_set_immutable }, - { "FloatColor_lightSkyBlue", _wrap_FloatColor_lightSkyBlue_get, SWIG_Lua_set_immutable }, - { "FloatColor_lightSlateGray", _wrap_FloatColor_lightSlateGray_get, SWIG_Lua_set_immutable }, - { "FloatColor_lightSlateGrey", _wrap_FloatColor_lightSlateGrey_get, SWIG_Lua_set_immutable }, - { "FloatColor_lightSteelBlue", _wrap_FloatColor_lightSteelBlue_get, SWIG_Lua_set_immutable }, - { "FloatColor_lightYellow", _wrap_FloatColor_lightYellow_get, SWIG_Lua_set_immutable }, - { "FloatColor_lime", _wrap_FloatColor_lime_get, SWIG_Lua_set_immutable }, - { "FloatColor_limeGreen", _wrap_FloatColor_limeGreen_get, SWIG_Lua_set_immutable }, - { "FloatColor_linen", _wrap_FloatColor_linen_get, SWIG_Lua_set_immutable }, - { "FloatColor_maroon", _wrap_FloatColor_maroon_get, SWIG_Lua_set_immutable }, - { "FloatColor_mediumAquaMarine", _wrap_FloatColor_mediumAquaMarine_get, SWIG_Lua_set_immutable }, - { "FloatColor_mediumBlue", _wrap_FloatColor_mediumBlue_get, SWIG_Lua_set_immutable }, - { "FloatColor_mediumOrchid", _wrap_FloatColor_mediumOrchid_get, SWIG_Lua_set_immutable }, - { "FloatColor_mediumPurple", _wrap_FloatColor_mediumPurple_get, SWIG_Lua_set_immutable }, - { "FloatColor_mediumSeaGreen", _wrap_FloatColor_mediumSeaGreen_get, SWIG_Lua_set_immutable }, - { "FloatColor_mediumSlateBlue", _wrap_FloatColor_mediumSlateBlue_get, SWIG_Lua_set_immutable }, - { "FloatColor_mediumSpringGreen", _wrap_FloatColor_mediumSpringGreen_get, SWIG_Lua_set_immutable }, - { "FloatColor_mediumTurquoise", _wrap_FloatColor_mediumTurquoise_get, SWIG_Lua_set_immutable }, - { "FloatColor_mediumVioletRed", _wrap_FloatColor_mediumVioletRed_get, SWIG_Lua_set_immutable }, - { "FloatColor_midnightBlue", _wrap_FloatColor_midnightBlue_get, SWIG_Lua_set_immutable }, - { "FloatColor_mintCream", _wrap_FloatColor_mintCream_get, SWIG_Lua_set_immutable }, - { "FloatColor_mistyRose", _wrap_FloatColor_mistyRose_get, SWIG_Lua_set_immutable }, - { "FloatColor_moccasin", _wrap_FloatColor_moccasin_get, SWIG_Lua_set_immutable }, - { "FloatColor_navajoWhite", _wrap_FloatColor_navajoWhite_get, SWIG_Lua_set_immutable }, - { "FloatColor_navy", _wrap_FloatColor_navy_get, SWIG_Lua_set_immutable }, - { "FloatColor_oldLace", _wrap_FloatColor_oldLace_get, SWIG_Lua_set_immutable }, - { "FloatColor_olive", _wrap_FloatColor_olive_get, SWIG_Lua_set_immutable }, - { "FloatColor_oliveDrab", _wrap_FloatColor_oliveDrab_get, SWIG_Lua_set_immutable }, - { "FloatColor_orange", _wrap_FloatColor_orange_get, SWIG_Lua_set_immutable }, - { "FloatColor_orangeRed", _wrap_FloatColor_orangeRed_get, SWIG_Lua_set_immutable }, - { "FloatColor_orchid", _wrap_FloatColor_orchid_get, SWIG_Lua_set_immutable }, - { "FloatColor_paleGoldenRod", _wrap_FloatColor_paleGoldenRod_get, SWIG_Lua_set_immutable }, - { "FloatColor_paleGreen", _wrap_FloatColor_paleGreen_get, SWIG_Lua_set_immutable }, - { "FloatColor_paleTurquoise", _wrap_FloatColor_paleTurquoise_get, SWIG_Lua_set_immutable }, - { "FloatColor_paleVioletRed", _wrap_FloatColor_paleVioletRed_get, SWIG_Lua_set_immutable }, - { "FloatColor_papayaWhip", _wrap_FloatColor_papayaWhip_get, SWIG_Lua_set_immutable }, - { "FloatColor_peachPuff", _wrap_FloatColor_peachPuff_get, SWIG_Lua_set_immutable }, - { "FloatColor_peru", _wrap_FloatColor_peru_get, SWIG_Lua_set_immutable }, - { "FloatColor_pink", _wrap_FloatColor_pink_get, SWIG_Lua_set_immutable }, - { "FloatColor_plum", _wrap_FloatColor_plum_get, SWIG_Lua_set_immutable }, - { "FloatColor_powderBlue", _wrap_FloatColor_powderBlue_get, SWIG_Lua_set_immutable }, - { "FloatColor_purple", _wrap_FloatColor_purple_get, SWIG_Lua_set_immutable }, - { "FloatColor_rosyBrown", _wrap_FloatColor_rosyBrown_get, SWIG_Lua_set_immutable }, - { "FloatColor_royalBlue", _wrap_FloatColor_royalBlue_get, SWIG_Lua_set_immutable }, - { "FloatColor_saddleBrown", _wrap_FloatColor_saddleBrown_get, SWIG_Lua_set_immutable }, - { "FloatColor_salmon", _wrap_FloatColor_salmon_get, SWIG_Lua_set_immutable }, - { "FloatColor_sandyBrown", _wrap_FloatColor_sandyBrown_get, SWIG_Lua_set_immutable }, - { "FloatColor_seaGreen", _wrap_FloatColor_seaGreen_get, SWIG_Lua_set_immutable }, - { "FloatColor_seaShell", _wrap_FloatColor_seaShell_get, SWIG_Lua_set_immutable }, - { "FloatColor_sienna", _wrap_FloatColor_sienna_get, SWIG_Lua_set_immutable }, - { "FloatColor_silver", _wrap_FloatColor_silver_get, SWIG_Lua_set_immutable }, - { "FloatColor_skyBlue", _wrap_FloatColor_skyBlue_get, SWIG_Lua_set_immutable }, - { "FloatColor_slateBlue", _wrap_FloatColor_slateBlue_get, SWIG_Lua_set_immutable }, - { "FloatColor_slateGray", _wrap_FloatColor_slateGray_get, SWIG_Lua_set_immutable }, - { "FloatColor_slateGrey", _wrap_FloatColor_slateGrey_get, SWIG_Lua_set_immutable }, - { "FloatColor_snow", _wrap_FloatColor_snow_get, SWIG_Lua_set_immutable }, - { "FloatColor_springGreen", _wrap_FloatColor_springGreen_get, SWIG_Lua_set_immutable }, - { "FloatColor_steelBlue", _wrap_FloatColor_steelBlue_get, SWIG_Lua_set_immutable }, - { "FloatColor_blueSteel", _wrap_FloatColor_blueSteel_get, SWIG_Lua_set_immutable }, - { "FloatColor_tan", _wrap_FloatColor_tan_get, SWIG_Lua_set_immutable }, - { "FloatColor_teal", _wrap_FloatColor_teal_get, SWIG_Lua_set_immutable }, - { "FloatColor_thistle", _wrap_FloatColor_thistle_get, SWIG_Lua_set_immutable }, - { "FloatColor_tomato", _wrap_FloatColor_tomato_get, SWIG_Lua_set_immutable }, - { "FloatColor_turquoise", _wrap_FloatColor_turquoise_get, SWIG_Lua_set_immutable }, - { "FloatColor_violet", _wrap_FloatColor_violet_get, SWIG_Lua_set_immutable }, - { "FloatColor_wheat", _wrap_FloatColor_wheat_get, SWIG_Lua_set_immutable }, - { "FloatColor_whiteSmoke", _wrap_FloatColor_whiteSmoke_get, SWIG_Lua_set_immutable }, - { "FloatColor_yellowGreen", _wrap_FloatColor_yellowGreen_get, SWIG_Lua_set_immutable }, - { "ShortColor_white", _wrap_ShortColor_white_get, SWIG_Lua_set_immutable }, - { "ShortColor_gray", _wrap_ShortColor_gray_get, SWIG_Lua_set_immutable }, - { "ShortColor_black", _wrap_ShortColor_black_get, SWIG_Lua_set_immutable }, - { "ShortColor_red", _wrap_ShortColor_red_get, SWIG_Lua_set_immutable }, - { "ShortColor_green", _wrap_ShortColor_green_get, SWIG_Lua_set_immutable }, - { "ShortColor_blue", _wrap_ShortColor_blue_get, SWIG_Lua_set_immutable }, - { "ShortColor_cyan", _wrap_ShortColor_cyan_get, SWIG_Lua_set_immutable }, - { "ShortColor_magenta", _wrap_ShortColor_magenta_get, SWIG_Lua_set_immutable }, - { "ShortColor_yellow", _wrap_ShortColor_yellow_get, SWIG_Lua_set_immutable }, - { "ShortColor_aliceBlue", _wrap_ShortColor_aliceBlue_get, SWIG_Lua_set_immutable }, - { "ShortColor_antiqueWhite", _wrap_ShortColor_antiqueWhite_get, SWIG_Lua_set_immutable }, - { "ShortColor_aqua", _wrap_ShortColor_aqua_get, SWIG_Lua_set_immutable }, - { "ShortColor_aquamarine", _wrap_ShortColor_aquamarine_get, SWIG_Lua_set_immutable }, - { "ShortColor_azure", _wrap_ShortColor_azure_get, SWIG_Lua_set_immutable }, - { "ShortColor_beige", _wrap_ShortColor_beige_get, SWIG_Lua_set_immutable }, - { "ShortColor_bisque", _wrap_ShortColor_bisque_get, SWIG_Lua_set_immutable }, - { "ShortColor_blanchedAlmond", _wrap_ShortColor_blanchedAlmond_get, SWIG_Lua_set_immutable }, - { "ShortColor_blueViolet", _wrap_ShortColor_blueViolet_get, SWIG_Lua_set_immutable }, - { "ShortColor_brown", _wrap_ShortColor_brown_get, SWIG_Lua_set_immutable }, - { "ShortColor_burlyWood", _wrap_ShortColor_burlyWood_get, SWIG_Lua_set_immutable }, - { "ShortColor_cadetBlue", _wrap_ShortColor_cadetBlue_get, SWIG_Lua_set_immutable }, - { "ShortColor_chartreuse", _wrap_ShortColor_chartreuse_get, SWIG_Lua_set_immutable }, - { "ShortColor_chocolate", _wrap_ShortColor_chocolate_get, SWIG_Lua_set_immutable }, - { "ShortColor_coral", _wrap_ShortColor_coral_get, SWIG_Lua_set_immutable }, - { "ShortColor_cornflowerBlue", _wrap_ShortColor_cornflowerBlue_get, SWIG_Lua_set_immutable }, - { "ShortColor_cornsilk", _wrap_ShortColor_cornsilk_get, SWIG_Lua_set_immutable }, - { "ShortColor_crimson", _wrap_ShortColor_crimson_get, SWIG_Lua_set_immutable }, - { "ShortColor_darkBlue", _wrap_ShortColor_darkBlue_get, SWIG_Lua_set_immutable }, - { "ShortColor_darkCyan", _wrap_ShortColor_darkCyan_get, SWIG_Lua_set_immutable }, - { "ShortColor_darkGoldenRod", _wrap_ShortColor_darkGoldenRod_get, SWIG_Lua_set_immutable }, - { "ShortColor_darkGray", _wrap_ShortColor_darkGray_get, SWIG_Lua_set_immutable }, - { "ShortColor_darkGrey", _wrap_ShortColor_darkGrey_get, SWIG_Lua_set_immutable }, - { "ShortColor_darkGreen", _wrap_ShortColor_darkGreen_get, SWIG_Lua_set_immutable }, - { "ShortColor_darkKhaki", _wrap_ShortColor_darkKhaki_get, SWIG_Lua_set_immutable }, - { "ShortColor_darkMagenta", _wrap_ShortColor_darkMagenta_get, SWIG_Lua_set_immutable }, - { "ShortColor_darkOliveGreen", _wrap_ShortColor_darkOliveGreen_get, SWIG_Lua_set_immutable }, - { "ShortColor_darkorange", _wrap_ShortColor_darkorange_get, SWIG_Lua_set_immutable }, - { "ShortColor_darkOrchid", _wrap_ShortColor_darkOrchid_get, SWIG_Lua_set_immutable }, - { "ShortColor_darkRed", _wrap_ShortColor_darkRed_get, SWIG_Lua_set_immutable }, - { "ShortColor_darkSalmon", _wrap_ShortColor_darkSalmon_get, SWIG_Lua_set_immutable }, - { "ShortColor_darkSeaGreen", _wrap_ShortColor_darkSeaGreen_get, SWIG_Lua_set_immutable }, - { "ShortColor_darkSlateBlue", _wrap_ShortColor_darkSlateBlue_get, SWIG_Lua_set_immutable }, - { "ShortColor_darkSlateGray", _wrap_ShortColor_darkSlateGray_get, SWIG_Lua_set_immutable }, - { "ShortColor_darkSlateGrey", _wrap_ShortColor_darkSlateGrey_get, SWIG_Lua_set_immutable }, - { "ShortColor_darkTurquoise", _wrap_ShortColor_darkTurquoise_get, SWIG_Lua_set_immutable }, - { "ShortColor_darkViolet", _wrap_ShortColor_darkViolet_get, SWIG_Lua_set_immutable }, - { "ShortColor_deepPink", _wrap_ShortColor_deepPink_get, SWIG_Lua_set_immutable }, - { "ShortColor_deepSkyBlue", _wrap_ShortColor_deepSkyBlue_get, SWIG_Lua_set_immutable }, - { "ShortColor_dimGray", _wrap_ShortColor_dimGray_get, SWIG_Lua_set_immutable }, - { "ShortColor_dimGrey", _wrap_ShortColor_dimGrey_get, SWIG_Lua_set_immutable }, - { "ShortColor_dodgerBlue", _wrap_ShortColor_dodgerBlue_get, SWIG_Lua_set_immutable }, - { "ShortColor_fireBrick", _wrap_ShortColor_fireBrick_get, SWIG_Lua_set_immutable }, - { "ShortColor_floralWhite", _wrap_ShortColor_floralWhite_get, SWIG_Lua_set_immutable }, - { "ShortColor_forestGreen", _wrap_ShortColor_forestGreen_get, SWIG_Lua_set_immutable }, - { "ShortColor_fuchsia", _wrap_ShortColor_fuchsia_get, SWIG_Lua_set_immutable }, - { "ShortColor_gainsboro", _wrap_ShortColor_gainsboro_get, SWIG_Lua_set_immutable }, - { "ShortColor_ghostWhite", _wrap_ShortColor_ghostWhite_get, SWIG_Lua_set_immutable }, - { "ShortColor_gold", _wrap_ShortColor_gold_get, SWIG_Lua_set_immutable }, - { "ShortColor_goldenRod", _wrap_ShortColor_goldenRod_get, SWIG_Lua_set_immutable }, - { "ShortColor_grey", _wrap_ShortColor_grey_get, SWIG_Lua_set_immutable }, - { "ShortColor_greenYellow", _wrap_ShortColor_greenYellow_get, SWIG_Lua_set_immutable }, - { "ShortColor_honeyDew", _wrap_ShortColor_honeyDew_get, SWIG_Lua_set_immutable }, - { "ShortColor_hotPink", _wrap_ShortColor_hotPink_get, SWIG_Lua_set_immutable }, - { "ShortColor_indianRed", _wrap_ShortColor_indianRed_get, SWIG_Lua_set_immutable }, - { "ShortColor_indigo", _wrap_ShortColor_indigo_get, SWIG_Lua_set_immutable }, - { "ShortColor_ivory", _wrap_ShortColor_ivory_get, SWIG_Lua_set_immutable }, - { "ShortColor_khaki", _wrap_ShortColor_khaki_get, SWIG_Lua_set_immutable }, - { "ShortColor_lavender", _wrap_ShortColor_lavender_get, SWIG_Lua_set_immutable }, - { "ShortColor_lavenderBlush", _wrap_ShortColor_lavenderBlush_get, SWIG_Lua_set_immutable }, - { "ShortColor_lawnGreen", _wrap_ShortColor_lawnGreen_get, SWIG_Lua_set_immutable }, - { "ShortColor_lemonChiffon", _wrap_ShortColor_lemonChiffon_get, SWIG_Lua_set_immutable }, - { "ShortColor_lightBlue", _wrap_ShortColor_lightBlue_get, SWIG_Lua_set_immutable }, - { "ShortColor_lightCoral", _wrap_ShortColor_lightCoral_get, SWIG_Lua_set_immutable }, - { "ShortColor_lightCyan", _wrap_ShortColor_lightCyan_get, SWIG_Lua_set_immutable }, - { "ShortColor_lightGoldenRodYellow", _wrap_ShortColor_lightGoldenRodYellow_get, SWIG_Lua_set_immutable }, - { "ShortColor_lightGray", _wrap_ShortColor_lightGray_get, SWIG_Lua_set_immutable }, - { "ShortColor_lightGrey", _wrap_ShortColor_lightGrey_get, SWIG_Lua_set_immutable }, - { "ShortColor_lightGreen", _wrap_ShortColor_lightGreen_get, SWIG_Lua_set_immutable }, - { "ShortColor_lightPink", _wrap_ShortColor_lightPink_get, SWIG_Lua_set_immutable }, - { "ShortColor_lightSalmon", _wrap_ShortColor_lightSalmon_get, SWIG_Lua_set_immutable }, - { "ShortColor_lightSeaGreen", _wrap_ShortColor_lightSeaGreen_get, SWIG_Lua_set_immutable }, - { "ShortColor_lightSkyBlue", _wrap_ShortColor_lightSkyBlue_get, SWIG_Lua_set_immutable }, - { "ShortColor_lightSlateGray", _wrap_ShortColor_lightSlateGray_get, SWIG_Lua_set_immutable }, - { "ShortColor_lightSlateGrey", _wrap_ShortColor_lightSlateGrey_get, SWIG_Lua_set_immutable }, - { "ShortColor_lightSteelBlue", _wrap_ShortColor_lightSteelBlue_get, SWIG_Lua_set_immutable }, - { "ShortColor_lightYellow", _wrap_ShortColor_lightYellow_get, SWIG_Lua_set_immutable }, - { "ShortColor_lime", _wrap_ShortColor_lime_get, SWIG_Lua_set_immutable }, - { "ShortColor_limeGreen", _wrap_ShortColor_limeGreen_get, SWIG_Lua_set_immutable }, - { "ShortColor_linen", _wrap_ShortColor_linen_get, SWIG_Lua_set_immutable }, - { "ShortColor_maroon", _wrap_ShortColor_maroon_get, SWIG_Lua_set_immutable }, - { "ShortColor_mediumAquaMarine", _wrap_ShortColor_mediumAquaMarine_get, SWIG_Lua_set_immutable }, - { "ShortColor_mediumBlue", _wrap_ShortColor_mediumBlue_get, SWIG_Lua_set_immutable }, - { "ShortColor_mediumOrchid", _wrap_ShortColor_mediumOrchid_get, SWIG_Lua_set_immutable }, - { "ShortColor_mediumPurple", _wrap_ShortColor_mediumPurple_get, SWIG_Lua_set_immutable }, - { "ShortColor_mediumSeaGreen", _wrap_ShortColor_mediumSeaGreen_get, SWIG_Lua_set_immutable }, - { "ShortColor_mediumSlateBlue", _wrap_ShortColor_mediumSlateBlue_get, SWIG_Lua_set_immutable }, - { "ShortColor_mediumSpringGreen", _wrap_ShortColor_mediumSpringGreen_get, SWIG_Lua_set_immutable }, - { "ShortColor_mediumTurquoise", _wrap_ShortColor_mediumTurquoise_get, SWIG_Lua_set_immutable }, - { "ShortColor_mediumVioletRed", _wrap_ShortColor_mediumVioletRed_get, SWIG_Lua_set_immutable }, - { "ShortColor_midnightBlue", _wrap_ShortColor_midnightBlue_get, SWIG_Lua_set_immutable }, - { "ShortColor_mintCream", _wrap_ShortColor_mintCream_get, SWIG_Lua_set_immutable }, - { "ShortColor_mistyRose", _wrap_ShortColor_mistyRose_get, SWIG_Lua_set_immutable }, - { "ShortColor_moccasin", _wrap_ShortColor_moccasin_get, SWIG_Lua_set_immutable }, - { "ShortColor_navajoWhite", _wrap_ShortColor_navajoWhite_get, SWIG_Lua_set_immutable }, - { "ShortColor_navy", _wrap_ShortColor_navy_get, SWIG_Lua_set_immutable }, - { "ShortColor_oldLace", _wrap_ShortColor_oldLace_get, SWIG_Lua_set_immutable }, - { "ShortColor_olive", _wrap_ShortColor_olive_get, SWIG_Lua_set_immutable }, - { "ShortColor_oliveDrab", _wrap_ShortColor_oliveDrab_get, SWIG_Lua_set_immutable }, - { "ShortColor_orange", _wrap_ShortColor_orange_get, SWIG_Lua_set_immutable }, - { "ShortColor_orangeRed", _wrap_ShortColor_orangeRed_get, SWIG_Lua_set_immutable }, - { "ShortColor_orchid", _wrap_ShortColor_orchid_get, SWIG_Lua_set_immutable }, - { "ShortColor_paleGoldenRod", _wrap_ShortColor_paleGoldenRod_get, SWIG_Lua_set_immutable }, - { "ShortColor_paleGreen", _wrap_ShortColor_paleGreen_get, SWIG_Lua_set_immutable }, - { "ShortColor_paleTurquoise", _wrap_ShortColor_paleTurquoise_get, SWIG_Lua_set_immutable }, - { "ShortColor_paleVioletRed", _wrap_ShortColor_paleVioletRed_get, SWIG_Lua_set_immutable }, - { "ShortColor_papayaWhip", _wrap_ShortColor_papayaWhip_get, SWIG_Lua_set_immutable }, - { "ShortColor_peachPuff", _wrap_ShortColor_peachPuff_get, SWIG_Lua_set_immutable }, - { "ShortColor_peru", _wrap_ShortColor_peru_get, SWIG_Lua_set_immutable }, - { "ShortColor_pink", _wrap_ShortColor_pink_get, SWIG_Lua_set_immutable }, - { "ShortColor_plum", _wrap_ShortColor_plum_get, SWIG_Lua_set_immutable }, - { "ShortColor_powderBlue", _wrap_ShortColor_powderBlue_get, SWIG_Lua_set_immutable }, - { "ShortColor_purple", _wrap_ShortColor_purple_get, SWIG_Lua_set_immutable }, - { "ShortColor_rosyBrown", _wrap_ShortColor_rosyBrown_get, SWIG_Lua_set_immutable }, - { "ShortColor_royalBlue", _wrap_ShortColor_royalBlue_get, SWIG_Lua_set_immutable }, - { "ShortColor_saddleBrown", _wrap_ShortColor_saddleBrown_get, SWIG_Lua_set_immutable }, - { "ShortColor_salmon", _wrap_ShortColor_salmon_get, SWIG_Lua_set_immutable }, - { "ShortColor_sandyBrown", _wrap_ShortColor_sandyBrown_get, SWIG_Lua_set_immutable }, - { "ShortColor_seaGreen", _wrap_ShortColor_seaGreen_get, SWIG_Lua_set_immutable }, - { "ShortColor_seaShell", _wrap_ShortColor_seaShell_get, SWIG_Lua_set_immutable }, - { "ShortColor_sienna", _wrap_ShortColor_sienna_get, SWIG_Lua_set_immutable }, - { "ShortColor_silver", _wrap_ShortColor_silver_get, SWIG_Lua_set_immutable }, - { "ShortColor_skyBlue", _wrap_ShortColor_skyBlue_get, SWIG_Lua_set_immutable }, - { "ShortColor_slateBlue", _wrap_ShortColor_slateBlue_get, SWIG_Lua_set_immutable }, - { "ShortColor_slateGray", _wrap_ShortColor_slateGray_get, SWIG_Lua_set_immutable }, - { "ShortColor_slateGrey", _wrap_ShortColor_slateGrey_get, SWIG_Lua_set_immutable }, - { "ShortColor_snow", _wrap_ShortColor_snow_get, SWIG_Lua_set_immutable }, - { "ShortColor_springGreen", _wrap_ShortColor_springGreen_get, SWIG_Lua_set_immutable }, - { "ShortColor_steelBlue", _wrap_ShortColor_steelBlue_get, SWIG_Lua_set_immutable }, - { "ShortColor_blueSteel", _wrap_ShortColor_blueSteel_get, SWIG_Lua_set_immutable }, - { "ShortColor_tan", _wrap_ShortColor_tan_get, SWIG_Lua_set_immutable }, - { "ShortColor_teal", _wrap_ShortColor_teal_get, SWIG_Lua_set_immutable }, - { "ShortColor_thistle", _wrap_ShortColor_thistle_get, SWIG_Lua_set_immutable }, - { "ShortColor_tomato", _wrap_ShortColor_tomato_get, SWIG_Lua_set_immutable }, - { "ShortColor_turquoise", _wrap_ShortColor_turquoise_get, SWIG_Lua_set_immutable }, - { "ShortColor_violet", _wrap_ShortColor_violet_get, SWIG_Lua_set_immutable }, - { "ShortColor_wheat", _wrap_ShortColor_wheat_get, SWIG_Lua_set_immutable }, - { "ShortColor_whiteSmoke", _wrap_ShortColor_whiteSmoke_get, SWIG_Lua_set_immutable }, - { "ShortColor_yellowGreen", _wrap_ShortColor_yellowGreen_get, SWIG_Lua_set_immutable }, - {0,0,0} -}; -static swig_lua_const_info swig_SwigModule_constants[]= { - {SWIG_LUA_CONSTTAB_INT("VERSION_MAJOR", 0)}, - {SWIG_LUA_CONSTTAB_INT("VERSION_MINOR", 9)}, - {SWIG_LUA_CONSTTAB_INT("VERSION_PATCH", 6)}, - {SWIG_LUA_CONSTTAB_STRING("VERSION_PRE_RELEASE", "stable")}, - {SWIG_LUA_CONSTTAB_INT("LOOP_NONE", OF_LOOP_NONE)}, - {SWIG_LUA_CONSTTAB_INT("LOOP_PALINDROME", OF_LOOP_PALINDROME)}, - {SWIG_LUA_CONSTTAB_INT("LOOP_NORMAL", OF_LOOP_NORMAL)}, - {SWIG_LUA_CONSTTAB_INT("TARGET_OSX", OF_TARGET_OSX)}, - {SWIG_LUA_CONSTTAB_INT("TARGET_MINGW", OF_TARGET_MINGW)}, - {SWIG_LUA_CONSTTAB_INT("TARGET_WINVS", OF_TARGET_WINVS)}, - {SWIG_LUA_CONSTTAB_INT("TARGET_IOS", OF_TARGET_IOS)}, - {SWIG_LUA_CONSTTAB_INT("TARGET_ANDROID", OF_TARGET_ANDROID)}, - {SWIG_LUA_CONSTTAB_INT("TARGET_LINUX", OF_TARGET_LINUX)}, - {SWIG_LUA_CONSTTAB_INT("TARGET_LINUX64", OF_TARGET_LINUX64)}, - {SWIG_LUA_CONSTTAB_INT("TARGET_LINUXARMV6L", OF_TARGET_LINUXARMV6L)}, - {SWIG_LUA_CONSTTAB_INT("TARGET_LINUXARMV7L", OF_TARGET_LINUXARMV7L)}, - {SWIG_LUA_CONSTTAB_INT("TARGET_EMSCRIPTEN", OF_TARGET_EMSCRIPTEN)}, - {SWIG_LUA_CONSTTAB_INT("B14400", 14400)}, - {SWIG_LUA_CONSTTAB_INT("B28800", 28800)}, - {SWIG_LUA_CONSTTAB_INT("HAS_TLS", 1)}, - {SWIG_LUA_CONSTTAB_INT("SERIAL_NO_DATA", -2)}, - {SWIG_LUA_CONSTTAB_INT("SERIAL_ERROR", -1)}, - {SWIG_LUA_CONSTTAB_FLOAT("PI", 3.14159265358979323846)}, - {SWIG_LUA_CONSTTAB_FLOAT("TWO_PI", 6.28318530717958647693)}, - {SWIG_LUA_CONSTTAB_FLOAT("M_TWO_PI", 6.28318530717958647693)}, - {SWIG_LUA_CONSTTAB_FLOAT("FOUR_PI", 12.56637061435917295385)}, - {SWIG_LUA_CONSTTAB_FLOAT("HALF_PI", 1.57079632679489661923)}, - {SWIG_LUA_CONSTTAB_FLOAT("DEG_TO_RAD", (3.14159265358979323846/180.0))}, - {SWIG_LUA_CONSTTAB_FLOAT("RAD_TO_DEG", (180.0/3.14159265358979323846))}, - {SWIG_LUA_CONSTTAB_INT("OUTLINE", OF_OUTLINE)}, - {SWIG_LUA_CONSTTAB_INT("FILLED", OF_FILLED)}, - {SWIG_LUA_CONSTTAB_INT("WINDOW", OF_WINDOW)}, - {SWIG_LUA_CONSTTAB_INT("FULLSCREEN", OF_FULLSCREEN)}, - {SWIG_LUA_CONSTTAB_INT("GAME_MODE", OF_GAME_MODE)}, - {SWIG_LUA_CONSTTAB_INT("ASPECT_RATIO_IGNORE", OF_ASPECT_RATIO_IGNORE)}, - {SWIG_LUA_CONSTTAB_INT("ASPECT_RATIO_KEEP", OF_ASPECT_RATIO_KEEP)}, - {SWIG_LUA_CONSTTAB_INT("ASPECT_RATIO_KEEP_BY_EXPANDING", OF_ASPECT_RATIO_KEEP_BY_EXPANDING)}, - {SWIG_LUA_CONSTTAB_INT("ALIGN_VERT_IGNORE", OF_ALIGN_VERT_IGNORE)}, - {SWIG_LUA_CONSTTAB_INT("ALIGN_VERT_TOP", OF_ALIGN_VERT_TOP)}, - {SWIG_LUA_CONSTTAB_INT("ALIGN_VERT_BOTTOM", OF_ALIGN_VERT_BOTTOM)}, - {SWIG_LUA_CONSTTAB_INT("ALIGN_VERT_CENTER", OF_ALIGN_VERT_CENTER)}, - {SWIG_LUA_CONSTTAB_INT("ALIGN_HORZ_IGNORE", OF_ALIGN_HORZ_IGNORE)}, - {SWIG_LUA_CONSTTAB_INT("ALIGN_HORZ_LEFT", OF_ALIGN_HORZ_LEFT)}, - {SWIG_LUA_CONSTTAB_INT("ALIGN_HORZ_RIGHT", OF_ALIGN_HORZ_RIGHT)}, - {SWIG_LUA_CONSTTAB_INT("ALIGN_HORZ_CENTER", OF_ALIGN_HORZ_CENTER)}, - {SWIG_LUA_CONSTTAB_INT("RECTMODE_CORNER", OF_RECTMODE_CORNER)}, - {SWIG_LUA_CONSTTAB_INT("RECTMODE_CENTER", OF_RECTMODE_CENTER)}, - {SWIG_LUA_CONSTTAB_INT("SCALEMODE_FIT", OF_SCALEMODE_FIT)}, - {SWIG_LUA_CONSTTAB_INT("SCALEMODE_FILL", OF_SCALEMODE_FILL)}, - {SWIG_LUA_CONSTTAB_INT("SCALEMODE_CENTER", OF_SCALEMODE_CENTER)}, - {SWIG_LUA_CONSTTAB_INT("SCALEMODE_STRETCH_TO_FILL", OF_SCALEMODE_STRETCH_TO_FILL)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_GRAYSCALE", OF_IMAGE_GRAYSCALE)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_COLOR", OF_IMAGE_COLOR)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_COLOR_ALPHA", OF_IMAGE_COLOR_ALPHA)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_UNDEFINED", OF_IMAGE_UNDEFINED)}, - {SWIG_LUA_CONSTTAB_INT("MAX_STYLE_HISTORY", 32)}, - {SWIG_LUA_CONSTTAB_INT("MAX_VIEWPORT_HISTORY", 32)}, - {SWIG_LUA_CONSTTAB_INT("MAX_CIRCLE_PTS", 1024)}, - {SWIG_LUA_CONSTTAB_INT("BLENDMODE_DISABLED", OF_BLENDMODE_DISABLED)}, - {SWIG_LUA_CONSTTAB_INT("BLENDMODE_ALPHA", OF_BLENDMODE_ALPHA)}, - {SWIG_LUA_CONSTTAB_INT("BLENDMODE_ADD", OF_BLENDMODE_ADD)}, - {SWIG_LUA_CONSTTAB_INT("BLENDMODE_SUBTRACT", OF_BLENDMODE_SUBTRACT)}, - {SWIG_LUA_CONSTTAB_INT("BLENDMODE_MULTIPLY", OF_BLENDMODE_MULTIPLY)}, - {SWIG_LUA_CONSTTAB_INT("BLENDMODE_SCREEN", OF_BLENDMODE_SCREEN)}, - {SWIG_LUA_CONSTTAB_INT("ORIENTATION_DEFAULT", OF_ORIENTATION_DEFAULT)}, - {SWIG_LUA_CONSTTAB_INT("ORIENTATION_180", OF_ORIENTATION_180)}, - {SWIG_LUA_CONSTTAB_INT("ORIENTATION_90_LEFT", OF_ORIENTATION_90_LEFT)}, - {SWIG_LUA_CONSTTAB_INT("ORIENTATION_90_RIGHT", OF_ORIENTATION_90_RIGHT)}, - {SWIG_LUA_CONSTTAB_INT("ORIENTATION_UNKNOWN", OF_ORIENTATION_UNKNOWN)}, - {SWIG_LUA_CONSTTAB_INT("GRADIENT_LINEAR", OF_GRADIENT_LINEAR)}, - {SWIG_LUA_CONSTTAB_INT("GRADIENT_CIRCULAR", OF_GRADIENT_CIRCULAR)}, - {SWIG_LUA_CONSTTAB_INT("GRADIENT_BAR", OF_GRADIENT_BAR)}, - {SWIG_LUA_CONSTTAB_INT("POLY_WINDING_ODD", OF_POLY_WINDING_ODD)}, - {SWIG_LUA_CONSTTAB_INT("POLY_WINDING_NONZERO", OF_POLY_WINDING_NONZERO)}, - {SWIG_LUA_CONSTTAB_INT("POLY_WINDING_POSITIVE", OF_POLY_WINDING_POSITIVE)}, - {SWIG_LUA_CONSTTAB_INT("POLY_WINDING_NEGATIVE", OF_POLY_WINDING_NEGATIVE)}, - {SWIG_LUA_CONSTTAB_INT("POLY_WINDING_ABS_GEQ_TWO", OF_POLY_WINDING_ABS_GEQ_TWO)}, - {SWIG_LUA_CONSTTAB_INT("CLOSE", (true))}, - {SWIG_LUA_CONSTTAB_INT("LEFT_HANDED", OF_LEFT_HANDED)}, - {SWIG_LUA_CONSTTAB_INT("RIGHT_HANDED", OF_RIGHT_HANDED)}, - {SWIG_LUA_CONSTTAB_INT("MATRIX_MODELVIEW", OF_MATRIX_MODELVIEW)}, - {SWIG_LUA_CONSTTAB_INT("MATRIX_PROJECTION", OF_MATRIX_PROJECTION)}, - {SWIG_LUA_CONSTTAB_INT("MATRIX_TEXTURE", OF_MATRIX_TEXTURE)}, - {SWIG_LUA_CONSTTAB_INT("KEY_MODIFIER", 0x0100)}, - {SWIG_LUA_CONSTTAB_INT("KEY_RETURN", 13)}, - {SWIG_LUA_CONSTTAB_INT("KEY_ESC", 27)}, - {SWIG_LUA_CONSTTAB_INT("KEY_TAB", 9)}, - {SWIG_LUA_CONSTTAB_INT("KEY_BACKSPACE", 8)}, - {SWIG_LUA_CONSTTAB_INT("KEY_DEL", 127)}, - {SWIG_LUA_CONSTTAB_INT("KEY_F1", (1|0x0100))}, - {SWIG_LUA_CONSTTAB_INT("KEY_F2", (2|0x0100))}, - {SWIG_LUA_CONSTTAB_INT("KEY_F3", (3|0x0100))}, - {SWIG_LUA_CONSTTAB_INT("KEY_F4", (4|0x0100))}, - {SWIG_LUA_CONSTTAB_INT("KEY_F5", (5|0x0100))}, - {SWIG_LUA_CONSTTAB_INT("KEY_F6", (6|0x0100))}, - {SWIG_LUA_CONSTTAB_INT("KEY_F7", (7|0x0100))}, - {SWIG_LUA_CONSTTAB_INT("KEY_F8", (8|0x0100))}, - {SWIG_LUA_CONSTTAB_INT("KEY_F9", (9|0x0100))}, - {SWIG_LUA_CONSTTAB_INT("KEY_F10", (10|0x0100))}, - {SWIG_LUA_CONSTTAB_INT("KEY_F11", (11|0x0100))}, - {SWIG_LUA_CONSTTAB_INT("KEY_F12", (12|0x0100))}, - {SWIG_LUA_CONSTTAB_INT("KEY_LEFT", (100|0x0100))}, - {SWIG_LUA_CONSTTAB_INT("KEY_UP", (101|0x0100))}, - {SWIG_LUA_CONSTTAB_INT("KEY_RIGHT", (102|0x0100))}, - {SWIG_LUA_CONSTTAB_INT("KEY_DOWN", (103|0x0100))}, - {SWIG_LUA_CONSTTAB_INT("KEY_PAGE_UP", (104|0x0100))}, - {SWIG_LUA_CONSTTAB_INT("KEY_PAGE_DOWN", (105|0x0100))}, - {SWIG_LUA_CONSTTAB_INT("KEY_HOME", (106|0x0100))}, - {SWIG_LUA_CONSTTAB_INT("KEY_END", (107|0x0100))}, - {SWIG_LUA_CONSTTAB_INT("KEY_INSERT", (108|0x0100))}, - {SWIG_LUA_CONSTTAB_INT("KEY_CONTROL", (0x200|0x0100))}, - {SWIG_LUA_CONSTTAB_INT("KEY_ALT", (0x400|0x0100))}, - {SWIG_LUA_CONSTTAB_INT("KEY_SHIFT", (0x800|0x0100))}, - {SWIG_LUA_CONSTTAB_INT("KEY_SUPER", (0x1000|0x0100))}, - {SWIG_LUA_CONSTTAB_INT("KEY_LEFT_SHIFT", (0x1|(0x800|0x0100)))}, - {SWIG_LUA_CONSTTAB_INT("KEY_RIGHT_SHIFT", (0x2|(0x800|0x0100)))}, - {SWIG_LUA_CONSTTAB_INT("KEY_LEFT_CONTROL", (0x1|(0x200|0x0100)))}, - {SWIG_LUA_CONSTTAB_INT("KEY_RIGHT_CONTROL", (0x2|(0x200|0x0100)))}, - {SWIG_LUA_CONSTTAB_INT("KEY_LEFT_ALT", (0x1|(0x400|0x0100)))}, - {SWIG_LUA_CONSTTAB_INT("KEY_RIGHT_ALT", (0x2|(0x400|0x0100)))}, - {SWIG_LUA_CONSTTAB_INT("KEY_LEFT_SUPER", (0x1|(0x1000|0x0100)))}, - {SWIG_LUA_CONSTTAB_INT("KEY_RIGHT_SUPER", (0x2|(0x1000|0x0100)))}, - {SWIG_LUA_CONSTTAB_INT("KEY_LEFT_COMMAND", (0x1|(0x1000|0x0100)))}, - {SWIG_LUA_CONSTTAB_INT("KEY_RIGHT_COMMAND", (0x2|(0x1000|0x0100)))}, - {SWIG_LUA_CONSTTAB_INT("MOUSE_BUTTON_1", 0)}, - {SWIG_LUA_CONSTTAB_INT("MOUSE_BUTTON_2", 1)}, - {SWIG_LUA_CONSTTAB_INT("MOUSE_BUTTON_3", 2)}, - {SWIG_LUA_CONSTTAB_INT("MOUSE_BUTTON_4", 3)}, - {SWIG_LUA_CONSTTAB_INT("MOUSE_BUTTON_5", 4)}, - {SWIG_LUA_CONSTTAB_INT("MOUSE_BUTTON_6", 5)}, - {SWIG_LUA_CONSTTAB_INT("MOUSE_BUTTON_7", 6)}, - {SWIG_LUA_CONSTTAB_INT("MOUSE_BUTTON_8", 7)}, - {SWIG_LUA_CONSTTAB_INT("MOUSE_BUTTON_LAST", 7)}, - {SWIG_LUA_CONSTTAB_INT("MOUSE_BUTTON_LEFT", 0)}, - {SWIG_LUA_CONSTTAB_INT("MOUSE_BUTTON_MIDDLE", 1)}, - {SWIG_LUA_CONSTTAB_INT("MOUSE_BUTTON_RIGHT", 2)}, - {SWIG_LUA_CONSTTAB_INT("CONSOLE_COLOR_RESTORE", (0))}, - {SWIG_LUA_CONSTTAB_INT("CONSOLE_COLOR_BLACK", (30))}, - {SWIG_LUA_CONSTTAB_INT("CONSOLE_COLOR_RED", (31))}, - {SWIG_LUA_CONSTTAB_INT("CONSOLE_COLOR_GREEN", (32))}, - {SWIG_LUA_CONSTTAB_INT("CONSOLE_COLOR_YELLOW", (33))}, - {SWIG_LUA_CONSTTAB_INT("CONSOLE_COLOR_BLUE", (34))}, - {SWIG_LUA_CONSTTAB_INT("CONSOLE_COLOR_PURPLE", (35))}, - {SWIG_LUA_CONSTTAB_INT("CONSOLE_COLOR_CYAN", (36))}, - {SWIG_LUA_CONSTTAB_INT("CONSOLE_COLOR_WHITE", (37))}, - {SWIG_LUA_CONSTTAB_INT("PIXELS_GRAY", OF_PIXELS_GRAY)}, - {SWIG_LUA_CONSTTAB_INT("PIXELS_GRAY_ALPHA", OF_PIXELS_GRAY_ALPHA)}, - {SWIG_LUA_CONSTTAB_INT("PIXELS_RGB", OF_PIXELS_RGB)}, - {SWIG_LUA_CONSTTAB_INT("PIXELS_BGR", OF_PIXELS_BGR)}, - {SWIG_LUA_CONSTTAB_INT("PIXELS_RGBA", OF_PIXELS_RGBA)}, - {SWIG_LUA_CONSTTAB_INT("PIXELS_BGRA", OF_PIXELS_BGRA)}, - {SWIG_LUA_CONSTTAB_INT("PIXELS_RGB565", OF_PIXELS_RGB565)}, - {SWIG_LUA_CONSTTAB_INT("PIXELS_NV12", OF_PIXELS_NV12)}, - {SWIG_LUA_CONSTTAB_INT("PIXELS_NV21", OF_PIXELS_NV21)}, - {SWIG_LUA_CONSTTAB_INT("PIXELS_YV12", OF_PIXELS_YV12)}, - {SWIG_LUA_CONSTTAB_INT("PIXELS_I420", OF_PIXELS_I420)}, - {SWIG_LUA_CONSTTAB_INT("PIXELS_YUY2", OF_PIXELS_YUY2)}, - {SWIG_LUA_CONSTTAB_INT("PIXELS_UYVY", OF_PIXELS_UYVY)}, - {SWIG_LUA_CONSTTAB_INT("PIXELS_Y", OF_PIXELS_Y)}, - {SWIG_LUA_CONSTTAB_INT("PIXELS_U", OF_PIXELS_U)}, - {SWIG_LUA_CONSTTAB_INT("PIXELS_V", OF_PIXELS_V)}, - {SWIG_LUA_CONSTTAB_INT("PIXELS_UV", OF_PIXELS_UV)}, - {SWIG_LUA_CONSTTAB_INT("PIXELS_VU", OF_PIXELS_VU)}, - {SWIG_LUA_CONSTTAB_INT("PIXELS_NUM_FORMATS", OF_PIXELS_NUM_FORMATS)}, - {SWIG_LUA_CONSTTAB_INT("PIXELS_UNKNOWN", OF_PIXELS_UNKNOWN)}, - {SWIG_LUA_CONSTTAB_INT("PIXELS_NATIVE", OF_PIXELS_NATIVE)}, - {SWIG_LUA_CONSTTAB_INT("BITMAPMODE_SIMPLE", OF_BITMAPMODE_SIMPLE)}, - {SWIG_LUA_CONSTTAB_INT("BITMAPMODE_SCREEN", OF_BITMAPMODE_SCREEN)}, - {SWIG_LUA_CONSTTAB_INT("BITMAPMODE_VIEWPORT", OF_BITMAPMODE_VIEWPORT)}, - {SWIG_LUA_CONSTTAB_INT("BITMAPMODE_MODEL", OF_BITMAPMODE_MODEL)}, - {SWIG_LUA_CONSTTAB_INT("BITMAPMODE_MODEL_BILLBOARD", OF_BITMAPMODE_MODEL_BILLBOARD)}, - {SWIG_LUA_CONSTTAB_INT("ENCODING_UTF8", OF_ENCODING_UTF8)}, - {SWIG_LUA_CONSTTAB_INT("ENCODING_ISO_8859_15", OF_ENCODING_ISO_8859_15)}, - {SWIG_LUA_CONSTTAB_INT("COMPRESS_NONE", OF_COMPRESS_NONE)}, - {SWIG_LUA_CONSTTAB_INT("COMPRESS_SRGB", OF_COMPRESS_SRGB)}, - {SWIG_LUA_CONSTTAB_INT("COMPRESS_ARB", OF_COMPRESS_ARB)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_QUALITY_BEST", OF_IMAGE_QUALITY_BEST)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_QUALITY_HIGH", OF_IMAGE_QUALITY_HIGH)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_QUALITY_MEDIUM", OF_IMAGE_QUALITY_MEDIUM)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_QUALITY_LOW", OF_IMAGE_QUALITY_LOW)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_QUALITY_WORST", OF_IMAGE_QUALITY_WORST)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_BMP", OF_IMAGE_FORMAT_BMP)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_ICO", OF_IMAGE_FORMAT_ICO)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_JPEG", OF_IMAGE_FORMAT_JPEG)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_JNG", OF_IMAGE_FORMAT_JNG)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_KOALA", OF_IMAGE_FORMAT_KOALA)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_LBM", OF_IMAGE_FORMAT_LBM)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_IFF", OF_IMAGE_FORMAT_IFF)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_MNG", OF_IMAGE_FORMAT_MNG)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_PBM", OF_IMAGE_FORMAT_PBM)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_PBMRAW", OF_IMAGE_FORMAT_PBMRAW)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_PCD", OF_IMAGE_FORMAT_PCD)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_PCX", OF_IMAGE_FORMAT_PCX)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_PGM", OF_IMAGE_FORMAT_PGM)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_PGMRAW", OF_IMAGE_FORMAT_PGMRAW)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_PNG", OF_IMAGE_FORMAT_PNG)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_PPM", OF_IMAGE_FORMAT_PPM)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_PPMRAW", OF_IMAGE_FORMAT_PPMRAW)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_RAS", OF_IMAGE_FORMAT_RAS)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_TARGA", OF_IMAGE_FORMAT_TARGA)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_TIFF", OF_IMAGE_FORMAT_TIFF)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_WBMP", OF_IMAGE_FORMAT_WBMP)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_PSD", OF_IMAGE_FORMAT_PSD)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_CUT", OF_IMAGE_FORMAT_CUT)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_XBM", OF_IMAGE_FORMAT_XBM)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_XPM", OF_IMAGE_FORMAT_XPM)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_DDS", OF_IMAGE_FORMAT_DDS)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_GIF", OF_IMAGE_FORMAT_GIF)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_HDR", OF_IMAGE_FORMAT_HDR)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_FAXG3", OF_IMAGE_FORMAT_FAXG3)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_SGI", OF_IMAGE_FORMAT_SGI)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_EXR", OF_IMAGE_FORMAT_EXR)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_J2K", OF_IMAGE_FORMAT_J2K)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_JP2", OF_IMAGE_FORMAT_JP2)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_PFM", OF_IMAGE_FORMAT_PFM)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_PICT", OF_IMAGE_FORMAT_PICT)}, - {SWIG_LUA_CONSTTAB_INT("IMAGE_FORMAT_RAW", OF_IMAGE_FORMAT_RAW)}, - {SWIG_LUA_CONSTTAB_INT("BoxPrimitive_SIDE_FRONT", ofBoxPrimitive::SIDE_FRONT)}, - {SWIG_LUA_CONSTTAB_INT("BoxPrimitive_SIDE_RIGHT", ofBoxPrimitive::SIDE_RIGHT)}, - {SWIG_LUA_CONSTTAB_INT("BoxPrimitive_SIDE_LEFT", ofBoxPrimitive::SIDE_LEFT)}, - {SWIG_LUA_CONSTTAB_INT("BoxPrimitive_SIDE_BACK", ofBoxPrimitive::SIDE_BACK)}, - {SWIG_LUA_CONSTTAB_INT("BoxPrimitive_SIDE_TOP", ofBoxPrimitive::SIDE_TOP)}, - {SWIG_LUA_CONSTTAB_INT("BoxPrimitive_SIDE_BOTTOM", ofBoxPrimitive::SIDE_BOTTOM)}, - {SWIG_LUA_CONSTTAB_INT("BoxPrimitive_SIDES_TOTAL", ofBoxPrimitive::SIDES_TOTAL)}, - {SWIG_LUA_CONSTTAB_INT("FIRMATA_MAJOR_VERSION", 2)}, - {SWIG_LUA_CONSTTAB_INT("FIRMATA_MINOR_VERSION", 0)}, - {SWIG_LUA_CONSTTAB_INT("FIRMATA_MAX_DATA_BYTES", 32)}, - {SWIG_LUA_CONSTTAB_INT("FIRMATA_DIGITAL_MESSAGE", 0x90)}, - {SWIG_LUA_CONSTTAB_INT("FIRMATA_ANALOG_MESSAGE", 0xE0)}, - {SWIG_LUA_CONSTTAB_INT("FIRMATA_REPORT_ANALOG", 0xC0)}, - {SWIG_LUA_CONSTTAB_INT("FIRMATA_REPORT_DIGITAL", 0xD0)}, - {SWIG_LUA_CONSTTAB_INT("FIRMATA_SET_PIN_MODE", 0xF4)}, - {SWIG_LUA_CONSTTAB_INT("FIRMATA_REPORT_VERSION", 0xF9)}, - {SWIG_LUA_CONSTTAB_INT("FIRMATA_SYSTEM_RESET", 0xFF)}, - {SWIG_LUA_CONSTTAB_INT("FIRMATA_START_SYSEX", 0xF0)}, - {SWIG_LUA_CONSTTAB_INT("FIRMATA_END_SYSEX", 0xF7)}, - {SWIG_LUA_CONSTTAB_INT("FIRMATA_INPUT", 0x00)}, - {SWIG_LUA_CONSTTAB_INT("FIRMATA_OUTPUT", 0x01)}, - {SWIG_LUA_CONSTTAB_INT("FIRMATA_ANALOG", 0x02)}, - {SWIG_LUA_CONSTTAB_INT("FIRMATA_PWM", 0x03)}, - {SWIG_LUA_CONSTTAB_INT("FIRMATA_SERVO", 0x04)}, - {SWIG_LUA_CONSTTAB_INT("SHIFT", 0x05)}, - {SWIG_LUA_CONSTTAB_INT("I2C", 0x06)}, - {SWIG_LUA_CONSTTAB_INT("TOTAL_PIN_MODES", 7)}, - {SWIG_LUA_CONSTTAB_INT("FIRMATA_SYSEX_SERVO_CONFIG", 0x70)}, - {SWIG_LUA_CONSTTAB_INT("FIRMATA_SYSEX_FIRMATA_STRING", 0x71)}, - {SWIG_LUA_CONSTTAB_INT("SHIFT_DATA", 0x75)}, - {SWIG_LUA_CONSTTAB_INT("I2C_REQUEST", 0x76)}, - {SWIG_LUA_CONSTTAB_INT("I2C_REPLY", 0x77)}, - {SWIG_LUA_CONSTTAB_INT("I2C_CONFIG", 0x78)}, - {SWIG_LUA_CONSTTAB_INT("EXTENDED_ANALOG", 0x6F)}, - {SWIG_LUA_CONSTTAB_INT("PIN_STATE_QUERY", 0x6D)}, - {SWIG_LUA_CONSTTAB_INT("PIN_STATE_RESPONSE", 0x6E)}, - {SWIG_LUA_CONSTTAB_INT("CAPABILITY_QUERY", 0x6B)}, - {SWIG_LUA_CONSTTAB_INT("CAPABILITY_RESPONSE", 0x6C)}, - {SWIG_LUA_CONSTTAB_INT("ANALOG_MAPPING_QUERY", 0x69)}, - {SWIG_LUA_CONSTTAB_INT("ANALOG_MAPPING_RESPONSE", 0x6A)}, - {SWIG_LUA_CONSTTAB_INT("FIRMATA_SYSEX_REPORT_FIRMWARE", 0x79)}, - {SWIG_LUA_CONSTTAB_INT("SAMPLING_INTERVAL", 0x7A)}, - {SWIG_LUA_CONSTTAB_INT("FIRMATA_SYSEX_NON_REALTIME", 0x7E)}, - {SWIG_LUA_CONSTTAB_INT("FIRMATA_SYSEX_REALTIME", 0x7F)}, - {SWIG_LUA_CONSTTAB_INT("ARD_TOTAL_DIGITAL_PINS", 22)}, - {SWIG_LUA_CONSTTAB_INT("ARD_TOTAL_ANALOG_PINS", 6)}, - {SWIG_LUA_CONSTTAB_INT("ARD_TOTAL_PORTS", 3)}, - {SWIG_LUA_CONSTTAB_INT("ARD_INPUT", 0x00)}, - {SWIG_LUA_CONSTTAB_INT("ARD_OUTPUT", 0x01)}, - {SWIG_LUA_CONSTTAB_INT("ARD_ANALOG", 0x02)}, - {SWIG_LUA_CONSTTAB_INT("ARD_PWM", 0x03)}, - {SWIG_LUA_CONSTTAB_INT("ARD_SERVO", 0x04)}, - {SWIG_LUA_CONSTTAB_INT("ARD_HIGH", 1)}, - {SWIG_LUA_CONSTTAB_INT("ARD_LOW", 0)}, - {SWIG_LUA_CONSTTAB_INT("ARD_ON", 1)}, - {SWIG_LUA_CONSTTAB_INT("ARD_OFF", 0)}, - {SWIG_LUA_CONSTTAB_INT("SYSEX_SERVO_ATTACH", 0x00)}, - {SWIG_LUA_CONSTTAB_INT("SYSEX_SERVO_DETACH", 0x01)}, - {SWIG_LUA_CONSTTAB_INT("SYSEX_SERVO_WRITE", 0x02)}, - {SWIG_LUA_CONSTTAB_FLOAT("ARDUINO_DELAY_LENGTH", 4.0)}, - {SWIG_LUA_CONSTTAB_INT("FIRMWARE2_2", 22)}, - {SWIG_LUA_CONSTTAB_INT("FIRMWARE2_3", 23)}, - {SWIG_LUA_CONSTTAB_INT("Vec2f_DIM", ofVec2f::DIM)}, - {SWIG_LUA_CONSTTAB_INT("Vec3f_DIM", ofVec3f::DIM)}, - {SWIG_LUA_CONSTTAB_INT("Vec4f_DIM", ofVec4f::DIM)}, - {SWIG_LUA_CONSTTAB_INT("TouchEventArgs_down", ofTouchEventArgs::down)}, - {SWIG_LUA_CONSTTAB_INT("TouchEventArgs_up", ofTouchEventArgs::up)}, - {SWIG_LUA_CONSTTAB_INT("TouchEventArgs_move", ofTouchEventArgs::move)}, - {SWIG_LUA_CONSTTAB_INT("TouchEventArgs_doubleTap", ofTouchEventArgs::doubleTap)}, - {SWIG_LUA_CONSTTAB_INT("TouchEventArgs_cancel", ofTouchEventArgs::cancel)}, - {SWIG_LUA_CONSTTAB_INT("TEXTURE_LUMINANCE", 6409)}, - {SWIG_LUA_CONSTTAB_INT("TEXTURE_RGB", 6407)}, - {SWIG_LUA_CONSTTAB_INT("TEXTURE_RGBA", 6408)}, - {SWIG_LUA_CONSTTAB_INT("NEAREST", 9728)}, - {SWIG_LUA_CONSTTAB_INT("LINEAR", 9729)}, - {SWIG_LUA_CONSTTAB_INT("FRAGMENT_SHADER", 35632)}, - {SWIG_LUA_CONSTTAB_INT("VERTEX_SHADER", 35633)}, - {SWIG_LUA_CONSTTAB_INT("CLAMP_TO_EDGE", 33071)}, - {SWIG_LUA_CONSTTAB_INT("REPEAT", 10497)}, - {SWIG_LUA_CONSTTAB_INT("MIRRORED_REPEAT", 33648)}, - {SWIG_LUA_CONSTTAB_INT("PRIMITIVE_TRIANGLES", OF_PRIMITIVE_TRIANGLES)}, - {SWIG_LUA_CONSTTAB_INT("PRIMITIVE_TRIANGLE_STRIP", OF_PRIMITIVE_TRIANGLE_STRIP)}, - {SWIG_LUA_CONSTTAB_INT("PRIMITIVE_TRIANGLE_FAN", OF_PRIMITIVE_TRIANGLE_FAN)}, - {SWIG_LUA_CONSTTAB_INT("PRIMITIVE_LINES", OF_PRIMITIVE_LINES)}, - {SWIG_LUA_CONSTTAB_INT("PRIMITIVE_LINE_STRIP", OF_PRIMITIVE_LINE_STRIP)}, - {SWIG_LUA_CONSTTAB_INT("PRIMITIVE_LINE_LOOP", OF_PRIMITIVE_LINE_LOOP)}, - {SWIG_LUA_CONSTTAB_INT("PRIMITIVE_POINTS", OF_PRIMITIVE_POINTS)}, - {SWIG_LUA_CONSTTAB_INT("MESH_POINTS", OF_MESH_POINTS)}, - {SWIG_LUA_CONSTTAB_INT("MESH_WIREFRAME", OF_MESH_WIREFRAME)}, - {SWIG_LUA_CONSTTAB_INT("MESH_FILL", OF_MESH_FILL)}, - {SWIG_LUA_CONSTTAB_INT("LIGHT_POINT", OF_LIGHT_POINT)}, - {SWIG_LUA_CONSTTAB_INT("LIGHT_DIRECTIONAL", OF_LIGHT_DIRECTIONAL)}, - {SWIG_LUA_CONSTTAB_INT("LIGHT_SPOT", OF_LIGHT_SPOT)}, - {SWIG_LUA_CONSTTAB_INT("LIGHT_AREA", OF_LIGHT_AREA)}, - {SWIG_LUA_CONSTTAB_INT("Shader_POSITION_ATTRIBUTE", ofShader::POSITION_ATTRIBUTE)}, - {SWIG_LUA_CONSTTAB_INT("Shader_COLOR_ATTRIBUTE", ofShader::COLOR_ATTRIBUTE)}, - {SWIG_LUA_CONSTTAB_INT("Shader_NORMAL_ATTRIBUTE", ofShader::NORMAL_ATTRIBUTE)}, - {SWIG_LUA_CONSTTAB_INT("Shader_TEXCOORD_ATTRIBUTE", ofShader::TEXCOORD_ATTRIBUTE)}, - {SWIG_LUA_CONSTTAB_INT("Shader_INDEX_ATTRIBUTE", ofShader::INDEX_ATTRIBUTE)}, - {SWIG_LUA_CONSTTAB_INT("INTERPOLATE_NEAREST_NEIGHBOR", OF_INTERPOLATE_NEAREST_NEIGHBOR)}, - {SWIG_LUA_CONSTTAB_INT("INTERPOLATE_BILINEAR", OF_INTERPOLATE_BILINEAR)}, - {SWIG_LUA_CONSTTAB_INT("INTERPOLATE_BICUBIC", OF_INTERPOLATE_BICUBIC)}, - {SWIG_LUA_CONSTTAB_INT("Path_COMMANDS", ofPath::COMMANDS)}, - {SWIG_LUA_CONSTTAB_INT("Path_POLYLINES", ofPath::POLYLINES)}, - {SWIG_LUA_CONSTTAB_INT("CIRC_RESOLUTION", 22)}, - {SWIG_LUA_CONSTTAB_INT("NUM_CHARACTER_TO_START", 32)}, - {SWIG_LUA_CONSTTAB_INT("File_Reference", ofFile::Reference)}, - {SWIG_LUA_CONSTTAB_INT("File_ReadOnly", ofFile::ReadOnly)}, - {SWIG_LUA_CONSTTAB_INT("File_WriteOnly", ofFile::WriteOnly)}, - {SWIG_LUA_CONSTTAB_INT("File_ReadWrite", ofFile::ReadWrite)}, - {SWIG_LUA_CONSTTAB_INT("File_Append", ofFile::Append)}, - {SWIG_LUA_CONSTTAB_INT("LOG_VERBOSE", OF_LOG_VERBOSE)}, - {SWIG_LUA_CONSTTAB_INT("LOG_NOTICE", OF_LOG_NOTICE)}, - {SWIG_LUA_CONSTTAB_INT("LOG_WARNING", OF_LOG_WARNING)}, - {SWIG_LUA_CONSTTAB_INT("LOG_ERROR", OF_LOG_ERROR)}, - {SWIG_LUA_CONSTTAB_INT("LOG_FATAL_ERROR", OF_LOG_FATAL_ERROR)}, - {SWIG_LUA_CONSTTAB_INT("LOG_SILENT", OF_LOG_SILENT)}, - {0,0,0,0,0,0} -}; -static swig_lua_method swig_SwigModule_methods[]= { - { "Fbo_checkGLSupport", _wrap_Fbo_checkGLSupport}, - { "Fbo_maxColorAttachments", _wrap_Fbo_maxColorAttachments}, - { "Fbo_maxDrawBuffers", _wrap_Fbo_maxDrawBuffers}, - { "Fbo_maxSamples", _wrap_Fbo_maxSamples}, - { "getUsingArbTex", _wrap_getUsingArbTex}, - { "enableArbTex", _wrap_enableArbTex}, - { "disableArbTex", _wrap_disableArbTex}, - { "getUsingNormalizedTexCoords", _wrap_getUsingNormalizedTexCoords}, - { "enableNormalizedTexCoords", _wrap_enableNormalizedTexCoords}, - { "disableNormalizedTexCoords", _wrap_disableNormalizedTexCoords}, - { "enableTextureEdgeHack", _wrap_enableTextureEdgeHack}, - { "disableTextureEdgeHack", _wrap_disableTextureEdgeHack}, - { "isTextureEdgeHackEnabled", _wrap_isTextureEdgeHackEnabled}, - { "isVFlipped", _wrap_isVFlipped}, - { "drawAxis", _wrap_drawAxis}, - { "drawGrid", _wrap_drawGrid}, - { "drawGridPlane", _wrap_drawGridPlane}, - { "drawArrow", _wrap_drawArrow}, - { "drawRotationAxes", _wrap_drawRotationAxes}, - { "Mesh_plane", _wrap_Mesh_plane}, - { "Mesh_sphere", _wrap_Mesh_sphere}, - { "Mesh_icosahedron", _wrap_Mesh_icosahedron}, - { "Mesh_icosphere", _wrap_Mesh_icosphere}, - { "Mesh_cylinder", _wrap_Mesh_cylinder}, - { "Mesh_cone", _wrap_Mesh_cone}, - { "Mesh_box", _wrap_Mesh_box}, - { "Mesh_axis", _wrap_Mesh_axis}, - { "getAppPtr", _wrap_getAppPtr}, - { "exit", _wrap_exit}, - { "getFrameRate", _wrap_getFrameRate}, - { "getTargetFrameRate", _wrap_getTargetFrameRate}, - { "getFrameNum", _wrap_getFrameNum}, - { "setFrameRate", _wrap_setFrameRate}, - { "getLastFrameTime", _wrap_getLastFrameTime}, - { "setOrientation", _wrap_setOrientation}, - { "getOrientation", _wrap_getOrientation}, - { "hideCursor", _wrap_hideCursor}, - { "showCursor", _wrap_showCursor}, - { "getWindowPositionX", _wrap_getWindowPositionX}, - { "getWindowPositionY", _wrap_getWindowPositionY}, - { "getScreenWidth", _wrap_getScreenWidth}, - { "getScreenHeight", _wrap_getScreenHeight}, - { "getWindowMode", _wrap_getWindowMode}, - { "getWidth", _wrap_getWidth}, - { "getHeight", _wrap_getHeight}, - { "getWindowWidth", _wrap_getWindowWidth}, - { "getWindowHeight", _wrap_getWindowHeight}, - { "randomWidth", _wrap_randomWidth}, - { "randomHeight", _wrap_randomHeight}, - { "doesHWOrientation", _wrap_doesHWOrientation}, - { "getWindowSize", _wrap_getWindowSize}, - { "getWindowRect", _wrap_getWindowRect}, - { "setWindowPosition", _wrap_setWindowPosition}, - { "setWindowShape", _wrap_setWindowShape}, - { "setWindowTitle", _wrap_setWindowTitle}, - { "enableSetupScreen", _wrap_enableSetupScreen}, - { "disableSetupScreen", _wrap_disableSetupScreen}, - { "setFullscreen", _wrap_setFullscreen}, - { "toggleFullscreen", _wrap_toggleFullscreen}, - { "setVerticalSync", _wrap_setVerticalSync}, - { "events", _wrap_events}, - { "setEscapeQuitsApp", _wrap_setEscapeQuitsApp}, - { "random", _wrap_random}, - { "randomf", _wrap_randomf}, - { "randomuf", _wrap_randomuf}, - { "seedRandom", _wrap_seedRandom}, - { "normalize", _wrap_normalize}, - { "map", _wrap_map}, - { "clamp", _wrap_clamp}, - { "inRange", _wrap_inRange}, - { "lerp", _wrap_lerp}, - { "dist", _wrap_dist}, - { "distSquared", _wrap_distSquared}, - { "radToDeg", _wrap_radToDeg}, - { "degToRad", _wrap_degToRad}, - { "lerpDegrees", _wrap_lerpDegrees}, - { "lerpRadians", _wrap_lerpRadians}, - { "angleDifferenceDegrees", _wrap_angleDifferenceDegrees}, - { "angleDifferenceRadians", _wrap_angleDifferenceRadians}, - { "wrap", _wrap_wrap}, - { "wrapRadians", _wrap_wrapRadians}, - { "wrapDegrees", _wrap_wrapDegrees}, - { "noise", _wrap_noise}, - { "signedNoise", _wrap_signedNoise}, - { "insidePoly", _wrap_insidePoly}, - { "lineSegmentIntersection", _wrap_lineSegmentIntersection}, - { "bezierPoint", _wrap_bezierPoint}, - { "curvePoint", _wrap_curvePoint}, - { "bezierTangent", _wrap_bezierTangent}, - { "curveTangent", _wrap_curveTangent}, - { "nextPow2", _wrap_nextPow2}, - { "sign", _wrap_sign}, - { "Matrix4x4_newIdentityMatrix", _wrap_Matrix4x4_newIdentityMatrix}, - { "Matrix4x4_newScaleMatrix", _wrap_Matrix4x4_newScaleMatrix}, - { "Matrix4x4_newTranslationMatrix", _wrap_Matrix4x4_newTranslationMatrix}, - { "Matrix4x4_newRotationMatrix", _wrap_Matrix4x4_newRotationMatrix}, - { "Matrix4x4_newOrthoMatrix", _wrap_Matrix4x4_newOrthoMatrix}, - { "Matrix4x4_newOrtho2DMatrix", _wrap_Matrix4x4_newOrtho2DMatrix}, - { "Matrix4x4_newFrustumMatrix", _wrap_Matrix4x4_newFrustumMatrix}, - { "Matrix4x4_newPerspectiveMatrix", _wrap_Matrix4x4_newPerspectiveMatrix}, - { "Matrix4x4_newLookAtMatrix", _wrap_Matrix4x4_newLookAtMatrix}, - { "Matrix4x4_getInverseOf", _wrap_Matrix4x4_getInverseOf}, - { "Matrix4x4_getTransposedOf", _wrap_Matrix4x4_getTransposedOf}, - { "Matrix4x4_getOrthoNormalOf", _wrap_Matrix4x4_getOrthoNormalOf}, - { "Matrix4x4_transform3x3", _wrap_Matrix4x4_transform3x3}, - { "Vec2f_zero", _wrap_Vec2f_zero}, - { "Vec2f_one", _wrap_Vec2f_one}, - { "Vec3f_zero", _wrap_Vec3f_zero}, - { "Vec3f_one", _wrap_Vec3f_one}, - { "Vec4f_zero", _wrap_Vec4f_zero}, - { "Vec4f_one", _wrap_Vec4f_one}, - { "getMousePressed", _wrap_getMousePressed}, - { "getKeyPressed", _wrap_getKeyPressed}, - { "getMouseX", _wrap_getMouseX}, - { "getMouseY", _wrap_getMouseY}, - { "getPreviousMouseX", _wrap_getPreviousMouseX}, - { "getPreviousMouseY", _wrap_getPreviousMouseY}, - { "sendMessage", _wrap_sendMessage}, - { "getGlInternalFormat", _wrap_getGlInternalFormat}, - { "getGlInternalFormatName", _wrap_getGlInternalFormatName}, - { "getGLFormatFromInternal", _wrap_getGLFormatFromInternal}, - { "getGlTypeFromInternal", _wrap_getGlTypeFromInternal}, - { "getGlType", _wrap_getGlType}, - { "getImageTypeFromGLType", _wrap_getImageTypeFromGLType}, - { "getGLPolyMode", _wrap_getGLPolyMode}, - { "getOFPolyMode", _wrap_getOFPolyMode}, - { "getGLPrimitiveMode", _wrap_getGLPrimitiveMode}, - { "getOFPrimitiveMode", _wrap_getOFPrimitiveMode}, - { "getGLInternalFormatFromPixelFormat", _wrap_getGLInternalFormatFromPixelFormat}, - { "getGLFormatFromPixelFormat", _wrap_getGLFormatFromPixelFormat}, - { "getBytesPerChannelFromGLType", _wrap_getBytesPerChannelFromGLType}, - { "getNumChannelsFromGLFormat", _wrap_getNumChannelsFromGLFormat}, - { "setPixelStoreiAlignment", _wrap_setPixelStoreiAlignment}, - { "GLSupportedExtensions", _wrap_GLSupportedExtensions}, - { "GLCheckExtension", _wrap_GLCheckExtension}, - { "GLSupportsNPOTTextures", _wrap_GLSupportsNPOTTextures}, - { "isGLProgrammableRenderer", _wrap_isGLProgrammableRenderer}, - { "GLSLVersionFromGL", _wrap_GLSLVersionFromGL}, - { "enableLighting", _wrap_enableLighting}, - { "disableLighting", _wrap_disableLighting}, - { "enableSeparateSpecularLight", _wrap_enableSeparateSpecularLight}, - { "disableSeparateSpecularLight", _wrap_disableSeparateSpecularLight}, - { "getLightingEnabled", _wrap_getLightingEnabled}, - { "setSmoothLighting", _wrap_setSmoothLighting}, - { "setGlobalAmbientColor", _wrap_setGlobalAmbientColor}, - { "getGlobalAmbientColor", _wrap_getGlobalAmbientColor}, - { "lightsData", _wrap_lightsData}, - { "Polyline_fromRectangle", _wrap_Polyline_fromRectangle}, - { "drawBitmapString", _wrap_drawBitmapString}, - { "setColor", _wrap_setColor}, - { "setHexColor", _wrap_setHexColor}, - { "noFill", _wrap_noFill}, - { "fill", _wrap_fill}, - { "getFill", _wrap_getFill}, - { "getBackgroundColor", _wrap_getBackgroundColor}, - { "background", _wrap_background}, - { "backgroundHex", _wrap_backgroundHex}, - { "backgroundGradient", _wrap_backgroundGradient}, - { "setBackgroundColor", _wrap_setBackgroundColor}, - { "setBackgroundColorHex", _wrap_setBackgroundColorHex}, - { "setBackgroundAuto", _wrap_setBackgroundAuto}, - { "getBackgroundAuto", _wrap_getBackgroundAuto}, - { "clear", _wrap_clear}, - { "clearAlpha", _wrap_clearAlpha}, - { "drawTriangle", _wrap_drawTriangle}, - { "drawCircle", _wrap_drawCircle}, - { "drawEllipse", _wrap_drawEllipse}, - { "drawLine", _wrap_drawLine}, - { "drawRectangle", _wrap_drawRectangle}, - { "drawRectRounded", _wrap_drawRectRounded}, - { "drawCurve", _wrap_drawCurve}, - { "drawBezier", _wrap_drawBezier}, - { "beginShape", _wrap_beginShape}, - { "vertex", _wrap_vertex}, - { "vertices", _wrap_vertices}, - { "curveVertex", _wrap_curveVertex}, - { "curveVertices", _wrap_curveVertices}, - { "bezierVertex", _wrap_bezierVertex}, - { "endShape", _wrap_endShape}, - { "nextContour", _wrap_nextContour}, - { "setDrawBitmapMode", _wrap_setDrawBitmapMode}, - { "drawBitmapStringHighlight", _wrap_drawBitmapStringHighlight}, - { "setupGraphicDefaults", _wrap_setupGraphicDefaults}, - { "setupScreen", _wrap_setupScreen}, - { "getRectMode", _wrap_getRectMode}, - { "setCircleResolution", _wrap_setCircleResolution}, - { "setCurveResolution", _wrap_setCurveResolution}, - { "setLineWidth", _wrap_setLineWidth}, - { "setDepthTest", _wrap_setDepthTest}, - { "enableDepthTest", _wrap_enableDepthTest}, - { "disableDepthTest", _wrap_disableDepthTest}, - { "enableBlendMode", _wrap_enableBlendMode}, - { "disableBlendMode", _wrap_disableBlendMode}, - { "enablePointSprites", _wrap_enablePointSprites}, - { "disablePointSprites", _wrap_disablePointSprites}, - { "enableAlphaBlending", _wrap_enableAlphaBlending}, - { "disableAlphaBlending", _wrap_disableAlphaBlending}, - { "enableSmoothing", _wrap_enableSmoothing}, - { "disableSmoothing", _wrap_disableSmoothing}, - { "enableAntiAliasing", _wrap_enableAntiAliasing}, - { "disableAntiAliasing", _wrap_disableAntiAliasing}, - { "getStyle", _wrap_getStyle}, - { "setStyle", _wrap_setStyle}, - { "pushStyle", _wrap_pushStyle}, - { "popStyle", _wrap_popStyle}, - { "setPolyMode", _wrap_setPolyMode}, - { "setRectMode", _wrap_setRectMode}, - { "pushMatrix", _wrap_pushMatrix}, - { "popMatrix", _wrap_popMatrix}, - { "getCurrentMatrix", _wrap_getCurrentMatrix}, - { "getCurrentOrientationMatrix", _wrap_getCurrentOrientationMatrix}, - { "getCurrentNormalMatrix", _wrap_getCurrentNormalMatrix}, - { "translate", _wrap_translate}, - { "scale", _wrap_scale}, - { "rotate", _wrap_rotate}, - { "rotateX", _wrap_rotateX}, - { "rotateY", _wrap_rotateY}, - { "rotateZ", _wrap_rotateZ}, - { "loadIdentityMatrix", _wrap_loadIdentityMatrix}, - { "loadMatrix", _wrap_loadMatrix}, - { "multMatrix", _wrap_multMatrix}, - { "setMatrixMode", _wrap_setMatrixMode}, - { "loadViewMatrix", _wrap_loadViewMatrix}, - { "multViewMatrix", _wrap_multViewMatrix}, - { "getCurrentViewMatrix", _wrap_getCurrentViewMatrix}, - { "pushView", _wrap_pushView}, - { "popView", _wrap_popView}, - { "viewport", _wrap_viewport}, - { "getCurrentViewport", _wrap_getCurrentViewport}, - { "getNativeViewport", _wrap_getNativeViewport}, - { "getViewportWidth", _wrap_getViewportWidth}, - { "getViewportHeight", _wrap_getViewportHeight}, - { "setupScreenPerspective", _wrap_setupScreenPerspective}, - { "setupScreenOrtho", _wrap_setupScreenOrtho}, - { "orientationToDegrees", _wrap_orientationToDegrees}, - { "setCoordHandedness", _wrap_setCoordHandedness}, - { "getCoordHandedness", _wrap_getCoordHandedness}, - { "beginSaveScreenAsPDF", _wrap_beginSaveScreenAsPDF}, - { "endSaveScreenAsPDF", _wrap_endSaveScreenAsPDF}, - { "beginSaveScreenAsSVG", _wrap_beginSaveScreenAsSVG}, - { "endSaveScreenAsSVG", _wrap_endSaveScreenAsSVG}, - { "setPlaneResolution", _wrap_setPlaneResolution}, - { "getPlaneResolution", _wrap_getPlaneResolution}, - { "drawPlane", _wrap_drawPlane}, - { "setSphereResolution", _wrap_setSphereResolution}, - { "getSphereResolution", _wrap_getSphereResolution}, - { "drawSphere", _wrap_drawSphere}, - { "setIcoSphereResolution", _wrap_setIcoSphereResolution}, - { "getIcoSphereResolution", _wrap_getIcoSphereResolution}, - { "drawIcoSphere", _wrap_drawIcoSphere}, - { "setCylinderResolution", _wrap_setCylinderResolution}, - { "getCylinderResolution", _wrap_getCylinderResolution}, - { "drawCylinder", _wrap_drawCylinder}, - { "setConeResolution", _wrap_setConeResolution}, - { "getConeResolution", _wrap_getConeResolution}, - { "drawCone", _wrap_drawCone}, - { "setBoxResolution", _wrap_setBoxResolution}, - { "getBoxResolution", _wrap_getBoxResolution}, - { "drawBox", _wrap_drawBox}, - { "TrueTypeFont_setGlobalDpi", _wrap_TrueTypeFont_setGlobalDpi}, - { "soundStreamSetup", _wrap_soundStreamSetup}, - { "soundStreamStop", _wrap_soundStreamStop}, - { "soundStreamStart", _wrap_soundStreamStart}, - { "soundStreamClose", _wrap_soundStreamClose}, - { "soundStreamListDevices", _wrap_soundStreamListDevices}, - { "Color_fromHsb", _wrap_Color_fromHsb}, - { "Color_fromHex", _wrap_Color_fromHex}, - { "Color_limit", _wrap_Color_limit}, - { "FloatColor_fromHsb", _wrap_FloatColor_fromHsb}, - { "FloatColor_fromHex", _wrap_FloatColor_fromHex}, - { "FloatColor_limit", _wrap_FloatColor_limit}, - { "ShortColor_fromHsb", _wrap_ShortColor_fromHsb}, - { "ShortColor_fromHex", _wrap_ShortColor_fromHex}, - { "ShortColor_limit", _wrap_ShortColor_limit}, - { "Xml_tokenize", _wrap_Xml_tokenize}, - { "bufferFromFile", _wrap_bufferFromFile}, - { "bufferToFile", _wrap_bufferToFile}, - { "FilePath_getFileExt", _wrap_FilePath_getFileExt}, - { "FilePath_removeExt", _wrap_FilePath_removeExt}, - { "FilePath_addLeadingSlash", _wrap_FilePath_addLeadingSlash}, - { "FilePath_addTrailingSlash", _wrap_FilePath_addTrailingSlash}, - { "FilePath_removeTrailingSlash", _wrap_FilePath_removeTrailingSlash}, - { "FilePath_getPathForDirectory", _wrap_FilePath_getPathForDirectory}, - { "FilePath_getAbsolutePath", _wrap_FilePath_getAbsolutePath}, - { "FilePath_isAbsolute", _wrap_FilePath_isAbsolute}, - { "FilePath_getFileName", _wrap_FilePath_getFileName}, - { "FilePath_getBaseName", _wrap_FilePath_getBaseName}, - { "FilePath_getEnclosingDirectory", _wrap_FilePath_getEnclosingDirectory}, - { "FilePath_createEnclosingDirectory", _wrap_FilePath_createEnclosingDirectory}, - { "FilePath_getCurrentWorkingDirectory", _wrap_FilePath_getCurrentWorkingDirectory}, - { "FilePath_join", _wrap_FilePath_join}, - { "FilePath_getCurrentExePath", _wrap_FilePath_getCurrentExePath}, - { "FilePath_getCurrentExeDir", _wrap_FilePath_getCurrentExeDir}, - { "FilePath_getUserHomeDir", _wrap_FilePath_getUserHomeDir}, - { "FilePath_makeRelative", _wrap_FilePath_makeRelative}, - { "File_copyFromTo", _wrap_File_copyFromTo}, - { "File_moveFromTo", _wrap_File_moveFromTo}, - { "File_doesFileExist", _wrap_File_doesFileExist}, - { "File_removeFile", _wrap_File_removeFile}, - { "Directory_createDirectory", _wrap_Directory_createDirectory}, - { "Directory_isDirectoryEmpty", _wrap_Directory_isDirectoryEmpty}, - { "Directory_doesDirectoryExist", _wrap_Directory_doesDirectoryExist}, - { "Directory_removeDirectory", _wrap_Directory_removeDirectory}, - { "log", _wrap_log}, - { "setLogLevel", _wrap_setLogLevel}, - { "getLogLevel", _wrap_getLogLevel}, - { "getLogLevelName", _wrap_getLogLevelName}, - { "logToFile", _wrap_logToFile}, - { "logToConsole", _wrap_logToConsole}, - { "systemAlertDialog", _wrap_systemAlertDialog}, - { "systemLoadDialog", _wrap_systemLoadDialog}, - { "systemSaveDialog", _wrap_systemSaveDialog}, - { "systemTextBoxDialog", _wrap_systemTextBoxDialog}, - { "loadURL", _wrap_loadURL}, - { "loadURLAsync", _wrap_loadURLAsync}, - { "saveURLTo", _wrap_saveURLTo}, - { "saveURLAsync", _wrap_saveURLAsync}, - { "removeURLRequest", _wrap_removeURLRequest}, - { "removeAllURLRequests", _wrap_removeAllURLRequests}, - { "stopURLLoader", _wrap_stopURLLoader}, - { "uRLResponseEvent", _wrap_uRLResponseEvent}, - { "resetElapsedTimeCounter", _wrap_resetElapsedTimeCounter}, - { "getElapsedTimef", _wrap_getElapsedTimef}, - { "getElapsedTimeMillis", _wrap_getElapsedTimeMillis}, - { "getElapsedTimeMicros", _wrap_getElapsedTimeMicros}, - { "getSeconds", _wrap_getSeconds}, - { "getMinutes", _wrap_getMinutes}, - { "getHours", _wrap_getHours}, - { "getUnixTime", _wrap_getUnixTime}, - { "getSystemTime", _wrap_getSystemTime}, - { "getSystemTimeMicros", _wrap_getSystemTimeMicros}, - { "sleepMillis", _wrap_sleepMillis}, - { "getTimestampString", _wrap_getTimestampString}, - { "getYear", _wrap_getYear}, - { "getMonth", _wrap_getMonth}, - { "getDay", _wrap_getDay}, - { "getWeekday", _wrap_getWeekday}, - { "enableDataPath", _wrap_enableDataPath}, - { "disableDataPath", _wrap_disableDataPath}, - { "toDataPath", _wrap_toDataPath}, - { "restoreWorkingDirectoryToDefault", _wrap_restoreWorkingDirectoryToDefault}, - { "setDataPathRoot", _wrap_setDataPathRoot}, - { "splitString", _wrap_splitString}, - { "joinString", _wrap_joinString}, - { "stringReplace", _wrap_stringReplace}, - { "isStringInString", _wrap_isStringInString}, - { "stringTimesInString", _wrap_stringTimesInString}, - { "toLower", _wrap_toLower}, - { "toUpper", _wrap_toUpper}, - { "trimFront", _wrap_trimFront}, - { "trimBack", _wrap_trimBack}, - { "trim", _wrap_trim}, - { "appendUTF8", _wrap_appendUTF8}, - { "toInt", _wrap_toInt}, - { "toInt64", _wrap_toInt64}, - { "toFloat", _wrap_toFloat}, - { "toDouble", _wrap_toDouble}, - { "toBool", _wrap_toBool}, - { "toHex", _wrap_toHex}, - { "hexToInt", _wrap_hexToInt}, - { "hexToChar", _wrap_hexToChar}, - { "hexToFloat", _wrap_hexToFloat}, - { "hexToString", _wrap_hexToString}, - { "toChar", _wrap_toChar}, - { "toBinary", _wrap_toBinary}, - { "binaryToInt", _wrap_binaryToInt}, - { "binaryToChar", _wrap_binaryToChar}, - { "binaryToFloat", _wrap_binaryToFloat}, - { "binaryToString", _wrap_binaryToString}, - { "getVersionInfo", _wrap_getVersionInfo}, - { "getVersionMajor", _wrap_getVersionMajor}, - { "getVersionMinor", _wrap_getVersionMinor}, - { "getVersionPatch", _wrap_getVersionPatch}, - { "getVersionPreRelease", _wrap_getVersionPreRelease}, - { "saveScreen", _wrap_saveScreen}, - { "saveFrame", _wrap_saveFrame}, - { "saveViewport", _wrap_saveViewport}, - { "launchBrowser", _wrap_launchBrowser}, - { "system", _wrap_system}, - { "getTargetPlatform", _wrap_getTargetPlatform}, - { "getEnv", _wrap_getEnv}, - {0,0} -}; -static swig_lua_class* swig_SwigModule_classes[]= { -&_wrap_class_string, -&_wrap_class_path, -&_wrap_class_IntVector, -&_wrap_class_FloatVector, -&_wrap_class_StringVector, -&_wrap_class_UCharVector, -&_wrap_class_VideoDeviceVector, -&_wrap_class_TextureVector, -&_wrap_class_Fbo, -&_wrap_class_TextureData, -&_wrap_class_Texture, -&_wrap_class_Image, -&_wrap_class_FloatImage, -&_wrap_class_ShortImage, -&_wrap_class_Node, -&_wrap_class_Camera, -&_wrap_class_EasyCam, -&_wrap_class_Mesh, -&_wrap_class_MeshFace, -&_wrap_class_3dPrimitive, -&_wrap_class_PlanePrimitive, -&_wrap_class_SpherePrimitive, -&_wrap_class_IcoSpherePrimitive, -&_wrap_class_CylinderPrimitive, -&_wrap_class_ConePrimitive, -&_wrap_class_BoxPrimitive, -&_wrap_class_Arduino, -&_wrap_class_Serial, -&_wrap_class_Matrix3x3, -&_wrap_class_Matrix4x4, -&_wrap_class_Quaternion, -&_wrap_class_Vec2f, -&_wrap_class_Vec3f, -&_wrap_class_Vec4f, -&_wrap_class_DragInfo, -&_wrap_class_TouchEventArgs, -&_wrap_class_BufferObject, -&_wrap_class_Light, -&_wrap_class_Material, -&_wrap_class_Shader, -&_wrap_class_Vbo, -&_wrap_class_VboMesh, -&_wrap_class_Pixels, -&_wrap_class_FloatPixels, -&_wrap_class_ShortPixels, -&_wrap_class_Path, -&_wrap_class_Polyline, -&_wrap_class_TrueTypeFont, -&_wrap_class_SoundStream, -&_wrap_class_SoundPlayer, -&_wrap_class_Color, -&_wrap_class_FloatColor, -&_wrap_class_ShortColor, -&_wrap_class_Rectangle, -&_wrap_class_SerialDeviceInfo, -&_wrap_class_Style, -&_wrap_class_FpsCounter, -&_wrap_class_Xml, -&_wrap_class_MatrixStack, -&_wrap_class_Buffer, -&_wrap_class_FilePath, -&_wrap_class_File, -&_wrap_class_Directory, -&_wrap_class_FileDialogResult, -&_wrap_class_HttpRequest, -&_wrap_class_HttpResponse, -&_wrap_class_URLFileLoader, -&_wrap_class_VideoGrabber, -&_wrap_class_VideoPlayer, - 0 -}; -static swig_lua_namespace* swig_SwigModule_namespaces[] = { - 0 -}; - -static swig_lua_namespace swig_SwigModule = { - "of", - swig_SwigModule_methods, - swig_SwigModule_attributes, - swig_SwigModule_constants, - swig_SwigModule_classes, - swig_SwigModule_namespaces -}; -#ifdef __cplusplus -} -#endif - -/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */ - -static void *_p_ofImage_T_unsigned_char_tTo_p_ofBaseImage_T_unsigned_char_t(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseImage_< unsigned char > *) ((ofImage_< unsigned char > *) x)); -} -static void *_p_ofImage_T_float_tTo_p_ofBaseImage_T_float_t(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseImage_< float > *) ((ofImage_< float > *) x)); -} -static void *_p_ofMaterialTo_p_ofBaseMaterial(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseMaterial *) ((ofMaterial *) x)); -} -static void *_p_ofSoundPlayerTo_p_ofBaseSoundPlayer(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseSoundPlayer *) ((ofSoundPlayer *) x)); -} -static void *_p_ofEasyCamTo_p_ofCamera(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofCamera *) ((ofEasyCam *) x)); -} -static void *_p_ofBaseVideoDrawsTo_p_ofBaseHasTexturePlanes(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseHasTexturePlanes *) ((ofBaseVideoDraws *) x)); -} -static void *_p_ofVideoGrabberTo_p_ofBaseHasTexturePlanes(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseHasTexturePlanes *) (ofBaseVideoDraws *) ((ofVideoGrabber *) x)); -} -static void *_p_ofVideoPlayerTo_p_ofBaseHasTexturePlanes(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseHasTexturePlanes *) (ofBaseVideoDraws *) ((ofVideoPlayer *) x)); -} -static void *_p_ofMouseEventArgsTo_p_ofVec2f(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofVec2f *) ((ofMouseEventArgs *) x)); -} -static void *_p_ofTouchEventArgsTo_p_ofVec2f(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofVec2f *) ((ofTouchEventArgs *) x)); -} -static void *_p_ofPlanePrimitiveTo_p_of3dPrimitive(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((of3dPrimitive *) ((ofPlanePrimitive *) x)); -} -static void *_p_ofSpherePrimitiveTo_p_of3dPrimitive(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((of3dPrimitive *) ((ofSpherePrimitive *) x)); -} -static void *_p_ofIcoSpherePrimitiveTo_p_of3dPrimitive(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((of3dPrimitive *) ((ofIcoSpherePrimitive *) x)); -} -static void *_p_ofCylinderPrimitiveTo_p_of3dPrimitive(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((of3dPrimitive *) ((ofCylinderPrimitive *) x)); -} -static void *_p_ofConePrimitiveTo_p_of3dPrimitive(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((of3dPrimitive *) ((ofConePrimitive *) x)); -} -static void *_p_ofBoxPrimitiveTo_p_of3dPrimitive(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((of3dPrimitive *) ((ofBoxPrimitive *) x)); -} -static void *_p_ofVideoPlayerTo_p_ofBaseVideoPlayer(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseVideoPlayer *) ((ofVideoPlayer *) x)); -} -static void *_p_of3dPrimitiveTo_p_ofNode(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofNode *) ((of3dPrimitive *) x)); -} -static void *_p_ofPlanePrimitiveTo_p_ofNode(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofNode *) (of3dPrimitive *) ((ofPlanePrimitive *) x)); -} -static void *_p_ofSpherePrimitiveTo_p_ofNode(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofNode *) (of3dPrimitive *) ((ofSpherePrimitive *) x)); -} -static void *_p_ofIcoSpherePrimitiveTo_p_ofNode(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofNode *) (of3dPrimitive *) ((ofIcoSpherePrimitive *) x)); -} -static void *_p_ofCylinderPrimitiveTo_p_ofNode(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofNode *) (of3dPrimitive *) ((ofCylinderPrimitive *) x)); -} -static void *_p_ofConePrimitiveTo_p_ofNode(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofNode *) (of3dPrimitive *) ((ofConePrimitive *) x)); -} -static void *_p_ofBoxPrimitiveTo_p_ofNode(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofNode *) (of3dPrimitive *) ((ofBoxPrimitive *) x)); -} -static void *_p_ofEasyCamTo_p_ofNode(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofNode *) (ofCamera *) ((ofEasyCam *) x)); -} -static void *_p_ofLightTo_p_ofNode(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofNode *) ((ofLight *) x)); -} -static void *_p_ofCameraTo_p_ofNode(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofNode *) ((ofCamera *) x)); -} -static void *_p_ofConsoleLoggerChannelTo_p_ofBaseLoggerChannel(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseLoggerChannel *) ((ofConsoleLoggerChannel *) x)); -} -static void *_p_ofFileLoggerChannelTo_p_ofBaseLoggerChannel(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseLoggerChannel *) ((ofFileLoggerChannel *) x)); -} -static void *_p_ofBaseVideoDrawsTo_p_ofBaseVideo(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseVideo *) ((ofBaseVideoDraws *) x)); -} -static void *_p_ofBaseVideoGrabberTo_p_ofBaseVideo(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseVideo *) ((ofBaseVideoGrabber *) x)); -} -static void *_p_ofVideoGrabberTo_p_ofBaseVideo(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseVideo *) (ofBaseVideoGrabber *) ((ofVideoGrabber *) x)); -} -static void *_p_ofBaseVideoPlayerTo_p_ofBaseVideo(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseVideo *) ((ofBaseVideoPlayer *) x)); -} -static void *_p_ofVideoPlayerTo_p_ofBaseVideo(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseVideo *) (ofBaseVideoPlayer *) ((ofVideoPlayer *) x)); -} -static void *_p_ofVboMeshTo_p_ofMesh(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofMesh *) ((ofVboMesh *) x)); -} -static void *_p_ofFileTo_p_fstream(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((fstream *) ((ofFile *) x)); -} -static void *_p_ofAbstractImageTo_p_ofBaseHasTexture(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseHasTexture *) ((ofAbstractImage *) x)); -} -static void *_p_ofBaseVideoDrawsTo_p_ofBaseHasTexture(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseHasTexture *) (ofBaseHasTexturePlanes *) ((ofBaseVideoDraws *) x)); -} -static void *_p_ofVideoGrabberTo_p_ofBaseHasTexture(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseHasTexture *) (ofBaseHasTexturePlanes *)(ofBaseVideoDraws *) ((ofVideoGrabber *) x)); -} -static void *_p_ofFboTo_p_ofBaseHasTexture(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseHasTexture *) ((ofFbo *) x)); -} -static void *_p_ofBaseHasTexturePlanesTo_p_ofBaseHasTexture(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseHasTexture *) ((ofBaseHasTexturePlanes *) x)); -} -static void *_p_ofVideoPlayerTo_p_ofBaseHasTexture(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseHasTexture *) (ofBaseHasTexturePlanes *)(ofBaseVideoDraws *) ((ofVideoPlayer *) x)); -} -static void *_p_ofXmlTo_p_ofBaseFileSerializer(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseFileSerializer *) ((ofXml *) x)); -} -static void *_p_ofBaseFileSerializerTo_p_ofBaseSerializer(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseSerializer *) ((ofBaseFileSerializer *) x)); -} -static void *_p_ofXmlTo_p_ofBaseSerializer(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseSerializer *) (ofBaseFileSerializer *) ((ofXml *) x)); -} -static void *_p_ofBaseGLRendererTo_p_ofBaseRenderer(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseRenderer *) ((ofBaseGLRenderer *) x)); -} -static void *_p_ofKeyEventArgsTo_p_ofEventArgs(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofEventArgs *) ((ofKeyEventArgs *) x)); -} -static void *_p_ofMouseEventArgsTo_p_ofEventArgs(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofEventArgs *) ((ofMouseEventArgs *) x)); -} -static void *_p_ofTouchEventArgsTo_p_ofEventArgs(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofEventArgs *) ((ofTouchEventArgs *) x)); -} -static void *_p_ofResizeEventArgsTo_p_ofEventArgs(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofEventArgs *) ((ofResizeEventArgs *) x)); -} -static void *_p_ofMessageTo_p_ofEventArgs(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofEventArgs *) ((ofMessage *) x)); -} -static void *_p_ofAbstractImageTo_p_ofBaseDraws(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseDraws *) ((ofAbstractImage *) x)); -} -static void *_p_ofBaseVideoDrawsTo_p_ofBaseDraws(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseDraws *) ((ofBaseVideoDraws *) x)); -} -static void *_p_ofVideoGrabberTo_p_ofBaseDraws(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseDraws *) (ofBaseVideoDraws *) ((ofVideoGrabber *) x)); -} -static void *_p_ofTextureTo_p_ofBaseDraws(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseDraws *) ((ofTexture *) x)); -} -static void *_p_ofFboTo_p_ofBaseDraws(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseDraws *) ((ofFbo *) x)); -} -static void *_p_ofVideoPlayerTo_p_ofBaseDraws(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseDraws *) (ofBaseVideoDraws *) ((ofVideoPlayer *) x)); -} -static void *_p_ofVideoGrabberTo_p_ofBaseVideoGrabber(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseVideoGrabber *) ((ofVideoGrabber *) x)); -} -static void *_p_ofVideoGrabberTo_p_ofBaseVideoDraws(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseVideoDraws *) ((ofVideoGrabber *) x)); -} -static void *_p_ofVideoPlayerTo_p_ofBaseVideoDraws(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseVideoDraws *) ((ofVideoPlayer *) x)); -} -static void *_p_ofLogErrorTo_p_ofLog(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofLog *) ((ofLogError *) x)); -} -static void *_p_ofLogNoticeTo_p_ofLog(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofLog *) ((ofLogNotice *) x)); -} -static void *_p_ofLogFatalErrorTo_p_ofLog(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofLog *) ((ofLogFatalError *) x)); -} -static void *_p_ofLogVerboseTo_p_ofLog(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofLog *) ((ofLogVerbose *) x)); -} -static void *_p_ofLogWarningTo_p_ofLog(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofLog *) ((ofLogWarning *) x)); -} -static void *_p_ofBaseVideoDrawsTo_p_ofBaseHasPixels(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseHasPixels *) (ofBaseVideo *) ((ofBaseVideoDraws *) x)); -} -static void *_p_ofBaseVideoGrabberTo_p_ofBaseHasPixels(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseHasPixels *) (ofBaseVideo *) ((ofBaseVideoGrabber *) x)); -} -static void *_p_ofVideoGrabberTo_p_ofBaseHasPixels(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseHasPixels *) (ofBaseVideo *)(ofBaseVideoGrabber *) ((ofVideoGrabber *) x)); -} -static void *_p_ofBaseVideoTo_p_ofBaseHasPixels(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseHasPixels *) ((ofBaseVideo *) x)); -} -static void *_p_ofBaseVideoPlayerTo_p_ofBaseHasPixels(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseHasPixels *) (ofBaseVideo *) ((ofBaseVideoPlayer *) x)); -} -static void *_p_ofVideoPlayerTo_p_ofBaseHasPixels(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseHasPixels *) (ofBaseVideo *)(ofBaseVideoPlayer *) ((ofVideoPlayer *) x)); -} -static void *_p_ofImage_T_unsigned_short_tTo_p_ofBaseImage_T_unsigned_short_t(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseImage_< unsigned short > *) ((ofImage_< unsigned short > *) x)); -} -static void *_p_ofBaseVideoDrawsTo_p_ofBaseUpdates(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseUpdates *) (ofBaseVideo *) ((ofBaseVideoDraws *) x)); -} -static void *_p_ofBaseVideoGrabberTo_p_ofBaseUpdates(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseUpdates *) (ofBaseVideo *) ((ofBaseVideoGrabber *) x)); -} -static void *_p_ofVideoGrabberTo_p_ofBaseUpdates(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseUpdates *) (ofBaseVideo *)(ofBaseVideoGrabber *) ((ofVideoGrabber *) x)); -} -static void *_p_ofBaseVideoTo_p_ofBaseUpdates(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseUpdates *) ((ofBaseVideo *) x)); -} -static void *_p_ofBaseVideoPlayerTo_p_ofBaseUpdates(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseUpdates *) (ofBaseVideo *) ((ofBaseVideoPlayer *) x)); -} -static void *_p_ofVideoPlayerTo_p_ofBaseUpdates(void *x, int *SWIGUNUSEDPARM(newmemory)) { - return (void *)((ofBaseUpdates *) (ofBaseVideo *)(ofBaseVideoPlayer *) ((ofVideoPlayer *) x)); -} -static swig_type_info _swigt__p_GLintptr = {"_p_GLintptr", "GLintptr *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_GLsizei = {"_p_GLsizei", "GLsizei *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_GLsizeiptr = {"_p_GLsizeiptr", "GLsizeiptr *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_double = {"_p_double", "double *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_float = {"_p_float", "float *|GLfloat *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_fstream = {"_p_fstream", "fstream *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_int = {"_p_int", "int *|GLint *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_long_long = {"_p_long_long", "int64_t *|long long *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_of3dPrimitive = {"_p_of3dPrimitive", "of3dPrimitive *", 0, 0, (void*)&_wrap_class_3dPrimitive, 0}; -static swig_type_info _swigt__p_ofAbstractParameter = {"_p_ofAbstractParameter", "ofAbstractParameter *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofAppBaseWindow = {"_p_ofAppBaseWindow", "ofAppBaseWindow *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofArduino = {"_p_ofArduino", "ofArduino *|ofStandardFirmata *", 0, 0, (void*)&_wrap_class_Arduino, 0}; -static swig_type_info _swigt__p_ofBaseApp = {"_p_ofBaseApp", "ofSimpleApp *|ofBaseApp *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofBaseDraws = {"_p_ofBaseDraws", "ofBaseDraws *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofAbstractImage = {"_p_ofAbstractImage", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_ofBaseFileSerializer = {"_p_ofBaseFileSerializer", "ofBaseFileSerializer *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofBaseHasPixels = {"_p_ofBaseHasPixels", "ofBaseHasPixels *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofBaseHasTexture = {"_p_ofBaseHasTexture", "ofBaseHasTexture *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofBaseHasTexturePlanes = {"_p_ofBaseHasTexturePlanes", "ofBaseHasTexturePlanes *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofBaseImage_T_float_t = {"_p_ofBaseImage_T_float_t", "ofBaseImage_< float > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofBaseImage_T_unsigned_char_t = {"_p_ofBaseImage_T_unsigned_char_t", "ofBaseImage_< unsigned char > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofBaseImage_T_unsigned_short_t = {"_p_ofBaseImage_T_unsigned_short_t", "ofBaseImage_< unsigned short > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofBaseLoggerChannel = {"_p_ofBaseLoggerChannel", "ofBaseLoggerChannel *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofConsoleLoggerChannel = {"_p_ofConsoleLoggerChannel", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_ofFileLoggerChannel = {"_p_ofFileLoggerChannel", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_ofBaseMaterial = {"_p_ofBaseMaterial", "ofBaseMaterial *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofBaseRenderer = {"_p_ofBaseRenderer", "ofBaseRenderer *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofBaseGLRenderer = {"_p_ofBaseGLRenderer", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_ofBaseSerializer = {"_p_ofBaseSerializer", "ofBaseSerializer *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofBaseSoundInput = {"_p_ofBaseSoundInput", "ofBaseSoundInput *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofBaseSoundOutput = {"_p_ofBaseSoundOutput", "ofBaseSoundOutput *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofBaseSoundPlayer = {"_p_ofBaseSoundPlayer", "ofBaseSoundPlayer *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofBaseUpdates = {"_p_ofBaseUpdates", "ofBaseUpdates *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofBaseVideo = {"_p_ofBaseVideo", "ofBaseVideo *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofBaseVideoDraws = {"_p_ofBaseVideoDraws", "ofBaseVideoDraws *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofBaseVideoGrabber = {"_p_ofBaseVideoGrabber", "ofBaseVideoGrabber *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofBaseVideoPlayer = {"_p_ofBaseVideoPlayer", "ofBaseVideoPlayer *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofBoxPrimitive = {"_p_ofBoxPrimitive", "ofBoxPrimitive *", 0, 0, (void*)&_wrap_class_BoxPrimitive, 0}; -static swig_type_info _swigt__p_ofBuffer = {"_p_ofBuffer", "ofBuffer *", 0, 0, (void*)&_wrap_class_Buffer, 0}; -static swig_type_info _swigt__p_ofBufferObject = {"_p_ofBufferObject", "ofBufferObject *", 0, 0, (void*)&_wrap_class_BufferObject, 0}; -static swig_type_info _swigt__p_ofCamera = {"_p_ofCamera", "ofCamera *", 0, 0, (void*)&_wrap_class_Camera, 0}; -static swig_type_info _swigt__p_ofColor_T_float_t = {"_p_ofColor_T_float_t", "ofColor_< float > *|ofFloatColor *", 0, 0, (void*)&_wrap_class_FloatColor, 0}; -static swig_type_info _swigt__p_ofColor_T_unsigned_char_t = {"_p_ofColor_T_unsigned_char_t", "ofColor_< unsigned char > *|ofColor *", 0, 0, (void*)&_wrap_class_Color, 0}; -static swig_type_info _swigt__p_ofColor_T_unsigned_short_t = {"_p_ofColor_T_unsigned_short_t", "ofColor_< unsigned short > *|ofShortColor *", 0, 0, (void*)&_wrap_class_ShortColor, 0}; -static swig_type_info _swigt__p_ofConePrimitive = {"_p_ofConePrimitive", "ofConePrimitive *", 0, 0, (void*)&_wrap_class_ConePrimitive, 0}; -static swig_type_info _swigt__p_ofCoreEvents = {"_p_ofCoreEvents", "ofCoreEvents *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofCylinderPrimitive = {"_p_ofCylinderPrimitive", "ofCylinderPrimitive *", 0, 0, (void*)&_wrap_class_CylinderPrimitive, 0}; -static swig_type_info _swigt__p_ofDirectory = {"_p_ofDirectory", "ofDirectory *", 0, 0, (void*)&_wrap_class_Directory, 0}; -static swig_type_info _swigt__p_ofDragInfo = {"_p_ofDragInfo", "ofDragInfo *", 0, 0, (void*)&_wrap_class_DragInfo, 0}; -static swig_type_info _swigt__p_ofEasyCam = {"_p_ofEasyCam", "ofEasyCam *", 0, 0, (void*)&_wrap_class_EasyCam, 0}; -static swig_type_info _swigt__p_ofEventArgs = {"_p_ofEventArgs", "ofEventArgs *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofKeyEventArgs = {"_p_ofKeyEventArgs", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_ofMouseEventArgs = {"_p_ofMouseEventArgs", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_ofResizeEventArgs = {"_p_ofResizeEventArgs", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_ofMessage = {"_p_ofMessage", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_ofEventT_int_const_t = {"_p_ofEventT_int_const_t", "ofEvent< int const > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofEventT_ofHttpResponse_t = {"_p_ofEventT_ofHttpResponse_t", "ofEvent< ofHttpResponse > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofEventT_std__string_const_t = {"_p_ofEventT_std__string_const_t", "ofEvent< std::string const > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofEventT_std__vectorT_unsigned_char_t_const_t = {"_p_ofEventT_std__vectorT_unsigned_char_t_const_t", "ofEvent< std::vector< unsigned char > const > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofFbo = {"_p_ofFbo", "ofFbo *", 0, 0, (void*)&_wrap_class_Fbo, 0}; -static swig_type_info _swigt__p_ofFbo__Settings = {"_p_ofFbo__Settings", "ofFbo::Settings *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofFile = {"_p_ofFile", "ofFile *", 0, 0, (void*)&_wrap_class_File, 0}; -static swig_type_info _swigt__p_ofFileDialogResult = {"_p_ofFileDialogResult", "ofFileDialogResult *", 0, 0, (void*)&_wrap_class_FileDialogResult, 0}; -static swig_type_info _swigt__p_ofFilePath = {"_p_ofFilePath", "ofFilePath *", 0, 0, (void*)&_wrap_class_FilePath, 0}; -static swig_type_info _swigt__p_ofFpsCounter = {"_p_ofFpsCounter", "ofFpsCounter *", 0, 0, (void*)&_wrap_class_FpsCounter, 0}; -static swig_type_info _swigt__p_ofHttpRequest = {"_p_ofHttpRequest", "ofHttpRequest *", 0, 0, (void*)&_wrap_class_HttpRequest, 0}; -static swig_type_info _swigt__p_ofHttpResponse = {"_p_ofHttpResponse", "ofHttpResponse *", 0, 0, (void*)&_wrap_class_HttpResponse, 0}; -static swig_type_info _swigt__p_ofIcoSpherePrimitive = {"_p_ofIcoSpherePrimitive", "ofIcoSpherePrimitive *", 0, 0, (void*)&_wrap_class_IcoSpherePrimitive, 0}; -static swig_type_info _swigt__p_ofImage_T_float_t = {"_p_ofImage_T_float_t", "ofFloatImage *|ofImage_< float > *", 0, 0, (void*)&_wrap_class_FloatImage, 0}; -static swig_type_info _swigt__p_ofImage_T_unsigned_char_t = {"_p_ofImage_T_unsigned_char_t", "ofImage *|ofImage_< unsigned char > *", 0, 0, (void*)&_wrap_class_Image, 0}; -static swig_type_info _swigt__p_ofImage_T_unsigned_short_t = {"_p_ofImage_T_unsigned_short_t", "ofImage_< unsigned short > *|ofShortImage *", 0, 0, (void*)&_wrap_class_ShortImage, 0}; -static swig_type_info _swigt__p_ofLight = {"_p_ofLight", "ofLight *", 0, 0, (void*)&_wrap_class_Light, 0}; -static swig_type_info _swigt__p_ofLog = {"_p_ofLog", "ofLog *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofLogError = {"_p_ofLogError", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_ofLogNotice = {"_p_ofLogNotice", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_ofLogFatalError = {"_p_ofLogFatalError", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_ofLogVerbose = {"_p_ofLogVerbose", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_ofLogWarning = {"_p_ofLogWarning", 0, 0, 0, 0, 0}; -static swig_type_info _swigt__p_ofMaterial = {"_p_ofMaterial", "ofMaterial *", 0, 0, (void*)&_wrap_class_Material, 0}; -static swig_type_info _swigt__p_ofMatrix3x3 = {"_p_ofMatrix3x3", "ofMatrix3x3 *", 0, 0, (void*)&_wrap_class_Matrix3x3, 0}; -static swig_type_info _swigt__p_ofMatrix4x4 = {"_p_ofMatrix4x4", "ofMatrix4x4 *", 0, 0, (void*)&_wrap_class_Matrix4x4, 0}; -static swig_type_info _swigt__p_ofMatrixStack = {"_p_ofMatrixStack", "ofMatrixStack *", 0, 0, (void*)&_wrap_class_MatrixStack, 0}; -static swig_type_info _swigt__p_ofMesh = {"_p_ofMesh", "ofMesh *", 0, 0, (void*)&_wrap_class_Mesh, 0}; -static swig_type_info _swigt__p_ofMeshFace = {"_p_ofMeshFace", "ofMeshFace *", 0, 0, (void*)&_wrap_class_MeshFace, 0}; -static swig_type_info _swigt__p_ofNode = {"_p_ofNode", "ofNode *", 0, 0, (void*)&_wrap_class_Node, 0}; -static swig_type_info _swigt__p_ofParameterGroup = {"_p_ofParameterGroup", "ofParameterGroup *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofPath = {"_p_ofPath", "ofTTFCharacter *|ofPath *", 0, 0, (void*)&_wrap_class_Path, 0}; -static swig_type_info _swigt__p_ofPixels_T_float_t = {"_p_ofPixels_T_float_t", "ofPixels_< float > *|ofFloatPixels *", 0, 0, (void*)&_wrap_class_FloatPixels, 0}; -static swig_type_info _swigt__p_ofPixels_T_unsigned_char_t = {"_p_ofPixels_T_unsigned_char_t", "ofPixels_< unsigned char > *|ofPixels *", 0, 0, (void*)&_wrap_class_Pixels, 0}; -static swig_type_info _swigt__p_ofPixels_T_unsigned_short_t = {"_p_ofPixels_T_unsigned_short_t", "ofPixels_< unsigned short > *|ofShortPixels *", 0, 0, (void*)&_wrap_class_ShortPixels, 0}; -static swig_type_info _swigt__p_ofPlanePrimitive = {"_p_ofPlanePrimitive", "ofPlanePrimitive *", 0, 0, (void*)&_wrap_class_PlanePrimitive, 0}; -static swig_type_info _swigt__p_ofPolyline = {"_p_ofPolyline", "ofPolyline *", 0, 0, (void*)&_wrap_class_Polyline, 0}; -static swig_type_info _swigt__p_ofQuaternion = {"_p_ofQuaternion", "ofQuaternion *", 0, 0, (void*)&_wrap_class_Quaternion, 0}; -static swig_type_info _swigt__p_ofRectangle = {"_p_ofRectangle", "ofRectangle *", 0, 0, (void*)&_wrap_class_Rectangle, 0}; -static swig_type_info _swigt__p_ofSerial = {"_p_ofSerial", "ofSerial *", 0, 0, (void*)&_wrap_class_Serial, 0}; -static swig_type_info _swigt__p_ofSerialDeviceInfo = {"_p_ofSerialDeviceInfo", "ofSerialDeviceInfo *", 0, 0, (void*)&_wrap_class_SerialDeviceInfo, 0}; -static swig_type_info _swigt__p_ofShader = {"_p_ofShader", "ofShader *", 0, 0, (void*)&_wrap_class_Shader, 0}; -static swig_type_info _swigt__p_ofSoundDevice = {"_p_ofSoundDevice", "ofSoundDevice *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofSoundPlayer = {"_p_ofSoundPlayer", "ofSoundPlayer *", 0, 0, (void*)&_wrap_class_SoundPlayer, 0}; -static swig_type_info _swigt__p_ofSoundStream = {"_p_ofSoundStream", "ofSoundStream *", 0, 0, (void*)&_wrap_class_SoundStream, 0}; -static swig_type_info _swigt__p_ofSpherePrimitive = {"_p_ofSpherePrimitive", "ofSpherePrimitive *", 0, 0, (void*)&_wrap_class_SpherePrimitive, 0}; -static swig_type_info _swigt__p_ofStyle = {"_p_ofStyle", "ofStyle *", 0, 0, (void*)&_wrap_class_Style, 0}; -static swig_type_info _swigt__p_ofTexture = {"_p_ofTexture", "ofTexture *", 0, 0, (void*)&_wrap_class_Texture, 0}; -static swig_type_info _swigt__p_ofTextureData = {"_p_ofTextureData", "ofTextureData *", 0, 0, (void*)&_wrap_class_TextureData, 0}; -static swig_type_info _swigt__p_ofTouchEventArgs = {"_p_ofTouchEventArgs", "ofTouchEventArgs *", 0, 0, (void*)&_wrap_class_TouchEventArgs, 0}; -static swig_type_info _swigt__p_ofTrueTypeFont = {"_p_ofTrueTypeFont", "ofTrueTypeFont *", 0, 0, (void*)&_wrap_class_TrueTypeFont, 0}; -static swig_type_info _swigt__p_ofURLFileLoader = {"_p_ofURLFileLoader", "ofURLFileLoader *", 0, 0, (void*)&_wrap_class_URLFileLoader, 0}; -static swig_type_info _swigt__p_ofVbo = {"_p_ofVbo", "ofVbo *", 0, 0, (void*)&_wrap_class_Vbo, 0}; -static swig_type_info _swigt__p_ofVboMesh = {"_p_ofVboMesh", "ofVboMesh *", 0, 0, (void*)&_wrap_class_VboMesh, 0}; -static swig_type_info _swigt__p_ofVec2f = {"_p_ofVec2f", "ofVec2f *", 0, 0, (void*)&_wrap_class_Vec2f, 0}; -static swig_type_info _swigt__p_ofVec3f = {"_p_ofVec3f", "ofPoint *|ofVec3f *", 0, 0, (void*)&_wrap_class_Vec3f, 0}; -static swig_type_info _swigt__p_ofVec4f = {"_p_ofVec4f", "ofVec4f *", 0, 0, (void*)&_wrap_class_Vec4f, 0}; -static swig_type_info _swigt__p_ofVideoDevice = {"_p_ofVideoDevice", "ofVideoDevice *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_ofVideoGrabber = {"_p_ofVideoGrabber", "ofVideoGrabber *", 0, 0, (void*)&_wrap_class_VideoGrabber, 0}; -static swig_type_info _swigt__p_ofVideoPlayer = {"_p_ofVideoPlayer", "ofVideoPlayer *", 0, 0, (void*)&_wrap_class_VideoPlayer, 0}; -static swig_type_info _swigt__p_ofXml = {"_p_ofXml", "ofXml *", 0, 0, (void*)&_wrap_class_Xml, 0}; -static swig_type_info _swigt__p_shared_ptrT_ofBaseRenderer_t = {"_p_shared_ptrT_ofBaseRenderer_t", "shared_ptr< ofBaseRenderer > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_shared_ptrT_ofBaseSoundPlayer_t = {"_p_shared_ptrT_ofBaseSoundPlayer_t", "shared_ptr< ofBaseSoundPlayer > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_shared_ptrT_ofBaseSoundStream_t = {"_p_shared_ptrT_ofBaseSoundStream_t", "shared_ptr< ofBaseSoundStream > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_shared_ptrT_ofBaseVideoGrabber_t = {"_p_shared_ptrT_ofBaseVideoGrabber_t", "shared_ptr< ofBaseVideoGrabber > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_std__filesystem__path = {"_p_std__filesystem__path", "std::filesystem::path *", 0, 0, (void*)&_wrap_class_path, 0}; -static swig_type_info _swigt__p_std__mapT_std__string_std__string_t = {"_p_std__mapT_std__string_std__string_t", "std::map< std::string,std::string > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_std__string = {"_p_std__string", "std::string *", 0, 0, (void*)&_wrap_class_string, 0}; -static swig_type_info _swigt__p_std__vectorT_float_t = {"_p_std__vectorT_float_t", "std::vector< float > *", 0, 0, (void*)&_wrap_class_FloatVector, 0}; -static swig_type_info _swigt__p_std__vectorT_int_t = {"_p_std__vectorT_int_t", "std::vector< int > *", 0, 0, (void*)&_wrap_class_IntVector, 0}; -static swig_type_info _swigt__p_std__vectorT_ofColor_T_float_t_t = {"_p_std__vectorT_ofColor_T_float_t_t", "std::vector< ofColor_< float > > *|std::vector< ofFloatColor > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_std__vectorT_ofFile_t = {"_p_std__vectorT_ofFile_t", "std::vector< ofFile > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_std__vectorT_ofMeshFace_t = {"_p_std__vectorT_ofMeshFace_t", "std::vector< ofMeshFace > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_std__vectorT_ofPath__Command_t = {"_p_std__vectorT_ofPath__Command_t", "std::vector< ofPath::Command > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_std__vectorT_ofPath_t = {"_p_std__vectorT_ofPath_t", "std::vector< ofTTFCharacter > *|std::vector< ofPath > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_std__vectorT_ofPolyline_t = {"_p_std__vectorT_ofPolyline_t", "std::vector< ofPolyline > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_std__vectorT_ofSerialDeviceInfo_t = {"_p_std__vectorT_ofSerialDeviceInfo_t", "std::vector< ofSerialDeviceInfo > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_std__vectorT_ofSoundDevice_t = {"_p_std__vectorT_ofSoundDevice_t", "std::vector< ofSoundDevice > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_std__vectorT_ofTexture_t = {"_p_std__vectorT_ofTexture_t", "std::vector< ofTexture > *", 0, 0, (void*)&_wrap_class_TextureVector, 0}; -static swig_type_info _swigt__p_std__vectorT_ofVec2f_t = {"_p_std__vectorT_ofVec2f_t", "std::vector< ofVec2f > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_std__vectorT_ofVec3f_t = {"_p_std__vectorT_ofVec3f_t", "std::vector< ofVec3f > *|std::vector< ofPoint > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_std__vectorT_ofVideoDevice_t = {"_p_std__vectorT_ofVideoDevice_t", "std::vector< ofVideoDevice > *", 0, 0, (void*)&_wrap_class_VideoDeviceVector, 0}; -static swig_type_info _swigt__p_std__vectorT_std__string_t = {"_p_std__vectorT_std__string_t", "std::vector< std::string > *", 0, 0, (void*)&_wrap_class_StringVector, 0}; -static swig_type_info _swigt__p_std__vectorT_unsigned_char_t = {"_p_std__vectorT_unsigned_char_t", "std::vector< unsigned char > *", 0, 0, (void*)&_wrap_class_UCharVector, 0}; -static swig_type_info _swigt__p_std__vectorT_unsigned_short_t = {"_p_std__vectorT_unsigned_short_t", "std::vector< unsigned short > *|std::vector< ofIndexType > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_std__vectorT_weak_ptrT_ofLight__Data_t_t = {"_p_std__vectorT_weak_ptrT_ofLight__Data_t_t", "std::vector< weak_ptr< ofLight::Data > > *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "size_t *|unsigned int *|GLuint *|GLenum *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_unsigned_long_long = {"_p_unsigned_long_long", "uint64_t *|unsigned long long *", 0, 0, (void*)0, 0}; -static swig_type_info _swigt__p_unsigned_short = {"_p_unsigned_short", "ofIndexType *|TESSindex *|unsigned short *", 0, 0, (void*)0, 0}; - -static swig_type_info *swig_type_initial[] = { - &_swigt__p_GLintptr, - &_swigt__p_GLsizei, - &_swigt__p_GLsizeiptr, - &_swigt__p_double, - &_swigt__p_float, - &_swigt__p_fstream, - &_swigt__p_int, - &_swigt__p_long_long, - &_swigt__p_of3dPrimitive, - &_swigt__p_ofAbstractImage, - &_swigt__p_ofAbstractParameter, - &_swigt__p_ofAppBaseWindow, - &_swigt__p_ofArduino, - &_swigt__p_ofBaseApp, - &_swigt__p_ofBaseDraws, - &_swigt__p_ofBaseFileSerializer, - &_swigt__p_ofBaseGLRenderer, - &_swigt__p_ofBaseHasPixels, - &_swigt__p_ofBaseHasTexture, - &_swigt__p_ofBaseHasTexturePlanes, - &_swigt__p_ofBaseImage_T_float_t, - &_swigt__p_ofBaseImage_T_unsigned_char_t, - &_swigt__p_ofBaseImage_T_unsigned_short_t, - &_swigt__p_ofBaseLoggerChannel, - &_swigt__p_ofBaseMaterial, - &_swigt__p_ofBaseRenderer, - &_swigt__p_ofBaseSerializer, - &_swigt__p_ofBaseSoundInput, - &_swigt__p_ofBaseSoundOutput, - &_swigt__p_ofBaseSoundPlayer, - &_swigt__p_ofBaseUpdates, - &_swigt__p_ofBaseVideo, - &_swigt__p_ofBaseVideoDraws, - &_swigt__p_ofBaseVideoGrabber, - &_swigt__p_ofBaseVideoPlayer, - &_swigt__p_ofBoxPrimitive, - &_swigt__p_ofBuffer, - &_swigt__p_ofBufferObject, - &_swigt__p_ofCamera, - &_swigt__p_ofColor_T_float_t, - &_swigt__p_ofColor_T_unsigned_char_t, - &_swigt__p_ofColor_T_unsigned_short_t, - &_swigt__p_ofConePrimitive, - &_swigt__p_ofConsoleLoggerChannel, - &_swigt__p_ofCoreEvents, - &_swigt__p_ofCylinderPrimitive, - &_swigt__p_ofDirectory, - &_swigt__p_ofDragInfo, - &_swigt__p_ofEasyCam, - &_swigt__p_ofEventArgs, - &_swigt__p_ofEventT_int_const_t, - &_swigt__p_ofEventT_ofHttpResponse_t, - &_swigt__p_ofEventT_std__string_const_t, - &_swigt__p_ofEventT_std__vectorT_unsigned_char_t_const_t, - &_swigt__p_ofFbo, - &_swigt__p_ofFbo__Settings, - &_swigt__p_ofFile, - &_swigt__p_ofFileDialogResult, - &_swigt__p_ofFileLoggerChannel, - &_swigt__p_ofFilePath, - &_swigt__p_ofFpsCounter, - &_swigt__p_ofHttpRequest, - &_swigt__p_ofHttpResponse, - &_swigt__p_ofIcoSpherePrimitive, - &_swigt__p_ofImage_T_float_t, - &_swigt__p_ofImage_T_unsigned_char_t, - &_swigt__p_ofImage_T_unsigned_short_t, - &_swigt__p_ofKeyEventArgs, - &_swigt__p_ofLight, - &_swigt__p_ofLog, - &_swigt__p_ofLogError, - &_swigt__p_ofLogFatalError, - &_swigt__p_ofLogNotice, - &_swigt__p_ofLogVerbose, - &_swigt__p_ofLogWarning, - &_swigt__p_ofMaterial, - &_swigt__p_ofMatrix3x3, - &_swigt__p_ofMatrix4x4, - &_swigt__p_ofMatrixStack, - &_swigt__p_ofMesh, - &_swigt__p_ofMeshFace, - &_swigt__p_ofMessage, - &_swigt__p_ofMouseEventArgs, - &_swigt__p_ofNode, - &_swigt__p_ofParameterGroup, - &_swigt__p_ofPath, - &_swigt__p_ofPixels_T_float_t, - &_swigt__p_ofPixels_T_unsigned_char_t, - &_swigt__p_ofPixels_T_unsigned_short_t, - &_swigt__p_ofPlanePrimitive, - &_swigt__p_ofPolyline, - &_swigt__p_ofQuaternion, - &_swigt__p_ofRectangle, - &_swigt__p_ofResizeEventArgs, - &_swigt__p_ofSerial, - &_swigt__p_ofSerialDeviceInfo, - &_swigt__p_ofShader, - &_swigt__p_ofSoundDevice, - &_swigt__p_ofSoundPlayer, - &_swigt__p_ofSoundStream, - &_swigt__p_ofSpherePrimitive, - &_swigt__p_ofStyle, - &_swigt__p_ofTexture, - &_swigt__p_ofTextureData, - &_swigt__p_ofTouchEventArgs, - &_swigt__p_ofTrueTypeFont, - &_swigt__p_ofURLFileLoader, - &_swigt__p_ofVbo, - &_swigt__p_ofVboMesh, - &_swigt__p_ofVec2f, - &_swigt__p_ofVec3f, - &_swigt__p_ofVec4f, - &_swigt__p_ofVideoDevice, - &_swigt__p_ofVideoGrabber, - &_swigt__p_ofVideoPlayer, - &_swigt__p_ofXml, - &_swigt__p_shared_ptrT_ofBaseRenderer_t, - &_swigt__p_shared_ptrT_ofBaseSoundPlayer_t, - &_swigt__p_shared_ptrT_ofBaseSoundStream_t, - &_swigt__p_shared_ptrT_ofBaseVideoGrabber_t, - &_swigt__p_std__filesystem__path, - &_swigt__p_std__mapT_std__string_std__string_t, - &_swigt__p_std__string, - &_swigt__p_std__vectorT_float_t, - &_swigt__p_std__vectorT_int_t, - &_swigt__p_std__vectorT_ofColor_T_float_t_t, - &_swigt__p_std__vectorT_ofFile_t, - &_swigt__p_std__vectorT_ofMeshFace_t, - &_swigt__p_std__vectorT_ofPath__Command_t, - &_swigt__p_std__vectorT_ofPath_t, - &_swigt__p_std__vectorT_ofPolyline_t, - &_swigt__p_std__vectorT_ofSerialDeviceInfo_t, - &_swigt__p_std__vectorT_ofSoundDevice_t, - &_swigt__p_std__vectorT_ofTexture_t, - &_swigt__p_std__vectorT_ofVec2f_t, - &_swigt__p_std__vectorT_ofVec3f_t, - &_swigt__p_std__vectorT_ofVideoDevice_t, - &_swigt__p_std__vectorT_std__string_t, - &_swigt__p_std__vectorT_unsigned_char_t, - &_swigt__p_std__vectorT_unsigned_short_t, - &_swigt__p_std__vectorT_weak_ptrT_ofLight__Data_t_t, - &_swigt__p_unsigned_char, - &_swigt__p_unsigned_int, - &_swigt__p_unsigned_long_long, - &_swigt__p_unsigned_short, -}; - -static swig_cast_info _swigc__p_GLintptr[] = { {&_swigt__p_GLintptr, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_GLsizei[] = { {&_swigt__p_GLsizei, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_GLsizeiptr[] = { {&_swigt__p_GLsizeiptr, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_double[] = { {&_swigt__p_double, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_float[] = { {&_swigt__p_float, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_fstream[] = { {&_swigt__p_fstream, 0, 0, 0}, {&_swigt__p_ofFile, _p_ofFileTo_p_fstream, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_long_long[] = { {&_swigt__p_long_long, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_of3dPrimitive[] = { {&_swigt__p_of3dPrimitive, 0, 0, 0}, {&_swigt__p_ofPlanePrimitive, _p_ofPlanePrimitiveTo_p_of3dPrimitive, 0, 0}, {&_swigt__p_ofSpherePrimitive, _p_ofSpherePrimitiveTo_p_of3dPrimitive, 0, 0}, {&_swigt__p_ofIcoSpherePrimitive, _p_ofIcoSpherePrimitiveTo_p_of3dPrimitive, 0, 0}, {&_swigt__p_ofCylinderPrimitive, _p_ofCylinderPrimitiveTo_p_of3dPrimitive, 0, 0}, {&_swigt__p_ofConePrimitive, _p_ofConePrimitiveTo_p_of3dPrimitive, 0, 0}, {&_swigt__p_ofBoxPrimitive, _p_ofBoxPrimitiveTo_p_of3dPrimitive, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofAbstractParameter[] = { {&_swigt__p_ofAbstractParameter, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofAppBaseWindow[] = { {&_swigt__p_ofAppBaseWindow, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofArduino[] = { {&_swigt__p_ofArduino, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofBaseApp[] = { {&_swigt__p_ofBaseApp, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofAbstractImage[] = {{&_swigt__p_ofAbstractImage, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofBaseDraws[] = { {&_swigt__p_ofAbstractImage, _p_ofAbstractImageTo_p_ofBaseDraws, 0, 0}, {&_swigt__p_ofBaseVideoDraws, _p_ofBaseVideoDrawsTo_p_ofBaseDraws, 0, 0}, {&_swigt__p_ofVideoGrabber, _p_ofVideoGrabberTo_p_ofBaseDraws, 0, 0}, {&_swigt__p_ofBaseDraws, 0, 0, 0}, {&_swigt__p_ofTexture, _p_ofTextureTo_p_ofBaseDraws, 0, 0}, {&_swigt__p_ofFbo, _p_ofFboTo_p_ofBaseDraws, 0, 0}, {&_swigt__p_ofVideoPlayer, _p_ofVideoPlayerTo_p_ofBaseDraws, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofBaseFileSerializer[] = { {&_swigt__p_ofXml, _p_ofXmlTo_p_ofBaseFileSerializer, 0, 0}, {&_swigt__p_ofBaseFileSerializer, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofBaseHasPixels[] = { {&_swigt__p_ofBaseVideoDraws, _p_ofBaseVideoDrawsTo_p_ofBaseHasPixels, 0, 0}, {&_swigt__p_ofVideoGrabber, _p_ofVideoGrabberTo_p_ofBaseHasPixels, 0, 0}, {&_swigt__p_ofBaseVideoGrabber, _p_ofBaseVideoGrabberTo_p_ofBaseHasPixels, 0, 0}, {&_swigt__p_ofBaseVideo, _p_ofBaseVideoTo_p_ofBaseHasPixels, 0, 0}, {&_swigt__p_ofBaseHasPixels, 0, 0, 0}, {&_swigt__p_ofVideoPlayer, _p_ofVideoPlayerTo_p_ofBaseHasPixels, 0, 0}, {&_swigt__p_ofBaseVideoPlayer, _p_ofBaseVideoPlayerTo_p_ofBaseHasPixels, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofBaseHasTexture[] = { {&_swigt__p_ofAbstractImage, _p_ofAbstractImageTo_p_ofBaseHasTexture, 0, 0}, {&_swigt__p_ofBaseVideoDraws, _p_ofBaseVideoDrawsTo_p_ofBaseHasTexture, 0, 0}, {&_swigt__p_ofVideoGrabber, _p_ofVideoGrabberTo_p_ofBaseHasTexture, 0, 0}, {&_swigt__p_ofBaseHasTexture, 0, 0, 0}, {&_swigt__p_ofFbo, _p_ofFboTo_p_ofBaseHasTexture, 0, 0}, {&_swigt__p_ofVideoPlayer, _p_ofVideoPlayerTo_p_ofBaseHasTexture, 0, 0}, {&_swigt__p_ofBaseHasTexturePlanes, _p_ofBaseHasTexturePlanesTo_p_ofBaseHasTexture, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofBaseHasTexturePlanes[] = { {&_swigt__p_ofBaseVideoDraws, _p_ofBaseVideoDrawsTo_p_ofBaseHasTexturePlanes, 0, 0}, {&_swigt__p_ofVideoGrabber, _p_ofVideoGrabberTo_p_ofBaseHasTexturePlanes, 0, 0}, {&_swigt__p_ofBaseHasTexturePlanes, 0, 0, 0}, {&_swigt__p_ofVideoPlayer, _p_ofVideoPlayerTo_p_ofBaseHasTexturePlanes, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofBaseImage_T_float_t[] = { {&_swigt__p_ofBaseImage_T_float_t, 0, 0, 0}, {&_swigt__p_ofImage_T_float_t, _p_ofImage_T_float_tTo_p_ofBaseImage_T_float_t, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofBaseImage_T_unsigned_char_t[] = { {&_swigt__p_ofBaseImage_T_unsigned_char_t, 0, 0, 0}, {&_swigt__p_ofImage_T_unsigned_char_t, _p_ofImage_T_unsigned_char_tTo_p_ofBaseImage_T_unsigned_char_t, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofBaseImage_T_unsigned_short_t[] = { {&_swigt__p_ofBaseImage_T_unsigned_short_t, 0, 0, 0}, {&_swigt__p_ofImage_T_unsigned_short_t, _p_ofImage_T_unsigned_short_tTo_p_ofBaseImage_T_unsigned_short_t, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofConsoleLoggerChannel[] = {{&_swigt__p_ofConsoleLoggerChannel, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofFileLoggerChannel[] = {{&_swigt__p_ofFileLoggerChannel, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofBaseLoggerChannel[] = { {&_swigt__p_ofBaseLoggerChannel, 0, 0, 0}, {&_swigt__p_ofConsoleLoggerChannel, _p_ofConsoleLoggerChannelTo_p_ofBaseLoggerChannel, 0, 0}, {&_swigt__p_ofFileLoggerChannel, _p_ofFileLoggerChannelTo_p_ofBaseLoggerChannel, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofBaseMaterial[] = { {&_swigt__p_ofBaseMaterial, 0, 0, 0}, {&_swigt__p_ofMaterial, _p_ofMaterialTo_p_ofBaseMaterial, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofBaseGLRenderer[] = {{&_swigt__p_ofBaseGLRenderer, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofBaseRenderer[] = { {&_swigt__p_ofBaseRenderer, 0, 0, 0}, {&_swigt__p_ofBaseGLRenderer, _p_ofBaseGLRendererTo_p_ofBaseRenderer, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofBaseSerializer[] = { {&_swigt__p_ofXml, _p_ofXmlTo_p_ofBaseSerializer, 0, 0}, {&_swigt__p_ofBaseSerializer, 0, 0, 0}, {&_swigt__p_ofBaseFileSerializer, _p_ofBaseFileSerializerTo_p_ofBaseSerializer, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofBaseSoundInput[] = { {&_swigt__p_ofBaseSoundInput, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofBaseSoundOutput[] = { {&_swigt__p_ofBaseSoundOutput, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofBaseSoundPlayer[] = { {&_swigt__p_ofBaseSoundPlayer, 0, 0, 0}, {&_swigt__p_ofSoundPlayer, _p_ofSoundPlayerTo_p_ofBaseSoundPlayer, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofBaseUpdates[] = { {&_swigt__p_ofBaseVideoDraws, _p_ofBaseVideoDrawsTo_p_ofBaseUpdates, 0, 0}, {&_swigt__p_ofVideoGrabber, _p_ofVideoGrabberTo_p_ofBaseUpdates, 0, 0}, {&_swigt__p_ofBaseVideoGrabber, _p_ofBaseVideoGrabberTo_p_ofBaseUpdates, 0, 0}, {&_swigt__p_ofBaseVideo, _p_ofBaseVideoTo_p_ofBaseUpdates, 0, 0}, {&_swigt__p_ofBaseUpdates, 0, 0, 0}, {&_swigt__p_ofVideoPlayer, _p_ofVideoPlayerTo_p_ofBaseUpdates, 0, 0}, {&_swigt__p_ofBaseVideoPlayer, _p_ofBaseVideoPlayerTo_p_ofBaseUpdates, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofBaseVideo[] = { {&_swigt__p_ofBaseVideoDraws, _p_ofBaseVideoDrawsTo_p_ofBaseVideo, 0, 0}, {&_swigt__p_ofVideoGrabber, _p_ofVideoGrabberTo_p_ofBaseVideo, 0, 0}, {&_swigt__p_ofBaseVideoGrabber, _p_ofBaseVideoGrabberTo_p_ofBaseVideo, 0, 0}, {&_swigt__p_ofBaseVideo, 0, 0, 0}, {&_swigt__p_ofVideoPlayer, _p_ofVideoPlayerTo_p_ofBaseVideo, 0, 0}, {&_swigt__p_ofBaseVideoPlayer, _p_ofBaseVideoPlayerTo_p_ofBaseVideo, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofBaseVideoDraws[] = { {&_swigt__p_ofBaseVideoDraws, 0, 0, 0}, {&_swigt__p_ofVideoGrabber, _p_ofVideoGrabberTo_p_ofBaseVideoDraws, 0, 0}, {&_swigt__p_ofVideoPlayer, _p_ofVideoPlayerTo_p_ofBaseVideoDraws, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofBaseVideoGrabber[] = { {&_swigt__p_ofBaseVideoGrabber, 0, 0, 0}, {&_swigt__p_ofVideoGrabber, _p_ofVideoGrabberTo_p_ofBaseVideoGrabber, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofBaseVideoPlayer[] = { {&_swigt__p_ofBaseVideoPlayer, 0, 0, 0}, {&_swigt__p_ofVideoPlayer, _p_ofVideoPlayerTo_p_ofBaseVideoPlayer, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofBoxPrimitive[] = { {&_swigt__p_ofBoxPrimitive, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofBuffer[] = { {&_swigt__p_ofBuffer, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofBufferObject[] = { {&_swigt__p_ofBufferObject, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofCamera[] = { {&_swigt__p_ofEasyCam, _p_ofEasyCamTo_p_ofCamera, 0, 0}, {&_swigt__p_ofCamera, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofColor_T_float_t[] = { {&_swigt__p_ofColor_T_float_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofColor_T_unsigned_char_t[] = { {&_swigt__p_ofColor_T_unsigned_char_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofColor_T_unsigned_short_t[] = { {&_swigt__p_ofColor_T_unsigned_short_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofConePrimitive[] = { {&_swigt__p_ofConePrimitive, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofCoreEvents[] = { {&_swigt__p_ofCoreEvents, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofCylinderPrimitive[] = { {&_swigt__p_ofCylinderPrimitive, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofDirectory[] = { {&_swigt__p_ofDirectory, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofDragInfo[] = { {&_swigt__p_ofDragInfo, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofEasyCam[] = { {&_swigt__p_ofEasyCam, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofKeyEventArgs[] = {{&_swigt__p_ofKeyEventArgs, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofMouseEventArgs[] = {{&_swigt__p_ofMouseEventArgs, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofResizeEventArgs[] = {{&_swigt__p_ofResizeEventArgs, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofMessage[] = {{&_swigt__p_ofMessage, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofEventArgs[] = { {&_swigt__p_ofEventArgs, 0, 0, 0}, {&_swigt__p_ofKeyEventArgs, _p_ofKeyEventArgsTo_p_ofEventArgs, 0, 0}, {&_swigt__p_ofMouseEventArgs, _p_ofMouseEventArgsTo_p_ofEventArgs, 0, 0}, {&_swigt__p_ofTouchEventArgs, _p_ofTouchEventArgsTo_p_ofEventArgs, 0, 0}, {&_swigt__p_ofResizeEventArgs, _p_ofResizeEventArgsTo_p_ofEventArgs, 0, 0}, {&_swigt__p_ofMessage, _p_ofMessageTo_p_ofEventArgs, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofEventT_int_const_t[] = { {&_swigt__p_ofEventT_int_const_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofEventT_ofHttpResponse_t[] = { {&_swigt__p_ofEventT_ofHttpResponse_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofEventT_std__string_const_t[] = { {&_swigt__p_ofEventT_std__string_const_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofEventT_std__vectorT_unsigned_char_t_const_t[] = { {&_swigt__p_ofEventT_std__vectorT_unsigned_char_t_const_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofFbo[] = { {&_swigt__p_ofFbo, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofFbo__Settings[] = { {&_swigt__p_ofFbo__Settings, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofFile[] = { {&_swigt__p_ofFile, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofFileDialogResult[] = { {&_swigt__p_ofFileDialogResult, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofFilePath[] = { {&_swigt__p_ofFilePath, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofFpsCounter[] = { {&_swigt__p_ofFpsCounter, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofHttpRequest[] = { {&_swigt__p_ofHttpRequest, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofHttpResponse[] = { {&_swigt__p_ofHttpResponse, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofIcoSpherePrimitive[] = { {&_swigt__p_ofIcoSpherePrimitive, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofImage_T_float_t[] = { {&_swigt__p_ofImage_T_float_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofImage_T_unsigned_char_t[] = { {&_swigt__p_ofImage_T_unsigned_char_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofImage_T_unsigned_short_t[] = { {&_swigt__p_ofImage_T_unsigned_short_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofLight[] = { {&_swigt__p_ofLight, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofLogError[] = {{&_swigt__p_ofLogError, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofLogNotice[] = {{&_swigt__p_ofLogNotice, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofLogFatalError[] = {{&_swigt__p_ofLogFatalError, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofLogVerbose[] = {{&_swigt__p_ofLogVerbose, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofLogWarning[] = {{&_swigt__p_ofLogWarning, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofLog[] = { {&_swigt__p_ofLogError, _p_ofLogErrorTo_p_ofLog, 0, 0}, {&_swigt__p_ofLogNotice, _p_ofLogNoticeTo_p_ofLog, 0, 0}, {&_swigt__p_ofLogFatalError, _p_ofLogFatalErrorTo_p_ofLog, 0, 0}, {&_swigt__p_ofLogVerbose, _p_ofLogVerboseTo_p_ofLog, 0, 0}, {&_swigt__p_ofLog, 0, 0, 0}, {&_swigt__p_ofLogWarning, _p_ofLogWarningTo_p_ofLog, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofMaterial[] = { {&_swigt__p_ofMaterial, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofMatrix3x3[] = { {&_swigt__p_ofMatrix3x3, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofMatrix4x4[] = { {&_swigt__p_ofMatrix4x4, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofMatrixStack[] = { {&_swigt__p_ofMatrixStack, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofMesh[] = { {&_swigt__p_ofMesh, 0, 0, 0}, {&_swigt__p_ofVboMesh, _p_ofVboMeshTo_p_ofMesh, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofMeshFace[] = { {&_swigt__p_ofMeshFace, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofNode[] = { {&_swigt__p_ofNode, 0, 0, 0}, {&_swigt__p_of3dPrimitive, _p_of3dPrimitiveTo_p_ofNode, 0, 0}, {&_swigt__p_ofPlanePrimitive, _p_ofPlanePrimitiveTo_p_ofNode, 0, 0}, {&_swigt__p_ofSpherePrimitive, _p_ofSpherePrimitiveTo_p_ofNode, 0, 0}, {&_swigt__p_ofIcoSpherePrimitive, _p_ofIcoSpherePrimitiveTo_p_ofNode, 0, 0}, {&_swigt__p_ofCylinderPrimitive, _p_ofCylinderPrimitiveTo_p_ofNode, 0, 0}, {&_swigt__p_ofConePrimitive, _p_ofConePrimitiveTo_p_ofNode, 0, 0}, {&_swigt__p_ofBoxPrimitive, _p_ofBoxPrimitiveTo_p_ofNode, 0, 0}, {&_swigt__p_ofEasyCam, _p_ofEasyCamTo_p_ofNode, 0, 0}, {&_swigt__p_ofLight, _p_ofLightTo_p_ofNode, 0, 0}, {&_swigt__p_ofCamera, _p_ofCameraTo_p_ofNode, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofParameterGroup[] = { {&_swigt__p_ofParameterGroup, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofPath[] = { {&_swigt__p_ofPath, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofPixels_T_float_t[] = { {&_swigt__p_ofPixels_T_float_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofPixels_T_unsigned_char_t[] = { {&_swigt__p_ofPixels_T_unsigned_char_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofPixels_T_unsigned_short_t[] = { {&_swigt__p_ofPixels_T_unsigned_short_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofPlanePrimitive[] = { {&_swigt__p_ofPlanePrimitive, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofPolyline[] = { {&_swigt__p_ofPolyline, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofQuaternion[] = { {&_swigt__p_ofQuaternion, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofRectangle[] = { {&_swigt__p_ofRectangle, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofSerial[] = { {&_swigt__p_ofSerial, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofSerialDeviceInfo[] = { {&_swigt__p_ofSerialDeviceInfo, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofShader[] = { {&_swigt__p_ofShader, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofSoundDevice[] = { {&_swigt__p_ofSoundDevice, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofSoundPlayer[] = { {&_swigt__p_ofSoundPlayer, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofSoundStream[] = { {&_swigt__p_ofSoundStream, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofSpherePrimitive[] = { {&_swigt__p_ofSpherePrimitive, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofStyle[] = { {&_swigt__p_ofStyle, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofTexture[] = { {&_swigt__p_ofTexture, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofTextureData[] = { {&_swigt__p_ofTextureData, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofTouchEventArgs[] = { {&_swigt__p_ofTouchEventArgs, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofTrueTypeFont[] = { {&_swigt__p_ofTrueTypeFont, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofURLFileLoader[] = { {&_swigt__p_ofURLFileLoader, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofVbo[] = { {&_swigt__p_ofVbo, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofVboMesh[] = { {&_swigt__p_ofVboMesh, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofVec2f[] = { {&_swigt__p_ofMouseEventArgs, _p_ofMouseEventArgsTo_p_ofVec2f, 0, 0}, {&_swigt__p_ofTouchEventArgs, _p_ofTouchEventArgsTo_p_ofVec2f, 0, 0}, {&_swigt__p_ofVec2f, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofVec3f[] = { {&_swigt__p_ofVec3f, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofVec4f[] = { {&_swigt__p_ofVec4f, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofVideoDevice[] = { {&_swigt__p_ofVideoDevice, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofVideoGrabber[] = { {&_swigt__p_ofVideoGrabber, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofVideoPlayer[] = { {&_swigt__p_ofVideoPlayer, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_ofXml[] = { {&_swigt__p_ofXml, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_shared_ptrT_ofBaseRenderer_t[] = { {&_swigt__p_shared_ptrT_ofBaseRenderer_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_shared_ptrT_ofBaseSoundPlayer_t[] = { {&_swigt__p_shared_ptrT_ofBaseSoundPlayer_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_shared_ptrT_ofBaseSoundStream_t[] = { {&_swigt__p_shared_ptrT_ofBaseSoundStream_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_shared_ptrT_ofBaseVideoGrabber_t[] = { {&_swigt__p_shared_ptrT_ofBaseVideoGrabber_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__filesystem__path[] = { {&_swigt__p_std__filesystem__path, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__mapT_std__string_std__string_t[] = { {&_swigt__p_std__mapT_std__string_std__string_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__string[] = { {&_swigt__p_std__string, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__vectorT_float_t[] = { {&_swigt__p_std__vectorT_float_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__vectorT_int_t[] = { {&_swigt__p_std__vectorT_int_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__vectorT_ofColor_T_float_t_t[] = { {&_swigt__p_std__vectorT_ofColor_T_float_t_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__vectorT_ofFile_t[] = { {&_swigt__p_std__vectorT_ofFile_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__vectorT_ofMeshFace_t[] = { {&_swigt__p_std__vectorT_ofMeshFace_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__vectorT_ofPath__Command_t[] = { {&_swigt__p_std__vectorT_ofPath__Command_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__vectorT_ofPath_t[] = { {&_swigt__p_std__vectorT_ofPath_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__vectorT_ofPolyline_t[] = { {&_swigt__p_std__vectorT_ofPolyline_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__vectorT_ofSerialDeviceInfo_t[] = { {&_swigt__p_std__vectorT_ofSerialDeviceInfo_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__vectorT_ofSoundDevice_t[] = { {&_swigt__p_std__vectorT_ofSoundDevice_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__vectorT_ofTexture_t[] = { {&_swigt__p_std__vectorT_ofTexture_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__vectorT_ofVec2f_t[] = { {&_swigt__p_std__vectorT_ofVec2f_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__vectorT_ofVec3f_t[] = { {&_swigt__p_std__vectorT_ofVec3f_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__vectorT_ofVideoDevice_t[] = { {&_swigt__p_std__vectorT_ofVideoDevice_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__vectorT_std__string_t[] = { {&_swigt__p_std__vectorT_std__string_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__vectorT_unsigned_char_t[] = { {&_swigt__p_std__vectorT_unsigned_char_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__vectorT_unsigned_short_t[] = { {&_swigt__p_std__vectorT_unsigned_short_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_std__vectorT_weak_ptrT_ofLight__Data_t_t[] = { {&_swigt__p_std__vectorT_weak_ptrT_ofLight__Data_t_t, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_unsigned_long_long[] = { {&_swigt__p_unsigned_long_long, 0, 0, 0},{0, 0, 0, 0}}; -static swig_cast_info _swigc__p_unsigned_short[] = { {&_swigt__p_unsigned_short, 0, 0, 0},{0, 0, 0, 0}}; - -static swig_cast_info *swig_cast_initial[] = { - _swigc__p_GLintptr, - _swigc__p_GLsizei, - _swigc__p_GLsizeiptr, - _swigc__p_double, - _swigc__p_float, - _swigc__p_fstream, - _swigc__p_int, - _swigc__p_long_long, - _swigc__p_of3dPrimitive, - _swigc__p_ofAbstractImage, - _swigc__p_ofAbstractParameter, - _swigc__p_ofAppBaseWindow, - _swigc__p_ofArduino, - _swigc__p_ofBaseApp, - _swigc__p_ofBaseDraws, - _swigc__p_ofBaseFileSerializer, - _swigc__p_ofBaseGLRenderer, - _swigc__p_ofBaseHasPixels, - _swigc__p_ofBaseHasTexture, - _swigc__p_ofBaseHasTexturePlanes, - _swigc__p_ofBaseImage_T_float_t, - _swigc__p_ofBaseImage_T_unsigned_char_t, - _swigc__p_ofBaseImage_T_unsigned_short_t, - _swigc__p_ofBaseLoggerChannel, - _swigc__p_ofBaseMaterial, - _swigc__p_ofBaseRenderer, - _swigc__p_ofBaseSerializer, - _swigc__p_ofBaseSoundInput, - _swigc__p_ofBaseSoundOutput, - _swigc__p_ofBaseSoundPlayer, - _swigc__p_ofBaseUpdates, - _swigc__p_ofBaseVideo, - _swigc__p_ofBaseVideoDraws, - _swigc__p_ofBaseVideoGrabber, - _swigc__p_ofBaseVideoPlayer, - _swigc__p_ofBoxPrimitive, - _swigc__p_ofBuffer, - _swigc__p_ofBufferObject, - _swigc__p_ofCamera, - _swigc__p_ofColor_T_float_t, - _swigc__p_ofColor_T_unsigned_char_t, - _swigc__p_ofColor_T_unsigned_short_t, - _swigc__p_ofConePrimitive, - _swigc__p_ofConsoleLoggerChannel, - _swigc__p_ofCoreEvents, - _swigc__p_ofCylinderPrimitive, - _swigc__p_ofDirectory, - _swigc__p_ofDragInfo, - _swigc__p_ofEasyCam, - _swigc__p_ofEventArgs, - _swigc__p_ofEventT_int_const_t, - _swigc__p_ofEventT_ofHttpResponse_t, - _swigc__p_ofEventT_std__string_const_t, - _swigc__p_ofEventT_std__vectorT_unsigned_char_t_const_t, - _swigc__p_ofFbo, - _swigc__p_ofFbo__Settings, - _swigc__p_ofFile, - _swigc__p_ofFileDialogResult, - _swigc__p_ofFileLoggerChannel, - _swigc__p_ofFilePath, - _swigc__p_ofFpsCounter, - _swigc__p_ofHttpRequest, - _swigc__p_ofHttpResponse, - _swigc__p_ofIcoSpherePrimitive, - _swigc__p_ofImage_T_float_t, - _swigc__p_ofImage_T_unsigned_char_t, - _swigc__p_ofImage_T_unsigned_short_t, - _swigc__p_ofKeyEventArgs, - _swigc__p_ofLight, - _swigc__p_ofLog, - _swigc__p_ofLogError, - _swigc__p_ofLogFatalError, - _swigc__p_ofLogNotice, - _swigc__p_ofLogVerbose, - _swigc__p_ofLogWarning, - _swigc__p_ofMaterial, - _swigc__p_ofMatrix3x3, - _swigc__p_ofMatrix4x4, - _swigc__p_ofMatrixStack, - _swigc__p_ofMesh, - _swigc__p_ofMeshFace, - _swigc__p_ofMessage, - _swigc__p_ofMouseEventArgs, - _swigc__p_ofNode, - _swigc__p_ofParameterGroup, - _swigc__p_ofPath, - _swigc__p_ofPixels_T_float_t, - _swigc__p_ofPixels_T_unsigned_char_t, - _swigc__p_ofPixels_T_unsigned_short_t, - _swigc__p_ofPlanePrimitive, - _swigc__p_ofPolyline, - _swigc__p_ofQuaternion, - _swigc__p_ofRectangle, - _swigc__p_ofResizeEventArgs, - _swigc__p_ofSerial, - _swigc__p_ofSerialDeviceInfo, - _swigc__p_ofShader, - _swigc__p_ofSoundDevice, - _swigc__p_ofSoundPlayer, - _swigc__p_ofSoundStream, - _swigc__p_ofSpherePrimitive, - _swigc__p_ofStyle, - _swigc__p_ofTexture, - _swigc__p_ofTextureData, - _swigc__p_ofTouchEventArgs, - _swigc__p_ofTrueTypeFont, - _swigc__p_ofURLFileLoader, - _swigc__p_ofVbo, - _swigc__p_ofVboMesh, - _swigc__p_ofVec2f, - _swigc__p_ofVec3f, - _swigc__p_ofVec4f, - _swigc__p_ofVideoDevice, - _swigc__p_ofVideoGrabber, - _swigc__p_ofVideoPlayer, - _swigc__p_ofXml, - _swigc__p_shared_ptrT_ofBaseRenderer_t, - _swigc__p_shared_ptrT_ofBaseSoundPlayer_t, - _swigc__p_shared_ptrT_ofBaseSoundStream_t, - _swigc__p_shared_ptrT_ofBaseVideoGrabber_t, - _swigc__p_std__filesystem__path, - _swigc__p_std__mapT_std__string_std__string_t, - _swigc__p_std__string, - _swigc__p_std__vectorT_float_t, - _swigc__p_std__vectorT_int_t, - _swigc__p_std__vectorT_ofColor_T_float_t_t, - _swigc__p_std__vectorT_ofFile_t, - _swigc__p_std__vectorT_ofMeshFace_t, - _swigc__p_std__vectorT_ofPath__Command_t, - _swigc__p_std__vectorT_ofPath_t, - _swigc__p_std__vectorT_ofPolyline_t, - _swigc__p_std__vectorT_ofSerialDeviceInfo_t, - _swigc__p_std__vectorT_ofSoundDevice_t, - _swigc__p_std__vectorT_ofTexture_t, - _swigc__p_std__vectorT_ofVec2f_t, - _swigc__p_std__vectorT_ofVec3f_t, - _swigc__p_std__vectorT_ofVideoDevice_t, - _swigc__p_std__vectorT_std__string_t, - _swigc__p_std__vectorT_unsigned_char_t, - _swigc__p_std__vectorT_unsigned_short_t, - _swigc__p_std__vectorT_weak_ptrT_ofLight__Data_t_t, - _swigc__p_unsigned_char, - _swigc__p_unsigned_int, - _swigc__p_unsigned_long_long, - _swigc__p_unsigned_short, -}; - - -/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */ - -/* ----------------------------------------------------------------------------- - * Type initialization: - * This problem is tough by the requirement that no dynamic - * memory is used. Also, since swig_type_info structures store pointers to - * swig_cast_info structures and swig_cast_info structures store pointers back - * to swig_type_info structures, we need some lookup code at initialization. - * The idea is that swig generates all the structures that are needed. - * The runtime then collects these partially filled structures. - * The SWIG_InitializeModule function takes these initial arrays out of - * swig_module, and does all the lookup, filling in the swig_module.types - * array with the correct data and linking the correct swig_cast_info - * structures together. - * - * The generated swig_type_info structures are assigned statically to an initial - * array. We just loop through that array, and handle each type individually. - * First we lookup if this type has been already loaded, and if so, use the - * loaded structure instead of the generated one. Then we have to fill in the - * cast linked list. The cast data is initially stored in something like a - * two-dimensional array. Each row corresponds to a type (there are the same - * number of rows as there are in the swig_type_initial array). Each entry in - * a column is one of the swig_cast_info structures for that type. - * The cast_initial array is actually an array of arrays, because each row has - * a variable number of columns. So to actually build the cast linked list, - * we find the array of casts associated with the type, and loop through it - * adding the casts to the list. The one last trick we need to do is making - * sure the type pointer in the swig_cast_info struct is correct. - * - * First off, we lookup the cast->type name to see if it is already loaded. - * There are three cases to handle: - * 1) If the cast->type has already been loaded AND the type we are adding - * casting info to has not been loaded (it is in this module), THEN we - * replace the cast->type pointer with the type pointer that has already - * been loaded. - * 2) If BOTH types (the one we are adding casting info to, and the - * cast->type) are loaded, THEN the cast info has already been loaded by - * the previous module so we just ignore it. - * 3) Finally, if cast->type has not already been loaded, then we add that - * swig_cast_info to the linked list (because the cast->type) pointer will - * be correct. - * ----------------------------------------------------------------------------- */ - -#ifdef __cplusplus -extern "C" { -#if 0 -} /* c-mode */ -#endif -#endif - -#if 0 -#define SWIGRUNTIME_DEBUG -#endif - - -SWIGRUNTIME void -SWIG_InitializeModule(void *clientdata) { - size_t i; - swig_module_info *module_head, *iter; - int init; - - /* check to see if the circular list has been setup, if not, set it up */ - if (swig_module.next==0) { - /* Initialize the swig_module */ - swig_module.type_initial = swig_type_initial; - swig_module.cast_initial = swig_cast_initial; - swig_module.next = &swig_module; - init = 1; - } else { - init = 0; - } - - /* Try and load any already created modules */ - module_head = SWIG_GetModule(clientdata); - if (!module_head) { - /* This is the first module loaded for this interpreter */ - /* so set the swig module into the interpreter */ - SWIG_SetModule(clientdata, &swig_module); - } else { - /* the interpreter has loaded a SWIG module, but has it loaded this one? */ - iter=module_head; - do { - if (iter==&swig_module) { - /* Our module is already in the list, so there's nothing more to do. */ - return; - } - iter=iter->next; - } while (iter!= module_head); - - /* otherwise we must add our module into the list */ - swig_module.next = module_head->next; - module_head->next = &swig_module; - } - - /* When multiple interpreters are used, a module could have already been initialized in - a different interpreter, but not yet have a pointer in this interpreter. - In this case, we do not want to continue adding types... everything should be - set up already */ - if (init == 0) return; - - /* Now work on filling in swig_module.types */ -#ifdef SWIGRUNTIME_DEBUG - printf("SWIG_InitializeModule: size %d\n", swig_module.size); -#endif - for (i = 0; i < swig_module.size; ++i) { - swig_type_info *type = 0; - swig_type_info *ret; - swig_cast_info *cast; - -#ifdef SWIGRUNTIME_DEBUG - printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name); -#endif - - /* if there is another module already loaded */ - if (swig_module.next != &swig_module) { - type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name); - } - if (type) { - /* Overwrite clientdata field */ -#ifdef SWIGRUNTIME_DEBUG - printf("SWIG_InitializeModule: found type %s\n", type->name); -#endif - if (swig_module.type_initial[i]->clientdata) { - type->clientdata = swig_module.type_initial[i]->clientdata; -#ifdef SWIGRUNTIME_DEBUG - printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name); -#endif - } - } else { - type = swig_module.type_initial[i]; - } - - /* Insert casting types */ - cast = swig_module.cast_initial[i]; - while (cast->type) { - - /* Don't need to add information already in the list */ - ret = 0; -#ifdef SWIGRUNTIME_DEBUG - printf("SWIG_InitializeModule: look cast %s\n", cast->type->name); -#endif - if (swig_module.next != &swig_module) { - ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name); -#ifdef SWIGRUNTIME_DEBUG - if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name); -#endif - } - if (ret) { - if (type == swig_module.type_initial[i]) { -#ifdef SWIGRUNTIME_DEBUG - printf("SWIG_InitializeModule: skip old type %s\n", ret->name); -#endif - cast->type = ret; - ret = 0; - } else { - /* Check for casting already in the list */ - swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type); -#ifdef SWIGRUNTIME_DEBUG - if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name); -#endif - if (!ocast) ret = 0; - } - } - - if (!ret) { -#ifdef SWIGRUNTIME_DEBUG - printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name); -#endif - if (type->cast) { - type->cast->prev = cast; - cast->next = type->cast; - } - type->cast = cast; - } - cast++; - } - /* Set entry in modules->types array equal to the type */ - swig_module.types[i] = type; - } - swig_module.types[i] = 0; - -#ifdef SWIGRUNTIME_DEBUG - printf("**** SWIG_InitializeModule: Cast List ******\n"); - for (i = 0; i < swig_module.size; ++i) { - int j = 0; - swig_cast_info *cast = swig_module.cast_initial[i]; - printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name); - while (cast->type) { - printf("SWIG_InitializeModule: cast type %s\n", cast->type->name); - cast++; - ++j; - } - printf("---- Total casts: %d\n",j); - } - printf("**** SWIG_InitializeModule: Cast List ******\n"); -#endif -} - -/* This function will propagate the clientdata field of type to -* any new swig_type_info structures that have been added into the list -* of equivalent types. It is like calling -* SWIG_TypeClientData(type, clientdata) a second time. -*/ -SWIGRUNTIME void -SWIG_PropagateClientData(void) { - size_t i; - swig_cast_info *equiv; - static int init_run = 0; - - if (init_run) return; - init_run = 1; - - for (i = 0; i < swig_module.size; i++) { - if (swig_module.types[i]->clientdata) { - equiv = swig_module.types[i]->cast; - while (equiv) { - if (!equiv->converter) { - if (equiv->type && !equiv->type->clientdata) - SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata); - } - equiv = equiv->next; - } - } - } -} - -#ifdef __cplusplus -#if 0 -{ /* c-mode */ -#endif -} -#endif - - - -/* Forward declaration of where the user's %init{} gets inserted */ -void SWIG_init_user(lua_State* L ); - -#ifdef __cplusplus -extern "C" { -#endif -/* this is the initialization function - added at the very end of the code - the function is always called SWIG_init, but an earlier #define will rename it -*/ -#if ((SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC)) -LUALIB_API int SWIG_init(lua_State* L) -#else -SWIGEXPORT int SWIG_init(lua_State* L) /* default Lua action */ -#endif -{ -#if (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC) /* valid for both Lua and eLua */ - int i; - int globalRegister = 0; - /* start with global table */ - lua_pushglobaltable (L); - /* SWIG's internal initialisation */ - SWIG_InitializeModule((void*)L); - SWIG_PropagateClientData(); -#endif - -#if ((SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUA) && (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC)) || defined(SWIG_LUA_ELUA_EMULATE) - /* add a global fn */ - SWIG_Lua_add_function(L,"swig_type",SWIG_Lua_type); - SWIG_Lua_add_function(L,"swig_equals",SWIG_Lua_class_equal); -#endif - -#if (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC) - /* set up base class pointers (the hierarchy) */ - for (i = 0; swig_types[i]; i++){ - if (swig_types[i]->clientdata){ - SWIG_Lua_init_base_class(L,(swig_lua_class*)(swig_types[i]->clientdata)); - } - } -#ifdef SWIG_LUA_MODULE_GLOBAL - globalRegister = 1; -#endif - - -#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_LUA) - SWIG_Lua_namespace_register(L,&swig_SwigModule, globalRegister); -#endif - -#if (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUA) || (SWIG_LUA_TARGET == SWIG_LUA_FLAVOR_ELUAC) - for (i = 0; swig_types[i]; i++){ - if (swig_types[i]->clientdata){ - SWIG_Lua_elua_class_register_instance(L,(swig_lua_class*)(swig_types[i]->clientdata)); - } - } -#endif - -#if defined(SWIG_LUA_ELUA_EMULATE) - lua_newtable(L); - SWIG_Lua_elua_emulate_register(L,swig_SwigModule.ns_methods); - SWIG_Lua_elua_emulate_register_clear(L); - if(globalRegister) { - lua_pushstring(L,swig_SwigModule.name); - lua_pushvalue(L,-2); - lua_rawset(L,-4); - } -#endif - -#endif - -#if (SWIG_LUA_TARGET != SWIG_LUA_FLAVOR_ELUAC) - /* invoke user-specific initialization */ - SWIG_init_user(L); - /* end module */ - /* Note: We do not clean up the stack here (Lua will do this for us). At this - point, we have the globals table and out module table on the stack. Returning - one value makes the module table the result of the require command. */ - return 1; -#else - return 0; -#endif -} - -#ifdef __cplusplus -} -#endif - - -const char* SWIG_LUACODE= - "\n" - "\n" - "-- this isn't wrapped correctly, so set it here\n" - "of.CLOSE = true\n" - "\n" - "-- handle typedefs which swig doesn't wrap\n" - "of.Point = of.Vec3f\n" - "\n" - "-- class.lua\n" - "-- Compatible with Lua 5.1 (not 5.0).\n" - "function class(base, __init)\n" - " local c = {} -- a new class instance\n" - " if not __init and type(base) == 'function' then\n" - " __init = base\n" - " base = nil\n" - " elseif type(base) == 'table' then\n" - " -- our new class is a shallow copy of the base class!\n" - " for i,v in pairs(base) do\n" - " c[i] = v\n" - " end\n" - " c._base = base\n" - " end\n" - " -- the class will be the metatable for all its objects,\n" - " -- and they will look up their methods in it.\n" - " c.__index = c\n" - "\n" - " -- expose a constructor which can be called by ()\n" - " local mt = {}\n" - " mt.__call = function(class_tbl, ...)\n" - " local obj = {}\n" - " setmetatable(obj,c)\n" - " if class_tbl.__init then\n" - " class_tbl.__init(obj,...)\n" - " else\n" - " -- make sure that any stuff from the base class is initialized!\n" - " if base and base.__init then\n" - " base.__init(obj, ...)\n" - " end\n" - " end\n" - " return obj\n" - " end\n" - " c.__init = __init\n" - " c.is_a = function(self, klass)\n" - " local m = getmetatable(self)\n" - " while m do\n" - " if m == klass then return true end\n" - " m = m._base\n" - " end\n" - " return false\n" - " end\n" - " setmetatable(c, mt)\n" - " return c\n" - "end"; - -void SWIG_init_user(lua_State* L) -{ - /* exec Lua code if applicable */ - SWIG_Lua_dostring(L,SWIG_LUACODE); -} - diff --git a/addons/ofxLua/src/bindings/ofxLuaBindings.h b/addons/ofxLua/src/bindings/ofBindings.h similarity index 98% rename from addons/ofxLua/src/bindings/ofxLuaBindings.h rename to addons/ofxLua/src/bindings/ofBindings.h index 67d8c42..b88c777 100644 --- a/addons/ofxLua/src/bindings/ofxLuaBindings.h +++ b/addons/ofxLua/src/bindings/ofBindings.h @@ -1,6 +1,6 @@ /* ---------------------------------------------------------------------------- * This file was automatically generated by SWIG (http://www.swig.org). - * Version 3.0.12 + * Version 4.0.1 * * This file is not intended to be easily readable and contains a number of * coding conventions designed to improve portability and efficiency. Do not make @@ -192,6 +192,7 @@ /* Flags for pointer conversions */ #define SWIG_POINTER_DISOWN 0x1 #define SWIG_CAST_NEW_MEMORY 0x2 +#define SWIG_POINTER_NO_NULL 0x4 /* Flags for new pointer objects */ #define SWIG_POINTER_OWN 0x1 @@ -902,8 +903,8 @@ typedef struct swig_elua_entry { * -------------------------------------------------------------------------- */ /* Push the string STR on the Lua stack, like lua_pushstring, but - prefixed with the the location of the innermost Lua call-point - (as formated by luaL_where). */ + prefixed with the location of the innermost Lua call-point + (as formatted by luaL_where). */ SWIGRUNTIME void SWIG_Lua_pusherrstring (lua_State *L, const char *str) { @@ -913,8 +914,8 @@ SWIG_Lua_pusherrstring (lua_State *L, const char *str) } /* Push a formatted string generated from FMT and following args on - the Lua stack, like lua_pushfstring, but prefixed with the the - location of the innermost Lua call-point (as formated by luaL_where). */ + the Lua stack, like lua_pushfstring, but prefixed with the + location of the innermost Lua call-point (as formatted by luaL_where). */ SWIGRUNTIME void SWIG_Lua_pushferrstring (lua_State *L, const char *fmt, ...) { @@ -1011,7 +1012,7 @@ to tell the two structures apart within SWIG, other than by looking at the type typedef struct { swig_type_info *type; int own; /* 1 if owned & must be destroyed */ - char data[1]; /* arbitary amount of data */ + char data[1]; /* arbitrary amount of data */ } swig_lua_rawdata; /* Common SWIG API */ @@ -1063,7 +1064,7 @@ typedef struct { #define SWIG_isptrtype(L,I) (lua_isuserdata(L,I) || lua_isnil(L,I)) #ifdef __cplusplus -/* Special helper for member function pointers +/* Special helper for member function pointers it gets the address, casts it, then dereferences it */ /*#define SWIG_mem_fn_as_voidptr(a) (*((char**)&(a))) */ #endif @@ -1166,7 +1167,7 @@ SWIGINTERN void SWIG_Lua_elua_emulate_register(lua_State *L, const swig_elua_ent lua_pop(L,1); /*remove nil */ lua_newtable(L); SWIG_Lua_elua_emulate_register(L,entry->value.value.table); - } + } if(is_metatable) { assert(lua_istable(L,-1)); lua_pushvalue(L,-1); @@ -1175,11 +1176,11 @@ SWIGINTERN void SWIG_Lua_elua_emulate_register(lua_State *L, const swig_elua_ent break; case LUA_TUSERDATA: - if(entry->value.value.userdata.member) + if(entry->value.value.userdata.member) SWIG_NewMemberObj(L,entry->value.value.userdata.pvalue, entry->value.value.userdata.lvalue, *(entry->value.value.userdata.ptype)); - else + else SWIG_NewPointerObj(L,entry->value.value.userdata.pvalue, *(entry->value.value.userdata.ptype),0); break; @@ -1224,7 +1225,7 @@ SWIGINTERN int SWIG_Lua_emulate_elua_getmetatable(lua_State *L) } assert(lua_gettop(L) == 2); return 1; - + fail: lua_error(L); return 0; @@ -1242,7 +1243,7 @@ SWIGINTERN void SWIG_Lua_emulate_elua_swap_getmetatable(lua_State *L) lua_pushcfunction(L, SWIG_Lua_emulate_elua_getmetatable); lua_rawset(L,-3); lua_pop(L,2); - + } /* END OF REMOVE */ @@ -1761,17 +1762,11 @@ SWIGINTERN int SWIG_Lua_class_tostring(lua_State *L) { /* there should be 1 param passed in (1) userdata (not the metatable) */ - const char *className; - void* userData; + swig_lua_userdata* userData; assert(lua_isuserdata(L,1)); /* just in case */ - userData = lua_touserdata(L,1); /* get the userdata address for later */ - lua_getmetatable(L,1); /* get the meta table */ - assert(lua_istable(L,-1)); /* just in case */ - - lua_getfield(L, -1, ".type"); - className = lua_tostring(L, -1); + userData = (swig_lua_userdata*)lua_touserdata(L,1); /* get the userdata address */ - lua_pushfstring(L, "<%s userdata: %p>", className, userData); + lua_pushfstring(L, "", userData->type->str, userData->ptr); return 1; } @@ -1783,7 +1778,7 @@ SWIGINTERN int SWIG_Lua_class_disown(lua_State *L) swig_lua_userdata *usr; assert(lua_isuserdata(L,-1)); /* just in case */ usr=(swig_lua_userdata*)lua_touserdata(L,-1); /* get it */ - + usr->own = 0; /* clear our ownership */ return 0; } @@ -1892,7 +1887,7 @@ SWIGINTERN void SWIG_Lua_get_class_metatable(lua_State *L,const char *cname) Each class structure has a list of pointers to the base class structures. This function fills them. It cannot be done at compile time, as this will not work with hireachies -spread over more than one swig file. +spread over more than one swig file. Therefore it must be done at runtime, querying the SWIG type system. */ SWIGINTERN void SWIG_Lua_init_base_class(lua_State *L,swig_lua_class *clss) @@ -2126,11 +2121,11 @@ SWIGRUNTIME int SWIG_Lua_resolve_metamethod(lua_State *L) lua_checkstack(L,5); numargs = lua_gettop(L); /* number of arguments to pass to actual metamethod */ - + /* Get upvalues from closure */ lua_pushvalue(L, lua_upvalueindex(1)); /*Get function name*/ metamethod_name_idx = lua_gettop(L); - + lua_pushvalue(L, lua_upvalueindex(2)); clss = (const swig_lua_class*)(lua_touserdata(L,-1)); lua_pop(L,1); /* remove lightuserdata with clss from stack */ @@ -2162,7 +2157,7 @@ SWIGINTERN int SWIG_Lua_add_class_user_metamethod(lua_State *L, swig_lua_class * /* metamethod name - on the top of the stack */ assert(lua_isstring(L,-1)); - + key_index = lua_gettop(L); /* Check whether method is already defined in metatable */ @@ -2172,7 +2167,7 @@ SWIGINTERN int SWIG_Lua_add_class_user_metamethod(lua_State *L, swig_lua_class * lua_pop(L,1); return -1; } - lua_pop(L,1); + lua_pop(L,1); /* Iterating over immediate bases */ for(i=0;clss->bases[i];i++) @@ -2182,13 +2177,13 @@ SWIGINTERN int SWIG_Lua_add_class_user_metamethod(lua_State *L, swig_lua_class * lua_pushvalue(L, key_index); lua_rawget(L, -2); if( !lua_isnil(L,-1) ) { - lua_pushvalue(L, key_index); + lua_pushvalue(L, key_index); /* Add proxy function */ lua_pushvalue(L, key_index); /* first closure value is function name */ lua_pushlightuserdata(L, clss); /* second closure value is swig_lua_class structure */ lua_pushcclosure(L, SWIG_Lua_resolve_metamethod, 2); - + lua_rawset(L, metatable_index); success = 1; } @@ -2199,7 +2194,7 @@ SWIGINTERN int SWIG_Lua_add_class_user_metamethod(lua_State *L, swig_lua_class * break; } - return success; + return success; } SWIGINTERN void SWIG_Lua_add_class_user_metamethods(lua_State *L, swig_lua_class *clss) @@ -2487,7 +2482,12 @@ SWIGRUNTIME int SWIG_Lua_ConvertPtr(lua_State *L,int index,void **ptr,swig_type { swig_lua_userdata *usr; swig_cast_info *cast; - if (lua_isnil(L,index)){*ptr=0; return SWIG_OK;} /* special case: lua nil => NULL pointer */ + /* special case: lua nil => NULL pointer */ + if (lua_isnil(L,index)) + { + *ptr=0; + return (flags & SWIG_POINTER_NO_NULL) ? SWIG_NullReferenceError : SWIG_OK; + } usr=(swig_lua_userdata*)lua_touserdata(L,index); /* get data */ if (usr) { @@ -2533,7 +2533,7 @@ SWIGRUNTIME void SWIG_Lua_NewPackedObj(lua_State *L,void *ptr,size_t size,swig_t memcpy(raw->data,ptr,size); /* copy the data */ SWIG_Lua_AddMetatable(L,type); /* add metatable */ } - + /* converts a packed userdata. user for member fn pointers only */ SWIGRUNTIME int SWIG_Lua_ConvertPacked(lua_State *L,int index,void *ptr,size_t size,swig_type_info *type) { @@ -2582,7 +2582,7 @@ SWIG_Lua_InstallConstants(lua_State *L, swig_lua_const_info constants[]) { switch(constants[i].type) { case SWIG_LUA_INT: lua_pushstring(L,constants[i].name); - lua_pushinteger(L,(lua_Number)constants[i].lvalue); + lua_pushinteger(L,(lua_Integer)constants[i].lvalue); lua_rawset(L,-3); break; case SWIG_LUA_FLOAT: @@ -2593,7 +2593,7 @@ SWIG_Lua_InstallConstants(lua_State *L, swig_lua_const_info constants[]) { case SWIG_LUA_CHAR: lua_pushstring(L,constants[i].name); { - char c = constants[i].lvalue; + char c = (char)constants[i].lvalue; lua_pushlstring(L,&c,1); } lua_rawset(L,-3); @@ -2632,7 +2632,7 @@ Unfortunately lua keeps changing its APIs, so we need a conditional compile In lua 5.0.X it's lua_dostring() In lua 5.1.X it's luaL_dostring() */ -SWIGINTERN int +SWIGINTERN int SWIG_Lua_dostring(lua_State *L, const char *str) { int ok,top; if (str==0 || str[0]==0) return 0; /* nothing to do */ @@ -2647,7 +2647,7 @@ SWIG_Lua_dostring(lua_State *L, const char *str) { } lua_settop(L,top); /* restore the stack */ return ok; -} +} #ifdef __cplusplus } diff --git a/addons/ofxLua/src/ofxLua.cpp b/addons/ofxLua/src/ofxLua.cpp index 8bb7a81..b9fb10e 100644 --- a/addons/ofxLua/src/ofxLua.cpp +++ b/addons/ofxLua/src/ofxLua.cpp @@ -17,8 +17,7 @@ #include "ofxLua.h" #include "ofUtils.h" -#include "ofxLuaBindings.h" -#include + // macro for chdir() as Windows uses a protected variant #ifdef TARGET_WIN32 @@ -29,6 +28,8 @@ #endif #include +#include "ofBindings.h" + // declare the wrapped modules extern "C" { int luaopen_of(lua_State* L); @@ -104,7 +105,7 @@ void ofxLua::setAbortOnError(bool abort) { } //------------------------------------------------------------------------------ -bool ofxLua::doString(const string& text) { +bool ofxLua::doString(const std::string& text) { if(!isValid()) { ofLogError("ofxLua") << "Cannot do string, lua state not inited!"; @@ -123,12 +124,12 @@ bool ofxLua::doString(const string& text) { if(ret != 0) { switch(ret) { case LUA_ERRSYNTAX: { - string msg = (string) lua_tostring(L, LUA_STACK_TOP); + std::string msg = (std::string) lua_tostring(L, LUA_STACK_TOP); errorOccurred(msg); break; } case LUA_ERRMEM: { - string msg = "Memory error", + std::string msg = "Memory error", errorOccurred(msg); break; } @@ -140,7 +141,7 @@ bool ofxLua::doString(const string& text) { // run the string ret = lua_pcall(L, 0, LUA_MULTRET, 0); if(ret != 0) { - string msg = (string) lua_tostring(L, LUA_STACK_TOP); + std::string msg = (std::string) lua_tostring(L, LUA_STACK_TOP); errorOccurred(msg); return false; } @@ -149,21 +150,21 @@ bool ofxLua::doString(const string& text) { } //------------------------------------------------------------------------------ -bool ofxLua::doScript(const string& script, bool changeDir) { +bool ofxLua::doScript(const std::string& script, bool changeDir) { if(!isValid()) { ofLogError("ofxLua") << "Cannot do script, lua state not inited!"; return false; } - string fullpath = ofFilePath::getAbsolutePath(ofToDataPath(script)); - string file = ofFilePath::getFileName(fullpath); - string folder = ofFilePath::getEnclosingDirectory(fullpath); - - cout << "fullpath " << fullpath << endl; - cout << "file " << file << endl; - cout << "folder " << folder << endl; + std::string fullpath = ofFilePath::getAbsolutePath(ofToDataPath(script)); + std::string file = ofFilePath::getFileName(fullpath); + std::string folder = ofFilePath::getEnclosingDirectory(fullpath); + std::cout << "fullpath " << fullpath << std::endl; + std::cout << "file " << file << std::endl; + std::cout << "folder " << folder << std::endl; + // trim trailing slash if(folder.size() > 0 && folder.at(folder.size()-1) == '/') { folder.erase(folder.end()-1); @@ -192,17 +193,17 @@ bool ofxLua::doScript(const string& script, bool changeDir) { if(ret != 0) { switch(ret) { case LUA_ERRFILE: { - string msg = (string)"Script \""+file+"\" not found or unreadable"; + std::string msg = (std::string)"Script \""+file+"\" not found or unreadable"; errorOccurred(msg); break; } case LUA_ERRSYNTAX: { - string msg = (string) lua_tostring(L, LUA_STACK_TOP); + std::string msg = (std::string) lua_tostring(L, LUA_STACK_TOP); errorOccurred(msg); break; } case LUA_ERRMEM: { - string msg = "Memory error for script \""+file+"\""; + std::string msg = "Memory error for script \""+file+"\""; errorOccurred(msg); break; } @@ -212,7 +213,7 @@ bool ofxLua::doScript(const string& script, bool changeDir) { // run the script if(lua_pcall(L, 0, LUA_MULTRET, 0) != 0) { - string msg = (string) lua_tostring(L, LUA_STACK_TOP); + std::string msg = (std::string) lua_tostring(L, LUA_STACK_TOP); errorOccurred(msg); return false; } @@ -237,7 +238,7 @@ void ofxLua::scriptSetup() { } lua_getglobal(L, "setup"); if(lua_pcall(L, 0, 0, 0) != 0) { - string msg = "Error running setup(): " + (string) lua_tostring(L, LUA_STACK_TOP); + std::string msg = "Error running setup(): " + (std::string) lua_tostring(L, LUA_STACK_TOP); errorOccurred(msg); } } @@ -248,7 +249,7 @@ void ofxLua::scriptUpdate() { } lua_getglobal(L, "update"); if(lua_pcall(L, 0, 0, 0) != 0) { - string msg = "Error running update(): " + (string) lua_tostring(L, LUA_STACK_TOP); + std::string msg = "Error running update(): " + (std::string) lua_tostring(L, LUA_STACK_TOP); errorOccurred(msg); } } @@ -259,7 +260,7 @@ void ofxLua::scriptDraw() { } lua_getglobal(L, "draw"); if(lua_pcall(L, 0, 0, 0) != 0) { - string msg = "Error running draw(): " + (string) lua_tostring(L, LUA_STACK_TOP); + std::string msg = "Error running draw(): " + (std::string) lua_tostring(L, LUA_STACK_TOP); errorOccurred(msg); } } @@ -270,7 +271,7 @@ void ofxLua::scriptDrawFBO() { } lua_getglobal(L, "drawFBO"); if(lua_pcall(L, 0, 0, 0) != 0) { - string msg = "Error running drawFBO(): " + (string) lua_tostring(L, LUA_STACK_TOP); + std::string msg = "Error running drawFBO(): " + (std::string) lua_tostring(L, LUA_STACK_TOP); errorOccurred(msg); } } @@ -282,7 +283,7 @@ void ofxLua::scriptDrawUI() { } lua_getglobal(L, "drawUI"); if(lua_pcall(L, 0, 0, 0) != 0) { - string msg = "Error running drawUI(): " + (string) lua_tostring(L, LUA_STACK_TOP); + std::string msg = "Error running drawUI(): " + (std::string) lua_tostring(L, LUA_STACK_TOP); errorOccurred(msg); } } @@ -293,7 +294,7 @@ void ofxLua::scriptExit() { } lua_getglobal(L, "exit"); if(lua_pcall(L, 0, 0, 0) != 0) { - string msg = "Error running exit(): " + (string) lua_tostring(L, LUA_STACK_TOP); + std::string msg = "Error running exit(): " + (std::string) lua_tostring(L, LUA_STACK_TOP); errorOccurred(msg); } } @@ -307,8 +308,8 @@ void ofxLua::scriptWindowResized(int w, int h) { lua_pushinteger(L, w); lua_pushinteger(L, h); if(lua_pcall(L, 2, 0, 0) != 0) { - string msg = "Error running windowResized(): " - + (string) lua_tostring(L, LUA_STACK_TOP); + std::string msg = "Error running windowResized(): " + + (std::string) lua_tostring(L, LUA_STACK_TOP); errorOccurred(msg); } } @@ -320,8 +321,8 @@ void ofxLua::scriptKeyPressed(int key) { lua_getglobal(L, "keyPressed"); lua_pushinteger(L, key); if(lua_pcall(L, 1, 0, 0) != 0) { - string msg = "Error running keyPressed(): " - + (string) lua_tostring(L, LUA_STACK_TOP); + std::string msg = "Error running keyPressed(): " + + (std::string) lua_tostring(L, LUA_STACK_TOP); errorOccurred(msg); } } @@ -333,8 +334,8 @@ void ofxLua::scriptKeyReleased(int key) { lua_getglobal(L, "keyReleased"); lua_pushinteger(L, key); if(lua_pcall(L, 1, 0, 0) != 0) { - string msg = "Error running keyReleased(): " - + (string) lua_tostring(L, LUA_STACK_TOP); + std::string msg = "Error running keyReleased(): " + + (std::string) lua_tostring(L, LUA_STACK_TOP); errorOccurred(msg); } } @@ -347,8 +348,8 @@ void ofxLua::scriptMouseMoved(int x, int y ) { lua_pushinteger(L, x); lua_pushinteger(L, y); if(lua_pcall(L, 2, 0, 0) != 0) { - string msg = "Error running mouseMoved(): " - + (string) lua_tostring(L, LUA_STACK_TOP); + std::string msg = "Error running mouseMoved(): " + + (std::string) lua_tostring(L, LUA_STACK_TOP); errorOccurred(msg); } } @@ -362,8 +363,8 @@ void ofxLua::scriptMouseDragged(int x, int y, int button) { lua_pushinteger(L, y); lua_pushinteger(L, button); if(lua_pcall(L, 3, 0, 0) != 0) { - string msg = "Error running mouseDragged(): " - + (string) lua_tostring(L, LUA_STACK_TOP); + std::string msg = "Error running mouseDragged(): " + + (std::string) lua_tostring(L, LUA_STACK_TOP); errorOccurred(msg); } } @@ -377,8 +378,8 @@ void ofxLua::scriptMousePressed(int x, int y, int button) { lua_pushinteger(L, y); lua_pushinteger(L, button); if(lua_pcall(L, 3, 0, 0) != 0) { - string msg = "Error running mousePressed(): " - + (string) lua_tostring(L, LUA_STACK_TOP); + std::string msg = "Error running mousePressed(): " + + (std::string) lua_tostring(L, LUA_STACK_TOP); errorOccurred(msg); } } @@ -392,8 +393,8 @@ void ofxLua::scriptMouseReleased(int x, int y, int button) { lua_pushinteger(L, y); lua_pushinteger(L, button); if(lua_pcall(L, 3, 0, 0) != 0) { - string msg = "Error running mouseReleased(): " - + (string) lua_tostring(L, LUA_STACK_TOP); + std::string msg = "Error running mouseReleased(): " + + (std::string) lua_tostring(L, LUA_STACK_TOP); errorOccurred(msg); } } @@ -408,8 +409,8 @@ void ofxLua::scriptMouseScrolled(int x, int y, float scrollX, float scrollY) { lua_pushnumber(L, scrollX); lua_pushnumber(L, scrollY); if(lua_pcall(L, 4, 0, 0) != 0) { - string msg = "Error running mouseScrolled(): " - + (string) lua_tostring(L, LUA_STACK_TOP); + std::string msg = "Error running mouseScrolled(): " + + (std::string) lua_tostring(L, LUA_STACK_TOP); errorOccurred(msg); } } @@ -422,8 +423,8 @@ void ofxLua::scriptMouseEntered(int x, int y) { lua_pushinteger(L, x); lua_pushinteger(L, y); if(lua_pcall(L, 2, 0, 0) != 0) { - string msg = "Error running mouseEntered(): " - + (string) lua_tostring(L, LUA_STACK_TOP); + std::string msg = "Error running mouseEntered(): " + + (std::string) lua_tostring(L, LUA_STACK_TOP); errorOccurred(msg); } } @@ -436,8 +437,8 @@ void ofxLua::scriptMouseExited(int x, int y) { lua_pushinteger(L, x); lua_pushinteger(L, y); if(lua_pcall(L, 2, 0, 0) != 0) { - string msg = "Error running mouseExited(): " - + (string) lua_tostring(L, LUA_STACK_TOP); + std::string msg = "Error running mouseExited(): " + + (std::string) lua_tostring(L, LUA_STACK_TOP); errorOccurred(msg); } } @@ -450,8 +451,8 @@ void ofxLua::scriptDragEvent(ofDragInfo dragInfo) { lua_getglobal(L, "dragEvent"); pushobject("ofDragInfo", new ofDragInfo(dragInfo)); // lua manages this memory if(lua_pcall(L, 1, 0, 0) != 0) { - string msg = "Error running dragInfo(): " - + (string) lua_tostring(L, LUA_STACK_TOP); + std::string msg = "Error running dragInfo(): " + + (std::string) lua_tostring(L, LUA_STACK_TOP); errorOccurred(msg); } } @@ -463,8 +464,8 @@ void ofxLua::scriptGotMessage(ofMessage msg) { lua_getglobal(L, "gotMessage"); lua_pushstring(L, msg.message.c_str()); if(lua_pcall(L, 1, 0, 0) != 0) { - string msg = "Error running gotMessage(): " - + (string) lua_tostring(L, LUA_STACK_TOP); + std::string msg = "Error running gotMessage(): " + + (std::string) lua_tostring(L, LUA_STACK_TOP); errorOccurred(msg); } } @@ -477,8 +478,8 @@ void ofxLua::scriptTouchDown(ofTouchEventArgs &touch) { lua_getglobal(L, "touchDown"); pushobject("ofTouchEventArgs", new ofTouchEventArgs(touch)); // lua manages this memory if(lua_pcall(L, 1, 0, 0) != 0) { - string msg = "Error running touchDown(): " - + (string) lua_tostring(L, LUA_STACK_TOP); + std::string msg = "Error running touchDown(): " + + (std::string) lua_tostring(L, LUA_STACK_TOP); errorOccurred(msg); } } @@ -490,8 +491,8 @@ void ofxLua::scriptTouchMoved(ofTouchEventArgs &touch) { lua_getglobal(L, "touchMoved"); pushobject("ofTouchEventArgs", new ofTouchEventArgs(touch)); // lua manages this memory if(lua_pcall(L, 1, 0, 0) != 0) { - string msg = "Error running touchMoved(): " - + (string) lua_tostring(L, LUA_STACK_TOP); + std::string msg = "Error running touchMoved(): " + + (std::string) lua_tostring(L, LUA_STACK_TOP); errorOccurred(msg); } } @@ -503,8 +504,8 @@ void ofxLua::scriptTouchUp(ofTouchEventArgs &touch) { lua_getglobal(L, "touchUp"); pushobject("ofTouchEventArgs", new ofTouchEventArgs(touch)); // lua manages this memory if(lua_pcall(L, 1, 0, 0) != 0) { - string msg = "Error running touchUp(): " - + (string) lua_tostring(L, LUA_STACK_TOP); + std::string msg = "Error running touchUp(): " + + (std::string) lua_tostring(L, LUA_STACK_TOP); errorOccurred(msg); } } @@ -516,8 +517,8 @@ void ofxLua::scriptTouchDoubleTap(ofTouchEventArgs &touch) { lua_getglobal(L, "touchDoubleTap"); pushobject("ofTouchEventArgs", new ofTouchEventArgs(touch)); // lua manages this memory if(lua_pcall(L, 1, 0, 0) != 0) { - string msg = "Error running touchDoubleTap(): " - + (string) lua_tostring(L, LUA_STACK_TOP); + std::string msg = "Error running touchDoubleTap(): " + + (std::string) lua_tostring(L, LUA_STACK_TOP); errorOccurred(msg); } } @@ -529,14 +530,14 @@ void ofxLua::scriptTouchCancelled(ofTouchEventArgs &touch) { lua_getglobal(L, "touchCancelled"); pushobject("ofTouchEventArgs", new ofTouchEventArgs(touch)); // lua manages this memory if(lua_pcall(L, 1, 0, 0) != 0) { - string msg = "Error running touchCancelled(): " - + (string) lua_tostring(L, LUA_STACK_TOP); + std::string msg = "Error running touchCancelled(): " + + (std::string) lua_tostring(L, LUA_STACK_TOP); errorOccurred(msg); } } //------------------------------------------------------------------------------ -bool ofxLua::isBool(const string& name) { +bool ofxLua::isBool(const std::string& name) { return exists(name, LUA_TBOOLEAN); } @@ -544,7 +545,7 @@ bool ofxLua::isBool(const unsigned int index) { return exists(index, LUA_TBOOLEAN); } -bool ofxLua::isNumber(const string& name) { +bool ofxLua::isNumber(const std::string& name) { return exists(name, LUA_TNUMBER); } @@ -552,7 +553,7 @@ bool ofxLua::isNumber(const unsigned int index) { return exists(index, LUA_TNUMBER); } -bool ofxLua::isString(const string& name) { +bool ofxLua::isString(const std::string& name) { return exists(name, LUA_TSTRING); } @@ -560,7 +561,7 @@ bool ofxLua::isString(const unsigned int index) { return exists(index, LUA_TSTRING); } -bool ofxLua::isFunction(const string& name) { +bool ofxLua::isFunction(const std::string& name) { return exists(name, LUA_TFUNCTION); } @@ -568,7 +569,7 @@ bool ofxLua::isFunction(const unsigned int index) { return exists(index, LUA_TFUNCTION); } -bool ofxLua::isTable(const string& name) { +bool ofxLua::isTable(const std::string& name) { return exists(name, LUA_TTABLE); } @@ -576,7 +577,7 @@ bool ofxLua::isTable(const unsigned int index) { return exists(index, LUA_TTABLE); } -bool ofxLua::isNil(const string& name) { +bool ofxLua::isNil(const std::string& name) { return exists(name, LUA_TNIL); } @@ -585,7 +586,7 @@ bool ofxLua::isNil(const unsigned int index) { } //------------------------------------------------------------------------------ -void ofxLua::newTable(const string& tableName) { +void ofxLua::newTable(const std::string& tableName) { if(!isValid()) { return; } @@ -620,7 +621,7 @@ void ofxLua::newTable(const unsigned int& tableIndex) { lua_settable(L, -3); } -bool ofxLua::pushTable(const string& tableName) { +bool ofxLua::pushTable(const std::string& tableName) { if(!isValid()) { return false; } @@ -708,7 +709,7 @@ unsigned int ofxLua::tableSize() { return lua_rawlen(L, LUA_STACK_TOP); } -unsigned int ofxLua::tableSize(const string& tableName) { +unsigned int ofxLua::tableSize(const std::string& tableName) { unsigned int size = 0; pushTable(tableName); size = tableSize(); @@ -742,11 +743,11 @@ void ofxLua::printTable() { return; } - ofLogNotice("ofxLua") << "table " << (string)tables.back(); + ofLogNotice("ofxLua") << "table " << (std::string)tables.back(); printTable(LUA_STACK_TOP, 1); } -void ofxLua::printTable(const string& tableName) { +void ofxLua::printTable(const std::string& tableName) { if(!pushTable(tableName)) { return; } @@ -793,7 +794,7 @@ void ofxLua::clearTable() { lua_pop(L, 1); // stack: } -void ofxLua::clearTable(const string& tableName) { +void ofxLua::clearTable(const std::string& tableName) { if(!pushTable(tableName)) { return; } @@ -810,7 +811,7 @@ void ofxLua::clearTable(const unsigned int& tableIndex) { } //------------------------------------------------------------------------------ -bool ofxLua::getBool(const string& name, bool defaultValue) { +bool ofxLua::getBool(const std::string& name, bool defaultValue) { return read(name, LUA_TBOOLEAN, defaultValue); } @@ -818,7 +819,7 @@ bool ofxLua::getBool(const unsigned int index, bool defaultValue) { return read(index, LUA_TBOOLEAN, defaultValue); } -lua_Number ofxLua::getNumber(const string& name, lua_Number defaultValue) { +lua_Number ofxLua::getNumber(const std::string& name, lua_Number defaultValue) { return read(name, LUA_TNUMBER, defaultValue); } @@ -826,40 +827,40 @@ lua_Number ofxLua::getNumber(const unsigned int index, lua_Number defaultValue) return read(index, LUA_TNUMBER, defaultValue); } -string ofxLua::getString(const string& name, const string& defaultValue) { - return read(name, LUA_TSTRING, defaultValue); +std::string ofxLua::getString(const std::string& name, const std::string& defaultValue) { + return read(name, LUA_TSTRING, defaultValue); } -string ofxLua::getString(const unsigned int index, const string& defaultValue) { - return read(index, LUA_TSTRING, defaultValue); +std::string ofxLua::getString(const unsigned int index, const std::string& defaultValue) { + return read(index, LUA_TSTRING, defaultValue); } -void ofxLua::getBoolVector(const string& tableName, vector& v) { +void ofxLua::getBoolVector(const std::string& tableName, std::vector& v) { readVector(tableName, v, LUA_TBOOLEAN, false); } -void ofxLua::getBoolVector(const unsigned int tableIndex, vector& v) { +void ofxLua::getBoolVector(const unsigned int tableIndex, std::vector& v) { readVector(tableIndex, v, LUA_TBOOLEAN, false); } -void ofxLua::getNumberVector(const string& tableName, vector& v) { +void ofxLua::getNumberVector(const std::string& tableName, std::vector& v) { readVector(tableName, v, LUA_TNUMBER, 0.0f); } -void ofxLua::getNumberVector(const unsigned int tableIndex, vector& v) { +void ofxLua::getNumberVector(const unsigned int tableIndex, std::vector& v) { readVector(tableIndex, v, LUA_TNUMBER, 0.0f); } -void ofxLua::getStringVector(const string& tableName, vector& v) { - readVector(tableName, v, LUA_TSTRING, ""); +void ofxLua::getStringVector(const std::string& tableName, std::vector& v) { + readVector(tableName, v, LUA_TSTRING, ""); } -void ofxLua::getStringVector(const unsigned int tableIndex, vector& v) { - readVector(tableIndex, v, LUA_TSTRING, ""); +void ofxLua::getStringVector(const unsigned int tableIndex, std::vector& v) { + readVector(tableIndex, v, LUA_TSTRING, ""); } //------------------------------------------------------------------------------ -void ofxLua::setBool(const string& name, bool value) { +void ofxLua::setBool(const std::string& name, bool value) { write(name, LUA_TBOOLEAN, value); } @@ -867,7 +868,7 @@ void ofxLua::setBool(const unsigned int index, bool value) { write(index, LUA_TBOOLEAN, value); } -void ofxLua::setNumber(const string& name, lua_Number value) { +void ofxLua::setNumber(const std::string& name, lua_Number value) { write(name, LUA_TNUMBER, value); } @@ -875,39 +876,39 @@ void ofxLua::setNumber(const unsigned int index, lua_Number value) { write(index, LUA_TNUMBER, value); } -void ofxLua::setString(const string& name, const string value) { - write(name, LUA_TSTRING, value); +void ofxLua::setString(const std::string& name, const std::string value) { + write(name, LUA_TSTRING, value); } -void ofxLua::setString(const unsigned int index, const string value) { - write(index, LUA_TSTRING, value); +void ofxLua::setString(const unsigned int index, const std::string value) { + write(index, LUA_TSTRING, value); } -void ofxLua::setBoolVector(const string& tableName, vector& v) { +void ofxLua::setBoolVector(const std::string& tableName, std::vector& v) { writeVector(tableName, LUA_TBOOLEAN, v); } -void ofxLua::setBoolVector(const unsigned int tableIndex, vector& v) { +void ofxLua::setBoolVector(const unsigned int tableIndex, std::vector& v) { writeVector(tableIndex, LUA_TBOOLEAN, v); } -void ofxLua::setNumberVector(const string& tableName, vector& v) { +void ofxLua::setNumberVector(const std::string& tableName, std::vector& v) { writeVector(tableName, LUA_TNUMBER, v); } -void ofxLua::setNumberVector(const unsigned int tableIndex, vector& v) { +void ofxLua::setNumberVector(const unsigned int tableIndex, std::vector& v) { writeVector(tableIndex, LUA_TNUMBER, v); } -void ofxLua::setStringVector(const string& tableName, vector& v) { - writeVector(tableName, LUA_TSTRING, v); +void ofxLua::setStringVector(const std::string& tableName, std::vector& v) { + writeVector(tableName, LUA_TSTRING, v); } -void ofxLua::setStringVector(const unsigned int tableIndex, vector& v) { - writeVector(tableIndex, LUA_TSTRING, v); +void ofxLua::setStringVector(const unsigned int tableIndex, std::vector& v) { + writeVector(tableIndex, LUA_TSTRING, v); } -void ofxLua::setNil(const string& name) { +void ofxLua::setNil(const std::string& name) { if(!isValid()) { return; } @@ -968,7 +969,7 @@ void ofxLua::writeTable(ofxLuaFileWriter& writer, bool recursive) { // in a table namespace if(!lua_istable(L, LUA_STACK_TOP)) { - ofLogWarning("ofxLua") << "Couldn't write table \"" << (string)tables.back() + ofLogWarning("ofxLua") << "Couldn't write table \"" << (std::string)tables.back() << "\", top of stack is not a table"; return; } @@ -976,7 +977,7 @@ void ofxLua::writeTable(ofxLuaFileWriter& writer, bool recursive) { writeTable(LUA_STACK_TOP, writer, recursive); } -void ofxLua::writeTable(const string& tableName, ofxLuaFileWriter& writer, bool recursive) { +void ofxLua::writeTable(const std::string& tableName, ofxLuaFileWriter& writer, bool recursive) { if(!pushTable(tableName)) { return; } @@ -986,20 +987,20 @@ void ofxLua::writeTable(const string& tableName, ofxLuaFileWriter& writer, bool popTable(); } -bool ofxLua::writeTableToFile(const string& filename, bool recursive) { +bool ofxLua::writeTableToFile(const std::string& filename, bool recursive) { ofxLuaFileWriter writer; writeTable(writer, recursive); return writer.saveToFile(filename); } -bool ofxLua::writeTableToFile(const string& tableName, const string& filename, bool recursive) { +bool ofxLua::writeTableToFile(const std::string& tableName, const std::string& filename, bool recursive) { ofxLuaFileWriter writer; writeTable(tableName, writer, recursive); return writer.saveToFile(filename); } //------------------------------------------------------------------------------ -void ofxLua::errorOccurred(string& msg) { +void ofxLua::errorOccurred(std::string& msg) { errorMessage = msg; @@ -1017,8 +1018,8 @@ void ofxLua::printStack() { if(!isValid()) { return; } - - stringstream line; + + std::stringstream line; line << "stack " << lua_gettop(L); int top = lua_gettop(L); @@ -1055,8 +1056,8 @@ void ofxLua::printStack() { // push object pointer to Lua using SWIG helper function, // from http://stackoverflow.com/questions/9455552/swiglua-passing-a-c-instance-as-a-lua-function-parameter -bool ofxLua::pushobject(const string &typeName, void *object, bool manageMemory) { - string typeString = typeName + " *"; +bool ofxLua::pushobject(const std::string &typeName, void *object, bool manageMemory) { + std::string typeString = typeName + " *"; swig_type_info *type = SWIG_TypeQuery(L, typeString.c_str()); if(type == NULL) { return false; @@ -1093,7 +1094,7 @@ template<> lua_Number ofxLua::totype(int stackIndex, int type, lua_N } } -template<> string ofxLua::totype(int stackIndex, int type, string defaultValue) { +template<> std::string ofxLua::totype(int stackIndex, int type, std::string defaultValue) { if(lua_type(L, stackIndex) != type) { return defaultValue; } @@ -1106,14 +1107,14 @@ template<> string ofxLua::totype(int stackIndex, int type, string defaul } //------------------------------------------------------------------------------ -template <> void ofxLua::settype(const string& name, int type, bool value) { +template<> void ofxLua::settype(const std::string& name, int type, bool value) { if(type == LUA_TBOOLEAN) { lua_pushboolean(L, value); lua_setfield(L, -2, name.c_str()); } } -template <> void ofxLua::settype(unsigned int index, int type, bool value) { +template<> void ofxLua::settype(unsigned int index, int type, bool value) { if(type == LUA_TBOOLEAN) { lua_pushinteger(L, index); lua_pushboolean(L, value); @@ -1121,14 +1122,14 @@ template <> void ofxLua::settype(unsigned int index, int type, bool value) } } -template <> void ofxLua::settype(const string& name, int type, lua_Number value) { +template<> void ofxLua::settype(const std::string& name, int type, lua_Number value) { if(type == LUA_TNUMBER) { lua_pushnumber(L, value); lua_setfield(L, -2, name.c_str()); } } -template <> void ofxLua::settype(unsigned int index, int type, lua_Number value) { +template<> void ofxLua::settype(unsigned int index, int type, lua_Number value) { if(type == LUA_TNUMBER) { lua_pushinteger(L, index); lua_pushnumber(L, value); @@ -1136,14 +1137,14 @@ template <> void ofxLua::settype(unsigned int index, int type, lua_N } } -template <> void ofxLua::settype(const string& name, int type, string value) { +template<> void ofxLua::settype(const std::string& name, int type, std::string value) { if(type == LUA_TSTRING) { lua_pushstring(L, value.c_str()); lua_setfield(L, -2, name.c_str()); } } -template <> void ofxLua::settype(unsigned int index, int type, string value) { +template<> void ofxLua::settype(unsigned int index, int type, std::string value) { if(type == LUA_TSTRING) { lua_pushinteger(L, index); lua_pushstring(L, value.c_str()); @@ -1152,7 +1153,7 @@ template <> void ofxLua::settype(unsigned int index, int type, string va } //------------------------------------------------------------------------------ -bool ofxLua::exists(const string& name, int type) { +bool ofxLua::exists(const std::string& name, int type) { if(!isValid()) { return false; } @@ -1220,15 +1221,15 @@ bool ofxLua::checkType(int stackIndex, int type) { // from http://stackoverflow.com/questions/6137684/iterate-through-lua-table void ofxLua::printTable(int stackIndex, int numTabs) { - string tabs; + std::string tabs; for(int i = 0; i < numTabs; ++i) { tabs += "\t"; } lua_pushvalue(L, stackIndex); // stack: -1 => table lua_pushnil(L); // stack : -2 => table; -1 => nil - - stringstream line; + + std::stringstream line; while(lua_next(L, -2)) { // stack: -3 => table; -2 => key; -1 => value @@ -1236,7 +1237,7 @@ void ofxLua::printTable(int stackIndex, int numTabs) { // stack: -4 => table; -3 => key; -2 => value; -1 => key // ignore global, packages, etc - string name = (string) lua_tostring(L, -1); + std::string name = (std::string) lua_tostring(L, -1); if(name == "_G" || name == "package") { line.str(""); lua_pop(L, 2); @@ -1244,7 +1245,7 @@ void ofxLua::printTable(int stackIndex, int numTabs) { } // print value type and key - line << tabs << (string) lua_typename(L, lua_type(L, -2)) << " " << name; + line << tabs << (std::string) lua_typename(L, lua_type(L, -2)) << " " << name; // recurse if a table if(lua_istable(L, -2)) { @@ -1280,8 +1281,8 @@ void ofxLua::writeTable(int stackIndex, ofxLuaFileWriter& writer, bool recursive lua_pushvalue(L, stackIndex); // stack: -1 => table lua_pushnil(L); // stack: -2 => table; -1 => nil - - stringstream line; + + std::stringstream line; while(lua_next(L, -2)) { // stack: -3 => table; -2 => key; -1 => value @@ -1308,7 +1309,7 @@ void ofxLua::writeTable(int stackIndex, ofxLuaFileWriter& writer, bool recursive writer.writeBool(lua_tonumber(L, -1), (bool)lua_toboolean(L, -2)); } else if(lua_isstring(L, -1)) { - writer.writeBool((string) lua_tostring(L, -1), (bool)lua_toboolean(L, -2)); + writer.writeBool((std::string) lua_tostring(L, -1), (bool)lua_toboolean(L, -2)); } else { ofLogWarning("ofxLua") << "unknown key type when writing table"; @@ -1319,7 +1320,7 @@ void ofxLua::writeTable(int stackIndex, ofxLuaFileWriter& writer, bool recursive writer.writeNumber(lua_tonumber(L, -1), lua_tonumber(L, -2)); } else if(lua_isstring(L, -1)) { - writer.writeNumber((string) lua_tostring(L, -1), lua_tonumber(L, -2)); + writer.writeNumber((std::string) lua_tostring(L, -1), lua_tonumber(L, -2)); } else { ofLogWarning("ofxLua") << "unknown key type when writing table"; @@ -1330,7 +1331,7 @@ void ofxLua::writeTable(int stackIndex, ofxLuaFileWriter& writer, bool recursive writer.writeString(lua_tonumber(L, -1), lua_tostring(L, -2)); } else if(lua_isstring(L, -1)) { - writer.writeString((string) lua_tostring(L, -1), lua_tostring(L, -2)); + writer.writeString((std::string) lua_tostring(L, -1), lua_tostring(L, -2)); } else { ofLogWarning("ofxLua") << "unknown key type when writing table"; diff --git a/addons/ofxLua/src/ofxLua.h b/addons/ofxLua/src/ofxLua.h index fa11292..23f769f 100644 --- a/addons/ofxLua/src/ofxLua.h +++ b/addons/ofxLua/src/ofxLua.h @@ -33,7 +33,7 @@ class ofxLuaListener { public : - virtual void errorReceived(string& msg) = 0; + virtual void errorReceived(std::string& msg) = 0; }; /// a Lua interpreter instance @@ -81,7 +81,7 @@ class ofxLua { /// \section Running Lua code /// run a lua string, returns false on script error - bool doString(const string& text); + bool doString(const std::string& text); /// run a lua script, returns false on script error /// @@ -90,7 +90,7 @@ class ofxLua { /// cannot find local scripts /// /// note: changeDir does not affect the current OF data path - bool doScript(const string& script, bool changeDir=false); + bool doScript(const std::string& script, bool changeDir=false); /// \section Listeners @@ -110,8 +110,9 @@ class ofxLua { void scriptSetup(); void scriptUpdate(); void scriptDraw(); - void scriptDrawFBO(); - void scriptDrawUI(); + void scriptDrawFBO(); + void scriptDrawUI(); + void scriptExit(); void scriptWindowResized(int w, int h); @@ -141,35 +142,35 @@ class ofxLua { /// /// note: pushTable must have been called when using the table index - bool isBool(const string& name); + bool isBool(const std::string& name); bool isBool(const unsigned int index); - bool isNumber(const string& name); + bool isNumber(const std::string& name); bool isNumber(const unsigned int index); - bool isString(const string& name); + bool isString(const std::string& name); bool isString(const unsigned int index); - bool isFunction(const string& name); + bool isFunction(const std::string& name); bool isFunction(const unsigned int index); - bool isTable(const string& name); + bool isTable(const std::string& name); bool isTable(const unsigned int index); /// check explictly if something *dosen't* exist /// /// nil is the lua equivalent of NULL - bool isNil(const string& name); + bool isNil(const std::string& name); bool isNil(const unsigned int index); /// \section Table Operations /// create a new table - void newTable(const string& tableName); + void newTable(const std::string& tableName); void newTable(const unsigned int& tableIndex); // must pushTable first /// push table one level - bool pushTable(const string& tableName); + bool pushTable(const std::string& tableName); bool pushTable(const unsigned int& tableIndex); // must pushTable first void popTable(); //< pop table one level void popAllTables(); //< pop all table levels @@ -177,17 +178,17 @@ class ofxLua { /// get the size of a table /// undefined if the table is not a sequence aka has a nil value somewhere unsigned int tableSize(); //< current table - unsigned int tableSize(const string& tableName); //< table in current table + unsigned int tableSize(const std::string& tableName); //< table in current table unsigned int tableSize(const unsigned int& tableIndex); //< table in current table /// print a table void printTable(); //< current table - void printTable(const string& tableName); //< table in current table + void printTable(const std::string& tableName); //< table in current table void printTable(const unsigned int& tableIndex); //< table in current table /// clear a table, removes all objects in the table void clearTable(); //< current table - void clearTable(const string& tableName); //< table in current table + void clearTable(const std::string& tableName); //< table in current table void clearTable(const unsigned int& tableIndex); //< table in current table /// \section Reading @@ -195,53 +196,53 @@ class ofxLua { /// note: integer indices start with 1! /// get variables - bool getBool(const string& name, bool defaultValue=false); + bool getBool(const std::string& name, bool defaultValue=false); bool getBool(const unsigned int index, bool defaultValue=false); - lua_Number getNumber(const string& name, lua_Number devaultValue=0); + lua_Number getNumber(const std::string& name, lua_Number devaultValue=0); lua_Number getNumber(const unsigned int index, lua_Number devaultValue=0); - string getString(const string& name, const string& defaultValue=""); - string getString(const unsigned int index, const string& defaultValue=""); + std::string getString(const std::string& name, const std::string& defaultValue=""); + std::string getString(const unsigned int index, const std::string& defaultValue=""); /// get a vector from a table, prints warnings on wrong type /// /// note: clears given vector before reading lua vars - void getBoolVector(const string& tableName, vector& v); - void getBoolVector(const unsigned int tableIndex, vector& v); + void getBoolVector(const std::string& tableName, std::vector& v); + void getBoolVector(const unsigned int tableIndex, std::vector& v); - void getNumberVector(const string& tableName, vector& v); - void getNumberVector(const unsigned int tableIndex, vector& v); + void getNumberVector(const std::string& tableName, std::vector& v); + void getNumberVector(const unsigned int tableIndex, std::vector& v); - void getStringVector(const string& tableName, vector& v); - void getStringVector(const unsigned int tableIndex, vector& v); + void getStringVector(const std::string& tableName, std::vector& v); + void getStringVector(const unsigned int tableIndex, std::vector& v); /// \section Writing /// note: integer indices start with 1! /// set variables, creates if not existing - void setBool(const string& name, bool value); + void setBool(const std::string& name, bool value); void setBool(const unsigned int index, bool value); - void setNumber(const string& name, lua_Number value); + void setNumber(const std::string& name, lua_Number value); void setNumber(const unsigned int index, lua_Number value); - void setString(const string& name, const string value); - void setString(const unsigned int index, const string value); + void setString(const std::string& name, const std::string value); + void setString(const unsigned int index, const std::string value); /// set a table from a vector, table must exist - void setBoolVector(const string& tableName, vector& v); - void setBoolVector(const unsigned int tableIndex, vector& v); + void setBoolVector(const std::string& tableName, std::vector& v); + void setBoolVector(const unsigned int tableIndex, std::vector& v); - void setNumberVector(const string& tableName, vector& v); - void setNumberVector(const unsigned int tableIndex, vector& v); + void setNumberVector(const std::string& tableName, std::vector& v); + void setNumberVector(const unsigned int tableIndex, std::vector& v); - void setStringVector(const string& tableName, vector& v); - void setStringVector(const unsigned int tableIndex, vector& v); + void setStringVector(const std::string& tableName, std::vector& v); + void setStringVector(const unsigned int tableIndex, std::vector& v); /// set a variable or table to nil, essentially deleting it from the state - void setNil(const string& name); + void setNil(const std::string& name); void setNil(const unsigned int index); /// \section Writing to a File @@ -259,19 +260,19 @@ class ofxLua { /// write the current table to a given file writer void writeTable(ofxLuaFileWriter& writer, bool recursive=true); - void writeTable(const string& tableName, ofxLuaFileWriter& writer, bool recursive=true); + void writeTable(const std::string& tableName, ofxLuaFileWriter& writer, bool recursive=true); - bool writeTableToFile(const string& filename, bool recursive=true); - bool writeTableToFile(const string& tableName, const string& filename, bool recursive=true); + bool writeTableToFile(const std::string& filename, bool recursive=true); + bool writeTableToFile(const std::string& tableName, const std::string& filename, bool recursive=true); /// \section Util /// send a lua error message to any listeners and clear lua state /// if abortOnError is set - virtual void errorOccurred(string& msg); + virtual void errorOccurred(std::string& msg); /// get the current error message, an alternative to ofxLuaListener - string getErrorMessage(); + std::string getErrorMessage(); /// print current stack length and contents /// from left to right, useful for debugging @@ -313,7 +314,7 @@ class ofxLua { /// lua.pushobject("ofTouchArgEvents", t, true); // true: let lua delete it /// lua_pcall(lua, 1, 0, 0); /// - bool pushobject(const string &typeName, void *object, bool manageMemory=true); + bool pushobject(const std::string &typeName, void *object, bool manageMemory=true); protected: @@ -321,7 +322,7 @@ class ofxLua { static const int LUA_STACK_TOP = -1; /// returns true if an object exists - bool exists(const string& name, int type); + bool exists(const std::string& name, int type); bool exists(const unsigned int index, int type); /// returns true is an object is of a certain type @@ -331,26 +332,26 @@ class ofxLua { template T totype(int stackIndex, int type, T defaultValue); /// read a value from the state - template T read(const string& name, int type, T defaultVal); + template T read(const std::string& name, int type, T defaultVal); template T read(const unsigned int index, int type, T defaultVal); /// read a table into a vector - template void readVector(const string& name, vector& v, int type, T defaultValue); - template void readVector(const unsigned int index, vector& v, int type, T defaultValue); - template void readVectorHelper(vector& v, int type, T defaultValue); + template void readVector(const std::string& name, std::vector& v, int type, T defaultValue); + template void readVector(const unsigned int index, std::vector& v, int type, T defaultValue); + template void readVectorHelper(std::vector& v, int type, T defaultValue); /// set a value of a given type - template void settype(const string& name, int type, T value); + template void settype(const std::string& name, int type, T value); template void settype(unsigned int index, int type, T value); /// write a value to the state - template void write(const string& name, int type, T value); + template void write(const std::string& name, int type, T value); template void write(const unsigned int index, int type, T value); /// write a vector into a table - template void writeVector(const string& name, int type, vector& v); - template void writeVector(const unsigned int index, int type, vector& v); - template void writeVectorHelper(int type, vector& v); + template void writeVector(const std::string& name, int type, std::vector& v); + template void writeVector(const unsigned int index, int type, std::vector& v); + template void writeVectorHelper(int type, std::vector& v); /// print a table void printTable(int stackIndex, int numTabs); @@ -366,19 +367,19 @@ class ofxLua { struct TableIndex { int type; //< LUA_TSTRING or LUA_TNUMBER - string name; //< name index + std::string name; //< name index unsigned int index; //< number index - operator string() { + operator std::string() { if(type == LUA_TNUMBER) { - return to_string(index); + return std::to_string(index); } return name; } }; - vector tables; //< the currently open table stack + std::vector tables; //< the currently open table stack - ofEvent errorEvent; //< error event object, string is error msg - string errorMessage = ""; //< current error message + ofEvent errorEvent; //< error event object, string is error msg + std::string errorMessage = ""; //< current error message }; // TEMPLATE FUNCTIONS @@ -389,7 +390,7 @@ template T ofxLua::totype(int stackIndex, int type, T defaultValue) { return defaultValue; } template -void ofxLua::settype(const string& name, int type, T value) {} +void ofxLua::settype(const std::string& name, int type, T value) {} template void ofxLua::settype(unsigned int index, int type, T value) {} @@ -397,7 +398,7 @@ void ofxLua::settype(unsigned int index, int type, T value) {} // READ template -T ofxLua::read(const string& name, int type, T defaultValue) { +T ofxLua::read(const std::string& name, int type, T defaultValue) { if(!isValid()) { return defaultValue; } @@ -468,7 +469,7 @@ T ofxLua::read(const unsigned int index, int type, T defaultValue) { } template -void ofxLua::readVector(const string& name, vector& v, int type, T defaultValue) { +void ofxLua::readVector(const std::string& name, std::vector& v, int type, T defaultValue) { if(!pushTable(name)) { return; } @@ -477,7 +478,7 @@ void ofxLua::readVector(const string& name, vector& v, int type, T defaultVal } template -void ofxLua::readVector(const unsigned int index, vector& v, int type, T defaultValue) { +void ofxLua::readVector(const unsigned int index, std::vector& v, int type, T defaultValue) { if(!pushTable(index)) { return; } @@ -486,7 +487,7 @@ void ofxLua::readVector(const unsigned int index, vector& v, int type, T defa } template -void ofxLua::readVectorHelper(vector& v, int type, T defaultValue) { +void ofxLua::readVectorHelper(std::vector& v, int type, T defaultValue) { if(!isValid()) { return; } @@ -494,7 +495,7 @@ void ofxLua::readVectorHelper(vector& v, int type, T defaultValue) { v.clear(); if(!lua_istable(L, LUA_STACK_TOP)) { - string tname = "unknown"; + std::string tname = "unknown"; if(!tables.empty()) { tname = tables.back(); } @@ -513,7 +514,7 @@ void ofxLua::readVectorHelper(vector& v, int type, T defaultValue) { v.push_back(totype(-1, type, defaultValue)); } else { - string tname = "unknown"; + std::string tname = "unknown"; if(!tables.empty()) { tname = tables.back(); } @@ -529,7 +530,7 @@ void ofxLua::readVectorHelper(vector& v, int type, T defaultValue) { // WRITE template -void ofxLua::write(const string& name, int type, T value) { +void ofxLua::write(const std::string& name, int type, T value) { if(!isValid()) { return; } @@ -537,7 +538,7 @@ void ofxLua::write(const string& name, int type, T value) { // global variable? if(tables.empty()) { lua_pushglobaltable(L); - settype(name, type, value); + settype(name, type, value); lua_pop(L, 1); } @@ -548,7 +549,7 @@ void ofxLua::write(const string& name, int type, T value) { << ", top of stack is not a table"; return; } - settype(name, type, value); + settype(name, type, value); } } @@ -568,11 +569,11 @@ void ofxLua::write(const unsigned int index, int type, T value) { return; } - settype(index, type, value); + settype(index, type, value); } template -void ofxLua::writeVector(const string& name, int type, vector& v) { +void ofxLua::writeVector(const std::string& name, int type, std::vector& v) { if(!pushTable(name)) { return; } @@ -581,7 +582,7 @@ void ofxLua::writeVector(const string& name, int type, vector& v) { } template -void ofxLua::writeVector(const unsigned int index, int type, vector& v) { +void ofxLua::writeVector(const unsigned int index, int type, std::vector& v) { if(!pushTable(index)) { return; } @@ -590,14 +591,14 @@ void ofxLua::writeVector(const unsigned int index, int type, vector& v) { } template -void ofxLua::writeVectorHelper(int type, vector& v) { +void ofxLua::writeVectorHelper(int type, std::vector& v) { // global variable? if(tables.empty()) { ofLogWarning("ofxLua") << "Couldn't write table vector, no open tables"; return; } - string tname = tables.back(); + std::string tname = tables.back(); if(v.empty()) { ofLogWarning("ofxLua") << "Couldn't write table \"" << tname << "\", vector is empty"; @@ -613,6 +614,6 @@ void ofxLua::writeVectorHelper(int type, vector& v) { // add new variables for(size_t i = 0; i < v.size(); ++i) { - settype(i+1, type, v[i]); + settype(i+1, type, v[i]); } } diff --git a/addons/ofxLua/src/ofxLuaFileWriter.cpp b/addons/ofxLua/src/ofxLuaFileWriter.cpp index 2f36a81..b32539b 100644 --- a/addons/ofxLua/src/ofxLuaFileWriter.cpp +++ b/addons/ofxLua/src/ofxLuaFileWriter.cpp @@ -21,7 +21,7 @@ ofxLuaFileWriter::ofxLuaFileWriter() { ofxLuaFileWriter::~ofxLuaFileWriter() {} //------------------------------------------------------------------------------ -bool ofxLuaFileWriter::saveToFile(const string& filename) { +bool ofxLuaFileWriter::saveToFile(const std::string& filename) { ofBuffer b(buffer); return ofBufferToFile(ofToDataPath(filename), b); } @@ -34,11 +34,11 @@ void ofxLuaFileWriter::clear() { //------------------------------------------------------------------------------ void ofxLuaFileWriter::newLine() { - buffer << endl; + buffer << std::endl; } -void ofxLuaFileWriter::writeComment(const string& comment) { - buffer << "-- " << comment << endl; +void ofxLuaFileWriter::writeComment(const std::string& comment) { + buffer << "-- " << comment << std::endl; } void ofxLuaFileWriter::beginCommentBlock() { @@ -47,7 +47,7 @@ void ofxLuaFileWriter::beginCommentBlock() { return; } bCommentBlock = true; - buffer << "--[[" << endl; + buffer << "--[[" << std::endl; } void ofxLuaFileWriter::endCommentBlock() { @@ -56,31 +56,31 @@ void ofxLuaFileWriter::endCommentBlock() { return; } bCommentBlock = false; - buffer << "--]]" << endl; + buffer << "--]]" << std::endl; } -void ofxLuaFileWriter::writeLine(const string& line) { - buffer << line << endl; +void ofxLuaFileWriter::writeLine(const std::string& line) { + buffer << line << std::endl; } -void ofxLuaFileWriter::beginTable(const string& tableName) { +void ofxLuaFileWriter::beginTable(const std::string& tableName) { if(tables.empty()) { - buffer << tableName << " = {}" << endl; + buffer << tableName << " = {}" << std::endl; } else { writeTablePath(); - buffer << "." << tableName << " = {}" << endl; + buffer << "." << tableName << " = {}" << std::endl; } tables.push_back({LUA_TSTRING, tableName, 0}); } void ofxLuaFileWriter::beginTable(const unsigned int tableIndex) { if(tables.empty()) { - buffer << tableIndex << " = {}" << endl; + buffer << tableIndex << " = {}" << std::endl; } else { writeTablePath(); - buffer << "[" << tableIndex << "] = {}" << endl; + buffer << "[" << tableIndex << "] = {}" << std::endl; } tables.push_back({LUA_TNUMBER, "", (unsigned int)tableIndex}); } @@ -95,7 +95,7 @@ void ofxLuaFileWriter::endTable() { } //------------------------------------------------------------------------------ -void ofxLuaFileWriter::writeBool(const string& name, bool value) { +void ofxLuaFileWriter::writeBool(const std::string& name, bool value) { write(name, LUA_TBOOLEAN, value); } @@ -103,7 +103,7 @@ void ofxLuaFileWriter::writeBool(const unsigned int index, bool value) { write(index, LUA_TBOOLEAN, value); } -void ofxLuaFileWriter::writeNumber(const string& name, lua_Number value) { +void ofxLuaFileWriter::writeNumber(const std::string& name, lua_Number value) { write(name, LUA_TNUMBER, value); } @@ -111,36 +111,36 @@ void ofxLuaFileWriter::writeNumber(const unsigned int index, lua_Number value) { write(index, LUA_TNUMBER, value); } -void ofxLuaFileWriter::writeString(const string& name, string value) { - write(name, LUA_TSTRING, value); +void ofxLuaFileWriter::writeString(const std::string& name, std::string value) { + write(name, LUA_TSTRING, value); } -void ofxLuaFileWriter::writeString(const unsigned int index, string value) { - write(index, LUA_TSTRING, value); +void ofxLuaFileWriter::writeString(const unsigned int index, std::string value) { + write(index, LUA_TSTRING, value); } -void ofxLuaFileWriter::writeBoolVector(const string& tableName, vector& v) { +void ofxLuaFileWriter::writeBoolVector(const std::string& tableName, std::vector& v) { writeVector(tableName, LUA_TBOOLEAN, v); } -void ofxLuaFileWriter::writeBoolVector(const unsigned int index, vector& v) { +void ofxLuaFileWriter::writeBoolVector(const unsigned int index, std::vector& v) { writeVector(index, LUA_TBOOLEAN, v); } -void ofxLuaFileWriter::writeNumberVector(const string& tableName, vector& v) { +void ofxLuaFileWriter::writeNumberVector(const std::string& tableName, std::vector& v) { writeVector(tableName, LUA_TNUMBER, v); } -void ofxLuaFileWriter::writeNumberVector(const unsigned int index, vector& v) { +void ofxLuaFileWriter::writeNumberVector(const unsigned int index, std::vector& v) { writeVector(index, LUA_TNUMBER, v); } -void ofxLuaFileWriter::writeStringVector(const string& tableName, vector& v) { - writeVector(tableName, LUA_TSTRING, v); +void ofxLuaFileWriter::writeStringVector(const std::string& tableName, std::vector& v) { + writeVector(tableName, LUA_TSTRING, v); } -void ofxLuaFileWriter::writeStringVector(const unsigned int index, vector& v) { - writeVector(index, LUA_TSTRING, v); +void ofxLuaFileWriter::writeStringVector(const unsigned int index, std::vector& v) { + writeVector(index, LUA_TSTRING, v); } // PRIVATE @@ -151,7 +151,7 @@ template <> void ofxLuaFileWriter::writetype(int type, bool value) { } // catch vector internal type since it isn't actually a bool -template <> void ofxLuaFileWriter::writetype::reference>(int type, vector::reference value) { +template <> void ofxLuaFileWriter::writetype::reference>(int type, std::vector::reference value) { buffer << ((bool)value ? "true" : "false"); } @@ -159,7 +159,7 @@ template <> void ofxLuaFileWriter::writetype(int type, lua_Number va buffer << value; } -template <> void ofxLuaFileWriter::writetype(int type, string value) { +template <> void ofxLuaFileWriter::writetype(int type, std::string value) { buffer << "\"" << value << "\""; } @@ -169,13 +169,13 @@ void ofxLuaFileWriter::writeTablePath() { if(tables.empty()) { return; } - buffer << (string)tables[0]; + buffer << (std::string)tables[0]; for(size_t i = 1; i < tables.size(); ++i) { if(tables[i].type == LUA_TSTRING) { - buffer << "." << (string)tables[i]; + buffer << "." << (std::string)tables[i]; } else { - buffer << "[" << (string)tables[i] << "]"; + buffer << "[" << (std::string)tables[i] << "]"; } } } diff --git a/addons/ofxLua/src/ofxLuaFileWriter.h b/addons/ofxLua/src/ofxLuaFileWriter.h index cf94663..50395c5 100644 --- a/addons/ofxLua/src/ofxLuaFileWriter.h +++ b/addons/ofxLua/src/ofxLuaFileWriter.h @@ -30,7 +30,7 @@ class ofxLuaFileWriter { /// save the current buffer to a file, /// best to name it with the ".lua" ext - bool saveToFile(const string& filename); + bool saveToFile(const std::string& filename); /// clear the buffer void clear(); @@ -41,7 +41,7 @@ class ofxLuaFileWriter { void newLine(); /// writes a single line "--" comment - void writeComment(const string& comment); + void writeComment(const std::string& comment); /// starts and stops a multi-line comment block aka /// --[[ @@ -55,61 +55,61 @@ class ofxLuaFileWriter { /// write a single line of text, not variable data /// /// note: don't write close comments "--]]" when in a comment block - void writeLine(const string& comment); + void writeLine(const std::string& comment); /// create a table, subsequent data is written as variables inside - void beginTable(const string& tableName); + void beginTable(const std::string& tableName); void beginTable(const unsigned int tableIndex); //< must beginTable first void endTable(); /// \section Write variables - void writeBool(const string& name, bool value); + void writeBool(const std::string& name, bool value); void writeBool(const unsigned int index, bool value); - void writeNumber(const string& name, lua_Number value); + void writeNumber(const std::string& name, lua_Number value); void writeNumber(const unsigned int index, lua_Number value); - void writeString(const string& name, string value); - void writeString(const unsigned int index, string value); + void writeString(const std::string& name, std::string value); + void writeString(const unsigned int index, std::string value); - void writeBoolVector(const string& tableName, vector& v); - void writeBoolVector(const unsigned int index, vector& v); + void writeBoolVector(const std::string& tableName, std::vector& v); + void writeBoolVector(const unsigned int index, std::vector& v); - void writeNumberVector(const string& tableName, vector& v); - void writeNumberVector(const unsigned int index, vector& v); + void writeNumberVector(const std::string& tableName, std::vector& v); + void writeNumberVector(const unsigned int index, std::vector& v); - void writeStringVector(const string& tableName, vector& v); - void writeStringVector(const unsigned int index, vector& v); + void writeStringVector(const std::string& tableName, std::vector& v); + void writeStringVector(const unsigned int index, std::vector& v); private: template void writetype(int type, T value); - template void write(const string& name, int type, T value); + template void write(const std::string& name, int type, T value); template void write(const unsigned int index, int type, T value); - template void writeVector(const string& tableName, int type, vector &v); - template void writeVector(const unsigned int index, int type, vector &v); + template void writeVector(const std::string& tableName, int type, std::vector &v); + template void writeVector(const unsigned int index, int type, std::vector &v); /// write the currently nest table paths void writeTablePath(); struct TableIndex { int type; //< LUA_TSTRING or LUA_TNUMBER - string name; //< name index + std::string name; //< name index unsigned int index; //< number index - operator string() { + operator std::string() { if(type == LUA_TNUMBER) { - return to_string(index); + return std::to_string(index); } return name; } }; - vector tables; //< the currently open table stack + std::vector tables; //< the currently open table stack bool bCommentBlock; //< currently in a comment block? - stringstream buffer; //< string buffer + std::stringstream buffer; //< string buffer }; // TEMPLATE FUNCTIONS @@ -118,7 +118,7 @@ template void ofxLuaFileWriter::writetype(int type, T value) {} template -void ofxLuaFileWriter::write(const string& name, int type, T value) { +void ofxLuaFileWriter::write(const std::string& name, int type, T value) { if(tables.empty()) { buffer << name << " = "; } @@ -127,7 +127,7 @@ void ofxLuaFileWriter::write(const string& name, int type, T value) { buffer << "." << name << " = "; } writetype(type, value); - buffer << endl; + buffer << std::endl; } template @@ -139,11 +139,11 @@ void ofxLuaFileWriter::write(const unsigned int index, int type, T value) { writeTablePath(); buffer << "[" << index << "] = "; writetype(type, value); - buffer << endl; + buffer << std::endl; } template -void ofxLuaFileWriter::writeVector(const string& tableName, int type, vector &v) { +void ofxLuaFileWriter::writeVector(const std::string& tableName, int type, std::vector &v) { if(v.empty()) { ofLogWarning("ofxLua") << "Couldn't write empty vector to file"; @@ -165,11 +165,11 @@ void ofxLuaFileWriter::writeVector(const string& tableName, int type, vector buffer << ", "; writetype(type, v[i]); } - buffer << " }" << endl; + buffer << " }" << std::endl; } template -void ofxLuaFileWriter::writeVector(const unsigned int index, int type, vector &v) { +void ofxLuaFileWriter::writeVector(const unsigned int index, int type, std::vector &v) { if(tables.empty()) { ofLogWarning("ofxLua") << "Couldn't write vector to file by index, no open tables"; @@ -186,5 +186,6 @@ void ofxLuaFileWriter::writeVector(const unsigned int index, int type, vector buffer << ", "; writetype(type, v[i]); } - buffer << " }" << endl; + buffer << " }" << std::endl; } + diff --git a/addons/ofxLua/swig/.gitignore b/addons/ofxLua/swig/.gitignore index 96ddc14..205e01c 100644 --- a/addons/ofxLua/swig/.gitignore +++ b/addons/ofxLua/swig/.gitignore @@ -1,4 +1,8 @@ - -*_symbols.txt +# generated files *.cpp *.h +*_symbols.txt + +# generated directories +./lua +./python diff --git a/addons/ofxLua/swig/Makefile b/addons/ofxLua/swig/Makefile index c949171..077a858 100644 --- a/addons/ofxLua/swig/Makefile +++ b/addons/ofxLua/swig/Makefile @@ -1,9 +1,9 @@ # # Makefile to generate OF bindings using SWIG # -# 2014 Dan Wilcox +# 2014-2018 Dan Wilcox # -# running `make` generates desktop os lua bindings and puts them in ../src, +# running `make` generates desktop os lua bindings and puts them in ./lua, # running `make ios` generates ios lua bindings, etc # # override any of the following variables using make, i.e. to generate Python @@ -18,6 +18,63 @@ SWIG = swig # default output language, see swig -h for more LANG = lua +# default platform target, available targets are: +# * desktop: win, linux, & mac osx +# * ios: apple iOS using OpenGL ES +# * linuxarm: embedded linux using OpenGL ES +TARGET = desktop + +# where to place the generated bindings +DEST_DIR = $(LANG) + +# any extra SWIG flags per-language, etc +SWIG_FLAGS = -O -small + +############## +# main targets +############## + +.PHONY: all clean desktop ios linuxarm header libs libs-clean \ +openFrameworks openFrameorks-header openFrameorks-symbols openFrameworks-clean \ +glm glm-symbols glm-clean + +all: desktop header libs + +clean: openFrameworks-clean libs-clean + +# desktop OS generation +desktop: desktop-prepare openFrameworks + +desktop-prepare: + $(eval TARGET := desktop) + $(eval CFLAGS := $(CFLAGS)) + +# iOS specific generation +ios: ios-prepare openFrameworks + +ios-prepare: + $(eval TARGET := ios) + $(eval CFLAGS := $(CFLAGS) -DTARGET_OPENGLES -DTARGET_IOS) + +# embedded linux specific generation +linuxarm: linuxarm-prepare openFrameworks + +linuxarm-prepare: + $(eval TARGET := linuxarm) + $(eval CFLAGS := $(CFLAGS) -DTARGET_OPENGLES) + +# runtime header generation +header: openFrameworks-header + +# additional library generation +libs: glm + +libs-clean: glm-clean + +####################### +# openFrameworks module +####################### + # module name MODULE_NAME = of @@ -27,26 +84,11 @@ RENAME = true # allow deprecated functions? otherwise, ignore DEPRECATED = false -# default platform target, available targets are: -# * desktop: win, linux, & mac osx -# * ios: apple iOS using OpenGL ES -# * linuxarm: embedded linux using OpenGL ES -TARGET = desktop - # generated bindings filename -NAME = openFrameworks_wrap - -# where to copy the generated bindings -DEST_DIR = ../src/bindings - -# where to copy the generated specific language files -DEST_LANG_DIR = . +NAME = ofBindings -# OF header includes -OF_HEADERS = -I../../../libs/openFrameworks - -# any extra SWIG flags per-language, etc -SWIG_FLAGS = +# OF libs header path +OF_HEADERS = -I../../../libs # Python specific preferences # typically, long names are used in Python, @@ -54,84 +96,66 @@ SWIG_FLAGS = ifeq ($(LANG), python) MODULE_NAME = openframeworks RENAME = false - SWIG_FLAGS = -modern + SWIG_FLAGS += -modern endif -# populate CFLAGS +# populate CFLAGS for openFrameworks +OF_CFLAGS = $(OF_HEADERS)/openFrameworks -DMODULE_NAME=$(MODULE_NAME) + ifeq ($(RENAME), true) - RENAME_CFLAGS = -DOF_SWIG_RENAME -else - RENAME_CFLAGS = + OF_CFLAGS += -DOF_SWIG_RENAME endif ifeq ($(DEPRECATED), true) - DEPRECATED_CFLAGS = -DOF_SWIG_DEPRECATED -else - DEPRECATED_CFLAGS = + OF_CFLAGS += -DOF_SWIG_DEPRECATED endif ifeq ($(ATTRIBUTES), true) - ATTRIBUTES_CFLAGS = -DOF_SWIG_ATTRIBUTES -else - ATTRIBUTES_CFLAGS = + OF_CFLAGS += -DOF_SWIG_ATTRIBUTES endif -CFLAGS = $(OF_HEADERS) -DMODULE_NAME=$(MODULE_NAME) $(RENAME_CFLAGS) $(DEPRECATED_CFLAGS) $(ATTRIBUTES_CFLAGS) -DTARGET_WIN32 - -.PHONY: all debug clean desktop ios linuxarm - # generates bindings -bindings: - - @echo Generating for: $(TARGET) - @echo LANG = $(LANG) - @echo CFLAGS = $(CFLAGS) - @echo NAME = $(NAME) - @echo DEST_DIR = $(DEST_DIR) - - $(SWIG) -c++ -$(LANG) $(SWIG_FLAGS) -fcompact -fvirtual $(CFLAGS) -outdir $(DEST_LANG_DIR) openFrameworks.i - mv openFrameworks_wrap.cxx $(NAME).cpp - - $(SWIG) -c++ -$(LANG) -external-runtime $(NAME).h - - mv openFrameworks_wrap.cpp ofxLuaBindings.cpp - mv openFrameworks_wrap.h ofxLuaBindings.h +openFrameworks: + @echo "### Generating: openFrameworks $(TARGET)" + @mkdir -p $(DEST_DIR)/$(TARGET) + $(SWIG) -c++ -$(LANG) $(SWIG_FLAGS) $(CFLAGS) $(OF_CFLAGS) -o $(DEST_DIR)/$(TARGET)/$(NAME).cpp openFrameworks.i -# move generated files to DEST_DIR -move: - mkdir -p $(DEST_DIR)/$(TARGET) - mv *.h $(DEST_DIR) - mv *.cpp $(DEST_DIR)/$(TARGET) +# generates swig runtime header +openFrameworks-header: + @echo "### Generating: openFrameworks header" + $(SWIG) -c++ -$(LANG) -external-runtime $(DEST_DIR)/$(NAME).h # outputs swig language symbols -symbols: - $(SWIG) -c++ -$(LANG) $(SWIG_FLAGS) -fcompact -fvirtual -debug-lsymbols $(CFLAGS) openFrameworks.i > $(MODULE_NAME)_$(LANG)_symbols.txt +openFrameworks-symbols: + $(SWIG) -c++ -$(LANG) $(SWIG_FLAGS) -debug-lsymbols $(CFLAGS) $(OF_CFLAGS) openFrameworks.i > $(MODULE_NAME)_$(LANG)_symbols.txt rm -f *.cxx - if [ $(LANG) == "python" ]; then rm -f *.py; fi + if [ $(LANG) = "python" ]; then rm -f *.py; fi -clean: - rm -f $(DEST_DIR)/$(FILENAME).h +# clean dest dir +openFrameworks-clean: rm -rf $(DEST_DIR)/desktop rm -rf $(DEST_DIR)/ios - rm -f debug.txt + rm -rf $(DEST_DIR)/linuxarm + rm -f $(DEST_DIR)/$(NAME).h + rm -f $(MODULE_NAME)_*_symbols.txt -# desktop OS generation -desktop-prepare: - $(eval TARGET := desktop) - $(eval CFLAGS := $(CFLAGS)) - -desktop: desktop-prepare bindings move - -# iOS specific generation -ios-prepare: - $(eval TARGET := ios) - $(eval CFLAGS := $(CFLAGS) -DTARGET_OPENGLES -DTARGET_IOS) +############ +# glm module +############ -ios: ios-prepare bindings move +# generates glm bindings +glm: + @echo "### Generating: glm" + @mkdir -p $(DEST_DIR) + $(SWIG) -c++ -$(LANG) $(SWIG_FLAGS) $(OF_HEADERS)/glm/include -o $(DEST_DIR)/glmBindings.cpp glm.i -# embedded linux specific generation -linuxarm-prepare: - $(eval TARGET := linuxarm) - $(eval CFLAGS := $(CFLAGS) -DTARGET_OPENGLES) +# outputs swig language symbols +glm-symbols: + $(SWIG) -c++ -$(LANG) $(SWIG_FLAGS) -debug-lsymbols $(OF_HEADERS)/glm/include glm.i > glm_$(LANG)_symbols.txt + rm -f *.cxx + if [ $(LANG) = "python" ]; then rm -f *.py; fi -linuxarm: linuxarm-prepare bindings move +# clean dest dir +glm-clean: + rm -f $(DEST_DIR)/glmBindings.cpp + rm -f glm_*_symbols.txt diff --git a/addons/ofxLua/swig/README.md b/addons/ofxLua/swig/README.md index 55984d1..e3028ac 100644 --- a/addons/ofxLua/swig/README.md +++ b/addons/ofxLua/swig/README.md @@ -3,7 +3,7 @@ swig-openframeworks a SWIG interface for openFrameworks with included Makefile -Copyright (c) [Dan Wilcox](danomatika.com) 2015 +Copyright (c) [Dan Wilcox](danomatika.com) 2015-2018 BSD Simplified License. @@ -84,6 +84,49 @@ In Python, the module (aka library) is called "openframeworks" and its members r color = ofColor() ... +glm Bindings +------------ + +As of openFrameworks 0.10.0, the glm library math types (vec3, mat3, quat, etc) have become integral to the OF API and are now wrapped via a swig interface as well. The resulting module is named "glm" and associated functions and types are accessed from within this name space. + +For example, in Lua: + + -- constructors + local v1 = glm.vec3(1, 2, 3) + local v2 = glm.vec3(4, 5, 6) + + -- operators + local v3 = v1 + v2 + v3 = v2 / v1 + + -- functions + local dot = glm.dot(v1, v2) + +One **important point**: Most scripting languages cannot support the casting operators which allow the OF math types (ofVec3f, ofMatrix3x3, etc) to be used with functions which take glm type arguments. To get around this problem, each math type has a special member function which returns the associated glm type: + +* ofVec2f -> glm::vec2: vec2() +* ofVec3f -> glm::vec3: vec3() +* ofVec4f -> glm::vec4: vec4() +* ofQuaternion -> glm::quat: quat() +* ofMatrix3x3 -> glm::mat4: mat3() +* ofMatrix4x4 -> glm::mat4: mat4() + +Essentially, the following will *not* work as it does in C++: + + -- error! + local v = of.Vec2f(100, 100) + of.drawRectangle(v, 20, 20) -- needs a glm.vec2 + +Either convert the OF math type to a glm type or use a glm type directly: + + -- convert + local v = of.Vec2f(100, 100) + of.drawRectangle(v.vec2(), 20, 20) + + -- use glm::vec2 + local v = glm.vec2(100, 100) + of.drawRectangle(v, 20, 20) + Usage ----- diff --git a/addons/ofxLua/swig/glm.i b/addons/ofxLua/swig/glm.i new file mode 100644 index 0000000..f98879e --- /dev/null +++ b/addons/ofxLua/swig/glm.i @@ -0,0 +1,81 @@ +// minimal SWIG (http://www.swig.org) interface wrapper for the glm library +// defines only the types used in openFrameworks: vec2, vec3, mat3, mat4, quat +// 2018 Dan Wilcox +// some parts adapted from https://github.com/IndiumGames/swig-wrapper-glm + +// main MODULE +%module glm +%{ +#include +#include +#include + +// these included in math/ofVectorMath.h +// we declare some things manually, so some includes are commented out +#include "glm/vec2.hpp" +#include "glm/vec3.hpp" +#include "glm/vec4.hpp" +#include "glm/mat3x3.hpp" +#include "glm/mat4x4.hpp" +#include "glm/geometric.hpp" +#include "glm/common.hpp" +#include "glm/trigonometric.hpp" +#include "glm/exponential.hpp" +//#include "glm/vector_relational.hpp" +//#include "glm/ext.hpp" + +//#include "glm/gtc/constants.hpp" +#include "glm/gtc/matrix_transform.hpp" +#include "glm/gtc/matrix_inverse.hpp" +//#include "glm/gtc/quaternion.hpp" +#include "glm/gtc/epsilon.hpp" +#include "glm/gtx/norm.hpp" +#include "glm/gtx/perpendicular.hpp" +#include "glm/gtx/quaternion.hpp" +#include "glm/gtx/rotate_vector.hpp" +#include "glm/gtx/spline.hpp" +#include "glm/gtx/transform.hpp" +#include "glm/gtx/vector_angle.hpp" +//#include "glm/gtx/scalar_multiplication.hpp" +//#include + +// extras included via glm/ext.h +#include +#include +#include +#include +#include +%} + +// ----- C++ ----- + +%include +%include + +// expanded primitives +%typedef unsigned int std::size_t; + +// ----- Bindings------ + +namespace glm { + +#ifdef SWIGLUA +%rename(add) operator+; +%rename(sub) operator-; +%rename(mul) operator*; +%rename(div) operator/; +%rename(eq) operator==; +#endif + +%typedef int length_t; + +%include "glm/vec2.i" +%include "glm/vec3.i" +%include "glm/vec4.i" +%include "glm/mat3.i" +%include "glm/mat4.i" +%include "glm/quat.i" +%include "glm/constants.i" +%include "glm/functions.i" + +} // namespace diff --git a/addons/ofxLua/swig/glm/constants.i b/addons/ofxLua/swig/glm/constants.i new file mode 100644 index 0000000..42bc786 --- /dev/null +++ b/addons/ofxLua/swig/glm/constants.i @@ -0,0 +1,82 @@ +// glm constants bindings +// adapted from https://github.com/IndiumGames/swig-wrapper-glm +// +// The MIT License (MIT) +// +// Copyright (c) 2016 Indium Games (www.indiumgames.fi) +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all +// copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +// SOFTWARE. + +// ----- glm/gtc/constants.hpp ----- + +template T epsilon(); +template T zero(); +template T one(); +template T pi(); +template T two_pi(); +template T root_pi(); +template T half_pi(); +template T three_over_two_pi(); +template T quarter_pi(); +template T one_over_pi(); +template T one_over_two_pi(); +template T two_over_pi(); +template T four_over_pi(); +template T two_over_root_pi(); +template T one_over_root_two(); +template T root_half_pi(); +template T root_two_pi(); +template T root_ln_four(); +template T e(); +template T euler(); +template T root_two(); +template T root_three(); +template T root_five(); +template T ln_two(); +template T ln_ten(); +template T ln_ln_two(); +template T third(); +template T two_thirds(); +template T golden_ratio(); + +%template(epsilon) epsilon; +%template(zero) zero; +%template(one) one; +%template(pi) pi; +%template(root_pi) root_pi; +%template(half_pi) half_pi; +%template(quarter_pi) quarter_pi; +%template(one_over_pi) one_over_pi; +%template(two_over_pi) two_over_pi; +%template(two_over_root_pi) two_over_root_pi; +%template(one_over_root_two) one_over_root_two; +%template(root_half_pi) root_half_pi; +%template(root_two_pi) root_two_pi; +%template(root_ln_four) root_ln_four; +%template(e) e; +%template(euler) euler; +%template(root_two) root_two; +%template(root_three) root_three; +%template(root_five) root_five; +%template(ln_two) ln_two; +%template(ln_ten) ln_ten; +%template(ln_ln_two) ln_ln_two; +%template(third) third; +%template(two_thirds) two_thirds; +%template(golden_ratio) golden_ratio; diff --git a/addons/ofxLua/swig/glm/functions.i b/addons/ofxLua/swig/glm/functions.i new file mode 100644 index 0000000..5d4bed7 --- /dev/null +++ b/addons/ofxLua/swig/glm/functions.i @@ -0,0 +1,336 @@ +// glm function bindings +// adapted from https://github.com/IndiumGames/swig-wrapper-glm +// +// The MIT License (MIT) +// +// Copyright (c) 2016 Indium Games (www.indiumgames.fi) +// +// Permission is hereby granted, free of charge, to any person obtaining a copy +// of this software and associated documentation files (the "Software"), to deal +// in the Software without restriction, including without limitation the rights +// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +// copies of the Software, and to permit persons to whom the Software is +// furnished to do so, subject to the following conditions: +// +// The above copyright notice and this permission notice shall be included in all +// copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +// SOFTWARE. + +%define FLOAT_VECTOR(function_name) + vec2 function_name(const vec2 &); + vec3 function_name(const vec3 &); + vec4 function_name(const vec4 &); +%enddef + +%define FLOAT_VECTOR_2_PARAMS(function_name) + vec2 function_name(const vec2 &, const vec2 &); + vec3 function_name(const vec3 &, const vec3 &); + vec4 function_name(const vec4 &, const vec4 &); +%enddef + +%define FLOAT_VECTOR_3_PARAMS(function_name) + vec2 function_name(const vec2 &, const vec2 &, const vec2 &); + vec3 function_name(const vec3 &, const vec3 &, const vec3 &); + vec4 function_name(const vec4 &, const vec4 &, const vec4 &); +%enddef + +%define FLOAT_VECTOR_RETURN_VALUE(function_name) + float function_name(const vec2 &); + float function_name(const vec3 &); + float function_name(const vec4 &); +%enddef + +%define FLOAT_VECTOR_RETURN_VALUE_2_PARAMS(function_name) + float function_name(const vec2 &, const vec2 &); + float function_name(const vec3 &, const vec3 &); + float function_name(const vec4 &, const vec4 &); +%enddef + +%define FLOAT_SCALAR_OR_VECTOR(function_name) + float function_name(const float &); + vec2 function_name(const vec2 &); + vec3 function_name(const vec3 &); + vec4 function_name(const vec4 &); +%enddef + +%define FLOAT_SCALAR_OR_VECTOR_RETURN_VALUE(function_name) + float function_name(const float &); + float function_name(const vec2 &); + float function_name(const vec3 &); + float function_name(const vec4 &); +%enddef + +%define FLOAT_SCALAR_OR_VECTOR_2_PARAMS(function_name) + float function_name(const float &, const float &); + vec2 function_name(const vec2 &, const vec2 &); + vec3 function_name(const vec3 &, const vec3 &); + vec4 function_name(const vec4 &, const vec4 &); +%enddef + +%define FLOAT_SCALAR_OR_VECTOR_2_PARAMS_VECTOR_VALUE(function_name) + vec2 function_name(const vec2 &, const float &); + vec3 function_name(const vec3 &, const float &); + vec4 function_name(const vec4 &, const float &); +%enddef + +%define FLOAT_SCALAR_OR_VECTOR_3_PARAMS(function_name) + float function_name(const float &, const float &, const float &); + vec2 function_name(const vec2 &, const vec2 &, const vec2 &); + vec3 function_name(const vec3 &, const vec3 &, const vec3 &); + vec4 function_name(const vec4 &, const vec4 &, const vec4 &); +%enddef + +%define FLOAT_SCALAR_OR_VECTOR_3_PARAMS_VECTOR_VALUE_VALUE(function_name) + vec2 function_name(const vec2 &, const float &, const float &); + vec3 function_name(const vec3 &, const float &, const float &); + vec4 function_name(const vec4 &, const float &, const float &); +%enddef + +%define FLOAT_SCALAR_OR_VECTOR_3_PARAMS_VECTOR_VECTOR_VALUE(function_name) + vec2 function_name(const vec2 &, const vec2 &, const float &); + vec3 function_name(const vec3 &, const vec3 &, const float &); + vec4 function_name(const vec4 &, const vec4 &, const float &); +%enddef + +// ----- glm/common.hpp ----- + +FLOAT_SCALAR_OR_VECTOR(abs); +FLOAT_SCALAR_OR_VECTOR(sign); +FLOAT_SCALAR_OR_VECTOR(floor); +FLOAT_SCALAR_OR_VECTOR(trunc); +FLOAT_SCALAR_OR_VECTOR(round); +FLOAT_SCALAR_OR_VECTOR(roundEven); +FLOAT_SCALAR_OR_VECTOR(ceil); +FLOAT_SCALAR_OR_VECTOR(fract); +FLOAT_SCALAR_OR_VECTOR_2_PARAMS(mod); +FLOAT_SCALAR_OR_VECTOR_2_PARAMS_VECTOR_VALUE(mod); +float modf(const float &, float &); +vec2 modf(const vec2 &, vec2 &); +vec3 modf(const vec3 &, vec3 &); +vec4 modf(const vec4 &, vec4 &); +FLOAT_SCALAR_OR_VECTOR_2_PARAMS(min); +FLOAT_SCALAR_OR_VECTOR_2_PARAMS_VECTOR_VALUE(min); +FLOAT_SCALAR_OR_VECTOR_2_PARAMS(max); +FLOAT_SCALAR_OR_VECTOR_2_PARAMS_VECTOR_VALUE(max); +FLOAT_SCALAR_OR_VECTOR_3_PARAMS(clamp); +FLOAT_SCALAR_OR_VECTOR_3_PARAMS_VECTOR_VALUE_VALUE(clamp); +float mix(const float &, const float &, const float &); +float mix(const float &, const float &, const bool &); +vec2 mix(const vec2 &, const vec2 &, const vec2 &); +vec3 mix(const vec3 &, const vec3 &, const vec3 &); +vec4 mix(const vec4 &, const vec4 &, const vec4 &); +vec2 mix(const vec2 &, const vec2 &, const bool &); +vec3 mix(const vec3 &, const vec3 &, const bool &); +vec4 mix(const vec4 &, const vec4 &, const bool &); +vec2 step(const vec2 &, const vec2 &); +vec3 step(const vec3 &, const vec3 &); +vec4 step(const vec4 &, const vec4 &); +vec2 step(const float &, const vec2 &); +vec3 step(const float &, const vec3 &); +vec4 step(const float &, const vec4 &); +FLOAT_SCALAR_OR_VECTOR_3_PARAMS(smoothstep); +vec2 smoothstep(const float &, const float &, const vec2 &); +vec3 smoothstep(const float &, const float &, const vec3 &); +vec4 smoothstep(const float &, const float &, const vec4 &); +bool isnan(const float &); +bool isinf(const float &); +FLOAT_SCALAR_OR_VECTOR_3_PARAMS(fma); + +// ----- glm/exponential.hpp ----- + +FLOAT_SCALAR_OR_VECTOR_2_PARAMS(pow); +FLOAT_SCALAR_OR_VECTOR(exp); +FLOAT_SCALAR_OR_VECTOR(log); +FLOAT_SCALAR_OR_VECTOR(exp2); +FLOAT_SCALAR_OR_VECTOR(log2); +FLOAT_VECTOR(sqrt); +FLOAT_SCALAR_OR_VECTOR(inversesqrt); + +// ----- glm/geometric.hpp ----- + +FLOAT_VECTOR_RETURN_VALUE(length); +FLOAT_VECTOR_RETURN_VALUE_2_PARAMS(distance); +FLOAT_VECTOR_RETURN_VALUE_2_PARAMS(dot); +vec3 cross(const vec3 &, const vec3 &); +FLOAT_VECTOR(normalize); +FLOAT_VECTOR_3_PARAMS(faceforward); +FLOAT_VECTOR_2_PARAMS(reflect); +vec2 refract(const vec2 &, const vec2 &, const float &); +vec3 refract(const vec3 &, const vec3 &, const float &); +vec4 refract(const vec4 &, const vec4 &, const float &); + +// ----- glm/matrix.hpp ----- + +mat3 matrixCompMult(const mat3 &, const mat3 &); +mat4 matrixCompMult(const mat4 &, const mat4 &); +mat3 outerProduct(const vec3 &, const vec3 &); +mat4 outerProduct(const vec4 &, const vec4 &); +mat3 transpose(const mat3 &); +mat4 transpose(const mat4 &); +float determinant(const mat3 &); +float determinant(const mat4 &); +mat3 inverse(const mat3 &); +mat4 inverse(const mat4 &); + +// ----- glm/trigonometric.hpp ----- + +FLOAT_SCALAR_OR_VECTOR(radians); +FLOAT_SCALAR_OR_VECTOR(degrees); +FLOAT_SCALAR_OR_VECTOR(sin); +FLOAT_SCALAR_OR_VECTOR(cos); +FLOAT_SCALAR_OR_VECTOR(tan); +FLOAT_SCALAR_OR_VECTOR(asin); +FLOAT_SCALAR_OR_VECTOR(acos); +FLOAT_SCALAR_OR_VECTOR_2_PARAMS(atan); +FLOAT_SCALAR_OR_VECTOR(atan); +FLOAT_SCALAR_OR_VECTOR(sinh); +FLOAT_SCALAR_OR_VECTOR(cosh); +FLOAT_SCALAR_OR_VECTOR(tanh); +FLOAT_SCALAR_OR_VECTOR(asinh); +FLOAT_SCALAR_OR_VECTOR(acosh); +FLOAT_SCALAR_OR_VECTOR(atanh); + +// ----- glm/gtc/epsilon.hpp ----- + +bool epsilonEqual(const float &, const float &, const float &); +vec2 epsilonEqual(const vec2 &, const vec2 &, const float &); +vec3 epsilonEqual(const vec3 &, const vec3 &, const float &); + +bool epsilonNotEqual(const float &, const float &, const float &); +vec2 epsilonNotEqual(const vec2 &, const vec2 &, const float &); +vec3 epsilonNotEqual(const vec3 &, const vec3 &, const float &); + +// ----- glm/gtc/matrix_access.hpp ----- + +vec3 row(const mat3 &, const length_t &); +vec4 row(const mat4 &, const length_t &); +mat3 row(const mat3 &, const length_t &, const vec3 &); +mat4 row(const mat4 &, const length_t &, const vec4 &); +vec3 column(const mat3 &, const length_t &); +vec4 column(const mat4 &, const length_t &); +mat3 column(const mat3 &, const length_t &, const vec3 &); +mat4 column(const mat4 &, const length_t &, const vec4 &); + +// ----- glm/gtc/matrix_inverse.hpp ----- + +mat3 affineInverse(const mat3 &); +mat4 affineInverse(const mat4 &); +mat3 inverseTranspose(const mat3 &); +mat4 inverseTranspose(const mat4 &); + +// ----- glm/ext/matrix_transform.hpp ----- + +//mat4 identity(); +mat4 translate(const mat4 &, const vec3 &); +mat4 rotate(const mat4 &, const float &, const vec3 &); +mat4 scale(const mat4 &, const vec3 &); +mat4 lookAt(const vec3 &, const vec3 &, const vec3 &); + +// ----- glm/ext/matrix_clip_space.hpp ----- + +mat4 ortho(const float &, const float &, + const float &, const float &); +mat4 ortho(const float &, const float &, + const float &, const float &, + const float &, const float &); +mat4 frustum(const float &, const float &, + const float &, const float &, + const float &, const float &); +mat4 perspective(const float &, const float &, + const float &, const float &); +mat4 perspectiveFov(const float &, + const float &, const float &, + const float &, const float &); +mat4 infinitePerspective(const float &, const float &, const float &); +mat4 tweakedInfinitePerspective(const float &, const float &, const float &); + +// ----- glm/ext/matrix_projection.hpp ----- + +vec3 project(const vec3 &, const mat4 &, const mat4 &, const vec4 &); +vec3 unProject(const vec3 &, const mat4 &, const mat4 &, const vec4 &); +mat4 pickMatrix(const vec2 &, const vec2 &, const vec4 &); + +// ----- glm/gtx/compatibility.hpp ----- + +FLOAT_SCALAR_OR_VECTOR_3_PARAMS(lerp); +FLOAT_SCALAR_OR_VECTOR_3_PARAMS_VECTOR_VECTOR_VALUE(lerp); +FLOAT_VECTOR(saturate); +FLOAT_VECTOR_2_PARAMS(atan2); +bool isfinite(float &); +vec2 isfinite(vec2 &); +vec3 isfinite(vec3 &); +vec4 isfinite(vec4 &); + +// scalar types seem to cause issues +//float atan2(float, float); +//float saturate(float); + +// ----- glm/gtx/fast_square_root.hpp ----- + +FLOAT_VECTOR(fastSqrt); +FLOAT_SCALAR_OR_VECTOR(fastInverseSqrt); +FLOAT_VECTOR_RETURN_VALUE(fastLength); +FLOAT_VECTOR_RETURN_VALUE_2_PARAMS(fastDistance); +FLOAT_VECTOR(fastNormalize); + +// ----- glm/gtx/norm.hpp ----- + +FLOAT_VECTOR_RETURN_VALUE(length2); +FLOAT_VECTOR_RETURN_VALUE_2_PARAMS(distance2); +float l1Norm(vec3 const &, vec3 const &); +float l1Norm(vec3 const &); +float l2Norm(vec3 const &, vec3 const &); +float l2Norm(vec3 const &); +float lxNorm(vec3 const &, vec3 const &, unsigned int); +float lxNorm(vec3 const &, unsigned int); + +// ----- glm/gtx/perpendicular.hpp ----- + +vec2 perp(const vec2 &, const vec2 &); +vec3 perp(const vec3 &, const vec3 &); + +// ----- glm/gtx/rotate_vector.hpp ----- + +vec3 slerp(const vec3 &, const vec3 &, const float &); +vec2 rotate(const vec2 &, const float &); +vec3 rotate(const vec3 &, const float &, const vec3 &); +vec4 rotate(const vec4 &, const float &, const vec3 &); +vec3 rotateX(const vec3 &, const float &); +vec4 rotateX(const vec4 &, const float &); +vec3 rotateY(const vec3 &, const float &); +vec4 rotateY(const vec4 &, const float &); +vec3 rotateZ(const vec3 &, const float &); +vec4 rotateZ(const vec4 &, const float &); +mat4 orientation(const vec3 &, const vec3 &); + +// ----- glm/gtx/scalar_multiplication.hpp ----- + +// handled in the type interfaces (ie. vec2.i, vec3.i, etc) + +// ----- glm/gtx/spline.hpp ----- + +vec2 catmullRom(const vec2 &, const vec2 &, const vec2 &, const vec2 &, const float &); +vec3 catmullRom(const vec3 &, const vec3 &, const vec3 &, const vec3 &, const float &); +vec2 hermite(const vec2 &, const vec2 &, const vec2 &, const vec2 &, const float &); +vec3 hermite(const vec3 &, const vec3 &, const vec3 &, const vec3 &, const float &); +vec2 cubic(const vec2 &, const vec2 &, const vec2 &, const vec2 &, const float &); +vec3 cubic(const vec3 &, const vec3 &, const vec3 &, const vec3 &, const float &); + +// ----- glm/gtx/transform.hpp ----- + +mat4 translate(const vec3 &); +mat4 rotate(float angle, const vec3 &); +mat4 scale(const vec3 &); + +// ----- glm/gtx/vector_angle.hpp ----- + +FLOAT_VECTOR_RETURN_VALUE_2_PARAMS(angle); +float orientedAngle(const vec2 &, const vec2 &); +float orientedAngle(const vec3 &, const vec3 &, const vec3 &); diff --git a/addons/ofxLua/swig/glm/mat3.i b/addons/ofxLua/swig/glm/mat3.i new file mode 100644 index 0000000..f04d971 --- /dev/null +++ b/addons/ofxLua/swig/glm/mat3.i @@ -0,0 +1,108 @@ +// glm::mat3 bindings +// 2018 Dan Wilcox + +// ----- glm/detail/type_mat3.hpp ----- + +struct mat3 { + + static length_t length(); + + mat3(); + mat3(mat3 const & v); + mat3(float scalar); + mat3(float x0, float y0, float z0, + float x1, float y1, float z1, + float x2, float y2, float z2); + mat3(vec3 const & v1, vec3 const & v2, vec3 const & v3); + mat3(glm::mat4 const & m); + + mat3 & operator=(mat3 const & m); +}; + +mat3 operator+(mat3 const & m, float scalar); +mat3 operator+(float scalar, mat3 const & m); +mat3 operator+(mat3 const & m1, mat3 const & m2); +mat3 operator-(mat3 const & m, float scalar); +mat3 operator-(float scalar, mat3 const & m); +mat3 operator-(mat3 const & m1, mat3 const & m2); +mat3 operator*(mat3 const & m, float scalar); +mat3 operator*(float scalar, mat3 const & m); +mat3 operator*(mat3 const & m1, mat3 const & m2); +vec3 operator*(vec3 const & v, mat3 const & m); +vec3 operator*(mat3 const & m, vec3 const & v); +mat3 operator/(mat3 const & m, float scalar); +mat3 operator/(float scalar, mat3 const & m); +mat3 operator/(mat3 const & m1, mat3 const & m2); +vec3 operator/(mat3 const & m, vec3 const & v); +vec3 operator/(vec3 const & v, mat3 const & m); +bool operator==(mat3 const & m1, mat3 const & m2); +bool operator!=(mat3 const & m1, mat3 const & m2); + +%extend mat3 { + + // [] getter + // out of bounds throws a string, which causes a Lua error + vec3 __getitem__(int i) throw (std::out_of_range) { + #ifdef SWIGLUA + if(i < 1 || i > $self->length()) { + throw std::out_of_range("in glm::mat3::__getitem__()"); + } + return (*$self)[i-1]; + #else + if(i < 0 || i >= $self->length()) { + throw std::out_of_range("in glm::mat3::__getitem__()"); + } + return (*$self)[i]; + #endif + } + + // [] setter + // out of bounds throws a string, which causes a Lua error + void __setitem__(int i, vec3 v) throw (std::out_of_range) { + #ifdef SWIGLUA + if(i < 1 || i > $self->length()) { + throw std::out_of_range("in glm::mat3::__setitem__()"); + } + (*$self)[i-1] = v; + #else + if(i < 0 || i >= $self->length()) { + throw std::out_of_range("in glm::mat3::__setitem__()"); + } + (*$self)[i] = v; + #endif + } + + // tostring operator + std::string __tostring() { + std::stringstream str; + const glm::length_t width = $self->length(); + const glm::length_t height = (*$self)[0].length(); + for(glm::length_t row = 0; row < height; ++row) { + for(glm::length_t col = 0; col < width; ++col) { + str << (*$self)[col][row]; + if(col + 1 != width) { + str << "\t"; + } + } + if(row + 1 != height) { + str << "\n"; + } + } + return str.str(); + } + + // extend operators, otherwise some languages (lua) + // won't be able to act on objects directly (ie. v1 + v2) + mat3 operator+(float scalar) {return (*$self) + scalar;} + mat3 operator+(mat3 const & m) {return (*$self) + m;} + mat3 operator-(float scalar) {return (*$self) - scalar;} + mat3 operator-(mat3 const & m) {return (*$self) - m;} + mat3 operator*(float scalar) {return (*$self) * scalar;} + mat3 operator*(mat3 const & m) {return (*$self) * m;} + vec3 operator*(vec3 const & v) {return (*$self) * v;} + mat3 operator/(float scalar) {return (*$self) / scalar;} + mat3 operator/(mat3 const & m) {return (*$self) / m;} + vec3 operator/(vec3 const & v) {return (*$self) / v;} + bool operator==(mat3 const & m) {return (*$self) == m;} + bool operator!=(mat3 const & m1) {return (*$self) != m;} +}; diff --git a/addons/ofxLua/swig/glm/mat4.i b/addons/ofxLua/swig/glm/mat4.i new file mode 100644 index 0000000..94a4fb2 --- /dev/null +++ b/addons/ofxLua/swig/glm/mat4.i @@ -0,0 +1,109 @@ +// glm::mat4 bindings +// 2018 Dan Wilcox + +// ----- glm/detail/type_mat4hpp ----- + +struct mat4 { + + static length_t length(); + + mat4(); + mat4(mat4 const & v); + mat4(float scalar); + mat4(float x0, float y0, float z0, float w0, + float x1, float y1, float z1, float w1, + float x2, float y2, float z2, float w2, + float x3, float y3, float z3, float w3); + mat4(vec4 const & v1, vec4 const & v2, vec4 const & v3, vec4 const & v4); + mat4(mat3 const & m); + + mat4 & operator=(mat4 const & m); +}; + +mat4 operator+(mat4 const & m, float scalar); +mat4 operator+(float scalar, mat4 const & m); +mat4 operator+(mat4 const & m1, mat4 const & m2); +mat4 operator-(mat4 const & m, float scalar); +mat4 operator-(float scalar, mat4 const & m); +mat4 operator-(mat4 const & m1, mat4 const & m2); +mat4 operator*(mat4 const & m, float scalar); +mat4 operator*(float scalar, mat4 const & v); +mat4 operator*(mat4 const & m1, mat4 const & m2); +vec4 operator*(mat4 const & m, vec4 const & v); +vec4 operator*(vec4 const & v, mat4 const & m); +mat4 operator/(mat4 const & m, float scalar); +mat4 operator/(float scalar, mat4 const & m); +mat4 operator/(mat4 const & m1, mat4 const & m2); +vec4 operator/(mat4 const & m, vec4 const & v); +vec4 operator/(vec4 const & v, mat4 const & m); +bool operator==(mat4 const & m1, mat4 const & m2); +bool operator!=(mat4 const & m1, mat4 const & m2); + +%extend mat4 { + + // [] getter + // out of bounds throws a string, which causes a Lua error + vec4 __getitem__(int i) throw (std::out_of_range) { + #ifdef SWIGLUA + if(i < 1 || i > $self->length()) { + throw std::out_of_range("in glm::mat4::__getitem__()"); + } + return (*$self)[i-1]; + #else + if(i < 0 || i >= $self->length()) { + throw std::out_of_range("in glm::mat4::__getitem__()"); + } + return (*$self)[i]; + #endif + } + + // [] setter + // out of bounds throws a string, which causes a Lua error + void __setitem__(int i, vec4 v) throw (std::out_of_range) { + #ifdef SWIGLUA + if(i < 1 || i > $self->length()) { + throw std::out_of_range("in glm::mat4::__setitem__()"); + } + (*$self)[i-1] = v; + #else + if(i < 0 || i >= $self->length()) { + throw std::out_of_range("in glm::mat4::__setitem__()"); + } + (*$self)[i] = v; + #endif + } + + // tostring operator + std::string __tostring() { + std::stringstream str; + const glm::length_t width = $self->length(); + const glm::length_t height = (*$self)[0].length(); + for(glm::length_t row = 0; row < height; ++row) { + for(glm::length_t col = 0; col < width; ++col) { + str << (*$self)[col][row]; + if(col + 1 != width) { + str << "\t"; + } + } + if(row + 1 != height) { + str << "\n"; + } + } + return str.str(); + } + + // extend operators, otherwise some languages (lua) + // won't be able to act on objects directly (ie. v1 + v2) + mat4 operator+(float scalar) {return (*$self) + scalar;} + mat4 operator+(mat4 const & m) {return (*$self) + m;} + mat4 operator-(float scalar) {return (*$self) - scalar;} + mat4 operator-(mat4 const & m) {return (*$self) - m;} + mat4 operator*(float scalar) {return (*$self) * scalar;} + mat4 operator*(mat4 const & m) {return (*$self) * m;} + vec4 operator*(vec4 const & v) {return (*$self) * v;} + mat4 operator/(float scalar) {return (*$self) / scalar;} + mat4 operator/(mat4 const & m) {return (*$self) / m;} + vec4 operator/(vec4 const & v) {return (*$self) / v;} + bool operator==(mat4 const & m) {return (*$self) == m;} + bool operator!=(mat4 const & m1) {return (*$self) != m;} +}; diff --git a/addons/ofxLua/swig/glm/quat.i b/addons/ofxLua/swig/glm/quat.i new file mode 100644 index 0000000..d6460e5 --- /dev/null +++ b/addons/ofxLua/swig/glm/quat.i @@ -0,0 +1,122 @@ +// glm::quat bindings +// 2018 Dan Wilcox + +// ----- glm/gtc/quaternion.hpp ----- + +struct quat { + + float x, y, z, w; + + static length_t length(); + + quat(); + quat(quat const & q); + quat(float s, vec3 const & v); + quat(float w, float x, float y, float z); + quat(vec3 const & u, vec3 const & v); + quat(vec3 const & eulerAngles); + quat(mat3 const & m); + quat(mat4 const & m); +}; + +quat operator+(quat const & q, quat const & p); +quat operator*(quat const & q, quat const & p); +vec3 operator*(quat const & q, vec3 const & v); +vec3 operator*(vec3 const & v, quat const & q); +vec4 operator*(quat const & q, vec4 const & v); +vec4 operator*(vec4 const & v, quat const & q); +quat operator*(quat const & q, float const & s); +quat operator*(float const & s, quat const & q); +quat operator/(quat const & q, float const & s); +bool operator==(quat const & q1, quat const & q2); +bool operator!=(quat const & q1, quat const & q2); + +float length(quat const & q); + +quat normalize(quat const & q); +float dot(quat const & x, quat const & y); +quat mix(quat const & x, quat const & y, float a); +quat lerp(quat const & x, quat const & y, float a); +quat slerp(quat const & x, quat const & y, float a); +quat conjugate(quat const & q); +quat inverse(quat const & q); +quat rotate(quat const & q, float const & angle, vec3 const & axis); +vec3 eulerAngles(quat const & x); +float roll(quat const & x); +float pitch(quat const & x); +float yaw(quat const & x); +mat3 mat3_cast(quat const & x); +mat4 mat4_cast(quat const & x); +quat quat_cast(glm::mat3 const & x); +quat quat_cast(glm::mat4 const & x); +float angle(quat const & x); +vec3 axis(quat const & x); +quat angleAxis(float const & angle, vec3 const & axis); + +// not sure what to do with these yet +// vec4 lessThan(quat const & x, quat const & y); +// vec4 lessThanEqual(quat const & x, quat const & y); +// vec4 greaterThan(quat const & x, quat const & y); +// vec4 greaterThanEqual(quat const & x, quat const & y); +// vec4 equal(quat const & x, quat const & y); +// vec4 notEqual(quat const & x, quat const & y); +// vec4 isnan(quat const & x); +// vec4 isinf(quat const & x); + +%extend quat { + + // [] getter + // out of bounds throws a string, which causes a Lua error + float __getitem__(int i) throw (std::out_of_range) { + #ifdef SWIGLUA + if(i < 1 || i > $self->length()) { + throw std::out_of_range("in glm::quat::__getitem__()"); + } + return (*$self)[i-1]; + #else + if(i < 0 || i >= $self->length()) { + throw std::out_of_range("in glm::quat::__getitem__()"); + } + return (*$self)[i]; + #endif + } + + // [] setter + // out of bounds throws a string, which causes a Lua error + void __setitem__(int i, float f) throw (std::out_of_range) { + #ifdef SWIGLUA + if(i < 1 || i > $self->length()) { + throw std::out_of_range("in glm::quat::__setitem__()"); + } + (*$self)[i-1] = f; + #else + if(i < 0 || i >= $self->length()) { + throw std::out_of_range("in glm::quat::__setitem__()"); + } + (*$self)[i] = f; + #endif + } + + // to string operator + std::string __tostring() { + std::stringstream str; + for(glm::length_t i = 0; i < $self->length(); ++i) { + str << (*$self)[i]; + if(i + 1 != $self->length()) { + str << " "; + } + } + return str.str(); + } + + // extend operators, otherwise some languages (lua) + // won't be able to act on objects directly (ie. v1 + v2) + quat operator+(quat const & q) {return (*$self) + q;} + quat operator*(quat const & q) {return (*$self) * q;} + vec3 operator*(vec3 const & v) {return (*$self) * v;} + vec4 operator*(vec4 const & v) {return (*$self) * v;} + quat operator*(float const & s) {return (*$self) * s;} + quat operator/(float const & s) {return (*$self) / s;} + bool operator==(quat const & q) {return (*$self) == q;} + bool operator!=(quat const & q) {return (*$self) != q;} +}; diff --git a/addons/ofxLua/swig/glm/vec2.i b/addons/ofxLua/swig/glm/vec2.i new file mode 100644 index 0000000..c636e6f --- /dev/null +++ b/addons/ofxLua/swig/glm/vec2.i @@ -0,0 +1,100 @@ +// glm::vec2 bindings +// 2018 Dan Wilcox + +// ----- glm/detail/type_vec2.hpp ----- + +struct vec2 { + + float x, y; + + static length_t length(); + + vec2(); + vec2(vec2 const & v); + vec2(float scalar); + vec2(float s1, float s2); + vec2(glm::vec3 const & v); + vec2(glm::vec4 const & v); + + vec2 & operator=(vec2 const & v); +}; + +vec2 operator+(vec2 const & v, float scalar); +vec2 operator+(float scalar, vec2 const & v); +vec2 operator+(vec2 const & v1, vec2 const & v2); +vec2 operator-(vec2 const & v, float scalar); +vec2 operator-(float scalar, vec2 const & v); +vec2 operator-(vec2 const & v1, vec2 const & v2); +vec2 operator*(vec2 const & v, float scalar); +vec2 operator*(float scalar, vec2 const & v); +vec2 operator*(vec2 const & v1, vec2 const & v2); +vec2 operator/(vec2 const & v, float scalar); +vec2 operator/(float scalar, vec2 const & v); +vec2 operator/(vec2 const & v1, vec2 const & v2); +vec2 operator%(vec2 const & v, float scalar); +vec2 operator%(float scalar, vec2 const & v); +vec2 operator%(vec2 const & v1, vec2 const & v2); +bool operator==(vec2 const & v1, vec2 const & v2); +bool operator!=(vec2 const & v1, vec2 const & v2); + +%extend vec2 { + + // [] getter + // out of bounds throws a string, which causes a Lua error + float __getitem__(int i) throw (std::out_of_range) { + #ifdef SWIGLUA + if(i < 1 || i > $self->length()) { + throw std::out_of_range("in glm::vec2::__getitem__()"); + } + return (*$self)[i-1]; + #else + if(i < 0 || i >= $self->length()) { + throw std::out_of_range("in glm::vec2::__getitem__()"); + } + return (*$self)[i]; + #endif + } + + // [] setter + // out of bounds throws a string, which causes a Lua error + void __setitem__(int i, float f) throw (std::out_of_range) { + #ifdef SWIGLUA + if(i < 1 || i > $self->length()) { + throw std::out_of_range("in glm::vec2::__setitem__()"); + } + (*$self)[i-1] = f; + #else + if(i < 0 || i >= $self->length()) { + throw std::out_of_range("in glm::vec2::__setitem__()"); + } + (*$self)[i] = f; + #endif + } + + // tostring operator + std::string __tostring() { + std::stringstream str; + for(glm::length_t i = 0; i < $self->length(); ++i) { + str << (*$self)[i]; + if(i + 1 != $self->length()) { + str << " "; + } + } + return str.str(); + } + + // extend operators, otherwise some languages (lua) + // won't be able to act on objects directly (ie. v1 + v2) + vec2 operator+(vec2 const & v) {return (*$self) + v;} + vec2 operator+(float scalar) {return (*$self) + scalar;} + vec2 operator-(vec2 const & v) {return (*$self) - v;} + vec2 operator-(float scalar) {return (*$self) - scalar;} + vec2 operator*(vec2 const & v) {return (*$self) * v;} + vec2 operator*(float scalar) {return (*$self) * scalar;} + vec2 operator/(vec2 const & v) {return (*$self) / v;} + vec2 operator/(float scalar) {return (*$self) / scalar;} + vec2 operator%(vec2 const & v) {return (*$self) % v;} + vec2 operator%(float scalar) {return (*$self) % scalar;} + bool operator==(vec2 const & v) {return (*$self) == v;} + bool operator!=(vec2 const & v) {return (*$self) != v;} +}; diff --git a/addons/ofxLua/swig/glm/vec3.i b/addons/ofxLua/swig/glm/vec3.i new file mode 100644 index 0000000..caa15b8 --- /dev/null +++ b/addons/ofxLua/swig/glm/vec3.i @@ -0,0 +1,101 @@ +// glm::vec3 bindings +// 2018 Dan Wilcox + +// ----- glm/detail/type_vec3.hpp ----- + +struct vec3 { + + float x, y, z; + + static length_t length(); + + vec3(); + vec3(vec3 const & v); + vec3(float scalar); + vec3(float s1, float s2, float s3); + vec3(glm::vec2 const & a, float b); + vec3(float a, glm::vec2 const & b); + vec3(glm::vec4 const & v); + + vec3 & operator=(vec3 const & v); +}; + +vec3 operator+(vec3 const & v, float scalar); +vec3 operator+(float scalar, vec3 const & v); +vec3 operator+(vec3 const & v1, vec3 const & v2); +vec3 operator-(vec3 const & v, float scalar); +vec3 operator-(float scalar, vec3 const & v); +vec3 operator-(vec3 const & v1, vec3 const & v2); +vec3 operator*(vec3 const & v, float scalar); +vec3 operator*(float scalar, vec3 const & v); +vec3 operator*(vec3 const & v1, vec3 const & v2); +vec3 operator/(vec3 const & v, float scalar); +vec3 operator/(float scalar, vec3 const & v); +vec3 operator/(vec3 const & v1, vec3 const & v2); +vec3 operator%(vec3 const & v, float scalar); +vec3 operator%(float scalar, vec3 const & v); +vec3 operator%(vec3 const & v1, vec3 const & v2); +bool operator==(vec3 const & v1, vec3 const & v2); +bool operator!=(vec3 const & v1, vec3 const & v2); + +%extend vec3 { + + // [] getter + // out of bounds throws a string, which causes a Lua error + float __getitem__(int i) throw (std::out_of_range) { + #ifdef SWIGLUA + if(i < 1 || i > $self->length()) { + throw std::out_of_range("in glm::vec3::__getitem__()"); + } + return (*$self)[i-1]; + #else + if(i < 0 || i >= $self->length()) { + throw std::out_of_range("in glm::vec3::__getitem__()"); + } + return (*$self)[i]; + #endif + } + + // [] setter + // out of bounds throws a string, which causes a Lua error + void __setitem__(int i, float f) throw (std::out_of_range) { + #ifdef SWIGLUA + if(i < 1 || i > $self->length()) { + throw std::out_of_range("in glm::vec3::__setitem__()"); + } + (*$self)[i-1] = f; + #else + if(i < 0 || i >= $self->length()) { + throw std::out_of_range("in glm::vec3::__setitem__()"); + } + (*$self)[i] = f; + #endif + } + + // tostring operator + std::string __tostring() { + std::stringstream str; + for(glm::length_t i = 0; i < $self->length(); ++i) { + str << (*$self)[i]; + if(i + 1 != $self->length()) { + str << " "; + } + } + return str.str(); + } + + // extend operators, otherwise some languages (lua) + // won't be able to act on objects directly (ie. v1 + v2) + vec3 operator+(vec3 const & v) {return (*$self) + v;} + vec3 operator+(float scalar) {return (*$self) + scalar;} + vec3 operator-(vec3 const & v) {return (*$self) - v;} + vec3 operator-(float scalar) {return (*$self) - scalar;} + vec3 operator*(vec3 const & v) {return (*$self) * v;} + vec3 operator*(float scalar) {return (*$self) * scalar;} + vec3 operator/(vec3 const & v) {return (*$self) / v;} + vec3 operator/(float scalar) {return (*$self) / scalar;} + vec3 operator%(vec3 const & v) {return (*$self) % v;} + vec3 operator%(float scalar) {return (*$self) % scalar;} + bool operator==(vec3 const & v) {return (*$self) == v;} + bool operator!=(vec3 const & v) {return (*$self) != v;} +}; diff --git a/addons/ofxLua/swig/glm/vec4.i b/addons/ofxLua/swig/glm/vec4.i new file mode 100644 index 0000000..78ab956 --- /dev/null +++ b/addons/ofxLua/swig/glm/vec4.i @@ -0,0 +1,104 @@ +// glm::vec4 bindings +// 2018 Dan Wilcox + +// ----- glm/detail/type_vec4.hpp ----- + +struct vec4 { + + float x, y, z, w; + + static length_t length(); + + vec4(); + vec4(vec4 const & v); + vec4(float scalar); + vec4(float s1, float s2, float s3, float s4); + vec4(vec2 const & a, vec2 const & b); + vec4(vec2 const & a, float b, float c); + vec4(float a, vec2 const & b, float c); + vec4(float a, float b, vec2 const & c); + vec4(vec3 const & a, float b); + vec4(float a, vec3 const & b); + + vec4 & operator=(vec4 const & v); +}; + +vec4 operator+(vec4 const & v, float scalar); +vec4 operator+(float scalar, vec4 const & v); +vec4 operator+(vec4 const & v1, vec4 const & v2); +vec4 operator-(vec4 const & v, float scalar); +vec4 operator-(float scalar, vec4 const & v); +vec4 operator-(vec4 const & v1, vec4 const & v2); +vec4 operator*(vec4 const & v, float scalar); +vec4 operator*(float scalar, vec4 const & v); +vec4 operator*(vec4 const & v1, vec4 const & v2); +vec4 operator/(vec4 const & v, float scalar); +vec4 operator/(float scalar, vec4 const & v); +vec4 operator/(vec4 const & v1, vec4 const & v2); +vec4 operator%(vec4 const & v, float scalar); +vec4 operator%(float scalar, vec4 const & v); +vec4 operator%(vec4 const & v1, vec4 const & v2); +bool operator==(vec4 const & v1, vec4 const & v2); +bool operator!=(vec4 const & v1, vec4 const & v2); + +%extend vec4 { + + // [] getter + // out of bounds throws a string, which causes a Lua error + float __getitem__(int i) throw (std::out_of_range) { + #ifdef SWIGLUA + if(i < 1 || i > $self->length()) { + throw std::out_of_range("in glm::vec4::__getitem__()"); + } + return (*$self)[i-1]; + #else + if(i < 0 || i >= $self->length()) { + throw std::out_of_range("in glm::vec4::__getitem__()"); + } + return (*$self)[i]; + #endif + } + + // [] setter + // out of bounds throws a string, which causes a Lua error + void __setitem__(int i, float f) throw (std::out_of_range) { + #ifdef SWIGLUA + if(i < 1 || i > $self->length()) { + throw std::out_of_range("in glm::vec4::__setitem__()"); + } + (*$self)[i-1] = f; + #else + if(i < 0 || i >= $self->length()) { + throw std::out_of_range("in glm::vec4::__setitem__()"); + } + (*$self)[i] = f; + #endif + } + + // tostring operator + std::string __tostring() { + std::stringstream str; + for(glm::length_t i = 0; i < $self->length(); ++i) { + str << (*$self)[i]; + if(i + 1 != $self->length()) { + str << " "; + } + } + return str.str(); + } + + // extend operators, otherwise some languages (lua) + // won't be able to act on objects directly (ie. v1 + v2) + vec4 operator+(vec4 const & v) {return (*$self) + v;} + vec4 operator+(float scalar) {return (*$self) + scalar;} + vec4 operator-(vec4 const & v) {return (*$self) - v;} + vec4 operator-(float scalar) {return (*$self) - scalar;} + vec4 operator*(vec4 const & v) {return (*$self) * v;} + vec4 operator*(float scalar) {return (*$self) * scalar;} + vec4 operator/(vec4 const & v) {return (*$self) / v;} + vec4 operator/(float scalar) {return (*$self) / scalar;} + vec4 operator%(vec4 const & v) {return (*$self) % v;} + vec4 operator%(float scalar) {return (*$self) % scalar;} + bool operator==(vec4 const & v) {return (*$self) == v;} + bool operator!=(vec4 const & v) {return (*$self) != v;} +}; diff --git a/addons/ofxLua/swig/interfaces/openFrameworks/3d.i b/addons/ofxLua/swig/interfaces/openFrameworks/3d.i deleted file mode 100644 index c39c5f3..0000000 --- a/addons/ofxLua/swig/interfaces/openFrameworks/3d.i +++ /dev/null @@ -1,45 +0,0 @@ -// 3d folder bindings -// 2017 Dan Wilcox - -// ----- ofNode.h ----- - -// DIFF: ofNode.h: ignoring const & copy constructor in favor of && constructor -%ignore ofNode::ofNode(ofNode const &); - -// process ofNode first since it's a base class -%include "3d/ofNode.h" - -// ----- of3dUtils.h ----- - -%include "3d/of3dUtils.h" - -// ----- ofCamera.h ----- - -%include "3d/ofCamera.h" - -// ----- ofEasyCam.h ----- - -%include "3d/ofEasyCam.h" - -// ----- ofMesh.h ----- - -// tesselator index -#ifdef TARGET_OPENGLES - %typedef unsigned short TESSindex; -#else - %typedef unsigned int TESSindex; -#endif - -// add ofMesh virtual destructor -%extend ofMesh { - virtual ~ofMesh() { - $self->clear(); - delete $self; - } -}; - -%include "3d/ofMesh.h" - -// ----- of3dPrimitives.h ----- - -%include "3d/of3dPrimitives.h" diff --git a/addons/ofxLua/swig/interfaces/openFrameworks/communication.i b/addons/ofxLua/swig/interfaces/openFrameworks/communication.i deleted file mode 100644 index 2311f4c..0000000 --- a/addons/ofxLua/swig/interfaces/openFrameworks/communication.i +++ /dev/null @@ -1,24 +0,0 @@ -// communication folder bindings -// 2017 Dan Wilcox - -// ----- ofArduino.h ----- - -// DIFF: ofArduino.h: ignoring functions which return list points -%ignore ofArduino::getDigitalHistory(int); -%ignore ofArduino::getAnalogHistory(int); -%ignore ofArduino::getSysExHistory(); -%ignore ofArduino::getStringHistory(); - -%include "communication/ofArduino.h" - -// ----- ofSerial.h ----- - -// DIFF: ofSerial.h: -// DIFF: pass binary data to ofSerial as full char strings -// DIFF: pass binary data & byte length as a single argument for ofBuffer -%apply(unsigned char *STRING, int LENGTH) {(unsigned char * buffer, int length)}; - -%include "communication/ofSerial.h" - -// clear typemap -%clear(unsigned char * buffer, int length); diff --git a/addons/ofxLua/swig/openFrameworks.i b/addons/ofxLua/swig/openFrameworks.i index ba27683..751fc4d 100644 --- a/addons/ofxLua/swig/openFrameworks.i +++ b/addons/ofxLua/swig/openFrameworks.i @@ -1,4 +1,4 @@ -// SWIG (http://www.swig.org) interface wrapper for the OpenFrameworks core API +// SWIG (http://www.swig.org) interface wrapper for the openFrameworks core API // 2014-17 Dan Wilcox // workaround when compiling in MinGW (Python) @@ -60,17 +60,17 @@ // ----- Lang specifics ------ #ifdef SWIGLUA -%include "interfaces/lang/lua/lua.i" +%include "openFrameworks/lang/lua/lua.i" #endif #ifdef SWIGPYTHON -%include "interfaces/lang/lua/python.i" +%include "openFrameworks/lang/python/python.i" #endif // ----- Deprecated ------ #ifndef OF_SWIG_DEPRECATED - %include "interfaces/deprecated.i" + %include "openFrameworks/deprecated.i" #endif // ----- Bindings------ @@ -108,24 +108,33 @@ // This forward declaration is then overridden by the actual implementation after // %include "SomeClass.h" later on. -%include "interfaces/openFrameworks/main.i" -%include "interfaces/openFrameworks/3d.i" -%include "interfaces/openFrameworks/app.i" +%include "openFrameworks/openFrameworks/main.i" +%include "openFrameworks/openFrameworks/3d.i" +%include "openFrameworks/openFrameworks/app.i" #if !defined(TARGET_IOS) && !defined(TARGET_ANDROID) -%include "interfaces/openFrameworks/communication.i" +%include "openFrameworks/openFrameworks/communication.i" #endif -%include "interfaces/openFrameworks/math.i" -%include "interfaces/openFrameworks/events.i" -%include "interfaces/openFrameworks/gl.i" -%include "interfaces/openFrameworks/graphics.i" -%include "interfaces/openFrameworks/sound.i" -%include "interfaces/openFrameworks/types.i" -%include "interfaces/openFrameworks/utils.i" -%include "interfaces/openFrameworks/video.i" - +%include "openFrameworks/openFrameworks/math.i" +%include "openFrameworks/openFrameworks/events.i" +%include "openFrameworks/openFrameworks/gl.i" +%include "openFrameworks/openFrameworks/graphics.i" +%include "openFrameworks/openFrameworks/sound.i" +%include "openFrameworks/openFrameworks/types.i" +%include "openFrameworks/openFrameworks/utils.i" +%include "openFrameworks/openFrameworks/video.i" // ----- Attributes ------ #ifdef OF_SWIG_ATTRIBUTES - %include "interfaces/attributes.i" + %include "openFrameworks/attributes.i" +#endif + +// ----- Lang code ------ + +#ifdef SWIGLUA +%include "openFrameworks/lang/lua/lua_code.i" +#endif + +#ifdef SWIGPYTHON +%include "openFrameworks/lang/python/python_code.i" #endif diff --git a/addons/ofxLua/swig/interfaces/attributes.i b/addons/ofxLua/swig/openFrameworks/attributes.i similarity index 98% rename from addons/ofxLua/swig/interfaces/attributes.i rename to addons/ofxLua/swig/openFrameworks/attributes.i index 709dca3..2b8eec5 100644 --- a/addons/ofxLua/swig/interfaces/attributes.i +++ b/addons/ofxLua/swig/openFrameworks/attributes.i @@ -122,7 +122,7 @@ // ATTR: ofFileUtils.h: ofBuffer getter: length, data, text %attribute(ofBuffer, long, length, size); %attribute(ofBuffer, char *, data, getData); -%attributestring(ofBuffer, string, text, getText); +%attributestring(ofBuffer, std::string, text, getText); // ----- ofVideoGrabber.h ----- @@ -146,7 +146,7 @@ // ATTR: height, duration, loaded, playing, initialized, numFrames // ATTR: getter/setter: usingTexture, pixelFormat, position, // ATTR: speed, loopState, paused, frame -%attributestring(ofVideoPlayer, string, moviePath, getMoviePath); +%attributestring(ofVideoPlayer, std::string, moviePath, getMoviePath); %attribute(ofVideoPlayer, ofPixelFormat, pixelFormat, getPixelFormat, setPixelFormat); %attribute(ofVideoPlayer, bool, frameNew, isFrameNew); %attribute(ofVideoPlayer, ofPixels &, pixels, getPixels); diff --git a/addons/ofxLua/swig/interfaces/deprecated.i b/addons/ofxLua/swig/openFrameworks/deprecated.i similarity index 64% rename from addons/ofxLua/swig/interfaces/deprecated.i rename to addons/ofxLua/swig/openFrameworks/deprecated.i index 485bd94..2bae0ec 100644 --- a/addons/ofxLua/swig/interfaces/deprecated.i +++ b/addons/ofxLua/swig/openFrameworks/deprecated.i @@ -2,11 +2,44 @@ // these are functions wrapped by the OF_DEPRECATED_MSG macro // 2015 Dan Wilcox +// ----- ofNode.h ----- + +%ignore ofNode::getPitch; +%ignore ofNode::getHeading; +%ignore ofNode::getRoll; +%ignore ofNode::getOrientationEuler; +%ignore ofNode::tilt; +%ignore ofNode::pan; +%ignore ofNode::roll; +%ignore ofNode::rotate; +%ignore ofNode::rotateAround(float, const glm::vec3&, const glm::vec3&); +%ignore ofNode::orbit; + +// ----- ofMaterial.h ----- + +%ignore ofMaterial::getData; +%ignore ofMaterial::setData; + +// ----- ofRectangle.h ----- + +%ignore ofRectangle::getPositionRef; + // ----- ofFbo.h ----- %ignore ofFbo::destroy; %ignore ofFbo::getTextureReference; +%ignore ofFbo::begin(bool) const; %ignore ofFbo::getFbo; +%ignore ofFbo::Settings; + +// ----- ofGLUtils.h ----- + +// deprecated in favor of ofGetGL* +%ignore ofGetGlInternalFormat; +%ignore ofGetGlInternalFormatName; +%ignore ofGetGlTypeFromInternal; +%ignore ofGetGlType; +%ignore ofGetGlFormat; // ----- ofTexture.h ----- @@ -17,8 +50,6 @@ %ignore ofGetUsingCustomMinMagFilters; %ignore ofRestoreMinMagFilters; %ignore ofTexture::bAllocated; -%ignore ofTexture::getTextureReference; -%ignore ofTexture::texData; // ----- ofImage.h ----- @@ -26,11 +57,19 @@ %ignore ofImage_::loadImage; %ignore ofImage_::getTextureReference; %ignore ofImage_::getPixelsRef; -%ignore ofImage_::getPixels; %ignore ofImage_::saveImage; // ----- ofSoundStream.h ----- +%ignore ofSoundStreamSetup(int, int); +%ignore ofSoundStreamSetup(int, int, ofBaseApp *); +%ignore ofSoundStreamSetup(int, int, int, int, int); +%ignore ofSoundStreamSetup(int, int, ofBaseApp *, int, int, int); + +%ignore ofSoundStream::setDeviceID; +%ignore ofSoundStream::setDevice; +%ignore ofSoundStream::setup(ofBaseApp *, int, int, int, int, int); +%ignore ofSoundStream::setup(int, int, int, int, int); %ignore ofSoundStream::listDevices; // ----- ofSoundPlayer.h ----- @@ -45,8 +84,8 @@ // ----- ofAppRunner.h ----- -%ignore ofSetupOpenGL(ofAppBaseWindow *, int, int, int); -%ignore ofRunApp(ofBaseApp *); +//%ignore ofSetupOpenGL(ofAppBaseWindow *, int, int, int); +//%ignore ofRunApp(ofBaseApp *); // ----- ofSerial.h ----- @@ -55,17 +94,22 @@ // ----- ofPixels.h ----- %ignore ofPixels_::getPixels; -%ignore ofPixels_::operator PixelType*(); -%ignore ofPixels_::operator const PixelType*(); + +// ----- ofPolyline.h ----- + +%ignore ofPolyline_::getAngleAtIndex; +%ignore ofPolyline_::getAngleAtIndexInterpolated; +%ignore ofPolyline_::rotate; // ----- ofPath.h ----- %ignore ofPath::setArcResolution; %ignore ofPath::getArcResolution; +%ignore ofPath::rotate; // ----- ofGraphics.h ----- -%ignore ofGetBackground(); +%ignore ofGetBackground; %ignore ofbClearBg; %ignore ofTriangle; %ignore ofCircle; @@ -75,6 +119,10 @@ %ignore ofRectRounded; %ignore ofCurve; %ignore ofBezier; +%ignore ofRotate; +%ignore ofRotateX; +%ignore ofRotateY; +%ignore ofRotateZ; %ignore ofSetupScreenPerspective(float, float, ofOrientation); %ignore ofSetupScreenPerspective(float, float, ofOrientation, bool); %ignore ofSetupScreenPerspective(float, float, ofOrientation, bool, float); @@ -136,13 +184,20 @@ // ----- ofFileUtils.h ----- -%ignore ofBuffer::getBinaryBuffer(); -%ignore ofBuffer::getBinaryBuffer() const; -%ignore ofBuffer::getNextLine(); -%ignore ofBuffer::getFirstLine(); -%ignore ofBuffer::isLastLine(); -%ignore ofBuffer::resetLineReader(); -%ignore ofDirectory::numFiles(); +%ignore ofBuffer::getBinaryBuffer; +%ignore ofBuffer::getBinaryBuffer const; +%ignore ofBuffer::getNextLine; +%ignore ofBuffer::getFirstLine; +%ignore ofBuffer::isLastLine; +%ignore ofBuffer::resetLineReader; +%ignore ofFile::setReadOnly; +%ignore ofDirectory::setReadOnly; +%ignore ofDirectory::numFiles; + +// ----- ofUtils.h ----- + +%ignore ofGetSystemTime; +%ignore ofAppendUTF8; // ----- ofVideoGrabber.h ----- @@ -152,7 +207,6 @@ // ----- ofVideoPlayer.h ----- -%ignore ofVideoPlayer::initGrabber; %ignore ofVideoPlayer::loadMovie; %ignore ofVideoPlayer::getPixelsRef; %ignore ofVideoPlayer::getTextureReference; diff --git a/addons/ofxLua/swig/interfaces/lang/lua/lua.i b/addons/ofxLua/swig/openFrameworks/lang/lua/lua.i similarity index 52% rename from addons/ofxLua/swig/interfaces/lang/lua/lua.i rename to addons/ofxLua/swig/openFrameworks/lang/lua/lua.i index 6c50946..d723afe 100644 --- a/addons/ofxLua/swig/interfaces/lang/lua/lua.i +++ b/addons/ofxLua/swig/openFrameworks/lang/lua/lua.i @@ -61,83 +61,21 @@ %ignore ofPixels_::ConstLines::end; %ignore ofPixels_::Pixels::end; -// ignore these to silence Warning 314 +%ignore ofUnicode::range::end; + +%ignore ofBuffer::Lines::end; +%ignore ofBuffer::RLines::end; + %ignore ofUTF8Iterator::end; -// ----- luacode ----- - -// support for simple classes from http://lua-users.org/wiki/SimpleLuaClasses -// -// example usage: -// -// -- class declaration -// MyClass = class() -// -// -- constructor & attributes -// function MyClass:__init(x, y) -// self.x = x -// self.y = y -// self.bBeingDragged = false -// self.bOver = false -// self.radius = 4 -// end -// -// -- create instance & access attribute -// myclass = MyClass(10, 10) -// myclass.x = 100 - -%luacode %{ - --- this isn't wrapped correctly, so set it here -of.CLOSE = true - --- handle typedefs which swig doesn't wrap -of.Point = of.Vec3f - --- class.lua --- Compatible with Lua 5.1 (not 5.0). -function class(base, __init) - local c = {} -- a new class instance - if not __init and type(base) == 'function' then - __init = base - base = nil - elseif type(base) == 'table' then - -- our new class is a shallow copy of the base class! - for i,v in pairs(base) do - c[i] = v - end - c._base = base - end - -- the class will be the metatable for all its objects, - -- and they will look up their methods in it. - c.__index = c - - -- expose a constructor which can be called by () - local mt = {} - mt.__call = function(class_tbl, ...) - local obj = {} - setmetatable(obj,c) - if class_tbl.__init then - class_tbl.__init(obj,...) - else - -- make sure that any stuff from the base class is initialized! - if base and base.__init then - base.__init(obj, ...) - end - end - return obj - end - c.__init = __init - c.is_a = function(self, klass) - local m = getmetatable(self) - while m do - if m == klass then return true end - m = m._base - end - return false - end - setmetatable(c, mt) - return c -end - -%} +// ----- other ----- + +// DIFF: ofFbo: (Lua) ofFboMode | operator renamed to of.FboModeOr(m1, m2) +// DIFF: ofFbo: (Lua) ofFboMode & operator renamed to of.FboModeAnd(m1, m2) +%rename(FboModeOr) operator | (ofFboMode, ofFboMode); +%rename(FboModeAnd) operator & (ofFboMode, ofFboMode); + +// DIFF: ofTrueTypeFont.h: (LUA) string static const strings +%rename(TTF_SANS) OF_TTF_SANS; +%rename(TTF_SERIF) OF_TTF_SERIF; +%rename(TTF_MONO) OF_TTF_MONO; diff --git a/addons/ofxLua/swig/openFrameworks/lang/lua/lua_code.i b/addons/ofxLua/swig/openFrameworks/lang/lua/lua_code.i new file mode 100644 index 0000000..5b1e06f --- /dev/null +++ b/addons/ofxLua/swig/openFrameworks/lang/lua/lua_code.i @@ -0,0 +1,80 @@ +// Lua specific code +// 2017 Dan Wilcox + +// ----- luacode ----- + +// support for simple classes from http://lua-users.org/wiki/SimpleLuaClasses +// +// example usage: +// +// -- class declaration +// MyClass = class() +// +// -- constructor & attributes +// function MyClass:__init(x, y) +// self.x = x +// self.y = y +// self.bBeingDragged = false +// self.bOver = false +// self.radius = 4 +// end +// +// -- create instance & access attribute +// myclass = MyClass(10, 10) +// myclass.x = 100 + +%luacode %{ + +-- this isn't wrapped correctly, so set it here +of.CLOSE = true + +-- handle typedefs which swig doesn't wrap +of.Point = of.Vec3f + +-- class.lua +-- Compatible with Lua 5.1 (not 5.0). +function class(base, __init) + local c = {} -- a new class instance + if not __init and type(base) == 'function' then + __init = base + base = nil + elseif type(base) == 'table' then + -- our new class is a shallow copy of the base class! + for i,v in pairs(base) do + c[i] = v + end + c._base = base + end + -- the class will be the metatable for all its objects, + -- and they will look up their methods in it. + c.__index = c + + -- expose a constructor which can be called by () + local mt = {} + mt.__call = function(class_tbl, ...) + local obj = {} + setmetatable(obj,c) + if class_tbl.__init then + class_tbl.__init(obj,...) + else + -- make sure that any stuff from the base class is initialized! + if base and base.__init then + base.__init(obj, ...) + end + end + return obj + end + c.__init = __init + c.is_a = function(self, klass) + local m = getmetatable(self) + while m do + if m == klass then return true end + m = m._base + end + return false + end + setmetatable(c, mt) + return c +end + +%} diff --git a/addons/ofxLua/swig/interfaces/lang/lua/std_filesystem_path.i b/addons/ofxLua/swig/openFrameworks/lang/lua/std_filesystem_path.i similarity index 93% rename from addons/ofxLua/swig/interfaces/lang/lua/std_filesystem_path.i rename to addons/ofxLua/swig/openFrameworks/lang/lua/std_filesystem_path.i index 16c436a..c16f219 100644 --- a/addons/ofxLua/swig/interfaces/lang/lua/std_filesystem_path.i +++ b/addons/ofxLua/swig/openFrameworks/lang/lua/std_filesystem_path.i @@ -77,8 +77,9 @@ namespace filesystem { %typemap(argout) string &INOUT = string &OUTPUT; -// a really cut down version of the string class -// this provides basic mapping of lua strings <-> std::string and little else +// a really cut down version of the std::filesystem::path class +// this provides basic mapping of lua strings <-> std::filesystem::path +// and little else class path { public: path(); diff --git a/addons/ofxLua/swig/interfaces/lang/python/python.i b/addons/ofxLua/swig/openFrameworks/lang/python/python.i similarity index 58% rename from addons/ofxLua/swig/interfaces/lang/python/python.i rename to addons/ofxLua/swig/openFrameworks/lang/python/python.i index ed63157..7292cc8 100644 --- a/addons/ofxLua/swig/interfaces/lang/python/python.i +++ b/addons/ofxLua/swig/openFrameworks/lang/python/python.i @@ -8,20 +8,3 @@ %rename(__div__) *::operator/; %rename(__add__) *::operator+; %rename(__sub__) *::operator-; - -// ----- pythoncode ----- - -#if !defined(OF_SWIG_RENAME) - -%pythoncode %{ - -# handle typedefs which swig doesn't wrap -ofPoint = ofVec3f - -# renaming log -> ofLog -ofLog = log -del log - -%} - -#endif diff --git a/addons/ofxLua/swig/openFrameworks/lang/python/python_code.i b/addons/ofxLua/swig/openFrameworks/lang/python/python_code.i new file mode 100644 index 0000000..e7a6d25 --- /dev/null +++ b/addons/ofxLua/swig/openFrameworks/lang/python/python_code.i @@ -0,0 +1,15 @@ +// Python specific code + +// ----- pythoncode ----- + +%pythoncode %{ + +# handle typedefs which swig doesn't wrap +ofPoint = ofVec3f +OF_PRIMITIVE_TRIANGLE_STRIP = None + +# renaming log -> ofLog +ofLog = log +del log + +%} \ No newline at end of file diff --git a/addons/ofxLua/swig/interfaces/lang/python/std_filesystem_path.i b/addons/ofxLua/swig/openFrameworks/lang/python/std_filesystem_path.i similarity index 100% rename from addons/ofxLua/swig/interfaces/lang/python/std_filesystem_path.i rename to addons/ofxLua/swig/openFrameworks/lang/python/std_filesystem_path.i diff --git a/addons/ofxLua/swig/openFrameworks/openFrameworks/3d.i b/addons/ofxLua/swig/openFrameworks/openFrameworks/3d.i new file mode 100644 index 0000000..c0a4954 --- /dev/null +++ b/addons/ofxLua/swig/openFrameworks/openFrameworks/3d.i @@ -0,0 +1,43 @@ +// 3d folder bindings +// 2017 Dan Wilcox + +// ----- ofNode.h ----- + +// DIFF: ofNode.h: ignoring const & copy constructor in favor of && constructor +%ignore ofNode::ofNode(ofNode const &); + +// process ofNode first since it's a base class +%include "3d/ofNode.h" + +// ----- of3dUtils.h ----- + +%include "3d/of3dUtils.h" + +// ----- ofCamera.h ----- + +%include "3d/ofCamera.h" + +// ----- ofEasyCam.h ----- + +// DIFF: ofEasyCam.h: ignoring hasInteraction(int, int) in favor of +// hasInteraction(TransformType, int, int) +%ignore ofEasyCam::hasInteraction(int, int); + +%include "3d/ofEasyCam.h" + +// ----- ofMesh.h ----- + +// tell SWIG about template vectors +namespace std { + %template(MeshFaceVector) std::vector>; +} + +%include "3d/ofMesh.h" + +// tell SWIG about template classes +%template(Mesh) ofMesh_; +%template(MeshFace) ofMeshFace_; + +// ----- of3dPrimitives.h ----- + +%include "3d/of3dPrimitives.h" diff --git a/addons/ofxLua/swig/interfaces/openFrameworks/app.i b/addons/ofxLua/swig/openFrameworks/openFrameworks/app.i similarity index 87% rename from addons/ofxLua/swig/interfaces/openFrameworks/app.i rename to addons/ofxLua/swig/openFrameworks/openFrameworks/app.i index ea9c2f8..a2e6480 100644 --- a/addons/ofxLua/swig/interfaces/openFrameworks/app.i +++ b/addons/ofxLua/swig/openFrameworks/openFrameworks/app.i @@ -13,10 +13,6 @@ // not needed -// ----- ofAppGlutWindow.h ----- - -// not needed - // ----- ofAppGLFWWindow.h ----- // not needed @@ -42,11 +38,12 @@ %ignore ofRunApp; %ignore ofRunMainLoop; -// DIFF: ofSetAppPtr not applicable in a target language -%ignore ofSetAppPtr; +// DIFF: ofGetAppPtr not applicable in a target language +%ignore ofGetAppPtr; -// DIFF: ofGetWindowPtr not applicable in a target language +// DIFF: ofGetWindowPtr and ofGetCurrentWindow not applicable in a target language %ignore ofGetWindowPtr; +%ignore ofGetCurrentWindow; // DIFF: get/set current renderer not applicable to target language %ignore ofSetCurrentRenderer; diff --git a/addons/ofxLua/swig/openFrameworks/openFrameworks/communication.i b/addons/ofxLua/swig/openFrameworks/openFrameworks/communication.i new file mode 100644 index 0000000..fdf8809 --- /dev/null +++ b/addons/ofxLua/swig/openFrameworks/openFrameworks/communication.i @@ -0,0 +1,40 @@ +// communication folder bindings +// 2017 Dan Wilcox + +// ----- ofArduino.h ----- + +// DIFF: ofArduino.h: ignoring functions which return list points +%ignore ofArduino::getDigitalHistory(int); +%ignore ofArduino::getAnalogHistory(int); +%ignore ofArduino::getSysExHistory; +%ignore ofArduino::getStringHistory; + +// DIFF: ofArduino.h: pass binary data to I2C as full char strings +%apply(const char *STRING, int LENGTH) {(const char * buffer, int numOfBytes)}; + +// DIFF: ofArduino.h: ignoring sendI2CWriteRequest() overloads in favor of +// version which takes bytes as a const char * +%ignore ofArduino::sendI2CWriteRequest(char, unsigned char *, int, int); +%ignore ofArduino::sendI2CWriteRequest(char, char *, int, int); +%ignore ofArduino::sendI2CWriteRequest(char, std::vector, int); + +// ... and again to handle the last argument's default value default causing +// SWIG to create the following function overloads +%ignore ofArduino::sendI2CWriteRequest(char, unsigned char *, int); +%ignore ofArduino::sendI2CWriteRequest(char, char *, int); +%ignore ofArduino::sendI2CWriteRequest(char, std::vector); + +%include "communication/ofArduino.h" + +// clear typemap +%clear(const char * buffer, int numOfBytes); + +// ----- ofSerial.h ----- + +// DIFF: ofSerial.h: pass binary data as full char strings +%apply(unsigned char *STRING, int LENGTH) {(unsigned char * buffer, int length)}; + +%include "communication/ofSerial.h" + +// clear typemap +%clear(unsigned char * buffer, int length); diff --git a/addons/ofxLua/swig/interfaces/openFrameworks/events.i b/addons/ofxLua/swig/openFrameworks/openFrameworks/events.i similarity index 62% rename from addons/ofxLua/swig/interfaces/openFrameworks/events.i rename to addons/ofxLua/swig/openFrameworks/openFrameworks/events.i index 3cbb28f..c1fdbae 100644 --- a/addons/ofxLua/swig/interfaces/openFrameworks/events.i +++ b/addons/ofxLua/swig/openFrameworks/openFrameworks/events.i @@ -1,6 +1,10 @@ // events folder bindings // 2017 Dan Wilcox +// ----- ofEvent.h ----- + +// not needed + // ----- ofEvents.h ----- // DIFF: ofEvents.h: @@ -12,12 +16,15 @@ // need ofTouchEventArgs for touch callbacks %ignore ofAudioEventArgs; %ignore ofResizeEventArgs; +%ignore ofWindowPosEventArgs; %ignore ofMessage; +%ignore ofTimeMode; + +%ignore ofCoreEvents; // DIFF: ignore ofSendMessage() with ofMessage in favor of std::string %ignore ofSendMessage(ofMessage msg); -%ignore ofCoreEvents; %ignore ofEvents; %ignore ofRegisterMouseEvents; @@ -31,24 +38,23 @@ %ignore ofUnregisterGetMessages; %ignore ofUnregisterDragEvents; -%ignore ofNotifySetup; -%ignore ofNotifyUpdate; -%ignore ofNotifyDraw; -%ignore ofNotifyKeyPressed; -%ignore ofNotifyKeyReleased; -%ignore ofNotifyKeyEvent; -%ignore ofNotifyMousePressed; -%ignore ofNotifyMouseReleased; -%ignore ofNotifyMouseDragged; -%ignore ofNotifyMouseMoved; -%ignore ofNotifyMouseEvent; -%ignore ofNotifyExit; -%ignore ofNotifyWindowResized; -%ignore ofNotifyWindowEntry; -%ignore ofNotifyDragEvent; - %include "events/ofEvents.h" +// DIFF: added target language tostring wrapper for ofTouchEventArgs::operator << +// TODO: ofTouchEventArgs inheritance from glm::vec2 doesn't create x & y attributes +%extend ofTouchEventArgs { + const char* __str__() { + stringstream str; + str << (*$self); + return str.str().c_str(); + } +}; + +// manually create attributes since inherting from +// glm::vec2 doesn't seem to create them +%attributeVar(ofTouchEventArgs, float, x, x, x); +%attributeVar(ofTouchEventArgs, float, y, y, y); + // ----- ofEventUtils.h ----- // not needed diff --git a/addons/ofxLua/swig/interfaces/openFrameworks/gl.i b/addons/ofxLua/swig/openFrameworks/openFrameworks/gl.i similarity index 61% rename from addons/ofxLua/swig/interfaces/openFrameworks/gl.i rename to addons/ofxLua/swig/openFrameworks/openFrameworks/gl.i index 4b65d01..3463dd2 100644 --- a/addons/ofxLua/swig/interfaces/openFrameworks/gl.i +++ b/addons/ofxLua/swig/openFrameworks/openFrameworks/gl.i @@ -25,6 +25,10 @@ #define OF_REPEAT 10497 // 0x2901 #define OF_MIRRORED_REPEAT 33648 // 0x8370 +// ----- ofGLBaseTypes.h ----- + +// not needed + // ----- ofBufferObject.h ----- %include "gl/ofBufferObject.h" @@ -44,14 +48,14 @@ // ----- ofGLUtils.h ----- // DIFF: ofGLUtils.h: ignoring ofGetGLRenderer() -%ignore ofGetGLRenderer(); +%ignore ofGetGLRenderer; // manually rename these otherwise the initial G in GL ends up lowercase #ifdef OF_SWIG_RENAME - %rename ofGLCheckExtension GLCheckExtension; - %rename ofGLSLVersionFromGL GLSLVersionFromGL; - %rename ofGLSupportedExtensions GLSupportedExtensions; - %rename ofGLSupportsNPOTTextures GLSupportsNPOTTextures; + %rename(ofGLCheckExtension) GLCheckExtension; + %rename(ofGLSLVersionFromGL) GLSLVersionFromGL; + %rename(ofGLSupportedExtensions) GLSupportedExtensions; + %rename(ofGLSupportsNPOTTextures) GLSupportsNPOTTextures; #endif // ignore extra GL defines @@ -61,40 +65,47 @@ // ----- ofLight.h ----- -// DIFF: ofLight.h: ignoring nested struct, not supported by SWIG +// DIFF: ofLight.h: ignoring nested Data struct %ignore ofLight::Data; +%ignore ofLightsData; %include "gl/ofLight.h" // ----- ofMaterial.h ----- -// DIFF: ofMaterial.h: ignoring nested struct, not supported by SWIG +// forward declare +%ignore ofBaseMaterial; +class ofBaseMaterial {}; + +// DIFF: ofMaterial.h: ignoring ofMaterial::Data %ignore ofMaterial::Data; -%ignore ofMaterial::getData() const; -%ignore ofMaterial::setData(const ofMaterial::Data &); %include "gl/ofMaterial.h" // ----- ofShader.h ----- -// DIFF: ofShader.h: ignoring const & copy constructor in favor of && constructor +// DIFF: ofShader.h: +// DIFF: ignoring const & copy constructor in favor of && constructor %ignore ofShader::ofShader(ofShader const &); -// ignore destructor -%ignore ofShader::~ofShader; +// DIFF: ignoring ofShaderSettings struct +%ignore ofShaderSettings; +%ignore ofShader::setup(const ofShaderSettings); -%include "gl/ofShader.h" +// DIFF: ignoring TransformFeedbackSettings structs +%ignore ofShader::TransformFeedbackSettings; +%ignore ofShader::setup(const ofShader::TransformFeedbackSettings); + +// DIFF: ignoring TransformFeedback range and base structs +%ignore ofShader::TransformFeedbackRangeBinding; +%ignore ofShader::TransformFeedbackBaseBinding; +%ignore ofShader::beginTransformFeedback; +%ignore ofShader::endTransformFeedback; -// TODO: ofShader.h: remove custom destructor if bug fixed in future OF versions -// DIFF: ofShader.h: custom destructor so shaders are unbound before deletion -%rename("%s") ofShader::~ofShader; // unignore -%extend ofShader { -public: - ~ofShader() { - $self->end(); - delete $self; - } -}; +// DIFF: ignore defaultAttributes enum +%ignore ofShader::defaultAttributes; + +%include "gl/ofShader.h" // ----- ofTexture.h ----- diff --git a/addons/ofxLua/swig/interfaces/openFrameworks/graphics.i b/addons/ofxLua/swig/openFrameworks/openFrameworks/graphics.i similarity index 64% rename from addons/ofxLua/swig/interfaces/openFrameworks/graphics.i rename to addons/ofxLua/swig/openFrameworks/openFrameworks/graphics.i index f9dced2..30b8fd3 100644 --- a/addons/ofxLua/swig/interfaces/openFrameworks/graphics.i +++ b/addons/ofxLua/swig/openFrameworks/openFrameworks/graphics.i @@ -1,6 +1,20 @@ // graphics folder bindings // 2017 Dan Wilcox +// ----- ofGraphicsBaseTypes.h ----- + +// handled in main.i + +// ----- ofGraphicsConstants.h ----- + +// make sure we use the actual classes +%ignore ofDefaultVertexType; +%ignore ofDefaultNormalType; +%ignore ofDefaultColorType; +%ignore ofDefaultTexCoordType; + +%include "graphics/ofGraphicsConstants.h" + // ----- ofPixels.h ----- // include pixels first as it's used by most other classes @@ -11,7 +25,7 @@ // DIFF: ofPixels.h: // DIFF: fixed ambiguous ofPixels function overloads since enums = int in SWIG -// DIFF: by renaming to allocatePixelFormat, allocateimageType, & setFromPixelsImageType +// DIFF: by renaming to allocatePixelFormat, allocateImageType, & setFromPixelsImageType %rename(allocatePixelFormat) ofPixels_::allocate(size_t, size_t, ofPixelFormat); %rename(allocateImageType) ofPixels_::allocate(size_t, size_t, ofImageType); %rename(setFromPixelsImageType) ofPixels_::setFromPixels(unsigned char const *, size_t, size_t, ofImageType); @@ -54,7 +68,7 @@ %ignore ofPixels_::pixelBitsFromPixelFormat(ofPixelFormat); %ignore ofPixels_::bytesFromPixelFormat(size_t, size_t, ofPixelFormat); -// DIFF: ignoring nested structs, not supported by SWIG +// DIFF: ignoring nested structs: Pixel, Line, ConstPixel, & ConstLine %ignore ofPixels_::ConstPixel; %ignore ofPixels_::Pixel; %ignore ofPixels_::Pixels; @@ -99,35 +113,35 @@ // ----- ofPath.h ----- -// DIFF: ofPath.h: ignoring nested struct, not supported by SWIG +// DIFF: ofPath.h: ignoring nested Command struct %ignore ofPath::Command; %include "graphics/ofPath.h" -#if OF_VERSION_MINOR > 9 +// tell SWIG about template classes %template(PolylineVector) std::vector; -#endif // ----- ofPolyline.h ----- // ignored due to default variable overload -%ignore ofPolyline::arc(float, float, float, float, float, float, float); -%ignore ofPolyline::arcNegative(float, float, float, float, float, float, float); +%ignore ofPolyline_::arc(float, float, float, float, float, float, float); +%ignore ofPolyline_::arcNegative(float, float, float, float, float, float, float); // DIFF: ofPolyline.h: ignoring iterators -%ignore ofPolyline::begin; -%ignore ofPolyline::end; -%ignore ofPolyline::rbegin; -%ignore ofPolyline::rend; +%ignore ofPolyline_::begin; +%ignore ofPolyline_::end; +%ignore ofPolyline_::rbegin; +%ignore ofPolyline_::rend; %include "graphics/ofPolyline.h" -#if OF_VERSION_MINOR > 9 - #ifdef OF_SWIG_RENAME - %template(Polyline) ofPolyline_; - #else - %template(ofPolyline) ofPolyline_; - #endif +// tell SWIG about template classes +#ifdef OF_SWIG_RENAME + %template(VertexVector) std::vector; + %template(Polyline) ofPolyline_; +#else + %template(ofVertexVector) std::vector; + %template(ofPolyline) ofPolyline_; #endif // ----- ofRendererCollection.h ----- @@ -153,16 +167,18 @@ #endif // DIFF: ofGraphics.h: -// DIFF: ignoring foDrawBitmapString template functions in favor of -// DIFF: string versions target languages can handle the string conversions -%ignore ofDrawBitmapString(const T &, const ofPoint&); +// DIFF: ignoring ofDrawBitmapString() template functions in favor of +// DIFF: string versions, target languages can handle the string conversions %ignore ofDrawBitmapString(const T &, float, float); +%ignore ofDrawBitmapString(const T &, const glm::vec3 &); +%ignore ofDrawBitmapString(const T &, const glm::vec2 &); %ignore ofDrawBitmapString(const T &, float, float, float); // manually define string functions here otherwise they get redefined by SWIG & then ignored -void ofDrawBitmapString(const string & textString, float x, float y); -void ofDrawBitmapString(const string & textString, const ofPoint & p); -void ofDrawBitmapString(const string & textString, float x, float y, float z); +void ofDrawBitmapString(const std::string & textString, float x, float y); +void ofDrawBitmapString(const std::string & textString, const glm::vec3 & p); +void ofDrawBitmapString(const std::string & textString, const glm::vec2 & p); +void ofDrawBitmapString(const std::string & textString, float x, float y, float z); %include "graphics/ofGraphics.h" @@ -173,7 +189,6 @@ void ofDrawBitmapString(const string & textString, float x, float y, float z); %include "graphics/of3dGraphics.h" - // ----- ofImage.h ----- // handled in main.i @@ -184,21 +199,86 @@ void ofDrawBitmapString(const string & textString, float x, float y, float z); // ----- ofTrueTypeFont.h ----- -// ignore internal font struct -%ignore charProps; - // DIFF: ofTrueTypeFont.h: +// ignore internal font structs +%ignore FT_Face; + +// strip "of" from following ofAlphabet enums +#ifdef OF_SWIG_RENAME + %rename("%(regex:/of(Alphabet.*)/\\1/)s", %$isenumitem) ""; +#endif + +// replace std::initializer with an enum that SWIG understands +%inline %{ + enum ofAlphabetEnum : int { + ofAlphabet_Emoji, + ofAlphabet_Japanese, + ofAlphabet_Chinese, + ofAlphabet_Korean, + ofAlphabet_Arabic, + ofAlphabet_Devanagari, + ofAlphabet_Latin, + ofAlphabet_Greek, + ofAlphabet_Cyrillic + }; +%} +%ignore ofAlphabet; + +// ignore ofUnicode::range nested struct warning +%warnfilter(325) ofUnicode::range; + // DIFF: ignoring ofTrueTypeShutdown() & ofExitCallback() friend %ignore ofTrueTypeShutdown; -%ignore ofExitCallback(); +%ignore ofExitCallback; + +// ignore std::initializer +%ignore ofTrueTypeFontSettings::addRanges(std::initializer_list); + +// DIFF: replaced ofAlphabet static instances with afAlphabet_ enums +%extend ofTrueTypeFontSettings { + void addRanges(ofAlphabetEnum alphabet) { + switch(alphabet) { + case ofAlphabet_Emoji: + $self->addRanges(ofAlphabet::Emoji); + break; + case ofAlphabet_Japanese: + $self->addRanges(ofAlphabet::Japanese); + break; + case ofAlphabet_Chinese: + $self->addRanges(ofAlphabet::Chinese); + break; + case ofAlphabet_Korean: + $self->addRanges(ofAlphabet::Korean); + break; + case ofAlphabet_Arabic: + $self->addRanges(ofAlphabet::Arabic); + break; + case ofAlphabet_Devanagari: + $self->addRanges(ofAlphabet::Devanagari); + break; + case ofAlphabet_Latin: + $self->addRanges(ofAlphabet::Latin); + break; + case ofAlphabet_Greek: + $self->addRanges(ofAlphabet::Greek); + break; + case ofAlphabet_Cyrillic: + $self->addRanges(ofAlphabet::Cyrillic); + break; + default: + break; + } + } +} // DIFF: ignoring const & copy constructor in favor of && constructor %ignore ofTrueTypeFont::ofTrueTypeFont(ofTrueTypeFont const &); -// string static const strings -%rename(TTF_SANS) OF_TTF_SANS; -%rename(TTF_SERIF) OF_TTF_SERIF; -%rename(TTF_MONO) OF_TTF_MONO; +// DIFF: ignoring protected structs +%ignore ofTrueTypeFont::range; +%ignore ofTrueTypeFont::glyph; +%ignore ofTrueTypeFont::glyphProps; + +// TODO: find a way to release ofRectangle returned by getStringBoundingBox() %include "graphics/ofTrueTypeFont.h" -%include "graphics/ofGraphicsConstants.h" diff --git a/addons/ofxLua/swig/interfaces/openFrameworks/main.i b/addons/ofxLua/swig/openFrameworks/openFrameworks/main.i similarity index 61% rename from addons/ofxLua/swig/interfaces/openFrameworks/main.i rename to addons/ofxLua/swig/openFrameworks/openFrameworks/main.i index 4c83e7e..3a9d71a 100644 --- a/addons/ofxLua/swig/interfaces/openFrameworks/main.i +++ b/addons/ofxLua/swig/openFrameworks/openFrameworks/main.i @@ -4,6 +4,12 @@ // ignore everything in the private namespace %ignore of::priv; +// TODO: wrap nested structs and classes? +//%feature ("flatnested"); + +// TODO: make sure returned class instances are freed by using %newobject + +// tell SWIG about template vectors, // needed for functions and return types namespace std { %template(IntVector) std::vector; @@ -14,7 +20,8 @@ namespace std { %template(TextureVector) std::vector; }; -// SWIG needs to know about boost::filesystem or it throws an error +// SWIG needs to know about boost::filesystem or it throws an error when it +// gets to ofFileUtils.h namespace boost { namespace filesystem {} } @@ -30,8 +37,59 @@ typedef unsigned int GLenum; typedef unsigned int GLuint; typedef float GLfloat; +// this in tesselator.h but SWIG needs to know about it for ofIndexType +#if defined(TARGET_OPENGLES) + typedef unsigned short TESSindex; +#else + typedef unsigned int TESSindex; +#endif + %include "utils/ofConstants.h" +// ----- ofMathConstants.h ----- + +%ignore ofDefaultVec2; +%ignore ofDefaultVec3; +%ignore ofDefaultVec4; +%ignore ofDefaultTexCoordType; + +// import the glm types +%import(module="glm") "../../glm.i" + +// include early for glm::vec* declarations, +// edit: not quite needed for now as this is handled below... +// ... needed for math constants +%include "math/ofMathConstants.h" + +// ----- ofUtils.h ----- + +// DIFF: ofUtils.h: +// DIFF: ignoring ofFromString as templating results in too much overloading +%ignore ofFromString; + +// DIFF: variable argument support is painful, safer to ignore +// see http://www.swig.org/Doc2.0/Varargs.html +%ignore ofVAArgsToString; + +// DIFF: ignoring ofUTF8Iterator +%ignore ofUTF8Iterator; + +// manually rename these otherwise the initial U in UTF ends up lowercase +#ifdef OF_SWIG_RENAME + %rename(ofUTF8Append) UTF8Append; + %rename(ofUTF8Insert) UTF8Insert; + %rename(ofUTF8Erase) UTF8Erase; + %rename(ofUTF8Substring) UTF8Substring; + %rename(ofUTF8ToString) UTF8ToString; + %rename(ofUTF8Length) UTF8Length; +#endif + +// include early for ofToString template declaration +%include "utils/ofUtils.h" + +// ignore further redefinitions +%ignore ofToString(const T &); + // ----- ofFbo.h ----- // need to forward declare these for ofFbo @@ -44,7 +102,6 @@ class ofBaseHasTexture {}; %ignore ofBaseHasPixels; class ofBaseHasPixels {}; -// DIFF: ofFbo.h: // DIFF: ignoring const & copy constructor in favor of && constructor %ignore ofFbo::ofFbo(ofFbo const &); @@ -55,8 +112,10 @@ class ofBaseHasPixels {}; // DIFF: ignoring setActiveDrawBufers() due to std::vector %ignore setActiveDrawBuffers(const vector& i); -// DIFF: ignoring nested structs, not supported by SWIG +// DIFF: ignoring ofFboSettings struct +%ignore ofFboSettings; %ignore ofFbo::Settings; +%ignore allocate(ofFboSettings); %include "gl/ofFbo.h" @@ -88,9 +147,7 @@ template class ofBaseImage_ {}; #endif // DIFF: ofImage.h: -// DIFF: ignore global helper functions -%ignore ofLoadImage; -%ignore ofSaveImage; +// DIFF: ignore ofCloseFreeImage() %ignore ofCloseFreeImage; // DIFF: ignoring ofPixels operator @@ -99,6 +156,8 @@ template class ofBaseImage_ {}; // DIFF: ignoring const & copy constructor in favor of && constructor %ignore ofImage_(const ofImage_&); +// TODO: find a way to release ofColor instances returned by getColor() + %include "graphics/ofImage.h" // handle template implementations @@ -112,9 +171,9 @@ template class ofBaseImage_ {}; %template(ofShortImage) ofImage_; #endif -// ----- ofBaseTypes.h ----- +// ----- ofGraphicsBaseTypes.h ----- -// DIFF: ofBaseTypes.h: ignore all abstract and base types +// DIFF: ofGraphicsBaseTypes.h: ignore all abstract and base types %ignore ofAbstractParameter; %ignore ofBaseDraws; %ignore ofBaseUpdates; @@ -133,14 +192,6 @@ template class ofBaseImage_ {}; %ignore ofBaseFloatImage; %ignore ofBaseShortImage; -%ignore ofBaseSoundInput; -%ignore ofBaseSoundOutput; - -%ignore ofBaseVideo; -%ignore ofBaseVideoDraws; -%ignore ofBaseVideoGrabber; -%ignore ofBaseVideoPlayer; - %ignore ofBaseRenderer; %ignore ofBaseGLRenderer; @@ -149,5 +200,27 @@ template class ofBaseImage_ {}; %ignore ofBaseURLFileLoader; %ignore ofBaseMaterial; -// still include header for derived classes -%include "types/ofBaseTypes.h" +// include header for derived classes +%include "graphics/ofGraphicsBaseTypes.h" + +// ----- ofSoundBaseTypes.h ----- + +// DIFF: ofSoundBaseTypes.h: ignore all abstract and base types + +%ignore ofBaseSoundInput; +%ignore ofBaseSoundOutput; + +// include header for derived classes +%include "sound/ofSoundBaseTypes.h" + +// ----- ofVideoBaseTypes.h ----- + +// DIFF: ofVideoBaseTypes.h: ignore all abstract and base types + +%ignore ofBaseVideo; +%ignore ofBaseVideoDraws; +%ignore ofBaseVideoGrabber; +%ignore ofBaseVideoPlayer; + +// include header for derived classes +%include "video/ofVideoBaseTypes.h" diff --git a/addons/ofxLua/swig/interfaces/openFrameworks/math.i b/addons/ofxLua/swig/openFrameworks/openFrameworks/math.i similarity index 66% rename from addons/ofxLua/swig/interfaces/openFrameworks/math.i rename to addons/ofxLua/swig/openFrameworks/openFrameworks/math.i index 7dc926b..33c902e 100644 --- a/addons/ofxLua/swig/interfaces/openFrameworks/math.i +++ b/addons/ofxLua/swig/openFrameworks/openFrameworks/math.i @@ -30,35 +30,60 @@ ofInterpolateHermite(float y1, float y2, float pct); %template(ofInterpolateHermite) ofInterpolateHermite; #endif +// ----- ofMathConstants.h ----- + +// handled in main.i + // ----- ofMatrix3x3.h ----- +// DIFF: ofMatrix3x3.h: ignoring glm::mat3 operator +%ignore ofMatrix3x3::operator glm::mat3; + %include "math/ofMatrix3x3.h" %extend ofMatrix3x3 { + + glm::mat3 mat3() { + return (*$self); + } + const char* __str__() { - stringstream str; + ostringstream str; str << (*$self); return str.str().c_str(); } + }; // ----- ofMatrix4x4.h ----- -// DIFF: ofMatrix4x4.h: ignoring operator(size_t,size_t) const overload +// DIFF: ofMatrix4x4.h: ignoring operator(size_t, size_t) const overload %ignore ofMatrix4x4::operator()(std::size_t, std::size_t) const; +// DIFF: ofMatrix4x4.h: ignoring glm::mat4 operator +%ignore ofMatrix4x4::operator glm::mat4; + %include "math/ofMatrix4x4.h" %extend ofMatrix4x4 { + + glm::mat4 mat4() { + return (*$self); + } + const char* __str__() { - stringstream str; + ostringstream str; str << (*$self); return str.str().c_str(); } + }; // ----- ofQuaternion.h ----- +// DIFF: ofQuaternion.h: ignoring glm::quat operator +%ignore ofQuaternion::operator glm::quat; + // silence warning as SWIG ignores these anyway // since it uses the non-const versions %ignore ofQuaternion::x() const; @@ -69,8 +94,13 @@ ofInterpolateHermite(float y1, float y2, float pct); %include "math/ofQuaternion.h" %extend ofQuaternion { + + glm::quat quat() { + return (*$self); + } + const char* __str__() { - stringstream str; + ostringstream str; str << (*$self); return str.str().c_str(); } @@ -78,11 +108,20 @@ ofInterpolateHermite(float y1, float y2, float pct); // ----- ofVec2f.h ----- +// DIFF: ofVec2f.h: ignoring glm::vec2 operator, +// DIFF:: use vec2() accessor instead +%ignore ofVec2f::operator glm::vec2; + %include "math/ofVec2f.h" %extend ofVec2f { + + glm::vec2 vec2() { + return (*$self); + } + const char* __str__() { - stringstream str; + ostringstream str; str << (*$self); return str.str().c_str(); } @@ -90,11 +129,20 @@ ofInterpolateHermite(float y1, float y2, float pct); // ----- ofVec3f.h ----- +// DIFF: ofVec3f.h: ignoring glm::vec3 operator, +// DIFF:: use vec3() accessor instead +%ignore ofVec3f::operator glm::vec3; + %include "math/ofVec3f.h" %extend ofVec3f { + + glm::vec3 vec3() { + return (*$self); + } + const char* __str__() { - stringstream str; + ostringstream str; str << (*$self); return str.str().c_str(); } @@ -102,11 +150,20 @@ ofInterpolateHermite(float y1, float y2, float pct); // ----- ofVec4f.h ----- +// DIFF: ofVec4f.h: ignoring glm::vec4 operator, +// DIFF:: use vec4() accessor instead +%ignore ofVec4f::operator glm::vec4; + %include "math/ofVec4f.h" %extend ofVec4f { + + glm::vec4 vec4() { + return (*$self); + } + const char* __str__() { - stringstream str; + ostringstream str; str << (*$self); return str.str().c_str(); } @@ -115,6 +172,3 @@ ofInterpolateHermite(float y1, float y2, float pct); // ----- ofVectorMath.h----- // not needed - - -%include "math/ofMathConstants.h" \ No newline at end of file diff --git a/addons/ofxLua/swig/interfaces/openFrameworks/sound.i b/addons/ofxLua/swig/openFrameworks/openFrameworks/sound.i similarity index 80% rename from addons/ofxLua/swig/interfaces/openFrameworks/sound.i rename to addons/ofxLua/swig/openFrameworks/openFrameworks/sound.i index 7f7090a..11a734a 100644 --- a/addons/ofxLua/swig/interfaces/openFrameworks/sound.i +++ b/addons/ofxLua/swig/openFrameworks/openFrameworks/sound.i @@ -1,13 +1,9 @@ // sound folder bindings // 2017 Dan Wilcox -// ----- ofBaseSoundPlayer.h ----- +// ----- ofSoundBaseTypes.h ----- -// not needed - -// ----- ofBaseSoundStream.h ----- - -// not needed +// handled in main.i // ----- ofFmodSoundPlayer.h ----- @@ -38,7 +34,7 @@ %ignore ofBaseSoundPlayer; class ofBaseSoundPlayer {}; -// DIFF: ofSoundPlayer.h: warnings say "FIX THIS SHIT", so leaving out fmod global functions +// DIFF: ofSoundPlayer.h: ignoring global FMOD functions %ignore ofSoundStopAll; %ignore ofSoundShutdown; %ignore ofSoundSetVolume; diff --git a/addons/ofxLua/swig/interfaces/openFrameworks/types.i b/addons/ofxLua/swig/openFrameworks/openFrameworks/types.i similarity index 91% rename from addons/ofxLua/swig/interfaces/openFrameworks/types.i rename to addons/ofxLua/swig/openFrameworks/openFrameworks/types.i index 26d08fb..4f18d0e 100644 --- a/addons/ofxLua/swig/interfaces/openFrameworks/types.i +++ b/addons/ofxLua/swig/openFrameworks/openFrameworks/types.i @@ -15,15 +15,18 @@ // ----- ofColor.h ----- +// DIFF: ofColor.h: +// TODO: find a way to release static named ofColor instances + // ignore SWIG Warning 312 from nested union that provides r, g, b, & a access -#pragma SWIG nowarn=312 +// ignore SWIG Warning 320 from extern template classes +#pragma SWIG nowarn=312,320 %include "types/ofColor.h" // reenable -#pragma SWIG nowarn=312 +#pragma SWIG nowarn= -// DIFF: ofColor.h: // DIFF: added ofColor_ pixel channel getters getR(), getG(), getB(), getA() // DIFF: added ofColor_ pixel channel setters setR(), setG(), setB(), setA() // DIFF: added target language tostring wrapper for ofColor_::operator << @@ -76,8 +79,8 @@ // ----- ofPoint.h ----- -// NOTE: ofPoint is just a typedef which swig cannot wrap, so the types need to be -// handled in the scripting language, see the Lua, Python, etc code in lang.i +// NOTE: ofPoint is just a typedef which swig cannot wrap, so the types need to +// be handled in the scripting language, see the Lua, Python, etc code in lang.i %include "types/ofPoint.h" // ----- ofRectangle.h ----- @@ -88,6 +91,8 @@ %rename(scaleToScaleMode) ofRectangle::scaleTo(ofRectangle const &, ofScaleMode); %rename(scaleToAspectRatio) ofRectangle::scaleTo(ofRectangle const &, ofAspectRatioMode); +// TODO: find a way to release returned ofRectangle instances + // ignore SWIG Warning 302 due to manual override of x & y attributes %warnfilter(302) ofRectangle::x; %warnfilter(302) ofRectangle::y; diff --git a/addons/ofxLua/swig/interfaces/openFrameworks/utils.i b/addons/ofxLua/swig/openFrameworks/openFrameworks/utils.i similarity index 69% rename from addons/ofxLua/swig/interfaces/openFrameworks/utils.i rename to addons/ofxLua/swig/openFrameworks/openFrameworks/utils.i index 14f778d..674727f 100644 --- a/addons/ofxLua/swig/interfaces/openFrameworks/utils.i +++ b/addons/ofxLua/swig/openFrameworks/openFrameworks/utils.i @@ -11,9 +11,23 @@ // ----- ofXml.h ----- -// DIFF: ofXml.h: ignoring PocoDocument & PocoElement getters -%ignore ofXml::getPocoDocument; -%ignore ofXml::getPocoElement; +// DIFF: ofXml.h: ignoring find() as it returns a pugi::xpath_node_set +%ignore ofXml::find; + +// DIFF: ofXml.h: ignoring iterators and nested structs +%ignore ofXmlIterator; +%ignore ofXmlSearchIterator; +%ignore ofXml::Search; +%ignore ofXml::Attribute; +%ignore ofXml::Range; +%ignore ofXml::Search::end; +%ignore ofXml::Range::end; + +// DIFF: ofXml.h: ignore removeAttribute(&&) +%ignore ofXml::removeAttribute(Attribute &&); + +// DIFF: ofXml.h: ignoring bool operator +%ignore ofXml::operator bool; %include "utils/ofXml.h" @@ -28,8 +42,8 @@ // ----- ofFileUtils.h ----- // forward declare fstream for ofFile -%ignore fstream; -class fstream {}; +%ignore std::fstream; +class std::fstream {}; // DIFF: ofFileUtils.h: // DIFF: ignoring iterators @@ -43,15 +57,15 @@ class fstream {}; %ignore ofDirectory::rend; // DIFF: ignoring ofBuffer istream & ostream functions -%ignore ofBuffer::ofBuffer(istream &); -%ignore ofBuffer::ofBuffer(istream &, size_t); -%ignore ofBuffer::set(istream &); -%ignore ofBuffer::set(istream &, size_t); -%ignore ofBuffer::writeTo(ostream &) const; +%ignore ofBuffer::ofBuffer(std::istream &); +%ignore ofBuffer::ofBuffer(std::istream &, size_t); +%ignore ofBuffer::set(std::istream &); +%ignore ofBuffer::set(std::istream &, size_t); +%ignore ofBuffer::writeTo(std::ostream &) const; -%ignore ofBuffer::ofBuffer(const string &); -%ignore ofBuffer::set(const string &); -%ignore ofBuffer::append(const string&); +%ignore ofBuffer::ofBuffer(const std::string &); +%ignore ofBuffer::set(const std::string &); +%ignore ofBuffer::append(const std::string&); // ignore char* getData() in preference to const char* getData() whose return // type is overriden below @@ -59,27 +73,20 @@ class fstream {}; // DIFF: pass binary data to ofBuffer as full char strings // pass binary data & byte length as a single argument for ofBuffer - -// ofBuffer constructor uses "buffer" and "size" while set & append use "_buffer" and "_size" %apply(char *STRING, size_t LENGTH) {(const char * buffer, std::size_t size)}; -%apply(char *STRING, size_t LENGTH) {(const char * _buffer, std::size_t _size)}; // DIFF: ignoring nested ofBuffer Line & Lines structs %ignore ofBuffer::Line; %ignore ofBuffer::Lines; %ignore ofBuffer::getLines(); -%ignore ofBuffer::Lines::end(); -#if OF_VERSION_MINOR > 9 // DIFF: ignoring nested ofBuffer RLine & RLines structs %ignore ofBuffer::RLine; %ignore ofBuffer::RLines; %ignore ofBuffer::getReverseLines(); -%ignore ofBuffer::RLines::end(); -#endif // DIFF: ignoring string, filebuf, & std::filesystem::path operators -%ignore ofBuffer::operator string() const; +%ignore ofBuffer::operator std::string() const; %ignore ofFile::getFileBuffer() const; %ignore ofFile::operator std::filesystem::path(); %ignore ofFile::operator const std::filesystem::path() const; @@ -96,7 +103,7 @@ class fstream {}; // function wrapper for ofLog class %inline %{ - void log(ofLogLevel level, const string & message) { + void log(ofLogLevel level, const std::string & message) { ofLog(level, message); } %} @@ -130,24 +137,20 @@ class fstream {}; // not needed +// ----- ofThreadChannel.h ----- + +// not needed + // ----- ofURLFileLoader.h ----- // DIFF: ofURLFileLoader.h: ignoring ofHttpResponse ofBuffer operator %ignore ofHttpResponse::operator ofBuffer&(); +// DIFF: ofURLFileLoader.h: ignoring ofURLResponseEvent() +%ignore ofURLResponseEvent(); + %include "utils/ofURLFileLoader.h" // ----- ofUtils.h ----- -// DIFF: ofUtils.h: -// DIFF: ignoring ofFromString as templating results in too much overloading -%ignore ofFromString; - -// DIFF: variable argument support is painful, safer to ignore -// see http://www.swig.org/Doc2.0/Varargs.html -%ignore ofVAArgsToString; - -// DIFF: ignoring ofUTF8Iterator -%ignore ofUTF8Iterator; - -%include "utils/ofUtils.h" +// handled in main.i diff --git a/addons/ofxLua/swig/interfaces/openFrameworks/video.i b/addons/ofxLua/swig/openFrameworks/openFrameworks/video.i similarity index 94% rename from addons/ofxLua/swig/interfaces/openFrameworks/video.i rename to addons/ofxLua/swig/openFrameworks/openFrameworks/video.i index 76e15de..bdc3c0d 100644 --- a/addons/ofxLua/swig/interfaces/openFrameworks/video.i +++ b/addons/ofxLua/swig/openFrameworks/openFrameworks/video.i @@ -1,6 +1,10 @@ // video folder bindings // 2017 Dan Wilcox +// ----- ofVideoBaseTypes.h ----- + +// handled in main.i + // ----- ofVideoGrabber.h ----- // DIFF: ofVideoGrabber.h: ignore getGrabber/setGrabber diff --git a/addons/ofxOpenCv/src/ofxCvContourFinder.h b/addons/ofxOpenCv/src/ofxCvContourFinder.h index 65ecd1b..4ce8e60 100644 --- a/addons/ofxOpenCv/src/ofxCvContourFinder.h +++ b/addons/ofxOpenCv/src/ofxCvContourFinder.h @@ -40,7 +40,7 @@ class ofxCvContourFinder : public ofBaseDraws { virtual void draw() const { draw(0,0, _width, _height); }; void draw( float x, float y ) const override { draw(x,y, _width, _height); }; void draw( float x, float y, float w, float h ) const override; - void draw(const ofPoint & point) const override; + void draw(const ofPoint & point) const; void draw(const ofRectangle & rect) const override; void setAnchorPercent(float xPct, float yPct) override; virtual void setAnchorPoint(int x, int y); diff --git a/addons/ofxXmlSettings/src/ofxXmlSettings.h b/addons/ofxXmlSettings/src/ofxXmlSettings.h index ae348bb..06dfbc1 100644 --- a/addons/ofxXmlSettings/src/ofxXmlSettings.h +++ b/addons/ofxXmlSettings/src/ofxXmlSettings.h @@ -44,7 +44,8 @@ using namespace std; #define MAX_TAG_VALUE_LENGTH_IN_CHARS 1024 -class ofxXmlSettings: public ofBaseFileSerializer{ +class ofxXmlSettings +{ public: ofxXmlSettings(); diff --git a/apps/hec/cc/bin/data/cc-settings.xml b/apps/hec/cc/bin/data/cc-settings.xml index 0713985..4098a24 100644 --- a/apps/hec/cc/bin/data/cc-settings.xml +++ b/apps/hec/cc/bin/data/cc-settings.xml @@ -4,11 +4,11 @@ 0.529296875 0.568396211 -0.251953125 -0.297169805 -0.919921875 +0.277343750 +0.311320752 +0.890625000 0.323113203 -0.900390625 -0.912735820 -0.216796875 -0.896226406 +0.910156250 +0.891509414 +0.271484375 +0.900943398 diff --git a/apps/hec/cc/cc.vcxproj b/apps/hec/cc/cc.vcxproj index 737a30e..8f960f6 100644 --- a/apps/hec/cc/cc.vcxproj +++ b/apps/hec/cc/cc.vcxproj @@ -22,30 +22,30 @@ {7FD42DF7-442E-479A-BA76-D0022F99702A} Win32Proj cc - 8.1 + 10.0 Application Unicode - v140 + v142 Application Unicode - v140 + v142 Application Unicode true - v140 + v142 Application Unicode true - v140 + v142 @@ -224,14 +224,34 @@ copy /Y "$(OF_ROOT)build\bin\luaBox2D_$(Platform)_$(Configuration)" - - + + + + + + + + + + + + + + + + - - - - - + + + + + + + + + + + @@ -288,15 +308,39 @@ copy /Y "$(OF_ROOT)build\bin\luaBox2D_$(Platform)_$(Configuration)" - - - + + + + + + + + + + + + + + + + + + + + - - - - - + + + + + + + + + + + + diff --git a/apps/hec/cc/cc.vcxproj.filters b/apps/hec/cc/cc.vcxproj.filters index 03c702b..e734594 100644 --- a/apps/hec/cc/cc.vcxproj.filters +++ b/apps/hec/cc/cc.vcxproj.filters @@ -97,30 +97,6 @@ src\convexHull - - addons\ofxGui - - - addons\ofxGui - - - addons\ofxGui - - - addons\ofxGui - - - addons\ofxGui - - - addons\ofxGui - - - addons\ofxGui - - - addons\ofxGui - addons\ofxXmlSettings\libs @@ -145,6 +121,90 @@ src + + addons\ofxGui + + + addons\ofxGui + + + addons\ofxGui + + + addons\ofxGui + + + addons\ofxGui + + + addons\ofxGui + + + addons\ofxGui + + + addons\ofxGui + + + addons\ofxGui + + + addons\ofxGui + + + addons\ofxGui + + + addons\ofxGui + + + addons\ofxGui + + + addons\ofxGui + + + addons\ofxGui + + + addons\ofxGui + + + addons\ofxGui + + + addons\ofxGui + + + addons\ofxGui + + + addons\ofxGui + + + addons\ofxGui + + + addons\ofxGui + + + addons\ofxGui + + + addons\ofxGui + + + addons\ofxGui + + + addons\ofxGui + + + addons\ofxGui + + + addons\ofxGui + @@ -878,33 +938,6 @@ src\convexHull - - addons\ofxGui - - - addons\ofxGui - - - addons\ofxGui - - - addons\ofxGui - - - addons\ofxGui - - - addons\ofxGui - - - addons\ofxGui - - - addons\ofxGui - - - addons\ofxGui - src @@ -941,6 +974,105 @@ src + + addons\ofxGui + + + addons\ofxGui + + + addons\ofxGui + + + addons\ofxGui + + + addons\ofxGui + + + addons\ofxGui + + + addons\ofxGui + + + addons\ofxGui + + + addons\ofxGui + + + addons\ofxGui + + + addons\ofxGui + + + addons\ofxGui + + + addons\ofxGui + + + addons\ofxGui + + + addons\ofxGui + + + addons\ofxGui + + + addons\ofxGui + + + addons\ofxGui + + + addons\ofxGui + + + addons\ofxGui + + + addons\ofxGui + + + addons\ofxGui + + + addons\ofxGui + + + addons\ofxGui + + + addons\ofxGui + + + addons\ofxGui + + + addons\ofxGui + + + addons\ofxGui + + + addons\ofxGui + + + addons\ofxGui + + + addons\ofxGui + + + addons\ofxGui + + + addons\ofxGui + diff --git a/apps/hec/cc/luaBox2D.dll b/apps/hec/cc/luaBox2D.dll index 5025743..80f235b 100644 Binary files a/apps/hec/cc/luaBox2D.dll and b/apps/hec/cc/luaBox2D.dll differ diff --git a/apps/hec/cc/luaBox2D.exp b/apps/hec/cc/luaBox2D.exp index d4fdbf3..e69f335 100644 Binary files a/apps/hec/cc/luaBox2D.exp and b/apps/hec/cc/luaBox2D.exp differ diff --git a/apps/hec/cc/luaBox2D.lib b/apps/hec/cc/luaBox2D.lib index 9331a6a..71be19c 100644 Binary files a/apps/hec/cc/luaBox2D.lib and b/apps/hec/cc/luaBox2D.lib differ diff --git a/apps/hec/cc/src/Analysis.cpp b/apps/hec/cc/src/Analysis.cpp index 1e9d128..7245222 100644 --- a/apps/hec/cc/src/Analysis.cpp +++ b/apps/hec/cc/src/Analysis.cpp @@ -233,7 +233,7 @@ void AnalysisThread::update_frame() blobs_path_.clear(); for (const auto& blob : contour_finder_.blobs) { - std::vector filtered; + std::vector filtered; for(const auto& point: blob.pts) { @@ -437,7 +437,7 @@ bool AnalysisThread::point_in_blobs(const ofPoint p, float distance) auto closest_point = blob.getClosestPoint( p ); - if ( fabsf(closest_point.distance(p)) <= distance ) + if ( fabsf(glm::distance(closest_point, glm::vec3(p))) <= distance ) { return true; } diff --git a/apps/hec/cc/src/Settings.cpp b/apps/hec/cc/src/Settings.cpp index c1e85ac..d6c2257 100644 --- a/apps/hec/cc/src/Settings.cpp +++ b/apps/hec/cc/src/Settings.cpp @@ -42,7 +42,7 @@ void ofSettings::scan_for_scripts() { // scripts to run - const string path = "scripts"; + const std::string path = "scripts"; ofDirectory dir(path); dir.allowExt("lua"); @@ -65,7 +65,7 @@ void ofSettings::scan_for_scripts() parameters.add(currentScript.set("script", 0, 0, scripts.size()-1) ); } -string ofSettings::get_script() +std::string ofSettings::get_script() { if (currentScript > 0 && currentScript < scripts.size()) return scripts[currentScript]; diff --git a/apps/hec/cc/src/Settings.h b/apps/hec/cc/src/Settings.h index acd665a..ee9eb85 100644 --- a/apps/hec/cc/src/Settings.h +++ b/apps/hec/cc/src/Settings.h @@ -21,7 +21,7 @@ class ofSettings ofSettings(); void scan_for_scripts(); - string get_script(); + std::string get_script(); int image_size_W = DEPTH_WIDTH; int image_size_H = DEPTH_HEIGHT; @@ -59,6 +59,6 @@ class ofSettings ofParameterGroup& get_gui_parameters(); - vector scripts; + std::vector scripts; ofParameter currentScript; }; diff --git a/apps/hec/cc/src/Uber.cpp b/apps/hec/cc/src/Uber.cpp index d211bb8..ef37859 100644 --- a/apps/hec/cc/src/Uber.cpp +++ b/apps/hec/cc/src/Uber.cpp @@ -1,5 +1,7 @@ #include "Uber.h" -#include "ofxLuaBindings.h" + +#include "ofBindings.h" +#include "ofxLua.h" using namespace lutok2; diff --git a/apps/hec/cc/src/main.cpp b/apps/hec/cc/src/main.cpp index fd40bab..1a9a796 100644 --- a/apps/hec/cc/src/main.cpp +++ b/apps/hec/cc/src/main.cpp @@ -2,32 +2,34 @@ #include "ofAppGui.h" #include "ofAppProjector.h" -ofGLFWWindowSettings settings; -std::shared_ptr app_settings; + //======================================================================== int main() { + ofGLFWWindowSettings projector_settings; + ofGLFWWindowSettings gui_settings; + + std::shared_ptr app_settings; + ofSetLogLevel(OF_LOG_VERBOSE); app_settings = std::make_shared(); - settings.width = 1024; - settings.height = 768; - - settings.resizable = false; - shared_ptr projector_window = ofCreateWindow(settings); - projector_window->setVerticalSync(true); - - settings.width = 1600; - settings.height = 1000; - settings.setPosition(ofVec2f(0, 25)); - settings.resizable = true; + projector_settings.setSize(1024, 768); + projector_settings.resizable = false; + + shared_ptr projector_window = ofCreateWindow(projector_settings); + projector_window->setVerticalSync(true); + + gui_settings.setSize(1600, 1000); + gui_settings.setPosition(ofVec2f(0, 25)); + gui_settings.resizable = true; // share main's OpenGL resources with gui - settings.shareContextWith = projector_window; - shared_ptr gui_window = ofCreateWindow(settings); + gui_settings.shareContextWith = projector_window; + shared_ptr gui_window = ofCreateWindow(gui_settings); gui_window->setVerticalSync(false); shared_ptr gui_app(new ofAppGui); diff --git a/apps/hec/cc/src/ofAppGui.cpp b/apps/hec/cc/src/ofAppGui.cpp index fc31fb3..21840a3 100644 --- a/apps/hec/cc/src/ofAppGui.cpp +++ b/apps/hec/cc/src/ofAppGui.cpp @@ -17,11 +17,11 @@ constexpr char roi_config_file_name[] = "cc-settings.xml"; //-------------------------------------------------------------- void ofAppGui::setup_gui() { - gui.setup(_settings->get_gui_parameters()); - gui.setPosition(spacing + _settings->image_size_W + 5*spacing, spacing + _settings->image_size_H); + //gui.setup(_settings->get_gui_parameters()); + //gui.setPosition(spacing + _settings->image_size_W + 5*spacing, spacing + _settings->image_size_H); - if (ofFile::doesFileExist(gui_config_file_name)) - gui.loadFromFile(gui_config_file_name); + //if (ofFile::doesFileExist(gui_config_file_name)) + // gui.loadFromFile(gui_config_file_name); ofAddListener( _settings->get_gui_parameters().parameterChangedE(), this, &ofAppGui::listenerFunction); @@ -42,7 +42,7 @@ void ofAppGui::listenerFunction(ofAbstractParameter& e) void ofAppGui::exit() { save_config(); - gui.saveToFile("hec-settings.xml"); + //gui.saveToFile("hec-settings.xml"); //recorder.stop(); } @@ -71,7 +71,7 @@ void ofAppGui::draw() // rect.set( _settings->color_preview_pos.getX(), _settings->color_preview_pos.getY(), _settings->image_size_W, _settings->image_size_H); // ofDrawBitmapString(reportStr.str(), rect.getX() + spacing, rect.getY() + spacing); - gui.draw(); + //gui.draw(); } //-------------------------------------------------------------- diff --git a/apps/hec/cc/src/ofAppGui.h b/apps/hec/cc/src/ofAppGui.h index c2b2058..fe002b7 100644 --- a/apps/hec/cc/src/ofAppGui.h +++ b/apps/hec/cc/src/ofAppGui.h @@ -3,7 +3,7 @@ #include "ofMain.h" #include "Settings.h" #include "Analysis.h" -#include "ofxGui/src/ofxPanel.h" +#include "ofxGui/src/ofxGuiExtended.h" #include "ofxXmlSettings/src/ofxXmlSettings.h" class ofAppGui : public ofBaseApp @@ -34,7 +34,7 @@ class ofAppGui : public ofBaseApp //ofRecorder recorder; std::shared_ptr analysis; - ofxPanel gui; + ofxGui gui; vector currentBlobs; diff --git a/libs/FreeImage/include/FreeImage.h b/libs/FreeImage/include/FreeImage.h index cc841b7..12182cd 100644 --- a/libs/FreeImage/include/FreeImage.h +++ b/libs/FreeImage/include/FreeImage.h @@ -29,7 +29,7 @@ // Version information ------------------------------------------------------ #define FREEIMAGE_MAJOR_VERSION 3 -#define FREEIMAGE_MINOR_VERSION 17 +#define FREEIMAGE_MINOR_VERSION 18 #define FREEIMAGE_RELEASE_SERIAL 0 // Compiler options --------------------------------------------------------- @@ -75,7 +75,7 @@ // or define any of FREEIMAGE_BIGENDIAN and FREEIMAGE_LITTLEENDIAN directly // to specify the desired endianness. #if (!defined(FREEIMAGE_BIGENDIAN) && !defined(FREEIMAGE_LITTLEENDIAN)) - #if (defined(BYTE_ORDER) && BYTE_ORDER==BIG_ENDIAN) || (defined(__BYTE_ORDER) && __BYTE_ORDER==__BIG_ENDIAN) || defined(__BIG_ENDIAN__) +#if (defined(BYTE_ORDER) && BYTE_ORDER==BIG_ENDIAN) || (defined(__BYTE_ORDER) && __BYTE_ORDER==__BIG_ENDIAN) || (defined(__BYTE_ORDER) && __BYTE_ORDER==__ORDER_BIG_ENDIAN__) || defined(__BIG_ENDIAN__) #define FREEIMAGE_BIGENDIAN #endif // BYTE_ORDER #endif // !FREEIMAGE_[BIG|LITTLE]ENDIAN @@ -150,22 +150,22 @@ FI_STRUCT (FIMULTIBITMAP) { void *data; }; #ifndef _MSC_VER // define portable types for 32-bit / 64-bit OS #include -#define BOOL int32_t -#define BYTE uint8_t -#define WORD uint16_t -#define DWORD uint32_t -#define LONG int32_t -#define INT64 int64_t -#define UINT64 uint64_t +typedef int32_t BOOL; +typedef uint8_t BYTE; +typedef uint16_t WORD; +typedef uint32_t DWORD; +typedef int32_t LONG; +typedef int64_t INT64; +typedef uint64_t UINT64; #else // MS is not C99 ISO compliant -#define BOOL long -#define BYTE unsigned char -#define WORD unsigned short -#define DWORD unsigned long -#define LONG long -#define INT64 signed __int64 -#define UINT64 unsigned __int64 +typedef long BOOL; +typedef unsigned char BYTE; +typedef unsigned short WORD; +typedef unsigned long DWORD; +typedef long LONG; +typedef signed __int64 INT64; +typedef unsigned __int64 UINT64; #endif // _MSC_VER #if (defined(_WIN32) || defined(__WIN32__)) @@ -731,6 +731,9 @@ typedef void (DLL_CALLCONV *FI_InitProc)(Plugin *plugin, int format_id); #define PSD_DEFAULT 0 #define PSD_CMYK 1 //! reads tags for separated CMYK (default is conversion to RGB) #define PSD_LAB 2 //! reads tags for CIELab (default is conversion to RGB) +#define PSD_NONE 0x0100 //! save without any compression +#define PSD_RLE 0x0200 //! save using RLE compression +#define PSD_PSB 0x2000 //! save using Adobe Large Document Format (use | to combine with other save flags) #define RAS_DEFAULT 0 #define RAW_DEFAULT 0 //! load the file as linear RGB 48-bit #define RAW_PREVIEW 1 //! try to load the embedded JPEG preview with included Exif Data or default to RGB 24-bit @@ -873,13 +876,19 @@ DLL_API void DLL_CALLCONV FreeImage_UnlockPage(FIMULTIBITMAP *bitmap, FIBITMAP * DLL_API BOOL DLL_CALLCONV FreeImage_MovePage(FIMULTIBITMAP *bitmap, int target, int source); DLL_API BOOL DLL_CALLCONV FreeImage_GetLockedPageNumbers(FIMULTIBITMAP *bitmap, int *pages, int *count); -// Filetype request routines ------------------------------------------------ +// File type request routines ------------------------------------------------ DLL_API FREE_IMAGE_FORMAT DLL_CALLCONV FreeImage_GetFileType(const char *filename, int size FI_DEFAULT(0)); DLL_API FREE_IMAGE_FORMAT DLL_CALLCONV FreeImage_GetFileTypeU(const wchar_t *filename, int size FI_DEFAULT(0)); DLL_API FREE_IMAGE_FORMAT DLL_CALLCONV FreeImage_GetFileTypeFromHandle(FreeImageIO *io, fi_handle handle, int size FI_DEFAULT(0)); DLL_API FREE_IMAGE_FORMAT DLL_CALLCONV FreeImage_GetFileTypeFromMemory(FIMEMORY *stream, int size FI_DEFAULT(0)); +DLL_API BOOL DLL_CALLCONV FreeImage_Validate(FREE_IMAGE_FORMAT fif, const char *filename); +DLL_API BOOL DLL_CALLCONV FreeImage_ValidateU(FREE_IMAGE_FORMAT fif, const wchar_t *filename); +DLL_API BOOL DLL_CALLCONV FreeImage_ValidateFromHandle(FREE_IMAGE_FORMAT fif, FreeImageIO *io, fi_handle handle); +DLL_API BOOL DLL_CALLCONV FreeImage_ValidateFromMemory(FREE_IMAGE_FORMAT fif, FIMEMORY *stream); + + // Image type request routine ----------------------------------------------- DLL_API FREE_IMAGE_TYPE DLL_CALLCONV FreeImage_GetImageType(FIBITMAP *dib); @@ -979,8 +988,11 @@ DLL_API void DLL_CALLCONV FreeImage_ConvertLine16To24_555(BYTE *target, BYTE *so DLL_API void DLL_CALLCONV FreeImage_ConvertLine16To24_565(BYTE *target, BYTE *source, int width_in_pixels); DLL_API void DLL_CALLCONV FreeImage_ConvertLine32To24(BYTE *target, BYTE *source, int width_in_pixels); DLL_API void DLL_CALLCONV FreeImage_ConvertLine1To32(BYTE *target, BYTE *source, int width_in_pixels, RGBQUAD *palette); +DLL_API void DLL_CALLCONV FreeImage_ConvertLine1To32MapTransparency(BYTE *target, BYTE *source, int width_in_pixels, RGBQUAD *palette, BYTE *table, int transparent_pixels); DLL_API void DLL_CALLCONV FreeImage_ConvertLine4To32(BYTE *target, BYTE *source, int width_in_pixels, RGBQUAD *palette); +DLL_API void DLL_CALLCONV FreeImage_ConvertLine4To32MapTransparency(BYTE *target, BYTE *source, int width_in_pixels, RGBQUAD *palette, BYTE *table, int transparent_pixels); DLL_API void DLL_CALLCONV FreeImage_ConvertLine8To32(BYTE *target, BYTE *source, int width_in_pixels, RGBQUAD *palette); +DLL_API void DLL_CALLCONV FreeImage_ConvertLine8To32MapTransparency(BYTE *target, BYTE *source, int width_in_pixels, RGBQUAD *palette, BYTE *table, int transparent_pixels); DLL_API void DLL_CALLCONV FreeImage_ConvertLine16To32_555(BYTE *target, BYTE *source, int width_in_pixels); DLL_API void DLL_CALLCONV FreeImage_ConvertLine16To32_565(BYTE *target, BYTE *source, int width_in_pixels); DLL_API void DLL_CALLCONV FreeImage_ConvertLine24To32(BYTE *target, BYTE *source, int width_in_pixels); @@ -1092,8 +1104,6 @@ DLL_API BOOL DLL_CALLCONV FreeImage_JPEGTransformCombinedFromMemory(FIMEMORY* sr // -------------------------------------------------------------------------- // rotation and flipping -/// @deprecated see FreeImage_Rotate -DLL_API FIBITMAP *DLL_CALLCONV FreeImage_RotateClassic(FIBITMAP *dib, double angle); DLL_API FIBITMAP *DLL_CALLCONV FreeImage_Rotate(FIBITMAP *dib, double angle, const void *bkcolor FI_DEFAULT(NULL)); DLL_API FIBITMAP *DLL_CALLCONV FreeImage_RotateEx(FIBITMAP *dib, double angle, double x_shift, double y_shift, double x_origin, double y_origin, BOOL use_mask); DLL_API BOOL DLL_CALLCONV FreeImage_FlipHorizontal(FIBITMAP *dib); diff --git a/libs/FreeImage/lib/vs/Win32/FreeImage.dll b/libs/FreeImage/lib/vs/Win32/FreeImage.dll index cb4cf6e..1959c17 100644 Binary files a/libs/FreeImage/lib/vs/Win32/FreeImage.dll and b/libs/FreeImage/lib/vs/Win32/FreeImage.dll differ diff --git a/libs/FreeImage/lib/vs/Win32/FreeImage.lib b/libs/FreeImage/lib/vs/Win32/FreeImage.lib index 28071aa..433ad8f 100644 Binary files a/libs/FreeImage/lib/vs/Win32/FreeImage.lib and b/libs/FreeImage/lib/vs/Win32/FreeImage.lib differ diff --git a/libs/boost/include/boost/aligned_storage.hpp b/libs/boost/include/boost/aligned_storage.hpp index b5455f0..f400fa9 100644 --- a/libs/boost/include/boost/aligned_storage.hpp +++ b/libs/boost/include/boost/aligned_storage.hpp @@ -13,131 +13,6 @@ #ifndef BOOST_ALIGNED_STORAGE_HPP #define BOOST_ALIGNED_STORAGE_HPP -#include // for std::size_t - -#include "boost/config.hpp" -#include "boost/detail/workaround.hpp" -#include "boost/type_traits/alignment_of.hpp" -#include "boost/type_traits/type_with_alignment.hpp" -#include "boost/type_traits/is_pod.hpp" - -#include "boost/mpl/eval_if.hpp" -#include "boost/mpl/identity.hpp" - -#include "boost/type_traits/detail/bool_trait_def.hpp" - -namespace boost { - -namespace detail { namespace aligned_storage { - -BOOST_STATIC_CONSTANT( - std::size_t - , alignment_of_max_align = ::boost::alignment_of::value - ); - -// -// To be TR1 conforming this must be a POD type: -// -template < - std::size_t size_ - , std::size_t alignment_ -> -struct aligned_storage_imp -{ - union data_t - { - char buf[size_]; - - typename ::boost::mpl::eval_if_c< - alignment_ == std::size_t(-1) - , ::boost::mpl::identity< ::boost::detail::max_align > - , ::boost::type_with_alignment - >::type align_; - } data_; - void* address() const { return const_cast(this); } -}; - -template< std::size_t alignment_ > -struct aligned_storage_imp<0u,alignment_> -{ - /* intentionally empty */ - void* address() const { return 0; } -}; - -}} // namespace detail::aligned_storage - -template < - std::size_t size_ - , std::size_t alignment_ = std::size_t(-1) -> -class aligned_storage : -#ifndef __BORLANDC__ - private -#else - public -#endif - ::boost::detail::aligned_storage::aligned_storage_imp -{ - -public: // constants - - typedef ::boost::detail::aligned_storage::aligned_storage_imp type; - - BOOST_STATIC_CONSTANT( - std::size_t - , size = size_ - ); - BOOST_STATIC_CONSTANT( - std::size_t - , alignment = ( - alignment_ == std::size_t(-1) - ? ::boost::detail::aligned_storage::alignment_of_max_align - : alignment_ - ) - ); - -private: // noncopyable - - aligned_storage(const aligned_storage&); - aligned_storage& operator=(const aligned_storage&); - -public: // structors - - aligned_storage() - { - } - - ~aligned_storage() - { - } - -public: // accessors - - void* address() - { - return static_cast(this)->address(); - } - - const void* address() const - { - return static_cast(this)->address(); - } -}; - -// -// Make sure that is_pod recognises aligned_storage<>::type -// as a POD (Note that aligned_storage<> itself is not a POD): -// -template -struct is_pod< ::boost::detail::aligned_storage::aligned_storage_imp > - BOOST_TT_AUX_BOOL_C_BASE(true) -{ - BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(true) -}; - - -} // namespace boost - -#include "boost/type_traits/detail/bool_trait_undef.hpp" +#include #endif // BOOST_ALIGNED_STORAGE_HPP diff --git a/libs/boost/include/boost/array.hpp b/libs/boost/include/boost/array.hpp index fa06fa9..210c072 100644 --- a/libs/boost/include/boost/array.hpp +++ b/libs/boost/include/boost/array.hpp @@ -13,6 +13,7 @@ * accompanying file LICENSE_1_0.txt or copy at * http://www.boost.org/LICENSE_1_0.txt) * + * 9 Jan 2013 - (mtc) Added constexpr * 14 Apr 2012 - (mtc) Added support for boost::hash * 28 Dec 2010 - (mtc) Added cbegin and cend (and crbegin and crend) for C++Ox compatibility. * 10 Mar 2010 - (mtc) fill method added, matching resolution of the standard library working group. @@ -42,12 +43,12 @@ #include #include #include +#include #include // Handles broken standard libraries better than #include #include -#include #include // FIXES for broken compilers @@ -81,15 +82,9 @@ namespace boost { const_iterator cend() const { return elems+N; } // reverse iterator support -#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_MSVC_STD_ITERATOR) && !defined(BOOST_NO_STD_ITERATOR_TRAITS) +#if !defined(BOOST_MSVC_STD_ITERATOR) && !defined(BOOST_NO_STD_ITERATOR_TRAITS) typedef std::reverse_iterator reverse_iterator; typedef std::reverse_iterator const_reverse_iterator; -#elif defined(_MSC_VER) && (_MSC_VER == 1300) && defined(BOOST_DINKUMWARE_STDLIB) && (BOOST_DINKUMWARE_STDLIB == 310) - // workaround for broken reverse_iterator in VC7 - typedef std::reverse_iterator > reverse_iterator; - typedef std::reverse_iterator > const_reverse_iterator; #elif defined(_RWSTD_NO_CLASS_PARTIAL_SPEC) typedef std::reverse_iterator reverse_iterator; @@ -120,19 +115,17 @@ namespace boost { // operator[] reference operator[](size_type i) { - BOOST_ASSERT_MSG( i < N, "out of range" ); - return elems[i]; + return BOOST_ASSERT_MSG( i < N, "out of range" ), elems[i]; } - const_reference operator[](size_type i) const + /*BOOST_CONSTEXPR*/ const_reference operator[](size_type i) const { - BOOST_ASSERT_MSG( i < N, "out of range" ); - return elems[i]; + return BOOST_ASSERT_MSG( i < N, "out of range" ), elems[i]; } // at() with range check - reference at(size_type i) { rangecheck(i); return elems[i]; } - const_reference at(size_type i) const { rangecheck(i); return elems[i]; } + reference at(size_type i) { return rangecheck(i), elems[i]; } + /*BOOST_CONSTEXPR*/ const_reference at(size_type i) const { return rangecheck(i), elems[i]; } // front() and back() reference front() @@ -140,7 +133,7 @@ namespace boost { return elems[0]; } - const_reference front() const + BOOST_CONSTEXPR const_reference front() const { return elems[0]; } @@ -150,15 +143,15 @@ namespace boost { return elems[N-1]; } - const_reference back() const + BOOST_CONSTEXPR const_reference back() const { return elems[N-1]; } // size is constant - static size_type size() { return N; } - static bool empty() { return false; } - static size_type max_size() { return N; } + static BOOST_CONSTEXPR size_type size() { return N; } + static BOOST_CONSTEXPR bool empty() { return false; } + static BOOST_CONSTEXPR size_type max_size() { return N; } enum { static_size = N }; // swap (note: linear complexity) @@ -189,16 +182,12 @@ namespace boost { } // check range (may be private because it is static) - static void rangecheck (size_type i) { - if (i >= size()) { - std::out_of_range e("array<>: index out of range"); - boost::throw_exception(e); - } + static BOOST_CONSTEXPR bool rangecheck (size_type i) { + return i > size() ? boost::throw_exception(std::out_of_range ("array<>: index out of range")), true : true; } }; -#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) template< class T > class array< T, 0 > { @@ -222,15 +211,9 @@ namespace boost { const_iterator cend() const { return cbegin(); } // reverse iterator support -#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_MSVC_STD_ITERATOR) && !defined(BOOST_NO_STD_ITERATOR_TRAITS) +#if !defined(BOOST_MSVC_STD_ITERATOR) && !defined(BOOST_NO_STD_ITERATOR_TRAITS) typedef std::reverse_iterator reverse_iterator; typedef std::reverse_iterator const_reverse_iterator; -#elif defined(_MSC_VER) && (_MSC_VER == 1300) && defined(BOOST_DINKUMWARE_STDLIB) && (BOOST_DINKUMWARE_STDLIB == 310) - // workaround for broken reverse_iterator in VC7 - typedef std::reverse_iterator > reverse_iterator; - typedef std::reverse_iterator > const_reverse_iterator; #elif defined(_RWSTD_NO_CLASS_PARTIAL_SPEC) typedef std::reverse_iterator reverse_iterator; @@ -264,14 +247,14 @@ namespace boost { return failed_rangecheck(); } - const_reference operator[](size_type /*i*/) const + /*BOOST_CONSTEXPR*/ const_reference operator[](size_type /*i*/) const { return failed_rangecheck(); } // at() with range check reference at(size_type /*i*/) { return failed_rangecheck(); } - const_reference at(size_type /*i*/) const { return failed_rangecheck(); } + /*BOOST_CONSTEXPR*/ const_reference at(size_type /*i*/) const { return failed_rangecheck(); } // front() and back() reference front() @@ -279,7 +262,7 @@ namespace boost { return failed_rangecheck(); } - const_reference front() const + BOOST_CONSTEXPR const_reference front() const { return failed_rangecheck(); } @@ -289,15 +272,15 @@ namespace boost { return failed_rangecheck(); } - const_reference back() const + BOOST_CONSTEXPR const_reference back() const { return failed_rangecheck(); } // size is constant - static size_type size() { return 0; } - static bool empty() { return true; } - static size_type max_size() { return 0; } + static BOOST_CONSTEXPR size_type size() { return 0; } + static BOOST_CONSTEXPR bool empty() { return true; } + static BOOST_CONSTEXPR size_type max_size() { return 0; } enum { static_size = 0 }; void swap (array& /*y*/) { @@ -335,7 +318,6 @@ namespace boost { #endif } }; -#endif // comparisons template @@ -391,7 +373,7 @@ namespace boost { // Specific for boost::array: simply returns its elems data member. template - typename const detail::c_array::type& get_c_array(const boost::array& arg) + typename detail::c_array::type const& get_c_array(const boost::array& arg) { return arg.elems; } @@ -429,6 +411,7 @@ namespace boost { } #endif + template std::size_t hash_range(It, It); template std::size_t hash_value(const array& arr) @@ -436,8 +419,36 @@ namespace boost { return boost::hash_range(arr.begin(), arr.end()); } + template + T &get(boost::array &arr) BOOST_NOEXCEPT { + BOOST_STATIC_ASSERT_MSG ( Idx < N, "boost::get<>(boost::array &) index out of range" ); + return arr[Idx]; + } + + template + const T &get(const boost::array &arr) BOOST_NOEXCEPT { + BOOST_STATIC_ASSERT_MSG ( Idx < N, "boost::get<>(const boost::array &) index out of range" ); + return arr[Idx]; + } + } /* namespace boost */ +#ifndef BOOST_NO_CXX11_HDR_ARRAY +// If we don't have std::array, I'm assuming that we don't have std::get +namespace std { + template + T &get(boost::array &arr) BOOST_NOEXCEPT { + BOOST_STATIC_ASSERT_MSG ( Idx < N, "std::get<>(boost::array &) index out of range" ); + return arr[Idx]; + } + + template + const T &get(const boost::array &arr) BOOST_NOEXCEPT { + BOOST_STATIC_ASSERT_MSG ( Idx < N, "std::get<>(const boost::array &) index out of range" ); + return arr[Idx]; + } +} +#endif #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) # pragma warning(pop) diff --git a/libs/boost/include/boost/assert.hpp b/libs/boost/include/boost/assert.hpp index 1713d9b..9650d7a 100644 --- a/libs/boost/include/boost/assert.hpp +++ b/libs/boost/include/boost/assert.hpp @@ -3,10 +3,12 @@ // BOOST_ASSERT_MSG(expr, msg) // BOOST_VERIFY(expr) // BOOST_VERIFY_MSG(expr, msg) +// BOOST_ASSERT_IS_VOID // // Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd. // Copyright (c) 2007, 2014 Peter Dimov // Copyright (c) Beman Dawes 2011 +// Copyright (c) 2015 Ion Gaztanaga // // Distributed under the Boost Software License, Version 1.0. // See accompanying file LICENSE_1_0.txt or copy at @@ -24,16 +26,18 @@ // // -// BOOST_ASSERT, BOOST_ASSERT_MSG +// BOOST_ASSERT, BOOST_ASSERT_MSG, BOOST_ASSERT_IS_VOID // #undef BOOST_ASSERT #undef BOOST_ASSERT_MSG +#undef BOOST_ASSERT_IS_VOID #if defined(BOOST_DISABLE_ASSERTS) || ( defined(BOOST_ENABLE_ASSERT_DEBUG_HANDLER) && defined(NDEBUG) ) # define BOOST_ASSERT(expr) ((void)0) # define BOOST_ASSERT_MSG(expr, msg) ((void)0) +# define BOOST_ASSERT_IS_VOID #elif defined(BOOST_ENABLE_ASSERT_HANDLER) || ( defined(BOOST_ENABLE_ASSERT_DEBUG_HANDLER) && !defined(NDEBUG) ) @@ -55,6 +59,9 @@ namespace boost # define BOOST_ASSERT(expr) assert(expr) # define BOOST_ASSERT_MSG(expr, msg) assert((expr)&&(msg)) +#if defined(NDEBUG) +# define BOOST_ASSERT_IS_VOID +#endif #endif diff --git a/libs/boost/include/boost/atomic.hpp b/libs/boost/include/boost/atomic.hpp new file mode 100644 index 0000000..cc28b1a --- /dev/null +++ b/libs/boost/include/boost/atomic.hpp @@ -0,0 +1,18 @@ +#ifndef BOOST_ATOMIC_HPP +#define BOOST_ATOMIC_HPP + +// Copyright (c) 2011 Helge Bahmann +// +// Distributed under the Boost Software License, Version 1.0. +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// This header includes all Boost.Atomic public headers + +#include + +#ifdef BOOST_HAS_PRAGMA_ONCE +#pragma once +#endif + +#endif diff --git a/libs/boost/include/boost/atomic/atomic.hpp b/libs/boost/include/boost/atomic/atomic.hpp new file mode 100644 index 0000000..8b0bdd1 --- /dev/null +++ b/libs/boost/include/boost/atomic/atomic.hpp @@ -0,0 +1,93 @@ +/* + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or copy at + * http://www.boost.org/LICENSE_1_0.txt) + * + * Copyright (c) 2011 Helge Bahmann + * Copyright (c) 2013 Tim Blechmann + * Copyright (c) 2014 Andrey Semashev + */ +/*! + * \file atomic/atomic.hpp + * + * This header contains definition of \c atomic template and \c atomic_flag. + */ + +#ifndef BOOST_ATOMIC_ATOMIC_HPP_INCLUDED_ +#define BOOST_ATOMIC_ATOMIC_HPP_INCLUDED_ + +#include +#include +#include +#include +#include + +#ifdef BOOST_HAS_PRAGMA_ONCE +#pragma once +#endif + +namespace boost { + +using atomics::atomic; + +using atomics::atomic_char; +using atomics::atomic_uchar; +using atomics::atomic_schar; +using atomics::atomic_uint8_t; +using atomics::atomic_int8_t; +using atomics::atomic_ushort; +using atomics::atomic_short; +using atomics::atomic_uint16_t; +using atomics::atomic_int16_t; +using atomics::atomic_uint; +using atomics::atomic_int; +using atomics::atomic_uint32_t; +using atomics::atomic_int32_t; +using atomics::atomic_ulong; +using atomics::atomic_long; +using atomics::atomic_uint64_t; +using atomics::atomic_int64_t; +#ifdef BOOST_HAS_LONG_LONG +using atomics::atomic_ullong; +using atomics::atomic_llong; +#endif +using atomics::atomic_address; +using atomics::atomic_bool; +using atomics::atomic_wchar_t; +#if !defined(BOOST_NO_CXX11_CHAR16_T) +using atomics::atomic_char16_t; +#endif +#if !defined(BOOST_NO_CXX11_CHAR32_T) +using atomics::atomic_char32_t; +#endif + +using atomics::atomic_int_least8_t; +using atomics::atomic_uint_least8_t; +using atomics::atomic_int_least16_t; +using atomics::atomic_uint_least16_t; +using atomics::atomic_int_least32_t; +using atomics::atomic_uint_least32_t; +using atomics::atomic_int_least64_t; +using atomics::atomic_uint_least64_t; +using atomics::atomic_int_fast8_t; +using atomics::atomic_uint_fast8_t; +using atomics::atomic_int_fast16_t; +using atomics::atomic_uint_fast16_t; +using atomics::atomic_int_fast32_t; +using atomics::atomic_uint_fast32_t; +using atomics::atomic_int_fast64_t; +using atomics::atomic_uint_fast64_t; +using atomics::atomic_intmax_t; +using atomics::atomic_uintmax_t; + +using atomics::atomic_size_t; +using atomics::atomic_ptrdiff_t; + +#if defined(BOOST_HAS_INTPTR_T) +using atomics::atomic_intptr_t; +using atomics::atomic_uintptr_t; +#endif + +} // namespace boost + +#endif // BOOST_ATOMIC_ATOMIC_HPP_INCLUDED_ diff --git a/libs/boost/include/boost/atomic/atomic_flag.hpp b/libs/boost/include/boost/atomic/atomic_flag.hpp new file mode 100644 index 0000000..ac296bc --- /dev/null +++ b/libs/boost/include/boost/atomic/atomic_flag.hpp @@ -0,0 +1,33 @@ +/* + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or copy at + * http://www.boost.org/LICENSE_1_0.txt) + * + * Copyright (c) 2011 Helge Bahmann + * Copyright (c) 2013 Tim Blechmann + * Copyright (c) 2014 Andrey Semashev + */ +/*! + * \file atomic/atomic_flag.hpp + * + * This header contains definition of \c atomic_flag. + */ + +#ifndef BOOST_ATOMIC_ATOMIC_FLAG_HPP_INCLUDED_ +#define BOOST_ATOMIC_ATOMIC_FLAG_HPP_INCLUDED_ + +#include +#include +#include + +#ifdef BOOST_HAS_PRAGMA_ONCE +#pragma once +#endif + +namespace boost { + +using atomics::atomic_flag; + +} // namespace boost + +#endif // BOOST_ATOMIC_ATOMIC_FLAG_HPP_INCLUDED_ diff --git a/libs/boost/include/boost/atomic/capabilities.hpp b/libs/boost/include/boost/atomic/capabilities.hpp new file mode 100644 index 0000000..05bbb0f --- /dev/null +++ b/libs/boost/include/boost/atomic/capabilities.hpp @@ -0,0 +1,161 @@ +/* + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or copy at + * http://www.boost.org/LICENSE_1_0.txt) + * + * Copyright (c) 2014 Andrey Semashev + */ +/*! + * \file atomic/capabilities.hpp + * + * This header defines feature capabilities macros. + */ + +#ifndef BOOST_ATOMIC_CAPABILITIES_HPP_INCLUDED_ +#define BOOST_ATOMIC_CAPABILITIES_HPP_INCLUDED_ + +#include +#include +#include + +#if !defined(BOOST_ATOMIC_EMULATED) +#include BOOST_ATOMIC_DETAIL_HEADER(boost/atomic/detail/caps_) +#endif + +#ifdef BOOST_HAS_PRAGMA_ONCE +#pragma once +#endif + +#ifndef BOOST_ATOMIC_INT8_LOCK_FREE +#define BOOST_ATOMIC_INT8_LOCK_FREE 0 +#endif + +#ifndef BOOST_ATOMIC_INT16_LOCK_FREE +#define BOOST_ATOMIC_INT16_LOCK_FREE 0 +#endif + +#ifndef BOOST_ATOMIC_INT32_LOCK_FREE +#define BOOST_ATOMIC_INT32_LOCK_FREE 0 +#endif + +#ifndef BOOST_ATOMIC_INT64_LOCK_FREE +#define BOOST_ATOMIC_INT64_LOCK_FREE 0 +#endif + +#ifndef BOOST_ATOMIC_INT128_LOCK_FREE +#define BOOST_ATOMIC_INT128_LOCK_FREE 0 +#endif + + +#ifndef BOOST_ATOMIC_CHAR_LOCK_FREE +#define BOOST_ATOMIC_CHAR_LOCK_FREE BOOST_ATOMIC_INT8_LOCK_FREE +#endif + +#ifndef BOOST_ATOMIC_CHAR16_T_LOCK_FREE +#define BOOST_ATOMIC_CHAR16_T_LOCK_FREE BOOST_ATOMIC_INT16_LOCK_FREE +#endif + +#ifndef BOOST_ATOMIC_CHAR32_T_LOCK_FREE +#define BOOST_ATOMIC_CHAR32_T_LOCK_FREE BOOST_ATOMIC_INT32_LOCK_FREE +#endif + +#ifndef BOOST_ATOMIC_WCHAR_T_LOCK_FREE +#if BOOST_ATOMIC_DETAIL_SIZEOF_WCHAR_T == 1 +#define BOOST_ATOMIC_WCHAR_T_LOCK_FREE BOOST_ATOMIC_INT8_LOCK_FREE +#elif BOOST_ATOMIC_DETAIL_SIZEOF_WCHAR_T == 2 +#define BOOST_ATOMIC_WCHAR_T_LOCK_FREE BOOST_ATOMIC_INT16_LOCK_FREE +#elif BOOST_ATOMIC_DETAIL_SIZEOF_WCHAR_T == 4 +#define BOOST_ATOMIC_WCHAR_T_LOCK_FREE BOOST_ATOMIC_INT32_LOCK_FREE +#elif BOOST_ATOMIC_DETAIL_SIZEOF_WCHAR_T == 8 +#define BOOST_ATOMIC_WCHAR_T_LOCK_FREE BOOST_ATOMIC_INT64_LOCK_FREE +#else +#define BOOST_ATOMIC_WCHAR_T_LOCK_FREE 0 +#endif +#endif + +#ifndef BOOST_ATOMIC_SHORT_LOCK_FREE +#if BOOST_ATOMIC_DETAIL_SIZEOF_SHORT == 1 +#define BOOST_ATOMIC_SHORT_LOCK_FREE BOOST_ATOMIC_INT8_LOCK_FREE +#elif BOOST_ATOMIC_DETAIL_SIZEOF_SHORT == 2 +#define BOOST_ATOMIC_SHORT_LOCK_FREE BOOST_ATOMIC_INT16_LOCK_FREE +#elif BOOST_ATOMIC_DETAIL_SIZEOF_SHORT == 4 +#define BOOST_ATOMIC_SHORT_LOCK_FREE BOOST_ATOMIC_INT32_LOCK_FREE +#elif BOOST_ATOMIC_DETAIL_SIZEOF_SHORT == 8 +#define BOOST_ATOMIC_SHORT_LOCK_FREE BOOST_ATOMIC_INT64_LOCK_FREE +#else +#define BOOST_ATOMIC_SHORT_LOCK_FREE 0 +#endif +#endif + +#ifndef BOOST_ATOMIC_INT_LOCK_FREE +#if BOOST_ATOMIC_DETAIL_SIZEOF_INT == 1 +#define BOOST_ATOMIC_INT_LOCK_FREE BOOST_ATOMIC_INT8_LOCK_FREE +#elif BOOST_ATOMIC_DETAIL_SIZEOF_INT == 2 +#define BOOST_ATOMIC_INT_LOCK_FREE BOOST_ATOMIC_INT16_LOCK_FREE +#elif BOOST_ATOMIC_DETAIL_SIZEOF_INT == 4 +#define BOOST_ATOMIC_INT_LOCK_FREE BOOST_ATOMIC_INT32_LOCK_FREE +#elif BOOST_ATOMIC_DETAIL_SIZEOF_INT == 8 +#define BOOST_ATOMIC_INT_LOCK_FREE BOOST_ATOMIC_INT64_LOCK_FREE +#else +#define BOOST_ATOMIC_INT_LOCK_FREE 0 +#endif +#endif + +#ifndef BOOST_ATOMIC_LONG_LOCK_FREE +#if BOOST_ATOMIC_DETAIL_SIZEOF_LONG == 1 +#define BOOST_ATOMIC_LONG_LOCK_FREE BOOST_ATOMIC_INT8_LOCK_FREE +#elif BOOST_ATOMIC_DETAIL_SIZEOF_LONG == 2 +#define BOOST_ATOMIC_LONG_LOCK_FREE BOOST_ATOMIC_INT16_LOCK_FREE +#elif BOOST_ATOMIC_DETAIL_SIZEOF_LONG == 4 +#define BOOST_ATOMIC_LONG_LOCK_FREE BOOST_ATOMIC_INT32_LOCK_FREE +#elif BOOST_ATOMIC_DETAIL_SIZEOF_LONG == 8 +#define BOOST_ATOMIC_LONG_LOCK_FREE BOOST_ATOMIC_INT64_LOCK_FREE +#else +#define BOOST_ATOMIC_LONG_LOCK_FREE 0 +#endif +#endif + +#ifndef BOOST_ATOMIC_LLONG_LOCK_FREE +#if BOOST_ATOMIC_DETAIL_SIZEOF_LLONG == 1 +#define BOOST_ATOMIC_LLONG_LOCK_FREE BOOST_ATOMIC_INT8_LOCK_FREE +#elif BOOST_ATOMIC_DETAIL_SIZEOF_LLONG == 2 +#define BOOST_ATOMIC_LLONG_LOCK_FREE BOOST_ATOMIC_INT16_LOCK_FREE +#elif BOOST_ATOMIC_DETAIL_SIZEOF_LLONG == 4 +#define BOOST_ATOMIC_LLONG_LOCK_FREE BOOST_ATOMIC_INT32_LOCK_FREE +#elif BOOST_ATOMIC_DETAIL_SIZEOF_LLONG == 8 +#define BOOST_ATOMIC_LLONG_LOCK_FREE BOOST_ATOMIC_INT64_LOCK_FREE +#else +#define BOOST_ATOMIC_LLONG_LOCK_FREE 0 +#endif +#endif + +#ifndef BOOST_ATOMIC_POINTER_LOCK_FREE +#if (BOOST_ATOMIC_DETAIL_SIZEOF_POINTER + 0) == 8 +#define BOOST_ATOMIC_POINTER_LOCK_FREE BOOST_ATOMIC_INT64_LOCK_FREE +#elif (BOOST_ATOMIC_DETAIL_SIZEOF_POINTER + 0) == 4 +#define BOOST_ATOMIC_POINTER_LOCK_FREE BOOST_ATOMIC_INT32_LOCK_FREE +#else +#define BOOST_ATOMIC_POINTER_LOCK_FREE 0 +#endif +#endif + +#define BOOST_ATOMIC_ADDRESS_LOCK_FREE BOOST_ATOMIC_POINTER_LOCK_FREE + +#ifndef BOOST_ATOMIC_BOOL_LOCK_FREE +// We store bools in 1-byte storage in all backends +#define BOOST_ATOMIC_BOOL_LOCK_FREE BOOST_ATOMIC_INT8_LOCK_FREE +#endif + +#ifndef BOOST_ATOMIC_FLAG_LOCK_FREE +#define BOOST_ATOMIC_FLAG_LOCK_FREE BOOST_ATOMIC_BOOL_LOCK_FREE +#endif + +#ifndef BOOST_ATOMIC_THREAD_FENCE +#define BOOST_ATOMIC_THREAD_FENCE 0 +#endif + +#ifndef BOOST_ATOMIC_SIGNAL_FENCE +#define BOOST_ATOMIC_SIGNAL_FENCE 0 +#endif + +#endif // BOOST_ATOMIC_CAPABILITIES_HPP_INCLUDED_ diff --git a/libs/boost/include/boost/atomic/detail/atomic_flag.hpp b/libs/boost/include/boost/atomic/detail/atomic_flag.hpp new file mode 100644 index 0000000..7fb44cd --- /dev/null +++ b/libs/boost/include/boost/atomic/detail/atomic_flag.hpp @@ -0,0 +1,70 @@ +/* + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or copy at + * http://www.boost.org/LICENSE_1_0.txt) + * + * Copyright (c) 2014 Andrey Semashev + */ +/*! + * \file atomic/detail/atomic_flag.hpp + * + * This header contains interface definition of \c atomic_flag. + */ + +#ifndef BOOST_ATOMIC_DETAIL_ATOMIC_FLAG_HPP_INCLUDED_ +#define BOOST_ATOMIC_DETAIL_ATOMIC_FLAG_HPP_INCLUDED_ + +#include +#include +#include +#include + +#ifdef BOOST_HAS_PRAGMA_ONCE +#pragma once +#endif + +/* + * IMPLEMENTATION NOTE: All interface functions MUST be declared with BOOST_FORCEINLINE, + * see comment for convert_memory_order_to_gcc in ops_gcc_atomic.hpp. + */ + +namespace boost { +namespace atomics { + +#if defined(BOOST_NO_CXX11_CONSTEXPR) || defined(BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX) +#define BOOST_ATOMIC_NO_ATOMIC_FLAG_INIT +#else +#define BOOST_ATOMIC_FLAG_INIT {} +#endif + +struct atomic_flag +{ + typedef atomics::detail::operations< 1u, false > operations; + typedef operations::storage_type storage_type; + + operations::aligned_storage_type m_storage; + + BOOST_FORCEINLINE BOOST_CONSTEXPR atomic_flag() BOOST_NOEXCEPT : m_storage(0) + { + } + + BOOST_FORCEINLINE bool test_and_set(memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT + { + return operations::test_and_set(m_storage.value, order); + } + + BOOST_FORCEINLINE void clear(memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT + { + BOOST_ASSERT(order != memory_order_acquire); + BOOST_ASSERT(order != memory_order_acq_rel); + operations::clear(m_storage.value, order); + } + + BOOST_DELETED_FUNCTION(atomic_flag(atomic_flag const&)) + BOOST_DELETED_FUNCTION(atomic_flag& operator= (atomic_flag const&)) +}; + +} // namespace atomics +} // namespace boost + +#endif // BOOST_ATOMIC_DETAIL_ATOMIC_FLAG_HPP_INCLUDED_ diff --git a/libs/boost/include/boost/atomic/detail/atomic_template.hpp b/libs/boost/include/boost/atomic/detail/atomic_template.hpp new file mode 100644 index 0000000..7bbc1ff --- /dev/null +++ b/libs/boost/include/boost/atomic/detail/atomic_template.hpp @@ -0,0 +1,727 @@ +/* + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or copy at + * http://www.boost.org/LICENSE_1_0.txt) + * + * Copyright (c) 2011 Helge Bahmann + * Copyright (c) 2013 Tim Blechmann + * Copyright (c) 2014 Andrey Semashev + */ +/*! + * \file atomic/detail/atomic_template.hpp + * + * This header contains interface definition of \c atomic template. + */ + +#ifndef BOOST_ATOMIC_DETAIL_ATOMIC_TEMPLATE_HPP_INCLUDED_ +#define BOOST_ATOMIC_DETAIL_ATOMIC_TEMPLATE_HPP_INCLUDED_ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef BOOST_HAS_PRAGMA_ONCE +#pragma once +#endif + +#if defined(BOOST_MSVC) +#pragma warning(push) +// 'boost::atomics::atomic' : multiple assignment operators specified +#pragma warning(disable: 4522) +#endif + +/* + * IMPLEMENTATION NOTE: All interface functions MUST be declared with BOOST_FORCEINLINE, + * see comment for convert_memory_order_to_gcc in ops_gcc_atomic.hpp. + */ + +namespace boost { +namespace atomics { +namespace detail { + +BOOST_FORCEINLINE BOOST_CONSTEXPR memory_order deduce_failure_order(memory_order order) BOOST_NOEXCEPT +{ + return order == memory_order_acq_rel ? memory_order_acquire : (order == memory_order_release ? memory_order_relaxed : order); +} + +BOOST_FORCEINLINE BOOST_CONSTEXPR bool cas_failure_order_must_not_be_stronger_than_success_order(memory_order success_order, memory_order failure_order) BOOST_NOEXCEPT +{ + // 15 == (memory_order_seq_cst | memory_order_consume), see memory_order.hpp + // Given the enum values we can test the strength of memory order requirements with this single condition. + return (failure_order & 15u) <= (success_order & 15u); +} + +template< typename T, bool IsFunction = boost::atomics::detail::is_function< T >::value > +struct classify_pointer +{ + typedef void* type; +}; + +template< typename T > +struct classify_pointer< T, true > +{ + typedef void type; +}; + +template< typename T, bool IsInt = boost::atomics::detail::is_integral< T >::value > +struct classify +{ + typedef void type; +}; + +template< typename T > +struct classify< T, true > { typedef int type; }; + +template< typename T > +struct classify< T*, false > { typedef typename classify_pointer< T >::type type; }; + +template< > +struct classify< void*, false > { typedef void type; }; + +template< > +struct classify< const void*, false > { typedef void type; }; + +template< > +struct classify< volatile void*, false > { typedef void type; }; + +template< > +struct classify< const volatile void*, false > { typedef void type; }; + +template< typename T, typename U > +struct classify< T U::*, false > { typedef void type; }; + +template< bool > +struct boolean_constant {}; +typedef boolean_constant< true > true_constant; +typedef boolean_constant< false > false_constant; + + +template< typename T, typename Kind > +class base_atomic; + +//! General template. Implementation for user-defined types, such as structs and enums, and pointers to non-object types +template< typename T > +class base_atomic< T, void > +{ +public: + typedef T value_type; + +protected: + typedef atomics::detail::operations< storage_size_of< value_type >::value, false > operations; + typedef typename boost::atomics::detail::conditional< sizeof(value_type) <= sizeof(void*), value_type, value_type const& >::type value_arg_type; + +public: + typedef typename operations::storage_type storage_type; + +private: + typedef boolean_constant< sizeof(value_type) == sizeof(storage_type) > value_matches_storage; + +protected: + typename operations::aligned_storage_type m_storage; + +public: + BOOST_FORCEINLINE explicit base_atomic(value_arg_type v = value_type()) BOOST_NOEXCEPT : m_storage(atomics::detail::bitwise_cast< storage_type >(v)) + { + } + + BOOST_FORCEINLINE void store(value_arg_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT + { + BOOST_ASSERT(order != memory_order_consume); + BOOST_ASSERT(order != memory_order_acquire); + BOOST_ASSERT(order != memory_order_acq_rel); + + operations::store(m_storage.value, atomics::detail::bitwise_cast< storage_type >(v), order); + } + + BOOST_FORCEINLINE value_type load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT + { + BOOST_ASSERT(order != memory_order_release); + BOOST_ASSERT(order != memory_order_acq_rel); + + return atomics::detail::bitwise_cast< value_type >(operations::load(m_storage.value, order)); + } + + BOOST_FORCEINLINE value_type exchange(value_arg_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT + { + return atomics::detail::bitwise_cast< value_type >(operations::exchange(m_storage.value, atomics::detail::bitwise_cast< storage_type >(v), order)); + } + + BOOST_FORCEINLINE bool compare_exchange_strong(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order) volatile BOOST_NOEXCEPT + { + BOOST_ASSERT(failure_order != memory_order_release); + BOOST_ASSERT(failure_order != memory_order_acq_rel); + BOOST_ASSERT(cas_failure_order_must_not_be_stronger_than_success_order(success_order, failure_order)); + + return compare_exchange_strong_impl(expected, desired, success_order, failure_order, value_matches_storage()); + } + + BOOST_FORCEINLINE bool compare_exchange_strong(value_type& expected, value_arg_type desired, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT + { + return compare_exchange_strong(expected, desired, order, atomics::detail::deduce_failure_order(order)); + } + + BOOST_FORCEINLINE bool compare_exchange_weak(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order) volatile BOOST_NOEXCEPT + { + BOOST_ASSERT(failure_order != memory_order_release); + BOOST_ASSERT(failure_order != memory_order_acq_rel); + BOOST_ASSERT(cas_failure_order_must_not_be_stronger_than_success_order(success_order, failure_order)); + + return compare_exchange_weak_impl(expected, desired, success_order, failure_order, value_matches_storage()); + } + + BOOST_FORCEINLINE bool compare_exchange_weak(value_type& expected, value_arg_type desired, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT + { + return compare_exchange_weak(expected, desired, order, atomics::detail::deduce_failure_order(order)); + } + + BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&)) + BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&)) + +private: + BOOST_FORCEINLINE bool compare_exchange_strong_impl(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order, true_constant) volatile BOOST_NOEXCEPT + { +#if defined(BOOST_ATOMIC_DETAIL_STORAGE_TYPE_MAY_ALIAS) + return operations::compare_exchange_strong(m_storage.value, reinterpret_cast< storage_type& >(expected), atomics::detail::bitwise_cast< storage_type >(desired), success_order, failure_order); +#else + return compare_exchange_strong_impl(expected, desired, success_order, failure_order, false_constant()); +#endif + } + + BOOST_FORCEINLINE bool compare_exchange_strong_impl(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order, false_constant) volatile BOOST_NOEXCEPT + { + storage_type old_value = atomics::detail::bitwise_cast< storage_type >(expected); + const bool res = operations::compare_exchange_strong(m_storage.value, old_value, atomics::detail::bitwise_cast< storage_type >(desired), success_order, failure_order); + expected = atomics::detail::bitwise_cast< value_type >(old_value); + return res; + } + + BOOST_FORCEINLINE bool compare_exchange_weak_impl(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order, true_constant) volatile BOOST_NOEXCEPT + { +#if defined(BOOST_ATOMIC_DETAIL_STORAGE_TYPE_MAY_ALIAS) + return operations::compare_exchange_weak(m_storage.value, reinterpret_cast< storage_type& >(expected), atomics::detail::bitwise_cast< storage_type >(desired), success_order, failure_order); +#else + return compare_exchange_weak_impl(expected, desired, success_order, failure_order, false_constant()); +#endif + } + + BOOST_FORCEINLINE bool compare_exchange_weak_impl(value_type& expected, value_arg_type desired, memory_order success_order, memory_order failure_order, false_constant) volatile BOOST_NOEXCEPT + { + storage_type old_value = atomics::detail::bitwise_cast< storage_type >(expected); + const bool res = operations::compare_exchange_weak(m_storage.value, old_value, atomics::detail::bitwise_cast< storage_type >(desired), success_order, failure_order); + expected = atomics::detail::bitwise_cast< value_type >(old_value); + return res; + } +}; + + +//! Implementation for integers +template< typename T > +class base_atomic< T, int > +{ +public: + typedef T value_type; + typedef T difference_type; + +protected: + typedef atomics::detail::operations< storage_size_of< value_type >::value, boost::atomics::detail::is_signed< T >::value > operations; + typedef value_type value_arg_type; + +public: + typedef typename operations::storage_type storage_type; + +protected: + typename operations::aligned_storage_type m_storage; + +public: + BOOST_DEFAULTED_FUNCTION(base_atomic(), {}) + BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : m_storage(v) {} + + BOOST_FORCEINLINE void store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT + { + BOOST_ASSERT(order != memory_order_consume); + BOOST_ASSERT(order != memory_order_acquire); + BOOST_ASSERT(order != memory_order_acq_rel); + + operations::store(m_storage.value, static_cast< storage_type >(v), order); + } + + BOOST_FORCEINLINE value_type load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT + { + BOOST_ASSERT(order != memory_order_release); + BOOST_ASSERT(order != memory_order_acq_rel); + + return static_cast< value_type >(operations::load(m_storage.value, order)); + } + + BOOST_FORCEINLINE value_type fetch_add(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT + { + return static_cast< value_type >(operations::fetch_add(m_storage.value, static_cast< storage_type >(v), order)); + } + + BOOST_FORCEINLINE value_type fetch_sub(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT + { + return static_cast< value_type >(operations::fetch_sub(m_storage.value, static_cast< storage_type >(v), order)); + } + + BOOST_FORCEINLINE value_type exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT + { + return static_cast< value_type >(operations::exchange(m_storage.value, static_cast< storage_type >(v), order)); + } + + BOOST_FORCEINLINE bool compare_exchange_strong(value_type& expected, value_type desired, memory_order success_order, memory_order failure_order) volatile BOOST_NOEXCEPT + { + BOOST_ASSERT(failure_order != memory_order_release); + BOOST_ASSERT(failure_order != memory_order_acq_rel); + BOOST_ASSERT(cas_failure_order_must_not_be_stronger_than_success_order(success_order, failure_order)); + +#if defined(BOOST_ATOMIC_DETAIL_STORAGE_TYPE_MAY_ALIAS) + return operations::compare_exchange_strong(m_storage.value, reinterpret_cast< storage_type& >(expected), static_cast< storage_type >(desired), success_order, failure_order); +#else + storage_type old_value = static_cast< storage_type >(expected); + const bool res = operations::compare_exchange_strong(m_storage.value, old_value, static_cast< storage_type >(desired), success_order, failure_order); + expected = static_cast< value_type >(old_value); + return res; +#endif + } + + BOOST_FORCEINLINE bool compare_exchange_strong(value_type& expected, value_type desired, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT + { + return compare_exchange_strong(expected, desired, order, atomics::detail::deduce_failure_order(order)); + } + + BOOST_FORCEINLINE bool compare_exchange_weak(value_type& expected, value_type desired, memory_order success_order, memory_order failure_order) volatile BOOST_NOEXCEPT + { + BOOST_ASSERT(failure_order != memory_order_release); + BOOST_ASSERT(failure_order != memory_order_acq_rel); + BOOST_ASSERT(cas_failure_order_must_not_be_stronger_than_success_order(success_order, failure_order)); + +#if defined(BOOST_ATOMIC_DETAIL_STORAGE_TYPE_MAY_ALIAS) + return operations::compare_exchange_weak(m_storage.value, reinterpret_cast< storage_type& >(expected), static_cast< storage_type >(desired), success_order, failure_order); +#else + storage_type old_value = static_cast< storage_type >(expected); + const bool res = operations::compare_exchange_weak(m_storage.value, old_value, static_cast< storage_type >(desired), success_order, failure_order); + expected = static_cast< value_type >(old_value); + return res; +#endif + } + + BOOST_FORCEINLINE bool compare_exchange_weak(value_type& expected, value_type desired, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT + { + return compare_exchange_weak(expected, desired, order, atomics::detail::deduce_failure_order(order)); + } + + BOOST_FORCEINLINE value_type fetch_and(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT + { + return static_cast< value_type >(operations::fetch_and(m_storage.value, static_cast< storage_type >(v), order)); + } + + BOOST_FORCEINLINE value_type fetch_or(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT + { + return static_cast< value_type >(operations::fetch_or(m_storage.value, static_cast< storage_type >(v), order)); + } + + BOOST_FORCEINLINE value_type fetch_xor(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT + { + return static_cast< value_type >(operations::fetch_xor(m_storage.value, static_cast< storage_type >(v), order)); + } + + BOOST_FORCEINLINE value_type operator++(int) volatile BOOST_NOEXCEPT + { + return fetch_add(1); + } + + BOOST_FORCEINLINE value_type operator++() volatile BOOST_NOEXCEPT + { + return fetch_add(1) + 1; + } + + BOOST_FORCEINLINE value_type operator--(int) volatile BOOST_NOEXCEPT + { + return fetch_sub(1); + } + + BOOST_FORCEINLINE value_type operator--() volatile BOOST_NOEXCEPT + { + return fetch_sub(1) - 1; + } + + BOOST_FORCEINLINE value_type operator+=(difference_type v) volatile BOOST_NOEXCEPT + { + return fetch_add(v) + v; + } + + BOOST_FORCEINLINE value_type operator-=(difference_type v) volatile BOOST_NOEXCEPT + { + return fetch_sub(v) - v; + } + + BOOST_FORCEINLINE value_type operator&=(value_type v) volatile BOOST_NOEXCEPT + { + return fetch_and(v) & v; + } + + BOOST_FORCEINLINE value_type operator|=(value_type v) volatile BOOST_NOEXCEPT + { + return fetch_or(v) | v; + } + + BOOST_FORCEINLINE value_type operator^=(value_type v) volatile BOOST_NOEXCEPT + { + return fetch_xor(v) ^ v; + } + + BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&)) + BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&)) +}; + +//! Implementation for bool +template< > +class base_atomic< bool, int > +{ +public: + typedef bool value_type; + +protected: + typedef atomics::detail::operations< 1u, false > operations; + typedef value_type value_arg_type; + +public: + typedef operations::storage_type storage_type; + +protected: + operations::aligned_storage_type m_storage; + +public: + BOOST_DEFAULTED_FUNCTION(base_atomic(), {}) + BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : m_storage(v) {} + + BOOST_FORCEINLINE void store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT + { + BOOST_ASSERT(order != memory_order_consume); + BOOST_ASSERT(order != memory_order_acquire); + BOOST_ASSERT(order != memory_order_acq_rel); + + operations::store(m_storage.value, static_cast< storage_type >(v), order); + } + + BOOST_FORCEINLINE value_type load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT + { + BOOST_ASSERT(order != memory_order_release); + BOOST_ASSERT(order != memory_order_acq_rel); + + return !!operations::load(m_storage.value, order); + } + + BOOST_FORCEINLINE value_type exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT + { + return !!operations::exchange(m_storage.value, static_cast< storage_type >(v), order); + } + + BOOST_FORCEINLINE bool compare_exchange_strong(value_type& expected, value_type desired, memory_order success_order, memory_order failure_order) volatile BOOST_NOEXCEPT + { + BOOST_ASSERT(failure_order != memory_order_release); + BOOST_ASSERT(failure_order != memory_order_acq_rel); + BOOST_ASSERT(cas_failure_order_must_not_be_stronger_than_success_order(success_order, failure_order)); + +#if defined(BOOST_ATOMIC_DETAIL_STORAGE_TYPE_MAY_ALIAS) + return operations::compare_exchange_strong(m_storage.value, reinterpret_cast< storage_type& >(expected), static_cast< storage_type >(desired), success_order, failure_order); +#else + storage_type old_value = static_cast< storage_type >(expected); + const bool res = operations::compare_exchange_strong(m_storage.value, old_value, static_cast< storage_type >(desired), success_order, failure_order); + expected = !!old_value; + return res; +#endif + } + + BOOST_FORCEINLINE bool compare_exchange_strong(value_type& expected, value_type desired, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT + { + return compare_exchange_strong(expected, desired, order, atomics::detail::deduce_failure_order(order)); + } + + BOOST_FORCEINLINE bool compare_exchange_weak(value_type& expected, value_type desired, memory_order success_order, memory_order failure_order) volatile BOOST_NOEXCEPT + { + BOOST_ASSERT(failure_order != memory_order_release); + BOOST_ASSERT(failure_order != memory_order_acq_rel); + BOOST_ASSERT(cas_failure_order_must_not_be_stronger_than_success_order(success_order, failure_order)); + +#if defined(BOOST_ATOMIC_DETAIL_STORAGE_TYPE_MAY_ALIAS) + return operations::compare_exchange_weak(m_storage.value, reinterpret_cast< storage_type& >(expected), static_cast< storage_type >(desired), success_order, failure_order); +#else + storage_type old_value = static_cast< storage_type >(expected); + const bool res = operations::compare_exchange_weak(m_storage.value, old_value, static_cast< storage_type >(desired), success_order, failure_order); + expected = !!old_value; + return res; +#endif + } + + BOOST_FORCEINLINE bool compare_exchange_weak(value_type& expected, value_type desired, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT + { + return compare_exchange_weak(expected, desired, order, atomics::detail::deduce_failure_order(order)); + } + + BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&)) + BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&)) +}; + + +//! Implementation for pointers to object types +template< typename T > +class base_atomic< T*, void* > +{ +public: + typedef T* value_type; + typedef std::ptrdiff_t difference_type; + +protected: + typedef atomics::detail::operations< storage_size_of< value_type >::value, false > operations; + typedef value_type value_arg_type; + +public: + typedef typename operations::storage_type storage_type; + +protected: + typename operations::aligned_storage_type m_storage; + +public: + BOOST_DEFAULTED_FUNCTION(base_atomic(), {}) + BOOST_FORCEINLINE explicit base_atomic(value_type const& v) BOOST_NOEXCEPT : m_storage(atomics::detail::bitwise_cast< storage_type >(v)) + { + } + + BOOST_FORCEINLINE void store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT + { + BOOST_ASSERT(order != memory_order_consume); + BOOST_ASSERT(order != memory_order_acquire); + BOOST_ASSERT(order != memory_order_acq_rel); + + operations::store(m_storage.value, atomics::detail::bitwise_cast< storage_type >(v), order); + } + + BOOST_FORCEINLINE value_type load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT + { + BOOST_ASSERT(order != memory_order_release); + BOOST_ASSERT(order != memory_order_acq_rel); + + return atomics::detail::bitwise_cast< value_type >(operations::load(m_storage.value, order)); + } + + BOOST_FORCEINLINE value_type fetch_add(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT + { + return atomics::detail::bitwise_cast< value_type >(operations::fetch_add(m_storage.value, static_cast< storage_type >(v * sizeof(T)), order)); + } + + BOOST_FORCEINLINE value_type fetch_sub(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT + { + return atomics::detail::bitwise_cast< value_type >(operations::fetch_sub(m_storage.value, static_cast< storage_type >(v * sizeof(T)), order)); + } + + BOOST_FORCEINLINE value_type exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT + { + return atomics::detail::bitwise_cast< value_type >(operations::exchange(m_storage.value, atomics::detail::bitwise_cast< storage_type >(v), order)); + } + + BOOST_FORCEINLINE bool compare_exchange_strong(value_type& expected, value_type desired, memory_order success_order, memory_order failure_order) volatile BOOST_NOEXCEPT + { + BOOST_ASSERT(failure_order != memory_order_release); + BOOST_ASSERT(failure_order != memory_order_acq_rel); + BOOST_ASSERT(cas_failure_order_must_not_be_stronger_than_success_order(success_order, failure_order)); + +#if defined(BOOST_ATOMIC_DETAIL_STORAGE_TYPE_MAY_ALIAS) + return operations::compare_exchange_strong(m_storage.value, reinterpret_cast< storage_type& >(expected), atomics::detail::bitwise_cast< storage_type >(desired), success_order, failure_order); +#else + storage_type old_value = atomics::detail::bitwise_cast< storage_type >(expected); + const bool res = operations::compare_exchange_strong(m_storage.value, old_value, atomics::detail::bitwise_cast< storage_type >(desired), success_order, failure_order); + expected = atomics::detail::bitwise_cast< value_type >(old_value); + return res; +#endif + } + + BOOST_FORCEINLINE bool compare_exchange_strong(value_type& expected, value_type desired, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT + { + return compare_exchange_strong(expected, desired, order, atomics::detail::deduce_failure_order(order)); + } + + BOOST_FORCEINLINE bool compare_exchange_weak(value_type& expected, value_type desired, memory_order success_order, memory_order failure_order) volatile BOOST_NOEXCEPT + { + BOOST_ASSERT(failure_order != memory_order_release); + BOOST_ASSERT(failure_order != memory_order_acq_rel); + BOOST_ASSERT(cas_failure_order_must_not_be_stronger_than_success_order(success_order, failure_order)); + +#if defined(BOOST_ATOMIC_DETAIL_STORAGE_TYPE_MAY_ALIAS) + return operations::compare_exchange_weak(m_storage.value, reinterpret_cast< storage_type& >(expected), atomics::detail::bitwise_cast< storage_type >(desired), success_order, failure_order); +#else + storage_type old_value = atomics::detail::bitwise_cast< storage_type >(expected); + const bool res = operations::compare_exchange_weak(m_storage.value, old_value, atomics::detail::bitwise_cast< storage_type >(desired), success_order, failure_order); + expected = atomics::detail::bitwise_cast< value_type >(old_value); + return res; +#endif + } + + BOOST_FORCEINLINE bool compare_exchange_weak(value_type& expected, value_type desired, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT + { + return compare_exchange_weak(expected, desired, order, atomics::detail::deduce_failure_order(order)); + } + + BOOST_FORCEINLINE value_type operator++(int) volatile BOOST_NOEXCEPT + { + return fetch_add(1); + } + + BOOST_FORCEINLINE value_type operator++() volatile BOOST_NOEXCEPT + { + return fetch_add(1) + 1; + } + + BOOST_FORCEINLINE value_type operator--(int) volatile BOOST_NOEXCEPT + { + return fetch_sub(1); + } + + BOOST_FORCEINLINE value_type operator--() volatile BOOST_NOEXCEPT + { + return fetch_sub(1) - 1; + } + + BOOST_FORCEINLINE value_type operator+=(difference_type v) volatile BOOST_NOEXCEPT + { + return fetch_add(v) + v; + } + + BOOST_FORCEINLINE value_type operator-=(difference_type v) volatile BOOST_NOEXCEPT + { + return fetch_sub(v) - v; + } + + BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&)) + BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&)) +}; + +} // namespace detail + +template< typename T > +class atomic : + public atomics::detail::base_atomic< T, typename atomics::detail::classify< T >::type > +{ +private: + typedef atomics::detail::base_atomic< T, typename atomics::detail::classify< T >::type > base_type; + typedef typename base_type::value_arg_type value_arg_type; + +public: + typedef typename base_type::value_type value_type; + typedef typename base_type::storage_type storage_type; + +public: + static BOOST_CONSTEXPR_OR_CONST bool is_always_lock_free = base_type::operations::is_always_lock_free; + +public: + BOOST_DEFAULTED_FUNCTION(atomic(), BOOST_NOEXCEPT {}) + + // NOTE: The constructor is made explicit because gcc 4.7 complains that + // operator=(value_arg_type) is considered ambiguous with operator=(atomic const&) + // in assignment expressions, even though conversion to atomic<> is less preferred + // than conversion to value_arg_type. + BOOST_FORCEINLINE explicit BOOST_CONSTEXPR atomic(value_arg_type v) BOOST_NOEXCEPT : base_type(v) {} + + BOOST_FORCEINLINE value_type operator= (value_arg_type v) volatile BOOST_NOEXCEPT + { + this->store(v); + return v; + } + + BOOST_FORCEINLINE operator value_type() const volatile BOOST_NOEXCEPT + { + return this->load(); + } + + BOOST_FORCEINLINE bool is_lock_free() const volatile BOOST_NOEXCEPT + { + // C++17 requires all instances of atomic<> return a value consistent with is_always_lock_free here + return is_always_lock_free; + } + + BOOST_FORCEINLINE storage_type& storage() BOOST_NOEXCEPT { return this->m_storage.value; } + BOOST_FORCEINLINE storage_type volatile& storage() volatile BOOST_NOEXCEPT { return this->m_storage.value; } + BOOST_FORCEINLINE storage_type const& storage() const BOOST_NOEXCEPT { return this->m_storage.value; } + BOOST_FORCEINLINE storage_type const volatile& storage() const volatile BOOST_NOEXCEPT { return this->m_storage.value; } + + BOOST_DELETED_FUNCTION(atomic(atomic const&)) + BOOST_DELETED_FUNCTION(atomic& operator= (atomic const&)) + BOOST_DELETED_FUNCTION(atomic& operator= (atomic const&) volatile) +}; + +template< typename T > +BOOST_CONSTEXPR_OR_CONST bool atomic< T >::is_always_lock_free; + +typedef atomic< char > atomic_char; +typedef atomic< unsigned char > atomic_uchar; +typedef atomic< signed char > atomic_schar; +typedef atomic< uint8_t > atomic_uint8_t; +typedef atomic< int8_t > atomic_int8_t; +typedef atomic< unsigned short > atomic_ushort; +typedef atomic< short > atomic_short; +typedef atomic< uint16_t > atomic_uint16_t; +typedef atomic< int16_t > atomic_int16_t; +typedef atomic< unsigned int > atomic_uint; +typedef atomic< int > atomic_int; +typedef atomic< uint32_t > atomic_uint32_t; +typedef atomic< int32_t > atomic_int32_t; +typedef atomic< unsigned long > atomic_ulong; +typedef atomic< long > atomic_long; +typedef atomic< uint64_t > atomic_uint64_t; +typedef atomic< int64_t > atomic_int64_t; +#ifdef BOOST_HAS_LONG_LONG +typedef atomic< boost::ulong_long_type > atomic_ullong; +typedef atomic< boost::long_long_type > atomic_llong; +#endif +typedef atomic< void* > atomic_address; +typedef atomic< bool > atomic_bool; +typedef atomic< wchar_t > atomic_wchar_t; +#if !defined(BOOST_NO_CXX11_CHAR16_T) +typedef atomic< char16_t > atomic_char16_t; +#endif +#if !defined(BOOST_NO_CXX11_CHAR32_T) +typedef atomic< char32_t > atomic_char32_t; +#endif + +typedef atomic< int_least8_t > atomic_int_least8_t; +typedef atomic< uint_least8_t > atomic_uint_least8_t; +typedef atomic< int_least16_t > atomic_int_least16_t; +typedef atomic< uint_least16_t > atomic_uint_least16_t; +typedef atomic< int_least32_t > atomic_int_least32_t; +typedef atomic< uint_least32_t > atomic_uint_least32_t; +typedef atomic< int_least64_t > atomic_int_least64_t; +typedef atomic< uint_least64_t > atomic_uint_least64_t; +typedef atomic< int_fast8_t > atomic_int_fast8_t; +typedef atomic< uint_fast8_t > atomic_uint_fast8_t; +typedef atomic< int_fast16_t > atomic_int_fast16_t; +typedef atomic< uint_fast16_t > atomic_uint_fast16_t; +typedef atomic< int_fast32_t > atomic_int_fast32_t; +typedef atomic< uint_fast32_t > atomic_uint_fast32_t; +typedef atomic< int_fast64_t > atomic_int_fast64_t; +typedef atomic< uint_fast64_t > atomic_uint_fast64_t; +typedef atomic< intmax_t > atomic_intmax_t; +typedef atomic< uintmax_t > atomic_uintmax_t; + +typedef atomic< std::size_t > atomic_size_t; +typedef atomic< std::ptrdiff_t > atomic_ptrdiff_t; + +#if defined(BOOST_HAS_INTPTR_T) +typedef atomic< intptr_t > atomic_intptr_t; +typedef atomic< uintptr_t > atomic_uintptr_t; +#endif + +} // namespace atomics +} // namespace boost + +#if defined(BOOST_MSVC) +#pragma warning(pop) +#endif + +#endif // BOOST_ATOMIC_DETAIL_ATOMIC_TEMPLATE_HPP_INCLUDED_ diff --git a/libs/boost/include/boost/atomic/detail/bitwise_cast.hpp b/libs/boost/include/boost/atomic/detail/bitwise_cast.hpp new file mode 100644 index 0000000..4a285ec --- /dev/null +++ b/libs/boost/include/boost/atomic/detail/bitwise_cast.hpp @@ -0,0 +1,74 @@ +/* + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or copy at + * http://www.boost.org/LICENSE_1_0.txt) + * + * Copyright (c) 2009 Helge Bahmann + * Copyright (c) 2012 Tim Blechmann + * Copyright (c) 2013 - 2014 Andrey Semashev + */ +/*! + * \file atomic/detail/bitwise_cast.hpp + * + * This header defines \c bitwise_cast used to convert between storage and value types + */ + +#ifndef BOOST_ATOMIC_DETAIL_BITWISE_CAST_HPP_INCLUDED_ +#define BOOST_ATOMIC_DETAIL_BITWISE_CAST_HPP_INCLUDED_ + +#include +#if !defined(BOOST_ATOMIC_DETAIL_HAS_BUILTIN_MEMCPY) +#include +#endif + +#ifdef BOOST_HAS_PRAGMA_ONCE +#pragma once +#endif + +#if defined(BOOST_GCC) && (BOOST_GCC+0) >= 40600 +#pragma GCC diagnostic push +// missing initializer for member var +#pragma GCC diagnostic ignored "-Wmissing-field-initializers" +#endif + +namespace boost { +namespace atomics { +namespace detail { + +template< typename T > +BOOST_FORCEINLINE T* addressof(T& value) BOOST_NOEXCEPT +{ + // Note: The point of using a local struct as the intermediate type instead of char is to avoid gcc warnings + // if T is a const volatile char*: + // warning: casting 'const volatile char* const' to 'const volatile char&' does not dereference pointer + // The local struct makes sure T is not related to the cast target type. + struct opaque_type; + return reinterpret_cast< T* >(&const_cast< opaque_type& >(reinterpret_cast< const volatile opaque_type& >(value))); +} + +template< typename To, typename From > +BOOST_FORCEINLINE To bitwise_cast(From const& from) BOOST_NOEXCEPT +{ + struct + { + To to; + } + value = {}; + BOOST_ATOMIC_DETAIL_MEMCPY + ( + atomics::detail::addressof(value.to), + atomics::detail::addressof(from), + (sizeof(From) < sizeof(To) ? sizeof(From) : sizeof(To)) + ); + return value.to; +} + +} // namespace detail +} // namespace atomics +} // namespace boost + +#if defined(BOOST_GCC) && (BOOST_GCC+0) >= 40600 +#pragma GCC diagnostic pop +#endif + +#endif // BOOST_ATOMIC_DETAIL_BITWISE_CAST_HPP_INCLUDED_ diff --git a/libs/boost/include/boost/atomic/detail/caps_gcc_alpha.hpp b/libs/boost/include/boost/atomic/detail/caps_gcc_alpha.hpp new file mode 100644 index 0000000..861432f --- /dev/null +++ b/libs/boost/include/boost/atomic/detail/caps_gcc_alpha.hpp @@ -0,0 +1,34 @@ +/* + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or copy at + * http://www.boost.org/LICENSE_1_0.txt) + * + * Copyright (c) 2009 Helge Bahmann + * Copyright (c) 2013 Tim Blechmann + * Copyright (c) 2014 Andrey Semashev + */ +/*! + * \file atomic/detail/caps_gcc_alpha.hpp + * + * This header defines feature capabilities macros + */ + +#ifndef BOOST_ATOMIC_DETAIL_CAPS_GCC_ALPHA_HPP_INCLUDED_ +#define BOOST_ATOMIC_DETAIL_CAPS_GCC_ALPHA_HPP_INCLUDED_ + +#include + +#ifdef BOOST_HAS_PRAGMA_ONCE +#pragma once +#endif + +#define BOOST_ATOMIC_INT8_LOCK_FREE 2 +#define BOOST_ATOMIC_INT16_LOCK_FREE 2 +#define BOOST_ATOMIC_INT32_LOCK_FREE 2 +#define BOOST_ATOMIC_INT64_LOCK_FREE 2 +#define BOOST_ATOMIC_POINTER_LOCK_FREE 2 + +#define BOOST_ATOMIC_THREAD_FENCE 2 +#define BOOST_ATOMIC_SIGNAL_FENCE 2 + +#endif // BOOST_ATOMIC_DETAIL_CAPS_GCC_ALPHA_HPP_INCLUDED_ diff --git a/libs/boost/include/boost/atomic/detail/caps_gcc_arm.hpp b/libs/boost/include/boost/atomic/detail/caps_gcc_arm.hpp new file mode 100644 index 0000000..b827c64 --- /dev/null +++ b/libs/boost/include/boost/atomic/detail/caps_gcc_arm.hpp @@ -0,0 +1,56 @@ +/* + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or copy at + * http://www.boost.org/LICENSE_1_0.txt) + * + * Copyright (c) 2009 Helge Bahmann + * Copyright (c) 2009 Phil Endecott + * Copyright (c) 2013 Tim Blechmann + * ARM Code by Phil Endecott, based on other architectures. + * Copyright (c) 2014 Andrey Semashev + */ +/*! + * \file atomic/detail/caps_gcc_arm.hpp + * + * This header defines feature capabilities macros + */ + +#ifndef BOOST_ATOMIC_DETAIL_CAPS_GCC_ARM_HPP_INCLUDED_ +#define BOOST_ATOMIC_DETAIL_CAPS_GCC_ARM_HPP_INCLUDED_ + +#include + +#ifdef BOOST_HAS_PRAGMA_ONCE +#pragma once +#endif + +#if !(defined(__ARM_ARCH_6__) || defined(__ARM_ARCH_6J__) || defined(__ARM_ARCH_6Z__) || defined(__ARM_ARCH_6K__) || defined(__ARM_ARCH_6ZK__)) +// ARMv7 and later have dmb instruction +#define BOOST_ATOMIC_DETAIL_ARM_HAS_DMB 1 +#endif + +#if !(defined(__ARM_ARCH_6__) || defined(__ARM_ARCH_6J__) || defined(__ARM_ARCH_6Z__)) +// ARMv6k and ARMv7 have 8 and 16 ldrex/strex variants +#define BOOST_ATOMIC_DETAIL_ARM_HAS_LDREXB_STREXB 1 +#define BOOST_ATOMIC_DETAIL_ARM_HAS_LDREXH_STREXH 1 +#if !(((defined(__ARM_ARCH_6K__) || defined(__ARM_ARCH_6ZK__)) && defined(__thumb__)) || defined(__ARM_ARCH_7M__)) +// ARMv6k and ARMv7 except ARMv7-M have 64-bit ldrex/strex variants. +// Unfortunately, GCC (at least 4.7.3 on Ubuntu) does not allocate register pairs properly when targeting ARMv6k Thumb, +// which is required for ldrexd/strexd instructions, so we disable 64-bit support. When targeting ARMv6k ARM +// or ARMv7 (both ARM and Thumb 2) it works as expected. +#define BOOST_ATOMIC_DETAIL_ARM_HAS_LDREXD_STREXD 1 +#endif +#endif + +#define BOOST_ATOMIC_INT8_LOCK_FREE 2 +#define BOOST_ATOMIC_INT16_LOCK_FREE 2 +#define BOOST_ATOMIC_INT32_LOCK_FREE 2 +#if defined(BOOST_ATOMIC_DETAIL_ARM_HAS_LDREXD_STREXD) +#define BOOST_ATOMIC_INT64_LOCK_FREE 2 +#endif +#define BOOST_ATOMIC_POINTER_LOCK_FREE 2 + +#define BOOST_ATOMIC_THREAD_FENCE 2 +#define BOOST_ATOMIC_SIGNAL_FENCE 2 + +#endif // BOOST_ATOMIC_DETAIL_CAPS_GCC_ARM_HPP_INCLUDED_ diff --git a/libs/boost/include/boost/atomic/detail/caps_gcc_atomic.hpp b/libs/boost/include/boost/atomic/detail/caps_gcc_atomic.hpp new file mode 100644 index 0000000..f4e7a70 --- /dev/null +++ b/libs/boost/include/boost/atomic/detail/caps_gcc_atomic.hpp @@ -0,0 +1,134 @@ +/* + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or copy at + * http://www.boost.org/LICENSE_1_0.txt) + * + * Copyright (c) 2014 Andrey Semashev + */ +/*! + * \file atomic/detail/caps_gcc_atomic.hpp + * + * This header defines feature capabilities macros + */ + +#ifndef BOOST_ATOMIC_DETAIL_CAPS_GCC_ATOMIC_HPP_INCLUDED_ +#define BOOST_ATOMIC_DETAIL_CAPS_GCC_ATOMIC_HPP_INCLUDED_ + +#include +#include + +#ifdef BOOST_HAS_PRAGMA_ONCE +#pragma once +#endif + +#if defined(__i386__) && defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8) +#define BOOST_ATOMIC_DETAIL_X86_HAS_CMPXCHG8B 1 +#endif + +#if defined(__x86_64__) && defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_16) +#define BOOST_ATOMIC_DETAIL_X86_HAS_CMPXCHG16B 1 +#endif + +#if defined(BOOST_ATOMIC_DETAIL_X86_HAS_CMPXCHG16B) && (defined(BOOST_HAS_INT128) || !defined(BOOST_NO_ALIGNMENT)) +#define BOOST_ATOMIC_INT128_LOCK_FREE 2 +#else +#define BOOST_ATOMIC_INT128_LOCK_FREE 0 +#endif + +#if __GCC_ATOMIC_LLONG_LOCK_FREE == 2 +#define BOOST_ATOMIC_LLONG_LOCK_FREE 2 +#else +#define BOOST_ATOMIC_LLONG_LOCK_FREE BOOST_ATOMIC_INT128_LOCK_FREE +#endif + +#if __GCC_ATOMIC_LONG_LOCK_FREE == 2 +#define BOOST_ATOMIC_LONG_LOCK_FREE 2 +#else +#define BOOST_ATOMIC_LONG_LOCK_FREE BOOST_ATOMIC_LLONG_LOCK_FREE +#endif + +#if __GCC_ATOMIC_INT_LOCK_FREE == 2 +#define BOOST_ATOMIC_INT_LOCK_FREE 2 +#else +#define BOOST_ATOMIC_INT_LOCK_FREE BOOST_ATOMIC_LONG_LOCK_FREE +#endif + +#if __GCC_ATOMIC_SHORT_LOCK_FREE == 2 +#define BOOST_ATOMIC_SHORT_LOCK_FREE 2 +#else +#define BOOST_ATOMIC_SHORT_LOCK_FREE BOOST_ATOMIC_INT_LOCK_FREE +#endif + +#if __GCC_ATOMIC_CHAR_LOCK_FREE == 2 +#define BOOST_ATOMIC_CHAR_LOCK_FREE 2 +#else +#define BOOST_ATOMIC_CHAR_LOCK_FREE BOOST_ATOMIC_SHORT_LOCK_FREE +#endif + +#if __GCC_ATOMIC_POINTER_LOCK_FREE == 2 +#define BOOST_ATOMIC_POINTER_LOCK_FREE 2 +#else +#define BOOST_ATOMIC_POINTER_LOCK_FREE 0 +#endif + + +#define BOOST_ATOMIC_INT8_LOCK_FREE BOOST_ATOMIC_CHAR_LOCK_FREE + +#if BOOST_ATOMIC_DETAIL_SIZEOF_SHORT == 2 +#define BOOST_ATOMIC_INT16_LOCK_FREE BOOST_ATOMIC_SHORT_LOCK_FREE +#elif BOOST_ATOMIC_DETAIL_SIZEOF_INT == 2 +#define BOOST_ATOMIC_INT16_LOCK_FREE BOOST_ATOMIC_INT_LOCK_FREE +#elif BOOST_ATOMIC_DETAIL_SIZEOF_LONG == 2 +#define BOOST_ATOMIC_INT16_LOCK_FREE BOOST_ATOMIC_LONG_LOCK_FREE +#elif BOOST_ATOMIC_DETAIL_SIZEOF_LLONG == 2 +#define BOOST_ATOMIC_INT16_LOCK_FREE BOOST_ATOMIC_LLONG_LOCK_FREE +#else +#define BOOST_ATOMIC_INT16_LOCK_FREE 0 +#endif + +#if BOOST_ATOMIC_DETAIL_SIZEOF_SHORT == 4 +#define BOOST_ATOMIC_INT32_LOCK_FREE BOOST_ATOMIC_SHORT_LOCK_FREE +#elif BOOST_ATOMIC_DETAIL_SIZEOF_INT == 4 +#define BOOST_ATOMIC_INT32_LOCK_FREE BOOST_ATOMIC_INT_LOCK_FREE +#elif BOOST_ATOMIC_DETAIL_SIZEOF_LONG == 4 +#define BOOST_ATOMIC_INT32_LOCK_FREE BOOST_ATOMIC_LONG_LOCK_FREE +#elif BOOST_ATOMIC_DETAIL_SIZEOF_LLONG == 4 +#define BOOST_ATOMIC_INT32_LOCK_FREE BOOST_ATOMIC_LLONG_LOCK_FREE +#else +#define BOOST_ATOMIC_INT32_LOCK_FREE 0 +#endif + +#if BOOST_ATOMIC_DETAIL_SIZEOF_SHORT == 8 +#define BOOST_ATOMIC_INT64_LOCK_FREE BOOST_ATOMIC_SHORT_LOCK_FREE +#elif BOOST_ATOMIC_DETAIL_SIZEOF_INT == 8 +#define BOOST_ATOMIC_INT64_LOCK_FREE BOOST_ATOMIC_INT_LOCK_FREE +#elif BOOST_ATOMIC_DETAIL_SIZEOF_LONG == 8 +#define BOOST_ATOMIC_INT64_LOCK_FREE BOOST_ATOMIC_LONG_LOCK_FREE +#elif BOOST_ATOMIC_DETAIL_SIZEOF_LLONG == 8 +#define BOOST_ATOMIC_INT64_LOCK_FREE BOOST_ATOMIC_LLONG_LOCK_FREE +#else +#define BOOST_ATOMIC_INT64_LOCK_FREE 0 +#endif + + +#if __GCC_ATOMIC_WCHAR_T_LOCK_FREE == 2 +#define BOOST_ATOMIC_WCHAR_T_LOCK_FREE 2 +#elif BOOST_ATOMIC_DETAIL_SIZEOF_WCHAR_T == 8 +#define BOOST_ATOMIC_WCHAR_T_LOCK_FREE BOOST_ATOMIC_INT64_LOCK_FREE +#elif BOOST_ATOMIC_DETAIL_SIZEOF_WCHAR_T == 4 +#define BOOST_ATOMIC_WCHAR_T_LOCK_FREE BOOST_ATOMIC_INT32_LOCK_FREE +#elif BOOST_ATOMIC_DETAIL_SIZEOF_WCHAR_T == 2 +#define BOOST_ATOMIC_WCHAR_T_LOCK_FREE BOOST_ATOMIC_INT16_LOCK_FREE +#elif BOOST_ATOMIC_DETAIL_SIZEOF_WCHAR_T == 1 +#define BOOST_ATOMIC_WCHAR_T_LOCK_FREE BOOST_ATOMIC_INT8_LOCK_FREE +#else +#define BOOST_ATOMIC_WCHAR_T_LOCK_FREE 0 +#endif + +#define BOOST_ATOMIC_CHAR32_T_LOCK_FREE BOOST_ATOMIC_INT32_LOCK_FREE +#define BOOST_ATOMIC_CHAR16_T_LOCK_FREE BOOST_ATOMIC_INT16_LOCK_FREE + +#define BOOST_ATOMIC_THREAD_FENCE 2 +#define BOOST_ATOMIC_SIGNAL_FENCE 2 + +#endif // BOOST_ATOMIC_DETAIL_CAPS_GCC_ATOMIC_HPP_INCLUDED_ diff --git a/libs/boost/include/boost/atomic/detail/caps_gcc_ppc.hpp b/libs/boost/include/boost/atomic/detail/caps_gcc_ppc.hpp new file mode 100644 index 0000000..ee23460 --- /dev/null +++ b/libs/boost/include/boost/atomic/detail/caps_gcc_ppc.hpp @@ -0,0 +1,36 @@ +/* + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or copy at + * http://www.boost.org/LICENSE_1_0.txt) + * + * Copyright (c) 2009 Helge Bahmann + * Copyright (c) 2013 Tim Blechmann + * Copyright (c) 2014 Andrey Semashev + */ +/*! + * \file atomic/detail/caps_gcc_ppc.hpp + * + * This header defines feature capabilities macros + */ + +#ifndef BOOST_ATOMIC_DETAIL_CAPS_GCC_PPC_HPP_INCLUDED_ +#define BOOST_ATOMIC_DETAIL_CAPS_GCC_PPC_HPP_INCLUDED_ + +#include + +#ifdef BOOST_HAS_PRAGMA_ONCE +#pragma once +#endif + +#define BOOST_ATOMIC_INT8_LOCK_FREE 2 +#define BOOST_ATOMIC_INT16_LOCK_FREE 2 +#define BOOST_ATOMIC_INT32_LOCK_FREE 2 +#if defined(__powerpc64__) || defined(__PPC64__) +#define BOOST_ATOMIC_INT64_LOCK_FREE 2 +#endif +#define BOOST_ATOMIC_POINTER_LOCK_FREE 2 + +#define BOOST_ATOMIC_THREAD_FENCE 2 +#define BOOST_ATOMIC_SIGNAL_FENCE 2 + +#endif // BOOST_ATOMIC_DETAIL_CAPS_GCC_PPC_HPP_INCLUDED_ diff --git a/libs/boost/include/boost/atomic/detail/caps_gcc_sparc.hpp b/libs/boost/include/boost/atomic/detail/caps_gcc_sparc.hpp new file mode 100644 index 0000000..5806684 --- /dev/null +++ b/libs/boost/include/boost/atomic/detail/caps_gcc_sparc.hpp @@ -0,0 +1,34 @@ +/* + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or copy at + * http://www.boost.org/LICENSE_1_0.txt) + * + * Copyright (c) 2010 Helge Bahmann + * Copyright (c) 2013 Tim Blechmann + * Copyright (c) 2014 Andrey Semashev + */ +/*! + * \file atomic/detail/caps_gcc_sparc.hpp + * + * This header defines feature capabilities macros + */ + +#ifndef BOOST_ATOMIC_DETAIL_CAPS_GCC_SPARC_HPP_INCLUDED_ +#define BOOST_ATOMIC_DETAIL_CAPS_GCC_SPARC_HPP_INCLUDED_ + +#include + +#ifdef BOOST_HAS_PRAGMA_ONCE +#pragma once +#endif + +#define BOOST_ATOMIC_INT8_LOCK_FREE 2 +#define BOOST_ATOMIC_INT16_LOCK_FREE 2 +#define BOOST_ATOMIC_INT32_LOCK_FREE 2 +#define BOOST_ATOMIC_INT64_LOCK_FREE 2 +#define BOOST_ATOMIC_POINTER_LOCK_FREE 2 + +#define BOOST_ATOMIC_THREAD_FENCE 2 +#define BOOST_ATOMIC_SIGNAL_FENCE 2 + +#endif // BOOST_ATOMIC_DETAIL_CAPS_GCC_SPARC_HPP_INCLUDED_ diff --git a/libs/boost/include/boost/atomic/detail/caps_gcc_sync.hpp b/libs/boost/include/boost/atomic/detail/caps_gcc_sync.hpp new file mode 100644 index 0000000..7fac07a --- /dev/null +++ b/libs/boost/include/boost/atomic/detail/caps_gcc_sync.hpp @@ -0,0 +1,62 @@ +/* + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or copy at + * http://www.boost.org/LICENSE_1_0.txt) + * + * Copyright (c) 2011 Helge Bahmann + * Copyright (c) 2013 Tim Blechmann + * Copyright (c) 2014 Andrey Semashev + */ +/*! + * \file atomic/detail/caps_gcc_sync.hpp + * + * This header defines feature capabilities macros + */ + +#ifndef BOOST_ATOMIC_DETAIL_CAPS_GCC_SYNC_HPP_INCLUDED_ +#define BOOST_ATOMIC_DETAIL_CAPS_GCC_SYNC_HPP_INCLUDED_ + +#include + +#ifdef BOOST_HAS_PRAGMA_ONCE +#pragma once +#endif + +#if defined(__i386__) && defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8) +#define BOOST_ATOMIC_DETAIL_X86_HAS_CMPXCHG8B 1 +#endif + +#if defined(__x86_64__) && defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_16) +#define BOOST_ATOMIC_DETAIL_X86_HAS_CMPXCHG16B 1 +#endif + +#if defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1)\ + || defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2)\ + || defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4)\ + || defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8)\ + || defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_16) +#define BOOST_ATOMIC_INT8_LOCK_FREE 2 +#endif +#if defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2)\ + || defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4)\ + || defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8)\ + || defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_16) +#define BOOST_ATOMIC_INT16_LOCK_FREE 2 +#endif +#if defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4)\ + || defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8)\ + || defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_16) +#define BOOST_ATOMIC_INT32_LOCK_FREE 2 +#endif +#if defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8)\ + || defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_16) +#define BOOST_ATOMIC_INT64_LOCK_FREE 2 +#endif +#if defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_16) +#define BOOST_ATOMIC_INT128_LOCK_FREE 2 +#endif + +#define BOOST_ATOMIC_THREAD_FENCE 2 +#define BOOST_ATOMIC_SIGNAL_FENCE 2 + +#endif // BOOST_ATOMIC_DETAIL_CAPS_GCC_SYNC_HPP_INCLUDED_ diff --git a/libs/boost/include/boost/atomic/detail/caps_gcc_x86.hpp b/libs/boost/include/boost/atomic/detail/caps_gcc_x86.hpp new file mode 100644 index 0000000..7485b01 --- /dev/null +++ b/libs/boost/include/boost/atomic/detail/caps_gcc_x86.hpp @@ -0,0 +1,75 @@ +/* + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or copy at + * http://www.boost.org/LICENSE_1_0.txt) + * + * Copyright (c) 2009 Helge Bahmann + * Copyright (c) 2012 Tim Blechmann + * Copyright (c) 2013 - 2014 Andrey Semashev + */ +/*! + * \file atomic/detail/caps_gcc_x86.hpp + * + * This header defines feature capabilities macros + */ + +#ifndef BOOST_ATOMIC_DETAIL_CAPS_GCC_X86_HPP_INCLUDED_ +#define BOOST_ATOMIC_DETAIL_CAPS_GCC_X86_HPP_INCLUDED_ + +#include + +#ifdef BOOST_HAS_PRAGMA_ONCE +#pragma once +#endif + +#if defined(__GNUC__) + +#if defined(__i386__) &&\ + (\ + defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8) ||\ + defined(__i586__) || defined(__i686__) || defined(__pentium4__) || defined(__nocona__) || defined(__core2__) || defined(__corei7__) ||\ + defined(__k6__) || defined(__athlon__) || defined(__k8__) || defined(__amdfam10__) || defined(__bdver1__) || defined(__bdver2__) || defined(__bdver3__) || defined(__btver1__) || defined(__btver2__)\ + ) +#define BOOST_ATOMIC_DETAIL_X86_HAS_CMPXCHG8B 1 +#endif + +#if defined(__x86_64__) && defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_16) +#define BOOST_ATOMIC_DETAIL_X86_HAS_CMPXCHG16B 1 +#endif + +#if defined(__x86_64__) || defined(__SSE2__) +// Use mfence only if SSE2 is available +#define BOOST_ATOMIC_DETAIL_X86_HAS_MFENCE 1 +#endif + +#else // defined(__GNUC__) + +#if defined(__i386__) && !defined(BOOST_ATOMIC_NO_CMPXCHG8B) +#define BOOST_ATOMIC_DETAIL_X86_HAS_CMPXCHG8B 1 +#endif + +#if defined(__x86_64__) && !defined(BOOST_ATOMIC_NO_CMPXCHG16B) +#define BOOST_ATOMIC_DETAIL_X86_HAS_CMPXCHG16B 1 +#endif + +#if !defined(BOOST_ATOMIC_NO_MFENCE) +#define BOOST_ATOMIC_DETAIL_X86_HAS_MFENCE 1 +#endif + +#endif // defined(__GNUC__) + +#define BOOST_ATOMIC_INT8_LOCK_FREE 2 +#define BOOST_ATOMIC_INT16_LOCK_FREE 2 +#define BOOST_ATOMIC_INT32_LOCK_FREE 2 +#if defined(__x86_64__) || defined(BOOST_ATOMIC_DETAIL_X86_HAS_CMPXCHG8B) +#define BOOST_ATOMIC_INT64_LOCK_FREE 2 +#endif +#if defined(BOOST_ATOMIC_DETAIL_X86_HAS_CMPXCHG16B) && (defined(BOOST_HAS_INT128) || !defined(BOOST_NO_ALIGNMENT)) +#define BOOST_ATOMIC_INT128_LOCK_FREE 2 +#endif +#define BOOST_ATOMIC_POINTER_LOCK_FREE 2 + +#define BOOST_ATOMIC_THREAD_FENCE 2 +#define BOOST_ATOMIC_SIGNAL_FENCE 2 + +#endif // BOOST_ATOMIC_DETAIL_CAPS_GCC_X86_HPP_INCLUDED_ diff --git a/libs/boost/include/boost/atomic/detail/caps_linux_arm.hpp b/libs/boost/include/boost/atomic/detail/caps_linux_arm.hpp new file mode 100644 index 0000000..abe6fb8 --- /dev/null +++ b/libs/boost/include/boost/atomic/detail/caps_linux_arm.hpp @@ -0,0 +1,35 @@ +/* + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or copy at + * http://www.boost.org/LICENSE_1_0.txt) + * + * Copyright (c) 2009, 2011 Helge Bahmann + * Copyright (c) 2009 Phil Endecott + * Copyright (c) 2013 Tim Blechmann + * Linux-specific code by Phil Endecott + * Copyright (c) 2014 Andrey Semashev + */ +/*! + * \file atomic/detail/caps_linux_arm.hpp + * + * This header defines feature capabilities macros + */ + +#ifndef BOOST_ATOMIC_DETAIL_CAPS_LINUX_ARM_HPP_INCLUDED_ +#define BOOST_ATOMIC_DETAIL_CAPS_LINUX_ARM_HPP_INCLUDED_ + +#include + +#ifdef BOOST_HAS_PRAGMA_ONCE +#pragma once +#endif + +#define BOOST_ATOMIC_INT8_LOCK_FREE 2 +#define BOOST_ATOMIC_INT16_LOCK_FREE 2 +#define BOOST_ATOMIC_INT32_LOCK_FREE 2 +#define BOOST_ATOMIC_POINTER_LOCK_FREE 2 + +#define BOOST_ATOMIC_THREAD_FENCE 2 +#define BOOST_ATOMIC_SIGNAL_FENCE 2 + +#endif // BOOST_ATOMIC_DETAIL_CAPS_LINUX_ARM_HPP_INCLUDED_ diff --git a/libs/boost/include/boost/atomic/detail/caps_msvc_arm.hpp b/libs/boost/include/boost/atomic/detail/caps_msvc_arm.hpp new file mode 100644 index 0000000..6b3c61f --- /dev/null +++ b/libs/boost/include/boost/atomic/detail/caps_msvc_arm.hpp @@ -0,0 +1,34 @@ +/* + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or copy at + * http://www.boost.org/LICENSE_1_0.txt) + * + * Copyright (c) 2009 Helge Bahmann + * Copyright (c) 2013 Tim Blechmann + * Copyright (c) 2012 - 2014 Andrey Semashev + */ +/*! + * \file atomic/detail/caps_msvc_arm.hpp + * + * This header defines feature capabilities macros + */ + +#ifndef BOOST_ATOMIC_DETAIL_CAPS_MSVC_ARM_HPP_INCLUDED_ +#define BOOST_ATOMIC_DETAIL_CAPS_MSVC_ARM_HPP_INCLUDED_ + +#include + +#ifdef BOOST_HAS_PRAGMA_ONCE +#pragma once +#endif + +#define BOOST_ATOMIC_INT8_LOCK_FREE 2 +#define BOOST_ATOMIC_INT16_LOCK_FREE 2 +#define BOOST_ATOMIC_INT32_LOCK_FREE 2 +#define BOOST_ATOMIC_INT64_LOCK_FREE 2 +#define BOOST_ATOMIC_POINTER_LOCK_FREE 2 + +#define BOOST_ATOMIC_THREAD_FENCE 2 +#define BOOST_ATOMIC_SIGNAL_FENCE 2 + +#endif // BOOST_ATOMIC_DETAIL_CAPS_MSVC_ARM_HPP_INCLUDED_ diff --git a/libs/boost/include/boost/atomic/detail/caps_msvc_x86.hpp b/libs/boost/include/boost/atomic/detail/caps_msvc_x86.hpp new file mode 100644 index 0000000..2ee4c92 --- /dev/null +++ b/libs/boost/include/boost/atomic/detail/caps_msvc_x86.hpp @@ -0,0 +1,55 @@ +/* + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or copy at + * http://www.boost.org/LICENSE_1_0.txt) + * + * Copyright (c) 2009 Helge Bahmann + * Copyright (c) 2013 Tim Blechmann + * Copyright (c) 2012 - 2014 Andrey Semashev + */ +/*! + * \file atomic/detail/caps_msvc_x86.hpp + * + * This header defines feature capabilities macros + */ + +#ifndef BOOST_ATOMIC_DETAIL_CAPS_MSVC_X86_HPP_INCLUDED_ +#define BOOST_ATOMIC_DETAIL_CAPS_MSVC_X86_HPP_INCLUDED_ + +#include + +#ifdef BOOST_HAS_PRAGMA_ONCE +#pragma once +#endif + +#if defined(_M_IX86) && _M_IX86 >= 500 +#define BOOST_ATOMIC_DETAIL_X86_HAS_CMPXCHG8B 1 +#endif + +#if _MSC_VER >= 1500 && defined(_M_AMD64) && !defined(BOOST_ATOMIC_NO_CMPXCHG16B) +#define BOOST_ATOMIC_DETAIL_X86_HAS_CMPXCHG16B 1 +#endif + +#if defined(_MSC_VER) && (defined(_M_AMD64) || (defined(_M_IX86) && defined(_M_IX86_FP) && _M_IX86_FP >= 2)) +// Use mfence only if SSE2 is available +#define BOOST_ATOMIC_DETAIL_X86_HAS_MFENCE 1 +#endif + +#define BOOST_ATOMIC_INT8_LOCK_FREE 2 +#define BOOST_ATOMIC_INT16_LOCK_FREE 2 +#define BOOST_ATOMIC_INT32_LOCK_FREE 2 + +#if defined(_M_AMD64) || defined(BOOST_ATOMIC_DETAIL_X86_HAS_CMPXCHG8B) +#define BOOST_ATOMIC_INT64_LOCK_FREE 2 +#endif + +#if defined(BOOST_ATOMIC_DETAIL_X86_HAS_CMPXCHG16B) && (defined(BOOST_HAS_INT128) || !defined(BOOST_NO_ALIGNMENT)) +#define BOOST_ATOMIC_INT128_LOCK_FREE 2 +#endif + +#define BOOST_ATOMIC_POINTER_LOCK_FREE 2 + +#define BOOST_ATOMIC_THREAD_FENCE 2 +#define BOOST_ATOMIC_SIGNAL_FENCE 2 + +#endif // BOOST_ATOMIC_DETAIL_CAPS_MSVC_X86_HPP_INCLUDED_ diff --git a/libs/boost/include/boost/atomic/detail/caps_windows.hpp b/libs/boost/include/boost/atomic/detail/caps_windows.hpp new file mode 100644 index 0000000..1cc0ded --- /dev/null +++ b/libs/boost/include/boost/atomic/detail/caps_windows.hpp @@ -0,0 +1,33 @@ +/* + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or copy at + * http://www.boost.org/LICENSE_1_0.txt) + * + * Copyright (c) 2009 Helge Bahmann + * Copyright (c) 2013 Tim Blechmann + * Copyright (c) 2012 - 2014 Andrey Semashev + */ +/*! + * \file atomic/detail/caps_windows.hpp + * + * This header defines feature capabilities macros + */ + +#ifndef BOOST_ATOMIC_DETAIL_CAPS_WINDOWS_HPP_INCLUDED_ +#define BOOST_ATOMIC_DETAIL_CAPS_WINDOWS_HPP_INCLUDED_ + +#include + +#ifdef BOOST_HAS_PRAGMA_ONCE +#pragma once +#endif + +#define BOOST_ATOMIC_INT8_LOCK_FREE 2 +#define BOOST_ATOMIC_INT16_LOCK_FREE 2 +#define BOOST_ATOMIC_INT32_LOCK_FREE 2 +#define BOOST_ATOMIC_POINTER_LOCK_FREE 2 + +#define BOOST_ATOMIC_THREAD_FENCE 2 +#define BOOST_ATOMIC_SIGNAL_FENCE 2 + +#endif // BOOST_ATOMIC_DETAIL_CAPS_WINDOWS_HPP_INCLUDED_ diff --git a/libs/boost/include/boost/atomic/detail/config.hpp b/libs/boost/include/boost/atomic/detail/config.hpp new file mode 100644 index 0000000..7a43e23 --- /dev/null +++ b/libs/boost/include/boost/atomic/detail/config.hpp @@ -0,0 +1,102 @@ +/* + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or copy at + * http://www.boost.org/LICENSE_1_0.txt) + * + * Copyright (c) 2012 Hartmut Kaiser + * Copyright (c) 2014 Andrey Semashev + */ +/*! + * \file atomic/detail/config.hpp + * + * This header defines configuraion macros for Boost.Atomic + */ + +#ifndef BOOST_ATOMIC_DETAIL_CONFIG_HPP_INCLUDED_ +#define BOOST_ATOMIC_DETAIL_CONFIG_HPP_INCLUDED_ + +#include + +#ifdef BOOST_HAS_PRAGMA_ONCE +#pragma once +#endif + +#if defined(__has_builtin) +#if __has_builtin(__builtin_memcpy) +#define BOOST_ATOMIC_DETAIL_HAS_BUILTIN_MEMCPY +#endif +#if __has_builtin(__builtin_memcmp) +#define BOOST_ATOMIC_DETAIL_HAS_BUILTIN_MEMCMP +#endif +#elif defined(BOOST_GCC) +#define BOOST_ATOMIC_DETAIL_HAS_BUILTIN_MEMCPY +#define BOOST_ATOMIC_DETAIL_HAS_BUILTIN_MEMCMP +#endif + +#if defined(BOOST_ATOMIC_DETAIL_HAS_BUILTIN_MEMCPY) +#define BOOST_ATOMIC_DETAIL_MEMCPY __builtin_memcpy +#else +#define BOOST_ATOMIC_DETAIL_MEMCPY std::memcpy +#endif + +#if defined(BOOST_ATOMIC_DETAIL_HAS_BUILTIN_MEMCMP) +#define BOOST_ATOMIC_DETAIL_MEMCMP __builtin_memcmp +#else +#define BOOST_ATOMIC_DETAIL_MEMCMP std::memcmp +#endif + +#if defined(__CUDACC__) +// nvcc does not support alternatives in asm statement constraints +#define BOOST_ATOMIC_DETAIL_NO_ASM_CONSTRAINT_ALTERNATIVES +// nvcc does not support condition code register ("cc") clobber in asm statements +#define BOOST_ATOMIC_DETAIL_NO_ASM_CLOBBER_CC +#endif + +#if !defined(BOOST_ATOMIC_DETAIL_NO_ASM_CLOBBER_CC) +#define BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC "cc" +#define BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC_COMMA "cc", +#else +#define BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC +#define BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC_COMMA +#endif + +#if ((defined(macintosh) || defined(__APPLE__) || defined(__APPLE_CC__)) && (defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__) < 403)) ||\ + defined(__SUNPRO_CC) +// This macro indicates we're using older binutils that don't support implied zero displacements for memory opereands, +// making code like this invalid: +// movl 4+(%%edx), %%eax +#define BOOST_ATOMIC_DETAIL_NO_ASM_IMPLIED_ZERO_DISPLACEMENTS +#endif + +#if defined(__clang__) || (defined(BOOST_GCC) && (BOOST_GCC+0) < 40500) || defined(__SUNPRO_CC) +// This macro indicates that the compiler does not support allocating rax:rdx register pairs ("A") in asm blocks +#define BOOST_ATOMIC_DETAIL_NO_ASM_RAX_RDX_PAIRS +#endif + +#if defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS) +#if !(defined(BOOST_LIBSTDCXX11) && (BOOST_LIBSTDCXX_VERSION+0) >= 40700) /* libstdc++ from gcc >= 4.7 in C++11 mode */ +// This macro indicates that there is no standard header that is sufficient for Boost.Atomic needs. +#define BOOST_ATOMIC_DETAIL_NO_CXX11_HDR_TYPE_TRAITS +#endif +#endif // defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS) + +// Enable pointer/reference casts between storage and value when possible. +// Note: Despite that MSVC does not employ strict aliasing rules for optimizations +// and does not require an explicit markup for types that may alias, we still don't +// enable the optimization for this compiler because at least MSVC-8 and 9 are known +// to generate broken code sometimes when casts are used. +#if defined(__GNUC__) && (!defined(BOOST_INTEL_CXX_VERSION) || (BOOST_INTEL_CXX_VERSION+0) >= 1300) +#define BOOST_ATOMIC_DETAIL_MAY_ALIAS __attribute__((__may_alias__)) +#define BOOST_ATOMIC_DETAIL_STORAGE_TYPE_MAY_ALIAS +#elif defined(__has_attribute) +#if __has_attribute(__may_alias__) +#define BOOST_ATOMIC_DETAIL_MAY_ALIAS __attribute__((__may_alias__)) +#define BOOST_ATOMIC_DETAIL_STORAGE_TYPE_MAY_ALIAS +#endif +#endif + +#if !defined(BOOST_ATOMIC_DETAIL_MAY_ALIAS) +#define BOOST_ATOMIC_DETAIL_MAY_ALIAS +#endif + +#endif // BOOST_ATOMIC_DETAIL_CONFIG_HPP_INCLUDED_ diff --git a/libs/boost/include/boost/atomic/detail/int_sizes.hpp b/libs/boost/include/boost/atomic/detail/int_sizes.hpp new file mode 100644 index 0000000..eada4ff --- /dev/null +++ b/libs/boost/include/boost/atomic/detail/int_sizes.hpp @@ -0,0 +1,140 @@ +/* + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or copy at + * http://www.boost.org/LICENSE_1_0.txt) + * + * Copyright (c) 2014 Andrey Semashev + */ +/*! + * \file atomic/detail/int_sizes.hpp + * + * This header defines macros for testing buitin integer type sizes + */ + +#ifndef BOOST_ATOMIC_DETAIL_INT_SIZES_HPP_INCLUDED_ +#define BOOST_ATOMIC_DETAIL_INT_SIZES_HPP_INCLUDED_ + +#include + +#ifdef BOOST_HAS_PRAGMA_ONCE +#pragma once +#endif + +// GCC and compatible compilers define internal macros with builtin type traits +#if defined(__SIZEOF_SHORT__) +#define BOOST_ATOMIC_DETAIL_SIZEOF_SHORT __SIZEOF_SHORT__ +#endif +#if defined(__SIZEOF_INT__) +#define BOOST_ATOMIC_DETAIL_SIZEOF_INT __SIZEOF_INT__ +#endif +#if defined(__SIZEOF_LONG__) +#define BOOST_ATOMIC_DETAIL_SIZEOF_LONG __SIZEOF_LONG__ +#endif +#if defined(__SIZEOF_LONG_LONG__) +#define BOOST_ATOMIC_DETAIL_SIZEOF_LLONG __SIZEOF_LONG_LONG__ +#endif +#if defined(__SIZEOF_WCHAR_T__) +#define BOOST_ATOMIC_DETAIL_SIZEOF_WCHAR_T __SIZEOF_WCHAR_T__ +#endif +#if defined(__SIZEOF_POINTER__) +#define BOOST_ATOMIC_DETAIL_SIZEOF_POINTER __SIZEOF_POINTER__ +#elif defined(_MSC_VER) +#if defined(_M_AMD64) || defined(_M_IA64) +#define BOOST_ATOMIC_DETAIL_SIZEOF_POINTER 8 +#else +#define BOOST_ATOMIC_DETAIL_SIZEOF_POINTER 4 +#endif +#endif + +#if !defined(BOOST_ATOMIC_DETAIL_SIZEOF_SHORT) || !defined(BOOST_ATOMIC_DETAIL_SIZEOF_INT) ||\ + !defined(BOOST_ATOMIC_DETAIL_SIZEOF_LONG) || !defined(BOOST_ATOMIC_DETAIL_SIZEOF_LLONG) + +// Try to deduce sizes from limits +#include +#include + +#if (USHRT_MAX + 0) == 0xff +#define BOOST_ATOMIC_DETAIL_SIZEOF_SHORT 1 +#elif (USHRT_MAX + 0) == 0xffff +#define BOOST_ATOMIC_DETAIL_SIZEOF_SHORT 2 +#elif (USHRT_MAX + 0) == 0xffffffff +#define BOOST_ATOMIC_DETAIL_SIZEOF_SHORT 4 +#elif (USHRT_MAX + 0) == UINT64_C(0xffffffffffffffff) +#define BOOST_ATOMIC_DETAIL_SIZEOF_SHORT 8 +#endif + +#if (UINT_MAX + 0) == 0xff +#define BOOST_ATOMIC_DETAIL_SIZEOF_INT 1 +#elif (UINT_MAX + 0) == 0xffff +#define BOOST_ATOMIC_DETAIL_SIZEOF_INT 2 +#elif (UINT_MAX + 0) == 0xffffffff +#define BOOST_ATOMIC_DETAIL_SIZEOF_INT 4 +#elif (UINT_MAX + 0) == UINT64_C(0xffffffffffffffff) +#define BOOST_ATOMIC_DETAIL_SIZEOF_INT 8 +#endif + +#if (ULONG_MAX + 0) == 0xff +#define BOOST_ATOMIC_DETAIL_SIZEOF_LONG 1 +#elif (ULONG_MAX + 0) == 0xffff +#define BOOST_ATOMIC_DETAIL_SIZEOF_LONG 2 +#elif (ULONG_MAX + 0) == 0xffffffff +#define BOOST_ATOMIC_DETAIL_SIZEOF_LONG 4 +#elif (ULONG_MAX + 0) == UINT64_C(0xffffffffffffffff) +#define BOOST_ATOMIC_DETAIL_SIZEOF_LONG 8 +#endif + +#if defined(__hpux) // HP-UX's value of ULONG_LONG_MAX is unusable in preprocessor expressions +#define BOOST_ATOMIC_DETAIL_SIZEOF_LLONG 8 +#else + +// The list of the non-standard macros (the ones except ULLONG_MAX) is taken from cstdint.hpp +#if defined(ULLONG_MAX) +#define BOOST_ATOMIC_DETAIL_ULLONG_MAX ULLONG_MAX +#elif defined(ULONG_LONG_MAX) +#define BOOST_ATOMIC_DETAIL_ULLONG_MAX ULONG_LONG_MAX +#elif defined(ULONGLONG_MAX) +#define BOOST_ATOMIC_DETAIL_ULLONG_MAX ULONGLONG_MAX +#elif defined(_LLONG_MAX) // strangely enough, this one seems to be holding the limit for the unsigned integer +#define BOOST_ATOMIC_DETAIL_ULLONG_MAX _LLONG_MAX +#endif + +#if (BOOST_ATOMIC_DETAIL_ULLONG_MAX + 0) == 0xff +#define BOOST_ATOMIC_DETAIL_SIZEOF_LLONG 1 +#elif (BOOST_ATOMIC_DETAIL_ULLONG_MAX + 0) == 0xffff +#define BOOST_ATOMIC_DETAIL_SIZEOF_LLONG 2 +#elif (BOOST_ATOMIC_DETAIL_ULLONG_MAX + 0) == 0xffffffff +#define BOOST_ATOMIC_DETAIL_SIZEOF_LLONG 4 +#elif (BOOST_ATOMIC_DETAIL_ULLONG_MAX + 0) == UINT64_C(0xffffffffffffffff) +#define BOOST_ATOMIC_DETAIL_SIZEOF_LLONG 8 +#endif + +#endif // defined(__hpux) + +#endif + +#if !defined(BOOST_ATOMIC_DETAIL_SIZEOF_WCHAR_T) + +#include +#include + + #if defined(_MSC_VER) && ( _MSC_VER <= 1310 || defined(UNDER_CE) && _MSC_VER <= 1500 ) +// MSVC 7.1 and MSVC 8 (arm) define WCHAR_MAX to a value not suitable for constant expressions +#define BOOST_ATOMIC_DETAIL_SIZEOF_WCHAR_T 2 +#elif (WCHAR_MAX + 0) == 0xff || (WCHAR_MAX + 0) == 0x7f +#define BOOST_ATOMIC_DETAIL_SIZEOF_WCHAR_T 1 +#elif (WCHAR_MAX + 0) == 0xffff || (WCHAR_MAX + 0) == 0x7fff +#define BOOST_ATOMIC_DETAIL_SIZEOF_WCHAR_T 2 +#elif (WCHAR_MAX + 0) == 0xffffffff || (WCHAR_MAX + 0) == 0x7fffffff +#define BOOST_ATOMIC_DETAIL_SIZEOF_WCHAR_T 4 +#elif (WCHAR_MAX + 0) == UINT64_C(0xffffffffffffffff) || (WCHAR_MAX + 0) == INT64_C(0x7fffffffffffffff) +#define BOOST_ATOMIC_DETAIL_SIZEOF_WCHAR_T 8 +#endif +#endif + +#if !defined(BOOST_ATOMIC_DETAIL_SIZEOF_SHORT) || !defined(BOOST_ATOMIC_DETAIL_SIZEOF_INT) ||\ + !defined(BOOST_ATOMIC_DETAIL_SIZEOF_LONG) || !defined(BOOST_ATOMIC_DETAIL_SIZEOF_LLONG) ||\ + !defined(BOOST_ATOMIC_DETAIL_SIZEOF_WCHAR_T) +#error Boost.Atomic: Failed to determine builtin integer sizes, the target platform is not supported. Please, report to the developers. +#endif + +#endif // BOOST_ATOMIC_DETAIL_INT_SIZES_HPP_INCLUDED_ diff --git a/libs/boost/include/boost/atomic/detail/interlocked.hpp b/libs/boost/include/boost/atomic/detail/interlocked.hpp new file mode 100644 index 0000000..82b6d3a --- /dev/null +++ b/libs/boost/include/boost/atomic/detail/interlocked.hpp @@ -0,0 +1,488 @@ +#ifndef BOOST_ATOMIC_DETAIL_INTERLOCKED_HPP +#define BOOST_ATOMIC_DETAIL_INTERLOCKED_HPP + +// Copyright (c) 2009 Helge Bahmann +// Copyright (c) 2012 - 2014 Andrey Semashev +// +// Distributed under the Boost Software License, Version 1.0. +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +#include + +#ifdef BOOST_HAS_PRAGMA_ONCE +#pragma once +#endif + +#if defined(_WIN32_WCE) + +#if _WIN32_WCE >= 0x600 + +extern "C" long __cdecl _InterlockedCompareExchange( long volatile *, long, long ); +extern "C" long __cdecl _InterlockedExchangeAdd( long volatile *, long ); +extern "C" long __cdecl _InterlockedExchange( long volatile *, long ); + +#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE(dest, exchange, compare) _InterlockedCompareExchange((long*)(dest), exchange, compare) +#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD(dest, addend) _InterlockedExchangeAdd((long*)(dest), (long)(addend)) +#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE(dest, newval) _InterlockedExchange((long*)(dest), (long)(newval)) + +#else // _WIN32_WCE >= 0x600 + +extern "C" long __cdecl InterlockedCompareExchange( long*, long, long ); +extern "C" long __cdecl InterlockedExchangeAdd( long*, long ); +extern "C" long __cdecl InterlockedExchange( long*, long ); + +#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE(dest, exchange, compare) InterlockedCompareExchange((long*)(dest), exchange, compare) +#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD(dest, addend) InterlockedExchangeAdd((long*)(dest), (long)(addend)) +#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE(dest, newval) InterlockedExchange((long*)(dest), (long)(newval)) + +#endif // _WIN32_WCE >= 0x600 + +#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE_POINTER(dest, exchange, compare) ((void*)BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE((long*)(dest), (long)(exchange), (long)(compare))) +#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_POINTER(dest, exchange) ((void*)BOOST_ATOMIC_INTERLOCKED_EXCHANGE((long*)(dest), (long)(exchange))) + +#elif defined(_MSC_VER) && _MSC_VER >= 1310 + +#if _MSC_VER < 1400 + +extern "C" long __cdecl _InterlockedCompareExchange( long volatile *, long, long ); +extern "C" long __cdecl _InterlockedExchangeAdd( long volatile *, long ); +extern "C" long __cdecl _InterlockedExchange( long volatile *, long ); + +#if defined(BOOST_MSVC) +#pragma intrinsic(_InterlockedCompareExchange) +#pragma intrinsic(_InterlockedExchangeAdd) +#pragma intrinsic(_InterlockedExchange) +#endif + +#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE(dest, exchange, compare) _InterlockedCompareExchange((long*)(dest), exchange, compare) +#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD(dest, addend) _InterlockedExchangeAdd((long*)(dest), (long)(addend)) +#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE(dest, newval) _InterlockedExchange((long*)(dest), (long)(newval)) + +#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE_POINTER(dest, exchange, compare) ((void*)BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE((long*)(dest), (long)(exchange), (long)(compare))) +#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_POINTER(dest, exchange) ((void*)BOOST_ATOMIC_INTERLOCKED_EXCHANGE((long*)(dest), (long)(exchange))) + +#else // _MSC_VER < 1400 + +#include + +#if defined(BOOST_MSVC) +#pragma intrinsic(_InterlockedCompareExchange) +#pragma intrinsic(_InterlockedExchangeAdd) +#pragma intrinsic(_InterlockedExchange) +#pragma intrinsic(_InterlockedAnd) +#pragma intrinsic(_InterlockedOr) +#pragma intrinsic(_InterlockedXor) +#endif + +#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE(dest, exchange, compare) _InterlockedCompareExchange((long*)(dest), (long)(exchange), (long)(compare)) +#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD(dest, addend) _InterlockedExchangeAdd((long*)(dest), (long)(addend)) +#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE(dest, newval) _InterlockedExchange((long*)(dest), (long)(newval)) +#define BOOST_ATOMIC_INTERLOCKED_AND(dest, arg) _InterlockedAnd((long*)(dest), (long)(arg)) +#define BOOST_ATOMIC_INTERLOCKED_OR(dest, arg) _InterlockedOr((long*)(dest), (long)(arg)) +#define BOOST_ATOMIC_INTERLOCKED_XOR(dest, arg) _InterlockedXor((long*)(dest), (long)(arg)) + +#if (defined(_M_IX86) && _M_IX86 >= 500) || defined(_M_AMD64) || defined(_M_IA64) +#if defined(BOOST_MSVC) +#pragma intrinsic(_InterlockedCompareExchange64) +#endif +#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE64(dest, exchange, compare) _InterlockedCompareExchange64((__int64*)(dest), (__int64)(exchange), (__int64)(compare)) +#endif + +#if _MSC_VER >= 1500 && defined(_M_AMD64) +#if defined(BOOST_MSVC) +#pragma intrinsic(_InterlockedCompareExchange128) +#endif +#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE128(dest, exchange, compare) _InterlockedCompareExchange128((__int64*)(dest), ((const __int64*)(&exchange))[1], ((const __int64*)(&exchange))[0], (__int64*)(compare)) +#endif + +#if _MSC_VER >= 1600 + +// MSVC 2010 and later provide intrinsics for 8 and 16 bit integers. +// Note that for each bit count these macros must be either all defined or all not defined. +// Otherwise atomic<> operations will be implemented inconsistently. + +#if defined(BOOST_MSVC) +#pragma intrinsic(_InterlockedCompareExchange8) +#pragma intrinsic(_InterlockedExchangeAdd8) +#pragma intrinsic(_InterlockedExchange8) +#pragma intrinsic(_InterlockedAnd8) +#pragma intrinsic(_InterlockedOr8) +#pragma intrinsic(_InterlockedXor8) +#endif + +#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE8(dest, exchange, compare) _InterlockedCompareExchange8((char*)(dest), (char)(exchange), (char)(compare)) +#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD8(dest, addend) _InterlockedExchangeAdd8((char*)(dest), (char)(addend)) +#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE8(dest, newval) _InterlockedExchange8((char*)(dest), (char)(newval)) +#define BOOST_ATOMIC_INTERLOCKED_AND8(dest, arg) _InterlockedAnd8((char*)(dest), (char)(arg)) +#define BOOST_ATOMIC_INTERLOCKED_OR8(dest, arg) _InterlockedOr8((char*)(dest), (char)(arg)) +#define BOOST_ATOMIC_INTERLOCKED_XOR8(dest, arg) _InterlockedXor8((char*)(dest), (char)(arg)) + +#if defined(BOOST_MSVC) +#pragma intrinsic(_InterlockedCompareExchange16) +#pragma intrinsic(_InterlockedExchangeAdd16) +#pragma intrinsic(_InterlockedExchange16) +#pragma intrinsic(_InterlockedAnd16) +#pragma intrinsic(_InterlockedOr16) +#pragma intrinsic(_InterlockedXor16) +#endif + +#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE16(dest, exchange, compare) _InterlockedCompareExchange16((short*)(dest), (short)(exchange), (short)(compare)) +#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD16(dest, addend) _InterlockedExchangeAdd16((short*)(dest), (short)(addend)) +#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE16(dest, newval) _InterlockedExchange16((short*)(dest), (short)(newval)) +#define BOOST_ATOMIC_INTERLOCKED_AND16(dest, arg) _InterlockedAnd16((short*)(dest), (short)(arg)) +#define BOOST_ATOMIC_INTERLOCKED_OR16(dest, arg) _InterlockedOr16((short*)(dest), (short)(arg)) +#define BOOST_ATOMIC_INTERLOCKED_XOR16(dest, arg) _InterlockedXor16((short*)(dest), (short)(arg)) + +#endif // _MSC_VER >= 1600 + +#if defined(_M_AMD64) || defined(_M_IA64) + +#if defined(BOOST_MSVC) +#pragma intrinsic(_InterlockedExchangeAdd64) +#pragma intrinsic(_InterlockedExchange64) +#pragma intrinsic(_InterlockedAnd64) +#pragma intrinsic(_InterlockedOr64) +#pragma intrinsic(_InterlockedXor64) +#endif + +#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD64(dest, addend) _InterlockedExchangeAdd64((__int64*)(dest), (__int64)(addend)) +#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE64(dest, newval) _InterlockedExchange64((__int64*)(dest), (__int64)(newval)) +#define BOOST_ATOMIC_INTERLOCKED_AND64(dest, arg) _InterlockedAnd64((__int64*)(dest), (__int64)(arg)) +#define BOOST_ATOMIC_INTERLOCKED_OR64(dest, arg) _InterlockedOr64((__int64*)(dest), (__int64)(arg)) +#define BOOST_ATOMIC_INTERLOCKED_XOR64(dest, arg) _InterlockedXor64((__int64*)(dest), (__int64)(arg)) + +#if defined(BOOST_MSVC) +#pragma intrinsic(_InterlockedCompareExchangePointer) +#pragma intrinsic(_InterlockedExchangePointer) +#endif + +#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE_POINTER(dest, exchange, compare) _InterlockedCompareExchangePointer((void**)(dest), (void*)(exchange), (void*)(compare)) +#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_POINTER(dest, newval) _InterlockedExchangePointer((void**)(dest), (void*)(newval)) +#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD_POINTER(dest, byte_offset) ((void*)BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD64((long*)(dest), byte_offset)) + +#elif defined(_M_IX86) + +#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE_POINTER(dest, exchange, compare) ((void*)_InterlockedCompareExchange((long*)(dest), (long)(exchange), (long)(compare))) +#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_POINTER(dest, newval) ((void*)_InterlockedExchange((long*)(dest), (long)(newval))) +#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD_POINTER(dest, byte_offset) ((void*)BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD((long*)(dest), byte_offset)) + +#endif + +#if _MSC_VER >= 1700 && (defined(_M_ARM) || defined(_M_ARM64)) + +#if defined(BOOST_MSVC) +#pragma intrinsic(_InterlockedExchangeAdd64) +#pragma intrinsic(_InterlockedExchange64) +#pragma intrinsic(_InterlockedAnd64) +#pragma intrinsic(_InterlockedOr64) +#pragma intrinsic(_InterlockedXor64) +#endif + +#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD64(dest, addend) _InterlockedExchangeAdd64((__int64*)(dest), (__int64)(addend)) +#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE64(dest, newval) _InterlockedExchange64((__int64*)(dest), (__int64)(newval)) +#define BOOST_ATOMIC_INTERLOCKED_AND64(dest, arg) _InterlockedAnd64((__int64*)(dest), (__int64)(arg)) +#define BOOST_ATOMIC_INTERLOCKED_OR64(dest, arg) _InterlockedOr64((__int64*)(dest), (__int64)(arg)) +#define BOOST_ATOMIC_INTERLOCKED_XOR64(dest, arg) _InterlockedXor64((__int64*)(dest), (__int64)(arg)) + +#if defined(BOOST_MSVC) +#pragma intrinsic(_InterlockedCompareExchange8_nf) +#pragma intrinsic(_InterlockedCompareExchange8_acq) +#pragma intrinsic(_InterlockedCompareExchange8_rel) +#pragma intrinsic(_InterlockedCompareExchange16_nf) +#pragma intrinsic(_InterlockedCompareExchange16_acq) +#pragma intrinsic(_InterlockedCompareExchange16_rel) +#pragma intrinsic(_InterlockedCompareExchange_nf) +#pragma intrinsic(_InterlockedCompareExchange_acq) +#pragma intrinsic(_InterlockedCompareExchange_rel) +#pragma intrinsic(_InterlockedCompareExchange64) +#pragma intrinsic(_InterlockedCompareExchange64_nf) +#pragma intrinsic(_InterlockedCompareExchange64_acq) +#pragma intrinsic(_InterlockedCompareExchange64_rel) +#pragma intrinsic(_InterlockedCompareExchangePointer) +#pragma intrinsic(_InterlockedCompareExchangePointer_nf) +#pragma intrinsic(_InterlockedCompareExchangePointer_acq) +#pragma intrinsic(_InterlockedCompareExchangePointer_rel) +#endif + +#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE8_RELAXED(dest, exchange, compare) _InterlockedCompareExchange8_nf((char*)(dest), (char)(exchange), (char)(compare)) +#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE8_ACQUIRE(dest, exchange, compare) _InterlockedCompareExchange8_acq((char*)(dest), (char)(exchange), (char)(compare)) +#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE8_RELEASE(dest, exchange, compare) _InterlockedCompareExchange8_rel((char*)(dest), (char)(exchange), (char)(compare)) +#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE16_RELAXED(dest, exchange, compare) _InterlockedCompareExchange16_nf((short*)(dest), (short)(exchange), (short)(compare)) +#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE16_ACQUIRE(dest, exchange, compare) _InterlockedCompareExchange16_acq((short*)(dest), (short)(exchange), (short)(compare)) +#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE16_RELEASE(dest, exchange, compare) _InterlockedCompareExchange16_rel((short*)(dest), (short)(exchange), (short)(compare)) +#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE_RELAXED(dest, exchange, compare) _InterlockedCompareExchange_nf((long*)(dest), (long)(exchange), (long)(compare)) +#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE_ACQUIRE(dest, exchange, compare) _InterlockedCompareExchange_acq((long*)(dest), (long)(exchange), (long)(compare)) +#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE_RELEASE(dest, exchange, compare) _InterlockedCompareExchange_rel((long*)(dest), (long)(exchange), (long)(compare)) +#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE64(dest, exchange, compare) _InterlockedCompareExchange64((__int64*)(dest), (__int64)(exchange), (__int64)(compare)) +#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE64_RELAXED(dest, exchange, compare) _InterlockedCompareExchange64_nf((__int64*)(dest), (__int64)(exchange), (__int64)(compare)) +#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE64_ACQUIRE(dest, exchange, compare) _InterlockedCompareExchange64_acq((__int64*)(dest), (__int64)(exchange), (__int64)(compare)) +#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE64_RELEASE(dest, exchange, compare) _InterlockedCompareExchange64_rel((__int64*)(dest), (__int64)(exchange), (__int64)(compare)) +#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE_POINTER(dest, exchange, compare) _InterlockedCompareExchangePointer((void**)(dest), (void*)(exchange), (void*)(compare)) +#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE_POINTER_RELAXED(dest, exchange, compare) _InterlockedCompareExchangePointer_nf((void**)(dest), (void*)(exchange), (void*)(compare)) +#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE_POINTER_ACQUIRE(dest, exchange, compare) _InterlockedCompareExchangePointer_acq((void**)(dest), (void*)(exchange), (void*)(compare)) +#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE_POINTER_RELEASE(dest, exchange, compare) _InterlockedCompareExchangePointer_rel((void**)(dest), (void*)(exchange), (void*)(compare)) + +#if defined(BOOST_MSVC) +#pragma intrinsic(_InterlockedExchangeAdd8_nf) +#pragma intrinsic(_InterlockedExchangeAdd8_acq) +#pragma intrinsic(_InterlockedExchangeAdd8_rel) +#pragma intrinsic(_InterlockedExchangeAdd16_nf) +#pragma intrinsic(_InterlockedExchangeAdd16_acq) +#pragma intrinsic(_InterlockedExchangeAdd16_rel) +#pragma intrinsic(_InterlockedExchangeAdd_nf) +#pragma intrinsic(_InterlockedExchangeAdd_acq) +#pragma intrinsic(_InterlockedExchangeAdd_rel) +#pragma intrinsic(_InterlockedExchangeAdd64_nf) +#pragma intrinsic(_InterlockedExchangeAdd64_acq) +#pragma intrinsic(_InterlockedExchangeAdd64_rel) +#endif + +#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD8_RELAXED(dest, addend) _InterlockedExchangeAdd8_nf((char*)(dest), (char)(addend)) +#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD8_ACQUIRE(dest, addend) _InterlockedExchangeAdd8_acq((char*)(dest), (char)(addend)) +#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD8_RELEASE(dest, addend) _InterlockedExchangeAdd8_rel((char*)(dest), (char)(addend)) +#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD16_RELAXED(dest, addend) _InterlockedExchangeAdd16_nf((short*)(dest), (short)(addend)) +#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD16_ACQUIRE(dest, addend) _InterlockedExchangeAdd16_acq((short*)(dest), (short)(addend)) +#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD16_RELEASE(dest, addend) _InterlockedExchangeAdd16_rel((short*)(dest), (short)(addend)) +#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD_RELAXED(dest, addend) _InterlockedExchangeAdd_nf((long*)(dest), (long)(addend)) +#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD_ACQUIRE(dest, addend) _InterlockedExchangeAdd_acq((long*)(dest), (long)(addend)) +#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD_RELEASE(dest, addend) _InterlockedExchangeAdd_rel((long*)(dest), (long)(addend)) +#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD64_RELAXED(dest, addend) _InterlockedExchangeAdd64_nf((__int64*)(dest), (__int64)(addend)) +#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD64_ACQUIRE(dest, addend) _InterlockedExchangeAdd64_acq((__int64*)(dest), (__int64)(addend)) +#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD64_RELEASE(dest, addend) _InterlockedExchangeAdd64_rel((__int64*)(dest), (__int64)(addend)) + +#if defined(_M_ARM64) +#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD_POINTER(dest, byte_offset) ((void*)BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD64((__int64*)(dest), byte_offset)) +#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD_POINTER_RELAXED(dest, byte_offset) ((void*)BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD64_RELAXED((__int64*)(dest), byte_offset)) +#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD_POINTER_ACQUIRE(dest, byte_offset) ((void*)BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD64_ACQUIRE((__int64*)(dest), byte_offset)) +#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD_POINTER_RELEASE(dest, byte_offset) ((void*)BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD64_RELEASE((__int64*)(dest), byte_offset)) +#else +#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD_POINTER(dest, byte_offset) ((void*)BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD((long*)(dest), byte_offset)) +#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD_POINTER_RELAXED(dest, byte_offset) ((void*)BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD_RELAXED((long*)(dest), byte_offset)) +#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD_POINTER_ACQUIRE(dest, byte_offset) ((void*)BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD_ACQUIRE((long*)(dest), byte_offset)) +#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD_POINTER_RELEASE(dest, byte_offset) ((void*)BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD_RELEASE((long*)(dest), byte_offset)) +#endif + +#if defined(BOOST_MSVC) +#pragma intrinsic(_InterlockedExchange8_nf) +#pragma intrinsic(_InterlockedExchange8_acq) +#pragma intrinsic(_InterlockedExchange16_nf) +#pragma intrinsic(_InterlockedExchange16_acq) +#pragma intrinsic(_InterlockedExchange_nf) +#pragma intrinsic(_InterlockedExchange_acq) +#pragma intrinsic(_InterlockedExchange64_nf) +#pragma intrinsic(_InterlockedExchange64_acq) +#pragma intrinsic(_InterlockedExchangePointer) +#pragma intrinsic(_InterlockedExchangePointer_nf) +#pragma intrinsic(_InterlockedExchangePointer_acq) +#if _MSC_VER >= 1800 +#pragma intrinsic(_InterlockedExchange8_rel) +#pragma intrinsic(_InterlockedExchange16_rel) +#pragma intrinsic(_InterlockedExchange_rel) +#pragma intrinsic(_InterlockedExchange64_rel) +#pragma intrinsic(_InterlockedExchangePointer_rel) +#endif +#endif + +#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE8_RELAXED(dest, newval) _InterlockedExchange8_nf((char*)(dest), (char)(newval)) +#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE8_ACQUIRE(dest, newval) _InterlockedExchange8_acq((char*)(dest), (char)(newval)) +#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE16_RELAXED(dest, newval) _InterlockedExchange16_nf((short*)(dest), (short)(newval)) +#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE16_ACQUIRE(dest, newval) _InterlockedExchange16_acq((short*)(dest), (short)(newval)) +#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_RELAXED(dest, newval) _InterlockedExchange_nf((long*)(dest), (long)(newval)) +#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ACQUIRE(dest, newval) _InterlockedExchange_acq((long*)(dest), (long)(newval)) +#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE64_RELAXED(dest, newval) _InterlockedExchange64_nf((__int64*)(dest), (__int64)(newval)) +#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE64_ACQUIRE(dest, newval) _InterlockedExchange64_acq((__int64*)(dest), (__int64)(newval)) +#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_POINTER(dest, newval) _InterlockedExchangePointer((void**)(dest), (void*)(newval)) +#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_POINTER_RELAXED(dest, newval) _InterlockedExchangePointer_nf((void**)(dest), (void*)(newval)) +#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_POINTER_ACQUIRE(dest, newval) _InterlockedExchangePointer_acq((void**)(dest), (void*)(newval)) + +#if _MSC_VER >= 1800 +#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE8_RELEASE(dest, newval) _InterlockedExchange8_rel((char*)(dest), (char)(newval)) +#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE16_RELEASE(dest, newval) _InterlockedExchange16_rel((short*)(dest), (short)(newval)) +#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_RELEASE(dest, newval) _InterlockedExchange_rel((long*)(dest), (long)(newval)) +#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE64_RELEASE(dest, newval) _InterlockedExchange64_rel((__int64*)(dest), (__int64)(newval)) +#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_POINTER_RELEASE(dest, newval) _InterlockedExchangePointer_rel((void**)(dest), (void*)(newval)) +#else +#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE8_RELEASE(dest, newval) BOOST_ATOMIC_INTERLOCKED_EXCHANGE8(dest, newval) +#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE16_RELEASE(dest, newval) BOOST_ATOMIC_INTERLOCKED_EXCHANGE16(dest, newval) +#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_RELEASE(dest, newval) BOOST_ATOMIC_INTERLOCKED_EXCHANGE(dest, newval) +#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE64_RELEASE(dest, newval) BOOST_ATOMIC_INTERLOCKED_EXCHANGE64(dest, newval) +#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_POINTER_RELEASE(dest, newval) BOOST_ATOMIC_INTERLOCKED_EXCHANGE_POINTER(dest, newval) +#endif + +#if defined(BOOST_MSVC) +#pragma intrinsic(_InterlockedAnd8_nf) +#pragma intrinsic(_InterlockedAnd8_acq) +#pragma intrinsic(_InterlockedAnd8_rel) +#pragma intrinsic(_InterlockedAnd16_nf) +#pragma intrinsic(_InterlockedAnd16_acq) +#pragma intrinsic(_InterlockedAnd16_rel) +#pragma intrinsic(_InterlockedAnd_nf) +#pragma intrinsic(_InterlockedAnd_acq) +#pragma intrinsic(_InterlockedAnd_rel) +#pragma intrinsic(_InterlockedAnd64_nf) +#pragma intrinsic(_InterlockedAnd64_acq) +#pragma intrinsic(_InterlockedAnd64_rel) +#endif + +#define BOOST_ATOMIC_INTERLOCKED_AND8_RELAXED(dest, arg) _InterlockedAnd8_nf((char*)(dest), (char)(arg)) +#define BOOST_ATOMIC_INTERLOCKED_AND8_ACQUIRE(dest, arg) _InterlockedAnd8_acq((char*)(dest), (char)(arg)) +#define BOOST_ATOMIC_INTERLOCKED_AND8_RELEASE(dest, arg) _InterlockedAnd8_rel((char*)(dest), (char)(arg)) +#define BOOST_ATOMIC_INTERLOCKED_AND16_RELAXED(dest, arg) _InterlockedAnd16_nf((short*)(dest), (short)(arg)) +#define BOOST_ATOMIC_INTERLOCKED_AND16_ACQUIRE(dest, arg) _InterlockedAnd16_acq((short*)(dest), (short)(arg)) +#define BOOST_ATOMIC_INTERLOCKED_AND16_RELEASE(dest, arg) _InterlockedAnd16_rel((short*)(dest), (short)(arg)) +#define BOOST_ATOMIC_INTERLOCKED_AND_RELAXED(dest, arg) _InterlockedAnd_nf((long*)(dest), (long)(arg)) +#define BOOST_ATOMIC_INTERLOCKED_AND_ACQUIRE(dest, arg) _InterlockedAnd_acq((long*)(dest), (long)(arg)) +#define BOOST_ATOMIC_INTERLOCKED_AND_RELEASE(dest, arg) _InterlockedAnd_rel((long*)(dest), (long)(arg)) +#define BOOST_ATOMIC_INTERLOCKED_AND64_RELAXED(dest, arg) _InterlockedAnd64_nf((__int64*)(dest), (__int64)(arg)) +#define BOOST_ATOMIC_INTERLOCKED_AND64_ACQUIRE(dest, arg) _InterlockedAnd64_acq((__int64*)(dest), (__int64)(arg)) +#define BOOST_ATOMIC_INTERLOCKED_AND64_RELEASE(dest, arg) _InterlockedAnd64_rel((__int64*)(dest), (__int64)(arg)) + +#if defined(BOOST_MSVC) +#pragma intrinsic(_InterlockedOr8_nf) +#pragma intrinsic(_InterlockedOr8_acq) +#pragma intrinsic(_InterlockedOr8_rel) +#pragma intrinsic(_InterlockedOr16_nf) +#pragma intrinsic(_InterlockedOr16_acq) +#pragma intrinsic(_InterlockedOr16_rel) +#pragma intrinsic(_InterlockedOr_nf) +#pragma intrinsic(_InterlockedOr_acq) +#pragma intrinsic(_InterlockedOr_rel) +#pragma intrinsic(_InterlockedOr64_nf) +#pragma intrinsic(_InterlockedOr64_acq) +#pragma intrinsic(_InterlockedOr64_rel) +#endif + +#define BOOST_ATOMIC_INTERLOCKED_OR8_RELAXED(dest, arg) _InterlockedOr8_nf((char*)(dest), (char)(arg)) +#define BOOST_ATOMIC_INTERLOCKED_OR8_ACQUIRE(dest, arg) _InterlockedOr8_acq((char*)(dest), (char)(arg)) +#define BOOST_ATOMIC_INTERLOCKED_OR8_RELEASE(dest, arg) _InterlockedOr8_rel((char*)(dest), (char)(arg)) +#define BOOST_ATOMIC_INTERLOCKED_OR16_RELAXED(dest, arg) _InterlockedOr16_nf((short*)(dest), (short)(arg)) +#define BOOST_ATOMIC_INTERLOCKED_OR16_ACQUIRE(dest, arg) _InterlockedOr16_acq((short*)(dest), (short)(arg)) +#define BOOST_ATOMIC_INTERLOCKED_OR16_RELEASE(dest, arg) _InterlockedOr16_rel((short*)(dest), (short)(arg)) +#define BOOST_ATOMIC_INTERLOCKED_OR_RELAXED(dest, arg) _InterlockedOr_nf((long*)(dest), (long)(arg)) +#define BOOST_ATOMIC_INTERLOCKED_OR_ACQUIRE(dest, arg) _InterlockedOr_acq((long*)(dest), (long)(arg)) +#define BOOST_ATOMIC_INTERLOCKED_OR_RELEASE(dest, arg) _InterlockedOr_rel((long*)(dest), (long)(arg)) +#define BOOST_ATOMIC_INTERLOCKED_OR64_RELAXED(dest, arg) _InterlockedOr64_nf((__int64*)(dest), (__int64)(arg)) +#define BOOST_ATOMIC_INTERLOCKED_OR64_ACQUIRE(dest, arg) _InterlockedOr64_acq((__int64*)(dest), (__int64)(arg)) +#define BOOST_ATOMIC_INTERLOCKED_OR64_RELEASE(dest, arg) _InterlockedOr64_rel((__int64*)(dest), (__int64)(arg)) + +#if defined(BOOST_MSVC) +#pragma intrinsic(_InterlockedXor8_nf) +#pragma intrinsic(_InterlockedXor8_acq) +#pragma intrinsic(_InterlockedXor8_rel) +#pragma intrinsic(_InterlockedXor16_nf) +#pragma intrinsic(_InterlockedXor16_acq) +#pragma intrinsic(_InterlockedXor16_rel) +#pragma intrinsic(_InterlockedXor_nf) +#pragma intrinsic(_InterlockedXor_acq) +#pragma intrinsic(_InterlockedXor_rel) +#pragma intrinsic(_InterlockedXor64_nf) +#pragma intrinsic(_InterlockedXor64_acq) +#pragma intrinsic(_InterlockedXor64_rel) +#endif + +#define BOOST_ATOMIC_INTERLOCKED_XOR8_RELAXED(dest, arg) _InterlockedXor8_nf((char*)(dest), (char)(arg)) +#define BOOST_ATOMIC_INTERLOCKED_XOR8_ACQUIRE(dest, arg) _InterlockedXor8_acq((char*)(dest), (char)(arg)) +#define BOOST_ATOMIC_INTERLOCKED_XOR8_RELEASE(dest, arg) _InterlockedXor8_rel((char*)(dest), (char)(arg)) +#define BOOST_ATOMIC_INTERLOCKED_XOR16_RELAXED(dest, arg) _InterlockedXor16_nf((short*)(dest), (short)(arg)) +#define BOOST_ATOMIC_INTERLOCKED_XOR16_ACQUIRE(dest, arg) _InterlockedXor16_acq((short*)(dest), (short)(arg)) +#define BOOST_ATOMIC_INTERLOCKED_XOR16_RELEASE(dest, arg) _InterlockedXor16_rel((short*)(dest), (short)(arg)) +#define BOOST_ATOMIC_INTERLOCKED_XOR_RELAXED(dest, arg) _InterlockedXor_nf((long*)(dest), (long)(arg)) +#define BOOST_ATOMIC_INTERLOCKED_XOR_ACQUIRE(dest, arg) _InterlockedXor_acq((long*)(dest), (long)(arg)) +#define BOOST_ATOMIC_INTERLOCKED_XOR_RELEASE(dest, arg) _InterlockedXor_rel((long*)(dest), (long)(arg)) +#define BOOST_ATOMIC_INTERLOCKED_XOR64_RELAXED(dest, arg) _InterlockedXor64_nf((__int64*)(dest), (__int64)(arg)) +#define BOOST_ATOMIC_INTERLOCKED_XOR64_ACQUIRE(dest, arg) _InterlockedXor64_acq((__int64*)(dest), (__int64)(arg)) +#define BOOST_ATOMIC_INTERLOCKED_XOR64_RELEASE(dest, arg) _InterlockedXor64_rel((__int64*)(dest), (__int64)(arg)) + +#endif // _MSC_VER >= 1700 && defined(_M_ARM) + +#endif // _MSC_VER < 1400 + +#else // defined(_MSC_VER) && _MSC_VER >= 1310 + +#if defined(BOOST_USE_WINDOWS_H) + +#include + +#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE(dest, exchange, compare) InterlockedCompareExchange((long*)(dest), (long)(exchange), (long)(compare)) +#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE(dest, newval) InterlockedExchange((long*)(dest), (long)(newval)) +#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD(dest, addend) InterlockedExchangeAdd((long*)(dest), (long)(addend)) + +#if defined(_WIN64) + +#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE64(dest, exchange, compare) InterlockedCompareExchange64((__int64*)(dest), (__int64)(exchange), (__int64)(compare)) +#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE64(dest, newval) InterlockedExchange64((__int64*)(dest), (__int64)(newval)) +#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD64(dest, addend) InterlockedExchangeAdd64((__int64*)(dest), (__int64)(addend)) + +#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE_POINTER(dest, exchange, compare) InterlockedCompareExchangePointer((void**)(dest), (void*)(exchange), (void*)(compare)) +#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_POINTER(dest, newval) InterlockedExchangePointer((void**)(dest), (void*)(newval)) +#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD_POINTER(dest, byte_offset) ((void*)BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD64(dest, byte_offset)) + +#else // defined(_WIN64) + +#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE_POINTER(dest, exchange, compare) ((void*)BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE(dest, exchange, compare)) +#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_POINTER(dest, newval) ((void*)BOOST_ATOMIC_INTERLOCKED_EXCHANGE(dest, newval)) +#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD_POINTER(dest, byte_offset) ((void*)BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD(dest, byte_offset)) + +#endif // defined(_WIN64) + +#else // defined(BOOST_USE_WINDOWS_H) + +#if defined(__MINGW64__) +#define BOOST_ATOMIC_INTERLOCKED_IMPORT +#else +#define BOOST_ATOMIC_INTERLOCKED_IMPORT __declspec(dllimport) +#endif + +namespace boost { +namespace atomics { +namespace detail { + +extern "C" { + +BOOST_ATOMIC_INTERLOCKED_IMPORT long __stdcall InterlockedCompareExchange(long volatile*, long, long); +BOOST_ATOMIC_INTERLOCKED_IMPORT long __stdcall InterlockedExchange(long volatile*, long); +BOOST_ATOMIC_INTERLOCKED_IMPORT long __stdcall InterlockedExchangeAdd(long volatile*, long); + +#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE(dest, exchange, compare) boost::atomics::detail::InterlockedCompareExchange((long*)(dest), (long)(exchange), (long)(compare)) +#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE(dest, newval) boost::atomics::detail::InterlockedExchange((long*)(dest), (long)(newval)) +#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD(dest, addend) boost::atomics::detail::InterlockedExchangeAdd((long*)(dest), (long)(addend)) + +#if defined(_WIN64) + +BOOST_ATOMIC_INTERLOCKED_IMPORT __int64 __stdcall InterlockedCompareExchange64(__int64 volatile*, __int64, __int64); +BOOST_ATOMIC_INTERLOCKED_IMPORT __int64 __stdcall InterlockedExchange64(__int64 volatile*, __int64); +BOOST_ATOMIC_INTERLOCKED_IMPORT __int64 __stdcall InterlockedExchangeAdd64(__int64 volatile*, __int64); + +BOOST_ATOMIC_INTERLOCKED_IMPORT void* __stdcall InterlockedCompareExchangePointer(void* volatile *, void*, void*); +BOOST_ATOMIC_INTERLOCKED_IMPORT void* __stdcall InterlockedExchangePointer(void* volatile *, void*); + +#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE64(dest, exchange, compare) boost::atomics::detail::InterlockedCompareExchange64((__int64*)(dest), (__int64)(exchange), (__int64)(compare)) +#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE64(dest, newval) boost::atomics::detail::InterlockedExchange64((__int64*)(dest), (__int64)(newval)) +#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD64(dest, addend) boost::atomics::detail::InterlockedExchangeAdd64((__int64*)(dest), (__int64)(addend)) + +#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE_POINTER(dest, exchange, compare) boost::atomics::detail::InterlockedCompareExchangePointer((void**)(dest), (void*)(exchange), (void*)(compare)) +#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_POINTER(dest, newval) boost::atomics::detail::InterlockedExchangePointer((void**)(dest), (void*)(newval)) +#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD_POINTER(dest, byte_offset) ((void*)BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD64(dest, byte_offset)) + +#else // defined(_WIN64) + +#define BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE_POINTER(dest, exchange, compare) ((void*)BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE(dest, exchange, compare)) +#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_POINTER(dest, newval) ((void*)BOOST_ATOMIC_INTERLOCKED_EXCHANGE(dest, newval)) +#define BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD_POINTER(dest, byte_offset) ((void*)BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD(dest, byte_offset)) + +#endif // defined(_WIN64) + +} // extern "C" + +} // namespace detail +} // namespace atomics +} // namespace boost + +#undef BOOST_ATOMIC_INTERLOCKED_IMPORT + +#endif // defined(BOOST_USE_WINDOWS_H) + +#endif // defined(_MSC_VER) + +#endif diff --git a/libs/boost/include/boost/atomic/detail/link.hpp b/libs/boost/include/boost/atomic/detail/link.hpp new file mode 100644 index 0000000..4f522ac --- /dev/null +++ b/libs/boost/include/boost/atomic/detail/link.hpp @@ -0,0 +1,58 @@ +/* + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or copy at + * http://www.boost.org/LICENSE_1_0.txt) + * + * Copyright (c) 2012 Hartmut Kaiser + * Copyright (c) 2014 Andrey Semashev + */ +/*! + * \file atomic/detail/config.hpp + * + * This header defines macros for linking with compiled library of Boost.Atomic + */ + +#ifndef BOOST_ATOMIC_DETAIL_LINK_HPP_INCLUDED_ +#define BOOST_ATOMIC_DETAIL_LINK_HPP_INCLUDED_ + +#include + +#ifdef BOOST_HAS_PRAGMA_ONCE +#pragma once +#endif + +/////////////////////////////////////////////////////////////////////////////// +// Set up dll import/export options +#if (defined(BOOST_ATOMIC_DYN_LINK) || defined(BOOST_ALL_DYN_LINK)) && \ + !defined(BOOST_ATOMIC_STATIC_LINK) + +#if defined(BOOST_ATOMIC_SOURCE) +#define BOOST_ATOMIC_DECL BOOST_SYMBOL_EXPORT +#define BOOST_ATOMIC_BUILD_DLL +#else +#define BOOST_ATOMIC_DECL BOOST_SYMBOL_IMPORT +#endif + +#endif // building a shared library + +#ifndef BOOST_ATOMIC_DECL +#define BOOST_ATOMIC_DECL +#endif + +/////////////////////////////////////////////////////////////////////////////// +// Auto library naming +#if !defined(BOOST_ATOMIC_SOURCE) && !defined(BOOST_ALL_NO_LIB) && \ + !defined(BOOST_ATOMIC_NO_LIB) + +#define BOOST_LIB_NAME boost_atomic + +// tell the auto-link code to select a dll when required: +#if defined(BOOST_ALL_DYN_LINK) || defined(BOOST_ATOMIC_DYN_LINK) +#define BOOST_DYN_LINK +#endif + +#include + +#endif // auto-linking disabled + +#endif diff --git a/libs/boost/include/boost/atomic/detail/lockpool.hpp b/libs/boost/include/boost/atomic/detail/lockpool.hpp new file mode 100644 index 0000000..4e249aa --- /dev/null +++ b/libs/boost/include/boost/atomic/detail/lockpool.hpp @@ -0,0 +1,51 @@ +/* + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or copy at + * http://www.boost.org/LICENSE_1_0.txt) + * + * Copyright (c) 2011 Helge Bahmann + * Copyright (c) 2013-2014 Andrey Semashev + */ +/*! + * \file atomic/detail/lockpool.hpp + * + * This header contains declaration of the lockpool used to emulate atomic ops. + */ + +#ifndef BOOST_ATOMIC_DETAIL_LOCKPOOL_HPP_INCLUDED_ +#define BOOST_ATOMIC_DETAIL_LOCKPOOL_HPP_INCLUDED_ + +#include +#include + +#ifdef BOOST_HAS_PRAGMA_ONCE +#pragma once +#endif + +namespace boost { +namespace atomics { +namespace detail { + +struct lockpool +{ + class scoped_lock + { + void* m_lock; + + public: + explicit BOOST_ATOMIC_DECL scoped_lock(const volatile void* addr) BOOST_NOEXCEPT; + BOOST_ATOMIC_DECL ~scoped_lock() BOOST_NOEXCEPT; + + BOOST_DELETED_FUNCTION(scoped_lock(scoped_lock const&)) + BOOST_DELETED_FUNCTION(scoped_lock& operator=(scoped_lock const&)) + }; + + static BOOST_ATOMIC_DECL void thread_fence() BOOST_NOEXCEPT; + static BOOST_ATOMIC_DECL void signal_fence() BOOST_NOEXCEPT; +}; + +} // namespace detail +} // namespace atomics +} // namespace boost + +#endif // BOOST_ATOMIC_DETAIL_LOCKPOOL_HPP_INCLUDED_ diff --git a/libs/boost/include/boost/atomic/detail/operations.hpp b/libs/boost/include/boost/atomic/detail/operations.hpp new file mode 100644 index 0000000..d81399a --- /dev/null +++ b/libs/boost/include/boost/atomic/detail/operations.hpp @@ -0,0 +1,24 @@ +/* + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or copy at + * http://www.boost.org/LICENSE_1_0.txt) + * + * Copyright (c) 2014 Andrey Semashev + */ +/*! + * \file atomic/detail/operations.hpp + * + * This header defines atomic operations, including the emulated version. + */ + +#ifndef BOOST_ATOMIC_DETAIL_OPERATIONS_HPP_INCLUDED_ +#define BOOST_ATOMIC_DETAIL_OPERATIONS_HPP_INCLUDED_ + +#include +#include + +#ifdef BOOST_HAS_PRAGMA_ONCE +#pragma once +#endif + +#endif // BOOST_ATOMIC_DETAIL_OPERATIONS_HPP_INCLUDED_ diff --git a/libs/boost/include/boost/atomic/detail/operations_fwd.hpp b/libs/boost/include/boost/atomic/detail/operations_fwd.hpp new file mode 100644 index 0000000..efd4970 --- /dev/null +++ b/libs/boost/include/boost/atomic/detail/operations_fwd.hpp @@ -0,0 +1,35 @@ +/* + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or copy at + * http://www.boost.org/LICENSE_1_0.txt) + * + * Copyright (c) 2014 Andrey Semashev + */ +/*! + * \file atomic/detail/operations_fwd.hpp + * + * This header contains forward declaration of the \c operations template. + */ + +#ifndef BOOST_ATOMIC_DETAIL_OPERATIONS_FWD_HPP_INCLUDED_ +#define BOOST_ATOMIC_DETAIL_OPERATIONS_FWD_HPP_INCLUDED_ + +#include +#include + +#ifdef BOOST_HAS_PRAGMA_ONCE +#pragma once +#endif + +namespace boost { +namespace atomics { +namespace detail { + +template< std::size_t Size, bool Signed > +struct operations; + +} // namespace detail +} // namespace atomics +} // namespace boost + +#endif // BOOST_ATOMIC_DETAIL_OPERATIONS_FWD_HPP_INCLUDED_ diff --git a/libs/boost/include/boost/atomic/detail/operations_lockfree.hpp b/libs/boost/include/boost/atomic/detail/operations_lockfree.hpp new file mode 100644 index 0000000..b465403 --- /dev/null +++ b/libs/boost/include/boost/atomic/detail/operations_lockfree.hpp @@ -0,0 +1,30 @@ +/* + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or copy at + * http://www.boost.org/LICENSE_1_0.txt) + * + * Copyright (c) 2014 Andrey Semashev + */ +/*! + * \file atomic/detail/operations_lockfree.hpp + * + * This header defines lockfree atomic operations. + */ + +#ifndef BOOST_ATOMIC_DETAIL_OPERATIONS_LOCKFREE_HPP_INCLUDED_ +#define BOOST_ATOMIC_DETAIL_OPERATIONS_LOCKFREE_HPP_INCLUDED_ + +#include +#include + +#if !defined(BOOST_ATOMIC_EMULATED) +#include BOOST_ATOMIC_DETAIL_HEADER(boost/atomic/detail/ops_) +#else +#include +#endif + +#ifdef BOOST_HAS_PRAGMA_ONCE +#pragma once +#endif + +#endif // BOOST_ATOMIC_DETAIL_OPERATIONS_LOCKFREE_HPP_INCLUDED_ diff --git a/libs/boost/include/boost/atomic/detail/ops_cas_based.hpp b/libs/boost/include/boost/atomic/detail/ops_cas_based.hpp new file mode 100644 index 0000000..504cedb --- /dev/null +++ b/libs/boost/include/boost/atomic/detail/ops_cas_based.hpp @@ -0,0 +1,105 @@ +/* + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or copy at + * http://www.boost.org/LICENSE_1_0.txt) + * + * Copyright (c) 2014 Andrey Semashev + */ +/*! + * \file atomic/detail/ops_cas_based.hpp + * + * This header contains CAS-based implementation of the \c operations template. + */ + +#ifndef BOOST_ATOMIC_DETAIL_OPS_CAS_BASED_HPP_INCLUDED_ +#define BOOST_ATOMIC_DETAIL_OPS_CAS_BASED_HPP_INCLUDED_ + +#include +#include +#include + +#ifdef BOOST_HAS_PRAGMA_ONCE +#pragma once +#endif + +namespace boost { +namespace atomics { +namespace detail { + +template< typename Base > +struct cas_based_exchange : + public Base +{ + typedef typename Base::storage_type storage_type; + + static BOOST_FORCEINLINE storage_type exchange(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + storage_type old_val; + atomics::detail::non_atomic_load(storage, old_val); + while (!Base::compare_exchange_weak(storage, old_val, v, order, memory_order_relaxed)) {} + return old_val; + } +}; + +template< typename Base > +struct cas_based_operations : + public Base +{ + typedef typename Base::storage_type storage_type; + + static BOOST_FORCEINLINE storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + storage_type old_val; + atomics::detail::non_atomic_load(storage, old_val); + while (!Base::compare_exchange_weak(storage, old_val, old_val + v, order, memory_order_relaxed)) {} + return old_val; + } + + static BOOST_FORCEINLINE storage_type fetch_sub(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + storage_type old_val; + atomics::detail::non_atomic_load(storage, old_val); + while (!Base::compare_exchange_weak(storage, old_val, old_val - v, order, memory_order_relaxed)) {} + return old_val; + } + + static BOOST_FORCEINLINE storage_type fetch_and(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + storage_type old_val; + atomics::detail::non_atomic_load(storage, old_val); + while (!Base::compare_exchange_weak(storage, old_val, old_val & v, order, memory_order_relaxed)) {} + return old_val; + } + + static BOOST_FORCEINLINE storage_type fetch_or(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + storage_type old_val; + atomics::detail::non_atomic_load(storage, old_val); + while (!Base::compare_exchange_weak(storage, old_val, old_val | v, order, memory_order_relaxed)) {} + return old_val; + } + + static BOOST_FORCEINLINE storage_type fetch_xor(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + storage_type old_val; + atomics::detail::non_atomic_load(storage, old_val); + while (!Base::compare_exchange_weak(storage, old_val, old_val ^ v, order, memory_order_relaxed)) {} + return old_val; + } + + static BOOST_FORCEINLINE bool test_and_set(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT + { + return !!Base::exchange(storage, (storage_type)1, order); + } + + static BOOST_FORCEINLINE void clear(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT + { + Base::store(storage, (storage_type)0, order); + } +}; + +} // namespace detail +} // namespace atomics +} // namespace boost + +#endif // BOOST_ATOMIC_DETAIL_OPS_CAS_BASED_HPP_INCLUDED_ diff --git a/libs/boost/include/boost/atomic/detail/ops_emulated.hpp b/libs/boost/include/boost/atomic/detail/ops_emulated.hpp new file mode 100644 index 0000000..e15f37a --- /dev/null +++ b/libs/boost/include/boost/atomic/detail/ops_emulated.hpp @@ -0,0 +1,158 @@ +/* + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or copy at + * http://www.boost.org/LICENSE_1_0.txt) + * + * Copyright (c) 2014 Andrey Semashev + */ +/*! + * \file atomic/detail/ops_emulated.hpp + * + * This header contains lockpool-based implementation of the \c operations template. + */ + +#ifndef BOOST_ATOMIC_DETAIL_OPS_EMULATED_HPP_INCLUDED_ +#define BOOST_ATOMIC_DETAIL_OPS_EMULATED_HPP_INCLUDED_ + +#include +#include +#include +#include +#include +#include +#include + +#ifdef BOOST_HAS_PRAGMA_ONCE +#pragma once +#endif + +namespace boost { +namespace atomics { +namespace detail { + +template< typename T > +struct emulated_operations +{ + typedef T storage_type; + + static BOOST_CONSTEXPR_OR_CONST bool is_always_lock_free = false; + + static BOOST_FORCEINLINE void store(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT + { + lockpool::scoped_lock lock(&storage); + const_cast< storage_type& >(storage) = v; + } + + static BOOST_FORCEINLINE storage_type load(storage_type const volatile& storage, memory_order) BOOST_NOEXCEPT + { + lockpool::scoped_lock lock(&storage); + return const_cast< storage_type const& >(storage); + } + + static BOOST_FORCEINLINE storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT + { + storage_type& s = const_cast< storage_type& >(storage); + lockpool::scoped_lock lock(&storage); + storage_type old_val = s; + s += v; + return old_val; + } + + static BOOST_FORCEINLINE storage_type fetch_sub(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT + { + storage_type& s = const_cast< storage_type& >(storage); + lockpool::scoped_lock lock(&storage); + storage_type old_val = s; + s -= v; + return old_val; + } + + static BOOST_FORCEINLINE storage_type exchange(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT + { + storage_type& s = const_cast< storage_type& >(storage); + lockpool::scoped_lock lock(&storage); + storage_type old_val = s; + s = v; + return old_val; + } + + static BOOST_FORCEINLINE bool compare_exchange_strong( + storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order, memory_order) BOOST_NOEXCEPT + { + storage_type& s = const_cast< storage_type& >(storage); + lockpool::scoped_lock lock(&storage); + storage_type old_val = s; + const bool res = old_val == expected; + if (res) + s = desired; + expected = old_val; + + return res; + } + + static BOOST_FORCEINLINE bool compare_exchange_weak( + storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order, memory_order) BOOST_NOEXCEPT + { + // Note: This function is the exact copy of compare_exchange_strong. The reason we're not just forwarding the call + // is that MSVC-12 ICEs in this case. + storage_type& s = const_cast< storage_type& >(storage); + lockpool::scoped_lock lock(&storage); + storage_type old_val = s; + const bool res = old_val == expected; + if (res) + s = desired; + expected = old_val; + + return res; + } + + static BOOST_FORCEINLINE storage_type fetch_and(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT + { + storage_type& s = const_cast< storage_type& >(storage); + lockpool::scoped_lock lock(&storage); + storage_type old_val = s; + s &= v; + return old_val; + } + + static BOOST_FORCEINLINE storage_type fetch_or(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT + { + storage_type& s = const_cast< storage_type& >(storage); + lockpool::scoped_lock lock(&storage); + storage_type old_val = s; + s |= v; + return old_val; + } + + static BOOST_FORCEINLINE storage_type fetch_xor(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT + { + storage_type& s = const_cast< storage_type& >(storage); + lockpool::scoped_lock lock(&storage); + storage_type old_val = s; + s ^= v; + return old_val; + } + + static BOOST_FORCEINLINE bool test_and_set(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT + { + return !!exchange(storage, (storage_type)1, order); + } + + static BOOST_FORCEINLINE void clear(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT + { + store(storage, (storage_type)0, order); + } +}; + +template< std::size_t Size, bool Signed > +struct operations : + public emulated_operations< typename make_storage_type< Size, Signed >::type > +{ + typedef typename make_storage_type< Size, Signed >::aligned aligned_storage_type; +}; + +} // namespace detail +} // namespace atomics +} // namespace boost + +#endif // BOOST_ATOMIC_DETAIL_OPS_EMULATED_HPP_INCLUDED_ diff --git a/libs/boost/include/boost/atomic/detail/ops_extending_cas_based.hpp b/libs/boost/include/boost/atomic/detail/ops_extending_cas_based.hpp new file mode 100644 index 0000000..3f21031 --- /dev/null +++ b/libs/boost/include/boost/atomic/detail/ops_extending_cas_based.hpp @@ -0,0 +1,68 @@ +/* + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or copy at + * http://www.boost.org/LICENSE_1_0.txt) + * + * Copyright (c) 2014 Andrey Semashev + */ +/*! + * \file atomic/detail/ops_extending_cas_based.hpp + * + * This header contains a boilerplate of the \c operations template implementation that requires sign/zero extension in arithmetic operations. + */ + +#ifndef BOOST_ATOMIC_DETAIL_OPS_EXTENDING_CAS_BASED_HPP_INCLUDED_ +#define BOOST_ATOMIC_DETAIL_OPS_EXTENDING_CAS_BASED_HPP_INCLUDED_ + +#include +#include +#include +#include + +#ifdef BOOST_HAS_PRAGMA_ONCE +#pragma once +#endif + +namespace boost { +namespace atomics { +namespace detail { + +template< typename Base, std::size_t Size, bool Signed > +struct extending_cas_based_operations : + public Base +{ + typedef typename Base::storage_type storage_type; + typedef typename make_storage_type< Size, Signed >::type emulated_storage_type; + + static BOOST_FORCEINLINE storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + storage_type old_val; + atomics::detail::non_atomic_load(storage, old_val); + emulated_storage_type new_val; + do + { + new_val = static_cast< emulated_storage_type >(old_val) + static_cast< emulated_storage_type >(v); + } + while (!Base::compare_exchange_weak(storage, old_val, static_cast< storage_type >(new_val), order, memory_order_relaxed)); + return old_val; + } + + static BOOST_FORCEINLINE storage_type fetch_sub(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + storage_type old_val; + atomics::detail::non_atomic_load(storage, old_val); + emulated_storage_type new_val; + do + { + new_val = static_cast< emulated_storage_type >(old_val) - static_cast< emulated_storage_type >(v); + } + while (!Base::compare_exchange_weak(storage, old_val, static_cast< storage_type >(new_val), order, memory_order_relaxed)); + return old_val; + } +}; + +} // namespace detail +} // namespace atomics +} // namespace boost + +#endif // BOOST_ATOMIC_DETAIL_OPS_EXTENDING_CAS_BASED_HPP_INCLUDED_ diff --git a/libs/boost/include/boost/atomic/detail/ops_gcc_alpha.hpp b/libs/boost/include/boost/atomic/detail/ops_gcc_alpha.hpp new file mode 100644 index 0000000..5a9deb4 --- /dev/null +++ b/libs/boost/include/boost/atomic/detail/ops_gcc_alpha.hpp @@ -0,0 +1,868 @@ +/* + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or copy at + * http://www.boost.org/LICENSE_1_0.txt) + * + * Copyright (c) 2009 Helge Bahmann + * Copyright (c) 2013 Tim Blechmann + * Copyright (c) 2014 Andrey Semashev + */ +/*! + * \file atomic/detail/ops_gcc_alpha.hpp + * + * This header contains implementation of the \c operations template. + */ + +#ifndef BOOST_ATOMIC_DETAIL_OPS_GCC_ALPHA_HPP_INCLUDED_ +#define BOOST_ATOMIC_DETAIL_OPS_GCC_ALPHA_HPP_INCLUDED_ + +#include +#include +#include +#include +#include + +#ifdef BOOST_HAS_PRAGMA_ONCE +#pragma once +#endif + +namespace boost { +namespace atomics { +namespace detail { + +/* + Refer to http://h71000.www7.hp.com/doc/82final/5601/5601pro_004.html + (HP OpenVMS systems documentation) and the Alpha Architecture Reference Manual. + */ + +/* + NB: The most natural thing would be to write the increment/decrement + operators along the following lines: + + __asm__ __volatile__ + ( + "1: ldl_l %0,%1 \n" + "addl %0,1,%0 \n" + "stl_c %0,%1 \n" + "beq %0,1b\n" + : "=&b" (tmp) + : "m" (value) + : "cc" + ); + + However according to the comments on the HP website and matching + comments in the Linux kernel sources this defies branch prediction, + as the cpu assumes that backward branches are always taken; so + instead copy the trick from the Linux kernel, introduce a forward + branch and back again. + + I have, however, had a hard time measuring the difference between + the two versions in microbenchmarks -- I am leaving it in nevertheless + as it apparently does not hurt either. +*/ + +struct gcc_alpha_operations_base +{ + static BOOST_CONSTEXPR_OR_CONST bool is_always_lock_free = true; + + static BOOST_FORCEINLINE void fence_before(memory_order order) BOOST_NOEXCEPT + { + if ((order & memory_order_release) != 0) + __asm__ __volatile__ ("mb" ::: "memory"); + } + + static BOOST_FORCEINLINE void fence_after(memory_order order) BOOST_NOEXCEPT + { + if ((order & (memory_order_consume | memory_order_acquire)) != 0) + __asm__ __volatile__ ("mb" ::: "memory"); + } + + static BOOST_FORCEINLINE void fence_after_store(memory_order order) BOOST_NOEXCEPT + { + if (order == memory_order_seq_cst) + __asm__ __volatile__ ("mb" ::: "memory"); + } +}; + + +template< bool Signed > +struct operations< 4u, Signed > : + public gcc_alpha_operations_base +{ + typedef typename make_storage_type< 4u, Signed >::type storage_type; + typedef typename make_storage_type< 4u, Signed >::aligned aligned_storage_type; + + static BOOST_FORCEINLINE void store(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + fence_before(order); + storage = v; + fence_after_store(order); + } + + static BOOST_FORCEINLINE storage_type load(storage_type const volatile& storage, memory_order order) BOOST_NOEXCEPT + { + storage_type v = storage; + fence_after(order); + return v; + } + + static BOOST_FORCEINLINE storage_type exchange(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + storage_type original, tmp; + fence_before(order); + __asm__ __volatile__ + ( + "1:\n" + "mov %3, %1\n" + "ldl_l %0, %2\n" + "stl_c %1, %2\n" + "beq %1, 2f\n" + + ".subsection 2\n" + "2: br 1b\n" + ".previous\n" + + : "=&r" (original), // %0 + "=&r" (tmp) // %1 + : "m" (storage), // %2 + "r" (v) // %3 + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC + ); + fence_after(order); + return original; + } + + static BOOST_FORCEINLINE bool compare_exchange_weak( + storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order success_order, memory_order failure_order) BOOST_NOEXCEPT + { + fence_before(success_order); + int success; + storage_type current; + __asm__ __volatile__ + ( + "1:\n" + "ldl_l %2, %4\n" // current = *(&storage) + "cmpeq %2, %0, %3\n" // success = current == expected + "mov %2, %0\n" // expected = current + "beq %3, 2f\n" // if (success == 0) goto end + "stl_c %1, %4\n" // storage = desired; desired = store succeeded + "mov %1, %3\n" // success = desired + "2:\n" + : "+&r" (expected), // %0 + "+&r" (desired), // %1 + "=&r" (current), // %2 + "=&r" (success) // %3 + : "m" (storage) // %4 + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC + ); + if (success) + fence_after(success_order); + else + fence_after(failure_order); + return !!success; + } + + static BOOST_FORCEINLINE bool compare_exchange_strong( + storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order success_order, memory_order failure_order) BOOST_NOEXCEPT + { + int success; + storage_type current, tmp; + fence_before(success_order); + __asm__ __volatile__ + ( + "1:\n" + "mov %5, %1\n" // tmp = desired + "ldl_l %2, %4\n" // current = *(&storage) + "cmpeq %2, %0, %3\n" // success = current == expected + "mov %2, %0\n" // expected = current + "beq %3, 2f\n" // if (success == 0) goto end + "stl_c %1, %4\n" // storage = tmp; tmp = store succeeded + "beq %1, 3f\n" // if (tmp == 0) goto retry + "mov %1, %3\n" // success = tmp + "2:\n" + + ".subsection 2\n" + "3: br 1b\n" + ".previous\n" + + : "+&r" (expected), // %0 + "=&r" (tmp), // %1 + "=&r" (current), // %2 + "=&r" (success) // %3 + : "m" (storage), // %4 + "r" (desired) // %5 + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC + ); + if (success) + fence_after(success_order); + else + fence_after(failure_order); + return !!success; + } + + static BOOST_FORCEINLINE storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + storage_type original, modified; + fence_before(order); + __asm__ __volatile__ + ( + "1:\n" + "ldl_l %0, %2\n" + "addl %0, %3, %1\n" + "stl_c %1, %2\n" + "beq %1, 2f\n" + + ".subsection 2\n" + "2: br 1b\n" + ".previous\n" + + : "=&r" (original), // %0 + "=&r" (modified) // %1 + : "m" (storage), // %2 + "r" (v) // %3 + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC + ); + fence_after(order); + return original; + } + + static BOOST_FORCEINLINE storage_type fetch_sub(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + storage_type original, modified; + fence_before(order); + __asm__ __volatile__ + ( + "1:\n" + "ldl_l %0, %2\n" + "subl %0, %3, %1\n" + "stl_c %1, %2\n" + "beq %1, 2f\n" + + ".subsection 2\n" + "2: br 1b\n" + ".previous\n" + + : "=&r" (original), // %0 + "=&r" (modified) // %1 + : "m" (storage), // %2 + "r" (v) // %3 + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC + ); + fence_after(order); + return original; + } + + static BOOST_FORCEINLINE storage_type fetch_and(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + storage_type original, modified; + fence_before(order); + __asm__ __volatile__ + ( + "1:\n" + "ldl_l %0, %2\n" + "and %0, %3, %1\n" + "stl_c %1, %2\n" + "beq %1, 2f\n" + + ".subsection 2\n" + "2: br 1b\n" + ".previous\n" + + : "=&r" (original), // %0 + "=&r" (modified) // %1 + : "m" (storage), // %2 + "r" (v) // %3 + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC + ); + fence_after(order); + return original; + } + + static BOOST_FORCEINLINE storage_type fetch_or(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + storage_type original, modified; + fence_before(order); + __asm__ __volatile__ + ( + "1:\n" + "ldl_l %0, %2\n" + "bis %0, %3, %1\n" + "stl_c %1, %2\n" + "beq %1, 2f\n" + + ".subsection 2\n" + "2: br 1b\n" + ".previous\n" + + : "=&r" (original), // %0 + "=&r" (modified) // %1 + : "m" (storage), // %2 + "r" (v) // %3 + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC + ); + fence_after(order); + return original; + } + + static BOOST_FORCEINLINE storage_type fetch_xor(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + storage_type original, modified; + fence_before(order); + __asm__ __volatile__ + ( + "1:\n" + "ldl_l %0, %2\n" + "xor %0, %3, %1\n" + "stl_c %1, %2\n" + "beq %1, 2f\n" + + ".subsection 2\n" + "2: br 1b\n" + ".previous\n" + + : "=&r" (original), // %0 + "=&r" (modified) // %1 + : "m" (storage), // %2 + "r" (v) // %3 + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC + ); + fence_after(order); + return original; + } + + static BOOST_FORCEINLINE bool test_and_set(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT + { + return !!exchange(storage, (storage_type)1, order); + } + + static BOOST_FORCEINLINE void clear(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT + { + store(storage, 0, order); + } +}; + + +template< > +struct operations< 1u, false > : + public operations< 4u, false > +{ + typedef operations< 4u, false > base_type; + typedef base_type::storage_type storage_type; + + static BOOST_FORCEINLINE storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + storage_type original, modified; + fence_before(order); + __asm__ __volatile__ + ( + "1:\n" + "ldl_l %0, %2\n" + "addl %0, %3, %1\n" + "zapnot %1, #1, %1\n" + "stl_c %1, %2\n" + "beq %1, 2f\n" + + ".subsection 2\n" + "2: br 1b\n" + ".previous\n" + + : "=&r" (original), // %0 + "=&r" (modified) // %1 + : "m" (storage), // %2 + "r" (v) // %3 + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC + ); + fence_after(order); + return original; + } + + static BOOST_FORCEINLINE storage_type fetch_sub(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + storage_type original, modified; + fence_before(order); + __asm__ __volatile__ + ( + "1:\n" + "ldl_l %0, %2\n" + "subl %0, %3, %1\n" + "zapnot %1, #1, %1\n" + "stl_c %1, %2\n" + "beq %1, 2f\n" + + ".subsection 2\n" + "2: br 1b\n" + ".previous\n" + + : "=&r" (original), // %0 + "=&r" (modified) // %1 + : "m" (storage), // %2 + "r" (v) // %3 + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC + ); + fence_after(order); + return original; + } +}; + +template< > +struct operations< 1u, true > : + public operations< 4u, true > +{ + typedef operations< 4u, true > base_type; + typedef base_type::storage_type storage_type; + + static BOOST_FORCEINLINE storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + storage_type original, modified; + fence_before(order); + __asm__ __volatile__ + ( + "1:\n" + "ldl_l %0, %2\n" + "addl %0, %3, %1\n" + "sextb %1, %1\n" + "stl_c %1, %2\n" + "beq %1, 2f\n" + + ".subsection 2\n" + "2: br 1b\n" + ".previous\n" + + : "=&r" (original), // %0 + "=&r" (modified) // %1 + : "m" (storage), // %2 + "r" (v) // %3 + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC + ); + fence_after(order); + return original; + } + + static BOOST_FORCEINLINE storage_type fetch_sub(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + storage_type original, modified; + fence_before(order); + __asm__ __volatile__ + ( + "1:\n" + "ldl_l %0, %2\n" + "subl %0, %3, %1\n" + "sextb %1, %1\n" + "stl_c %1, %2\n" + "beq %1, 2f\n" + + ".subsection 2\n" + "2: br 1b\n" + ".previous\n" + + : "=&r" (original), // %0 + "=&r" (modified) // %1 + : "m" (storage), // %2 + "r" (v) // %3 + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC + ); + fence_after(order); + return original; + } +}; + + +template< > +struct operations< 2u, false > : + public operations< 4u, false > +{ + typedef operations< 4u, false > base_type; + typedef base_type::storage_type storage_type; + + static BOOST_FORCEINLINE storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + storage_type original, modified; + fence_before(order); + __asm__ __volatile__ + ( + "1:\n" + "ldl_l %0, %2\n" + "addl %0, %3, %1\n" + "zapnot %1, #3, %1\n" + "stl_c %1, %2\n" + "beq %1, 2f\n" + + ".subsection 2\n" + "2: br 1b\n" + ".previous\n" + + : "=&r" (original), // %0 + "=&r" (modified) // %1 + : "m" (storage), // %2 + "r" (v) // %3 + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC + ); + fence_after(order); + return original; + } + + static BOOST_FORCEINLINE storage_type fetch_sub(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + storage_type original, modified; + fence_before(order); + __asm__ __volatile__ + ( + "1:\n" + "ldl_l %0, %2\n" + "subl %0, %3, %1\n" + "zapnot %1, #3, %1\n" + "stl_c %1, %2\n" + "beq %1, 2f\n" + + ".subsection 2\n" + "2: br 1b\n" + ".previous\n" + + : "=&r" (original), // %0 + "=&r" (modified) // %1 + : "m" (storage), // %2 + "r" (v) // %3 + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC + ); + fence_after(order); + return original; + } +}; + +template< > +struct operations< 2u, true > : + public operations< 4u, true > +{ + typedef operations< 4u, true > base_type; + typedef base_type::storage_type storage_type; + + static BOOST_FORCEINLINE storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + storage_type original, modified; + fence_before(order); + __asm__ __volatile__ + ( + "1:\n" + "ldl_l %0, %2\n" + "addl %0, %3, %1\n" + "sextw %1, %1\n" + "stl_c %1, %2\n" + "beq %1, 2f\n" + + ".subsection 2\n" + "2: br 1b\n" + ".previous\n" + + : "=&r" (original), // %0 + "=&r" (modified) // %1 + : "m" (storage), // %2 + "r" (v) // %3 + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC + ); + fence_after(order); + return original; + } + + static BOOST_FORCEINLINE storage_type fetch_sub(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + storage_type original, modified; + fence_before(order); + __asm__ __volatile__ + ( + "1:\n" + "ldl_l %0, %2\n" + "subl %0, %3, %1\n" + "sextw %1, %1\n" + "stl_c %1, %2\n" + "beq %1, 2f\n" + + ".subsection 2\n" + "2: br 1b\n" + ".previous\n" + + : "=&r" (original), // %0 + "=&r" (modified) // %1 + : "m" (storage), // %2 + "r" (v) // %3 + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC + ); + fence_after(order); + return original; + } +}; + + +template< bool Signed > +struct operations< 8u, Signed > : + public gcc_alpha_operations_base +{ + typedef typename make_storage_type< 8u, Signed >::type storage_type; + typedef typename make_storage_type< 8u, Signed >::aligned aligned_storage_type; + + static BOOST_FORCEINLINE void store(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + fence_before(order); + storage = v; + fence_after_store(order); + } + + static BOOST_FORCEINLINE storage_type load(storage_type const volatile& storage, memory_order order) BOOST_NOEXCEPT + { + storage_type v = storage; + fence_after(order); + return v; + } + + static BOOST_FORCEINLINE storage_type exchange(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + storage_type original, tmp; + fence_before(order); + __asm__ __volatile__ + ( + "1:\n" + "mov %3, %1\n" + "ldq_l %0, %2\n" + "stq_c %1, %2\n" + "beq %1, 2f\n" + + ".subsection 2\n" + "2: br 1b\n" + ".previous\n" + + : "=&r" (original), // %0 + "=&r" (tmp) // %1 + : "m" (storage), // %2 + "r" (v) // %3 + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC + ); + fence_after(order); + return original; + } + + static BOOST_FORCEINLINE bool compare_exchange_weak( + storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order success_order, memory_order failure_order) BOOST_NOEXCEPT + { + fence_before(success_order); + int success; + storage_type current; + __asm__ __volatile__ + ( + "1:\n" + "ldq_l %2, %4\n" // current = *(&storage) + "cmpeq %2, %0, %3\n" // success = current == expected + "mov %2, %0\n" // expected = current + "beq %3, 2f\n" // if (success == 0) goto end + "stq_c %1, %4\n" // storage = desired; desired = store succeeded + "mov %1, %3\n" // success = desired + "2:\n" + : "+&r" (expected), // %0 + "+&r" (desired), // %1 + "=&r" (current), // %2 + "=&r" (success) // %3 + : "m" (storage) // %4 + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC + ); + if (success) + fence_after(success_order); + else + fence_after(failure_order); + return !!success; + } + + static BOOST_FORCEINLINE bool compare_exchange_strong( + storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order success_order, memory_order failure_order) BOOST_NOEXCEPT + { + int success; + storage_type current, tmp; + fence_before(success_order); + __asm__ __volatile__ + ( + "1:\n" + "mov %5, %1\n" // tmp = desired + "ldq_l %2, %4\n" // current = *(&storage) + "cmpeq %2, %0, %3\n" // success = current == expected + "mov %2, %0\n" // expected = current + "beq %3, 2f\n" // if (success == 0) goto end + "stq_c %1, %4\n" // storage = tmp; tmp = store succeeded + "beq %1, 3f\n" // if (tmp == 0) goto retry + "mov %1, %3\n" // success = tmp + "2:\n" + + ".subsection 2\n" + "3: br 1b\n" + ".previous\n" + + : "+&r" (expected), // %0 + "=&r" (tmp), // %1 + "=&r" (current), // %2 + "=&r" (success) // %3 + : "m" (storage), // %4 + "r" (desired) // %5 + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC + ); + if (success) + fence_after(success_order); + else + fence_after(failure_order); + return !!success; + } + + static BOOST_FORCEINLINE storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + storage_type original, modified; + fence_before(order); + __asm__ __volatile__ + ( + "1:\n" + "ldq_l %0, %2\n" + "addq %0, %3, %1\n" + "stq_c %1, %2\n" + "beq %1, 2f\n" + + ".subsection 2\n" + "2: br 1b\n" + ".previous\n" + + : "=&r" (original), // %0 + "=&r" (modified) // %1 + : "m" (storage), // %2 + "r" (v) // %3 + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC + ); + fence_after(order); + return original; + } + + static BOOST_FORCEINLINE storage_type fetch_sub(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + storage_type original, modified; + fence_before(order); + __asm__ __volatile__ + ( + "1:\n" + "ldq_l %0, %2\n" + "subq %0, %3, %1\n" + "stq_c %1, %2\n" + "beq %1, 2f\n" + + ".subsection 2\n" + "2: br 1b\n" + ".previous\n" + + : "=&r" (original), // %0 + "=&r" (modified) // %1 + : "m" (storage), // %2 + "r" (v) // %3 + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC + ); + fence_after(order); + return original; + } + + static BOOST_FORCEINLINE storage_type fetch_and(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + storage_type original, modified; + fence_before(order); + __asm__ __volatile__ + ( + "1:\n" + "ldq_l %0, %2\n" + "and %0, %3, %1\n" + "stq_c %1, %2\n" + "beq %1, 2f\n" + + ".subsection 2\n" + "2: br 1b\n" + ".previous\n" + + : "=&r" (original), // %0 + "=&r" (modified) // %1 + : "m" (storage), // %2 + "r" (v) // %3 + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC + ); + fence_after(order); + return original; + } + + static BOOST_FORCEINLINE storage_type fetch_or(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + storage_type original, modified; + fence_before(order); + __asm__ __volatile__ + ( + "1:\n" + "ldq_l %0, %2\n" + "bis %0, %3, %1\n" + "stq_c %1, %2\n" + "beq %1, 2f\n" + + ".subsection 2\n" + "2: br 1b\n" + ".previous\n" + + : "=&r" (original), // %0 + "=&r" (modified) // %1 + : "m" (storage), // %2 + "r" (v) // %3 + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC + ); + fence_after(order); + return original; + } + + static BOOST_FORCEINLINE storage_type fetch_xor(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + storage_type original, modified; + fence_before(order); + __asm__ __volatile__ + ( + "1:\n" + "ldq_l %0, %2\n" + "xor %0, %3, %1\n" + "stq_c %1, %2\n" + "beq %1, 2f\n" + + ".subsection 2\n" + "2: br 1b\n" + ".previous\n" + + : "=&r" (original), // %0 + "=&r" (modified) // %1 + : "m" (storage), // %2 + "r" (v) // %3 + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC + ); + fence_after(order); + return original; + } + + static BOOST_FORCEINLINE bool test_and_set(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT + { + return !!exchange(storage, (storage_type)1, order); + } + + static BOOST_FORCEINLINE void clear(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT + { + store(storage, 0, order); + } +}; + + +BOOST_FORCEINLINE void thread_fence(memory_order order) BOOST_NOEXCEPT +{ + if (order != memory_order_relaxed) + __asm__ __volatile__ ("mb" ::: "memory"); +} + +BOOST_FORCEINLINE void signal_fence(memory_order order) BOOST_NOEXCEPT +{ + if (order != memory_order_relaxed) + __asm__ __volatile__ ("" ::: "memory"); +} + +} // namespace detail +} // namespace atomics +} // namespace boost + +#endif // BOOST_ATOMIC_DETAIL_OPS_GCC_ALPHA_HPP_INCLUDED_ diff --git a/libs/boost/include/boost/atomic/detail/ops_gcc_arm.hpp b/libs/boost/include/boost/atomic/detail/ops_gcc_arm.hpp new file mode 100644 index 0000000..86a75f5 --- /dev/null +++ b/libs/boost/include/boost/atomic/detail/ops_gcc_arm.hpp @@ -0,0 +1,965 @@ +/* + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or copy at + * http://www.boost.org/LICENSE_1_0.txt) + * + * Copyright (c) 2009 Helge Bahmann + * Copyright (c) 2013 Tim Blechmann + * Copyright (c) 2014 Andrey Semashev + */ +/*! + * \file atomic/detail/ops_gcc_arm.hpp + * + * This header contains implementation of the \c operations template. + */ + +#ifndef BOOST_ATOMIC_DETAIL_OPS_GCC_ARM_HPP_INCLUDED_ +#define BOOST_ATOMIC_DETAIL_OPS_GCC_ARM_HPP_INCLUDED_ + +#include +#include +#include +#include +#include +#include +#include + +#ifdef BOOST_HAS_PRAGMA_ONCE +#pragma once +#endif + +namespace boost { +namespace atomics { +namespace detail { + +// From the ARM Architecture Reference Manual for architecture v6: +// +// LDREX{} , [] +// Specifies the destination register for the memory word addressed by +// Specifies the register containing the address. +// +// STREX{} , , [] +// Specifies the destination register for the returned status value. +// 0 if the operation updates memory +// 1 if the operation fails to update memory +// Specifies the register containing the word to be stored to memory. +// Specifies the register containing the address. +// Rd must not be the same register as Rm or Rn. +// +// ARM v7 is like ARM v6 plus: +// There are half-word and byte versions of the LDREX and STREX instructions, +// LDREXH, LDREXB, STREXH and STREXB. +// There are also double-word versions, LDREXD and STREXD. +// (Actually it looks like these are available from version 6k onwards.) +// FIXME these are not yet used; should be mostly a matter of copy-and-paste. +// I think you can supply an immediate offset to the address. +// +// A memory barrier is effected using a "co-processor 15" instruction, +// though a separate assembler mnemonic is available for it in v7. +// +// "Thumb 1" is a subset of the ARM instruction set that uses a 16-bit encoding. It +// doesn't include all instructions and in particular it doesn't include the co-processor +// instruction used for the memory barrier or the load-locked/store-conditional +// instructions. So, if we're compiling in "Thumb 1" mode, we need to wrap all of our +// asm blocks with code to temporarily change to ARM mode. +// +// You can only change between ARM and Thumb modes when branching using the bx instruction. +// bx takes an address specified in a register. The least significant bit of the address +// indicates the mode, so 1 is added to indicate that the destination code is Thumb. +// A temporary register is needed for the address and is passed as an argument to these +// macros. It must be one of the "low" registers accessible to Thumb code, specified +// using the "l" attribute in the asm statement. +// +// Architecture v7 introduces "Thumb 2", which does include (almost?) all of the ARM +// instruction set. (Actually, there was an extension of v6 called v6T2 which supported +// "Thumb 2" mode, but its architecture manual is no longer available, referring to v7.) +// So in v7 we don't need to change to ARM mode; we can write "universal +// assembler" which will assemble to Thumb 2 or ARM code as appropriate. The only thing +// we need to do to make this "universal" assembler mode work is to insert "IT" instructions +// to annotate the conditional instructions. These are ignored in other modes (e.g. v6), +// so they can always be present. + +// A note about memory_order_consume. Technically, this architecture allows to avoid +// unnecessary memory barrier after consume load since it supports data dependency ordering. +// However, some compiler optimizations may break a seemingly valid code relying on data +// dependency tracking by injecting bogus branches to aid out of order execution. +// This may happen not only in Boost.Atomic code but also in user's code, which we have no +// control of. See this thread: http://lists.boost.org/Archives/boost/2014/06/213890.php. +// For this reason we promote memory_order_consume to memory_order_acquire. + +#if defined(__thumb__) && !defined(__thumb2__) +#define BOOST_ATOMIC_DETAIL_ARM_ASM_START(TMPREG) "adr " #TMPREG ", 8f\n" "bx " #TMPREG "\n" ".arm\n" ".align 4\n" "8:\n" +#define BOOST_ATOMIC_DETAIL_ARM_ASM_END(TMPREG) "adr " #TMPREG ", 9f + 1\n" "bx " #TMPREG "\n" ".thumb\n" ".align 2\n" "9:\n" +#define BOOST_ATOMIC_DETAIL_ARM_ASM_TMPREG_CONSTRAINT(var) "=&l" (var) +#else +// The tmpreg may be wasted in this case, which is non-optimal. +#define BOOST_ATOMIC_DETAIL_ARM_ASM_START(TMPREG) +#define BOOST_ATOMIC_DETAIL_ARM_ASM_END(TMPREG) +#define BOOST_ATOMIC_DETAIL_ARM_ASM_TMPREG_CONSTRAINT(var) "=&r" (var) +#endif + +struct gcc_arm_operations_base +{ + static BOOST_CONSTEXPR_OR_CONST bool is_always_lock_free = true; + + static BOOST_FORCEINLINE void fence_before(memory_order order) BOOST_NOEXCEPT + { + if ((order & memory_order_release) != 0) + hardware_full_fence(); + } + + static BOOST_FORCEINLINE void fence_after(memory_order order) BOOST_NOEXCEPT + { + if ((order & (memory_order_consume | memory_order_acquire)) != 0) + hardware_full_fence(); + } + + static BOOST_FORCEINLINE void fence_after_store(memory_order order) BOOST_NOEXCEPT + { + if (order == memory_order_seq_cst) + hardware_full_fence(); + } + + static BOOST_FORCEINLINE void hardware_full_fence() BOOST_NOEXCEPT + { +#if defined(BOOST_ATOMIC_DETAIL_ARM_HAS_DMB) + // Older binutils (supposedly, older than 2.21.1) didn't support symbolic or numeric arguments of the "dmb" instruction such as "ish" or "#11". + // As a workaround we have to inject encoded bytes of the instruction. There are two encodings for the instruction: ARM and Thumb. See ARM Architecture Reference Manual, A8.8.43. + // Since we cannot detect binutils version at compile time, we'll have to always use this hack. + __asm__ __volatile__ + ( +#if defined(__thumb2__) + ".short 0xF3BF, 0x8F5B\n" // dmb ish +#else + ".word 0xF57FF05B\n" // dmb ish +#endif + : + : + : "memory" + ); +#else + int tmp; + __asm__ __volatile__ + ( + BOOST_ATOMIC_DETAIL_ARM_ASM_START(%0) + "mcr\tp15, 0, r0, c7, c10, 5\n" + BOOST_ATOMIC_DETAIL_ARM_ASM_END(%0) + : "=&l" (tmp) + : + : "memory" + ); +#endif + } +}; + + +template< bool Signed > +struct operations< 4u, Signed > : + public gcc_arm_operations_base +{ + typedef typename make_storage_type< 4u, Signed >::type storage_type; + typedef typename make_storage_type< 4u, Signed >::aligned aligned_storage_type; + + static BOOST_FORCEINLINE void store(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + fence_before(order); + storage = v; + fence_after_store(order); + } + + static BOOST_FORCEINLINE storage_type load(storage_type const volatile& storage, memory_order order) BOOST_NOEXCEPT + { + storage_type v = storage; + fence_after(order); + return v; + } + + static BOOST_FORCEINLINE storage_type exchange(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + storage_type original; + fence_before(order); + uint32_t tmp; + __asm__ __volatile__ + ( + BOOST_ATOMIC_DETAIL_ARM_ASM_START(%[tmp]) + "1:\n" + "ldrex %[original], %[storage]\n" // load the original value + "strex %[tmp], %[value], %[storage]\n" // store the replacement, tmp = store failed + "teq %[tmp], #0\n" // check if store succeeded + "bne 1b\n" + BOOST_ATOMIC_DETAIL_ARM_ASM_END(%[tmp]) + : [tmp] "=&l" (tmp), [original] "=&r" (original), [storage] "+Q" (storage) + : [value] "r" (v) + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC + ); + fence_after(order); + return original; + } + + static BOOST_FORCEINLINE bool compare_exchange_weak( + storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order success_order, memory_order failure_order) BOOST_NOEXCEPT + { + fence_before(success_order); + uint32_t success; + uint32_t tmp; + storage_type original; + __asm__ __volatile__ + ( + BOOST_ATOMIC_DETAIL_ARM_ASM_START(%[tmp]) + "mov %[success], #0\n" // success = 0 + "ldrex %[original], %[storage]\n" // original = *(&storage) + "cmp %[original], %[expected]\n" // flags = original==expected + "itt eq\n" // [hint that the following 2 instructions are conditional on flags.equal] + "strexeq %[success], %[desired], %[storage]\n" // if (flags.equal) *(&storage) = desired, success = store failed + "eoreq %[success], %[success], #1\n" // if (flags.equal) success ^= 1 (i.e. make it 1 if store succeeded) + BOOST_ATOMIC_DETAIL_ARM_ASM_END(%[tmp]) + : [original] "=&r" (original), // %0 + [success] "=&r" (success), // %1 + [tmp] "=&l" (tmp), // %2 + [storage] "+Q" (storage) // %3 + : [expected] "r" (expected), // %4 + [desired] "r" (desired) // %5 + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC + ); + if (success) + fence_after(success_order); + else + fence_after(failure_order); + expected = original; + return !!success; + } + + static BOOST_FORCEINLINE bool compare_exchange_strong( + storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order success_order, memory_order failure_order) BOOST_NOEXCEPT + { + fence_before(success_order); + uint32_t success; + uint32_t tmp; + storage_type original; + __asm__ __volatile__ + ( + BOOST_ATOMIC_DETAIL_ARM_ASM_START(%[tmp]) + "mov %[success], #0\n" // success = 0 + "1:\n" + "ldrex %[original], %[storage]\n" // original = *(&storage) + "cmp %[original], %[expected]\n" // flags = original==expected + "bne 2f\n" // if (!flags.equal) goto end + "strex %[success], %[desired], %[storage]\n" // *(&storage) = desired, success = store failed + "eors %[success], %[success], #1\n" // success ^= 1 (i.e. make it 1 if store succeeded); flags.equal = success == 0 + "beq 1b\n" // if (flags.equal) goto retry + "2:\n" + BOOST_ATOMIC_DETAIL_ARM_ASM_END(%[tmp]) + : [original] "=&r" (original), // %0 + [success] "=&r" (success), // %1 + [tmp] "=&l" (tmp), // %2 + [storage] "+Q" (storage) // %3 + : [expected] "r" (expected), // %4 + [desired] "r" (desired) // %5 + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC + ); + if (success) + fence_after(success_order); + else + fence_after(failure_order); + expected = original; + return !!success; + } + + static BOOST_FORCEINLINE storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + fence_before(order); + uint32_t tmp; + storage_type original, result; + __asm__ __volatile__ + ( + BOOST_ATOMIC_DETAIL_ARM_ASM_START(%[tmp]) + "1:\n" + "ldrex %[original], %[storage]\n" // original = *(&storage) + "add %[result], %[original], %[value]\n" // result = original + value + "strex %[tmp], %[result], %[storage]\n" // *(&storage) = result, tmp = store failed + "teq %[tmp], #0\n" // flags = tmp==0 + "bne 1b\n" // if (!flags.equal) goto retry + BOOST_ATOMIC_DETAIL_ARM_ASM_END(%[tmp]) + : [original] "=&r" (original), // %0 + [result] "=&r" (result), // %1 + [tmp] "=&l" (tmp), // %2 + [storage] "+Q" (storage) // %3 + : [value] "r" (v) // %4 + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC + ); + fence_after(order); + return original; + } + + static BOOST_FORCEINLINE storage_type fetch_sub(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + fence_before(order); + uint32_t tmp; + storage_type original, result; + __asm__ __volatile__ + ( + BOOST_ATOMIC_DETAIL_ARM_ASM_START(%[tmp]) + "1:\n" + "ldrex %[original], %[storage]\n" // original = *(&storage) + "sub %[result], %[original], %[value]\n" // result = original - value + "strex %[tmp], %[result], %[storage]\n" // *(&storage) = result, tmp = store failed + "teq %[tmp], #0\n" // flags = tmp==0 + "bne 1b\n" // if (!flags.equal) goto retry + BOOST_ATOMIC_DETAIL_ARM_ASM_END(%[tmp]) + : [original] "=&r" (original), // %0 + [result] "=&r" (result), // %1 + [tmp] "=&l" (tmp), // %2 + [storage] "+Q" (storage) // %3 + : [value] "r" (v) // %4 + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC + ); + fence_after(order); + return original; + } + + static BOOST_FORCEINLINE storage_type fetch_and(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + fence_before(order); + uint32_t tmp; + storage_type original, result; + __asm__ __volatile__ + ( + BOOST_ATOMIC_DETAIL_ARM_ASM_START(%[tmp]) + "1:\n" + "ldrex %[original], %[storage]\n" // original = *(&storage) + "and %[result], %[original], %[value]\n" // result = original & value + "strex %[tmp], %[result], %[storage]\n" // *(&storage) = result, tmp = store failed + "teq %[tmp], #0\n" // flags = tmp==0 + "bne 1b\n" // if (!flags.equal) goto retry + BOOST_ATOMIC_DETAIL_ARM_ASM_END(%[tmp]) + : [original] "=&r" (original), // %0 + [result] "=&r" (result), // %1 + [tmp] "=&l" (tmp), // %2 + [storage] "+Q" (storage) // %3 + : [value] "r" (v) // %4 + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC + ); + fence_after(order); + return original; + } + + static BOOST_FORCEINLINE storage_type fetch_or(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + fence_before(order); + uint32_t tmp; + storage_type original, result; + __asm__ __volatile__ + ( + BOOST_ATOMIC_DETAIL_ARM_ASM_START(%[tmp]) + "1:\n" + "ldrex %[original], %[storage]\n" // original = *(&storage) + "orr %[result], %[original], %[value]\n" // result = original | value + "strex %[tmp], %[result], %[storage]\n" // *(&storage) = result, tmp = store failed + "teq %[tmp], #0\n" // flags = tmp==0 + "bne 1b\n" // if (!flags.equal) goto retry + BOOST_ATOMIC_DETAIL_ARM_ASM_END(%[tmp]) + : [original] "=&r" (original), // %0 + [result] "=&r" (result), // %1 + [tmp] "=&l" (tmp), // %2 + [storage] "+Q" (storage) // %3 + : [value] "r" (v) // %4 + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC + ); + fence_after(order); + return original; + } + + static BOOST_FORCEINLINE storage_type fetch_xor(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + fence_before(order); + uint32_t tmp; + storage_type original, result; + __asm__ __volatile__ + ( + BOOST_ATOMIC_DETAIL_ARM_ASM_START(%[tmp]) + "1:\n" + "ldrex %[original], %[storage]\n" // original = *(&storage) + "eor %[result], %[original], %[value]\n" // result = original ^ value + "strex %[tmp], %[result], %[storage]\n" // *(&storage) = result, tmp = store failed + "teq %[tmp], #0\n" // flags = tmp==0 + "bne 1b\n" // if (!flags.equal) goto retry + BOOST_ATOMIC_DETAIL_ARM_ASM_END(%[tmp]) + : [original] "=&r" (original), // %0 + [result] "=&r" (result), // %1 + [tmp] "=&l" (tmp), // %2 + [storage] "+Q" (storage) // %3 + : [value] "r" (v) // %4 + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC + ); + fence_after(order); + return original; + } + + static BOOST_FORCEINLINE bool test_and_set(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT + { + return !!exchange(storage, (storage_type)1, order); + } + + static BOOST_FORCEINLINE void clear(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT + { + store(storage, 0, order); + } +}; + + +template< > +struct operations< 1u, false > : + public operations< 4u, false > +{ + typedef operations< 4u, false > base_type; + typedef base_type::storage_type storage_type; + + static BOOST_FORCEINLINE storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + fence_before(order); + uint32_t tmp; + storage_type original, result; + __asm__ __volatile__ + ( + BOOST_ATOMIC_DETAIL_ARM_ASM_START(%[tmp]) + "1:\n" + "ldrex %[original], %[storage]\n" // original = *(&storage) + "add %[result], %[original], %[value]\n" // result = original + value + "uxtb %[result], %[result]\n" // zero extend result from 8 to 32 bits + "strex %[tmp], %[result], %[storage]\n" // *(&storage) = result, tmp = store failed + "teq %[tmp], #0\n" // flags = tmp==0 + "bne 1b\n" // if (!flags.equal) goto retry + BOOST_ATOMIC_DETAIL_ARM_ASM_END(%[tmp]) + : [original] "=&r" (original), // %0 + [result] "=&r" (result), // %1 + [tmp] "=&l" (tmp), // %2 + [storage] "+Q" (storage) // %3 + : [value] "r" (v) // %4 + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC + ); + fence_after(order); + return original; + } + + static BOOST_FORCEINLINE storage_type fetch_sub(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + fence_before(order); + uint32_t tmp; + storage_type original, result; + __asm__ __volatile__ + ( + BOOST_ATOMIC_DETAIL_ARM_ASM_START(%[tmp]) + "1:\n" + "ldrex %[original], %[storage]\n" // original = *(&storage) + "sub %[result], %[original], %[value]\n" // result = original - value + "uxtb %[result], %[result]\n" // zero extend result from 8 to 32 bits + "strex %[tmp], %[result], %[storage]\n" // *(&storage) = result, tmp = store failed + "teq %[tmp], #0\n" // flags = tmp==0 + "bne 1b\n" // if (!flags.equal) goto retry + BOOST_ATOMIC_DETAIL_ARM_ASM_END(%[tmp]) + : [original] "=&r" (original), // %0 + [result] "=&r" (result), // %1 + [tmp] "=&l" (tmp), // %2 + [storage] "+Q" (storage) // %3 + : [value] "r" (v) // %4 + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC + ); + fence_after(order); + return original; + } +}; + +template< > +struct operations< 1u, true > : + public operations< 4u, true > +{ + typedef operations< 4u, true > base_type; + typedef base_type::storage_type storage_type; + + static BOOST_FORCEINLINE storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + fence_before(order); + uint32_t tmp; + storage_type original, result; + __asm__ __volatile__ + ( + BOOST_ATOMIC_DETAIL_ARM_ASM_START(%[tmp]) + "1:\n" + "ldrex %[original], %[storage]\n" // original = *(&storage) + "add %[result], %[original], %[value]\n" // result = original + value + "sxtb %[result], %[result]\n" // sign extend result from 8 to 32 bits + "strex %[tmp], %[result], %[storage]\n" // *(&storage) = result, tmp = store failed + "teq %[tmp], #0\n" // flags = tmp==0 + "bne 1b\n" // if (!flags.equal) goto retry + BOOST_ATOMIC_DETAIL_ARM_ASM_END(%[tmp]) + : [original] "=&r" (original), // %0 + [result] "=&r" (result), // %1 + [tmp] "=&l" (tmp), // %2 + [storage] "+Q" (storage) // %3 + : [value] "r" (v) // %4 + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC + ); + fence_after(order); + return original; + } + + static BOOST_FORCEINLINE storage_type fetch_sub(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + fence_before(order); + uint32_t tmp; + storage_type original, result; + __asm__ __volatile__ + ( + BOOST_ATOMIC_DETAIL_ARM_ASM_START(%[tmp]) + "1:\n" + "ldrex %[original], %[storage]\n" // original = *(&storage) + "sub %[result], %[original], %[value]\n" // result = original - value + "sxtb %[result], %[result]\n" // sign extend result from 8 to 32 bits + "strex %[tmp], %[result], %[storage]\n" // *(&storage) = result, tmp = store failed + "teq %[tmp], #0\n" // flags = tmp==0 + "bne 1b\n" // if (!flags.equal) goto retry + BOOST_ATOMIC_DETAIL_ARM_ASM_END(%[tmp]) + : [original] "=&r" (original), // %0 + [result] "=&r" (result), // %1 + [tmp] "=&l" (tmp), // %2 + [storage] "+Q" (storage) // %3 + : [value] "r" (v) // %4 + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC + ); + fence_after(order); + return original; + } +}; + + +template< > +struct operations< 2u, false > : + public operations< 4u, false > +{ + typedef operations< 4u, false > base_type; + typedef base_type::storage_type storage_type; + + static BOOST_FORCEINLINE storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + fence_before(order); + uint32_t tmp; + storage_type original, result; + __asm__ __volatile__ + ( + BOOST_ATOMIC_DETAIL_ARM_ASM_START(%[tmp]) + "1:\n" + "ldrex %[original], %[storage]\n" // original = *(&storage) + "add %[result], %[original], %[value]\n" // result = original + value + "uxth %[result], %[result]\n" // zero extend result from 16 to 32 bits + "strex %[tmp], %[result], %[storage]\n" // *(&storage) = result, tmp = store failed + "teq %[tmp], #0\n" // flags = tmp==0 + "bne 1b\n" // if (!flags.equal) goto retry + BOOST_ATOMIC_DETAIL_ARM_ASM_END(%[tmp]) + : [original] "=&r" (original), // %0 + [result] "=&r" (result), // %1 + [tmp] "=&l" (tmp), // %2 + [storage] "+Q" (storage) // %3 + : [value] "r" (v) // %4 + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC + ); + fence_after(order); + return original; + } + + static BOOST_FORCEINLINE storage_type fetch_sub(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + fence_before(order); + uint32_t tmp; + storage_type original, result; + __asm__ __volatile__ + ( + BOOST_ATOMIC_DETAIL_ARM_ASM_START(%[tmp]) + "1:\n" + "ldrex %[original], %[storage]\n" // original = *(&storage) + "sub %[result], %[original], %[value]\n" // result = original - value + "uxth %[result], %[result]\n" // zero extend result from 16 to 32 bits + "strex %[tmp], %[result], %[storage]\n" // *(&storage) = result, tmp = store failed + "teq %[tmp], #0\n" // flags = tmp==0 + "bne 1b\n" // if (!flags.equal) goto retry + BOOST_ATOMIC_DETAIL_ARM_ASM_END(%[tmp]) + : [original] "=&r" (original), // %0 + [result] "=&r" (result), // %1 + [tmp] "=&l" (tmp), // %2 + [storage] "+Q" (storage) // %3 + : [value] "r" (v) // %4 + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC + ); + fence_after(order); + return original; + } +}; + +template< > +struct operations< 2u, true > : + public operations< 4u, true > +{ + typedef operations< 4u, true > base_type; + typedef base_type::storage_type storage_type; + + static BOOST_FORCEINLINE storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + fence_before(order); + uint32_t tmp; + storage_type original, result; + __asm__ __volatile__ + ( + BOOST_ATOMIC_DETAIL_ARM_ASM_START(%[tmp]) + "1:\n" + "ldrex %[original], %[storage]\n" // original = *(&storage) + "add %[result], %[original], %[value]\n" // result = original + value + "sxth %[result], %[result]\n" // sign extend result from 16 to 32 bits + "strex %[tmp], %[result], %[storage]\n" // *(&storage) = result, tmp = store failed + "teq %[tmp], #0\n" // flags = tmp==0 + "bne 1b\n" // if (!flags.equal) goto retry + BOOST_ATOMIC_DETAIL_ARM_ASM_END(%[tmp]) + : [original] "=&r" (original), // %0 + [result] "=&r" (result), // %1 + [tmp] "=&l" (tmp), // %2 + [storage] "+Q" (storage) // %3 + : [value] "r" (v) // %4 + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC + ); + fence_after(order); + return original; + } + + static BOOST_FORCEINLINE storage_type fetch_sub(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + fence_before(order); + uint32_t tmp; + storage_type original, result; + __asm__ __volatile__ + ( + BOOST_ATOMIC_DETAIL_ARM_ASM_START(%[tmp]) + "1:\n" + "ldrex %[original], %[storage]\n" // original = *(&storage) + "sub %[result], %[original], %[value]\n" // result = original - value + "sxth %[result], %[result]\n" // sign extend result from 16 to 32 bits + "strex %[tmp], %[result], %[storage]\n" // *(&storage) = result, tmp = store failed + "teq %[tmp], #0\n" // flags = tmp==0 + "bne 1b\n" // if (!flags.equal) goto retry + BOOST_ATOMIC_DETAIL_ARM_ASM_END(%[tmp]) + : [original] "=&r" (original), // %0 + [result] "=&r" (result), // %1 + [tmp] "=&l" (tmp), // %2 + [storage] "+Q" (storage) // %3 + : [value] "r" (v) // %4 + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC + ); + fence_after(order); + return original; + } +}; + + +#if defined(BOOST_ATOMIC_DETAIL_ARM_HAS_LDREXD_STREXD) + +// Unlike 32-bit operations, for 64-bit loads and stores we must use ldrexd/strexd. +// Any other instructions result in a non-atomic sequence of 32-bit accesses. +// See "ARM Architecture Reference Manual ARMv7-A and ARMv7-R edition", +// Section A3.5.3 "Atomicity in the ARM architecture". + +// In the asm blocks below we have to use 32-bit register pairs to compose 64-bit values. +// In order to pass the 64-bit operands to/from asm blocks, we use undocumented gcc feature: +// the lower half (Rt) of the operand is accessible normally, via the numbered placeholder (e.g. %0), +// and the upper half (Rt2) - via the same placeholder with an 'H' after the '%' sign (e.g. %H0). +// See: http://hardwarebug.org/2010/07/06/arm-inline-asm-secrets/ + +template< bool Signed > +struct operations< 8u, Signed > : + public gcc_arm_operations_base +{ + typedef typename make_storage_type< 8u, Signed >::type storage_type; + typedef typename make_storage_type< 8u, Signed >::aligned aligned_storage_type; + + static BOOST_FORCEINLINE void store(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + exchange(storage, v, order); + } + + static BOOST_FORCEINLINE storage_type load(storage_type const volatile& storage, memory_order order) BOOST_NOEXCEPT + { + storage_type original; + uint32_t tmp; + __asm__ __volatile__ + ( + BOOST_ATOMIC_DETAIL_ARM_ASM_START(%0) + "ldrexd %1, %H1, [%2]\n" + BOOST_ATOMIC_DETAIL_ARM_ASM_END(%0) + : BOOST_ATOMIC_DETAIL_ARM_ASM_TMPREG_CONSTRAINT(tmp), // %0 + "=&r" (original) // %1 + : "r" (&storage) // %2 + ); + fence_after(order); + return original; + } + + static BOOST_FORCEINLINE storage_type exchange(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + storage_type original; + fence_before(order); + uint32_t tmp; + __asm__ __volatile__ + ( + BOOST_ATOMIC_DETAIL_ARM_ASM_START(%0) + "1:\n" + "ldrexd %1, %H1, [%3]\n" // load the original value + "strexd %0, %2, %H2, [%3]\n" // store the replacement, tmp = store failed + "teq %0, #0\n" // check if store succeeded + "bne 1b\n" + BOOST_ATOMIC_DETAIL_ARM_ASM_END(%0) + : BOOST_ATOMIC_DETAIL_ARM_ASM_TMPREG_CONSTRAINT(tmp), // %0 + "=&r" (original) // %1 + : "r" (v), // %2 + "r" (&storage) // %3 + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC_COMMA "memory" + ); + fence_after(order); + return original; + } + + static BOOST_FORCEINLINE bool compare_exchange_weak( + storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order success_order, memory_order failure_order) BOOST_NOEXCEPT + { + fence_before(success_order); + uint32_t tmp; + storage_type original, old_val = expected; + __asm__ __volatile__ + ( + BOOST_ATOMIC_DETAIL_ARM_ASM_START(%0) + "ldrexd %1, %H1, [%3]\n" // original = *(&storage) + "cmp %1, %2\n" // flags = original.lo==old_val.lo + "ittt eq\n" // [hint that the following 3 instructions are conditional on flags.equal] + "cmpeq %H1, %H2\n" // if (flags.equal) flags = original.hi==old_val.hi + "strexdeq %0, %4, %H4, [%3]\n" // if (flags.equal) *(&storage) = desired, tmp = store failed + "teqeq %0, #0\n" // if (flags.equal) flags = tmp==0 + "ite eq\n" // [hint that the following 2 instructions are conditional on flags.equal] + "moveq %2, #1\n" // if (flags.equal) old_val.lo = 1 + "movne %2, #0\n" // if (!flags.equal) old_val.lo = 0 + BOOST_ATOMIC_DETAIL_ARM_ASM_END(%0) + : BOOST_ATOMIC_DETAIL_ARM_ASM_TMPREG_CONSTRAINT(tmp), // %0 + "=&r" (original), // %1 + "+r" (old_val) // %2 + : "r" (&storage), // %3 + "r" (desired) // %4 + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC_COMMA "memory" + ); + const uint32_t success = (uint32_t)old_val; + if (success) + fence_after(success_order); + else + fence_after(failure_order); + expected = original; + return !!success; + } + + static BOOST_FORCEINLINE bool compare_exchange_strong( + storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order success_order, memory_order failure_order) BOOST_NOEXCEPT + { + fence_before(success_order); + uint32_t tmp; + storage_type original, old_val = expected; + __asm__ __volatile__ + ( + BOOST_ATOMIC_DETAIL_ARM_ASM_START(%0) + "1:\n" + "ldrexd %1, %H1, [%3]\n" // original = *(&storage) + "cmp %1, %2\n" // flags = original.lo==old_val.lo + "it eq\n" // [hint that the following instruction is conditional on flags.equal] + "cmpeq %H1, %H2\n" // if (flags.equal) flags = original.hi==old_val.hi + "bne 2f\n" // if (!flags.equal) goto end + "strexd %0, %4, %H4, [%3]\n" // *(&storage) = desired, tmp = store failed + "teq %0, #0\n" // flags.equal = tmp == 0 + "bne 1b\n" // if (flags.equal) goto retry + "2:\n" + "ite eq\n" // [hint that the following 2 instructions are conditional on flags.equal] + "moveq %2, #1\n" // if (flags.equal) old_val.lo = 1 + "movne %2, #0\n" // if (!flags.equal) old_val.lo = 0 + BOOST_ATOMIC_DETAIL_ARM_ASM_END(%0) + : BOOST_ATOMIC_DETAIL_ARM_ASM_TMPREG_CONSTRAINT(tmp), // %0 + "=&r" (original), // %1 + "+r" (old_val) // %2 + : "r" (&storage), // %3 + "r" (desired) // %4 + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC_COMMA "memory" + ); + const uint32_t success = (uint32_t)old_val; + if (success) + fence_after(success_order); + else + fence_after(failure_order); + expected = original; + return !!success; + } + + static BOOST_FORCEINLINE storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + fence_before(order); + storage_type original, result; + uint32_t tmp; + __asm__ __volatile__ + ( + BOOST_ATOMIC_DETAIL_ARM_ASM_START(%0) + "1:\n" + "ldrexd %1, %H1, [%3]\n" // original = *(&storage) + "adds %2, %1, %4\n" // result = original + value + "adc %H2, %H1, %H4\n" + "strexd %0, %2, %H2, [%3]\n" // *(&storage) = result, tmp = store failed + "teq %0, #0\n" // flags = tmp==0 + "bne 1b\n" // if (!flags.equal) goto retry + BOOST_ATOMIC_DETAIL_ARM_ASM_END(%0) + : BOOST_ATOMIC_DETAIL_ARM_ASM_TMPREG_CONSTRAINT(tmp), // %0 + "=&r" (original), // %1 + "=&r" (result) // %2 + : "r" (&storage), // %3 + "r" (v) // %4 + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC_COMMA "memory" + ); + fence_after(order); + return original; + } + + static BOOST_FORCEINLINE storage_type fetch_sub(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + fence_before(order); + storage_type original, result; + uint32_t tmp; + __asm__ __volatile__ + ( + BOOST_ATOMIC_DETAIL_ARM_ASM_START(%0) + "1:\n" + "ldrexd %1, %H1, [%3]\n" // original = *(&storage) + "subs %2, %1, %4\n" // result = original - value + "sbc %H2, %H1, %H4\n" + "strexd %0, %2, %H2, [%3]\n" // *(&storage) = result, tmp = store failed + "teq %0, #0\n" // flags = tmp==0 + "bne 1b\n" // if (!flags.equal) goto retry + BOOST_ATOMIC_DETAIL_ARM_ASM_END(%0) + : BOOST_ATOMIC_DETAIL_ARM_ASM_TMPREG_CONSTRAINT(tmp), // %0 + "=&r" (original), // %1 + "=&r" (result) // %2 + : "r" (&storage), // %3 + "r" (v) // %4 + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC_COMMA "memory" + ); + fence_after(order); + return original; + } + + static BOOST_FORCEINLINE storage_type fetch_and(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + fence_before(order); + storage_type original, result; + uint32_t tmp; + __asm__ __volatile__ + ( + BOOST_ATOMIC_DETAIL_ARM_ASM_START(%0) + "1:\n" + "ldrexd %1, %H1, [%3]\n" // original = *(&storage) + "and %2, %1, %4\n" // result = original & value + "and %H2, %H1, %H4\n" + "strexd %0, %2, %H2, [%3]\n" // *(&storage) = result, tmp = store failed + "teq %0, #0\n" // flags = tmp==0 + "bne 1b\n" // if (!flags.equal) goto retry + BOOST_ATOMIC_DETAIL_ARM_ASM_END(%0) + : BOOST_ATOMIC_DETAIL_ARM_ASM_TMPREG_CONSTRAINT(tmp), // %0 + "=&r" (original), // %1 + "=&r" (result) // %2 + : "r" (&storage), // %3 + "r" (v) // %4 + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC_COMMA "memory" + ); + fence_after(order); + return original; + } + + static BOOST_FORCEINLINE storage_type fetch_or(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + fence_before(order); + storage_type original, result; + uint32_t tmp; + __asm__ __volatile__ + ( + BOOST_ATOMIC_DETAIL_ARM_ASM_START(%0) + "1:\n" + "ldrexd %1, %H1, [%3]\n" // original = *(&storage) + "orr %2, %1, %4\n" // result = original | value + "orr %H2, %H1, %H4\n" + "strexd %0, %2, %H2, [%3]\n" // *(&storage) = result, tmp = store failed + "teq %0, #0\n" // flags = tmp==0 + "bne 1b\n" // if (!flags.equal) goto retry + BOOST_ATOMIC_DETAIL_ARM_ASM_END(%0) + : BOOST_ATOMIC_DETAIL_ARM_ASM_TMPREG_CONSTRAINT(tmp), // %0 + "=&r" (original), // %1 + "=&r" (result) // %2 + : "r" (&storage), // %3 + "r" (v) // %4 + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC_COMMA "memory" + ); + fence_after(order); + return original; + } + + static BOOST_FORCEINLINE storage_type fetch_xor(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + fence_before(order); + storage_type original, result; + uint32_t tmp; + __asm__ __volatile__ + ( + BOOST_ATOMIC_DETAIL_ARM_ASM_START(%0) + "1:\n" + "ldrexd %1, %H1, [%3]\n" // original = *(&storage) + "eor %2, %1, %4\n" // result = original ^ value + "eor %H2, %H1, %H4\n" + "strexd %0, %2, %H2, [%3]\n" // *(&storage) = result, tmp = store failed + "teq %0, #0\n" // flags = tmp==0 + "bne 1b\n" // if (!flags.equal) goto retry + BOOST_ATOMIC_DETAIL_ARM_ASM_END(%0) + : BOOST_ATOMIC_DETAIL_ARM_ASM_TMPREG_CONSTRAINT(tmp), // %0 + "=&r" (original), // %1 + "=&r" (result) // %2 + : "r" (&storage), // %3 + "r" (v) // %4 + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC_COMMA "memory" + ); + fence_after(order); + return original; + } + + static BOOST_FORCEINLINE bool test_and_set(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT + { + return !!exchange(storage, (storage_type)1, order); + } + + static BOOST_FORCEINLINE void clear(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT + { + store(storage, 0, order); + } +}; + +#endif // defined(BOOST_ATOMIC_DETAIL_ARM_HAS_LDREXD_STREXD) + + +BOOST_FORCEINLINE void thread_fence(memory_order order) BOOST_NOEXCEPT +{ + if (order != memory_order_relaxed) + gcc_arm_operations_base::hardware_full_fence(); +} + +BOOST_FORCEINLINE void signal_fence(memory_order order) BOOST_NOEXCEPT +{ + if (order != memory_order_relaxed) + __asm__ __volatile__ ("" ::: "memory"); +} + +} // namespace detail +} // namespace atomics +} // namespace boost + +#endif // BOOST_ATOMIC_DETAIL_OPS_GCC_ARM_HPP_INCLUDED_ diff --git a/libs/boost/include/boost/atomic/detail/ops_gcc_atomic.hpp b/libs/boost/include/boost/atomic/detail/ops_gcc_atomic.hpp new file mode 100644 index 0000000..4e1adae --- /dev/null +++ b/libs/boost/include/boost/atomic/detail/ops_gcc_atomic.hpp @@ -0,0 +1,395 @@ +/* + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or copy at + * http://www.boost.org/LICENSE_1_0.txt) + * + * Copyright (c) 2014 Andrey Semashev + */ +/*! + * \file atomic/detail/ops_gcc_atomic.hpp + * + * This header contains implementation of the \c operations template. + */ + +#ifndef BOOST_ATOMIC_DETAIL_OPS_GCC_ATOMIC_HPP_INCLUDED_ +#define BOOST_ATOMIC_DETAIL_OPS_GCC_ATOMIC_HPP_INCLUDED_ + +#include +#include +#include +#include +#include +#if defined(__clang__) && (defined(BOOST_ATOMIC_DETAIL_X86_HAS_CMPXCHG8B) || defined(BOOST_ATOMIC_DETAIL_X86_HAS_CMPXCHG16B)) +#include +#include +#endif + +#if __GCC_ATOMIC_LLONG_LOCK_FREE != BOOST_ATOMIC_LLONG_LOCK_FREE || __GCC_ATOMIC_LONG_LOCK_FREE != BOOST_ATOMIC_LONG_LOCK_FREE ||\ + __GCC_ATOMIC_INT_LOCK_FREE != BOOST_ATOMIC_INT_LOCK_FREE || __GCC_ATOMIC_SHORT_LOCK_FREE != BOOST_ATOMIC_SHORT_LOCK_FREE ||\ + __GCC_ATOMIC_CHAR_LOCK_FREE != BOOST_ATOMIC_CHAR_LOCK_FREE || __GCC_ATOMIC_BOOL_LOCK_FREE != BOOST_ATOMIC_BOOL_LOCK_FREE ||\ + __GCC_ATOMIC_WCHAR_T_LOCK_FREE != BOOST_ATOMIC_WCHAR_T_LOCK_FREE +// There are platforms where we need to use larger storage types +#include +#include +#endif + +#ifdef BOOST_HAS_PRAGMA_ONCE +#pragma once +#endif + +#if defined(__INTEL_COMPILER) +// This is used to suppress warning #32013 described below for Intel Compiler. +// In debug builds the compiler does not inline any functions, so basically +// every atomic function call results in this warning. I don't know any other +// way to selectively disable just this one warning. +#pragma system_header +#endif + +namespace boost { +namespace atomics { +namespace detail { + +/*! + * The function converts \c boost::memory_order values to the compiler-specific constants. + * + * NOTE: The intention is that the function is optimized away by the compiler, and the + * compiler-specific constants are passed to the intrinsics. I know constexpr doesn't + * work in this case because the standard atomics interface require memory ordering + * constants to be passed as function arguments, at which point they stop being constexpr. + * However it is crucial that the compiler sees constants and not runtime values, + * because otherwise it just ignores the ordering value and always uses seq_cst. + * This is the case with Intel C++ Compiler 14.0.3 (Composer XE 2013 SP1, update 3) and + * gcc 4.8.2. Intel Compiler issues a warning in this case: + * + * warning #32013: Invalid memory order specified. Defaulting to seq_cst memory order. + * + * while gcc acts silently. + * + * To mitigate the problem ALL functions, including the atomic<> members must be + * declared with BOOST_FORCEINLINE. In this case the compilers are able to see that + * all functions are called with constant orderings and call intrinstcts properly. + * + * Unfortunately, this still doesn't work in debug mode as the compiler doesn't + * inline functions even when marked with BOOST_FORCEINLINE. In this case all atomic + * operaions will be executed with seq_cst semantics. + */ +BOOST_FORCEINLINE BOOST_CONSTEXPR int convert_memory_order_to_gcc(memory_order order) BOOST_NOEXCEPT +{ + return (order == memory_order_relaxed ? __ATOMIC_RELAXED : (order == memory_order_consume ? __ATOMIC_CONSUME : + (order == memory_order_acquire ? __ATOMIC_ACQUIRE : (order == memory_order_release ? __ATOMIC_RELEASE : + (order == memory_order_acq_rel ? __ATOMIC_ACQ_REL : __ATOMIC_SEQ_CST))))); +} + +template< typename T > +struct gcc_atomic_operations +{ + typedef T storage_type; + + // Note: In the current implementation, gcc_atomic_operations are used onlu when the particularly sized __atomic + // intrinsics are always lock-free (i.e. the corresponding LOCK_FREE macro is 2). Therefore it is safe to + // always set is_always_lock_free to true here. + static BOOST_CONSTEXPR_OR_CONST bool is_always_lock_free = true; + + static BOOST_FORCEINLINE void store(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + __atomic_store_n(&storage, v, atomics::detail::convert_memory_order_to_gcc(order)); + } + + static BOOST_FORCEINLINE storage_type load(storage_type const volatile& storage, memory_order order) BOOST_NOEXCEPT + { + return __atomic_load_n(&storage, atomics::detail::convert_memory_order_to_gcc(order)); + } + + static BOOST_FORCEINLINE storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + return __atomic_fetch_add(&storage, v, atomics::detail::convert_memory_order_to_gcc(order)); + } + + static BOOST_FORCEINLINE storage_type fetch_sub(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + return __atomic_fetch_sub(&storage, v, atomics::detail::convert_memory_order_to_gcc(order)); + } + + static BOOST_FORCEINLINE storage_type exchange(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + return __atomic_exchange_n(&storage, v, atomics::detail::convert_memory_order_to_gcc(order)); + } + + static BOOST_FORCEINLINE bool compare_exchange_strong( + storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order success_order, memory_order failure_order) BOOST_NOEXCEPT + { + return __atomic_compare_exchange_n + ( + &storage, &expected, desired, false, + atomics::detail::convert_memory_order_to_gcc(success_order), + atomics::detail::convert_memory_order_to_gcc(failure_order) + ); + } + + static BOOST_FORCEINLINE bool compare_exchange_weak( + storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order success_order, memory_order failure_order) BOOST_NOEXCEPT + { + return __atomic_compare_exchange_n + ( + &storage, &expected, desired, true, + atomics::detail::convert_memory_order_to_gcc(success_order), + atomics::detail::convert_memory_order_to_gcc(failure_order) + ); + } + + static BOOST_FORCEINLINE storage_type fetch_and(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + return __atomic_fetch_and(&storage, v, atomics::detail::convert_memory_order_to_gcc(order)); + } + + static BOOST_FORCEINLINE storage_type fetch_or(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + return __atomic_fetch_or(&storage, v, atomics::detail::convert_memory_order_to_gcc(order)); + } + + static BOOST_FORCEINLINE storage_type fetch_xor(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + return __atomic_fetch_xor(&storage, v, atomics::detail::convert_memory_order_to_gcc(order)); + } + + static BOOST_FORCEINLINE bool test_and_set(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT + { + return __atomic_test_and_set(&storage, atomics::detail::convert_memory_order_to_gcc(order)); + } + + static BOOST_FORCEINLINE void clear(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT + { + __atomic_clear(const_cast< storage_type* >(&storage), atomics::detail::convert_memory_order_to_gcc(order)); + } +}; + +#if BOOST_ATOMIC_INT128_LOCK_FREE > 0 +#if defined(__clang__) && defined(BOOST_ATOMIC_DETAIL_X86_HAS_CMPXCHG16B) + +// Workaround for clang bug: http://llvm.org/bugs/show_bug.cgi?id=19149 +// Clang 3.4 does not implement 128-bit __atomic* intrinsics even though it defines __GCC_HAVE_SYNC_COMPARE_AND_SWAP_16 +template< bool Signed > +struct operations< 16u, Signed > : + public cas_based_operations< gcc_dcas_x86_64< Signed > > +{ +}; + +#else + +template< bool Signed > +struct operations< 16u, Signed > : + public gcc_atomic_operations< typename make_storage_type< 16u, Signed >::type > +{ + typedef typename make_storage_type< 16u, Signed >::aligned aligned_storage_type; +}; + +#endif +#endif + + +#if BOOST_ATOMIC_INT64_LOCK_FREE > 0 +#if defined(__clang__) && defined(BOOST_ATOMIC_DETAIL_X86_HAS_CMPXCHG8B) + +// Workaround for clang bug http://llvm.org/bugs/show_bug.cgi?id=19355 +template< bool Signed > +struct operations< 8u, Signed > : + public cas_based_operations< gcc_dcas_x86< Signed > > +{ +}; + +#elif (BOOST_ATOMIC_DETAIL_SIZEOF_LLONG == 8 && __GCC_ATOMIC_LLONG_LOCK_FREE != BOOST_ATOMIC_LLONG_LOCK_FREE) ||\ + (BOOST_ATOMIC_DETAIL_SIZEOF_LONG == 8 && __GCC_ATOMIC_LONG_LOCK_FREE != BOOST_ATOMIC_LONG_LOCK_FREE) ||\ + (BOOST_ATOMIC_DETAIL_SIZEOF_INT == 8 && __GCC_ATOMIC_INT_LOCK_FREE != BOOST_ATOMIC_INT_LOCK_FREE) ||\ + (BOOST_ATOMIC_DETAIL_SIZEOF_SHORT == 8 && __GCC_ATOMIC_SHORT_LOCK_FREE != BOOST_ATOMIC_SHORT_LOCK_FREE) ||\ + (BOOST_ATOMIC_DETAIL_SIZEOF_WCHAR_T == 8 && __GCC_ATOMIC_WCHAR_T_LOCK_FREE != BOOST_ATOMIC_WCHAR_T_LOCK_FREE) + +#define BOOST_ATOMIC_DETAIL_INT64_EXTENDED + +template< bool Signed > +struct operations< 8u, Signed > : + public extending_cas_based_operations< gcc_atomic_operations< typename make_storage_type< 16u, Signed >::type >, 8u, Signed > +{ + typedef typename make_storage_type< 16u, Signed >::aligned aligned_storage_type; +}; + +#else + +template< bool Signed > +struct operations< 8u, Signed > : + public gcc_atomic_operations< typename make_storage_type< 8u, Signed >::type > +{ + typedef typename make_storage_type< 8u, Signed >::aligned aligned_storage_type; +}; + +#endif +#endif + +#if BOOST_ATOMIC_INT32_LOCK_FREE > 0 +#if (BOOST_ATOMIC_DETAIL_SIZEOF_LLONG == 4 && __GCC_ATOMIC_LLONG_LOCK_FREE != BOOST_ATOMIC_LLONG_LOCK_FREE) ||\ + (BOOST_ATOMIC_DETAIL_SIZEOF_LONG == 4 && __GCC_ATOMIC_LONG_LOCK_FREE != BOOST_ATOMIC_LONG_LOCK_FREE) ||\ + (BOOST_ATOMIC_DETAIL_SIZEOF_INT == 4 && __GCC_ATOMIC_INT_LOCK_FREE != BOOST_ATOMIC_INT_LOCK_FREE) ||\ + (BOOST_ATOMIC_DETAIL_SIZEOF_SHORT == 4 && __GCC_ATOMIC_SHORT_LOCK_FREE != BOOST_ATOMIC_SHORT_LOCK_FREE) ||\ + (BOOST_ATOMIC_DETAIL_SIZEOF_WCHAR_T == 4 && __GCC_ATOMIC_WCHAR_T_LOCK_FREE != BOOST_ATOMIC_WCHAR_T_LOCK_FREE) + +#define BOOST_ATOMIC_DETAIL_INT32_EXTENDED + +#if !defined(BOOST_ATOMIC_DETAIL_INT64_EXTENDED) + +template< bool Signed > +struct operations< 4u, Signed > : + public extending_cas_based_operations< gcc_atomic_operations< typename make_storage_type< 8u, Signed >::type >, 4u, Signed > +{ + typedef typename make_storage_type< 8u, Signed >::aligned aligned_storage_type; +}; + +#else // !defined(BOOST_ATOMIC_DETAIL_INT64_EXTENDED) + +template< bool Signed > +struct operations< 4u, Signed > : + public extending_cas_based_operations< gcc_atomic_operations< typename make_storage_type< 16u, Signed >::type >, 4u, Signed > +{ + typedef typename make_storage_type< 16u, Signed >::aligned aligned_storage_type; +}; + +#endif // !defined(BOOST_ATOMIC_DETAIL_INT64_EXTENDED) + +#else + +template< bool Signed > +struct operations< 4u, Signed > : + public gcc_atomic_operations< typename make_storage_type< 4u, Signed >::type > +{ + typedef typename make_storage_type< 4u, Signed >::aligned aligned_storage_type; +}; + +#endif +#endif + +#if BOOST_ATOMIC_INT16_LOCK_FREE > 0 +#if (BOOST_ATOMIC_DETAIL_SIZEOF_LLONG == 2 && __GCC_ATOMIC_LLONG_LOCK_FREE != BOOST_ATOMIC_LLONG_LOCK_FREE) ||\ + (BOOST_ATOMIC_DETAIL_SIZEOF_LONG == 2 && __GCC_ATOMIC_LONG_LOCK_FREE != BOOST_ATOMIC_LONG_LOCK_FREE) ||\ + (BOOST_ATOMIC_DETAIL_SIZEOF_INT == 2 && __GCC_ATOMIC_INT_LOCK_FREE != BOOST_ATOMIC_INT_LOCK_FREE) ||\ + (BOOST_ATOMIC_DETAIL_SIZEOF_SHORT == 2 && __GCC_ATOMIC_SHORT_LOCK_FREE != BOOST_ATOMIC_SHORT_LOCK_FREE) ||\ + (BOOST_ATOMIC_DETAIL_SIZEOF_WCHAR_T == 2 && __GCC_ATOMIC_WCHAR_T_LOCK_FREE != BOOST_ATOMIC_WCHAR_T_LOCK_FREE) + +#define BOOST_ATOMIC_DETAIL_INT16_EXTENDED + +#if !defined(BOOST_ATOMIC_DETAIL_INT32_EXTENDED) + +template< bool Signed > +struct operations< 2u, Signed > : + public extending_cas_based_operations< gcc_atomic_operations< typename make_storage_type< 4u, Signed >::type >, 2u, Signed > +{ + typedef typename make_storage_type< 4u, Signed >::aligned aligned_storage_type; +}; + +#elif !defined(BOOST_ATOMIC_DETAIL_INT64_EXTENDED) + +template< bool Signed > +struct operations< 2u, Signed > : + public extending_cas_based_operations< gcc_atomic_operations< typename make_storage_type< 8u, Signed >::type >, 2u, Signed > +{ + typedef typename make_storage_type< 8u, Signed >::aligned aligned_storage_type; +}; + +#else + +template< bool Signed > +struct operations< 2u, Signed > : + public extending_cas_based_operations< gcc_atomic_operations< typename make_storage_type< 16u, Signed >::type >, 2u, Signed > +{ + typedef typename make_storage_type< 16u, Signed >::aligned aligned_storage_type; +}; + +#endif + +#else + +template< bool Signed > +struct operations< 2u, Signed > : + public gcc_atomic_operations< typename make_storage_type< 2u, Signed >::type > +{ + typedef typename make_storage_type< 2u, Signed >::aligned aligned_storage_type; +}; + +#endif +#endif + +#if BOOST_ATOMIC_INT8_LOCK_FREE > 0 +#if (BOOST_ATOMIC_DETAIL_SIZEOF_LLONG == 1 && __GCC_ATOMIC_LLONG_LOCK_FREE != BOOST_ATOMIC_LLONG_LOCK_FREE) ||\ + (BOOST_ATOMIC_DETAIL_SIZEOF_LONG == 1 && __GCC_ATOMIC_LONG_LOCK_FREE != BOOST_ATOMIC_LONG_LOCK_FREE) ||\ + (BOOST_ATOMIC_DETAIL_SIZEOF_INT == 1 && __GCC_ATOMIC_INT_LOCK_FREE != BOOST_ATOMIC_INT_LOCK_FREE) ||\ + (BOOST_ATOMIC_DETAIL_SIZEOF_SHORT == 1 && __GCC_ATOMIC_SHORT_LOCK_FREE != BOOST_ATOMIC_SHORT_LOCK_FREE) ||\ + (BOOST_ATOMIC_DETAIL_SIZEOF_WCHAR_T == 1 && __GCC_ATOMIC_WCHAR_T_LOCK_FREE != BOOST_ATOMIC_WCHAR_T_LOCK_FREE) ||\ + (__GCC_ATOMIC_CHAR_LOCK_FREE != BOOST_ATOMIC_CHAR_LOCK_FREE) ||\ + (__GCC_ATOMIC_BOOL_LOCK_FREE != BOOST_ATOMIC_BOOL_LOCK_FREE) + +#if !defined(BOOST_ATOMIC_DETAIL_INT16_EXTENDED) + +template< bool Signed > +struct operations< 1u, Signed > : + public extending_cas_based_operations< gcc_atomic_operations< typename make_storage_type< 2u, Signed >::type >, 1u, Signed > +{ + typedef typename make_storage_type< 2u, Signed >::aligned aligned_storage_type; +}; + +#elif !defined(BOOST_ATOMIC_DETAIL_INT32_EXTENDED) + +template< bool Signed > +struct operations< 1u, Signed > : + public extending_cas_based_operations< gcc_atomic_operations< typename make_storage_type< 4u, Signed >::type >, 1u, Signed > +{ + typedef typename make_storage_type< 4u, Signed >::aligned aligned_storage_type; +}; + +#elif !defined(BOOST_ATOMIC_DETAIL_INT64_EXTENDED) + +template< bool Signed > +struct operations< 1u, Signed > : + public extending_cas_based_operations< gcc_atomic_operations< typename make_storage_type< 8u, Signed >::type >, 1u, Signed > +{ + typedef typename make_storage_type< 8u, Signed >::aligned aligned_storage_type; +}; + +#else + +template< bool Signed > +struct operations< 1u, Signed > : + public extending_cas_based_operations< gcc_atomic_operations< typename make_storage_type< 16u, Signed >::type >, 1u, Signed > +{ + typedef typename make_storage_type< 16u, Signed >::aligned aligned_storage_type; +}; + +#endif + +#else + +template< bool Signed > +struct operations< 1u, Signed > : + public gcc_atomic_operations< typename make_storage_type< 1u, Signed >::type > +{ + typedef typename make_storage_type< 1u, Signed >::aligned aligned_storage_type; +}; + +#endif +#endif + +#undef BOOST_ATOMIC_DETAIL_INT16_EXTENDED +#undef BOOST_ATOMIC_DETAIL_INT32_EXTENDED +#undef BOOST_ATOMIC_DETAIL_INT64_EXTENDED + +BOOST_FORCEINLINE void thread_fence(memory_order order) BOOST_NOEXCEPT +{ + __atomic_thread_fence(atomics::detail::convert_memory_order_to_gcc(order)); +} + +BOOST_FORCEINLINE void signal_fence(memory_order order) BOOST_NOEXCEPT +{ + __atomic_signal_fence(atomics::detail::convert_memory_order_to_gcc(order)); +} + +} // namespace detail +} // namespace atomics +} // namespace boost + +#endif // BOOST_ATOMIC_DETAIL_OPS_GCC_ATOMIC_HPP_INCLUDED_ diff --git a/libs/boost/include/boost/atomic/detail/ops_gcc_ppc.hpp b/libs/boost/include/boost/atomic/detail/ops_gcc_ppc.hpp new file mode 100644 index 0000000..76eae4e --- /dev/null +++ b/libs/boost/include/boost/atomic/detail/ops_gcc_ppc.hpp @@ -0,0 +1,794 @@ +/* + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or copy at + * http://www.boost.org/LICENSE_1_0.txt) + * + * Copyright (c) 2009 Helge Bahmann + * Copyright (c) 2013 Tim Blechmann + * Copyright (c) 2014 Andrey Semashev + */ +/*! + * \file atomic/detail/ops_gcc_ppc.hpp + * + * This header contains implementation of the \c operations template. + */ + +#ifndef BOOST_ATOMIC_DETAIL_OPS_GCC_PPC_HPP_INCLUDED_ +#define BOOST_ATOMIC_DETAIL_OPS_GCC_PPC_HPP_INCLUDED_ + +#include +#include +#include +#include +#include + +#ifdef BOOST_HAS_PRAGMA_ONCE +#pragma once +#endif + +namespace boost { +namespace atomics { +namespace detail { + +// The implementation below uses information from this document: +// http://www.rdrop.com/users/paulmck/scalability/paper/N2745r.2010.02.19a.html + +/* + Refer to: Motorola: "Programming Environments Manual for 32-Bit + Implementations of the PowerPC Architecture", Appendix E: + "Synchronization Programming Examples" for an explanation of what is + going on here (can be found on the web at various places by the + name "MPCFPE32B.pdf", Google is your friend...) + + Most of the atomic operations map to instructions in a relatively + straight-forward fashion, but "load"s may at first glance appear + a bit strange as they map to: + + lwz %rX, addr + cmpw %rX, %rX + bne- 1f + 1: + + That is, the CPU is forced to perform a branch that "formally" depends + on the value retrieved from memory. This scheme has an overhead of + about 1-2 clock cycles per load, but it allows to map "acquire" to + the "isync" instruction instead of "sync" uniformly and for all type + of atomic operations. Since "isync" has a cost of about 15 clock + cycles, while "sync" hast a cost of about 50 clock cycles, the small + penalty to atomic loads more than compensates for this. + + Byte- and halfword-sized atomic values are realized by encoding the + value to be represented into a word, performing sign/zero extension + as appropriate. This means that after add/sub operations the value + needs fixing up to accurately preserve the wrap-around semantic of + the smaller type. (Nothing special needs to be done for the bit-wise + and the "exchange type" operators as the compiler already sees to + it that values carried in registers are extended appropriately and + everything falls into place naturally). + + The register constraint "b" instructs gcc to use any register + except r0; this is sometimes required because the encoding for + r0 is used to signify "constant zero" in a number of instructions, + making r0 unusable in this place. For simplicity this constraint + is used everywhere since I am to lazy to look this up on a + per-instruction basis, and ppc has enough registers for this not + to pose a problem. +*/ + +// A note about memory_order_consume. Technically, this architecture allows to avoid +// unnecessary memory barrier after consume load since it supports data dependency ordering. +// However, some compiler optimizations may break a seemingly valid code relying on data +// dependency tracking by injecting bogus branches to aid out of order execution. +// This may happen not only in Boost.Atomic code but also in user's code, which we have no +// control of. See this thread: http://lists.boost.org/Archives/boost/2014/06/213890.php. +// For this reason we promote memory_order_consume to memory_order_acquire. + +struct gcc_ppc_operations_base +{ + static BOOST_CONSTEXPR_OR_CONST bool is_always_lock_free = true; + + static BOOST_FORCEINLINE void fence_before(memory_order order) BOOST_NOEXCEPT + { +#if defined(__powerpc64__) || defined(__PPC64__) + if (order == memory_order_seq_cst) + __asm__ __volatile__ ("sync" ::: "memory"); + else if ((order & memory_order_release) != 0) + __asm__ __volatile__ ("lwsync" ::: "memory"); +#else + if ((order & memory_order_release) != 0) + __asm__ __volatile__ ("sync" ::: "memory"); +#endif + } + + static BOOST_FORCEINLINE void fence_after(memory_order order) BOOST_NOEXCEPT + { + if ((order & (memory_order_consume | memory_order_acquire)) != 0) + __asm__ __volatile__ ("isync" ::: "memory"); + } +}; + + +template< bool Signed > +struct operations< 4u, Signed > : + public gcc_ppc_operations_base +{ + typedef typename make_storage_type< 4u, Signed >::type storage_type; + typedef typename make_storage_type< 4u, Signed >::aligned aligned_storage_type; + + static BOOST_FORCEINLINE void store(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + fence_before(order); + __asm__ __volatile__ + ( + "stw %1, %0\n\t" + : "+m" (storage) + : "r" (v) + ); + } + + static BOOST_FORCEINLINE storage_type load(storage_type const volatile& storage, memory_order order) BOOST_NOEXCEPT + { + storage_type v; + if (order == memory_order_seq_cst) + __asm__ __volatile__ ("sync" ::: "memory"); + if ((order & (memory_order_consume | memory_order_acquire)) != 0) + { + __asm__ __volatile__ + ( + "lwz %0, %1\n\t" + "cmpw %0, %0\n\t" + "bne- 1f\n\t" + "1:\n\t" + "isync\n\t" + : "=&r" (v) + : "m" (storage) + : "cr0", "memory" + ); + } + else + { + __asm__ __volatile__ + ( + "lwz %0, %1\n\t" + : "=&r" (v) + : "m" (storage) + ); + } + return v; + } + + static BOOST_FORCEINLINE storage_type exchange(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + storage_type original; + fence_before(order); + __asm__ __volatile__ + ( + "1:\n\t" + "lwarx %0,%y1\n\t" + "stwcx. %2,%y1\n\t" + "bne- 1b\n\t" + : "=&b" (original), "+Z" (storage) + : "b" (v) + : "cr0" + ); + fence_after(order); + return original; + } + + static BOOST_FORCEINLINE bool compare_exchange_weak( + storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order success_order, memory_order failure_order) BOOST_NOEXCEPT + { + int success; + fence_before(success_order); + __asm__ __volatile__ + ( + "li %1, 0\n\t" + "lwarx %0,%y2\n\t" + "cmpw %0, %3\n\t" + "bne- 1f\n\t" + "stwcx. %4,%y2\n\t" + "bne- 1f\n\t" + "li %1, 1\n\t" + "1:\n\t" + : "=&b" (expected), "=&b" (success), "+Z" (storage) + : "b" (expected), "b" (desired) + : "cr0" + ); + if (success) + fence_after(success_order); + else + fence_after(failure_order); + return !!success; + } + + static BOOST_FORCEINLINE bool compare_exchange_strong( + storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order success_order, memory_order failure_order) BOOST_NOEXCEPT + { + int success; + fence_before(success_order); + __asm__ __volatile__ + ( + "li %1, 0\n\t" + "0: lwarx %0,%y2\n\t" + "cmpw %0, %3\n\t" + "bne- 1f\n\t" + "stwcx. %4,%y2\n\t" + "bne- 0b\n\t" + "li %1, 1\n\t" + "1:\n\t" + : "=&b" (expected), "=&b" (success), "+Z" (storage) + : "b" (expected), "b" (desired) + : "cr0" + ); + if (success) + fence_after(success_order); + else + fence_after(failure_order); + return !!success; + } + + static BOOST_FORCEINLINE storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + storage_type original, tmp; + fence_before(order); + __asm__ __volatile__ + ( + "1:\n\t" + "lwarx %0,%y2\n\t" + "add %1,%0,%3\n\t" + "stwcx. %1,%y2\n\t" + "bne- 1b\n\t" + : "=&b" (original), "=&b" (tmp), "+Z" (storage) + : "b" (v) + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC + ); + fence_after(order); + return original; + } + + static BOOST_FORCEINLINE storage_type fetch_sub(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + storage_type original, tmp; + fence_before(order); + __asm__ __volatile__ + ( + "1:\n\t" + "lwarx %0,%y2\n\t" + "sub %1,%0,%3\n\t" + "stwcx. %1,%y2\n\t" + "bne- 1b\n\t" + : "=&b" (original), "=&b" (tmp), "+Z" (storage) + : "b" (v) + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC + ); + fence_after(order); + return original; + } + + static BOOST_FORCEINLINE storage_type fetch_and(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + storage_type original, tmp; + fence_before(order); + __asm__ __volatile__ + ( + "1:\n\t" + "lwarx %0,%y2\n\t" + "and %1,%0,%3\n\t" + "stwcx. %1,%y2\n\t" + "bne- 1b\n\t" + : "=&b" (original), "=&b" (tmp), "+Z" (storage) + : "b" (v) + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC + ); + fence_after(order); + return original; + } + + static BOOST_FORCEINLINE storage_type fetch_or(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + storage_type original, tmp; + fence_before(order); + __asm__ __volatile__ + ( + "1:\n\t" + "lwarx %0,%y2\n\t" + "or %1,%0,%3\n\t" + "stwcx. %1,%y2\n\t" + "bne- 1b\n\t" + : "=&b" (original), "=&b" (tmp), "+Z" (storage) + : "b" (v) + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC + ); + fence_after(order); + return original; + } + + static BOOST_FORCEINLINE storage_type fetch_xor(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + storage_type original, tmp; + fence_before(order); + __asm__ __volatile__ + ( + "1:\n\t" + "lwarx %0,%y2\n\t" + "xor %1,%0,%3\n\t" + "stwcx. %1,%y2\n\t" + "bne- 1b\n\t" + : "=&b" (original), "=&b" (tmp), "+Z" (storage) + : "b" (v) + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC + ); + fence_after(order); + return original; + } + + static BOOST_FORCEINLINE bool test_and_set(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT + { + return !!exchange(storage, (storage_type)1, order); + } + + static BOOST_FORCEINLINE void clear(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT + { + store(storage, 0, order); + } +}; + + +template< > +struct operations< 1u, false > : + public operations< 4u, false > +{ + typedef operations< 4u, false > base_type; + typedef base_type::storage_type storage_type; + + static BOOST_FORCEINLINE storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + storage_type original, tmp; + fence_before(order); + __asm__ __volatile__ + ( + "1:\n\t" + "lwarx %0,%y2\n\t" + "add %1,%0,%3\n\t" + "rlwinm %1, %1, 0, 0xff\n\t" + "stwcx. %1,%y2\n\t" + "bne- 1b\n\t" + : "=&b" (original), "=&b" (tmp), "+Z" (storage) + : "b" (v) + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC + ); + fence_after(order); + return original; + } + + static BOOST_FORCEINLINE storage_type fetch_sub(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + storage_type original, tmp; + fence_before(order); + __asm__ __volatile__ + ( + "1:\n\t" + "lwarx %0,%y2\n\t" + "sub %1,%0,%3\n\t" + "rlwinm %1, %1, 0, 0xff\n\t" + "stwcx. %1,%y2\n\t" + "bne- 1b\n\t" + : "=&b" (original), "=&b" (tmp), "+Z" (storage) + : "b" (v) + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC + ); + fence_after(order); + return original; + } +}; + +template< > +struct operations< 1u, true > : + public operations< 4u, true > +{ + typedef operations< 4u, true > base_type; + typedef base_type::storage_type storage_type; + + static BOOST_FORCEINLINE storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + storage_type original, tmp; + fence_before(order); + __asm__ __volatile__ + ( + "1:\n\t" + "lwarx %0,%y2\n\t" + "add %1,%0,%3\n\t" + "extsb %1, %1\n\t" + "stwcx. %1,%y2\n\t" + "bne- 1b\n\t" + : "=&b" (original), "=&b" (tmp), "+Z" (storage) + : "b" (v) + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC + ); + fence_after(order); + return original; + } + + static BOOST_FORCEINLINE storage_type fetch_sub(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + storage_type original, tmp; + fence_before(order); + __asm__ __volatile__ + ( + "1:\n\t" + "lwarx %0,%y2\n\t" + "sub %1,%0,%3\n\t" + "extsb %1, %1\n\t" + "stwcx. %1,%y2\n\t" + "bne- 1b\n\t" + : "=&b" (original), "=&b" (tmp), "+Z" (storage) + : "b" (v) + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC + ); + fence_after(order); + return original; + } +}; + + +template< > +struct operations< 2u, false > : + public operations< 4u, false > +{ + typedef operations< 4u, false > base_type; + typedef base_type::storage_type storage_type; + + static BOOST_FORCEINLINE storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + storage_type original, tmp; + fence_before(order); + __asm__ __volatile__ + ( + "1:\n\t" + "lwarx %0,%y2\n\t" + "add %1,%0,%3\n\t" + "rlwinm %1, %1, 0, 0xffff\n\t" + "stwcx. %1,%y2\n\t" + "bne- 1b\n\t" + : "=&b" (original), "=&b" (tmp), "+Z" (storage) + : "b" (v) + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC + ); + fence_after(order); + return original; + } + + static BOOST_FORCEINLINE storage_type fetch_sub(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + storage_type original, tmp; + fence_before(order); + __asm__ __volatile__ + ( + "1:\n\t" + "lwarx %0,%y2\n\t" + "sub %1,%0,%3\n\t" + "rlwinm %1, %1, 0, 0xffff\n\t" + "stwcx. %1,%y2\n\t" + "bne- 1b\n\t" + : "=&b" (original), "=&b" (tmp), "+Z" (storage) + : "b" (v) + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC + ); + fence_after(order); + return original; + } +}; + +template< > +struct operations< 2u, true > : + public operations< 4u, true > +{ + typedef operations< 4u, true > base_type; + typedef base_type::storage_type storage_type; + + static BOOST_FORCEINLINE storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + storage_type original, tmp; + fence_before(order); + __asm__ __volatile__ + ( + "1:\n\t" + "lwarx %0,%y2\n\t" + "add %1,%0,%3\n\t" + "extsh %1, %1\n\t" + "stwcx. %1,%y2\n\t" + "bne- 1b\n\t" + : "=&b" (original), "=&b" (tmp), "+Z" (storage) + : "b" (v) + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC + ); + fence_after(order); + return original; + } + + static BOOST_FORCEINLINE storage_type fetch_sub(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + storage_type original, tmp; + fence_before(order); + __asm__ __volatile__ + ( + "1:\n\t" + "lwarx %0,%y2\n\t" + "sub %1,%0,%3\n\t" + "extsh %1, %1\n\t" + "stwcx. %1,%y2\n\t" + "bne- 1b\n\t" + : "=&b" (original), "=&b" (tmp), "+Z" (storage) + : "b" (v) + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC + ); + fence_after(order); + return original; + } +}; + + +#if defined(__powerpc64__) || defined(__PPC64__) + +template< bool Signed > +struct operations< 8u, Signed > : + public gcc_ppc_operations_base +{ + typedef typename make_storage_type< 8u, Signed >::type storage_type; + typedef typename make_storage_type< 8u, Signed >::aligned aligned_storage_type; + + static BOOST_FORCEINLINE void store(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + fence_before(order); + __asm__ __volatile__ + ( + "std %1, %0\n\t" + : "+m" (storage) + : "r" (v) + ); + } + + static BOOST_FORCEINLINE storage_type load(storage_type const volatile& storage, memory_order order) BOOST_NOEXCEPT + { + storage_type v; + if (order == memory_order_seq_cst) + __asm__ __volatile__ ("sync" ::: "memory"); + if ((order & (memory_order_consume | memory_order_acquire)) != 0) + { + __asm__ __volatile__ + ( + "ld %0, %1\n\t" + "cmpd %0, %0\n\t" + "bne- 1f\n\t" + "1:\n\t" + "isync\n\t" + : "=&b" (v) + : "m" (storage) + : "cr0", "memory" + ); + } + else + { + __asm__ __volatile__ + ( + "ld %0, %1\n\t" + : "=&b" (v) + : "m" (storage) + ); + } + return v; + } + + static BOOST_FORCEINLINE storage_type exchange(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + storage_type original; + fence_before(order); + __asm__ __volatile__ + ( + "1:\n\t" + "ldarx %0,%y1\n\t" + "stdcx. %2,%y1\n\t" + "bne- 1b\n\t" + : "=&b" (original), "+Z" (storage) + : "b" (v) + : "cr0" + ); + fence_after(order); + return original; + } + + static BOOST_FORCEINLINE bool compare_exchange_weak( + storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order success_order, memory_order failure_order) BOOST_NOEXCEPT + { + int success; + fence_before(success_order); + __asm__ __volatile__ + ( + "li %1, 0\n\t" + "ldarx %0,%y2\n\t" + "cmpd %0, %3\n\t" + "bne- 1f\n\t" + "stdcx. %4,%y2\n\t" + "bne- 1f\n\t" + "li %1, 1\n\t" + "1:" + : "=&b" (expected), "=&b" (success), "+Z" (storage) + : "b" (expected), "b" (desired) + : "cr0" + ); + if (success) + fence_after(success_order); + else + fence_after(failure_order); + return !!success; + } + + static BOOST_FORCEINLINE bool compare_exchange_strong( + storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order success_order, memory_order failure_order) BOOST_NOEXCEPT + { + int success; + fence_before(success_order); + __asm__ __volatile__ + ( + "li %1, 0\n\t" + "0: ldarx %0,%y2\n\t" + "cmpd %0, %3\n\t" + "bne- 1f\n\t" + "stdcx. %4,%y2\n\t" + "bne- 0b\n\t" + "li %1, 1\n\t" + "1:\n\t" + : "=&b" (expected), "=&b" (success), "+Z" (storage) + : "b" (expected), "b" (desired) + : "cr0" + ); + if (success) + fence_after(success_order); + else + fence_after(failure_order); + return !!success; + } + + static BOOST_FORCEINLINE storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + storage_type original, tmp; + fence_before(order); + __asm__ __volatile__ + ( + "1:\n\t" + "ldarx %0,%y2\n\t" + "add %1,%0,%3\n\t" + "stdcx. %1,%y2\n\t" + "bne- 1b\n\t" + : "=&b" (original), "=&b" (tmp), "+Z" (storage) + : "b" (v) + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC + ); + fence_after(order); + return original; + } + + static BOOST_FORCEINLINE storage_type fetch_sub(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + storage_type original, tmp; + fence_before(order); + __asm__ __volatile__ + ( + "1:\n\t" + "ldarx %0,%y2\n\t" + "sub %1,%0,%3\n\t" + "stdcx. %1,%y2\n\t" + "bne- 1b\n\t" + : "=&b" (original), "=&b" (tmp), "+Z" (storage) + : "b" (v) + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC + ); + fence_after(order); + return original; + } + + static BOOST_FORCEINLINE storage_type fetch_and(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + storage_type original, tmp; + fence_before(order); + __asm__ __volatile__ + ( + "1:\n\t" + "ldarx %0,%y2\n\t" + "and %1,%0,%3\n\t" + "stdcx. %1,%y2\n\t" + "bne- 1b\n\t" + : "=&b" (original), "=&b" (tmp), "+Z" (storage) + : "b" (v) + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC + ); + fence_after(order); + return original; + } + + static BOOST_FORCEINLINE storage_type fetch_or(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + storage_type original, tmp; + fence_before(order); + __asm__ __volatile__ + ( + "1:\n\t" + "ldarx %0,%y2\n\t" + "or %1,%0,%3\n\t" + "stdcx. %1,%y2\n\t" + "bne- 1b\n\t" + : "=&b" (original), "=&b" (tmp), "+Z" (storage) + : "b" (v) + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC + ); + fence_after(order); + return original; + } + + static BOOST_FORCEINLINE storage_type fetch_xor(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + storage_type original, tmp; + fence_before(order); + __asm__ __volatile__ + ( + "1:\n\t" + "ldarx %0,%y2\n\t" + "xor %1,%0,%3\n\t" + "stdcx. %1,%y2\n\t" + "bne- 1b\n\t" + : "=&b" (original), "=&b" (tmp), "+Z" (storage) + : "b" (v) + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC + ); + fence_after(order); + return original; + } + + static BOOST_FORCEINLINE bool test_and_set(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT + { + return !!exchange(storage, (storage_type)1, order); + } + + static BOOST_FORCEINLINE void clear(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT + { + store(storage, 0, order); + } +}; + +#endif // defined(__powerpc64__) || defined(__PPC64__) + + +BOOST_FORCEINLINE void thread_fence(memory_order order) BOOST_NOEXCEPT +{ + switch (order) + { + case memory_order_consume: + case memory_order_acquire: + case memory_order_release: + case memory_order_acq_rel: +#if defined(__powerpc64__) || defined(__PPC64__) + __asm__ __volatile__ ("lwsync" ::: "memory"); + break; +#endif + case memory_order_seq_cst: + __asm__ __volatile__ ("sync" ::: "memory"); + break; + default:; + } +} + +BOOST_FORCEINLINE void signal_fence(memory_order order) BOOST_NOEXCEPT +{ + if (order != memory_order_relaxed) +#if defined(__ibmxl__) || defined(__IBMCPP__) + __fence(); +#else + __asm__ __volatile__ ("" ::: "memory"); +#endif +} + +} // namespace detail +} // namespace atomics +} // namespace boost + +#endif // BOOST_ATOMIC_DETAIL_OPS_GCC_PPC_HPP_INCLUDED_ diff --git a/libs/boost/include/boost/atomic/detail/ops_gcc_sparc.hpp b/libs/boost/include/boost/atomic/detail/ops_gcc_sparc.hpp new file mode 100644 index 0000000..08492ac --- /dev/null +++ b/libs/boost/include/boost/atomic/detail/ops_gcc_sparc.hpp @@ -0,0 +1,232 @@ +/* + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or copy at + * http://www.boost.org/LICENSE_1_0.txt) + * + * Copyright (c) 2010 Helge Bahmann + * Copyright (c) 2013 Tim Blechmann + * Copyright (c) 2014 Andrey Semashev + */ +/*! + * \file atomic/detail/ops_gcc_sparc.hpp + * + * This header contains implementation of the \c operations template. + */ + +#ifndef BOOST_ATOMIC_DETAIL_OPS_GCC_SPARC_HPP_INCLUDED_ +#define BOOST_ATOMIC_DETAIL_OPS_GCC_SPARC_HPP_INCLUDED_ + +#include +#include +#include +#include +#include +#include +#include + +#ifdef BOOST_HAS_PRAGMA_ONCE +#pragma once +#endif + +namespace boost { +namespace atomics { +namespace detail { + +struct gcc_sparc_cas_base +{ + static BOOST_CONSTEXPR_OR_CONST bool is_always_lock_free = true; + + static BOOST_FORCEINLINE void fence_before(memory_order order) BOOST_NOEXCEPT + { + if (order == memory_order_seq_cst) + __asm__ __volatile__ ("membar #Sync" ::: "memory"); + else if ((order & memory_order_release) != 0) + __asm__ __volatile__ ("membar #StoreStore | #LoadStore" ::: "memory"); + } + + static BOOST_FORCEINLINE void fence_after(memory_order order) BOOST_NOEXCEPT + { + if (order == memory_order_seq_cst) + __asm__ __volatile__ ("membar #Sync" ::: "memory"); + else if ((order & (memory_order_consume | memory_order_acquire)) != 0) + __asm__ __volatile__ ("membar #StoreStore | #LoadStore" ::: "memory"); + } + + static BOOST_FORCEINLINE void fence_after_store(memory_order order) BOOST_NOEXCEPT + { + if (order == memory_order_seq_cst) + __asm__ __volatile__ ("membar #Sync" ::: "memory"); + } +}; + +template< bool Signed > +struct gcc_sparc_cas32 : + public gcc_sparc_cas_base +{ + typedef typename make_storage_type< 4u, Signed >::type storage_type; + typedef typename make_storage_type< 4u, Signed >::aligned aligned_storage_type; + + static BOOST_FORCEINLINE void store(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + fence_before(order); + storage = v; + fence_after_store(order); + } + + static BOOST_FORCEINLINE storage_type load(storage_type const volatile& storage, memory_order order) BOOST_NOEXCEPT + { + storage_type v = storage; + fence_after(order); + return v; + } + + static BOOST_FORCEINLINE bool compare_exchange_strong( + storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order success_order, memory_order failure_order) BOOST_NOEXCEPT + { + fence_before(success_order); + storage_type previous = expected; + __asm__ __volatile__ + ( + "cas [%1], %2, %0" + : "+r" (desired) + : "r" (&storage), "r" (previous) + : "memory" + ); + const bool success = (desired == previous); + if (success) + fence_after(success_order); + else + fence_after(failure_order); + expected = desired; + return success; + } + + static BOOST_FORCEINLINE bool compare_exchange_weak( + storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order success_order, memory_order failure_order) BOOST_NOEXCEPT + { + return compare_exchange_strong(storage, expected, desired, success_order, failure_order); + } + + static BOOST_FORCEINLINE storage_type exchange(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + fence_before(order); + __asm__ __volatile__ + ( + "swap [%1], %0" + : "+r" (v) + : "r" (&storage) + : "memory" + ); + fence_after(order); + return v; + } +}; + +template< bool Signed > +struct operations< 4u, Signed > : + public cas_based_operations< gcc_sparc_cas32< Signed > > +{ +}; + +template< bool Signed > +struct operations< 1u, Signed > : + public extending_cas_based_operations< operations< 4u, Signed >, 1u, Signed > +{ +}; + +template< bool Signed > +struct operations< 2u, Signed > : + public extending_cas_based_operations< operations< 4u, Signed >, 2u, Signed > +{ +}; + +template< bool Signed > +struct gcc_sparc_cas64 : + public gcc_sparc_cas_base +{ + typedef typename make_storage_type< 8u, Signed >::type storage_type; + typedef typename make_storage_type< 8u, Signed >::aligned aligned_storage_type; + + static BOOST_FORCEINLINE void store(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + fence_before(order); + storage = v; + fence_after_store(order); + } + + static BOOST_FORCEINLINE storage_type load(storage_type const volatile& storage, memory_order order) BOOST_NOEXCEPT + { + storage_type v = storage; + fence_after(order); + return v; + } + + static BOOST_FORCEINLINE bool compare_exchange_strong( + storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order success_order, memory_order failure_order) BOOST_NOEXCEPT + { + fence_before(success_order); + storage_type previous = expected; + __asm__ __volatile__ + ( + "casx [%1], %2, %0" + : "+r" (desired) + : "r" (&storage), "r" (previous) + : "memory" + ); + const bool success = (desired == previous); + if (success) + fence_after(success_order); + else + fence_after(failure_order); + expected = desired; + return success; + } + + static BOOST_FORCEINLINE bool compare_exchange_weak( + storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order success_order, memory_order failure_order) BOOST_NOEXCEPT + { + return compare_exchange_strong(storage, expected, desired, success_order, failure_order); + } +}; + +template< bool Signed > +struct operations< 8u, Signed > : + public cas_based_operations< cas_based_exchange< gcc_sparc_cas64< Signed > > > +{ +}; + + +BOOST_FORCEINLINE void thread_fence(memory_order order) BOOST_NOEXCEPT +{ + switch (order) + { + case memory_order_release: + __asm__ __volatile__ ("membar #StoreStore | #LoadStore" ::: "memory"); + break; + case memory_order_consume: + case memory_order_acquire: + __asm__ __volatile__ ("membar #LoadLoad | #LoadStore" ::: "memory"); + break; + case memory_order_acq_rel: + __asm__ __volatile__ ("membar #LoadLoad | #LoadStore | #StoreStore" ::: "memory"); + break; + case memory_order_seq_cst: + __asm__ __volatile__ ("membar #Sync" ::: "memory"); + break; + case memory_order_relaxed: + default: + break; + } +} + +BOOST_FORCEINLINE void signal_fence(memory_order order) BOOST_NOEXCEPT +{ + if (order != memory_order_relaxed) + __asm__ __volatile__ ("" ::: "memory"); +} + +} // namespace detail +} // namespace atomics +} // namespace boost + +#endif // BOOST_ATOMIC_DETAIL_OPS_GCC_SPARC_HPP_INCLUDED_ diff --git a/libs/boost/include/boost/atomic/detail/ops_gcc_sync.hpp b/libs/boost/include/boost/atomic/detail/ops_gcc_sync.hpp new file mode 100644 index 0000000..a9a9ae2 --- /dev/null +++ b/libs/boost/include/boost/atomic/detail/ops_gcc_sync.hpp @@ -0,0 +1,267 @@ +/* + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or copy at + * http://www.boost.org/LICENSE_1_0.txt) + * + * Copyright (c) 2011 Helge Bahmann + * Copyright (c) 2013 Tim Blechmann + * Copyright (c) 2014 Andrey Semashev + */ +/*! + * \file atomic/detail/ops_gcc_sync.hpp + * + * This header contains implementation of the \c operations template. + */ + +#ifndef BOOST_ATOMIC_DETAIL_OPS_GCC_SYNC_HPP_INCLUDED_ +#define BOOST_ATOMIC_DETAIL_OPS_GCC_SYNC_HPP_INCLUDED_ + +#include +#include +#include +#include +#include +#include + +#ifdef BOOST_HAS_PRAGMA_ONCE +#pragma once +#endif + +namespace boost { +namespace atomics { +namespace detail { + +struct gcc_sync_operations_base +{ + static BOOST_CONSTEXPR_OR_CONST bool is_always_lock_free = true; + + static BOOST_FORCEINLINE void fence_before_store(memory_order order) BOOST_NOEXCEPT + { + if ((order & memory_order_release) != 0) + __sync_synchronize(); + } + + static BOOST_FORCEINLINE void fence_after_store(memory_order order) BOOST_NOEXCEPT + { + if (order == memory_order_seq_cst) + __sync_synchronize(); + } + + static BOOST_FORCEINLINE void fence_after_load(memory_order order) BOOST_NOEXCEPT + { + if ((order & (memory_order_acquire | memory_order_consume)) != 0) + __sync_synchronize(); + } +}; + +template< typename T > +struct gcc_sync_operations : + public gcc_sync_operations_base +{ + typedef T storage_type; + + static BOOST_FORCEINLINE void store(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + fence_before_store(order); + storage = v; + fence_after_store(order); + } + + static BOOST_FORCEINLINE storage_type load(storage_type const volatile& storage, memory_order order) BOOST_NOEXCEPT + { + storage_type v = storage; + fence_after_load(order); + return v; + } + + static BOOST_FORCEINLINE storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT + { + return __sync_fetch_and_add(&storage, v); + } + + static BOOST_FORCEINLINE storage_type fetch_sub(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT + { + return __sync_fetch_and_sub(&storage, v); + } + + static BOOST_FORCEINLINE storage_type exchange(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + // GCC docs mention that not all architectures may support full exchange semantics for this intrinsic. However, GCC's implementation of + // std::atomic<> uses this intrinsic unconditionally. We do so as well. In case if some architectures actually don't support this, we can always + // add a check here and fall back to a CAS loop. + if ((order & memory_order_release) != 0) + __sync_synchronize(); + return __sync_lock_test_and_set(&storage, v); + } + + static BOOST_FORCEINLINE bool compare_exchange_strong( + storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order, memory_order) BOOST_NOEXCEPT + { + storage_type expected2 = expected; + storage_type old_val = __sync_val_compare_and_swap(&storage, expected2, desired); + + if (old_val == expected2) + { + return true; + } + else + { + expected = old_val; + return false; + } + } + + static BOOST_FORCEINLINE bool compare_exchange_weak( + storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order success_order, memory_order failure_order) BOOST_NOEXCEPT + { + return compare_exchange_strong(storage, expected, desired, success_order, failure_order); + } + + static BOOST_FORCEINLINE storage_type fetch_and(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT + { + return __sync_fetch_and_and(&storage, v); + } + + static BOOST_FORCEINLINE storage_type fetch_or(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT + { + return __sync_fetch_and_or(&storage, v); + } + + static BOOST_FORCEINLINE storage_type fetch_xor(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT + { + return __sync_fetch_and_xor(&storage, v); + } + + static BOOST_FORCEINLINE bool test_and_set(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT + { + if ((order & memory_order_release) != 0) + __sync_synchronize(); + return !!__sync_lock_test_and_set(&storage, 1); + } + + static BOOST_FORCEINLINE void clear(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT + { + __sync_lock_release(&storage); + if (order == memory_order_seq_cst) + __sync_synchronize(); + } +}; + +#if BOOST_ATOMIC_INT8_LOCK_FREE > 0 +template< bool Signed > +struct operations< 1u, Signed > : +#if defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1) + public gcc_sync_operations< typename make_storage_type< 1u, Signed >::type > +#elif defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2) + public extending_cas_based_operations< gcc_sync_operations< typename make_storage_type< 2u, Signed >::type >, 1u, Signed > +#elif defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4) + public extending_cas_based_operations< gcc_sync_operations< typename make_storage_type< 4u, Signed >::type >, 1u, Signed > +#elif defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8) + public extending_cas_based_operations< gcc_sync_operations< typename make_storage_type< 8u, Signed >::type >, 1u, Signed > +#else + public extending_cas_based_operations< gcc_sync_operations< typename make_storage_type< 16u, Signed >::type >, 1u, Signed > +#endif +{ +#if defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1) + typedef typename make_storage_type< 1u, Signed >::aligned aligned_storage_type; +#elif defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2) + typedef typename make_storage_type< 2u, Signed >::aligned aligned_storage_type; +#elif defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4) + typedef typename make_storage_type< 4u, Signed >::aligned aligned_storage_type; +#elif defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8) + typedef typename make_storage_type< 8u, Signed >::aligned aligned_storage_type; +#else + typedef typename make_storage_type< 16u, Signed >::aligned aligned_storage_type; +#endif +}; +#endif + +#if BOOST_ATOMIC_INT16_LOCK_FREE > 0 +template< bool Signed > +struct operations< 2u, Signed > : +#if defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2) + public gcc_sync_operations< typename make_storage_type< 2u, Signed >::type > +#elif defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4) + public extending_cas_based_operations< gcc_sync_operations< typename make_storage_type< 4u, Signed >::type >, 2u, Signed > +#elif defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8) + public extending_cas_based_operations< gcc_sync_operations< typename make_storage_type< 8u, Signed >::type >, 2u, Signed > +#else + public extending_cas_based_operations< gcc_sync_operations< typename make_storage_type< 16u, Signed >::type >, 2u, Signed > +#endif +{ +#if defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2) + typedef typename make_storage_type< 2u, Signed >::aligned aligned_storage_type; +#elif defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4) + typedef typename make_storage_type< 4u, Signed >::aligned aligned_storage_type; +#elif defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8) + typedef typename make_storage_type< 8u, Signed >::aligned aligned_storage_type; +#else + typedef typename make_storage_type< 16u, Signed >::aligned aligned_storage_type; +#endif +}; +#endif + +#if BOOST_ATOMIC_INT32_LOCK_FREE > 0 +template< bool Signed > +struct operations< 4u, Signed > : +#if defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4) + public gcc_sync_operations< typename make_storage_type< 4u, Signed >::type > +#elif defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8) + public extending_cas_based_operations< gcc_sync_operations< typename make_storage_type< 8u, Signed >::type >, 4u, Signed > +#else + public extending_cas_based_operations< gcc_sync_operations< typename make_storage_type< 16u, Signed >::type >, 4u, Signed > +#endif +{ +#if defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4) + typedef typename make_storage_type< 4u, Signed >::aligned aligned_storage_type; +#elif defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8) + typedef typename make_storage_type< 8u, Signed >::aligned aligned_storage_type; +#else + typedef typename make_storage_type< 16u, Signed >::aligned aligned_storage_type; +#endif +}; +#endif + +#if BOOST_ATOMIC_INT64_LOCK_FREE > 0 +template< bool Signed > +struct operations< 8u, Signed > : +#if defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8) + public gcc_sync_operations< typename make_storage_type< 8u, Signed >::type > +#else + public extending_cas_based_operations< gcc_sync_operations< typename make_storage_type< 16u, Signed >::type >, 8u, Signed > +#endif +{ +#if defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8) + typedef typename make_storage_type< 8u, Signed >::aligned aligned_storage_type; +#else + typedef typename make_storage_type< 16u, Signed >::aligned aligned_storage_type; +#endif +}; +#endif + +#if BOOST_ATOMIC_INT128_LOCK_FREE > 0 +template< bool Signed > +struct operations< 16u, Signed > : + public gcc_sync_operations< typename make_storage_type< 16u, Signed >::type > +{ + typedef typename make_storage_type< 16u, Signed >::aligned aligned_storage_type; +}; +#endif + +BOOST_FORCEINLINE void thread_fence(memory_order order) BOOST_NOEXCEPT +{ + if (order != memory_order_relaxed) + __sync_synchronize(); +} + +BOOST_FORCEINLINE void signal_fence(memory_order order) BOOST_NOEXCEPT +{ + if (order != memory_order_relaxed) + __asm__ __volatile__ ("" ::: "memory"); +} + +} // namespace detail +} // namespace atomics +} // namespace boost + +#endif // BOOST_ATOMIC_DETAIL_OPS_GCC_SYNC_HPP_INCLUDED_ diff --git a/libs/boost/include/boost/atomic/detail/ops_gcc_x86.hpp b/libs/boost/include/boost/atomic/detail/ops_gcc_x86.hpp new file mode 100644 index 0000000..74e45c1 --- /dev/null +++ b/libs/boost/include/boost/atomic/detail/ops_gcc_x86.hpp @@ -0,0 +1,511 @@ +/* + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or copy at + * http://www.boost.org/LICENSE_1_0.txt) + * + * Copyright (c) 2009 Helge Bahmann + * Copyright (c) 2012 Tim Blechmann + * Copyright (c) 2014 Andrey Semashev + */ +/*! + * \file atomic/detail/ops_gcc_x86.hpp + * + * This header contains implementation of the \c operations template. + */ + +#ifndef BOOST_ATOMIC_DETAIL_OPS_GCC_X86_HPP_INCLUDED_ +#define BOOST_ATOMIC_DETAIL_OPS_GCC_X86_HPP_INCLUDED_ + +#include +#include +#include +#include +#include +#if defined(BOOST_ATOMIC_DETAIL_X86_HAS_CMPXCHG8B) || defined(BOOST_ATOMIC_DETAIL_X86_HAS_CMPXCHG16B) +#include +#include +#endif + +#ifdef BOOST_HAS_PRAGMA_ONCE +#pragma once +#endif + +#if defined(__x86_64__) +#define BOOST_ATOMIC_DETAIL_TEMP_CAS_REGISTER "rdx" +#else +#define BOOST_ATOMIC_DETAIL_TEMP_CAS_REGISTER "edx" +#endif + +namespace boost { +namespace atomics { +namespace detail { + +struct gcc_x86_operations_base +{ + static BOOST_CONSTEXPR_OR_CONST bool is_always_lock_free = true; + + static BOOST_FORCEINLINE void fence_before(memory_order order) BOOST_NOEXCEPT + { + if ((order & memory_order_release) != 0) + __asm__ __volatile__ ("" ::: "memory"); + } + + static BOOST_FORCEINLINE void fence_after(memory_order order) BOOST_NOEXCEPT + { + if ((order & memory_order_acquire) != 0) + __asm__ __volatile__ ("" ::: "memory"); + } +}; + +template< typename T, typename Derived > +struct gcc_x86_operations : + public gcc_x86_operations_base +{ + typedef T storage_type; + + static BOOST_FORCEINLINE void store(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + if (order != memory_order_seq_cst) + { + fence_before(order); + storage = v; + fence_after(order); + } + else + { + Derived::exchange(storage, v, order); + } + } + + static BOOST_FORCEINLINE storage_type load(storage_type const volatile& storage, memory_order order) BOOST_NOEXCEPT + { + storage_type v = storage; + fence_after(order); + return v; + } + + static BOOST_FORCEINLINE storage_type fetch_sub(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + return Derived::fetch_add(storage, -v, order); + } + + static BOOST_FORCEINLINE bool compare_exchange_weak( + storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order success_order, memory_order failure_order) BOOST_NOEXCEPT + { + return Derived::compare_exchange_strong(storage, expected, desired, success_order, failure_order); + } + + static BOOST_FORCEINLINE bool test_and_set(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT + { + return !!Derived::exchange(storage, (storage_type)1, order); + } + + static BOOST_FORCEINLINE void clear(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT + { + store(storage, (storage_type)0, order); + } +}; + +template< bool Signed > +struct operations< 1u, Signed > : + public gcc_x86_operations< typename make_storage_type< 1u, Signed >::type, operations< 1u, Signed > > +{ + typedef gcc_x86_operations< typename make_storage_type< 1u, Signed >::type, operations< 1u, Signed > > base_type; + typedef typename base_type::storage_type storage_type; + typedef typename make_storage_type< 1u, Signed >::aligned aligned_storage_type; + + static BOOST_FORCEINLINE storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT + { + __asm__ __volatile__ + ( + "lock; xaddb %0, %1" + : "+q" (v), "+m" (storage) + : + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC_COMMA "memory" + ); + return v; + } + + static BOOST_FORCEINLINE storage_type exchange(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT + { + __asm__ __volatile__ + ( + "xchgb %0, %1" + : "+q" (v), "+m" (storage) + : + : "memory" + ); + return v; + } + + static BOOST_FORCEINLINE bool compare_exchange_strong( + storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order, memory_order) BOOST_NOEXCEPT + { + storage_type previous = expected; + bool success; + __asm__ __volatile__ + ( + "lock; cmpxchgb %3, %1\n\t" + "sete %2" + : "+a" (previous), "+m" (storage), "=q" (success) + : "q" (desired) + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC_COMMA "memory" + ); + expected = previous; + return success; + } + +#define BOOST_ATOMIC_DETAIL_CAS_LOOP(op, argument, result)\ + __asm__ __volatile__\ + (\ + "xor %%" BOOST_ATOMIC_DETAIL_TEMP_CAS_REGISTER ", %%" BOOST_ATOMIC_DETAIL_TEMP_CAS_REGISTER "\n\t"\ + ".align 16\n\t"\ + "1: movb %[arg], %%dl\n\t"\ + op " %%al, %%dl\n\t"\ + "lock; cmpxchgb %%dl, %[storage]\n\t"\ + "jne 1b"\ + : [res] "+a" (result), [storage] "+m" (storage)\ + : [arg] "q" (argument)\ + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC_COMMA BOOST_ATOMIC_DETAIL_TEMP_CAS_REGISTER, "memory"\ + ) + + static BOOST_FORCEINLINE storage_type fetch_and(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT + { + storage_type res = storage; + BOOST_ATOMIC_DETAIL_CAS_LOOP("andb", v, res); + return res; + } + + static BOOST_FORCEINLINE storage_type fetch_or(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT + { + storage_type res = storage; + BOOST_ATOMIC_DETAIL_CAS_LOOP("orb", v, res); + return res; + } + + static BOOST_FORCEINLINE storage_type fetch_xor(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT + { + storage_type res = storage; + BOOST_ATOMIC_DETAIL_CAS_LOOP("xorb", v, res); + return res; + } + +#undef BOOST_ATOMIC_DETAIL_CAS_LOOP +}; + +template< bool Signed > +struct operations< 2u, Signed > : + public gcc_x86_operations< typename make_storage_type< 2u, Signed >::type, operations< 2u, Signed > > +{ + typedef gcc_x86_operations< typename make_storage_type< 2u, Signed >::type, operations< 2u, Signed > > base_type; + typedef typename base_type::storage_type storage_type; + typedef typename make_storage_type< 2u, Signed >::aligned aligned_storage_type; + + static BOOST_FORCEINLINE storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT + { + __asm__ __volatile__ + ( + "lock; xaddw %0, %1" + : "+q" (v), "+m" (storage) + : + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC_COMMA "memory" + ); + return v; + } + + static BOOST_FORCEINLINE storage_type exchange(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT + { + __asm__ __volatile__ + ( + "xchgw %0, %1" + : "+q" (v), "+m" (storage) + : + : "memory" + ); + return v; + } + + static BOOST_FORCEINLINE bool compare_exchange_strong( + storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order, memory_order) BOOST_NOEXCEPT + { + storage_type previous = expected; + bool success; + __asm__ __volatile__ + ( + "lock; cmpxchgw %3, %1\n\t" + "sete %2" + : "+a" (previous), "+m" (storage), "=q" (success) + : "q" (desired) + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC_COMMA "memory" + ); + expected = previous; + return success; + } + +#define BOOST_ATOMIC_DETAIL_CAS_LOOP(op, argument, result)\ + __asm__ __volatile__\ + (\ + "xor %%" BOOST_ATOMIC_DETAIL_TEMP_CAS_REGISTER ", %%" BOOST_ATOMIC_DETAIL_TEMP_CAS_REGISTER "\n\t"\ + ".align 16\n\t"\ + "1: movw %[arg], %%dx\n\t"\ + op " %%ax, %%dx\n\t"\ + "lock; cmpxchgw %%dx, %[storage]\n\t"\ + "jne 1b"\ + : [res] "+a" (result), [storage] "+m" (storage)\ + : [arg] "q" (argument)\ + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC_COMMA BOOST_ATOMIC_DETAIL_TEMP_CAS_REGISTER, "memory"\ + ) + + static BOOST_FORCEINLINE storage_type fetch_and(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT + { + storage_type res = storage; + BOOST_ATOMIC_DETAIL_CAS_LOOP("andw", v, res); + return res; + } + + static BOOST_FORCEINLINE storage_type fetch_or(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT + { + storage_type res = storage; + BOOST_ATOMIC_DETAIL_CAS_LOOP("orw", v, res); + return res; + } + + static BOOST_FORCEINLINE storage_type fetch_xor(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT + { + storage_type res = storage; + BOOST_ATOMIC_DETAIL_CAS_LOOP("xorw", v, res); + return res; + } + +#undef BOOST_ATOMIC_DETAIL_CAS_LOOP +}; + +template< bool Signed > +struct operations< 4u, Signed > : + public gcc_x86_operations< typename make_storage_type< 4u, Signed >::type, operations< 4u, Signed > > +{ + typedef gcc_x86_operations< typename make_storage_type< 4u, Signed >::type, operations< 4u, Signed > > base_type; + typedef typename base_type::storage_type storage_type; + typedef typename make_storage_type< 4u, Signed >::aligned aligned_storage_type; + + static BOOST_FORCEINLINE storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT + { + __asm__ __volatile__ + ( + "lock; xaddl %0, %1" + : "+r" (v), "+m" (storage) + : + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC_COMMA "memory" + ); + return v; + } + + static BOOST_FORCEINLINE storage_type exchange(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT + { + __asm__ __volatile__ + ( + "xchgl %0, %1" + : "+r" (v), "+m" (storage) + : + : "memory" + ); + return v; + } + + static BOOST_FORCEINLINE bool compare_exchange_strong( + storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order, memory_order) BOOST_NOEXCEPT + { + storage_type previous = expected; + bool success; + __asm__ __volatile__ + ( + "lock; cmpxchgl %3, %1\n\t" + "sete %2" + : "+a" (previous), "+m" (storage), "=q" (success) + : "r" (desired) + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC_COMMA "memory" + ); + expected = previous; + return success; + } + +#define BOOST_ATOMIC_DETAIL_CAS_LOOP(op, argument, result)\ + __asm__ __volatile__\ + (\ + "xor %%" BOOST_ATOMIC_DETAIL_TEMP_CAS_REGISTER ", %%" BOOST_ATOMIC_DETAIL_TEMP_CAS_REGISTER "\n\t"\ + ".align 16\n\t"\ + "1: movl %[arg], %%edx\n\t"\ + op " %%eax, %%edx\n\t"\ + "lock; cmpxchgl %%edx, %[storage]\n\t"\ + "jne 1b"\ + : [res] "+a" (result), [storage] "+m" (storage)\ + : [arg] "r" (argument)\ + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC_COMMA BOOST_ATOMIC_DETAIL_TEMP_CAS_REGISTER, "memory"\ + ) + + static BOOST_FORCEINLINE storage_type fetch_and(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT + { + storage_type res = storage; + BOOST_ATOMIC_DETAIL_CAS_LOOP("andl", v, res); + return res; + } + + static BOOST_FORCEINLINE storage_type fetch_or(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT + { + storage_type res = storage; + BOOST_ATOMIC_DETAIL_CAS_LOOP("orl", v, res); + return res; + } + + static BOOST_FORCEINLINE storage_type fetch_xor(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT + { + storage_type res = storage; + BOOST_ATOMIC_DETAIL_CAS_LOOP("xorl", v, res); + return res; + } + +#undef BOOST_ATOMIC_DETAIL_CAS_LOOP +}; + +#if defined(BOOST_ATOMIC_DETAIL_X86_HAS_CMPXCHG8B) + +template< bool Signed > +struct operations< 8u, Signed > : + public cas_based_operations< gcc_dcas_x86< Signed > > +{ +}; + +#elif defined(__x86_64__) + +template< bool Signed > +struct operations< 8u, Signed > : + public gcc_x86_operations< typename make_storage_type< 8u, Signed >::type, operations< 8u, Signed > > +{ + typedef gcc_x86_operations< typename make_storage_type< 8u, Signed >::type, operations< 8u, Signed > > base_type; + typedef typename base_type::storage_type storage_type; + typedef typename make_storage_type< 8u, Signed >::aligned aligned_storage_type; + + static BOOST_FORCEINLINE storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT + { + __asm__ __volatile__ + ( + "lock; xaddq %0, %1" + : "+r" (v), "+m" (storage) + : + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC_COMMA "memory" + ); + return v; + } + + static BOOST_FORCEINLINE storage_type exchange(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT + { + __asm__ __volatile__ + ( + "xchgq %0, %1" + : "+r" (v), "+m" (storage) + : + : "memory" + ); + return v; + } + + static BOOST_FORCEINLINE bool compare_exchange_strong( + storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order, memory_order) BOOST_NOEXCEPT + { + storage_type previous = expected; + bool success; + __asm__ __volatile__ + ( + "lock; cmpxchgq %3, %1\n\t" + "sete %2" + : "+a" (previous), "+m" (storage), "=q" (success) + : "r" (desired) + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC_COMMA "memory" + ); + expected = previous; + return success; + } + +#define BOOST_ATOMIC_DETAIL_CAS_LOOP(op, argument, result)\ + __asm__ __volatile__\ + (\ + "xor %%" BOOST_ATOMIC_DETAIL_TEMP_CAS_REGISTER ", %%" BOOST_ATOMIC_DETAIL_TEMP_CAS_REGISTER "\n\t"\ + ".align 16\n\t"\ + "1: movq %[arg], %%rdx\n\t"\ + op " %%rax, %%rdx\n\t"\ + "lock; cmpxchgq %%rdx, %[storage]\n\t"\ + "jne 1b"\ + : [res] "+a" (result), [storage] "+m" (storage)\ + : [arg] "r" (argument)\ + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC_COMMA BOOST_ATOMIC_DETAIL_TEMP_CAS_REGISTER, "memory"\ + ) + + static BOOST_FORCEINLINE storage_type fetch_and(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT + { + storage_type res = storage; + BOOST_ATOMIC_DETAIL_CAS_LOOP("andq", v, res); + return res; + } + + static BOOST_FORCEINLINE storage_type fetch_or(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT + { + storage_type res = storage; + BOOST_ATOMIC_DETAIL_CAS_LOOP("orq", v, res); + return res; + } + + static BOOST_FORCEINLINE storage_type fetch_xor(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT + { + storage_type res = storage; + BOOST_ATOMIC_DETAIL_CAS_LOOP("xorq", v, res); + return res; + } + +#undef BOOST_ATOMIC_DETAIL_CAS_LOOP +}; + +#endif + +#if defined(BOOST_ATOMIC_DETAIL_X86_HAS_CMPXCHG16B) + +template< bool Signed > +struct operations< 16u, Signed > : + public cas_based_operations< gcc_dcas_x86_64< Signed > > +{ +}; + +#endif // defined(BOOST_ATOMIC_DETAIL_X86_HAS_CMPXCHG16B) + +BOOST_FORCEINLINE void thread_fence(memory_order order) BOOST_NOEXCEPT +{ + if (order == memory_order_seq_cst) + { + __asm__ __volatile__ + ( +#if defined(BOOST_ATOMIC_DETAIL_X86_HAS_MFENCE) + "mfence\n" +#else + "lock; addl $0, (%%esp)\n" +#endif + ::: "memory" + ); + } + else if ((order & (memory_order_acquire | memory_order_release)) != 0) + { + __asm__ __volatile__ ("" ::: "memory"); + } +} + +BOOST_FORCEINLINE void signal_fence(memory_order order) BOOST_NOEXCEPT +{ + if (order != memory_order_relaxed) + __asm__ __volatile__ ("" ::: "memory"); +} + +} // namespace detail +} // namespace atomics +} // namespace boost + +#undef BOOST_ATOMIC_DETAIL_TEMP_CAS_REGISTER + +#endif // BOOST_ATOMIC_DETAIL_OPS_GCC_X86_HPP_INCLUDED_ diff --git a/libs/boost/include/boost/atomic/detail/ops_gcc_x86_dcas.hpp b/libs/boost/include/boost/atomic/detail/ops_gcc_x86_dcas.hpp new file mode 100644 index 0000000..7f39621 --- /dev/null +++ b/libs/boost/include/boost/atomic/detail/ops_gcc_x86_dcas.hpp @@ -0,0 +1,617 @@ +/* + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or copy at + * http://www.boost.org/LICENSE_1_0.txt) + * + * Copyright (c) 2009 Helge Bahmann + * Copyright (c) 2012 Tim Blechmann + * Copyright (c) 2014 Andrey Semashev + */ +/*! + * \file atomic/detail/ops_gcc_x86_dcas.hpp + * + * This header contains implementation of the double-width CAS primitive for x86. + */ + +#ifndef BOOST_ATOMIC_DETAIL_OPS_GCC_X86_DCAS_HPP_INCLUDED_ +#define BOOST_ATOMIC_DETAIL_OPS_GCC_X86_DCAS_HPP_INCLUDED_ + +#include +#include +#include +#include +#include + +#ifdef BOOST_HAS_PRAGMA_ONCE +#pragma once +#endif + +namespace boost { +namespace atomics { +namespace detail { + +#if defined(BOOST_ATOMIC_DETAIL_X86_HAS_CMPXCHG8B) + +template< bool Signed > +struct gcc_dcas_x86 +{ + typedef typename make_storage_type< 8u, Signed >::type storage_type; + typedef typename make_storage_type< 8u, Signed >::aligned aligned_storage_type; + + static BOOST_CONSTEXPR_OR_CONST bool is_always_lock_free = true; + + static BOOST_FORCEINLINE void store(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT + { + if ((((uint32_t)&storage) & 0x00000007) == 0) + { +#if defined(__SSE2__) + __asm__ __volatile__ + ( +#if defined(__AVX__) + "vmovq %1, %%xmm4\n\t" + "vmovq %%xmm4, %0\n\t" +#else + "movq %1, %%xmm4\n\t" + "movq %%xmm4, %0\n\t" +#endif + : "=m" (storage) + : "m" (v) + : "memory", "xmm4" + ); +#else + __asm__ __volatile__ + ( + "fildll %1\n\t" + "fistpll %0\n\t" + : "=m" (storage) + : "m" (v) + : "memory" + ); +#endif + } + else + { +#if !defined(BOOST_ATOMIC_DETAIL_NO_ASM_IMPLIED_ZERO_DISPLACEMENTS) +#if defined(__PIC__) + uint32_t v_lo = (uint32_t)v; + uint32_t scratch; + __asm__ __volatile__ + ( + "movl %%ebx, %[scratch]\n\t" + "movl %[value_lo], %%ebx\n\t" + "movl %[dest], %%eax\n\t" + "movl 4+%[dest], %%edx\n\t" + ".align 16\n\t" + "1: lock; cmpxchg8b %[dest]\n\t" + "jne 1b\n\t" + "movl %[scratch], %%ebx\n\t" + : [scratch] "=m" (scratch), [dest] "=o" (storage), [value_lo] "+a" (v_lo) + : "c" ((uint32_t)(v >> 32)) + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC_COMMA "edx", "memory" + ); +#else // defined(__PIC__) + __asm__ __volatile__ + ( + "movl %[dest], %%eax\n\t" + "movl 4+%[dest], %%edx\n\t" + ".align 16\n\t" + "1: lock; cmpxchg8b %[dest]\n\t" + "jne 1b\n\t" + : [dest] "=o" (storage) + : [value_lo] "b" ((uint32_t)v), "c" ((uint32_t)(v >> 32)) + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC_COMMA "eax", "edx", "memory" + ); +#endif // defined(__PIC__) +#else // !defined(BOOST_ATOMIC_DETAIL_NO_ASM_IMPLIED_ZERO_DISPLACEMENTS) +#if defined(__PIC__) + uint32_t v_lo = (uint32_t)v; + uint32_t scratch; + __asm__ __volatile__ + ( + "movl %%ebx, %[scratch]\n\t" + "movl %[value_lo], %%ebx\n\t" + "movl 0(%[dest]), %%eax\n\t" + "movl 4(%[dest]), %%edx\n\t" + ".align 16\n\t" + "1: lock; cmpxchg8b 0(%[dest])\n\t" + "jne 1b\n\t" + "movl %[scratch], %%ebx\n\t" +#if !defined(BOOST_ATOMIC_DETAIL_NO_ASM_CONSTRAINT_ALTERNATIVES) + : [scratch] "=m,m" (scratch), [value_lo] "+a,a" (v_lo) + : "c,c" ((uint32_t)(v >> 32)), [dest] "D,S" (&storage) +#else + : [scratch] "=m" (scratch), [value_lo] "+a" (v_lo) + : "c" ((uint32_t)(v >> 32)), [dest] "D" (&storage) +#endif + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC_COMMA "edx", "memory" + ); +#else // defined(__PIC__) + __asm__ __volatile__ + ( + "movl 0(%[dest]), %%eax\n\t" + "movl 4(%[dest]), %%edx\n\t" + ".align 16\n\t" + "1: lock; cmpxchg8b 0(%[dest])\n\t" + "jne 1b\n\t" + : +#if !defined(BOOST_ATOMIC_DETAIL_NO_ASM_CONSTRAINT_ALTERNATIVES) + : [value_lo] "b,b" ((uint32_t)v), "c,c" ((uint32_t)(v >> 32)), [dest] "D,S" (&storage) +#else + : [value_lo] "b" ((uint32_t)v), "c" ((uint32_t)(v >> 32)), [dest] "D" (&storage) +#endif + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC_COMMA "eax", "edx", "memory" + ); +#endif // defined(__PIC__) +#endif // !defined(BOOST_ATOMIC_DETAIL_NO_ASM_IMPLIED_ZERO_DISPLACEMENTS) + } + } + + static BOOST_FORCEINLINE storage_type load(storage_type const volatile& storage, memory_order) BOOST_NOEXCEPT + { + storage_type value; + + if ((((uint32_t)&storage) & 0x00000007) == 0) + { +#if defined(__SSE2__) + __asm__ __volatile__ + ( +#if defined(__AVX__) + "vmovq %1, %%xmm4\n\t" + "vmovq %%xmm4, %0\n\t" +#else + "movq %1, %%xmm4\n\t" + "movq %%xmm4, %0\n\t" +#endif + : "=m" (value) + : "m" (storage) + : "memory", "xmm4" + ); +#else + __asm__ __volatile__ + ( + "fildll %1\n\t" + "fistpll %0\n\t" + : "=m" (value) + : "m" (storage) + : "memory" + ); +#endif + } + else + { +#if defined(__clang__) + // Clang cannot allocate eax:edx register pairs but it has sync intrinsics + value = __sync_val_compare_and_swap(&storage, (storage_type)0, (storage_type)0); +#else + // We don't care for comparison result here; the previous value will be stored into value anyway. + // Also we don't care for ebx and ecx values, they just have to be equal to eax and edx before cmpxchg8b. + __asm__ __volatile__ + ( + "movl %%ebx, %%eax\n\t" + "movl %%ecx, %%edx\n\t" + "lock; cmpxchg8b %[storage]\n\t" + : "=&A" (value) + : [storage] "m" (storage) + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC_COMMA "memory" + ); +#endif + } + + return value; + } + + static BOOST_FORCEINLINE bool compare_exchange_strong( + storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order, memory_order) BOOST_NOEXCEPT + { +#if defined(__clang__) + // Clang cannot allocate eax:edx register pairs but it has sync intrinsics + storage_type old_expected = expected; + expected = __sync_val_compare_and_swap(&storage, old_expected, desired); + return expected == old_expected; +#elif defined(__PIC__) + // Make sure ebx is saved and restored properly in case + // of position independent code. To make this work + // setup register constraints such that ebx can not be + // used by accident e.g. as base address for the variable + // to be modified. Accessing "scratch" should always be okay, + // as it can only be placed on the stack (and therefore + // accessed through ebp or esp only). + // + // In theory, could push/pop ebx onto/off the stack, but movs + // to a prepared stack slot turn out to be faster. + + uint32_t scratch; + bool success; + __asm__ __volatile__ + ( + "movl %%ebx, %[scratch]\n\t" + "movl %[desired_lo], %%ebx\n\t" + "lock; cmpxchg8b %[dest]\n\t" + "movl %[scratch], %%ebx\n\t" + "sete %[success]\n\t" +#if !defined(BOOST_ATOMIC_DETAIL_NO_ASM_CONSTRAINT_ALTERNATIVES) + : "+A,A,A,A,A,A" (expected), [dest] "+m,m,m,m,m,m" (storage), [scratch] "=m,m,m,m,m,m" (scratch), [success] "=q,m,q,m,q,m" (success) + : [desired_lo] "S,S,D,D,m,m" ((uint32_t)desired), "c,c,c,c,c,c" ((uint32_t)(desired >> 32)) +#else + : "+A" (expected), [dest] "+m" (storage), [scratch] "=m" (scratch), [success] "=q" (success) + : [desired_lo] "S" ((uint32_t)desired), "c" ((uint32_t)(desired >> 32)) +#endif + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC_COMMA "memory" + ); + return success; +#else + bool success; + __asm__ __volatile__ + ( + "lock; cmpxchg8b %[dest]\n\t" + "sete %[success]\n\t" +#if !defined(BOOST_ATOMIC_DETAIL_NO_ASM_CONSTRAINT_ALTERNATIVES) + : "+A,A" (expected), [dest] "+m,m" (storage), [success] "=q,m" (success) + : "b,b" ((uint32_t)desired), "c,c" ((uint32_t)(desired >> 32)) +#else + : "+A" (expected), [dest] "+m" (storage), [success] "=q" (success) + : "b" ((uint32_t)desired), "c" ((uint32_t)(desired >> 32)) +#endif + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC_COMMA "memory" + ); + return success; +#endif + } + + static BOOST_FORCEINLINE bool compare_exchange_weak( + storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order success_order, memory_order failure_order) BOOST_NOEXCEPT + { + return compare_exchange_strong(storage, expected, desired, success_order, failure_order); + } + + static BOOST_FORCEINLINE storage_type exchange(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { +#if defined(__clang__) + // Clang cannot allocate eax:edx register pairs but it has sync intrinsics + storage_type old_val = storage; + while (true) + { + storage_type val = __sync_val_compare_and_swap(&storage, old_val, v); + if (val == old_val) + return val; + old_val = val; + } +#elif !defined(BOOST_ATOMIC_DETAIL_NO_ASM_IMPLIED_ZERO_DISPLACEMENTS) +#if defined(__PIC__) + uint32_t scratch; + __asm__ __volatile__ + ( + "movl %%ebx, %[scratch]\n\t" + "movl %%eax, %%ebx\n\t" + "movl %%edx, %%ecx\n\t" + "movl %[dest], %%eax\n\t" + "movl 4+%[dest], %%edx\n\t" + ".align 16\n\t" + "1: lock; cmpxchg8b %[dest]\n\t" + "jne 1b\n\t" + "movl %[scratch], %%ebx\n\t" + : "+A" (v), [scratch] "=m" (scratch), [dest] "+o" (storage) + : + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC_COMMA "ecx", "memory" + ); + return v; +#else // defined(__PIC__) + __asm__ __volatile__ + ( + "movl %[dest], %%eax\n\t" + "movl 4+%[dest], %%edx\n\t" + ".align 16\n\t" + "1: lock; cmpxchg8b %[dest]\n\t" + "jne 1b\n\t" + : "=A" (v), [dest] "+o" (storage) + : "b" ((uint32_t)v), "c" ((uint32_t)(v >> 32)) + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC_COMMA "memory" + ); + return v; +#endif // defined(__PIC__) +#else // !defined(BOOST_ATOMIC_DETAIL_NO_ASM_IMPLIED_ZERO_DISPLACEMENTS) +#if defined(__PIC__) + uint32_t scratch; + __asm__ __volatile__ + ( + "movl %%ebx, %[scratch]\n\t" + "movl %%eax, %%ebx\n\t" + "movl %%edx, %%ecx\n\t" + "movl 0(%[dest]), %%eax\n\t" + "movl 4(%[dest]), %%edx\n\t" + ".align 16\n\t" + "1: lock; cmpxchg8b 0(%[dest])\n\t" + "jne 1b\n\t" + "movl %[scratch], %%ebx\n\t" +#if !defined(BOOST_ATOMIC_DETAIL_NO_ASM_CONSTRAINT_ALTERNATIVES) + : "+A,A" (v), [scratch] "=m,m" (scratch) + : [dest] "D,S" (&storage) +#else + : "+A" (v), [scratch] "=m" (scratch) + : [dest] "D" (&storage) +#endif + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC_COMMA "ecx", "memory" + ); + return v; +#else // defined(__PIC__) + __asm__ __volatile__ + ( + "movl 0(%[dest]), %%eax\n\t" + "movl 4(%[dest]), %%edx\n\t" + ".align 16\n\t" + "1: lock; cmpxchg8b 0(%[dest])\n\t" + "jne 1b\n\t" +#if !defined(BOOST_ATOMIC_DETAIL_NO_ASM_CONSTRAINT_ALTERNATIVES) + : "=A,A" (v) + : "b,b" ((uint32_t)v), "c,c" ((uint32_t)(v >> 32)), [dest] "D,S" (&storage) +#else + : "=A" (v) + : "b" ((uint32_t)v), "c" ((uint32_t)(v >> 32)), [dest] "D" (&storage) +#endif + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC_COMMA "memory" + ); + return v; +#endif // defined(__PIC__) +#endif + } +}; + +#endif // defined(BOOST_ATOMIC_DETAIL_X86_HAS_CMPXCHG8B) + +#if defined(BOOST_ATOMIC_DETAIL_X86_HAS_CMPXCHG16B) + +template< bool Signed > +struct gcc_dcas_x86_64 +{ + typedef typename make_storage_type< 16u, Signed >::type storage_type; + typedef typename make_storage_type< 16u, Signed >::aligned aligned_storage_type; + + static BOOST_CONSTEXPR_OR_CONST bool is_always_lock_free = true; + + static BOOST_FORCEINLINE void store(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT + { + uint64_t const* p_value = (uint64_t const*)&v; + const uint64_t v_lo = p_value[0], v_hi = p_value[1]; +#if !defined(BOOST_ATOMIC_DETAIL_NO_ASM_IMPLIED_ZERO_DISPLACEMENTS) + __asm__ __volatile__ + ( + "movq %[dest], %%rax\n\t" + "movq 8+%[dest], %%rdx\n\t" + ".align 16\n\t" + "1: lock; cmpxchg16b %[dest]\n\t" + "jne 1b\n\t" + : [dest] "=o" (storage) + : "b" (v_lo), "c" (v_hi) + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC_COMMA "rax", "rdx", "memory" + ); +#else // !defined(BOOST_ATOMIC_DETAIL_NO_ASM_IMPLIED_ZERO_DISPLACEMENTS) + __asm__ __volatile__ + ( + "movq 0(%[dest]), %%rax\n\t" + "movq 8(%[dest]), %%rdx\n\t" + ".align 16\n\t" + "1: lock; cmpxchg16b 0(%[dest])\n\t" + "jne 1b\n\t" + : + : "b" (v_lo), "c" (v_hi), [dest] "r" (&storage) + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC_COMMA "rax", "rdx", "memory" + ); +#endif // !defined(BOOST_ATOMIC_DETAIL_NO_ASM_IMPLIED_ZERO_DISPLACEMENTS) + } + + static BOOST_FORCEINLINE storage_type load(storage_type const volatile& storage, memory_order) BOOST_NOEXCEPT + { +#if defined(__clang__) + // Clang cannot allocate rax:rdx register pairs but it has sync intrinsics + storage_type value = storage_type(); + return __sync_val_compare_and_swap(&storage, value, value); +#elif defined(BOOST_ATOMIC_DETAIL_NO_ASM_RAX_RDX_PAIRS) + // GCC 4.4 can't allocate rax:rdx register pair either but it also doesn't support 128-bit __sync_val_compare_and_swap + storage_type value; + + // We don't care for comparison result here; the previous value will be stored into value anyway. + // Also we don't care for rbx and rcx values, they just have to be equal to rax and rdx before cmpxchg16b. +#if !defined(BOOST_ATOMIC_DETAIL_NO_ASM_IMPLIED_ZERO_DISPLACEMENTS) + __asm__ __volatile__ + ( + "movq %%rbx, %%rax\n\t" + "movq %%rcx, %%rdx\n\t" + "lock; cmpxchg16b %[storage]\n\t" + "movq %%rax, %[value]\n\t" + "movq %%rdx, 8+%[value]\n\t" + : [value] "=o" (value) + : [storage] "m" (storage) + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC_COMMA "memory", "rax", "rdx" + ); +#else // !defined(BOOST_ATOMIC_DETAIL_NO_ASM_IMPLIED_ZERO_DISPLACEMENTS) + __asm__ __volatile__ + ( + "movq %%rbx, %%rax\n\t" + "movq %%rcx, %%rdx\n\t" + "lock; cmpxchg16b %[storage]\n\t" + "movq %%rax, 0(%[value])\n\t" + "movq %%rdx, 8(%[value])\n\t" + : + : [storage] "m" (storage), [value] "r" (&value) + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC_COMMA "memory", "rax", "rdx" + ); +#endif // !defined(BOOST_ATOMIC_DETAIL_NO_ASM_IMPLIED_ZERO_DISPLACEMENTS) + + return value; +#else // defined(BOOST_ATOMIC_DETAIL_NO_ASM_RAX_RDX_PAIRS) + storage_type value; + + // We don't care for comparison result here; the previous value will be stored into value anyway. + // Also we don't care for rbx and rcx values, they just have to be equal to rax and rdx before cmpxchg16b. + __asm__ __volatile__ + ( + "movq %%rbx, %%rax\n\t" + "movq %%rcx, %%rdx\n\t" + "lock; cmpxchg16b %[storage]\n\t" + : "=&A" (value) + : [storage] "m" (storage) + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC_COMMA "memory" + ); + + return value; +#endif + } + + static BOOST_FORCEINLINE bool compare_exchange_strong( + storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order, memory_order) BOOST_NOEXCEPT + { +#if defined(__clang__) + // Clang cannot allocate rax:rdx register pairs but it has sync intrinsics + storage_type old_expected = expected; + expected = __sync_val_compare_and_swap(&storage, old_expected, desired); + return expected == old_expected; +#elif defined(BOOST_ATOMIC_DETAIL_NO_ASM_RAX_RDX_PAIRS) + // GCC 4.4 can't allocate rax:rdx register pair either but it also doesn't support 128-bit __sync_val_compare_and_swap + uint64_t const* p_desired = (uint64_t const*)&desired; + const uint64_t desired_lo = p_desired[0], desired_hi = p_desired[1]; + bool success; +#if !defined(BOOST_ATOMIC_DETAIL_NO_ASM_IMPLIED_ZERO_DISPLACEMENTS) + __asm__ __volatile__ + ( + "movq %[expected], %%rax\n\t" + "movq 8+%[expected], %%rdx\n\t" + "lock; cmpxchg16b %[dest]\n\t" + "sete %[success]\n\t" + "movq %%rax, %[expected]\n\t" + "movq %%rdx, 8+%[expected]\n\t" + : [dest] "+m" (storage), [expected] "+o" (expected), [success] "=q" (success) + : "b" (desired_lo), "c" (desired_hi) + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC_COMMA "memory", "rax", "rdx" + ); +#else // !defined(BOOST_ATOMIC_DETAIL_NO_ASM_IMPLIED_ZERO_DISPLACEMENTS) + __asm__ __volatile__ + ( + "movq 0(%[expected]), %%rax\n\t" + "movq 8(%[expected]), %%rdx\n\t" + "lock; cmpxchg16b %[dest]\n\t" + "sete %[success]\n\t" + "movq %%rax, 0(%[expected])\n\t" + "movq %%rdx, 8(%[expected])\n\t" + : [dest] "+m" (storage), [success] "=q" (success) + : "b" (desired_lo), "c" (desired_hi), [expected] "r" (&expected) + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC_COMMA "memory", "rax", "rdx" + ); +#endif // !defined(BOOST_ATOMIC_DETAIL_NO_ASM_IMPLIED_ZERO_DISPLACEMENTS) + + return success; +#else // defined(BOOST_ATOMIC_DETAIL_NO_ASM_RAX_RDX_PAIRS) + uint64_t const* p_desired = (uint64_t const*)&desired; + const uint64_t desired_lo = p_desired[0], desired_hi = p_desired[1]; + bool success; + __asm__ __volatile__ + ( + "lock; cmpxchg16b %[dest]\n\t" + "sete %[success]\n\t" +#if !defined(BOOST_ATOMIC_DETAIL_NO_ASM_CONSTRAINT_ALTERNATIVES) + : "+A,A" (expected), [dest] "+m,m" (storage), [success] "=q,m" (success) + : "b,b" (desired_lo), "c,c" (desired_hi) +#else + : "+A" (expected), [dest] "+m" (storage), [success] "=q" (success) + : "b" (desired_lo), "c" (desired_hi) +#endif + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC_COMMA "memory" + ); + return success; +#endif + } + + static BOOST_FORCEINLINE bool compare_exchange_weak( + storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order success_order, memory_order failure_order) BOOST_NOEXCEPT + { + return compare_exchange_strong(storage, expected, desired, success_order, failure_order); + } + + static BOOST_FORCEINLINE storage_type exchange(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT + { +#if defined(__clang__) + // Clang cannot allocate eax:edx register pairs but it has sync intrinsics + storage_type old_val = storage; + while (true) + { + storage_type val = __sync_val_compare_and_swap(&storage, old_val, v); + if (val == old_val) + return val; + old_val = val; + } +#elif defined(BOOST_ATOMIC_DETAIL_NO_ASM_RAX_RDX_PAIRS) + // GCC 4.4 can't allocate rax:rdx register pair either but it also doesn't support 128-bit __sync_val_compare_and_swap + storage_type old_value; + uint64_t const* p_value = (uint64_t const*)&v; + const uint64_t v_lo = p_value[0], v_hi = p_value[1]; +#if !defined(BOOST_ATOMIC_DETAIL_NO_ASM_IMPLIED_ZERO_DISPLACEMENTS) + __asm__ __volatile__ + ( + "movq %[dest], %%rax\n\t" + "movq 8+%[dest], %%rdx\n\t" + ".align 16\n\t" + "1: lock; cmpxchg16b %[dest]\n\t" + "jne 1b\n\t" + "movq %%rax, %[old_value]\n\t" + "movq %%rdx, 8+%[old_value]\n\t" + : [dest] "+o" (storage), [old_value] "=o" (old_value) + : "b" (v_lo), "c" (v_hi) + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC_COMMA "memory", "rax", "rdx" + ); +#else // !defined(BOOST_ATOMIC_DETAIL_NO_ASM_IMPLIED_ZERO_DISPLACEMENTS) + __asm__ __volatile__ + ( + "movq 0(%[dest]), %%rax\n\t" + "movq 8(%[dest]), %%rdx\n\t" + ".align 16\n\t" + "1: lock; cmpxchg16b 0(%[dest])\n\t" + "jne 1b\n\t" + "movq %%rax, 0(%[old_value])\n\t" + "movq %%rdx, 8(%[old_value])\n\t" + : + : "b" (v_lo), "c" (v_hi), [dest] "r" (&storage), [old_value] "r" (&old_value) + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC_COMMA "memory", "rax", "rdx" + ); +#endif // !defined(BOOST_ATOMIC_DETAIL_NO_ASM_IMPLIED_ZERO_DISPLACEMENTS) + + return old_value; +#else // defined(BOOST_ATOMIC_DETAIL_NO_ASM_RAX_RDX_PAIRS) + uint64_t const* p_value = (uint64_t const*)&v; + const uint64_t v_lo = p_value[0], v_hi = p_value[1]; +#if !defined(BOOST_ATOMIC_DETAIL_NO_ASM_IMPLIED_ZERO_DISPLACEMENTS) + __asm__ __volatile__ + ( + "movq %[dest], %%rax\n\t" + "movq 8+%[dest], %%rdx\n\t" + ".align 16\n\t" + "1: lock; cmpxchg16b %[dest]\n\t" + "jne 1b\n\t" + : "=&A" (v), [dest] "+o" (storage) + : "b" (v_lo), "c" (v_hi) + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC_COMMA "memory" + ); +#else // !defined(BOOST_ATOMIC_DETAIL_NO_ASM_IMPLIED_ZERO_DISPLACEMENTS) + __asm__ __volatile__ + ( + "movq 0(%[dest]), %%rax\n\t" + "movq 8(%[dest]), %%rdx\n\t" + ".align 16\n\t" + "1: lock; cmpxchg16b 0(%[dest])\n\t" + "jne 1b\n\t" + : "=&A" (v) + : "b" (v_lo), "c" (v_hi), [dest] "r" (&storage) + : BOOST_ATOMIC_DETAIL_ASM_CLOBBER_CC_COMMA "memory" + ); +#endif // !defined(BOOST_ATOMIC_DETAIL_NO_ASM_IMPLIED_ZERO_DISPLACEMENTS) + + return v; +#endif + } +}; + +#endif // defined(BOOST_ATOMIC_DETAIL_X86_HAS_CMPXCHG16B) + +} // namespace detail +} // namespace atomics +} // namespace boost + +#endif // BOOST_ATOMIC_DETAIL_OPS_GCC_X86_DCAS_HPP_INCLUDED_ diff --git a/libs/boost/include/boost/atomic/detail/ops_linux_arm.hpp b/libs/boost/include/boost/atomic/detail/ops_linux_arm.hpp new file mode 100644 index 0000000..c26bc2c --- /dev/null +++ b/libs/boost/include/boost/atomic/detail/ops_linux_arm.hpp @@ -0,0 +1,175 @@ +/* + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or copy at + * http://www.boost.org/LICENSE_1_0.txt) + * + * Copyright (c) 2009, 2011 Helge Bahmann + * Copyright (c) 2009 Phil Endecott + * Copyright (c) 2013 Tim Blechmann + * Linux-specific code by Phil Endecott + * Copyright (c) 2014 Andrey Semashev + */ +/*! + * \file atomic/detail/ops_linux_arm.hpp + * + * This header contains implementation of the \c operations template. + */ + +#ifndef BOOST_ATOMIC_DETAIL_OPS_LINUX_ARM_HPP_INCLUDED_ +#define BOOST_ATOMIC_DETAIL_OPS_LINUX_ARM_HPP_INCLUDED_ + +#include +#include +#include +#include +#include +#include +#include + +#ifdef BOOST_HAS_PRAGMA_ONCE +#pragma once +#endif + +namespace boost { +namespace atomics { +namespace detail { + +// Different ARM processors have different atomic instructions. In particular, +// architecture versions before v6 (which are still in widespread use, e.g. the +// Intel/Marvell XScale chips like the one in the NSLU2) have only atomic swap. +// On Linux the kernel provides some support that lets us abstract away from +// these differences: it provides emulated CAS and barrier functions at special +// addresses that are guaranteed not to be interrupted by the kernel. Using +// this facility is slightly slower than inline assembler would be, but much +// faster than a system call. +// +// While this emulated CAS is "strong" in the sense that it does not fail +// "spuriously" (i.e.: it never fails to perform the exchange when the value +// found equals the value expected), it does not return the found value on +// failure. To satisfy the atomic API, compare_exchange_{weak|strong} must +// return the found value on failure, and we have to manually load this value +// after the emulated CAS reports failure. This in turn introduces a race +// between the CAS failing (due to the "wrong" value being found) and subsequently +// loading (which might turn up the "right" value). From an application's +// point of view this looks like "spurious failure", and therefore the +// emulated CAS is only good enough to provide compare_exchange_weak +// semantics. + +struct linux_arm_cas_base +{ + static BOOST_CONSTEXPR_OR_CONST bool is_always_lock_free = true; + + static BOOST_FORCEINLINE void fence_before_store(memory_order order) BOOST_NOEXCEPT + { + if ((order & memory_order_release) != 0) + hardware_full_fence(); + } + + static BOOST_FORCEINLINE void fence_after_store(memory_order order) BOOST_NOEXCEPT + { + if (order == memory_order_seq_cst) + hardware_full_fence(); + } + + static BOOST_FORCEINLINE void fence_after_load(memory_order order) BOOST_NOEXCEPT + { + if ((order & (memory_order_consume | memory_order_acquire)) != 0) + hardware_full_fence(); + } + + static BOOST_FORCEINLINE void hardware_full_fence() BOOST_NOEXCEPT + { + typedef void (*kernel_dmb_t)(void); + ((kernel_dmb_t)0xffff0fa0)(); + } +}; + +template< bool Signed > +struct linux_arm_cas : + public linux_arm_cas_base +{ + typedef typename make_storage_type< 4u, Signed >::type storage_type; + typedef typename make_storage_type< 4u, Signed >::aligned aligned_storage_type; + + static BOOST_FORCEINLINE void store(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + fence_before_store(order); + storage = v; + fence_after_store(order); + } + + static BOOST_FORCEINLINE storage_type load(storage_type const volatile& storage, memory_order order) BOOST_NOEXCEPT + { + storage_type v = storage; + fence_after_load(order); + return v; + } + + static BOOST_FORCEINLINE bool compare_exchange_strong( + storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order success_order, memory_order failure_order) BOOST_NOEXCEPT + { + while (true) + { + storage_type tmp = expected; + if (compare_exchange_weak(storage, tmp, desired, success_order, failure_order)) + return true; + if (tmp != expected) + { + expected = tmp; + return false; + } + } + } + + static BOOST_FORCEINLINE bool compare_exchange_weak( + storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order, memory_order) BOOST_NOEXCEPT + { + typedef storage_type (*kernel_cmpxchg32_t)(storage_type oldval, storage_type newval, volatile storage_type* ptr); + + if (((kernel_cmpxchg32_t)0xffff0fc0)(expected, desired, &storage) == 0) + { + return true; + } + else + { + expected = storage; + return false; + } + } +}; + +template< bool Signed > +struct operations< 1u, Signed > : + public extending_cas_based_operations< cas_based_operations< cas_based_exchange< linux_arm_cas< Signed > > >, 1u, Signed > +{ +}; + +template< bool Signed > +struct operations< 2u, Signed > : + public extending_cas_based_operations< cas_based_operations< cas_based_exchange< linux_arm_cas< Signed > > >, 2u, Signed > +{ +}; + +template< bool Signed > +struct operations< 4u, Signed > : + public cas_based_operations< cas_based_exchange< linux_arm_cas< Signed > > > +{ +}; + +BOOST_FORCEINLINE void thread_fence(memory_order order) BOOST_NOEXCEPT +{ + if (order != memory_order_relaxed) + linux_arm_cas_base::hardware_full_fence(); +} + +BOOST_FORCEINLINE void signal_fence(memory_order order) BOOST_NOEXCEPT +{ + if (order != memory_order_relaxed) + __asm__ __volatile__ ("" ::: "memory"); +} + +} // namespace detail +} // namespace atomics +} // namespace boost + +#endif // BOOST_ATOMIC_DETAIL_OPS_LINUX_ARM_HPP_INCLUDED_ diff --git a/libs/boost/include/boost/atomic/detail/ops_msvc_arm.hpp b/libs/boost/include/boost/atomic/detail/ops_msvc_arm.hpp new file mode 100644 index 0000000..e0a709c --- /dev/null +++ b/libs/boost/include/boost/atomic/detail/ops_msvc_arm.hpp @@ -0,0 +1,821 @@ +/* + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or copy at + * http://www.boost.org/LICENSE_1_0.txt) + * + * Copyright (c) 2009 Helge Bahmann + * Copyright (c) 2012 Tim Blechmann + * Copyright (c) 2014 Andrey Semashev + */ +/*! + * \file atomic/detail/ops_msvc_arm.hpp + * + * This header contains implementation of the \c operations template. + */ + +#ifndef BOOST_ATOMIC_DETAIL_OPS_MSVC_ARM_HPP_INCLUDED_ +#define BOOST_ATOMIC_DETAIL_OPS_MSVC_ARM_HPP_INCLUDED_ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef BOOST_HAS_PRAGMA_ONCE +#pragma once +#endif + +#define BOOST_ATOMIC_DETAIL_ARM_LOAD8(p) __iso_volatile_load8((const volatile __int8*)(p)) +#define BOOST_ATOMIC_DETAIL_ARM_LOAD16(p) __iso_volatile_load16((const volatile __int16*)(p)) +#define BOOST_ATOMIC_DETAIL_ARM_LOAD32(p) __iso_volatile_load32((const volatile __int32*)(p)) +#define BOOST_ATOMIC_DETAIL_ARM_LOAD64(p) __iso_volatile_load64((const volatile __int64*)(p)) +#define BOOST_ATOMIC_DETAIL_ARM_STORE8(p, v) __iso_volatile_store8((volatile __int8*)(p), (__int8)(v)) +#define BOOST_ATOMIC_DETAIL_ARM_STORE16(p, v) __iso_volatile_store16((volatile __int16*)(p), (__int16)(v)) +#define BOOST_ATOMIC_DETAIL_ARM_STORE32(p, v) __iso_volatile_store32((volatile __int32*)(p), (__int32)(v)) +#define BOOST_ATOMIC_DETAIL_ARM_STORE64(p, v) __iso_volatile_store64((volatile __int64*)(p), (__int64)(v)) + +namespace boost { +namespace atomics { +namespace detail { + +// A note about memory_order_consume. Technically, this architecture allows to avoid +// unnecessary memory barrier after consume load since it supports data dependency ordering. +// However, some compiler optimizations may break a seemingly valid code relying on data +// dependency tracking by injecting bogus branches to aid out of order execution. +// This may happen not only in Boost.Atomic code but also in user's code, which we have no +// control of. See this thread: http://lists.boost.org/Archives/boost/2014/06/213890.php. +// For this reason we promote memory_order_consume to memory_order_acquire. + +struct msvc_arm_operations_base +{ + static BOOST_CONSTEXPR_OR_CONST bool is_always_lock_free = true; + + static BOOST_FORCEINLINE void hardware_full_fence() BOOST_NOEXCEPT + { + __dmb(0xB); // _ARM_BARRIER_ISH, see armintr.h from MSVC 11 and later + } + + static BOOST_FORCEINLINE void fence_before_store(memory_order order) BOOST_NOEXCEPT + { + BOOST_ATOMIC_DETAIL_COMPILER_BARRIER(); + + if ((order & memory_order_release) != 0) + hardware_full_fence(); + + BOOST_ATOMIC_DETAIL_COMPILER_BARRIER(); + } + + static BOOST_FORCEINLINE void fence_after_store(memory_order order) BOOST_NOEXCEPT + { + BOOST_ATOMIC_DETAIL_COMPILER_BARRIER(); + + if (order == memory_order_seq_cst) + hardware_full_fence(); + + BOOST_ATOMIC_DETAIL_COMPILER_BARRIER(); + } + + static BOOST_FORCEINLINE void fence_after_load(memory_order order) BOOST_NOEXCEPT + { + BOOST_ATOMIC_DETAIL_COMPILER_BARRIER(); + + if ((order & (memory_order_consume | memory_order_acquire)) != 0) + hardware_full_fence(); + + BOOST_ATOMIC_DETAIL_COMPILER_BARRIER(); + } + + static BOOST_FORCEINLINE BOOST_CONSTEXPR memory_order cas_common_order(memory_order success_order, memory_order failure_order) BOOST_NOEXCEPT + { + // Combine order flags together and promote memory_order_consume to memory_order_acquire + return static_cast< memory_order >(((failure_order | success_order) & ~memory_order_consume) | (((failure_order | success_order) & memory_order_consume) << 1u)); + } +}; + +template< typename T, typename Derived > +struct msvc_arm_operations : + public msvc_arm_operations_base +{ + typedef T storage_type; + + static BOOST_FORCEINLINE storage_type fetch_sub(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + typedef typename boost::atomics::detail::make_signed< storage_type >::type signed_storage_type; + return Derived::fetch_add(storage, static_cast< storage_type >(-static_cast< signed_storage_type >(v)), order); + } + + static BOOST_FORCEINLINE bool compare_exchange_weak( + storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order success_order, memory_order failure_order) BOOST_NOEXCEPT + { + return Derived::compare_exchange_strong(storage, expected, desired, success_order, failure_order); + } + + static BOOST_FORCEINLINE bool test_and_set(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT + { + return !!Derived::exchange(storage, (storage_type)1, order); + } + + static BOOST_FORCEINLINE void clear(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT + { + Derived::store(storage, (storage_type)0, order); + } +}; + +template< bool Signed > +struct operations< 1u, Signed > : + public msvc_arm_operations< typename make_storage_type< 1u, Signed >::type, operations< 1u, Signed > > +{ + typedef msvc_arm_operations< typename make_storage_type< 1u, Signed >::type, operations< 1u, Signed > > base_type; + typedef typename base_type::storage_type storage_type; + typedef typename make_storage_type< 1u, Signed >::aligned aligned_storage_type; + + static BOOST_FORCEINLINE void store(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + base_type::fence_before_store(order); + BOOST_ATOMIC_DETAIL_ARM_STORE8(&storage, v); + base_type::fence_after_store(order); + } + + static BOOST_FORCEINLINE storage_type load(storage_type const volatile& storage, memory_order order) BOOST_NOEXCEPT + { + storage_type v = BOOST_ATOMIC_DETAIL_ARM_LOAD8(&storage); + base_type::fence_after_load(order); + return v; + } + + static BOOST_FORCEINLINE storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + switch (order) + { + case memory_order_relaxed: + v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD8_RELAXED(&storage, v)); + break; + case memory_order_consume: + case memory_order_acquire: + v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD8_ACQUIRE(&storage, v)); + break; + case memory_order_release: + v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD8_RELEASE(&storage, v)); + break; + case memory_order_acq_rel: + case memory_order_seq_cst: + default: + v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD8(&storage, v)); + break; + } + return v; + } + + static BOOST_FORCEINLINE storage_type exchange(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + switch (order) + { + case memory_order_relaxed: + v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE8_RELAXED(&storage, v)); + break; + case memory_order_consume: + case memory_order_acquire: + v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE8_ACQUIRE(&storage, v)); + break; + case memory_order_release: + v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE8_RELEASE(&storage, v)); + break; + case memory_order_acq_rel: + case memory_order_seq_cst: + default: + v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE8(&storage, v)); + break; + } + return v; + } + + static BOOST_FORCEINLINE bool compare_exchange_strong( + storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order success_order, memory_order failure_order) BOOST_NOEXCEPT + { + storage_type previous = expected, old_val; + + switch (cas_common_order(success_order, failure_order)) + { + case memory_order_relaxed: + old_val = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE8_RELAXED(&storage, desired, previous)); + break; + case memory_order_consume: + case memory_order_acquire: + old_val = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE8_ACQUIRE(&storage, desired, previous)); + break; + case memory_order_release: + old_val = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE8_RELEASE(&storage, desired, previous)); + break; + case memory_order_acq_rel: + case memory_order_seq_cst: + default: + old_val = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE8(&storage, desired, previous)); + break; + } + expected = old_val; + + return (previous == old_val); + } + + static BOOST_FORCEINLINE storage_type fetch_and(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + switch (order) + { + case memory_order_relaxed: + v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_AND8_RELAXED(&storage, v)); + break; + case memory_order_consume: + case memory_order_acquire: + v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_AND8_ACQUIRE(&storage, v)); + break; + case memory_order_release: + v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_AND8_RELEASE(&storage, v)); + break; + case memory_order_acq_rel: + case memory_order_seq_cst: + default: + v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_AND8(&storage, v)); + break; + } + return v; + } + + static BOOST_FORCEINLINE storage_type fetch_or(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + switch (order) + { + case memory_order_relaxed: + v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_OR8_RELAXED(&storage, v)); + break; + case memory_order_consume: + case memory_order_acquire: + v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_OR8_ACQUIRE(&storage, v)); + break; + case memory_order_release: + v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_OR8_RELEASE(&storage, v)); + break; + case memory_order_acq_rel: + case memory_order_seq_cst: + default: + v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_OR8(&storage, v)); + break; + } + return v; + } + + static BOOST_FORCEINLINE storage_type fetch_xor(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + switch (order) + { + case memory_order_relaxed: + v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_XOR8_RELAXED(&storage, v)); + break; + case memory_order_consume: + case memory_order_acquire: + v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_XOR8_ACQUIRE(&storage, v)); + break; + case memory_order_release: + v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_XOR8_RELEASE(&storage, v)); + break; + case memory_order_acq_rel: + case memory_order_seq_cst: + default: + v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_XOR8(&storage, v)); + break; + } + return v; + } +}; + +template< bool Signed > +struct operations< 2u, Signed > : + public msvc_arm_operations< typename make_storage_type< 2u, Signed >::type, operations< 2u, Signed > > +{ + typedef msvc_arm_operations< typename make_storage_type< 2u, Signed >::type, operations< 2u, Signed > > base_type; + typedef typename base_type::storage_type storage_type; + typedef typename make_storage_type< 2u, Signed >::aligned aligned_storage_type; + + static BOOST_FORCEINLINE void store(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + base_type::fence_before_store(order); + BOOST_ATOMIC_DETAIL_ARM_STORE16(&storage, v); + base_type::fence_after_store(order); + } + + static BOOST_FORCEINLINE storage_type load(storage_type const volatile& storage, memory_order order) BOOST_NOEXCEPT + { + storage_type v = BOOST_ATOMIC_DETAIL_ARM_LOAD16(&storage); + base_type::fence_after_load(order); + return v; + } + + static BOOST_FORCEINLINE storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + switch (order) + { + case memory_order_relaxed: + v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD16_RELAXED(&storage, v)); + break; + case memory_order_consume: + case memory_order_acquire: + v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD16_ACQUIRE(&storage, v)); + break; + case memory_order_release: + v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD16_RELEASE(&storage, v)); + break; + case memory_order_acq_rel: + case memory_order_seq_cst: + default: + v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD16(&storage, v)); + break; + } + return v; + } + + static BOOST_FORCEINLINE storage_type exchange(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + switch (order) + { + case memory_order_relaxed: + v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE16_RELAXED(&storage, v)); + break; + case memory_order_consume: + case memory_order_acquire: + v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE16_ACQUIRE(&storage, v)); + break; + case memory_order_release: + v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE16_RELEASE(&storage, v)); + break; + case memory_order_acq_rel: + case memory_order_seq_cst: + default: + v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE16(&storage, v)); + break; + } + return v; + } + + static BOOST_FORCEINLINE bool compare_exchange_strong( + storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order success_order, memory_order failure_order) BOOST_NOEXCEPT + { + storage_type previous = expected, old_val; + + switch (cas_common_order(success_order, failure_order)) + { + case memory_order_relaxed: + old_val = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE16_RELAXED(&storage, desired, previous)); + break; + case memory_order_consume: + case memory_order_acquire: + old_val = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE16_ACQUIRE(&storage, desired, previous)); + break; + case memory_order_release: + old_val = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE16_RELEASE(&storage, desired, previous)); + break; + case memory_order_acq_rel: + case memory_order_seq_cst: + default: + old_val = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE16(&storage, desired, previous)); + break; + } + expected = old_val; + + return (previous == old_val); + } + + static BOOST_FORCEINLINE storage_type fetch_and(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + switch (order) + { + case memory_order_relaxed: + v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_AND16_RELAXED(&storage, v)); + break; + case memory_order_consume: + case memory_order_acquire: + v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_AND16_ACQUIRE(&storage, v)); + break; + case memory_order_release: + v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_AND16_RELEASE(&storage, v)); + break; + case memory_order_acq_rel: + case memory_order_seq_cst: + default: + v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_AND16(&storage, v)); + break; + } + return v; + } + + static BOOST_FORCEINLINE storage_type fetch_or(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + switch (order) + { + case memory_order_relaxed: + v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_OR16_RELAXED(&storage, v)); + break; + case memory_order_consume: + case memory_order_acquire: + v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_OR16_ACQUIRE(&storage, v)); + break; + case memory_order_release: + v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_OR16_RELEASE(&storage, v)); + break; + case memory_order_acq_rel: + case memory_order_seq_cst: + default: + v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_OR16(&storage, v)); + break; + } + return v; + } + + static BOOST_FORCEINLINE storage_type fetch_xor(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + switch (order) + { + case memory_order_relaxed: + v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_XOR16_RELAXED(&storage, v)); + break; + case memory_order_consume: + case memory_order_acquire: + v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_XOR16_ACQUIRE(&storage, v)); + break; + case memory_order_release: + v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_XOR16_RELEASE(&storage, v)); + break; + case memory_order_acq_rel: + case memory_order_seq_cst: + default: + v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_XOR16(&storage, v)); + break; + } + return v; + } +}; + +template< bool Signed > +struct operations< 4u, Signed > : + public msvc_arm_operations< typename make_storage_type< 4u, Signed >::type, operations< 4u, Signed > > +{ + typedef msvc_arm_operations< typename make_storage_type< 4u, Signed >::type, operations< 4u, Signed > > base_type; + typedef typename base_type::storage_type storage_type; + typedef typename make_storage_type< 4u, Signed >::aligned aligned_storage_type; + + static BOOST_FORCEINLINE void store(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + base_type::fence_before_store(order); + BOOST_ATOMIC_DETAIL_ARM_STORE32(&storage, v); + base_type::fence_after_store(order); + } + + static BOOST_FORCEINLINE storage_type load(storage_type const volatile& storage, memory_order order) BOOST_NOEXCEPT + { + storage_type v = BOOST_ATOMIC_DETAIL_ARM_LOAD32(&storage); + base_type::fence_after_load(order); + return v; + } + + static BOOST_FORCEINLINE storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + switch (order) + { + case memory_order_relaxed: + v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD_RELAXED(&storage, v)); + break; + case memory_order_consume: + case memory_order_acquire: + v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD_ACQUIRE(&storage, v)); + break; + case memory_order_release: + v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD_RELEASE(&storage, v)); + break; + case memory_order_acq_rel: + case memory_order_seq_cst: + default: + v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD(&storage, v)); + break; + } + return v; + } + + static BOOST_FORCEINLINE storage_type exchange(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + switch (order) + { + case memory_order_relaxed: + v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE_RELAXED(&storage, v)); + break; + case memory_order_consume: + case memory_order_acquire: + v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ACQUIRE(&storage, v)); + break; + case memory_order_release: + v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE_RELEASE(&storage, v)); + break; + case memory_order_acq_rel: + case memory_order_seq_cst: + default: + v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE(&storage, v)); + break; + } + return v; + } + + static BOOST_FORCEINLINE bool compare_exchange_strong( + storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order success_order, memory_order failure_order) BOOST_NOEXCEPT + { + storage_type previous = expected, old_val; + + switch (cas_common_order(success_order, failure_order)) + { + case memory_order_relaxed: + old_val = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE_RELAXED(&storage, desired, previous)); + break; + case memory_order_consume: + case memory_order_acquire: + old_val = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE_ACQUIRE(&storage, desired, previous)); + break; + case memory_order_release: + old_val = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE_RELEASE(&storage, desired, previous)); + break; + case memory_order_acq_rel: + case memory_order_seq_cst: + default: + old_val = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE(&storage, desired, previous)); + break; + } + expected = old_val; + + return (previous == old_val); + } + + static BOOST_FORCEINLINE storage_type fetch_and(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + switch (order) + { + case memory_order_relaxed: + v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_AND_RELAXED(&storage, v)); + break; + case memory_order_consume: + case memory_order_acquire: + v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_AND_ACQUIRE(&storage, v)); + break; + case memory_order_release: + v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_AND_RELEASE(&storage, v)); + break; + case memory_order_acq_rel: + case memory_order_seq_cst: + default: + v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_AND(&storage, v)); + break; + } + return v; + } + + static BOOST_FORCEINLINE storage_type fetch_or(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + switch (order) + { + case memory_order_relaxed: + v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_OR_RELAXED(&storage, v)); + break; + case memory_order_consume: + case memory_order_acquire: + v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_OR_ACQUIRE(&storage, v)); + break; + case memory_order_release: + v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_OR_RELEASE(&storage, v)); + break; + case memory_order_acq_rel: + case memory_order_seq_cst: + default: + v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_OR(&storage, v)); + break; + } + return v; + } + + static BOOST_FORCEINLINE storage_type fetch_xor(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + switch (order) + { + case memory_order_relaxed: + v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_XOR_RELAXED(&storage, v)); + break; + case memory_order_consume: + case memory_order_acquire: + v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_XOR_ACQUIRE(&storage, v)); + break; + case memory_order_release: + v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_XOR_RELEASE(&storage, v)); + break; + case memory_order_acq_rel: + case memory_order_seq_cst: + default: + v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_XOR(&storage, v)); + break; + } + return v; + } +}; + +template< bool Signed > +struct operations< 8u, Signed > : + public msvc_arm_operations< typename make_storage_type< 8u, Signed >::type, operations< 8u, Signed > > +{ + typedef msvc_arm_operations< typename make_storage_type< 8u, Signed >::type, operations< 8u, Signed > > base_type; + typedef typename base_type::storage_type storage_type; + typedef typename make_storage_type< 8u, Signed >::aligned aligned_storage_type; + + static BOOST_FORCEINLINE void store(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + base_type::fence_before_store(order); + BOOST_ATOMIC_DETAIL_ARM_STORE64(&storage, v); + base_type::fence_after_store(order); + } + + static BOOST_FORCEINLINE storage_type load(storage_type const volatile& storage, memory_order order) BOOST_NOEXCEPT + { + storage_type v = BOOST_ATOMIC_DETAIL_ARM_LOAD64(&storage); + base_type::fence_after_load(order); + return v; + } + + static BOOST_FORCEINLINE storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + switch (order) + { + case memory_order_relaxed: + v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD64_RELAXED(&storage, v)); + break; + case memory_order_consume: + case memory_order_acquire: + v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD64_ACQUIRE(&storage, v)); + break; + case memory_order_release: + v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD64_RELEASE(&storage, v)); + break; + case memory_order_acq_rel: + case memory_order_seq_cst: + default: + v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD64(&storage, v)); + break; + } + return v; + } + + static BOOST_FORCEINLINE storage_type exchange(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + switch (order) + { + case memory_order_relaxed: + v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE64_RELAXED(&storage, v)); + break; + case memory_order_consume: + case memory_order_acquire: + v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE64_ACQUIRE(&storage, v)); + break; + case memory_order_release: + v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE64_RELEASE(&storage, v)); + break; + case memory_order_acq_rel: + case memory_order_seq_cst: + default: + v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE64(&storage, v)); + break; + } + return v; + } + + static BOOST_FORCEINLINE bool compare_exchange_strong( + storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order success_order, memory_order failure_order) BOOST_NOEXCEPT + { + storage_type previous = expected, old_val; + + switch (cas_common_order(success_order, failure_order)) + { + case memory_order_relaxed: + old_val = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE64_RELAXED(&storage, desired, previous)); + break; + case memory_order_consume: + case memory_order_acquire: + old_val = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE64_ACQUIRE(&storage, desired, previous)); + break; + case memory_order_release: + old_val = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE64_RELEASE(&storage, desired, previous)); + break; + case memory_order_acq_rel: + case memory_order_seq_cst: + default: + old_val = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE64(&storage, desired, previous)); + break; + } + expected = old_val; + + return (previous == old_val); + } + + static BOOST_FORCEINLINE storage_type fetch_and(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + switch (order) + { + case memory_order_relaxed: + v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_AND64_RELAXED(&storage, v)); + break; + case memory_order_consume: + case memory_order_acquire: + v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_AND64_ACQUIRE(&storage, v)); + break; + case memory_order_release: + v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_AND64_RELEASE(&storage, v)); + break; + case memory_order_acq_rel: + case memory_order_seq_cst: + default: + v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_AND64(&storage, v)); + break; + } + return v; + } + + static BOOST_FORCEINLINE storage_type fetch_or(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + switch (order) + { + case memory_order_relaxed: + v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_OR64_RELAXED(&storage, v)); + break; + case memory_order_consume: + case memory_order_acquire: + v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_OR64_ACQUIRE(&storage, v)); + break; + case memory_order_release: + v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_OR64_RELEASE(&storage, v)); + break; + case memory_order_acq_rel: + case memory_order_seq_cst: + default: + v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_OR64(&storage, v)); + break; + } + return v; + } + + static BOOST_FORCEINLINE storage_type fetch_xor(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + switch (order) + { + case memory_order_relaxed: + v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_XOR64_RELAXED(&storage, v)); + break; + case memory_order_consume: + case memory_order_acquire: + v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_XOR64_ACQUIRE(&storage, v)); + break; + case memory_order_release: + v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_XOR64_RELEASE(&storage, v)); + break; + case memory_order_acq_rel: + case memory_order_seq_cst: + default: + v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_XOR64(&storage, v)); + break; + } + return v; + } +}; + + +BOOST_FORCEINLINE void thread_fence(memory_order order) BOOST_NOEXCEPT +{ + BOOST_ATOMIC_DETAIL_COMPILER_BARRIER(); + if (order != memory_order_relaxed) + msvc_arm_operations_base::hardware_full_fence(); + BOOST_ATOMIC_DETAIL_COMPILER_BARRIER(); +} + +BOOST_FORCEINLINE void signal_fence(memory_order order) BOOST_NOEXCEPT +{ + if (order != memory_order_relaxed) + BOOST_ATOMIC_DETAIL_COMPILER_BARRIER(); +} + +} // namespace detail +} // namespace atomics +} // namespace boost + +#undef BOOST_ATOMIC_DETAIL_ARM_LOAD8 +#undef BOOST_ATOMIC_DETAIL_ARM_LOAD16 +#undef BOOST_ATOMIC_DETAIL_ARM_LOAD32 +#undef BOOST_ATOMIC_DETAIL_ARM_LOAD64 +#undef BOOST_ATOMIC_DETAIL_ARM_STORE8 +#undef BOOST_ATOMIC_DETAIL_ARM_STORE16 +#undef BOOST_ATOMIC_DETAIL_ARM_STORE32 +#undef BOOST_ATOMIC_DETAIL_ARM_STORE64 + +#endif // BOOST_ATOMIC_DETAIL_OPS_MSVC_ARM_HPP_INCLUDED_ diff --git a/libs/boost/include/boost/atomic/detail/ops_msvc_common.hpp b/libs/boost/include/boost/atomic/detail/ops_msvc_common.hpp new file mode 100644 index 0000000..53628f3 --- /dev/null +++ b/libs/boost/include/boost/atomic/detail/ops_msvc_common.hpp @@ -0,0 +1,38 @@ +/* + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or copy at + * http://www.boost.org/LICENSE_1_0.txt) + * + * Copyright (c) 2009 Helge Bahmann + * Copyright (c) 2012 Tim Blechmann + * Copyright (c) 2014 Andrey Semashev + */ +/*! + * \file atomic/detail/ops_msvc_common.hpp + * + * This header contains common tools for MSVC implementation of the \c operations template. + */ + +#ifndef BOOST_ATOMIC_DETAIL_OPS_MSVC_COMMON_HPP_INCLUDED_ +#define BOOST_ATOMIC_DETAIL_OPS_MSVC_COMMON_HPP_INCLUDED_ + +#include + +#ifdef BOOST_HAS_PRAGMA_ONCE +#pragma once +#endif + +// Define compiler barriers +#if defined(__INTEL_COMPILER) +#define BOOST_ATOMIC_DETAIL_COMPILER_BARRIER() __memory_barrier() +#elif defined(_MSC_VER) && !defined(_WIN32_WCE) +extern "C" void _ReadWriteBarrier(void); +#pragma intrinsic(_ReadWriteBarrier) +#define BOOST_ATOMIC_DETAIL_COMPILER_BARRIER() _ReadWriteBarrier() +#endif + +#ifndef BOOST_ATOMIC_DETAIL_COMPILER_BARRIER +#define BOOST_ATOMIC_DETAIL_COMPILER_BARRIER() +#endif + +#endif // BOOST_ATOMIC_DETAIL_OPS_MSVC_COMMON_HPP_INCLUDED_ diff --git a/libs/boost/include/boost/atomic/detail/ops_msvc_x86.hpp b/libs/boost/include/boost/atomic/detail/ops_msvc_x86.hpp new file mode 100644 index 0000000..6236624 --- /dev/null +++ b/libs/boost/include/boost/atomic/detail/ops_msvc_x86.hpp @@ -0,0 +1,918 @@ +/* + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or copy at + * http://www.boost.org/LICENSE_1_0.txt) + * + * Copyright (c) 2009 Helge Bahmann + * Copyright (c) 2012 Tim Blechmann + * Copyright (c) 2014 Andrey Semashev + */ +/*! + * \file atomic/detail/ops_msvc_x86.hpp + * + * This header contains implementation of the \c operations template. + */ + +#ifndef BOOST_ATOMIC_DETAIL_OPS_MSVC_X86_HPP_INCLUDED_ +#define BOOST_ATOMIC_DETAIL_OPS_MSVC_X86_HPP_INCLUDED_ + +#include +#include +#include +#include +#include +#include +#include +#if defined(BOOST_ATOMIC_DETAIL_X86_HAS_CMPXCHG8B) || defined(BOOST_ATOMIC_DETAIL_X86_HAS_CMPXCHG16B) +#include +#include +#endif +#include +#if !defined(_M_IX86) && !(defined(BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE8) && defined(BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE16)) +#include +#endif + +#ifdef BOOST_HAS_PRAGMA_ONCE +#pragma once +#endif + +#if defined(BOOST_MSVC) +#pragma warning(push) +// frame pointer register 'ebx' modified by inline assembly code. See the note below. +#pragma warning(disable: 4731) +#endif + +#if defined(BOOST_ATOMIC_DETAIL_X86_HAS_MFENCE) +extern "C" void _mm_mfence(void); +#if defined(BOOST_MSVC) +#pragma intrinsic(_mm_mfence) +#endif +#endif + +namespace boost { +namespace atomics { +namespace detail { + +/* + * Implementation note for asm blocks. + * + * http://msdn.microsoft.com/en-us/data/k1a8ss06%28v=vs.105%29 + * + * Some SSE types require eight-byte stack alignment, forcing the compiler to emit dynamic stack-alignment code. + * To be able to access both the local variables and the function parameters after the alignment, the compiler + * maintains two frame pointers. If the compiler performs frame pointer omission (FPO), it will use EBP and ESP. + * If the compiler does not perform FPO, it will use EBX and EBP. To ensure code runs correctly, do not modify EBX + * in asm code if the function requires dynamic stack alignment as it could modify the frame pointer. + * Either move the eight-byte aligned types out of the function, or avoid using EBX. + * + * Since we have no way of knowing that the compiler uses FPO, we have to always save and restore ebx + * whenever we have to clobber it. Additionally, we disable warning C4731 above so that the compiler + * doesn't spam about ebx use. + */ + +struct msvc_x86_operations_base +{ + static BOOST_CONSTEXPR_OR_CONST bool is_always_lock_free = true; + + static BOOST_FORCEINLINE void hardware_full_fence() BOOST_NOEXCEPT + { +#if defined(BOOST_ATOMIC_DETAIL_X86_HAS_MFENCE) + _mm_mfence(); +#else + long tmp; + BOOST_ATOMIC_INTERLOCKED_EXCHANGE(&tmp, 0); +#endif + } + + static BOOST_FORCEINLINE void fence_before(memory_order) BOOST_NOEXCEPT + { + BOOST_ATOMIC_DETAIL_COMPILER_BARRIER(); + } + + static BOOST_FORCEINLINE void fence_after(memory_order) BOOST_NOEXCEPT + { + BOOST_ATOMIC_DETAIL_COMPILER_BARRIER(); + } + + static BOOST_FORCEINLINE void fence_after_load(memory_order) BOOST_NOEXCEPT + { + BOOST_ATOMIC_DETAIL_COMPILER_BARRIER(); + + // On x86 and x86_64 there is no need for a hardware barrier, + // even if seq_cst memory order is requested, because all + // seq_cst writes are implemented with lock-prefixed operations + // or xchg which has implied lock prefix. Therefore normal loads + // are already ordered with seq_cst stores on these architectures. + } +}; + +template< typename T, typename Derived > +struct msvc_x86_operations : + public msvc_x86_operations_base +{ + typedef T storage_type; + + static BOOST_FORCEINLINE void store(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + if (order != memory_order_seq_cst) + { + fence_before(order); + storage = v; + fence_after(order); + } + else + { + Derived::exchange(storage, v, order); + } + } + + static BOOST_FORCEINLINE storage_type load(storage_type const volatile& storage, memory_order order) BOOST_NOEXCEPT + { + storage_type v = storage; + fence_after_load(order); + return v; + } + + static BOOST_FORCEINLINE storage_type fetch_sub(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + typedef typename boost::atomics::detail::make_signed< storage_type >::type signed_storage_type; + return Derived::fetch_add(storage, static_cast< storage_type >(-static_cast< signed_storage_type >(v)), order); + } + + static BOOST_FORCEINLINE bool compare_exchange_weak( + storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order success_order, memory_order failure_order) BOOST_NOEXCEPT + { + return Derived::compare_exchange_strong(storage, expected, desired, success_order, failure_order); + } + + static BOOST_FORCEINLINE bool test_and_set(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT + { + return !!Derived::exchange(storage, (storage_type)1, order); + } + + static BOOST_FORCEINLINE void clear(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT + { + store(storage, (storage_type)0, order); + } +}; + +template< bool Signed > +struct operations< 4u, Signed > : + public msvc_x86_operations< typename make_storage_type< 4u, Signed >::type, operations< 4u, Signed > > +{ + typedef msvc_x86_operations< typename make_storage_type< 4u, Signed >::type, operations< 4u, Signed > > base_type; + typedef typename base_type::storage_type storage_type; + typedef typename make_storage_type< 4u, Signed >::aligned aligned_storage_type; + + static BOOST_FORCEINLINE storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT + { + return static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD(&storage, v)); + } + + static BOOST_FORCEINLINE storage_type exchange(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT + { + return static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE(&storage, v)); + } + + static BOOST_FORCEINLINE bool compare_exchange_strong( + storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order, memory_order) BOOST_NOEXCEPT + { + storage_type previous = expected; + storage_type old_val = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE(&storage, desired, previous)); + expected = old_val; + return (previous == old_val); + } + +#if defined(BOOST_ATOMIC_INTERLOCKED_AND) + static BOOST_FORCEINLINE storage_type fetch_and(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT + { + return static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_AND(&storage, v)); + } +#else + static BOOST_FORCEINLINE storage_type fetch_and(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + storage_type res = storage; + while (!compare_exchange_strong(storage, res, res & v, order, memory_order_relaxed)) {} + return res; + } +#endif + +#if defined(BOOST_ATOMIC_INTERLOCKED_OR) + static BOOST_FORCEINLINE storage_type fetch_or(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT + { + return static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_OR(&storage, v)); + } +#else + static BOOST_FORCEINLINE storage_type fetch_or(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + storage_type res = storage; + while (!compare_exchange_strong(storage, res, res | v, order, memory_order_relaxed)) {} + return res; + } +#endif + +#if defined(BOOST_ATOMIC_INTERLOCKED_XOR) + static BOOST_FORCEINLINE storage_type fetch_xor(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT + { + return static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_XOR(&storage, v)); + } +#else + static BOOST_FORCEINLINE storage_type fetch_xor(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + storage_type res = storage; + while (!compare_exchange_strong(storage, res, res ^ v, order, memory_order_relaxed)) {} + return res; + } +#endif +}; + +#if defined(BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE8) + +template< bool Signed > +struct operations< 1u, Signed > : + public msvc_x86_operations< typename make_storage_type< 1u, Signed >::type, operations< 1u, Signed > > +{ + typedef msvc_x86_operations< typename make_storage_type< 1u, Signed >::type, operations< 1u, Signed > > base_type; + typedef typename base_type::storage_type storage_type; + typedef typename make_storage_type< 1u, Signed >::aligned aligned_storage_type; + + static BOOST_FORCEINLINE storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT + { + return static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD8(&storage, v)); + } + + static BOOST_FORCEINLINE storage_type exchange(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT + { + return static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE8(&storage, v)); + } + + static BOOST_FORCEINLINE bool compare_exchange_strong( + storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order, memory_order) BOOST_NOEXCEPT + { + storage_type previous = expected; + storage_type old_val = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE8(&storage, desired, previous)); + expected = old_val; + return (previous == old_val); + } + + static BOOST_FORCEINLINE storage_type fetch_and(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT + { + return static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_AND8(&storage, v)); + } + + static BOOST_FORCEINLINE storage_type fetch_or(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT + { + return static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_OR8(&storage, v)); + } + + static BOOST_FORCEINLINE storage_type fetch_xor(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT + { + return static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_XOR8(&storage, v)); + } +}; + +#elif defined(_M_IX86) + +template< bool Signed > +struct operations< 1u, Signed > : + public msvc_x86_operations< typename make_storage_type< 1u, Signed >::type, operations< 1u, Signed > > +{ + typedef msvc_x86_operations< typename make_storage_type< 1u, Signed >::type, operations< 1u, Signed > > base_type; + typedef typename base_type::storage_type storage_type; + typedef typename make_storage_type< 1u, Signed >::aligned aligned_storage_type; + + static BOOST_FORCEINLINE storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + base_type::fence_before(order); + __asm + { + mov edx, storage + movzx eax, v + lock xadd byte ptr [edx], al + mov v, al + }; + base_type::fence_after(order); + return v; + } + + static BOOST_FORCEINLINE storage_type exchange(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + base_type::fence_before(order); + __asm + { + mov edx, storage + movzx eax, v + xchg byte ptr [edx], al + mov v, al + }; + base_type::fence_after(order); + return v; + } + + static BOOST_FORCEINLINE bool compare_exchange_strong( + storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order success_order, memory_order) BOOST_NOEXCEPT + { + base_type::fence_before(success_order); + bool success; + __asm + { + mov esi, expected + mov edi, storage + movzx eax, byte ptr [esi] + movzx edx, desired + lock cmpxchg byte ptr [edi], dl + mov byte ptr [esi], al + sete success + }; + // The success and failure fences are equivalent anyway + base_type::fence_after(success_order); + return success; + } + + static BOOST_FORCEINLINE storage_type fetch_and(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + base_type::fence_before(order); + int backup; + __asm + { + mov backup, ebx + xor edx, edx + mov edi, storage + movzx ebx, v + movzx eax, byte ptr [edi] + align 16 + again: + mov dl, al + and dl, bl + lock cmpxchg byte ptr [edi], dl + jne again + mov v, al + mov ebx, backup + }; + base_type::fence_after(order); + return v; + } + + static BOOST_FORCEINLINE storage_type fetch_or(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + base_type::fence_before(order); + int backup; + __asm + { + mov backup, ebx + xor edx, edx + mov edi, storage + movzx ebx, v + movzx eax, byte ptr [edi] + align 16 + again: + mov dl, al + or dl, bl + lock cmpxchg byte ptr [edi], dl + jne again + mov v, al + mov ebx, backup + }; + base_type::fence_after(order); + return v; + } + + static BOOST_FORCEINLINE storage_type fetch_xor(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + base_type::fence_before(order); + int backup; + __asm + { + mov backup, ebx + xor edx, edx + mov edi, storage + movzx ebx, v + movzx eax, byte ptr [edi] + align 16 + again: + mov dl, al + xor dl, bl + lock cmpxchg byte ptr [edi], dl + jne again + mov v, al + mov ebx, backup + }; + base_type::fence_after(order); + return v; + } +}; + +#else + +template< bool Signed > +struct operations< 1u, Signed > : + public extending_cas_based_operations< operations< 4u, Signed >, 1u, Signed > +{ +}; + +#endif + +#if defined(BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE16) + +template< bool Signed > +struct operations< 2u, Signed > : + public msvc_x86_operations< typename make_storage_type< 2u, Signed >::type, operations< 2u, Signed > > +{ + typedef msvc_x86_operations< typename make_storage_type< 2u, Signed >::type, operations< 2u, Signed > > base_type; + typedef typename base_type::storage_type storage_type; + typedef typename make_storage_type< 2u, Signed >::aligned aligned_storage_type; + + static BOOST_FORCEINLINE storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT + { + return static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD16(&storage, v)); + } + + static BOOST_FORCEINLINE storage_type exchange(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT + { + return static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE16(&storage, v)); + } + + static BOOST_FORCEINLINE bool compare_exchange_strong( + storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order, memory_order) BOOST_NOEXCEPT + { + storage_type previous = expected; + storage_type old_val = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE16(&storage, desired, previous)); + expected = old_val; + return (previous == old_val); + } + + static BOOST_FORCEINLINE storage_type fetch_and(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT + { + return static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_AND16(&storage, v)); + } + + static BOOST_FORCEINLINE storage_type fetch_or(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT + { + return static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_OR16(&storage, v)); + } + + static BOOST_FORCEINLINE storage_type fetch_xor(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT + { + return static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_XOR16(&storage, v)); + } +}; + +#elif defined(_M_IX86) + +template< bool Signed > +struct operations< 2u, Signed > : + public msvc_x86_operations< typename make_storage_type< 2u, Signed >::type, operations< 2u, Signed > > +{ + typedef msvc_x86_operations< typename make_storage_type< 2u, Signed >::type, operations< 2u, Signed > > base_type; + typedef typename base_type::storage_type storage_type; + typedef typename make_storage_type< 2u, Signed >::aligned aligned_storage_type; + + static BOOST_FORCEINLINE storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + base_type::fence_before(order); + __asm + { + mov edx, storage + movzx eax, v + lock xadd word ptr [edx], ax + mov v, ax + }; + base_type::fence_after(order); + return v; + } + + static BOOST_FORCEINLINE storage_type exchange(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + base_type::fence_before(order); + __asm + { + mov edx, storage + movzx eax, v + xchg word ptr [edx], ax + mov v, ax + }; + base_type::fence_after(order); + return v; + } + + static BOOST_FORCEINLINE bool compare_exchange_strong( + storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order success_order, memory_order) BOOST_NOEXCEPT + { + base_type::fence_before(success_order); + bool success; + __asm + { + mov esi, expected + mov edi, storage + movzx eax, word ptr [esi] + movzx edx, desired + lock cmpxchg word ptr [edi], dx + mov word ptr [esi], ax + sete success + }; + // The success and failure fences are equivalent anyway + base_type::fence_after(success_order); + return success; + } + + static BOOST_FORCEINLINE storage_type fetch_and(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + base_type::fence_before(order); + int backup; + __asm + { + mov backup, ebx + xor edx, edx + mov edi, storage + movzx ebx, v + movzx eax, word ptr [edi] + align 16 + again: + mov dx, ax + and dx, bx + lock cmpxchg word ptr [edi], dx + jne again + mov v, ax + mov ebx, backup + }; + base_type::fence_after(order); + return v; + } + + static BOOST_FORCEINLINE storage_type fetch_or(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + base_type::fence_before(order); + int backup; + __asm + { + mov backup, ebx + xor edx, edx + mov edi, storage + movzx ebx, v + movzx eax, word ptr [edi] + align 16 + again: + mov dx, ax + or dx, bx + lock cmpxchg word ptr [edi], dx + jne again + mov v, ax + mov ebx, backup + }; + base_type::fence_after(order); + return v; + } + + static BOOST_FORCEINLINE storage_type fetch_xor(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + base_type::fence_before(order); + int backup; + __asm + { + mov backup, ebx + xor edx, edx + mov edi, storage + movzx ebx, v + movzx eax, word ptr [edi] + align 16 + again: + mov dx, ax + xor dx, bx + lock cmpxchg word ptr [edi], dx + jne again + mov v, ax + mov ebx, backup + }; + base_type::fence_after(order); + return v; + } +}; + +#else + +template< bool Signed > +struct operations< 2u, Signed > : + public extending_cas_based_operations< operations< 4u, Signed >, 2u, Signed > +{ +}; + +#endif + + +#if defined(BOOST_ATOMIC_DETAIL_X86_HAS_CMPXCHG8B) + +template< bool Signed > +struct msvc_dcas_x86 +{ + typedef typename make_storage_type< 8u, Signed >::type storage_type; + typedef typename make_storage_type< 8u, Signed >::aligned aligned_storage_type; + + static BOOST_CONSTEXPR_OR_CONST bool is_always_lock_free = true; + + // Intel 64 and IA-32 Architectures Software Developer's Manual, Volume 3A, 8.1.1. Guaranteed Atomic Operations: + // + // The Pentium processor (and newer processors since) guarantees that the following additional memory operations will always be carried out atomically: + // * Reading or writing a quadword aligned on a 64-bit boundary + // + // Luckily, the memory is almost always 8-byte aligned in our case because atomic<> uses 64 bit native types for storage and dynamic memory allocations + // have at least 8 byte alignment. The only unfortunate case is when atomic is placed on the stack and it is not 8-byte aligned (like on 32 bit Windows). + + static BOOST_FORCEINLINE void store(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT + { + BOOST_ATOMIC_DETAIL_COMPILER_BARRIER(); + + storage_type volatile* p = &storage; + if (((uint32_t)p & 0x00000007) == 0) + { +#if defined(_M_IX86_FP) && _M_IX86_FP >= 2 +#if defined(__AVX__) + __asm + { + mov edx, p + vmovq xmm4, v + vmovq qword ptr [edx], xmm4 + }; +#else + __asm + { + mov edx, p + movq xmm4, v + movq qword ptr [edx], xmm4 + }; +#endif +#else + __asm + { + mov edx, p + fild v + fistp qword ptr [edx] + }; +#endif + } + else + { + int backup; + __asm + { + mov backup, ebx + mov edi, p + mov ebx, dword ptr [v] + mov ecx, dword ptr [v + 4] + mov eax, dword ptr [edi] + mov edx, dword ptr [edi + 4] + align 16 + again: + lock cmpxchg8b qword ptr [edi] + jne again + mov ebx, backup + }; + } + + BOOST_ATOMIC_DETAIL_COMPILER_BARRIER(); + } + + static BOOST_FORCEINLINE storage_type load(storage_type const volatile& storage, memory_order) BOOST_NOEXCEPT + { + BOOST_ATOMIC_DETAIL_COMPILER_BARRIER(); + + storage_type const volatile* p = &storage; + storage_type value; + + if (((uint32_t)p & 0x00000007) == 0) + { +#if defined(_M_IX86_FP) && _M_IX86_FP >= 2 +#if defined(__AVX__) + __asm + { + mov edx, p + vmovq xmm4, qword ptr [edx] + vmovq value, xmm4 + }; +#else + __asm + { + mov edx, p + movq xmm4, qword ptr [edx] + movq value, xmm4 + }; +#endif +#else + __asm + { + mov edx, p + fild qword ptr [edx] + fistp value + }; +#endif + } + else + { + // We don't care for comparison result here; the previous value will be stored into value anyway. + // Also we don't care for ebx and ecx values, they just have to be equal to eax and edx before cmpxchg8b. + __asm + { + mov edi, p + mov eax, ebx + mov edx, ecx + lock cmpxchg8b qword ptr [edi] + mov dword ptr [value], eax + mov dword ptr [value + 4], edx + }; + } + + BOOST_ATOMIC_DETAIL_COMPILER_BARRIER(); + + return value; + } + + static BOOST_FORCEINLINE bool compare_exchange_strong( + storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order, memory_order) BOOST_NOEXCEPT + { + // MSVC-11 in 32-bit mode sometimes generates messed up code without compiler barriers, + // even though the _InterlockedCompareExchange64 intrinsic already provides one. + BOOST_ATOMIC_DETAIL_COMPILER_BARRIER(); + + storage_type volatile* p = &storage; +#if defined(BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE64) + const storage_type old_val = (storage_type)BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE64(p, desired, expected); + const bool result = (old_val == expected); + expected = old_val; +#else + bool result; + int backup; + __asm + { + mov backup, ebx + mov edi, p + mov esi, expected + mov ebx, dword ptr [desired] + mov ecx, dword ptr [desired + 4] + mov eax, dword ptr [esi] + mov edx, dword ptr [esi + 4] + lock cmpxchg8b qword ptr [edi] + mov dword ptr [esi], eax + mov dword ptr [esi + 4], edx + mov ebx, backup + sete result + }; +#endif + BOOST_ATOMIC_DETAIL_COMPILER_BARRIER(); + + return result; + } + + static BOOST_FORCEINLINE bool compare_exchange_weak( + storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order success_order, memory_order failure_order) BOOST_NOEXCEPT + { + return compare_exchange_strong(storage, expected, desired, success_order, failure_order); + } + + static BOOST_FORCEINLINE storage_type exchange(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT + { + BOOST_ATOMIC_DETAIL_COMPILER_BARRIER(); + + storage_type volatile* p = &storage; + int backup; + __asm + { + mov backup, ebx + mov edi, p + mov ebx, dword ptr [v] + mov ecx, dword ptr [v + 4] + mov eax, dword ptr [edi] + mov edx, dword ptr [edi + 4] + align 16 + again: + lock cmpxchg8b qword ptr [edi] + jne again + mov ebx, backup + mov dword ptr [v], eax + mov dword ptr [v + 4], edx + }; + + BOOST_ATOMIC_DETAIL_COMPILER_BARRIER(); + + return v; + } +}; + +template< bool Signed > +struct operations< 8u, Signed > : + public cas_based_operations< msvc_dcas_x86< Signed > > +{ +}; + +#elif defined(_M_AMD64) + +template< bool Signed > +struct operations< 8u, Signed > : + public msvc_x86_operations< typename make_storage_type< 8u, Signed >::type, operations< 8u, Signed > > +{ + typedef msvc_x86_operations< typename make_storage_type< 8u, Signed >::type, operations< 8u, Signed > > base_type; + typedef typename base_type::storage_type storage_type; + typedef typename make_storage_type< 8u, Signed >::aligned aligned_storage_type; + + static BOOST_FORCEINLINE storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT + { + return static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD64(&storage, v)); + } + + static BOOST_FORCEINLINE storage_type exchange(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT + { + return static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE64(&storage, v)); + } + + static BOOST_FORCEINLINE bool compare_exchange_strong( + storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order, memory_order) BOOST_NOEXCEPT + { + storage_type previous = expected; + storage_type old_val = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE64(&storage, desired, previous)); + expected = old_val; + return (previous == old_val); + } + + static BOOST_FORCEINLINE storage_type fetch_and(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT + { + return static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_AND64(&storage, v)); + } + + static BOOST_FORCEINLINE storage_type fetch_or(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT + { + return static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_OR64(&storage, v)); + } + + static BOOST_FORCEINLINE storage_type fetch_xor(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT + { + return static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_XOR64(&storage, v)); + } +}; + +#endif + +#if defined(BOOST_ATOMIC_DETAIL_X86_HAS_CMPXCHG16B) + +template< bool Signed > +struct msvc_dcas_x86_64 +{ + typedef typename make_storage_type< 16u, Signed >::type storage_type; + typedef typename make_storage_type< 16u, Signed >::aligned aligned_storage_type; + + static BOOST_CONSTEXPR_OR_CONST bool is_always_lock_free = true; + + static BOOST_FORCEINLINE void store(storage_type volatile& storage, storage_type v, memory_order) BOOST_NOEXCEPT + { + storage_type value = const_cast< storage_type& >(storage); + while (!BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE128(&storage, v, &value)) {} + } + + static BOOST_FORCEINLINE storage_type load(storage_type const volatile& storage, memory_order) BOOST_NOEXCEPT + { + storage_type value = storage_type(); + BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE128(&storage, value, &value); + return value; + } + + static BOOST_FORCEINLINE bool compare_exchange_strong( + storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order, memory_order) BOOST_NOEXCEPT + { + return !!BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE128(&storage, desired, &expected); + } + + static BOOST_FORCEINLINE bool compare_exchange_weak( + storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order success_order, memory_order failure_order) BOOST_NOEXCEPT + { + return compare_exchange_strong(storage, expected, desired, success_order, failure_order); + } +}; + +template< bool Signed > +struct operations< 16u, Signed > : + public cas_based_operations< cas_based_exchange< msvc_dcas_x86_64< Signed > > > +{ +}; + +#endif // defined(BOOST_ATOMIC_DETAIL_X86_HAS_CMPXCHG16B) + +BOOST_FORCEINLINE void thread_fence(memory_order order) BOOST_NOEXCEPT +{ + BOOST_ATOMIC_DETAIL_COMPILER_BARRIER(); + if (order == memory_order_seq_cst) + msvc_x86_operations_base::hardware_full_fence(); + BOOST_ATOMIC_DETAIL_COMPILER_BARRIER(); +} + +BOOST_FORCEINLINE void signal_fence(memory_order order) BOOST_NOEXCEPT +{ + if (order != memory_order_relaxed) + BOOST_ATOMIC_DETAIL_COMPILER_BARRIER(); +} + +} // namespace detail +} // namespace atomics +} // namespace boost + +#if defined(BOOST_MSVC) +#pragma warning(pop) +#endif + +#endif // BOOST_ATOMIC_DETAIL_OPS_MSVC_X86_HPP_INCLUDED_ diff --git a/libs/boost/include/boost/atomic/detail/ops_windows.hpp b/libs/boost/include/boost/atomic/detail/ops_windows.hpp new file mode 100644 index 0000000..50d951d --- /dev/null +++ b/libs/boost/include/boost/atomic/detail/ops_windows.hpp @@ -0,0 +1,213 @@ +/* + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or copy at + * http://www.boost.org/LICENSE_1_0.txt) + * + * Copyright (c) 2009 Helge Bahmann + * Copyright (c) 2012 Tim Blechmann + * Copyright (c) 2014 Andrey Semashev + */ +/*! + * \file atomic/detail/ops_windows.hpp + * + * This header contains implementation of the \c operations template. + * + * This implementation is the most basic version for Windows. It should + * work for any non-MSVC-like compilers as long as there are Interlocked WinAPI + * functions available. This version is also used for WinCE. + * + * Notably, this implementation is not as efficient as other + * versions based on compiler intrinsics. + */ + +#ifndef BOOST_ATOMIC_DETAIL_OPS_WINDOWS_HPP_INCLUDED_ +#define BOOST_ATOMIC_DETAIL_OPS_WINDOWS_HPP_INCLUDED_ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef BOOST_HAS_PRAGMA_ONCE +#pragma once +#endif + +namespace boost { +namespace atomics { +namespace detail { + +struct windows_operations_base +{ + static BOOST_CONSTEXPR_OR_CONST bool is_always_lock_free = true; + + static BOOST_FORCEINLINE void hardware_full_fence() BOOST_NOEXCEPT + { + long tmp; + BOOST_ATOMIC_INTERLOCKED_EXCHANGE(&tmp, 0); + } + + static BOOST_FORCEINLINE void fence_before(memory_order) BOOST_NOEXCEPT + { + BOOST_ATOMIC_DETAIL_COMPILER_BARRIER(); + } + + static BOOST_FORCEINLINE void fence_after(memory_order) BOOST_NOEXCEPT + { + BOOST_ATOMIC_DETAIL_COMPILER_BARRIER(); + } +}; + +template< typename T, typename Derived > +struct windows_operations : + public windows_operations_base +{ + typedef T storage_type; + + static BOOST_FORCEINLINE void store(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + Derived::exchange(storage, v, order); + } + + static BOOST_FORCEINLINE storage_type load(storage_type const volatile& storage, memory_order order) BOOST_NOEXCEPT + { + return Derived::fetch_add(const_cast< storage_type volatile& >(storage), (storage_type)0, order); + } + + static BOOST_FORCEINLINE storage_type fetch_sub(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + typedef typename boost::atomics::detail::make_signed< storage_type >::type signed_storage_type; + return Derived::fetch_add(storage, static_cast< storage_type >(-static_cast< signed_storage_type >(v)), order); + } + + static BOOST_FORCEINLINE bool compare_exchange_weak( + storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order success_order, memory_order failure_order) BOOST_NOEXCEPT + { + return Derived::compare_exchange_strong(storage, expected, desired, success_order, failure_order); + } + + static BOOST_FORCEINLINE bool test_and_set(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT + { + return !!Derived::exchange(storage, (storage_type)1, order); + } + + static BOOST_FORCEINLINE void clear(storage_type volatile& storage, memory_order order) BOOST_NOEXCEPT + { + store(storage, (storage_type)0, order); + } +}; + +template< bool Signed > +struct operations< 4u, Signed > : + public windows_operations< typename make_storage_type< 4u, Signed >::type, operations< 4u, Signed > > +{ + typedef windows_operations< typename make_storage_type< 4u, Signed >::type, operations< 4u, Signed > > base_type; + typedef typename base_type::storage_type storage_type; + typedef typename make_storage_type< 4u, Signed >::aligned aligned_storage_type; + + static BOOST_FORCEINLINE storage_type fetch_add(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + base_type::fence_before(order); + v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE_ADD(&storage, v)); + base_type::fence_after(order); + return v; + } + + static BOOST_FORCEINLINE storage_type exchange(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { + base_type::fence_before(order); + v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_EXCHANGE(&storage, v)); + base_type::fence_after(order); + return v; + } + + static BOOST_FORCEINLINE bool compare_exchange_strong( + storage_type volatile& storage, storage_type& expected, storage_type desired, memory_order success_order, memory_order failure_order) BOOST_NOEXCEPT + { + storage_type previous = expected; + base_type::fence_before(success_order); + storage_type old_val = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_COMPARE_EXCHANGE(&storage, desired, previous)); + expected = old_val; + // The success and failure fences are the same anyway + base_type::fence_after(success_order); + return (previous == old_val); + } + + static BOOST_FORCEINLINE storage_type fetch_and(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { +#if defined(BOOST_ATOMIC_INTERLOCKED_AND) + base_type::fence_before(order); + v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_AND(&storage, v)); + base_type::fence_after(order); + return v; +#else + storage_type res = storage; + while (!compare_exchange_strong(storage, res, res & v, order, memory_order_relaxed)) {} + return res; +#endif + } + + static BOOST_FORCEINLINE storage_type fetch_or(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { +#if defined(BOOST_ATOMIC_INTERLOCKED_OR) + base_type::fence_before(order); + v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_OR(&storage, v)); + base_type::fence_after(order); + return v; +#else + storage_type res = storage; + while (!compare_exchange_strong(storage, res, res | v, order, memory_order_relaxed)) {} + return res; +#endif + } + + static BOOST_FORCEINLINE storage_type fetch_xor(storage_type volatile& storage, storage_type v, memory_order order) BOOST_NOEXCEPT + { +#if defined(BOOST_ATOMIC_INTERLOCKED_XOR) + base_type::fence_before(order); + v = static_cast< storage_type >(BOOST_ATOMIC_INTERLOCKED_XOR(&storage, v)); + base_type::fence_after(order); + return v; +#else + storage_type res = storage; + while (!compare_exchange_strong(storage, res, res ^ v, order, memory_order_relaxed)) {} + return res; +#endif + } +}; + +template< bool Signed > +struct operations< 1u, Signed > : + public extending_cas_based_operations< operations< 4u, Signed >, 1u, Signed > +{ +}; + +template< bool Signed > +struct operations< 2u, Signed > : + public extending_cas_based_operations< operations< 4u, Signed >, 2u, Signed > +{ +}; + +BOOST_FORCEINLINE void thread_fence(memory_order order) BOOST_NOEXCEPT +{ + BOOST_ATOMIC_DETAIL_COMPILER_BARRIER(); + if (order == memory_order_seq_cst) + windows_operations_base::hardware_full_fence(); + BOOST_ATOMIC_DETAIL_COMPILER_BARRIER(); +} + +BOOST_FORCEINLINE void signal_fence(memory_order order) BOOST_NOEXCEPT +{ + if (order != memory_order_relaxed) + BOOST_ATOMIC_DETAIL_COMPILER_BARRIER(); +} + +} // namespace detail +} // namespace atomics +} // namespace boost + +#endif // BOOST_ATOMIC_DETAIL_OPS_WINDOWS_HPP_INCLUDED_ diff --git a/libs/boost/include/boost/atomic/detail/pause.hpp b/libs/boost/include/boost/atomic/detail/pause.hpp new file mode 100644 index 0000000..37aa5ca --- /dev/null +++ b/libs/boost/include/boost/atomic/detail/pause.hpp @@ -0,0 +1,43 @@ +/* + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or copy at + * http://www.boost.org/LICENSE_1_0.txt) + * + * (C) Copyright 2013 Tim Blechmann + * (C) Copyright 2013 Andrey Semashev + */ + +#ifndef BOOST_ATOMIC_DETAIL_PAUSE_HPP_INCLUDED_ +#define BOOST_ATOMIC_DETAIL_PAUSE_HPP_INCLUDED_ + +#include + +#ifdef BOOST_HAS_PRAGMA_ONCE +#pragma once +#endif + +#if defined(_MSC_VER) && (defined(_M_AMD64) || defined(_M_IX86)) +extern "C" void _mm_pause(void); +#if defined(BOOST_MSVC) +#pragma intrinsic(_mm_pause) +#endif +#endif + +namespace boost { +namespace atomics { +namespace detail { + +BOOST_FORCEINLINE void pause() BOOST_NOEXCEPT +{ +#if defined(_MSC_VER) && (defined(_M_AMD64) || defined(_M_IX86)) + _mm_pause(); +#elif defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__)) + __asm__ __volatile__("pause;"); +#endif +} + +} // namespace detail +} // namespace atomics +} // namespace boost + +#endif // BOOST_ATOMIC_DETAIL_PAUSE_HPP_INCLUDED_ diff --git a/libs/boost/include/boost/atomic/detail/platform.hpp b/libs/boost/include/boost/atomic/detail/platform.hpp new file mode 100644 index 0000000..786b1f1 --- /dev/null +++ b/libs/boost/include/boost/atomic/detail/platform.hpp @@ -0,0 +1,122 @@ +/* + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or copy at + * http://www.boost.org/LICENSE_1_0.txt) + * + * Copyright (c) 2009 Helge Bahmann + * Copyright (c) 2014 Andrey Semashev + */ +/*! + * \file atomic/detail/platform.hpp + * + * This header defines macros for the target platform detection + */ + +#ifndef BOOST_ATOMIC_DETAIL_PLATFORM_HPP_INCLUDED_ +#define BOOST_ATOMIC_DETAIL_PLATFORM_HPP_INCLUDED_ + +#include + +#ifdef BOOST_HAS_PRAGMA_ONCE +#pragma once +#endif + +#if !defined(BOOST_ATOMIC_FORCE_FALLBACK) + +// Compiler-based backends +#if (defined(__ibmxl__) || defined(__IBMCPP__)) && defined(__PPC__) + +// IBM XL C++ Compiler has to be checked before GCC/Clang as it pretends to be one but does not support __atomic* intrinsics. +// It does support GCC inline assembler though. +#define BOOST_ATOMIC_DETAIL_PLATFORM gcc_ppc + +#elif ((defined(__GNUC__) && ((__GNUC__ * 100 + __GNUC_MINOR__) >= 407)) ||\ + (defined(BOOST_CLANG) && ((__clang_major__ * 100 + __clang_minor__) >= 302))) &&\ + (\ + (__GCC_ATOMIC_BOOL_LOCK_FREE + 0) == 2 ||\ + (__GCC_ATOMIC_CHAR_LOCK_FREE + 0) == 2 ||\ + (__GCC_ATOMIC_SHORT_LOCK_FREE + 0) == 2 ||\ + (__GCC_ATOMIC_INT_LOCK_FREE + 0) == 2 ||\ + (__GCC_ATOMIC_LONG_LOCK_FREE + 0) == 2 ||\ + (__GCC_ATOMIC_LLONG_LOCK_FREE + 0) == 2\ + ) + +#define BOOST_ATOMIC_DETAIL_PLATFORM gcc_atomic + +#elif (defined(__GNUC__) || defined(__SUNPRO_CC)) && (defined(__i386__) || defined(__x86_64__)) + +#define BOOST_ATOMIC_DETAIL_PLATFORM gcc_x86 + +#elif defined(__GNUC__) && (defined(__POWERPC__) || defined(__PPC__)) + +#define BOOST_ATOMIC_DETAIL_PLATFORM gcc_ppc + +// This list of ARM architecture versions comes from Apple's arm/arch.h header. +// I don't know how complete it is. +#elif defined(__GNUC__) &&\ + (\ + defined(__ARM_ARCH_6__) || defined(__ARM_ARCH_6J__) ||\ + defined(__ARM_ARCH_6K__) || defined(__ARM_ARCH_6Z__) ||\ + defined(__ARM_ARCH_6ZK__) ||\ + defined(__ARM_ARCH_7__) || defined(__ARM_ARCH_7A__) ||\ + defined(__ARM_ARCH_7R__) || defined(__ARM_ARCH_7M__) ||\ + defined(__ARM_ARCH_7EM__) || defined(__ARM_ARCH_7S__) ||\ + defined(__ARM_ARCH_8A__)\ + ) + +#define BOOST_ATOMIC_DETAIL_PLATFORM gcc_arm + +#elif (defined(__GNUC__) || defined(__SUNPRO_CC)) && (defined(__sparcv8plus) || defined(__sparc_v9__)) + +#define BOOST_ATOMIC_DETAIL_PLATFORM gcc_sparc + +#elif defined(__GNUC__) && defined(__alpha__) + +#define BOOST_ATOMIC_DETAIL_PLATFORM gcc_alpha + +#elif defined(__GNUC__) && ((__GNUC__ * 100 + __GNUC_MINOR__) >= 401) &&\ + (\ + defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1) ||\ + defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2) ||\ + defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4) ||\ + defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8) ||\ + defined(__GCC_HAVE_SYNC_COMPARE_AND_SWAP_16)\ + ) + +#define BOOST_ATOMIC_DETAIL_PLATFORM gcc_sync + +#elif defined(_MSC_VER) && (defined(_M_IX86) || defined(_M_X64)) + +#define BOOST_ATOMIC_DETAIL_PLATFORM msvc_x86 + +#elif defined(_MSC_VER) && _MSC_VER >= 1700 && (defined(_M_ARM) || defined(_M_ARM64)) + +#define BOOST_ATOMIC_DETAIL_PLATFORM msvc_arm + +#endif + +// OS-based backends +#if !defined(BOOST_ATOMIC_DETAIL_PLATFORM) + +#if defined(__linux__) && defined(__arm__) + +#define BOOST_ATOMIC_DETAIL_PLATFORM linux_arm + +#elif defined(BOOST_WINDOWS) || defined(_WIN32_CE) + +#define BOOST_ATOMIC_DETAIL_PLATFORM windows + +#endif + +#endif // !defined(BOOST_ATOMIC_DETAIL_PLATFORM) + +#endif // !defined(BOOST_ATOMIC_FORCE_FALLBACK) + +#if !defined(BOOST_ATOMIC_DETAIL_PLATFORM) +#define BOOST_ATOMIC_DETAIL_PLATFORM emulated +#define BOOST_ATOMIC_EMULATED +#endif + +#define BOOST_ATOMIC_DETAIL_HEADER(prefix) + +#endif // BOOST_ATOMIC_DETAIL_PLATFORM_HPP_INCLUDED_ diff --git a/libs/boost/include/boost/atomic/detail/storage_type.hpp b/libs/boost/include/boost/atomic/detail/storage_type.hpp new file mode 100644 index 0000000..59e6901 --- /dev/null +++ b/libs/boost/include/boost/atomic/detail/storage_type.hpp @@ -0,0 +1,280 @@ +/* + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or copy at + * http://www.boost.org/LICENSE_1_0.txt) + * + * Copyright (c) 2009 Helge Bahmann + * Copyright (c) 2012 Tim Blechmann + * Copyright (c) 2013 - 2014 Andrey Semashev + */ +/*! + * \file atomic/detail/storage_type.hpp + * + * This header defines underlying types used as storage + */ + +#ifndef BOOST_ATOMIC_DETAIL_STORAGE_TYPE_HPP_INCLUDED_ +#define BOOST_ATOMIC_DETAIL_STORAGE_TYPE_HPP_INCLUDED_ + +#include +#include +#include +#if !defined(BOOST_ATOMIC_DETAIL_HAS_BUILTIN_MEMCMP) || !defined(BOOST_ATOMIC_DETAIL_HAS_BUILTIN_MEMCPY) +#include +#endif + +#ifdef BOOST_HAS_PRAGMA_ONCE +#pragma once +#endif + +namespace boost { +namespace atomics { +namespace detail { + +template< typename T > +BOOST_FORCEINLINE void non_atomic_load(T const volatile& from, T& to) BOOST_NOEXCEPT +{ + to = from; +} + +template< std::size_t Size > +struct BOOST_ATOMIC_DETAIL_MAY_ALIAS buffer_storage +{ + BOOST_ALIGNMENT(16) unsigned char data[Size]; + + BOOST_FORCEINLINE bool operator! () const BOOST_NOEXCEPT + { + return (data[0] == 0u && BOOST_ATOMIC_DETAIL_MEMCMP(data, data + 1, Size - 1) == 0); + } + + BOOST_FORCEINLINE bool operator== (buffer_storage const& that) const BOOST_NOEXCEPT + { + return BOOST_ATOMIC_DETAIL_MEMCMP(data, that.data, Size) == 0; + } + + BOOST_FORCEINLINE bool operator!= (buffer_storage const& that) const BOOST_NOEXCEPT + { + return BOOST_ATOMIC_DETAIL_MEMCMP(data, that.data, Size) != 0; + } +}; + +template< std::size_t Size > +BOOST_FORCEINLINE void non_atomic_load(buffer_storage< Size > const volatile& from, buffer_storage< Size >& to) BOOST_NOEXCEPT +{ + BOOST_ATOMIC_DETAIL_MEMCPY(to.data, const_cast< unsigned char const* >(from.data), Size); +} + +template< std::size_t Size, bool Signed > +struct make_storage_type +{ + typedef buffer_storage< Size > type; + + struct BOOST_ATOMIC_DETAIL_MAY_ALIAS aligned + { + type value; + + BOOST_DEFAULTED_FUNCTION(aligned(), {}) + BOOST_FORCEINLINE BOOST_CONSTEXPR explicit aligned(type const& v) BOOST_NOEXCEPT : value(v) {} + }; +}; + +template< > +struct make_storage_type< 1u, false > +{ + typedef boost::uint8_t BOOST_ATOMIC_DETAIL_MAY_ALIAS type; + + struct BOOST_ATOMIC_DETAIL_MAY_ALIAS aligned + { + type value; + + BOOST_DEFAULTED_FUNCTION(aligned(), {}) + BOOST_FORCEINLINE BOOST_CONSTEXPR explicit aligned(type v) BOOST_NOEXCEPT : value(v) {} + }; +}; + +template< > +struct make_storage_type< 1u, true > +{ + typedef boost::int8_t BOOST_ATOMIC_DETAIL_MAY_ALIAS type; + + struct BOOST_ATOMIC_DETAIL_MAY_ALIAS aligned + { + type value; + + BOOST_DEFAULTED_FUNCTION(aligned(), {}) + BOOST_FORCEINLINE BOOST_CONSTEXPR explicit aligned(type v) BOOST_NOEXCEPT : value(v) {} + }; +}; + +template< > +struct make_storage_type< 2u, false > +{ + typedef boost::uint16_t BOOST_ATOMIC_DETAIL_MAY_ALIAS type; + + struct BOOST_ATOMIC_DETAIL_MAY_ALIAS aligned + { + BOOST_ALIGNMENT(2) type value; + + BOOST_DEFAULTED_FUNCTION(aligned(), {}) + BOOST_FORCEINLINE BOOST_CONSTEXPR explicit aligned(type v) BOOST_NOEXCEPT : value(v) {} + }; +}; + +template< > +struct make_storage_type< 2u, true > +{ + typedef boost::int16_t BOOST_ATOMIC_DETAIL_MAY_ALIAS type; + + struct BOOST_ATOMIC_DETAIL_MAY_ALIAS aligned + { + BOOST_ALIGNMENT(2) type value; + + BOOST_DEFAULTED_FUNCTION(aligned(), {}) + BOOST_FORCEINLINE BOOST_CONSTEXPR explicit aligned(type v) BOOST_NOEXCEPT : value(v) {} + }; +}; + +template< > +struct make_storage_type< 4u, false > +{ + typedef boost::uint32_t BOOST_ATOMIC_DETAIL_MAY_ALIAS type; + + struct BOOST_ATOMIC_DETAIL_MAY_ALIAS aligned + { + BOOST_ALIGNMENT(4) type value; + + BOOST_DEFAULTED_FUNCTION(aligned(), {}) + BOOST_FORCEINLINE BOOST_CONSTEXPR explicit aligned(type v) BOOST_NOEXCEPT : value(v) {} + }; +}; + +template< > +struct make_storage_type< 4u, true > +{ + typedef boost::int32_t BOOST_ATOMIC_DETAIL_MAY_ALIAS type; + + struct BOOST_ATOMIC_DETAIL_MAY_ALIAS aligned + { + BOOST_ALIGNMENT(4) type value; + + BOOST_DEFAULTED_FUNCTION(aligned(), {}) + BOOST_FORCEINLINE BOOST_CONSTEXPR explicit aligned(type v) BOOST_NOEXCEPT : value(v) {} + }; +}; + +template< > +struct make_storage_type< 8u, false > +{ + typedef boost::uint64_t BOOST_ATOMIC_DETAIL_MAY_ALIAS type; + + struct BOOST_ATOMIC_DETAIL_MAY_ALIAS aligned + { + BOOST_ALIGNMENT(8) type value; + + BOOST_DEFAULTED_FUNCTION(aligned(), {}) + BOOST_FORCEINLINE BOOST_CONSTEXPR explicit aligned(type v) BOOST_NOEXCEPT : value(v) {} + }; +}; + +template< > +struct make_storage_type< 8u, true > +{ + typedef boost::int64_t BOOST_ATOMIC_DETAIL_MAY_ALIAS type; + + struct BOOST_ATOMIC_DETAIL_MAY_ALIAS aligned + { + BOOST_ALIGNMENT(8) type value; + + BOOST_DEFAULTED_FUNCTION(aligned(), {}) + BOOST_FORCEINLINE BOOST_CONSTEXPR explicit aligned(type v) BOOST_NOEXCEPT : value(v) {} + }; +}; + +#if defined(BOOST_HAS_INT128) + +template< > +struct make_storage_type< 16u, false > +{ + typedef boost::uint128_type BOOST_ATOMIC_DETAIL_MAY_ALIAS type; + + struct BOOST_ATOMIC_DETAIL_MAY_ALIAS aligned + { + BOOST_ALIGNMENT(16) type value; + + BOOST_DEFAULTED_FUNCTION(aligned(), {}) + BOOST_FORCEINLINE BOOST_CONSTEXPR explicit aligned(type v) BOOST_NOEXCEPT : value(v) {} + }; +}; + +template< > +struct make_storage_type< 16u, true > +{ + typedef boost::int128_type BOOST_ATOMIC_DETAIL_MAY_ALIAS type; + + struct BOOST_ATOMIC_DETAIL_MAY_ALIAS aligned + { + BOOST_ALIGNMENT(16) type value; + + BOOST_DEFAULTED_FUNCTION(aligned(), {}) + BOOST_FORCEINLINE BOOST_CONSTEXPR explicit aligned(type v) BOOST_NOEXCEPT : value(v) {} + }; +}; + +#elif !defined(BOOST_NO_ALIGNMENT) + +struct BOOST_ATOMIC_DETAIL_MAY_ALIAS storage128_t +{ + boost::uint64_t data[2]; + + BOOST_FORCEINLINE bool operator! () const BOOST_NOEXCEPT + { + return data[0] == 0 && data[1] == 0; + } +}; + +BOOST_FORCEINLINE bool operator== (storage128_t const& left, storage128_t const& right) BOOST_NOEXCEPT +{ + return left.data[0] == right.data[0] && left.data[1] == right.data[1]; +} +BOOST_FORCEINLINE bool operator!= (storage128_t const& left, storage128_t const& right) BOOST_NOEXCEPT +{ + return !(left == right); +} + +BOOST_FORCEINLINE void non_atomic_load(storage128_t const volatile& from, storage128_t& to) BOOST_NOEXCEPT +{ + to.data[0] = from.data[0]; + to.data[1] = from.data[1]; +} + +template< bool Signed > +struct make_storage_type< 16u, Signed > +{ + typedef storage128_t type; + + struct BOOST_ATOMIC_DETAIL_MAY_ALIAS aligned + { + BOOST_ALIGNMENT(16) type value; + + BOOST_DEFAULTED_FUNCTION(aligned(), {}) + BOOST_FORCEINLINE BOOST_CONSTEXPR explicit aligned(type const& v) BOOST_NOEXCEPT : value(v) {} + }; +}; + +#endif + +template< typename T > +struct storage_size_of +{ + enum _ + { + size = sizeof(T), + value = (size == 3 ? 4 : (size >= 5 && size <= 7 ? 8 : (size >= 9 && size <= 15 ? 16 : size))) + }; +}; + +} // namespace detail +} // namespace atomics +} // namespace boost + +#endif // BOOST_ATOMIC_DETAIL_STORAGE_TYPE_HPP_INCLUDED_ diff --git a/libs/boost/include/boost/atomic/detail/type_traits/conditional.hpp b/libs/boost/include/boost/atomic/detail/type_traits/conditional.hpp new file mode 100644 index 0000000..71397ab --- /dev/null +++ b/libs/boost/include/boost/atomic/detail/type_traits/conditional.hpp @@ -0,0 +1,42 @@ +/* + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or copy at + * http://www.boost.org/LICENSE_1_0.txt) + * + * Copyright (c) 2017 Andrey Semashev + */ +/*! + * \file atomic/detail/type_traits/conditional.hpp + * + * This header defines \c conditional type trait + */ + +#ifndef BOOST_ATOMIC_DETAIL_TYPE_TRAITS_CONDITIONAL_HPP_INCLUDED_ +#define BOOST_ATOMIC_DETAIL_TYPE_TRAITS_CONDITIONAL_HPP_INCLUDED_ + +#include +#if !defined(BOOST_ATOMIC_DETAIL_NO_CXX11_HDR_TYPE_TRAITS) +#include +#else +#include +#endif + +#ifdef BOOST_HAS_PRAGMA_ONCE +#pragma once +#endif + +namespace boost { +namespace atomics { +namespace detail { + +#if !defined(BOOST_ATOMIC_DETAIL_NO_CXX11_HDR_TYPE_TRAITS) +using std::conditional; +#else +using boost::conditional; +#endif + +} // namespace detail +} // namespace atomics +} // namespace boost + +#endif // BOOST_ATOMIC_DETAIL_TYPE_TRAITS_CONDITIONAL_HPP_INCLUDED_ diff --git a/libs/boost/include/boost/atomic/detail/type_traits/is_function.hpp b/libs/boost/include/boost/atomic/detail/type_traits/is_function.hpp new file mode 100644 index 0000000..7b82840 --- /dev/null +++ b/libs/boost/include/boost/atomic/detail/type_traits/is_function.hpp @@ -0,0 +1,42 @@ +/* + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or copy at + * http://www.boost.org/LICENSE_1_0.txt) + * + * Copyright (c) 2017 Andrey Semashev + */ +/*! + * \file atomic/detail/type_traits/is_function.hpp + * + * This header defines \c is_function type trait + */ + +#ifndef BOOST_ATOMIC_DETAIL_TYPE_TRAITS_IS_FUNCTION_HPP_INCLUDED_ +#define BOOST_ATOMIC_DETAIL_TYPE_TRAITS_IS_FUNCTION_HPP_INCLUDED_ + +#include +#if !defined(BOOST_ATOMIC_DETAIL_NO_CXX11_HDR_TYPE_TRAITS) +#include +#else +#include +#endif + +#ifdef BOOST_HAS_PRAGMA_ONCE +#pragma once +#endif + +namespace boost { +namespace atomics { +namespace detail { + +#if !defined(BOOST_ATOMIC_DETAIL_NO_CXX11_HDR_TYPE_TRAITS) +using std::is_function; +#else +using boost::is_function; +#endif + +} // namespace detail +} // namespace atomics +} // namespace boost + +#endif // BOOST_ATOMIC_DETAIL_TYPE_TRAITS_IS_FUNCTION_HPP_INCLUDED_ diff --git a/libs/boost/include/boost/atomic/detail/type_traits/is_integral.hpp b/libs/boost/include/boost/atomic/detail/type_traits/is_integral.hpp new file mode 100644 index 0000000..5deb120 --- /dev/null +++ b/libs/boost/include/boost/atomic/detail/type_traits/is_integral.hpp @@ -0,0 +1,43 @@ +/* + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or copy at + * http://www.boost.org/LICENSE_1_0.txt) + * + * Copyright (c) 2017 Andrey Semashev + */ +/*! + * \file atomic/detail/type_traits/is_integral.hpp + * + * This header defines \c is_integral type trait + */ + +#ifndef BOOST_ATOMIC_DETAIL_TYPE_TRAITS_IS_INTEGRAL_HPP_INCLUDED_ +#define BOOST_ATOMIC_DETAIL_TYPE_TRAITS_IS_INTEGRAL_HPP_INCLUDED_ + +#include +// Some versions of libstdc++ don't consider __int128 an integral type. Use Boost.TypeTraits because of that. +#if !defined(BOOST_ATOMIC_DETAIL_NO_CXX11_HDR_TYPE_TRAITS) && !defined(BOOST_HAS_INT128) +#include +#else +#include +#endif + +#ifdef BOOST_HAS_PRAGMA_ONCE +#pragma once +#endif + +namespace boost { +namespace atomics { +namespace detail { + +#if !defined(BOOST_ATOMIC_DETAIL_NO_CXX11_HDR_TYPE_TRAITS) && !defined(BOOST_HAS_INT128) +using std::is_integral; +#else +using boost::is_integral; +#endif + +} // namespace detail +} // namespace atomics +} // namespace boost + +#endif // BOOST_ATOMIC_DETAIL_TYPE_TRAITS_IS_INTEGRAL_HPP_INCLUDED_ diff --git a/libs/boost/include/boost/atomic/detail/type_traits/is_signed.hpp b/libs/boost/include/boost/atomic/detail/type_traits/is_signed.hpp new file mode 100644 index 0000000..bf95163 --- /dev/null +++ b/libs/boost/include/boost/atomic/detail/type_traits/is_signed.hpp @@ -0,0 +1,43 @@ +/* + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or copy at + * http://www.boost.org/LICENSE_1_0.txt) + * + * Copyright (c) 2017 Andrey Semashev + */ +/*! + * \file atomic/detail/type_traits/is_signed.hpp + * + * This header defines \c is_signed type trait + */ + +#ifndef BOOST_ATOMIC_DETAIL_TYPE_TRAITS_IS_SIGNED_HPP_INCLUDED_ +#define BOOST_ATOMIC_DETAIL_TYPE_TRAITS_IS_SIGNED_HPP_INCLUDED_ + +#include +// Some versions of libstdc++ don't consider __int128 an integral type. Use Boost.TypeTraits because of that. +#if !defined(BOOST_ATOMIC_DETAIL_NO_CXX11_HDR_TYPE_TRAITS) && !defined(BOOST_HAS_INT128) +#include +#else +#include +#endif + +#ifdef BOOST_HAS_PRAGMA_ONCE +#pragma once +#endif + +namespace boost { +namespace atomics { +namespace detail { + +#if !defined(BOOST_ATOMIC_DETAIL_NO_CXX11_HDR_TYPE_TRAITS) && !defined(BOOST_HAS_INT128) +using std::is_signed; +#else +using boost::is_signed; +#endif + +} // namespace detail +} // namespace atomics +} // namespace boost + +#endif // BOOST_ATOMIC_DETAIL_TYPE_TRAITS_IS_SIGNED_HPP_INCLUDED_ diff --git a/libs/boost/include/boost/atomic/detail/type_traits/make_signed.hpp b/libs/boost/include/boost/atomic/detail/type_traits/make_signed.hpp new file mode 100644 index 0000000..831efdc --- /dev/null +++ b/libs/boost/include/boost/atomic/detail/type_traits/make_signed.hpp @@ -0,0 +1,43 @@ +/* + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or copy at + * http://www.boost.org/LICENSE_1_0.txt) + * + * Copyright (c) 2017 Andrey Semashev + */ +/*! + * \file atomic/detail/type_traits/make_signed.hpp + * + * This header defines \c make_signed type trait + */ + +#ifndef BOOST_ATOMIC_DETAIL_TYPE_TRAITS_MAKE_SIGNED_HPP_INCLUDED_ +#define BOOST_ATOMIC_DETAIL_TYPE_TRAITS_MAKE_SIGNED_HPP_INCLUDED_ + +#include +// Some versions of libstdc++ don't consider __int128 an integral type. Use Boost.TypeTraits because of that. +#if !defined(BOOST_ATOMIC_DETAIL_NO_CXX11_HDR_TYPE_TRAITS) && !defined(BOOST_HAS_INT128) +#include +#else +#include +#endif + +#ifdef BOOST_HAS_PRAGMA_ONCE +#pragma once +#endif + +namespace boost { +namespace atomics { +namespace detail { + +#if !defined(BOOST_ATOMIC_DETAIL_NO_CXX11_HDR_TYPE_TRAITS) && !defined(BOOST_HAS_INT128) +using std::make_signed; +#else +using boost::make_signed; +#endif + +} // namespace detail +} // namespace atomics +} // namespace boost + +#endif // BOOST_ATOMIC_DETAIL_TYPE_TRAITS_MAKE_SIGNED_HPP_INCLUDED_ diff --git a/libs/boost/include/boost/atomic/fences.hpp b/libs/boost/include/boost/atomic/fences.hpp new file mode 100644 index 0000000..31e3040 --- /dev/null +++ b/libs/boost/include/boost/atomic/fences.hpp @@ -0,0 +1,67 @@ +/* + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or copy at + * http://www.boost.org/LICENSE_1_0.txt) + * + * Copyright (c) 2011 Helge Bahmann + * Copyright (c) 2013 Tim Blechmann + * Copyright (c) 2014 Andrey Semashev + */ +/*! + * \file atomic/fences.hpp + * + * This header contains definition of \c atomic_thread_fence and \c atomic_signal_fence functions. + */ + +#ifndef BOOST_ATOMIC_FENCES_HPP_INCLUDED_ +#define BOOST_ATOMIC_FENCES_HPP_INCLUDED_ + +#include +#include +#include + +#ifdef BOOST_HAS_PRAGMA_ONCE +#pragma once +#endif + +/* + * IMPLEMENTATION NOTE: All interface functions MUST be declared with BOOST_FORCEINLINE, + * see comment for convert_memory_order_to_gcc in ops_gcc_atomic.hpp. + */ + +namespace boost { + +namespace atomics { + +#if BOOST_ATOMIC_THREAD_FENCE > 0 +BOOST_FORCEINLINE void atomic_thread_fence(memory_order order) BOOST_NOEXCEPT +{ + detail::thread_fence(order); +} +#else +BOOST_FORCEINLINE void atomic_thread_fence(memory_order) BOOST_NOEXCEPT +{ + detail::lockpool::thread_fence(); +} +#endif + +#if BOOST_ATOMIC_SIGNAL_FENCE > 0 +BOOST_FORCEINLINE void atomic_signal_fence(memory_order order) BOOST_NOEXCEPT +{ + detail::signal_fence(order); +} +#else +BOOST_FORCEINLINE void atomic_signal_fence(memory_order) BOOST_NOEXCEPT +{ + detail::lockpool::signal_fence(); +} +#endif + +} // namespace atomics + +using atomics::atomic_thread_fence; +using atomics::atomic_signal_fence; + +} // namespace boost + +#endif // BOOST_ATOMIC_FENCES_HPP_INCLUDED_ diff --git a/libs/boost/include/boost/bind.hpp b/libs/boost/include/boost/bind.hpp index fd3421e..450120c 100644 --- a/libs/boost/include/boost/bind.hpp +++ b/libs/boost/include/boost/bind.hpp @@ -10,7 +10,7 @@ // // bind.hpp - binds function objects to arguments // -// Copyright (c) 2009 Peter Dimov +// Copyright (c) 2009, 2015 Peter Dimov // // Distributed under the Boost Software License, Version 1.0. // See accompanying file LICENSE_1_0.txt or copy at @@ -21,4 +21,21 @@ #include +#ifndef BOOST_BIND_NO_PLACEHOLDERS + +#if defined(BOOST_CLANG) +# pragma clang diagnostic push +# if __has_warning("-Wheader-hygiene") +# pragma clang diagnostic ignored "-Wheader-hygiene" +# endif +#endif + +using namespace boost::placeholders; + +#if defined(BOOST_CLANG) +# pragma clang diagnostic pop +#endif + +#endif // #ifndef BOOST_BIND_NO_PLACEHOLDERS + #endif // #ifndef BOOST_BIND_HPP_INCLUDED diff --git a/libs/boost/include/boost/bind/arg.hpp b/libs/boost/include/boost/bind/arg.hpp index c879bb4..cb52e66 100644 --- a/libs/boost/include/boost/bind/arg.hpp +++ b/libs/boost/include/boost/bind/arg.hpp @@ -21,24 +21,31 @@ #include #include -#include namespace boost { +template struct _arg_eq +{ +}; + +template<> struct _arg_eq +{ + typedef void type; +}; + template< int I > struct arg { - arg() + BOOST_CONSTEXPR arg() { } - template< class T > arg( T const & /* t */ ) + template< class T > BOOST_CONSTEXPR arg( T const & /* t */, typename _arg_eq< I == is_placeholder::value >::type * = 0 ) { - BOOST_STATIC_ASSERT( I == is_placeholder::value ); } }; -template< int I > bool operator==( arg const &, arg const & ) +template< int I > BOOST_CONSTEXPR bool operator==( arg const &, arg const & ) { return true; } diff --git a/libs/boost/include/boost/bind/bind.hpp b/libs/boost/include/boost/bind/bind.hpp index 924d055..85d675a 100644 --- a/libs/boost/include/boost/bind/bind.hpp +++ b/libs/boost/include/boost/bind/bind.hpp @@ -29,6 +29,12 @@ #include #include #include +#include +#include + +#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES ) +#include // std::forward +#endif // Borland-specific bug, visit_each() silently fails to produce code @@ -861,14 +867,409 @@ template struct list_add_cref +template< class A1 > class rrlist1 { - typedef A const & type; +private: + + A1 & a1_; // not A1&& because of msvc-10.0 + +public: + + explicit rrlist1( A1 & a1 ): a1_( a1 ) {} + + A1 && operator[] (boost::arg<1>) const { return std::forward( a1_ ); } // not static_cast because of g++ 4.9 + + A1 && operator[] (boost::arg<1> (*) ()) const { return std::forward( a1_ ); } + + template T & operator[] ( _bi::value & v ) const { return v.get(); } + + template T const & operator[] ( _bi::value const & v ) const { return v.get(); } + + template T & operator[] (reference_wrapper const & v) const { return v.get(); } + + template typename result_traits::type operator[] (bind_t & b) const + { + rrlist1 a( a1_ ); + return b.eval( a ); + } + + template typename result_traits::type operator[] (bind_t const & b) const + { + rrlist1 a( a1_ ); + return b.eval( a ); + } }; -template< class A > struct list_add_cref< A& > +template< class A1, class A2 > class rrlist2 { - typedef A & type; +private: + + A1 & a1_; + A2 & a2_; + +public: + + rrlist2( A1 & a1, A2 & a2 ): a1_( a1 ), a2_( a2 ) {} + + A1 && operator[] (boost::arg<1>) const { return std::forward( a1_ ); } + A2 && operator[] (boost::arg<2>) const { return std::forward( a2_ ); } + + A1 && operator[] (boost::arg<1> (*) ()) const { return std::forward( a1_ ); } + A2 && operator[] (boost::arg<2> (*) ()) const { return std::forward( a2_ ); } + + template T & operator[] ( _bi::value & v ) const { return v.get(); } + + template T const & operator[] ( _bi::value const & v ) const { return v.get(); } + + template T & operator[] (reference_wrapper const & v) const { return v.get(); } + + template typename result_traits::type operator[] (bind_t & b) const + { + rrlist2 a( a1_, a2_ ); + return b.eval( a ); + } + + template typename result_traits::type operator[] (bind_t const & b) const + { + rrlist2 a( a1_, a2_ ); + return b.eval( a ); + } +}; + +template< class A1, class A2, class A3 > class rrlist3 +{ +private: + + A1 & a1_; + A2 & a2_; + A3 & a3_; + +public: + + rrlist3( A1 & a1, A2 & a2, A3 & a3 ): a1_( a1 ), a2_( a2 ), a3_( a3 ) {} + + A1 && operator[] (boost::arg<1>) const { return std::forward( a1_ ); } + A2 && operator[] (boost::arg<2>) const { return std::forward( a2_ ); } + A3 && operator[] (boost::arg<3>) const { return std::forward( a3_ ); } + + A1 && operator[] (boost::arg<1> (*) ()) const { return std::forward( a1_ ); } + A2 && operator[] (boost::arg<2> (*) ()) const { return std::forward( a2_ ); } + A3 && operator[] (boost::arg<3> (*) ()) const { return std::forward( a3_ ); } + + template T & operator[] ( _bi::value & v ) const { return v.get(); } + + template T const & operator[] ( _bi::value const & v ) const { return v.get(); } + + template T & operator[] (reference_wrapper const & v) const { return v.get(); } + + template typename result_traits::type operator[] (bind_t & b) const + { + rrlist3 a( a1_, a2_, a3_ ); + return b.eval( a ); + } + + template typename result_traits::type operator[] (bind_t const & b) const + { + rrlist3 a( a1_, a2_, a3_ ); + return b.eval( a ); + } +}; + +template< class A1, class A2, class A3, class A4 > class rrlist4 +{ +private: + + A1 & a1_; + A2 & a2_; + A3 & a3_; + A4 & a4_; + +public: + + rrlist4( A1 & a1, A2 & a2, A3 & a3, A4 & a4 ): a1_( a1 ), a2_( a2 ), a3_( a3 ), a4_( a4 ) {} + + A1 && operator[] (boost::arg<1>) const { return std::forward( a1_ ); } + A2 && operator[] (boost::arg<2>) const { return std::forward( a2_ ); } + A3 && operator[] (boost::arg<3>) const { return std::forward( a3_ ); } + A4 && operator[] (boost::arg<4>) const { return std::forward( a4_ ); } + + A1 && operator[] (boost::arg<1> (*) ()) const { return std::forward( a1_ ); } + A2 && operator[] (boost::arg<2> (*) ()) const { return std::forward( a2_ ); } + A3 && operator[] (boost::arg<3> (*) ()) const { return std::forward( a3_ ); } + A4 && operator[] (boost::arg<4> (*) ()) const { return std::forward( a4_ ); } + + template T & operator[] ( _bi::value & v ) const { return v.get(); } + + template T const & operator[] ( _bi::value const & v ) const { return v.get(); } + + template T & operator[] (reference_wrapper const & v) const { return v.get(); } + + template typename result_traits::type operator[] (bind_t & b) const + { + rrlist4 a( a1_, a2_, a3_, a4_ ); + return b.eval( a ); + } + + template typename result_traits::type operator[] (bind_t const & b) const + { + rrlist4 a( a1_, a2_, a3_, a4_ ); + return b.eval( a ); + } +}; + +template< class A1, class A2, class A3, class A4, class A5 > class rrlist5 +{ +private: + + A1 & a1_; + A2 & a2_; + A3 & a3_; + A4 & a4_; + A5 & a5_; + +public: + + rrlist5( A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5 ): a1_( a1 ), a2_( a2 ), a3_( a3 ), a4_( a4 ), a5_( a5 ) {} + + A1 && operator[] (boost::arg<1>) const { return std::forward( a1_ ); } + A2 && operator[] (boost::arg<2>) const { return std::forward( a2_ ); } + A3 && operator[] (boost::arg<3>) const { return std::forward( a3_ ); } + A4 && operator[] (boost::arg<4>) const { return std::forward( a4_ ); } + A5 && operator[] (boost::arg<5>) const { return std::forward( a5_ ); } + + A1 && operator[] (boost::arg<1> (*) ()) const { return std::forward( a1_ ); } + A2 && operator[] (boost::arg<2> (*) ()) const { return std::forward( a2_ ); } + A3 && operator[] (boost::arg<3> (*) ()) const { return std::forward( a3_ ); } + A4 && operator[] (boost::arg<4> (*) ()) const { return std::forward( a4_ ); } + A5 && operator[] (boost::arg<5> (*) ()) const { return std::forward( a5_ ); } + + template T & operator[] ( _bi::value & v ) const { return v.get(); } + + template T const & operator[] ( _bi::value const & v ) const { return v.get(); } + + template T & operator[] (reference_wrapper const & v) const { return v.get(); } + + template typename result_traits::type operator[] (bind_t & b) const + { + rrlist5 a( a1_, a2_, a3_, a4_, a5_ ); + return b.eval( a ); + } + + template typename result_traits::type operator[] (bind_t const & b) const + { + rrlist5 a( a1_, a2_, a3_, a4_, a5_ ); + return b.eval( a ); + } +}; + +template< class A1, class A2, class A3, class A4, class A5, class A6 > class rrlist6 +{ +private: + + A1 & a1_; + A2 & a2_; + A3 & a3_; + A4 & a4_; + A5 & a5_; + A6 & a6_; + +public: + + rrlist6( A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6 ): a1_( a1 ), a2_( a2 ), a3_( a3 ), a4_( a4 ), a5_( a5 ), a6_( a6 ) {} + + A1 && operator[] (boost::arg<1>) const { return std::forward( a1_ ); } + A2 && operator[] (boost::arg<2>) const { return std::forward( a2_ ); } + A3 && operator[] (boost::arg<3>) const { return std::forward( a3_ ); } + A4 && operator[] (boost::arg<4>) const { return std::forward( a4_ ); } + A5 && operator[] (boost::arg<5>) const { return std::forward( a5_ ); } + A6 && operator[] (boost::arg<6>) const { return std::forward( a6_ ); } + + A1 && operator[] (boost::arg<1> (*) ()) const { return std::forward( a1_ ); } + A2 && operator[] (boost::arg<2> (*) ()) const { return std::forward( a2_ ); } + A3 && operator[] (boost::arg<3> (*) ()) const { return std::forward( a3_ ); } + A4 && operator[] (boost::arg<4> (*) ()) const { return std::forward( a4_ ); } + A5 && operator[] (boost::arg<5> (*) ()) const { return std::forward( a5_ ); } + A6 && operator[] (boost::arg<6> (*) ()) const { return std::forward( a6_ ); } + + template T & operator[] ( _bi::value & v ) const { return v.get(); } + + template T const & operator[] ( _bi::value const & v ) const { return v.get(); } + + template T & operator[] (reference_wrapper const & v) const { return v.get(); } + + template typename result_traits::type operator[] (bind_t & b) const + { + rrlist6 a( a1_, a2_, a3_, a4_, a5_, a6_ ); + return b.eval( a ); + } + + template typename result_traits::type operator[] (bind_t const & b) const + { + rrlist6 a( a1_, a2_, a3_, a4_, a5_, a6_ ); + return b.eval( a ); + } +}; + +template< class A1, class A2, class A3, class A4, class A5, class A6, class A7 > class rrlist7 +{ +private: + + A1 & a1_; + A2 & a2_; + A3 & a3_; + A4 & a4_; + A5 & a5_; + A6 & a6_; + A7 & a7_; + +public: + + rrlist7( A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7 ): a1_( a1 ), a2_( a2 ), a3_( a3 ), a4_( a4 ), a5_( a5 ), a6_( a6 ), a7_( a7 ) {} + + A1 && operator[] (boost::arg<1>) const { return std::forward( a1_ ); } + A2 && operator[] (boost::arg<2>) const { return std::forward( a2_ ); } + A3 && operator[] (boost::arg<3>) const { return std::forward( a3_ ); } + A4 && operator[] (boost::arg<4>) const { return std::forward( a4_ ); } + A5 && operator[] (boost::arg<5>) const { return std::forward( a5_ ); } + A6 && operator[] (boost::arg<6>) const { return std::forward( a6_ ); } + A7 && operator[] (boost::arg<7>) const { return std::forward( a7_ ); } + + A1 && operator[] (boost::arg<1> (*) ()) const { return std::forward( a1_ ); } + A2 && operator[] (boost::arg<2> (*) ()) const { return std::forward( a2_ ); } + A3 && operator[] (boost::arg<3> (*) ()) const { return std::forward( a3_ ); } + A4 && operator[] (boost::arg<4> (*) ()) const { return std::forward( a4_ ); } + A5 && operator[] (boost::arg<5> (*) ()) const { return std::forward( a5_ ); } + A6 && operator[] (boost::arg<6> (*) ()) const { return std::forward( a6_ ); } + A7 && operator[] (boost::arg<7> (*) ()) const { return std::forward( a7_ ); } + + template T & operator[] ( _bi::value & v ) const { return v.get(); } + + template T const & operator[] ( _bi::value const & v ) const { return v.get(); } + + template T & operator[] (reference_wrapper const & v) const { return v.get(); } + + template typename result_traits::type operator[] (bind_t & b) const + { + rrlist7 a( a1_, a2_, a3_, a4_, a5_, a6_, a7_ ); + return b.eval( a ); + } + + template typename result_traits::type operator[] (bind_t const & b) const + { + rrlist7 a( a1_, a2_, a3_, a4_, a5_, a6_, a7_ ); + return b.eval( a ); + } +}; + +template< class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 > class rrlist8 +{ +private: + + A1 & a1_; + A2 & a2_; + A3 & a3_; + A4 & a4_; + A5 & a5_; + A6 & a6_; + A7 & a7_; + A8 & a8_; + +public: + + rrlist8( A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8 ): a1_( a1 ), a2_( a2 ), a3_( a3 ), a4_( a4 ), a5_( a5 ), a6_( a6 ), a7_( a7 ), a8_( a8 ) {} + + A1 && operator[] (boost::arg<1>) const { return std::forward( a1_ ); } + A2 && operator[] (boost::arg<2>) const { return std::forward( a2_ ); } + A3 && operator[] (boost::arg<3>) const { return std::forward( a3_ ); } + A4 && operator[] (boost::arg<4>) const { return std::forward( a4_ ); } + A5 && operator[] (boost::arg<5>) const { return std::forward( a5_ ); } + A6 && operator[] (boost::arg<6>) const { return std::forward( a6_ ); } + A7 && operator[] (boost::arg<7>) const { return std::forward( a7_ ); } + A8 && operator[] (boost::arg<8>) const { return std::forward( a8_ ); } + + A1 && operator[] (boost::arg<1> (*) ()) const { return std::forward( a1_ ); } + A2 && operator[] (boost::arg<2> (*) ()) const { return std::forward( a2_ ); } + A3 && operator[] (boost::arg<3> (*) ()) const { return std::forward( a3_ ); } + A4 && operator[] (boost::arg<4> (*) ()) const { return std::forward( a4_ ); } + A5 && operator[] (boost::arg<5> (*) ()) const { return std::forward( a5_ ); } + A6 && operator[] (boost::arg<6> (*) ()) const { return std::forward( a6_ ); } + A7 && operator[] (boost::arg<7> (*) ()) const { return std::forward( a7_ ); } + A8 && operator[] (boost::arg<8> (*) ()) const { return std::forward( a8_ ); } + + template T & operator[] ( _bi::value & v ) const { return v.get(); } + + template T const & operator[] ( _bi::value const & v ) const { return v.get(); } + + template T & operator[] (reference_wrapper const & v) const { return v.get(); } + + template typename result_traits::type operator[] (bind_t & b) const + { + rrlist8 a( a1_, a2_, a3_, a4_, a5_, a6_, a7_, a8_ ); + return b.eval( a ); + } + + template typename result_traits::type operator[] (bind_t const & b) const + { + rrlist8 a( a1_, a2_, a3_, a4_, a5_, a6_, a7_, a8_ ); + return b.eval( a ); + } +}; + +template< class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9 > class rrlist9 +{ +private: + + A1 & a1_; + A2 & a2_; + A3 & a3_; + A4 & a4_; + A5 & a5_; + A6 & a6_; + A7 & a7_; + A8 & a8_; + A9 & a9_; + +public: + + rrlist9( A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8, A9 & a9 ): a1_( a1 ), a2_( a2 ), a3_( a3 ), a4_( a4 ), a5_( a5 ), a6_( a6 ), a7_( a7 ), a8_( a8 ), a9_( a9 ) {} + + A1 && operator[] (boost::arg<1>) const { return std::forward( a1_ ); } + A2 && operator[] (boost::arg<2>) const { return std::forward( a2_ ); } + A3 && operator[] (boost::arg<3>) const { return std::forward( a3_ ); } + A4 && operator[] (boost::arg<4>) const { return std::forward( a4_ ); } + A5 && operator[] (boost::arg<5>) const { return std::forward( a5_ ); } + A6 && operator[] (boost::arg<6>) const { return std::forward( a6_ ); } + A7 && operator[] (boost::arg<7>) const { return std::forward( a7_ ); } + A8 && operator[] (boost::arg<8>) const { return std::forward( a8_ ); } + A9 && operator[] (boost::arg<9>) const { return std::forward( a9_ ); } + + A1 && operator[] (boost::arg<1> (*) ()) const { return std::forward( a1_ ); } + A2 && operator[] (boost::arg<2> (*) ()) const { return std::forward( a2_ ); } + A3 && operator[] (boost::arg<3> (*) ()) const { return std::forward( a3_ ); } + A4 && operator[] (boost::arg<4> (*) ()) const { return std::forward( a4_ ); } + A5 && operator[] (boost::arg<5> (*) ()) const { return std::forward( a5_ ); } + A6 && operator[] (boost::arg<6> (*) ()) const { return std::forward( a6_ ); } + A7 && operator[] (boost::arg<7> (*) ()) const { return std::forward( a7_ ); } + A8 && operator[] (boost::arg<8> (*) ()) const { return std::forward( a8_ ); } + A9 && operator[] (boost::arg<9> (*) ()) const { return std::forward( a9_ ); } + + template T & operator[] ( _bi::value & v ) const { return v.get(); } + + template T const & operator[] ( _bi::value const & v ) const { return v.get(); } + + template T & operator[] (reference_wrapper const & v) const { return v.get(); } + + template typename result_traits::type operator[] (bind_t & b) const + { + rrlist9 a( a1_, a2_, a3_, a4_, a5_, a6_, a7_, a8_, a9_ ); + return b.eval( a ); + } + + template typename result_traits::type operator[] (bind_t const & b) const + { + rrlist9 a( a1_, a2_, a3_, a4_, a5_, a6_, a7_, a8_, a9_ ); + return b.eval( a ); + } }; template class bind_t @@ -901,221 +1302,109 @@ template class bind_t template result_type operator()( A1 && a1 ) { - list1< typename list_add_cref::type > a( a1 ); + rrlist1< A1 > a( a1 ); return l_( type(), f_, a, 0 ); } template result_type operator()( A1 && a1 ) const { - list1< typename list_add_cref::type > a( a1 ); + rrlist1< A1 > a( a1 ); return l_(type(), f_, a, 0); } template result_type operator()( A1 && a1, A2 && a2 ) { - list2< typename list_add_cref::type, typename list_add_cref::type > a( a1, a2 ); + rrlist2< A1, A2 > a( a1, a2 ); return l_( type(), f_, a, 0 ); } template result_type operator()( A1 && a1, A2 && a2 ) const { - list2< typename list_add_cref::type, typename list_add_cref::type > a( a1, a2 ); + rrlist2< A1, A2 > a( a1, a2 ); return l_( type(), f_, a, 0 ); } template result_type operator()( A1 && a1, A2 && a2, A3 && a3 ) { - list3< - typename list_add_cref::type, - typename list_add_cref::type, - typename list_add_cref::type - > a( a1, a2, a3 ); - + rrlist3< A1, A2, A3 > a( a1, a2, a3 ); return l_( type(), f_, a, 0 ); } template result_type operator()( A1 && a1, A2 && a2, A3 && a3 ) const { - list3< - typename list_add_cref::type, - typename list_add_cref::type, - typename list_add_cref::type - > a( a1, a2, a3 ); - + rrlist3< A1, A2, A3 > a( a1, a2, a3 ); return l_( type(), f_, a, 0 ); } template result_type operator()( A1 && a1, A2 && a2, A3 && a3, A4 && a4 ) { - list4< - typename list_add_cref::type, - typename list_add_cref::type, - typename list_add_cref::type, - typename list_add_cref::type - > a( a1, a2, a3, a4 ); - + rrlist4< A1, A2, A3, A4 > a( a1, a2, a3, a4 ); return l_( type(), f_, a, 0 ); } template result_type operator()( A1 && a1, A2 && a2, A3 && a3, A4 && a4 ) const { - list4< - typename list_add_cref::type, - typename list_add_cref::type, - typename list_add_cref::type, - typename list_add_cref::type - > a( a1, a2, a3, a4 ); - + rrlist4< A1, A2, A3, A4 > a( a1, a2, a3, a4 ); return l_( type(), f_, a, 0 ); } template result_type operator()( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5 ) { - list5< - typename list_add_cref::type, - typename list_add_cref::type, - typename list_add_cref::type, - typename list_add_cref::type, - typename list_add_cref::type - > a( a1, a2, a3, a4, a5 ); - + rrlist5< A1, A2, A3, A4, A5 > a( a1, a2, a3, a4, a5 ); return l_( type(), f_, a, 0 ); } template result_type operator()( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5 ) const { - list5< - typename list_add_cref::type, - typename list_add_cref::type, - typename list_add_cref::type, - typename list_add_cref::type, - typename list_add_cref::type - > a( a1, a2, a3, a4, a5 ); - + rrlist5< A1, A2, A3, A4, A5 > a( a1, a2, a3, a4, a5 ); return l_( type(), f_, a, 0 ); } template result_type operator()( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6 ) { - list6< - typename list_add_cref::type, - typename list_add_cref::type, - typename list_add_cref::type, - typename list_add_cref::type, - typename list_add_cref::type, - typename list_add_cref::type - > a( a1, a2, a3, a4, a5, a6 ); - + rrlist6< A1, A2, A3, A4, A5, A6 > a( a1, a2, a3, a4, a5, a6 ); return l_( type(), f_, a, 0 ); } template result_type operator()( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6 ) const { - list6< - typename list_add_cref::type, - typename list_add_cref::type, - typename list_add_cref::type, - typename list_add_cref::type, - typename list_add_cref::type, - typename list_add_cref::type - > a( a1, a2, a3, a4, a5, a6 ); - + rrlist6< A1, A2, A3, A4, A5, A6 > a( a1, a2, a3, a4, a5, a6 ); return l_( type(), f_, a, 0 ); } template result_type operator()( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6, A7 && a7 ) { - list7< - typename list_add_cref::type, - typename list_add_cref::type, - typename list_add_cref::type, - typename list_add_cref::type, - typename list_add_cref::type, - typename list_add_cref::type, - typename list_add_cref::type - > a( a1, a2, a3, a4, a5, a6, a7 ); - + rrlist7< A1, A2, A3, A4, A5, A6, A7 > a( a1, a2, a3, a4, a5, a6, a7 ); return l_( type(), f_, a, 0 ); } template result_type operator()( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6, A7 && a7 ) const { - list7< - typename list_add_cref::type, - typename list_add_cref::type, - typename list_add_cref::type, - typename list_add_cref::type, - typename list_add_cref::type, - typename list_add_cref::type, - typename list_add_cref::type - > a( a1, a2, a3, a4, a5, a6, a7 ); - + rrlist7< A1, A2, A3, A4, A5, A6, A7 > a( a1, a2, a3, a4, a5, a6, a7 ); return l_( type(), f_, a, 0 ); } template result_type operator()( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6, A7 && a7, A8 && a8 ) { - list8< - typename list_add_cref::type, - typename list_add_cref::type, - typename list_add_cref::type, - typename list_add_cref::type, - typename list_add_cref::type, - typename list_add_cref::type, - typename list_add_cref::type, - typename list_add_cref::type - > a( a1, a2, a3, a4, a5, a6, a7, a8 ); - + rrlist8< A1, A2, A3, A4, A5, A6, A7, A8 > a( a1, a2, a3, a4, a5, a6, a7, a8 ); return l_( type(), f_, a, 0 ); } template result_type operator()( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6, A7 && a7, A8 && a8 ) const { - list8< - typename list_add_cref::type, - typename list_add_cref::type, - typename list_add_cref::type, - typename list_add_cref::type, - typename list_add_cref::type, - typename list_add_cref::type, - typename list_add_cref::type, - typename list_add_cref::type - > a( a1, a2, a3, a4, a5, a6, a7, a8 ); - + rrlist8< A1, A2, A3, A4, A5, A6, A7, A8 > a( a1, a2, a3, a4, a5, a6, a7, a8 ); return l_( type(), f_, a, 0 ); } template result_type operator()( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6, A7 && a7, A8 && a8, A9 && a9 ) { - list9< - typename list_add_cref::type, - typename list_add_cref::type, - typename list_add_cref::type, - typename list_add_cref::type, - typename list_add_cref::type, - typename list_add_cref::type, - typename list_add_cref::type, - typename list_add_cref::type, - typename list_add_cref::type - > a( a1, a2, a3, a4, a5, a6, a7, a8, a9 ); - + rrlist9< A1, A2, A3, A4, A5, A6, A7, A8, A9 > a( a1, a2, a3, a4, a5, a6, a7, a8, a9 ); return l_( type(), f_, a, 0 ); } template result_type operator()( A1 && a1, A2 && a2, A3 && a3, A4 && a4, A5 && a5, A6 && a6, A7 && a7, A8 && a8, A9 && a9 ) const { - list9< - typename list_add_cref::type, - typename list_add_cref::type, - typename list_add_cref::type, - typename list_add_cref::type, - typename list_add_cref::type, - typename list_add_cref::type, - typename list_add_cref::type, - typename list_add_cref::type, - typename list_add_cref::type - > a( a1, a2, a3, a4, a5, a6, a7, a8, a9 ); - + rrlist9< A1, A2, A3, A4, A5, A6, A7, A8, A9 > a( a1, a2, a3, a4, a5, a6, a7, a8, a9 ); return l_( type(), f_, a, 0 ); } diff --git a/libs/boost/include/boost/bind/bind_mf_cc.hpp b/libs/boost/include/boost/bind/bind_mf_cc.hpp index 9c3d290..e149384 100644 --- a/libs/boost/include/boost/bind/bind_mf_cc.hpp +++ b/libs/boost/include/boost/bind/bind_mf_cc.hpp @@ -36,8 +36,9 @@ template + typename boost::enable_if_c::value, _bi::bind_t, typename _bi::list_av_1::type> - BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (), A1 a1) + >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (), A1 a1) { typedef _mfi::BOOST_BIND_MF_NAME(mf0) F; typedef typename _bi::list_av_1::type list_type; @@ -46,8 +47,9 @@ template + typename boost::enable_if_c::value, _bi::bind_t, typename _bi::list_av_1::type> - BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) () const, A1 a1) + >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) () const, A1 a1) { typedef _mfi::BOOST_BIND_MF_NAME(cmf0) F; typedef typename _bi::list_av_1::type list_type; @@ -81,8 +83,9 @@ template + typename boost::enable_if_c::value, _bi::bind_t, typename _bi::list_av_2::type> - BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1), A1 a1, A2 a2) + >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1), A1 a1, A2 a2) { typedef _mfi::BOOST_BIND_MF_NAME(mf1) F; typedef typename _bi::list_av_2::type list_type; @@ -92,8 +95,9 @@ template + typename boost::enable_if_c::value, _bi::bind_t, typename _bi::list_av_2::type> - BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1) const, A1 a1, A2 a2) + >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1) const, A1 a1, A2 a2) { typedef _mfi::BOOST_BIND_MF_NAME(cmf1) F; typedef typename _bi::list_av_2::type list_type; @@ -127,8 +131,9 @@ template + typename boost::enable_if_c::value, _bi::bind_t, typename _bi::list_av_3::type> - BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2), A1 a1, A2 a2, A3 a3) + >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2), A1 a1, A2 a2, A3 a3) { typedef _mfi::BOOST_BIND_MF_NAME(mf2) F; typedef typename _bi::list_av_3::type list_type; @@ -138,8 +143,9 @@ template + typename boost::enable_if_c::value, _bi::bind_t, typename _bi::list_av_3::type> - BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2) const, A1 a1, A2 a2, A3 a3) + >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2) const, A1 a1, A2 a2, A3 a3) { typedef _mfi::BOOST_BIND_MF_NAME(cmf2) F; typedef typename _bi::list_av_3::type list_type; @@ -173,8 +179,9 @@ template + typename boost::enable_if_c::value, _bi::bind_t, typename _bi::list_av_4::type> - BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3), A1 a1, A2 a2, A3 a3, A4 a4) + >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3), A1 a1, A2 a2, A3 a3, A4 a4) { typedef _mfi::BOOST_BIND_MF_NAME(mf3) F; typedef typename _bi::list_av_4::type list_type; @@ -184,8 +191,9 @@ template + typename boost::enable_if_c::value, _bi::bind_t, typename _bi::list_av_4::type> - BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3) const, A1 a1, A2 a2, A3 a3, A4 a4) + >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3) const, A1 a1, A2 a2, A3 a3, A4 a4) { typedef _mfi::BOOST_BIND_MF_NAME(cmf3) F; typedef typename _bi::list_av_4::type list_type; @@ -219,8 +227,9 @@ template + typename boost::enable_if_c::value, _bi::bind_t, typename _bi::list_av_5::type> - BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) + >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) { typedef _mfi::BOOST_BIND_MF_NAME(mf4) F; typedef typename _bi::list_av_5::type list_type; @@ -230,8 +239,9 @@ template + typename boost::enable_if_c::value, _bi::bind_t, typename _bi::list_av_5::type> - BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) + >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) { typedef _mfi::BOOST_BIND_MF_NAME(cmf4) F; typedef typename _bi::list_av_5::type list_type; @@ -265,8 +275,9 @@ template + typename boost::enable_if_c::value, _bi::bind_t, typename _bi::list_av_6::type> - BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) + >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) { typedef _mfi::BOOST_BIND_MF_NAME(mf5) F; typedef typename _bi::list_av_6::type list_type; @@ -276,8 +287,9 @@ template + typename boost::enable_if_c::value, _bi::bind_t, typename _bi::list_av_6::type> - BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) + >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) { typedef _mfi::BOOST_BIND_MF_NAME(cmf5) F; typedef typename _bi::list_av_6::type list_type; @@ -311,8 +323,9 @@ template + typename boost::enable_if_c::value, _bi::bind_t, typename _bi::list_av_7::type> - BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) + >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) { typedef _mfi::BOOST_BIND_MF_NAME(mf6) F; typedef typename _bi::list_av_7::type list_type; @@ -322,8 +335,9 @@ template + typename boost::enable_if_c::value, _bi::bind_t, typename _bi::list_av_7::type> - BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) + >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) { typedef _mfi::BOOST_BIND_MF_NAME(cmf6) F; typedef typename _bi::list_av_7::type list_type; @@ -357,8 +371,9 @@ template + typename boost::enable_if_c::value, _bi::bind_t, typename _bi::list_av_8::type> - BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) + >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) { typedef _mfi::BOOST_BIND_MF_NAME(mf7) F; typedef typename _bi::list_av_8::type list_type; @@ -368,8 +383,9 @@ template + typename boost::enable_if_c::value, _bi::bind_t, typename _bi::list_av_8::type> - BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) + >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) { typedef _mfi::BOOST_BIND_MF_NAME(cmf7) F; typedef typename _bi::list_av_8::type list_type; @@ -403,8 +419,9 @@ template + typename boost::enable_if_c::value, _bi::bind_t, typename _bi::list_av_9::type> - BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7, B8), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) + >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7, B8), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) { typedef _mfi::BOOST_BIND_MF_NAME(mf8) F; typedef typename _bi::list_av_9::type list_type; @@ -414,8 +431,9 @@ template + typename boost::enable_if_c::value, _bi::bind_t, typename _bi::list_av_9::type> - BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7, B8) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) + >::type BOOST_BIND(R (BOOST_BIND_MF_CC T::*f) (B1, B2, B3, B4, B5, B6, B7, B8) const, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8, A9 a9) { typedef _mfi::BOOST_BIND_MF_NAME(cmf8) F; typedef typename _bi::list_av_9::type list_type; diff --git a/libs/boost/include/boost/bind/placeholders.hpp b/libs/boost/include/boost/bind/placeholders.hpp index 3b098b1..b819ef4 100644 --- a/libs/boost/include/boost/bind/placeholders.hpp +++ b/libs/boost/include/boost/bind/placeholders.hpp @@ -11,10 +11,11 @@ // bind/placeholders.hpp - _N definitions // // Copyright (c) 2002 Peter Dimov and Multi Media Ltd. +// Copyright 2015 Peter Dimov // -// Distributed under the Boost Software License, Version 1.0. (See -// accompanying file LICENSE_1_0.txt or copy at -// http://www.boost.org/LICENSE_1_0.txt) +// Distributed under the Boost Software License, Version 1.0. +// See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt // // See http://www.boost.org/libs/bind/bind.html for documentation. // @@ -22,48 +23,40 @@ #include #include -namespace +namespace boost { -#if defined(__BORLANDC__) || defined(__GNUC__) && (__GNUC__ < 4) - -static inline boost::arg<1> _1() { return boost::arg<1>(); } -static inline boost::arg<2> _2() { return boost::arg<2>(); } -static inline boost::arg<3> _3() { return boost::arg<3>(); } -static inline boost::arg<4> _4() { return boost::arg<4>(); } -static inline boost::arg<5> _5() { return boost::arg<5>(); } -static inline boost::arg<6> _6() { return boost::arg<6>(); } -static inline boost::arg<7> _7() { return boost::arg<7>(); } -static inline boost::arg<8> _8() { return boost::arg<8>(); } -static inline boost::arg<9> _9() { return boost::arg<9>(); } +namespace placeholders +{ -#elif defined(BOOST_MSVC) || (defined(__DECCXX_VER) && __DECCXX_VER <= 60590031) || defined(__MWERKS__) || \ - defined(__GNUC__) && (__GNUC__ == 4 && __GNUC_MINOR__ < 2) +#if defined(__BORLANDC__) || defined(__GNUC__) && (__GNUC__ < 4) -static boost::arg<1> _1; -static boost::arg<2> _2; -static boost::arg<3> _3; -static boost::arg<4> _4; -static boost::arg<5> _5; -static boost::arg<6> _6; -static boost::arg<7> _7; -static boost::arg<8> _8; -static boost::arg<9> _9; +inline boost::arg<1> _1() { return boost::arg<1>(); } +inline boost::arg<2> _2() { return boost::arg<2>(); } +inline boost::arg<3> _3() { return boost::arg<3>(); } +inline boost::arg<4> _4() { return boost::arg<4>(); } +inline boost::arg<5> _5() { return boost::arg<5>(); } +inline boost::arg<6> _6() { return boost::arg<6>(); } +inline boost::arg<7> _7() { return boost::arg<7>(); } +inline boost::arg<8> _8() { return boost::arg<8>(); } +inline boost::arg<9> _9() { return boost::arg<9>(); } #else -boost::arg<1> _1; -boost::arg<2> _2; -boost::arg<3> _3; -boost::arg<4> _4; -boost::arg<5> _5; -boost::arg<6> _6; -boost::arg<7> _7; -boost::arg<8> _8; -boost::arg<9> _9; +BOOST_STATIC_CONSTEXPR boost::arg<1> _1; +BOOST_STATIC_CONSTEXPR boost::arg<2> _2; +BOOST_STATIC_CONSTEXPR boost::arg<3> _3; +BOOST_STATIC_CONSTEXPR boost::arg<4> _4; +BOOST_STATIC_CONSTEXPR boost::arg<5> _5; +BOOST_STATIC_CONSTEXPR boost::arg<6> _6; +BOOST_STATIC_CONSTEXPR boost::arg<7> _7; +BOOST_STATIC_CONSTEXPR boost::arg<8> _8; +BOOST_STATIC_CONSTEXPR boost::arg<9> _9; #endif -} // unnamed namespace +} // namespace placeholders + +} // namespace boost #endif // #ifndef BOOST_BIND_PLACEHOLDERS_HPP_INCLUDED diff --git a/libs/boost/include/boost/cerrno.hpp b/libs/boost/include/boost/cerrno.hpp index 6f26698..57278f5 100644 --- a/libs/boost/include/boost/cerrno.hpp +++ b/libs/boost/include/boost/cerrno.hpp @@ -7,8 +7,8 @@ // See library home page at http://www.boost.org/libs/system -#ifndef BOOST_CERRNO_HPP -#define BOOST_CERRNO_HPP +#ifndef BOOST_SYSTEM_CERRNO_HPP +#define BOOST_SYSTEM_CERRNO_HPP #include diff --git a/libs/boost/include/boost/chrono/ceil.hpp b/libs/boost/include/boost/chrono/ceil.hpp new file mode 100644 index 0000000..7fbf9dd --- /dev/null +++ b/libs/boost/include/boost/chrono/ceil.hpp @@ -0,0 +1,36 @@ +// boost/chrono/round.hpp ------------------------------------------------------------// + +// (C) Copyright Howard Hinnant +// Copyright 2011 Vicente J. Botet Escriba + +// Distributed under the Boost Software License, Version 1.0. (See accompanying +// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org/libs/chrono for documentation. + +#ifndef BOOST_CHRONO_CEIL_HPP +#define BOOST_CHRONO_CEIL_HPP + +#include + +namespace boost +{ + namespace chrono + { + + /** + * rounds up + */ + template + To ceil(const duration& d) + { + To t = duration_cast(d); + if (t < d) + ++t; + return t; + } + + } // namespace chrono +} // namespace boost + +#endif diff --git a/libs/boost/include/boost/chrono/detail/inlined/chrono.hpp b/libs/boost/include/boost/chrono/detail/inlined/chrono.hpp index 0278843..3bad546 100644 --- a/libs/boost/include/boost/chrono/detail/inlined/chrono.hpp +++ b/libs/boost/include/boost/chrono/detail/inlined/chrono.hpp @@ -11,7 +11,9 @@ #include #include +#if defined BOOST_CHRONO_PROVIDE_HYBRID_ERROR_HANDLING #include +#endif #include #include diff --git a/libs/boost/include/boost/chrono/detail/inlined/mac/chrono.hpp b/libs/boost/include/boost/chrono/detail/inlined/mac/chrono.hpp index bf20ae9..0bd3400 100644 --- a/libs/boost/include/boost/chrono/detail/inlined/mac/chrono.hpp +++ b/libs/boost/include/boost/chrono/detail/inlined/mac/chrono.hpp @@ -13,6 +13,7 @@ #include //for gettimeofday and timeval #include // mach_absolute_time, mach_timebase_info_data_t +#include namespace boost { @@ -39,7 +40,7 @@ system_clock::now(system::error_code & ec) { timeval tv; gettimeofday(&tv, 0); - if (!BOOST_CHRONO_IS_THROWS(ec)) + if (!BOOST_CHRONO_IS_THROWS(ec)) { ec.clear(); } @@ -88,7 +89,7 @@ BOOST_CHRONO_STATIC steady_clock::rep steady_simplified_ec(system::error_code & ec) { - if (!BOOST_CHRONO_IS_THROWS(ec)) + if (!BOOST_CHRONO_IS_THROWS(ec)) { ec.clear(); } @@ -112,9 +113,9 @@ BOOST_CHRONO_STATIC steady_clock::rep steady_full() { - static kern_return_t err; - static const double factor = chrono_detail::compute_steady_factor(err); - if (err != 0) + kern_return_t err; + const double factor = chrono_detail::compute_steady_factor(err); + if (err != 0) { BOOST_ASSERT(0 && "Boost::Chrono - Internal Error"); } @@ -126,25 +127,25 @@ BOOST_CHRONO_STATIC steady_clock::rep steady_full_ec(system::error_code & ec) { - static kern_return_t err; - static const double factor = chrono_detail::compute_steady_factor(err); - if (err != 0) + kern_return_t err; + const double factor = chrono_detail::compute_steady_factor(err); + if (err != 0) { if (BOOST_CHRONO_IS_THROWS(ec)) { boost::throw_exception( - system::system_error( - err, - BOOST_CHRONO_SYSTEM_CATEGORY, + system::system_error( + err, + BOOST_CHRONO_SYSTEM_CATEGORY, "chrono::steady_clock" )); - } + } else { ec.assign( errno, BOOST_CHRONO_SYSTEM_CATEGORY ); return steady_clock::rep(); } } - if (!BOOST_CHRONO_IS_THROWS(ec)) + if (!BOOST_CHRONO_IS_THROWS(ec)) { ec.clear(); } @@ -163,7 +164,7 @@ init_steady_clock(kern_return_t & err) { mach_timebase_info_data_t MachInfo; err = mach_timebase_info(&MachInfo); - if ( err != 0 ) + if ( err != 0 ) { return 0; } @@ -182,12 +183,12 @@ init_steady_clock_ec(kern_return_t & err) { mach_timebase_info_data_t MachInfo; err = mach_timebase_info(&MachInfo); - if ( err != 0 ) + if ( err != 0 ) { return 0; } - if (MachInfo.numer == MachInfo.denom) + if (MachInfo.numer == MachInfo.denom) { return &chrono_detail::steady_simplified_ec; } @@ -199,10 +200,10 @@ init_steady_clock_ec(kern_return_t & err) steady_clock::time_point steady_clock::now() BOOST_NOEXCEPT { - static kern_return_t err; - static chrono_detail::FP fp = chrono_detail::init_steady_clock(err); - if ( err != 0 ) - { + kern_return_t err; + chrono_detail::FP fp = chrono_detail::init_steady_clock(err); + if ( err != 0 ) + { BOOST_ASSERT(0 && "Boost::Chrono - Internal Error"); } return time_point(duration(fp())); @@ -212,16 +213,16 @@ steady_clock::now() BOOST_NOEXCEPT steady_clock::time_point steady_clock::now(system::error_code & ec) { - static kern_return_t err; - static chrono_detail::FP_ec fp = chrono_detail::init_steady_clock_ec(err); - if ( err != 0 ) + kern_return_t err; + chrono_detail::FP_ec fp = chrono_detail::init_steady_clock_ec(err); + if ( err != 0 ) { if (BOOST_CHRONO_IS_THROWS(ec)) { boost::throw_exception( - system::system_error( - err, - BOOST_CHRONO_SYSTEM_CATEGORY, + system::system_error( + err, + BOOST_CHRONO_SYSTEM_CATEGORY, "chrono::steady_clock" )); } else @@ -230,7 +231,7 @@ steady_clock::now(system::error_code & ec) return time_point(); } } - if (!BOOST_CHRONO_IS_THROWS(ec)) + if (!BOOST_CHRONO_IS_THROWS(ec)) { ec.clear(); } diff --git a/libs/boost/include/boost/chrono/detail/inlined/mac/process_cpu_clocks.hpp b/libs/boost/include/boost/chrono/detail/inlined/mac/process_cpu_clocks.hpp index 6d09e2c..6e55b0f 100644 --- a/libs/boost/include/boost/chrono/detail/inlined/mac/process_cpu_clocks.hpp +++ b/libs/boost/include/boost/chrono/detail/inlined/mac/process_cpu_clocks.hpp @@ -28,7 +28,7 @@ namespace boost inline long tick_factor() // multiplier to convert ticks // to nanoseconds; -1 if unknown { - static long factor = 0; + long factor = 0; if (!factor) { if ((factor = ::sysconf(_SC_CLK_TCK)) <= 0) diff --git a/libs/boost/include/boost/chrono/detail/inlined/mac/thread_clock.hpp b/libs/boost/include/boost/chrono/detail/inlined/mac/thread_clock.hpp index 1a4406b..690458f 100644 --- a/libs/boost/include/boost/chrono/detail/inlined/mac/thread_clock.hpp +++ b/libs/boost/include/boost/chrono/detail/inlined/mac/thread_clock.hpp @@ -14,6 +14,7 @@ #include #include #include +#include # include # include diff --git a/libs/boost/include/boost/chrono/detail/inlined/posix/chrono.hpp b/libs/boost/include/boost/chrono/detail/inlined/posix/chrono.hpp index e35a7ce..c4c8a6a 100644 --- a/libs/boost/include/boost/chrono/detail/inlined/posix/chrono.hpp +++ b/libs/boost/include/boost/chrono/detail/inlined/posix/chrono.hpp @@ -11,6 +11,7 @@ //----------------------------------------------------------------------------// #include // for clock_gettime +#include namespace boost { @@ -38,9 +39,9 @@ namespace chrono if (BOOST_CHRONO_IS_THROWS(ec)) { boost::throw_exception( - system::system_error( - errno, - BOOST_CHRONO_SYSTEM_CATEGORY, + system::system_error( + errno, + BOOST_CHRONO_SYSTEM_CATEGORY, "chrono::system_clock" )); } else @@ -50,7 +51,7 @@ namespace chrono } } - if (!BOOST_CHRONO_IS_THROWS(ec)) + if (!BOOST_CHRONO_IS_THROWS(ec)) { ec.clear(); } @@ -92,9 +93,9 @@ namespace chrono if (BOOST_CHRONO_IS_THROWS(ec)) { boost::throw_exception( - system::system_error( - errno, - BOOST_CHRONO_SYSTEM_CATEGORY, + system::system_error( + errno, + BOOST_CHRONO_SYSTEM_CATEGORY, "chrono::steady_clock" )); } else @@ -104,7 +105,7 @@ namespace chrono } } - if (!BOOST_CHRONO_IS_THROWS(ec)) + if (!BOOST_CHRONO_IS_THROWS(ec)) { ec.clear(); } diff --git a/libs/boost/include/boost/chrono/detail/inlined/posix/process_cpu_clocks.hpp b/libs/boost/include/boost/chrono/detail/inlined/posix/process_cpu_clocks.hpp index 0476f59..feecc86 100644 --- a/libs/boost/include/boost/chrono/detail/inlined/posix/process_cpu_clocks.hpp +++ b/libs/boost/include/boost/chrono/detail/inlined/posix/process_cpu_clocks.hpp @@ -25,7 +25,7 @@ namespace chrono_detail inline nanoseconds::rep tick_factor() // multiplier to convert ticks // to nanoseconds; -1 if unknown { - static long factor = 0; + long factor = 0; if ( !factor ) { if ( (factor = ::sysconf( _SC_CLK_TCK )) <= 0 ) diff --git a/libs/boost/include/boost/chrono/detail/inlined/posix/thread_clock.hpp b/libs/boost/include/boost/chrono/detail/inlined/posix/thread_clock.hpp index a101224..a42b3c8 100644 --- a/libs/boost/include/boost/chrono/detail/inlined/posix/thread_clock.hpp +++ b/libs/boost/include/boost/chrono/detail/inlined/posix/thread_clock.hpp @@ -13,6 +13,7 @@ #include #include #include +#include #if !defined(__VXWORKS__) # include diff --git a/libs/boost/include/boost/chrono/detail/inlined/process_cpu_clocks.hpp b/libs/boost/include/boost/chrono/detail/inlined/process_cpu_clocks.hpp index d37f675..fad6036 100644 --- a/libs/boost/include/boost/chrono/detail/inlined/process_cpu_clocks.hpp +++ b/libs/boost/include/boost/chrono/detail/inlined/process_cpu_clocks.hpp @@ -18,8 +18,9 @@ #include #include #include +#if defined BOOST_CHRONO_PROVIDE_HYBRID_ERROR_HANDLING #include - +#endif //----------------------------------------------------------------------------// // Windows // //----------------------------------------------------------------------------// diff --git a/libs/boost/include/boost/chrono/detail/inlined/thread_clock.hpp b/libs/boost/include/boost/chrono/detail/inlined/thread_clock.hpp index 16d19ef..e4f8317 100644 --- a/libs/boost/include/boost/chrono/detail/inlined/thread_clock.hpp +++ b/libs/boost/include/boost/chrono/detail/inlined/thread_clock.hpp @@ -16,7 +16,9 @@ #if defined(BOOST_CHRONO_HAS_THREAD_CLOCK) #include #include +#if defined BOOST_CHRONO_PROVIDE_HYBRID_ERROR_HANDLING #include +#endif #include #include diff --git a/libs/boost/include/boost/chrono/detail/inlined/win/chrono.hpp b/libs/boost/include/boost/chrono/detail/inlined/win/chrono.hpp index 16e8c51..e61f11e 100644 --- a/libs/boost/include/boost/chrono/detail/inlined/win/chrono.hpp +++ b/libs/boost/include/boost/chrono/detail/inlined/win/chrono.hpp @@ -14,7 +14,8 @@ #include #include -#include +#include +#include namespace boost { diff --git a/libs/boost/include/boost/chrono/detail/inlined/win/process_cpu_clocks.hpp b/libs/boost/include/boost/chrono/detail/inlined/win/process_cpu_clocks.hpp index e97bfe5..7169f80 100644 --- a/libs/boost/include/boost/chrono/detail/inlined/win/process_cpu_clocks.hpp +++ b/libs/boost/include/boost/chrono/detail/inlined/win/process_cpu_clocks.hpp @@ -14,15 +14,15 @@ #define BOOST_CHRONO_DETAIL_INLINED_WIN_PROCESS_CLOCK_HPP #include -//#include #include #include #include +#include -#include -#include +#include +#include #if BOOST_PLAT_WINDOWS_DESKTOP -#include +#include #endif namespace boost diff --git a/libs/boost/include/boost/chrono/detail/inlined/win/thread_clock.hpp b/libs/boost/include/boost/chrono/detail/inlined/win/thread_clock.hpp index e47c481..037ccbe 100644 --- a/libs/boost/include/boost/chrono/detail/inlined/win/thread_clock.hpp +++ b/libs/boost/include/boost/chrono/detail/inlined/win/thread_clock.hpp @@ -14,10 +14,11 @@ #include #include #include +#include -#include -#include -#include +#include +#include +#include namespace boost { @@ -42,7 +43,7 @@ thread_clock::time_point thread_clock::now( system::error_code & ec ) ((static_cast(system_time.dwHighDateTime) << 32) | system_time.dwLowDateTime) * 100 ); - if (!BOOST_CHRONO_IS_THROWS(ec)) + if (!BOOST_CHRONO_IS_THROWS(ec)) { ec.clear(); } @@ -51,15 +52,15 @@ thread_clock::time_point thread_clock::now( system::error_code & ec ) } else { - if (BOOST_CHRONO_IS_THROWS(ec)) + if (BOOST_CHRONO_IS_THROWS(ec)) { boost::throw_exception( - system::system_error( - boost::detail::winapi::GetLastError(), - BOOST_CHRONO_SYSTEM_CATEGORY, + system::system_error( + boost::detail::winapi::GetLastError(), + BOOST_CHRONO_SYSTEM_CATEGORY, "chrono::thread_clock" )); - } - else + } + else { ec.assign( boost::detail::winapi::GetLastError(), BOOST_CHRONO_SYSTEM_CATEGORY ); return thread_clock::time_point(duration(0)); @@ -74,7 +75,7 @@ thread_clock::time_point thread_clock::now() BOOST_NOEXCEPT // note that Windows uses 100 nanosecond ticks for FILETIME boost::detail::winapi::FILETIME_ creation, exit, user_time, system_time; - if ( boost::detail::winapi::GetThreadTimes( + if ( boost::detail::winapi::GetThreadTimes( boost::detail::winapi::GetCurrentThread (), &creation, &exit, &system_time, &user_time ) ) { diff --git a/libs/boost/include/boost/chrono/duration.hpp b/libs/boost/include/boost/chrono/duration.hpp index a2110bf..0a09674 100644 --- a/libs/boost/include/boost/chrono/duration.hpp +++ b/libs/boost/include/boost/chrono/duration.hpp @@ -433,11 +433,13 @@ namespace chrono { rep rep_; public: -#if defined BOOST_NO_CXX11_DEFAULTED_FUNCTIONS +#if defined BOOST_CHRONO_DURATION_DEFAULTS_TO_ZERO BOOST_FORCEINLINE BOOST_CONSTEXPR duration() : rep_(duration_values::zero()) { } +#elif defined BOOST_NO_CXX11_DEFAULTED_FUNCTIONS + BOOST_CONSTEXPR duration() {} #else - BOOST_CONSTEXPR duration() BOOST_NOEXCEPT {}; + BOOST_CONSTEXPR duration() = default; #endif template BOOST_SYMBOL_VISIBLE BOOST_FORCEINLINE BOOST_CONSTEXPR @@ -541,8 +543,8 @@ namespace chrono { const duration& rhs) { typedef typename common_type, - duration >::type CD; - return CD(CD(lhs).count()+CD(rhs).count()); + duration >::type common_duration; + return common_duration(common_duration(lhs).count()+common_duration(rhs).count()); } // Duration - @@ -554,8 +556,8 @@ namespace chrono { const duration& rhs) { typedef typename common_type, - duration >::type CD; - return CD(CD(lhs).count()-CD(rhs).count()); + duration >::type common_duration; + return common_duration(common_duration(lhs).count()-common_duration(rhs).count()); } // Duration * @@ -571,9 +573,9 @@ namespace chrono { >::type operator*(const duration& d, const Rep2& s) { - typedef typename common_type::type CR; - typedef duration CD; - return CD(CD(d).count()*static_cast(s)); + typedef typename common_type::type common_rep; + typedef duration common_duration; + return common_duration(common_duration(d).count()*static_cast(s)); } template @@ -600,10 +602,9 @@ namespace chrono { >::type operator/(const duration& d, const Rep2& s) { - typedef typename common_type::type CR; - typedef duration CD; - - return CD(CD(d).count()/static_cast(s)); + typedef typename common_type::type common_rep; + typedef duration common_duration; + return common_duration(common_duration(d).count()/static_cast(s)); } template @@ -612,8 +613,8 @@ namespace chrono { operator/(const duration& lhs, const duration& rhs) { typedef typename common_type, - duration >::type CD; - return CD(lhs).count() / CD(rhs).count(); + duration >::type common_duration; + return common_duration(lhs).count() / common_duration(rhs).count(); } #ifdef BOOST_CHRONO_EXTENSIONS @@ -625,10 +626,9 @@ namespace chrono { >::type operator/(const Rep1& s, const duration& d) { - typedef typename common_type::type CR; - typedef duration CD; - - return static_cast(s)/CD(d).count(); + typedef typename common_type::type common_rep; + typedef duration common_duration; + return static_cast(s)/common_duration(d).count(); } #endif // Duration % @@ -641,10 +641,9 @@ namespace chrono { >::type operator%(const duration& d, const Rep2& s) { - typedef typename common_type::type CR; - typedef duration CD; - - return CD(CD(d).count()%static_cast(s)); + typedef typename common_type::type common_rep; + typedef duration common_duration; + return common_duration(common_duration(d).count()%static_cast(s)); } template @@ -653,9 +652,9 @@ namespace chrono { operator%(const duration& lhs, const duration& rhs) { typedef typename common_type, - duration >::type CD; + duration >::type common_duration; - return CD(CD(lhs).count()%CD(rhs).count()); + return common_duration(common_duration(lhs).count()%common_duration(rhs).count()); } @@ -670,8 +669,8 @@ namespace detail { BOOST_CONSTEXPR bool operator()(const LhsDuration& lhs, const RhsDuration& rhs) const { - typedef typename common_type::type CD; - return CD(lhs).count() == CD(rhs).count(); + typedef typename common_type::type common_duration; + return common_duration(lhs).count() == common_duration(rhs).count(); } }; @@ -689,8 +688,8 @@ namespace detail { BOOST_CONSTEXPR bool operator()(const LhsDuration& lhs, const RhsDuration& rhs) const { - typedef typename common_type::type CD; - return CD(lhs).count() < CD(rhs).count(); + typedef typename common_type::type common_duration; + return common_duration(lhs).count() < common_duration(rhs).count(); } }; diff --git a/libs/boost/include/boost/chrono/process_cpu_clocks.hpp b/libs/boost/include/boost/chrono/process_cpu_clocks.hpp index 2488375..93d3c94 100644 --- a/libs/boost/include/boost/chrono/process_cpu_clocks.hpp +++ b/libs/boost/include/boost/chrono/process_cpu_clocks.hpp @@ -20,7 +20,7 @@ #include #include #include -#include +#include #include #include @@ -193,7 +193,7 @@ namespace boost { namespace chrono { typedef std::istreambuf_iterator in_iterator; in_iterator i(is); in_iterator e; - if (i == e || *i != '{') // mandatory '{' + if (i == e || *i++ != '{') // mandatory '{' { is.setstate(is.failbit | is.eofbit); return; @@ -244,7 +244,8 @@ namespace chrono const duration, Period2>& rhs) { return boost::chrono::detail::duration_eq< - duration, Period1>, duration, Period2> >()(lhs, rhs); + duration, duration + >()(duration(lhs.count().real), duration(rhs.count().real)); } template @@ -285,7 +286,8 @@ namespace chrono operator< (const duration& lhs, const duration, Period2>& rhs) { - return rhs < lhs; + return boost::chrono::detail::duration_lt< + duration, duration >()(lhs, duration(rhs.count().real)); } template @@ -295,7 +297,8 @@ namespace chrono const duration, Period2>& rhs) { return boost::chrono::detail::duration_lt< - duration, duration >()(lhs, rhs); + duration, duration + >()(duration(lhs.count().real), duration(rhs.count().real)); } @@ -412,7 +415,7 @@ namespace chrono { static const CharT u[] = - { 'p', 'r', 'o', 'c', 'e', 's', 's', '_', 's', 'y', 's', 't', 't', 'e', 'm', '_', 'c', 'l', 'o', 'c', 'k' }; + { 'p', 'r', 'o', 'c', 'e', 's', 's', '_', 's', 'y', 's', 't', 'e', 'm', '_', 'c', 'l', 'o', 'c', 'k' }; static const std::basic_string str(u, u + sizeof(u) / sizeof(u[0])); return str; @@ -473,7 +476,7 @@ namespace std { (std::numeric_limits::max)(), (std::numeric_limits::max)()); } - static Res lowest() throw() + static Res lowest() BOOST_NOEXCEPT_OR_NOTHROW { return (min)(); } diff --git a/libs/boost/include/boost/chrono/time_point.hpp b/libs/boost/include/boost/chrono/time_point.hpp index 6449fac..fc23095 100644 --- a/libs/boost/include/boost/chrono/time_point.hpp +++ b/libs/boost/include/boost/chrono/time_point.hpp @@ -31,7 +31,6 @@ time2_demo contained this comment: #define BOOST_CHRONO_TIME_POINT_HPP #include -#include #ifndef BOOST_CHRONO_HEADER_ONLY // this must occur after all of the includes and before any code appears: diff --git a/libs/boost/include/boost/concept/detail/general.hpp b/libs/boost/include/boost/concept/detail/general.hpp index c88a1ed..525ea65 100644 --- a/libs/boost/include/boost/concept/detail/general.hpp +++ b/libs/boost/include/boost/concept/detail/general.hpp @@ -4,6 +4,7 @@ #ifndef BOOST_CONCEPT_DETAIL_GENERAL_DWA2006429_HPP # define BOOST_CONCEPT_DETAIL_GENERAL_DWA2006429_HPP +# include # include # include @@ -65,19 +66,11 @@ struct requirement_ # endif -// Version check from https://svn.boost.org/trac/boost/changeset/82886 -// (boost/static_assert.hpp) -#if defined(__GNUC__) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7))) -#define BOOST_CONCEPT_UNUSED_TYPEDEF __attribute__((unused)) -#else -#define BOOST_CONCEPT_UNUSED_TYPEDEF /**/ -#endif - # define BOOST_CONCEPT_ASSERT_FN( ModelFnPtr ) \ typedef ::boost::concepts::detail::instantiate< \ &::boost::concepts::requirement_::failed> \ BOOST_PP_CAT(boost_concept_check,__LINE__) \ - BOOST_CONCEPT_UNUSED_TYPEDEF + BOOST_ATTRIBUTE_UNUSED }} diff --git a/libs/boost/include/boost/concept_check.hpp b/libs/boost/include/boost/concept_check.hpp index 2d6fa32..25f118b 100644 --- a/libs/boost/include/boost/concept_check.hpp +++ b/libs/boost/include/boost/concept_check.hpp @@ -19,7 +19,7 @@ # include -# include +# include # include # include # include @@ -27,7 +27,6 @@ # include # include # include -# include # include # include @@ -504,11 +503,11 @@ namespace boost : Assignable , EqualityComparable { - typedef typename boost::detail::iterator_traits::value_type value_type; - typedef typename boost::detail::iterator_traits::difference_type difference_type; - typedef typename boost::detail::iterator_traits::reference reference; - typedef typename boost::detail::iterator_traits::pointer pointer; - typedef typename boost::detail::iterator_traits::iterator_category iterator_category; + typedef typename std::iterator_traits::value_type value_type; + typedef typename std::iterator_traits::difference_type difference_type; + typedef typename std::iterator_traits::reference reference; + typedef typename std::iterator_traits::pointer pointer; + typedef typename std::iterator_traits::iterator_category iterator_category; BOOST_CONCEPT_USAGE(InputIterator) { @@ -617,7 +616,7 @@ namespace boost private: TT a, b; TT i, j; - typename boost::detail::iterator_traits::difference_type n; + typename std::iterator_traits::difference_type n; }; BOOST_concept(Mutable_RandomAccessIterator,(TT)) @@ -630,7 +629,7 @@ namespace boost } private: TT i; - typename boost::detail::iterator_traits::difference_type n; + typename std::iterator_traits::difference_type n; }; //=========================================================================== diff --git a/libs/boost/include/boost/config/auto_link.hpp b/libs/boost/include/boost/config/auto_link.hpp index 56a16b0..c71e803 100644 --- a/libs/boost/include/boost/config/auto_link.hpp +++ b/libs/boost/include/boost/config/auto_link.hpp @@ -161,10 +161,15 @@ BOOST_LIB_VERSION: The Boost version, in the form x_y, for Boost version x.y. // vc12: # define BOOST_LIB_TOOLSET "vc120" -# elif defined(BOOST_MSVC) +# elif defined(BOOST_MSVC) && (BOOST_MSVC < 1910) - // vc14: -# define BOOST_LIB_TOOLSET "vc140" + // vc14: +# define BOOST_LIB_TOOLSET "vc140" + +# elif defined(BOOST_MSVC) + + // vc14.1: +# define BOOST_LIB_TOOLSET "vc141" # elif defined(__BORLANDC__) diff --git a/libs/boost/include/boost/config/compiler/borland.hpp b/libs/boost/include/boost/config/compiler/borland.hpp index 80dd230..fa891de 100644 --- a/libs/boost/include/boost/config/compiler/borland.hpp +++ b/libs/boost/include/boost/config/compiler/borland.hpp @@ -185,6 +185,7 @@ #define BOOST_NO_CXX11_RVALUE_REFERENCES #define BOOST_NO_CXX11_SCOPED_ENUMS #define BOOST_NO_SFINAE_EXPR +#define BOOST_NO_CXX11_SFINAE_EXPR #define BOOST_NO_CXX11_TEMPLATE_ALIASES #define BOOST_NO_CXX11_UNICODE_LITERALS // UTF-8 still not supported #define BOOST_NO_CXX11_VARIADIC_TEMPLATES @@ -196,6 +197,7 @@ #define BOOST_NO_CXX11_INLINE_NAMESPACES #define BOOST_NO_CXX11_REF_QUALIFIERS #define BOOST_NO_CXX11_FINAL +#define BOOST_NO_CXX11_THREAD_LOCAL // C++ 14: #if !defined(__cpp_aggregate_nsdmi) || (__cpp_aggregate_nsdmi < 201304) @@ -226,6 +228,17 @@ # define BOOST_NO_CXX14_VARIABLE_TEMPLATES #endif +// C++17 +#if !defined(__cpp_structured_bindings) || (__cpp_structured_bindings < 201606) +# define BOOST_NO_CXX17_STRUCTURED_BINDINGS +#endif +#if !defined(__cpp_inline_variables) || (__cpp_inline_variables < 201606) +# define BOOST_NO_CXX17_INLINE_VARIABLES +#endif +#if !defined(__cpp_fold_expressions) || (__cpp_fold_expressions < 201603) +# define BOOST_NO_CXX17_FOLD_EXPRESSIONS +#endif + #if __BORLANDC__ >= 0x590 # define BOOST_HAS_TR1_HASH